int
main()
{
Display* display = XOpenDisplay(0);
if (display == 0) {
fprintf(stderr, "unable to open display\n");
exit(-1);
}
int major, minor;
if (!XRecordQueryVersion(display, &major, &minor)) {
fprintf(stderr, "xrecord extension not available\n");
}
// Receive from ALL clients, including future clients.
XRecordClientSpec clients = XRecordAllClients;
XRecordRange* range = XRecordAllocRange();
if (range == 0) {
fprintf(stderr, "unable to allocate XRecordRange\n");
exit(-1);
}
// Receive KeyPress, KeyRelease, ButtonPress, ButtonRelease and
// MotionNotify events.
memset(range, 0, sizeof(XRecordRange));
range->device_events.first = KeyPress;
range->device_events.last = MotionNotify;
// And create the XRECORD context.
XRecordContext context = XRecordCreateContext (display, 0, &clients, 1, &range, 1);
if (context == 0) {
fprintf(stderr, "XRecordCreateContext failed\n");
exit(-1);
}
XFree(range);
// what is that for? (copied from workrave sourcecode)
XSync(display, True);
Display* display_datalink = XOpenDisplay(0);
if (display_datalink == 0) {
fprintf(stderr, "unable to open second display\n");
exit(-1);
}
if (!XRecordEnableContext(display_datalink, context, &callback, (XPointer)0)) {
fprintf(stderr, "XRecordEnableContext() failed\n");
exit(-1);
}
// Call above seems to block forever.
fprintf(stderr, "Terminating. (huh?)\n");
// Who cares about cleanup, linux and xorg sure will do this for us.
return 0;
}
static gpointer xevent_thread_fuc(gpointer ctx)
{
// 会一直阻塞在这里
XRecordEnableContext(s_display, s_context, xevent_event_callback, 0);
XRecordFreeContext(s_display, s_context);
XCloseDisplay(s_display);
return NULL;
}
static gpointer
enable_ctx_thread (gpointer user_data)
{
if ( !XRecordEnableContext (grab_info->data_disp, grab_info->context,
grab_key_event_cb, NULL) ) {
g_warning ("Unable to enable context...");
grab_xrecord_finalize ();
}
g_thread_exit (NULL);
}
int
main()
{
XRecordContext xrd;
XRecordRange *range;
XRecordClientSpec client;
osd = configure_osd(NKEYS);
keystack = create_keystack(NKEYS);
d0 = XOpenDisplay(NULL);
d1 = XOpenDisplay(NULL);
XSynchronize(d0, True);
if (d0 == NULL || d1 == NULL) {
fprintf(stderr, "Cannot connect to X server");
exit (-1);
}
client=XRecordAllClients;
range=XRecordAllocRange();
memset(range, 0, sizeof(XRecordRange));
range->device_events.first=KeyPress;
range->device_events.last=KeyRelease;
xrd = XRecordCreateContext(d0, 0, &client, 1, &range, 1);
if (! xrd) {
fprintf(stderr, "Error in creating context");
exit (-1);
}
XRecordEnableContext(d1, xrd, update_key_ring, (XPointer)osd);
XRecordProcessReplies (d1);
XRecordDisableContext (d0, xrd);
XRecordFreeContext (d0, xrd);
XCloseDisplay(d0);
XCloseDisplay(d1);
exit(0);
}
void start(){
// Record...
XFlush(disp);
XFlush(udisp);
evt.buttons = 0;
evt.pressb = 0;
evt.clickb = 0;
evt.clickn = 0;
evt.w = 0;
//if (!XRecordEnableContext(xdisp, xrctx, EventCallback, (XPointer)disp)) {
if (!XRecordEnableContext(udisp, xrctx, EventCallback, (XPointer)this)) {
fprintf(stderr, "Enable context failed\n");
//throw new Exception("Fail");
exit(1); // TODO
}
// blocked ... until StopRecording() is called.
}
void *intercept_key_thread(void *data) {
XRecordClientSpec rcs;
XRecordRange* rr;
Display *dpy;
static GStaticMutex mutex = G_STATIC_MUTEX_INIT;
g_static_mutex_lock (&mutex); // ensure the thread is not called again while it is running
dpy = XOpenDisplay(0);
if (!(rr = XRecordAllocRange())) {
fprintf(stderr, "XRecordAllocRange error\n");
fprintf(stderr, "Error: %s (%d)\n", __FILE__, __LINE__);
exit(1);
}
rr->device_events.first = KeyPress;
rr->device_events.last = KeyRelease;
rcs = XRecordAllClients;
if (!(rc = XRecordCreateContext(dpy, 0, &rcs, 1, &rr, 1))) {
fprintf(stderr, "XRecordCreateContext error\n");
fprintf(stderr, "Error: %s (%d)\n", __FILE__, __LINE__);
exit(1);
}
XFree(rr);
if (!XRecordEnableContext(dpy, rc, key_pressed_cb, (char*) data)) {
fprintf(stderr, "XRecordEnableContext error\n");
fprintf(stderr, "Error: %s (%d)\n", __FILE__, __LINE__);
exit(1);
}
XFree(dpy); // free?
g_static_mutex_unlock (&mutex);
return 0;
}
void* intercept_key_thread(void* data) {
XRecordClientSpec rcs;
XRecordRange* rr;
dpy = XOpenDisplay(0);
if (!(rr = XRecordAllocRange())) {
fprintf(stderr, "XRecordAllocRange error\n");
exit(1);
}
rr->device_events.first = KeyPress;
rr->device_events.last = MotionNotify;
rcs = XRecordAllClients;
if (!(rc = XRecordCreateContext(dpy, 0, &rcs, 1, &rr, 1))) {
fprintf(stderr, "XRecordCreateContext error\n");
exit(1);
}
XFree(rr);
if (!XRecordEnableContext(dpy, rc, key_pressed_cb, data)) {
fprintf(stderr, "XRecordEnableContext error\n");
exit(1);
}
return 0;
}
int main (int argc, char **argv)
{
ctrl_disp = XOpenDisplay (NULL);
data_disp = XOpenDisplay (NULL);
if (!ctrl_disp || !data_disp) {
fprintf (stderr, "Error to open local display!\n");
exit (1);
}
/*
* we must set the ctrl_disp to sync mode, or, when we the enalbe
* context in data_disp, there will be a fatal X error !!!
*/
XSynchronize(ctrl_disp,True);
int major, minor;
if (!XRecordQueryVersion (ctrl_disp, &major, &minor)) {
fprintf (stderr, "RECORD extension not supported on this X server!\n");
exit (2);
}
printf ("RECORD extension for local server is version is %d.%d\n", major, minor);
XRecordRange *rr;
XRecordClientSpec rcs;
XRecordContext rc;
rr = XRecordAllocRange ();
if (!rr) {
fprintf (stderr, "Could not alloc record range object!\n");
exit (3);
}
rr->device_events.first = KeyPress;
rr->device_events.last = MotionNotify;
rcs = XRecordAllClients;
rc = XRecordCreateContext (ctrl_disp, 0, &rcs, 1, &rr, 1);
if (!rc) {
fprintf (stderr, "Could not create a record context!\n");
exit (4);
}
if (!XRecordEnableContext (data_disp, rc, event_callback, NULL)) {
fprintf (stderr, "Cound not enable the record context!\n");
exit (5);
}
while (stop != 1) {
XRecordProcessReplies (data_disp);
}
XRecordDisableContext (ctrl_disp, rc);
XRecordFreeContext (ctrl_disp, rc);
XFree (rr);
XCloseDisplay (data_disp);
XCloseDisplay (ctrl_disp);
return 0;
}
void xrecord_thread (gpointer data)
{
int dummy;
self_xcape = calloc (sizeof (XCape_t), 1);
if ( !self_xcape ) {
g_debug ("Got XCape memory failed!\n");
/*return FALSE;*/
g_thread_exit (NULL);
}
self_xcape->data_conn = XOpenDisplay (NULL);
self_xcape->ctrl_conn = XOpenDisplay (NULL);
if ( !self_xcape->data_conn || !self_xcape->ctrl_conn ) {
g_debug ("Unable to connect to X11 display!\n");
/*return FALSE;*/
g_thread_exit (NULL);
}
if ( !XQueryExtension (self_xcape->ctrl_conn,
"XTEST", &dummy, &dummy, &dummy) ) {
g_debug ("Xtst extension missing!\n");
/*return FALSE;*/
g_thread_exit (NULL);
}
if ( !XRecordQueryVersion (self_xcape->ctrl_conn, &dummy, &dummy) ) {
g_debug ("Failed to obtain xrecord version!\n");
/*return FALSE;*/
g_thread_exit (NULL);
}
if ( !XkbQueryExtension (self_xcape->ctrl_conn, &dummy, &dummy,
&dummy, &dummy, &dummy)) {
g_debug ("Failed to obtain xkb version!\n");
/*return FALSE;*/
g_thread_exit (NULL);
}
XRecordRange* rec_range = XRecordAllocRange ();
rec_range->device_events.first = KeyPress;
rec_range->device_events.last = ButtonRelease;
XRecordClientSpec client_spec = XRecordAllClients;
self_xcape->record_ctx = XRecordCreateContext (self_xcape->ctrl_conn,
0, &client_spec, 1, &rec_range, 1);
if ( self_xcape->record_ctx == 0 ) {
g_debug ("Failed to create xrecord context!\n");
/*return FALSE;*/
g_thread_exit (NULL);
}
/*XSync (self_xcape->ctrl_conn, FALSE);*/
XFlush (self_xcape->ctrl_conn);
if ( !XRecordEnableContext (self_xcape->data_conn,
self_xcape->record_ctx, intercept, (XPointer)self_xcape) ) {
g_debug ("Failed to enable xrecord context!\n");
/*return FALSE;*/
g_thread_exit (NULL);
}
g_thread_exit (NULL);
}
/************************************************************************
* Main function
***********************************************************************/
int main(int argc, char **argv) {
XCape_t *self = malloc(sizeof(XCape_t));
int dummy, ch;
static char default_mapping[] = "Num_Lock;Caps_Lock";
char *mapping = default_mapping;
self->debug = False;
while ((ch = getopt(argc, argv, "d")) != -1) {
switch (ch) {
case 'd':
self->debug = True;
break;
default:
fprintf(stdout, "Usage: %s [-d]\n", argv[0]);
fprintf(stdout, "Runs as a daemon unless -d flag is set\n");
return EXIT_SUCCESS;
}
}
self->data_conn = XOpenDisplay(NULL);
self->ctrl_conn = XOpenDisplay(NULL);
if (!self->data_conn || !self->ctrl_conn) {
fprintf(stderr, "Unable to connect to X11 display. Is $DISPLAY set?\n");
exit(EXIT_FAILURE);
}
if (!XQueryExtension(self->ctrl_conn, "XTEST", &dummy, &dummy, &dummy)) {
fprintf(stderr, "Xtst extension missing\n");
exit(EXIT_FAILURE);
}
if (!XRecordQueryVersion(self->ctrl_conn, &dummy, &dummy)) {
fprintf(stderr, "Failed to obtain xrecord version\n");
exit(EXIT_FAILURE);
}
if (!XkbQueryExtension(self->ctrl_conn, &dummy, &dummy, &dummy, &dummy,
&dummy)) {
fprintf(stderr, "Failed to obtain xkb version\n");
exit(EXIT_FAILURE);
}
self->map = parse_mapping(self->ctrl_conn, mapping);
if (self->map == NULL)
exit(EXIT_FAILURE);
if (self->debug != True)
daemon(0, 0);
sigemptyset(&self->sigset);
sigaddset(&self->sigset, SIGINT);
sigaddset(&self->sigset, SIGTERM);
pthread_sigmask(SIG_BLOCK, &self->sigset, NULL);
pthread_create(&self->sigwait_thread,
NULL, sig_handler, self);
XRecordRange *rec_range = XRecordAllocRange();
rec_range->device_events.first = KeyPress;
rec_range->device_events.last = ButtonRelease;
XRecordClientSpec client_spec = XRecordAllClients;
self->record_ctx = XRecordCreateContext(self->ctrl_conn, 0, &client_spec, 1,
&rec_range, 1);
if (self->record_ctx == 0) {
fprintf(stderr, "Failed to create xrecord context\n");
exit(EXIT_FAILURE);
}
XSync(self->ctrl_conn, False);
if (!XRecordEnableContext(self->data_conn, self->record_ctx, intercept,
(XPointer) self)) {
fprintf(stderr, "Failed to enable xrecord context\n");
exit(EXIT_FAILURE);
}
if (!XRecordFreeContext(self->ctrl_conn, self->record_ctx)) {
fprintf(stderr, "Failed to free xrecord context\n");
}
XCloseDisplay(self->ctrl_conn);
XCloseDisplay(self->data_conn);
if (self->debug)
fprintf(stdout, "main exiting\n");
return EXIT_SUCCESS;
}
