2019 lines
54 KiB
C++
2019 lines
54 KiB
C++
/*************************************************************************/
|
|
/* os_x11.cpp */
|
|
/*************************************************************************/
|
|
/* This file is part of: */
|
|
/* GODOT ENGINE */
|
|
/* http://www.godotengine.org */
|
|
/*************************************************************************/
|
|
/* Copyright (c) 2007-2017 Juan Linietsky, Ariel Manzur. */
|
|
/* */
|
|
/* Permission is hereby granted, free of charge, to any person obtaining */
|
|
/* a copy of this software and associated documentation files (the */
|
|
/* "Software"), to deal in the Software without restriction, including */
|
|
/* without limitation the rights to use, copy, modify, merge, publish, */
|
|
/* distribute, sublicense, and/or sell copies of the Software, and to */
|
|
/* permit persons to whom the Software is furnished to do so, subject to */
|
|
/* the following conditions: */
|
|
/* */
|
|
/* The above copyright notice and this permission notice shall be */
|
|
/* included in all copies or substantial portions of the Software. */
|
|
/* */
|
|
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
|
|
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
|
|
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
|
|
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
|
|
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
|
|
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
|
|
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
|
|
/*************************************************************************/
|
|
#include "servers/visual/visual_server_raster.h"
|
|
#include "drivers/gles2/rasterizer_gles2.h"
|
|
#include "os_x11.h"
|
|
#include "key_mapping_x11.h"
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include "print_string.h"
|
|
#include "servers/physics/physics_server_sw.h"
|
|
#include "errno.h"
|
|
|
|
#include "X11/Xutil.h"
|
|
|
|
#include "X11/Xatom.h"
|
|
#include "X11/extensions/Xinerama.h"
|
|
// ICCCM
|
|
#define WM_NormalState 1L // window normal state
|
|
#define WM_IconicState 3L // window minimized
|
|
// EWMH
|
|
#define _NET_WM_STATE_REMOVE 0L // remove/unset property
|
|
#define _NET_WM_STATE_ADD 1L // add/set property
|
|
#define _NET_WM_STATE_TOGGLE 2L // toggle property
|
|
|
|
#include "main/main.h"
|
|
|
|
|
|
|
|
#include <sys/types.h>
|
|
#include <sys/stat.h>
|
|
#include <fcntl.h>
|
|
#include <unistd.h>
|
|
#include <dlfcn.h>
|
|
|
|
//stupid linux.h
|
|
#ifdef KEY_TAB
|
|
#undef KEY_TAB
|
|
#endif
|
|
|
|
|
|
#include <X11/Xatom.h>
|
|
|
|
#undef CursorShape
|
|
|
|
int OS_X11::get_video_driver_count() const {
|
|
return 1;
|
|
}
|
|
|
|
const char * OS_X11::get_video_driver_name(int p_driver) const {
|
|
return "GLES2";
|
|
}
|
|
|
|
OS::VideoMode OS_X11::get_default_video_mode() const {
|
|
return OS::VideoMode(1024,600,false);
|
|
}
|
|
|
|
int OS_X11::get_audio_driver_count() const {
|
|
return AudioDriverManagerSW::get_driver_count();
|
|
}
|
|
|
|
const char *OS_X11::get_audio_driver_name(int p_driver) const {
|
|
|
|
AudioDriverSW* driver = AudioDriverManagerSW::get_driver(p_driver);
|
|
ERR_FAIL_COND_V( !driver, "" );
|
|
return AudioDriverManagerSW::get_driver(p_driver)->get_name();
|
|
}
|
|
|
|
void OS_X11::initialize(const VideoMode& p_desired,int p_video_driver,int p_audio_driver) {
|
|
|
|
last_button_state=0;
|
|
|
|
xmbstring=NULL;
|
|
event_id=0;
|
|
x11_window=0;
|
|
last_click_ms=0;
|
|
args=OS::get_singleton()->get_cmdline_args();
|
|
current_videomode=p_desired;
|
|
main_loop=NULL;
|
|
last_timestamp=0;
|
|
last_mouse_pos_valid=false;
|
|
last_keyrelease_time=0;
|
|
xdnd_version = 0;
|
|
|
|
if (get_render_thread_mode()==RENDER_SEPARATE_THREAD) {
|
|
XInitThreads();
|
|
}
|
|
|
|
/** XLIB INITIALIZATION **/
|
|
x11_display = XOpenDisplay(NULL);
|
|
|
|
char * modifiers = XSetLocaleModifiers ("@im=none");
|
|
if (modifiers==NULL) {
|
|
WARN_PRINT("Error setting locale modifiers");
|
|
}
|
|
|
|
const char* err;
|
|
xrr_get_monitors = NULL;
|
|
xrr_free_monitors = NULL;
|
|
int xrandr_major = 0;
|
|
int xrandr_minor = 0;
|
|
int event_base, error_base;
|
|
xrandr_ext_ok = XRRQueryExtension(x11_display,&event_base, &error_base);
|
|
xrandr_handle = dlopen("libXrandr.so.2", RTLD_LAZY);
|
|
if (!xrandr_handle) {
|
|
err = dlerror();
|
|
fprintf(stderr, "could not load libXrandr.so.2, Error: %s\n", err);
|
|
}
|
|
else {
|
|
XRRQueryVersion(x11_display, &xrandr_major, &xrandr_minor);
|
|
if (((xrandr_major << 8) | xrandr_minor) >= 0x0105) {
|
|
xrr_get_monitors = (xrr_get_monitors_t) dlsym(xrandr_handle, "XRRGetMonitors");
|
|
if (!xrr_get_monitors) {
|
|
err = dlerror();
|
|
fprintf(stderr, "could not find symbol XRRGetMonitors\nError: %s\n", err);
|
|
}
|
|
else {
|
|
xrr_free_monitors = (xrr_free_monitors_t) dlsym(xrandr_handle, "XRRFreeMonitors");
|
|
if (!xrr_free_monitors) {
|
|
err = dlerror();
|
|
fprintf(stderr, "could not find XRRFreeMonitors\nError: %s\n", err);
|
|
xrr_get_monitors = NULL;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
xim = XOpenIM (x11_display, NULL, NULL, NULL);
|
|
|
|
|
|
if (xim == NULL) {
|
|
WARN_PRINT("XOpenIM failed");
|
|
xim_style=0L;
|
|
} else {
|
|
::XIMStyles *xim_styles=NULL;
|
|
xim_style=0L;
|
|
char *imvalret=NULL;
|
|
imvalret = XGetIMValues(xim, XNQueryInputStyle, &xim_styles, NULL);
|
|
if (imvalret != NULL || xim_styles == NULL) {
|
|
fprintf (stderr, "Input method doesn't support any styles\n");
|
|
}
|
|
|
|
if (xim_styles) {
|
|
xim_style = 0L;
|
|
for (int i=0;i<xim_styles->count_styles;i++) {
|
|
|
|
if (xim_styles->supported_styles[i] ==
|
|
(XIMPreeditNothing | XIMStatusNothing)) {
|
|
|
|
xim_style = xim_styles->supported_styles[i];
|
|
break;
|
|
}
|
|
}
|
|
|
|
XFree (xim_styles);
|
|
}
|
|
XFree( imvalret );
|
|
}
|
|
|
|
/*
|
|
char* windowid = getenv("GODOT_WINDOWID");
|
|
if (windowid) {
|
|
|
|
//freopen("/home/punto/stdout", "w", stdout);
|
|
//reopen("/home/punto/stderr", "w", stderr);
|
|
x11_window = atol(windowid);
|
|
|
|
XWindowAttributes xwa;
|
|
XGetWindowAttributes(x11_display,x11_window,&xwa);
|
|
|
|
current_videomode.width = xwa.width;
|
|
current_videomode.height = xwa.height;
|
|
};
|
|
*/
|
|
|
|
// maybe contextgl wants to be in charge of creating the window
|
|
//print_line("def videomode "+itos(current_videomode.width)+","+itos(current_videomode.height));
|
|
#if defined(OPENGL_ENABLED) || defined(LEGACYGL_ENABLED)
|
|
|
|
context_gl = memnew( ContextGL_X11( x11_display, x11_window,current_videomode, false ) );
|
|
context_gl->initialize();
|
|
|
|
rasterizer = memnew( RasterizerGLES2 );
|
|
|
|
#endif
|
|
visual_server = memnew( VisualServerRaster(rasterizer) );
|
|
|
|
if (get_render_thread_mode()!=RENDER_THREAD_UNSAFE) {
|
|
|
|
visual_server =memnew(VisualServerWrapMT(visual_server,get_render_thread_mode()==RENDER_SEPARATE_THREAD));
|
|
}
|
|
|
|
// borderless fullscreen window mode
|
|
if (current_videomode.fullscreen) {
|
|
// needed for lxde/openbox, possibly others
|
|
Hints hints;
|
|
Atom property;
|
|
hints.flags = 2;
|
|
hints.decorations = 0;
|
|
property = XInternAtom(x11_display, "_MOTIF_WM_HINTS", True);
|
|
XChangeProperty(x11_display, x11_window, property, property, 32, PropModeReplace, (unsigned char *)&hints, 5);
|
|
XMapRaised(x11_display, x11_window);
|
|
XWindowAttributes xwa;
|
|
XGetWindowAttributes(x11_display, DefaultRootWindow(x11_display), &xwa);
|
|
XMoveResizeWindow(x11_display, x11_window, 0, 0, xwa.width, xwa.height);
|
|
|
|
// code for netwm-compliants
|
|
XEvent xev;
|
|
Atom wm_state = XInternAtom(x11_display, "_NET_WM_STATE", False);
|
|
Atom fullscreen = XInternAtom(x11_display, "_NET_WM_STATE_FULLSCREEN", False);
|
|
|
|
memset(&xev, 0, sizeof(xev));
|
|
xev.type = ClientMessage;
|
|
xev.xclient.window = x11_window;
|
|
xev.xclient.message_type = wm_state;
|
|
xev.xclient.format = 32;
|
|
xev.xclient.data.l[0] = 1;
|
|
xev.xclient.data.l[1] = fullscreen;
|
|
xev.xclient.data.l[2] = 0;
|
|
|
|
XSendEvent(x11_display, DefaultRootWindow(x11_display), False, SubstructureNotifyMask, &xev);
|
|
}
|
|
|
|
// disable resizable window
|
|
if (!current_videomode.resizable) {
|
|
XSizeHints *xsh;
|
|
xsh = XAllocSizeHints();
|
|
xsh->flags = PMinSize | PMaxSize;
|
|
XWindowAttributes xwa;
|
|
if (current_videomode.fullscreen) {
|
|
XGetWindowAttributes(x11_display,DefaultRootWindow(x11_display),&xwa);
|
|
} else {
|
|
XGetWindowAttributes(x11_display,x11_window,&xwa);
|
|
}
|
|
xsh->min_width = xwa.width;
|
|
xsh->max_width = xwa.width;
|
|
xsh->min_height = xwa.height;
|
|
xsh->max_height = xwa.height;
|
|
XSetWMNormalHints(x11_display, x11_window, xsh);
|
|
XFree(xsh);
|
|
}
|
|
|
|
AudioDriverManagerSW::get_driver(p_audio_driver)->set_singleton();
|
|
|
|
audio_driver_index=p_audio_driver;
|
|
if (AudioDriverManagerSW::get_driver(p_audio_driver)->init()!=OK) {
|
|
|
|
bool success=false;
|
|
audio_driver_index=-1;
|
|
for(int i=0;i<AudioDriverManagerSW::get_driver_count();i++) {
|
|
if (i==p_audio_driver)
|
|
continue;
|
|
AudioDriverManagerSW::get_driver(i)->set_singleton();
|
|
if (AudioDriverManagerSW::get_driver(i)->init()==OK) {
|
|
success=true;
|
|
print_line("Audio Driver Failed: "+String(AudioDriverManagerSW::get_driver(p_audio_driver)->get_name()));
|
|
print_line("Using alternate audio driver: "+String(AudioDriverManagerSW::get_driver(i)->get_name()));
|
|
audio_driver_index=i;
|
|
break;
|
|
}
|
|
}
|
|
if (!success) {
|
|
ERR_PRINT("Initializing audio failed.");
|
|
}
|
|
|
|
}
|
|
|
|
sample_manager = memnew( SampleManagerMallocSW );
|
|
audio_server = memnew( AudioServerSW(sample_manager) );
|
|
audio_server->init();
|
|
spatial_sound_server = memnew( SpatialSoundServerSW );
|
|
spatial_sound_server->init();
|
|
spatial_sound_2d_server = memnew( SpatialSound2DServerSW );
|
|
spatial_sound_2d_server->init();
|
|
|
|
|
|
ERR_FAIL_COND(!visual_server);
|
|
ERR_FAIL_COND(x11_window==0);
|
|
|
|
XSetWindowAttributes new_attr;
|
|
|
|
new_attr.event_mask=KeyPressMask | KeyReleaseMask | ButtonPressMask |
|
|
ButtonReleaseMask | EnterWindowMask |
|
|
LeaveWindowMask | PointerMotionMask |
|
|
Button1MotionMask |
|
|
Button2MotionMask | Button3MotionMask |
|
|
Button4MotionMask | Button5MotionMask |
|
|
ButtonMotionMask | KeymapStateMask |
|
|
ExposureMask | VisibilityChangeMask |
|
|
StructureNotifyMask |
|
|
SubstructureNotifyMask | SubstructureRedirectMask |
|
|
FocusChangeMask | PropertyChangeMask |
|
|
ColormapChangeMask | OwnerGrabButtonMask;
|
|
|
|
XChangeWindowAttributes(x11_display, x11_window,CWEventMask,&new_attr);
|
|
|
|
XClassHint* classHint;
|
|
|
|
/* set the titlebar name */
|
|
XStoreName(x11_display, x11_window, "Godot");
|
|
|
|
/* set the name and class hints for the window manager to use */
|
|
classHint = XAllocClassHint();
|
|
if (classHint) {
|
|
classHint->res_name = (char *)"Godot_Engine";
|
|
classHint->res_class = (char *)"Godot";
|
|
}
|
|
XSetClassHint(x11_display, x11_window, classHint);
|
|
XFree(classHint);
|
|
|
|
wm_delete = XInternAtom(x11_display, "WM_DELETE_WINDOW", true);
|
|
XSetWMProtocols(x11_display, x11_window, &wm_delete, 1);
|
|
|
|
|
|
if (xim && xim_style) {
|
|
|
|
xic = XCreateIC (xim,XNInputStyle, xim_style,XNClientWindow,x11_window,XNFocusWindow, x11_window, (char*)NULL);
|
|
} else {
|
|
|
|
xic=NULL;
|
|
WARN_PRINT("XCreateIC couldn't create xic");
|
|
|
|
}
|
|
|
|
XcursorSetTheme(x11_display,"default");
|
|
cursor_size = XcursorGetDefaultSize(x11_display);
|
|
cursor_theme = XcursorGetTheme(x11_display);
|
|
|
|
if (!cursor_theme) {
|
|
print_line("not found theme");
|
|
cursor_theme="default";
|
|
}
|
|
|
|
for(int i=0;i<CURSOR_MAX;i++) {
|
|
|
|
cursors[i]=None;
|
|
img[i]=NULL;
|
|
}
|
|
|
|
current_cursor=CURSOR_ARROW;
|
|
|
|
if (cursor_theme) {
|
|
//print_line("cursor theme: "+String(cursor_theme));
|
|
for(int i=0;i<CURSOR_MAX;i++) {
|
|
|
|
static const char *cursor_file[]={
|
|
"left_ptr",
|
|
"xterm",
|
|
"hand2",
|
|
"cross",
|
|
"watch",
|
|
"left_ptr_watch",
|
|
"fleur",
|
|
"hand1",
|
|
"X_cursor",
|
|
"sb_v_double_arrow",
|
|
"sb_h_double_arrow",
|
|
"size_bdiag",
|
|
"size_fdiag",
|
|
"hand1",
|
|
"sb_v_double_arrow",
|
|
"sb_h_double_arrow",
|
|
"question_arrow"
|
|
};
|
|
|
|
img[i] = XcursorLibraryLoadImage(cursor_file[i],cursor_theme,cursor_size);
|
|
if (img[i]) {
|
|
cursors[i]=XcursorImageLoadCursor(x11_display,img[i]);
|
|
//print_line("found cursor: "+String(cursor_file[i])+" id "+itos(cursors[i]));
|
|
} else {
|
|
if (OS::is_stdout_verbose())
|
|
print_line("failed cursor: "+String(cursor_file[i]));
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
{
|
|
Pixmap cursormask;
|
|
XGCValues xgc;
|
|
GC gc;
|
|
XColor col;
|
|
Cursor cursor;
|
|
|
|
cursormask = XCreatePixmap(x11_display, RootWindow(x11_display,DefaultScreen(x11_display)), 1, 1, 1);
|
|
xgc.function = GXclear;
|
|
gc = XCreateGC(x11_display, cursormask, GCFunction, &xgc);
|
|
XFillRectangle(x11_display, cursormask, gc, 0, 0, 1, 1);
|
|
col.pixel = 0;
|
|
col.red = 0;
|
|
col.flags = 4;
|
|
cursor = XCreatePixmapCursor(x11_display,
|
|
cursormask, cursormask,
|
|
&col, &col, 0, 0);
|
|
XFreePixmap(x11_display, cursormask);
|
|
XFreeGC(x11_display, gc);
|
|
|
|
|
|
if (cursor == None)
|
|
{
|
|
ERR_PRINT("FAILED CREATING CURSOR");
|
|
}
|
|
|
|
null_cursor=cursor;
|
|
}
|
|
set_cursor_shape(CURSOR_BUSY);
|
|
|
|
//Set Xdnd (drag & drop) support
|
|
Atom XdndAware = XInternAtom(x11_display, "XdndAware", False);
|
|
Atom version=5;
|
|
XChangeProperty(x11_display, x11_window, XdndAware, XA_ATOM, 32, PropModeReplace, (unsigned char*)&version, 1);
|
|
|
|
xdnd_enter = XInternAtom(x11_display, "XdndEnter", False);
|
|
xdnd_position = XInternAtom(x11_display, "XdndPosition", False);
|
|
xdnd_status = XInternAtom(x11_display, "XdndStatus", False);
|
|
xdnd_action_copy = XInternAtom(x11_display, "XdndActionCopy", False);
|
|
xdnd_drop = XInternAtom(x11_display, "XdndDrop", False);
|
|
xdnd_finished = XInternAtom(x11_display, "XdndFinished", False);
|
|
xdnd_selection = XInternAtom(x11_display, "XdndSelection", False);
|
|
requested = None;
|
|
|
|
visual_server->init();
|
|
//
|
|
physics_server = memnew( PhysicsServerSW );
|
|
physics_server->init();
|
|
//physics_2d_server = memnew( Physics2DServerSW );
|
|
physics_2d_server = Physics2DServerWrapMT::init_server<Physics2DServerSW>();
|
|
physics_2d_server->init();
|
|
|
|
input = memnew( InputDefault );
|
|
#ifdef JOYDEV_ENABLED
|
|
joystick = memnew( joystick_linux(input));
|
|
#endif
|
|
_ensure_data_dir();
|
|
}
|
|
|
|
void OS_X11::finalize() {
|
|
|
|
if(main_loop)
|
|
memdelete(main_loop);
|
|
main_loop=NULL;
|
|
|
|
spatial_sound_server->finish();
|
|
memdelete(spatial_sound_server);
|
|
spatial_sound_2d_server->finish();
|
|
memdelete(spatial_sound_2d_server);
|
|
|
|
//if (debugger_connection_console) {
|
|
// memdelete(debugger_connection_console);
|
|
//}
|
|
|
|
#ifdef JOYDEV_ENABLED
|
|
memdelete(joystick);
|
|
#endif
|
|
memdelete(input);
|
|
|
|
memdelete(sample_manager);
|
|
|
|
audio_server->finish();
|
|
memdelete(audio_server);
|
|
|
|
visual_server->finish();
|
|
memdelete(visual_server);
|
|
memdelete(rasterizer);
|
|
|
|
physics_server->finish();
|
|
memdelete(physics_server);
|
|
|
|
physics_2d_server->finish();
|
|
memdelete(physics_2d_server);
|
|
|
|
if (xrandr_handle)
|
|
dlclose(xrandr_handle);
|
|
|
|
XUnmapWindow( x11_display, x11_window );
|
|
XDestroyWindow( x11_display, x11_window );
|
|
|
|
#if defined(OPENGL_ENABLED) || defined(LEGACYGL_ENABLED)
|
|
memdelete(context_gl);
|
|
#endif
|
|
for(int i=0;i<CURSOR_MAX;i++) {
|
|
if( cursors[i] != None )
|
|
XFreeCursor( x11_display, cursors[i] );
|
|
if( img[i] != NULL )
|
|
XcursorImageDestroy( img[i] );
|
|
};
|
|
|
|
XDestroyIC( xic );
|
|
XCloseIM( xim );
|
|
|
|
XCloseDisplay(x11_display);
|
|
if (xmbstring)
|
|
memfree(xmbstring);
|
|
|
|
|
|
args.clear();
|
|
}
|
|
|
|
|
|
void OS_X11::set_mouse_mode(MouseMode p_mode) {
|
|
|
|
if (p_mode==mouse_mode)
|
|
return;
|
|
|
|
if (mouse_mode==MOUSE_MODE_CAPTURED)
|
|
XUngrabPointer(x11_display, CurrentTime);
|
|
if (mouse_mode!=MOUSE_MODE_VISIBLE && p_mode==MOUSE_MODE_VISIBLE)
|
|
XUndefineCursor(x11_display,x11_window);
|
|
if (p_mode!=MOUSE_MODE_VISIBLE && mouse_mode==MOUSE_MODE_VISIBLE) {
|
|
XDefineCursor(x11_display,x11_window,null_cursor);
|
|
}
|
|
|
|
mouse_mode=p_mode;
|
|
|
|
if (mouse_mode==MOUSE_MODE_CAPTURED) {
|
|
|
|
while(true) {
|
|
//flush pending motion events
|
|
|
|
if (XPending(x11_display) > 0) {
|
|
XEvent event;
|
|
XPeekEvent(x11_display, &event);
|
|
if (event.type==MotionNotify) {
|
|
XNextEvent(x11_display,&event);
|
|
} else {
|
|
break;
|
|
}
|
|
} else {
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (XGrabPointer(x11_display, x11_window, True,
|
|
ButtonPressMask | ButtonReleaseMask |
|
|
PointerMotionMask, GrabModeAsync, GrabModeAsync,
|
|
x11_window, None, CurrentTime) !=
|
|
GrabSuccess) {
|
|
ERR_PRINT("NO GRAB");
|
|
}
|
|
|
|
center.x = current_videomode.width/2;
|
|
center.y = current_videomode.height/2;
|
|
XWarpPointer(x11_display, None, x11_window,
|
|
0,0,0,0, (int)center.x, (int)center.y);
|
|
|
|
input->set_mouse_pos(center);
|
|
} else {
|
|
do_mouse_warp=false;
|
|
}
|
|
|
|
XFlush(x11_display);
|
|
}
|
|
|
|
void OS_X11::warp_mouse_pos(const Point2& p_to) {
|
|
|
|
if (mouse_mode==MOUSE_MODE_CAPTURED) {
|
|
|
|
last_mouse_pos=p_to;
|
|
} else {
|
|
|
|
/*XWindowAttributes xwa;
|
|
XGetWindowAttributes(x11_display, x11_window, &xwa);
|
|
printf("%d %d\n", xwa.x, xwa.y); needed? */
|
|
|
|
XWarpPointer(x11_display, None, x11_window,
|
|
0,0,0,0, (int)p_to.x , (int)p_to.y);
|
|
}
|
|
|
|
}
|
|
|
|
OS::MouseMode OS_X11::get_mouse_mode() const {
|
|
return mouse_mode;
|
|
}
|
|
|
|
int OS_X11::get_mouse_button_state() const {
|
|
return last_button_state;
|
|
}
|
|
|
|
Point2 OS_X11::get_mouse_pos() const {
|
|
return last_mouse_pos;
|
|
}
|
|
|
|
void OS_X11::set_window_title(const String& p_title) {
|
|
XStoreName(x11_display,x11_window,p_title.utf8().get_data());
|
|
|
|
Atom _net_wm_name = XInternAtom(x11_display, "_NET_WM_NAME", false);
|
|
Atom utf8_string = XInternAtom(x11_display, "UTF8_STRING", false);
|
|
XChangeProperty( x11_display, x11_window, _net_wm_name, utf8_string, 8, PropModeReplace, (unsigned char*) p_title.utf8().get_data(), p_title.utf8().length());
|
|
}
|
|
|
|
void OS_X11::set_video_mode(const VideoMode& p_video_mode,int p_screen) {
|
|
}
|
|
|
|
OS::VideoMode OS_X11::get_video_mode(int p_screen) const {
|
|
return current_videomode;
|
|
}
|
|
|
|
void OS_X11::get_fullscreen_mode_list(List<VideoMode> *p_list,int p_screen) const {
|
|
}
|
|
|
|
void OS_X11::set_wm_fullscreen(bool p_enabled) {
|
|
// Using EWMH -- Extened Window Manager Hints
|
|
XEvent xev;
|
|
Atom wm_state = XInternAtom(x11_display, "_NET_WM_STATE", False);
|
|
Atom wm_fullscreen = XInternAtom(x11_display, "_NET_WM_STATE_FULLSCREEN", False);
|
|
|
|
memset(&xev, 0, sizeof(xev));
|
|
xev.type = ClientMessage;
|
|
xev.xclient.window = x11_window;
|
|
xev.xclient.message_type = wm_state;
|
|
xev.xclient.format = 32;
|
|
xev.xclient.data.l[0] = p_enabled ? _NET_WM_STATE_ADD : _NET_WM_STATE_REMOVE;
|
|
xev.xclient.data.l[1] = wm_fullscreen;
|
|
xev.xclient.data.l[2] = 0;
|
|
|
|
XSendEvent(x11_display, DefaultRootWindow(x11_display), False, SubstructureRedirectMask | SubstructureNotifyMask, &xev);
|
|
|
|
}
|
|
|
|
int OS_X11::get_screen_count() const {
|
|
// Using Xinerama Extension
|
|
int event_base, error_base;
|
|
const Bool ext_okay = XineramaQueryExtension(x11_display, &event_base, &error_base);
|
|
if( !ext_okay ) return 0;
|
|
|
|
int count;
|
|
XineramaScreenInfo* xsi = XineramaQueryScreens(x11_display, &count);
|
|
XFree(xsi);
|
|
return count;
|
|
}
|
|
|
|
int OS_X11::get_current_screen() const {
|
|
int x,y;
|
|
Window child;
|
|
XTranslateCoordinates( x11_display, x11_window, DefaultRootWindow(x11_display), 0, 0, &x, &y, &child);
|
|
|
|
int count = get_screen_count();
|
|
for(int i=0; i<count; i++) {
|
|
Point2i pos = get_screen_position(i);
|
|
Size2i size = get_screen_size(i);
|
|
if( (x >= pos.x && x <pos.x + size.width) && (y >= pos.y && y < pos.y + size.height) )
|
|
return i;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
void OS_X11::set_current_screen(int p_screen) {
|
|
int count = get_screen_count();
|
|
if(p_screen >= count) return;
|
|
|
|
if( current_videomode.fullscreen ) {
|
|
Point2i position = get_screen_position(p_screen);
|
|
Size2i size = get_screen_size(p_screen);
|
|
|
|
XMoveResizeWindow(x11_display, x11_window, position.x, position.y, size.x, size.y);
|
|
}
|
|
else {
|
|
if( p_screen != get_current_screen() ) {
|
|
Point2i position = get_screen_position(p_screen);
|
|
XMoveWindow(x11_display, x11_window, position.x, position.y);
|
|
}
|
|
}
|
|
}
|
|
|
|
Point2 OS_X11::get_screen_position(int p_screen) const {
|
|
// Using Xinerama Extension
|
|
int event_base, error_base;
|
|
const Bool ext_okay = XineramaQueryExtension(x11_display, &event_base, &error_base);
|
|
if( !ext_okay ) {
|
|
return Point2i(0,0);
|
|
}
|
|
|
|
int count;
|
|
XineramaScreenInfo* xsi = XineramaQueryScreens(x11_display, &count);
|
|
if( p_screen >= count ) {
|
|
return Point2i(0,0);
|
|
}
|
|
|
|
Point2i position = Point2i(xsi[p_screen].x_org, xsi[p_screen].y_org);
|
|
|
|
XFree(xsi);
|
|
|
|
return position;
|
|
}
|
|
|
|
Size2 OS_X11::get_screen_size(int p_screen) const {
|
|
// Using Xinerama Extension
|
|
int event_base, error_base;
|
|
const Bool ext_okay = XineramaQueryExtension(x11_display, &event_base, &error_base);
|
|
if( !ext_okay ) return Size2i(0,0);
|
|
|
|
int count;
|
|
XineramaScreenInfo* xsi = XineramaQueryScreens(x11_display, &count);
|
|
if( p_screen >= count ) return Size2i(0,0);
|
|
|
|
Size2i size = Point2i(xsi[p_screen].width, xsi[p_screen].height);
|
|
XFree(xsi);
|
|
return size;
|
|
}
|
|
|
|
int OS_X11::get_screen_dpi(int p_screen) const {
|
|
|
|
//invalid screen?
|
|
ERR_FAIL_INDEX_V(p_screen, get_screen_count(), 0);
|
|
|
|
//Get physical monitor Dimensions through XRandR and calculate dpi
|
|
Size2 sc = get_screen_size(p_screen);
|
|
if (xrandr_ext_ok) {
|
|
int count = 0;
|
|
if (xrr_get_monitors) {
|
|
xrr_monitor_info *monitors = xrr_get_monitors(x11_display, x11_window, true, &count);
|
|
if (p_screen < count) {
|
|
double xdpi = sc.width / (double) monitors[p_screen].mwidth * 25.4;
|
|
double ydpi = sc.height / (double) monitors[p_screen].mheight * 25.4;
|
|
xrr_free_monitors(monitors);
|
|
return (xdpi + ydpi) / 2;
|
|
}
|
|
xrr_free_monitors(monitors);
|
|
}
|
|
else if (p_screen == 0) {
|
|
XRRScreenSize *sizes = XRRSizes(x11_display, 0, &count);
|
|
if (sizes) {
|
|
double xdpi = sc.width / (double) sizes[0].mwidth * 25.4;
|
|
double ydpi = sc.height / (double) sizes[0].mheight * 25.4;
|
|
return (xdpi + ydpi) / 2;
|
|
}
|
|
}
|
|
}
|
|
|
|
int width_mm = DisplayWidthMM(x11_display, p_screen);
|
|
int height_mm = DisplayHeightMM(x11_display, p_screen);
|
|
double xdpi = (width_mm ? sc.width / (double) width_mm * 25.4 : 0);
|
|
double ydpi = (height_mm ? sc.height / (double) height_mm * 25.4 : 0);
|
|
if (xdpi || xdpi)
|
|
return (xdpi + ydpi)/(xdpi && ydpi ? 2 : 1);
|
|
|
|
//could not get dpi
|
|
return 96;
|
|
}
|
|
|
|
Point2 OS_X11::get_window_position() const {
|
|
int x,y;
|
|
Window child;
|
|
XTranslateCoordinates( x11_display, x11_window, DefaultRootWindow(x11_display), 0, 0, &x, &y, &child);
|
|
|
|
int screen = get_current_screen();
|
|
Point2i screen_position = get_screen_position(screen);
|
|
|
|
return Point2i(x-screen_position.x, y-screen_position.y);
|
|
}
|
|
|
|
void OS_X11::set_window_position(const Point2& p_position) {
|
|
XMoveWindow(x11_display,x11_window,p_position.x,p_position.y);
|
|
}
|
|
|
|
Size2 OS_X11::get_window_size() const {
|
|
// Use current_videomode width and height instead of XGetWindowAttributes
|
|
// since right after a XResizeWindow the attributes may not be updated yet
|
|
return Size2i(current_videomode.width, current_videomode.height);
|
|
}
|
|
|
|
void OS_X11::set_window_size(const Size2 p_size) {
|
|
// If window resizable is disabled we need to update the attributes first
|
|
if (is_window_resizable() == false) {
|
|
XSizeHints *xsh;
|
|
xsh = XAllocSizeHints();
|
|
xsh->flags = PMinSize | PMaxSize;
|
|
xsh->min_width = p_size.x;
|
|
xsh->max_width = p_size.x;
|
|
xsh->min_height = p_size.y;
|
|
xsh->max_height = p_size.y;
|
|
XSetWMNormalHints(x11_display, x11_window, xsh);
|
|
XFree(xsh);
|
|
}
|
|
|
|
// Resize the window
|
|
XResizeWindow(x11_display, x11_window, p_size.x, p_size.y);
|
|
|
|
// Update our videomode width and height
|
|
current_videomode.width = p_size.x;
|
|
current_videomode.height = p_size.y;
|
|
}
|
|
|
|
void OS_X11::set_window_fullscreen(bool p_enabled) {
|
|
set_wm_fullscreen(p_enabled);
|
|
current_videomode.fullscreen = p_enabled;
|
|
}
|
|
|
|
bool OS_X11::is_window_fullscreen() const {
|
|
return current_videomode.fullscreen;
|
|
}
|
|
|
|
void OS_X11::set_window_resizable(bool p_enabled) {
|
|
XSizeHints *xsh;
|
|
Size2 size = get_window_size();
|
|
|
|
xsh = XAllocSizeHints();
|
|
xsh->flags = p_enabled ? 0L : PMinSize | PMaxSize;
|
|
if(!p_enabled) {
|
|
xsh->min_width = size.x;
|
|
xsh->max_width = size.x;
|
|
xsh->min_height = size.y;
|
|
xsh->max_height = size.y;
|
|
}
|
|
XSetWMNormalHints(x11_display, x11_window, xsh);
|
|
XFree(xsh);
|
|
current_videomode.resizable = p_enabled;
|
|
}
|
|
|
|
bool OS_X11::is_window_resizable() const {
|
|
return current_videomode.resizable;
|
|
}
|
|
|
|
void OS_X11::set_window_minimized(bool p_enabled) {
|
|
// Using ICCCM -- Inter-Client Communication Conventions Manual
|
|
XEvent xev;
|
|
Atom wm_change = XInternAtom(x11_display, "WM_CHANGE_STATE", False);
|
|
|
|
memset(&xev, 0, sizeof(xev));
|
|
xev.type = ClientMessage;
|
|
xev.xclient.window = x11_window;
|
|
xev.xclient.message_type = wm_change;
|
|
xev.xclient.format = 32;
|
|
xev.xclient.data.l[0] = p_enabled ? WM_IconicState : WM_NormalState;
|
|
|
|
XSendEvent(x11_display, DefaultRootWindow(x11_display), False, SubstructureRedirectMask | SubstructureNotifyMask, &xev);
|
|
|
|
Atom wm_state = XInternAtom(x11_display, "_NET_WM_STATE", False);
|
|
Atom wm_hidden = XInternAtom(x11_display, "_NET_WM_STATE_HIDDEN", False);
|
|
|
|
memset(&xev, 0, sizeof(xev));
|
|
xev.type = ClientMessage;
|
|
xev.xclient.window = x11_window;
|
|
xev.xclient.message_type = wm_state;
|
|
xev.xclient.format = 32;
|
|
xev.xclient.data.l[0] = _NET_WM_STATE_ADD;
|
|
xev.xclient.data.l[1] = wm_hidden;
|
|
|
|
XSendEvent(x11_display, DefaultRootWindow(x11_display), False, SubstructureRedirectMask | SubstructureNotifyMask, &xev);
|
|
}
|
|
|
|
bool OS_X11::is_window_minimized() const {
|
|
// Using ICCCM -- Inter-Client Communication Conventions Manual
|
|
Atom property = XInternAtom(x11_display,"WM_STATE", True);
|
|
Atom type;
|
|
int format;
|
|
unsigned long len;
|
|
unsigned long remaining;
|
|
unsigned char *data = NULL;
|
|
|
|
int result = XGetWindowProperty(
|
|
x11_display,
|
|
x11_window,
|
|
property,
|
|
0,
|
|
32,
|
|
False,
|
|
AnyPropertyType,
|
|
&type,
|
|
&format,
|
|
&len,
|
|
&remaining,
|
|
&data
|
|
);
|
|
|
|
if( result == Success ) {
|
|
long *state = (long *) data;
|
|
if( state[0] == WM_IconicState )
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
void OS_X11::set_window_maximized(bool p_enabled) {
|
|
// Using EWMH -- Extended Window Manager Hints
|
|
XEvent xev;
|
|
Atom wm_state = XInternAtom(x11_display, "_NET_WM_STATE", False);
|
|
Atom wm_max_horz = XInternAtom(x11_display, "_NET_WM_STATE_MAXIMIZED_HORZ", False);
|
|
Atom wm_max_vert = XInternAtom(x11_display, "_NET_WM_STATE_MAXIMIZED_VERT", False);
|
|
|
|
memset(&xev, 0, sizeof(xev));
|
|
xev.type = ClientMessage;
|
|
xev.xclient.window = x11_window;
|
|
xev.xclient.message_type = wm_state;
|
|
xev.xclient.format = 32;
|
|
xev.xclient.data.l[0] = p_enabled ? _NET_WM_STATE_ADD : _NET_WM_STATE_REMOVE;
|
|
xev.xclient.data.l[1] = wm_max_horz;
|
|
xev.xclient.data.l[2] = wm_max_vert;
|
|
|
|
XSendEvent(x11_display, DefaultRootWindow(x11_display), False, SubstructureRedirectMask | SubstructureNotifyMask, &xev);
|
|
|
|
maximized = p_enabled;
|
|
}
|
|
|
|
bool OS_X11::is_window_maximized() const {
|
|
// Using EWMH -- Extended Window Manager Hints
|
|
Atom property = XInternAtom(x11_display,"_NET_WM_STATE",False );
|
|
Atom type;
|
|
int format;
|
|
unsigned long len;
|
|
unsigned long remaining;
|
|
unsigned char *data = NULL;
|
|
|
|
int result = XGetWindowProperty(
|
|
x11_display,
|
|
x11_window,
|
|
property,
|
|
0,
|
|
1024,
|
|
False,
|
|
XA_ATOM,
|
|
&type,
|
|
&format,
|
|
&len,
|
|
&remaining,
|
|
&data
|
|
);
|
|
|
|
if(result == Success) {
|
|
Atom *atoms = (Atom*) data;
|
|
Atom wm_max_horz = XInternAtom(x11_display, "_NET_WM_STATE_MAXIMIZED_HORZ", False);
|
|
Atom wm_max_vert = XInternAtom(x11_display, "_NET_WM_STATE_MAXIMIZED_VERT", False);
|
|
bool found_wm_max_horz = false;
|
|
bool found_wm_max_vert = false;
|
|
|
|
for( unsigned int i=0; i < len; i++ ) {
|
|
if( atoms[i] == wm_max_horz )
|
|
found_wm_max_horz = true;
|
|
if( atoms[i] == wm_max_vert )
|
|
found_wm_max_vert = true;
|
|
|
|
if( found_wm_max_horz && found_wm_max_vert )
|
|
return true;
|
|
}
|
|
XFree(atoms);
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
void OS_X11::request_attention() {
|
|
// Using EWMH -- Extended Window Manager Hints
|
|
//
|
|
// Sets the _NET_WM_STATE_DEMANDS_ATTENTION atom for WM_STATE
|
|
// Will be unset by the window manager after user react on the request for attention
|
|
//
|
|
XEvent xev;
|
|
Atom wm_state = XInternAtom(x11_display, "_NET_WM_STATE", False);
|
|
Atom wm_attention = XInternAtom(x11_display, "_NET_WM_STATE_DEMANDS_ATTENTION", False);
|
|
|
|
memset(&xev, 0, sizeof(xev));
|
|
xev.type = ClientMessage;
|
|
xev.xclient.window = x11_window;
|
|
xev.xclient.message_type = wm_state;
|
|
xev.xclient.format = 32;
|
|
xev.xclient.data.l[0] = _NET_WM_STATE_ADD;
|
|
xev.xclient.data.l[1] = wm_attention;
|
|
|
|
XSendEvent(x11_display, DefaultRootWindow(x11_display), False, SubstructureRedirectMask | SubstructureNotifyMask, &xev);
|
|
}
|
|
|
|
InputModifierState OS_X11::get_key_modifier_state(unsigned int p_x11_state) {
|
|
|
|
InputModifierState state;
|
|
|
|
state.shift = (p_x11_state&ShiftMask);
|
|
state.control = (p_x11_state&ControlMask);
|
|
state.alt = (p_x11_state&Mod1Mask /*|| p_x11_state&Mod5Mask*/); //altgr should not count as alt
|
|
state.meta = (p_x11_state&Mod4Mask);
|
|
|
|
return state;
|
|
}
|
|
|
|
unsigned int OS_X11::get_mouse_button_state(unsigned int p_x11_state) {
|
|
|
|
unsigned int state=0;
|
|
|
|
if (p_x11_state&Button1Mask) {
|
|
|
|
state|=1<<0;
|
|
}
|
|
|
|
if (p_x11_state&Button3Mask) {
|
|
|
|
state|=1<<1;
|
|
}
|
|
|
|
if (p_x11_state&Button2Mask) {
|
|
|
|
state|=1<<2;
|
|
}
|
|
|
|
if (p_x11_state&Button4Mask) {
|
|
|
|
state|=1<<3;
|
|
}
|
|
|
|
if (p_x11_state&Button5Mask) {
|
|
|
|
state|=1<<4;
|
|
}
|
|
|
|
last_button_state=state;
|
|
return state;
|
|
}
|
|
|
|
void OS_X11::handle_key_event(XKeyEvent *p_event, bool p_echo) {
|
|
|
|
// X11 functions don't know what const is
|
|
XKeyEvent *xkeyevent = p_event;
|
|
|
|
// This code was pretty difficult to write.
|
|
// The docs stink and every toolkit seems to
|
|
// do it in a different way.
|
|
|
|
/* Phase 1, obtain a proper keysym */
|
|
|
|
// This was also very difficult to figure out.
|
|
// You'd expect you could just use Keysym provided by
|
|
// XKeycodeToKeysym to obtain internationalized
|
|
// input.. WRONG!!
|
|
// you must use XLookupString (???) which not only wastes
|
|
// cycles generating an unnecesary string, but also
|
|
// still works in half the cases. (won't handle deadkeys)
|
|
// For more complex input methods (deadkeys and more advanced)
|
|
// you have to use XmbLookupString (??).
|
|
// So.. then you have to chosse which of both results
|
|
// you want to keep.
|
|
// This is a real bizarreness and cpu waster.
|
|
|
|
KeySym keysym_keycode=0; // keysym used to find a keycode
|
|
KeySym keysym_unicode=0; // keysym used to find unicode
|
|
|
|
// XLookupString returns keysyms usable as nice scancodes/
|
|
char str[256+1];
|
|
XLookupString(xkeyevent, str, 256, &keysym_keycode, NULL);
|
|
|
|
// Meanwhile, XLookupString returns keysyms useful for unicode.
|
|
|
|
|
|
if (!xmbstring) {
|
|
// keep a temporary buffer for the string
|
|
xmbstring=(char*)memalloc(sizeof(char)*8);
|
|
xmblen=8;
|
|
}
|
|
|
|
if (xkeyevent->type == KeyPress && xic) {
|
|
|
|
Status status;
|
|
do {
|
|
|
|
int mnbytes = XmbLookupString (xic, xkeyevent, xmbstring, xmblen - 1, &keysym_unicode, &status);
|
|
xmbstring[mnbytes] = '\0';
|
|
|
|
if (status == XBufferOverflow) {
|
|
xmblen = mnbytes + 1;
|
|
xmbstring = (char*)memrealloc (xmbstring, xmblen);
|
|
}
|
|
} while (status == XBufferOverflow);
|
|
}
|
|
|
|
|
|
/* Phase 2, obtain a pigui keycode from the keysym */
|
|
|
|
// KeyMappingX11 just translated the X11 keysym to a PIGUI
|
|
// keysym, so it works in all platforms the same.
|
|
|
|
unsigned int keycode = KeyMappingX11::get_keycode(keysym_keycode);
|
|
|
|
/* Phase 3, obtain an unicode character from the keysym */
|
|
|
|
// KeyMappingX11 also translates keysym to unicode.
|
|
// It does a binary search on a table to translate
|
|
// most properly.
|
|
//print_line("keysym_unicode: "+rtos(keysym_unicode));
|
|
unsigned int unicode = keysym_unicode>0? KeyMappingX11::get_unicode_from_keysym(keysym_unicode):0;
|
|
|
|
|
|
/* Phase 4, determine if event must be filtered */
|
|
|
|
// This seems to be a side-effect of using XIM.
|
|
// XEventFilter looks like a core X11 funciton,
|
|
// but it's actually just used to see if we must
|
|
// ignore a deadkey, or events XIM determines
|
|
// must not reach the actual gui.
|
|
// Guess it was a design problem of the extension
|
|
|
|
bool keypress = xkeyevent->type == KeyPress;
|
|
|
|
if (xkeyevent->type == KeyPress && xic) {
|
|
if (XFilterEvent((XEvent*)xkeyevent, x11_window))
|
|
return;
|
|
}
|
|
|
|
if (keycode==0 && unicode==0)
|
|
return;
|
|
|
|
/* Phase 5, determine modifier mask */
|
|
|
|
// No problems here, except I had no way to
|
|
// know Mod1 was ALT and Mod4 was META (applekey/winkey)
|
|
// just tried Mods until i found them.
|
|
|
|
//print_line("mod1: "+itos(xkeyevent->state&Mod1Mask)+" mod 5: "+itos(xkeyevent->state&Mod5Mask));
|
|
|
|
InputModifierState state = get_key_modifier_state(xkeyevent->state);
|
|
|
|
/* Phase 6, determine echo character */
|
|
|
|
// Echo characters in X11 are a keyrelease and a keypress
|
|
// one after the other with the (almot) same timestamp.
|
|
// To detect them, i use XPeekEvent and check that their
|
|
// difference in time is below a treshold.
|
|
|
|
|
|
if (xkeyevent->type != KeyPress) {
|
|
|
|
// make sure there are events pending,
|
|
// so this call won't block.
|
|
if (XPending(x11_display)>0) {
|
|
XEvent peek_event;
|
|
XPeekEvent(x11_display, &peek_event);
|
|
|
|
// I'm using a treshold of 5 msecs,
|
|
// since sometimes there seems to be a little
|
|
// jitter. I'm still not convinced that all this approach
|
|
// is correct, but the xorg developers are
|
|
// not very helpful today.
|
|
|
|
::Time tresh=ABS(peek_event.xkey.time-xkeyevent->time);
|
|
if (peek_event.type == KeyPress && tresh<5 ) {
|
|
KeySym rk;
|
|
XLookupString((XKeyEvent*)&peek_event, str, 256, &rk, NULL);
|
|
if (rk==keysym_keycode) {
|
|
XEvent event;
|
|
XNextEvent(x11_display, &event); //erase next event
|
|
handle_key_event( (XKeyEvent*)&event,true );
|
|
return; //ignore current, echo next
|
|
}
|
|
}
|
|
|
|
// use the time from peek_event so it always works
|
|
}
|
|
|
|
// save the time to check for echo when keypress happens
|
|
}
|
|
|
|
|
|
/* Phase 7, send event to Window */
|
|
|
|
InputEvent event;
|
|
event.ID=++event_id;
|
|
event.type = InputEvent::KEY;
|
|
event.device=0;
|
|
event.key.mod=state;
|
|
event.key.pressed=keypress;
|
|
|
|
if (keycode>='a' && keycode<='z')
|
|
keycode-='a'-'A';
|
|
|
|
event.key.scancode=keycode;
|
|
event.key.unicode=unicode;
|
|
event.key.echo=p_echo;
|
|
|
|
if (event.key.scancode==KEY_BACKTAB) {
|
|
//make it consistent accross platforms.
|
|
event.key.scancode=KEY_TAB;
|
|
event.key.mod.shift=true;
|
|
}
|
|
|
|
//don't set mod state if modifier keys are released by themselves
|
|
//else event.is_action() will not work correctly here
|
|
if (!event.key.pressed) {
|
|
if (event.key.scancode == KEY_SHIFT)
|
|
event.key.mod.shift = false;
|
|
else if (event.key.scancode == KEY_CONTROL)
|
|
event.key.mod.control = false;
|
|
else if (event.key.scancode == KEY_ALT)
|
|
event.key.mod.alt = false;
|
|
else if (event.key.scancode == KEY_META)
|
|
event.key.mod.meta = false;
|
|
}
|
|
|
|
//printf("key: %x\n",event.key.scancode);
|
|
input->parse_input_event( event);
|
|
}
|
|
|
|
struct Property
|
|
{
|
|
unsigned char *data;
|
|
int format, nitems;
|
|
Atom type;
|
|
};
|
|
|
|
static Property read_property(Display* p_display, Window p_window, Atom p_property) {
|
|
|
|
Atom actual_type;
|
|
int actual_format;
|
|
unsigned long nitems;
|
|
unsigned long bytes_after;
|
|
unsigned char *ret=0;
|
|
|
|
int read_bytes = 1024;
|
|
|
|
//Keep trying to read the property until there are no
|
|
//bytes unread.
|
|
do
|
|
{
|
|
if(ret != 0)
|
|
XFree(ret);
|
|
|
|
XGetWindowProperty(p_display, p_window, p_property, 0, read_bytes, False, AnyPropertyType,
|
|
&actual_type, &actual_format, &nitems, &bytes_after,
|
|
&ret);
|
|
|
|
read_bytes *= 2;
|
|
|
|
}while(bytes_after != 0);
|
|
|
|
Property p = {ret, actual_format, nitems, actual_type};
|
|
|
|
return p;
|
|
}
|
|
|
|
static Atom pick_target_from_list(Display* p_display, Atom *p_list, int p_count) {
|
|
|
|
static const char* target_type = "text/uri-list";
|
|
|
|
for (int i = 0; i < p_count; i++) {
|
|
|
|
Atom atom = p_list[i];
|
|
|
|
if (atom != None && String(XGetAtomName(p_display, atom)) == target_type)
|
|
return atom;
|
|
}
|
|
return None;
|
|
}
|
|
|
|
static Atom pick_target_from_atoms(Display* p_disp, Atom p_t1, Atom p_t2, Atom p_t3) {
|
|
|
|
static const char* target_type = "text/uri-list";
|
|
if (p_t1 != None && String(XGetAtomName(p_disp, p_t1)) == target_type)
|
|
return p_t1;
|
|
|
|
if (p_t2 != None && String(XGetAtomName(p_disp, p_t2)) == target_type)
|
|
return p_t2;
|
|
|
|
if (p_t3 != None && String(XGetAtomName(p_disp, p_t3)) == target_type)
|
|
return p_t3;
|
|
|
|
return None;
|
|
}
|
|
|
|
void OS_X11::process_xevents() {
|
|
|
|
//printf("checking events %i\n", XPending(x11_display));
|
|
|
|
do_mouse_warp=false;
|
|
|
|
while (XPending(x11_display) > 0) {
|
|
XEvent event;
|
|
XNextEvent(x11_display, &event);
|
|
|
|
switch (event.type) {
|
|
case Expose:
|
|
Main::force_redraw();
|
|
break;
|
|
|
|
case NoExpose:
|
|
minimized = true;
|
|
break;
|
|
|
|
case VisibilityNotify: {
|
|
XVisibilityEvent * visibility = (XVisibilityEvent *)&event;
|
|
minimized = (visibility->state == VisibilityFullyObscured);
|
|
} break;
|
|
case LeaveNotify: {
|
|
|
|
if (main_loop && mouse_mode!=MOUSE_MODE_CAPTURED)
|
|
main_loop->notification(MainLoop::NOTIFICATION_WM_MOUSE_EXIT);
|
|
if (input)
|
|
input->set_mouse_in_window(false);
|
|
|
|
} break;
|
|
case EnterNotify: {
|
|
|
|
if (main_loop && mouse_mode!=MOUSE_MODE_CAPTURED)
|
|
main_loop->notification(MainLoop::NOTIFICATION_WM_MOUSE_ENTER);
|
|
if (input)
|
|
input->set_mouse_in_window(true);
|
|
} break;
|
|
case FocusIn:
|
|
minimized = false;
|
|
main_loop->notification(MainLoop::NOTIFICATION_WM_FOCUS_IN);
|
|
if (mouse_mode==MOUSE_MODE_CAPTURED) {
|
|
XGrabPointer(x11_display, x11_window, True,
|
|
ButtonPressMask | ButtonReleaseMask |
|
|
PointerMotionMask, GrabModeAsync, GrabModeAsync,
|
|
x11_window, None, CurrentTime);
|
|
}
|
|
break;
|
|
|
|
case FocusOut:
|
|
main_loop->notification(MainLoop::NOTIFICATION_WM_FOCUS_OUT);
|
|
if (mouse_mode==MOUSE_MODE_CAPTURED) {
|
|
//dear X11, I try, I really try, but you never work, you do whathever you want.
|
|
XUngrabPointer(x11_display, CurrentTime);
|
|
}
|
|
break;
|
|
|
|
case ConfigureNotify:
|
|
/* call resizeGLScene only if our window-size changed */
|
|
|
|
if ((event.xconfigure.width == current_videomode.width) &&
|
|
(event.xconfigure.height == current_videomode.height))
|
|
break;
|
|
|
|
current_videomode.width=event.xconfigure.width;
|
|
current_videomode.height=event.xconfigure.height;
|
|
break;
|
|
case ButtonPress:
|
|
case ButtonRelease: {
|
|
|
|
/* exit in case of a mouse button press */
|
|
last_timestamp=event.xbutton.time;
|
|
if (mouse_mode==MOUSE_MODE_CAPTURED) {
|
|
event.xbutton.x=last_mouse_pos.x;
|
|
event.xbutton.y=last_mouse_pos.y;
|
|
}
|
|
|
|
InputEvent mouse_event;
|
|
mouse_event.ID=++event_id;
|
|
mouse_event.type = InputEvent::MOUSE_BUTTON;
|
|
mouse_event.device=0;
|
|
mouse_event.mouse_button.mod = get_key_modifier_state(event.xbutton.state);
|
|
mouse_event.mouse_button.button_mask = get_mouse_button_state(event.xbutton.state);
|
|
mouse_event.mouse_button.x=event.xbutton.x;
|
|
mouse_event.mouse_button.y=event.xbutton.y;
|
|
mouse_event.mouse_button.global_x=event.xbutton.x;
|
|
mouse_event.mouse_button.global_y=event.xbutton.y;
|
|
mouse_event.mouse_button.button_index=event.xbutton.button;
|
|
if (mouse_event.mouse_button.button_index==2)
|
|
mouse_event.mouse_button.button_index=3;
|
|
else if (mouse_event.mouse_button.button_index==3)
|
|
mouse_event.mouse_button.button_index=2;
|
|
|
|
mouse_event.mouse_button.pressed=(event.type==ButtonPress);
|
|
|
|
|
|
if (event.type==ButtonPress && event.xbutton.button==1) {
|
|
|
|
uint64_t diff = get_ticks_usec()/1000 - last_click_ms;
|
|
|
|
if (diff<400 && Point2(last_click_pos).distance_to(Point2(event.xbutton.x,event.xbutton.y))<5) {
|
|
|
|
last_click_ms=0;
|
|
last_click_pos = Point2(-100,-100);
|
|
mouse_event.mouse_button.doubleclick=true;
|
|
mouse_event.ID=++event_id;
|
|
|
|
} else {
|
|
last_click_ms+=diff;
|
|
last_click_pos = Point2(event.xbutton.x,event.xbutton.y);
|
|
}
|
|
}
|
|
|
|
input->parse_input_event( mouse_event);
|
|
|
|
|
|
} break;
|
|
case MotionNotify: {
|
|
|
|
// FUCK YOU X11 API YOU SERIOUSLY GROSS ME OUT
|
|
// YOU ARE AS GROSS AS LOOKING AT A PUTRID PILE
|
|
// OF POOP STICKING OUT OF A CLOGGED TOILET
|
|
// HOW THE FUCK I AM SUPPOSED TO KNOW WHICH ONE
|
|
// OF THE MOTION NOTIFY EVENTS IS THE ONE GENERATED
|
|
// BY WARPING THE MOUSE POINTER?
|
|
// YOU ARE FORCING ME TO FILTER ONE BY ONE TO FIND IT
|
|
// PLEASE DO ME A FAVOR AND DIE DROWNED IN A FECAL
|
|
// MOUNTAIN BECAUSE THAT'S WHERE YOU BELONG.
|
|
|
|
|
|
while(true) {
|
|
if (mouse_mode==MOUSE_MODE_CAPTURED && event.xmotion.x==current_videomode.width/2 && event.xmotion.y==current_videomode.height/2) {
|
|
//this is likely the warp event since it was warped here
|
|
center=Vector2(event.xmotion.x,event.xmotion.y);
|
|
break;
|
|
}
|
|
|
|
if (XPending(x11_display) > 0) {
|
|
XEvent tevent;
|
|
XPeekEvent(x11_display, &tevent);
|
|
if (tevent.type==MotionNotify) {
|
|
XNextEvent(x11_display,&event);
|
|
} else {
|
|
break;
|
|
}
|
|
} else {
|
|
break;
|
|
}
|
|
}
|
|
|
|
last_timestamp=event.xmotion.time;
|
|
|
|
// Motion is also simple.
|
|
// A little hack is in order
|
|
// to be able to send relative motion events.
|
|
Point2i pos( event.xmotion.x, event.xmotion.y );
|
|
|
|
if (mouse_mode==MOUSE_MODE_CAPTURED) {
|
|
#if 1
|
|
//Vector2 c = Point2i(current_videomode.width/2,current_videomode.height/2);
|
|
if (pos==Point2i(current_videomode.width/2,current_videomode.height/2)) {
|
|
//this sucks, it's a hack, etc and is a little inaccurate, etc.
|
|
//but nothing I can do, X11 sucks.
|
|
|
|
center=pos;
|
|
break;
|
|
}
|
|
|
|
Point2i new_center = pos;
|
|
pos = last_mouse_pos + ( pos - center );
|
|
center=new_center;
|
|
do_mouse_warp=true;
|
|
#else
|
|
//Dear X11, thanks for making my life miserable
|
|
|
|
center.x = current_videomode.width/2;
|
|
center.y = current_videomode.height/2;
|
|
pos = last_mouse_pos + ( pos-center );
|
|
if (pos==last_mouse_pos)
|
|
break;
|
|
XWarpPointer(x11_display, None, x11_window,
|
|
0,0,0,0, (int)center.x, (int)center.y);
|
|
#endif
|
|
}
|
|
|
|
if (!last_mouse_pos_valid) {
|
|
|
|
last_mouse_pos=pos;
|
|
last_mouse_pos_valid=true;
|
|
}
|
|
|
|
Point2i rel = pos - last_mouse_pos;
|
|
|
|
InputEvent motion_event;
|
|
motion_event.ID=++event_id;
|
|
motion_event.type=InputEvent::MOUSE_MOTION;
|
|
motion_event.device=0;
|
|
|
|
motion_event.mouse_motion.mod = get_key_modifier_state(event.xmotion.state);
|
|
motion_event.mouse_motion.button_mask = get_mouse_button_state(event.xmotion.state);
|
|
motion_event.mouse_motion.x=pos.x;
|
|
motion_event.mouse_motion.y=pos.y;
|
|
input->set_mouse_pos(pos);
|
|
motion_event.mouse_motion.global_x=pos.x;
|
|
motion_event.mouse_motion.global_y=pos.y;
|
|
motion_event.mouse_motion.speed_x=input->get_mouse_speed().x;
|
|
motion_event.mouse_motion.speed_y=input->get_mouse_speed().y;
|
|
|
|
motion_event.mouse_motion.relative_x=rel.x;
|
|
motion_event.mouse_motion.relative_y=rel.y;
|
|
|
|
last_mouse_pos=pos;
|
|
|
|
// printf("rel: %d,%d\n", rel.x, rel.y );
|
|
|
|
input->parse_input_event( motion_event);
|
|
|
|
} break;
|
|
case KeyPress:
|
|
case KeyRelease: {
|
|
|
|
last_timestamp=event.xkey.time;
|
|
|
|
// key event is a little complex, so
|
|
// it will be handled in it's own function.
|
|
handle_key_event( (XKeyEvent*)&event );
|
|
} break;
|
|
case SelectionRequest: {
|
|
|
|
XSelectionRequestEvent *req;
|
|
XEvent e, respond;
|
|
e = event;
|
|
|
|
req=&(e.xselectionrequest);
|
|
if (req->target == XA_STRING || req->target == XInternAtom(x11_display, "COMPOUND_TEXT", 0) ||
|
|
req->target == XInternAtom(x11_display, "UTF8_STRING", 0))
|
|
{
|
|
CharString clip = OS::get_clipboard().utf8();
|
|
XChangeProperty (x11_display,
|
|
req->requestor,
|
|
req->property,
|
|
req->target,
|
|
8,
|
|
PropModeReplace,
|
|
(unsigned char*)clip.get_data(),
|
|
clip.length());
|
|
respond.xselection.property=req->property;
|
|
} else if (req->target == XInternAtom(x11_display, "TARGETS", 0)) {
|
|
|
|
Atom data[2];
|
|
data[0] = XInternAtom(x11_display, "UTF8_STRING", 0);
|
|
data[1] = XA_STRING;
|
|
XChangeProperty (x11_display, req->requestor, req->property, req->target,
|
|
8, PropModeReplace, (unsigned char *) &data,
|
|
sizeof (data));
|
|
respond.xselection.property=req->property;
|
|
|
|
} else {
|
|
printf ("No String %x\n",
|
|
(int)req->target);
|
|
respond.xselection.property= None;
|
|
}
|
|
respond.xselection.type= SelectionNotify;
|
|
respond.xselection.display= req->display;
|
|
respond.xselection.requestor= req->requestor;
|
|
respond.xselection.selection=req->selection;
|
|
respond.xselection.target= req->target;
|
|
respond.xselection.time = req->time;
|
|
XSendEvent (x11_display, req->requestor,0,0,&respond);
|
|
XFlush (x11_display);
|
|
} break;
|
|
|
|
case SelectionNotify:
|
|
|
|
if (event.xselection.target == requested) {
|
|
|
|
Property p = read_property(x11_display, x11_window, XInternAtom(x11_display, "PRIMARY", 0));
|
|
|
|
Vector<String> files = String((char *)p.data).split("\n", false);
|
|
for (int i = 0; i < files.size(); i++) {
|
|
files[i] = files[i].replace("file://", "").replace("%20", " ").strip_escapes();
|
|
}
|
|
main_loop->drop_files(files);
|
|
|
|
//Reply that all is well.
|
|
XClientMessageEvent m;
|
|
memset(&m, 0, sizeof(m));
|
|
m.type = ClientMessage;
|
|
m.display = x11_display;
|
|
m.window = xdnd_source_window;
|
|
m.message_type = xdnd_finished;
|
|
m.format=32;
|
|
m.data.l[0] = x11_window;
|
|
m.data.l[1] = 1;
|
|
m.data.l[2] = xdnd_action_copy; //We only ever copy.
|
|
|
|
XSendEvent(x11_display, xdnd_source_window, False, NoEventMask, (XEvent*)&m);
|
|
}
|
|
break;
|
|
|
|
case ClientMessage:
|
|
|
|
if ((unsigned int)event.xclient.data.l[0]==(unsigned int)wm_delete)
|
|
main_loop->notification(MainLoop::NOTIFICATION_WM_QUIT_REQUEST);
|
|
|
|
else if ((unsigned int)event.xclient.message_type == (unsigned int)xdnd_enter) {
|
|
|
|
//File(s) have been dragged over the window, check for supported target (text/uri-list)
|
|
xdnd_version = ( event.xclient.data.l[1] >> 24);
|
|
Window source = event.xclient.data.l[0];
|
|
bool more_than_3 = event.xclient.data.l[1] & 1;
|
|
if (more_than_3) {
|
|
Property p = read_property(x11_display, source, XInternAtom(x11_display, "XdndTypeList", False));
|
|
requested = pick_target_from_list(x11_display, (Atom*)p.data, p.nitems);
|
|
}
|
|
else
|
|
requested = pick_target_from_atoms(x11_display, event.xclient.data.l[2],event.xclient.data.l[3], event.xclient.data.l[4]);
|
|
}
|
|
else if ((unsigned int)event.xclient.message_type == (unsigned int )xdnd_position) {
|
|
|
|
//xdnd position event, reply with an XDND status message
|
|
//just depending on type of data for now
|
|
XClientMessageEvent m;
|
|
memset(&m, 0, sizeof(m));
|
|
m.type = ClientMessage;
|
|
m.display = event.xclient.display;
|
|
m.window = event.xclient.data.l[0];
|
|
m.message_type = xdnd_status;
|
|
m.format=32;
|
|
m.data.l[0] = x11_window;
|
|
m.data.l[1] = (requested != None);
|
|
m.data.l[2] = 0; //empty rectangle
|
|
m.data.l[3] = 0;
|
|
m.data.l[4] = xdnd_action_copy;
|
|
|
|
XSendEvent(x11_display, event.xclient.data.l[0], False, NoEventMask, (XEvent*)&m);
|
|
XFlush(x11_display);
|
|
}
|
|
else if ((unsigned int)event.xclient.message_type == (unsigned int)xdnd_drop) {
|
|
|
|
if (requested != None) {
|
|
xdnd_source_window = event.xclient.data.l[0];
|
|
if(xdnd_version >= 1)
|
|
XConvertSelection(x11_display, xdnd_selection, requested, XInternAtom(x11_display, "PRIMARY", 0), x11_window, event.xclient.data.l[2]);
|
|
else
|
|
XConvertSelection(x11_display, xdnd_selection, requested, XInternAtom(x11_display, "PRIMARY", 0), x11_window, CurrentTime);
|
|
}
|
|
else {
|
|
//Reply that we're not interested.
|
|
XClientMessageEvent m;
|
|
memset(&m, 0, sizeof(m));
|
|
m.type = ClientMessage;
|
|
m.display = event.xclient.display;
|
|
m.window = event.xclient.data.l[0];
|
|
m.message_type = xdnd_finished;
|
|
m.format=32;
|
|
m.data.l[0] = x11_window;
|
|
m.data.l[1] = 0;
|
|
m.data.l[2] = None; //Failed.
|
|
XSendEvent(x11_display, event.xclient.data.l[0], False, NoEventMask, (XEvent*)&m);
|
|
}
|
|
}
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
XFlush(x11_display);
|
|
|
|
if (do_mouse_warp) {
|
|
|
|
XWarpPointer(x11_display, None, x11_window,
|
|
0,0,0,0, (int)current_videomode.width/2, (int)current_videomode.height/2);
|
|
|
|
/*
|
|
Window root, child;
|
|
int root_x, root_y;
|
|
int win_x, win_y;
|
|
unsigned int mask;
|
|
XQueryPointer( x11_display, x11_window, &root, &child, &root_x, &root_y, &win_x, &win_y, &mask );
|
|
|
|
printf("Root: %d,%d\n", root_x, root_y);
|
|
printf("Win: %d,%d\n", win_x, win_y);
|
|
*/
|
|
}
|
|
}
|
|
|
|
MainLoop *OS_X11::get_main_loop() const {
|
|
|
|
return main_loop;
|
|
}
|
|
|
|
void OS_X11::delete_main_loop() {
|
|
|
|
if (main_loop)
|
|
memdelete(main_loop);
|
|
main_loop=NULL;
|
|
}
|
|
|
|
void OS_X11::set_main_loop( MainLoop * p_main_loop ) {
|
|
|
|
main_loop=p_main_loop;
|
|
input->set_main_loop(p_main_loop);
|
|
}
|
|
|
|
bool OS_X11::can_draw() const {
|
|
|
|
return !minimized;
|
|
};
|
|
|
|
void OS_X11::set_clipboard(const String& p_text) {
|
|
|
|
OS::set_clipboard(p_text);
|
|
|
|
XSetSelectionOwner(x11_display, XA_PRIMARY, x11_window, CurrentTime);
|
|
XSetSelectionOwner(x11_display, XInternAtom(x11_display, "CLIPBOARD", 0), x11_window, CurrentTime);
|
|
};
|
|
|
|
static String _get_clipboard(Atom p_source, Window x11_window, ::Display* x11_display, String p_internal_clipboard) {
|
|
|
|
String ret;
|
|
|
|
Atom type;
|
|
Atom selection = XA_PRIMARY;
|
|
int format, result;
|
|
unsigned long len, bytes_left, dummy;
|
|
unsigned char *data;
|
|
Window Sown = XGetSelectionOwner (x11_display, p_source);
|
|
|
|
if (Sown == x11_window) {
|
|
|
|
return p_internal_clipboard;
|
|
};
|
|
|
|
if (Sown != None) {
|
|
XConvertSelection (x11_display, p_source, XA_STRING, selection,
|
|
x11_window, CurrentTime);
|
|
XFlush (x11_display);
|
|
while (true) {
|
|
XEvent event;
|
|
XNextEvent(x11_display, &event);
|
|
if (event.type == SelectionNotify && event.xselection.requestor == x11_window) {
|
|
break;
|
|
};
|
|
};
|
|
|
|
//
|
|
// Do not get any data, see how much data is there
|
|
//
|
|
XGetWindowProperty (x11_display, x11_window,
|
|
selection, // Tricky..
|
|
0, 0, // offset - len
|
|
0, // Delete 0==FALSE
|
|
AnyPropertyType, //flag
|
|
&type, // return type
|
|
&format, // return format
|
|
&len, &bytes_left, //that
|
|
&data);
|
|
// DATA is There
|
|
if (bytes_left > 0)
|
|
{
|
|
result = XGetWindowProperty (x11_display, x11_window,
|
|
selection, 0,bytes_left,0,
|
|
AnyPropertyType, &type,&format,
|
|
&len, &dummy, &data);
|
|
if (result == Success) {
|
|
ret.parse_utf8((const char*)data);
|
|
} else printf ("FAIL\n");
|
|
XFree (data);
|
|
}
|
|
}
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
String OS_X11::get_clipboard() const {
|
|
|
|
String ret;
|
|
ret = _get_clipboard(XInternAtom(x11_display, "CLIPBOARD", 0), x11_window, x11_display, OS::get_clipboard());
|
|
|
|
if (ret == "") {
|
|
ret = _get_clipboard(XA_PRIMARY, x11_window, x11_display, OS::get_clipboard());
|
|
};
|
|
|
|
return ret;
|
|
}
|
|
|
|
String OS_X11::get_name() {
|
|
|
|
return "X11";
|
|
}
|
|
|
|
Error OS_X11::shell_open(String p_uri) {
|
|
|
|
Error ok;
|
|
List<String> args;
|
|
args.push_back(p_uri);
|
|
ok = execute("/usr/bin/xdg-open",args,false);
|
|
if (ok==OK)
|
|
return OK;
|
|
ok = execute("gnome-open",args,false);
|
|
if (ok==OK)
|
|
return OK;
|
|
ok = execute("kde-open",args,false);
|
|
return ok;
|
|
}
|
|
|
|
String OS_X11::get_system_dir(SystemDir p_dir) const {
|
|
|
|
|
|
String xdgparam;
|
|
|
|
switch(p_dir) {
|
|
case SYSTEM_DIR_DESKTOP: {
|
|
|
|
xdgparam="DESKTOP";
|
|
} break;
|
|
case SYSTEM_DIR_DCIM: {
|
|
|
|
xdgparam="PICTURES";
|
|
|
|
} break;
|
|
case SYSTEM_DIR_DOCUMENTS: {
|
|
|
|
xdgparam="DOCUMENTS";
|
|
|
|
} break;
|
|
case SYSTEM_DIR_DOWNLOADS: {
|
|
|
|
xdgparam="DOWNLOAD";
|
|
|
|
} break;
|
|
case SYSTEM_DIR_MOVIES: {
|
|
|
|
xdgparam="VIDEOS";
|
|
|
|
} break;
|
|
case SYSTEM_DIR_MUSIC: {
|
|
|
|
xdgparam="MUSIC";
|
|
|
|
} break;
|
|
case SYSTEM_DIR_PICTURES: {
|
|
|
|
xdgparam="PICTURES";
|
|
|
|
} break;
|
|
case SYSTEM_DIR_RINGTONES: {
|
|
|
|
xdgparam="MUSIC";
|
|
|
|
} break;
|
|
}
|
|
|
|
String pipe;
|
|
List<String> arg;
|
|
arg.push_back(xdgparam);
|
|
Error err = const_cast<OS_X11*>(this)->execute("/usr/bin/xdg-user-dir",arg,true,NULL,&pipe);
|
|
if (err!=OK)
|
|
return ".";
|
|
return pipe.strip_edges();
|
|
}
|
|
|
|
void OS_X11::move_window_to_foreground() {
|
|
|
|
XRaiseWindow(x11_display,x11_window);
|
|
}
|
|
|
|
void OS_X11::set_cursor_shape(CursorShape p_shape) {
|
|
|
|
ERR_FAIL_INDEX(p_shape,CURSOR_MAX);
|
|
|
|
if (p_shape==current_cursor)
|
|
return;
|
|
if (mouse_mode==MOUSE_MODE_VISIBLE) {
|
|
if (cursors[p_shape]!=None)
|
|
XDefineCursor(x11_display,x11_window,cursors[p_shape]);
|
|
else if (cursors[CURSOR_ARROW]!=None)
|
|
XDefineCursor(x11_display,x11_window,cursors[CURSOR_ARROW]);
|
|
}
|
|
|
|
current_cursor=p_shape;
|
|
}
|
|
|
|
|
|
void OS_X11::release_rendering_thread() {
|
|
|
|
context_gl->release_current();
|
|
|
|
}
|
|
|
|
void OS_X11::make_rendering_thread() {
|
|
|
|
context_gl->make_current();
|
|
}
|
|
|
|
void OS_X11::swap_buffers() {
|
|
|
|
context_gl->swap_buffers();
|
|
}
|
|
|
|
void OS_X11::alert(const String& p_alert,const String& p_title) {
|
|
|
|
List<String> args;
|
|
args.push_back("-center");
|
|
args.push_back("-title");
|
|
args.push_back(p_title);
|
|
args.push_back(p_alert);
|
|
|
|
execute("/usr/bin/xmessage",args,true);
|
|
}
|
|
|
|
void OS_X11::set_icon(const Image& p_icon) {
|
|
Atom net_wm_icon = XInternAtom(x11_display, "_NET_WM_ICON", False);
|
|
|
|
if (!p_icon.empty()) {
|
|
Image img=p_icon;
|
|
img.convert(Image::FORMAT_RGBA);
|
|
|
|
int w = img.get_width();
|
|
int h = img.get_height();
|
|
|
|
// We're using long to have wordsize (32Bit build -> 32 Bits, 64 Bit build -> 64 Bits
|
|
Vector<long> pd;
|
|
|
|
pd.resize(2+w*h);
|
|
|
|
pd[0]=w;
|
|
pd[1]=h;
|
|
|
|
DVector<uint8_t>::Read r = img.get_data().read();
|
|
|
|
long * wr = &pd[2];
|
|
uint8_t const * pr = r.ptr();
|
|
|
|
for(int i=0;i<w*h;i++) {
|
|
long v=0;
|
|
// A R G B
|
|
v|=pr[3] << 24 | pr[0] << 16 | pr[1] << 8 | pr[2];
|
|
*wr++=v;
|
|
pr += 4;
|
|
}
|
|
XChangeProperty(x11_display, x11_window, net_wm_icon, XA_CARDINAL, 32, PropModeReplace, (unsigned char*) pd.ptr(), pd.size());
|
|
} else {
|
|
XDeleteProperty(x11_display, x11_window, net_wm_icon);
|
|
}
|
|
XFlush(x11_display);
|
|
}
|
|
|
|
|
|
void OS_X11::run() {
|
|
|
|
force_quit = false;
|
|
|
|
if (!main_loop)
|
|
return;
|
|
|
|
main_loop->init();
|
|
|
|
// uint64_t last_ticks=get_ticks_usec();
|
|
|
|
// int frames=0;
|
|
// uint64_t frame=0;
|
|
|
|
while (!force_quit) {
|
|
|
|
process_xevents(); // get rid of pending events
|
|
#ifdef JOYDEV_ENABLED
|
|
event_id = joystick->process_joysticks(event_id);
|
|
#endif
|
|
if (Main::iteration()==true)
|
|
break;
|
|
};
|
|
|
|
main_loop->finish();
|
|
}
|
|
|
|
bool OS_X11::is_joy_known(int p_device) {
|
|
return input->is_joy_mapped(p_device);
|
|
}
|
|
|
|
String OS_X11::get_joy_guid(int p_device) const {
|
|
return input->get_joy_guid_remapped(p_device);
|
|
}
|
|
|
|
void OS_X11::set_use_vsync(bool p_enable) {
|
|
if (context_gl)
|
|
return context_gl->set_use_vsync(p_enable);
|
|
}
|
|
|
|
bool OS_X11::is_vsync_enabled() const {
|
|
|
|
if (context_gl)
|
|
return context_gl->is_using_vsync();
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
void OS_X11::set_context(int p_context) {
|
|
|
|
XClassHint* classHint = NULL;
|
|
classHint = XAllocClassHint();
|
|
if (classHint) {
|
|
|
|
if (p_context == CONTEXT_EDITOR)
|
|
classHint->res_name = (char *)"Godot_Editor";
|
|
if (p_context == CONTEXT_PROJECTMAN)
|
|
classHint->res_name = (char *)"Godot_ProjectList";
|
|
classHint->res_class = (char *)"Godot";
|
|
XSetClassHint(x11_display, x11_window, classHint);
|
|
XFree(classHint);
|
|
}
|
|
}
|
|
|
|
OS_X11::OS_X11() {
|
|
|
|
#ifdef RTAUDIO_ENABLED
|
|
AudioDriverManagerSW::add_driver(&driver_rtaudio);
|
|
#endif
|
|
|
|
#ifdef PULSEAUDIO_ENABLED
|
|
AudioDriverManagerSW::add_driver(&driver_pulseaudio);
|
|
#endif
|
|
|
|
#ifdef ALSA_ENABLED
|
|
AudioDriverManagerSW::add_driver(&driver_alsa);
|
|
#endif
|
|
|
|
if(AudioDriverManagerSW::get_driver_count() == 0){
|
|
WARN_PRINT("No sound driver found... Defaulting to dummy driver");
|
|
AudioDriverManagerSW::add_driver(&driver_dummy);
|
|
}
|
|
|
|
minimized = false;
|
|
xim_style=0L;
|
|
mouse_mode=MOUSE_MODE_VISIBLE;
|
|
}
|