xserver: Branch 'master' - 7 commits
Peter Hutterer
whot at kemper.freedesktop.org
Mon Nov 24 15:50:14 PST 2008
dix/Makefile.am | 2
dix/devices.c | 4
dix/enterleave.c | 542 +++++++++++++++++++++++++++++++++++++++++++++++++++++++
dix/enterleave.h | 70 +++++++
dix/events.c | 286 ++++++++---------------------
include/input.h | 7
6 files changed, 698 insertions(+), 213 deletions(-)
New commits:
commit 3e6da1636093d7dc98baac40544c0b0fb7fd8aec
Author: Peter Hutterer <peter.hutterer at redhat.com>
Date: Fri Nov 14 15:55:57 2008 +1000
include: remove ENTER_LEAVE_SEMAPHORE macros.
diff --git a/include/input.h b/include/input.h
index 343542c..62f5449 100644
--- a/include/input.h
+++ b/include/input.h
@@ -97,12 +97,6 @@ SOFTWARE.
#define SEMAPHORE_FIELD_UNSET(win, dev, field) \
(win)->field[(dev)->id/8] &= ~(1 << ((dev)->id % 8));
-#define ENTER_LEAVE_SEMAPHORE_SET(win, dev) \
- SEMAPHORE_FIELD_SET(win, dev, enterleave);
-
-#define ENTER_LEAVE_SEMAPHORE_UNSET(win, dev) \
- SEMAPHORE_FIELD_UNSET(win, dev, enterleave);
-
#define FOCUS_SEMAPHORE_SET(win, dev) \
SEMAPHORE_FIELD_SET(win, dev, focusinout);
commit b292a7a2d7e259177e1cc37346c2bee27a018630
Author: Peter Hutterer <peter.hutterer at redhat.com>
Date: Fri Nov 14 15:44:29 2008 +1000
dix: updated enter/leave core event model.
As proposed by Owen Taylor [1], the enter-leave event model needs to adjust
the events sent to each window depending on the presence of pointers in a
window, or in a subwindow.
The new model can be summarised as:
- if the pointer moves into or out of a window that has a pointer in a child
window, the events are modified to appear as if the pointer was moved out of
or into this child window.
- if the pointer moves into or out of a window that has a pointer in a parent
window, the events are modified to appear as if the pointer was moved out of
or into this parent window.
Note that this model requires CoreEnterLeaveEvent and DeviceEnterLeaveEvent to
be split and treated separately.
[1] http://lists.freedesktop.org/archives/xorg/2008-August/037606.html
Signed-off-by: Peter Hutterer <peter.hutterer at redhat.com>
diff --git a/dix/devices.c b/dix/devices.c
index 33b723a..583ecc0 100644
--- a/dix/devices.c
+++ b/dix/devices.c
@@ -86,6 +86,7 @@ SOFTWARE.
#include "exevents.h"
#include "listdev.h" /* for CopySwapXXXClass */
#include "xiproperty.h"
+#include "enterleave.h" /* for EnterWindow() */
#include "xserver-properties.h"
/** @file
@@ -284,7 +285,8 @@ EnableDevice(DeviceIntPtr dev)
if (dev->spriteInfo->spriteOwner)
{
InitializeSprite(dev, WindowTable[0]);
- ENTER_LEAVE_SEMAPHORE_SET(WindowTable[0], dev);
+ /* mode doesn't matter */
+ EnterWindow(dev, WindowTable[0], NotifyAncestor);
}
else if ((other = NextFreePointerDevice()) == NULL)
{
diff --git a/dix/enterleave.c b/dix/enterleave.c
index 0f3b12f..8176f96 100644
--- a/dix/enterleave.c
+++ b/dix/enterleave.c
@@ -33,6 +33,80 @@
#include "exglobals.h"
#include "enterleave.h"
+/* @file This file describes the model for sending core enter/leave events in
+ * the case of multiple pointers.
+ * Since we can't send more than one Enter or Leave event per window
+ * to a core client without confusing it, this is a rather complicated
+ * approach.
+ *
+ * For a full description of the model from a window's perspective, see
+ * http://lists.freedesktop.org/archives/xorg/2008-August/037606.html
+ *
+ *
+ * EnterNotify(Virtual, B) means EnterNotify Event, detail Virtual, child = B.
+ *
+ * Pointer moves from A to B, nonlinear (CoreEnterLeaveNonLinear):
+ * 1. a. if A has another pointer, goto 2.
+ * b. otherwise, if A has a child with a pointer in it,
+ * LeaveNotify(Inferior) to A
+ * LeaveNotify(Virtual) between A and child(A)
+ *
+ * 2. Find common ancestor X between A and B.
+ * 3. Find closest pointer window P between A and X.
+ * a. if P exists
+ * LeaveNotify(Ancestor) to A
+ * LeaveNotify(Virtual) between A and P
+ * b. otherwise, if P does not exist,
+ * LeaveNotify(NonLinear) to A
+ * LeaveNotify(NonLinearVirtual) between A and X.
+ *
+ * 4. If X does not have a pointer, EnterNotify(NonLinearVirtual, B) to X.
+ * 5. Find closest pointer window P between X and B.
+ * a. if P exists, EnterNotify(NonLinearVirtual) between X and P
+ * b. otherwise, EnterNotify(NonLinearVirtual) between X and B
+ *
+ * 5. a. if B has another pointer in it, finish.
+ * b. otherwise, if B has a child with a pointer in it
+ * LeaveNotify(Virtual) between child(B) and B.
+ * EnterNotify(Inferior) to B.
+ * c. otherwise, EnterNotify(NonLinear) to B.
+ *
+ * --------------------------------------------------------------------------
+ *
+ * Pointer moves from A to B, A is a parent of B (CoreEnterLeaveToDescendant):
+ * 1. a. If A has another pointer, goto 2.
+ * b. Otherwise, LeaveNotify(Inferior) to A.
+ *
+ * 2. Find highest window X that has a pointer child that is not a child of B.
+ * a. if X exists, EnterNotify(Virtual, B) between A and X,
+ * EnterNotify(Virtual, B) to X (if X has no pointer).
+ * b. otherwise, EnterNotify(Virtual, B) between A and B.
+ *
+ * 3. a. if B has another pointer, finish
+ * b. otherwise, if B has a child with a pointer in it,
+ * LeaveNotify(Virtual, child(B)) between child(B) and B.
+ * EnterNotify(Inferior, child(B)) to B.
+ * c. otherwise, EnterNotify(Ancestor) to B.
+ *
+ * --------------------------------------------------------------------------
+ *
+ * Pointer moves from A to B, A is a child of B (CoreEnterLeaveToAncestor):
+ * 1. a. If A has another pointer, goto 2.
+ * b. Otherwise, if A has a child with a pointer in it.
+ * LeaveNotify(Inferior, child(A)) to A.
+ * EnterNotify(Virtual, child(A)) between A and child(A).
+ * Skip to 3.
+ *
+ * 2. Find closest pointer window P between A and B.
+ * If P does not exist, P is B.
+ * LeaveNotify(Ancestor) to A.
+ * LeaveNotify(Virtual, A) between A and P.
+ * 3. a. If B has another pointer, finish.
+ * b. otherwise, EnterNotify(Inferior) to B.
+ */
+
+#define WID(w) ((w) ? ((w)->drawable.id) : 0)
+
/**
* Return TRUE if @win has a pointer within its boundaries, excluding child
* window.
@@ -67,7 +141,7 @@ HasOtherPointer(WindowPtr win, DeviceIntPtr dev)
/**
* Set the presence flag for @dev to mark that it is now in @win.
*/
-static void
+void
EnterWindow(DeviceIntPtr dev, WindowPtr win, int mode)
{
win->enterleave[dev->id/8] |= (1 << (dev->id % 8));
@@ -253,6 +327,198 @@ FirstPointerAncestor(WindowPtr win, WindowPtr stopBefore)
}
/**
+ * Pointer @dev moves from @A to @B and @A neither a descendant of @B nor is
+ * @B a descendant of @A.
+ */
+static void
+CoreEnterLeaveNonLinear(DeviceIntPtr dev,
+ WindowPtr A,
+ WindowPtr B,
+ int mode)
+{
+ WindowPtr childA, childB, X, P;
+ BOOL hasPointerA = HasPointer(A);
+
+ /* 2 */
+ X = CommonAncestor(A, B);
+
+ /* 1.a */ /* 1.b */
+ if (!hasPointerA && (childA = FirstPointerChild(A, None)))
+ {
+ CoreEnterLeaveEvent(dev, LeaveNotify, mode, NotifyInferior, A, WID(childA));
+ EnterNotifies(dev, A, childA, mode, NotifyVirtual, TRUE);
+ } else {
+ /* 3 */
+ P = FirstPointerAncestor(A, X);
+
+ if (P)
+ {
+ if (!hasPointerA)
+ CoreEnterLeaveEvent(dev, LeaveNotify, mode, NotifyAncestor, A, None);
+ LeaveNotifies(dev, A, P, mode, NotifyVirtual, TRUE);
+ /* 3.b */
+ } else
+ {
+ if (!hasPointerA)
+ CoreEnterLeaveEvent(dev, LeaveNotify, mode, NotifyNonlinear, A, None);
+ LeaveNotifies(dev, A, X, mode, NotifyNonlinearVirtual, TRUE);
+ }
+ }
+
+ /* 4. */
+ if (!HasPointer(X))
+ CoreEnterLeaveEvent(dev, EnterNotify, mode, NotifyNonlinearVirtual, X, WID(B));
+
+ /* 5. */
+ P = FirstPointerChild(X, B);
+ if (!P)
+ P = B; /* 4.b */
+ EnterNotifies(dev, X, P, mode, NotifyNonlinearVirtual, TRUE);
+
+ /* 5.a */
+ if (!HasOtherPointer(B, dev))
+ {
+ /* 5.b */
+ if ((childB = FirstPointerChild(B, None)))
+ {
+ LeaveNotifies(dev, childB, B, mode, NotifyVirtual, TRUE);
+ CoreEnterLeaveEvent(dev, EnterNotify, mode, NotifyInferior, B, WID(childB));
+ } else
+ /* 5.c */
+ CoreEnterLeaveEvent(dev, EnterNotify, mode, NotifyNonlinear, B, None);
+ }
+}
+
+/**
+ * Pointer @dev moves from @A to @B and @A is a descendant of @B.
+ */
+static void
+CoreEnterLeaveToAncestor(DeviceIntPtr dev,
+ WindowPtr A,
+ WindowPtr B,
+ int mode)
+{
+ WindowPtr childA = NULL, P;
+ BOOL hasPointerA = HasPointer(A);
+
+ /* 1.a */ /* 1.b */
+ if (!hasPointerA && (childA = FirstPointerChild(A, None)))
+ {
+ CoreEnterLeaveEvent(dev, LeaveNotify, mode, NotifyInferior, A, WID(childA));
+ EnterNotifies(dev, A, childA, mode, NotifyVirtual, TRUE);
+ } else {
+ /* 2 */
+ P = FirstPointerAncestor(A, B);
+ if (!P)
+ P = B;
+
+ if (!hasPointerA)
+ CoreEnterLeaveEvent(dev, LeaveNotify, mode, NotifyAncestor, A, None);
+ LeaveNotifies(dev, A, P, mode, NotifyVirtual, TRUE);
+ }
+
+ /* 3 */
+ if (!HasOtherPointer(B, dev))
+ CoreEnterLeaveEvent(dev, EnterNotify, mode, NotifyInferior, B, None);
+
+}
+
+/**
+ * Pointer @dev moves from @A to @B and @B is a descendant of @A.
+ */
+static void
+CoreEnterLeaveToDescendant(DeviceIntPtr dev,
+ WindowPtr A,
+ WindowPtr B,
+ int mode)
+{
+ WindowPtr X, childB, tmp;
+
+ /* 1 */
+ if (!HasPointer(A))
+ CoreEnterLeaveEvent(dev, LeaveNotify, mode, NotifyInferior, A, WID(B));
+
+ /* 2 */
+ X = FirstPointerAncestor(B, A);
+ if (X)
+ {
+ /* 2.a */
+ tmp = X;
+ while((tmp = FirstPointerAncestor(tmp, A)))
+ X = tmp;
+ } else /* 2.b */
+ X = B;
+
+ EnterNotifies(dev, A, X, mode, NotifyVirtual, TRUE);
+
+ if (X != B && !HasPointer(X))
+ CoreEnterLeaveEvent(dev, LeaveNotify, mode, NotifyVirtual, X, None);
+
+ /* 3 */
+ if (!HasOtherPointer(B, dev))
+ {
+ childB = FirstPointerChild(B, None);
+ /* 3.a */
+ if (childB)
+ {
+ LeaveNotifies(dev, childB, B, mode, NotifyVirtual, TRUE);
+ CoreEnterLeaveEvent(dev, EnterNotify, mode, NotifyInferior, B, WID(childB));
+ } else /* 3.c */
+ CoreEnterLeaveEvent(dev, EnterNotify, mode, NotifyAncestor, B, None);
+ }
+}
+
+static void
+CoreEnterLeaveEvents(DeviceIntPtr dev,
+ WindowPtr from,
+ WindowPtr to,
+ int mode)
+{
+ if (!dev->isMaster)
+ return;
+
+ LeaveWindow(dev, from, mode);
+
+ if (IsParent(from, to))
+ CoreEnterLeaveToDescendant(dev, from, to, mode);
+ else if (IsParent(to, from))
+ CoreEnterLeaveToAncestor(dev, from, to, mode);
+ else
+ CoreEnterLeaveNonLinear(dev, from, to, mode);
+
+ EnterWindow(dev, to, mode);
+}
+
+static void
+DeviceEnterLeaveEvents(DeviceIntPtr dev,
+ WindowPtr from,
+ WindowPtr to,
+ int mode)
+{
+ if (IsParent(from, to))
+ {
+ DeviceEnterLeaveEvent(dev, DeviceLeaveNotify, mode, NotifyInferior, from, None);
+ EnterNotifies(dev, from, to, mode, NotifyVirtual, FALSE);
+ DeviceEnterLeaveEvent(dev, DeviceEnterNotify, mode, NotifyAncestor, to, None);
+ }
+ else if (IsParent(to, from))
+ {
+ DeviceEnterLeaveEvent(dev, DeviceLeaveNotify, mode, NotifyAncestor, from, None);
+ LeaveNotifies(dev, from, to, mode, NotifyVirtual, FALSE);
+ DeviceEnterLeaveEvent(dev, DeviceEnterNotify, mode, NotifyInferior, to, None);
+ }
+ else
+ { /* neither from nor to is descendent of the other */
+ WindowPtr common = CommonAncestor(to, from);
+ /* common == NullWindow ==> different screens */
+ DeviceEnterLeaveEvent(dev, DeviceLeaveNotify, mode, NotifyNonlinear, from, None);
+ LeaveNotifies(dev, from, common, mode, NotifyNonlinearVirtual, FALSE);
+ EnterNotifies(dev, common, to, mode, NotifyNonlinearVirtual, FALSE);
+ DeviceEnterLeaveEvent(dev, DeviceEnterNotify, mode, NotifyNonlinear, to, None);
+ }
+}
+
+/**
* Figure out if enter/leave events are necessary and send them to the
* appropriate windows.
*
diff --git a/dix/enterleave.h b/dix/enterleave.h
index 6e06226..99e2e46 100644
--- a/dix/enterleave.h
+++ b/dix/enterleave.h
@@ -63,4 +63,8 @@ extern void DeviceEnterLeaveEvent(DeviceIntPtr mouse,
WindowPtr pWin,
Window child);
+extern void EnterWindow(DeviceIntPtr dev,
+ WindowPtr win,
+ int mode);
+
#endif /* _ENTERLEAVE_H_ */
commit 724f83b87bb16472d4c328e35d2a477384b29f84
Author: Peter Hutterer <peter.hutterer at redhat.com>
Date: Fri Nov 14 15:29:01 2008 +1000
dix: add FirstPointerChild, FirstPointerAncestor auxiliary functions.
FirstPointerChild: Return the first child that has a pointer within its
boundaries.
FirstPointerAncestor: return the first ancestor with a child within its
boundaries.
These are required for the updated enter/leave model.
Signed-off-by: Peter Hutterer <peter.hutterer at redhat.com>
diff --git a/dix/enterleave.c b/dix/enterleave.c
index 57d1f1e..0f3b12f 100644
--- a/dix/enterleave.c
+++ b/dix/enterleave.c
@@ -153,6 +153,106 @@ LeaveNotifies(DeviceIntPtr dev,
}
/**
+ * Search for the first window below @win that has a pointer directly within
+ * it's boundaries (excluding boundaries of its own descendants).
+ * Windows including @exclude and its descendants are ignored.
+ *
+ * @return The child window that has the pointer within its boundaries or
+ * NULL.
+ */
+static WindowPtr
+FirstPointerChild(WindowPtr win, WindowPtr exclude)
+{
+ static WindowPtr *queue = NULL;
+ static int queue_size = 256; /* allocated size of queue */
+
+ WindowPtr child = NULL;
+ int queue_len = 0; /* no of elements in queue */
+ int queue_head = 0; /* pos of current element */
+
+ if (!win || win == exclude || !win->firstChild)
+ return NULL;
+
+ if (!queue && !(queue = xcalloc(queue_size, sizeof(WindowPtr))))
+ FatalError("[dix] FirstPointerChild: OOM.\n");
+
+ queue[0] = win;
+ queue_head = 0;
+ queue_len = 1;
+
+ while (queue_len--)
+ {
+ if (queue[queue_head] == exclude)
+ {
+ queue_head = (queue_head + 1) % queue_size;
+ continue;
+ }
+
+ if (queue[queue_head] != win && HasPointer(queue[queue_head]))
+ return queue[queue_head];
+
+ child = queue[queue_head]->firstChild;
+ /* pop children onto queue */
+ while(child)
+ {
+ queue_len++;
+ if (queue_len >= queue_size)
+ {
+ const int inc = 256;
+
+ queue = xrealloc(queue, (queue_size + inc) * sizeof(WindowPtr));
+ if (!queue)
+ FatalError("[dix] FirstPointerChild: OOM.\n");
+
+ /* Are we wrapped around? */
+ if (queue_head + queue_len > queue_size)
+ {
+ memmove(&queue[queue_head + inc], &queue[queue_head],
+ (queue_size - queue_head) * sizeof(WindowPtr));
+ queue_head += inc;
+ }
+
+ queue_size += inc;
+ }
+
+ queue[(queue_head + queue_len) % queue_size] = child;
+ child = child->nextSib;
+ }
+
+ queue_head = (queue_head + 1) % queue_size;
+ }
+
+ return NULL;
+}
+
+/**
+ * Find the first parent of @win that has a pointer or has a child window with
+ * a pointer. Traverses up to (and including) the root window if @stopBefore
+ * is NULL, otherwise it stops at @stopBefore.
+ * Neither @win nor @win's descendants nor @stopBefore are tested for having a
+ * pointer.
+ *
+ * @return the window or NULL if @stopBefore was reached.
+ */
+static WindowPtr
+FirstPointerAncestor(WindowPtr win, WindowPtr stopBefore)
+{
+ WindowPtr parent;
+
+ parent = win->parent;
+
+ while(parent && parent != stopBefore)
+ {
+ if (HasPointer(parent) || FirstPointerChild(parent, win))
+ return parent;
+
+ parent = parent->parent;
+ }
+
+ return NULL;
+}
+
+/**
* Figure out if enter/leave events are necessary and send them to the
* appropriate windows.
*
commit 7d3e595f93dcd3d334e766a9dea602c05affdbaf
Author: Peter Hutterer <peter.hutterer at redhat.com>
Date: Fri Nov 14 15:27:19 2008 +1000
dix: Add EnterWindow, LeaveWindow, HasPointer auxiliary functions.
These replace the ENTER_LEAVE_SEMAPHORE_* macros. Unused currently.
Signed-off-by: Peter Hutterer <peter.hutterer at redhat.com>
diff --git a/dix/enterleave.c b/dix/enterleave.c
index 11929c6..57d1f1e 100644
--- a/dix/enterleave.c
+++ b/dix/enterleave.c
@@ -34,6 +34,56 @@
#include "enterleave.h"
/**
+ * Return TRUE if @win has a pointer within its boundaries, excluding child
+ * window.
+ */
+static BOOL
+HasPointer(WindowPtr win)
+{
+ int i;
+
+ for (i = 0; i < sizeof(win->enterleave); i++)
+ if (win->enterleave[i])
+ return TRUE;
+
+ return FALSE;
+}
+
+static BOOL
+HasOtherPointer(WindowPtr win, DeviceIntPtr dev)
+{
+ int i;
+
+ for (i = 0; i < sizeof(win->enterleave); i++)
+ if (win->enterleave[i] &&
+ !(i == dev->id/8 && win->enterleave[i] == (1 << (dev->id % 8))))
+ {
+ return TRUE;
+ }
+
+ return FALSE;
+}
+
+/**
+ * Set the presence flag for @dev to mark that it is now in @win.
+ */
+static void
+EnterWindow(DeviceIntPtr dev, WindowPtr win, int mode)
+{
+ win->enterleave[dev->id/8] |= (1 << (dev->id % 8));
+}
+
+/**
+ * Unset the presence flag for @dev to mark that it is not in @win anymore.
+ */
+static void
+LeaveWindow(DeviceIntPtr dev, WindowPtr win, int mode)
+{
+ win->enterleave[dev->id/8] &= ~(1 << (dev->id % 8));
+}
+
+
+/**
* @return The window that is the first ancestor of both a and b.
*/
WindowPtr
commit 6bdc963cdabb4a2e77de7f00a1d062aa2b873f9b
Author: Peter Hutterer <peter.hutterer at redhat.com>
Date: Fri Nov 14 15:37:35 2008 +1000
dix: split enter/leave event handling into core and device handling.
Device events always need to be delivered, core events only in some cases.
Let's keep them completely separate so we can adjust core event delivery.
Signed-off-by: Peter Hutterer <peter.hutterer at redhat.com>
diff --git a/dix/enterleave.c b/dix/enterleave.c
index 941aa52..11929c6 100644
--- a/dix/enterleave.c
+++ b/dix/enterleave.c
@@ -30,6 +30,7 @@
#include <X11/X.h>
#include "windowstr.h"
+#include "exglobals.h"
#include "enterleave.h"
/**
@@ -47,46 +48,57 @@ CommonAncestor(
/**
- * Send enter notifies to all parent windows up to ancestor.
- * This function recurses.
+ * Send enter notifies to all windows between @ancestor and @child (excluding
+ * both). Events are sent running up the window hierarchy. This function
+ * recurses.
+ * If @core is TRUE, core events are sent, otherwise XI events will be sent.
*/
static void
-EnterNotifies(DeviceIntPtr pDev,
+EnterNotifies(DeviceIntPtr dev,
WindowPtr ancestor,
WindowPtr child,
int mode,
- int detail)
+ int detail,
+ BOOL core)
{
WindowPtr parent = child->parent;
if (ancestor == parent)
return;
- EnterNotifies(pDev, ancestor, parent, mode, detail);
- EnterLeaveEvent(pDev, EnterNotify, mode, detail, parent,
- child->drawable.id);
+ EnterNotifies(dev, ancestor, parent, mode, detail, core);
+ if (core)
+ CoreEnterLeaveEvent(dev, EnterNotify, mode, detail, parent,
+ child->drawable.id);
+ else
+ DeviceEnterLeaveEvent(dev, DeviceEnterNotify, mode, detail, parent,
+ child->drawable.id);
}
-
/**
- * Send leave notifies to all parent windows up to ancestor.
- * This function recurses.
+ * Send leave notifies to all windows between @child and @ancestor.
+ * Events are sent running up the hierarchy.
*/
static void
-LeaveNotifies(DeviceIntPtr pDev,
+LeaveNotifies(DeviceIntPtr dev,
WindowPtr child,
WindowPtr ancestor,
int mode,
- int detail)
+ int detail,
+ BOOL core)
{
- WindowPtr pWin;
+ WindowPtr win;
if (ancestor == child)
return;
- for (pWin = child->parent; pWin != ancestor; pWin = pWin->parent)
+ for (win = child->parent; win != ancestor; win = win->parent)
{
- EnterLeaveEvent(pDev, LeaveNotify, mode, detail, pWin,
- child->drawable.id);
- child = pWin;
+ if (core)
+ CoreEnterLeaveEvent(dev, LeaveNotify, mode, detail, win,
+ child->drawable.id);
+ else
+ DeviceEnterLeaveEvent(dev, DeviceLeaveNotify, mode, detail, win,
+ child->drawable.id);
+ child = win;
}
}
@@ -108,31 +120,7 @@ DoEnterLeaveEvents(DeviceIntPtr pDev,
if (fromWin == toWin)
return;
- if (IsParent(fromWin, toWin))
- {
- EnterLeaveEvent(pDev, LeaveNotify, mode, NotifyInferior, fromWin,
- None);
- EnterNotifies(pDev, fromWin, toWin, mode,
- NotifyVirtual);
- EnterLeaveEvent(pDev, EnterNotify, mode, NotifyAncestor, toWin, None);
- }
- else if (IsParent(toWin, fromWin))
- {
- EnterLeaveEvent(pDev, LeaveNotify, mode, NotifyAncestor, fromWin,
- None);
- LeaveNotifies(pDev, fromWin, toWin, mode, NotifyVirtual);
- EnterLeaveEvent(pDev, EnterNotify, mode, NotifyInferior, toWin, None);
- }
- else
- { /* neither fromWin nor toWin is descendent of the other */
- WindowPtr common = CommonAncestor(toWin, fromWin);
- /* common == NullWindow ==> different screens */
- EnterLeaveEvent(pDev, LeaveNotify, mode, NotifyNonlinear, fromWin,
- None);
- LeaveNotifies(pDev, fromWin, common, mode, NotifyNonlinearVirtual);
- EnterNotifies(pDev, common, toWin, mode, NotifyNonlinearVirtual);
- EnterLeaveEvent(pDev, EnterNotify, mode, NotifyNonlinear, toWin,
- None);
- }
-}
+ CoreEnterLeaveEvents(pDev, fromWin, toWin, mode);
+ DeviceEnterLeaveEvents(pDev, fromWin, toWin, mode);
+}
diff --git a/dix/enterleave.h b/dix/enterleave.h
index c1bfc3a..6e06226 100644
--- a/dix/enterleave.h
+++ b/dix/enterleave.h
@@ -50,4 +50,17 @@ extern WindowPtr CommonAncestor(
WindowPtr a,
WindowPtr b);
+extern void CoreEnterLeaveEvent(DeviceIntPtr mouse,
+ int type,
+ int mode,
+ int detail,
+ WindowPtr pWin,
+ Window child);
+extern void DeviceEnterLeaveEvent(DeviceIntPtr mouse,
+ int type,
+ int mode,
+ int detail,
+ WindowPtr pWin,
+ Window child);
+
#endif /* _ENTERLEAVE_H_ */
diff --git a/dix/events.c b/dix/events.c
index 0f63ca3..bfc8494 100644
--- a/dix/events.c
+++ b/dix/events.c
@@ -4184,7 +4184,7 @@ EventSuppressForWindow(WindowPtr pWin, ClientPtr client,
* Uses the paired keyboard to get some additional information.
*/
void
-EnterLeaveEvent(
+CoreEnterLeaveEvent(
DeviceIntPtr mouse,
int type,
int mode,
@@ -4197,12 +4197,6 @@ EnterLeaveEvent(
DeviceIntPtr keybd;
GrabPtr grab = mouse->deviceGrab.grab;
Mask mask;
- int inWindow; /* zero if no sprites are in window */
- Bool sendevent = FALSE;
-
- deviceEnterNotify *devEnterLeave;
- int mskidx;
- OtherInputMasks *inputMasks;
keybd = GetPairedDevice(mouse);
@@ -4250,44 +4244,7 @@ EnterLeaveEvent(
IsParent(focus, pWin)))
event.u.enterLeave.flags |= ELFlagFocus;
-
- /*
- * Sending multiple core enter/leave events to the same window confuse the
- * client.
- * We can send multiple events that have detail NotifyVirtual or
- * NotifyNonlinearVirtual however. For most clients anyway.
- *
- * For standard events (NotifyAncestor, NotifyInferior, NotifyNonlinear)
- * we only send an enter event for the first pointer to enter. A leave
- * event is sent for the last pointer to leave.
- *
- * For events with Virtual detail, we send them only to a window that does
- * not have a pointer inside.
- *
- * For a window tree in the form of
- *
- * A -> Bp -> C -> D
- * \ (where B and E have pointers)
- * -> Ep
- *
- * If the pointer moves from E into D, a LeaveNotify is sent to E, an
- * EnterNotify is sent to D, an EnterNotify with detail
- * NotifyNonlinearVirtual to C and nothing to B.
- */
-
- /* Clear bit for device, but don't worry about SDs. */
- if (mouse->isMaster && type == LeaveNotify &&
- (detail != NotifyVirtual && detail != NotifyNonlinearVirtual))
- if (mode != NotifyUngrab)
- ENTER_LEAVE_SEMAPHORE_UNSET(pWin, mouse);
-
- inWindow = EnterLeaveSemaphoresIsset(pWin);
-
- if(!inWindow || mode == NotifyGrab || mode == NotifyUngrab)
- sendevent = TRUE;
-
-
- if ((mask & filters[mouse->id][type]) && sendevent)
+ if ((mask & filters[mouse->id][type]))
{
if (grab)
TryClientEvents(rClient(grab), mouse, &event, 1, mask,
@@ -4297,18 +4254,81 @@ EnterLeaveEvent(
filters[mouse->id][type], NullGrab, 0);
}
- if (mouse->isMaster && type == EnterNotify &&
- (detail != NotifyVirtual && detail != NotifyNonlinearVirtual))
- if (mode != NotifyGrab)
- ENTER_LEAVE_SEMAPHORE_SET(pWin, mouse);
+ if ((type == EnterNotify) && (mask & KeymapStateMask))
+ {
+ xKeymapEvent ke;
+ ClientPtr client = grab ? rClient(grab)
+ : clients[CLIENT_ID(pWin->drawable.id)];
+ if (XaceHook(XACE_DEVICE_ACCESS, client, keybd, DixReadAccess))
+ bzero((char *)&ke.map[0], 31);
+ else
+ memmove((char *)&ke.map[0], (char *)&keybd->key->down[1], 31);
+
+ ke.type = KeymapNotify;
+ if (grab)
+ TryClientEvents(rClient(grab), keybd, (xEvent *)&ke, 1,
+ mask, KeymapStateMask, grab);
+ else
+ DeliverEventsToWindow(mouse, pWin, (xEvent *)&ke, 1,
+ KeymapStateMask, NullGrab, 0);
+ }
+}
+
+void
+DeviceEnterLeaveEvent(
+ DeviceIntPtr mouse,
+ int type,
+ int mode,
+ int detail,
+ WindowPtr pWin,
+ Window child)
+{
+ xEvent event;
+ GrabPtr grab = mouse->deviceGrab.grab;
+ deviceEnterNotify *devEnterLeave;
+ int mskidx;
+ OtherInputMasks *inputMasks;
+ Mask mask;
+ DeviceIntPtr keybd = GetPairedDevice(mouse);
+ BOOL sameScreen;
+
+ if (grab) {
+ mask = (pWin == grab->window) ? grab->eventMask : 0;
+ if (grab->ownerEvents)
+ mask |= EventMaskForClient(pWin, rClient(grab));
+ } else {
+ mask = pWin->eventMask | wOtherEventMasks(pWin);
+ }
/* we don't have enough bytes, so we squash flags and mode into
one byte, and use the last byte for the deviceid. */
- devEnterLeave = (deviceEnterNotify*)&event;
- devEnterLeave->type = (type == EnterNotify) ? DeviceEnterNotify :
- DeviceLeaveNotify;
- devEnterLeave->mode |= (event.u.enterLeave.flags << 4);
+ devEnterLeave = (deviceEnterNotify*)&event;
+ devEnterLeave->detail = detail;
+ devEnterLeave->time = currentTime.milliseconds;
+ devEnterLeave->rootX = mouse->spriteInfo->sprite->hot.x;
+ devEnterLeave->rootY = mouse->spriteInfo->sprite->hot.y;
+ FixUpEventFromWindow(mouse, &event, pWin, None, FALSE);
+ sameScreen = event.u.keyButtonPointer.sameScreen;
+
+ devEnterLeave->child = child;
+ devEnterLeave->type = type;
devEnterLeave->deviceid = mouse->id;
+ devEnterLeave->mode = mode;
+ devEnterLeave->mode |= (sameScreen ? (ELFlagSameScreen << 4) : 0);
+
+#ifdef XKB
+ if (!noXkbExtension) {
+ devEnterLeave->state = mouse->button->state & 0x1f00;
+ if (keybd)
+ devEnterLeave->state |=
+ XkbGrabStateFromRec(&keybd->key->xkbInfo->state);
+ } else
+#endif
+ {
+ devEnterLeave->state = (keybd) ? keybd->key->state : 0;
+ devEnterLeave->state |= mouse->button->state;
+ }
+
mskidx = mouse->id;
inputMasks = wOtherInputMasks(pWin);
if (inputMasks &&
@@ -4316,34 +4336,15 @@ EnterLeaveEvent(
inputMasks->deliverableEvents[mskidx]))
{
if (grab)
- (void)TryClientEvents(rClient(grab), mouse,
- (xEvent*)devEnterLeave, 1,
- mask, filters[mouse->id][devEnterLeave->type],
- grab);
- else
- (void)DeliverEventsToWindow(mouse, pWin, (xEvent*)devEnterLeave,
- 1, filters[mouse->id][devEnterLeave->type],
- NullGrab, mouse->id);
+ TryClientEvents(rClient(grab), mouse,
+ (xEvent*)devEnterLeave, 1, mask,
+ filters[mouse->id][devEnterLeave->type], grab);
+ else
+ DeliverEventsToWindow(mouse, pWin, (xEvent*)devEnterLeave, 1,
+ filters[mouse->id][devEnterLeave->type],
+ NullGrab, mouse->id);
}
- if ((type == EnterNotify) && (mask & KeymapStateMask))
- {
- xKeymapEvent ke;
- ClientPtr client = grab ? rClient(grab)
- : clients[CLIENT_ID(pWin->drawable.id)];
- if (XaceHook(XACE_DEVICE_ACCESS, client, keybd, DixReadAccess))
- bzero((char *)&ke.map[0], 31);
- else
- memmove((char *)&ke.map[0], (char *)&keybd->key->down[1], 31);
-
- ke.type = KeymapNotify;
- if (grab)
- (void)TryClientEvents(rClient(grab), keybd, (xEvent *)&ke, 1,
- mask, KeymapStateMask, grab);
- else
- (void)DeliverEventsToWindow(mouse, pWin, (xEvent *)&ke, 1,
- KeymapStateMask, NullGrab, 0);
- }
}
static void
commit 5e48f5e2dd2dec7cfd1fa40b61e25123dfca515e
Author: Peter Hutterer <peter.hutterer at redhat.com>
Date: Fri Nov 14 15:41:59 2008 +1000
dix: remove unused EnterLeaveSemaphoresIsset.
Signed-off-by: Peter Hutterer <peter.hutterer at redhat.com>
diff --git a/dix/events.c b/dix/events.c
index 77ca3d2..0f63ca3 100644
--- a/dix/events.c
+++ b/dix/events.c
@@ -6149,21 +6149,6 @@ ExtGrabDevice(ClientPtr client,
}
/*
- * @return Zero if no device is currently in window, non-zero otherwise.
- */
-int
-EnterLeaveSemaphoresIsset(WindowPtr win)
-{
- int set = 0;
- int i;
-
- for (i = 0; i < (MAXDEVICES + 7)/8; i++)
- set += win->enterleave[i];
-
- return set;
-}
-
-/*
* @return Zero if no devices has focus on the window, non-zero otherwise.
*/
int
diff --git a/include/input.h b/include/input.h
index 30457f3..343542c 100644
--- a/include/input.h
+++ b/include/input.h
@@ -512,7 +512,6 @@ extern int AllocMasterDevice(ClientPtr client,
extern void DeepCopyDeviceClasses(DeviceIntPtr from,
DeviceIntPtr to);
-extern int EnterLeaveSemaphoresIsset(WindowPtr win);
extern int FocusSemaphoresIsset(WindowPtr win);
/* Implemented by the DDX. */
commit 868fd503b7aeab31dba72046b59061008d8b7501
Author: Peter Hutterer <peter.hutterer at redhat.com>
Date: Fri Nov 14 15:18:56 2008 +1000
dix: move Enter-Leave related functions into new enterleave.c
Preparation for the new core enter/leave model.
Signed-off-by: Peter Hutterer <peter.hutterer at redhat.com>
diff --git a/dix/Makefile.am b/dix/Makefile.am
index a4b48c8..4c2395d 100644
--- a/dix/Makefile.am
+++ b/dix/Makefile.am
@@ -14,6 +14,8 @@ libdix_la_SOURCES = \
dispatch.h \
dixfonts.c \
dixutils.c \
+ enterleave.c \
+ enterleave.h \
events.c \
extension.c \
ffs.c \
diff --git a/dix/enterleave.c b/dix/enterleave.c
new file mode 100644
index 0000000..941aa52
--- /dev/null
+++ b/dix/enterleave.c
@@ -0,0 +1,138 @@
+/*
+ * Copyright © 2008 Red Hat, Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ *
+ * Authors: Peter Hutterer
+ *
+ */
+
+#ifdef HAVE_DIX_CONFIG_H
+#include <dix-config.h>
+#endif
+
+#include <X11/X.h>
+#include "windowstr.h"
+#include "enterleave.h"
+
+/**
+ * @return The window that is the first ancestor of both a and b.
+ */
+WindowPtr
+CommonAncestor(
+ WindowPtr a,
+ WindowPtr b)
+{
+ for (b = b->parent; b; b = b->parent)
+ if (IsParent(b, a)) return b;
+ return NullWindow;
+}
+
+
+/**
+ * Send enter notifies to all parent windows up to ancestor.
+ * This function recurses.
+ */
+static void
+EnterNotifies(DeviceIntPtr pDev,
+ WindowPtr ancestor,
+ WindowPtr child,
+ int mode,
+ int detail)
+{
+ WindowPtr parent = child->parent;
+
+ if (ancestor == parent)
+ return;
+ EnterNotifies(pDev, ancestor, parent, mode, detail);
+ EnterLeaveEvent(pDev, EnterNotify, mode, detail, parent,
+ child->drawable.id);
+}
+
+
+/**
+ * Send leave notifies to all parent windows up to ancestor.
+ * This function recurses.
+ */
+static void
+LeaveNotifies(DeviceIntPtr pDev,
+ WindowPtr child,
+ WindowPtr ancestor,
+ int mode,
+ int detail)
+{
+ WindowPtr pWin;
+
+ if (ancestor == child)
+ return;
+ for (pWin = child->parent; pWin != ancestor; pWin = pWin->parent)
+ {
+ EnterLeaveEvent(pDev, LeaveNotify, mode, detail, pWin,
+ child->drawable.id);
+ child = pWin;
+ }
+}
+
+/**
+ * Figure out if enter/leave events are necessary and send them to the
+ * appropriate windows.
+ *
+ * @param fromWin Window the sprite moved out of.
+ * @param toWin Window the sprite moved into.
+ */
+void
+DoEnterLeaveEvents(DeviceIntPtr pDev,
+ WindowPtr fromWin,
+ WindowPtr toWin,
+ int mode)
+{
+ if (!IsPointerDevice(pDev))
+ return;
+
+ if (fromWin == toWin)
+ return;
+ if (IsParent(fromWin, toWin))
+ {
+ EnterLeaveEvent(pDev, LeaveNotify, mode, NotifyInferior, fromWin,
+ None);
+ EnterNotifies(pDev, fromWin, toWin, mode,
+ NotifyVirtual);
+ EnterLeaveEvent(pDev, EnterNotify, mode, NotifyAncestor, toWin, None);
+ }
+ else if (IsParent(toWin, fromWin))
+ {
+ EnterLeaveEvent(pDev, LeaveNotify, mode, NotifyAncestor, fromWin,
+ None);
+ LeaveNotifies(pDev, fromWin, toWin, mode, NotifyVirtual);
+ EnterLeaveEvent(pDev, EnterNotify, mode, NotifyInferior, toWin, None);
+ }
+ else
+ { /* neither fromWin nor toWin is descendent of the other */
+ WindowPtr common = CommonAncestor(toWin, fromWin);
+ /* common == NullWindow ==> different screens */
+ EnterLeaveEvent(pDev, LeaveNotify, mode, NotifyNonlinear, fromWin,
+ None);
+ LeaveNotifies(pDev, fromWin, common, mode, NotifyNonlinearVirtual);
+ EnterNotifies(pDev, common, toWin, mode, NotifyNonlinearVirtual);
+ EnterLeaveEvent(pDev, EnterNotify, mode, NotifyNonlinear, toWin,
+ None);
+ }
+}
+
diff --git a/dix/enterleave.h b/dix/enterleave.h
new file mode 100644
index 0000000..c1bfc3a
--- /dev/null
+++ b/dix/enterleave.h
@@ -0,0 +1,53 @@
+/*
+ * Copyright © 2008 Red Hat, Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ *
+ * Authors: Peter Hutterer
+ *
+ */
+
+#ifdef HAVE_DIX_CONFIG_H
+#include <dix-config.h>
+#endif
+
+#ifndef ENTERLEAVE_H
+#define ENTERLEAVE_H
+
+extern void DoEnterLeaveEvents(
+ DeviceIntPtr pDev,
+ WindowPtr fromWin,
+ WindowPtr toWin,
+ int mode
+);
+
+extern void EnterLeaveEvent(
+ DeviceIntPtr mouse,
+ int type,
+ int mode,
+ int detail,
+ WindowPtr pWin,
+ Window child);
+
+extern WindowPtr CommonAncestor(
+ WindowPtr a,
+ WindowPtr b);
+
+#endif /* _ENTERLEAVE_H_ */
diff --git a/dix/events.c b/dix/events.c
index 27601b7..77ca3d2 100644
--- a/dix/events.c
+++ b/dix/events.c
@@ -164,6 +164,8 @@ typedef const char *string;
#include "geext.h"
#include "geint.h"
+#include "enterleave.h"
+
/**
* Extension events type numbering starts at EXTENSION_EVENT_BASE.
*/
@@ -326,13 +328,6 @@ IsKeyboardDevice(DeviceIntPtr dev)
return (dev->key && dev->kbdfeed) && !IsPointerDevice(dev);
}
-static void DoEnterLeaveEvents(
- DeviceIntPtr pDev,
- WindowPtr fromWin,
- WindowPtr toWin,
- int mode
-);
-
static WindowPtr XYToWindow(
DeviceIntPtr pDev,
int x,
@@ -4185,23 +4180,10 @@ EventSuppressForWindow(WindowPtr pWin, ClientPtr client,
}
/**
- * @return The window that is the first ancestor of both a and b.
- */
-static WindowPtr
-CommonAncestor(
- WindowPtr a,
- WindowPtr b)
-{
- for (b = b->parent; b; b = b->parent)
- if (IsParent(b, a)) return b;
- return NullWindow;
-}
-
-/**
* Assembles an EnterNotify or LeaveNotify and sends it event to the client.
* Uses the paired keyboard to get some additional information.
*/
-static void
+void
EnterLeaveEvent(
DeviceIntPtr mouse,
int type,
@@ -4364,98 +4346,6 @@ EnterLeaveEvent(
}
}
-/**
- * Send enter notifies to all parent windows up to ancestor.
- * This function recurses.
- */
-static void
-EnterNotifies(DeviceIntPtr pDev,
- WindowPtr ancestor,
- WindowPtr child,
- int mode,
- int detail)
-{
- WindowPtr parent = child->parent;
-
- if (ancestor == parent)
- return;
- EnterNotifies(pDev, ancestor, parent, mode, detail);
- EnterLeaveEvent(pDev, EnterNotify, mode, detail, parent,
- child->drawable.id);
-}
-
-
-/**
- * Send leave notifies to all parent windows up to ancestor.
- * This function recurses.
- */
-static void
-LeaveNotifies(DeviceIntPtr pDev,
- WindowPtr child,
- WindowPtr ancestor,
- int mode,
- int detail)
-{
- WindowPtr pWin;
-
- if (ancestor == child)
- return;
- for (pWin = child->parent; pWin != ancestor; pWin = pWin->parent)
- {
- EnterLeaveEvent(pDev, LeaveNotify, mode, detail, pWin,
- child->drawable.id);
- child = pWin;
- }
-}
-
-
-
-/**
- * Figure out if enter/leave events are necessary and send them to the
- * appropriate windows.
- *
- * @param fromWin Window the sprite moved out of.
- * @param toWin Window the sprite moved into.
- */
-static void
-DoEnterLeaveEvents(DeviceIntPtr pDev,
- WindowPtr fromWin,
- WindowPtr toWin,
- int mode)
-{
- if (!IsPointerDevice(pDev))
- return;
-
- if (fromWin == toWin)
- return;
- if (IsParent(fromWin, toWin))
- {
- EnterLeaveEvent(pDev, LeaveNotify, mode, NotifyInferior, fromWin,
- None);
- EnterNotifies(pDev, fromWin, toWin, mode,
- NotifyVirtual);
- EnterLeaveEvent(pDev, EnterNotify, mode, NotifyAncestor, toWin, None);
- }
- else if (IsParent(toWin, fromWin))
- {
- EnterLeaveEvent(pDev, LeaveNotify, mode, NotifyAncestor, fromWin,
- None);
- LeaveNotifies(pDev, fromWin, toWin, mode, NotifyVirtual);
- EnterLeaveEvent(pDev, EnterNotify, mode, NotifyInferior, toWin, None);
- }
- else
- { /* neither fromWin nor toWin is descendent of the other */
- WindowPtr common = CommonAncestor(toWin, fromWin);
- /* common == NullWindow ==> different screens */
- EnterLeaveEvent(pDev, LeaveNotify, mode, NotifyNonlinear, fromWin,
- None);
- LeaveNotifies(pDev, fromWin, common, mode, NotifyNonlinearVirtual);
- EnterNotifies(pDev, common, toWin, mode, NotifyNonlinearVirtual);
- EnterLeaveEvent(pDev, EnterNotify, mode, NotifyNonlinear, toWin,
- None);
- }
-}
-
static void
FocusEvent(DeviceIntPtr dev, int type, int mode, int detail, WindowPtr pWin)
{
More information about the xorg-commit
mailing list