diff --git a/TODO b/TODO index a950308..897196c 100644 --- a/TODO +++ b/TODO @@ -2,5 +2,3 @@ path rendering is correct for that visual * formalize loader/saver api * fix loaders to only build if libs are present -* move db loader/saver to use edb -* bug in mmx image -> image blending skips 1 line high segments diff --git a/doc/blank.gif b/doc/blank.gif new file mode 100644 index 0000000..60fa7a1 Binary files /dev/null and b/doc/blank.gif differ diff --git a/doc/imlib2.gif b/doc/imlib2.gif new file mode 100644 index 0000000..1fcd7f3 Binary files /dev/null and b/doc/imlib2.gif differ diff --git a/doc/index.html b/doc/index.html new file mode 100644 index 0000000..de68cc7 --- /dev/null +++ b/doc/index.html @@ -0,0 +1,1704 @@ + + + + + + + Imlib 2 - Documentation. + + + +
+

+Imlib2

+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
What +is it?
Imlib 2 is the successor +to Imlib. It is NOT a newer version - it is a completely new library. Imlib +2 can be installed alongside Imlib 1.x without any problems since they +are effectively different libraries - BUT they Have very similar functionality. +

Imlib 2 does the following: +

    +
  • +Load image files from disk in one of many formats
    • + +
  • +Save images to disk in one of many formats
    • + +
  • +Render image data onto other images
    • + +
  • +Render images to an X-Windows drawable
    • + +
  • +Produce pixmaps and pixmap masks of Images
    • + +
  • +Apply filters to images
    • + +
  • +Rotate images
    • + +
  • +Accept RGBA Data for images
    • + +
  • +Scale images
    • + +
  • +Alpha blend Images on other images or drawables
    • + +
  • +Apply color correction and modification tables and factors to images
    • + +
  • +Render images onto images with color correction and modification tables
    • + +
  • +Render truetype anti-aliased text
    • + +
  • +Render truetype anti-aliased text at any angle
    • + +
  • +Render anti-aliased lines
    • + +
  • +Render rectangles
    • + +
  • +Render linear multi-coloured gradients
    • + +
  • +Cache data intelligently for maximum performance
    • + +
  • +Allocate colours automatically
    • + +
  • +Allow full control over caching and colour allocation
    • + +
  • +Provide highly optimized MMX assembly for core routines
    • + +
  • +Provide plug-in filter interface
    • + +
  • +Provide on-the-fly runtime plug-in image loading and saving interface
    • + +
  • +Fastest image compositing, rendering and manipulation library for X
    • +
+If what you want isn't in the list above somewhere then likely Imlib 2 +does not do it. If it does it it likely does it faster than any other library +you can find (this includes gdk-pixbuf, gdkrgb, etc.) primarily because +of highly optimized code and a smart subsystem that does the dirty work +for you and picks up the pieces for you so you can be lazy and let all +the optimizations for FOR you. +

Imlib 2 can run without a display, so it can be easily used for background +image processing for websites or servers - it onyl requires the X libraries +to be installed - that is all - it does not require an Xserver to run unless +you wish to display images. +

The interface is simple - once you get used to it, the functions do +exactly what they say they do.

+ +
  +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
A +Simple Example
The best way to start +is to show a simple example of an Imlib2 program. This one will load an +image of any format you have a loader installed for (all loaders are dynamic +code objects that imlib2 will use and update automatically runtime - anyone +is free to write a loader. All that has to be done is for the object to +be dropped into the loaders directory with the others and all imlib2 programs +will automatically be able to use it - without a restart). +
/* standard headers */
+#include <X11/Xlib.h>
+#include <Imlib2.h>
+#include <stdio.h>
+#include <string.h>
+
+/* main program */
+int main(int argc, char **argv)
+{
+  /* an image handle */
+  Imlib_Image image;
+  
+  /* if we provided < 2 arguments after the command - exit */
+  if (argc != 3) exit(1);
+  /* load the image */
+  image = imlib_load_image(argv[1]);
+  /* if the load was successful */
+  if (image)
+    {
+      /* set the image we loaded as the current context image to work on */
+      imlib_context_set_image(image);
+      /* set the image format to be the format of the extension of our last */
+      /* argument - ie .png = png, .tif = tiff etc. */
+      imlib_image_set_format(strrchr(argv[2], '.') + 1);
+      /* save the image */
+      imlib_save_image(argv[2]);
+    }
+}
+Now to compile this +
cc imlib2_convert.c -o imlib2_convert `imlib2-config --cflags` `imlib2-config --libs`
+You now have a program that if used as follows: +
./imlib2_convert image1.jpg image2.png
+will convert image1.jpg into a png called image2.png. It is that simple.
+ +
  +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
How +Image Loading Works
It is probably a +good idea to discuss how Imlib2 actually loads an Image so the programmer +knows what is going on, how to take advantage of the optimizations already +there and to explain why things work as they do. +
  +
+

+Loading using imlib_load_image();

+This is likey to be by far the most common way to load an image - when +you don't really care about the details of the loading process or why it +failed - all you care about is if you got a valid image handle. +

When you call this function Imlib2 attempts to find the file specified +as the parameter. This will involve Imlib2 first checking to see if that +file path already has been loaded and is in Imlib2's cache (a cache of +already decoded images in memory to save having to load and decode from +disk all the time). If there alrady is a copy in the cache (either already +active or speculatively cached from a previous load & free) this copy +will have its handle returned instead of Imlib2 checking on disk (in some +circumstances this is not true - see later in this section to find out). +This means if your program blindly loads an Image, renders it, then frees +it - then soon afterwards loads the same image again, it will not be loaded +from disk at all, instead it will simply be re-refernced from the cache +- meaning the load will be almost instant. A great way to take full advantage +of this is to set the cache to some size you are happy with for the image +data being used by yout application and then all rendering o an image follows +the pseudocode: +

set cache to some amount (eg 4 Mb)
+...
+rendering loop ...
+    load image
+    render image
+    free image
+... continue loop
+This may normally sound silly - load image, render then free - EVERY time +we want to use it, BUT - it is actually the smartest way to use Imlib2 +- since the caching will find the image for you in the cache - you do not +need to manage your own cache, or worry about filling up memory with image +data - only as much memory as you have set for the cache sizae will actually +ever be used to store image data - if you have lots of image data to work +with then increase the cache size for better perfromance, but this is the +only thing you need to worry about. you won't have problems fo accidentally +forgetting to free images later since you free them immediately after use. +

Now what happens if the file changes on disk while it's in cahe? By +default nothing. The file is ignored. This is an optimization (to avoid +hitting the disk to check if the file changed for every load if it's cached). +You can inform Imlib2 that you care about this by using the imlib_image_set_changes_on_disk(); +call. +Do this whenever you load an Image that you expect will change on disk, +and the fact that it changes really matters. Remember this will marginally +reduce the caching performance. +

Now what actually happens when we try and load +an image using a filename? First the filename is broken down into 2 parts. +the filename before a colon (:) and the key after the colon. This means +when we have a filename like: +

/path/to/file.jpg +

the filename is: +

/path/to/file.jpg +

and the key is blank. If we have: +

/path/to/file.db:key.value/blah +

the filename is: +

/path/to/file.db +

and the key is: +

key.value/blah +

You may ask what is this thing with keys and filenames? +Well Imlib2 has loaders that are able to load data that is WITHIN a file +(the loader capable of this right now is the database loader that is able +to laod image data stroed with a key in a berkley-db database file). The +colon is used to delimit where the filename ends and the key begins. Fro +the majority of files you load you won't have to worry, but there is a +limit in this case that filenames cannot contain a color character. +

First Imlib2 checks to see if the file exists +and that you have permission to read it. If this fails it will abort the +load. Now that it has checked that this is the case it evaulates that it's +list of dynamically loaded loader modules it up to date then it runs through +the loader modules until one of them claims it can load this file. If this +is the case  that loader is now used to decode the image and return +an Image handle to the calling program. If the loader is written correctly +and the file format sanely supports this, the laoder will NOT decode any +image data at this point. It will ONLY read the header of the image to +figure out its size, if it has an alpha channel, format and any other header +information. The loader is rememebred and it will be re-used to load the +image data itself later if and ONLY if the actual image data itself is +needed. This means you can scan vast directories of files figuring their +format and size and other such information just by loading and freeing +- and it will be fast because no image data is decoded. You can take advantage +of this by loading the image anc checkign its size to calculate the size +of an output area before you vere load the data. This means  geometry +calculations can be doen fast ahead of time. +

If you desire more detailed information about +why a load failed you can use imlib_load_image_with_error_return(); +and +it will return a detailed error return code. +

If you do not wish to have the image data loaded +later using the optimized "deferred" method of loading, you can force the +data to be decoded immediately with imlib_load_image_immediately(); +

If you wish to bypass the cache when loading images +you can using imlib_load_image_without_cache(); +and +imlib_load_image_immediately_without_cache();. +

Sometimes loading images can take a while. Often +it is a good idea to provide feedback to the user whilst this is happening. +This is when you set the progress function callback. Setting this to NULL +will mean no progress function is called during load - this is the default. +When it is set you set it to a function that will get called every so often +(depending on the progress granularity) during load. Use imlib_context_set_progress_function(); +and imlib_context_set_progress_granularity(); +to +set this up.

+
+ +
  +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
Title
Hello
+ +
  +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
API +Reference
+
+		 +

+This is a list of all the Imlib2 API calls and what each of them do. You +should familiarise 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 colours. +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 wich 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 "anit-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 considrably better results. this +option has no effect foe rendering in 24 bit and up, but in 16bit and lower +it will dither, producing smooht 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 toehr +values in the same channel when rendering, allowing for fades, color +correction etc. to be done whisl 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 arbitary 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 colour with wich 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 colour 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 +ths 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);
+
+
+Retruns 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 colour 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 colro 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 +cahce 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 curretn cache useage is +less than or equal to the cache size. +
+

+int imlib_get_color_usage(void);
+
+
+Get the number of colros 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);
+
+
+Conveneince 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 withotu deferred image data decoding (ie 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 succedds 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 sugested 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 poitner +expecting the program to NOT write to the data returned (it is for +einspection pruposes 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 +comapre it with the image in its cache - this is to minimise 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 att he edge of the image that does not scale witht he 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 fromat 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 cachng 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 (ie 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 imagem 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 pximap 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);
+
+
+Thsi 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 fromn 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 frm 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 alreay dhave 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 shoudl 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 creat an image from the x, y, widht , +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);
+
+ +

+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);
+
+ +

+Imlib_Image imlib_clone_image(void);
+
+ +

+Imlib_Image imlib_create_cropped_image(int x, 
+                                       int y, 
+				       int width, 
+				       int height);
+
+ +

+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);
+
+ +

+Imlib_Updates imlib_updates_clone(Imlib_Updates updates);
+
+ +

+Imlib_Updates imlib_update_append_rect(Imlib_Updates updates, 
+                                       int x, 
+				       int y, 
+				       int w, 
+				       int h);
+
+ +

+Imlib_Updates imlib_updates_merge(Imlib_Updates updates, 
+                                  int w, 
+				  int h);
+
+ +

+Imlib_Updates imlib_updates_merge_for_rendering(Imlib_Updates updates, 
+                                                int w, 
+						int h);
+
+ +

+void imlib_updates_free(Imlib_Updates updates);
+
+ +

+Imlib_Updates imlib_updates_get_next(Imlib_Updates updates);
+
+ +

+void imlib_updates_get_coordinates(Imlib_Updates updates, 
+                                   int *x_return, 
+				   int *y_return, 
+				   int *width_return, 
+				   int *height_return);
+
+ +

+void imlib_updates_set_coordinates(Imlib_Updates updates, 
+                                   int x, 
+				   int y, 
+				   int width, 
+				   int height);
+
+ +

+void imlib_render_image_updates_on_drawable(Imlib_Updates updates, 
+                                            int x, 
+					    int y);
+
+ +

+Imlib_Updates imlib_updates_init(void);
+
+ +

+Imlib_Updates imlib_updates_append_updates(Imlib_Updates updates, 
+                                           Imlib_Updates appended_updates);
+
+ +

+void imlib_image_flip_horizontal(void);
+
+ +

+void imlib_image_flip_vertical(void);
+
+ +

+void imlib_image_flip_diagonal(void);
+
+ +

+void imlib_image_orientate(int orientation);
+
+ +

+void imlib_image_blur(int radius);
+
+ +

+void imlib_image_sharpen(int radius);
+
+ +

+void imlib_image_tile_horizontal(void);
+
+ +

+void imlib_image_tile_vertical(void);
+
+ +

+void imlib_image_tile(void);
+
+ +

+Imlib_Font imlib_load_font(const char *font_name);
+
+ +

+void imlib_free_font(void);
+
+ +

+void imlib_text_draw(int x, int y, const char *text);
+
+ +

+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);
+
+ +

+void imlib_get_text_size(const char *text, 
+                         int *width_return, 
+			 int *height_return);
+
+ +

+void imlib_add_path_to_font_path(const char *path);
+
+ +

+void imlib_remove_path_from_font_path(const char *path);
+
+ +

+char **imlib_list_font_path(int *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);
+
+ +

+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);
+
+ +

+char **imlib_list_fonts(int *number_return);
+
+ +

+void imlib_free_font_list(char **font_list, 
+                          int number);
+
+ +

+int imlib_get_font_cache_size(void);
+
+ +

+void imlib_set_font_cache_size(int bytes);
+
+ +

+void imlib_flush_font_cache(void);
+
+ +

+int imlib_get_font_ascent(void);
+
+ +

+int imlib_get_font_descent(void);
+
+ +

+int imlib_get_maximum_font_ascent(void);
+
+ +

+int imlib_get_maximum_font_descent(void);
+
+ +

+Imlib_Color_Modifier imlib_create_color_modifier(void);
+
+ +

+void imlib_free_color_modifier(void);
+
+ +

+void imlib_modify_color_modifier_gamma(double gamma_value);
+
+ +

+void imlib_modify_color_modifier_brightness(double brightness_value);
+
+ +

+void imlib_modify_color_modifier_contrast(double contrast_value);
+
+ +

+void imlib_set_color_modifier_tables(DATA8 *red_table, 
+                                     DATA8 *green_table, 
+				     DATA8 *blue_table, 
+				     DATA8 *alpha_table);
+
+ +

+void imlib_get_color_modifier_tables(DATA8 *red_table, 
+                                     DATA8 *green_table, 
+				     DATA8 *blue_table, 
+				     DATA8 *alpha_table);
+
+ +

+void imlib_reset_color_modifier(void);
+
+ +

+void imlib_apply_color_modifier(void);
+
+ +

+void imlib_apply_color_modifier_to_rectangle(int x, 
+                                             int y, 
+					     int width, 
+					     int height);
+
+ +

+Imlib_Updates imlib_image_draw_line(int x1, 
+                                    int y1, 
+				    int x2, 
+				    int y2, 
+				    char make_updates);
+
+ +

+void imlib_image_draw_rectangle(int x, 
+                                int y, 
+				int width, 
+				int height);
+
+ +

+void imlib_image_fill_rectangle(int x, 
+                                int y, 
+				int width, 
+				int height);
+
+ +

+void imlib_image_copy_alpha_to_image(Imlib_Image image_source, 
+                                     int x, 
+				     int y);
+
+ +

+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);
+
+ +

+void imlib_image_scroll_rect(int x, 
+                             int y, 
+			     int width, 
+			     int height, 
+			     int delta_x, 
+			     int delta_y);
+
+ +

+void imlib_image_copy_rect(int x, 
+                           int y, 
+			   int width, 
+			   int height, 
+			   int new_x, 
+			   int new_y);
+
+ +

+Imlib_Color_Range imlib_create_color_range(void);
+
+ +

+void imlib_free_color_range(void);
+
+ +

+void imlib_add_color_to_color_range(int distance_away);
+
+ +

+void imlib_image_fill_color_range_rectangle(int x, 
+                                            int y, 
+					    int width, 
+					    int height, 
+					    double angle);
+
+ +

+void imlib_image_query_pixel(int x, 
+                             int y, 
+			     Imlib_Color *color_return);
+
+ +

+void imlib_image_attach_data_value(const char *key, 
+                                   void *data, 
+				   int value, 
+				   Imlib_Data_Destructor_Function destructor_function);
+
+ +

+void *imlib_image_get_attached_data(const char *key);
+
+ +

+int imlib_image_get_attached_value(const char *key);
+
+ +

+void imlib_image_remove_attached_data_value(const char *key);
+
+ +

+void imlib_image_remove_and_free_attached_data_value(const char *key);
+
+ +

+void imlib_save_image(const char *filename);
+
+ +

+void imlib_save_image_with_error_return(const char *filename, 
+                                        Imlib_Load_Error *error_return);
+
+ +

+Imlib_Image imlib_create_rotated_image(double angle);
+
+ +

+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);
+
+ +

+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);
+
+ +

+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);
+
+ +

+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);
+
+ +

+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, ... );
+
+
+ + +