path: root/man/Xcursor.man

.\"
.\" Copyright © 2002 Keith Packard
.\"
.\" Permission to use, copy, modify, distribute, and sell this software and its
.\" documentation for any purpose is hereby granted without fee, provided that
.\" the above copyright notice appear in all copies and that both that
.\" copyright notice and this permission notice appear in supporting
.\" documentation, and that the name of Keith Packard not be used in
.\" advertising or publicity pertaining to distribution of the software without
.\" specific, written prior permission.  Keith Packard makes no
.\" representations about the suitability of this software for any purpose.  It
.\" is provided "as is" without express or implied warranty.
.\"
.\" KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
.\" INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
.\" EVENT SHALL KEITH PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR
.\" CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
.\" DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
.\" TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
.\" PERFORMANCE OF THIS SOFTWARE.
.\"
.de NS
.sp
.ns
.TP \\$1
.na
.nf
..
.de NE
.br
.ad
.fi
.sp
..
.de bP
.ie n  .IP \(bu 4
.el    .IP \(bu 2
..
.ie \n(.g .ds `` \(lq
.el       .ds `` ``
.ie \n(.g .ds '' \(rq
.el       .ds '' ''
.TH XCURSOR __libmansuffix__ __xorgversion__ "Keith Packard"
.hy 0
.SH NAME
XCURSOR \- Cursor management library
.
.SH SYNOPSIS
.nf
.B #include <X11/Xcursor/Xcursor.h>
.fi
.SH DESCRIPTION
.B Xcursor
is a simple library designed to help locate and load cursors.
Cursors can be loaded from files or memory.
A library of common cursors exists which
map to the standard X cursor names.
Cursors can exist in several sizes and
the library automatically picks the best size.
.
.SH FUNCTIONAL OVERVIEW
Xcursor is built in a couple of layers; at the bottom layer is code which
can load cursor images from files.  Above that is a layer which locates
cursor files based on the library path and theme.  At the top is a layer
which builds cursors either out of an image loaded from a file or one of the
standard X cursors.  When using images loaded from files, Xcursor prefers
to use the Render extension CreateCursor request if supported by the X
server.  Where not supported, Xcursor maps the cursor image to a standard X
cursor and uses the core CreateCursor request.
.
.SS CURSOR FILES
Xcursor defines a new format for cursors on disk.  Each file holds
one or more cursor images.  Each cursor image is tagged with a nominal size
so that the best size can be selected automatically.  Multiple cursors of
the same nominal size can be loaded together; applications are expected to
use them as an animated sequence.
.P
Cursor files are stored as a header containing a table of contents followed
by a sequence of chunks.  The table of contents indicates the type, subtype
and position in the file of each chunk.  The file header looks like:
.LP
.in +.2i
\fImagic\fP\^:	CARD32 "Xcur" (0x58, 0x63, 0x75, 0x72)
.br
\fIheader\fP\^:	CARD32 bytes in this header
.br
\fIversion\fP\^:	CARD32 file version number
.br
\fIntoc\fP\^:	CARD32 number of toc entries
.br
\fItoc\fP\^:		LISTofTOC table of contents
.in -.2i
.P
Each table of contents entry looks like:
.LP
.in +.2i
\fItype\fP\^:	CARD32 entry type
.br
\fIsubtype\fP\^:	CARD32 type-specific label - size for images
.br
\fIposition\fP\^:	CARD32 absolute byte position of table in file
.in -.2i
.P
.P
Each chunk in the file has set of common header fields followed by
additional type-specific fields:
.LP
.in +.2i
\fIheader\fP\^:	CARD32 bytes in chunk header (including type-specific fields)
.br
\fItype\fP\^:	CARD32 must match type in TOC for this chunk
.br
\fIsubtype\fP\^:	CARD32 must match subtype in TOC for this chunk
.br
\fIversion\fP\^:	CARD32 version number for this chunk type
.in -.2i
.P
There are currently two chunk types defined for cursor files; comments and
images.  Comments look like:
.LP
.in +.2i
\fIheader\fP\^:	20 Comment headers are 20 bytes
.br
\fItype\fP\^:	0xfffe0001 Comment type is 0xfffe0001
.br
\fIsubtype\fP\^:	{ 1 (COPYRIGHT), 2 (LICENSE), 3 (OTHER) }
.br
\fIversion\fP\^:	1
.br
\fIlength\fP\^:	CARD32 byte length of UTF-8 string
.br
\fIstring\fP\^:	LISTofCARD8 UTF-8 string
.in -.2i
.P
Images look like:
.LP
.in +.2i
\fIheader\fP\^:	36 Image headers are 36 bytes
.br
\fItype\fP\^:	0xfffd0002 Image type is 0xfffd0002
.br
\fIsubtype\fP\^:	CARD32 Image subtype is the nominal size
.br
\fIversion\fP\^:	1
.br
\fIwidth\fP\^:	CARD32 Must be less than or equal to 0x7fff
.br
\fIheight\fP\^:	CARD32 Must be less than or equal to 0x7fff
.br
\fIxhot\fP\^:	CARD32 Must be less than or equal to width
.br
\fIyhot\fP\^:	CARD32 Must be less than or equal to height
.br
\fIdelay\fP\^:	CARD32 Delay between animation frames in milliseconds
.br
\fIpixels\fP\^:	LISTofCARD32 Packed ARGB format pixels
.in -.2i
.
.SS THEMES
Xcursor (mostly) follows the freedesktop.org spec for theming icons.  The
default search path it uses is
.sp
.RS
__XCURSORPATH__
.RE
.PP
Within each of these directories,
it searches for a directory using the theme name:
.bP
Within the theme directory,
it looks for cursor files in the \*(``cursors\*('' subdirectory.
.IP
Xcursor looks for a specific file,
which must be one of the cursor \fIshape\fP names, 
e.g., as used in XcursorLibraryLoadImage or XcursorLibraryShape.
.bP
If it finds no matching cursor file in the \*(``cursors\*('' subdirectory,
Xcursor next looks for an \*(``index.theme\*('' file
in each theme directory to look for inherited themes.
Those are lines in this format:
.sp
.RS
Inherits = \fItheme-name\fP
.PP
Xcursor uses the first inherited \fItheme-name\fP,
ignoring others which may exist in a given \*(``index.theme\*('' file.
If it finds an inherited them, Xcursor searches along the path to use
that as well.
Xcursor ignores other \fIkeys\fP in the \*(``index.theme\*('' file,
including \*(``Name\*('' (i.e., the name which a graphical
application may use as the \fIpresentation name\fP).
.RE
.PP
If no theme is set, or if no cursor is found for the specified theme
anywhere along the path,
Xcursor checks the \*(``default\*('' theme.
.PP
When Xcursor finds a cursor file, it stops searching.
It always uses the first cursor file found while searching along the path.
.
.SH DATATYPES
.
.TP
.B XcursorImage
holds a single cursor image in memory.  Each pixel in the cursor is a 32-bit
value containing ARGB with A in the high byte.
.sp
.nf
.ft CR
    typedef struct _XcursorImage {
        XcursorDim	size;	    /\(** nominal size for matching */
        XcursorDim	width;	    /\(** actual width */
        XcursorDim	height;	    /\(** actual height */
        XcursorDim	xhot;	    /\(** hot spot x (must be inside image) */
        XcursorDim	yhot;       /\(** hot spot y (must be inside image) */
        XcursorPixel    *pixels;    /\(** pointer to pixels */
    } XcursorImage;
.ft
.fi
.
.TP
.B XcursorImages
holds multiple XcursorImage structures.
They are all freed when the
XcursorImages is freed.
.sp
.nf
.ft CR
    typedef struct _XcursorImages {
        int             nimage;	    /\(** number of images */
        XcursorImage    **images;   /\(** array of XcursorImage pointers */
    } XcursorImages;
.ft
.fi
.
.TP
.B XcursorCursors
Holds multiple Cursor objects.  They're all freed when the XcursorCursors is
freed.  These are reference counted so that multiple XcursorAnimate
structures can use the same XcursorCursors.
.sp
.nf
.ft CR
    typedef struct _XcursorCursors {
        Display     *dpy;	/\(** Display holding cursors */
        int	    ref;	/\(** reference count */
        int	    ncursor;	/\(** number of cursors */
        Cursor	    *cursors;	/\(** array of cursors */
    } XcursorCursors;
.ft
.fi
.
.TP
.B XcursorAnimate
References a set of cursors and a sequence within that set.  Multiple
XcursorAnimate structures may reference the same XcursorCursors; each
holds a reference which is removed when the XcursorAnimate is freed.
.sp
.nf
.ft CR
    typedef struct _XcursorAnimate {
        XcursorCursors   *cursors;  /\(** list of cursors to use */
        int		 sequence;  /\(** which cursor is next */
    } XcursorAnimate;
.ft
.fi
.
.TP
.B XcursorFile
Xcursor provides an abstract API for accessing the file data.  Xcursor
provides a stdio implementation of this abstract API; applications
are free to create additional implementations.  These functions
parallel the stdio functions in return value and expected argument values;
the read and write functions flip the arguments around to match the POSIX
versions.
.sp
.nf
.ft CR
    typedef struct _XcursorFile {
        void	*closure;
        int	(*read)  (XcursorFile *file, unsigned char *buf, int len);
        int	(*write) (XcursorFile *file, unsigned char *buf, int len);
        int	(*seek)  (XcursorFile *file, long offset, int whence);
    };
.ft
.fi
.
.SH FUNCTIONS
.
.SS Object Management
.NS
XcursorImage *XcursorImageCreate (
	int \fIwidth\fP,
	int \fIheight\fP)
.NS
void XcursorImageDestroy (
	XcursorImage *\fIimage\fP)
.NE
Allocate and free images.  On allocation, the hotspot and the pixels are
left uninitialized.
The size is set to the maximum of \fIwidth\fP and \fIheight\fP.
.
.NS
XcursorImages *XcursorImagesCreate (
	int \fIsize\fP)
.NS
void XcursorImagesDestroy (
	XcursorImages *\fIimages\fP)
.NE
Allocate and free arrays to hold multiple cursor images.  On allocation,
\fInimage\fP is set to zero.
.
.NS
XcursorCursors *XcursorCursorsCreate (
	Display *\fIdpy\fP,
	int \fIsize\fP)
.NS
void XcursorCursorsDestroy (
	XcursorCursors *\fIcursors\fP)
.NE
Allocate and free arrays to hold multiple cursors.  On allocation,
\fIncursor\fP is set to zero, \fIref\fP is set to one.
.
.
.SS Reading and writing images.
.
.NS
XcursorImage *XcursorXcFileLoadImage (XcursorFile *\fIfile\fP, int \fIsize\fP)
.NS
XcursorImages *XcursorXcFileLoadImages (XcursorFile *\fIfile\fP, int \fIsize\fP)
.NS
XcursorImages *XcursorXcFileLoadAllImages (XcursorFile *\fIfile\fP)
.NS
XcursorBool XcursorXcFileLoad (
	XcursorFile *\fIfile\fP,
	XcursorComments **\fIcommentsp\fP,
	XcursorImages **\fIimagesp\fP)
.NS
XcursorBool XcursorXcFileSave (
	XcursorFile *\fIfile\fP,
	const XcursorComments *\fIcomments\fP,
	const XcursorImages *\fIimages\fP)
.NE
These read and write cursors from an XcursorFile handle.  After reading, the
file pointer will be left at some random place in the file.
.
.NS
XcursorImage *XcursorFileLoadImage (FILE *\fIfile\fP, int \fIsize\fP)
.NS
XcursorImages *XcursorFileLoadImages (FILE *\fIfile\fP, int \fIsize\fP)
.NS
XcursorImages *XcursorFileLoadAllImages (FILE *\fIfile\fP)
.NS
XcursorBool XcursorFileLoad (
	FILE *\fIfile\fP,
	XcursorComments **\fIcommentsp\fP,
	XcursorImages **\fIimagesp\fP)
.NS
XcursorBool XcursorFileSaveImages (
	FILE *\fIfile\fP,
	const XcursorImages *\fIimages\fP)
.NS
XcursorBool XcursorFileSave (
	FILE * \fIfile\fP,
	const XcursorComments *\fIcomments\fP,
	const XcursorImages *\fIimages\fP)
.NE
These read and write cursors from a stdio FILE handle.  Writing flushes
before returning so that any errors should be detected.
.
.NS
XcursorImage *XcursorFilenameLoadImage (
	const char *\fIfilename\fP,
	int \fIsize\fP)
.NS
XcursorImages *XcursorFilenameLoadImages (
	const char *\fIfilename\fP,
	int \fIsize\fP)
.NS
XcursorImages *XcursorFilenameLoadAllImages (const char *\fIfile\fP)
.NS
XcursorBool XcursorFilenameLoad (
	const char *\fIfile\fP,
	XcursorComments **\fIcommentsp\fP,
	XcursorImages **\fIimagesp\fP)
.NS
XcursorBool XcursorFilenameSaveImages (
	const char *\fIfilename\fP,
	const XcursorImages *\fIimages\fP)
.NS
XcursorBool XcursorFilenameSave (
	const char *\fIfile\fP,
	const XcursorComments *\fIcomments\fP,
	const XcursorImages *\fIimages\fP)
.NE
These parallel the stdio FILE interfaces above, but take filenames.
.
.SS Reading library images
.NS
XcursorImage *XcursorLibraryLoadImage (
	const char	*\fIname\fP,
	const char	*\fItheme\fP,
	int		 \fIsize\fP)
.NS
XcursorImages *XcursorLibraryLoadImages (
	const char	*\fIname\fP,
	const char	*\fItheme\fP,
	int		 \fIsize\fP)
.NE
These search the library path, loading the first file found
of the desired \fIsize\fP,
using a private function (XcursorScanTheme) to find the appropriate theme:
.RS
.bP
If \fItheme\fP is not NULL, use that.
.bP
If \fItheme\fP is NULL, or if there was no match for the desired theme,
use \*(``default\*('' for the theme name.
.bP
If neither search succeeds,
these functions return NULL.
.RE
.IP
The two functions differ by more than the number of images loaded:
.RS
.bP
XcursorLibraryLoadImage calls XcursorFileLoadImage but
.bP
XcursorLibraryLoadImages calls XcursorFileLoadImages,
and (on success)
it calls XcursorImagesSetName to associate \fIname\fP with the result.
.RE
.
.SS Library attributes
.NS
const char * XcursorLibraryPath (void)
.NE
Returns the library search path:
.RS
.bP
If the environment variable \fBXCURSOR_PATH\fP is set,
return that value.
.bP
Otherwise, return the compiled-in search path.
.RE
.
.NS
int XcursorLibraryShape (const char *\fIlibrary\fP)
.NE
Search Xcursor's table of cursor font names for the given
\*(``shape name\*('' (\fIlibrary\fP):
.RS
.bP
If found, return the index into that table,
multiplied by two (to account for the source- and mask-values
used in an X cursor font).
.bP
If not found, return -1.
.RE
.
.SS Cursor APIs
.
.NS
Cursor XcursorFilenameLoadCursor (
	Display *\fIdpy\fP,
	const char *\fIfile\fP)
.NS
XcursorCursors *XcursorFilenameLoadCursors (
	Display *\fIdpy\fP,
	const char *\fIfile\fP)
.NE
These load cursors from the specified file.
.
.NS
Cursor XcursorLibraryLoadCursor (
	Display *\fIdpy\fP,
	const char *\fIname\fP)
.NS
XcursorCursors *XcursorLibraryLoadCursors (
	Display *\fIdpy\fP,
	const char *\fIname\fP)
.NE
These load cursors using the specified library \fIname\fP.  The theme
comes from the display.
.
.NS
Cursor XcursorImageLoadCursor(
	Display *dpy,
	const XcursorImage *image)
.NE
This creates a cursor, given the image to display.
It calls XcursorSupportsARGB to decide what type of cursor to create:
.RS
.bP
XRenderCreateCursor is used if ARGB is supported on the display, and
.bP
XCreatePixmapCursor is used otherwise.
.RE
.
.NS
Cursor XcursorImagesLoadCursor(
	Display *dpy,
	const XcursorImages *images)
.NE
This provides an interface for creating animated cursors,
if the \fIimages\fP array contains multiple images, and
if XcursorSupportsAnim returns true.
Otherwise, it calls XcursorImageLoadCursor.
.
.NS
XcursorCursors *XcursorImagesLoadCursors(
	Display *dpy,
	const XcursorImages *images)
.NE
This calls XcursorCursorsCreate to create an array of XcursorCursors,
to correspond to the XcursorImages \fIimages\fP array,
and uses XcursorImageLoadCursor to load the corresponding cursor data.
.IP
Normally it returns the resulting array pointer.
On any failure, it discards the result XcursorCursorsDestroy,
and returns NULL.
.
.SS X Cursor Name APIs
.
.NS
XcursorImage *XcursorShapeLoadImage (
	unsigned int \fIshape\fP,
	const char *\fItheme\fP,
	int \fIsize\fP)
.NS
XcursorImages *XcursorShapeLoadImages (
	unsigned int \fIshape\fP,
	const char *\fItheme\fP,
	int \fIsize\fP)
.NE
These map \fIshape\fP to a library name using the standard X cursor names and
then load the images.
.
.NS
Cursor XcursorShapeLoadCursor (
	Display *\fIdpy\fP,
	unsigned int \fIshape\fP)
.NS
XcursorCursors *XcursorShapeLoadCursors (
	Display *\fIdpy\fP,
	unsigned int \fIshape\fP)
.NE
These map \fIshape\fP to a library name and then load the cursors.
.
.SS X Cursor Comment APIs
.NS
XcursorComment *XcursorCommentCreate (
	XcursorUInt comment_type,
	int length)
.NE
XcursorXcFileLoad uses this function to allocate an XcursorComment
structure for a single cursor.
The \fIcomment_type\fP parameter is used as the \fIsubtype\fP field,
e.g., COPYRIGHT.
The \fIlength\fP is the number of bytes to allocate for the comment text.
.
.NS
void XcursorCommentDestroy(
	XcursorComment *comment)
.NE
Deallocates the given XcursorComment structure.
.
.NS
XcursorComments * XcursorCommentsCreate (
	int size)
.NE
XcursorXcFileLoad uses this function to allocate an index of
XcursorComment structure pointers.
The \fIsize\fP parameter tells it how many pointers will be in the index.
.
.NS
void XcursorCommentsDestroy (
	XcursorComments *comments)
.NE
Deallocates the given XcursorComments structure
as well as the XcursorComment structures which it points to.
.
.SS Animated Cursors
.NS
XcursorAnimate * XcursorAnimateCreate (
	XcursorCursors *cursors)
.NE
Wrap the given array of cursors in a newly allocated XcursorAnimate structure,
which adds a sequence number used in XcursorAnimateNext.
.
.NS
void XcursorAnimateDestroy (
	XcursorAnimate *animate)
.NE
Discards the given \fIanimate\fP data,
freeing both the XcursorCursors array of cursors
as well as the XcursorAnimate structure.
.
.NS
Cursor XcursorAnimateNext (
	XcursorAnimate *animate)
.NE
Cyclically returns the next Cursor in the array,
incrementing the sequence number to prepare for the next call.
.IP
The caller is responsible for displaying the series of Cursor images.
Xcursor does not do that.
.
.SS Glyph Cursor APIs
The X11 XCreateFontCursor and XCreateGlyphCursor functions use
this part of the API to extend the X core cursors feature to use themes.
.NS
void XcursorImageHash (
	XImage		*image,
	unsigned char	 hash[XCURSOR_BITMAP_HASH_SIZE])
.NE
Compute a hash of the image,
to display when the environment variable XCURSOR_DISCOVER is set.
.
.NS
void XcursorImagesSetName (
	XcursorImages	*images,
	const char	*name)
.NE
Associates the given name with the images.
.
.NS
void XcursorNoticeCreateBitmap (
	Display		*dpy,
	Pixmap		 pid,
	unsigned int	 width,
	unsigned int	 height)
.NE
Check if the display supports either ARGB or themes,
and also if the image size fits within the maximum cursor size (64 pixels).
If so, create a bitmap of the specified size,
and cache the result in Xcursor,
identifying it with the Pixmap-id (pid) value.
.
.NS
void XcursorNoticePutBitmap (
	Display		*dpy,
	Drawable	draw,
	XImage		*image)
.NE
Update the image contents in the bitmap specified by the draw value
(a Pixmap-id).
The bitmap must have been created by XcursorNoticeCreateBitmap.
.
.NS
Cursor XcursorTryShapeBitmapCursor (
	Display		*dpy,
	Pixmap		 source,
	Pixmap		 mask,
	XColor		*foreground,
	XColor		*background,
	unsigned int	 x,
	unsigned int	 y)
.NE
If the display supports either ARGB or themes,
try to load a cursor into Xcursor's cache
using the source parameter as a Pixmap-id.
The source may no longer be in the cache.
Xcursor uses the hash value to identify the desired image.
.
.NS
Cursor XcursorTryShapeCursor (
	Display		*dpy,
	Font		 source_font,
	Font		 mask_font,
	unsigned int	 source_char,
	unsigned int	 mask_char,
	XColor _Xconst	*foreground,
	XColor _Xconst	*background)
.NE
If the display supports either ARGB or themes,
try to load a cursor into Xcursor's cache
using the source_char parameter as a shape.
Using
.RS
.bP
the default size from XcursorGetDefaultSize,
.bP
the default theme from XcursorGetTheme, and
.bP
the source_char parameter as a shape,
.RE
.IP
Xcursor calls XcursorShapeLoadImages to load the cursor images.
If successful, Xcursor uses XcursorImagesLoadCursor
to load the cursor information.
.
.SS Display Information APIs
.
.NS
XcursorBool XcursorSupportsARGB (Display *\fIdpy\fP)
.NE
Returns true if the display supports ARGB cursors.
Otherwise, cursors will be mapped to a core X cursor.
.
.NS
XcursorBool XcursorSupportsAnim (Display *\fIdpy\fP)
.NE
Returns true if the display supports animated cursors.
Otherwise, cursors will be mapped to a core X cursor.
.
.NS
XcursorBool XcursorSetDefaultSize (Display *\fIdpy\fP, int \fIsize\fP)
.NE
Sets the default size for cursors on the specified display. When loading
cursors, those whose nominal size is closest to this size will be preferred.
.
.NS
int XcursorGetDefaultSize (Display *\fIdpy\fP)
.NE
Gets the default cursor size.
.
.NS
XcursorBool XcursorSetTheme (Display *\fIdpy\fP, const char *\fItheme\fP)
.NE
Sets the current theme name.
.
.NS
char *XcursorGetTheme (Display *\fIdpy\fP)
.NE
Gets the current theme name.
.
.NS
XcursorBool XcursorGetThemeCore (
	Display *\fIdpy\fP)
.NS
XcursorBool XcursorSetThemeCore (
	Display *\fIdpy\fP,
	XcursorBool \fItheme_core\fP)
.NE
Get or set property which tells Xcurses whether to 
enable themes for core cursors.
.
.SH "ENVIRONMENT VARIABLES"
Environment variables can be used to override resource settings,
which in turn override compiled-in default values.
.PP
Some of the environment variables recognized by Xcursor are booleans,
specified as follows:
.RS 3
.TP 5
\fItrue\fP for \*(``t\*('', \*(``1\*('', \*(``y\*('' or \*(``on\*(''
.TP 5
\fIfalse\fP for \*(``f\*('', \*(``0\*('', \*(``n\*('' or \*(``off\*(''
.RE
.PP
Xcursor ignores other values for these booleans.
.TP 15
.B HOME
Xcursor interprets \*(``~\*('' in the search list as the home directory,
using this variable rather than the password database.
.TP 15
.B XCURSOR_ANIM
If the display supports the Render CreateCursor request,
and the Render feature is enabled,
disable \fIanimated\fP cursors if the environment variable is \fIfalse\fP.
.IP
If the environment variable is not given,
Xcursor uses the resource \fBXcursor.anim\fP.
.TP 15
.B XCURSOR_CORE
If the display supports the Render CreateCursor request
disable the Render feature if the environment variable is \fIfalse\fP.
.IP
If the environment variable is not given,
Xcursor uses the resource \fBXcursor.core\fP.
.TP 15
.B XCURSOR_DISCOVER
If the variable is set, Xcursor turns on a logging feature.
It displays the hash value and the image so that users can see which
cursor name is associated with each image.
.IP
There is no corresponding resource setting.
.TP 15
.B XCURSOR_DITHER
This variable sets the desired \fIdither\fP.
.IP
If the environment variable is not given,
Xcursor uses the resource \fBXcursor.dither\fP.
.IP
If neither environment variable or resource is found,
Xcursor uses \*(``threshold\*(''
.IP
These are the recognized values:
.RS 18
.TP 5
.B diffuse
.TP 5
.B median
.TP 5
.B ordered
.TP 5
.B threshold
.RE
.TP 15
.B XCURSOR_PATH
This variable sets the list of paths in which to search for cursors,
rather than the compiled-in default list.
.IP
Directories in this path are separated by colons (:).
.TP 15
.B XCURSOR_SIZE
This variable sets the desired cursor size, in pixels.
.IP
If the environment variable is not given,
Xcursor tries the \fBXcursor.size\fP resource.
.IP
If no size is given, whether by environment variable or resource setting,
Xcursor next tries the \fBXft.dpi\fP resource setting to guess
the size of a 16-point cursor.
.IP
Finally, if \fBXft.dpi\fP is not set,
Xcursor uses the display height,
dividing by 48 (assuming that the height is 768).
.TP 15
.B XCURSOR_THEME
This variable selects the desired \fItheme\fP.
.IP
If the environment variable is not given,
Xcursor tries the \fBXcursor.theme\fP resource.
.IP
If neither environment variable or resource is found,
Xcursor uses the \fIdefault\fP theme.
.TP 15
.B XCURSOR_THEME_CORE
Enables themes for core cursors if the environment variable is \fItrue\fP.
.IP
If the environment variable is not given,
Xcursor tries the \fBXcursor.theme_core\fP resource.
.IP
An application can enable or disable themes using XcursorSetThemeCore.
.
.SH SEE ALSO
.na
XCreateRenderCursor(__libmansuffix__),
XCreatePixmapCursor(__libmansuffix__), and
XCreateFontCursor(__libmansuffix__)
.ad
.PP
as well as
.IP
https://specifications.freedesktop.org/icon-theme-spec/
.
.SH RESTRICTIONS
.B Xcursor
will probably change radically in the future; weak attempts will be made to
retain some level of source-file compatibility.
.
.SH AUTHOR
Keith Packard