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::DoGetTextExtent(const wxString& string,
1080                                   int *x, int *y,
1081                                   int *descent,
1082                                   int *externalLeading,
1083                                   const wxFont *theFont) const
1084 {
1085     wxFont fontToUse = GetFont();
1086     if (theFont) fontToUse = *theFont;
1087
1088     wxCHECK_RET( fontToUse.Ok(), wxT("invalid font") );
1089
1090     if (string.empty())
1091     {
1092         if (x) (*x) = 0;
1093         if (y) (*y) = 0;
1094         return;
1095     }
1096
1097 #if wxUSE_UNICODE
1098     PangoLayout *layout = pango_layout_new( wxTheApp->GetPangoContext() );
1099
1100     PangoFontDescription *desc = fontToUse.GetNativeFontInfo()->description;
1101     pango_layout_set_font_description(layout, desc);
1102
1103     const wxCharBuffer data = wxConvUTF8.cWC2MB( string );
1104     pango_layout_set_text(layout, (const char*) data, strlen( (const char*) data ));
1105
1106     PangoLayoutLine *line = (PangoLayoutLine *)pango_layout_get_lines(layout)->data;
1107
1108
1109     PangoRectangle rect;
1110     pango_layout_line_get_extents(line, NULL, &rect);
1111
1112     if (x) (*x) = (wxCoord) (rect.width / PANGO_SCALE);
1113     if (y) (*y) = (wxCoord) (rect.height / PANGO_SCALE);
1114     if (descent)
1115     {
1116         // Do something about metrics here
1117         (*descent) = 0;
1118     }
1119     if (externalLeading) (*externalLeading) = 0;  // ??
1120
1121     g_object_unref( G_OBJECT( layout ) );
1122 #else
1123     WXFontStructPtr pFontStruct = fontToUse.GetFontStruct(1.0, wxGlobalDisplay());
1124
1125     int direction, ascent, descent2;
1126     XCharStruct overall;
1127     int slen = string.length();
1128
1129     XTextExtents((XFontStruct*) pFontStruct, (const char*) string.c_str(), slen,
1130                  &direction, &ascent, &descent2, &overall);
1131
1132     if ( x )
1133         *x = (overall.width);
1134     if ( y )
1135         *y = (ascent + descent2);
1136     if (descent)
1137         *descent = descent2;
1138     if (externalLeading)
1139         *externalLeading = 0;
1140 #endif
1141 }
1142
1143 // ----------------------------------------------------------------------------
1144 // painting
1145 // ----------------------------------------------------------------------------
1146
1147 void wxWindowX11::Refresh(bool eraseBack, const wxRect *rect)
1148 {
1149     if (eraseBack)
1150     {
1151         if (rect)
1152         {
1153             // Schedule for later Updating in ::Update() or ::OnInternalIdle().
1154             m_clearRegion.Union( rect->x, rect->y, rect->width, rect->height );
1155         }
1156         else
1157         {
1158             int height,width;
1159             GetSize( &width, &height );
1160
1161             // Schedule for later Updating in ::Update() or ::OnInternalIdle().
1162             m_clearRegion.Clear();
1163             m_clearRegion.Union( 0, 0, width, height );
1164         }
1165     }
1166
1167     if (rect)
1168     {
1169          // Schedule for later Updating in ::Update() or ::OnInternalIdle().
1170          m_updateRegion.Union( rect->x, rect->y, rect->width, rect->height );
1171     }
1172     else
1173     {
1174         int height,width;
1175         GetSize( &width, &height );
1176
1177         // Schedule for later Updating in ::Update() or ::OnInternalIdle().
1178         m_updateRegion.Clear();
1179         m_updateRegion.Union( 0, 0, width, height );
1180     }
1181 }
1182
1183 void wxWindowX11::Update()
1184 {
1185     if (m_updateNcArea)
1186     {
1187         // wxLogDebug("wxWindowX11::UpdateNC: %s", GetClassInfo()->GetClassName());
1188         // Send nc paint events.
1189         SendNcPaintEvents();
1190     }
1191
1192     if (!m_updateRegion.IsEmpty())
1193     {
1194         // wxLogDebug("wxWindowX11::Update: %s", GetClassInfo()->GetClassName());
1195         // Actually send erase events.
1196         SendEraseEvents();
1197
1198         // Actually send paint events.
1199         SendPaintEvents();
1200     }
1201 }
1202
1203 void wxWindowX11::SendEraseEvents()
1204 {
1205     if (m_clearRegion.IsEmpty()) return;
1206
1207     wxClientDC dc( (wxWindow*)this );
1208     dc.SetDeviceClippingRegion( m_clearRegion );
1209
1210     wxEraseEvent erase_event( GetId(), &dc );
1211     erase_event.SetEventObject( this );
1212
1213     if (!HandleWindowEvent(erase_event) )
1214     {
1215         Display *xdisplay = wxGlobalDisplay();
1216         Window xwindow = (Window) GetClientAreaWindow();
1217         XSetForeground( xdisplay, g_eraseGC, m_backgroundColour.GetPixel() );
1218
1219         wxRegionIterator upd( m_clearRegion );
1220         while (upd)
1221         {
1222             XFillRectangle( xdisplay, xwindow, g_eraseGC,
1223                             upd.GetX(), upd.GetY(), upd.GetWidth(), upd.GetHeight() );
1224             upd ++;
1225         }
1226     }
1227
1228     m_clearRegion.Clear();
1229 }
1230
1231 void wxWindowX11::SendPaintEvents()
1232 {
1233     //    wxLogDebug("SendPaintEvents: %s (%ld)", GetClassInfo()->GetClassName(), GetId());
1234
1235     m_clipPaintRegion = true;
1236
1237     wxPaintEvent paint_event( GetId() );
1238     paint_event.SetEventObject( this );
1239     HandleWindowEvent( paint_event );
1240
1241     m_updateRegion.Clear();
1242
1243     m_clipPaintRegion = false;
1244 }
1245
1246 void wxWindowX11::SendNcPaintEvents()
1247 {
1248     wxWindow *window = (wxWindow*) this;
1249
1250     // All this for drawing the small square between the scrollbars.
1251     int width = 0;
1252     int height = 0;
1253     int x = 0;
1254     int y = 0;
1255     wxScrollBar *sb = window->GetScrollbar( wxHORIZONTAL );
1256     if (sb && sb->IsShown())
1257     {
1258         height = sb->GetSize().y;
1259         y = sb->GetPosition().y;
1260
1261         sb = window->GetScrollbar( wxVERTICAL );
1262         if (sb && sb->IsShown())
1263         {
1264             width = sb->GetSize().x;
1265             x = sb->GetPosition().x;
1266
1267             Display *xdisplay = wxGlobalDisplay();
1268             Window xwindow = (Window) GetMainWindow();
1269             Colormap cm = (Colormap) wxTheApp->GetMainColormap( wxGetDisplay() );
1270             wxColour colour = wxSystemSettings::GetColour(wxSYS_COLOUR_APPWORKSPACE);
1271             colour.CalcPixel( (WXColormap) cm );
1272
1273             XSetForeground( xdisplay, g_eraseGC, colour.GetPixel() );
1274
1275             XFillRectangle( xdisplay, xwindow, g_eraseGC, x, y, width, height );
1276         }
1277     }
1278
1279     wxNcPaintEvent nc_paint_event( GetId() );
1280     nc_paint_event.SetEventObject( this );
1281     HandleWindowEvent( nc_paint_event );
1282
1283     m_updateNcArea = false;
1284 }
1285
1286 // ----------------------------------------------------------------------------
1287 // event handlers
1288 // ----------------------------------------------------------------------------
1289
1290 // Responds to colour changes: passes event on to children.
1291 void wxWindowX11::OnSysColourChanged(wxSysColourChangedEvent& event)
1292 {
1293     wxWindowList::compatibility_iterator node = GetChildren().GetFirst();
1294     while ( node )
1295     {
1296         // Only propagate to non-top-level windows
1297         wxWindow *win = node->GetData();
1298         if ( win->GetParent() )
1299         {
1300             wxSysColourChangedEvent event2;
1301             event.SetEventObject(win);
1302             win->HandleWindowEvent(event2);
1303         }
1304
1305         node = node->GetNext();
1306     }
1307 }
1308
1309 // See handler for InFocus case in app.cpp for details.
1310 wxWindow* g_GettingFocus = NULL;
1311
1312 void wxWindowX11::OnInternalIdle()
1313 {
1314     // Update invalidated regions.
1315     Update();
1316
1317     // This calls the UI-update mechanism (querying windows for
1318     // menu/toolbar/control state information)
1319     if (wxUpdateUIEvent::CanUpdate((wxWindow*) this) && IsShownOnScreen())
1320         UpdateWindowUI(wxUPDATE_UI_FROMIDLE);
1321
1322     // Set the input focus if couldn't do it before
1323     if (m_needsInputFocus)
1324     {
1325 #if 0
1326         wxString msg;
1327         msg.Printf("Setting focus for %s from OnInternalIdle\n", GetClassInfo()->GetClassName());
1328         printf(msg.c_str());
1329 #endif
1330         SetFocus();
1331
1332         // If it couldn't set the focus now, there's
1333         // no point in trying again.
1334         m_needsInputFocus = false;
1335     }
1336     g_GettingFocus = NULL;
1337 }
1338
1339 // ----------------------------------------------------------------------------
1340 // function which maintain the global hash table mapping Widgets to wxWidgets
1341 // ----------------------------------------------------------------------------
1342
1343 static bool DoAddWindowToTable(wxWindowHash *hash, Window w, wxWindow *win)
1344 {
1345     if ( !hash->insert(wxWindowHash::value_type(w, win)).second )
1346     {
1347         wxLogDebug( wxT("Widget table clash: new widget is 0x%08x, %s"),
1348                     (unsigned int)w, win->GetClassInfo()->GetClassName());
1349         return false;
1350     }
1351
1352     wxLogTrace( wxT("widget"), wxT("XWindow 0x%08x <-> window %p (%s)"),
1353                 (unsigned int) w, win, win->GetClassInfo()->GetClassName());
1354
1355     return true;
1356 }
1357
1358 static inline wxWindow *DoGetWindowFromTable(wxWindowHash *hash, Window w)
1359 {
1360     wxWindowHash::iterator i = hash->find(w);
1361     return i == hash->end() ? NULL : i->second;
1362 }
1363
1364 static inline void DoDeleteWindowFromTable(wxWindowHash *hash, Window w)
1365 {
1366     wxLogTrace( wxT("widget"), wxT("XWindow 0x%08x deleted"), (unsigned int) w);
1367
1368     hash->erase(w);
1369 }
1370
1371 // ----------------------------------------------------------------------------
1372 // public wrappers
1373 // ----------------------------------------------------------------------------
1374
1375 bool wxAddWindowToTable(Window w, wxWindow *win)
1376 {
1377     return DoAddWindowToTable(wxWidgetHashTable, w, win);
1378 }
1379
1380 wxWindow *wxGetWindowFromTable(Window w)
1381 {
1382     return DoGetWindowFromTable(wxWidgetHashTable, w);
1383 }
1384
1385 void wxDeleteWindowFromTable(Window w)
1386 {
1387     DoDeleteWindowFromTable(wxWidgetHashTable, w);
1388 }
1389
1390 bool wxAddClientWindowToTable(Window w, wxWindow *win)
1391 {
1392     return DoAddWindowToTable(wxClientWidgetHashTable, w, win);
1393 }
1394
1395 wxWindow *wxGetClientWindowFromTable(Window w)
1396 {
1397     return DoGetWindowFromTable(wxClientWidgetHashTable, w);
1398 }
1399
1400 void wxDeleteClientWindowFromTable(Window w)
1401 {
1402     DoDeleteWindowFromTable(wxClientWidgetHashTable, w);
1403 }
1404
1405 // ----------------------------------------------------------------------------
1406 // X11-specific accessors
1407 // ----------------------------------------------------------------------------
1408
1409 WXWindow wxWindowX11::GetMainWindow() const
1410 {
1411     return m_mainWindow;
1412 }
1413
1414 WXWindow wxWindowX11::GetClientAreaWindow() const
1415 {
1416     return m_clientWindow;
1417 }
1418
1419 // ----------------------------------------------------------------------------
1420 // TranslateXXXEvent() functions
1421 // ----------------------------------------------------------------------------
1422
1423 bool wxTranslateMouseEvent(wxMouseEvent& wxevent,
1424                            wxWindow *win,
1425                            Window WXUNUSED(window),
1426                            XEvent *xevent)
1427 {
1428     switch (XEventGetType(xevent))
1429     {
1430         case EnterNotify:
1431         case LeaveNotify:
1432         case ButtonPress:
1433         case ButtonRelease:
1434         case MotionNotify:
1435         {
1436             wxEventType eventType = wxEVT_NULL;
1437
1438             if (XEventGetType(xevent) == EnterNotify)
1439             {
1440                 //if (local_event.xcrossing.mode!=NotifyNormal)
1441                 //  return ; // Ignore grab events
1442                 eventType = wxEVT_ENTER_WINDOW;
1443                 //            canvas->GetEventHandler()->OnSetFocus();
1444             }
1445             else if (XEventGetType(xevent) == LeaveNotify)
1446             {
1447                 //if (local_event.xcrossingr.mode!=NotifyNormal)
1448                 //  return ; // Ignore grab events
1449                 eventType = wxEVT_LEAVE_WINDOW;
1450                 //            canvas->GetEventHandler()->OnKillFocus();
1451             }
1452             else if (XEventGetType(xevent) == MotionNotify)
1453             {
1454                 eventType = wxEVT_MOTION;
1455             }
1456             else if (XEventGetType(xevent) == ButtonPress)
1457             {
1458                 wxevent.SetTimestamp(XButtonEventGetTime(xevent));
1459                 int button = 0;
1460                 if (XButtonEventLChanged(xevent))
1461                 {
1462                     eventType = wxEVT_LEFT_DOWN;
1463                     button = 1;
1464                 }
1465                 else if (XButtonEventMChanged(xevent))
1466                 {
1467                     eventType = wxEVT_MIDDLE_DOWN;
1468                     button = 2;
1469                 }
1470                 else if (XButtonEventRChanged(xevent))
1471                 {
1472                     eventType = wxEVT_RIGHT_DOWN;
1473                     button = 3;
1474                 }
1475                 else if ( xevent->xbutton.button == Button4 ||
1476                             xevent->xbutton.button == Button5 )
1477                 {
1478                     // this is the same value as used under wxMSW
1479                     static const int WHEEL_DELTA = 120;
1480
1481                     eventType = wxEVT_MOUSEWHEEL;
1482                     button = xevent->xbutton.button;
1483
1484                     wxevent.m_linesPerAction = 3;
1485                     wxevent.m_wheelDelta = WHEEL_DELTA;
1486
1487                     // Button 4 means mousewheel up, 5 means down
1488                     wxevent.m_wheelRotation = button == Button4 ? WHEEL_DELTA
1489                                                                 : -WHEEL_DELTA;
1490                 }
1491
1492                 // check for a double click
1493                 // TODO: where can we get this value from?
1494                 //long dclickTime = XtGetMultiClickTime(wxGlobalDisplay());
1495                 long dclickTime = 200;
1496                 long ts = wxevent.GetTimestamp();
1497
1498                 int buttonLast = win->GetLastClickedButton();
1499                 long lastTS = win->GetLastClickTime();
1500                 if ( buttonLast && buttonLast == button && (ts - lastTS) < dclickTime )
1501                 {
1502                     // I have a dclick
1503                     win->SetLastClick(0, ts);
1504                     if ( eventType == wxEVT_LEFT_DOWN )
1505                         eventType = wxEVT_LEFT_DCLICK;
1506                     else if ( eventType == wxEVT_MIDDLE_DOWN )
1507                         eventType = wxEVT_MIDDLE_DCLICK;
1508                     else if ( eventType == wxEVT_RIGHT_DOWN )
1509                         eventType = wxEVT_RIGHT_DCLICK;
1510                 }
1511                 else
1512                 {
1513                     // not fast enough or different button
1514                     win->SetLastClick(button, ts);
1515                 }
1516             }
1517             else if (XEventGetType(xevent) == ButtonRelease)
1518             {
1519                 if (XButtonEventLChanged(xevent))
1520                 {
1521                     eventType = wxEVT_LEFT_UP;
1522                 }
1523                 else if (XButtonEventMChanged(xevent))
1524                 {
1525                     eventType = wxEVT_MIDDLE_UP;
1526                 }
1527                 else if (XButtonEventRChanged(xevent))
1528                 {
1529                     eventType = wxEVT_RIGHT_UP;
1530                 }
1531                 else return false;
1532             }
1533             else
1534             {
1535                 return false;
1536             }
1537
1538             wxevent.SetEventType(eventType);
1539
1540             wxevent.m_x = XButtonEventGetX(xevent);
1541             wxevent.m_y = XButtonEventGetY(xevent);
1542
1543             wxevent.m_leftDown = ((eventType == wxEVT_LEFT_DOWN)
1544                 || (XButtonEventLIsDown(xevent)
1545                 && (eventType != wxEVT_LEFT_UP)));
1546             wxevent.m_middleDown = ((eventType == wxEVT_MIDDLE_DOWN)
1547                 || (XButtonEventMIsDown(xevent)
1548                 && (eventType != wxEVT_MIDDLE_UP)));
1549             wxevent.m_rightDown = ((eventType == wxEVT_RIGHT_DOWN)
1550                 || (XButtonEventRIsDown (xevent)
1551                 && (eventType != wxEVT_RIGHT_UP)));
1552
1553             wxevent.m_shiftDown = XButtonEventShiftIsDown(xevent);
1554             wxevent.m_controlDown = XButtonEventCtrlIsDown(xevent);
1555             wxevent.m_altDown = XButtonEventAltIsDown(xevent);
1556             wxevent.m_metaDown = XButtonEventMetaIsDown(xevent);
1557
1558             wxevent.SetId(win->GetId());
1559             wxevent.SetEventObject(win);
1560
1561             return true;
1562         }
1563     }
1564     return false;
1565 }
1566
1567 bool wxTranslateKeyEvent(wxKeyEvent& wxevent, wxWindow *win, Window WXUNUSED(win), XEvent *xevent, bool isAscii)
1568 {
1569     switch (XEventGetType(xevent))
1570     {
1571     case KeyPress:
1572     case KeyRelease:
1573         {
1574             char buf[20];
1575
1576             KeySym keySym;
1577             (void) XLookupString ((XKeyEvent *) xevent, buf, 20, &keySym, NULL);
1578             int id = wxCharCodeXToWX (keySym);
1579             // id may be WXK_xxx code - these are outside ASCII range, so we
1580             // can't just use toupper() on id.
1581             // Only change this if we want the raw key that was pressed,
1582             // and don't change it if we want an ASCII value.
1583             if (!isAscii && (id >= 'a' && id <= 'z'))
1584             {
1585                 id = id + 'A' - 'a';
1586             }
1587
1588             wxevent.m_shiftDown = XKeyEventShiftIsDown(xevent);
1589             wxevent.m_controlDown = XKeyEventCtrlIsDown(xevent);
1590             wxevent.m_altDown = XKeyEventAltIsDown(xevent);
1591             wxevent.m_metaDown = XKeyEventMetaIsDown(xevent);
1592             wxevent.SetEventObject(win);
1593             wxevent.m_keyCode = id;
1594             wxevent.SetTimestamp(XKeyEventGetTime(xevent));
1595
1596             wxevent.m_x = XKeyEventGetX(xevent);
1597             wxevent.m_y = XKeyEventGetY(xevent);
1598
1599             return id > -1;
1600         }
1601     default:
1602         break;
1603     }
1604     return false;
1605 }
1606
1607 // ----------------------------------------------------------------------------
1608 // Colour stuff
1609 // ----------------------------------------------------------------------------
1610
1611 bool wxWindowX11::SetBackgroundColour(const wxColour& col)
1612 {
1613     wxWindowBase::SetBackgroundColour(col);
1614
1615     Display *xdisplay = (Display*) wxGlobalDisplay();
1616     int xscreen = DefaultScreen( xdisplay );
1617     Colormap cm = DefaultColormap( xdisplay, xscreen );
1618
1619     m_backgroundColour.CalcPixel( (WXColormap) cm );
1620
1621     // We don't set the background colour as we paint
1622     // the background ourselves.
1623     // XSetWindowBackground( xdisplay, (Window) m_clientWindow, m_backgroundColour.GetPixel() );
1624
1625     return true;
1626 }
1627
1628 bool wxWindowX11::SetForegroundColour(const wxColour& col)
1629 {
1630     if ( !wxWindowBase::SetForegroundColour(col) )
1631         return false;
1632
1633     return true;
1634 }
1635
1636 // ----------------------------------------------------------------------------
1637 // global functions
1638 // ----------------------------------------------------------------------------
1639
1640 wxWindow *wxGetActiveWindow()
1641 {
1642     // TODO
1643     wxFAIL_MSG(wxT("Not implemented"));
1644     return NULL;
1645 }
1646
1647 /* static */
1648 wxWindow *wxWindowBase::GetCapture()
1649 {
1650     return (wxWindow *)g_captureWindow;
1651 }
1652
1653
1654 // Find the wxWindow at the current mouse position, returning the mouse
1655 // position.
1656 wxWindow* wxFindWindowAtPointer(wxPoint& pt)
1657 {
1658     pt = wxGetMousePosition();
1659     return wxFindWindowAtPoint(pt);
1660 }
1661
1662 void wxGetMouseState(int& rootX, int& rootY, unsigned& maskReturn)
1663 {
1664 #if wxUSE_NANOX
1665     /* TODO */
1666     rootX = rootY = 0;
1667     maskReturn = 0;
1668 #else
1669     Display *display = wxGlobalDisplay();
1670     Window rootWindow = RootWindowOfScreen (DefaultScreenOfDisplay(display));
1671     Window rootReturn, childReturn;
1672     int winX, winY;
1673
1674     XQueryPointer (display,
1675                    rootWindow,
1676                    &rootReturn,
1677                    &childReturn,
1678                    &rootX, &rootY, &winX, &winY, &maskReturn);
1679 #endif
1680 }
1681
1682 // Get the current mouse position.
1683 wxPoint wxGetMousePosition()
1684 {
1685     int x, y;
1686     unsigned mask;
1687
1688     wxGetMouseState(x, y, mask);
1689     return wxPoint(x, y);
1690 }
1691
1692 wxMouseState wxGetMouseState()
1693 {
1694     wxMouseState ms;
1695     int x, y;
1696     unsigned mask;
1697
1698     wxGetMouseState(x, y, mask);
1699
1700     ms.SetX(x);
1701     ms.SetY(y);
1702
1703     ms.SetLeftDown(mask & Button1Mask);
1704     ms.SetMiddleDown(mask & Button2Mask);
1705     ms.SetRightDown(mask & Button3Mask);
1706
1707     ms.SetControlDown(mask & ControlMask);
1708     ms.SetShiftDown(mask & ShiftMask);
1709     ms.SetAltDown(mask & Mod3Mask);
1710     ms.SetMetaDown(mask & Mod1Mask);
1711
1712     return ms;
1713 }
1714
1715
1716 // ----------------------------------------------------------------------------
1717 // wxNoOptimize: switch off size optimization
1718 // ----------------------------------------------------------------------------
1719
1720 int wxNoOptimize::ms_count = 0;
1721
1722
1723 // ----------------------------------------------------------------------------
1724 // wxDCModule
1725 // ----------------------------------------------------------------------------
1726
1727 class wxWinModule : public wxModule
1728 {
1729 public:
1730     wxWinModule()
1731     {
1732         // we must be cleaned up before the display is closed
1733         AddDependency(wxClassInfo::FindClass(_T("wxX11DisplayModule")));
1734     }
1735
1736     virtual bool OnInit();
1737     virtual void OnExit();
1738
1739 private:
1740     DECLARE_DYNAMIC_CLASS(wxWinModule)
1741 };
1742
1743 IMPLEMENT_DYNAMIC_CLASS(wxWinModule, wxModule)
1744
1745 bool wxWinModule::OnInit()
1746 {
1747     Display *xdisplay = wxGlobalDisplay();
1748     int xscreen = DefaultScreen( xdisplay );
1749     Window xroot = RootWindow( xdisplay, xscreen );
1750     g_eraseGC = XCreateGC( xdisplay, xroot, 0, NULL );
1751     XSetFillStyle( xdisplay, g_eraseGC, FillSolid );
1752
1753     return true;
1754 }
1755
1756 void wxWinModule::OnExit()
1757 {
1758     Display *xdisplay = wxGlobalDisplay();
1759     XFreeGC( xdisplay, g_eraseGC );
1760 }