|
This is a list of
all the Imlib2 API calls and what each of them do. You should familiarize
yourself well with this API so you have a good idea of what can be done.
void imlib_context_set_display(Display *display);
Sets the current X display to be used for rendering of images
to drawables. You do not need to set this if you do not intend to render
an image to an X drawable. If you do you will need to set this. If you
change displays just set this to the new display pointer. Do not use a
Display pointer if you have closed that display already - also note that
if you close a display connection and continue to render using Imlib2 without
setting the display pointer to NULL or something new, crashes may occur.
void imlib_context_set_visual(Visual *visual);
This sets the current visual to use when rendering images to
drawables or producing pixmaps. You need to set this for anything to render
to a drawable or produce any pixmaps (this can be the default visual).
void imlib_context_set_colormap(Colormap colormap);
Sets the colormap to use when rendering to drawables and allocating
colors. You must set this to the colormap you are using to render any images
or produce any pixmaps (this can be the default colormap).
void imlib_context_set_drawable(Drawable drawable);
This sets the X drawable to which images will be rendered when
you call a render call in Imlib2. This may be either a pixmap or a window.
You must set this to render anything.
void imlib_context_set_mask(Pixmap mask);
This sets the 1-bit deep pixmap to be drawn to when rendering
to generate a mask pixmap. This is only useful if the image you are rendering
has alpha. Set this to 0 to not render a pixmap mask.
void imlib_context_set_dither_mask(char dither_mask);
Selects if, you are rendering to a mask, or producing pixmap
masks from images, if the mask is to be dithered or not. passing in 1 for
dither_mask means the mask pixmap will be dithered, 0 means it will not
be dithered.
void imlib_context_set_anti_alias(char anti_alias);
Toggles "anti-aliased" scaling of images. This isn't quite
correct since it's actually super and sub pixel sampling that it turns
on and off, but anti-aliasing is used for having "smooth" edges to lines
and shapes and this means when images are scaled they will keep their smooth
appearance. Passing in 1 turns this on and 0 turns it off.
void imlib_context_set_dither(char dither);
Sets the dithering flag for rendering to a drawable or when
pixmaps are produced. This affects the color image appearance by enabling
dithering. Dithering slows down rendering but produces considerably better
results. this option has no effect foe rendering in 24 bit and up, but
in 16 bit and lower it will dither, producing smooth gradients and much
better quality images. setting dither to 1 enables it and 0 disables it.
void imlib_context_set_blend(char blend);
When rendering an image to a drawable, Imlib2 is able to blend
the image directly onto the drawable during rendering. setting this to
1 will enable this. If the image has no alpha channel this has no effect.
Setting it to 0 will disable this.
void imlib_context_set_color_modifier(Imlib_Color_Modifier color_modifier);
This sets the current color modifier used for rendering pixmaps
or images to a drawable or images onto other images. Color modifiers are
lookup tables that map the values in the red, green, blue and alpha channels
to other values in the same channel when rendering, allowing for fades,
color correction etc. to be done whilst rendering. pass in NULL as the
color_modifier to disable the color modifier for rendering.
void imlib_context_set_operation(Imlib_Operation operation);
When Imlib2 draws an image onto another or an image onto a
drawable it is able to do more than juts blend the result on using the
given alpha channel of the image. It is also able to do saturating additive,
subtractive and a combination of the both (called reshade) rendering. The
default mode is IMLIB_OP_COPY. you can also set it to IMLIB_OP_ADD, IMLIB_OP_SUBTRACT
or IMLIB_OP_RESHADE. Use this function to set the rendering operation.
IMLIB_OP_COPY perfroms basic alpha blending: DST = (SRC * A) + (DST * (1
- A)). IMLIB_OP_ADD does DST = DST + (SRC * A). IMLIB_OP_SUBTRACT does
DST = DST - (SRC * A) and IMLIB_OP_RESHADE does DST = DST + (((SRC - 0.5)
/ 2) * A).
void imlib_context_set_font(Imlib_Font font);
This function sets the current font to use when rendering text.
you should load the font first with imlib_load_font().
void imlib_context_set_direction(Imlib_Text_Direction direction);
This sets the direction in which to draw text in terms of simple
90 degree orientations or an arbitrary angle. The direction can be one
of IMLIB_TEXT_TO_RIGHT, IMLIB_TEXT_TO_LEFT, IMLIB_TEXT_TO_DOWN, IMLIB_TEXT_TO_UP
or IMLIB_TEXT_TO_ANGLE. The default is IMLIB_TEXT_TO_RIGHT. If you use
IMLIB_TEXT_TO_ANGLE, you will also have to set the angle with imlib_context_set_angle().
void imlib_context_set_angle(double angle);
This sets the angle at which text strings will be drawn if
the text direction has been set to IMLIB_TEXT_TO_ANGLE with imlib_context_set_direction().
void imlib_context_set_color(int red,
int green,
int blue,
int alpha);
This sets the color with which text, lines and rectangles are
drawn when being rendered onto an image. Values for red, green, blue and
alpha are between 0 and 255 - any other values have undefined results.
void imlib_context_set_color_range(Imlib_Color_Range color_range);
This sets the current color range to use for rendering gradients.
void imlib_context_set_progress_function(Imlib_Progress_Function progress_function);
This sets the progress function to be called back whilst loading
images. Set this to the function to be called, or set it to NULL to disable
progress callbacks whilst loading.
void imlib_context_set_progress_granularity(char progress_granularity);
This hints as to how often to call the progress callback. 0
means as often as possible. 1 means whenever 15 more of the image has been
decoded, 10 means every 10% of the image decoding, 50 means every 50% and
100 means only call at the end. Values outside of the range 0-100 are undefined.
void imlib_context_set_image(Imlib_Image image);
This sets the current image Imlib2 will be using with its function
calls.
void imlib_context_set_filter(Imlib_Filter filter);
This sets the current filter to be used when applying filters
to images. Set this to NULL to disable filters.
Display *imlib_context_get_display(void);
This returns the current display used for Imlib2's display
context.
Visual *imlib_context_get_visual(void);
Returns the current visual used for Imlib2's context.
Colormap imlib_context_get_colormap(void);
Returns the current Colormap used for Imlib2's context.
Drawable imlib_context_get_drawable(void);
Returns the current Drawable used for Imlib2's context.
Pixmap imlib_context_get_mask(void);
Returns the current pixmap destination to be used to render
a mask into.
char imlib_context_get_dither_mask(void);
Returns the current mode for dithering pixmap masks. 1 means
dithering is enabled and 0 means it is not.
char imlib_context_get_anti_alias(void);
Returns if Imlib2 currently will smoothly scale images. 1 means
it will and 0 means it will not.
char imlib_context_get_dither(void);
Returns if image data is rendered with dithering currently.
1 means yes and 0 means no.
char imlib_context_get_blend(void);
Returns if Imlib2 will blend images onto a drawable whilst
rendering to that drawable. 1 means yes and 0 means no.
Imlib_Color_Modifier imlib_context_get_color_modifier(void);
Returns the current colormodifier being used.
Imlib_Operation imlib_context_get_operation(void);
Returns the current operation mode.
Imlib_Font imlib_context_get_font(void);
Returns the current font.
double imlib_context_get_angle(void);
Returns the current angle used to render text at if the direction
is IMLIB_TEXT_TO_ANGLE.
Imlib_Text_Direction imlib_context_get_direction(void);
Returns the current direction to render text in.
void imlib_context_get_color(int *red, int *green, int *blue, int *alpha);
Returns the current color for rendering text, rectangles and
lines.
Imlib_Color *imlib_context_get_imlib_color(void);
Returns the current color as a color struct. Do NOT free this
pointer.
Imlib_Color_Range imlib_context_get_color_range(void);
Return the current color range being used for gradients.
Imlib_Progress_Function imlib_context_get_progress_function(void);
Return the current progress function being used.
char imlib_context_get_progress_granularity(void);
Get the current progress granularity being used.
Imlib_Image imlib_context_get_image(void);
Return the current context image.
Imlib_Filter imlib_context_get_filter(void);
Get the current context image filter.
int imlib_get_cache_size(void);
Return the current size of the image cache in bytes. The cache
is a unified cache used for image data AND pixmaps.
void imlib_set_cache_size(int bytes);
Set the cache size. The size is in bytes. Setting the cache
size to 0 effectively flushes the cache and keeps the cache size at 0 until
set to another value. Whenever you set the cache size Imlib2 will flush
as many old images and pixmap from the cache as needed until the current
cache usage is less than or equal to the cache size.
int imlib_get_color_usage(void);
Get the number of colors Imlib2 currently at a maximum is allowed
to allocate for rendering. The default is 256.
void imlib_set_color_usage(int max);
Set the maximum number of colors you would like Imlib2 to allocate
for you when rendering. The default ids 256. This has no effect in depths
greater than 8 bit.
void imlib_flush_loaders(void);
If you want Imlib2 to forcibly flush any cached loaders it
has and re-load them from disk (this is useful if the program just installed
a new loader and does not want to wait till Imlib2 deems it an optimal
time to rescan the loaders)
int imlib_get_visual_depth(Display *display,
Visual *visual);
Convenience function that returns the depth of a visual for
that display.
Visual *imlib_get_best_visual(Display *display,
int screen,
int *depth_return);
Returns the visual for that display and screen that Imlib2
thinks will give you the best quality output. depth_return should point
to an int that will be filled with the depth of that visual too.
Imlib_Image imlib_load_image(const char *file);
This function loads an image from disk located at the path
specified by file. Please see the "How image loading works" section for
more detail. Returns an image handle on success or NULL on failure.
Imlib_Image imlib_load_image_immediately(const char *file);
Loads an image from disk located at the path specified by file.
This forces the image data to be decoded at load time too, instead of decoding
being deferred until it is needed. Returns an image handle on success or
NULL on failure.
Imlib_Image imlib_load_image_without_cache(const char *file);
This loads the image without looking in the cache first. Returns
an image handle on success or NULL on failure.
Imlib_Image imlib_load_image_immediately_without_cache(const char *file);
Loads the image without deferred image data decoding (i.e.
it is decoded straight away) and without looking in the cache. Returns
an image handle on success or NULL on failure.
Imlib_Image imlib_load_image_with_error_return(const char *file,
Imlib_Load_Error *error_return);
This loads an image at the path file on disk. If it succeeds
it returns a valid image handle, if not NULL is returned and the error_return
pointed to is set to the detail of the error.
void imlib_free_image(void);
This frees the image that is set as the current image in Imlib2's
context.
void imlib_free_image_and_decache(void);
Frees the current image in Imlib2's context AND removes it
from the cache.
int imlib_image_get_width(void);
Returns the width in pixels of the current image in Imlib2's
context.
int imlib_image_get_height(void);
Returns the height in pixels of the current image in Imlib2's
context.
const char *imlib_image_get_filename(void);
This returns the filename for the file that is set as the current
context. The pointer returned is only valid as long as no operations cause
the filename of the image to change. Saving the file with a different name
would cause this. It is suggested you duplicate the string if you wish
to continue to use the string for later processing. Do not free the string
pointer returned by this function.
DATA32 *imlib_image_get_data(void);
This returns a pointer to the image data in the image set as
the image for the current context. When you get this pointer it is assumed
you are planning on writing to the data, thus once you do this the image
can no longer be used for caching - in fact all images cached from this
one will also be affected when you put the data back. If this matters it
is suggested you clone the image first before playing with the image data.
The image data is returned in the format of a DATA32 (32 bits) per pixel
in a linear array ordered from the top left of the image to the bottom
right going from left to right each line. Each pixel has the upper 8 bits
as the alpha channel and the lower 8 bits are the blue channel - so a pixel's
bits are ARGB (from most to least significant, 8 bits per channel). You
must put the data back at some point.
DATA32 *imlib_image_get_data_for_reading_only(void);
This functions the same way as imlib_image_get_data(), but
returns a pointer expecting the program to NOT write to the data returned
(it is for inspection purposes only). Writing to this data has undefined
results. The data does not need to be put back.
void imlib_image_put_back_data(DATA32 *data);
This will put back data when it was obtained by imlib_image_get_data().
The data must be the same pointer returned by imlib_image_get_data(). This
operated on the current context image.
char imlib_image_has_alpha(void);
Returns 1 if the current context image has an alpha channel,
or 0 if it does not (the alpha data space is still there and available
- just "unused").
void imlib_image_set_changes_on_disk(void);
By default Imlib2 will not check the timestamp of an image
on disk and compare it with the image in its cache - this is to minimize
disk activity when using the cache. Call this function and it will flag
the current context image as being liable to change on disk and Imlib2
will check the timestamp of the image file on disk and compare it with
the cached image when it next needs to use this image in the cache.
void imlib_image_get_border(Imlib_Border *border);
This function fills the Imlib_Border structure to which border
points to with the values of the border of the current context image. The
border is the area at the edge of the image that does not scale with the
rest of the image when resized - the borders remain constant in size. This
is useful for scaling bevels at the edge of images differently to the image
center.
void imlib_image_set_border(Imlib_Border *border);
This sets the border of the current context image to the values
contained in the Imlib_Border structure border points to.
void imlib_image_set_format(const char *format);
This sets the format of the current image. This is used for
when you wish to save an image in a different format that it was loaded
in, or if the image currently has no file format associated with it.
void imlib_image_set_irrelevant_format(char irrelevant);
This sets if the format value of the current image is irrelevant
for caching purposes - by default it is. pass irrelevant as 1 to make it
irrelevant and 0 to make it relevant for caching.
void imlib_image_set_irrelevant_border(char irrelevant);
This sets if the border of the current image is irrelevant
for caching purposes. By default it is. Set irrelevant to 1 to make it
irrelevant, and 0 to make it relevant.
void imlib_image_set_irrelevant_alpha(char irrelevant);
This sets if the alpha channel status of the current image
(i.e. if there is or is not one) is important for caching purposes. By
default it is not. Set irrelevant to 1 to make it irrelevant and 0 to make
it relevant.
char *imlib_image_format(void);
This returns the current image's format. Do not free this string.
Duplicate it if you need it for later use.
void imlib_image_set_has_alpha(char has_alpha);
Sets the alpha flag for the current image. Set has_alpha to
1 to enable the alpha channel in the current image, or 0 to disable it.
void imlib_render_pixmaps_for_whole_image(Pixmap *pixmap_return,
Pixmap *mask_return);
This function will create a pixmap of the current image (and
a mask if the image has an alpha value) and return the id's of the pixmap
and mask to the pixmap_return and mask_return pixmap id's. You must free
these pixmaps using Imlib2's free function imlib_free_pixmap_and_mask();.
void imlib_render_pixmaps_for_whole_image_at_size(Pixmap *pixmap_return,
Pixmap *mask_return,
int width,
int height);
This function works just like imlib_render_pixmaps_for_whole_image(),
but will scale the output result to the width and height specified. Scaling
is done before depth conversion so pixels used for dithering don't grow
large.
void imlib_free_pixmap_and_mask(Pixmap pixmap);
This will free the pixmap (and any mask generated in association
with that pixmap). The pixmap will remain cached until the image the pixmap
was generated from is dirtied or decached, or the cache is flushed.
void imlib_render_image_on_drawable(int x, int y);
This renders the current image onto the current drawable at
the x, y pixel location specified without scaling.
void imlib_render_image_on_drawable_at_size(int x,
int y,
int width,
int height);
This will render the current image onto the current drawable
at the x, y location specified AND scale the image to the width and height
specified.
void imlib_render_image_part_on_drawable_at_size(int source_x,
int source_y,
int source_width,
int source_height,
int x,
int y,
int width,
int height);
This renders the source x, y, width, height pixel rectangle
from the current image onto the current drawable at the x, y location scaled
to the width and height specified.
void imlib_blend_image_onto_image(Imlib_Image source_image,
char merge_alpha,
int source_x,
int source_y,
int source_width,
int source_height,
int destination_x,
int destination_y,
int destination_width,
int destination_height);
This will blend the source rectangle x, y, width, height from
the source_image onto the current image at the destination x, y location
scaled to the width and height specified. If merge_alpha is set to 1 it
will also modify the destination image alpha channel, otherwise the destination
alpha channel is left untouched.
Imlib_Image imlib_create_image(int width,
int height);
This creates a new blank image of size width and height. The
contents of this image at creation time are undefined (they could be garbage
memory). You are free to do whatever you like with this image. It is not
cached. On success an image handle is returned - on failure NULL is returned.
Imlib_Image imlib_create_image_using_data(int width,
int height,
DATA32 *data);
This creates an image from the image data specified with the
width and height specified. The image data must be in the same format as
imlib_image_get_data() would return. You are responsible for freeing this
image data once the image is freed - Imlib2 will not do that for you. This
is useful for when you already have static buffers of the same format Imlib2
uses (many video grabbing devices use such a format) and wish to use Imlib2
to render the results onto another image, or X drawable. You should free
the image when you are done with it. Imlib2 returns a valid image handle
on success or NULL on failure
Imlib_Image imlib_create_image_using_copied_data(int width,
int height,
DATA32 *data);
This works the same way as imlib_create_image_using_data()
but Imlib2 copies the image data to the image structure. You may now do
whatever you wish with the original data as it will not be needed anymore.
Imlib2 returns a valid image handle on success or NULL on failure.
Imlib_Image imlib_create_image_from_drawable(Pixmap mask,
int x,
int y,
int width,
int height,
char need_to_grab_x);
This will return an image (using the mask to determine the
alpha channel) from the current drawable. If the mask is 0 it will not
create a useful alpha channel in the image. It will create an image from
the x, y, width , height rectangle in the drawable. If need_to_grab_x is
1 it will also grab the X Server to avoid possible race conditions in grabbing.
If you have not already grabbed the server you MUST set this to 1. Imlib2
returns a valid image handle on success or NULL on failure.
Imlib_Image imlib_create_scaled_image_from_drawable(Pixmap mask,
int source_x,
int source_y,
int source_width,
int source_height,
int destination_width,
int destination_height,
char need_to_grab_x,
char get_mask_from_shape);
This will create an image from the current drawable (optionally
using the mask pixmap specified to determine alpha transparency) and scale
the grabbed data first before converting to an actual image (to minimize
reads from the frame buffer which can be slow). The source x, y, width,
height rectangle will be grabbed, scaled to the destination width and height,
then converted to an image. If need_to_grab_x is set to 1, X is grabbed
(set this to 1 unless you have already grabbed the server) and if get_mask_from_shape
and the current drawable is a window its shape is used for determining
the alpha channel. If successful this function will return a valid image
handle, otherwise NULL is returned.
char imlib_copy_drawable_to_image(Pixmap mask,
int x,
int y,
int width,
int height,
int destination_x,
int destination_y,
char need_to_grab_x);
This routine will grab a section of the current drawable (optionally
using the pixmap provided as a corresponding mask for that drawable - if
mask is 0 this is not used). It grabs the x, y, width, height rectangle
and places it at the destination x, y location in the current image. If
need_to_grab_x is 1 it will grab and ungrab the server whilst doing this
- you need to do this if you have not already grabbed the server.
Imlib_Image imlib_clone_image(void);
This creates an exact duplicate of the current image and returns
a valid image handle on success, or NULL on failure.
Imlib_Image imlib_create_cropped_image(int x,
int y,
int width,
int height);
This creates a duplicate of a x, y, width, height rectangle
in the current image and returns a valid image handle on success, or NULL
on failure.
Imlib_Image imlib_create_cropped_scaled_image(int source_x,
int source_y,
int source_width,
int source_height,
int destination_width,
int destination_height);
This function works the same as imlib_create_cropped_image()
but will scale the new image to the new destination width and height whilst
cropping.
Imlib_Updates imlib_updates_clone(Imlib_Updates updates);
This function creates a duplicate of the updates list passed
into the function.
Imlib_Updates imlib_update_append_rect(Imlib_Updates updates,
int x,
int y,
int w,
int h);
This function appends an update rectangle to the updates list
passed in (if the updates is NULL it will create a new updates list) and
returns a handle to the modified updates list (the handle may be modified
so only use the new updates handle returned)
Imlib_Updates imlib_updates_merge(Imlib_Updates updates,
int w,
int h);
This function takes an updates list, and modifies it by merging
overlapped rectangles and lots of tiny rectangles into larger rectangles
to minimize the number of rectangles in the list for optimized redrawing.
The new updates handle is now valid and the old one passed in is not.
Imlib_Updates imlib_updates_merge_for_rendering(Imlib_Updates updates,
int w,
int h);
This works almost exactly as imlib_updates_merge() but is more
lenient on the spacing between update rectangles - if they are very close
it amalgamates 2 smaller rectangles into 1 larger one.
void imlib_updates_free(Imlib_Updates updates);
This frees an updates list.
Imlib_Updates imlib_updates_get_next(Imlib_Updates updates);
This gets the next update in the updates list relative to the
one passed in.
void imlib_updates_get_coordinates(Imlib_Updates updates,
int *x_return,
int *y_return,
int *width_return,
int *height_return);
This returns the coordinates of an update.
void imlib_updates_set_coordinates(Imlib_Updates updates,
int x,
int y,
int width,
int height);
This modifies the coordinates of an update in an updates list.
void imlib_render_image_updates_on_drawable(Imlib_Updates updates,
int x,
int y);
Given an updates list (preferable already merged for rendering)
this will render the corresponding parts of the image to the current drawable
at an offset of x, y in the drawable.
Imlib_Updates imlib_updates_init(void);
This initializes an updates list before you add any updates
to it or merge it for rendering etc.
Imlib_Updates imlib_updates_append_updates(Imlib_Updates updates,
Imlib_Updates appended_updates);
This appends one updates list (appended_updates) to the updates
list (updates) and returns the new list.
void imlib_image_flip_horizontal(void);
This will flip/mirror the current image horizontally.
void imlib_image_flip_vertical(void);
This will flip/mirror the current image vertically.
void imlib_image_flip_diagonal(void);
This will flip/mirror the current image diagonally (good for
quick and dirty 90 degree rotations if used before to after a horizontal
or vertical flip).
void imlib_image_orientate(int orientation);
This will perform 90 degree rotations on the current image.
Passing in orientation does not rotate, 1 rotates clockwise by 90 degree,
2, rotates clockwise by 180 degrees, 3 rotates clockwise by 270 degrees.
void imlib_image_blur(int radius);
This will blur the current image. A radius of 0 has no effect,
1 and above determine the blur matrix radius that determine how much to
blur the image.
void imlib_image_sharpen(int radius);
This sharpens the current image. The radius affects how much
to sharpen by.
void imlib_image_tile_horizontal(void);
This modifies an image so it will tile seamlessly horizontally
if used as a tile (i.e. drawn multiple times horizontally)
void imlib_image_tile_vertical(void);
This modifies an image so it will tile seamlessly vertically
if used as a tile (i.e. drawn multiple times vertically)
void imlib_image_tile(void);
This modifies an image so it will tile seamlessly horizontally
and vertically if used as a tile (i.e. drawn multiple times horizontally
and vertically)
Imlib_Font imlib_load_font(const char *font_name);
This function will load a truetype font from the first directory
in the font path that contains that font. The font name format is "font_name/size".
For example. If there is a font file called blum.ttf somewhere in the font
path you might use "blum/20" to load a 20 pixel sized font of blum. If
the font cannot be found NULL is returned.
void imlib_free_font(void);
This frees the current font.
void imlib_text_draw(int x, int y, const char *text);
Call this function to draw the nul-byte terminated string text
using the current font on the current image at the x, y location (x, y
denoting the top left corner of the font string)
void imlib_text_draw_with_return_metrics(int x,
int y,
const char *text,
int *width_return,
int *height_return,
int *horizontal_advance_return,
int *vertical_advance_return);
This function works just like imlib_text_draw() but also returns
the width and height of the string drawn, and horizontal_advance_return
returns the number of pixels you should advance horizontally to draw another
string (useful if you are drawing a line of text word by word) and vertical_advance_return
does the same for the vertical direction (i.e. drawing text line by line).
void imlib_get_text_size(const char *text,
int *width_return,
int *height_return);
This function returns the width and height in pixels the text
string would use up if drawn with the current font.
void imlib_add_path_to_font_path(const char *path);
This function adds the directory path to the end of the current
list of directories to scan for fonts.
void imlib_remove_path_from_font_path(const char *path);
This function removes all directories in the font path that
match the path specified.
char **imlib_list_font_path(int *number_return);
This returns a list of strings that are the directories in
the font path. Do not free this list or change it in any way. If you add
or delete members of the font path this list will be invalid. If you intend
to use this list later duplicate it for your own use. The number of elements
in the array of strings is put into number_return.
int imlib_text_get_index_and_location(const char *text,
int x,
int y,
int *char_x_return,
int *char_y_return,
int *char_width_return,
int *char_height_return);
This will return the character number in the string text using
the current font at the x, y pixel location which is an offset relative
to the top left of that string. -1 is returned if there is no character
there. If there is a character, character x, y, width and height are also
filled in.
void imlib_text_get_location_at_index(const char *text,
int index,
int *char_x_return,
int *char_y_return,
int *char_width_return,
int *char_height_return);
This will return the geometry of the character at index index
in the text string using the current font.
char **imlib_list_fonts(int *number_return);
This returns a list of fonts imlib2 can find in its font path.
void imlib_free_font_list(char **font_list,
int number);
This will free the font list returned by imlib_list_fonts().
int imlib_get_font_cache_size(void);
This returns the font cache size in bytes.
void imlib_set_font_cache_size(int bytes);
This sets the font cache in bytes. Whenever you set the font
cache size Imlib2 will flush fonts from the cache until the memory used
by fonts is less than or equal to the font cache size. Setting the size
to 0 effectively frees all speculatively cached fonts.
void imlib_flush_font_cache(void);
This will cause a flush of all speculatively cached fonts from
the font cache.
int imlib_get_font_ascent(void);
Returns the current font's ascent value in pixels.
int imlib_get_font_descent(void);
Returns the current font's descent value in pixels.
int imlib_get_maximum_font_ascent(void);
Returns the current font's maximum ascent extent.
int imlib_get_maximum_font_descent(void);
Returns the current font's maximum descent extent.
Imlib_Color_Modifier imlib_create_color_modifier(void);
This function creates a new empty color modifier and returns
a valid handle on success. NULL is returned on failure.
void imlib_free_color_modifier(void);
Calling this function frees the current color modifier.
void imlib_modify_color_modifier_gamma(double gamma_value);
This function modifies the current color modifier by adjusting
the gamma by the value specified. The color modifier is modified not set,
so calling this repeatedly has cumulative effects. A gamma of 1.0 is normal
linear, 2.0 brightens and 0.5 darkens etc. Negative values are not allows.
void imlib_modify_color_modifier_brightness(double brightness_value);
This function modifies the current color modifier by adjusting
the brightness by the value specified. The color modifier is modified not
set, so calling this repeatedly has cumulative effects. brightness values
of 0 do not affect anything. -1.0 will make things completely black and
1.0 will make things all white. Values in-between vary brightness linearly.
void imlib_modify_color_modifier_contrast(double contrast_value);
This function modifies the current color modifier by adjusting
the contrast by the value specified. The color modifier is modified not
set, so calling this repeatedly has cumulative effects. Contrast of 1.0
does nothing. 0.0 will merge to gray, 2.0 will double contrast etc.
void imlib_set_color_modifier_tables(DATA8 *red_table,
DATA8 *green_table,
DATA8 *blue_table,
DATA8 *alpha_table);
This function explicitly copies the mapping tables from the
table pointers passed into this function into those of the current color
modifier. Tables are 256 entry arrays of DATA8 which are a mapping of that
channel value to a new channel value. A normal mapping would be linear
(v[0] = 0, v[10] = 10, v[50] = 50, v[200] = 200, v[255] = 255).
void imlib_get_color_modifier_tables(DATA8 *red_table,
DATA8 *green_table,
DATA8 *blue_table,
DATA8 *alpha_table);
This copies the table values from the current color modifier
into the pointers to mapping tables specified. They must have 256 entries
and be DATA8 format.
void imlib_reset_color_modifier(void);
This function resets the current color modifier to have linear
mapping tables.
void imlib_apply_color_modifier(void);
This uses the current color modifier and modifies the current
image using the mapping tables in the current color modifier.
void imlib_apply_color_modifier_to_rectangle(int x,
int y,
int width,
int height);
This works the same way as imlib_apply_color_modifier() but
only modifies a selected rectangle in the current image.
Imlib_Updates imlib_image_draw_line(int x1,
int y1,
int x2,
int y2,
char make_updates);
Draw a line using the current color on the current image from
coordinates x1, y1 to x2, y2. If make_updates is 1 it will also return
an update you can use for an updates list, otherwise it returns NULL.
void imlib_image_draw_rectangle(int x,
int y,
int width,
int height);
This draws the outline of a rectangle on the current image
at the x, y coordinates with a size of width and height pixels, using the
current color.
void imlib_image_fill_rectangle(int x,
int y,
int width,
int height);
This draws a filled rectangle on the current image at the x,
y coordinates with a size of width and height pixels, using the current
color.
void imlib_image_copy_alpha_to_image(Imlib_Image image_source,
int x,
int y);
This copies the alpha channel of the source image to the x,
y coordinates of the current image, replacing the alpha channel there.
void imlib_image_copy_alpha_rectangle_to_image(Imlib_Image image_source,
int x,
int y,
int width,
int height,
int destination_x,
int destination_y);
This copies the source x, y, width, height rectangle alpha
channel from the source image and replaces the alpha channel on the destination
image at the x, y, coordinates.
void imlib_image_scroll_rect(int x,
int y,
int width,
int height,
int delta_x,
int delta_y);
This scrolls a rectangle at x, y, width, height within the
current image by the delta x, y distance (in pixels).
void imlib_image_copy_rect(int x,
int y,
int width,
int height,
int new_x,
int new_y);
This copies a rectangle of size width, height at the x, y location
specified in the current image to a new location x, y in the same image.
Imlib_Color_Range imlib_create_color_range(void);
This creates a new empty color range and returns a valid handle
to that color range.
void imlib_free_color_range(void);
This frees the current color range.
void imlib_add_color_to_color_range(int distance_away);
This adds the current color to the current color range at a
distance_away distance from the previous color in the range (if it's the
first color in the range this is irrelevant).
void imlib_image_fill_color_range_rectangle(int x,
int y,
int width,
int height,
double angle);
This fills a rectangle of width and height at the x, y location
specified in the current image with a linear gradient of the current color
range at an angle of angle degrees with 0 degrees being vertical from top
to bottom going clockwise from there.
void imlib_image_query_pixel(int x,
int y,
Imlib_Color *color_return);
This fills the color_return color structure with the color
of the pixel in the current image that is at the x, y location specified.
void imlib_image_attach_data_value(const char *key,
void *data,
int value,
Imlib_Data_Destructor_Function destructor_function);
This attaches data to the current image with the string key
of key, and the data of data and an integer of value. The destructor function,
if not NULL is called when this image is freed so the destructor can free
the data, if this is needed.
void *imlib_image_get_attached_data(const char *key);
This returns the data attached to the current image with the
key specified. NULL is returned if no data could be found with that key
on the current image.
int imlib_image_get_attached_value(const char *key);
This returns the value attached to the current image with the
specified key. If none could be found 0 is returned.
void imlib_image_remove_attached_data_value(const char *key);
This detaches the data & value attached with the specified
key from the current image.
void imlib_image_remove_and_free_attached_data_value(const char *key);
This removes the data and value attached to the current image
with the specified key and also calls the destructor function that was
supplied when attaching it.
void imlib_save_image(const char *filename);
This saves the current image in the format specified by the
current image's format settings to the filename specified.
void imlib_save_image_with_error_return(const char *filename,
Imlib_Load_Error *error_return);
This works the same way imlib_save_image() works, but will
set the error_return to an error value if the save fails.
Imlib_Image imlib_create_rotated_image(double angle);
This creates an new copy of the current image, but rotated
by angle degrees. On success it returns a valid image handle, otherwise
NULL.
void imlib_blend_image_onto_image_at_angle(Imlib_Image source_image,
char merge_alpha,
int source_x,
int source_y,
int source_width,
int source_height,
int destination_x,
int destination_y,
int angle_x,
int angle_y);
This function works just like imlib_blend_image_onto_image_skewed() except
you cannot skew an image (v_angle_x and v_angle_y are 0).
void imlib_blend_image_onto_image_skewed(Imlib_Image source_image,
char merge_alpha,
int source_x,
int source_y,
int source_width,
int source_height,
int destination_x,
int destination_y,
int h_angle_x,
int h_angle_y,
int v_angle_x,
int v_angle_y);
This will blend the source rectangle x, y, width, height from the
source_image onto the current image at the destination x, y location.
It will be rotated and scaled so that the upper right corner will be
positioned h_angle_x pixels to the right (or left, if negative) and
h_angle_y pixels down (from destination_[x|y]).
If v_angle_x and v_angle_y are not 0, the image will also be skewed
so that the lower left corner will be positioned v_angle_x pixels to
the right and v_angle_y pixels down.
The at_angle versions simply have the v_angle_x and v_angle_y set to 0
so the rotation doesn't get skewed, and the render_..._on_drawable ones
seem obvious enough; they do the same on a drawable.
Examples:
- imlib_blend_image_onto_image_skewed(..., 0, 0, 100, 0, 0, 100);
will simply scale the image to be 100x100.
- imlib_blend_image_onto_image_skewed(..., 0, 0, 0, 100, 100, 0);
will scale the image to be 100x100, and flip it diagonally.
- imlib_blend_image_onto_image_skewed(..., 100, 0, 0, 100, -100, 0);
will scale the image and rotate it 90 degrees clockwise.
- imlib_blend_image_onto_image_skewed(..., 50, 0, 50, 50, -50, 50);
will rotate the image 45 degrees clockwise, and will scale it so its
corners are at (50,0)-(100,50)-(50,100)-(0,50) i.e. it fits into
the 100x100 square, so it's scaled down to 70.7% (sqrt(2)/2).
- imlib_blend_image_onto_image_skewed(..., 50, 50, 100 * cos(a), 100 * sin(a), 0);
will rotate the image `a' degrees, with its upper left corner at
(50,50).
void imlib_render_image_on_drawable_skewed(int source_x,
int source_y,
int source_width,
int source_height,
int destination_x,
int destination_y,
int h_angle_x,
int h_angle_y,
int v_angle_x,
int v_angle_y);
This works just like imlib_blend_image_onto_image_skewed(), except it blends
the image onto the current drawable instead of the current image.
void imlib_render_image_on_drawable_at_angle(int source_x,
int source_y,
int source_width,
int source_height,
int destination_x,
int destination_y,
int angle_x,
int angle_y);
This function works just like imlib_render_image_on_drawable_skewed() except
you cannot skew an image (v_angle_x and v_angle_y are 0).
void imlib_context_set_cliprect(int x, int y, int w, int h);
Sets the current clipping rectangle to (x,y w*h). The clipping rectangle
effects all image drawing functions and prevents the area outside the
rectangle from being edited. Set w to 0 to disable clipping.
int imlib_clip_line(int x0, int y0, int x1, int y1, int xmin, int xmax, int ymin, int ymax, int *clip_x0, int *clip_y0, int *clip_x1, int *clip_y1);
A utility function to return clipped line coordinates.
void imlib_polygon_new(void);
Returns a new polygon object with no points set.
void imlib_polygon_free(ImlibPolygon poly);
Frees a polygon object.
void imlib_polygon_add_point(ImlibPolygon poly, int x, int y);
Adds the point (x,y) to a polygon object. The point will be added to the
end of the polygon's internal point list. The points are drawn in order,
from the first to the last.
void imlib_image_draw_polygon(ImlibPolygon poly, unsigned char closed);
Draws a polygon onto the current context image. Points which have been
added to the polygon are drawn in sequence, first to last. The final point will be
joined with the first point if closed is non-zero.
void imlib_image_fill_polygon(ImlibPolygon poly);
Fill the area defined by the polygon on the current context image with
the current context colour.
void imlib_polygon_get_bounds(ImlibPolygon poly, int *px1, int *py1, int *px2, int *py2);
Calculate the bounding area of the polygon. (px1, py1) defines the upper
left corner of the bounding box and (px2, py2) defines it's lower right
corner.
unsigned char imlib_polygon_contains_point(ImlibPolygon poly, int x, int y);
Returns non-zero if the point (x,y) is within the area defined by the
polygon.
void imlib_image_draw_ellipse(int xc, int yc, int a, int b);
Draw an ellipse on the current context image. The ellipse is defined as (x-xc)^2/a^2 + (y-yc)^2/b^2 = 1. This means that the point (xc,yc) marks the center of the ellipse, a defines the horizontal amplitude of the ellipse, and b defines the vertical amplitude.
void imlib_image_fill_ellipse(int xc, int yc, int a, int b);
Fills an ellipse on the current context image using the current context colour. The ellipse is defined as (x-xc)^2/a^2 + (y-yc)^2/b^2 = 1. This means that the point (xc,yc) marks the center of the ellipse, a defines the horizontal amplitude of the ellipse, and b defines the vertical amplitude.
void imlib_image_filter(void);
Imlib_Filter imlib_create_filter(int initsize);
void imlib_free_filter(void);
void imlib_filter_set(int xoff,
int yoff,
int a,
int r,
int g,
int b);
void imlib_filter_set_alpha(int xoff,
int yoff,
int a,
int r,
int g,
int b);
void imlib_filter_set_red(int xoff,
int yoff,
int a,
int r,
int g,
int b);
void imlib_filter_set_green(int xoff,
int yoff,
int a,
int r,
int g,
int b);
void imlib_filter_set_blue(int xoff,
int yoff,
int a,
int r,
int g,
int b);
void imlib_filter_constants(int a,
int r,
int g,
int b);
void imlib_filter_divisors(int a,
int r,
int g,
int b);
void imlib_apply_filter( char *script, ... );
|
|