home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 22 gnu / 22-gnu.zip / gwm18a.zip / wool-gwm.c < prev    next >
C/C++ Source or Header  |  1995-07-03  |  55KB  |  1,798 lines
  1. /* Copyright 1989 GROUPE BULL -- See license conditions in file COPYRIGHT
  2.  * Copyright 1989 Massachusetts Institute of Technology
  3.  */
  4. /*************************************************************\
  5. *                                   *
  6. * GWM: Wool-gwm.c                          *
  7. *                                   *
  8. * WOOL/GWM interface.                          *
  9. *                                   *
  10. * Here are defined Wool objects referring to X objects          *
  11. * To add a function:                          *
  12. *        - declare it (coded in or extern)              *
  13. *        - add it to the declaration of predefined functions  *
  14. *          in the wool_init function                  *
  15. *                                   *
  16. \*************************************************************/
  17.  
  18. /*  include  */
  19.  
  20. #include <stdio.h>
  21. #include "EXTERN.h"
  22. #include "wool.h"
  23. #include "wl_number.h"
  24. #include "wl_atom.h"
  25. #include "wl_string.h"
  26. #include "wl_list.h"
  27. #include "wl_func.h"
  28. #include "wl_active.h"
  29. #include "wl_pointer.h"
  30. #include "gwm.h"
  31. #include "wl_event.h"
  32. #include "wl_fsm.h"
  33. #include "wl_label.h"
  34. #include "wl_pixmap.h"
  35. #include "wl_cursor.h"
  36. #include "wl_plug.h"
  37. #include "wl_bar.h"
  38. #include "wl_menu.h"
  39. #include "wl_client.h"
  40. #include "wl_coll.h"
  41. #include "wl_name.h"
  42. #include <X11/Xresource.h>
  43. #include "INTERN.h"
  44.  
  45. /*
  46.  * external:
  47.  * declare here all functions defined in GWM_init_wool_before_profile
  48.  */
  49.  
  50. extern WOOL_OBJECT
  51.     MapWindow(),
  52.     UnmapWindow(),
  53.     MoveWindow(),
  54.     MoveSeveralWindows(),
  55.     ResizeWindow(),
  56.     LowerWindow(),
  57.     RaiseWindow(),
  58.     IconifyWindow(),
  59.     KillWindow(),
  60.     ReDecorateWindow(),
  61.     CirculateWindowsDown(),
  62.     CirculateWindowsUp(),
  63.     PopMenu(),
  64.     PlaceFixedMenu(),
  65.     UnpopMenu(),
  66.     wool_set_focus(),
  67.     wool_current_wob(),
  68.     wool_current_wob_set(),
  69.     wool_current_wob_width(),
  70.     wool_current_wob_height(),
  71.     current_wob_set_bitmap(),
  72.     current_wob_set_borderpixel(),
  73.     current_wob_set_borderwidth(),
  74.     current_wob_set_background(),
  75.     current_wob_get_bitmap(),
  76.     current_wob_get_borderpixel(),
  77.     current_wob_get_borderwidth(),
  78.     current_wob_get_background(),
  79.     current_wob_invert_aera(),
  80.     wool_current_window(),
  81.     wool_set_current_window(),
  82.     wool_current_window_is_mapped(),
  83.     wool_current_window_name(),
  84.     wool_current_window_name_set(),
  85.     wool_current_window_client_name(),
  86.     wool_current_window_client_class(),
  87.     wool_current_window_machine_name(),
  88.     wool_current_window_icon_name(),
  89.     wool_current_window_x(),
  90.     wool_current_window_y(),
  91.     wool_current_window_width(),
  92.     wool_current_window_height(),
  93.     wool_current_client_x(),
  94.     wool_current_client_y(),
  95.     wool_current_client_width(),
  96.     wool_current_client_height(),
  97.     wool_current_client_borderwidth(),
  98.     wool_current_window_icon_window(),
  99.     wool_current_window_icon_bitmap(),
  100.     wool_current_window_icon_bitmap_id(),
  101.     wool_current_window_US_position(),
  102.     wool_current_window_US_size(),
  103.     wool_current_window_P_position(),
  104.     wool_current_window_P_size(),
  105.     wool_current_window_is_transient_for(),
  106.     Wob_set_property(),
  107.     Wob_get_property(),
  108.     wool_last_key_struck(),
  109.     wool_send_key_to_client(),
  110.     wool_send_keycode_to_client(),
  111.     wool_logical_coords(),
  112.     wool_process_exposes(),
  113.     wool_current_mouse_position(),
  114.     wool_meter_open(),
  115.     MeterClose(),
  116.     wool_meter_update(),
  117.     wool_window_logical_size_get(),
  118.     wool_window_logical_size_set(),
  119.     wool_window_map_as_icon_get(),
  120.     wool_window_map_as_icon_set(),
  121.     Wob_get_menu(),
  122.     Wob_set_menu(),
  123.     Wob_get_fsm(),
  124.     Wob_set_fsm(),
  125.     wool_last_user_event(),
  126.     wool_resend_event(),
  127.     wool_window_group_get(),
  128.     wool_window_group_set(),
  129.     wool_xpm_pixmap_make(),
  130.     wool_draw_line(),
  131.     wool_wob_cursor_get(),
  132.     wool_wob_cursor_set(),
  133.     wool_wm_state_user_icon_set(),
  134.     wool_wm_state_user_icon_get(),
  135.     wool_wm_state_update(),
  136.     wool_set_colormap_focus(),
  137.     wool_set_wm_icon_sizes(),
  138.     wool_set_subwindow_colormap_focus(),
  139.     wool_set_grabs(), wool_unset_grabs(),
  140.         wool_set_grab(), wool_remove_grab(),
  141.     wool_delete_window(),
  142.     wool_save_yourself(),
  143.     wool_meter_modify(),
  144.     wool_current_screen_get(),
  145.     wool_current_screen_set(),
  146.     wool_warp_pointer(),
  147.     wool_get_root_window(), wool_set_root_window(),
  148.     WLMenu_wob(),
  149.     wool_wm_state_get(),
  150.     wool_ungrab_and_replay_event(),
  151.     wool_wob_x_get(), wool_wob_y_get(),
  152.     wool_makes_replayable(),
  153.     wool_get_triggering_event_state(),
  154.     wool_get_triggering_event_code(),
  155.     wool_get_triggering_event_x(),
  156.     wool_get_triggering_event_y(),
  157.     wool_get_triggering_event_x_relative(),
  158.     wool_get_triggering_event_y_relative(),
  159.     wool_get_triggering_event_time(),
  160.     wool_get_triggering_event_data(),
  161.     wool_event_was_due_to_a_grab(),
  162.         wool_send_button_to_client(),
  163.         MakeResourceIdentifier(),
  164.         wool_allow_events(),
  165.         LookUpWobW(),
  166.         wool_draw_rectangle(),
  167.         wool_draw_text(),
  168.         wool_wob_is_valid(), wool_window_is_valid(),
  169.         Window2ClientW(), Client2WindowW(),
  170.     wool_get_wm_command();
  171. /*---*/
  172.  
  173. #ifdef SHAPE
  174. extern WOOL_OBJECT wool_window_has_shaped_client();
  175. #endif /* SHAPE */
  176.  
  177. extern XError(), NoXError();
  178. extern char * getenv();
  179. extern ClientWindow init_managed_windows(), get_next_managed_window();
  180. extern WOOL_OBJECT GetWobOfNumber();
  181.  
  182. /*  local defs  */
  183.  
  184. XrmDatabase WLRSC_database = NULL;
  185.  
  186. /*  global variables */
  187.  
  188. /*  routines  */
  189.  
  190. void            GWM_init_wool_before_profile();
  191.  
  192. /*
  193.  * Initialize Wool. Define subrs and global known from WOOL.
  194.  */
  195.  
  196. int
  197. InitWool()
  198. {
  199.     init_new_standard_wool_methods();
  200.     if (wool_init(GWM_init_wool_before_profile))
  201.     return FatalError;
  202.     /* put here the initialisations to be done AFTER user profile */
  203.     return OK;
  204. }
  205.  
  206. /* Sets new methods to standard Wool types
  207.  */
  208.  
  209. EXT WOOL_OBJECT WLString_get_dimensions();    /* see wl_label.c */
  210.  
  211. init_new_standard_wool_methods()
  212. {
  213.     WLString[WOOL_get_dimensions] = WLString_get_dimensions;
  214. }
  215.  
  216. /* refreshes the screen or window if specified
  217.  * very simple: creates/destroy a window just over the managed one
  218.  */
  219.  
  220. WOOL_OBJECT
  221. wool_refresh(argc, argv)
  222. int argc;
  223. WOOL_Number     argv[];
  224. {
  225.     XSetWindowAttributes wa;
  226.     Window          wd;
  227.     ClientWindow    cw;
  228.  
  229.     if (argc) {
  230.     must_be_number(argv[0], 0);
  231.     cw = (ClientWindow) argv[0] -> number;
  232.     }
  233.     wd = XCreateSimpleWindow(dpy, (argc ? cw -> hook : Context->root), 0, 0,
  234.                  (argc ? cw -> box.width : Context->width),
  235.                  (argc ? cw -> box.height : Context->height),
  236.                  0, Context -> pixel.Back, Context -> pixel.Back);
  237.     wa.override_redirect = 1;
  238.     XChangeWindowAttributes(dpy, wd, CWOverrideRedirect, &wa);
  239.     XMapWindow(dpy, wd);
  240.     XDestroyWindow(dpy, wd);
  241.     XFlush(dpy);
  242.     return NIL;
  243. }
  244.  
  245. /* gets the (default) visual type of screen
  246.  * returns an atom that can be of:
  247.  * mono, color or gray
  248.  */
  249.  
  250. WOOL_OBJECT
  251. wool_get_visual_type()
  252. {
  253.     switch (DefaultVisual(dpy, Context -> screen) -> class) {
  254.     case StaticGray:
  255.     case GrayScale:
  256.     if (Context -> depth > 1)
  257.         return (WOOL_OBJECT) WA_gray;
  258.     else
  259.         return (WOOL_OBJECT) WA_mono;
  260.     default:
  261.     return (WOOL_OBJECT) WA_color;
  262.     }
  263. }
  264.  
  265. /* sets the backgound of the screen in the current context.
  266.  * can be given a WOOL_Number (pixel) or WOOL_Pixmap (pixmap)
  267.  */
  268.  
  269. WOOL_OBJECT
  270. wool_set_screen_background(background)
  271. WOOL_Number     background;
  272. {
  273.     if (background -> type == WLNumber) {
  274.     XSetWindowBackground(dpy, Context->root,
  275.                  background -> number);
  276.     } else if (background -> type == WLPixmap) {
  277.     decrease_reference(((ClientWindow) Context->rootWob) -> tile);
  278.     increase_reference(((ClientWindow) Context->rootWob) -> tile =
  279.                (WOOL_OBJECT) background);
  280.     XSetWindowBackgroundPixmap(dpy, Context->root,
  281.                    ((WOOL_Pixmap) background) -> pixmap);
  282.     } else {
  283.     wool_puts("Not a background: ");
  284.     wool_print(background);
  285.     wool_newline();
  286.     }
  287.     XClearWindow(dpy, Context->root);
  288.     return NIL;
  289. }
  290.  
  291. WOOL_OBJECT
  292. wool_set_screen_saver(argc, argv)
  293. int argc;
  294. WOOL_Number    argv[];
  295. {
  296.     if (argc != 4)
  297.     wool_error(BAD_NUMBER_OF_ARGS, argc);
  298.     XSetScreenSaver(dpy, argv[0] -> number, argv[1] -> number,
  299.             argv[2] -> number, argv[3] -> number);
  300.     return NIL;
  301. }
  302.  
  303. WOOL_OBJECT
  304. wool_set_acceleration(num, den)
  305. WOOL_Number     num, den;
  306. {
  307.     XChangePointerControl(dpy, 1, 0, num -> number, den -> number, 0);
  308.     return NIL;
  309. }
  310.  
  311. WOOL_OBJECT
  312. wool_set_threshold(threshold)
  313. WOOL_Number     threshold;
  314. {
  315.     XChangePointerControl(dpy, 0, 1, 1, 1, threshold -> number);
  316.     return NIL;
  317. }
  318.  
  319. /* Keyboard bell ringer: (bell [volume percentage])
  320.  */
  321.  
  322. WOOL_OBJECT
  323. wool_keyboard_bell_ring(argc, argv)
  324. int argc;
  325. WOOL_Number argv[];
  326. {
  327.     int             percent = 0;
  328.  
  329.     if (argc) {
  330.     must_be_number(argv[0], 0);
  331.     percent = argv[0] -> number;
  332.     }
  333.     XBell(dpy, percent);
  334.     return NIL;
  335. }
  336.  
  337. /*
  338.  * change mapping by specifiyng
  339.  * keycode keysym keysym-with-mod1 keysym-with-mod2 ...
  340.  * WARNING:  XChangeKeyboardMapping MALLOCS! (do not re-change same keys!)
  341.  */
  342.  
  343. WOOL_OBJECT
  344. wool_change_keyboard_mapping(argc, argv)
  345. int argc;
  346. WOOL_Number argv[];
  347. {
  348.     KeySym         *keysyms = (KeySym *) Malloc((argc - 1) * sizeof(KeySym));
  349.     int             i;
  350.  
  351.     for (i = 0; i < argc - 1; i++) {
  352.     keysyms[i] = argv[i + 1] -> number;
  353.     }
  354.     XChangeKeyboardMapping(dpy, argv[0] -> number, argc - 1, keysyms, 1);
  355.     Free(keysyms);
  356.     return NIL;
  357. }
  358.  
  359. /*
  360.  * converts a key name to a keysym
  361.  */
  362.  
  363. WOOL_OBJECT
  364. wool_string_to_keysym(string)
  365. WOOL_String string;
  366. {
  367.     KeySym          keysym;
  368.  
  369.     must_be_string(string, 0);
  370.     return (WOOL_OBJECT)
  371.         WLNumber_make(XStringToKeysym(string -> string));
  372. }
  373.     
  374. /* translation beetween keysyms and keycodes
  375.  */
  376.  
  377. WOOL_OBJECT
  378. wool_keysym_to_keycode(key)
  379. WOOL_Number key;
  380. {
  381.     must_be_number(key, 0);
  382.     return (WOOL_OBJECT) WLNumber_make(XKeysymToKeycode(dpy, key->number));
  383. }
  384.  
  385. WOOL_OBJECT
  386. wool_keycode_to_keysym(key, index)
  387. WOOL_Number key, index;
  388. {
  389.     must_be_number(key, 0);
  390.     must_be_number(index, 1);
  391.     return (WOOL_OBJECT) WLNumber_make(XKeycodeToKeysym(
  392.                       dpy, key -> number, index -> number));
  393. }
  394.  
  395. /*
  396.  * Selection interface:
  397.  * Active values:
  398.  *     cut-buffer: access to cut-buffer 0 (for xterm use)
  399.  */
  400.  
  401. WOOL_OBJECT
  402. wool_cut_buffer_0_get()
  403. {
  404.     int             nbytes;
  405.     char           *buffer = XFetchBytes(dpy, &nbytes);
  406.     WOOL_String     string_of_buffer;
  407.  
  408.     if (buffer) {
  409.     string_of_buffer = WLString_make(buffer);
  410.     XFree(buffer);
  411.     return (WOOL_OBJECT) string_of_buffer;
  412.     } else {
  413.     return (WOOL_OBJECT) NIL_STRING;
  414.     }
  415. }
  416.  
  417. WOOL_OBJECT
  418. wool_cut_buffer_0_set(string)
  419. WOOL_String    string;
  420. {
  421.     XStoreBytes(dpy, string -> string, strlen(string -> string));
  422.     return (WOOL_OBJECT) string;
  423. }
  424.  
  425. /* buffer i becomes buffer i+incr %8 */
  426.  
  427. WOOL_OBJECT
  428. wool_rotate_cut_buffers(argc, argv)
  429. int argc;
  430. WOOL_Number argv[];
  431. {
  432.     int             incr = 1;
  433.  
  434.     if (argc) {
  435.     must_be_number(argv[0], 0);
  436.     incr = argv[0] -> number;
  437.     }
  438.     XRotateBuffers(dpy, incr);
  439.     return NIL;
  440. }
  441.  
  442. /*
  443.  * RESOURCE MANAGER INTERFACE
  444.  * (WLRSC)
  445.  * 
  446.  * (WLRSC_put description value)
  447.  * (WLRSC_get name class) --> value
  448.  * 
  449.  * types:
  450.  *     0    WOOL_OBJECT (auto-typed!)
  451.  * 
  452.  * KNOWN_BUG: if putting twice the same description,
  453.  *     previous value is not freed!
  454.  */
  455.  
  456. WOOL_OBJECT
  457. WLRSC_put(resource, value)
  458. WOOL_String     resource;
  459. WOOL_OBJECT    value;
  460. {
  461.     XrmValue xrm_value;
  462.  
  463.     must_be_string(resource, 0);
  464.     xrm_value.size = sizeof(WOOL_OBJECT);
  465.     increase_reference(value);
  466.     xrm_value.addr = (caddr_t) &value;
  467.     XrmPutResource(&WLRSC_database, resource -> string, 0, &xrm_value);
  468.     return value;
  469. }
  470.  
  471. WOOL_OBJECT
  472. WLRSC_get(name, class)
  473. WOOL_String     name, class;
  474. {
  475.     XrmValue        xrm_value;
  476.     char *        type;
  477.  
  478.     must_be_string(name, 0);
  479.     must_be_string(class, 1);
  480. #ifdef DEBUG
  481.     {
  482.     int numdn = 0, numdc = 0;
  483.     char *p;
  484.     for (p = name -> string; *p; p++)
  485.         if (*p == '.')
  486.         numdn++;
  487.     for (p = class -> string; *p; p++)
  488.         if (*p == '.')
  489.         numdc++;
  490.     if (numdn != numdc) {
  491.         char tmp[2000];
  492.         strcpy(tmp, name->string);
  493.         strcat(tmp, ", ");
  494.         strcat(tmp, class->string);
  495.         return wool_error("Bad resource fetch %s", tmp);
  496.     }
  497.     }
  498. #endif
  499.  
  500.     if (False ==
  501.     XrmGetResource(WLRSC_database, name -> string, class -> string,
  502.                &type, &xrm_value))
  503.     return NIL;
  504.     else
  505.     return (WOOL_OBJECT) *((WOOL_OBJECT *) (xrm_value.addr));
  506. }
  507.  
  508. /*
  509.  * get any property of current window
  510.  */
  511.  
  512. WOOL_OBJECT
  513. wool_get_window_property(name)
  514. WOOL_String name;
  515. {
  516.     Atom            actual_type;
  517.     Atom            property_name;
  518.     int             actual_format;
  519.     unsigned long   nitems;
  520.     unsigned long   bytes_after;
  521.     unsigned char  *buffer = 0;
  522.     WOOL_OBJECT     result = NIL;
  523.     WOOL_Pointer    x_atom;
  524.  
  525.     must_be_string(name, 0);
  526.     if (wool_self_pointer_make(name -> string, '\030', &x_atom)) {
  527.     property_name = *(x_atom -> ptr);
  528.     } else {
  529.     property_name = XInternAtom(dpy, name -> string, False);
  530.     *(x_atom -> ptr) = property_name;
  531.     }
  532.     if (TargetWindow -> client &&
  533.     Success == XGetWindowProperty(dpy, TargetWindow -> client,
  534.                    property_name, 0, 8000,
  535.                       GWM_delete_read_properties,
  536.        AnyPropertyType, &actual_type, &actual_format, &nitems, &bytes_after,
  537.                    &buffer)
  538.     && buffer && nitems) {
  539.     switch (actual_type) {
  540.     case XA_STRING:
  541.         result = (WOOL_OBJECT) WLString_make(buffer);
  542.         break;
  543.     case XA_INTEGER:
  544.         result = (WOOL_OBJECT) WLNumber_make(*((int *) buffer));
  545.         break;
  546.     }
  547.     XFree(buffer);
  548.     return result;
  549.     } else {
  550.     return NIL;
  551.     }
  552. }
  553.  
  554. WOOL_OBJECT
  555. wool_set_window_property(name, value)
  556. WOOL_String name;
  557. WOOL_String value;
  558. {
  559.     Atom            actual_type;
  560.     Atom            property_name;
  561.     int             actual_format;
  562.     unsigned long   nitems;
  563.     unsigned char  *buffer;
  564.     WOOL_Pointer    x_atom;
  565.     WOOL_TYPE       type;
  566.  
  567.     must_be_string(name, 0);
  568.     if (wool_self_pointer_make(name -> string, '\030', &x_atom)) {
  569.     property_name = *(x_atom -> ptr);
  570.     } else {
  571.     property_name = XInternAtom(dpy, name -> string, False);
  572.     *(x_atom -> ptr) = property_name;
  573.     }
  574.  
  575.     type = value -> type;
  576.     if (type == WLString || type == WLAtom || type == WLActive ||
  577.     type == WLPointer || type == WLName) {
  578.     actual_type = XA_STRING;
  579.     actual_format = 8;
  580.     if (type == WLString)
  581.         buffer = (unsigned char *) value -> string;
  582.     else
  583.         buffer = (unsigned char *) ((WOOL_Atom) value) -> p_name;
  584.     nitems = strlen(buffer) + 1;
  585.     } else if (type == WLNumber) {
  586.     actual_type = XA_INTEGER;
  587.     actual_format = 32;
  588.     buffer = (unsigned char *) &(((WOOL_Number) value) -> number);
  589.     nitems = 1;
  590.     } else {
  591.     bad_argument(value, 1, "string or number");
  592.     }
  593.  
  594.     if (TargetWindow -> client &&
  595.     Success == XChangeProperty(dpy, TargetWindow -> client,
  596.                    property_name, actual_type, actual_format,
  597.                    PropModeReplace, buffer, nitems))
  598.     return (WOOL_OBJECT) value;
  599.     else
  600.     return NIL;
  601. }
  602. WOOL_OBJECT
  603. wool_set_window_property_append(name, value)
  604. WOOL_String name;
  605. WOOL_String value;
  606. {
  607.     Atom            actual_type;
  608.     Atom            property_name;
  609.     int             actual_format;
  610.     unsigned long   nitems;
  611.     unsigned char  *buffer;
  612.     WOOL_Pointer    x_atom;
  613.     WOOL_TYPE       type;
  614.  
  615.     must_be_string(name, 0);
  616.     if (wool_self_pointer_make(name -> string, '\030', &x_atom)) {
  617.     property_name = *(x_atom -> ptr);
  618.     } else {
  619.     property_name = XInternAtom(dpy, name -> string, False);
  620.     *(x_atom -> ptr) = property_name;
  621.     }
  622.  
  623.     type = value -> type;
  624.     if (type == WLString || type == WLAtom || type == WLActive ||
  625.     type == WLPointer || type == WLName) {
  626.     actual_type = XA_STRING;
  627.     actual_format = 8;
  628.     if (type == WLString)
  629.         buffer = (unsigned char *) value -> string;
  630.     else
  631.         buffer = (unsigned char *) ((WOOL_Atom) value) -> p_name;
  632.     nitems = strlen(buffer) + 1;
  633.     } else if (type == WLNumber) {
  634.     actual_type = XA_INTEGER;
  635.     actual_format = 32;
  636.     buffer = (unsigned char *) &(((WOOL_Number) value) -> number);
  637.     nitems = 1;
  638.     } else {
  639.     bad_argument(value, 1, "string or number");
  640.     }
  641.  
  642.     if (TargetWindow -> client &&
  643.     Success == XChangeProperty(dpy, TargetWindow -> client,
  644.                    property_name, actual_type, actual_format,
  645.                    PropModeAppend, buffer, nitems))
  646.     return (WOOL_OBJECT) value;
  647.     else
  648.     return NIL;
  649. }
  650.  
  651. /* send  a client message event */
  652. WOOL_OBJECT
  653. wool_send_client_message(argc, argv)
  654.     int       argc;
  655.     WOOL_Number argv[];
  656. {
  657.     Atom      property_name;
  658.     unsigned long nitems;
  659.     unsigned char *buffer;
  660.     WOOL_Pointer x_atom;
  661.     WOOL_TYPE type;
  662.     int i;
  663.     XClientMessageEvent CliMessage;
  664.  
  665.     if (argc < 2)
  666.     wool_error(BAD_NUMBER_OF_ARGS, argc);
  667.     must_be_string(argv[0], 0);
  668.     if (wool_self_pointer_make(((WOOL_String)argv[0])->string, '\030', &x_atom)) {
  669.     property_name = *(x_atom->ptr);
  670.     }
  671.     else {
  672.     property_name = XInternAtom(dpy,((WOOL_String)argv[0])->string, False);
  673.     *(x_atom->ptr) = property_name;
  674.     }
  675.  
  676.     CliMessage.message_type = property_name;
  677.     CliMessage.window = TargetWindow->client;
  678.     CliMessage.type = ClientMessage;
  679.  
  680.     type = argv[1]->type;
  681.     if (type == WLString || type == WLAtom || type == WLActive ||
  682.     type == WLPointer || type == WLName) {
  683.     CliMessage.format = 8;
  684.     if (type == WLString)
  685.         buffer = (unsigned char *) ((WOOL_String)argv[1])->string;
  686.     else
  687.         buffer = (unsigned char *) ((WOOL_Atom) argv[1])->p_name;
  688.     nitems = strlen(buffer) + 1;
  689.     if (nitems > 20)
  690.         nitems = 20;
  691.     bcopy(buffer, CliMessage.data.b, nitems);
  692.  
  693.     }
  694.     else if ((type == WLNumber) && (argc < 6)) {
  695.     CliMessage.format = 32;
  696.     for (i = 1; i < argc; i++) {
  697.         CliMessage.data.l[i - 1] = (long) (((WOOL_Number) argv[i])->number);
  698.     }
  699.     }
  700.     else if ((type == WLNumber) && (argc < 11)) {
  701.     CliMessage.format = 16;
  702.     for (i = 1; i < argc; i++) {
  703.         CliMessage.data.s[i - 1] = (short) (((WOOL_Number) argv[i])->number);
  704.     }
  705.     }
  706.     else
  707.     return TRU;
  708.  
  709.  
  710.  
  711.     XSendEvent(dpy, TargetWindow->client, False, 0, (XEvent *) &CliMessage);
  712.     return NIL;
  713. }
  714.  
  715. /* executes GWM_EXECUTE string in current window
  716.  */
  717.  
  718. WlExecGWM_EXECUTE()
  719. {
  720.     WOOL_OBJECT wool_get_window_property();
  721.     static WOOL_String gwm_execute_string;
  722.     WOOL_OBJECT to_exec;
  723.     int OldGWM_delete_read_properties = GWM_delete_read_properties;
  724.     
  725.     if(!gwm_execute_string)
  726.     increase_reference(gwm_execute_string = WLString_make("GWM_EXECUTE"));
  727.     
  728.     GWM_delete_read_properties = True;
  729.     to_exec = wool_get_window_property(gwm_execute_string);
  730.     GWM_delete_read_properties = OldGWM_delete_read_properties;
  731.     wool_execute_wool_string(to_exec);
  732. }
  733.  
  734. /*
  735.  * interface to XGetDefault
  736.  */
  737.  
  738. WOOL_OBJECT
  739. wool_x_get_default(program, option)
  740. WOOL_String program;
  741. WOOL_String option;
  742. {
  743.     char           *result;
  744.  
  745.     must_be_string(program, 0);
  746.     must_be_string(option, 1);
  747.     result = XGetDefault(dpy, program -> string, option -> string);
  748.     if (result)
  749.     return (WOOL_OBJECT) WLString_make(result);
  750.     else
  751.     return NIL;
  752. }
  753.  
  754. /*
  755.  * Returns a color (pixel value) from an English name, or a #RGB description
  756.  */
  757.  
  758. WOOL_OBJECT
  759. wool_color_make(color)
  760. WOOL_String color;
  761. {
  762.     XColor          x_color;
  763.  
  764.     must_be_string(color, 0);
  765.     XSetErrorHandler(NoXError);
  766.     if (!XParseColor(dpy, DefaultColormap(dpy, Context -> screen),
  767.              color -> string, &x_color)) {
  768.     wool_printf("GWM: Color not found: %s\n", color -> string);
  769.     x_color.pixel = Context -> pixel.Back;
  770.     } else if (!XAllocColor(dpy, DefaultColormap(dpy, Context -> screen),
  771.              &x_color)) {
  772.     wool_printf("GWM: Colormap full, couldn't allocate Color: %s\n",
  773.             color -> string);
  774.     x_color.pixel = Context -> pixel.Back;
  775.     }
  776.     XSync(dpy, 0);
  777.     XSetErrorHandler(XError);
  778.     return (WOOL_OBJECT) WLNumber_make(x_color.pixel);
  779. }
  780.  
  781. WOOL_OBJECT
  782. wool_rgb_color_make(argc, argv)
  783. int argc;
  784. WOOL_Number argv[];
  785. {
  786.     XColor          x_color;
  787.  
  788.     if (argc != 3)
  789.     wool_error(BAD_NUMBER_OF_ARGS, argc);
  790.     must_be_number(argv[0], 0);
  791.     must_be_number(argv[1], 1);
  792.     must_be_number(argv[2], 2);
  793.  
  794.     x_color.red = argv[0] -> number;
  795.     x_color.green = argv[1] -> number;
  796.     x_color.blue = argv[2] -> number;
  797.  
  798.     XSetErrorHandler(NoXError);
  799.     if (!XAllocColor(dpy, DefaultColormap(dpy, Context -> screen), &x_color)) {
  800.     wool_printf("GWM: Color not found: #%04x%04x%04x\n",
  801.         argv[0] -> number, argv[1] -> number, argv[2] -> number);
  802.     x_color.pixel = Context -> pixel.Back;
  803.     }
  804.     XSync(dpy, 0);
  805.     XSetErrorHandler(XError);
  806.     return (WOOL_OBJECT) WLNumber_make(x_color.pixel);
  807. }
  808.  
  809. WOOL_OBJECT
  810. wool_color_free(argc, argv)
  811.     int argc;
  812.     WOOL_Number argv[];
  813. {
  814.     unsigned long *pixels = (unsigned long *) Malloc(argc * sizeof(int));
  815.     int i;
  816.  
  817.     for (i = 0; i < argc; i++) {
  818.     pixels[i] = argv[i] -> number;
  819.     }
  820.     XSetErrorHandler(NoXError);
  821.     XFreeColors(dpy, DefaultColormap(dpy, Context -> screen),
  822.         pixels, argc, 0);
  823.     XSync(dpy, 0);
  824.     XSetErrorHandler(XError);
  825.     return NIL;
  826. }
  827.  
  828. /* returns the RGB values of a color as a list of 3 integers between
  829.  * 0 and 65535
  830.  */
  831.  
  832. WOOL_OBJECT
  833. wool_color_components(color)
  834. WOOL_Number color;
  835. {
  836.     XColor          x_color;
  837.     WOOL_List       result;
  838.  
  839.     must_be_number(color, 0);
  840.     x_color.pixel = color->number;
  841.     XQueryColor(dpy, DefaultColormap(dpy, Context -> screen), &x_color);
  842.     result = wool_list_make(3);
  843.     increase_reference(result->list[0] =
  844.                (WOOL_OBJECT) WLNumber_make(x_color.red));
  845.     increase_reference(result->list[1] =
  846.                (WOOL_OBJECT) WLNumber_make(x_color.green));
  847.     increase_reference(result->list[2] =
  848.                (WOOL_OBJECT) WLNumber_make(x_color.blue));
  849.     return (WOOL_OBJECT) result;
  850. }
  851.  
  852.  
  853. /*
  854.  * loading a font (prefixed by ^F in hash table)
  855.  */
  856.  
  857. WOOL_OBJECT
  858. wool_font_make(string)
  859. WOOL_String     string;
  860. {
  861.     long            fontid;
  862.     WOOL_Pointer    font_pointer;
  863.  
  864.     if (wool_self_pointer_make(string -> string, '\006', &font_pointer)) {
  865.     fontid = *(font_pointer -> ptr);
  866.     } else {
  867.     if (TrapXErrors(fontid = (long) XLoadFont(dpy, string -> string))
  868.         || (!fontid)) {
  869.  
  870. /*
  871.  *     /*This should have used the server's default but seems broken... 
  872.  *         wool_printf("GWM: Cannot find Font %s , using server default\n",
  873.  *             string -> string);
  874.  *         fontid = XQueryFont(dpy,
  875.  *                   DefaultGC(dpy, Context->screen) -> gid) -> fid;
  876.  *     }
  877.  */
  878.  
  879.         wool_printf("GWM: Cannot find Font %s , using \"font\" default\n",
  880.             string -> string);
  881.         *(font_pointer -> ptr) = fontid = DefaultFont;
  882.     } else {
  883.         *(font_pointer -> ptr) = fontid;
  884.     }
  885.     }
  886.     return (WOOL_OBJECT) WLNumber_make(fontid);
  887. }
  888.  
  889.  
  890. /*
  891.  * send an user event to all sub-wobs of the window
  892.  */
  893.  
  894. WOOL_OBJECT
  895. wool_send_user_event(argc, argv)
  896. int argc;
  897. WOOL_Number argv[];
  898. {
  899.     ClientWindow cw, sender;
  900.     XAnyEvent evt;
  901.     int old_GWM_Propagate_user_events = GWM_Propagate_user_events;
  902.  
  903.     sender = TargetWindow;
  904.     if(argc >= 2){
  905.     cw = (ClientWindow) argv[1] -> number;
  906.     }else{
  907.     cw = sender;
  908.     }
  909.     if (argc == 3 && ((WOOL_OBJECT) argv[2]) != NIL)
  910.     GWM_Propagate_user_events = 0;
  911.     else
  912.     GWM_Propagate_user_events = 1;
  913.     if(!cw || argc == 0)
  914.     return NIL;
  915.     must_be_or_nil(WLAtom, argv[0], 0);
  916.     evt.type = GWMUserEvent;            /* our event */
  917.     evt.display = (Display *) argv[0];         /* the message */
  918.     evt.window = (Window) sender;        /* the sender */
  919.     {
  920.     SAVE_EVENT_CONTEXT;
  921.     WOOL_send(WOOL_process_event, cw, (cw, &evt)); 
  922.     RESTORE_EVENT_CONTEXT;
  923.     }
  924.     GWM_Propagate_user_events = old_GWM_Propagate_user_events;
  925.     return NIL;
  926. }
  927.  
  928. /* get the value of GWM_ProcessingExistingWindows */
  929.  
  930. WOOL_OBJECT
  931. GWM_ProcessingExistingWindows_get()
  932. {
  933.     if (GWM_ProcessingExistingWindows)
  934.     return TRU;
  935.     else
  936.     return NIL;
  937. }
  938.  
  939. /* returns the list of managed screens
  940.  */
  941.  
  942. WOOL_OBJECT
  943. wool_get_list_of_screens()
  944. {
  945.     WOOL_List       wl_list = wool_list_make(ScreenCount(dpy));
  946.     int             i = 0;
  947.  
  948.     FOR_ALL_SCREENS{
  949.     increase_reference(wl_list -> list[i++] =
  950.                (WOOL_OBJECT) WLNumber_make(Context -> screen));
  951.     }END_OF_ALL_SCREENS;
  952.     wl_list -> size = i;
  953.     return (WOOL_OBJECT) wl_list;
  954. }
  955.  
  956. /* returns the list of clientwindows or realized icons on screen,
  957.  * mapped or not
  958.  */
  959.  
  960. WOOL_OBJECT
  961. wool_get_list_of_windows(argc, argv)
  962. int    argc;
  963. WOOL_Atom argv[];
  964. {
  965.     int             i;
  966.     WOOL_List       wl_list;
  967.     ClientWindow    cw;
  968.     int             status = 0;        /* 'window or 'icon */
  969.     int             mapped = 0;        /* 'mapped for only visible ones */
  970.     int             stacking_order = 0;    /* do a XQueryTree to get the list */
  971.     unsigned int    nb_windows = Context -> WindowCount;
  972.     Window         *windows, dummywin, parent;
  973.  
  974.     for (i = 0; i < argc; i++)        /* options parsing */
  975.     if (argv[i] == WA_window)
  976.         status = ClientWindowStatus;
  977.     else if (argv[i] == WA_icon)
  978.         status = IconStatus;
  979.     else if (argv[i] == WA_mapped)
  980.         mapped = 1;
  981.     else if (argv[i] == WA_stacking_order)
  982.         stacking_order = 1;
  983.  
  984.     if (stacking_order) {
  985.     XQueryTree(dpy, Context->root, &dummywin, &parent,
  986.            &windows, &nb_windows);
  987.     }
  988.     if (nb_windows) {
  989.     wl_list = wool_list_make(nb_windows);
  990.     if (stacking_order)
  991.         cw = init_managed_windows(windows, nb_windows); /* will free */
  992.     else
  993.         cw = Context->rootWob -> next;
  994.     i = 0;
  995.     while (cw) {
  996.         if (((!status) || cw -> status & status)
  997.         && ((!mapped) || cw -> mapped))
  998.         increase_reference(wl_list -> list[i++] =
  999.                    (WOOL_OBJECT) WLNumber_make(cw));
  1000.         if (stacking_order)
  1001.         cw = get_next_managed_window();
  1002.         else
  1003.         cw = cw -> next;
  1004.     }
  1005.     wl_list -> size = i;
  1006.     if (i) {
  1007.         return (WOOL_OBJECT) wl_list;
  1008.     }
  1009.     }
  1010.     return NIL;
  1011. }
  1012.  
  1013. static Window *managed_window_list;
  1014. static Window *old_managed_window_list;    /* to be freed */
  1015. static int     managed_window_size;
  1016.  
  1017. ClientWindow
  1018. init_managed_windows(window_list, window_size)
  1019. Window *window_list;
  1020. int     window_size;
  1021. {
  1022.     ClientWindow    cw = 0;
  1023.  
  1024.     XFreeN(old_managed_window_list);
  1025.     old_managed_window_list = window_list;
  1026.     while (window_size > 0
  1027.        && (!(cw = (ClientWindow) LookUpWob(*window_list))
  1028.            || cw -> type != ClientWindowClass)) {
  1029.     window_list++;
  1030.     window_size--;
  1031.     }
  1032.     managed_window_list = window_list;
  1033.     managed_window_size = window_size;
  1034.     return (window_size ? cw : 0);
  1035. }
  1036.  
  1037. ClientWindow
  1038. get_next_managed_window()
  1039. {
  1040.     ClientWindow    cw = 0;
  1041.  
  1042.     do {
  1043.     managed_window_list++;
  1044.     managed_window_size--;
  1045.     } while (managed_window_size > 0 &&
  1046.          (!(cw = (ClientWindow) LookUpWob(*managed_window_list))
  1047.           || cw -> type != ClientWindowClass));
  1048.     return (managed_window_size ? cw : 0);
  1049. }
  1050.  
  1051. /*
  1052.  * get the type of the wob (status)
  1053.  */
  1054.  
  1055. WOOL_OBJECT
  1056. wool_wob_status(wob)
  1057. Wob    wob;
  1058. {
  1059.     if (wob -> type[0] == (WOB_METHOD) WA_window
  1060.     && (wob -> status & IconStatus))
  1061.     return (WOOL_OBJECT) WA_icon;
  1062.     else
  1063.     return (WOOL_OBJECT) wob -> type[0];
  1064. }
  1065.  
  1066. WOOL_OBJECT
  1067. wool_get_window_status()
  1068. {
  1069.     return wool_wob_status(TargetWindow);
  1070. }
  1071.  
  1072. WOOL_OBJECT
  1073. wool_get_wob_status()
  1074. {
  1075.     return wool_wob_status(TargetWob);
  1076. }
  1077.  
  1078. WOOL_OBJECT
  1079. wool_get_wob_of_position(x, y)
  1080. WOOL_Number x,y;
  1081. {
  1082.     int             xr, yr;
  1083.     Window          window;
  1084.     Wob             wob;
  1085.  
  1086.     if (XTranslateCoordinates(dpy, Context->root, Context->root,
  1087.                   x -> number, y -> number, &xr, &yr, &window)) {
  1088.     if ((wob = (Wob) LookUpWob(window))
  1089.         || (wob = (Wob) LookUpClient(window)))
  1090.         return (WOOL_OBJECT) WLNumber_make(wob);
  1091.     }
  1092.     return NIL;
  1093. }
  1094.  
  1095. /*
  1096.  * get the associated window:
  1097.  *     clientwindow => icon
  1098.  *     icon => clientwindow
  1099.  *     menu => parent
  1100.  *     wob => parent
  1101.  */
  1102.  
  1103. WOOL_OBJECT
  1104. wool_get_wob_parent()
  1105. {
  1106.     if (TargetWob -> parent)
  1107.     return (WOOL_OBJECT) WLNumber_make(TargetWob -> parent);
  1108.     else
  1109.     return NIL;
  1110. }
  1111.  
  1112. WOOL_OBJECT
  1113. wool_get_icon()
  1114. {
  1115.     Wob             target = TargetWob;
  1116.  
  1117.     if (!(TargetWindow -> icon)) {
  1118.     RealizeIconWindow(TargetWindow);
  1119.     SetTarget(target);
  1120.     }
  1121.     return (WOOL_OBJECT) WLNumber_make(TargetWindow -> icon);
  1122. }
  1123.  
  1124. WOOL_OBJECT
  1125. wool_icon_exists(argc, argv)
  1126. int argc;
  1127. WOOL_Number argv[];
  1128. {
  1129.     ClientWindow    cw;
  1130.  
  1131.     if (argc) {
  1132.     must_be_number(argv[0], 0);
  1133.     cw = (ClientWindow) argv[0] -> number;
  1134.     } else {
  1135.     cw = TargetWindow;
  1136.     }
  1137.     if (cw->icon) {
  1138.     return TRU;
  1139.     } else {
  1140.     return NIL;
  1141.     }
  1142. }
  1143.  
  1144. WOOL_OBJECT
  1145. wool_get_window()
  1146. {
  1147.     return (WOOL_OBJECT) WLNumber_make(TargetWindow -> window);
  1148. }
  1149.  
  1150. /*
  1151.  * width & height of any object
  1152.  */
  1153.  
  1154. WOOL_OBJECT
  1155. wool_width(object)
  1156. WOOL_OBJECT    object;
  1157. {
  1158.     struct _Box     box;
  1159.  
  1160.     object = GetWobOfNumber(object);
  1161.     WOOL_send(WOOL_get_dimensions, object, (object, &box));
  1162.     return (WOOL_OBJECT) WLNumber_make(box.width);
  1163. }
  1164.  
  1165. WOOL_OBJECT
  1166. wool_height(object)
  1167. WOOL_OBJECT    object;
  1168. {
  1169.     struct _Box     box;
  1170.  
  1171.     object = GetWobOfNumber(object);
  1172.     WOOL_send(WOOL_get_dimensions, object, (object, &box));
  1173.     return (WOOL_OBJECT) WLNumber_make(box.height);
  1174. }
  1175.  
  1176. WOOL_OBJECT
  1177. wool_dimensions(object)
  1178. WOOL_OBJECT     object;
  1179. {
  1180.     struct _Box     box;
  1181.     WOOL_Number        tab[4];
  1182.  
  1183.     object = GetWobOfNumber(object);
  1184.     WOOL_send(WOOL_get_dimensions, object, (object, &box));
  1185.     tab[0] = WLNumber_make(box.x);
  1186.     tab[1] = WLNumber_make(box.y);
  1187.     tab[2] = WLNumber_make(box.width);
  1188.     tab[3] = WLNumber_make(box.height);
  1189.     return (WOOL_OBJECT) wool_list_make_from_evaluated_array(4, tab);    
  1190. }
  1191.  
  1192. #ifdef DEBUG
  1193. /* debugging-only functions:
  1194.  */
  1195.  
  1196. char *
  1197. atom_name(atom)                /* get name (string) of X atom */
  1198. Atom    atom;
  1199. {
  1200.     if (atom)
  1201.     return XGetAtomName(dpy, atom);
  1202.     else
  1203.     return NULL;
  1204. }
  1205. #endif /* DEBUG */
  1206.  
  1207. /* handler called by wool before execing a son after a fork
  1208.  */
  1209.  
  1210. wool_clean_before_exec()
  1211. {
  1212.     close(XConnectionNumber(dpy));
  1213. }
  1214.  
  1215. /*
  1216.  * restarts GWM the hard way
  1217.  */
  1218.  
  1219. WOOL_OBJECT
  1220. GWM_restart(argc, argv)
  1221. int     argc;
  1222. WOOL_String argv[];
  1223. {
  1224.     extern int      GWM_argc;
  1225.     extern char   **GWM_argv;
  1226.  
  1227.     if (argc) {                /* pass args */
  1228.     char          **new_argv = (char **)
  1229.     Malloc(sizeof(char *) * (argc + 1));
  1230.     int             i;
  1231.  
  1232.     for (i = 0; i < argc; i++) {
  1233.         must_be_string(argv[i], i);
  1234.         new_argv[i] = argv[i] -> string;
  1235.     }
  1236.     new_argv[argc] = 0;
  1237.     GWM_is_restarting = new_argv;
  1238.     } else {                /* same args */
  1239.     GWM_is_restarting = GWM_argv;
  1240.     }
  1241.     XSetInputFocus(dpy, PointerRoot, RevertToPointerRoot, CurrentTime);
  1242.     XSync(dpy, True);
  1243.     FOR_ALL_SCREENS {
  1244.     if (Context -> rootWob) {
  1245.         SetTarget(Context -> rootWob);
  1246.         ScreenClose(Context -> rootWob);
  1247.     }
  1248.     }END_OF_ALL_SCREENS;
  1249.     XCloseDisplay(dpy);
  1250.     execvp(GWM_is_restarting[0], GWM_is_restarting);
  1251.     return wool_error("could not restart %s", GWM_is_restarting[0]);
  1252. }
  1253.  
  1254. /* this function allows a kind of multitasking in wool:
  1255.  * It recusrivly processes pending events in the queue and returns as soon as
  1256.  * the queue is empty
  1257.  * Can be used during long tedious tasks so as not to "freeze" gwm
  1258.  * with arg <> (), do a Sync before
  1259.  */
  1260.  
  1261. WOOL_OBJECT
  1262. wool_process_events(argc, argv)
  1263. int         argc;
  1264. WOOL_OBJECT argv[];
  1265. {
  1266.     SAVE_EVENT_CONTEXT;
  1267.     if (argc && argv[0] != NIL)
  1268.     XSync(dpy, 0);
  1269.     GWM_ProcessEvents(0);
  1270.     RESTORE_EVENT_CONTEXT;
  1271.     return NIL;
  1272. }
  1273.  
  1274. /* to make a function call of an atom */
  1275.  
  1276. wool_function_call_make(list, atom)
  1277. WOOL_List *list;
  1278. WOOL_Atom atom;
  1279. {
  1280.     *list = wool_list_make(1);
  1281.     increase_reference((*list) -> list[0] = (WOOL_OBJECT) atom);
  1282.     increase_reference(*list);
  1283. }
  1284.  
  1285. /* Here goes the initialisations to be done AFTER wool is brought up, but
  1286.  * BEFORE the user's profile is read
  1287.  * 
  1288.  * You will bind all your C functions to WOOL atoms here
  1289.  */
  1290.  
  1291. void
  1292. GWM_init_wool_before_profile()
  1293. {
  1294.     /* Types of Wool Objects, This the ONLY list of all objects 
  1295.      * see also declarations of wobs at the end of the function
  1296.      */
  1297.  
  1298.     WLActive[0] = (WOOL_METHOD) wool_atom("active");
  1299.     WLAtom[0] = (WOOL_METHOD) wool_atom("atom");
  1300.     WLBar[0] = (WOOL_METHOD) wool_atom("bar");
  1301.     WLClient[0] = (WOOL_METHOD) wool_atom("client");
  1302.     WLCollection[0] = (WOOL_METHOD) wool_atom("collection");
  1303.     WLQuotedExpr[0] = (WOOL_METHOD) wool_atom("quoted-expr");
  1304.     WLCursor[0] = (WOOL_METHOD) wool_atom("cursor");
  1305.     WLEvent[0] = (WOOL_METHOD) wool_atom("event");
  1306.     WLFsm[0] = (WOOL_METHOD) wool_atom("fsm");
  1307.     WLFsmState[0] = (WOOL_METHOD) wool_atom("fsm-state");
  1308.     WLStateArc[0] = (WOOL_METHOD) wool_atom("state-arc");
  1309.     WLSubr[0] = (WOOL_METHOD) wool_atom("subr");
  1310.     WLFSubr[0] = (WOOL_METHOD) wool_atom("fsubr");
  1311.     WLExpr[0] = (WOOL_METHOD) wool_atom("expr");
  1312.     WLFExpr[0] = (WOOL_METHOD) wool_atom("fexpr");
  1313.     WLLabel[0] = (WOOL_METHOD) wool_atom("label");
  1314.     WLList[0] = (WOOL_METHOD) wool_atom("list");
  1315.     WLMenu[0] = (WOOL_METHOD) wool_atom("menu");
  1316.     WLName[0] = (WOOL_METHOD) wool_atom("name");
  1317.     WLNamespace[0] = (WOOL_METHOD) wool_atom("namespace");
  1318.     WLNumber[0] = (WOOL_METHOD) wool_atom("number");
  1319.     WLPixmap[0] = (WOOL_METHOD) wool_atom("pixmap");
  1320.     WLPlug[0] = (WOOL_METHOD) wool_atom("plug");
  1321.     WLPointer[0] = (WOOL_METHOD) wool_atom("pointer");
  1322.     WLString[0] = (WOOL_METHOD) wool_atom("string");
  1323.  
  1324.                         /*  wool functions: declare them with
  1325.                        type, C name, WOOL name, number of
  1326.                        arguments (0,1,2,NARY) */
  1327.  
  1328.     wool_subr_make(WLSubr, wool_client_make, "window-make", NARY);
  1329.     wool_subr_make(WLSubr, wool_plug_make, "plug-make", 1);
  1330.     wool_subr_make(WLSubr, wool_bar_make, "bar-make", NARY);
  1331.     wool_subr_make(WLSubr, wool_fsm_make, "fsm-make", NARY);
  1332.     wool_subr_make(WLSubr, wool_fsm_state_make, "state-make", NARY);
  1333.     wool_subr_make(WLFSubr, wool_state_arc_make, "on", NARY);
  1334.     wool_subr_make(WLSubr, wool_state_arc_make, "on-eval", NARY);
  1335.     increase_reference(wool_atom("pixmap-make") -> c_val =
  1336.      wool_subr_make(WLSubr, wool_layered_bitmap_make, "layered-bitmap-make",
  1337.             NARY));
  1338.     wool_subr_make(WLSubr, wool_label_make, "active-label-make", NARY);
  1339.     wool_subr_make(WLSubr, wool_cursor_make, "cursor-make", NARY);
  1340.     wool_subr_make(WLSubr, wool_menu_make, "menu-make", NARY);
  1341.     wool_subr_make(WLSubr, wool_font_make, "font-make", 1);
  1342.     wool_subr_make(WLSubr, wool_color_make, "color-make", 1);
  1343.     wool_subr_make(WLSubr, wool_rgb_color_make, "color-make-rgb", NARY);
  1344.     wool_subr_make(WLSubr, wool_color_free, "color-free", NARY);
  1345.     wool_subr_make(WLSubr, wool_color_components, "color-components", 1);
  1346.     wool_subr_make(WLSubr, wool_stamp_make, "label-make", NARY);
  1347.     wool_subr_make(WLSubr, wool_string_to_keysym, "key-make", 1);
  1348.     wool_subr_make(WLSubr, wool_set_acceleration, "set-acceleration", 2);
  1349.     wool_subr_make(WLSubr, wool_set_threshold, "set-threshold", 1);
  1350.     wool_subr_make(WLSubr,
  1351.            wool_change_keyboard_mapping, "set-key-binding", NARY);
  1352.     wool_subr_make(WLSubr, wool_refresh, "refresh", NARY);
  1353.     wool_subr_make(WLSubr, wool_set_screen_saver, "set-screen-saver", NARY);
  1354.     wool_subr_make(WLSubr, PlaceFixedMenu, "place-menu", NARY);
  1355.     wool_subr_make(WLSubr, wool_meter_open, "meter-open", NARY);
  1356.     wool_subr_make(WLSubr, wool_meter_update, "meter-update", 1);
  1357.     wool_subr_make(WLSubr, MeterClose, "meter-close", 0);
  1358.     wool_subr_make(WLSubr, WLRSC_put, "resource-put", 2);
  1359.     wool_subr_make(WLSubr, WLRSC_get, "resource-get", 2);
  1360.     wool_subr_make(WLSubr, wool_x_get_default, "get-x-default", 2);
  1361.     wool_subr_make(WLFSubr, CirculateWindowsDown,
  1362.            "circulate-windows-down", 0);
  1363.     wool_subr_make(WLFSubr, CirculateWindowsUp, "circulate-windows-up", 0);
  1364.     wool_subr_make(WLSubr, ReDecorateWindow, "re-decorate-window", NARY);
  1365.     wool_subr_make(WLSubr, KillWindow, "kill-window", NARY);
  1366.     wool_subr_make(WLSubr, MoveWindow, "move-window", NARY);
  1367.     wool_subr_make(WLSubr, MoveSeveralWindows, "move-several-windows", NARY);
  1368.     wool_subr_make(WLSubr, ResizeWindow, "resize-window", NARY);
  1369.     wool_subr_make(WLSubr, RaiseWindow, "raise-window", NARY);
  1370.     wool_subr_make(WLSubr, LowerWindow, "lower-window", NARY);
  1371.     wool_subr_make(WLSubr, IconifyWindow, "iconify-window", 0);
  1372.     wool_subr_make(WLSubr, wool_set_focus, "set-focus", NARY);
  1373.     wool_subr_make(WLSubr, wool_send_user_event, "send-user-event", NARY);
  1374.     wool_subr_make(WLSubr, wool_get_triggering_event_state,
  1375.            "current-event-modifier", 0);
  1376.     wool_subr_make(WLSubr, wool_get_triggering_event_code,
  1377.            "current-event-code", 0);
  1378.     wool_subr_make(WLSubr, wool_get_triggering_event_x,
  1379.            "current-event-x", 0);
  1380.     wool_subr_make(WLSubr, wool_get_triggering_event_y,
  1381.            "current-event-y", 0);
  1382.     wool_subr_make(WLSubr, wool_get_triggering_event_time,
  1383.            "current-event-time", 0);
  1384.     wool_subr_make(WLSubr, wool_get_triggering_event_data,
  1385.            "current-event-data", 0);
  1386.     wool_subr_make(WLSubr, PopMenu, "pop-menu", NARY);
  1387.     wool_subr_make(WLSubr, UnpopMenu, "unpop-menu", NARY);
  1388.     wool_subr_make(WLSubr, wool_set_grab, "grab-server", NARY);
  1389.     wool_subr_make(WLSubr, wool_remove_grab, "ungrab-server", NARY);
  1390.     wool_subr_make(WLSubr, MapWindow, "map-window", NARY);
  1391.     wool_subr_make(WLSubr, UnmapWindow, "unmap-window", NARY);
  1392.     wool_subr_make(WLFSubr, wool_last_key_struck, "last-key", 0);
  1393.     wool_subr_make(WLSubr, wool_get_list_of_windows, "list-of-windows", NARY);
  1394.     wool_subr_make(WLSubr, wool_get_list_of_screens, "list-of-screens", NARY);
  1395.     wool_subr_make(WLFSubr, wool_logical_coords,
  1396.            "current-event-window-coords", 0);
  1397.     wool_subr_make(WLSubr, wool_send_key_to_client, "send-key-to-window", 2);
  1398.     wool_subr_make(WLSubr, wool_send_keycode_to_client,
  1399.            "send-keycode-to-window", 2);
  1400.     wool_subr_make(WLSubr, wool_send_button_to_client,
  1401.            "send-button-to-window", NARY);
  1402.     wool_subr_make(WLFSubr, wool_process_exposes, "process-exposes", 0);
  1403.     wool_subr_make(WLFSubr, wool_current_mouse_position,
  1404.            "current-mouse-position", 0);
  1405.     wool_subr_make(WLFSubr, current_wob_invert_aera, "wob-invert", 0);
  1406.     wool_subr_make(WLSubr, wool_get_window_property, "get-x-property", 1);
  1407.     wool_subr_make(WLSubr, wool_set_window_property, "set-x-property", 2);
  1408.     wool_subr_make(WLSubr, wool_set_window_property_append, 
  1409.            "set-x-property-append", 2);
  1410.     wool_subr_make(WLSubr, wool_send_client_message, "send-client-message",
  1411.            NARY);
  1412.     wool_subr_make(WLSubr, wool_get_wob_of_position, "wob-at-coords", 2);
  1413.     wool_subr_make(WLFSubr, wool_last_user_event, "current-user-event", 0);
  1414.     wool_subr_make(WLSubr, wool_resend_event, "send-current-event", 1);
  1415.     wool_subr_make(WLSubr, wool_xpm_pixmap_make, "paxmap-make", NARY);
  1416.     wool_subr_make(WLSubr, wool_xpm_pixmap_make, "pixmap-load", NARY);
  1417.     wool_subr_make(WLSubr, wool_rotate_cut_buffers,
  1418.                "rotate-cut-buffers", NARY);
  1419.     wool_subr_make(WLSubr, wool_draw_line, "draw-line", NARY);
  1420.     wool_subr_make(WLSubr, wool_draw_rectangle, "draw-rectangle", NARY);
  1421.     wool_subr_make(WLSubr, wool_draw_text, "draw-text", NARY);
  1422.     wool_subr_make(WLSubr, wool_keyboard_bell_ring, "bell", NARY);
  1423.     wool_subr_make(WLSubr, wool_wm_state_update, "window-wm-state-update", NARY);
  1424.     wool_subr_make(WLSubr, wool_set_colormap_focus,
  1425.                "set-colormap-focus", NARY);
  1426.     wool_subr_make(WLSubr, wool_set_wm_icon_sizes, "set-icon-sizes", NARY);
  1427.     wool_subr_make(WLSubr, wool_set_subwindow_colormap_focus,
  1428.                "set-subwindow-colormap-focus", NARY);
  1429.     wool_subr_make(WLSubr, wool_set_grabs, "set-grabs", NARY);
  1430.     wool_subr_make(WLSubr, wool_unset_grabs, "unset-grabs", NARY);
  1431.     wool_subr_make(WLSubr, wool_width, "width", 1);
  1432.     wool_subr_make(WLSubr, wool_height, "height", 1);
  1433.     wool_subr_make(WLSubr, wool_dimensions, "dimensions", 1);
  1434.     wool_subr_make(WLSubr, GWM_restart, "restart", NARY);
  1435.     wool_subr_make(WLSubr, wool_process_events, "process-events", NARY);
  1436.     wool_subr_make(WLSubr, wool_delete_window, "delete-window", NARY);
  1437.     wool_subr_make(WLSubr, wool_save_yourself, "save-yourself", NARY);
  1438.     wool_subr_make(WLSubr, wool_keycode_to_keysym, "keycode-to-keysym", 2);
  1439.     wool_subr_make(WLSubr, wool_keysym_to_keycode, "keysym-to-keycode", 1);
  1440.     wool_subr_make(WLSubr, wool_list_make_from_wool, "list-make", NARY);
  1441.     wool_subr_make(WLSubr, wool_meter_modify, "meter", NARY);
  1442.     wool_subr_make(WLSubr, wool_warp_pointer, "warp-pointer", NARY);
  1443.     wool_subr_make(WLSubr, WLMenu_wob, "menu-wob", 1);
  1444.     wool_subr_make(WLSubr, wool_wm_state_get, "window-wm-state", NARY);
  1445.     wool_subr_make(WLSubr, wool_get_triggering_event_x_relative,
  1446.         "current-event-relative-x", 0);
  1447.     wool_subr_make(WLSubr, wool_get_triggering_event_y_relative,
  1448.         "current-event-relative-y", 0);
  1449.     wool_subr_make(WLSubr, wool_ungrab_and_replay_event,
  1450.     "ungrab-server-and-replay-event", 1);
  1451.     wool_subr_make(WLSubr, wool_makes_replayable, "replayable-event", 1);
  1452.     wool_subr_make(WLSubr, wool_event_was_due_to_a_grab,
  1453.         "current-event-from-grab", 0);
  1454.     wool_subr_make(WLSubr, wool_get_wm_command, "get-wm-command", 0);
  1455.     wool_subr_make(WLSubr, MakeResourceIdentifier, "make-string-usable-for-resource-key", 1);
  1456.     wool_subr_make(WLSubr, wool_allow_events, "allow-event-processing", 0);
  1457.     wool_subr_make(WLSubr, LookUpWobW, "xid-to-wob", 1);
  1458.     wool_subr_make(WLSubr, Window2ClientW, "window-to-client", 1);
  1459.     wool_subr_make(WLSubr, Client2WindowW, "client-to-window", 1);
  1460.     wool_subr_make(WLSubr, wool_window_is_valid, "window-is-valid", 1);
  1461.     wool_subr_make(WLSubr, wool_wob_is_valid, "wob-is-valid", 1);
  1462.     wool_subr_make(WLSubr, wool_icon_exists, "window-icon?", NARY);
  1463.  
  1464.                     /* --- */
  1465. #ifdef SHAPE
  1466.     wool_subr_make(WLSubr, wool_window_has_shaped_client,
  1467.         "window-is-shaped", 0);
  1468. #else /* SHAPE */
  1469.     wool_subr_make(WLSubr, NIL_FUNC, "window-is-shaped", 0);
  1470. #endif /* SHAPE */
  1471.  
  1472.                      /* pointers to ints: declare them
  1473.                        with WOOL name, pointer to memory
  1474.                        location */
  1475.  
  1476.     wool_pointer_make("borderwidth", &DefaultBorderWidth);
  1477.     wool_pointer_make("inner-borderwidth", &DefaultInnerBorderwidth);
  1478.     wool_pointer_make("move-grid-style", &GWM_Movegrid);
  1479.     wool_pointer_make("resize-grid-style", &GWM_Resizegrid);
  1480.     wool_pointer_make("resize-style", &GWM_resize_style);
  1481.     wool_pointer_make("mwm-resize-style-corner-size",
  1482.               &GWM_window_cutting_size);
  1483.     wool_pointer_make("mwm-resize-style-catch-corners",
  1484.               &GWM_Mwm_catch_corners);
  1485.     wool_pointer_make("move-meter", &GWM_Move_meter);
  1486.     wool_pointer_make("resize-meter", &GWM_Resize_meter);
  1487.     wool_pointer_make("label-horizontal-margin",
  1488.               &DefaultLabelHorizontalMargin);
  1489.     wool_pointer_make("label-vertical-margin",
  1490.               &DefaultLabelVerticalMargin);
  1491.     wool_pointer_make("plug-separator", &DefaultPlugSeparator);
  1492.     wool_pointer_make("bar-separator", &DefaultBarSeparator);
  1493.     wool_pointer_make("invert-cursors", &GWM_InvertCursors);
  1494.     WA_font = (WOOL_Atom) wool_pointer_make("font", &DefaultFont);
  1495.     wool_pointer_make("freeze-server", &GWM_GrabServer);
  1496.     wool_pointer_make("double-click-delay", &GWM_DoubleClickDelay);
  1497.     wool_pointer_make("direction", &DefaultMenuDirection);
  1498.     wool_pointer_make("bar-max-width", &DefaultBarMaxWidth);
  1499.     wool_pointer_make("bar-min-width", &DefaultBarMinWidth);
  1500.     wool_pointer_make("menu-max-width", &DefaultMenuMaxWidth);
  1501.     wool_pointer_make("menu-min-width", &DefaultMenuMinWidth);
  1502.     wool_pointer_make("check-input-focus-flag", &GWM_check_input_focus_flag);
  1503.     wool_pointer_make("print-errors-flag", &wool_do_print_errors);
  1504.     wool_pointer_make("screen-count", &GWM_ScreenCount);
  1505.     wool_pointer_make("grab-keyboard-also", &GWM_grab_keyboard_also);
  1506.     wool_pointer_make("confine-grabs", &GWM_confine_grabs);
  1507.     wool_pointer_make("confine-windows", &GWM_confine_windows);
  1508.     wool_pointer_make("gwm-quiet", &GWM_quiet);
  1509.     wool_pointer_make("reenter-on-opening", &GWM_reenter_on_opens);
  1510.     wool_pointer_make("delete-read-properties", &GWM_delete_read_properties);
  1511.     wool_pointer_make("never-warp-pointer", &GWM_never_warp_pointer);
  1512.     wool_pointer_make("xpm-closeness", &GWM_xpm_closeness);
  1513.     wool_pointer_make("border-on-shaped", &GWM_allow_border_on_shaped_windows);
  1514.  
  1515.                     /* pointers to Context fields */
  1516.  
  1517. #define pointer_to_Context(name, field) \
  1518.     (WOOL_Atom) wool_base_pointer_make(name, &Context, &(Context -> field))
  1519.  
  1520.     WA_background = pointer_to_Context("background", pixel.Back);
  1521.     WA_foreground = pointer_to_Context("foreground", pixel.Fore);
  1522.     WA_borderpixel = pointer_to_Context("borderpixel", pixel.Border);
  1523.     pointer_to_Context("grid-color", pixel.GridColor);
  1524.     pointer_to_Context("invert-color", pixel.InvertColor);
  1525.     pointer_to_Context("screen-width", width);
  1526.     pointer_to_Context("screen-height", height);
  1527.     pointer_to_Context("screen-depth", depth);
  1528.     pointer_to_Context("screen-widthMM", widthMM);
  1529.     pointer_to_Context("screen-heightMM", heightMM);
  1530.  
  1531.                      /* context atoms initialisation. Give
  1532.                        type, C name, WOOL name, initial
  1533.                        value */
  1534.  
  1535.     wool_atom_make(WOOL_Atom, WA_bordertile, "bordertile", NIL);
  1536.     wool_atom_make(WOOL_Atom, WA_property, "property", NIL);
  1537.     wool_atom_make(WOOL_Atom, WA_fsm, "fsm", NIL);
  1538.     wool_atom_make(WOOL_Atom, WA_menu, "menu", NIL);
  1539.     wool_atom_make(WOOL_Atom, WA_tile, "tile", NIL);
  1540.     wool_atom_make(WOOL_Atom, WA_cursor, "cursor", NIL);
  1541.     wool_atom_make(WOOL_Atom, WA_property, "property", NIL);
  1542.     wool_atom_make(WOOL_Atom, WA_describe_window, "describe-window", NIL);
  1543.     wool_atom_make(WOOL_Atom, WA_describe_screen, "describe-screen", NIL);
  1544.     wool_atom_make(WOOL_Atom, WA_window_description, "window-description",
  1545.            NIL);
  1546.     wool_atom_make(WOOL_Atom, WA_icon_description, "icon-description", NIL);
  1547.     wool_atom_make(WOOL_Atom, WA_grabs, "grabs", NIL);
  1548.     wool_atom_make(WOOL_Atom, WA_opening, "opening", NIL);
  1549.     wool_atom_make(WOOL_Atom, WA_closing, "closing", NIL);
  1550.     wool_atom_make(WOOL_Atom, WA_horizontal_margin, "horizontal-margin", NIL);
  1551.     wool_atom_make(WOOL_Atom, WA_vertical_margin, "vertical-margin", NIL);
  1552.     wool_atom_make(WOOL_Atom, WA_cursorNW, "cursor-NW", NIL);
  1553.     wool_atom_make(WOOL_Atom, WA_cursorNE, "cursor-NE", NIL);
  1554.     wool_atom_make(WOOL_Atom, WA_cursorN, "cursor-N", NIL);
  1555.     wool_atom_make(WOOL_Atom, WA_cursorSW, "cursor-SW", NIL);
  1556.     wool_atom_make(WOOL_Atom, WA_cursorSE, "cursor-SE", NIL);
  1557.     wool_atom_make(WOOL_Atom, WA_cursorS, "cursor-S", NIL);
  1558.     wool_atom_make(WOOL_Atom, WA_cursorE, "cursor-E", NIL);
  1559.     wool_atom_make(WOOL_Atom, WA_cursorW, "cursor-W", NIL);
  1560.     wool_atom_make(WOOL_Atom, WA_cursorW, "cursor-W", NIL);
  1561.     wool_atom_make(WOOL_Atom, WA_class_name, "class-name",
  1562.            WLString_make("Gwm"));
  1563.     wool_atom_make(WOOL_Atom, WA_client_name, "client-name", 
  1564.            WLString_make("menu"));
  1565.     wool_atom_make(WOOL_Atom, WA_icon_name, "icon-name", NIL);
  1566.     wool_atom_make(WOOL_Atom, WA_starts_iconic, "starts-iconic", NIL);
  1567.     wool_atom_make(WOOL_Atom, WA_map_on_raise, "map-on-raise", NIL);
  1568.     wool_atom_make(WOOL_Atom, WA_ignore_take_focus, "ignore-take-focus", NIL);
  1569.  
  1570.     wool_atom_with_numeric_value_make("horizontal", HORIZONTAL);
  1571.     wool_atom_with_numeric_value_make("vertical", VERTICAL);
  1572.  
  1573.     WA_iconify_window = wool_atom("iconify-window");
  1574.     WA_here = wool_atom("here");
  1575.     WA_bar = wool_atom("bar");
  1576.     WA_plug = wool_atom("plug");
  1577.     WA_root = wool_atom("root");
  1578.     WA_icon = wool_atom("icon");
  1579.     WA_mapped = wool_atom("mapped");
  1580.     WA_stacking_order = wool_atom("stacking-order");
  1581.     WA_mono = wool_atom("mono");
  1582.     WA_gray = wool_atom("gray");
  1583.     WA_color = wool_atom("color");
  1584.     WA_grab = wool_atom("grab");
  1585.     WA_ungrab = wool_atom("ungrab");
  1586.     WA_x = wool_atom("x");
  1587.     WA_y = wool_atom("y");
  1588.     WA_gravity = wool_atom("gravity");
  1589.     WA_borderwidth = wool_atom("borderwidth");
  1590.  
  1591.                      /* functional calls are lists of one
  1592.                        atom */
  1593.  
  1594.     wool_function_call_make(&WL_describe_window_call, WA_describe_window);
  1595.     wool_function_call_make(&WL_describe_screen_call, WA_describe_screen);
  1596.     wool_function_call_make(&WL_iconify_window_call, WA_iconify_window);
  1597.  
  1598.                      /* active values. Give WOOL name, get
  1599.                        C function, set C function (might
  1600.                        be NULL) */
  1601.  
  1602.     WA_window = (WOOL_Atom)
  1603.     wool_active_make("window",
  1604.              wool_current_window, wool_set_current_window);
  1605.     wool_active_make("window-name", wool_current_window_name,
  1606.              wool_current_window_name_set);
  1607.     wool_active_make("window-client-name",
  1608.              wool_current_window_client_name, NULL);
  1609.     wool_active_make("window-client-class",
  1610.              wool_current_window_client_class, NULL);
  1611.     wool_active_make("window-machine-name",
  1612.              wool_current_window_machine_name, NULL);
  1613.     wool_active_make("window-icon-name",
  1614.              wool_current_window_icon_name, NULL);
  1615.     wool_active_make("window-is-mapped",
  1616.              wool_current_window_is_mapped, NULL);
  1617.     wool_active_make("window-x", wool_current_window_x, NULL);
  1618.     wool_active_make("window-y", wool_current_window_y, NULL);
  1619.     wool_active_make("wob-x", wool_wob_x_get, NULL);
  1620.     wool_active_make("wob-y", wool_wob_y_get, NULL);
  1621.     wool_active_make("window-width", wool_current_window_width, NULL);
  1622.     wool_active_make("window-height", wool_current_window_height, NULL);
  1623.     wool_active_make("window-client-x", wool_current_client_x, NULL);
  1624.     wool_active_make("window-client-y", wool_current_client_y, NULL);
  1625.     wool_active_make("window-client-width", wool_current_client_width, NULL);
  1626.     wool_active_make("window-client-height", wool_current_client_height,
  1627.              NULL);
  1628.     wool_active_make("window-client-borderwidth", wool_current_client_borderwidth,
  1629.                      NULL);
  1630.     wool_active_make("window-icon-window", wool_current_window_icon_window,
  1631.              NULL);
  1632.     wool_active_make("window-icon-pixmap", wool_current_window_icon_bitmap,
  1633.              NULL);
  1634.     wool_active_make("window-icon-pixmap-id",
  1635.              wool_current_window_icon_bitmap_id, NULL);
  1636.     wool_active_make("window-user-set-position",
  1637.              wool_current_window_US_position, NULL);
  1638.     wool_active_make("window-user-set-size", wool_current_window_US_size,
  1639.              NULL);
  1640.     wool_active_make("window-program-set-position",
  1641.              wool_current_window_P_position, NULL);
  1642.     wool_active_make("window-program-set-size", wool_current_window_P_size,
  1643.              NULL);
  1644.     wool_active_make("window-is-transient-for",
  1645.              wool_current_window_is_transient_for, NULL);
  1646.     wool_active_make("wob", wool_current_wob, wool_current_wob_set);
  1647.     wool_active_make("wob-width", wool_current_wob_width, NULL);
  1648.     wool_active_make("wob-height", wool_current_wob_height, NULL);
  1649.     wool_active_make("wob-property", Wob_get_property, Wob_set_property);
  1650.     wool_active_make("wob-menu", Wob_get_menu, Wob_set_menu);
  1651.     wool_active_make("wob-fsm", Wob_get_fsm, Wob_set_fsm);
  1652.     wool_active_make("window-property", WLClient_get_property,
  1653.              WLClient_set_property);
  1654.     wool_active_make("wob-status", wool_get_wob_status, NULL);
  1655.     wool_active_make("window-status", wool_get_window_status, NULL);
  1656.     wool_active_make("wob-parent", wool_get_wob_parent, NULL);
  1657.     wool_active_make("window-size", wool_window_logical_size_get,
  1658.              wool_window_logical_size_set);
  1659.     wool_active_make("wob-tile", current_wob_get_bitmap,
  1660.              current_wob_set_bitmap);
  1661.     wool_active_make("wob-pixmap", current_wob_get_bitmap,
  1662.              current_wob_set_bitmap);
  1663.     wool_active_make("wob-borderpixel", current_wob_get_borderpixel,
  1664.              current_wob_set_borderpixel);
  1665.     wool_active_make("wob-borderwidth", current_wob_get_borderwidth,
  1666.              current_wob_set_borderwidth);
  1667.     wool_active_make("wob-background", current_wob_get_background,
  1668.              current_wob_set_background);
  1669.     wool_active_make("window-was-on-screen",
  1670.              GWM_ProcessingExistingWindows_get, NULL);
  1671.     wool_active_make("window-icon", wool_get_icon, NULL);
  1672.     wool_active_make("window-window", wool_get_window, NULL);
  1673.     wool_active_make("window-starts-iconic",
  1674.              wool_window_map_as_icon_get,
  1675.              wool_window_map_as_icon_set);
  1676.     wool_active_make("window-group", wool_window_group_get,
  1677.              wool_window_group_set);
  1678.     wool_active_make("cut-buffer", wool_cut_buffer_0_get,
  1679.              wool_cut_buffer_0_set);
  1680.     wool_active_make("wob-cursor", wool_wob_cursor_get, wool_wob_cursor_set);
  1681.     wool_active_make("window-wm-state-icon", wool_wm_state_user_icon_get,
  1682.              wool_wm_state_user_icon_set);
  1683.     wool_active_make("screen", wool_current_screen_get,
  1684.                  wool_current_screen_set);
  1685.     wool_active_make("screen-type", wool_get_visual_type, NULL);
  1686.     wool_active_make("root-window", wool_get_root_window,
  1687.                  wool_set_root_window);
  1688.  
  1689.     /* Xevents */
  1690.     wool_all_events_make();
  1691.  
  1692.     /* Strings */
  1693.     increase_reference(DefaultClientClass = WLString_make("client"));
  1694.     increase_reference(DefaultClientName = WLString_make("name"));
  1695.     increase_reference(DefaultWindowName = WLString_make("window"));
  1696.     increase_reference(DefaultMachineName = WLString_make("machine"));
  1697.     increase_reference(DefaultIconName = WLString_make("icon"));
  1698.     increase_reference(wool_atom("display-name") -> c_val =
  1699.                (WOOL_OBJECT) WLString_make(GWM_Display));
  1700.  
  1701.     /* fsms */
  1702.     NIL_FSM_make();
  1703.  
  1704.     /* type names of the wobs for consistency purposes */
  1705.  
  1706.     ClientWindowClass[0] = (WOB_METHOD) WA_window;
  1707.     BarClass[0] = (WOB_METHOD) WA_bar;
  1708.     MenuClass[0] = (WOB_METHOD) WA_menu;
  1709.     PlugClass[0] = (WOB_METHOD) WA_plug;
  1710.     ScreenClass[0] = (WOB_METHOD) WA_root;
  1711.  
  1712.     /* screen namespace */
  1713.     ContextNamespace_init();
  1714.     SetDefaultScreen();
  1715. }
  1716.  
  1717. /*
  1718.  * Keep in mind that SetUpdefault is called BEFORE wool is initialized
  1719.  * InitWool in wool_C.c initialize after wool...
  1720.  * argc, argv points AFTER the host:display arg
  1721.  */
  1722.  
  1723. int
  1724. SetUpDefaults()
  1725. {
  1726.     /* initialize wool_host_name */
  1727.     wool_hostname_get();
  1728.  
  1729.     /* fonts */
  1730.     if (TrapXErrors(DefaultFont = (long) XLoadFont(dpy, DEFAULT_FONT))
  1731.     || (!DefaultFont)) {
  1732.     wool_printf("GWM: Cannot find default font %s, aborting\n",
  1733.             DEFAULT_FONT);
  1734.     GWM_end(1);
  1735.     }
  1736.  
  1737.     /* set up per-screen defaults */
  1738.     FOR_ALL_SCREENS {
  1739.     Context -> pixel.Fore = BlackPixel(dpy, Context -> screen);
  1740.     Context -> pixel.Back = WhitePixel(dpy, Context -> screen);
  1741.     Context -> pixel.GridColor =
  1742.         (((unsigned long) 1) << Context -> depth) - 1;
  1743.     Context -> pixel.InvertColor = Context -> pixel.GridColor;
  1744.     Context -> pixel.Border = Context -> pixel.Fore;
  1745.     MeterCreate();
  1746.     }END_OF_ALL_SCREENS;
  1747.  
  1748.     /* X Atoms */
  1749.     XA_WM_STATE = XInternAtom(dpy, "WM_STATE", False);
  1750.     XA_WM_COLORMAP_WINDOWS = XInternAtom(dpy, "WM_COLORMAP_WINDOWS", False);
  1751.     XA_WM_CHANGE_STATE = XInternAtom(dpy, "WM_CHANGE_STATE", False);
  1752.     XA_WM_PROTOCOLS = XInternAtom(dpy, "WM_PROTOCOLS", False);
  1753.     XA_WM_TAKE_FOCUS = XInternAtom(dpy, "WM_TAKE_FOCUS", False);
  1754.     XA_WM_SAVE_YOURSELF = XInternAtom(dpy, "WM_SAVE_YOURSELF", False);
  1755.     XA_WM_DELETE_WINDOW = XInternAtom(dpy, "WM_DELETE_WINDOW", False);
  1756.     XA_GWM_EXECUTE = XInternAtom(dpy, "GWM_EXECUTE", False);
  1757.     XA_GWM_RUNNING = XInternAtom(dpy, "GWM_RUNNING", False);
  1758. }
  1759.  
  1760. /* initialize the switching name space of the screen */
  1761.  
  1762. WOOL_Namespace ContextNamespace;
  1763.  
  1764. void
  1765. ContextNamespace_trigger(i)
  1766. int i;
  1767. {
  1768.     wool_current_screen_set(WLNumber_make(i));
  1769. }
  1770.  
  1771. static Wob ContextNamespace_oldwob;
  1772.  
  1773. void
  1774. ContextNamespace_save_state()
  1775. {
  1776.     ContextNamespace_oldwob = TargetWob;
  1777. }
  1778.  
  1779. void
  1780. ContextNamespace_restore_state()
  1781. {
  1782.     SetTarget(ContextNamespace_oldwob);
  1783. }
  1784.  
  1785. ContextNamespace_init()
  1786. {
  1787.     int i;
  1788.  
  1789.     ContextNamespace = WLNamespace_make();
  1790.     ContextNamespace -> trigger = ContextNamespace_trigger;
  1791.     ContextNamespace -> save_state = ContextNamespace_save_state;
  1792.     ContextNamespace -> restore_state = ContextNamespace_restore_state;
  1793.     for (i=0; i < ScreenCount(dpy); i++)
  1794.     WLNamespace_add(ContextNamespace);
  1795.     wool_atom_make(WOOL_Atom, WA_ContextNamespace, "screen.",
  1796.            ContextNamespace);
  1797. }
  1798.