AuroraMiddleware/gtk
1
0
Fork 1
mirror of https://gitlab.gnome.org/GNOME/gtk.git synced 2024-12-27 06:00:22 +00:00
Code Issues Projects Releases Wiki Activity

Drop _gdk_x11_set_input_focus_safe

Browse Source 
All that this function did was to asynchronously catch errors.
Since we have asynchronous error traps now, we can just use
XSetInputFocus().
This commit is contained in:
Matthias Clasen 2011-02-26 22:13:06 -05:00
parent 3dc3767d0c
commit 7df2ce8eab
4 changed files with 16 additions and 105 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

93
gdk/x11/gdkasync.c
View File

@ -288,99 +288,6 @@ _gdk_x11_send_client_message_async (GdkDisplay *display,
SyncHandle();
}
static Bool
set_input_focus_handler (Display *dpy,
xReply *rep,
char *buf,
int len,
XPointer data)
{
SetInputFocusState *state = (SetInputFocusState *)data;
if (dpy->last_request_read == state->set_input_focus_req)
{
if (rep->generic.type == X_Error &&
rep->error.errorCode == BadMatch)
{
/* Consume BadMatch errors, since we have no control
* over them.
*/
return True;
}
}
if (dpy->last_request_read == state->get_input_focus_req)
{
xGetInputFocusReply replbuf;
xGetInputFocusReply *repl G_GNUC_UNUSED;
if (rep->generic.type != X_Error)
{
/* Actually does nothing, since there are no additional bytes
* to read, but maintain good form.
*/
repl = (xGetInputFocusReply *)
_XGetAsyncReply(dpy, (char *)&replbuf, rep, buf, len,
(sizeof(xGetInputFocusReply) - sizeof(xReply)) >> 2,
True);
}
DeqAsyncHandler(state->dpy, &state->async);
g_free (state);
return (rep->generic.type != X_Error);
}
return False;
}
void
_gdk_x11_set_input_focus_safe (GdkDisplay *display,
Window window,
int revert_to,
Time time)
{
Display *dpy;
SetInputFocusState *state;
dpy = GDK_DISPLAY_XDISPLAY (display);
state = g_new (SetInputFocusState, 1);
state->dpy = dpy;
LockDisplay(dpy);
state->async.next = dpy->async_handlers;
state->async.handler = set_input_focus_handler;
state->async.data = (XPointer) state;
dpy->async_handlers = &state->async;
{
xSetInputFocusReq *req;
GetReq(SetInputFocus, req);
req->focus = window;
req->revertTo = revert_to;
req->time = time;
state->set_input_focus_req = dpy->request;
}
/*
* XSync (dpy, 0)
*/
{
xReq *req;
GetEmptyReq(GetInputFocus, req);
state->get_input_focus_req = dpy->request;
}
UnlockDisplay(dpy);
SyncHandle();
}
static Bool
list_children_handler (Display *dpy,
xReply *rep,

4
gdk/x11/gdkasync.h
View File

@ -54,10 +54,6 @@ void _gdk_x11_send_client_message_async (GdkDisplay *display,
XClientMessageEvent *event_send,
GdkSendXEventCallback callback,
gpointer data);
void _gdk_x11_set_input_focus_safe (GdkDisplay *display,
Window window,
int revert_to,
Time time);
gboolean _gdk_x11_get_window_child_info (GdkDisplay *display,
Window window,

13
gdk/x11/gdkdisplay-x11.c
View File

@ -1024,12 +1024,17 @@ _gdk_wm_protocols_filter (GdkXEvent *xev,
GdkToplevelX11 *toplevel = _gdk_x11_window_get_toplevel (event->any.window);
/* There is no way of knowing reliably whether we are viewable;
* _gdk_x11_set_input_focus_safe() traps errors asynchronously.
* so trap errors asynchronously around the XSetInputFocus call
*/
if (toplevel && win->accept_focus)
_gdk_x11_set_input_focus_safe (display, toplevel->focus_window,
RevertToParent,
xevent->xclient.data.l[1]);
{
gdk_x11_display_error_trap_push (display);
XSetInputFocus (GDK_DISPLAY_XDISPLAY (display),
toplevel->focus_window,
RevertToParent,
xevent->xclient.data.l[1]);
gdk_x11_display_error_trap_pop_ignored (display);
}
return GDK_FILTER_REMOVE;
}

11
gdk/x11/gdkwindow-x11.c
View File

@ -1821,11 +1821,14 @@ gdk_x11_window_focus (GdkWindow *window,
XRaiseWindow (GDK_DISPLAY_XDISPLAY (display), GDK_WINDOW_XID (window));
/* There is no way of knowing reliably whether we are viewable;
* _gdk_x11_set_input_focus_safe() traps errors asynchronously.
* so trap errors asynchronously around the XSetInputFocus call
*/
_gdk_x11_set_input_focus_safe (display, GDK_WINDOW_XID (window),
RevertToParent,
timestamp);
gdk_x11_display_error_trap_push (display);
XSetInputFocus (GDK_DISPLAY_XDISPLAY (display),
GDK_WINDOW_XID (window),
RevertToParent,
timestamp);
gdk_x11_display_error_trap_pop_ignored (display);
}
}