src/motif/window.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        src/motif/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 // ============================================================================
  13 // declarations
  14 // ============================================================================
  15
  16 // ----------------------------------------------------------------------------
  17 // headers
  18 // ----------------------------------------------------------------------------
  19
  20 // For compilers that support precompilation, includes "wx.h".
  21 #include "wx/wxprec.h"
  22
  23 #ifndef WX_PRECOMP
  24     #include "wx/hash.h"
  25     #include "wx/log.h"
  26     #include "wx/app.h"
  27     #include "wx/utils.h"
  28     #include "wx/frame.h"
  29     #include "wx/dc.h"
  30     #include "wx/dcclient.h"
  31     #include "wx/button.h"
  32     #include "wx/menu.h"
  33     #include "wx/settings.h"
  34     #include "wx/scrolwin.h"
  35     #include "wx/layout.h"
  36     #include "wx/menuitem.h"
  37     #include "wx/module.h"
  38 #endif
  39
  40 #include "wx/evtloop.h"
  41
  42 #if  wxUSE_DRAG_AND_DROP
  43     #include "wx/dnd.h"
  44 #endif
  45
  46 // DoSetSizeIntr and DoMoveWindowIntr
  47 // PROBLEM:
  48 // under Motif composite controls (such as wxCalendarCtrl or generic wxSpinCtrl
  49 // did not work and/or segfaulted because
  50 // 1) wxWindow::Create calls SetSize,
  51 //    which results in a call to DoSetSize much earlier than in the other ports
  52 // 2) if wxWindow::Create is called (wxControl::Create calls it)
  53 //    then DoSetSize is never called, causing layout problems in composite
  54 //    controls
  55 //
  56 // SOLUTION:
  57 // 1) don't call SetSize, DoSetSize, DoMoveWindow, DoGetPosition,
  58 //    DoSetPosition directly or indirectly from wxWindow::Create
  59 // 2) call DoMoveWindow from DoSetSize, allowing controls to override it
  60
  61 #ifdef __VMS__
  62     #pragma message disable nosimpint
  63 #endif
  64 #include <Xm/Xm.h>
  65
  66 #include <Xm/DrawingA.h>
  67 #include <Xm/ScrolledW.h>
  68 #include <Xm/ScrollBar.h>
  69 #include <Xm/Frame.h>
  70 #include <Xm/Label.h>
  71 #include <Xm/RowColumn.h>           // for XmMenuPosition
  72 #ifdef __VMS__
  73     #pragma message enable nosimpint
  74 #endif
  75
  76 #include "wx/motif/private.h"
  77 #include "wx/motif/dcclient.h"
  78
  79 #include <string.h>
  80
  81 // ----------------------------------------------------------------------------
  82 // global variables for this module
  83 // ----------------------------------------------------------------------------
  84
  85 extern wxHashTable *wxWidgetHashTable;
  86 static wxWindow* g_captureWindow = NULL;
  87
  88
  89 // ----------------------------------------------------------------------------
  90 // private functions
  91 // ----------------------------------------------------------------------------
  92
  93 static void wxCanvasRepaintProc(Widget, XtPointer, XmDrawingAreaCallbackStruct * cbs);
  94 static void wxCanvasInputEvent(Widget drawingArea, XtPointer data, XmDrawingAreaCallbackStruct * cbs);
  95 static void wxCanvasMotionEvent(Widget, XButtonEvent * event);
  96 static void wxCanvasEnterLeave(Widget drawingArea, XtPointer clientData, XCrossingEvent * event);
  97 static void wxScrollBarCallback(Widget widget, XtPointer clientData,
  98                                 XmScrollBarCallbackStruct *cbs);
  99 static void wxPanelItemEventHandler(Widget    wid,
 100                                     XtPointer client_data,
 101                                     XEvent*   event,
 102                                     Boolean  *continueToDispatch);
 103
 104 // unused for now
 105 #if 0
 106
 107 // Helper function for 16-bit fonts
 108 static int str16len(const char *s)
 109 {
 110     int count = 0;
 111
 112     while (s[0] && s[1]) {
 113         count++;
 114         s += 2;
 115     }
 116
 117     return count;
 118 }
 119
 120 #endif // 0
 121
 122 // ----------------------------------------------------------------------------
 123 // macros
 124 // ----------------------------------------------------------------------------
 125
 126 #define event_left_is_down(x) ((x)->xbutton.state & Button1Mask)
 127 #define event_middle_is_down(x) ((x)->xbutton.state & Button2Mask)
 128 #define event_right_is_down(x) ((x)->xbutton.state & Button3Mask)
 129
 130 // ----------------------------------------------------------------------------
 131 // event tables
 132 // ----------------------------------------------------------------------------
 133
 134     IMPLEMENT_DYNAMIC_CLASS(wxWindow, wxWindowBase)
 135
 136     BEGIN_EVENT_TABLE(wxWindow, wxWindowBase)
 137         EVT_SYS_COLOUR_CHANGED(wxWindow::OnSysColourChanged)
 138     END_EVENT_TABLE()
 139
 140 // ============================================================================
 141 // implementation
 142 // ============================================================================
 143
 144 // ----------------------------------------------------------------------------
 145 // helper functions
 146 // ----------------------------------------------------------------------------
 147
 148 void wxWindow::UnmanageAndDestroy(WXWidget widget)
 149 {
 150     Widget w = (Widget)widget;
 151     if ( w )
 152     {
 153         XtUnmanageChild(w);
 154         XtDestroyWidget(w);
 155     }
 156 }
 157
 158 bool wxWindow::MapOrUnmap(WXWidget widget, bool domap)
 159 {
 160     Widget w = (Widget)widget;
 161     if ( !w )
 162         return false;
 163
 164     //   Rationale: a lot of common operations (including but not
 165     // limited to moving, resizing and appending items to a listbox)
 166     // unmamange the widget, do their work, then manage it again.
 167     // This means that, for example adding an item to a listbox will show it,
 168     // or that most controls are shown every time they are moved or resized!
 169     XtSetMappedWhenManaged( w, domap );
 170
 171     // if the widget is not unmanaged, it still intercepts
 172     // mouse events, even if it is not mapped (and hence invisible)
 173     if ( domap )
 174     {
 175         XtManageChild(w);
 176         // XtMapWidget(w);
 177     }
 178     else
 179     {
 180         XtUnmanageChild(w);
 181         // XtUnmapWidget(w);
 182     }
 183
 184     return true;
 185 }
 186
 187 // ----------------------------------------------------------------------------
 188 // constructors
 189 // ----------------------------------------------------------------------------
 190
 191 void wxWindow::Init()
 192 {
 193     // Motif-specific
 194     m_needsRefresh = true;
 195     m_mainWidget = (WXWidget) 0;
 196
 197     m_winCaptured = false;
 198
 199     m_isShown = true;
 200
 201     m_hScrollBar =
 202     m_vScrollBar =
 203     m_borderWidget =
 204     m_scrolledWindow =
 205     m_drawingArea = (WXWidget) 0;
 206
 207     m_scrollPosX =
 208     m_scrollPosY = 0;
 209
 210     m_backingPixmap = (WXPixmap) 0;
 211     m_pixmapWidth =
 212     m_pixmapHeight = 0;
 213
 214     m_pixmapOffsetX =
 215     m_pixmapOffsetY = 0;
 216
 217     m_lastTS = 0;
 218     m_lastButton = 0;
 219 }
 220
 221 // real construction (Init() must have been called before!)
 222 bool wxWindow::Create(wxWindow *parent, wxWindowID id,
 223                       const wxPoint& pos,
 224                       const wxSize& size,
 225                       long style,
 226                       const wxString& name)
 227 {
 228     // Get default border
 229     wxBorder border = GetBorder(style);
 230     style &= ~wxBORDER_MASK;
 231     style |= border;
 232
 233     wxCHECK_MSG( parent, false, "can't create wxWindow without parent" );
 234
 235     CreateBase(parent, id, pos, size, style, wxDefaultValidator, name);
 236
 237     parent->AddChild(this);
 238     PreCreation();
 239
 240     //// TODO: we should probably optimize by only creating a
 241     //// a drawing area if we have one or more scrollbars (wxVSCROLL/wxHSCROLL).
 242     //// But for now, let's simplify things by always creating the
 243     //// drawing area, since otherwise the translations are different.
 244
 245     // New translations for getting mouse motion feedback
 246     static const String translations = wxMOTIF_STR(
 247 "<Btn1Motion>: wxCanvasMotionEvent() DrawingAreaInput() ManagerGadgetButtonMotion()\n\
 248 <Btn2Motion>: wxCanvasMotionEvent() DrawingAreaInput() ManagerGadgetButtonMotion()\n\
 249 <Btn3Motion>: wxCanvasMotionEvent() DrawingAreaInput() ManagerGadgetButtonMotion()\n\
 250 <BtnMotion>: wxCanvasMotionEvent() DrawingAreaInput() ManagerGadgetButtonMotion()\n\
 251 <Btn1Down>: DrawingAreaInput() ManagerGadgetArm()\n\
 252 <Btn2Down>: DrawingAreaInput() ManagerGadgetArm()\n\
 253 <Btn3Down>: DrawingAreaInput() ManagerGadgetArm()\n\
 254 <Btn1Up>: DrawingAreaInput() ManagerGadgetActivate()\n\
 255 <Btn2Up>: DrawingAreaInput() ManagerGadgetActivate()\n\
 256 <Btn3Up>: DrawingAreaInput() ManagerGadgetActivate()\n\
 257 <Motion>: wxCanvasMotionEvent() DrawingAreaInput()\n\
 258 <EnterWindow>: wxCanvasMotionEvent() DrawingAreaInput()\n\
 259 <LeaveWindow>: wxCanvasMotionEvent() DrawingAreaInput()\n\
 260 <Key>: DrawingAreaInput()");
 261
 262     XtActionsRec actions[1];
 263     actions[0].string = wxMOTIF_STR("wxCanvasMotionEvent");
 264     actions[0].proc = (XtActionProc) wxCanvasMotionEvent;
 265     XtAppAddActions ((XtAppContext) wxTheApp->GetAppContext(), actions, 1);
 266
 267     Widget parentWidget = (Widget) parent->GetClientWidget();
 268     m_borderWidget = wxCreateBorderWidget( (WXWidget)parentWidget, style );
 269
 270     m_scrolledWindow = (WXWidget)XtVaCreateManagedWidget
 271                                  (
 272                                   "scrolledWindow",
 273                                   xmScrolledWindowWidgetClass,
 274                                   m_borderWidget ? (Widget) m_borderWidget
 275                                                  : parentWidget,
 276                                   XmNresizePolicy, XmRESIZE_NONE,
 277                                   XmNspacing, 0,
 278                                   XmNscrollingPolicy, XmAPPLICATION_DEFINED,
 279                                   //XmNscrollBarDisplayPolicy, XmAS_NEEDED,
 280                                   NULL
 281                                  );
 282
 283     XtTranslations ptr = XtParseTranslationTable(translations);
 284     m_drawingArea = (WXWidget)XtVaCreateWidget
 285                               (
 286                                name,
 287                                xmDrawingAreaWidgetClass, (Widget) m_scrolledWindow,
 288                                XmNunitType, XmPIXELS,
 289                                // XmNresizePolicy, XmRESIZE_ANY,
 290                                XmNresizePolicy, XmRESIZE_NONE,
 291                                XmNmarginHeight, 0,
 292                                XmNmarginWidth, 0,
 293                                XmNtranslations, ptr,
 294                                NULL
 295                               );
 296     XtFree((char *) ptr);
 297
 298 #if 0
 299     if (GetWindowStyleFlag() & wxOVERRIDE_KEY_TRANSLATIONS)
 300     {
 301         ptr = XtParseTranslationTable ("<Key>: DrawingAreaInput()");
 302         XtOverrideTranslations ((Widget) m_drawingArea, ptr);
 303         XtFree ((char *) ptr);
 304     }
 305 #endif // 0
 306
 307     wxAddWindowToTable((Widget) m_drawingArea, this);
 308     wxAddWindowToTable((Widget) m_scrolledWindow, this);
 309
 310     // This order is very important in Motif 1.2.1
 311     XtRealizeWidget ((Widget) m_scrolledWindow);
 312     XtRealizeWidget ((Widget) m_drawingArea);
 313     XtManageChild ((Widget) m_drawingArea);
 314
 315     ptr = XtParseTranslationTable("<Configure>: resize()");
 316     XtOverrideTranslations((Widget) m_drawingArea, ptr);
 317     XtFree ((char *) ptr);
 318
 319     XtAddCallback ((Widget) m_drawingArea, XmNexposeCallback, (XtCallbackProc) wxCanvasRepaintProc, (XtPointer) this);
 320     XtAddCallback ((Widget) m_drawingArea, XmNinputCallback, (XtCallbackProc) wxCanvasInputEvent, (XtPointer) this);
 321
 322     XtAddEventHandler(
 323                       (Widget)m_drawingArea,
 324                        PointerMotionHintMask | EnterWindowMask |
 325                        LeaveWindowMask | FocusChangeMask,
 326                        False,
 327                        (XtEventHandler) wxCanvasEnterLeave,
 328                        (XtPointer) this
 329                      );
 330
 331     XmScrolledWindowSetAreas(
 332                              (Widget)m_scrolledWindow,
 333                              (Widget) 0, (Widget) 0,
 334                              (Widget) m_drawingArea);
 335
 336     PostCreation();
 337
 338     // Without this, the cursor may not be restored properly (e.g. in splitter
 339     // sample).
 340     SetCursor(*wxSTANDARD_CURSOR);
 341     DoSetSizeIntr(pos.x, pos.y, size.x,size.y, wxSIZE_AUTO, true);
 342     return true;
 343 }
 344
 345 // Destructor
 346 wxWindow::~wxWindow()
 347 {
 348     SendDestroyEvent();
 349
 350     if (g_captureWindow == this)
 351         g_captureWindow = NULL;
 352
 353     // Motif-specific actions first
 354     WXWidget wMain = GetMainWidget();
 355     if ( wMain )
 356     {
 357         // Removes event handlers
 358         DetachWidget(wMain);
 359     }
 360
 361     // If m_drawingArea, we're a fully-fledged window with drawing area,
 362     // scrollbars etc. (what wxCanvas used to be)
 363     if ( m_drawingArea )
 364     {
 365         // Destroy children before destroying self
 366         DestroyChildren();
 367
 368         if (m_backingPixmap)
 369             XFreePixmap (XtDisplay ((Widget) GetMainWidget()), (Pixmap) m_backingPixmap);
 370
 371         Widget w = (Widget) m_drawingArea;
 372         wxDeleteWindowFromTable(w);
 373
 374         if (w)
 375         {
 376             XtDestroyWidget(w);
 377             m_drawingArea = (WXWidget) 0;
 378         }
 379
 380         // Only if we're _really_ a canvas (not a dialog box/panel)
 381         if (m_scrolledWindow)
 382         {
 383             wxDeleteWindowFromTable((Widget) m_scrolledWindow);
 384         }
 385
 386         if (m_hScrollBar)
 387         {
 388             wxDeleteWindowFromTable((Widget) m_hScrollBar);
 389             XtUnmanageChild((Widget) m_hScrollBar);
 390         }
 391         if (m_vScrollBar)
 392         {
 393             wxDeleteWindowFromTable((Widget) m_vScrollBar);
 394             XtUnmanageChild((Widget) m_vScrollBar);
 395         }
 396
 397         if (m_hScrollBar)
 398             XtDestroyWidget((Widget) m_hScrollBar);
 399         if (m_vScrollBar)
 400             XtDestroyWidget((Widget) m_vScrollBar);
 401
 402         UnmanageAndDestroy(m_scrolledWindow);
 403
 404         if (m_borderWidget)
 405         {
 406             XtDestroyWidget ((Widget) m_borderWidget);
 407             m_borderWidget = (WXWidget) 0;
 408         }
 409     }
 410     else // Why wasn't this here before? JACS 8/3/2000
 411         DestroyChildren();
 412
 413
 414     // Destroy the window
 415     if (GetMainWidget())
 416     {
 417         // If this line (XtDestroyWidget) causes a crash, you may comment it out.
 418         // Child widgets will get destroyed automatically when a frame
 419         // or dialog is destroyed, but before that you may get some memory
 420         // leaks and potential layout problems if you delete and then add
 421         // child windows.
 422
 423         // GRG, Feb/2000: commented this out when adding support for
 424         //   wxSCROLL[WIN]_THUMBRELEASE events. Also it was reported
 425         //   that this call crashed wxMotif under OS/2, so it seems
 426         //   that leaving it out is the right thing to do.
 427         // SN, Feb/2000: newgrid/griddemo shows why it is needed :-(
 428         XtDestroyWidget((Widget) GetMainWidget());
 429         SetMainWidget((WXWidget) NULL);
 430     }
 431 }
 432
 433 // ----------------------------------------------------------------------------
 434 // scrollbar management
 435 // ----------------------------------------------------------------------------
 436
 437 WXWidget wxWindow::DoCreateScrollBar(WXWidget parent,
 438                                      wxOrientation orientation,
 439                                      void (*callback)())
 440 {
 441     int orient = ( orientation & wxHORIZONTAL ) ? XmHORIZONTAL : XmVERTICAL;
 442     Widget sb =
 443         XtVaCreateManagedWidget( "scrollBarWidget",
 444                                  xmScrollBarWidgetClass, (Widget)parent,
 445                                  XmNorientation, orient,
 446                                  XmNincrement, 1,
 447                                  XmNvalue, 0,
 448                                  NULL );
 449
 450     XtPointer o = (XtPointer)orientation;
 451     XtCallbackProc cb = (XtCallbackProc)callback;
 452
 453     XtAddCallback( sb, XmNvalueChangedCallback, cb, o );
 454     XtAddCallback( sb, XmNdragCallback, cb, o );
 455     XtAddCallback( sb, XmNincrementCallback, cb, o );
 456     XtAddCallback( sb, XmNdecrementCallback, cb, o );
 457     XtAddCallback( sb, XmNpageIncrementCallback, cb, o );
 458     XtAddCallback( sb, XmNpageDecrementCallback, cb, o );
 459     XtAddCallback( sb, XmNtoTopCallback, cb, o );
 460     XtAddCallback( sb, XmNtoBottomCallback, cb, o );
 461
 462     return (WXWidget)sb;
 463 }
 464
 465 // Helper function
 466 void wxWindow::CreateScrollbar(wxOrientation orientation)
 467 {
 468     wxCHECK_RET( m_drawingArea, "this window can't have scrollbars" );
 469
 470     XtVaSetValues( (Widget) m_scrolledWindow,
 471                    XmNresizePolicy, XmRESIZE_NONE,
 472                    NULL );
 473
 474     wxColour backgroundColour = wxSystemSettings::GetColour(wxSYS_COLOUR_3DFACE);
 475     // Add scrollbars if required
 476     if (orientation == wxHORIZONTAL)
 477     {
 478         m_hScrollBar = DoCreateScrollBar( m_scrolledWindow, wxHORIZONTAL,
 479                                           (void (*)())wxScrollBarCallback );
 480
 481         wxDoChangeBackgroundColour(m_hScrollBar, backgroundColour, true);
 482
 483         XtRealizeWidget( (Widget)m_hScrollBar );
 484
 485         XtVaSetValues((Widget) m_scrolledWindow,
 486             XmNhorizontalScrollBar, (Widget) m_hScrollBar,
 487             NULL);
 488
 489         wxAddWindowToTable( (Widget)m_hScrollBar, this );
 490     }
 491     else if (orientation == wxVERTICAL)
 492     {
 493         m_vScrollBar = DoCreateScrollBar( m_scrolledWindow, wxVERTICAL,
 494                                           (void (*)())wxScrollBarCallback );
 495
 496         wxDoChangeBackgroundColour(m_vScrollBar, backgroundColour, true);
 497
 498         XtRealizeWidget((Widget)m_vScrollBar);
 499
 500         XtVaSetValues((Widget) m_scrolledWindow,
 501             XmNverticalScrollBar, (Widget) m_vScrollBar,
 502             NULL);
 503
 504         wxAddWindowToTable( (Widget)m_vScrollBar, this );
 505     }
 506
 507     XtVaSetValues( (Widget) m_scrolledWindow,
 508                    XmNresizePolicy, XmRESIZE_ANY,
 509                    NULL );
 510 }
 511
 512 void wxWindow::DestroyScrollbar(wxOrientation orientation)
 513 {
 514     wxCHECK_RET( m_drawingArea, "this window can't have scrollbars" );
 515
 516     XtVaSetValues((Widget) m_scrolledWindow,
 517                   XmNresizePolicy, XmRESIZE_NONE,
 518                   NULL);
 519     String stringSB = orientation == wxHORIZONTAL ?
 520         XmNhorizontalScrollBar : XmNverticalScrollBar;
 521     WXWidget* widgetSB = orientation == wxHORIZONTAL ?
 522         &m_hScrollBar : &m_vScrollBar;
 523
 524     if( *widgetSB )
 525     {
 526         wxDeleteWindowFromTable( (Widget)*widgetSB );
 527         XtDestroyWidget( (Widget)*widgetSB );
 528         *widgetSB = (WXWidget)NULL;
 529     }
 530
 531     XtVaSetValues( (Widget)m_scrolledWindow,
 532                    stringSB, (Widget) 0,
 533                    NULL );
 534
 535     XtVaSetValues((Widget) m_scrolledWindow,
 536                   XmNresizePolicy, XmRESIZE_ANY,
 537                   NULL);
 538 }
 539
 540 // ---------------------------------------------------------------------------
 541 // basic operations
 542 // ---------------------------------------------------------------------------
 543
 544 void wxWindow::SetFocus()
 545 {
 546     Widget wMain = (Widget) GetMainWidget();
 547     XmProcessTraversal(wMain, XmTRAVERSE_CURRENT);
 548     XmProcessTraversal((Widget) GetMainWidget(), XmTRAVERSE_CURRENT);
 549 }
 550
 551 // Get the window with the focus
 552 wxWindow *wxWindowBase::DoFindFocus()
 553 {
 554     // TODO Problems:
 555     // (1) Can there be multiple focussed widgets in an application?
 556     // In which case we need to find the top-level window that's
 557     // currently active.
 558     // (2) The widget with the focus may not be in the widget table
 559     // depending on which widgets I put in the table
 560     wxWindow *winFocus = NULL;
 561     for ( wxWindowList::compatibility_iterator node = wxTopLevelWindows.GetFirst();
 562           node;
 563           node = node->GetNext() )
 564     {
 565         wxWindow *win = node->GetData();
 566
 567         Widget w = XmGetFocusWidget ((Widget) win->GetTopWidget());
 568
 569         if (w != (Widget) NULL)
 570         {
 571             winFocus = wxGetWindowFromTable(w);
 572             if ( winFocus )
 573                 break;
 574         }
 575     }
 576
 577     return winFocus;
 578 }
 579
 580 bool wxWindow::Enable(bool enable)
 581 {
 582     if ( !wxWindowBase::Enable(enable) )
 583         return false;
 584
 585     Widget wMain = (Widget)GetMainWidget();
 586     if ( wMain )
 587     {
 588         XtSetSensitive(wMain, enable);
 589         XmUpdateDisplay(wMain);
 590     }
 591
 592     return true;
 593 }
 594
 595 bool wxWindow::Show(bool show)
 596 {
 597     if ( !wxWindowBase::Show(show) )
 598         return false;
 599
 600     if (m_borderWidget || m_scrolledWindow)
 601     {
 602         MapOrUnmap(m_borderWidget ? m_borderWidget : m_scrolledWindow, show);
 603         // MapOrUnmap(m_drawingArea, show);
 604     }
 605     else
 606     {
 607         if ( !MapOrUnmap(GetTopWidget(), show) )
 608             MapOrUnmap(GetMainWidget(), show);
 609     }
 610
 611     return true;
 612 }
 613
 614 // Raise the window to the top of the Z order
 615 void wxWindow::Raise()
 616 {
 617     Widget wTop = (Widget) GetTopWidget();
 618     Window window = XtWindow(wTop);
 619     XRaiseWindow(XtDisplay(wTop), window);
 620 }
 621
 622 // Lower the window to the bottom of the Z order
 623 void wxWindow::Lower()
 624 {
 625     Widget wTop = (Widget) GetTopWidget();
 626     Window window = XtWindow(wTop);
 627     XLowerWindow(XtDisplay(wTop), window);
 628 }
 629
 630 void wxWindow::SetLabel(const wxString& label)
 631 {
 632     XtVaSetValues((Widget)GetMainWidget(), XmNtitle,
 633                   (const char*)label.mb_str(), NULL);
 634 }
 635
 636 wxString wxWindow::GetLabel() const
 637 {
 638     char *label = NULL;
 639     XtVaGetValues((Widget)GetMainWidget(), XmNtitle, &label, NULL);
 640
 641     return wxString(label);
 642 }
 643
 644 void wxWindow::DoCaptureMouse()
 645 {
 646     g_captureWindow = this;
 647     if ( m_winCaptured )
 648         return;
 649
 650     Widget wMain = (Widget)GetMainWidget();
 651     if ( wMain )
 652         XtAddGrab(wMain, True, False);
 653
 654     m_winCaptured = true;
 655 }
 656
 657 void wxWindow::DoReleaseMouse()
 658 {
 659     g_captureWindow = NULL;
 660     if ( !m_winCaptured )
 661         return;
 662
 663     Widget wMain = (Widget)GetMainWidget();
 664     if ( wMain )
 665         XtRemoveGrab(wMain);
 666
 667     m_winCaptured = false;
 668 }
 669
 670 bool wxWindow::SetFont(const wxFont& font)
 671 {
 672     if ( !wxWindowBase::SetFont(font) )
 673     {
 674         // nothing to do
 675         return false;
 676     }
 677
 678     ChangeFont();
 679
 680     return true;
 681 }
 682
 683 bool wxWindow::SetCursor(const wxCursor& cursor)
 684 {
 685     if ( !wxWindowBase::SetCursor(cursor) )
 686     {
 687         // no change
 688         return false;
 689     }
 690
 691     //    wxASSERT_MSG( m_cursor.Ok(),
 692     //                  wxT("cursor must be valid after call to the base version"));
 693     const wxCursor* cursor2 = NULL;
 694     if (m_cursor.Ok())
 695         cursor2 = & m_cursor;
 696     else
 697         cursor2 = wxSTANDARD_CURSOR;
 698
 699     WXDisplay *dpy = GetXDisplay();
 700     WXCursor x_cursor = cursor2->GetXCursor(dpy);
 701
 702     Widget w = (Widget) GetMainWidget();
 703     Window win = XtWindow(w);
 704     XDefineCursor((Display*) dpy, win, (Cursor) x_cursor);
 705
 706     return true;
 707 }
 708
 709 // Coordinates relative to the window
 710 void wxWindow::WarpPointer (int x, int y)
 711 {
 712     Widget wClient = (Widget)GetClientWidget();
 713
 714     XWarpPointer(XtDisplay(wClient), None, XtWindow(wClient), 0, 0, 0, 0, x, y);
 715 }
 716
 717 // ---------------------------------------------------------------------------
 718 // scrolling stuff
 719 // ---------------------------------------------------------------------------
 720
 721 int wxWindow::GetScrollPos(int orient) const
 722 {
 723     if (orient == wxHORIZONTAL)
 724         return m_scrollPosX;
 725     else
 726         return m_scrollPosY;
 727
 728 #if 0
 729     Widget scrollBar = (Widget) ((orient == wxHORIZONTAL) ? m_hScrollBar : m_vScrollBar);
 730     if (scrollBar)
 731     {
 732         int pos;
 733         XtVaGetValues(scrollBar, XmNvalue, &pos, NULL);
 734         return pos;
 735     }
 736     else
 737         return 0;
 738 #endif // 0
 739 }
 740
 741 // This now returns the whole range, not just the number of positions that we
 742 // can scroll.
 743 int wxWindow::GetScrollRange(int orient) const
 744 {
 745     Widget scrollBar = (Widget)GetScrollbar((wxOrientation)orient);
 746     // CE scintilla windows don't always have these scrollbars
 747     // and it tends to pile up a whole bunch of asserts
 748     //wxCHECK_MSG( scrollBar, 0, "no such scrollbar" );
 749
 750     int range = 0;
 751     if (scrollBar)
 752         XtVaGetValues(scrollBar, XmNmaximum, &range, NULL);
 753     return range;
 754 }
 755
 756 int wxWindow::GetScrollThumb(int orient) const
 757 {
 758     Widget scrollBar = (Widget)GetScrollbar((wxOrientation)orient);
 759     //wxCHECK_MSG( scrollBar, 0, "no such scrollbar" );
 760
 761     int thumb = 0;
 762     if (scrollBar)
 763         XtVaGetValues(scrollBar, XmNsliderSize, &thumb, NULL);
 764     return thumb;
 765 }
 766
 767 void wxWindow::SetScrollPos(int orient, int pos, bool WXUNUSED(refresh))
 768 {
 769     Widget scrollBar = (Widget)GetScrollbar((wxOrientation)orient);
 770
 771     if ( scrollBar )
 772     {
 773         XtVaSetValues (scrollBar, XmNvalue, pos, NULL);
 774     }
 775
 776     SetInternalScrollPos((wxOrientation)orient, pos);
 777 }
 778
 779 // New function that will replace some of the above.
 780 void wxWindow::SetScrollbar(int orient, int pos, int thumbVisible,
 781                             int range, bool WXUNUSED(refresh))
 782 {
 783     int oldW, oldH;
 784     GetSize(& oldW, & oldH);
 785
 786     if (range == 0)
 787         range = 1;
 788     if (thumbVisible == 0)
 789         thumbVisible = 1;
 790
 791     if (thumbVisible > range)
 792         thumbVisible = range;
 793
 794     // Save the old state to see if it changed
 795     WXWidget oldScrollBar = GetScrollbar((wxOrientation)orient);
 796
 797     if (orient == wxHORIZONTAL)
 798     {
 799         if (thumbVisible == range)
 800         {
 801             if (m_hScrollBar)
 802                 DestroyScrollbar(wxHORIZONTAL);
 803         }
 804         else
 805         {
 806             if (!m_hScrollBar)
 807                 CreateScrollbar(wxHORIZONTAL);
 808         }
 809     }
 810     if (orient == wxVERTICAL)
 811     {
 812         if (thumbVisible == range)
 813         {
 814             if (m_vScrollBar)
 815                 DestroyScrollbar(wxVERTICAL);
 816         }
 817         else
 818         {
 819             if (!m_vScrollBar)
 820                 CreateScrollbar(wxVERTICAL);
 821         }
 822     }
 823     WXWidget newScrollBar =  GetScrollbar((wxOrientation)orient);
 824
 825     if (oldScrollBar != newScrollBar)
 826     {
 827         // This is important! Without it, scrollbars misbehave badly.
 828         XtUnrealizeWidget((Widget) m_scrolledWindow);
 829         XmScrolledWindowSetAreas ((Widget) m_scrolledWindow, (Widget) m_hScrollBar, (Widget) m_vScrollBar, (Widget) m_drawingArea);
 830         XtRealizeWidget((Widget) m_scrolledWindow);
 831         XtManageChild((Widget) m_scrolledWindow);
 832     }
 833
 834     if (newScrollBar)
 835     {
 836         XtVaSetValues((Widget) newScrollBar,
 837         XmNvalue, pos,
 838         XmNminimum, 0,
 839         XmNmaximum, range,
 840         XmNsliderSize, thumbVisible,
 841         NULL);
 842     }
 843
 844     SetInternalScrollPos((wxOrientation)orient, pos);
 845
 846     int newW, newH;
 847     GetSize(& newW, & newH);
 848
 849     // Adjusting scrollbars can resize the canvas accidentally
 850     if (newW != oldW || newH != oldH)
 851         SetSize(wxDefaultCoord, wxDefaultCoord, oldW, oldH);
 852 }
 853
 854 // Does a physical scroll
 855 void wxWindow::ScrollWindow(int dx, int dy, const wxRect *rect)
 856 {
 857     int x, y, w, h;
 858     if (rect)
 859     {
 860         // Use specified rectangle
 861         x = rect->x; y = rect->y; w = rect->width; h = rect->height;
 862     }
 863     else
 864     {
 865         // Use whole client area
 866         x = 0; y = 0;
 867         GetClientSize(& w, & h);
 868     }
 869
 870     int x1 = (dx >= 0) ? x : x - dx;
 871     int y1 = (dy >= 0) ? y : y - dy;
 872     int w1 = w - abs(dx);
 873     int h1 = h - abs(dy);
 874     int x2 = (dx >= 0) ? x + dx : x;
 875     int y2 = (dy >= 0) ? y + dy : y;
 876
 877     wxClientDC dc(this);
 878     wxClientDCImpl * const
 879         dcimpl = static_cast<wxClientDCImpl *>(dc.GetImpl());
 880     GC const gc = (GC) dcimpl->GetGC();
 881
 882     dc.SetLogicalFunction (wxCOPY);
 883
 884     Widget widget = (Widget) GetMainWidget();
 885     Window window = XtWindow(widget);
 886     Display* display = XtDisplay(widget);
 887
 888     XCopyArea(display, window, window, gc, x1, y1, w1, h1, x2, y2);
 889
 890     dcimpl->SetAutoSetting(true);
 891     wxBrush brush(GetBackgroundColour(), wxSOLID);
 892     dc.SetBrush(brush); // FIXME: needed?
 893
 894     wxWindowList::compatibility_iterator cnode = m_children.GetFirst();
 895     while (cnode)
 896     {
 897         wxWindow *child = cnode->GetData();
 898         int sx = 0;
 899         int sy = 0;
 900         child->GetSize( &sx, &sy );
 901         wxPoint pos( child->GetPosition() );
 902         child->SetSize( pos.x + dx, pos.y + dy, sx, sy, wxSIZE_ALLOW_MINUS_ONE );
 903         cnode = cnode->GetNext();
 904     }
 905
 906     // We'll add rectangles to the list of update rectangles according to which
 907     // bits we've exposed.
 908     wxList updateRects;
 909
 910     if (dx > 0)
 911     {
 912         wxRect *rect = new wxRect;
 913         rect->x = x;
 914         rect->y = y;
 915         rect->width = dx;
 916         rect->height = h;
 917
 918         XFillRectangle(display, window, gc, rect->x, rect->y, rect->width, rect->height);
 919
 920         rect->x = rect->x;
 921         rect->y = rect->y;
 922         rect->width = rect->width;
 923         rect->height = rect->height;
 924
 925         updateRects.Append((wxObject*) rect);
 926     }
 927     else if (dx < 0)
 928     {
 929         wxRect *rect = new wxRect;
 930
 931         rect->x = x + w + dx;
 932         rect->y = y;
 933         rect->width = -dx;
 934         rect->height = h;
 935
 936         XFillRectangle(display, window, gc, rect->x, rect->y, rect->width, rect->height);
 937
 938         rect->x = rect->x;
 939         rect->y = rect->y;
 940         rect->width = rect->width;
 941         rect->height = rect->height;
 942
 943         updateRects.Append((wxObject*) rect);
 944     }
 945     if (dy > 0)
 946     {
 947         wxRect *rect = new wxRect;
 948
 949         rect->x = x;
 950         rect->y = y;
 951         rect->width = w;
 952         rect->height = dy;
 953
 954         XFillRectangle(display, window, gc, rect->x, rect->y, rect->width, rect->height);
 955
 956         rect->x = rect->x;
 957         rect->y = rect->y;
 958         rect->width = rect->width;
 959         rect->height = rect->height;
 960
 961         updateRects.Append((wxObject*) rect);
 962     }
 963     else if (dy < 0)
 964     {
 965         wxRect *rect = new wxRect;
 966
 967         rect->x = x;
 968         rect->y = y + h + dy;
 969         rect->width = w;
 970         rect->height = -dy;
 971
 972         XFillRectangle(display, window, gc, rect->x, rect->y, rect->width, rect->height);
 973
 974         rect->x = rect->x;
 975         rect->y = rect->y;
 976         rect->width = rect->width;
 977         rect->height = rect->height;
 978
 979         updateRects.Append((wxObject*) rect);
 980     }
 981     dc.SetBrush(wxNullBrush);
 982
 983     // Now send expose events
 984
 985     wxList::compatibility_iterator  node = updateRects.GetFirst();
 986     while (node)
 987     {
 988         wxRect* rect = (wxRect*) node->GetData();
 989         XExposeEvent event;
 990
 991         event.type = Expose;
 992         event.display = display;
 993         event.send_event = True;
 994         event.window = window;
 995
 996         event.x = rect->x;
 997         event.y = rect->y;
 998         event.width = rect->width;
 999         event.height = rect->height;
1000
1001         event.count = 0;
1002
1003         XSendEvent(display, window, False, ExposureMask, (XEvent *)&event);
1004
1005         node = node->GetNext();
1006
1007     }
1008
1009     // Delete the update rects
1010     node = updateRects.GetFirst();
1011     while (node)
1012     {
1013         wxRect* rect = (wxRect*) node->GetData();
1014         delete rect;
1015         node = node->GetNext();
1016     }
1017
1018     XmUpdateDisplay((Widget) GetMainWidget());
1019 }
1020
1021 // ---------------------------------------------------------------------------
1022 // drag and drop
1023 // ---------------------------------------------------------------------------
1024
1025 #if wxUSE_DRAG_AND_DROP
1026
1027 void wxWindow::SetDropTarget(wxDropTarget * WXUNUSED(pDropTarget))
1028 {
1029     // TODO
1030 }
1031
1032 #endif
1033
1034 // Old style file-manager drag&drop
1035 void wxWindow::DragAcceptFiles(bool WXUNUSED(accept))
1036 {
1037     // TODO
1038 }
1039
1040 // ----------------------------------------------------------------------------
1041 // tooltips
1042 // ----------------------------------------------------------------------------
1043
1044 #if wxUSE_TOOLTIPS
1045
1046 void wxWindow::DoSetToolTip(wxToolTip * WXUNUSED(tooltip))
1047 {
1048     // TODO
1049 }
1050
1051 #endif // wxUSE_TOOLTIPS
1052
1053 // ----------------------------------------------------------------------------
1054 // popup menus
1055 // ----------------------------------------------------------------------------
1056
1057 #if wxUSE_MENUS
1058
1059 bool wxWindow::DoPopupMenu(wxMenu *menu, int x, int y)
1060 {
1061     if ( x == wxDefaultCoord && y == wxDefaultCoord )
1062     {
1063         wxPoint mouse = ScreenToClient(wxGetMousePosition());
1064         x = mouse.x; y = mouse.y;
1065     }
1066
1067     Widget widget = (Widget) GetMainWidget();
1068
1069     /* The menuId field seems to be usused, so we'll use it to
1070     indicate whether a menu is popped up or not:
1071     0: Not currently created as a popup
1072     -1: Created as a popup, but not active
1073     1: Active popup.
1074     */
1075
1076     if (menu->GetParent() && (menu->GetId() != -1))
1077         return false;
1078
1079     if (menu->GetMainWidget())
1080     {
1081         menu->DestroyMenu(true);
1082     }
1083
1084     menu->SetId(1); /* Mark as popped-up */
1085     menu->CreateMenu(NULL, widget, menu, 0);
1086     menu->SetInvokingWindow(this);
1087
1088     menu->UpdateUI();
1089
1090     //  menu->SetParent(parent);
1091     //  parent->children->Append(menu);  // Store menu for later deletion
1092
1093     Widget menuWidget = (Widget) menu->GetMainWidget();
1094
1095     int rootX = 0;
1096     int rootY = 0;
1097
1098     int deviceX = x;
1099     int deviceY = y;
1100     /*
1101     if (this->IsKindOf(CLASSINFO(wxCanvas)))
1102     {
1103     wxCanvas *canvas = (wxCanvas *) this;
1104     deviceX = canvas->GetDC ()->LogicalToDeviceX (x);
1105     deviceY = canvas->GetDC ()->LogicalToDeviceY (y);
1106     }
1107     */
1108
1109     Display *display = XtDisplay (widget);
1110     Window rootWindow = RootWindowOfScreen (XtScreen((Widget)widget));
1111     Window thisWindow = XtWindow (widget);
1112     Window childWindow;
1113     XTranslateCoordinates (display, thisWindow, rootWindow, (int) deviceX, (int) deviceY,
1114         &rootX, &rootY, &childWindow);
1115
1116     XButtonPressedEvent event;
1117     event.type = ButtonPress;
1118     event.button = 1;
1119
1120     event.x = deviceX;
1121     event.y = deviceY;
1122
1123     event.x_root = rootX;
1124     event.y_root = rootY;
1125
1126     XmMenuPosition (menuWidget, &event);
1127     XtManageChild (menuWidget);
1128
1129     // The ID of a pop-up menu is 1 when active, and is set to 0 by the
1130     // idle-time destroy routine.
1131     // Waiting until this ID changes causes this function to block until
1132     // the menu has been dismissed and the widgets cleaned up.
1133     // In other words, once this routine returns, it is safe to delete
1134     // the menu object.
1135     // Ian Brown <ian.brown@printsoft.de>
1136
1137     wxEventLoop evtLoop;
1138
1139     while (menu->GetId() == 1)
1140     {
1141         wxDoEventLoopIteration( evtLoop );
1142     }
1143
1144     return true;
1145 }
1146
1147 #endif
1148
1149 // ---------------------------------------------------------------------------
1150 // moving and resizing
1151 // ---------------------------------------------------------------------------
1152
1153 bool wxWindow::PreResize()
1154 {
1155     return true;
1156 }
1157
1158 // Get total size
1159 void wxWindow::DoGetSize(int *x, int *y) const
1160 {
1161     Widget widget = (Widget)( !m_drawingArea ? GetTopWidget() :
1162                               ( m_borderWidget ? m_borderWidget :
1163                                 m_scrolledWindow ? m_scrolledWindow :
1164                                 m_drawingArea ) );
1165     Dimension xx, yy;
1166
1167     if (widget)
1168         XtVaGetValues( widget,
1169                        XmNwidth, &xx,
1170                        XmNheight, &yy,
1171                        NULL );
1172     if(x) *x = widget ? xx : -1;
1173     if(y) *y = widget ? yy : -1;
1174 }
1175
1176 void wxWindow::DoGetPosition(int *x, int *y) const
1177 {
1178     Widget widget = (Widget)
1179         ( m_drawingArea ?
1180           ( m_borderWidget ? m_borderWidget : m_scrolledWindow ) :
1181           GetTopWidget() );
1182
1183     Position xx, yy;
1184     XtVaGetValues(widget, XmNx, &xx, XmNy, &yy, NULL);
1185
1186     // We may be faking the client origin. So a window that's really at (0, 30)
1187     // may appear (to wxWin apps) to be at (0, 0).
1188     if (GetParent())
1189     {
1190         wxPoint pt(GetParent()->GetClientAreaOrigin());
1191         xx = (Position)(xx - pt.x);
1192         yy = (Position)(yy - pt.y);
1193     }
1194
1195     if(x) *x = xx;
1196     if(y) *y = yy;
1197 }
1198
1199 void wxWindow::DoScreenToClient(int *x, int *y) const
1200 {
1201     Widget widget = (Widget) GetClientWidget();
1202     Display *display = XtDisplay((Widget) GetMainWidget());
1203     Window rootWindow = RootWindowOfScreen(XtScreen(widget));
1204     Window thisWindow = XtWindow(widget);
1205
1206     Window childWindow;
1207     int xx = x ? *x : 0;
1208     int yy = y ? *y : 0;
1209     XTranslateCoordinates(display, rootWindow, thisWindow,
1210                           xx, yy, x ? x : &xx, y ? y : &yy,
1211                           &childWindow);
1212 }
1213
1214 void wxWindow::DoClientToScreen(int *x, int *y) const
1215 {
1216     Widget widget = (Widget) GetClientWidget();
1217     Display *display = XtDisplay(widget);
1218     Window rootWindow = RootWindowOfScreen(XtScreen(widget));
1219     Window thisWindow = XtWindow(widget);
1220
1221     Window childWindow;
1222     int xx = x ? *x : 0;
1223     int yy = y ? *y : 0;
1224     XTranslateCoordinates(display, thisWindow, rootWindow,
1225                           xx, yy, x ? x : &xx, y ? y : &yy,
1226                           &childWindow);
1227 }
1228
1229
1230 // Get size *available for subwindows* i.e. excluding menu bar etc.
1231 void wxWindow::DoGetClientSize(int *x, int *y) const
1232 {
1233     Widget widget = (Widget) GetClientWidget();
1234     Dimension xx, yy;
1235     XtVaGetValues(widget, XmNwidth, &xx, XmNheight, &yy, NULL);
1236     if(x) *x = xx; if(y) *y = yy;
1237 }
1238
1239 void wxWindow::DoSetSize(int x, int y, int width, int height, int sizeFlags)
1240 {
1241     DoSetSizeIntr(x, y, width, height, sizeFlags, false);
1242 }
1243
1244 void wxWindow::DoSetSizeIntr(int x, int y, int width, int height,
1245                              int sizeFlags, bool fromCtor)
1246 {
1247     // A bit of optimization to help sort out the flickers.
1248     int oldX = -1, oldY = -1, oldW = -1, oldH = -1;
1249
1250     if( !fromCtor )
1251     {
1252         GetSize(& oldW, & oldH);
1253         GetPosition(& oldX, & oldY);
1254     }
1255
1256     if (x == -1)
1257         x = oldX;
1258     if (x == -1)
1259         x = oldY;
1260
1261     if ( !(sizeFlags & wxSIZE_ALLOW_MINUS_ONE) )
1262     {
1263         if ( width == -1 )
1264             width = oldW;
1265         if ( height == -1 )
1266             height = oldH;
1267     }
1268
1269     wxSize size(wxDefaultSize);
1270     if ( width <= 0 )
1271     {
1272         if ( ( sizeFlags & wxSIZE_AUTO_WIDTH ) && !fromCtor )
1273         {
1274             size = DoGetBestSize();
1275             width = size.x;
1276         }
1277         else
1278         {
1279             width = oldW;
1280         }
1281     }
1282
1283     if ( height == -1 )
1284     {
1285         if( ( sizeFlags & wxSIZE_AUTO_HEIGHT ) && !fromCtor )
1286         {
1287             if( size.x == -1 ) size = DoGetBestSize();
1288             height = size.y;
1289         }
1290         else
1291         {
1292             height = oldH;
1293         }
1294     }
1295
1296     if ( x != oldX || y != oldY || width != oldW || height != oldH
1297          || !wxNoOptimize::CanOptimize() )
1298     {
1299         if (m_drawingArea)
1300         {
1301             int flags = 0;
1302
1303             if (x != oldX)
1304                 flags |= wxMOVE_X;
1305
1306             if (y != oldY)
1307                 flags |= wxMOVE_Y;
1308
1309             if (width > 0)
1310                 flags |= wxMOVE_WIDTH;
1311
1312             if (height > 0)
1313                 flags |= wxMOVE_HEIGHT;
1314
1315             int xx = x; int yy = y;
1316             AdjustForParentClientOrigin(xx, yy, sizeFlags);
1317             if( !fromCtor )
1318                 DoMoveWindow( xx, yy, width, height );
1319             else
1320                 DoMoveWindowIntr( xx, yy, width, height, flags );
1321
1322             return;
1323         }
1324
1325         Widget widget = (Widget) GetTopWidget();
1326         if (!widget)
1327             return;
1328
1329         bool managed = XtIsManaged( widget );
1330         if (managed)
1331             XtUnmanageChild(widget);
1332
1333         int xx = x;
1334         int yy = y;
1335         AdjustForParentClientOrigin(xx, yy, sizeFlags);
1336
1337         DoMoveWindow(xx, yy, width, height);
1338
1339         if (managed)
1340             XtManageChild(widget);
1341     }
1342 }
1343
1344 void wxWindow::DoSetClientSize(int width, int height)
1345 {
1346     if (m_drawingArea)
1347     {
1348         Widget drawingArea = (Widget) m_drawingArea;
1349
1350         XtVaSetValues(drawingArea, XmNresizePolicy, XmRESIZE_ANY, NULL);
1351
1352         if (width > -1)
1353             XtVaSetValues(drawingArea, XmNwidth, width, NULL);
1354         if (height > -1)
1355             XtVaSetValues(drawingArea, XmNheight, height, NULL);
1356
1357         XtVaSetValues(drawingArea, XmNresizePolicy, XmRESIZE_NONE, NULL);
1358         return;
1359     }
1360
1361     Widget widget = (Widget) GetTopWidget();
1362
1363     if (width > -1)
1364         XtVaSetValues(widget, XmNwidth, width, NULL);
1365     if (height > -1)
1366         XtVaSetValues(widget, XmNheight, height, NULL);
1367 }
1368
1369 void wxWindow::DoMoveWindowIntr(int xx, int yy, int w, int h,
1370                                 int flags)
1371 {
1372     if (m_drawingArea)
1373     {
1374         Widget drawingArea = (Widget) m_drawingArea;
1375         Widget borderOrScrolled = m_borderWidget ?
1376             (Widget) m_borderWidget :
1377             (Widget) m_scrolledWindow;
1378
1379         bool managed = XtIsManaged(borderOrScrolled);
1380         if (managed)
1381             XtUnmanageChild (borderOrScrolled);
1382         XtVaSetValues(drawingArea, XmNresizePolicy, XmRESIZE_ANY, NULL);
1383
1384         if (flags & wxMOVE_X)
1385             XtVaSetValues (borderOrScrolled,
1386                            XmNx, xx,
1387                            NULL);
1388         if (flags & wxMOVE_Y)
1389             XtVaSetValues (borderOrScrolled,
1390                            XmNy, yy,
1391                            NULL);
1392
1393         if (flags & wxMOVE_WIDTH)
1394         {
1395             if (m_borderWidget)
1396             {
1397                 XtVaSetValues ((Widget) m_borderWidget, XmNwidth, w, NULL);
1398                 short thick, margin;
1399                 XtVaGetValues ((Widget) m_borderWidget,
1400                                XmNshadowThickness, &thick,
1401                                XmNmarginWidth, &margin,
1402                                NULL);
1403                 w -= 2 * (thick + margin);
1404             }
1405
1406             if( w < 1 ) w = 1;
1407             XtVaSetValues ((Widget) m_scrolledWindow, XmNwidth, w, NULL);
1408         }
1409
1410         if (flags & wxMOVE_HEIGHT)
1411         {
1412             if (m_borderWidget)
1413             {
1414                 XtVaSetValues ((Widget) m_borderWidget, XmNheight, h, NULL);
1415                 short thick, margin;
1416                 XtVaGetValues ((Widget) m_borderWidget,
1417                                XmNshadowThickness, &thick,
1418                                XmNmarginHeight, &margin,
1419                                NULL);
1420                 h -= 2 * (thick + margin);
1421             }
1422
1423             if( h < 1 ) h = 1;
1424             XtVaSetValues ((Widget) m_scrolledWindow, XmNheight, h, NULL);
1425         }
1426
1427         if (managed)
1428             XtManageChild (borderOrScrolled);
1429         XtVaSetValues(drawingArea, XmNresizePolicy, XmRESIZE_NONE, NULL);
1430     }
1431     else
1432     {
1433         if( w < 1 ) w = 1;
1434         if( h < 1 ) h = 1;
1435
1436         XtVaSetValues((Widget)GetTopWidget(),
1437                       XmNx, xx,
1438                       XmNy, yy,
1439                       XmNwidth, w,
1440                       XmNheight, h,
1441                       NULL);
1442     }
1443 }
1444
1445 void wxWindow::DoMoveWindow(int x, int y, int width, int height)
1446 {
1447     DoMoveWindowIntr (x, y, width, height,
1448                       wxMOVE_X|wxMOVE_Y|wxMOVE_WIDTH|wxMOVE_HEIGHT);
1449 }
1450
1451 // ---------------------------------------------------------------------------
1452 // text metrics
1453 // ---------------------------------------------------------------------------
1454
1455 int wxWindow::GetCharHeight() const
1456 {
1457     int height;
1458
1459     if (m_font.Ok())
1460         wxGetTextExtent (GetXDisplay(), m_font, 1.0,
1461                          "x", NULL, &height, NULL, NULL);
1462     else
1463         wxGetTextExtent (this, "x", NULL, &height, NULL, NULL);
1464
1465     return height;
1466 }
1467
1468 int wxWindow::GetCharWidth() const
1469 {
1470     int width;
1471
1472     if (m_font.Ok())
1473         wxGetTextExtent (GetXDisplay(), m_font, 1.0,
1474                          "x", &width, NULL, NULL, NULL);
1475     else
1476         wxGetTextExtent (this, "x", &width, NULL, NULL, NULL);
1477
1478     return width;
1479 }
1480
1481 void wxWindow::GetTextExtent(const wxString& string,
1482                              int *x, int *y,
1483                              int *descent, int *externalLeading,
1484                              const wxFont *theFont) const
1485 {
1486     const wxFont *fontToUse = theFont ? theFont : &m_font;
1487
1488     if (externalLeading)
1489         *externalLeading = 0;
1490     if (fontToUse->Ok())
1491         wxGetTextExtent (GetXDisplay(), *fontToUse, 1.0,
1492                          string, x, y, NULL, descent);
1493     else
1494         wxGetTextExtent (this, string, x, y, NULL, descent);
1495 }
1496
1497 // ----------------------------------------------------------------------------
1498 // painting
1499 // ----------------------------------------------------------------------------
1500
1501 void wxWindow::AddUpdateRect(int x, int y, int w, int h)
1502 {
1503     m_updateRegion.Union( x, y, w, h );
1504 }
1505
1506 void wxWindow::Refresh(bool eraseBack, const wxRect *rect)
1507 {
1508     Widget widget = (Widget) GetMainWidget();
1509     if (!widget)
1510         return;
1511     m_needsRefresh = true;
1512     Display *display = XtDisplay(widget);
1513     Window thisWindow = XtWindow(widget);
1514
1515     XExposeEvent dummyEvent;
1516     int width, height;
1517     GetSize(&width, &height);
1518
1519     dummyEvent.type = Expose;
1520     dummyEvent.display = display;
1521     dummyEvent.send_event = True;
1522     dummyEvent.window = thisWindow;
1523     if (rect)
1524     {
1525         dummyEvent.x = rect->x;
1526         dummyEvent.y = rect->y;
1527         dummyEvent.width = rect->width;
1528         dummyEvent.height = rect->height;
1529     }
1530     else
1531     {
1532         dummyEvent.x = 0;
1533         dummyEvent.y = 0;
1534         dummyEvent.width = width;
1535         dummyEvent.height = height;
1536     }
1537     dummyEvent.count = 0;
1538
1539     if (eraseBack)
1540     {
1541         wxClientDC dc(this);
1542         wxBrush backgroundBrush(GetBackgroundColour(), wxSOLID);
1543         dc.SetBackground(backgroundBrush);
1544
1545         wxClientDCImpl * const
1546             dcimpl = static_cast<wxClientDCImpl *>(dc.GetImpl());
1547         if (rect)
1548             dcimpl->Clear(*rect);
1549         else
1550             dcimpl->Clear();
1551     }
1552
1553     XSendEvent(display, thisWindow, False, ExposureMask, (XEvent *)&dummyEvent);
1554 }
1555
1556 void wxWindow::DoPaint()
1557 {
1558     //TODO : make a temporary gc so we can do the XCopyArea below
1559     if (m_backingPixmap && !m_needsRefresh)
1560     {
1561       wxPaintDC dc(this);
1562
1563       wxPaintDCImpl * const
1564           dcimpl = static_cast<wxPaintDCImpl *>(dc.GetImpl());
1565
1566       GC tempGC = (GC) dcimpl->GetBackingGC();
1567
1568       Widget widget = (Widget) GetMainWidget();
1569
1570       int scrollPosX = 0;
1571       int scrollPosY = 0;
1572
1573       // We have to test whether it's a wxScrolledWindow (hack!) because
1574       // otherwise we don't know how many pixels have been scrolled. We might
1575       // solve this in the future by defining virtual wxWindow functions to get
1576       // the scroll position in pixels. Or, each kind of scrolled window has to
1577       // implement backing stores itself, using generic wxWidgets code.
1578       wxScrolledWindow* scrolledWindow = wxDynamicCast(this, wxScrolledWindow);
1579       if ( scrolledWindow )
1580       {
1581           int x, y;
1582           scrolledWindow->CalcScrolledPosition(0, 0, &x, &y);
1583
1584           scrollPosX = - x;
1585           scrollPosY = - y;
1586       }
1587
1588       // TODO: This could be optimized further by only copying the areas in the
1589       //       current update region.
1590
1591       // Only blit the part visible in the client area. The backing pixmap
1592       // always starts at 0, 0 but we may be looking at only a portion of it.
1593       wxSize clientArea = GetClientSize();
1594       int toBlitX = m_pixmapWidth - scrollPosX;
1595       int toBlitY = m_pixmapHeight - scrollPosY;
1596
1597       // Copy whichever is samller, the amount of pixmap we have to copy,
1598       // or the size of the client area.
1599       toBlitX = wxMin(toBlitX, clientArea.x);
1600       toBlitY = wxMin(toBlitY, clientArea.y);
1601
1602       // Make sure we're not negative
1603       toBlitX = wxMax(0, toBlitX);
1604       toBlitY = wxMax(0, toBlitY);
1605
1606       XCopyArea
1607       (
1608        XtDisplay(widget),
1609        (Pixmap) m_backingPixmap,
1610        XtWindow (widget),
1611        tempGC,
1612        scrollPosX, scrollPosY, // Start at the scroll position
1613        toBlitX, toBlitY,       // How much of the pixmap to copy
1614        0, 0                    // Destination
1615       );
1616     }
1617     else
1618     {
1619         wxWindowDC dc(this);
1620         // Set an erase event first
1621         wxEraseEvent eraseEvent(GetId(), &dc);
1622         eraseEvent.SetEventObject(this);
1623         HandleWindowEvent(eraseEvent);
1624
1625         wxPaintEvent event(GetId());
1626         event.SetEventObject(this);
1627         HandleWindowEvent(event);
1628
1629         m_needsRefresh = false;
1630     }
1631 }
1632
1633 // ----------------------------------------------------------------------------
1634 // event handlers
1635 // ----------------------------------------------------------------------------
1636
1637 // Responds to colour changes: passes event on to children.
1638 void wxWindow::OnSysColourChanged(wxSysColourChangedEvent& event)
1639 {
1640     wxWindowList::compatibility_iterator node = GetChildren().GetFirst();
1641     while ( node )
1642     {
1643         // Only propagate to non-top-level windows
1644         wxWindow *win = node->GetData();
1645         if ( win->GetParent() )
1646         {
1647             wxSysColourChangedEvent event2;
1648             event.SetEventObject(win);
1649             win->HandleWindowEvent(event2);
1650         }
1651
1652         node = node->GetNext();
1653     }
1654 }
1655
1656 void wxWindow::OnInternalIdle()
1657 {
1658     // This calls the UI-update mechanism (querying windows for
1659     // menu/toolbar/control state information)
1660     if (wxUpdateUIEvent::CanUpdate(this) && IsShownOnScreen())
1661         UpdateWindowUI(wxUPDATE_UI_FROMIDLE);
1662 }
1663
1664 // ----------------------------------------------------------------------------
1665 // accelerators
1666 // ----------------------------------------------------------------------------
1667
1668 bool wxWindow::ProcessAccelerator(wxKeyEvent& event)
1669 {
1670 #if wxUSE_ACCEL
1671     if (!m_acceleratorTable.Ok())
1672         return false;
1673
1674     int count = m_acceleratorTable.GetCount();
1675     wxAcceleratorEntry* entries = m_acceleratorTable.GetEntries();
1676     int i;
1677     for (i = 0; i < count; i++)
1678     {
1679         wxAcceleratorEntry* entry = & (entries[i]);
1680         if (entry->MatchesEvent(event))
1681         {
1682             // Bingo, we have a match. Now find a control that matches the
1683             // entry command id.
1684
1685             // Need to go up to the top of the window hierarchy, since it might
1686             // be e.g. a menu item
1687             wxWindow* parent = this;
1688             while ( parent && !parent->IsTopLevel() )
1689                 parent = parent->GetParent();
1690
1691             if (!parent)
1692                 return false;
1693
1694             wxFrame* frame = wxDynamicCast(parent, wxFrame);
1695             if ( frame )
1696             {
1697 #if wxUSE_MENUS
1698                 // Try for a menu command
1699                 if (frame->GetMenuBar())
1700                 {
1701                     wxMenuItem* item = frame->GetMenuBar()->FindItem(entry->GetCommand());
1702                     if (item)
1703                     {
1704                         wxCommandEvent commandEvent(wxEVT_COMMAND_MENU_SELECTED, entry->GetCommand());
1705                         commandEvent.SetEventObject(frame);
1706
1707                         // If ProcessEvent returns true (it was handled), then
1708                         // the calling code will skip the event handling.
1709                         return frame->HandleWindowEvent(commandEvent);
1710                     }
1711                 }
1712 #endif
1713             }
1714
1715             // Find a child matching the command id
1716             wxWindow* child = parent->FindWindow(entry->GetCommand());
1717
1718             // No such child
1719             if (!child)
1720                 return false;
1721
1722             // Now we process those kinds of windows that we can.
1723             // For now, only buttons.
1724             if ( wxDynamicCast(child, wxButton) )
1725             {
1726                 wxCommandEvent commandEvent (wxEVT_COMMAND_BUTTON_CLICKED, child->GetId());
1727                 commandEvent.SetEventObject(child);
1728                 return child->HandleWindowEvent(commandEvent);
1729             }
1730
1731             return false;
1732         } // matches event
1733     }// for
1734 #endif
1735
1736     // We didn't match the key event against an accelerator.
1737     return false;
1738 }
1739
1740 // ============================================================================
1741 // Motif-specific stuff from here on
1742 // ============================================================================
1743
1744 // ----------------------------------------------------------------------------
1745 // function which maintain the global hash table mapping Widgets to wxWidgets
1746 // ----------------------------------------------------------------------------
1747
1748 bool wxAddWindowToTable(Widget w, wxWindow *win)
1749 {
1750     const long key = (long)w;
1751     if ( wxWidgetHashTable->Get(key))
1752     {
1753         wxLogDebug("Widget table clash: new widget is %ld, %s",
1754                    key, win->GetClassInfo()->GetClassName());
1755         return false;
1756     }
1757
1758     wxWidgetHashTable->Put(key, win);
1759
1760     wxLogTrace("widget", "Widget 0x%p <-> window %p (%s)",
1761                w, win, win->GetClassInfo()->GetClassName());
1762
1763     return true;
1764 }
1765
1766 wxWindow *wxGetWindowFromTable(Widget w)
1767 {
1768     return (wxWindow *)wxWidgetHashTable->Get((long) w);
1769 }
1770
1771 void wxDeleteWindowFromTable(Widget w)
1772 {
1773     wxLogTrace("widget", "Widget 0x%p", (WXWidget)w);
1774
1775     wxWidgetHashTable->Delete((long)w);
1776 }
1777
1778 // ----------------------------------------------------------------------------
1779 // add/remove window from the table
1780 // ----------------------------------------------------------------------------
1781
1782 // Add to hash table, add event handler
1783 bool wxWindow::AttachWidget (wxWindow* WXUNUSED(parent), WXWidget mainWidget,
1784                              WXWidget formWidget, int x, int y, int width, int height)
1785 {
1786     wxAddWindowToTable((Widget) mainWidget, this);
1787     XtAddEventHandler( (Widget) mainWidget,
1788                        ButtonPressMask | ButtonReleaseMask
1789                      | PointerMotionMask,
1790                        False,
1791                        wxPanelItemEventHandler,
1792                        (XtPointer) this);
1793
1794     if (!formWidget)
1795     {
1796         XtTranslations ptr;
1797         XtOverrideTranslations ((Widget) mainWidget,
1798             ptr = XtParseTranslationTable ("<Configure>: resize()"));
1799         XtFree ((char *) ptr);
1800     }
1801
1802     // Some widgets have a parent form widget, e.g. wxRadioBox
1803     if (formWidget)
1804     {
1805         if (!wxAddWindowToTable((Widget) formWidget, this))
1806             return false;
1807
1808         XtTranslations ptr;
1809         XtOverrideTranslations ((Widget) formWidget,
1810             ptr = XtParseTranslationTable ("<Configure>: resize()"));
1811         XtFree ((char *) ptr);
1812     }
1813
1814     if (x == -1)
1815         x = 0;
1816     if (y == -1)
1817         y = 0;
1818     DoSetSize (x, y, width, height, wxSIZE_USE_EXISTING);
1819
1820     return true;
1821 }
1822
1823 // Remove event handler, remove from hash table
1824 bool wxWindow::DetachWidget(WXWidget widget)
1825 {
1826     XtRemoveEventHandler( (Widget) widget,
1827                           ButtonPressMask | ButtonReleaseMask
1828                         | PointerMotionMask,
1829                           False,
1830                           wxPanelItemEventHandler,
1831                           (XtPointer)this);
1832
1833     wxDeleteWindowFromTable((Widget) widget);
1834     return true;
1835 }
1836
1837 // ----------------------------------------------------------------------------
1838 // Motif-specific accessors
1839 // ----------------------------------------------------------------------------
1840
1841 WXWindow wxWindow::GetClientXWindow() const
1842 {
1843     Widget wMain = (Widget)GetClientWidget();
1844     if ( wMain )
1845         return (WXWindow) XtWindow(wMain);
1846     else
1847         return (WXWindow) 0;
1848 }
1849
1850 // Get the underlying X window
1851 WXWindow wxWindow::GetXWindow() const
1852 {
1853     Widget wMain = (Widget)GetMainWidget();
1854     if ( wMain )
1855         return (WXWindow) XtWindow(wMain);
1856     else
1857         return (WXWindow) 0;
1858 }
1859
1860 // Get the underlying X display
1861 WXDisplay *wxWindow::GetXDisplay() const
1862 {
1863     Widget wMain = (Widget)GetMainWidget();
1864     if ( wMain )
1865         return (WXDisplay*) XtDisplay(wMain);
1866     else
1867         return NULL;
1868 }
1869
1870 WXWidget wxWindow::GetMainWidget() const
1871 {
1872     if (m_drawingArea)
1873         return m_drawingArea;
1874     else
1875         return m_mainWidget;
1876 }
1877
1878 WXWidget wxWindow::GetClientWidget() const
1879 {
1880     if (m_drawingArea != (WXWidget) 0)
1881         return m_drawingArea;
1882     else
1883         return GetMainWidget();
1884 }
1885
1886 WXWidget wxWindow::GetTopWidget() const
1887 {
1888     return GetMainWidget();
1889 }
1890
1891 WXWidget wxWindow::GetLabelWidget() const
1892 {
1893     return GetMainWidget();
1894 }
1895
1896 // ----------------------------------------------------------------------------
1897 // Motif callbacks
1898 // ----------------------------------------------------------------------------
1899
1900 // All widgets should have this as their resize proc.
1901 // OnSize sent to wxWindow via client data.
1902 void wxWidgetResizeProc(Widget w, XConfigureEvent *WXUNUSED(event),
1903                         String WXUNUSED(args)[], int *WXUNUSED(num_args))
1904 {
1905     wxWindow *win = wxGetWindowFromTable(w);
1906     if (!win)
1907         return;
1908
1909     if (win->PreResize())
1910     {
1911         wxSize newSize(win->GetSize());
1912         wxSizeEvent sizeEvent(newSize, win->GetId());
1913         sizeEvent.SetEventObject(win);
1914         win->HandleWindowEvent(sizeEvent);
1915     }
1916 }
1917
1918 static void wxCanvasRepaintProc(Widget drawingArea,
1919                                 XtPointer clientData,
1920                                 XmDrawingAreaCallbackStruct * cbs)
1921 {
1922     if (!wxGetWindowFromTable(drawingArea))
1923         return;
1924
1925     XEvent * event = cbs->event;
1926     wxWindow * win = (wxWindow *) clientData;
1927
1928     switch (event->type)
1929     {
1930     case Expose:
1931         {
1932             win->AddUpdateRect(event->xexpose.x, event->xexpose.y,
1933                                event->xexpose.width, event->xexpose.height);
1934
1935             if (event -> xexpose.count == 0)
1936             {
1937                 win->DoPaint();
1938             }
1939             break;
1940         }
1941     }
1942 }
1943
1944 // Unable to deal with Enter/Leave without a separate EventHandler (Motif 1.1.4)
1945 static void wxCanvasEnterLeave(Widget drawingArea,
1946                                XtPointer WXUNUSED(clientData),
1947                                XCrossingEvent * event)
1948 {
1949     XmDrawingAreaCallbackStruct cbs;
1950     XEvent ev;
1951
1952     ((XCrossingEvent &) ev) = *event;
1953
1954     cbs.reason = XmCR_INPUT;
1955     cbs.event = &ev;
1956
1957     wxCanvasInputEvent(drawingArea, (XtPointer) NULL, &cbs);
1958 }
1959
1960 // Fix to make it work under Motif 1.0 (!)
1961 static void wxCanvasMotionEvent (Widget WXUNUSED(drawingArea),
1962                                  XButtonEvent *WXUNUSED(event))
1963 {
1964 #if XmVersion <= 1000
1965     XmDrawingAreaCallbackStruct cbs;
1966     XEvent ev;
1967
1968     ev = *((XEvent *) event);
1969     cbs.reason = XmCR_INPUT;
1970     cbs.event = &ev;
1971
1972     wxCanvasInputEvent (drawingArea, (XtPointer) NULL, &cbs);
1973 #endif // XmVersion <= 1000
1974 }
1975
1976 static void wxCanvasInputEvent(Widget drawingArea,
1977                                XtPointer WXUNUSED(data),
1978                                XmDrawingAreaCallbackStruct * cbs)
1979 {
1980     wxWindow *canvas = wxGetWindowFromTable(drawingArea);
1981     XEvent* xevent = cbs->event;
1982
1983     if (canvas==NULL)
1984         return;
1985
1986     if (cbs->reason != XmCR_INPUT)
1987         return;
1988
1989     switch (xevent->xany.type)
1990     {
1991     case EnterNotify:
1992     case LeaveNotify:
1993     case ButtonPress:
1994     case ButtonRelease:
1995     case MotionNotify:
1996         {
1997             wxMouseEvent wxevent(0);
1998             if (wxTranslateMouseEvent(wxevent, canvas, drawingArea, xevent))
1999             {
2000                 canvas->HandleWindowEvent(wxevent);
2001             }
2002             break;
2003         }
2004     case KeyPress:
2005         {
2006             wxKeyEvent event (wxEVT_CHAR);
2007             if (wxTranslateKeyEvent (event, canvas, (Widget) 0, xevent))
2008             {
2009                 // Implement wxFrame::OnCharHook by checking ancestor.
2010                 wxWindow *parent = canvas;
2011                 while (parent && !parent->IsTopLevel())
2012                     parent = parent->GetParent();
2013
2014                 if (parent)
2015                 {
2016                     event.SetEventType(wxEVT_CHAR_HOOK);
2017                     if (parent->HandleWindowEvent(event))
2018                         return;
2019                 }
2020
2021                 // For simplicity, OnKeyDown is the same as OnChar
2022                 // TODO: filter modifier key presses from OnChar
2023                 event.SetEventType(wxEVT_KEY_DOWN);
2024
2025                 // Only process OnChar if OnKeyDown didn't swallow it
2026                 if (!canvas->HandleWindowEvent (event))
2027                 {
2028                     event.SetEventType(wxEVT_CHAR);
2029                     canvas->HandleWindowEvent (event);
2030                 }
2031             }
2032             break;
2033         }
2034     case KeyRelease:
2035         {
2036             wxKeyEvent event (wxEVT_KEY_UP);
2037             if (wxTranslateKeyEvent (event, canvas, (Widget) 0, xevent))
2038             {
2039                 canvas->HandleWindowEvent (event);
2040             }
2041             break;
2042         }
2043     case FocusIn:
2044         {
2045             if (xevent->xfocus.detail != NotifyPointer)
2046             {
2047                 wxFocusEvent event(wxEVT_SET_FOCUS, canvas->GetId());
2048                 event.SetEventObject(canvas);
2049                 canvas->HandleWindowEvent(event);
2050             }
2051             break;
2052         }
2053     case FocusOut:
2054         {
2055             if (xevent->xfocus.detail != NotifyPointer)
2056             {
2057                 wxFocusEvent event(wxEVT_KILL_FOCUS, canvas->GetId());
2058                 event.SetEventObject(canvas);
2059                 canvas->HandleWindowEvent(event);
2060             }
2061             break;
2062         }
2063     default:
2064         break;
2065     }
2066 }
2067
2068 static void wxPanelItemEventHandler(Widget    wid,
2069                                     XtPointer WXUNUSED(client_data),
2070                                     XEvent*   event,
2071                                     Boolean  *continueToDispatch)
2072 {
2073     // Widget can be a label or the actual widget.
2074
2075     wxWindow *window = wxGetWindowFromTable(wid);
2076     if (window)
2077     {
2078         wxMouseEvent wxevent(0);
2079         if (wxTranslateMouseEvent(wxevent, window, wid, event))
2080         {
2081             window->HandleWindowEvent(wxevent);
2082         }
2083     }
2084
2085     // TODO: probably the key to allowing default behaviour to happen. Say we
2086     // set a m_doDefault flag to false at the start of this function. Then in
2087     // e.g. wxWindow::OnMouseEvent we can call Default() which sets this flag to
2088     // true, indicating that default processing can happen. Thus, behaviour can
2089     // appear to be overridden just by adding an event handler and not calling
2090     // wxWindow::OnWhatever. ALSO, maybe we can use this instead of the current
2091     // way of handling drawing area events, to simplify things.
2092     *continueToDispatch = True;
2093 }
2094
2095 static void wxScrollBarCallback(Widget scrollbar,
2096                                 XtPointer clientData,
2097                                 XmScrollBarCallbackStruct *cbs)
2098 {
2099     wxWindow *win = wxGetWindowFromTable(scrollbar);
2100     wxCHECK_RET( win, _T("invalid widget in scrollbar callback") );
2101
2102     wxOrientation orientation = (wxOrientation)wxPtrToUInt(clientData);
2103
2104     wxEventType eventType = wxEVT_NULL;
2105     switch (cbs->reason)
2106     {
2107     case XmCR_INCREMENT:
2108         {
2109             eventType = wxEVT_SCROLLWIN_LINEDOWN;
2110             break;
2111         }
2112     case XmCR_DECREMENT:
2113         {
2114             eventType = wxEVT_SCROLLWIN_LINEUP;
2115             break;
2116         }
2117     case XmCR_DRAG:
2118         {
2119             eventType = wxEVT_SCROLLWIN_THUMBTRACK;
2120             break;
2121         }
2122     case XmCR_VALUE_CHANGED:
2123         {
2124             eventType = wxEVT_SCROLLWIN_THUMBRELEASE;
2125             break;
2126         }
2127     case XmCR_PAGE_INCREMENT:
2128         {
2129             eventType = wxEVT_SCROLLWIN_PAGEDOWN;
2130             break;
2131         }
2132     case XmCR_PAGE_DECREMENT:
2133         {
2134             eventType = wxEVT_SCROLLWIN_PAGEUP;
2135             break;
2136         }
2137     case XmCR_TO_TOP:
2138         {
2139             eventType = wxEVT_SCROLLWIN_TOP;
2140             break;
2141         }
2142     case XmCR_TO_BOTTOM:
2143         {
2144             eventType = wxEVT_SCROLLWIN_BOTTOM;
2145             break;
2146         }
2147     default:
2148         {
2149             // Should never get here
2150             wxFAIL_MSG("Unknown scroll event.");
2151             break;
2152         }
2153     }
2154
2155     wxScrollWinEvent event(eventType,
2156                            cbs->value,
2157                            orientation);
2158     event.SetEventObject( win );
2159     win->HandleWindowEvent(event);
2160 }
2161
2162 // For repainting arbitrary windows
2163 void wxUniversalRepaintProc(Widget w, XtPointer WXUNUSED(c_data), XEvent *event, char *)
2164 {
2165     wxWindow* win = wxGetWindowFromTable(w);
2166     if (!win)
2167         return;
2168
2169     switch ( event->type )
2170     {
2171         case Expose:
2172         {
2173             win->AddUpdateRect(event->xexpose.x, event->xexpose.y,
2174                                event->xexpose.width, event->xexpose.height);
2175
2176             if ( event->xexpose.count == 0 )
2177             {
2178                 win->DoPaint();
2179             }
2180
2181             break;
2182         }
2183     }
2184 }
2185
2186 // ----------------------------------------------------------------------------
2187 // TranslateXXXEvent() functions
2188 // ----------------------------------------------------------------------------
2189
2190 bool wxTranslateMouseEvent(wxMouseEvent& wxevent, wxWindow *win,
2191                            Widget widget, const XEvent *xevent)
2192 {
2193     switch (xevent->xany.type)
2194     {
2195         case EnterNotify:
2196         case LeaveNotify:
2197 #if 0
2198             fprintf(stderr, "Widget 0x%p <-> window %p (%s), %s\n",
2199                     (WXWidget)widget, win, win->GetClassInfo()->GetClassName(),
2200                     (xevent->xany.type == EnterNotify ? "ENTER" : "LEAVE"));
2201 #endif
2202         case ButtonPress:
2203         case ButtonRelease:
2204         case MotionNotify:
2205         {
2206             int eventx = xevent->xbutton.x, eventy = xevent->xbutton.y;
2207
2208             wxEventType eventType = wxEVT_NULL;
2209
2210             if (xevent->xany.type == LeaveNotify)
2211             {
2212                 eventType = wxEVT_LEAVE_WINDOW;
2213             }
2214             if (xevent->xany.type == EnterNotify)
2215             {
2216                 eventType = wxEVT_ENTER_WINDOW;
2217             }
2218             else if (xevent->xany.type == MotionNotify)
2219             {
2220                 eventType = wxEVT_MOTION;
2221
2222                 if (xevent->xmotion.is_hint == NotifyHint)
2223                 {
2224                     Window root, child;
2225                     int x_root, y_root;
2226                     unsigned int state;
2227                     Display *dpy = XtDisplay (widget);
2228
2229                     XQueryPointer (dpy, XtWindow (widget),
2230                         &root, &child,
2231                         &x_root, &y_root, &eventx, &eventy, &state);
2232                 }
2233             }
2234             else if (xevent->xany.type == ButtonPress)
2235             {
2236                 wxevent.SetTimestamp(xevent->xbutton.time);
2237                 int button = 0;
2238                 if (xevent->xbutton.button == Button1)
2239                 {
2240                     eventType = wxEVT_LEFT_DOWN;
2241                     button = 1;
2242                 }
2243                 else if (xevent->xbutton.button == Button2)
2244                 {
2245                     eventType = wxEVT_MIDDLE_DOWN;
2246                     button = 2;
2247                 }
2248                 else if (xevent->xbutton.button == Button3)
2249                 {
2250                     eventType = wxEVT_RIGHT_DOWN;
2251                     button = 3;
2252                 }
2253
2254                 // check for a double click
2255                 //
2256                 long dclickTime = XtGetMultiClickTime(xevent->xany.display);
2257                 long ts = wxevent.GetTimestamp();
2258
2259                 int buttonLast = win->GetLastClickedButton();
2260                 long lastTS = win->GetLastClickTime();
2261                 if ( buttonLast && buttonLast == button &&
2262                      (ts - lastTS) < dclickTime )
2263                 {
2264                     // I have a dclick
2265                     win->SetLastClick(0, ts);
2266                     if ( eventType == wxEVT_LEFT_DOWN )
2267                         eventType = wxEVT_LEFT_DCLICK;
2268                     else if ( eventType == wxEVT_MIDDLE_DOWN )
2269                         eventType = wxEVT_MIDDLE_DCLICK;
2270                     else if ( eventType == wxEVT_RIGHT_DOWN )
2271                         eventType = wxEVT_RIGHT_DCLICK;
2272                 }
2273                 else
2274                 {
2275                     // not fast enough or different button
2276                     win->SetLastClick(button, ts);
2277                 }
2278             }
2279             else if (xevent->xany.type == ButtonRelease)
2280             {
2281                 if (xevent->xbutton.button == Button1)
2282                 {
2283                     eventType = wxEVT_LEFT_UP;
2284                 }
2285                 else if (xevent->xbutton.button == Button2)
2286                 {
2287                     eventType = wxEVT_MIDDLE_UP;
2288                 }
2289                 else if (xevent->xbutton.button == Button3)
2290                 {
2291                     eventType = wxEVT_RIGHT_UP;
2292                 }
2293                 else
2294                     return false;
2295             }
2296             else
2297             {
2298                 return false;
2299             }
2300
2301             wxevent.SetEventType(eventType);
2302
2303             Position x1, y1;
2304             XtVaGetValues(widget, XmNx, &x1, XmNy, &y1, NULL);
2305
2306             int x2, y2;
2307             win->GetPosition(&x2, &y2);
2308
2309             // The button x/y must be translated to wxWidgets
2310             // window space - the widget might be a label or button,
2311             // within a form.
2312             int dx = 0;
2313             int dy = 0;
2314             if (widget != (Widget)win->GetMainWidget())
2315             {
2316                 dx = x1;
2317                 dy = y1;
2318             }
2319
2320             wxevent.m_x = eventx + dx;
2321             wxevent.m_y = eventy + dy;
2322
2323             wxevent.m_leftDown = ((eventType == wxEVT_LEFT_DOWN)
2324                 || (event_left_is_down (xevent)
2325                 && (eventType != wxEVT_LEFT_UP)));
2326             wxevent.m_middleDown = ((eventType == wxEVT_MIDDLE_DOWN)
2327                 || (event_middle_is_down (xevent)
2328                 && (eventType != wxEVT_MIDDLE_UP)));
2329             wxevent.m_rightDown = ((eventType == wxEVT_RIGHT_DOWN)
2330                 || (event_right_is_down (xevent)
2331                 && (eventType != wxEVT_RIGHT_UP)));
2332
2333             wxevent.m_shiftDown = (xevent->xbutton.state & ShiftMask) == ShiftMask;
2334             wxevent.m_controlDown = (xevent->xbutton.state & ControlMask) == ControlMask;
2335             wxevent.m_altDown = (xevent->xbutton.state & Mod3Mask) == Mod3Mask;
2336             wxevent.m_metaDown = (xevent->xbutton.state & Mod1Mask) == Mod1Mask;
2337
2338             wxevent.SetId(win->GetId());
2339             wxevent.SetEventObject(win);
2340
2341             return true;
2342         }
2343     }
2344     return false;
2345 }
2346
2347 bool wxTranslateKeyEvent(wxKeyEvent& wxevent, wxWindow *win,
2348                          Widget WXUNUSED(widget), const XEvent *xevent)
2349 {
2350     switch (xevent->xany.type)
2351     {
2352     case KeyPress:
2353     case KeyRelease:
2354         {
2355             char buf[20];
2356
2357             KeySym keySym;
2358             (void) XLookupString((XKeyEvent *)xevent, buf, 20, &keySym, NULL);
2359             int id = wxCharCodeXToWX (keySym);
2360             // id may be WXK_xxx code - these are outside ASCII range, so we
2361             // can't just use toupper() on id
2362             if (id >= 'a' && id <= 'z')
2363                 id = toupper(id);
2364
2365             if (xevent->xkey.state & ShiftMask)
2366                 wxevent.m_shiftDown = true;
2367             if (xevent->xkey.state & ControlMask)
2368                 wxevent.m_controlDown = true;
2369             if (xevent->xkey.state & Mod3Mask)
2370                 wxevent.m_altDown = true;
2371             if (xevent->xkey.state & Mod1Mask)
2372                 wxevent.m_metaDown = true;
2373             wxevent.SetEventObject(win);
2374             wxevent.m_keyCode = id;
2375             wxevent.SetTimestamp(xevent->xkey.time);
2376
2377             wxevent.m_x = xevent->xbutton.x;
2378             wxevent.m_y = xevent->xbutton.y;
2379
2380             if (id > -1)
2381                 return true;
2382
2383             return false;
2384         }
2385     default:
2386         break;
2387     }
2388     return false;
2389 }
2390
2391 // ----------------------------------------------------------------------------
2392 // Colour stuff
2393 // ----------------------------------------------------------------------------
2394
2395 #define YAllocColor XAllocColor
2396 XColor g_itemColors[5];
2397 int wxComputeColours (Display *display, const wxColour * back, const wxColour * fore)
2398 {
2399     int result;
2400     static XmColorProc colorProc;
2401
2402     result = wxNO_COLORS;
2403
2404     if (back)
2405     {
2406         g_itemColors[0].red = (unsigned short)(((long) back->Red ()) << 8);
2407         g_itemColors[0].green = (unsigned short)(((long) back->Green ()) << 8);
2408         g_itemColors[0].blue = (unsigned short)(((long) back->Blue ()) << 8);
2409         g_itemColors[0].flags = DoRed | DoGreen | DoBlue;
2410         if (colorProc == (XmColorProc) NULL)
2411         {
2412             // Get a ptr to the actual function
2413             colorProc = XmSetColorCalculation ((XmColorProc) NULL);
2414             // And set it back to motif.
2415             XmSetColorCalculation (colorProc);
2416         }
2417         (*colorProc) (&g_itemColors[wxBACK_INDEX],
2418             &g_itemColors[wxFORE_INDEX],
2419             &g_itemColors[wxSELE_INDEX],
2420             &g_itemColors[wxTOPS_INDEX],
2421             &g_itemColors[wxBOTS_INDEX]);
2422         result = wxBACK_COLORS;
2423     }
2424     if (fore)
2425     {
2426         g_itemColors[wxFORE_INDEX].red = (unsigned short)(((long) fore->Red ()) << 8);
2427         g_itemColors[wxFORE_INDEX].green = (unsigned short)(((long) fore->Green ()) << 8);
2428         g_itemColors[wxFORE_INDEX].blue = (unsigned short)(((long) fore->Blue ()) << 8);
2429         g_itemColors[wxFORE_INDEX].flags = DoRed | DoGreen | DoBlue;
2430         if (result == wxNO_COLORS)
2431             result = wxFORE_COLORS;
2432     }
2433
2434     Display *dpy = display;
2435     Colormap cmap = (Colormap) wxTheApp->GetMainColormap((WXDisplay*) dpy);
2436
2437     if (back)
2438     {
2439         /* 5 Colours to allocate */
2440         for (int i = 0; i < 5; i++)
2441             if (!YAllocColor (dpy, cmap, &g_itemColors[i]))
2442                 result = wxNO_COLORS;
2443     }
2444     else if (fore)
2445     {
2446         /* Only 1 colour to allocate */
2447         if (!YAllocColor (dpy, cmap, &g_itemColors[wxFORE_INDEX]))
2448             result = wxNO_COLORS;
2449     }
2450
2451     return result;
2452 }
2453
2454 // Changes the foreground and background colours to be derived from the current
2455 // background colour. To change the foreground colour, you must call
2456 // SetForegroundColour explicitly.
2457 void wxWindow::ChangeBackgroundColour()
2458 {
2459     WXWidget mainWidget = GetMainWidget();
2460     if ( mainWidget )
2461         wxDoChangeBackgroundColour(mainWidget, m_backgroundColour);
2462     if ( m_scrolledWindow && mainWidget != m_scrolledWindow )
2463         wxDoChangeForegroundColour(m_scrolledWindow, m_backgroundColour);
2464 }
2465
2466 void wxWindow::ChangeForegroundColour()
2467 {
2468     WXWidget mainWidget = GetMainWidget();
2469     if ( mainWidget )
2470         wxDoChangeForegroundColour(mainWidget, m_foregroundColour);
2471     if ( m_scrolledWindow && mainWidget != m_scrolledWindow )
2472         wxDoChangeForegroundColour(m_scrolledWindow, m_foregroundColour);
2473 }
2474
2475 bool wxWindow::SetBackgroundColour(const wxColour& col)
2476 {
2477     if ( !wxWindowBase::SetBackgroundColour(col) )
2478         return false;
2479
2480     ChangeBackgroundColour();
2481
2482     return true;
2483 }
2484
2485 bool wxWindow::SetForegroundColour(const wxColour& col)
2486 {
2487     if ( !wxWindowBase::SetForegroundColour(col) )
2488         return false;
2489
2490     ChangeForegroundColour();
2491
2492     return true;
2493 }
2494
2495 void wxWindow::ChangeFont(bool keepOriginalSize)
2496 {
2497     // Note that this causes the widget to be resized back
2498     // to its original size! We therefore have to set the size
2499     // back again. TODO: a better way in Motif?
2500     Widget w = (Widget) GetLabelWidget(); // Usually the main widget
2501     if (w && m_font.Ok())
2502     {
2503         int width, height, width1, height1;
2504         GetSize(& width, & height);
2505
2506         wxDoChangeFont( w, m_font );
2507
2508         GetSize(& width1, & height1);
2509         if (keepOriginalSize && (width != width1 || height != height1))
2510         {
2511             SetSize(wxDefaultCoord, wxDefaultCoord, width, height);
2512         }
2513     }
2514 }
2515
2516 // Post-creation
2517 void wxWindow::PostCreation()
2518 {
2519     ChangeFont();
2520     ChangeForegroundColour();
2521     ChangeBackgroundColour();
2522 }
2523
2524 // Pre-creation
2525 void wxWindow::PreCreation()
2526 {
2527     InheritAttributes();
2528 }
2529
2530 // ----------------------------------------------------------------------------
2531 // global functions
2532 // ----------------------------------------------------------------------------
2533
2534 wxWindow *wxGetActiveWindow()
2535 {
2536     // TODO
2537     wxFAIL_MSG("Not implemented");
2538     return NULL;
2539 }
2540
2541 /* static */
2542 wxWindow *wxWindowBase::GetCapture()
2543 {
2544     return (wxWindow *)g_captureWindow;
2545 }
2546
2547
2548 // Find the wxWindow at the current mouse position, returning the mouse
2549 // position.
2550 wxWindow* wxFindWindowAtPointer(wxPoint& pt)
2551 {
2552     pt = wxGetMousePosition();
2553     return wxFindWindowAtPoint(pt);
2554 }
2555
2556 void wxGetMouseState(int& rootX, int& rootY, unsigned& maskReturn)
2557 {
2558     Display *display = wxGlobalDisplay();
2559     Window rootWindow = RootWindowOfScreen (DefaultScreenOfDisplay(display));
2560     Window rootReturn, childReturn;
2561     int winX, winY;
2562
2563     XQueryPointer (display,
2564                    rootWindow,
2565                    &rootReturn,
2566                    &childReturn,
2567                    &rootX, &rootY, &winX, &winY, &maskReturn);
2568 }
2569
2570 // Get the current mouse position.
2571 wxPoint wxGetMousePosition()
2572 {
2573     int x, y;
2574     unsigned mask;
2575
2576     wxGetMouseState(x, y, mask);
2577     return wxPoint(x, y);
2578 }
2579
2580 wxMouseState wxGetMouseState()
2581 {
2582     wxMouseState ms;
2583     int x, y;
2584     unsigned mask;
2585
2586     wxGetMouseState(x, y, mask);
2587
2588     ms.SetX(x);
2589     ms.SetY(y);
2590
2591     ms.SetLeftDown(mask & Button1Mask);
2592     ms.SetMiddleDown(mask & Button2Mask);
2593     ms.SetRightDown(mask & Button3Mask);
2594
2595     ms.SetControlDown(mask & ControlMask);
2596     ms.SetShiftDown(mask & ShiftMask);
2597     ms.SetAltDown(mask & Mod3Mask);
2598     ms.SetMetaDown(mask & Mod1Mask);
2599
2600     return ms;
2601 }
2602
2603
2604 #if wxMOTIF_NEW_FONT_HANDLING
2605
2606 #include <Xm/XmP.h>
2607
2608 void wxGetTextExtent(const wxWindow* window, const wxString& str,
2609                      int* width, int* height, int* ascent, int* descent)
2610 {
2611     Arg args[2];
2612     int count = 0;
2613     XmRendition rendition = NULL;
2614     XmRenderTable table = NULL;
2615     Widget w = (Widget) window->GetLabelWidget();
2616
2617     XtVaGetValues( w, XmNrenderTable, &table, NULL );
2618     if (table == NULL)
2619         table = XmeGetDefaultRenderTable(w, XmTEXT_RENDER_TABLE);
2620
2621     rendition = XmRenderTableGetRendition( table, "" );
2622     XtSetArg( args[count], XmNfont, 0 ); ++count;
2623     XtSetArg( args[count], XmNfontType, 0 ); ++count;
2624     XmRenditionRetrieve( rendition, args, count );
2625
2626     if (args[1].value == XmFONT_IS_FONTSET)
2627     {
2628         XRectangle ink, logical;
2629         WXFontSet fset = (WXFontSet) args[0].value;
2630
2631         XmbTextExtents( (XFontSet)fset, str.c_str(), str.length(),
2632                         &ink, &logical);
2633
2634         if( width ) *width = logical.width;
2635         if( height ) *height = logical.height;
2636         if( ascent ) *ascent = -logical.y;
2637         if( descent ) *descent = logical.height + logical.y;
2638     }
2639     else
2640     {
2641         int direction, ascent2, descent2;
2642         XCharStruct overall;
2643         XFontStruct* fontStruct;
2644
2645         XmeRenderTableGetDefaultFont( table, &fontStruct );
2646         XTextExtents(fontStruct, (const char*)str.c_str(), str.length(),
2647                      &direction, &ascent2, &descent2, &overall);
2648
2649         if ( width ) *width = overall.width;
2650         if ( height ) *height = ascent2 + descent2;
2651         if ( descent ) *descent = descent2;
2652         if ( ascent ) *ascent = ascent2;
2653     }
2654 }
2655
2656 #else // if !wxMOTIF_NEW_FONT_HANDLING
2657
2658 void wxGetTextExtent(const wxWindow* window, const wxString& str,
2659                      int* width, int* height, int* ascent, int* descent)
2660 {
2661     XmFontList list = NULL;
2662     XmFontContext cxt;
2663     XmFontType type;
2664     Widget w = (Widget) window->GetLabelWidget();
2665
2666     XtVaGetValues( w, XmNfontList, &list, NULL );
2667     XmFontListInitFontContext( &cxt, list );
2668
2669     XmFontListEntry entry = XmFontListNextEntry( cxt );
2670     XmFontListFreeFontContext( cxt );
2671     XtPointer thing = XmFontListEntryGetFont( entry, &type );
2672
2673     if (type == XmFONT_IS_FONTSET)
2674     {
2675         XRectangle ink, logical;
2676
2677         XmbTextExtents( (XFontSet)thing, str.c_str(), str.length(),
2678                         &ink, &logical);
2679
2680         if( width ) *width = logical.width;
2681         if( height ) *height = logical.height;
2682         if( ascent ) *ascent = -logical.y;
2683         if( descent ) *descent = logical.height + logical.y;
2684     }
2685     else
2686     {
2687         int direction, ascent2, descent2;
2688         XCharStruct overall;
2689
2690         XTextExtents( (XFontStruct*)thing, (char*)(const char*)str.c_str(), str.length(),
2691                      &direction, &ascent2, &descent2, &overall);
2692
2693         if ( width ) *width = overall.width;
2694         if ( height ) *height = ascent2 + descent2;
2695         if ( descent ) *descent = descent2;
2696         if ( ascent ) *ascent = ascent2;
2697     }
2698 }
2699
2700 #endif // !wxMOTIF_NEW_FONT_HANDLING
2701
2702 // ----------------------------------------------------------------------------
2703 // wxNoOptimize: switch off size optimization
2704 // ----------------------------------------------------------------------------
2705
2706 int wxNoOptimize::ms_count = 0;