xruler

xruler.c (6927B)

---

 /**
  * xruler -- a screen ruler for X11
  * Copyright 2019 Matthias Balk
  */
 
 #include <stdint.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 
 #include <xcb/xcb.h>
 
 
 static uint32_t width = 1500;
 static uint32_t height = 50;
 
 
 static void set_crosshair_cursor(
     xcb_connection_t *c,
     xcb_screen_t     *screen,
     xcb_window_t      window)
 {
   int cursor_id = 33; /* Crosshair */
 
   xcb_font_t font = xcb_generate_id(c);
   xcb_void_cookie_t cookie_font =
       xcb_open_font_checked(c, font, strlen("cursor"), "cursor");
 
   xcb_generic_error_t *error;
   error = xcb_request_check(c, cookie_font);
   if (error) {
     fprintf(stderr, "ERROR: can't open font : %d\n", error->error_code);
     xcb_disconnect(c);
     exit(-1);
   }
 
   xcb_cursor_t cursor = xcb_generate_id(c);
   xcb_create_glyph_cursor(c, cursor, font, font,
                           cursor_id, cursor_id + 1,
                           0, 0, 0,
                           0, 0, 0);
 
   xcb_gcontext_t gc = xcb_generate_id(c);
   uint32_t mask = XCB_GC_FOREGROUND | XCB_GC_BACKGROUND | XCB_GC_FONT;
   uint32_t values_list[] = {screen->black_pixel, screen->white_pixel, font};
   xcb_void_cookie_t cookie_gc =
       xcb_create_gc_checked(c, gc, window, mask, values_list);
 
   error = xcb_request_check(c, cookie_gc);
   if (error) {
     fprintf(stderr, "ERROR: can't create gc : %d\n", error->error_code);
     xcb_disconnect(c);
     exit(-1);
   }
 
   mask = XCB_CW_CURSOR;
   uint32_t value_list = cursor;
   xcb_change_window_attributes(c, window, mask, &value_list);
 
   xcb_free_cursor(c, cursor);
 
   cookie_font = xcb_close_font_checked(c, font);
   error = xcb_request_check(c, cookie_font);
   if (error) {
     fprintf(stderr, "ERROR: can't close font : %d\n", error->error_code);
     xcb_disconnect(c);
     exit(-1);
   }
 }
 
 
 static xcb_gc_t get_gc_font(
     xcb_connection_t *c,
     xcb_screen_t     *screen,
     xcb_window_t      window,
     const char       *font_name)
 {
   xcb_font_t font = xcb_generate_id(c);
   xcb_void_cookie_t cookie_font =
       xcb_open_font_checked(c, font, strlen(font_name), font_name);
 
   xcb_generic_error_t *error;
   error = xcb_request_check(c, cookie_font);
   if (error) {
     fprintf(stderr, "ERROR: can't open font : %d\n", error->error_code);
     xcb_disconnect(c);
     return -1;
   }
 
   xcb_gcontext_t gc = xcb_generate_id(c);
   uint32_t mask = XCB_GC_FOREGROUND | XCB_GC_BACKGROUND | XCB_GC_FONT;
   uint32_t value_list[] = {screen->black_pixel, screen->white_pixel, font};
   xcb_void_cookie_t cookie_gc =
       xcb_create_gc_checked(c, gc, window, mask, value_list);
 
   error = xcb_request_check(c, cookie_gc);
   if (error) {
     fprintf(stderr, "ERROR: can't create gc : %d\n", error->error_code);
     xcb_disconnect(c);
     exit(-1);
   }
 
   cookie_font = xcb_close_font_checked(c, font);
   error = xcb_request_check(c, cookie_font);
   if (error) {
     fprintf(stderr, "ERROR: can't close font : %d\n", error->error_code);
     xcb_disconnect(c);
     exit(-1);
   }
 
   return gc;
 }
 
 
 static void draw_text(
     xcb_connection_t *c,
     xcb_screen_t     *screen,
     xcb_window_t      window,
     int16_t           x,
     int16_t           y,
     const char       *label)
 {
   xcb_gcontext_t gc = get_gc_font(c, screen, window, "8x13");
   xcb_void_cookie_t cookie_text =
       xcb_image_text_8_checked(c, strlen(label), window, gc, x, y, label);
 
   xcb_generic_error_t *error;
   error = xcb_request_check(c, cookie_text);
   if (error) {
     fprintf(stderr, "ERROR: can't paste text : %d\n", error->error_code);
     xcb_disconnect(c);
     exit(-1);
   }
 
   xcb_void_cookie_t cookie_gc = xcb_free_gc(c, gc);
   error = xcb_request_check(c, cookie_gc);
   if (error) {
     fprintf(stderr, "ERROR: can't free gc : %d\n", error->error_code);
     xcb_disconnect(c);
     exit(-1);
   }
 }
 
 
 int main(int argc, char** argv)
 {
   /* Open the connection to the X server */
   xcb_connection_t* connection = xcb_connect(NULL, NULL);
 
 
   /* Get the first screen */
   xcb_screen_t* screen =
       xcb_setup_roots_iterator(xcb_get_setup(connection)).data;
 
 
   /* Create black (foreground) graphic context */
   xcb_drawable_t  window     = screen->root;
   xcb_gcontext_t  foreground = xcb_generate_id(connection);
   uint32_t        mask       = XCB_GC_FOREGROUND | XCB_GC_GRAPHICS_EXPOSURES;
   uint32_t        values[2]  = {screen->black_pixel, 0};
 
   xcb_create_gc(connection, foreground, window, mask, values);
 
 
   /* Create a window */
   window = xcb_generate_id(connection);
 
   mask = XCB_CW_BACK_PIXEL | XCB_CW_EVENT_MASK;
   values[0] = screen->white_pixel;
   values[1] = XCB_EVENT_MASK_EXPOSURE |
               XCB_EVENT_MASK_KEY_PRESS |
               XCB_EVENT_MASK_POINTER_MOTION;
 
   xcb_create_window(connection,                    /* connection    */
                     XCB_COPY_FROM_PARENT,          /* depth         */
                     window,                        /* window Id     */
                     screen->root,                  /* parent window */
                     0, 0,                          /* x, y          */
                     width, height,                 /* width, height */
                     0,                             /* border_width  */
                     XCB_WINDOW_CLASS_INPUT_OUTPUT, /* class         */
                     screen->root_visual,           /* visual        */
                     mask, values);                 /* masks         */
 
 
   /* Map the window on the screen and flush*/
   xcb_map_window(connection, window);
   xcb_flush(connection);
 
   set_crosshair_cursor(connection, screen, window);
 
   /* draw primitives */
   xcb_generic_event_t* event;
   while (event = xcb_wait_for_event(connection)) {
     switch (event->response_type & ~0x80) {
       case XCB_EXPOSE:
       {
           for (int i = 1; i < 1000; i++)
           {
             int y = 15;
             if (i % 50 == 0) y = 45;
             else if (i % 10 == 0) y = 35;
             else if (i % 5 == 0) y = 25;
 
             xcb_point_t  polyline[] = { {5*i, 0}, {0, y} };
             xcb_poly_line(
                 connection, XCB_COORD_MODE_PREVIOUS, window, foreground,
                 2, polyline);
           }
 
           /* flush the request */
           xcb_flush(connection);
 
           break;
       }
 
       case XCB_KEY_PRESS:
       {
         xcb_key_press_event_t* kp = (xcb_key_press_event_t*) event;
 
         if (kp->detail == 24 || kp->detail == 9)      /* q or ESC */
         {
           free(event);
           xcb_disconnect(connection);
           return 0;
         }
       }
 
       case XCB_MOTION_NOTIFY:
       {
         xcb_motion_notify_event_t* motion = (xcb_motion_notify_event_t*) event;
         char buf[16];
         snprintf(buf, 16, "%04d,%04d      ", motion->event_x, motion->event_y);
         draw_text(connection, screen, window, 5, height - 5, buf);
         break;
       }
 
       default:
         /* Unknown event type, ignore it */
         break;
     }
 
     free(event);
   }
 }