sk_app::Window_unix Class Reference

#include <Window_unix.h>

Inheritance diagram for sk_app::Window_unix:

Public Member Functions
	Window_unix ()
	~Window_unix () override
bool	initWindow (Display *display)
void	setTitle (const char *) override
void	show () override
const char *	getClipboardText () override
void	setClipboardText (const char *) override
bool	attach (BackendType) override
void	onInval () override
bool	handleEvent (const XEvent &event)
void	markPendingPaint ()
void	finishPaint ()
void	markPendingResize (int width, int height)
void	finishResize ()
void	setRequestedDisplayParams (const DisplayParams &, bool allowReattach) override
Public Member Functions inherited from sk_app::Window
virtual	~Window ()
virtual void	setUIState (const char *)
void	inval ()
virtual bool	scaleContentToFit () const
void	detach ()
void	pushLayer (Layer *layer)
void	onBackendCreated ()
bool	onChar (SkUnichar c, skui::ModifierKey modifiers)
bool	onKey (skui::Key key, skui::InputState state, skui::ModifierKey modifiers)
bool	onMouse (int x, int y, skui::InputState state, skui::ModifierKey modifiers)
bool	onMouseWheel (float delta, int x, int y, skui::ModifierKey modifiers)
bool	onTouch (intptr_t owner, skui::InputState state, float x, float y)
bool	onFling (skui::InputState state)
bool	onPinch (skui::InputState state, float scale, float x, float y)
void	onUIStateChanged (const SkString &stateName, const SkString &stateValue)
void	onPaint ()
void	onResize (int width, int height)
void	onActivate (bool isActive)
int	width () const
int	height () const
virtual float	scaleFactor () const
virtual const DisplayParams &	getRequestedDisplayParams ()
int	sampleCount () const
int	stencilBits () const
GrDirectContext *	directContext () const
skgpu::graphite::Context *	graphiteContext () const
skgpu::graphite::Recorder *	graphiteRecorder () const

Static Public Member Functions
static const XWindow &	GetKey (const Window_unix &w)
static uint32_t	Hash (const XWindow &w)
Static Public Member Functions inherited from sk_app::Window
static Window *	CreateNativeWindow (void *platformData)

Static Public Attributes
static SkTDynamicHash< Window_unix, XWindow >	gWindowMap

Additional Inherited Members
Public Types inherited from sk_app::Window
enum	BackendType { kRaster_BackendType , kLast_BackendType = kRaster_BackendType }
enum	{ kBackendTypeCount = kLast_BackendType + 1 }
Protected Member Functions inherited from sk_app::Window
	Window ()
void	markInvalProcessed ()
void	visitLayers (const std::function< void(Layer *)> &visitor)
bool	signalLayers (const std::function< bool(Layer *)> &visitor)
Protected Attributes inherited from sk_app::Window
SkTDArray< Layer * >	fLayers
DisplayParams	fRequestedDisplayParams
bool	fIsActive = true
std::unique_ptr< skwindow::WindowContext >	fWindowContext
bool	fIsContentInvalidated = false

Detailed Description

Definition at line 24 of file Window_unix.h.

Constructor & Destructor Documentation

Window_unix()

sk_app::Window_unix::Window_unix ( )

inline

Definition at line 26 of file Window_unix.h.

            : Window()
            , fDisplay(nullptr)
            , fWindow(0)
            , fGC(nullptr)
            , fFBConfig(nullptr)
            , fVisualInfo(nullptr)
            , fMSAASampleCount(1) {}

~Window_unix()

sk_app::Window_unix::~Window_unix ( )

inlineoverride

Definition at line 34 of file Window_unix.h.

{ this->closeWindow(); }

Member Function Documentation

attach()

bool sk_app::Window_unix::attach ( BackendType  attachType )

overridevirtual

Implements sk_app::Window.

Definition at line 378 of file Window_unix.cpp.

                                               {
    fBackend = attachType;
 
    this->initWindow(fDisplay);
 
    skwindow::XlibWindowInfo winInfo;
    winInfo.fDisplay = fDisplay;
    winInfo.fWindow = fWindow;
    winInfo.fFBConfig = fFBConfig;
    winInfo.fVisualInfo = fVisualInfo;
 
    XWindowAttributes attrs;
    if (XGetWindowAttributes(fDisplay, fWindow, &attrs)) {
        winInfo.fWidth = attrs.width;
        winInfo.fHeight = attrs.height;
    } else {
        winInfo.fWidth = winInfo.fHeight = 0;
    }
 
    switch (attachType) {
#if defined(SK_DAWN) && defined(SK_GRAPHITE)
        case kGraphiteDawn_BackendType:
            fWindowContext = skwindow::MakeGraphiteDawnVulkanForXlib(winInfo,
                                                                     fRequestedDisplayParams);
            break;
#endif
#ifdef SK_VULKAN
        case kVulkan_BackendType:
            fWindowContext = skwindow::MakeVulkanForXlib(winInfo, fRequestedDisplayParams);
            break;
#endif
#if defined(SK_VULKAN) && defined(SK_GRAPHITE)
        case kGraphiteVulkan_BackendType:
            fWindowContext = skwindow::MakeGraphiteVulkanForXlib(winInfo, fRequestedDisplayParams);
            break;
#endif
#ifdef SK_GL
        case kNativeGL_BackendType:
            fWindowContext = skwindow::MakeGLForXlib(winInfo, fRequestedDisplayParams);
            break;
#endif
        case kRaster_BackendType:
            fWindowContext = skwindow::MakeRasterForXlib(winInfo, fRequestedDisplayParams);
            break;
    }
    this->onBackendCreated();
 
    return (SkToBool(fWindowContext));
}

finishPaint()

void sk_app::Window_unix::finishPaint ( )

inline

Definition at line 61 of file Window_unix.h.

                       {
        if (fPendingPaint) {
            this->onPaint();
            fPendingPaint = false;
        }
    }

finishResize()

void sk_app::Window_unix::finishResize ( )

inline

Definition at line 75 of file Window_unix.h.

                        {
        if (fPendingResize) {
            this->onResize(fPendingWidth, fPendingHeight);
            fPendingResize = false;
        }
    }

getClipboardText()

const char * sk_app::Window_unix::getClipboardText ( )

overridevirtual

Reimplemented from sk_app::Window.

Definition at line 460 of file Window_unix.cpp.

                                          {
    Atom UTF8      = XInternAtom(fDisplay, "UTF8_STRING", 0),
         CLIPBOARD = XInternAtom(fDisplay, "CLIPBOARD", 0),
         XSEL_DATA = XInternAtom(fDisplay, "XSEL_DATA", 0);
 
    // Ask for a UTF8 copy of the CLIPBOARD...
    XEvent event;
    XConvertSelection(fDisplay, CLIPBOARD, UTF8, XSEL_DATA, fWindow, CurrentTime);
    XSync(fDisplay, 0);
    XNextEvent(fDisplay, &event);
    if (event.type == SelectionNotify &&
            event.xselection.selection == CLIPBOARD &&
            event.xselection.property != None) {
 
        // We got a response
        Atom type;
        int format;
        unsigned long nitems, bytes_after;
        char* data;
 
        // Fetch the CLIPBOARD property
        XSelectionEvent xsel = event.xselection;
        XGetWindowProperty(xsel.display, xsel.requestor, xsel.property, /*offset=*/0,
                           /*length=*/~0L, /*delete=*/False, AnyPropertyType, &type, &format,
                           &nitems, &bytes_after, (unsigned char**)&data);
        SkASSERT(bytes_after == 0);
        if (type == UTF8) {
            fClipboardText.assign(data, nitems);
        }
        XFree(data);
        XDeleteProperty(xsel.display, xsel.requestor, xsel.property);
    }
    return fClipboardText.c_str();
}

GetKey()

static const XWindow & sk_app::Window_unix::GetKey ( const Window_unix &  w )

inlinestatic

Definition at line 50 of file Window_unix.h.

                                                       {
        return w.fWindow;
    }

handleEvent()

bool sk_app::Window_unix::handleEvent

(

const XEvent &

event

)

Definition at line 249 of file Window_unix.cpp.

                                                 {
    switch (event.type) {
        case MapNotify:
            if (!fGC) {
                fGC = XCreateGC(fDisplay, fWindow, 0, nullptr);
            }
            break;
 
        case ClientMessage:
            if ((Atom)event.xclient.data.l[0] == fWmDeleteMessage &&
                gWindowMap.count() == 1) {
                return true;
            }
            break;
 
        case ButtonPress:
            switch (event.xbutton.button) {
                case Button1:
                    this->onMouse(event.xbutton.x, event.xbutton.y,
                                  skui::InputState::kDown, get_modifiers(event));
                    break;
                case Button4:
                    this->onMouseWheel(1.0f, 0, 0, get_modifiers(event));
                    break;
                case Button5:
                    this->onMouseWheel(-1.0f, 0, 0, get_modifiers(event));
                    break;
            }
            break;
 
        case ButtonRelease:
            if (event.xbutton.button == Button1) {
                this->onMouse(event.xbutton.x, event.xbutton.y,
                              skui::InputState::kUp, get_modifiers(event));
            }
            break;
 
        case MotionNotify:
            this->onMouse(event.xmotion.x, event.xmotion.y,
                          skui::InputState::kMove, get_modifiers(event));
            break;
 
        case KeyPress: {
            int shiftLevel = (event.xkey.state & ShiftMask) ? 1 : 0;
            KeySym keysym = XkbKeycodeToKeysym(fDisplay, event.xkey.keycode, 0, shiftLevel);
            skui::Key key = get_key(keysym);
            if (key != skui::Key::kNONE) {
                if (!this->onKey(key, skui::InputState::kDown, get_modifiers(event))) {
                    if (keysym == XK_Escape) {
                        return true;
                    }
                }
            }
 
            long uni = keysym2ucs(keysym);
            if (uni != -1) {
                (void) this->onChar((SkUnichar) uni, get_modifiers(event));
            }
        } break;
 
        case KeyRelease: {
            int shiftLevel = (event.xkey.state & ShiftMask) ? 1 : 0;
            KeySym keysym = XkbKeycodeToKeysym(fDisplay, event.xkey.keycode,
                                               0, shiftLevel);
            skui::Key key = get_key(keysym);
            (void) this->onKey(key, skui::InputState::kUp,
                               get_modifiers(event));
        } break;
 
        case SelectionClear: {
            // Lost selection ownership
            fClipboardText.clear();
        } break;
 
        case SelectionRequest: {
            Atom UTF8      = XInternAtom(fDisplay, "UTF8_STRING", 0),
                 CLIPBOARD = XInternAtom(fDisplay, "CLIPBOARD", 0);
 
            const XSelectionRequestEvent* xsr = &event.xselectionrequest;
 
            XSelectionEvent xsel = {};
            xsel.type      = SelectionNotify;
            xsel.requestor = xsr->requestor;
            xsel.selection = xsr->selection;
            xsel.target    = xsr->target;
            xsel.property  = xsr->property;
            xsel.time      = xsr->time;
 
            if (xsr->selection != CLIPBOARD) {
                // A request for a different kind of selection. This shouldn't happen.
                break;
            }
 
            if (fClipboardText.empty() || xsr->target != UTF8 || xsr->property == None) {
                // We can't fulfill this request. Deny it.
                xsel.property = None;
                XSendEvent(fDisplay, xsr->requestor, True, NoEventMask, (XEvent*)&xsel);
            } else {
                // We can fulfill this request! Update the contents of the CLIPBOARD property,
                // and let the requestor know.
                XChangeProperty(fDisplay, xsr->requestor, xsr->property, UTF8, /*format=*/8,
                                PropModeReplace, (unsigned char*)fClipboardText.data(),
                                fClipboardText.length());
                XSendEvent(fDisplay, xsr->requestor, True, NoEventMask, (XEvent*)&xsel);
            }
        } break;
 
        default:
            // these events should be handled in the main event loop
            SkASSERT(event.type != Expose && event.type != ConfigureNotify);
            break;
    }
 
    return false;
}

Hash()

static uint32_t sk_app::Window_unix::Hash ( const XWindow &  w )

inlinestatic

Definition at line 54 of file Window_unix.h.

                                           {
        return SkChecksum::Mix(w);
    }

initWindow()

bool sk_app::Window_unix::initWindow

(

Display *

display

)

Definition at line 44 of file Window_unix.cpp.

                                             {
    if (fRequestedDisplayParams.fMSAASampleCount != fMSAASampleCount) {
        this->closeWindow();
    }
    // we already have a window
    if (fDisplay) {
        return true;
    }
    fDisplay = display;
 
    constexpr int initialWidth = 1280;
    constexpr int initialHeight = 960;
 
#ifdef SK_GL
    // Attempt to create a window that supports GL
 
    // We prefer the more recent glXChooseFBConfig but fall back to glXChooseVisual. They have
    // slight differences in how attributes are specified.
    static int constexpr kChooseFBConfigAtt[] = {
        GLX_RENDER_TYPE, GLX_RGBA_BIT,
        GLX_DOUBLEBUFFER, True,
        GLX_STENCIL_SIZE, 8,
        None
    };
    // For some reason glXChooseVisual takes a non-const pointer to the attributes.
    int chooseVisualAtt[] = {
        GLX_RGBA,
        GLX_DOUBLEBUFFER,
        GLX_STENCIL_SIZE, 8,
        None
    };
    SkASSERT(nullptr == fVisualInfo);
    if (fRequestedDisplayParams.fMSAASampleCount > 1) {
        static const GLint kChooseFBConifgAttCnt = std::size(kChooseFBConfigAtt);
        GLint msaaChooseFBConfigAtt[kChooseFBConifgAttCnt + 4];
        memcpy(msaaChooseFBConfigAtt, kChooseFBConfigAtt, sizeof(kChooseFBConfigAtt));
        SkASSERT(None == msaaChooseFBConfigAtt[kChooseFBConifgAttCnt - 1]);
        msaaChooseFBConfigAtt[kChooseFBConifgAttCnt - 1] = GLX_SAMPLE_BUFFERS_ARB;
        msaaChooseFBConfigAtt[kChooseFBConifgAttCnt + 0] = 1;
        msaaChooseFBConfigAtt[kChooseFBConifgAttCnt + 1] = GLX_SAMPLES_ARB;
        msaaChooseFBConfigAtt[kChooseFBConifgAttCnt + 2] = fRequestedDisplayParams.fMSAASampleCount;
        msaaChooseFBConfigAtt[kChooseFBConifgAttCnt + 3] = None;
        int n;
        fFBConfig = glXChooseFBConfig(fDisplay, DefaultScreen(fDisplay), msaaChooseFBConfigAtt, &n);
        if (n > 0) {
            fVisualInfo = glXGetVisualFromFBConfig(fDisplay, *fFBConfig);
        } else {
            static const GLint kChooseVisualAttCnt = std::size(chooseVisualAtt);
            GLint msaaChooseVisualAtt[kChooseVisualAttCnt + 4];
            memcpy(msaaChooseVisualAtt, chooseVisualAtt, sizeof(chooseVisualAtt));
            SkASSERT(None == msaaChooseVisualAtt[kChooseVisualAttCnt - 1]);
            msaaChooseFBConfigAtt[kChooseVisualAttCnt - 1] = GLX_SAMPLE_BUFFERS_ARB;
            msaaChooseFBConfigAtt[kChooseVisualAttCnt + 0] = 1;
            msaaChooseFBConfigAtt[kChooseVisualAttCnt + 1] = GLX_SAMPLES_ARB;
            msaaChooseFBConfigAtt[kChooseVisualAttCnt + 2] =
                    fRequestedDisplayParams.fMSAASampleCount;
            msaaChooseFBConfigAtt[kChooseVisualAttCnt + 3] = None;
            fVisualInfo = glXChooseVisual(display, DefaultScreen(display), msaaChooseVisualAtt);
            fFBConfig = nullptr;
        }
    }
    if (nullptr == fVisualInfo) {
        int n;
        fFBConfig = glXChooseFBConfig(fDisplay, DefaultScreen(fDisplay), kChooseFBConfigAtt, &n);
        if (n > 0) {
            fVisualInfo = glXGetVisualFromFBConfig(fDisplay, *fFBConfig);
        } else {
            fVisualInfo = glXChooseVisual(display, DefaultScreen(display), chooseVisualAtt);
            fFBConfig = nullptr;
        }
    }
 
    if (fVisualInfo) {
        Colormap colorMap = XCreateColormap(display,
                                            RootWindow(display, fVisualInfo->screen),
                                            fVisualInfo->visual,
                                            AllocNone);
        XSetWindowAttributes swa;
        swa.colormap = colorMap;
        swa.event_mask = kEventMask;
        fWindow = XCreateWindow(display,
                                RootWindow(display, fVisualInfo->screen),
                                0, 0, // x, y
                                initialWidth, initialHeight,
                                0, // border width
                                fVisualInfo->depth,
                                InputOutput,
                                fVisualInfo->visual,
                                CWEventMask | CWColormap,
                                &swa);
    }
#endif
    if (!fWindow) {
        // Create a simple window instead.  We will not be able to show GL
        fWindow = XCreateSimpleWindow(display,
                                      DefaultRootWindow(display),
                                      0, 0,  // x, y
                                      initialWidth, initialHeight,
                                      0,     // border width
                                      0,     // border value
                                      0);    // background value
        XSelectInput(display, fWindow, kEventMask);
    }
 
    if (!fWindow) {
        return false;
    }
 
    fMSAASampleCount = fRequestedDisplayParams.fMSAASampleCount;
 
    // set up to catch window delete message
    fWmDeleteMessage = XInternAtom(display, "WM_DELETE_WINDOW", False);
    XSetWMProtocols(display, fWindow, &fWmDeleteMessage, 1);
 
    // add to hashtable of windows
    gWindowMap.add(this);
 
    // init event variables
    fPendingPaint = false;
    fPendingResize = false;
 
    return true;
}

markPendingPaint()

void sk_app::Window_unix::markPendingPaint ( )

inline

Definition at line 60 of file Window_unix.h.

{ fPendingPaint = true; }

markPendingResize()

void sk_app::Window_unix::markPendingResize ( int  width, int  height  )

inline

Definition at line 68 of file Window_unix.h.

                                                  {
        if (width != this->width() || height != this->height()){
            fPendingResize = true;
            fPendingWidth = width;
            fPendingHeight = height;
        }
    }

onInval()

void sk_app::Window_unix::onInval ( )

overridevirtual

Implements sk_app::Window.

Definition at line 428 of file Window_unix.cpp.

                          {
    XEvent event;
    event.type = Expose;
    event.xexpose.send_event = True;
    event.xexpose.display = fDisplay;
    event.xexpose.window = fWindow;
    event.xexpose.x = 0;
    event.xexpose.y = 0;
    event.xexpose.width = this->width();
    event.xexpose.height = this->height();
    event.xexpose.count = 0;
 
    XSendEvent(fDisplay, fWindow, False, 0, &event);
}

setClipboardText()

void sk_app::Window_unix::setClipboardText ( const char *  text )

overridevirtual

Reimplemented from sk_app::Window.

Definition at line 495 of file Window_unix.cpp.

                                                   {
    fClipboardText.assign(text);
 
    // Take ownership of the CLIPBOARD
    Atom CLIPBOARD = XInternAtom(fDisplay, "CLIPBOARD", 0);
    XSetSelectionOwner(fDisplay, CLIPBOARD, fWindow, CurrentTime);
}

setRequestedDisplayParams()

void sk_app::Window_unix::setRequestedDisplayParams ( const DisplayParams &  params, bool  allowReattach  )

overridevirtual

Reimplemented from sk_app::Window.

Definition at line 443 of file Window_unix.cpp.

                                                                                           {
#if defined(SK_VULKAN)
    // Vulkan on unix crashes if we try to reinitialize the vulkan context without remaking the
    // window.
    if (fBackend == kVulkan_BackendType && allowReattach) {
        // Need to change these early, so attach() creates the window context correctly
        fRequestedDisplayParams = params;
 
        this->detach();
        this->attach(fBackend);
        return;
    }
#endif
 
    Window::setRequestedDisplayParams(params, allowReattach);
}

setTitle()

void sk_app::Window_unix::setTitle ( const char *  title )

overridevirtual

Implements sk_app::Window.

Definition at line 365 of file Window_unix.cpp.

                                            {
    XTextProperty textproperty;
    if (!XStringListToTextProperty(const_cast<char**>(&title), 1, &textproperty)) {
        return;
    }
    XSetWMName(fDisplay, fWindow, &textproperty);
    XFree(textproperty.value);
}

show()

void sk_app::Window_unix::show ( )

overridevirtual

Implements sk_app::Window.

Definition at line 374 of file Window_unix.cpp.

                       {
    XMapWindow(fDisplay, fWindow);
}

Member Data Documentation

gWindowMap

SkTDynamicHash< Window_unix, XWindow > sk_app::Window_unix::gWindowMap

static

Definition at line 58 of file Window_unix.h.

---

The documentation for this class was generated from the following files:

• third_party/skia/tools/sk_app/unix/Window_unix.h
• third_party/skia/tools/sk_app/unix/Window_unix.cpp