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