Attachment #302436 for bug #508553

View | Details | Raw Unified | Return to bug 508553
Collapse All | Expand All

Lines 66-72 rfbSetXCutText(char *str, int len) Link Here

(-)xorg-server-1.6.1/hw/vnc/cutpaste.c (-1 / +1 lines)
66	event.u.selectionClear.time = GetTimeInMillis();	66	event.u.selectionClear.time = GetTimeInMillis();
67	event.u.selectionClear.window = pSel->window;	67	event.u.selectionClear.window = pSel->window;
68	event.u.selectionClear.atom = pSel->selection;	68	event.u.selectionClear.atom = pSel->selection;
69	(void) TryClientEvents (pSel->client, &event, 1,	69	(void) TryClientEvents (pSel->client, NULL, &event, 1,
70	NoEventMask, NoEventMask /* CantBeFiltered */,	70	NoEventMask, NoEventMask /* CantBeFiltered */,
71	NullGrab);	71	NullGrab);
72	}	72	}

Lines 74-92 vncSetPointerDevice(DeviceIntPtr ptr) Link Here

(-)xorg-server-1.6.1/hw/vnc/kbdptr.c (-7 / +28 lines)
74	static void	74	static void
75	EnqueueMotion(DeviceIntPtr ptrDev, int x, int y)	75	EnqueueMotion(DeviceIntPtr ptrDev, int x, int y)
76	{	76	{
77	xEvent events = (xEvent) calloc(sizeof(xEvent), GetMaximumEventsNum());	77	int maxEventsNum = GetMaximumEventsNum();
		78	xEvent events = (xEvent) calloc(sizeof(xEvent), maxEventsNum);
		79	EventListPtr evls= calloc(sizeof(EventList), maxEventsNum);
78	int detail = 0, valuators[2], nevents, i;	80	int detail = 0, valuators[2], nevents, i;
79	valuators[0] = x;	81	valuators[0] = x;
80	valuators[1] = y;	82	valuators[1] = y;
		83	for (i = 0; i < maxEventsNum; i++) {
		84	evls[i].event = &events[i];
		85	evls[i].evlen = sizeof(xEvent);
		86	}
81	if (!ptrDev) {	87	if (!ptrDev) {
82	ErrorF("VNC: In EnqueueMotion() ptrDev=NULL\n");	88	ErrorF("VNC: In EnqueueMotion() ptrDev=NULL\n");
83	return;	89	return;
84	}	90	}
85	nevents = GetPointerEvents(events, ptrDev, MotionNotify, detail,	91	nevents = GetPointerEvents(evls, ptrDev, MotionNotify, detail,
86	POINTER_ABSOLUTE, 0, 2, valuators);	92	POINTER_ABSOLUTE, 0, 2, valuators);
87	for (i = 0; i < nevents; i++)	93	for (i = 0; i < nevents; i++)
88	mieqEnqueue(ptrDev, events + i);	94	mieqEnqueue(ptrDev, events + i);
89	free(events);	95	free(events);
		96	free(evls);
90	}	97	}
91	#endif	98	#endif
92		99
Lines 94-126 EnqueueMotion(DeviceIntPtr ptrDev, int x Link Here
94	static void	101	static void
95	EnqueueButton(DeviceIntPtr ptrDev, int type, int detail)	102	EnqueueButton(DeviceIntPtr ptrDev, int type, int detail)
96	{	103	{
97	xEvent events = (xEvent) calloc(sizeof(xEvent), GetMaximumEventsNum());	104	int maxEventsNum = GetMaximumEventsNum();
		105	xEvent events = (xEvent) calloc(sizeof(xEvent), maxEventsNum);
		106	EventListPtr evls= calloc(sizeof(EventList), maxEventsNum);
98	int nevents, i;	107	int nevents, i;
		108	for (i = 0; i < maxEventsNum; i++) {
		109	evls[i].event = &events[i];
		110	evls[i].evlen = sizeof(xEvent);
		111	}
99	if (!ptrDev) {	112	if (!ptrDev) {
100	ErrorF("VNC: In EnqueueButton() ptrDev=NULL\n");	113	ErrorF("VNC: In EnqueueButton() ptrDev=NULL\n");
101	return;	114	return;
102	}	115	}
103	nevents = GetPointerEvents(events, ptrDev, type, detail,	116	nevents = GetPointerEvents(evls, ptrDev, type, detail,
104	POINTER_ABSOLUTE, 0, 0, NULL/valuators/);	117	POINTER_ABSOLUTE, 0, 0, NULL/valuators/);
105	for (i = 0; i < nevents; i++)	118	for (i = 0; i < nevents; i++)
106	mieqEnqueue(ptrDev, events + i);	119	mieqEnqueue(ptrDev, events + i);
107	free(events);	120	free(events);
		121	free(evls);
108	}	122	}
109		123
110		124
111	static void	125	static void
112	EnqueueKey(DeviceIntPtr kbdDev, int type, int detail)	126	EnqueueKey(DeviceIntPtr kbdDev, int type, int detail)
113	{	127	{
114	xEvent events = (xEvent) calloc(sizeof(xEvent), GetMaximumEventsNum());	128	int maxEventsNum = GetMaximumEventsNum();
		129	xEvent events = (xEvent) calloc(sizeof(xEvent), maxEventsNum);
		130	EventListPtr evls= calloc(sizeof(EventList), maxEventsNum);
115	int nevents, i;	131	int nevents, i;
		132	for (i = 0; i < maxEventsNum; i++) {
		133	evls[i].event = &events[i];
		134	evls[i].evlen = sizeof(xEvent);
		135	}
116	if (!kbdDev) {	136	if (!kbdDev) {
117	ErrorF("VNC: In EnqueueKey() kbdDev=NULL\n");	137	ErrorF("VNC: In EnqueueKey() kbdDev=NULL\n");
118	return;	138	return;
119	}	139	}
120	nevents = GetKeyboardEvents(events, kbdDev, type, detail);	140	nevents = GetKeyboardEvents(evls, kbdDev, type, detail);
121	for (i = 0; i < nevents; i++)	141	for (i = 0; i < nevents; i++)
122	mieqEnqueue(kbdDev, events + i);	142	mieqEnqueue(kbdDev, events + i);
123	free(events);	143	free(events);
		144	free(evls);
124	}	145	}
125		146
126		147
Lines 256-262 KbdAddEvent(Bool down, KeySym keySym, rf Link Here
256	shiftMustBePressed = TRUE;	277	shiftMustBePressed = TRUE;
257	}	278	}
258		279
259	SendMappingNotify(MappingKeyboard, keyCode, 1, serverClient);	280	SendMappingNotify(kbdDevice, MappingKeyboard, keyCode, 1, serverClient);
260		281
261	ErrorF("KbdAddEvent: unknown KeySym 0x%x - allocating KeyCode %d\n",	282	ErrorF("KbdAddEvent: unknown KeySym 0x%x - allocating KeyCode %d\n",
262	(int)keySym, keyCode);	283	(int)keySym, keyCode);

Lines 388-394 static XF86ModuleVersionInfo xf86rfbKeyb Link Here

(-)xorg-server-1.6.1/hw/vnc/rfbkeyb.c (-1 / +1 lines)
388	"xf4vnc Project, see http://xf4vnc.sf.net",	388	"xf4vnc Project, see http://xf4vnc.sf.net",
389	MODINFOSTRING1,	389	MODINFOSTRING1,
390	MODINFOSTRING2,	390	MODINFOSTRING2,
391	XF86_VERSION_CURRENT,	391	XORG_VERSION_CURRENT,
392	1, 0, 0,	392	1, 0, 0,
393	ABI_CLASS_XINPUT,	393	ABI_CLASS_XINPUT,
394	ABI_XINPUT_VERSION,	394	ABI_XINPUT_VERSION,




    void *func1;
    int (*func2)(void);

#if GET_ABI_MAJOR(ABI_XINPUT_VERSION) < 3
    if (LoaderSymbol("GetMotionHistory"))
    	func1 = LoaderSymbol("GetMotionHistory");
    else
    	func1 = LoaderSymbol("miPointerGetMotionEvents");
#endif

    if (LoaderSymbol("GetMotionHistorySize"))
    	func2 = LoaderSymbol("GetMotionHistorySize");

	map[4] = 4;
	map[5] = 5;
	InitPointerDeviceStruct(pDev, map, 5, 
#if GET_ABI_MAJOR(ABI_XINPUT_VERSION) < 3
                                func1,
#endif
				PtrDeviceControl,
                                (*func2)(), 2);
	break;

    "xf4vnc Project, see http://xf4vnc.sf.net",
    MODINFOSTRING1,
    MODINFOSTRING2,
    XORG_VERSION_CURRENT,
    1, 0, 0,
    ABI_CLASS_XINPUT,
    ABI_XINPUT_VERSION,

Lines 1122-1129 rfbProcessClientNormalMessage(cl) Link Here

(-)xorg-server-1.6.1/hw/vnc/rfbserver.c (-2 / +2 lines)
1122		1122
1123	{	1123	{
1124	int x, y;	1124	int x, y;
1125	miPointerPosition(&x, &y); /XXX deprecated/	1125	miPointerGetPosition(inputInfo.pointer, &x, &y);
1126	(*pVNC->spriteFuncs->SetCursor)(cl->pScreen, pVNC->pCurs, x, y);	1126	(*pVNC->spriteFuncs->SetCursor)(inputInfo.pointer, cl->pScreen, pVNC->pCurs, x, y);
1127	}	1127	}
1128	#endif	1128	#endif
1129		1129




static RegionPtr    rfbSpriteRestoreAreas(WindowPtr pWin, RegionPtr pRgnExposed);
static void	    rfbSpriteComputeSaved(ScreenPtr pScreen);

static int rfbSpriteScreenKeyStore;
static DevPrivateKey rfbSpriteScreenKey = &rfbSpriteScreenKeyStore;

#define SCREEN_PROLOGUE(pScreen, field) ((pScreen)->field = \
   ((rfbSpriteScreenPtr)dixLookupPrivate(&(pScreen)->devPrivates, \

    rfbSpriteCopyClip,
};

static int rfbSpriteGCKeyStore;
static DevPrivateKey rfbSpriteGCKey = &rfbSpriteGCKeyStore;

#define GC_FUNC_PROLOGUE(pGC)					\
    rfbSpriteGCPtr   pGCPriv =					\

 * pointer-sprite method table
 */

static Bool rfbSpriteRealizeCursor (DeviceIntPtr pDev, ScreenPtr pScreen, CursorPtr pCursor);
static Bool rfbSpriteUnrealizeCursor (DeviceIntPtr pDev, ScreenPtr pScreen, CursorPtr pCursor);
static void rfbSpriteSetCursor (DeviceIntPtr pDev, ScreenPtr pScreen, CursorPtr pCursor, int x, int y);
static void rfbSpriteMoveCursor (DeviceIntPtr pDev, ScreenPtr pScreen, int x, int y);
static Bool rfbSpriteInitializeCursor (DeviceIntPtr pDev, ScreenPtr pScreen);
static void rfbSpriteCleanupCursor (DeviceIntPtr pDev, ScreenPtr pScreen);

miPointerSpriteFuncRec rfbSpritePointerFuncs = {
    rfbSpriteRealizeCursor,
    rfbSpriteUnrealizeCursor,
    rfbSpriteSetCursor,
    rfbSpriteMoveCursor,
    rfbSpriteInitializeCursor,
    rfbSpriteCleanupCursor,
};

/*
 * other misc functions
 */

static Bool rfbDisplayCursor (DeviceIntPtr pDev, ScreenPtr pScreen, CursorPtr pCursor);


/*

#define SPRITE_PAD 8

static Bool
rfbSpriteRealizeCursor (DeviceIntPtr pDev, ScreenPtr pScreen, CursorPtr pCursor)
{
    rfbSpriteScreenPtr	pScreenPriv;


}

static Bool
rfbSpriteUnrealizeCursor (DeviceIntPtr pDev, ScreenPtr pScreen, CursorPtr pCursor)
{
    rfbSpriteScreenPtr	pScreenPriv;


}

static void
rfbSpriteSetCursor (DeviceIntPtr pDev, ScreenPtr pScreen, CursorPtr pCursor, int x, int y)
{
    rfbSpriteScreenPtr	pScreenPriv;
    rfbClientPtr cl, nextCl;

}

static void
rfbSpriteMoveCursor (DeviceIntPtr pDev, ScreenPtr pScreen, int x, int y)
{
    rfbSpriteScreenPtr	pScreenPriv;

    pScreenPriv = (rfbSpriteScreenPtr)dixLookupPrivate(&pScreen->devPrivates,
						      rfbSpriteScreenKey);
    rfbSpriteSetCursor (pDev, pScreen, pScreenPriv->pCursor, x, y);
}

static Bool
rfbSpriteInitializeCursor (DeviceIntPtr pDev, ScreenPtr pScreen)
{
    return TRUE;
}

static void
rfbSpriteCleanupCursor (DeviceIntPtr pDev, ScreenPtr pScreen)
{
}

/*

 */

static Bool
rfbDisplayCursor(DeviceIntPtr pDev, ScreenPtr pScreen, CursorPtr pCursor)
    ScreenPtr pScreen;
    CursorPtr pCursor;
{
    rfbClientPtr cl;
    rfbSpriteScreenPtr pPriv;


    pPriv = (rfbSpriteScreenPtr)dixLookupPrivate(&pScreen->devPrivates,
						      rfbSpriteScreenKey);
    status = (*pPriv->DisplayCursor)(pDev, pScreen, pCursor);

    /* send new cursor shape to interested viewers */
    for (cl = rfbClientHead; cl ; cl = cl->next) {




#include "xf86.h"
#include "xf86_OSproc.h"
#include "xf86Resources.h"
#include "xorgVersion.h"

int vncScreenPrivateIndex = -1;
int inetdSock = -1;

static const OptionInfoRec *VNCAvailableOptions(void *unused);
static void rfbWakeupHandler (int i, pointer blockData, unsigned long err, pointer pReadmask);

static Bool vncCursorRealizeCursor(DeviceIntPtr, ScreenPtr, CursorPtr);
static Bool vncCursorUnrealizeCursor(DeviceIntPtr, ScreenPtr, CursorPtr);
static void vncCursorSetCursor(DeviceIntPtr, ScreenPtr, CursorPtr, int, int);
static void vncCursorMoveCursor(DeviceIntPtr, ScreenPtr, int, int);
static Bool vncDisplayCursor(DeviceIntPtr, ScreenPtr, CursorPtr);

static miPointerSpriteFuncRec vncCursorSpriteFuncs = {
   vncCursorRealizeCursor,

/****** miPointerSpriteFunctions *******/

static Bool
vncCursorRealizeCursor(DeviceIntPtr pDev, ScreenPtr pScreen, CursorPtr pCurs)
{
    vncScreenPtr   pScreenPriv = VNCPTR(pScreen);

    return (*pScreenPriv->spriteFuncs->RealizeCursor)(pDev, pScreen, pCurs);
}

static Bool
vncCursorUnrealizeCursor(DeviceIntPtr pDev, ScreenPtr pScreen, CursorPtr pCurs)
{
    vncScreenPtr   pScreenPriv = VNCPTR(pScreen);

    return (*pScreenPriv->spriteFuncs->UnrealizeCursor)(pDev, pScreen, pCurs);
}

static void
vncCursorSetCursor(DeviceIntPtr pDev, ScreenPtr pScreen, CursorPtr pCurs, int x, int y)
{
    vncScreenPtr   pScreenPriv = VNCPTR(pScreen);


    pScreenPriv->cursorIsDrawn = TRUE;
#endif

    (*pScreenPriv->spriteFuncs->SetCursor)(pDev, pScreen, pCurs, x, y);
}

static void
vncCursorMoveCursor(DeviceIntPtr pDev, ScreenPtr pScreen, int x, int y)
{
    vncScreenPtr   pScreenPriv = VNCPTR(pScreen);
    rfbClientPtr cl;

	    cl->cursorWasMoved = TRUE;
    }

    (*pScreenPriv->spriteFuncs->MoveCursor)(pDev, pScreen, x, y);
}

Bool

#endif

static Bool
vncDisplayCursor(DeviceIntPtr pDev, ScreenPtr pScreen, CursorPtr pCursor)
    ScreenPtr pScreen;
    CursorPtr pCursor;
{
    vncScreenPtr   pScreenPriv = VNCPTR(pScreen);
    rfbClientPtr cl;

	    cl->cursorWasChanged = TRUE;
    }

    ret = (*pScreen->DisplayCursor)(pDev, pScreen, pCursor);

    pScreen->DisplayCursor = vncDisplayCursor;





#include <arpa/inet.h>
#include <netdb.h>

static int vncCreateScreenResourcesKeyStore, rfbGCKeyStore;
DevPrivateKey vncCreateScreenResourcesKey = &vncCreateScreenResourcesKeyStore;
DevPrivateKey rfbGCKey = &rfbGCKeyStore;

int VncSelectNotify(ClientPtr client, BOOL onoff);
void VncExtensionInit(void);

   	  else
		conn.ipaddress = (CARD32)peer.sin_addr.s_addr;

	  (void) TryClientEvents(pn->client, NULL, (xEventPtr)&conn, 1, NoEventMask,
				 NoEventMask, NullGrab);
	}
	pn = pn->next;

   	  else
		conn.ipaddress = (CARD32)peer.sin_addr.s_addr;

	  (void) TryClientEvents(pn->client, NULL, (xEventPtr)&conn, 1, NoEventMask,
				 NoEventMask, NullGrab);
	}
	pn = pn->next;

    	  conn.type = VncEventBase + XVncDisconnected;
    	  conn.sequenceNumber = pn->client->sequence;
    	  conn.connected = sock;
	  (void) TryClientEvents(pn->client, NULL, (xEventPtr)&conn, 1, NoEventMask,
				 NoEventMask, NullGrab);
	}
	pn = pn->next;

Lines 262-268 rfbSendCursorPos(cl, pScreen) Link Here

(-)xorg-server-1.6.1/hw/vnc/cursor.c (-1 / +1 lines)
262		262
263	#if XFREE86VNC	263	#if XFREE86VNC
264	if (pScreen == pCursorScreen)	264	if (pScreen == pCursorScreen)
265	miPointerPosition(&x, &y);	265	miPointerGetPosition(inputInfo.pointer, &x, &y);
266	#else	266	#else
267	rfbSpriteGetCursorPos(pScreen, &x, &y);	267	rfbSpriteGetCursorPos(pScreen, &x, &y);
268	#endif	268	#endif






static void
PointerWarpCursor(DeviceIntPtr pDev, ScreenPtr pScreen, int x, int y)
{
#if 0
   DeviceIntPtr pDev = NULL;

    char *argv[];
{
    DeviceIntPtr p, k;
    k = AddInputDevice(serverClient, rfbKeybdProc, TRUE);
    p = AddInputDevice(serverClient, rfbMouseProc, TRUE);
    RegisterKeyboardDevice(k);
    RegisterPointerDevice(p);


	map[4] = 4;
	map[5] = 5;
	InitPointerDeviceStruct(pDev, map, 5,
                                GetMotionHistory,
				PtrDeviceControl,
                                GetMaximumEventsNum(), 2 /* numAxes */);
        vncSetPointerDevice(pDevice);

Lines 74-80 in this Software without prior written a Link Here

(-)xorg-server-1.6.1/hw/vnc/dispcur.c (-8 / +11 lines)
74		74
75	/* per-screen private data */	75	/* per-screen private data */
76		76
77	static DevPrivateKey rfbDCScreenKey = &rfbDCScreenKey;	77	static int rfbDCScreenKeyStore;
		78	static DevPrivateKey rfbDCScreenKey = &rfbDCScreenKeyStore;
		79	static int rfbScreenKeyStore;
		80	static DevPrivateKey rfbScreenKey = &rfbScreenKeyStore;
78		81
79	static Bool rfbDCCloseScreen(int index, ScreenPtr pScreen);	82	static Bool rfbDCCloseScreen(int index, ScreenPtr pScreen);
80		83
Lines 205-211 rfbDCRealizeCursor (pScreen, pCursor) Link Here
205	CursorPtr pCursor;	208	CursorPtr pCursor;
206	{	209	{
207	if (pCursor->bits->refcnt <= 1)	210	if (pCursor->bits->refcnt <= 1)
208	dixSetPrivate(&pCursor->bits->devPrivates, pScreen, NULL);	211	dixSetPrivate(&pCursor->bits->devPrivates, rfbScreenKey, NULL);
209	return TRUE;	212	return TRUE;
210	}	213	}
211		214
Lines 303-309 rfbDCRealize (ScreenPtr pScreen, CursorP Link Here
303	xfree ((pointer) pPriv);	306	xfree ((pointer) pPriv);
304	return (rfbDCCursorPtr)NULL;	307	return (rfbDCCursorPtr)NULL;
305	}	308	}
306	dixSetPrivate(&pCursor->bits->devPrivates, pScreen, pPriv);	309	dixSetPrivate(&pCursor->bits->devPrivates, rfbScreenKey, pPriv);
307	return pPriv;	310	return pPriv;
308	}	311	}
309	pPriv->pPicture = 0;	312	pPriv->pPicture = 0;
Lines 321-327 rfbDCRealize (ScreenPtr pScreen, CursorP Link Here
321	xfree ((pointer) pPriv);	324	xfree ((pointer) pPriv);
322	return (rfbDCCursorPtr)NULL;	325	return (rfbDCCursorPtr)NULL;
323	}	326	}
324	dixSetPrivate(&pCursor->bits->devPrivates, pScreen, pPriv);	327	dixSetPrivate(&pCursor->bits->devPrivates, rfbScreenKey, pPriv);
325		328
326	/* create the two sets of bits, clipping as appropriate */	329	/* create the two sets of bits, clipping as appropriate */
327		330
Lines 368-374 rfbDCUnrealizeCursor (pScreen, pCursor) Link Here
368	rfbDCCursorPtr pPriv;	371	rfbDCCursorPtr pPriv;
369		372
370	pPriv = (rfbDCCursorPtr)dixLookupPrivate(&pCursor->bits->devPrivates,	373	pPriv = (rfbDCCursorPtr)dixLookupPrivate(&pCursor->bits->devPrivates,
371	pScreen);	374	rfbScreenKey);
372	if (pPriv && (pCursor->bits->refcnt <= 1))	375	if (pPriv && (pCursor->bits->refcnt <= 1))
373	{	376	{
374	if (pPriv->sourceBits)	377	if (pPriv->sourceBits)
Lines 380-386 rfbDCUnrealizeCursor (pScreen, pCursor) Link Here
380	FreePicture (pPriv->pPicture, 0);	383	FreePicture (pPriv->pPicture, 0);
381	#endif	384	#endif
382	xfree ((pointer) pPriv);	385	xfree ((pointer) pPriv);
383	dixSetPrivate(&pCursor->bits->devPrivates, pScreen, NULL);	386	dixSetPrivate(&pCursor->bits->devPrivates, rfbScreenKey, NULL);
384	}	387	}
385	return TRUE;	388	return TRUE;
386	}	389	}
Lines 439-445 rfbDCPutUpCursor (pScreen, pCursor, x, y Link Here
439	WindowPtr pWin;	442	WindowPtr pWin;
440		443
441	pPriv = (rfbDCCursorPtr)dixLookupPrivate(&pCursor->bits->devPrivates,	444	pPriv = (rfbDCCursorPtr)dixLookupPrivate(&pCursor->bits->devPrivates,
442	pScreen);	445	rfbScreenKey);
443	if (!pPriv)	446	if (!pPriv)
444	{	447	{
445	pPriv = rfbDCRealize(pScreen, pCursor);	448	pPriv = rfbDCRealize(pScreen, pCursor);
Lines 690-696 rfbDCMoveCursor (pScreen, pCursor, x, y, Link Here
690	PixmapPtr pTemp;	693	PixmapPtr pTemp;
691		694
692	pPriv = (rfbDCCursorPtr)dixLookupPrivate(&pCursor->bits->devPrivates,	695	pPriv = (rfbDCCursorPtr)dixLookupPrivate(&pCursor->bits->devPrivates,
693	pScreen);	696	rfbScreenKey);
694	if (!pPriv)	697	if (!pPriv)
695	{	698	{
696	pPriv = rfbDCRealize(pScreen, pCursor);	699	pPriv = rfbDCRealize(pScreen, pCursor);

Return to bug 508553

Lines 112-118 static void rfbSpriteSaveDoomedAreas Link Here

(-)xorg-server-1.6.1/hw/vnc/sprite.c (-16 / +31 lines)
112	static RegionPtr rfbSpriteRestoreAreas(WindowPtr pWin, RegionPtr pRgnExposed);	112	static RegionPtr rfbSpriteRestoreAreas(WindowPtr pWin, RegionPtr pRgnExposed);
113	static void rfbSpriteComputeSaved(ScreenPtr pScreen);	113	static void rfbSpriteComputeSaved(ScreenPtr pScreen);
114		114
115	static DevPrivateKey rfbSpriteScreenKey = &rfbSpriteScreenKey;	115	static int rfbSpriteScreenKeyStore;
		116	static DevPrivateKey rfbSpriteScreenKey = &rfbSpriteScreenKeyStore;
116		117
117	#define SCREEN_PROLOGUE(pScreen, field) ((pScreen)->field = \	118	#define SCREEN_PROLOGUE(pScreen, field) ((pScreen)->field = \
118	((rfbSpriteScreenPtr)dixLookupPrivate(&(pScreen)->devPrivates, \	119	((rfbSpriteScreenPtr)dixLookupPrivate(&(pScreen)->devPrivates, \
Lines 144-150 static GCFuncs rfbSpriteGCFuncs = { Link Here
144	rfbSpriteCopyClip,	145	rfbSpriteCopyClip,
145	};	146	};
146		147
147	static DevPrivateKey rfbSpriteGCKey = &rfbSpriteGCKey;	148	static int rfbSpriteGCKeyStore;
		149	static DevPrivateKey rfbSpriteGCKey = &rfbSpriteGCKeyStore;
148		150
149	#define GC_FUNC_PROLOGUE(pGC) \	151	#define GC_FUNC_PROLOGUE(pGC) \
150	rfbSpriteGCPtr pGCPriv = \	152	rfbSpriteGCPtr pGCPriv = \
Lines 289-311 static GCOps rfbSpriteGCOps = { Link Here
289	* pointer-sprite method table	291	* pointer-sprite method table
290	*/	292	*/
291		293
292	static Bool rfbSpriteRealizeCursor (ScreenPtr pScreen, CursorPtr pCursor);	294	static Bool rfbSpriteRealizeCursor (DeviceIntPtr pDev, ScreenPtr pScreen, CursorPtr pCursor);
293	static Bool rfbSpriteUnrealizeCursor (ScreenPtr pScreen, CursorPtr pCursor);	295	static Bool rfbSpriteUnrealizeCursor (DeviceIntPtr pDev, ScreenPtr pScreen, CursorPtr pCursor);
294	static void rfbSpriteSetCursor (ScreenPtr pScreen, CursorPtr pCursor, int x, int y);	296	static void rfbSpriteSetCursor (DeviceIntPtr pDev, ScreenPtr pScreen, CursorPtr pCursor, int x, int y);
295	static void rfbSpriteMoveCursor (ScreenPtr pScreen, int x, int y);	297	static void rfbSpriteMoveCursor (DeviceIntPtr pDev, ScreenPtr pScreen, int x, int y);
		298	static Bool rfbSpriteInitializeCursor (DeviceIntPtr pDev, ScreenPtr pScreen);
		299	static void rfbSpriteCleanupCursor (DeviceIntPtr pDev, ScreenPtr pScreen);
296		300
297	miPointerSpriteFuncRec rfbSpritePointerFuncs = {	301	miPointerSpriteFuncRec rfbSpritePointerFuncs = {
298	rfbSpriteRealizeCursor,	302	rfbSpriteRealizeCursor,
299	rfbSpriteUnrealizeCursor,	303	rfbSpriteUnrealizeCursor,
300	rfbSpriteSetCursor,	304	rfbSpriteSetCursor,
301	rfbSpriteMoveCursor,	305	rfbSpriteMoveCursor,
		306	rfbSpriteInitializeCursor,
		307	rfbSpriteCleanupCursor,
302	};	308	};
303		309
304	/*	310	/*
305	* other misc functions	311	* other misc functions
306	*/	312	*/
307		313
308	static Bool rfbDisplayCursor (ScreenPtr pScreen, CursorPtr pCursor);	314	static Bool rfbDisplayCursor (DeviceIntPtr pDev, ScreenPtr pScreen, CursorPtr pCursor);
309		315
310		316
311	/*	317	/*
Lines 1963-1969 rfbSpriteLineHelper() Link Here
1963	#define SPRITE_PAD 8	1969	#define SPRITE_PAD 8
1964		1970
1965	static Bool	1971	static Bool
1966	rfbSpriteRealizeCursor (ScreenPtr pScreen, CursorPtr pCursor)	1972	rfbSpriteRealizeCursor (DeviceIntPtr pDev, ScreenPtr pScreen, CursorPtr pCursor)
1967	{	1973	{
1968	rfbSpriteScreenPtr pScreenPriv;	1974	rfbSpriteScreenPtr pScreenPriv;
1969		1975
Lines 1975-1981 rfbSpriteRealizeCursor (ScreenPtr pScree Link Here
1975	}	1981	}
1976		1982
1977	static Bool	1983	static Bool
1978	rfbSpriteUnrealizeCursor (ScreenPtr pScreen, CursorPtr pCursor)	1984	rfbSpriteUnrealizeCursor (DeviceIntPtr pDev, ScreenPtr pScreen, CursorPtr pCursor)
1979	{	1985	{
1980	rfbSpriteScreenPtr pScreenPriv;	1986	rfbSpriteScreenPtr pScreenPriv;
1981		1987
Lines 1985-1991 rfbSpriteUnrealizeCursor (ScreenPtr pScr Link Here
1985	}	1991	}
1986		1992
1987	static void	1993	static void
1988	rfbSpriteSetCursor (ScreenPtr pScreen, CursorPtr pCursor, int x, int y)	1994	rfbSpriteSetCursor (DeviceIntPtr pDev, ScreenPtr pScreen, CursorPtr pCursor, int x, int y)
1989	{	1995	{
1990	rfbSpriteScreenPtr pScreenPriv;	1996	rfbSpriteScreenPtr pScreenPriv;
1991	rfbClientPtr cl, nextCl;	1997	rfbClientPtr cl, nextCl;
Lines 2101-2113 rfbSpriteSetCursor (ScreenPtr pScreen, C Link Here
2101	}	2107	}
2102		2108
2103	static void	2109	static void
2104	rfbSpriteMoveCursor (ScreenPtr pScreen, int x, int y)	2110	rfbSpriteMoveCursor (DeviceIntPtr pDev, ScreenPtr pScreen, int x, int y)
2105	{	2111	{
2106	rfbSpriteScreenPtr pScreenPriv;	2112	rfbSpriteScreenPtr pScreenPriv;
2107		2113
2108	pScreenPriv = (rfbSpriteScreenPtr)dixLookupPrivate(&pScreen->devPrivates,	2114	pScreenPriv = (rfbSpriteScreenPtr)dixLookupPrivate(&pScreen->devPrivates,
2109	rfbSpriteScreenKey);	2115	rfbSpriteScreenKey);
2110	rfbSpriteSetCursor (pScreen, pScreenPriv->pCursor, x, y);	2116	rfbSpriteSetCursor (pDev, pScreen, pScreenPriv->pCursor, x, y);
		2117	}
		2118
		2119	static Bool
		2120	rfbSpriteInitializeCursor (DeviceIntPtr pDev, ScreenPtr pScreen)
		2121	{
		2122	return TRUE;
		2123	}
		2124
		2125	static void
		2126	rfbSpriteCleanupCursor (DeviceIntPtr pDev, ScreenPtr pScreen)
		2127	{
2111	}	2128	}
2112		2129
2113	/*	2130	/*
Lines 2215-2223 rfbSpriteComputeSaved (pScreen) Link Here
2215	*/	2232	*/
2216		2233
2217	static Bool	2234	static Bool
2218	rfbDisplayCursor(pScreen, pCursor)	2235	rfbDisplayCursor(DeviceIntPtr pDev, ScreenPtr pScreen, CursorPtr pCursor)
2219	ScreenPtr pScreen;
2220	CursorPtr pCursor;
2221	{	2236	{
2222	rfbClientPtr cl;	2237	rfbClientPtr cl;
2223	rfbSpriteScreenPtr pPriv;	2238	rfbSpriteScreenPtr pPriv;
Lines 2230-2236 rfbDisplayCursor(pScreen, pCursor) Link Here
2230		2245
2231	pPriv = (rfbSpriteScreenPtr)dixLookupPrivate(&pScreen->devPrivates,	2246	pPriv = (rfbSpriteScreenPtr)dixLookupPrivate(&pScreen->devPrivates,
2232	rfbSpriteScreenKey);	2247	rfbSpriteScreenKey);
2233	status = (*pPriv->DisplayCursor)(pScreen, pCursor);	2248	status = (*pPriv->DisplayCursor)(pDev, pScreen, pCursor);
2234		2249
2235	/* send new cursor shape to interested viewers */	2250	/* send new cursor shape to interested viewers */
2236	for (cl = rfbClientHead; cl ; cl = cl->next) {	2251	for (cl = rfbClientHead; cl ; cl = cl->next) {

Lines 98-107 xf86rfbMouseControlProc(DeviceIntPtr dev Link Here

(-)xorg-server-1.6.1/hw/vnc/rfbmouse.c (-1 / +5 lines)
98	void *func1;	98	void *func1;
99	int (*func2)(void);	99	int (*func2)(void);
100		100
		101	#if GET_ABI_MAJOR(ABI_XINPUT_VERSION) < 3
101	if (LoaderSymbol("GetMotionHistory"))	102	if (LoaderSymbol("GetMotionHistory"))
102	func1 = LoaderSymbol("GetMotionHistory");	103	func1 = LoaderSymbol("GetMotionHistory");
103	else	104	else
104	func1 = LoaderSymbol("miPointerGetMotionEvents");	105	func1 = LoaderSymbol("miPointerGetMotionEvents");
		106	#endif
105		107
106	if (LoaderSymbol("GetMotionHistorySize"))	108	if (LoaderSymbol("GetMotionHistorySize"))
107	func2 = LoaderSymbol("GetMotionHistorySize");	109	func2 = LoaderSymbol("GetMotionHistorySize");
Lines 120-126 xf86rfbMouseControlProc(DeviceIntPtr dev Link Here
120	map[4] = 4;	122	map[4] = 4;
121	map[5] = 5;	123	map[5] = 5;
122	InitPointerDeviceStruct(pDev, map, 5,	124	InitPointerDeviceStruct(pDev, map, 5,
		125	#if GET_ABI_MAJOR(ABI_XINPUT_VERSION) < 3
123	func1,	126	func1,
		127	#endif
124	PtrDeviceControl,	128	PtrDeviceControl,
125	(*func2)(), 2);	129	(*func2)(), 2);
126	break;	130	break;
Lines 243-249 static XF86ModuleVersionInfo xf86rfbMous Link Here
243	"xf4vnc Project, see http://xf4vnc.sf.net",	247	"xf4vnc Project, see http://xf4vnc.sf.net",
244	MODINFOSTRING1,	248	MODINFOSTRING1,
245	MODINFOSTRING2,	249	MODINFOSTRING2,
246	XF86_VERSION_CURRENT,	250	XORG_VERSION_CURRENT,
247	1, 0, 0,	251	1, 0, 0,
248	ABI_CLASS_XINPUT,	252	ABI_CLASS_XINPUT,
249	ABI_XINPUT_VERSION,	253	ABI_XINPUT_VERSION,

Lines 35-41 Link Here

(-)xorg-server-1.6.1/hw/xfree86/vnc/vncInit.c (-18 / +16 lines)
35	#include "xf86.h"	35	#include "xf86.h"
36	#include "xf86_OSproc.h"	36	#include "xf86_OSproc.h"
37	#include "xf86Resources.h"	37	#include "xf86Resources.h"
38	#include "xf86Version.h"	38	#include "xorgVersion.h"
39		39
40	int vncScreenPrivateIndex = -1;	40	int vncScreenPrivateIndex = -1;
41	int inetdSock = -1;	41	int inetdSock = -1;
Lines 56-66 static unsigned long VNCGeneration = 0; Link Here
56	static const OptionInfoRec VNCAvailableOptions(void unused);	56	static const OptionInfoRec VNCAvailableOptions(void unused);
57	static void rfbWakeupHandler (int i, pointer blockData, unsigned long err, pointer pReadmask);	57	static void rfbWakeupHandler (int i, pointer blockData, unsigned long err, pointer pReadmask);
58		58
59	static Bool vncCursorRealizeCursor(ScreenPtr, CursorPtr);	59	static Bool vncCursorRealizeCursor(DeviceIntPtr, ScreenPtr, CursorPtr);
60	static Bool vncCursorUnrealizeCursor(ScreenPtr, CursorPtr);	60	static Bool vncCursorUnrealizeCursor(DeviceIntPtr, ScreenPtr, CursorPtr);
61	static void vncCursorSetCursor(ScreenPtr, CursorPtr, int, int);	61	static void vncCursorSetCursor(DeviceIntPtr, ScreenPtr, CursorPtr, int, int);
62	static void vncCursorMoveCursor(ScreenPtr, int, int);	62	static void vncCursorMoveCursor(DeviceIntPtr, ScreenPtr, int, int);
63	static Bool vncDisplayCursor(ScreenPtr, CursorPtr);	63	static Bool vncDisplayCursor(DeviceIntPtr, ScreenPtr, CursorPtr);
64		64
65	static miPointerSpriteFuncRec vncCursorSpriteFuncs = {	65	static miPointerSpriteFuncRec vncCursorSpriteFuncs = {
66	vncCursorRealizeCursor,	66	vncCursorRealizeCursor,
Lines 389-411 VNCInit(ScreenPtr pScreen, unsigned char Link Here
389	/**** miPointerSpriteFunctions *****/	389	/**** miPointerSpriteFunctions *****/
390		390
391	static Bool	391	static Bool
392	vncCursorRealizeCursor(ScreenPtr pScreen, CursorPtr pCurs)	392	vncCursorRealizeCursor(DeviceIntPtr pDev, ScreenPtr pScreen, CursorPtr pCurs)
393	{	393	{
394	vncScreenPtr pScreenPriv = VNCPTR(pScreen);	394	vncScreenPtr pScreenPriv = VNCPTR(pScreen);
395		395
396	return (*pScreenPriv->spriteFuncs->RealizeCursor)(pScreen, pCurs);	396	return (*pScreenPriv->spriteFuncs->RealizeCursor)(pDev, pScreen, pCurs);
397	}	397	}
398		398
399	static Bool	399	static Bool
400	vncCursorUnrealizeCursor(ScreenPtr pScreen, CursorPtr pCurs)	400	vncCursorUnrealizeCursor(DeviceIntPtr pDev, ScreenPtr pScreen, CursorPtr pCurs)
401	{	401	{
402	vncScreenPtr pScreenPriv = VNCPTR(pScreen);	402	vncScreenPtr pScreenPriv = VNCPTR(pScreen);
403		403
404	return (*pScreenPriv->spriteFuncs->UnrealizeCursor)(pScreen, pCurs);	404	return (*pScreenPriv->spriteFuncs->UnrealizeCursor)(pDev, pScreen, pCurs);
405	}	405	}
406		406
407	static void	407	static void
408	vncCursorSetCursor(ScreenPtr pScreen, CursorPtr pCurs, int x, int y)	408	vncCursorSetCursor(DeviceIntPtr pDev, ScreenPtr pScreen, CursorPtr pCurs, int x, int y)
409	{	409	{
410	vncScreenPtr pScreenPriv = VNCPTR(pScreen);	410	vncScreenPtr pScreenPriv = VNCPTR(pScreen);
411		411
Lines 426-436 vncCursorSetCursor(ScreenPtr pScreen, Cu Link Here
426	pScreenPriv->cursorIsDrawn = TRUE;	426	pScreenPriv->cursorIsDrawn = TRUE;
427	#endif	427	#endif
428		428
429	(*pScreenPriv->spriteFuncs->SetCursor)(pScreen, pCurs, x, y);	429	(*pScreenPriv->spriteFuncs->SetCursor)(pDev, pScreen, pCurs, x, y);
430	}	430	}
431		431
432	static void	432	static void
433	vncCursorMoveCursor(ScreenPtr pScreen, int x, int y)	433	vncCursorMoveCursor(DeviceIntPtr pDev, ScreenPtr pScreen, int x, int y)
434	{	434	{
435	vncScreenPtr pScreenPriv = VNCPTR(pScreen);	435	vncScreenPtr pScreenPriv = VNCPTR(pScreen);
436	rfbClientPtr cl;	436	rfbClientPtr cl;
Lines 440-446 vncCursorMoveCursor(ScreenPtr pScreen, i Link Here
440	cl->cursorWasMoved = TRUE;	440	cl->cursorWasMoved = TRUE;
441	}	441	}
442		442
443	(*pScreenPriv->spriteFuncs->MoveCursor)(pScreen, x, y);	443	(*pScreenPriv->spriteFuncs->MoveCursor)(pDev, pScreen, x, y);
444	}	444	}
445		445
446	Bool	446	Bool
Lines 505-513 vncUseHWCursorARGB(pScreen, pCursor) Link Here
505	#endif	505	#endif
506		506
507	static Bool	507	static Bool
508	vncDisplayCursor(pScreen, pCursor)	508	vncDisplayCursor(DeviceIntPtr pDev, ScreenPtr pScreen, CursorPtr pCursor)
509	ScreenPtr pScreen;
510	CursorPtr pCursor;
511	{	509	{
512	vncScreenPtr pScreenPriv = VNCPTR(pScreen);	510	vncScreenPtr pScreenPriv = VNCPTR(pScreen);
513	rfbClientPtr cl;	511	rfbClientPtr cl;
Lines 520-526 vncDisplayCursor(pScreen, pCursor) Link Here
520	cl->cursorWasChanged = TRUE;	518	cl->cursorWasChanged = TRUE;
521	}	519	}
522		520
523	ret = (*pScreen->DisplayCursor)(pScreen, pCursor);	521	ret = (*pScreen->DisplayCursor)(pDev, pScreen, pCursor);
524		522
525	pScreen->DisplayCursor = vncDisplayCursor;	523	pScreen->DisplayCursor = vncDisplayCursor;
526		524

Lines 36-43 Link Here

(-)xorg-server-1.6.1/hw/vnc/vncext.c (-5 / +6 lines)
36	#include <arpa/inet.h>	36	#include <arpa/inet.h>
37	#include <netdb.h>	37	#include <netdb.h>
38		38
39	DevPrivateKey vncCreateScreenResourcesKey = &vncCreateScreenResourcesKey;	39	static int vncCreateScreenResourcesKeyStore, rfbGCKeyStore;
40	DevPrivateKey rfbGCKey = &rfbGCKey;	40	DevPrivateKey vncCreateScreenResourcesKey = &vncCreateScreenResourcesKeyStore;
		41	DevPrivateKey rfbGCKey = &rfbGCKeyStore;
41		42
42	int VncSelectNotify(ClientPtr client, BOOL onoff);	43	int VncSelectNotify(ClientPtr client, BOOL onoff);
43	void VncExtensionInit(void);	44	void VncExtensionInit(void);
Lines 514-520 GenerateVncConnectedEvent(int sock) Link Here
514	else	515	else
515	conn.ipaddress = (CARD32)peer.sin_addr.s_addr;	516	conn.ipaddress = (CARD32)peer.sin_addr.s_addr;
516		517
517	(void) TryClientEvents(pn->client, (xEventPtr)&conn, 1, NoEventMask,	518	(void) TryClientEvents(pn->client, NULL, (xEventPtr)&conn, 1, NoEventMask,
518	NoEventMask, NullGrab);	519	NoEventMask, NullGrab);
519	}	520	}
520	pn = pn->next;	521	pn = pn->next;
Lines 557-563 GenerateVncChromiumConnectedEvent(int so Link Here
557	else	558	else
558	conn.ipaddress = (CARD32)peer.sin_addr.s_addr;	559	conn.ipaddress = (CARD32)peer.sin_addr.s_addr;
559		560
560	(void) TryClientEvents(pn->client, (xEventPtr)&conn, 1, NoEventMask,	561	(void) TryClientEvents(pn->client, NULL, (xEventPtr)&conn, 1, NoEventMask,
561	NoEventMask, NullGrab);	562	NoEventMask, NullGrab);
562	}	563	}
563	pn = pn->next;	564	pn = pn->next;
Lines 586-592 GenerateVncDisconnectedEvent(int sock) Link Here
586	conn.type = VncEventBase + XVncDisconnected;	587	conn.type = VncEventBase + XVncDisconnected;
587	conn.sequenceNumber = pn->client->sequence;	588	conn.sequenceNumber = pn->client->sequence;
588	conn.connected = sock;	589	conn.connected = sock;
589	(void) TryClientEvents(pn->client, (xEventPtr)&conn, 1, NoEventMask,	590	(void) TryClientEvents(pn->client, NULL, (xEventPtr)&conn, 1, NoEventMask,
590	NoEventMask, NullGrab);	591	NoEventMask, NullGrab);
591	}	592	}
592	pn = pn->next;	593	pn = pn->next;

Lines 138-144 static void rfbCrossScreen(ScreenPtr pSc Link Here

(-)xorg-server-1.6.1/hw/vnc/init.c (-4 / +3 lines)
138		138
139		139
140	static void	140	static void
141	PointerWarpCursor(ScreenPtr pScreen, int x, int y)	141	PointerWarpCursor(DeviceIntPtr pDev, ScreenPtr pScreen, int x, int y)
142	{	142	{
143	#if 0	143	#if 0
144	DeviceIntPtr pDev = NULL;	144	DeviceIntPtr pDev = NULL;
Lines 775-782 InitInput(argc, argv) Link Here
775	char *argv[];	775	char *argv[];
776	{	776	{
777	DeviceIntPtr p, k;	777	DeviceIntPtr p, k;
778	k = AddInputDevice(rfbKeybdProc, TRUE);	778	k = AddInputDevice(serverClient, rfbKeybdProc, TRUE);
779	p = AddInputDevice(rfbMouseProc, TRUE);	779	p = AddInputDevice(serverClient, rfbMouseProc, TRUE);
780	RegisterKeyboardDevice(k);	780	RegisterKeyboardDevice(k);
781	RegisterPointerDevice(p);	781	RegisterPointerDevice(p);
782		782
Lines 843-849 rfbMouseProc(pDevice, onoff) Link Here
843	map[4] = 4;	843	map[4] = 4;
844	map[5] = 5;	844	map[5] = 5;
845	InitPointerDeviceStruct(pDev, map, 5,	845	InitPointerDeviceStruct(pDev, map, 5,
846	GetMotionHistory,
847	PtrDeviceControl,	846	PtrDeviceControl,
848	GetMaximumEventsNum(), 2 /* numAxes */);	847	GetMaximumEventsNum(), 2 /* numAxes */);
849	vncSetPointerDevice(pDevice);	848	vncSetPointerDevice(pDevice);