void
render_init(void)
{
font = XftFontOpen(display, screen,
XFT_FAMILY, XftTypeString, FONT_NAME,
XFT_SIZE, XftTypeInteger, FONT_SIZE,
NULL);
if (!XftColorAllocName(display, XDefaultVisual(display, screen),
DefaultColormap(display, screen), TouchCross, &cross)) {
fprintf(stderr, "Cannot get color");
exit(2);
}
if (!XftColorAllocName(display, XDefaultVisual(display, screen),
DefaultColormap(display, screen), PromptText, &promptColor)) {
fprintf(stderr, "Cannot get color");
exit(2);
}
if (!XftColorAllocName(display, XDefaultVisual(display, screen),
DefaultColormap(display, screen), Background, &bg)) {
fprintf(stderr, "Cannot get bg color");
exit(2);
}
if (!XftColorAllocName(display, XDefaultVisual(display, screen),
DefaultColormap(display, screen), Error, &errorColor)) {
fprintf(stderr, "Cannot get color");
exit(2);
}
draw = XftDrawCreate(display, win, DefaultVisual(display, screen),
DefaultColormap(display, screen));
}
void XImlib2Caption::createFont()
{
XDesktopContainer * xContainer =
dynamic_cast<XDesktopContainer *>(AbstractImage::container);
DesktopIconConfig * dIconConfig =
dynamic_cast<DesktopIconConfig *>(AbstractImage::iconConfig);
font = XftFontOpen( xContainer->getDisplay(),
DefaultScreen( xContainer->getDisplay()),
XFT_FAMILY,
XftTypeString,
dIconConfig->getFont().c_str(),
XFT_SIZE,
XftTypeDouble,
(double)dIconConfig->getFontSize(),
XFT_WEIGHT, XftTypeInteger, boldVal,
NULL );
XColor screen, exact;
if (!XAllocNamedColor (xContainer->getDisplay(), cmap, (char*)dIconConfig->getFontColor().c_str(), &screen, &exact))
cout << "BAD COLORS!!!\n";
XftColorAllocName(xContainer->getDisplay(), visual, cmap,
(char*)dIconConfig->getFontColor().c_str(), &fontColor );
if (shadowOn)
XftColorAllocName(xContainer->getDisplay(), visual, cmap,
(char*)shadowColor.c_str(), &shadowFontColor );
}
// set an Xft font by name
void textbox_font(textbox *tb, char *font, char *fg, char *bg)
{
if (tb->font) XftFontClose(display, tb->font);
tb->font = XftFontOpenName(display, DefaultScreen(display), font);
XftColorAllocName(display, DefaultVisual(display, DefaultScreen(display)), DefaultColormap(display, DefaultScreen(display)), fg, &tb->color_fg);
XftColorAllocName(display, DefaultVisual(display, DefaultScreen(display)), DefaultColormap(display, DefaultScreen(display)), bg, &tb->color_bg);
}
int
createWin(XDataStr *data)
{
u_long attributeMask;
XSetWindowAttributes attribute;
Window w;
Display *display = data->display;
int screen = DefaultScreen(display);
XGCValues gc_val;
Screen *s;
attribute.background_pixel = WhitePixel(display, screen);
attribute.border_pixel = WhitePixel(display, screen);
attribute.bit_gravity = NorthWestGravity;
attribute.event_mask = ButtonPressMask|ButtonReleaseMask|KeyPressMask|
ExposureMask;
attributeMask =
CWBorderPixel |
CWBackPixel |
CWEventMask |
CWBitGravity;
s = ScreenOfDisplay(data->display, screen);
w = XCreateWindow(display, RootWindow(display, screen), 0, 0,
DisplayWidth(display, screen)/2, 150,
0, DefaultDepth(display, screen), InputOutput,
DefaultVisual(display, screen), attributeMask, &attribute);
data->font = XftFontOpen(display, screen,
XFT_FAMILY, XftTypeString, "mono",
XFT_SIZE, XftTypeInteger, 16,
NULL);
if (!XftColorAllocName(display, XDefaultVisual(display, screen),
DefaultColormap(display, screen), "red4", &data->color)) {
fprintf(stderr, "cannot get color");
return -1;
}
if (!XftColorAllocName(display, XDefaultVisual(display, screen),
DefaultColormap(display, screen), "linen", &data->bg)) {
fprintf(stderr, "cannot get bg color");
return -1;
}
data->draw = XftDrawCreate(display, w, DefaultVisual(display, screen),
DefaultColormap(display, screen));
gc_val.foreground = BlackPixel(display, screen);
gc_val.background = WhitePixel(display, screen);
data->gc = XCreateGC (display, w, GCForeground|GCBackground,
&gc_val);
data->win = w;
return 0;
}
void setup() {
XSetWindowAttributes attributes;
XWindowAttributes window_attributes;
Visual *vis;
Colormap cmap;
int ignore;
display = XOpenDisplay(NULL);
screen = DefaultScreen(display);
vis = XDefaultVisual(display, screen);
cmap = DefaultColormap(display, screen);
if (XGetGeometry(display, RootWindow(display, screen), &root,
&ignore, &ignore,
&max_width, &max_height, &ignore, &ignore) == False)
die("Failed to get root Geometry!");
if (!XftColorAllocName(display, vis, cmap, fg_name, &fg))
die("Failed to allocate foreground color");
if (!XftColorAllocName(display, vis, cmap, bg_name, &bg))
die("Failed to allocate background color");
/* Setup and map window */
attributes.border_pixel = fg.pixel;
attributes.background_pixel = bg.pixel;
attributes.override_redirect = True;
attributes.event_mask =
ExposureMask|KeyPressMask|ButtonPressMask|ButtonReleaseMask;
win = XCreateWindow(display, root,
0, 0, 1, 1, BORDER_WIDTH,
DefaultDepth(display, 0),
CopyFromParent, CopyFromParent,
CWBackPixel|CWOverrideRedirect|CWEventMask|CWBorderPixel,
&attributes);
xim = XOpenIM(display, NULL, NULL, NULL);
xic = XCreateIC(xim, XNInputStyle,
XIMPreeditNothing | XIMStatusNothing,
XNClientWindow, win, XNFocusWindow, win, NULL);
gc = XCreateGC(display, win, 0, 0);
buf = XCreatePixmap(display, win, 1, 1,
DefaultDepth(display, screen));
draw = XftDrawCreate(display, buf, vis, cmap);
load_font(font_str);
}
void main (void)
{
Display *dsp = XOpenDisplay (0);
if (dsp)
{
int scr = DefaultScreen (dsp);
Window p = XCreateSimpleWindow (dsp, RootWindow (dsp, scr), 100, 100, 300, 100, 1,
BlackPixel (dsp, scr), WhitePixel (dsp, scr));
XSelectInput (dsp, p, ExposureMask);
XMapWindow (dsp, p);
XftColor xft_color;
XftColorAllocName (dsp, DefaultVisual (dsp, scr), DefaultColormap (dsp, scr), "tan", &xft_color);
XftFont *font = XftFontOpenName (dsp, scr, "sans:bold:pixelsize=18");
XftDraw *draw = XftDrawCreate (dsp, p, DefaultVisual (dsp, scr), DefaultColormap (dsp, scr));
for (;;)
{
char *txt = "Lorem ipsum";
XEvent e;
XNextEvent (dsp, &e);
if (e.type == Expose)
XftDrawString8 (draw, &xft_color, font, 20, 30, (XftChar8*)(txt), strlen(txt));
}
}
}
bool de_alloc_colour(WRootWin *rootwin, DEColour *ret, const char *name)
{
#ifdef HAVE_X11_XFT
if(name==NULL)
return FALSE;
return XftColorAllocName(
ioncore_g.dpy,
XftDEDefaultVisual(),
rootwin->default_cmap,
name,
ret);
#else /* HAVE_X11_XFT */
XColor c;
bool ok=FALSE;
if(name==NULL)
return FALSE;
if(XParseColor(ioncore_g.dpy, rootwin->default_cmap, name, &c)){
ok=XAllocColor(ioncore_g.dpy, rootwin->default_cmap, &c);
if(ok)
*ret=c.pixel;
}
return ok;
#endif /* HAVE_X11_XFT */
}
/** 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 win_alloc_color(const win_env_t *e, const char *name, XftColor *col)
{
if (!XftColorAllocName(e->dpy, DefaultVisual(e->dpy, e->scr),
DefaultColormap(e->dpy, e->scr), name, col))
{
error(EXIT_FAILURE, 0, "Error allocating color '%s'", name);
}
}
ColorSet *
initcolor(DC *dc, const char * foreground, const char * background) {
ColorSet * col = (ColorSet *)malloc(sizeof(ColorSet));
if(!col)
eprintf("error, cannot allocate memory for color set");
col->BG = getcolor(dc, background);
col->FG = getcolor(dc, foreground);
if(dc->font.xft_font)
if(!XftColorAllocName(dc->dpy, DefaultVisual(dc->dpy, DefaultScreen(dc->dpy)),
DefaultColormap(dc->dpy, DefaultScreen(dc->dpy)), foreground, &col->FG_xft))
eprintf("error, cannot allocate xft font color '%s'\n", foreground);
return col;
}
Clr *
drw_clr_create(Drw *drw, const char *clrname)
{
Clr *clr;
clr = ecalloc(1, sizeof(Clr));
if (!XftColorAllocName(drw->dpy, DefaultVisual(drw->dpy, drw->screen),
DefaultColormap(drw->dpy, drw->screen),
clrname, &clr->rgb))
die("error, cannot allocate color '%s'\n", clrname);
clr->pix = clr->rgb.pixel;
return clr;
}
// make a color set (foreground, background)
ColorSet * initcolor(DC * dc, const char * foreground, const char * background) {
ColorSet * col = (ColorSet *)malloc(sizeof(ColorSet));
col->BG = getcolor(dc, background);
col->FG = getcolor(dc, foreground);
if(dc->font.xft_font) {
if(!XftColorAllocName(dc->dpy, DefaultVisual(dc->dpy, DefaultScreen(dc->dpy)),
DefaultColormap(dc->dpy, DefaultScreen(dc->dpy)), foreground, &col->FG_xft)) {
}
}
return col;
}
Clr *
drw_clr_create(Drw *drw, const char *clrname) {
Clr *clr;
XftColor color;
if(!drw)
return NULL;
clr = (Clr *)calloc(1, sizeof(Clr));
if(!clr)
return NULL;
if(!XftColorAllocName(drw->dpy, DefaultVisual(drw->dpy, drw->screen), DefaultColormap(drw->dpy, drw->screen), clrname, &color))
die("error, cannot allocate color '%s'\n", clrname);
clr->xftc = color;
return clr;
}
XftColor *ColorGetXftColor(const char *name)
{
for (int i = 0; i < num_xft_colors; i++) {
if (strcmp(xft_color_table[i].name, name) == 0) {
return &xft_color_table[i].color;
}
}
if (num_xft_colors == MAX_COLORS) {
fprintf(stderr, "color table full");
exit(1);
}
xft_color_table[num_xft_colors].name = GC_STRDUP(name);
XftColorAllocName(disp, visual, colormap, name, &xft_color_table[num_xft_colors].color);
return &xft_color_table[num_xft_colors++].color;
}
Clr * drw_clr_create(Drw *drw, const char *clrname)
{
Clr *clr;
Colormap cmap;
Visual *vis;
if (!drw)
return NULL;
clr = (Clr *)calloc(1, sizeof(Clr));
if (!clr)
return NULL;
cmap = DefaultColormap(drw->dpy, drw->screen);
vis = DefaultVisual(drw->dpy, drw->screen);
if (!XftColorAllocName(drw->dpy, vis, cmap, clrname, &clr->rgb))
die("error, cannot allocate color '%s'\n", clrname);
clr->pix = clr->rgb.pixel;
return clr;
}
static XftColor load_colour(const char* name, const char* fallback)
{
lua_getglobal(L, name);
const char* value = lua_tostring(L, -1);
if (!value)
value = fallback;
XftColor colour;
if (!XftColorAllocName(display,
DefaultVisual(display, DefaultScreen(display)),
DefaultColormap(display, DefaultScreen(display)),
value, &colour))
{
fprintf(stderr, "Error: can't parse colour '%s'.\n", value);
exit(1);
}
return colour;
}
Color
getcolor(DC *dc, const char *colstr, Color defaultc) {
if (!colstr)
return defaultc;
Colormap cmap = DefaultColormap(dc->dpy, screen);
Visual *vis = DefaultVisual(dc->dpy, screen);
XftColor xftcolor;
XColor screenc, dummy;
if(XftColorAllocName(dc->dpy, vis, cmap, colstr, &xftcolor)
&& XAllocNamedColor(dc->dpy, cmap, colstr, &screenc, &dummy))
{
return (Color) {screenc.pixel, xftcolor};
} else {
eprintf("cannot allocate color '%s'\n", colstr);
return defaultc;
}
}
static void gui_init_xft(void)
{
int i;
/* 釋放原有的字型 */
if (gui->xftfonts)
{
for (i=0 ; i < gui->num_fonts ; i++)
{
XftFontClose(gui->display, gui->xftfonts[i]);
}
free(gui->xftfonts);
}
gui->num_fonts = 0;
gui->xftfonts = NULL;
/* 釋放缺字表 */
if (gui->missing_chars)
{
FcCharSetDestroy(gui->missing_chars);
}
gui->missing_chars = FcCharSetCreate();
/* */
for (i = 0 ; i < MAX_COLORS ; i++)
{
XftColorFree(gui->display, gui->visual, gui->colormap, &gui->colors[i]);
XftColorAllocName(gui->display, gui->visual, gui->colormap,
oxim_get_config(colors[i].key_id), &gui->colors[colors[i].color_idx]);
}
/* 紀錄預設字型大小 */
unsigned int default_fontsize = atoi(oxim_get_config(DefaultFontSize));
if (default_fontsize < 12 || default_fontsize > 48)
default_fontsize = 16;
gui->default_fontsize = default_fontsize;
}
/*----------------------------------------------------------------------------*/
void VKLoadPalette()
{
#ifdef USE_XFT
XftColorAllocName(display, visual, colormap, "red", &clRed );
XftColorAllocName(display, visual, colormap, "yellow", &clYellow );
XftColorAllocName(display, visual, colormap, "white", &clWhite );
XftColorAllocName(display, visual, colormap, "black", &clBlack );
XftColorAllocName(display, visual, colormap, "blue", &clBlue );
XftColorAllocName(display, visual, colormap, "gray", &clGray );
XftColorAllocName(display, visual, colormap, "SteelBlue", &clMenuBar );
#else
VKAllocColorName("red", &clRed);
VKAllocColorName("yellow", &clYellow);
VKAllocColorName("white", &clWhite);
VKAllocColorName("black", &clBlack);
VKAllocColorName("blue", &clBlue);
VKAllocColorName("gray", &clGray);
VKAllocColorName("SteelBlue", &clMenuBar);
#endif
}
char *
parse_line(const char *line, int lnr, int align, int reverse, int nodraw) {
/* bitmaps */
unsigned int bm_w, bm_h;
int bm_xh, bm_yh;
/* rectangles, cirlcles*/
int rectw, recth, rectx, recty;
/* positioning */
int n_posx, n_posy, set_posy=0;
int px=0, py=0, opx=0;
int i, next_pos=0, j=0, h=0, tw=0;
/* buffer pos */
const char *linep=NULL;
/* fonts */
int font_was_set=0;
/* position */
int pos_is_fixed = 0;
/* block alignment */
int block_align = -1;
int block_width = -1;
/* clickable area y tracking */
int max_y=-1;
/* temp buffers */
char lbuf[MAX_LINE_LEN], *rbuf = NULL;
/* parser state */
int t=-1, nobg=0;
char *tval=NULL;
/* X stuff */
long lastfg = dzen.norm[ColFG], lastbg = dzen.norm[ColBG];
Fnt *cur_fnt = NULL;
#ifndef DZEN_XFT
XGCValues gcv;
#endif
Drawable pm=0, bm;
#ifdef DZEN_XPM
int free_xpm_attrib = 0;
Pixmap xpm_pm;
XpmAttributes xpma;
XpmColorSymbol xpms;
#endif
#ifdef DZEN_XFT
XftDraw *xftd=NULL;
XftColor xftc;
char *xftcs;
int xftcs_f=0;
char *xftcs_bg;
int xftcs_bgf=0;
xftcs = (char *)dzen.fg;
xftcs_bg = (char *)dzen.bg;
#endif
/* icon cache */
int ip;
/* parse line and return the text without control commands */
if(nodraw) {
rbuf = emalloc(MAX_LINE_LEN);
rbuf[0] = '\0';
if( (lnr + dzen.slave_win.first_line_vis) >= dzen.slave_win.tcnt)
line = NULL;
else
line = dzen.slave_win.tbuf[dzen.slave_win.first_line_vis+lnr];
}
/* parse line and render text */
else {
h = dzen.font.height;
py = (dzen.line_height - h) / 2;
xorig[LNR2WINDOW(lnr)] = 0;
if(lnr != -1) {
pm = XCreatePixmap(dzen.dpy, RootWindow(dzen.dpy, DefaultScreen(dzen.dpy)), dzen.slave_win.width,
dzen.line_height, DefaultDepth(dzen.dpy, dzen.screen));
}
else {
pm = XCreatePixmap(dzen.dpy, RootWindow(dzen.dpy, DefaultScreen(dzen.dpy)), dzen.title_win.width,
dzen.line_height, DefaultDepth(dzen.dpy, dzen.screen));
}
#ifdef DZEN_XFT
xftd = XftDrawCreate(dzen.dpy, pm, DefaultVisual(dzen.dpy, dzen.screen),
DefaultColormap(dzen.dpy, dzen.screen));
#endif
if(!reverse) {
XSetForeground(dzen.dpy, dzen.tgc, dzen.norm[ColBG]);
#ifdef DZEN_XPM
xpms.pixel = dzen.norm[ColBG];
#endif
#ifdef DZEN_XFT
xftcs_bg = (char *)dzen.bg;
xftcs_bgf = 0;
#endif
}
else {
XSetForeground(dzen.dpy, dzen.tgc, dzen.norm[ColFG]);
#ifdef DZEN_XPM
xpms.pixel = dzen.norm[ColFG];
#endif
}
XFillRectangle(dzen.dpy, pm, dzen.tgc, 0, 0, dzen.w, dzen.h);
if(!reverse) {
XSetForeground(dzen.dpy, dzen.tgc, dzen.norm[ColFG]);
}
else {
XSetForeground(dzen.dpy, dzen.tgc, dzen.norm[ColBG]);
}
#ifdef DZEN_XPM
xpms.name = NULL;
xpms.value = (char *)"none";
xpma.colormap = DefaultColormap(dzen.dpy, dzen.screen);
xpma.depth = DefaultDepth(dzen.dpy, dzen.screen);
xpma.visual = DefaultVisual(dzen.dpy, dzen.screen);
xpma.colorsymbols = &xpms;
xpma.numsymbols = 1;
xpma.valuemask = XpmColormap|XpmDepth|XpmVisual|XpmColorSymbols;
#endif
#ifndef DZEN_XFT
if(!dzen.font.set){
gcv.font = dzen.font.xfont->fid;
XChangeGC(dzen.dpy, dzen.tgc, GCFont, &gcv);
}
#endif
cur_fnt = &dzen.font;
if( lnr != -1 && (lnr + dzen.slave_win.first_line_vis >= dzen.slave_win.tcnt)) {
XCopyArea(dzen.dpy, pm, dzen.slave_win.drawable[lnr], dzen.gc,
0, 0, px, dzen.line_height, xorig[LNR2WINDOW(lnr)], 0);
XFreePixmap(dzen.dpy, pm);
return NULL;
}
}
linep = line;
while(1) {
if(*linep == ESC_CHAR || *linep == '\0') {
lbuf[j] = '\0';
/* clear _lock_x at EOL so final width is correct */
if(*linep=='\0')
pos_is_fixed=0;
if(nodraw) {
strcat(rbuf, lbuf);
}
else {
if(t != -1 && tval) {
switch(t) {
case icon:
if(MAX_ICON_CACHE && (ip=search_icon_cache(tval)) != -1) {
int y;
XCopyArea(dzen.dpy, icons[ip].p, pm, dzen.tgc,
0, 0, icons[ip].w, icons[ip].h, px, y=(set_posy ? py :
(dzen.line_height >= (signed)icons[ip].h ?
(dzen.line_height - icons[ip].h)/2 : 0)));
px += !pos_is_fixed ? icons[ip].w : 0;
max_y = MAX(max_y, y+icons[ip].h);
} else {
int y;
if(XReadBitmapFile(dzen.dpy, pm, tval, &bm_w,
&bm_h, &bm, &bm_xh, &bm_yh) == BitmapSuccess
&& (h/2 + px + (signed)bm_w < dzen.w)) {
setcolor(&pm, px, bm_w, lastfg, lastbg, reverse, nobg);
XCopyPlane(dzen.dpy, bm, pm, dzen.tgc,
0, 0, bm_w, bm_h, px, y=(set_posy ? py :
(dzen.line_height >= (int)bm_h ?
(dzen.line_height - (int)bm_h)/2 : 0)), 1);
XFreePixmap(dzen.dpy, bm);
px += !pos_is_fixed ? bm_w : 0;
max_y = MAX(max_y, y+bm_h);
}
#ifdef DZEN_XPM
else if(XpmReadFileToPixmap(dzen.dpy, dzen.title_win.win, tval, &xpm_pm, NULL, &xpma) == XpmSuccess) {
setcolor(&pm, px, xpma.width, lastfg, lastbg, reverse, nobg);
if(MAX_ICON_CACHE)
cache_icon(tval, xpm_pm, xpma.width, xpma.height);
XCopyArea(dzen.dpy, xpm_pm, pm, dzen.tgc,
0, 0, xpma.width, xpma.height, px, y=(set_posy ? py :
(dzen.line_height >= (int)xpma.height ?
(dzen.line_height - (int)xpma.height)/2 : 0)));
px += !pos_is_fixed ? xpma.width : 0;
max_y = MAX(max_y, y+xpma.height);
/* freed by cache_icon() */
//XFreePixmap(dzen.dpy, xpm_pm);
free_xpm_attrib = 1;
}
#endif
}
break;
case rect:
get_rect_vals(tval, &rectw, &recth, &rectx, &recty);
recth = recth > dzen.line_height ? dzen.line_height : recth;
if(set_posy)
py += recty;
recty = recty == 0 ? (dzen.line_height - recth)/2 :
(dzen.line_height - recth)/2 + recty;
px += !pos_is_fixed ? rectx : 0;
setcolor(&pm, px, rectw, lastfg, lastbg, reverse, nobg);
XFillRectangle(dzen.dpy, pm, dzen.tgc, px,
set_posy ? py :
((int)recty < 0 ? dzen.line_height + recty : recty),
rectw, recth);
px += !pos_is_fixed ? rectw : 0;
break;
case recto:
get_rect_vals(tval, &rectw, &recth, &rectx, &recty);
if (!rectw) break;
recth = recth > dzen.line_height ? dzen.line_height-2 : recth-1;
if(set_posy)
py += recty;
recty = recty == 0 ? (dzen.line_height - recth)/2 :
(dzen.line_height - recth)/2 + recty;
px = (rectx == 0) ? px : rectx+px;
/* prevent from stairs effect when rounding recty */
if (!((dzen.line_height - recth) % 2)) recty--;
setcolor(&pm, px, rectw, lastfg, lastbg, reverse, nobg);
XDrawRectangle(dzen.dpy, pm, dzen.tgc, px,
set_posy ? py :
((int)recty<0 ? dzen.line_height + recty : recty), rectw-1, recth);
px += !pos_is_fixed ? rectw : 0;
break;
case circle:
rectx = get_circle_vals(tval, &rectw, &recth);
setcolor(&pm, px, rectw, lastfg, lastbg, reverse, nobg);
XFillArc(dzen.dpy, pm, dzen.tgc, px, set_posy ? py :(dzen.line_height - rectw)/2,
rectw, rectw, 90*64, rectx>1?recth*64:64*360);
px += !pos_is_fixed ? rectw : 0;
break;
case circleo:
rectx = get_circle_vals(tval, &rectw, &recth);
setcolor(&pm, px, rectw, lastfg, lastbg, reverse, nobg);
XDrawArc(dzen.dpy, pm, dzen.tgc, px, set_posy ? py : (dzen.line_height - rectw)/2,
rectw, rectw, 90*64, rectx>1?recth*64:64*360);
px += !pos_is_fixed ? rectw : 0;
break;
case pos:
if(tval[0]) {
int r=0;
r = get_pos_vals(tval, &n_posx, &n_posy);
if( (r == 1 && !set_posy))
set_posy=0;
else if (r == 5) {
switch(n_posx) {
case LOCK_X:
pos_is_fixed = 1;
break;
case UNLOCK_X:
pos_is_fixed = 0;
break;
case LEFT:
px = 0;
break;
case RIGHT:
px = dzen.w;
break;
case CENTER:
px = dzen.w/2;
break;
case BOTTOM:
set_posy = 1;
py = dzen.line_height;
break;
case TOP:
set_posy = 1;
py = 0;
break;
}
} else
set_posy=1;
if(r != 2)
px = px+n_posx<0? 0 : px + n_posx;
if(r != 1)
py += n_posy;
} else {
set_posy = 0;
py = (dzen.line_height - dzen.font.height) / 2;
}
break;
case abspos:
if(tval[0]) {
int r=0;
if( (r=get_pos_vals(tval, &n_posx, &n_posy)) == 1 && !set_posy)
set_posy=0;
else
set_posy=1;
n_posx = n_posx < 0 ? n_posx*-1 : n_posx;
if(r != 2)
px = n_posx;
if(r != 1)
py = n_posy;
} else {
set_posy = 0;
py = (dzen.line_height - dzen.font.height) / 2;
}
break;
case ibg:
nobg = atoi(tval);
break;
case bg:
lastbg = tval[0] ? (unsigned)getcolor(tval) : dzen.norm[ColBG];
#ifdef DZEN_XFT
if(xftcs_bgf) free(xftcs_bg);
if(tval[0]) {
xftcs_bg = estrdup(tval);
xftcs_bgf = 1;
} else {
xftcs_bg = (char *)dzen.bg;
xftcs_bgf = 0;
}
#endif
break;
case fg:
lastfg = tval[0] ? (unsigned)getcolor(tval) : dzen.norm[ColFG];
XSetForeground(dzen.dpy, dzen.tgc, lastfg);
#ifdef DZEN_XFT
if(tval[0]) {
xftcs = estrdup(tval);
xftcs_f = 1;
} else {
xftcs = (char *)dzen.fg;
xftcs_f = 0;
}
#endif
break;
case fn:
if(tval[0]) {
#ifndef DZEN_XFT
if(!strncmp(tval, "dfnt", 4)) {
cur_fnt = &(dzen.fnpl[atoi(tval+4)]);
if(!cur_fnt->set) {
gcv.font = cur_fnt->xfont->fid;
XChangeGC(dzen.dpy, dzen.tgc, GCFont, &gcv);
}
}
else
#endif
setfont(tval);
}
else {
cur_fnt = &dzen.font;
#ifndef DZEN_XFT
if(!cur_fnt->set){
gcv.font = cur_fnt->xfont->fid;
XChangeGC(dzen.dpy, dzen.tgc, GCFont, &gcv);
}
#else
setfont(dzen.fnt ? dzen.fnt : FONT);
#endif
}
py = set_posy ? py : (dzen.line_height - cur_fnt->height) / 2;
font_was_set = 1;
break;
case ca:
{
sens_w *w = &window_sens[LNR2WINDOW(lnr)];
if(tval[0]) {
click_a *area = &((*w).sens_areas[(*w).sens_areas_cnt]);
if((*w).sens_areas_cnt < MAX_CLICKABLE_AREAS) {
get_sens_area(tval,
&(*area).button,
LNR2WINDOW(lnr)*MAX_CLICKABLE_AREAS+(*w).sens_areas_cnt);
(*area).start_x = px;
(*area).start_y = py;
(*area).end_y = py;
max_y = py;
(*area).active = 0;
if(lnr == -1) {
(*area).win = dzen.title_win.win;
} else {
(*area).win = dzen.slave_win.line[lnr];
}
(*w).sens_areas_cnt++;
}
} else {
//find most recent unclosed area
for(i = (*w).sens_areas_cnt - 1; i >= 0; i--)
if(!(*w).sens_areas[i].active)
break;
if(i >= 0 && i < MAX_CLICKABLE_AREAS) {
(*w).sens_areas[i].end_x = px;
(*w).sens_areas[i].end_y = max_y;
(*w).sens_areas[i].active = 1;
}
}
} break;
case ba:
if(tval[0])
get_block_align_vals(tval, &block_align, &block_width);
else
block_align=block_width=-1;
break;
}
free(tval);
}
/* check if text is longer than window's width */
tw = textnw(cur_fnt, lbuf, strlen(lbuf));
while((((tw + px) > (dzen.w)) || (block_align!=-1 && tw>block_width)) && j>=0) {
lbuf[--j] = '\0';
tw = textnw(cur_fnt, lbuf, strlen(lbuf));
}
opx = px;
/* draw background for block */
if(block_align!=-1 && !nobg) {
setcolor(&pm, px, rectw, lastbg, lastbg, 0, nobg);
XFillRectangle(dzen.dpy, pm, dzen.tgc, px, 0, block_width, dzen.line_height);
}
if(block_align==ALIGNRIGHT)
px += (block_width - tw);
else if(block_align==ALIGNCENTER)
px += (block_width/2) - (tw/2);
if(!nobg)
setcolor(&pm, px, tw, lastfg, lastbg, reverse, nobg);
#ifndef DZEN_XFT
if(cur_fnt->set)
XmbDrawString(dzen.dpy, pm, cur_fnt->set,
dzen.tgc, px, py + cur_fnt->ascent, lbuf, strlen(lbuf));
else
XDrawString(dzen.dpy, pm, dzen.tgc, px, py+dzen.font.ascent, lbuf, strlen(lbuf));
#else
if(reverse) {
XftColorAllocName(dzen.dpy, DefaultVisual(dzen.dpy, dzen.screen),
DefaultColormap(dzen.dpy, dzen.screen), xftcs_bg, &xftc);
} else {
XftColorAllocName(dzen.dpy, DefaultVisual(dzen.dpy, dzen.screen),
DefaultColormap(dzen.dpy, dzen.screen), xftcs, &xftc);
}
XftDrawStringUtf8(xftd, &xftc,
cur_fnt->xftfont, px, py + dzen.font.xftfont->ascent, (const FcChar8 *)lbuf, strlen(lbuf));
if(xftcs_f) {
free(xftcs);
xftcs_f = 0;
}
if(xftcs_bgf) {
free(xftcs_bg);
xftcs_bgf = 0;
}
#endif
max_y = MAX(max_y, py+dzen.font.height);
if(block_align==-1) {
if(!pos_is_fixed || *linep =='\0')
px += tw;
} else {
if(pos_is_fixed)
px = opx;
else
px = opx+block_width;
}
block_align=block_width=-1;
}
if(*linep=='\0')
break;
j=0; t=-1; tval=NULL;
next_pos = get_token(linep, &t, &tval);
linep += next_pos;
/* ^^ escapes */
if(next_pos == 0)
lbuf[j++] = *linep++;
}
else
lbuf[j++] = *linep;
linep++;
}
if(!nodraw) {
/* expand/shrink dynamically */
if(dzen.title_win.expand && lnr == -1){
i = px;
switch(dzen.title_win.expand) {
case left:
/* grow left end */
otx = dzen.title_win.x_right_corner - i > dzen.title_win.x ?
dzen.title_win.x_right_corner - i : dzen.title_win.x;
XMoveResizeWindow(dzen.dpy, dzen.title_win.win, otx, dzen.title_win.y, px, dzen.line_height);
break;
case right:
XResizeWindow(dzen.dpy, dzen.title_win.win, px, dzen.line_height);
break;
}
} else {
if(align == ALIGNLEFT)
xorig[LNR2WINDOW(lnr)] = 0;
if(align == ALIGNCENTER) {
xorig[LNR2WINDOW(lnr)] = (lnr != -1) ?
(dzen.slave_win.width - px)/2 :
(dzen.title_win.width - px)/2;
}
else if(align == ALIGNRIGHT) {
xorig[LNR2WINDOW(lnr)] = (lnr != -1) ?
(dzen.slave_win.width - px) :
(dzen.title_win.width - px);
}
}
if(lnr != -1) {
XCopyArea(dzen.dpy, pm, dzen.slave_win.drawable[lnr], dzen.gc,
0, 0, dzen.w, dzen.line_height, xorig[LNR2WINDOW(lnr)], 0);
}
else {
XCopyArea(dzen.dpy, pm, dzen.title_win.drawable, dzen.gc,
0, 0, dzen.w, dzen.line_height, xorig[LNR2WINDOW(lnr)], 0);
}
XFreePixmap(dzen.dpy, pm);
/* reset font to default */
if(font_was_set)
setfont(dzen.fnt ? dzen.fnt : FONT);
#ifdef DZEN_XPM
if(free_xpm_attrib) {
XFreeColors(dzen.dpy, xpma.colormap, xpma.pixels, xpma.npixels, xpma.depth);
XpmFreeAttributes(&xpma);
}
#endif
#ifdef DZEN_XFT
XftDrawDestroy(xftd);
#endif
}
return nodraw ? rbuf : NULL;
}
Tooltip *
tooltip_create(MainWin *mw, dlist *config)
{
Tooltip *tt;
XSetWindowAttributes attr;
const char *tmp;
long int tmp_l;
tt = (Tooltip *)malloc(sizeof(Tooltip));
if(! tt)
return 0;
tt->mainwin = mw;
tt->window = None;
tt->font = 0;
tt->draw = 0;
tt->text = 0;
tt->color.pixel = tt->background.pixel = tt->border.pixel = tt->shadow.pixel = None;
attr.override_redirect = True;
attr.border_pixel = None;
attr.background_pixel = None;
attr.event_mask = ExposureMask;
attr.colormap = mw->colormap;
tt->window = XCreateWindow(mw->dpy, mw->root,
0, 0, 1, 1, 0,
mw->depth, InputOutput, mw->visual,
CWBorderPixel|CWBackPixel|CWOverrideRedirect|CWEventMask|CWColormap,
&attr);
if(tt->window == None)
{
fprintf(stderr, "WARNING: Couldn't create tooltip window.\n");
tooltip_destroy(tt);
return 0;
}
tmp = config_get(config, "tooltip", "border", "#e0e0e0");
if(! XftColorAllocName(mw->dpy, mw->visual, mw->colormap, tmp, &tt->border))
{
fprintf(stderr, "WARNING: Invalid color '%s'.\n", tmp);
tooltip_destroy(tt);
return 0;
}
tmp = config_get(config, "tooltip", "background", "#404040");
if(! XftColorAllocName(mw->dpy, mw->visual, mw->colormap, tmp, &tt->background))
{
fprintf(stderr, "WARNING: Invalid color '%s'.\n", tmp);
tooltip_destroy(tt);
return 0;
}
tmp = config_get(config, "tooltip", "opacity", "128");
tmp_l = MIN(MAX(0, strtol(tmp, 0, 0) * 256), 65535);
tt->background.color.alpha = tmp_l;
tt->border.color.alpha = tmp_l;
tmp = config_get(config, "tooltip", "text", "#e0e0e0");
if(! XftColorAllocName(mw->dpy, mw->visual, mw->colormap, tmp, &tt->color))
{
fprintf(stderr, "WARNING: Couldn't allocate color '%s'.\n", tmp);
tooltip_destroy(tt);
return 0;
}
tmp = config_get(config, "tooltip", "textShadow", "black");
if(strcasecmp(tmp, "none") != 0)
{
if(! XftColorAllocName(mw->dpy, mw->visual, mw->colormap, tmp, &tt->shadow))
{
fprintf(stderr, "WARNING: Couldn't allocate color '%s'.\n", tmp);
tooltip_destroy(tt);
return 0;
}
}
tt->draw = XftDrawCreate(mw->dpy, tt->window, mw->visual, mw->colormap);
if(! tt->draw)
{
fprintf(stderr, "WARNING: Couldn't create Xft draw surface.\n");
tooltip_destroy(tt);
return 0;
}
tt->font = XftFontOpenName(mw->dpy, mw->screen, config_get(config, "tooltip", "font", "fixed-11:weight=bold"));
if(! tt->font)
{
fprintf(stderr, "WARNING: Couldn't open Xft font.\n");
tooltip_destroy(tt);
return 0;
}
tt->font_height = tt->font->ascent + tt->font->descent;
return tt;
}
PlatformFont::CharInfo &x86UNIXFont::getCharInfo(const UTF16 ch) const
{
Display *display = XOpenDisplay(getenv("DISPLAY"));
if (!display )
AssertFatal(false, "createFont: cannot connect to X server");
static PlatformFont::CharInfo c;
dMemset(&c, 0, sizeof(c));
c.bitmapIndex = 0;
c.xOffset = 0;
c.yOffset = 0;
XftFont *fontInfo = XftFontOpenName(display, DefaultScreen(display), mFontName);
if (!fontInfo)
AssertFatal(false, "createFont: cannot load font");
int screen = DefaultScreen(display);
// Create the pixmap to draw on.
Drawable pixmap = XCreatePixmap(display,
DefaultRootWindow(display),
fontInfo->max_advance_width,
fontInfo->height,
DefaultDepth(display, screen));
// And the Xft wrapper around it.
XftDraw *draw = XftDrawCreate(display,
pixmap,
DefaultVisual(display, screen),
DefaultColormap(display, screen));
// Allocate some colors, we don't use XftColorAllocValue here as that
// Don't appear to function correctly (or I'm using it wrong) As we only do
// this twice per new un cached font it isn't that big of a penalty. (Each
// call to XftColorAllocName involves a round trip to the X Server)
XftColor black, white;
XftColorAllocName(display,
DefaultVisual(display, screen),
DefaultColormap(display, screen),
"black",
&black);
// White
XftColorAllocName(display,
DefaultVisual(display, screen),
DefaultColormap(display, screen),
"white",
&white);
XGlyphInfo charinfo;
XftTextExtents16(display, fontInfo, &ch, 1, &charinfo);
c.height = fontInfo->height;
c.xOrigin = 0;
c.yOrigin = fontInfo->ascent;
c.xIncrement = charinfo.xOff;
c.width = charinfo.xOff;
// kick out early if the character is undrawable
if( c.width == 0 || c.height == 0)
return c;
// allocate a greyscale bitmap and clear it.
int bitmapDataSize = c.width * c.height;
c.bitmapData = new U8[bitmapDataSize];
dMemset(c.bitmapData, 0, bitmapDataSize);
XftDrawRect (draw, &black, 0, 0, fontInfo->max_advance_width, fontInfo->height);
XftDrawString16 (draw, &white, fontInfo, 0, fontInfo->ascent, &ch, 1);
// grab the pixmap image
XImage *ximage = XGetImage(display, pixmap, 0, 0,
charinfo.xOff, fontInfo->height,
AllPlanes, XYPixmap);
if (!ximage)
AssertFatal(false, "cannot get x image");
int x, y;
// grab each pixel and store it in the scratchPad
for(y = 0; y < fontInfo->height; y++)
{
for(x = 0; x < charinfo.xOff; x++)
c.bitmapData[y * charinfo.xOff + x] = static_cast<U8>(XGetPixel(ximage, x, y));
}
XDestroyImage(ximage);
XftColorFree(display, DefaultVisual(display, screen),
DefaultColormap(display, screen), &black);
XftColorFree(display, DefaultVisual(display, screen),
DefaultColormap(display, screen), &white);
XftDrawDestroy(draw);
XFreePixmap(display, pixmap);
XCloseDisplay(display);
return c;
}
Menu::Menu(WindowManager *manager, XEvent *e)
: m_items(0), m_nItems(0), m_nHidden(0),
m_hasSubmenus(False),
m_windowManager(manager),
m_event(e)
{
if (!m_initialised)
{
XGCValues *values;
XSetWindowAttributes *attr;
m_menuGC = (GC *) malloc(m_windowManager->screensTotal() * sizeof(GC));
m_window = (Window *) malloc(m_windowManager->screensTotal() *
sizeof(Window));
#ifdef CONFIG_USE_XFT
char *fi = strdup(CONFIG_MENU_FONT);
char *ffi = fi, *tokstr = fi;
while ((fi = strtok(tokstr, ","))) {
fprintf(stderr, "fi = \"%s\"\n", fi);
tokstr = 0;
FcPattern *pattern = FcPatternCreate();
FcPatternAddString(pattern, FC_FAMILY, (FcChar8 *)fi);
FcPatternAddInteger(pattern, FC_SLANT, FC_SLANT_ROMAN);
#ifndef FC_WEIGHT_REGULAR
#define FC_WEIGHT_REGULAR FC_WEIGHT_MEDIUM
#endif
FcPatternAddInteger(pattern, FC_WEIGHT, FC_WEIGHT_REGULAR);
FcPatternAddInteger(pattern, FC_PIXEL_SIZE, CONFIG_MENU_FONT_SIZE);
FcConfigSubstitute(FcConfigGetCurrent(), pattern, FcMatchPattern);
FcResult result = FcResultMatch;
FcPattern *match = FcFontMatch(FcConfigGetCurrent(), pattern, &result);
FcPatternDestroy(pattern);
if (!match || result != FcResultMatch) {
if (match) FcPatternDestroy(match);
continue;
}
m_font = XftFontOpenPattern(display(), match);
if (m_font) break;
FcPatternDestroy(match);
}
free(ffi);
if (!m_font) {
m_windowManager->fatal("couldn't load menu Xft font");
}
m_xftColour = (XftColor *) malloc(m_windowManager->screensTotal() *
sizeof(XftColor));
m_xftDraw = (XftDraw **) malloc(m_windowManager->screensTotal() *
sizeof(XftDraw *));
#else
m_font = (XFontStruct **) malloc(m_windowManager->screensTotal() *
sizeof(XFontStruct *));
#endif
values = (XGCValues *) malloc(m_windowManager->screensTotal() *
sizeof(XGCValues));
attr = (XSetWindowAttributes *) malloc(m_windowManager->screensTotal() *
sizeof(XSetWindowAttributes));
for (int i = 0; i < m_windowManager->screensTotal(); i++)
{
m_foreground = m_windowManager->allocateColour
(i, CONFIG_MENU_FOREGROUND, "menu foreground");
m_background = m_windowManager->allocateColour
(i, CONFIG_MENU_BACKGROUND, "menu background");
m_border = m_windowManager->allocateColour
(i, CONFIG_MENU_BORDERS, "menu border");
#ifndef CONFIG_USE_XFT
char **ml;
int mc;
char *ds;
m_fontset = XCreateFontSet(display(), CONFIG_NICE_MENU_FONT,
&ml, &mc, &ds);
if (!m_fontset)
m_fontset = XCreateFontSet(display(), CONFIG_NASTY_FONT,
&ml, &mc, &ds);
if (m_fontset) {
XFontStruct **fs_list;
XFontsOfFontSet(m_fontset, &fs_list, &ml);
m_font[i] = fs_list[0];
} else {
m_font[i] = NULL;
}
#define XDrawString(t,u,v,w,x,y,z) XmbDrawString(t,u,m_fontset,v,w,x,y,z)
if (!m_font[i]) m_windowManager->fatal("couldn't load menu font\n");
#endif
values[i].background = m_background;
values[i].foreground = m_foreground ^ m_background;
values[i].function = GXxor;
values[i].line_width = 0;
values[i].subwindow_mode = IncludeInferiors;
#ifndef CONFIG_USE_XFT
values[i].font = m_font[i]->fid;
#endif
m_menuGC[i] = XCreateGC
(display(), m_windowManager->mroot(i),
GCForeground | GCBackground | GCFunction |
GCLineWidth | GCSubwindowMode, &values[i]);
#ifndef CONFIG_USE_XFT
XChangeGC(display(), Border::drawGC(m_windowManager, i),
GCFont, &values[i]);
#endif
m_window[i] = XCreateSimpleWindow
(display(), m_windowManager->mroot(i), 0, 0, 1, 1, 1,
m_border, m_background);
#if ( CONFIG_USE_PIXMAPS != False ) && ( CONFIG_USE_PIXMAP_MENUS != False )
attr[i].background_pixmap = Border::backgroundPixmap(manager);
#endif
attr[i].save_under =
(DoesSaveUnders(ScreenOfDisplay(display(), i)) ?
True : False);
#if ( CONFIG_USE_PIXMAPS != False ) && ( CONFIG_USE_PIXMAP_MENUS != False )
XChangeWindowAttributes
(display(), m_window[i], CWBackPixmap, &attr[i]);
#endif
XChangeWindowAttributes
(display(), m_window[i], CWSaveUnder, &attr[i]);
#ifdef CONFIG_USE_XFT
XftColorAllocName
(display(),
XDefaultVisual(display(), i),
XDefaultColormap(display(), i),
CONFIG_MENU_FOREGROUND,
&m_xftColour[i]);
m_xftDraw[i] = XftDrawCreate(display(), m_window[i],
XDefaultVisual(display(), i),
XDefaultColormap(display(), i));
#endif
}
m_initialised = True;
}
}
static void *
noseguy_init (Display *d, Window w)
{
struct state *st = (struct state *) calloc (1, sizeof(*st));
unsigned long fg, bg, text_fg, text_bg;
XWindowAttributes xgwa;
Colormap cmap;
char *fontname;
XGCValues gcvalues;
st->dpy = d;
st->window = w;
st->first_time = 1;
fontname = get_string_resource (st->dpy, "font", "Font");
XGetWindowAttributes (st->dpy, st->window, &xgwa);
st->Width = xgwa.width + 2;
st->Height = xgwa.height + 2;
cmap = xgwa.colormap;
st->tc = textclient_open (st->dpy);
{
int w = 40;
int h = 15;
textclient_reshape (st->tc, w, h, w, h,
/* Passing MAXLINES isn't actually necessary */
0);
}
init_images(st);
st->xftfont = XftFontOpenXlfd (st->dpy, screen_number (xgwa.screen),
fontname);
XftColorAllocName (st->dpy, xgwa.visual, xgwa.colormap,
get_string_resource (st->dpy,
"textForeground", "Foreground"),
&st->xftcolor);
st->xftdraw = XftDrawCreate (st->dpy, st->window, xgwa.visual,
xgwa.colormap);
fg = get_pixel_resource (st->dpy, cmap, "foreground", "Foreground");
bg = get_pixel_resource (st->dpy, cmap, "background", "Background");
text_fg = get_pixel_resource (st->dpy, cmap, "textForeground", "Foreground");
text_bg = get_pixel_resource (st->dpy, cmap, "textBackground", "Background");
/* notice when unspecified */
if (! get_string_resource (st->dpy, "textForeground", "Foreground"))
text_fg = bg;
if (! get_string_resource (st->dpy, "textBackground", "Background"))
text_bg = fg;
gcvalues.foreground = fg;
gcvalues.background = bg;
st->fg_gc = XCreateGC (st->dpy, st->window,
GCForeground|GCBackground,
&gcvalues);
gcvalues.foreground = bg;
gcvalues.background = fg;
st->bg_gc = XCreateGC (st->dpy, st->window,
GCForeground|GCBackground,
&gcvalues);
gcvalues.foreground = text_fg;
gcvalues.background = text_bg;
st->text_fg_gc = XCreateGC (st->dpy, st->window,
GCForeground|GCBackground,
&gcvalues);
gcvalues.foreground = text_bg;
gcvalues.background = text_fg;
st->text_bg_gc = XCreateGC (st->dpy, st->window,
GCForeground|GCBackground,
&gcvalues);
st->x = st->Width / 2;
st->y = st->Height / 2;
st->state = IS_MOVING;
st->next_fn = move;
st->walk_up = 1;
return st;
}
int
main(int argc, char *argv[])
{
XEvent e;
Atom type;
XClassHint *h;
XSetWindowAttributes wa;
unsigned int desktop;
struct pollfd pfd[1];
int nfds;
char *fontstr = FONT;
int running = 1;
d = XOpenDisplay(NULL);
if (d == NULL) {
fprintf(stderr, "Cannot open display\n");
exit(1);
}
s = DefaultScreen(d);
wa.override_redirect = 1;
wa.background_pixmap = ParentRelative;
wa.event_mask = ExposureMask | ButtonReleaseMask | ButtonPressMask;
w = XCreateWindow(d, RootWindow(d, s), 0, BARPOS, BARWIDTH, BARHEIGHT, 0,
DefaultDepth(d, s), CopyFromParent, DefaultVisual(d, s),
CWOverrideRedirect | CWBackPixmap | CWEventMask, &wa);
h = XAllocClassHint();
h->res_name = "status";
h->res_class = "status";
XSetClassHint(d, w, h);
XFree(h);
XStoreName(d, w, "status");
type = XInternAtom(d, "_NET_WM_WINDOW_TYPE_DOCK", False);
XChangeProperty(d, w, XInternAtom(d, "_NET_WM_WINDOW_TYPE", False),
XInternAtom(d, "ATOM", False), 32, PropModeReplace, (unsigned char *)&type, 1);
type = XInternAtom(d, "_NET_WM_STATE_ABOVE", False);
XChangeProperty(d, w, XInternAtom(d, "_NET_WM_STATE", False),
XInternAtom(d, "ATOM", False), 32, PropModeReplace, (unsigned char *)&type, 1);
type = XInternAtom(d, "_NET_WM_STATE_STICKY", False);
XChangeProperty(d, w, XInternAtom(d, "_NET_WM_STATE", False),
XInternAtom(d, "ATOM", False), 32, PropModeAppend, (unsigned char *)&type, 1);
desktop = 0xffffffff;
XChangeProperty(d, w, XInternAtom(d, "_NET_WM_DESKTOP", False),
XInternAtom(d, "CARDINAL", False), 32, PropModeReplace, (unsigned char *)&desktop, 1);
xftd = XftDrawCreate(d, w, DefaultVisual(d, s), DefaultColormap(d, s));
XftColorAllocName(d, DefaultVisual(d, s), DefaultColormap(d, s), "white", &white);
XftColorAllocName(d, DefaultVisual(d, s), DefaultColormap(d, s), "black", &black);
XftColorAllocName(d, DefaultVisual(d, s), DefaultColormap(d, s), "red", &red);
XftColorAllocName(d, DefaultVisual(d, s), DefaultColormap(d, s), "green", &green);
xftfont = XftFontOpenXlfd(d, s, fontstr);
if (!xftfont)
xftfont = XftFontOpenName(d, s, fontstr);
if (!xftfont)
exit(1);
XSelectInput(d, w, ExposureMask | ButtonPressMask | ButtonReleaseMask | Button1MotionMask);
XSelectInput(d, RootWindow(d, s), PropertyChangeMask);
XMapWindow(d, w);
XFlush(d);
pfd[0].fd = ConnectionNumber(d);
pfd[0].events = POLLIN;
while (running) {
nfds = poll(pfd, 1, 1000);
if (nfds == -1 || (pfd[0].revents & (POLLERR|POLLHUP|POLLNVAL)))
break;
if (nfds == 0) {
redraw();
XFlush(d);
continue;
}
while (XPending(d)) {
XNextEvent(d, &e);
if (e.type == PropertyNotify &&
e.xproperty.window == RootWindow(d, s) &&
e.xproperty.atom == XInternAtom(d, "_NET_CURRENT_DESKTOP", True)) {
redraw();
}
if (e.type == Expose) {
XftDrawRect(xftd, &black, 0, 0, BARWIDTH, BARHEIGHT);
redraw();
}
if (e.type == ButtonPress) {
/*running = 0;
break;*/
redraw();
}
}
}
XftColorFree(d, DefaultVisual(d, s), DefaultColormap(d, s), &white);
XftColorFree(d, DefaultVisual(d, s), DefaultColormap(d, s), &black);
XftFontClose(d, xftfont);
XftDrawDestroy(xftd);
XDestroyWindow(d, w);
XCloseDisplay(d);
return 0;
}
static GdkPixmap *
create_text_pixmap(GtkWidget *drawing_area, FT_Face face)
{
gint i, pixmap_width, pixmap_height, pos_y, textlen;
GdkPixmap *pixmap = NULL;
const gchar *text;
Display *xdisplay;
Drawable xdrawable;
Visual *xvisual;
Colormap xcolormap;
XftDraw *draw;
XftColor colour;
XGlyphInfo extents;
XftFont *font;
gint *sizes = NULL, n_sizes, alpha_size;
FcCharSet *charset = NULL;
cairo_t *cr;
GdkWindow *window = gtk_widget_get_window (drawing_area);
text = pango_language_get_sample_string(NULL);
if (! check_font_contain_text (face, text))
{
pango_language_get_sample_string (pango_language_from_string ("en_US"));
}
textlen = strlen(text);
/* create the XftDraw */
xdisplay = GDK_PIXMAP_XDISPLAY(window);
#if GTK_CHECK_VERSION(3, 0, 0)
xvisual = GDK_VISUAL_XVISUAL(gdk_window_get_visual(window));
#else
xvisual = GDK_VISUAL_XVISUAL(gdk_drawable_get_visual(window));
#endif
xcolormap = GDK_COLORMAP_XCOLORMAP(gdk_drawable_get_colormap(window));
XftColorAllocName(xdisplay, xvisual, xcolormap, "black", &colour);
/* work out what sizes to render */
if (FT_IS_SCALABLE(face)) {
n_sizes = 8;
sizes = g_new(gint, n_sizes);
sizes[0] = 8;
sizes[1] = 10;
sizes[2] = 12;
sizes[3] = 18;
sizes[4] = 24;
sizes[5] = 36;
sizes[6] = 48;
sizes[7] = 72;
alpha_size = 24;
} else {
/* use fixed sizes */
n_sizes = face->num_fixed_sizes;
sizes = g_new(gint, n_sizes);
alpha_size = 0;
for (i = 0; i < face->num_fixed_sizes; i++) {
sizes[i] = face->available_sizes[i].height;
/* work out which font size to render */
if (face->available_sizes[i].height <= 24)
alpha_size = face->available_sizes[i].height;
}
}
/* calculate size of pixmap to use (with 4 pixels padding) ... */
pixmap_width = 8;
pixmap_height = 8;
font = get_font(xdisplay, face, alpha_size, charset);
charset = FcCharSetCopy (font->charset);
XftTextExtentsUtf8(xdisplay, font,
(guchar *)lowercase_text, strlen(lowercase_text), &extents);
pixmap_height += extents.height + 4;
pixmap_width = MAX(pixmap_width, 8 + extents.width);
XftTextExtentsUtf8(xdisplay, font,
(guchar *)uppercase_text, strlen(uppercase_text), &extents);
pixmap_height += extents.height + 4;
pixmap_width = MAX(pixmap_width, 8 + extents.width);
XftTextExtentsUtf8(xdisplay, font,
(guchar *)punctuation_text, strlen(punctuation_text), &extents);
pixmap_height += extents.height + 4;
pixmap_width = MAX(pixmap_width, 8 + extents.width);
XftFontClose(xdisplay, font);
pixmap_height += 8;
for (i = 0; i < n_sizes; i++) {
font = get_font(xdisplay, face, sizes[i], charset);
if (!font) continue;
XftTextExtentsUtf8(xdisplay, font, (guchar *)text, textlen, &extents);
pixmap_height += extents.height + 4;
pixmap_width = MAX(pixmap_width, 8 + extents.width);
XftFontClose(xdisplay, font);
}
/* create pixmap */
gtk_widget_set_size_request(drawing_area, pixmap_width, pixmap_height);
pixmap = gdk_pixmap_new(window,
pixmap_width, pixmap_height, -1);
if (!pixmap)
goto end;
cr = gdk_cairo_create (pixmap);
cairo_set_source_rgb (cr, 1, 1, 1);
cairo_paint (cr);
cairo_destroy (cr);
xdrawable = GDK_DRAWABLE_XID(pixmap);
draw = XftDrawCreate(xdisplay, xdrawable, xvisual, xcolormap);
/* draw text */
pos_y = 4;
font = get_font(xdisplay, face, alpha_size, charset);
draw_string(xdisplay, draw, font, &colour, lowercase_text, &pos_y);
draw_string(xdisplay, draw, font, &colour, uppercase_text, &pos_y);
draw_string(xdisplay, draw, font, &colour, punctuation_text, &pos_y);
XftFontClose(xdisplay, font);
pos_y += 8;
for (i = 0; i < n_sizes; i++) {
font = get_font(xdisplay, face, sizes[i], charset);
if (!font) continue;
draw_string(xdisplay, draw, font, &colour, text, &pos_y);
XftFontClose(xdisplay, font);
}
g_signal_connect(drawing_area, "expose-event", G_CALLBACK(expose_event),
pixmap);
end:
g_free(sizes);
FcCharSetDestroy (charset);
return pixmap;
}
void
getcolor(char *colstr, XftColor *color) {
if(!XftColorAllocName(dpy, visual, cmap, colstr, color))
die("ERROR: cannot allocate color '%s'\n", colstr);
}
