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);
}
}
ExcCode screen_cursor_blend(int x, int y, Imlib_Image image) {
xcb_xfixes_get_cursor_image_cookie_t cookie =
xcb_xfixes_get_cursor_image(display);
xcb_xfixes_get_cursor_image_reply_t *reply =
xcb_xfixes_get_cursor_image_reply(display, cookie, NULL);
if (reply == NULL)
return 0;
unsigned *cursor_data = xcb_xfixes_get_cursor_image_cursor_image(reply);
if (cursor_data == NULL)
return 0;
Imlib_Image cursor = imlib_create_image_using_data(
reply->width, reply->height,
cursor_data);
if (cursor == NULL)
PANIC(ERR_IMAGE);
imlib_context_set_image(cursor);
imlib_image_set_has_alpha(1);
imlib_context_set_image(image);
imlib_blend_image_onto_image(cursor, 0, 0, 0, reply->width, reply->height,
reply->x - reply->xhot - x, reply->y - reply->yhot - y,
reply->width, reply->height);
imlib_context_set_image(cursor);
imlib_free_image_and_decache();
free(reply);
return 0;
}
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;
}
}
static void draw_image(Imlib_Image img, int ox)
{
if (!img)
return;
int curw = get_image_width(img);
imlib_context_set_image(bb);
imlib_blend_image_onto_image(img, 1,
0, 0, curw, theme->height,
ox, 0, curw, theme->height);
}
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
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);
}
static void tile_image(Imlib_Image img, int ox, int width)
{
int curw = get_image_width(img);
imlib_context_set_image(bb);
while (width > 0) {
width -= curw;
if (width < 0)
curw += width;
imlib_blend_image_onto_image(img, 1,
0, 0, curw, theme->height,
ox, 0, curw, theme->height);
ox += curw;
}
}
static tvalue im2_blend(struct sequ_image *from, struct sequ_image *to,
int x, int y, int w, int h)
{
if(!from || !to)
return FALSE;
imlib_context_set_image((Imlib_Image)to->privdata);
imlib_blend_image_onto_image((Imlib_Image)from->privdata,
0,0,0,
from->width,from->height,x,y,w,h);
print_debug("%s: kuvan osoite on %p\n",THIS_FUNCTION,
(Imlib_Image)from->privdata);
return TRUE;
}
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;
}
ngx_int_t ngx_http_small_light_imlib2_process(ngx_http_request_t *r, ngx_http_small_light_ctx_t *ctx)
{
ngx_http_small_light_imlib2_ctx_t *ictx;
ngx_http_small_light_image_size_t sz;
Imlib_Image image_org, image_dst, image_tmp;
Imlib_Load_Error err;
ngx_file_info_t fi;
ngx_fd_t fd;
char *filename, *sharpen, *blur, *of, *buf;
void *data;
int w, h, radius, orientation;
double iw, ih, q;
ngx_int_t type;
const char *ext;
ssize_t size;
ictx = (ngx_http_small_light_imlib2_ctx_t *)ctx->ictx;
filename = (char *)ictx->tf->file.name.data;
/* adjust image size */
ngx_http_small_light_calc_image_size(r, ctx, &sz, 10000.0, 10000.0);
if (sz.jpeghint_flg != 0) {
if (ngx_http_small_light_load_jpeg((void**)&data, &w, &h, r, filename, sz.dw, sz.dh) != NGX_OK) {
image_org = imlib_load_image_immediately_without_cache(filename);
if (image_org == NULL) {
ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
"failed to load image %s:%d",
__FUNCTION__,
__LINE__);
return NGX_ERROR;
}
} else {
image_org = imlib_create_image_using_data(w, h, data);
}
} else {
image_org = imlib_load_image_immediately_without_cache(filename);
if (image_org == NULL) {
ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
"failed to load image %s:%d",
__FUNCTION__,
__LINE__);
return NGX_ERROR;
}
}
/* rotate. */
if (sz.angle) {
orientation = 0;
switch (sz.angle) {
case 90:
orientation = 1;
break;
case 180:
orientation = 2;
break;
case 270:
orientation = 3;
break;
default:
ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
"image not rotated. 'angle'(%d) must be 90 or 180 or 270. %s:%d",
sz.angle,
__FUNCTION__,
__LINE__);
break;
}
imlib_context_set_image(image_org);
imlib_image_orientate(orientation);
}
/* calc size. */
imlib_context_set_image(image_org);
iw = (double)imlib_image_get_width();
ih = (double)imlib_image_get_height();
ngx_http_small_light_calc_image_size(r, ctx, &sz, iw, ih);
/* pass through. */
if (sz.pt_flg != 0) {
ctx->of = ctx->inf;
return NGX_OK;
}
/* crop, scale. */
if (sz.scale_flg != 0) {
image_dst = imlib_create_cropped_scaled_image((int)sz.sx, (int)sz.sy, (int)sz.sw, (int)sz.sh, (int)sz.dw, (int)sz.dh);
imlib_context_set_image(image_org);
imlib_free_image();
} else {
image_dst = image_org;
}
if (image_dst == NULL) {
ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
"imlib_create_cropped_scaled_image failed. %s:%d",
__FUNCTION__,
__LINE__);
return NGX_ERROR;
}
/* create canvas then draw image to the canvas. */
if (sz.cw > 0.0 && sz.ch > 0.0) {
image_tmp = imlib_create_image(sz.cw, sz.ch);
if (image_tmp == NULL) {
imlib_context_set_image(image_dst);
imlib_free_image();
return NGX_ERROR;
}
imlib_context_set_image(image_tmp);
imlib_context_set_color(sz.cc.r, sz.cc.g, sz.cc.b, sz.cc.a);
imlib_image_fill_rectangle(0, 0, sz.cw, sz.ch);
imlib_blend_image_onto_image(image_dst, 255, 0, 0,
(int)sz.dw, (int)sz.dh, (int)sz.dx, (int)sz.dy, (int)sz.dw, (int)sz.dh);
imlib_context_set_image(image_dst);
imlib_free_image();
image_dst = image_tmp;
}
/* effects. */
sharpen = NGX_HTTP_SMALL_LIGHT_PARAM_GET_LIT(&ctx->hash, "sharpen");
if (sharpen) {
radius = ngx_http_small_light_parse_int(sharpen);
if (radius > 0) {
imlib_context_set_image(image_dst);
imlib_image_sharpen(radius);
}
}
blur = NGX_HTTP_SMALL_LIGHT_PARAM_GET_LIT(&ctx->hash, "blur");
if (blur) {
radius = ngx_http_small_light_parse_int(blur);
if (radius > 0) {
imlib_context_set_image(image_dst);
imlib_image_blur(radius);
}
}
/* border. */
if (sz.bw > 0.0 || sz.bh > 0.0) {
imlib_context_set_color(sz.bc.r, sz.bc.g, sz.bc.b, sz.bc.a);
imlib_context_set_image(image_dst);
if (sz.cw > 0.0 && sz.ch > 0.0) {
imlib_image_fill_rectangle(0, 0, sz.cw, sz.bh);
imlib_image_fill_rectangle(0, 0, sz.bw, sz.ch);
imlib_image_fill_rectangle(0, sz.ch - sz.bh, sz.cw, sz.bh);
imlib_image_fill_rectangle(sz.cw - sz.bw, 0, sz.bw, sz.ch);
} else {
imlib_image_fill_rectangle(0, 0, sz.dw, sz.bh);
imlib_image_fill_rectangle(0, 0, sz.bw, sz.ch);
imlib_image_fill_rectangle(0, sz.dh - sz.bh, sz.dw, sz.bh);
imlib_image_fill_rectangle(sz.dw - sz.bw, 0, sz.bw, sz.dh);
}
}
/* set params. */
imlib_context_set_image(image_dst);
q = ngx_http_small_light_parse_double(NGX_HTTP_SMALL_LIGHT_PARAM_GET_LIT(&ctx->hash, "q"));
if (q > 0.0) {
imlib_image_attach_data_value("quality", NULL, q, NULL);
}
of = NGX_HTTP_SMALL_LIGHT_PARAM_GET_LIT(&ctx->hash, "of");
if (ngx_strlen(of) > 0) {
type = ngx_http_small_light_type(of);
if (type == NGX_HTTP_SMALL_LIGHT_IMAGE_NONE) {
ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
"of is invalid(%s) %s:%d",
of,
__FUNCTION__,
__LINE__);
of = (char *)ngx_http_small_light_image_exts[ictx->type - 1];
} else if (type == NGX_HTTP_SMALL_LIGHT_IMAGE_WEBP) {
ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
"WebP is not supported %s:%d",
__FUNCTION__,
__LINE__);
of = (char *)ngx_http_small_light_image_exts[ictx->type - 1];
} else {
ictx->type = type;
}
imlib_image_set_format(of);
ctx->of = ngx_http_small_light_image_types[ictx->type - 1];
} else {
ext = ngx_http_small_light_image_exts[ictx->type - 1];
imlib_image_set_format(ext);
ctx->of = ctx->inf;
}
/* save image. */
imlib_save_image_with_error_return(filename, &err);
imlib_free_image();
/* check error. */
if (err != IMLIB_LOAD_ERROR_NONE) {
ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
"failed to imlib_save_error %s:%d",
__FUNCTION__,
__LINE__);
return NGX_ERROR;
}
if (ngx_file_info(filename, &fi) == NGX_FILE_ERROR) {
ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
"failed to ngx_file_info %s:%d",
__FUNCTION__,
__LINE__);
return NGX_ERROR;
}
fd = ngx_open_file(filename, NGX_FILE_RDONLY, NGX_FILE_OPEN, 0);
if (fd == NGX_INVALID_FILE) {
ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
"failed to open fd %s:%d",
__FUNCTION__,
__LINE__);
return NGX_ERROR;
}
if (ngx_fd_info(fd, &fi) == NGX_FILE_ERROR) {
ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
"failed to ngx_fd_info %s:%d",
__FUNCTION__,
__LINE__);
ngx_close_file(fd);
return NGX_ERROR;
}
buf = ngx_palloc(r->pool, ngx_file_size(&fi));
if (buf == NULL) {
ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
"failed to allocate memory from r->pool %s:%d",
__FUNCTION__,
__LINE__);
ngx_close_file(fd);
return NGX_ERROR;
}
size = ngx_read_fd(fd, buf, ngx_file_size(&fi));
if (size == -1) {
ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
"failed to ngx_read_fd %s:%d",
__FUNCTION__,
__LINE__);
ngx_close_file(fd);
return NGX_ERROR;
}
if ((size_t)size > ctx->content_length) {
ctx->content = ngx_palloc(r->pool, size);
if (ctx->content == NULL) {
ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
"failed to allocate memory from r->pool %s:%d",
__FUNCTION__,
__LINE__);
ngx_close_file(fd);
return NGX_ERROR;
}
}
ngx_memcpy(ctx->content, buf, size);
ngx_close_file(fd);
ctx->content_length = size;
return NGX_OK;
}
/*
Dual wallpaper generator
Copyright (C) 2009 Aleksi Räsänen <*****@*****.**>
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU Affero General Public License as
published by the Free Software Foundation, either version 3 of the
License, or (at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Affero General Public License for more details.
You should have received a copy of the GNU Affero General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
int
main( int argc, char *argv[] )
{
Imlib_Image input_image;
Imlib_Image output_image;
int image1_width, image1_height, image2_width, image2_height;
int input_width, input_height, output_width;
if( argc < 7 )
{
printf( "Usage: %s inputfile img1_width img1_height ", argv[0] );
printf( "img2_width img2_height output.jpg\n" );
exit(1);
}
// Check if input file exists or not. If not, quit.
FILE *fp;
fp = fopen( argv[1], "r" );
if( fp == NULL )
{
printf( "File %s not found!\n", argv[1] );
exit(1);
}
// Read output image dimensions
image1_width = atoi( argv[2] );
image1_height = atoi( argv[3] );
image2_width = atoi( argv[4] );
image2_height = atoi( argv[5] );
input_image = imlib_load_image( argv[1] );
// Output image width must be selected by wider image
if( image1_width > image2_width )
output_width = image1_width;
else
output_width = image2_width;
// Create new empty image
output_image = imlib_create_image( output_width,
image1_height + image2_height );
if(! input_image )
{
printf( "Failed to load image %s\n", argv[1] );
exit(1);
}
// Read original image size
imlib_context_set_image( input_image );
input_width = imlib_image_get_width();
input_height = imlib_image_get_height();
imlib_context_set_image( output_image );
// Copy whole input image to output image
imlib_blend_image_onto_image( input_image, 0, 0, 0,
input_width, input_height,
0, 0,
image1_width, image1_height );
imlib_blend_image_onto_image( input_image, 0, 0, 0,
input_width, input_height,
0, image1_height,
image2_width, image2_height );
imlib_save_image( argv[6] );
return 0;
}
/* draw background to root */
void
drawbg(void) {
int i, w, h, nx, ny, nh, nw, tmp;
double factor;
Pixmap pm;
Imlib_Image tmpimg, buffer;
pm = XCreatePixmap(dpy, root, sw, sh,
DefaultDepth(dpy, DefaultScreen(dpy)));
if(!(buffer = imlib_create_image(sw, sh)))
die("Error: Cannot allocate buffer.\n");
imlib_context_set_image(buffer);
imlib_image_fill_rectangle(0, 0, sw, sh);
imlib_context_set_blend(1);
for(i = 0; i < nmonitor; i++) {
imlib_context_set_image(images[i % nimage]);
w = imlib_image_get_width();
h = imlib_image_get_height();
if(!(tmpimg = imlib_clone_image()))
die("Error: Cannot clone image.\n");
imlib_context_set_image(tmpimg);
if(rotate && ((monitors[i].w > monitors[i].h && w < h) ||
(monitors[i].w < monitors[i].h && w > h))) {
imlib_image_orientate(1);
tmp = w;
w = h;
h = tmp;
}
imlib_context_set_image(buffer);
switch(mode) {
case ModeCenter:
nw = (monitors[i].w - w) / 2;
nh = (monitors[i].h - h) / 2;
nx = monitors[i].x + (monitors[i].w - nw) / 2;
ny = monitors[i].y + (monitors[i].h - nh) / 2;
break;
case ModeZoom:
nw = monitors[i].w;
nh = monitors[i].h;
if(w > h && (w / h > (monitors[i].w / monitors[i].h))) {
nx = monitors[i].x + (monitors[i].w - nw) / 2;
ny = monitors[i].y + (int)ceil(h * nx / w) / 2;
}
else {
ny = monitors[i].y + (monitors[i].h - nh) / 2;
nx = monitors[i].x + (int)ceil(w * ny / h) / 2;
}
break;
default: /* ModeScale */
factor = MAX((double)w / monitors[i].w,
(double)h / monitors[i].h);
nw = w / factor;
nh = h / factor;
nx = monitors[i].x + (monitors[i].w - nw) / 2;
ny = monitors[i].y + (monitors[i].h - nh) / 2;
}
imlib_blend_image_onto_image(tmpimg, 0, 0, 0, w, h,
nx, ny, nw, nh);
imlib_context_set_image(tmpimg);
imlib_free_image();
}
imlib_context_set_blend(0);
imlib_context_set_image(buffer);
imlib_context_set_drawable(root);
imlib_render_image_on_drawable(0, 0);
imlib_context_set_drawable(pm);
imlib_render_image_on_drawable(0, 0);
XSetWindowBackgroundPixmap(dpy, root, pm);
imlib_context_set_image(buffer);
imlib_free_image_and_decache();
XFreePixmap(dpy, pm);
}
int load_Mod_image (ImageMode mode, const char *arg, int userW, int userH,
int alpha, Imlib_Image rootimg, int ck0)
{
int width, height;
int imgW, imgH, o;
int left, top;
left=top=0;
int x, y;
width = DisplayWidth (display, screen);
height = DisplayHeight (display, screen);
Imlib_Image buffer = imlib_load_image (arg);
if ( !buffer )
{
return 1;
}
imlib_context_set_image (buffer);
imgW = imlib_image_get_width (), imgH = imlib_image_get_height ();
if (alpha < 255)
{
// Create alpha-override mask
imlib_image_set_has_alpha (1);
Imlib_Color_Modifier modifier = imlib_create_color_modifier ();
imlib_context_set_color_modifier (modifier);
DATA8 red[256], green[256], blue[256], alph[256];
imlib_get_color_modifier_tables (red, green, blue, alph);
for (o = 0; o < 256; o++)
alph[o] = (DATA8) alpha;
imlib_set_color_modifier_tables (red, green, blue, alph);
imlib_apply_color_modifier ();
imlib_free_color_modifier ();
}
imlib_context_set_image (rootimg);
if (mode == Fill)
{
imlib_blend_image_onto_image (buffer, 0, 0, 0, imgW, imgH,
0, 0, userW, userH);
}
if (mode == Dia)
{
if (userW >= width || userH >= height )
{
imlib_blend_image_onto_image (buffer, 0, 0, 0, imgW, imgH, 0, 0, width, height);
}
else if ( userH < height || userW < width )
{
int left, top;
left = (width - userW) / 2;
top = (height - userH) / 2;
imlib_blend_image_onto_image (buffer, 0, 0, 0, imgW, imgH, left, top, userW, userH);
}
}
if (mode == Tile)
{
if ( ck0 == 3 )
{
left = (width - imgW) / 2;
top = (height - imgH) / 2;
for (; left > 0; left -= imgW);
for (; top > 0; top -= imgH);
for (x = left; x < width; x += imgW)
for (y = top; y < height; y += imgH)
imlib_blend_image_onto_image (buffer, 0, 0, 0, imgW, imgH, x, y, imgW, imgH);
}
if (ck0 != 3)
{
left = (width - userW) / 2;
top = (height - userH) /2;
for (; left > 0; left -= userW);
for (; top > 0; top -= userH);
for (x = left; x < width; x += userW)
for (y = top; y < height; y += userH)
imlib_blend_image_onto_image (buffer, 0, 0, 0, imgW, imgH, x, y, userW, userH);
}
}
if (mode == Center)
{
left = (width - imgW) / 2;
top = (height - imgH) / 2;
imlib_blend_image_onto_image (buffer, 0, 0, 0, imgW, imgH, left, top, imgW, imgH);
}
imlib_context_set_image (buffer);
imlib_free_image ();
imlib_context_set_image (rootimg);
return 0;
}
