src/x11/window.cpp

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