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