--- /dev/null
+/* $Xorg: dsimple.c,v 1.4 2001/02/09 02:05:54 xorgcvs Exp $ */
+/*
+
+Copyright 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.
+
+*/
+
+#include <X11/Xos.h>
+#include <X11/Xlib.h>
+#include <X11/Xutil.h>
+#include <X11/cursorfont.h>
+#include <stdio.h>
+/*
+ * Other_stuff.h: Definitions of routines in other_stuff.
+ *
+ * Written by Mark Lillibridge. Last updated 7/1/87
+ */
+
+unsigned long Resolve_Color();
+Pixmap Bitmap_To_Pixmap();
+Window Select_Window();
+void out();
+void blip();
+Window Window_With_Name();
+void Fatal_Error();
+
+/*
+ * Just_display: A group of routines designed to make the writting of simple
+ * X11 applications which open a display but do not open
+ * any windows much faster and easier. Unless a routine says
+ * otherwise, it may be assumed to require program_name, dpy,
+ * and screen already defined on entry.
+ *
+ * Written by Mark Lillibridge. Last updated 7/1/87
+ */
+
+
+/* This stuff is defined in the calling program by just_display.h */
+extern char *program_name;
+extern Display *dpy;
+extern int screen;
+
+
+/*
+ * Malloc: like malloc but handles out of memory using Fatal_Error.
+ */
+char *Malloc(size)
+ unsigned size;
+{
+ char *data, *malloc();
+
+ if (!(data = malloc(size)))
+ Fatal_Error("Out of memory!");
+
+ return(data);
+}
+
+
+/*
+ * Realloc: like Malloc except for realloc, handles NULL using Malloc.
+ */
+char *Realloc(ptr, size)
+ char *ptr;
+ int size;
+{
+ char *new_ptr, *realloc();
+
+ if (!ptr)
+ return(Malloc(size));
+
+ if (!(new_ptr = realloc(ptr, size)))
+ Fatal_Error("Out of memory!");
+
+ return(new_ptr);
+}
+
+
+/*
+ * Get_Display_Name (argc, argv) Look for -display, -d, or host:dpy (obselete)
+ * If found, remove it from command line. Don't go past a lone -.
+ */
+char *Get_Display_Name(pargc, argv)
+ int *pargc; /* MODIFIED */
+ char **argv; /* MODIFIED */
+{
+ int argc = *pargc;
+ char **pargv = argv+1;
+ char *displayname = NULL;
+ int i;
+
+ for (i = 1; i < argc; i++) {
+ char *arg = argv[i];
+
+ if (!strcmp (arg, "-display") || !strcmp (arg, "-d")) {
+ if (++i >= argc) usage ();
+
+ displayname = argv[i];
+ *pargc -= 2;
+ continue;
+ }
+ if (!strcmp(arg,"-")) {
+ while (i<argc)
+ *pargv++ = argv[i++];
+ break;
+ }
+ *pargv++ = arg;
+ }
+
+ *pargv = NULL;
+ return (displayname);
+}
+
+
+/*
+ * Open_Display: Routine to open a display with correct error handling.
+ * Does not require dpy or screen defined on entry.
+ */
+Display *Open_Display(display_name)
+char *display_name;
+{
+ Display *d;
+
+ d = XOpenDisplay(display_name);
+ if (d == NULL) {
+ fprintf (stderr, "%s: unable to open display '%s'\n",
+ program_name, XDisplayName (display_name));
+ usage ();
+ /* doesn't return */
+ }
+
+ return(d);
+}
+
+
+/*
+ * Setup_Display_And_Screen: This routine opens up the correct display (i.e.,
+ * it calls Get_Display_Name) and then stores a
+ * pointer to it in dpy. The default screen
+ * for this display is then stored in screen.
+ * Does not require dpy or screen defined.
+ */
+void Setup_Display_And_Screen(argc, argv)
+int *argc; /* MODIFIED */
+char **argv; /* MODIFIED */
+{
+ dpy = Open_Display (Get_Display_Name(argc, argv));
+ screen = DefaultScreen(dpy);
+}
+
+
+/*
+ * Open_Font: This routine opens a font with error handling.
+ */
+XFontStruct *Open_Font(name)
+char *name;
+{
+ XFontStruct *font;
+
+ if (!(font=XLoadQueryFont(dpy, name)))
+ Fatal_Error("Unable to open font %s!", name);
+
+ return(font);
+}
+
+
+/*
+ * Beep: Routine to beep the display.
+ */
+void Beep()
+{
+ XBell(dpy, 50);
+}
+
+
+/*
+ * ReadBitmapFile: same as XReadBitmapFile except it returns the bitmap
+ * directly and handles errors using Fatal_Error.
+ */
+static void _bitmap_error(status, filename)
+ int status;
+ char *filename;
+{
+ if (status == BitmapOpenFailed)
+ Fatal_Error("Can't open file %s!", filename);
+ else if (status == BitmapFileInvalid)
+ Fatal_Error("file %s: Bad bitmap format.", filename);
+ else
+ Fatal_Error("Out of memory!");
+}
+
+Pixmap ReadBitmapFile(d, filename, width, height, x_hot, y_hot)
+ Drawable d;
+ char *filename;
+ int *width, *height, *x_hot, *y_hot;
+{
+ Pixmap bitmap;
+ int status;
+
+ status = XReadBitmapFile(dpy, RootWindow(dpy, screen), filename,
+ (unsigned int *)width, (unsigned int *)height,
+ &bitmap, x_hot, y_hot);
+ if (status != BitmapSuccess)
+ _bitmap_error(status, filename);
+
+ return(bitmap);
+}
+
+
+/*
+ * WriteBitmapFile: same as XWriteBitmapFile except it handles errors
+ * using Fatal_Error.
+ */
+void WriteBitmapFile(filename, bitmap, width, height, x_hot, y_hot)
+ char *filename;
+ Pixmap bitmap;
+ int width, height, x_hot, y_hot;
+{
+ int status;
+
+ status= XWriteBitmapFile(dpy, filename, bitmap, width, height, x_hot,
+ y_hot);
+ if (status != BitmapSuccess)
+ _bitmap_error(status, filename);
+}
+
+
+/*
+ * Select_Window_Args: a rountine to provide a common interface for
+ * applications that need to allow the user to select one
+ * window on the screen for special consideration.
+ * This routine implements the following command line
+ * arguments:
+ *
+ * -root Selects the root window.
+ * -id <id> Selects window with id <id>. <id> may
+ * be either in decimal or hex.
+ * -name <name> Selects the window with name <name>.
+ *
+ * Call as Select_Window_Args(&argc, argv) in main before
+ * parsing any of your program's command line arguments.
+ * Select_Window_Args will remove its arguments so that
+ * your program does not have to worry about them.
+ * The window returned is the window selected or 0 if
+ * none of the above arguments was present. If 0 is
+ * returned, Select_Window should probably be called after
+ * all command line arguments, and other setup is done.
+ * For examples of usage, see xwininfo, xwd, or xprop.
+ */
+Window Select_Window_Args(rargc, argv)
+ int *rargc;
+ char **argv;
+#define ARGC (*rargc)
+{
+ int nargc=1;
+ int argc;
+ char **nargv;
+ Window w=0;
+
+ nargv = argv+1; argc = ARGC;
+#define OPTION argv[0]
+#define NXTOPTP ++argv, --argc>0
+#define NXTOPT if (++argv, --argc==0) usage()
+#define COPYOPT nargv++[0]=OPTION, nargc++
+
+ while (NXTOPTP) {
+ if (!strcmp(OPTION, "-")) {
+ COPYOPT;
+ while (NXTOPTP)
+ COPYOPT;
+ break;
+ }
+ if (!strcmp(OPTION, "-root")) {
+ w=RootWindow(dpy, screen);
+ continue;
+ }
+ if (!strcmp(OPTION, "-name")) {
+ NXTOPT;
+ w = Window_With_Name(dpy, RootWindow(dpy, screen),
+ OPTION);
+ if (!w)
+ Fatal_Error("No window with name %s exists!",OPTION);
+ continue;
+ }
+ if (!strcmp(OPTION, "-id")) {
+ NXTOPT;
+ w=0;
+ sscanf(OPTION, "0x%lx", &w);
+ if (!w)
+ sscanf(OPTION, "%ld", &w);
+ if (!w)
+ Fatal_Error("Invalid window id format: %s.", OPTION);
+ continue;
+ }
+ COPYOPT;
+ }
+ ARGC = nargc;
+
+ return(w);
+}
+
+/*
+ * Other_stuff: A group of routines which do common X11 tasks.
+ *
+ * Written by Mark Lillibridge. Last updated 7/1/87
+ */
+
+extern Display *dpy;
+extern int screen;
+
+/*
+ * Resolve_Color: This routine takes a color name and returns the pixel #
+ * that when used in the window w will be of color name.
+ * (WARNING: The colormap of w MAY be modified! )
+ * If colors are run out of, only the first n colors will be
+ * as correct as the hardware can make them where n depends
+ * on the display. This routine does not require wind to
+ * be defined.
+ */
+unsigned long Resolve_Color(w, name)
+ Window w;
+ char *name;
+{
+ XColor c;
+ Colormap colormap;
+ XWindowAttributes wind_info;
+
+ /*
+ * The following is a hack to insure machines without a rgb table
+ * handle at least white & black right.
+ */
+ if (!strcmp(name, "white"))
+ name="#ffffffffffff";
+ if (!strcmp(name, "black"))
+ name="#000000000000";
+
+ XGetWindowAttributes(dpy, w, &wind_info);
+ colormap = wind_info.colormap;
+
+ if (!XParseColor(dpy, colormap, name, &c))
+ Fatal_Error("Bad color format '%s'.", name);
+
+ if (!XAllocColor(dpy, colormap, &c))
+ Fatal_Error("XAllocColor failed!");
+
+ return(c.pixel);
+}
+
+
+/*
+ * Bitmap_To_Pixmap: Convert a bitmap to a 2 colored pixmap. The colors come
+ * from the foreground and background colors of the gc.
+ * Width and height are required solely for efficiency.
+ * If needed, they can be obtained via. XGetGeometry.
+ */
+Pixmap Bitmap_To_Pixmap(dpy, d, gc, bitmap, width, height)
+ Display *dpy;
+ Drawable d;
+ GC gc;
+ Pixmap bitmap;
+ int width, height;
+{
+ Pixmap pix;
+ int x;
+ unsigned int i, depth;
+ Drawable root;
+
+ if (!XGetGeometry(dpy, d, &root, &x, &x, &i, &i, &i, &depth))
+ return(0);
+
+ pix = XCreatePixmap(dpy, d, width, height, (int)depth);
+
+ XCopyPlane(dpy, bitmap, pix, gc, 0, 0, width, height, 0, 0, 1);
+
+ return(pix);
+}
+
+
+/*
+ * blip: a debugging routine. Prints Blip! on stderr with flushing.
+ */
+void blip()
+{
+ outl("blip!");
+}
+
+
+/*
+ * Routine to let user select a window using the mouse
+ */
+
+Window Select_Window(dpy)
+ Display *dpy;
+{
+ int status;
+ Cursor cursor;
+ XEvent event;
+ Window target_win = None, root = RootWindow(dpy,screen);
+ int buttons = 0;
+
+ /* Make the target cursor */
+ cursor = XCreateFontCursor(dpy, XC_crosshair);
+
+ /* Grab the pointer using target cursor, letting it room all over */
+ status = XGrabPointer(dpy, root, False,
+ ButtonPressMask|ButtonReleaseMask, GrabModeSync,
+ GrabModeAsync, root, cursor, CurrentTime);
+ if (status != GrabSuccess) Fatal_Error("Can't grab the mouse.");
+
+ /* Let the user select a window... */
+ while ((target_win == None) || (buttons != 0)) {
+ /* allow one more event */
+ XAllowEvents(dpy, SyncPointer, CurrentTime);
+ XWindowEvent(dpy, root, ButtonPressMask|ButtonReleaseMask, &event);
+ switch (event.type) {
+ case ButtonPress:
+ if (target_win == None) {
+ target_win = event.xbutton.subwindow; /* window selected */
+ if (target_win == None) target_win = root;
+ }
+ buttons++;
+ break;
+ case ButtonRelease:
+ if (buttons > 0) /* there may have been some down before we started */
+ buttons--;
+ break;
+ }
+ }
+
+ XUngrabPointer(dpy, CurrentTime); /* Done with pointer */
+
+ return(target_win);
+}
+
+
+/*
+ * Window_With_Name: routine to locate a window with a given name on a display.
+ * If no window with the given name is found, 0 is returned.
+ * If more than one window has the given name, the first
+ * one found will be returned. Only top and its subwindows
+ * are looked at. Normally, top should be the RootWindow.
+ */
+Window Window_With_Name(dpy, top, name)
+ Display *dpy;
+ Window top;
+ char *name;
+{
+ Window *children, dummy;
+ unsigned int nchildren;
+ int i;
+ Window w=0;
+ char *window_name;
+
+ if (XFetchName(dpy, top, &window_name) && !strcmp(window_name, name))
+ return(top);
+
+ if (!XQueryTree(dpy, top, &dummy, &dummy, &children, &nchildren))
+ return(0);
+
+ for (i=0; i<nchildren; i++) {
+ w = Window_With_Name(dpy, children[i], name);
+ if (w)
+ break;
+ }
+ if (children) XFree ((char *)children);
+ return(w);
+}
+
+/*
+ * outl: a debugging routine. Flushes stdout then prints a message on stderr
+ * and flushes stderr. Used to print messages when past certain points
+ * in code so we can tell where we are. Outl may be invoked like
+ * printf with up to 7 arguments.
+ */
+/* VARARGS1 */
+outl(msg, arg0,arg1,arg2,arg3,arg4,arg5,arg6)
+ char *msg;
+ char *arg0, *arg1, *arg2, *arg3, *arg4, *arg5, *arg6;
+{
+ fflush(stdout);
+ fprintf(stderr, msg, arg0, arg1, arg2, arg3, arg4, arg5, arg6);
+ fprintf(stderr, "\n");
+ fflush(stderr);
+}
+
+
+/*
+ * Standard fatal error routine - call like printf but maximum of 7 arguments.
+ * Does not require dpy or screen defined.
+ */
+/* VARARGS1 */
+void Fatal_Error(msg, arg0,arg1,arg2,arg3,arg4,arg5,arg6)
+char *msg;
+char *arg0, *arg1, *arg2, *arg3, *arg4, *arg5, *arg6;
+{
+ fflush(stdout);
+ fflush(stderr);
+ fprintf(stderr, "%s: error: ", program_name);
+ fprintf(stderr, msg, arg0, arg1, arg2, arg3, arg4, arg5, arg6);
+ fprintf(stderr, "\n");
+ exit(1);
+}
--- /dev/null
+/* $Xorg: dsimple.h,v 1.4 2001/02/09 02:05:54 xorgcvs Exp $ */
+/*
+
+Copyright 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.
+
+*/
+
+/*
+ * Just_display.h: This file contains the definitions needed to use the
+ * functions in just_display.c. It also declares the global
+ * variables dpy, screen, and program_name which are needed to
+ * use just_display.c.
+ *
+ * Written by Mark Lillibridge. Last updated 7/1/87
+ *
+ * Send bugs, etc. to chariot@athena.mit.edu.
+ */
+
+ /* Global variables used by routines in just_display.c */
+
+char *program_name = "unknown_program"; /* Name of this program */
+Display *dpy; /* The current display */
+int screen; /* The current screen */
+
+#define INIT_NAME program_name=argv[0] /* use this in main to setup
+ program_name */
+
+ /* Declaritions for functions in just_display.c */
+
+void Fatal_Error();
+char *Malloc();
+char *Realloc();
+char *Get_Display_Name();
+Display *Open_Display();
+void Setup_Display_And_Screen();
+XFontStruct *Open_Font();
+void Beep();
+Pixmap ReadBitmapFile();
+void WriteBitmapFile();
+Window Select_Window_Args();
+
+#define X_USAGE "[host:display]" /* X arguments handled by
+ Get_Display_Name */
+#define SELECT_USAGE "[{-root|-id <id>|-font <font>|-name <name>}]"
+
+/*
+ * Other_stuff.h: Definitions of routines in other_stuff.
+ *
+ * Written by Mark Lillibridge. Last updated 7/1/87
+ *
+ * Send bugs, etc. to chariot@athena.mit.edu.
+ */
+
+unsigned long Resolve_Color();
+Pixmap Bitmap_To_Pixmap();
+Window Select_Window();
+void out();
+void blip();
+Window Window_With_Name();
--- /dev/null
+/* $Xorg: list.c,v 1.5 2001/02/09 02:06:03 xorgcvs Exp $ */
+/** ------------------------------------------------------------------------
+ This file contains routines for manipulating generic lists.
+ Lists are implemented with a "harness". In other words, each
+ node in the list consists of two pointers, one to the data item
+ and one to the next node in the list. The head of the list is
+ the same struct as each node, but the "item" ptr is used to point
+ to the current member of the list (used by the first_in_list and
+ next_in_list functions).
+
+Copyright 1994 Hewlett-Packard Co.
+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 <stdio.h>
+#include "list.h"
+
+
+/** ------------------------------------------------------------------------
+ Sets the pointers of the specified list to NULL.
+ --------------------------------------------------------------------- **/
+#if NeedFunctionPrototypes
+void zero_list(list_ptr lp)
+#else
+void zero_list(lp)
+ list_ptr lp;
+#endif
+{
+ lp->next = NULL;
+ lp->ptr.item = NULL;
+}
+
+
+/** ------------------------------------------------------------------------
+ Adds item to the list pointed to by lp. Finds the end of the
+ list, then mallocs a new list node onto the end of the list.
+ The item pointer in the new node is set to "item" passed in,
+ and the next pointer in the new node is set to NULL.
+ Returns 1 if successful, 0 if the malloc failed.
+ -------------------------------------------------------------------- **/
+#if NeedFunctionPrototypes
+int add_to_list(list_ptr lp, void *item)
+#else
+int add_to_list(lp, item)
+ list_ptr lp;
+ void *item;
+#endif
+{
+ while (lp->next) {
+ lp = lp->next;
+ }
+ if ((lp->next = (list_ptr) malloc( sizeof( list_item))) == NULL) {
+
+ return 0;
+ }
+ lp->next->ptr.item = item;
+ lp->next->next = NULL;
+
+ return 1;
+}
+
+
+/** ------------------------------------------------------------------------
+ Creates a new list and sets its pointers to NULL.
+ Returns a pointer to the new list.
+ -------------------------------------------------------------------- **/
+list_ptr new_list ()
+{
+ list_ptr lp;
+
+ if ((lp = (list_ptr) malloc( sizeof( list_item)))) {
+ lp->next = NULL;
+ lp->ptr.item = NULL;
+ }
+
+ return lp;
+}
+
+
+/** ------------------------------------------------------------------------
+ Creates a new list head, pointing to the same list as the one
+ passed in. If start_at_curr is TRUE, the new list's first item
+ is the "current" item (as set by calls to first/next_in_list()).
+ If start_at_curr is FALSE, the first item in the new list is the
+ same as the first item in the old list. In either case, the
+ curr pointer in the new list is the same as in the old list.
+ Returns a pointer to the new list head.
+ -------------------------------------------------------------------- **/
+#if NeedFunctionPrototypes
+list_ptr dup_list_head(list_ptr lp, int start_at_curr)
+#else
+list_ptr dup_list_head(lp, start_at_curr)
+ list_ptr lp;
+ int start_at_curr;
+#endif
+{
+ list_ptr new_list;
+
+ if ((new_list = (list_ptr) malloc( sizeof( list_item))) == NULL) {
+
+ return (list_ptr)NULL;
+ }
+ new_list->next = start_at_curr ? lp->ptr.curr : lp->next;
+ new_list->ptr.curr = lp->ptr.curr;
+
+ return new_list;
+}
+
+
+/** ------------------------------------------------------------------------
+ Returns the number of items in the list.
+ -------------------------------------------------------------------- **/
+#if NeedFunctionPrototypes
+unsigned int list_length(list_ptr lp)
+#else
+unsigned int list_length(lp)
+ list_ptr lp;
+#endif
+{
+ unsigned int count = 0;
+
+ while (lp->next) {
+ count++;
+ lp = lp->next;
+ }
+
+ return count;
+}
+
+
+/** ------------------------------------------------------------------------
+ Scans thru list, looking for a node whose ptr.item is equal to
+ the "item" passed in. "Equal" here means the same address - no
+ attempt is made to match equivalent values stored in different
+ locations. If a match is found, that node is deleted from the
+ list. Storage for the node is freed, but not for the item itself.
+ Returns a pointer to the item, so the caller can free it if it
+ so desires. If a match is not found, returns NULL.
+ -------------------------------------------------------------------- **/
+#if NeedFunctionPrototypes
+void *delete_from_list(list_ptr lp, void *item)
+#else
+void *delete_from_list(lp, item)
+ list_ptr lp;
+ void *item;
+#endif
+{
+ list_ptr new_next;
+
+ while (lp->next) {
+ if (lp->next->ptr.item == item) {
+ new_next = lp->next->next;
+ free (lp->next);
+ lp->next = new_next;
+
+ return item;
+ }
+ lp = lp->next;
+ }
+
+ return NULL;
+}
+
+
+/** ------------------------------------------------------------------------
+ Deletes each node in the list *except the head*. This allows
+ the deletion of lists where the head is not malloced or created
+ with new_list(). If free_items is true, each item pointed to
+ from the node is freed, in addition to the node itself.
+ -------------------------------------------------------------------- **/
+#if NeedFunctionPrototypes
+void delete_list(list_ptr lp, int free_items)
+#else
+void delete_list(lp, free_items)
+ list_ptr lp;
+ int free_items;
+#endif
+{
+ list_ptr del_node;
+ void *item;
+
+ while (lp->next) {
+ del_node = lp->next;
+ item = del_node->ptr.item;
+ lp->next = del_node->next;
+ free (del_node);
+ if (free_items) {
+ free( item);
+ }
+ }
+}
+
+#if NeedFunctionPrototypes
+void delete_list_destroying(list_ptr lp, void destructor(void *item))
+#else
+void delete_list_destroying(lp, destructor)
+ list_ptr lp;
+ void (*destructor)();
+#endif
+{
+ list_ptr del_node;
+ void *item;
+
+ while (lp->next) {
+ del_node = lp->next;
+ item = del_node->ptr.item;
+ lp->next = del_node->next;
+ free( del_node);
+ if (destructor) {
+ destructor( item);
+ }
+ }
+}
+
+
+/** ------------------------------------------------------------------------
+ Returns a ptr to the first *item* (not list node) in the list.
+ Sets the list head node's curr ptr to the first node in the list.
+ Returns NULL if the list is empty.
+ -------------------------------------------------------------------- **/
+#if NeedFunctionPrototypes
+void * first_in_list(list_ptr lp)
+#else
+void * first_in_list(lp)
+ list_ptr lp;
+#endif
+{
+ if (! lp) {
+
+ return NULL;
+ }
+ lp->ptr.curr = lp->next;
+
+ return lp->ptr.curr ? lp->ptr.curr->ptr.item : NULL;
+}
+
+/** ------------------------------------------------------------------------
+ Returns a ptr to the next *item* (not list node) in the list.
+ Sets the list head node's curr ptr to the next node in the list.
+ first_in_list must have been called prior.
+ Returns NULL if no next item.
+ -------------------------------------------------------------------- **/
+#if NeedFunctionPrototypes
+void * next_in_list(list_ptr lp)
+#else
+void * next_in_list(lp)
+ list_ptr lp;
+#endif
+{
+ if (! lp) {
+
+ return NULL;
+ }
+ if (lp->ptr.curr) {
+ lp->ptr.curr = lp->ptr.curr->next;
+ }
+
+ return lp->ptr.curr ? lp->ptr.curr->ptr.item : NULL;
+}
+
+#if NeedFunctionPrototypes
+int list_is_empty(list_ptr lp)
+#else
+int list_is_empty(lp)
+ list_ptr lp;
+#endif
+{
+ return (lp == NULL || lp->next == NULL);
+}
+
--- /dev/null
+/* $Xorg: list.h,v 1.4 2001/02/09 02:06:03 xorgcvs Exp $ */
+/** ------------------------------------------------------------------------
+ This file contains routines for manipulating generic lists.
+ Lists are implemented with a "harness". In other words, each
+ node in the list consists of two pointers, one to the data item
+ and one to the next node in the list. The head of the list is
+ the same struct as each node, but the "item" ptr is used to point
+ to the current member of the list (used by the first_in_list and
+ next_in_list functions).
+
+Copyright 1994 Hewlett-Packard Co.
+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.
+
+ -------------------------------------------------------------------- **/
+
+#ifndef LIST_DEF
+#define LIST_DEF
+
+#define LESS -1
+#define EQUAL 0
+#define GREATER 1
+#define DUP_WHOLE_LIST 0
+#define START_AT_CURR 1
+
+typedef struct _list_item {
+ struct _list_item *next;
+ union {
+ void *item; /* in normal list node, pts to data */
+ struct _list_item *curr; /* in list head, pts to curr for 1st, next */
+ } ptr;
+} list, list_item, *list_ptr;
+
+typedef void (*DESTRUCT_FUNC_PTR)(
+#if NeedFunctionPrototypes
+void *
+#endif
+);
+
+void zero_list(
+#if NeedFunctionPrototypes
+ list_ptr
+#endif
+ );
+int add_to_list (
+#if NeedFunctionPrototypes
+ list_ptr , void *
+#endif
+ );
+list_ptr new_list (
+#if NeedFunctionPrototypes
+ void
+#endif
+ );
+list_ptr dup_list_head (
+#if NeedFunctionPrototypes
+ list_ptr , int
+#endif
+ );
+unsigned int list_length(
+#if NeedFunctionPrototypes
+ list_ptr
+#endif
+ );
+void *delete_from_list (
+#if NeedFunctionPrototypes
+ list_ptr , void *
+#endif
+ );
+void delete_list(
+#if NeedFunctionPrototypes
+ list_ptr , int
+#endif
+ );
+void delete_list_destroying (
+#if NeedFunctionPrototypes
+ list_ptr , DESTRUCT_FUNC_PTR
+#endif
+ );
+void *first_in_list (
+#if NeedFunctionPrototypes
+ list_ptr
+#endif
+ );
+void *next_in_list (
+#if NeedFunctionPrototypes
+ list_ptr
+#endif
+ );
+int list_is_empty (
+#if NeedFunctionPrototypes
+ list_ptr
+#endif
+ );
+
+#endif
--- /dev/null
+/* $Xorg: multiVis.c,v 1.5 2001/02/09 02:06:03 xorgcvs Exp $ */
+/** ------------------------------------------------------------------------
+ This file contains functions to create a list of regions which
+ tile a specified window. Each region contains all visible
+ portions of the window which are drawn with the same visual.
+ If the window consists of subwindows of two different visual types,
+ there will be two regions in the list. The list can be traversed
+ to correctly pull an image of the window using XGetImage or the
+ Image Library.
+
+Copyright 1994 Hewlett-Packard Co.
+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 <stdlib.h>
+#include <X11/Xlib.h>
+#include <X11/Xutil.h>
+#include <X11/X.h>
+#include <stdio.h>
+#include "list.h"
+#include "wsutils.h"
+#include "multiVis.h"
+static char *vis_class_str[] = { "StaticGray" , "GrayScale" , "StaticColor",
+ "PseudoColor","TrueColor","DirectColor" } ;
+/* These structures are copied from X11/region.h. For some reason
+ * they're invisible from the outside.
+ */
+typedef struct {
+ short x1, x2, y1, y2;
+} myBox, myBOX, myBoxRec, *myBoxPtr;
+
+typedef struct my_XRegion {
+ long size;
+ long numRects;
+ myBOX *rects;
+ myBOX extents;
+} myREGION;
+
+/* Items in long list of windows that have some part in the grabbed area */
+typedef struct {
+ Window win;
+ Visual *vis;
+ Colormap cmap;
+ int x_rootrel, y_rootrel; /* root relative location of window */
+ int x_vis, y_vis; /* rt rel x,y of vis part, not parent clipped */
+ int width, height; /* width and height of visible part */
+ int border_width; /* border width of the window */
+ Window parent; /* id of parent (for debugging) */
+} image_win_type;
+
+/* Items in short list of regions that tile the grabbed area. May have
+ multiple windows in the region.
+*/
+typedef struct {
+ Window win; /* lowest window of this visual */
+ Visual *vis;
+ Colormap cmap;
+ int x_rootrel, y_rootrel; /* root relative location of bottom window */
+ int x_vis, y_vis; /* rt rel x,y of vis part, not parent clipped */
+ int width, height; /* w & h of visible rect of bottom window */
+ int border; /* border width of the window */
+ Region visible_region;
+} image_region_type;
+
+/** ------------------------------------------------------------------------
+ Returns TRUE if the two structs pointed to have the same "vis" &
+ "cmap" fields and s2 lies completely within s1. s1 and s2 can
+ point to structs of image_win_type or image_region_type.
+ ------------------------------------------------------------------------ **/
+#define SAME_REGIONS( s1, s2) \
+ ((s1)->vis == (s2)->vis && (s1)->cmap == (s2)->cmap && \
+ (s1)->x_vis <= (s2)->x_vis && \
+ (s1)->y_vis <= (s2)->y_vis && \
+ (s1)->x_vis + (s1)->width >= (s2)->x_vis + (s2)->width && \
+ (s1)->y_vis + (s1)->height >= (s2)->y_vis + (s2)->height)
+
+#ifndef MIN
+#define MIN( a, b) ((a) < (b) ? a : b)
+#define MAX( a, b) ((a) > (b) ? a : b)
+#endif
+
+#define RED_SHIFT 16
+#define GREEN_SHIFT 8
+#define BLUE_SHIFT 0
+
+/*
+extern list_ptr new_list();
+extern list_ptr dup_list_head();
+extern void * first_in_list();
+extern void * next_in_list();
+extern int add_to_list();
+extern void zero_list();
+extern void delete_list();
+extern void delete_list_destroying();
+extern unsigned int list_length();
+*/
+
+/* Prototype Declarations for Static Functions */
+static int QueryColorMap(
+#if NeedFunctionPrototypes
+ Display *, Colormap , Visual *,
+ XColor **, int *, int *, int *
+#endif
+ );
+static void TransferImage(
+#if NeedFunctionPrototypes
+ Display *, XImage *,int, int , image_region_type*,
+ XImage *,int ,int
+#endif
+ );
+static XImage * ReadRegionsInList(
+#if NeedFunctionPrototypes
+ Display *, Visual *, int ,int ,int ,
+ int , XRectangle, list_ptr
+#endif
+ );
+
+static list_ptr make_region_list(
+#if NeedFunctionPrototypes
+ Display*, Window, XRectangle*,
+ int*, int, XVisualInfo**, int *
+#endif
+ );
+
+static void destroy_region_list(
+#if NeedFunctionPrototypes
+ list_ptr
+#endif
+ ) ;
+static void subtr_rect_from_image_region(
+#if NeedFunctionPrototypes
+ image_region_type *, int , int , int , int
+#endif
+ );
+static void add_rect_to_image_region(
+#if NeedFunctionPrototypes
+ image_region_type *,
+ int , int , int , int
+#endif
+ );
+static int src_in_region_list(
+#if NeedFunctionPrototypes
+ image_win_type *, list_ptr
+#endif
+ );
+static void add_window_to_list(
+#if NeedFunctionPrototypes
+ list_ptr, Window, int, int ,
+ int , int , int , int, int,
+ Visual*, Colormap, Window
+#endif
+ );
+static int src_in_image(
+#if NeedFunctionPrototypes
+ image_win_type *, int , XVisualInfo**
+#endif
+ );
+static int src_in_overlay(
+#if NeedFunctionPrototypes
+ image_region_type *, int, OverlayInfo *, int*, int*
+#endif
+ );
+
+/* End of Prototype Declarations */
+
+void initFakeVisual(Vis)
+Visual *Vis ;
+{
+ Vis->ext_data=NULL;
+ Vis->class = DirectColor ;
+ Vis->red_mask = 0x00FF0000;
+ Vis->green_mask = 0x0000FF00 ;
+ Vis->blue_mask = 0x000000FF ;
+ Vis->map_entries = 256 ;
+ Vis->bits_per_rgb = 8 ;
+}
+
+static int
+QueryColorMap(disp,src_cmap,src_vis,src_colors,rShift,gShift,bShift)
+Display *disp ;
+Visual *src_vis ;
+Colormap src_cmap ;
+XColor **src_colors ;
+int *rShift, *gShift, *bShift;
+{
+ int ncolors,i ;
+ unsigned long redMask, greenMask, blueMask;
+ int redShift, greenShift, blueShift;
+ XColor *colors ;
+
+ ncolors = src_vis->map_entries ;
+ *src_colors = colors = (XColor *)malloc(ncolors * sizeof(XColor) ) ;
+
+ if(src_vis->class != TrueColor && src_vis->class != DirectColor)
+ {
+ for(i=0 ; i < ncolors ; i++)
+ {
+ colors[i].pixel = i ;
+ colors[i].pad = 0;
+ colors[i].flags = DoRed|DoGreen|DoBlue;
+ }
+ }
+ else /** src is decomposed rgb ***/
+ {
+ /* Get the X colormap */
+ redMask = src_vis->red_mask;
+ greenMask = src_vis->green_mask;
+ blueMask = src_vis->blue_mask;
+ redShift = 0; while (!(redMask&0x1)) {
+ redShift++;
+ redMask = redMask>>1;
+ }
+ greenShift = 0; while (!(greenMask&0x1)) {
+ greenShift++;
+ greenMask = greenMask>>1;
+ }
+ blueShift = 0; while (!(blueMask&0x1)) {
+ blueShift++;
+ blueMask = blueMask>>1;
+ }
+ *rShift = redShift ;
+ *gShift = greenShift ;
+ *bShift = blueShift ;
+ for (i=0; i<ncolors; i++) {
+ if( i <= redMask)colors[i].pixel = (i<<redShift) ;
+ if( i <= greenMask)colors[i].pixel |= (i<<greenShift) ;
+ if( i <= blueMask)colors[i].pixel |= (i<<blueShift) ;
+ /***** example :for gecko's 3-3-2 map, blue index should be <= 3.
+ colors[i].pixel = (i<<redShift)|(i<<greenShift)|(i<<blueShift);
+ *****/
+ colors[i].pad = 0;
+ colors[i].flags = DoRed|DoGreen|DoBlue;
+ }
+ }
+
+
+ XQueryColors(disp, src_cmap, colors, ncolors);
+ return ncolors ;
+}
+
+int
+GetMultiVisualRegions(disp,srcRootWinid, x, y, width, height,
+ transparentOverlays,numVisuals, pVisuals,numOverlayVisuals, pOverlayVisuals,
+ numImageVisuals, pImageVisuals,vis_regions,vis_image_regions,allImage)
+ Display *disp;
+ Window srcRootWinid; /* root win on which grab was done */
+ int x; /* root rel UL corner of bounding box of grab */
+ int y;
+ unsigned int width; /* size of bounding box of grab */
+ unsigned int height;
+ int *transparentOverlays ;
+ int *numVisuals;
+ XVisualInfo **pVisuals;
+ int *numOverlayVisuals;
+ OverlayInfo **pOverlayVisuals;
+ int *numImageVisuals;
+ XVisualInfo ***pImageVisuals;
+ list_ptr *vis_regions; /* list of regions to read from */
+ list_ptr *vis_image_regions ;
+ int *allImage ;
+{
+ int hasNonDefault;
+ XRectangle bbox; /* bounding box of grabbed area */
+
+
+ bbox.x = x; /* init X rect for bounding box */
+ bbox.y = y;
+ bbox.width = width;
+ bbox.height = height;
+
+ GetXVisualInfo(disp,DefaultScreen(disp),
+ transparentOverlays,
+ numVisuals, pVisuals,
+ numOverlayVisuals, pOverlayVisuals,
+ numImageVisuals, pImageVisuals);
+
+ *vis_regions = *vis_image_regions = NULL ;
+ if ((*vis_regions = make_region_list( disp, srcRootWinid, &bbox,
+ &hasNonDefault, *numImageVisuals,
+ *pImageVisuals, allImage)) == NULL)
+ return 0 ;
+
+ if (*transparentOverlays)
+ {
+ *allImage = 1; /* until proven otherwise,
+ this flags that it to be an image only list */
+ *vis_image_regions =
+ make_region_list( disp, srcRootWinid, &bbox, &hasNonDefault,
+ *numImageVisuals, *pImageVisuals, allImage);
+ }
+
+ /* if there is a second region in any of the two lists return 1 **/
+ if ( ( *vis_regions && (*vis_regions)->next && (*vis_regions)->next->next ) ||
+ ( *vis_image_regions && (*vis_image_regions)->next &&
+ (*vis_image_regions)->next->next ) ) return 1 ;
+ else return 0 ;
+
+}
+
+static void TransferImage(disp,reg_image,srcw,srch,reg,
+ target_image,dst_x,dst_y)
+Display *disp;
+XImage *reg_image,*target_image ;
+image_region_type *reg;
+int srcw,srch,dst_x , dst_y ;
+{
+ int ncolors;
+ int i,j,old_pixel,new_pixel,red_ind,green_ind,blue_ind ;
+ XColor *colors;
+ int rShift,gShift,bShift;
+ int targetBytesPerLine ;
+
+ ncolors = QueryColorMap(disp,reg->cmap,reg->vis,&colors,
+ &rShift,&gShift,&bShift) ;
+
+ targetBytesPerLine = target_image->bytes_per_line;
+
+ switch (reg->vis->class) {
+ case TrueColor :
+ for(i=0 ; i < srch ; i++)
+ {
+ for(j=0 ; j < srcw ; j++)
+ {
+ old_pixel = XGetPixel(reg_image,j,i) ;
+
+ if( reg->vis->map_entries == 16) {
+
+ red_ind = (old_pixel & reg->vis->red_mask) >> rShift ;
+ green_ind = (old_pixel & reg->vis->green_mask) >> gShift ;
+ blue_ind = (old_pixel & reg->vis->blue_mask) >> bShift ;
+
+ new_pixel = (
+ ((colors[red_ind].red >> 8) << RED_SHIFT)
+ |((colors[green_ind].green >> 8) << GREEN_SHIFT)
+ |((colors[blue_ind].blue >> 8) << BLUE_SHIFT)
+ );
+ }
+ else
+ new_pixel = old_pixel;
+
+ XPutPixel(target_image,dst_x+j, dst_y+i,new_pixel);
+
+ }
+ }
+ break;
+ case DirectColor :
+ for(i=0 ; i < srch ; i++)
+ {
+
+ for(j=0 ; j < srcw ; j++)
+ {
+ old_pixel = XGetPixel(reg_image,j,i) ;
+ red_ind = (old_pixel & reg->vis->red_mask) >> rShift ;
+ green_ind = (old_pixel & reg->vis->green_mask) >> gShift ;
+ blue_ind = (old_pixel & reg->vis->blue_mask) >> bShift ;
+
+ new_pixel = (
+ ((colors[red_ind].red >> 8) << RED_SHIFT)
+ |((colors[green_ind].green >> 8) << GREEN_SHIFT)
+ |((colors[blue_ind].blue >> 8) << BLUE_SHIFT)
+ );
+ XPutPixel(target_image,dst_x+j, dst_y+i,new_pixel);
+
+ }
+ }
+ break;
+ default :
+ for(i=0 ; i < srch ; i++)
+ {
+ for(j=0 ; j < srcw ; j++)
+ {
+ old_pixel = XGetPixel(reg_image,j,i) ;
+
+ new_pixel = (
+ ((colors[old_pixel].red >> 8) << RED_SHIFT)
+ |((colors[old_pixel].green >> 8) << GREEN_SHIFT)
+ |((colors[old_pixel].blue >> 8) << BLUE_SHIFT)
+ );
+ XPutPixel(target_image,dst_x+j, dst_y+i,new_pixel);
+
+ }
+ }
+ break;
+ }
+}
+
+static XImage *
+ReadRegionsInList(disp,fakeVis,depth,format,width,height,bbox,regions)
+Display *disp ;
+Visual *fakeVis ;
+int depth , width , height ;
+int format ;
+XRectangle bbox; /* bounding box of grabbed area */
+list_ptr regions;/* list of regions to read from */
+{
+ image_region_type *reg;
+ int dst_x, dst_y; /* where in pixmap to write (UL) */
+ int diff;
+
+ XImage *reg_image,*ximage ;
+ int srcRect_x,srcRect_y,srcRect_width,srcRect_height ;
+ int rem ;
+ int bytes_per_line;
+ int bitmap_unit;
+
+ bitmap_unit = sizeof (long);
+ if (format == ZPixmap)
+ bytes_per_line = width*depth/8;
+ else
+ bytes_per_line = width/8;
+
+
+ /* Find out how many more bytes are required for padding so that
+ ** bytes per scan line will be multiples of bitmap_unit bits */
+ if (format == ZPixmap) {
+ rem = (bytes_per_line*8)%bitmap_unit;
+ if (rem)
+ bytes_per_line += (rem/8 + 1);
+ }
+
+ ximage = XCreateImage(disp,fakeVis,depth,format,0,NULL,width,height,
+ 8,0) ;
+ bytes_per_line = ximage->bytes_per_line;
+
+ if (format == ZPixmap)
+ ximage->data = malloc(height*bytes_per_line);
+ else
+ ximage->data = malloc(height*bytes_per_line*depth);
+
+ ximage->bits_per_pixel = depth; /** Valid only if format is ZPixmap ***/
+
+ for (reg = (image_region_type *) first_in_list( regions); reg;
+ reg = (image_region_type *) next_in_list( regions))
+ {
+ int rect;
+ struct my_XRegion *vis_reg;
+ vis_reg = (struct my_XRegion *)(reg->visible_region);
+ for (rect = 0;
+ rect < vis_reg->numRects;
+ rect++)
+ {
+ /** ------------------------------------------------------------------------
+ Intersect bbox with visible part of region giving src rect & output
+ location. Width is the min right side minus the max left side.
+ Similar for height. Offset src rect so x,y are relative to
+ origin of win, not the root-relative visible rect of win.
+ ------------------------------------------------------------------------ **/
+ srcRect_width = MIN( vis_reg->rects[rect].x2, bbox.width + bbox.x) -
+ MAX( vis_reg->rects[rect].x1, bbox.x);
+ srcRect_height = MIN( vis_reg->rects[rect].y2, bbox.height + bbox.y) -
+ MAX( vis_reg->rects[rect].y1, bbox.y);
+ diff = bbox.x - vis_reg->rects[rect].x1;
+ srcRect_x = MAX( 0, diff) + (vis_reg->rects[rect].x1 - reg->x_rootrel - reg->border);
+ dst_x = MAX( 0, -diff) ;
+ diff = bbox.y - vis_reg->rects[rect].y1;
+ srcRect_y = MAX( 0, diff) + (vis_reg->rects[rect].y1 - reg->y_rootrel - reg->border);
+ dst_y = MAX( 0, -diff) ;
+ reg_image = XGetImage(disp,reg->win,srcRect_x,srcRect_y,
+ srcRect_width,srcRect_height,AllPlanes,format) ;
+ TransferImage(disp,reg_image,srcRect_width,
+ srcRect_height,reg,ximage,dst_x,dst_y) ;
+ }
+ }
+ return ximage ;
+}
+
+
+/** ------------------------------------------------------------------------
+ ------------------------------------------------------------------------ **/
+
+XImage *ReadAreaToImage(disp, srcRootWinid, x, y, width, height,
+ numVisuals,pVisuals,numOverlayVisuals,pOverlayVisuals,numImageVisuals,
+ pImageVisuals,vis_regions,vis_image_regions,format,allImage)
+ Display *disp;
+ Window srcRootWinid; /* root win on which grab was done */
+ int x; /* root rel UL corner of bounding box of grab */
+ int y;
+ unsigned int width; /* size of bounding box of grab */
+ unsigned int height;
+ /** int transparentOverlays; ***/
+ int numVisuals;
+ XVisualInfo *pVisuals;
+ int numOverlayVisuals;
+ OverlayInfo *pOverlayVisuals;
+ int numImageVisuals;
+ XVisualInfo **pImageVisuals;
+ list_ptr vis_regions; /* list of regions to read from */
+ list_ptr vis_image_regions ;/* list of regions to read from */
+ int format;
+ int allImage ;
+{
+ image_region_type *reg;
+ XRectangle bbox; /* bounding box of grabbed area */
+ int depth ;
+ XImage *ximage, *ximage_ipm ;
+ Visual fakeVis ;
+ int x1, y1;
+ XImage *image;
+ unsigned char *pmData , *ipmData ;
+ int transparentColor, transparentType;
+ int srcRect_x,srcRect_y,srcRect_width,srcRect_height ;
+ int diff ;
+ int dst_x, dst_y; /* where in pixmap to write (UL) */
+ int pixel;
+
+ bbox.x = x; /* init X rect for bounding box */
+ bbox.y = y;
+ bbox.width = width;
+ bbox.height = height;
+
+
+ initFakeVisual(&fakeVis) ;
+
+ depth = 24 ;
+ ximage = ReadRegionsInList(disp,&fakeVis,depth,format,width,height,
+ bbox,vis_regions) ;
+ pmData = (unsigned char *)ximage -> data ;
+
+/* if transparency possible do it again, but this time for image planes only */
+ if (vis_image_regions && (vis_image_regions->next) && !allImage)
+ {
+ ximage_ipm = ReadRegionsInList(disp,&fakeVis,depth,format,width,height,
+ bbox,vis_image_regions) ;
+ ipmData = (unsigned char *)ximage_ipm -> data ;
+ }
+/* Now tranverse the overlay visual windows and test for transparency index. */
+/* If you find one, subsitute the value from the matching image plane pixmap. */
+
+ for (reg = (image_region_type *) first_in_list( vis_regions); reg;
+ reg = (image_region_type *) next_in_list( vis_regions))
+ {
+
+ if (src_in_overlay( reg, numOverlayVisuals, pOverlayVisuals,
+ &transparentColor, &transparentType))
+ {
+ int test = 0 ;
+ srcRect_width = MIN( reg->width + reg->x_vis, bbox.width + bbox.x)
+ - MAX( reg->x_vis, bbox.x);
+ srcRect_height = MIN( reg->height + reg->y_vis, bbox.height
+ + bbox.y) - MAX( reg->y_vis, bbox.y);
+ diff = bbox.x - reg->x_vis;
+ srcRect_x = MAX( 0, diff) + (reg->x_vis - reg->x_rootrel - reg->border);
+ dst_x = MAX( 0, -diff) ;
+ diff = bbox.y - reg->y_vis;
+ srcRect_y = MAX( 0, diff) + (reg->y_vis - reg->y_rootrel - reg->border);
+ dst_y = MAX( 0, -diff) ;
+ /* let's test some pixels for transparency */
+ image = XGetImage(disp, reg->win, srcRect_x, srcRect_y,
+ srcRect_width, srcRect_height, 0xffffffff, ZPixmap);
+
+ /* let's assume byte per pixel for overlay image for now */
+ if ((image->depth == 8) && (transparentType == TransparentPixel))
+ {
+ unsigned char *pixel_ptr;
+ unsigned char *start_of_line = (unsigned char *) image->data;
+
+ for (y1 = 0; y1 < srcRect_height; y1++) {
+ pixel_ptr = start_of_line;
+ for (x1 = 0; x1 < srcRect_width; x1++)
+ {
+ if (*pixel_ptr++ == transparentColor)
+ {
+ /*
+ *pmData++ = *ipmData++;
+ *pmData++ = *ipmData++;
+ *pmData++ = *ipmData++;
+ */
+ pixel = XGetPixel(ximage_ipm,dst_x+x1,dst_y+y1) ;
+ XPutPixel(ximage,dst_x+x1, dst_y+y1,pixel);
+
+ if(!test){
+ test = 1 ;
+ }
+ }
+ /*
+ else {
+ pmData +=3;
+ ipmData +=3;
+ }
+ */
+ }
+ start_of_line += image->bytes_per_line;
+ }
+ } else {
+ if (transparentType == TransparentPixel) {
+ for (y1 = 0; y1 < srcRect_height; y1++) {
+ for (x1 = 0; x1 < srcRect_width; x1++)
+ {
+ int pixel_value = XGetPixel(image, x1, y1);
+ if (pixel_value == transparentColor)
+ {
+ /*
+ *pmData++ = *ipmData++;
+ *pmData++ = *ipmData++;
+ *pmData++ = *ipmData++;
+ */
+ pixel = XGetPixel(ximage_ipm,dst_x+x1,dst_y+y1) ;
+ XPutPixel(ximage,dst_x+x1, dst_y+y1,pixel);
+ if(!test){
+ test = 1 ;
+ }
+ }
+ /*
+ else {
+ pmData +=3;
+ ipmData +=3;
+ }
+ */
+ }
+ }
+ } else {
+ for (y1 = 0; y1 < srcRect_height; y1++) {
+ for (x1 = 0; x1 < srcRect_width; x1++)
+ {
+ int pixel_value = XGetPixel(image, x1, y1);
+ if (pixel_value & transparentColor)
+ {
+ /*
+ *pmData++ = *ipmData++;
+ *pmData++ = *ipmData++;
+ *pmData++ = *ipmData++;
+ */
+ pixel = XGetPixel(ximage_ipm,dst_x+x1,dst_y+y1) ;
+ XPutPixel(ximage,dst_x+x1, dst_y+y1,pixel);
+ if(!test){
+ test = 1 ;
+ }
+ }
+ /*
+ else {
+ pmData +=3;
+ ipmData +=3;
+ }
+ */
+ }
+ }
+ }
+ }
+ XDestroyImage (image);
+ } /* end of src_in_overlay */
+ } /** end transparency **/
+ destroy_region_list( vis_regions);
+ if (vis_image_regions) destroy_region_list( vis_image_regions );
+ FreeXVisualInfo(pVisuals, pOverlayVisuals, pImageVisuals);
+ XSync(disp, 0);
+
+ return ximage;
+}
+
+/** ------------------------------------------------------------------------
+ Creates a list of the subwindows of a given window which have a
+ different visual than their parents. The function is recursive.
+ This list is used in make_region_list(), which coalesces the
+ windows with the same visual into a region.
+ image_wins must point to an existing list struct that's already
+ been zeroed (zero_list()).
+ ------------------------------------------------------------------------ **/
+static void make_src_list( disp, image_wins, bbox, curr, x_rootrel, y_rootrel,
+ curr_attrs, pclip)
+ Display *disp;
+ list_ptr image_wins;
+ XRectangle *bbox; /* bnding box of area we want */
+ Window curr;
+ int x_rootrel; /* pos of curr WRT root */
+ int y_rootrel;
+ XWindowAttributes *curr_attrs;
+ XRectangle *pclip; /* visible part of curr, not */
+ /* obscurred by ancestors */
+{
+ XWindowAttributes child_attrs;
+ Window root, parent, *child; /* variables for XQueryTree() */
+ Window *save_child_list; /* variables for XQueryTree() */
+ unsigned int nchild; /* variables for XQueryTree() */
+ XRectangle child_clip; /* vis part of child */
+ int curr_clipX, curr_clipY, curr_clipRt, curr_clipBt;
+
+ /* check that win is mapped & not outside bounding box */
+ if (curr_attrs->map_state == IsViewable &&
+ curr_attrs->class == InputOutput &&
+ !( pclip->x >= (int) (bbox->x + bbox->width) ||
+ pclip->y >= (int) (bbox->y + bbox->height) ||
+ (int) (pclip->x + pclip->width) <= bbox->x ||
+ (int) (pclip->y + pclip->height) <= bbox->y)) {
+
+ XQueryTree( disp, curr, &root, &parent, &child, &nchild );
+ save_child_list = child; /* so we can free list when we're done */
+ add_window_to_list( image_wins, curr, x_rootrel, y_rootrel,
+ pclip->x, pclip->y,
+ pclip->width, pclip->height,
+ curr_attrs->border_width,curr_attrs->visual,
+ curr_attrs->colormap, parent);
+
+
+/** ------------------------------------------------------------------------
+ set RR coords of right (Rt), left (X), bottom (Bt) and top (Y)
+ of rect we clip all children by. This is our own clip rect (pclip)
+ inflicted on us by our parent plus our own borders. Within the
+ child loop, we figure the clip rect for each child by adding in
+ it's rectangle (not taking into account the child's borders).
+ ------------------------------------------------------------------------ **/
+ curr_clipX = MAX( pclip->x, x_rootrel + (int) curr_attrs->border_width);
+ curr_clipY = MAX( pclip->y, y_rootrel + (int) curr_attrs->border_width);
+ curr_clipRt = MIN( pclip->x + (int) pclip->width,
+ x_rootrel + (int) curr_attrs->width +
+ 2 * (int) curr_attrs->border_width);
+ curr_clipBt = MIN( pclip->y + (int) pclip->height,
+ y_rootrel + (int) curr_attrs->height +
+ 2 * (int) curr_attrs->border_width);
+
+ while (nchild--) {
+ int new_width, new_height;
+ int child_xrr, child_yrr; /* root relative x & y of child */
+
+ XGetWindowAttributes( disp, *child, &child_attrs);
+
+ /* intersect parent & child clip rects */
+ child_xrr = x_rootrel + child_attrs.x + curr_attrs->border_width;
+ child_clip.x = MAX( curr_clipX, child_xrr);
+ new_width = MIN( curr_clipRt, child_xrr + (int) child_attrs.width
+ + 2 * child_attrs.border_width)
+ - child_clip.x;
+ if (new_width >= 0) {
+ child_clip.width = new_width;
+
+ child_yrr = y_rootrel + child_attrs.y +
+ curr_attrs->border_width;
+ child_clip.y = MAX( curr_clipY, child_yrr);
+ new_height = MIN( curr_clipBt,
+ child_yrr + (int) child_attrs.height +
+ 2 * child_attrs.border_width)
+ - child_clip.y;
+ if (new_height >= 0) {
+ child_clip.height = new_height;
+ make_src_list( disp, image_wins, bbox, *child,
+ child_xrr, child_yrr,
+ &child_attrs, &child_clip);
+ }
+ }
+ child++;
+ }
+ XFree( save_child_list);
+ }
+}
+
+
+/** ------------------------------------------------------------------------
+ This function creates a list of regions which tile a specified
+ window. Each region contains all visible portions of the window
+ which are drawn with the same visual. For example, if the
+ window consists of subwindows of two different visual types,
+ there will be two regions in the list.
+ Returns a pointer to the list.
+ ------------------------------------------------------------------------ **/
+static list_ptr make_region_list( disp, win, bbox, hasNonDefault,
+ numImageVisuals, pImageVisuals, allImage)
+ Display *disp;
+ Window win;
+ XRectangle *bbox;
+ int *hasNonDefault;
+ int numImageVisuals;
+ XVisualInfo **pImageVisuals;
+ int *allImage;
+{
+ XWindowAttributes win_attrs;
+ list image_wins;
+ list_ptr image_regions;
+ list_ptr srcs_left;
+ image_region_type *new_reg;
+ image_win_type *base_src, *src;
+ Region bbox_region = XCreateRegion();
+ XRectangle clip;
+ int image_only;
+
+ int count=0 ;
+
+ *hasNonDefault = False;
+ XUnionRectWithRegion( bbox, bbox_region, bbox_region);
+ XGetWindowAttributes( disp, win, &win_attrs);
+
+ zero_list( &image_wins);
+ clip.x = 0;
+ clip.y = 0;
+ clip.width = win_attrs.width;
+ clip.height = win_attrs.height;
+ make_src_list( disp, &image_wins, bbox, win,
+ 0 /* x_rootrel */, 0 /* y_rootrel */, &win_attrs, &clip);
+
+ image_regions = new_list();
+ image_only = (*allImage) ? True:False;
+
+ for (base_src = (image_win_type *) first_in_list( &image_wins); base_src;
+ base_src = (image_win_type *) next_in_list( &image_wins))
+ {
+ /* test for image visual */
+ if (!image_only || src_in_image(base_src, numImageVisuals, pImageVisuals))
+ {
+ /* find a window whose visual hasn't been put in list yet */
+ if (!src_in_region_list( base_src, image_regions))
+ {
+ if (! (new_reg = (image_region_type *)
+ malloc( sizeof( image_region_type)))) {
+ return (list_ptr) NULL;
+ }
+ count++;
+
+ new_reg->visible_region = XCreateRegion();
+ new_reg->win = base_src->win;
+ new_reg->vis = base_src->vis;
+ new_reg->cmap = base_src->cmap;
+ new_reg->x_rootrel = base_src->x_rootrel;
+ new_reg->y_rootrel = base_src->y_rootrel;
+ new_reg->x_vis = base_src->x_vis;
+ new_reg->y_vis = base_src->y_vis;
+ new_reg->width = base_src->width;
+ new_reg->height = base_src->height;
+ new_reg->border = base_src->border_width;
+
+ srcs_left = (list_ptr) dup_list_head( &image_wins, START_AT_CURR);
+ for (src = (image_win_type *) first_in_list( srcs_left); src;
+ src = (image_win_type *) next_in_list( srcs_left)) {
+ if (SAME_REGIONS( base_src, src)) {
+ add_rect_to_image_region( new_reg, src->x_vis, src->y_vis,
+ src->width, src->height);
+ }
+ else {
+ if (!image_only || src_in_image(src, numImageVisuals, pImageVisuals))
+ {
+ subtr_rect_from_image_region( new_reg, src->x_vis,
+ src->y_vis, src->width, src->height);
+ }
+ }
+ }
+ XIntersectRegion( bbox_region, new_reg->visible_region,
+ new_reg->visible_region);
+ if (! XEmptyRegion( new_reg->visible_region)) {
+ add_to_list( image_regions, new_reg);
+ if (new_reg->vis != DefaultVisualOfScreen( win_attrs.screen) ||
+ new_reg->cmap != DefaultColormapOfScreen(
+ win_attrs.screen)) {
+ *hasNonDefault = True;
+ }
+ }
+ else {
+ XDestroyRegion( new_reg->visible_region);
+ free( (void *) new_reg);
+ }
+ }
+ } else *allImage = 0;
+ }
+ delete_list( &image_wins, True);
+ XDestroyRegion( bbox_region);
+ return image_regions;
+}
+/** ------------------------------------------------------------------------
+ Destructor called from destroy_region_list().
+ ------------------------------------------------------------------------ **/
+void destroy_image_region( image_region)
+ image_region_type *image_region;
+{
+ XDestroyRegion( image_region->visible_region);
+ free( (void *) image_region);
+}
+
+/** ------------------------------------------------------------------------
+ Destroys the region list, destroying all the regions contained in it.
+ ------------------------------------------------------------------------ **/
+static void destroy_region_list( rlist)
+ list_ptr rlist;
+{
+ delete_list_destroying( rlist, (DESTRUCT_FUNC_PTR)destroy_image_region);
+}
+
+
+/** ------------------------------------------------------------------------
+ Subtracts the specified rectangle from the region in image_region.
+ First converts the rectangle to a region of its own, since X
+ only provides a way to subtract one region from another, not a
+ rectangle from a region.
+ ------------------------------------------------------------------------ **/
+static void subtr_rect_from_image_region( image_region, x, y, width, height)
+ image_region_type *image_region;
+ int x;
+ int y;
+ int width;
+ int height;
+{
+ XRectangle rect;
+ Region rect_region;
+
+ rect_region = XCreateRegion();
+ rect.x = x;
+ rect.y = y;
+ rect.width = width;
+ rect.height = height;
+ XUnionRectWithRegion( &rect, rect_region, rect_region);
+ XSubtractRegion( image_region->visible_region, rect_region,
+ image_region->visible_region);
+ XDestroyRegion( rect_region);
+}
+
+
+/** ------------------------------------------------------------------------
+ Adds the specified rectangle to the region in image_region.
+ ------------------------------------------------------------------------ **/
+static void add_rect_to_image_region( image_region, x, y, width, height)
+ image_region_type *image_region;
+ int x;
+ int y;
+ int width;
+ int height;
+{
+ XRectangle rect;
+
+ rect.x = x;
+ rect.y = y;
+ rect.width = width;
+ rect.height = height;
+ XUnionRectWithRegion( &rect, image_region->visible_region,
+ image_region->visible_region);
+}
+
+
+/** ------------------------------------------------------------------------
+ Returns TRUE if the given src's visual is already represented in
+ the image_regions list, FALSE otherwise.
+ ------------------------------------------------------------------------ **/
+static int src_in_region_list( src, image_regions)
+ image_win_type *src;
+ list_ptr image_regions;
+{
+ image_region_type *ir;
+
+ for (ir = (image_region_type *) first_in_list( image_regions); ir;
+ ir = (image_region_type *) next_in_list( image_regions)) {
+ if (SAME_REGIONS( ir, src)) {
+
+ return 1;
+ }
+ }
+
+ return 0;
+}
+
+
+/** ------------------------------------------------------------------------
+ Makes a new entry in image_wins with the given fields filled in.
+ ------------------------------------------------------------------------ **/
+static void add_window_to_list( image_wins, w, xrr, yrr, x_vis, y_vis,
+ width, height, border_width,vis, cmap, parent)
+ list_ptr image_wins;
+ Window w;
+ int xrr;
+ int yrr;
+ int x_vis;
+ int y_vis;
+ int width;
+ int height;
+ Visual *vis;
+ Colormap cmap;
+ Window parent;
+{
+ image_win_type *new_src;
+
+ if ((new_src = (image_win_type *) malloc( sizeof( image_win_type))) == NULL)
+
+ return;
+
+ new_src->win = w;
+ new_src->x_rootrel = xrr;
+ new_src->y_rootrel = yrr;
+ new_src->x_vis = x_vis;
+ new_src->y_vis = y_vis;
+ new_src->width = width;
+ new_src->height = height;
+ new_src->border_width = border_width;
+ new_src->vis = vis;
+ new_src->cmap = cmap;
+ new_src->parent = parent;
+ add_to_list( image_wins, new_src);
+}
+
+/** ------------------------------------------------------------------------
+ Returns TRUE if the given src's visual is in the image planes,
+ FALSE otherwise.
+ ------------------------------------------------------------------------ **/
+static int src_in_image( src, numImageVisuals, pImageVisuals)
+ image_win_type *src;
+ int numImageVisuals;
+ XVisualInfo **pImageVisuals;
+{
+ int i;
+
+ for (i = 0 ; i < numImageVisuals ; i++)
+ {
+ if (pImageVisuals[i]->visual == src->vis)
+ return 1;
+ }
+ return 0;
+}
+
+
+/** ------------------------------------------------------------------------
+ Returns TRUE if the given src's visual is in the overlay planes
+ and transparency is possible, FALSE otherwise.
+ ------------------------------------------------------------------------ **/
+static int src_in_overlay( src, numOverlayVisuals, pOverlayVisuals,
+ transparentColor, transparentType)
+ image_region_type *src;
+ int numOverlayVisuals;
+ OverlayInfo *pOverlayVisuals;
+ int *transparentColor;
+ int *transparentType;
+{
+ int i;
+
+ for (i = 0 ; i < numOverlayVisuals ; i++)
+ {
+ if (((pOverlayVisuals[i].pOverlayVisualInfo)->visual == src->vis)
+ && (pOverlayVisuals[i].transparentType != None))
+ {
+ *transparentColor = pOverlayVisuals[i].value;
+ *transparentType = pOverlayVisuals[i].transparentType;
+ return 1;
+ }
+
+ else {
+ }
+
+ }
+ return 0;
+}
+
+
+/********************** from wsutils.c ******************************/
+
+/******************************************************************************
+ *
+ * This file contains a set of example utility procedures; procedures that can
+ * help a "window-smart" Starbase or PHIGS program determine information about
+ * a device, and create image and overlay plane windows. To use these
+ * utilities, #include "wsutils.h" and compile this file and link the results
+ * with your program.
+ *
+ ******************************************************************************/
+
+
+
+#define STATIC_GRAY 0x01
+#define GRAY_SCALE 0x02
+#define PSEUDO_COLOR 0x04
+#define TRUE_COLOR 0x10
+#define DIRECT_COLOR 0x11
+
+
+static int weCreateServerOverlayVisualsProperty = False;
+
+
+/******************************************************************************
+ *
+ * GetXVisualInfo()
+ *
+ * This routine takes an X11 Display, screen number, and returns whether the
+ * screen supports transparent overlays and three arrays:
+ *
+ * 1) All of the XVisualInfo struct's for the screen.
+ * 2) All of the OverlayInfo struct's for the screen.
+ * 3) An array of pointers to the screen's image plane XVisualInfo
+ * structs.
+ *
+ * The code below obtains the array of all the screen's visuals, and obtains
+ * the array of all the screen's overlay visual information. It then processes
+ * the array of the screen's visuals, determining whether the visual is an
+ * overlay or image visual.
+ *
+ * If the routine sucessfully obtained the visual information, it returns zero.
+ * If the routine didn't obtain the visual information, it returns non-zero.
+ *
+ ******************************************************************************/
+
+int GetXVisualInfo(display, screen, transparentOverlays,
+ numVisuals, pVisuals,
+ numOverlayVisuals, pOverlayVisuals,
+ numImageVisuals, pImageVisuals)
+
+ Display *display; /* Which X server (aka "display"). */
+ int screen; /* Which screen of the "display". */
+ int *transparentOverlays; /* Non-zero if there's at least one
+ * overlay visual and if at least one
+ * of those supports a transparent
+ * pixel. */
+ int *numVisuals; /* Number of XVisualInfo struct's
+ * pointed to to by pVisuals. */
+ XVisualInfo **pVisuals; /* All of the device's visuals. */
+ int *numOverlayVisuals; /* Number of OverlayInfo's pointed
+ * to by pOverlayVisuals. If this
+ * number is zero, the device does
+ * not have overlay planes. */
+ OverlayInfo **pOverlayVisuals; /* The device's overlay plane visual
+ * information. */
+ int *numImageVisuals; /* Number of XVisualInfo's pointed
+ * to by pImageVisuals. */
+ XVisualInfo ***pImageVisuals; /* The device's image visuals. */
+{
+ XVisualInfo getVisInfo; /* Paramters of XGetVisualInfo */
+ int mask;
+ XVisualInfo *pVis, **pIVis; /* Faster, local copies */
+ OverlayInfo *pOVis;
+ OverlayVisualPropertyRec *pOOldVis;
+ int nVisuals, nOVisuals;
+ Atom overlayVisualsAtom; /* Parameters for XGetWindowProperty */
+ Atom actualType;
+ unsigned long numLongs, bytesAfter;
+ int actualFormat;
+ int nImageVisualsAlloced; /* Values to process the XVisualInfo */
+ int imageVisual; /* array */
+
+
+ /* First, get the list of visuals for this screen. */
+ getVisInfo.screen = screen;
+ mask = VisualScreenMask;
+
+ *pVisuals = XGetVisualInfo(display, mask, &getVisInfo, numVisuals);
+ if ((nVisuals = *numVisuals) <= 0)
+ {
+ /* Return that the information wasn't sucessfully obtained: */
+ return(1);
+ }
+ pVis = *pVisuals;
+
+
+ /* Now, get the overlay visual information for this screen. To obtain
+ * this information, get the SERVER_OVERLAY_VISUALS property.
+ */
+ overlayVisualsAtom = XInternAtom(display, "SERVER_OVERLAY_VISUALS", True);
+ if (overlayVisualsAtom != None)
+ {
+ /* Since the Atom exists, we can request the property's contents. The
+ * do-while loop makes sure we get the entire list from the X server.
+ */
+ bytesAfter = 0;
+ numLongs = sizeof(OverlayVisualPropertyRec) / 4;
+ do
+ {
+ numLongs += bytesAfter * 4;
+ XGetWindowProperty(display, RootWindow(display, screen),
+ overlayVisualsAtom, 0, numLongs, False,
+ overlayVisualsAtom, &actualType, &actualFormat,
+ &numLongs, &bytesAfter, (unsigned char**) pOverlayVisuals);
+ } while (bytesAfter > 0);
+
+
+ /* Calculate the number of overlay visuals in the list. */
+ *numOverlayVisuals = numLongs / (sizeof(OverlayVisualPropertyRec) / 4);
+ }
+ else
+ {
+ /* This screen doesn't have overlay planes. */
+ *numOverlayVisuals = 0;
+ *pOverlayVisuals = NULL;
+ *transparentOverlays = 0;
+ }
+
+
+ /* Process the pVisuals array. */
+ *numImageVisuals = 0;
+ nImageVisualsAlloced = 1;
+ pIVis = *pImageVisuals = (XVisualInfo **) malloc(sizeof(XVisualInfo *));
+ while (--nVisuals >= 0)
+ {
+ nOVisuals = *numOverlayVisuals;
+ pOVis = *pOverlayVisuals;
+ imageVisual = True;
+ while (--nOVisuals >= 0)
+ {
+ pOOldVis = (OverlayVisualPropertyRec *) pOVis;
+ if (pVis->visualid == pOOldVis->visualID)
+ {
+ imageVisual = False;
+ pOVis->pOverlayVisualInfo = pVis;
+ if (pOVis->transparentType == TransparentPixel)
+ *transparentOverlays = 1;
+ }
+ pOVis++;
+ }
+ if (imageVisual)
+ {
+ if ((*numImageVisuals += 1) > nImageVisualsAlloced)
+ {
+ nImageVisualsAlloced++;
+ *pImageVisuals = (XVisualInfo **)
+ realloc(*pImageVisuals, (nImageVisualsAlloced * sizeof(XVisualInfo *)));
+ pIVis = *pImageVisuals + (*numImageVisuals - 1);
+ }
+ *pIVis++ = pVis;
+ }
+ pVis++;
+ }
+
+
+ /* Return that the information was sucessfully obtained: */
+ return(0);
+
+} /* GetXVisualInfo() */
+
+
+/******************************************************************************
+ *
+ * FreeXVisualInfo()
+ *
+ * This routine frees the data that was allocated by GetXVisualInfo().
+ *
+ ******************************************************************************/
+
+void FreeXVisualInfo(pVisuals, pOverlayVisuals, pImageVisuals)
+
+ XVisualInfo *pVisuals;
+ OverlayInfo *pOverlayVisuals;
+ XVisualInfo **pImageVisuals;
+{
+ XFree(pVisuals);
+ if (weCreateServerOverlayVisualsProperty)
+ free(pOverlayVisuals);
+ else
+ XFree(pOverlayVisuals);
+ free(pImageVisuals);
+
+} /* FreeXVisualInfo() */
--- /dev/null
+/* $Xorg: multiVis.h,v 1.4 2001/02/09 02:06:03 xorgcvs Exp $ */
+/** ------------------------------------------------------------------------
+ This file contains routines for manipulating generic lists.
+ Lists are implemented with a "harness". In other words, each
+ node in the list consists of two pointers, one to the data item
+ and one to the next node in the list. The head of the list is
+ the same struct as each node, but the "item" ptr is used to point
+ to the current member of the list (used by the first_in_list and
+ next_in_list functions).
+
+Copyright 1994 Hewlett-Packard Co.
+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.
+
+ ------------------------------------------------------------------------ **/
+
+extern int GetMultiVisualRegions(
+#if NeedFunctionPrototypes
+ Display *, Window, int, int, unsigned int,
+ unsigned int, int *, int *, XVisualInfo **, int *,
+ OverlayInfo **, int *, XVisualInfo ***, list_ptr *,
+ list_ptr *, int *
+#endif
+);
+
+extern XImage *ReadAreaToImage(
+#if NeedFunctionPrototypes
+ Display *, Window, int, int, unsigned int,
+ unsigned int, int, XVisualInfo *, int,
+ OverlayInfo *, int, XVisualInfo **, list_ptr,
+ list_ptr, int, int
+#endif
+);
+
+extern void initFakeVisual(
+#if NeedFunctionPrototypes
+ Visual *
+#endif
+);
--- /dev/null
+/* $Xorg: wsutils.h,v 1.4 2001/02/09 02:06:03 xorgcvs Exp $ */
+/** ------------------------------------------------------------------------
+ This file contains routines for manipulating generic lists.
+ Lists are implemented with a "harness". In other words, each
+ node in the list consists of two pointers, one to the data item
+ and one to the next node in the list. The head of the list is
+ the same struct as each node, but the "item" ptr is used to point
+ to the current member of the list (used by the first_in_list and
+ next_in_list functions).
+
+Copyright 1994 Hewlett-Packard Co.
+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.
+
+ ------------------------------------------------------------------------ **/
+/******************************************************************************
+ *
+ * This file contains various typedef's, macros and procedure declarations for
+ * a set of example utility procedures contained in the file "wsutils.c".
+ *
+ ******************************************************************************/
+
+/* This is the actual structure returned by the X server describing the
+ * SERVER_OVERLAY_VISUAL property.
+ */
+typedef struct
+{
+ VisualID visualID; /* The VisualID of the overlay visual */
+ int transparentType; /* Can be None, TransparentPixel or
+ * TransparentMask */
+ int value; /* Pixel value */
+ int layer; /* Overlay planes will always be in
+ * layer 1 */
+} OverlayVisualPropertyRec;
+
+
+/* This is structure also describes the SERVER_OVERLAY_VISUAL property, but
+ * should be more useful than the one actually returned by the X server
+ * because it actually points to the visual's XVisualInfo struct rather than
+ * refering to the visual's ID.
+ */
+typedef struct
+{
+ XVisualInfo *pOverlayVisualInfo; /* Pointer to the XVisualInfo struct */
+ int transparentType; /* Can be None, TransparentPixel or
+ * TransparentMask */
+ int value; /* Pixel value */
+ int layer; /* Overlay planes will always be in
+ * layer 1 */
+} OverlayInfo;
+
+
+/* These macros are the values of the "transparentType" above: */
+#ifndef None
+#define None 0
+#endif
+#ifndef TransparentPixel
+#define TransparentPixel 1
+#endif
+
+
+/* These macros define how flexible a program is when it requests a window's
+ * creation with either the CreateImagePlanesWindow() or
+ * CreateOverlayPlanesWindow():
+ */
+#ifndef NOT_FLEXIBLE
+#define NOT_FLEXIBLE 0
+#define FLEXIBLE 1
+#endif
+
+
+/* These macros define the values of the "sbCmapHint" parameter of the
+ * CreateImagePlanesWindow():
+ */
+#ifndef SB_CMAP_TYPE_NORMAL
+#define SB_CMAP_TYPE_NORMAL 1
+#endif
+
+#ifndef SB_CMAP_TYPE_MONOTONIC
+#define SB_CMAP_TYPE_MONOTONIC 2
+#endif
+
+#ifndef SB_CMAP_TYPE_FULL
+#define SB_CMAP_TYPE_FULL 4
+#endif
+
+
+/******************************************************************************
+ *
+ * GetXVisualInfo()
+ *
+ * This routine takes an X11 Display, screen number, and returns whether the
+ * screen supports transparent overlays and three arrays:
+ *
+ * 1) All of the XVisualInfo struct's for the screen.
+ * 2) All of the OverlayInfo struct's for the screen.
+ * 3) An array of pointers to the screen's image plane XVisualInfo
+ * structs.
+ *
+ * The code below obtains the array of all the screen's visuals, and obtains
+ * the array of all the screen's overlay visual information. It then processes
+ * the array of the screen's visuals, determining whether the visual is an
+ * overlay or image visual.
+ *
+ * If the routine sucessfully obtained the visual information, it returns zero.
+ * If the routine didn't obtain the visual information, it returns non-zero.
+ *
+ ******************************************************************************/
+
+extern int GetXVisualInfo(
+#if NeedFunctionPrototypes
+ Display *display, /* Which X server (aka "display"). */
+ int screen, /* Which screen of the "display". */
+ int *transparentOverlays, /* Non-zero if there's at least one
+ * overlay visual and if at least one
+ * of those supports a transparent
+ * pixel. */
+ int *numVisuals, /* Number of XVisualInfo struct's
+ * pointed to to by pVisuals. */
+ XVisualInfo **pVisuals, /* All of the device's visuals. */
+ int *numOverlayVisuals, /* Number of OverlayInfo's pointed
+ * to by pOverlayVisuals. If this
+ * number is zero, the device does
+ * not have overlay planes. */
+ OverlayInfo **pOverlayVisuals, /* The device's overlay plane visual
+ * information. */
+ int *numImageVisuals, /* Number of XVisualInfo's pointed
+ * to by pImageVisuals. */
+ XVisualInfo ***pImageVisuals /* The device's image visuals. */
+#endif
+ );
+
+
+/******************************************************************************
+ *
+ * FreeXVisualInfo()
+ *
+ * This routine frees the data that was allocated by GetXVisualInfo().
+ *
+ ******************************************************************************/
+
+extern void FreeXVisualInfo(
+#if NeedFunctionPrototypes
+ XVisualInfo *pVisuals,
+ OverlayInfo *pOverlayVisuals,
+ XVisualInfo **pImageVisuals
+#endif
+ );
+
+
+/******************************************************************************
+ *
+ * FindImagePlanesVisual()
+ *
+ * This routine attempts to find a visual to use to create an image planes
+ * window based upon the information passed in.
+ *
+ * The "Hint" values give guides to the routine as to what the program wants.
+ * The "depthFlexibility" value tells the routine how much the program wants
+ * the actual "depthHint" specified. If the program can't live with the
+ * screen's image planes visuals, the routine returns non-zero, and the
+ * "depthObtained" and "pImageVisualToUse" return parameters are NOT valid.
+ * Otherwise, the "depthObtained" and "pImageVisualToUse" return parameters
+ * are valid and the routine returns zero.
+ *
+ * NOTE: This is just an example of what can be done. It may or may not be
+ * useful for any specific application.
+ *
+ ******************************************************************************/
+
+extern int FindImagePlanesVisual(
+#if NeedFunctionPrototypes
+ Display *display, /* Which X server (aka "display"). */
+ int screen, /* Which screen of the "display". */
+ int numImageVisuals, /* Number of XVisualInfo's pointed
+ * to by pImageVisuals. */
+ XVisualInfo **pImageVisuals, /* The device's image visuals. */
+ int sbCmapHint, /* What Starbase cmap modes will be
+ * used with the visual. NOTE: This
+ * is a mask of the possible values. */
+ int depthHint, /* Desired depth. */
+ int depthFlexibility, /* How much the actual value in
+ * "depthHint" is desired. */
+ Visual **pImageVisualToUse, /* The screen's image visual to use. */
+ int *depthObtained /* Actual depth of the visual. */
+#endif
+ );
+
+
+/******************************************************************************
+ *
+ * FindOverlayPlanesVisual()
+ *
+ * This routine attempts to find a visual to use to create an overlay planes
+ * window based upon the information passed in.
+ *
+ * While the CreateImagePlanesWindow() routine took a sbCmapHint, this
+ * routine doesn't. Starbase's CMAP_FULL shouldn't be used in overlay planes
+ * windows. This is partially because this functionality is better suited in
+ * the image planes where there are generally more planes, and partially
+ * because the overlay planes generally have PseudoColor visuals with one
+ * color being transparent (the transparent normally being the "white" color
+ * for CMAP_FULL).
+ *
+ * The "depthHint" values give guides to the routine as to what depth the
+ * program wants the window to be. The "depthFlexibility" value tells the
+ * routine how much the program wants the actual "depthHint" specified. If
+ * the program can't live with the screen's overlay planes visuals, the
+ * routine returns non-zero, and the "depthObtained" and "pOverlayVisualToUse"
+ * return parameters are NOT valid. Otherwise, the "depthObtained" and
+ * "pOverlayVisualToUse" return parameters are valid and the routine returns
+ * zero.
+ *
+ * NOTE: This is just an example of what can be done. It may or may not be
+ * useful for any specific application.
+ *
+ ******************************************************************************/
+
+extern int FindOverlayPlanesVisual(
+#if NeedFunctionPrototypes
+ Display *display, /* Which X server (aka "display"). */
+ int screen, /* Which screen of the "display". */
+ int numOverlayVisuals, /* Number of OverlayInfo's pointed
+ * to by pOverlayVisuals. */
+ OverlayInfo *pOverlayVisuals, /* The device's overlay plane visual
+ * information. */
+ int depthHint, /* Desired depth. */
+ int depthFlexibility, /* How much the actual value in
+ * "depthHint" is desired. */
+ int transparentBackground, /* Non-zero if the visual must have
+ * a transparent color. */
+ Visual **pOverlayVisualToUse, /* The screen's overlay visual to
+ * use. */
+ int *depthObtained, /* Actual depth of the visual. */
+ int *transparentColor /* The transparent color the program
+ * can use with the visual. */
+#endif
+ );
+
+
+/******************************************************************************
+ *
+ * CreateImagePlanesWindow()
+ *
+ * This routine creates an image planes window, potentially creates a colormap
+ * for the window to use, and sets the window's standard properties, based
+ * upon the information passed in to the routine. While "created," the window
+ * has not been mapped.
+ *
+ * If the routine suceeds, it returns zero and the return parameters
+ * "imageWindow", "imageColormap" and "mustFreeImageColormap" are valid.
+ * Otherwise, the routine returns non-zero and the return parameters are
+ * NOT valid.
+ *
+ * NOTE: This is just an example of what can be done. It may or may not be
+ * useful for any specific application.
+ *
+ ******************************************************************************/
+
+extern int CreateImagePlanesWindow(
+#if NeedFunctionPrototypes
+ Display *display, /* Which X server (aka "display"). */
+ int screen, /* Which screen of the "display". */
+ Window parentWindow, /* Window ID of the parent window for
+ * the created window. */
+ int windowX, /* Desired X coord. of the window. */
+ int windowY, /* Desired Y coord of the window. */
+ int windowWidth, /* Desired width of the window. */
+ int windowHeight, /* Desired height of the window. */
+ int windowDepth, /* Desired depth of the window. */
+ Visual *pImageVisualToUse, /* The window's image planes visual. */
+ int argc, /* Program's argc parameter. */
+ char *argv[], /* Program's argv parameter. */
+ char *windowName, /* Name to put on window's border. */
+ char *iconName, /* Name to put on window's icon. */
+ Window *imageWindow, /* Window ID of the created window. */
+ Colormap *imageColormap, /* The window's colormap. */
+ int *mustFreeImageColormap /* Non-zero if the program must call
+ * XFreeColormap() for imageColormap. */
+#endif
+ );
+
+
+/******************************************************************************
+ *
+ * CreateOverlayPlanesWindow()
+ *
+ * This routine creates an overlay planes window, potentially creates a colormap
+ * for the window to use, and sets the window's standard properties, based
+ * upon the information passed in to the routine. While "created," the window
+ * has not been mapped.
+ *
+ * If the routine suceeds, it returns zero and the return parameters
+ * "overlayWindow", "overlayColormap" and "mustFreeOverlayColormap" are valid.
+ * Otherwise, the routine returns non-zero and the return parameters are
+ * NOT valid.
+ *
+ * NOTE: This is just an example of what can be done. It may or may not be
+ * useful for any specific application.
+ *
+ ******************************************************************************/
+
+int CreateOverlayPlanesWindow(
+#if NeedFunctionPrototypes
+ Display *display, /* Which X server (aka "display"). */
+ int screen, /* Which screen of the "display". */
+ Window parentWindow, /* Window ID of the parent window for
+ * the created window. */
+ int windowX, /* Desired X coord. of the window. */
+ int windowY, /* Desired Y coord of the window. */
+ int windowWidth, /* Desired width of the window. */
+ int windowHeight, /* Desired height of the window. */
+ int windowDepth, /* Desired depth of the window. */
+ Visual *pOverlayVisualToUse, /* The window's overlay planes visual.*/
+ int argc, /* Program's argc parameter. */
+ char *argv[], /* Program's argv parameter. */
+ char *windowName, /* Name to put on window's border. */
+ char *iconName, /* Name to put on window's icon. */
+ int transparentBackground, /* Non-zero if the window's background
+ * should be a transparent color. */
+ int *transparentColor, /* The transparent color to use as the
+ * window's background. */
+ Window *overlayWindow, /* Window ID of the created window. */
+ Colormap *overlayColormap, /* The window's colormap. */
+ int *mustFreeOverlayColormap/* Non-zero if the program must call
+ * XFreeColormap() for
+ * overlayColormap. */
+#endif
+ );
--- /dev/null
+/* $Xorg: xwd.c,v 1.5 2001/02/09 02:06:03 xorgcvs Exp $ */
+
+/*
+
+Copyright 1987, 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.
+
+*/
+
+/*
+ * xwd.c MIT Project Athena, X Window system window raster image dumper.
+ *
+ * This program will dump a raster image of the contents of a window into a
+ * file for output on graphics printers or for other uses.
+ *
+ * Author: Tony Della Fera, DEC
+ * 17-Jun-85
+ *
+ * Modification history:
+ *
+ * 11/14/86 Bill Wyatt, Smithsonian Astrophysical Observatory
+ * - Removed Z format option, changing it to an XY option. Monochrome
+ * windows will always dump in XY format. Color windows will dump
+ * in Z format by default, but can be dumped in XY format with the
+ * -xy option.
+ *
+ * 11/18/86 Bill Wyatt
+ * - VERSION 6 is same as version 5 for monchrome. For colors, the
+ * appropriate number of Color structs are dumped after the header,
+ * which has the number of colors (=0 for monochrome) in place of the
+ * V5 padding at the end. Up to 16-bit displays are supported. I
+ * don't yet know how 24- to 32-bit displays will be handled under
+ * the Version 11 protocol.
+ *
+ * 6/15/87 David Krikorian, MIT Project Athena
+ * - VERSION 7 runs under the X Version 11 servers, while the previous
+ * versions of xwd were are for X Version 10. This version is based
+ * on xwd version 6, and should eventually have the same color
+ * abilities. (Xwd V7 has yet to be tested on a color machine, so
+ * all color-related code is commented out until color support
+ * becomes practical.)
+ */
+
+/*%
+ *% This is the format for commenting out color-related code until
+ *% color can be supported.
+%*/
+
+#include <stdio.h>
+#include <errno.h>
+#include <X11/Xos.h>
+
+#ifdef X_NOT_STDC_ENV
+extern int errno;
+#endif
+
+#include <X11/Xlib.h>
+#include <X11/Xutil.h>
+
+#include <X11/Xmu/WinUtil.h>
+typedef unsigned long Pixel;
+#include "X11/XWDFile.h"
+
+#define FEEP_VOLUME 0
+
+/* Include routines to do parsing */
+#include "dsimple.h"
+#include "list.h"
+#include "wsutils.h"
+#include "multiVis.h"
+
+#ifdef XKB
+#include <X11/extensions/XKBbells.h>
+#endif
+
+/* Setable Options */
+
+int format = ZPixmap;
+Bool nobdrs = False;
+Bool on_root = False;
+Bool standard_out = True;
+Bool debug = False;
+Bool silent = False;
+Bool use_installed = False;
+long add_pixel_value = 0;
+
+extern int (*_XErrorFunction)();
+extern int _XDefaultError();
+
+static long parse_long (s)
+ char *s;
+{
+ char *fmt = "%lu";
+ long retval = 0L;
+ int thesign = 1;
+
+ if (s && s[0]) {
+ if (s[0] == '-') s++, thesign = -1;
+ if (s[0] == '0') s++, fmt = "%lo";
+ if (s[0] == 'x' || s[0] == 'X') s++, fmt = "%lx";
+ (void) sscanf (s, fmt, &retval);
+ }
+ return (thesign * retval);
+}
+
+main(argc, argv)
+ int argc;
+ char **argv;
+{
+ register i;
+ Window target_win;
+ FILE *out_file = stdout;
+ Bool frame_only = False;
+
+ INIT_NAME;
+
+ Setup_Display_And_Screen(&argc, argv);
+
+ /* Get window select on command line, if any */
+ target_win = Select_Window_Args(&argc, argv);
+
+ for (i = 1; i < argc; i++) {
+ if (!strcmp(argv[i], "-nobdrs")) {
+ nobdrs = True;
+ continue;
+ }
+ if (!strcmp(argv[i], "-debug")) {
+ debug = True;
+ continue;
+ }
+ if (!strcmp(argv[i], "-help"))
+ usage();
+ if (!strcmp(argv[i], "-out")) {
+ if (++i >= argc) usage();
+ if (!(out_file = fopen(argv[i], "wb")))
+ Error("Can't open output file as specified.");
+ standard_out = False;
+ continue;
+ }
+ if (!strcmp(argv[i], "-xy")) {
+ format = XYPixmap;
+ continue;
+ }
+ if (!strcmp(argv[i], "-screen")) {
+ on_root = True;
+ continue;
+ }
+ if (!strcmp(argv[i], "-icmap")) {
+ use_installed = True;
+ continue;
+ }
+ if (!strcmp(argv[i], "-add")) {
+ if (++i >= argc) usage();
+ add_pixel_value = parse_long (argv[i]);
+ continue;
+ }
+ if (!strcmp(argv[i], "-frame")) {
+ frame_only = True;
+ continue;
+ }
+ if (!strcmp(argv[i], "-silent")) {
+ silent = True;
+ continue;
+ }
+ usage();
+ }
+#ifdef WIN32
+ if (standard_out)
+ _setmode(fileno(out_file), _O_BINARY);
+#endif
+
+ /*
+ * Let the user select the target window.
+ */
+ if (!target_win) {
+ target_win = Select_Window(dpy);
+ if (target_win != None && !frame_only) {
+ Window root;
+ int dummyi;
+ unsigned int dummy;
+
+ if (XGetGeometry (dpy, target_win, &root, &dummyi, &dummyi,
+ &dummy, &dummy, &dummy, &dummy) &&
+ target_win != root)
+ target_win = XmuClientWindow (dpy, target_win);
+ }
+ }
+
+
+ /*
+ * Dump it!
+ */
+ Window_Dump(target_win, out_file);
+
+ XCloseDisplay(dpy);
+ if (fclose(out_file)) {
+ perror("xwd");
+ exit(1);
+ }
+ exit(0);
+}
+
+static int
+Get24bitDirectColors(colors)
+XColor **colors ;
+{
+ int i , ncolors = 256 ;
+ XColor *tcol ;
+
+ *colors = tcol = (XColor *)malloc(sizeof(XColor) * ncolors) ;
+
+ for(i=0 ; i < ncolors ; i++)
+ {
+ tcol[i].pixel = i << 16 | i << 8 | i ;
+ tcol[i].red = tcol[i].green = tcol[i].blue = i << 8 | i ;
+ }
+
+ return ncolors ;
+}
+
+
+/*
+ * Window_Dump: dump a window to a file which must already be open for
+ * writting.
+ */
+
+char *calloc();
+
+Window_Dump(window, out)
+ Window window;
+ FILE *out;
+{
+ unsigned long swaptest = 1;
+ XColor *colors;
+ unsigned buffer_size;
+ int win_name_size;
+ int header_size;
+ int ncolors, i;
+ char *win_name;
+ Bool got_win_name;
+ XWindowAttributes win_info;
+ XImage *image;
+ int absx, absy, x, y;
+ unsigned width, height;
+ int dwidth, dheight;
+ int bw;
+ Window dummywin;
+ XWDFileHeader header;
+ XWDColor xwdcolor;
+
+ int transparentOverlays , multiVis;
+ int numVisuals;
+ XVisualInfo *pVisuals;
+ int numOverlayVisuals;
+ OverlayInfo *pOverlayVisuals;
+ int numImageVisuals;
+ XVisualInfo **pImageVisuals;
+ list_ptr vis_regions; /* list of regions to read from */
+ list_ptr vis_image_regions ;
+ Visual vis_h,*vis ;
+ int allImage = 0 ;
+
+ /*
+ * Inform the user not to alter the screen.
+ */
+ if (!silent) {
+#ifdef XKB
+ XkbStdBell(dpy,None,50,XkbBI_Wait);
+#else
+ XBell(dpy,FEEP_VOLUME);
+#endif
+ XFlush(dpy);
+ }
+
+ /*
+ * Get the parameters of the window being dumped.
+ */
+ if (debug) outl("xwd: Getting target window information.\n");
+ if(!XGetWindowAttributes(dpy, window, &win_info))
+ Fatal_Error("Can't get target window attributes.");
+
+ /* handle any frame window */
+ if (!XTranslateCoordinates (dpy, window, RootWindow (dpy, screen), 0, 0,
+ &absx, &absy, &dummywin)) {
+ fprintf (stderr,
+ "%s: unable to translate window coordinates (%d,%d)\n",
+ program_name, absx, absy);
+ exit (1);
+ }
+ win_info.x = absx;
+ win_info.y = absy;
+ width = win_info.width;
+ height = win_info.height;
+ bw = 0;
+
+ if (!nobdrs) {
+ absx -= win_info.border_width;
+ absy -= win_info.border_width;
+ bw = win_info.border_width;
+ width += (2 * bw);
+ height += (2 * bw);
+ }
+ dwidth = DisplayWidth (dpy, screen);
+ dheight = DisplayHeight (dpy, screen);
+
+
+ /* clip to window */
+ if (absx < 0) width += absx, absx = 0;
+ if (absy < 0) height += absy, absy = 0;
+ if (absx + width > dwidth) width = dwidth - absx;
+ if (absy + height > dheight) height = dheight - absy;
+
+ XFetchName(dpy, window, &win_name);
+ if (!win_name || !win_name[0]) {
+ win_name = "xwdump";
+ got_win_name = False;
+ } else {
+ got_win_name = True;
+ }
+
+ /* sizeof(char) is included for the null string terminator. */
+ win_name_size = strlen(win_name) + sizeof(char);
+
+ /*
+ * Snarf the pixmap with XGetImage.
+ */
+
+ x = absx - win_info.x;
+ y = absy - win_info.y;
+
+ multiVis = GetMultiVisualRegions(dpy,RootWindow(dpy, screen),
+ absx, absy,
+ width, height,&transparentOverlays,&numVisuals, &pVisuals,
+ &numOverlayVisuals,&pOverlayVisuals,&numImageVisuals,
+ &pImageVisuals,&vis_regions,&vis_image_regions,&allImage) ;
+ if (on_root || multiVis)
+ {
+ if(!multiVis)
+ image = XGetImage (dpy, RootWindow(dpy, screen), absx, absy,
+ width, height, AllPlanes, format);
+ else
+ image = ReadAreaToImage(dpy, RootWindow(dpy, screen), absx, absy,
+ width, height,
+ numVisuals,pVisuals,numOverlayVisuals,pOverlayVisuals,
+ numImageVisuals, pImageVisuals,vis_regions,
+ vis_image_regions,format,allImage);
+ }
+ else
+ image = XGetImage (dpy, window, x, y, width, height, AllPlanes, format);
+ if (!image) {
+ fprintf (stderr, "%s: unable to get image at %dx%d+%d+%d\n",
+ program_name, width, height, x, y);
+ exit (1);
+ }
+
+ if (add_pixel_value != 0) XAddPixel (image, add_pixel_value);
+
+ /*
+ * Determine the pixmap size.
+ */
+ buffer_size = Image_Size(image);
+
+ if (debug) outl("xwd: Getting Colors.\n");
+
+ if( !multiVis)
+ {
+ ncolors = Get_XColors(&win_info, &colors);
+ vis = win_info.visual ;
+ }
+ else
+ {
+ ncolors = Get24bitDirectColors(&colors) ;
+ initFakeVisual(&vis_h) ;
+ vis = &vis_h ;
+ }
+ /*
+ * Inform the user that the image has been retrieved.
+ */
+ if (!silent) {
+#ifdef XKB
+ XkbStdBell(dpy,window,FEEP_VOLUME,XkbBI_Proceed);
+ XkbStdBell(dpy,window,FEEP_VOLUME,XkbBI_RepeatingLastBell);
+#else
+ XBell(dpy, FEEP_VOLUME);
+ XBell(dpy, FEEP_VOLUME);
+#endif
+ XFlush(dpy);
+ }
+
+ /*
+ * Calculate header size.
+ */
+ if (debug) outl("xwd: Calculating header size.\n");
+ header_size = SIZEOF(XWDheader) + win_name_size;
+
+ /*
+ * Write out header information.
+ */
+ if (debug) outl("xwd: Constructing and dumping file header.\n");
+ header.header_size = (CARD32) header_size;
+ header.file_version = (CARD32) XWD_FILE_VERSION;
+ header.pixmap_format = (CARD32) format;
+ header.pixmap_depth = (CARD32) image->depth;
+ header.pixmap_width = (CARD32) image->width;
+ header.pixmap_height = (CARD32) image->height;
+ header.xoffset = (CARD32) image->xoffset;
+ header.byte_order = (CARD32) image->byte_order;
+ header.bitmap_unit = (CARD32) image->bitmap_unit;
+ header.bitmap_bit_order = (CARD32) image->bitmap_bit_order;
+ header.bitmap_pad = (CARD32) image->bitmap_pad;
+ header.bits_per_pixel = (CARD32) image->bits_per_pixel;
+ header.bytes_per_line = (CARD32) image->bytes_per_line;
+ /****
+ header.visual_class = (CARD32) win_info.visual->class;
+ header.red_mask = (CARD32) win_info.visual->red_mask;
+ header.green_mask = (CARD32) win_info.visual->green_mask;
+ header.blue_mask = (CARD32) win_info.visual->blue_mask;
+ header.bits_per_rgb = (CARD32) win_info.visual->bits_per_rgb;
+ header.colormap_entries = (CARD32) win_info.visual->map_entries;
+ *****/
+ header.visual_class = (CARD32) vis->class;
+ header.red_mask = (CARD32) vis->red_mask;
+ header.green_mask = (CARD32) vis->green_mask;
+ header.blue_mask = (CARD32) vis->blue_mask;
+ header.bits_per_rgb = (CARD32) vis->bits_per_rgb;
+ header.colormap_entries = (CARD32) vis->map_entries;
+
+ header.ncolors = ncolors;
+ header.window_width = (CARD32) win_info.width;
+ header.window_height = (CARD32) win_info.height;
+ header.window_x = absx;
+ header.window_y = absy;
+ header.window_bdrwidth = (CARD32) win_info.border_width;
+
+ if (*(char *) &swaptest) {
+ _swaplong((char *) &header, sizeof(header));
+ for (i = 0; i < ncolors; i++) {
+ _swaplong((char *) &colors[i].pixel, sizeof(long));
+ _swapshort((char *) &colors[i].red, 3 * sizeof(short));
+ }
+ }
+
+ if (fwrite((char *)&header, SIZEOF(XWDheader), 1, out) != 1 ||
+ fwrite(win_name, win_name_size, 1, out) != 1) {
+ perror("xwd");
+ exit(1);
+ }
+
+ /*
+ * Write out the color maps, if any
+ */
+
+ if (debug) outl("xwd: Dumping %d colors.\n", ncolors);
+ for (i = 0; i < ncolors; i++) {
+ xwdcolor.pixel = colors[i].pixel;
+ xwdcolor.red = colors[i].red;
+ xwdcolor.green = colors[i].green;
+ xwdcolor.blue = colors[i].blue;
+ xwdcolor.flags = colors[i].flags;
+ if (fwrite((char *) &xwdcolor, SIZEOF(XWDColor), 1, out) != 1) {
+ perror("xwd");
+ exit(1);
+ }
+ }
+
+ /*
+ * Write out the buffer.
+ */
+ if (debug) outl("xwd: Dumping pixmap. bufsize=%d\n",buffer_size);
+
+ /*
+ * This copying of the bit stream (data) to a file is to be replaced
+ * by an Xlib call which hasn't been written yet. It is not clear
+ * what other functions of xwd will be taken over by this (as yet)
+ * non-existant X function.
+ */
+ if (fwrite(image->data, (int) buffer_size, 1, out) != 1) {
+ perror("xwd");
+ exit(1);
+ }
+
+ /*
+ * free the color buffer.
+ */
+
+ if(debug && ncolors > 0) outl("xwd: Freeing colors.\n");
+ if(ncolors > 0) free(colors);
+
+ /*
+ * Free window name string.
+ */
+ if (debug) outl("xwd: Freeing window name string.\n");
+ if (got_win_name) XFree(win_name);
+
+ /*
+ * Free image
+ */
+ XDestroyImage(image);
+}
+
+/*
+ * Report the syntax for calling xwd.
+ */
+usage()
+{
+ fprintf (stderr,
+"usage: %s [-display host:dpy] [-debug] [-help] %s [-nobdrs] [-out <file>]",
+ program_name, SELECT_USAGE);
+ fprintf (stderr, " [-xy] [-add value] [-frame]\n");
+ exit(1);
+}
+
+
+/*
+ * Error - Fatal xwd error.
+ */
+
+Error(string)
+ char *string; /* Error description string. */
+{
+ outl("\nxwd: Error => %s\n", string);
+ if (errno != 0) {
+ perror("xwd");
+ outl("\n");
+ }
+
+ exit(1);
+}
+
+
+/*
+ * Determine the pixmap size.
+ */
+
+int Image_Size(image)
+ XImage *image;
+{
+ if (image->format != ZPixmap)
+ return(image->bytes_per_line * image->height * image->depth);
+
+ return(image->bytes_per_line * image->height);
+}
+
+#define lowbit(x) ((x) & (~(x) + 1))
+
+static int
+ReadColors(vis,cmap,colors)
+Visual *vis ;
+Colormap cmap ;
+XColor **colors ;
+{
+ int i,ncolors ;
+
+ ncolors = vis->map_entries;
+
+ if (!(*colors = (XColor *) malloc (sizeof(XColor) * ncolors)))
+ Fatal_Error("Out of memory!");
+
+ if (vis->class == DirectColor ||
+ vis->class == TrueColor) {
+ Pixel red, green, blue, red1, green1, blue1;
+
+ red = green = blue = 0;
+ red1 = lowbit(vis->red_mask);
+ green1 = lowbit(vis->green_mask);
+ blue1 = lowbit(vis->blue_mask);
+ for (i=0; i<ncolors; i++) {
+ (*colors)[i].pixel = red|green|blue;
+ (*colors)[i].pad = 0;
+ red += red1;
+ if (red > vis->red_mask)
+ red = 0;
+ green += green1;
+ if (green > vis->green_mask)
+ green = 0;
+ blue += blue1;
+ if (blue > vis->blue_mask)
+ blue = 0;
+ }
+ } else {
+ for (i=0; i<ncolors; i++) {
+ (*colors)[i].pixel = i;
+ (*colors)[i].pad = 0;
+ }
+ }
+
+ XQueryColors(dpy, cmap, *colors, ncolors);
+
+ return(ncolors);
+}
+
+/*
+ * Get the XColors of all pixels in image - returns # of colors
+ */
+int Get_XColors(win_info, colors)
+ XWindowAttributes *win_info;
+ XColor **colors;
+{
+ int i, ncolors;
+ Colormap cmap = win_info->colormap;
+
+ if (use_installed)
+ /* assume the visual will be OK ... */
+ cmap = XListInstalledColormaps(dpy, win_info->root, &i)[0];
+ if (!cmap)
+ return(0);
+ ncolors = ReadColors(win_info->visual,cmap,colors) ;
+ return ncolors ;
+}
+
+_swapshort (bp, n)
+ register char *bp;
+ register unsigned n;
+{
+ register char c;
+ register char *ep = bp + n;
+
+ while (bp < ep) {
+ c = *bp;
+ *bp = *(bp + 1);
+ bp++;
+ *bp++ = c;
+ }
+}
+
+_swaplong (bp, n)
+ register char *bp;
+ register unsigned n;
+{
+ register char c;
+ register char *ep = bp + n;
+ register char *sp;
+
+ while (bp < ep) {
+ sp = bp + 3;
+ c = *sp;
+ *sp = *bp;
+ *bp++ = c;
+ sp = bp + 1;
+ c = *sp;
+ *sp = *bp;
+ *bp++ = c;
+ bp += 2;
+ }
+}
--- /dev/null
+.\" $Xorg: xwd.man,v 1.4 2001/02/09 02:06:03 xorgcvs Exp $
+.\" Copyright 1988, 1994, 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.
+.TH XWD 1 "Release 6.4" "X Version 11"
+.SH NAME
+xwd - dump an image of an X window
+.SH SYNOPSIS
+.B "xwd"
+[-debug] [-help] [-nobdrs] [-out \fIfile\fP] [-xy] [-frame] [-add \fIvalue\fP]
+[-root | -id \fIid\fP | -name \fIname\fP ] [-icmap] [-screen]
+[-display \fIdisplay\fP]
+.SH DESCRIPTION
+.PP
+.I Xwd
+is an X Window System window dumping utility.
+.I Xwd
+allows X users to store window images in a specially formatted dump
+file. This file can then be read by various other X utilities for
+redisplay, printing, editing, formatting, archiving, image processing, etc.
+The target window is selected by clicking the pointer in the desired window.
+The keyboard bell is rung once at the beginning of the dump and twice when
+the dump is completed.
+.SH OPTIONS
+.PP
+.TP 8
+.B "-display \fIdisplay\fP"
+This argument allows you to specify the server to connect to; see \fIX(1)\fP.
+.PP
+.TP 8
+.B "-help"
+Print out the `Usage:' command syntax summary.
+.PP
+.TP 8
+.B "-nobdrs"
+This argument specifies that the window dump should not include the
+pixels that compose the X window border. This is useful in situations
+where you may wish to include the window contents in a document
+as an illustration.
+.PP
+.TP 8
+.B "-out \fIfile\fP"
+This argument allows the user to explicitly specify the output
+file on the command line. The default is to output to standard out.
+.PP
+.TP 8
+.B "-xy"
+This option applies to color displays only. It selects `XY' format dumping
+instead of the default `Z' format.
+.PP
+.TP 8
+.B "-add \fIvalue\fP"
+This option specifies an signed value to be added to every pixel.
+.PP
+.TP 8
+.B "-frame"
+This option indicates that the window manager frame should be included when
+manually selecting a window.
+.PP
+.TP 8
+.B "-root"
+This option indicates that the root window should be selected for the
+window dump, without requiring the user to select a window with the pointer.
+.PP
+.TP 8
+.B "-id \fIid\fP"
+This option indicates that the window with the specified resource id
+should be selected for the window dump, without requiring the user to
+select a window with the pointer.
+.PP
+.TP 8
+.B "-name \fIname\fP"
+This option indicates that the window with the specified WM_NAME property
+should be selected for the window dump, without requiring the user to
+select a window with the pointer.
+.PP
+.TP 8
+.B "-icmap"
+Normally the colormap of the chosen window is used to obtain RGB values.
+This option forces the first installed colormap of the screen to be used
+instead.
+.PP
+.TP 8
+.B "-screen"
+This option indicates that the GetImage request used to obtain the image
+should be done on the root window, rather than directly on the specified
+window. In this way, you can obtain pieces of other windows that overlap
+the specified window, and more importantly, you can capture menus or other
+popups that are independent windows but appear over the specified window.
+.PP
+.TP 8
+.B "-silent"
+Operate silently, i.e. don't ring any bells before and after dumping
+the window.
+.SH ENVIRONMENT
+.PP
+.TP 8
+.B DISPLAY
+To get default host and display number.
+.SH FILES
+.PP
+.TP 8
+.B XWDFile.h
+X Window Dump File format definition file.
+.SH SEE ALSO
+xwud(1), xpr(1), X(1)
+.SH AUTHORS
+Tony Della Fera, Digital Equipment Corp., MIT Project Athena
+.br
+William F. Wyatt, Smithsonian Astrophysical Observatory
projects / platform / upstream / xwd.git / commitdiff