/* initialisation function. */
static tvalue im2_init(Display *disp)
{
Visual *vis;
Colormap cm;
int depth;
imlib_set_cache_size(sequ_config_imlib_cache_size*1048576);
imlib_set_color_usage(sequ_config_imlib_color_usage);
imlib_context_set_dither(sequ_config_imlib_dither);
imlib_context_set_anti_alias(sequ_config_imlib_anti_alias);
if(im2_initialized == TRUE)
return TRUE;
if(!disp)
return FALSE;
vis = DefaultVisual(disp, DefaultScreen(disp));
depth = DefaultDepth(disp, DefaultScreen(disp));
cm = DefaultColormap(disp, DefaultScreen(disp));
imlib_context_set_display(disp);
imlib_context_set_visual(vis);
imlib_context_set_colormap(cm);
im2_initialized=TRUE;
return TRUE;
}
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
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();
}
Imlib_Image gib_imlib_create_cropped_scaled_image(Imlib_Image im, int sx,
int sy, int sw, int sh,
int dw, int dh, char alias)
{
imlib_context_set_image(im);
imlib_context_set_anti_alias(alias);
return imlib_create_cropped_scaled_image(sx, sy, sw, sh, dw, dh);
}
void img_toggle_antialias(img_t *img) {
if (img == NULL || img->im == NULL)
return;
img->aa = !img->aa;
imlib_context_set_image(img->im);
imlib_context_set_anti_alias(img->aa);
img->dirty = true;
}
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
gib_imlib_image_fill_polygon(Imlib_Image im, ImlibPolygon poly, int r, int g,
int b, int a, unsigned char alias, int cx,
int cy, int cw, int ch)
{
imlib_context_set_image(im);
imlib_context_set_color(r, g, b, a);
imlib_context_set_anti_alias(alias);
imlib_context_set_cliprect(cx, cy, cw, ch);
imlib_image_fill_polygon(poly);
imlib_context_set_cliprect(0, 0, 0, 0);
}
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;
}
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 set_font() {
Imlib_Font font;
/* set the font cache to 512Kb - again to avoid re-loading */
imlib_set_font_cache_size(512 * 1024);
/* add the ./ttfonts dir to our font path - you'll want a notepad.ttf */
/* in that dir for the text to display */
imlib_add_path_to_font_path("/usr/share/fonts/TTF");
/* draw text - centered with the current mouse x, y */
font = imlib_load_font("times/10");
if (font) {
/* set the current font */
imlib_context_set_font(font);
imlib_context_set_anti_alias(1);
}
else {
fprintf(stderr, "Font not found: %s\n", "times/8");
}
}
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);
}
int init_x11() {
if ((display = XOpenDisplay(NULL)) == NULL)
dief("cannot open display");
window = XCreateSimpleWindow(display, DefaultRootWindow(display),
x, y, width, height, 0, 0, 0);
XSelectInput(display, window, ExposureMask);
XMapWindow(display, window);
imlib_context_set_dither(1);
imlib_context_set_anti_alias(1);
imlib_context_set_display(display);
imlib_context_set_visual(DefaultVisual(display, DefaultScreen(display)));
imlib_context_set_colormap(DefaultColormap(display, DefaultScreen(display)));
imlib_context_set_drawable(window);
updates = imlib_updates_init();
return ConnectionNumber(display);
}
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;
}
bool img_load(img_t *img, const fileinfo_t *file) {
const char *fmt;
if (img == NULL || file == NULL || file->name == NULL || file->path == NULL)
return false;
if (access(file->path, R_OK) < 0 ||
(img->im = imlib_load_image(file->path)) == NULL)
{
warn("could not open image: %s", file->name);
return false;
}
imlib_context_set_image(img->im);
imlib_image_set_changes_on_disk();
imlib_context_set_anti_alias(img->aa);
fmt = imlib_image_format();
/* avoid unused-but-set-variable warning */
(void) fmt;
#if EXIF_SUPPORT
if (streq(fmt, "jpeg"))
exif_auto_orientate(file);
#endif
#if GIF_SUPPORT
if (streq(fmt, "gif"))
img_load_gif(img, file);
#endif
img->w = imlib_image_get_width();
img->h = imlib_image_get_height();
img->scalemode = options->scalemode;
img->re = false;
img->checkpan = false;
img->dirty = true;
return true;
}
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;
}
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)
{
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;
}
