Sweden-Number/windows/x11drv/mouse.c

219 lines
8.0 KiB
C
Raw Normal View History

1998-12-07 10:13:40 +01:00
/*
1998-12-26 13:00:43 +01:00
* X11 mouse driver
1998-12-07 10:13:40 +01:00
*
1998-12-26 13:00:43 +01:00
* Copyright 1998 Ulrich Weigand
1998-12-07 10:13:40 +01:00
*/
#include "config.h"
#ifndef X_DISPLAY_MISSING
1998-12-26 13:00:43 +01:00
#include "ts_xlib.h"
#include "callback.h"
1999-02-04 12:11:01 +01:00
#include "debug.h"
#include "display.h"
#include "win.h"
1998-12-26 13:00:43 +01:00
#include "wintypes.h"
1998-12-07 10:13:40 +01:00
#include "x11drv.h"
1998-12-26 13:00:43 +01:00
/**********************************************************************/
1999-02-04 12:11:01 +01:00
Cursor X11DRV_MOUSE_XCursor = None; /* Current X cursor */
1998-12-26 13:00:43 +01:00
1999-02-04 12:11:01 +01:00
BOOL32 X11DRV_MOUSE_DisableWarpPointer = FALSE; /* hack; see DISPLAY_MoveCursor */
1998-12-26 13:00:43 +01:00
/***********************************************************************
* X11DRV_MOUSE_DoSetCursor
*/
static BOOL32 X11DRV_MOUSE_DoSetCursor( CURSORICONINFO *ptr )
{
Pixmap pixmapBits, pixmapMask, pixmapAll;
XColor fg, bg;
Cursor cursor = None;
if (!ptr) /* Create an empty cursor */
{
static const char data[] = { 0 };
bg.red = bg.green = bg.blue = 0x0000;
1999-02-04 12:11:01 +01:00
pixmapBits = XCreateBitmapFromData( display, X11DRV_GetXRootWindow(), data, 1, 1 );
1998-12-26 13:00:43 +01:00
if (pixmapBits)
{
cursor = XCreatePixmapCursor( display, pixmapBits, pixmapBits,
&bg, &bg, 0, 0 );
XFreePixmap( display, pixmapBits );
}
}
else /* Create the X cursor from the bits */
{
XImage *image;
if (ptr->bPlanes * ptr->bBitsPerPixel != 1)
{
WARN(cursor, "Cursor has more than 1 bpp!\n" );
return FALSE;
}
/* Create a pixmap and transfer all the bits to it */
/* NOTE: Following hack works, but only because XFree depth
* 1 images really use 1 bit/pixel (and so the same layout
* as the Windows cursor data). Perhaps use a more generic
* algorithm here.
*/
1999-02-04 12:11:01 +01:00
pixmapAll = XCreatePixmap( display, X11DRV_GetXRootWindow(),
1998-12-26 13:00:43 +01:00
ptr->nWidth, ptr->nHeight * 2, 1 );
1999-02-04 12:11:01 +01:00
image = XCreateImage( display, DefaultVisualOfScreen(X11DRV_GetXScreen()),
1998-12-26 13:00:43 +01:00
1, ZPixmap, 0, (char *)(ptr + 1), ptr->nWidth,
ptr->nHeight * 2, 16, ptr->nWidthBytes);
if (image)
{
image->byte_order = MSBFirst;
image->bitmap_bit_order = MSBFirst;
image->bitmap_unit = 16;
_XInitImageFuncPtrs(image);
if (pixmapAll)
XPutImage( display, pixmapAll, BITMAP_monoGC, image,
0, 0, 0, 0, ptr->nWidth, ptr->nHeight * 2 );
image->data = NULL;
XDestroyImage( image );
}
/* Now create the 2 pixmaps for bits and mask */
1999-02-04 12:11:01 +01:00
pixmapBits = XCreatePixmap( display, X11DRV_GetXRootWindow(),
1998-12-26 13:00:43 +01:00
ptr->nWidth, ptr->nHeight, 1 );
1999-02-04 12:11:01 +01:00
pixmapMask = XCreatePixmap( display, X11DRV_GetXRootWindow(),
1998-12-26 13:00:43 +01:00
ptr->nWidth, ptr->nHeight, 1 );
/* Make sure everything went OK so far */
if (pixmapBits && pixmapMask && pixmapAll)
{
/* We have to do some magic here, as cursors are not fully
* compatible between Windows and X11. Under X11, there
* are only 3 possible color cursor: black, white and
* masked. So we map the 4th Windows color (invert the
* bits on the screen) to black. This require some boolean
* arithmetic:
*
* Windows | X11
* Xor And Result | Bits Mask Result
* 0 0 black | 0 1 background
* 0 1 no change | X 0 no change
* 1 0 white | 1 1 foreground
* 1 1 inverted | 0 1 background
*
* which gives:
* Bits = 'Xor' and not 'And'
* Mask = 'Xor' or not 'And'
*
* FIXME: apparently some servers do support 'inverted' color.
* I don't know if it's correct per the X spec, but maybe
* we ought to take advantage of it. -- AJ
*/
XCopyArea( display, pixmapAll, pixmapBits, BITMAP_monoGC,
0, 0, ptr->nWidth, ptr->nHeight, 0, 0 );
XCopyArea( display, pixmapAll, pixmapMask, BITMAP_monoGC,
0, 0, ptr->nWidth, ptr->nHeight, 0, 0 );
XSetFunction( display, BITMAP_monoGC, GXandReverse );
XCopyArea( display, pixmapAll, pixmapBits, BITMAP_monoGC,
0, ptr->nHeight, ptr->nWidth, ptr->nHeight, 0, 0 );
XSetFunction( display, BITMAP_monoGC, GXorReverse );
XCopyArea( display, pixmapAll, pixmapMask, BITMAP_monoGC,
0, ptr->nHeight, ptr->nWidth, ptr->nHeight, 0, 0 );
XSetFunction( display, BITMAP_monoGC, GXcopy );
fg.red = fg.green = fg.blue = 0xffff;
bg.red = bg.green = bg.blue = 0x0000;
cursor = XCreatePixmapCursor( display, pixmapBits, pixmapMask,
&fg, &bg, ptr->ptHotSpot.x, ptr->ptHotSpot.y );
}
/* Now free everything */
if (pixmapAll) XFreePixmap( display, pixmapAll );
if (pixmapBits) XFreePixmap( display, pixmapBits );
if (pixmapMask) XFreePixmap( display, pixmapMask );
}
if (cursor == None) return FALSE;
1999-02-04 12:11:01 +01:00
if (X11DRV_MOUSE_XCursor != None) XFreeCursor( display, X11DRV_MOUSE_XCursor );
X11DRV_MOUSE_XCursor = cursor;
1998-12-26 13:00:43 +01:00
1999-02-04 12:11:01 +01:00
if (X11DRV_GetXRootWindow() != DefaultRootWindow(display) || !WIN_GetDesktop())
1998-12-26 13:00:43 +01:00
{
/* Set the cursor on the desktop window */
1999-02-04 12:11:01 +01:00
XDefineCursor( display, X11DRV_GetXRootWindow(), cursor );
1998-12-26 13:00:43 +01:00
}
else
{
/* FIXME: this won't work correctly with native USER !*/
/* Set the same cursor for all top-level windows */
HWND32 hwnd = GetWindow32( GetDesktopWindow32(), GW_CHILD );
while(hwnd)
{
Window win = X11DRV_WND_FindXWindow( WIN_FindWndPtr( hwnd ) );
if (win && win!=DefaultRootWindow(display))
XDefineCursor( display, win, cursor );
hwnd = GetWindow32( hwnd, GW_HWNDNEXT );
}
}
return TRUE;
}
/***********************************************************************
* X11DRV_MOUSE_SetCursor
*/
void X11DRV_MOUSE_SetCursor( CURSORICONINFO *lpCursor )
{
EnterCriticalSection( &X11DRV_CritSection );
CALL_LARGE_STACK( X11DRV_MOUSE_DoSetCursor, lpCursor );
LeaveCriticalSection( &X11DRV_CritSection );
}
/***********************************************************************
* X11DRV_MOUSE_MoveCursor
*/
void X11DRV_MOUSE_MoveCursor(WORD wAbsX, WORD wAbsY)
{
/*
* We do not want the to create MotionNotify events here,
* otherwise we will get an endless recursion:
* XMotionEvent -> MOUSEEVENTF_MOVE -> mouse_event -> DisplayMoveCursor
* -> XWarpPointer -> XMotionEvent -> ...
*
* Unfortunately, the XWarpPointer call does create a MotionNotify
* event. So, we use a hack: before MOUSE_SendEvent calls the mouse event
* procedure, it sets a global flag. If this flag is set, we skip the
* XWarpPointer call. If we are *not* called from within MOUSE_SendEvent,
* we will call XWarpPointer, which will create a MotionNotify event.
* Strictly speaking, this is also wrong, but that should normally not
* have any negative effects ...
*
* But first of all, we check whether we already are at the position
* are supposed to move to; if so, we don't need to do anything.
*/
Window root, child;
int rootX, rootY, winX, winY;
unsigned int xstate;
1999-02-04 12:11:01 +01:00
if (X11DRV_MOUSE_DisableWarpPointer) return;
1998-12-26 13:00:43 +01:00
1999-02-04 12:11:01 +01:00
if (!TSXQueryPointer( display, X11DRV_GetXRootWindow(), &root, &child,
1998-12-26 13:00:43 +01:00
&rootX, &rootY, &winX, &winY, &xstate ))
return;
if ( winX == wAbsX && winY == wAbsY )
return;
TRACE( cursor, "(%d,%d): moving from (%d,%d)\n", wAbsX, wAbsY, winX, winY );
1999-02-04 12:11:01 +01:00
TSXWarpPointer( display, X11DRV_GetXRootWindow(), X11DRV_GetXRootWindow(),
0, 0, 0, 0, wAbsX, wAbsY );
1998-12-26 13:00:43 +01:00
}
1998-12-07 10:13:40 +01:00
#endif /* !defined(X_DISPLAY_MISSING) */