src/x11/window.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        src/x11/window.cpp
   3 // Purpose:     wxWindow
   4 // Author:      Julian Smart
   5 // Modified by:
   6 // Created:     17/09/98
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) Julian Smart
   9 // Licence:     wxWindows licence
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 // for compilers that support precompilation, includes "wx.h".
  13 #include "wx/wxprec.h"
  14
  15 #if defined(__BORLANDC__)
  16     #pragma hdrstop
  17 #endif
  18
  19 // ============================================================================
  20 // declarations
  21 // ============================================================================
  22
  23 // ----------------------------------------------------------------------------
  24 // headers
  25 // ----------------------------------------------------------------------------
  26
  27 #include "wx/window.h"
  28
  29 #ifndef WX_PRECOMP
  30     #include "wx/hash.h"
  31     #include "wx/log.h"
  32     #include "wx/app.h"
  33     #include "wx/utils.h"
  34     #include "wx/panel.h"
  35     #include "wx/frame.h"
  36     #include "wx/dc.h"
  37     #include "wx/dcclient.h"
  38     #include "wx/button.h"
  39     #include "wx/menu.h"
  40     #include "wx/dialog.h"
  41     #include "wx/timer.h"
  42     #include "wx/settings.h"
  43     #include "wx/msgdlg.h"
  44     #include "wx/scrolbar.h"
  45     #include "wx/listbox.h"
  46     #include "wx/scrolwin.h"
  47     #include "wx/layout.h"
  48     #include "wx/menuitem.h"
  49     #include "wx/module.h"
  50 #endif
  51
  52 #include "wx/fontutil.h"
  53 #include "wx/univ/renderer.h"
  54
  55 #if  wxUSE_DRAG_AND_DROP
  56     #include "wx/dnd.h"
  57 #endif
  58
  59 #include "wx/x11/private.h"
  60 #include "X11/Xutil.h"
  61
  62 #include <string.h>
  63
  64 // ----------------------------------------------------------------------------
  65 // global variables for this module
  66 // ----------------------------------------------------------------------------
  67
  68 static wxWindow* g_captureWindow = NULL;
  69 static GC g_eraseGC;
  70
  71 // ----------------------------------------------------------------------------
  72 // macros
  73 // ----------------------------------------------------------------------------
  74
  75 #define event_left_is_down(x) ((x)->xbutton.state & Button1Mask)
  76 #define event_middle_is_down(x) ((x)->xbutton.state & Button2Mask)
  77 #define event_right_is_down(x) ((x)->xbutton.state & Button3Mask)
  78
  79 // ----------------------------------------------------------------------------
  80 // event tables
  81 // ----------------------------------------------------------------------------
  82
  83 IMPLEMENT_ABSTRACT_CLASS(wxWindowX11, wxWindowBase)
  84
  85 BEGIN_EVENT_TABLE(wxWindowX11, wxWindowBase)
  86     EVT_SYS_COLOUR_CHANGED(wxWindowX11::OnSysColourChanged)
  87 END_EVENT_TABLE()
  88
  89 // ============================================================================
  90 // implementation
  91 // ============================================================================
  92
  93 // ----------------------------------------------------------------------------
  94 // helper functions
  95 // ----------------------------------------------------------------------------
  96
  97 // ----------------------------------------------------------------------------
  98 // constructors
  99 // ----------------------------------------------------------------------------
 100
 101 void wxWindowX11::Init()
 102 {
 103     // X11-specific
 104     m_mainWindow = (WXWindow) 0;
 105     m_clientWindow = (WXWindow) 0;
 106     m_insertIntoMain = false;
 107     m_updateNcArea = false;
 108
 109     m_winCaptured = false;
 110     m_needsInputFocus = false;
 111     m_isShown = true;
 112     m_lastTS = 0;
 113     m_lastButton = 0;
 114 }
 115
 116 // real construction (Init() must have been called before!)
 117 bool wxWindowX11::Create(wxWindow *parent, wxWindowID id,
 118                          const wxPoint& pos,
 119                          const wxSize& size,
 120                          long style,
 121                          const wxString& name)
 122 {
 123     wxCHECK_MSG( parent, false, wxT("can't create wxWindow without parent") );
 124
 125     CreateBase(parent, id, pos, size, style, wxDefaultValidator, name);
 126
 127     parent->AddChild(this);
 128
 129     Display *xdisplay = (Display*) wxGlobalDisplay();
 130     int xscreen = DefaultScreen( xdisplay );
 131     Visual *xvisual = DefaultVisual( xdisplay, xscreen );
 132     Colormap cm = DefaultColormap( xdisplay, xscreen );
 133
 134     m_backgroundColour = wxSystemSettings::GetColour(wxSYS_COLOUR_3DFACE);
 135     m_backgroundColour.CalcPixel( (WXColormap) cm );
 136
 137     m_foregroundColour = *wxBLACK;
 138     m_foregroundColour.CalcPixel( (WXColormap) cm );
 139
 140     Window xparent = (Window) parent->GetClientAreaWindow();
 141
 142     // Add window's own scrollbars to main window, not to client window
 143     if (parent->GetInsertIntoMain())
 144     {
 145         // wxLogDebug( "Inserted into main: %s", GetName().c_str() );
 146         xparent = (Window) parent->GetMainWindow();
 147     }
 148
 149     // Size (not including the border) must be nonzero (or a Value error results)!
 150     // Note: The Xlib manual doesn't mention this restriction of XCreateWindow.
 151     wxSize size2(size);
 152     if (size2.x <= 0)
 153         size2.x = 20;
 154     if (size2.y <= 0)
 155         size2.y = 20;
 156
 157     wxPoint pos2(pos);
 158     if (pos2.x == wxDefaultCoord)
 159         pos2.x = 0;
 160     if (pos2.y == wxDefaultCoord)
 161         pos2.y = 0;
 162
 163 #if wxUSE_TWO_WINDOWS
 164     bool need_two_windows =
 165         ((( wxSUNKEN_BORDER | wxRAISED_BORDER | wxSIMPLE_BORDER | wxHSCROLL | wxVSCROLL ) & m_windowStyle) != 0);
 166 #else
 167     bool need_two_windows = false;
 168 #endif
 169
 170 #if wxUSE_NANOX
 171     long xattributes = 0;
 172 #else
 173     XSetWindowAttributes xattributes;
 174     long xattributes_mask = 0;
 175
 176     xattributes_mask |= CWBackPixel;
 177     xattributes.background_pixel = m_backgroundColour.GetPixel();
 178
 179     xattributes_mask |= CWBorderPixel;
 180     xattributes.border_pixel = BlackPixel( xdisplay, xscreen );
 181
 182     xattributes_mask |= CWEventMask;
 183 #endif
 184
 185     if (need_two_windows)
 186     {
 187 #if wxUSE_NANOX
 188         long backColor, foreColor;
 189         backColor = GR_RGB(m_backgroundColour.Red(), m_backgroundColour.Green(), m_backgroundColour.Blue());
 190         foreColor = GR_RGB(m_foregroundColour.Red(), m_foregroundColour.Green(), m_foregroundColour.Blue());
 191
 192         Window xwindow = XCreateWindowWithColor( xdisplay, xparent, pos2.x, pos2.y, size2.x, size2.y,
 193                                     0, 0, InputOutput, xvisual, backColor, foreColor);
 194         XSelectInput( xdisplay, xwindow,
 195           GR_EVENT_MASK_CLOSE_REQ | ExposureMask | KeyPressMask | KeyReleaseMask | ButtonPressMask | ButtonReleaseMask |
 196           ButtonMotionMask | EnterWindowMask | LeaveWindowMask | PointerMotionMask |
 197           KeymapStateMask | FocusChangeMask | ColormapChangeMask | StructureNotifyMask |
 198                       PropertyChangeMask );
 199
 200 #else
 201         // Normal X11
 202         xattributes.event_mask =
 203             ExposureMask | StructureNotifyMask | ColormapChangeMask;
 204
 205         Window xwindow = XCreateWindow( xdisplay, xparent, pos2.x, pos2.y, size2.x, size2.y,
 206             0, DefaultDepth(xdisplay,xscreen), InputOutput, xvisual, xattributes_mask, &xattributes );
 207
 208 #endif
 209
 210         XSetWindowBackgroundPixmap( xdisplay, xwindow, None );
 211
 212         m_mainWindow = (WXWindow) xwindow;
 213         wxAddWindowToTable( xwindow, (wxWindow*) this );
 214
 215         XMapWindow( xdisplay, xwindow );
 216
 217 #if !wxUSE_NANOX
 218         xattributes.event_mask =
 219             ExposureMask | KeyPressMask | KeyReleaseMask | ButtonPressMask | ButtonReleaseMask |
 220             ButtonMotionMask | EnterWindowMask | LeaveWindowMask | PointerMotionMask |
 221             KeymapStateMask | FocusChangeMask | ColormapChangeMask | StructureNotifyMask |
 222             PropertyChangeMask | VisibilityChangeMask ;
 223
 224         if (!HasFlag( wxFULL_REPAINT_ON_RESIZE ))
 225         {
 226             xattributes_mask |= CWBitGravity;
 227             xattributes.bit_gravity = StaticGravity;
 228         }
 229 #endif
 230
 231         if (HasFlag( wxSUNKEN_BORDER) || HasFlag( wxRAISED_BORDER))
 232         {
 233             pos2.x = 2;
 234             pos2.y = 2;
 235             size2.x -= 4;
 236             size2.y -= 4;
 237         }
 238         else if (HasFlag( wxSIMPLE_BORDER ))
 239         {
 240             pos2.x = 1;
 241             pos2.y = 1;
 242             size2.x -= 2;
 243             size2.y -= 2;
 244         }
 245         else
 246         {
 247             pos2.x = 0;
 248             pos2.y = 0;
 249         }
 250
 251         // Make again sure the size is nonzero.
 252         if (size2.x <= 0)
 253             size2.x = 1;
 254         if (size2.y <= 0)
 255             size2.y = 1;
 256
 257 #if wxUSE_NANOX
 258         backColor = GR_RGB(m_backgroundColour.Red(), m_backgroundColour.Green(), m_backgroundColour.Blue());
 259         foreColor = GR_RGB(m_foregroundColour.Red(), m_foregroundColour.Green(), m_foregroundColour.Blue());
 260
 261         xwindow = XCreateWindowWithColor( xdisplay, xwindow, pos2.x, pos2.y, size2.x, size2.y,
 262                                     0, 0, InputOutput, xvisual, backColor, foreColor);
 263         XSelectInput( xdisplay, xwindow,
 264           GR_EVENT_MASK_CLOSE_REQ | ExposureMask | KeyPressMask | KeyReleaseMask | ButtonPressMask | ButtonReleaseMask |
 265           ButtonMotionMask | EnterWindowMask | LeaveWindowMask | PointerMotionMask |
 266           KeymapStateMask | FocusChangeMask | ColormapChangeMask | StructureNotifyMask |
 267                       PropertyChangeMask );
 268
 269 #else
 270         xwindow = XCreateWindow( xdisplay, xwindow, pos2.x, pos2.y, size2.x, size2.y,
 271             0, DefaultDepth(xdisplay,xscreen), InputOutput, xvisual, xattributes_mask, &xattributes );
 272 #endif
 273
 274         XSetWindowBackgroundPixmap( xdisplay, xwindow, None );
 275
 276         m_clientWindow = (WXWindow) xwindow;
 277         wxAddClientWindowToTable( xwindow, (wxWindow*) this );
 278
 279         XMapWindow( xdisplay, xwindow );
 280     }
 281     else
 282     {
 283         // wxLogDebug( "No two windows needed %s", GetName().c_str() );
 284 #if wxUSE_NANOX
 285         long backColor, foreColor;
 286         backColor = GR_RGB(m_backgroundColour.Red(), m_backgroundColour.Green(), m_backgroundColour.Blue());
 287         foreColor = GR_RGB(m_foregroundColour.Red(), m_foregroundColour.Green(), m_foregroundColour.Blue());
 288
 289         Window xwindow = XCreateWindowWithColor( xdisplay, xparent, pos2.x, pos2.y, size2.x, size2.y,
 290                                     0, 0, InputOutput, xvisual, backColor, foreColor);
 291         XSelectInput( xdisplay, xwindow,
 292           GR_EVENT_MASK_CLOSE_REQ | ExposureMask | KeyPressMask | KeyReleaseMask | ButtonPressMask | ButtonReleaseMask |
 293           ButtonMotionMask | EnterWindowMask | LeaveWindowMask | PointerMotionMask |
 294           KeymapStateMask | FocusChangeMask | ColormapChangeMask | StructureNotifyMask |
 295                       PropertyChangeMask );
 296
 297 #else
 298         xattributes.event_mask =
 299             ExposureMask | KeyPressMask | KeyReleaseMask | ButtonPressMask | ButtonReleaseMask |
 300             ButtonMotionMask | EnterWindowMask | LeaveWindowMask | PointerMotionMask |
 301             KeymapStateMask | FocusChangeMask | ColormapChangeMask | StructureNotifyMask |
 302             PropertyChangeMask | VisibilityChangeMask ;
 303
 304         if (!HasFlag( wxFULL_REPAINT_ON_RESIZE ))
 305         {
 306             xattributes_mask |= CWBitGravity;
 307             xattributes.bit_gravity = NorthWestGravity;
 308         }
 309
 310         Window xwindow = XCreateWindow( xdisplay, xparent, pos2.x, pos2.y, size2.x, size2.y,
 311             0, DefaultDepth(xdisplay,xscreen), InputOutput, xvisual, xattributes_mask, &xattributes );
 312 #endif
 313
 314         XSetWindowBackgroundPixmap( xdisplay, xwindow, None );
 315
 316         m_mainWindow = (WXWindow) xwindow;
 317         m_clientWindow = m_mainWindow;
 318         wxAddWindowToTable( xwindow, (wxWindow*) this );
 319
 320         XMapWindow( xdisplay, xwindow );
 321     }
 322
 323     // Is a subwindow, so map immediately
 324     m_isShown = true;
 325
 326     // Without this, the cursor may not be restored properly (e.g. in splitter
 327     // sample).
 328     SetCursor(*wxSTANDARD_CURSOR);
 329     SetFont(wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT));
 330
 331     // Don't call this, it can have nasty repercussions for composite controls,
 332     // for example
 333     //    SetSize(pos.x, pos.y, size.x, size.y);
 334
 335     return true;
 336 }
 337
 338 // Destructor
 339 wxWindowX11::~wxWindowX11()
 340 {
 341     SendDestroyEvent();
 342
 343     if (g_captureWindow == this)
 344         g_captureWindow = NULL;
 345
 346     m_isBeingDeleted = true;
 347
 348     DestroyChildren();
 349
 350     if (m_clientWindow != m_mainWindow)
 351     {
 352         // Destroy the cleint window
 353         Window xwindow = (Window) m_clientWindow;
 354         wxDeleteClientWindowFromTable( xwindow );
 355         XDestroyWindow( wxGlobalDisplay(), xwindow );
 356         m_clientWindow = NULL;
 357     }
 358
 359     // Destroy the window
 360     if ( m_mainWindow )
 361     {
 362         Window xwindow = (Window) m_mainWindow;
 363         wxDeleteWindowFromTable( xwindow );
 364         XDestroyWindow( wxGlobalDisplay(), xwindow );
 365         m_mainWindow = NULL;
 366     }
 367 }
 368
 369 // ---------------------------------------------------------------------------
 370 // basic operations
 371 // ---------------------------------------------------------------------------
 372
 373 void wxWindowX11::SetFocus()
 374 {
 375     Window xwindow = (Window) m_clientWindow;
 376
 377     wxCHECK_RET( xwindow, wxT("invalid window") );
 378
 379     // Don't assert; we might be trying to set the focus for a panel
 380     // with only static controls, so the panel returns false from AcceptsFocus.
 381     // The app should be not be expected to deal with this.
 382     if (!AcceptsFocus())
 383         return;
 384
 385 #if 0
 386     if (GetName() == "scrollBar")
 387     {
 388         char *crash = NULL;
 389         *crash = 0;
 390     }
 391 #endif
 392
 393     if (wxWindowIsVisible(xwindow))
 394     {
 395         wxLogTrace( _T("focus"), _T("wxWindowX11::SetFocus: %s"), GetClassInfo()->GetClassName());
 396         //        XSetInputFocus( wxGlobalDisplay(), xwindow, RevertToParent, CurrentTime );
 397         XSetInputFocus( wxGlobalDisplay(), xwindow, RevertToNone, CurrentTime );
 398         m_needsInputFocus = false;
 399     }
 400     else
 401     {
 402         m_needsInputFocus = true;
 403     }
 404 }
 405
 406 // Get the window with the focus
 407 wxWindow *wxWindowBase::DoFindFocus()
 408 {
 409     Window xfocus = (Window) 0;
 410     int revert = 0;
 411
 412     XGetInputFocus( wxGlobalDisplay(), &xfocus, &revert);
 413     if (xfocus)
 414     {
 415         wxWindow *win = wxGetWindowFromTable( xfocus );
 416         if (!win)
 417         {
 418             win = wxGetClientWindowFromTable( xfocus );
 419         }
 420
 421         return win;
 422     }
 423
 424     return NULL;
 425 }
 426
 427 // Enabling/disabling handled by event loop, and not sending events
 428 // if disabled.
 429 bool wxWindowX11::Enable(bool enable)
 430 {
 431     if ( !wxWindowBase::Enable(enable) )
 432         return false;
 433
 434     return true;
 435 }
 436
 437 bool wxWindowX11::Show(bool show)
 438 {
 439     wxWindowBase::Show(show);
 440
 441     Window xwindow = (Window) m_mainWindow;
 442     Display *xdisp = wxGlobalDisplay();
 443     if (show)
 444     {
 445         // wxLogDebug( "Mapping window of type %s", GetName().c_str() );
 446         XMapWindow(xdisp, xwindow);
 447     }
 448     else
 449     {
 450         // wxLogDebug( "Unmapping window of type %s", GetName().c_str() );
 451         XUnmapWindow(xdisp, xwindow);
 452     }
 453
 454     return true;
 455 }
 456
 457 // Raise the window to the top of the Z order
 458 void wxWindowX11::Raise()
 459 {
 460     if (m_mainWindow)
 461         XRaiseWindow( wxGlobalDisplay(), (Window) m_mainWindow );
 462 }
 463
 464 // Lower the window to the bottom of the Z order
 465 void wxWindowX11::Lower()
 466 {
 467     if (m_mainWindow)
 468         XLowerWindow( wxGlobalDisplay(), (Window) m_mainWindow );
 469 }
 470
 471 void wxWindowX11::SetLabel(const wxString& WXUNUSED(label))
 472 {
 473     // TODO
 474 }
 475
 476 wxString wxWindowX11::GetLabel() const
 477 {
 478     // TODO
 479     return wxEmptyString;
 480 }
 481
 482 void wxWindowX11::DoCaptureMouse()
 483 {
 484     if ((g_captureWindow != NULL) && (g_captureWindow != this))
 485     {
 486         wxFAIL_MSG(wxT("Trying to capture before mouse released."));
 487
 488         // Core dump now
 489         int *tmp = NULL;
 490         (*tmp) = 1;
 491         return;
 492     }
 493
 494     if (m_winCaptured)
 495         return;
 496
 497     Window xwindow = (Window) m_clientWindow;
 498
 499     wxCHECK_RET( xwindow, wxT("invalid window") );
 500
 501     g_captureWindow = (wxWindow*) this;
 502
 503     if (xwindow)
 504     {
 505         int res = XGrabPointer(wxGlobalDisplay(), xwindow,
 506             FALSE,
 507             ButtonPressMask | ButtonReleaseMask | ButtonMotionMask | EnterWindowMask | LeaveWindowMask | PointerMotionMask,
 508             GrabModeAsync,
 509             GrabModeAsync,
 510             None,
 511             None, /* cursor */ // TODO: This may need to be set to the cursor of this window
 512             CurrentTime );
 513
 514         if (res != GrabSuccess)
 515         {
 516             wxString msg;
 517             msg.Printf(wxT("Failed to grab pointer for window %s"), this->GetClassInfo()->GetClassName());
 518             wxLogDebug(msg);
 519             if (res == GrabNotViewable)
 520                 wxLogDebug( wxT("This is not a viewable window - perhaps not shown yet?") );
 521
 522             g_captureWindow = NULL;
 523             return;
 524         }
 525
 526         m_winCaptured = true;
 527     }
 528 }
 529
 530 void wxWindowX11::DoReleaseMouse()
 531 {
 532     g_captureWindow = NULL;
 533
 534     if ( !m_winCaptured )
 535         return;
 536
 537     Window xwindow = (Window) m_clientWindow;
 538
 539     if (xwindow)
 540     {
 541         XUngrabPointer( wxGlobalDisplay(), CurrentTime );
 542     }
 543
 544     // wxLogDebug( "Ungrabbed pointer in %s", GetName().c_str() );
 545
 546     m_winCaptured = false;
 547 }
 548
 549 bool wxWindowX11::SetFont(const wxFont& font)
 550 {
 551     if ( !wxWindowBase::SetFont(font) )
 552     {
 553         // nothing to do
 554         return false;
 555     }
 556
 557     return true;
 558 }
 559
 560 bool wxWindowX11::SetCursor(const wxCursor& cursor)
 561 {
 562     if ( !wxWindowBase::SetCursor(cursor) )
 563     {
 564         // no change
 565         return false;
 566     }
 567
 568     Window xwindow = (Window) m_clientWindow;
 569
 570     wxCHECK_MSG( xwindow, false, wxT("invalid window") );
 571
 572     wxCursor cursorToUse;
 573     if (m_cursor.Ok())
 574         cursorToUse = m_cursor;
 575     else
 576         cursorToUse = *wxSTANDARD_CURSOR;
 577
 578     Cursor xcursor = (Cursor) cursorToUse.GetCursor();
 579
 580     XDefineCursor( wxGlobalDisplay(), xwindow, xcursor );
 581
 582     return true;
 583 }
 584
 585 // Coordinates relative to the window
 586 void wxWindowX11::WarpPointer (int x, int y)
 587 {
 588     Window xwindow = (Window) m_clientWindow;
 589
 590     wxCHECK_RET( xwindow, wxT("invalid window") );
 591
 592     XWarpPointer( wxGlobalDisplay(), None, xwindow, 0, 0, 0, 0, x, y);
 593 }
 594
 595 // Does a physical scroll
 596 void wxWindowX11::ScrollWindow(int dx, int dy, const wxRect *rect)
 597 {
 598     // No scrolling requested.
 599     if ((dx == 0) && (dy == 0)) return;
 600
 601     if (!m_updateRegion.IsEmpty())
 602     {
 603         m_updateRegion.Offset( dx, dy );
 604
 605         int cw = 0;
 606         int ch = 0;
 607         GetSize( &cw, &ch );  // GetClientSize() ??
 608         m_updateRegion.Intersect( 0, 0, cw, ch );
 609     }
 610
 611     if (!m_clearRegion.IsEmpty())
 612     {
 613         m_clearRegion.Offset( dx, dy );
 614
 615         int cw = 0;
 616         int ch = 0;
 617         GetSize( &cw, &ch );  // GetClientSize() ??
 618         m_clearRegion.Intersect( 0, 0, cw, ch );
 619     }
 620
 621     Window xwindow = (Window) GetClientAreaWindow();
 622
 623     wxCHECK_RET( xwindow, wxT("invalid window") );
 624
 625     Display *xdisplay = wxGlobalDisplay();
 626
 627     GC xgc = XCreateGC( xdisplay, xwindow, 0, NULL );
 628     XSetGraphicsExposures( xdisplay, xgc, True );
 629
 630     int s_x = 0;
 631     int s_y = 0;
 632     int cw;
 633     int ch;
 634     if (rect)
 635     {
 636         s_x = rect->x;
 637         s_y = rect->y;
 638
 639         cw = rect->width;
 640         ch = rect->height;
 641     }
 642     else
 643     {
 644         s_x = 0;
 645         s_y = 0;
 646         GetClientSize( &cw, &ch );
 647     }
 648
 649 #if wxUSE_TWO_WINDOWS
 650     wxPoint offset( 0,0 );
 651 #else
 652     wxPoint offset = GetClientAreaOrigin();
 653     s_x += offset.x;
 654     s_y += offset.y;
 655 #endif
 656
 657     int w = cw - abs(dx);
 658     int h = ch - abs(dy);
 659
 660     if ((h < 0) || (w < 0))
 661     {
 662         Refresh();
 663     }
 664     else
 665     {
 666         wxRect rect;
 667         if (dx < 0) rect.x = cw+dx + offset.x; else rect.x = s_x;
 668         if (dy < 0) rect.y = ch+dy + offset.y; else rect.y = s_y;
 669         if (dy != 0) rect.width = cw; else rect.width = abs(dx);
 670         if (dx != 0) rect.height = ch; else rect.height = abs(dy);
 671
 672         int d_x = s_x;
 673         int d_y = s_y;
 674
 675         if (dx < 0) s_x += -dx;
 676         if (dy < 0) s_y += -dy;
 677         if (dx > 0) d_x = dx + offset.x;
 678         if (dy > 0) d_y = dy + offset.y;
 679
 680         XCopyArea( xdisplay, xwindow, xwindow, xgc, s_x, s_y, w, h, d_x, d_y );
 681
 682         // wxLogDebug( "Copy: s_x %d s_y %d w %d h %d d_x %d d_y %d", s_x, s_y, w, h, d_x, d_y );
 683
 684         // wxLogDebug( "Update: %d %d %d %d", rect.x, rect.y, rect.width, rect.height );
 685
 686         m_updateRegion.Union( rect );
 687         m_clearRegion.Union( rect );
 688     }
 689
 690     XFreeGC( xdisplay, xgc );
 691
 692     // Move Clients, but not the scrollbars
 693     // FIXME: There may be a better method to move a lot of Windows within X11
 694     wxScrollBar *sbH = ((wxWindow *) this)->GetScrollbar( wxHORIZONTAL );
 695     wxScrollBar *sbV = ((wxWindow *) this)->GetScrollbar( wxVERTICAL );
 696     wxWindowList::compatibility_iterator node = GetChildren().GetFirst();
 697     while ( node )
 698     {
 699         // Only propagate to non-top-level windows
 700         wxWindow *win = node->GetData();
 701         if ( win->GetParent() && win != sbH && win != sbV )
 702         {
 703             wxPoint pos = win->GetPosition();
 704             // Add the delta to the old Position
 705             pos.x += dx;
 706             pos.y += dy;
 707             win->SetPosition(pos);
 708         }
 709         node = node->GetNext();
 710     }
 711 }
 712
 713 // ---------------------------------------------------------------------------
 714 // drag and drop
 715 // ---------------------------------------------------------------------------
 716
 717 #if wxUSE_DRAG_AND_DROP
 718
 719 void wxWindowX11::SetDropTarget(wxDropTarget * WXUNUSED(pDropTarget))
 720 {
 721     // TODO
 722 }
 723
 724 #endif
 725
 726 // Old style file-manager drag&drop
 727 void wxWindowX11::DragAcceptFiles(bool WXUNUSED(accept))
 728 {
 729     // TODO
 730 }
 731
 732 // ----------------------------------------------------------------------------
 733 // tooltips
 734 // ----------------------------------------------------------------------------
 735
 736 #if wxUSE_TOOLTIPS
 737
 738 void wxWindowX11::DoSetToolTip(wxToolTip * WXUNUSED(tooltip))
 739 {
 740     // TODO
 741 }
 742
 743 #endif // wxUSE_TOOLTIPS
 744
 745 // ---------------------------------------------------------------------------
 746 // moving and resizing
 747 // ---------------------------------------------------------------------------
 748
 749 bool wxWindowX11::PreResize()
 750 {
 751     return true;
 752 }
 753
 754 // Get total size
 755 void wxWindowX11::DoGetSize(int *x, int *y) const
 756 {
 757     Window xwindow = (Window) m_mainWindow;
 758
 759     wxCHECK_RET( xwindow, wxT("invalid window") );
 760
 761     //XSync(wxGlobalDisplay(), False);
 762
 763     XWindowAttributes attr;
 764     Status status = XGetWindowAttributes( wxGlobalDisplay(), xwindow, &attr );
 765     wxASSERT(status);
 766
 767     if (status)
 768     {
 769         *x = attr.width /* + 2*m_borderSize */ ;
 770         *y = attr.height /* + 2*m_borderSize */ ;
 771     }
 772 }
 773
 774 void wxWindowX11::DoGetPosition(int *x, int *y) const
 775 {
 776     Window window = (Window) m_mainWindow;
 777     if (window)
 778     {
 779         //XSync(wxGlobalDisplay(), False);
 780         XWindowAttributes attr;
 781         Status status = XGetWindowAttributes(wxGlobalDisplay(), window, & attr);
 782         wxASSERT(status);
 783
 784         if (status)
 785         {
 786             *x = attr.x;
 787             *y = attr.y;
 788
 789             // We may be faking the client origin. So a window that's really at (0, 30)
 790             // may appear (to wxWin apps) to be at (0, 0).
 791             if (GetParent())
 792             {
 793                 wxPoint pt(GetParent()->GetClientAreaOrigin());
 794                 *x -= pt.x;
 795                 *y -= pt.y;
 796             }
 797         }
 798     }
 799 }
 800
 801 void wxWindowX11::DoScreenToClient(int *x, int *y) const
 802 {
 803     Display *display = wxGlobalDisplay();
 804     Window rootWindow = RootWindowOfScreen(DefaultScreenOfDisplay(display));
 805     Window thisWindow = (Window) m_clientWindow;
 806
 807     Window childWindow;
 808     int xx = x ? *x : 0;
 809     int yy = y ? *y : 0;
 810     XTranslateCoordinates(display, rootWindow, thisWindow,
 811                           xx, yy, x ? x : &xx, y ? y : &yy,
 812                           &childWindow);
 813 }
 814
 815 void wxWindowX11::DoClientToScreen(int *x, int *y) const
 816 {
 817     Display *display = wxGlobalDisplay();
 818     Window rootWindow = RootWindowOfScreen(DefaultScreenOfDisplay(display));
 819     Window thisWindow = (Window) m_clientWindow;
 820
 821     int xx = x ? *x : 0;
 822     int yy = y ? *y : 0;
 823     XTranslateCoordinates(display, thisWindow, rootWindow,
 824                           xx, yy, x ? x : &xx, y ? y : &yy,
 825                           &childWindow);
 826 }
 827
 828
 829 // Get size *available for subwindows* i.e. excluding menu bar etc.
 830 void wxWindowX11::DoGetClientSize(int *x, int *y) const
 831 {
 832     Window window = (Window) m_mainWindow;
 833
 834     if (window)
 835     {
 836         XWindowAttributes attr;
 837         Status status = XGetWindowAttributes( wxGlobalDisplay(), window, &attr );
 838         wxASSERT(status);
 839
 840         if (status)
 841         {
 842             *x = attr.width ;
 843             *y = attr.height ;
 844         }
 845     }
 846 }
 847
 848 void wxWindowX11::DoSetSize(int x, int y, int width, int height, int sizeFlags)
 849 {
 850     //    wxLogDebug("DoSetSize: %s (%ld) %d, %d %dx%d", GetClassInfo()->GetClassName(), GetId(), x, y, width, height);
 851
 852     Window xwindow = (Window) m_mainWindow;
 853
 854     wxCHECK_RET( xwindow, wxT("invalid window") );
 855
 856     XWindowAttributes attr;
 857     Status status = XGetWindowAttributes( wxGlobalDisplay(), xwindow, &attr );
 858     wxCHECK_RET( status, wxT("invalid window attributes") );
 859
 860     int new_x = attr.x;
 861     int new_y = attr.y;
 862     int new_w = attr.width;
 863     int new_h = attr.height;
 864
 865     if (x != wxDefaultCoord || (sizeFlags & wxSIZE_ALLOW_MINUS_ONE))
 866     {
 867         int yy = 0;
 868         AdjustForParentClientOrigin( x, yy, sizeFlags);
 869         new_x = x;
 870     }
 871     if (y != wxDefaultCoord || (sizeFlags & wxSIZE_ALLOW_MINUS_ONE))
 872     {
 873         int xx = 0;
 874         AdjustForParentClientOrigin( xx, y, sizeFlags);
 875         new_y = y;
 876     }
 877     if (width != wxDefaultCoord)
 878     {
 879         new_w = width;
 880         if (new_w <= 0)
 881             new_w = 20;
 882     }
 883     if (height != wxDefaultCoord)
 884     {
 885         new_h = height;
 886         if (new_h <= 0)
 887             new_h = 20;
 888     }
 889
 890     DoMoveWindow( new_x, new_y, new_w, new_h );
 891 }
 892
 893 void wxWindowX11::DoSetClientSize(int width, int height)
 894 {
 895     //    wxLogDebug("DoSetClientSize: %s (%ld) %dx%d", GetClassInfo()->GetClassName(), GetId(), width, height);
 896
 897     Window xwindow = (Window) m_mainWindow;
 898
 899     wxCHECK_RET( xwindow, wxT("invalid window") );
 900
 901     XResizeWindow( wxGlobalDisplay(), xwindow, width, height );
 902
 903     if (m_mainWindow != m_clientWindow)
 904     {
 905         xwindow = (Window) m_clientWindow;
 906
 907         wxWindow *window = (wxWindow*) this;
 908         wxRenderer *renderer = window->GetRenderer();
 909         if (renderer)
 910         {
 911             wxRect border = renderer->GetBorderDimensions( (wxBorder)(m_windowStyle & wxBORDER_MASK) );
 912             width -= border.x + border.width;
 913             height -= border.y + border.height;
 914         }
 915
 916         XResizeWindow( wxGlobalDisplay(), xwindow, width, height );
 917     }
 918 }
 919
 920 void wxWindowX11::DoMoveWindow(int x, int y, int width, int height)
 921 {
 922     Window xwindow = (Window) m_mainWindow;
 923
 924     wxCHECK_RET( xwindow, wxT("invalid window") );
 925
 926 #if !wxUSE_NANOX
 927
 928     XMoveResizeWindow( wxGlobalDisplay(), xwindow, x, y, width, height );
 929     if (m_mainWindow != m_clientWindow)
 930     {
 931         xwindow = (Window) m_clientWindow;
 932
 933         wxWindow *window = (wxWindow*) this;
 934         wxRenderer *renderer = window->GetRenderer();
 935         if (renderer)
 936         {
 937             wxRect border = renderer->GetBorderDimensions( (wxBorder)(m_windowStyle & wxBORDER_MASK) );
 938             x = border.x;
 939             y = border.y;
 940             width -= border.x + border.width;
 941             height -= border.y + border.height;
 942         }
 943         else
 944         {
 945             x = 0;
 946             y = 0;
 947         }
 948
 949         wxScrollBar *sb = window->GetScrollbar( wxHORIZONTAL );
 950         if (sb && sb->IsShown())
 951         {
 952             wxSize size = sb->GetSize();
 953             height -= size.y;
 954         }
 955         sb = window->GetScrollbar( wxVERTICAL );
 956         if (sb && sb->IsShown())
 957         {
 958             wxSize size = sb->GetSize();
 959             width -= size.x;
 960         }
 961
 962         XMoveResizeWindow( wxGlobalDisplay(), xwindow, x, y, wxMax(1, width), wxMax(1, height) );
 963     }
 964
 965 #else
 966
 967     XWindowChanges windowChanges;
 968     windowChanges.x = x;
 969     windowChanges.y = y;
 970     windowChanges.width = width;
 971     windowChanges.height = height;
 972     windowChanges.stack_mode = 0;
 973     int valueMask = CWX | CWY | CWWidth | CWHeight;
 974
 975     XConfigureWindow( wxGlobalDisplay(), xwindow, valueMask, &windowChanges );
 976
 977 #endif
 978 }
 979
 980 void wxWindowX11::DoSetSizeHints(int minW, int minH, int maxW, int maxH, int incW, int incH)
 981 {
 982     m_minWidth = minW;
 983     m_minHeight = minH;
 984     m_maxWidth = maxW;
 985     m_maxHeight = maxH;
 986
 987 #if !wxUSE_NANOX
 988     XSizeHints sizeHints;
 989     sizeHints.flags = 0;
 990
 991     if (minW > -1 && minH > -1)
 992     {
 993         sizeHints.flags |= PMinSize;
 994         sizeHints.min_width = minW;
 995         sizeHints.min_height = minH;
 996     }
 997     if (maxW > -1 && maxH > -1)
 998     {
 999         sizeHints.flags |= PMaxSize;
1000         sizeHints.max_width = maxW;
1001         sizeHints.max_height = maxH;
1002     }
1003     if (incW > -1 && incH > -1)
1004     {
1005         sizeHints.flags |= PResizeInc;
1006         sizeHints.width_inc = incW;
1007         sizeHints.height_inc = incH;
1008     }
1009
1010     XSetWMNormalHints(wxGlobalDisplay(), (Window) m_mainWindow, &sizeHints );
1011 #endif
1012 }
1013
1014 // ---------------------------------------------------------------------------
1015 // text metrics
1016 // ---------------------------------------------------------------------------
1017
1018 int wxWindowX11::GetCharHeight() const
1019 {
1020     wxFont font(GetFont());
1021     wxCHECK_MSG( font.Ok(), 0, wxT("valid window font needed") );
1022
1023 #if wxUSE_UNICODE
1024     // There should be an easier way.
1025     PangoLayout *layout = pango_layout_new( wxTheApp->GetPangoContext() );
1026     pango_layout_set_font_description( layout, font.GetNativeFontInfo()->description );
1027     pango_layout_set_text(layout, "H", 1 );
1028     int w,h;
1029     pango_layout_get_pixel_size(layout, &w, &h);
1030     g_object_unref( G_OBJECT( layout ) );
1031
1032     return h;
1033 #else
1034     WXFontStructPtr pFontStruct = font.GetFontStruct(1.0, wxGlobalDisplay());
1035
1036     int direction, ascent, descent;
1037     XCharStruct overall;
1038     XTextExtents ((XFontStruct*) pFontStruct, "x", 1, &direction, &ascent,
1039         &descent, &overall);
1040
1041     //  return (overall.ascent + overall.descent);
1042     return (ascent + descent);
1043 #endif
1044 }
1045
1046 int wxWindowX11::GetCharWidth() const
1047 {
1048     wxFont font(GetFont());
1049     wxCHECK_MSG( font.Ok(), 0, wxT("valid window font needed") );
1050
1051 #if wxUSE_UNICODE
1052     // There should be an easier way.
1053     PangoLayout *layout = pango_layout_new( wxTheApp->GetPangoContext() );
1054     pango_layout_set_font_description( layout, font.GetNativeFontInfo()->description );
1055     pango_layout_set_text(layout, "H", 1 );
1056     int w,h;
1057     pango_layout_get_pixel_size(layout, &w, &h);
1058     g_object_unref( G_OBJECT( layout ) );
1059
1060     return w;
1061 #else
1062     WXFontStructPtr pFontStruct = font.GetFontStruct(1.0, wxGlobalDisplay());
1063
1064     int direction, ascent, descent;
1065     XCharStruct overall;
1066     XTextExtents ((XFontStruct*) pFontStruct, "x", 1, &direction, &ascent,
1067         &descent, &overall);
1068
1069     return overall.width;
1070 #endif
1071 }
1072
1073 void wxWindowX11::GetTextExtent(const wxString& string,
1074                                 int *x, int *y,
1075                                 int *descent, int *externalLeading,
1076                                 const wxFont *theFont) const
1077 {
1078     wxFont fontToUse = GetFont();
1079     if (theFont) fontToUse = *theFont;
1080
1081     wxCHECK_RET( fontToUse.Ok(), wxT("invalid font") );
1082
1083     if (string.empty())
1084     {
1085         if (x) (*x) = 0;
1086         if (y) (*y) = 0;
1087         return;
1088     }
1089
1090 #if wxUSE_UNICODE
1091     PangoLayout *layout = pango_layout_new( wxTheApp->GetPangoContext() );
1092
1093     PangoFontDescription *desc = fontToUse.GetNativeFontInfo()->description;
1094     pango_layout_set_font_description(layout, desc);
1095
1096     const wxCharBuffer data = wxConvUTF8.cWC2MB( string );
1097     pango_layout_set_text(layout, (const char*) data, strlen( (const char*) data ));
1098
1099     PangoLayoutLine *line = (PangoLayoutLine *)pango_layout_get_lines(layout)->data;
1100
1101
1102     PangoRectangle rect;
1103     pango_layout_line_get_extents(line, NULL, &rect);
1104
1105     if (x) (*x) = (wxCoord) (rect.width / PANGO_SCALE);
1106     if (y) (*y) = (wxCoord) (rect.height / PANGO_SCALE);
1107     if (descent)
1108     {
1109         // Do something about metrics here
1110         (*descent) = 0;
1111     }
1112     if (externalLeading) (*externalLeading) = 0;  // ??
1113
1114     g_object_unref( G_OBJECT( layout ) );
1115 #else
1116     WXFontStructPtr pFontStruct = fontToUse.GetFontStruct(1.0, wxGlobalDisplay());
1117
1118     int direction, ascent, descent2;
1119     XCharStruct overall;
1120     int slen = string.length();
1121
1122     XTextExtents((XFontStruct*) pFontStruct, (char*) string.c_str(), slen,
1123                  &direction, &ascent, &descent2, &overall);
1124
1125     if ( x )
1126         *x = (overall.width);
1127     if ( y )
1128         *y = (ascent + descent2);
1129     if (descent)
1130         *descent = descent2;
1131     if (externalLeading)
1132         *externalLeading = 0;
1133 #endif
1134 }
1135
1136 // ----------------------------------------------------------------------------
1137 // painting
1138 // ----------------------------------------------------------------------------
1139
1140 void wxWindowX11::Refresh(bool eraseBack, const wxRect *rect)
1141 {
1142     if (eraseBack)
1143     {
1144         if (rect)
1145         {
1146             // Schedule for later Updating in ::Update() or ::OnInternalIdle().
1147             m_clearRegion.Union( rect->x, rect->y, rect->width, rect->height );
1148         }
1149         else
1150         {
1151             int height,width;
1152             GetSize( &width, &height );
1153
1154             // Schedule for later Updating in ::Update() or ::OnInternalIdle().
1155             m_clearRegion.Clear();
1156             m_clearRegion.Union( 0, 0, width, height );
1157         }
1158     }
1159
1160     if (rect)
1161     {
1162          // Schedule for later Updating in ::Update() or ::OnInternalIdle().
1163          m_updateRegion.Union( rect->x, rect->y, rect->width, rect->height );
1164     }
1165     else
1166     {
1167         int height,width;
1168         GetSize( &width, &height );
1169
1170         // Schedule for later Updating in ::Update() or ::OnInternalIdle().
1171         m_updateRegion.Clear();
1172         m_updateRegion.Union( 0, 0, width, height );
1173     }
1174 }
1175
1176 void wxWindowX11::Update()
1177 {
1178     if (m_updateNcArea)
1179     {
1180         // wxLogDebug("wxWindowX11::UpdateNC: %s", GetClassInfo()->GetClassName());
1181         // Send nc paint events.
1182         SendNcPaintEvents();
1183     }
1184
1185     if (!m_updateRegion.IsEmpty())
1186     {
1187         // wxLogDebug("wxWindowX11::Update: %s", GetClassInfo()->GetClassName());
1188         // Actually send erase events.
1189         SendEraseEvents();
1190
1191         // Actually send paint events.
1192         SendPaintEvents();
1193     }
1194 }
1195
1196 void wxWindowX11::SendEraseEvents()
1197 {
1198     if (m_clearRegion.IsEmpty()) return;
1199
1200     wxClientDC dc( (wxWindow*)this );
1201     dc.SetClippingRegion( m_clearRegion );
1202
1203     wxEraseEvent erase_event( GetId(), &dc );
1204     erase_event.SetEventObject( this );
1205
1206     if (!GetEventHandler()->ProcessEvent(erase_event) )
1207     {
1208         Display *xdisplay = wxGlobalDisplay();
1209         Window xwindow = (Window) GetClientAreaWindow();
1210         XSetForeground( xdisplay, g_eraseGC, m_backgroundColour.GetPixel() );
1211
1212         wxRegionIterator upd( m_clearRegion );
1213         while (upd)
1214         {
1215             XFillRectangle( xdisplay, xwindow, g_eraseGC,
1216                             upd.GetX(), upd.GetY(), upd.GetWidth(), upd.GetHeight() );
1217             upd ++;
1218         }
1219     }
1220
1221     m_clearRegion.Clear();
1222 }
1223
1224 void wxWindowX11::SendPaintEvents()
1225 {
1226     //    wxLogDebug("SendPaintEvents: %s (%ld)", GetClassInfo()->GetClassName(), GetId());
1227
1228     m_clipPaintRegion = true;
1229
1230     wxPaintEvent paint_event( GetId() );
1231     paint_event.SetEventObject( this );
1232     GetEventHandler()->ProcessEvent( paint_event );
1233
1234     m_updateRegion.Clear();
1235
1236     m_clipPaintRegion = false;
1237 }
1238
1239 void wxWindowX11::SendNcPaintEvents()
1240 {
1241     wxWindow *window = (wxWindow*) this;
1242
1243     // All this for drawing the small square between the scrollbars.
1244     int width = 0;
1245     int height = 0;
1246     int x = 0;
1247     int y = 0;
1248     wxScrollBar *sb = window->GetScrollbar( wxHORIZONTAL );
1249     if (sb && sb->IsShown())
1250     {
1251         height = sb->GetSize().y;
1252         y = sb->GetPosition().y;
1253
1254         sb = window->GetScrollbar( wxVERTICAL );
1255         if (sb && sb->IsShown())
1256         {
1257             width = sb->GetSize().x;
1258             x = sb->GetPosition().x;
1259
1260             Display *xdisplay = wxGlobalDisplay();
1261             Window xwindow = (Window) GetMainWindow();
1262             Colormap cm = (Colormap) wxTheApp->GetMainColormap( wxGetDisplay() );
1263             wxColour colour = wxSystemSettings::GetColour(wxSYS_COLOUR_APPWORKSPACE);
1264             colour.CalcPixel( (WXColormap) cm );
1265
1266             XSetForeground( xdisplay, g_eraseGC, colour.GetPixel() );
1267
1268             XFillRectangle( xdisplay, xwindow, g_eraseGC, x, y, width, height );
1269         }
1270     }
1271
1272     wxNcPaintEvent nc_paint_event( GetId() );
1273     nc_paint_event.SetEventObject( this );
1274     GetEventHandler()->ProcessEvent( nc_paint_event );
1275
1276     m_updateNcArea = false;
1277 }
1278
1279 // ----------------------------------------------------------------------------
1280 // event handlers
1281 // ----------------------------------------------------------------------------
1282
1283 // Responds to colour changes: passes event on to children.
1284 void wxWindowX11::OnSysColourChanged(wxSysColourChangedEvent& event)
1285 {
1286     wxWindowList::compatibility_iterator node = GetChildren().GetFirst();
1287     while ( node )
1288     {
1289         // Only propagate to non-top-level windows
1290         wxWindow *win = node->GetData();
1291         if ( win->GetParent() )
1292         {
1293             wxSysColourChangedEvent event2;
1294             event.SetEventObject(win);
1295             win->GetEventHandler()->ProcessEvent(event2);
1296         }
1297
1298         node = node->GetNext();
1299     }
1300 }
1301
1302 // See handler for InFocus case in app.cpp for details.
1303 wxWindow* g_GettingFocus = NULL;
1304
1305 void wxWindowX11::OnInternalIdle()
1306 {
1307     // Update invalidated regions.
1308     Update();
1309
1310     // This calls the UI-update mechanism (querying windows for
1311     // menu/toolbar/control state information)
1312     if (wxUpdateUIEvent::CanUpdate((wxWindow*) this))
1313         UpdateWindowUI(wxUPDATE_UI_FROMIDLE);
1314
1315     // Set the input focus if couldn't do it before
1316     if (m_needsInputFocus)
1317     {
1318 #if 0
1319         wxString msg;
1320         msg.Printf("Setting focus for %s from OnInternalIdle\n", GetClassInfo()->GetClassName());
1321         printf(msg.c_str());
1322 #endif
1323         SetFocus();
1324
1325         // If it couldn't set the focus now, there's
1326         // no point in trying again.
1327         m_needsInputFocus = false;
1328     }
1329     g_GettingFocus = NULL;
1330 }
1331
1332 // ----------------------------------------------------------------------------
1333 // function which maintain the global hash table mapping Widgets to wxWidgets
1334 // ----------------------------------------------------------------------------
1335
1336 static bool DoAddWindowToTable(wxWindowHash *hash, Window w, wxWindow *win)
1337 {
1338     if ( !hash->insert(wxWindowHash::value_type(w, win)).second )
1339     {
1340         wxLogDebug( wxT("Widget table clash: new widget is 0x%08x, %s"),
1341                     (unsigned int)w, win->GetClassInfo()->GetClassName());
1342         return false;
1343     }
1344
1345     wxLogTrace( wxT("widget"), wxT("XWindow 0x%08x <-> window %p (%s)"),
1346                 (unsigned int) w, win, win->GetClassInfo()->GetClassName());
1347
1348     return true;
1349 }
1350
1351 static inline wxWindow *DoGetWindowFromTable(wxWindowHash *hash, Window w)
1352 {
1353     wxWindowHash::iterator i = hash->find(w);
1354     return i == hash->end() ? NULL : i->second;
1355 }
1356
1357 static inline void DoDeleteWindowFromTable(wxWindowHash *hash, Window w)
1358 {
1359     wxLogTrace( wxT("widget"), wxT("XWindow 0x%08x deleted"), (unsigned int) w);
1360
1361     hash->erase(w);
1362 }
1363
1364 // ----------------------------------------------------------------------------
1365 // public wrappers
1366 // ----------------------------------------------------------------------------
1367
1368 bool wxAddWindowToTable(Window w, wxWindow *win)
1369 {
1370     return DoAddWindowToTable(wxWidgetHashTable, w, win);
1371 }
1372
1373 wxWindow *wxGetWindowFromTable(Window w)
1374 {
1375     return DoGetWindowFromTable(wxWidgetHashTable, w);
1376 }
1377
1378 void wxDeleteWindowFromTable(Window w)
1379 {
1380     DoDeleteWindowFromTable(wxWidgetHashTable, w);
1381 }
1382
1383 bool wxAddClientWindowToTable(Window w, wxWindow *win)
1384 {
1385     return DoAddWindowToTable(wxClientWidgetHashTable, w, win);
1386 }
1387
1388 wxWindow *wxGetClientWindowFromTable(Window w)
1389 {
1390     return DoGetWindowFromTable(wxClientWidgetHashTable, w);
1391 }
1392
1393 void wxDeleteClientWindowFromTable(Window w)
1394 {
1395     DoDeleteWindowFromTable(wxClientWidgetHashTable, w);
1396 }
1397
1398 // ----------------------------------------------------------------------------
1399 // X11-specific accessors
1400 // ----------------------------------------------------------------------------
1401
1402 WXWindow wxWindowX11::GetMainWindow() const
1403 {
1404     return m_mainWindow;
1405 }
1406
1407 WXWindow wxWindowX11::GetClientAreaWindow() const
1408 {
1409     return m_clientWindow;
1410 }
1411
1412 // ----------------------------------------------------------------------------
1413 // TranslateXXXEvent() functions
1414 // ----------------------------------------------------------------------------
1415
1416 bool wxTranslateMouseEvent(wxMouseEvent& wxevent, wxWindow *win, Window window, XEvent *xevent)
1417 {
1418     switch (XEventGetType(xevent))
1419     {
1420         case EnterNotify:
1421         case LeaveNotify:
1422         case ButtonPress:
1423         case ButtonRelease:
1424         case MotionNotify:
1425         {
1426             wxEventType eventType = wxEVT_NULL;
1427
1428             if (XEventGetType(xevent) == EnterNotify)
1429             {
1430                 //if (local_event.xcrossing.mode!=NotifyNormal)
1431                 //  return ; // Ignore grab events
1432                 eventType = wxEVT_ENTER_WINDOW;
1433                 //            canvas->GetEventHandler()->OnSetFocus();
1434             }
1435             else if (XEventGetType(xevent) == LeaveNotify)
1436             {
1437                 //if (local_event.xcrossingr.mode!=NotifyNormal)
1438                 //  return ; // Ignore grab events
1439                 eventType = wxEVT_LEAVE_WINDOW;
1440                 //            canvas->GetEventHandler()->OnKillFocus();
1441             }
1442             else if (XEventGetType(xevent) == MotionNotify)
1443             {
1444                 eventType = wxEVT_MOTION;
1445             }
1446             else if (XEventGetType(xevent) == ButtonPress)
1447             {
1448                 wxevent.SetTimestamp(XButtonEventGetTime(xevent));
1449                 int button = 0;
1450                 if (XButtonEventLChanged(xevent))
1451                 {
1452                     eventType = wxEVT_LEFT_DOWN;
1453                     button = 1;
1454                 }
1455                 else if (XButtonEventMChanged(xevent))
1456                 {
1457                     eventType = wxEVT_MIDDLE_DOWN;
1458                     button = 2;
1459                 }
1460                 else if (XButtonEventRChanged(xevent))
1461                 {
1462                     eventType = wxEVT_RIGHT_DOWN;
1463                     button = 3;
1464                 }
1465
1466                 // check for a double click
1467                 // TODO: where can we get this value from?
1468                 //long dclickTime = XtGetMultiClickTime(wxGlobalDisplay());
1469                 long dclickTime = 200;
1470                 long ts = wxevent.GetTimestamp();
1471
1472                 int buttonLast = win->GetLastClickedButton();
1473                 long lastTS = win->GetLastClickTime();
1474                 if ( buttonLast && buttonLast == button && (ts - lastTS) < dclickTime )
1475                 {
1476                     // I have a dclick
1477                     win->SetLastClick(0, ts);
1478                     if ( eventType == wxEVT_LEFT_DOWN )
1479                         eventType = wxEVT_LEFT_DCLICK;
1480                     else if ( eventType == wxEVT_MIDDLE_DOWN )
1481                         eventType = wxEVT_MIDDLE_DCLICK;
1482                     else if ( eventType == wxEVT_RIGHT_DOWN )
1483                         eventType = wxEVT_RIGHT_DCLICK;
1484                 }
1485                 else
1486                 {
1487                     // not fast enough or different button
1488                     win->SetLastClick(button, ts);
1489                 }
1490             }
1491             else if (XEventGetType(xevent) == ButtonRelease)
1492             {
1493                 if (XButtonEventLChanged(xevent))
1494                 {
1495                     eventType = wxEVT_LEFT_UP;
1496                 }
1497                 else if (XButtonEventMChanged(xevent))
1498                 {
1499                     eventType = wxEVT_MIDDLE_UP;
1500                 }
1501                 else if (XButtonEventRChanged(xevent))
1502                 {
1503                     eventType = wxEVT_RIGHT_UP;
1504                 }
1505                 else return false;
1506             }
1507             else
1508             {
1509                 return false;
1510             }
1511
1512             wxevent.SetEventType(eventType);
1513
1514             wxevent.m_x = XButtonEventGetX(xevent);
1515             wxevent.m_y = XButtonEventGetY(xevent);
1516
1517             wxevent.m_leftDown = ((eventType == wxEVT_LEFT_DOWN)
1518                 || (XButtonEventLIsDown(xevent)
1519                 && (eventType != wxEVT_LEFT_UP)));
1520             wxevent.m_middleDown = ((eventType == wxEVT_MIDDLE_DOWN)
1521                 || (XButtonEventMIsDown(xevent)
1522                 && (eventType != wxEVT_MIDDLE_UP)));
1523             wxevent.m_rightDown = ((eventType == wxEVT_RIGHT_DOWN)
1524                 || (XButtonEventRIsDown (xevent)
1525                 && (eventType != wxEVT_RIGHT_UP)));
1526
1527             wxevent.m_shiftDown = XButtonEventShiftIsDown(xevent);
1528             wxevent.m_controlDown = XButtonEventCtrlIsDown(xevent);
1529             wxevent.m_altDown = XButtonEventAltIsDown(xevent);
1530             wxevent.m_metaDown = XButtonEventMetaIsDown(xevent);
1531
1532             wxevent.SetId(win->GetId());
1533             wxevent.SetEventObject(win);
1534
1535             return true;
1536         }
1537     }
1538     return false;
1539 }
1540
1541 bool wxTranslateKeyEvent(wxKeyEvent& wxevent, wxWindow *win, Window WXUNUSED(win), XEvent *xevent, bool isAscii)
1542 {
1543     switch (XEventGetType(xevent))
1544     {
1545     case KeyPress:
1546     case KeyRelease:
1547         {
1548             char buf[20];
1549
1550             KeySym keySym;
1551             (void) XLookupString ((XKeyEvent *) xevent, buf, 20, &keySym, NULL);
1552             int id = wxCharCodeXToWX (keySym);
1553             // id may be WXK_xxx code - these are outside ASCII range, so we
1554             // can't just use toupper() on id.
1555             // Only change this if we want the raw key that was pressed,
1556             // and don't change it if we want an ASCII value.
1557             if (!isAscii && (id >= 'a' && id <= 'z'))
1558             {
1559                 id = id + 'A' - 'a';
1560             }
1561
1562             wxevent.m_shiftDown = XKeyEventShiftIsDown(xevent);
1563             wxevent.m_controlDown = XKeyEventCtrlIsDown(xevent);
1564             wxevent.m_altDown = XKeyEventAltIsDown(xevent);
1565             wxevent.m_metaDown = XKeyEventMetaIsDown(xevent);
1566             wxevent.SetEventObject(win);
1567             wxevent.m_keyCode = id;
1568             wxevent.SetTimestamp(XKeyEventGetTime(xevent));
1569
1570             wxevent.m_x = XKeyEventGetX(xevent);
1571             wxevent.m_y = XKeyEventGetY(xevent);
1572
1573             return id > -1;
1574         }
1575     default:
1576         break;
1577     }
1578     return false;
1579 }
1580
1581 // ----------------------------------------------------------------------------
1582 // Colour stuff
1583 // ----------------------------------------------------------------------------
1584
1585 bool wxWindowX11::SetBackgroundColour(const wxColour& col)
1586 {
1587     wxWindowBase::SetBackgroundColour(col);
1588
1589     Display *xdisplay = (Display*) wxGlobalDisplay();
1590     int xscreen = DefaultScreen( xdisplay );
1591     Colormap cm = DefaultColormap( xdisplay, xscreen );
1592
1593     m_backgroundColour.CalcPixel( (WXColormap) cm );
1594
1595     // We don't set the background colour as we paint
1596     // the background ourselves.
1597     // XSetWindowBackground( xdisplay, (Window) m_clientWindow, m_backgroundColour.GetPixel() );
1598
1599     return true;
1600 }
1601
1602 bool wxWindowX11::SetForegroundColour(const wxColour& col)
1603 {
1604     if ( !wxWindowBase::SetForegroundColour(col) )
1605         return false;
1606
1607     return true;
1608 }
1609
1610 // ----------------------------------------------------------------------------
1611 // global functions
1612 // ----------------------------------------------------------------------------
1613
1614 wxWindow *wxGetActiveWindow()
1615 {
1616     // TODO
1617     wxFAIL_MSG(wxT("Not implemented"));
1618     return NULL;
1619 }
1620
1621 /* static */
1622 wxWindow *wxWindowBase::GetCapture()
1623 {
1624     return (wxWindow *)g_captureWindow;
1625 }
1626
1627
1628 // Find the wxWindow at the current mouse position, returning the mouse
1629 // position.
1630 wxWindow* wxFindWindowAtPointer(wxPoint& pt)
1631 {
1632     return wxFindWindowAtPoint(wxGetMousePosition());
1633 }
1634
1635 void wxGetMouseState(int& rootX, int& rootY, unsigned& maskReturn)
1636 {
1637 #if wxUSE_NANOX
1638     /* TODO */
1639     rootX = rootY = 0;
1640     maskReturn = 0;
1641 #else
1642     Display *display = wxGlobalDisplay();
1643     Window rootWindow = RootWindowOfScreen (DefaultScreenOfDisplay(display));
1644     Window rootReturn, childReturn;
1645     int winX, winY;
1646
1647     XQueryPointer (display,
1648                    rootWindow,
1649                    &rootReturn,
1650                    &childReturn,
1651                    &rootX, &rootY, &winX, &winY, &maskReturn);
1652 #endif
1653 }
1654
1655 // Get the current mouse position.
1656 wxPoint wxGetMousePosition()
1657 {
1658     int x, y;
1659     unsigned mask;
1660
1661     wxGetMouseState(x, y, mask);
1662     return wxPoint(x, y);
1663 }
1664
1665 wxMouseState wxGetMouseState()
1666 {
1667     wxMouseState ms;
1668     int x, y;
1669     unsigned mask;
1670
1671     wxGetMouseState(x, y, mask);
1672
1673     ms.SetX(x);
1674     ms.SetY(y);
1675
1676     ms.SetLeftDown(mask & Button1Mask);
1677     ms.SetMiddleDown(mask & Button2Mask);
1678     ms.SetRightDown(mask & Button3Mask);
1679
1680     ms.SetControlDown(mask & ControlMask);
1681     ms.SetShiftDown(mask & ShiftMask);
1682     ms.SetAltDown(mask & Mod3Mask);
1683     ms.SetMetaDown(mask & Mod1Mask);
1684
1685     return ms;
1686 }
1687
1688
1689 // ----------------------------------------------------------------------------
1690 // wxNoOptimize: switch off size optimization
1691 // ----------------------------------------------------------------------------
1692
1693 int wxNoOptimize::ms_count = 0;
1694
1695
1696 // ----------------------------------------------------------------------------
1697 // wxDCModule
1698 // ----------------------------------------------------------------------------
1699
1700 class wxWinModule : public wxModule
1701 {
1702 public:
1703     wxWinModule()
1704     {
1705         // we must be cleaned up before the display is closed
1706         AddDependency(wxClassInfo::FindClass(_T("wxX11DisplayModule")));
1707     }
1708
1709     virtual bool OnInit();
1710     virtual void OnExit();
1711
1712 private:
1713     DECLARE_DYNAMIC_CLASS(wxWinModule)
1714 };
1715
1716 IMPLEMENT_DYNAMIC_CLASS(wxWinModule, wxModule)
1717
1718 bool wxWinModule::OnInit()
1719 {
1720     Display *xdisplay = wxGlobalDisplay();
1721     int xscreen = DefaultScreen( xdisplay );
1722     Window xroot = RootWindow( xdisplay, xscreen );
1723     g_eraseGC = XCreateGC( xdisplay, xroot, 0, NULL );
1724     XSetFillStyle( xdisplay, g_eraseGC, FillSolid );
1725
1726     return true;
1727 }
1728
1729 void wxWinModule::OnExit()
1730 {
1731     Display *xdisplay = wxGlobalDisplay();
1732     XFreeGC( xdisplay, g_eraseGC );
1733 }