aboutsummaryrefslogtreecommitdiff
path: root/platform/x11
diff options
context:
space:
mode:
Diffstat (limited to '')
-rw-r--r--platform/x11/context_gl_x11.cpp101
-rw-r--r--platform/x11/context_gl_x11.h15
-rw-r--r--platform/x11/export/export.cpp7
-rw-r--r--platform/x11/godot_x11.cpp10
-rw-r--r--platform/x11/joystick_linux.cpp148
-rw-r--r--platform/x11/joystick_linux.h11
-rw-r--r--platform/x11/key_mapping_x11.cpp340
-rw-r--r--platform/x11/key_mapping_x11.h7
-rw-r--r--platform/x11/os_x11.cpp1332
-rw-r--r--platform/x11/os_x11.h99
10 files changed, 1003 insertions, 1067 deletions
diff --git a/platform/x11/context_gl_x11.cpp b/platform/x11/context_gl_x11.cpp
index 776a4dc7e..1c255f7e4 100644
--- a/platform/x11/context_gl_x11.cpp
+++ b/platform/x11/context_gl_x11.cpp
@@ -31,17 +31,17 @@
#ifdef X11_ENABLED
#if defined(OPENGL_ENABLED) || defined(LEGACYGL_ENABLED)
#include <stdio.h>
-#include <unistd.h>
#include <stdlib.h>
+#include <unistd.h>
#define GLX_GLXEXT_PROTOTYPES
#include <GL/glx.h>
#include <GL/glxext.h>
-#define GLX_CONTEXT_MAJOR_VERSION_ARB 0x2091
-#define GLX_CONTEXT_MINOR_VERSION_ARB 0x2092
+#define GLX_CONTEXT_MAJOR_VERSION_ARB 0x2091
+#define GLX_CONTEXT_MINOR_VERSION_ARB 0x2092
-typedef GLXContext (*GLXCREATECONTEXTATTRIBSARBPROC)(Display*, GLXFBConfig, GLXContext, Bool, const int*);
+typedef GLXContext (*GLXCREATECONTEXTATTRIBSARBPROC)(Display *, GLXFBConfig, GLXContext, Bool, const int *);
struct ContextGL_X11_Private {
@@ -60,7 +60,7 @@ void ContextGL_X11::make_current() {
void ContextGL_X11::swap_buffers() {
- glXSwapBuffers(x11_display,x11_window);
+ glXSwapBuffers(x11_display, x11_window);
}
/*
@@ -78,30 +78,28 @@ static GLWrapperFuncPtr wrapper_get_proc_address(const char* p_function) {
Error ContextGL_X11::initialize() {
-
GLXCREATECONTEXTATTRIBSARBPROC glXCreateContextAttribsARB = NULL;
-// const char *extensions = glXQueryExtensionsString(x11_display, DefaultScreen(x11_display));
-
- glXCreateContextAttribsARB = (GLXCREATECONTEXTATTRIBSARBPROC)glXGetProcAddress((const GLubyte*)"glXCreateContextAttribsARB");
+ // const char *extensions = glXQueryExtensionsString(x11_display, DefaultScreen(x11_display));
- ERR_FAIL_COND_V( !glXCreateContextAttribsARB, ERR_UNCONFIGURED );
+ glXCreateContextAttribsARB = (GLXCREATECONTEXTATTRIBSARBPROC)glXGetProcAddress((const GLubyte *)"glXCreateContextAttribsARB");
+ ERR_FAIL_COND_V(!glXCreateContextAttribsARB, ERR_UNCONFIGURED);
static int visual_attribs[] = {
- GLX_RENDER_TYPE, GLX_RGBA_BIT,
- GLX_DRAWABLE_TYPE, GLX_WINDOW_BIT,
- GLX_DOUBLEBUFFER, true,
- GLX_RED_SIZE, 1,
- GLX_GREEN_SIZE, 1,
- GLX_BLUE_SIZE, 1,
- GLX_DEPTH_SIZE, 24,
- None
+ GLX_RENDER_TYPE, GLX_RGBA_BIT,
+ GLX_DRAWABLE_TYPE, GLX_WINDOW_BIT,
+ GLX_DOUBLEBUFFER, true,
+ GLX_RED_SIZE, 1,
+ GLX_GREEN_SIZE, 1,
+ GLX_BLUE_SIZE, 1,
+ GLX_DEPTH_SIZE, 24,
+ None
};
int fbcount;
GLXFBConfig *fbc = glXChooseFBConfig(x11_display, DefaultScreen(x11_display), visual_attribs, &fbcount);
- ERR_FAIL_COND_V(!fbc,ERR_UNCONFIGURED);
+ ERR_FAIL_COND_V(!fbc, ERR_UNCONFIGURED);
XVisualInfo *vi = glXGetVisualFromFBConfig(x11_display, fbc[0]);
@@ -120,11 +118,10 @@ Error ContextGL_X11::initialize() {
x11_window = atol(windowid);
} else {
*/
- x11_window = XCreateWindow(x11_display, RootWindow(x11_display, vi->screen), 0, 0, OS::get_singleton()->get_video_mode().width, OS::get_singleton()->get_video_mode().height, 0, vi->depth, InputOutput, vi->visual, CWBorderPixel|CWColormap|CWEventMask, &swa);
- ERR_FAIL_COND_V(!x11_window,ERR_UNCONFIGURED);
- XMapWindow(x11_display, x11_window);
- //};
-
+ x11_window = XCreateWindow(x11_display, RootWindow(x11_display, vi->screen), 0, 0, OS::get_singleton()->get_video_mode().width, OS::get_singleton()->get_video_mode().height, 0, vi->depth, InputOutput, vi->visual, CWBorderPixel | CWColormap | CWEventMask, &swa);
+ ERR_FAIL_COND_V(!x11_window, ERR_UNCONFIGURED);
+ XMapWindow(x11_display, x11_window);
+ //};
if (!opengl_3_context) {
//oldstyle context:
@@ -137,7 +134,7 @@ Error ContextGL_X11::initialize() {
};
p->glx_context = glXCreateContextAttribsARB(x11_display, fbc[0], NULL, true, context_attribs);
- ERR_FAIL_COND_V(!p->glx_context,ERR_UNCONFIGURED);
+ ERR_FAIL_COND_V(!p->glx_context, ERR_UNCONFIGURED);
}
glXMakeCurrent(x11_display, x11_window, p->glx_context);
@@ -150,8 +147,8 @@ Error ContextGL_X11::initialize() {
*/
//glXMakeCurrent(x11_display, None, NULL);
- XFree( vi );
- XFree( fbc );
+ XFree(vi);
+ XFree(fbc);
return OK;
}
@@ -159,14 +156,14 @@ Error ContextGL_X11::initialize() {
int ContextGL_X11::get_window_width() {
XWindowAttributes xwa;
- XGetWindowAttributes(x11_display,x11_window,&xwa);
+ XGetWindowAttributes(x11_display, x11_window, &xwa);
return xwa.width;
}
int ContextGL_X11::get_window_height() {
XWindowAttributes xwa;
- XGetWindowAttributes(x11_display,x11_window,&xwa);
+ XGetWindowAttributes(x11_display, x11_window, &xwa);
return xwa.height;
}
@@ -181,24 +178,22 @@ void ContextGL_X11::set_use_vsync(bool p_use) {
setup = true;
String extensions = glXQueryExtensionsString(x11_display, DefaultScreen(x11_display));
if (extensions.find("GLX_EXT_swap_control") != -1)
- glXSwapIntervalEXT = (PFNGLXSWAPINTERVALEXTPROC) glXGetProcAddressARB((const GLubyte*)"glXSwapIntervalEXT");
+ glXSwapIntervalEXT = (PFNGLXSWAPINTERVALEXTPROC)glXGetProcAddressARB((const GLubyte *)"glXSwapIntervalEXT");
if (extensions.find("GLX_MESA_swap_control") != -1)
- glXSwapIntervalMESA = (PFNGLXSWAPINTERVALSGIPROC) glXGetProcAddressARB((const GLubyte*)"glXSwapIntervalMESA");
+ glXSwapIntervalMESA = (PFNGLXSWAPINTERVALSGIPROC)glXGetProcAddressARB((const GLubyte *)"glXSwapIntervalMESA");
if (extensions.find("GLX_SGI_swap_control") != -1)
- glXSwapIntervalSGI = (PFNGLXSWAPINTERVALSGIPROC) glXGetProcAddressARB((const GLubyte*)"glXSwapIntervalSGI");
+ glXSwapIntervalSGI = (PFNGLXSWAPINTERVALSGIPROC)glXGetProcAddressARB((const GLubyte *)"glXSwapIntervalSGI");
}
- int val = p_use ? 1:0;
+ int val = p_use ? 1 : 0;
if (glXSwapIntervalMESA) {
glXSwapIntervalMESA(val);
- }
- else if (glXSwapIntervalSGI) {
+ } else if (glXSwapIntervalSGI) {
glXSwapIntervalSGI(val);
- }
- else if (glXSwapIntervalEXT) {
+ } else if (glXSwapIntervalEXT) {
GLXDrawable drawable = glXGetCurrentDrawable();
glXSwapIntervalEXT(x11_display, drawable, val);
- }
- else return;
+ } else
+ return;
use_vsync = p_use;
}
bool ContextGL_X11::is_using_vsync() const {
@@ -206,30 +201,28 @@ bool ContextGL_X11::is_using_vsync() const {
return use_vsync;
}
+ContextGL_X11::ContextGL_X11(::Display *p_x11_display, ::Window &p_x11_window, const OS::VideoMode &p_default_video_mode, bool p_opengl_3_context)
+ : x11_window(p_x11_window) {
-ContextGL_X11::ContextGL_X11(::Display *p_x11_display,::Window &p_x11_window,const OS::VideoMode& p_default_video_mode,bool p_opengl_3_context) : x11_window(p_x11_window) {
+ default_video_mode = p_default_video_mode;
+ x11_display = p_x11_display;
- default_video_mode=p_default_video_mode;
- x11_display=p_x11_display;
+ opengl_3_context = p_opengl_3_context;
- opengl_3_context=p_opengl_3_context;
-
- double_buffer=false;
- direct_render=false;
- glx_minor=glx_major=0;
- p = memnew( ContextGL_X11_Private );
- p->glx_context=0;
- use_vsync=false;
+ double_buffer = false;
+ direct_render = false;
+ glx_minor = glx_major = 0;
+ p = memnew(ContextGL_X11_Private);
+ p->glx_context = 0;
+ use_vsync = false;
}
-
ContextGL_X11::~ContextGL_X11() {
release_current();
- glXDestroyContext( x11_display, p->glx_context );
+ glXDestroyContext(x11_display, p->glx_context);
- memdelete( p );
+ memdelete(p);
}
-
#endif
#endif
diff --git a/platform/x11/context_gl_x11.h b/platform/x11/context_gl_x11.h
index efe377ad9..a4411bc33 100644
--- a/platform/x11/context_gl_x11.h
+++ b/platform/x11/context_gl_x11.h
@@ -36,10 +36,8 @@
#if defined(OPENGL_ENABLED) || defined(LEGACYGL_ENABLED)
-
-
-#include "os/os.h"
#include "drivers/gl_context/context_gl.h"
+#include "os/os.h"
#include <X11/Xlib.h>
struct ContextGL_X11_Private;
@@ -48,16 +46,16 @@ class ContextGL_X11 : public ContextGL {
ContextGL_X11_Private *p;
OS::VideoMode default_video_mode;
-// ::Colormap x11_colormap;
+ // ::Colormap x11_colormap;
::Display *x11_display;
- ::Window& x11_window;
+ ::Window &x11_window;
bool double_buffer;
bool direct_render;
- int glx_minor,glx_major;
+ int glx_minor, glx_major;
bool opengl_3_context;
bool use_vsync;
-public:
+public:
virtual void release_current();
virtual void make_current();
virtual void swap_buffers();
@@ -69,9 +67,8 @@ public:
virtual void set_use_vsync(bool p_use);
virtual bool is_using_vsync() const;
- ContextGL_X11(::Display *p_x11_display,::Window &p_x11_window,const OS::VideoMode& p_default_video_mode,bool p_opengl_3_context);
+ ContextGL_X11(::Display *p_x11_display, ::Window &p_x11_window, const OS::VideoMode &p_default_video_mode, bool p_opengl_3_context);
~ContextGL_X11();
-
};
#endif
diff --git a/platform/x11/export/export.cpp b/platform/x11/export/export.cpp
index 393946322..79d3722e6 100644
--- a/platform/x11/export/export.cpp
+++ b/platform/x11/export/export.cpp
@@ -27,18 +27,18 @@
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
/*************************************************************************/
#include "export.h"
-#include "platform/x11/logo.h"
#include "editor/editor_import_export.h"
+#include "platform/x11/logo.h"
#include "scene/resources/texture.h"
void register_x11_exporter() {
Image img(_x11_logo);
- Ref<ImageTexture> logo = memnew( ImageTexture );
+ Ref<ImageTexture> logo = memnew(ImageTexture);
logo->create_from_image(img);
{
- Ref<EditorExportPlatformPC> exporter = Ref<EditorExportPlatformPC>( memnew(EditorExportPlatformPC) );
+ Ref<EditorExportPlatformPC> exporter = Ref<EditorExportPlatformPC>(memnew(EditorExportPlatformPC));
exporter->set_binary_extension("");
exporter->set_release_binary32("linux_x11_32_release");
exporter->set_debug_binary32("linux_x11_32_debug");
@@ -48,5 +48,4 @@ void register_x11_exporter() {
exporter->set_logo(logo);
EditorImportExport::get_singleton()->add_export_platform(exporter);
}
-
}
diff --git a/platform/x11/godot_x11.cpp b/platform/x11/godot_x11.cpp
index adb919c2f..078baf76e 100644
--- a/platform/x11/godot_x11.cpp
+++ b/platform/x11/godot_x11.cpp
@@ -26,22 +26,22 @@
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
/*************************************************************************/
-#include <unistd.h>
#include <limits.h>
#include <stdlib.h>
+#include <unistd.h>
#include "main/main.h"
#include "os_x11.h"
-int main(int argc, char* argv[]) {
+int main(int argc, char *argv[]) {
OS_X11 os;
- char *cwd = (char*)malloc(PATH_MAX);
+ char *cwd = (char *)malloc(PATH_MAX);
getcwd(cwd, PATH_MAX);
- Error err = Main::setup(argv[0],argc-1,&argv[1]);
- if (err!=OK)
+ Error err = Main::setup(argv[0], argc - 1, &argv[1]);
+ if (err != OK)
return 255;
if (Main::start())
diff --git a/platform/x11/joystick_linux.cpp b/platform/x11/joystick_linux.cpp
index d101a725a..1e2cf2563 100644
--- a/platform/x11/joystick_linux.cpp
+++ b/platform/x11/joystick_linux.cpp
@@ -32,21 +32,21 @@
#include "joystick_linux.h"
+#include <errno.h>
+#include <fcntl.h>
#include <linux/input.h>
#include <unistd.h>
-#include <fcntl.h>
-#include <errno.h>
#ifdef UDEV_ENABLED
#include <libudev.h>
#endif
-#define LONG_BITS (sizeof(long) * 8)
-#define test_bit(nr, addr) (((1UL << ((nr) % LONG_BITS)) & ((addr)[(nr) / LONG_BITS])) != 0)
-#define NBITS(x) ((((x)-1)/LONG_BITS)+1)
+#define LONG_BITS (sizeof(long) * 8)
+#define test_bit(nr, addr) (((1UL << ((nr) % LONG_BITS)) & ((addr)[(nr) / LONG_BITS])) != 0)
+#define NBITS(x) ((((x)-1) / LONG_BITS) + 1)
#ifdef UDEV_ENABLED
-static const char* ignore_str = "/dev/input/js";
+static const char *ignore_str = "/dev/input/js";
#endif
joystick_linux::Joystick::Joystick() {
@@ -68,20 +68,19 @@ joystick_linux::Joystick::~Joystick() {
}
void joystick_linux::Joystick::reset() {
- dpad = 0;
- fd = -1;
+ dpad = 0;
+ fd = -1;
InputDefault::JoyAxis jx;
jx.min = -1;
jx.value = 0.0f;
- for (int i=0; i < MAX_ABS; i++) {
+ for (int i = 0; i < MAX_ABS; i++) {
abs_map[i] = -1;
curr_axis[i] = jx;
}
}
-joystick_linux::joystick_linux(InputDefault *in)
-{
+joystick_linux::joystick_linux(InputDefault *in) {
exit_udev = false;
input = in;
joy_mutex = Mutex::create();
@@ -99,7 +98,7 @@ joystick_linux::~joystick_linux() {
void joystick_linux::joy_thread_func(void *p_user) {
if (p_user) {
- joystick_linux* joy = (joystick_linux*) p_user;
+ joystick_linux *joy = (joystick_linux *)p_user;
joy->run_joystick_thread();
}
return;
@@ -125,16 +124,16 @@ void joystick_linux::enumerate_joysticks(udev *p_udev) {
udev_device *dev;
enumerate = udev_enumerate_new(p_udev);
- udev_enumerate_add_match_subsystem(enumerate,"input");
+ udev_enumerate_add_match_subsystem(enumerate, "input");
udev_enumerate_add_match_property(enumerate, "ID_INPUT_JOYSTICK", "1");
udev_enumerate_scan_devices(enumerate);
devices = udev_enumerate_get_list_entry(enumerate);
udev_list_entry_foreach(dev_list_entry, devices) {
- const char* path = udev_list_entry_get_name(dev_list_entry);
+ const char *path = udev_list_entry_get_name(dev_list_entry);
dev = udev_device_new_from_syspath(p_udev, path);
- const char* devnode = udev_device_get_devnode(dev);
+ const char *devnode = udev_device_get_devnode(dev);
if (devnode) {
@@ -169,7 +168,7 @@ void joystick_linux::monitor_joysticks(udev *p_udev) {
tv.tv_sec = 0;
tv.tv_usec = 0;
- ret = select(fd+1, &fds, NULL, NULL, &tv);
+ ret = select(fd + 1, &fds, NULL, NULL, &tv);
/* Check if our file descriptor has received data. */
if (ret > 0 && FD_ISSET(fd, &fds)) {
@@ -181,7 +180,7 @@ void joystick_linux::monitor_joysticks(udev *p_udev) {
joy_mutex->lock();
String action = udev_device_get_action(dev);
- const char* devnode = udev_device_get_devnode(dev);
+ const char *devnode = udev_device_get_devnode(dev);
if (devnode) {
String devnode_str = devnode;
@@ -242,13 +241,13 @@ int joystick_linux::get_joy_from_path(String p_path) const {
void joystick_linux::close_joystick(int p_id) {
if (p_id == -1) {
- for (int i=0; i<JOYSTICKS_MAX; i++) {
+ for (int i = 0; i < JOYSTICKS_MAX; i++) {
close_joystick(i);
};
return;
- }
- else if (p_id < 0) return;
+ } else if (p_id < 0)
+ return;
Joystick &joy = joysticks[p_id];
@@ -263,11 +262,11 @@ void joystick_linux::close_joystick(int p_id) {
static String _hex_str(uint8_t p_byte) {
- static const char* dict = "0123456789abcdef";
+ static const char *dict = "0123456789abcdef";
char ret[3];
ret[2] = 0;
- ret[0] = dict[p_byte>>4];
+ ret[0] = dict[p_byte >> 4];
ret[1] = dict[p_byte & 0xF];
return ret;
@@ -275,7 +274,7 @@ static String _hex_str(uint8_t p_byte) {
void joystick_linux::setup_joystick_properties(int p_id) {
- Joystick* joy = &joysticks[p_id];
+ Joystick *joy = &joysticks[p_id];
unsigned long keybit[NBITS(KEY_MAX)] = { 0 };
unsigned long absbit[NBITS(ABS_MAX)] = { 0 };
@@ -284,7 +283,7 @@ void joystick_linux::setup_joystick_properties(int p_id) {
int num_axes = 0;
if ((ioctl(joy->fd, EVIOCGBIT(EV_KEY, sizeof(keybit)), keybit) < 0) ||
- (ioctl(joy->fd, EVIOCGBIT(EV_ABS, sizeof(absbit)), absbit) < 0)) {
+ (ioctl(joy->fd, EVIOCGBIT(EV_ABS, sizeof(absbit)), absbit) < 0)) {
return;
}
for (int i = BTN_JOYSTICK; i < KEY_MAX; ++i) {
@@ -342,8 +341,8 @@ void joystick_linux::open_joystick(const char *p_path) {
attached_devices.push_back(String(p_path));
if ((ioctl(fd, EVIOCGBIT(0, sizeof(evbit)), evbit) < 0) ||
- (ioctl(fd, EVIOCGBIT(EV_KEY, sizeof(keybit)), keybit) < 0) ||
- (ioctl(fd, EVIOCGBIT(EV_ABS, sizeof(absbit)), absbit) < 0)) {
+ (ioctl(fd, EVIOCGBIT(EV_KEY, sizeof(keybit)), keybit) < 0) ||
+ (ioctl(fd, EVIOCGBIT(EV_ABS, sizeof(absbit)), absbit) < 0)) {
close(fd);
return;
}
@@ -351,10 +350,10 @@ void joystick_linux::open_joystick(const char *p_path) {
//check if the device supports basic gamepad events, prevents certain keyboards from
//being detected as joysticks
if (!(test_bit(EV_KEY, evbit) && test_bit(EV_ABS, evbit) &&
- (test_bit(ABS_X, absbit) || test_bit(ABS_Y, absbit) || test_bit(ABS_HAT0X, absbit) ||
- test_bit(ABS_GAS, absbit) || test_bit(ABS_RUDDER, absbit)) &&
- (test_bit(BTN_A, keybit) || test_bit(BTN_THUMBL, keybit) ||
- test_bit(BTN_TRIGGER, keybit) || test_bit(BTN_1, keybit)))) {
+ (test_bit(ABS_X, absbit) || test_bit(ABS_Y, absbit) || test_bit(ABS_HAT0X, absbit) ||
+ test_bit(ABS_GAS, absbit) || test_bit(ABS_RUDDER, absbit)) &&
+ (test_bit(BTN_A, keybit) || test_bit(BTN_THUMBL, keybit) ||
+ test_bit(BTN_TRIGGER, keybit) || test_bit(BTN_1, keybit)))) {
close(fd);
return;
}
@@ -385,13 +384,12 @@ void joystick_linux::open_joystick(const char *p_path) {
uint16_t product = __bswap_16(inpid.product);
uint16_t version = __bswap_16(inpid.version);
- sprintf(uid + String(uid).length(), "%04x%04x%04x%04x%04x%04x", vendor,0,product,0,version,0);
+ sprintf(uid + String(uid).length(), "%04x%04x%04x%04x%04x%04x", vendor, 0, product, 0, version, 0);
input->joy_connection_changed(joy_num, true, name, uid);
- }
- else {
+ } else {
String uidname = uid;
int uidlen = MIN(name.length(), 11);
- for (int i=0; i<uidlen; i++) {
+ for (int i = 0; i < uidlen; i++) {
uidname = uidname + _hex_str(name[i]);
}
@@ -401,9 +399,8 @@ void joystick_linux::open_joystick(const char *p_path) {
}
}
-void joystick_linux::joystick_vibration_start(int p_id, float p_weak_magnitude, float p_strong_magnitude, float p_duration, uint64_t p_timestamp)
-{
- Joystick& joy = joysticks[p_id];
+void joystick_linux::joystick_vibration_start(int p_id, float p_weak_magnitude, float p_strong_magnitude, float p_duration, uint64_t p_timestamp) {
+ Joystick &joy = joysticks[p_id];
if (!joy.force_feedback || joy.fd == -1 || p_weak_magnitude < 0.f || p_weak_magnitude > 1.f || p_strong_magnitude < 0.f || p_strong_magnitude > 1.f) {
return;
}
@@ -427,15 +424,14 @@ void joystick_linux::joystick_vibration_start(int p_id, float p_weak_magnitude,
play.type = EV_FF;
play.code = effect.id;
play.value = 1;
- write(joy.fd, (const void*)&play, sizeof(play));
+ write(joy.fd, (const void *)&play, sizeof(play));
joy.ff_effect_id = effect.id;
joy.ff_effect_timestamp = p_timestamp;
}
-void joystick_linux::joystick_vibration_stop(int p_id, uint64_t p_timestamp)
-{
- Joystick& joy = joysticks[p_id];
+void joystick_linux::joystick_vibration_stop(int p_id, uint64_t p_timestamp) {
+ Joystick &joy = joysticks[p_id];
if (!joy.force_feedback || joy.fd == -1 || joy.ff_effect_id == -1) {
return;
}
@@ -457,13 +453,13 @@ InputDefault::JoyAxis joystick_linux::axis_correct(const input_absinfo *p_abs, i
if (min < 0) {
jx.min = -1;
if (p_value < 0) {
- jx.value = (float) -p_value / min;
+ jx.value = (float)-p_value / min;
}
- jx.value = (float) p_value / max;
+ jx.value = (float)p_value / max;
}
if (min == 0) {
jx.min = 0;
- jx.value = 0.0f + (float) p_value / max;
+ jx.value = 0.0f + (float)p_value / max;
}
return jx;
}
@@ -473,12 +469,12 @@ uint32_t joystick_linux::process_joysticks(uint32_t p_event_id) {
if (joy_mutex->try_lock() != OK) {
return p_event_id;
}
- for (int i=0; i<JOYSTICKS_MAX; i++) {
+ for (int i = 0; i < JOYSTICKS_MAX; i++) {
if (joysticks[i].fd == -1) continue;
input_event events[32];
- Joystick* joy = &joysticks[i];
+ Joystick *joy = &joysticks[i];
int len;
@@ -490,45 +486,49 @@ uint32_t joystick_linux::process_joysticks(uint32_t p_event_id) {
// ev may be tainted and out of MAX_KEY range, which will cause
// joy->key_map[ev.code] to crash
- if( ev.code < 0 || ev.code >= MAX_KEY )
+ if (ev.code < 0 || ev.code >= MAX_KEY)
return p_event_id;
switch (ev.type) {
- case EV_KEY:
- p_event_id = input->joy_button(p_event_id, i, joy->key_map[ev.code], ev.value);
- break;
+ case EV_KEY:
+ p_event_id = input->joy_button(p_event_id, i, joy->key_map[ev.code], ev.value);
+ break;
- case EV_ABS:
+ case EV_ABS:
- switch (ev.code) {
- case ABS_HAT0X:
- if (ev.value != 0) {
- if (ev.value < 0) joy->dpad |= InputDefault::HAT_MASK_LEFT;
- else joy->dpad |= InputDefault::HAT_MASK_RIGHT;
- }
- else joy->dpad &= ~(InputDefault::HAT_MASK_LEFT | InputDefault::HAT_MASK_RIGHT);
+ switch (ev.code) {
+ case ABS_HAT0X:
+ if (ev.value != 0) {
+ if (ev.value < 0)
+ joy->dpad |= InputDefault::HAT_MASK_LEFT;
+ else
+ joy->dpad |= InputDefault::HAT_MASK_RIGHT;
+ } else
+ joy->dpad &= ~(InputDefault::HAT_MASK_LEFT | InputDefault::HAT_MASK_RIGHT);
- p_event_id = input->joy_hat(p_event_id, i, joy->dpad);
- break;
+ p_event_id = input->joy_hat(p_event_id, i, joy->dpad);
+ break;
- case ABS_HAT0Y:
- if (ev.value != 0) {
- if (ev.value < 0) joy->dpad |= InputDefault::HAT_MASK_UP;
- else joy->dpad |= InputDefault::HAT_MASK_DOWN;
- }
- else joy->dpad &= ~(InputDefault::HAT_MASK_UP | InputDefault::HAT_MASK_DOWN);
+ case ABS_HAT0Y:
+ if (ev.value != 0) {
+ if (ev.value < 0)
+ joy->dpad |= InputDefault::HAT_MASK_UP;
+ else
+ joy->dpad |= InputDefault::HAT_MASK_DOWN;
+ } else
+ joy->dpad &= ~(InputDefault::HAT_MASK_UP | InputDefault::HAT_MASK_DOWN);
- p_event_id = input->joy_hat(p_event_id, i, joy->dpad);
- break;
+ p_event_id = input->joy_hat(p_event_id, i, joy->dpad);
+ break;
- default:
- if (joy->abs_map[ev.code] != -1 && joy->abs_info[ev.code]) {
- InputDefault::JoyAxis value = axis_correct(joy->abs_info[ev.code], ev.value);
- joy->curr_axis[joy->abs_map[ev.code]] = value;
+ default:
+ if (joy->abs_map[ev.code] != -1 && joy->abs_info[ev.code]) {
+ InputDefault::JoyAxis value = axis_correct(joy->abs_info[ev.code], ev.value);
+ joy->curr_axis[joy->abs_map[ev.code]] = value;
+ }
+ break;
}
break;
- }
- break;
}
}
}
diff --git a/platform/x11/joystick_linux.h b/platform/x11/joystick_linux.h
index 34e7001ca..4d3f16d1a 100644
--- a/platform/x11/joystick_linux.h
+++ b/platform/x11/joystick_linux.h
@@ -32,23 +32,22 @@
#define JOYSTICK_LINUX_H
#ifdef JOYDEV_ENABLED
#include "main/input_default.h"
-#include "os/thread.h"
#include "os/mutex.h"
+#include "os/thread.h"
struct input_absinfo;
-class joystick_linux
-{
+class joystick_linux {
public:
joystick_linux(InputDefault *in);
~joystick_linux();
uint32_t process_joysticks(uint32_t p_event_id);
-private:
+private:
enum {
JOYSTICKS_MAX = 16,
MAX_ABS = 63,
- MAX_KEY = 767, // Hack because <linux/input.h> can't be included here
+ MAX_KEY = 767, // Hack because <linux/input.h> can't be included here
};
struct Joystick {
@@ -90,7 +89,7 @@ private:
#endif
void monitor_joysticks();
void run_joystick_thread();
- void open_joystick(const char* path);
+ void open_joystick(const char *path);
void joystick_vibration_start(int p_id, float p_weak_magnitude, float p_strong_magnitude, float p_duration, uint64_t p_timestamp);
void joystick_vibration_stop(int p_id, uint64_t p_timestamp);
diff --git a/platform/x11/key_mapping_x11.cpp b/platform/x11/key_mapping_x11.cpp
index 7b92ed95d..411b40125 100644
--- a/platform/x11/key_mapping_x11.cpp
+++ b/platform/x11/key_mapping_x11.cpp
@@ -28,7 +28,6 @@
/*************************************************************************/
#include "key_mapping_x11.h"
-
/***** SCAN CODE CONVERSION ******/
struct _XTranslatePair {
@@ -37,162 +36,161 @@ struct _XTranslatePair {
unsigned int keycode;
};
-static _XTranslatePair _xkeysym_to_keycode[]={
- // misc keys
+static _XTranslatePair _xkeysym_to_keycode[] = {
+ // misc keys
- { XK_Escape, KEY_ESCAPE },
- { XK_Tab, KEY_TAB },
- { XK_ISO_Left_Tab, KEY_BACKTAB },
- { XK_BackSpace, KEY_BACKSPACE },
- { XK_Return, KEY_RETURN },
- { XK_Insert, KEY_INSERT },
- { XK_Delete, KEY_DELETE },
- { XK_Clear, KEY_DELETE },
- { XK_Pause, KEY_PAUSE },
- { XK_Print, KEY_PRINT },
- { XK_Home, KEY_HOME },
- { XK_End, KEY_END },
- { XK_Left, KEY_LEFT },
- { XK_Up, KEY_UP },
- { XK_Right, KEY_RIGHT },
- { XK_Down, KEY_DOWN },
- { XK_Prior, KEY_PAGEUP },
- { XK_Next, KEY_PAGEDOWN },
- { XK_Shift_L, KEY_SHIFT },
- { XK_Shift_R, KEY_SHIFT },
- { XK_Shift_Lock, KEY_SHIFT },
- { XK_Control_L, KEY_CONTROL },
- { XK_Control_R, KEY_CONTROL },
- { XK_Meta_L, KEY_META },
- { XK_Meta_R, KEY_META },
- { XK_Alt_L, KEY_ALT },
- { XK_Alt_R, KEY_ALT },
- { XK_Caps_Lock, KEY_CAPSLOCK },
- { XK_Num_Lock, KEY_NUMLOCK },
- { XK_Scroll_Lock, KEY_SCROLLLOCK },
- { XK_Super_L, KEY_SUPER_L },
- { XK_Super_R, KEY_SUPER_R },
- { XK_Menu, KEY_MENU },
- { XK_Hyper_L, KEY_HYPER_L },
- { XK_Hyper_R, KEY_HYPER_R },
- { XK_Help, KEY_HELP },
- { XK_KP_Space, KEY_SPACE },
- { XK_KP_Tab, KEY_TAB },
- { XK_KP_Enter, KEY_ENTER },
- { XK_Home, KEY_HOME },
- { XK_Left, KEY_LEFT },
- { XK_Up, KEY_UP },
- { XK_Right, KEY_RIGHT },
- { XK_Down, KEY_DOWN },
- { XK_Prior, KEY_PAGEUP },
- { XK_Next, KEY_PAGEDOWN },
- { XK_End, KEY_END },
- { XK_Begin, KEY_CLEAR },
- { XK_Insert, KEY_INSERT },
- { XK_Delete, KEY_DELETE },
-// { XK_KP_Equal, KEY_EQUAL },
-// { XK_KP_Separator, KEY_COMMA },
- { XK_KP_Decimal, KEY_KP_PERIOD },
- { XK_KP_Delete, KEY_KP_PERIOD },
- { XK_KP_Enter, KEY_KP_ENTER },
- { XK_KP_Multiply, KEY_KP_MULTIPLY},
- { XK_KP_Divide, KEY_KP_DIVIDE},
- { XK_KP_Subtract, KEY_KP_SUBTRACT},
- { XK_KP_Add, KEY_KP_ADD},
- { XK_KP_0, KEY_KP_0},
- { XK_KP_1, KEY_KP_1},
- { XK_KP_2, KEY_KP_2},
- { XK_KP_3, KEY_KP_3},
- { XK_KP_4, KEY_KP_4},
- { XK_KP_5, KEY_KP_5},
- { XK_KP_6, KEY_KP_6},
- { XK_KP_7, KEY_KP_7},
- { XK_KP_8, KEY_KP_8},
- { XK_KP_9, KEY_KP_9},
+ { XK_Escape, KEY_ESCAPE },
+ { XK_Tab, KEY_TAB },
+ { XK_ISO_Left_Tab, KEY_BACKTAB },
+ { XK_BackSpace, KEY_BACKSPACE },
+ { XK_Return, KEY_RETURN },
+ { XK_Insert, KEY_INSERT },
+ { XK_Delete, KEY_DELETE },
+ { XK_Clear, KEY_DELETE },
+ { XK_Pause, KEY_PAUSE },
+ { XK_Print, KEY_PRINT },
+ { XK_Home, KEY_HOME },
+ { XK_End, KEY_END },
+ { XK_Left, KEY_LEFT },
+ { XK_Up, KEY_UP },
+ { XK_Right, KEY_RIGHT },
+ { XK_Down, KEY_DOWN },
+ { XK_Prior, KEY_PAGEUP },
+ { XK_Next, KEY_PAGEDOWN },
+ { XK_Shift_L, KEY_SHIFT },
+ { XK_Shift_R, KEY_SHIFT },
+ { XK_Shift_Lock, KEY_SHIFT },
+ { XK_Control_L, KEY_CONTROL },
+ { XK_Control_R, KEY_CONTROL },
+ { XK_Meta_L, KEY_META },
+ { XK_Meta_R, KEY_META },
+ { XK_Alt_L, KEY_ALT },
+ { XK_Alt_R, KEY_ALT },
+ { XK_Caps_Lock, KEY_CAPSLOCK },
+ { XK_Num_Lock, KEY_NUMLOCK },
+ { XK_Scroll_Lock, KEY_SCROLLLOCK },
+ { XK_Super_L, KEY_SUPER_L },
+ { XK_Super_R, KEY_SUPER_R },
+ { XK_Menu, KEY_MENU },
+ { XK_Hyper_L, KEY_HYPER_L },
+ { XK_Hyper_R, KEY_HYPER_R },
+ { XK_Help, KEY_HELP },
+ { XK_KP_Space, KEY_SPACE },
+ { XK_KP_Tab, KEY_TAB },
+ { XK_KP_Enter, KEY_ENTER },
+ { XK_Home, KEY_HOME },
+ { XK_Left, KEY_LEFT },
+ { XK_Up, KEY_UP },
+ { XK_Right, KEY_RIGHT },
+ { XK_Down, KEY_DOWN },
+ { XK_Prior, KEY_PAGEUP },
+ { XK_Next, KEY_PAGEDOWN },
+ { XK_End, KEY_END },
+ { XK_Begin, KEY_CLEAR },
+ { XK_Insert, KEY_INSERT },
+ { XK_Delete, KEY_DELETE },
+ // { XK_KP_Equal, KEY_EQUAL },
+ // { XK_KP_Separator, KEY_COMMA },
+ { XK_KP_Decimal, KEY_KP_PERIOD },
+ { XK_KP_Delete, KEY_KP_PERIOD },
+ { XK_KP_Enter, KEY_KP_ENTER },
+ { XK_KP_Multiply, KEY_KP_MULTIPLY },
+ { XK_KP_Divide, KEY_KP_DIVIDE },
+ { XK_KP_Subtract, KEY_KP_SUBTRACT },
+ { XK_KP_Add, KEY_KP_ADD },
+ { XK_KP_0, KEY_KP_0 },
+ { XK_KP_1, KEY_KP_1 },
+ { XK_KP_2, KEY_KP_2 },
+ { XK_KP_3, KEY_KP_3 },
+ { XK_KP_4, KEY_KP_4 },
+ { XK_KP_5, KEY_KP_5 },
+ { XK_KP_6, KEY_KP_6 },
+ { XK_KP_7, KEY_KP_7 },
+ { XK_KP_8, KEY_KP_8 },
+ { XK_KP_9, KEY_KP_9 },
// same but with numlock
- { XK_KP_Insert, KEY_KP_0},
- { XK_KP_End, KEY_KP_1},
- { XK_KP_Down, KEY_KP_2},
- { XK_KP_Page_Down, KEY_KP_3},
- { XK_KP_Left, KEY_KP_4},
- { XK_KP_Begin, KEY_KP_5},
- { XK_KP_Right, KEY_KP_6},
- { XK_KP_Home, KEY_KP_7},
- { XK_KP_Up, KEY_KP_8},
- { XK_KP_Page_Up, KEY_KP_9},
- { XK_F1, KEY_F1},
- { XK_F2, KEY_F2},
- { XK_F3, KEY_F3},
- { XK_F4, KEY_F4},
- { XK_F5, KEY_F5},
- { XK_F6, KEY_F6},
- { XK_F7, KEY_F7},
- { XK_F8, KEY_F8},
- { XK_F9, KEY_F9},
- { XK_F10, KEY_F10},
- { XK_F11, KEY_F11},
- { XK_F12, KEY_F12},
- { XK_F13, KEY_F13},
- { XK_F14, KEY_F14},
- { XK_F15, KEY_F15},
- { XK_F16, KEY_F16},
+ { XK_KP_Insert, KEY_KP_0 },
+ { XK_KP_End, KEY_KP_1 },
+ { XK_KP_Down, KEY_KP_2 },
+ { XK_KP_Page_Down, KEY_KP_3 },
+ { XK_KP_Left, KEY_KP_4 },
+ { XK_KP_Begin, KEY_KP_5 },
+ { XK_KP_Right, KEY_KP_6 },
+ { XK_KP_Home, KEY_KP_7 },
+ { XK_KP_Up, KEY_KP_8 },
+ { XK_KP_Page_Up, KEY_KP_9 },
+ { XK_F1, KEY_F1 },
+ { XK_F2, KEY_F2 },
+ { XK_F3, KEY_F3 },
+ { XK_F4, KEY_F4 },
+ { XK_F5, KEY_F5 },
+ { XK_F6, KEY_F6 },
+ { XK_F7, KEY_F7 },
+ { XK_F8, KEY_F8 },
+ { XK_F9, KEY_F9 },
+ { XK_F10, KEY_F10 },
+ { XK_F11, KEY_F11 },
+ { XK_F12, KEY_F12 },
+ { XK_F13, KEY_F13 },
+ { XK_F14, KEY_F14 },
+ { XK_F15, KEY_F15 },
+ { XK_F16, KEY_F16 },
- // media keys
- { XF86XK_Back, KEY_BACK },
- { XF86XK_Forward, KEY_FORWARD },
- { XF86XK_Stop, KEY_STOP },
- { XF86XK_Refresh, KEY_REFRESH },
- { XF86XK_Favorites, KEY_FAVORITES },
- { XF86XK_AudioMedia, KEY_LAUNCHMEDIA },
- { XF86XK_OpenURL, KEY_OPENURL },
- { XF86XK_HomePage, KEY_HOMEPAGE },
- { XF86XK_Search, KEY_SEARCH },
- { XF86XK_AudioLowerVolume, KEY_VOLUMEDOWN },
- { XF86XK_AudioMute, KEY_VOLUMEMUTE },
- { XF86XK_AudioRaiseVolume, KEY_VOLUMEUP },
- { XF86XK_AudioPlay, KEY_MEDIAPLAY },
- { XF86XK_AudioStop, KEY_MEDIASTOP },
- { XF86XK_AudioPrev, KEY_MEDIAPREVIOUS },
- { XF86XK_AudioNext, KEY_MEDIANEXT },
- { XF86XK_AudioRecord, KEY_MEDIARECORD },
+ // media keys
+ { XF86XK_Back, KEY_BACK },
+ { XF86XK_Forward, KEY_FORWARD },
+ { XF86XK_Stop, KEY_STOP },
+ { XF86XK_Refresh, KEY_REFRESH },
+ { XF86XK_Favorites, KEY_FAVORITES },
+ { XF86XK_AudioMedia, KEY_LAUNCHMEDIA },
+ { XF86XK_OpenURL, KEY_OPENURL },
+ { XF86XK_HomePage, KEY_HOMEPAGE },
+ { XF86XK_Search, KEY_SEARCH },
+ { XF86XK_AudioLowerVolume, KEY_VOLUMEDOWN },
+ { XF86XK_AudioMute, KEY_VOLUMEMUTE },
+ { XF86XK_AudioRaiseVolume, KEY_VOLUMEUP },
+ { XF86XK_AudioPlay, KEY_MEDIAPLAY },
+ { XF86XK_AudioStop, KEY_MEDIASTOP },
+ { XF86XK_AudioPrev, KEY_MEDIAPREVIOUS },
+ { XF86XK_AudioNext, KEY_MEDIANEXT },
+ { XF86XK_AudioRecord, KEY_MEDIARECORD },
- // launch keys
- { XF86XK_Mail, KEY_LAUNCHMAIL },
- { XF86XK_MyComputer, KEY_LAUNCH0 },
- { XF86XK_Calculator, KEY_LAUNCH1 },
- { XF86XK_Standby, KEY_STANDBY },
+ // launch keys
+ { XF86XK_Mail, KEY_LAUNCHMAIL },
+ { XF86XK_MyComputer, KEY_LAUNCH0 },
+ { XF86XK_Calculator, KEY_LAUNCH1 },
+ { XF86XK_Standby, KEY_STANDBY },
- { XF86XK_Launch0, KEY_LAUNCH2 },
- { XF86XK_Launch1, KEY_LAUNCH3 },
- { XF86XK_Launch2, KEY_LAUNCH4 },
- { XF86XK_Launch3, KEY_LAUNCH5 },
- { XF86XK_Launch4, KEY_LAUNCH6 },
- { XF86XK_Launch5, KEY_LAUNCH7 },
- { XF86XK_Launch6, KEY_LAUNCH8 },
- { XF86XK_Launch7, KEY_LAUNCH9 },
- { XF86XK_Launch8, KEY_LAUNCHA },
- { XF86XK_Launch9, KEY_LAUNCHB },
- { XF86XK_LaunchA, KEY_LAUNCHC },
- { XF86XK_LaunchB, KEY_LAUNCHD },
- { XF86XK_LaunchC, KEY_LAUNCHE },
- { XF86XK_LaunchD, KEY_LAUNCHF },
+ { XF86XK_Launch0, KEY_LAUNCH2 },
+ { XF86XK_Launch1, KEY_LAUNCH3 },
+ { XF86XK_Launch2, KEY_LAUNCH4 },
+ { XF86XK_Launch3, KEY_LAUNCH5 },
+ { XF86XK_Launch4, KEY_LAUNCH6 },
+ { XF86XK_Launch5, KEY_LAUNCH7 },
+ { XF86XK_Launch6, KEY_LAUNCH8 },
+ { XF86XK_Launch7, KEY_LAUNCH9 },
+ { XF86XK_Launch8, KEY_LAUNCHA },
+ { XF86XK_Launch9, KEY_LAUNCHB },
+ { XF86XK_LaunchA, KEY_LAUNCHC },
+ { XF86XK_LaunchB, KEY_LAUNCHD },
+ { XF86XK_LaunchC, KEY_LAUNCHE },
+ { XF86XK_LaunchD, KEY_LAUNCHF },
- {0, 0 }
+ { 0, 0 }
};
-
unsigned int KeyMappingX11::get_keycode(KeySym p_keysym) {
// kinda bruteforce.. could optimize.
- if (p_keysym<0x100) // Latin 1, maps 1-1
+ if (p_keysym < 0x100) // Latin 1, maps 1-1
return p_keysym;
// look for special key
- for(int idx=0;_xkeysym_to_keycode[idx].keysym!=0;idx++) {
+ for (int idx = 0; _xkeysym_to_keycode[idx].keysym != 0; idx++) {
- if (_xkeysym_to_keycode[idx].keysym==p_keysym)
- return _xkeysym_to_keycode[idx].keycode;
+ if (_xkeysym_to_keycode[idx].keysym == p_keysym)
+ return _xkeysym_to_keycode[idx].keycode;
}
return 0;
@@ -202,20 +200,19 @@ KeySym KeyMappingX11::get_keysym(unsigned int p_code) {
// kinda bruteforce.. could optimize.
- if (p_code<0x100) // Latin 1, maps 1-1
+ if (p_code < 0x100) // Latin 1, maps 1-1
return p_code;
// look for special key
- for(int idx=0;_xkeysym_to_keycode[idx].keysym!=0;idx++) {
+ for (int idx = 0; _xkeysym_to_keycode[idx].keysym != 0; idx++) {
- if (_xkeysym_to_keycode[idx].keycode==p_code)
- return _xkeysym_to_keycode[idx].keysym;
+ if (_xkeysym_to_keycode[idx].keycode == p_code)
+ return _xkeysym_to_keycode[idx].keysym;
}
return 0;
}
-
/***** UNICODE CONVERSION ******/
// Tables taken from FOX toolkit
@@ -228,7 +225,7 @@ struct _XTranslateUnicodePair {
enum {
- _KEYSYM_MAX=759
+ _KEYSYM_MAX = 759
};
static _XTranslateUnicodePair _xkeysym_to_unicode[_KEYSYM_MAX] = {
@@ -995,32 +992,31 @@ static _XTranslateUnicodePair _xkeysym_to_unicode[_KEYSYM_MAX] = {
unsigned int KeyMappingX11::get_unicode_from_keysym(KeySym p_keysym) {
/* Latin-1 */
- if (p_keysym>=0x20 && p_keysym<=0x7e)
+ if (p_keysym >= 0x20 && p_keysym <= 0x7e)
return p_keysym;
- if (p_keysym>=0xa0 && p_keysym<=0xff)
+ if (p_keysym >= 0xa0 && p_keysym <= 0xff)
return p_keysym;
// keypad to latin1 is easy
- if (p_keysym>=0xffaa && p_keysym<=0xffb9)
- return p_keysym-0xff80;
+ if (p_keysym >= 0xffaa && p_keysym <= 0xffb9)
+ return p_keysym - 0xff80;
/* Unicode (may be present)*/
- if((p_keysym&0xff000000)==0x01000000)
- return p_keysym&0x00ffffff;
+ if ((p_keysym & 0xff000000) == 0x01000000)
+ return p_keysym & 0x00ffffff;
- int middle,low=0,high=_KEYSYM_MAX-1;
+ int middle, low = 0, high = _KEYSYM_MAX - 1;
do {
- middle=(high+low)/2;
- if ( _xkeysym_to_unicode[middle].keysym==p_keysym)
+ middle = (high + low) / 2;
+ if (_xkeysym_to_unicode[middle].keysym == p_keysym)
return _xkeysym_to_unicode[middle].unicode;
- if ( _xkeysym_to_unicode[middle].keysym<=p_keysym )
- low=middle+1;
+ if (_xkeysym_to_unicode[middle].keysym <= p_keysym)
+ low = middle + 1;
else
- high=middle-1;
- } while (high>=low);
+ high = middle - 1;
+ } while (high >= low);
return 0;
-
}
struct _XTranslateUnicodePairReverse {
@@ -1031,7 +1027,7 @@ struct _XTranslateUnicodePairReverse {
enum {
- _UNICODE_MAX=750
+ _UNICODE_MAX = 750
};
static _XTranslateUnicodePairReverse _unicode_to_xkeysym[_UNICODE_MAX] = {
@@ -1791,23 +1787,23 @@ KeySym KeyMappingX11::get_keysym_from_unicode(unsigned int p_unicode) {
/* Latin 1 */
- if (p_unicode>=0x20 && p_unicode<=0x7e)
+ if (p_unicode >= 0x20 && p_unicode <= 0x7e)
return p_unicode;
- if (p_unicode>=0xa0 && p_unicode<=0xff)
+ if (p_unicode >= 0xa0 && p_unicode <= 0xff)
return p_unicode;
- int middle,low=0,high=_UNICODE_MAX-1;
+ int middle, low = 0, high = _UNICODE_MAX - 1;
do {
- middle=(high+low)/2;
- if ( _unicode_to_xkeysym[middle].keysym==p_unicode)
+ middle = (high + low) / 2;
+ if (_unicode_to_xkeysym[middle].keysym == p_unicode)
return _unicode_to_xkeysym[middle].keysym;
- if ( _unicode_to_xkeysym[middle].keysym<=p_unicode )
- low=middle+1;
+ if (_unicode_to_xkeysym[middle].keysym <= p_unicode)
+ low = middle + 1;
else
- high=middle-1;
- } while (high>=low);
+ high = middle - 1;
+ } while (high >= low);
// if not found, let's hope X understands it as unicode
- return p_unicode|0x01000000;
+ return p_unicode | 0x01000000;
}
diff --git a/platform/x11/key_mapping_x11.h b/platform/x11/key_mapping_x11.h
index 9749b2ec2..8210df06e 100644
--- a/platform/x11/key_mapping_x11.h
+++ b/platform/x11/key_mapping_x11.h
@@ -32,8 +32,8 @@
/**
@author Juan Linietsky <reduzio@gmail.com>
*/
-#include <X11/Xlib.h>
#include <X11/XF86keysym.h>
+#include <X11/Xlib.h>
#define XK_MISCELLANY
#define XK_LATIN1
#define XK_XKB_KEYS
@@ -42,14 +42,13 @@
#include "os/keyboard.h"
class KeyMappingX11 {
- KeyMappingX11() {};
+ KeyMappingX11(){};
+
public:
static unsigned int get_keycode(KeySym p_keysym);
static KeySym get_keysym(unsigned int p_code);
static unsigned int get_unicode_from_keysym(KeySym p_keysym);
static KeySym get_keysym_from_unicode(unsigned int p_unicode);
-
};
-
#endif
diff --git a/platform/x11/os_x11.cpp b/platform/x11/os_x11.cpp
index 5cff4edc8..f72cde321 100644
--- a/platform/x11/os_x11.cpp
+++ b/platform/x11/os_x11.cpp
@@ -26,45 +26,42 @@
/* 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 "drivers/gles2/rasterizer_gles2.h"
+#include "errno.h"
#include "key_mapping_x11.h"
+#include "print_string.h"
+#include "servers/physics/physics_server_sw.h"
+#include "servers/visual/visual_server_raster.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
+#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
+#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 <dlfcn.h>
#include <fcntl.h>
+#include <sys/stat.h>
+#include <sys/types.h>
#include <unistd.h>
-#include <dlfcn.h>
//stupid linux.h
#ifdef KEY_TAB
#undef KEY_TAB
#endif
-
#include <X11/Xatom.h>
#undef CursorShape
@@ -73,75 +70,73 @@ int OS_X11::get_video_driver_count() const {
return 1;
}
-const char * OS_X11::get_video_driver_name(int p_driver) const {
+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);
+ return OS::VideoMode(1024, 600, false);
}
int OS_X11::get_audio_driver_count() const {
- return AudioDriverManagerSW::get_driver_count();
+ 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();
+ 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) {
+void OS_X11::initialize(const VideoMode &p_desired, int p_video_driver, int p_audio_driver) {
- last_button_state=0;
+ 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;
+ 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) {
+ if (get_render_thread_mode() == RENDER_SEPARATE_THREAD) {
XInitThreads();
}
/** XLIB INITIALIZATION **/
x11_display = XOpenDisplay(NULL);
- char * modifiers = XSetLocaleModifiers ("@im=none");
- if (modifiers==NULL) {
+ char *modifiers = XSetLocaleModifiers("@im=none");
+ if (modifiers == NULL) {
WARN_PRINT("Error setting locale modifiers");
}
- const char* err;
+ 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_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 {
+ } 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");
+ 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");
+ } 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);
@@ -151,39 +146,38 @@ void OS_X11::initialize(const VideoMode& p_desired,int p_video_driver,int p_audi
}
}
- xim = XOpenIM (x11_display, NULL, NULL, NULL);
-
+ xim = XOpenIM(x11_display, NULL, NULL, NULL);
if (xim == NULL) {
WARN_PRINT("XOpenIM failed");
- xim_style=0L;
+ xim_style = 0L;
} else {
- ::XIMStyles *xim_styles=NULL;
- xim_style=0L;
- char *imvalret=NULL;
+ ::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");
+ 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++) {
+ for (int i = 0; i < xim_styles->count_styles; i++) {
if (xim_styles->supported_styles[i] ==
- (XIMPreeditNothing | XIMStatusNothing)) {
+ (XIMPreeditNothing | XIMStatusNothing)) {
- xim_style = xim_styles->supported_styles[i];
- break;
- }
+ xim_style = xim_styles->supported_styles[i];
+ break;
+ }
}
- XFree (xim_styles);
+ XFree(xim_styles);
}
- XFree( imvalret );
+ XFree(imvalret);
}
- /*
+/*
char* windowid = getenv("GODOT_WINDOWID");
if (windowid) {
@@ -199,26 +193,26 @@ void OS_X11::initialize(const VideoMode& p_desired,int p_video_driver,int p_audi
};
*/
- // maybe contextgl wants to be in charge of creating the window
- //print_line("def videomode "+itos(current_videomode.width)+","+itos(current_videomode.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 = memnew(ContextGL_X11(x11_display, x11_window, current_videomode, false));
context_gl->initialize();
- rasterizer = memnew( RasterizerGLES2 );
+ rasterizer = memnew(RasterizerGLES2);
#endif
- visual_server = memnew( VisualServerRaster(rasterizer) );
+ visual_server = memnew(VisualServerRaster(rasterizer));
- if (get_render_thread_mode()!=RENDER_THREAD_UNSAFE) {
+ if (get_render_thread_mode() != RENDER_THREAD_UNSAFE) {
- visual_server =memnew(VisualServerWrapMT(visual_server,get_render_thread_mode()==RENDER_SEPARATE_THREAD));
+ 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
+ // needed for lxde/openbox, possibly others
Hints hints;
Atom property;
hints.flags = 2;
@@ -254,9 +248,9 @@ void OS_X11::initialize(const VideoMode& p_desired,int p_video_driver,int p_audi
xsh->flags = PMinSize | PMaxSize;
XWindowAttributes xwa;
if (current_videomode.fullscreen) {
- XGetWindowAttributes(x11_display,DefaultRootWindow(x11_display),&xwa);
+ XGetWindowAttributes(x11_display, DefaultRootWindow(x11_display), &xwa);
} else {
- XGetWindowAttributes(x11_display,x11_window,&xwa);
+ XGetWindowAttributes(x11_display, x11_window, &xwa);
}
xsh->min_width = xwa.width;
xsh->max_width = xwa.width;
@@ -268,59 +262,57 @@ void OS_X11::initialize(const VideoMode& p_desired,int p_video_driver,int p_audi
AudioDriverManagerSW::get_driver(p_audio_driver)->set_singleton();
- audio_driver_index=p_audio_driver;
- if (AudioDriverManagerSW::get_driver(p_audio_driver)->init()!=OK) {
+ 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)
+ 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;
+ 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) );
+ sample_manager = memnew(SampleManagerMallocSW);
+ audio_server = memnew(AudioServerSW(sample_manager));
audio_server->init();
- spatial_sound_server = memnew( SpatialSoundServerSW );
+ spatial_sound_server = memnew(SpatialSoundServerSW);
spatial_sound_server->init();
- spatial_sound_2d_server = memnew( SpatialSound2DServerSW );
+ spatial_sound_2d_server = memnew(SpatialSound2DServerSW);
spatial_sound_2d_server->init();
-
ERR_FAIL_COND(!visual_server);
- ERR_FAIL_COND(x11_window==0);
+ 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;
+ 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);
+ XChangeWindowAttributes(x11_display, x11_window, CWEventMask, &new_attr);
- XClassHint* classHint;
+ XClassHint *classHint;
/* set the titlebar name */
XStoreName(x11_display, x11_window, "Godot");
@@ -337,39 +329,37 @@ void OS_X11::initialize(const VideoMode& p_desired,int p_video_driver,int p_audi
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);
+ xic = XCreateIC(xim, XNInputStyle, xim_style, XNClientWindow, x11_window, XNFocusWindow, x11_window, (char *)NULL);
} else {
- xic=NULL;
+ xic = NULL;
WARN_PRINT("XCreateIC couldn't create xic");
-
}
- XcursorSetTheme(x11_display,"default");
+ 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";
+ cursor_theme = "default";
}
- for(int i=0;i<CURSOR_MAX;i++) {
+ for (int i = 0; i < CURSOR_MAX; i++) {
- cursors[i]=None;
- img[i]=NULL;
+ cursors[i] = None;
+ img[i] = NULL;
}
- current_cursor=CURSOR_ARROW;
+ current_cursor = CURSOR_ARROW;
if (cursor_theme) {
//print_line("cursor theme: "+String(cursor_theme));
- for(int i=0;i<CURSOR_MAX;i++) {
+ for (int i = 0; i < CURSOR_MAX; i++) {
- static const char *cursor_file[]={
+ static const char *cursor_file[] = {
"left_ptr",
"xterm",
"hand2",
@@ -389,26 +379,25 @@ void OS_X11::initialize(const VideoMode& p_desired,int p_video_driver,int p_audi
"question_arrow"
};
- img[i] = XcursorLibraryLoadImage(cursor_file[i],cursor_theme,cursor_size);
+ img[i] = XcursorLibraryLoadImage(cursor_file[i], cursor_theme, cursor_size);
if (img[i]) {
- cursors[i]=XcursorImageLoadCursor(x11_display,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]));
+ print_line("failed cursor: " + String(cursor_file[i]));
}
}
}
-
{
Pixmap cursormask;
- XGCValues xgc;
- GC gc;
- XColor col;
- Cursor cursor;
+ XGCValues xgc;
+ GC gc;
+ XColor col;
+ Cursor cursor;
- cursormask = XCreatePixmap(x11_display, RootWindow(x11_display,DefaultScreen(x11_display)), 1, 1, 1);
+ 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);
@@ -416,25 +405,23 @@ void OS_X11::initialize(const VideoMode& p_desired,int p_video_driver,int p_audi
col.red = 0;
col.flags = 4;
cursor = XCreatePixmapCursor(x11_display,
- cursormask, cursormask,
- &col, &col, 0, 0);
- XFreePixmap(x11_display, cursormask);
- XFreeGC(x11_display, gc);
-
+ cursormask, cursormask,
+ &col, &col, 0, 0);
+ XFreePixmap(x11_display, cursormask);
+ XFreeGC(x11_display, gc);
- if (cursor == None)
- {
- ERR_PRINT("FAILED CREATING CURSOR");
- }
+ if (cursor == None) {
+ ERR_PRINT("FAILED CREATING CURSOR");
+ }
- null_cursor=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);
+ 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);
@@ -447,31 +434,31 @@ void OS_X11::initialize(const VideoMode& p_desired,int p_video_driver,int p_audi
visual_server->init();
//
- physics_server = memnew( PhysicsServerSW );
+ 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 );
+ input = memnew(InputDefault);
#ifdef JOYDEV_ENABLED
- joystick = memnew( joystick_linux(input));
+ joystick = memnew(joystick_linux(input));
#endif
_ensure_data_dir();
}
void OS_X11::finalize() {
- if(main_loop)
+ if (main_loop)
memdelete(main_loop);
- main_loop=NULL;
+ 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) {
+//if (debugger_connection_console) {
// memdelete(debugger_connection_console);
//}
@@ -498,56 +485,54 @@ void OS_X11::finalize() {
if (xrandr_handle)
dlclose(xrandr_handle);
- XUnmapWindow( x11_display, x11_window );
- XDestroyWindow( x11_display, x11_window );
+ 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] );
+ 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 );
+ 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)
+ if (p_mode == mouse_mode)
return;
- if (mouse_mode==MOUSE_MODE_CAPTURED)
+ 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);
+ 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;
+ mouse_mode = p_mode;
- if (mouse_mode==MOUSE_MODE_CAPTURED) {
+ if (mouse_mode == MOUSE_MODE_CAPTURED) {
- while(true) {
+ 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);
+ if (event.type == MotionNotify) {
+ XNextEvent(x11_display, &event);
} else {
break;
}
@@ -557,30 +542,30 @@ void OS_X11::set_mouse_mode(MouseMode p_mode) {
}
if (XGrabPointer(
- x11_display, x11_window, True,
- ButtonPressMask | ButtonReleaseMask | PointerMotionMask,
- GrabModeAsync, GrabModeAsync, x11_window, None, CurrentTime) != GrabSuccess) {
+ 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;
+ 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);
+ 0, 0, 0, 0, (int)center.x, (int)center.y);
input->set_mouse_pos(center);
} else {
- do_mouse_warp=false;
+ do_mouse_warp = false;
}
XFlush(x11_display);
}
-void OS_X11::warp_mouse_pos(const Point2& p_to) {
+void OS_X11::warp_mouse_pos(const Point2 &p_to) {
- if (mouse_mode==MOUSE_MODE_CAPTURED) {
+ if (mouse_mode == MOUSE_MODE_CAPTURED) {
- last_mouse_pos=p_to;
+ last_mouse_pos = p_to;
} else {
/*XWindowAttributes xwa;
@@ -588,9 +573,8 @@ void OS_X11::warp_mouse_pos(const Point2& p_to) {
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);
+ 0, 0, 0, 0, (int)p_to.x, (int)p_to.y);
}
-
}
OS::MouseMode OS_X11::get_mouse_mode() const {
@@ -605,22 +589,22 @@ 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());
+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());
+ 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) {
+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::get_fullscreen_mode_list(List<VideoMode> *p_list, int p_screen) const {
}
void OS_X11::set_wm_fullscreen(bool p_enabled) {
@@ -639,31 +623,30 @@ void OS_X11::set_wm_fullscreen(bool p_enabled) {
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;
+ if (!ext_okay) return 0;
int count;
- XineramaScreenInfo* xsi = XineramaQueryScreens(x11_display, &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 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++) {
+ 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) )
+ if ((x >= pos.x && x < pos.x + size.width) && (y >= pos.y && y < pos.y + size.height))
return i;
}
return 0;
@@ -671,16 +654,15 @@ int OS_X11::get_current_screen() const {
void OS_X11::set_current_screen(int p_screen) {
int count = get_screen_count();
- if(p_screen >= count) return;
+ if (p_screen >= count) return;
- if( current_videomode.fullscreen ) {
+ 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() ) {
+ 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);
}
@@ -691,14 +673,14 @@ 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);
+ if (!ext_okay) {
+ return Point2i(0, 0);
}
int count;
- XineramaScreenInfo* xsi = XineramaQueryScreens(x11_display, &count);
- if( p_screen >= count ) {
- return Point2i(0,0);
+ 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);
@@ -712,11 +694,11 @@ 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);
+ if (!ext_okay) return Size2i(0, 0);
int count;
- XineramaScreenInfo* xsi = XineramaQueryScreens(x11_display, &count);
- if( p_screen >= count ) return Size2i(0,0);
+ 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);
@@ -735,47 +717,46 @@ int OS_X11::get_screen_dpi(int p_screen) const {
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;
+ 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) {
+ } 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;
+ 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 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);
+ 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);
+ return (xdpi + ydpi) / (xdpi && ydpi ? 2 : 1);
//could not get dpi
return 96;
}
Point2 OS_X11::get_window_position() const {
- int x,y;
+ int x, y;
Window child;
- XTranslateCoordinates( x11_display, x11_window, DefaultRootWindow(x11_display), 0, 0, &x, &y, &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);
+ 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);
+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 {
@@ -821,7 +802,7 @@ void OS_X11::set_window_resizable(bool p_enabled) {
xsh = XAllocSizeHints();
xsh->flags = p_enabled ? 0L : PMinSize | PMaxSize;
- if(!p_enabled) {
+ if (!p_enabled) {
xsh->min_width = size.x;
xsh->max_width = size.x;
xsh->min_height = size.y;
@@ -850,8 +831,8 @@ void OS_X11::set_window_minimized(bool p_enabled) {
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);
+ 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;
@@ -866,31 +847,30 @@ void OS_X11::set_window_minimized(bool p_enabled) {
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;
+ 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
- );
+ 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 )
+ if (result == Success) {
+ long *state = (long *)data;
+ if (state[0] == WM_IconicState)
return true;
}
return false;
@@ -919,7 +899,7 @@ void OS_X11::set_window_maximized(bool 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 property = XInternAtom(x11_display, "_NET_WM_STATE", False);
Atom type;
int format;
unsigned long len;
@@ -938,23 +918,22 @@ bool OS_X11::is_window_maximized() const {
&format,
&len,
&remaining,
- &data
- );
+ &data);
- if(result == Success) {
- Atom *atoms = (Atom*) 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 )
+ 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 )
+ if (atoms[i] == wm_max_vert)
found_wm_max_vert = true;
- if( found_wm_max_horz && found_wm_max_vert )
+ if (found_wm_max_horz && found_wm_max_vert)
return true;
}
XFree(atoms);
@@ -988,44 +967,44 @@ 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);
+ 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;
+ unsigned int state = 0;
- if (p_x11_state&Button1Mask) {
+ if (p_x11_state & Button1Mask) {
- state|=1<<0;
+ state |= 1 << 0;
}
- if (p_x11_state&Button3Mask) {
+ if (p_x11_state & Button3Mask) {
- state|=1<<1;
+ state |= 1 << 1;
}
- if (p_x11_state&Button2Mask) {
+ if (p_x11_state & Button2Mask) {
- state|=1<<2;
+ state |= 1 << 2;
}
- if (p_x11_state&Button4Mask) {
+ if (p_x11_state & Button4Mask) {
- state|=1<<3;
+ state |= 1 << 3;
}
- if (p_x11_state&Button5Mask) {
+ if (p_x11_state & Button5Mask) {
- state|=1<<4;
+ state |= 1 << 4;
}
- last_button_state=state;
+ last_button_state = state;
return state;
}
@@ -1053,20 +1032,19 @@ void OS_X11::handle_key_event(XKeyEvent *p_event, bool p_echo) {
// 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
+ 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];
+ char str[256 + 1];
XLookupString(xkeyevent, str, 256, &keysym_keycode, NULL);
- // Meanwhile, XLookupString returns keysyms useful for unicode.
-
+ // Meanwhile, XLookupString returns keysyms useful for unicode.
if (!xmbstring) {
// keep a temporary buffer for the string
- xmbstring=(char*)memalloc(sizeof(char)*8);
- xmblen=8;
+ xmbstring = (char *)memalloc(sizeof(char) * 8);
+ xmblen = 8;
}
if (xkeyevent->type == KeyPress && xic) {
@@ -1074,17 +1052,16 @@ void OS_X11::handle_key_event(XKeyEvent *p_event, bool p_echo) {
Status status;
do {
- int mnbytes = XmbLookupString (xic, xkeyevent, xmbstring, xmblen - 1, &keysym_unicode, &status);
+ 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);
+ 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
@@ -1098,8 +1075,7 @@ void OS_X11::handle_key_event(XKeyEvent *p_event, bool p_echo) {
// 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;
-
+ unsigned int unicode = keysym_unicode > 0 ? KeyMappingX11::get_unicode_from_keysym(keysym_unicode) : 0;
/* Phase 4, determine if event must be filtered */
@@ -1113,11 +1089,11 @@ void OS_X11::handle_key_event(XKeyEvent *p_event, bool p_echo) {
bool keypress = xkeyevent->type == KeyPress;
if (xkeyevent->type == KeyPress && xic) {
- if (XFilterEvent((XEvent*)xkeyevent, x11_window))
- return;
+ if (XFilterEvent((XEvent *)xkeyevent, x11_window))
+ return;
}
- if (keycode==0 && unicode==0)
+ if (keycode == 0 && unicode == 0)
return;
/* Phase 5, determine modifier mask */
@@ -1137,12 +1113,11 @@ void OS_X11::handle_key_event(XKeyEvent *p_event, bool p_echo) {
// 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) {
+ if (XPending(x11_display) > 0) {
XEvent peek_event;
XPeekEvent(x11_display, &peek_event);
@@ -1152,14 +1127,14 @@ void OS_X11::handle_key_event(XKeyEvent *p_event, bool p_echo) {
// 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 ) {
+ ::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) {
+ 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 );
+ handle_key_event((XKeyEvent *)&event, true);
return; //ignore current, echo next
}
}
@@ -1170,27 +1145,26 @@ void OS_X11::handle_key_event(XKeyEvent *p_event, bool p_echo) {
// save the time to check for echo when keypress happens
}
-
/* Phase 7, send event to Window */
InputEvent event;
- event.ID=++event_id;
+ event.ID = ++event_id;
event.type = InputEvent::KEY;
- event.device=0;
- event.key.mod=state;
- event.key.pressed=keypress;
+ event.device = 0;
+ event.key.mod = state;
+ event.key.pressed = keypress;
- if (keycode>='a' && keycode<='z')
- keycode-='a'-'A';
+ if (keycode >= 'a' && keycode <= 'z')
+ keycode -= 'a' - 'A';
- event.key.scancode=keycode;
- event.key.unicode=unicode;
- event.key.echo=p_echo;
+ event.key.scancode = keycode;
+ event.key.unicode = unicode;
+ event.key.echo = p_echo;
- if (event.key.scancode==KEY_BACKTAB) {
+ if (event.key.scancode == KEY_BACKTAB) {
//make it consistent accross platforms.
- event.key.scancode=KEY_TAB;
- event.key.mod.shift=true;
+ event.key.scancode = KEY_TAB;
+ event.key.mod.shift = true;
}
//don't set mod state if modifier keys are released by themselves
@@ -1207,63 +1181,61 @@ void OS_X11::handle_key_event(XKeyEvent *p_event, bool p_echo) {
}
//printf("key: %x\n",event.key.scancode);
- input->parse_input_event( event);
+ input->parse_input_event(event);
}
-struct Property
-{
+struct Property {
unsigned char *data;
int format, nitems;
Atom type;
};
-static Property read_property(Display* p_display, Window p_window, Atom p_property) {
+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;
+ unsigned char *ret = 0;
int read_bytes = 1024;
//Keep trying to read the property until there are no
//bytes unread.
- do
- {
- if(ret != 0)
+ 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);
+ &actual_type, &actual_format, &nitems, &bytes_after,
+ &ret);
read_bytes *= 2;
- }while(bytes_after != 0);
+ } while (bytes_after != 0);
- Property p = {ret, actual_format, nitems, actual_type};
+ 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 Atom pick_target_from_list(Display *p_display, Atom *p_list, int p_count) {
- static const char* target_type = "text/uri-list";
+ 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 atom;
}
return None;
}
-static Atom pick_target_from_atoms(Display* p_disp, Atom p_t1, Atom p_t2, Atom p_t3) {
+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";
+ static const char *target_type = "text/uri-list";
if (p_t1 != None && String(XGetAtomName(p_disp, p_t1)) == target_type)
return p_t1;
@@ -1280,367 +1252,359 @@ void OS_X11::process_xevents() {
//printf("checking events %i\n", XPending(x11_display));
- do_mouse_warp=false;
+ 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 Expose:
+ Main::force_redraw();
+ break;
- case VisibilityNotify: {
- XVisibilityEvent * visibility = (XVisibilityEvent *)&event;
- minimized = (visibility->state == VisibilityFullyObscured);
- } break;
- case LeaveNotify: {
+ case NoExpose:
+ minimized = true;
+ break;
- if (main_loop && mouse_mode!=MOUSE_MODE_CAPTURED)
- main_loop->notification(MainLoop::NOTIFICATION_WM_MOUSE_EXIT);
- if (input)
- input->set_mouse_in_window(false);
+ case VisibilityNotify: {
+ XVisibilityEvent *visibility = (XVisibilityEvent *)&event;
+ minimized = (visibility->state == VisibilityFullyObscured);
+ } break;
+ case LeaveNotify: {
- } break;
- case EnterNotify: {
+ if (main_loop && mouse_mode != MOUSE_MODE_CAPTURED)
+ main_loop->notification(MainLoop::NOTIFICATION_WM_MOUSE_EXIT);
+ if (input)
+ input->set_mouse_in_window(false);
- 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;
+ } break;
+ case EnterNotify: {
- 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))
+ 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;
- current_videomode.width=event.xconfigure.width;
- current_videomode.height=event.xconfigure.height;
- break;
- case ButtonPress:
- case ButtonRelease: {
+ 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;
- /* 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;
- }
+ case ConfigureNotify:
+ /* call resizeGLScene only if our window-size changed */
- 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;
+ if ((event.xconfigure.width == current_videomode.width) &&
+ (event.xconfigure.height == current_videomode.height))
+ break;
- mouse_event.mouse_button.pressed=(event.type==ButtonPress);
+ 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;
+ }
- if (event.type==ButtonPress && event.xbutton.button==1) {
+ 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;
- uint64_t diff = get_ticks_usec()/1000 - last_click_ms;
+ mouse_event.mouse_button.pressed = (event.type == ButtonPress);
- if (diff<400 && Point2(last_click_pos).distance_to(Point2(event.xbutton.x,event.xbutton.y))<5) {
+ if (event.type == ButtonPress && event.xbutton.button == 1) {
- last_click_ms=0;
- last_click_pos = Point2(-100,-100);
- mouse_event.mouse_button.doubleclick=true;
- mouse_event.ID=++event_id;
+ uint64_t diff = get_ticks_usec() / 1000 - last_click_ms;
- } else {
- last_click_ms+=diff;
- last_click_pos = Point2(event.xbutton.x,event.xbutton.y);
- }
- }
+ if (diff < 400 && Point2(last_click_pos).distance_to(Point2(event.xbutton.x, event.xbutton.y)) < 5) {
- input->parse_input_event( mouse_event);
+ 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);
+ }
+ }
- } break;
- case MotionNotify: {
+ input->parse_input_event(mouse_event);
- // 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.
+ } 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;
- }
+ 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);
+ if (XPending(x11_display) > 0) {
+ XEvent tevent;
+ XPeekEvent(x11_display, &tevent);
+ if (tevent.type == MotionNotify) {
+ XNextEvent(x11_display, &event);
+ } else {
+ break;
+ }
} else {
break;
}
- } else {
- break;
}
- }
- last_timestamp=event.xmotion.time;
+ 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 );
+ // 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 (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.
+ //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;
- }
+ center = pos;
+ break;
+ }
- Point2i new_center = pos;
- pos = last_mouse_pos + ( pos - center );
- center=new_center;
- do_mouse_warp=true;
+ 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
+ //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);
+ 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;
+ if (!last_mouse_pos_valid) {
- motion_event.mouse_motion.relative_x=rel.x;
- motion_event.mouse_motion.relative_y=rel.y;
+ last_mouse_pos = pos;
+ last_mouse_pos_valid = true;
+ }
- last_mouse_pos=pos;
+ Point2i rel = pos - last_mouse_pos;
- // printf("rel: %d,%d\n", rel.x, rel.y );
+ InputEvent motion_event;
+ motion_event.ID = ++event_id;
+ motion_event.type = InputEvent::MOUSE_MOTION;
+ motion_event.device = 0;
- input->parse_input_event( motion_event);
+ 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;
- } break;
- case KeyPress:
- case KeyRelease: {
+ motion_event.mouse_motion.relative_x = rel.x;
+ motion_event.mouse_motion.relative_y = rel.y;
- last_timestamp=event.xkey.time;
+ last_mouse_pos = pos;
- // key event is a little complex, so
- // it will be handled in it's own function.
- handle_key_event( (XKeyEvent*)&event );
- } break;
- case SelectionRequest: {
+ // printf("rel: %d,%d\n", rel.x, rel.y );
- XSelectionRequestEvent *req;
- XEvent e, respond;
- e = event;
+ input->parse_input_event(motion_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)) {
+ } break;
+ case KeyPress:
+ case KeyRelease: {
- 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;
+ last_timestamp = event.xkey.time;
- } 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;
+ // key event is a little complex, so
+ // it will be handled in it's own function.
+ handle_key_event((XKeyEvent *)&event);
+ } break;
+ case SelectionRequest: {
- case SelectionNotify:
+ XSelectionRequestEvent *req;
+ XEvent e, respond;
+ e = event;
- if (event.xselection.target == requested) {
+ 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)) {
- Property p = read_property(x11_display, x11_window, XInternAtom(x11_display, "PRIMARY", 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;
- 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();
+ } else {
+ printf("No String %x\n",
+ (int)req->target);
+ respond.xselection.property = None;
}
- main_loop->drop_files(files);
+ 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;
- //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.
+ case SelectionNotify:
- XSendEvent(x11_display, xdnd_source_window, False, NoEventMask, (XEvent*)&m);
- }
- break;
+ if (event.xselection.target == requested) {
- case ClientMessage:
+ Property p = read_property(x11_display, x11_window, XInternAtom(x11_display, "PRIMARY", 0));
- if ((unsigned int)event.xclient.data.l[0]==(unsigned int)wm_delete)
- main_loop->notification(MainLoop::NOTIFICATION_WM_QUIT_REQUEST);
+ 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);
- else if ((unsigned int)event.xclient.message_type == (unsigned int)xdnd_enter) {
+ //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.
- //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);
+ XSendEvent(x11_display, xdnd_source_window, False, NoEventMask, (XEvent *)&m);
}
- 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) {
+ break;
- //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;
+ case ClientMessage:
- 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 ((unsigned int)event.xclient.data.l[0] == (unsigned int)wm_delete)
+ main_loop->notification(MainLoop::NOTIFICATION_WM_QUIT_REQUEST);
- 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.
+ 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_finished;
- m.format=32;
+ m.message_type = xdnd_status;
+ 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);
+ 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;
+ break;
+ default:
+ break;
}
}
@@ -1649,7 +1613,7 @@ void OS_X11::process_xevents() {
if (do_mouse_warp) {
XWarpPointer(x11_display, None, x11_window,
- 0,0,0,0, (int)current_videomode.width/2, (int)current_videomode.height/2);
+ 0, 0, 0, 0, (int)current_videomode.width / 2, (int)current_videomode.height / 2);
/*
Window root, child;
@@ -1673,12 +1637,12 @@ void OS_X11::delete_main_loop() {
if (main_loop)
memdelete(main_loop);
- main_loop=NULL;
+ main_loop = NULL;
}
-void OS_X11::set_main_loop( MainLoop * p_main_loop ) {
+void OS_X11::set_main_loop(MainLoop *p_main_loop) {
- main_loop=p_main_loop;
+ main_loop = p_main_loop;
input->set_main_loop(p_main_loop);
}
@@ -1687,7 +1651,7 @@ bool OS_X11::can_draw() const {
return !minimized;
};
-void OS_X11::set_clipboard(const String& p_text) {
+void OS_X11::set_clipboard(const String &p_text) {
OS::set_clipboard(p_text);
@@ -1695,7 +1659,7 @@ void OS_X11::set_clipboard(const String& p_text) {
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) {
+static String _get_clipboard(Atom p_source, Window x11_window, ::Display *x11_display, String p_internal_clipboard) {
String ret;
@@ -1704,7 +1668,7 @@ static String _get_clipboard(Atom p_source, Window x11_window, ::Display* x11_di
int format, result;
unsigned long len, bytes_left, dummy;
unsigned char *data;
- Window Sown = XGetSelectionOwner (x11_display, p_source);
+ Window Sown = XGetSelectionOwner(x11_display, p_source);
if (Sown == x11_window) {
@@ -1712,9 +1676,9 @@ static String _get_clipboard(Atom p_source, Window x11_window, ::Display* x11_di
};
if (Sown != None) {
- XConvertSelection (x11_display, p_source, XA_STRING, selection,
- x11_window, CurrentTime);
- XFlush (x11_display);
+ XConvertSelection(x11_display, p_source, XA_STRING, selection,
+ x11_window, CurrentTime);
+ XFlush(x11_display);
while (true) {
XEvent event;
XNextEvent(x11_display, &event);
@@ -1726,31 +1690,30 @@ static String _get_clipboard(Atom p_source, Window x11_window, ::Display* x11_di
//
// 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);
+ 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 (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);
+ ret.parse_utf8((const char *)data);
+ } else
+ printf("FAIL\n");
+ XFree(data);
}
}
return ret;
-
}
String OS_X11::get_clipboard() const {
@@ -1775,59 +1738,58 @@ 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)
+ ok = execute("/usr/bin/xdg-open", args, false);
+ if (ok == OK)
return OK;
- ok = execute("gnome-open",args,false);
- if (ok==OK)
+ ok = execute("gnome-open", args, false);
+ if (ok == OK)
return OK;
- ok = execute("kde-open",args,false);
+ ok = execute("kde-open", args, false);
return ok;
}
String OS_X11::get_system_dir(SystemDir p_dir) const {
-
String xdgparam;
- switch(p_dir) {
+ switch (p_dir) {
case SYSTEM_DIR_DESKTOP: {
- xdgparam="DESKTOP";
+ xdgparam = "DESKTOP";
} break;
case SYSTEM_DIR_DCIM: {
- xdgparam="PICTURES";
+ xdgparam = "PICTURES";
} break;
case SYSTEM_DIR_DOCUMENTS: {
- xdgparam="DOCUMENTS";
+ xdgparam = "DOCUMENTS";
} break;
case SYSTEM_DIR_DOWNLOADS: {
- xdgparam="DOWNLOAD";
+ xdgparam = "DOWNLOAD";
} break;
case SYSTEM_DIR_MOVIES: {
- xdgparam="VIDEOS";
+ xdgparam = "VIDEOS";
} break;
case SYSTEM_DIR_MUSIC: {
- xdgparam="MUSIC";
+ xdgparam = "MUSIC";
} break;
case SYSTEM_DIR_PICTURES: {
- xdgparam="PICTURES";
+ xdgparam = "PICTURES";
} break;
case SYSTEM_DIR_RINGTONES: {
- xdgparam="MUSIC";
+ xdgparam = "MUSIC";
} break;
}
@@ -1835,38 +1797,36 @@ String OS_X11::get_system_dir(SystemDir p_dir) const {
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)
+ 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);
+ XRaiseWindow(x11_display, x11_window);
}
void OS_X11::set_cursor_shape(CursorShape p_shape) {
- ERR_FAIL_INDEX(p_shape,CURSOR_MAX);
+ ERR_FAIL_INDEX(p_shape, CURSOR_MAX);
- if (p_shape==current_cursor)
+ 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]);
+ 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;
+ current_cursor = p_shape;
}
-
void OS_X11::release_rendering_thread() {
context_gl->release_current();
-
}
void OS_X11::make_rendering_thread() {
@@ -1879,7 +1839,7 @@ void OS_X11::swap_buffers() {
context_gl->swap_buffers();
}
-void OS_X11::alert(const String& p_alert,const String& p_title) {
+void OS_X11::alert(const String &p_alert, const String &p_title) {
List<String> args;
args.push_back("-center");
@@ -1887,14 +1847,14 @@ void OS_X11::alert(const String& p_alert,const String& p_title) {
args.push_back(p_title);
args.push_back(p_alert);
- execute("/usr/bin/xmessage",args,true);
+ execute("/usr/bin/xmessage", args, true);
}
-void OS_X11::set_icon(const Image& p_icon) {
+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;
+ Image img = p_icon;
img.convert(Image::FORMAT_RGBA);
int w = img.get_width();
@@ -1903,31 +1863,30 @@ void OS_X11::set_icon(const Image& p_icon) {
// 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.resize(2 + w * h);
- pd[0]=w;
- pd[1]=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();
+ long *wr = &pd[2];
+ uint8_t const *pr = r.ptr();
- for(int i=0;i<w*h;i++) {
- long v=0;
+ 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;
+ 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());
+ 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);
+ XDeleteProperty(x11_display, x11_window, net_wm_icon);
}
XFlush(x11_display);
}
-
void OS_X11::run() {
force_quit = false;
@@ -1937,10 +1896,10 @@ void OS_X11::run() {
main_loop->init();
-// uint64_t last_ticks=get_ticks_usec();
+ // uint64_t last_ticks=get_ticks_usec();
-// int frames=0;
-// uint64_t frame=0;
+ // int frames=0;
+ // uint64_t frame=0;
while (!force_quit) {
@@ -1948,7 +1907,7 @@ void OS_X11::run() {
#ifdef JOYDEV_ENABLED
event_id = joystick->process_joysticks(event_id);
#endif
- if (Main::iteration()==true)
+ if (Main::iteration() == true)
break;
};
@@ -1976,10 +1935,9 @@ bool OS_X11::is_vsync_enabled() const {
return true;
}
-
void OS_X11::set_context(int p_context) {
- XClassHint* classHint = NULL;
+ XClassHint *classHint = NULL;
classHint = XAllocClassHint();
if (classHint) {
@@ -2007,12 +1965,12 @@ OS_X11::OS_X11() {
AudioDriverManagerSW::add_driver(&driver_alsa);
#endif
- if(AudioDriverManagerSW::get_driver_count() == 0){
+ 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;
+ xim_style = 0L;
+ mouse_mode = MOUSE_MODE_VISIBLE;
}
diff --git a/platform/x11/os_x11.h b/platform/x11/os_x11.h
index a677a44cd..de09ecb04 100644
--- a/platform/x11/os_x11.h
+++ b/platform/x11/os_x11.h
@@ -29,31 +29,30 @@
#ifndef OS_X11_H
#define OS_X11_H
-
-#include "os/input.h"
-#include "drivers/unix/os_unix.h"
#include "context_gl_x11.h"
-#include "servers/visual_server.h"
-#include "servers/visual/visual_server_wrap_mt.h"
-#include "servers/visual/rasterizer.h"
-#include "servers/physics_server.h"
-#include "servers/audio/audio_server_sw.h"
-#include "servers/audio/sample_manager_sw.h"
-#include "servers/spatial_sound/spatial_sound_server_sw.h"
-#include "servers/spatial_sound_2d/spatial_sound_2d_server_sw.h"
-#include "drivers/rtaudio/audio_driver_rtaudio.h"
#include "drivers/alsa/audio_driver_alsa.h"
#include "drivers/pulseaudio/audio_driver_pulseaudio.h"
+#include "drivers/rtaudio/audio_driver_rtaudio.h"
+#include "drivers/unix/os_unix.h"
+#include "joystick_linux.h"
+#include "main/input_default.h"
+#include "os/input.h"
#include "servers/audio/audio_driver_dummy.h"
+#include "servers/audio/audio_server_sw.h"
+#include "servers/audio/sample_manager_sw.h"
#include "servers/physics_2d/physics_2d_server_sw.h"
#include "servers/physics_2d/physics_2d_server_wrap_mt.h"
-#include "main/input_default.h"
-#include "joystick_linux.h"
+#include "servers/physics_server.h"
+#include "servers/spatial_sound/spatial_sound_server_sw.h"
+#include "servers/spatial_sound_2d/spatial_sound_2d_server_sw.h"
+#include "servers/visual/rasterizer.h"
+#include "servers/visual/visual_server_wrap_mt.h"
+#include "servers/visual_server.h"
-#include <X11/keysym.h>
-#include <X11/Xlib.h>
#include <X11/Xcursor/Xcursor.h>
+#include <X11/Xlib.h>
#include <X11/extensions/Xrandr.h>
+#include <X11/keysym.h>
// Hints for X11 fullscreen
typedef struct {
@@ -65,17 +64,17 @@ typedef struct {
} Hints;
typedef struct _xrr_monitor_info {
- Atom name;
- Bool primary;
- Bool automatic;
- int noutput;
- int x;
- int y;
- int width;
- int height;
- int mwidth;
- int mheight;
- RROutput *outputs;
+ Atom name;
+ Bool primary;
+ Bool automatic;
+ int noutput;
+ int x;
+ int y;
+ int width;
+ int height;
+ int mwidth;
+ int mheight;
+ RROutput *outputs;
} xrr_monitor_info;
#undef CursorShape
@@ -95,7 +94,7 @@ class OS_X11 : public OS_Unix {
Atom xdnd_selection;
Atom requested;
- int xdnd_version;
+ int xdnd_version;
#if defined(OPENGL_ENABLED) || defined(LEGACYGL_ENABLED)
ContextGL_X11 *context_gl;
@@ -107,7 +106,7 @@ class OS_X11 : public OS_Unix {
Window x11_window;
Window xdnd_source_window;
MainLoop *main_loop;
- ::Display* x11_display;
+ ::Display *x11_display;
char *xmbstring;
int xmblen;
unsigned long last_timestamp;
@@ -130,7 +129,7 @@ class OS_X11 : public OS_Unix {
MouseMode mouse_mode;
Point2i center;
- void handle_key_event(XKeyEvent *p_event,bool p_echo=false);
+ void handle_key_event(XKeyEvent *p_event, bool p_echo = false);
void process_xevents();
virtual void delete_main_loop();
IP_Unix *ip_unix;
@@ -179,30 +178,27 @@ class OS_X11 : public OS_Unix {
//void set_wm_border(bool p_enabled);
void set_wm_fullscreen(bool p_enabled);
- typedef xrr_monitor_info* (*xrr_get_monitors_t)(Display *dpy, Window window, Bool get_active, int *nmonitors);
- typedef void (*xrr_free_monitors_t)(xrr_monitor_info* monitors);
+ typedef xrr_monitor_info *(*xrr_get_monitors_t)(Display *dpy, Window window, Bool get_active, int *nmonitors);
+ typedef void (*xrr_free_monitors_t)(xrr_monitor_info *monitors);
xrr_get_monitors_t xrr_get_monitors;
xrr_free_monitors_t xrr_free_monitors;
void *xrandr_handle;
Bool xrandr_ext_ok;
protected:
-
virtual int get_video_driver_count() const;
- virtual const char * get_video_driver_name(int p_driver) const;
+ virtual const char *get_video_driver_name(int p_driver) const;
virtual VideoMode get_default_video_mode() const;
virtual int get_audio_driver_count() const;
- virtual const char * get_audio_driver_name(int p_driver) const;
+ virtual const char *get_audio_driver_name(int p_driver) const;
- virtual void initialize(const VideoMode& p_desired,int p_video_driver,int p_audio_driver);
+ virtual void initialize(const VideoMode &p_desired, int p_video_driver, int p_audio_driver);
virtual void finalize();
- virtual void set_main_loop( MainLoop * p_main_loop );
-
+ virtual void set_main_loop(MainLoop *p_main_loop);
public:
-
virtual String get_name();
virtual void set_cursor_shape(CursorShape p_shape);
@@ -210,18 +206,18 @@ public:
void set_mouse_mode(MouseMode p_mode);
MouseMode get_mouse_mode() const;
- virtual void warp_mouse_pos(const Point2& p_to);
+ virtual void warp_mouse_pos(const Point2 &p_to);
virtual Point2 get_mouse_pos() const;
virtual int get_mouse_button_state() const;
- virtual void set_window_title(const String& p_title);
+ virtual void set_window_title(const String &p_title);
- virtual void set_icon(const Image& p_icon);
+ virtual void set_icon(const Image &p_icon);
virtual MainLoop *get_main_loop() const;
virtual bool can_draw() const;
- virtual void set_clipboard(const String& p_text);
+ virtual void set_clipboard(const String &p_text);
virtual String get_clipboard() const;
virtual void release_rendering_thread();
@@ -232,19 +228,18 @@ public:
virtual Error shell_open(String p_uri);
- virtual void set_video_mode(const VideoMode& p_video_mode,int p_screen=0);
- virtual VideoMode get_video_mode(int p_screen=0) const;
- virtual void get_fullscreen_mode_list(List<VideoMode> *p_list,int p_screen=0) const;
-
+ virtual void set_video_mode(const VideoMode &p_video_mode, int p_screen = 0);
+ virtual VideoMode get_video_mode(int p_screen = 0) const;
+ virtual void get_fullscreen_mode_list(List<VideoMode> *p_list, int p_screen = 0) const;
virtual int get_screen_count() const;
virtual int get_current_screen() const;
virtual void set_current_screen(int p_screen);
- virtual Point2 get_screen_position(int p_screen=0) const;
- virtual Size2 get_screen_size(int p_screen=0) const;
- virtual int get_screen_dpi(int p_screen=0) const;
+ virtual Point2 get_screen_position(int p_screen = 0) const;
+ virtual Size2 get_screen_size(int p_screen = 0) const;
+ virtual int get_screen_dpi(int p_screen = 0) const;
virtual Point2 get_window_position() const;
- virtual void set_window_position(const Point2& p_position);
+ virtual void set_window_position(const Point2 &p_position);
virtual Size2 get_window_size() const;
virtual void set_window_size(const Size2 p_size);
virtual void set_window_fullscreen(bool p_enabled);
@@ -258,7 +253,7 @@ public:
virtual void request_attention();
virtual void move_window_to_foreground();
- virtual void alert(const String& p_alert,const String& p_title="ALERT!");
+ virtual void alert(const String &p_alert, const String &p_title = "ALERT!");
virtual bool is_joy_known(int p_device);
virtual String get_joy_guid(int p_device) const;
generated by cgit v1.2.3-70-g09d2 (git 2.52.0) at 2026-01-19 21:32:30 +0000