allocimage, allocimagemix, freeimage, nameimage, namedimage, setalpha, loadimage, cloadimage, unloadimage, readimage, writeimage, bytesperline, wordsperline – allocating, freeing, reading, writing images
Image *allocimage(Display *d, Rectangle r,
ulong chan, int repl, ulong col)
Image *allocimagemix(Display *d, ulong one, ulong three)
int freeimage(Image *i)
int nameimage(Image *i, char *name, int in)
Image *namedimage(Display *d, char *name)
ulong setalpha(ulong color, uchar alpha)
int loadimage(Image *i, Rectangle r, uchar *data, int ndata)
int cloadimage(Image *i, Rectangle r, uchar *data, int ndata)
int unloadimage(Image *i, Rectangle r, uchar *data, int ndata)
Image *readimage(Display *d, int fd, int dolock)
int writeimage(int fd, Image *i, int dolock)
int bytesperline(Rectangle r, int d)
int wordsperline(Rectangle r, int d)
DOpaque = 0xFFFFFFFF,
DTransparent = 0x00000000,
DBlack = 0x000000FF,
DWhite = 0xFFFFFFFF,
DRed = 0xFF0000FF,
DGreen = 0x00FF00FF,
DBlue = 0x0000FFFF,
DCyan = 0x00FFFFFF,
DMagenta = 0xFF00FFFF,
DYellow = 0xFFFF00FF,
DPaleyellow = 0xFFFFAAFF,
DDarkyellow = 0xEEEE9EFF,
DDarkgreen = 0x448844FF,
DPalegreen = 0xAAFFAAFF,
DMedgreen = 0x88CC88FF,
DDarkblue = 0x000055FF,
DPalebluegreen = 0xAAFFFFFF,
DPaleblue = 0x0000BBFF,
DBluegreen = 0x008888FF,
DGreygreen = 0x55AAAAFF,
DPalegreygreen = 0x9EEEEEFF,
DYellowgreen = 0x99994CFF,
DMedblue = 0x000099FF,
DGreyblue = 0x005DBBFF,
DPalegreyblue = 0x4993DDFF,
DPurpleblue = 0x8888CCFF,
DNotacolor = 0xFFFFFF00,
DNofill = DNotacolor,
is allocated with
it will have the rectangle, pixel channel format,
and initial fill color
given by its arguments.
Convenient pixel channels like
All the new image’s pixels will have initial value
no initialization is done.
Representative useful values of color are predefined:
and so on.
Colors are specified by 32-bit numbers comprising,
from most to least significant byte,
8-bit values for red, green, blue, and alpha.
The values correspond to illumination, so 0 is black and 255 is white.
Similarly, for alpha 0 is transparent and 255 is opaque.
field will have been set to the identifying number used by
field will be zero.
is true, the clip rectangle is set to a very large region; if false, it is set to
field will be set to the number of bits per pixel specified
by the channel descriptor
returns 0 if the server has run out of image memory.
is used to allocate background colors.
On 8-bit color-mapped displays, it
returns a 2×2 replicated image with one pixel colored
and the other three with
(This simulates a wider range of tones than can be represented by a single pixel
value on a color-mapped display.)
On true color displays, it returns a 1×1 replicated image
whose pixel is the result of mixing the two colors in
a one to three ratio.
frees the resources used by its argument image.
publishes in the server the image
under the given
is non-zero, the image is published; otherwise
must be already named
and it is withdrawn from publication.
returns a reference to the image published under the given
These routines permit unrelated applications sharing a display to share an image;
for example they provide the mechanism behind
The RGB values in a color are
by the alpha value; for example, a 50% red is
performs the alpha computation on a given
ignoring its initial alpha value, multiplying the components by the supplied
For example, to make a 50% red color value, one could execute
The remaining functions deal with moving groups of pixel
values between image and user space or external files.
There is a fixed format for the exchange and storage of
reads a rectangle of pixels from image
whose length is specified by
It is an error if
is too small to accommodate the pixels.
replaces the specified rectangle in image
The pixels are presented one horizontal line at a time,
starting with the top-left pixel of
In the data processed by these routines, each scan line starts with a new byte in the array,
leaving the last byte of the previous line partially empty, if necessary.
Pixels are packed as tightly as possible within
regardless of the rectangle being extracted.
Bytes are filled from most to least significant bit order,
coordinate increases, aligned so
would appear as the leftmost pixel of its byte.
1, the pixel at
offset 165 within the rectangle will be in a
byte at bit-position
regardless of the overall
rectangle: 165 mod 8 equals 5, and
0x80 >> 5
does the same as
bytes of compressed image
On each call to
must be at the beginning of a compressed data block, in particular,
it should start with the
coordinate and data length for the block.
return the number of bytes copied.
creates an image from data contained in an external file (see
for the file format);
is a file descriptor obtained by opening such a file for reading.
The returned image is allocated using
flag specifies whether the
should be synchronized for multithreaded access; single-threaded
programs can leave it zero.
onto file descriptor
which should be open for writing.
The format is as described for
do not close
return the number of bytes or words occupied in memory by one scan line of rectangle
in an image with
bits per pixel.
To allocate a single-pixel replicated image that may be used to paint a region red,
red = allocimage(display, Rect(0, 0, 1, 1), RGB24, 1, DRed);
These functions return pointer 0 or integer –1 on failure, usually due to insufficient
must be a divisor or multiple of 8.