windows/event.c

   1 /*
   2  * X events handling functions
   3  *
   4  * Copyright 1993 Alexandre Julliard
   5  *
   6  */
   7
   8 #include <assert.h>
   9 #include <ctype.h>
  10 #include <stdlib.h>
  11 #include <string.h>
  12 #include <unistd.h>
  13 #include <sys/time.h>
  14 #include <sys/types.h>
  15 #include <errno.h>
  16 #include <X11/keysym.h>
  17 #include "ts_xlib.h"
  18 #include "ts_xresource.h"
  19 #include "ts_xutil.h"
  20 #include <X11/Xatom.h>
  21
  22 #include "windows.h"
  23 #include "winnt.h"
  24 #include "gdi.h"
  25 #include "heap.h"
  26 #include "queue.h"
  27 #include "win.h"
  28 #include "class.h"
  29 #include "clipboard.h"
  30 #include "dce.h"
  31 #include "message.h"
  32 #include "module.h"
  33 #include "options.h"
  34 #include "queue.h"
  35 #include "winpos.h"
  36 #include "drive.h"
  37 #include "shell.h"
  38 #include "keyboard.h"
  39 #include "mouse.h"
  40 #include "debug.h"
  41 #include "dde_proc.h"
  42 #include "winsock.h"
  43 #include "mouse.h"
  44
  45
  46 #define NB_BUTTONS      3     /* Windows can handle 3 buttons */
  47
  48 #define DndNotDnd       -1    /* OffiX drag&drop */
  49 #define DndUnknown      0
  50 #define DndRawData      1
  51 #define DndFile         2
  52 #define DndFiles        3
  53 #define DndText         4
  54 #define DndDir          5
  55 #define DndLink         6
  56 #define DndExe          7
  57
  58 #define DndEND          8
  59
  60 #define DndURL          128   /* KDE drag&drop */
  61
  62
  63   /* X context to associate a hwnd to an X window */
  64 static XContext winContext = 0;
  65
  66 static Atom wmProtocols = None;
  67 static Atom wmDeleteWindow = None;
  68 static Atom dndProtocol = None;
  69 static Atom dndSelection = None;
  70
  71 /* EVENT_WaitNetEvent() master fd sets */
  72
  73 static fd_set __event_io_set[3];
  74 static int    __event_max_fd = 0;
  75 static int    __event_x_connection = 0;
  76
  77 static const char * const event_names[] =
  78 {
  79     "", "", "KeyPress", "KeyRelease", "ButtonPress", "ButtonRelease",
  80     "MotionNotify", "EnterNotify", "LeaveNotify", "FocusIn", "FocusOut",
  81     "KeymapNotify", "Expose", "GraphicsExpose", "NoExpose", "VisibilityNotify",
  82     "CreateNotify", "DestroyNotify", "UnmapNotify", "MapNotify", "MapRequest",
  83     "ReparentNotify", "ConfigureNotify", "ConfigureRequest", "GravityNotify",
  84     "ResizeRequest", "CirculateNotify", "CirculateRequest", "PropertyNotify",
  85     "SelectionClear", "SelectionRequest", "SelectionNotify", "ColormapNotify",
  86     "ClientMessage", "MappingNotify"
  87 };
  88
  89   /* Event handlers */
  90 static void EVENT_Key( WND *pWnd, XKeyEvent *event );
  91 static void EVENT_ButtonPress( WND *pWnd, XButtonEvent *event );
  92 static void EVENT_ButtonRelease( WND *pWnd, XButtonEvent *event );
  93 static void EVENT_MotionNotify( WND *pWnd, XMotionEvent *event );
  94 static void EVENT_FocusIn( WND *pWnd, XFocusChangeEvent *event );
  95 static void EVENT_FocusOut( WND *pWnd, XFocusChangeEvent *event );
  96 static int  EVENT_Expose( WND *pWnd, XExposeEvent *event );
  97 static void EVENT_GraphicsExpose( WND *pWnd, XGraphicsExposeEvent *event );
  98 static void EVENT_ConfigureNotify( WND *pWnd, XConfigureEvent *event );
  99 static void EVENT_SelectionRequest( WND *pWnd, XSelectionRequestEvent *event);
 100 static void EVENT_SelectionNotify( XSelectionEvent *event);
 101 static void EVENT_SelectionClear( WND *pWnd, XSelectionClearEvent *event);
 102 static void EVENT_ClientMessage( WND *pWnd, XClientMessageEvent *event );
 103 static void EVENT_MapNotify( HWND32 hwnd, XMapEvent *event );
 104
 105 /* Usable only with OLVWM - compile option perhaps?
 106 static void EVENT_EnterNotify( WND *pWnd, XCrossingEvent *event );
 107 */
 108
 109 static void EVENT_GetGeometry( Window win, int *px, int *py,
 110                                unsigned int *pwidth, unsigned int *pheight );
 111
 112 /***********************************************************************
 113  *           EVENT_Init
 114  *
 115  * Initialize network IO.
 116  */
 117 BOOL32 EVENT_Init(void)
 118 {
 119     int  i;
 120     for( i = 0; i < 3; i++ )
 121         FD_ZERO( __event_io_set + i );
 122
 123     __event_max_fd = __event_x_connection = ConnectionNumber(display);
 124     FD_SET( __event_x_connection, &__event_io_set[EVENT_IO_READ] );
 125     __event_max_fd++;
 126     return TRUE;
 127 }
 128
 129 /***********************************************************************
 130  *          EVENT_AddIO
 131  */
 132 void EVENT_AddIO( int fd, unsigned io_type )
 133 {
 134     FD_SET( fd, &__event_io_set[io_type] );
 135     if( __event_max_fd <= fd ) __event_max_fd = fd + 1;
 136 }
 137
 138 void EVENT_DeleteIO( int fd, unsigned io_type )
 139 {
 140     FD_CLR( fd, &__event_io_set[io_type] );
 141 }
 142
 143 /***********************************************************************
 144  *           EVENT_ProcessEvent
 145  *
 146  * Process an X event.
 147  */
 148 void EVENT_ProcessEvent( XEvent *event )
 149 {
 150     WND *pWnd;
 151
 152     if ( TSXFindContext( display, event->xany.window, winContext,
 153                          (char **)&pWnd ) != 0) {
 154       if ( event->type == ClientMessage) {
 155         /* query window (drag&drop event contains only drag window) */
 156         Window          root, child;
 157         int             root_x, root_y, child_x, child_y;
 158         unsigned        u;
 159         TSXQueryPointer( display, rootWindow, &root, &child,
 160                          &root_x, &root_y, &child_x, &child_y, &u);
 161         if (TSXFindContext( display, child, winContext, (char **)&pWnd ) != 0)
 162           return;
 163       } else {
 164         pWnd = NULL;  /* Not for a registered window */
 165       }
 166     }
 167
 168     TRACE(event, "Got event %s for hwnd %04x\n",
 169           event_names[event->type], pWnd? pWnd->hwndSelf : 0 );
 170
 171     switch(event->type)
 172     {
 173     case KeyPress:
 174     case KeyRelease:
 175         EVENT_Key( pWnd, (XKeyEvent*)event );
 176         break;
 177
 178     case ButtonPress:
 179         EVENT_ButtonPress( pWnd, (XButtonEvent*)event );
 180         break;
 181
 182     case ButtonRelease:
 183         EVENT_ButtonRelease( pWnd, (XButtonEvent*)event );
 184         break;
 185
 186     case MotionNotify:
 187         /* Wine between two fast machines across the overloaded campus
 188            ethernet gets very boged down in MotionEvents. The following
 189            simply finds the last motion event in the queue and drops
 190            the rest. On a good link events are servered before they build
 191            up so this doesn't take place. On a slow link this may cause
 192            problems if the event order is important. I'm not yet seen
 193            of any problems. Jon 7/6/96.
 194          */
 195         while (TSXCheckTypedWindowEvent(display,((XAnyEvent *)event)->window,
 196                                         MotionNotify, event));
 197         EVENT_MotionNotify( pWnd, (XMotionEvent*)event );
 198         break;
 199
 200     case FocusIn:
 201         if (!pWnd) return;
 202         EVENT_FocusIn( pWnd, (XFocusChangeEvent*)event );
 203         break;
 204
 205     case FocusOut:
 206         if (!pWnd) return;
 207         EVENT_FocusOut( pWnd, (XFocusChangeEvent*)event );
 208         break;
 209
 210     case Expose:
 211         if (!pWnd) return;
 212         if (EVENT_Expose( pWnd, (XExposeEvent *)event )) {
 213             /* need to process ConfigureNotify first */
 214             XEvent new_event;
 215
 216             /* attempt to find and process the ConfigureNotify event now */
 217             if (TSXCheckTypedWindowEvent(display,((XAnyEvent *)event)->window,
 218                                           ConfigureNotify, &new_event)) {
 219                 EVENT_ProcessEvent( &new_event );
 220                 EVENT_Expose( pWnd, (XExposeEvent *)event );
 221                 break;
 222             }
 223
 224             /* no luck at this time, defer Expose event for later */
 225             if (!pWnd->expose_event) pWnd->expose_event = malloc( sizeof(XExposeEvent) );
 226             else { FIXME(x11,"can't handle more than one deferred Expose events\n"); }
 227             *(pWnd->expose_event) = *(XExposeEvent *)event;
 228         }
 229         break;
 230
 231     case GraphicsExpose:
 232         if (!pWnd) return;
 233         EVENT_GraphicsExpose( pWnd, (XGraphicsExposeEvent *)event );
 234         break;
 235
 236     case ConfigureNotify:
 237         if (!pWnd) return;
 238         EVENT_ConfigureNotify( pWnd, (XConfigureEvent*)event );
 239         if (pWnd->expose_event) {
 240             /* process deferred Expose event */
 241             EVENT_Expose( pWnd, pWnd->expose_event );
 242             free( pWnd->expose_event );
 243             pWnd->expose_event = NULL;
 244         }
 245         break;
 246
 247     case SelectionRequest:
 248         if (!pWnd) return;
 249         EVENT_SelectionRequest( pWnd, (XSelectionRequestEvent *)event );
 250         break;
 251
 252     case SelectionNotify:
 253         if (!pWnd) return;
 254         EVENT_SelectionNotify( (XSelectionEvent *)event );
 255         break;
 256
 257     case SelectionClear:
 258         if (!pWnd) return;
 259         EVENT_SelectionClear( pWnd, (XSelectionClearEvent*) event );
 260         break;
 261
 262     case ClientMessage:
 263         if (!pWnd) return;
 264         EVENT_ClientMessage( pWnd, (XClientMessageEvent *) event );
 265         break;
 266
 267 /*  case EnterNotify:
 268  *       EVENT_EnterNotify( pWnd, (XCrossingEvent *) event );
 269  *       break;
 270  */
 271     case NoExpose:
 272         break;
 273
 274     /* We get all these because of StructureNotifyMask. */
 275     case UnmapNotify:
 276     case CirculateNotify:
 277     case CreateNotify:
 278     case DestroyNotify:
 279     case GravityNotify:
 280     case ReparentNotify:
 281         break;
 282
 283     case MapNotify:
 284         if (!pWnd) return;
 285         EVENT_MapNotify( pWnd->hwndSelf, (XMapEvent *)event );
 286         break;
 287
 288     default:
 289         WARN(event, "Unprocessed event %s for hwnd %04x\n",
 290                 event_names[event->type], pWnd? pWnd->hwndSelf : 0 );
 291         break;
 292     }
 293 }
 294
 295
 296 /***********************************************************************
 297  *           EVENT_RegisterWindow
 298  *
 299  * Associate an X window to a HWND.
 300  */
 301 void EVENT_RegisterWindow( WND *pWnd )
 302 {
 303     if (wmProtocols == None)
 304         wmProtocols = TSXInternAtom( display, "WM_PROTOCOLS", True );
 305     if (wmDeleteWindow == None)
 306         wmDeleteWindow = TSXInternAtom( display, "WM_DELETE_WINDOW", True );
 307     if( dndProtocol == None )
 308         dndProtocol = TSXInternAtom( display, "DndProtocol" , False );
 309     if( dndSelection == None )
 310         dndSelection = TSXInternAtom( display, "DndSelection" , False );
 311
 312     TSXSetWMProtocols( display, pWnd->window, &wmDeleteWindow, 1 );
 313
 314     if (!winContext) winContext = TSXUniqueContext();
 315     TSXSaveContext( display, pWnd->window, winContext, (char *)pWnd );
 316 }
 317
 318 /***********************************************************************
 319  *           EVENT_DestroyWindow
 320  */
 321 void EVENT_DestroyWindow( WND *pWnd )
 322 {
 323    XEvent xe;
 324
 325    if (pWnd->expose_event) {
 326        free( pWnd->expose_event );
 327        pWnd->expose_event = NULL;
 328    }
 329    TSXDeleteContext( display, pWnd->window, winContext );
 330    TSXDestroyWindow( display, pWnd->window );
 331    while( TSXCheckWindowEvent(display, pWnd->window, NoEventMask, &xe) );
 332 }
 333
 334
 335 /***********************************************************************
 336  *           IsUserIdle         (USER.333)
 337  *
 338  * Check if we have pending X events.
 339  */
 340 BOOL16 WINAPI IsUserIdle(void)
 341 {
 342     struct timeval timeout = {0, 0};
 343     fd_set check_set;
 344
 345     FD_ZERO(&check_set);
 346     FD_SET(__event_x_connection, &check_set);
 347     if( select(__event_x_connection + 1, &check_set, NULL, NULL, &timeout) > 0 )
 348         return TRUE;
 349     return FALSE;
 350 }
 351
 352
 353 /***********************************************************************
 354  *           EVENT_WaitNetEvent
 355  *
 356  * Wait for a network event, optionally sleeping until one arrives.
 357  * Return TRUE if an event is pending, FALSE on timeout or error
 358  * (for instance lost connection with the server).
 359  */
 360 BOOL32 EVENT_WaitNetEvent( BOOL32 sleep, BOOL32 peek )
 361 {
 362     XEvent event;
 363     LONG maxWait = sleep ? TIMER_GetNextExpiration() : 0;
 364     int pending = TSXPending(display);
 365
 366     /* Wait for an event or a timeout. If maxWait is -1, we have no timeout;
 367      * in this case, we fall through directly to the XNextEvent loop.
 368      */
 369
 370     if ((maxWait != -1) && !pending)
 371     {
 372         int num_pending;
 373         struct timeval timeout;
 374         fd_set io_set[3];
 375
 376         memcpy( io_set, __event_io_set, sizeof(io_set) );
 377
 378         timeout.tv_usec = (maxWait % 1000) * 1000;
 379         timeout.tv_sec = maxWait / 1000;
 380
 381 #ifdef CONFIG_IPC
 382         sigsetjmp(env_wait_x, 1);
 383         stop_wait_op= CONT;
 384
 385         if (DDE_GetRemoteMessage()) {
 386             while(DDE_GetRemoteMessage())
 387                 ;
 388             return TRUE;
 389         }
 390         stop_wait_op = STOP_WAIT_X;
 391         /* The code up to the next "stop_wait_op = CONT" must be reentrant */
 392         num_pending = select( __event_max_fd, &io_set[EVENT_IO_READ],
 393                                               &io_set[EVENT_IO_WRITE],
 394                                               &io_set[EVENT_IO_EXCEPT], &timeout );
 395         if ( num_pending == 0 )
 396         {
 397             stop_wait_op = CONT;
 398             TIMER_ExpireTimers();
 399             return FALSE;
 400         }
 401         else stop_wait_op = CONT;
 402 #else  /* CONFIG_IPC */
 403         num_pending = select( __event_max_fd, &io_set[EVENT_IO_READ],
 404                                               &io_set[EVENT_IO_WRITE],
 405                                               &io_set[EVENT_IO_EXCEPT], &timeout );
 406         if ( num_pending == 0)
 407         {
 408             /* Timeout or error */
 409             TIMER_ExpireTimers();
 410             return FALSE;
 411         }
 412 #endif  /* CONFIG_IPC */
 413
 414         /*  Winsock asynchronous services */
 415
 416         if( FD_ISSET( __event_x_connection, &io_set[EVENT_IO_READ]) )
 417         {
 418             num_pending--;
 419             if( num_pending )
 420                 WINSOCK_HandleIO( &__event_max_fd, num_pending, io_set, __event_io_set );
 421         }
 422         else /* no X events */
 423             return WINSOCK_HandleIO( &__event_max_fd, num_pending, io_set, __event_io_set );
 424     }
 425     else if(!pending)
 426     {                           /* Wait for X11 input. */
 427         fd_set set;
 428
 429         FD_ZERO(&set);
 430         FD_SET(__event_x_connection, &set);
 431         select(__event_x_connection + 1, &set, 0, 0, 0 );
 432     }
 433
 434     /* Process current X event (and possibly others that occurred in the meantime) */
 435
 436     EnterCriticalSection(&X11DRV_CritSection);
 437     while (XPending( display ))
 438     {
 439
 440 #ifdef CONFIG_IPC
 441         if (DDE_GetRemoteMessage())
 442         {
 443             LeaveCriticalSection(&X11DRV_CritSection);
 444             while(DDE_GetRemoteMessage()) ;
 445             return TRUE;
 446         }
 447 #endif  /* CONFIG_IPC */
 448
 449         XNextEvent( display, &event );
 450
 451         LeaveCriticalSection(&X11DRV_CritSection);
 452         if( peek )
 453         {
 454           WND*          pWnd;
 455           MESSAGEQUEUE* pQ;
 456
 457
 458           /* Check only for those events which can be processed
 459            * internally. */
 460
 461           if( event.type == MotionNotify ||
 462               event.type == ButtonPress || event.type == ButtonRelease ||
 463               event.type == KeyPress || event.type == KeyRelease ||
 464               event.type == SelectionRequest || event.type == SelectionClear ||
 465               event.type == ClientMessage )
 466           {
 467                EVENT_ProcessEvent( &event );
 468                continue;
 469           }
 470
 471           if (TSXFindContext( display, ((XAnyEvent *)&event)->window, winContext,
 472                             (char **)&pWnd ) || (event.type == NoExpose))
 473               pWnd = NULL;
 474
 475           if( pWnd )
 476           {
 477             if( (pQ = (MESSAGEQUEUE*)GlobalLock16(pWnd->hmemTaskQ)) )
 478             {
 479               pQ->flags |= QUEUE_FLAG_XEVENT;
 480               PostEvent(pQ->hTask);
 481               TSXPutBackEvent(display, &event);
 482               break;
 483             }
 484           }
 485         }
 486         else EVENT_ProcessEvent( &event );
 487         EnterCriticalSection(&X11DRV_CritSection);
 488     }
 489     LeaveCriticalSection(&X11DRV_CritSection);
 490     return TRUE;
 491 }
 492
 493
 494 /***********************************************************************
 495  *           EVENT_Synchronize
 496  *
 497  * Synchronize with the X server. Should not be used too often.
 498  */
 499 void EVENT_Synchronize()
 500 {
 501     XEvent event;
 502
 503     /* Use of the X critical section is needed or we have a small
 504      * race between XPending() and XNextEvent().
 505      */
 506     EnterCriticalSection( &X11DRV_CritSection );
 507     XSync( display, False );
 508     while (XPending( display ))
 509     {
 510         XNextEvent( display, &event );
 511         /* unlock X critsection for EVENT_ProcessEvent() might switch tasks */
 512         LeaveCriticalSection( &X11DRV_CritSection );
 513         EVENT_ProcessEvent( &event );
 514         EnterCriticalSection( &X11DRV_CritSection );
 515     }
 516     LeaveCriticalSection( &X11DRV_CritSection );
 517 }
 518
 519 /***********************************************************************
 520  *           EVENT_QueryZOrder
 521  *
 522  * Try to synchronize internal z-order with the window manager's.
 523  * Probably a futile endeavor.
 524  */
 525 static BOOL32 __check_query_condition( WND** pWndA, WND** pWndB )
 526 {
 527     /* return TRUE if we have at least two managed windows */
 528
 529     for( *pWndB = NULL; *pWndA; *pWndA = (*pWndA)->next )
 530         if( (*pWndA)->flags & WIN_MANAGED &&
 531             (*pWndA)->dwStyle & WS_VISIBLE ) break;
 532     if( *pWndA )
 533         for( *pWndB = (*pWndA)->next; *pWndB; *pWndB = (*pWndB)->next )
 534             if( (*pWndB)->flags & WIN_MANAGED &&
 535                 (*pWndB)->dwStyle & WS_VISIBLE ) break;
 536      return ((*pWndB) != NULL);
 537 }
 538
 539 static Window __get_common_ancestor( Window A, Window B,
 540                                      Window** children, unsigned* total )
 541 {
 542     /* find the real root window */
 543
 544     Window      root, *childrenB;
 545     unsigned    totalB;
 546
 547     do
 548     {
 549         if( *children ) TSXFree( *children );
 550         TSXQueryTree( display, A, &root, &A, children, total );
 551         TSXQueryTree( display, B, &root, &B, &childrenB, &totalB );
 552         if( childrenB ) TSXFree( childrenB );
 553     } while( A != B && A && B );
 554     return ( A && B ) ? A : 0 ;
 555 }
 556
 557 static Window __get_top_decoration( Window w, Window ancestor )
 558 {
 559     Window*     children, root, prev = w, parent = w;
 560     unsigned    total;
 561
 562     do
 563     {
 564         w = parent;
 565         TSXQueryTree( display, w, &root, &parent, &children, &total );
 566         if( children ) TSXFree( children );
 567     } while( parent && parent != ancestor );
 568     TRACE(event, "\t%08x -> %08x\n", (unsigned)prev, (unsigned)w );
 569     return ( parent ) ? w : 0 ;
 570 }
 571
 572 static unsigned __td_lookup( Window w, Window* list, unsigned max )
 573 {
 574     unsigned    i;
 575     for( i = 0; i < max; i++ ) if( list[i] == w ) break;
 576     return i;
 577 }
 578
 579 static BOOL32 EVENT_QueryZOrder( WND* pWndCheck )
 580 {
 581     BOOL32      bRet = FALSE;
 582     HWND32      hwndInsertAfter = HWND_TOP;
 583     WND*        pWnd, *pWndZ = WIN_GetDesktop()->child;
 584     Window      w, parent, *children = NULL;
 585     unsigned    total, check, pos, best;
 586
 587     if( !__check_query_condition(&pWndZ, &pWnd) ) return TRUE;
 588
 589     parent = __get_common_ancestor( pWndZ->window, pWnd->window,
 590                                       &children, &total );
 591     if( parent && children )
 592     {
 593         w = __get_top_decoration( pWndCheck->window, parent );
 594         if( w != children[total - 1] )
 595         {
 596             check = __td_lookup( w, children, total );
 597             best = total;
 598             for( pWnd = pWndZ; pWnd; pWnd = pWnd->next )
 599             {
 600                 if( pWnd != pWndCheck )
 601                 {
 602                     if( !(pWnd->flags & WIN_MANAGED) ||
 603                         !(w = __get_top_decoration( pWnd->window, parent )) )
 604                         continue;
 605                     pos = __td_lookup( w, children, total );
 606                     if( pos < best && pos > check )
 607                     {
 608                         best = pos;
 609                         hwndInsertAfter = pWnd->hwndSelf;
 610                     }
 611                     if( check - best == 1 ) break;
 612                 }
 613             }
 614             WIN_UnlinkWindow( pWndCheck->hwndSelf );
 615             WIN_LinkWindow( pWndCheck->hwndSelf, hwndInsertAfter);
 616         }
 617     }
 618     if( children ) TSXFree( children );
 619     return bRet;
 620 }
 621
 622
 623 /***********************************************************************
 624  *           EVENT_XStateToKeyState
 625  *
 626  * Translate a X event state (Button1Mask, ShiftMask, etc...) to
 627  * a Windows key state (MK_SHIFT, MK_CONTROL, etc...)
 628  */
 629 static WORD EVENT_XStateToKeyState( int state )
 630 {
 631     int kstate = 0;
 632
 633     if (state & Button1Mask) kstate |= MK_LBUTTON;
 634     if (state & Button2Mask) kstate |= MK_MBUTTON;
 635     if (state & Button3Mask) kstate |= MK_RBUTTON;
 636     if (state & ShiftMask)   kstate |= MK_SHIFT;
 637     if (state & ControlMask) kstate |= MK_CONTROL;
 638     return kstate;
 639 }
 640
 641 /***********************************************************************
 642  *           EVENT_QueryPointer
 643  */
 644 BOOL32 EVENT_QueryPointer( DWORD *posX, DWORD *posY, DWORD *state )
 645 {
 646     Window root, child;
 647     int rootX, rootY, winX, winY;
 648     unsigned int xstate;
 649
 650     if (!TSXQueryPointer( display, rootWindow, &root, &child,
 651                           &rootX, &rootY, &winX, &winY, &xstate ))
 652         return FALSE;
 653
 654     *posX  = (DWORD)winX;
 655     *posY  = (DWORD)winY;
 656     *state = EVENT_XStateToKeyState( xstate );
 657
 658     return TRUE;
 659 }
 660
 661 /***********************************************************************
 662  *           EVENT_Expose
 663  */
 664 static int EVENT_Expose( WND *pWnd, XExposeEvent *event )
 665 {
 666     RECT32 rect;
 667     int x, y;
 668     unsigned int width, height;
 669
 670     /* When scrolling, many (fvwm2-based) window managers send the Expose
 671      * event before sending the ConfigureNotify event, and we don't like
 672      * that, so before processing the Expose event, we check whether the
 673      * geometry has changed, and if so, we defer the Expose event until
 674      * we get the ConfigureNotify event.  -Ove Kåven */
 675     EVENT_GetGeometry( event->window, &x, &y, &width, &height );
 676
 677     if ( x != pWnd->rectWindow.left || y != pWnd->rectWindow.top ||
 678          (width != pWnd->rectWindow.right - pWnd->rectWindow.left) ||
 679          (height != pWnd->rectWindow.bottom - pWnd->rectWindow.top))
 680         return 1; /* tell EVENT_ProcessEvent() to defer it */
 681
 682     /* Make position relative to client area instead of window */
 683     rect.left   = event->x - (pWnd->rectClient.left - pWnd->rectWindow.left);
 684     rect.top    = event->y - (pWnd->rectClient.top - pWnd->rectWindow.top);
 685     rect.right  = rect.left + event->width;
 686     rect.bottom = rect.top + event->height;
 687
 688     PAINT_RedrawWindow( pWnd->hwndSelf, &rect, 0,
 689                         RDW_INVALIDATE | RDW_FRAME | RDW_ALLCHILDREN | RDW_ERASE |
 690                         (event->count ? 0 : RDW_ERASENOW), 0 );
 691     return 0;
 692 }
 693
 694
 695 /***********************************************************************
 696  *           EVENT_GraphicsExpose
 697  *
 698  * This is needed when scrolling area is partially obscured
 699  * by non-Wine X window.
 700  */
 701 static void EVENT_GraphicsExpose( WND *pWnd, XGraphicsExposeEvent *event )
 702 {
 703     RECT32 rect;
 704
 705     /* Make position relative to client area instead of window */
 706     rect.left   = event->x - (pWnd->rectClient.left - pWnd->rectWindow.left);
 707     rect.top    = event->y - (pWnd->rectClient.top - pWnd->rectWindow.top);
 708     rect.right  = rect.left + event->width;
 709     rect.bottom = rect.top + event->height;
 710
 711     PAINT_RedrawWindow( pWnd->hwndSelf, &rect, 0,
 712                         RDW_INVALIDATE | RDW_ALLCHILDREN | RDW_ERASE |
 713                         (event->count ? 0 : RDW_ERASENOW), 0 );
 714 }
 715
 716
 717 /***********************************************************************
 718  *           EVENT_Key
 719  *
 720  * Handle a X key event
 721  */
 722 static void EVENT_Key( WND *pWnd, XKeyEvent *event )
 723 {
 724     KEYBOARD_HandleEvent( pWnd, event );
 725 }
 726
 727
 728 /***********************************************************************
 729  *           EVENT_MotionNotify
 730  */
 731 static void EVENT_MotionNotify( WND *pWnd, XMotionEvent *event )
 732 {
 733     int xOffset = pWnd? pWnd->rectWindow.left : 0;
 734     int yOffset = pWnd? pWnd->rectWindow.top  : 0;
 735
 736     MOUSE_SendEvent( MOUSEEVENTF_MOVE,
 737                      xOffset + event->x, yOffset + event->y,
 738                      EVENT_XStateToKeyState( event->state ),
 739                      event->time - MSG_WineStartTicks,
 740                      pWnd? pWnd->hwndSelf : 0 );
 741 }
 742
 743
 744 /***********************************************************************
 745  *           EVENT_DummyMotionNotify
 746  *
 747  * Generate a dummy MotionNotify event. Used to force a WM_SETCURSOR message.
 748  */
 749 void EVENT_DummyMotionNotify(void)
 750 {
 751     DWORD winX, winY, state;
 752
 753     if ( EVENT_QueryPointer( &winX, &winY, &state ) )
 754     {
 755         MOUSE_SendEvent( MOUSEEVENTF_MOVE, winX, winY, state,
 756                          GetTickCount(), 0 );
 757     }
 758 }
 759
 760
 761 /***********************************************************************
 762  *           EVENT_ButtonPress
 763  */
 764 static void EVENT_ButtonPress( WND *pWnd, XButtonEvent *event )
 765 {
 766     static WORD statusCodes[NB_BUTTONS] =
 767         { MOUSEEVENTF_LEFTDOWN, MOUSEEVENTF_MIDDLEDOWN, MOUSEEVENTF_RIGHTDOWN };
 768     int buttonNum = event->button - 1;
 769
 770     int xOffset = pWnd? pWnd->rectWindow.left : 0;
 771     int yOffset = pWnd? pWnd->rectWindow.top  : 0;
 772
 773     if (buttonNum >= NB_BUTTONS) return;
 774
 775     MOUSE_SendEvent( statusCodes[buttonNum],
 776                      xOffset + event->x, yOffset + event->y,
 777                      EVENT_XStateToKeyState( event->state ),
 778                      event->time - MSG_WineStartTicks,
 779                      pWnd? pWnd->hwndSelf : 0 );
 780 }
 781
 782
 783 /***********************************************************************
 784  *           EVENT_ButtonRelease
 785  */
 786 static void EVENT_ButtonRelease( WND *pWnd, XButtonEvent *event )
 787 {
 788     static WORD statusCodes[NB_BUTTONS] =
 789         { MOUSEEVENTF_LEFTUP, MOUSEEVENTF_MIDDLEUP, MOUSEEVENTF_RIGHTUP };
 790     int buttonNum = event->button - 1;
 791
 792     int xOffset = pWnd? pWnd->rectWindow.left : 0;
 793     int yOffset = pWnd? pWnd->rectWindow.top  : 0;
 794
 795     if (buttonNum >= NB_BUTTONS) return;
 796
 797     MOUSE_SendEvent( statusCodes[buttonNum],
 798                      xOffset + event->x, yOffset + event->y,
 799                      EVENT_XStateToKeyState( event->state ),
 800                      event->time - MSG_WineStartTicks,
 801                      pWnd? pWnd->hwndSelf : 0 );
 802 }
 803
 804
 805 /**********************************************************************
 806  *              EVENT_FocusIn
 807  */
 808 static void EVENT_FocusIn( WND *pWnd, XFocusChangeEvent *event )
 809 {
 810     if (Options.managed) EVENT_QueryZOrder( pWnd );
 811
 812     if (event->detail != NotifyPointer)
 813     {
 814         HWND32  hwnd = pWnd->hwndSelf;
 815
 816         if (hwnd != GetActiveWindow32())
 817         {
 818             WINPOS_ChangeActiveWindow( hwnd, FALSE );
 819             KEYBOARD_UpdateState();
 820         }
 821         if ((hwnd != GetFocus32()) && !IsChild32( hwnd, GetFocus32()))
 822             SetFocus32( hwnd );
 823     }
 824 }
 825
 826
 827 /**********************************************************************
 828  *              EVENT_FocusOut
 829  *
 830  * Note: only top-level override-redirect windows get FocusOut events.
 831  */
 832 static void EVENT_FocusOut( WND *pWnd, XFocusChangeEvent *event )
 833 {
 834     if (event->detail != NotifyPointer)
 835     {
 836         HWND32  hwnd = pWnd->hwndSelf;
 837
 838         if (hwnd == GetActiveWindow32())
 839             WINPOS_ChangeActiveWindow( 0, FALSE );
 840         if ((hwnd == GetFocus32()) || IsChild32( hwnd, GetFocus32()))
 841             SetFocus32( 0 );
 842     }
 843 }
 844
 845 /**********************************************************************
 846  *              EVENT_CheckFocus
 847  */
 848 BOOL32 EVENT_CheckFocus(void)
 849 {
 850     WND*   pWnd;
 851     Window xW;
 852     int    state;
 853
 854     TSXGetInputFocus(display, &xW, &state);
 855     if( xW == None ||
 856         TSXFindContext(display, xW, winContext, (char **)&pWnd) )
 857         return FALSE;
 858     return TRUE;
 859 }
 860
 861
 862 /**********************************************************************
 863  *              EVENT_GetGeometry
 864  *
 865  * Helper function for ConfigureNotify handling.
 866  * Get the new geometry of a window relative to the root window.
 867  */
 868 static void EVENT_GetGeometry( Window win, int *px, int *py,
 869                                unsigned int *pwidth, unsigned int *pheight )
 870 {
 871     Window root, parent, *children;
 872     int xpos, ypos;
 873     unsigned int width, height, border, depth, nb_children;
 874
 875     if (!TSXGetGeometry( display, win, &root, px, py, pwidth, pheight,
 876                        &border, &depth )) return;
 877     if (win == rootWindow)
 878     {
 879         *px = *py = 0;
 880         return;
 881     }
 882
 883     for (;;)
 884     {
 885         if (!TSXQueryTree(display, win, &root, &parent, &children, &nb_children))
 886             return;
 887         TSXFree( children );
 888         if (parent == rootWindow) break;
 889         win = parent;
 890         if (!TSXGetGeometry( display, win, &root, &xpos, &ypos,
 891                            &width, &height, &border, &depth )) return;
 892         *px += xpos;
 893         *py += ypos;
 894     }
 895 }
 896
 897
 898 /**********************************************************************
 899  *              EVENT_ConfigureNotify
 900  *
 901  * The ConfigureNotify event is only selected on top-level windows
 902  * when the -managed flag is used.
 903  */
 904 static void EVENT_ConfigureNotify( WND *pWnd, XConfigureEvent *event )
 905 {
 906     WINDOWPOS32 winpos;
 907     RECT32 newWindowRect, newClientRect;
 908     HRGN32 hrgnOldPos, hrgnNewPos;
 909     Window above = event->above;
 910     int x, y;
 911     unsigned int width, height;
 912
 913     assert (pWnd->flags & WIN_MANAGED);
 914
 915     /* We don't rely on the event geometry info, because it is relative
 916      * to parent and not to root, and it may be wrong (XFree sets x,y to 0,0
 917      * if the window hasn't moved).
 918      */
 919     EVENT_GetGeometry( event->window, &x, &y, &width, &height );
 920
 921     /* Fill WINDOWPOS struct */
 922     winpos.flags = SWP_NOACTIVATE | SWP_NOZORDER;
 923     winpos.hwnd = pWnd->hwndSelf;
 924     winpos.x = x;
 925     winpos.y = y;
 926     winpos.cx = width;
 927     winpos.cy = height;
 928
 929     /* Check for unchanged attributes */
 930     if (winpos.x == pWnd->rectWindow.left && winpos.y == pWnd->rectWindow.top)
 931         winpos.flags |= SWP_NOMOVE;
 932     if ((winpos.cx == pWnd->rectWindow.right - pWnd->rectWindow.left) &&
 933         (winpos.cy == pWnd->rectWindow.bottom - pWnd->rectWindow.top))
 934         winpos.flags |= SWP_NOSIZE;
 935     else
 936     {
 937         RECT32 rect = { 0, 0, pWnd->rectWindow.right - pWnd->rectWindow.left,
 938                         pWnd->rectWindow.bottom - pWnd->rectWindow.top };
 939         DCE_InvalidateDCE( pWnd, &rect );
 940     }
 941
 942     /* Send WM_WINDOWPOSCHANGING */
 943     SendMessage32A( winpos.hwnd, WM_WINDOWPOSCHANGING, 0, (LPARAM)&winpos );
 944
 945     /* Calculate new position and size */
 946     newWindowRect.left = x;
 947     newWindowRect.right = x + width;
 948     newWindowRect.top = y;
 949     newWindowRect.bottom = y + height;
 950
 951     WINPOS_SendNCCalcSize( winpos.hwnd, TRUE, &newWindowRect,
 952                            &pWnd->rectWindow, &pWnd->rectClient,
 953                            &winpos, &newClientRect );
 954
 955     hrgnOldPos = CreateRectRgnIndirect32( &pWnd->rectWindow );
 956     hrgnNewPos = CreateRectRgnIndirect32( &newWindowRect );
 957     CombineRgn32( hrgnOldPos, hrgnOldPos, hrgnNewPos, RGN_DIFF );
 958     DeleteObject32(hrgnOldPos);
 959     DeleteObject32(hrgnNewPos);
 960
 961     /* Set new size and position */
 962     pWnd->rectWindow = newWindowRect;
 963     pWnd->rectClient = newClientRect;
 964     SendMessage32A( winpos.hwnd, WM_WINDOWPOSCHANGED, 0, (LPARAM)&winpos );
 965
 966     if (!IsWindow32( winpos.hwnd )) return;
 967     if( above == None )                 /* absolute bottom */
 968     {
 969         WIN_UnlinkWindow( winpos.hwnd );
 970         WIN_LinkWindow( winpos.hwnd, HWND_BOTTOM);
 971     }
 972     else EVENT_QueryZOrder( pWnd );     /* try to outsmart window manager */
 973 }
 974
 975
 976 /***********************************************************************
 977  *           EVENT_SelectionRequest
 978  */
 979 static void EVENT_SelectionRequest( WND *pWnd, XSelectionRequestEvent *event )
 980 {
 981     XSelectionEvent result;
 982     Atom            rprop = None;
 983     Window          request = event->requestor;
 984
 985     if(event->target == XA_STRING)
 986     {
 987         HANDLE16 hText;
 988         LPSTR  text;
 989         int    size,i,j;
 990
 991         rprop = event->property;
 992
 993         if(rprop == None) rprop = event->target;
 994
 995         if(event->selection!=XA_PRIMARY) rprop = None;
 996         else if(!CLIPBOARD_IsPresent(CF_OEMTEXT)) rprop = None;
 997         else
 998         {
 999             /* open to make sure that clipboard is available */
1000
1001             BOOL32 couldOpen = OpenClipboard32( pWnd->hwndSelf );
1002             char* lpstr = 0;
1003
1004             hText = GetClipboardData16(CF_TEXT);
1005             text = GlobalLock16(hText);
1006             size = GlobalSize16(hText);
1007
1008             /* remove carriage returns */
1009
1010             lpstr = (char*)HEAP_xalloc( GetProcessHeap(), 0, size-- );
1011             for(i=0,j=0; i < size && text[i]; i++ )
1012             {
1013                if( text[i] == '\r' &&
1014                   (text[i+1] == '\n' || text[i+1] == '\0') ) continue;
1015                lpstr[j++] = text[i];
1016             }
1017             lpstr[j]='\0';
1018
1019             TSXChangeProperty(display, request, rprop,
1020                             XA_STRING, 8, PropModeReplace,
1021                             lpstr, j);
1022             HeapFree( GetProcessHeap(), 0, lpstr );
1023
1024             /* close only if we opened before */
1025
1026             if(couldOpen) CloseClipboard32();
1027         }
1028     }
1029
1030     if(rprop == None)
1031        TRACE(event,"Request for %s ignored\n", TSXGetAtomName(display,event->target));
1032
1033     result.type = SelectionNotify;
1034     result.display = display;
1035     result.requestor = request;
1036     result.selection = event->selection;
1037     result.property = rprop;
1038     result.target = event->target;
1039     result.time = event->time;
1040     TSXSendEvent(display,event->requestor,False,NoEventMask,(XEvent*)&result);
1041 }
1042
1043
1044 /***********************************************************************
1045  *           EVENT_SelectionNotify
1046  */
1047 static void EVENT_SelectionNotify( XSelectionEvent *event )
1048 {
1049     if (event->selection != XA_PRIMARY) return;
1050
1051     if (event->target != XA_STRING) CLIPBOARD_ReadSelection( 0, None );
1052     else CLIPBOARD_ReadSelection( event->requestor, event->property );
1053
1054     TRACE(clipboard,"\tSelectionNotify done!\n");
1055 }
1056
1057
1058 /***********************************************************************
1059  *           EVENT_SelectionClear
1060  */
1061 static void EVENT_SelectionClear( WND *pWnd, XSelectionClearEvent *event )
1062 {
1063     if (event->selection != XA_PRIMARY) return;
1064     CLIPBOARD_ReleaseSelection( event->window, pWnd->hwndSelf );
1065 }
1066
1067
1068 /**********************************************************************
1069  *           EVENT_DropFromOffix
1070  *
1071  * don't know if it still works (last Changlog is from 96/11/04)
1072  */
1073 static void EVENT_DropFromOffiX( WND *pWnd, XClientMessageEvent *event )
1074 {
1075   unsigned long         data_length;
1076   unsigned long         aux_long;
1077   unsigned char*        p_data = NULL;
1078   union {
1079     Atom                atom_aux;
1080     POINT32     pt_aux;
1081     int         i;
1082   }             u;
1083   int                   x, y;
1084   BOOL16                bAccept;
1085   HGLOBAL16             hDragInfo = GlobalAlloc16( GMEM_SHARE | GMEM_ZEROINIT, sizeof(DRAGINFO));
1086   LPDRAGINFO            lpDragInfo = (LPDRAGINFO) GlobalLock16(hDragInfo);
1087   SEGPTR                spDragInfo = (SEGPTR) WIN16_GlobalLock16(hDragInfo);
1088   Window                w_aux_root, w_aux_child;
1089   WND*                  pDropWnd;
1090
1091   if( !lpDragInfo || !spDragInfo ) return;
1092
1093   TSXQueryPointer( display, pWnd->window, &w_aux_root, &w_aux_child,
1094                    &x, &y, &u.pt_aux.x, &u.pt_aux.y, (unsigned int*)&aux_long);
1095
1096   lpDragInfo->hScope = pWnd->hwndSelf;
1097   lpDragInfo->pt.x = (INT16)x; lpDragInfo->pt.y = (INT16)y;
1098
1099   /* find out drop point and drop window */
1100   if( x < 0 || y < 0 ||
1101       x > (pWnd->rectWindow.right - pWnd->rectWindow.left) ||
1102       y > (pWnd->rectWindow.bottom - pWnd->rectWindow.top) )
1103     {   bAccept = pWnd->dwExStyle & WS_EX_ACCEPTFILES; x = y = 0; }
1104   else
1105     {
1106       bAccept = DRAG_QueryUpdate( pWnd->hwndSelf, spDragInfo, TRUE );
1107       x = lpDragInfo->pt.x; y = lpDragInfo->pt.y;
1108     }
1109   pDropWnd = WIN_FindWndPtr( lpDragInfo->hScope );
1110   GlobalFree16( hDragInfo );
1111
1112   if( bAccept )
1113     {
1114       TSXGetWindowProperty( display, DefaultRootWindow(display),
1115                             dndSelection, 0, 65535, FALSE,
1116                             AnyPropertyType, &u.atom_aux, &u.pt_aux.y,
1117                             &data_length, &aux_long, &p_data);
1118
1119       if( !aux_long && p_data)  /* don't bother if > 64K */
1120         {
1121           char *p = (char*) p_data;
1122           char *p_drop;
1123
1124           aux_long = 0;
1125           while( *p )   /* calculate buffer size */
1126             {
1127               p_drop = p;
1128               if((u.i = *p) != -1 )
1129                 u.i = DRIVE_FindDriveRoot( (const char **)&p_drop );
1130               if( u.i == -1 ) *p = -1;  /* mark as "bad" */
1131               else
1132                 {
1133                   INT32 len = GetShortPathName32A( p, NULL, 0 );
1134                   if (len) aux_long += len + 1;
1135                   else *p = -1;
1136                 }
1137               p += strlen(p) + 1;
1138             }
1139           if( aux_long && aux_long < 65535 )
1140             {
1141               HDROP16                 hDrop;
1142               LPDROPFILESTRUCT16        lpDrop;
1143
1144               aux_long += sizeof(DROPFILESTRUCT16) + 1;
1145               hDrop = (HDROP16)GlobalAlloc16( GMEM_SHARE, aux_long );
1146               lpDrop = (LPDROPFILESTRUCT16) GlobalLock16( hDrop );
1147
1148               if( lpDrop )
1149                 {
1150                   lpDrop->wSize = sizeof(DROPFILESTRUCT16);
1151                   lpDrop->ptMousePos.x = (INT16)x;
1152                   lpDrop->ptMousePos.y = (INT16)y;
1153                   lpDrop->fInNonClientArea = (BOOL16)
1154                     ( x < (pDropWnd->rectClient.left - pDropWnd->rectWindow.left)  ||
1155                       y < (pDropWnd->rectClient.top - pDropWnd->rectWindow.top)    ||
1156                       x > (pDropWnd->rectClient.right - pDropWnd->rectWindow.left) ||
1157                       y > (pDropWnd->rectClient.bottom - pDropWnd->rectWindow.top) );
1158                   p_drop = ((char*)lpDrop) + sizeof(DROPFILESTRUCT16);
1159                   p = p_data;
1160                   while(*p)
1161                     {
1162                       if( *p != -1 )    /* use only "good" entries */
1163                         {
1164                           GetShortPathName32A( p, p_drop, 65535 );
1165                           p_drop += strlen( p_drop ) + 1;
1166                         }
1167                       p += strlen(p) + 1;
1168                     }
1169                   *p_drop = '\0';
1170                   PostMessage16( pWnd->hwndSelf, WM_DROPFILES,
1171                                  (WPARAM16)hDrop, 0L );
1172                 }
1173             }
1174         }
1175       if( p_data ) TSXFree(p_data);
1176
1177     } /* WS_EX_ACCEPTFILES */
1178 }
1179
1180 /**********************************************************************
1181  *           EVENT_DropURLs
1182  *
1183  * drop items are separated by \n
1184  * each item is prefixed by its mime type
1185  *
1186  * event->data.l[3], event->data.l[4] contains drop x,y position
1187  */
1188 static void EVENT_DropURLs( WND *pWnd, XClientMessageEvent *event )
1189 {
1190   WND           *pDropWnd;
1191   unsigned long data_length;
1192   unsigned long aux_long, drop_len = 0;
1193   unsigned char *p_data = NULL; /* property data */
1194   char          *p_drop = NULL;
1195   char          *p, *next;
1196   int           x, y, drop32 = FALSE ;
1197   union {
1198     Atom        atom_aux;
1199     POINT32     pt_aux;
1200     int         i;
1201     Window      w_aux;
1202   }             u; /* unused */
1203   union {
1204     HDROP16     h16;
1205     HDROP32     h32;
1206   } hDrop;
1207
1208   drop32 = pWnd->flags & WIN_ISWIN32;
1209
1210   if (!(pWnd->dwExStyle & WS_EX_ACCEPTFILES))
1211     return;
1212
1213   TSXGetWindowProperty( display, DefaultRootWindow(display),
1214                         dndSelection, 0, 65535, FALSE,
1215                         AnyPropertyType, &u.atom_aux, &u.i,
1216                         &data_length, &aux_long, &p_data);
1217   if (aux_long)
1218     WARN(event,"property too large, truncated!\n");
1219   TRACE(event,"urls=%s\n", p_data);
1220
1221   if( !aux_long && p_data) {    /* don't bother if > 64K */
1222     /* calculate length */
1223     p = p_data;
1224     next = strchr(p, '\n');
1225     while (p) {
1226       if (next) *next=0;
1227       if (strncmp(p,"file:",5) == 0 ) {
1228         INT32 len = GetShortPathName32A( p+5, NULL, 0 );
1229         if (len) drop_len += len + 1;
1230       }
1231       if (next) {
1232         *next = '\n';
1233         p = next + 1;
1234         next = strchr(p, '\n');
1235       } else {
1236         p = NULL;
1237       }
1238     }
1239
1240     if( drop_len && drop_len < 65535 ) {
1241       TSXQueryPointer( display, rootWindow, &u.w_aux, &u.w_aux,
1242                        &x, &y, &u.i, &u.i, &u.i);
1243       pDropWnd = WIN_FindWndPtr( pWnd->hwndSelf );
1244
1245       if (drop32) {
1246         LPDROPFILESTRUCT32        lpDrop;
1247         drop_len += sizeof(DROPFILESTRUCT32) + 1;
1248         hDrop.h32 = (HDROP32)GlobalAlloc32( GMEM_SHARE, drop_len );
1249         lpDrop = (LPDROPFILESTRUCT32) GlobalLock32( hDrop.h32 );
1250
1251         if( lpDrop ) {
1252           lpDrop->lSize = sizeof(DROPFILESTRUCT32);
1253           lpDrop->ptMousePos.x = (INT32)x;
1254           lpDrop->ptMousePos.y = (INT32)y;
1255           lpDrop->fInNonClientArea = (BOOL32)
1256             ( x < (pDropWnd->rectClient.left - pDropWnd->rectWindow.left)  ||
1257               y < (pDropWnd->rectClient.top - pDropWnd->rectWindow.top)    ||
1258               x > (pDropWnd->rectClient.right - pDropWnd->rectWindow.left) ||
1259               y > (pDropWnd->rectClient.bottom - pDropWnd->rectWindow.top) );
1260           lpDrop->fWideChar = FALSE;
1261           p_drop = ((char*)lpDrop) + sizeof(DROPFILESTRUCT32);
1262         }
1263       } else {
1264         LPDROPFILESTRUCT16        lpDrop;
1265         drop_len += sizeof(DROPFILESTRUCT16) + 1;
1266         hDrop.h16 = (HDROP16)GlobalAlloc16( GMEM_SHARE, drop_len );
1267         lpDrop = (LPDROPFILESTRUCT16) GlobalLock16( hDrop.h16 );
1268
1269         if( lpDrop ) {
1270           lpDrop->wSize = sizeof(DROPFILESTRUCT16);
1271           lpDrop->ptMousePos.x = (INT16)x;
1272           lpDrop->ptMousePos.y = (INT16)y;
1273           lpDrop->fInNonClientArea = (BOOL16)
1274             ( x < (pDropWnd->rectClient.left - pDropWnd->rectWindow.left)  ||
1275               y < (pDropWnd->rectClient.top - pDropWnd->rectWindow.top)    ||
1276               x > (pDropWnd->rectClient.right - pDropWnd->rectWindow.left) ||
1277               y > (pDropWnd->rectClient.bottom - pDropWnd->rectWindow.top) );
1278           p_drop = ((char*)lpDrop) + sizeof(DROPFILESTRUCT16);
1279         }
1280       }
1281
1282       /* create message content */
1283       if (p_drop) {
1284         p = p_data;
1285         next = strchr(p, '\n');
1286         while (p) {
1287           if (next) *next=0;
1288           if (strncmp(p,"file:",5) == 0 ) {
1289             INT32 len = GetShortPathName32A( p+5, p_drop, 65535 );
1290             if (len) {
1291               TRACE(event, "drop file %s as %s\n", p+5, p_drop);
1292               p_drop += len+1;
1293             } else {
1294               WARN(event, "can't convert file %s to dos name \n", p+5);
1295             }
1296           } else {
1297             WARN(event, "unknown mime type %s\n", p);
1298           }
1299           if (next) {
1300             *next = '\n';
1301             p = next + 1;
1302             next = strchr(p, '\n');
1303           } else {
1304             p = NULL;
1305           }
1306           *p_drop = '\0';
1307         }
1308
1309         if (drop32) {
1310           /* can not use PostMessage32A because it is currently based on
1311            * PostMessage16 and WPARAM32 would be truncated to WPARAM16
1312            */
1313           GlobalUnlock32(hDrop.h32);
1314           SendMessage32A( pWnd->hwndSelf, WM_DROPFILES,
1315                           (WPARAM32)hDrop.h32, 0L );
1316         } else {
1317           GlobalUnlock16(hDrop.h16);
1318           PostMessage16( pWnd->hwndSelf, WM_DROPFILES,
1319                          (WPARAM16)hDrop.h16, 0L );
1320         }
1321       }
1322     }
1323     if( p_data ) TSXFree(p_data);
1324   }
1325 }
1326
1327 /**********************************************************************
1328  *           EVENT_ClientMessage
1329  */
1330 static void EVENT_ClientMessage( WND *pWnd, XClientMessageEvent *event )
1331 {
1332     if (event->message_type != None && event->format == 32) {
1333       if ((event->message_type == wmProtocols) &&
1334           (((Atom) event->data.l[0]) == wmDeleteWindow))
1335         SendMessage16( pWnd->hwndSelf, WM_SYSCOMMAND, SC_CLOSE, 0 );
1336       else if ( event->message_type == dndProtocol &&
1337                 (event->data.l[0] == DndFile || event->data.l[0] == DndFiles) )
1338         EVENT_DropFromOffiX(pWnd, event);
1339       else if ( event->message_type == dndProtocol &&
1340                 event->data.l[0] == DndURL )
1341         EVENT_DropURLs(pWnd, event);
1342       else {
1343 #if 0
1344         /* enable this if you want to see the message */
1345         unsigned char* p_data = NULL;
1346         union {
1347           unsigned long l;
1348           int                   i;
1349           Atom          atom;
1350         } u; /* unused */
1351         TSXGetWindowProperty( display, DefaultRootWindow(display),
1352                               dndSelection, 0, 65535, FALSE,
1353                               AnyPropertyType, &u.atom, &u.i,
1354                               &u.l, &u.l, &p_data);
1355         TRACE(event, "message_type=%ld, data=%ld,%ld,%ld,%ld,%ld, msg=%s\n",
1356               event->message_type, event->data.l[0], event->data.l[1],
1357               event->data.l[2], event->data.l[3], event->data.l[4],
1358               p_data);
1359 #endif
1360         TRACE(event, "unrecognized ClientMessage\n" );
1361       }
1362     }
1363 }
1364
1365 /**********************************************************************
1366  *           EVENT_EnterNotify
1367  *
1368  * Install colormap when Wine window is focused in
1369  * self-managed mode with private colormap
1370  */
1371 /*
1372   void EVENT_EnterNotify( WND *pWnd, XCrossingEvent *event )
1373   {
1374    if( !Options.managed && rootWindow == DefaultRootWindow(display) &&
1375      (COLOR_GetSystemPaletteFlags() & COLOR_PRIVATE) && GetFocus32() )
1376       TSXInstallColormap( display, COLOR_GetColormap() );
1377   }
1378  */
1379
1380 /**********************************************************************
1381  *              EVENT_MapNotify
1382  */
1383 void EVENT_MapNotify( HWND32 hWnd, XMapEvent *event )
1384 {
1385     HWND32 hwndFocus = GetFocus32();
1386
1387     if (hwndFocus && IsChild32( hWnd, hwndFocus ))
1388       FOCUS_SetXFocus( (HWND32)hwndFocus );
1389
1390     return;
1391 }
1392