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

Enhance libi3 and use it in i3bar. 

Abstracted draw_text and predict_text_width into libi3. Use
predict_text_width from libi3 in i3 too. This required tracking
xcb_connection in a xcb_connection_t *conn variable that libi3
expects to be available in i3bar.
This commit is contained in:
Fernando Tarlá Cardoso Lemos 2011-11-13 17:19:42 -02:00 committed by Michael Stapelberg
parent 70151ea238
commit 5c2088c87e
11 changed files with 307 additions and 262 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

4
i3bar/src/workspaces.c
View File

@ -124,8 +124,8 @@ static int workspaces_string_cb(void *params_, const unsigned char *val, unsigne
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,

185
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,75 +99,6 @@ 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
*
@ -181,16 +112,16 @@ void refresh_statusline() {
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);
draw_text((char*)text, glyph_count, true, statusline_pm, statusline_ctx, 0, 0);
FREE(text);
}
@ -242,9 +173,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 +309,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 +396,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 +404,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 +580,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 +709,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 */
@ -869,29 +801,16 @@ 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);
/* Load the font */
font = load_font(fontname, true);
set_font(&font);
DLOG("Calculated Font-height: %d\n", font.height);
/* 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 });
/* Set the font in the gc */
xcb_change_gc(xcb_connection, statusline_ctx, XCB_GC_FONT, (uint32_t[]){ font.id });
xcb_flush(xcb_connection);
@ -936,25 +855,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 +984,6 @@ void clean_xcb() {
FREE(xcb_chk);
FREE(xcb_prep);
FREE(xcb_io);
FREE(font_info);
}
/*
@ -1137,7 +1036,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[3] = { colors.bar_bg, colors.bar_bg, font.id };
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,
@ -1207,8 +1106,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 +1181,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;
@ -1305,7 +1204,7 @@ void reconfig_windows() {
* with which we draw to them) */
walk->bargc = xcb_generate_id(xcb_connection);
mask = XCB_GC_FONT;
values[0] = xcb_font;
values[0] = font.id;
xcb_void_cookie_t gc_cookie = xcb_create_gc_checked(xcb_connection,
walk->bargc,
walk->bar,
@ -1343,9 +1242,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 +1300,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 +1321,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 +1332,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,7 +1366,7 @@ 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,
@ -1477,12 +1376,8 @@ void draw_bars() {
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);
draw_text((char*)ws_walk->ucs2_name, ws_walk->name_glyphs, true,
outputs_walk->buffer, outputs_walk->bargc, i + 5, 2);
i += 10 + ws_walk->name_width;
}

34
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
@ -195,4 +202,27 @@ char *convert_ucs2_to_utf8(xcb_char2b_t *text, size_t num_glyphs);
*/
xcb_char2b_t *convert_utf8_to_ucs2(char *input, int *real_strlen);
/**
* Defines the font to be used for the forthcoming draw_text and
* predict_text_width calls.
*
*/
void set_font(i3Font *font);
/**
* 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);
/**
* 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
*

230
libi3/font.c Normal file
View File

@ -0,0 +1,230 @@
/*
* 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, 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;
}
/*
* 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) {
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;
if (is_ucs2) {
input = text;
}
else {
int real_strlen;
input = (char*)convert_utf8_to_ucs2(text, &real_strlen);
text_len = real_strlen;
}
/* 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 */
static bool first = true;
if (first) {
fprintf(stderr, "Using slow code path for text extents\n");
first = 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 {
int real_strlen;
input = convert_utf8_to_ucs2(text, &real_strlen);
text_len = real_strlen;
}
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;
}

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

2
src/sighandler.c
View File

@ -152,7 +152,7 @@ void handle_signal(int sig, siginfo_t *info, void *data) {
/* calculate width for longest text */
int 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 */

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
*