static void
xftfont_close (struct font *font)
{
struct x_display_info *xdi;
struct xftfont_info *xftfont_info = (struct xftfont_info *) font;
#ifdef HAVE_LIBOTF
if (xftfont_info->otf)
{
OTF_close (xftfont_info->otf);
xftfont_info->otf = NULL;
}
#endif
/* See comment in xfont_close. */
if (xftfont_info->xftfont
&& ((xdi = x_display_info_for_display (xftfont_info->display))
&& xftfont_info->x_display_id == xdi->x_id))
{
block_input ();
XftUnlockFace (xftfont_info->xftfont);
XftFontClose (xftfont_info->display, xftfont_info->xftfont);
unblock_input ();
xftfont_info->xftfont = NULL;
}
}
static void
_xft_Unload(TextState * ts)
{
FontCtxXft *fdc = (FontCtxXft *) ts->fdc;
XftFontClose(disp, fdc->font);
}
bool x86UNIXFont::create(const char *name, U32 size, U32 charset)
{
Display *display = XOpenDisplay(getenv("DISPLAY"));
if (display == NULL)
AssertFatal(false, "createFont: cannot connect to X server");
XftFont *font = loadFont(name, size, display);
if (!font)
{
Con::errorf("Error: Could not load font -%s-", name);
return false;
}
char xfontname[1024];
XftNameUnparse(font->pattern, xfontname, 1024);
#ifdef DEBUG
Con::printf("CreateFont: request for %s %d, using %s", name, size, xfontname);
#endif
// store some info about the font
baseline = font->ascent;
height = font->height;
mFontName = StringTable->insert(xfontname);
XftFontClose (display, font);
// DISPLAY
XCloseDisplay(display);
return true;
}
void
xaw_destroy_instance (widget_instance *instance)
{
#ifdef HAVE_XFT
if (instance->xft_data)
{
int i;
for (i = 0; i < instance->nr_xft_data; ++i)
{
if (instance->xft_data[i].xft_draw)
XftDrawDestroy (instance->xft_data[i].xft_draw);
if (instance->xft_data[i].p != None)
{
XtVaSetValues (instance->xft_data[i].widget, XtNbitmap, None,
NULL);
XFreePixmap (XtDisplay (instance->widget),
instance->xft_data[i].p);
}
}
if (instance->xft_data[0].xft_font)
XftFontClose (XtDisplay (instance->widget),
instance->xft_data[0].xft_font);
xfree (instance->xft_data);
}
#endif
if (XtIsSubclass (instance->widget, dialogWidgetClass))
/* Need to destroy the Shell too. */
XtDestroyWidget (XtParent (instance->widget));
else
XtDestroyWidget (instance->widget);
}
void
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);
}
int win_draw_text(win_t *win, XftDraw *d, const XftColor *color, int x, int y,
char *text, int len, int w)
{
int err, tw = 0;
char *t, *next;
uint32_t rune;
XftFont *f;
FcCharSet *fccharset;
XGlyphInfo ext;
for (t = text; t - text < len; t = next) {
next = utf8_decode(t, &rune, &err);
if (XftCharExists(win->env.dpy, font, rune)) {
f = font;
} else { /* fallback font */
fccharset = FcCharSetCreate();
FcCharSetAddChar(fccharset, rune);
f = XftFontOpen(win->env.dpy, win->env.scr, FC_CHARSET, FcTypeCharSet,
fccharset, FC_SCALABLE, FcTypeBool, FcTrue,
FC_SIZE, FcTypeDouble, fontsize, NULL);
FcCharSetDestroy(fccharset);
}
XftTextExtentsUtf8(win->env.dpy, f, (XftChar8*)t, next - t, &ext);
tw += ext.xOff;
if (tw <= w) {
XftDrawStringUtf8(d, color, f, x, y, (XftChar8*)t, next - t);
x += ext.xOff;
}
if (f != font)
XftFontClose(win->env.dpy, f);
}
return tw;
}
Error FontX11::load(const String& p_name,float p_size,unsigned int p_flags) {
if (font) {
XftFontInfoDestroy( x11_display, font_info );
XftFontClose( x11_display, font );
font=NULL;
}
name="";
size=0;
flags=0;
font = XftFontOpen (x11_display, DefaultScreen(x11_display),XFT_FAMILY, XftTypeString, p_name.utf8().get_data(),
XFT_SIZE, XftTypeDouble, p_size,NULL);
if (!font) {
return ERR_UNSUPPORTED;
}
font_info = XftFontInfoCreate( x11_display, font->pattern );
flags=p_flags;
name=p_name;
size=p_size;
return OK;
}
void
drw_font_free(Display *dpy, Fnt *font) {
if(!font)
return;
XftFontClose(dpy, font->xfont);
free(font);
}
static void
FinishedWithFont(
UnixFtFont *fontPtr)
{
Display *display = fontPtr->display;
int i;
Tk_ErrorHandler handler = Tk_CreateErrorHandler(display, -1, -1, -1, NULL,
(ClientData) NULL);
for (i = 0; i < fontPtr->nfaces; i++) {
if (fontPtr->faces[i].ftFont) {
XftFontClose(fontPtr->display, fontPtr->faces[i].ftFont);
}
if (fontPtr->faces[i].charset) {
FcCharSetDestroy(fontPtr->faces[i].charset);
}
}
if (fontPtr->faces) {
ckfree((char *)fontPtr->faces);
}
if (fontPtr->pattern) {
FcPatternDestroy(fontPtr->pattern);
}
if (fontPtr->ftDraw) {
XftDrawDestroy(fontPtr->ftDraw);
}
if (fontPtr->font.fid) {
XUnloadFont(fontPtr->display, fontPtr->font.fid);
}
if (fontPtr->fontset) {
FcFontSetDestroy(fontPtr->fontset);
}
Tk_DeleteErrorHandler(handler);
}
// 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);
}
void CFont::CloseXftFont( XftFont* font )
{
if( font )
{
Display *display = gdk_x11_get_default_xdisplay();
XftFontClose(display, font );
}
}
FontX11::~FontX11() {
if (font) {
XftFontInfoDestroy( x11_display, font_info );
XftFontClose( x11_display, font );
}
}
void drw_font_free(Fnt *font)
{
if (!font)
return;
if (font->pattern)
FcPatternDestroy(font->pattern);
XftFontClose(font->dpy, font->xfont);
free(font);
}
void
setfont(const char *fontstr) {
#ifndef DZEN_XFT
char *def, **missing;
int i, n;
missing = NULL;
if(dzen.font.set)
XFreeFontSet(dzen.dpy, dzen.font.set);
dzen.font.set = XCreateFontSet(dzen.dpy, fontstr, &missing, &n, &def);
if(missing)
XFreeStringList(missing);
if(dzen.font.set) {
XFontSetExtents *font_extents;
XFontStruct **xfonts;
char **font_names;
dzen.font.ascent = dzen.font.descent = 0;
font_extents = XExtentsOfFontSet(dzen.font.set);
n = XFontsOfFontSet(dzen.font.set, &xfonts, &font_names);
for(i = 0, dzen.font.ascent = 0, dzen.font.descent = 0; i < n; i++) {
if(dzen.font.ascent < (*xfonts)->ascent)
dzen.font.ascent = (*xfonts)->ascent;
if(dzen.font.descent < (*xfonts)->descent)
dzen.font.descent = (*xfonts)->descent;
xfonts++;
}
}
else {
if(dzen.font.xfont)
XFreeFont(dzen.dpy, dzen.font.xfont);
dzen.font.xfont = NULL;
if(!(dzen.font.xfont = XLoadQueryFont(dzen.dpy, fontstr)))
eprint("dzen: error, cannot load font: '%s'\n", fontstr);
dzen.font.ascent = dzen.font.xfont->ascent;
dzen.font.descent = dzen.font.xfont->descent;
}
dzen.font.height = dzen.font.ascent + dzen.font.descent;
#else
if(dzen.font.xftfont)
XftFontClose(dzen.dpy, dzen.font.xftfont);
dzen.font.xftfont = XftFontOpenXlfd(dzen.dpy, dzen.screen, fontstr);
if(!dzen.font.xftfont)
dzen.font.xftfont = XftFontOpenName(dzen.dpy, dzen.screen, fontstr);
if(!dzen.font.xftfont)
eprint("error, cannot load font: '%s'\n", fontstr);
dzen.font.extents = malloc(sizeof(XGlyphInfo));
XftTextExtentsUtf8(dzen.dpy, dzen.font.xftfont, (unsigned const char *) fontstr, strlen(fontstr), dzen.font.extents);
dzen.font.height = dzen.font.xftfont->ascent + dzen.font.xftfont->descent;
dzen.font.width = (dzen.font.extents->width)/strlen(fontstr);
#endif
}
/* This function is an implementation detail. Library users should use
* drw_font_create instead.
*/
static Fnt * drw_font_xcreate(Drw *drw, const char *fontname, FcPattern *fontpattern)
{
Fnt *font;
if (!(fontname || fontpattern))
die("No font specified.\n");
if (!(font = (Fnt *)calloc(1, sizeof(Fnt))))
return NULL;
if (fontname)
{
/* Using the pattern found at font->xfont->pattern does not yield same
* the same substitution results as using the pattern returned by
* FcNameParse; using the latter results in the desired fallback
* behaviour whereas the former just results in
* missing-character-rectangles being drawn, at least with some fonts.
*/
if (!(font->xfont = XftFontOpenName(drw->dpy, drw->screen, fontname)) ||
!(font->pattern = FcNameParse((FcChar8 *) fontname)))
{
if (font->xfont)
{
XftFontClose(drw->dpy, font->xfont);
font->xfont = NULL;
}
fprintf(stderr, "error, cannot load font: '%s'\n", fontname);
}
}
else if (fontpattern)
{
if (!(font->xfont = XftFontOpenPattern(drw->dpy, fontpattern)))
{
fprintf(stderr, "error, cannot load font pattern.\n");
} else {
font->pattern = NULL;
}
}
if (!font->xfont)
{
free(font);
return NULL;
}
font->ascent = font->xfont->ascent;
font->descent = font->xfont->descent;
font->h = font->ascent + font->descent;
font->dpy = drw->dpy;
return font;
}
static void
xftfont_close (FRAME_PTR f, struct font *font)
{
struct xftfont_info *xftfont_info = (struct xftfont_info *) font;
#ifdef HAVE_LIBOTF
if (xftfont_info->otf)
OTF_close (xftfont_info->otf);
#endif
BLOCK_INPUT;
XftUnlockFace (xftfont_info->xftfont);
XftFontClose (xftfont_info->display, xftfont_info->xftfont);
UNBLOCK_INPUT;
}
void
WMReleaseFont(WMFont *font)
{
wassertr(font!=NULL);
font->refCount--;
if (font->refCount < 1) {
XftFontClose(font->screen->display, font->font);
if (font->name) {
WMHashRemove(font->screen->fontCache, font->name);
wfree(font->name);
}
wfree(font);
}
}
// will also unmap the window if still displayed
void textbox_free(textbox *tb)
{
if (tb->flags & TB_EDITABLE)
{
XDestroyIC(tb->xic);
XCloseIM(tb->xim);
}
if (tb->text) free(tb->text);
if (tb->prompt) free(tb->prompt);
if (tb->font) XftFontClose(display, tb->font);
XDestroyWindow(display, tb->window);
free(tb);
}
void Menu::cleanup(WindowManager *const wm)
{
if (m_initialised) { // fix due to Eric Marsden
#ifdef CONFIG_USE_XFT
XftFontClose(wm->display(), m_font);
#endif
for (int i = 0; i < wm->screensTotal(); i++) {
#ifdef CONFIG_USE_XFT
XftDrawDestroy(m_xftDraw[i]);
#else
XFreeFontSet(wm->display(), m_fontset);
#endif
XFreeGC(wm->display(), m_menuGC[i]);
}
}
}
void
JXFontManager::XFont::Free
(
JXDisplay* display
)
{
if (type == kStdType)
{
XFreeFont(*display, xfstd);
}
else
{
assert( type == kTrueType );
XftFontClose(*display, xftrue);
}
}
bool x11_blocks_resize(XRESOURCES* xres, CFG* config, TEXTBLOCK** blocks, XGlyphInfo* bounding_box, double size){
XftFont* font = NULL;
unsigned bounding_width = 0, bounding_height = 0;
unsigned i;
//load font with at supplied size
font=XftFontOpen(xres->display, xres->screen,
XFT_FAMILY, XftTypeString, config->font_name,
XFT_PIXEL_SIZE, XftTypeDouble, size,
NULL
);
if(!font){
fprintf(stderr, "Could not load font\n");
return false;
}
//fprintf(stderr, "Block \"%s\" extents: width %d, height %d, x %d, y %d, xOff %d, yOff %d\n",
// block->text, block->extents.width, block->extents.height, block->extents.x, block->extents.y,
// block->extents.xOff, block->extents.yOff);
//bounds calculation
for(i = 0; blocks[i] && blocks[i]->active; i++){
//update only not yet calculated blocks
if(!(blocks[i]->calculated)){
XftTextExtentsUtf8(xres->display, font, (FcChar8*)blocks[i]->text, strlen(blocks[i]->text), &(blocks[i]->extents));
errlog(config, LOG_DEBUG, "Recalculated block %d (%s) extents: %dx%d\n", i, blocks[i]->text, blocks[i]->extents.width, blocks[i]->extents.height);
blocks[i]->size = size;
}
//calculate bounding box over all
bounding_height += blocks[i]->extents.height;
if(blocks[i]->extents.width > bounding_width){
bounding_width = blocks[i]->extents.width;
}
}
if(bounding_box){
bounding_box->width = bounding_width;
bounding_box->height = bounding_height;
}
XftFontClose(xres->display, font);
return true;
}
JXFontManager::~JXFontManager()
{
const JSize count = itsFontList->GetElementCount();
for (JIndex i=1; i<=count; i++)
{
FontInfo info = itsFontList->GetElement(i);
delete info.name;
#ifdef _J_USE_XFT
XftFontClose(*itsDisplay, info.xftfont);
#else
XFreeFont(*itsDisplay, info.xfont);
#endif
}
delete itsFontList;
delete itsAllFontNames;
delete itsMonoFontNames;
}
/*----------------------------------------------------------------------------*/
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
}
void freedc(DC * dc)
{
if (dc->font.xft_font) {
XftFontClose(dc->dpy, dc->font.xft_font);
XftDrawDestroy(dc->xftdraw);
}
if (dc->font.set)
XFreeFontSet(dc->dpy, dc->font.set);
if (dc->font.xfont)
XFreeFont(dc->dpy, dc->font.xfont);
if (dc->canvas)
XFreePixmap(dc->dpy, dc->canvas);
if (dc->gc)
XFreeGC(dc->dpy, dc->gc);
if (dc->dpy)
XCloseDisplay(dc->dpy);
if (dc)
free(dc);
}
static void Change_Font(Widget w, int n, char *s)
{
CtrlWidget cw = (CtrlWidget)w;
CtrlPart *c = & cw->ctrl;
Display *dpy = XtDisplay(w);
clabel_t *cl = c->clabel+n;
XftFont *font;
TF();
TRACE(2,"%s",s);
if( IsEmpty(s) ) s="Sans-12";
font = XftFontOpenName(dpy, DefaultScreen(dpy), s );
if(!font )
XtAppError(XtWidgetToApplicationContext(w), "CtrlWidget: unknown font" );
else {
if( cl->font ) XftFontClose( dpy, cl->font);
cl->font = font;
}
}
void de_free_font(DEFont *font)
{
if(--font->refcount!=0)
return;
#ifdef HAVE_X11_XFT
if(font->font!=NULL)
XftFontClose(ioncore_g.dpy, font->font);
#else /* HAVE_X11_XFT */
if(font->fontset!=NULL)
XFreeFontSet(ioncore_g.dpy, font->fontset);
if(font->fontstruct!=NULL)
XFreeFont(ioncore_g.dpy, font->fontstruct);
#endif /* HAVE_X11_XFT */
if(font->pattern!=NULL)
free(font->pattern);
UNLINK_ITEM(fonts, font, next, prev);
free(font);
}
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
freedc(DC *dc) {
if(dc->info) {
XFree(dc->info);
}
if(dc->font.xft_font)
XftFontClose(dc->dpy, dc->font.xft_font);
if(dc->font.set)
XFreeFontSet(dc->dpy, dc->font.set);
if(dc->font.xfont)
XFreeFont(dc->dpy, dc->font.xfont);
if(dc->menus){
for(int i=0; i<dc->scrcount; ++i){
freemenu(dc, &dc->menus[i]);
}
free(dc->menus);
}
if(dc->gc)
XFreeGC(dc->dpy, dc->gc);
if(dc->dpy)
XCloseDisplay(dc->dpy);
if(dc)
free(dc);
}
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;
}
}
}
static void setup_font_sample(GtkWidget* darea, Antialiasing antialiasing, Hinting hinting)
{
const char* string1 = "abcfgop AO ";
const char* string2 = "abcfgop";
XftColor black, white;
XRenderColor rendcolor;
Display* xdisplay = gdk_x11_get_default_xdisplay();
#if GTK_CHECK_VERSION (3, 0, 0)
Colormap xcolormap = DefaultColormap(xdisplay, 0);
#else
GdkColormap* colormap = gdk_rgb_get_colormap();
Colormap xcolormap = GDK_COLORMAP_XCOLORMAP(colormap);
#endif
#if GTK_CHECK_VERSION (3, 0, 0)
GdkVisual* visual = gdk_visual_get_system ();
#else
GdkVisual* visual = gdk_colormap_get_visual(colormap);
#endif
Visual* xvisual = GDK_VISUAL_XVISUAL(visual);
FcPattern* pattern;
XftFont* font1;
XftFont* font2;
XGlyphInfo extents1 = { 0 };
XGlyphInfo extents2 = { 0 };
#if !GTK_CHECK_VERSION (3, 0, 0)
GdkPixmap* pixmap;
#endif
XftDraw* draw;
GdkPixbuf* tmp_pixbuf;
GdkPixbuf* pixbuf;
int width, height;
int ascent, descent;
pattern = FcPatternBuild (NULL,
FC_FAMILY, FcTypeString, "Serif",
FC_SLANT, FcTypeInteger, FC_SLANT_ROMAN,
FC_SIZE, FcTypeDouble, 18.,
NULL);
font1 = open_pattern (pattern, antialiasing, hinting);
FcPatternDestroy (pattern);
pattern = FcPatternBuild (NULL,
FC_FAMILY, FcTypeString, "Serif",
FC_SLANT, FcTypeInteger, FC_SLANT_ITALIC,
FC_SIZE, FcTypeDouble, 20.,
NULL);
font2 = open_pattern (pattern, antialiasing, hinting);
FcPatternDestroy (pattern);
ascent = 0;
descent = 0;
if (font1)
{
XftTextExtentsUtf8 (xdisplay, font1, (unsigned char*) string1,
strlen (string1), &extents1);
ascent = MAX (ascent, font1->ascent);
descent = MAX (descent, font1->descent);
}
if (font2)
{
XftTextExtentsUtf8 (xdisplay, font2, (unsigned char*) string2, strlen (string2), &extents2);
ascent = MAX (ascent, font2->ascent);
descent = MAX (descent, font2->descent);
}
width = extents1.xOff + extents2.xOff + 4;
height = ascent + descent + 2;
#if !GTK_CHECK_VERSION (3, 0, 0)
pixmap = gdk_pixmap_new (NULL, width, height, visual->depth);
#endif
#if GTK_CHECK_VERSION (3, 0, 0)
draw = XftDrawCreate (xdisplay, GDK_WINDOW_XID (gdk_screen_get_root_window (gdk_screen_get_default ())), xvisual, xcolormap);
#else
draw = XftDrawCreate (xdisplay, GDK_DRAWABLE_XID (pixmap), xvisual, xcolormap);
#endif
rendcolor.red = 0;
rendcolor.green = 0;
rendcolor.blue = 0;
rendcolor.alpha = 0xffff;
XftColorAllocValue(xdisplay, xvisual, xcolormap, &rendcolor, &black);
rendcolor.red = 0xffff;
rendcolor.green = 0xffff;
rendcolor.blue = 0xffff;
rendcolor.alpha = 0xffff;
XftColorAllocValue(xdisplay, xvisual, xcolormap, &rendcolor, &white);
XftDrawRect(draw, &white, 0, 0, width, height);
if (font1)
{
XftDrawStringUtf8(draw, &black, font1, 2, 2 + ascent, (unsigned char*) string1, strlen(string1));
}
if (font2)
{
XftDrawStringUtf8(draw, &black, font2, 2 + extents1.xOff, 2 + ascent, (unsigned char*) string2, strlen(string2));
}
XftDrawDestroy(draw);
if (font1)
{
XftFontClose(xdisplay, font1);
}
if (font2)
{
XftFontClose(xdisplay, font2);
}
#if GTK_CHECK_VERSION (3, 0, 0)
tmp_pixbuf = gdk_pixbuf_new (GDK_COLORSPACE_RGB, TRUE,8, width, height);
#else
tmp_pixbuf = gdk_pixbuf_get_from_drawable(NULL, pixmap, colormap, 0, 0, 0, 0, width, height);
#endif
pixbuf = gdk_pixbuf_scale_simple(tmp_pixbuf, 1 * width, 1 * height, GDK_INTERP_TILES);
#if !GTK_CHECK_VERSION (3, 0, 0)
g_object_unref(pixmap);
#endif
g_object_unref(tmp_pixbuf);
g_object_set_data_full(G_OBJECT(darea), "sample-pixbuf", pixbuf, (GDestroyNotify) g_object_unref);
#if GTK_CHECK_VERSION (3, 0, 0)
gtk_widget_set_size_request (GTK_WIDGET(darea), width + 2, height + 2);
g_signal_connect(darea, "draw", G_CALLBACK(sample_draw), NULL);
#else
g_signal_connect(darea, "size_request", G_CALLBACK(sample_size_request), NULL);
g_signal_connect(darea, "expose_event", G_CALLBACK(sample_expose), NULL);
#endif
}
