Generic_Window_Manager/wool-gwm.c

/* Copyright 1989 GROUPE BULL -- See license conditions in file COPYRIGHT
 * Copyright 1989 Massachusetts Institute of Technology
 */
/*************************************************************\
* 							      *
* GWM: Wool-gwm.c					      *
* 							      *
* WOOL/GWM interface.					      *
* 							      *
* Here are defined Wool objects referring to X objects	      *
* To add a function:					      *
*        - declare it (coded in or extern)		      *
*        - add it to the declaration of predefined functions  *
*          in the wool_init function			      *
* 							      *
\*************************************************************/

/*  include  */

#include <stdio.h>
#include <string.h>
#include "EXTERN.h"
#include "wool.h"
#include "wl_number.h"
#include "wl_atom.h"
#include "wl_string.h"
#include "wl_list.h"
#include "wl_func.h"
#include "wl_active.h"
#include "wl_pointer.h"
#include "gwm.h"
#include "wl_event.h"
#include "wl_fsm.h"
#include "wl_label.h"
#include "wl_pixmap.h"
#include "wl_cursor.h"
#include "wl_plug.h"
#include "wl_bar.h"
#include "wl_menu.h"
#include "wl_client.h"
#include "wl_coll.h"
#include "wl_name.h"
#include <X11/Xresource.h>
#include "INTERN.h"

/*
 * external:
 * declare here all functions defined in GWM_init_wool_before_profile
 */

extern WOOL_OBJECT
	MapWindow(),
	UnmapWindow(),
	MoveWindow(),
	MoveSeveralWindows(),
	ResizeWindow(),
	LowerWindow(),
	RaiseWindow(),
	IconifyWindow(),
	KillWindow(),
	ReDecorateWindow(),
	CirculateWindowsDown(),
	CirculateWindowsUp(),
	PopMenu(),
	PlaceFixedMenu(),
	UnpopMenu(),
	wool_set_focus(),
	wool_current_wob(),
	wool_current_wob_set(),
	wool_current_wob_width(),
	wool_current_wob_height(),
	current_wob_set_bitmap(),
	current_wob_set_borderpixel(),
	current_wob_set_borderwidth(),
	current_wob_set_background(),
	current_wob_get_bitmap(),
	current_wob_get_borderpixel(),
	current_wob_get_borderwidth(),
	current_wob_get_background(),
	current_wob_invert_aera(),
	wool_current_window(),
	wool_set_current_window(),
	wool_current_window_is_mapped(),
	wool_current_window_name(),
	wool_current_window_name_set(),
	wool_current_window_client_name(),
	wool_current_window_client_class(),
	wool_current_window_machine_name(),
	wool_current_window_icon_name(),
	wool_current_window_icon_name_set(),
	wool_current_window_x(),
	wool_current_window_y(),
	wool_current_window_width(),
	wool_current_window_height(),
	wool_current_client_x(),
	wool_current_client_y(),
	wool_current_client_width(),
	wool_current_client_height(),
	wool_current_client_borderwidth(),
	wool_current_window_icon_window(),
	wool_current_window_icon_bitmap(),
	wool_current_window_icon_bitmap_id(),
	wool_current_window_US_position(),
	wool_current_window_US_size(),
	wool_current_window_P_position(),
	wool_current_window_P_size(),
	wool_current_window_is_transient_for(),
	Wob_set_property(),
	Wob_get_property(),
	wool_last_key_struck(),
	wool_send_key_to_client(),
	wool_send_keycode_to_client(),
	wool_logical_coords(),
	wool_process_exposes(),
	wool_current_mouse_position(),
	wool_meter_open(),
	MeterClose(),
	wool_meter_update(),
	wool_window_logical_size_get(),
	wool_window_logical_size_set(),
	wool_window_map_as_icon_get(),
	wool_window_map_as_icon_set(),
	Wob_get_menu(),
	Wob_set_menu(),
	Wob_get_fsm(),
	Wob_set_fsm(),
	wool_last_user_event(),
	wool_resend_event(),
	wool_window_group_get(),
	wool_window_group_set(),
	wool_xpm_pixmap_make(),
	wool_draw_line(),
	wool_wob_cursor_get(),
	wool_wob_cursor_set(),
	wool_wm_state_user_icon_set(),
	wool_wm_state_user_icon_get(),
	wool_wm_state_update(),
	wool_set_colormap_focus(),
	wool_set_wm_icon_sizes(),
	wool_set_subwindow_colormap_focus(),
	wool_set_grabs(), wool_unset_grabs(),
        wool_set_grab(), wool_remove_grab(),
	wool_delete_window(),
	wool_save_yourself(),
	wool_meter_modify(),
	wool_current_screen_get(),
	wool_current_screen_set(),
	wool_warp_pointer(),
	wool_get_root_window(), wool_set_root_window(),
	WLMenu_wob(),
	wool_wm_state_get(),
	wool_ungrab_and_replay_event(),
	wool_wob_x_get(), wool_wob_y_get(),
	wool_makes_replayable(),
	wool_get_triggering_event_state(),
	wool_get_triggering_event_code(),
	wool_get_triggering_event_x(),
	wool_get_triggering_event_y(),
	wool_get_triggering_event_x_relative(),
	wool_get_triggering_event_y_relative(),
	wool_get_triggering_event_time(),
	wool_get_triggering_event_data(),
	wool_event_was_due_to_a_grab(),
        wool_send_button_to_client(),
        MakeResourceIdentifier(),
        wool_allow_events(),
    	LookUpWobW(),
        wool_draw_rectangle(),
        wool_draw_text(),
        wool_wob_is_valid(), wool_window_is_valid(),
        Window2ClientW(), Client2WindowW(),
	wool_get_wm_command();
/*---*/

#ifdef SHAPE
extern WOOL_OBJECT wool_window_has_shaped_client();
#endif /* SHAPE */

extern XError(), NoXError();
extern char * getenv();
extern ClientWindow init_managed_windows(), get_next_managed_window();
extern WOOL_OBJECT GetWobOfNumber();

/*  local defs  */

XrmDatabase WLRSC_database = NULL;

/*  global variables */

/*  routines  */

void            GWM_init_wool_before_profile();

/*
 * Initialize Wool. Define subrs and global known from WOOL.
 */

int
InitWool()
{
    init_new_standard_wool_methods();
    if (wool_init(GWM_init_wool_before_profile))
	return FatalError;
    /* put here the initialisations to be done AFTER user profile */
    return OK;
}

/* Sets new methods to standard Wool types
 */

EXT WOOL_OBJECT WLString_get_dimensions();	/* see wl_label.c */

init_new_standard_wool_methods()
{
    WLString[WOOL_get_dimensions] = WLString_get_dimensions;
}

/* refreshes the screen or window if specified
 * very simple: creates/destroy a window just over the managed one
 */

WOOL_OBJECT
wool_refresh(argc, argv)
int argc;
WOOL_Number     argv[];
{
    XSetWindowAttributes wa;
    Window          wd;
    ClientWindow    cw;

    if (argc) {
	must_be_number(argv[0], 0);
	cw = (ClientWindow) argv[0] -> number;
    }
    wd = XCreateSimpleWindow(dpy, (argc ? cw -> hook : Context->root), 0, 0,
			     (argc ? cw -> box.width : Context->width),
			     (argc ? cw -> box.height : Context->height),
			     0, Context -> pixel.Back, Context -> pixel.Back);
    wa.override_redirect = 1;
    XChangeWindowAttributes(dpy, wd, CWOverrideRedirect, &wa);
    XMapWindow(dpy, wd);
    XDestroyWindow(dpy, wd);
    XFlush(dpy);
    return NIL;
}

/* gets the (default) visual type of screen
 * returns an atom that can be of:
 * mono, color or gray
 */

WOOL_OBJECT
wool_get_visual_type()
{
    switch (DefaultVisual(dpy, Context -> screen) -> class) {
    case StaticGray:
    case GrayScale:
	if (Context -> depth > 1)
	    return (WOOL_OBJECT) WA_gray;
	else
	    return (WOOL_OBJECT) WA_mono;
    default:
	return (WOOL_OBJECT) WA_color;
    }
}

/* sets the backgound of the screen in the current context.
 * can be given a WOOL_Number (pixel) or WOOL_Pixmap (pixmap)
 */

WOOL_OBJECT
wool_set_screen_background(background)
WOOL_Number     background;
{
    if (background -> type == WLNumber) {
	XSetWindowBackground(dpy, Context->root,
			     background -> number);
    } else if (background -> type == WLPixmap) {
	decrease_reference(((ClientWindow) Context->rootWob) -> tile);
	increase_reference(((ClientWindow) Context->rootWob) -> tile =
			   (WOOL_OBJECT) background);
	XSetWindowBackgroundPixmap(dpy, Context->root,
				   ((WOOL_Pixmap) background) -> pixmap);
    } else {
	wool_puts("Not a background: ");
	wool_print(background);
	wool_newline();
    }
    XClearWindow(dpy, Context->root);
    return NIL;
}

WOOL_OBJECT
wool_set_screen_saver(argc, argv)
int argc;
WOOL_Number	argv[];
{
    if (argc != 4)
	wool_error(BAD_NUMBER_OF_ARGS, argc);
    XSetScreenSaver(dpy, argv[0] -> number, argv[1] -> number,
		    argv[2] -> number, argv[3] -> number);
    return NIL;
}

WOOL_OBJECT
wool_set_acceleration(num, den)
WOOL_Number     num, den;
{
    XChangePointerControl(dpy, 1, 0, num -> number, den -> number, 0);
    return NIL;
}

WOOL_OBJECT
wool_set_threshold(threshold)
WOOL_Number     threshold;
{
    XChangePointerControl(dpy, 0, 1, 1, 1, threshold -> number);
    return NIL;
}

/* Keyboard bell ringer: (bell [volume percentage])
 */

WOOL_OBJECT
wool_keyboard_bell_ring(argc, argv)
int argc;
WOOL_Number argv[];
{
    int             percent = 0;

    if (argc) {
	must_be_number(argv[0], 0);
	percent = argv[0] -> number;
    }
    XBell(dpy, percent);
    return NIL;
}

/*
 * change mapping by specifiyng
 * keycode keysym keysym-with-mod1 keysym-with-mod2 ...
 * WARNING:  XChangeKeyboardMapping MALLOCS! (do not re-change same keys!)
 */

WOOL_OBJECT
wool_change_keyboard_mapping(argc, argv)
int argc;
WOOL_Number argv[];
{
    KeySym         *keysyms = (KeySym *) Malloc((argc - 1) * sizeof(KeySym));
    int             i;

    for (i = 0; i < argc - 1; i++) {
	keysyms[i] = argv[i + 1] -> number;
    }
    XChangeKeyboardMapping(dpy, argv[0] -> number, argc - 1, keysyms, 1);
    Free(keysyms);
    return NIL;
}

/*
 * converts a key name to a keysym
 */

WOOL_OBJECT
wool_string_to_keysym(string)
WOOL_String string;
{
    KeySym          keysym;

    must_be_string(string, 0);
    return (WOOL_OBJECT)
    	WLNumber_make(XStringToKeysym(string -> string));
}
    
/* translation beetween keysyms and keycodes
 */

WOOL_OBJECT
wool_keysym_to_keycode(key)
WOOL_Number key;
{
    must_be_number(key, 0);
    return (WOOL_OBJECT) WLNumber_make(XKeysymToKeycode(dpy, key->number));
}

WOOL_OBJECT
wool_keycode_to_keysym(key, index)
WOOL_Number key, index;
{
    must_be_number(key, 0);
    must_be_number(index, 1);
    return (WOOL_OBJECT) WLNumber_make(XKeycodeToKeysym(
				      dpy, key -> number, index -> number));
}

/*
 * Selection interface:
 * Active values:
 * 	cut-buffer: access to cut-buffer 0 (for xterm use)
 */

WOOL_OBJECT
wool_cut_buffer_0_get()
{
    int             nbytes;
    char           *buffer = XFetchBytes(dpy, &nbytes);
    WOOL_String     string_of_buffer;

    if (buffer) {
	string_of_buffer = WLString_make(buffer);
	XFree(buffer);
	return (WOOL_OBJECT) string_of_buffer;
    } else {
	return (WOOL_OBJECT) NIL_STRING;
    }
}

WOOL_OBJECT
wool_cut_buffer_0_set(string)
WOOL_String	string;
{
    XStoreBytes(dpy, string -> string, strlen(string -> string));
    XSetSelectionOwner(dpy, XA_PRIMARY, None, CurrentTime);
    return (WOOL_OBJECT) string;
}

/* buffer i becomes buffer i+incr %8 */

WOOL_OBJECT
wool_rotate_cut_buffers(argc, argv)
int argc;
WOOL_Number argv[];
{
    int             incr = 1;

    if (argc) {
	must_be_number(argv[0], 0);
	incr = argv[0] -> number;
    }
    XRotateBuffers(dpy, incr);
    return NIL;
}

/*
 * RESOURCE MANAGER INTERFACE
 * (WLRSC)
 * 
 * (WLRSC_put description value)
 * (WLRSC_get name class) --> value
 * 
 * types:
 * 	0	WOOL_OBJECT (auto-typed!)
 * 
 * KNOWN_BUG: if putting twice the same description,
 * 	previous value is not freed!
 */

WOOL_OBJECT
WLRSC_put(resource, value)
WOOL_String 	resource;
WOOL_OBJECT	value;
{
    XrmValue xrm_value;

    must_be_string(resource, 0);
    xrm_value.size = sizeof(WOOL_OBJECT);
    increase_reference(value);
    xrm_value.addr = (caddr_t) &value;
    XrmPutResource(&WLRSC_database, resource -> string, 0, &xrm_value);
    return value;
}

WOOL_OBJECT
WLRSC_get(name, class)
WOOL_String 	name, class;
{
    XrmValue        xrm_value;
    char *	    type;

    must_be_string(name, 0);
    must_be_string(class, 1);
#ifdef DEBUG
    {
	int numdn = 0, numdc = 0;
	char *p;
	for (p = name -> string; *p; p++)
	    if (*p == '.')
		numdn++;
	for (p = class -> string; *p; p++)
	    if (*p == '.')
		numdc++;
	if (numdn != numdc) {
	    char tmp[2000];
	    strcpy(tmp, name->string);
	    strcat(tmp, ", ");
	    strcat(tmp, class->string);
	    return wool_error("Bad resource fetch %s", tmp);
	}
    }
#endif

    if (False ==
	XrmGetResource(WLRSC_database, name -> string, class -> string,
		       &type, &xrm_value))
	return NIL;
    else
	return (WOOL_OBJECT) *((WOOL_OBJECT *) (xrm_value.addr));
}

/*
 * get any property of current window
 */

WOOL_OBJECT
wool_get_window_property(name)
WOOL_String name;
{
    Atom            actual_type;
    Atom            property_name;
    int             actual_format;
    unsigned long   nitems;
    unsigned long   bytes_after;
    unsigned char  *buffer = 0;
    WOOL_OBJECT     result = NIL;
    WOOL_Pointer    x_atom;

    must_be_string(name, 0);
    if (wool_self_pointer_make(name -> string, '\030', &x_atom)) {
	property_name = *(x_atom -> ptr);
    } else {
	property_name = XInternAtom(dpy, name -> string, False);
	*(x_atom -> ptr) = property_name;
    }
    if (TargetWindow -> client &&
	Success == XGetWindowProperty(dpy, TargetWindow -> client,
				   property_name, 0, 8000,
				      GWM_delete_read_properties,
       AnyPropertyType, &actual_type, &actual_format, &nitems, &bytes_after,
				   &buffer)
	&& buffer && nitems) {
	switch (actual_type) {
	case XA_STRING:
	    result = (WOOL_OBJECT) WLString_make(buffer);
	    break;
	case XA_INTEGER:
	    result = (WOOL_OBJECT) WLNumber_make(*((int *) buffer));
	    break;
	}
	XFree(buffer);
	return result;
    } else {
	return NIL;
    }
}

WOOL_OBJECT
wool_set_window_property(name, value)
WOOL_String name;
WOOL_String value;
{
    Atom            actual_type;
    Atom            property_name;
    int             actual_format;
    unsigned long   nitems;
    unsigned char  *buffer;
    WOOL_Pointer    x_atom;
    WOOL_TYPE       type;

    must_be_string(name, 0);
    if (wool_self_pointer_make(name -> string, '\030', &x_atom)) {
	property_name = *(x_atom -> ptr);
    } else {
	property_name = XInternAtom(dpy, name -> string, False);
	*(x_atom -> ptr) = property_name;
    }

    type = value -> type;
    if (type == WLString || type == WLAtom || type == WLActive ||
	type == WLPointer || type == WLName) {
	actual_type = XA_STRING;
	actual_format = 8;
	if (type == WLString)
	    buffer = (unsigned char *) value -> string;
	else
	    buffer = (unsigned char *) ((WOOL_Atom) value) -> p_name;
	nitems = strlen(buffer) + 1;
    } else if (type == WLNumber) {
	actual_type = XA_INTEGER;
	actual_format = 32;
	buffer = (unsigned char *) &(((WOOL_Number) value) -> number);
	nitems = 1;
    } else {
	bad_argument(value, 1, "string or number");
    }

    if (TargetWindow -> client &&
	Success == XChangeProperty(dpy, TargetWindow -> client,
				   property_name, actual_type, actual_format,
				   PropModeReplace, buffer, nitems))
	return (WOOL_OBJECT) value;
    else
	return NIL;
}
WOOL_OBJECT
wool_set_window_property_append(name, value)
WOOL_String name;
WOOL_String value;
{
    Atom            actual_type;
    Atom            property_name;
    int             actual_format;
    unsigned long   nitems;
    unsigned char  *buffer;
    WOOL_Pointer    x_atom;
    WOOL_TYPE       type;

    must_be_string(name, 0);
    if (wool_self_pointer_make(name -> string, '\030', &x_atom)) {
	property_name = *(x_atom -> ptr);
    } else {
	property_name = XInternAtom(dpy, name -> string, False);
	*(x_atom -> ptr) = property_name;
    }

    type = value -> type;
    if (type == WLString || type == WLAtom || type == WLActive ||
	type == WLPointer || type == WLName) {
	actual_type = XA_STRING;
	actual_format = 8;
	if (type == WLString)
	    buffer = (unsigned char *) value -> string;
	else
	    buffer = (unsigned char *) ((WOOL_Atom) value) -> p_name;
	nitems = strlen(buffer) + 1;
    } else if (type == WLNumber) {
	actual_type = XA_INTEGER;
	actual_format = 32;
	buffer = (unsigned char *) &(((WOOL_Number) value) -> number);
	nitems = 1;
    } else {
	bad_argument(value, 1, "string or number");
    }

    if (TargetWindow -> client &&
	Success == XChangeProperty(dpy, TargetWindow -> client,
				   property_name, actual_type, actual_format,
				   PropModeAppend, buffer, nitems))
	return (WOOL_OBJECT) value;
    else
	return NIL;
}

/* send  a client message event */
WOOL_OBJECT
wool_send_client_message(argc, argv)
    int       argc;
    WOOL_Number argv[];
{
    Atom      property_name;
    unsigned long nitems;
    unsigned char *buffer;
    WOOL_Pointer x_atom;
    WOOL_TYPE type;
    int i;
    XClientMessageEvent CliMessage;

    if (argc < 2)
	wool_error(BAD_NUMBER_OF_ARGS, argc);
    must_be_string(argv[0], 0);
    if (wool_self_pointer_make(((WOOL_String)argv[0])->string, '\030', &x_atom)) {
	property_name = *(x_atom->ptr);
    }
    else {
	property_name = XInternAtom(dpy,((WOOL_String)argv[0])->string, False);
	*(x_atom->ptr) = property_name;
    }

    CliMessage.message_type = property_name;
    CliMessage.window = TargetWindow->client;
    CliMessage.type = ClientMessage;

    type = argv[1]->type;
    if (type == WLString || type == WLAtom || type == WLActive ||
	type == WLPointer || type == WLName) {
	CliMessage.format = 8;
	if (type == WLString)
	    buffer = (unsigned char *) ((WOOL_String)argv[1])->string;
	else
	    buffer = (unsigned char *) ((WOOL_Atom) argv[1])->p_name;
	nitems = strlen(buffer) + 1;
	if (nitems > 20)
	    nitems = 20;
	bcopy(buffer, CliMessage.data.b, nitems);

    }
    else if ((type == WLNumber) && (argc < 6)) {
	CliMessage.format = 32;
	for (i = 1; i < argc; i++) {
	    CliMessage.data.l[i - 1] = (long) (((WOOL_Number) argv[i])->number);
	}
    }
    else if ((type == WLNumber) && (argc < 11)) {
	CliMessage.format = 16;
	for (i = 1; i < argc; i++) {
	    CliMessage.data.s[i - 1] = (short) (((WOOL_Number) argv[i])->number);
	}
    }
    else
	return TRU;



    XSendEvent(dpy, TargetWindow->client, False, 0, (XEvent *) &CliMessage);
    return NIL;
}

/* executes GWM_EXECUTE string in current window
 */

WlExecGWM_EXECUTE()
{
    WOOL_OBJECT wool_get_window_property();
    static WOOL_String gwm_execute_string;
    WOOL_OBJECT to_exec;
    int OldGWM_delete_read_properties = GWM_delete_read_properties;
    
    if(!gwm_execute_string)
	increase_reference(gwm_execute_string = WLString_make("GWM_EXECUTE"));
    
    GWM_delete_read_properties = True;
    to_exec = wool_get_window_property(gwm_execute_string);
    GWM_delete_read_properties = OldGWM_delete_read_properties;
    wool_execute_wool_string(to_exec);
}

/*
 * interface to XGetDefault
 */

WOOL_OBJECT
wool_x_get_default(program, option)
WOOL_String program;
WOOL_String option;
{
    char           *result;

    must_be_string(program, 0);
    must_be_string(option, 1);
    result = XGetDefault(dpy, program -> string, option -> string);
    if (result)
	return (WOOL_OBJECT) WLString_make(result);
    else
	return NIL;
}

/*
 * Returns a color (pixel value) from an English name, or a #RGB description
 */

WOOL_OBJECT
wool_color_make(color)
WOOL_String color;
{
    XColor          x_color;

    must_be_string(color, 0);
    XSetErrorHandler(NoXError);
    if (!XParseColor(dpy, DefaultColormap(dpy, Context -> screen),
		     color -> string, &x_color)) {
	wool_printf("GWM: Color not found: %s\n", color -> string);
	x_color.pixel = Context -> pixel.Back;
    } else if (!XAllocColor(dpy, DefaultColormap(dpy, Context -> screen),
		     &x_color)) {
	wool_printf("GWM: Colormap full, couldn't allocate Color: %s\n",
		    color -> string);
	x_color.pixel = Context -> pixel.Back;
    }
    XSync(dpy, 0);
    XSetErrorHandler(XError);
    return (WOOL_OBJECT) WLNumber_make(x_color.pixel);
}

WOOL_OBJECT
wool_rgb_color_make(argc, argv)
int argc;
WOOL_Number argv[];
{
    XColor          x_color;

    if (argc != 3)
	wool_error(BAD_NUMBER_OF_ARGS, argc);
    must_be_number(argv[0], 0);
    must_be_number(argv[1], 1);
    must_be_number(argv[2], 2);

    x_color.red = argv[0] -> number;
    x_color.green = argv[1] -> number;
    x_color.blue = argv[2] -> number;

    XSetErrorHandler(NoXError);
    if (!XAllocColor(dpy, DefaultColormap(dpy, Context -> screen), &x_color)) {
	wool_printf("GWM: Color not found: #%04x%04x%04x\n",
		argv[0] -> number, argv[1] -> number, argv[2] -> number);
	x_color.pixel = Context -> pixel.Back;
    }
    XSync(dpy, 0);
    XSetErrorHandler(XError);
    return (WOOL_OBJECT) WLNumber_make(x_color.pixel);
}

WOOL_OBJECT
wool_color_free(argc, argv)
    int argc;
    WOOL_Number argv[];
{
    unsigned long *pixels = (unsigned long *) Malloc(argc * sizeof(int));
    int i;

    for (i = 0; i < argc; i++) {
	pixels[i] = argv[i] -> number;
    }
    XSetErrorHandler(NoXError);
    XFreeColors(dpy, DefaultColormap(dpy, Context -> screen),
		pixels, argc, 0);
    XSync(dpy, 0);
    XSetErrorHandler(XError);
    return NIL;
}

/* returns the RGB values of a color as a list of 3 integers between
 * 0 and 65535
 */

WOOL_OBJECT
wool_color_components(color)
WOOL_Number color;
{
    XColor          x_color;
    WOOL_List       result;

    must_be_number(color, 0);
    x_color.pixel = color->number;
    XQueryColor(dpy, DefaultColormap(dpy, Context -> screen), &x_color);
    result = wool_list_make(3);
    increase_reference(result->list[0] =
		       (WOOL_OBJECT) WLNumber_make(x_color.red));
    increase_reference(result->list[1] =
		       (WOOL_OBJECT) WLNumber_make(x_color.green));
    increase_reference(result->list[2] =
		       (WOOL_OBJECT) WLNumber_make(x_color.blue));
    return (WOOL_OBJECT) result;
}


/*
 * loading a font (prefixed by ^F in hash table)
 */

WOOL_OBJECT
wool_font_make(string)
WOOL_String     string;
{
    long            fontid;
    WOOL_Pointer    font_pointer;

    if (wool_self_pointer_make(string -> string, '\006', &font_pointer)) {
	fontid = *(font_pointer -> ptr);
    } else {
	if (TrapXErrors(fontid = (long) XLoadFont(dpy, string -> string))
	    || (!fontid)) {

/*
 *     /*This should have used the server's default but seems broken... 
 * 	    wool_printf("GWM: Cannot find Font %s , using server default\n",
 * 			string -> string);
 * 	    fontid = XQueryFont(dpy,
 * 			      DefaultGC(dpy, Context->screen) -> gid) -> fid;
 * 	}
 */

	    wool_printf("GWM: Cannot find Font %s , using \"font\" default\n",
			string -> string);
	    *(font_pointer -> ptr) = fontid = DefaultFont;
	} else {
	    *(font_pointer -> ptr) = fontid;
	}
    }
    return (WOOL_OBJECT) WLNumber_make(fontid);
}


/*
 * send an user event to all sub-wobs of the window
 */

WOOL_OBJECT
wool_send_user_event(argc, argv)
int argc;
WOOL_Number argv[];
{
    ClientWindow cw, sender;
    XAnyEvent evt;
    int old_GWM_Propagate_user_events = GWM_Propagate_user_events;

    sender = TargetWindow;
    if(argc >= 2){
	cw = (ClientWindow) argv[1] -> number;
    }else{
	cw = sender;
    }
    if (argc == 3 && ((WOOL_OBJECT) argv[2]) != NIL)
	GWM_Propagate_user_events = 0;
    else
	GWM_Propagate_user_events = 1;
    if(!cw || argc == 0)
    return NIL;
    must_be_or_nil(WLAtom, argv[0], 0);
    evt.type = GWMUserEvent;			/* our event */
    evt.display = (Display *) argv[0]; 		/* the message */
    evt.window = (Window) sender;		/* the sender */
    {
	SAVE_EVENT_CONTEXT;
	WOOL_send(WOOL_process_event, cw, (cw, &evt)); 
	RESTORE_EVENT_CONTEXT;
    }
    GWM_Propagate_user_events = old_GWM_Propagate_user_events;
    return NIL;
}

/* get the value of GWM_ProcessingExistingWindows */

WOOL_OBJECT
GWM_ProcessingExistingWindows_get()
{
    if (GWM_ProcessingExistingWindows)
	return TRU;
    else
	return NIL;
}

/* returns the list of managed screens
 */

WOOL_OBJECT
wool_get_list_of_screens()
{
    WOOL_List       wl_list = wool_list_make(ScreenCount(dpy));
    int             i = 0;

    FOR_ALL_SCREENS{
	increase_reference(wl_list -> list[i++] =
			   (WOOL_OBJECT) WLNumber_make(Context -> screen));
    }END_OF_ALL_SCREENS;
    wl_list -> size = i;
    return (WOOL_OBJECT) wl_list;
}

/* returns the list of clientwindows or realized icons on screen,
 * mapped or not
 */

WOOL_OBJECT
wool_get_list_of_windows(argc, argv)
int	argc;
WOOL_Atom argv[];
{
    int             i;
    WOOL_List       wl_list;
    ClientWindow    cw;
    int             status = 0;		/* 'window or 'icon */
    int             mapped = 0;		/* 'mapped for only visible ones */
    int             stacking_order = 0;	/* do a XQueryTree to get the list */
    unsigned int    nb_windows = Context -> WindowCount;
    Window         *windows, dummywin, parent;

    for (i = 0; i < argc; i++)		/* options parsing */
	if (argv[i] == WA_window)
	    status = ClientWindowStatus;
	else if (argv[i] == WA_icon)
	    status = IconStatus;
	else if (argv[i] == WA_mapped)
	    mapped = 1;
	else if (argv[i] == WA_stacking_order)
	    stacking_order = 1;

    if (stacking_order) {
	XQueryTree(dpy, Context->root, &dummywin, &parent,
		   &windows, &nb_windows);
    }
    if (nb_windows) {
	wl_list = wool_list_make(nb_windows);
	if (stacking_order)
	    cw = init_managed_windows(windows, nb_windows); /* will free */
	else
	    cw = Context->rootWob -> next;
	i = 0;
	while (cw) {
	    if (((!status) || cw -> status & status)
		&& ((!mapped) || cw -> mapped))
		increase_reference(wl_list -> list[i++] =
				   (WOOL_OBJECT) WLNumber_make(cw));
	    if (stacking_order)
		cw = get_next_managed_window();
	    else
		cw = cw -> next;
	}
	wl_list -> size = i;
	if (i) {
	    return (WOOL_OBJECT) wl_list;
	}
    }
    return NIL;
}

static Window *managed_window_list;
static Window *old_managed_window_list;	/* to be freed */
static int     managed_window_size;

ClientWindow
init_managed_windows(window_list, window_size)
Window *window_list;
int     window_size;
{
    ClientWindow    cw = 0;

    XFreeN(old_managed_window_list);
    old_managed_window_list = window_list;
    while (window_size > 0
	   && (!(cw = (ClientWindow) LookUpWob(*window_list))
	       || cw -> type != ClientWindowClass)) {
	window_list++;
	window_size--;
    }
    managed_window_list = window_list;
    managed_window_size = window_size;
    return (window_size ? cw : 0);
}

ClientWindow
get_next_managed_window()
{
    ClientWindow    cw = 0;

    do {
	managed_window_list++;
	managed_window_size--;
    } while (managed_window_size > 0 &&
	     (!(cw = (ClientWindow) LookUpWob(*managed_window_list))
	      || cw -> type != ClientWindowClass));
    return (managed_window_size ? cw : 0);
}

/*
 * get the type of the wob (status)
 */

WOOL_OBJECT
wool_wob_status(wob)
Wob	wob;
{
    if (wob -> type[0] == (WOB_METHOD) WA_window
	&& (wob -> status & IconStatus))
	return (WOOL_OBJECT) WA_icon;
    else
	return (WOOL_OBJECT) wob -> type[0];
}

WOOL_OBJECT
wool_get_window_status()
{
    return wool_wob_status(TargetWindow);
}

WOOL_OBJECT
wool_get_wob_status()
{
    return wool_wob_status(TargetWob);
}

WOOL_OBJECT
wool_get_wob_of_position(x, y)
WOOL_Number x,y;
{
    int             xr, yr;
    Window          window;
    Wob             wob;

    if (XTranslateCoordinates(dpy, Context->root, Context->root,
			      x -> number, y -> number, &xr, &yr, &window)) {
	if ((wob = (Wob) LookUpWob(window))
	    || (wob = (Wob) LookUpClient(window)))
	    return (WOOL_OBJECT) WLNumber_make(wob);
    }
    return NIL;
}

/*
 * get the associated window:
 * 	clientwindow => icon
 * 	icon => clientwindow
 * 	menu => parent
 * 	wob => parent
 */

WOOL_OBJECT
wool_get_wob_parent()
{
    if (TargetWob -> parent)
	return (WOOL_OBJECT) WLNumber_make(TargetWob -> parent);
    else
	return NIL;
}

WOOL_OBJECT
wool_get_icon()
{
    Wob             target = TargetWob;

    if (!(TargetWindow -> icon)) {
	RealizeIconWindow(TargetWindow);
	SetTarget(target);
    }
    return (WOOL_OBJECT) WLNumber_make(TargetWindow -> icon);
}

WOOL_OBJECT
wool_icon_exists(argc, argv)
int argc;
WOOL_Number argv[];
{
    ClientWindow    cw;

    if (argc) {
	must_be_number(argv[0], 0);
	cw = (ClientWindow) argv[0] -> number;
    } else {
	cw = TargetWindow;
    }
    if (cw->icon) {
	return TRU;
    } else {
	return NIL;
    }
}

WOOL_OBJECT
wool_get_window()
{
    return (WOOL_OBJECT) WLNumber_make(TargetWindow -> window);
}

/*
 * width & height of any object
 */

WOOL_OBJECT
wool_width(object)
WOOL_OBJECT	object;
{
    struct _Box     box;

    object = GetWobOfNumber(object);
    WOOL_send(WOOL_get_dimensions, object, (object, &box));
    return (WOOL_OBJECT) WLNumber_make(box.width);
}

WOOL_OBJECT
wool_height(object)
WOOL_OBJECT	object;
{
    struct _Box     box;

    object = GetWobOfNumber(object);
    WOOL_send(WOOL_get_dimensions, object, (object, &box));
    return (WOOL_OBJECT) WLNumber_make(box.height);
}

WOOL_OBJECT
wool_dimensions(object)
WOOL_OBJECT     object;
{
    struct _Box     box;
    WOOL_Number	    tab[4];

    object = GetWobOfNumber(object);
    WOOL_send(WOOL_get_dimensions, object, (object, &box));
    tab[0] = WLNumber_make(box.x);
    tab[1] = WLNumber_make(box.y);
    tab[2] = WLNumber_make(box.width);
    tab[3] = WLNumber_make(box.height);
    return (WOOL_OBJECT) wool_list_make_from_evaluated_array(4, tab);    
}

#ifdef DEBUG
/* debugging-only functions:
 */

char *
atom_name(atom)				/* get name (string) of X atom */
Atom	atom;
{
    if (atom)
	return XGetAtomName(dpy, atom);
    else
	return NULL;
}
#endif /* DEBUG */

/* handler called by wool before execing a son after a fork
 */

wool_clean_before_exec()
{
    close(XConnectionNumber(dpy));
}

/*
 * restarts GWM the hard way
 */

WOOL_OBJECT
GWM_restart(argc, argv)
int     argc;
WOOL_String argv[];
{
    extern int      GWM_argc;
    extern char   **GWM_argv;

    if (argc) {				/* pass args */
	char          **new_argv = (char **)
	Malloc(sizeof(char *) * (argc + 1));
	int             i;

	for (i = 0; i < argc; i++) {
	    must_be_string(argv[i], i);
	    new_argv[i] = argv[i] -> string;
	}
	new_argv[argc] = 0;
	GWM_is_restarting = new_argv;
    } else {				/* same args */
	GWM_is_restarting = GWM_argv;
    }
    XSetInputFocus(dpy, PointerRoot, RevertToPointerRoot, CurrentTime);
    XSync(dpy, True);
    FOR_ALL_SCREENS {
	if (Context -> rootWob) {
	    SetTarget(Context -> rootWob);
	    ScreenClose(Context -> rootWob);
	}
    }END_OF_ALL_SCREENS;
    XCloseDisplay(dpy);
    execvp(GWM_is_restarting[0], GWM_is_restarting);
    return wool_error("could not restart %s", GWM_is_restarting[0]);
}

/* this function allows a kind of multitasking in wool:
 * It recusrivly processes pending events in the queue and returns as soon as
 * the queue is empty
 * Can be used during long tedious tasks so as not to "freeze" gwm
 * with arg <> (), do a Sync before
 */

WOOL_OBJECT
wool_process_events(argc, argv)
int         argc;
WOOL_OBJECT argv[];
{
    SAVE_EVENT_CONTEXT;
    if (argc && argv[0] != NIL)
	XSync(dpy, 0);
    GWM_ProcessEvents(0);
    RESTORE_EVENT_CONTEXT;
    return NIL;
}

/* to make a function call of an atom */

wool_function_call_make(list, atom)
WOOL_List *list;
WOOL_Atom atom;
{
    *list = wool_list_make(1);
    increase_reference((*list) -> list[0] = (WOOL_OBJECT) atom);
    increase_reference(*list);
}

/* Here goes the initialisations to be done AFTER wool is brought up, but
 * BEFORE the user's profile is read
 * 
 * You will bind all your C functions to WOOL atoms here
 */

void
GWM_init_wool_before_profile()
{
    /* Types of Wool Objects, This the ONLY list of all objects 
     * see also declarations of wobs at the end of the function
     */

    WLActive[0] = (WOOL_METHOD) wool_atom("active");
    WLAtom[0] = (WOOL_METHOD) wool_atom("atom");
    WLBar[0] = (WOOL_METHOD) wool_atom("bar");
    WLClient[0] = (WOOL_METHOD) wool_atom("client");
    WLCollection[0] = (WOOL_METHOD) wool_atom("collection");
    WLQuotedExpr[0] = (WOOL_METHOD) wool_atom("quoted-expr");
    WLCursor[0] = (WOOL_METHOD) wool_atom("cursor");
    WLEvent[0] = (WOOL_METHOD) wool_atom("event");
    WLFsm[0] = (WOOL_METHOD) wool_atom("fsm");
    WLFsmState[0] = (WOOL_METHOD) wool_atom("fsm-state");
    WLStateArc[0] = (WOOL_METHOD) wool_atom("state-arc");
    WLSubr[0] = (WOOL_METHOD) wool_atom("subr");
    WLFSubr[0] = (WOOL_METHOD) wool_atom("fsubr");
    WLExpr[0] = (WOOL_METHOD) wool_atom("expr");
    WLFExpr[0] = (WOOL_METHOD) wool_atom("fexpr");
    WLLabel[0] = (WOOL_METHOD) wool_atom("label");
    WLList[0] = (WOOL_METHOD) wool_atom("list");
    WLMenu[0] = (WOOL_METHOD) wool_atom("menu");
    WLName[0] = (WOOL_METHOD) wool_atom("name");
    WLNamespace[0] = (WOOL_METHOD) wool_atom("namespace");
    WLNumber[0] = (WOOL_METHOD) wool_atom("number");
    WLPixmap[0] = (WOOL_METHOD) wool_atom("pixmap");
    WLPlug[0] = (WOOL_METHOD) wool_atom("plug");
    WLPointer[0] = (WOOL_METHOD) wool_atom("pointer");
    WLString[0] = (WOOL_METHOD) wool_atom("string");

    					/*  wool functions: declare them with
					   type, C name, WOOL name, number of
					   arguments (0,1,2,NARY) */

    wool_subr_make(WLSubr, wool_client_make, "window-make", NARY);
    wool_subr_make(WLSubr, wool_plug_make, "plug-make", 1);
    wool_subr_make(WLSubr, wool_bar_make, "bar-make", NARY);
    wool_subr_make(WLSubr, wool_fsm_make, "fsm-make", NARY);
    wool_subr_make(WLSubr, wool_fsm_state_make, "state-make", NARY);
    wool_subr_make(WLFSubr, wool_state_arc_make, "on", NARY);
    wool_subr_make(WLSubr, wool_state_arc_make, "on-eval", NARY);
    increase_reference(wool_atom("pixmap-make") -> c_val =
     wool_subr_make(WLSubr, wool_layered_bitmap_make, "layered-bitmap-make",
		    NARY));
    wool_subr_make(WLSubr, wool_label_make, "active-label-make", NARY);
    wool_subr_make(WLSubr, wool_cursor_make, "cursor-make", NARY);
    wool_subr_make(WLSubr, wool_menu_make, "menu-make", NARY);
    wool_subr_make(WLSubr, wool_font_make, "font-make", 1);
    wool_subr_make(WLSubr, wool_color_make, "color-make", 1);
    wool_subr_make(WLSubr, wool_rgb_color_make, "color-make-rgb", NARY);
    wool_subr_make(WLSubr, wool_color_free, "color-free", NARY);
    wool_subr_make(WLSubr, wool_color_components, "color-components", 1);
    wool_subr_make(WLSubr, wool_stamp_make, "label-make", NARY);
    wool_subr_make(WLSubr, wool_string_to_keysym, "key-make", 1);
    wool_subr_make(WLSubr, wool_set_acceleration, "set-acceleration", 2);
    wool_subr_make(WLSubr, wool_set_threshold, "set-threshold", 1);
    wool_subr_make(WLSubr,
		   wool_change_keyboard_mapping, "set-key-binding", NARY);
    wool_subr_make(WLSubr, wool_refresh, "refresh", NARY);
    wool_subr_make(WLSubr, wool_set_screen_saver, "set-screen-saver", NARY);
    wool_subr_make(WLSubr, PlaceFixedMenu, "place-menu", NARY);
    wool_subr_make(WLSubr, wool_meter_open, "meter-open", NARY);
    wool_subr_make(WLSubr, wool_meter_update, "meter-update", 1);
    wool_subr_make(WLSubr, MeterClose, "meter-close", 0);
    wool_subr_make(WLSubr, WLRSC_put, "resource-put", 2);
    wool_subr_make(WLSubr, WLRSC_get, "resource-get", 2);
    wool_subr_make(WLSubr, wool_x_get_default, "get-x-default", 2);
    wool_subr_make(WLFSubr, CirculateWindowsDown,
		   "circulate-windows-down", 0);
    wool_subr_make(WLFSubr, CirculateWindowsUp, "circulate-windows-up", 0);
    wool_subr_make(WLSubr, ReDecorateWindow, "re-decorate-window", NARY);
    wool_subr_make(WLSubr, KillWindow, "kill-window", NARY);
    wool_subr_make(WLSubr, MoveWindow, "move-window", NARY);
    wool_subr_make(WLSubr, MoveSeveralWindows, "move-several-windows", NARY);
    wool_subr_make(WLSubr, ResizeWindow, "resize-window", NARY);
    wool_subr_make(WLSubr, RaiseWindow, "raise-window", NARY);
    wool_subr_make(WLSubr, LowerWindow, "lower-window", NARY);
    wool_subr_make(WLSubr, IconifyWindow, "iconify-window", 0);
    wool_subr_make(WLSubr, wool_set_focus, "set-focus", NARY);
    wool_subr_make(WLSubr, wool_send_user_event, "send-user-event", NARY);
    wool_subr_make(WLSubr, wool_get_triggering_event_state,
		   "current-event-modifier", 0);
    wool_subr_make(WLSubr, wool_get_triggering_event_code,
		   "current-event-code", 0);
    wool_subr_make(WLSubr, wool_get_triggering_event_x,
		   "current-event-x", 0);
    wool_subr_make(WLSubr, wool_get_triggering_event_y,
		   "current-event-y", 0);
    wool_subr_make(WLSubr, wool_get_triggering_event_time,
		   "current-event-time", 0);
    wool_subr_make(WLSubr, wool_get_triggering_event_data,
		   "current-event-data", 0);
    wool_subr_make(WLSubr, PopMenu, "pop-menu", NARY);
    wool_subr_make(WLSubr, UnpopMenu, "unpop-menu", NARY);
    wool_subr_make(WLSubr, wool_set_grab, "grab-server", NARY);
    wool_subr_make(WLSubr, wool_remove_grab, "ungrab-server", NARY);
    wool_subr_make(WLSubr, MapWindow, "map-window", NARY);
    wool_subr_make(WLSubr, UnmapWindow, "unmap-window", NARY);
    wool_subr_make(WLFSubr, wool_last_key_struck, "last-key", 0);
    wool_subr_make(WLSubr, wool_get_list_of_windows, "list-of-windows", NARY);
    wool_subr_make(WLSubr, wool_get_list_of_screens, "list-of-screens", NARY);
    wool_subr_make(WLFSubr, wool_logical_coords,
		   "current-event-window-coords", 0);
    wool_subr_make(WLSubr, wool_send_key_to_client, "send-key-to-window", 2);
    wool_subr_make(WLSubr, wool_send_keycode_to_client,
		   "send-keycode-to-window", 2);
    wool_subr_make(WLSubr, wool_send_button_to_client,
		   "send-button-to-window", NARY);
    wool_subr_make(WLFSubr, wool_process_exposes, "process-exposes", 0);
    wool_subr_make(WLFSubr, wool_current_mouse_position,
		   "current-mouse-position", 0);
    wool_subr_make(WLFSubr, current_wob_invert_aera, "wob-invert", 0);
    wool_subr_make(WLSubr, wool_get_window_property, "get-x-property", 1);
    wool_subr_make(WLSubr, wool_set_window_property, "set-x-property", 2);
    wool_subr_make(WLSubr, wool_set_window_property_append, 
		   "set-x-property-append", 2);
    wool_subr_make(WLSubr, wool_send_client_message, "send-client-message",
		   NARY);
    wool_subr_make(WLSubr, wool_get_wob_of_position, "wob-at-coords", 2);
    wool_subr_make(WLFSubr, wool_last_user_event, "current-user-event", 0);
    wool_subr_make(WLSubr, wool_resend_event, "send-current-event", 1);
    wool_subr_make(WLSubr, wool_xpm_pixmap_make, "paxmap-make", NARY);
    wool_subr_make(WLSubr, wool_xpm_pixmap_make, "pixmap-load", NARY);
    wool_subr_make(WLSubr, wool_rotate_cut_buffers,
    		   "rotate-cut-buffers", NARY);
    wool_subr_make(WLSubr, wool_draw_line, "draw-line", NARY);
    wool_subr_make(WLSubr, wool_draw_rectangle, "draw-rectangle", NARY);
    wool_subr_make(WLSubr, wool_draw_text, "draw-text", NARY);
    wool_subr_make(WLSubr, wool_keyboard_bell_ring, "bell", NARY);
    wool_subr_make(WLSubr, wool_wm_state_update, "window-wm-state-update", NARY);
    wool_subr_make(WLSubr, wool_set_colormap_focus,
    		   "set-colormap-focus", NARY);
    wool_subr_make(WLSubr, wool_set_wm_icon_sizes, "set-icon-sizes", NARY);
    wool_subr_make(WLSubr, wool_set_subwindow_colormap_focus,
    		   "set-subwindow-colormap-focus", NARY);
    wool_subr_make(WLSubr, wool_set_grabs, "set-grabs", NARY);
    wool_subr_make(WLSubr, wool_unset_grabs, "unset-grabs", NARY);
    wool_subr_make(WLSubr, wool_width, "width", 1);
    wool_subr_make(WLSubr, wool_height, "height", 1);
    wool_subr_make(WLSubr, wool_dimensions, "dimensions", 1);
    wool_subr_make(WLSubr, GWM_restart, "restart", NARY);
    wool_subr_make(WLSubr, wool_process_events, "process-events", NARY);
    wool_subr_make(WLSubr, wool_delete_window, "delete-window", NARY);
    wool_subr_make(WLSubr, wool_save_yourself, "save-yourself", NARY);
    wool_subr_make(WLSubr, wool_keycode_to_keysym, "keycode-to-keysym", 2);
    wool_subr_make(WLSubr, wool_keysym_to_keycode, "keysym-to-keycode", 1);
    wool_subr_make(WLSubr, wool_list_make_from_wool, "list-make", NARY);
    wool_subr_make(WLSubr, wool_meter_modify, "meter", NARY);
    wool_subr_make(WLSubr, wool_warp_pointer, "warp-pointer", NARY);
    wool_subr_make(WLSubr, WLMenu_wob, "menu-wob", 1);
    wool_subr_make(WLSubr, wool_wm_state_get, "window-wm-state", NARY);
    wool_subr_make(WLSubr, wool_get_triggering_event_x_relative,
    	"current-event-relative-x", 0);
    wool_subr_make(WLSubr, wool_get_triggering_event_y_relative,
    	"current-event-relative-y", 0);
    wool_subr_make(WLSubr, wool_ungrab_and_replay_event,
	"ungrab-server-and-replay-event", 1);
    wool_subr_make(WLSubr, wool_makes_replayable, "replayable-event", 1);
    wool_subr_make(WLSubr, wool_event_was_due_to_a_grab,
    	"current-event-from-grab", 0);
    wool_subr_make(WLSubr, wool_get_wm_command, "get-wm-command", 0);
    wool_subr_make(WLSubr, MakeResourceIdentifier, "make-string-usable-for-resource-key", 1);
    wool_subr_make(WLSubr, wool_allow_events, "allow-event-processing", 0);
    wool_subr_make(WLSubr, LookUpWobW, "xid-to-wob", 1);
    wool_subr_make(WLSubr, Window2ClientW, "window-to-client", 1);
    wool_subr_make(WLSubr, Client2WindowW, "client-to-window", 1);
    wool_subr_make(WLSubr, wool_window_is_valid, "window-is-valid", 1);
    wool_subr_make(WLSubr, wool_wob_is_valid, "wob-is-valid", 1);
    wool_subr_make(WLSubr, wool_icon_exists, "window-icon?", NARY);

					/* --- */
#ifdef SHAPE
    wool_subr_make(WLSubr, wool_window_has_shaped_client,
    	"window-is-shaped", 0);
#else /* SHAPE */
    wool_subr_make(WLSubr, NIL_FUNC, "window-is-shaped", 0);
#endif /* SHAPE */

 					/* pointers to ints: declare them
					   with WOOL name, pointer to memory
					   location */

    wool_pointer_make("borderwidth", &DefaultBorderWidth);
    wool_pointer_make("inner-borderwidth", &DefaultInnerBorderwidth);
    wool_pointer_make("move-grid-style", &GWM_Movegrid);
    wool_pointer_make("resize-grid-style", &GWM_Resizegrid);
    wool_pointer_make("resize-style", &GWM_resize_style);
    wool_pointer_make("mwm-resize-style-corner-size",
		      &GWM_window_cutting_size);
    wool_pointer_make("mwm-resize-style-catch-corners",
		      &GWM_Mwm_catch_corners);
    wool_pointer_make("move-meter", &GWM_Move_meter);
    wool_pointer_make("resize-meter", &GWM_Resize_meter);
    wool_pointer_make("label-horizontal-margin",
		      &DefaultLabelHorizontalMargin);
    wool_pointer_make("label-vertical-margin",
		      &DefaultLabelVerticalMargin);
    wool_pointer_make("plug-separator", &DefaultPlugSeparator);
    wool_pointer_make("bar-separator", &DefaultBarSeparator);
    wool_pointer_make("invert-cursors", &GWM_InvertCursors);
    WA_font = (WOOL_Atom) wool_pointer_make("font", &DefaultFont);
    wool_pointer_make("freeze-server", &GWM_GrabServer);
    wool_pointer_make("double-click-delay", &GWM_DoubleClickDelay);
    wool_pointer_make("direction", &DefaultMenuDirection);
    wool_pointer_make("bar-max-width", &DefaultBarMaxWidth);
    wool_pointer_make("bar-min-width", &DefaultBarMinWidth);
    wool_pointer_make("menu-max-width", &DefaultMenuMaxWidth);
    wool_pointer_make("menu-min-width", &DefaultMenuMinWidth);
    wool_pointer_make("check-input-focus-flag", &GWM_check_input_focus_flag);
    wool_pointer_make("print-errors-flag", &wool_do_print_errors);
    wool_pointer_make("screen-count", &GWM_ScreenCount);
    wool_pointer_make("grab-keyboard-also", &GWM_grab_keyboard_also);
    wool_pointer_make("confine-grabs", &GWM_confine_grabs);
    wool_pointer_make("confine-windows", &GWM_confine_windows);
    wool_pointer_make("gwm-quiet", &GWM_quiet);
    wool_pointer_make("reenter-on-opening", &GWM_reenter_on_opens);
    wool_pointer_make("delete-read-properties", &GWM_delete_read_properties);
    wool_pointer_make("never-warp-pointer", &GWM_never_warp_pointer);
    wool_pointer_make("xpm-closeness", &GWM_xpm_closeness);
    wool_pointer_make("border-on-shaped", &GWM_allow_border_on_shaped_windows);

					/* pointers to Context fields */

#define pointer_to_Context(name, field) \
    (WOOL_Atom) wool_base_pointer_make(name, &Context, &(Context -> field))

    WA_background = pointer_to_Context("background", pixel.Back);
    WA_foreground = pointer_to_Context("foreground", pixel.Fore);
    WA_borderpixel = pointer_to_Context("borderpixel", pixel.Border);
    pointer_to_Context("grid-color", pixel.GridColor);
    pointer_to_Context("invert-color", pixel.InvertColor);
    pointer_to_Context("screen-width", width);
    pointer_to_Context("screen-height", height);
    pointer_to_Context("screen-depth", depth);
    pointer_to_Context("screen-widthMM", widthMM);
    pointer_to_Context("screen-heightMM", heightMM);

 					/* context atoms initialisation. Give
					   type, C name, WOOL name, initial
					   value */

    wool_atom_make(WOOL_Atom, WA_bordertile, "bordertile", NIL);
    wool_atom_make(WOOL_Atom, WA_property, "property", NIL);
    wool_atom_make(WOOL_Atom, WA_fsm, "fsm", NIL);
    wool_atom_make(WOOL_Atom, WA_menu, "menu", NIL);
    wool_atom_make(WOOL_Atom, WA_tile, "tile", NIL);
    wool_atom_make(WOOL_Atom, WA_cursor, "cursor", NIL);
    wool_atom_make(WOOL_Atom, WA_property, "property", NIL);
    wool_atom_make(WOOL_Atom, WA_describe_window, "describe-window", NIL);
    wool_atom_make(WOOL_Atom, WA_describe_screen, "describe-screen", NIL);
    wool_atom_make(WOOL_Atom, WA_window_description, "window-description",
		   NIL);
    wool_atom_make(WOOL_Atom, WA_icon_description, "icon-description", NIL);
    wool_atom_make(WOOL_Atom, WA_grabs, "grabs", NIL);
    wool_atom_make(WOOL_Atom, WA_opening, "opening", NIL);
    wool_atom_make(WOOL_Atom, WA_closing, "closing", NIL);
    wool_atom_make(WOOL_Atom, WA_horizontal_margin, "horizontal-margin", NIL);
    wool_atom_make(WOOL_Atom, WA_vertical_margin, "vertical-margin", NIL);
    wool_atom_make(WOOL_Atom, WA_cursorNW, "cursor-NW", NIL);
    wool_atom_make(WOOL_Atom, WA_cursorNE, "cursor-NE", NIL);
    wool_atom_make(WOOL_Atom, WA_cursorN, "cursor-N", NIL);
    wool_atom_make(WOOL_Atom, WA_cursorSW, "cursor-SW", NIL);
    wool_atom_make(WOOL_Atom, WA_cursorSE, "cursor-SE", NIL);
    wool_atom_make(WOOL_Atom, WA_cursorS, "cursor-S", NIL);
    wool_atom_make(WOOL_Atom, WA_cursorE, "cursor-E", NIL);
    wool_atom_make(WOOL_Atom, WA_cursorW, "cursor-W", NIL);
    wool_atom_make(WOOL_Atom, WA_cursorW, "cursor-W", NIL);
    wool_atom_make(WOOL_Atom, WA_class_name, "class-name",
		   WLString_make("Gwm"));
    wool_atom_make(WOOL_Atom, WA_client_name, "client-name", 
		   WLString_make("menu"));
    wool_atom_make(WOOL_Atom, WA_icon_name, "icon-name", NIL);
    wool_atom_make(WOOL_Atom, WA_starts_iconic, "starts-iconic", NIL);
    wool_atom_make(WOOL_Atom, WA_map_on_raise, "map-on-raise", NIL);
    wool_atom_make(WOOL_Atom, WA_ignore_take_focus, "ignore-take-focus", NIL);

    wool_atom_with_numeric_value_make("horizontal", HORIZONTAL);
    wool_atom_with_numeric_value_make("vertical", VERTICAL);

    WA_iconify_window = wool_atom("iconify-window");
    WA_here = wool_atom("here");
    WA_bar = wool_atom("bar");
    WA_plug = wool_atom("plug");
    WA_root = wool_atom("root");
    WA_icon = wool_atom("icon");
    WA_mapped = wool_atom("mapped");
    WA_stacking_order = wool_atom("stacking-order");
    WA_mono = wool_atom("mono");
    WA_gray = wool_atom("gray");
    WA_color = wool_atom("color");
    WA_grab = wool_atom("grab");
    WA_ungrab = wool_atom("ungrab");
    WA_x = wool_atom("x");
    WA_y = wool_atom("y");
    WA_gravity = wool_atom("gravity");
    WA_borderwidth = wool_atom("borderwidth");

 					/* functional calls are lists of one
					   atom */

    wool_function_call_make(&WL_describe_window_call, WA_describe_window);
    wool_function_call_make(&WL_describe_screen_call, WA_describe_screen);
    wool_function_call_make(&WL_iconify_window_call, WA_iconify_window);

 					/* active values. Give WOOL name, get
					   C function, set C function (might
					   be NULL) */

    WA_window = (WOOL_Atom)
	wool_active_make("window",
			 wool_current_window, wool_set_current_window);
    wool_active_make("window-name", wool_current_window_name,
		     wool_current_window_name_set);
    wool_active_make("window-client-name",
		     wool_current_window_client_name, NULL);
    wool_active_make("window-client-class",
		     wool_current_window_client_class, NULL);
    wool_active_make("window-machine-name",
		     wool_current_window_machine_name, NULL);
    wool_active_make("window-icon-name",
		     wool_current_window_icon_name, 
		     wool_current_window_icon_name_set);
     wool_active_make("window-is-mapped",
		     wool_current_window_is_mapped, NULL);
    wool_active_make("window-x", wool_current_window_x, NULL);
    wool_active_make("window-y", wool_current_window_y, NULL);
    wool_active_make("wob-x", wool_wob_x_get, NULL);
    wool_active_make("wob-y", wool_wob_y_get, NULL);
    wool_active_make("window-width", wool_current_window_width, NULL);
    wool_active_make("window-height", wool_current_window_height, NULL);
    wool_active_make("window-client-x", wool_current_client_x, NULL);
    wool_active_make("window-client-y", wool_current_client_y, NULL);
    wool_active_make("window-client-width", wool_current_client_width, NULL);
    wool_active_make("window-client-height", wool_current_client_height,
		     NULL);
    wool_active_make("window-client-borderwidth", wool_current_client_borderwidth,
                     NULL);
    wool_active_make("window-icon-window", wool_current_window_icon_window,
		     NULL);
    wool_active_make("window-icon-pixmap", wool_current_window_icon_bitmap,
		     NULL);
    wool_active_make("window-icon-pixmap-id",
		     wool_current_window_icon_bitmap_id, NULL);
    wool_active_make("window-user-set-position",
		     wool_current_window_US_position, NULL);
    wool_active_make("window-user-set-size", wool_current_window_US_size,
		     NULL);
    wool_active_make("window-program-set-position",
		     wool_current_window_P_position, NULL);
    wool_active_make("window-program-set-size", wool_current_window_P_size,
		     NULL);
    wool_active_make("window-is-transient-for",
		     wool_current_window_is_transient_for, NULL);
    wool_active_make("wob", wool_current_wob, wool_current_wob_set);
    wool_active_make("wob-width", wool_current_wob_width, NULL);
    wool_active_make("wob-height", wool_current_wob_height, NULL);
    wool_active_make("wob-property", Wob_get_property, Wob_set_property);
    wool_active_make("wob-menu", Wob_get_menu, Wob_set_menu);
    wool_active_make("wob-fsm", Wob_get_fsm, Wob_set_fsm);
    wool_active_make("window-property", WLClient_get_property,
		     WLClient_set_property);
    wool_active_make("wob-status", wool_get_wob_status, NULL);
    wool_active_make("window-status", wool_get_window_status, NULL);
    wool_active_make("wob-parent", wool_get_wob_parent, NULL);
    wool_active_make("window-size", wool_window_logical_size_get,
		     wool_window_logical_size_set);
    wool_active_make("wob-tile", current_wob_get_bitmap,
		     current_wob_set_bitmap);
    wool_active_make("wob-pixmap", current_wob_get_bitmap,
		     current_wob_set_bitmap);
    wool_active_make("wob-borderpixel", current_wob_get_borderpixel,
		     current_wob_set_borderpixel);
    wool_active_make("wob-borderwidth", current_wob_get_borderwidth,
		     current_wob_set_borderwidth);
    wool_active_make("wob-background", current_wob_get_background,
		     current_wob_set_background);
    wool_active_make("window-was-on-screen",
		     GWM_ProcessingExistingWindows_get, NULL);
    wool_active_make("window-icon", wool_get_icon, NULL);
    wool_active_make("window-window", wool_get_window, NULL);
    wool_active_make("window-starts-iconic",
		     wool_window_map_as_icon_get,
		     wool_window_map_as_icon_set);
    wool_active_make("window-group", wool_window_group_get,
		     wool_window_group_set);
    wool_active_make("cut-buffer", wool_cut_buffer_0_get,
		     wool_cut_buffer_0_set);
    wool_active_make("wob-cursor", wool_wob_cursor_get, wool_wob_cursor_set);
    wool_active_make("window-wm-state-icon", wool_wm_state_user_icon_get,
		     wool_wm_state_user_icon_set);
    wool_active_make("screen", wool_current_screen_get,
    		     wool_current_screen_set);
    wool_active_make("screen-type", wool_get_visual_type, NULL);
    wool_active_make("root-window", wool_get_root_window,
    		     wool_set_root_window);

    /* Xevents */
    wool_all_events_make();

    /* Strings */
    increase_reference(DefaultClientClass = WLString_make("client"));
    increase_reference(DefaultClientName = WLString_make("name"));
    increase_reference(DefaultWindowName = WLString_make("window"));
    increase_reference(DefaultMachineName = WLString_make("machine"));
    increase_reference(DefaultIconName = WLString_make("icon"));
    increase_reference(wool_atom("display-name") -> c_val =
		       (WOOL_OBJECT) WLString_make(GWM_Display));

    /* fsms */
    NIL_FSM_make();

    /* type names of the wobs for consistency purposes */

    ClientWindowClass[0] = (WOB_METHOD) WA_window;
    BarClass[0] = (WOB_METHOD) WA_bar;
    MenuClass[0] = (WOB_METHOD) WA_menu;
    PlugClass[0] = (WOB_METHOD) WA_plug;
    ScreenClass[0] = (WOB_METHOD) WA_root;

    /* screen namespace */
    ContextNamespace_init();
    SetDefaultScreen();
}

/*
 * Keep in mind that SetUpdefault is called BEFORE wool is initialized
 * InitWool in wool_C.c initialize after wool...
 * argc, argv points AFTER the host:display arg
 */

int
SetUpDefaults()
{
    /* fonts */
    if (TrapXErrors(DefaultFont = (long) XLoadFont(dpy, DEFAULT_FONT))
	|| (!DefaultFont)) {
	wool_printf("GWM: Cannot find default font %s, aborting\n",
		    DEFAULT_FONT);
	GWM_end(1);
    }

    /* set up per-screen defaults */
    FOR_ALL_SCREENS {
	Context -> pixel.Fore = BlackPixel(dpy, Context -> screen);
	Context -> pixel.Back = WhitePixel(dpy, Context -> screen);
	Context -> pixel.GridColor =
	    (((unsigned long) 1) << Context -> depth) - 1;
	Context -> pixel.InvertColor = Context -> pixel.GridColor;
	Context -> pixel.Border = Context -> pixel.Fore;
	MeterCreate();
    }END_OF_ALL_SCREENS;

    /* X Atoms */
    XA_WM_STATE = XInternAtom(dpy, "WM_STATE", False);
    XA_WM_COLORMAP_WINDOWS = XInternAtom(dpy, "WM_COLORMAP_WINDOWS", False);
    XA_WM_CHANGE_STATE = XInternAtom(dpy, "WM_CHANGE_STATE", False);
    XA_WM_PROTOCOLS = XInternAtom(dpy, "WM_PROTOCOLS", False);
    XA_WM_TAKE_FOCUS = XInternAtom(dpy, "WM_TAKE_FOCUS", False);
    XA_WM_SAVE_YOURSELF = XInternAtom(dpy, "WM_SAVE_YOURSELF", False);
    XA_WM_DELETE_WINDOW = XInternAtom(dpy, "WM_DELETE_WINDOW", False);
    XA_GWM_EXECUTE = XInternAtom(dpy, "GWM_EXECUTE", False);
    XA_GWM_RUNNING = XInternAtom(dpy, "GWM_RUNNING", False);
}

/* initialize the switching name space of the screen */

WOOL_Namespace ContextNamespace;

void
ContextNamespace_trigger(i)
int i;
{
    wool_current_screen_set(WLNumber_make(i));
}

static Wob ContextNamespace_oldwob;

void
ContextNamespace_save_state()
{
    ContextNamespace_oldwob = TargetWob;
}

void
ContextNamespace_restore_state()
{
    SetTarget(ContextNamespace_oldwob);
}

ContextNamespace_init()
{
    int i;

    ContextNamespace = WLNamespace_make();
    ContextNamespace -> trigger = ContextNamespace_trigger;
    ContextNamespace -> save_state = ContextNamespace_save_state;
    ContextNamespace -> restore_state = ContextNamespace_restore_state;
    for (i=0; i < ScreenCount(dpy); i++)
	WLNamespace_add(ContextNamespace);
    wool_atom_make(WOOL_Atom, WA_ContextNamespace, "screen.",
		   ContextNamespace);
}