/*
* Try to deliver a general event such as focus in, focus out, mouse enter,
* or mouse exit to the clients which have selected for it. These events
* only have the window id as data, and do not propagate upwards.
*/
void
GsDeliverGeneralEvent(GR_WINDOW *wp, GR_EVENT_TYPE type, GR_WINDOW *other)
{
GR_EVENT_GENERAL *gp; /* general event */
GR_EVENT_CLIENT *ecp; /* current event client */
GR_EVENT_MASK eventmask; /* event mask */
eventmask = GR_EVENTMASK(type);
if (eventmask == 0)
return;
for (ecp = wp->eventclients; ecp; ecp = ecp->next) {
if ((ecp->eventmask & eventmask) == 0)
continue;
gp = (GR_EVENT_GENERAL *) GsAllocEvent(ecp->client);
if (gp == NULL)
continue;
gp->type = type;
gp->wid = wp->id;
if (other)
gp->otherid = other->id;
else gp->otherid = 0;
}
}
/* This is a bit of a misnomer - this will deliver the normal events
but it doesn't bother doing any sort of bounds checking or anything,
we just start at the "focus" window and try to deliver events to the path
*/
void
GsDeliverRawMouseEvent(int rx, int ry, int buttons, int modifiers)
{
int i;
GR_WINDOW *wp; /* current window */
GR_CLIENT *client; /* current client */
GR_WINDOW_ID subwid; /* subwindow id event is for */
GR_EVENT_CLIENT *ecp;
/* Start with the "focus" window and move up */
/* Since the raw mouse position doesn't match the actual
geometry, this is all we can do */
wp = mousewp;
subwid = wp->id;
for (ecp = wp->eventclients; ecp; ecp = ecp->next) {
GR_EVENT_MOUSE *ep;
if ((ecp->eventmask & GR_EVENT_MASK_MOUSE_POSITION) == 0)
continue;
client = ecp->client;
GsFreePositionEvent(client, wp->id, subwid);
ep = (GR_EVENT_MOUSE *) GsAllocEvent(client);
if (ep == NULL)
continue;
ep->type = GR_EVENT_TYPE_MOUSE_POSITION;
ep->wid = wp->id;
ep->subwid = subwid;
ep->rootx = rx;
ep->rooty = ry;
ep->x = 0; /* These make no sense in raw mode */
ep->y = 0;
ep->buttons = buttons;
ep->modifiers = modifiers;
if ((wp == rootwp)
|| (wp->nopropmask & GR_EVENT_MASK_MOUSE_POSITION))
break;
wp = wp->parent;
}
/* Deliver button events if we have to */
for (i = 0; i < 2; i++) {
GR_EVENT_BUTTON *gp;
unsigned long cbuttons = 0;
GR_EVENT_TYPE etype = (i == 0) ? GR_EVENT_TYPE_BUTTON_DOWN :
GR_EVENT_TYPE_BUTTON_UP;
if (i == 0)
cbuttons = (curbuttons & ~buttons);
else
cbuttons = (~buttons & curbuttons);
if (!cbuttons)
continue;
wp = mousewp;
subwid = wp->id;
for (ecp = wp->eventclients; ecp; ecp = ecp->next) {
client = ecp->client;
if ((ecp->eventmask & GR_EVENTMASK(etype)) == 0)
continue;
gp = (GR_EVENT_BUTTON *) GsAllocEvent(ecp->client);
if (gp == NULL)
continue;
gp->type = etype;
gp->wid = wp->id;
gp->subwid = subwid;
gp->rootx = rx;
gp->rooty = ry;
gp->x = 0;
gp->y = 0;
gp->buttons = buttons;
gp->changebuttons = cbuttons;
gp->modifiers = modifiers;
gp->time = GsGetTickCount();
if ((wp == rootwp) || (wp->nopropmask & GR_EVENTMASK(etype)))
break;
wp = wp->parent;
}
}
curbuttons = buttons;
}
/*
* Deliver a keyboard event to one of the clients which have selected for it.
* Only the first client found gets the event (no duplicates are sent). The
* window the event is delivered to is either the smallest one containing
* the mouse coordinates, or else one of its direct ancestors (if such a
* window is a descendant of the focus window), or else just the focus window.
* The lowest window in that tree which has enabled for the event gets it.
* If a window with the correct noprop mask is reached, or if no window selects
* for the event, then the event is discarded.
*/
void GsDeliverKeyboardEvent(GR_WINDOW_ID wid, GR_EVENT_TYPE type,
GR_KEY keyvalue, GR_KEYMOD modifiers, GR_SCANCODE scancode)
{
GR_EVENT_KEYSTROKE *ep; /* keystroke event */
GR_WINDOW *wp; /* current window */
GR_WINDOW *tempwp; /* temporary window pointer */
GR_EVENT_CLIENT *ecp; /* current event client */
GR_WINDOW_ID subwid; /* subwindow id event is for */
GR_EVENT_MASK eventmask; /* event mask */
GR_WINDOW *kwp;
GR_GRABBED_KEY *keygrab;
eventmask = GR_EVENTMASK(type);
if (eventmask == 0)
return;
GsResetScreenSaver();
/* Check for grabbed keystroke.
* - GR_GRAB_HOTKEY events are sent (possibly multiple times) here,
* and the loop terminates normally with keygrab==NULL so the
* event is also delivered normally.
* - GR_GRAB_HOTKEY_EXCLUSIVE sends the hotkey events then returns.
* - Other exclusive events (GR_GRAB_EXCLUSIVE_MOUSE and GR_GRAB_EXCLUSIVE)
* cause the loop to terminate with keygrab != NULL. The checking
* for these events happens after the loop.
*
* Note: This algorithm requires any GR_GRAB_HOTKEY grabs to be
* listed _after_ any exclusive grabs for the same key. The
* GrGrabKey() and GrUngrabKey() methods ensure this property holds.
*/
for (keygrab = list_grabbed_keys; keygrab != NULL; keygrab = keygrab->next) {
if (keygrab->key == keyvalue) {
if ((keygrab->type == GR_GRAB_HOTKEY)
|| (keygrab->type == GR_GRAB_HOTKEY_EXCLUSIVE)) {
ep = (GR_EVENT_KEYSTROKE *) GsAllocEvent(keygrab->owner);
if (ep == NULL)
continue;
ep->type = type;
ep->wid = keygrab->wid;
ep->subwid = keygrab->wid;
ep->rootx = cursorx;
ep->rooty = cursory;
ep->x = cursorx;
ep->y = cursory;
ep->buttons = curbuttons;
ep->modifiers = modifiers;
ep->ch = keyvalue;
ep->scancode = scancode;
ep->hotkey = GR_TRUE;
if (keygrab->type == GR_GRAB_HOTKEY_EXCLUSIVE)
return; /* only one client gets it */
} else {
/* GR_GRAB_EXCLUSIVE or GR_GRAB_EXCLUSIVE_MOUSE */
break; /* found it, exit the loop. */
}
}
}
/* Handle a grabbed key:
* The associated window must be an ancestor of the focused window,
* or (for GR_GRAB_EXCLUSIVE_MOUSE only) a descendent that contains the
* pointer.
*/
if (keygrab != NULL) {
/* The key grab must be of type GR_GRAB_EXCLUSIVE or
* GR_GRAB_EXCLUSIVE_MOUSE
*/
/* Find the window that has the grab */
wp = GsFindWindow(keygrab->wid);
if (wp == NULL)
return; /* Key is reserved by window that doesn't exist. */
/* See if the grabbing window is an ancestor of the focussed window. */
kwp = focuswp;
while (kwp != wp && kwp != rootwp)
kwp = kwp->parent;
/* Want to send event if:
* GR_GRAB_EXCLUSIVE: grabbing window is an ancestor of focussed window
* GR_GRAB_EXCLUSIVE_MOUSE: same as GR_GRAB_EXCLUSIVE OR
* the mouse is in the grabbing window.
*/
if (kwp != wp && (keygrab->type != GR_GRAB_EXCLUSIVE_MOUSE || wp != mousewp))
return;
subwid = wp->id;
} else {
/* if window id passed, use it, otherwise focus window */
if (wid) {
kwp = GsFindWindow(wid);
if (!kwp)
return;
} else
kwp = focuswp;
wp = mousewp;
subwid = wp->id;
/*
* See if the actual window the pointer is in is a descendant of
* the focus window. If not, then ignore it, and force the input
* into the focus window itself.
*/
tempwp = wp;
while (tempwp != kwp && tempwp != rootwp)
tempwp = tempwp->parent;
if (tempwp != kwp) {
wp = kwp;
subwid = wp->id;
}
}
/*
* Now walk upwards looking for the first window which will accept
* the keyboard event. However, do not go beyond the focus window,
* and only give the event to one client.
*/
for (;;) {
for (ecp = wp->eventclients; ecp; ecp = ecp->next) {
if ((ecp->eventmask & eventmask) == 0)
continue;
ep = (GR_EVENT_KEYSTROKE *) GsAllocEvent(ecp->client);
if (ep == NULL)
return;
ep->type = type;
ep->wid = wp->id;
ep->subwid = subwid;
ep->rootx = cursorx;
ep->rooty = cursory;
ep->x = cursorx - wp->x;
ep->y = cursory - wp->y;
ep->buttons = curbuttons;
ep->modifiers = modifiers;
ep->ch = keyvalue;
ep->scancode = scancode;
ep->hotkey = GR_FALSE;
return; /* only one client gets it */
}
if ((wp == rootwp) || (wp == kwp) ||
(wp->nopropmask & eventmask))
return;
wp = wp->parent;
}
}
/*
* Deliver a mouse motion event to the clients which have selected for it.
* Each client can only be delivered one instance of the event. The window
* the event is delivered for is either the smallest one containing the
* mouse coordinates, or else one of its direct ancestors. The lowest
* window in that tree which has enabled for the event gets it. This scan
* is done independently for each client. If a window with the correct
* noprop mask is reached, or if no window selects for the event, then the
* event is discarded for that client. Special case: If the event type is
* GR_EVENT_TYPE_MOUSE_POSITION, then only the last such event is queued for
* any single client to reduce events. If the mouse is implicitly grabbed,
* then only the grabbing window receives the events, and continues to do
* so even if the mouse is currently outside of the grabbing window.
*/
void GsDeliverMotionEvent(GR_EVENT_TYPE type, int buttons, MWKEYMOD modifiers)
{
GR_EVENT_MOUSE *ep; /* mouse motion event */
GR_WINDOW *wp; /* current window */
GR_EVENT_CLIENT *ecp; /* current event client */
GR_CLIENT *client; /* current client */
GR_WINDOW_ID subwid; /* subwindow id event is for */
GR_EVENT_MASK eventmask; /* event mask */
eventmask = GR_EVENTMASK(type);
if (eventmask == 0)
return;
wp = mousewp;
subwid = wp->id;
if (grabbuttonwp) {
#if 0
while ((wp != rootwp) && (wp != grabbuttonwp))
wp = wp->parent;
if (wp != grabbuttonwp)
subwid = grabbuttonwp->id;
#endif
wp = grabbuttonwp;
}
for (;;) {
for (ecp = wp->eventclients; ecp; ecp = ecp->next) {
if ((ecp->eventmask & eventmask) == 0)
continue;
client = ecp->client;
/*
* If the event is for just the latest position,
* then search the event queue for an existing
* event of this type (if any), and free it.
*/
if (type == GR_EVENT_TYPE_MOUSE_POSITION)
GsFreePositionEvent(client, wp->id, subwid);
ep = (GR_EVENT_MOUSE *) GsAllocEvent(client);
if (ep == NULL)
continue;
ep->type = type;
ep->wid = wp->id;
ep->subwid = subwid;
ep->rootx = cursorx;
ep->rooty = cursory;
ep->x = cursorx - wp->x;
ep->y = cursory - wp->y;
ep->buttons = buttons;
ep->modifiers = modifiers;
}
if ((wp == rootwp) || grabbuttonwp ||
(wp->nopropmask & eventmask))
return;
wp = wp->parent;
}
}
/*
* Deliver a mouse button event to the clients which have selected for it.
* Each client can only be delivered one instance of the event. The window
* the event is delivered for is either the smallest one containing the
* mouse coordinates, or else one of its direct ancestors. The lowest
* window in that tree which has enabled for the event gets it. This scan
* is done independently for each client. If a window with the correct
* noprop mask is reached, or if no window selects for the event, then the
* event is discarded for that client. Special case: for the first client
* that is enabled for both button down and button up events in a window,
* then the pointer is implicitly grabbed by that window when a button is
* pressed down in that window. The grabbing remains until all buttons are
* released. While the pointer is grabbed, no other clients or windows can
* receive button down or up events.
*/
void GsDeliverButtonEvent(GR_EVENT_TYPE type, int buttons, int changebuttons,
int modifiers)
{
GR_EVENT_BUTTON *ep; /* mouse button event */
GR_WINDOW *wp; /* current window */
GR_EVENT_CLIENT *ecp; /* current event client */
GR_CLIENT *client; /* current client */
GR_WINDOW_ID subwid; /* subwindow id event is for */
GR_EVENT_MASK eventmask; /* event mask */
GR_EVENT_MASK tempmask; /* to get around compiler bug */
eventmask = GR_EVENTMASK(type);
if (eventmask == 0)
return;
/*
* If the pointer is implicitly grabbed, then the only window
* which can receive button events is that window. Otherwise
* the window the pointer is in gets the events. Determine the
* subwindow by seeing if it is a child of the grabbed button.
*/
wp = mousewp;
subwid = wp->id;
if (grabbuttonwp) {
#if 0
while ((wp != rootwp) && (wp != grabbuttonwp))
wp = wp->parent;
if (wp != grabbuttonwp)
subwid = grabbuttonwp->id;
#endif
wp = grabbuttonwp;
}
for (;;) {
for (ecp = wp->eventclients; ecp; ecp = ecp->next) {
if ((ecp->eventmask & eventmask) == 0)
continue;
client = ecp->client;
/*
* If this is a button down, the buttons are not
* yet grabbed, and this client is enabled for both
* button down and button up events, then implicitly
* grab the window for him.
*/
if ((type == GR_EVENT_TYPE_BUTTON_DOWN)
&& (grabbuttonwp == NULL))
{
tempmask = GR_EVENT_MASK_BUTTON_UP;
if (ecp->eventmask & tempmask) {
DPRINTF("nano-X: implicit grab on window %d\n", wp->id);
grabbuttonwp = wp;
}
}
ep = (GR_EVENT_BUTTON *) GsAllocEvent(client);
if (ep == NULL)
continue;
ep->type = type;
ep->wid = wp->id;
ep->subwid = subwid;
ep->rootx = cursorx;
ep->rooty = cursory;
ep->x = cursorx - wp->x;
ep->y = cursory - wp->y;
ep->buttons = buttons;
ep->changebuttons = changebuttons;
ep->modifiers = modifiers;
ep->time = GsGetTickCount();
}
/*
* Events do not propagate if the window was grabbed.
* Also release the grab if the buttons are now all released,
* which can cause various events.
*/
if (grabbuttonwp) {
if (buttons == 0) {
DPRINTF("nano-X: implicit ungrab on window %d\n", grabbuttonwp->id);
grabbuttonwp = NULL;
GrMoveCursor(cursorx, cursory);
}
return;
}
if ((wp == rootwp) || (wp->nopropmask & eventmask))
return;
wp = wp->parent;
}
}
/*
* Deliver a keyboard event to one of the clients which have selected for it.
* Only the first client found gets the event (no duplicates are sent). The
* window the event is delivered to is either the smallest one containing
* the mouse coordinates, or else one of its direct ancestors (if such a
* window is a descendant of the focus window), or else just the focus window.
* The lowest window in that tree which has enabled for the event gets it.
* If a window with the correct noprop mask is reached, or if no window selects
* for the event, then the event is discarded.
*/
void GsDeliverKeyboardEvent(GR_EVENT_TYPE type, GR_CHAR ch, MODIFIER modifiers)
{
GR_EVENT_KEYSTROKE *ep; /* keystroke event */
GR_WINDOW *wp; /* current window */
GR_WINDOW *tempwp; /* temporary window pointer */
GR_EVENT_CLIENT *ecp; /* current event client */
GR_WINDOW_ID subwid; /* subwindow id event is for */
GR_EVENT_MASK eventmask; /* event mask */
eventmask = GR_EVENTMASK(type);
if (eventmask == 0)
return;
wp = mousewp;
subwid = wp->id;
/*
* See if the actual window the pointer is in is a descendant of
* the focus window. If not, then ignore it, and force the input
* into the focus window itself.
*/
tempwp = wp;
while ((tempwp != focuswp) && (tempwp != rootwp))
tempwp = tempwp->parent;
if (tempwp != focuswp) {
wp = focuswp;
subwid = wp->id;
}
/*
* Now walk upwards looking for the first window which will accept
* the keyboard event. However, do not go beyond the focus window,
* and only give the event to one client.
*/
for (;;) {
for (ecp = wp->eventclients; ecp; ecp = ecp->next) {
if ((ecp->eventmask & eventmask) == 0)
continue;
ep = (GR_EVENT_KEYSTROKE *) GsAllocEvent(ecp->client);
if (ep == NULL)
return;
ep->type = type;
ep->wid = wp->id;
ep->subwid = subwid;
ep->rootx = cursorx;
ep->rooty = cursory;
ep->x = cursorx - wp->x;
ep->y = cursory - wp->y;
ep->buttons = curbuttons;
ep->modifiers = modifiers;
ep->ch = ch;
return; /* only one client gets it */
}
if ((wp == rootwp) || (wp == focuswp) ||
(wp->nopropmask & eventmask))
return;
wp = wp->parent;
}
}
