midfavila/Generic_Window_Manager
1
0
Fork 0
Code Issues 4 Pull Requests Projects Releases Wiki Activity
d3b3ac5a10
Generic_Window_Manager/wl_event.c

1512 lines
37 KiB
C
Raw Blame History

/* Copyright 1989 GROUPE BULL -- See license conditions in file COPYRIGHT
* Copyright 1989 Massachusetts Institute of Technology
*/
/***********************\
* *
* WOOL_OBJECT: Event *
* BODY *
* *
\***********************/
#include "EXTERN.h"
#include <stdio.h>
#include "wool.h"
#include "wl_atom.h"
#include "wl_pointer.h"
#include "wl_string.h"
#include "wl_number.h"
#include "wl_list.h"
#include "wl_func.h"
#include "gwm.h"
#include <X11/Xatom.h>
#include <X11/Xutil.h>
#include "INTERN.h"
#include "wl_event.h"
#include "EXTERN.h"
#include "wl_cursor.h"
#include "wl_fsm.h"
extern WOB_METHOD MenuClass[], PlugClass[];
/* table of events getting redirected to grabbing wob during a GWM grab
*/
Card32 EventProperties[] = {
/* zero */ 0,
/* one */ 0,
/* KeyPress */ EPGrabRedirected|EPKeyOrButton|EPXY|EPXYRoot|EPTime,
/* KeyRelease */ EPGrabRedirected|EPKeyOrButton|EPXY|EPXYRoot|EPTime,
/* ButtonPress */ EPGrabRedirected|EPKeyOrButton|EPXY|EPXYRoot|EPTime,
/* ButtonRelease */ EPGrabRedirected|EPKeyOrButton|EPXY|EPXYRoot|EPTime,
/* MotionNotify */ EPGrabRedirected|EPKeyOrButton|EPXY|EPXYRoot|EPTime,
/* EnterNotify */ EPRedirectable|EPCrossing|EPXY|EPXYRoot|EPTime,
/* LeaveNotify */ EPRedirectable|EPCrossing|EPXY|EPXYRoot|EPTime,
/* FocusIn */ EPRedirectable|EPFocus,
/* FocusOut */ EPRedirectable|EPFocus,
/* KeymapNotify */ 0,
/* Expose */ 0,
/* GraphicsExpose */ 0,
/* NoExpose */ 0,
/* VisibilityNotify */ 0,
/* CreateNotify */ 0,
/* DestroyNotify */ 0,
/* UnmapNotify */ 0,
/* MapNotify */ 0,
/* MapRequest */ 0,
/* ReparentNotify */ 0,
/* ConfigureNotify */ 0,
/* ConfigureRequest */ 0,
/* GravityNotify */ 0,
/* ResizeRequest */ 0,
/* CirculateNotify */ 0,
/* CirculateRequest */ 0,
/* PropertyNotify */ EPTime,
/* SelectionClear */ EPTime,
/* SelectionRequest */ EPTime,
/* SelectionNotify */ EPTime,
/* ColormapNotify */ 0,
/* ClientMessage */ 0,
/* MappingNotify */ 0,
/* LASTEvent */ 0,
/* GWMUserEvent */ 0
};
/* offset of the Time field of events possessing it */
/* IF THIS GIVES COMPILES ERROR, USE THE FLAG -DNO_STRUCTURE_OFFSETS */
XEvent dummy_evt_ptr;
#define XEventFieldOffset(evt_type, field) \
((char *)(&(dummy_evt_ptr.evt_type.field))) - \
((char *)(&(dummy_evt_ptr.type)))
int EventTimeFieldOffset
#ifndef NO_STRUCTURE_OFFSETS
[] = {
/* zero */ 0,
/* one */ 0,
/* KeyPress */ XEventFieldOffset(xkey, time),
/* KeyRelease */ XEventFieldOffset(xkey, time),
/* ButtonPress */ XEventFieldOffset(xbutton, time),
/* ButtonRelease */ XEventFieldOffset(xbutton, time),
/* MotionNotify */ XEventFieldOffset(xmotion, time),
/* EnterNotify */ XEventFieldOffset(xcrossing, time),
/* LeaveNotify */ XEventFieldOffset(xcrossing, time),
/* FocusIn */ 0,
/* FocusOut */ 0,
/* KeymapNotify */ 0,
/* Expose */ 0,
/* GraphicsExpose */ 0,
/* NoExpose */ 0,
/* VisibilityNotify */ 0,
/* CreateNotify */ 0,
/* DestroyNotify */ 0,
/* UnmapNotify */ 0,
/* MapNotify */ 0,
/* MapRequest */ 0,
/* ReparentNotify */ 0,
/* ConfigureNotify */ 0,
/* ConfigureRequest */ 0,
/* GravityNotify */ 0,
/* ResizeRequest */ 0,
/* CirculateNotify */ 0,
/* CirculateRequest */ 0,
/* PropertyNotify */ XEventFieldOffset(xproperty, time),
/* SelectionClear */ XEventFieldOffset(xselectionclear, time),
/* SelectionRequest */ XEventFieldOffset(xselectionrequest, time),
/* SelectionNotify */ XEventFieldOffset(xselection, time),
/* ColormapNotify */ 0,
/* ClientMessage */ 0,
/* MappingNotify */ 0,
/* LASTEvent */ 0,
/* GWMUserEvent */ 0
}
#else
[GWMUserEvent]
#endif /* NO_STRUCTURE_OFFSETS */
;
/* to filter button releases events from the fact that they get the same button
* pressed as a modifier...
*/
unsigned int ButtonMasks[] = {
~0,
~Button1Mask,
~Button2Mask,
~Button3Mask,
~Button4Mask,
~Button5Mask
};
/*
* to built a Event from C
*/
WOOL_Event
wool_event_make(name, x_type, match, release, mask, state, detail)
char * name;
int x_type;
int (*match)();
int (*release)();
unsigned int mask, state, detail;
{
WOOL_Event object = (WOOL_Event) WLEvent_make(state, detail);
object -> x_type = x_type;
object -> match = match;
object -> release = release;
object -> mask = mask;
return (WOOL_Event) WLAtom_set(wool_atom(name), object);
}
WOOL_Event
WLEvent_make(state, detail)
unsigned int state, detail;
{
WOOL_Event object = (WOOL_Event) Malloc(
sizeof(struct _WOOL_Event));
zrt_put(object);
object -> type = WLEvent;
object -> state = state;
object -> detail = detail;
object -> user_mask = 0;
object -> flags = 0;
return object;
}
WOOL_OBJECT
WLEvent_print(obj)
WOOL_Event obj;
{
wool_printf("{EVENT %s", eventtype[obj->x_type]);
wool_printf(" d=%d", obj->detail);
wool_printf(" s=%d", obj->state);
/*print_atom_pointing_to(obj); */
wool_puts("}");
return (WOOL_OBJECT) obj;
}
/*
* List of matching procedures for each event
*/
int
WLEvent_user(wl_event, evt)
WOOL_Event wl_event;
Event evt;
{
if ((wl_event -> detail == (int) evt -> xany.display)
|| (wl_event -> detail == (unsigned int) ANY))
return TRUE;
else
return FALSE;
}
int
WLEvent_propertychange(wl_event, evt)
WOOL_Event wl_event;
Event evt;
{
if (evt -> xproperty.atom == (Atom) wl_event -> detail
|| (wl_event -> detail == (unsigned int) ANY)) {
return TRUE;
} else
return FALSE;
}
int
WLEvent_clientmessage(wl_event, evt)
WOOL_Event wl_event;
Event evt;
{
if (evt -> xclient.message_type == (Atom) wl_event -> detail
|| (wl_event -> detail == (unsigned int) ANY)) {
return TRUE;
} else
return FALSE;
}
int
WLEvent_property_icon_pixmap_change(wl_event, evt)
WOOL_Event wl_event;
Event evt;
{
if ((evt -> xproperty.atom == (Atom) XA_WM_HINTS)
&&
(SetTarget(TargetWob),
TargetWindow -> cached_props -> wm_hints.flags & IconPixmapHint)
&&
(!(GWM_backup_of_old_property.wm_hints.flags & IconPixmapHint)
||
TargetWindow -> cached_props -> wm_hints.icon_pixmap !=
GWM_backup_of_old_property.wm_hints.icon_pixmap))
return TRUE;
else
return FALSE;
}
int
WLEvent_configurenotify(wl_event, evt)
WOOL_Event wl_event;
Event evt;
{
return TRUE;
}
int
WLEvent_buttonpress(wl_event, evt)
WOOL_Event wl_event;
Event evt;
{
if (((wl_event -> detail == (unsigned int) ANY) ||
(wl_event -> detail == evt -> xbutton.button))
&&
((wl_event -> state == (unsigned int) ANY) ||
(wl_event -> state == evt -> xbutton.state)))
return TRUE;
else
return FALSE;
}
int
WLEvent_double_buttonpress(wl_event, evt)
WOOL_Event wl_event;
Event evt;
{
if (((wl_event -> detail == (unsigned int) ANY) ||
(wl_event -> detail == evt -> xbutton.button))
&&
((wl_event -> state == (unsigned int) ANY) ||
(wl_event -> state == evt -> xbutton.state))
&&
evt -> xbutton.button == GWM_LastEvent.xbutton.button
&&
evt -> xbutton.window == GWM_LastEvent.xbutton.window
&&
evt -> xbutton.time <
(GWM_LastEvent.xbutton.time + GWM_DoubleClickDelay))
return TRUE;
else
return FALSE;
}
int
WLEvent_buttonrelease(wl_event, evt)
WOOL_Event wl_event;
Event evt;
{
unsigned int butmask = ButtonMasks[evt -> xbutton.button];
if (((wl_event -> detail == (unsigned int) ANY) ||
(wl_event -> detail == evt -> xbutton.button))
&&
((wl_event -> state == (unsigned int) ANY) ||
((wl_event -> state & butmask) == (evt -> xbutton.state & butmask)
)))
return TRUE;
else
return FALSE;
}
int
WLEvent_keypress(wl_event, evt)
WOOL_Event wl_event;
Event evt;
{
if (((wl_event -> detail == (unsigned int) ANY) ||
(wl_event -> detail == XKeycodeToKeysym(dpy,
evt -> xkey.keycode, 0)))
&&
((wl_event -> state == (unsigned int) ANY) ||
(wl_event -> state == evt -> xkey.state))) {
return TRUE;
} else
return FALSE;
}
int
WLEvent_keyrelease(wl_event, evt)
WOOL_Event wl_event;
Event evt;
{
if (((wl_event -> detail == (unsigned int) ANY) ||
(wl_event -> detail == XKeycodeToKeysym(dpy,
evt -> xkey.keycode, 0)))
&&
((wl_event -> state == (unsigned int) ANY) ||
(wl_event -> state == evt -> xkey.state))) {
return TRUE;
} else
return FALSE;
}
/*
* enter & leave in the subtree of the window
*/
int
WLEvent_enterwindow(wl_event, evt)
WOOL_Event wl_event;
Event evt;
{
XEvent report;
if (evt -> xcrossing.detail != NotifyInferior) {
/* XSync(dpy, 0); */
if (!XCheckTypedWindowEvent(dpy, evt -> xcrossing.window,
LeaveNotify, &report)
|| report.xcrossing.detail == NotifyInferior)
return TRUE;
else
return FALSE;
} else
return FALSE;
}
int
WLEvent_leavewindow(wl_event, evt)
WOOL_Event wl_event;
Event evt;
{
XEvent report;
if (evt -> xcrossing.detail != NotifyInferior) {
/* XSync(dpy, 0); */
if (!XCheckTypedWindowEvent(dpy, evt -> xcrossing.window,
EnterNotify, &report)
|| report.xcrossing.detail == NotifyInferior)
return TRUE;
else
return FALSE;
} else
return FALSE;
}
int
WLEvent_enterwindow_nograb(wl_event, evt)
WOOL_Event wl_event;
Event evt;
{
XEvent report;
if (evt -> xcrossing.detail != NotifyInferior) {
/* XSync(dpy, 0); */
if ((!XCheckTypedWindowEvent(dpy, evt -> xcrossing.window,
LeaveNotify, &report)
|| report.xcrossing.detail == NotifyInferior)
&& evt -> xcrossing.mode != NotifyGrab
&& evt -> xcrossing.mode != NotifyUngrab)
return TRUE;
else
return FALSE;
} else
return FALSE;
}
int
WLEvent_leavewindow_nograb(wl_event, evt)
WOOL_Event wl_event;
Event evt;
{
XEvent report;
if (evt -> xcrossing.detail != NotifyInferior) {
/* XSync(dpy, 0); */
if ((!XCheckTypedWindowEvent(dpy, evt -> xcrossing.window,
EnterNotify, &report)
|| report.xcrossing.detail == NotifyInferior)
&& evt -> xcrossing.mode != NotifyGrab
&& evt -> xcrossing.mode != NotifyUngrab)
return TRUE;
else
return FALSE;
} else
return FALSE;
}
/* Focus management
*/
int
WLEvent_focusin(wl_event, evt)
WOOL_Event wl_event;
Event evt;
{
if (evt -> xfocus.detail == NotifyNonlinearVirtual
|| TargetWob -> type == PlugClass) {
return TRUE;
} else
return FALSE;
}
int
WLEvent_focusout(wl_event, evt)
WOOL_Event wl_event;
Event evt;
{
if (evt -> xfocus.detail == NotifyNonlinearVirtual
|| TargetWob -> type == PlugClass) {
return TRUE;
} else
return FALSE;
}
/* visibility management
*/
int
WLEvent_visibility_partially_obscured(wl_event, evt)
WOOL_Event wl_event;
Event evt;
{
return (evt -> xvisibility.state == VisibilityPartiallyObscured);
}
int
WLEvent_visibility_fully_obscured(wl_event, evt)
WOOL_Event wl_event;
Event evt;
{
return (evt -> xvisibility.state == VisibilityFullyObscured);
}
int
WLEvent_visibility_unobscured(wl_event, evt)
WOOL_Event wl_event;
Event evt;
{
return (evt -> xvisibility.state == VisibilityUnobscured);
}
/*
* list of release procedures
*/
int
WLEvent_button_release(wl_event, evt)
WOOL_Event wl_event;
Event evt;
{
wait_for_button_release(evt -> xbutton.button);
return 0;
}
int
WLEvent_key_release(wl_event, evt)
WOOL_Event wl_event;
Event evt;
{
wait_for_key_release(evt -> xkey.keycode);
return 0;
}
/* mapping of window
*/
int
WLEvent_map_notify(wl_event, evt)
WOOL_Event wl_event;
Event evt;
{
return TRUE;
}
/*
* functions to make the different events
*/
WOOL_Event
WLEvent_user_make(data)
WOOL_Atom data;
{
WOOL_Event event;
if (data -> type == WLNumber && (((WOOL_Number) data) -> number == ANY))
event = WLEvent_make(0, ANY);
else
event = WLEvent_make(0, (unsigned int)data);
event -> x_type = GWMUserEvent;
event -> match = WLEvent_user;
event -> release = NULL;
event -> mask = 0;
event -> user_mask = 1;
return event;
}
WOOL_Event
WLEvent_propertychange_make(name)
WOOL_String name;
{
WOOL_Event event = WLEvent_make(0, 0);
WOOL_Pointer x_atom;
Atom property_name;
event -> x_type = PropertyNotify;
event -> match = WLEvent_propertychange;
event -> release = NULL;
event -> mask = PropertyChangeMask;
if (is_a_string(name)) {
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;
}
} else {
property_name = (Atom) ANY;
}
event -> detail = (unsigned int) property_name;
return event;
}
WOOL_Event
WLEvent_clientmessage_make(name)
WOOL_String name;
{
WOOL_Event event = WLEvent_make(0, 0);
WOOL_Pointer x_atom;
Atom property_name;
event -> x_type = ClientMessage;
event -> match = WLEvent_clientmessage;
event -> release = NULL;
event -> mask = 0;
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;
}
event -> detail = (unsigned int) property_name;
return event;
}
WOOL_Event
WLEvent_button_make(button, modifier)
WOOL_Number modifier;
WOOL_Number button;
{
WOOL_Event event = WLEvent_make(modifier -> number,
(button -> number == AnyButton ? ANY : button -> number));
event -> x_type = ButtonPress;
event -> match = WLEvent_buttonpress;
event -> release = WLEvent_button_release;
event -> mask = ButtonPressMask | ButtonReleaseMask;
return event;
}
WOOL_Event
WLEvent_buttonpress_make(button, modifier)
WOOL_Number modifier;
WOOL_Number button;
{
WOOL_Event event = WLEvent_button_make(button, modifier);
event -> release = NULL;
return event;
}
WOOL_Event
WLEvent_double_button_make(button, modifier)
WOOL_Number modifier;
WOOL_Number button;
{
WOOL_Event event = WLEvent_make(modifier -> number,
(button -> number == AnyButton ? ANY : button -> number));
event -> x_type = ButtonPress;
event -> match = WLEvent_double_buttonpress;
event -> release = WLEvent_button_release;
event -> mask = ButtonPressMask | ButtonReleaseMask;
return event;
}
WOOL_Event
WLEvent_double_buttonpress_make(button, modifier)
WOOL_Number modifier;
WOOL_Number button;
{
WOOL_Event event = WLEvent_double_button_make(button, modifier);
event -> release = NULL;
return event;
}
WOOL_Event
WLEvent_buttonrelease_make(button, modifier)
WOOL_Number modifier;
WOOL_Number button;
{
WOOL_Event event =
WLEvent_button_make(button,
WLNumber_make(((unsigned long) modifier -> number) |
(((unsigned long) Button1Mask) << (button -> number - Button1))));
event -> x_type = ButtonRelease;
event -> match = WLEvent_buttonrelease;
event -> release = NULL;
return event;
}
WOOL_Event
WLEvent_key_make(key, modifier)
WOOL_Number modifier;
WOOL_Number key;
{
WOOL_Event event;
KeySym keysym;
must_be_number(modifier, 1);
if (key -> type == WLNumber)
keysym = key -> number;
else {
if ((keysym = XStringToKeysym(((WOOL_String) key) -> string))
== NoSymbol) {
wool_printf("unknown key name: \"%s\"\n",
((WOOL_String) key) -> string);
keysym = (KeySym) UNDEFINED_KEYCODE;
}
}
event = WLEvent_make(modifier -> number, keysym);
event -> x_type = KeyPress;
event -> match = WLEvent_keypress;
event -> release = WLEvent_key_release;
event -> mask = KeyPressMask | KeyReleaseMask;
return event;
}
WOOL_Event
WLEvent_keypress_make(key, modifier)
WOOL_Number modifier;
WOOL_Number key;
{
WOOL_Event event = WLEvent_key_make(key, modifier);
event -> release = NULL;
return event;
}
WOOL_Event
WLEvent_keyrelease_make(key, modifier)
WOOL_Number modifier;
WOOL_Number key;
{
WOOL_Event event = WLEvent_key_make(key, modifier);
event -> x_type = KeyRelease;
event -> match = WLEvent_keyrelease;
event -> release = NULL;
return event;
}
/*
* Initialize all the events
*/
void
wool_all_events_make()
{
grab_queue_init();
wool_atom_with_numeric_value_make("any", ANY);
wool_atom_with_numeric_value_make("alone", 0);
wool_atom_with_numeric_value_make("with-button-1", Button1Mask);
wool_atom_with_numeric_value_make("with-button-2", Button2Mask);
wool_atom_with_numeric_value_make("with-button-3", Button3Mask);
wool_atom_with_numeric_value_make("with-button-4", Button4Mask);
wool_atom_with_numeric_value_make("with-button-5", Button5Mask);
wool_atom_with_numeric_value_make("with-shift", ShiftMask);
wool_atom_with_numeric_value_make("with-lock", LockMask);
wool_atom_with_numeric_value_make("with-control", ControlMask);
wool_atom_with_numeric_value_make("with-alt", Mod1Mask);
wool_atom_with_numeric_value_make("with-modifier-1", Mod1Mask);
wool_atom_with_numeric_value_make("with-modifier-2", Mod2Mask);
wool_atom_with_numeric_value_make("with-modifier-3", Mod3Mask);
wool_atom_with_numeric_value_make("with-modifier-4", Mod4Mask);
wool_atom_with_numeric_value_make("with-modifier-5", Mod5Mask);
wool_subr_make(WLSubr, WLEvent_buttonpress_make, "buttonpress", 2);
wool_subr_make(WLSubr, WLEvent_keypress_make, "keypress", 2);
wool_subr_make(WLSubr, WLEvent_button_make, "button", 2);
wool_subr_make(WLSubr, WLEvent_key_make, "key", 2);
wool_subr_make(WLSubr, WLEvent_buttonrelease_make, "buttonrelease", 2);
wool_subr_make(WLSubr, WLEvent_keyrelease_make, "keyrelease", 2);
wool_subr_make(WLSubr, WLEvent_user_make, "user-event", 1);
wool_subr_make(WLSubr, WLEvent_propertychange_make, "property-change", 1);
wool_subr_make(WLSubr, WLEvent_clientmessage_make, "client-message", 1);
wool_subr_make(WLSubr, WLEvent_double_buttonpress_make,
"double-buttonpress", 2);
wool_subr_make(WLSubr, WLEvent_double_button_make, "double-button", 2);
wool_event_make("name-change", PropertyNotify, WLEvent_propertychange,
NULL, PropertyChangeMask, 0, XA_WM_NAME);
wool_event_make("window-icon-pixmap-change", PropertyNotify,
WLEvent_property_icon_pixmap_change, NULL,
PropertyChangeMask, 0, XA_WM_HINTS);
wool_event_make("geometry-change", ConfigureNotify,
WLEvent_configurenotify, NULL, SubstructureNotifyMask, 0, 0);
wool_event_make("enter-window", EnterNotify, WLEvent_enterwindow, NULL,
EnterWindowMask, 0, 0);
wool_event_make("leave-window", LeaveNotify, WLEvent_leavewindow, NULL,
LeaveWindowMask, 0, 0);
wool_event_make("enter-window-not-from-grab", EnterNotify,
WLEvent_enterwindow_nograb, NULL,
EnterWindowMask, 0, 0);
wool_event_make("leave-window-not-from-grab", LeaveNotify,
WLEvent_leavewindow_nograb, NULL,
LeaveWindowMask, 0, 0);
wool_event_make("focus-in", FocusIn, WLEvent_focusin, NULL,
FocusChangeMask, 0, 0);
wool_event_make("focus-out", FocusOut, WLEvent_focusout, NULL,
FocusChangeMask, 0, 0);
wool_event_make("map-notify", MapNotify, WLEvent_map_notify, NULL,
StructureNotifyMask, 0, 0);
wool_event_make("visibility-unobscured", VisibilityNotify,
WLEvent_visibility_unobscured,
NULL, VisibilityChangeMask, 0, 0);
wool_event_make("visibility-partially-obscured", VisibilityNotify,
WLEvent_visibility_partially_obscured,
NULL, VisibilityChangeMask, 0, 0);
wool_event_make("visibility-fully-obscured", VisibilityNotify,
WLEvent_visibility_fully_obscured,
NULL, VisibilityChangeMask, 0, 0);
}
/*
* wait for release of button n
*/
int
LookForButtonRelease(display, evt, arg)
Display *display;
XEvent *evt;
char *arg;
{
int n = (int)arg;
if ((evt -> type == ButtonRelease) && (evt -> xbutton.button == n))
return True;
else
return False;
}
wait_for_button_release(n)
int n;
{
XEvent button_event;
XIfEvent(dpy, &button_event, LookForButtonRelease, (char *)n);
}
/*
* wait for release of key of code n
*/
int
LookForKeyRelease(display, evt, arg)
Display *display;
XEvent *evt;
char *arg;
{
if ((evt -> type == KeyRelease) && (evt -> xkey.keycode == (int)arg))
return True;
else
return False;
}
wait_for_key_release(n)
int n;
{
XEvent button_event;
XIfEvent(dpy, &button_event, LookForKeyRelease, (char *)n);
}
/* grab management
*/
WOOL_OBJECT
set_grab(wob)
Wob wob;
{
WOOL_Cursor cursor;
int status;
if (wob -> type == MenuClass)
cursor = (WOOL_Cursor) wob -> cursor;
else
cursor =
(WOOL_Cursor) WOOL_send(WOOL_eval, WA_cursor, (WA_cursor));
if ((status =
XGrabPointer(dpy, wob -> hook, True,
LegalPointerEventMask(((WOOL_Fsm) wob -> fsm) -> mask),
GrabModeAsync, GrabModeAsync,
(GWM_confine_grabs ? wob -> hook : None),
(cursor == (WOOL_Cursor) NIL ? None : cursor -> cursor),
CurrentTime))
!= GrabSuccess)
return (WOOL_OBJECT) WLNumber_make(status);
if (GWM_grab_keyboard_also)
if ((status = XGrabKeyboard(dpy, wob -> hook, True,
GrabModeAsync, GrabModeAsync, CurrentTime))
!= GrabSuccess) {
XUngrabPointer(dpy, CurrentTime);
return (WOOL_OBJECT) WLNumber_make(status);
} else {
GWM_KeyboardGrabbed = wob;
}
if (GWM_GrabServer)
XGrabServer(dpy);
GWM_ServerGrabbed = wob;
return NIL;
}
WOOL_OBJECT
remove_grab(wob)
Wob wob;
{
if (!wob || wob == GWM_ServerGrabbed) {
if (GWM_ServerGrabbed)
XUngrabPointer(dpy, CurrentTime);
if (GWM_KeyboardGrabbed)
XUngrabKeyboard(dpy, CurrentTime);
if (GWM_GrabServer)
XUngrabServer(dpy);
XSync(dpy, 0);
GWM_ServerGrabbed = GWM_KeyboardGrabbed = NULL;
FlushQueuedGrabEvents();
}
return NIL;
}
WOOL_OBJECT
wool_set_grab(argc, argv)
int argc;
WOOL_Number argv[];
{
GWM_GrabChildEvents = 0;
switch (argc) {
case 0:
return set_grab(TargetWob);
case 2:
GWM_GrabChildEvents = 1;
}
must_be_number(argv[0], 0);
return set_grab(argv[0] -> number);
}
WOOL_OBJECT
wool_remove_grab(argc, argv)
int argc;
WOOL_Number argv[];
{
if (!argc)
return remove_grab(0);
must_be_number(argv[0], 0);
return remove_grab(argv[0] -> number);
}
/* replay back event in a grab
* if arg != NIL, replay key event
*/
WOOL_OBJECT
wool_ungrab_and_replay_event(key)
WOOL_OBJECT key;
{
if (key == NIL)
XAllowEvents(dpy, ReplayPointer, CurrentTime);
else
XAllowEvents(dpy, ReplayKeyboard, CurrentTime);
return NIL;
}
/* makes a button event replayable */
WOOL_OBJECT
wool_makes_replayable(event)
WOOL_Event event;
{
must_be_event(event, 0);
event -> flags |= FREEZE_ON_GRABS;
return (WOOL_OBJECT) event;
}
/* allows event processing after a freeze due to a replayable event
*/
WOOL_OBJECT
wool_allow_events()
{
XAllowEvents(dpy, AsyncPointer, CurrentTime);
XAllowEvents(dpy, AsyncKeyboard, CurrentTime);
return NIL;
}
/* last events of some type
*/
WOOL_OBJECT
wool_last_key_struck()
{
char s[81];
int l;
if ((TriggeringEvent -> type == KeyPress ||
TriggeringEvent -> type == KeyRelease)
&& (l = XLookupString(&TriggeringEvent->xkey, s, 80, 0, 0))) {
s[l] = '\0';
return (WOOL_OBJECT) WLString_make(s);
} else
return NIL;
}
WOOL_OBJECT
wool_last_user_event()
{
if (TriggeringEvent -> type == GWMUserEvent)
return (WOOL_OBJECT) TriggeringEvent -> xany.display;
else
return wool_error("last event%s was not an user event", "");
}
Event
last_key_or_button_event(evt)
Event evt;
{
if (event_is_key_or_button(*TriggeringEvent))
return TriggeringEvent;
else
return &GWM_LastEvent;
}
/*
* returns the coords of the click relative to the client as a list
* (logical-x logical-y x y) for the current window's client
*/
#ifdef NOBASEDIMS
#ifdef PBaseSize
#undef PBaseSize
#endif
#define PBaseSize PMinSize
#define base_width min_width
#define base_height min_height
#endif /* NOBASEDIMS */
WOOL_OBJECT
wool_logical_coords()
{
int x=0 , y=0;
Window child;
WOOL_List wl_list = wool_list_make(6);
Event evt = last_key_or_button_event(TriggeringEvent);
XSizeHints *normal_hints =
&(TargetWindow -> cached_props -> normal_hints);
if (TargetWindow -> client)
XTranslateCoordinates(dpy, evt -> xbutton.root,
TargetWindow -> client, evt -> xbutton.x_root,
evt -> xbutton.y_root, &x, &y, &child);
increase_reference(wl_list -> list[0] = (WOOL_OBJECT) WLNumber_make(
(x - (normal_hints -> flags & PBaseSize ?
normal_hints -> base_width : 0))
/ (normal_hints -> flags & PResizeInc ?
normal_hints -> width_inc : 1)));
increase_reference(wl_list -> list[1] = (WOOL_OBJECT) WLNumber_make(
(y - (normal_hints -> flags & PBaseSize ?
normal_hints -> base_height : 0))
/ (normal_hints -> flags & PResizeInc ?
normal_hints -> height_inc : 1)));
increase_reference(wl_list -> list[2] = (WOOL_OBJECT) WLNumber_make(x));
increase_reference(wl_list -> list[3] = (WOOL_OBJECT) WLNumber_make(y));
XTranslateCoordinates(dpy, evt -> xbutton.root,
TargetWindow -> hook, evt -> xbutton.x_root,
evt -> xbutton.y_root, &x, &y, &child);
increase_reference(wl_list -> list[4] = (WOOL_OBJECT) WLNumber_make(x));
increase_reference(wl_list -> list[5] = (WOOL_OBJECT) WLNumber_make(y));
return (WOOL_OBJECT) wl_list;
}
int EventMasks[]={0,0,
KeyPressMask,
KeyReleaseMask,
ButtonPressMask,
ButtonReleaseMask};
WOOL_OBJECT
wool_resend_event(wob)
WOOL_Number wob;
{
Window window;
Event evt = last_key_or_button_event(TriggeringEvent);
if (wob = (WOOL_Number) NIL)
window = TargetWindow -> client;
else
window = ((Wob) wob) -> hook;
if (window) {
evt -> xany.window = window;
XSendEvent(dpy, TargetWindow -> client, False,
EventMasks[evt->type], evt);
XFlush(dpy);
}
return (WOOL_OBJECT) NIL;
}
WOOL_OBJECT
wool_send_keycode_to_client(keycode, mod)
WOOL_Number keycode, mod;
{
XEvent event;
fill_x_key_event(&event, keycode -> number, mod -> number);
XSendEvent(dpy, TargetWindow -> client, False, KeyPressMask, &event);
fill_x_key_event(&event, keycode -> number, mod -> number);
event.type = KeyRelease;
XSendEvent(dpy, TargetWindow -> client, False, KeyReleaseMask, &event);
return (WOOL_OBJECT) keycode;
}
WOOL_OBJECT
wool_send_key_to_client(key, mod)
WOOL_Number key, mod;
{
XEvent event;
char *p = 0;
int keysym, keycode;
int modifier;
must_be_number(mod, 1);
if (key -> type != WLNumber) {
must_be_string(key, 0);
p = ((WOOL_String) key) -> string;
if (!(*p))
return NIL;
}
do { /* we MUST re-init event each time */
modifier = mod -> number;
if (key -> type == WLNumber)
keysym = key -> number;
else {
keysym = *p++;
}
if (!(keycode = XKeysymToKeycode(dpy, keysym)))
return wool_error("unknown keysym for this server: 0x%x", keysym);
/* add shift automatically for shifted chars */
/* We should do same thing for control chars & meta... */
if (keysym != XKeycodeToKeysym(dpy, keycode, 0)) {
if (keysym == XKeycodeToKeysym(dpy, keycode, 1)) {
modifier |= ShiftMask;
}
}
fill_x_key_event(&event, keycode, modifier);
XSendEvent(dpy, TargetWindow -> client, False, KeyPressMask, &event);
fill_x_key_event(&event, keycode, modifier);
event.type = KeyRelease;
XSendEvent(dpy, TargetWindow -> client, False, KeyReleaseMask,
&event);
} while (p && *p);
return (WOOL_OBJECT) key;
}
fill_x_key_event(evt, keycode, modifier)
XKeyPressedEvent *evt;
int keycode, modifier;
{
evt -> type = KeyPress;
evt -> display = dpy;
evt -> window = evt -> subwindow = TargetWindow -> client;
evt -> root = Context->root;
evt -> time = CurrentTime;
evt -> x = evt -> y = evt -> x_root = evt -> y_root = 0;
evt -> same_screen = 1;
evt -> keycode = keycode;
evt -> state = modifier;
}
/* same with button: button modifier x y
*/
fill_x_button_event(evt, button, modifier, x, y, x_root, y_root, child)
XButtonEvent *evt;
int button, modifier, x, y, x_root, y_root;
Window child;
{
evt -> type = ButtonPress;
evt -> display = dpy;
evt -> window = child;
evt -> subwindow = 0;
evt -> root = Context->root;
evt -> time = CurrentTime;
evt -> x = x;
evt -> y = y;
evt -> x_root = x_root;
evt -> y_root = y_root;
evt -> same_screen = 1;
evt -> button = button;
evt -> state = modifier;
}
/* look which window would receive button event
*/
Window
WindowGettingButtonEvent(w, x, y)
Window w;
int x,y;
{
int x2, y2;
Window child, w2 = w;
XWindowAttributes wa;
find_window:
XTranslateCoordinates(dpy, w, w2, x, y, &x2, &y2, &child);
if (child) {
x = x2;
y = y2;
w = w2;
w2 = child;
goto find_window;
}
x = x2;
y = y2;
w = w2;
find_listener:
XGetWindowAttributes(dpy, w, &wa);
if (!(wa.all_event_masks & (ButtonPressMask | ButtonReleaseMask))) {
Window d1, d2, *d3, parent;
unsigned int d4;
XQueryTree(dpy, w, &d1, &parent, &d3, &d4);
XFreeN(d3);
if (parent) {
w = parent;
goto find_listener;
}
}
return w;
}
WOOL_OBJECT
wool_send_button_to_client(argc, argv)
int argc;
WOOL_Number argv[];
{
XEvent event;
int button, modifier, x, y, x2, y2, x_root, y_root, i;
Window child, dummy;
if (argc != 4)
return wool_error(BAD_NUMBER_OF_ARGS, argc);
for (i = 0; i < argc; i++)
must_be_number(argv[i], i);
button = argv[0] -> number;
modifier = argv[1] -> number;
x = argv[2] -> number;
y = argv[3] -> number;
XTranslateCoordinates(dpy, TargetWindow -> client, Context -> root, x, y,
&x_root, &y_root, &child);
child = WindowGettingButtonEvent(TargetWindow -> client, x, y);
x2 =x, y2 =y;
XTranslateCoordinates(dpy, TargetWindow -> client, child, x2, y2,
&x, &y, &dummy);
fill_x_button_event(&event, button, modifier, x, y, x_root, y_root, child);
XSendEvent(dpy, child, False, ButtonPressMask, &event);
fill_x_button_event(&event, button, modifier, x, y, x_root, y_root, child);
event.type = ButtonRelease;
XSendEvent(dpy, child, False, ButtonReleaseMask, &event);
return (WOOL_OBJECT) argv[0];
}
/* management of the enter/leave on grabs for menus
* these functions are used
* - just before sending event in GWM_ProcessEvents (gwm.c)
* if (IsNotGrabDiscarded(&evt)) {
* send-event...
* }
* - in remove_grab (at the end) for FlushQueuedGrabEvents
*
* - in wool_all_events_make for grab_queue_init
*/
static XEvent *grab_queue;
static int grab_queue_start;
static int grab_queue_size;
static int grab_queue_limit;
grab_queue_init()
{
grab_queue_size = 0;
grab_queue_limit = 1;
grab_queue = (XEvent *) Malloc(grab_queue_limit * sizeof(XEvent));
}
int
IsNotGrabDiscarded(evt)
Event evt;
{
if (((evt -> type == LeaveNotify)
&& (evt -> xcrossing.mode == NotifyGrab))
|| ((evt -> type == FocusOut)
&& (evt -> xfocus.mode == NotifyGrab))) {
if (grab_queue_size == grab_queue_limit) {
grab_queue_limit *= 2;
grab_queue = (XEvent *) Realloc(grab_queue, grab_queue_limit
* sizeof(XEvent));
}
bcopy(evt, &grab_queue[grab_queue_size++], sizeof(XEvent));
return FALSE;
} else {
if (((evt -> type == EnterNotify)
&& (evt -> xcrossing.mode == NotifyUngrab))
|| ((evt -> type == FocusIn)
&& (evt -> xfocus.mode == NotifyUngrab))) {
return TRUE;
} else {
return FALSE;
}
}
}
FlushQueuedGrabEvents()
{
Wob wob;
SAVE_EVENT_CONTEXT;
while (grab_queue_start < grab_queue_size) {
if (wob = (Wob) LookUpWob(grab_queue[grab_queue_start].xany.window)) {
WOOL_send(WOOL_process_event, wob,
(wob, &grab_queue[grab_queue_start]));
}
grab_queue_start++;
}
RESTORE_EVENT_CONTEXT;
grab_queue_size = 0;
grab_queue_start = 0;
}
/*
* recuperates parameters of the triggering event
*/
#define field_of_event(evt, event_property, etype, field) \
if(TriggeringEvent->type > 1 && TriggeringEvent->type < LASTEvent && \
EventProperties[TriggeringEvent->type] & event_property) \
return (WOOL_OBJECT) WLNumber_make(((etype *) evt) -> field); \
else return (WOOL_OBJECT) WLNumber_make(0);
WOOL_OBJECT
wool_get_triggering_event_data()
{
if (TriggeringEvent->type == ClientMessage)
{
switch (((XClientMessageEvent *) TriggeringEvent)->format)
{
case 8:
return ((WOOL_OBJECT) WLString_make(
((XClientMessageEvent *) TriggeringEvent)->data.b));
case 16:
{
WOOL_Number ListArgv[10];
int i;
for (i=0;i<10;i++)
{
ListArgv[i] = WLNumber_make(
((XClientMessageEvent *) TriggeringEvent)->data.s[i]);
}
return ((WOOL_OBJECT) wool_list_make_from_evaluated_array(10,
(WOOL_OBJECT *) ListArgv));
}
case 32:
{
WOOL_Number ListArgv[5];
int i;
for (i=0;i<5;i++)
{
ListArgv[i] = WLNumber_make(
((XClientMessageEvent *) TriggeringEvent)->data.l[i]);
}
return ((WOOL_OBJECT) wool_list_make_from_evaluated_array(5,
(WOOL_OBJECT *) ListArgv));
}
}
}
return wool_error("internal error, event was not of good type%s", "");
}
WOOL_OBJECT
wool_get_triggering_event_state()
{
field_of_event(TriggeringEvent, EPKeyOrButton, XButtonEvent, state);
}
WOOL_OBJECT
wool_get_triggering_event_code()
{
field_of_event(TriggeringEvent, EPKeyOrButton, XButtonEvent, button);
}
WOOL_OBJECT
wool_get_triggering_event_x()
{
field_of_event(TriggeringEvent, EPXYRoot, XButtonEvent, x_root);
}
WOOL_OBJECT
wool_get_triggering_event_y()
{
field_of_event(TriggeringEvent, EPXYRoot, XButtonEvent, y_root);
}
WOOL_OBJECT
wool_get_triggering_event_x_relative()
{
field_of_event(TriggeringEvent, EPXY, XButtonEvent, x);
}
WOOL_OBJECT
wool_get_triggering_event_y_relative()
{
field_of_event(TriggeringEvent, EPXY, XButtonEvent, y);
}
WOOL_OBJECT
wool_get_triggering_event_time()
{
field_of_event(TriggeringEvent, EPXY, XButtonEvent, time);
}
/* used to know if current event was due to a grab */
WOOL_OBJECT
wool_event_was_due_to_a_grab()
{
WOOL_Atom result = (WOOL_Atom) NIL;
if (event_is_crossing(*TriggeringEvent)) {
if (TriggeringEvent -> xcrossing.mode == NotifyGrab)
result = WA_grab;
else if (TriggeringEvent -> xcrossing.mode == NotifyUngrab)
result = WA_ungrab;
} else if (event_is_focus(*TriggeringEvent)) {
if (TriggeringEvent -> xfocus.mode == NotifyGrab)
result = WA_grab;
else if (TriggeringEvent -> xfocus.mode == NotifyUngrab)
result = WA_ungrab;
}
return (WOOL_OBJECT) result;
}
/********************\
* *
* Tracing of events *
* *
\********************/
#ifdef DEBUG
char *FocusDetailText[] = {
"NotifyAncestor", /* 0 */
"NotifyVirtual", /* 1 */
"NotifyInferior", /* 2 */
"NotifyNonlinear", /* 3 */
"NotifyNonlinearVirtual", /* 4 */
"NotifyPointer", /* 5 */
"NotifyPointerRoot", /* 6 */
"NotifyDetailNone" /* 7 */
};
char *FocusModeText[] = {
"NotifyNormal", /* 0 */
"NotifyGrab", /* 1 */
"NotifyUngrab", /* 2 */
"NotifyWhileGrabbed" /* 3 */
};
GWM_prettyprint_fsm_event(wob, evt, text, state, newstate)
Wob wob;
Event evt;
char *text;
int state, newstate;
{
fprintf(stderr, "%s %s (0x%lx/0x%lx): ",
text, ((WOOL_Atom) wob -> type[0])-> p_name,
wob, wob -> hook);
if (state || newstate) {
fprintf(stderr, " (s%d", state);
if (state != newstate) {
fprintf(stderr, "->%d", newstate);
}
fprintf(stderr, ")");
}
GWM_prettyprint_event(" ", evt, "\n");
}
GWM_prettyprint_event(tag, evt, end)
char *tag;
Event evt;
char *end;
{
fputs(tag, stderr);
fprintf(stderr, "%s ", eventtype[evt -> type]);
switch (evt->type) {
case GWMUserEvent:
fprintf(stderr, "%s",
((WOOL_String) (evt->xany.display))->string);
break;
case FocusIn:
case FocusOut:
fprintf(stderr, "w 0x%x, detail %s, mode %s",
evt->xfocus.window,
FocusDetailText[evt->xfocus.detail],
FocusModeText[evt->xfocus.mode]);
break;
case EnterNotify:
case LeaveNotify:
fprintf(stderr, "w 0x%x, detail %s, mode %s",
evt->xcrossing.window,
FocusDetailText[evt->xcrossing.detail],
FocusModeText[evt->xcrossing.mode]);
break;
case PropertyNotify:
fprintf(stderr, "w 0x%x, %s",
evt->xproperty.window,
XGetAtomName(dpy, evt->xproperty.atom));
break;
case ReparentNotify:
fprintf(stderr, "w 0x%x to 0x%x %s",
evt->xreparent.window, evt->xreparent.parent,
(evt->xreparent.override_redirect ? "(Override)":""));
break;
case ConfigureNotify:
fprintf(stderr, "event 0x%x window 0x%x x %d y %d w %d h %d bw %d above 0x%x\n", evt->xconfigure.event, evt->xconfigure.window, evt->xconfigure.x, evt->xconfigure.y, evt->xconfigure.width, evt->xconfigure.height, evt->xconfigure.border_width, evt->xconfigure.above);
break;
case ConfigureRequest:
fprintf(stderr, "parent 0x%x window 0x%x x %d y %d w %d h %d bw %d above 0x%x detail %d mask %d\n", evt->xconfigurerequest.parent, evt->xconfigurerequest.window, evt->xconfigurerequest.x, evt->xconfigurerequest.y, evt->xconfigurerequest.width, evt->xconfigurerequest.height, evt->xconfigurerequest.border_width, evt->xconfigurerequest.above, evt->xconfigurerequest.detail, evt->xconfigurerequest.value_mask);
break;
default:
fprintf(stderr, "w 0x%x", evt->xany.window);
}
fputs(end, stderr);
}
#endif /* DEBUG */
Reference in New Issue View Git Blame Copy Permalink