/** Stop grabbing the mouse pointer.
* \param L The Lua VM state.
* \return The number of elements pushed on stack.
*/
int
luaA_mousegrabber_stop(lua_State *L)
{
xcb_ungrab_pointer(globalconf.connection, XCB_CURRENT_TIME);
luaA_unregister(L, &globalconf.mousegrabber);
return 0;
}
void X11WindowedBackend::grabKeyboard(xcb_timestamp_t time)
{
const bool oldState = m_keyboardGrabbed;
if (m_keyboardGrabbed) {
xcb_ungrab_keyboard(m_connection, time);
xcb_ungrab_pointer(m_connection, time);
m_keyboardGrabbed = false;
} else {
const auto c = xcb_grab_keyboard_unchecked(m_connection, false, window(), time,
XCB_GRAB_MODE_ASYNC, XCB_GRAB_MODE_ASYNC);
ScopedCPointer<xcb_grab_keyboard_reply_t> grab(xcb_grab_keyboard_reply(m_connection, c, nullptr));
if (grab.isNull()) {
return;
}
if (grab->status == XCB_GRAB_STATUS_SUCCESS) {
const auto c = xcb_grab_pointer_unchecked(m_connection, false, window(),
XCB_EVENT_MASK_BUTTON_PRESS | XCB_EVENT_MASK_BUTTON_RELEASE |
XCB_EVENT_MASK_POINTER_MOTION |
XCB_EVENT_MASK_ENTER_WINDOW | XCB_EVENT_MASK_LEAVE_WINDOW,
XCB_GRAB_MODE_ASYNC, XCB_GRAB_MODE_ASYNC,
window(), XCB_CURSOR_NONE, time);
ScopedCPointer<xcb_grab_pointer_reply_t> grab(xcb_grab_pointer_reply(m_connection, c, nullptr));
if (grab.isNull() || grab->status != XCB_GRAB_STATUS_SUCCESS) {
xcb_ungrab_keyboard(m_connection, time);
return;
}
m_keyboardGrabbed = true;
}
}
if (oldState != m_keyboardGrabbed) {
updateWindowTitle();
xcb_flush(m_connection);
}
}
void WindowSelector::start(std::function<void(KWin::Toplevel*)> callback, const QByteArray &cursorName)
{
xcb_cursor_t cursor = createCursor(cursorName);
if (m_active) {
callback(nullptr);
return;
}
xcb_connection_t *c = connection();
ScopedCPointer<xcb_grab_pointer_reply_t> grabPointer(xcb_grab_pointer_reply(c, xcb_grab_pointer_unchecked(c, false, rootWindow(),
XCB_EVENT_MASK_BUTTON_PRESS | XCB_EVENT_MASK_BUTTON_RELEASE |
XCB_EVENT_MASK_POINTER_MOTION |
XCB_EVENT_MASK_ENTER_WINDOW | XCB_EVENT_MASK_LEAVE_WINDOW,
XCB_GRAB_MODE_ASYNC, XCB_GRAB_MODE_ASYNC, XCB_WINDOW_NONE,
cursor, XCB_TIME_CURRENT_TIME), NULL));
if (grabPointer.isNull() || grabPointer->status != XCB_GRAB_STATUS_SUCCESS) {
callback(nullptr);
return;
}
m_active = grabXKeyboard();
if (!m_active) {
xcb_ungrab_pointer(connection(), XCB_TIME_CURRENT_TIME);
callback(nullptr);
return;
}
grabXServer();
m_callback = callback;
}
void WindowSelector::release()
{
ungrabXKeyboard();
xcb_ungrab_pointer(connection(), XCB_TIME_CURRENT_TIME);
ungrabXServer();
m_active = false;
m_callback = std::function<void(KWin::Toplevel*)>();
}
void menuwin_ungrab_mouse(char do_flush) {
if (key_win.mouse_grabed==1) {
xcb_ungrab_pointer(conn,XCB_CURRENT_TIME);
if (do_flush) {
xcb_flush(conn);
}
key_win.mouse_grabed=0;
}
}
/* We start the exposition when the user touch triangle reactangle at the top left. */
static int _handle_motion_notify(xcb_motion_notify_event_t *e) {
if (e->root_x + e->root_y < 20 && _this.state == _IDLE && gd.win_count >= 2) {
_show();
} else {
xcb_ungrab_pointer(gd.conn, XCB_TIME_CURRENT_TIME);
e->time = XCB_CURRENT_TIME;
xcb_send_event(gd.conn, 1, e->child, 0, (char *) e);
xcb_grab_pointer(gd.conn, 1, gd.def_screen->root,
XCB_EVENT_MASK_POINTER_MOTION | XCB_EVENT_MASK_BUTTON_PRESS,
XCB_GRAB_MODE_ASYNC, XCB_GRAB_MODE_ASYNC, XCB_NONE, XCB_NONE, XCB_CURRENT_TIME);
xcb_flush(gd.conn);
}
return 1;
}
static
void handle_button_release(xcb_button_release_event_t *e) {
const struct layout_t *h;
NIL_LOG("event: mouse release %d", e->detail);
mouse_evt_.x2 = e->event_x;
mouse_evt_.y2 = e->event_y;
h = get_layout(mouse_evt_.ws);
switch (mouse_evt_.mode) {
case CURSOR_MOVE:
if (h->move) {
(*h->move)(mouse_evt_.ws, &mouse_evt_);
}
break;
case CURSOR_RESIZE:
if (h->resize) {
(*h->resize)(mouse_evt_.ws, &mouse_evt_);
}
break;
}
xcb_ungrab_pointer(nil_.con, XCB_CURRENT_TIME);
xcb_flush(nil_.con);
}
void track_pointer(coordinates_t loc, pointer_action_t pac, xcb_point_t pos)
{
node_t *n = loc.node;
resize_handle_t rh = get_handle(loc.node, pos, pac);
uint16_t last_motion_x = pos.x, last_motion_y = pos.y;
xcb_timestamp_t last_motion_time = 0;
xcb_generic_event_t *evt = NULL;
grabbing = true;
grabbed_node = n;
do {
free(evt);
while ((evt = xcb_wait_for_event(dpy)) == NULL) {
xcb_flush(dpy);
}
uint8_t resp_type = XCB_EVENT_RESPONSE_TYPE(evt);
if (resp_type == XCB_MOTION_NOTIFY) {
xcb_motion_notify_event_t *e = (xcb_motion_notify_event_t*) evt;
uint32_t dtime = e->time - last_motion_time;
if (dtime < pointer_motion_interval) {
continue;
}
last_motion_time = e->time;
int16_t dx = e->root_x - last_motion_x;
int16_t dy = e->root_y - last_motion_y;
if (pac == ACTION_MOVE) {
move_client(&loc, dx, dy);
} else {
resize_client(&loc, rh, e->root_x, e->root_y, false);
}
last_motion_x = e->root_x;
last_motion_y = e->root_y;
xcb_flush(dpy);
} else if (resp_type == XCB_BUTTON_RELEASE) {
grabbing = false;
} else {
handle_event(evt);
}
} while (grabbing && grabbed_node != NULL);
free(evt);
xcb_ungrab_pointer(dpy, XCB_CURRENT_TIME);
if (grabbed_node == NULL) {
grabbing = false;
return;
}
if (pac == ACTION_MOVE) {
put_status(SBSC_MASK_POINTER_ACTION, "pointer_action 0x%08X 0x%08X 0x%08X move end\n", loc.monitor->id, loc.desktop->id, n->id);
} else if (pac == ACTION_RESIZE_CORNER) {
put_status(SBSC_MASK_POINTER_ACTION, "pointer_action 0x%08X 0x%08X 0x%08X resize_corner end\n", loc.monitor->id, loc.desktop->id, n->id);
} else if (pac == ACTION_RESIZE_SIDE) {
put_status(SBSC_MASK_POINTER_ACTION, "pointer_action 0x%08X 0x%08X 0x%08X resize_side end\n", loc.monitor->id, loc.desktop->id, n->id);
}
xcb_rectangle_t r = get_rectangle(NULL, NULL, n);
put_status(SBSC_MASK_NODE_GEOMETRY, "node_geometry 0x%08X 0x%08X 0x%08X %ux%u+%i+%i\n", loc.monitor->id, loc.desktop->id, loc.node->id, r.width, r.height, r.x, r.y);
if ((pac == ACTION_MOVE && IS_TILED(n->client)) ||
((pac == ACTION_RESIZE_CORNER || pac == ACTION_RESIZE_SIDE) &&
n->client->state == STATE_TILED)) {
for (node_t *f = first_extrema(loc.desktop->root); f != NULL; f = next_leaf(f, loc.desktop->root)) {
if (f == n || f->client == NULL || !IS_TILED(f->client)) {
continue;
}
xcb_rectangle_t r = f->client->tiled_rectangle;
put_status(SBSC_MASK_NODE_GEOMETRY, "node_geometry 0x%08X 0x%08X 0x%08X %ux%u+%i+%i\n", loc.monitor->id, loc.desktop->id, f->id, r.width, r.height, r.x, r.y);
}
}
}
xcb_window_t Select_Window(xcb_connection_t *dpy,
const xcb_screen_t *screen,
int descend)
{
xcb_cursor_t cursor;
xcb_generic_event_t *event;
xcb_window_t target_win = XCB_WINDOW_NONE;
xcb_window_t root = screen->root;
int buttons = 0;
xcb_generic_error_t *err;
xcb_grab_pointer_cookie_t grab_cookie;
xcb_grab_pointer_reply_t *grab_reply;
/* Make the target cursor */
cursor = Create_Font_Cursor (dpy, XC_crosshair);
/* Grab the pointer using target cursor, letting it room all over */
grab_cookie = xcb_grab_pointer
(dpy, False, root,
XCB_EVENT_MASK_BUTTON_PRESS | XCB_EVENT_MASK_BUTTON_RELEASE,
XCB_GRAB_MODE_SYNC, XCB_GRAB_MODE_ASYNC,
root, cursor, XCB_TIME_CURRENT_TIME);
grab_reply = xcb_grab_pointer_reply (dpy, grab_cookie, &err);
if (grab_reply->status != XCB_GRAB_STATUS_SUCCESS)
Fatal_Error ("Can't grab the mouse.");
/* Let the user select a window... */
while ((target_win == XCB_WINDOW_NONE) || (buttons != 0)) {
/* allow one more event */
xcb_allow_events (dpy, XCB_ALLOW_SYNC_POINTER, XCB_TIME_CURRENT_TIME);
xcb_flush (dpy);
event = xcb_wait_for_event (dpy);
switch (event->response_type & 0x7f) {
case XCB_BUTTON_PRESS:
{
xcb_button_press_event_t *bp = (xcb_button_press_event_t *)event;
if (target_win == XCB_WINDOW_NONE) {
target_win = bp->child; /* window selected */
if (target_win == XCB_WINDOW_NONE)
target_win = root;
}
buttons++;
break;
}
case XCB_BUTTON_RELEASE:
if (buttons > 0) /* there may have been some down before we started */
buttons--;
break;
default:
/* just discard all other events */
break;
}
free (event);
}
xcb_ungrab_pointer (dpy, XCB_TIME_CURRENT_TIME); /* Done with pointer */
if (!descend || (target_win == root))
return (target_win);
target_win = Find_Client (dpy, root, target_win);
return (target_win);
}
int main(void)
{
xcb_connection_t *c;
xcb_screen_t *s;
xcb_window_t w;
xcb_gcontext_t g;
xcb_generic_event_t *e;
uint32_t mask;
uint32_t values[2];
int done = 0;
/* open connection with the server */
c = xcb_connect(NULL,NULL);
if (xcb_connection_has_error(c)) {
printf("Cannot open display\n");
exit(1);
}
/* get the first screen */
s = xcb_setup_roots_iterator( xcb_get_setup(c) ).data;
G.conn = c;
G.s= s;
//enable mouse event
xcb_cursor_t cursor;
xcb_font_t cursor_font=0;
short glyph = 0x34; //cross
xcb_grab_pointer_cookie_t grab_cookie;
xcb_grab_pointer_reply_t *grab_reply;
xcb_generic_error_t *err;
cursor = xcb_generate_id (c);
if (!cursor_font) {
cursor_font = xcb_generate_id (c);
xcb_open_font (c, cursor_font, strlen ("cursor"), "cursor");
}
xcb_create_glyph_cursor (c, cursor, cursor_font, cursor_font,
glyph, glyph + 1,
0, 0, 0, 0xffff, 0xffff, 0xffff); /* rgb, rgb */
grab_cookie = xcb_grab_pointer(c, 0, s->root,
XCB_EVENT_MASK_POINTER_MOTION |
XCB_EVENT_MASK_BUTTON_PRESS | XCB_EVENT_MASK_BUTTON_RELEASE,
XCB_GRAB_MODE_SYNC, XCB_GRAB_MODE_ASYNC,
s->root, cursor, XCB_TIME_CURRENT_TIME);
assert(grab_reply!=NULL);
grab_reply = xcb_grab_pointer_reply (c, grab_cookie, &err);
if (grab_reply->status != XCB_GRAB_STATUS_SUCCESS)
printf("Can't grab the mouse.");
printf("grab pointer cookie=0x%x\n", grab_cookie);
xcb_allow_events (c, XCB_ALLOW_ASYNC_POINTER, XCB_TIME_CURRENT_TIME); xcb_flush (c);
// xcb_allow_events (c, XCB_ALLOW_SYNC_POINTER, XCB_TIME_CURRENT_TIME); xcb_flush (c);
while (!done ) {
e = xcb_wait_for_event(c);
if(e==NULL) printf("wait event error\n");
//printf("\revent=>%d", e->response_type);
switch (e->response_type & ~0x80) {
case XCB_EXPOSE: /* draw or redraw the window */
printf("XCB_EXPOSE\n");
draw_gc(w);
break;
case XCB_MOTION_NOTIFY:
{
static xcb_window_t oldw;
xcb_button_press_event_t *bp = (xcb_button_press_event_t *)e;
w = bp->child; /* window selected */
if(oldw!=w){
oldw = w;
printf("windowid = %x\n", w);
}
//draw it
draw_gc(w);
}
break;
case XCB_BUTTON_PRESS:
{
xcb_button_press_event_t *bp = (xcb_button_press_event_t *)e;
w = bp->child; /* window selected */
if (w== XCB_WINDOW_NONE){
printf("window select is root\n");
w=s->root;
}
else
printf("window = %x\n", w);
draw_gc(w);
done=1; printf("grab a child\n");
break;
}
}
free(e);
}
xcb_ungrab_pointer(c, XCB_TIME_CURRENT_TIME);
draw_byxid(w);
return 0;
#if 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);
/* map (show) the window */
xcb_map_window(c, w);
xcb_flush(c);
/* event loop */
while (!done && (e = xcb_wait_for_event(c))) {
switch (e->response_type & ~0x80) {
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 */
//gwj done = 1;
break;
}
free(e);
}
/* close connection to server */
xcb_disconnect(c);
return 0;
if(0){
//draw image with xcb_put_image
// creat gc and draw to parent window
xcb_gcontext_t g;
g = xcb_generate_id(c);
xcb_create_gc(c, g, child, 0,NULL);
//xcb_poly_fill_rectangle(c, w, g, 1, &r); xcb_flush(c);
int psize=geo->width * geo->height* (geo->depth/8);
uint8_t *pbuf = malloc(psize);
xcb_void_cookie_t ck;
printf("malloc pbuf=0x%x size=%d\n",pbuf, psize);
memset(pbuf, 0x18, psize);
ck = xcb_put_image_checked(c, XCB_IMAGE_FORMAT_Z_PIXMAP,
child, g,
geo->width, geo->height , 0, 0,
0, geo->depth,
psize, pbuf);
//BadMatch=8 BadLength=16
xcb_generic_error_t *err;
err = xcb_request_check (c, ck);
if (err)
{
int code = err->error_code;
free (err);
printf("put image error %d\n", code);
assert (code != 0);
}
}
printf("depth =%d\n", geo->depth);
/* create black graphics context */
#endif
}
//_____________________________________________
void SizeGrip::sendMoveResizeEvent( QPoint position )
{
#if OXYGEN_HAVE_X11
if( !QX11Info::isPlatformX11() ) return;
// pointer to connection
auto connection( QX11Info::connection() );
// client
auto c = m_decoration.data()->client().data();
/*
get root position matching position
need to use xcb because the embedding of the widget
breaks QT's mapToGlobal and other methods
*/
QPoint rootPosition( position );
xcb_get_geometry_cookie_t cookie( xcb_get_geometry( connection, winId() ) );
ScopedPointer<xcb_get_geometry_reply_t> reply( xcb_get_geometry_reply( connection, cookie, 0x0 ) );
if( reply )
{
// translate coordinates
xcb_translate_coordinates_cookie_t coordCookie( xcb_translate_coordinates(
connection, winId(), reply.data()->root,
-reply.data()->border_width,
-reply.data()->border_width ) );
ScopedPointer< xcb_translate_coordinates_reply_t> coordReply( xcb_translate_coordinates_reply( connection, coordCookie, 0x0 ) );
if( coordReply )
{
rootPosition.rx() += coordReply.data()->dst_x;
rootPosition.ry() += coordReply.data()->dst_y;
}
}
// move/resize atom
if( !m_moveResizeAtom )
{
// create atom if not found
const QString atomName( "_NET_WM_MOVERESIZE" );
xcb_intern_atom_cookie_t cookie( xcb_intern_atom( connection, false, atomName.size(), qPrintable( atomName ) ) );
ScopedPointer<xcb_intern_atom_reply_t> reply( xcb_intern_atom_reply( connection, cookie, 0x0 ) );
m_moveResizeAtom = reply ? reply->atom:0;
}
if( !m_moveResizeAtom ) return;
// button release event
xcb_button_release_event_t releaseEvent;
memset(&releaseEvent, 0, sizeof(releaseEvent));
releaseEvent.response_type = XCB_BUTTON_RELEASE;
releaseEvent.event = winId();
releaseEvent.child = XCB_WINDOW_NONE;
releaseEvent.root = QX11Info::appRootWindow();
releaseEvent.event_x = position.x();
releaseEvent.event_y = position.y();
releaseEvent.root_x = rootPosition.x();
releaseEvent.root_y = rootPosition.y();
releaseEvent.detail = XCB_BUTTON_INDEX_1;
releaseEvent.state = XCB_BUTTON_MASK_1;
releaseEvent.time = XCB_CURRENT_TIME;
releaseEvent.same_screen = true;
xcb_send_event( connection, false, winId(), XCB_EVENT_MASK_BUTTON_RELEASE, reinterpret_cast<const char*>(&releaseEvent));
xcb_ungrab_pointer( connection, XCB_TIME_CURRENT_TIME );
// move resize event
xcb_client_message_event_t clientMessageEvent;
memset(&clientMessageEvent, 0, sizeof(clientMessageEvent));
clientMessageEvent.response_type = XCB_CLIENT_MESSAGE;
clientMessageEvent.type = m_moveResizeAtom;
clientMessageEvent.format = 32;
clientMessageEvent.window = c->windowId();
clientMessageEvent.data.data32[0] = rootPosition.x();
clientMessageEvent.data.data32[1] = rootPosition.y();
clientMessageEvent.data.data32[2] = 4; // bottom right
clientMessageEvent.data.data32[3] = Qt::LeftButton;
clientMessageEvent.data.data32[4] = 0;
xcb_send_event( connection, false, QX11Info::appRootWindow(),
XCB_EVENT_MASK_SUBSTRUCTURE_NOTIFY |
XCB_EVENT_MASK_SUBSTRUCTURE_REDIRECT,
reinterpret_cast<const char*>(&clientMessageEvent) );
xcb_flush( connection );
#endif
}
static void forwardMouseEventToRoot(QMouseEvent* event) {
xcb_ungrab_pointer(QX11Info::connection(), event->timestamp());
// forward the event to the root window
xcb_button_press_event_t xcb_event;
uint32_t mask = 0;
xcb_event.state = 0;
switch(event->type()) {
case QEvent::MouseButtonPress:
xcb_event.response_type = XCB_BUTTON_PRESS;
mask = XCB_EVENT_MASK_BUTTON_PRESS;
break;
case QEvent::MouseButtonRelease:
xcb_event.response_type = XCB_BUTTON_RELEASE;
mask = XCB_EVENT_MASK_BUTTON_RELEASE;
break;
default:
return;
}
// convert Qt button to XCB button
switch(event->button()) {
case Qt::LeftButton:
xcb_event.detail = 1;
xcb_event.state |= XCB_BUTTON_MASK_1;
break;
case Qt::MiddleButton:
xcb_event.detail = 2;
xcb_event.state |= XCB_BUTTON_MASK_2;
break;
case Qt::RightButton:
xcb_event.detail = 3;
xcb_event.state |= XCB_BUTTON_MASK_3;
break;
default:
xcb_event.detail = 0;
}
// convert Qt modifiers to XCB states
if(event->modifiers() & Qt::ShiftModifier) {
xcb_event.state |= XCB_MOD_MASK_SHIFT;
}
if(event->modifiers() & Qt::ControlModifier) {
xcb_event.state |= XCB_MOD_MASK_SHIFT;
}
if(event->modifiers() & Qt::AltModifier) {
xcb_event.state |= XCB_MOD_MASK_1;
}
xcb_event.sequence = 0;
xcb_event.time = event->timestamp();
WId root = QX11Info::appRootWindow(QX11Info::appScreen());
xcb_event.event = root;
xcb_event.root = root;
xcb_event.child = 0;
xcb_event.root_x = event->globalX();
xcb_event.root_y = event->globalY();
xcb_event.event_x = event->x();
xcb_event.event_y = event->y();
xcb_event.same_screen = 1;
xcb_send_event(QX11Info::connection(), 0, root, mask, (char*)&xcb_event);
xcb_flush(QX11Info::connection());
}
static void
events_loop (void) {
uint32_t values[3];
xcb_generic_event_t *ev;
xcb_get_geometry_reply_t *geom;
xcb_window_t win = 0;
/* loop */
for (;;) {
ev = xcb_wait_for_event(conn);
if (ev == NULL)
errx(1, "xcb connection broken");
switch (ev->response_type & ~0x80) {
case XCB_CREATE_NOTIFY: {
xcb_create_notify_event_t *e;
e = (xcb_create_notify_event_t *)ev;
if (!e->override_redirect) {
setup_win(e->window);
focus(e->window, ACTIVE);
}
} break;
case XCB_DESTROY_NOTIFY: {
xcb_destroy_notify_event_t *e;
e = (xcb_destroy_notify_event_t *)ev;
xcb_kill_client(conn, e->window);
} break;
case XCB_KEY_PRESS: {
xcb_key_press_event_t *e;
e = (xcb_key_press_event_t *)ev;
xcb_keysym_t keysym = xcb_get_keysym(e->detail);
for (unsigned int i=0; i < LENGTH(keys); i++) {
if (keys[i].keysym == keysym
&& CLEANMASK(keys[i].mod) == CLEANMASK(e->state)
&& keys[i].mfunc) {
keys[i].mfunc(keys[i].x, keys[i].y);
}
else if (keys[i].keysym == keysym
&& CLEANMASK(keys[i].mod) == CLEANMASK(e->state)
&& keys[i].func) {
keys[i].func();
}
}
} break;
case XCB_ENTER_NOTIFY: {
xcb_enter_notify_event_t *e;
e = (xcb_enter_notify_event_t *)ev;
focus(e->event, ACTIVE);
} break;
case XCB_MAP_NOTIFY: {
xcb_map_notify_event_t *e;
e = (xcb_map_notify_event_t *)ev;
if (!e->override_redirect) {
xcb_map_window(conn, e->window);
xcb_set_input_focus(conn,
XCB_INPUT_FOCUS_POINTER_ROOT,
e->window, XCB_CURRENT_TIME);
}
} break;
case XCB_BUTTON_PRESS: {
xcb_button_press_event_t *e;
e = ( xcb_button_press_event_t *)ev;
win = e->child;
if (!win || win == scr->root)
break;
values[0] = XCB_STACK_MODE_ABOVE;
xcb_configure_window(conn, win,
XCB_CONFIG_WINDOW_STACK_MODE, values);
geom = xcb_get_geometry_reply(conn,
xcb_get_geometry(conn, win), NULL);
if (1 == e->detail) {
values[2] = 1;
center_pointer(win);
} else {
values[2] = 3;
xcb_warp_pointer(conn, XCB_NONE, win, 0, 0, 0,
0, geom->width, geom->height);
}
xcb_grab_pointer(conn, 0, scr->root,
XCB_EVENT_MASK_BUTTON_RELEASE
| XCB_EVENT_MASK_BUTTON_MOTION
| XCB_EVENT_MASK_POINTER_MOTION_HINT,
XCB_GRAB_MODE_ASYNC, XCB_GRAB_MODE_ASYNC,
scr->root, XCB_NONE, XCB_CURRENT_TIME);
xcb_flush(conn);
} break;
case XCB_MOTION_NOTIFY: {
xcb_query_pointer_reply_t *pointer;
pointer = xcb_query_pointer_reply(conn,
xcb_query_pointer(conn, scr->root), 0);
if (values[2] == 1) {
geom = xcb_get_geometry_reply(conn,
xcb_get_geometry(conn, win), NULL);
if (!geom) {
break;
}
values[0] = (pointer->root_x + geom->width / 2
> scr->width_in_pixels
- (BORDERWIDTH*2))
? scr->width_in_pixels - geom->width
- (BORDERWIDTH*2)
: pointer->root_x - geom->width / 2;
values[1] = (pointer->root_y + geom->height / 2
> scr->height_in_pixels
- (BORDERWIDTH*2))
? (scr->height_in_pixels - geom->height
- (BORDERWIDTH*2))
: pointer->root_y - geom->height / 2;
if (pointer->root_x < geom->width/2)
values[0] = 0;
if (pointer->root_y < geom->height/2)
values[1] = 0;
xcb_configure_window(conn, win,
XCB_CONFIG_WINDOW_X
| XCB_CONFIG_WINDOW_Y, values);
xcb_flush(conn);
} else if (values[2] == 3) {
focus(win, RESIZE);
geom = xcb_get_geometry_reply(conn,
xcb_get_geometry(conn, win), NULL);
values[0] = pointer->root_x - geom->x;
values[1] = pointer->root_y - geom->y;
xcb_configure_window(conn, win,
XCB_CONFIG_WINDOW_WIDTH
| XCB_CONFIG_WINDOW_HEIGHT, values);
xcb_flush(conn);
}
} break;
case XCB_BUTTON_RELEASE:
focus(win, ACTIVE);
xcb_ungrab_pointer(conn, XCB_CURRENT_TIME);
break;
}
xcb_flush(conn);
free(ev);
}
}
static void
ephyrProcessKeyRelease(xcb_generic_event_t *xev)
{
xcb_connection_t *conn = hostx_get_xcbconn();
xcb_key_release_event_t *key = (xcb_key_release_event_t *)xev;
static xcb_key_symbols_t *keysyms;
static int grabbed_screen = -1;
int mod1_down = ephyrUpdateGrabModifierState(key->state);
if (!keysyms)
keysyms = xcb_key_symbols_alloc(conn);
if (!EphyrWantNoHostGrab &&
(((xcb_key_symbols_get_keysym(keysyms, key->detail, 0) == XK_Shift_L
|| xcb_key_symbols_get_keysym(keysyms, key->detail, 0) == XK_Shift_R)
&& (key->state & XCB_MOD_MASK_CONTROL)) ||
((xcb_key_symbols_get_keysym(keysyms, key->detail, 0) == XK_Control_L
|| xcb_key_symbols_get_keysym(keysyms, key->detail, 0) == XK_Control_R)
&& (key->state & XCB_MOD_MASK_SHIFT)))) {
KdScreenInfo *screen = screen_from_window(key->event);
EphyrScrPriv *scrpriv = screen->driver;
if (grabbed_screen != -1) {
xcb_ungrab_keyboard(conn, XCB_TIME_CURRENT_TIME);
xcb_ungrab_pointer(conn, XCB_TIME_CURRENT_TIME);
grabbed_screen = -1;
hostx_set_win_title(screen,
"(ctrl+shift grabs mouse and keyboard)");
}
else if (!mod1_down) {
/* Attempt grab */
xcb_grab_keyboard_cookie_t kbgrabc =
xcb_grab_keyboard(conn,
TRUE,
scrpriv->win,
XCB_TIME_CURRENT_TIME,
XCB_GRAB_MODE_ASYNC,
XCB_GRAB_MODE_ASYNC);
xcb_grab_keyboard_reply_t *kbgrabr;
xcb_grab_pointer_cookie_t pgrabc =
xcb_grab_pointer(conn,
TRUE,
scrpriv->win,
0,
XCB_GRAB_MODE_ASYNC,
XCB_GRAB_MODE_ASYNC,
scrpriv->win,
XCB_NONE,
XCB_TIME_CURRENT_TIME);
xcb_grab_pointer_reply_t *pgrabr;
kbgrabr = xcb_grab_keyboard_reply(conn, kbgrabc, NULL);
if (!kbgrabr || kbgrabr->status != XCB_GRAB_STATUS_SUCCESS) {
xcb_discard_reply(conn, pgrabc.sequence);
xcb_ungrab_pointer(conn, XCB_TIME_CURRENT_TIME);
} else {
pgrabr = xcb_grab_pointer_reply(conn, pgrabc, NULL);
if (!pgrabr || pgrabr->status != XCB_GRAB_STATUS_SUCCESS)
{
xcb_ungrab_keyboard(conn,
XCB_TIME_CURRENT_TIME);
} else {
grabbed_screen = scrpriv->mynum;
hostx_set_win_title
(screen,
"(ctrl+shift releases mouse and keyboard)");
}
}
}
}
if (!ephyrKbd ||
!((EphyrKbdPrivate *) ephyrKbd->driverPrivate)->enabled) {
return;
}
/* Still send the release event even if above has happened server
* will get confused with just an up event. Maybe it would be
* better to just block shift+ctrls getting to kdrive all
* together.
*/
ephyrUpdateModifierState(key->state);
KdEnqueueKeyboardEvent(ephyrKbd, key->detail, TRUE);
}
int main(int argc,char**argv){
xcb_connection_t*d=xcb_connect(0,0);
int32_t*x,*y,*tx=0,mx,my,rt=xcb_setup_roots_iterator(xcb_get_setup(d)).data->root,cs[255],*cz=cs+1;
uint8_t mz,mZ;
xcb_change_window_attributes(d,rt,XCB_CW_EVENT_MASK,&cwa);
xcb_grab_key(d,1,rt,0,64,XCB_GRAB_MODE_ASYNC,XCB_GRAB_MODE_ASYNC);
xcb_grab_key(d,1,rt,8,XCB_GRAB_ANY,XCB_GRAB_MODE_ASYNC,XCB_GRAB_MODE_ASYNC);
xcb_grab_button(d,1,rt,XCB_EVENT_MASK_BUTTON_PRESS,XCB_GRAB_MODE_ASYNC,XCB_GRAB_MODE_ASYNC,XCB_NONE,XCB_NONE,XCB_GRAB_ANY,8);
#ifdef COMPOSITE
xcb_composite_redirect_subwindows(d,rt,XCB_COMPOSITE_REDIRECT_AUTOMATIC);
#endif
xcb_generic_event_t*e=0;
main:xcb_flush(d);
waitpid(-1,0,WNOHANG);
noflush:x=y=cz-1;
again:free(e);
switch((e=xcb_wait_for_event(d))->response_type&127){
case XCB_BUTTON_PRESS:
for(;x>cs;x--)
if(*x==((xcb_button_press_event_t*)e)->child){
if(((xcb_key_press_event_t*)e)->detail==2)goto pocus;
case XCB_KEY_PRESS:
mz=128|((xcb_key_press_event_t*)e)->detail;
my=((xcb_key_press_event_t*)e)->state;
goto*(cz==cs+1?&&kcode:&&stack);
}
goto noflush;
case XCB_KEY_RELEASE:
if(((xcb_key_press_event_t*)e)->detail!=64||!tx)default:goto again;
xt:x=tx;
tx=0;
goto stack;
case XCB_CONFIGURE_REQUEST:{
void*p=buf;
for(mz=0;mz<5;mz++)
if(((xcb_configure_request_event_t*)e)->value_mask&1<<mz){*(uint32_t*)p=*(int16_t*)(((void*)e)+16+mz*2);p+=4;}
if(((xcb_configure_request_event_t*)e)->value_mask&XCB_CONFIG_WINDOW_SIBLING){*(uint32_t*)p=((xcb_configure_request_event_t*)e)->sibling;p+=4;}
if(mz=((xcb_configure_request_event_t*)e)->value_mask&XCB_CONFIG_WINDOW_STACK_MODE)*(uint32_t*)p=((xcb_configure_request_event_t*)e)->stack_mode;
xcb_configure_window(d,((xcb_configure_request_event_t*)e)->window,((xcb_configure_request_event_t*)e)->value_mask,buf);
if(mz){
p=xcb_query_tree_reply(d,xcb_query_tree_unchecked(d,rt),0);
int32_t*cl=p+32+((xcb_query_tree_reply_t*)p)->children_len*4;
for(y=p+32;y<cl;y++){
for(x=cs+1;x<cz;x++)
if(*x==*y)goto nono;
*y=0;
nono:;
}
x=cs;
for(y=p+32;y<cl;y++)
if(*y)*++x=*y;
free(p);
goto pocus;
}else goto main;}
case XCB_MAP_REQUEST:{
void*p=xcb_get_window_attributes_reply(d,xcb_get_window_attributes_unchecked(d,((xcb_map_request_event_t*)e)->window),0);
if(((xcb_get_window_attributes_reply_t*)p)->override_redirect){
free(p);
goto pocus;
}
free(p);
for(;x>cs;x--)
if(*x==((xcb_map_request_event_t*)e)->window)goto noflush;
xcb_map_window(d,*cz++=((xcb_map_request_event_t*)e)->window);
goto hocus;}
case XCB_MOTION_NOTIFY:
*buf=mZ&&((xcb_motion_notify_event_t*)e)->root_x<=mx?:((xcb_motion_notify_event_t*)e)->root_x-mx;
buf[1]=mZ&&((xcb_motion_notify_event_t*)e)->root_y<=my?:((xcb_motion_notify_event_t*)e)->root_y-my;
xcb_configure_window(d,*x,mZ?XCB_CONFIG_WINDOW_WIDTH|XCB_CONFIG_WINDOW_HEIGHT:XCB_CONFIG_WINDOW_X|XCB_CONFIG_WINDOW_Y,buf);
goto main;
case XCB_BUTTON_RELEASE:
xcb_ungrab_pointer(d,XCB_CURRENT_TIME);
goto main;
case XCB_UNMAP_NOTIFY:unmap:goto*(x==cs?&&noflush:*x==((xcb_unmap_notify_event_t*)e)->window&&--cz>cs+1?&&stack:(x--,&&unmap));
}
stack:mx=*x;
for(;x!=y;x+=x<y?:-1)*x=x[x<y?:-1];
*x=mx;
hocus:x=cz-1;
xcb_configure_window(d,*x,XCB_CONFIG_WINDOW_STACK_MODE,di);
pocus:xcb_set_input_focus(d,XCB_INPUT_FOCUS_POINTER_ROOT,*x,XCB_CURRENT_TIME);
if(!(mz&128))goto main;
kcode:switch(mz&=127){
void*p;
case 1:case 3:
p=xcb_grab_pointer_reply(d,xcb_grab_pointer_unchecked(d,0,rt,XCB_EVENT_MASK_BUTTON_RELEASE|XCB_EVENT_MASK_POINTER_MOTION,XCB_GRAB_MODE_ASYNC,XCB_GRAB_MODE_ASYNC,XCB_NONE,XCB_NONE,XCB_CURRENT_TIME),0);
if(((xcb_grab_pointer_reply_t*)p)->status!=XCB_GRAB_STATUS_SUCCESS){
free(p);
goto noflush;
}
free(p);
p=xcb_get_geometry_reply(d,xcb_get_geometry_unchecked(d,*y),0);
mx=((xcb_get_geometry_reply_t*)p)->x;
my=((xcb_get_geometry_reply_t*)p)->y;
free(p);
if(mZ=mz==1){
p=xcb_query_pointer_reply(d,xcb_query_pointer_unchecked(d,rt),0);
mx=((xcb_query_pointer_reply_t*)p)->root_x-mx;
my=((xcb_query_pointer_reply_t*)p)->root_y-my;
free(p);
}
goto noflush;
case 23:case 49:
if(cz-cs<3)goto main;
y=tx;
tx=mz==23?(y!=cs+1?(y?:x)-1:x):!y||y==x?cs+1:y+1;
if(y&&y<cz-1){
*buf=y[mz==23?:-1];
buf[1]=mz==23;
xcb_configure_window(d,*y,XCB_CONFIG_WINDOW_SIBLING|XCB_CONFIG_WINDOW_STACK_MODE,buf);
}
xcb_configure_window(d,*tx,XCB_CONFIG_WINDOW_STACK_MODE,di);
goto main;
case 32:return 0;
case 44:
if(cz>cs+1)xcb_configure_window(d,*y,XCB_CONFIG_WINDOW_X|XCB_CONFIG_WINDOW_Y|XCB_CONFIG_WINDOW_WIDTH|XCB_CONFIG_WINDOW_HEIGHT,di);
goto main;
case 46:
if(cz==cs+1)goto main;
if(tx)goto*(mz|=128,&&xt);
{xcb_intern_atom_cookie_t c1=xcb_intern_atom_unchecked(d,0,12,"WM_PROTOCOLS"),c2=xcb_intern_atom_unchecked(d,0,16,"WM_DELETE_WINDOW");
p=xcb_intern_atom_reply(d,c1,0);
mx=((xcb_intern_atom_reply_t*)p)->atom;
free(p);
p=xcb_intern_atom_reply(d,c2,0);}
my=((xcb_intern_atom_reply_t*)p)->atom;
free(p);
p=xcb_get_property_reply(d,xcb_get_property_unchecked(d,0,*y,mx,XCB_ATOM_ATOM,0,-1),0);
xcb_send_event(d,0,*y,XCB_EVENT_MASK_NO_EVENT,(void*)(xcb_client_message_event_t[]){{.response_type=XCB_CLIENT_MESSAGE,.window=*y,.type=mx,.format=32,.data.data32={my,XCB_CURRENT_TIME}}});
static void
events_loop(void)
{
xcb_generic_event_t *ev;
#ifdef ENABLE_MOUSE
uint32_t values[3];
xcb_get_geometry_reply_t *geom;
xcb_window_t win = 0;
#endif
/* loop */
for (;;) {
ev = xcb_wait_for_event(conn);
if (!ev)
errx(1, "xcb connection broken");
switch (CLEANMASK(ev->response_type)) {
case XCB_CREATE_NOTIFY: {
xcb_create_notify_event_t *e;
e = (xcb_create_notify_event_t *)ev;
if (!e->override_redirect) {
subscribe(e->window);
focus(e->window, ACTIVE);
}
} break;
case XCB_DESTROY_NOTIFY: {
xcb_destroy_notify_event_t *e;
e = (xcb_destroy_notify_event_t *)ev;
xcb_kill_client(conn, e->window);
} break;
#ifdef ENABLE_SLOPPY
case XCB_ENTER_NOTIFY: {
xcb_enter_notify_event_t *e;
e = (xcb_enter_notify_event_t *)ev;
focus(e->event, ACTIVE);
} break;
#endif
case XCB_MAP_NOTIFY: {
xcb_map_notify_event_t *e;
e = (xcb_map_notify_event_t *)ev;
if (!e->override_redirect) {
xcb_map_window(conn, e->window);
focus(e->window, ACTIVE);
}
} break;
#ifdef ENABLE_MOUSE
case XCB_BUTTON_PRESS: {
xcb_button_press_event_t *e;
e = ( xcb_button_press_event_t *)ev;
win = e->child;
if (!win || win == scr->root)
break;
values[0] = XCB_STACK_MODE_ABOVE;
xcb_configure_window(conn, win,
XCB_CONFIG_WINDOW_STACK_MODE, values);
geom = xcb_get_geometry_reply(conn,
xcb_get_geometry(conn, win), NULL);
if (e->detail == 1) {
values[2] = 1;
xcb_warp_pointer(conn, XCB_NONE, win, 0, 0, 0,
0, geom->width/2, geom->height/2);
} else {
values[2] = 3;
xcb_warp_pointer(conn, XCB_NONE, win, 0, 0, 0,
0, geom->width, geom->height);
}
xcb_grab_pointer(conn, 0, scr->root,
XCB_EVENT_MASK_BUTTON_RELEASE
| XCB_EVENT_MASK_BUTTON_MOTION
| XCB_EVENT_MASK_POINTER_MOTION_HINT,
XCB_GRAB_MODE_ASYNC, XCB_GRAB_MODE_ASYNC,
scr->root, XCB_NONE, XCB_CURRENT_TIME);
xcb_flush(conn);
} break;
case XCB_MOTION_NOTIFY: {
xcb_query_pointer_reply_t *pointer;
pointer = xcb_query_pointer_reply(conn,
xcb_query_pointer(conn, scr->root), 0);
if (values[2] == 1) {
geom = xcb_get_geometry_reply(conn,
xcb_get_geometry(conn, win), NULL);
if (!geom)
break;
values[0] = (pointer->root_x + geom->width / 2
> scr->width_in_pixels
- (BORDERWIDTH*2))
? scr->width_in_pixels - geom->width
- (BORDERWIDTH*2)
: pointer->root_x - geom->width / 2;
values[1] = (pointer->root_y + geom->height / 2
> scr->height_in_pixels
- (BORDERWIDTH*2))
? (scr->height_in_pixels - geom->height
- (BORDERWIDTH*2))
: pointer->root_y - geom->height / 2;
if (pointer->root_x < geom->width/2)
values[0] = 0;
if (pointer->root_y < geom->height/2)
values[1] = 0;
xcb_configure_window(conn, win,
XCB_CONFIG_WINDOW_X
| XCB_CONFIG_WINDOW_Y, values);
xcb_flush(conn);
} else if (values[2] == 3) {
geom = xcb_get_geometry_reply(conn,
xcb_get_geometry(conn, win), NULL);
values[0] = pointer->root_x - geom->x;
values[1] = pointer->root_y - geom->y;
xcb_configure_window(conn, win,
XCB_CONFIG_WINDOW_WIDTH
| XCB_CONFIG_WINDOW_HEIGHT, values);
xcb_flush(conn);
}
} break;
case XCB_BUTTON_RELEASE:
focus(win, ACTIVE);
xcb_ungrab_pointer(conn, XCB_CURRENT_TIME);
break;
#endif
case XCB_CONFIGURE_NOTIFY: {
xcb_configure_notify_event_t *e;
e = (xcb_configure_notify_event_t *)ev;
if (e->window != focuswin)
focus(e->window, INACTIVE);
focus(focuswin, ACTIVE);
} break;
}
xcb_flush(conn);
free(ev);
}
}
