void
R_destroy_image_imlib2(struct R_image *image)
{
if (image->orig) {
if (image->pixmap) {
#if (USE_XSHM)
if (image->hasshm) {
shmseg = &image->shmseg;
XShmDetach(image->app->display, shmseg);
shmdt(shmseg->shmaddr);
shmctl(shmseg->shmid, IPC_RMID, NULL);
shmseg->shmid = -1;
shmseg->shmaddr = NULL;
image->hasshm = 0;
} else {
imlib_free_pixmap_and_mask(image->pixmap);
}
#else
imlib_free_pixmap_and_mask(image->pixmap);
#endif
image->pixmap = image->mask = None;
}
imlib_context_set_image(image->orig);
imlib_free_image();
image->orig = NULL;
}
R_free_image_imlib2(image);
return;
}
static void update_bg()
{
if (currootpmap != *rootpmap && *rootpmap != 0) {
currootpmap = *rootpmap;
imlib_context_set_drawable(currootpmap);
if (bg) {
imlib_context_set_image(bg);
imlib_free_image();
}
bg = imlib_create_image_from_drawable(0, bbx, bby, bbwidth, bbheight, 1);
Pixmap tile, mask;
imlib_context_set_display(bbdpy);
imlib_context_set_visual(bbvis);
imlib_context_set_drawable(bbwin);
imlib_context_set_image(bg);
Imlib_Image tmpbg = imlib_clone_image();
tile_image_blend(tmpbg, theme->tile_img, 0, bbwidth);
imlib_render_pixmaps_for_whole_image(&tile, &mask);
XSetWindowBackgroundPixmap(bbdpy, bbwin, tile);
imlib_free_pixmap_and_mask(tile);
imlib_free_image();
}
}
void
R_free_image_imlib2(struct R_image *image)
{
#if (USE_XSHM)
XShmSegmentInfo *shmseg;
#endif
if (image && !(image->flags & R_IMAGE_STATIC_FLAG)) {
// image->filename = NULL;
if (image->orig) {
imlib_context_set_image(image->orig);
imlib_free_image();
image->img = NULL;
}
}
if (image->img) {
imlib_context_set_image(image->img);
imlib_free_image();
image->img = NULL;
}
if (image->overlay) {
imlib_context_set_image(image->overlay);
imlib_free_image();
image->overlay = NULL;
}
if (!(image->flags & R_IMAGE_STATIC_THUMB_FLAG) && (image->timg)) {
imlib_context_set_image(image->timg);
imlib_free_image();
image->timg = NULL;
}
if (image->pixmap) {
imlib_free_pixmap_and_mask(image->pixmap);
image->pixmap = image->mask = None;
}
if (image->tpixmap) {
imlib_free_pixmap_and_mask(image->tpixmap);
image->tpixmap = image->tmask = None;
}
if (image->xpixmap) {
XFreePixmap(R_global.app->display,
image->xpixmap);
image->xpixmap = None;
}
return;
}
static void set_bg()
{
Pixmap tile, mask;
imlib_context_set_display(bbdpy);
imlib_context_set_visual(bbvis);
imlib_context_set_drawable(bbwin);
imlib_context_set_image(theme->tile_img);
imlib_render_pixmaps_for_whole_image(&tile, &mask);
XSetWindowBackgroundPixmap(bbdpy, bbwin, tile);
imlib_free_pixmap_and_mask(tile);
}
void
image_destroy_pixmaps_imlib2(struct R_image *image)
{
if (image == NULL) {
return;
}
if (image->pixmap) {
imlib_free_pixmap_and_mask(image->pixmap);
image->pixmap = None;
image->maskpixmap = None;
}
return;
}
void XImlib2Caption::draw()
{
XDesktopContainer * xContainer =
dynamic_cast<XDesktopContainer *>(AbstractImage::container);
XIconWithShadow * sIcon = dynamic_cast<XIconWithShadow *>(AbstractImage::iconParent);
Display * display = xContainer->getDisplay();
int fX, fY;
setXY(fX, fY);
Imlib_Image cropImage = xContainer->bg->createCropImage(fX, fY, width, height, width, height);
imlib_context_set_image(cropImage);
imlib_context_set_drawable(window);
imlib_render_image_on_drawable(0, 0);
Pixmap shapeMask;
imlib_render_pixmaps_for_whole_image (&pixmap, &shapeMask);
XSetWindowBackgroundPixmap (display, window, pixmap);
imlib_free_image();
imlib_context_set_drawable(xContainer->getRootWindow());
imlib_context_set_image(xContainer->bg->spareRoot);
// if the icon shadow is enabled and the shadow is visible underneath the
// text window
if (sIcon && //TODO Fix this
sIcon->getShadowX() > fX - sIcon->getWidth() &&
sIcon->getShadowY() > fY - sIcon->getHeight() &&
sIcon->getShadowX() < fX + sIcon->getWidth() &&
sIcon->getShadowY() < fY + sIcon->getHeight() )
sIcon->renderShadowToImage(pixmap, fX, fY);
updateText();
XMoveWindow(display, window, fX, fY );
//apply the buffer to the window
XSetFillStyle(display, gc, FillTiled);
XSetTile(display, gc, pixmap);
XFillRectangle(display, window, gc, 0, 0, width, height);
imlib_free_pixmap_and_mask(pixmap);
}
void
mainwin_destroy(MainWin *mw)
{
if(mw->tooltip)
tooltip_destroy(mw->tooltip);
if(! mw->no_free_color)
XFreeColors(mw->dpy, mw->colormap, mw->pixels, 2, 0);
else {
if(! (mw->no_free_color & 1))
XFreeColors(mw->dpy, mw->colormap, &BORDER_COLOR(mw), 1, 0);
if(! (mw->no_free_color & 2))
XFreeColors(mw->dpy, mw->colormap, &HIGHLIGHT_COLOR(mw), 1, 0);
}
if(mw->cm_highlight)
{
imlib_context_set_color_modifier(mw->cm_highlight);
imlib_free_color_modifier();
}
if(mw->cm_normal)
{
imlib_context_set_color_modifier(mw->cm_normal);
imlib_free_color_modifier();
}
if(mw->background)
{
imlib_context_set_image(mw->background);
imlib_free_image();
}
if(mw->bg_pixmap != None)
imlib_free_pixmap_and_mask(mw->bg_pixmap);
XDestroyWindow(mw->dpy, mw->window);
#ifdef XINERAMA
if(mw->xin_info)
XFree(mw->xin_info);
#endif /* XINERAMA */
free(mw);
}
void XImlib2Image::shapeWindow()
{
XDesktopContainer * xContainer = dynamic_cast<XDesktopContainer *>(container);
//Shape the window to the icon
imlib_context_set_image(image);
imlib_context_set_color_modifier(colorMod);
imlib_set_color_modifier_tables(mapNone, mapNone, mapNone, mapZeroAlpha);
Pixmap pixmap, pixMask;
imlib_render_pixmaps_for_whole_image(&pixmap, &pixMask);
XSetWindowBackgroundPixmap (display, window, pixmap);
#ifdef SHAPE
XShapeCombineMask(display, window, ShapeBounding, 0, 0, pixMask, ShapeSet);
#endif // SHAPE
imlib_reset_color_modifier();
imlib_free_pixmap_and_mask(pixmap);
}
void
R_free_thumb_imlib2(struct R_image *image)
{
if (image) {
// image->filename = NULL;
if (image->timg) {
imlib_context_set_image(image->timg);
imlib_free_image();
image->timg = NULL;
}
if (image->tpixmap) {
imlib_free_pixmap_and_mask(image->tpixmap);
image->tpixmap = image->tmask = None;
}
if (image->xpixmap) {
XFreePixmap(image->app->display,
image->xpixmap);
image->xpixmap = None;
}
}
return;
}
static
void mainwin_update_bg_pixmap(MainWin *mw)
{
Imlib_Image tmp;
XSetWindowAttributes wattr;
Pixmap dummy;
if(mw->bg_pixmap != None)
imlib_free_pixmap_and_mask(mw->bg_pixmap);
imlib_context_set_image(mw->background);
tmp = imlib_create_cropped_image(mw->x, mw->y, mw->width, mw->height);
imlib_context_set_image(tmp);
imlib_context_set_drawable(mw->window);
imlib_render_pixmaps_for_whole_image(&mw->bg_pixmap, &dummy);
wattr.background_pixmap = mw->bg_pixmap;
XChangeWindowAttributes(mw->dpy, mw->window, CWBackPixmap, &wattr);
XClearArea(mw->dpy, mw->window, 0, 0, 0, 0, False);
imlib_free_image();
}
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;
}
void
window_fade_imlib2(Rwindow_t *window, struct R_image *image, int usecs, int mode)
{
double value, lastvalue;
struct R_image *scaledimage;
Imlib_Color_Modifier colormod;
Pixmap pixmap;
Pixmap mask;
struct timeval start, stop;
int usedtime;
XWindowAttributes attributes;
if (window == NULL
|| image == NULL) {
return;
}
if (mode == WINDOW_FADE_IN) {
value = 0.0;
} else {
value = 1.0;
}
lastvalue = -1.0;
usedtime = 0;
memset(&attributes, 0, sizeof(attributes));
XGetWindowAttributes(window->app->display, window->win, &attributes);
scaledimage = image_clone_imlib2(window->win,
image,
attributes.width, attributes.height);
if (scaledimage == NULL) {
return;
}
colormod = imlib_create_color_modifier();
if (colormod == NULL) {
image_destroy_imlib2(scaledimage);
return;
}
imlib_context_set_drawable(window->win);
imlib_context_set_image(scaledimage->im2img);
imlib_context_set_color_modifier(colormod);
imlib_modify_color_modifier_gamma(1.0);
imlib_modify_color_modifier_contrast(1.0);
gettimeofday(&start, NULL);
while (usedtime < usecs) {
if (value != lastvalue) {
imlib_modify_color_modifier_brightness(value);
imlib_context_set_mask(0);
imlib_render_pixmaps_for_whole_image(&pixmap, &mask);
XSetWindowBackgroundPixmap(window->app->display,
window->win,
pixmap);
XClearWindow(window->app->display,
window->win);
XFlush(window->app->display);
imlib_free_pixmap_and_mask(pixmap);
lastvalue = value;
}
gettimeofday(&stop, NULL);
usedtime = TIMEVAL_CMP_USEC(&start, &stop);
value = IMAGE_NORMAL_MODIFIER * (usedtime / (double)usecs);
if (mode == WINDOW_FADE_OUT) {
value = IMAGE_NORMAL_MODIFIER - value;
}
}
if (mode == WINDOW_FADE_IN
&& lastvalue != IMAGE_NORMAL_MODIFIER) {
imlib_modify_color_modifier_brightness(IMAGE_NORMAL_MODIFIER);
imlib_context_set_mask(0);
imlib_render_pixmaps_for_whole_image(&pixmap, &mask);
XSetWindowBackgroundPixmap(window->app->display,
window->win,
pixmap);
XClearWindow(window->app->display,
window->win);
XFlush(window->app->display);
imlib_free_pixmap_and_mask(pixmap);
} else if (lastvalue != 0.0) {
imlib_modify_color_modifier_brightness(0.0);
imlib_context_set_mask(0);
imlib_render_pixmaps_for_whole_image(&pixmap, &mask);
XSetWindowBackgroundPixmap(window->app->display,
window->win,
pixmap);
XClearWindow(window->app->display,
window->win);
XFlush(window->app->display);
imlib_free_pixmap_and_mask(pixmap);
}
image_destroy_imlib2(scaledimage);
return;
}
/* FIXME: check for errors. */
int
R_render_image_imlib2(struct R_image *image,
struct R_window *window,
int w,
int h,
int flags)
{
unsigned int rendw = 0;
unsigned int rendh = 0;
int winw = 0;
int winh = 0;
int copyx = 0;
int copyy = 0;
int copyw;
int copyh;
int dummyi;
int nx;
int ny;
unsigned int dummyui;
Window dummywin;
Pixmap pixmap;
int x = 0;
int y = 0;
static GC rendgc = NULL;
#if (USE_XSHM)
int shmid;
XShmSegmentInfo *shmseg;
#endif
long factor;
int xofs = 0;
int yofs = 0;
#if 0
if (!image || !image->orig || !window->id) {
return -1;
}
#endif
R_free_image_imlib2(image);
if (image->flags & R_IMAGE_STATIC_FLAG) {
if (image->pixmap) {
#if (USE_XSHM)
if (image->hasshm) {
shmseg = &image->shmseg;
XShmDetach(image->app->display, shmseg);
shmdt(shmseg->shmaddr);
shmctl(shmseg->shmid, IPC_RMID, NULL);
shmseg->shmid = -1;
shmseg->shmaddr = NULL;
image->hasshm = 0;
} else {
imlib_free_pixmap_and_mask(image->pixmap);
}
#else
imlib_free_pixmap_and_mask(image->pixmap);
#endif
image->pixmap = image->mask = None;
}
}
imlib_context_set_drawable(window->id);
imlib_context_set_image(image->orig);
imlib_context_set_mask(image->mask);
imlib_context_set_blend(image->flags & R_IMAGE_BLEND_FLAG);
if ((flags & R_IMAGE_STRETCH_FLAG)
|| (flags & R_IMAGE_FILL_FLAG)
|| w == R_TILE_FIT_IMAGE || h == R_TILE_FIT_IMAGE
|| w == R_INTEGER_TILE_IMAGE || h == R_INTEGER_TILE_IMAGE
|| w == R_FIT_IMAGE || h == R_FIT_IMAGE
|| (flags & R_IMAGE_FIT_FLAG)) {
XGetGeometry(image->app->display,
window->id,
&dummywin,
&dummyi,
&dummyi,
&winw,
&winh,
&dummyui,
&dummyui);
}
if (flags & R_IMAGE_STRETCH_FLAG) {
rendw = winw;
rendh = winh;
} else {
if (w == R_INTEGER_TILE_IMAGE) {
long tmp1 = winw / image->origw;
long tmp2 = winh / image->origh;
factor = MIN(tmp1, tmp2);
rendw = image->origw;
xofs = (winw - (factor * rendw)) >> 1;
} else if (w == R_TILE_FIT_IMAGE) {
