Commit e35d6366 authored by Patrik Stridvall's avatar Patrik Stridvall Committed by Alexandre Julliard

Moved more code to the X11 driver.

parent 1c1be3aa
#ifndef __WINE_CLIPBOARD_H
#define __WINE_CLIPBOARD_H
void CLIPBOARD_ResetLock(HQUEUE16 hqRef, HQUEUE16 hqNew);
void CLIPBOARD_ResetOwner(WND* pWnd);
void CLIPBOARD_ReadSelection(Window w, Atom prop);
void CLIPBOARD_ReleaseSelection(Window w, HWND32 hwnd);
BOOL32 CLIPBOARD_IsPresent(WORD wFormat);
#include "win.h"
#include "wintypes.h"
typedef struct tagCLIPFORMAT {
WORD wFormatID;
WORD wRefCount;
WORD wDataPresent;
LPSTR Name;
HANDLE32 hData32;
DWORD BufSize;
struct tagCLIPFORMAT *PrevFormat;
struct tagCLIPFORMAT *NextFormat;
HANDLE16 hData16;
} CLIPFORMAT, *LPCLIPFORMAT;
typedef struct _CLIPBOARD_DRIVER
{
void (*pEmptyClipboard)();
void (*pSetClipboardData)(UINT32);
BOOL32 (*pRequestSelection)();
void (*pResetOwner)(WND *);
} CLIPBOARD_DRIVER;
CLIPBOARD_DRIVER *CLIPBOARD_GetDriver();
extern void CLIPBOARD_ResetLock(HQUEUE16 hqRef, HQUEUE16 hqNew);
extern void CLIPBOARD_DeleteRecord(LPCLIPFORMAT lpFormat, BOOL32 bChange);
extern BOOL32 CLIPBOARD_IsPresent(WORD wFormat);
#endif /* __WINE_CLIPBOARD_H */
......@@ -7,6 +7,8 @@
#ifndef __WINE_KEYBOARD_H
#define __WINE_KEYBOARD_H
#include "wintypes.h"
#pragma pack(1)
typedef struct _KBINFO
{
......@@ -27,8 +29,17 @@ VOID WINAPI KEYBOARD_Disable(VOID);
/* Wine internals */
extern void KEYBOARD_HandleEvent( WND *pWnd, XKeyEvent *event );
extern void KEYBOARD_UpdateState( void );
typedef struct _KEYBOARD_DRIVER {
void (*pInit)();
WORD (*pVkKeyScan)(CHAR);
UINT16 (*pMapVirtualKey)(UINT16, UINT16);
INT16 (*pGetKeyNameText)(LONG, LPSTR, INT16);
INT16 (*pToAscii)(UINT16, UINT16, LPBYTE, LPVOID, UINT16);
} KEYBOARD_DRIVER;
extern KEYBOARD_DRIVER *KEYBOARD_GetDriver();
extern void KEYBOARD_SendEvent(BYTE bVk, BYTE bScan, DWORD dwFlags, DWORD posX, DWORD posY, DWORD time);
#define WINE_KEYBDEVENT_MAGIC ( ('K'<<24)|('E'<<16)|('Y'<<8)|'B' )
typedef struct _WINE_KEYBDEVENT
......
......@@ -9,6 +9,7 @@
#include "win.h"
#include "queue.h"
#include "wintypes.h"
extern DWORD MSG_WineStartTicks; /* Ticks at Wine startup */
......@@ -31,16 +32,32 @@ extern BOOL32 TIMER_GetTimerMsg( MSG16 *msg, HWND32 hwnd,
#define EVENT_IO_EXCEPT 2
/* event.c */
typedef struct _EVENT_DRIVER {
BOOL32 (*pInit)(void);
void (*pAddIO)(int, unsigned);
void (*pDeleteIO)(int, unsigned);
BOOL32 (*pWaitNetEvent)(BOOL32, BOOL32);
void (*pSynchronize)(void);
BOOL32 (*pCheckFocus)(void);
BOOL32 (*pQueryPointer)(DWORD *, DWORD *, DWORD *);
void (*pDummyMotionNotify)(void);
BOOL32 (*pPending)(void);
BOOL16 (*pIsUserIdle)(void);
} EVENT_DRIVER;
extern void EVENT_AddIO( int fd, unsigned flag );
extern BOOL32 EVENT_CheckFocus( void );
extern void EVENT_DeleteIO( int fd, unsigned flag );
extern BOOL32 EVENT_Init( void );
extern BOOL32 EVENT_WaitNetEvent( BOOL32 sleep, BOOL32 peek );
extern void EVENT_Synchronize(void);
extern void EVENT_ProcessEvent( XEvent *event );
extern void EVENT_RegisterWindow( WND *pWnd );
extern void EVENT_DestroyWindow( WND *pWnd );
extern BOOL32 EVENT_CheckFocus( void );
extern BOOL32 EVENT_QueryPointer(DWORD *posX, DWORD *posY, DWORD *state);
extern void EVENT_DummyMotionNotify(void);
extern BOOL32 EVENT_Pending(void);
/* input.c */
extern HWND32 EVENT_Capture( HWND32, INT16 );
extern INT16 EVENT_GetCaptureInfo(void);
extern BOOL32 EVENT_QueryPointer( DWORD *posX, DWORD *posY, DWORD *state );
......
......@@ -7,7 +7,11 @@
#ifndef __WINE_WIN_H
#define __WINE_WIN_H
#include "ts_xlib.h"
#include "config.h"
#ifndef X_DISPLAY_MISSING
#include <X11/Xlib.h>
#endif /* !defined(X_DISPLAY_MISSING) */
#include "ldt.h"
#include "class.h"
......@@ -89,14 +93,18 @@ typedef struct tagWND
typedef struct _WND_DRIVER
{
BOOL32 (*pCreateDesktopWindow)(WND *, CLASS *, BOOL32);
BOOL32 (*pCreateWindow)(WND *, CLASS *, CREATESTRUCT32A *, BOOL32);
BOOL32 (*pDestroyWindow)(WND *);
WND* (*pSetParent)(WND *, WND *);
void (*pForceWindowRaise)(WND *);
void (*pSetWindowPos)(WND *, const WINDOWPOS32 *, BOOL32);
void (*pSetText)(WND *, LPCSTR);
void (*pSetFocus)(WND *);
void (*pPreSizeMove)(WND *);
void (*pPostSizeMove)(WND *);
} WND_DRIVER;
/* X11 windows driver */
/* FIXME: does not belong here */
extern WND_DRIVER X11DRV_WND_Driver;
typedef struct
{
RECT16 rectNormal;
......@@ -130,7 +138,6 @@ extern WND* WIN_FindWndPtr( HWND32 hwnd );
extern WND* WIN_GetDesktop(void);
extern void WIN_DumpWindow( HWND32 hwnd );
extern void WIN_WalkWindows( HWND32 hwnd, int indent );
extern Window WIN_GetXWindow( HWND32 hwnd );
extern BOOL32 WIN_UnlinkWindow( HWND32 hwnd );
extern BOOL32 WIN_LinkWindow( HWND32 hwnd, HWND32 hwndInsertAfter );
extern HWND32 WIN_FindWinToRepaint( HWND32 hwnd, HQUEUE16 hQueue );
......@@ -164,7 +171,6 @@ extern HWND32 ICONTITLE_Create( WND* );
extern BOOL32 ICONTITLE_Init( void );
/* windows/focus.c */
extern void FOCUS_SetXFocus( HWND32 );
extern void FOCUS_SwitchFocus( HWND32 , HWND32 );
extern Display * display;
......
......@@ -5,12 +5,18 @@
#ifndef __WINE_X11DRV_H
#define __WINE_X11DRV_H
#include "config.h"
#include "ts_xlib.h"
#include "ts_xutil.h"
#include "winbase.h"
#include "windows.h"
#include "gdi.h"
#include "xmalloc.h" /* for XCREATEIMAGE macro */
#include "clipboard.h"
#include "keyboard.h"
#include "message.h"
#include "win.h"
/* X physical pen */
typedef struct
......@@ -181,7 +187,6 @@ extern void _XInitImageFuncPtrs(XImage *);
(width), (height), 32, width_bytes ); \
}
/* exported dib functions for now */
/* This structure holds the arguments for DIB_SetImageBits() */
......@@ -213,6 +218,63 @@ extern int *X11DRV_DIB_BuildColorMap( struct tagDC *dc, WORD coloruse,
WORD depth, const BITMAPINFO *info,
int *nColors );
/* X11 windows driver */
extern WND_DRIVER X11DRV_WND_Driver;
#endif /* __WINE_X11DRV_H */
extern Window X11DRV_WND_GetXWindow(HWND32 hwnd);
extern BOOL32 X11DRV_WND_CreateDesktopWindow(WND *wndPtr, CLASS *classPtr, BOOL32 bUnicode);
extern BOOL32 X11DRV_WND_CreateWindow(WND *wndPtr, CLASS *classPtr, CREATESTRUCT32A *cs, BOOL32 bUnicode);
extern BOOL32 X11DRV_WND_DestroyWindow(WND *pWnd);
extern WND *X11DRV_WND_SetParent(WND *wndPtr, WND *pWndParent);
extern void X11DRV_WND_ForceWindowRaise(WND *pWnd);
extern void X11DRV_WND_SetWindowPos(WND *wndPtr, const WINDOWPOS32 *winpos, BOOL32 bSMC_SETXPOS);
extern void X11DRV_WND_SetText(WND *wndPtr, LPCSTR text);
extern void X11DRV_WND_SetFocus(WND *wndPtr);
extern void X11DRV_WND_PreSizeMove(WND *wndPtr);
extern void X11DRV_WND_PostSizeMove(WND *wndPtr);
/* X11 clipboard driver */
extern CLIPBOARD_DRIVER X11DRV_CLIPBOARD_Driver;
extern void X11DRV_CLIPBOARD_EmptyClipboard();
extern void X11DRV_CLIPBOARD_SetClipboardData(UINT32 wFormat);
extern BOOL32 X11DRV_CLIPBOARD_RequestSelection();
extern void X11DRV_CLIPBOARD_ResetOwner(WND *pWnd);
void X11DRV_CLIPBOARD_ReadSelection(Window w, Atom prop);
void X11DRV_CLIPBOARD_ReleaseSelection(Window w, HWND32 hwnd);
/* X11 keyboard driver */
extern KEYBOARD_DRIVER X11DRV_KEYBOARD_Driver;
extern void X11DRV_KEYBOARD_Init(void);
extern WORD X11DRV_KEYBOARD_VkKeyScan(CHAR cChar);
extern UINT16 X11DRV_KEYBOARD_MapVirtualKey(UINT16 wCode, UINT16 wMapType);
extern INT16 X11DRV_KEYBOARD_GetKeyNameText(LONG lParam, LPSTR lpBuffer, INT16 nSize);
extern INT16 X11DRV_KEYBOARD_ToAscii(UINT16 virtKey, UINT16 scanCode, LPBYTE lpKeyState, LPVOID lpChar, UINT16 flags);
/* X11 mouse driver */
#if 0
extern MOUSE_DRIVER X11DRV_MOUSE_Driver;
#endif
/* X11 event driver */
extern EVENT_DRIVER X11DRV_EVENT_Driver;
extern BOOL32 X11DRV_EVENT_Init(void);
extern void X11DRV_EVENT_AddIO(int fd, unsigned flag);
extern void X11DRV_EVENT_DeleteIO(int fd, unsigned flag);
extern BOOL32 X11DRV_EVENT_WaitNetEvent(BOOL32 sleep, BOOL32 peek);
extern void X11DRV_EVENT_Synchronize(void);
extern BOOL32 X11DRV_EVENT_CheckFocus( void );
extern BOOL32 X11DRV_EVENT_QueryPointer(DWORD *posX, DWORD *posY, DWORD *state);
extern void X11DRV_EVENT_DummyMotionNotify(void);
extern BOOL32 X11DRV_EVENT_Pending(void);
extern BOOL16 X11DRV_EVENT_IsUserIdle(void);
#endif /* __WINE_X11DRV_H */
......@@ -60,12 +60,8 @@ void DEFWND_SetText( WND *wndPtr, LPCSTR text )
{
if (!text) text = "";
if (wndPtr->text) HeapFree( SystemHeap, 0, wndPtr->text );
wndPtr->text = HEAP_strdupA( SystemHeap, 0, text );
if (wndPtr->window)
{
TSXStoreName( display, wndPtr->window, wndPtr->text );
TSXSetIconName( display, wndPtr->window, wndPtr->text );
}
wndPtr->text = HEAP_strdupA( SystemHeap, 0, text );
wndPtr->pDriver->pSetText(wndPtr, wndPtr->text);
}
/***********************************************************************
......
......@@ -18,11 +18,12 @@
* an utter mess.)
*/
#include "ts_xlib.h"
#include "config.h"
#include <string.h>
#include <unistd.h>
#include <assert.h>
#include <X11/Xlib.h>
#include <sys/signal.h>
#include "windows.h"
......@@ -470,17 +471,15 @@ static HRESULT WINAPI SysMouseA_SetDataFormat(
if (df->dwFlags == DIDF_ABSAXIS)
mthis->absolute = 1;
else {
Window rw, cr;
int rx, ry, cx, cy;
unsigned int mask;
DWORD rx, ry;
/* We need to get the initial "previous" position to be able
to return deltas */
mthis->absolute = 0;
/* Get the mouse position */
TSXQueryPointer(display, rootWindow, &rw, &cr,
&rx, &ry, &cx, &cy, &mask);
EVENT_QueryPointer(&rx, &ry, NULL);
/* Fill the initial mouse state structure */
mthis->prevX = rx;
mthis->prevY = ry;
......@@ -498,9 +497,7 @@ static HRESULT WINAPI SysMouseA_SetDataFormat(
static HRESULT WINAPI SysMouseA_GetDeviceState(
LPDIRECTINPUTDEVICE32A this,DWORD len,LPVOID ptr
) {
Window rw, cr;
int rx, ry, cx, cy;
unsigned int mask;
DWORD rx, ry, state;
struct DIMOUSESTATE *mstate = (struct DIMOUSESTATE *) ptr;
LPSYSMOUSE32A mthis = (LPSYSMOUSE32A) this;
......@@ -513,8 +510,7 @@ static HRESULT WINAPI SysMouseA_GetDeviceState(
}
/* Get the mouse position */
TSXQueryPointer(display, rootWindow, &rw, &cr,
&rx, &ry, &cx, &cy, &mask);
EVENT_QueryPointer(&rx, &ry, &state);
TRACE(dinput,"(X:%d - Y:%d)\n", rx, ry);
/* Fill the mouse state structure */
......@@ -529,10 +525,10 @@ static HRESULT WINAPI SysMouseA_GetDeviceState(
mthis->prevY = ry;
}
mstate->lZ = 0;
mstate->rgbButtons[0] = (mask & Button1Mask ? 0xFF : 0x00);
mstate->rgbButtons[1] = (mask & Button3Mask ? 0xFF : 0x00); /* Windows button two is X button 3 */
mstate->rgbButtons[2] = (mask & Button2Mask ? 0xFF : 0x00);
mstate->rgbButtons[3] = (mask & Button4Mask ? 0xFF : 0x00);
mstate->rgbButtons[0] = (state & MK_LBUTTON ? 0xFF : 0x00);
mstate->rgbButtons[1] = (state & MK_RBUTTON ? 0xFF : 0x00);
mstate->rgbButtons[2] = (state & MK_MBUTTON ? 0xFF : 0x00);
mstate->rgbButtons[3] = 0x00;
return 0;
}
......
......@@ -5,13 +5,13 @@
*
*/
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include "ts_xlib.h"
#include "ts_xresource.h"
#include "ts_xutil.h"
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include "windows.h"
#include "win.h"
#include "gdi.h"
......@@ -169,7 +169,7 @@ static BOOL32 DISPLAY_DoSetCursor( CURSORICONINFO *ptr )
HWND32 hwnd = GetWindow32( GetDesktopWindow32(), GW_CHILD );
while(hwnd)
{
Window win = WIN_GetXWindow( hwnd );
Window win = X11DRV_WND_GetXWindow( hwnd );
if (win && win!=DefaultRootWindow(display))
XDefineCursor( display, win, cursor );
hwnd = GetWindow32( hwnd, GW_HWNDNEXT );
......
......@@ -17,46 +17,11 @@
static HWND32 hwndFocus = 0;
/*****************************************************************
* FOCUS_SetXFocus
*
* Set the X focus.
* Explicit colormap management seems to work only with OLVWM.
*/
void FOCUS_SetXFocus( HWND32 hwnd )
{
XWindowAttributes win_attr;
Window win;
/* Only mess with the X focus if there's */
/* no desktop window and no window manager. */
if ((rootWindow != DefaultRootWindow(display)) || Options.managed) return;
if (!hwnd) /* If setting the focus to 0, uninstall the colormap */
{
if (COLOR_GetSystemPaletteFlags() & COLOR_PRIVATE)
TSXUninstallColormap( display, COLOR_GetColormap() );
return;
}
/* Set X focus and install colormap */
if (!(win = WIN_GetXWindow( hwnd ))) return;
if (!TSXGetWindowAttributes( display, win, &win_attr ) ||
(win_attr.map_state != IsViewable))
return; /* If window is not viewable, don't change anything */
TSXSetInputFocus( display, win, RevertToParent, CurrentTime );
if (COLOR_GetSystemPaletteFlags() & COLOR_PRIVATE)
TSXInstallColormap( display, COLOR_GetColormap() );
EVENT_Synchronize();
}
/*****************************************************************
* FOCUS_SwitchFocus
*/
void FOCUS_SwitchFocus( HWND32 hFocusFrom, HWND32 hFocusTo )
{
WND *pFocusTo = WIN_FindWndPtr( hFocusTo );
hwndFocus = hFocusTo;
#if 0
......@@ -71,7 +36,8 @@ void FOCUS_SwitchFocus( HWND32 hFocusFrom, HWND32 hFocusTo )
/* According to API docs, the WM_SETFOCUS message is sent AFTER the window
has received the keyboard focus. */
FOCUS_SetXFocus( hFocusTo );
pFocusTo->pDriver->pSetFocus(pFocusTo);
#if 0
SendMessage32A( hFocusTo, WM_SETFOCUS, hFocusFrom, 0 );
......
......@@ -4,6 +4,8 @@
* Copyright 1993, 1994 Alexandre Julliard
*/
#include "ts_xlib.h"
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
......@@ -449,7 +451,7 @@ static BOOL32 MSG_PeekHardwareMsg( MSG16 *msg, HWND16 hwnd, DWORD filter,
/* If the queue is empty, attempt to fill it */
if (!sysMsgQueue->msgCount && THREAD_IsWin16( THREAD_Current() )
&& TSXPending(display))
&& EVENT_Pending())
EVENT_WaitNetEvent( FALSE, FALSE );
for (i = kbd_msg = 0; i < sysMsgQueue->msgCount; i++, pos++)
......
......@@ -2048,9 +2048,10 @@ static void NC_DoSizeMove( HWND32 hwnd, WORD wParam )
else
{ /* Grab the server only when moving top-level windows without desktop */
hdc = GetDC32( 0 );
if (rootWindow == DefaultRootWindow(display)) TSXGrabServer( display );
}
wndPtr->pDriver->pPreSizeMove(wndPtr);
if( iconic ) /* create a cursor for dragging */
{
HICON16 hIcon = (wndPtr->class->hIcon) ? wndPtr->class->hIcon
......@@ -2146,9 +2147,10 @@ static void NC_DoSizeMove( HWND32 hwnd, WORD wParam )
else
{
ReleaseDC32( 0, hdc );
if (rootWindow == DefaultRootWindow(display)) TSXUngrabServer( display );
}
wndPtr->pDriver->pPostSizeMove(wndPtr);
if (HOOK_IsHooked( WH_CBT ))
{
RECT16* pr = SEGPTR_NEW(RECT16);
......
......@@ -31,6 +31,8 @@
#include "winerror.h"
#include "mdi.h"
extern WND_DRIVER X11DRV_WND_Driver;
/* Desktop window */
static WND *pWndDesktop = NULL;
......@@ -146,20 +148,6 @@ void WIN_WalkWindows( HWND32 hwnd, int indent )
}
}
/***********************************************************************
* WIN_GetXWindow
*
* Return the X window associated to a window.
*/
Window WIN_GetXWindow( HWND32 hwnd )
{
WND *wndPtr = WIN_FindWndPtr( hwnd );
while (wndPtr && !wndPtr->window) wndPtr = wndPtr->parent;
return wndPtr ? wndPtr->window : 0;
}
/***********************************************************************
* WIN_UnlinkWindow
*
......@@ -325,7 +313,7 @@ static WND* WIN_DestroyWindow( WND* wndPtr )
if (!(wndPtr->dwStyle & WS_CHILD))
if (wndPtr->wIDmenu) DestroyMenu32( (HMENU32)wndPtr->wIDmenu );
if (wndPtr->hSysMenu) DestroyMenu32( wndPtr->hSysMenu );
if (wndPtr->window) EVENT_DestroyWindow( wndPtr );
wndPtr->pDriver->pDestroyWindow( wndPtr );
DCE_FreeWindowDCE( wndPtr ); /* Always do this to catch orphaned DCs */
WINPROC_FreeProc( wndPtr->winproc, WIN_PROC_WINDOW );
wndPtr->hwndSelf = 0;
......@@ -433,15 +421,15 @@ BOOL32 WIN_CreateDesktopWindow(void)
pWndDesktop->wIDmenu = 0;
pWndDesktop->helpContext = 0;
pWndDesktop->flags = 0;
pWndDesktop->window = rootWindow;
pWndDesktop->hSysMenu = 0;
pWndDesktop->userdata = 0;
pWndDesktop->pDriver = &X11DRV_WND_Driver;
pWndDesktop->expose_event = NULL;
pWndDesktop->winproc = (WNDPROC16)class->winproc;
EVENT_RegisterWindow( pWndDesktop );
/* FIXME: How do we know if it should be Unicode or not */
if(!pWndDesktop->pDriver->pCreateDesktopWindow(pWndDesktop, class, FALSE))
return FALSE;
SendMessage32A( hwndDesktop, WM_NCCREATE, 0, 0 );
pWndDesktop->flags |= WIN_NEEDS_ERASEBKGND;
return TRUE;
......@@ -648,7 +636,8 @@ static HWND32 WIN_CreateWindowEx( CREATESTRUCT32A *cs, ATOM classAtom,
wndPtr->rectWindow.bottom = cs->y + cs->cy;
wndPtr->rectClient = wndPtr->rectWindow;
(*wndPtr->pDriver->pCreateWindow)(wndPtr, classPtr, cs, unicode);
if(!wndPtr->pDriver->pCreateWindow(wndPtr, classPtr, cs, unicode))
return FALSE;
/* Set the window menu */
......@@ -924,7 +913,7 @@ static void WIN_SendDestroyMsg( WND* pWnd )
WIN_CheckFocus(pWnd);
if( CARET_GetHwnd() == pWnd->hwndSelf ) DestroyCaret32();
if( !pWnd->window ) CLIPBOARD_ResetOwner( pWnd );
if( !pWnd->window ) CLIPBOARD_GetDriver()->pResetOwner( pWnd );
SendMessage32A( pWnd->hwndSelf, WM_DESTROY, 0, 0);
......@@ -986,7 +975,7 @@ BOOL32 WINAPI DestroyWindow32( HWND32 hwnd )
if( !IsWindow32(hwnd) ) return TRUE;
}
if( wndPtr->window ) CLIPBOARD_ResetOwner( wndPtr ); /* before the window is unmapped */
if( wndPtr->window ) CLIPBOARD_GetDriver()->pResetOwner( wndPtr ); /* before the window is unmapped */
/* Hide the window */
......
......@@ -6,9 +6,6 @@
*/
#include <string.h>
#include "ts_xlib.h"
#include "ts_xutil.h"
#include <X11/Xatom.h>
#include "sysmetrics.h"
#include "heap.h"
#include "module.h"
......@@ -1435,35 +1432,6 @@ void WINAPI SetInternalWindowPos32( HWND32 hwnd, UINT32 showCmd,
}
}
/***********************************************************************
* WINPOS_ForceXWindowRaise
*
* Raise a window on top of the X stacking order, while preserving
* the correct Windows Z order.
*/
static void WINPOS_ForceXWindowRaise( WND* pWnd )
{
XWindowChanges winChanges;
WND *wndPrev;
/* Raise all windows up to pWnd according to their Z order.
* (it would be easier with sibling-related Below but it doesn't
* work very well with SGI mwm for instance)
*/
winChanges.stack_mode = Above;
while (pWnd)
{
if (pWnd->window) TSXReconfigureWMWindow( display, pWnd->window, 0,
CWStackMode, &winChanges );
wndPrev = WIN_GetDesktop()->child;
if (wndPrev == pWnd) break;
while (wndPrev && (wndPrev->next != pWnd)) wndPrev = wndPrev->next;
pWnd = wndPrev;
}
}
/*******************************************************************
* WINPOS_SetActiveWindow
*
......@@ -1620,9 +1588,8 @@ BOOL32 WINPOS_SetActiveWindow( HWND32 hWnd, BOOL32 fMouse, BOOL32 fChangeFocus)
hwndActive
);
if( !hwndPrevActive && wndPtr &&
wndPtr->window && !(wndPtr->flags & WIN_MANAGED) )
WINPOS_ForceXWindowRaise(wndPtr);
if( !hwndPrevActive && wndPtr )
(*wndPtr->pDriver->pForceWindowRaise)(wndPtr);
/* if active wnd is minimized redraw icon title */
if( IsIconic32(hwndActive) ) WINPOS_RedrawIconTitle(hwndActive);
......@@ -2057,104 +2024,6 @@ static UINT32 WINPOS_SizeMoveClean( WND* Wnd, HRGN32 oldVisRgn,
return uFlags;
}
/***********************************************************************
* WINPOS_FindDeskTopXWindow
*
* Find the actual X window which needs be restacked.
* Used by WINPOS_SetXWindowPos().
*/
static Window WINPOS_FindDeskTopXWindow( WND *wndPtr )
{
if (!(wndPtr->flags & WIN_MANAGED))
return wndPtr->window;
else
{
Window window, root, parent, *children;
int nchildren;
window = wndPtr->window;
for (;;)
{
TSXQueryTree( display, window, &root, &parent,
&children, &nchildren );
TSXFree( children );
if (parent == root)
return window;
window = parent;
}
}
}
/***********************************************************************
* WINPOS_SetXWindowPos
*
* SetWindowPos() for an X window. Used by the real SetWindowPos().
*/
static void WINPOS_SetXWindowPos( const WINDOWPOS32 *winpos )
{
XWindowChanges winChanges;
int changeMask = 0;
WND *wndPtr = WIN_FindWndPtr( winpos->hwnd );
if (!(winpos->flags & SWP_NOSIZE))
{
winChanges.width = winpos->cx;
winChanges.height = winpos->cy;
changeMask |= CWWidth | CWHeight;
/* Tweak dialog window size hints */
if ((wndPtr->flags & WIN_MANAGED) &&
(wndPtr->dwExStyle & WS_EX_DLGMODALFRAME))
{
XSizeHints *size_hints = TSXAllocSizeHints();
if (size_hints)
{
long supplied_return;
TSXGetWMSizeHints( display, wndPtr->window, size_hints,
&supplied_return, XA_WM_NORMAL_HINTS);
size_hints->min_width = size_hints->max_width = winpos->cx;
size_hints->min_height = size_hints->max_height = winpos->cy;
TSXSetWMSizeHints( display, wndPtr->window, size_hints,
XA_WM_NORMAL_HINTS );
TSXFree(size_hints);
}
}
}
if (!(winpos->flags & SWP_NOMOVE))
{
winChanges.x = winpos->x;
winChanges.y = winpos->y;
changeMask |= CWX | CWY;
}
if (!(winpos->flags & SWP_NOZORDER))
{
winChanges.stack_mode = Below;
changeMask |= CWStackMode;
if (winpos->hwndInsertAfter == HWND_TOP) winChanges.stack_mode = Above;
else if (winpos->hwndInsertAfter != HWND_BOTTOM)
{
WND* insertPtr = WIN_FindWndPtr( winpos->hwndInsertAfter );
Window stack[2];
stack[0] = WINPOS_FindDeskTopXWindow( insertPtr );
stack[1] = WINPOS_FindDeskTopXWindow( wndPtr );
/* for stupid window managers (i.e. all of them) */
TSXRestackWindows(display, stack, 2);
changeMask &= ~CWStackMode;
}
}
if (!changeMask) return;
TSXReconfigureWMWindow( display, wndPtr->window, 0, changeMask, &winChanges );
}
/***********************************************************************
* SetWindowPos (USER.232)
*/
......@@ -2364,7 +2233,7 @@ BOOL32 WINAPI SetWindowPos32( HWND32 hwnd, HWND32 hwndInsertAfter,
if( !(flags & (SWP_SHOWWINDOW | SWP_HIDEWINDOW)) )
{
WINPOS_SetXWindowPos( &winpos );
wndPtr->pDriver->pSetWindowPos(wndPtr, &winpos, TRUE);
winpos.hwndInsertAfter = tempInsertAfter;
}
else uFlags |= SMC_SETXPOS;
......@@ -2459,12 +2328,12 @@ BOOL32 WINAPI SetWindowPos32( HWND32 hwnd, HWND32 hwndInsertAfter,
{
HWND32 focus, curr;
wndPtr->pDriver->pSetWindowPos(wndPtr, &winpos, uFlags & SMC_SETXPOS );
if( uFlags & SMC_SETXPOS )
{
WINPOS_SetXWindowPos( &winpos );
winpos.hwndInsertAfter = tempInsertAfter;
}
TSXMapWindow( display, wndPtr->window );
if (wndPtr->flags & WIN_MANAGED) resync = TRUE;
/* If focus was set to an unmapped window, reset X focus now */
......@@ -2488,19 +2357,18 @@ BOOL32 WINAPI SetWindowPos32( HWND32 hwnd, HWND32 hwndInsertAfter,
}
else if (flags & SWP_HIDEWINDOW)
{
wndPtr->dwStyle &= ~WS_VISIBLE;
if (wndPtr->window)
{
if (wndPtr->dwStyle & WS_VISIBLE) TSXUnmapWindow( display, wndPtr->window );
wndPtr->dwStyle &= ~WS_VISIBLE;
if( uFlags & SMC_SETXPOS )
{
WINPOS_SetXWindowPos( &winpos );
winpos.hwndInsertAfter = tempInsertAfter;
}
wndPtr->pDriver->pSetWindowPos(wndPtr, &winpos, uFlags & SMC_SETXPOS );
if( uFlags & SMC_SETXPOS )
{
winpos.hwndInsertAfter = tempInsertAfter;
}
}
else
{
wndPtr->dwStyle &= ~WS_VISIBLE;
if (!(flags & SWP_NOREDRAW))
PAINT_RedrawWindow( wndPtr->parent->hwndSelf, &oldWindowRect,
0, RDW_INVALIDATE | RDW_ALLCHILDREN |
......
......@@ -6,7 +6,12 @@ VPATH = @srcdir@
MODULE = x11drv
C_SRCS = \
init.c
clipboard.c \
event.c \
init.c \
keyboard.c \
mouse.c \
wnd.c
all: $(MODULE).o
......
/*
* X11 windows driver
*
* Copyright 1994 Martin Ayotte
* 1996 Alex Korobka
*/
#include "config.h"
#ifndef X_DISPLAY_MISSING
#include <X11/Xatom.h>
#include "ts_xlib.h"
#include "windows.h"
#include "wintypes.h"
#include "clipboard.h"
#include "debug.h"
#include "message.h"
#include "win.h"
#include "x11drv.h"
extern HWND32 hWndClipOwner;
extern HWND32 hWndClipWindow;
extern CLIPFORMAT ClipFormats[];
static Bool selectionWait = False;
static Bool selectionAcquired = False;
static Window selectionWindow = None;
static Window selectionPrevWindow = None;
/**************************************************************************
* X11DRV_CLIPBOARD_CheckSelection [Internal]
*
* Prevent X selection from being lost when a top level window is
* destroyed.
*/
static void X11DRV_CLIPBOARD_CheckSelection(WND* pWnd)
{
TRACE(clipboard,"\tchecking %08x\n", (unsigned)pWnd->window);
if( selectionAcquired && selectionWindow != None &&
pWnd->window == selectionWindow )
{
selectionPrevWindow = selectionWindow;
selectionWindow = None;
if( pWnd->next )
selectionWindow = pWnd->next->window;
else if( pWnd->parent )
if( pWnd->parent->child != pWnd )
selectionWindow = pWnd->parent->child->window;
TRACE(clipboard,"\tswitching selection from %08x to %08x\n",
(unsigned)selectionPrevWindow, (unsigned)selectionWindow);
if( selectionWindow != None )
{
TSXSetSelectionOwner(display, XA_PRIMARY, selectionWindow, CurrentTime);
if( TSXGetSelectionOwner(display, XA_PRIMARY) != selectionWindow )
selectionWindow = None;
}
}
}
/**************************************************************************
* X11DRV_CLIPBOARD_ReadSelection
*
* Called from the SelectionNotify event handler.
*/
void X11DRV_CLIPBOARD_ReadSelection(Window w,Atom prop)
{
HANDLE32 hText = 0;
LPCLIPFORMAT lpFormat = ClipFormats;
TRACE(clipboard,"ReadSelection callback\n");
if(prop != None)
{
Atom atype=AnyPropertyType;
int aformat;
unsigned long nitems,remain;
unsigned char* val=NULL;
TRACE(clipboard,"\tgot property %s\n",TSXGetAtomName(display,prop));
/* TODO: Properties longer than 64K */
if(TSXGetWindowProperty(display,w,prop,0,0x3FFF,True,XA_STRING,
&atype, &aformat, &nitems, &remain, &val) != Success)
WARN(clipboard, "\tcouldn't read property\n");
else
{
TRACE(clipboard,"\tType %s,Format %d,nitems %ld,value %s\n",
TSXGetAtomName(display,atype),aformat,nitems,val);
if(atype == XA_STRING && aformat == 8)
{
int i,inlcount = 0;
char* lpstr;
TRACE(clipboard,"\tselection is '%s'\n",val);
for(i=0; i <= nitems; i++)
if( val[i] == '\n' ) inlcount++;
if( nitems )
{
hText=GlobalAlloc32(GMEM_MOVEABLE, nitems + inlcount + 1);
if( (lpstr = (char*)GlobalLock32(hText)) )
for(i=0,inlcount=0; i <= nitems; i++)
{
if( val[i] == '\n' ) lpstr[inlcount++]='\r';
lpstr[inlcount++]=val[i];
}
else hText = 0;
}
}
TSXFree(val);
}
}
/* delete previous CF_TEXT and CF_OEMTEXT data */
if( hText )
{
lpFormat = &ClipFormats[CF_TEXT-1];
if (lpFormat->wDataPresent || lpFormat->hData16 || lpFormat->hData32)
CLIPBOARD_DeleteRecord(lpFormat, !(hWndClipWindow));
lpFormat = &ClipFormats[CF_OEMTEXT-1];
if (lpFormat->wDataPresent || lpFormat->hData16 || lpFormat->hData32)
CLIPBOARD_DeleteRecord(lpFormat, !(hWndClipWindow));
lpFormat->wDataPresent = 1;
lpFormat->hData32 = hText;
lpFormat->hData16 = 0;
}
selectionWait=False;
}
/**************************************************************************
* X11DRV_CLIPBOARD_ReleaseSelection
*
* Wine might have lost XA_PRIMARY selection because of
* EmptyClipboard() or other client.
*/
void X11DRV_CLIPBOARD_ReleaseSelection(Window w, HWND32 hwnd)
{
/* w is the window that lost selection,
*
* selectionPrevWindow is nonzero if CheckSelection() was called.
*/
TRACE(clipboard,"\tevent->window = %08x (sw = %08x, spw=%08x)\n",
(unsigned)w, (unsigned)selectionWindow, (unsigned)selectionPrevWindow );
if( selectionAcquired )
{
if( w == selectionWindow || selectionPrevWindow == None)
{
/* alright, we really lost it */
selectionAcquired = False;
selectionWindow = None;
/* but we'll keep existing data for internal use */
}
else if( w == selectionPrevWindow )
{
w = TSXGetSelectionOwner(display, XA_PRIMARY);
if( w == None )
TSXSetSelectionOwner(display, XA_PRIMARY, selectionWindow, CurrentTime);
}
}
selectionPrevWindow = None;
}
/**************************************************************************
* X11DRV_CLIPBOARD_EmptyClipboard
*/
void X11DRV_CLIPBOARD_EmptyClipboard()
{
if(selectionAcquired)
{
selectionAcquired = False;
selectionPrevWindow = selectionWindow;
selectionWindow = None;
TRACE(clipboard, "\tgiving up selection (spw = %08x)\n",
(unsigned)selectionPrevWindow);
TSXSetSelectionOwner(display, XA_PRIMARY, None, CurrentTime);
}
}
/**************************************************************************
* X11DRV_CLIPBOARD_SetClipboardData
*/
void X11DRV_CLIPBOARD_SetClipboardData(UINT32 wFormat)
{
Window owner;
/* Acquire X selection if text format */
if( !selectionAcquired &&
(wFormat == CF_TEXT || wFormat == CF_OEMTEXT) )
{
owner = X11DRV_WND_GetXWindow( hWndClipWindow ? hWndClipWindow : AnyPopup32() );
TSXSetSelectionOwner(display,XA_PRIMARY, owner, CurrentTime);
if( TSXGetSelectionOwner(display,XA_PRIMARY) == owner )
{
selectionAcquired = True;
selectionWindow = owner;
TRACE(clipboard,"Grabbed X selection, owner=(%08x)\n",
(unsigned) owner);
}
}
}
/**************************************************************************
* X11DRV_CLIPBOARD_RequestSelection
*/
BOOL32 X11DRV_CLIPBOARD_RequestSelection()
{
HWND32 hWnd = (hWndClipWindow) ? hWndClipWindow : GetActiveWindow32();
if( selectionAcquired )
return TRUE;
if( !hWnd ) return FALSE;
TRACE(clipboard,"Requesting selection...\n");
/* request data type XA_STRING, later
* CLIPBOARD_ReadSelection() will be invoked
* from the SelectionNotify event handler */
TSXConvertSelection(display,XA_PRIMARY,XA_STRING,
TSXInternAtom(display,"PRIMARY_TEXT",False),
X11DRV_WND_GetXWindow(hWnd),CurrentTime);
/* wait until SelectionNotify is processed
*
* FIXME: Use TSXCheckTypedWindowEvent() instead ( same in the
* CLIPBOARD_CheckSelection() ).
*/
selectionWait=True;
while(selectionWait) EVENT_WaitNetEvent( TRUE, FALSE );
/* we treat Unix text as CF_OEMTEXT */
TRACE(clipboard,"\tgot CF_OEMTEXT = %i\n",
ClipFormats[CF_OEMTEXT-1].wDataPresent);
return (BOOL32)ClipFormats[CF_OEMTEXT-1].wDataPresent;
}
/**************************************************************************
* X11DRV_CLIPBOARD_ResetOwner
*
* Called from DestroyWindow().
*/
void X11DRV_CLIPBOARD_ResetOwner(WND *pWnd)
{
LPCLIPFORMAT lpFormat = ClipFormats;
TRACE(clipboard,"clipboard owner = %04x, selection = %08x\n",
hWndClipOwner, (unsigned)selectionWindow);
if( pWnd->hwndSelf == hWndClipOwner)
{
SendMessage16(hWndClipOwner,WM_RENDERALLFORMATS,0,0L);
/* check if all formats were rendered */
while(lpFormat)
{
if( lpFormat->wDataPresent && !lpFormat->hData16 && !lpFormat->hData32 )
{
TRACE(clipboard,"\tdata missing for clipboard format %i\n",
lpFormat->wFormatID);
lpFormat->wDataPresent = 0;
}
lpFormat = lpFormat->NextFormat;
}
hWndClipOwner = 0;
}
/* now try to salvage current selection from being destroyed by X */
if( pWnd->window ) X11DRV_CLIPBOARD_CheckSelection(pWnd);
}
#endif /* !defined(X_DISPLAY_MISSING) */
/*
* X11 windows driver
* X11 driver
*
* Copyright 1993, 1994 Alexandre Julliard
* Copyright 1998 Patrik Stridvall
*/
#include <string.h>
#include <X11/Xatom.h>
#include "ts_xlib.h"
#include "color.h"
#include "display.h"
#include "dce.h"
#include "options.h"
#include "message.h"
#include "win.h"
#include "windows.h"
#include "x11drv.h"
#include "config.h"
#ifndef X_DISPLAY_MISSING
static BOOL32 X11DRV_WND_CreateWindow(WND *wndPtr, CLASS *classPtr, CREATESTRUCT32A *cs, BOOL32 bUnicode);
static WND *X11DRV_WND_SetParent(WND *wndPtr, WND *pWndParent);
#include "x11drv.h"
WND_DRIVER X11DRV_WND_Driver =
{
X11DRV_WND_CreateWindow,
X11DRV_WND_SetParent
X11DRV_WND_CreateDesktopWindow,
X11DRV_WND_CreateWindow,
X11DRV_WND_DestroyWindow,
X11DRV_WND_SetParent,
X11DRV_WND_ForceWindowRaise,
X11DRV_WND_SetWindowPos,
X11DRV_WND_SetText,
X11DRV_WND_SetFocus,
X11DRV_WND_PreSizeMove,
X11DRV_WND_PostSizeMove
};
extern Cursor DISPLAY_XCursor; /* Current X cursor */
CLIPBOARD_DRIVER X11DRV_CLIPBOARD_Driver =
{
X11DRV_CLIPBOARD_EmptyClipboard,
X11DRV_CLIPBOARD_SetClipboardData,
X11DRV_CLIPBOARD_RequestSelection,
X11DRV_CLIPBOARD_ResetOwner
};
/**********************************************************************
* X11DRV_WND_CreateWindow [Internal]
*/
static BOOL32 X11DRV_WND_CreateWindow(WND *wndPtr, CLASS *classPtr, CREATESTRUCT32A *cs, BOOL32 bUnicode)
KEYBOARD_DRIVER X11DRV_KEYBOARD_Driver =
{
/* Create the X window (only for top-level windows, and then only */
/* when there's no desktop window) */
if (!(cs->style & WS_CHILD) && (rootWindow == DefaultRootWindow(display)))
{
XSetWindowAttributes win_attr;
if (Options.managed && ((cs->style & (WS_DLGFRAME | WS_THICKFRAME)) ||
(cs->dwExStyle & WS_EX_DLGMODALFRAME)))
{
win_attr.event_mask = ExposureMask | KeyPressMask |
KeyReleaseMask | PointerMotionMask |
ButtonPressMask | ButtonReleaseMask |
FocusChangeMask | StructureNotifyMask;
win_attr.override_redirect = FALSE;
wndPtr->flags |= WIN_MANAGED;
}
else
{
win_attr.event_mask = ExposureMask | KeyPressMask |
KeyReleaseMask | PointerMotionMask |
ButtonPressMask | ButtonReleaseMask |
FocusChangeMask;
win_attr.override_redirect = TRUE;
}
win_attr.colormap = COLOR_GetColormap();
win_attr.backing_store = Options.backingstore ? WhenMapped : NotUseful;
win_attr.save_under = ((classPtr->style & CS_SAVEBITS) != 0);
win_attr.cursor = DISPLAY_XCursor;
wndPtr->window = TSXCreateWindow( display, rootWindow, cs->x, cs->y,
cs->cx, cs->cy, 0, CopyFromParent,
InputOutput, CopyFromParent,
CWEventMask | CWOverrideRedirect |
CWColormap | CWCursor | CWSaveUnder |
CWBackingStore, &win_attr );
X11DRV_KEYBOARD_Init,
X11DRV_KEYBOARD_VkKeyScan,
X11DRV_KEYBOARD_MapVirtualKey,
X11DRV_KEYBOARD_GetKeyNameText,
X11DRV_KEYBOARD_ToAscii
};
if ((wndPtr->flags & WIN_MANAGED) &&
(cs->dwExStyle & WS_EX_DLGMODALFRAME))
{
XSizeHints* size_hints = TSXAllocSizeHints();
if (size_hints)
{
size_hints->min_width = size_hints->max_width = cs->cx;
size_hints->min_height = size_hints->max_height = cs->cy;
size_hints->flags = (PSize | PMinSize | PMaxSize);
TSXSetWMSizeHints( display, wndPtr->window, size_hints,
XA_WM_NORMAL_HINTS );
TSXFree(size_hints);
}
}
if (cs->hwndParent) /* Get window owner */
{
Window win = WIN_GetXWindow( cs->hwndParent );
if (win) TSXSetTransientForHint( display, wndPtr->window, win );
}
EVENT_RegisterWindow( wndPtr );
}
return TRUE;
}
EVENT_DRIVER X11DRV_EVENT_Driver =
{
X11DRV_EVENT_Init,
X11DRV_EVENT_AddIO,
X11DRV_EVENT_DeleteIO,
X11DRV_EVENT_WaitNetEvent,
X11DRV_EVENT_Synchronize,
X11DRV_EVENT_CheckFocus,
X11DRV_EVENT_QueryPointer,
X11DRV_EVENT_DummyMotionNotify,
X11DRV_EVENT_Pending,
X11DRV_EVENT_IsUserIdle
};
/*****************************************************************
* X11DRV_WND_SetParent [Internal]
*/
static WND *X11DRV_WND_SetParent(WND *wndPtr, WND *pWndParent)
#if 0
MOUSE_DRIVER X11DRV_MOUSE_Driver =
{
if( wndPtr && pWndParent && (wndPtr != WIN_GetDesktop()) )
{
WND* pWndPrev = wndPtr->parent;
};
#endif
#endif /* !defined(X_DISPLAY_MISSING) */
if( pWndParent != pWndPrev )
{
BOOL32 bFixupDCE = IsWindowVisible32(wndPtr->hwndSelf);
if ( wndPtr->window )
{
/* Toplevel window needs to be reparented. Used by Tk 8.0 */
TSXDestroyWindow( display, wndPtr->window );
wndPtr->window = None;
}
else if( bFixupDCE )
DCE_InvalidateDCE( wndPtr, &wndPtr->rectWindow );
WIN_UnlinkWindow(wndPtr->hwndSelf);
wndPtr->parent = pWndParent;
/* FIXME: Create an X counterpart for reparented top-level windows
* when not in the desktop mode. */
if ( pWndParent != WIN_GetDesktop() ) wndPtr->dwStyle |= WS_CHILD;
WIN_LinkWindow(wndPtr->hwndSelf, HWND_BOTTOM);
if( bFixupDCE )
{
DCE_InvalidateDCE( wndPtr, &wndPtr->rectWindow );
UpdateWindow32(wndPtr->hwndSelf);
}
}
return pWndPrev;
} /* failure */
return 0;
}
/*
* X11 windows driver
*
* Copyright 1998 Patrik Stridvall
*/
#include "config.h"
#ifndef X_DISPLAY_MISSING
#include "x11drv.h"
#endif /* !defined(X_DISPLAY_MISSING) */
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment