# Copyright 2007 Sun Microsystems, Inc.  All rights reserved.

# Use subject to license terms.

#

# 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, and/or sell copies of the Software, and to permit persons

# to whom the Software is furnished to do so, provided that the above

# copyright notice(s) and this permission notice appear in all copies of

# the Software and that both the above copyright notice(s) and this

# permission notice appear in supporting documentation.

# 

# 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

# OF THIRD PARTY RIGHTS. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR

# HOLDERS INCLUDED IN THIS NOTICE BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL

# INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING

# FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,

# NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION

# WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

# 

# Except as contained in this notice, the name of a copyright holder

# shall not be used in advertising or otherwise to promote the sale, use

# or other dealings in this Software without prior written authorization

# of the copyright holder.

diff -urp -x '*~' -x '*.orig' Xext/Makefile.am Xext/Makefile.am

@@ -153,6 +153,12 @@ endif

 TSOL_SRCS = tsolCompat.c

 BUILTIN_SRCS += $(TSOL_SRCS)

+# Project Looking Glass Extension

+LGE_SRCS = lge.c

+if LGE

+BUILTIN_SRCS += $(LGE_SRCS)

+endif

+

 # Now take all of the above, mix well, bake for 10 minutes and get libXext*.la

 libXext_la_SOURCES =		$(BUILTIN_SRCS) $(MODULE_SRCS)

@@ -182,5 +188,6 @@ EXTRA_DIST = \

 	$(EXTRA_MULTIBUFFER_SRCS) \

 	$(FONTCACHE_SRCS) \

 	$(BIGFONT_SRCS) \

-	$(DPMS_SRCS)

+	$(DPMS_SRCS) \

+	$(LGE_SRCS) 

diff -urp -x '*~' -x '*.orig' configure.ac configure.ac

 AC_ARG_ENABLE(xcalibrate,     AS_HELP_STRING([--enable-xcalibrate], [Build XCalibrate extension (default: disabled)]), [XCALIBRATE=$enableval], [XCALIBRATE=no])

 AC_ARG_ENABLE(tslib,          AS_HELP_STRING([--enable-tslib], [Build kdrive tslib touchscreen support (default: disabled)]), [TSLIB=$enableval], [TSLIB=no])

 AC_ARG_ENABLE(xevie,          AS_HELP_STRING([--disable-xevie], [Build XEvIE extension (default: enabled)]), [XEVIE=$enableval], [XEVIE=yes])

+AC_ARG_ENABLE(lge,            AS_HELP_STRING([--disable-lge], [Build Project Looking Glass extension (default: enabled)]), [LGE=$enableval], [LGE=yes])

 AC_ARG_ENABLE(cup,            AS_HELP_STRING([--disable-cup], [Build TOG-CUP extension (default: enabled)]), [CUP=$enableval], [CUP=yes])

 AC_ARG_ENABLE(evi,            AS_HELP_STRING([--disable-evi], [Build Extended-Visual-Information extension (default: enabled)]), [EVI=$enableval], [EVI=yes])

 AC_ARG_ENABLE(multibuffer,    AS_HELP_STRING([--enable-multibuffer], [Build Multibuffer extension (default: disabled)]), [MULTIBUFFER=$enableval], [MULTIBUFFER=no])

 	REQUIRED_MODULES="$REQUIRED_MODULES evieproto"

 fi

+AM_CONDITIONAL(LGE, [test "x$LGE" = xyes])

+if test "x$LGE" = xyes; then

+	AC_DEFINE(LGE, 1, [Build Project Looking Glass extension])

+	REQUIRED_MODULES="$REQUIRED_MODULES lg3dproto"

+fi

+

 AM_CONDITIONAL(APPGROUP, [test "x$APPGROUP" = xyes])

 if test "x$APPGROUP" = xyes; then

 	if test "x$XACE" != xyes || test "x$XCSECURITY" != xyes; then

 PKG_CHECK_MODULES([XSERVERCFLAGS], [$REQUIRED_MODULES $REQUIRED_LIBS])

 PKG_CHECK_MODULES([XSERVERLIBS], [$REQUIRED_LIBS])

-XSERVER_CFLAGS="${XSERVERCFLAGS_CFLAGS}"

+XSERVER_CFLAGS="${XSERVERCFLAGS_CFLAGS} -DLG3D"

 LIBS="${LIBS} -lproject"

 XSERVER_LIBS="${XSERVERLIBS_LIBS} ${SYS_LIBS} ${LIBS}"

 AC_SUBST([SYS_LIBS])

diff -urp -x '*~' -x '*.orig' dix/Makefile.am dix/Makefile.am

@@ -30,7 +30,8 @@ libdix_la_SOURCES = 	\

 	swapreq.c	\

 	tables.c	\

 	window.c	\

-	strcasecmp.c

+	strcasecmp.c    \

+        xytosubwin.c

 libxpstubs_la_SOURCES =	\

 	xpstubs.c

diff -urp -x '*~' -x '*.orig' dix/events.c dix/events.c

@@ -167,6 +167,23 @@ xEvent *xeviexE;

 #include "dixgrabs.h"

 #include "dispatch.h"

+#ifdef LG3D

+

+#include <X11/extensions/damagewire.h>

+#include "../Xext/lgeint.h"

+

+extern void

+fillSpriteTraceFromRootToWin (WindowPtr pWin);

+

+extern WindowPtr XYToSubWindow (WindowPtr pWin, int x, int y, 

+				int *xWinRel, int *yWinRel);

+

+Bool PointInBorderSize(WindowPtr pWin, int x, int y);

+

+extern Window GetLgPrwFromSprite(void);

+

+#endif /* LG3D */

+

 #define EXTENSION_EVENT_BASE  64

 #define NoSuchEvent 0x80000000	/* so doesn't match NoEventMask */

@@ -230,10 +247,18 @@ static struct {

  * windows between the root and the current pointer window each time a button

  * or key goes down. The grabs on each of those windows must be checked.

  */

+#ifdef LG3D

+WindowPtr *spriteTrace = (WindowPtr *)NULL;

+WindowPtr lgeCurrentRootWin;

+#define ROOT spriteTrace[0]

+int spriteTraceSize = 0;

+int spriteTraceGood;

+#else

 static WindowPtr *spriteTrace = (WindowPtr *)NULL;

 #define ROOT spriteTrace[0]

 static int spriteTraceSize = 0;

 static int spriteTraceGood;

+#endif /* LG3D */

 static  struct {

     CursorPtr	current;

@@ -255,6 +280,15 @@ static  struct {

 #endif

 } sprite;			/* info about the cursor sprite */

+#ifdef LG3D

+typedef struct virtual_sprite {

+    WindowPtr win;              /* The top-level window the sprite is in (or PRW) */

+    HotSpot   hot;		/* Sprite location relative to win */

+} VirtualSprite;

+

+static VirtualSprite virtualSprite = { NULL, {0, 0} };

+#endif /* LG3D */

+

 #ifdef XEVIE

 _X_EXPORT WindowPtr xeviewin;

 _X_EXPORT HotSpot xeviehot;

@@ -1160,7 +1194,28 @@ ComputeFreezes()

 	count = replayDev->sync.evcount;

 	syncEvents.replayDev = (DeviceIntPtr)NULL;

+#ifdef LG3D	

+	{ WindowPtr pWin = (WindowPtr) LookupIDByType(XE_KBPTR.event, RT_WINDOW);

+	  if (lgeDisplayServerIsAlive && GetLgePRWForRoot(pWin)) {

+	      if (sprite.hotPhys.pScreen != pWin->drawable.pScreen) {

+		  w = XYToSubWindow(pWin, 

+				    xE->u.keyButtonPointer.eventX, xE->u.keyButtonPointer.eventY,

+				    &virtualSprite.hot.x, &virtualSprite.hot.y);

+		  if (IsWinLgePRWOne(w->drawable.id)) {

+		      ErrorF("ComputeFreezes %d %d seq %d\n", (int)xE->u.keyButtonPointer.event,

+			     (int)w->drawable.id, xE->u.u.sequenceNumber);

+		  }

+	      } else {

+    	    	w = XYToWindow( XE_KBPTR.rootX, XE_KBPTR.rootY);	

+	      }

+	  } else {

+	      w = XYToWindow( XE_KBPTR.rootX, XE_KBPTR.rootY);	

+	  }

+	}

+#else

         w = XYToWindow( XE_KBPTR.rootX, XE_KBPTR.rootY);

+#endif /* LG3D */

+

 	for (i = 0; i < spriteTraceGood; i++)

 	{

 	    if (syncEvents.replayWin == spriteTrace[i])

@@ -1770,6 +1825,151 @@ MaybeDeliverEventsToClient(register Wind

     return 2;

 }

+#ifdef LG3D

+

+/*

+** Returns true if the event type is one which was generated

+** by an input device. These are the only types of events

+** which been sent to the Display Server so they are the only

+** types of events which have the event field already set.

+**

+** TODO: this macro does not yet support XINPUT devices.

+*/

+

+#define EVENT_IS_DEVICE_EVENT(e) \

+    ((e)->u.u.type == KeyPress      || \

+     (e)->u.u.type == KeyRelease    || \

+     (e)->u.u.type == ButtonPress   || \

+     (e)->u.u.type == ButtonRelease || \

+     (e)->u.u.type == MotionNotify)

+

+static void

+lgeFixUpEventFromPRW(

+    xEvent *xE,

+    WindowPtr pWin,

+    Window child,

+    Bool calcChild)

+{

+    XE_KBPTR.root = ROOT->drawable.id;

+

+    /* 

+    ** If the non-3D event is going to the DS (e.g. because 

+    ** of a grab) make the the coordinates relative to the PRW 

+    ** (that is, screen absolute),

+    */

+

+    if (!IsWinLgePRWOne(XE_KBPTR.event)) {

+	WindowPtr pOldWin = (WindowPtr) LookupIDByType(XE_KBPTR.event, RT_WINDOW);

+	if (pOldWin != NULL) {

+	    XE_KBPTR.eventX = XE_KBPTR.rootX;

+	    XE_KBPTR.eventY = XE_KBPTR.rootY;

+	}

+    }

+

+    XE_KBPTR.event = pWin->drawable.id;

+

+    if (sprite.hot.pScreen != pWin->drawable.pScreen)

+    {

+	XE_KBPTR.sameScreen = xFalse;

+        /*

+	XE_KBPTR.child = None;

+	XE_KBPTR.eventX = 0;

+	XE_KBPTR.eventY = 0;

+	*/

+    } else {

+	XE_KBPTR.sameScreen = xTrue;

+    }

+}

+

+static void

+lgeFixUpEventFromXWindow(

+    xEvent *xE,

+    WindowPtr pWin,

+    Window child,

+    Bool calcChild)

+{

+    Window eventWindowOld = INVALID;

+

+    if (calcChild)

+    {

+        WindowPtr w=spriteTrace[spriteTraceGood-1];

+	/* If the search ends up past the root should the child field be 

+	   set to none or should the value in the argument be passed 

+	   through. It probably doesn't matter since everyone calls 

+	   this function with child == None anyway. */

+

+        while (w) 

+        {

+            /* If the source window is same as event window, child should be

+	       none.  Don't bother going all all the way back to the root. */

+

+ 	    if (w == pWin)

+	    { 

+   		child = None;

+ 		break;

+	    }

+	    

+	    if (w->parent == pWin)

+	    {

+		child = w->drawable.id;

+		break;

+            }

+ 	    w = w->parent;

+        } 	    

+    }

+

+    XE_KBPTR.root = WindowTable[sprite.hotPhys.pScreen->myNum]->drawable.id;    

+    eventWindowOld = XE_KBPTR.event;

+    XE_KBPTR.event = pWin->drawable.id;

+

+    XE_KBPTR.sameScreen = xTrue;

+    if (sprite.hot.pScreen != pWin->drawable.pScreen)

+    {

+	XE_KBPTR.sameScreen = xFalse;

+	/*

+	XE_KBPTR.child = None;

+	XE_KBPTR.eventX = 0;

+	XE_KBPTR.eventY = 0;

+	*/

+	/* TODO: Amir commented this out. Does we really want to not return? */

+	return;

+    }

+

+    XE_KBPTR.child = child;

+

+    /* 

+    ** The only events needing fixup at this point are mouse events

+    ** where the event window has been changed.

+    */

+    if ((xE->u.u.type == ButtonPress   ||

+	 xE->u.u.type == ButtonRelease  ||

+	 xE->u.u.type == MotionNotify)  &&

+	eventWindowOld != XE_KBPTR.event) {

+

+	/* TODO: it would be good to avoid a resource lookup here. Some sort of 

+	   caching might optimize this */

+	WindowPtr pOuterWin = (WindowPtr) LookupIDByType(eventWindowOld, RT_WINDOW);

+	if (pOuterWin == NULL) {

+	    /*

+	    ** This can happen if the window has died since the pick on the window

+	    ** occurred. So we don't need to be verbose about it.

+	    ErrorF("Error: FixupEventFromWindow: outer window %d, not found. No XY fix up occuring.\n",

+	           eventWindowOld);

+	    */

+	} else {

+	    /* 

+	    ** Make the event coords relative to the destination window

+	    ** instead of relative to the outer window.

+	    */

+	    XE_KBPTR.eventX -= pWin->drawable.x - pOuterWin->drawable.x;

+	    XE_KBPTR.eventY -= pWin->drawable.y - pOuterWin->drawable.y;

+	    /*ErrorF("new eventxy = %d, %d", XE_KBPTR.eventX, XE_KBPTR.eventY);*/

+	}		    

+    }

+}

+

+#endif /* LG3D */

+

 static void

 FixUpEventFromWindow(

     xEvent *xE,

@@ -1777,6 +1977,17 @@ FixUpEventFromWindow(

     Window child,

     Bool calcChild)

 {

+#ifdef LG3D

+    if (lgeDisplayServerIsAlive && GetLgePRWForRoot(pWin)) {

+	if (EVENT_IS_DEVICE_EVENT(xE) && IsWinLgePRWOne(pWin->drawable.id)) {

+	    lgeFixUpEventFromPRW(xE, pWin, child, calcChild);

+	} else {

+	    lgeFixUpEventFromXWindow(xE, pWin, child, calcChild);

+	}

+	return;

+    }

+#endif /* LG3D */

+

     if (calcChild)

     {

         WindowPtr w=spriteTrace[spriteTraceGood-1];

@@ -1824,6 +2035,163 @@ FixUpEventFromWindow(

     }

 }

+#ifdef LG3D

+

+/* 

+** Fix LG3D bug 293.

+** This is similar to CheckMotion, but for button events 

+*/

+

+static WindowPtr

+lg3dDetermineButtonDestWindow (xEvent *xE, WindowPtr spriteWin)

+{

+   WindowPtr pEventWin;

+   WindowPtr pDestWin;

+   int       xDummy, yDummy;

+

+   if (!lgeDisplayServerIsAlive) {

+       /* Backwards compatibility: the LG DS isn't running */

+       return spriteWin;

+   } 

+

+   if (IsWinLgePRWOne(XE_KBPTR.event)) {

+       /* This is a 3D event. Always send these to the PRW */

+       return GetLgePRWWinFor(XE_KBPTR.event);

+   }

+

+   /* 

+   ** At this point, we know that it is a 2D native window event.

+   ** Determine the appropriate subwindow to which the event should be sent.

+   */

+   pEventWin = (WindowPtr) LookupIDByType(XE_KBPTR.event, RT_WINDOW); 

+   if (pEventWin == NULL) {

+       /* 

+       ** This may happen if the top-level destination window has been destroyed

+       ** since the pick was performed. So just make sure that the event is discarded.

+       */

+       return NULL;

+   }

+

+   pDestWin = XYToSubWindow(pEventWin, XE_KBPTR.eventX, XE_KBPTR.eventY,

+			    &xDummy, &yDummy);

+

+   return pDestWin;

+}

+

+static int

+DeliverDeviceEventsXorg(register WindowPtr pWin, register xEvent *xE, GrabPtr grab, 

+			register WindowPtr stopAt, DeviceIntPtr dev, int count)

+{

+    Window child = None;

+    int type = xE->u.u.type;

+    Mask filter = filters[type];

+    int deliveries = 0;

+#ifdef LG3D

+    WindowPtr tmpWin;

+#endif /* LG3D */

+

+    if (type & EXTENSION_EVENT_BASE)

+    {

+	register OtherInputMasks *inputMasks;

+	int mskidx = dev->id;

+

+	inputMasks = wOtherInputMasks(pWin);

+	if (inputMasks && !(filter & inputMasks->deliverableEvents[mskidx]))

+	    return 0;

+	while (pWin)

+	{

+	    if (inputMasks && (inputMasks->inputEvents[mskidx] & filter))

+	    {

+		FixUpEventFromWindow(xE, pWin, child, FALSE);

+		deliveries = DeliverEventsToWindow(pWin, xE, count, filter,

+						   grab, mskidx);

+		if (deliveries > 0)

+		    return deliveries;

+	    }

+#ifdef LG3D

+	    tmpWin = (pWin->parent) ? pWin->parent : pWin;

+#endif /* LG3D */

+	    if ((deliveries < 0) ||

+		(pWin == stopAt) ||

+#ifdef LG3D

+		/*

+		** Stop propogating when the parent of the window is the PRW.

+		** This prevents events that are not caught by any X11 window from

+		** being sent back to the the Display Server, because the DS can

+		** misinterpret these.

+		** TODO: we need to decide if a server change is the best way to 

+		** deal with this problem, or whether the DS or WM can do something 

+		** about it.

+		*/

+		(lgeDisplayServerIsAlive && (pWin->parent)

+		&& pWin->parent->drawable.id == IsWinLgePRWOne(tmpWin->drawable.id)) ||

+#endif /* LG3D */

+		(inputMasks &&

+		 (filter & inputMasks->dontPropagateMask[mskidx])))

+		return 0;

+	    child = pWin->drawable.id;

+	    pWin = pWin->parent;

+	    if (pWin)

+		inputMasks = wOtherInputMasks(pWin);

+	}

+    }

+    else

+    {

+	if (!(filter & pWin->deliverableEvents))

+	    return 0;

+	while (pWin)

+	{

+	    if ((wOtherEventMasks(pWin)|pWin->eventMask) & filter)

+	    {

+		FixUpEventFromWindow(xE, pWin, child, FALSE);

+		deliveries = DeliverEventsToWindow(pWin, xE, count, filter,

+						   grab, 0);

+		if (deliveries > 0)

+		    return deliveries;

+	    }

+#ifdef LG3D

+	    tmpWin = (pWin->parent) ? pWin->parent : pWin;

+#endif /* LG3D */

+	    if ((deliveries < 0) ||

+		(pWin == stopAt) ||

+#ifdef LG3D

+		/* See comment above */		

+		(lgeDisplayServerIsAlive 		

+		&& pWin->parent->drawable.id == IsWinLgePRWOne(tmpWin->drawable.id)) ||

+#endif /* LG3D */

+		(filter & wDontPropagateMask(pWin)))

+		return 0;

+	    child = pWin->drawable.id;

+	    pWin = pWin->parent;

+	}

+    }

+    return 0;

+}

+

+int

+DeliverDeviceEvents (WindowPtr pSpriteWin, xEvent *xE, GrabPtr grab, 

+		     WindowPtr stopAt, DeviceIntPtr dev, int count)

+{

+    int ret;

+

+    /* 

+    ** Fix LG3D bug 293: make sure that we send button events for

+    ** 2D to a subwindow of the top-level window that the DS Picker

+    ** has chosen.

+    */

+    if (xE->u.u.type == ButtonPress || xE->u.u.type == ButtonRelease) {

+	WindowPtr pDestWin = lg3dDetermineButtonDestWindow(xE, pSpriteWin);

+	if (pDestWin == NULL) return 0;

+	ret = DeliverDeviceEventsXorg(pDestWin, xE, grab, stopAt, dev, count);

+    } else {

+	ret = DeliverDeviceEventsXorg(pSpriteWin, xE, grab, stopAt, dev, count);

+    }

+

+    return ret;

+}

+

+#else

+

 int

 DeliverDeviceEvents(register WindowPtr pWin, register xEvent *xE, GrabPtr grab, 

                     register WindowPtr stopAt, DeviceIntPtr dev, int count)

@@ -1887,6 +2255,8 @@ DeliverDeviceEvents(register WindowPtr p

     return 0;

 }