git.sur5r.net Git - i3/i3/blob - i3bar/src/cairo_util.c

   1 /*
   2  * vim:ts=4:sw=4:expandtab
   3  *
   4  * © 2015 Ingo Bürk and contributors (see also: LICENSE)
   5  *
   6  * cairo_util.c: Utility for operations using cairo.
   7  *
   8  */
   9 #include <stdlib.h>
  10 #include <err.h>
  11 #include <string.h>
  12 #include <xcb/xcb.h>
  13 #include <xcb/xcb_aux.h>
  14 #include <cairo/cairo-xcb.h>
  15
  16 #include "common.h"
  17 #include "libi3.h"
  18
  19 xcb_connection_t *xcb_connection;
  20 xcb_visualtype_t *visual_type;
  21
  22 /*
  23  * Initialize the cairo surface to represent the given drawable.
  24  *
  25  */
  26 void cairo_surface_init(surface_t *surface, xcb_drawable_t drawable, int width, int height) {
  27     surface->id = drawable;
  28
  29     surface->gc = xcb_generate_id(xcb_connection);
  30     xcb_void_cookie_t gc_cookie = xcb_create_gc_checked(xcb_connection, surface->gc, surface->id, 0, NULL);
  31     if (xcb_request_failed(gc_cookie, "Could not create graphical context"))
  32         exit(EXIT_FAILURE);
  33
  34     surface->surface = cairo_xcb_surface_create(xcb_connection, surface->id, visual_type, width, height);
  35     surface->cr = cairo_create(surface->surface);
  36 }
  37
  38 /*
  39  * Destroys the surface.
  40  *
  41  */
  42 void cairo_surface_free(surface_t *surface) {
  43     xcb_free_gc(xcb_connection, surface->gc);
  44     cairo_surface_destroy(surface->surface);
  45     cairo_destroy(surface->cr);
  46 }
  47
  48 /*
  49  * Parses the given color in hex format to an internal color representation.
  50  * Note that the input must begin with a hash sign, e.g., "#3fbc59".
  51  *
  52  */
  53 color_t cairo_hex_to_color(const char *color) {
  54     char alpha[2];
  55     if (strlen(color) == strlen("#rrggbbaa")) {
  56         alpha[0] = color[7];
  57         alpha[1] = color[8];
  58     } else {
  59         alpha[0] = alpha[1] = 'F';
  60     }
  61
  62     char groups[4][3] = {
  63         {color[1], color[2], '\0'},
  64         {color[3], color[4], '\0'},
  65         {color[5], color[6], '\0'},
  66         {alpha[0], alpha[1], '\0'}};
  67
  68     return (color_t){
  69         .red = strtol(groups[0], NULL, 16) / 255.0,
  70         .green = strtol(groups[1], NULL, 16) / 255.0,
  71         .blue = strtol(groups[2], NULL, 16) / 255.0,
  72         .alpha = strtol(groups[3], NULL, 16) / 255.0,
  73         .colorpixel = get_colorpixel(color)};
  74 }
  75
  76 /*
  77  * Set the given color as the source color on the surface.
  78  *
  79  */
  80 void cairo_set_source_color(surface_t *surface, color_t color) {
  81     cairo_set_source_rgba(surface->cr, color.red, color.green, color.blue, color.alpha);
  82 }
  83
  84 /**
  85  * Draw the given text using libi3.
  86  * This function also marks the surface dirty which is needed if other means of
  87  * drawing are used. This will be the case when using XCB to draw text.
  88  *
  89  */
  90 void cairo_draw_text(i3String *text, surface_t *surface, color_t fg_color, color_t bg_color, int x, int y, int max_width) {
  91     set_font_colors(surface->gc, fg_color.colorpixel, bg_color.colorpixel);
  92     draw_text(text, surface->id, surface->gc, visual_type, x, y, max_width);
  93
  94     cairo_surface_mark_dirty(surface->surface);
  95 }
  96
  97 /**
  98  * Draws a filled rectangle.
  99  * This function is a convenience wrapper and takes care of flushing the
 100  * surface as well as restoring the cairo state.
 101  * Note that the drawing is done using CAIRO_OPERATOR_SOURCE.
 102  *
 103  */
 104 void cairo_draw_rectangle(surface_t *surface, color_t color, double x, double y, double w, double h) {
 105     cairo_save(surface->cr);
 106
 107     /* Using the SOURCE operator will copy both color and alpha information directly
 108      * onto the surface rather than blending it. This is a bit more efficient and
 109      * allows better color control for the user when using opacity. */
 110     cairo_set_operator(surface->cr, CAIRO_OPERATOR_SOURCE);
 111     cairo_set_source_color(surface, color);
 112
 113     cairo_rectangle(surface->cr, x, y, w, h);
 114     cairo_fill(surface->cr);
 115
 116     /* Make sure we flush the surface for any text drawing operations that could follow.
 117      * Since we support drawing text via XCB, we need this. */
 118     cairo_surface_flush(surface->surface);
 119
 120     cairo_restore(surface->cr);
 121 }
 122
 123 /**
 124  * Copies a surface onto another surface.
 125  * Note that the drawing is done using CAIRO_OPERATOR_SOURCE.
 126  *
 127  */
 128 void cairo_copy_surface(surface_t *src, surface_t *dest, double src_x, double src_y,
 129                         double dest_x, double dest_y, double dest_w, double dest_h) {
 130     cairo_save(dest->cr);
 131
 132     /* Using the SOURCE operator will copy both color and alpha information directly
 133      * onto the surface rather than blending it. This is a bit more efficient and
 134      * allows better color control for the user when using opacity. */
 135     cairo_set_operator(dest->cr, CAIRO_OPERATOR_SOURCE);
 136     cairo_set_source_surface(dest->cr, src->surface, src_x, src_y);
 137
 138     cairo_rectangle(dest->cr, dest_x, dest_y, dest_w, dest_h);
 139     cairo_fill(dest->cr);
 140
 141     /* Make sure we flush the surface for any text drawing operations that could follow.
 142      * Since we support drawing text via XCB, we need this. */
 143     cairo_surface_flush(dest->surface);
 144     cairo_restore(dest->cr);
 145 }