static void
desktops(int start)
{
char buf[4];
XGlyphInfo extents;
int x, i, curdesk, numdesk;
int cellwidth = 14;
curdesk = get_int_property("_NET_CURRENT_DESKTOP");
numdesk = get_int_property("_NET_NUMBER_OF_DESKTOPS");
if (curdesk < 0 || numdesk < 0)
return;
for (i=0, x=start; i<numdesk; i++, x+=cellwidth) {
sprintf(buf, "%d", i+1);
if (i == curdesk) {
XftDrawRect(xftd, &white, x, 0, cellwidth, BARHEIGHT);
XftTextExtentsUtf8(d, xftfont, (const FcChar8 *)buf, strlen(buf), &extents);
XftDrawStringUtf8(xftd, &black, xftfont, x + (cellwidth - extents.xOff) / 2, 2 + xftfont->ascent, (const FcChar8 *)buf, strlen(buf));
} else {
XftDrawRect(xftd, &black, x, 0, cellwidth, BARHEIGHT);
XftTextExtentsUtf8(d, xftfont, (const FcChar8 *)buf, strlen(buf), &extents);
XftDrawStringUtf8(xftd, &white, xftfont, x + (cellwidth - extents.xOff) / 2, 2 + xftfont->ascent, (const FcChar8 *)buf, strlen(buf));
}
}
}
static void draw_text(Client *c, XftFont *fnt, int fill, int tcol, int scol,
int x, int y, const char *str)
{
XSetForeground(dpy, gc, fill);
XFillRectangle (dpy, c->frame, gc, x-5, 0, c->w, config.title_height);
set_xcolor(scol, 0xFFFF);
XftDrawStringUtf8(c->draw, &xcolor, fnt, x, y, (XftChar8 *)str, strlen(str));
set_xcolor(tcol, 0xFFFF);
XftDrawStringUtf8(c->draw, &xcolor, fnt, x-1, y-1, (XftChar8 *)str, strlen(str));
}
void XImlib2Caption::updateText()
{
XDesktopContainer * xContainer =
dynamic_cast<XDesktopContainer *>(AbstractImage::container);
XftDrawChange(fontDrawHandle, pixmap);
if (shadowOn)
XftDrawStringUtf8( fontDrawHandle, &shadowFontColor, font, FONTSHIFT/2 + shadowX, font->ascent + shadowY, (XftChar8*)text.c_str(), text.length() );
XftDrawStringUtf8(fontDrawHandle, &fontColor, font, FONTSHIFT/2, font->ascent, (XftChar8*)text.c_str(), text.length() );
}
/*----------------------------------------------------------------------------*/
void VKDrawFontDialog()
{
static char *titles[2] = {"Select interface font", "Chọn font giao dien"};
static char *mesages[] = {"Press a key group:", "Nhấn một nhóm phím:"};
char *S = mesages[vk_interface];
char *T = titles[vk_interface];
int i, fa = vk_text_ascent;
#ifdef USE_XFT
XftDraw *draw;
draw = XftDrawCreate(display, fnt.window, visual, colormap);
#else
#define draw
#endif
XClearWindow(display, fnt.window);
VKSetColor(display, fnt.gc, clBackground);
XFillRectangle(display, fnt.window, fnt.gc, 0, 0, fnt.width, fnt.height);
VKSetColor(display, fnt.gc, clBorder);
XDrawRectangle(display, fnt.window, fnt.gc, 1, 1, fnt.width-3, fnt.height-3);
XFillRectangle(display, fnt.window, fnt.gc, 1, 1, fnt.width-3, vk_text_height+6);
XDrawLine(display, fnt.window, fnt.gc, 1, fnt.ly, fnt.width-3, fnt.ly);
for( i=0; i<3; i++ ) {
VKDrawLabel((VKLabel *)fc[i]);
}
#ifdef USE_XFT
XftDrawStringUtf8(draw, &clBlack, vk_font,
11, fa+5+1, (XftChar8*)T, strlen(T));
XftDrawStringUtf8(draw, &clWhite, vk_font,
10, fa+5, (XftChar8*)T, strlen(T));
XftDrawStringUtf8(draw, &clGray, vk_font,
fnt.tx+1, fnt.ty+1, (XftChar8*)S, strlen(S));
XftDrawStringUtf8(draw, &clBlack, vk_font,
fnt.tx, fnt.ty, (XftChar8*)S, strlen(S));
XftDrawDestroy(draw);
#else
#undef draw
VKSetColor(display, fnt.gc, clBlack);
XmbDrawString(display, fnt.window, vk_fontset, fnt.gc,
11, fa+5+1, T, strlen(T));
VKSetColor(display, fnt.gc, clWhite);
XmbDrawString(display, fnt.window, vk_fontset, fnt.gc,
10, fa+5, T, strlen(T));
VKSetColor(display, fnt.gc, clGray);
XmbDrawString(display, fnt.window, vk_fontset, fnt.gc,
fnt.tx+1, fnt.ty+1, S, strlen(S));
VKSetColor(display, fnt.gc, clBlack);
XmbDrawString(display, fnt.window, vk_fontset, fnt.gc,
fnt.tx, fnt.ty, S, strlen(S));
#endif
}
/* render text
position - 0 left, 1-center
*/
static void draw_str( Widget w, int clear_area, enum CLABEL n )
{
CtrlWidget cw = (CtrlWidget)w;
CtrlPart *c = & cw->ctrl;
Display *dpy = XtDisplay(w);
clabel_t *cl = c->clabel + n;
char *s;
Dimension x,y;
TF();
if( ! cl->width || ! cl->height ) return;
if( clear_area ) {
TRACE(2, "%s %d", cw->core.name, c->msg.state );
XFillRectangle( XtDisplay(w), XtWindow(w), c->gc[c->msg.state],
cl->x, cl->y, cl->width, cl->height );
}
s = cl->str;
if( IsEmpty(s) ) return;
x = cl->x;
y = cl->y + cl->font->ascent;
if( cl->position == 1 ) // center label
{
XftTextExtentsUtf8(dpy, cl->font, (FcChar8*)s,
strlen(s), & cl->extents );
x+=(cl->width - cl->extents.xOff) / 2;
calc_str_position( cl );
TRACE(2, "%s (%u %u) (%u %u)", cw->core.name,
cl->x, cl->y,
cl->str_x, cl->str_y );
XftDrawStringUtf8(c->draw, c->col+c->msg.state, cl->font,
cl->x + cl->str_x,
cl->y + cl->str_y,
(FcChar8*)s,strlen(s) );
return;
}
XftDrawStringUtf8(c->draw, c->col+c->msg.state, cl->font, x,y,
(FcChar8*)s,strlen(s) );
}
static int
drawstring(char *str, int x, int flushright)
{
XGlyphInfo extents;
int erasemore = 10;
XftTextExtentsUtf8(d, xftfont, (const FcChar8 *)str, strlen(str), &extents);
if (flushright) {
XftDrawRect(xftd, &black, x - extents.xOff - erasemore, 0, extents.xOff + erasemore, BARHEIGHT);
XftDrawStringUtf8(xftd, &white, xftfont, x - extents.xOff, 1 + xftfont->ascent, (const FcChar8 *)str, strlen(str));
} else {
XftDrawRect(xftd, &black, x, 0, extents.xOff + erasemore, BARHEIGHT);
XftDrawStringUtf8(xftd, &white, xftfont, x, 1 + xftfont->ascent, (const FcChar8 *)str, strlen(str));
}
return extents.xOff;
}
int win_draw_text(win_t *win, XftDraw *d, const XftColor *color, int x, int y,
char *text, int len, int w)
{
int err, tw = 0;
char *t, *next;
uint32_t rune;
XftFont *f;
FcCharSet *fccharset;
XGlyphInfo ext;
for (t = text; t - text < len; t = next) {
next = utf8_decode(t, &rune, &err);
if (XftCharExists(win->env.dpy, font, rune)) {
f = font;
} else { /* fallback font */
fccharset = FcCharSetCreate();
FcCharSetAddChar(fccharset, rune);
f = XftFontOpen(win->env.dpy, win->env.scr, FC_CHARSET, FcTypeCharSet,
fccharset, FC_SCALABLE, FcTypeBool, FcTrue,
FC_SIZE, FcTypeDouble, fontsize, NULL);
FcCharSetDestroy(fccharset);
}
XftTextExtentsUtf8(win->env.dpy, f, (XftChar8*)t, next - t, &ext);
tw += ext.xOff;
if (tw <= w) {
XftDrawStringUtf8(d, color, f, x, y, (XftChar8*)t, next - t);
x += ext.xOff;
}
if (f != font)
XftFontClose(win->env.dpy, f);
}
return tw;
}
void
drw_text(Drw *drw, int x, int y, unsigned int w, unsigned int h, const char *text) {
char buf[256];
int i, tx, ty, th, len, olen;
Extnts tex;
XftDraw *d;
if(!drw || !drw->scheme)
return;
XSetForeground(drw->dpy, drw->gc, drw->scheme->bg->rgb);
XFillRectangle(drw->dpy, drw->drawable, drw->gc, x, y, w, h);
if(!text || !drw->font)
return;
olen = strlen(text);
drw_font_getexts(drw, text, olen, &tex);
/* shorten text if necessary */
for(len = MIN(olen, sizeof buf); len && (tex.w > w - tex.h || w < tex.h); len--)
drw_font_getexts(drw, text, len, &tex);
if(!len)
return;
memcpy(buf, text, len);
if(len < olen)
for(i = len; i && i > len - 3; buf[--i] = '.');
th = drw->font->ascent + drw->font->descent;
ty = y + (h / 2) - (th / 2) + drw->font->ascent;
tx = x + (w / 2) - (tex.w / 2);
d = XftDrawCreate(drw->dpy, drw->drawable, DefaultVisual(drw->dpy, drw->screen), DefaultColormap(drw->dpy, drw->screen));
XftDrawStringUtf8(d, &drw->scheme->fg->xftc, drw->font->xfont, tx, ty, (XftChar8 *) buf, len);
XftDrawDestroy(d);
}
static void
draw_text (struct widget_xft_data *data, char *lbl, int inverse)
{
Screen *sc = XtScreen (data->widget);
int screen = XScreenNumberOfScreen (sc);
int y = data->xft_font->ascent;
int x = inverse ? 0 : 2;
char *bp = lbl;
data->xft_draw = XftDrawCreate (XtDisplay (data->widget),
data->p,
DefaultVisual (XtDisplay (data->widget),
screen),
DefaultColormapOfScreen (sc));
XftDrawRect (data->xft_draw,
inverse ? &data->xft_fg : &data->xft_bg,
0, 0, data->p_width, data->p_height);
if (!inverse) y += 2;
while (bp && *bp != '\0')
{
char *cp = strchr (bp, '\n');
XftDrawStringUtf8 (data->xft_draw,
inverse ? &data->xft_bg : &data->xft_fg,
data->xft_font, x, y,
(FcChar8 *) bp,
cp ? cp - bp : strlen (bp));
bp = cp ? cp + 1 : NULL;
/* 1.2 gives reasonable line spacing. */
y += data->xft_font->height * 1.2;
}
}
/** Draw a string in a Drawable
* \param d Drawable
* \param x X position
* \param y Y position
* \param fg Foreground text color
* \param pad Text padding
* \param str String that will be draw
*/
void
draw_image_ofset_text(Drawable d, int x, int y, char* fg, char *str, int x_image_ofset, int y_image_ofset)
{
XftColor xftcolor;
XftDraw *xftd;
#ifdef HAVE_IMLIB
char *ostr = NULL;
int i, ni, sw = 0;
ImageAttr im[128];
size_t textlen;
#else
(void)x_image_ofset;
(void)y_image_ofset;
#endif /* HAVE_IMLIB */
if(!str)
return;
/* To draw image everywhere we can draw text */
#ifdef HAVE_IMLIB
ostr = xstrdup(str);
textlen = strlen(ostr);
if(strstr(str, "i["))
{
ni = parse_image_block(im, str);
if(infobar[conf.systray.screen].bar && d == infobar[conf.systray.screen].bar->dr)
sw = systray_get_width();
for(i = 0; i < ni; ++i)
draw_image(d, x_image_ofset + im[i].x - sw, y_image_ofset + im[i].y, im[i].w, im[i].h, im[i].name);
}
#endif /* HAVE_IMLIB */
/* Transform X Drawable -> Xft Drawable */
xftd = XftDrawCreate(dpy, d, DefaultVisual(dpy, SCREEN), DefaultColormap(dpy, SCREEN));
/* Alloc text color */
XftColorAllocName(dpy, DefaultVisual(dpy, SCREEN),
DefaultColormap(dpy, SCREEN), fg, &xftcolor);
XftDrawStringUtf8(xftd, &xftcolor, font, x, y, (FcChar8 *)str, strlen(str));
/* Free the text color and XftDraw */
XftColorFree(dpy, DefaultVisual(dpy, SCREEN), DefaultColormap(dpy, SCREEN), &xftcolor);
XftDrawDestroy(xftd);
#ifdef HAVE_IMLIB
if(strstr(ostr, "i["))
strncpy(str, ostr, textlen);
free(ostr);
#endif /* HAVE_IMLIB */
return;
}
//=========================================
// setText
//-----------------------------------------
XImage* setText (Display* dpy,int screen,char* text, int* x, int* y) {
Window root = RootWindow ( dpy,screen );
int DWidth = DisplayWidth ( dpy,screen );
int DHeight = DisplayHeight ( dpy,screen );
XftPattern *pattern = NULL;
XftFont* FTfont = NULL;
XftDraw* FTdraw = NULL;
XftColor* FTcolor = NULL;
XImage* Image = NULL;
XGlyphInfo FTinfo;
XColor color;
XGCValues values;
int XTwidth;
int XTheight;
int x1,y1;
pattern = XftNameParse (XFTFONT);
pattern = XftFontMatch (dpy,screen,pattern,NULL);
FTfont = XftFontOpenPattern (dpy, pattern);
XftTextExtentsUtf8 (
dpy,FTfont,text,strlen(text),&FTinfo
);
XTwidth = FTinfo.xOff;
XTheight= FTfont->height + 20;
FTdraw = XftDrawCreate (
dpy, root, DefaultVisual(dpy,screen),DefaultColormap(dpy,screen)
);
FTcolor = (XftColor*)malloc(sizeof(XftColor));
color.red = 255 << 8;
color.green = 255 << 8;
color.blue = 255 << 8;
XAllocColor (dpy,DefaultColormap(dpy,screen),&color);
XSetForeground(dpy,DefaultGC (dpy,screen),color.pixel);
XGetGCValues (
dpy, DefaultGC (dpy,screen),
GCForeground | GCBackground, &values
);
FTcolor->color.red = color.red;
FTcolor->color.green = color.green;
FTcolor->color.blue = color.blue;
FTcolor->color.alpha = 0xffff;
x1 = (int)((DWidth / 2) - (XTwidth / 2));
y1 = (int)((DHeight / 2) - (XTheight / 2));
XftDrawStringUtf8 (
FTdraw, FTcolor,FTfont,x1,y1,text,strlen(text)
);
XFlush (dpy);
y1 = (int)((DHeight / 2) - XTheight);
Image = XGetImage(
dpy,root,x1,y1,XTwidth,XTheight,AllPlanes,XYPixmap
);
*x = x1;
*y = y1;
return (Image);
}
static void
_xft_TextDraw(TextState * ts, int x, int y, const char *text, int len)
{
FontCtxXft *fdc = (FontCtxXft *) ts->fdc;
XftDrawStringUtf8(fdc->xftd, &(fdc->xftc), fdc->font, x, y,
(const XftChar8 *)text, len);
}
static void ui_draw_coordinates()
{
for ( int y = 0; y < 8; ++y ) {
XftChar8 c = '8' - y;
XGlyphInfo extents;
XftTextExtentsUtf8(ui_display, ui_coordfont, &c, 1, &extents);
int xPos = ui_board_pos_x + (4 * UI_SIZE_SQUARE_WIDTH) / 100;
int yPos = UI_POS_BOARD_Y + (UI_SIZE_SQUARE_HEIGHT * y) +
extents.height + (4 * UI_SIZE_SQUARE_WIDTH) / 100;
XftColor* color = NULL;
if ( y % 2 == 0 ) {
color = &ui_squarecolorblack;
} else {
color = &ui_squarecolorwhite;
}
XftDrawStringUtf8(ui_xftdraw, color, ui_coordfont, xPos, yPos, &c, 1);
}
for ( int x = 0; x < 8; ++x ) {
XftChar8 c = 'a' + x;
XGlyphInfo extents;
XftTextExtentsUtf8(ui_display, ui_coordfont, &c, 1, &extents);
int xPos = ui_board_pos_x + (UI_SIZE_SQUARE_WIDTH * (x + 1)) -
extents.width;// - (4 * UI_SIZE_SQUARE_WIDTH) / 100;
int yPos = UI_POS_BOARD_Y + (UI_SIZE_SQUARE_HEIGHT * 8) -
(60 * extents.height) / 100;
XftColor* color = NULL;
if ( x % 2 == 0 ) {
color = &ui_squarecolorwhite;
} else {
color = &ui_squarecolorblack;
}
XftDrawStringUtf8(ui_xftdraw, color, ui_coordfont, xPos, yPos, &c, 1);
}
}
static inline void
draw_string(Display *xdisplay, XftDraw *draw, XftFont *font, XftColor *colour,
const gchar *text, gint *pos_y)
{
XGlyphInfo extents;
gint len = strlen(text);
XftTextExtentsUtf8(xdisplay, font, (guchar *)text, len, &extents);
XftDrawStringUtf8(draw, colour, font, 4, *pos_y + extents.y, (guchar *)text, len);
*pos_y += extents.height + 4;
}
/* 繪出Utf8字元 */
static unsigned int Draw_Utf8_Char(winlist_t *win, XftFont *font, int foreground_idx, int background_idx, int x, int y, char *Utf8Char, int Utf8len)
{
unsigned int width = Utf8_Char_Escapement(win->draw, font, Utf8Char, Utf8len);
if (background_idx >= 0 && background_idx <= MAX_COLORS)
{
XftDrawRect(win->draw, &gui->colors[background_idx], x, y - win->font_size+1, width, win->font_size);
}
XftDrawStringUtf8(win->draw, &gui->colors[foreground_idx], font, x, y, (FcChar8 *)Utf8Char, Utf8len);
return width;
}
void ShowGeometry::update(int x, int y)
{
char string[20];
sprintf(string, "%d %d", x, y);
int width = getTextWidth(string, strlen(string)) + 8;
#ifdef CONFIG_USE_XFT
int height = m_font->ascent + m_font->descent + 8;
#else
int height = m_font[screen()]->ascent + m_font[screen()]->descent + 8;
#endif
int mx = DisplayWidth (display(), screen()) - 1;
int my = DisplayHeight(display(), screen()) - 1;
XMoveResizeWindow(display(), m_window[screen()],
#if CONFIG_GEOMETRY_X_POS < 0
0
#elif CONFIG_GEOMETRY_X_POS > 0
(mx - width)
#else
(mx - width) / 2
#endif
,
#if CONFIG_GEOMETRY_X_POS < 0
0
#elif CONFIG_GEOMETRY_X_POS > 0
(my - height)
#else
(my - height) / 2
#endif
, width, height);
XClearWindow(display(), m_window[screen()]);
XMapRaised(display(), m_window[screen()]);
#ifdef CONFIG_USE_XFT
XftDrawStringUtf8(m_xftDraw[screen()],
&m_xftColour[screen()],
m_font,
4,
4 + m_font->ascent,
(FcChar8 *)string,
strlen(string));
#else
XDrawString(display(), m_window[screen()],
Border::drawGC(m_windowManager,screen()),
4, 4 + m_font[screen()]->ascent, string, strlen(string));
#endif
}
SE_UNUSED void se_draw_char_utf8( se_text_xviewer* viewer, XftColor* color,
se_cursor cur, int c )
{
assert( viewer && viewer->xftDraw );
const se_env* env = viewer->env;
se_position cur_pos = se_text_cursor_to_physical(viewer, cur);
se_position start_pos = {
cur_pos.x,
cur_pos.y + env->glyphAscent,
};
XftDrawStringUtf8( viewer->xftDraw, color, viewer->env->xftFont,
start_pos.x, start_pos.y, (const XftChar8*)&c, 1 );
}
static void se_draw_text_utf8( se_text_xviewer* viewer, XftColor* color,
se_cursor cur, const char* utf8, int utf8_len )
{
assert( viewer && viewer->xftDraw );
const se_env* env = viewer->env;
se_position cur_pos = se_text_cursor_to_physical(viewer, cur);
se_position start_pos = {
cur_pos.x,
cur_pos.y + env->glyphAscent,
};
/* se_debug( "utf8: %s, utf8_len: %d", utf8, utf8_len ); */
XftDrawStringUtf8( viewer->xftDraw, color, viewer->env->xftFont,
start_pos.x, start_pos.y,
(const XftChar8*)utf8, utf8_len );
}
void
gui_draw_text_length(struct gui_instance *gi, struct gui_font *font,
int x, int y, const char *text, size_t length,
unsigned int color)
{
XftColor xft_color;
xft_color.pixel = color | 0xff000000;
xft_color.color.red = (color >> 16) * 0x0101;
xft_color.color.green = ((color >> 8) & 0xff) * 0x0101;
xft_color.color.blue = (color & 0xff) * 0x0101;
xft_color.color.alpha = 0xffff;
XftDrawStringUtf8(gi->fontdraw, &xft_color, font->xft_font,
x, y + font->xft_font->ascent,
(const unsigned char *) text, length);
}
void
drawtextn(DC *dc, const char *text, size_t n, ColorSet *col) {
int x = dc->x + dc->font.height/2;
int y = dc->y + dc->font.ascent+1;
XSetForeground(dc->dpy, dc->gc, col->FG);
if(dc->font.xft_font) {
if (!dc->xftdraw)
eprintf("error, xft drawable does not exist");
XftDrawStringUtf8(dc->xftdraw, &col->FG_xft,
dc->font.xft_font, x, y, (unsigned char*)text, n);
} else if(dc->font.set) {
XmbDrawString(dc->dpy, dc->canvas, dc->font.set, dc->gc, x, y, text, n);
} else {
XSetFont(dc->dpy, dc->gc, dc->font.xfont->fid);
XDrawString(dc->dpy, dc->canvas, dc->gc, x, y, text, n);
}
}
static void ui_draw_string( const char* str, XftFont* font, XftColor* color, int x, int y, int maxwidth, int* width)
{
XftChar16 dotch = 0x2026; // unicode ... character
/* get width of three dots */
XGlyphInfo extents;
XftTextExtents16(ui_display, font, &dotch, 1, &extents);
int sizepoints = extents.width;
size_t cutlen = 0;
XftTextExtentsUtf8(ui_display, font, (XftChar8*) str, strlen(str), &extents);
int totlen = extents.width;
while (totlen > maxwidth && cutlen < strlen(str)) {
++cutlen;
XftTextExtentsUtf8(ui_display, font, (XftChar8*) str, strlen(str) - cutlen, &extents);
totlen = extents.width + sizepoints;
}
if (NULL != width) {
*width = 0;
}
if (totlen <= maxwidth) {
XftDrawStringUtf8(ui_xftdraw, color, font, x, y, (XftChar8*) str, strlen(str) - cutlen);
if (cutlen > 0) {
XftDrawString16(ui_xftdraw, color, font, x + extents.width, y, &dotch, 1);
}
if (NULL != width) {
*width = totlen;
}
}
}
static void
xft_draw (Lisp_Font *f, char *string, size_t length,
Window id, GC gc, Lisp_Color *fg, int x, int y)
{
static XftDraw *draw;
XftColor xft_color;
if (draw == 0)
draw = XftDrawCreate (dpy, id, image_visual, image_cmap);
else
XftDrawChange (draw, id);
xft_color.pixel = fg->pixel;
xft_color.color.red = fg->red;
xft_color.color.green = fg->green;
xft_color.color.blue = fg->blue;
xft_color.color.alpha = fg->alpha;
XftDrawStringUtf8 (draw, &xft_color, f->font,
x, y, (FcChar8 *)string, length);
}
void
gui_draw_text(struct gui_instance *gi, struct gui_font *font,
int x, int y, const char *text, unsigned int color,
int alignment)
{
XftColor xft_color;
size_t length;
length = strlen(text);
if(alignment)
x -= gui_text_width(font, text, length) * alignment / 2;
xft_color.pixel = color | 0xff000000;
xft_color.color.red = (color >> 16) * 0x0101;
xft_color.color.green = ((color >> 8) & 0xff) * 0x0101;
xft_color.color.blue = (color & 0xff) * 0x0101;
xft_color.color.alpha = 0xffff;
XftDrawStringUtf8(gi->fontdraw, &xft_color, font->xft_font,
x, y + font->xft_font->ascent,
(const unsigned char *) text, length);
}
static void debrush_do_draw_string_default_xft(
DEBrush *brush,
int x, int y, const char *str,
int len, bool needfill,
DEColourGroup *colours)
{
Window win = brush->win;
GC gc=brush->d->normal_gc;
XftDraw *draw;
XftFont *font;
if(brush->d->font==NULL)
return;
font=brush->d->font->font;
draw=debrush_get_draw(brush, win);
if(needfill){
XGlyphInfo extents;
if(ioncore_g.enc_utf8){
XftTextExtentsUtf8(ioncore_g.dpy, font, (XftChar8*)str, len,
&extents);
}else{
XftTextExtents8(ioncore_g.dpy, font, (XftChar8*)str, len, &extents);
}
XftDrawRect(draw, &(colours->bg), x-extents.x, y-extents.y,
extents.width+10, extents.height);
}
if(ioncore_g.enc_utf8){
XftDrawStringUtf8(draw, &(colours->fg), font, x, y, (XftChar8*)str,
len);
}else{
XftDrawString8(draw, &(colours->fg), font, x, y, (XftChar8*)str, len);
}
}
void redraw_frame(client_t *c)
{
int x, y;
if (c && c->decor) {
XClearWindow(dpy, c->frame);
if (!c->shaded) XDrawLine(dpy, c->frame, border_gc,
0, frame_height(c) - BW(c) + BW(c)/2,
c->geom.w, frame_height(c) - BW(c) + BW(c)/2);
XDrawLine(dpy, c->frame, border_gc,
c->geom.w - frame_height(c) + BW(c)/2, 0,
c->geom.w - frame_height(c) + BW(c)/2, frame_height(c));
if (!c->trans && c->name) {
x = opt_pad + DESCENT/2;
y = opt_pad + ASCENT;
#ifdef XFT
#ifdef X_HAVE_UTF8_STRING
XftDrawStringUtf8(c->xftdraw, &xft_fg, xftfont, x, y,
(unsigned char *)c->name, strlen(c->name));
#else
XftDrawString8(c->xftdraw, &xft_fg, xftfont, x, y,
(unsigned char *)c->name, strlen(c->name));
#endif
#else
#ifdef X_HAVE_UTF8_STRING
Xutf8DrawString(dpy, c->frame, font_set, string_gc, x, y,
c->name, strlen(c->name));
#else
XDrawString(dpy, c->frame, string_gc, x, y,
c->name, strlen(c->name));
#endif
#endif
}
}
}
void Thumbnail::redraw()
{
int borderWidth = Settings::instance()->borderWidth();
int headerHeight = Resources::instance()->headerMiddle()->height();
int headerLeftWidth = Resources::instance()->headerLeft()->width();
int headerRightWidth = Resources::instance()->headerRight()->width();
int w = _clientScaledWidth;
int h = _clientScaledHeight;
bool selected = (!Settings::instance()->disableSelection())
&& this == _teleWindow->activeThumbnail();
const XRenderColor *borderColor = selected ?
Resources::instance()->borderActiveColor() :
Resources::instance()->borderColor();
Picture left = selected ?
Resources::instance()->headerLeftSelected()->picture() :
Resources::instance()->headerLeft()->picture();
Picture right = selected ?
Resources::instance()->headerRightSelected()->picture() :
Resources::instance()->headerRight()->picture();
Picture middle = selected ?
Resources::instance()->headerMiddleSelected()->picture() :
Resources::instance()->headerMiddle()->picture();
XRenderComposite(_dpy, PictOpSrc,
left, None, _image->picture(),
0, 0,
0, 0,
_clientOffsetX - borderWidth,
_clientOffsetY - headerHeight,
headerLeftWidth, headerHeight
);
XRenderComposite(_dpy, PictOpSrc,
right, None, _image->picture(),
0, 0,
0, 0,
_clientOffsetX + w + borderWidth - headerRightWidth,
_clientOffsetY - headerHeight,
headerRightWidth, headerHeight
);
XRenderComposite(_dpy, PictOpSrc,
middle, None, _image->picture(),
0, 0,
0, 0,
_clientOffsetX - borderWidth + headerLeftWidth,
_clientOffsetY - headerHeight,
w + 2 * borderWidth - headerLeftWidth - headerRightWidth,
headerHeight
);
// Left border
XRenderFillRectangle(_dpy, PictOpSrc, _image->picture(), borderColor,
_clientOffsetX - borderWidth,
_clientOffsetY,
borderWidth, h
);
// Right border
XRenderFillRectangle(_dpy, PictOpSrc, _image->picture(), borderColor,
_clientOffsetX + w,
_clientOffsetY,
borderWidth, h
);
// Bottom border
XRenderFillRectangle(_dpy, PictOpSrc, _image->picture(), borderColor,
_clientOffsetX - borderWidth,
_clientOffsetY + h,
w + 2*borderWidth, borderWidth
);
// Drawing title text
XftColor fontColor;
fontColor.pixel = 0;
fontColor.color.red = 0xffff;
fontColor.color.green = 0xffff;
fontColor.color.blue = 0xffff;
fontColor.color.alpha = 0xffff;
XRectangle rect = {
_clientOffsetX - borderWidth + Settings::instance()->textLeftMargin(),
_clientOffsetY - headerHeight,
_clientScaledWidth + 2*borderWidth - Settings::instance()->textLeftMargin() - Settings::instance()->textRightMargin(),
headerHeight
};
Region clip = XCreateRegion();
XUnionRectWithRegion(&rect, clip, clip);
XftDrawSetClip(_xftDraw, clip);
XftDrawStringUtf8(_xftDraw, &fontColor, _teleWindow->xftFont(),
_clientOffsetX - borderWidth + Settings::instance()->textLeftMargin(),
_clientOffsetY + Settings::instance()->textYOffset(),
(const FcChar8*)_title,
strlen(_title)
);
XDestroyRegion(clip);
drawPreview();
}
static void setup_font_sample(GtkWidget* darea, Antialiasing antialiasing, Hinting hinting)
{
const char* string1 = "abcfgop AO ";
const char* string2 = "abcfgop";
XftColor black, white;
XRenderColor rendcolor;
Display* xdisplay = gdk_x11_get_default_xdisplay();
#if GTK_CHECK_VERSION (3, 0, 0)
Colormap xcolormap = DefaultColormap(xdisplay, 0);
#else
GdkColormap* colormap = gdk_rgb_get_colormap();
Colormap xcolormap = GDK_COLORMAP_XCOLORMAP(colormap);
#endif
#if GTK_CHECK_VERSION (3, 0, 0)
GdkVisual* visual = gdk_visual_get_system ();
#else
GdkVisual* visual = gdk_colormap_get_visual(colormap);
#endif
Visual* xvisual = GDK_VISUAL_XVISUAL(visual);
FcPattern* pattern;
XftFont* font1;
XftFont* font2;
XGlyphInfo extents1 = { 0 };
XGlyphInfo extents2 = { 0 };
#if !GTK_CHECK_VERSION (3, 0, 0)
GdkPixmap* pixmap;
#endif
XftDraw* draw;
GdkPixbuf* tmp_pixbuf;
GdkPixbuf* pixbuf;
int width, height;
int ascent, descent;
pattern = FcPatternBuild (NULL,
FC_FAMILY, FcTypeString, "Serif",
FC_SLANT, FcTypeInteger, FC_SLANT_ROMAN,
FC_SIZE, FcTypeDouble, 18.,
NULL);
font1 = open_pattern (pattern, antialiasing, hinting);
FcPatternDestroy (pattern);
pattern = FcPatternBuild (NULL,
FC_FAMILY, FcTypeString, "Serif",
FC_SLANT, FcTypeInteger, FC_SLANT_ITALIC,
FC_SIZE, FcTypeDouble, 20.,
NULL);
font2 = open_pattern (pattern, antialiasing, hinting);
FcPatternDestroy (pattern);
ascent = 0;
descent = 0;
if (font1)
{
XftTextExtentsUtf8 (xdisplay, font1, (unsigned char*) string1,
strlen (string1), &extents1);
ascent = MAX (ascent, font1->ascent);
descent = MAX (descent, font1->descent);
}
if (font2)
{
XftTextExtentsUtf8 (xdisplay, font2, (unsigned char*) string2, strlen (string2), &extents2);
ascent = MAX (ascent, font2->ascent);
descent = MAX (descent, font2->descent);
}
width = extents1.xOff + extents2.xOff + 4;
height = ascent + descent + 2;
#if !GTK_CHECK_VERSION (3, 0, 0)
pixmap = gdk_pixmap_new (NULL, width, height, visual->depth);
#endif
#if GTK_CHECK_VERSION (3, 0, 0)
draw = XftDrawCreate (xdisplay, GDK_WINDOW_XID (gdk_screen_get_root_window (gdk_screen_get_default ())), xvisual, xcolormap);
#else
draw = XftDrawCreate (xdisplay, GDK_DRAWABLE_XID (pixmap), xvisual, xcolormap);
#endif
rendcolor.red = 0;
rendcolor.green = 0;
rendcolor.blue = 0;
rendcolor.alpha = 0xffff;
XftColorAllocValue(xdisplay, xvisual, xcolormap, &rendcolor, &black);
rendcolor.red = 0xffff;
rendcolor.green = 0xffff;
rendcolor.blue = 0xffff;
rendcolor.alpha = 0xffff;
XftColorAllocValue(xdisplay, xvisual, xcolormap, &rendcolor, &white);
XftDrawRect(draw, &white, 0, 0, width, height);
if (font1)
{
XftDrawStringUtf8(draw, &black, font1, 2, 2 + ascent, (unsigned char*) string1, strlen(string1));
}
if (font2)
{
XftDrawStringUtf8(draw, &black, font2, 2 + extents1.xOff, 2 + ascent, (unsigned char*) string2, strlen(string2));
}
XftDrawDestroy(draw);
if (font1)
{
XftFontClose(xdisplay, font1);
}
if (font2)
{
XftFontClose(xdisplay, font2);
}
#if GTK_CHECK_VERSION (3, 0, 0)
tmp_pixbuf = gdk_pixbuf_new (GDK_COLORSPACE_RGB, TRUE,8, width, height);
#else
tmp_pixbuf = gdk_pixbuf_get_from_drawable(NULL, pixmap, colormap, 0, 0, 0, 0, width, height);
#endif
pixbuf = gdk_pixbuf_scale_simple(tmp_pixbuf, 1 * width, 1 * height, GDK_INTERP_TILES);
#if !GTK_CHECK_VERSION (3, 0, 0)
g_object_unref(pixmap);
#endif
g_object_unref(tmp_pixbuf);
g_object_set_data_full(G_OBJECT(darea), "sample-pixbuf", pixbuf, (GDestroyNotify) g_object_unref);
#if GTK_CHECK_VERSION (3, 0, 0)
gtk_widget_set_size_request (GTK_WIDGET(darea), width + 2, height + 2);
g_signal_connect(darea, "draw", G_CALLBACK(sample_draw), NULL);
#else
g_signal_connect(darea, "size_request", G_CALLBACK(sample_size_request), NULL);
g_signal_connect(darea, "expose_event", G_CALLBACK(sample_expose), NULL);
#endif
}
void draw_string(FcChar8 *s, int x, int y) {
if (x > w * 2 || y > h * 2) return;
XftDrawStringUtf8(draw, &fg, font, x, y,
(FcChar8 *) s, strlen(s));
}
bool x11_draw_blocks(CFG* config, XRESOURCES* xres, TEXTBLOCK** blocks){
unsigned i;
double current_size;
XftFont* font = NULL;
//early exit
if(!blocks || !blocks[0]){
return true;
}
//draw debug blocks if requested
if(config->debug_boxes){
for(i = 0; blocks[i] && blocks[i]->active; i++){
XftDrawRect(xres->drawable, &(xres->debug_color), blocks[i]->layout_x, blocks[i]->layout_y, blocks[i]->extents.width, blocks[i]->extents.height);
}
}
//draw boxes only
if(config->disable_text){
return true;
}
//draw all blocks
for(i = 0; blocks[i] && blocks[i]->active; i++){
//load font
if(!font || (font && current_size != blocks[i]->size)){
if(font){
XftFontClose(xres->display, font);
}
font = XftFontOpen(xres->display, xres->screen,
XFT_FAMILY, XftTypeString, config->font_name,
XFT_PIXEL_SIZE, XftTypeDouble, blocks[i]->size,
NULL
);
current_size = blocks[i]->size;
if(!font){
fprintf(stderr, "Failed to load block font (%s, %d)\n", config->font_name, (int)current_size);
return false;
}
}
//draw text
errlog(config, LOG_DEBUG, "Drawing block %d (%s) at layoutcoords %d|%d size %d\n", i, blocks[i]->text,
blocks[i]->layout_x + blocks[i]->extents.x,
blocks[i]->layout_y + blocks[i]->extents.y,
(int)blocks[i]->size);
XftDrawStringUtf8(xres->drawable,
&(xres->text_color),
font,
blocks[i]->layout_x + blocks[i]->extents.x,
blocks[i]->layout_y + blocks[i]->extents.y,
(FcChar8*)blocks[i]->text,
strlen(blocks[i]->text));
}
//clean up the mess
if(font){
XftFontClose(xres->display, font);
}
return true;
}
void
WMDrawImageString(WMScreen *scr, Drawable d, WMColor *color, WMColor *background,
WMFont *font, int x, int y, char *text, int length)
{
XftColor textColor;
XftColor bgColor;
wassertr(font!=NULL);
textColor.color.red = color->color.red;
textColor.color.green = color->color.green;
textColor.color.blue = color->color.blue;
textColor.color.alpha = color->alpha;;
textColor.pixel = W_PIXEL(color);
bgColor.color.red = background->color.red;
bgColor.color.green = background->color.green;
bgColor.color.blue = background->color.blue;
bgColor.color.alpha = background->alpha;;
bgColor.pixel = W_PIXEL(background);
XftDrawChange(scr->xftdraw, d);
XftDrawRect(scr->xftdraw, &bgColor, x, y,
WMWidthOfString(font, text, length),
font->height);
if (font->screen->useWideChar) {
wchar_t *wtext;
const char *mtext;
int len;
mtext = text;
wtext = (wchar_t *)wmalloc(sizeof(wchar_t)*(length+1));
len = wmbsnrtowcs(wtext, &mtext, length, length);
if (len>0) {
XftDrawString32(scr->xftdraw, &textColor, font->font,
x, y + font->y, (XftChar32*)wtext, len);
} else if (len==-1) {
wwarning(_("Conversion to widechar failed (possible invalid "
"multibyte sequence): '%s':(pos %d)\n"),
text, mtext-text+1);
/* we can draw normal text, or we can draw as much widechar
* text as was already converted until the error. go figure */
/*XftDrawString8(scr->xftdraw, &textColor, font->font,
x, y + font->y, (XftChar8*)text, length);*/
}
wfree(wtext);
} else if (font->screen->useMultiByte) {
XftDrawStringUtf8(scr->xftdraw, &textColor, font->font,
x, y + font->y, (XftChar8*)text, length);
} else {
XftDrawString8(scr->xftdraw, &textColor, font->font,
x, y + font->y, (XftChar8*)text, length);
}
}