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);
}
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);
}
static void
XmuFreeXftColor (XtAppContext app, XrmValuePtr toVal, XtPointer closure,
XrmValuePtr args, Cardinal *num_args)
{
Screen *screen;
Colormap colormap;
XftColor *color;
if (*num_args != 2)
{
XtAppErrorMsg (app,
"freeXftColor", "wrongParameters",
"XtToolkitError",
"Freeing an XftColor requires screen and colormap arguments",
(String *) NULL, (Cardinal *)NULL);
return;
}
screen = *((Screen **) args[0].addr);
colormap = *((Colormap *) args[1].addr);
color = (XftColor *) toVal->addr;
XftColorFree (DisplayOfScreen (screen),
DefaultVisual (DisplayOfScreen (screen),
XScreenNumberOfScreen (screen)),
colormap, color);
}
static void free_xft_color(Widget w, XftColor *col)
{
Display *dpy = XtDisplay(w);
TF();
XftColorFree(dpy, DefaultVisual(dpy, DefaultScreen(dpy)),
None, col );
}
/** 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 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
freecol(DC *dc, ColorSet *col) {
if(col) {
if(&col->FG_xft)
XftColorFree(dc->dpy, DefaultVisual(dc->dpy, DefaultScreen(dc->dpy)),
DefaultColormap(dc->dpy, DefaultScreen(dc->dpy)), &col->FG_xft);
free(col);
}
}
// set an Xft font by name
void textbox_font( textbox *tb, char *font, char *fg, char *bg )
{
if ( tb->font ) {
XftColorFree ( display,
DefaultVisual( display, DefaultScreen( display ) ),
DefaultColormap( display, DefaultScreen( display ) ),
&tb->color_fg );
XftColorFree ( display,
DefaultVisual( display, DefaultScreen( display ) ),
DefaultColormap( display, DefaultScreen( display ) ),
&tb->color_bg );
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 );
}
void de_free_colour(WRootWin *rootwin, DEColour col)
{
#ifdef HAVE_X11_XFT
XftColorFree(ioncore_g.dpy, XftDEDefaultVisual(), rootwin->default_cmap, &col);
#else /* HAVE_X11_XFT */
DEColour pixels[1];
pixels[0]=col;
XFreeColors(ioncore_g.dpy, rootwin->default_cmap, pixels, 1, 0);
#endif /* HAVE_X11_XFT */
}
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]);
}
}
/*----------------------------------------------------------------------------*/
void VKFreeXResource()
{
XFreeCursor(display, vk_hand);
XFreeCursor(display, vk_cursor);
#ifdef USE_XFT
XftColorFree(display, visual, colormap, &clRed);
XftColorFree(display, visual, colormap, &clYellow);
XftColorFree(display, visual, colormap, &clWhite);
XftColorFree(display, visual, colormap, &clBlack);
XftColorFree(display, visual, colormap, &clBlue);
XftColorFree(display, visual, colormap, &clGray);
XftColorFree(display, visual, colormap, &clMenuBar);
XftFontClose(display, vk_font);
#else
XFreeFontSet(display, vk_fontset);
XFreeFont(display, vk_font);
#endif
}
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 XftTextRenderer::drawRect(int x, int y, int w, int h, const GdkColor* color)
{
#if defined(USE_XFT_DRAWRECT)
g_warning("(%d,%d,%d,%d)", x,y,w,h);
XftColor xft_c;
XRenderColor xrender_c;
getXRenderColorFromGdkColor(color, &xrender_c);
XftColorAllocValue(xdisplay,
xvisual,
xcmap,
&xrender_c,
&xft_c);
x -= gdkxoff;
y -= gdkyoff;
XftDrawRect(xftdraw, &xft_c, x, y, w, h);
XftColorFree(xdisplay,
xvisual,
xcmap,
&xft_c);
#else
gdk_gc_set_rgb_fg_color(gdkgc, const_cast<GdkColor*>(color));
x -= gdkxoff;
y -= gdkyoff;
gdk_gc_set_fill (gdkgc, GDK_SOLID);
gdk_draw_rectangle(gdkdrawable, gdkgc, TRUE, x, y, w, h);
#endif
}
static void destroy(Widget w)
{
int i;
CtrlPart *c = & ((CtrlWidget)w)->ctrl;
Display *dpy = XtDisplay(w);
clabel_t *cl;
TF();
if(! c->draw ) return;
XftDrawDestroy( c->draw ); c->draw =0;
for(i=0;i<3;i++) {
XftColorFree(dpy, DefaultVisual(dpy, DefaultScreen(dpy)), None, c->col+i );
XtReleaseGC( w, c->gc[i] ); c->gc[i] =0;
}
for(i=0;i<MAX_CLABEL;i++) {
cl = c->clabel+i;
if( cl->font ) {
XftFontClose(dpy, cl->font ); cl->font = 0;
}
}
}
void* thread_pattern_gen(void *data){
Display *dp;
Bool is_ntsc = (Bool)data;
Window mw; /* One TopLevel Window & Two Child Windows */
GC gc, gc_rect1, gc_rect2, gc_string;
XftFont *xft;
XftDraw *xftdraw;
XRenderColor xrcolor;
XftColor xftcolor;
XGCValues gv;
XSetWindowAttributes xswa;
struct timeval tv;
/* 서버와 접속하기 그리고 변수들을 초기화 */
dp = XOpenDisplay ( NULL );
mw = XCreateSimpleWindow ( dp, DefaultRootWindow( dp ),
0, 0, 720, is_ntsc?480:576, 0,
WhitePixel(dp,0), BlackPixel(dp,0) );
xswa.override_redirect = True;
XChangeWindowAttributes ( dp, mw, CWOverrideRedirect, &xswa );
XMapWindow( dp, mw );
gv.foreground = UsrColorPixel( dp, "red" );
gv.background = UsrColorPixel( dp, "yello" );
gc = XCreateGC( dp, mw, GCForeground | GCBackground, &gv );
gv.foreground = UsrColorPixel( dp, "red" );
gv.background = UsrColorPixel( dp, "black" );
gc_rect1 = XCreateGC( dp, mw, GCForeground | GCBackground, &gv );
gv.foreground = UsrColorPixel( dp, "blue" );
gv.background = UsrColorPixel( dp, "black" );
gc_rect2 = XCreateGC( dp, mw, GCForeground | GCBackground, &gv );
gv.foreground = UsrColorPixel( dp, "white" );
gv.background = UsrColorPixel( dp, "black" );
gc_string = XCreateGC( dp, mw, GCForeground | GCBackground, &gv );
//xft = XftFontOpenName( dp, 0, "Bitstream Vera Sans Mono-50:bold" );
xft = XftFontOpenName( dp, 0, "Courier New-48:bold" );
if(!xft){
printf("font null\n");
return 0;
}
xftdraw = XftDrawCreate(dp, mw, DefaultVisual(dp, 0), DefaultColormap(dp, 0));
xrcolor.red = 65535;
xrcolor.green = 65535;
xrcolor.blue =65535;
xrcolor.alpha = 65535;
XftColorAllocValue(dp, DefaultVisual(dp, 0), DefaultColormap(dp, 0), &xrcolor, &xftcolor);
int frame_rate = is_ntsc? 30:25;
unsigned int div = is_ntsc? 33333: 40000;
char line1[40];
char line2[40];
int line1_y = is_ntsc? (480/2)-30 : (576/2)-30;
int line2_y = is_ntsc? (480/2)+30 : (576/2)+30;
int rect1_y = is_ntsc? 480/4 : 576/4;
int rect2_y = is_ntsc? (480/4)*3 : (576/4)*3;
while(1){
if(kill_thread) break;
int move;
for( move = 0; move < frame_rate; move ++){
gettimeofday(&tv, NULL);
struct tm *ptm = localtime(&(tv.tv_sec));
XFlush(dp);
XClearWindow( dp, mw );
XFillRectangle ( dp, mw, gc_rect1, (move==0)? 0:(720/30)*move, rect1_y, 50, 10);
XFillRectangle ( dp, mw, gc_rect2, (move==0)? 0:720-(720/30)*move, rect2_y, 50, 10);
sprintf(line1," %04d/%02d/%02d ", ptm->tm_year+1900, ptm->tm_mon+1, ptm->tm_mday);
sprintf(line2,"%02d:%02d:%02d %02ld\'",ptm->tm_hour, ptm->tm_min, ptm->tm_sec, tv.tv_usec/div);
XftDrawString8(xftdraw, &xftcolor, xft, 100, line1_y, (XftChar8 *)line1, 12);
XftDrawString8(xftdraw, &xftcolor, xft, 100, line2_y, (XftChar8 *)line2, 12);
usleep(div);
}
}
printf("thread kill\n");
/* GC, 창 파괴 & 서버와의 접속 해제 */
XFreeGC( dp, gc );
XUnmapWindow( dp, mw );
XftDrawDestroy(xftdraw);
XftColorFree(dp, DefaultVisual(dp, 0), DefaultColormap(dp, 0), &xftcolor);
XDestroyWindow( dp, mw );
XCloseDisplay( dp );
return 0;
}
static void se_draw_buffer_point( se_text_xviewer* viewer )
{
se_env *env = viewer->env;
se_world *world = viewer->env->world;
g_assert( world );
se_buffer *cur_buf = world->current;
g_assert( cur_buf );
se_cursor point_cur = {
.row = cur_buf->getLine( cur_buf ),
.column = cur_buf->getCurrentColumn( cur_buf )
};
se_position point_pos = se_text_cursor_to_physical( viewer, point_cur );
point_pos.y -= (env->glyphMaxHeight - env->glyphAscent)/2;
XRenderColor renderClr = {
.red = 0x00,
.green = 0xffff,
.blue = 0x00,
.alpha = 0x00
};
XftColor clr;
XftColorAllocValue( env->display, env->visual, env->colormap, &renderClr, &clr );
XftDrawRect( viewer->xftDraw, &clr, point_pos.x, point_pos.y, 2, env->glyphMaxHeight );
XftColorFree( env->display, env->visual, env->colormap, &clr );
}
// send draw event and do real update in redisplay routine
static void se_text_xviewer_repaint( se_text_xviewer* viewer )
{
XWindowAttributes attrs;
XGetWindowAttributes( viewer->env->display, viewer->view, &attrs);
viewer->updateSize( viewer, attrs.width, attrs.height );
//refill text viewer
se_world *world = viewer->env->world;
g_assert( world );
se_buffer *cur_buf = world->current;
g_assert( cur_buf );
//FIXME: this is slow algo just as a demo, change it later
se_line* lp = cur_buf->lines;
int nr_lines = cur_buf->getLineCount( cur_buf );
se_debug( "paint rect: rows: %d", nr_lines );
for (int r = 0; r < MIN(viewer->rows, nr_lines); ++r) {
const char* buf = se_line_getData( lp );
int cols = se_line_getLineLength( lp );
if ( buf[cols-1] == '\n' ) cols--;
memcpy( (viewer->content + r*SE_MAX_ROWS), buf, cols );
*(viewer->content + r*SE_MAX_ROWS+cols) = '\0';
/* se_debug( "draw No.%d: [%s]", r, buf ); */
lp = lp->next;
}
}
static void se_text_xviewer_redisplay(se_text_xviewer* viewer )
{
se_debug( "redisplay" );
se_env *env = viewer->env;
XRenderColor renderClr = {
.red = 0x0,
.green = 0x0,
.blue = 0x0,
.alpha = 0xffff
};
XftColor clr;
XftColorAllocValue( env->display, env->visual, env->colormap, &renderClr, &clr );
se_world *world = viewer->env->world;
g_assert( world );
se_buffer *cur_buf = world->current;
g_assert( cur_buf );
int nr_lines = cur_buf->getLineCount( cur_buf );
se_debug( "update buf %s [%d, %d]", cur_buf->getBufferName(cur_buf),
viewer->columns, MIN(viewer->rows, nr_lines) );
// this clear the whole window ( slow )
XClearArea( env->display, viewer->view, 0, 0, 0, 0, False );
viewer->cursor = (se_cursor){ 0, 0 };
for (int r = 0; r < MIN(viewer->rows, nr_lines); ++r) {
char *data = viewer->content + r*SE_MAX_ROWS;
int data_len = strlen( data );
se_draw_text_utf8( viewer, &clr, viewer->cursor,
data, MIN(data_len, viewer->columns) );
viewer->cursor = (se_cursor){0, viewer->cursor.row + 1};
}
se_draw_buffer_point( viewer );
XftColorFree( env->display, env->visual, env->colormap, &clr );
}
void se_text_xviewer_configure_change_handler(se_text_xviewer* viewer, XEvent* ev )
{
se_debug( "enter configure_change_handler" );
gboolean need_update = FALSE;
if ( ev->type == ConfigureRequest ) {
XConfigureEvent configEv = ev->xconfigure;
if ( viewer->physicalWidth != configEv.width
|| viewer->physicalHeight != configEv.height ) {
need_update = TRUE;
}
} else if ( ev->type == ResizeRequest ) {
XResizeRequestEvent resizeEv = ev->xresizerequest;
if ( viewer->physicalWidth != resizeEv.width
|| viewer->physicalHeight != resizeEv.height ) {
need_update = TRUE;
}
}
if ( need_update ) {
XWindowAttributes attrs;
XGetWindowAttributes( viewer->env->display, viewer->view, &attrs);
viewer->updateSize( viewer, attrs.width, attrs.height );
}
}
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;
}
void ui_close()
{
if (ui_squarecolorwhiteinit) {
XftColorFree(ui_display, DefaultVisual(ui_display, 0), DefaultColormap(ui_display, 0), &ui_squarecolorwhite);
ui_squarecolorwhiteinit = false;
}
if (ui_squarecolorblackinit) {
XftColorFree(ui_display, DefaultVisual(ui_display, 0), DefaultColormap(ui_display, 0), &ui_squarecolorblack);
ui_squarecolorblackinit = false;
}
if (ui_piececolorwhiteinit) {
XftColorFree(ui_display, DefaultVisual(ui_display, 0), DefaultColormap(ui_display, 0), &ui_piececolorwhite);
ui_piececolorwhiteinit = false;
}
if (ui_piececolorblackinit) {
XftColorFree(ui_display, DefaultVisual(ui_display, 0), DefaultColormap(ui_display, 0), &ui_piececolorblack);
ui_piececolorblackinit = false;
}
if (ui_infocolorinit) {
XftColorFree(ui_display, DefaultVisual(ui_display, 0), DefaultColormap(ui_display, 0), &ui_infocolor);
ui_infocolorinit = false;
}
if (ui_infocolortaginit) {
XftColorFree(ui_display, DefaultVisual(ui_display, 0), DefaultColormap(ui_display, 0), &ui_infocolortag);
ui_infocolortaginit = false;
}
if ( NULL != ui_xftdraw) {
XftDrawDestroy(ui_xftdraw);
ui_xftdraw = NULL;
}
if ( NULL != ui_piecefont) {
XftFontClose(ui_display, ui_piecefont);
ui_piecefont = NULL;
}
if ( NULL != ui_infofont) {
XftFontClose(ui_display, ui_infofont);
ui_infofont = NULL;
}
if ( NULL != ui_namefont) {
XftFontClose(ui_display, ui_namefont);
ui_namefont = NULL;
}
if ( NULL != ui_coordfont) {
XftFontClose(ui_display, ui_coordfont);
ui_coordfont = NULL;
}
if (0 != ui_gcontext) {
XFreeGC(ui_display, ui_gcontext);
ui_gcontext = 0;
}
if ( ui_backbuf != 0 ) {
XFreePixmap( ui_display, ui_backbuf );
ui_backbuf = 0;
}
ui_rootwindow = 0;
if ( NULL != ui_display) {
XCloseDisplay(ui_display);
ui_display = NULL;
}
}
void XftTextRenderer::drawRun(const WebCoreTextRun *run, const WebCoreTextStyle *style, int x, int y)
{
assert(run);
assert(style);
assert(style->families);
if (run->length == 0)
return;
XRenderColor xrc;
XftColor c;
getXRenderColorFromGdkColor(&style->textColor, &xrc);
XftColorAllocValue(xdisplay,
xvisual,
xcmap,
&xrc,
&c);
x -= gdkxoff;
y -= gdkyoff;
const int wordBufSz = 10; // size of scan buffer
WordRange words[wordBufSz]; // scan buffer
int nWords; // number of words in scan buffer
int totWords = 0; // total word count
// needs always totWords because wordSpacing is applied only to spaces in the middle, not
// for the last word. Is this correct practice?
scanRunForWords(run, run->from, words, wordBufSz, &nWords, &totWords);
if (totWords == 0)
return;
float wordPadding = style->padding / totWords;
float wordWidth = 0.0f;
int wordsDrawn = 0;
int wordIndex;
while (1) {
// iterate over scan buffer
for (wordIndex = 0; wordIndex < nWords; wordIndex++) {
wordWidth = drawRange(run, style, words[wordIndex].start, words[wordIndex].stop, x, y, &c, true);
// not last word
wordWidth += wordPadding;
wordWidth += font->spaceWidth + style->wordSpacing;
x += (int)wordWidth;
++wordsDrawn;
}
if (nWords > 0 && words[nWords-1].stop+1 < run->to) {
// update scan buffer (will happen if number of spaces > wordBufSz)
scanRunForWords(run, words[nWords-1].stop+1, words, wordBufSz, &nWords, NULL);
} else
break;
}
XftColorFree(xdisplay,
xvisual,
xcmap,
&c);
if (style->rtl){
g_warning("RTL painting not implemented"); // FIXME:: Handle right-to-left text
}
}
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;
}
