forks
/
dlangui
mirror of https://github.com/buggins/dlangui.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

XCB platform

This commit is contained in:
Vadim Lopatin 2014-03-14 12:15:21 +04:00
parent f3584dd6fc
commit 5135e9ec30
4 changed files with 2652 additions and 77 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2438
3rdparty/X11/keysymdef.d vendored Normal file
View File

File diff suppressed because it is too large Load Diff

1
dlanguilib.dproj
View File

@ -159,6 +159,7 @@
<Compile Include="3rdparty\X11\xcb\xtest.d" /> <Compile Include="3rdparty\X11\xcb\xtest.d" />
<Compile Include="3rdparty\X11\xcb\xv.d" /> <Compile Include="3rdparty\X11\xcb\xv.d" />
<Compile Include="3rdparty\X11\xcb\xvmc.d" /> <Compile Include="3rdparty\X11\xcb\xvmc.d" />
<Compile Include="3rdparty\X11\keysymdef.d" />
</ItemGroup> </ItemGroup>
<ItemGroup> <ItemGroup>
<Folder Include="src\dlangui\platforms\x11\" /> <Folder Include="src\dlangui\platforms\x11\" />

30
src/dlangui/platforms/common/platform.d
View File

@ -5,24 +5,24 @@ import dlangui.graphics.drawbuf;
import std.file; import std.file;
private import dlangui.graphics.gldrawbuf; private import dlangui.graphics.gldrawbuf;
public class Window { class Window {
int _dx; int _dx;
int _dy; int _dy;
Widget _mainWidget; Widget _mainWidget;
public @property int width() { return _dx; } @property int width() { return _dx; }
public @property int height() { return _dy; } @property int height() { return _dy; }
public @property Widget mainWidget() { return _mainWidget; } @property Widget mainWidget() { return _mainWidget; }
public @property void mainWidget(Widget widget) { @property void mainWidget(Widget widget) {
if (_mainWidget !is null) if (_mainWidget !is null)
_mainWidget.window = null; _mainWidget.window = null;
_mainWidget = widget; _mainWidget = widget;
if (_mainWidget !is null) if (_mainWidget !is null)
_mainWidget.window = this; _mainWidget.window = this;
} }
abstract public void show(); abstract void show();
abstract public @property string windowCaption(); abstract @property string windowCaption();
abstract public @property void windowCaption(string caption); abstract @property void windowCaption(string caption);
public void onResize(int width, int height) { void onResize(int width, int height) {
if (_dx == width && _dy == height) if (_dx == width && _dy == height)
return; return;
_dx = width; _dx = width;
@ -32,23 +32,23 @@ public class Window {
_mainWidget.layout(Rect(0, 0, _dx, _dy)); _mainWidget.layout(Rect(0, 0, _dx, _dy));
} }
} }
public void onDraw(DrawBuf buf) { void onDraw(DrawBuf buf) {
if (_mainWidget !is null) { if (_mainWidget !is null) {
_mainWidget.onDraw(buf); _mainWidget.onDraw(buf);
} }
} }
} }
public class Platform { class Platform {
static __gshared Platform _instance; static __gshared Platform _instance;
public static void setInstance(Platform instance) { static void setInstance(Platform instance) {
_instance = instance; _instance = instance;
} }
public static Platform instance() { static Platform instance() {
return _instance; return _instance;
} }
abstract public Window createWindow(string windowCaption, Window parent); abstract Window createWindow(string windowCaption, Window parent);
abstract public int enterMessageLoop(); abstract int enterMessageLoop();
} }
version (USE_OPENGL) { version (USE_OPENGL) {

260
src/dlangui/platforms/x11/x11app.d
View File

@ -3,74 +3,210 @@ module src.dlangui.platforms.x11.x11app;
import std.stdio; import std.stdio;
import std.c.linux.X11.xcb.xcb; import std.c.linux.X11.xcb.xcb;
import std.c.linux.X11.xcb.xproto; import std.c.linux.X11.xcb.xproto;
import std.c.linux.X11.keysymdef;
import std.c.stdlib; import std.c.stdlib;
import dlangui.core.logger;
import dlangui.platforms.common.platform;
class XCBWindow : Window {
xcb_window_t _w;
xcb_gcontext_t _g;
@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() {
uint mask;
uint values[2];
/* create black graphics context */
_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]);
/* create window */
_w = xcb_generate_id(_xcbconnection);
Log.d("window=", _w, " gc=", _g);
mask = XCB_CW_BACK_PIXEL | XCB_CW_EVENT_MASK;
values[0] = _xcbscreen.white_pixel;
values[1] = 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_create_window(_xcbconnection, _xcbscreen.root_depth, _w, _xcbscreen.root,
10, 10, 100, 100, 1,
XCB_WINDOW_CLASS_INPUT_OUTPUT, _xcbscreen.root_visual,
mask, &values[0]);
xcb_flush(_xcbconnection);
return true;
}
override void show() {
Log.d("XCBWindow.show()");
/* map (show) the window */
xcb_map_window(_xcbconnection, _w);
xcb_flush(_xcbconnection);
}
string _caption;
override @property string windowCaption() {
return _caption;
}
override @property void windowCaption(string caption) {
_caption = caption;
}
void processExpose(xcb_expose_event_t * event) {
static xcb_rectangle_t r = { 20, 20, 60, 60 };
xcb_poly_fill_rectangle(_xcbconnection, _w, _g, 1, &r);
xcb_flush(_xcbconnection);
}
}
private __gshared xcb_connection_t * _xcbconnection;
private __gshared xcb_screen_t * _xcbscreen;
class XCBPlatform : Platform {
this() {
}
~this() {
disconnect();
}
void disconnect() {
if (_xcbconnection) {
/* close connection to server */
xcb_disconnect(_xcbconnection);
}
}
bool connect() {
Log.d("Opening 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;
}
Log.d("Getting first screen");
/* get the first screen */
_xcbscreen = xcb_setup_roots_iterator( xcb_get_setup(_xcbconnection) ).data;
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;
/* event loop */
do {
Log.v("waiting for event");
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_EXPOSE: { /* draw or redraw the window */
xcb_expose_event_t *expose = cast(xcb_expose_event_t *)e;
Log.i("expose event");
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");
break;
}
case XCB_BUTTON_RELEASE: {
Log.d("XCB_BUTTON_RELEASE");
xcb_button_release_event_t *br = cast(xcb_button_release_event_t *)e;
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);
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);
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);
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);
break;
}
default:
break;
}
free(e);
} while(!done);
Log.i("exiting message loop");
return 0;
}
XCBWindow[xcb_window_t] _windowMap;
}
int main(string[] args) int main(string[] args)
{ {
xcb_connection_t *c;
xcb_screen_t *s;
xcb_window_t w;
xcb_gcontext_t g;
xcb_generic_event_t *e;
uint mask;
uint values[2];
int done = 0;
static xcb_rectangle_t r = { 20, 20, 60, 60 };
/* open connection with the server */
c = xcb_connect(null,null);
if (xcb_connection_has_error(c)) {
writefln("Cannot open display");
return 1;
}
/* get the first screen */ setStderrLogger();
s = xcb_setup_roots_iterator( xcb_get_setup(c) ).data; setLogLevel(LogLevel.Trace);
XCBPlatform xcb = new XCBPlatform();
if (!xcb.connect()) {
return 1;
}
Platform.setInstance(xcb);
/* create black graphics context */ Window window = xcb.createWindow("Window Caption", null);
g = xcb_generate_id(c); window.show();
w = s.root;
mask = XCB_GC_FOREGROUND | XCB_GC_GRAPHICS_EXPOSURES;
values[0] = s.black_pixel;
values[1] = 0;
xcb_create_gc(c, g, w, mask, &values[0]);
/* create window */
w = xcb_generate_id(c);
mask = XCB_CW_BACK_PIXEL | XCB_CW_EVENT_MASK;
values[0] = s.white_pixel;
values[1] = XCB_EVENT_MASK_EXPOSURE | XCB_EVENT_MASK_KEY_PRESS;
xcb_create_window(c, s.root_depth, w, s.root,
10, 10, 100, 100, 1,
XCB_WINDOW_CLASS_INPUT_OUTPUT, s.root_visual,
mask, &values[0]);
/* map (show) the window */
xcb_map_window(c, w);
xcb_flush(c);
/* event loop */
do {
e = xcb_wait_for_event(c); int res = xcb.enterMessageLoop();
if (!e)
break; Platform.setInstance(null);
switch (e.response_type & ~0x80) { destroy(xcb);
case XCB_EXPOSE: /* draw or redraw the window */
xcb_poly_fill_rectangle(c, w, g, 1, &r);
xcb_flush(c);
break;
case XCB_KEY_PRESS: /* exit on key press */
done = 1;
break;
default:
break;
}
free(e);
} while(!done);
/* close connection to server */
xcb_disconnect(c);
return 0; return res;
} }