# memberdef

refid: a70e88af10d1862603d4dbc65ba936d16
name: devs
definition: DMXLocalInputInfoPtr* _DMXInputInfo::devs
type: DMXLocalInputInfoPtr *
scope: _DMXInputInfo
detaileddescription:
 List of actual input devices.  Each _DMXInputInfo structure can
refer to more than one device.  For example, the keyboard and the
pointer of a backend display; or all of the XInput extension
devices on a backend display.  


refid: a27f8606aec1028f80bd9b21c421e78fe
name: savedMotionProc
type: int(*
argsstring: )(DeviceIntPtr, xTimecoord *, unsigned long, unsigned long, ScreenPtr)
scope: _DMXLocalInputInfo
definition:
int(* _DMXLocalInputInfo::savedMotionProc)(DeviceIntPtr, xTimecoord *, unsigned long, unsigned long, ScreenPtr)


refid: a492aa70992c986ae525318a29678c4bb
name: XCheckNotMaskEvent
definition: Bool XCheckNotMaskEvent
type: Bool
argsstring: (Display *dpy, long mask, XEvent *event)
detaileddescription:
 Check existing events in queue to find if any match.  If so, return.
If not, flush buffer and see if any more events are readable. If one
matches, return.  If all else fails, tell the user no events found.


refid: ad1ec3b5086644b176e48fbdb72b39adc
name: DMX_VENDOR_RELEASE
initializer:
((major)     * 100000000) + \
    ((minor)     *   1000000) + \
    ((year-2000) *     10000) + \
    ((month)     *       100) + \
    ((day)       *         1)


refid: a686f18ccb493fefc4403401991da115a
name: dmxPopulate
definition: static int dmxPopulate
type: int
argsstring:
(ClientPtr client, Window window, CARD32 *screens, CARD32 *windows, xRectangle *pos, xRectangle *vis)


refid: a67000d9b6ab4428d002523c0ef981ed0
name: DMX_WRAP
detaileddescription: Wrap screen or GC function pointer
initializer:
do {									\
    (_saved)->_entry  = (_actual)->_entry;				\
    (_actual)->_entry = (_newfunc);					\
} while (0)


refid: a175903acd588f450ac6325e17355f8ca
name: DMXInputInfo
definition: typedef struct _DMXInputInfo DMXInputInfo
type: struct _DMXInputInfo
detaileddescription:
 Provide the typedef globally, but keep the contents opaque outside
of the input routines.  \see dmxinput.h  


refid: aac7b710f9533f3b984574f1403488673
name: DMXStatInfo
definition: typedef struct _DMXStatInfo DMXStatInfo
type: struct _DMXStatInfo
detaileddescription:
 Provide the typedef globally, but keep the contents opaque outside
of the XSync statistic routines.  \see dmxstat.c  


refid: a10581b0cb51e730e26cbc08913a76c5f
name: dmxFontPath
definition: char* dmxFontPath
type: char *
detaileddescription:
 NULL if no font

path is set on the
command line;
otherwise, a string
of comma separated
paths built from the
command line
specified font
paths  


refid: a8c817583455230eb81b38c9fcdf3d363
name: GetGLXVisualConfigsFromFBConfigs
definition: __GLXvisualConfig* GetGLXVisualConfigsFromFBConfigs
type: __GLXvisualConfig *
argsstring:
(__GLXFBConfig *fbconfigs, int nfbconfigs, XVisualInfo *visuals, int nvisuals, __GLXvisualConfig *glxConfigs, int nGlxConfigs, int *nconfigs)


refid: a7de14f607c61ecac05f9c45d002e36ab
name: dmxArgV
definition: const char* dmxArgV
type: const char *
argsstring: (dmxArg a, int item)
detaileddescription:
 Return the argument number \a item in the \a dmxArg object.
Arguments are 0 based.  NULL will be returned for values less than 0
or equal to or greater than the number of arguments in the object.  


refid: a7d872851e86ae8063cd13e85ed203d09
name: dmxArgParse
definition: dmxArg dmxArgParse
type: dmxArg
argsstring: (const char *string)
detaileddescription:
 Parse a string into arguments delimited by commas.  Return a new \a
dmxArg object containing the arguments.  


refid: a002212ef0a93ad12011045e99ad95711
name: dmxBackendDestroyPrivate
definition: void dmxBackendDestroyPrivate
type: void
argsstring: (void *private)
detaileddescription:
 Destroy the private data structure.  No checking is performed to
verify that the structure was actually created by
#dmxBackendCreatePrivate.  


refid: ad3d553a49ef7c6d3b1bdbd30d9889fa8
name: dmxBackendUpdatePosition
definition: void dmxBackendUpdatePosition
type: void
argsstring: (void *private, int x, int y)
detaileddescription:
 This routine is called from #dmxCoreMotion for each motion
event. \a x and \a y are global coordinants.  


refid: a6e9b6f0743636b93aeb6ae71a3517abf
name: dmxBackendCollectEvents
definition: void dmxBackendCollectEvents
type: void
detaileddescription: Get events from the X queue on the backend servers and put the events into the DMX event queue.
argsstring:
(DevicePtr pDev, dmxMotionProcPtr motion, dmxEnqueueProcPtr enqueue, dmxCheckSpecialProcPtr checkspecial, DMXBlockType block)


refid: aa33f7542c68f9b5d7552322a499f66ae
name: dmxBackendProcessInput
definition: void dmxBackendProcessInput
type: void
argsstring: (void *private)
detaileddescription:
 Called after input events are processed from the DMX queue.  No
event processing actually takes place here, but this is a convenient
place to update the pointer.  


refid: a0e5463014d4a4b67ab7610d52e01ac2e
name: dmxBackendFunctions
definition: int dmxBackendFunctions
type: int
argsstring: (void *private, DMXFunctionType function)
detaileddescription:
 Process #DMXFunctionType functions.  The only function handled here
is to acknowledge a pending server shutdown.  


refid: aaafedb53a138b81ebb62eeff391f1115
name: dmxSetWidthHeight
definition: void dmxSetWidthHeight
type: void
argsstring: (int width, int height)
detaileddescription:
 We may want the wall dimensions to be different from the bounding
box dimensions that Xinerama computes, so save those and update them
here.


refid: a077a54c8577746426371b996c9aacefb
name: dmxComputeWidthHeight
definition: void dmxComputeWidthHeight
type: void
argsstring: (DMXRecomputeFlag flag)
detaileddescription:
 Computes the global bounding box for DMX.  This may be larger than
the one computed by Xinerama because of the DMX configuration
file.  


refid: a39179d932cde34ab3c947fa017d2d78d
name: dmxConnectionBlockCallback
definition: void dmxConnectionBlockCallback
type: void
argsstring: (void)
detaileddescription:
 A callback routine that hooks into Xinerama and provides a
convenient place to print summary log information during server
startup.  This routine does not modify any values.  


refid: ad9bd99dabcb14e9efe85df040d63c4b3
name: ADD
initializer:
if (count < DMX_MAX_XINPUT_EVENT_TYPES) {                                \
        type(priv->xi, event_type[count], event_list[count]);                \
        if (event_type[count]) {                                             \
            dmxMapInsert(dmxLocal, event_type[count], XI_##type);            \
            ++count;                                                         \
        }                                                                    \
    } else {                                                                 \
        dmxLog(dmxWarning, "More than %d event types for %s\n",              \
               DMX_MAX_XINPUT_EVENT_TYPES, dmxInput->name);                  \
    }


refid: a907580b7be71d9be0b771d32210f3cad
name: dmxFindPointerScreen
definition: int dmxFindPointerScreen
type: int
argsstring: (int x, int y)
detaileddescription:
 Given the global coordinates \a x and \a y, determine the screen
with the lowest number on which those coordinates lie.  If they are
not on any screen, return -1.  The number returned is an index into
\a dmxScreenInfo and is between -1 and \a dmxNumScreens - 1,
inclusive.  


refid: ae89d76b1c335746264678b2dc9923889
name: dmxCommonCopyPrivate
definition: void* dmxCommonCopyPrivate
type: void *
argsstring: (DeviceIntPtr pDevice)
detaileddescription:
 Returns a pointer to the private area for the device that comes just
prior to \a pDevice in the current \a dmxInput device list.  This is
used as the private area for the current device in some situations
(e.g., when a keyboard and mouse form a pair that should share the
same private area).  If the requested private area cannot be located,
then NULL is returned.  


refid: a454277a1d03deeb3acfd1c040cbaf21c
name: dmxCommonSaveState
definition: void dmxCommonSaveState
type: void
argsstring: (void *private)
detaileddescription:
 This routine saves and resets some important state for the backend
and console device drivers:
- the modifier map is saved and set to 0 (so DMX controls the LEDs)
- the key click, bell, led, and repeat masks are saved and set to the
values that DMX claims to be using

This routine and #dmxCommonRestoreState are used when the pointer
enters and leaves the console window, or when the backend window is
active or not active (for a full-screen window, this only happens at
server startup and server shutdown).


refid: ac501f773a244037a88da37c0dc48ac66
name: DMX_COMMON_OTHER
initializer:
Display                 *display;       \
    Window                  window;         \
    DMXScreenInfo           *be;            \
    DMXLocalInputInfoPtr    dmxLocal;       \
    int                     initPointerX;   \
    int                     initPointerY;   \
    long                    eventMask;      \
    KeybdCtrl               kctrl;          \
    PtrCtrl                 mctrl;          \
    int                     kctrlset;       \
    int                     mctrlset;       \
    KeybdCtrl               savedKctrl;     \
    XModifierKeymap         *savedModMap;   \
    int                     stateSaved


refid: ac4c9fac008144d96c6bd6313b5e158d2
name: DMX_COMMON_XKB
initializer:
DMX_COMMON_OTHER;                       \
    XkbDescPtr              xkb;            \
    XkbIndicatorRec         savedIndicators


refid: ae04675e973690cab79ef643f298cb375
name: GETPRIVFROMPRIVATE
initializer:
GETONLYPRIVFROMPRIVATE;                                             \
    DMXInputInfo         *dmxInput = &dmxInputs[priv->dmxLocal->inputIdx]


refid: ae60813d58a79b6dae5b98321fd7e1866
name: GETDMXLOCALFROMPDEVICE
initializer:
DevicePtr            pDev      = &pDevice->public;                  \
    DMXLocalInputInfoPtr dmxLocal  = pDev->devicePrivate


refid: a7067dd8545db11300dc1ee7f461b346d
name: GETDMXINPUTFROMPDEVICE
initializer:
GETDMXLOCALFROMPDEVICE;                                             \
    DMXInputInfo         *dmxInput = &dmxInputs[dmxLocal->inputIdx]


refid: ad100a619cb405b9f315abf1019622dd7
name: GETDMXINPUTFROMPDEV
initializer:
GETDMXLOCALFROMPDEV;                                                \
    DMXInputInfo         *dmxInput = &dmxInputs[dmxLocal->inputIdx]


refid: a162b4980b050465ca21228eb41f207a2
name: GETPRIVFROMPDEV
initializer:
GETDMXLOCALFROMPDEV;                                                \
    myPrivate            *priv     = dmxLocal->private


refid: a48a37477c3206396f646511a64e8b7c9
name: dmxVDLDisplayEntry
definition: static void dmxVDLDisplayEntry
type: void
argsstring:
(const char *buf, char *name, int *len, int *x, int *y, int *xoff, int *yoff, int *xorig, int *yorig)


refid: af12101f305634cb9d15269a4b7a13b34
name: GEN
initializer:
void dmxConfigSet##glob(const char *param) {                                 \
     if (dmx##glob) free((void *)dmx##glob);                                  \
     dmx##glob = strdup(param);                                               \
 }                                                                            \
 char *dmxConfigGet##glob(void) {                                             \
     return (char *)(dmx##glob ? dmx##glob : def);                            \
 }

detaileddescription:
 This macro is used to generate the following access methods:
- dmxConfig{Set,Get}rules
- dmxConfig{Set,Get}model
- dmxConfig{Set,Get}layout
- dmxConfig{Set,Get}variant
- dmxConfig{Set,Get}options
These methods are used to read and write information about the keyboard.  


refid: ac372c2ded30d6c82cc7973f7891d2363
name: dmxConfigStoreDisplay
definition: void dmxConfigStoreDisplay
type: void
argsstring: (const char *display)
detaileddescription:
 Make a note that \a display is the name of an X11 display that
should be initialized as a backend (output) display.  Called from
#ddxProcessArgument.  


refid: aa591f4e1846bc6e6d78c68d77879c900
name: dmxConfigStoreInput
definition: void dmxConfigStoreInput
type: void
argsstring: (const char *input)
detaileddescription:
 Make a note that \a input is the name of an X11 display that should
be used for input (either a backend or a console input device).  


refid: ac116ffa05f76ddb8f5920cf3a262e2e5
name: dmxConfigStoreXInput
definition: void dmxConfigStoreXInput
type: void
argsstring: (const char *input)
detaileddescription:
 Make a note that \a input is the name of an X11 display that should
be used for input from XInput extension devices.  


refid: a224cf25e04e43ce049574c10ce39b597
name: dmxConfigStoreConfig
definition: void dmxConfigStoreConfig
type: void
argsstring: (const char *config)
detaileddescription:
 Make a note that \a config should be used as the configuration for
current instantiation of the DMX server.  


refid: a5fa6729153f7f7e5d3037d451291fa64
name: dmxConfigAddDisplay
definition: static DMXScreenInfo* dmxConfigAddDisplay
type: DMXScreenInfo *
argsstring:
(const char *name, int scrnWidth, int scrnHeight, int scrnX, int scrnY, int scrnXSign, int scrnYSign, int rootWidth, int rootHeight, int rootX, int rootY, int rootXSign, int rootYSign)


refid: a826f729e29c8737ac9bbb9416505cd74
name: dmxConfigConfigure
definition: void dmxConfigConfigure
type: void
argsstring: (void)
detaileddescription:
 Set up the appropriate global variables so that the DMX server will
be initialized using the configuration specified in the config file
and on the command line.  


refid: a41ff0900fb1b1056b02014bf39bee02f
name: dmxConfigSetMaxScreens
definition: void dmxConfigSetMaxScreens
type: void
argsstring: (void)
detaileddescription:
 This function determines the number of displays we WILL have and
sets MAXSCREENS to that value.  This is difficult since the number
depends on the command line (which is easy to count) or on the config
file, which has to be parsed.  


refid: a349aab5778d28bca1b1c86fd03865f80
name: dmxConsoleUpdateInfo
definition: void dmxConsoleUpdateInfo
type: void
argsstring: (void *private, DMXUpdateType type, WindowPtr pWindow)
detaileddescription:
 Whenever the window layout (size, position, stacking order) might be
changed, this routine is called with the \a pWindow that changed and
the \a type of change.  This routine is called in a conservative
fashion: the actual layout of the windows of the screen might not
have had any human-visible changes.  


refid: aa0155ff801b6836aa494cd1980c83bf9
name: dmxConsoleUpdatePosition
definition: void dmxConsoleUpdatePosition
type: void
argsstring: (void *private, int x, int y)
detaileddescription:
 This routine gets called from #dmxCoreMotion for each motion.  This
allows the console's notion of the cursor postion to change when
another input device actually caused the change.  


refid: a9c2ec3c63c36955d2458283dbd62b605
name: dmxConsoleCollectEvents
definition: void dmxConsoleCollectEvents
type: void
argsstring:
(DevicePtr pDev, dmxMotionProcPtr motion, dmxEnqueueProcPtr enqueue, dmxCheckSpecialProcPtr checkspecial, DMXBlockType block)

detaileddescription:
 Collect all pending events from the console's display.  Plase these
events on the server event queue using the \a motion and \a enqueue
routines.  The \a checkspecial routine is used to check for special
keys that need handling.  \a block tells if signals should be blocked
when updating the event queue.  


refid: a6d6dd821d75fae79c02d7407bbd3c4c5
name: dmxConsoleComputeWidthHeight
definition: static void dmxConsoleComputeWidthHeight
type: void
argsstring:
(myPrivate *priv, int *width, int *height, double *xScale, double *yScale, int *consWidth, int *consHeight)


refid: ae70541f26e4a4ff6360090393d622b41
name: dmxConsoleCapture
definition: void dmxConsoleCapture
type: void
argsstring: (DMXInputInfo *dmxInput)
detaileddescription:
 This routine is used to warp the pointer into the console window
from anywhere on the screen.  It is used when backend and console
input are both being taken from the same X display.  


refid: a7bf2f59a6c5d381aea975cd78dd1f9dc
name: dmxPointerSpriteFuncs
definition: miPointerSpriteFuncRec dmxPointerSpriteFuncs
type: miPointerSpriteFuncRec
detaileddescription: Sprite functions for mi layer. \see dmxcursor.c \see dmxscrinit.c
initializer:
= {
    dmxRealizeCursor,
    dmxUnrealizeCursor,
    dmxSetCursor,
    dmxMoveCursor,
    dmxDeviceCursorInitialize,
    dmxDeviceCursorCleanup
}


refid: a709e3d4a4e44e17fed3de1fcb0d42b20
name: dmxCursorNoMulti
definition: void dmxCursorNoMulti
type: void
argsstring: (void)
detaileddescription:
Turn off support for displaying multiple cursors on overlapped
back-end displays.  See #dmxCursorDoMultiCursors.  


refid: af3fb4b2c2d3cc318c88fbc6658893360
name: dmxInitOrigins
definition: void dmxInitOrigins
type: void
argsstring: (void)
detaileddescription:
 Initialize screen origins (and relative position).  This is called
for each server generation.  For dynamic reconfiguration, use
#dmxReInitOrigins() instead.  


refid: adaf3455cdd3f54d22285e5a0fa99fddb
name: dmxOnScreen
definition: int dmxOnScreen
type: int
argsstring: (int x, int y, DMXScreenInfo *dmxScreen)
detaileddescription:
 Returns non-zero if the global \a x, \a y coordinate is on the
screen window of the \a dmxScreen.  


refid: a28c6651bdff6f7fc01292548659a6eb4
name: dmxIterateOverlap
definition: static void* dmxIterateOverlap
type: void *
argsstring: (DMXScreenInfo *start, void *(*f)(DMXScreenInfo *dmxScreen, void *), void *closure)
detaileddescription:
 Iterate over the screens which overlap with the \a start screen,
calling \a f with the \a closure for each argument.  Often used with
#dmxPrintOverlap.  


refid: a77c74a33de88fae6cf0de8b755a5c411
name: dmxInitOverlap
definition: void dmxInitOverlap
type: void
argsstring: (void)
detaileddescription:
 Detects overlapping dmxScreens and creates circular lists.  This
uses an O(dmxNumScreens^2) algorithm, but dmxNumScreens is < 100 and
the computation only needs to be performed for every server
generation or dynamic reconfiguration .  


refid: a21820e2001f763e3cfc924a1d602bb62
name: dmxMoveCursor
definition: void dmxMoveCursor
type: void
argsstring: (DeviceIntPtr pDev, ScreenPtr pScreen, int x, int y)
detaileddescription:
 Move the cursor to coordinates (\a x, \a y)on \a pScreen.  This
function is usually called via #dmxPointerSpriteFuncs, except during
reconfiguration when the cursor is repositioned to force an update on
newley overlapping screens and on screens that no longer overlap.

The coords (x,y) are in global coord space.  We'll loop over the
back-end screens and see if they contain the global coord.  If so, call
_dmxMoveCursor() (XWarpPointer) to position the pointer on that screen.


refid: ad67e1086ef62ecfa33549d74cd89a379
name: dmxHideCursor
definition: void dmxHideCursor
type: void
argsstring: (DMXScreenInfo *dmxScreen)
detaileddescription:
 This routine is used by the backend input routines to hide the
cursor on a screen that is being used for relative input.  \see
dmxbackend.c  


refid: a7ddaf12551bbbd8a23fa60c09cdd6218
name: DMX_GET_CURSOR_PRIV
initializer:
((dmxCursorPrivPtr) \
    dixLookupScreenPrivate(&(_pCursor)->devPrivates, CursorScreenKey, _pScreen))


refid: a6c93ecabb9ee83027c79f878e143a472
name: dmxDPMSInit
definition: void dmxDPMSInit
type: void
argsstring: (DMXScreenInfo *dmxScreen)
detaileddescription:
 Initialize DPMS support.  We save the current settings and turn off
DPMS.  The settings are restored in #dmxDPMSTerm.  


refid: a31bf72cac5b5327393423d49a437fc8b
name: dmxDummyKbdGetInfo
definition: void dmxDummyKbdGetInfo
type: void
argsstring: (DevicePtr pDev, DMXLocalInitInfoPtr info)
detaileddescription:
 Return information about the dummy keyboard device specified in \a pDev
into the structure pointed to by \a info.  The keyboard is set up to
have 1 valid key code that is \a NoSymbol  


refid: a0d9cc243adf2eb5869b9ebcca9125bf4
name: dmxDummyMouGetInfo
definition: void dmxDummyMouGetInfo
type: void
argsstring: (DevicePtr pDev, DMXLocalInitInfoPtr info)
detaileddescription:
 Return information about the dummy mouse device specified in \a pDev
into the structure pointed to by \a info.  They mouse has 3 buttons
and two axes.  


refid: a4424526939b87a780233ad69fdf26c62
name: EXTRACT_VALUATORS
initializer:
valuators[0] = ke->axis_data[0]; \
        valuators[1] = ke->axis_data[1]; \
        valuators[2] = ke->axis_data[2]; \
        valuators[3] = ke->axis_data[3]; \
        valuators[4] = ke->axis_data[4]; \
        valuators[5] = ke->axis_data[5]; \


refid: a8463e76279fff9479a552b69c4754273
name: dmxExtMotion
definition: static void dmxExtMotion
type: void
argsstring:
(DMXLocalInputInfoPtr dmxLocal, int *v, int firstAxis, int axesCount, DMXMotionType type, DMXBlockType block)


refid: ae08f1801d0215396a7f39bd083ddca11
name: dmxMotion
definition: void dmxMotion
type: void
argsstring: (DevicePtr pDev, int *v, int firstAxes, int axesCount, DMXMotionType type, DMXBlockType block)
detaileddescription:
 Enqueue a motion event for \a pDev.  The \a v vector has length \a
axesCount, and contains values for each of the axes, starting at \a
firstAxes.

The \a type of the motion may be \a DMX_RELATIVE, \a DMX_ABSOLUTE, or
\a DMX_ABSOLUTE_CONFINED (in the latter case, the pointer will not be
allowed to move outside the global boundaires).

If \a block is set to \a DMX_BLOCK, then the SIGIO handler will be
blocked around calls to \a enqueueMotion().  


refid: ac678be4d489b749fea88a8f0e9045499
name: dmxEnqueue
definition: void dmxEnqueue
type: void
argsstring: (DevicePtr pDev, int type, int detail, KeySym keySym, XEvent *e, DMXBlockType block)
detaileddescription:
 Enqueue an event from the \a pDev device with the
specified \a type and \a detail.  If the event is a KeyPress or
KeyRelease event, then the \a keySym is also specified.

FIXME: make the code do what the comment says, or remove this comment.
If \a block is set to \a DMX_BLOCK, then the SIGIO handler will be
blocked around calls to dmxeqEnqueue().  


refid: a082f21151ec3d66b75d4613a3612c755
name: dmxCheckSpecialKeys
definition: int dmxCheckSpecialKeys
type: int
argsstring: (DevicePtr pDev, KeySym keySym)
detaileddescription:
 A pointer to this routine is passed to low-level input drivers so
that all special keychecking is unified to this file.  This function
returns 0 if no special keys have been pressed.  If the user has
requested termination of the DMX server, -1 is returned.  If the user
has requested a switch to a VT, then the (1-based) number of that VT
is returned.  


refid: a7e2b64de1aef77d43ee78d3a8187f651
name: dmxGetInputCount
definition: int dmxGetInputCount
type: int
argsstring: (void)
detaileddescription:
 Return the total number of devices, not just #dmxNumInputs.  The
number returned should be the same as that returned by
XListInputDevices.  


refid: a3bde3bbb52470b5eb185805d861e6216
name: dmxGetInputAttributes
definition: int dmxGetInputAttributes
type: int
argsstring: (int deviceId, DMXInputAttributesPtr attr)
detaileddescription:
 Return information about the device with id = \a deviceId.  This
information is primarily for the #ProcDMXGetInputAttributes()
function, which does not have access to the appropriate data
structure.  


refid: a6b0b38eb49c6be097a59dbcdd6dacb51
name: dmxAddInput
definition: int dmxAddInput
type: int
argsstring: (DMXInputAttributesPtr attr, int *id)
detaileddescription:
 Add an input with the specified attributes.  If the input is added,
the physical id is returned in \a deviceId.  


refid: a1317039ecdb6f4eca7c1e5cea884657e
name: dmxGetNumScreens
definition: unsigned long dmxGetNumScreens
type: unsigned long
argsstring: (void)
detaileddescription:
 Return the value of #dmxNumScreens &ndash; the total number of backend
screens in use (these are logical screens and may be larger than the
number of backend displays).  


refid: a8c94ba784e540d8a5fba70373f1167f4
name: dmxBERestorePixmap
definition: static void dmxBERestorePixmap
type: void
argsstring: (PixmapPtr pPixmap)
detaileddescription:
Restore the pixmap image either from another screen or from an image
that was saved when the screen was previously detached.  


refid: adba74bf296ecc7122acd43cb5f7df5bb
name: dmxBECreateResources
definition: static void dmxBECreateResources
type: void
argsstring: (void *value, XID id, RESTYPE type, void *n)
detaileddescription:
Create resources on the back-end server.  This function is called
from #dmxAttachScreen() via the dix layer's FindAllResources
function.  It walks all resources, compares them to the screen
number passed in as \a n and calls the appropriate DMX function to
create the associated resource on the back-end server.  


refid: a3d9d96382bf12f21023b8983412073ac
name: dmxBECreateWindowTree
definition: static void dmxBECreateWindowTree
type: void
argsstring: (int idx)
detaileddescription:
Create window hierachy on back-end server.  The window tree is
created in a special order (bottom most subwindow first) so that the
#dmxCreateNonRootWindow() function does not need to recursively call
itself to create each window's parents.  This is required so that we
have the opportunity to create each window's border and background
pixmaps (where appropriate) before the window is created.  


refid: a3dee225e6bc7fa7f8684ebc5b4f96884
name: dmxBESavePixmap
definition: static void dmxBESavePixmap
type: void
argsstring: (PixmapPtr pPixmap)
detaileddescription:
Save the pixmap image only when there is not another screen with
that pixmap from which the image can be read when the screen is
reattached.  To do this, we first try to find a pixmap on another
screen corresponding to the one we are trying to save.  If we find
one, then we do not need to save the image data since during
reattachment, the image data can be read from that other pixmap.
However, if we do not find one, then we need to save the image data.
The common case for these are for the default stipple and root
tile.  


refid: a2d15b75042837ec54742a6dbbecd966a
name: dmxBEDestroyResources
definition: static void dmxBEDestroyResources
type: void
argsstring: (void *value, XID id, RESTYPE type, void *n)
detaileddescription:
Destroy resources on the back-end server.  This function is called
from #dmxDetachScreen() via the dix layer's FindAllResources
function.  It walks all resources, compares them to the screen
number passed in as \a n and calls the appropriate DMX function to
free the associated resource on the back-end server.  


refid: a30620fb306cff3ee44d6de43aa97346a
name: dmxBEDestroyWindowTree
definition: static void dmxBEDestroyWindowTree
type: void
argsstring: (int idx)
detaileddescription:
Destroy window hierachy on back-end server.  To ensure that all
XDestroyWindow() calls succeed, they must be performed in a bottom
up order so that windows are not destroyed before their children.
XDestroyWindow(), which is called from #dmxBEDestroyWindow(), will
destroy a window as well as all of it's children.  


refid: a2d9cf629a70ed7c46a38dac9611b6527
name: dmxInitFonts
definition: void dmxInitFonts
type: void
argsstring: (void)
detaileddescription:
Initialize font support.  In addition to the screen function call
pointers, DMX also hooks in at the ProcVector[] level.  Here the old
ProcVector function pointers are saved and the new ProcVector
function pointers are initialized.  


refid: ad24fe115ec27d050da7a4cb47d7ce52f
name: dmxBELoadFont
definition: Bool dmxBELoadFont
type: Bool
argsstring: (ScreenPtr pScreen, FontPtr pFont)
detaileddescription:
Load the font, \a pFont, on the back-end server associated with \a
pScreen.  When a font is loaded, the font path on back-end server is
first initialized to that specified on the command line with the
-fontpath options, and then the font is loaded.  


refid: a3c6b012a9ca843b7f1083a151030c400
name: dmxGCFuncs
definition: GCFuncs dmxGCFuncs
type: GCFuncs
initializer:
= {
    dmxValidateGC,
    dmxChangeGC,
    dmxCopyGC,
    dmxDestroyGC,
    dmxChangeClip,
    dmxDestroyClip,
    dmxCopyClip,
}


refid: a4688e83670c13b303cba5309eaf23424
name: dmxGCOps
definition: GCOps dmxGCOps
type: GCOps
initializer:
= {
    dmxFillSpans,
    dmxSetSpans,
    dmxPutImage,
    dmxCopyArea,
    dmxCopyPlane,
    dmxPolyPoint,
    dmxPolylines,
    dmxPolySegment,
    dmxPolyRectangle,
    dmxPolyArc,
    dmxFillPolygon,
    dmxPolyFillRect,
    dmxPolyFillArc,
    dmxPolyText8,
    dmxPolyText16,
    dmxImageText8,
    dmxImageText16,
    dmxImageGlyphBlt,
    dmxPolyGlyphBlt,
    dmxPushPixels
}


refid: ad34a918e727baa65bea235ac16b5e08f
name: dmxValidateGC
definition: void dmxValidateGC
type: void
argsstring: (GCPtr pGC, unsigned long changes, DrawablePtr pDrawable)
detaileddescription:
Validate a graphics context, \a pGC, locally in the DMX server and
recompute the composite clip, if necessary.  


refid: aa4d5583f3d6876e1fb96226ec9aa281a
name: DMX_GC_FUNC_PROLOGUE
initializer:
do {									\
    dmxGCPrivPtr _pGCPriv = DMX_GET_GC_PRIV(_pGC);			\
    DMX_UNWRAP(funcs, _pGCPriv, (_pGC));				\
    if (_pGCPriv->ops)							\
	DMX_UNWRAP(ops, _pGCPriv, (_pGC));				\
} while (0)


refid: aa69b8c93d609c2be2d8680388477d5a4
name: DMX_GC_FUNC_EPILOGUE
initializer:
do {									\
    dmxGCPrivPtr _pGCPriv = DMX_GET_GC_PRIV(_pGC);			\
    DMX_WRAP(funcs, &dmxGCFuncs, _pGCPriv, (_pGC));			\
    if (_pGCPriv->ops)							\
	DMX_WRAP(ops, &dmxGCOps, _pGCPriv, (_pGC));			\
} while (0)


refid: a4e091318ff2a64af06aef315453b88a2
name: DMX_GCOPS_SET_DRAWABLE
initializer:
do {									\
    if ((_pDraw)->type == DRAWABLE_WINDOW) {				\
	dmxWinPrivPtr  pWinPriv =					\
	    DMX_GET_WINDOW_PRIV((WindowPtr)(_pDraw));			\
	(_draw) = (Drawable)pWinPriv->window;				\
    } else {								\
	dmxPixPrivPtr  pPixPriv =					\
	    DMX_GET_PIXMAP_PRIV((PixmapPtr)(_pDraw));			\
	(_draw) = (Drawable)pPixPriv->pixmap;				\
    }									\
} while (0)


refid: a95d43c03eb7e78bbe20269c5e7dc6e14
name: DMX_GCOPS_OFFSCREEN
initializer:
(!dmxScreens[(_pDraw)->pScreen->myNum].beDisplay ||			\
     (dmxOffScreenOpt &&						\
      (_pDraw)->type == DRAWABLE_WINDOW &&				\
      (DMX_GET_WINDOW_PRIV((WindowPtr)(_pDraw))->offscreen ||		\
       !DMX_GET_WINDOW_PRIV((WindowPtr)(_pDraw))->window)))


refid: a5fa3b658c712aa8a4f48a27eca05730d
name: dmxSetSpans
definition: void dmxSetSpans
type: void
detaileddescription: Set spans &ndash; this function should never be called.
argsstring:
(DrawablePtr pDrawable, GCPtr pGC, char *psrc, DDXPointPtr ppt, int *pwidth, int nspans, int fSorted)


refid: ae1e930ec29cf8bd07acd6ccee4a548a3
name: dmxPutImage
definition: void dmxPutImage
type: void
argsstring:
(DrawablePtr pDrawable, GCPtr pGC, int depth, int x, int y, int w, int h, int leftPad, int format, char *pBits)

detaileddescription:
Transfer \a pBits image to back-end server associated with \a
pDrawable's screen.  If primitive subdivision optimization is
enabled, then only transfer the sections of \a pBits that are
visible (i.e., not-clipped) to the back-end server.  


refid: a9165fc8e2f98c6d4d82154a1b52b7c0f
name: dmxCopyArea
definition: RegionPtr dmxCopyArea
type: RegionPtr
argsstring:
(DrawablePtr pSrc, DrawablePtr pDst, GCPtr pGC, int srcx, int srcy, int w, int h, int dstx, int dsty)

detaileddescription:
Copy area from \a pSrc drawable to \a pDst drawable on the back-end
server associated with \a pSrc drawable's screen.  If the offscreen
optimization is enabled, only copy when both \a pSrc and \a pDst are
at least partially visible.  


refid: aa6b3b34e3b0e151d5b2d5f081f6d6e0f
name: dmxCopyPlane
definition: RegionPtr dmxCopyPlane
type: RegionPtr
argsstring:
(DrawablePtr pSrc, DrawablePtr pDst, GCPtr pGC, int srcx, int srcy, int width, int height, int dstx, int dsty, unsigned long bitPlane)

detaileddescription:
Copy plane number \a bitPlane from \a pSrc drawable to \a pDst
drawable on the back-end server associated with \a pSrc drawable's
screen.  If the offscreen optimization is enabled, only copy when
both \a pSrc and \a pDst are at least partially visible.  


refid: a03892f8e655a4bb743a264f121b096c6
name: dmxPolyPoint
definition: void dmxPolyPoint
type: void
argsstring: (DrawablePtr pDrawable, GCPtr pGC, int mode, int npt, DDXPointPtr pptInit)
detaileddescription:
Render list of points, \a pptInit in \a pDrawable on the back-end
server associated with \a pDrawable's screen.  If the offscreen
optimization is enabled, only draw when \a pDrawable is at least
partially visible.  


refid: abd3dea8c777a8e39ffbf2b9fa8e1405e
name: dmxPolylines
definition: void dmxPolylines
type: void
argsstring: (DrawablePtr pDrawable, GCPtr pGC, int mode, int npt, DDXPointPtr pptInit)
detaileddescription:
Render list of connected lines, \a pptInit in \a pDrawable on the
back-end server associated with \a pDrawable's screen.  If the
offscreen optimization is enabled, only draw when \a pDrawable is at
least partially visible.  


refid: a9592aeb83549cbe036a47e9ac90dbf36
name: dmxPolySegment
definition: void dmxPolySegment
type: void
argsstring: (DrawablePtr pDrawable, GCPtr pGC, int nseg, xSegment *pSegs)
detaileddescription:
Render list of disjoint segments, \a pSegs in \a pDrawable on the
back-end server associated with \a pDrawable's screen.  If the
offscreen optimization is enabled, only draw when \a pDrawable is at
least partially visible.  


refid: a6bc862a4f475154ff9ff5f30a0ffcf89
name: dmxPolyRectangle
definition: void dmxPolyRectangle
type: void
argsstring: (DrawablePtr pDrawable, GCPtr pGC, int nrects, xRectangle *pRects)
detaileddescription:
Render list of rectangle outlines, \a pRects in \a pDrawable on the
back-end server associated with \a pDrawable's screen.  If the
offscreen optimization is enabled, only draw when \a pDrawable is at
least partially visible.  


refid: a7c4ff7ddf5b1a31d11e9124dc18f69f0
name: dmxPolyArc
definition: void dmxPolyArc
type: void
argsstring: (DrawablePtr pDrawable, GCPtr pGC, int narcs, xArc *parcs)
detaileddescription:
Render list of arc outlines, \a parcs in \a pDrawable on the
back-end server associated with \a pDrawable's screen.  If the
offscreen optimization is enabled, only draw when \a pDrawable is at
least partially visible.  


refid: a4c24d2a2ddb121d2281084dd4f1361a6
name: dmxFillPolygon
definition: void dmxFillPolygon
type: void
argsstring: (DrawablePtr pDrawable, GCPtr pGC, int shape, int mode, int count, DDXPointPtr pPts)
detaileddescription:
Render a filled polygons in \a pDrawable on the back-end server
associated with \a pDrawable's screen.  If the offscreen
optimization is enabled, only draw when \a pDrawable is at least
partially visible.  


refid: a7d7eee30be7b445772f875b8cc1c8e0a
name: dmxPolyFillRect
definition: void dmxPolyFillRect
type: void
argsstring: (DrawablePtr pDrawable, GCPtr pGC, int nrectFill, xRectangle *prectInit)
detaileddescription:
Render list of filled rectangles, \a prectInit in \a pDrawable on
the back-end server associated with \a pDrawable's screen.  If the
offscreen optimization is enabled, only draw when \a pDrawable is at
least partially visible.  


refid: a5488891f016532e40ba5e31466fb67fd
name: dmxPolyFillArc
definition: void dmxPolyFillArc
type: void
argsstring: (DrawablePtr pDrawable, GCPtr pGC, int narcs, xArc *parcs)
detaileddescription:
Render list of filled arcs, \a parcs in \a pDrawable on the back-end
server associated with \a pDrawable's screen.  If the offscreen
optimization is enabled, only draw when \a pDrawable is at least
partially visible.  


refid: a9b3a993a29bb01745ddbf7bd9ff97ef5
name: dmxPolyText8
definition: int dmxPolyText8
type: int
argsstring: (DrawablePtr pDrawable, GCPtr pGC, int x, int y, int count, char *chars)
detaileddescription:
Render string of 8-bit \a chars (foreground only) in \a pDrawable on
the back-end server associated with \a pDrawable's screen.  If the
offscreen optimization is enabled, only draw when \a pDrawable is at
least partially visible.  


refid: a2fe37b5892867df4c29292c975c17e52
name: dmxPolyText16
definition: int dmxPolyText16
type: int
argsstring: (DrawablePtr pDrawable, GCPtr pGC, int x, int y, int count, unsigned short *chars)
detaileddescription:
Render string of 16-bit \a chars (foreground only) in \a pDrawable
on the back-end server associated with \a pDrawable's screen.  If
the offscreen optimization is enabled, only draw when \a pDrawable
is at least partially visible.  


refid: a1fc863ca944469fc34d78db948f14053
name: dmxImageText8
definition: void dmxImageText8
type: void
argsstring: (DrawablePtr pDrawable, GCPtr pGC, int x, int y, int count, char *chars)
detaileddescription:
Render string of 8-bit \a chars (both foreground and background) in
\a pDrawable on the back-end server associated with \a pDrawable's
screen.  If the offscreen optimization is enabled, only draw when \a
pDrawable is at least partially visible.  


refid: acb19f9ef082c76f281679994057fafe1
name: dmxImageText16
definition: void dmxImageText16
type: void
argsstring: (DrawablePtr pDrawable, GCPtr pGC, int x, int y, int count, unsigned short *chars)
detaileddescription:
Render string of 16-bit \a chars (both foreground and background) in
\a pDrawable on the back-end server associated with \a pDrawable's
screen.  If the offscreen optimization is enabled, only draw when \a
pDrawable is at least partially visible.  


refid: afa4477961c59816de687e726eff4a25d
name: dmxImageGlyphBlt
definition: void dmxImageGlyphBlt
type: void
detaileddescription: Image Glyph Blt &ndash; this function should never be called.
argsstring:
(DrawablePtr pDrawable, GCPtr pGC, int x, int y, unsigned int nglyph, CharInfoPtr *ppci, void *pglyphBase)


refid: ad44d59f0e4f0c77ca7278cb5d31f0121
name: dmxFindAlternatePixmap
definition: static DMXScreenInfo* dmxFindAlternatePixmap
type: DMXScreenInfo *
argsstring: (DrawablePtr pDrawable, XID *draw)
detaileddescription:
 When Xinerama is active, the client pixmaps are always obtained from
screen 0.  When screen 0 is detached, the pixmaps must be obtained
from any other screen that is not detached.  Usually, this is screen
1.  


refid: ace88d57bbb8edfcdc3e7206e59c1e30f
name: dmxGetImage
definition: void dmxGetImage
type: void
argsstring:
(DrawablePtr pDrawable, int sx, int sy, int w, int h, unsigned int format, unsigned long planeMask, char *pdstLine)

detaileddescription:
Get an image from the back-end server associated with \a pDrawable's
screen.  If \a pDrawable is a window, it must be viewable to get an
image from it.  If it is not viewable, then get the image from the
first ancestor of \a pDrawable that is viewable.  If no viewable
ancestor is found, then simply return without getting an image.   


refid: ab618e049a23d5386e66b9468e738a9ce
name: AbortDDX
definition: void AbortDDX
type: void
argsstring: (enum ExitCode error)
detaileddescription:
 This function is called in Xserver/os/utils.c from \a AbortServer().
We must ensure that backend and console state is restored in the
event the server shutdown wasn't clean.  


refid: ae174a1d876b5af5287f51cd692fe5ec8
name: ddxGiveUp
definition: void ddxGiveUp
type: void
argsstring: (enum ExitCode error)
detaileddescription:
 This function is called in Xserver/dix/main.c from \a main() when
dispatchException & DE_TERMINATE (which is the only way to exit the
main loop without an interruption.  


refid: a9847289ad3f625185c0c036e5f1ce463
name: OsVendorFatalError
definition: void OsVendorFatalError
type: void
argsstring: (const char *f, va_list args)
detaileddescription:
 This function is called in Xserver/os/utils.c from \a FatalError()
and \a VFatalError().  (Note that setting the function pointer \a
OsVendorVErrorFProc will cause \a VErrorF() (which is called by the
two routines mentioned here, as well as by others) to use the
referenced routine instead of \a vfprintf().)  


refid: a794cad8ab41d42457e19090e38c5b338
name: LegalModifier
definition: Bool LegalModifier
type: Bool
argsstring: (unsigned int key, DeviceIntPtr pDev)
detaileddescription:
 Returns TRUE if the key is a valid modifier.  For PC-class
keyboards, all keys can be used as modifiers, so return TRUE
always.  


refid: a1ffd49de15b6ee0cafe5e83740c7a316
name: InitInput
definition: void InitInput
type: void
argsstring: (int argc, char **argv)
detaileddescription:
 Called from dix/main.c on each server generation to initialize
inputs.  All the work is done in dmxInputInit.  \see
dmxInputInit()  


refid: acf517b24d6b846578e70c059b4afcb1b
name: ProcessInputEvents
definition: void ProcessInputEvents
type: void
argsstring: (void)
detaileddescription:
 Called from dix/dispatch.c in Dispatch() whenever input events
require processing.  All the work is done in the lower level
routines.  


refid: a122b762a283b031348730294d3aa1319
name: dmxUpdateWindowInfo
definition: void dmxUpdateWindowInfo
type: void
argsstring: (DMXUpdateType type, WindowPtr pWindow)
detaileddescription:
 This routine is called from \a dmxwindow.c whenever the layout of
windows on the display might have changed.  This information is used
by input drivers (currently only the console driver) that provide
information about window layout to the user.  


refid: ac8f3465a13cae73a3d657526643ef7b7
name: dmxInputReInit
definition: void dmxInputReInit
type: void
argsstring: (DMXInputInfo *dmxInput)
detaileddescription:
Re-initialize all the devices described in \a dmxInput.  Called from
#dmxAdjustCursorBoundaries before the cursor is redisplayed.  


refid: a9d1185c140ba54b24312ff6c98105c15
name: dmxInputLateReInit
definition: void dmxInputLateReInit
type: void
argsstring: (DMXInputInfo *dmxInput)
detaileddescription:
Re-initialize all the devices described in \a dmxInput.  Called from
#dmxAdjustCursorBoundaries after the cursor is redisplayed.  


refid: a3041e526ae9e56b4a2d0a99f030af71f
name: DMXDummyMou
definition: DMXLocalInputInfoRec DMXDummyMou
type: DMXLocalInputInfoRec
initializer:
= {
    "dummy-mou", DMX_LOCAL_MOUSE, DMX_LOCAL_TYPE_LOCAL, 1,
    NULL, NULL, NULL, NULL, NULL, dmxDummyMouGetInfo
}


refid: af0b33ec9267eea9d58f6792e33e02295
name: DMXDummyKbd
definition: DMXLocalInputInfoRec DMXDummyKbd
type: DMXLocalInputInfoRec
initializer:
= {
    "dummy-kbd", DMX_LOCAL_KEYBOARD, DMX_LOCAL_TYPE_LOCAL, 1,
    NULL, NULL, NULL, NULL, NULL, dmxDummyKbdGetInfo
}


refid: a420b4847b9c9f9992e042754c9a5d9c9
name: DMXBackendMou
definition: DMXLocalInputInfoRec DMXBackendMou
type: DMXLocalInputInfoRec
initializer:
= {
    "backend-mou", DMX_LOCAL_MOUSE, DMX_LOCAL_TYPE_BACKEND, 2,
    dmxBackendCreatePrivate, dmxBackendDestroyPrivate,
    dmxBackendInit, NULL, dmxBackendLateReInit, dmxBackendMouGetInfo,
    dmxCommonMouOn, dmxCommonMouOff, dmxBackendUpdatePosition,
    NULL, NULL, NULL,
    dmxBackendCollectEvents, dmxBackendProcessInput, dmxBackendFunctions, NULL,
    dmxCommonMouCtrl
}


refid: a4ad947489cdc8cae1835dbd5604e0cde
name: DMXBackendKbd
definition: DMXLocalInputInfoRec DMXBackendKbd
type: DMXLocalInputInfoRec
initializer:
= {
    "backend-kbd", DMX_LOCAL_KEYBOARD, DMX_LOCAL_TYPE_BACKEND,
    1,                          
    dmxCommonCopyPrivate, NULL,
    dmxBackendInit, NULL, NULL, dmxBackendKbdGetInfo,
    dmxCommonKbdOn, dmxCommonKbdOff, NULL,
    NULL, NULL, NULL,
    NULL, NULL, NULL, NULL,
    NULL, dmxCommonKbdCtrl, dmxCommonKbdBell
}


refid: a3a58ba39e104b23698ca8ef19789caf3
name: DMXConsoleMou
definition: DMXLocalInputInfoRec DMXConsoleMou
type: DMXLocalInputInfoRec
initializer:
= {
    "console-mou", DMX_LOCAL_MOUSE, DMX_LOCAL_TYPE_CONSOLE, 2,
    dmxConsoleCreatePrivate, dmxConsoleDestroyPrivate,
    dmxConsoleInit, dmxConsoleReInit, NULL, dmxConsoleMouGetInfo,
    dmxCommonMouOn, dmxCommonMouOff, dmxConsoleUpdatePosition,
    NULL, NULL, NULL,
    dmxConsoleCollectEvents, NULL, dmxConsoleFunctions, dmxConsoleUpdateInfo,
    dmxCommonMouCtrl
}


refid: a3c213f84d74e74751787f916f509581f
name: DMXConsoleKbd
definition: DMXLocalInputInfoRec DMXConsoleKbd
type: DMXLocalInputInfoRec
initializer:
= {
    "console-kbd", DMX_LOCAL_KEYBOARD, DMX_LOCAL_TYPE_CONSOLE,
    1,                          
    dmxCommonCopyPrivate, NULL,
    dmxConsoleInit, dmxConsoleReInit, NULL, dmxConsoleKbdGetInfo,
    dmxCommonKbdOn, dmxCommonKbdOff, NULL,
    NULL, NULL, NULL,
    NULL, NULL, NULL, NULL,
    NULL, dmxCommonKbdCtrl, dmxCommonKbdBell
}


refid: aaba396b9c08ac672d3dcf6561ac57b40
name: dmxChangePointerControl
definition: void dmxChangePointerControl
type: void
argsstring: (DeviceIntPtr pDevice, PtrCtrl *ctrl)
detaileddescription:
 Change the pointer control information for the \a pDevice.  If the
device sends core events, then also change the control information
for all of the pointer devices that send core events.  


refid: ad23e145891ad0fb1c909d85ca8e4fe19
name: dmxKeyboardKbdCtrlProc
definition: void dmxKeyboardKbdCtrlProc
type: void
argsstring: (DeviceIntPtr pDevice, KeybdCtrl *ctrl)
detaileddescription:
 Change the keyboard control information for the \a pDevice.  If the
device sends core events, then also change the control information
for all of the keyboard devices that send core events.  


refid: a53a1b16d112e1ddec8bf699ba7b68259
name: dmxKeyboardBellProc
definition: void dmxKeyboardBellProc
type: void
argsstring: (int percent, DeviceIntPtr pDevice, void *ctrl, int unknown)
detaileddescription:
 Sound the bell on the device.  If the device send core events, then
sound the bell on all of the devices that send core events.  


refid: a1279820425966adabf5c77357e4a289c
name: dmxMotionProcPtr
type: void(*
argsstring: )(DevicePtr, int *valuators, int firstAxis, int axesCount, DMXMotionType type, DMXBlockType block)
definition:
typedef void(* dmxMotionProcPtr)(DevicePtr, int *valuators, int firstAxis, int axesCount, DMXMotionType type, DMXBlockType block)


refid: adbd955b9ddbc5ffe38ff65e3f068f205
name: dmxEnqueueProcPtr
type: void(*
argsstring: )(DevicePtr, int type, int detail, KeySym keySym, XEvent *e, DMXBlockType block)
definition:
typedef void(* dmxEnqueueProcPtr)(DevicePtr, int type, int detail, KeySym keySym, XEvent *e, DMXBlockType block)


refid: adcfb97363d7c30f429637f857e07ab89
name: dmxCollectEventsProcPtr
type: void(*
argsstring: )(DevicePtr, dmxMotionProcPtr, dmxEnqueueProcPtr, dmxCheckSpecialProcPtr, DMXBlockType)
definition:
typedef void(* dmxCollectEventsProcPtr)(DevicePtr, dmxMotionProcPtr, dmxEnqueueProcPtr, dmxCheckSpecialProcPtr, DMXBlockType)


refid: a18d50c3ccca9422952b75ceed4e26e8e
name: DMXLocalInputInfoRec
definition: typedef struct _DMXLocalInputInfo DMXLocalInputInfoRec
type: struct _DMXLocalInputInfo
detaileddescription:
 This is the device-independent structure used by the low-level input
routines.  The contents are not exposed to top-level .c files (except
dmxextensions.c).  \see dmxinput.h \see dmxextensions.c  


refid: ab6259430a57c3cffdfc9f6259df0ad23
name: dmxLog
definition: void dmxLog
type: void
argsstring: (dmxLogLevel logLevel, const char *format,...)
detaileddescription:
 Log the specified message at the specified \a logLevel.  \a format
can be a printf-like format expression.  


refid: aabe50ca33403c25a9e57a06d1d3a089a
name: dmxLogOutput
definition: void dmxLogOutput
type: void
argsstring: (DMXScreenInfo *dmxScreen, const char *format,...)
detaileddescription:
 Log an informational message (at level #dmxInfo) related to ouput.
The message prefix will contain backend information from \a
dmxScreen.  


refid: a079f70db20eaa2ba22b976851da820b6
name: dmxLogOutputWarning
definition: void dmxLogOutputWarning
type: void
argsstring: (DMXScreenInfo *dmxScreen, const char *format,...)
detaileddescription:
 Log a warning message (at level #dmxWarning) related to output.
The message prefix will contain backend information from \a
dmxScreen.  


refid: ac8d8dc0ec631bab1d1d95815c238d574
name: dmxLogInput
definition: void dmxLogInput
type: void
argsstring: (DMXInputInfo *dmxInput, const char *format,...)
detaileddescription:
 Log an informational message (at level #dmxInfo) related to input.
The message prefix will contain information from \a dmxInput.  


refid: afc95eb36d0aadc52b34ee3e506f70f7b
name: dmxLogArgs
definition: void dmxLogArgs
type: void
argsstring: (dmxLogLevel logLevel, int argc, char **argv)
detaileddescription:
 Print \a argc messages, each describing an element in \a argv.  This
is maingly for debugging purposes.  


refid: ada5a28e0c746708e0f5c45e9e193d907
name: dmxMapInsert
definition: void dmxMapInsert
type: void
argsstring: (DMXLocalInputInfoPtr dmxLocal, int remoteEvent, int serverEvent)
detaileddescription:
 Create a mapping from \a remoteEvent to \a serverEvent. The \a
remoteEvent is the type returned from the remote server.  The \a
serverEvent is from the XI_* list of events in
include/extensions/XIproto.h.  


refid: abc1a46c87c4acd45e4e5f79370be6169
name: dmxMapLookup
definition: int dmxMapLookup
type: int
argsstring: (DMXLocalInputInfoPtr dmxLocal, int remoteEvent)
detaileddescription:
 Lookup a mapping for \a remoteEvent.  The \a remoteEvent is the type
returned from the remote server.  The return value is that which was
passed into #dmxMapInsert (i.e., a value from the XI_* list in
include/extensions/XIproto.h).  If a mapping is not available, -1 is
returned.  


refid: a6ebfa18908cd0473f3f23643e9ca2a58
name: dmxPointerGetMotionEvents
definition: int dmxPointerGetMotionEvents
type: int
argsstring:
(DeviceIntPtr pDevice, xTimecoord *coords, unsigned long start, unsigned long stop, ScreenPtr pScreen)

detaileddescription:
 This routine performs the same function as \a miPointerGetMotionEvents:
the events in the motion history that are between the start and stop
times (in mS) are placed in the coords vector, and the count of the
number of items so placed is returned.  This routine is called from
dix/devices.c so that coords can hold valuator->numMotionEvents
events.  This routine is called from \a Xi/gtmotion.c with coords large
enough to hold the same number of events in a variable-length
extended \a xTimecoord structure.  This provides sufficient data for the
\a XGetDeviceMotionEvents library call, and would be identical to
\a miPointerGetMotionEvents for devices with only 2 axes (i.e., core
pointers) if \a xTimecoord used 32bit integers.

Because DMX uses the mi* routines for all core devices, this routine
only has to support extension devices using the polymorphic coords.
Because compatibility with miPointerGetMotionEvents is not possible,
it is not provided.  


refid: abe71ba14a07f4077ca2658f81426f4c6
name: dmxPointerPutMotionEvent
definition: void dmxPointerPutMotionEvent
type: void
argsstring: (DeviceIntPtr pDevice, int firstAxis, int axesCount, int *v, unsigned long time)
detaileddescription:
 This routine adds an event to the motion history.  A similar
function is performed by miPointerMove for the mi versions of these
routines.  


refid: ab3f5b4d4a5b535faf87b3bf7cb30d2d0
name: dmxConfigCreateDisplay
definition: DMXConfigDisplayPtr dmxConfigCreateDisplay
type: DMXConfigDisplayPtr
argsstring:
(DMXConfigTokenPtr pStart, DMXConfigStringPtr pName, DMXConfigFullDimPtr pDim, DMXConfigPairPtr pOrigin, DMXConfigTokenPtr pEnd)


refid: a6078c6ad23fc49e4992cade35f7351b2
name: dmxConfigCreateWall
definition: DMXConfigWallPtr dmxConfigCreateWall
type: DMXConfigWallPtr
argsstring:
(DMXConfigTokenPtr pStart, DMXConfigPairPtr pWallDim, DMXConfigPairPtr pDisplayDim, DMXConfigStringPtr pNameList, DMXConfigTokenPtr pEnd)


refid: a0a4ebd4b3769682daf7a6fed9f11744d
name: dmxConfigCreateParam
definition: DMXConfigParamPtr dmxConfigCreateParam
type: DMXConfigParamPtr
argsstring:
(DMXConfigTokenPtr pStart, DMXConfigTokenPtr pOpen, DMXConfigStringPtr pParam, DMXConfigTokenPtr pClose, DMXConfigTokenPtr pEnd)


refid: aa7e24c7be4cc3880e15274a53b627267
name: dmxConfigCreateSub
definition: DMXConfigSubPtr dmxConfigCreateSub
type: DMXConfigSubPtr
argsstring:
(DMXConfigType type, DMXConfigCommentPtr comment, DMXConfigDisplayPtr display, DMXConfigWallPtr wall, DMXConfigOptionPtr option, DMXConfigParamPtr param)


refid: a427549ab2ffa269ca34bdb1a60e87bb0
name: dmxConfigCreateVirtual
definition: DMXConfigVirtualPtr dmxConfigCreateVirtual
type: DMXConfigVirtualPtr
argsstring:
(DMXConfigTokenPtr pStart, DMXConfigStringPtr pName, DMXConfigPairPtr pDim, DMXConfigTokenPtr pOpen, DMXConfigSubPtr pSubentry, DMXConfigTokenPtr pClose)


refid: acec532235fc1d75b24779b3ed50aa037
name: dmxConfigAddEntry
definition: DMXConfigEntryPtr dmxConfigAddEntry
type: DMXConfigEntryPtr
argsstring:
(DMXConfigEntryPtr head, DMXConfigType type, DMXConfigCommentPtr comment, DMXConfigVirtualPtr virtual)


refid: a80081bafc7043ef16f07b96b9322264c
name: dmxGlyphLastError
definition: int dmxGlyphLastError
type: int
detaileddescription:
Catch errors that might occur when allocating Glyph Sets.  Errors
are saved in dmxGlyphLastError for later handling.  


refid: aaaa954b686d1322b7cda6a83f24a8c45
name: dmxProcRenderCreateGlyphSet
definition: static int dmxProcRenderCreateGlyphSet
type: int
argsstring: (ClientPtr client)
detaileddescription:
Create a Glyph Set on each screen.  Save the glyphset ID from each
screen in the Glyph Set's private structure.  Fail if the format
requested is not available or if the Glyph Set cannot be created on
the screen.  


refid: a612db8702e6a380e12719576a57602e7
name: dmxProcRenderCompositeGlyphs
definition: static int dmxProcRenderCompositeGlyphs
type: int
argsstring: (ClientPtr client)
detaileddescription:
Composite glyphs on each screen into the requested picture.  If
either the src or dest picture has not been allocated due to lazy
window creation, this request will gracefully return.  


refid: a76cabef9d3047d8f514fb6e17b951145
name: dmxInitRender
definition: void dmxInitRender
type: void
argsstring: (void)
detaileddescription:
Initialize the Proc Vector for the RENDER extension.  The functions
here cannot be handled by the mi layer RENDER hooks either because
the required information is no longer available when it reaches the
mi layer or no mi layer hooks exist.  This function is called from
InitOutput() since it should be initialized only once per server
generation.  


refid: a93c956636d6aba1f2ce1cab637e00fff
name: dmxResetRender
definition: void dmxResetRender
type: void
argsstring: (void)
detaileddescription:
Reset the Proc Vector for the RENDER extension back to the original
functions.  This function is called from dmxCloseScreen() during the
server reset (only for screen #0).  


refid: a457aa4df6b01e88a26cc069094e4b07c
name: dmxPictureInit
definition: Bool dmxPictureInit
type: Bool
argsstring: (ScreenPtr pScreen, PictFormatPtr formats, int nformats)
detaileddescription:
Initialize the RENDER extension, allocate the picture privates and
wrap mi function hooks.  If the shadow frame buffer is used, then
call the appropriate fb initialization function.  


refid: aa154f0c705ffdaf3770cd87c478db004
name: dmxFindFormat
definition: static XRenderPictFormat* dmxFindFormat
type: XRenderPictFormat *
argsstring: (DMXScreenInfo *dmxScreen, PictFormatPtr pFmt)
detaileddescription:
Find the appropriate format on the requested screen given the
internal format requested.  The list of formats is searched
sequentially as the XRenderFindFormat() function does not always
find the appropriate format when a specific format is requested.  


refid: a314fad65d3e8f6470ed95e052348df3d
name: dmxDoCreatePicture
definition: static Picture dmxDoCreatePicture
type: Picture
argsstring: (PicturePtr pPicture)
detaileddescription:
Create a picture on the appropriate screen.  This is the actual
function that creates the picture.  However, if the associated
window has not yet been created due to lazy window creation, then
delay the picture creation until the window is mapped.  


refid: a8c52091268b0f77d74d3a097b396abcf
name: dmxCreatePictureList
definition: void dmxCreatePictureList
type: void
argsstring: (WindowPtr pWindow)
detaileddescription:
Create a list of pictures.  This function is called by
dmxCreateAndRealizeWindow() during the lazy window creation
realization process.  It creates the entire list of pictures that
are associated with the given window.  


refid: ad7adb9c71564816f5f3172c710274d57
name: dmxCreatePicture
definition: int dmxCreatePicture
type: int
argsstring: (PicturePtr pPicture)
detaileddescription:
Create a picture.  This function handles the CreatePicture
unwrapping/wrapping and calls dmxDoCreatePicture to actually create
the picture on the appropriate screen.   


refid: a0af49a0382a2763672f3f8bc1e1ee156
name: dmxDestroyPictureList
definition: Bool dmxDestroyPictureList
type: Bool
argsstring: (WindowPtr pWindow)
detaileddescription:
Destroy a list of pictures that are associated with the window that
is being destroyed.  This function is called by #dmxDestroyWindow().


refid: aee92c240df08f4c8a62c291b3efa4d7e
name: dmxDestroyPicture
definition: void dmxDestroyPicture
type: void
argsstring: (PicturePtr pPicture)
detaileddescription:
Destroy a picture.  This function calls the wrapped function that
frees the resources in the DMX server associated with this
picture.  


refid: a316382a2e169f1662363123670a252c7
name: dmxChangePicture
definition: void dmxChangePicture
type: void
argsstring: (PicturePtr pPicture, Mask mask)
detaileddescription:
Change the attributes of the pictures.  If the picture has not yet
been created due to lazy window creation, save the mask so that it
can be used to appropriately initialize the picture's attributes
when it is created later.  


refid: a3a9285c518b050130e40b7e147309350
name: dmxValidatePicture
definition: void dmxValidatePicture
type: void
argsstring: (PicturePtr pPicture, Mask mask)
detaileddescription:
Validate the picture's attributes before rendering to it.  Update
any picture attributes that have been changed by one of the higher
layers.  


refid: a65851c1a4e9cd6946d67ff5aaf7bce88
name: dmxComposite
definition: void dmxComposite
type: void
argsstring:
(CARD8 op, PicturePtr pSrc, PicturePtr pMask, PicturePtr pDst, INT16 xSrc, INT16 ySrc, INT16 xMask, INT16 yMask, INT16 xDst, INT16 yDst, CARD16 width, CARD16 height)

detaileddescription:
Composite a picture on the appropriate screen by combining the
specified rectangle of the transformed src and mask operands with
the specified rectangle of the dst using op as the compositing
operator.  For a complete description see the protocol document of
the RENDER library.  


refid: a8a98dca5e23c501c44fa3e040e31d100
name: dmxGlyphs
definition: void dmxGlyphs
type: void
argsstring:
(CARD8 op, PicturePtr pSrc, PicturePtr pDst, PictFormatPtr maskFormat, INT16 xSrc, INT16 ySrc, int nlists, GlyphListPtr lists, GlyphPtr *glyphs)

detaileddescription:
Null function to catch when/if RENDER calls lower level mi hooks.
Compositing glyphs is handled by dmxProcRenderCompositeGlyphs().
This function should never be called.  


refid: ae828cd3db7af3c9e3a615267cd780ac4
name: dmxCompositeRects
definition: void dmxCompositeRects
type: void
argsstring: (CARD8 op, PicturePtr pDst, xRenderColor *color, int nRect, xRectangle *rects)
detaileddescription:
Fill a rectangle on the appropriate screen by combining the color
with the dest picture in the area specified by the list of
rectangles.  For a complete description see the protocol document of
the RENDER library.  


refid: ae54f217c222944bb10731d73e05ed4b2
name: dmxTrapezoids
definition: void dmxTrapezoids
type: void
argsstring:
(CARD8 op, PicturePtr pSrc, PicturePtr pDst, PictFormatPtr maskFormat, INT16 xSrc, INT16 ySrc, int ntrap, xTrapezoid *traps)

detaileddescription:
Composite a list of trapezoids on the appropriate screen.  For a
complete description see the protocol document of the RENDER
library.  


refid: a401f568feed789ffc0bb1cc52573f707
name: dmxTriangles
definition: void dmxTriangles
type: void
argsstring:
(CARD8 op, PicturePtr pSrc, PicturePtr pDst, PictFormatPtr maskFormat, INT16 xSrc, INT16 ySrc, int ntri, xTriangle *tris)

detaileddescription:
Composite a list of triangles on the appropriate screen.  For a
complete description see the protocol document of the RENDER
library.  


refid: aeebcf1d84e771f9d64413521173d366a
name: dmxConfigPrint
definition: void dmxConfigPrint
type: void
argsstring: (FILE *stream, DMXConfigEntryPtr entry)
detaileddescription:
 The configuration information in \a entry will be pretty-printed to
the \a stream.  If \a stream is NULL, then stdout will be used.  


refid: ae0a45c7fe5f9f4afb7e68856253350be
name: dmxConfigVirtualPrint
definition: void dmxConfigVirtualPrint
type: void
argsstring: (FILE *stream, DMXConfigVirtualPtr p)
detaileddescription:
 The configuration information in \a p will be pretty-printed to the
\a stream.  If \a stream is NULL, then stdout will be used.  


refid: a1353800f90c3a1f46d453caa71a41ab6
name: dmxPropertyIterate
definition: void* dmxPropertyIterate
type: void *
argsstring: (DMXScreenInfo *start, void *(*f)(DMXScreenInfo *dmxScreen, void *), void *closure)
detaileddescription:
 Starting with the \a start screen, iterate over all of the screens
on the same physical X server as \a start, calling \a f with the
screen and the \a closure.  (The common case is that \a start is the
only DMX window on the backend X server.)  


refid: a5e976d40a4af5d6cd99b69ead01d0dfb
name: dmxPropertyCheckOtherWindows
definition: static DMXScreenInfo* dmxPropertyCheckOtherWindows
type: DMXScreenInfo *
argsstring: (DMXScreenInfo *dmxScreen, Atom atom)
detaileddescription:
 Returns NULL if this is the only Xdmx window on the display.
Otherwise, returns a pointer to the dmxScreen of the other windows on
the display.  


refid: ad0a551002589f00b2bac2b081283bc83
name: dmxPropertySameDisplay
definition: int dmxPropertySameDisplay
type: int
argsstring: (DMXScreenInfo *dmxScreen, const char *name)
detaileddescription:
 Returns 1 if the dmxScreen and the display in \a name are on the
same display, or 0 otherwise.  We can't just compare the display
names because there can be multiple synonyms for the same display,
some of which cannot be determined without accessing the display
itself (e.g., domain aliases or machines with multiple NICs).  


refid: aa97527eeaaf0744a67a5c5d188daf8c2
name: dmxPropertyWindow
definition: void dmxPropertyWindow
type: void
argsstring: (DMXScreenInfo *dmxScreen)
detaileddescription:
 Prints a log message if \a dmxScreen is on the same backend X server
as some other DMX backend (output) screen.  Modifies the property
(#DMX_ATOMNAME) on the backend X server to reflect the creation of \a
dmxScreen.

The root window of the backend X server holds a list of window ids
for all DMX windows (on this DMX server or some other DMX server).

This list can then be iterated, and the property for each window can
be examined.  This property contains the following tuple (no quotes):

"#DMX_IDENT:<hostname running DMX>:<display name of DMX>,<screen number>"


refid: ac3cccb6a8d72aaa0c7ac64f061d0b877
name: dmxSigioRegister
definition: void dmxSigioRegister
type: void
argsstring: (DMXInputInfo *dmxInput, int fd)
detaileddescription:
 Make a note that the input device described in \a dmxInput will be
using the file descriptor \a fd for SIGIO signals.  Calls
AddEnabledDevice ifi SIGIO handling has been enabled with
#dmxSigioEnableInput().  


refid: ac447ef5c9a3aa88a5cb049ea0beecfd2
name: dmxSigioUnregister
definition: void dmxSigioUnregister
type: void
argsstring: (DMXInputInfo *dmxInput)
detaileddescription:
 Remove the notes that \a dmxInput is using any file descriptors for
SIGIO signals.  Calls RemoveEnabledDevice.  


refid: a1a534cc2274afee02c883ac10ea9435f
name: usec
definition: static unsigned long usec
type: unsigned long
argsstring: (struct timeval *stop, struct timeval *start)
detaileddescription:
 Return the number of microseconds as an unsigned long.
Unfortunately, this is only useful for intervals < about 4 sec.   


refid: a3d01ce5487317c131c32e31f05489c58
name: dmxStatActivate
definition: void dmxStatActivate
type: void
argsstring: (const char *interval, const char *displays)
detaileddescription:
 Turn on XSync statistic gathering and printing.  Print every \a
interval seconds, with lines for the first \a displays.  If \a
interval is NULL, 1 will be used.  If \a displays is NULL, 0 will be
used (meaning a line for every display will be printed).  Note that
this function takes string arguments because it will usually be
called from #ddxProcessArgument in \a dmxinit.c.  


refid: a1098a195e40df685aaf2fbc238884027
name: dmxStatSync
definition: void dmxStatSync
type: void
argsstring: (DMXScreenInfo *dmxScreen, struct timeval *stop, struct timeval *start, unsigned long pending)
detaileddescription:
 Note that a XSync() was just done on \a dmxScreen with the \a start
and \a stop times (from gettimeofday()) and the number of
pending-but-not-yet-processed XSync requests.  This routine is called
from #dmxDoSync in \a dmxsync.c  


refid: a48ed41878576dd3ff9212deaecb2cc1f
name: dmxStatInit
definition: void dmxStatInit
type: void
argsstring: (void)
detaileddescription:
 Try to initialize the statistic gathering and printing routines.
Initialization only takes place if #dmxStatActivate has already been
called.  We don't need the same generation protection that we used in
dmxSyncInit because our timer is always on a queue &ndash; hence, server
generation will always free it.  


refid: ae0a769161d6f8d88067a9cac16f9cf6f
name: dmxSyncActivate
definition: void dmxSyncActivate
type: void
argsstring: (const char *interval)
detaileddescription:
 Request the XSync() batching optimization with the specified \a
interval (in mS).  If the \a interval is 0, 100mS is used.  If the \a
interval is less than 0, then the XSync() batching optimization is
not requested (e.g., so the -syncbatch -1 command line option can
turn off the default 100mS XSync() batching).

Note that the parameter to this routine is a string, since it will
usually be called from #ddxProcessArgument in \a dmxinit.c  


refid: a0b349896e58d4291d712e31121fdc0ac
name: dmxSyncInit
definition: void dmxSyncInit
type: void
argsstring: (void)
detaileddescription:
 Initialize the XSync() batching optimization, but only if
#dmxSyncActivate was last called with a non-negative value.  


refid: ab848762f4d2e30d31b87d3e8e10c5967
name: dmxSync
definition: void dmxSync
type: void
argsstring: (DMXScreenInfo *dmxScreen, Bool now)
detaileddescription:
 Request an XSync() to the display used by \a dmxScreen.  If \a now
is TRUE, call XSync() immediately instead of waiting for the next
XSync() batching point.  Note that if XSync() batching was deselected
with #dmxSyncActivate() before #dmxSyncInit() was called, then no
XSync() batching is performed and this function always calles XSync()
immediately.

(Note that this function uses TimerSet but works correctly in the
face of a server generation.  See the source for details.)

If \a dmxScreen is \a NULL, then all pending syncs will be flushed
immediately.


refid: af96b8583264e78a4c693c6f7ee887067
name: dmxResizeScreenWindow
definition: void dmxResizeScreenWindow
type: void
argsstring: (ScreenPtr pScreen, int x, int y, int w, int h)
detaileddescription:
Change the location and size of the "screen" window.  Called from
dmxextension.c dmxConfigureScreenWindow().  


refid: afefa2121a2898700d285e77730a52c4d
name: dmxCreateAndRealizeWindow
definition: void dmxCreateAndRealizeWindow
type: void
argsstring: (WindowPtr pWindow, Bool doSync)
detaileddescription:
This function handles lazy window creation and realization.  Window
creation is handled by #dmxCreateNonRootWindow().  It also handles
any stacking changes that have occured since the window was
originally created by calling #dmxDoRestackWindow().  If the window
is shaped, the shape is set on the back-end server by calling
#dmxDoSetShape(), and if the window has pictures (from RENDER)
associated with it, those pictures are created on the back-end
server by calling #dmxCreatePictureList().  If \a doSync is TRUE,
then #dmxSync() is called.  


refid: aebb0ce7ac51645832a20c7d6a7d21d9c
name: dmxCreateWindow
definition: Bool dmxCreateWindow
type: Bool
argsstring: (WindowPtr pWindow)
detaileddescription:
Create \a pWindow on the back-end server.  If the lazy window
creation optimization is enabled, then the actual creation and
realization of the window is handled by
#dmxCreateAndRealizeWindow().  


refid: a25a0aafd36f68137e67a3e6d95b78f53
name: dmxDestroyWindow
definition: Bool dmxDestroyWindow
type: Bool
argsstring: (WindowPtr pWindow)
detaileddescription:
Destroy \a pWindow on the back-end server.  If any RENDER pictures
were created, destroy them as well.  


refid: ac75f5d6332a78eeac4e0e185cf326045
name: dmxRealizeWindow
definition: Bool dmxRealizeWindow
type: Bool
argsstring: (WindowPtr pWindow)
detaileddescription:
Realize \a pWindow on the back-end server.  If the lazy window
creation optimization is enabled, the window is only realized when
it at least partially overlaps the screen.  


refid: a02a6991e5248012e287fe4be3a985926
name: dmxWindowExposures
definition: void dmxWindowExposures
type: void
argsstring: (WindowPtr pWindow, RegionPtr prgn, RegionPtr other_exposed)
detaileddescription:
Handle exposures on \a pWindow.  Since window exposures are handled
in DMX, the events that are generated by the back-end server are
redundant, so we eat them here.  


refid: ad78bdba42db62285cf174f072a63a81a
name: dmxCopyWindow
definition: void dmxCopyWindow
type: void
argsstring: (WindowPtr pWindow, DDXPointRec ptOldOrg, RegionPtr prgnSrc)
detaileddescription:
Move \a pWindow on the back-end server.  Determine whether or not it
is on or offscreen, and realize it if it is newly on screen and the
lazy window creation optimization is enabled.  


refid: ac3811e381fef200b5cd3207478df66e1
name: dmxResizeWindow
definition: void dmxResizeWindow
type: void
argsstring: (WindowPtr pWindow, int x, int y, unsigned int w, unsigned int h, WindowPtr pSib)
detaileddescription:
Resize \a pWindow on the back-end server.  Determine whether or not
it is on or offscreen, and realize it if it is newly on screen and
the lazy window creation optimization is enabled.  


refid: a35b887c43ad7855996b9aab8151fc479
name: DMX_WINDOW_FUNC_PROLOGUE
initializer:
do {									\
    dmxGCPrivPtr pGCPriv = DMX_GET_GC_PRIV(_pGC);			\
    DMX_UNWRAP(funcs, pGCPriv, (_pGC));					\
    if (pGCPriv->ops)							\
	DMX_UNWRAP(ops, pGCPriv, (_pGC));				\
} while (0)


refid: a9144b8f0cbe6f869da8a9ddcfbaa5f1b
name: DMX_WINDOW_FUNC_EPILOGUE
initializer:
do {									\
    dmxGCPrivPtr pGCPriv = DMX_GET_GC_PRIV(_pGC);			\
    DMX_WRAP(funcs, &dmxGCFuncs, pGCPriv, (_pGC));			\
    if (pGCPriv->ops)							\
	DMX_WRAP(ops, &dmxGCOps, pGCPriv, (_pGC));			\
} while (0)


refid: a9d5f07cf04c9e32d918d57d096769a5d
name: DMX_WINDOW_OFFSCREEN
initializer:
(DMX_WINDOW_X1(_pWin) >= (_pWin)->drawable.pScreen->width  ||	\
     DMX_WINDOW_Y1(_pWin) >= (_pWin)->drawable.pScreen->height ||	\
     DMX_WINDOW_X2(_pWin) <= 0                                 ||	\
     DMX_WINDOW_Y2(_pWin) <= 0)


refid: aacf069d346230dd96812d5395728eef2
name: GETPRIV
initializer:
myPrivate *priv                            \
                      = ((DMXLocalInputInfoPtr)(pDev->devicePrivate))->private


refid: a0acb8c77b4bd032bda9aeb87a656b9e7
name: kbdLinuxBell
definition: void kbdLinuxBell
type: void
argsstring: (DevicePtr pDev, int percent, int volume, int pitch, int duration)
detaileddescription:
 Ring the bell.

Note: we completely ignore the \a volume, since Linux's ioctl()
interface does not provide a way to control it.  If it did, the XBell
manpage tells how the actual volume is a function of the percent and
the (base) volume.

Note that most of the other PC-based bell drivers compute the
duration for KDMKTONE as a function of the volume and the duration.
For some drivers, the duration is only measured in mS if the volume
is 50, and is scaled by the volume for other values.  This seems
confusing and possibly incorrect (the xset man page says that the
bell will be "as closely as it can to the user's specifications" &ndash;
if we ignore the volume and set the duration correctly, then we'll
get one parameter "wrong" &ndash; but if we use the volume to scale the
duration, then we'll get both parameters "wrong").  


refid: a3dfbbb162874ae05c4e0581a1fcf2066
name: kbdLinuxVTSwitch
definition: int kbdLinuxVTSwitch
type: int
argsstring: (void *p, int vt, void(*switch_return)(void *), void *switch_return_data)
detaileddescription:
 Tell the operating system to switch to \a vt.  The \a switch_return
function is called with the \a switch_return_data when the VT is
switched back to the pre-switch VT (i.e., the user returns to the DMX
session).  


refid: aa7781cedb743039542090faf43d9423f
name: kbdLinuxRead
definition: void kbdLinuxRead
type: void
argsstring: (DevicePtr pDev, MOTIONPROC motion, ENQUEUEPROC enqueue, CHECKPROC checkspecial, BLOCK block)
detaileddescription:
 Read an event from the \a pDev device.  If the event is a motion
event, enqueue it with the \a motion function.  Otherwise, check for
special keys with the \a checkspecial function and enqueue the event
with the \a enqueue function.  The \a block type is passed to the
functions so that they may block SIGIO handling as appropriate to the
caller of this function.  


refid: a7581da9bfd7ebf4fe3703352df521931
name: PRESS
initializer:
do {                                                 \
        enqueue(pDev, ButtonPress, 0, 0, NULL, block);   \
    } while (0)


refid: a2b4d2480737f9eb52f80998518486f01
name: RELEASE
initializer:
do {                                                 \
        enqueue(pDev, ButtonRelease, 0, 0, NULL, block); \
    } while (0)


refid: aacf069d346230dd96812d5395728eef2
name: GETPRIV
initializer:
myPrivate *priv                                         \
                      = ((DMXLocalInputInfoPtr)(pDev->devicePrivate))->private


refid: ae20f3b14463c8e288041f9970e388950
name: usbRead
definition: void usbRead
type: void
argsstring: (DevicePtr pDev, MOTIONPROC motion, ENQUEUEPROC enqueue, int minButton, BLOCK block)
detaileddescription:
 Read an event from the \a pDev device.  If the event is a motion
event, enqueue it with the \a motion function.  Otherwise, enqueue
the event with the \a enqueue function.  The \a block type is passed
to the functions so that they may block SIGIO handling as appropriate
to the caller of this function.

Since USB devices return EV_KEY events for buttons and keys, \a
minButton is used to decide if a Button or Key event should be
queued. 


refid: aea8c9cef438c8851ef7f47d7167152cb
name: usbRead
definition: void usbRead
type: void
argsstring:
(DevicePtr pDev, dmxMotionProcPtr motion, dmxEnqueueProcPtr enqueue, int minButton, DMXBlockType block)


refid: a1bdbc94af66450a58735130ce8b994d0
name: kbdUSBConvert
definition: static void kbdUSBConvert
type: void
argsstring:
(DevicePtr pDev, unsigned int scanCode, int value, ENQUEUEPROC enqueue, CHECKPROC checkspecial, BLOCK block)


