forked from old/legacy-imlib2
517 lines
14 KiB
C
517 lines
14 KiB
C
#include "config.h"
|
|
#include <Imlib2.h>
|
|
#include "common.h"
|
|
|
|
#include <stdio.h>
|
|
|
|
#include "api.h"
|
|
#include "blend.h"
|
|
#include "image.h"
|
|
#include "updates.h"
|
|
|
|
#include "x11_color.h"
|
|
#include "x11_grab.h"
|
|
#include "x11_pixmap.h"
|
|
#include "x11_rend.h"
|
|
#include "x11_ximage.h"
|
|
|
|
EAPI void
|
|
imlib_context_set_display(Display * display)
|
|
{
|
|
ctx->display = display;
|
|
}
|
|
|
|
EAPI Display *
|
|
imlib_context_get_display(void)
|
|
{
|
|
return ctx->display;
|
|
}
|
|
|
|
EAPI void
|
|
imlib_context_disconnect_display(void)
|
|
{
|
|
if (!ctx->display)
|
|
return;
|
|
__imlib_RenderDisconnect(ctx->display);
|
|
ctx->display = NULL;
|
|
}
|
|
|
|
EAPI void
|
|
imlib_context_set_visual(Visual * visual)
|
|
{
|
|
ctx->visual = visual;
|
|
ctx->depth = imlib_get_visual_depth(ctx->display, ctx->visual);
|
|
}
|
|
|
|
EAPI Visual *
|
|
imlib_context_get_visual(void)
|
|
{
|
|
return ctx->visual;
|
|
}
|
|
|
|
EAPI void
|
|
imlib_context_set_colormap(Colormap colormap)
|
|
{
|
|
ctx->colormap = colormap;
|
|
}
|
|
|
|
EAPI Colormap
|
|
imlib_context_get_colormap(void)
|
|
{
|
|
return ctx->colormap;
|
|
}
|
|
|
|
EAPI void
|
|
imlib_context_set_drawable(Drawable drawable)
|
|
{
|
|
ctx->drawable = drawable;
|
|
}
|
|
|
|
EAPI Drawable
|
|
imlib_context_get_drawable(void)
|
|
{
|
|
return ctx->drawable;
|
|
}
|
|
|
|
EAPI void
|
|
imlib_context_set_mask(Pixmap mask)
|
|
{
|
|
ctx->mask = mask;
|
|
}
|
|
|
|
EAPI Pixmap
|
|
imlib_context_get_mask(void)
|
|
{
|
|
return ctx->mask;
|
|
}
|
|
|
|
EAPI void
|
|
imlib_context_set_dither_mask(char dither_mask)
|
|
{
|
|
ctx->dither_mask = dither_mask;
|
|
}
|
|
|
|
EAPI char
|
|
imlib_context_get_dither_mask(void)
|
|
{
|
|
return ctx->dither_mask;
|
|
}
|
|
|
|
EAPI void
|
|
imlib_context_set_mask_alpha_threshold(int mask_alpha_threshold)
|
|
{
|
|
ctx->mask_alpha_threshold = mask_alpha_threshold;
|
|
}
|
|
|
|
EAPI int
|
|
imlib_context_get_mask_alpha_threshold(void)
|
|
{
|
|
return ctx->mask_alpha_threshold;
|
|
}
|
|
|
|
EAPI int
|
|
imlib_get_ximage_cache_count_used(void)
|
|
{
|
|
return __imlib_GetXImageCacheCountUsed(ctx->display);
|
|
}
|
|
|
|
EAPI int
|
|
imlib_get_ximage_cache_count_max(void)
|
|
{
|
|
return __imlib_GetXImageCacheCountMax(ctx->display);
|
|
}
|
|
|
|
EAPI void
|
|
imlib_set_ximage_cache_count_max(int count)
|
|
{
|
|
__imlib_SetXImageCacheCountMax(ctx->display, count);
|
|
}
|
|
|
|
EAPI int
|
|
imlib_get_ximage_cache_size_used(void)
|
|
{
|
|
return __imlib_GetXImageCacheSizeUsed(ctx->display);
|
|
}
|
|
|
|
EAPI int
|
|
imlib_get_ximage_cache_size_max(void)
|
|
{
|
|
return __imlib_GetXImageCacheSizeMax(ctx->display);
|
|
}
|
|
|
|
EAPI void
|
|
imlib_set_ximage_cache_size_max(int bytes)
|
|
{
|
|
__imlib_SetXImageCacheSizeMax(ctx->display, bytes);
|
|
}
|
|
|
|
EAPI int
|
|
imlib_get_color_usage(void)
|
|
{
|
|
return (int)_max_colors;
|
|
}
|
|
|
|
EAPI void
|
|
imlib_set_color_usage(int max)
|
|
{
|
|
if (max < 2)
|
|
max = 2;
|
|
else if (max > 256)
|
|
max = 256;
|
|
_max_colors = max;
|
|
}
|
|
|
|
EAPI int
|
|
imlib_get_visual_depth(Display * display, Visual * visual)
|
|
{
|
|
CHECK_PARAM_POINTER_RETURN("display", display, 0);
|
|
CHECK_PARAM_POINTER_RETURN("visual", visual, 0);
|
|
return __imlib_XActualDepth(display, visual);
|
|
}
|
|
|
|
EAPI Visual *
|
|
imlib_get_best_visual(Display * display, int screen, int *depth_return)
|
|
{
|
|
CHECK_PARAM_POINTER_RETURN("display", display, NULL);
|
|
CHECK_PARAM_POINTER_RETURN("depth_return", depth_return, NULL);
|
|
return __imlib_BestVisual(display, screen, depth_return);
|
|
}
|
|
|
|
EAPI void
|
|
imlib_render_pixmaps_for_whole_image(Pixmap * pixmap_return,
|
|
Pixmap * mask_return)
|
|
{
|
|
ImlibImage *im;
|
|
|
|
CHECK_PARAM_POINTER("image", ctx->image);
|
|
CHECK_PARAM_POINTER("pixmap_return", pixmap_return);
|
|
CAST_IMAGE(im, ctx->image);
|
|
ctx->error = __imlib_LoadImageData(im);
|
|
if (ctx->error)
|
|
return;
|
|
__imlib_CreatePixmapsForImage(ctx->display, ctx->drawable, ctx->visual,
|
|
ctx->depth, ctx->colormap, im, pixmap_return,
|
|
mask_return, 0, 0, im->w, im->h, im->w,
|
|
im->h, 0, ctx->dither, ctx->dither_mask,
|
|
ctx->mask_alpha_threshold,
|
|
ctx->color_modifier);
|
|
}
|
|
|
|
EAPI void
|
|
imlib_render_pixmaps_for_whole_image_at_size(Pixmap * pixmap_return,
|
|
Pixmap * mask_return, int width,
|
|
int height)
|
|
{
|
|
ImlibImage *im;
|
|
|
|
CHECK_PARAM_POINTER("image", ctx->image);
|
|
CHECK_PARAM_POINTER("pixmap_return", pixmap_return);
|
|
CAST_IMAGE(im, ctx->image);
|
|
ctx->error = __imlib_LoadImageData(im);
|
|
if (ctx->error)
|
|
return;
|
|
__imlib_CreatePixmapsForImage(ctx->display, ctx->drawable, ctx->visual,
|
|
ctx->depth, ctx->colormap, im, pixmap_return,
|
|
mask_return, 0, 0, im->w, im->h, width,
|
|
height, ctx->anti_alias, ctx->dither,
|
|
ctx->dither_mask, ctx->mask_alpha_threshold,
|
|
ctx->color_modifier);
|
|
}
|
|
|
|
EAPI void
|
|
imlib_free_pixmap_and_mask(Pixmap pixmap)
|
|
{
|
|
__imlib_FreePixmap(ctx->display, pixmap);
|
|
}
|
|
|
|
EAPI void
|
|
imlib_render_image_on_drawable(int x, int y)
|
|
{
|
|
ImlibImage *im;
|
|
|
|
CHECK_PARAM_POINTER("image", ctx->image);
|
|
CAST_IMAGE(im, ctx->image);
|
|
ctx->error = __imlib_LoadImageData(im);
|
|
if (ctx->error)
|
|
return;
|
|
__imlib_RenderImage(ctx->display, im, ctx->drawable, ctx->mask,
|
|
ctx->visual, ctx->colormap, ctx->depth, 0, 0, im->w,
|
|
im->h, x, y, im->w, im->h, 0, ctx->dither, ctx->blend,
|
|
ctx->dither_mask, ctx->mask_alpha_threshold,
|
|
ctx->color_modifier, ctx->operation);
|
|
}
|
|
|
|
EAPI void
|
|
imlib_render_image_on_drawable_at_size(int x, int y, int width, int height)
|
|
{
|
|
ImlibImage *im;
|
|
|
|
CHECK_PARAM_POINTER("image", ctx->image);
|
|
CAST_IMAGE(im, ctx->image);
|
|
ctx->error = __imlib_LoadImageData(im);
|
|
if (ctx->error)
|
|
return;
|
|
__imlib_RenderImage(ctx->display, im, ctx->drawable, ctx->mask,
|
|
ctx->visual, ctx->colormap, ctx->depth,
|
|
0, 0, im->w, im->h, x, y, width, height,
|
|
ctx->anti_alias, ctx->dither, ctx->blend,
|
|
ctx->dither_mask, ctx->mask_alpha_threshold,
|
|
ctx->color_modifier, ctx->operation);
|
|
}
|
|
|
|
EAPI void
|
|
imlib_render_image_part_on_drawable_at_size(int src_x, int src_y,
|
|
int src_width, int src_height,
|
|
int dst_x, int dst_y,
|
|
int dst_width, int dst_height)
|
|
{
|
|
ImlibImage *im;
|
|
|
|
CHECK_PARAM_POINTER("image", ctx->image);
|
|
CAST_IMAGE(im, ctx->image);
|
|
ctx->error = __imlib_LoadImageData(im);
|
|
if (ctx->error)
|
|
return;
|
|
__imlib_RenderImage(ctx->display, im, ctx->drawable, 0,
|
|
ctx->visual, ctx->colormap, ctx->depth,
|
|
src_x, src_y, src_width, src_height,
|
|
dst_x, dst_y, dst_width, dst_height,
|
|
ctx->anti_alias, ctx->dither, ctx->blend, 0, 0,
|
|
ctx->color_modifier, ctx->operation);
|
|
}
|
|
|
|
EAPI uint32_t
|
|
imlib_render_get_pixel_color(void)
|
|
{
|
|
return __imlib_RenderGetPixel(ctx->display, ctx->drawable, ctx->visual,
|
|
ctx->colormap, ctx->depth,
|
|
(uint8_t) ctx->color.red,
|
|
(uint8_t) ctx->color.green,
|
|
(uint8_t) ctx->color.blue);
|
|
}
|
|
|
|
EAPI Imlib_Image
|
|
imlib_create_image_from_drawable(Pixmap mask, int x, int y, int width,
|
|
int height, char need_to_grab_x)
|
|
{
|
|
ImlibImage *im;
|
|
char domask = 0;
|
|
|
|
if (mask)
|
|
{
|
|
domask = 1;
|
|
if (mask == (Pixmap) 1)
|
|
mask = None;
|
|
}
|
|
|
|
im = __imlib_CreateImage(width, height, NULL, 0);
|
|
if (!im)
|
|
return NULL;
|
|
|
|
if (!__imlib_GrabDrawableToRGBA(im->data, 0, 0, width, height, ctx->display,
|
|
ctx->drawable, mask, ctx->visual,
|
|
ctx->colormap, ctx->depth, x, y, width,
|
|
height, &domask, need_to_grab_x))
|
|
{
|
|
__imlib_FreeImage(im);
|
|
return NULL;
|
|
}
|
|
|
|
im->has_alpha = domask;
|
|
|
|
return im;
|
|
}
|
|
|
|
EAPI Imlib_Image
|
|
imlib_create_image_from_ximage(XImage * image, XImage * mask, int x, int y,
|
|
int width, int height, char need_to_grab_x)
|
|
{
|
|
ImlibImage *im;
|
|
|
|
im = __imlib_CreateImage(width, height, NULL, 0);
|
|
if (!im)
|
|
return NULL;
|
|
|
|
__imlib_GrabXImageToRGBA(im->data, 0, 0, width, height,
|
|
ctx->display, image, mask, ctx->visual,
|
|
ctx->depth, x, y, width, height, need_to_grab_x);
|
|
return im;
|
|
}
|
|
|
|
EAPI Imlib_Image
|
|
imlib_create_scaled_image_from_drawable(Pixmap mask, int src_x, int src_y,
|
|
int src_width, int src_height,
|
|
int dst_width, int dst_height,
|
|
char need_to_grab_x,
|
|
char get_mask_from_shape)
|
|
{
|
|
ImlibImage *im;
|
|
char domask;
|
|
|
|
if (!IMAGE_DIMENSIONS_OK(src_width, src_height))
|
|
return NULL;
|
|
|
|
im = __imlib_CreateImage(dst_width, dst_height, NULL, 0);
|
|
if (!im)
|
|
return NULL;
|
|
|
|
domask = mask != 0 || get_mask_from_shape;
|
|
|
|
if (!__imlib_GrabDrawableScaledToRGBA(im->data, 0, 0, dst_width, dst_height,
|
|
ctx->display, ctx->drawable, mask,
|
|
ctx->visual, ctx->colormap, ctx->depth,
|
|
src_x, src_y, src_width, src_height,
|
|
&domask, need_to_grab_x))
|
|
{
|
|
__imlib_FreeImage(im);
|
|
return NULL;
|
|
}
|
|
|
|
im->has_alpha = domask;
|
|
|
|
return im;
|
|
}
|
|
|
|
EAPI char
|
|
imlib_copy_drawable_to_image(Pixmap mask, int src_x, int src_y, int src_width,
|
|
int src_height, int dst_x, int dst_y,
|
|
char need_to_grab_x)
|
|
{
|
|
ImlibImage *im;
|
|
char domask = 0;
|
|
int pre_adj;
|
|
|
|
CHECK_PARAM_POINTER_RETURN("image", ctx->image, 0);
|
|
if (mask)
|
|
{
|
|
domask = 1;
|
|
if (mask == (Pixmap) 1)
|
|
mask = None;
|
|
}
|
|
CAST_IMAGE(im, ctx->image);
|
|
|
|
ctx->error = __imlib_LoadImageData(im);
|
|
if (ctx->error)
|
|
return 0;
|
|
|
|
pre_adj = 0;
|
|
if (src_x < 0)
|
|
{
|
|
src_width += src_x;
|
|
pre_adj = src_x;
|
|
src_x = 0;
|
|
}
|
|
if (src_width < 0)
|
|
src_width = 0;
|
|
if (dst_x < 0)
|
|
{
|
|
src_width += dst_x;
|
|
src_x -= dst_x - pre_adj;
|
|
dst_x = 0;
|
|
}
|
|
if ((dst_x + src_width) >= im->w)
|
|
src_width = im->w - dst_x;
|
|
|
|
pre_adj = 0;
|
|
if (src_y < 0)
|
|
{
|
|
src_height += src_y;
|
|
pre_adj = src_y;
|
|
src_y = 0;
|
|
}
|
|
if (src_height < 0)
|
|
src_height = 0;
|
|
if (dst_y < 0)
|
|
{
|
|
src_height += dst_y;
|
|
src_y -= dst_y - pre_adj;
|
|
dst_y = 0;
|
|
}
|
|
if ((dst_y + src_height) >= im->h)
|
|
src_height = im->h - dst_y;
|
|
|
|
if ((src_width <= 0) || (src_height <= 0))
|
|
return 0;
|
|
__imlib_DirtyImage(im);
|
|
return __imlib_GrabDrawableToRGBA(im->data, dst_x, dst_y, im->w, im->h,
|
|
ctx->display, ctx->drawable, mask,
|
|
ctx->visual, ctx->colormap, ctx->depth,
|
|
src_x, src_y, src_width, src_height,
|
|
&domask, need_to_grab_x);
|
|
}
|
|
|
|
EAPI void
|
|
imlib_render_image_updates_on_drawable(Imlib_Updates updates, int x, int y)
|
|
{
|
|
ImlibUpdate *u;
|
|
ImlibImage *im;
|
|
int ximcs;
|
|
|
|
CHECK_PARAM_POINTER("image", ctx->image);
|
|
CAST_IMAGE(im, ctx->image);
|
|
u = (ImlibUpdate *) updates;
|
|
if (!updates)
|
|
return;
|
|
ctx->error = __imlib_LoadImageData(im);
|
|
if (ctx->error)
|
|
return;
|
|
ximcs = __imlib_GetXImageCacheCountMax(ctx->display); /* Save */
|
|
if (ximcs == 0) /* Only if we don't set this up elsewhere */
|
|
__imlib_SetXImageCacheCountMax(ctx->display, 10);
|
|
for (; u; u = u->next)
|
|
{
|
|
__imlib_RenderImage(ctx->display, im, ctx->drawable, 0, ctx->visual,
|
|
ctx->colormap, ctx->depth, u->x, u->y, u->w, u->h,
|
|
x + u->x, y + u->y, u->w, u->h, 0, ctx->dither, 0,
|
|
0, 0, ctx->color_modifier, OP_COPY);
|
|
}
|
|
if (ximcs == 0)
|
|
__imlib_SetXImageCacheCountMax(ctx->display, ximcs);
|
|
}
|
|
|
|
EAPI void
|
|
imlib_render_image_on_drawable_skewed(int src_x, int src_y,
|
|
int src_width, int src_height,
|
|
int dst_x, int dst_y,
|
|
int h_angle_x, int h_angle_y,
|
|
int v_angle_x, int v_angle_y)
|
|
{
|
|
ImlibImage *im;
|
|
|
|
CHECK_PARAM_POINTER("image", ctx->image);
|
|
CAST_IMAGE(im, ctx->image);
|
|
ctx->error = __imlib_LoadImageData(im);
|
|
if (ctx->error)
|
|
return;
|
|
__imlib_RenderImageSkewed(ctx->display, im, ctx->drawable, ctx->mask,
|
|
ctx->visual, ctx->colormap, ctx->depth, src_x,
|
|
src_y, src_width, src_height,
|
|
dst_x, dst_y, h_angle_x,
|
|
h_angle_y, v_angle_x, v_angle_y, ctx->anti_alias,
|
|
ctx->dither, ctx->blend, ctx->dither_mask,
|
|
ctx->mask_alpha_threshold, ctx->color_modifier,
|
|
ctx->operation);
|
|
}
|
|
|
|
EAPI void
|
|
imlib_render_image_on_drawable_at_angle(int src_x, int src_y,
|
|
int src_width, int src_height,
|
|
int dst_x, int dst_y,
|
|
int angle_x, int angle_y)
|
|
{
|
|
ImlibImage *im;
|
|
|
|
CHECK_PARAM_POINTER("image", ctx->image);
|
|
CAST_IMAGE(im, ctx->image);
|
|
ctx->error = __imlib_LoadImageData(im);
|
|
if (ctx->error)
|
|
return;
|
|
__imlib_RenderImageSkewed(ctx->display, im, ctx->drawable, ctx->mask,
|
|
ctx->visual, ctx->colormap, ctx->depth, src_x,
|
|
src_y, src_width, src_height,
|
|
dst_x, dst_y, angle_x, angle_y,
|
|
0, 0, ctx->anti_alias, ctx->dither, ctx->blend,
|
|
ctx->dither_mask, ctx->mask_alpha_threshold,
|
|
ctx->color_modifier, ctx->operation);
|
|
}
|