Injecting a Screen event

The following walkthrough takes you through the process of injecting a screen event into a specified display.

1. Create some basic variables you'll need for your application:

   screen_context_t screen_ctx;    /* a connection to the screen windowing system */
   screen_display_t screen_disp;   /* a screen display */
   screen_display_t *screen_dlist; /* a list of all available displays */
   screen_event_t screen_ev;       /* a screen event to handle */
   int ndisplays;                  /* number of available displays */
   int val;                        /* a variable used to set/get window properties */
   const char *display = "1";      /* the display type */
   int rval = EXIT_FAILURE;        /* the application return code*/
   int rc;                         /* a return code */
                       

2. Create your native context with a privileged context that allows for the injection of Screen events. In this example, you will use the SCREEN_INPUT_PROVIDER_CONTEXT context.

   rc = screen_create_context(&screen_ctx, SCREEN_INPUT_PROVIDER_CONTEXT);
                       

3. Identify the display into which your Screen event is to be injected.
   In this example, the display used is the internal display, unless it is otherwise specified as a command-line argument.

   rc = screen_get_context_property_iv(screen_ctx,
                                       SCREEN_PROPERTY_DISPLAY_COUNT,
                                       &ndisplays);
   if (rc) {
       perror("screen_get_context_property_iv(SCREEN_PROPERTY_DISPLAY_COUNT)");
       goto fail2;
   }
   
   screen_dlist = calloc(ndisplays, sizeof(*screen_dlist));
   if (screen_dlist == NULL) {
       fprintf(stderr, "could not allocate memory for display list\n");
       goto fail2;
   }
   
   rc = screen_get_context_property_pv(screen_ctx,
                                       SCREEN_PROPERTY_DISPLAYS,
                                       (void **)screen_dlist);
   if (rc) {
       perror("screen_get_context_property_pv(SCREEN_PROPERTY_DISPLAYS)");
       free(screen_dlist);
       goto fail2;
   }
   
   if (isdigit(*display)) {
       j = atoi(display) - 1;
   } else {
       int type = -1;
       if (strcmp(display, "internal") == 0) {
           type = SCREEN_DISPLAY_TYPE_INTERNAL;
       } else if (strcmp(display, "composite") == 0) {
           type = SCREEN_DISPLAY_TYPE_COMPOSITE;
       } else if (strcmp(display, "svideo") == 0) {
           type = SCREEN_DISPLAY_TYPE_SVIDEO;
       } else if (strcmp(display, "YPbPr") == 0) {
           type = SCREEN_DISPLAY_TYPE_COMPONENT_YPbPr;
       } else if (strcmp(display, "rgb") == 0) {
           type = SCREEN_DISPLAY_TYPE_COMPONENT_RGB;
       } else if (strcmp(display, "rgbhv") == 0) {
           type = SCREEN_DISPLAY_TYPE_COMPONENT_RGBHV;
       } else if (strcmp(display, "dvi") == 0) {
           type = SCREEN_DISPLAY_TYPE_DVI;
       } else if (strcmp(display, "hdmi") == 0) {
           type = SCREEN_DISPLAY_TYPE_HDMI;
       } else if (strcmp(display, "other") == 0) {
           type = SCREEN_DISPLAY_TYPE_OTHER;
       } else {
           fprintf(stderr, "unknown display type %s\n", display);
           free(screen_dlist);
           goto fail2;
       }
       for (j = 0; j < ndisplays; j++) {
           screen_get_display_property_iv(screen_dlist[j],
                                          SCREEN_PROPERTY_TYPE,
                                          &val);
           if (val == type) {
               break;
           }
       }
   }
   
   if (j >= ndisplays) {
       fprintf(stderr, "couldn't find display %s\n", display);
       free(screen_dlist);
       goto fail2;
   }
   
   screen_disp = screen_dlist[j];
   free(screen_dlist);
                       

4. Create a screen event.

   This is the screen event that you will be injecting into the display.

   rc = screen_create_event(&screen_ev);
                       

5. Set the type of the event that you will be injecting.

   In this example, you will be injecting a keyboard event.

   val = SCREEN_EVENT_KEYBOARD;
   rc = screen_set_event_property_iv(screen_ev, SCREEN_PROPERTY_TYPE, &val);
                       

6. Set the value of the keyboard flags that are associated with this keyboard event.

   val = KEY_DOWN|KEY_SYM_VALID;
   rc = screen_set_event_property_iv(screen_ev, SCREEN_PROPERTY_KEY_FLAGS, &val);
                       

7. Set the value of the keyboard symbols that are associated with this keyboard event.
   In this example, the keyboard symbols are passed as command-line arguments.

   val = argv[i][j];
   rc = screen_set_event_property_iv(screen_ev, SCREEN_PROPERTY_KEY_SYM, &val);
                       

8. Inject your Screen event.

   rc = screen_inject_event(screen_disp, screen_ev);
                       

9. Release the resources.

   screen_destroy_event(screen_ev);
   screen_destroy_context(screen_ctx);