BC_Pixmap::~BC_Pixmap()
{
if(use_opaque())
{
#ifdef HAVE_XFT
if(opaque_xft_draw)
XftDrawDestroy((XftDraw*)opaque_xft_draw);
#endif
XFreePixmap(top_level->display, opaque_pixmap);
}
if(use_alpha())
{
XFreeGC(top_level->display, alpha_gc);
#ifdef HAVE_XFT
if(alpha_xft_draw)
XftDrawDestroy((XftDraw*)alpha_xft_draw);
#endif
XFreePixmap(top_level->display, alpha_pixmap);
}
// Have to delete GL objects because pixmaps are deleted during resizes.
#ifdef HAVE_GL
if(BC_WindowBase::get_synchronous() && glx_pixmap)
{
BC_WindowBase::get_synchronous()->delete_pixmap(parent_window,
glx_pixmap, glx_pixmap_context);
}
#endif
}
ImageDraw::~ImageDraw()
{
GuiLock __;
XftDrawDestroy(xftdraw);
XFreePixmap(Xdisplay, dw);
XFreeGC(Xdisplay, gc);
XftDrawDestroy(alpha.xftdraw);
XFreePixmap(Xdisplay, alpha.dw);
XFreeGC(Xdisplay, alpha.gc);
}
void cfg_reinitialize(void) {
int i;
#ifdef USE_XFT
int xft = xftfont ? 1 : 0;
#endif
/* free things from old configuration */
XFreeGC(dpy, gc);
XFreeGC(dpy, igc);
XFreeGC(dpy, bgc);
XFreeGC(dpy, ibgc);
keys_free();
/* read config again */
cfg_read(0);
/* update some things */
p_attr.background_pixel = fg.pixel;
p_attr.border_pixel = ibfg.pixel;
select_root_events();
/* update clients */
for(i = 0; i < cn; i++) {
#ifdef USE_XFT
if(xftfont && !xft)
clients[i]->wlist_draw = XftDrawCreate(dpy, clients[i]->wlist_item, visual, colormap);
if(!xftfont && xft) {
XftDrawDestroy(clients[i]->title_draw);
XftDrawDestroy(clients[i]->wlist_draw);
}
#endif
XDestroyWindow(dpy, clients[i]->button_parent_left);
XDestroyWindow(dpy, clients[i]->button_parent_right);
free((void *) clients[i]->buttons);
clients[i]->flags ^= clients[i]->flags & HAS_BUTTONS;
buttons_create(clients[i]); /* buttons are now on top of the client window */
XRaiseWindow(dpy, clients[i]->window); /* hence this line */
client_update(clients[i]);
client_update_name(clients[i]);
(clients[i] == current) ? client_set_bg(clients[i], bg, fg) : client_set_bg(clients[i], ibg, ifg);
if(clients[i]->flags & IS_TASKBAR)
client_set_layer(clients[i], taskbar_ontop ? TOP : NORMAL);
XUngrabButton(dpy, AnyButton, AnyModifier, clients[i]->parent);
client_grab_buttons(clients[i]);
if(clients[i]->flags & FULLSCREEN && clients[i]->layer <= NORMAL && fullscreen_stacking != FS_NORMAL)
client_update_layer(clients[i], (fullscreen_stacking == FS_ALWAYS_ONTOP) ? NORMAL : TOP);
if(clients[i]->flags & HAS_BORDER)
XSetWindowBorderWidth(dpy, clients[i]->parent, border_width);
ewmh_update_extents(clients[i]);
}
ewmh_update_number_of_desktops();
ewmh_update_geometry();
ewmh_update_strut();
}
void
freemenu(DC *dc, DM *dm){
if(dc->font.xft_font)
XftDrawDestroy(dm->xftdraw);
if(dm->canvas)
XFreePixmap(dc->dpy, dm->canvas);
}
static void
configure_window (struct gui_instance *gi)
{
if (gi->back_buffer)
XRenderFreePicture (GUI_display, gi->back_buffer);
if (gi->fontdraw)
XftDrawDestroy (gi->fontdraw);
if (gi->pmap)
XFreePixmap (GUI_display, gi->pmap);
if (gi->gc)
XFreeGC (GUI_display, gi->gc);
gi->gc = XCreateGC (GUI_display, gi->window, 0, 0);
gi->pmap = XCreatePixmap (GUI_display, gi->window, gi->width, gi->height, GUI_visual_info->depth);
gi->fontdraw = XftDrawCreate (GUI_display, gi->pmap, GUI_visual, DefaultColormap (GUI_display, GUI_screenidx));
gi->back_buffer
= XRenderCreatePicture (GUI_display, gi->pmap, xrenderpictformat, 0, 0);
if (!gi->back_buffer)
errx (EXIT_FAILURE, "Failed to create back buffer for X window (XRenderCreatePicture)");
}
static void
FinishedWithFont(
UnixFtFont *fontPtr)
{
Display *display = fontPtr->display;
int i;
Tk_ErrorHandler handler = Tk_CreateErrorHandler(display, -1, -1, -1, NULL,
(ClientData) NULL);
for (i = 0; i < fontPtr->nfaces; i++) {
if (fontPtr->faces[i].ftFont) {
XftFontClose(fontPtr->display, fontPtr->faces[i].ftFont);
}
if (fontPtr->faces[i].charset) {
FcCharSetDestroy(fontPtr->faces[i].charset);
}
}
if (fontPtr->faces) {
ckfree((char *)fontPtr->faces);
}
if (fontPtr->pattern) {
FcPatternDestroy(fontPtr->pattern);
}
if (fontPtr->ftDraw) {
XftDrawDestroy(fontPtr->ftDraw);
}
if (fontPtr->font.fid) {
XUnloadFont(fontPtr->display, fontPtr->font.fid);
}
if (fontPtr->fontset) {
FcFontSetDestroy(fontPtr->fontset);
}
Tk_DeleteErrorHandler(handler);
}
void
tooltip_destroy(Tooltip *tt)
{
if(tt->text)
free(tt->text);
if(tt->font)
XftFontClose(tt->mainwin->dpy, tt->font);
if(tt->draw)
XftDrawDestroy(tt->draw);
if(tt->color.pixel != None)
XftColorFree(tt->mainwin->dpy,
tt->mainwin->visual,
tt->mainwin->colormap,
&tt->color);
if(tt->background.pixel != None)
XftColorFree(tt->mainwin->dpy,
tt->mainwin->visual,
tt->mainwin->colormap,
&tt->background);
if(tt->border.pixel != None)
XftColorFree(tt->mainwin->dpy,
tt->mainwin->visual,
tt->mainwin->colormap,
&tt->border);
if(tt->shadow.pixel != None)
XftColorFree(tt->mainwin->dpy,
tt->mainwin->visual,
tt->mainwin->colormap,
&tt->shadow);
if(tt->window != None)
XDestroyWindow(tt->mainwin->dpy, tt->window);
free(tt);
}
void
xaw_destroy_instance (widget_instance *instance)
{
#ifdef HAVE_XFT
if (instance->xft_data)
{
int i;
for (i = 0; i < instance->nr_xft_data; ++i)
{
if (instance->xft_data[i].xft_draw)
XftDrawDestroy (instance->xft_data[i].xft_draw);
if (instance->xft_data[i].p != None)
{
XtVaSetValues (instance->xft_data[i].widget, XtNbitmap, None,
NULL);
XFreePixmap (XtDisplay (instance->widget),
instance->xft_data[i].p);
}
}
if (instance->xft_data[0].xft_font)
XftFontClose (XtDisplay (instance->widget),
instance->xft_data[0].xft_font);
xfree (instance->xft_data);
}
#endif
if (XtIsSubclass (instance->widget, dialogWidgetClass))
/* Need to destroy the Shell too. */
XtDestroyWidget (XtParent (instance->widget));
else
XtDestroyWidget (instance->widget);
}
void
_xft_FdcFini(TextState * ts)
{
FontCtxXft *fdc = (FontCtxXft *) ts->fdc;
XftDrawDestroy(fdc->xftd);
}
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);
}
void
x11_draw_glyphs( Drawable drawable,
GC gc,
PangoFont *font,
int x,
int y,
PangoGlyphString *glyphs,
wxColour &colour )
{
if (PANGO_XFT_IS_FONT (font))
{
Display* xdisplay = wxGlobalDisplay();
int xscreen = DefaultScreen( xdisplay );
Visual* xvisual = DefaultVisual( xdisplay, xscreen );
Colormap xcolormap = DefaultColormapOfScreen( XScreenOfDisplay( xdisplay, xscreen ) );
XftDraw *draw = XftDrawCreate( xdisplay, drawable, xvisual, xcolormap );
XftColor color;
color.pixel = 0;
color.color.red = colour.Red() << 8;
color.color.green = colour.Green() << 8;
color.color.blue = colour.Blue() << 8;
color.color.alpha = 65000;
pango_xft_render( draw, &color, font, glyphs, x, y );
XftDrawDestroy( draw );
}
}
static void InitWindows(xccore_t *xccore)
{
gui_status_init();
gui_root_init();
gui_preedit_init();
gui_select_init();
gui_tray_init();
gui_menu_init();
gui_symbol_init();
gui_keyboard_init();
gui_xcin_init();
gui_msgbox_init();
gui_selectmenu_init();
int isok = gui_restore_window_pos();
winlist_t *win = winlist;
while (win)
{
win->data = (void *)xccore;
if (win->draw)
{
XftDrawDestroy(win->draw);
}
win->draw = XftDrawCreate(gui->display, win->window, gui->visual, gui->colormap);
XSelectInput(gui->display, win->window, (ExposureMask|ButtonPressMask|ButtonReleaseMask|PointerMotionMask|EnterWindowMask|LeaveWindowMask|StructureNotifyMask|KeyPressMask));
MakeDefaultFont(win); /* 建立預設字型 */
XMoveResizeWindow(gui->display, win->window,
win->pos_x, win->pos_y, win->width, win->height);
win = win->next;
}
}
/** 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;
}
void
bfree(Bitmap *b)
{
if (b->fd)
XftDrawDestroy(b->fd);
XFreePixmap(_dpy, (Pixmap)b->id);
free(b);
}
static void
fini()
{
if (pbuf != None) {
XftDrawDestroy(xft);
XFreePixmap(d, pbuf);
}
XCloseDisplay(d);
}
void se_text_xviewer_draw_create( se_text_xviewer* viewer )
{
assert ( viewer->env->xftFont );
if ( viewer->xftDraw ) {
XftDrawDestroy( viewer->xftDraw );
viewer->xftDraw = NULL;
}
viewer->xftDraw = XftDrawCreate(
viewer->env->display, viewer->view, viewer->env->visual,
viewer->env->colormap );
}
/*----------------------------------------------------------------------------*/
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
}
void del_client(client_t *c, int mode)
{
client_t *p;
XGrabServer(dpy);
XSetErrorHandler(ignore_xerror);
#ifdef DEBUG
dump_name(c, "removing", 'r');
dump_removal(c, mode);
#endif
if (mode == DEL_WITHDRAW) {
set_wm_state(c, WithdrawnState);
} else /* mode == DEL_REMAP */ {
if (c->zoomed) {
c->geom.x = c->save.x;
c->geom.y = c->save.y;
c->geom.w = c->save.w;
c->geom.h = c->save.h;
XResizeWindow(dpy, c->win, c->geom.w, c->geom.h);
}
XMapWindow(dpy, c->win);
}
remove_atom(root, net_client_list, XA_WINDOW, c->win);
remove_atom(root, net_client_stack, XA_WINDOW, c->win);
XSetWindowBorderWidth(dpy, c->win, c->old_bw);
#ifdef XFT
if (c->xftdraw)
XftDrawDestroy(c->xftdraw);
#endif
XReparentWindow(dpy, c->win, root, c->geom.x, c->geom.y);
XRemoveFromSaveSet(dpy, c->win);
XDestroyWindow(dpy, c->frame);
if (head == c)
head = c->next;
else for (p = head; p && p->next; p = p->next)
if (p->next == c)
p->next = c->next;
if (c->name) XFree(c->name);
free(c);
XSync(dpy, False);
XSetErrorHandler(handle_xerror);
XUngrabServer(dpy);
}
static void
free_win_content(winlist_t *win)
{
int i;
if ((win->winmode & WMODE_EXIT))
return;
XUnmapWindow(gui->display, win->window);
win->winmode &= ~WMODE_MAP;
XftDrawDestroy(win->draw);
XDestroyWindow(gui->display, win->window);
win->winmode |= WMODE_EXIT;
}
void ReloadXlibMenu(void* arg, boolean enabled)
{
XlibMenu* menu = (XlibMenu*) arg;
boolean visable = WindowIsVisable(menu->owner->dpy, menu->menuWindow);
XFreePixmap(menu->owner->dpy, menu->pixmap);
XDestroyWindow(menu->owner->dpy, menu->menuWindow);
XftDrawDestroy(menu->xftDraw);
menu->pixmap = None;
menu->menuWindow = None;
InitXlibMenu(menu);
if (visable)
XMapWindow(menu->owner->dpy, menu->menuWindow);
}
void Menu::cleanup(WindowManager *const wm)
{
if (m_initialised) { // fix due to Eric Marsden
#ifdef CONFIG_USE_XFT
XftFontClose(wm->display(), m_font);
#endif
for (int i = 0; i < wm->screensTotal(); i++) {
#ifdef CONFIG_USE_XFT
XftDrawDestroy(m_xftDraw[i]);
#else
XFreeFontSet(wm->display(), m_fontset);
#endif
XFreeGC(wm->display(), m_menuGC[i]);
}
}
}
XImlib2Caption::~XImlib2Caption()
{
XDesktopContainer * xContainer =
dynamic_cast<XDesktopContainer *>(AbstractImage::container);
XftColorFree( xContainer->getDisplay(), visual, cmap, &fontColor );
if (shadowOn)
XftColorFree( xContainer->getDisplay(), visual, cmap, &shadowFontColor);
if(gc)
XFreeGC(xContainer->getDisplay(), gc);
XDestroyWindow(xContainer->getDisplay(), window);
XftDrawDestroy(fontDrawHandle);
}
void x11_cleanup(XRESOURCES* xres, CFG* config){
if(!(xres->display)){
return;
}
XftColorFree(xres->display, DefaultVisual(xres->display, xres->screen), DefaultColormap(xres->display, xres->screen), &(xres->text_color));
XftColorFree(xres->display, DefaultVisual(xres->display, xres->screen), DefaultColormap(xres->display, xres->screen), &(xres->bg_color));
XftColorFree(xres->display, DefaultVisual(xres->display, xres->screen), DefaultColormap(xres->display, xres->screen), &(xres->debug_color));
if(xres->drawable){
XftDrawDestroy(xres->drawable);
}
if(config->double_buffer){
XdbeDeallocateBackBufferName(xres->display, xres->back_buffer);
}
XCloseDisplay(xres->display);
xfd_free(&(xres->xfds));
}
void BC_Pixmap::resize(int w, int h)
{
Pixmap new_pixmap = XCreatePixmap(top_level->display,
top_level->win,
w,
h,
top_level->default_depth);
#ifdef HAVE_XFT
XftDraw *new_xft_draw;
if(BC_WindowBase::get_resources()->use_xft)
{
new_xft_draw = XftDrawCreate(top_level->display,
new_pixmap,
top_level->vis,
top_level->cmap);
}
#endif
XCopyArea(top_level->display,
opaque_pixmap,
new_pixmap,
top_level->gc,
0,
0,
get_w(),
get_h(),
0,
0);
this->w = w;
this->h = h;
#ifdef HAVE_XFT
if(BC_WindowBase::get_resources()->use_xft)
XftDrawDestroy((XftDraw*)opaque_xft_draw);
#endif
XFreePixmap(top_level->display, opaque_pixmap);
opaque_pixmap = new_pixmap;
#ifdef HAVE_XFT
if(BC_WindowBase::get_resources()->use_xft)
opaque_xft_draw = new_xft_draw;
#endif
}
static int
xftfont_end_for_frame (struct frame *f)
{
XftDraw *xft_draw;
/* Don't do anything if display is dead */
if (FRAME_X_DISPLAY (f) == NULL) return 0;
xft_draw = font_get_frame_data (f, &xftfont_driver);
if (xft_draw)
{
block_input ();
XftDrawDestroy (xft_draw);
unblock_input ();
font_put_frame_data (f, &xftfont_driver, NULL);
}
return 0;
}
void freedc(DC * dc)
{
if (dc->font.xft_font) {
XftFontClose(dc->dpy, dc->font.xft_font);
XftDrawDestroy(dc->xftdraw);
}
if (dc->font.set)
XFreeFontSet(dc->dpy, dc->font.set);
if (dc->font.xfont)
XFreeFont(dc->dpy, dc->font.xfont);
if (dc->canvas)
XFreePixmap(dc->dpy, dc->canvas);
if (dc->gc)
XFreeGC(dc->dpy, dc->gc);
if (dc->dpy)
XCloseDisplay(dc->dpy);
if (dc)
free(dc);
}
static void ExitXLib()
{
if(sGetSystemFlags() & sISF_2D)
{
XRenderFreePicture(sXDisplay(),XPict);
XftDrawDestroy(XDraw);
for(sInt i=0;i<MAX_COLORS;i++)
XftColorFree(sXDisplay(),sXVisual,sXColMap,&ColorXFT[i]);
for(sInt i=0;i<MAX_CLIPS;i++)
XDestroyRegion(ClipStack[i]);
XDestroyRegion(EmptyRegion);
for(sInt i=0;i<sMP_MAX;i++)
XFreeCursor(sXDisplay(),Cursors[i]);
}
}
static int
xftfont_end_for_frame (FRAME_PTR f)
{
XftDraw *xft_draw;
/* Don't do anything if display is dead */
if (FRAME_X_DISPLAY (f) == NULL) return 0;
xft_draw = font_get_frame_data (f, &xftfont_driver);
if (xft_draw)
{
BLOCK_INPUT;
XftDrawDestroy (xft_draw);
UNBLOCK_INPUT;
font_put_frame_data (f, &xftfont_driver, NULL);
}
return 0;
}
void win_draw_bar(win_t *win)
{
int len, x, y, w, tw;
win_env_t *e;
win_bar_t *l, *r;
XftDraw *d;
const XftColor *bg, *fg;
if ((l = &win->bar.l)->buf == NULL || (r = &win->bar.r)->buf == NULL)
return;
e = &win->env;
y = win->h + font->ascent + V_TEXT_PAD;
w = win->w - 2*H_TEXT_PAD;
d = XftDrawCreate(e->dpy, win->buf.pm, DefaultVisual(e->dpy, e->scr),
DefaultColormap(e->dpy, e->scr));
if (win->fullscreen && !win->light)
bg = &win->bg, fg = &win->fg;
else
bg = &win->fg, fg = &win->bg;
XSetForeground(e->dpy, gc, bg->pixel);
XFillRectangle(e->dpy, win->buf.pm, gc, 0, win->h, win->w, win->bar.h);
XSetForeground(e->dpy, gc, fg->pixel);
XSetBackground(e->dpy, gc, bg->pixel);
if ((len = strlen(r->buf)) > 0) {
if ((tw = TEXTWIDTH(win, r->buf, len)) > w)
return;
x = win->w - tw - H_TEXT_PAD;
w -= tw;
win_draw_text(win, d, fg, x, y, r->buf, len, tw);
}
if ((len = strlen(l->buf)) > 0) {
x = H_TEXT_PAD;
w -= 2 * H_TEXT_PAD; /* gap between left and right parts */
win_draw_text(win, d, fg, x, y, l->buf, len, w);
}
XftDrawDestroy(d);
}
Thumbnail::~Thumbnail()
{
if (_xftDraw)
XftDrawDestroy(_xftDraw);
if (_gc)
XFreeGC(_dpy, _gc);
delete _image;
if (! _clientDestroyed)
{
XSelectInput(_dpy, _clientWindow, 0);
XDamageDestroy(_dpy, _damage);
XRenderFreePicture(_dpy, _clientPict);
}
free(_title);
free(_clientClass);
}
