void XImlib2Image::repaint()
{
XDesktopContainer * xContainer =
dynamic_cast<XDesktopContainer *>(container);
Imlib_Image cropImage = xContainer->bg->createCropImage(x, y, width, height, width, height);
imlib_context_set_dither(1);
imlib_context_set_blend(1); //automatically blend image and background
imlib_context_set_dither_mask(0);
imlib_context_set_image(cropImage);
imlib_blend_image_onto_image(image, 1, 0, 0, width, height, 0, 0, width, height);
imlib_image_set_has_alpha(1);
imlib_context_set_anti_alias(1); //smoother scaling
imlib_context_set_blend(0);
imlib_context_set_drawable(window);
imlib_render_image_on_drawable_at_size(0, 0, width, height);
imlib_free_image();
imlib_context_set_drawable(xContainer->getRootWindow());
}
void render_taskbar(struct task *tasks, struct desktop *desktops)
{
tile_image(theme->tile_img, taskbar_pos, taskbar_width);
int activedesktop = 0;
struct desktop *iter = desktops;
while (iter) {
if (iter->focused)
break;
activedesktop++;
iter = iter->next;
}
struct task *t = tasks;
uint state;
int gap = theme->taskbar.space_gap;
while (t) {
if (t->desktop == activedesktop || t->desktop == -1) {
state = t->focused ? BSTATE_PRESSED : BSTATE_IDLE;
/* draw bg */
draw_taskbar_button(state, t->posx, t->width);
int lgap = get_image_width(theme->taskbar.left_img[state]);
int rgap = get_image_width(theme->taskbar.right_img[state]);
int x = t->posx + gap + lgap;
int w = t->width - ((gap * 2) + lgap + rgap);
/* draw icon */
if (theme->taskbar.icon_h && theme->taskbar.icon_w) {
int srcw, srch;
int y = (theme->height - theme->taskbar.icon_h) / 2;
imlib_context_set_image(t->icon);
srcw = imlib_image_get_width();
srch = imlib_image_get_height();
y += theme->taskbar.icon_offset_y;
x += theme->taskbar.icon_offset_x;
w -= theme->taskbar.icon_offset_x;
imlib_context_set_image(bb);
imlib_context_set_blend(1);
imlib_blend_image_onto_image(t->icon, 1, 0, 0, srcw, srch,
x, y, theme->taskbar.icon_w, theme->taskbar.icon_h);
imlib_context_set_blend(0);
x += theme->taskbar.icon_w;
w -= theme->taskbar.icon_w;
}
/* draw text */
imlib_context_set_cliprect(x, 0, w, bbheight);
draw_text(theme->taskbar.font, theme->taskbar.text_align, x, w,
theme->taskbar.text_offset_x, theme->taskbar.text_offset_y,
t->name, &theme->taskbar.text_color[state]);
imlib_context_set_cliprect(0, 0, bbwidth, bbheight);
/* draw separator if exists */
if (t->next && t->next->desktop == activedesktop)
draw_image(theme->taskbar.separator_img, x+w+gap+rgap);
}
t = t->next;
}
}
void render_present()
{
update_bg();
#ifdef WITH_COMPOSITE
if (theme->use_composite) {
/*
* Because XRender can't do directly SRCc * SRCa + DSTc * (1 - SRCa) blending,
* I must apply SRCa to my SRCc manually. To do this I'm using PictOpSrc with
* alpha channel in mask. So, I need to copy RGB data to one buffer (color) and
* Alpha to another buffer (mask), then use them in XRenderComposite.
*
* But I think in can be done on theme loading stage. Just apply SRCa to SRCc
* immediately. Optimization?
*/
/* copy color part to bbcolor */
imlib_context_set_image(bbcolor);
imlib_image_set_has_alpha(1);
imlib_context_set_color(0,0,0,255);
imlib_image_fill_rectangle(0,0,bbwidth,bbheight);
imlib_blend_image_onto_image(bb,0,0,0,bbwidth,bbheight,0,0,bbwidth,bbheight);
imlib_context_set_drawable(pixcolor);
imlib_render_image_on_drawable(0,0);
/* copy alpha part to bbalpha */
imlib_context_set_image(bbalpha);
imlib_image_copy_alpha_to_image(bb,0,0);
imlib_image_set_has_alpha(1);
imlib_context_set_drawable(pixalpha);
imlib_render_image_on_drawable(0,0);
XRenderComposite(bbdpy,
PictOpSrc,
piccolor,
picalpha,
rootpic,
0, 0, 0, 0, 0, 0, bbwidth,
bbheight);
} else
#endif
if (*rootpmap) {
imlib_context_set_image(bbcolor);
imlib_blend_image_onto_image(bg,0,0,0,bbwidth,bbheight,0,0,bbwidth,bbheight);
imlib_context_set_blend(1);
imlib_blend_image_onto_image(bb,0,0,0,bbwidth,bbheight,0,0,bbwidth,bbheight);
imlib_context_set_blend(0);
imlib_context_set_drawable(bbwin);
imlib_render_image_on_drawable(0,0);
} else {
imlib_context_set_drawable(bbwin);
imlib_context_set_image(bb);
imlib_render_image_on_drawable(0,0);
}
}
void feh_imlib_image_fill_text_bg(Imlib_Image im, int w, int h)
{
gib_imlib_image_set_has_alpha(im, 1);
imlib_context_set_blend(0);
if (opt.text_bg == TEXT_BG_CLEAR)
gib_imlib_image_fill_rectangle(im, 0, 0, w, h, 0, 0, 0, 0);
else
gib_imlib_image_fill_rectangle(im, 0, 0, w, h, 0, 0, 0, 127);
imlib_context_set_blend(1);
}
void image_to_pixmap(image *img, GdkPixmap *pm, int w, int h)
{
int realw, realh;
int need_free;
imlib_context_set_image(img->image);
realw = imlib_image_get_width();
realh = imlib_image_get_height();
if (w != realw || h != realh) {
Imlib_Image newimg;
newimg = imlib_create_cropped_scaled_image(0, 0, realw, realh, w, h);
imlib_context_set_image(newimg);
need_free = TRUE;
} else
need_free = FALSE;
imlib_context_set_display(GDK_WINDOW_XDISPLAY(pm));
imlib_context_set_visual(GDK_VISUAL_XVISUAL(gdk_visual_get_system()));
imlib_context_set_colormap
(GDK_COLORMAP_XCOLORMAP(gdk_colormap_get_system()));
imlib_context_set_drawable(GDK_WINDOW_XWINDOW(pm));
imlib_context_set_blend(1);
imlib_render_image_on_drawable(0, 0);
if (need_free)
imlib_free_image();
}
void
gib_imlib_render_image_part_on_drawable_at_size_with_rotation(Drawable d,
Imlib_Image im,
int sx, int sy,
int sw, int sh,
int dx, int dy,
int dw, int dh,
double angle,
char dither,
char blend,
char alias)
{
Imlib_Image new_im;
imlib_context_set_image(im);
imlib_context_set_drawable(d);
imlib_context_set_anti_alias(alias);
imlib_context_set_dither(dither);
imlib_context_set_angle(angle);
imlib_context_set_blend(blend);
new_im = imlib_create_rotated_image(angle);
imlib_context_set_image(new_im);
imlib_render_image_part_on_drawable_at_size(sx, sy, sw, sh, dx, dy, dw,
dh);
imlib_free_image_and_decache();
}
static void tile_image_blend(Imlib_Image dst, Imlib_Image img, int ox, int width)
{
int curw = get_image_width(img);
imlib_context_set_blend(1);
imlib_context_set_image(dst);
while (width > 0) {
width -= curw;
if (width < 0)
curw += width;
imlib_blend_image_onto_image(img, 0,
0, 0, curw, theme->height,
ox, 0, curw, theme->height);
ox += curw;
}
imlib_context_set_blend(0);
}
void draw_launcher_icon(void *obj, cairo_t *c)
{
LauncherIcon *launcherIcon = (LauncherIcon*)obj;
Imlib_Image icon_scaled = launcherIcon->icon_scaled;
// Render
imlib_context_set_image (icon_scaled);
imlib_context_set_blend(1);
imlib_context_set_drawable(launcherIcon->area.pix);
imlib_render_image_on_drawable(0, 0);
}
void
gib_imlib_render_image_on_drawable(Drawable d, Imlib_Image im, int x, int y,
char dither, char blend, char alias)
{
imlib_context_set_image(im);
imlib_context_set_drawable(d);
imlib_context_set_anti_alias(alias);
imlib_context_set_dither(dither);
imlib_context_set_blend(blend);
imlib_context_set_angle(0);
imlib_render_image_on_drawable(x, y);
}
void
Rterm_draw_screen_string_imlib2(struct R_termscreen *screen, int row, int column, int len)
{
R_text_t *text;
R_textflags_t *textflags;
int bufferrow;
int bgcolor, fgcolor;
int textw, texth;
struct imlib2color *color;
Imlib_Image *textimg;
if (screen == NULL) {
return;
}
text = screen->textbuf.data[screen->viewrow + row] + column;
textflags = screen->textbuf.renddata[screen->viewrow + row] + column;
memcpy(screen->stringbuffer, text, len);
screen->stringbuffer[len] = '\0';
fprintf(stderr, "string: %s\n", screen->stringbuffer);
fgcolor = RTERM_CHAR_FG_COLOR(*textflags);
if (fgcolor) {
color = &screen->im2colors[fgcolor];
} else {
color = &screen->im2colors[RTERM_SCREEN_FOREGROUND];
}
#if 0
fprintf(stderr, "red == %d, green == %d, blue == %d, alpha == %d\n",
color->red, color->green, color->blue, color->alpha);
#endif
imlib_context_set_font(screen->im2font);
imlib_context_set_color(color->red, color->green, color->blue,
color->alpha);
imlib_context_set_drawable(screen->buf);
imlib_get_text_size(screen->stringbuffer,
&textw, &texth);
textimg = imlib_create_image(textw, texth);
imlib_context_set_image(textimg);
imlib_image_clear();
imlib_image_set_has_alpha(1);
imlib_context_set_blend(0);
imlib_context_set_anti_alias(0);
imlib_text_draw(0,
0,
screen->stringbuffer);
imlib_render_image_on_drawable(Rterm_screen_column_x(screen, column),
Rterm_screen_row_y(screen, column));
imlib_free_image();
return;
}
int command_line(int argc, const char **argv) {
if ( !(dpy=XOpenDisplay(0x0)) ) exit(1);
scr = DefaultScreen(dpy); root = DefaultRootWindow(dpy);
sw = DisplayWidth(dpy,scr); sh = DisplayHeight(dpy,scr);
int i; const char *c;
for (i = 1; i < argc; i++) {
if (argv[i][0] != '-') break;
if ( *(c=argv[i]+1) == '-' ) c++;
if (*c == '\0') continue;
if (*c == 'b') win = root;
}
if ( !(img=imlib_load_image(argv[i])) ) exit(2);;
imlib_context_set_image(img);
imlib_context_set_display(dpy);
imlib_context_set_visual(DefaultVisual(dpy,scr));
imlib_context_set_colormap(DefaultColormap(dpy,scr));
iw = imlib_image_get_width();
ih = imlib_image_get_height();
imlib_context_set_anti_alias(0);
imlib_context_set_dither(0);
imlib_context_set_blend(0);
XSetWindowAttributes wa;
if (win == root) {
Pixmap buf = XCreatePixmap(dpy,root,sw,sh,DefaultDepth(dpy,scr));
imlib_context_set_drawable(buf);
imlib_render_image_on_drawable_at_size(0, 0, sw, sh);
wa.background_pixmap = buf;
XSetWindowBackgroundPixmap(dpy,root,buf);
XFlush(dpy);
XFreePixmap(dpy,buf);
XCloseDisplay(dpy);
exit(0);
}
if (iw > mw) scale = mw / (float) iw;
if (ih * scale > mh) scale = mh / (float) ih;
ww = iw * scale + 0.5; wh = ih * scale + 0.5;
wa.background_pixel = BlackPixel(dpy,scr);
wa.event_mask = KeyPressMask | ExposureMask | StructureNotifyMask;
win = XCreateWindow(dpy,root,0,0,ww,wh,0,DefaultDepth(dpy,scr),
InputOutput, DefaultVisual(dpy,scr),CWEventMask|CWBackPixel,&wa);
const char *name;
if ( (name=strrchr(argv[i],'/')) ) name++;
else name = argv[i];
XStoreName(dpy,win,name);
class.res_name = (char *) argv[0];
class.res_class = "float";
XSetClassHint(dpy,win,&class);
XMapWindow(dpy,win); XFlush(dpy);
imlib_context_set_drawable(win);
return 0;
}
static inline PyObject *
ImageObject_blend_image(PyObject* self, PyObject *args, PyObject *kwargs)
{
int merge_alpha = 1;
PyObject *src = NULL;
int src_x = 0, src_y = 0, src_h = -1, src_w = -1;
int dest_x = 0, dest_y = 0, dest_h = -1, dest_w = -1;
Imlib_Image *src_img;
static char *keywords[] = {"img", "src", "dest", "alpha", NULL};
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|(iiii)(iiii)i:blend_image", keywords, &src,
&src_x, &src_y, &src_w, &src_h,
&dest_x, &dest_y, &dest_w, &dest_h, &merge_alpha)){
return NULL;
}
DEBUG("src = %d %d %d %d ", src_x, src_y, src_w, src_h);
DEBUG("dest = %d %d %d %d ", dest_x, dest_y, dest_w, dest_h);
DEBUG("alpha = %d ", merge_alpha);
//check
if(!CheckImageObject(src)){
//TODO raise TypeError
return NULL;
}
src_img = (((ImageObject *)src)->image);
imlib_context_set_image(src_img);
if(src_w == -1){
src_w = imlib_image_get_width();
}
if(src_h == -1){
src_h = imlib_image_get_height();
}
if(dest_w == -1){
dest_w = src_w;
}
if(dest_h == -1){
dest_h = src_h;
}
imlib_context_set_image(((ImageObject *)self)->image);
imlib_context_set_blend(1);
imlib_blend_image_onto_image(src_img, merge_alpha,
src_x, src_y, src_w, src_h,
dest_x, dest_y, dest_w, dest_h);
Py_RETURN_NONE;
}
void
init_imlib(void)
{
bg_image = imlib_load_image("/home/matt/gradient.jpg");
/* imlib settings */
imlib_set_cache_size(2048 * 1024);
imlib_set_color_usage(128);
imlib_context_set_dither(1);
imlib_context_set_blend(1);
imlib_context_set_display(disp);
imlib_context_set_visual(vis);
imlib_context_set_colormap(cm);
}
void
R_init_imlib2(struct R_app *app)
{
imlib_context_set_display(app->display);
imlib_context_set_visual(app->visual);
imlib_context_set_colormap(app->colormap);
imlib_context_set_blend(0);
imlib_context_set_mask(0);
imlib_set_cache_size(IMLIB2_CACHE_SIZE);
imlib_set_font_cache_size(IMLIB2_FONT_CACHE_SIZE);
imlib_add_path_to_font_path(RESURRECTION_FONT_SEARCH_PATH "ttf");
return;
}
void
gib_imlib_blend_image_onto_image(Imlib_Image dest_image,
Imlib_Image source_image, char merge_alpha,
int sx, int sy, int sw, int sh, int dx,
int dy, int dw, int dh, char dither,
char blend, char alias)
{
imlib_context_set_image(dest_image);
imlib_context_set_anti_alias(alias);
imlib_context_set_dither(dither);
imlib_context_set_blend(blend);
imlib_context_set_angle(0);
imlib_blend_image_onto_image(source_image, merge_alpha, sx, sy, sw, sh, dx,
dy, dw, dh);
}
void
gib_imlib_render_image_part_on_drawable_at_size(Drawable d, Imlib_Image im,
int sx, int sy, int sw,
int sh, int dx, int dy,
int dw, int dh, char dither,
char blend, char alias)
{
imlib_context_set_image(im);
imlib_context_set_drawable(d);
imlib_context_set_anti_alias(alias);
imlib_context_set_dither(dither);
imlib_context_set_blend(blend);
imlib_context_set_angle(0);
imlib_render_image_part_on_drawable_at_size(sx, sy, sw, sh, dx, dy, dw,
dh);
}
void init_render(struct xinfo *X, struct panel *P)
{
bbwidth = P->width;
bbheight = P->theme->height;
bb = imlib_create_image(bbwidth, bbheight);
bbcolor = imlib_create_image(bbwidth, bbheight);
imlib_context_set_image(bb);
imlib_image_set_has_alpha(1);
bbdpy = X->display;
bbvis = X->visual;
bbwin = P->win;
bbcm = X->colmap;
bbx = P->x;
bby = P->y;
rootpmap = &X->rootpmap;
theme = P->theme;
imlib_context_set_display(bbdpy);
imlib_context_set_visual(bbvis);
imlib_context_set_colormap(bbcm);
#ifdef WITH_COMPOSITE
if (P->theme->use_composite) {
XRenderPictFormat *fmt = XRenderFindStandardFormat(bbdpy, PictStandardARGB32);
bbalpha = imlib_create_image(bbwidth, bbheight);
pixcolor = XCreatePixmap(bbdpy, bbwin, bbwidth, bbheight, 32);
pixalpha = XCreatePixmap(bbdpy, bbwin, bbwidth, bbheight, 32);
piccolor = XRenderCreatePicture(bbdpy, pixcolor, fmt, 0, 0);
picalpha = XRenderCreatePicture(bbdpy, pixalpha, fmt, 0, 0);
XRenderPictureAttributes pwin;
pwin.subwindow_mode = IncludeInferiors;
rootpic = XRenderCreatePicture(bbdpy, bbwin, XRenderFindVisualFormat(bbdpy, bbvis),
CPSubwindowMode, &pwin);
} else
#endif
if (*rootpmap) {
update_bg();
} else {
set_bg();
}
imlib_context_set_blend(0);
imlib_context_set_operation(IMLIB_OP_COPY);
}
void
gib_imlib_render_image_on_drawable_with_rotation(Drawable d, Imlib_Image im,
int x, int y, double angle,
char dither, char blend,
char alias)
{
Imlib_Image new_im;
imlib_context_set_image(im);
imlib_context_set_anti_alias(alias);
imlib_context_set_dither(dither);
imlib_context_set_blend(blend);
imlib_context_set_angle(angle);
imlib_context_set_drawable(d);
new_im = imlib_create_rotated_image(angle);
imlib_context_set_image(new_im);
imlib_render_image_on_drawable(x, y);
imlib_free_image();
}
void XImlib2Shadow::renderShadowToImage(Pixmap &buffer, int fX, int fY)
{
XIconWithShadow * sIcon = dynamic_cast<XIconWithShadow *>(iconParent);
//sIcon->snapShadow();
x = sIcon->getShadowX();
y = sIcon->getShadowY();
int xCord = x - fX;
int yCord = y - fY;
imlib_context_set_image(image);
imlib_context_set_anti_alias(1); //smoother scaling
imlib_context_set_blend(1); //automatically blend image and background
imlib_context_set_drawable(buffer);
imlib_render_image_on_drawable(xCord, yCord);
}
// TODO icons look too large when the panel is large
void draw_task_icon (Task *tsk, int text_width)
{
if (tsk->icon[tsk->current_state] == 0) return;
// Find pos
int pos_x;
Panel *panel = (Panel*)tsk->area.panel;
if (panel->g_task.centered) {
if (panel->g_task.text)
pos_x = (tsk->area.bounds.width - text_width - panel->g_task.icon_size1) / 2;
else
pos_x = (tsk->area.bounds.width - panel->g_task.icon_size1) / 2;
}
else pos_x = panel->g_task.area.paddingxlr + tsk->area.background->border.width;
// Render
imlib_context_set_image (tsk->icon[tsk->current_state]);
imlib_context_set_blend(1);
imlib_context_set_drawable(tsk->area.pixmap);
imlib_render_image_on_drawable(pos_x, panel->g_task.icon_posy);
}
void
gib_imlib_blend_image_onto_image_with_rotation(Imlib_Image dest_image,
Imlib_Image source_image,
char merge_alpha, int sx,
int sy, int sw, int sh, int dx,
int dy, int dw, int dh,
double angle, char dither,
char blend, char alias)
{
imlib_context_set_image(dest_image);
imlib_context_set_anti_alias(alias);
imlib_context_set_dither(dither);
imlib_context_set_blend(blend);
imlib_context_set_angle(angle);
imlib_blend_image_onto_image_at_angle(source_image, merge_alpha, sx, sy,
sw, sh, dx, dy, (int) angle,
(int) angle);
return;
dw = 0;
dh = 0;
}
int
app_init_imlib2(struct R_app *app)
{
if (app == NULL) {
return -1;
}
imlib_context_set_display(app->display);
imlib_context_set_visual(app->visual);
imlib_context_set_colormap(app->colormap);
imlib_context_set_drawable(app->window->win);
imlib_context_set_blend(0);
imlib_context_set_mask(0);
imlib_set_font_cache_size(1024 * 1024);
#if 0
imlib_add_path_to_font_path(RESURRECTION_FONT_SEARCH_PATH "ttf/");
#endif
imlib_set_cache_size(4096 * 1024);
return 0;
}
void LFSTK_imageClass::LFSTK_clearWindow(void)
{
if(this->wc->useTile==true)
{
XSetTSOrigin(this->display,this->gc,0-this->gadgetGeom.x,0-this->gadgetGeom.y);
XSetFillStyle(this->display,this->gc,FillTiled);
XSetTile(this->display,this->gc,this->wc->tile[0]);
XFillRectangle(this->display,this->window,this->gc,0,0,this->gadgetGeom.w,this->gadgetGeom.h);
XSetFillStyle(this->display,this->gc,FillSolid);
}
else
{
XSetFillStyle(this->display,this->gc,FillSolid);
XSetForeground(this->display,this->gc,this->wc->windowColourNames[NORMALCOLOUR].pixel);
XFillRectangle(this->display,this->window,this->gc,0,0,this->gadgetGeom.w,this->gadgetGeom.h);
}
if(this->gotIcon==true)
{
XSetClipMask(this->display,this->gc,this->icon[1]);
XSetClipOrigin(this->display,this->gc,0,0);
XCopyArea(this->display,this->icon[0],this->window,this->gc,0,0,this->iconSize,this->iconSize,0,0);
XSetClipMask(this->display,this->gc,None);
}
else if(this->useImage==true)
{
imlib_context_set_display(this->display);
imlib_context_set_visual(this->visual);
imlib_context_set_colormap(this->cm);
imlib_context_set_drawable(this->window);
imlib_context_set_image(this->image);
imlib_context_set_blend(1);
imlib_render_image_on_drawable_at_size(4,(this->gadgetGeom.h/2)-(this->imageHeight/2),this->imageWidth,this->imageHeight);
}
}
static int
progress(Imlib_Image im, char percent, int update_x, int update_y,
int update_w, int update_h)
{
/* first time it's called */
imlib_context_set_drawable(pm);
imlib_context_set_anti_alias(0);
imlib_context_set_dither(0);
imlib_context_set_blend(0);
if (image_width == 0)
{
int x, y, onoff;
imlib_context_set_image(im);
image_width = imlib_image_get_width();
image_height = imlib_image_get_height();
if (pm)
XFreePixmap(disp, pm);
pm = XCreatePixmap(disp, win, image_width, image_height, depth);
imlib_context_set_drawable(pm);
if (bg_im)
{
imlib_context_set_image(bg_im);
imlib_free_image_and_decache();
}
bg_im = imlib_create_image(image_width, image_height);
imlib_context_set_image(bg_im);
for (y = 0; y < image_height; y += 8)
{
onoff = (y / 8) & 0x1;
for (x = 0; x < image_width; x += 8)
{
if (onoff)
imlib_context_set_color(144, 144, 144, 255);
else
imlib_context_set_color(100, 100, 100, 255);
imlib_image_fill_rectangle(x, y, 8, 8);
onoff++;
if (onoff == 2)
onoff = 0;
}
}
imlib_render_image_part_on_drawable_at_size(0, 0, image_width,
image_height, 0, 0,
image_width, image_height);
XSetWindowBackgroundPixmap(disp, win, pm);
XResizeWindow(disp, win, image_width, image_height);
XMapWindow(disp, win);
XSync(disp, False);
}
imlib_context_set_anti_alias(0);
imlib_context_set_dither(0);
imlib_context_set_blend(1);
imlib_blend_image_onto_image(im, 0,
update_x, update_y,
update_w, update_h,
update_x, update_y, update_w, update_h);
imlib_context_set_blend(0);
imlib_render_image_part_on_drawable_at_size(update_x, update_y,
update_w, update_h,
update_x, update_y,
update_w, update_h);
XSetWindowBackgroundPixmap(disp, win, pm);
XClearArea(disp, win, update_x, update_y, update_w, update_h, False);
XFlush(disp);
return 1;
}
int
main(int argc, char **argv)
{
Imlib_Image *im = NULL;
char *file = NULL;
int no = 1;
const char *display_name = getenv("DISPLAY");
if (argc < 2)
return 1;
file = argv[no];
if (display_name == NULL)
display_name = ":0";
disp = XOpenDisplay(display_name);
if (disp == NULL)
{
fprintf(stderr, "Can't open display %s\n", display_name);
return 1;
}
vis = DefaultVisual(disp, DefaultScreen(disp));
depth = DefaultDepth(disp, DefaultScreen(disp));
cm = DefaultColormap(disp, DefaultScreen(disp));
win = XCreateSimpleWindow(disp, DefaultRootWindow(disp), 0, 0, 10, 10,
0, 0, 0);
XSelectInput(disp, win, ButtonPressMask | ButtonReleaseMask |
ButtonMotionMask | PointerMotionMask);
imlib_context_set_display(disp);
imlib_context_set_visual(vis);
imlib_context_set_colormap(cm);
imlib_context_set_progress_function(progress);
imlib_context_set_progress_granularity(10);
imlib_context_set_drawable(win);
im = imlib_load_image(file);
while (!im)
{
no++;
if (no == argc)
{
fprintf(stderr, "Image format not available\n");
exit(0);
}
file = argv[no];
image_width = 0;
im = imlib_load_image(file);
imlib_context_set_image(im);
}
if (!im)
{
fprintf(stderr, "Image format not available\n");
exit(0);
}
for (;;)
{
int x, y, b, count, fdsize, xfd, timeout = 0;
XEvent ev;
static int zoom_mode = 0, zx, zy;
static double zoom = 1.0;
struct timeval tval;
fd_set fdset;
double t1;
XFlush(disp);
XNextEvent(disp, &ev);
switch (ev.type)
{
case ButtonPress:
b = ev.xbutton.button;
x = ev.xbutton.x;
y = ev.xbutton.y;
if (b == 3)
{
zoom_mode = 1;
zx = x;
zy = y;
imlib_context_set_drawable(pm);
imlib_context_set_image(bg_im);
imlib_context_set_anti_alias(0);
imlib_context_set_dither(0);
imlib_context_set_blend(0);
imlib_render_image_part_on_drawable_at_size
(0, 0, image_width, image_height,
0, 0, image_width, image_height);
XSetWindowBackgroundPixmap(disp, win, pm);
XClearWindow(disp, win);
}
break;
case ButtonRelease:
b = ev.xbutton.button;
x = ev.xbutton.x;
y = ev.xbutton.y;
if (b == 3)
zoom_mode = 0;
if (b == 1)
{
no++;
if (no == argc)
no = argc - 1;
file = argv[no];
image_width = 0;
zoom = 1.0;
zoom_mode = 0;
imlib_context_set_image(im);
imlib_free_image_and_decache();
im = imlib_load_image(file);
while (!im)
{
no++;
if (no == argc)
exit(0);
file = argv[no];
image_width = 0;
im = imlib_load_image(file);
}
imlib_context_set_image(im);
}
if (b == 2)
{
no--;
if (no == 0)
no = 1;
file = argv[no];
image_width = 0;
zoom = 1.0;
zoom_mode = 0;
imlib_context_set_image(im);
imlib_free_image_and_decache();
im = imlib_load_image(file);
while (!im)
{
no--;
if (no == 0)
no = 1;
file = argv[no];
image_width = 0;
im = imlib_load_image(file);
}
imlib_context_set_image(im);
}
break;
case MotionNotify:
while (XCheckTypedWindowEvent(disp, win, MotionNotify, &ev));
x = ev.xmotion.x;
y = ev.xmotion.y;
if (zoom_mode)
{
int sx, sy, sw, sh, dx, dy, dw, dh;
zoom = ((double)x - (double)zx) / 32.0;
if (zoom < 0)
zoom = 1.0 + ((zoom * 32.0) / ((double)(zx + 1)));
else
zoom += 1.0;
if (zoom <= 0.0001)
zoom = 0.0001;
if (zoom > 1.0)
{
dx = 0;
dy = 0;
dw = image_width;
dh = image_height;
sx = zx - (zx / zoom);
sy = zy - (zy / zoom);
sw = image_width / zoom;
sh = image_height / zoom;
}
else
{
dx = zx - (zx * zoom);
dy = zy - (zy * zoom);
dw = image_width * zoom;
dh = image_height * zoom;
sx = 0;
sy = 0;
sw = image_width;
sh = image_height;
}
imlib_context_set_anti_alias(0);
imlib_context_set_dither(0);
imlib_context_set_blend(0);
imlib_context_set_image(bg_im);
imlib_render_image_part_on_drawable_at_size
(sx, sy, sw, sh, dx, dy, dw, dh);
XSetWindowBackgroundPixmap(disp, win, pm);
XClearWindow(disp, win);
XFlush(disp);
timeout = 1;
}
default:
break;
}
t1 = 0.2;
tval.tv_sec = (long)t1;
tval.tv_usec = (long)((t1 - ((double)tval.tv_sec)) * 1000000);
xfd = ConnectionNumber(disp);
fdsize = xfd + 1;
FD_ZERO(&fdset);
FD_SET(xfd, &fdset);
if (timeout)
count = select(fdsize, &fdset, NULL, NULL, &tval);
else
count = select(fdsize, &fdset, NULL, NULL, NULL);
if (count < 0)
{
if ((errno == ENOMEM) || (errno == EINVAL) || (errno == EBADF))
exit(1);
}
else
{
if ((count == 0) && (timeout))
{
int sx, sy, sw, sh, dx, dy, dw, dh;
if (zoom > 1.0)
{
dx = 0;
dy = 0;
dw = image_width;
dh = image_height;
sx = zx - (zx / zoom);
sy = zy - (zy / zoom);
sw = image_width / zoom;
sh = image_height / zoom;
}
else
{
dx = zx - (zx * zoom);
dy = zy - (zy * zoom);
dw = image_width * zoom;
dh = image_height * zoom;
sx = 0;
sy = 0;
sw = image_width;
sh = image_height;
}
imlib_context_set_anti_alias(1);
imlib_context_set_dither(1);
imlib_context_set_blend(0);
imlib_context_set_image(bg_im);
imlib_render_image_part_on_drawable_at_size
(sx, sy, sw, sh, dx, dy, dw, dh);
XSetWindowBackgroundPixmap(disp, win, pm);
XClearWindow(disp, win);
XFlush(disp);
timeout = 0;
}
}
}
return 0;
}
int
main(int argc, char **argv)
{
int w, h, tw, th;
Imlib_Image im_bg = NULL;
XEvent ev;
KeySym keysym;
static char kbuf[20];
Imlib_Font font;
Imlib_Color_Range range;
const char *display_name = getenv("DISPLAY");
/**
* First tests to determine which rendering task to perform
*/
if (display_name == NULL)
display_name = ":0";
disp = XOpenDisplay(display_name);
if (disp == NULL)
{
fprintf(stderr, "Can't open display %s\n", display_name);
return 1;
}
vis = DefaultVisual(disp, DefaultScreen(disp));
depth = DefaultDepth(disp, DefaultScreen(disp));
cm = DefaultColormap(disp, DefaultScreen(disp));
win =
XCreateSimpleWindow(disp, DefaultRootWindow(disp), 0, 0, 100, 100, 0, 0,
0);
XSelectInput(disp, win,
ButtonPressMask | ButtonReleaseMask | ButtonMotionMask |
PointerMotionMask | ExposureMask | KeyPressMask);
XMapWindow(disp, win);
/**
* Start rendering
*/
imlib_set_font_cache_size(512 * 1024);
imlib_add_path_to_font_path(PACKAGE_DATA_DIR"/data/fonts");
imlib_context_set_display(disp);
imlib_context_set_visual(vis);
imlib_context_set_colormap(cm);
imlib_context_set_drawable(win);
imlib_context_set_blend(0);
imlib_context_set_color_modifier(NULL);
imlib_context_set_blend(0);
im_bg = imlib_create_image(600, 400);
imlib_context_set_image(im_bg);
w = imlib_image_get_width();
h = imlib_image_get_height();
imlib_context_set_color(128, 128, 255, 255);
imlib_image_fill_rectangle(0, 0, w, h);
XResizeWindow(disp, win, w, h);
XSync(disp, False);
while (1)
{
do
{
XNextEvent(disp, &ev);
switch (ev.type)
{
case ButtonRelease:
exit(0);
break;
case KeyPress:
XLookupString(&ev.xkey, (char *)kbuf, sizeof(kbuf), &keysym,
NULL);
switch (*kbuf)
{
case 'q':
exit(0);
default:
break;
}
break;
default:
break;
}
}
while (XPending(disp));
imlib_context_set_image(im_bg);
imlib_context_set_color(128, 128, 255, 255);
imlib_image_fill_rectangle(0, 0, w, h);
imlib_context_set_color(0, 0, 0, 255);
imlib_image_draw_rectangle(20, 20, 560, 140);
imlib_image_draw_rectangle(20, 220, 560, 140);
font = imlib_load_font("notepad/15");
if (font)
{
char text[4096];
imlib_context_set_font(font);
imlib_context_set_color(0, 0, 0, 255);
sprintf(text, "RGBA range, 2 points, from red to magenta");
imlib_get_text_size(text, &tw, &th);
imlib_text_draw(300 - tw / 2, 180 - th / 2, text);
sprintf(text, "HSVA range, 2 points, from red to magenta");
imlib_get_text_size(text, &tw, &th);
imlib_text_draw(300 - tw / 2, 380 - th / 2, text);
imlib_free_font();
}
/* Draw rectangle w/ RGBA gradient */
range = imlib_create_color_range();
imlib_context_set_color_range(range);
imlib_context_set_color(255, 0, 0, 255);
imlib_add_color_to_color_range(0);
imlib_context_set_color(255, 0, 255, 255);
imlib_add_color_to_color_range(20);
imlib_image_fill_color_range_rectangle(21, 21, 558, 138, -90.0);
imlib_free_color_range();
/* Draw rectangle w/ HSVA gradient */
range = imlib_create_color_range();
imlib_context_set_color_range(range);
imlib_context_set_color_hsva(0, 1, 1, 255);
imlib_add_color_to_color_range(0);
imlib_context_set_color_hsva(300, 1, 1, 255);
imlib_add_color_to_color_range(20);
imlib_image_fill_hsva_color_range_rectangle(21, 221, 558, 138, -90.0);
imlib_free_color_range();
imlib_render_image_on_drawable(0, 0);
}
return 0;
}
int
main(int argc, char **argv)
{
int w, h;
Imlib_Image im_bg = NULL;
XEvent ev;
KeySym keysym;
static char kbuf[20];
ImlibPolygon poly, poly1, poly2;
const char *display_name = getenv("DISPLAY");
/**
* First tests to determine which rendering task to perform
*/
if (display_name == NULL)
display_name = ":0";
disp = XOpenDisplay(display_name);
if (disp == NULL)
{
fprintf(stderr, "Can't open display %s\n", display_name);
return 1;
}
vis = DefaultVisual(disp, DefaultScreen(disp));
depth = DefaultDepth(disp, DefaultScreen(disp));
cm = DefaultColormap(disp, DefaultScreen(disp));
win =
XCreateSimpleWindow(disp, DefaultRootWindow(disp), 0, 0, 100, 100, 0, 0,
0);
XSelectInput(disp, win,
ButtonPressMask | ButtonReleaseMask | ButtonMotionMask |
PointerMotionMask | ExposureMask | KeyPressMask);
XMapWindow(disp, win);
/**
* Start rendering
*/
imlib_context_set_display(disp);
imlib_context_set_visual(vis);
imlib_context_set_colormap(cm);
imlib_context_set_drawable(win);
imlib_context_set_blend(0);
imlib_context_set_color_modifier(NULL);
imlib_context_set_blend(0);
im_bg = imlib_create_image(400, 400);
imlib_context_set_image(im_bg);
w = imlib_image_get_width();
h = imlib_image_get_height();
imlib_context_set_color(0, 0, 0, 255);
imlib_image_fill_rectangle(0, 0, w, h);
XResizeWindow(disp, win, w, h);
XSync(disp, False);
poly = imlib_polygon_new();
imlib_polygon_add_point(poly, 20, 20);
imlib_polygon_add_point(poly, 70, 20);
imlib_polygon_add_point(poly, 70, 70);
imlib_polygon_add_point(poly, 20, 70);
poly1 = imlib_polygon_new();
imlib_polygon_add_point(poly1, 100, 20);
imlib_polygon_add_point(poly1, 190, 100);
imlib_polygon_add_point(poly1, 120, 70);
poly2 = imlib_polygon_new();
imlib_polygon_add_point(poly2, 290, 20);
imlib_polygon_add_point(poly2, 200, 100);
imlib_polygon_add_point(poly2, 270, 70);
while (1)
{
do
{
XNextEvent(disp, &ev);
switch (ev.type)
{
case ButtonRelease:
exit(0);
break;
case KeyPress:
XLookupString(&ev.xkey, (char *)kbuf, sizeof(kbuf), &keysym,
NULL);
switch (*kbuf)
{
case ' ':
imlib_context_set_anti_alias
(!imlib_context_get_anti_alias());
printf("AA is %s\n",
imlib_context_get_anti_alias()? "on" : "off");
break;
case 'q':
exit(0);
default:
break;
}
break;
default:
break;
}
}
while (XPending(disp));
imlib_context_set_image(im_bg);
imlib_context_set_color(0, 0, 0, 255);
imlib_image_fill_rectangle(0, 0, w, h);
imlib_context_set_color(255, 255, 255, 255);
imlib_image_fill_polygon(poly);
imlib_image_fill_polygon(poly1);
imlib_image_fill_polygon(poly2);
imlib_render_image_on_drawable(0, 0);
}
return 0;
}
/* TODO s/bit/lot */
void init_thumbnail_mode(void)
{
/* moved to thumbnail_data:
Imlib_Image im_main;
Imlib_Image bg_im = NULL;
Imlib_Font fn = NULL;
Imlib_Font title_fn = NULL;
int w = 800, h = 600;
int bg_w = 0, bg_h = 0;
int text_area_w, text_area_h;
int max_column_w = 0;
*/
Imlib_Image im_temp;
int ww = 0, hh = 0, www, hhh, xxx, yyy;
int x = 0, y = 0;
winwidget winwid = NULL;
Imlib_Image im_thumb = NULL;
unsigned char trans_bg = 0;
int title_area_h = 0;
int tw = 0, th = 0;
int fw_name, fw_size, fw_dim, fh;
int thumbnailcount = 0;
feh_file *file = NULL;
gib_list *l, *last = NULL;
int lines;
int index_image_width, index_image_height;
int x_offset_name = 0, x_offset_dim = 0, x_offset_size = 0;
char *s;
unsigned int thumb_counter = 0;
/* initialize thumbnail mode data */
td.im_main = NULL;
td.im_bg = NULL;
td.font_main = NULL;
td.font_title = NULL;
td.w = 640;
td.h = 480;
td.bg_w = 0;
td.bg_h = 0;
td.thumb_tot_h = 0;
td.text_area_w = 0;
td.text_area_h = 0;
td.vertical = 0;
td.max_column_w = 0;
mode = "thumbnail";
if (opt.font)
td.font_main = gib_imlib_load_font(opt.font);
if (!td.font_main)
td.font_main = gib_imlib_load_font(DEFAULT_FONT);
if (opt.title_font) {
int fh, fw;
td.font_title = gib_imlib_load_font(opt.title_font);
gib_imlib_get_text_size(td.font_title, "W", NULL, &fw, &fh,
IMLIB_TEXT_TO_RIGHT);
title_area_h = fh + 4;
} else
td.font_title = imlib_load_font(DEFAULT_FONT_TITLE);
if ((!td.font_main) || (!td.font_title))
eprintf("Error loading fonts");
/* Work out how tall the font is */
gib_imlib_get_text_size(td.font_main, "W", NULL, &tw, &th,
IMLIB_TEXT_TO_RIGHT);
/* For now, allow room for the right number of lines with small gaps */
td.text_area_h = ((th + 2) * (opt.index_show_name + opt.index_show_size +
opt.index_show_dim)) + 5;
/* This includes the text area for index data */
td.thumb_tot_h = opt.thumb_h + td.text_area_h;
/* Use bg image dimensions for default size */
if (opt.bg && opt.bg_file) {
if (!strcmp(opt.bg_file, "trans"))
trans_bg = 1;
else {
D(3, ("Time to apply a background to blend onto\n"));
if (feh_load_image_char(&td.im_bg, opt.bg_file) != 0) {
td.bg_w = gib_imlib_image_get_width(td.im_bg);
td.bg_h = gib_imlib_image_get_height(td.im_bg);
}
}
}
/* figure out geometry for the main window and entries */
feh_thumbnail_calculate_geometry();
index_image_width = td.w;
index_image_height = td.h + title_area_h;
td.im_main = imlib_create_image(index_image_width, index_image_height);
gib_imlib_image_set_has_alpha(td.im_main, 1);
if (!td.im_main)
eprintf("Imlib error creating index image, are you low on RAM?");
if (td.im_bg)
gib_imlib_blend_image_onto_image(td.im_main, td.im_bg,
gib_imlib_image_has_alpha
(td.im_bg), 0, 0, td.bg_w, td.bg_h, 0, 0,
td.w, td.h, 1, 0, 0);
else if (trans_bg) {
gib_imlib_image_fill_rectangle(td.im_main, 0, 0, td.w,
td.h + title_area_h, 0, 0, 0, 0);
gib_imlib_image_set_has_alpha(td.im_main, 1);
} else {
/* Colour the background */
gib_imlib_image_fill_rectangle(td.im_main, 0, 0, td.w,
td.h + title_area_h, 0, 0, 0, 255);
}
/* Create title now */
if (!opt.title)
s = estrdup(PACKAGE " [thumbnail mode]");
else
s = estrdup(feh_printf(opt.title, NULL));
if (opt.display) {
winwid = winwidget_create_from_image(td.im_main, s, WIN_TYPE_THUMBNAIL);
winwidget_show(winwid);
}
/* make sure we have an ~/.thumbnails/normal directory for storing
permanent thumbnails */
td.cache_thumbnails = opt.cache_thumbnails;
if (td.cache_thumbnails) {
if (opt.thumb_w > opt.thumb_h)
td.cache_dim = opt.thumb_w;
else
td.cache_dim = opt.thumb_h;
if (td.cache_dim > 256) {
/* No caching as specified by standard. Sort of. */
td.cache_thumbnails = 0;
} else if (td.cache_dim > 128) {
td.cache_dim = 256;
td.cache_dir = estrdup("large");
} else {
td.cache_dim = 128;
td.cache_dir = estrdup("normal");
}
feh_thumbnail_setup_thumbnail_dir();
}
for (l = filelist; l; l = l->next) {
file = FEH_FILE(l->data);
if (last) {
filelist = feh_file_remove_from_list(filelist, last);
last = NULL;
}
D(4, ("About to load image %s\n", file->filename));
/* if (feh_load_image(&im_temp, file) != 0) */
if (feh_thumbnail_get_thumbnail(&im_temp, file) != 0) {
if (opt.verbose)
feh_display_status('.');
D(4, ("Successfully loaded %s\n", file->filename));
www = opt.thumb_w;
hhh = opt.thumb_h;
ww = gib_imlib_image_get_width(im_temp);
hh = gib_imlib_image_get_height(im_temp);
thumbnailcount++;
if (gib_imlib_image_has_alpha(im_temp))
imlib_context_set_blend(1);
else
imlib_context_set_blend(0);
if (opt.aspect) {
double ratio = 0.0;
/* Keep the aspect ratio for the thumbnail */
ratio = ((double) ww / hh) / ((double) www / hhh);
if (ratio > 1.0)
hhh = opt.thumb_h / ratio;
else if (ratio != 1.0)
www = opt.thumb_w * ratio;
}
if ((!opt.stretch) && ((www > ww) || (hhh > hh))) {
/* Don't make the image larger unless stretch is specified */
www = ww;
hhh = hh;
}
im_thumb = gib_imlib_create_cropped_scaled_image(im_temp, 0, 0,
ww, hh, www, hhh, 1);
gib_imlib_free_image_and_decache(im_temp);
if (opt.alpha) {
DATA8 atab[256];
D(3, ("Applying alpha options\n"));
gib_imlib_image_set_has_alpha(im_thumb, 1);
memset(atab, opt.alpha_level, sizeof(atab));
gib_imlib_apply_color_modifier_to_rectangle
(im_thumb, 0, 0, www, hhh, NULL, NULL, NULL, atab);
}
td.text_area_w = opt.thumb_w;
/* Now draw on the info text */
if (opt.index_show_name) {
gib_imlib_get_text_size(td.font_main, file->name, NULL,
&fw_name, &fh, IMLIB_TEXT_TO_RIGHT);
if (fw_name > td.text_area_w)
td.text_area_w = fw_name;
}
if (opt.index_show_dim) {
gib_imlib_get_text_size(td.font_main,
create_index_dimension_string(ww, hh),
NULL, &fw_dim, &fh, IMLIB_TEXT_TO_RIGHT);
if (fw_dim > td.text_area_w)
td.text_area_w = fw_dim;
}
if (opt.index_show_size) {
gib_imlib_get_text_size(td.font_main,
create_index_size_string(file->filename),
NULL, &fw_size, &fh, IMLIB_TEXT_TO_RIGHT);
if (fw_size > td.text_area_w)
td.text_area_w = fw_size;
}
if (td.text_area_w > opt.thumb_w)
td.text_area_w += 5;
/* offsets for centering text */
x_offset_name = (td.text_area_w - fw_name) / 2;
x_offset_dim = (td.text_area_w - fw_dim) / 2;
x_offset_size = (td.text_area_w - fw_size) / 2;
if (td.vertical) {
if (td.text_area_w > td.max_column_w)
td.max_column_w = td.text_area_w;
if (y > td.h - td.thumb_tot_h) {
y = 0;
x += td.max_column_w;
td.max_column_w = 0;
}
if (x > td.w - td.text_area_w)
break;
} else {
if (x > td.w - td.text_area_w) {
x = 0;
y += td.thumb_tot_h;
}
if (y > td.h - td.thumb_tot_h)
break;
}
/* center image relative to the text below it (if any) */
xxx = x + ((td.text_area_w - www) / 2);
yyy = y;
if (opt.aspect)
yyy += (opt.thumb_h - hhh) / 2;
/* Draw now */
gib_imlib_blend_image_onto_image(td.im_main,
im_thumb,
gib_imlib_image_has_alpha
(im_thumb), 0, 0,
www, hhh, xxx,
yyy, www, hhh, 1,
gib_imlib_image_has_alpha(im_thumb), 0);
thumbnails = gib_list_add_front(thumbnails,
feh_thumbnail_new(file, xxx, yyy, www, hhh));
gib_imlib_free_image_and_decache(im_thumb);
lines = 0;
if (opt.index_show_name)
gib_imlib_text_draw(td.im_main,
td.font_main, NULL,
x + x_offset_name,
y + opt.thumb_h + (lines++ * (th + 2)) + 2,
file->name, IMLIB_TEXT_TO_RIGHT,
255, 255, 255, 255);
if (opt.index_show_dim)
gib_imlib_text_draw(td.im_main,
td.font_main, NULL,
x + x_offset_dim,
y + opt.thumb_h + (lines++ * (th + 2)) + 2,
create_index_dimension_string(ww, hh),
IMLIB_TEXT_TO_RIGHT, 255, 255, 255, 255);
if (opt.index_show_size)
gib_imlib_text_draw(td.im_main,
td.font_main, NULL,
x + x_offset_size,
y + opt.thumb_h + (lines++ * (th + 2)) + 2,
create_index_size_string(file->filename),
IMLIB_TEXT_TO_RIGHT, 255, 255, 255, 255);
if (td.vertical)
y += td.thumb_tot_h;
else
x += td.text_area_w;
} else {
if (opt.verbose)
feh_display_status('x');
last = l;
}
if (opt.display) {
/* thumb_counter is unsigned, so no need to catch overflows */
if (++thumb_counter == opt.thumb_redraw) {
winwidget_render_image(winwid, 0, 0);
thumb_counter = 0;
}
if (!feh_main_iteration(0))
exit(0);
}
}
if (thumb_counter != 0)
winwidget_render_image(winwid, 0, 0);
if (opt.verbose)
fprintf(stdout, "\n");
if (opt.title_font) {
int fw, fh, fx, fy;
char *s;
s = create_index_title_string(thumbnailcount, td.w, td.h);
gib_imlib_get_text_size(td.font_title, s, NULL, &fw, &fh,
IMLIB_TEXT_TO_RIGHT);
fx = (index_image_width - fw) >> 1;
fy = index_image_height - fh - 2;
gib_imlib_text_draw(td.im_main, td.font_title, NULL, fx,
fy, s, IMLIB_TEXT_TO_RIGHT, 255, 255, 255, 255);
}
int
image_render_imlib2(Drawable drawable, struct R_image *image, int w, int h)
{
Window dummyw;
Imlib_Image img;
Imlib_Border *border;
Imlib_Color_Modifier colormod;
Pixmap pixmap;
Pixmap mask;
int origw, origh;
int neww, newh;
int dummyi;
unsigned int drawablew, drawableh;
unsigned int dummyui;
if (image == NULL) {
return -1;
}
if (image->im2img == NULL) {
image_load_data_imlib2(image);
}
pixmap = None;
mask = None;
img = image->im2img;
if (img) {
imlib_context_set_drawable(drawable);
imlib_context_set_image(img);
imlib_context_set_mask(image->maskpixmap);
imlib_context_set_blend(0);
border = &image->im2border;
imlib_image_set_border(border);
if (w == -1 || h == -1) {
XGetGeometry(Rglobals.app->display,
drawable,
&dummyw,
&dummyi, &dummyi,
&drawablew, &drawableh,
&dummyui,
&dummyui);
}
origw = imlib_image_get_width();
image->origw = origw;
if (w == 0) {
neww = origw;
} else if (w == -1) {
neww = drawablew;
} else {
neww = w;
}
origh = imlib_image_get_height();
image->origh = origh;
if (h == 0) {
newh = origh;
} else if (h == -1) {
newh = drawableh;
} else {
newh = h;
}
colormod = image->im2colormods[IMAGE_COLOR_MODIFIER];
if (colormod == NULL) {
colormod = imlib_create_color_modifier();
image->im2colormods[IMAGE_COLOR_MODIFIER] = colormod;
}
imlib_context_set_color_modifier(colormod);
imlib_render_pixmaps_for_whole_image_at_size(&pixmap, &mask, neww, newh);
if (image->pixmap) {
imlib_free_pixmap_and_mask(image->pixmap);
image->pixmap = None;
image->maskpixmap = None;
}
image->pixmap = pixmap;
image->maskpixmap = mask;
#if 0
image->flags |= IMAGE_KEEP_PIXMAP;
image_destroy_data_imlib2(image);
#endif
}
return 0;
}
int
main(int argc, char **argv)
{
int w, h, x, y;
Imlib_Image im = NULL, im_bg = NULL;
XEvent ev;
const char *display_name = getenv("DISPLAY");
/**
* Initialization according to options
*/
printf("Initialising\n");
/**
* First tests to determine which rendering task to perform
*/
if (display_name == NULL)
display_name = ":0";
disp = XOpenDisplay(display_name);
if (disp == NULL)
{
fprintf(stderr, "Can't open display %s\n", display_name);
return 1;
}
vis = DefaultVisual(disp, DefaultScreen(disp));
depth = DefaultDepth(disp, DefaultScreen(disp));
cm = DefaultColormap(disp, DefaultScreen(disp));
win =
XCreateSimpleWindow(disp, DefaultRootWindow(disp), 0, 0, 100, 100, 0, 0,
0);
XSelectInput(disp, win,
ButtonPressMask | ButtonReleaseMask | ButtonMotionMask |
PointerMotionMask | ExposureMask);
XMapWindow(disp, win);
/**
* Start rendering
*/
printf("Rendering\n");
imlib_context_set_display(disp);
imlib_context_set_visual(vis);
imlib_context_set_colormap(cm);
imlib_context_set_drawable(win);
imlib_context_set_dither(1);
imlib_context_set_blend(0);
imlib_context_set_color_modifier(NULL);
im_bg = imlib_load_image(PACKAGE_DATA_DIR"/data/images/imlib2.png");
im = imlib_load_image(PACKAGE_DATA_DIR"/data/images/imlib2.png");
imlib_context_set_image(im_bg);
w = imlib_image_get_width();
h = imlib_image_get_height();
printf("Resizing Window to %d by %d\n", w, h);
XResizeWindow(disp, win, w, h);
XSync(disp, False);
x = -9999;
y = -9999;
while (1)
{
Imlib_Image *temp, *temp2;
do
{
XNextEvent(disp, &ev);
switch (ev.type)
{
case Expose:
break;
case ButtonRelease:
exit(0);
break;
case MotionNotify:
x = ev.xmotion.x;
y = ev.xmotion.y;
default:
break;
}
}
while (XPending(disp));
imlib_context_set_blend(0);
imlib_context_set_image(im_bg);
temp = imlib_clone_image();
imlib_context_set_image(temp);
/* imlib_blend_image_onto_image(im_bg, 0,
* 0, 0, w, h,
* 0, 0, w, h);
* first = 0; */
imlib_apply_filter
("bump_map_point(x=[],y=[],map="PACKAGE_DATA_DIR"/data/images/imlib2.png);", &x, &y);
temp2 = im_bg;
im_bg = temp;
imlib_context_set_image(im_bg);
imlib_render_image_on_drawable(0, 0);
im_bg = temp2;
imlib_context_set_image(temp);
imlib_free_image();
}
return 0;
}
