Exemple #1
0
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;
}
Exemple #2
0
int initKeyHook(void)
{
    int major = 0;
    int minor = 0;
    XRecordRange *xrr = NULL;
    XRecordClientSpec xrcs = XRecordAllClients;

    if (ctrldpy)
        return 0;  // already initialized.

    ctrldpy = XOpenDisplay(NULL);
    if (!ctrldpy)
        goto failed;

    XSynchronize(ctrldpy, True);

    datadpy = XOpenDisplay(NULL);
    if (!datadpy)
        goto failed;
    else if (!XRecordQueryVersion(ctrldpy, &major, &minor))
        goto failed;
    else if ((xrr = XRecordAllocRange()) == NULL)
        goto failed;

    memset(xrr, '\0', sizeof (*xrr));
    xrr->device_events.first = KeyPress;
    xrr->device_events.last = KeyPress;

    if ((xrc = XRecordCreateContext(ctrldpy, 0, &xrcs, 1, &xrr, 1)) == 0)
        goto failed;
    else if (!XRecordEnableContextAsync(datadpy, xrc, keyhookCallback, NULL))
        goto failed;

    XFree(xrr);
    xrr = NULL;

    return 1;

failed:
    deinitKeyHook();
    if (xrr) XFree(xrr);

    return 0;
} // initKeyHook
/* test if the xrecord extension is found */
Bool
check_xrecord(Display * display)
{

    Bool found;
    Status status;
    int major_opcode, minor_opcode, first_error;
    int version[2];

    found = XQueryExtension(display,
                            "RECORD",
                            &major_opcode, &minor_opcode, &first_error);

    status = XRecordQueryVersion(display, version, version + 1);
    if (verbose && status) {
        printf("X RECORD extension version %d.%d\n", version[0], version[1]);
    }
    return found;
}
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);
}
Exemple #6
0
void
grab_xrecord_init ()
{
    key_table = g_hash_table_new_full (g_direct_hash, g_direct_equal,
                                       NULL, (GDestroyNotify)g_free);
    grab_info = g_new0 (XRecordGrabInfo, 1);

    if ( !grab_info ) {
        g_warning ("Alloc XRecordGrabInfo memory failed...");
        grab_xrecord_finalize ();
    }

    grab_info->ctrl_disp = XOpenDisplay (NULL);
    grab_info->data_disp = XOpenDisplay (NULL);

    if ( !grab_info->ctrl_disp || !grab_info->data_disp ) {
        g_warning ("Unable to connect to X server...");
        grab_xrecord_finalize ();
    }

    gint dummy;

    if ( !XQueryExtension (grab_info->ctrl_disp, "XTEST",
                           &dummy, &dummy, &dummy) ) {
        g_warning ("XTest extension missing...");
        grab_xrecord_finalize ();
    }

    if ( !XRecordQueryVersion (grab_info->ctrl_disp, &dummy, &dummy) ) {
        g_warning ("Failed to obtain xrecord version...");
        grab_xrecord_finalize ();
    }

    grab_info->range = XRecordAllocRange ();

    if ( !grab_info->range ) {
        g_warning ("Alloc XRecordRange memory failed...");
        grab_xrecord_finalize ();
    }

    grab_info->range->device_events.first = KeyPress;
    grab_info->range->device_events.last = ButtonRelease;

    XRecordClientSpec spec = XRecordAllClients;
    grab_info->context = XRecordCreateContext (
                             grab_info->data_disp, 0, &spec, 1, &grab_info->range, 1);

    if ( !grab_info->context ) {
        g_warning ("Unable to create context...");
        grab_xrecord_finalize();
    }

    XSynchronize (grab_info->ctrl_disp, TRUE);
    XFlush (grab_info->ctrl_disp);

    GThread *thrd = g_thread_new ("enable context",
                                  (GThreadFunc)enable_ctx_thread, NULL);

    if ( !thrd ) {
        g_warning ("Unable to create thread...");
        grab_xrecord_finalize ();
    }
    g_thread_unref(thrd);
}
Exemple #7
0
  GUIRecord():disp(NULL),xrr(NULL),udisp(NULL){
    init_keysym();

    disp = XOpenDisplay(NULL);
    display = disp;

    if (disp == NULL) {
      fprintf(stderr, "Unable to open display connection.\n");
      exit(1);
    }
    XSynchronize(disp, False);

    udisp = XOpenDisplay(NULL);
    if (udisp == NULL) {
      fprintf(stderr, "Unable to open other display connection.\n");
      exit(1);
    }

    // Ensure extension available 
    int major = 0, minor = 0;
    if (!XRecordQueryVersion(disp, &major, &minor)) {
      fprintf(stderr, "The record extension is unavailable.\n");
      exit(1);
    }

    xrr = XRecordAllocRange();
    if (xrr == NULL) {
      fprintf(stderr, "Range allocation failed.\n");
      exit(1);
    }
    xrr->device_events.first = KeyPress;
    xrr->device_events.last  = MotionNotify;
    //xrr->device_events.last  = FocusIn;


    xrr->delivered_events.first = FocusIn;
    //xrr->delivered_events.last  = FocusOut;
    xrr->delivered_events.last  = ConfigureNotify;
    //xrr->delivered_events.last  = SelectionNotify;
    // INFO: use PropertyNotify when Copy
    // INFO: use SelectionRequest when Paste

    /*
    xrr->core_requests.first = EnterNotify;
    xrr->core_requests.last  = FocusIn;
    xrr->core_replies.first = EnterNotify;
    xrr->core_replies.last  = FocusIn;
    */

    //XRecordClientSpec xrclient = XRecordAllClients;
    XRecordClientSpec xrclient = XRecordCurrentClients;

    xrctx = XRecordCreateContext(disp, 0, &xrclient, 1, &xrr, 1);
    if (!xrctx) {
      fprintf(stderr, "Unable to create context.\n");
      exit(1);
    }

    // Clean out X events in progress
    //XFlush(disp);
    //XFlush(otherDisp);

  }
Exemple #8
0
/************************************************************************
 * 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;
}