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;
 809     int yy = *y;
 810     XTranslateCoordinates(display, rootWindow, thisWindow, xx, yy, x, y, &childWindow);
 811 }
 812
 813 void wxWindowX11::DoClientToScreen(int *x, int *y) const
 814 {
 815     Display *display = wxGlobalDisplay();
 816     Window rootWindow = RootWindowOfScreen(DefaultScreenOfDisplay(display));
 817     Window thisWindow = (Window) m_clientWindow;
 818
 819     Window childWindow;
 820     int xx = *x;
 821     int yy = *y;
 822     XTranslateCoordinates(display, thisWindow, rootWindow, xx, yy, x, y, &childWindow);
 823 }
 824
 825
 826 // Get size *available for subwindows* i.e. excluding menu bar etc.
 827 void wxWindowX11::DoGetClientSize(int *x, int *y) const
 828 {
 829     Window window = (Window) m_mainWindow;
 830
 831     if (window)
 832     {
 833         XWindowAttributes attr;
 834         Status status = XGetWindowAttributes( wxGlobalDisplay(), window, &attr );
 835         wxASSERT(status);
 836
 837         if (status)
 838         {
 839             *x = attr.width ;
 840             *y = attr.height ;
 841         }
 842     }
 843 }
 844
 845 void wxWindowX11::DoSetSize(int x, int y, int width, int height, int sizeFlags)
 846 {
 847     //    wxLogDebug("DoSetSize: %s (%ld) %d, %d %dx%d", GetClassInfo()->GetClassName(), GetId(), x, y, width, height);
 848
 849     Window xwindow = (Window) m_mainWindow;
 850
 851     wxCHECK_RET( xwindow, wxT("invalid window") );
 852
 853     XWindowAttributes attr;
 854     Status status = XGetWindowAttributes( wxGlobalDisplay(), xwindow, &attr );
 855     wxCHECK_RET( status, wxT("invalid window attributes") );
 856
 857     int new_x = attr.x;
 858     int new_y = attr.y;
 859     int new_w = attr.width;
 860     int new_h = attr.height;
 861
 862     if (x != wxDefaultCoord || (sizeFlags & wxSIZE_ALLOW_MINUS_ONE))
 863     {
 864         int yy = 0;
 865         AdjustForParentClientOrigin( x, yy, sizeFlags);
 866         new_x = x;
 867     }
 868     if (y != wxDefaultCoord || (sizeFlags & wxSIZE_ALLOW_MINUS_ONE))
 869     {
 870         int xx = 0;
 871         AdjustForParentClientOrigin( xx, y, sizeFlags);
 872         new_y = y;
 873     }
 874     if (width != wxDefaultCoord)
 875     {
 876         new_w = width;
 877         if (new_w <= 0)
 878             new_w = 20;
 879     }
 880     if (height != wxDefaultCoord)
 881     {
 882         new_h = height;
 883         if (new_h <= 0)
 884             new_h = 20;
 885     }
 886
 887     DoMoveWindow( new_x, new_y, new_w, new_h );
 888 }
 889
 890 void wxWindowX11::DoSetClientSize(int width, int height)
 891 {
 892     //    wxLogDebug("DoSetClientSize: %s (%ld) %dx%d", GetClassInfo()->GetClassName(), GetId(), width, height);
 893
 894     Window xwindow = (Window) m_mainWindow;
 895
 896     wxCHECK_RET( xwindow, wxT("invalid window") );
 897
 898     XResizeWindow( wxGlobalDisplay(), xwindow, width, height );
 899
 900     if (m_mainWindow != m_clientWindow)
 901     {
 902         xwindow = (Window) m_clientWindow;
 903
 904         wxWindow *window = (wxWindow*) this;
 905         wxRenderer *renderer = window->GetRenderer();
 906         if (renderer)
 907         {
 908             wxRect border = renderer->GetBorderDimensions( (wxBorder)(m_windowStyle & wxBORDER_MASK) );
 909             width -= border.x + border.width;
 910             height -= border.y + border.height;
 911         }
 912
 913         XResizeWindow( wxGlobalDisplay(), xwindow, width, height );
 914     }
 915 }
 916
 917 void wxWindowX11::DoMoveWindow(int x, int y, int width, int height)
 918 {
 919     Window xwindow = (Window) m_mainWindow;
 920
 921     wxCHECK_RET( xwindow, wxT("invalid window") );
 922
 923 #if !wxUSE_NANOX
 924
 925     XMoveResizeWindow( wxGlobalDisplay(), xwindow, x, y, width, height );
 926     if (m_mainWindow != m_clientWindow)
 927     {
 928         xwindow = (Window) m_clientWindow;
 929
 930         wxWindow *window = (wxWindow*) this;
 931         wxRenderer *renderer = window->GetRenderer();
 932         if (renderer)
 933         {
 934             wxRect border = renderer->GetBorderDimensions( (wxBorder)(m_windowStyle & wxBORDER_MASK) );
 935             x = border.x;
 936             y = border.y;
 937             width -= border.x + border.width;
 938             height -= border.y + border.height;
 939         }
 940         else
 941         {
 942             x = 0;
 943             y = 0;
 944         }
 945
 946         wxScrollBar *sb = window->GetScrollbar( wxHORIZONTAL );
 947         if (sb && sb->IsShown())
 948         {
 949             wxSize size = sb->GetSize();
 950             height -= size.y;
 951         }
 952         sb = window->GetScrollbar( wxVERTICAL );
 953         if (sb && sb->IsShown())
 954         {
 955             wxSize size = sb->GetSize();
 956             width -= size.x;
 957         }
 958
 959         XMoveResizeWindow( wxGlobalDisplay(), xwindow, x, y, wxMax(1, width), wxMax(1, height) );
 960     }
 961
 962 #else
 963
 964     XWindowChanges windowChanges;
 965     windowChanges.x = x;
 966     windowChanges.y = y;
 967     windowChanges.width = width;
 968     windowChanges.height = height;
 969     windowChanges.stack_mode = 0;
 970     int valueMask = CWX | CWY | CWWidth | CWHeight;
 971
 972     XConfigureWindow( wxGlobalDisplay(), xwindow, valueMask, &windowChanges );
 973
 974 #endif
 975 }
 976
 977 void wxWindowX11::DoSetSizeHints(int minW, int minH, int maxW, int maxH, int incW, int incH)
 978 {
 979     m_minWidth = minW;
 980     m_minHeight = minH;
 981     m_maxWidth = maxW;
 982     m_maxHeight = maxH;
 983
 984 #if !wxUSE_NANOX
 985     XSizeHints sizeHints;
 986     sizeHints.flags = 0;
 987
 988     if (minW > -1 && minH > -1)
 989     {
 990         sizeHints.flags |= PMinSize;
 991         sizeHints.min_width = minW;
 992         sizeHints.min_height = minH;
 993     }
 994     if (maxW > -1 && maxH > -1)
 995     {
 996         sizeHints.flags |= PMaxSize;
 997         sizeHints.max_width = maxW;
 998         sizeHints.max_height = maxH;
 999     }
1000     if (incW > -1 && incH > -1)
1001     {
1002         sizeHints.flags |= PResizeInc;
1003         sizeHints.width_inc = incW;
1004         sizeHints.height_inc = incH;
1005     }
1006
1007     XSetWMNormalHints(wxGlobalDisplay(), (Window) m_mainWindow, &sizeHints );
1008 #endif
1009 }
1010
1011 // ---------------------------------------------------------------------------
1012 // text metrics
1013 // ---------------------------------------------------------------------------
1014
1015 int wxWindowX11::GetCharHeight() const
1016 {
1017     wxFont font(GetFont());
1018     wxCHECK_MSG( font.Ok(), 0, wxT("valid window font needed") );
1019
1020 #if wxUSE_UNICODE
1021     // There should be an easier way.
1022     PangoLayout *layout = pango_layout_new( wxTheApp->GetPangoContext() );
1023     pango_layout_set_font_description( layout, font.GetNativeFontInfo()->description );
1024     pango_layout_set_text(layout, "H", 1 );
1025     int w,h;
1026     pango_layout_get_pixel_size(layout, &w, &h);
1027     g_object_unref( G_OBJECT( layout ) );
1028
1029     return h;
1030 #else
1031     WXFontStructPtr pFontStruct = font.GetFontStruct(1.0, wxGlobalDisplay());
1032
1033     int direction, ascent, descent;
1034     XCharStruct overall;
1035     XTextExtents ((XFontStruct*) pFontStruct, "x", 1, &direction, &ascent,
1036         &descent, &overall);
1037
1038     //  return (overall.ascent + overall.descent);
1039     return (ascent + descent);
1040 #endif
1041 }
1042
1043 int wxWindowX11::GetCharWidth() const
1044 {
1045     wxFont font(GetFont());
1046     wxCHECK_MSG( font.Ok(), 0, wxT("valid window font needed") );
1047
1048 #if wxUSE_UNICODE
1049     // There should be an easier way.
1050     PangoLayout *layout = pango_layout_new( wxTheApp->GetPangoContext() );
1051     pango_layout_set_font_description( layout, font.GetNativeFontInfo()->description );
1052     pango_layout_set_text(layout, "H", 1 );
1053     int w,h;
1054     pango_layout_get_pixel_size(layout, &w, &h);
1055     g_object_unref( G_OBJECT( layout ) );
1056
1057     return w;
1058 #else
1059     WXFontStructPtr pFontStruct = font.GetFontStruct(1.0, wxGlobalDisplay());
1060
1061     int direction, ascent, descent;
1062     XCharStruct overall;
1063     XTextExtents ((XFontStruct*) pFontStruct, "x", 1, &direction, &ascent,
1064         &descent, &overall);
1065
1066     return overall.width;
1067 #endif
1068 }
1069
1070 void wxWindowX11::GetTextExtent(const wxString& string,
1071                                 int *x, int *y,
1072                                 int *descent, int *externalLeading,
1073                                 const wxFont *theFont) const
1074 {
1075     wxFont fontToUse = GetFont();
1076     if (theFont) fontToUse = *theFont;
1077
1078     wxCHECK_RET( fontToUse.Ok(), wxT("invalid font") );
1079
1080     if (string.empty())
1081     {
1082         if (x) (*x) = 0;
1083         if (y) (*y) = 0;
1084         return;
1085     }
1086
1087 #if wxUSE_UNICODE
1088     PangoLayout *layout = pango_layout_new( wxTheApp->GetPangoContext() );
1089
1090     PangoFontDescription *desc = fontToUse.GetNativeFontInfo()->description;
1091     pango_layout_set_font_description(layout, desc);
1092
1093     const wxCharBuffer data = wxConvUTF8.cWC2MB( string );
1094     pango_layout_set_text(layout, (const char*) data, strlen( (const char*) data ));
1095
1096     PangoLayoutLine *line = (PangoLayoutLine *)pango_layout_get_lines(layout)->data;
1097
1098
1099     PangoRectangle rect;
1100     pango_layout_line_get_extents(line, NULL, &rect);
1101
1102     if (x) (*x) = (wxCoord) (rect.width / PANGO_SCALE);
1103     if (y) (*y) = (wxCoord) (rect.height / PANGO_SCALE);
1104     if (descent)
1105     {
1106         // Do something about metrics here
1107         (*descent) = 0;
1108     }
1109     if (externalLeading) (*externalLeading) = 0;  // ??
1110
1111     g_object_unref( G_OBJECT( layout ) );
1112 #else
1113     WXFontStructPtr pFontStruct = fontToUse.GetFontStruct(1.0, wxGlobalDisplay());
1114
1115     int direction, ascent, descent2;
1116     XCharStruct overall;
1117     int slen = string.length();
1118
1119     XTextExtents((XFontStruct*) pFontStruct, (char*) string.c_str(), slen,
1120                  &direction, &ascent, &descent2, &overall);
1121
1122     if ( x )
1123         *x = (overall.width);
1124     if ( y )
1125         *y = (ascent + descent2);
1126     if (descent)
1127         *descent = descent2;
1128     if (externalLeading)
1129         *externalLeading = 0;
1130 #endif
1131 }
1132
1133 // ----------------------------------------------------------------------------
1134 // painting
1135 // ----------------------------------------------------------------------------
1136
1137 void wxWindowX11::Refresh(bool eraseBack, const wxRect *rect)
1138 {
1139     if (eraseBack)
1140     {
1141         if (rect)
1142         {
1143             // Schedule for later Updating in ::Update() or ::OnInternalIdle().
1144             m_clearRegion.Union( rect->x, rect->y, rect->width, rect->height );
1145         }
1146         else
1147         {
1148             int height,width;
1149             GetSize( &width, &height );
1150
1151             // Schedule for later Updating in ::Update() or ::OnInternalIdle().
1152             m_clearRegion.Clear();
1153             m_clearRegion.Union( 0, 0, width, height );
1154         }
1155     }
1156
1157     if (rect)
1158     {
1159          // Schedule for later Updating in ::Update() or ::OnInternalIdle().
1160          m_updateRegion.Union( rect->x, rect->y, rect->width, rect->height );
1161     }
1162     else
1163     {
1164         int height,width;
1165         GetSize( &width, &height );
1166
1167         // Schedule for later Updating in ::Update() or ::OnInternalIdle().
1168         m_updateRegion.Clear();
1169         m_updateRegion.Union( 0, 0, width, height );
1170     }
1171 }
1172
1173 void wxWindowX11::Update()
1174 {
1175     if (m_updateNcArea)
1176     {
1177         // wxLogDebug("wxWindowX11::UpdateNC: %s", GetClassInfo()->GetClassName());
1178         // Send nc paint events.
1179         SendNcPaintEvents();
1180     }
1181
1182     if (!m_updateRegion.IsEmpty())
1183     {
1184         // wxLogDebug("wxWindowX11::Update: %s", GetClassInfo()->GetClassName());
1185         // Actually send erase events.
1186         SendEraseEvents();
1187
1188         // Actually send paint events.
1189         SendPaintEvents();
1190     }
1191 }
1192
1193 void wxWindowX11::SendEraseEvents()
1194 {
1195     if (m_clearRegion.IsEmpty()) return;
1196
1197     wxClientDC dc( (wxWindow*)this );
1198     dc.SetClippingRegion( m_clearRegion );
1199
1200     wxEraseEvent erase_event( GetId(), &dc );
1201     erase_event.SetEventObject( this );
1202
1203     if (!GetEventHandler()->ProcessEvent(erase_event) )
1204     {
1205         Display *xdisplay = wxGlobalDisplay();
1206         Window xwindow = (Window) GetClientAreaWindow();
1207         XSetForeground( xdisplay, g_eraseGC, m_backgroundColour.GetPixel() );
1208
1209         wxRegionIterator upd( m_clearRegion );
1210         while (upd)
1211         {
1212             XFillRectangle( xdisplay, xwindow, g_eraseGC,
1213                             upd.GetX(), upd.GetY(), upd.GetWidth(), upd.GetHeight() );
1214             upd ++;
1215         }
1216     }
1217
1218     m_clearRegion.Clear();
1219 }
1220
1221 void wxWindowX11::SendPaintEvents()
1222 {
1223     //    wxLogDebug("SendPaintEvents: %s (%ld)", GetClassInfo()->GetClassName(), GetId());
1224
1225     m_clipPaintRegion = true;
1226
1227     wxPaintEvent paint_event( GetId() );
1228     paint_event.SetEventObject( this );
1229     GetEventHandler()->ProcessEvent( paint_event );
1230
1231     m_updateRegion.Clear();
1232
1233     m_clipPaintRegion = false;
1234 }
1235
1236 void wxWindowX11::SendNcPaintEvents()
1237 {
1238     wxWindow *window = (wxWindow*) this;
1239
1240     // All this for drawing the small square between the scrollbars.
1241     int width = 0;
1242     int height = 0;
1243     int x = 0;
1244     int y = 0;
1245     wxScrollBar *sb = window->GetScrollbar( wxHORIZONTAL );
1246     if (sb && sb->IsShown())
1247     {
1248         height = sb->GetSize().y;
1249         y = sb->GetPosition().y;
1250
1251         sb = window->GetScrollbar( wxVERTICAL );
1252         if (sb && sb->IsShown())
1253         {
1254             width = sb->GetSize().x;
1255             x = sb->GetPosition().x;
1256
1257             Display *xdisplay = wxGlobalDisplay();
1258             Window xwindow = (Window) GetMainWindow();
1259             Colormap cm = (Colormap) wxTheApp->GetMainColormap( wxGetDisplay() );
1260             wxColour colour = wxSystemSettings::GetColour(wxSYS_COLOUR_APPWORKSPACE);
1261             colour.CalcPixel( (WXColormap) cm );
1262
1263             XSetForeground( xdisplay, g_eraseGC, colour.GetPixel() );
1264
1265             XFillRectangle( xdisplay, xwindow, g_eraseGC, x, y, width, height );
1266         }
1267     }
1268
1269     wxNcPaintEvent nc_paint_event( GetId() );
1270     nc_paint_event.SetEventObject( this );
1271     GetEventHandler()->ProcessEvent( nc_paint_event );
1272
1273     m_updateNcArea = false;
1274 }
1275
1276 // ----------------------------------------------------------------------------
1277 // event handlers
1278 // ----------------------------------------------------------------------------
1279
1280 // Responds to colour changes: passes event on to children.
1281 void wxWindowX11::OnSysColourChanged(wxSysColourChangedEvent& event)
1282 {
1283     wxWindowList::compatibility_iterator node = GetChildren().GetFirst();
1284     while ( node )
1285     {
1286         // Only propagate to non-top-level windows
1287         wxWindow *win = node->GetData();
1288         if ( win->GetParent() )
1289         {
1290             wxSysColourChangedEvent event2;
1291             event.SetEventObject(win);
1292             win->GetEventHandler()->ProcessEvent(event2);
1293         }
1294
1295         node = node->GetNext();
1296     }
1297 }
1298
1299 // See handler for InFocus case in app.cpp for details.
1300 wxWindow* g_GettingFocus = NULL;
1301
1302 void wxWindowX11::OnInternalIdle()
1303 {
1304     // Update invalidated regions.
1305     Update();
1306
1307     // This calls the UI-update mechanism (querying windows for
1308     // menu/toolbar/control state information)
1309     if (wxUpdateUIEvent::CanUpdate((wxWindow*) this))
1310         UpdateWindowUI(wxUPDATE_UI_FROMIDLE);
1311
1312     // Set the input focus if couldn't do it before
1313     if (m_needsInputFocus)
1314     {
1315 #if 0
1316         wxString msg;
1317         msg.Printf("Setting focus for %s from OnInternalIdle\n", GetClassInfo()->GetClassName());
1318         printf(msg.c_str());
1319 #endif
1320         SetFocus();
1321
1322         // If it couldn't set the focus now, there's
1323         // no point in trying again.
1324         m_needsInputFocus = false;
1325     }
1326     g_GettingFocus = NULL;
1327 }
1328
1329 // ----------------------------------------------------------------------------
1330 // function which maintain the global hash table mapping Widgets to wxWidgets
1331 // ----------------------------------------------------------------------------
1332
1333 static bool DoAddWindowToTable(wxWindowHash *hash, Window w, wxWindow *win)
1334 {
1335     if ( !hash->insert(wxWindowHash::value_type(w, win)).second )
1336     {
1337         wxLogDebug( wxT("Widget table clash: new widget is 0x%08x, %s"),
1338                     (unsigned int)w, win->GetClassInfo()->GetClassName());
1339         return false;
1340     }
1341
1342     wxLogTrace( wxT("widget"), wxT("XWindow 0x%08x <-> window %p (%s)"),
1343                 (unsigned int) w, win, win->GetClassInfo()->GetClassName());
1344
1345     return true;
1346 }
1347
1348 static inline wxWindow *DoGetWindowFromTable(wxWindowHash *hash, Window w)
1349 {
1350     wxWindowHash::iterator i = hash->find(w);
1351     return i == hash->end() ? NULL : i->second;
1352 }
1353
1354 static inline void DoDeleteWindowFromTable(wxWindowHash *hash, Window w)
1355 {
1356     wxLogTrace( wxT("widget"), wxT("XWindow 0x%08x deleted"), (unsigned int) w);
1357
1358     hash->erase(w);
1359 }
1360
1361 // ----------------------------------------------------------------------------
1362 // public wrappers
1363 // ----------------------------------------------------------------------------
1364
1365 bool wxAddWindowToTable(Window w, wxWindow *win)
1366 {
1367     return DoAddWindowToTable(wxWidgetHashTable, w, win);
1368 }
1369
1370 wxWindow *wxGetWindowFromTable(Window w)
1371 {
1372     return DoGetWindowFromTable(wxWidgetHashTable, w);
1373 }
1374
1375 void wxDeleteWindowFromTable(Window w)
1376 {
1377     DoDeleteWindowFromTable(wxWidgetHashTable, w);
1378 }
1379
1380 bool wxAddClientWindowToTable(Window w, wxWindow *win)
1381 {
1382     return DoAddWindowToTable(wxClientWidgetHashTable, w, win);
1383 }
1384
1385 wxWindow *wxGetClientWindowFromTable(Window w)
1386 {
1387     return DoGetWindowFromTable(wxClientWidgetHashTable, w);
1388 }
1389
1390 void wxDeleteClientWindowFromTable(Window w)
1391 {
1392     DoDeleteWindowFromTable(wxClientWidgetHashTable, w);
1393 }
1394
1395 // ----------------------------------------------------------------------------
1396 // X11-specific accessors
1397 // ----------------------------------------------------------------------------
1398
1399 WXWindow wxWindowX11::GetMainWindow() const
1400 {
1401     return m_mainWindow;
1402 }
1403
1404 WXWindow wxWindowX11::GetClientAreaWindow() const
1405 {
1406     return m_clientWindow;
1407 }
1408
1409 // ----------------------------------------------------------------------------
1410 // TranslateXXXEvent() functions
1411 // ----------------------------------------------------------------------------
1412
1413 bool wxTranslateMouseEvent(wxMouseEvent& wxevent, wxWindow *win, Window window, XEvent *xevent)
1414 {
1415     switch (XEventGetType(xevent))
1416     {
1417         case EnterNotify:
1418         case LeaveNotify:
1419         case ButtonPress:
1420         case ButtonRelease:
1421         case MotionNotify:
1422         {
1423             wxEventType eventType = wxEVT_NULL;
1424
1425             if (XEventGetType(xevent) == EnterNotify)
1426             {
1427                 //if (local_event.xcrossing.mode!=NotifyNormal)
1428                 //  return ; // Ignore grab events
1429                 eventType = wxEVT_ENTER_WINDOW;
1430                 //            canvas->GetEventHandler()->OnSetFocus();
1431             }
1432             else if (XEventGetType(xevent) == LeaveNotify)
1433             {
1434                 //if (local_event.xcrossingr.mode!=NotifyNormal)
1435                 //  return ; // Ignore grab events
1436                 eventType = wxEVT_LEAVE_WINDOW;
1437                 //            canvas->GetEventHandler()->OnKillFocus();
1438             }
1439             else if (XEventGetType(xevent) == MotionNotify)
1440             {
1441                 eventType = wxEVT_MOTION;
1442             }
1443             else if (XEventGetType(xevent) == ButtonPress)
1444             {
1445                 wxevent.SetTimestamp(XButtonEventGetTime(xevent));
1446                 int button = 0;
1447                 if (XButtonEventLChanged(xevent))
1448                 {
1449                     eventType = wxEVT_LEFT_DOWN;
1450                     button = 1;
1451                 }
1452                 else if (XButtonEventMChanged(xevent))
1453                 {
1454                     eventType = wxEVT_MIDDLE_DOWN;
1455                     button = 2;
1456                 }
1457                 else if (XButtonEventRChanged(xevent))
1458                 {
1459                     eventType = wxEVT_RIGHT_DOWN;
1460                     button = 3;
1461                 }
1462
1463                 // check for a double click
1464                 // TODO: where can we get this value from?
1465                 //long dclickTime = XtGetMultiClickTime(wxGlobalDisplay());
1466                 long dclickTime = 200;
1467                 long ts = wxevent.GetTimestamp();
1468
1469                 int buttonLast = win->GetLastClickedButton();
1470                 long lastTS = win->GetLastClickTime();
1471                 if ( buttonLast && buttonLast == button && (ts - lastTS) < dclickTime )
1472                 {
1473                     // I have a dclick
1474                     win->SetLastClick(0, ts);
1475                     if ( eventType == wxEVT_LEFT_DOWN )
1476                         eventType = wxEVT_LEFT_DCLICK;
1477                     else if ( eventType == wxEVT_MIDDLE_DOWN )
1478                         eventType = wxEVT_MIDDLE_DCLICK;
1479                     else if ( eventType == wxEVT_RIGHT_DOWN )
1480                         eventType = wxEVT_RIGHT_DCLICK;
1481                 }
1482                 else
1483                 {
1484                     // not fast enough or different button
1485                     win->SetLastClick(button, ts);
1486                 }
1487             }
1488             else if (XEventGetType(xevent) == ButtonRelease)
1489             {
1490                 if (XButtonEventLChanged(xevent))
1491                 {
1492                     eventType = wxEVT_LEFT_UP;
1493                 }
1494                 else if (XButtonEventMChanged(xevent))
1495                 {
1496                     eventType = wxEVT_MIDDLE_UP;
1497                 }
1498                 else if (XButtonEventRChanged(xevent))
1499                 {
1500                     eventType = wxEVT_RIGHT_UP;
1501                 }
1502                 else return false;
1503             }
1504             else
1505             {
1506                 return false;
1507             }
1508
1509             wxevent.SetEventType(eventType);
1510
1511             wxevent.m_x = XButtonEventGetX(xevent);
1512             wxevent.m_y = XButtonEventGetY(xevent);
1513
1514             wxevent.m_leftDown = ((eventType == wxEVT_LEFT_DOWN)
1515                 || (XButtonEventLIsDown(xevent)
1516                 && (eventType != wxEVT_LEFT_UP)));
1517             wxevent.m_middleDown = ((eventType == wxEVT_MIDDLE_DOWN)
1518                 || (XButtonEventMIsDown(xevent)
1519                 && (eventType != wxEVT_MIDDLE_UP)));
1520             wxevent.m_rightDown = ((eventType == wxEVT_RIGHT_DOWN)
1521                 || (XButtonEventRIsDown (xevent)
1522                 && (eventType != wxEVT_RIGHT_UP)));
1523
1524             wxevent.m_shiftDown = XButtonEventShiftIsDown(xevent);
1525             wxevent.m_controlDown = XButtonEventCtrlIsDown(xevent);
1526             wxevent.m_altDown = XButtonEventAltIsDown(xevent);
1527             wxevent.m_metaDown = XButtonEventMetaIsDown(xevent);
1528
1529             wxevent.SetId(win->GetId());
1530             wxevent.SetEventObject(win);
1531
1532             return true;
1533         }
1534     }
1535     return false;
1536 }
1537
1538 bool wxTranslateKeyEvent(wxKeyEvent& wxevent, wxWindow *win, Window WXUNUSED(win), XEvent *xevent, bool isAscii)
1539 {
1540     switch (XEventGetType(xevent))
1541     {
1542     case KeyPress:
1543     case KeyRelease:
1544         {
1545             char buf[20];
1546
1547             KeySym keySym;
1548             (void) XLookupString ((XKeyEvent *) xevent, buf, 20, &keySym, NULL);
1549             int id = wxCharCodeXToWX (keySym);
1550             // id may be WXK_xxx code - these are outside ASCII range, so we
1551             // can't just use toupper() on id.
1552             // Only change this if we want the raw key that was pressed,
1553             // and don't change it if we want an ASCII value.
1554             if (!isAscii && (id >= 'a' && id <= 'z'))
1555             {
1556                 id = id + 'A' - 'a';
1557             }
1558
1559             wxevent.m_shiftDown = XKeyEventShiftIsDown(xevent);
1560             wxevent.m_controlDown = XKeyEventCtrlIsDown(xevent);
1561             wxevent.m_altDown = XKeyEventAltIsDown(xevent);
1562             wxevent.m_metaDown = XKeyEventMetaIsDown(xevent);
1563             wxevent.SetEventObject(win);
1564             wxevent.m_keyCode = id;
1565             wxevent.SetTimestamp(XKeyEventGetTime(xevent));
1566
1567             wxevent.m_x = XKeyEventGetX(xevent);
1568             wxevent.m_y = XKeyEventGetY(xevent);
1569
1570             return id > -1;
1571         }
1572     default:
1573         break;
1574     }
1575     return false;
1576 }
1577
1578 // ----------------------------------------------------------------------------
1579 // Colour stuff
1580 // ----------------------------------------------------------------------------
1581
1582 bool wxWindowX11::SetBackgroundColour(const wxColour& col)
1583 {
1584     wxWindowBase::SetBackgroundColour(col);
1585
1586     Display *xdisplay = (Display*) wxGlobalDisplay();
1587     int xscreen = DefaultScreen( xdisplay );
1588     Colormap cm = DefaultColormap( xdisplay, xscreen );
1589
1590     m_backgroundColour.CalcPixel( (WXColormap) cm );
1591
1592     // We don't set the background colour as we paint
1593     // the background ourselves.
1594     // XSetWindowBackground( xdisplay, (Window) m_clientWindow, m_backgroundColour.GetPixel() );
1595
1596     return true;
1597 }
1598
1599 bool wxWindowX11::SetForegroundColour(const wxColour& col)
1600 {
1601     if ( !wxWindowBase::SetForegroundColour(col) )
1602         return false;
1603
1604     return true;
1605 }
1606
1607 // ----------------------------------------------------------------------------
1608 // global functions
1609 // ----------------------------------------------------------------------------
1610
1611 wxWindow *wxGetActiveWindow()
1612 {
1613     // TODO
1614     wxFAIL_MSG(wxT("Not implemented"));
1615     return NULL;
1616 }
1617
1618 /* static */
1619 wxWindow *wxWindowBase::GetCapture()
1620 {
1621     return (wxWindow *)g_captureWindow;
1622 }
1623
1624
1625 // Find the wxWindow at the current mouse position, returning the mouse
1626 // position.
1627 wxWindow* wxFindWindowAtPointer(wxPoint& pt)
1628 {
1629     return wxFindWindowAtPoint(wxGetMousePosition());
1630 }
1631
1632 void wxGetMouseState(int& rootX, int& rootY, unsigned& maskReturn)
1633 {
1634 #if wxUSE_NANOX
1635     /* TODO */
1636     rootX = rootY = 0;
1637     maskReturn = 0;
1638 #else
1639     Display *display = wxGlobalDisplay();
1640     Window rootWindow = RootWindowOfScreen (DefaultScreenOfDisplay(display));
1641     Window rootReturn, childReturn;
1642     int winX, winY;
1643
1644     XQueryPointer (display,
1645                    rootWindow,
1646                    &rootReturn,
1647                    &childReturn,
1648                    &rootX, &rootY, &winX, &winY, &maskReturn);
1649 #endif
1650 }
1651
1652 // Get the current mouse position.
1653 wxPoint wxGetMousePosition()
1654 {
1655     int x, y;
1656     unsigned mask;
1657
1658     wxGetMouseState(x, y, mask);
1659     return wxPoint(x, y);
1660 }
1661
1662 wxMouseState wxGetMouseState()
1663 {
1664     wxMouseState ms;
1665     int x, y;
1666     unsigned mask;
1667
1668     wxGetMouseState(x, y, mask);
1669
1670     ms.SetX(x);
1671     ms.SetY(y);
1672
1673     ms.SetLeftDown(mask & Button1Mask);
1674     ms.SetMiddleDown(mask & Button2Mask);
1675     ms.SetRightDown(mask & Button3Mask);
1676
1677     ms.SetControlDown(mask & ControlMask);
1678     ms.SetShiftDown(mask & ShiftMask);
1679     ms.SetAltDown(mask & Mod3Mask);
1680     ms.SetMetaDown(mask & Mod1Mask);
1681
1682     return ms;
1683 }
1684
1685
1686 // ----------------------------------------------------------------------------
1687 // wxNoOptimize: switch off size optimization
1688 // ----------------------------------------------------------------------------
1689
1690 int wxNoOptimize::ms_count = 0;
1691
1692
1693 // ----------------------------------------------------------------------------
1694 // wxDCModule
1695 // ----------------------------------------------------------------------------
1696
1697 class wxWinModule : public wxModule
1698 {
1699 public:
1700     wxWinModule()
1701     {
1702         // we must be cleaned up before the display is closed
1703         AddDependency(wxClassInfo::FindClass(_T("wxX11DisplayModule")));
1704     }
1705
1706     virtual bool OnInit();
1707     virtual void OnExit();
1708
1709 private:
1710     DECLARE_DYNAMIC_CLASS(wxWinModule)
1711 };
1712
1713 IMPLEMENT_DYNAMIC_CLASS(wxWinModule, wxModule)
1714
1715 bool wxWinModule::OnInit()
1716 {
1717     Display *xdisplay = wxGlobalDisplay();
1718     int xscreen = DefaultScreen( xdisplay );
1719     Window xroot = RootWindow( xdisplay, xscreen );
1720     g_eraseGC = XCreateGC( xdisplay, xroot, 0, NULL );
1721     XSetFillStyle( xdisplay, g_eraseGC, FillSolid );
1722
1723     return true;
1724 }
1725
1726 void wxWinModule::OnExit()
1727 {
1728     Display *xdisplay = wxGlobalDisplay();
1729     XFreeGC( xdisplay, g_eraseGC );
1730 }