aboutsummaryrefslogtreecommitdiff
path: root/nx-X11/lib/Xss
diff options
context:
space:
mode:
Diffstat (limited to 'nx-X11/lib/Xss')
-rw-r--r--nx-X11/lib/Xss/Imakefile47
-rw-r--r--nx-X11/lib/Xss/XScrnSaver.c442
-rw-r--r--nx-X11/lib/Xss/Xss-def.cpp14
-rw-r--r--nx-X11/lib/Xss/Xss.man328
4 files changed, 831 insertions, 0 deletions
diff --git a/nx-X11/lib/Xss/Imakefile b/nx-X11/lib/Xss/Imakefile
new file mode 100644
index 000000000..bd7f7a8fc
--- /dev/null
+++ b/nx-X11/lib/Xss/Imakefile
@@ -0,0 +1,47 @@
+XCOMM $XFree86: xc/lib/Xss/Imakefile,v 3.5 2003/10/26 18:59:49 herrb Exp $
+#define DoNormalLib NormalLibXss
+#define DoSharedLib SharedLibXss
+#define DoExtraLib SharedLibXss
+#define DoDebugLib DebugLibXss
+#define DoProfileLib ProfileLibXss
+#define LibName Xss
+#define SoRev SOXSSREV
+#define LibHeaders NO
+
+#include <Threads.tmpl>
+
+#ifdef SharedXssReqs
+REQUIREDLIBS = SharedXssReqs
+#endif
+
+SCRNSAVSRC = XScrnSaver.c
+SCRNSAVOBJ = XScrnSaver.o
+
+#if Malloc0ReturnsNull
+ALLOC_DEFINES = -DMALLOC_0_RETURNS_NULL
+#endif
+
+ DEFINES = $(ALLOC_DEFINES)
+ SRCS = $(SCRNSAVSRC)
+ OBJS = $(SCRNSAVOBJ)
+ LINTLIBS = $(LINTXLIB)
+
+#define IncludeSharedObjectInNormalLib
+
+MANSUFFIX=$(LIBMANSUFFIX)
+InstallManPage(LibName,$(LIBMANDIR))
+#if ExpandManNames
+InstallManPageAliases(LibName,$(LIBMANDIR), XScreenSaverQueryExtension \ @@\
+ XScreenSaverQueryVersion \ @@\
+ XScreenSaverAllocInfo \ @@\
+ XScreenSaverQueryInfo \ @@\
+ XScreenSaverSelectInput \ @@\
+ XScreenSaverSetAttributes \ @@\
+ XScreenSaverUnsetAttributes \ @@\
+ XScreenSaverRegister \ @@\
+ XScreenSaverUnregister \ @@\
+ XScreenSaverGetRegistered)
+#endif
+#include <Library.tmpl>
+
+DependTarget()
diff --git a/nx-X11/lib/Xss/XScrnSaver.c b/nx-X11/lib/Xss/XScrnSaver.c
new file mode 100644
index 000000000..3727ae4f6
--- /dev/null
+++ b/nx-X11/lib/Xss/XScrnSaver.c
@@ -0,0 +1,442 @@
+/*
+ * $XConsortium: XScrnSaver.c,v 1.5 94/04/17 20:59:35 rws Exp $
+ *
+Copyright (c) 1992 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 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 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 dealings
+in this Software without prior written authorization from the X Consortium.
+ *
+ * Author: Keith Packard, MIT X Consortium
+ */
+/* $XFree86: xc/lib/Xss/XScrnSaver.c,v 3.1 2001/10/28 03:32:40 tsi Exp $ */
+
+#define NEED_EVENTS
+#define NEED_REPLIES
+#include <X11/Xlibint.h>
+#include <X11/Xutil.h>
+#include <X11/extensions/Xext.h>
+#include <X11/extensions/extutil.h>
+#include <X11/extensions/saverproto.h>
+#include <X11/extensions/scrnsaver.h>
+
+
+static XExtensionInfo _screen_saver_info_data;
+static XExtensionInfo *screen_saver_info = &_screen_saver_info_data;
+static /* const */ char *screen_saver_extension_name = ScreenSaverName;
+
+#define ScreenSaverCheckExtension(dpy,i,val) \
+ XextCheckExtension (dpy, i, screen_saver_extension_name, val)
+#define ScreenSaverSimpleCheckExtension(dpy,i) \
+ XextSimpleCheckExtension (dpy, i, screen_saver_extension_name)
+
+static int close_display();
+static Bool wire_to_event();
+static Status event_to_wire();
+static /* const */ XExtensionHooks screen_saver_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, screen_saver_info,
+ screen_saver_extension_name,
+ &screen_saver_extension_hooks,
+ ScreenSaverNumberEvents, NULL)
+
+static XEXT_GENERATE_CLOSE_DISPLAY (close_display, screen_saver_info)
+
+
+static Bool wire_to_event (dpy, re, event)
+ Display *dpy;
+ XEvent *re;
+ xEvent *event;
+{
+ XExtDisplayInfo *info = find_display (dpy);
+ XScreenSaverNotifyEvent *se;
+ xScreenSaverNotifyEvent *sevent;
+
+ ScreenSaverCheckExtension (dpy, info, False);
+
+ switch ((event->u.u.type & 0x7f) - info->codes->first_event) {
+ case ScreenSaverNotify:
+ se = (XScreenSaverNotifyEvent *) re;
+ sevent = (xScreenSaverNotifyEvent *) 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->window = sevent->root;
+ se->state = sevent->state;
+ se->kind = sevent->kind;
+ se->forced = True;
+ if (sevent->forced == xFalse)
+ se->forced = False;
+ se->time = sevent->timestamp;
+ return True;
+ }
+ return False;
+}
+
+static Status event_to_wire (dpy, re, event)
+ Display *dpy;
+ XEvent *re;
+ xEvent *event;
+{
+ XExtDisplayInfo *info = find_display (dpy);
+ XScreenSaverNotifyEvent *se;
+ xScreenSaverNotifyEvent *sevent;
+
+ ScreenSaverCheckExtension (dpy, info, 0);
+
+ switch ((re->type & 0x7f) - info->codes->first_event) {
+ case ScreenSaverNotify:
+ se = (XScreenSaverNotifyEvent *) re;
+ sevent = (xScreenSaverNotifyEvent *) event;
+ sevent->type = se->type | (se->send_event ? 0x80 : 0);
+ sevent->sequenceNumber = se->serial & 0xffff;
+ sevent->root = se->root;
+ sevent->window = se->window;
+ sevent->state = se->state;
+ sevent->kind = se->kind;
+ sevent->forced = xFalse;
+ if (se->forced == True)
+ sevent->forced = xTrue;
+ sevent->timestamp = se->time;
+ return 1;
+ }
+ return 0;
+}
+
+/****************************************************************************
+ * *
+ * ScreenSaver public interfaces *
+ * *
+ ****************************************************************************/
+
+Bool XScreenSaverQueryExtension (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 XScreenSaverQueryVersion(dpy, major_versionp, minor_versionp)
+ Display *dpy;
+ int *major_versionp, *minor_versionp;
+{
+ XExtDisplayInfo *info = find_display (dpy);
+ xScreenSaverQueryVersionReply rep;
+ register xScreenSaverQueryVersionReq *req;
+
+ ScreenSaverCheckExtension (dpy, info, 0);
+
+ LockDisplay (dpy);
+ GetReq (ScreenSaverQueryVersion, req);
+ req->reqType = info->codes->major_opcode;
+ req->saverReqType = X_ScreenSaverQueryVersion;
+ req->clientMajor = ScreenSaverMajorVersion;
+ req->clientMinor = ScreenSaverMinorVersion;
+ 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;
+}
+
+XScreenSaverInfo *XScreenSaverAllocInfo ()
+{
+ return (XScreenSaverInfo *) Xmalloc (sizeof (XScreenSaverInfo));
+}
+
+Status XScreenSaverQueryInfo (dpy, drawable, saver_info)
+ Display *dpy;
+ Drawable drawable;
+ XScreenSaverInfo *saver_info;
+{
+ XExtDisplayInfo *info = find_display (dpy);
+ xScreenSaverQueryInfoReply rep;
+ register xScreenSaverQueryInfoReq *req;
+
+ ScreenSaverCheckExtension (dpy, info, 0);
+
+ LockDisplay (dpy);
+ GetReq (ScreenSaverQueryInfo, req);
+ req->reqType = info->codes->major_opcode;
+ req->saverReqType = X_ScreenSaverQueryInfo;
+ req->drawable = drawable;
+ if (!_XReply (dpy, (xReply *) &rep, 0, xTrue)) {
+ UnlockDisplay (dpy);
+ SyncHandle ();
+ return 0;
+ }
+ UnlockDisplay (dpy);
+ SyncHandle ();
+ saver_info->window = rep.window;
+ saver_info->state = rep.state;
+ saver_info->kind = rep.kind;
+ saver_info->til_or_since = rep.tilOrSince;
+ saver_info->idle = rep.idle;
+ saver_info->eventMask = rep.eventMask;
+ return 1;
+}
+
+void XScreenSaverSelectInput (dpy, drawable, mask)
+ register Display *dpy;
+ Drawable drawable;
+ unsigned long mask;
+{
+ XExtDisplayInfo *info = find_display (dpy);
+ register xScreenSaverSelectInputReq *req;
+
+ ScreenSaverSimpleCheckExtension (dpy, info);
+
+ LockDisplay (dpy);
+ GetReq (ScreenSaverSelectInput, req);
+ req->reqType = info->codes->major_opcode;
+ req->saverReqType = X_ScreenSaverSelectInput;
+ req->drawable = drawable;
+ req->eventMask = mask;
+ UnlockDisplay (dpy);
+ SyncHandle ();
+}
+
+static void
+XScreenSaverProcessWindowAttributes (dpy, req, valuemask, attributes)
+ register Display *dpy;
+ xChangeWindowAttributesReq *req;
+ register unsigned long valuemask;
+ register XSetWindowAttributes *attributes;
+ {
+ unsigned long values[32];
+ register unsigned long *value = values;
+ unsigned int nvalues;
+
+ if (valuemask & CWBackPixmap)
+ *value++ = attributes->background_pixmap;
+
+ if (valuemask & CWBackPixel)
+ *value++ = attributes->background_pixel;
+
+ if (valuemask & CWBorderPixmap)
+ *value++ = attributes->border_pixmap;
+
+ if (valuemask & CWBorderPixel)
+ *value++ = attributes->border_pixel;
+
+ if (valuemask & CWBitGravity)
+ *value++ = attributes->bit_gravity;
+
+ if (valuemask & CWWinGravity)
+ *value++ = attributes->win_gravity;
+
+ if (valuemask & CWBackingStore)
+ *value++ = attributes->backing_store;
+
+ if (valuemask & CWBackingPlanes)
+ *value++ = attributes->backing_planes;
+
+ if (valuemask & CWBackingPixel)
+ *value++ = attributes->backing_pixel;
+
+ if (valuemask & CWOverrideRedirect)
+ *value++ = attributes->override_redirect;
+
+ if (valuemask & CWSaveUnder)
+ *value++ = attributes->save_under;
+
+ if (valuemask & CWEventMask)
+ *value++ = attributes->event_mask;
+
+ if (valuemask & CWDontPropagate)
+ *value++ = attributes->do_not_propagate_mask;
+
+ if (valuemask & CWColormap)
+ *value++ = attributes->colormap;
+
+ if (valuemask & CWCursor)
+ *value++ = attributes->cursor;
+
+ req->length += (nvalues = value - values);
+
+ nvalues <<= 2; /* watch out for macros... */
+ Data32 (dpy, (long *) values, (long)nvalues);
+
+ }
+
+void XScreenSaverSetAttributes (dpy, drawable, x, y, width, height,
+ border_width, depth, class, visual,
+ valuemask, attributes)
+ Display* dpy;
+ Drawable drawable;
+ int x;
+ int y;
+ unsigned int width;
+ unsigned int height;
+ unsigned int border_width;
+ int depth;
+ unsigned int class;
+ Visual * visual;
+ unsigned long valuemask;
+ XSetWindowAttributes *attributes;
+{
+ XExtDisplayInfo *info = find_display (dpy);
+ register xScreenSaverSetAttributesReq *req;
+
+ ScreenSaverSimpleCheckExtension (dpy, info);
+
+ LockDisplay (dpy);
+ GetReq (ScreenSaverSetAttributes, req);
+ req->reqType = info->codes->major_opcode;
+ req->saverReqType = X_ScreenSaverSetAttributes;
+ req->drawable = drawable;
+ req->x = x;
+ req->y = y;
+ req->width = width;
+ req->height = height;
+ req->borderWidth = border_width;
+ req->c_class = class;
+ req->depth = depth;
+ if (visual == CopyFromParent)
+ req->visualID = CopyFromParent;
+ else
+ req->visualID = visual->visualid;
+ /* abuse an Xlib internal interface - is this legal for us? */
+ if ((req->mask = valuemask))
+ XScreenSaverProcessWindowAttributes (dpy,
+ (xChangeWindowAttributesReq *)req,
+ valuemask, attributes);
+ UnlockDisplay (dpy);
+ SyncHandle ();
+}
+
+
+void XScreenSaverUnsetAttributes (dpy, drawable)
+ register Display *dpy;
+ Drawable drawable;
+{
+ XExtDisplayInfo *info = find_display (dpy);
+ register xScreenSaverUnsetAttributesReq *req;
+
+ ScreenSaverSimpleCheckExtension (dpy, info);
+
+ LockDisplay (dpy);
+ GetReq (ScreenSaverUnsetAttributes, req);
+ req->reqType = info->codes->major_opcode;
+ req->saverReqType = X_ScreenSaverUnsetAttributes;
+ req->drawable = drawable;
+ UnlockDisplay (dpy);
+ SyncHandle ();
+}
+
+
+Status XScreenSaverRegister (dpy, screen, xid, type)
+ Display *dpy;
+ int screen;
+ XID xid;
+ Atom type;
+{
+ Atom prop;
+ unsigned long ul;
+
+ prop = XInternAtom (dpy, ScreenSaverPropertyName, False);
+ if (!prop)
+ return 0;
+
+ ul = (unsigned long) xid;
+ XChangeProperty (dpy, RootWindow(dpy,screen), prop, type, 32,
+ PropModeReplace, (unsigned char *) &ul, 1);
+ return 1;
+}
+
+
+
+Status XScreenSaverUnregister (dpy, screen)
+ Display *dpy;
+ int screen;
+{
+ Atom prop;
+
+ prop = XInternAtom (dpy, ScreenSaverPropertyName, False);
+ if (!prop)
+ return 0;
+
+ XDeleteProperty (dpy, RootWindow(dpy,screen), prop);
+ return 1;
+}
+
+
+
+Status XScreenSaverGetRegistered (dpy, screen, xid, type)
+ Display *dpy;
+ int screen;
+ XID *xid;
+ Atom *type;
+{
+ Atom actual_type = None;
+ int actual_format;
+ unsigned long nitems, bytesafter;
+ unsigned long *ulp = (unsigned long *) 0;
+ Atom prop;
+ int retval = 0;
+
+ prop = XInternAtom (dpy, ScreenSaverPropertyName, False);
+ if (!prop)
+ return retval;
+
+ if (XGetWindowProperty (dpy, RootWindow(dpy,screen), prop, 0L, 1L, False,
+ AnyPropertyType, &actual_type, &actual_format,
+ &nitems, &bytesafter, (unsigned char **) &ulp)
+ != Success)
+ return retval;
+
+ if (ulp) {
+ if (actual_format == 32) {
+ *xid = (XID) ulp[0];
+ *type = actual_type;
+ retval = 1;
+ }
+ XFree ((char *) ulp);
+ }
+ return retval;
+}
diff --git a/nx-X11/lib/Xss/Xss-def.cpp b/nx-X11/lib/Xss/Xss-def.cpp
new file mode 100644
index 000000000..60d529cf1
--- /dev/null
+++ b/nx-X11/lib/Xss/Xss-def.cpp
@@ -0,0 +1,14 @@
+LIBRARY Xss
+EXPORTS
+ XScreenSaverQueryExtension
+ XScreenSaverQueryVersion
+ XScreenSaverAllocInfo
+ XScreenSaverQueryInfo
+ XScreenSaverSelectInput
+ XScreenSaverSetAttributes
+ XScreenSaverUnsetAttributes
+ XScreenSaverRegister
+ XScreenSaverUnregister
+ XScreenSaverGetRegistered
+
+/* $XFree86: xc/lib/Xss/Xss-def.cpp,v 1.1 2000/08/09 23:40:13 dawes Exp $ */
diff --git a/nx-X11/lib/Xss/Xss.man b/nx-X11/lib/Xss/Xss.man
new file mode 100644
index 000000000..fa1545241
--- /dev/null
+++ b/nx-X11/lib/Xss/Xss.man
@@ -0,0 +1,328 @@
+.\"
+.\" $XFree86: xc/lib/Xss/Xss.man,v 1.1 2003/10/26 19:00:24 herrb Exp $
+.\" $XdotOrg: xc/lib/Xss/Xss.man,v 1.2 2004/04/23 18:43:51 eich Exp $
+.\"
+.\" Copyright (C) 2003 The XFree86 Project, Inc. All Rights Reserved.
+.\"
+.\" 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 NON-INFRINGEMENT.
+.\" IN NO EVENT SHALL THE XFREE86 PROJECT 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 XFree86 Project
+.\" 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 XFree86 Project.
+.\"
+.TH XScreenSaver __libmansuffix__ __vendorversion__
+.SH NAME
+XScreenSaver \- X11 Screen Saver extension client library
+.SH SYNOPSIS
+.B #include <X11/extension/scrnsaver.h>
+.PP
+.nf
+.ta .5i 2i
+typedef struct {
+ Window window; /\(** screen saver window */
+ int state; /\(** ScreenSaver{Off,On,Disabled} */
+ int kind; /\(** ScreenSaver{Blanked,Internal,External} */
+ unsigned long til_or_since; /\(** milliseconds */
+ unsigned long idle; /\(** milliseconds */
+ unsigned long event_mask; /\(** events */
+.br
+} XScreenSaverInfo;
+
+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; /\(** screen saver window */
+ Window root; /\(** root window of event screen */
+ int state; /\(** ScreenSaver{Off,On,Cycle} */
+ int kind; /\(** ScreenSaver{Blanked,Internal,External} */
+ Bool forced; /\(** extents of new region */
+ Time time; /\(** event timestamp */
+.br
+} XScreenSaverNotifyEvent;
+.fi
+.HP
+Bool XScreenSaverQueryExtension(Display *\fIdpy\fP,
+int *\fIevent_basep\fP, int *\fIerror_basep\fP\^);
+.HP
+Status XScreenSaverQueryVersion(Display *\fIdpy\fP, int *\fImajor_versionp\fP,
+int *\fIminor_versionp\fP\^);
+.HP
+XScreenSaverInfo *XScreenSaverAllocInfo(\^void\^);
+.HP
+Status XScreenSaverQueryInfo(\^Display *\fIdpy\fP, Drawable \fIdrawable\fP,
+XScreenSaverInfo *\fIsaver_info\fP\^);
+.HP
+void XScreenSaverSelectInput(Display *\fIdpy\fP, Drawable \fIdrawable\fP,
+unsigned long \fImask\fp\^);
+.HP
+void XScreenSaverSetAttributes(Display *\fIdpy\fP, Drawable \fIdrawable\fP,
+int \fIx\fP,
+int \fIy\fP,
+unsigned int \fIwidth\fP,
+unsigned int \fIheight\fP,
+unsigned int \fIborder_width\fP,
+int \fIdepth\fP,
+unsigned int \fIclass\fP,
+Visual *\fIvisual\fP,
+unsigned long \fIvaluemask\fP,
+XSetWindowAttributes *\fIattributes\fP\^);
+.HP
+void XScreenSaverUnsetAttributes(Display *\fIdpy\fP,
+Drawable \fIdrawable\fP\^);
+.HP
+void XScreenSaverSaverRegister(Display *\fIdpy\fP, int \fIscreen\fP,
+XID \fIxid\fP, Atom \fItype\fP\^);
+.HP
+Status XScreenSaverUnregister(Display *\fIdpy\fP, int \fIscreen\fP\^);
+.HP
+Status XScreenSaverGetRegistered(Display *\fIdpy\fP, int \fIscreen\fP,
+XID *\fIxid\fP, Atom *\fItype\fP\^);
+.PP
+.SH DESCRIPTION
+The X Window System provides support for changing the image on a
+display screen after a user-settable period of inactivity to avoid
+burning the cathode ray tube phosphors.
+However, no interfaces are provided for the user to control the image
+that is drawn.
+This extension allows an external ``screen saver'' client to detect
+when the alternate image is to be displayed and to provide the
+graphics.
+.PP
+Current X server implementations typically provide at least one form of
+``screen saver'' image.
+Historically, this has been a copy of the X logo drawn against the
+root background pattern.
+However, many users have asked for the mechanism to allow them to
+write screen saver programs that provide capabilities similar to those
+provided by other window systems.
+In particular, such users often wish to be able to display corporate
+logos, instructions on how to reactivate the screen, and automatic
+screen-locking utilities.
+This extension provides a means for writing such clients.
+.SS Assumptions
+This extension exports the notion of a special screen saver window that is
+mapped above all other windows on a display.
+This window has the \fIoverride-redirect\fP attribute set so that it
+is not subject to manipulation by the window manager.
+Furthermore, the X identifier for the window is never returned by
+\fBQueryTree\fP requests on the root window, so it is typically not
+visible to other clients.
+.PP
+.B XScreenSaverQueryExtension
+returns
+.B True
+if the
+.I XScreenSaver
+extension is available on the given display.
+A client must call
+.B XScreenSaverQueryExtension
+before calling any other XScreenSaver function in order
+to negotiate a compatible protocol version; otherwise the client will
+get undefined behavior (XScreenSaver may or may not work).
+.PP
+If the extension is supported, the event number for
+.I ScreenSaverNotify
+events is returned in the value pointed to by \fIevent_base\fP.
+Since no additional errors are defined by this extension, the results
+of \fIerror_base\fP are not defined.
+.PP
+.B XScreenSaverQueryVersion
+returns
+.B True
+if the request succeeded; the values of the major and minor protocol
+versions supported by the server are returned in
+.I major_versionp
+and
+.I minor_versionp .
+.PP
+.B XScreenSaverAllocInfo
+allocates and returns an \fBXScreenSaverInfo\fP structure
+for use in calls to \fBXScreenSaverQueryInfo\fP.
+All fields in the structure are initialized to zero.
+If insufficient memory is available, NULL is returned.
+The results of this routine can be released using \fIXFree\fP.
+.PP
+.B XScreenSaverQueryInfo
+returns information about the current state of the
+screen server in \fIsaver_info\fP and a non-zero value is
+returned.
+If the extension is not supported, \fIsaver_info\fP is not changed and 0
+is returned.
+.br
+The \fIstate\fP field specifies whether or not the screen saver is currently
+active and how the \fItil-or-since\fP value should be interpreted:
+.TP 4
+.I Off
+The screen is not currently being saved; \fItil-or-since\fP
+specifies the number of milliseconds until the screen saver is expected to
+activate.
+.TP 4
+.I On
+The screen is currently being saved; \fItil-or-since\fP specifies
+the number of milliseconds since the screen saver activated.
+.TP 4
+.I Disabled
+The screen saver is currently disabled; \fItil-or-since\fP is zero.
+.br
+The \fIkind\fP field specifies the mechanism that either is currently being
+used or would have been were the screen being saved:
+.TP 4
+.I Blanked
+The video signal to the display monitor was disabled.
+.TP 4
+.I Internal
+A server-dependent, built-in screen saver image was displayed; either no
+client had set the screen saver window attributes or a different client
+had the server grabbed when the screen saver activated.
+.TP 4
+.I External
+The screen saver window was mapped with attributes set by a
+client using the \fBScreenSaverSetAttributes\fP request.
+.PP
+The \fIidle\fP field specifies the number of milliseconds since the last
+input was received from the user on any of the input devices.
+.br
+The \fIevent-mask\fP field specifies which, if any, screen saver
+events this client has requested using \fBScreenSaverSelectInput\fP.
+.PP
+.B XScreenSaverSelectInput
+asks that events related to
+the screen saver be generated for this client.
+If
+no bits are set in \fIevent-mask\fP, then no events will be generated.
+Otherwise, any combination of the following bits may be set:
+.TP 8
+.B ScreenSaverNotify
+If this bit is set, \fBScreenSaverNotify\fP events are generated whenever
+the screen saver is activated or deactivated.
+.TP 8
+.B ScreenSaverCycle
+If this bit is set, \fBScreenSaverNotify\fP events are generated whenever
+the screen saver cycle interval passes.
+.PP
+.B XScreenSaverSetAttributes
+sets the attributes to be used
+the next time the external screen saver is activated.
+If another client currently has the attributes set,
+a BadAccess error is generated and the request is ignored.
+.br
+Otherwise, the specified window attributes are checked as if
+they were used in a core \fBCreateWindow\fP request whose
+parent is the root.
+The \fIoverride-redirect\fP field is ignored as it is implicitly set
+to True.
+If the window attributes result in an error according to the rules for
+\fBCreateWindow\fP, the request is ignored.
+.br
+Otherwise, the attributes are stored and will take effect on the next
+activation that occurs when the server is not grabbed by another client.
+Any resources specified for the
+\fIbackground-pixmap\fP or \fIcursor\fP attributes may be
+freed immediately.
+The server is free to copy the \fIbackground-pixmap\fP or \fIcursor\fP
+resources or to use them in place; therefore, the effect of changing
+the contents of those resources is undefined.
+If the specified \fIcolormap\fP no longer exists when the screen saver
+activates, the parent's colormap is used instead.
+If no errors are generated by this request, any previous screen saver
+window attributes set by this client are released.
+.br
+When the screen saver next activates and the server is not grabbed by
+another client, the screen saver window is
+created, if necessary, and set to the specified attributes and events
+are generated as usual.
+The colormap associated with the screen saver window is installed.
+Finally, the screen saver window is mapped.
+.br
+The window remains mapped and at the top of the stacking order
+until the screen saver is deactivated in response to activity on
+any of the user input devices, a \fBForceScreenSaver\fP request with
+a value of Reset, or any request that would cause the window to be
+unmapped.
+.br
+If the screen saver activates while the server is grabbed by another
+client, the internal saver mechanism is used.
+The \fBForceScreenSaver\fP request may be used with a value of Active
+to deactivate the internal saver and activate the external saver.
+.br
+If the screen saver client's connection to the server is broken
+while the screen saver is activated and the client's close down mode has not
+been RetainPermanent or RetainTemporary, the current screen saver
+is deactivated and the internal screen saver is immediately activated.
+.br
+When the screen saver deactivates, the screen saver window's colormap
+is uninstalled and the window is unmapped (except as described below).
+The screen saver XID is disassociated
+with the window and the server may, but is not required to,
+destroy the window along with any children.
+.br
+When the screen saver is being deactivated and then immediately
+reactivated (such as when switching screen savers), the server
+may leave the screen saver window mapped (typically to avoid
+generating exposures).
+.PP
+.B XScreenSaverUnsetAttributes
+instructs the server to discard
+any previous screen saver window attributes set by this client.
+.PP
+.B XScreenSaverRegister
+stores the given \fIXID\fP in the \fB_SCREEN_SAVER_ID\fP
+property (of the given \fItype\fP) on the
+root window of the specified \fIscreen\fP.
+It returns zero if an error is encountered and the property is not
+changed, otherwise it returns non-zero.
+.PP
+.B XScreenSaverUnregister
+removes any \fB_SCREEN_SAVER_ID\fP from the
+root window of the specified \fIscreen\fP.
+It returns zero if an error is encountered and the property is
+changed, otherwise it returns non-zero.
+.PP
+.B XScreenSaverGetRegistered
+returns the \fIXID\fP and \fItype\fP stored in
+the \fB_SCREEN_SAVER_ID\fP property on the
+root window of the specified \fIscreen\fP.
+It returns zero if an error is encountered or if the property does not
+exist or is not of the correct format; otherwise it returns non-zero.
+.SH "ERRORS"
+.B XScreenSaverSelectInput,
+.B XScreenSaverQueryInfo,
+.B XScreenSaverSetAttributes
+and
+.B XScreenSaverUnsetAttributes
+will generate a
+.I BadDrawable
+error if \fIdrawable\fP is not a valid drawable identifier.
+If any undefined bits are set in \fIevent-mask\fP,
+a BadValue error is generated by
+.B XScreenSaverSelectInput .
+.PP
+.SH "SEE ALSO"
+X(__miscmansuffix__)
+.SH AUTHORS
+Jim Fulton and Keith Packard.
+.SH STABILITY
+This API is considered as experimental.
+The Xss library major revision may be incremented whenever
+incompatible changes are done to the API without notice.
+Use with care.
generated by cgit v1.2.3 (git 2.25.1) at 2024-11-17 08:43:38 +0000