mirror of https://github.com/axmolengine/axmol.git
1005 lines
44 KiB
C
1005 lines
44 KiB
C
//========================================================================
|
|
// GLFW 3.4 X11 - www.glfw.org
|
|
//------------------------------------------------------------------------
|
|
// Copyright (c) 2002-2006 Marcus Geelnard
|
|
// Copyright (c) 2006-2019 Camilla Löwy <elmindreda@glfw.org>
|
|
//
|
|
// This software is provided 'as-is', without any express or implied
|
|
// warranty. In no event will the authors be held liable for any damages
|
|
// arising from the use of this software.
|
|
//
|
|
// Permission is granted to anyone to use this software for any purpose,
|
|
// including commercial applications, and to alter it and redistribute it
|
|
// freely, subject to the following restrictions:
|
|
//
|
|
// 1. The origin of this software must not be misrepresented; you must not
|
|
// claim that you wrote the original software. If you use this software
|
|
// in a product, an acknowledgment in the product documentation would
|
|
// be appreciated but is not required.
|
|
//
|
|
// 2. Altered source versions must be plainly marked as such, and must not
|
|
// be misrepresented as being the original software.
|
|
//
|
|
// 3. This notice may not be removed or altered from any source
|
|
// distribution.
|
|
//
|
|
//========================================================================
|
|
|
|
#include <unistd.h>
|
|
#include <signal.h>
|
|
#include <stdint.h>
|
|
|
|
#include <X11/Xlib.h>
|
|
#include <X11/keysym.h>
|
|
#include <X11/Xatom.h>
|
|
#include <X11/Xresource.h>
|
|
#include <X11/Xcursor/Xcursor.h>
|
|
|
|
// The XRandR extension provides mode setting and gamma control
|
|
#include <X11/extensions/Xrandr.h>
|
|
|
|
// The Xkb extension provides improved keyboard support
|
|
#include <X11/XKBlib.h>
|
|
|
|
// The Xinerama extension provides legacy monitor indices
|
|
#include <X11/extensions/Xinerama.h>
|
|
|
|
// The XInput extension provides raw mouse motion input
|
|
#include <X11/extensions/XInput2.h>
|
|
|
|
// The Shape extension provides custom window shapes
|
|
#include <X11/extensions/shape.h>
|
|
|
|
#define GLX_VENDOR 1
|
|
#define GLX_RGBA_BIT 0x00000001
|
|
#define GLX_WINDOW_BIT 0x00000001
|
|
#define GLX_DRAWABLE_TYPE 0x8010
|
|
#define GLX_RENDER_TYPE 0x8011
|
|
#define GLX_RGBA_TYPE 0x8014
|
|
#define GLX_DOUBLEBUFFER 5
|
|
#define GLX_STEREO 6
|
|
#define GLX_AUX_BUFFERS 7
|
|
#define GLX_RED_SIZE 8
|
|
#define GLX_GREEN_SIZE 9
|
|
#define GLX_BLUE_SIZE 10
|
|
#define GLX_ALPHA_SIZE 11
|
|
#define GLX_DEPTH_SIZE 12
|
|
#define GLX_STENCIL_SIZE 13
|
|
#define GLX_ACCUM_RED_SIZE 14
|
|
#define GLX_ACCUM_GREEN_SIZE 15
|
|
#define GLX_ACCUM_BLUE_SIZE 16
|
|
#define GLX_ACCUM_ALPHA_SIZE 17
|
|
#define GLX_SAMPLES 0x186a1
|
|
#define GLX_VISUAL_ID 0x800b
|
|
|
|
#define GLX_FRAMEBUFFER_SRGB_CAPABLE_ARB 0x20b2
|
|
#define GLX_CONTEXT_DEBUG_BIT_ARB 0x00000001
|
|
#define GLX_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB 0x00000002
|
|
#define GLX_CONTEXT_CORE_PROFILE_BIT_ARB 0x00000001
|
|
#define GLX_CONTEXT_PROFILE_MASK_ARB 0x9126
|
|
#define GLX_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB 0x00000002
|
|
#define GLX_CONTEXT_MAJOR_VERSION_ARB 0x2091
|
|
#define GLX_CONTEXT_MINOR_VERSION_ARB 0x2092
|
|
#define GLX_CONTEXT_FLAGS_ARB 0x2094
|
|
#define GLX_CONTEXT_ES2_PROFILE_BIT_EXT 0x00000004
|
|
#define GLX_CONTEXT_ROBUST_ACCESS_BIT_ARB 0x00000004
|
|
#define GLX_LOSE_CONTEXT_ON_RESET_ARB 0x8252
|
|
#define GLX_CONTEXT_RESET_NOTIFICATION_STRATEGY_ARB 0x8256
|
|
#define GLX_NO_RESET_NOTIFICATION_ARB 0x8261
|
|
#define GLX_CONTEXT_RELEASE_BEHAVIOR_ARB 0x2097
|
|
#define GLX_CONTEXT_RELEASE_BEHAVIOR_NONE_ARB 0
|
|
#define GLX_CONTEXT_RELEASE_BEHAVIOR_FLUSH_ARB 0x2098
|
|
#define GLX_CONTEXT_OPENGL_NO_ERROR_ARB 0x31b3
|
|
|
|
typedef XID GLXWindow;
|
|
typedef XID GLXDrawable;
|
|
typedef struct __GLXFBConfig* GLXFBConfig;
|
|
typedef struct __GLXcontext* GLXContext;
|
|
typedef void (*__GLXextproc)(void);
|
|
|
|
typedef XClassHint* (* PFN_XAllocClassHint)(void);
|
|
typedef XSizeHints* (* PFN_XAllocSizeHints)(void);
|
|
typedef XWMHints* (* PFN_XAllocWMHints)(void);
|
|
typedef int (* PFN_XChangeProperty)(Display*,Window,Atom,Atom,int,int,const unsigned char*,int);
|
|
typedef int (* PFN_XChangeWindowAttributes)(Display*,Window,unsigned long,XSetWindowAttributes*);
|
|
typedef Bool (* PFN_XCheckIfEvent)(Display*,XEvent*,Bool(*)(Display*,XEvent*,XPointer),XPointer);
|
|
typedef Bool (* PFN_XCheckTypedWindowEvent)(Display*,Window,int,XEvent*);
|
|
typedef int (* PFN_XCloseDisplay)(Display*);
|
|
typedef Status (* PFN_XCloseIM)(XIM);
|
|
typedef int (* PFN_XConvertSelection)(Display*,Atom,Atom,Atom,Window,Time);
|
|
typedef Colormap (* PFN_XCreateColormap)(Display*,Window,Visual*,int);
|
|
typedef Cursor (* PFN_XCreateFontCursor)(Display*,unsigned int);
|
|
typedef XIC (* PFN_XCreateIC)(XIM,...);
|
|
typedef Region (* PFN_XCreateRegion)(void);
|
|
typedef Window (* PFN_XCreateWindow)(Display*,Window,int,int,unsigned int,unsigned int,unsigned int,int,unsigned int,Visual*,unsigned long,XSetWindowAttributes*);
|
|
typedef int (* PFN_XDefineCursor)(Display*,Window,Cursor);
|
|
typedef int (* PFN_XDeleteContext)(Display*,XID,XContext);
|
|
typedef int (* PFN_XDeleteProperty)(Display*,Window,Atom);
|
|
typedef void (* PFN_XDestroyIC)(XIC);
|
|
typedef int (* PFN_XDestroyRegion)(Region);
|
|
typedef int (* PFN_XDestroyWindow)(Display*,Window);
|
|
typedef int (* PFN_XDisplayKeycodes)(Display*,int*,int*);
|
|
typedef int (* PFN_XEventsQueued)(Display*,int);
|
|
typedef Bool (* PFN_XFilterEvent)(XEvent*,Window);
|
|
typedef int (* PFN_XFindContext)(Display*,XID,XContext,XPointer*);
|
|
typedef int (* PFN_XFlush)(Display*);
|
|
typedef int (* PFN_XFree)(void*);
|
|
typedef int (* PFN_XFreeColormap)(Display*,Colormap);
|
|
typedef int (* PFN_XFreeCursor)(Display*,Cursor);
|
|
typedef void (* PFN_XFreeEventData)(Display*,XGenericEventCookie*);
|
|
typedef int (* PFN_XGetErrorText)(Display*,int,char*,int);
|
|
typedef Bool (* PFN_XGetEventData)(Display*,XGenericEventCookie*);
|
|
typedef char* (* PFN_XGetICValues)(XIC,...);
|
|
typedef char* (* PFN_XGetIMValues)(XIM,...);
|
|
typedef int (* PFN_XGetInputFocus)(Display*,Window*,int*);
|
|
typedef KeySym* (* PFN_XGetKeyboardMapping)(Display*,KeyCode,int,int*);
|
|
typedef int (* PFN_XGetScreenSaver)(Display*,int*,int*,int*,int*);
|
|
typedef Window (* PFN_XGetSelectionOwner)(Display*,Atom);
|
|
typedef XVisualInfo* (* PFN_XGetVisualInfo)(Display*,long,XVisualInfo*,int*);
|
|
typedef Status (* PFN_XGetWMNormalHints)(Display*,Window,XSizeHints*,long*);
|
|
typedef Status (* PFN_XGetWindowAttributes)(Display*,Window,XWindowAttributes*);
|
|
typedef int (* PFN_XGetWindowProperty)(Display*,Window,Atom,long,long,Bool,Atom,Atom*,int*,unsigned long*,unsigned long*,unsigned char**);
|
|
typedef int (* PFN_XGrabPointer)(Display*,Window,Bool,unsigned int,int,int,Window,Cursor,Time);
|
|
typedef Status (* PFN_XIconifyWindow)(Display*,Window,int);
|
|
typedef Status (* PFN_XInitThreads)(void);
|
|
typedef Atom (* PFN_XInternAtom)(Display*,const char*,Bool);
|
|
typedef int (* PFN_XLookupString)(XKeyEvent*,char*,int,KeySym*,XComposeStatus*);
|
|
typedef int (* PFN_XMapRaised)(Display*,Window);
|
|
typedef int (* PFN_XMapWindow)(Display*,Window);
|
|
typedef int (* PFN_XMoveResizeWindow)(Display*,Window,int,int,unsigned int,unsigned int);
|
|
typedef int (* PFN_XMoveWindow)(Display*,Window,int,int);
|
|
typedef int (* PFN_XNextEvent)(Display*,XEvent*);
|
|
typedef Display* (* PFN_XOpenDisplay)(const char*);
|
|
typedef XIM (* PFN_XOpenIM)(Display*,XrmDatabase*,char*,char*);
|
|
typedef int (* PFN_XPeekEvent)(Display*,XEvent*);
|
|
typedef int (* PFN_XPending)(Display*);
|
|
typedef Bool (* PFN_XQueryExtension)(Display*,const char*,int*,int*,int*);
|
|
typedef Bool (* PFN_XQueryPointer)(Display*,Window,Window*,Window*,int*,int*,int*,int*,unsigned int*);
|
|
typedef int (* PFN_XRaiseWindow)(Display*,Window);
|
|
typedef Bool (* PFN_XRegisterIMInstantiateCallback)(Display*,void*,char*,char*,XIDProc,XPointer);
|
|
typedef int (* PFN_XResizeWindow)(Display*,Window,unsigned int,unsigned int);
|
|
typedef char* (* PFN_XResourceManagerString)(Display*);
|
|
typedef int (* PFN_XSaveContext)(Display*,XID,XContext,const char*);
|
|
typedef int (* PFN_XSelectInput)(Display*,Window,long);
|
|
typedef Status (* PFN_XSendEvent)(Display*,Window,Bool,long,XEvent*);
|
|
typedef int (* PFN_XSetClassHint)(Display*,Window,XClassHint*);
|
|
typedef XErrorHandler (* PFN_XSetErrorHandler)(XErrorHandler);
|
|
typedef void (* PFN_XSetICFocus)(XIC);
|
|
typedef char* (* PFN_XSetIMValues)(XIM,...);
|
|
typedef int (* PFN_XSetInputFocus)(Display*,Window,int,Time);
|
|
typedef char* (* PFN_XSetLocaleModifiers)(const char*);
|
|
typedef int (* PFN_XSetScreenSaver)(Display*,int,int,int,int);
|
|
typedef int (* PFN_XSetSelectionOwner)(Display*,Atom,Window,Time);
|
|
typedef int (* PFN_XSetWMHints)(Display*,Window,XWMHints*);
|
|
typedef void (* PFN_XSetWMNormalHints)(Display*,Window,XSizeHints*);
|
|
typedef Status (* PFN_XSetWMProtocols)(Display*,Window,Atom*,int);
|
|
typedef Bool (* PFN_XSupportsLocale)(void);
|
|
typedef int (* PFN_XSync)(Display*,Bool);
|
|
typedef Bool (* PFN_XTranslateCoordinates)(Display*,Window,Window,int,int,int*,int*,Window*);
|
|
typedef int (* PFN_XUndefineCursor)(Display*,Window);
|
|
typedef int (* PFN_XUngrabPointer)(Display*,Time);
|
|
typedef int (* PFN_XUnmapWindow)(Display*,Window);
|
|
typedef void (* PFN_XUnsetICFocus)(XIC);
|
|
typedef VisualID (* PFN_XVisualIDFromVisual)(Visual*);
|
|
typedef int (* PFN_XWarpPointer)(Display*,Window,Window,int,int,unsigned int,unsigned int,int,int);
|
|
typedef void (* PFN_XkbFreeKeyboard)(XkbDescPtr,unsigned int,Bool);
|
|
typedef void (* PFN_XkbFreeNames)(XkbDescPtr,unsigned int,Bool);
|
|
typedef XkbDescPtr (* PFN_XkbGetMap)(Display*,unsigned int,unsigned int);
|
|
typedef Status (* PFN_XkbGetNames)(Display*,unsigned int,XkbDescPtr);
|
|
typedef Status (* PFN_XkbGetState)(Display*,unsigned int,XkbStatePtr);
|
|
typedef KeySym (* PFN_XkbKeycodeToKeysym)(Display*,KeyCode,int,int);
|
|
typedef Bool (* PFN_XkbQueryExtension)(Display*,int*,int*,int*,int*,int*);
|
|
typedef Bool (* PFN_XkbSelectEventDetails)(Display*,unsigned int,unsigned int,unsigned long,unsigned long);
|
|
typedef Bool (* PFN_XkbSetDetectableAutoRepeat)(Display*,Bool,Bool*);
|
|
typedef void (* PFN_XrmDestroyDatabase)(XrmDatabase);
|
|
typedef Bool (* PFN_XrmGetResource)(XrmDatabase,const char*,const char*,char**,XrmValue*);
|
|
typedef XrmDatabase (* PFN_XrmGetStringDatabase)(const char*);
|
|
typedef void (* PFN_XrmInitialize)(void);
|
|
typedef XrmQuark (* PFN_XrmUniqueQuark)(void);
|
|
typedef Bool (* PFN_XUnregisterIMInstantiateCallback)(Display*,void*,char*,char*,XIDProc,XPointer);
|
|
typedef int (* PFN_Xutf8LookupString)(XIC,XKeyPressedEvent*,char*,int,KeySym*,Status*);
|
|
typedef void (* PFN_Xutf8SetWMProperties)(Display*,Window,const char*,const char*,char**,int,XSizeHints*,XWMHints*,XClassHint*);
|
|
#define XAllocClassHint _glfw.x11.xlib.AllocClassHint
|
|
#define XAllocSizeHints _glfw.x11.xlib.AllocSizeHints
|
|
#define XAllocWMHints _glfw.x11.xlib.AllocWMHints
|
|
#define XChangeProperty _glfw.x11.xlib.ChangeProperty
|
|
#define XChangeWindowAttributes _glfw.x11.xlib.ChangeWindowAttributes
|
|
#define XCheckIfEvent _glfw.x11.xlib.CheckIfEvent
|
|
#define XCheckTypedWindowEvent _glfw.x11.xlib.CheckTypedWindowEvent
|
|
#define XCloseDisplay _glfw.x11.xlib.CloseDisplay
|
|
#define XCloseIM _glfw.x11.xlib.CloseIM
|
|
#define XConvertSelection _glfw.x11.xlib.ConvertSelection
|
|
#define XCreateColormap _glfw.x11.xlib.CreateColormap
|
|
#define XCreateFontCursor _glfw.x11.xlib.CreateFontCursor
|
|
#define XCreateIC _glfw.x11.xlib.CreateIC
|
|
#define XCreateRegion _glfw.x11.xlib.CreateRegion
|
|
#define XCreateWindow _glfw.x11.xlib.CreateWindow
|
|
#define XDefineCursor _glfw.x11.xlib.DefineCursor
|
|
#define XDeleteContext _glfw.x11.xlib.DeleteContext
|
|
#define XDeleteProperty _glfw.x11.xlib.DeleteProperty
|
|
#define XDestroyIC _glfw.x11.xlib.DestroyIC
|
|
#define XDestroyRegion _glfw.x11.xlib.DestroyRegion
|
|
#define XDestroyWindow _glfw.x11.xlib.DestroyWindow
|
|
#define XDisplayKeycodes _glfw.x11.xlib.DisplayKeycodes
|
|
#define XEventsQueued _glfw.x11.xlib.EventsQueued
|
|
#define XFilterEvent _glfw.x11.xlib.FilterEvent
|
|
#define XFindContext _glfw.x11.xlib.FindContext
|
|
#define XFlush _glfw.x11.xlib.Flush
|
|
#define XFree _glfw.x11.xlib.Free
|
|
#define XFreeColormap _glfw.x11.xlib.FreeColormap
|
|
#define XFreeCursor _glfw.x11.xlib.FreeCursor
|
|
#define XFreeEventData _glfw.x11.xlib.FreeEventData
|
|
#define XGetErrorText _glfw.x11.xlib.GetErrorText
|
|
#define XGetEventData _glfw.x11.xlib.GetEventData
|
|
#define XGetICValues _glfw.x11.xlib.GetICValues
|
|
#define XGetIMValues _glfw.x11.xlib.GetIMValues
|
|
#define XGetInputFocus _glfw.x11.xlib.GetInputFocus
|
|
#define XGetKeyboardMapping _glfw.x11.xlib.GetKeyboardMapping
|
|
#define XGetScreenSaver _glfw.x11.xlib.GetScreenSaver
|
|
#define XGetSelectionOwner _glfw.x11.xlib.GetSelectionOwner
|
|
#define XGetVisualInfo _glfw.x11.xlib.GetVisualInfo
|
|
#define XGetWMNormalHints _glfw.x11.xlib.GetWMNormalHints
|
|
#define XGetWindowAttributes _glfw.x11.xlib.GetWindowAttributes
|
|
#define XGetWindowProperty _glfw.x11.xlib.GetWindowProperty
|
|
#define XGrabPointer _glfw.x11.xlib.GrabPointer
|
|
#define XIconifyWindow _glfw.x11.xlib.IconifyWindow
|
|
#define XInternAtom _glfw.x11.xlib.InternAtom
|
|
#define XLookupString _glfw.x11.xlib.LookupString
|
|
#define XMapRaised _glfw.x11.xlib.MapRaised
|
|
#define XMapWindow _glfw.x11.xlib.MapWindow
|
|
#define XMoveResizeWindow _glfw.x11.xlib.MoveResizeWindow
|
|
#define XMoveWindow _glfw.x11.xlib.MoveWindow
|
|
#define XNextEvent _glfw.x11.xlib.NextEvent
|
|
#define XOpenIM _glfw.x11.xlib.OpenIM
|
|
#define XPeekEvent _glfw.x11.xlib.PeekEvent
|
|
#define XPending _glfw.x11.xlib.Pending
|
|
#define XQueryExtension _glfw.x11.xlib.QueryExtension
|
|
#define XQueryPointer _glfw.x11.xlib.QueryPointer
|
|
#define XRaiseWindow _glfw.x11.xlib.RaiseWindow
|
|
#define XRegisterIMInstantiateCallback _glfw.x11.xlib.RegisterIMInstantiateCallback
|
|
#define XResizeWindow _glfw.x11.xlib.ResizeWindow
|
|
#define XResourceManagerString _glfw.x11.xlib.ResourceManagerString
|
|
#define XSaveContext _glfw.x11.xlib.SaveContext
|
|
#define XSelectInput _glfw.x11.xlib.SelectInput
|
|
#define XSendEvent _glfw.x11.xlib.SendEvent
|
|
#define XSetClassHint _glfw.x11.xlib.SetClassHint
|
|
#define XSetErrorHandler _glfw.x11.xlib.SetErrorHandler
|
|
#define XSetICFocus _glfw.x11.xlib.SetICFocus
|
|
#define XSetIMValues _glfw.x11.xlib.SetIMValues
|
|
#define XSetInputFocus _glfw.x11.xlib.SetInputFocus
|
|
#define XSetLocaleModifiers _glfw.x11.xlib.SetLocaleModifiers
|
|
#define XSetScreenSaver _glfw.x11.xlib.SetScreenSaver
|
|
#define XSetSelectionOwner _glfw.x11.xlib.SetSelectionOwner
|
|
#define XSetWMHints _glfw.x11.xlib.SetWMHints
|
|
#define XSetWMNormalHints _glfw.x11.xlib.SetWMNormalHints
|
|
#define XSetWMProtocols _glfw.x11.xlib.SetWMProtocols
|
|
#define XSupportsLocale _glfw.x11.xlib.SupportsLocale
|
|
#define XSync _glfw.x11.xlib.Sync
|
|
#define XTranslateCoordinates _glfw.x11.xlib.TranslateCoordinates
|
|
#define XUndefineCursor _glfw.x11.xlib.UndefineCursor
|
|
#define XUngrabPointer _glfw.x11.xlib.UngrabPointer
|
|
#define XUnmapWindow _glfw.x11.xlib.UnmapWindow
|
|
#define XUnsetICFocus _glfw.x11.xlib.UnsetICFocus
|
|
#define XVisualIDFromVisual _glfw.x11.xlib.VisualIDFromVisual
|
|
#define XWarpPointer _glfw.x11.xlib.WarpPointer
|
|
#define XkbFreeKeyboard _glfw.x11.xkb.FreeKeyboard
|
|
#define XkbFreeNames _glfw.x11.xkb.FreeNames
|
|
#define XkbGetMap _glfw.x11.xkb.GetMap
|
|
#define XkbGetNames _glfw.x11.xkb.GetNames
|
|
#define XkbGetState _glfw.x11.xkb.GetState
|
|
#define XkbKeycodeToKeysym _glfw.x11.xkb.KeycodeToKeysym
|
|
#define XkbQueryExtension _glfw.x11.xkb.QueryExtension
|
|
#define XkbSelectEventDetails _glfw.x11.xkb.SelectEventDetails
|
|
#define XkbSetDetectableAutoRepeat _glfw.x11.xkb.SetDetectableAutoRepeat
|
|
#define XrmDestroyDatabase _glfw.x11.xrm.DestroyDatabase
|
|
#define XrmGetResource _glfw.x11.xrm.GetResource
|
|
#define XrmGetStringDatabase _glfw.x11.xrm.GetStringDatabase
|
|
#define XrmUniqueQuark _glfw.x11.xrm.UniqueQuark
|
|
#define XUnregisterIMInstantiateCallback _glfw.x11.xlib.UnregisterIMInstantiateCallback
|
|
#define Xutf8LookupString _glfw.x11.xlib.utf8LookupString
|
|
#define Xutf8SetWMProperties _glfw.x11.xlib.utf8SetWMProperties
|
|
|
|
typedef XRRCrtcGamma* (* PFN_XRRAllocGamma)(int);
|
|
typedef void (* PFN_XRRFreeCrtcInfo)(XRRCrtcInfo*);
|
|
typedef void (* PFN_XRRFreeGamma)(XRRCrtcGamma*);
|
|
typedef void (* PFN_XRRFreeOutputInfo)(XRROutputInfo*);
|
|
typedef void (* PFN_XRRFreeScreenResources)(XRRScreenResources*);
|
|
typedef XRRCrtcGamma* (* PFN_XRRGetCrtcGamma)(Display*,RRCrtc);
|
|
typedef int (* PFN_XRRGetCrtcGammaSize)(Display*,RRCrtc);
|
|
typedef XRRCrtcInfo* (* PFN_XRRGetCrtcInfo) (Display*,XRRScreenResources*,RRCrtc);
|
|
typedef XRROutputInfo* (* PFN_XRRGetOutputInfo)(Display*,XRRScreenResources*,RROutput);
|
|
typedef RROutput (* PFN_XRRGetOutputPrimary)(Display*,Window);
|
|
typedef XRRScreenResources* (* PFN_XRRGetScreenResourcesCurrent)(Display*,Window);
|
|
typedef Bool (* PFN_XRRQueryExtension)(Display*,int*,int*);
|
|
typedef Status (* PFN_XRRQueryVersion)(Display*,int*,int*);
|
|
typedef void (* PFN_XRRSelectInput)(Display*,Window,int);
|
|
typedef Status (* PFN_XRRSetCrtcConfig)(Display*,XRRScreenResources*,RRCrtc,Time,int,int,RRMode,Rotation,RROutput*,int);
|
|
typedef void (* PFN_XRRSetCrtcGamma)(Display*,RRCrtc,XRRCrtcGamma*);
|
|
typedef int (* PFN_XRRUpdateConfiguration)(XEvent*);
|
|
#define XRRAllocGamma _glfw.x11.randr.AllocGamma
|
|
#define XRRFreeCrtcInfo _glfw.x11.randr.FreeCrtcInfo
|
|
#define XRRFreeGamma _glfw.x11.randr.FreeGamma
|
|
#define XRRFreeOutputInfo _glfw.x11.randr.FreeOutputInfo
|
|
#define XRRFreeScreenResources _glfw.x11.randr.FreeScreenResources
|
|
#define XRRGetCrtcGamma _glfw.x11.randr.GetCrtcGamma
|
|
#define XRRGetCrtcGammaSize _glfw.x11.randr.GetCrtcGammaSize
|
|
#define XRRGetCrtcInfo _glfw.x11.randr.GetCrtcInfo
|
|
#define XRRGetOutputInfo _glfw.x11.randr.GetOutputInfo
|
|
#define XRRGetOutputPrimary _glfw.x11.randr.GetOutputPrimary
|
|
#define XRRGetScreenResourcesCurrent _glfw.x11.randr.GetScreenResourcesCurrent
|
|
#define XRRQueryExtension _glfw.x11.randr.QueryExtension
|
|
#define XRRQueryVersion _glfw.x11.randr.QueryVersion
|
|
#define XRRSelectInput _glfw.x11.randr.SelectInput
|
|
#define XRRSetCrtcConfig _glfw.x11.randr.SetCrtcConfig
|
|
#define XRRSetCrtcGamma _glfw.x11.randr.SetCrtcGamma
|
|
#define XRRUpdateConfiguration _glfw.x11.randr.UpdateConfiguration
|
|
|
|
typedef XcursorImage* (* PFN_XcursorImageCreate)(int,int);
|
|
typedef void (* PFN_XcursorImageDestroy)(XcursorImage*);
|
|
typedef Cursor (* PFN_XcursorImageLoadCursor)(Display*,const XcursorImage*);
|
|
typedef char* (* PFN_XcursorGetTheme)(Display*);
|
|
typedef int (* PFN_XcursorGetDefaultSize)(Display*);
|
|
typedef XcursorImage* (* PFN_XcursorLibraryLoadImage)(const char*,const char*,int);
|
|
#define XcursorImageCreate _glfw.x11.xcursor.ImageCreate
|
|
#define XcursorImageDestroy _glfw.x11.xcursor.ImageDestroy
|
|
#define XcursorImageLoadCursor _glfw.x11.xcursor.ImageLoadCursor
|
|
#define XcursorGetTheme _glfw.x11.xcursor.GetTheme
|
|
#define XcursorGetDefaultSize _glfw.x11.xcursor.GetDefaultSize
|
|
#define XcursorLibraryLoadImage _glfw.x11.xcursor.LibraryLoadImage
|
|
|
|
typedef Bool (* PFN_XineramaIsActive)(Display*);
|
|
typedef Bool (* PFN_XineramaQueryExtension)(Display*,int*,int*);
|
|
typedef XineramaScreenInfo* (* PFN_XineramaQueryScreens)(Display*,int*);
|
|
#define XineramaIsActive _glfw.x11.xinerama.IsActive
|
|
#define XineramaQueryExtension _glfw.x11.xinerama.QueryExtension
|
|
#define XineramaQueryScreens _glfw.x11.xinerama.QueryScreens
|
|
|
|
typedef XID xcb_window_t;
|
|
typedef XID xcb_visualid_t;
|
|
typedef struct xcb_connection_t xcb_connection_t;
|
|
typedef xcb_connection_t* (* PFN_XGetXCBConnection)(Display*);
|
|
#define XGetXCBConnection _glfw.x11.x11xcb.GetXCBConnection
|
|
|
|
typedef Bool (* PFN_XF86VidModeQueryExtension)(Display*,int*,int*);
|
|
typedef Bool (* PFN_XF86VidModeGetGammaRamp)(Display*,int,int,unsigned short*,unsigned short*,unsigned short*);
|
|
typedef Bool (* PFN_XF86VidModeSetGammaRamp)(Display*,int,int,unsigned short*,unsigned short*,unsigned short*);
|
|
typedef Bool (* PFN_XF86VidModeGetGammaRampSize)(Display*,int,int*);
|
|
#define XF86VidModeQueryExtension _glfw.x11.vidmode.QueryExtension
|
|
#define XF86VidModeGetGammaRamp _glfw.x11.vidmode.GetGammaRamp
|
|
#define XF86VidModeSetGammaRamp _glfw.x11.vidmode.SetGammaRamp
|
|
#define XF86VidModeGetGammaRampSize _glfw.x11.vidmode.GetGammaRampSize
|
|
|
|
typedef Status (* PFN_XIQueryVersion)(Display*,int*,int*);
|
|
typedef int (* PFN_XISelectEvents)(Display*,Window,XIEventMask*,int);
|
|
#define XIQueryVersion _glfw.x11.xi.QueryVersion
|
|
#define XISelectEvents _glfw.x11.xi.SelectEvents
|
|
|
|
typedef Bool (* PFN_XRenderQueryExtension)(Display*,int*,int*);
|
|
typedef Status (* PFN_XRenderQueryVersion)(Display*dpy,int*,int*);
|
|
typedef XRenderPictFormat* (* PFN_XRenderFindVisualFormat)(Display*,Visual const*);
|
|
#define XRenderQueryExtension _glfw.x11.xrender.QueryExtension
|
|
#define XRenderQueryVersion _glfw.x11.xrender.QueryVersion
|
|
#define XRenderFindVisualFormat _glfw.x11.xrender.FindVisualFormat
|
|
|
|
typedef Bool (* PFN_XShapeQueryExtension)(Display*,int*,int*);
|
|
typedef Status (* PFN_XShapeQueryVersion)(Display*dpy,int*,int*);
|
|
typedef void (* PFN_XShapeCombineRegion)(Display*,Window,int,int,int,Region,int);
|
|
typedef void (* PFN_XShapeCombineMask)(Display*,Window,int,int,int,Pixmap,int);
|
|
|
|
#define XShapeQueryExtension _glfw.x11.xshape.QueryExtension
|
|
#define XShapeQueryVersion _glfw.x11.xshape.QueryVersion
|
|
#define XShapeCombineRegion _glfw.x11.xshape.ShapeCombineRegion
|
|
#define XShapeCombineMask _glfw.x11.xshape.ShapeCombineMask
|
|
|
|
typedef int (*PFNGLXGETFBCONFIGATTRIBPROC)(Display*,GLXFBConfig,int,int*);
|
|
typedef const char* (*PFNGLXGETCLIENTSTRINGPROC)(Display*,int);
|
|
typedef Bool (*PFNGLXQUERYEXTENSIONPROC)(Display*,int*,int*);
|
|
typedef Bool (*PFNGLXQUERYVERSIONPROC)(Display*,int*,int*);
|
|
typedef void (*PFNGLXDESTROYCONTEXTPROC)(Display*,GLXContext);
|
|
typedef Bool (*PFNGLXMAKECURRENTPROC)(Display*,GLXDrawable,GLXContext);
|
|
typedef void (*PFNGLXSWAPBUFFERSPROC)(Display*,GLXDrawable);
|
|
typedef const char* (*PFNGLXQUERYEXTENSIONSSTRINGPROC)(Display*,int);
|
|
typedef GLXFBConfig* (*PFNGLXGETFBCONFIGSPROC)(Display*,int,int*);
|
|
typedef GLXContext (*PFNGLXCREATENEWCONTEXTPROC)(Display*,GLXFBConfig,int,GLXContext,Bool);
|
|
typedef __GLXextproc (* PFNGLXGETPROCADDRESSPROC)(const GLubyte *procName);
|
|
typedef void (*PFNGLXSWAPINTERVALEXTPROC)(Display*,GLXDrawable,int);
|
|
typedef XVisualInfo* (*PFNGLXGETVISUALFROMFBCONFIGPROC)(Display*,GLXFBConfig);
|
|
typedef GLXWindow (*PFNGLXCREATEWINDOWPROC)(Display*,GLXFBConfig,Window,const int*);
|
|
typedef void (*PFNGLXDESTROYWINDOWPROC)(Display*,GLXWindow);
|
|
|
|
typedef int (*PFNGLXSWAPINTERVALMESAPROC)(int);
|
|
typedef int (*PFNGLXSWAPINTERVALSGIPROC)(int);
|
|
typedef GLXContext (*PFNGLXCREATECONTEXTATTRIBSARBPROC)(Display*,GLXFBConfig,GLXContext,Bool,const int*);
|
|
|
|
// libGL.so function pointer typedefs
|
|
#define glXGetFBConfigs _glfw.glx.GetFBConfigs
|
|
#define glXGetFBConfigAttrib _glfw.glx.GetFBConfigAttrib
|
|
#define glXGetClientString _glfw.glx.GetClientString
|
|
#define glXQueryExtension _glfw.glx.QueryExtension
|
|
#define glXQueryVersion _glfw.glx.QueryVersion
|
|
#define glXDestroyContext _glfw.glx.DestroyContext
|
|
#define glXMakeCurrent _glfw.glx.MakeCurrent
|
|
#define glXSwapBuffers _glfw.glx.SwapBuffers
|
|
#define glXQueryExtensionsString _glfw.glx.QueryExtensionsString
|
|
#define glXCreateNewContext _glfw.glx.CreateNewContext
|
|
#define glXGetVisualFromFBConfig _glfw.glx.GetVisualFromFBConfig
|
|
#define glXCreateWindow _glfw.glx.CreateWindow
|
|
#define glXDestroyWindow _glfw.glx.DestroyWindow
|
|
|
|
typedef VkFlags VkXlibSurfaceCreateFlagsKHR;
|
|
typedef VkFlags VkXcbSurfaceCreateFlagsKHR;
|
|
|
|
typedef struct VkXlibSurfaceCreateInfoKHR
|
|
{
|
|
VkStructureType sType;
|
|
const void* pNext;
|
|
VkXlibSurfaceCreateFlagsKHR flags;
|
|
Display* dpy;
|
|
Window window;
|
|
} VkXlibSurfaceCreateInfoKHR;
|
|
|
|
typedef struct VkXcbSurfaceCreateInfoKHR
|
|
{
|
|
VkStructureType sType;
|
|
const void* pNext;
|
|
VkXcbSurfaceCreateFlagsKHR flags;
|
|
xcb_connection_t* connection;
|
|
xcb_window_t window;
|
|
} VkXcbSurfaceCreateInfoKHR;
|
|
|
|
typedef VkResult (APIENTRY *PFN_vkCreateXlibSurfaceKHR)(VkInstance,const VkXlibSurfaceCreateInfoKHR*,const VkAllocationCallbacks*,VkSurfaceKHR*);
|
|
typedef VkBool32 (APIENTRY *PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR)(VkPhysicalDevice,uint32_t,Display*,VisualID);
|
|
typedef VkResult (APIENTRY *PFN_vkCreateXcbSurfaceKHR)(VkInstance,const VkXcbSurfaceCreateInfoKHR*,const VkAllocationCallbacks*,VkSurfaceKHR*);
|
|
typedef VkBool32 (APIENTRY *PFN_vkGetPhysicalDeviceXcbPresentationSupportKHR)(VkPhysicalDevice,uint32_t,xcb_connection_t*,xcb_visualid_t);
|
|
|
|
#include "xkb_unicode.h"
|
|
#include "posix_poll.h"
|
|
|
|
#define GLFW_X11_WINDOW_STATE _GLFWwindowX11 x11;
|
|
#define GLFW_X11_LIBRARY_WINDOW_STATE _GLFWlibraryX11 x11;
|
|
#define GLFW_X11_MONITOR_STATE _GLFWmonitorX11 x11;
|
|
#define GLFW_X11_CURSOR_STATE _GLFWcursorX11 x11;
|
|
|
|
#define GLFW_GLX_CONTEXT_STATE _GLFWcontextGLX glx;
|
|
#define GLFW_GLX_LIBRARY_CONTEXT_STATE _GLFWlibraryGLX glx;
|
|
|
|
|
|
// GLX-specific per-context data
|
|
//
|
|
typedef struct _GLFWcontextGLX
|
|
{
|
|
GLXContext handle;
|
|
GLXWindow window;
|
|
} _GLFWcontextGLX;
|
|
|
|
// GLX-specific global data
|
|
//
|
|
typedef struct _GLFWlibraryGLX
|
|
{
|
|
int major, minor;
|
|
int eventBase;
|
|
int errorBase;
|
|
|
|
void* handle;
|
|
|
|
// GLX 1.3 functions
|
|
PFNGLXGETFBCONFIGSPROC GetFBConfigs;
|
|
PFNGLXGETFBCONFIGATTRIBPROC GetFBConfigAttrib;
|
|
PFNGLXGETCLIENTSTRINGPROC GetClientString;
|
|
PFNGLXQUERYEXTENSIONPROC QueryExtension;
|
|
PFNGLXQUERYVERSIONPROC QueryVersion;
|
|
PFNGLXDESTROYCONTEXTPROC DestroyContext;
|
|
PFNGLXMAKECURRENTPROC MakeCurrent;
|
|
PFNGLXSWAPBUFFERSPROC SwapBuffers;
|
|
PFNGLXQUERYEXTENSIONSSTRINGPROC QueryExtensionsString;
|
|
PFNGLXCREATENEWCONTEXTPROC CreateNewContext;
|
|
PFNGLXGETVISUALFROMFBCONFIGPROC GetVisualFromFBConfig;
|
|
PFNGLXCREATEWINDOWPROC CreateWindow;
|
|
PFNGLXDESTROYWINDOWPROC DestroyWindow;
|
|
|
|
// GLX 1.4 and extension functions
|
|
PFNGLXGETPROCADDRESSPROC GetProcAddress;
|
|
PFNGLXGETPROCADDRESSPROC GetProcAddressARB;
|
|
PFNGLXSWAPINTERVALSGIPROC SwapIntervalSGI;
|
|
PFNGLXSWAPINTERVALEXTPROC SwapIntervalEXT;
|
|
PFNGLXSWAPINTERVALMESAPROC SwapIntervalMESA;
|
|
PFNGLXCREATECONTEXTATTRIBSARBPROC CreateContextAttribsARB;
|
|
GLFWbool SGI_swap_control;
|
|
GLFWbool EXT_swap_control;
|
|
GLFWbool MESA_swap_control;
|
|
GLFWbool ARB_multisample;
|
|
GLFWbool ARB_framebuffer_sRGB;
|
|
GLFWbool EXT_framebuffer_sRGB;
|
|
GLFWbool ARB_create_context;
|
|
GLFWbool ARB_create_context_profile;
|
|
GLFWbool ARB_create_context_robustness;
|
|
GLFWbool EXT_create_context_es2_profile;
|
|
GLFWbool ARB_create_context_no_error;
|
|
GLFWbool ARB_context_flush_control;
|
|
} _GLFWlibraryGLX;
|
|
|
|
// X11-specific per-window data
|
|
//
|
|
typedef struct _GLFWwindowX11
|
|
{
|
|
Colormap colormap;
|
|
Window handle;
|
|
Window parent;
|
|
XIC ic;
|
|
|
|
GLFWbool overrideRedirect;
|
|
GLFWbool iconified;
|
|
GLFWbool maximized;
|
|
|
|
// Whether the visual supports framebuffer transparency
|
|
GLFWbool transparent;
|
|
|
|
// Cached position and size used to filter out duplicate events
|
|
int width, height;
|
|
int xpos, ypos;
|
|
|
|
// The last received cursor position, regardless of source
|
|
int lastCursorPosX, lastCursorPosY;
|
|
// The last position the cursor was warped to by GLFW
|
|
int warpCursorPosX, warpCursorPosY;
|
|
|
|
// The time of the last KeyPress event per keycode, for discarding
|
|
// duplicate key events generated for some keys by ibus
|
|
Time keyPressTimes[256];
|
|
} _GLFWwindowX11;
|
|
|
|
// X11-specific global data
|
|
//
|
|
typedef struct _GLFWlibraryX11
|
|
{
|
|
Display* display;
|
|
int screen;
|
|
Window root;
|
|
|
|
// System content scale
|
|
float contentScaleX, contentScaleY;
|
|
// Helper window for IPC
|
|
Window helperWindowHandle;
|
|
// Invisible cursor for hidden cursor mode
|
|
Cursor hiddenCursorHandle;
|
|
// Context for mapping window XIDs to _GLFWwindow pointers
|
|
XContext context;
|
|
// XIM input method
|
|
XIM im;
|
|
// The previous X error handler, to be restored later
|
|
XErrorHandler errorHandler;
|
|
// Most recent error code received by X error handler
|
|
int errorCode;
|
|
// Primary selection string (while the primary selection is owned)
|
|
char* primarySelectionString;
|
|
// Clipboard string (while the selection is owned)
|
|
char* clipboardString;
|
|
// Key name string
|
|
char keynames[GLFW_KEY_LAST + 1][5];
|
|
// X11 keycode to GLFW key LUT
|
|
short int keycodes[256];
|
|
// GLFW key to X11 keycode LUT
|
|
short int scancodes[GLFW_KEY_LAST + 1];
|
|
// Where to place the cursor when re-enabled
|
|
double restoreCursorPosX, restoreCursorPosY;
|
|
// The window whose disabled cursor mode is active
|
|
_GLFWwindow* disabledCursorWindow;
|
|
int emptyEventPipe[2];
|
|
|
|
// Window manager atoms
|
|
Atom NET_SUPPORTED;
|
|
Atom NET_SUPPORTING_WM_CHECK;
|
|
Atom WM_PROTOCOLS;
|
|
Atom WM_STATE;
|
|
Atom WM_DELETE_WINDOW;
|
|
Atom NET_WM_NAME;
|
|
Atom NET_WM_ICON_NAME;
|
|
Atom NET_WM_ICON;
|
|
Atom NET_WM_PID;
|
|
Atom NET_WM_PING;
|
|
Atom NET_WM_WINDOW_TYPE;
|
|
Atom NET_WM_WINDOW_TYPE_NORMAL;
|
|
Atom NET_WM_STATE;
|
|
Atom NET_WM_STATE_ABOVE;
|
|
Atom NET_WM_STATE_FULLSCREEN;
|
|
Atom NET_WM_STATE_MAXIMIZED_VERT;
|
|
Atom NET_WM_STATE_MAXIMIZED_HORZ;
|
|
Atom NET_WM_STATE_DEMANDS_ATTENTION;
|
|
Atom NET_WM_BYPASS_COMPOSITOR;
|
|
Atom NET_WM_FULLSCREEN_MONITORS;
|
|
Atom NET_WM_WINDOW_OPACITY;
|
|
Atom NET_WM_CM_Sx;
|
|
Atom NET_WORKAREA;
|
|
Atom NET_CURRENT_DESKTOP;
|
|
Atom NET_ACTIVE_WINDOW;
|
|
Atom NET_FRAME_EXTENTS;
|
|
Atom NET_REQUEST_FRAME_EXTENTS;
|
|
Atom MOTIF_WM_HINTS;
|
|
|
|
// Xdnd (drag and drop) atoms
|
|
Atom XdndAware;
|
|
Atom XdndEnter;
|
|
Atom XdndPosition;
|
|
Atom XdndStatus;
|
|
Atom XdndActionCopy;
|
|
Atom XdndDrop;
|
|
Atom XdndFinished;
|
|
Atom XdndSelection;
|
|
Atom XdndTypeList;
|
|
Atom text_uri_list;
|
|
|
|
// Selection (clipboard) atoms
|
|
Atom TARGETS;
|
|
Atom MULTIPLE;
|
|
Atom INCR;
|
|
Atom CLIPBOARD;
|
|
Atom PRIMARY;
|
|
Atom CLIPBOARD_MANAGER;
|
|
Atom SAVE_TARGETS;
|
|
Atom NULL_;
|
|
Atom UTF8_STRING;
|
|
Atom COMPOUND_STRING;
|
|
Atom ATOM_PAIR;
|
|
Atom GLFW_SELECTION;
|
|
|
|
struct {
|
|
void* handle;
|
|
GLFWbool utf8;
|
|
PFN_XAllocClassHint AllocClassHint;
|
|
PFN_XAllocSizeHints AllocSizeHints;
|
|
PFN_XAllocWMHints AllocWMHints;
|
|
PFN_XChangeProperty ChangeProperty;
|
|
PFN_XChangeWindowAttributes ChangeWindowAttributes;
|
|
PFN_XCheckIfEvent CheckIfEvent;
|
|
PFN_XCheckTypedWindowEvent CheckTypedWindowEvent;
|
|
PFN_XCloseDisplay CloseDisplay;
|
|
PFN_XCloseIM CloseIM;
|
|
PFN_XConvertSelection ConvertSelection;
|
|
PFN_XCreateColormap CreateColormap;
|
|
PFN_XCreateFontCursor CreateFontCursor;
|
|
PFN_XCreateIC CreateIC;
|
|
PFN_XCreateRegion CreateRegion;
|
|
PFN_XCreateWindow CreateWindow;
|
|
PFN_XDefineCursor DefineCursor;
|
|
PFN_XDeleteContext DeleteContext;
|
|
PFN_XDeleteProperty DeleteProperty;
|
|
PFN_XDestroyIC DestroyIC;
|
|
PFN_XDestroyRegion DestroyRegion;
|
|
PFN_XDestroyWindow DestroyWindow;
|
|
PFN_XDisplayKeycodes DisplayKeycodes;
|
|
PFN_XEventsQueued EventsQueued;
|
|
PFN_XFilterEvent FilterEvent;
|
|
PFN_XFindContext FindContext;
|
|
PFN_XFlush Flush;
|
|
PFN_XFree Free;
|
|
PFN_XFreeColormap FreeColormap;
|
|
PFN_XFreeCursor FreeCursor;
|
|
PFN_XFreeEventData FreeEventData;
|
|
PFN_XGetErrorText GetErrorText;
|
|
PFN_XGetEventData GetEventData;
|
|
PFN_XGetICValues GetICValues;
|
|
PFN_XGetIMValues GetIMValues;
|
|
PFN_XGetInputFocus GetInputFocus;
|
|
PFN_XGetKeyboardMapping GetKeyboardMapping;
|
|
PFN_XGetScreenSaver GetScreenSaver;
|
|
PFN_XGetSelectionOwner GetSelectionOwner;
|
|
PFN_XGetVisualInfo GetVisualInfo;
|
|
PFN_XGetWMNormalHints GetWMNormalHints;
|
|
PFN_XGetWindowAttributes GetWindowAttributes;
|
|
PFN_XGetWindowProperty GetWindowProperty;
|
|
PFN_XGrabPointer GrabPointer;
|
|
PFN_XIconifyWindow IconifyWindow;
|
|
PFN_XInternAtom InternAtom;
|
|
PFN_XLookupString LookupString;
|
|
PFN_XMapRaised MapRaised;
|
|
PFN_XMapWindow MapWindow;
|
|
PFN_XMoveResizeWindow MoveResizeWindow;
|
|
PFN_XMoveWindow MoveWindow;
|
|
PFN_XNextEvent NextEvent;
|
|
PFN_XOpenIM OpenIM;
|
|
PFN_XPeekEvent PeekEvent;
|
|
PFN_XPending Pending;
|
|
PFN_XQueryExtension QueryExtension;
|
|
PFN_XQueryPointer QueryPointer;
|
|
PFN_XRaiseWindow RaiseWindow;
|
|
PFN_XRegisterIMInstantiateCallback RegisterIMInstantiateCallback;
|
|
PFN_XResizeWindow ResizeWindow;
|
|
PFN_XResourceManagerString ResourceManagerString;
|
|
PFN_XSaveContext SaveContext;
|
|
PFN_XSelectInput SelectInput;
|
|
PFN_XSendEvent SendEvent;
|
|
PFN_XSetClassHint SetClassHint;
|
|
PFN_XSetErrorHandler SetErrorHandler;
|
|
PFN_XSetICFocus SetICFocus;
|
|
PFN_XSetIMValues SetIMValues;
|
|
PFN_XSetInputFocus SetInputFocus;
|
|
PFN_XSetLocaleModifiers SetLocaleModifiers;
|
|
PFN_XSetScreenSaver SetScreenSaver;
|
|
PFN_XSetSelectionOwner SetSelectionOwner;
|
|
PFN_XSetWMHints SetWMHints;
|
|
PFN_XSetWMNormalHints SetWMNormalHints;
|
|
PFN_XSetWMProtocols SetWMProtocols;
|
|
PFN_XSupportsLocale SupportsLocale;
|
|
PFN_XSync Sync;
|
|
PFN_XTranslateCoordinates TranslateCoordinates;
|
|
PFN_XUndefineCursor UndefineCursor;
|
|
PFN_XUngrabPointer UngrabPointer;
|
|
PFN_XUnmapWindow UnmapWindow;
|
|
PFN_XUnsetICFocus UnsetICFocus;
|
|
PFN_XVisualIDFromVisual VisualIDFromVisual;
|
|
PFN_XWarpPointer WarpPointer;
|
|
PFN_XUnregisterIMInstantiateCallback UnregisterIMInstantiateCallback;
|
|
PFN_Xutf8LookupString utf8LookupString;
|
|
PFN_Xutf8SetWMProperties utf8SetWMProperties;
|
|
} xlib;
|
|
|
|
struct {
|
|
PFN_XrmDestroyDatabase DestroyDatabase;
|
|
PFN_XrmGetResource GetResource;
|
|
PFN_XrmGetStringDatabase GetStringDatabase;
|
|
PFN_XrmUniqueQuark UniqueQuark;
|
|
} xrm;
|
|
|
|
struct {
|
|
GLFWbool available;
|
|
void* handle;
|
|
int eventBase;
|
|
int errorBase;
|
|
int major;
|
|
int minor;
|
|
GLFWbool gammaBroken;
|
|
GLFWbool monitorBroken;
|
|
PFN_XRRAllocGamma AllocGamma;
|
|
PFN_XRRFreeCrtcInfo FreeCrtcInfo;
|
|
PFN_XRRFreeGamma FreeGamma;
|
|
PFN_XRRFreeOutputInfo FreeOutputInfo;
|
|
PFN_XRRFreeScreenResources FreeScreenResources;
|
|
PFN_XRRGetCrtcGamma GetCrtcGamma;
|
|
PFN_XRRGetCrtcGammaSize GetCrtcGammaSize;
|
|
PFN_XRRGetCrtcInfo GetCrtcInfo;
|
|
PFN_XRRGetOutputInfo GetOutputInfo;
|
|
PFN_XRRGetOutputPrimary GetOutputPrimary;
|
|
PFN_XRRGetScreenResourcesCurrent GetScreenResourcesCurrent;
|
|
PFN_XRRQueryExtension QueryExtension;
|
|
PFN_XRRQueryVersion QueryVersion;
|
|
PFN_XRRSelectInput SelectInput;
|
|
PFN_XRRSetCrtcConfig SetCrtcConfig;
|
|
PFN_XRRSetCrtcGamma SetCrtcGamma;
|
|
PFN_XRRUpdateConfiguration UpdateConfiguration;
|
|
} randr;
|
|
|
|
struct {
|
|
GLFWbool available;
|
|
GLFWbool detectable;
|
|
int majorOpcode;
|
|
int eventBase;
|
|
int errorBase;
|
|
int major;
|
|
int minor;
|
|
unsigned int group;
|
|
PFN_XkbFreeKeyboard FreeKeyboard;
|
|
PFN_XkbFreeNames FreeNames;
|
|
PFN_XkbGetMap GetMap;
|
|
PFN_XkbGetNames GetNames;
|
|
PFN_XkbGetState GetState;
|
|
PFN_XkbKeycodeToKeysym KeycodeToKeysym;
|
|
PFN_XkbQueryExtension QueryExtension;
|
|
PFN_XkbSelectEventDetails SelectEventDetails;
|
|
PFN_XkbSetDetectableAutoRepeat SetDetectableAutoRepeat;
|
|
} xkb;
|
|
|
|
struct {
|
|
int count;
|
|
int timeout;
|
|
int interval;
|
|
int blanking;
|
|
int exposure;
|
|
} saver;
|
|
|
|
struct {
|
|
int version;
|
|
Window source;
|
|
Atom format;
|
|
} xdnd;
|
|
|
|
struct {
|
|
void* handle;
|
|
PFN_XcursorImageCreate ImageCreate;
|
|
PFN_XcursorImageDestroy ImageDestroy;
|
|
PFN_XcursorImageLoadCursor ImageLoadCursor;
|
|
PFN_XcursorGetTheme GetTheme;
|
|
PFN_XcursorGetDefaultSize GetDefaultSize;
|
|
PFN_XcursorLibraryLoadImage LibraryLoadImage;
|
|
} xcursor;
|
|
|
|
struct {
|
|
GLFWbool available;
|
|
void* handle;
|
|
int major;
|
|
int minor;
|
|
PFN_XineramaIsActive IsActive;
|
|
PFN_XineramaQueryExtension QueryExtension;
|
|
PFN_XineramaQueryScreens QueryScreens;
|
|
} xinerama;
|
|
|
|
struct {
|
|
void* handle;
|
|
PFN_XGetXCBConnection GetXCBConnection;
|
|
} x11xcb;
|
|
|
|
struct {
|
|
GLFWbool available;
|
|
void* handle;
|
|
int eventBase;
|
|
int errorBase;
|
|
PFN_XF86VidModeQueryExtension QueryExtension;
|
|
PFN_XF86VidModeGetGammaRamp GetGammaRamp;
|
|
PFN_XF86VidModeSetGammaRamp SetGammaRamp;
|
|
PFN_XF86VidModeGetGammaRampSize GetGammaRampSize;
|
|
} vidmode;
|
|
|
|
struct {
|
|
GLFWbool available;
|
|
void* handle;
|
|
int majorOpcode;
|
|
int eventBase;
|
|
int errorBase;
|
|
int major;
|
|
int minor;
|
|
PFN_XIQueryVersion QueryVersion;
|
|
PFN_XISelectEvents SelectEvents;
|
|
} xi;
|
|
|
|
struct {
|
|
GLFWbool available;
|
|
void* handle;
|
|
int major;
|
|
int minor;
|
|
int eventBase;
|
|
int errorBase;
|
|
PFN_XRenderQueryExtension QueryExtension;
|
|
PFN_XRenderQueryVersion QueryVersion;
|
|
PFN_XRenderFindVisualFormat FindVisualFormat;
|
|
} xrender;
|
|
|
|
struct {
|
|
GLFWbool available;
|
|
void* handle;
|
|
int major;
|
|
int minor;
|
|
int eventBase;
|
|
int errorBase;
|
|
PFN_XShapeQueryExtension QueryExtension;
|
|
PFN_XShapeCombineRegion ShapeCombineRegion;
|
|
PFN_XShapeQueryVersion QueryVersion;
|
|
PFN_XShapeCombineMask ShapeCombineMask;
|
|
} xshape;
|
|
} _GLFWlibraryX11;
|
|
|
|
// X11-specific per-monitor data
|
|
//
|
|
typedef struct _GLFWmonitorX11
|
|
{
|
|
RROutput output;
|
|
RRCrtc crtc;
|
|
RRMode oldMode;
|
|
|
|
// Index of corresponding Xinerama screen,
|
|
// for EWMH full screen window placement
|
|
int index;
|
|
} _GLFWmonitorX11;
|
|
|
|
// X11-specific per-cursor data
|
|
//
|
|
typedef struct _GLFWcursorX11
|
|
{
|
|
Cursor handle;
|
|
} _GLFWcursorX11;
|
|
|
|
|
|
GLFWbool _glfwConnectX11(int platformID, _GLFWplatform* platform);
|
|
int _glfwInitX11(void);
|
|
void _glfwTerminateX11(void);
|
|
|
|
GLFWbool _glfwCreateWindowX11(_GLFWwindow* window, const _GLFWwndconfig* wndconfig, const _GLFWctxconfig* ctxconfig, const _GLFWfbconfig* fbconfig);
|
|
void _glfwDestroyWindowX11(_GLFWwindow* window);
|
|
void _glfwSetWindowTitleX11(_GLFWwindow* window, const char* title);
|
|
void _glfwSetWindowIconX11(_GLFWwindow* window, int count, const GLFWimage* images);
|
|
void _glfwGetWindowPosX11(_GLFWwindow* window, int* xpos, int* ypos);
|
|
void _glfwSetWindowPosX11(_GLFWwindow* window, int xpos, int ypos);
|
|
void _glfwGetWindowSizeX11(_GLFWwindow* window, int* width, int* height);
|
|
void _glfwSetWindowSizeX11(_GLFWwindow* window, int width, int height);
|
|
void _glfwSetWindowSizeLimitsX11(_GLFWwindow* window, int minwidth, int minheight, int maxwidth, int maxheight);
|
|
void _glfwSetWindowAspectRatioX11(_GLFWwindow* window, int numer, int denom);
|
|
void _glfwGetFramebufferSizeX11(_GLFWwindow* window, int* width, int* height);
|
|
void _glfwGetWindowFrameSizeX11(_GLFWwindow* window, int* left, int* top, int* right, int* bottom);
|
|
void _glfwGetWindowContentScaleX11(_GLFWwindow* window, float* xscale, float* yscale);
|
|
void _glfwIconifyWindowX11(_GLFWwindow* window);
|
|
void _glfwRestoreWindowX11(_GLFWwindow* window);
|
|
void _glfwMaximizeWindowX11(_GLFWwindow* window);
|
|
void _glfwShowWindowX11(_GLFWwindow* window);
|
|
void _glfwHideWindowX11(_GLFWwindow* window);
|
|
void _glfwRequestWindowAttentionX11(_GLFWwindow* window);
|
|
void _glfwFocusWindowX11(_GLFWwindow* window);
|
|
void _glfwSetWindowMonitorX11(_GLFWwindow* window, _GLFWmonitor* monitor, int xpos, int ypos, int width, int height, int refreshRate);
|
|
GLFWbool _glfwWindowFocusedX11(_GLFWwindow* window);
|
|
GLFWbool _glfwWindowIconifiedX11(_GLFWwindow* window);
|
|
GLFWbool _glfwWindowVisibleX11(_GLFWwindow* window);
|
|
GLFWbool _glfwWindowMaximizedX11(_GLFWwindow* window);
|
|
GLFWbool _glfwWindowHoveredX11(_GLFWwindow* window);
|
|
GLFWbool _glfwFramebufferTransparentX11(_GLFWwindow* window);
|
|
void _glfwSetWindowResizableX11(_GLFWwindow* window, GLFWbool enabled);
|
|
void _glfwSetWindowDecoratedX11(_GLFWwindow* window, GLFWbool enabled);
|
|
void _glfwSetWindowFloatingX11(_GLFWwindow* window, GLFWbool enabled);
|
|
float _glfwGetWindowOpacityX11(_GLFWwindow* window);
|
|
void _glfwSetWindowOpacityX11(_GLFWwindow* window, float opacity);
|
|
void _glfwSetWindowMousePassthroughX11(_GLFWwindow* window, GLFWbool enabled);
|
|
|
|
void _glfwSetRawMouseMotionX11(_GLFWwindow *window, GLFWbool enabled);
|
|
GLFWbool _glfwRawMouseMotionSupportedX11(void);
|
|
|
|
void _glfwPollEventsX11(void);
|
|
void _glfwWaitEventsX11(void);
|
|
void _glfwWaitEventsTimeoutX11(double timeout);
|
|
void _glfwPostEmptyEventX11(void);
|
|
|
|
void _glfwGetCursorPosX11(_GLFWwindow* window, double* xpos, double* ypos);
|
|
void _glfwSetCursorPosX11(_GLFWwindow* window, double xpos, double ypos);
|
|
void _glfwSetCursorModeX11(_GLFWwindow* window, int mode);
|
|
const char* _glfwGetScancodeNameX11(int scancode);
|
|
int _glfwGetKeyScancodeX11(int key);
|
|
GLFWbool _glfwCreateCursorX11(_GLFWcursor* cursor, const GLFWimage* image, int xhot, int yhot);
|
|
GLFWbool _glfwCreateStandardCursorX11(_GLFWcursor* cursor, int shape);
|
|
void _glfwDestroyCursorX11(_GLFWcursor* cursor);
|
|
void _glfwSetCursorX11(_GLFWwindow* window, _GLFWcursor* cursor);
|
|
void _glfwSetClipboardStringX11(const char* string);
|
|
const char* _glfwGetClipboardStringX11(void);
|
|
|
|
EGLenum _glfwGetEGLPlatformX11(EGLint** attribs);
|
|
EGLNativeDisplayType _glfwGetEGLNativeDisplayX11(void);
|
|
EGLNativeWindowType _glfwGetEGLNativeWindowX11(_GLFWwindow* window);
|
|
|
|
void _glfwGetRequiredInstanceExtensionsX11(char** extensions);
|
|
GLFWbool _glfwGetPhysicalDevicePresentationSupportX11(VkInstance instance, VkPhysicalDevice device, uint32_t queuefamily);
|
|
VkResult _glfwCreateWindowSurfaceX11(VkInstance instance, _GLFWwindow* window, const VkAllocationCallbacks* allocator, VkSurfaceKHR* surface);
|
|
|
|
void _glfwFreeMonitorX11(_GLFWmonitor* monitor);
|
|
void _glfwGetMonitorPosX11(_GLFWmonitor* monitor, int* xpos, int* ypos);
|
|
void _glfwGetMonitorContentScaleX11(_GLFWmonitor* monitor, float* xscale, float* yscale);
|
|
void _glfwGetMonitorWorkareaX11(_GLFWmonitor* monitor, int* xpos, int* ypos, int* width, int* height);
|
|
GLFWvidmode* _glfwGetVideoModesX11(_GLFWmonitor* monitor, int* count);
|
|
void _glfwGetVideoModeX11(_GLFWmonitor* monitor, GLFWvidmode* mode);
|
|
GLFWbool _glfwGetGammaRampX11(_GLFWmonitor* monitor, GLFWgammaramp* ramp);
|
|
void _glfwSetGammaRampX11(_GLFWmonitor* monitor, const GLFWgammaramp* ramp);
|
|
|
|
void _glfwPollMonitorsX11(void);
|
|
void _glfwSetVideoModeX11(_GLFWmonitor* monitor, const GLFWvidmode* desired);
|
|
void _glfwRestoreVideoModeX11(_GLFWmonitor* monitor);
|
|
|
|
Cursor _glfwCreateNativeCursorX11(const GLFWimage* image, int xhot, int yhot);
|
|
|
|
unsigned long _glfwGetWindowPropertyX11(Window window,
|
|
Atom property,
|
|
Atom type,
|
|
unsigned char** value);
|
|
GLFWbool _glfwIsVisualTransparentX11(Visual* visual);
|
|
|
|
void _glfwGrabErrorHandlerX11(void);
|
|
void _glfwReleaseErrorHandlerX11(void);
|
|
void _glfwInputErrorX11(int error, const char* message);
|
|
|
|
void _glfwPushSelectionToManagerX11(void);
|
|
void _glfwCreateInputContextX11(_GLFWwindow* window);
|
|
|
|
GLFWbool _glfwInitGLX(void);
|
|
void _glfwTerminateGLX(void);
|
|
GLFWbool _glfwCreateContextGLX(_GLFWwindow* window,
|
|
const _GLFWctxconfig* ctxconfig,
|
|
const _GLFWfbconfig* fbconfig);
|
|
void _glfwDestroyContextGLX(_GLFWwindow* window);
|
|
GLFWbool _glfwChooseVisualGLX(const _GLFWwndconfig* wndconfig,
|
|
const _GLFWctxconfig* ctxconfig,
|
|
const _GLFWfbconfig* fbconfig,
|
|
Visual** visual, int* depth);
|
|
|