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); }