From 0d3d2607404af7f6e059fab64caea39dc34e391e Mon Sep 17 00:00:00 2001 From: Kaleb Keithley Date: Fri, 14 Nov 2003 15:54:38 +0000 Subject: R6.6 is the Xorg base-line --- man/DBE.man | 314 ++++++++ man/XShape.man | 175 +++++ man/XdbeAllocateBackBufferName.man | 68 ++ man/XdbeBeginIdiom.man | 47 ++ man/XdbeDeallocateBackBufferName.man | 54 ++ man/XdbeEndIdiom.man | 47 ++ man/XdbeFreeVisualInfo.man | 49 ++ man/XdbeGetBackBufferAttributes.man | 66 ++ man/XdbeGetVisualInfo.man | 126 ++++ man/XdbeQueryExtension.man | 62 ++ man/XdbeSwapBuffers.man | 97 +++ man/Xevi.man | 162 +++++ man/Xmbuf.man | 344 +++++++++ src/DPMS.c | 296 ++++++++ src/MITMisc.c | 134 ++++ src/XAppgroup.c | 432 +++++++++++ src/XEVI.c | 212 ++++++ src/XLbx.c | 127 ++++ src/XMultibuf.c | 722 +++++++++++++++++++ src/XSecurity.c | 308 ++++++++ src/XShape.c | 493 +++++++++++++ src/XShm.c | 444 ++++++++++++ src/XSync.c | 862 ++++++++++++++++++++++ src/XTestExt1.c | 1317 ++++++++++++++++++++++++++++++++++ src/Xcup.c | 283 ++++++++ src/Xdbe.c | 542 ++++++++++++++ src/extutil.c | 298 ++++++++ src/globals.c | 89 +++ 28 files changed, 8170 insertions(+) create mode 100644 man/DBE.man create mode 100644 man/XShape.man create mode 100644 man/XdbeAllocateBackBufferName.man create mode 100644 man/XdbeBeginIdiom.man create mode 100644 man/XdbeDeallocateBackBufferName.man create mode 100644 man/XdbeEndIdiom.man create mode 100644 man/XdbeFreeVisualInfo.man create mode 100644 man/XdbeGetBackBufferAttributes.man create mode 100644 man/XdbeGetVisualInfo.man create mode 100644 man/XdbeQueryExtension.man create mode 100644 man/XdbeSwapBuffers.man create mode 100644 man/Xevi.man create mode 100644 man/Xmbuf.man create mode 100644 src/DPMS.c create mode 100644 src/MITMisc.c create mode 100644 src/XAppgroup.c create mode 100644 src/XEVI.c create mode 100644 src/XLbx.c create mode 100644 src/XMultibuf.c create mode 100644 src/XSecurity.c create mode 100644 src/XShape.c create mode 100644 src/XShm.c create mode 100644 src/XSync.c create mode 100644 src/XTestExt1.c create mode 100644 src/Xcup.c create mode 100644 src/Xdbe.c create mode 100644 src/extutil.c create mode 100644 src/globals.c diff --git a/man/DBE.man b/man/DBE.man new file mode 100644 index 0000000..bf36222 --- /dev/null +++ b/man/DBE.man @@ -0,0 +1,314 @@ +.\" $Xorg: DBE.man,v 1.4 2001/03/16 17:49:55 pookie Exp $ +.\" +.\" Copyright (c) 1995 Hewlett-Packard Company +.\" +.\" Permission is hereby granted, free of charge, to any person obtaining a +.\" copy of this software and associated documentation files (the "Software"), +.\" to deal in the Software without restriction, including without limitation +.\" the rights to use, copy, modify, merge, publish, distribute, sublicense, +.\" and/or sell copies of the Software, and to permit persons to whom the +.\" Software furnished to do so, subject to the following conditions: +.\" +.\" The above copyright notice and this permission notice shall be included in +.\" all copies or substantial portions of the Software. +.\" +.\" THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +.\" IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +.\" FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL +.\" HEWLETT-PACKARD COMPANY BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, +.\" WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF +.\" OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +.\" SOFTWARE. +.\" +.\" Except as contained in this notice, the name of the Hewlett-Packard Company shall not +.\" be used in advertising or otherwise to promote the sale, use or other +.\" dealing in this Software without prior written authorization from the +.\" Hewlett-Packard Company. +.TH DBE 3X11 "Release 6.6" "X Version 11" "X FUNCTIONS" +.SH NAME +DBE - Double Buffer Extension +.SH SYNOPSIS +The Double Buffer Extension (DBE) provides a standard way to utilize +double-buffering within the framework of the X Window System. +Double-buffering uses two buffers, called front and back, which hold images. +The front buffer is visible to the user; the back buffer is not. Successive +frames of an animation are rendered into the back buffer while the previously +rendered frame is displayed in the front buffer. When a new frame is ready, +the back and front buffers swap roles, making the new frame visible. Ideally, +this exchange appears to happen instantaneously to the user, with no visual +artifacts. Thus, only completely rendered images are presented to the user, +and remain visible during the entire time it takes to render a new frame. The +result is a flicker-free animation. +.SH DESCRIPTION +.B Concepts +.RS +Normal windows are created using +.B XCreateWindow() +or +.B XCreateSimpleWindow(), +which allocate a set of window attributes and, for InputOutput windows, a front +buffer, into which an image can be drawn. The contents of this buffer will be +displayed when the window is visible. + +This extension enables applications to use double-buffering with a window. +This involves creating a second buffer, called a back buffer, and associating +one or more back buffer names +.I (XIDs) +with the window, for use when referring +to (i.e., drawing to or reading from) the window's back buffer. +The back buffer name is a drawable of type +.I XdbeBackBuffer. + +DBE provides a relative double-buffering model. One XID, the window, +always refers to the front buffer. One or more other XIDs, the back buffer +names, always refer to the back buffer. After a buffer swap, the window +continues to refer to the (new) front buffer, and the back buffer name +continues to refer to the (new) back buffer. Thus, applications and toolkits +that want to just render to the back buffer always use the back buffer name +for all drawing requests to the window. Portions of an application that want +to render to the front buffer always use the window XID for all drawing +requests to the window. + +Multiple clients and toolkits can all use double-buffering on the same window. +DBE does not provide a request for querying whether a window has +double-buffering support, and if so, what the back buffer name is. Given the +asynchronous nature of the X Window System, this would cause race +conditions. Instead, DBE allows multiple back buffer names to exist for the +same window; they all refer to the same physical back buffer. The first time a +back buffer name is allocated for a window, the window becomes +double-buffered and the back buffer name is associated with the window. +Subsequently, the window already is a double-buffered window, and nothing +about the window changes when a new back buffer name is allocated, except +that the new back buffer name is associated with the window. The window +remains double-buffered until either the window is destroyed, or until all of +the back buffer names for the window are deallocated. + +In general, both the front and back buffers ae treated the same. In +particular, here are some important characteristics: + +.RS +Only one buffer per window can be visible at a time (the front buffer). + +Both buffers associated with a window have the same visual type, depth, +width, height, and shape as the window. + +Both buffers associated with a window are "visible" (or "obscured") in +the same way. When an Expose event is generated for a window, this +event is considered to apply to both buffers equally. When a +double-buffered window is exposed, both buffers are tiled with the +window background. +Even though the back buffer is not visible, terms such as obscure apply to the +back buffer as well as to the front buffer. + +It is acceptable at any time to pass an +.I XdbeBackBuffer +in any function that expects a drawable. +This enables an application to draw directly into +.I XdbeBackBuffer +in the same fashion as it would draw into any other drawable. + +It is an error (Window) to pass an +.I XdbeBackBuffer +in a function that expects a Window. + +An +.I XdbeBackBuffer +will never be sent in a reply, event, or error where a Window is specified. + +If backing-store and save-under applies to a double-buffered +window, it applies to both buffers equally. + +If the +.B XClearArea() +or +.B XClearWindow() +function is executed on a +double-buffered window, the same area in both the front and back buffers +is cleared. +.RE + +The effect of passing a window to a function that accepts a drawable +is unchanged by this extension. The window and front buffer are synonomous +with each other. This includes obeying the +.B XGetImage() +and +.B XGetSubImage() +semantics and the subwindow-mode semantics if a graphics context is +involved. Regardless of whether the window was explicitly passed in an +.B XGetImage() +or +.B XGetSubImage() +call, or implicitly referenced (i.e., one of +the window's ancestors was passed in the function), the front (i.e. visible) +buffer is always referenced. +Thus, DBE-naive screen dump clients will always get the front buffer. +.B XGetImage() +and +.B XGetSubImage() +on a back +buffer return undefined image contents for any obscured regions of the back +buffer that fall within the image. + +Drawing to a back buffer always uses the clip region that would be used to +draw to the front buffer with a GC subwindow-mode of ClipByChildren. If an +ancestor of a double-buffered window is drawn to with a GC having a +subwindow-mode of IncludeInferiors, the effect on the double-buffered +window's back buffer depends on the depth of the double-buffered window +and the ancestor. If the depths are the same, the contents of the back buffer +of the double-buffered window are not changed. If the depths are different, +the contents of the back buffer of the double-buffered window are undefined +for the pixels that the IncludeInferiors drawing touched. + +DBE adds no new events. DBE does not extend the semantics of any existing +events with the exception of adding a new drawable type called +.I XdbeBackBuffer. + +If events, replies, or errors that contain a drawable +(e.g., GraphicsExpose) are generated in response to a request, the +drawable returned will be the one specified in the request. + +DBE advertises which visuals support double buffering. + +DBE does not include any timing or synchronization facilities. Applications +that need such facilities (e.g., to maintain a constant frame rate) should +investigate the Synchronization Extension, an X Consortium standard. +.RE + +.B Window Management Operations + +.RS +The basic philosophy of DBE is that both buffers are treated the same by +X window management operations. + +When a double-buffered window is destroyed, +both buffers associated with the window are destroyed, and all back buffer +names associated with the window are freed. + +If the size of a double-buffered window changes, both +buffers assume the new size. If the window's size increases, the effect on the +buffers depends on whether the implementation honors bit gravity for buffers. +If bit gravity is implemented, then the contents of both buffers are moved in +accordance with the window's bit gravity, +and the remaining areas are tiled with the window background. If +bit gravity is not implemented, then the entire unobscured region of both +buffers is tiled with the window background. In either case, Expose events are +generated for the region that is tiled with the window background. + +If the +.B XGetGeometry() +function is executed on an +.I XdbeBackBuffer, +the returned x, y, and border-width will be zero. + +If the Shape extension +.B ShapeRectangles, ShapeMask, ShapeCombine, +or +.B ShapeOffset +request is executed on a double-buffered window, both +buffers are reshaped to match the new window shape. The region difference +D = new shape - old shape is tiled with the window background in both +buffers, and Expose events are generated for D. +.RE + +.B Complex Swap Actions + +.RS +DBE has no explicit knowledge of ancillary buffers (e.g. depth buffers or +alpha buffers), and only has a limited set of defined swap actions. Some +applications may need a richer set of swap actions than DBE provides. Some +DBE implementations have knowledge of ancillary buffers, and/or can provide +a rich set of swap actions. Instead of continually extending DBE to increase +its set of swap actions, DBE provides a flexible "idiom" mechanism. If an +applications's needs are served by the defined swap actions, it should use +them; otherwise, it should use the following method of expressing a complex +swap action as an idiom. Following this policy will ensure the best possible +performance across a wide variety of implementations. + +As suggested by the term "idiom," a complex swap action should be expressed +as a group/series of requests. Taken together, this group of requests may be +combined into an atomic operation by the implementation, in order to +maximize performance. The set of idioms actually recognized for optimization +is implementation dependent. To help with idiom expression and +interpretation, an idiom must be surrounded by two function calls: +.B XdbeBeginIdiom() +and +.B XdbeEndIdiom(). +Unless this begin-end pair +surrounds the idiom, it may not be recognized by a given implementation, and +performance will suffer. + +For example, if an application wants to swap buffers for two windows, and use +X to clear only certain planes of the back buffers, the application would +make the following calls as a group, and in the following order: + +.RS +.B XdbeBeginIdiom(). + +.B XdbeSwapBuffers() +with XIDs for two windows, each of which uses a swap action of Untouched. + +.B XFillRectangle() +to the back buffer of one window. + +.B XFillRectangle() +to the back buffer of the other window. + +.B XdbeEndIdiom(). +.RE + +The +.B XdbeBeginIdiom() +and +.B XdbeEndIdiom() +functions do not perform any +actions themselves. They are treated as markers by implementations that can +combine certain groups/series of requests as idioms, and are ignored by other +implementations or for non-recognized groups/series of requests. If these +function calls are made out of order, or are mismatched, no errors are sent, +and the functions are executed as usual, though performance may suffer. + +.B XdbeSwapBuffers() +need not be included in an idiom. For +example, if a swap action of Copied is desired, but only some of the planes +should be copied, +.B XCopyArea() +may be used instead of +.B XdbeSwapBuffers(). +If +.B XdbeSwapBuffers() +is included in an idiom, it should immediately follow the +.B XdbeBeginIdiom() +call. Also, when the +.B XdbeSwapBuffers() +is included in an idiom, that request's swap action will +still be valid, and if the swap action might overlap with another request, then +the final result of the idiom must be as if the separate requests were executed +serially. For example, if the specified swap action is Untouched, and if a +.B XFillRectangle() +using a client clip rectangle is done to the window's back +buffer after the +.B XdbeSwapBuffers() +call, then the contents of the new +back buffer (after the idiom) will be the same as if the idiom was not +recognized by the implementation. + +It is highly recommended that API providers define, and application +developers use, "convenience" functions that allow client applications to call +one procedure that encapsulates common idioms. These functions will +generate the +.B XdbeBeginIdiom(), +idiom, and +.B XdbeEndIdiom() +calls. Usage of these functions will ensure best possible +performance across a wide variety of implementations. +.SH SEE ALSO +.I XdbeAllocateBackBufferName(), +.I XdbeBeginIdiom(), +.I XdbeDeallocateBackBufferName(), +.I XdbeEndIdiom(), +.I XdbeFreeVisualInfo(), +.I XdbeGetBackBufferAttributes(), +.I XdbeGetVisualInfo(), +.I XdbeQueryExtension(), +.I XdbeSwapBuffers(). + diff --git a/man/XShape.man b/man/XShape.man new file mode 100644 index 0000000..cd4df57 --- /dev/null +++ b/man/XShape.man @@ -0,0 +1,175 @@ +.\" $Xorg: XShape.man,v 1.4 2001/03/16 17:49:24 pookie Exp $ +.\" +.\" Copyright (c) 1989, 1994 X Consortium +.\" +.\" Permission is hereby granted, free of charge, to any person obtaining a +.\" copy of this software and associated documentation files (the "Software"), +.\" to deal in the Software without restriction, including without limitation +.\" the rights to use, copy, modify, merge, publish, distribute, sublicense, +.\" and/or sell copies of the Software, and to permit persons to whom the +.\" Software furnished to do so, subject to the following conditions: +.\" +.\" The above copyright notice and this permission notice shall be included in +.\" all copies or substantial portions of the Software. +.\" +.\" THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +.\" IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +.\" FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL +.\" THE X CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, +.\" WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF +.\" OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +.\" SOFTWARE. +.\" +.\" Except as contained in this notice, the name of the X Consortium shall not +.\" be used in advertising or otherwise to promote the sale, use or other +.\" dealing in this Software without prior written authorization from the +.\" X Consortium. +.de ZN +.ie t \fB\^\\$1\^\fR\\$2 +.el \fI\^\\$1\^\fP\\$2 +.. +.TH XSHAPE 3X11 "Release 6.6" "X Version 11" "X FUNCTIONS" +.SH NAME +XShapeQueryExtension, XShapeQueryVersion, XShapeCombineRegion, XShapeCombineRectangles, XShapeCombineMask, XShapeCombineShape, XShapeOffsetShape, XShapeQueryExtents, XShapeSelectInput, XShapeInputSelected, XShapeGetRectangles \- X nonrectangular shape functions +.SH SYNTAX +.nf +.LP +#include +.LP +Bool XShapeQueryExtension ( + Display *dpy, + int *event_basep, + int *error_basep); +.LP +Status XShapeQueryVersion ( + Display *dpy, + int *major_versionp, + int *minor_versionp); +.LP +void XShapeCombineRegion ( + Display *dpy, + Window dest, + int destKind, + int xOff, + int yOff, + struct _XRegion *r, + int op); +.LP +void XShapeCombineRectangles ( + Display *dpy, + XID dest, + int destKind, + int xOff, + int yOff, + XRectangle *rects, + int n_rects, + int op, + int ordering); +.LP +void XShapeCombineMask ( + Display *dpy, + XID dest, + int destKind, + int xOff, + int yOff, + Pixmap src, + int op); +.LP +void XShapeCombineShape ( + Display *dpy, + XID dest, + int destKind, + int xOff, + int yOff, + Pixmap src, + int srcKind, + int op); +.LP +void XShapeOffsetShape ( + Display *dpy, + XID dest, + int destKind, + int xOff, + int yOff); +.LP +Status XShapeQueryExtents ( + Display *dpy, + Window window, + int *bShaped, + int *xbs, + int *ybs, + unsigned int *wbs, + unsigned int *hbs, + int *cShaped, + int *xcs, + int *ycs, + unsigned int *wcs, + unsigned int *hcs); +.LP +void XShapeSelectInput ( + Display *dpy, + Window window, + unsigned longmask); +.LP +unsigned long XShapeInputSelected ( + Display *dpy, + Window window); +.LP +XRectangle *XShapeGetRectangles ( + Display *dpy, + Window window, + int kind, + int *count, + int *ordering); +.fi +.SH STRUCTURES +.nf +.LP +.ta 3i +typedef struct { + int type; /* of event */ + unsigned long serial; /* # of last request processed by server */ + Bool send_event; /* true if this came frome a SendEvent request */ + Display *display; /* Display the event was read from */ + Window window; /* window of event */ + int kind; /* ShapeBounding or ShapeClip */ + int x, y; /* extents of new region */ + unsigned width, height; + Time time; /* server timestamp when region changed */ + Bool shaped; /* true if the region exists */ +} XShapeEvent; +.fi +.SH DESCRIPTION +The \fIX11 Nonrectangular Window Shape Extension\fP adds nonrectangular +windows to the X Window System. +.SH PREDEFINED VALUES +Operations: +.in +.5i +.nf +.ZN ShapeSet +.ZN ShapeUnion +.ZN ShapeIntersect +.ZN ShapeSubtract +.ZN ShapeInvert +.in -.5i +.fi +.sp +Shape Kinds: +.in +.5i +.nf +.ZN ShapeBounding +.ZN ShapeClip +.in -.5i +.fi +.sp +Event defines: +.in +.5i +.nf +.ZN ShapeNotifyMask +.ZN ShapeNotify +.in -.5i +.fi +.SH BUGS +This manual pages needs a lot more work. +.SH SEE ALSO +\fIX11 Nonrectangular Window Shape Extension\fP diff --git a/man/XdbeAllocateBackBufferName.man b/man/XdbeAllocateBackBufferName.man new file mode 100644 index 0000000..b1bcadf --- /dev/null +++ b/man/XdbeAllocateBackBufferName.man @@ -0,0 +1,68 @@ +.\" $Xorg: XdbeAllo.man,v 1.4 2001/03/16 17:49:55 pookie Exp $ +.\" +.\" Copyright (c) 1995 Hewlett-Packard Company +.\" +.\" Permission is hereby granted, free of charge, to any person obtaining a +.\" copy of this software and associated documentation files (the "Software"), +.\" to deal in the Software without restriction, including without limitation +.\" the rights to use, copy, modify, merge, publish, distribute, sublicense, +.\" and/or sell copies of the Software, and to permit persons to whom the +.\" Software furnished to do so, subject to the following conditions: +.\" +.\" The above copyright notice and this permission notice shall be included in +.\" all copies or substantial portions of the Software. +.\" +.\" THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +.\" IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +.\" FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL +.\" HEWLETT-PACKARD COMPANY BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, +.\" WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF +.\" OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +.\" SOFTWARE. +.\" +.\" Except as contained in this notice, the name of the Hewlett-Packard Company shall not +.\" be used in advertising or otherwise to promote the sale, use or other +.\" dealing in this Software without prior written authorization from the +.\" Hewlett-Packard Company. +.TH XdbeAllocateBackBufferName 3X11 "Release 6.6" "X Version 11" "X FUNCTIONS" +.SH NAME +XdbeAllocateBackBufferName - allocates a DBE buffer. +.SH SYNOPSIS +#include + +XdbeBackBuffer XdbeAllocateBackBufferName( + Display *dpy, + Window window, + XdbeSwapAction swap_action) +.SH DESCRIPTION +This function returns a drawable ID used to refer to the back buffer of the +specified window. The swap_action is a hint to indicate the swap action that +will likely be used in subsequent calls to +.B XdbeSwapBuffers(). +The actual swap +action used in calls to +.B XdbeSwapBuffers() +does not have to be the same as the +swap_action passed to this function, though clients are encouraged to provide +accurate information whenever possible. +.SH ERRORS +.IP BadAlloc +.IP BadIDChoice +.IP BadMatch +The specified window is not an InputOutput window or its visual does not +support DBE. +.IP BadValue +An invalid swap action was specified. +.IP BadWindow +An invalid window was specified. +.SH SEE ALSO +DBE, +.I XdbeBeginIdiom(), +.I XdbeDeallocateBackBufferName(), +.I XdbeEndIdiom(), +.I XdbeFreeVisualInfo(), +.I XdbeGetBackBufferAttributes(), +.I XdbeGetVisualInfo(), +.I XdbeQueryExtension(), +.I XdbeSwapBuffers(). + diff --git a/man/XdbeBeginIdiom.man b/man/XdbeBeginIdiom.man new file mode 100644 index 0000000..686147a --- /dev/null +++ b/man/XdbeBeginIdiom.man @@ -0,0 +1,47 @@ +.\" $Xorg: XdbeBegi.man,v 1.4 2001/03/16 17:49:55 pookie Exp $ +.\" +.\" Copyright (c) 1995 Hewlett-Packard Company +.\" +.\" Permission is hereby granted, free of charge, to any person obtaining a +.\" copy of this software and associated documentation files (the "Software"), +.\" to deal in the Software without restriction, including without limitation +.\" the rights to use, copy, modify, merge, publish, distribute, sublicense, +.\" and/or sell copies of the Software, and to permit persons to whom the +.\" Software furnished to do so, subject to the following conditions: +.\" +.\" The above copyright notice and this permission notice shall be included in +.\" all copies or substantial portions of the Software. +.\" +.\" THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +.\" IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +.\" FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL +.\" HEWLETT-PACKARD COMPANY BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, +.\" WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF +.\" OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +.\" SOFTWARE. +.\" +.\" Except as contained in this notice, the name of the Hewlett-Packard Company shall not +.\" be used in advertising or otherwise to promote the sale, use or other +.\" dealing in this Software without prior written authorization from the +.\" Hewlett-Packard Company. +.TH DBE 3X11 "Release 6.6" "X Version 11" "X FUNCTIONS" +.SH NAME +XdbeBeginIdiom - marks the beginning of a DBE idiom sequence. +.SH SYNOPSIS +#include + +Status XdbeBeginIdiom( + Display *dpy) +.SH DESCRIPTION +This function marks the beginning of an idiom sequence. +.SH SEE ALSO +DBE, +.I XdbeAllocateBackBufferName(), +.I XdbeDeallocateBackBufferName(), +.I XdbeEndIdiom(), +.I XdbeFreeVisualInfo(), +.I XdbeGetBackBufferAttributes(), +.I XdbeGetVisualInfo(), +.I XdbeQueryExtension(), +.I XdbeSwapBuffers(). + diff --git a/man/XdbeDeallocateBackBufferName.man b/man/XdbeDeallocateBackBufferName.man new file mode 100644 index 0000000..df58dd2 --- /dev/null +++ b/man/XdbeDeallocateBackBufferName.man @@ -0,0 +1,54 @@ +.\" $Xorg: XdbeDeal.man,v 1.4 2001/03/16 17:49:55 pookie Exp $ +.\" +.\" Copyright (c) 1995 Hewlett-Packard Company +.\" +.\" Permission is hereby granted, free of charge, to any person obtaining a +.\" copy of this software and associated documentation files (the "Software"), +.\" to deal in the Software without restriction, including without limitation +.\" the rights to use, copy, modify, merge, publish, distribute, sublicense, +.\" and/or sell copies of the Software, and to permit persons to whom the +.\" Software furnished to do so, subject to the following conditions: +.\" +.\" The above copyright notice and this permission notice shall be included in +.\" all copies or substantial portions of the Software. +.\" +.\" THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +.\" IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +.\" FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL +.\" HEWLETT-PACKARD COMPANY BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, +.\" WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF +.\" OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +.\" SOFTWARE. +.\" +.\" Except as contained in this notice, the name of the Hewlett-Packard Company shall not +.\" be used in advertising or otherwise to promote the sale, use or other +.\" dealing in this Software without prior written authorization from the +.\" Hewlett-Packard Company. +.TH XdbeDeallocateBackBufferName 3X11 "Release 6.6" "X Version 11" "X FUNCTIONS" +.SH NAME +XdbeDeallocateBackBufferName - frees a DBE buffer. +.SH SYNOPSIS +#include + +Status XdbeDeallocateBackBufferName( + Display *dpy, + XdbeBackBuffer buffer) +.SH DESCRIPTION +This function frees a drawable ID, buffer, that was obtained via +.B XdbeAllocateBackBufferName(). +The buffer must be a valid name for the back +buffer of a window, or a protocol error results. +.SH ERRORS +.IP BadBuffer +The specified buffer is not associated with a window. +.SH SEE ALSO +DBE, +.I XdbeAllocateBackBufferName(), +.I XdbeBeginIdiom(), +.I XdbeEndIdiom(), +.I XdbeFreeVisualInfo(), +.I XdbeGetBackBufferAttributes(), +.I XdbeGetVisualInfo(), +.I XdbeQueryExtension(), +.I XdbeSwapBuffers(). + diff --git a/man/XdbeEndIdiom.man b/man/XdbeEndIdiom.man new file mode 100644 index 0000000..ffacb50 --- /dev/null +++ b/man/XdbeEndIdiom.man @@ -0,0 +1,47 @@ +.\" $Xorg: XdbeEndI.man,v 1.4 2001/03/16 17:49:55 pookie Exp $ +.\" +.\" Copyright (c) 1995 Hewlett-Packard Company +.\" +.\" Permission is hereby granted, free of charge, to any person obtaining a +.\" copy of this software and associated documentation files (the "Software"), +.\" to deal in the Software without restriction, including without limitation +.\" the rights to use, copy, modify, merge, publish, distribute, sublicense, +.\" and/or sell copies of the Software, and to permit persons to whom the +.\" Software furnished to do so, subject to the following conditions: +.\" +.\" The above copyright notice and this permission notice shall be included in +.\" all copies or substantial portions of the Software. +.\" +.\" THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +.\" IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +.\" FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL +.\" HEWLETT-PACKARD COMPANY BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, +.\" WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF +.\" OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +.\" SOFTWARE. +.\" +.\" Except as contained in this notice, the name of the Hewlett-Packard Company shall not +.\" be used in advertising or otherwise to promote the sale, use or other +.\" dealing in this Software without prior written authorization from the +.\" Hewlett-Packard Company. +.TH XdbeEndIdiom 3X11 "Release 6.6" "X Version 11" "X FUNCTIONS" +.SH NAME +XdbeEndIdiom - marks the end of a DBE idiom sequence. +.SH SYNOPSIS +#include + +Status XdbeEndIdiom( + Display *dpy) +.SH DESCRIPTION +This function marks the end of an idiom sequence. +.SH SEE ALSO +DBE, +.I XdbeAllocateBackBufferName(), +.I XdbeBeginIdiom(), +.I XdbeDeallocateBackBufferName(), +.I XdbeFreeVisualInfo(), +.I XdbeGetBackBufferAttributes(), +.I XdbeGetVisualInfo(), +.I XdbeQueryExtension(), +.I XdbeSwapBuffers(). + diff --git a/man/XdbeFreeVisualInfo.man b/man/XdbeFreeVisualInfo.man new file mode 100644 index 0000000..2792067 --- /dev/null +++ b/man/XdbeFreeVisualInfo.man @@ -0,0 +1,49 @@ +.\" $Xorg: XdbeFree.man,v 1.4 2001/03/16 17:49:55 pookie Exp $ +.\" +.\" Copyright (c) 1995 Hewlett-Packard Company +.\" +.\" Permission is hereby granted, free of charge, to any person obtaining a +.\" copy of this software and associated documentation files (the "Software"), +.\" to deal in the Software without restriction, including without limitation +.\" the rights to use, copy, modify, merge, publish, distribute, sublicense, +.\" and/or sell copies of the Software, and to permit persons to whom the +.\" Software furnished to do so, subject to the following conditions: +.\" +.\" The above copyright notice and this permission notice shall be included in +.\" all copies or substantial portions of the Software. +.\" +.\" THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +.\" IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +.\" FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL +.\" HEWLETT-PACKARD COMPANY BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, +.\" WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF +.\" OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +.\" SOFTWARE. +.\" +.\" Except as contained in this notice, the name of the Hewlett-Packard Company shall not +.\" be used in advertising or otherwise to promote the sale, use or other +.\" dealing in this Software without prior written authorization from the +.\" Hewlett-Packard Company. +.TH XdbeFreeVisualInfo 3X11 "Release 6.6" "X Version 11" "X FUNCTIONS" +.SH NAME +XdbeFreeVisualInfo - frees information returned by +.B XdbeGetVisualInfo(). +.SH SYNOPSIS +#include + +void XdbeFreeVisualInfo( + XdbeScreenVisualInfo *visual_info) +.SH DESCRIPTION +This function frees the list of XdbeScreenVisualInfo returned by the function +.B XdbeGetVisualInfo(). +.SH SEE ALSO +DBE, +.I XdbeAllocateBackBufferName(), +.I XdbeBeginIdiom(), +.I XdbeDeallocateBackBufferName(), +.I XdbeEndIdiom(), +.I XdbeGetBackBufferAttributes(), +.I XdbeGetVisualInfo(), +.I XdbeQueryExtension(), +.I XdbeSwapBuffers(). + diff --git a/man/XdbeGetBackBufferAttributes.man b/man/XdbeGetBackBufferAttributes.man new file mode 100644 index 0000000..c1b1856 --- /dev/null +++ b/man/XdbeGetBackBufferAttributes.man @@ -0,0 +1,66 @@ +.\" $Xorg: XdbeGetB.man,v 1.4 2001/03/16 17:49:55 pookie Exp $ +.\" +.\" Copyright (c) 1995 Hewlett-Packard Company +.\" +.\" Permission is hereby granted, free of charge, to any person obtaining a +.\" copy of this software and associated documentation files (the "Software"), +.\" to deal in the Software without restriction, including without limitation +.\" the rights to use, copy, modify, merge, publish, distribute, sublicense, +.\" and/or sell copies of the Software, and to permit persons to whom the +.\" Software furnished to do so, subject to the following conditions: +.\" +.\" The above copyright notice and this permission notice shall be included in +.\" all copies or substantial portions of the Software. +.\" +.\" THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +.\" IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +.\" FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL +.\" HEWLETT-PACKARD COMPANY BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, +.\" WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF +.\" OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +.\" SOFTWARE. +.\" +.\" Except as contained in this notice, the name of the Hewlett-Packard Company shall not +.\" be used in advertising or otherwise to promote the sale, use or other +.\" dealing in this Software without prior written authorization from the +.\" Hewlett-Packard Company. +.TH XdbeGetBackBufferAttributes 3X11 "Release 6.6" "X Version 11" "X FUNCTIONS" +.SH NAME +XdbeGetBackBufferAttributes - returns attributes of a DBE buffer. +.SH SYNOPSIS +#include + +XdbeBackBufferAttributes *XdbeGetBackBufferAttributes( + Display *dpy, + XdbeBackBuffer buffer) +.SH DESCRIPTION +This function returns the attributes associated with the specified buffer. + +The +.I XdbeBackBufferAttributes +structure has the following fields: + +.RS +Window window window that buffer belongs to +.RE + +If buffer is not a valid +.I XdbeBackBuffer, +window returns None. + +The returned +.I XdbeBackBufferAttributes +structure can be freed with the +Xlib function +.B Xfree(). +.SH SEE ALSO +DBE, +.I XdbeAllocateBackBufferName(), +.I XdbeBeginIdiom(), +.I XdbeDeallocateBackBufferName(), +.I XdbeEndIdiom(), +.I XdbeFreeVisualInfo(), +.I XdbeGetVisualInfo(), +.I XdbeQueryExtension(), +.I XdbeSwapBuffers(). + diff --git a/man/XdbeGetVisualInfo.man b/man/XdbeGetVisualInfo.man new file mode 100644 index 0000000..31204c5 --- /dev/null +++ b/man/XdbeGetVisualInfo.man @@ -0,0 +1,126 @@ +.\" $Xorg: XdbeGetV.man,v 1.4 2001/03/16 17:49:55 pookie Exp $ +.\" +.\" Copyright (c) 1995 Hewlett-Packard Company +.\" +.\" Permission is hereby granted, free of charge, to any person obtaining a +.\" copy of this software and associated documentation files (the "Software"), +.\" to deal in the Software without restriction, including without limitation +.\" the rights to use, copy, modify, merge, publish, distribute, sublicense, +.\" and/or sell copies of the Software, and to permit persons to whom the +.\" Software furnished to do so, subject to the following conditions: +.\" +.\" The above copyright notice and this permission notice shall be included in +.\" all copies or substantial portions of the Software. +.\" +.\" THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +.\" IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +.\" FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL +.\" HEWLETT-PACKARD COMPANY BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, +.\" WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF +.\" OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +.\" SOFTWARE. +.\" +.\" Except as contained in this notice, the name of the Hewlett-Packard Company shall not +.\" be used in advertising or otherwise to promote the sale, use or other +.\" dealing in this Software without prior written authorization from the +.\" Hewlett-Packard Company. +.TH XdbeGetVisualInfo 3X11 "Release 6.6" "X Version 11" "X FUNCTIONS" +.SH NAME +XdbeGetVisualInfo +.SH SYNOPSIS +#include + +XdbeScreenVisualInfo *XdbeGetVisualInfo( + Display *dpy, + Drawable *screen_specifiers, + int *num_screens) +.SH DESCRIPTION +This function returns information about which visuals support double +buffering. The argument +.I num_screens +specifies how many elements there are +in the +.I screen_specifiers +list. Each drawable in +.I screen_specifiers +designates a +screen for which the supported visuals are being requested. If +.I num_screens +is zero, information for all screens is requested. In this case, upon return +from this function, +.I num_screens +will be set to the number of screens that were +found. If an error occurs, this function returns NULL, else it returns a +pointer to a list of +.I XdbeScreenVisualInfo +structures of length +.I num_screens. +The nth +element in the returned list corresponds to the nth drawable in the +.I screen_specifiers +list, unless +.I num_screens +was passed in with the value zero, +in which case the nth element in the returned list corresponds to the nth screen +of the server, starting with screen zero. The +.I XdbeScreenVisualInfo +structure has the following fields: + + int count + XdbeVisualInfo *visinfo + +.I count +specifies the number of items in +.I visinfo. +.I visinfo +specifies a list of visuals, depths, and performance hints for this screen. + +The +.I XdbeVisualInfo +structure has the following fields: + + VisualID visual + int depth + int perflevel + +.I visual +specifies one visual ID that supports double-buffering. +.I depth +specifies the depth of the visual. +.I perflevel +is a performance hint. + +The only operation defined on a +.I perflevel +is comparison to a +.I perflevel +of another visual on the same screen. The visual having the higher +.I perflevel +is likely to have better double-buffering graphics performance than the visual +having the lower +.I perflevel. +Nothing can be deduced from the following: the magnitude of the difference +of two +.I perflevels, +a +.I perflevel +value in isolation, or comparing +.I perflevels +from different servers. + +.SH ERRORS +.IP BadDrawable +One or more values passed in +.I screen_specifiers +is not a valid drawable. +.SH SEE ALSO +DBE, +.I XdbeAllocateBackBufferName(), +.I XdbeBeginIdiom(), +.I XdbeDeallocateBackBufferName(), +.I XdbeEndIdiom(), +.I XdbeFreeVisualInfo(), +.I XdbeGetBackBufferAttributes(), +.I XdbeQueryExtension(), +.I XdbeSwapBuffers(). + diff --git a/man/XdbeQueryExtension.man b/man/XdbeQueryExtension.man new file mode 100644 index 0000000..3bae215 --- /dev/null +++ b/man/XdbeQueryExtension.man @@ -0,0 +1,62 @@ +.\" $Xorg: XdbeQuer.man,v 1.4 2001/03/16 17:49:55 pookie Exp $ +.\" +.\" Copyright (c) 1995 Hewlett-Packard Company +.\" +.\" Permission is hereby granted, free of charge, to any person obtaining a +.\" copy of this software and associated documentation files (the "Software"), +.\" to deal in the Software without restriction, including without limitation +.\" the rights to use, copy, modify, merge, publish, distribute, sublicense, +.\" and/or sell copies of the Software, and to permit persons to whom the +.\" Software furnished to do so, subject to the following conditions: +.\" +.\" The above copyright notice and this permission notice shall be included in +.\" all copies or substantial portions of the Software. +.\" +.\" THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +.\" IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +.\" FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL +.\" HEWLETT-PACKARD COMPANY BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, +.\" WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF +.\" OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +.\" SOFTWARE. +.\" +.\" Except as contained in this notice, the name of the Hewlett-Packard Company shall not +.\" be used in advertising or otherwise to promote the sale, use or other +.\" dealing in this Software without prior written authorization from the +.\" Hewlett-Packard Company. +.TH XdbeQueryExtension 3X11 "Release 6.6" "X Version 11" "X FUNCTIONS" +.SH NAME +XdbeQueryExtension - returns the version of DBE supported by the server. +.SH SYNOPSIS +#include + +Status XdbeQueryExtension( + Display *dpy, + int *major_version_return, + int *minor_version_return) +.SH DESCRIPTION +Sets +.I major_version_return +and +.I minor_version_return +to the major and minor +DBE protocol version supported by the server. If the DBE library is +compatible with the version returned by the server, this function returns +non-zero. If +.I dpy +does not support the DBE extension, or if there was an error +during communication with the server, or if the server and library protocol +versions are incompatible, this function returns zero. No other Xdbe functions +may be called before this function. If a client violates this rule, the +effects of all subsequent Xdbe calls that it makes are undefined. +.SH SEE ALSO +DBE, +.I XdbeAllocateBackBufferName(), +.I XdbeBeginIdiom(), +.I XdbeDeallocateBackBufferName(), +.I XdbeEndIdiom(), +.I XdbeFreeVisualInfo(), +.I XdbeGetBackBufferAttributes(), +.I XdbeGetVisualInfo(), +.I XdbeSwapBuffers(). + diff --git a/man/XdbeSwapBuffers.man b/man/XdbeSwapBuffers.man new file mode 100644 index 0000000..782afba --- /dev/null +++ b/man/XdbeSwapBuffers.man @@ -0,0 +1,97 @@ +.\" $Xorg: XdbeSwap.man,v 1.4 2001/03/16 17:49:55 pookie Exp $ +.\" +.\" Copyright (c) 1995 Hewlett-Packard Company +.\" +.\" Permission is hereby granted, free of charge, to any person obtaining a +.\" copy of this software and associated documentation files (the "Software"), +.\" to deal in the Software without restriction, including without limitation +.\" the rights to use, copy, modify, merge, publish, distribute, sublicense, +.\" and/or sell copies of the Software, and to permit persons to whom the +.\" Software furnished to do so, subject to the following conditions: +.\" +.\" The above copyright notice and this permission notice shall be included in +.\" all copies or substantial portions of the Software. +.\" +.\" THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +.\" IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +.\" FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL +.\" HEWLETT-PACKARD COMPANY BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, +.\" WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF +.\" OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +.\" SOFTWARE. +.\" +.\" Except as contained in this notice, the name of the Hewlett-Packard Company shall not +.\" be used in advertising or otherwise to promote the sale, use or other +.\" dealing in this Software without prior written authorization from the +.\" Hewlett-Packard Company. +.TH XdbeSwapBuffers 3X11 "Release 6.6" "X Version 11" "X FUNCTIONS" +.SH NAME +XdbeSwapBuffers - swaps front and back DBE buffers. +.SH SYNOPSIS +#include + +Status XdbeSwapBuffers( + Display *dpy, + XdbeSwapInfo *swap_info, + int num_windows) +.SH DESCRIPTION +This function swaps the front and back buffers for a list of windows. The +argument +.I num_windows +specifies how many windows are to have their buffers +swapped; it is the number of elements in the +.I swap_info +array. The argument +.I swap_info +specifies the information needed per window to do the swap. + +The +.I XdbeSwapInfo +structure has the following fields: + + Window swap_window + XdbeSwapAction swap_action + +.I swap_window +specifies the window for which to swap buffers. +.I swap_action +specifies the swap action to use for this +.I swap_window. + +.I swap_action +determines what will happen to the new back buffer of the +.I swap_window +it is paired with in the list in addition to making the old back buffer +become visible. The defined actions are as follows: + +.IP XdbeUndefined +The contents of the new back buffer become undefined. This may be the most +efficient action since it allows the implementation to discard the contents of +the buffer if it needs to. +.IP XdbeBackground +The unobscured region of the new back buffer will be tiled with the +window background. The background action allows devices to use a fast clear +capability during a swap. +.IP XdbeUntouched +The unobscured region of the new back buffer will be unmodified by the swap. +.IP XdbeCopied +The unobscured region of the new back buffer will be the contents of the old +back buffer +.SH ERRORS +.IP BadMatch +A non-double-buffered window was specififed or a window was specified twice. +.IP BadWindow +An invalid window was specified. +.IP BadValue +An invalid swap action was specified. +.SH SEE ALSO +DBE, +.I XdbeAllocateBackBufferName(), +.I XdbeBeginIdiom(), +.I XdbeDeallocateBackBufferName(), +.I XdbeEndIdiom(), +.I XdbeFreeVisualInfo(), +.I XdbeGetBackBufferAttributes(), +.I XdbeGetVisualInfo(), +.I XdbeQueryExtension(). + diff --git a/man/Xevi.man b/man/Xevi.man new file mode 100644 index 0000000..4cdd16e --- /dev/null +++ b/man/Xevi.man @@ -0,0 +1,162 @@ +.\" $Xorg: Xevi.man,v 1.4 2001/03/16 17:49:24 pookie Exp $ +.\" +.\" Copyright (c) 1997 Silicon Graphics, Inc. +.\" +.\" Permission is hereby granted, free of charge, to any person obtaining a +.\" copy of this software and associated documentation files (the "Software"), +.\" to deal in the Software without restriction, including without limitation +.\" the rights to use, copy, modify, merge, publish, distribute, sublicense, +.\" and/or sell copies of the Software, and to permit persons to whom the +.\" Software furnished to do so, subject to the following conditions: +.\" +.\" The above copyright notice and this permission notice shall be included in +.\" all copies or substantial portions of the Software. +.\" +.\" THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +.\" IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +.\" FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL +.\" SILICON GRAPHICS, INC. BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, +.\" WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF +.\" OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +.\" SOFTWARE. +.\" +.\" Except as contained in this notice, the name of Silicon Graphics, Inc. shall not +.\" be used in advertising or otherwise to promote the sale, use or other +.\" dealing in this Software without prior written authorization from +.\" Silicon Graphics, Inc. +.TH XEVI 3X11 "Release 6.6" "X Version 11" "X FUNCTIONS" +.SH NAME +XeviQueryExtension, XeviQueryVersion, XeviGetVisualInfo - X Extended Visual Information functions +.SH SYNOPSIS +#include + +Bool +XeviQueryExtension (Display *dpy); +.LP +Bool +XeviQueryVersion (Display *dpy, + int *major_version_return, + int *minor_version_return); +.LP +int +XeviGetVisualInfo (Display *dpy, VisualID *visual, + int n_visual, ExtendedVisualInfo ** evi_return, + int * n_info_return); +.fi +.SH DESCRIPTION +The +X11 Extended Visual Information extension (EVI) allows a client to determine +information about core X visuals beyond what the core protocol provides. + +The EVI application programming library contains the interfaces described below. +With the exception of +.BR XeviQueryExtension, +if any of these routines are +called with a display that does not support the extension, the +ExtensionErrorHandler (which can be set with +.BR XSetExtensionErrorHandler +and functions the same way as +.BR XSetErrorHandler ) +will be called and the function will then return. +.PP +.BR XeviQueryExtension +returns +.BR True +if the Extended Visual Information extension is available on the given display. +A client must call +.BR XeviQueryExtension +before calling any other EVI +function in order to negotiate a compatible protocol version; otherwise +the client will get undefined behavior (EVI may or may not work). +.PP +.BR XeviQueryVersion +returns +.BR True +if the request succeeded; the values of the major and minor protocol +version supported by the server are returned in +.I major_version_return +and +.I minor_version_return. +.PP +.BR XeviGetVisualInfo +returns a list of ExtendedVisualInfo structures that describe +visual information beyond that supported by the core protocol. This includes +layer information relevant for systems supporting overlays and/or underlay +planes, and information that allows applications better to determine the level +of hardware support for multiple colormaps. XeviGetVisualInfo returns +.BR Success +if successful, or an X error otherwise. +If the argument +.I visual +is NULL, then information for all visuals of all +screens is returned. Otherwise, it's a pointer to a list of visuals for which +extended visual information is desired. +.I n_visual +is the number of elements in the array visual. +.I evi_return +returns a pointer to a list of ExtendedVisualInfo. When done, the client +should free the list using XFree\. +.I n_info_return +returns the number of elements in the array evi_return. +.LP +The +.BR ExtendedVisualInfo +structure has the following fields: +.in +.5i +.nf +.ta 1.6i +VisualID \fIcore_visual_id\fR +int \fIscreen\fR +int \fIlevel\fR +unsigned int \fItransparency_type\fR +unsigned int \fItransparency_value\fR +unsigned int \fImin_hw_colormaps\fR +unsigned int \fImax_hw_colormaps\fR +unsigned int \fInum_colormap_conflicts\fR +VisualID * \fIcolormap_conflicts\fR +.fi +.LP +The combination of +.I core_visual_id +and +.I screen +number uniquely specify the visual being described. +.LP +.I level +returns the level number for the visual, 0 for normal planes, > 0 for +overlays, < 0 for underlays. +.LP +.I +transparency_type +returns the type of transparency supported by the visual. XEVI_TRANSPARENCY_NONE if +there are no transparent pixels, XEVI_TRANSPARENCY_PIXEL if the visual supports +a transparent pixel, XEVI_TRANSPARENCY_MASK if the visual supports transparent +plane(s). +.LP +.I transparency_value +returns the pixel/plane value to set for transparency if transparency_type isn't +XEVI_TRANSPARENCY_NONE. +.LP +.I min_hw_colormaps +and +.I max_hw_colormaps +return the minimum and maximum number of hardware colormaps backing up the +visual. +.LP +.I num_colormap_conflicts +returns the number of elements in +.I colormap_conflicts. +This array returns a list of visuals that may cause conflicts in the use of the +hardware colormap. For example, if a 12-bit hardware colormap is overloaded to +support 8-bit colormaps, the corresponding 8-bit visuals would conflict with the +12-bit visuals. + +.SH ERRORS +.BR XeviGetVisualInfo +will return +.I BadValue +if passed an illegal visual ID, +.I BadAccess +if the X server does not respond, +.I BadAlloc +if there is a memory allocation failure. diff --git a/man/Xmbuf.man b/man/Xmbuf.man new file mode 100644 index 0000000..842c26f --- /dev/null +++ b/man/Xmbuf.man @@ -0,0 +1,344 @@ +.\" $Xorg: Xmbuf.man,v 1.4 2001/03/16 17:49:24 pookie Exp $ +.\" Copyright (c) 1989, 1994 X Consortium +.\" +.\" Permission is hereby granted, free of charge, to any person obtaining a +.\" copy of this software and associated documentation files (the "Software"), +.\" to deal in the Software without restriction, including without limitation +.\" the rights to use, copy, modify, merge, publish, distribute, sublicense, +.\" and/or sell copies of the Software, and to permit persons to whom the +.\" Software furnished to do so, subject to the following conditions: +.\" +.\" The above copyright notice and this permission notice shall be included in +.\" all copies or substantial portions of the Software. +.\" +.\" THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +.\" IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +.\" FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL +.\" THE X CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, +.\" WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF +.\" OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +.\" SOFTWARE. +.\" +.\" Except as contained in this notice, the name of the X Consortium shall not +.\" be used in advertising or otherwise to promote the sale, use or other +.\" dealing in this Software without prior written authorization from the +.\" X Consortium. +.\" +.\" Copyright 1989, Digital Equipment Corporation. +.\" Permission to use, copy, modify, distribute, and sell this documentation +.\" for any purpose and without fee is hereby granted, provided that the above +.\" copyright notice and this permission notice appear in all copies. +.\" Digital Equipment Corporation makes no representations +.\" about the suitability for any purpose of the information in +.\" this document. This documentation is provided "as is" +.\" without express or implied warranty. +.\" +.de ZN +.ie t \fB\^\\$1\^\fR\\$2 +.el \fI\^\\$1\^\fP\\$2 +.. +.TH XMBUF 3X11 "Release 6.6" "X Version 11" "X FUNCTIONS" +.SH NAME +XmbufQueryExtension, XmbufGetVersion, XmbufCreateBuffers, XmbufDestroyBuffers, XmbufDisplayBuffers, XmbufGetWindowAttributes, XmbufChangeWindowAttributes, XmbufGetBufferAttributes, XmbufChangeBufferAttributes, XmbufGetScreenInfo, XmbufCreateStereoWindow - X multibuffering functions +.SH SYNTAX +.nf +.LP +#include +.LP +Bool XmbufQueryExtension( + Display *dpy, + Display *dpy, + int *event_base_return, + int *error_base_return); +.LP +Status XmbufGetVersion( + Display *dpy, + int *major_version_return, + int *minor_version_return); +.LP +int XmbufCreateBuffers( + Display *dpy, + Window window, + int count, + int update_action, + int update_hint, + Multibuffer *buffers_update); +.LP +void XmbufDestroyBuffers( + Display *dpy, + Window window); +.LP +void XmbufDisplayBuffers( + Display *dpy, + int count, + Multibuffer *buffers, + int min_delay, + int max_delay); +.LP +Status XmbufGetWindowAttributes( + Display *dpy, + Window window, + XmbufWindowAttributes *attributes); +.LP +void XmbufChangeWindowAttributes( + Display *dpy, + Window window, + unsigned long valuemask, + XmbufSetWindowAttributes *attributes); +.LP +Status XmbufGetBufferAttributes( + Display *dpy, + Multibuffer buffer, + XmbufBufferAttributes *attributes); +.LP +void XmbufChangeBufferAttributes( + Display *dpy, + Multibuffer buffer, + unsigned long valuemask, + XmbufSetBufferAttributes *attributes); +.LP +Status XmbufGetScreenInfo( + Display *dpy, + Drawable drawable, + int *nmono_return, + XmbufBufferInfo **mono_info_return, + int *nstereo_return, + XmbufBufferInfo **stereo_info_return); +.LP +Window XmbufCreateStereoWindow( + Display *dpy, + Window parent, + int x, + int y, + unsigned int width, + unsigned int height, + unsigned int border_width, + int depth, + unsigned int class, /* InputOutput, InputOnly*/ + Visual *visual, + unsigned long valuemask, + XSetWindowAttributes *attributes, + Multibuffer *left_return, + Multibuffer *right_return); +.fi +.SH STRUCTURES +.nf +.ta 3i +\fIEvents:\fP +typedef struct { + int type; /* of event */ + unsigned long serial; /* # of last request processed by server */ + int send_event; /* true if this came frome a SendEvent request */ + Display *display; /* Display the event was read from */ + Multibuffer buffer; /* buffer of event */ + int state; /* see Clobbered constants above */ +} XmbufClobberNotifyEvent; +.LP +typedef struct { + int type; /* of event */ + unsigned long serial; /* # of last request processed by server */ + int send_event; /* true if this came frome a SendEvent request */ + Display *display; /* Display the event was read from */ + Multibuffer buffer; /* buffer of event */ +} XmbufUpdateNotifyEvent; +.LP +\fIPer-window attributes that can be got:\fP +typedef struct { + int displayed_index; /* which buffer is being displayed */ + int update_action; /* Undefined, Background, Untouched, Copied */ + int update_hint; /* Frequent, Intermittent, Static */ + int window_mode; /* Mono, Stereo */ + int nbuffers; /* Number of buffers */ + Multibuffer *buffers; /* Buffers */ +} XmbufWindowAttributes; +.LP +\fIPer-window attributes that can be set:\fP +typedef struct { + int update_hint; /* Frequent, Intermittent, Static */ +} XmbufSetWindowAttributes; +.LP +\fIPer-buffer attributes that can be got:\fP +typedef struct { + Window window; /* which window this belongs to */ + unsigned long event_mask; /* events that have been selected */ + int buffer_index; /* which buffer is this */ + int side; /* Mono, Left, Right */ +} XmbufBufferAttributes; +.LP +\fIPer-buffer attributes that can be set:\fP +typedef struct { + unsigned long event_mask; /* events that have been selected */ +} XmbufSetBufferAttributes; +.LP +\fIPer-screen buffer info (there will be lists of them):\fP +typedef struct { + VisualID visualid; /* visual usuable at this depth */ + int max_buffers; /* most buffers for this visual */ + int depth; /* depth of buffers to be created */ +} XmbufBufferInfo; +.fi +.SH DESCRIPTION +The application programming library for the +\fIX11 Double-Buffering, Multi-Buffering, and Stereo Extension\fP +contains the interfaces described below. +With the exception of +.ZN XmbufQueryExtension , +if any of these routines are +called with a display that does not support the extension, the +ExtensionErrorHandler (which can be set with +.ZN XSetExtensionErrorHandler +and functions the same way as +.ZN XSetErrorHandler ) +will be called and the function will then return. +.PP +.ZN XmbufQueryExtension +returns +.ZN True +if the multibuffering/stereo +extension is available on the +given display. If the extension exists, the value of the first event +code (which should be added to the event type constants +.ZN MultibufferClobberNotify +and +.ZN MultibufferUpdateNotify +to get the actual +values) is stored into event_base_return and the value of the first +error code (which should be added to the error type constant +.ZN MultibufferBadBuffer +to get the actual value) is stored into error_base_return. +.PP +.ZN XmbufGetVersion +gets the major and minor version numbers of the extension. +The return +value is zero if an error occurs or non-zero if no error happens. +.PP +.ZN XmbufCreateBuffers +requests that "count" buffers be +created with the given update_action +and update_hint and be associated with the indicated window. The +number of buffers created is returned (zero if an error occurred) +and buffers_update is filled in with that many Multibuffer identifiers. +.PP +.ZN XmbufDestroyBuffers +destroys the buffers associated +with the given window. +.PP +.ZN XmbufDisplayBuffers +displays the indicated buffers their +appropriate windows within +max_delay milliseconds after min_delay milliseconds have passed. +No two buffers may be associated with the same window or else a Matc +error is generated. +.PP +.ZN XmbufGetWindowAttributes +gets the multibuffering attributes that apply +to all buffers associated +with the given window. +The list of buffers returns may be freed with +.ZN XFree . +Returns non-zero on success and zero if an error occurs. +.PP +.ZN XmbufChangeWindowAttributes +sets the multibuffering attributes +that apply to all buffers associated +with the given window. This is currently limited to the update_hint. +.PP +.ZN XmbufGetBufferAttributes +gets the attributes for the indicated buffer. +Returns non-zero on +success and zero if an error occurs. +.PP +.ZN XmbufChangeBufferAttributes +sets the attributes for the indicated buffer. +This is currently limited to the event_mask. +.PP +.ZN XmbufGetScreenInfo +gets the parameters controlling how +mono and stereo windows may be +created on the screen of the given drawable. The numbers of sets of +visual and depths are returned in nmono_return and nstereo_return. If +nmono_return is greater than zero, then mono_info_return is set to the +address of an array of +.ZN XmbufBufferInfo +structures describing the +various visuals and depths that may be used. Otherwise, +mono_info_return is set to NULL. Similarly, stereo_info_return is set +according to nstereo_return. The storage returned in mono_info_return +and stereo_info_return may be released by +.ZN XFree . +If no errors are +encounted, non-zero will be returned. +.PP +.ZN XmbufCreateStereoWindow +creates a stereo window in the same way that +.ZN XCreateWindow +creates a mono window. The buffer ids for the left and right buffers are +returned in left_return and right_return, respectively. If an +extension error handler that returns is installed, +.ZN None +will be returned if the extension is not available on this display. +.SH PREDEFINED VALUES +.sp +Update_action field: +.in +.5i +.nf +.ZN MultibufferUpdateActionUndefined +.ZN MultibufferUpdateActionBackground +.ZN MultibufferUpdateActionUntouched +.ZN MultibufferUpdateActionCopied +.in -.5i +.fi +.sp +Update_hint field: +.in +.5i +.nf +.ZN MultibufferUpdateHintFrequent +.ZN MultibufferUpdateHintIntermittent +.ZN MultibufferUpdateHintStatic +.in -.5i +.sp +.fi +Valuemask fields: +.in +.5i +.nf +.ZN MultibufferWindowUpdateHint +.ZN MultibufferBufferEventMask +.in -.5i +.fi +.sp +Mono vs. stereo and left vs. right: +.in +.5i +.nf +.ZN MultibufferModeMono +.ZN MultibufferModeStereo +.ZN MultibufferSideMono +.ZN MultibufferSideLeft +.ZN MultibufferSideRight +.in -.5i +.fi +.sp +Clobber state: +.in +.5i +.nf +.ZN MultibufferUnclobbered +.ZN MultibufferPartiallyClobbered +.ZN MultibufferFullyClobbered +.in -.5i +.fi +.sp +Event stuff: +.in +.5i +.nf +.ZN MultibufferClobberNotifyMask +.ZN MultibufferUpdateNotifyMask +.ZN MultibufferClobberNotify +.ZN MultibufferUpdateNotify +.ZN MultibufferNumberEvents +.ZN MultibufferBadBuffer +.ZN MultibufferNumberErrors +.in -.5i +.fi +.SH BUGS +This manual page needs more work. +.SH SEE ALSO +\fIExtending X for Double Buffering, Multi-Buffering, and Stereo\fP diff --git a/src/DPMS.c b/src/DPMS.c new file mode 100644 index 0000000..62e3dfb --- /dev/null +++ b/src/DPMS.c @@ -0,0 +1,296 @@ +/* $Xorg: DPMS.c,v 1.3 2000/08/17 19:45:50 cpqbld Exp $ */ +/***************************************************************** + +Copyright (c) 1996 Digital Equipment Corporation, Maynard, Massachusetts. + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software. + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL +DIGITAL EQUIPMENT CORPORATION BE LIABLE FOR ANY CLAIM, DAMAGES, INCLUDING, +BUT NOT LIMITED TO CONSEQUENTIAL OR INCIDENTAL DAMAGES, OR OTHER LIABILITY, +WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR +IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +Except as contained in this notice, the name of Digital Equipment Corporation +shall not be used in advertising or otherwise to promote the sale, use or other +dealings in this Software without prior written authorization from Digital +Equipment Corporation. + +******************************************************************/ + +/* + * HISTORY + */ + +#define NEED_REPLIES +#include "Xlibint.h" +#include "dpms.h" +#include "dpmsstr.h" +#include "Xext.h" +#include "extutil.h" +#include "stdio.h" + +static XExtensionInfo _dpms_info_data; +static XExtensionInfo *dpms_info = &_dpms_info_data; +static char *dpms_extension_name = DPMSExtensionName; + +#define DPMSCheckExtension(dpy,i,val) \ + XextCheckExtension (dpy, i, dpms_extension_name, val) + +/***************************************************************************** + * * + * private utility routines * + * * + *****************************************************************************/ + +static int close_display(); +static /* const */ XExtensionHooks dpms_extension_hooks = { + NULL, /* create_gc */ + NULL, /* copy_gc */ + NULL, /* flush_gc */ + NULL, /* free_gc */ + NULL, /* create_font */ + NULL, /* free_font */ + close_display, /* close_display */ + NULL, /* wire_to_event */ + NULL, /* event_to_wire */ + NULL, /* error */ + NULL /* error_string */ +}; + +static XEXT_GENERATE_FIND_DISPLAY (find_display, dpms_info, + dpms_extension_name, + &dpms_extension_hooks, DPMSNumberEvents, + NULL) + +static XEXT_GENERATE_CLOSE_DISPLAY (close_display, dpms_info) + +/***************************************************************************** + * * + * public routines * + * * + *****************************************************************************/ + +Bool DPMSQueryExtension (dpy, event_basep, error_basep) + Display *dpy; + int *event_basep, *error_basep; +{ + XExtDisplayInfo *info = find_display (dpy); + + if (XextHasExtension(info)) { + *event_basep = info->codes->first_event; + *error_basep = info->codes->first_error; + return True; + } else { + return False; + } +} + +Status DPMSGetVersion(dpy, major_versionp, minor_versionp) + Display *dpy; + int *major_versionp, *minor_versionp; +{ + XExtDisplayInfo *info = find_display (dpy); + xDPMSGetVersionReply rep; + register xDPMSGetVersionReq *req; + + DPMSCheckExtension (dpy, info, 0); + + LockDisplay (dpy); + GetReq (DPMSGetVersion, req); + req->reqType = info->codes->major_opcode; + req->dpmsReqType = X_DPMSGetVersion; + if (!_XReply (dpy, (xReply *) &rep, 0, xTrue)) { + UnlockDisplay (dpy); + SyncHandle (); + return 0; + } + *major_versionp = rep.majorVersion; + *minor_versionp = rep.minorVersion; + UnlockDisplay (dpy); + SyncHandle (); + return 1; +} + +Bool DPMSCapable(dpy) + Display *dpy; +{ + XExtDisplayInfo *info = find_display (dpy); + register xDPMSCapableReq *req; + xDPMSCapableReply rep; + + DPMSCheckExtension (dpy, info, 0); + + LockDisplay(dpy); + GetReq(DPMSCapable, req); + req->reqType = info->codes->major_opcode; + req->dpmsReqType = X_DPMSCapable; + + if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) { + UnlockDisplay(dpy); + SyncHandle(); + return False; + } + UnlockDisplay(dpy); + SyncHandle(); + return rep.capable; +} + +Status DPMSSetTimeouts(dpy, standby, suspend, off) + Display *dpy; + CARD16 standby, suspend, off; +{ + XExtDisplayInfo *info = find_display (dpy); + register xDPMSSetTimeoutsReq *req; + + if ((off != 0)&&(off < suspend)) + { + return BadValue; + } + if ((suspend != 0)&&(suspend < standby)) + { + return BadValue; + } + + DPMSCheckExtension (dpy, info, 0); + LockDisplay(dpy); + GetReq(DPMSSetTimeouts, req); + req->reqType = info->codes->major_opcode; + req->dpmsReqType = X_DPMSSetTimeouts; + req->standby = standby; + req->suspend = suspend; + req->off = off; + + UnlockDisplay(dpy); + SyncHandle(); + return 1; +} + +Bool DPMSGetTimeouts(dpy, standby, suspend, off) + Display *dpy; + CARD16 *standby, *suspend, *off; +{ + XExtDisplayInfo *info = find_display (dpy); + register xDPMSGetTimeoutsReq *req; + xDPMSGetTimeoutsReply rep; + + DPMSCheckExtension (dpy, info, 0); + + LockDisplay(dpy); + GetReq(DPMSGetTimeouts, req); + req->reqType = info->codes->major_opcode; + req->dpmsReqType = X_DPMSGetTimeouts; + + if (!_XReply(dpy, (xReply *)&rep, 0, xTrue)) { + UnlockDisplay(dpy); + SyncHandle(); + return False; + } + UnlockDisplay(dpy); + SyncHandle(); + *standby = rep.standby; + *suspend = rep.suspend; + *off = rep.off; + return 1; +} + +Status DPMSEnable(dpy) + Display *dpy; +{ + XExtDisplayInfo *info = find_display (dpy); + register xDPMSEnableReq *req; + + DPMSCheckExtension (dpy, info, 0); + LockDisplay(dpy); + GetReq(DPMSEnable, req); + req->reqType = info->codes->major_opcode; + req->dpmsReqType = X_DPMSEnable; + + UnlockDisplay(dpy); + SyncHandle(); + return 1; +} + +Status DPMSDisable(dpy) + Display *dpy; +{ + XExtDisplayInfo *info = find_display (dpy); + register xDPMSDisableReq *req; + + DPMSCheckExtension (dpy, info, 0); + LockDisplay(dpy); + GetReq(DPMSDisable, req); + req->reqType = info->codes->major_opcode; + req->dpmsReqType = X_DPMSDisable; + + UnlockDisplay(dpy); + SyncHandle(); + return 1; +} + + +Status DPMSForceLevel(dpy, level) + Display *dpy; + CARD16 level; +{ + XExtDisplayInfo *info = find_display (dpy); + register xDPMSForceLevelReq *req; + + DPMSCheckExtension (dpy, info, 0); + + if ((level != DPMSModeOn) && + (level != DPMSModeStandby) && + (level != DPMSModeSuspend) && + (level != DPMSModeOff)) + return BadValue; + + LockDisplay(dpy); + GetReq(DPMSForceLevel, req); + req->reqType = info->codes->major_opcode; + req->dpmsReqType = X_DPMSForceLevel; + req->level = level; + + UnlockDisplay(dpy); + SyncHandle(); + return 1; +} + +Status DPMSInfo(dpy, power_level, state) + Display *dpy; + CARD16 *power_level; + BOOL *state; +{ + XExtDisplayInfo *info = find_display (dpy); + register xDPMSInfoReq *req; + xDPMSInfoReply rep; + + DPMSCheckExtension (dpy, info, 0); + + LockDisplay(dpy); + GetReq(DPMSInfo, req); + req->reqType = info->codes->major_opcode; + req->dpmsReqType = X_DPMSInfo; + + if (!_XReply(dpy, (xReply *)&rep, 0, xTrue)) { + UnlockDisplay(dpy); + SyncHandle(); + return False; + } + UnlockDisplay(dpy); + SyncHandle(); + *power_level = rep.power_level; + *state = rep.state; + return 1; +} + + + diff --git a/src/MITMisc.c b/src/MITMisc.c new file mode 100644 index 0000000..810e5cb --- /dev/null +++ b/src/MITMisc.c @@ -0,0 +1,134 @@ +/* + * $Xorg: MITMisc.c,v 1.4 2001/02/09 02:03:49 xorgcvs Exp $ + * +Copyright 1989, 1998 The Open Group + +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. + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN +AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN +CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +Except as contained in this notice, the name of The Open Group shall not be +used in advertising or otherwise to promote the sale, use or other dealings +in this Software without prior written authorization from The Open Group. + * + */ + +/* RANDOM CRUFT! THIS HAS NO OFFICIAL X CONSORTIUM BLESSING */ + +#define NEED_REPLIES +#include "Xlibint.h" +#include "MITMisc.h" +#include "mitmiscstr.h" +#include "Xext.h" +#include "extutil.h" + +static XExtensionInfo _mit_info_data; +static XExtensionInfo *mit_info = &_mit_info_data; +static /* const */ char *mit_extension_name = MITMISCNAME; + +#define MITCheckExtension(dpy,i,val) \ + XextCheckExtension (dpy, i, mit_extension_name, val) + +/***************************************************************************** + * * + * private utility routines * + * * + *****************************************************************************/ + +static int close_display(); +static /* const */ XExtensionHooks mit_extension_hooks = { + NULL, /* create_gc */ + NULL, /* copy_gc */ + NULL, /* flush_gc */ + NULL, /* free_gc */ + NULL, /* create_font */ + NULL, /* free_font */ + close_display, /* close_display */ + NULL, /* wire_to_event */ + NULL, /* event_to_wire */ + NULL, /* error */ + NULL /* error_string */ +}; + +static XEXT_GENERATE_FIND_DISPLAY (find_display, mit_info, mit_extension_name, + &mit_extension_hooks, MITMiscNumberEvents, + NULL) + +static XEXT_GENERATE_CLOSE_DISPLAY (close_display, mit_info) + + +/***************************************************************************** + * * + * public routines * + * * + *****************************************************************************/ + +Bool XMITMiscQueryExtension (dpy, event_basep, error_basep) + Display *dpy; + int *event_basep, *error_basep; +{ + XExtDisplayInfo *info = find_display (dpy); + + if (XextHasExtension(info)) { + *event_basep = info->codes->first_event; + *error_basep = info->codes->first_error; + return True; + } else { + return False; + } +} + + +Status XMITMiscSetBugMode(dpy, onOff) + Display *dpy; + Bool onOff; +{ + XExtDisplayInfo *info = find_display (dpy); + register xMITSetBugModeReq *req; + + MITCheckExtension (dpy, info, 0); + + LockDisplay(dpy); + GetReq(MITSetBugMode, req); + req->reqType = info->codes->major_opcode; + req->mitReqType = X_MITSetBugMode; + req->onOff = onOff; + UnlockDisplay(dpy); + SyncHandle(); + return 1; +} + +Bool XMITMiscGetBugMode(dpy) + Display *dpy; +{ + XExtDisplayInfo *info = find_display (dpy); + register xMITGetBugModeReq *req; + xMITGetBugModeReply rep; + + MITCheckExtension (dpy, info, 0); + + LockDisplay(dpy); + GetReq(MITGetBugMode, req); + req->reqType = info->codes->major_opcode; + req->mitReqType = X_MITGetBugMode; + if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) { + UnlockDisplay(dpy); + SyncHandle(); + return False; + } + UnlockDisplay(dpy); + SyncHandle(); + return rep.onOff; +} diff --git a/src/XAppgroup.c b/src/XAppgroup.c new file mode 100644 index 0000000..915d989 --- /dev/null +++ b/src/XAppgroup.c @@ -0,0 +1,432 @@ +/* + +Copyright 1996, 1998 The Open Group + +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. + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN +AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN +CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +Except as contained in this notice, the name of The Open Group shall not be +used in advertising or otherwise to promote the sale, use or other dealings +in this Software without prior written authorization from The Open Group. + +*/ +/* $Xorg: XAppgroup.c,v 1.5 2001/02/09 02:03:49 xorgcvs Exp $ */ + +#ifdef WIN32 +#define BOOL wBOOL +#undef Status +#define Status wStatus +#include +#undef Status +#define Status int +#undef BOOL +#endif + +#define NEED_EVENTS +#define NEED_REPLIES +#include "Xlibint.h" +#include "Xagstr.h" +#include "Xext.h" +#include "extutil.h" + +#if NeedVarargsPrototypes +#define Va_start(a,b) va_start(a,b) +#else +#define Va_start(a,b) va_start(a) +#endif + +struct xagstuff { + int attrib_mask; + Bool app_group_leader; + Bool single_screen; + Window default_root; + VisualID root_visual; + Colormap default_colormap; + unsigned long black_pixel; + unsigned long white_pixel; +}; + +static XExtensionInfo _xag_info_data; +static XExtensionInfo *xag_info = &_xag_info_data; +static char *xag_extension_name = XAGNAME; + +#define XagCheckExtension(dpy,i,val) \ + XextCheckExtension (dpy, i, xag_extension_name, val) + +/***************************************************************************** + * * + * private utility routines * + * * + *****************************************************************************/ + +static int close_display(); +static /* const */ XExtensionHooks xag_extension_hooks = { + NULL, /* create_gc */ + NULL, /* copy_gc */ + NULL, /* flush_gc */ + NULL, /* free_gc */ + NULL, /* create_font */ + NULL, /* free_font */ + close_display, /* close_display */ + NULL, /* wire_to_event */ + NULL, /* event_to_wire */ + NULL, /* error */ + NULL, /* error_string */ +}; + +static XEXT_GENERATE_FIND_DISPLAY (find_display, xag_info, + xag_extension_name, + &xag_extension_hooks, + 0, NULL) + +static XEXT_GENERATE_CLOSE_DISPLAY (close_display, xag_info) + + +/***************************************************************************** + * * + * public Xag Extension routines * + * * + *****************************************************************************/ + +Bool +XagQueryVersion(dpy, major_version_return, minor_version_return) + Display* dpy; + int* major_version_return; + int* minor_version_return; +{ + XExtDisplayInfo *info = find_display (dpy); + xXagQueryVersionReply rep; + xXagQueryVersionReq *req; + + XagCheckExtension (dpy, info, False); + + LockDisplay(dpy); + GetReq(XagQueryVersion, req); + req->reqType = info->codes->major_opcode; + req->xagReqType = X_XagQueryVersion; + req->client_major_version = XAG_MAJOR_VERSION; + req->client_minor_version = XAG_MINOR_VERSION; + if (!_XReply(dpy, (xReply *)&rep, 0, xTrue)) { + UnlockDisplay(dpy); + SyncHandle(); + return False; + } + *major_version_return = rep.server_major_version; + *minor_version_return = rep.server_minor_version; + UnlockDisplay(dpy); + SyncHandle(); + return True; +} + +static void +StuffToWire (dpy, stuff, req) + Display* dpy; + struct xagstuff* stuff; + xXagCreateReq* req; +{ + unsigned long values[8]; + unsigned long* value = values; + unsigned int nvalues; + + /* the order these are in is important */ + if (stuff->attrib_mask & XagSingleScreenMask) + *value++ = stuff->single_screen; + + if (stuff->attrib_mask & XagDefaultRootMask) + *value++ = stuff->default_root; + + if (stuff->attrib_mask & XagRootVisualMask) + *value++ = stuff->root_visual; + + if (stuff->attrib_mask & XagDefaultColormapMask) + *value++ = stuff->default_colormap; + + if (stuff->attrib_mask & XagBlackPixelMask) + *value++ = stuff->black_pixel; + + if (stuff->attrib_mask & XagWhitePixelMask) + *value++ = stuff->white_pixel; + + if (stuff->attrib_mask & XagAppGroupLeaderMask) + *value++ = stuff->app_group_leader; + + req->length += (nvalues = value - values); + + nvalues <<= 2; + Data32 (dpy, (long*) values, (long) nvalues); +} + +Bool +#if NeedFunctionPrototypes +XagCreateEmbeddedApplicationGroup( + Display* dpy, + VisualID root_visual, + Colormap default_colormap, + unsigned long black_pixel, + unsigned long white_pixel, + XAppGroup* app_group_return) +#else +XagCreateEmbeddedApplicationGroup(dpy, root_visual, default_colormap, black_pixel, white_pixel, app_group_return) + Display* dpy; + VisualID root_visual; + Colormap default_colormap; + unsigned long black_pixel, white_pixel; + XAppGroup* app_group_return; +#endif +{ + XExtDisplayInfo *info = find_display (dpy); + xXagCreateReq *req; + struct xagstuff stuff; + + XagCheckExtension (dpy, info, False); + + LockDisplay(dpy); + stuff.app_group_leader = True; + stuff.single_screen = True; + stuff.default_root = RootWindow (dpy, DefaultScreen(dpy)); + stuff.root_visual = root_visual; + stuff.default_colormap = default_colormap; + stuff.attrib_mask = + XagAppGroupLeaderMask | XagSingleScreenMask | XagDefaultRootMask | + XagRootVisualMask | XagDefaultColormapMask; + if (default_colormap != None) { + stuff.black_pixel = black_pixel; + stuff.white_pixel = white_pixel; + stuff.attrib_mask |= XagBlackPixelMask | XagWhitePixelMask; + } + /* might do some validation here */ + GetReq(XagCreate, req); + req->reqType = info->codes->major_opcode; + req->xagReqType = X_XagCreate; + *app_group_return = req->app_group = XAllocID(dpy); + req->attrib_mask = stuff.attrib_mask; + StuffToWire (dpy, &stuff, req); + UnlockDisplay(dpy); + SyncHandle(); + return True; +} + +Bool +#if NeedFunctionPrototypes +XagCreateNonembeddedApplicationGroup( + Display* dpy, + XAppGroup* app_group_return) +#else +XagCreateNonembeddedApplicationGroup(dpy, app_group_return) + Display* dpy; + XAppGroup* app_group_return; +#endif +{ + XExtDisplayInfo *info = find_display (dpy); + xXagCreateReq *req; + struct xagstuff stuff; + + XagCheckExtension (dpy, info, False); + + LockDisplay(dpy); + stuff.app_group_leader = False; + stuff.single_screen = False; + stuff.attrib_mask = XagAppGroupLeaderMask | XagSingleScreenMask; + /* might do some validation here */ + GetReq(XagCreate, req); + req->reqType = info->codes->major_opcode; + req->xagReqType = X_XagCreate; + *app_group_return = req->app_group = XAllocID(dpy); + req->attrib_mask = stuff.attrib_mask; + StuffToWire (dpy, &stuff, req); + UnlockDisplay(dpy); + SyncHandle(); + return True; +} + +Bool XagDestroyApplicationGroup(dpy,app_group) + Display* dpy; + XAppGroup app_group; +{ + XExtDisplayInfo *info = find_display (dpy); + xXagDestroyReq *req; + + XagCheckExtension (dpy, info, False); + + LockDisplay(dpy); + GetReq(XagDestroy, req); + req->reqType = info->codes->major_opcode; + req->xagReqType = X_XagDestroy; + req->app_group = app_group; + UnlockDisplay(dpy); + SyncHandle(); + return True; +} + +Bool +#if NeedVarargsPrototypes +XagGetApplicationGroupAttributes( + Display* dpy, + XAppGroup app_group, + ...) +#else +XagGetApplicationGroupAttributes(dpy, app_group, va_alist) + Display* dpy; + XAppGroup app_group; + va_dcl +#endif +{ + va_list var; + XExtDisplayInfo *info = find_display (dpy); + xXagGetAttrReq *req; + xXagGetAttrReply rep; + int attr; + + XagCheckExtension (dpy, info, False); + + LockDisplay(dpy); + GetReq(XagGetAttr, req); + req->reqType = info->codes->major_opcode; + req->xagReqType = X_XagGetAttr; + req->app_group = app_group; + if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) { + UnlockDisplay(dpy); + SyncHandle(); + return False; + } + Va_start (var, app_group); + for (attr = va_arg(var, int); attr != 0; attr = va_arg(var, int)) { + void* ptr; + + switch (attr) { + case XagNappGroupLeader: + ptr = va_arg(var, void*); + *(Bool*)ptr = rep.app_group_leader; + break; + case XagNsingleScreen: + ptr = va_arg(var, void*); + *(Bool*)ptr = rep.single_screen; + break; + case XagNdefaultRoot: + ptr = va_arg(var, void*); + *(Window*)ptr = rep.default_root; + break; + case XagNrootVisual: + ptr = va_arg(var, void*); + *(VisualID*)ptr = rep.root_visual; + break; + case XagNdefaultColormap: + ptr = va_arg(var, void*); + *(Colormap*)ptr = rep.default_colormap; + break; + case XagNblackPixel: + ptr = va_arg(var, void*); + *(unsigned long*)ptr = rep.black_pixel; + break; + case XagNwhitePixel: + ptr = va_arg(var, void*); + *(unsigned long*)ptr = rep.white_pixel; + break; + } + } + va_end (var); + UnlockDisplay(dpy); + SyncHandle(); + return True; +} + +Bool +XagQueryApplicationGroup(dpy, resource, app_group_return) + Display* dpy; + XID resource; + XAppGroup* app_group_return; +{ + XExtDisplayInfo *info = find_display (dpy); + xXagQueryReq *req; + xXagQueryReply rep; + + XagCheckExtension (dpy, info, False); + + LockDisplay(dpy); + GetReq(XagQuery, req); + req->reqType = info->codes->major_opcode; + req->xagReqType = X_XagQuery; + req->resource = resource; + if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) { + UnlockDisplay(dpy); + SyncHandle(); + return False; + } + *app_group_return = rep.app_group; + UnlockDisplay(dpy); + SyncHandle(); + return True; + +} + +Bool +XagCreateAssociation(dpy, window_return, system_window) + Display* dpy; + Window* window_return; + void* system_window; +{ +#ifdef WIN32 + long tmp = *(HWND*) system_window; + XExtDisplayInfo *info = find_display (dpy); + xXagCreateAssocReq *req; + + XagCheckExtension (dpy, info, False); + + LockDisplay(dpy); + GetReq(XagCreateAssoc, req); + req->reqType = info->codes->major_opcode; + req->xagReqType = X_XagCreateAssoc; + *window_return = req->window = XAllocID(dpy); + req->window_type = XagWindowTypeWin32; + req->system_window_len = sizeof(HWND); + Data32 (dpy, (long*) tmp, 1L); + req->length++; + UnlockDisplay(dpy); + SyncHandle(); +#else + /* other platforms go here */ + + /* this whole thing could be arranged better, but since X need + * only short-circuit the protocol and WIN32 is the only other + * platform the XC supports, it will suffice for now. + */ + *window_return = *(Window*)system_window; +#endif + return True; +} + +Bool +XagDestroyAssociation(dpy, window) + Display* dpy; + Window window; +{ +#ifdef WIN32 + XExtDisplayInfo *info = find_display (dpy); + xXagDestroyAssocReq *req; + + XagCheckExtension (dpy, info, False); + + LockDisplay(dpy); + GetReq(XagDestroyAssoc, req); + req->reqType = info->codes->major_opcode; + req->xagReqType = X_XagDestroyAssoc; + req->window = window; + UnlockDisplay(dpy); + SyncHandle(); +#endif + return True; +} + diff --git a/src/XEVI.c b/src/XEVI.c new file mode 100644 index 0000000..88e3ff3 --- /dev/null +++ b/src/XEVI.c @@ -0,0 +1,212 @@ +/* $Xorg: XEVI.c,v 1.3 2000/08/17 19:45:51 cpqbld Exp $ */ +/************************************************************ +Copyright (c) 1997 by Silicon Graphics Computer Systems, Inc. +Permission to use, copy, modify, and distribute this +software and its documentation for any purpose and without +fee is hereby granted, 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 Silicon Graphics not be +used in advertising or publicity pertaining to distribution +of the software without specific prior written permission. +Silicon Graphics makes no representation about the suitability +of this software for any purpose. It is provided "as is" +without any express or implied warranty. +SILICON GRAPHICS DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS +SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY +AND FITNESS FOR A PARTICULAR PURPOSE. IN NO EVENT SHALL SILICON +GRAPHICS 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. +********************************************************/ +#define NEED_EVENTS +#define NEED_REPLIES +#include "Xlibint.h" +#include "XEVI.h" +#include "XEVIstr.h" +#include "Xext.h" +#include "extutil.h" +#include +static XExtensionInfo *xevi_info;/* needs to move to globals.c */ +static /* const */ char *xevi_extension_name = EVINAME; +#define XeviCheckExtension(dpy,i,val) \ + XextCheckExtension (dpy, i, xevi_extension_name, val) +/***************************************************************************** + * * + * private utility routines * + * * + *****************************************************************************/ +static /* const */ XExtensionHooks xevi_extension_hooks = { + NULL, /* create_gc */ + NULL, /* copy_gc */ + NULL, /* flush_gc */ + NULL, /* free_gc */ + NULL, /* create_font */ + NULL, /* free_font */ + NULL, /* close_display */ + NULL, /* wire_to_event */ + NULL, /* event_to_wire */ + NULL, /* error */ + NULL, /* error_string */ +}; +static XEXT_GENERATE_FIND_DISPLAY (find_display, xevi_info, + xevi_extension_name, + &xevi_extension_hooks, 0, NULL) +Bool XeviQueryExtension (dpy) + Display *dpy; +{ + XExtDisplayInfo *info = find_display (dpy); + if (XextHasExtension(info)) { + return True; + } else { + return False; + } +} +Bool XeviQueryVersion(dpy, majorVersion, minorVersion) + Display *dpy; + int *majorVersion, *minorVersion; +{ + XExtDisplayInfo *info = find_display (dpy); + xEVIQueryVersionReply rep; + register xEVIQueryVersionReq *req; + XeviCheckExtension (dpy, info, False); + LockDisplay(dpy); + GetReq(EVIQueryVersion, req); + req->reqType = info->codes->major_opcode; + req->xeviReqType = X_EVIQueryVersion; + if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) { + UnlockDisplay(dpy); + SyncHandle(); + return False; + } + *majorVersion = rep.majorVersion; + *minorVersion = rep.minorVersion; + UnlockDisplay(dpy); + SyncHandle(); + return True; +} +static Bool notInList(VisualID32 *visual, int sz_visual, VisualID newVisualid) +{ + while (sz_visual-- > 0) { + if (*visual == newVisualid) + return False; + visual++; + } + return True; +} +Status XeviGetVisualInfo(dpy, visual, n_visual, evi_return, n_info_return) + register Display *dpy; + VisualID *visual; + int n_visual; + ExtendedVisualInfo **evi_return; + int *n_info_return; +{ + XExtDisplayInfo *info = find_display (dpy); + register xEVIGetVisualInfoReq *req; + xEVIGetVisualInfoReply rep; + int sz_info, sz_xInfo, sz_conflict, sz_xConflict; + VisualID32 *temp_conflict, *temp_visual, *xConflictPtr; + VisualID *conflict; + xExtendedVisualInfo *temp_xInfo; + XVisualInfo *vinfo; + register ExtendedVisualInfo *infoPtr; + register xExtendedVisualInfo *xInfoPtr; + register int n_data, visualIndex, vinfoIndex; + Bool isValid; + XeviCheckExtension (dpy, info, 0); + *n_info_return = 0; + *evi_return = NULL; + vinfo = XGetVisualInfo(dpy, 0, NULL, &sz_info); + if (!vinfo) { + return BadValue; + } + if (!n_visual || !visual) { /* copy the all visual */ + temp_visual = (VisualID32 *)Xmalloc(sz_VisualID32 * sz_info); + n_visual = 0; + for (vinfoIndex = 0; vinfoIndex < sz_info; vinfoIndex++) + if (notInList(temp_visual, n_visual, vinfo[vinfoIndex].visualid)) + temp_visual[n_visual++] = vinfo[vinfoIndex].visualid; + } + else { /* check if the visual is valid */ + for (visualIndex = 0; visualIndex < n_visual; visualIndex++) { + isValid = False; + for (vinfoIndex = 0; vinfoIndex < sz_info; vinfoIndex++) { + if (visual[visualIndex] == vinfo[vinfoIndex].visualid) { + isValid = True; + break; + } + } + if (!isValid) { + XFree(vinfo); + return BadValue; + } + } + temp_visual = (VisualID32 *)Xmalloc(sz_VisualID32 * n_visual); + for (visualIndex = 0; visualIndex < n_visual; visualIndex++) + temp_visual[visualIndex] = visual[visualIndex]; + } + XFree(vinfo); + LockDisplay(dpy); + GetReq(EVIGetVisualInfo, req); + req->reqType = info->codes->major_opcode; + req->xeviReqType = X_EVIGetVisualInfo; + req->n_visual = n_visual; + SetReqLen(req, n_visual, 1); + Data(dpy, (char *)temp_visual, n_visual * sz_VisualID32); + if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) { + UnlockDisplay(dpy); + SyncHandle(); + Xfree(temp_visual); + return BadAccess; + } + Xfree(temp_visual); + sz_info = rep.n_info * sizeof(ExtendedVisualInfo); + sz_xInfo = rep.n_info * sz_xExtendedVisualInfo; + sz_conflict = rep.n_conflicts * sizeof(VisualID); + sz_xConflict = rep.n_conflicts * sz_VisualID32; + infoPtr = *evi_return = (ExtendedVisualInfo *)Xmalloc(sz_info + sz_conflict); + xInfoPtr = temp_xInfo = (xExtendedVisualInfo *)Xmalloc(sz_xInfo); + xConflictPtr = temp_conflict = (VisualID32 *)Xmalloc(sz_xConflict); + if (!*evi_return || !temp_xInfo || !temp_conflict) { + _XEatData(dpy, (sz_xInfo + sz_xConflict + 3) & ~3); + UnlockDisplay(dpy); + SyncHandle(); + if (evi_return) + Xfree(evi_return); + if (temp_xInfo) + Xfree(temp_xInfo); + if (temp_conflict) + Xfree(temp_conflict); + return BadAlloc; + } + _XRead(dpy, (char *)temp_xInfo, sz_xInfo); + _XRead(dpy, (char *)temp_conflict, sz_xConflict); + UnlockDisplay(dpy); + SyncHandle(); + n_data = rep.n_info; + conflict = (VisualID *)(infoPtr + n_data); + while (n_data-- > 0) { + infoPtr->core_visual_id = xInfoPtr->core_visual_id; + infoPtr->screen = xInfoPtr->screen; + infoPtr->level = xInfoPtr->level; + infoPtr->transparency_type = xInfoPtr->transparency_type; + infoPtr->transparency_value = xInfoPtr->transparency_value; + infoPtr->min_hw_colormaps = xInfoPtr->min_hw_colormaps; + infoPtr->max_hw_colormaps = xInfoPtr->max_hw_colormaps; + infoPtr->num_colormap_conflicts = xInfoPtr->num_colormap_conflicts; + infoPtr->colormap_conflicts = conflict; + conflict += infoPtr->num_colormap_conflicts; + infoPtr++; + xInfoPtr++; + } + n_data = rep.n_conflicts; + conflict = (VisualID *)(infoPtr); + while (n_data-- > 0) + *conflict++ = *xConflictPtr++; + Xfree(temp_xInfo); + Xfree(temp_conflict); + *n_info_return = rep.n_info; + return Success; +} diff --git a/src/XLbx.c b/src/XLbx.c new file mode 100644 index 0000000..cf4ee16 --- /dev/null +++ b/src/XLbx.c @@ -0,0 +1,127 @@ +/* + * $Xorg: XLbx.c,v 1.3 2000/08/17 19:45:51 cpqbld Exp $ + * + * Copyright 1992 Network Computing Devices + * + * 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 NCD. not be used in advertising or + * publicity pertaining to distribution of the software without specific, + * written prior permission. NCD. makes no representations about the + * suitability of this software for any purpose. It is provided "as is" + * without express or implied warranty. + * + * NCD. DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL NCD. + * 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. + * + * Author: Keith Packard, Network Computing Devices + */ +#define NEED_EVENTS +#define NEED_REPLIES +#include "Xlibint.h" +#include "XLbx.h" +#include "lbxstr.h" +#include "Xext.h" +#include "extutil.h" + +static XExtensionInfo _lbx_info_data; +static XExtensionInfo *lbx_info = &_lbx_info_data; +static /* const */ char *lbx_extension_name = LBXNAME; + +#define LbxCheckExtension(dpy,i,val) \ + XextCheckExtension (dpy, i, lbx_extension_name, val) + +static int close_display(); +static char *error_string(); +static Bool wire_to_event(); +static Status event_to_wire(); +static /* const */ XExtensionHooks lbx_extension_hooks = { + NULL, /* create_gc */ + NULL, /* copy_gc */ + NULL, /* flush_gc */ + NULL, /* free_gc */ + NULL, /* create_font */ + NULL, /* free_font */ + close_display, /* close_display */ + NULL, /* wire_to_event */ + NULL, /* event_to_wire */ + NULL, /* error */ + error_string, /* error_string */ +}; + +static /* const */ char *lbx_error_list[] = { + "BadLbxClient", /* BadLbxClient */ +}; + +static XEXT_GENERATE_FIND_DISPLAY (find_display, lbx_info, lbx_extension_name, + &lbx_extension_hooks, LbxNumberEvents, NULL) + +static XEXT_GENERATE_CLOSE_DISPLAY (close_display, lbx_info) + +static XEXT_GENERATE_ERROR_STRING (error_string, lbx_extension_name, + LbxNumberErrors, lbx_error_list) + + +Bool XLbxQueryExtension (dpy, requestp, event_basep, error_basep) + Display *dpy; + int *requestp, *event_basep, *error_basep; +{ + XExtDisplayInfo *info = find_display (dpy); + + if (XextHasExtension(info)) { + *requestp = info->codes->major_opcode; + *event_basep = info->codes->first_event; + *error_basep = info->codes->first_error; + return True; + } else { + return False; + } +} + + +int XLbxGetEventBase(dpy) + Display *dpy; +{ + XExtDisplayInfo *info = find_display (dpy); + + if (XextHasExtension(info)) { + return info->codes->first_event; + } else { + return -1; + } +} + + +Bool XLbxQueryVersion(dpy, majorVersion, minorVersion) + Display *dpy; + int *majorVersion, *minorVersion; +{ + XExtDisplayInfo *info = find_display (dpy); + xLbxQueryVersionReply rep; + register xLbxQueryVersionReq *req; + + LbxCheckExtension (dpy, info, False); + + LockDisplay(dpy); + GetReq(LbxQueryVersion, req); + req->reqType = info->codes->major_opcode; + req->lbxReqType = X_LbxQueryVersion; + if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) { + UnlockDisplay(dpy); + SyncHandle(); + return False; + } + *majorVersion = rep.majorVersion; + *minorVersion = rep.minorVersion; + UnlockDisplay(dpy); + SyncHandle(); + return True; +} + +/* all other requests will run after Xlib has lost the wire ... */ diff --git a/src/XMultibuf.c b/src/XMultibuf.c new file mode 100644 index 0000000..55a1777 --- /dev/null +++ b/src/XMultibuf.c @@ -0,0 +1,722 @@ +/* + * $Xorg: XMultibuf.c,v 1.6 2001/02/09 02:03:49 xorgcvs Exp $ + * +Copyright 1989, 1998 The Open Group + +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. + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN +AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN +CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +Except as contained in this notice, the name of The Open Group shall not be +used in advertising or otherwise to promote the sale, use or other dealings +in this Software without prior written authorization from The Open Group. + * + * Authors: Jim Fulton, MIT X Consortium + */ + +#define NEED_EVENTS +#define NEED_REPLIES +#include +#include "Xext.h" /* in ../include */ +#include "extutil.h" /* in ../include */ +#include "multibufst.h" /* in ../include */ + +static XExtensionInfo _multibuf_info_data; +static XExtensionInfo *multibuf_info = &_multibuf_info_data; +static /* const */ char *multibuf_extension_name = MULTIBUFFER_PROTOCOL_NAME; + +#define MbufCheckExtension(dpy,i,val) \ + XextCheckExtension (dpy, i, multibuf_extension_name, val) +#define MbufSimpleCheckExtension(dpy,i) \ + XextSimpleCheckExtension (dpy, i, multibuf_extension_name) + + +/***************************************************************************** + * * + * private utility routines * + * * + *****************************************************************************/ + +/* + * find_display - locate the display info block + */ +static int close_display(); +static char *error_string(); +static Bool wire_to_event(); +static Status event_to_wire(); +static /* const */ XExtensionHooks multibuf_extension_hooks = { + NULL, /* create_gc */ + NULL, /* copy_gc */ + NULL, /* flush_gc */ + NULL, /* free_gc */ + NULL, /* create_font */ + NULL, /* free_font */ + close_display, /* close_display */ + wire_to_event, /* wire_to_event */ + event_to_wire, /* event_to_wire */ + NULL, /* error */ + error_string, /* error_string */ +}; + +static /* const */ char *multibuf_error_list[] = { + "BadBuffer", /* MultibufferBadBuffer */ +}; + +static XEXT_GENERATE_FIND_DISPLAY (find_display, multibuf_info, + multibuf_extension_name, + &multibuf_extension_hooks, + MultibufferNumberEvents, NULL) + +static XEXT_GENERATE_CLOSE_DISPLAY (close_display, multibuf_info) + +static XEXT_GENERATE_ERROR_STRING (error_string, multibuf_extension_name, + MultibufferNumberErrors, + multibuf_error_list) + +/* + * wire_to_event - convert a wire event in network format to a C + * event structure + */ +static Bool wire_to_event (dpy, libevent, netevent) + Display *dpy; + XEvent *libevent; + xEvent *netevent; +{ + XExtDisplayInfo *info = find_display (dpy); + + MbufCheckExtension (dpy, info, False); + + switch ((netevent->u.u.type & 0x7f) - info->codes->first_event) { + case MultibufferClobberNotify: + { + XmbufClobberNotifyEvent *ev; + xMbufClobberNotifyEvent *event; + + ev = (XmbufClobberNotifyEvent *) libevent; + event = (xMbufClobberNotifyEvent *) netevent; + ev->type = event->type & 0x7f; + ev->serial = _XSetLastRequestRead(dpy,(xGenericReply *) netevent); + ev->send_event = ((event->type & 0x80) != 0); + ev->display = dpy; + ev->buffer = event->buffer; + ev->state = event->state; + return True; + } + case MultibufferUpdateNotify: + { + XmbufUpdateNotifyEvent *ev; + xMbufUpdateNotifyEvent *event; + + ev = (XmbufUpdateNotifyEvent *) libevent; + event = (xMbufUpdateNotifyEvent *) netevent; + ev->type = event->type & 0x7f; + ev->serial = _XSetLastRequestRead(dpy,(xGenericReply *) netevent); + ev->send_event = ((event->type & 0x80) != 0); + ev->display = dpy; + ev->buffer = event->buffer; + return True; + } + } + return False; +} + + +/* + * event_to_wire - convert a C event structure to a wire event in + * network format + */ +static Status event_to_wire (dpy, libevent, netevent) + Display *dpy; + XEvent *libevent; + xEvent *netevent; +{ + XExtDisplayInfo *info = find_display (dpy); + + MbufCheckExtension (dpy, info, 0); + + switch ((libevent->type & 0x7f) - info->codes->first_event) { + case MultibufferClobberNotify: + { + XmbufClobberNotifyEvent *ev; + xMbufClobberNotifyEvent *event; + + ev = (XmbufClobberNotifyEvent *) libevent; + event = (xMbufClobberNotifyEvent *) netevent; + event->type = ev->type; + event->sequenceNumber = (ev->serial & 0xffff); + event->buffer = ev->buffer; + event->state = ev->state; + return 1; + } + case MultibufferUpdateNotify: + { + XmbufUpdateNotifyEvent *ev; + xMbufUpdateNotifyEvent *event; + + ev = (XmbufUpdateNotifyEvent *) libevent; + event = (xMbufUpdateNotifyEvent *) netevent; + event->type = ev->type; + event->sequenceNumber = (ev->serial & 0xffff); + event->buffer = ev->buffer; + return 1; + } + } + return 0; +} + + +/* + * read_buffer_info - read Buffer Info descriptors from the net; if unable + * to allocate memory, read junk to make sure that stream is clear. + */ +#define TALLOC(type,count) ((type *) Xmalloc ((unsigned) count * sizeof(type))) + +static XmbufBufferInfo *read_buffer_info (dpy, nbufs) + Display *dpy; + int nbufs; +{ + xMbufBufferInfo *netbuf = TALLOC (xMbufBufferInfo, nbufs); + XmbufBufferInfo *bufinfo = NULL; + long netbytes = nbufs * SIZEOF(xMbufBufferInfo); + + if (netbuf) { + _XRead (dpy, (char *) netbuf, netbytes); + + bufinfo = TALLOC (XmbufBufferInfo, nbufs); + if (bufinfo) { + register XmbufBufferInfo *c; + register xMbufBufferInfo *net; + register int i; + + for (i = 0, c = bufinfo, net = netbuf; i < nbufs; + i++, c++, net++) { + c->visualid = net->visualID; + c->max_buffers = net->maxBuffers; + c->depth = net->depth; + } + } + Xfree ((char *) netbuf); + } else { /* eat the data */ + while (netbytes > 0) { + char dummy[256]; /* stack size vs loops tradeoff */ + long nbytes = sizeof dummy; + + if (nbytes > netbytes) nbytes = netbytes; + _XRead (dpy, dummy, nbytes); + netbytes -= nbytes; + } + } + + return bufinfo; +} + +#undef TALLOC + + +/***************************************************************************** + * * + * Multibuffering/stereo public interfaces * + * * + *****************************************************************************/ + + +/* + * XmbufQueryExtension - + * Returns True if the multibuffering/stereo extension is available + * on the given display. If the extension exists, the value of the + * first event code (which should be added to the event type constants + * MultibufferClobberNotify and MultibufferUpdateNotify to get the + * actual values) is stored into event_base and the value of the first + * error code (which should be added to the error type constant + * MultibufferBadBuffer to get the actual value) is stored into + * error_base. + */ +Bool XmbufQueryExtension (dpy, event_base_return, error_base_return) + Display *dpy; + int *event_base_return, *error_base_return; +{ + XExtDisplayInfo *info = find_display (dpy); + + if (XextHasExtension (info)) { + *event_base_return = info->codes->first_event; + *error_base_return = info->codes->first_error; + return True; + } else { + return False; + } +} + + +/* + * XmbufGetVersion - + * Gets the major and minor version numbers of the extension. The return + * value is zero if an error occurs or non-zero if no error happens. + */ +Status XmbufGetVersion (dpy, major_version_return, minor_version_return) + Display *dpy; + int *major_version_return, *minor_version_return; +{ + XExtDisplayInfo *info = find_display (dpy); + xMbufGetBufferVersionReply rep; + register xMbufGetBufferVersionReq *req; + + MbufCheckExtension (dpy, info, 0); + + LockDisplay (dpy); + MbufGetReq (MbufGetBufferVersion, req, info); + if (!_XReply (dpy, (xReply *) &rep, 0, xTrue)) { + UnlockDisplay (dpy); + SyncHandle (); + return 0; + } + *major_version_return = rep.majorVersion; + *minor_version_return = rep.minorVersion; + UnlockDisplay (dpy); + + SyncHandle (); + return 1; +} + + +/* + * XmbufCreateBuffers - + * Requests that "count" buffers be created with the given update_action + * and update_hint and be associated with the indicated window. The + * number of buffers created is returned (zero if an error occurred) + * and buffers_return is filled in with that many Multibuffer identifiers. + */ +int XmbufCreateBuffers (dpy, w, count, update_action, update_hint, buffers) + Display *dpy; + Window w; + int count; + int update_action, update_hint; + Multibuffer *buffers; +{ + XExtDisplayInfo *info = find_display (dpy); + xMbufCreateImageBuffersReply rep; + register xMbufCreateImageBuffersReq *req; + int result; + + MbufCheckExtension (dpy, info, 0); + + LockDisplay (dpy); + + XAllocIDs(dpy, buffers, count); + MbufGetReq (MbufCreateImageBuffers, req, info); + req->window = w; + req->updateAction = update_action; + req->updateHint = update_hint; + req->length += count; + count <<= 2; + PackData32 (dpy, buffers, count); + if (!_XReply (dpy, (xReply *) &rep, 0, xTrue)) { + UnlockDisplay (dpy); + SyncHandle (); + return 0; + } + result = rep.numberBuffer; + UnlockDisplay (dpy); + + SyncHandle (); + return result; +} + + +/* + * XmbufDestroyBuffers - + * Destroys the buffers associated with the given window. + */ +void XmbufDestroyBuffers (dpy, window) + Display *dpy; + Window window; +{ + XExtDisplayInfo *info = find_display (dpy); + register xMbufDestroyImageBuffersReq *req; + + MbufSimpleCheckExtension (dpy, info); + + LockDisplay (dpy); + MbufGetReq (MbufDestroyImageBuffers, req, info); + req->window = window; + UnlockDisplay (dpy); + SyncHandle (); +} + + +/* + * XmbufDisplayBuffers - + * Displays the indicated buffers their appropriate windows within + * max_delay milliseconds after min_delay milliseconds have passed. + * No two buffers may be associated with the same window or else a Matc + * error is generated. + */ +void XmbufDisplayBuffers (dpy, count, buffers, min_delay, max_delay) + Display *dpy; + int count; + Multibuffer *buffers; + int min_delay, max_delay; +{ + XExtDisplayInfo *info = find_display (dpy); + register xMbufDisplayImageBuffersReq *req; + + MbufSimpleCheckExtension (dpy, info); + + LockDisplay (dpy); + MbufGetReq (MbufDisplayImageBuffers, req, info); + req->minDelay = min_delay; + req->maxDelay = max_delay; + req->length += count; + count <<= 2; + PackData32 (dpy, buffers, count); + UnlockDisplay (dpy); + SyncHandle(); +} + + +/* + * XmbufGetWindowAttributes - + * Gets the multibuffering attributes that apply to all buffers associated + * with the given window. Returns non-zero on success and zero if an + * error occurs. + */ +Status XmbufGetWindowAttributes (dpy, w, attr) + Display *dpy; + Window w; + XmbufWindowAttributes *attr; +{ + XExtDisplayInfo *info = find_display (dpy); + register xMbufGetMBufferAttributesReq *req; + xMbufGetMBufferAttributesReply rep; + + MbufCheckExtension (dpy, info, 0); + + LockDisplay (dpy); + MbufGetReq (MbufGetMBufferAttributes, req, info); + req->window = w; + if (!_XReply (dpy, (xReply *) &rep, 0, xFalse)) { + UnlockDisplay (dpy); + SyncHandle (); + return 0; + } + attr->buffers = (Multibuffer *) NULL; + if ((attr->nbuffers = rep.length)) { + int nbytes = rep.length * sizeof(Multibuffer); + attr->buffers = (Multibuffer *) Xmalloc((unsigned) nbytes); + nbytes = rep.length << 2; + if (! attr->buffers) { + _XEatData(dpy, (unsigned long) nbytes); + UnlockDisplay(dpy); + SyncHandle(); + return (0); + } + _XRead32 (dpy, (char *) attr->buffers, nbytes); + } + attr->displayed_index = rep.displayedBuffer; + attr->update_action = rep.updateAction; + attr->update_hint = rep.updateHint; + attr->window_mode = rep.windowMode; + + UnlockDisplay (dpy); + SyncHandle(); + return 1; +} + + +/* + * XmbufChangeWindowAttributes - + * Sets the multibuffering attributes that apply to all buffers associated + * with the given window. This is currently limited to the update_hint. + */ +void XmbufChangeWindowAttributes (dpy, w, valuemask, attr) + Display *dpy; + Window w; + unsigned long valuemask; + XmbufSetWindowAttributes *attr; +{ + XExtDisplayInfo *info = find_display (dpy); + register xMbufSetMBufferAttributesReq *req; + + MbufSimpleCheckExtension (dpy, info); + + LockDisplay (dpy); + MbufGetReq (MbufSetMBufferAttributes, req, info); + req->window = w; + if ((req->valueMask = valuemask)) { /* stolen from lib/X/XWindow.c */ + unsigned long values[1]; /* one per element in if stmts below */ + unsigned long *v = values; + unsigned int nvalues; + + if (valuemask & MultibufferWindowUpdateHint) + *v++ = attr->update_hint; + req->length += (nvalues = v - values); + nvalues <<= 2; /* watch out for macros... */ + Data32 (dpy, (long *) values, (long)nvalues); + } + UnlockDisplay (dpy); + SyncHandle(); +} + + +/* + * XmbufGetBufferAttributes - + * Gets the attributes for the indicated buffer. Returns non-zero on + * success and zero if an error occurs. + */ +Status XmbufGetBufferAttributes (dpy, b, attr) + Display *dpy; + Multibuffer b; + XmbufBufferAttributes *attr; +{ + XExtDisplayInfo *info = find_display (dpy); + register xMbufGetBufferAttributesReq *req; + xMbufGetBufferAttributesReply rep; + + MbufCheckExtension (dpy, info, 0); + + LockDisplay (dpy); + MbufGetReq (MbufGetBufferAttributes, req, info); + req->buffer = b; + if (!_XReply (dpy, (xReply *) &rep, 0, xTrue)) { + UnlockDisplay (dpy); + SyncHandle (); + return 0; + } + attr->window = rep.window; + attr->event_mask = rep.eventMask; + attr->buffer_index = rep.bufferIndex; + attr->side = rep.side; + + UnlockDisplay (dpy); + SyncHandle(); + return 1; +} + + +/* + * XmbufChangeBufferAttributes - + * Sets the attributes for the indicated buffer. This is currently + * limited to the event_mask. + */ +void XmbufChangeBufferAttributes (dpy, b, valuemask, attr) + Display *dpy; + Multibuffer b; + unsigned long valuemask; + XmbufSetBufferAttributes *attr; +{ + XExtDisplayInfo *info = find_display (dpy); + register xMbufSetBufferAttributesReq *req; + + MbufSimpleCheckExtension (dpy, info); + + LockDisplay (dpy); + MbufGetReq (MbufSetBufferAttributes, req, info); + req->buffer = b; + if ((req->valueMask = valuemask)) { /* stolen from lib/X/XWindow.c */ + unsigned long values[1]; /* one per element in if stmts below */ + unsigned long *v = values; + unsigned int nvalues; + + if (valuemask & MultibufferBufferEventMask) + *v++ = attr->event_mask; + req->length += (nvalues = v - values); + nvalues <<= 2; /* watch out for macros... */ + Data32 (dpy, (long *) values, (long)nvalues); + } + UnlockDisplay (dpy); + SyncHandle(); +} + + + +/* + * XmbufGetScreenInfo - + * Gets the parameters controlling how mono and stereo windows may be + * created on the indicated screen. The numbers of sets of visual and + * depths are returned in nmono_return and nstereo_return. If + * nmono_return is greater than zero, then mono_info_return is set to + * the address of an array of XmbufBufferInfo structures describing the + * various visuals and depths that may be used. Otherwise, + * mono_info_return is set to NULL. Similarly, stereo_info_return is + * set according to nstereo_return. The storage returned in + * mono_info_return and stereo_info_return may be released by XFree. + * If no errors are encounted, non-zero will be returned. + */ +Status XmbufGetScreenInfo (dpy, d, nmono_return, mono_info_return, + nstereo_return, stereo_info_return) + Display *dpy; + Drawable d; + int *nmono_return; + XmbufBufferInfo **mono_info_return; + int *nstereo_return; + XmbufBufferInfo **stereo_info_return; +{ + XExtDisplayInfo *info = find_display (dpy); + register xMbufGetBufferInfoReq *req; + xMbufGetBufferInfoReply rep; + int nmono, nstereo; + XmbufBufferInfo *minfo, *sinfo; + + MbufCheckExtension (dpy, info, 0); + + LockDisplay (dpy); + MbufGetReq (MbufGetBufferInfo, req, info); + req->drawable = d; + if (!_XReply (dpy, (xReply *) &rep, 0, xFalse)) { + UnlockDisplay (dpy); + SyncHandle (); + return 0; + } + nmono = rep.normalInfo; + nstereo = rep.stereoInfo; + minfo = ((nmono > 0) ? read_buffer_info (dpy, nmono) : NULL); + sinfo = ((nstereo > 0) ? read_buffer_info (dpy, nstereo) : NULL); + + /* check for bad reads indicating we need to return an error */ + if ((nmono > 0 && !minfo) || (nstereo > 0 && !sinfo)) { + if (minfo) Xfree ((char *) minfo); + if (sinfo) Xfree ((char *) sinfo); + UnlockDisplay (dpy); + SyncHandle(); + return 0; + } + + *nmono_return = nmono; + *mono_info_return = minfo; + *nstereo_return = nstereo; + *stereo_info_return = sinfo; + + UnlockDisplay (dpy); + SyncHandle(); + return 1; +} + + +/* + * XmbufCreateStereoWindow - + * Creates a stereo window in the same way that XCreateWindow creates + * a mono window (in fact, use the same code, except for the request) + * and returns the left and right buffers that may be + */ +Window XmbufCreateStereoWindow (dpy, parent, x, y, width, height, border_width, + depth, class, visual, valuemask, attr, + leftp, rightp) + Display *dpy; + Window parent; + int x, y; + unsigned int width, height, border_width; + int depth; + unsigned int class; + Visual *visual; + unsigned long valuemask; + XSetWindowAttributes *attr; + Multibuffer *leftp, *rightp; +{ + XExtDisplayInfo *info = find_display (dpy); + Window wid; + register xMbufCreateStereoWindowReq *req; + + MbufCheckExtension (dpy, info, None); + + LockDisplay(dpy); + MbufGetReq(MbufCreateStereoWindow, req, info); + wid = req->wid = XAllocID(dpy); + req->parent = parent; + req->left = *leftp = XAllocID (dpy); + req->right = *rightp = XAllocID (dpy); + req->x = x; + req->y = y; + req->width = width; + req->height = height; + req->borderWidth = border_width; + req->depth = depth; + req->class = class; + if (visual == CopyFromParent) + req->visual = CopyFromParent; + else + req->visual = visual->visualid; + valuemask &= (CWBackPixmap|CWBackPixel|CWBorderPixmap| + CWBorderPixel|CWBitGravity|CWWinGravity| + CWBackingStore|CWBackingPlanes|CWBackingPixel| + CWOverrideRedirect|CWSaveUnder|CWEventMask| + CWDontPropagate|CWColormap|CWCursor); + if ((req->mask = valuemask)) { + unsigned long values[32]; + register unsigned long *value = values; + unsigned int nvalues; + + if (valuemask & CWBackPixmap) + *value++ = attr->background_pixmap; + if (valuemask & CWBackPixel) + *value++ = attr->background_pixel; + if (valuemask & CWBorderPixmap) + *value++ = attr->border_pixmap; + if (valuemask & CWBorderPixel) + *value++ = attr->border_pixel; + if (valuemask & CWBitGravity) + *value++ = attr->bit_gravity; + if (valuemask & CWWinGravity) + *value++ = attr->win_gravity; + if (valuemask & CWBackingStore) + *value++ = attr->backing_store; + if (valuemask & CWBackingPlanes) + *value++ = attr->backing_planes; + if (valuemask & CWBackingPixel) + *value++ = attr->backing_pixel; + if (valuemask & CWOverrideRedirect) + *value++ = attr->override_redirect; + if (valuemask & CWSaveUnder) + *value++ = attr->save_under; + if (valuemask & CWEventMask) + *value++ = attr->event_mask; + if (valuemask & CWDontPropagate) + *value++ = attr->do_not_propagate_mask; + if (valuemask & CWColormap) + *value++ = attr->colormap; + if (valuemask & CWCursor) + *value++ = attr->cursor; + req->length += (nvalues = value - values); + + nvalues <<= 2; /* watch out for macros... */ + Data32 (dpy, (long *) values, (long)nvalues); + } + UnlockDisplay(dpy); + SyncHandle(); + return wid; +} + +void XmbufClearBufferArea (dpy, buffer, x, y, width, height, exposures) + Display *dpy; + Multibuffer buffer; + int x, y; + unsigned int width, height; + Bool exposures; +{ + XExtDisplayInfo *info = find_display (dpy); + register xMbufClearImageBufferAreaReq *req; + + MbufSimpleCheckExtension (dpy, info); + + LockDisplay (dpy); + MbufGetReq (MbufClearImageBufferArea, req, info); + req->buffer = buffer; + req->x = x; + req->y = y; + req->width = width; + req->height = height; + req->exposures = exposures; + UnlockDisplay (dpy); + SyncHandle(); +} + diff --git a/src/XSecurity.c b/src/XSecurity.c new file mode 100644 index 0000000..7d0de9b --- /dev/null +++ b/src/XSecurity.c @@ -0,0 +1,308 @@ +/* $Xorg: XSecurity.c,v 1.6 2001/02/09 02:03:49 xorgcvs Exp $ */ +/* + +Copyright 1996, 1998 The Open Group + +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. + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN +AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN +CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +Except as contained in this notice, the name of The Open Group shall not be +used in advertising or otherwise to promote the sale, use or other dealings +in this Software without prior written authorization from The Open Group. + +*/ +#include +#include "Xext.h" +#include "extutil.h" +#include "securstr.h" + +static XExtensionInfo _Security_info_data; +static XExtensionInfo *Security_info = &_Security_info_data; +static char *Security_extension_name = SECURITY_EXTENSION_NAME; + +#define SecurityCheckExtension(dpy,i,val) \ + XextCheckExtension (dpy, i, Security_extension_name, val) +#define SecuritySimpleCheckExtension(dpy,i) \ + XextSimpleCheckExtension (dpy, i, Security_extension_name) + +#define SecurityGetReq(name,req,info) GetReq (name, req); \ + req->reqType = info->codes->major_opcode; \ + req->securityReqType = X_##name; + +/***************************************************************************** + * * + * private utility routines * + * * + *****************************************************************************/ + +/* + * find_display - locate the display info block + */ +static int close_display(); +static Bool wire_to_event(); +static Status event_to_wire(); +static char *error_string(); +static XExtensionHooks Security_extension_hooks = { + NULL, /* create_gc */ + NULL, /* copy_gc */ + NULL, /* flush_gc */ + NULL, /* free_gc */ + NULL, /* create_font */ + NULL, /* free_font */ + close_display, /* close_display */ + wire_to_event, /* wire_to_event */ + event_to_wire, /* event_to_wire */ + NULL, /* error */ + error_string /* error_string */ +}; + +static char *security_error_list[] = { + "BadAuthorization" + "BadAuthorizationProtocol" +}; + +static XEXT_GENERATE_FIND_DISPLAY (find_display, Security_info, + Security_extension_name, + &Security_extension_hooks, + XSecurityNumberEvents, NULL) + +static XEXT_GENERATE_CLOSE_DISPLAY (close_display, Security_info) + +static +XEXT_GENERATE_ERROR_STRING(error_string, Security_extension_name, + XSecurityNumberErrors, security_error_list) + +static Bool +wire_to_event(dpy, event, wire) + Display *dpy; + XEvent *event; + xEvent *wire; +{ + XExtDisplayInfo *info = find_display(dpy); + + SecurityCheckExtension (dpy, info, False); + + switch ((wire->u.u.type & 0x7F) - info->codes->first_event) + { + case XSecurityAuthorizationRevoked: + { + xSecurityAuthorizationRevokedEvent *rwire = + (xSecurityAuthorizationRevokedEvent *)wire; + XSecurityAuthorizationRevokedEvent *revent = + (XSecurityAuthorizationRevokedEvent *)event; + + revent->type = rwire->type & 0x7F; + revent->serial = _XSetLastRequestRead(dpy, + (xGenericReply *) wire); + revent->send_event = (rwire->type & 0x80) != 0; + revent->display = dpy; + revent->auth_id = rwire->authId; + return True; + } + } + return False; +} + +static Status +event_to_wire(dpy, event, wire) + Display *dpy; + XEvent *event; + xEvent *wire; +{ + XExtDisplayInfo *info = find_display(dpy); + + SecurityCheckExtension(dpy, info, False); + + switch ((event->type & 0x7F) - info->codes->first_event) + { + case XSecurityAuthorizationRevoked: + { + xSecurityAuthorizationRevokedEvent *rwire = + (xSecurityAuthorizationRevokedEvent *)wire; + XSecurityAuthorizationRevokedEvent *revent = + (XSecurityAuthorizationRevokedEvent *)event; + rwire->type = revent->type | (revent->send_event ? 0x80 : 0); + rwire->sequenceNumber = revent->serial & 0xFFFF; + return True; + } + } + return False; +} + +/***************************************************************************** + * * + * Security public interfaces * + * * + *****************************************************************************/ + +Status XSecurityQueryExtension ( + Display *dpy, + int *major_version_return, + int *minor_version_return) +{ + XExtDisplayInfo *info = find_display (dpy); + xSecurityQueryVersionReply rep; + register xSecurityQueryVersionReq *req; + + if (!XextHasExtension (info)) + return (Status)0; /* failure */ + + LockDisplay (dpy); + SecurityGetReq (SecurityQueryVersion, req, info); + req->majorVersion = SECURITY_MAJOR_VERSION; + req->minorVersion = SECURITY_MINOR_VERSION; + + if (!_XReply (dpy, (xReply *) &rep, 0, xTrue)) { + UnlockDisplay (dpy); + SyncHandle (); + return (Status)0; /* failure */ + } + *major_version_return = rep.majorVersion; + *minor_version_return = rep.minorVersion; + UnlockDisplay (dpy); + + SyncHandle (); + + if (*major_version_return != SECURITY_MAJOR_VERSION) + return (Status)0; /* failure */ + else + return (Status)1; /* success */ +} + +Xauth * +XSecurityAllocXauth(void) +{ + return Xcalloc(1, sizeof(Xauth)); +} + +void +XSecurityFreeXauth(Xauth *auth) +{ + XFree(auth); +} + +static int +Ones(Mask mask) +{ + register Mask y; + + y = (mask >> 1) &033333333333; + y = mask - y - ((y >>1) & 033333333333); + return (((y + (y >> 3)) & 030707070707) % 077); +} + +Xauth * +XSecurityGenerateAuthorization( + Display *dpy, + Xauth *auth_in, + unsigned long valuemask, + XSecurityAuthorizationAttributes *attributes, + XSecurityAuthorization *auth_id_return) +{ + XExtDisplayInfo *info = find_display (dpy); + register xSecurityGenerateAuthorizationReq *req; + xSecurityGenerateAuthorizationReply rep; + Xauth *auth_return; + unsigned long values[3]; + unsigned long *value = values; + unsigned int nvalues; + + *auth_id_return = 0; /* in case we fail */ + + /* make sure extension is available */ + + SecurityCheckExtension (dpy, info, (Xauth *)NULL); + + LockDisplay(dpy); + SecurityGetReq(SecurityGenerateAuthorization, req, info); + + req->nbytesAuthProto = auth_in->name_length; + req->nbytesAuthData = auth_in->data_length; + + /* adjust length to account for auth name and data */ + req->length += (auth_in->name_length + (unsigned)3) >> 2; + req->length += (auth_in->data_length + (unsigned)3) >> 2; + + /* adjust length to account for list of values */ + req->valueMask = valuemask & XSecurityAllAuthorizationAttributes; + nvalues = Ones(req->valueMask); + req->length += nvalues; + + /* send auth name and data */ + Data(dpy, auth_in->name, auth_in->name_length); + Data(dpy, auth_in->data, auth_in->data_length); + + /* send values */ + if (valuemask & XSecurityTimeout) *value++ = attributes->timeout; + if (valuemask & XSecurityTrustLevel) *value++ = attributes->trust_level; + if (valuemask & XSecurityGroup) *value++ = attributes->group; + if (valuemask & XSecurityEventMask) *value++ = attributes->event_mask; + + nvalues <<= 2; + Data32(dpy, (long *)values, (long)nvalues); + + if (!_XReply (dpy, (xReply *) &rep, 0, xFalse)) { + UnlockDisplay (dpy); + SyncHandle (); + return (Xauth *)NULL; + } + + *auth_id_return = rep.authId; + + /* Allocate space for the Xauth struct and the auth name and data all + * in one hunk. This lets XSecurityFreeXauth not have to care + * about whether the auth was allocated here or in + * XSecurityAllocXauth; in both cases, you just free one pointer. + */ + + if ((auth_return = (Xauth *)Xcalloc(1, + (sizeof(Xauth) + auth_in->name_length + rep.dataLength)))) + { + auth_return->data_length = rep.dataLength; + auth_return->data = (char *)&auth_return[1]; + _XReadPad(dpy, auth_return->data, (long)rep.dataLength); + + auth_return->name_length = auth_in->name_length; + auth_return->name = auth_return->data + auth_return->data_length; + memcpy(auth_return->name, auth_in->name, auth_return->name_length); + } + else + { + _XEatData(dpy, (unsigned long) (rep.dataLength + 3) & ~3); + } + + UnlockDisplay (dpy); + SyncHandle (); + return auth_return; + +} /* XSecurityGenerateAuthorization */ + +Status +XSecurityRevokeAuthorization( + Display *dpy, + XSecurityAuthorization auth_id) +{ + XExtDisplayInfo *info = find_display (dpy); + xSecurityRevokeAuthorizationReq *req; + + SecurityCheckExtension (dpy, info, 0); + LockDisplay(dpy); + SecurityGetReq(SecurityRevokeAuthorization, req, info); + req->authId = auth_id; + UnlockDisplay (dpy); + SyncHandle (); + return 1; +} /* XSecurityRevokeAuthorization */ diff --git a/src/XShape.c b/src/XShape.c new file mode 100644 index 0000000..ba09d68 --- /dev/null +++ b/src/XShape.c @@ -0,0 +1,493 @@ +/* + * $Xorg: XShape.c,v 1.4 2001/02/09 02:03:49 xorgcvs Exp $ + * +Copyright 1989, 1998 The Open Group + +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. + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN +AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN +CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +Except as contained in this notice, the name of The Open Group shall not be +used in advertising or otherwise to promote the sale, use or other dealings +in this Software without prior written authorization from The Open Group. + * + * Author: Keith Packard, MIT X Consortium + */ +#define NEED_EVENTS +#define NEED_REPLIES +#include +#include +#include "region.h" /* in Xlib sources */ +#include "Xext.h" /* in ../include */ +#include "extutil.h" /* in ../include */ +#include "shapestr.h" /* in ../include */ + +static XExtensionInfo _shape_info_data; +static XExtensionInfo *shape_info = &_shape_info_data; +static /* const */ char *shape_extension_name = SHAPENAME; + +#define ShapeCheckExtension(dpy,i,val) \ + XextCheckExtension (dpy, i, shape_extension_name, val) +#define ShapeSimpleCheckExtension(dpy,i) \ + XextSimpleCheckExtension (dpy, i, shape_extension_name) + + +/***************************************************************************** + * * + * private utility routines * + * * + *****************************************************************************/ + +static int close_display(); +static Bool wire_to_event(); +static Status event_to_wire(); +static /* const */ XExtensionHooks shape_extension_hooks = { + NULL, /* create_gc */ + NULL, /* copy_gc */ + NULL, /* flush_gc */ + NULL, /* free_gc */ + NULL, /* create_font */ + NULL, /* free_font */ + close_display, /* close_display */ + wire_to_event, /* wire_to_event */ + event_to_wire, /* event_to_wire */ + NULL, /* error */ + NULL, /* error_string */ +}; + +static XEXT_GENERATE_FIND_DISPLAY (find_display, shape_info, + shape_extension_name, + &shape_extension_hooks, + ShapeNumberEvents, NULL) + +static XEXT_GENERATE_CLOSE_DISPLAY (close_display, shape_info) + + +static Bool wire_to_event (dpy, re, event) + Display *dpy; + XEvent *re; + xEvent *event; +{ + XExtDisplayInfo *info = find_display (dpy); + XShapeEvent *se; + xShapeNotifyEvent *sevent; + + ShapeCheckExtension (dpy, info, False); + + switch ((event->u.u.type & 0x7f) - info->codes->first_event) { + case ShapeNotify: + se = (XShapeEvent *) re; + sevent = (xShapeNotifyEvent *) event; + se->type = sevent->type & 0x7f; + se->serial = _XSetLastRequestRead(dpy,(xGenericReply *) event); + se->send_event = (sevent->type & 0x80) != 0; + se->display = dpy; + se->window = sevent->window; + se->kind = sevent->kind; + se->x = cvtINT16toInt (sevent->x); + se->y = cvtINT16toInt (sevent->y); + se->width = sevent->width; + se->height = sevent->height; + se->time = sevent->time; + se->shaped = True; + if (sevent->shaped == xFalse) + se->shaped = False; + return True; + } + return False; +} + +static Status event_to_wire (dpy, re, event) + Display *dpy; + XEvent *re; + xEvent *event; +{ + XExtDisplayInfo *info = find_display (dpy); + XShapeEvent *se; + xShapeNotifyEvent *sevent; + + ShapeCheckExtension (dpy, info, 0); + + switch ((re->type & 0x7f) - info->codes->first_event) { + case ShapeNotify: + se = (XShapeEvent *) re; + sevent = (xShapeNotifyEvent *) event; + sevent->type = se->type | (se->send_event ? 0x80 : 0); + sevent->sequenceNumber = se->serial & 0xffff; + sevent->window = se->window; + sevent->kind = se->kind; + sevent->x = se->x; + sevent->y = se->y; + sevent->width = se->width; + sevent->height = se->height; + sevent->time = se->time; + return 1; + } + return 0; +} + + +/**************************************************************************** + * * + * Shape public interfaces * + * * + ****************************************************************************/ + +Bool XShapeQueryExtension (dpy, event_basep, error_basep) + Display *dpy; + int *event_basep, *error_basep; +{ + XExtDisplayInfo *info = find_display (dpy); + + if (XextHasExtension(info)) { + *event_basep = info->codes->first_event; + *error_basep = info->codes->first_error; + return True; + } else { + return False; + } +} + + +Status XShapeQueryVersion(dpy, major_versionp, minor_versionp) + Display *dpy; + int *major_versionp, *minor_versionp; +{ + XExtDisplayInfo *info = find_display (dpy); + xShapeQueryVersionReply rep; + register xShapeQueryVersionReq *req; + + ShapeCheckExtension (dpy, info, 0); + + LockDisplay (dpy); + GetReq (ShapeQueryVersion, req); + req->reqType = info->codes->major_opcode; + req->shapeReqType = X_ShapeQueryVersion; + if (!_XReply (dpy, (xReply *) &rep, 0, xTrue)) { + UnlockDisplay (dpy); + SyncHandle (); + return 0; + } + *major_versionp = rep.majorVersion; + *minor_versionp = rep.minorVersion; + UnlockDisplay (dpy); + SyncHandle (); + return 1; +} + +void XShapeCombineRegion(dpy, dest, destKind, xOff, yOff, r, op) +register Display *dpy; +Window dest; +int destKind, op, xOff, yOff; +register REGION *r; +{ + XExtDisplayInfo *info = find_display (dpy); + register xShapeRectanglesReq *req; + register long nbytes; + register int i; + register XRectangle *xr, *pr; + register BOX *pb; + + ShapeSimpleCheckExtension (dpy, info); + + LockDisplay(dpy); + GetReq(ShapeRectangles, req); + xr = (XRectangle *) + _XAllocScratch(dpy, (unsigned long)(r->numRects * sizeof (XRectangle))); + for (pr = xr, pb = r->rects, i = r->numRects; --i >= 0; pr++, pb++) { + pr->x = pb->x1; + pr->y = pb->y1; + pr->width = pb->x2 - pb->x1; + pr->height = pb->y2 - pb->y1; + } + req->reqType = info->codes->major_opcode; + req->shapeReqType = X_ShapeRectangles; + req->op = op; + req->ordering = YXBanded; + req->destKind = destKind; + req->dest = dest; + req->xOff = xOff; + req->yOff = yOff; + + /* SIZEOF(xRectangle) will be a multiple of 4 */ + req->length += r->numRects * (SIZEOF(xRectangle) / 4); + + nbytes = r->numRects * sizeof(xRectangle); + + Data16 (dpy, (short *) xr, nbytes); + UnlockDisplay(dpy); + SyncHandle(); +} + + +void XShapeCombineRectangles (dpy, dest, destKind, xOff, yOff, + rects, n_rects, op, ordering) +register Display *dpy; +XID dest; +int destKind, op, xOff, yOff, ordering; +XRectangle *rects; +int n_rects; +{ + XExtDisplayInfo *info = find_display (dpy); + register xShapeRectanglesReq *req; + register long nbytes; + + ShapeSimpleCheckExtension (dpy, info); + + LockDisplay(dpy); + GetReq(ShapeRectangles, req); + req->reqType = info->codes->major_opcode; + req->shapeReqType = X_ShapeRectangles; + req->op = op; + req->ordering = ordering; + req->destKind = destKind; + req->dest = dest; + req->xOff = xOff; + req->yOff = yOff; + + /* SIZEOF(xRectangle) will be a multiple of 4 */ + req->length += n_rects * (SIZEOF(xRectangle) / 4); + + nbytes = n_rects * sizeof(xRectangle); + + Data16 (dpy, (short *) rects, nbytes); + UnlockDisplay(dpy); + SyncHandle(); +} + + +void XShapeCombineMask (dpy, dest, destKind, xOff, yOff, src, op) +register Display *dpy; +int destKind; +XID dest; +Pixmap src; +int op, xOff, yOff; +{ + XExtDisplayInfo *info = find_display (dpy); + register xShapeMaskReq *req; + + ShapeSimpleCheckExtension (dpy, info); + + LockDisplay(dpy); + GetReq(ShapeMask, req); + req->reqType = info->codes->major_opcode; + req->shapeReqType = X_ShapeMask; + req->op = op; + req->destKind = destKind; + req->dest = dest; + req->xOff = xOff; + req->yOff = yOff; + req->src = src; + UnlockDisplay(dpy); + SyncHandle(); +} + +void XShapeCombineShape (dpy, dest, destKind, xOff, yOff, src, srcKind, op) +register Display *dpy; +int destKind; +XID dest; +int srcKind; +XID src; +int op, xOff, yOff; +{ + XExtDisplayInfo *info = find_display (dpy); + register xShapeCombineReq *req; + + ShapeSimpleCheckExtension (dpy, info); + + LockDisplay(dpy); + GetReq(ShapeCombine, req); + req->reqType = info->codes->major_opcode; + req->shapeReqType = X_ShapeCombine; + req->op = op; + req->destKind = destKind; + req->srcKind = srcKind; + req->dest = dest; + req->xOff = xOff; + req->yOff = yOff; + req->src = src; + UnlockDisplay(dpy); + SyncHandle(); +} + +void XShapeOffsetShape (dpy, dest, destKind, xOff, yOff) +register Display *dpy; +int destKind; +XID dest; +int xOff, yOff; +{ + XExtDisplayInfo *info = find_display (dpy); + register xShapeOffsetReq *req; + + ShapeSimpleCheckExtension (dpy, info); + + LockDisplay(dpy); + GetReq(ShapeOffset, req); + req->reqType = info->codes->major_opcode; + req->shapeReqType = X_ShapeOffset; + req->destKind = destKind; + req->dest = dest; + req->xOff = xOff; + req->yOff = yOff; + UnlockDisplay(dpy); + SyncHandle(); +} + +Status XShapeQueryExtents (dpy, window, + bShaped, xbs, ybs, wbs, hbs, + cShaped, xcs, ycs, wcs, hcs) + register Display *dpy; + Window window; + int *bShaped, *cShaped; /* RETURN */ + int *xbs, *ybs, *xcs, *ycs; /* RETURN */ + unsigned int *wbs, *hbs, *wcs, *hcs; /* RETURN */ +{ + XExtDisplayInfo *info = find_display (dpy); + xShapeQueryExtentsReply rep; + register xShapeQueryExtentsReq *req; + + ShapeCheckExtension (dpy, info, 0); + + LockDisplay (dpy); + GetReq (ShapeQueryExtents, req); + req->reqType = info->codes->major_opcode; + req->shapeReqType = X_ShapeQueryExtents; + req->window = window; + if (!_XReply (dpy, (xReply *) &rep, 0, xTrue)) { + UnlockDisplay (dpy); + SyncHandle (); + return 0; + } + *bShaped = rep.boundingShaped; + *cShaped = rep.clipShaped; + *xbs = cvtINT16toInt (rep.xBoundingShape); + *ybs = cvtINT16toInt (rep.yBoundingShape); + *wbs = rep.widthBoundingShape; + *hbs = rep.heightBoundingShape; + *xcs = cvtINT16toInt (rep.xClipShape); + *ycs = cvtINT16toInt (rep.yClipShape); + *wcs = rep.widthClipShape; + *hcs = rep.heightClipShape; + UnlockDisplay (dpy); + SyncHandle (); + return 1; +} + + +void XShapeSelectInput (dpy, window, mask) + register Display *dpy; + Window window; + unsigned long mask; +{ + XExtDisplayInfo *info = find_display (dpy); + register xShapeSelectInputReq *req; + + ShapeSimpleCheckExtension (dpy, info); + + LockDisplay (dpy); + GetReq (ShapeSelectInput, req); + req->reqType = info->codes->major_opcode; + req->shapeReqType = X_ShapeSelectInput; + req->window = window; + if (mask & ShapeNotifyMask) + req->enable = xTrue; + else + req->enable = xFalse; + UnlockDisplay (dpy); + SyncHandle (); +} + +unsigned long XShapeInputSelected (dpy, window) + register Display *dpy; + Window window; +{ + XExtDisplayInfo *info = find_display (dpy); + register xShapeInputSelectedReq *req; + xShapeInputSelectedReply rep; + + ShapeCheckExtension (dpy, info, False); + + LockDisplay (dpy); + GetReq (ShapeInputSelected, req); + req->reqType = info->codes->major_opcode; + req->shapeReqType = X_ShapeInputSelected; + req->window = window; + if (!_XReply (dpy, (xReply *) &rep, 0, xFalse)) { + UnlockDisplay (dpy); + SyncHandle (); + return False; + } + UnlockDisplay (dpy); + SyncHandle (); + return rep.enabled ? ShapeNotifyMask : 0L; +} + + +XRectangle *XShapeGetRectangles (dpy, window, kind, count, ordering) + register Display *dpy; + Window window; + int kind; + int *count; /* RETURN */ + int *ordering; /* RETURN */ +{ + XExtDisplayInfo *info = find_display (dpy); + register xShapeGetRectanglesReq *req; + xShapeGetRectanglesReply rep; + XRectangle *rects; + xRectangle *xrects; + int i; + + ShapeCheckExtension (dpy, info, (XRectangle *)NULL); + + LockDisplay (dpy); + GetReq (ShapeGetRectangles, req); + req->reqType = info->codes->major_opcode; + req->shapeReqType = X_ShapeGetRectangles; + req->window = window; + req->kind = kind; + if (!_XReply (dpy, (xReply *) &rep, 0, xFalse)) { + UnlockDisplay (dpy); + SyncHandle (); + return (XRectangle *)NULL; + } + *count = rep.nrects; + *ordering = rep.ordering; + rects = 0; + if (*count) { + xrects = (xRectangle *) Xmalloc (*count * sizeof (xRectangle)); + rects = (XRectangle *) Xmalloc (*count * sizeof (XRectangle)); + if (!xrects || !rects) { + if (xrects) + Xfree (xrects); + if (rects) + Xfree (rects); + _XEatData (dpy, *count * sizeof (xRectangle)); + rects = 0; + *count = 0; + } else { + _XRead (dpy, (char *) xrects, *count * sizeof (xRectangle)); + for (i = 0; i < *count; i++) { + rects[i].x = (short) cvtINT16toInt (xrects[i].x); + rects[i].y = (short) cvtINT16toInt (xrects[i].y); + rects[i].width = xrects[i].width; + rects[i].height = xrects[i].height; + } + Xfree (xrects); + } + } + UnlockDisplay (dpy); + SyncHandle (); + return rects; +} diff --git a/src/XShm.c b/src/XShm.c new file mode 100644 index 0000000..4bdea55 --- /dev/null +++ b/src/XShm.c @@ -0,0 +1,444 @@ +/* + * $Xorg: XShm.c,v 1.4 2001/02/09 02:03:49 xorgcvs Exp $ + * +Copyright 1989, 1998 The Open Group + +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. + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN +AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN +CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +Except as contained in this notice, the name of The Open Group shall not be +used in advertising or otherwise to promote the sale, use or other dealings +in this Software without prior written authorization from The Open Group. + * + * Author: Bob Scheifler and Keith Packard, MIT X Consortium + */ + +/* THIS IS NOT AN X CONSORTIUM STANDARD OR AN X PROJECT TEAM SPECIFICATION */ + +#define NEED_EVENTS +#define NEED_REPLIES +#include "Xlibint.h" +#include "XShm.h" +#include "shmstr.h" +#include "Xext.h" +#include "extutil.h" + +static XExtensionInfo _shm_info_data; +static XExtensionInfo *shm_info = &_shm_info_data; +static /* const */ char *shm_extension_name = SHMNAME; + +#define ShmCheckExtension(dpy,i,val) \ + XextCheckExtension (dpy, i, shm_extension_name, val) + +/***************************************************************************** + * * + * private utility routines * + * * + *****************************************************************************/ + +static int close_display(); +static char *error_string(); +static Bool wire_to_event(); +static Status event_to_wire(); +static /* const */ XExtensionHooks shm_extension_hooks = { + NULL, /* create_gc */ + NULL, /* copy_gc */ + NULL, /* flush_gc */ + NULL, /* free_gc */ + NULL, /* create_font */ + NULL, /* free_font */ + close_display, /* close_display */ + wire_to_event, /* wire_to_event */ + event_to_wire, /* event_to_wire */ + NULL, /* error */ + error_string, /* error_string */ +}; + +static /* const */ char *shm_error_list[] = { + "BadShmSeg", /* BadShmSeg */ +}; + +static XEXT_GENERATE_FIND_DISPLAY (find_display, shm_info, shm_extension_name, + &shm_extension_hooks, ShmNumberEvents, NULL) + +static XEXT_GENERATE_CLOSE_DISPLAY (close_display, shm_info) + +static XEXT_GENERATE_ERROR_STRING (error_string, shm_extension_name, + ShmNumberErrors, shm_error_list) + + +static Bool wire_to_event (dpy, re, event) + Display *dpy; + XEvent *re; + xEvent *event; +{ + XExtDisplayInfo *info = find_display (dpy); + XShmCompletionEvent *se; + xShmCompletionEvent *sevent; + + ShmCheckExtension (dpy, info, False); + + switch ((event->u.u.type & 0x7f) - info->codes->first_event) { + case ShmCompletion: + se = (XShmCompletionEvent *) re; + sevent = (xShmCompletionEvent *) event; + se->type = sevent->type & 0x7f; + se->serial = _XSetLastRequestRead(dpy,(xGenericReply *) event); + se->send_event = (sevent->type & 0x80) != 0; + se->display = dpy; + se->drawable = sevent->drawable; + se->major_code = sevent->majorEvent; + se->minor_code = sevent->minorEvent; + se->shmseg = sevent->shmseg; + se->offset = sevent->offset; + return True; + } + return False; +} + +static Status event_to_wire (dpy, re, event) + Display *dpy; + XEvent *re; + xEvent *event; +{ + XExtDisplayInfo *info = find_display (dpy); + XShmCompletionEvent *se; + xShmCompletionEvent *sevent; + + ShmCheckExtension (dpy, info, 0); + + switch ((re->type & 0x7f) - info->codes->first_event) { + case ShmCompletion: + se = (XShmCompletionEvent *) re; + sevent = (xShmCompletionEvent *) event; + sevent->type = se->type | (se->send_event ? 0x80 : 0); + sevent->sequenceNumber = se->serial & 0xffff; + sevent->drawable = se->drawable; + sevent->majorEvent = se->major_code; + sevent->minorEvent = se->minor_code; + sevent->shmseg = se->shmseg; + sevent->offset = se->offset; + return True; + } + return False; +} + +/***************************************************************************** + * * + * public Shared Memory Extension routines * + * * + *****************************************************************************/ + +Bool XShmQueryExtension (dpy /* event_basep, error_basep */) + Display *dpy; +/* int *event_basep, *error_basep; */ +{ + XExtDisplayInfo *info = find_display (dpy); + + if (XextHasExtension(info)) { +/* *event_basep = info->codes->first_event; + *error_basep = info->codes->error_event; */ + return True; + } else { + return False; + } +} + + +int XShmGetEventBase(dpy) + Display *dpy; +{ + XExtDisplayInfo *info = find_display (dpy); + + if (XextHasExtension(info)) { + return info->codes->first_event; + } else { + return -1; + } +} + + +Bool XShmQueryVersion(dpy, majorVersion, minorVersion, sharedPixmaps) + Display *dpy; + int *majorVersion, *minorVersion; + Bool *sharedPixmaps; +{ + XExtDisplayInfo *info = find_display (dpy); + xShmQueryVersionReply rep; + register xShmQueryVersionReq *req; + + ShmCheckExtension (dpy, info, False); + + LockDisplay(dpy); + GetReq(ShmQueryVersion, req); + req->reqType = info->codes->major_opcode; + req->shmReqType = X_ShmQueryVersion; + if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) { + UnlockDisplay(dpy); + SyncHandle(); + return False; + } + *majorVersion = rep.majorVersion; + *minorVersion = rep.minorVersion; + *sharedPixmaps = rep.sharedPixmaps ? True : False; + UnlockDisplay(dpy); + SyncHandle(); + return True; +} + + +int XShmPixmapFormat(dpy) + Display *dpy; +{ + XExtDisplayInfo *info = find_display (dpy); + xShmQueryVersionReply rep; + register xShmQueryVersionReq *req; + + ShmCheckExtension (dpy, info, False); + + LockDisplay(dpy); + GetReq(ShmQueryVersion, req); + req->reqType = info->codes->major_opcode; + req->shmReqType = X_ShmQueryVersion; + if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) { + UnlockDisplay(dpy); + SyncHandle(); + return 0; + } + UnlockDisplay(dpy); + SyncHandle(); + if (rep.sharedPixmaps && + (rep.majorVersion > 1 || rep.minorVersion > 0)) + return rep.pixmapFormat; + return 0; +} + + +Status XShmAttach(dpy, shminfo) + Display *dpy; + XShmSegmentInfo *shminfo; +{ + XExtDisplayInfo *info = find_display (dpy); + register xShmAttachReq *req; + + ShmCheckExtension (dpy, info, 0); + + shminfo->shmseg = XAllocID(dpy); + LockDisplay(dpy); + GetReq(ShmAttach, req); + req->reqType = info->codes->major_opcode; + req->shmReqType = X_ShmAttach; + req->shmseg = shminfo->shmseg; + req->shmid = shminfo->shmid; + req->readOnly = shminfo->readOnly ? xTrue : xFalse; + UnlockDisplay(dpy); + SyncHandle(); + return 1; +} + + +Status XShmDetach(dpy, shminfo) + Display *dpy; + XShmSegmentInfo *shminfo; +{ + XExtDisplayInfo *info = find_display (dpy); + register xShmDetachReq *req; + + ShmCheckExtension (dpy, info, 0); + + LockDisplay(dpy); + GetReq(ShmDetach, req); + req->reqType = info->codes->major_opcode; + req->shmReqType = X_ShmDetach; + req->shmseg = shminfo->shmseg; + UnlockDisplay(dpy); + SyncHandle(); + return 1; +} + +static int _XShmDestroyImage (ximage) + XImage *ximage; + +{ + Xfree((char *)ximage); + return 1; +} + +#define ROUNDUP(nbytes, pad) ((((nbytes) + ((pad) - 1)) / (pad)) * (pad)) + +XImage *XShmCreateImage (dpy, visual, depth, format, data, shminfo, + width, height) + register Display *dpy; + register Visual *visual; + unsigned int depth; + int format; + char *data; + XShmSegmentInfo *shminfo; + unsigned int width; + unsigned int height; +{ + register XImage *image; + + image = (XImage *)Xcalloc(1, (unsigned)sizeof(XImage)); + if (!image) + return image; + image->data = data; + image->obdata = (char *)shminfo; + image->width = width; + image->height = height; + image->depth = depth; + image->format = format; + image->byte_order = dpy->byte_order; + image->bitmap_unit = dpy->bitmap_unit; + image->bitmap_bit_order = dpy->bitmap_bit_order; + image->bitmap_pad = _XGetScanlinePad(dpy, depth); + image->xoffset = 0; + if (visual) { + image->red_mask = visual->red_mask; + image->green_mask = visual->green_mask; + image->blue_mask = visual->blue_mask; + } else { + image->red_mask = image->green_mask = image->blue_mask = 0; + } + if (format == ZPixmap) + image->bits_per_pixel = _XGetBitsPerPixel(dpy, (int)depth); + else + image->bits_per_pixel = 1; + image->bytes_per_line = ROUNDUP((image->bits_per_pixel * width), + image->bitmap_pad) >> 3; + _XInitImageFuncPtrs(image); + image->f.destroy_image = _XShmDestroyImage; + return image; +} + +Status XShmPutImage (dpy, d, gc, image, src_x, src_y, dst_x, dst_y, + src_width, src_height, send_event) + register Display *dpy; + Drawable d; + GC gc; + register XImage *image; + int src_x, src_y, dst_x, dst_y; + unsigned int src_width, src_height; + Bool send_event; +{ + XExtDisplayInfo *info = find_display (dpy); + XShmSegmentInfo *shminfo = (XShmSegmentInfo *)image->obdata; + register xShmPutImageReq *req; + + ShmCheckExtension (dpy, info, 0); + if (!shminfo) return 0; + + LockDisplay(dpy); + FlushGC(dpy, gc); + GetReq(ShmPutImage, req); + req->reqType = info->codes->major_opcode; + req->shmReqType = X_ShmPutImage; + req->drawable = d; + req->gc = gc->gid; + req->srcX = src_x; + req->srcY = src_y; + req->srcWidth = src_width; + req->srcHeight = src_height; + req->dstX = dst_x; + req->dstY = dst_y; + req->totalWidth = image->width; + req->totalHeight = image->height; + req->depth = image->depth; + req->format = image->format; + req->sendEvent = send_event; + req->shmseg = shminfo->shmseg; + req->offset = image->data - shminfo->shmaddr; + UnlockDisplay(dpy); + SyncHandle(); + return 1; +} + + +Status XShmGetImage(dpy, d, image, x, y, plane_mask) + register Display *dpy; + Drawable d; + XImage *image; + int x, y; + unsigned long plane_mask; +{ + XExtDisplayInfo *info = find_display (dpy); + XShmSegmentInfo *shminfo = (XShmSegmentInfo *)image->obdata; + register xShmGetImageReq *req; + xShmGetImageReply rep; + register Visual *visual; + + ShmCheckExtension (dpy, info, 0); + if (!shminfo) return 0; + + LockDisplay(dpy); + GetReq(ShmGetImage, req); + req->reqType = info->codes->major_opcode; + req->shmReqType = X_ShmGetImage; + req->drawable = d; + req->x = x; + req->y = y; + req->width = image->width; + req->height = image->height; + req->planeMask = plane_mask; + req->format = image->format; + req->shmseg = shminfo->shmseg; + req->offset = image->data - shminfo->shmaddr; + if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) { + UnlockDisplay(dpy); + SyncHandle(); + return 0; + } + visual = _XVIDtoVisual(dpy, rep.visual); + if (visual) { + image->red_mask = visual->red_mask; + image->green_mask = visual->green_mask; + image->blue_mask = visual->blue_mask; + } else { + image->red_mask = image->green_mask = image->blue_mask = 0; + } + UnlockDisplay(dpy); + SyncHandle(); + return 1; +} + +Pixmap XShmCreatePixmap (dpy, d, data, shminfo, width, height, depth) + register Display *dpy; + Drawable d; + char *data; + XShmSegmentInfo *shminfo; + unsigned int width, height, depth; +{ + XExtDisplayInfo *info = find_display (dpy); + Pixmap pid; + register xShmCreatePixmapReq *req; + + ShmCheckExtension (dpy, info, 0); + + LockDisplay(dpy); + GetReq(ShmCreatePixmap, req); + req->reqType = info->codes->major_opcode; + req->shmReqType = X_ShmCreatePixmap; + req->drawable = d; + req->width = width; + req->height = height; + req->depth = depth; + req->shmseg = shminfo->shmseg; + req->offset = data - shminfo->shmaddr; + pid = req->pid = XAllocID(dpy); + UnlockDisplay(dpy); + SyncHandle(); + return pid; +} diff --git a/src/XSync.c b/src/XSync.c new file mode 100644 index 0000000..fe17698 --- /dev/null +++ b/src/XSync.c @@ -0,0 +1,862 @@ +/* $Xorg: XSync.c,v 1.5 2001/02/09 02:03:49 xorgcvs Exp $ */ +/* + +Copyright 1991, 1993, 1998 The Open Group + +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. + +The above copyright notice and this permission notice shall be included +in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS +OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. +IN NO EVENT SHALL THE OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR +OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, +ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR +OTHER DEALINGS IN THE SOFTWARE. + +Except as contained in this notice, the name of The Open Group shall +not be used in advertising or otherwise to promote the sale, use or +other dealings in this Software without prior written authorization +from The Open Group. + +*/ + +/*********************************************************** +Copyright 1991,1993 by Digital Equipment Corporation, Maynard, Massachusetts, +and Olivetti Research Limited, Cambridge, England. + + All Rights Reserved + +Permission to use, copy, modify, and distribute this software and its +documentation for any purpose and without fee is hereby granted, +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 names of Digital or Olivetti +not be used in advertising or publicity pertaining to distribution of the +software without specific, written prior permission. + +DIGITAL AND OLIVETTI DISCLAIM ALL WARRANTIES WITH REGARD TO THIS +SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND +FITNESS, IN NO EVENT SHALL THEY 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. + +******************************************************************/ + +#include +#define NEED_EVENTS +#define NEED_REPLIES +#include "Xlibint.h" +#include "Xext.h" +#include "extutil.h" +#include "syncstr.h" + +static XExtensionInfo _sync_info_data; +static XExtensionInfo *sync_info = &_sync_info_data; +static char *sync_extension_name = SYNC_NAME; + +#define SyncCheckExtension(dpy,i,val) \ + XextCheckExtension(dpy, i, sync_extension_name, val) +#define SyncSimpleCheckExtension(dpy,i) \ + XextSimpleCheckExtension(dpy, i, sync_extension_name) + +static int close_display(); +static Bool wire_to_event(); +static Status event_to_wire(); +static char *error_string(); + +static XExtensionHooks sync_extension_hooks = { + NULL, /* create_gc */ + NULL, /* copy_gc */ + NULL, /* flush_gc */ + NULL, /* free_gc */ + NULL, /* create_font */ + NULL, /* free_font */ + close_display, /* close_display */ + wire_to_event, /* wire_to_event */ + event_to_wire, /* event_to_wire */ + NULL, /* error */ + error_string, /* error_string */ +}; + +static char *sync_error_list[] = { + "BadCounter", + "BadAlarm", +}; + +static +XEXT_GENERATE_FIND_DISPLAY(find_display, sync_info, + sync_extension_name, + &sync_extension_hooks, + XSyncNumberEvents, (XPointer) NULL) + +static +XEXT_GENERATE_CLOSE_DISPLAY(close_display, sync_info) + +static +XEXT_GENERATE_ERROR_STRING(error_string, sync_extension_name, + XSyncNumberErrors, sync_error_list) + + +static Bool +wire_to_event(dpy, event, wire) + Display *dpy; + XEvent *event; + xEvent *wire; +{ + XExtDisplayInfo *info = find_display(dpy); + XSyncCounterNotifyEvent *aevent; + xSyncCounterNotifyEvent *awire; + XSyncAlarmNotifyEvent *anl; + xSyncAlarmNotifyEvent *ane; + + SyncCheckExtension(dpy, info, False); + + switch ((wire->u.u.type & 0x7F) - info->codes->first_event) + { + case XSyncCounterNotify: + awire = (xSyncCounterNotifyEvent *) wire; + aevent = (XSyncCounterNotifyEvent *) event; + aevent->type = awire->type & 0x7F; + aevent->serial = _XSetLastRequestRead(dpy, + (xGenericReply *) wire); + aevent->send_event = (awire->type & 0x80) != 0; + aevent->display = dpy; + aevent->counter = awire->counter; + XSyncIntsToValue(&aevent->wait_value, awire->wait_value_lo, + awire->wait_value_hi); + XSyncIntsToValue(&aevent->counter_value, + awire->counter_value_lo, + awire->counter_value_hi); + aevent->time = awire->time; + aevent->count = awire->count; + aevent->destroyed = awire->destroyed; + return True; + + case XSyncAlarmNotify: + ane = (xSyncAlarmNotifyEvent *) wire; /* ENCODING EVENT PTR */ + anl = (XSyncAlarmNotifyEvent *) event; /* LIBRARY EVENT PTR */ + anl->type = ane->type & 0x7F; + anl->serial = _XSetLastRequestRead(dpy, + (xGenericReply *) wire); + anl->send_event = (ane->type & 0x80) != 0; + anl->display = dpy; + anl->alarm = ane->alarm; + XSyncIntsToValue(&anl->counter_value, + ane->counter_value_lo, + ane->counter_value_hi); + XSyncIntsToValue(&anl->alarm_value, + ane->alarm_value_lo, + ane->alarm_value_hi); + anl->state = ane->state; + anl->time = ane->time; + return True; + } + + return False; +} + +static Status +event_to_wire(dpy, event, wire) + Display *dpy; + XEvent *event; + xEvent *wire; +{ + XExtDisplayInfo *info = find_display(dpy); + XSyncCounterNotifyEvent *aevent; + xSyncCounterNotifyEvent *awire; + XSyncAlarmNotifyEvent *anl; + xSyncAlarmNotifyEvent *ane; + + SyncCheckExtension(dpy, info, False); + + switch ((event->type & 0x7F) - info->codes->first_event) + { + case XSyncCounterNotify: + awire = (xSyncCounterNotifyEvent *) wire; + aevent = (XSyncCounterNotifyEvent *) event; + awire->type = aevent->type | (aevent->send_event ? 0x80 : 0); + awire->sequenceNumber = aevent->serial & 0xFFFF; + awire->counter = aevent->counter; + awire->wait_value_lo = XSyncValueLow32(aevent->wait_value); + awire->wait_value_hi = XSyncValueHigh32(aevent->wait_value); + awire->counter_value_lo = XSyncValueLow32(aevent->counter_value); + awire->counter_value_hi = XSyncValueHigh32(aevent->counter_value); + awire->time = aevent->time; + awire->count = aevent->count; + awire->destroyed = aevent->destroyed; + return True; + + case XSyncAlarmNotify: + ane = (xSyncAlarmNotifyEvent *) wire; /* ENCODING EVENT PTR */ + anl = (XSyncAlarmNotifyEvent *) event; /* LIBRARY EVENT PTR */ + ane->type = anl->type | (anl->send_event ? 0x80 : 0); + ane->sequenceNumber = anl->serial & 0xFFFF; + ane->alarm = anl->alarm; + ane->counter_value_lo = XSyncValueLow32(anl->counter_value); + ane->counter_value_hi = XSyncValueHigh32(anl->counter_value); + ane->alarm_value_lo = XSyncValueLow32(anl->alarm_value); + ane->alarm_value_hi = XSyncValueHigh32(anl->alarm_value); + ane->state = anl->state; + ane->time = anl->time; + return True; + } + return False; +} + +Status +XSyncQueryExtension(dpy, event_base_return, error_base_return) + Display *dpy; + int *event_base_return, *error_base_return; +{ + XExtDisplayInfo *info = find_display(dpy); + + if (XextHasExtension(info)) + { + *event_base_return = info->codes->first_event; + *error_base_return = info->codes->first_error; + return True; + } + else + return False; +} + +Status +XSyncInitialize(dpy, major_version_return, minor_version_return) + Display *dpy; + int *major_version_return, *minor_version_return; +{ + XExtDisplayInfo *info = find_display(dpy); + xSyncInitializeReply rep; + xSyncInitializeReq *req; + + SyncCheckExtension(dpy, info, False); + + LockDisplay(dpy); + GetReq(SyncInitialize, req); + req->reqType = info->codes->major_opcode; + req->syncReqType = X_SyncInitialize; + req->majorVersion = SYNC_MAJOR_VERSION; + req->minorVersion = SYNC_MINOR_VERSION; + if (!_XReply(dpy, (xReply *) & rep, 0, xTrue)) + { + UnlockDisplay(dpy); + SyncHandle(); + return False; + } + UnlockDisplay(dpy); + SyncHandle(); + *major_version_return = rep.majorVersion; + *minor_version_return = rep.minorVersion; + return ((rep.majorVersion == SYNC_MAJOR_VERSION) +#if SYNC_MINOR_VERSION > 0 /* avoid compiler warning */ + && (rep.minorVersion >= SYNC_MINOR_VERSION) +#endif + ); +} + +XSyncSystemCounter * +XSyncListSystemCounters(dpy, n_counters_return) + Display *dpy; + int *n_counters_return; +{ + XExtDisplayInfo *info = find_display(dpy); + xSyncListSystemCountersReply rep; + xSyncListSystemCountersReq *req; + XSyncSystemCounter *list = NULL; + + SyncCheckExtension(dpy, info, NULL); + + LockDisplay(dpy); + GetReq(SyncListSystemCounters, req); + req->reqType = info->codes->major_opcode; + req->syncReqType = X_SyncListSystemCounters; + if (!_XReply(dpy, (xReply *) & rep, 0, xFalse)) + goto bail; + + *n_counters_return = rep.nCounters; + if (rep.nCounters > 0) + { + xSyncSystemCounter *pWireSysCounter, *pNextWireSysCounter; + XSyncCounter counter; + int replylen; + int i; + + list = (XSyncSystemCounter *)Xmalloc( + rep.nCounters * sizeof(XSyncSystemCounter)); + replylen = rep.length << 2; + pWireSysCounter = (xSyncSystemCounter *) Xmalloc ((unsigned) replylen + 1); + /* +1 to leave room for last null-terminator */ + + if ((!list) || (!pWireSysCounter)) + { + if (list) Xfree((char *) list); + if (pWireSysCounter) Xfree((char *) pWireSysCounter); + _XEatData(dpy, (unsigned long) replylen); + list = NULL; + goto bail; + } + + _XReadPad(dpy, (char *)pWireSysCounter, replylen); + + counter = pWireSysCounter->counter; + for (i = 0; i < rep.nCounters; i++) + { + list[i].counter = counter; + XSyncIntsToValue(&list[i].resolution, + pWireSysCounter->resolution_lo, + pWireSysCounter->resolution_hi); + + /* we may be about to clobber the counter field of the + * next syscounter because we have to add a null terminator + * to the counter name string. So we save the next counter + * here. + */ + pNextWireSysCounter = (xSyncSystemCounter *) + (((char *)pWireSysCounter) + ((SIZEOF(xSyncSystemCounter) + + pWireSysCounter->name_length + 3) & ~3)); + counter = pNextWireSysCounter->counter; + + list[i].name = ((char *)pWireSysCounter) + + SIZEOF(xSyncSystemCounter); + /* null-terminate the string */ + *(list[i].name + pWireSysCounter->name_length) = '\0'; + pWireSysCounter = pNextWireSysCounter; + } + } + +bail: + UnlockDisplay(dpy); + SyncHandle(); + return list; +} + +void +XSyncFreeSystemCounterList(list) + XSyncSystemCounter *list; +{ + if (list) + { + Xfree( ((char *)list[0].name) - SIZEOF(xSyncSystemCounter)); + Xfree(list); + } +} + + +XSyncCounter +XSyncCreateCounter(dpy, initial_value) + Display *dpy; + XSyncValue initial_value; +{ + XExtDisplayInfo *info = find_display(dpy); + xSyncCreateCounterReq *req; + + SyncCheckExtension(dpy, info, None); + + LockDisplay(dpy); + GetReq(SyncCreateCounter, req); + req->reqType = info->codes->major_opcode; + req->syncReqType = X_SyncCreateCounter; + + req->cid = XAllocID(dpy); + req->initial_value_lo = XSyncValueLow32(initial_value); + req->initial_value_hi = XSyncValueHigh32(initial_value); + + UnlockDisplay(dpy); + SyncHandle(); + return req->cid; +} + +Status +XSyncSetCounter(dpy, counter, value) + Display *dpy; + XSyncCounter counter; + XSyncValue value; +{ + XExtDisplayInfo *info = find_display(dpy); + xSyncSetCounterReq *req; + + SyncCheckExtension(dpy, info, False); + + LockDisplay(dpy); + GetReq(SyncSetCounter, req); + req->reqType = info->codes->major_opcode; + req->syncReqType = X_SyncSetCounter; + req->cid = counter; + req->value_lo = XSyncValueLow32(value); + req->value_hi = XSyncValueHigh32(value); + UnlockDisplay(dpy); + SyncHandle(); + return True; +} + +Status +XSyncChangeCounter(dpy, counter, value) + Display *dpy; + XSyncCounter counter; + XSyncValue value; +{ + XExtDisplayInfo *info = find_display(dpy); + xSyncChangeCounterReq *req; + + SyncCheckExtension(dpy, info, False); + + LockDisplay(dpy); + GetReq(SyncChangeCounter, req); + req->reqType = info->codes->major_opcode; + req->syncReqType = X_SyncChangeCounter; + req->cid = counter; + req->value_lo = XSyncValueLow32(value); + req->value_hi = XSyncValueHigh32(value); + UnlockDisplay(dpy); + SyncHandle(); + return True; +} + +Status +XSyncDestroyCounter(dpy, counter) + Display *dpy; + XSyncCounter counter; +{ + XExtDisplayInfo *info = find_display(dpy); + xSyncDestroyCounterReq *req; + + SyncCheckExtension(dpy, info, False); + + LockDisplay(dpy); + GetReq(SyncDestroyCounter, req); + req->reqType = info->codes->major_opcode; + req->syncReqType = X_SyncDestroyCounter; + req->counter = counter; + UnlockDisplay(dpy); + SyncHandle(); + + return True; +} + +Status +XSyncQueryCounter(dpy, counter, value_return) + Display *dpy; + XSyncCounter counter; + XSyncValue *value_return; +{ + XExtDisplayInfo *info = find_display(dpy); + xSyncQueryCounterReply rep; + xSyncQueryCounterReq *req; + + SyncCheckExtension(dpy, info, False); + + LockDisplay(dpy); + GetReq(SyncQueryCounter, req); + req->reqType = info->codes->major_opcode; + req->syncReqType = X_SyncQueryCounter; + req->counter = counter; + if (!_XReply(dpy, (xReply *) & rep, 0, xTrue)) + { + UnlockDisplay(dpy); + SyncHandle(); + return False; + } + XSyncIntsToValue(value_return, rep.value_lo, rep.value_hi); + UnlockDisplay(dpy); + SyncHandle(); + + return True; +} + + +Status +XSyncAwait(dpy, wait_list, n_conditions) + Display *dpy; + XSyncWaitCondition *wait_list; + int n_conditions; +{ + XExtDisplayInfo *info = find_display(dpy); + XSyncWaitCondition *wait_item = wait_list; + xSyncAwaitReq *req; + unsigned int len; + + SyncCheckExtension(dpy, info, False); + + LockDisplay(dpy); + GetReq(SyncAwait, req); + req->reqType = info->codes->major_opcode; + req->syncReqType = X_SyncAwait; + len = (n_conditions * SIZEOF(xSyncWaitCondition)) >> 2; + SetReqLen(req, len, len /* XXX */ ); + + while (n_conditions--) + { + xSyncWaitCondition wc; + wc.counter = wait_item->trigger.counter; + wc.value_type = wait_item->trigger.value_type; + wc.wait_value_lo = XSyncValueLow32(wait_item->trigger.wait_value); + wc.wait_value_hi = XSyncValueHigh32(wait_item->trigger.wait_value); + wc.test_type = wait_item->trigger.test_type; + wc.event_threshold_lo = XSyncValueLow32(wait_item->event_threshold); + wc.event_threshold_hi = XSyncValueHigh32(wait_item->event_threshold); + Data(dpy, (char *)&wc, SIZEOF(xSyncWaitCondition)); + wait_item++; /* get next trigger */ + } + + UnlockDisplay(dpy); + SyncHandle(); + return True; +} + +static void +_XProcessAlarmAttributes(dpy, req, valuemask, attributes) + Display *dpy; + xSyncChangeAlarmReq *req; + unsigned long valuemask; + XSyncAlarmAttributes *attributes; +{ + + unsigned long values[32]; + unsigned long *value = values; + unsigned int nvalues; + + if (valuemask & XSyncCACounter) + *value++ = attributes->trigger.counter; + + if (valuemask & XSyncCAValueType) + *value++ = attributes->trigger.value_type; + + if (valuemask & XSyncCAValue) + { + *value++ = XSyncValueHigh32(attributes->trigger.wait_value); + *value++ = XSyncValueLow32(attributes->trigger.wait_value); + } + + if (valuemask & XSyncCATestType) + *value++ = attributes->trigger.test_type; + + if (valuemask & XSyncCADelta) + { + *value++ = XSyncValueHigh32(attributes->delta); + *value++ = XSyncValueLow32(attributes->delta); + } + + if (valuemask & XSyncCAEvents) + *value++ = attributes->events; + + /* N.B. the 'state' field cannot be set or changed */ + req->length += (nvalues = value - values); + nvalues <<= 2; /* watch out for macros... */ + + Data32(dpy, (long *) values, (long) nvalues); +} + +XSyncAlarm +XSyncCreateAlarm(dpy, values_mask, values) + Display *dpy; + unsigned long values_mask; + XSyncAlarmAttributes *values; +{ + XExtDisplayInfo *info = find_display(dpy); + xSyncCreateAlarmReq *req; + XSyncAlarm aid; + + SyncCheckExtension(dpy, info, False); + + LockDisplay(dpy); + GetReq(SyncCreateAlarm, req); + req->reqType = info->codes->major_opcode; + req->syncReqType = X_SyncCreateAlarm; + req->id = aid = XAllocID(dpy); + values_mask &= XSyncCACounter | XSyncCAValueType | XSyncCAValue + | XSyncCATestType | XSyncCADelta | XSyncCAEvents; + if ((req->valueMask = values_mask)) + _XProcessAlarmAttributes(dpy, (xSyncChangeAlarmReq *) req, + values_mask, values); + UnlockDisplay(dpy); + SyncHandle(); + return aid; +} + +Status +XSyncDestroyAlarm(dpy, alarm) + Display *dpy; + XSyncAlarm alarm; +{ + XExtDisplayInfo *info = find_display(dpy); + xSyncDestroyAlarmReq *req; + + SyncCheckExtension(dpy, info, False); + + LockDisplay(dpy); + GetReq(SyncDestroyAlarm, req); + req->reqType = info->codes->major_opcode; + req->syncReqType = X_SyncDestroyAlarm; + req->alarm = alarm; + UnlockDisplay(dpy); + SyncHandle(); + return True; +} + +Status +XSyncQueryAlarm(dpy, alarm, values_return) + Display *dpy; + XSyncAlarm alarm; + XSyncAlarmAttributes *values_return; +{ + XExtDisplayInfo *info = find_display(dpy); + xSyncQueryAlarmReq *req; + xSyncQueryAlarmReply rep; + + SyncCheckExtension(dpy, info, False); + + LockDisplay(dpy); + GetReq(SyncQueryAlarm, req); + req->reqType = info->codes->major_opcode; + req->syncReqType = X_SyncQueryAlarm; + req->alarm = alarm; + + if (!(_XReply(dpy, (xReply *) & rep, + ((SIZEOF(xSyncQueryAlarmReply) - SIZEOF(xGenericReply)) >> 2), xFalse))) + { + UnlockDisplay(dpy); + SyncHandle(); + return False; + } + + values_return->trigger.counter = rep.counter; + values_return->trigger.value_type = rep.value_type; + XSyncIntsToValue(&values_return->trigger.wait_value, + rep.wait_value_lo, rep.wait_value_hi); + values_return->trigger.test_type = rep.test_type; + XSyncIntsToValue(&values_return->delta, rep.delta_lo, + rep.delta_hi); + values_return->events = rep.events; + values_return->state = rep.state; + UnlockDisplay(dpy); + SyncHandle(); + return True; +} + +Status +XSyncChangeAlarm(dpy, alarm, values_mask, values) + Display *dpy; + XSyncAlarm alarm; + unsigned long values_mask; + XSyncAlarmAttributes *values; +{ + XExtDisplayInfo *info = find_display(dpy); + xSyncChangeAlarmReq *req; + + SyncCheckExtension(dpy, info, False); + + LockDisplay(dpy); + GetReq(SyncChangeAlarm, req); + req->reqType = info->codes->major_opcode; + req->syncReqType = X_SyncChangeAlarm; + req->alarm = alarm; + values_mask &= XSyncCACounter | XSyncCAValueType | XSyncCAValue + | XSyncCATestType | XSyncCADelta | XSyncCAEvents; + if ((req->valueMask = values_mask)) + _XProcessAlarmAttributes(dpy, req, values_mask, values); + UnlockDisplay(dpy); + SyncHandle(); + return True; +} + +Status +XSyncSetPriority(dpy, client_resource_id, priority) + Display *dpy; + XID client_resource_id; + int priority; +{ + XExtDisplayInfo *info = find_display(dpy); + xSyncSetPriorityReq *req; + + SyncCheckExtension(dpy, info, False); + + LockDisplay(dpy); + GetReq(SyncSetPriority, req); + req->reqType = info->codes->major_opcode; + req->syncReqType = X_SyncSetPriority; + req->id = client_resource_id; + req->priority = priority; + UnlockDisplay(dpy); + SyncHandle(); + return True; +} + +Status +XSyncGetPriority(dpy, client_resource_id, return_priority) + Display *dpy; + XID client_resource_id; + int *return_priority; +{ + XExtDisplayInfo *info = find_display(dpy); + xSyncGetPriorityReply rep; + xSyncGetPriorityReq *req; + + SyncCheckExtension(dpy, info, False); + + LockDisplay(dpy); + GetReq(SyncGetPriority, req); + req->reqType = info->codes->major_opcode; + req->syncReqType = X_SyncGetPriority; + req->id = client_resource_id; + + if (!_XReply(dpy, (xReply *) & rep, 0, xFalse)) + { + UnlockDisplay(dpy); + SyncHandle(); + return False; + } + if (return_priority) + *return_priority = rep.priority; + + UnlockDisplay(dpy); + SyncHandle(); + return True; +} + +/* + * Functions corresponding to the macros for manipulating 64-bit values + */ + +/* get rid of macros so we can define corresponding functions */ +#undef XSyncIntToValue +#undef XSyncIntsToValue +#undef XSyncValueGreaterThan +#undef XSyncValueLessThan +#undef XSyncValueGreaterOrEqual +#undef XSyncValueLessOrEqual +#undef XSyncValueEqual +#undef XSyncValueIsNegative +#undef XSyncValueIsZero +#undef XSyncValueIsPositive +#undef XSyncValueLow32 +#undef XSyncValueHigh32 +#undef XSyncValueAdd +#undef XSyncValueSubtract +#undef XSyncMaxValue +#undef XSyncMinValue + +void +XSyncIntToValue(pv, i) + XSyncValue *pv; + int i; +{ + _XSyncIntToValue(pv,i); +} + +void +XSyncIntsToValue(pv, l, h) + XSyncValue *pv; + unsigned int l; + int h; +{ + _XSyncIntsToValue(pv, l, h); +} + +Bool +XSyncValueGreaterThan(a, b) + XSyncValue a, b; +{ + return _XSyncValueGreaterThan(a, b); +} + +Bool +XSyncValueLessThan(a, b) + XSyncValue a, b; +{ + return _XSyncValueLessThan(a, b); +} + +Bool +XSyncValueGreaterOrEqual(a, b) + XSyncValue a, b; +{ + return _XSyncValueGreaterOrEqual(a, b); +} + +Bool +XSyncValueLessOrEqual(a, b) + XSyncValue a, b; +{ + return _XSyncValueLessOrEqual(a, b); +} + +Bool +XSyncValueEqual(a, b) + XSyncValue a, b; +{ + return _XSyncValueEqual(a, b); +} + +Bool +XSyncValueIsNegative(v) + XSyncValue v; +{ + return _XSyncValueIsNegative(v); +} + +Bool +XSyncValueIsZero(a) + XSyncValue a; +{ + return _XSyncValueIsZero(a); +} + +Bool +XSyncValueIsPositive(v) + XSyncValue v; +{ + return _XSyncValueIsPositive(v); +} + +unsigned int +XSyncValueLow32(v) + XSyncValue v; +{ + return _XSyncValueLow32(v); +} + +int +XSyncValueHigh32(v) + XSyncValue v; +{ + return _XSyncValueHigh32(v); +} + +void +XSyncValueAdd(presult, a, b, poverflow) + XSyncValue *presult, a, b; + Bool *poverflow; +{ + _XSyncValueAdd(presult, a, b, poverflow); +} + +void +XSyncValueSubtract(presult, a, b, poverflow) + XSyncValue *presult, a, b; + Bool *poverflow; +{ + _XSyncValueSubtract(presult, a, b, poverflow); +} + +void +XSyncMaxValue(pv) + XSyncValue *pv; +{ + _XSyncMaxValue(pv); +} + +void +XSyncMinValue(pv) + XSyncValue *pv; +{ + _XSyncMinValue(pv); +} diff --git a/src/XTestExt1.c b/src/XTestExt1.c new file mode 100644 index 0000000..ddd3e29 --- /dev/null +++ b/src/XTestExt1.c @@ -0,0 +1,1317 @@ +/* $Xorg: XTestExt1.c,v 1.4 2001/02/09 02:03:49 xorgcvs Exp $ */ +/* + * File: xtestext1lib.c + * + * This file contains the Xlib parts of the input synthesis extension + */ + +/* + + +Copyright 1986, 1987, 1988, 1998 The Open Group + +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. + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN +AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN +CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +Except as contained in this notice, the name of The Open Group shall not be +used in advertising or otherwise to promote the sale, use or other dealings +in this Software without prior written authorization from The Open Group. + + +Copyright 1986, 1987, 1988 by Hewlett-Packard Corporation + +Permission to use, copy, modify, and distribute this +software and its documentation for any purpose and without +fee is hereby granted, 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 Hewlett-Packard not be used in +advertising or publicity pertaining to distribution of the +software without specific, written prior permission. + +Hewlett-Packard makes no representations about the +suitability of this software for any purpose. It is provided +"as is" without express or implied warranty. + +This software is not subject to any license of the American +Telephone and Telegraph Company or of the Regents of the +University of California. + +*/ + +/****************************************************************************** + * include files + *****************************************************************************/ + +#define NEED_REPLIES +#define NEED_EVENTS + +#include +#include +#include + +/****************************************************************************** + * variables + *****************************************************************************/ + +/* + * Holds the request type code for this extension. The request type code + * for this extension may vary depending on how many extensions are installed + * already, so the initial value given below will be added to the base request + * code that is aquired when this extension is installed. + */ +static int XTestReqCode = 0; +/* + * Holds the two event type codes for this extension. The event type codes + * for this extension may vary depending on how many extensions are installed + * already, so the initial values given below will be added to the base event + * code that is aquired when this extension is installed. + * + * These two variables must be available to programs that use this extension. + */ +int XTestInputActionType = 0; +int XTestFakeAckType = 1; +/* + * holds the current x and y coordinates for XTestMovePointer + */ +static int current_x = 0; +static int current_y = 0; +/* + * Holds input actions being accumulated until the input action buffer is + * full or until XTestFlush is called. + */ +static CARD8 action_buf[XTestMAX_ACTION_LIST_SIZE]; +/* + * the index into the input action buffer + */ +static int action_index = 0; +/* + * the number of input actions that the server can handle at one time + */ +static unsigned long action_array_size = 0; +/* + * the current number of input actions + */ +static unsigned long action_count = 0; + +/****************************************************************************** + * function declarations + *****************************************************************************/ + +static int XTestWireToEvent(); +static int XTestCheckExtInit(); +static Bool XTestIdentifyMyEvent(); +static int XTestInitExtension(); +static int XTestKeyOrButton(); +static int XTestCheckDelay(); +static int XTestPackInputAction(); +static int XTestWriteInputActions(); + +/****************************************************************************** + * + * XTestFakeInput + * + * Send a a request containing one or more input actions to be sent + * to the server by this extension. + */ +int +XTestFakeInput(dpy, action_list_addr, action_list_size, ack_flag) +/* + * the connection to the X server + */ +register Display *dpy; +/* + * the address of a list of input actions to be sent to the server + */ +char *action_list_addr; +/* + * the size (in bytes) of the list of input actions + */ +int action_list_size; +/* + * specifies whether the server needs to send an event to indicate that its + * input action buffer is empty + */ +int ack_flag; +{ + /* + * pointer to xTestFakeInputReq structure + */ + xTestFakeInputReq *req; + /* + * loop index + */ + int i; + + LockDisplay(dpy); + if ((XTestCheckExtInit(dpy) == -1) || + (action_list_size > XTestMAX_ACTION_LIST_SIZE)) + { + /* + * if the extension is not installed in the server or the + * action list will not fit in the request, then unlock + * the display and return -1. + */ + UnlockDisplay(dpy); + return(-1); + } + else + { + /* + * Get the next available X request packet in the buffer. + * It sets the `length' field to the size (in 32-bit words) + * of the request. It also sets the `reqType' field in the + * request to X_TestFakeInput, which is not what is needed. + * + * GetReq is a macro defined in Xlibint.h. + */ + GetReq(TestFakeInput, req); + /* + * fix up the request type code to what is needed + */ + req->reqType = XTestReqCode; + /* + * set the minor request type code to X_TestFakeInput + */ + req->XTestReqType = X_TestFakeInput; + /* + * set the ack code + */ + req->ack = ack_flag; + /* + * Set the action_list area to all 0's. An input action header + * value of 0 is interpreted as a flag to the input action + * list handling code in the server part of this extension + * that there are no more input actions in this request. + */ + for (i = 0; i < XTestMAX_ACTION_LIST_SIZE; i++) + { + req->action_list[i] = 0; + } + /* + * copy the input actions into the request + */ + for (i = 0; i < action_list_size; i++) + { + req->action_list[i] = *(action_list_addr++); + } + UnlockDisplay(dpy); + SyncHandle(); + return(0); + } +} + +/****************************************************************************** + * + * XTestGetInput + * + * Request the server to begin putting user input actions into events + * to be sent to the client that called this function. + */ +int +XTestGetInput(dpy, action_handling) +/* + * the connection to the X server + */ +register Display *dpy; +/* + * tells the server what to do with the user input actions + */ +int action_handling; +{ + /* + * pointer to xTestGetInputReq structure + */ + xTestGetInputReq *req; + + LockDisplay(dpy); + if (XTestCheckExtInit(dpy) == -1) + { + /* + * if the extension is not installed in the server + * then unlock the display and return -1. + */ + UnlockDisplay(dpy); + return(-1); + } + else + { + /* + * Get the next available X request packet in the buffer. + * It sets the `length' field to the size (in 32-bit words) + * of the request. It also sets the `reqType' field in the + * request to X_TestGetInput, which is not what is needed. + * + * GetReq is a macro defined in Xlibint.h. + */ + GetReq(TestGetInput, req); + /* + * fix up the request type code to what is needed + */ + req->reqType = XTestReqCode; + /* + * set the minor request type code to X_TestGetInput + */ + req->XTestReqType = X_TestGetInput; + /* + * set the action handling mode + */ + req->mode = action_handling; + UnlockDisplay(dpy); + SyncHandle(); + return(0); + } +} + +/****************************************************************************** + * + * XTestStopInput + * + * Tell the server to stop putting information about user input actions + * into events. + */ +int +XTestStopInput(dpy) +/* + * the connection to the X server + */ +register Display *dpy; +{ + /* + * pointer to xTestStopInputReq structure + */ + xTestStopInputReq *req; + + LockDisplay(dpy); + if (XTestCheckExtInit(dpy) == -1) + { + /* + * if the extension is not installed in the server + * then unlock the display and return -1. + */ + UnlockDisplay(dpy); + return(-1); + } + else + { + /* + * Get the next available X request packet in the buffer. + * It sets the `length' field to the size (in 32-bit words) + * of the request. It also sets the `reqType' field in the + * request to X_TestStopInput, which is not what is needed. + * + * GetReq is a macro defined in Xlibint.h. + */ + GetReq(TestStopInput, req); + /* + * fix up the request type code to what is needed + */ + req->reqType = XTestReqCode; + /* + * set the minor request type code to X_TestStopInput + */ + req->XTestReqType = X_TestStopInput; + UnlockDisplay(dpy); + SyncHandle(); + return(0); + } +} + +/****************************************************************************** + * + * XTestReset + * + * Tell the server to set everything having to do with this extension + * back to its initial state. + */ +int +XTestReset(dpy) +/* + * the connection to the X server + */ +register Display *dpy; +{ + /* + * pointer to xTestReset structure + */ + xTestResetReq *req; + + LockDisplay(dpy); + if (XTestCheckExtInit(dpy) == -1) + { + /* + * if the extension is not installed in the server + * then unlock the display and return -1. + */ + UnlockDisplay(dpy); + return(-1); + } + else + { + /* + * Get the next available X request packet in the buffer. + * It sets the `length' field to the size (in 32-bit words) + * of the request. It also sets the `reqType' field in the + * request to X_TestReset, which is not what is needed. + * + * GetReq is a macro defined in Xlibint.h. + */ + GetReq(TestReset, req); + /* + * fix up the request type code to what is needed + */ + req->reqType = XTestReqCode; + /* + * set the minor request type code to X_TestReset + */ + req->XTestReqType = X_TestReset; + UnlockDisplay(dpy); + SyncHandle(); + return(0); + } +} + +/****************************************************************************** + * + * XTestQueryInputSize + * + * Returns the number of input actions in the server's input action buffer. + */ +int +XTestQueryInputSize(dpy, size_return) +/* + * the connection to the X server + */ +register Display *dpy; +/* + * the address of the place to put the number of input actions in the + * server's input action buffer + */ +unsigned long *size_return; +{ + /* + * pointer to xTestQueryInputSize structure + */ + xTestQueryInputSizeReq *req; + /* + * pointer to xTestQueryInputSize structure + */ + xTestQueryInputSizeReply rep; + + LockDisplay(dpy); + if (XTestCheckExtInit(dpy) == -1) + { + /* + * if the extension is not installed in the server + * then unlock the display and return -1. + */ + UnlockDisplay(dpy); + return(-1); + } + else + { + /* + * Get the next available X request packet in the buffer. + * It sets the `length' field to the size (in 32-bit words) + * of the request. It also sets the `reqType' field in the + * request to X_TestQueryInputSize, which is not what is needed. + * + * GetReq is a macro defined in Xlibint.h. + */ + GetReq(TestQueryInputSize, req); + /* + * fix up the request type code to what is needed + */ + req->reqType = XTestReqCode; + /* + * set the minor request type code to X_TestQueryInputSize + */ + req->XTestReqType = X_TestQueryInputSize; + /* + * get a reply from the server + */ + (void) _XReply (dpy, (xReply *) &rep, 0, xTrue); + /* + * put the size in the caller's variable + */ + *size_return = (unsigned long) rep.size_return; + UnlockDisplay(dpy); + SyncHandle(); + return(0); + } +} + +/****************************************************************************** + * + * XTestCheckExtInit + * + * Check to see if the XTest extension is installed in the server. + */ +static int +XTestCheckExtInit(dpy) +/* + * the connection to the X server + */ +register Display *dpy; +{ + /* + * if the extension has not been initialized, then do so + */ + if (!XTestReqCode) + { + return(XTestInitExtension(dpy)); + } + return(0); +} + +/****************************************************************************** + * + * XTestInitExtension + * + * Attempt to initialize this extension in the server. Return 0 if it + * succeeds, -1 if it does not succeed. + */ +static int +XTestInitExtension(dpy) +/* + * the connection to the X server + */ +register Display *dpy; +{ + /* + * loop index + */ + int i; + /* + * return value from XInitExtension + */ + XExtCodes *ret; + + /* + * attempt to initialize the extension + */ + ret = XInitExtension(dpy, XTestEXTENSION_NAME); + /* + * if the initialize failed, return -1 + */ + if (ret == NULL) + { + return (-1); + } + /* + * the initialize succeeded, remember the major opcode + * for this extension + */ + XTestReqCode = ret->major_opcode; + /* + * set up the event handler for any events from + * this extension + */ + for (i = 0; i < XTestEVENT_COUNT; i++) + { + XESetWireToEvent(dpy, + ret->first_event+i, + XTestWireToEvent); + } + /* + * compute the event type codes for the events + * in this extension + */ + XTestInputActionType += ret->first_event; + XTestFakeAckType += ret->first_event; + /* + * everything worked ok + */ + return(0); +} + +/****************************************************************************** + * + * XTestWireToEvent + * + * Handle XTest extension events. + * Reformat a wire event into an XEvent structure of the right type. + */ +static Bool +XTestWireToEvent(dpy, reTemp, eventTemp) +/* + * the connection to the X server + */ +Display *dpy; +/* + * a pointer to where a host formatted event should be stored + * with the information copied to it + */ +XEvent *reTemp; +/* + * a pointer to the wire event + */ +xEvent *eventTemp; +{ + XTestInputActionEvent *re = (XTestInputActionEvent *) reTemp; + xTestInputActionEvent *event = (xTestInputActionEvent *) eventTemp; + + /* + * loop index + */ + int i; + /* + * pointer to where the input actions go in the host format event + */ + CARD8 *to; + /* + * pointer to the input actions in the wire event + */ + CARD8 *from; + + /* + * Copy the type of the wire event to the new event. + * This will work for either event type because the type, + * display, and window fields in the events have to be the same. + */ + re->type = event->type; + /* + * set the display parameter in case it is needed (by who?) + */ + re->display = dpy; + if (re->type == XTestInputActionType) + { + /* + * point at the first byte of input actions in the wire event + */ + from = &(event->actions[0]); + /* + * point at where the input action bytes go in the new event + */ + to = &(re->actions[0]); + /* + * copy the input action bytes from the wire event to + * the new event + */ + for (i = 0; i < XTestACTIONS_SIZE; i++) + { + *(to++) = *(from++); + } + } + else if (re->type == XTestFakeAckType) + { + /* + * nothing else needs to be done + */ + } + else + { + printf("XTestWireToEvent: UNKNOWN WIRE EVENT! type=%d\n", + (int) event->type); + printf("%s is giving up.\n", XTestEXTENSION_NAME); + exit (1); + } + return 1; +} + +/****************************************************************************** + * + * XTestPressKey + * + * Send input actions to the server to cause the server to think + * that the specified key on the keyboard was moved as specified. + */ +int +XTestPressKey(display, device_id, delay, keycode, key_action) +Display *display; +int device_id; +unsigned long delay; +unsigned int keycode; +unsigned int key_action; +{ + /* + * bounds check the key code + */ + if (keycode < 8 || keycode > 255) + { + return(-1); + } + /* + * use the commmon key/button handling routine + */ + return(XTestKeyOrButton(display, + device_id, + delay, + keycode, + key_action)); +} + +/****************************************************************************** + * + * XTestPressButton + * + * Send input actions to the server to cause the server to think + * that the specified button on the mouse was moved as specified. + */ +int +XTestPressButton(display, device_id, delay, button_number, button_action) +Display *display; +int device_id; +unsigned long delay; +unsigned int button_number; +unsigned int button_action; +{ + /* + * bounds check the button number + */ + if (button_number > 7) + { + return(-1); + } + /* + * use the commmon key/button handling routine + */ + return(XTestKeyOrButton(display, + device_id, + delay, + button_number, + button_action)); +} + +/****************************************************************************** + * + * XTestKeyOrButton + * + * Send input actions to the server to cause the server to think + * that the specified key/button was moved as specified. + */ +static int +XTestKeyOrButton(display, device_id, delay, code, action) +Display *display; +int device_id; +unsigned long delay; +unsigned int code; +unsigned int action; +{ + /* + * holds a key input action to be filled out and sent to the server + */ + XTestKeyInfo keyinfo; + + /* + * bounds check the device id + */ + if (device_id < 0 || device_id > XTestMAX_DEVICE_ID) + { + return(-1); + } + /* + * fill out the key input action(s) as appropriate + */ + switch(action) + { + case XTestPRESS: + /* + * Check the delay. If it is larger than will fit in the + * key input action, send a delay input action. + */ + if(XTestCheckDelay(display, &delay) == -1) + { + /* + * an error occurred, return -1 + */ + return(-1); + } + /* + * create the header + */ + keyinfo.header = XTestPackDeviceID(device_id) | + XTestKEY_ACTION | + XTestKEY_DOWN; + /* + * set the key/button code + */ + keyinfo.keycode = code; + /* + * set the delay time + */ + keyinfo.delay_time = delay; + /* + * pack the input action into a request to be sent to the + * server when the request is full or XTestFlush is called + */ + return(XTestPackInputAction(display, + (CARD8 *) &keyinfo, + sizeof(XTestKeyInfo))); + case XTestRELEASE: + /* + * Check the delay. If it is larger than will fit in the + * key input action, send a delay input action. + */ + if(XTestCheckDelay(display, &delay) == -1) + { + /* + * an error occurred, return -1 + */ + return(-1); + } + /* + * create the header + */ + keyinfo.header = XTestPackDeviceID(device_id) | + XTestKEY_ACTION | + XTestKEY_UP; + /* + * set the key/button code + */ + keyinfo.keycode = code; + /* + * set the delay time + */ + keyinfo.delay_time = delay; + /* + * pack the input action into a request to be sent to the + * server when the request is full or XTestFlush is called + */ + return(XTestPackInputAction(display, + (CARD8 *) &keyinfo, + sizeof(XTestKeyInfo))); + case XTestSTROKE: + /* + * Check the delay. If it is larger than will fit in the + * key input action, send a delay input action. + */ + if(XTestCheckDelay(display, &delay) == -1) + { + /* + * an error occurred, return -1 + */ + return(-1); + } + /* + * create a key/button-down input action header + */ + keyinfo.header = XTestPackDeviceID(device_id) | + XTestKEY_ACTION | + XTestKEY_DOWN; + /* + * set the key/button code + */ + keyinfo.keycode = code; + /* + * set the delay time + */ + keyinfo.delay_time = delay; + /* + * pack the input action into a request to be sent to the + * server when the request is full or XTestFlush is called + */ + if (XTestPackInputAction(display, + (CARD8 *) &keyinfo, + sizeof(XTestKeyInfo)) == -1) + { + /* + * an error occurred, return -1 + */ + return(-1); + } + /* + * set the delay to XTestSTROKE_DELAY_TIME + */ + delay = XTestSTROKE_DELAY_TIME; + /* + * Check the delay. If it is larger than will fit in the + * key input action, send a delay input action. + */ + if(XTestCheckDelay(display, &delay) == -1) + { + /* + * an error occurred, return -1 + */ + return(-1); + } + /* + * create a key/button-up input action header + */ + keyinfo.header = XTestPackDeviceID(device_id) | + XTestKEY_ACTION | + XTestKEY_UP; + /* + * set the key/button code + */ + keyinfo.keycode = code; + /* + * set the delay time + */ + keyinfo.delay_time = delay; + /* + * pack the input action into a request to be sent to the + * server when the request is full or XTestFlush is called + */ + return(XTestPackInputAction(display, + (CARD8 *) &keyinfo, + sizeof(XTestKeyInfo))); + default: + /* + * invalid action value, return -1 + */ + return(-1); + } +} + +/****************************************************************************** + * + * XTestMovePointer + * + * Send input actions to the server to cause the server to think + * that the mouse was moved as specified. + */ +int +XTestMovePointer(display, device_id, delay, x, y, count) +Display *display; +int device_id; +unsigned long delay[]; +int x[]; +int y[]; +unsigned int count; +{ + /* + * holds a motion input action to be filled out and sent to the server + */ + XTestMotionInfo motioninfo; + /* + * holds a jump input action to be filled out and sent to the server + */ + XTestJumpInfo jumpinfo; + /* + * loop index + */ + unsigned int i; + /* + * holds the change in x and y directions from the current x and y + * coordinates + */ + int dx; + int dy; + + /* + * bounds check the device id + */ + if (device_id < 0 || device_id > XTestMAX_DEVICE_ID) + { + return(-1); + } + /* + * if the count is 0, there is nothing to do. return 0 + */ + if (count == 0) + { + return(0); + } + /* + * loop through the pointer motions, creating the appropriate + * input actions for each motion + */ + for (i = 0; i < count; i++) + { + /* + * Check the delay. If it is larger than will fit in the + * input action, send a delay input action. + */ + if(XTestCheckDelay(display, &(delay[i])) == -1) + { + /* + * an error occurred, return -1 + */ + return(-1); + } + /* + * compute the change from the current x and y coordinates + * to the new x and y coordinates + */ + dx = x[i] - current_x; + dy = y[i] - current_y; + /* + * update the current x and y coordinates + */ + current_x = x[i]; + current_y = y[i]; + /* + * If the pointer motion range is too large to fit into + * a motion input action, then use a jump input action. + * Otherwise, use a motion input action. + */ + if ((dx > XTestMOTION_MAX) || (dx < XTestMOTION_MIN) || + (dy > XTestMOTION_MAX) || (dy < XTestMOTION_MIN)) + { + /* + * create a jump input action header + */ + jumpinfo.header = XTestPackDeviceID(device_id) | + XTestJUMP_ACTION; + /* + * set the x and y coordinates to jump to + */ + jumpinfo.jumpx = x[i]; + jumpinfo.jumpy = y[i]; + /* + * set the delay time + */ + jumpinfo.delay_time = delay[i]; + /* + * pack the jump input action into a request to be + * sent to the server when the request is full + * or XTestFlush is called + */ + if (XTestPackInputAction(display, + (CARD8 *) &jumpinfo, + sizeof(XTestJumpInfo)) == -1) + { + /* + * an error occurred, return -1 + */ + return(-1); + } + } + else + { + /* + * create a motion input action header + */ + motioninfo.header = XTestPackDeviceID(device_id) | + XTestMOTION_ACTION; + /* + * compute the motion data byte + */ + if (dx < 0) + { + motioninfo.header |= XTestX_NEGATIVE; + dx = abs(dx); + } + if (dy < 0) + { + motioninfo.header |= XTestY_NEGATIVE; + dy = abs(dy); + } + motioninfo.motion_data = XTestPackXMotionValue(dx); + motioninfo.motion_data |= XTestPackYMotionValue(dy); + /* + * set the delay time + */ + motioninfo.delay_time = delay[i]; + /* + * pack the motion input action into a request to be + * sent to the server when the request is full + * or XTestFlush is called + */ + if (XTestPackInputAction(display, + (CARD8 *) &motioninfo, + sizeof(XTestMotionInfo)) == -1) + { + /* + * an error occurred, return -1 + */ + return(-1); + } + } + } + /* + * if you get here, everything went ok + */ + return(0); +} + +/****************************************************************************** + * + * XTestCheckDelay + * + * Check the delay value at the passed-in address. If it is larger than + * will fit in a normal input action, then send a delay input action. + */ +static int +XTestCheckDelay(display, delay_addr) +Display *display; +unsigned long *delay_addr; +{ + /* + * holds a delay input action to be filled out and sent to the server + */ + XTestDelayInfo delayinfo; + + /* + * if the delay value will fit in the input action, + * then there is no need for a delay input action + */ + if (*delay_addr <= XTestSHORT_DELAY_TIME) + { + return(0); + } + /* + * fill out a delay input action + */ + delayinfo.header = XTestPackDeviceID(XTestDELAY_DEVICE_ID); + delayinfo.delay_time = *delay_addr; + /* + * all of the delay time will be accounted for in the + * delay input action, so set the original delay value to 0 + */ + *delay_addr = 0; + /* + * pack the delay input action into a request to be sent to the + * server when the request is full or XTestFlush is called + */ + return(XTestPackInputAction(display, + (CARD8 *) &delayinfo, + sizeof(XTestDelayInfo))); +} + +/****************************************************************************** + * + * XTestPackInputAction + * + * If the input action buffer is full or the number of input actions + * has reached the maximum that the server can handle at one time, + * then send the input actions to the server using XTestFakeInput. + */ +static int +XTestPackInputAction(display, action_addr, action_size) +Display *display; +CARD8 *action_addr; +int action_size; +{ + /* + * loop index + */ + int i; + /* + * acknowledge flag + */ + int ack_flag; + + /* + * if we don't already know it, find out how many input actions + * the server can handle at one time + */ + if (action_array_size == 0) + { + if(XTestQueryInputSize(display, &action_array_size) == -1) + { + /* + * if an error, return -1 + */ + return(-1); + } + } + /* + * if the specified input action will fit in the the input + * action buffer and won't exceed the server's capacity, then + * put the input action into the input buffer + */ + if(((action_index + action_size) <= XTestMAX_ACTION_LIST_SIZE) && + ((action_count + 1) < action_array_size)) + { + /* + * copy the input action into the buffer + */ + for (i = 0; i < action_size; i++) + { + action_buf[action_index++] = *(action_addr++); + } + /* + * increment the action count + */ + action_count++; + /* + * everything went ok, return 0 + */ + return(0); + } + /* + * We have to write input actions to the server. If the server's + * input action capacity will be reached, then ask for an + * acknowledge event when the server has processed all of the + * input actions. Otherwise, an acknowledge event is not needed. + */ + if (action_count >= action_array_size) + { + ack_flag = XTestFAKE_ACK_REQUEST; + } + else + { + ack_flag = XTestFAKE_ACK_NOT_NEEDED; + } + /* + * write the input actions to the server + */ + if (XTestWriteInputActions(display, + (char *) &(action_buf[0]), + action_index, + ack_flag) == -1) + { + /* + * error, return -1 + */ + return(-1); + } + /* + * copy the input action into the buffer + */ + for (i = 0; i < action_size; i++) + { + action_buf[action_index++] = *(action_addr++); + } + /* + * increment the action count + */ + action_count++; + return(0); +} + +/****************************************************************************** + * + * XTestWriteInputActions + * + * Send input actions to the server. + */ +static int +XTestWriteInputActions(display, action_list_addr, action_list_size, ack_flag) +Display *display; +char *action_list_addr; +int action_list_size; +int ack_flag; +{ + /* + * Holds an event. Used while waiting for an acknowledge event + */ + XEvent event; + /* + * points to XTestIdentifyMyEvent + */ + Bool (*func_ptr)(); + + /* + * write the input actions to the server + */ + if (XTestFakeInput(display, + action_list_addr, + action_list_size, + ack_flag) == -1) + { + /* + * if an error, return -1 + */ + return(-1); + } + /* + * flush X's buffers to make sure that the server really gets + * the input actions + */ + XFlush(display); + /* + * mark the input action buffer as empty + */ + action_index = 0; + /* + * if we asked for an acknowledge event, then wait for it + */ + if (ack_flag == XTestFAKE_ACK_REQUEST) + { + /* + * point func_ptr at XTestIdentifyMyEvent + */ + func_ptr = XTestIdentifyMyEvent; + /* + * Wait until the acknowledge event comes. When the + * acknowledge event comes, it is removed from the event + * queue without disturbing any other events that might + * be in the queue. + */ + XIfEvent(display, &event, func_ptr, NULL); + /* + * set the input action count back to 0 + */ + action_count = 0; + } + /* + * if we got here, then everything is ok, return 0 + */ + return(0); +} + +/****************************************************************************** + * + * XTestIdentifyMyEvent + * + * This function is called by XIfEvent to look at an event and see if + * it is of XTestFakeAckType. + */ +static Bool +XTestIdentifyMyEvent(display, event_ptr, args) +Display *display; +/* + * Holds the event that this routiine is supposed to look at. + */ +XEvent *event_ptr; +/* + * this points to any user-specified arguments (ignored) + */ +char *args; +{ + /* + * if the event if of the correct type, return the Bool True, + * otherwise return the Bool False. + */ + if (event_ptr->type == XTestFakeAckType) + { + return(True); + } + else + { + return(False); + } +} + +/****************************************************************************** + * + * XTestFlush + * + * Send any input actions in the input action buffer to the server. + */ +int +XTestFlush(display) +Display *display; +{ + /* + * acknowledge flag + */ + int ack_flag; + + /* + * if there are no input actions in the input action buffer, + * then return 0 + */ + if (action_index == 0) + { + return(0); + } + /* + * We have input actions to write to the server. We will + * wait until the server has finished processing the input actions. + */ + ack_flag = XTestFAKE_ACK_REQUEST; + /* + * write the input actions to the server + */ + return(XTestWriteInputActions(display, + (char *) &(action_buf[0]), + action_index, + ack_flag)); +} diff --git a/src/Xcup.c b/src/Xcup.c new file mode 100644 index 0000000..fcd9038 --- /dev/null +++ b/src/Xcup.c @@ -0,0 +1,283 @@ +/* + +Copyright 1987, 1988, 1998 The Open Group + +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. + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN +AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN +CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +Except as contained in this notice, the name of The Open Group shall not be +used in advertising or otherwise to promote the sale, use or other dealings +in this Software without prior written authorization from The Open Group. + +*/ +/* $Xorg: Xcup.c,v 1.5 2001/02/09 02:03:49 xorgcvs Exp $ */ + +#ifdef WIN32 +#define BOOL wBOOL +#undef Status +#define Status wStatus +#include +#undef Status +#define Status int +#undef BOOL +#endif + +#define NEED_EVENTS +#define NEED_REPLIES +#include "Xlibint.h" +#include "Xcupstr.h" +#include "Xext.h" +#include "extutil.h" + +static XExtensionInfo _xcup_info_data; +static XExtensionInfo *xcup_info = &_xcup_info_data; +static char *xcup_extension_name = XCUPNAME; + +/***************************************************************************** + * * + * private utility routines * + * * + *****************************************************************************/ + +static int close_display(); +static /* const */ XExtensionHooks xcup_extension_hooks = { + NULL, /* create_gc */ + NULL, /* copy_gc */ + NULL, /* flush_gc */ + NULL, /* free_gc */ + NULL, /* create_font */ + NULL, /* free_font */ + close_display, /* close_display */ + NULL, /* wire_to_event */ + NULL, /* event_to_wire */ + NULL, /* error */ + NULL, /* error_string */ +}; + +static XEXT_GENERATE_FIND_DISPLAY (find_display, xcup_info, + xcup_extension_name, + &xcup_extension_hooks, + 0, NULL) + +static XEXT_GENERATE_CLOSE_DISPLAY (close_display, xcup_info) + + +/***************************************************************************** + * * + * public Xcup Extension routines * + * * + *****************************************************************************/ + +Status +XcupQueryVersion(dpy, major_version_return, minor_version_return) + Display* dpy; + int* major_version_return; + int* minor_version_return; +{ + XExtDisplayInfo *info = find_display (dpy); + xXcupQueryVersionReply rep; + xXcupQueryVersionReq *req; + + XextCheckExtension (dpy, info, xcup_extension_name, False); + + LockDisplay(dpy); + GetReq(XcupQueryVersion, req); + req->reqType = info->codes->major_opcode; + req->xcupReqType = X_XcupQueryVersion; + req->client_major_version = XCUP_MAJOR_VERSION; + req->client_minor_version = XCUP_MINOR_VERSION; + if (!_XReply(dpy, (xReply *)&rep, 0, xTrue)) { + UnlockDisplay(dpy); + SyncHandle(); + return False; + } + *major_version_return = rep.server_major_version; + *minor_version_return = rep.server_minor_version; + UnlockDisplay(dpy); + SyncHandle(); + return True; +} + +/* Win32 reserves 20 colormap entries for its desktop */ +#ifndef TYP_RESERVED_ENTRIES +#define TYP_RESERVED_ENTRIES 20 +#endif + +Status +#if NeedFunctionPrototypes +XcupGetReservedColormapEntries( + Display* dpy, + int screen, + XColor** colors_out, + int* ncolors) +#else +XcupGetReservedColormapEntries(dpy, screen, colors_out, ncolors) + Display* dpy; + int screen; + XColor** colors_out; + int* ncolors; +#endif +{ + XExtDisplayInfo *info = find_display (dpy); + xXcupGetReservedColormapEntriesReply rep; + xXcupGetReservedColormapEntriesReq *req; + xColorItem rbuf[TYP_RESERVED_ENTRIES]; + + *ncolors = 0; + + XextCheckExtension (dpy, info, xcup_extension_name, False); + + LockDisplay(dpy); + GetReq(XcupGetReservedColormapEntries, req); + req->reqType = info->codes->major_opcode; + req->xcupReqType = X_XcupGetReservedColormapEntries; + req->screen = screen; + if (_XReply(dpy, (xReply *)&rep, 0, xFalse)) { + long nbytes; + xColorItem* rbufp; + int nentries = rep.length / 3; + + nbytes = nentries * SIZEOF (xColorItem); + if (nentries > TYP_RESERVED_ENTRIES) + rbufp = (xColorItem*) Xmalloc (nbytes); + else + rbufp = rbuf; + + if (rbufp == NULL) { + _XEatData (dpy, (unsigned long) nbytes); + UnlockDisplay (dpy); + SyncHandle (); + return False; + } + _XRead (dpy, (char*) rbufp, nbytes); + + *colors_out = (XColor*) Xmalloc (nentries * sizeof (XColor)); + if (*colors_out) { + xColorItem* cs = (xColorItem *) rbufp; + XColor* cd = *colors_out; + int i; + + *ncolors = nentries; + for (i = 0; i < *ncolors; i++, cd++) { + cd->pixel = cs->pixel; + cd->red = cs->red; + cd->green = cs->green; + cd->blue = cs->blue; + cs = (xColorItem*) (((char*) cs) + SIZEOF(xColorItem)); + } + if (rbufp != rbuf) XFree ((char*) rbufp); + UnlockDisplay(dpy); + SyncHandle(); + return True; + } + if (rbufp != rbuf) XFree ((char*) rbufp); + } + UnlockDisplay(dpy); + SyncHandle(); + return False; +} + +Status +#if NeedFunctionPrototypes +XcupStoreColors( + Display* dpy, + Colormap colormap, + XColor* colors_in_out, + int ncolors) +#else +XcupStoreColors(dpy, colormap, colors_in_out, ncolors) + Display* dpy; + Colormap colormap; + XColor* colors_in_out; + int ncolors; +#endif +{ + XExtDisplayInfo *info = find_display (dpy); + xXcupStoreColorsReply rep; + xXcupStoreColorsReq *req; + xColorItem rbuf[256]; + xColorItem citem; + int i; + XColor* xcp; + + XextCheckExtension (dpy, info, xcup_extension_name, False); + + LockDisplay(dpy); + GetReq(XcupStoreColors, req); + req->reqType = info->codes->major_opcode; + req->xcupReqType = X_XcupStoreColors; + req->cmap = colormap; + req->length += (ncolors * SIZEOF(xColorItem)) >> 2; + + for (i = 0, xcp = colors_in_out; i < ncolors; i++, xcp++) { + citem.pixel = xcp->pixel; + citem.red = xcp->red; + citem.green = xcp->green; + citem.blue = xcp->blue; + + /* note that xColorItem doesn't contain all 16-bit quantities, so + we can't use Data16 */ + Data(dpy, (char *)&citem, (long) SIZEOF(xColorItem)); + } + + if (_XReply(dpy, (xReply *)&rep, 0, xFalse)) { + long nbytes; + xColorItem* rbufp; + xColorItem* cs; + int nentries = rep.length / 3; + + nbytes = nentries * SIZEOF (xColorItem); + + if (nentries != ncolors) { + _XEatData (dpy, (unsigned long) nbytes); + UnlockDisplay (dpy); + SyncHandle (); + return False; + } + + if (ncolors > 256) + rbufp = (xColorItem*) Xmalloc (nbytes); + else + rbufp = rbuf; + + if (rbufp == NULL) { + _XEatData (dpy, (unsigned long) nbytes); + UnlockDisplay (dpy); + SyncHandle (); + return False; + + } + + _XRead (dpy, (char*) rbufp, nbytes); + + for (i = 0, xcp = colors_in_out, cs = rbufp; i < ncolors; i++, xcp++, cs++) { + xcp->pixel = cs->pixel; + xcp->red = cs->red; + xcp->green = cs->green; + xcp->blue = cs->blue; + xcp->flags = cs->flags; + } + if (rbufp != rbuf) XFree ((char*)rbufp); + + UnlockDisplay(dpy); + SyncHandle(); + return True; + } + UnlockDisplay(dpy); + SyncHandle(); + return False; +} + diff --git a/src/Xdbe.c b/src/Xdbe.c new file mode 100644 index 0000000..a08aab9 --- /dev/null +++ b/src/Xdbe.c @@ -0,0 +1,542 @@ +/* $Xorg: Xdbe.c,v 1.4 2000/08/17 19:45:53 cpqbld Exp $ */ +/****************************************************************************** + * + * Copyright (c) 1994, 1995 Hewlett-Packard Company + * + * Permission is hereby granted, free of charge, to any person obtaining + * a copy of this software and associated documentation files (the + * "Software"), to deal in the Software without restriction, including + * without limitation the rights to use, copy, modify, merge, publish, + * distribute, sublicense, and/or sell copies of the Software, and to + * permit persons to whom the Software is furnished to do so, subject to + * the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. + * IN NO EVENT SHALL HEWLETT-PACKARD COMPANY BE LIABLE FOR ANY CLAIM, + * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR + * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR + * THE USE OR OTHER DEALINGS IN THE SOFTWARE. + * + * Except as contained in this notice, the name of the Hewlett-Packard + * Company shall not be used in advertising or otherwise to promote the + * sale, use or other dealings in this Software without prior written + * authorization from the Hewlett-Packard Company. + * + * Xlib DBE code + * + *****************************************************************************/ + + +#define NEED_EVENTS +#define NEED_REPLIES +#include +#include "Xext.h" +#include "extutil.h" +#define NEED_DBE_PROTOCOL +#include "Xdbe.h" + +static XExtensionInfo _dbe_info_data; +static XExtensionInfo *dbe_info = &_dbe_info_data; +static char *dbe_extension_name = DBE_PROTOCOL_NAME; + +#define DbeCheckExtension(dpy,i,val) \ + XextCheckExtension (dpy, i, dbe_extension_name, val) +#define DbeSimpleCheckExtension(dpy,i) \ + XextSimpleCheckExtension (dpy, i, dbe_extension_name) + +#if defined(__STDC__) && !defined(UNIXCPP) +#define DbeGetReq(name,req,info) GetReq (name, req); \ + req->reqType = info->codes->major_opcode; \ + req->dbeReqType = X_##name; +#else +#define DbeGetReq(name,req,info) GetReq (name, req); \ + req->reqType = info->codes->major_opcode; \ + req->dbeReqType = X_/**/name; +#endif + + +/***************************************************************************** + * * + * private utility routines * + * * + *****************************************************************************/ + +/* + * find_display - locate the display info block + */ +static int close_display(); +static char *error_string(); +static XExtensionHooks dbe_extension_hooks = { + NULL, /* create_gc */ + NULL, /* copy_gc */ + NULL, /* flush_gc */ + NULL, /* free_gc */ + NULL, /* create_font */ + NULL, /* free_font */ + close_display, /* close_display */ + NULL, /* wire_to_event */ + NULL, /* event_to_wire */ + NULL, /* error */ + error_string, /* error_string */ +}; + +static char *dbe_error_list[] = { + "BadBuffer", /* DbeBadBuffer */ +}; + +static XEXT_GENERATE_FIND_DISPLAY (find_display, dbe_info, + dbe_extension_name, + &dbe_extension_hooks, + DbeNumberEvents, NULL) + +static XEXT_GENERATE_CLOSE_DISPLAY (close_display, dbe_info) + +static XEXT_GENERATE_ERROR_STRING (error_string, dbe_extension_name, + DbeNumberErrors, + dbe_error_list) + + +/***************************************************************************** + * * + * Double-Buffering public interfaces * + * * + *****************************************************************************/ + +/* + * XdbeQueryExtension - + * Sets major_version_return and minor_verion_return to the major and + * minor DBE protocol version supported by the server. If the DBE + * library is compatible with the version returned by the server, this + * function returns non-zero. If dpy does not support the DBE + * extension, or if there was an error during communication with the + * server, or if the server and library protocol versions are + * incompatible, this functions returns zero. No other Xdbe functions + * may be called before this function. If a client violates this rule, + * the effects of all subsequent Xdbe calls are undefined. + */ +#if NeedFunctionPrototypes +Status XdbeQueryExtension ( + Display *dpy, + int *major_version_return, + int *minor_version_return) +#else +Status XdbeQueryExtension (dpy, major_version_return, minor_version_return) + Display *dpy; + int *major_version_return; + int *minor_version_return; +#endif +{ + XExtDisplayInfo *info = find_display (dpy); + xDbeGetVersionReply rep; + register xDbeGetVersionReq *req; + + if (!XextHasExtension (info)) + return (Status)0; /* failure */ + + LockDisplay (dpy); + DbeGetReq (DbeGetVersion, req, info); + req->majorVersion = DBE_MAJOR_VERSION; + req->minorVersion = DBE_MINOR_VERSION; + + if (!_XReply (dpy, (xReply *) &rep, 0, xTrue)) { + UnlockDisplay (dpy); + SyncHandle (); + return (Status)0; /* failure */ + } + *major_version_return = rep.majorVersion; + *minor_version_return = rep.minorVersion; + UnlockDisplay (dpy); + + SyncHandle (); + + if (*major_version_return != DBE_MAJOR_VERSION) + return (Status)0; /* failure */ + else + return (Status)1; /* success */ +} + + +/* + * XdbeAllocateBackBuffer - + * This function returns a drawable ID used to refer to the back buffer + * of the specified window. The swap_action is a hint to indicate the + * swap action that will likely be used in subsequent calls to + * XdbeSwapBuffers. The actual swap action used in calls to + * XdbeSwapBuffers does not have to be the same as the swap_action + * passed to this function, though clients are encouraged to provide + * accurate information whenever possible. + */ + +/*## If NeedFunctionPrototypes is defined, the swap_action parameter causes + *## compiler failure without the #ifdef workaround below. With + *## NeedFunctionPrototype enabled, this function is prototyped as + *## + *## XdbeBackBuffer XdbeAllocateBackBufferName (dpy, window, swap_action) + *## Display *dpy; + *## Window window; + *## XdbeSwapAction swap_action; + *## + *## Without the workaround, an error occurs because swap_action is promoted to + *## an int by the compiler when compiling this file. However, this type does + *## not match what is in the function prototype in Xdbe.h. In Xdbe.h, the + *## swap_action parameter is defined as an unsigned char, not an int. + *##*/ + +#if NeedFunctionPrototypes +XdbeBackBuffer XdbeAllocateBackBufferName( + Display *dpy, + Window window, + XdbeSwapAction swap_action) +#else +XdbeBackBuffer XdbeAllocateBackBufferName (dpy, window, swap_action) + Display *dpy; + Window window; + XdbeSwapAction swap_action; +#endif +{ + XExtDisplayInfo *info = find_display (dpy); + register xDbeAllocateBackBufferNameReq *req; + XdbeBackBuffer buffer; + + /* make sure extension is available; if not, return the + * third parameter (0). + */ + DbeCheckExtension (dpy, info, (XdbeBackBuffer)0); + + /* allocate the id */ + buffer = XAllocID (dpy); + + LockDisplay(dpy); + DbeGetReq(DbeAllocateBackBufferName, req, info); + req->window = window; + req->swapAction = (unsigned char)swap_action; + req->buffer = buffer; + + UnlockDisplay (dpy); + SyncHandle (); + return buffer; + +} /* XdbeAllocateBackBufferName() */ + +/* + * XdbeDeallocateBackBufferName - + * This function frees a drawable ID, buffer, that was obtained via + * XdbeAllocateBackBufferName. The buffer must refer to the back buffer + * of the specified window, or a protocol error results. + */ +#if NeedFunctionPrototypes +Status XdbeDeallocateBackBufferName ( + Display *dpy, + XdbeBackBuffer buffer) +#else +Status XdbeDeallocateBackBufferName (dpy, buffer) + Display *dpy; + XdbeBackBuffer buffer; +#endif +{ + XExtDisplayInfo *info = find_display (dpy); + register xDbeDeallocateBackBufferNameReq *req; + + DbeCheckExtension (dpy, info, (Status)0 /* failure */); + + LockDisplay (dpy); + DbeGetReq (DbeDeallocateBackBufferName, req, info); + req->buffer = buffer; + UnlockDisplay (dpy); + SyncHandle (); + + return (Status)1; /* success */ +} + + +/* + * XdbeSwapBuffers - + * This function swaps the front and back buffers for a list of windows. + * The argument num_windows specifies how many windows are to have their + * buffers swapped; it is the number of elements in the swap_info array. + * The argument swap_info specifies the information needed per window + * to do the swap. + */ +#if NeedFunctionPrototypes +Status XdbeSwapBuffers ( + Display *dpy, + XdbeSwapInfo *swap_info, + int num_windows) +#else +Status XdbeSwapBuffers (dpy, swap_info, num_windows) + Display *dpy; + XdbeSwapInfo *swap_info; + int num_windows; +#endif +{ + XExtDisplayInfo *info = find_display (dpy); + register xDbeSwapBuffersReq *req; + int i; + + DbeCheckExtension (dpy, info, (Status)0 /* failure */); + + LockDisplay (dpy); + DbeGetReq (DbeSwapBuffers, req, info); + req->length += 2*num_windows; + req->n = num_windows; + + /* We need to handle 64-bit machines, where we can not use PackData32 + * directly because info would be lost in translating from 32- to 64-bit. + * Instead we send data via a loop that accounts for the translation. + */ + for (i = 0; i < num_windows; i++) + { + char tmp[4]; + Data32 (dpy, (long *)&swap_info[i].swap_window, 4); + tmp[0] = swap_info[i].swap_action; + Data (dpy, (char *)tmp, 4); + } + + UnlockDisplay (dpy); + SyncHandle (); + + + return (Status)1; /* success */ + +} /* XdbeSwapBuffers() */ + + +/* + * XdbeBeginIdiom - + * This function marks the beginning of an idiom sequence. + */ +#if NeedFunctionPrototypes +Status XdbeBeginIdiom ( + Display *dpy) +#else +Status XdbeBeginIdiom (dpy) + Display *dpy; +#endif +{ + XExtDisplayInfo *info = find_display(dpy); + register xDbeBeginIdiomReq *req; + + DbeCheckExtension (dpy, info, (Status)0 /* failure */); + + LockDisplay (dpy); + DbeGetReq (DbeBeginIdiom, req, info); + UnlockDisplay (dpy); + SyncHandle (); + + return (Status)1; /* success */ +} + + +/* + * XdbeEndIdiom - + * This function marks the end of an idiom sequence. + */ +#if NeedFunctionPrototypes +Status XdbeEndIdiom ( + Display *dpy) +#else +Status XdbeEndIdiom (dpy) + Display *dpy; +#endif +{ + XExtDisplayInfo *info = find_display(dpy); + register xDbeEndIdiomReq *req; + + DbeCheckExtension (dpy, info, (Status)0 /* failure */); + + LockDisplay (dpy); + DbeGetReq (DbeEndIdiom, req, info); + UnlockDisplay (dpy); + SyncHandle (); + + return (Status)1; /* success */ +} + + +/* + * XdbeGetVisualInfo - + * This function returns information about which visuals support + * double buffering. The argument num_screens specifies how many + * elements there are in the screen_specifiers list. Each drawable + * in screen_specifiers designates a screen for which the supported + * visuals are being requested. If num_screens is zero, information + * for all screens is requested. In this case, upon return from this + * function, num_screens will be set to the number of screens that were + * found. If an error occurs, this function returns NULL, else it returns + * a pointer to a list of XdbeScreenVisualInfo structures of length + * num_screens. The nth element in the returned list corresponds to the + * nth drawable in the screen_specifiers list, unless num_screens was + * passed in with the value zero, in which case the nth element in the + * returned list corresponds to the nth screen of the server, starting + * with screen zero. + */ +#if NeedFunctionPrototypes +XdbeScreenVisualInfo *XdbeGetVisualInfo ( + Display *dpy, + Drawable *screen_specifiers, + int *num_screens) /* SEND and RETURN */ +#else +XdbeScreenVisualInfo *XdbeGetVisualInfo (dpy, screen_specifiers, num_screens) + Display *dpy; + Drawable *screen_specifiers; + int *num_screens; /* SEND and RETURN */ +#endif +{ + XExtDisplayInfo *info = find_display(dpy); + register xDbeGetVisualInfoReq *req; + xDbeGetVisualInfoReply rep; + XdbeScreenVisualInfo *scrVisInfo; + int i; + + DbeCheckExtension (dpy, info, (XdbeScreenVisualInfo *)NULL); + + LockDisplay (dpy); + + DbeGetReq(DbeGetVisualInfo, req, info); + req->length = 2 + *num_screens; + req->n = *num_screens; + Data32 (dpy, screen_specifiers, (*num_screens * sizeof (CARD32))); + + if (!_XReply (dpy, (xReply *) &rep, 0, xFalse)) { + UnlockDisplay (dpy); + SyncHandle (); + return NULL; + } + + /* return the number of screens actually found if we + * requested information about all screens (*num_screens == 0) + */ + if (*num_screens == 0) + *num_screens = rep.m; + + /* allocate list of visual information to be returned */ + if (!(scrVisInfo = + (XdbeScreenVisualInfo *)Xmalloc( + (unsigned)(*num_screens * sizeof(XdbeScreenVisualInfo))))) { + UnlockDisplay (dpy); + SyncHandle (); + return NULL; + } + + for (i = 0; i < *num_screens; i++) + { + int nbytes; + int j; + long c; + + _XRead32 (dpy, (char *)&c, sizeof(CARD32)); + scrVisInfo[i].count = c; + + nbytes = scrVisInfo[i].count * sizeof(XdbeVisualInfo); + + /* if we can not allocate the list of visual/depth info + * then free the lists that we already allocate as well + * as the visual info list itself + */ + if (!(scrVisInfo[i].visinfo = (XdbeVisualInfo *)Xmalloc( + (unsigned)nbytes))) { + for (j = 0; j < i; j++) { + Xfree ((char *)scrVisInfo[j].visinfo); + } + Xfree ((char *)scrVisInfo); + UnlockDisplay (dpy); + SyncHandle (); + return NULL; + } + + /* Read the visual info item into the wire structure. Then copy each + * element into the library structure. The element sizes and/or + * padding may be different in the two structures. + */ + for (j = 0; j < scrVisInfo[i].count; j++) { + xDbeVisInfo xvi; + + _XRead (dpy, (char *)&xvi, sizeof(xDbeVisInfo)); + scrVisInfo[i].visinfo[j].visual = xvi.visualID; + scrVisInfo[i].visinfo[j].depth = xvi.depth; + scrVisInfo[i].visinfo[j].perflevel = xvi.perfLevel; + } + + } + + UnlockDisplay (dpy); + SyncHandle (); + return scrVisInfo; + +} /* XdbeGetVisualInfo() */ + + +/* + * XdbeFreeVisualInfo - + * This function frees the list of XdbeScreenVisualInfo returned by the + * function XdbeGetVisualInfo. + */ +#if NeedFunctionPrototypes +void XdbeFreeVisualInfo( + XdbeScreenVisualInfo *visual_info) +#else +void XdbeFreeVisualInfo(visual_info) + XdbeScreenVisualInfo *visual_info; +#endif +{ + if (visual_info == NULL) { + return; + } + + if (visual_info->visinfo) { + XFree(visual_info->visinfo); + } + + XFree(visual_info); +} + + +/* + * XdbeGetBackBufferAttributes - + * This function returns the attributes associated with the specified + * buffer. + */ +#if NeedFunctionPrototypes +XdbeBackBufferAttributes *XdbeGetBackBufferAttributes( + Display *dpy, + XdbeBackBuffer buffer) +#else +XdbeBackBufferAttributes *XdbeGetBackBufferAttributes(dpy, buffer) + Display *dpy; + XdbeBackBuffer buffer; +#endif +{ + XExtDisplayInfo *info = find_display(dpy); + register xDbeGetBackBufferAttributesReq *req; + xDbeGetBackBufferAttributesReply rep; + XdbeBackBufferAttributes *attr; + + DbeCheckExtension(dpy, info, (XdbeBackBufferAttributes *)NULL); + + if (!(attr = + (XdbeBackBufferAttributes *)Xmalloc(sizeof(XdbeBackBufferAttributes)))) { + return NULL; + } + + LockDisplay(dpy); + DbeGetReq(DbeGetBackBufferAttributes, req, info); + req->buffer = buffer; + + if (!_XReply (dpy, (xReply *) &rep, 0, xTrue)) { + UnlockDisplay (dpy); + SyncHandle (); + return NULL; + } + attr->window = rep.attributes; + + UnlockDisplay (dpy); + SyncHandle (); + + return attr; +} + diff --git a/src/extutil.c b/src/extutil.c new file mode 100644 index 0000000..8fa6aec --- /dev/null +++ b/src/extutil.c @@ -0,0 +1,298 @@ +/* + * $Xorg: extutil.c,v 1.4 2001/02/09 02:03:49 xorgcvs Exp $ + * +Copyright 1989, 1998 The Open Group + +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. + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN +AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN +CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +Except as contained in this notice, the name of The Open Group shall not be +used in advertising or otherwise to promote the sale, use or other dealings +in this Software without prior written authorization from The Open Group. + * + * Author: Jim Fulton, MIT X Consortium + * + * + * Xlib Extension-Writing Utilities + * + * This package contains utilities for writing the client API for various + * protocol extensions. THESE INTERFACES ARE NOT PART OF THE X STANDARD AND + * ARE SUBJECT TO CHANGE! + * + * Routines include: + * + * XextCreateExtension called once per extension + * XextDestroyExtension if no longer using extension + * XextAddDisplay add another display + * XextRemoveDisplay remove a display + * XextFindDisplay is a display open + * + * In addition, the following Xlib-style interfaces are provided: + * + * XSetExtensionErrorHandler establish an extension error handler + * XMissingExtension raise an error about missing ext + */ + +#include +#include "Xlibint.h" +#include "Xext.h" +#include "extutil.h" + + +/* + * XextCreateExtension - return an extension descriptor containing context + * information for this extension. This object is passed to all Xext + * routines. + */ +XExtensionInfo *XextCreateExtension () +{ + register XExtensionInfo *info = + (XExtensionInfo *) Xmalloc (sizeof (XExtensionInfo)); + + if (info) { + info->head = NULL; + info->cur = NULL; + info->ndisplays = 0; + } + return info; +} + + +/* + * XextDestroyExtension - free memory the given extension descriptor + */ +void XextDestroyExtension (info) + XExtensionInfo *info; +{ + info->head = NULL; /* to catch refs after this */ + info->cur = NULL; + info->ndisplays = 0; + XFree ((char *) info); +} + + + +/* + * XextAddDisplay - add a display to this extension + */ +XExtDisplayInfo *XextAddDisplay (extinfo, dpy, ext_name, hooks, nevents, data) + XExtensionInfo *extinfo; + Display *dpy; + char *ext_name; + XExtensionHooks *hooks; + int nevents; + XPointer data; +{ + XExtDisplayInfo *dpyinfo; + + dpyinfo = (XExtDisplayInfo *) Xmalloc (sizeof (XExtDisplayInfo)); + if (!dpyinfo) return NULL; + dpyinfo->display = dpy; + dpyinfo->data = data; + dpyinfo->codes = XInitExtension (dpy, ext_name); + + /* + * if the server has the extension, then we can initialize the + * appropriate function vectors + */ + if (dpyinfo->codes) { + int i, j; + + for (i = 0, j = dpyinfo->codes->first_event; i < nevents; i++, j++) { + XESetWireToEvent (dpy, j, hooks->wire_to_event); + XESetEventToWire (dpy, j, hooks->event_to_wire); + } + if (hooks->create_gc) + XESetCreateGC (dpy, dpyinfo->codes->extension, hooks->create_gc); + if (hooks->copy_gc) + XESetCopyGC (dpy, dpyinfo->codes->extension, hooks->copy_gc); + if (hooks->flush_gc) + XESetFlushGC (dpy, dpyinfo->codes->extension, hooks->flush_gc); + if (hooks->free_gc) + XESetFreeGC (dpy, dpyinfo->codes->extension, hooks->free_gc); + if (hooks->create_font) + XESetCreateFont (dpy, dpyinfo->codes->extension, hooks->create_font); + if (hooks->free_font) + XESetFreeFont (dpy, dpyinfo->codes->extension, hooks->free_font); + if (hooks->close_display) + XESetCloseDisplay (dpy, dpyinfo->codes->extension, + hooks->close_display); + if (hooks->error) + XESetError (dpy, dpyinfo->codes->extension, hooks->error); + if (hooks->error_string) + XESetErrorString (dpy, dpyinfo->codes->extension, + hooks->error_string); + } else if (hooks->close_display) { + /* The server doesn't have this extension. + * Use a private Xlib-internal extension to hang the close_display + * hook on so that the "cache" (extinfo->cur) is properly cleaned. + * (XBUG 7955) + */ + XExtCodes *codes = XAddExtension(dpy); + if (!codes) { + XFree(dpyinfo); + return NULL; + } + XESetCloseDisplay (dpy, codes->extension, hooks->close_display); + } + + /* + * now, chain it onto the list + */ + _XLockMutex(_Xglobal_lock); + dpyinfo->next = extinfo->head; + extinfo->head = dpyinfo; + extinfo->cur = dpyinfo; + extinfo->ndisplays++; + _XUnlockMutex(_Xglobal_lock); + return dpyinfo; +} + + +/* + * XextRemoveDisplay - remove the indicated display from the extension object + */ +int XextRemoveDisplay (extinfo, dpy) + XExtensionInfo *extinfo; + Display *dpy; +{ + XExtDisplayInfo *dpyinfo, *prev; + + /* + * locate this display and its back link so that it can be removed + */ + _XLockMutex(_Xglobal_lock); + prev = NULL; + for (dpyinfo = extinfo->head; dpyinfo; dpyinfo = dpyinfo->next) { + if (dpyinfo->display == dpy) break; + prev = dpyinfo; + } + if (!dpyinfo) { + _XUnlockMutex(_Xglobal_lock); + return 0; /* hmm, actually an error */ + } + + /* + * remove the display from the list; handles going to zero + */ + if (prev) + prev->next = dpyinfo->next; + else + extinfo->head = dpyinfo->next; + + extinfo->ndisplays--; + if (dpyinfo == extinfo->cur) extinfo->cur = NULL; /* flush cache */ + _XUnlockMutex(_Xglobal_lock); + + Xfree ((char *) dpyinfo); + return 1; +} + + +/* + * XextFindDisplay - look for a display in this extension; keeps a cache + * of the most-recently used for efficiency. + */ +XExtDisplayInfo *XextFindDisplay (extinfo, dpy) + XExtensionInfo *extinfo; + Display *dpy; +{ + register XExtDisplayInfo *dpyinfo; + + /* + * see if this was the most recently accessed display + */ + if ((dpyinfo = extinfo->cur)&& dpyinfo->display == dpy) return dpyinfo; + + + /* + * look for display in list + */ + _XLockMutex(_Xglobal_lock); + for (dpyinfo = extinfo->head; dpyinfo; dpyinfo = dpyinfo->next) { + if (dpyinfo->display == dpy) { + extinfo->cur = dpyinfo; /* cache most recently used */ + _XUnlockMutex(_Xglobal_lock); + return dpyinfo; + } + } + _XUnlockMutex(_Xglobal_lock); + + return NULL; +} + + + +static int _default_exterror (dpy, ext_name, reason) + Display *dpy; + char *ext_name; + char *reason; +{ + fprintf (stderr, "Xlib: extension \"%s\" %s on display \"%s\".\n", + ext_name, reason, DisplayString(dpy)); + return 0; +} + + +/* + * XSetExtensionErrorHandler - sets the handler that gets called when a + * requested extension is referenced. This should eventually move into Xlib. + */ + +extern int (*_XExtensionErrorFunction)(); + +#if NeedFunctionPrototypes +int (*XSetExtensionErrorHandler( + int (*handler)( +#if NeedNestedPrototypes + Display*, + char *, + char * +#endif + ) +))() +#else +int (*XSetExtensionErrorHandler(handler))() + int (*handler)(); +#endif +{ + int (*oldhandler)() = _XExtensionErrorFunction; + + _XExtensionErrorFunction = (handler ? handler : + _default_exterror); + return oldhandler; +} + + +/* + * XMissingExtension - call the extension error handler + */ +#if NeedFunctionPrototypes +int XMissingExtension ( + Display *dpy, + _Xconst char *ext_name) +#else +int XMissingExtension (dpy, ext_name) + Display *dpy; + char *ext_name; +#endif +{ + int (*func)() = (_XExtensionErrorFunction ? + _XExtensionErrorFunction : _default_exterror); + + if (!ext_name) ext_name = X_EXTENSION_UNKNOWN; + return (*func) (dpy, ext_name, X_EXTENSION_MISSING); +} diff --git a/src/globals.c b/src/globals.c new file mode 100644 index 0000000..07fdeeb --- /dev/null +++ b/src/globals.c @@ -0,0 +1,89 @@ +/* $Xorg: globals.c,v 1.4 2001/02/09 02:03:50 xorgcvs Exp $ */ +/* + +Copyright 1989, 1998 The Open Group + +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. + +The above copyright notice and this permission notice shall be included +in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS +OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. +IN NO EVENT SHALL THE OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR +OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, +ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR +OTHER DEALINGS IN THE SOFTWARE. + +Except as contained in this notice, the name of The Open Group shall +not be used in advertising or otherwise to promote the sale, use or +other dealings in this Software without prior written authorization +from The Open Group. + +*/ +/* + * This file should contain only those objects which must be predefined. + */ +#include +#include +#ifndef X_NOT_STDC_ENV +#include /* for definition of NULL */ +#else +#include +#endif + +/* + * If possible, it is useful to have the global data default to a null value. + * Some shared library implementations are *much* happier if there isn't any + * global initialized data. + */ +#ifdef NULL_NOT_ZERO /* then need to initialize */ +#define SetZero(t,var,z) t var = z +#else +#define SetZero(t,var,z) t var +#endif + +#ifdef ATTSHAREDLIB /* then need extra variables */ +/* + * If we need to define extra variables for each global + */ +#if (defined(__STDC__) && !defined(UNIXCPP)) || defined(ANSICPP) +#define ZEROINIT(t,var,val) SetZero(t,var,val); \ + SetZero (long, _libX_##var##Flag, 0); \ + SetZero (void *, _libX_##var##Ptr, NULL) +#else /* else pcc concatenation */ +#define ZEROINIT(t,var,val) SetZero(t,var,val); \ + SetZero (long, _libX_/**/var/**/Flag, 0); \ + SetZero (void *, _libX_/**/var/**/Ptr, NULL) +#endif /* concat ANSI C vs. pcc */ + +#else /* else not ATTSHAREDLIB */ +/* + * no extra crud + */ +#define ZEROINIT(t,var,val) SetZero (t, var, val) + +#endif /* ATTSHAREDLIB */ + + +/* + * Error handlers; used to be in XlibInt.c + */ +typedef int (*funcptr)(); +ZEROINIT (funcptr, _XExtensionErrorFunction, NULL); + +/* + * NOTE: any additional external definition NEED + * to be inserted BELOW this point!!! + */ + +/* + * NOTE: any additional external definition NEED + * to be inserted ABOVE this point!!! + */ + -- cgit v1.2.3