nixo
/
gri3-wm
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Merge branch 'drawing' into next (Thanks fernandotcl) 

(from the 'less code duplication & more uniform behavior' department)
This commit is contained in:
Michael Stapelberg 2011-11-21 21:48:34 +00:00
parent 70151ea238 561cf3719f
commit 32e58e7b39
19 changed files with 374 additions and 368 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

24
i3-config-wizard/main.c
View File

@ -112,13 +112,15 @@ static int handle_expose() {
xcb_change_gc(conn, pixmap_gc, XCB_GC_FOREGROUND, (uint32_t[]){ get_colorpixel("#000000") });
xcb_poly_fill_rectangle(conn, pixmap, pixmap_gc, 1, &border);
xcb_change_gc(conn, pixmap_gc, XCB_GC_FONT, (uint32_t[]){ font.id });
set_font(&font);
#define txt(x, row, text) xcb_image_text_8(conn, strlen(text), pixmap, pixmap_gc, x, (row * font.height) + 2, text)
#define txt(x, row, text) \
draw_text(text, strlen(text), false, pixmap, pixmap_gc,\
x, (row - 1) * font.height + 4, 300 - x * 2)
if (current_step == STEP_WELCOME) {
/* restore font color */
xcb_change_gc(conn, pixmap_gc, XCB_GC_FOREGROUND, (uint32_t[]){ get_colorpixel("#FFFFFF") });
set_font_colors(pixmap_gc, get_colorpixel("#FFFFFF"), get_colorpixel("#000000"));
txt(10, 2, "You have not configured i3 yet.");
txt(10, 3, "Do you want me to generate ~/.i3/config?");
@ -126,16 +128,16 @@ static int handle_expose() {
txt(85, 7, "No, I will use the defaults");
/* green */
xcb_change_gc(conn, pixmap_gc, XCB_GC_FOREGROUND, (uint32_t[]){ get_colorpixel("#00FF00") });
set_font_colors(pixmap_gc, get_colorpixel("#00FF00"), get_colorpixel("#000000"));
txt(25, 5, "<Enter>");
/* red */
xcb_change_gc(conn, pixmap_gc, XCB_GC_FOREGROUND, (uint32_t[]){ get_colorpixel("#FF0000") });
set_font_colors(pixmap_gc, get_colorpixel("#FF0000"), get_colorpixel("#000000"));
txt(31, 7, "<ESC>");
}
if (current_step == STEP_GENERATE) {
xcb_change_gc(conn, pixmap_gc, XCB_GC_FOREGROUND, (uint32_t[]){ get_colorpixel("#FFFFFF") });
set_font_colors(pixmap_gc, get_colorpixel("#FFFFFF"), get_colorpixel("#000000"));
txt(10, 2, "Please choose either:");
txt(85, 4, "Win as default modifier");
@ -150,19 +152,19 @@ static int handle_expose() {
else txt(31, 4, "<Win>");
/* the selected modifier */
xcb_change_gc(conn, pixmap_gc, XCB_GC_FONT, (uint32_t[]){ bold_font.id });
set_font(&bold_font);
set_font_colors(pixmap_gc, get_colorpixel("#FFFFFF"), get_colorpixel("#000000"));
if (modifier == MOD_Mod4)
txt(31, 4, "<Win>");
else txt(31, 5, "<Alt>");
/* green */
xcb_change_gc(conn, pixmap_gc, XCB_GC_FOREGROUND | XCB_GC_FONT,
(uint32_t[]) { get_colorpixel("#00FF00"), font.id });
set_font(&font);
set_font_colors(pixmap_gc, get_colorpixel("#00FF00"), get_colorpixel("#000000"));
txt(25, 9, "<Enter>");
/* red */
xcb_change_gc(conn, pixmap_gc, XCB_GC_FOREGROUND, (uint32_t[]){ get_colorpixel("#FF0000") });
set_font_colors(pixmap_gc, get_colorpixel("#FF0000"), get_colorpixel("#000000"));
txt(31, 10, "<ESC>");
}

14
i3-input/main.c
View File

@ -50,7 +50,7 @@ static char *glyphs_utf8[512];
static int input_position;
static i3Font font;
static char *prompt;
static int prompt_len;
static size_t prompt_len;
static int limit;
xcb_window_t root;
xcb_connection_t *conn;
@ -94,7 +94,9 @@ static int handle_expose(void *data, xcb_connection_t *conn, xcb_expose_event_t
xcb_poly_fill_rectangle(conn, pixmap, pixmap_gc, 1, &inner);
/* restore font color */
xcb_change_gc(conn, pixmap_gc, XCB_GC_FOREGROUND, (uint32_t[]){ get_colorpixel("#FFFFFF") });
set_font_colors(pixmap_gc, get_colorpixel("#FFFFFF"), get_colorpixel("#000000"));
/* draw the text */
uint8_t *con = concat_strings(glyphs_ucs, input_position);
char *full_text = (char*)con;
if (prompt != NULL) {
@ -104,8 +106,8 @@ static int handle_expose(void *data, xcb_connection_t *conn, xcb_expose_event_t
memcpy(full_text, prompt, prompt_len * 2);
memcpy(full_text + (prompt_len * 2), con, input_position * 2);
}
xcb_image_text_16(conn, input_position + prompt_len, pixmap, pixmap_gc, 4 /* X */,
font.height + 2 /* Y = baseline of font */, (xcb_char2b_t*)full_text);
if (input_position + prompt_len != 0)
draw_text(full_text, input_position + prompt_len, true, pixmap, pixmap_gc, 4, 4, 492);
/* Copy the contents of the pixmap to the real window */
xcb_copy_area(conn, pixmap, win, pixmap_gc, 0, 0, 0, 0, /* */ 500, font.height + 8);
@ -361,6 +363,7 @@ int main(int argc, char *argv[]) {
symbols = xcb_key_symbols_alloc(conn);
font = load_font(pattern, true);
set_font(&font);
/* Open an input window */
win = xcb_generate_id(conn);
@ -393,9 +396,6 @@ int main(int argc, char *argv[]) {
* this for us) */
xcb_set_input_focus(conn, XCB_INPUT_FOCUS_POINTER_ROOT, win, XCB_CURRENT_TIME);
/* Create graphics context */
xcb_change_gc(conn, pixmap_gc, XCB_GC_FONT, (uint32_t[]){ font.id });
/* Grab the keyboard to get all input */
xcb_flush(conn);

33
i3-nagbar/main.c
View File

@ -131,17 +131,15 @@ static int handle_expose(xcb_connection_t *conn, xcb_expose_event_t *event) {
xcb_poly_fill_rectangle(conn, pixmap, pixmap_gc, 1, &rect);
/* restore font color */
uint32_t values[3];
values[0] = color_text;
values[1] = color_background;
xcb_change_gc(conn, pixmap_gc, XCB_GC_FOREGROUND | XCB_GC_BACKGROUND, values);
xcb_image_text_8(conn, strlen(prompt), pixmap, pixmap_gc, 4 + 4/* X */,
font.height + 2 + 4 /* Y = baseline of font */, prompt);
set_font_colors(pixmap_gc, color_text, color_background);
draw_text(prompt, strlen(prompt), false, pixmap, pixmap_gc,
4 + 4, 4 + 4, rect.width - 4 - 4);
/* render close button */
int line_width = 4;
int w = 20;
int y = rect.width;
uint32_t values[3];
values[0] = color_button_background;
values[1] = line_width;
xcb_change_gc(conn, pixmap_gc, XCB_GC_FOREGROUND | XCB_GC_LINE_WIDTH, values);
@ -159,12 +157,10 @@ static int handle_expose(xcb_connection_t *conn, xcb_expose_event_t *event) {
};
xcb_poly_line(conn, XCB_COORD_MODE_ORIGIN, pixmap, pixmap_gc, 5, points);
values[0] = color_text;
values[1] = color_button_background;
values[2] = 1;
xcb_change_gc(conn, pixmap_gc, XCB_GC_FOREGROUND | XCB_GC_BACKGROUND | XCB_GC_LINE_WIDTH, values);
xcb_image_text_8(conn, strlen("x"), pixmap, pixmap_gc, y - w - line_width + (w / 2) - 4/* X */,
font.height + 2 + 4 - 1/* Y = baseline of font */, "X");
values[0] = 1;
set_font_colors(pixmap_gc, color_text, color_button_background);
draw_text("X", 1, false, pixmap, pixmap_gc, y - w - line_width + w / 2 - 4,
4 + 4 - 1, rect.width - y + w + line_width - w / 2 + 4);
y -= w;
y -= 20;
@ -193,9 +189,9 @@ static int handle_expose(xcb_connection_t *conn, xcb_expose_event_t *event) {
values[0] = color_text;
values[1] = color_button_background;
xcb_change_gc(conn, pixmap_gc, XCB_GC_FOREGROUND | XCB_GC_BACKGROUND, values);
xcb_image_text_8(conn, strlen(buttons[c].label), pixmap, pixmap_gc, y - w - line_width + 6/* X */,
font.height + 2 + 3/* Y = baseline of font */, buttons[c].label);
set_font_colors(pixmap_gc, color_text, color_button_background);
draw_text(buttons[c].label, strlen(buttons[c].label), false, pixmap, pixmap_gc,
y - w - line_width + 6, 4 + 3, rect.width - y + w + line_width - 6);
y -= w;
}
@ -304,6 +300,7 @@ int main(int argc, char *argv[]) {
}
font = load_font(pattern, true);
set_font(&font);
/* Open an input window */
win = xcb_generate_id(conn);
@ -387,9 +384,6 @@ int main(int argc, char *argv[]) {
xcb_create_pixmap(conn, root_screen->root_depth, pixmap, win, 500, font.height + 8);
xcb_create_gc(conn, pixmap_gc, pixmap, 0, 0);
/* Create graphics context */
xcb_change_gc(conn, pixmap_gc, XCB_GC_FONT, (uint32_t[]){ font.id });
/* Grab the keyboard to get all input */
xcb_flush(conn);
@ -431,9 +425,6 @@ int main(int argc, char *argv[]) {
xcb_create_pixmap(conn, root_screen->root_depth, pixmap, win, rect.width, rect.height);
xcb_create_gc(conn, pixmap_gc, pixmap, 0, 0);
/* Create graphics context */
xcb_change_gc(conn, pixmap_gc, XCB_GC_FONT, (uint32_t[]){ font.id });
break;
}
}

8
i3bar/include/xcb.h
View File

@ -103,12 +103,4 @@ void draw_bars();
*/
void redraw_bars();
/*
* Predicts the length of text based on cached data.
* The string has to be encoded in ucs2 and glyph_len has to be the length
* of the string (in glyphs).
*
*/
uint32_t predict_text_extents(xcb_char2b_t *text, uint32_t length);
#endif

6
i3bar/src/workspaces.c
View File

@ -119,13 +119,13 @@ static int workspaces_string_cb(void *params_, const unsigned char *val, unsigne
params->workspaces_walk->name[len] = '\0';
/* Convert the name to ucs2, save its length in glyphs and calculate its rendered width */
int ucs2_len;
size_t ucs2_len;
xcb_char2b_t *ucs2_name = (xcb_char2b_t*) convert_utf8_to_ucs2(params->workspaces_walk->name, &ucs2_len);
params->workspaces_walk->ucs2_name = ucs2_name;
params->workspaces_walk->name_glyphs = ucs2_len;
params->workspaces_walk->name_width =
predict_text_extents(params->workspaces_walk->ucs2_name,
params->workspaces_walk->name_glyphs);
predict_text_width((char *)params->workspaces_walk->ucs2_name,
params->workspaces_walk->name_glyphs, true);
DLOG("Got Workspace %s, name_width: %d, glyphs: %d\n",
params->workspaces_walk->name,

207
i3bar/src/xcb.c
View File

@ -48,12 +48,12 @@ xcb_connection_t *xcb_connection;
int screen;
xcb_screen_t *xcb_screen;
xcb_window_t xcb_root;
xcb_font_t xcb_font;
/* We need to cache some data to speed up text-width-prediction */
xcb_query_font_reply_t *font_info;
int font_height;
xcb_charinfo_t *font_table;
/* This is needed for integration with libi3 */
xcb_connection_t *conn;
/* The font we'll use */
static i3Font font;
/* These are only relevant for XKB, which we only need for grabbing modifiers */
Display *xkb_dpy;
@ -99,98 +99,31 @@ int _xcb_request_failed(xcb_void_cookie_t cookie, char *err_msg, int line) {
return 0;
}
/*
* Predicts the length of text based on cached data.
* The string has to be encoded in ucs2 and glyph_len has to be the length
* of the string (in glyphs).
*
*/
uint32_t predict_text_extents(xcb_char2b_t *text, uint32_t length) {
/* If we don't have per-character data, return the maximum width */
if (font_table == NULL) {
return (font_info->max_bounds.character_width * length);
}
uint32_t width = 0;
uint32_t i;
for (i = 0; i < length; i++) {
xcb_charinfo_t *info;
int row = text[i].byte1;
int col = text[i].byte2;
if (row < font_info->min_byte1 || row > font_info->max_byte1 ||
col < font_info->min_char_or_byte2 || col > font_info->max_char_or_byte2) {
continue;
}
/* Don't you ask me, how this one works… */
info = &font_table[((row - font_info->min_byte1) *
(font_info->max_char_or_byte2 - font_info->min_char_or_byte2 + 1)) +
(col - font_info->min_char_or_byte2)];
if (info->character_width != 0 ||
(info->right_side_bearing |
info->left_side_bearing |
info->ascent |
info->descent) != 0) {
width += info->character_width;
}
}
return width;
}
/*
* Draws text given in UCS-2-encoding to a given drawable and position
*
*/
void draw_text(xcb_drawable_t drawable, xcb_gcontext_t ctx, int16_t x, int16_t y,
xcb_char2b_t *text, uint32_t glyph_count) {
int offset = 0;
int16_t pos_x = x;
int16_t font_ascent = font_info->font_ascent;
while (glyph_count > 0) {
uint8_t chunk_size = MIN(255, glyph_count);
uint32_t chunk_width = predict_text_extents(text + offset, chunk_size);
xcb_image_text_16(xcb_connection,
chunk_size,
drawable,
ctx,
pos_x, y + font_ascent,
text + offset);
offset += chunk_size;
pos_x += chunk_width;
glyph_count -= chunk_size;
}
}
/*
* Redraws the statusline to the buffer
*
*/
void refresh_statusline() {
int glyph_count;
size_t glyph_count;
if (statusline == NULL) {
return;
}
xcb_char2b_t *text = (xcb_char2b_t*) convert_utf8_to_ucs2(statusline, &glyph_count);
xcb_char2b_t *text = (xcb_char2b_t*)convert_utf8_to_ucs2(statusline, &glyph_count);
uint32_t old_statusline_width = statusline_width;
statusline_width = predict_text_extents(text, glyph_count);
statusline_width = predict_text_width((char*)text, glyph_count, true);
/* If the statusline is bigger than our screen we need to make sure that
* the pixmap provides enough space, so re-allocate if the width grew */
if (statusline_width > xcb_screen->width_in_pixels &&
statusline_width > old_statusline_width)
realloc_sl_buffer();
xcb_rectangle_t rect = { 0, 0, xcb_screen->width_in_pixels, font_height };
xcb_rectangle_t rect = { 0, 0, xcb_screen->width_in_pixels, font.height };
xcb_poly_fill_rectangle(xcb_connection, statusline_pm, statusline_clear, 1, &rect);
draw_text(statusline_pm, statusline_ctx, 0, 0, text, glyph_count);
set_font_colors(statusline_ctx, colors.bar_fg, colors.bar_bg);
draw_text((char*)text, glyph_count, true, statusline_pm, statusline_ctx,
0, 0, xcb_screen->width_in_pixels);
FREE(text);
}
@ -242,9 +175,9 @@ void unhide_bars() {
values[0] = walk->rect.x;
if (config.position == POS_TOP)
values[1] = walk->rect.y;
else values[1] = walk->rect.y + walk->rect.h - font_height - 6;
else values[1] = walk->rect.y + walk->rect.h - font.height - 6;
values[2] = walk->rect.w;
values[3] = font_height + 6;
values[3] = font.height + 6;
values[4] = XCB_STACK_MODE_ABOVE;
DLOG("Reconfiguring Window for output %s to %d,%d\n", walk->name, values[0], values[1]);
cookie = xcb_configure_window_checked(xcb_connection,
@ -378,8 +311,8 @@ static void configure_trayclients() {
clients++;
DLOG("Configuring tray window %08x to x=%d\n",
trayclient->win, output->rect.w - (clients * (font_height + 2)));
uint32_t x = output->rect.w - (clients * (font_height + 2));
trayclient->win, output->rect.w - (clients * (font.height + 2)));
uint32_t x = output->rect.w - (clients * (font.height + 2));
xcb_configure_window(xcb_connection,
trayclient->win,
XCB_CONFIG_WINDOW_X,
@ -465,7 +398,7 @@ static void handle_client_message(xcb_client_message_event_t* event) {
xcb_reparent_window(xcb_connection,
client,
output->bar,
output->rect.w - font_height - 2,
output->rect.w - font.height - 2,
2);
/* We reconfigure the window to use a reasonable size. The systray
* specification explicitly says:
@ -473,8 +406,8 @@ static void handle_client_message(xcb_client_message_event_t* event) {
* should do their best to cope with any size effectively
*/
mask = XCB_CONFIG_WINDOW_WIDTH | XCB_CONFIG_WINDOW_HEIGHT;
values[0] = font_height;
values[1] = font_height;
values[0] = font.height;
values[1] = font.height;
xcb_configure_window(xcb_connection,
client,
mask,
@ -649,10 +582,10 @@ static void handle_configure_request(xcb_configure_request_event_t *event) {
continue;
xcb_rectangle_t rect;
rect.x = output->rect.w - (clients * (font_height + 2));
rect.x = output->rect.w - (clients * (font.height + 2));
rect.y = 2;
rect.width = font_height;
rect.height = font_height;
rect.width = font.height;
rect.height = font.height;
DLOG("This is a tray window. x = %d\n", rect.x);
fake_configure_notify(xcb_connection, rect, event->window, 0);
@ -778,6 +711,7 @@ char *init_xcb_early() {
ELOG("Cannot open display\n");
exit(EXIT_FAILURE);
}
conn = xcb_connection;
DLOG("Connected to xcb\n");
/* We have to request the atoms we need */
@ -799,14 +733,12 @@ char *init_xcb_early() {
mask,
vals);
mask |= XCB_GC_BACKGROUND;
vals[0] = colors.bar_fg;
statusline_ctx = xcb_generate_id(xcb_connection);
xcb_void_cookie_t sl_ctx_cookie = xcb_create_gc_checked(xcb_connection,
statusline_ctx,
xcb_root,
mask,
vals);
0,
NULL);
statusline_pm = xcb_generate_id(xcb_connection);
xcb_void_cookie_t sl_pm_cookie = xcb_create_pixmap_checked(xcb_connection,
@ -869,29 +801,13 @@ char *init_xcb_early() {
*
*/
void init_xcb_late(char *fontname) {
if (fontname == NULL) {
/* XXX: font fallback to 'misc' like i3 does it would be good. */
if (fontname == NULL)
fontname = "-misc-fixed-medium-r-normal--13-120-75-75-C-70-iso10646-1";
}
/* We load and allocate the font */
xcb_font = xcb_generate_id(xcb_connection);
xcb_void_cookie_t open_font_cookie;
open_font_cookie = xcb_open_font_checked(xcb_connection,
xcb_font,
strlen(fontname),
fontname);
/* We need to save info about the font, because we need the font's height and
* information about the width of characters */
xcb_query_font_cookie_t query_font_cookie;
query_font_cookie = xcb_query_font(xcb_connection,
xcb_font);
xcb_change_gc(xcb_connection,
statusline_ctx,
XCB_GC_FONT,
(uint32_t[]){ xcb_font });
/* Load the font */
font = load_font(fontname, true);
set_font(&font);
DLOG("Calculated Font-height: %d\n", font.height);
xcb_flush(xcb_connection);
@ -936,25 +852,6 @@ void init_xcb_late(char *fontname) {
ev_io_start(main_loop, xkb_io);
XFlush(xkb_dpy);
}
/* Now we save the font-infos */
font_info = xcb_query_font_reply(xcb_connection,
query_font_cookie,
NULL);
if (xcb_request_failed(open_font_cookie, "Could not open font")) {
exit(EXIT_FAILURE);
}
font_height = font_info->font_ascent + font_info->font_descent;
if (xcb_query_font_char_infos_length(font_info) == 0) {
font_table = NULL;
} else {
font_table = xcb_query_font_char_infos(font_info);
}
DLOG("Calculated Font-height: %d\n", font_height);
}
/*
@ -1084,7 +981,6 @@ void clean_xcb() {
FREE(xcb_chk);
FREE(xcb_prep);
FREE(xcb_io);
FREE(font_info);
}
/*
@ -1137,7 +1033,7 @@ void realloc_sl_buffer() {
xcb_screen->height_in_pixels);
uint32_t mask = XCB_GC_FOREGROUND;
uint32_t vals[3] = { colors.bar_bg, colors.bar_bg, xcb_font };
uint32_t vals[2] = { colors.bar_bg, colors.bar_bg };
xcb_free_gc(xcb_connection, statusline_clear);
statusline_clear = xcb_generate_id(xcb_connection);
xcb_void_cookie_t clear_ctx_cookie = xcb_create_gc_checked(xcb_connection,
@ -1146,7 +1042,7 @@ void realloc_sl_buffer() {
mask,
vals);
mask |= XCB_GC_BACKGROUND | XCB_GC_FONT;
mask |= XCB_GC_BACKGROUND;
vals[0] = colors.bar_fg;
statusline_ctx = xcb_generate_id(xcb_connection);
xcb_free_gc(xcb_connection, statusline_ctx);
@ -1207,8 +1103,8 @@ void reconfig_windows() {
xcb_screen->root_depth,
walk->bar,
xcb_root,
walk->rect.x, walk->rect.y + walk->rect.h - font_height - 6,
walk->rect.w, font_height + 6,
walk->rect.x, walk->rect.y + walk->rect.h - font.height - 6,
walk->rect.w, font.height + 6,
1,
XCB_WINDOW_CLASS_INPUT_OUTPUT,
xcb_screen->root_visual,
@ -1282,12 +1178,12 @@ void reconfig_windows() {
case POS_NONE:
break;
case POS_TOP:
strut_partial.top = font_height + 6;
strut_partial.top = font.height + 6;
strut_partial.top_start_x = walk->rect.x;
strut_partial.top_end_x = walk->rect.x + walk->rect.w;
break;
case POS_BOT:
strut_partial.bottom = font_height + 6;
strut_partial.bottom = font.height + 6;
strut_partial.bottom_start_x = walk->rect.x;
strut_partial.bottom_end_x = walk->rect.x + walk->rect.w;
break;
@ -1304,13 +1200,11 @@ void reconfig_windows() {
/* We also want a graphics-context for the bars (it defines the properties
* with which we draw to them) */
walk->bargc = xcb_generate_id(xcb_connection);
mask = XCB_GC_FONT;
values[0] = xcb_font;
xcb_void_cookie_t gc_cookie = xcb_create_gc_checked(xcb_connection,
walk->bargc,
walk->bar,
mask,
values);
0,
NULL);
/* We finally map the bar (display it on screen), unless the modifier-switch is on */
xcb_void_cookie_t map_cookie;
@ -1343,9 +1237,9 @@ void reconfig_windows() {
XCB_CONFIG_WINDOW_HEIGHT |
XCB_CONFIG_WINDOW_STACK_MODE;
values[0] = walk->rect.x;
values[1] = walk->rect.y + walk->rect.h - font_height - 6;
values[1] = walk->rect.y + walk->rect.h - font.height - 6;
values[2] = walk->rect.w;
values[3] = font_height + 6;
values[3] = font.height + 6;
values[4] = XCB_STACK_MODE_ABOVE;
DLOG("Destroying buffer for output %s", walk->name);
@ -1401,7 +1295,7 @@ void draw_bars() {
outputs_walk->bargc,
XCB_GC_FOREGROUND,
&color);
xcb_rectangle_t rect = { 0, 0, outputs_walk->rect.w, font_height + 6 };
xcb_rectangle_t rect = { 0, 0, outputs_walk->rect.w, font.height + 6 };
xcb_poly_fill_rectangle(xcb_connection,
outputs_walk->buffer,
outputs_walk->bargc,
@ -1422,7 +1316,7 @@ void draw_bars() {
/* We assume the tray icons are quadratic (we use the font
* *height* as *width* of the icons) because we configured them
* like this. */
traypx += font_height + 2;
traypx += font.height + 2;
}
/* Add 2px of padding if there are any tray icons */
if (traypx > 0)
@ -1433,7 +1327,7 @@ void draw_bars() {
outputs_walk->bargc,
MAX(0, (int16_t)(statusline_width - outputs_walk->rect.w + 4)), 0,
MAX(0, (int16_t)(outputs_walk->rect.w - statusline_width - traypx - 4)), 3,
MIN(outputs_walk->rect.w - traypx - 4, statusline_width), font_height);
MIN(outputs_walk->rect.w - traypx - 4, statusline_width), font.height);
}
if (config.disable_ws) {
@ -1467,22 +1361,15 @@ void draw_bars() {
outputs_walk->bargc,
mask,
vals);
xcb_rectangle_t rect = { i + 1, 1, ws_walk->name_width + 8, font_height + 4 };
xcb_rectangle_t rect = { i + 1, 1, ws_walk->name_width + 8, font.height + 4 };
xcb_poly_fill_rectangle(xcb_connection,
outputs_walk->buffer,
outputs_walk->bargc,
1,
&rect);
xcb_change_gc(xcb_connection,
outputs_walk->bargc,
XCB_GC_FOREGROUND,
&fg_color);
xcb_image_text_16(xcb_connection,
ws_walk->name_glyphs,
outputs_walk->buffer,
outputs_walk->bargc,
i + 5, font_info->font_ascent + 2,
ws_walk->ucs2_name);
set_font_colors(outputs_walk->bargc, fg_color, bg_color);
draw_text((char*)ws_walk->ucs2_name, ws_walk->name_glyphs, true,
outputs_walk->buffer, outputs_walk->bargc, i + 5, 2, ws_walk->name_width);
i += 10 + ws_walk->name_width;
}

2
include/data.h
View File

@ -285,7 +285,7 @@ struct Window {
char *name_json;
/** The length of the name in glyphs (not bytes) */
int name_len;
size_t name_len;
/** Whether the application used _NET_WM_NAME */
bool uses_net_wm_name;

44
include/libi3.h
View File

@ -27,10 +27,17 @@ typedef struct Font i3Font;
*
*/
struct Font {
/** The height of the font, built from font_ascent + font_descent */
int height;
/** The xcb-id for the font */
xcb_font_t id;
/** Font information gathered from the server */
xcb_query_font_reply_t *info;
/** Font table for this font (may be NULL) */
xcb_charinfo_t *table;
/** The height of the font, built from font_ascent + font_descent */
int height;
};
/* Since this file also gets included by utilities which don’t use the i3 log
@ -177,7 +184,7 @@ uint32_t get_mod_mask_for(uint32_t keysym,
* the fonts 'fixed' or '-misc-*' will be loaded instead of exiting.
*
*/
i3Font load_font(const char *pattern, bool fallback);
i3Font load_font(const char *pattern, const bool fallback);
/**
* Converts the given string to UTF-8 from UCS-2 big endian. The return value
@ -193,6 +200,35 @@ char *convert_ucs2_to_utf8(xcb_char2b_t *text, size_t num_glyphs);
* returned. It has to be freed when done.
*
*/
xcb_char2b_t *convert_utf8_to_ucs2(char *input, int *real_strlen);
xcb_char2b_t *convert_utf8_to_ucs2(char *input, size_t *real_strlen);
/**
* Defines the font to be used for the forthcoming draw_text and
* predict_text_width calls.
*
*/
void set_font(i3Font *font);
/**
* Defines the colors to be used for the forthcoming draw_text calls.
*
*/
void set_font_colors(xcb_gcontext_t gc, uint32_t foreground, uint32_t background);
/**
* Draws text onto the specified X drawable (normally a pixmap) at the
* specified coordinates (from the top left corner of the leftmost, uppermost
* glyph) and using the provided gc. Text can be specified as UCS-2 or UTF-8.
*
*/
void draw_text(char *text, size_t text_len, bool is_ucs2, xcb_drawable_t drawable,
xcb_gcontext_t gc, int x, int y, int max_width);
/**
* Predict the text width in pixels for the given text. Text can be specified
* as UCS-2 or UTF-8.
*
*/
int predict_text_width(char *text, size_t text_len, bool is_ucs2);
#endif

7
include/xcb.h
View File

@ -94,13 +94,6 @@ void send_take_focus(xcb_window_t window);
*/
void xcb_raise_window(xcb_connection_t *conn, xcb_window_t window);
/**
* Calculate the width of the given text (16-bit characters, UCS) with given
* real length (amount of glyphs) using the given font.
*
*/
int predict_text_width(const xcb_char2b_t *text, int length);
/**
* Configures the given window to have the size/position specified by given rect
*

229
libi3/font.c Normal file
View File

@ -0,0 +1,229 @@
/*
* vim:ts=4:sw=4:expandtab
*
* i3 - an improved dynamic tiling window manager
* © 2009-2011 Michael Stapelberg and contributors (see also: LICENSE)
*
*/
#include <assert.h>
#include <stdint.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>
#include <err.h>
#include "libi3.h"
extern xcb_connection_t *conn;
static const i3Font *savedFont = NULL;
/*
* Loads a font for usage, also getting its metrics. If fallback is true,
* the fonts 'fixed' or '-misc-*' will be loaded instead of exiting.
*
*/
i3Font load_font(const char *pattern, const bool fallback) {
i3Font font;
/* Send all our requests first */
font.id = xcb_generate_id(conn);
xcb_void_cookie_t font_cookie = xcb_open_font_checked(conn, font.id,
strlen(pattern), pattern);
xcb_query_font_cookie_t info_cookie = xcb_query_font(conn, font.id);
/* Check for errors. If errors, fall back to default font. */
xcb_generic_error_t *error;
error = xcb_request_check(conn, font_cookie);
/* If we fail to open font, fall back to 'fixed' */
if (fallback && error != NULL) {
ELOG("Could not open font %s (X error %d). Trying fallback to 'fixed'.\n",
pattern, error->error_code);
pattern = "fixed";
font_cookie = xcb_open_font_checked(conn, font.id, strlen(pattern), pattern);
info_cookie = xcb_query_font(conn, font.id);
/* Check if we managed to open 'fixed' */
error = xcb_request_check(conn, font_cookie);
/* Fall back to '-misc-*' if opening 'fixed' fails. */
if (error != NULL) {
ELOG("Could not open fallback font 'fixed', trying with '-misc-*'.\n");
pattern = "-misc-*";
font_cookie = xcb_open_font_checked(conn, font.id, strlen(pattern), pattern);
info_cookie = xcb_query_font(conn, font.id);
if ((error = xcb_request_check(conn, font_cookie)) != NULL)
errx(EXIT_FAILURE, "Could open neither requested font nor fallbacks "
"(fixed or -misc-*): X11 error %d", error->error_code);
}
}
/* Get information (height/name) for this font */
if (!(font.info = xcb_query_font_reply(conn, info_cookie, NULL)))
errx(EXIT_FAILURE, "Could not load font \"%s\"", pattern);
/* Get the font table, if possible */
font.table = xcb_query_font_char_infos(font.info);
/* Calculate the font height */
font.height = font.info->font_ascent + font.info->font_descent;
return font;
}
/*
* Defines the font to be used for the forthcoming draw_text and
* predict_text_width calls.
*
*/
void set_font(i3Font *font) {
savedFont = font;
}
/*
* Defines the colors to be used for the forthcoming draw_text calls.
*
*/
void set_font_colors(xcb_gcontext_t gc, uint32_t foreground, uint32_t background) {
assert(savedFont != NULL);
uint32_t mask = XCB_GC_FOREGROUND | XCB_GC_BACKGROUND | XCB_GC_FONT;
uint32_t values[] = { foreground, background, savedFont->id };
xcb_change_gc(conn, gc, mask, values);
}
/*
* Draws text onto the specified X drawable (normally a pixmap) at the
* specified coordinates (from the top left corner of the leftmost, uppermost
* glyph) and using the provided gc. Text can be specified as UCS-2 or UTF-8.
*
*/
void draw_text(char *text, size_t text_len, bool is_ucs2, xcb_drawable_t drawable,
xcb_gcontext_t gc, int x, int y, int max_width) {
assert(savedFont != NULL);
assert(text_len != 0);
/* X11 coordinates for fonts start at the baseline */
int pos_y = y + savedFont->info->font_ascent;
/* As an optimization, check if we can bypass conversion */
if (!is_ucs2 && text_len <= 255) {
xcb_image_text_8(conn, text_len, drawable, gc, x, pos_y, text);
return;
}
/* Convert the text into UCS-2 so we can do basic pointer math */
char *input = (is_ucs2 ? text : (char*)convert_utf8_to_ucs2(text, &text_len));
/* The X11 protocol limits text drawing to 255 chars, so we may need
* multiple calls */
int pos_x = x;
int offset = 0;
for (;;) {
/* Calculate the size of this chunk */
int chunk_size = (text_len > 255 ? 255 : text_len);
xcb_char2b_t *chunk = (xcb_char2b_t*)input + offset;
/* Draw it */
xcb_image_text_16(conn, chunk_size, drawable, gc, pos_x, pos_y, chunk);
/* Advance the offset and length of the text to draw */
offset += chunk_size;
text_len -= chunk_size;
/* Check if we're done */
if (text_len == 0)
break;
/* Advance pos_x based on the predicted text width */
pos_x += predict_text_width((char*)chunk, chunk_size, true);
}
/* If we had to convert, free the converted string */
if (!is_ucs2)
free(input);
}
static int xcb_query_text_width(xcb_char2b_t *text, size_t text_len) {
/* Make the user know we’re using the slow path, but only once. */
static bool first_invocation = true;
if (first_invocation) {
fprintf(stderr, "Using slow code path for text extents\n");
first_invocation = false;
}
/* Query the text width */
xcb_generic_error_t *error;
xcb_query_text_extents_cookie_t cookie = xcb_query_text_extents(conn,
savedFont->id, text_len, (xcb_char2b_t*)text);
xcb_query_text_extents_reply_t *reply = xcb_query_text_extents_reply(conn,
cookie, &error);
if (reply == NULL) {
/* We return a safe estimate because a rendering error is better than
* a crash. Plus, the user will see the error in his log. */
fprintf(stderr, "Could not get text extents (X error code %d)\n",
error->error_code);
return savedFont->info->max_bounds.character_width * text_len;
}
int width = reply->overall_width;
free(reply);
return width;
}
/*
* Predict the text width in pixels for the given text. Text can be specified
* as UCS-2 or UTF-8.
*
*/
int predict_text_width(char *text, size_t text_len, bool is_ucs2) {
/* Convert the text into UTF-16 so we can do basic pointer math */
xcb_char2b_t *input;
if (is_ucs2)
input = (xcb_char2b_t*)text;
else
input = convert_utf8_to_ucs2(text, &text_len);
int width;
if (savedFont->table == NULL) {
/* If we don't have a font table, fall back to querying the server */
width = xcb_query_text_width(input, text_len);
} else {
/* Save some pointers for convenience */
xcb_query_font_reply_t *font_info = savedFont->info;
xcb_charinfo_t *font_table = savedFont->table;
/* Calculate the width using the font table */
width = 0;
for (size_t i = 0; i < text_len; i++) {
xcb_charinfo_t *info;
int row = input[i].byte1;
int col = input[i].byte2;
if (row < font_info->min_byte1 ||
row > font_info->max_byte1 ||
col < font_info->min_char_or_byte2 ||
col > font_info->max_char_or_byte2)
continue;
/* Don't you ask me, how this one works… (Merovius) */
info = &font_table[((row - font_info->min_byte1) *
(font_info->max_char_or_byte2 - font_info->min_char_or_byte2 + 1)) +
(col - font_info->min_char_or_byte2)];
if (info->character_width != 0 ||
(info->right_side_bearing |
info->left_side_bearing |
info->ascent |
info->descent) != 0) {
width += info->character_width;
}
}
}
/* If we had to convert, free the converted string */
if (!is_ucs2)
free(input);
return width;
}

71
libi3/load_font.c
View File

@ -1,71 +0,0 @@
/*
* vim:ts=4:sw=4:expandtab
*
* i3 - an improved dynamic tiling window manager
* © 2009-2011 Michael Stapelberg and contributors (see also: LICENSE)
*
*/
#include <stdint.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>
#include <err.h>
#include "libi3.h"
extern xcb_connection_t *conn;
/*
* Loads a font for usage, also getting its height. If fallback is true,
* the fonts 'fixed' or '-misc-*' will be loaded instead of exiting.
*
*/
i3Font load_font(const char *pattern, bool fallback) {
i3Font font;
xcb_void_cookie_t font_cookie;
xcb_list_fonts_with_info_cookie_t info_cookie;
xcb_list_fonts_with_info_reply_t *info_reply;
xcb_generic_error_t *error;
/* Send all our requests first */
font.id = xcb_generate_id(conn);
font_cookie = xcb_open_font_checked(conn, font.id, strlen(pattern), pattern);
info_cookie = xcb_list_fonts_with_info(conn, 1, strlen(pattern), pattern);
/* Check for errors. If errors, fall back to default font. */
error = xcb_request_check(conn, font_cookie);
/* If we fail to open font, fall back to 'fixed' */
if (fallback && error != NULL) {
ELOG("Could not open font %s (X error %d). Trying fallback to 'fixed'.\n",
pattern, error->error_code);
pattern = "fixed";
font_cookie = xcb_open_font_checked(conn, font.id, strlen(pattern), pattern);
info_cookie = xcb_list_fonts_with_info(conn, 1, strlen(pattern), pattern);
/* Check if we managed to open 'fixed' */
error = xcb_request_check(conn, font_cookie);
/* Fall back to '-misc-*' if opening 'fixed' fails. */
if (error != NULL) {
ELOG("Could not open fallback font 'fixed', trying with '-misc-*'.\n");
pattern = "-misc-*";
font_cookie = xcb_open_font_checked(conn, font.id, strlen(pattern), pattern);
info_cookie = xcb_list_fonts_with_info(conn, 1, strlen(pattern), pattern);
if ((error = xcb_request_check(conn, font_cookie)) != NULL)
errx(EXIT_FAILURE, "Could open neither requested font nor fallbacks "
"(fixed or -misc-*): X11 error %d", error->error_code);
}
}
/* Get information (height/name) for this font */
if (!(info_reply = xcb_list_fonts_with_info_reply(conn, info_cookie, NULL)))
errx(EXIT_FAILURE, "Could not load font \"%s\"", pattern);
font.height = info_reply->font_ascent + info_reply->font_descent;
free(info_reply);
return font;
}

2
libi3/ucs2_conversion.c
View File

@ -60,7 +60,7 @@ char *convert_ucs2_to_utf8(xcb_char2b_t *text, size_t num_glyphs) {
* returned. It has to be freed when done.
*
*/
xcb_char2b_t *convert_utf8_to_ucs2(char *input, int *real_strlen) {
xcb_char2b_t *convert_utf8_to_ucs2(char *input, size_t *real_strlen) {
/* Calculate the input buffer size (UTF-8 is strlen-safe) */
size_t input_size = strlen(input);

1
src/cfgparse.y
View File

@ -1546,6 +1546,7 @@ font:
TOKFONT STR
{
config.font = load_font($2, true);
set_font(&config.font);
printf("font %s\n", $2);
FREE(font_pattern);
font_pattern = $2;

1
src/config.c
View File

@ -371,6 +371,7 @@ void load_configuration(xcb_connection_t *conn, const char *override_configpath,
if (config.font.id == 0) {
ELOG("You did not specify required configuration option \"font\"\n");
config.font = load_font("fixed", true);
set_font(&config.font);
}
#if 0

4
src/render.c
View File

@ -193,7 +193,9 @@ void render_con(Con *con, bool render_fullscreen) {
}
/* find the height for the decorations */
int deco_height = config.font.height + 5;
int deco_height = config.font.height + 4;
if (config.font.height & 0x01)
++deco_height;
/* precalculate the sizes to be able to correct rounding errors */
int sizes[children];

17
src/sighandler.c
View File

@ -47,15 +47,11 @@ static int sig_draw_window(xcb_window_t win, int width, int height, int font_hei
xcb_poly_fill_rectangle(conn, pixmap, pixmap_gc, 1, &inner);
/* restore font color */
xcb_change_gc(conn, pixmap_gc, XCB_GC_FOREGROUND, (uint32_t[]){ get_colorpixel("#FFFFFF") });
set_font_colors(pixmap_gc, get_colorpixel("#FFFFFF"), get_colorpixel("#000000"));
for (int i = 0; i < sizeof(crash_text) / sizeof(char*); i++) {
int text_len = strlen(crash_text[i]);
xcb_char2b_t *full_text = convert_utf8_to_ucs2(crash_text[i], &text_len);
xcb_image_text_16(conn, text_len, pixmap, pixmap_gc, 8 /* X */,
3 + (i + 1) * font_height /* Y = baseline of font */,
(xcb_char2b_t*)full_text);
free(full_text);
draw_text(crash_text[i], strlen(crash_text[i]), false, pixmap, pixmap_gc,
8, 3 + (i - 1) * font_height, width - 16);
}
/* Copy the contents of the pixmap to the real window */
@ -150,9 +146,9 @@ void handle_signal(int sig, siginfo_t *info, void *data) {
int height = 13 + (crash_text_num * config.font.height);
/* calculate width for longest text */
int text_len = strlen(crash_text[crash_text_longest]);
size_t text_len = strlen(crash_text[crash_text_longest]);
xcb_char2b_t *longest_text = convert_utf8_to_ucs2(crash_text[crash_text_longest], &text_len);
int font_width = predict_text_width(longest_text, text_len);
int font_width = predict_text_width((char *)longest_text, text_len, true);
int width = font_width + 20;
/* Open a popup window on each virtual screen */
@ -169,9 +165,6 @@ void handle_signal(int sig, siginfo_t *info, void *data) {
xcb_create_pixmap(conn, root_depth, pixmap, win, width, height);
xcb_create_gc(conn, pixmap_gc, pixmap, 0, 0);
/* Create graphics context */
xcb_change_gc(conn, pixmap_gc, XCB_GC_FONT, (uint32_t[]){ config.font.id });
/* Grab the keyboard to get all input */
xcb_grab_keyboard(conn, false, win, XCB_CURRENT_TIME, XCB_GRAB_MODE_ASYNC, XCB_GRAB_MODE_ASYNC);

2
src/window.c
View File

@ -68,7 +68,7 @@ void window_update_name(i3Window *win, xcb_get_property_reply_t *prop, bool befo
return;
}
/* Convert it to UCS-2 here for not having to convert it later every time we want to pass it to X */
int len;
size_t len;
xcb_char2b_t *ucs2_name = convert_utf8_to_ucs2(new_name, &len);
if (ucs2_name == NULL) {
LOG("Could not convert _NET_WM_NAME to UCS-2, ignoring new hint\n");

44
src/x.c
View File

@ -408,25 +408,17 @@ void x_draw_decoration(Con *con) {
xcb_poly_segment(conn, parent->pixmap, parent->pm_gc, 2, segments);
/* 6: draw the title */
uint32_t mask = XCB_GC_FOREGROUND | XCB_GC_BACKGROUND | XCB_GC_FONT;
uint32_t values[] = { p->color->text, p->color->background, config.font.id };
xcb_change_gc(conn, parent->pm_gc, mask, values);
int text_offset_y = config.font.height + (con->deco_rect.height - config.font.height) / 2 - 1;
set_font_colors(parent->pm_gc, p->color->text, p->color->background);
int text_offset_y = (con->deco_rect.height - config.font.height) / 2;
struct Window *win = con->window;
if (win == NULL || win->name_x == NULL) {
/* this is a non-leaf container, we need to make up a good description */
// TODO: use a good description instead of just "another container"
xcb_image_text_8(
conn,
strlen("another container"),
parent->pixmap,
parent->pm_gc,
con->deco_rect.x + 2,
con->deco_rect.y + text_offset_y,
"another container"
);
draw_text("another container", strlen("another container"), false,
parent->pixmap, parent->pm_gc,
con->deco_rect.x + 2, con->deco_rect.y + text_offset_y,
con->deco_rect.width - 2);
goto copy_pixmaps;
}
@ -447,26 +439,10 @@ void x_draw_decoration(Con *con) {
//DLOG("indent_level = %d, indent_mult = %d\n", indent_level, indent_mult);
int indent_px = (indent_level * 5) * indent_mult;
if (win->uses_net_wm_name)
xcb_image_text_16(
conn,
win->name_len,
parent->pixmap,
parent->pm_gc,
con->deco_rect.x + 2 + indent_px,
con->deco_rect.y + text_offset_y,
(xcb_char2b_t*)win->name_x
);
else
xcb_image_text_8(
conn,
win->name_len,
parent->pixmap,
parent->pm_gc,
con->deco_rect.x + 2 + indent_px,
con->deco_rect.y + text_offset_y,
win->name_x
);
draw_text(win->name_x, win->name_len, win->uses_net_wm_name,
parent->pixmap, parent->pm_gc,
con->deco_rect.x + 2 + indent_px, con->deco_rect.y + text_offset_y,
con->deco_rect.width - 2 - indent_px);
copy_pixmaps:
xcb_copy_area(conn, con->pixmap, con->frame, con->pm_gc, 0, 0, 0, 0, con->rect.width, con->rect.height);

26
src/xcb.c
View File

@ -130,32 +130,6 @@ void xcb_raise_window(xcb_connection_t *conn, xcb_window_t window) {
xcb_configure_window(conn, window, XCB_CONFIG_WINDOW_STACK_MODE, values);
}
/*
* Query the width of the given text (16-bit characters, UCS) with given real
* length (amount of glyphs) using the given font.
*
*/
int predict_text_width(const xcb_char2b_t *text, int length) {
xcb_query_text_extents_cookie_t cookie;
xcb_query_text_extents_reply_t *reply;
xcb_generic_error_t *error;
int width;
cookie = xcb_query_text_extents(conn, config.font.id, length, text);
if ((reply = xcb_query_text_extents_reply(conn, cookie, &error)) == NULL) {
ELOG("Could not get text extents (X error code %d)\n",
error->error_code);
/* We return the rather safe guess of 7 pixels, because a
* rendering error is better than a crash. Plus, the user will
* see the error in his log. */
return 7;
}
width = reply->overall_width;
free(reply);
return width;
}
/*
* Configures the given window to have the size/position specified by given rect
*