forks
/
dlangui
mirror of https://github.com/buggins/dlangui.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
dlangui/3rdparty-extra/platforms/x11/x11app.d

1195 lines
36 KiB
D
Raw Blame History

// Written in the D programming language.
/**
This module contains implementation of Win32 platform support
Provides XCB platform and window classes.
Usually you don't need to use this module directly.
NOTE: Current implementation of XCB backend does not work well. Consider using of SDL2 backend instead.
Synopsis:
----
import dlangui.platforms.x11.x11app;
----
Copyright: Vadim Lopatin, 2014
License: Boost License 1.0
Authors: Vadim Lopatin, coolreader.org@gmail.com
*/
module src.dlangui.platforms.x11.x11app;
version(USE_XCB):
import std.string;
import std.c.linux.X11.xcb.xcb;
import std.c.linux.X11.xcb.shm;
import std.c.linux.X11.xcb.xproto;
import std.c.linux.X11.xcb.image;
import std.c.linux.X11.keysymdef;
import std.c.linux.linux;
import std.c.stdlib;
import std.conv;
import dlangui.core.logger;
import dlangui.core.events;
import dlangui.core.files;
import dlangui.graphics.drawbuf;
import dlangui.graphics.fonts;
import dlangui.graphics.ftfonts;
import dlangui.graphics.resources;
import dlangui.widgets.styles;
import dlangui.platforms.common.platform;
version (USE_OPENGL) {
import dlangui.graphics.glsupport;
}
import derelict.opengl3.gl3;
import derelict.opengl3.glx;
// pragma(lib, "xcb");
// pragma(lib, "xcb-shm");
// pragma(lib, "xcb-image");
// pragma(lib, "X11-xcb");
// pragma(lib, "X11");
// pragma(lib, "dl");
extern (System)
xcb_connection_t *XGetXCBConnection(std.c.linux.X11.Xlib.Display *dpy);
enum XEventQueueOwner { XlibOwnsEventQueue = 0, XCBOwnsEventQueue };
extern (System)
void XSetEventQueueOwner(std.c.linux.X11.Xlib.Display *dpy, XEventQueueOwner owner);
struct xcb_key_symbols_t {};
/* enumeration for col parameter? */
enum xcb_lookup_t {
xcb_lookup_none_t = 1,
xcb_lookup_chars_t = 2,
xcb_lookup_key_sym_t = 3,
xcb_lookup_both_t = 4
};
extern(C) xcb_key_symbols_t *xcb_key_symbols_alloc (xcb_connection_t *c);
extern(C) void xcb_key_symbols_free (xcb_key_symbols_t *syms);
extern(C) xcb_keysym_t xcb_key_symbols_get_keysym (xcb_key_symbols_t *syms,
xcb_keycode_t keycode,
int col);
extern(C) xcb_keysym_t xcb_key_press_lookup_keysym (xcb_key_symbols_t *syms,
xcb_key_press_event_t *event,
int col);
extern(C) xcb_keysym_t xcb_key_release_lookup_keysym (xcb_key_symbols_t *syms,
xcb_key_release_event_t *event,
int col);
class XCBWindow : Window {
xcb_window_t _w;
xcb_gcontext_t _g;
xcb_image_t * _image;
xcb_shm_segment_info_t shminfo;
version(USE_OPENGL) {
/* Create GLX Window */
private GLXDrawable _drawable;
private GLXWindow _glxwindow;
private GLXContext _context;
private GLXFBConfig _fb_config;
}
private int _visualID = 0;
private xcb_colormap_t _colormap;
@property xcb_window_t windowId() { return _w; }
this(string caption, Window parent) {
_caption = caption;
Log.d("Creating XCB window");
create();
}
~this() {
Log.d("Destroying window");
}
bool create() {
import std.c.linux.X11.Xlib;
uint mask;
uint[3] values;
// disable opengl for testing
_enableOpengl = false;
/* create black graphics context */
if (true || !_enableOpengl) {
_g = xcb_generate_id(_xcbconnection);
_w = _xcbscreen.root;
mask = XCB_GC_FOREGROUND | XCB_GC_GRAPHICS_EXPOSURES;
values[0] = _xcbscreen.black_pixel;
values[1] = 0;
xcb_create_gc(_xcbconnection, _g, _w, mask, &values[0]);
}
ubyte depth = _xcbscreen.root_depth;
/* create window */
_w = xcb_generate_id(_xcbconnection);
Log.d("window=", _w, " gc=", _g);
version (USE_OPENGL) {
if (_enableOpengl) {
int[] visual_attribs = [
GLX_RENDER_TYPE, GLX_RGBA_BIT,
GLX_DRAWABLE_TYPE, GLX_WINDOW_BIT,
GLX_DOUBLEBUFFER, 1,
GLX_RED_SIZE, 8,
GLX_GREEN_SIZE, 8,
GLX_BLUE_SIZE, 8,
std.c.linux.X11.Xlib.None];
Log.d("Getting framebuffer config");
int fbcount;
GLXFBConfig *fbc = glXChooseFBConfig(_display, DefaultScreen(_display), visual_attribs.ptr, &fbcount);
if (!fbc)
{
Log.d("Failed to retrieve a framebuffer config");
//return 1;
}
Log.d("Getting XVisualInfo");
_fb_config = fbc[0];
auto vi = glXGetVisualFromFBConfig(_display, _fb_config);
//auto vi = glXChooseVisual(_display, std.c.linux.X11.Xlib.DefaultScreen(_display), attributeList.ptr);
_visualID = vi.visualid;
//swa.colormap = std.c.linux.X11.Xlib.XCreateColormap(_display, std.c.linux.X11.Xlib.RootWindow(_display, vi.screen), vi.visual, 0); // AllocNone
Log.d("Creating color map");
_colormap = xcb_generate_id(_xcbconnection);
/* Create colormap */
xcb_create_colormap(
_xcbconnection,
XCB_COLORMAP_ALLOC_NONE,
_colormap,
_xcbscreen.root,
_visualID
);
depth = cast(ubyte)vi.depth;
}
}
//mask = XCB_CW_BACK_PIXEL | XCB_CW_EVENT_MASK;
//values[0] = _xcbscreen.white_pixel;
int visualId;
uint eventmask =
XCB_EVENT_MASK_EXPOSURE | XCB_EVENT_MASK_KEY_PRESS | XCB_EVENT_MASK_BUTTON_PRESS | XCB_EVENT_MASK_BUTTON_RELEASE
| XCB_EVENT_MASK_POINTER_MOTION | XCB_EVENT_MASK_BUTTON_MOTION
| XCB_EVENT_MASK_ENTER_WINDOW | XCB_EVENT_MASK_LEAVE_WINDOW
| XCB_EVENT_MASK_KEY_PRESS | XCB_EVENT_MASK_KEY_RELEASE
| XCB_EVENT_MASK_STRUCTURE_NOTIFY | XCB_EVENT_MASK_VISIBILITY_CHANGE;
if (_enableOpengl) {
mask = XCB_CW_BACK_PIXEL | XCB_CW_EVENT_MASK | XCB_CW_COLORMAP;
values[0] = _xcbscreen.white_pixel;
values[1] = eventmask;
values[2] = _colormap;
//visualId = _xcbscreen.root_visual;
visualId = _visualID;
} else {
mask = XCB_CW_BACK_PIXEL | XCB_CW_EVENT_MASK;
values[0] = _xcbscreen.white_pixel;
values[1] = eventmask;
visualId = _xcbscreen.root_visual;
}
Log.d("xcb_create_window - window=", _w, " VisualID=", _visualID);
auto res = xcb_create_window(_xcbconnection,
depth, //_xcbscreen.root_depth,
//XCB_COPY_FROM_PARENT,//_xcbscreen.root_depth,
_w,
_xcbscreen.root,
30, 30, 800, 650,
1,
XCB_WINDOW_CLASS_INPUT_OUTPUT,
visualId,
mask,
&values[0]);
xcb_flush(_xcbconnection);
windowCaption = _caption;
return true;
}
private int _imageDx;
private int _imageDy;
void createImage() {
if (_image) {
if (_imageDx == _imageDx && _imageDy == _dy)
return; // already have image of proper size
Log.i("CRXCBScreen::createImage - destroying existing image");
xcb_image_destroy(_image);
_image = null;
}
_imageDx = _dx;
_imageDy = _dy;
Log.i("CRXCBScreen::createImage ", _dx, "x", _dy);
xcb_shm_query_version_reply_t * rep_shm;
rep_shm = xcb_shm_query_version_reply (_xcbconnection,
xcb_shm_query_version(_xcbconnection),
null);
if(rep_shm) {
xcb_image_format_t format;
int shmctl_status;
if (rep_shm.shared_pixmaps &&
(rep_shm.major_version > 1 || rep_shm.minor_version > 0))
format = cast(xcb_image_format_t)rep_shm.pixmap_format;
else
format = XCB_IMAGE_FORMAT_Z_PIXMAP;
_image = xcb_image_create_native (_xcbconnection, cast(short)_dx, cast(short)_dy,
format, _xcbscreendepth, null, ~0, null);
//format, depth, NULL, ~0, NULL);
//format, depth, NULL, ~0, NULL);
assert(_image);
shminfo.shmid = shmget (IPC_PRIVATE,
_image.stride*_image.height,
IPC_CREAT | octal!777);
assert(shminfo.shmid != cast(uint)-1);
shminfo.shmaddr = cast(ubyte*)shmat (shminfo.shmid, null, 0);
assert(shminfo.shmaddr);
_image.data = shminfo.shmaddr;
Log.d("Created image depth=", _image.depth, " bpp=", _image.bpp, " stride=", _image.stride );
shminfo.shmseg = xcb_generate_id (_xcbconnection);
xcb_shm_attach (_xcbconnection, shminfo.shmseg,
shminfo.shmid, 0);
shmctl_status = shmctl(shminfo.shmid, IPC_RMID, null);
assert(shmctl_status != -1);
free(rep_shm);
} else {
Log.e("Can't get shms");
}
}
void draw(ColorDrawBuf buf) {
int i;
i = xcb_image_shm_get(_xcbconnection, _w,
_image, shminfo,
0, 0,
XCB_ALL_PLANES);
if (!i) {
Log.e("cannot get shm image");
return;
}
Rect rc;
rc.right = buf.width;
rc.bottom = buf.height;
switch ( _image.bpp ) {
case 32:
{
for (int y = rc.top; y<rc.bottom; y++) {
uint * src = buf.scanLine(y);
uint * dst = cast(uint *)(_image.data + _image.stride * y);
for ( int x = 0; x < rc.right; x++ ) {
uint data = src[x];
dst[x] = data;
}
}
}
break;
default:
Log.d("image bit depth not supported: ", _image.bpp);
break;
}
xcb_image_shm_put(_xcbconnection, _w, _g,
_image, shminfo,
cast(short)rc.left, cast(short)rc.top, cast(short)rc.left, cast(short)rc.top, cast(ushort)rc.width(), cast(ushort)rc.height(), 0);
xcb_flush(_xcbconnection);
}
bool _derelictgl3Reloaded;
override void show() {
Log.d("XCBWindow.show()");
/* map (show) the window */
xcb_map_window(_xcbconnection, _w);
xcb_flush(_xcbconnection);
//_enableOpengl = false; // test
version (USE_OPENGL) {
if (_enableOpengl && !_glxwindow) {
Log.d("Calling glXCreateWindow display=", _display, " fbconfig=", _fb_config, " window=", _w);
_glxwindow = glXCreateWindow(
_display,
_fb_config,
_w,
null);
if (!_glxwindow) {
Log.e("Failed to create GLX window: disabling OpenGL");
_enableOpengl = false;
} else {
import derelict.opengl3.glxext;
import std.c.linux.X11.Xlib;
_drawable = _glxwindow;
if (!_derelictgl3Reloaded) {
int count;
glGetIntegerv( GL_NUM_EXTENSIONS, &count );
Log.d("Number of extensions: ", count);
for( int i=0; i<count; ++i ) {
auto e = glGetStringi( GL_EXTENSIONS, i );
Log.d("Extension: ", fromStringz(e));
}
Log.e("Reloading DerelictGL3");
_derelictgl3Reloaded = true;
_context = glXCreateNewContext(_display, _fb_config, GLX_RGBA_TYPE, null, true);
if (_context is null) {
Log.e("Cannot create temporary context");
}
//glXMakeContextCurrent(_display, _drawable, _drawable, _context);
glXMakeContextCurrent(_display, _glxwindow, _glxwindow, _context);
//glXMakeCurrent(_display, _w, _context);
DerelictGL3.reload();
Log.e("Reloaded DerelictGL3 - removing temporary context");
glXMakeCurrent(_display, 0, null);
Log.e("Destroying context");
glXDestroyContext(_display, _context);
Log.e("DerelictGL3 initialized");
_context = null;
}
// Get the default screen's GLX extension list
const char *glxExts = glXQueryExtensionsString( _display,
DefaultScreen( _display ) );
Log.d("GLX Extensions: ", fromStringz(glxExts));
const char * exts = glGetString( GL_EXTENSIONS );
Log.d("Extensions: ", fromStringz(exts));
Log.d("GLX_ARB_get_proc_address=", GLX_ARB_get_proc_address);
Log.d("GLX_ARB_create_context=", GLX_ARB_create_context);
//da_glXCreateContextAttribsARB glXCreateContextAttribsARB;
//Log.d("getting address of glXCreateContextAttribsARB");
//glXCreateContextAttribsARB = cast(da_glXCreateContextAttribsARB)
// glXGetProcAddressARB( cast(const GLubyte *)("glXCreateContextAttribsARB".toStringz));
//Log.d("glXCreateContextAttribsARB = ", &glXCreateContextAttribsARB);
Log.d("Creating context");
//_context = glXCreateNewContext(_display, _fb_config, GLX_RGBA_TYPE, null, true);
if (!GLX_ARB_create_context) {
Log.e("glXCreateContextAttribsARB function is not found");
_context = glXCreateNewContext(_display, _fb_config, GLX_RGBA_TYPE, null, true);
} else {
int[] context_attribs =
[
GLX_CONTEXT_MAJOR_VERSION_ARB, 3,
GLX_CONTEXT_MINOR_VERSION_ARB, 0,
None
];
Log.e("calling glXCreateContextAttribsARB");
_context = glXCreateContextAttribsARB(_display, _fb_config, null, true, context_attribs.ptr);
}
Log.d("Created context: ", _context);
/* Create OpenGL context */
//auto context = glXCreateNewContext(_display, _fb_config, GLX_RGBA_TYPE, null, true);
if (!_context) {
_enableOpengl = false;
Log.e("Failed to create OpenGL context");
} else {
}
/* make OpenGL context current */
if(!glXMakeContextCurrent(_display, _drawable, _drawable, _context) || !initShaders()) {
Log.e("Failed to make GL context current");
_enableOpengl = false;
glXDestroyContext(_display, _context);
_context = null;
} else {
}
}
}
}
}
protected string _caption;
override @property string windowCaption() {
return _caption;
}
override @property void windowCaption(string caption) {
_caption = caption;
const char * title = _caption.toStringz;
xcb_change_property (_xcbconnection,
XCB_PROP_MODE_REPLACE,
_w,
XCB_ATOM_WM_NAME,
XCB_ATOM_STRING,
8,
cast(uint)_caption.length,
cast(void*)title);
}
void redraw() {
if (_enableOpengl) {
version(USE_OPENGL) {
import std.c.linux.X11.Xlib;
Log.d("Drawing using opengl ", _dx, "x", _dy, " context=", _context);
//glXMakeContextCurrent(_display, _drawable, _drawable, _context);
glXMakeContextCurrent(_display, _glxwindow, _glxwindow, _context);
glEnable(GL_BLEND);
glDisable(GL_CULL_FACE);
glDisable(GL_DEPTH_TEST);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glViewport(0, 0, _dx, _dy);
Log.d("glClearColor");
glClearColor(0.2f, 0.4f, 0.9f, 1.0f);
Log.d("glClear");
glClear(GL_COLOR_BUFFER_BIT);
import dlangui.graphics.gldrawbuf;
GLDrawBuf buf = new GLDrawBuf(_dx, _dy);
buf.beforeDrawing();
onDraw(buf);
buf.fillRect(Rect(0, 0, 100, 100), 0x805010);
buf.afterDrawing();
destroy(buf);
Log.d("Calling glx swap buffers for drawable ", _drawable);
glXSwapBuffers(_display, _drawable);
//glXMakeContextCurrent(_display, _drawable, _drawable, null);
xcb_flush(_xcbconnection);
glXMakeContextCurrent (_display, None, None, null);
glXWaitGL();
}
} else {
if (!_drawbuf)
_drawbuf = new ColorDrawBuf(_dx, _dy);
_drawbuf.resize(_dx, _dy);
_drawbuf.fill(_backgroundColor);
//Log.d("calling createImage");
createImage();
//Log.d("done createImage");
onDraw(_drawbuf);
draw(_drawbuf);
/*
xcb_rectangle_t r = { 20, 20, 60, 60 };
xcb_poly_fill_rectangle(_xcbconnection, _w, _g, 1, &r);
r = xcb_rectangle_t(cast(short)(_dx - 20 - 60), cast(short)(_dy - 20 - 60), 60, 60);
xcb_poly_fill_rectangle(_xcbconnection, _w, _g, 1, &r);
*/
xcb_flush(_xcbconnection);
}
}
ColorDrawBuf _drawbuf;
bool _exposeSent;
void processExpose(xcb_expose_event_t * event) {
redraw();
_exposeSent = false;
}
/// request window redraw
override void invalidate() {
if (_exposeSent)
return;
_exposeSent = true;
xcb_expose_event_t * event = cast(xcb_expose_event_t*)std.c.stdlib.malloc(xcb_expose_event_t.sizeof);
event.response_type = XCB_EXPOSE; /* The type of the event, here it is XCB_EXPOSE */
event.sequence = 0;
event.window = _w; /* The Id of the window that receives the event (in case */
/* our application registered for events on several windows */
event.x = 0; /* The x coordinate of the top-left part of the window that needs to be redrawn */
event.y = 0; /* The y coordinate of the top-left part of the window that needs to be redrawn */
event.width = cast(ushort)_dx; /* The width of the part of the window that needs to be redrawn */
event.height = cast(ushort)_dy; /* The height of the part of the window that needs to be redrawn */
event.count = 1;
xcb_void_cookie_t res = xcb_send_event(_xcbconnection, false, _w, XCB_EVENT_MASK_EXPOSURE, cast(char *)event);
xcb_flush(_xcbconnection);
}
protected ButtonDetails _lbutton;
protected ButtonDetails _mbutton;
protected ButtonDetails _rbutton;
void processMouseEvent(MouseAction action, ubyte detail, ushort state, short x, short y) {
MouseButton button = MouseButton.None;
short wheelDelta = 0;
ButtonDetails * pbuttonDetails = null;
ushort flags = 0;
if (state & XCB_BUTTON_MASK_1)
flags |= MouseFlag.LButton;
if (state & XCB_BUTTON_MASK_2)
flags |= MouseFlag.MButton;
if (state & XCB_BUTTON_MASK_3)
flags |= MouseFlag.RButton;
if (state & XCB_MOD_MASK_SHIFT)
flags |= MouseFlag.Shift;
if (state & XCB_MOD_MASK_CONTROL)
flags |= MouseFlag.Control;
if (state & XCB_MOD_MASK_LOCK)
flags |= MouseFlag.Alt;
if (action == MouseAction.ButtonDown || action == MouseAction.ButtonUp) {
switch (detail) {
case 1:
button = MouseButton.Left;
pbuttonDetails = &_lbutton;
if (action == MouseAction.ButtonDown)
flags |= MouseFlag.LButton;
else if (action == MouseAction.ButtonUp)
flags &= ~MouseFlag.LButton;
break;
case 2:
button = MouseButton.Middle;
pbuttonDetails = &_mbutton;
if (action == MouseAction.ButtonDown)
flags |= MouseFlag.MButton;
else if (action == MouseAction.ButtonUp)
flags &= ~MouseFlag.MButton;
break;
case 3:
button = MouseButton.Right;
pbuttonDetails = &_rbutton;
if (action == MouseAction.ButtonDown)
flags |= MouseFlag.RButton;
else if (action == MouseAction.ButtonUp)
flags &= ~MouseFlag.RButton;
break;
case 4:
if (action == MouseAction.ButtonUp)
return;
wheelDelta = -1;
action = MouseAction.Wheel;
break;
case 5:
if (action == MouseAction.ButtonUp)
return;
wheelDelta = 1;
action = MouseAction.Wheel;
break;
default:
// unknown button
return;
}
}
//Log.d("processMouseEvent ", action, " detail=", detail, " state=", state, " at coords ", x, ", ", y);
if (action == MouseAction.ButtonDown) {
pbuttonDetails.down(x, y, cast(ushort)flags);
} else if (action == MouseAction.ButtonUp) {
pbuttonDetails.up(x, y, cast(ushort)flags);
}
MouseEvent event = new MouseEvent(action, button, cast(ushort)flags, x, y, wheelDelta);
event.lbutton = _lbutton;
event.rbutton = _rbutton;
event.mbutton = _mbutton;
bool res = dispatchMouseEvent(event);
if (res) {
Log.d("Calling update() after mouse event");
invalidate();
}
}
uint convertKeyCode(uint keyCode) {
switch (keyCode) {
case XK_BackSpace:
return KeyCode.BACK;
case XK_Tab:
return KeyCode.TAB;
case XK_Linefeed:
case XK_Return:
return KeyCode.RETURN;
case XK_Shift_L:
return KeyCode.LSHIFT;
case XK_Shift_R:
return KeyCode.RSHIFT;
case XK_Control_L:
return KeyCode.LCONTROL;
case XK_Control_R:
return KeyCode.RCONTROL;
case XK_Alt_L:
return KeyCode.LALT;
case XK_Alt_R:
return KeyCode.RALT;
case XK_Pause:
return KeyCode.PAUSE;
case XK_Caps_Lock:
return KeyCode.CAPS;
case XK_Escape:
return KeyCode.ESCAPE;
case XK_KP_Space:
return KeyCode.SPACE;
case XK_KP_Page_Up:
case XK_Page_Up:
return KeyCode.PAGEUP;
case XK_KP_Page_Down:
case XK_Page_Down:
return KeyCode.PAGEDOWN;
case XK_End:
case XK_KP_End:
return KeyCode.END;
case XK_Home:
case XK_KP_Home:
return KeyCode.HOME;
case XK_KP_Left:
case XK_Left:
return KeyCode.LEFT;
case XK_KP_Up:
case XK_Up:
return KeyCode.UP;
case XK_KP_Right:
case XK_Right:
return KeyCode.RIGHT;
case XK_KP_Down:
case XK_Down:
return KeyCode.DOWN;
case XK_Insert:
case XK_KP_Insert:
return KeyCode.INS;
case XK_KP_Delete:
case XK_Delete:
return KeyCode.DEL;
case XK_0:
return KeyCode.KEY_0;
case XK_1:
return KeyCode.KEY_1;
case XK_2:
return KeyCode.KEY_2;
case XK_3:
return KeyCode.KEY_3;
case XK_4:
return KeyCode.KEY_4;
case XK_5:
return KeyCode.KEY_5;
case XK_6:
return KeyCode.KEY_6;
case XK_7:
return KeyCode.KEY_7;
case XK_8:
return KeyCode.KEY_8;
case XK_9:
return KeyCode.KEY_9;
case XK_A:
return KeyCode.KEY_A;
case XK_B:
return KeyCode.KEY_B;
case XK_C:
return KeyCode.KEY_C;
case XK_D:
return KeyCode.KEY_D;
case XK_E:
return KeyCode.KEY_E;
case XK_F:
return KeyCode.KEY_F;
case XK_G:
return KeyCode.KEY_G;
case XK_H:
return KeyCode.KEY_H;
case XK_I:
return KeyCode.KEY_I;
case XK_J:
return KeyCode.KEY_J;
case XK_K:
return KeyCode.KEY_K;
case XK_L:
return KeyCode.KEY_L;
case XK_M:
return KeyCode.KEY_M;
case XK_N:
return KeyCode.KEY_N;
case XK_O:
return KeyCode.KEY_O;
case XK_P:
return KeyCode.KEY_P;
case XK_Q:
return KeyCode.KEY_Q;
case XK_R:
return KeyCode.KEY_R;
case XK_S:
return KeyCode.KEY_S;
case XK_T:
return KeyCode.KEY_T;
case XK_U:
return KeyCode.KEY_U;
case XK_V:
return KeyCode.KEY_V;
case XK_W:
return KeyCode.KEY_W;
case XK_X:
return KeyCode.KEY_X;
case XK_Y:
return KeyCode.KEY_Y;
case XK_Z:
return KeyCode.KEY_Z;
//return KeyCode.LWIN = 0x5b,
//return KeyCode.RWIN = 0x5c,
case XK_KP_0:
return KeyCode.NUM_0;
case XK_KP_1:
return KeyCode.NUM_1;
case XK_KP_2:
return KeyCode.NUM_2;
case XK_KP_3:
return KeyCode.NUM_3;
case XK_KP_4:
return KeyCode.NUM_4;
case XK_KP_5:
return KeyCode.NUM_5;
case XK_KP_6:
return KeyCode.NUM_6;
case XK_KP_7:
return KeyCode.NUM_7;
case XK_KP_8:
return KeyCode.NUM_8;
case XK_KP_9:
return KeyCode.NUM_9;
case XK_asterisk:
return KeyCode.MUL;
case XK_plus:
return KeyCode.ADD;
case XK_slash:
return KeyCode.DIV;
case XK_minus:
return KeyCode.SUB;
case XK_period:
return KeyCode.DECIMAL;
case XK_F1:
return KeyCode.F1;
case XK_F2:
return KeyCode.F2;
case XK_F3:
return KeyCode.F3;
case XK_F4:
return KeyCode.F4;
case XK_F5:
return KeyCode.F5;
case XK_F6:
return KeyCode.F6;
case XK_F7:
return KeyCode.F7;
case XK_F8:
return KeyCode.F8;
case XK_F9:
return KeyCode.F9;
case XK_F10:
return KeyCode.F10;
case XK_F11:
return KeyCode.F11;
case XK_F12:
return KeyCode.F12;
case XK_Num_Lock:
return KeyCode.NUMLOCK;
case XK_Scroll_Lock:
return KeyCode.SCROLL;
default:
return 0x10000 | keyCode;
}
}
uint convertKeyFlags(uint flags) {
return 0;
}
bool processKeyEvent(KeyAction action, uint keyCode, uint flags) {
Log.d("processKeyEvent ", action, " x11 key=", keyCode, " x11 flags=", flags);
keyCode = convertKeyCode(keyCode);
flags = convertKeyFlags(flags);
Log.d("processKeyEvent ", action, " converted key=", keyCode, " converted flags=", flags);
bool res = dispatchKeyEvent(new KeyEvent(action, keyCode, flags));
if (keyCode & 0x10000 && (keyCode & 0xF000) != 0xF000) {
dchar[1] text;
text[0] = keyCode & 0xFFFF;
res = dispatchKeyEvent(new KeyEvent(KeyAction.Text, keyCode, flags, cast(dstring)text)) || res;
}
if (res) {
Log.d("Calling update() after key event");
invalidate();
}
return res;
}
}
private __gshared xcb_connection_t * _xcbconnection;
private __gshared xcb_screen_t * _xcbscreen;
private __gshared ubyte _xcbscreendepth;
private __gshared bool _enableOpengl;
private __gshared std.c.linux.X11.Xlib.Display * _display;
class XCBPlatform : Platform {
this() {
}
~this() {
foreach(ref XCBWindow wnd; _windowMap) {
destroy(wnd);
wnd = null;
}
_windowMap.clear();
disconnect();
}
void disconnect() {
/* Cleanup */
if (_display) {
Log.d("Closing X display");
std.c.linux.X11.Xlib.XCloseDisplay(_display);
_display = null;
} else if (_xcbconnection) {
Log.d("Closing XCB connection");
/* close connection to server */
xcb_disconnect(_xcbconnection);
_xcbconnection = null;
}
}
bool connect() {
try {
DerelictGL3.load();
_enableOpengl = true;
} catch (Exception e) {
Log.e("Cannot load opengl library", e);
}
//_enableOpengl = false; // test
// X
import std.c.linux.X11.Xlib;
int default_screen;
if (_enableOpengl) {
Log.d("Opening display via XLib");
/* Open Xlib Display */
_display = XOpenDisplay(null);
if (!_display)
{
Log.e("Failed to open display using Xlib");
_enableOpengl = false;
} else {
// display is opened
default_screen = DefaultScreen(_display);
Log.d("Opened display =");
/* Get the XCB connection from the display */
_xcbconnection = XGetXCBConnection(_display);
if (!_xcbconnection)
{
XCloseDisplay(_display);
_display = null;
Log.e("Failed to get XCB connection from Xlib display");
_enableOpengl = false;
} else {
/* Acquire event queue ownership */
XSetEventQueueOwner(_display, XEventQueueOwner.XCBOwnsEventQueue);
}
}
}
if (_xcbconnection is null) {
Log.d("Opening XCB connection");
/* open connection with the server */
_xcbconnection = xcb_connect(null,null);
}
if (xcb_connection_has_error(_xcbconnection)) {
Log.e("Cannot open display");
_xcbconnection = null;
return false;
}
//XSetEventQueueOwner(display, XCBOwnsEventQueue);
Log.d("Getting first screen");
/* get the first screen */
if (_enableOpengl) {
/* Find XCB screen */
//xcb_screen_t *screen = null;
xcb_screen_iterator_t screen_iter =
xcb_setup_roots_iterator(xcb_get_setup(_xcbconnection));
for(int screen_num = default_screen;
screen_iter.rem && screen_num > 0;
--screen_num, xcb_screen_next(&screen_iter)) {
}
_xcbscreen = screen_iter.data;
} else {
_xcbscreen = xcb_setup_roots_iterator( xcb_get_setup(_xcbconnection) ).data;
}
_xcbscreendepth = xcb_aux_get_depth(_xcbconnection, _xcbscreen);
if (_enableOpengl) {
int versionMajor;
int versionMinor;
if (!glXQueryVersion(_display,
&versionMajor,
&versionMinor)) {
Log.e("Cannot get GLX version");
} else {
Log.e("GLX version: ", versionMajor, ".", versionMinor);
}
}
return true;
}
XCBWindow getWindow(xcb_window_t w) {
if (w in _windowMap)
return _windowMap[w];
return null;
}
override Window createWindow(string windowCaption, Window parent) {
XCBWindow res = new XCBWindow(windowCaption, parent);
_windowMap[res.windowId] = res;
return res;
}
override int enterMessageLoop() {
Log.i("entering message loop");
int done = 0;
xcb_generic_event_t *e;
xcb_key_symbols_t * keysyms;// = xcb_key_symbols_alloc(_xcbconnection);
keysyms = xcb_key_symbols_alloc(_xcbconnection);
if (!keysyms)
Log.e("xcb_key_symbols_alloc returned null");
/* event loop */
do {
e = xcb_wait_for_event(_xcbconnection);
if (e is null) {
Log.w("NULL event received. Exiting message loop");
break;
}
switch (e.response_type & ~0x80) {
case XCB_CREATE_NOTIFY: {
xcb_create_notify_event_t *event = cast(xcb_create_notify_event_t *)e;
Log.i("XCB_CREATE_NOTIFY");
XCBWindow window = getWindow(event.window);
if (window !is null) {
//
} else {
Log.w("Received message for unknown window", event.window);
}
break;
}
case XCB_DESTROY_NOTIFY: {
xcb_destroy_notify_event_t *event = cast(xcb_destroy_notify_event_t *)e;
Log.i("XCB_DESTROY_NOTIFY");
XCBWindow window = getWindow(event.window);
if (window !is null) {
//
} else {
Log.w("Received message for unknown window", event.window);
}
break;
}
case XCB_MAP_NOTIFY: {
xcb_map_notify_event_t *event = cast(xcb_map_notify_event_t *)e;
Log.i("XCB_MAP_NOTIFY");
XCBWindow window = getWindow(event.window);
if (window !is null) {
//
} else {
Log.w("Received message for unknown window", event.window);
}
break;
}
case XCB_UNMAP_NOTIFY: {
xcb_unmap_notify_event_t *event = cast(xcb_unmap_notify_event_t *)e;
Log.i("XCB_UNMAP_NOTIFY");
XCBWindow window = getWindow(event.window);
if (window !is null) {
//
} else {
Log.w("Received message for unknown window", event.window);
}
break;
}
case XCB_VISIBILITY_NOTIFY: {
xcb_visibility_notify_event_t *event = cast(xcb_visibility_notify_event_t *)e;
Log.i("XCB_VISIBILITY_NOTIFY ", event.state);
XCBWindow window = getWindow(event.window);
if (window !is null) {
//
} else {
Log.w("Received message for unknown window", event.window);
}
break;
}
case XCB_REPARENT_NOTIFY: {
xcb_reparent_notify_event_t *event = cast(xcb_reparent_notify_event_t *)e;
Log.i("XCB_REPARENT_NOTIFY");
break;
}
case XCB_CONFIGURE_NOTIFY: {
xcb_configure_notify_event_t *event = cast(xcb_configure_notify_event_t *)e;
Log.i("XCB_CONFIGURE_NOTIFY ", event.width, "x", event.height);
XCBWindow window = getWindow(event.window);
if (window !is null) {
//
window.onResize(event.width, event.height);
} else {
Log.w("Received message for unknown window", event.window);
}
break;
}
case XCB_EXPOSE: { /* draw or redraw the window */
xcb_expose_event_t *expose = cast(xcb_expose_event_t *)e;
Log.i("XCB_EXPOSE");
XCBWindow window = getWindow(expose.window);
if (window !is null) {
window.processExpose(expose);
} else {
Log.w("Received message for unknown window", expose.window);
}
break;
}
case XCB_BUTTON_PRESS: {
xcb_button_press_event_t *bp = cast(xcb_button_press_event_t *)e;
Log.d("XCB_BUTTON_PRESS");
XCBWindow window = getWindow(bp.event);
if (window !is null) {
//
window.processMouseEvent(MouseAction.ButtonDown, bp.detail, bp.state, bp.event_x, bp.event_y);
} else {
Log.w("Received message for unknown window", bp.event);
}
break;
}
case XCB_BUTTON_RELEASE: {
Log.d("XCB_BUTTON_RELEASE");
xcb_button_release_event_t *br = cast(xcb_button_release_event_t *)e;
XCBWindow window = getWindow(br.event);
if (window !is null) {
//
window.processMouseEvent(MouseAction.ButtonUp, br.detail, br.state, br.event_x, br.event_y);
} else {
Log.w("Received message for unknown window", br.event);
}
break;
}
case XCB_MOTION_NOTIFY: {
xcb_motion_notify_event_t *motion = cast(xcb_motion_notify_event_t *)e;
//Log.d("XCB_MOTION_NOTIFY ", motion.event, " at coords ", motion.event_x, ", ", motion.event_y);
XCBWindow window = getWindow(motion.event);
if (window !is null) {
//
window.processMouseEvent(MouseAction.Move, 0, motion.state, motion.event_x, motion.event_y);
} else {
Log.w("Received message for unknown window", motion.event);
}
break;
}
case XCB_ENTER_NOTIFY: {
xcb_enter_notify_event_t *enter = cast(xcb_enter_notify_event_t *)e;
Log.d("XCB_ENTER_NOTIFY ", enter.event, " at coords ", enter.event_x, ", ", enter.event_y);
break;
}
case XCB_LEAVE_NOTIFY: {
xcb_leave_notify_event_t *leave = cast(xcb_leave_notify_event_t *)e;
Log.d("XCB_LEAVE_NOTIFY ", leave.event, " at coords ", leave.event_x, ", ", leave.event_y);
XCBWindow window = getWindow(leave.event);
if (window !is null) {
//
window.processMouseEvent(MouseAction.Leave, 0, leave.state, leave.event_x, leave.event_y);
} else {
Log.w("Received message for unknown window", leave.event);
}
break;
}
case XCB_KEY_PRESS: {
xcb_key_press_event_t *kp = cast(xcb_key_press_event_t *)e;
//print_modifiers(kp.state);
Log.d("XCB_KEY_PRESS ", kp.event, " key=", kp.detail);
XCBWindow window = getWindow(kp.event);
if (window !is null) {
//xcb_keysym_t keysym = xcb_key_press_lookup_keysym(keysyms, kp, xcb_lookup_t.xcb_lookup_key_sym_t);
xcb_keysym_t keysym = xcb_key_press_lookup_keysym(keysyms, kp, 2);
Log.d("xcb_key_press_lookup_keysym - key=", kp.detail, " keysym=", keysym);
//xcb_keysym_t keysym = xcb_key_symbols_get_keysym(keysyms, kp.detail, xcb_lookup_t.xcb_lookup_key_sym_t);
window.processKeyEvent(KeyAction.KeyDown, keysym, kp.state);
}
//if (kp.detail == XK_space) // exist by space
// done = 1;
break;
}
case XCB_KEY_RELEASE: {
xcb_key_release_event_t *kr = cast(xcb_key_release_event_t *)e;
//print_modifiers(kr.state);
Log.d("XCB_KEY_RELEASE ", kr.event, " key=", kr.detail);
XCBWindow window = getWindow(kr.event);
if (window !is null) {
//xcb_keysym_t keysym = xcb_key_symbols_get_keysym(keysyms, kr.detail, xcb_lookup_t.xcb_lookup_key_sym_t);
xcb_keysym_t keysym = xcb_key_release_lookup_keysym(keysyms, kr, 2);
window.processKeyEvent(KeyAction.KeyUp, keysym, kr.state);
}
break;
}
default:
Log.v("unknown event: ", e.response_type & ~0x80);
break;
}
free(e);
} while(!done);
if (keysyms)
xcb_key_symbols_free(keysyms);
Log.i("exiting message loop");
return 0;
}
/// retrieves text from clipboard (when mouseBuffer == true, use mouse selection clipboard - under linux)
override dstring getClipboardText(bool mouseBuffer = false) {
return ""d;
}
/// sets text to clipboard (when mouseBuffer == true, use mouse selection clipboard - under linux)
override void setClipboardText(dstring text, bool mouseBuffer = false) {
}
protected XCBWindow[xcb_window_t] _windowMap;
}
// entry point
extern(C) int UIAppMain(string[] args);
int main(string[] args)
{
setStderrLogger();
Log.setLogLevel(LogLevel.Trace);
FreeTypeFontManager ft = new FreeTypeFontManager();
ft.registerFont("/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf", FontFamily.SansSerif, "DejaVu", false, FontWeight.Normal);
FontManager.instance = ft;
currentTheme = createDefaultTheme();
XCBPlatform xcb = new XCBPlatform();
if (!xcb.connect()) {
return 1;
}
Platform.setInstance(xcb);
int res = 0;
static if (true) {
res = UIAppMain(args);
} else {
Window window = xcb.createWindow("Window Caption", null);
window.show();
res = xcb.enterMessageLoop();
}
Platform.setInstance(null);
Log.d("Destroying XCB platform");
destroy(xcb);
currentTheme = null;
drawableCache = null;
imageCache = null;
FontManager.instance = null;
Log.d("Exiting main");
return res;
}
Reference in New Issue View Git Blame Copy Permalink