From f6e3a2eb9c8a6faf24b0ae3478f388618cf50140 Mon Sep 17 00:00:00 2001 From: Carsten Haitzler Date: Fri, 8 Sep 2000 18:39:28 +0000 Subject: [PATCH] add docs to cvs SVN revision: 3359 --- TODO | 2 - doc/blank.gif | Bin 0 -> 266 bytes doc/imlib2.gif | Bin 0 -> 6794 bytes doc/index.html | 1704 ++++++++++++++++++++++++++++++++++++++++++++++++ 4 files changed, 1704 insertions(+), 2 deletions(-) create mode 100644 doc/blank.gif create mode 100644 doc/imlib2.gif create mode 100644 doc/index.html 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 0000000000000000000000000000000000000000..60fa7a1acfebae5abb3f687985ff70ca668a9397 GIT binary patch literal 266 zcmZ?wbhEHbWMp7uSjxb_%*?Eypy1`@Ra;xz-rhcM-n<<(9l@1Vg(l$ z*S~-N?Ck8)($dbIJNKW)K=Ge~bACZ(QD%BZi9$$5szOj=aY<@XZepH-hO?%E5zv7Q aia%KxxftXbbQpjD$`}qe_6L%-1 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 literal 0 HcmV?d00001 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, ... );
+
+
+ + +