src/motif/window.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        windows.cpp
   3 // Purpose:     wxWindow
   4 // Author:      Julian Smart
   5 // Modified by:
   6 // Created:     17/09/98
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) Julian Smart
   9 // Licence:     wxWindows licence
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 #ifdef __GNUG__
  13 #pragma implementation "window.h"
  14 #endif
  15
  16 #include "wx/setup.h"
  17 #include "wx/menu.h"
  18 #include "wx/dc.h"
  19 #include "wx/dcclient.h"
  20 #include "wx/utils.h"
  21 #include "wx/app.h"
  22 #include "wx/panel.h"
  23 #include "wx/layout.h"
  24 #include "wx/dialog.h"
  25 #include "wx/listbox.h"
  26 #include "wx/button.h"
  27 #include "wx/settings.h"
  28 #include "wx/msgdlg.h"
  29 #include "wx/frame.h"
  30
  31 #include "wx/menuitem.h"
  32 #include "wx/log.h"
  33
  34 #if  wxUSE_DRAG_AND_DROP
  35 #include "wx/dnd.h"
  36 #endif
  37
  38 #include <Xm/Xm.h>
  39
  40 #include <Xm/DrawingA.h>
  41 #include <Xm/ScrolledW.h>
  42 #include <Xm/ScrollBar.h>
  43 #include <Xm/Frame.h>
  44 #include <Xm/Label.h>
  45
  46 #include "wx/motif/private.h"
  47
  48 #include <string.h>
  49
  50 #define SCROLL_MARGIN 4
  51 void wxCanvasRepaintProc (Widget, XtPointer, XmDrawingAreaCallbackStruct * cbs);
  52 void wxCanvasInputEvent (Widget drawingArea, XtPointer data, XmDrawingAreaCallbackStruct * cbs);
  53 void wxCanvasMotionEvent (Widget, XButtonEvent * event);
  54 void wxCanvasEnterLeave (Widget drawingArea, XtPointer clientData, XCrossingEvent * event);
  55 void wxScrollBarCallback(Widget widget, XtPointer clientData,
  56                         XmScaleCallbackStruct *cbs);
  57 void wxPanelItemEventHandler (Widget    wid,
  58                               XtPointer client_data,
  59                               XEvent*   event,
  60                               Boolean *continueToDispatch);
  61
  62 #define event_left_is_down(x) ((x)->xbutton.state & Button1Mask)
  63 #define event_middle_is_down(x) ((x)->xbutton.state & Button2Mask)
  64 #define event_right_is_down(x) ((x)->xbutton.state & Button3Mask)
  65
  66 extern wxList wxPendingDelete;
  67
  68 #if !USE_SHARED_LIBRARY
  69 IMPLEMENT_DYNAMIC_CLASS(wxWindow, wxEvtHandler)
  70
  71 BEGIN_EVENT_TABLE(wxWindow, wxEvtHandler)
  72   EVT_CHAR(wxWindow::OnChar)
  73   EVT_ERASE_BACKGROUND(wxWindow::OnEraseBackground)
  74   EVT_SYS_COLOUR_CHANGED(wxWindow::OnSysColourChanged)
  75   EVT_INIT_DIALOG(wxWindow::OnInitDialog)
  76   EVT_IDLE(wxWindow::OnIdle)
  77 END_EVENT_TABLE()
  78
  79 #endif
  80
  81
  82 // Constructor
  83 wxWindow::wxWindow()
  84 {
  85     // Generic
  86     m_windowId = 0;
  87     m_windowStyle = 0;
  88     m_windowParent = NULL;
  89     m_windowEventHandler = this;
  90     m_windowName = "";
  91     m_windowCursor = *wxSTANDARD_CURSOR;
  92     m_children = new wxList;
  93     m_constraints = NULL;
  94     m_constraintsInvolvedIn = NULL;
  95     m_windowSizer = NULL;
  96     m_sizerParent = NULL;
  97     m_autoLayout = FALSE;
  98     m_windowValidator = NULL;
  99     m_defaultItem = NULL;
 100     m_returnCode = 0;
 101     m_caretWidth = 0; m_caretHeight = 0;
 102     m_caretEnabled = FALSE;
 103     m_caretShown = FALSE;
 104     // m_backgroundColour = wxSystemSettings::GetSystemColour(wxSYS_COLOUR_WINDOW) ; ;
 105     m_backgroundColour = wxSystemSettings::GetSystemColour(wxSYS_COLOUR_3DFACE) ;
 106     m_foregroundColour = *wxBLACK;
 107
 108 #if  wxUSE_DRAG_AND_DROP
 109     m_pDropTarget = NULL;
 110 #endif
 111
 112     /// Motif-specific
 113     m_mainWidget = (WXWidget) 0;
 114     m_button1Pressed = FALSE;
 115     m_button2Pressed = FALSE;
 116     m_button3Pressed = FALSE;
 117     m_winCaptured = FALSE;
 118     m_isShown = TRUE;
 119     m_hScrollBar = (WXWidget) 0;
 120     m_vScrollBar = (WXWidget) 0;
 121     m_borderWidget = (WXWidget) 0;
 122     m_scrolledWindow = (WXWidget) 0;
 123     m_drawingArea = (WXWidget) 0;
 124     m_hScroll = FALSE;
 125     m_vScroll = FALSE;
 126     m_backingPixmap = (WXPixmap) 0;
 127     m_pixmapWidth = 0;
 128     m_pixmapHeight = 0;
 129     m_pixmapOffsetX = 0;
 130     m_pixmapOffsetY = 0;
 131     m_lastTS = 0;
 132     m_lastButton = 0;
 133     m_canAddEventHandler = FALSE;
 134     m_scrollPosX = 0;
 135     m_scrollPosY = 0;
 136     m_paintRegion = (WXRegion) 0;
 137 }
 138
 139 // Destructor
 140 wxWindow::~wxWindow()
 141 {
 142     //// Motif-specific
 143
 144     if (m_paintRegion)
 145         XDestroyRegion ((Region) m_paintRegion);
 146     m_paintRegion = (WXRegion) 0;
 147
 148     if (GetMainWidget())
 149         DetachWidget(GetMainWidget()); // Removes event handlers
 150
 151     // If m_drawingArea, we're a fully-fledged window with drawing area, scrollbars etc. (what wxCanvas used to be)
 152     if (m_drawingArea)
 153     {
 154         // Destroy children before destroying self
 155         DestroyChildren();
 156
 157         if (m_backingPixmap)
 158         XFreePixmap (XtDisplay ((Widget) GetMainWidget()), (Pixmap) m_backingPixmap);
 159
 160         Widget w = (Widget) m_drawingArea;
 161         wxDeleteWindowFromTable(w);
 162
 163         if (w)
 164             XtDestroyWidget(w);
 165         m_mainWidget = (WXWidget) 0;
 166
 167         // Only if we're _really_ a canvas (not a dialog box/panel)
 168         if (m_scrolledWindow)
 169         {
 170             wxDeleteWindowFromTable((Widget) m_scrolledWindow);
 171         }
 172
 173         if (m_hScrollBar)
 174         {
 175             XtUnmanageChild ((Widget) m_hScrollBar);
 176             XtDestroyWidget ((Widget) m_hScrollBar);
 177         }
 178         if (m_vScrollBar)
 179         {
 180             XtUnmanageChild ((Widget) m_vScrollBar);
 181             XtDestroyWidget ((Widget) m_vScrollBar);
 182         }
 183         if (m_scrolledWindow)
 184         {
 185             XtUnmanageChild ((Widget) m_scrolledWindow);
 186             XtDestroyWidget ((Widget) m_scrolledWindow);
 187         }
 188
 189         if (m_borderWidget)
 190         {
 191             XtDestroyWidget ((Widget) m_borderWidget);
 192             m_borderWidget = (WXWidget) 0;
 193         }
 194     }
 195
 196     //// Generic stuff
 197
 198         // Have to delete constraints/sizer FIRST otherwise
 199         // sizers may try to look at deleted windows as they
 200         // delete themselves.
 201 #if wxUSE_CONSTRAINTS
 202     DeleteRelatedConstraints();
 203     if (m_constraints)
 204     {
 205         // This removes any dangling pointers to this window
 206         // in other windows' constraintsInvolvedIn lists.
 207         UnsetConstraints(m_constraints);
 208         delete m_constraints;
 209         m_constraints = NULL;
 210     }
 211     if (m_windowSizer)
 212     {
 213         delete m_windowSizer;
 214         m_windowSizer = NULL;
 215     }
 216     // If this is a child of a sizer, remove self from parent
 217     if (m_sizerParent)
 218         m_sizerParent->RemoveChild((wxWindow *)this);
 219 #endif
 220
 221     if (m_windowParent)
 222         m_windowParent->RemoveChild(this);
 223
 224     DestroyChildren();
 225
 226     // Destroy the window
 227     if (GetMainWidget())
 228     {
 229       wxDeleteWindowFromTable((Widget) GetMainWidget());
 230       XtDestroyWidget((Widget) GetMainWidget());
 231       SetMainWidget((WXWidget) NULL);
 232     }
 233
 234     delete m_children;
 235     m_children = NULL;
 236
 237     // Just in case the window has been Closed, but
 238     // we're then deleting immediately: don't leave
 239     // dangling pointers.
 240     wxPendingDelete.DeleteObject(this);
 241
 242     if ( m_windowValidator )
 243             delete m_windowValidator;
 244 }
 245
 246 // Destroy the window (delayed, if a managed window)
 247 bool wxWindow::Destroy()
 248 {
 249     delete this;
 250     return TRUE;
 251 }
 252
 253 // Constructor
 254 bool wxWindow::Create(wxWindow *parent, wxWindowID id,
 255            const wxPoint& pos,
 256            const wxSize& size,
 257            long style,
 258            const wxString& name)
 259 {
 260     // Generic
 261     m_windowId = 0;
 262     m_windowStyle = 0;
 263     m_windowParent = NULL;
 264     m_windowEventHandler = this;
 265     m_windowName = "";
 266     m_windowCursor = *wxSTANDARD_CURSOR;
 267     m_constraints = NULL;
 268     m_constraintsInvolvedIn = NULL;
 269     m_windowSizer = NULL;
 270     m_sizerParent = NULL;
 271     m_autoLayout = FALSE;
 272     m_windowValidator = NULL;
 273 #if wxUSE_DRAG_AND_DROP
 274     m_pDropTarget = NULL;
 275 #endif
 276     m_caretWidth = 0; m_caretHeight = 0;
 277     m_caretEnabled = FALSE;
 278     m_caretShown = FALSE;
 279     m_minSizeX = -1;
 280     m_minSizeY = -1;
 281     m_maxSizeX = -1;
 282     m_maxSizeY = -1;
 283     m_defaultItem = NULL;
 284     m_windowParent = NULL;
 285
 286     // Motif-specific
 287     m_canAddEventHandler = FALSE;
 288     m_mainWidget = (WXWidget) 0;
 289     m_button1Pressed = FALSE;
 290     m_button2Pressed = FALSE;
 291     m_button3Pressed = FALSE;
 292     m_winCaptured = FALSE;
 293     m_isShown = TRUE;
 294     m_hScrollBar = (WXWidget) 0;
 295     m_vScrollBar = (WXWidget) 0;
 296     m_borderWidget = (WXWidget) 0;
 297     m_scrolledWindow = (WXWidget) 0;
 298     m_drawingArea = (WXWidget) 0;
 299     m_hScroll = FALSE;
 300     m_vScroll = FALSE;
 301     m_backingPixmap = (WXPixmap) 0;
 302     m_pixmapWidth = 0;
 303     m_pixmapHeight = 0;
 304     m_pixmapOffsetX = 0;
 305     m_pixmapOffsetY = 0;
 306     m_scrollPosX = 0;
 307     m_scrollPosY = 0;
 308     m_paintRegion = (WXRegion) 0;
 309
 310     if (!parent)
 311         return FALSE;
 312
 313     if (parent) parent->AddChild(this);
 314
 315     m_returnCode = 0;
 316
 317     SetName(name);
 318
 319     if ( id == -1 )
 320         m_windowId = (int)NewControlId();
 321     else
 322         m_windowId = id;
 323
 324     // m_backgroundColour = wxSystemSettings::GetSystemColour(wxSYS_COLOUR_WINDOW) ; ;
 325     m_backgroundColour = wxSystemSettings::GetSystemColour(wxSYS_COLOUR_3DFACE) ;
 326     m_foregroundColour = *wxBLACK;
 327
 328     m_windowStyle = style;
 329
 330     if ( id == -1 )
 331         m_windowId = (int)NewControlId();
 332     else
 333         m_windowId = id;
 334
 335     //// TODO: we should probably optimize by only creating a
 336     //// a drawing area if we have one or more scrollbars (wxVSCROLL/wxHSCROLL).
 337     //// But for now, let's simplify things by always creating the
 338     //// drawing area, since otherwise the translations are different.
 339
 340   // New translations for getting mouse motion feedback
 341   String translations =
 342   "<Btn1Motion>: wxCanvasMotionEvent() DrawingAreaInput() ManagerGadgetButtonMotion()\n\
 343      <Btn2Motion>: wxCanvasMotionEvent() DrawingAreaInput() ManagerGadgetButtonMotion()\n\
 344      <Btn3Motion>: wxCanvasMotionEvent() DrawingAreaInput() ManagerGadgetButtonMotion()\n\
 345      <BtnMotion>: wxCanvasMotionEvent() DrawingAreaInput() ManagerGadgetButtonMotion()\n\
 346      <Btn1Down>: DrawingAreaInput() ManagerGadgetArm()\n\
 347      <Btn2Down>: DrawingAreaInput() ManagerGadgetArm()\n\
 348      <Btn3Down>: DrawingAreaInput() ManagerGadgetArm()\n\
 349      <Btn1Up>: DrawingAreaInput() ManagerGadgetActivate()\n\
 350      <Btn2Up>: DrawingAreaInput() ManagerGadgetActivate()\n\
 351      <Btn3Up>: DrawingAreaInput() ManagerGadgetActivate()\n\
 352      <Motion>: wxCanvasMotionEvent() DrawingAreaInput()\n\
 353      <EnterWindow>: wxCanvasMotionEvent() DrawingAreaInput()\n\
 354      <LeaveWindow>: wxCanvasMotionEvent() DrawingAreaInput()\n\
 355      <Key>: DrawingAreaInput()";
 356
 357   XtActionsRec actions[1];
 358   actions[0].string = "wxCanvasMotionEvent";
 359   actions[0].proc = (XtActionProc) wxCanvasMotionEvent;
 360   XtAppAddActions ((XtAppContext) wxTheApp->GetAppContext(), actions, 1);
 361
 362   Widget parentWidget = (Widget) parent->GetClientWidget();
 363   if (style & wxBORDER)
 364     m_borderWidget = (WXWidget) XtVaCreateManagedWidget ("canvasBorder",
 365                                       xmFrameWidgetClass, parentWidget,
 366                                             XmNshadowType, XmSHADOW_IN,
 367                                             NULL);
 368
 369   m_scrolledWindow = (WXWidget) XtVaCreateManagedWidget ("scrolledWindow",
 370                                             xmScrolledWindowWidgetClass, m_borderWidget ? (Widget) m_borderWidget : parentWidget,
 371                                   XmNspacing, 0,
 372                                   XmNscrollingPolicy, XmAPPLICATION_DEFINED,
 373                                             NULL);
 374
 375   XtTranslations ptr;
 376   m_drawingArea = (WXWidget) XtVaCreateWidget ((char*) (const char*) name,
 377                                    xmDrawingAreaWidgetClass, (Widget) m_scrolledWindow,
 378                                          XmNunitType, XmPIXELS,
 379 //                                       XmNresizePolicy, XmRESIZE_ANY,
 380                                          XmNresizePolicy, XmRESIZE_NONE,
 381                                          XmNmarginHeight, 0,
 382                                          XmNmarginWidth, 0,
 383               XmNtranslations, ptr = XtParseTranslationTable (translations),
 384                                          NULL);
 385   /*
 386   if (GetWindowStyleFlag() & wxOVERRIDE_KEY_TRANSLATIONS)
 387   {
 388     XtFree ((char *) ptr);
 389     ptr = XtParseTranslationTable ("<Key>: DrawingAreaInput()");
 390     XtOverrideTranslations ((Widget) m_drawingArea, ptr);
 391     XtFree ((char *) ptr);
 392   }
 393   */
 394
 395   wxAddWindowToTable((Widget) m_drawingArea, this);
 396   wxAddWindowToTable((Widget) m_scrolledWindow, this);
 397
 398   /*
 399    * This order is very important in Motif 1.2.1
 400    *
 401    */
 402
 403   XtRealizeWidget ((Widget) m_scrolledWindow);
 404   XtRealizeWidget ((Widget) m_drawingArea);
 405   XtManageChild ((Widget) m_drawingArea);
 406
 407   XtOverrideTranslations ((Widget) m_drawingArea,
 408                    ptr = XtParseTranslationTable ("<Configure>: resize()"));
 409   XtFree ((char *) ptr);
 410
 411   XtAddCallback ((Widget) m_drawingArea, XmNexposeCallback, (XtCallbackProc) wxCanvasRepaintProc, (XtPointer) this);
 412   XtAddCallback ((Widget) m_drawingArea, XmNinputCallback, (XtCallbackProc) wxCanvasInputEvent, (XtPointer) this);
 413
 414   /* TODO?
 415   display = XtDisplay (scrolledWindow);
 416   xwindow = XtWindow (drawingArea);
 417   */
 418
 419   XtAddEventHandler ((Widget) m_drawingArea, PointerMotionHintMask | EnterWindowMask | LeaveWindowMask | FocusChangeMask,
 420     False, (XtEventHandler) wxCanvasEnterLeave, (XtPointer) this);
 421
 422   // Add scrollbars if required
 423   if (m_windowStyle & wxHSCROLL)
 424   {
 425       Widget hScrollBar = XtVaCreateManagedWidget ("hsb",
 426                                      xmScrollBarWidgetClass, (Widget) m_scrolledWindow,
 427                                                 XmNorientation, XmHORIZONTAL,
 428                                                 NULL);
 429       //          XtAddCallback (hScrollBar, XmNvalueChangedCallback, (XtCallbackProc) wxScrollBarCallback, (XtPointer) XmHORIZONTAL);
 430           XtAddCallback (hScrollBar, XmNdragCallback, (XtCallbackProc) wxScrollBarCallback, (XtPointer) XmHORIZONTAL);
 431           XtAddCallback (hScrollBar, XmNincrementCallback, (XtCallbackProc) wxScrollBarCallback, (XtPointer) XmHORIZONTAL);
 432           XtAddCallback (hScrollBar, XmNdecrementCallback, (XtCallbackProc) wxScrollBarCallback, (XtPointer) XmHORIZONTAL);
 433           XtAddCallback (hScrollBar, XmNpageIncrementCallback, (XtCallbackProc) wxScrollBarCallback, (XtPointer) XmHORIZONTAL);
 434           XtAddCallback (hScrollBar, XmNpageDecrementCallback, (XtCallbackProc) wxScrollBarCallback, (XtPointer) XmHORIZONTAL);
 435           XtAddCallback (hScrollBar, XmNtoTopCallback, (XtCallbackProc) wxScrollBarCallback, (XtPointer) XmHORIZONTAL);
 436           XtAddCallback (hScrollBar, XmNtoBottomCallback, (XtCallbackProc) wxScrollBarCallback, (XtPointer) XmHORIZONTAL);
 437
 438       XtVaSetValues (hScrollBar,
 439                      XmNincrement, 1,
 440                      XmNvalue, 0,
 441                      NULL);
 442
 443       m_hScrollBar = (WXWidget) hScrollBar;
 444       m_hScroll = TRUE;
 445   }
 446   if (m_windowStyle & wxVSCROLL)
 447   {
 448       Widget vScrollBar = XtVaCreateManagedWidget ("vsb",
 449                                      xmScrollBarWidgetClass, (Widget) m_scrolledWindow,
 450                                                 XmNorientation, XmVERTICAL,
 451                                                 NULL);
 452       //          XtAddCallback (vScrollBar, XmNvalueChangedCallback, (XtCallbackProc) wxScrollBarCallback, (XtPointer) XmVERTICAL);
 453           XtAddCallback (vScrollBar, XmNdragCallback, (XtCallbackProc) wxScrollBarCallback, (XtPointer) XmVERTICAL);
 454           XtAddCallback (vScrollBar, XmNincrementCallback, (XtCallbackProc) wxScrollBarCallback, (XtPointer) XmVERTICAL);
 455           XtAddCallback (vScrollBar, XmNdecrementCallback, (XtCallbackProc) wxScrollBarCallback, (XtPointer) XmVERTICAL);
 456           XtAddCallback (vScrollBar, XmNpageIncrementCallback, (XtCallbackProc) wxScrollBarCallback, (XtPointer) XmVERTICAL);
 457           XtAddCallback (vScrollBar, XmNpageDecrementCallback, (XtCallbackProc) wxScrollBarCallback, (XtPointer) XmVERTICAL);
 458           XtAddCallback (vScrollBar, XmNtoTopCallback, (XtCallbackProc) wxScrollBarCallback, (XtPointer) XmVERTICAL);
 459           XtAddCallback (vScrollBar, XmNtoBottomCallback, (XtCallbackProc) wxScrollBarCallback, (XtPointer) XmVERTICAL);
 460
 461       XtVaSetValues (vScrollBar,
 462                      XmNincrement, 1,
 463                      XmNvalue, 0,
 464                      NULL);
 465
 466       m_vScrollBar = (WXWidget) vScrollBar;
 467       m_vScroll = TRUE;
 468   }
 469
 470   if (m_hScrollBar || m_vScrollBar)
 471     XmScrolledWindowSetAreas ((Widget) m_scrolledWindow, (Widget) m_hScrollBar, (Widget) m_vScrollBar, (Widget) m_drawingArea);
 472
 473   if (m_hScrollBar)
 474         XtRealizeWidget ((Widget) m_hScrollBar);
 475   if (m_vScrollBar)
 476         XtRealizeWidget ((Widget) m_vScrollBar);
 477
 478   // Without this, the cursor may not be restored properly
 479   // (e.g. in splitter sample).
 480   SetCursor(*wxSTANDARD_CURSOR);
 481   SetSize(pos.x, pos.y, size.x, size.y);
 482
 483   return TRUE;
 484 }
 485
 486 void wxWindow::SetFocus()
 487 {
 488   XmProcessTraversal((Widget) GetMainWidget(), XmTRAVERSE_CURRENT);
 489   XmProcessTraversal((Widget) GetMainWidget(), XmTRAVERSE_CURRENT);
 490 }
 491
 492 void wxWindow::Enable(bool enable)
 493 {
 494   if (GetMainWidget())
 495   {
 496     XtSetSensitive((Widget) GetMainWidget(), enable);
 497     XmUpdateDisplay((Widget) GetMainWidget());
 498   }
 499 }
 500
 501 void wxWindow::CaptureMouse()
 502 {
 503   if (m_winCaptured)
 504     return;
 505
 506   if (GetMainWidget())
 507     XtAddGrab((Widget) GetMainWidget(), TRUE, FALSE);
 508
 509   m_winCaptured = TRUE;
 510 }
 511
 512 void wxWindow::ReleaseMouse()
 513 {
 514   if (!m_winCaptured)
 515     return;
 516
 517   if (GetMainWidget())
 518     XtRemoveGrab((Widget) GetMainWidget());
 519   m_winCaptured = FALSE;
 520 }
 521
 522 // Push/pop event handler (i.e. allow a chain of event handlers
 523 // be searched)
 524 void wxWindow::PushEventHandler(wxEvtHandler *handler)
 525 {
 526         handler->SetNextHandler(GetEventHandler());
 527         SetEventHandler(handler);
 528 }
 529
 530 wxEvtHandler *wxWindow::PopEventHandler(bool deleteHandler)
 531 {
 532         if ( GetEventHandler() )
 533         {
 534                 wxEvtHandler *handlerA = GetEventHandler();
 535                 wxEvtHandler *handlerB = handlerA->GetNextHandler();
 536                 handlerA->SetNextHandler(NULL);
 537                 SetEventHandler(handlerB);
 538                 if ( deleteHandler )
 539                 {
 540                         delete handlerA;
 541                         return NULL;
 542                 }
 543                 else
 544                         return handlerA;
 545         }
 546         else
 547                 return NULL;
 548 }
 549
 550 #if    wxUSE_DRAG_AND_DROP
 551
 552 void wxWindow::SetDropTarget(wxDropTarget *pDropTarget)
 553 {
 554   if ( m_pDropTarget != 0 ) {
 555     delete m_pDropTarget;
 556   }
 557
 558   m_pDropTarget = pDropTarget;
 559   if ( m_pDropTarget != 0 )
 560   {
 561     // TODO
 562   }
 563 }
 564
 565 #endif
 566
 567 // Old style file-manager drag&drop
 568 void wxWindow::DragAcceptFiles(bool accept)
 569 {
 570     // TODO
 571 }
 572
 573 // Get total size
 574 void wxWindow::GetSize(int *x, int *y) const
 575 {
 576   if (m_drawingArea)
 577   {
 578     CanvasGetSize(x, y);
 579     return;
 580   }
 581
 582   Widget widget = (Widget) GetTopWidget();
 583   Dimension xx, yy;
 584   XtVaGetValues(widget, XmNwidth, &xx, XmNheight, &yy, NULL);
 585   *x = xx; *y = yy;
 586 }
 587
 588 void wxWindow::GetPosition(int *x, int *y) const
 589 {
 590     if (m_drawingArea)
 591     {
 592         CanvasGetPosition(x, y);
 593         return;
 594     }
 595     Widget widget = (Widget) GetTopWidget();
 596     Position xx, yy;
 597     XtVaGetValues(widget, XmNx, &xx, XmNy, &yy, NULL);
 598
 599     // We may be faking the client origin.
 600     // So a window that's really at (0, 30) may appear
 601     // (to wxWin apps) to be at (0, 0).
 602     if (GetParent())
 603     {
 604         wxPoint pt(GetParent()->GetClientAreaOrigin());
 605         xx -= pt.x;
 606         yy -= pt.y;
 607     }
 608
 609     *x = xx; *y = yy;
 610 }
 611
 612 void wxWindow::ScreenToClient(int *x, int *y) const
 613 {
 614   Widget widget = (Widget) GetClientWidget();
 615   Display *display = XtDisplay((Widget) GetMainWidget());
 616   Window rootWindow = RootWindowOfScreen(XtScreen(widget));
 617   Window thisWindow = XtWindow(widget);
 618
 619   Window childWindow;
 620   int xx = *x;
 621   int yy = *y;
 622   XTranslateCoordinates(display, rootWindow, thisWindow, xx, yy, x, y, &childWindow);
 623 }
 624
 625 void wxWindow::ClientToScreen(int *x, int *y) const
 626 {
 627   Widget widget = (Widget) GetClientWidget();
 628   Display *display = XtDisplay(widget);
 629   Window rootWindow = RootWindowOfScreen(XtScreen(widget));
 630   Window thisWindow = XtWindow(widget);
 631
 632   Window childWindow;
 633   int xx = *x;
 634   int yy = *y;
 635   XTranslateCoordinates(display, thisWindow, rootWindow, xx, yy, x, y, &childWindow);
 636 }
 637
 638 void wxWindow::SetCursor(const wxCursor& cursor)
 639 {
 640   m_windowCursor = cursor;
 641   if (m_windowCursor.Ok())
 642   {
 643     WXDisplay *dpy = GetXDisplay();
 644     WXCursor x_cursor = ((wxCursor&)cursor).GetXCursor(dpy);
 645
 646     Widget w = (Widget) GetMainWidget();
 647     Window win = XtWindow(w);
 648     XDefineCursor((Display*) dpy, win, (Cursor) x_cursor);
 649   }
 650 }
 651
 652
 653 // Get size *available for subwindows* i.e. excluding menu bar etc.
 654 void wxWindow::GetClientSize(int *x, int *y) const
 655 {
 656   Widget widget = (Widget) GetClientWidget();
 657   Dimension xx, yy;
 658   XtVaGetValues(widget, XmNwidth, &xx, XmNheight, &yy, NULL);
 659   *x = xx; *y = yy;
 660 }
 661
 662 void wxWindow::SetSize(int x, int y, int width, int height, int sizeFlags)
 663 {
 664   if (m_drawingArea)
 665   {
 666     CanvasSetSize(x, y, width, height, sizeFlags);
 667     return;
 668   }
 669   Widget widget = (Widget) GetTopWidget();
 670   if (!widget)
 671     return;
 672
 673   bool managed = XtIsManaged( widget );
 674   if (managed)
 675     XtUnmanageChild(widget);
 676
 677   int xx = x; int yy = y;
 678   AdjustForParentClientOrigin(xx, yy, sizeFlags);
 679
 680   if (x > -1 || (sizeFlags & wxSIZE_ALLOW_MINUS_ONE))
 681     XtVaSetValues(widget, XmNx, xx, NULL);
 682   if (y > -1 || (sizeFlags & wxSIZE_ALLOW_MINUS_ONE))
 683     XtVaSetValues(widget, XmNy, yy, NULL);
 684   if (width > -1)
 685     XtVaSetValues(widget, XmNwidth, width, NULL);
 686   if (height > -1)
 687     XtVaSetValues(widget, XmNheight, height, NULL);
 688
 689   if (managed)
 690     XtManageChild(widget);
 691
 692   wxSizeEvent sizeEvent(wxSize(width, height), GetId());
 693   sizeEvent.SetEventObject(this);
 694
 695   GetEventHandler()->ProcessEvent(sizeEvent);
 696 }
 697
 698 void wxWindow::SetClientSize(int width, int height)
 699 {
 700   if (m_drawingArea)
 701   {
 702     CanvasSetClientSize(width, height);
 703     return;
 704   }
 705
 706   Widget widget = (Widget) GetTopWidget();
 707
 708   if (width > -1)
 709     XtVaSetValues(widget, XmNwidth, width, NULL);
 710   if (height > -1)
 711     XtVaSetValues(widget, XmNheight, height, NULL);
 712
 713   wxSizeEvent sizeEvent(wxSize(width, height), GetId());
 714   sizeEvent.SetEventObject(this);
 715
 716   GetEventHandler()->ProcessEvent(sizeEvent);
 717 }
 718
 719 // For implementation purposes - sometimes decorations make the client area
 720 // smaller
 721 wxPoint wxWindow::GetClientAreaOrigin() const
 722 {
 723     return wxPoint(0, 0);
 724 }
 725
 726 // Makes an adjustment to the window position (for example, a frame that has
 727 // a toolbar that it manages itself).
 728 void wxWindow::AdjustForParentClientOrigin(int& x, int& y, int sizeFlags)
 729 {
 730     if (((sizeFlags & wxSIZE_NO_ADJUSTMENTS) == 0) && GetParent())
 731     {
 732         wxPoint pt(GetParent()->GetClientAreaOrigin());
 733         x += pt.x; y += pt.y;
 734     }
 735 }
 736
 737 bool wxWindow::Show(bool show)
 738 {
 739     if (show)
 740     {
 741        if (m_borderWidget || m_scrolledWindow)
 742        {
 743            XtMapWidget(m_borderWidget ? (Widget) m_borderWidget : (Widget) m_scrolledWindow);
 744        }
 745        else
 746        {
 747            XtMapWidget((Widget) GetTopWidget());
 748        }
 749     }
 750     else
 751     {
 752        if (m_borderWidget || m_scrolledWindow)
 753        {
 754            XtUnmapWidget(m_borderWidget ? (Widget) m_borderWidget : (Widget) m_scrolledWindow);
 755        }
 756        else
 757        {
 758            XtUnmapWidget((Widget) GetTopWidget());
 759        }
 760     }
 761
 762   /*
 763     Window xwin = (Window) GetXWindow();
 764     Display *xdisp = (Display*) GetXDisplay();
 765     if (show)
 766         XMapWindow(xdisp, xwin);
 767     else
 768         XUnmapWindow(xdisp, xwin);
 769    */
 770
 771     m_isShown = show;
 772
 773     return TRUE;
 774 }
 775
 776 bool wxWindow::IsShown() const
 777 {
 778     return m_isShown;
 779 }
 780
 781 int wxWindow::GetCharHeight() const
 782 {
 783   if (!m_windowFont.Ok())
 784     return 0;
 785
 786   WXFontStructPtr pFontStruct = m_windowFont.GetFontStruct(1.0, GetXDisplay());
 787
 788   int direction, ascent, descent;
 789   XCharStruct overall;
 790   XTextExtents ((XFontStruct*) pFontStruct, "x", 1, &direction, &ascent,
 791         &descent, &overall);
 792 //  return (overall.ascent + overall.descent);
 793   return (ascent + descent);
 794 }
 795
 796 int wxWindow::GetCharWidth() const
 797 {
 798   if (!m_windowFont.Ok())
 799     return 0;
 800
 801   WXFontStructPtr pFontStruct = m_windowFont.GetFontStruct(1.0, GetXDisplay());
 802
 803   int direction, ascent, descent;
 804   XCharStruct overall;
 805   XTextExtents ((XFontStruct*) pFontStruct, "x", 1, &direction, &ascent,
 806         &descent, &overall);
 807   return overall.width;
 808 }
 809
 810 /* Helper function for 16-bit fonts */
 811 static int str16len(const char *s)
 812 {
 813   int count = 0;
 814
 815   while (s[0] && s[1]) {
 816     count++;
 817     s += 2;
 818   }
 819
 820   return count;
 821 }
 822
 823 void wxWindow::GetTextExtent(const wxString& string, int *x, int *y,
 824                            int *descent, int *externalLeading, const wxFont *theFont, bool use16) const
 825 {
 826   wxFont *fontToUse = (wxFont *)theFont;
 827   if (!fontToUse)
 828     fontToUse = (wxFont *) & m_windowFont;
 829
 830   if (!fontToUse->Ok())
 831     return;
 832
 833   WXFontStructPtr pFontStruct = theFont->GetFontStruct(1.0, GetXDisplay());
 834
 835   int direction, ascent, descent2;
 836   XCharStruct overall;
 837   int slen;
 838
 839   if (use16) slen = str16len(string); else slen = strlen(string);
 840
 841   if (use16)
 842     XTextExtents16((XFontStruct*) pFontStruct, (XChar2b *) (char*) (const char*) string, slen, &direction,
 843            &ascent, &descent2, &overall);
 844   else
 845      XTextExtents((XFontStruct*) pFontStruct, (char*) (const char*) string, slen, &direction,
 846          &ascent, &descent2, &overall);
 847
 848   *x = (overall.width);
 849   *y = (ascent + descent2);
 850   if (descent)
 851     *descent = descent2;
 852   if (externalLeading)
 853     *externalLeading = 0;
 854 }
 855
 856 void wxWindow::Refresh(bool eraseBack, const wxRectangle *rect)
 857 {
 858     Display *display = XtDisplay((Widget) GetMainWidget());
 859     Window thisWindow = XtWindow((Widget) GetMainWidget());
 860
 861     XExposeEvent dummyEvent;
 862     int width, height;
 863     GetSize(&width, &height);
 864
 865     dummyEvent.type = Expose;
 866     dummyEvent.display = display;
 867     dummyEvent.send_event = True;
 868     dummyEvent.window = thisWindow;
 869     if (rect)
 870     {
 871       dummyEvent.x = rect->x;
 872       dummyEvent.y = rect->y;
 873       dummyEvent.width = rect->width;
 874       dummyEvent.height = rect->height;
 875     }
 876     else
 877     {
 878       dummyEvent.x = 0;
 879       dummyEvent.y = 0;
 880       dummyEvent.width = width;
 881       dummyEvent.height = height;
 882     }
 883     dummyEvent.count = 0;
 884
 885     if (eraseBack)
 886     {
 887         wxClientDC dc(this);
 888         wxBrush backgroundBrush(GetBackgroundColour(), wxSOLID);
 889         dc.SetBackground(backgroundBrush);
 890         dc.Clear();
 891     }
 892
 893     XSendEvent(display, thisWindow, False, ExposureMask, (XEvent *)&dummyEvent);
 894 }
 895
 896 // Responds to colour changes: passes event on to children.
 897 void wxWindow::OnSysColourChanged(wxSysColourChangedEvent& event)
 898 {
 899     wxNode *node = GetChildren()->First();
 900     while ( node )
 901     {
 902         // Only propagate to non-top-level windows
 903         wxWindow *win = (wxWindow *)node->Data();
 904         if ( win->GetParent() )
 905         {
 906             wxSysColourChangedEvent event2;
 907             event.m_eventObject = win;
 908             win->GetEventHandler()->ProcessEvent(event2);
 909         }
 910
 911         node = node->Next();
 912     }
 913 }
 914
 915 // This can be called by the app (or wxWindows) to do default processing for the current
 916 // event. Save message/event info in wxWindow so they can be used in this function.
 917 long wxWindow::Default()
 918 {
 919     // TODO
 920     return 0;
 921 }
 922
 923 void wxWindow::InitDialog()
 924 {
 925   wxInitDialogEvent event(GetId());
 926   event.SetEventObject( this );
 927   GetEventHandler()->ProcessEvent(event);
 928 }
 929
 930 // Default init dialog behaviour is to transfer data to window
 931 void wxWindow::OnInitDialog(wxInitDialogEvent& event)
 932 {
 933   TransferDataToWindow();
 934 }
 935
 936 // Caret manipulation
 937 void wxWindow::CreateCaret(int w, int h)
 938 {
 939   m_caretWidth = w;
 940   m_caretHeight = h;
 941   m_caretEnabled = TRUE;
 942 }
 943
 944 void wxWindow::CreateCaret(const wxBitmap *WXUNUSED(bitmap))
 945 {
 946     // TODO
 947 }
 948
 949 void wxWindow::ShowCaret(bool show)
 950 {
 951     // TODO
 952 }
 953
 954 void wxWindow::DestroyCaret()
 955 {
 956     // TODO
 957     m_caretEnabled = FALSE;
 958 }
 959
 960 void wxWindow::SetCaretPos(int x, int y)
 961 {
 962     // TODO
 963 }
 964
 965 void wxWindow::GetCaretPos(int *x, int *y) const
 966 {
 967     // TODO
 968 }
 969
 970 wxWindow *wxGetActiveWindow()
 971 {
 972     // TODO
 973     return NULL;
 974 }
 975
 976 void wxWindow::SetSizeHints(int minW, int minH, int maxW, int maxH, int incW, int incH)
 977 {
 978     m_minSizeX = minW;
 979     m_minSizeY = minH;
 980     m_maxSizeX = maxW;
 981     m_maxSizeY = maxH;
 982
 983     if (!this->IsKindOf(CLASSINFO(wxFrame)))
 984       return;
 985
 986     wxFrame *frame = (wxFrame *)this;
 987     Widget widget = (Widget) frame->GetShellWidget();
 988
 989     if (minW > -1)
 990       XtVaSetValues(widget, XmNminWidth, minW, NULL);
 991     if (minH > -1)
 992       XtVaSetValues(widget, XmNminHeight, minH, NULL);
 993     if (maxW > -1)
 994       XtVaSetValues(widget, XmNmaxWidth, maxW, NULL);
 995     if (maxH > -1)
 996       XtVaSetValues(widget, XmNmaxHeight, maxH, NULL);
 997     if (incW > -1)
 998       XtVaSetValues(widget, XmNwidthInc, incW, NULL);
 999     if (incH > -1)
1000       XtVaSetValues(widget, XmNheightInc, incH, NULL);
1001 }
1002
1003 void wxWindow::Centre(int direction)
1004 {
1005   int x, y, width, height, panel_width, panel_height, new_x, new_y;
1006
1007   wxWindow *father = (wxWindow *)GetParent();
1008   if (!father)
1009     return;
1010
1011   father->GetClientSize(&panel_width, &panel_height);
1012   GetSize(&width, &height);
1013   GetPosition(&x, &y);
1014
1015   new_x = -1;
1016   new_y = -1;
1017
1018   if (direction & wxHORIZONTAL)
1019     new_x = (int)((panel_width - width)/2);
1020
1021   if (direction & wxVERTICAL)
1022     new_y = (int)((panel_height - height)/2);
1023
1024   SetSize(new_x, new_y, -1, -1);
1025
1026 }
1027
1028 // Coordinates relative to the window
1029 void wxWindow::WarpPointer (int x, int y)
1030 {
1031   XWarpPointer (XtDisplay((Widget) GetClientWidget()), None, XtWindow((Widget) GetClientWidget()), 0, 0, 0, 0, x, y);
1032 }
1033
1034 void wxWindow::OnEraseBackground(wxEraseEvent& event)
1035 {
1036     // TODO
1037     Default();
1038 }
1039
1040 int wxWindow::GetScrollPos(int orient) const
1041 {
1042     if (orient == wxHORIZONTAL)
1043         return m_scrollPosX;
1044     else
1045         return m_scrollPosY;
1046 /*
1047         Widget scrollBar = (Widget) ((orient == wxHORIZONTAL) ? m_hScrollBar : m_vScrollBar);
1048         if (scrollBar)
1049         {
1050         int pos;
1051         XtVaGetValues(scrollBar,
1052             XmNvalue, &pos, NULL);
1053         return pos;
1054     }
1055     else
1056         return 0;
1057 */
1058 }
1059
1060 // This now returns the whole range, not just the number
1061 // of positions that we can scroll.
1062 int wxWindow::GetScrollRange(int orient) const
1063 {
1064         Widget scrollBar = (Widget) ((orient == wxHORIZONTAL) ? m_hScrollBar : m_vScrollBar);
1065         if (scrollBar)
1066         {
1067         int range;
1068         XtVaGetValues(scrollBar,
1069             XmNmaximum, &range, NULL);
1070         return range;
1071     }
1072     else
1073         return 0;
1074 }
1075
1076 int wxWindow::GetScrollThumb(int orient) const
1077 {
1078         Widget scrollBar = (Widget) ((orient == wxHORIZONTAL) ? m_hScrollBar : m_vScrollBar);
1079         if (scrollBar)
1080         {
1081         int thumb;
1082         XtVaGetValues(scrollBar,
1083             XmNsliderSize, &thumb, NULL);
1084         return thumb;
1085     }
1086     else
1087         return 0;
1088 }
1089
1090 void wxWindow::SetScrollPos(int orient, int pos, bool WXUNUSED(refresh))
1091 {
1092         Widget scrollBar = (Widget) ((orient == wxHORIZONTAL) ? m_hScrollBar : m_vScrollBar);
1093         if (scrollBar)
1094         {
1095                 XtVaSetValues (scrollBar,
1096                                 XmNvalue, pos,
1097                                 NULL);
1098         }
1099         if (orient == wxHORIZONTAL)
1100           m_scrollPosX = pos;
1101         else
1102           m_scrollPosY = pos;
1103
1104 }
1105
1106 // New function that will replace some of the above.
1107 void wxWindow::SetScrollbar(int orient, int pos, int thumbVisible,
1108     int range, bool WXUNUSED(refresh))
1109 {
1110     Widget scrollBar = (Widget) ((orient == wxHORIZONTAL) ? m_hScrollBar : m_vScrollBar );
1111     if (!scrollBar)
1112         return;
1113
1114     if (range == 0)
1115       range = 1;
1116     if (thumbVisible == 0)
1117       thumbVisible = 1;
1118
1119     XtVaSetValues(scrollBar,
1120          XmNvalue, pos,
1121          XmNminimum, 0,
1122          XmNmaximum, range,
1123          XmNsliderSize, thumbVisible,
1124          NULL);
1125
1126     if (orient == wxHORIZONTAL)
1127         m_scrollPosX = pos;
1128     else
1129         m_scrollPosY = pos;
1130 }
1131
1132 // Does a physical scroll
1133 void wxWindow::ScrollWindow(int dx, int dy, const wxRectangle *rect)
1134 {
1135 //  cerr << "Scrolling. delta = " << dx << ", " << dy << endl;
1136   int x, y, w, h;
1137   if (rect)
1138   {
1139     // Use specified rectangle
1140     x = rect->x; y = rect->y; w = rect->width; h = rect->height;
1141   }
1142   else
1143   {
1144     // Use whole client area
1145     x = 0; y = 0;
1146     GetClientSize(& w, & h);
1147   }
1148
1149   int x1 = (dx >= 0) ? x : x - dx ;
1150   int y1 = (dy >= 0) ? y : y - dy;
1151   int w1 = w - abs(dx);
1152   int h1 = h - abs(dy);
1153   int x2 = (dx >= 0) ? x + dx : x;
1154   int y2 = (dy >= 0) ? y + dy : y;
1155
1156   wxClientDC dc(this);
1157
1158   dc.SetLogicalFunction (wxCOPY);
1159
1160   Widget widget = (Widget) GetMainWidget();
1161   Window window = XtWindow(widget);
1162   Display* display = XtDisplay(widget);
1163
1164   XCopyArea(display, window,
1165     window, (GC) dc.GetGC(),
1166     x1, y1,
1167     w1, h1,
1168     x2, y2);
1169
1170   dc.SetAutoSetting(TRUE);
1171   wxBrush brush(GetBackgroundColour(), wxSOLID);
1172   dc.SetBrush(brush); // ??
1173
1174   // We'll add rectangles to the list of update rectangles
1175   // according to which bits we've exposed.
1176   wxList updateRects;
1177
1178   if (dx > 0)
1179   {
1180     wxRect *rect = new wxRect;
1181     rect->x = x;
1182     rect->y = y;
1183     rect->width = dx;
1184     rect->height = h;
1185
1186     XFillRectangle(display, window,
1187       (GC) dc.GetGC(), rect->x, rect->y, rect->width, rect->height);
1188
1189     rect->x = rect->x;
1190     rect->y = rect->y;
1191     rect->width = rect->width;
1192     rect->height = rect->height;
1193
1194     updateRects.Append((wxObject*) rect);
1195   }
1196   else if (dx < 0)
1197   {
1198     wxRect *rect = new wxRect;
1199
1200     rect->x = x + w + dx;
1201     rect->y = y;
1202     rect->width = -dx;
1203     rect->height = h;
1204
1205     XFillRectangle(display, window,
1206       (GC) dc.GetGC(), rect->x, rect->y, rect->width,
1207       rect->height);
1208
1209     rect->x = rect->x;
1210     rect->y = rect->y;
1211     rect->width = rect->width;
1212     rect->height = rect->height;
1213
1214     updateRects.Append((wxObject*) rect);
1215   }
1216   if (dy > 0)
1217   {
1218     wxRect *rect = new wxRect;
1219
1220     rect->x = x;
1221     rect->y = y;
1222     rect->width = w;
1223     rect->height = dy;
1224
1225     XFillRectangle(display, window,
1226       (GC) dc.GetGC(), rect->x, rect->y, rect->width, rect->height);
1227
1228     rect->x = rect->x;
1229     rect->y = rect->y;
1230     rect->width = rect->width;
1231     rect->height = rect->height;
1232
1233     updateRects.Append((wxObject*) rect);
1234   }
1235   else if (dy < 0)
1236   {
1237     wxRect *rect = new wxRect;
1238
1239     rect->x = x;
1240     rect->y = y + h + dy;
1241     rect->width = w;
1242     rect->height = -dy;
1243
1244     XFillRectangle(display, window,
1245       (GC) dc.GetGC(), rect->x, rect->y, rect->width, rect->height);
1246
1247     rect->x = rect->x;
1248     rect->y = rect->y;
1249     rect->width = rect->width;
1250     rect->height = rect->height;
1251
1252     updateRects.Append((wxObject*) rect);
1253   }
1254   dc.SetBrush(wxNullBrush);
1255
1256   // Now send expose events
1257
1258   wxNode* node = updateRects.First();
1259   while (node)
1260   {
1261     wxRect* rect = (wxRect*) node->Data();
1262     XExposeEvent event;
1263
1264     event.type = Expose;
1265     event.display = display;
1266     event.send_event = True;
1267     event.window = window;
1268
1269     event.x = rect->x;
1270     event.y = rect->y;
1271     event.width = rect->width;
1272     event.height = rect->height;
1273
1274     event.count = 0;
1275
1276     XSendEvent(display, window, False, ExposureMask, (XEvent *)&event);
1277
1278     node = node->Next();
1279
1280   }
1281 }
1282
1283 void wxWindow::OnChar(wxKeyEvent& event)
1284 {
1285     if ( event.KeyCode() == WXK_TAB ) {
1286         // propagate the TABs to the parent - it's up to it to decide what
1287         // to do with it
1288         if ( GetParent() ) {
1289             if ( GetParent()->ProcessEvent(event) )
1290                 return;
1291         }
1292     }
1293 }
1294
1295 void wxWindow::OnPaint(wxPaintEvent& event)
1296 {
1297         Default();
1298 }
1299
1300 bool wxWindow::IsEnabled() const
1301 {
1302     // TODO. Is this right?
1303     // return XtGetSensitive((Widget) GetMainWidget());
1304     return FALSE;
1305 }
1306
1307 // Dialog support: override these and call
1308 // base class members to add functionality
1309 // that can't be done using validators.
1310 // NOTE: these functions assume that controls
1311 // are direct children of this window, not grandchildren
1312 // or other levels of descendant.
1313
1314 // Transfer values to controls. If returns FALSE,
1315 // it's an application error (pops up a dialog)
1316 bool wxWindow::TransferDataToWindow()
1317 {
1318         wxNode *node = GetChildren()->First();
1319         while ( node )
1320         {
1321                 wxWindow *child = (wxWindow *)node->Data();
1322                 if ( child->GetValidator() &&
1323                      !child->GetValidator()->TransferToWindow() )
1324                 {
1325                         wxMessageBox("Application Error", "Could not transfer data to window", wxOK|wxICON_EXCLAMATION);
1326                         return FALSE;
1327                 }
1328
1329                 node = node->Next();
1330         }
1331         return TRUE;
1332 }
1333
1334 // Transfer values from controls. If returns FALSE,
1335 // validation failed: don't quit
1336 bool wxWindow::TransferDataFromWindow()
1337 {
1338         wxNode *node = GetChildren()->First();
1339         while ( node )
1340         {
1341                 wxWindow *child = (wxWindow *)node->Data();
1342                 if ( child->GetValidator() && !child->GetValidator()->TransferFromWindow() )
1343                 {
1344                         return FALSE;
1345                 }
1346
1347                 node = node->Next();
1348         }
1349         return TRUE;
1350 }
1351
1352 bool wxWindow::Validate()
1353 {
1354         wxNode *node = GetChildren()->First();
1355         while ( node )
1356         {
1357                 wxWindow *child = (wxWindow *)node->Data();
1358                 if ( child->GetValidator() && /* child->GetValidator()->Ok() && */ !child->GetValidator()->Validate(this) )
1359                 {
1360                         return FALSE;
1361                 }
1362
1363                 node = node->Next();
1364         }
1365         return TRUE;
1366 }
1367
1368 // Get the window with the focus
1369 wxWindow *wxWindow::FindFocus()
1370 {
1371     // TODO
1372     return NULL;
1373 }
1374
1375 void wxWindow::AddChild(wxWindow *child)
1376 {
1377     GetChildren()->Append(child);
1378     child->m_windowParent = this;
1379 }
1380
1381 void wxWindow::RemoveChild(wxWindow *child)
1382 {
1383     if (GetChildren())
1384         GetChildren()->DeleteObject(child);
1385     child->m_windowParent = NULL;
1386 }
1387
1388 void wxWindow::DestroyChildren()
1389 {
1390   if (GetChildren()) {
1391     wxNode *node;
1392     while ((node = GetChildren()->First()) != (wxNode *)NULL) {
1393       wxWindow *child;
1394       if ((child = (wxWindow *)node->Data()) != (wxWindow *)NULL) {
1395         delete child;
1396                 if ( GetChildren()->Member(child) )
1397                         delete node;
1398       }
1399     } /* while */
1400   }
1401 }
1402
1403 void wxWindow::MakeModal(bool modal)
1404 {
1405   // Disable all other windows
1406   if (this->IsKindOf(CLASSINFO(wxDialog)) || this->IsKindOf(CLASSINFO(wxFrame)))
1407   {
1408     wxNode *node = wxTopLevelWindows.First();
1409     while (node)
1410     {
1411       wxWindow *win = (wxWindow *)node->Data();
1412       if (win != this)
1413         win->Enable(!modal);
1414
1415       node = node->Next();
1416     }
1417   }
1418 }
1419
1420 // If nothing defined for this, try the parent.
1421 // E.g. we may be a button loaded from a resource, with no callback function
1422 // defined.
1423 void wxWindow::OnCommand(wxWindow& win, wxCommandEvent& event)
1424 {
1425   if (GetEventHandler()->ProcessEvent(event) )
1426     return;
1427   if (m_windowParent)
1428     m_windowParent->GetEventHandler()->OnCommand(win, event);
1429 }
1430
1431 void wxWindow::SetConstraints(wxLayoutConstraints *c)
1432 {
1433   if (m_constraints)
1434   {
1435     UnsetConstraints(m_constraints);
1436     delete m_constraints;
1437   }
1438   m_constraints = c;
1439   if (m_constraints)
1440   {
1441     // Make sure other windows know they're part of a 'meaningful relationship'
1442     if (m_constraints->left.GetOtherWindow() && (m_constraints->left.GetOtherWindow() != this))
1443       m_constraints->left.GetOtherWindow()->AddConstraintReference((wxWindow *)this);
1444     if (m_constraints->top.GetOtherWindow() && (m_constraints->top.GetOtherWindow() != this))
1445       m_constraints->top.GetOtherWindow()->AddConstraintReference((wxWindow *)this);
1446     if (m_constraints->right.GetOtherWindow() && (m_constraints->right.GetOtherWindow() != this))
1447       m_constraints->right.GetOtherWindow()->AddConstraintReference((wxWindow *)this);
1448     if (m_constraints->bottom.GetOtherWindow() && (m_constraints->bottom.GetOtherWindow() != this))
1449       m_constraints->bottom.GetOtherWindow()->AddConstraintReference((wxWindow *)this);
1450     if (m_constraints->width.GetOtherWindow() && (m_constraints->width.GetOtherWindow() != this))
1451       m_constraints->width.GetOtherWindow()->AddConstraintReference((wxWindow *)this);
1452     if (m_constraints->height.GetOtherWindow() && (m_constraints->height.GetOtherWindow() != this))
1453       m_constraints->height.GetOtherWindow()->AddConstraintReference((wxWindow *)this);
1454     if (m_constraints->centreX.GetOtherWindow() && (m_constraints->centreX.GetOtherWindow() != this))
1455       m_constraints->centreX.GetOtherWindow()->AddConstraintReference((wxWindow *)this);
1456     if (m_constraints->centreY.GetOtherWindow() && (m_constraints->centreY.GetOtherWindow() != this))
1457       m_constraints->centreY.GetOtherWindow()->AddConstraintReference((wxWindow *)this);
1458   }
1459 }
1460
1461 // This removes any dangling pointers to this window
1462 // in other windows' constraintsInvolvedIn lists.
1463 void wxWindow::UnsetConstraints(wxLayoutConstraints *c)
1464 {
1465   if (c)
1466   {
1467     if (c->left.GetOtherWindow() && (c->top.GetOtherWindow() != this))
1468       c->left.GetOtherWindow()->RemoveConstraintReference((wxWindow *)this);
1469     if (c->top.GetOtherWindow() && (c->top.GetOtherWindow() != this))
1470       c->top.GetOtherWindow()->RemoveConstraintReference((wxWindow *)this);
1471     if (c->right.GetOtherWindow() && (c->right.GetOtherWindow() != this))
1472       c->right.GetOtherWindow()->RemoveConstraintReference((wxWindow *)this);
1473     if (c->bottom.GetOtherWindow() && (c->bottom.GetOtherWindow() != this))
1474       c->bottom.GetOtherWindow()->RemoveConstraintReference((wxWindow *)this);
1475     if (c->width.GetOtherWindow() && (c->width.GetOtherWindow() != this))
1476       c->width.GetOtherWindow()->RemoveConstraintReference((wxWindow *)this);
1477     if (c->height.GetOtherWindow() && (c->height.GetOtherWindow() != this))
1478       c->height.GetOtherWindow()->RemoveConstraintReference((wxWindow *)this);
1479     if (c->centreX.GetOtherWindow() && (c->centreX.GetOtherWindow() != this))
1480       c->centreX.GetOtherWindow()->RemoveConstraintReference((wxWindow *)this);
1481     if (c->centreY.GetOtherWindow() && (c->centreY.GetOtherWindow() != this))
1482       c->centreY.GetOtherWindow()->RemoveConstraintReference((wxWindow *)this);
1483   }
1484 }
1485
1486 // Back-pointer to other windows we're involved with, so if we delete
1487 // this window, we must delete any constraints we're involved with.
1488 void wxWindow::AddConstraintReference(wxWindow *otherWin)
1489 {
1490   if (!m_constraintsInvolvedIn)
1491     m_constraintsInvolvedIn = new wxList;
1492   if (!m_constraintsInvolvedIn->Member(otherWin))
1493     m_constraintsInvolvedIn->Append(otherWin);
1494 }
1495
1496 // REMOVE back-pointer to other windows we're involved with.
1497 void wxWindow::RemoveConstraintReference(wxWindow *otherWin)
1498 {
1499   if (m_constraintsInvolvedIn)
1500     m_constraintsInvolvedIn->DeleteObject(otherWin);
1501 }
1502
1503 // Reset any constraints that mention this window
1504 void wxWindow::DeleteRelatedConstraints()
1505 {
1506   if (m_constraintsInvolvedIn)
1507   {
1508     wxNode *node = m_constraintsInvolvedIn->First();
1509     while (node)
1510     {
1511       wxWindow *win = (wxWindow *)node->Data();
1512       wxNode *next = node->Next();
1513       wxLayoutConstraints *constr = win->GetConstraints();
1514
1515       // Reset any constraints involving this window
1516       if (constr)
1517       {
1518         constr->left.ResetIfWin((wxWindow *)this);
1519         constr->top.ResetIfWin((wxWindow *)this);
1520         constr->right.ResetIfWin((wxWindow *)this);
1521         constr->bottom.ResetIfWin((wxWindow *)this);
1522         constr->width.ResetIfWin((wxWindow *)this);
1523         constr->height.ResetIfWin((wxWindow *)this);
1524         constr->centreX.ResetIfWin((wxWindow *)this);
1525         constr->centreY.ResetIfWin((wxWindow *)this);
1526       }
1527       delete node;
1528       node = next;
1529     }
1530     delete m_constraintsInvolvedIn;
1531     m_constraintsInvolvedIn = NULL;
1532   }
1533 }
1534
1535 void wxWindow::SetSizer(wxSizer *sizer)
1536 {
1537   m_windowSizer = sizer;
1538   if (sizer)
1539     sizer->SetSizerParent((wxWindow *)this);
1540 }
1541
1542 /*
1543  * New version
1544  */
1545
1546 bool wxWindow::Layout()
1547 {
1548   if (GetConstraints())
1549   {
1550     int w, h;
1551     GetClientSize(&w, &h);
1552     GetConstraints()->width.SetValue(w);
1553     GetConstraints()->height.SetValue(h);
1554   }
1555
1556   // If top level (one sizer), evaluate the sizer's constraints.
1557   if (GetSizer())
1558   {
1559     int noChanges;
1560     GetSizer()->ResetConstraints();   // Mark all constraints as unevaluated
1561     GetSizer()->LayoutPhase1(&noChanges);
1562     GetSizer()->LayoutPhase2(&noChanges);
1563     GetSizer()->SetConstraintSizes(); // Recursively set the real window sizes
1564     return TRUE;
1565   }
1566   else
1567   {
1568     // Otherwise, evaluate child constraints
1569     ResetConstraints();   // Mark all constraints as unevaluated
1570     DoPhase(1);           // Just one phase need if no sizers involved
1571     DoPhase(2);
1572     SetConstraintSizes(); // Recursively set the real window sizes
1573   }
1574   return TRUE;
1575 }
1576
1577
1578 // Do a phase of evaluating constraints:
1579 // the default behaviour. wxSizers may do a similar
1580 // thing, but also impose their own 'constraints'
1581 // and order the evaluation differently.
1582 bool wxWindow::LayoutPhase1(int *noChanges)
1583 {
1584   wxLayoutConstraints *constr = GetConstraints();
1585   if (constr)
1586   {
1587     return constr->SatisfyConstraints((wxWindow *)this, noChanges);
1588   }
1589   else
1590     return TRUE;
1591 }
1592
1593 bool wxWindow::LayoutPhase2(int *noChanges)
1594 {
1595   *noChanges = 0;
1596
1597   // Layout children
1598   DoPhase(1);
1599   DoPhase(2);
1600   return TRUE;
1601 }
1602
1603 // Do a phase of evaluating child constraints
1604 bool wxWindow::DoPhase(int phase)
1605 {
1606   int noIterations = 0;
1607   int maxIterations = 500;
1608   int noChanges = 1;
1609   int noFailures = 0;
1610   wxList succeeded;
1611   while ((noChanges > 0) && (noIterations < maxIterations))
1612   {
1613     noChanges = 0;
1614     noFailures = 0;
1615     wxNode *node = GetChildren()->First();
1616     while (node)
1617     {
1618       wxWindow *child = (wxWindow *)node->Data();
1619       if (!child->IsKindOf(CLASSINFO(wxFrame)) && !child->IsKindOf(CLASSINFO(wxDialog)))
1620       {
1621         wxLayoutConstraints *constr = child->GetConstraints();
1622         if (constr)
1623         {
1624           if (succeeded.Member(child))
1625           {
1626           }
1627           else
1628           {
1629             int tempNoChanges = 0;
1630             bool success = ( (phase == 1) ? child->LayoutPhase1(&tempNoChanges) : child->LayoutPhase2(&tempNoChanges) ) ;
1631             noChanges += tempNoChanges;
1632             if (success)
1633             {
1634               succeeded.Append(child);
1635             }
1636           }
1637         }
1638       }
1639       node = node->Next();
1640     }
1641     noIterations ++;
1642   }
1643   return TRUE;
1644 }
1645
1646 void wxWindow::ResetConstraints()
1647 {
1648   wxLayoutConstraints *constr = GetConstraints();
1649   if (constr)
1650   {
1651     constr->left.SetDone(FALSE);
1652     constr->top.SetDone(FALSE);
1653     constr->right.SetDone(FALSE);
1654     constr->bottom.SetDone(FALSE);
1655     constr->width.SetDone(FALSE);
1656     constr->height.SetDone(FALSE);
1657     constr->centreX.SetDone(FALSE);
1658     constr->centreY.SetDone(FALSE);
1659   }
1660   wxNode *node = GetChildren()->First();
1661   while (node)
1662   {
1663     wxWindow *win = (wxWindow *)node->Data();
1664     if (!win->IsKindOf(CLASSINFO(wxFrame)) && !win->IsKindOf(CLASSINFO(wxDialog)))
1665       win->ResetConstraints();
1666     node = node->Next();
1667   }
1668 }
1669
1670 // Need to distinguish between setting the 'fake' size for
1671 // windows and sizers, and setting the real values.
1672 void wxWindow::SetConstraintSizes(bool recurse)
1673 {
1674   wxLayoutConstraints *constr = GetConstraints();
1675   if (constr && constr->left.GetDone() && constr->right.GetDone() &&
1676                 constr->width.GetDone() && constr->height.GetDone())
1677   {
1678     int x = constr->left.GetValue();
1679     int y = constr->top.GetValue();
1680     int w = constr->width.GetValue();
1681     int h = constr->height.GetValue();
1682
1683     // If we don't want to resize this window, just move it...
1684     if ((constr->width.GetRelationship() != wxAsIs) ||
1685         (constr->height.GetRelationship() != wxAsIs))
1686     {
1687       // Calls Layout() recursively. AAAGH. How can we stop that.
1688       // Simply take Layout() out of non-top level OnSizes.
1689       SizerSetSize(x, y, w, h);
1690     }
1691     else
1692     {
1693       SizerMove(x, y);
1694     }
1695   }
1696   else if (constr)
1697   {
1698     char *windowClass = this->GetClassInfo()->GetClassName();
1699
1700     wxString winName;
1701         if (GetName() == "")
1702                 winName = "unnamed";
1703         else
1704                 winName = GetName();
1705     wxDebugMsg("Constraint(s) not satisfied for window of type %s, name %s:\n", (const char *)windowClass, (const char *)winName);
1706     if (!constr->left.GetDone())
1707       wxDebugMsg("  unsatisfied 'left' constraint.\n");
1708     if (!constr->right.GetDone())
1709       wxDebugMsg("  unsatisfied 'right' constraint.\n");
1710     if (!constr->width.GetDone())
1711       wxDebugMsg("  unsatisfied 'width' constraint.\n");
1712     if (!constr->height.GetDone())
1713       wxDebugMsg("  unsatisfied 'height' constraint.\n");
1714     wxDebugMsg("Please check constraints: try adding AsIs() constraints.\n");
1715   }
1716
1717   if (recurse)
1718   {
1719     wxNode *node = GetChildren()->First();
1720     while (node)
1721     {
1722       wxWindow *win = (wxWindow *)node->Data();
1723       if (!win->IsKindOf(CLASSINFO(wxFrame)) && !win->IsKindOf(CLASSINFO(wxDialog)))
1724         win->SetConstraintSizes();
1725       node = node->Next();
1726     }
1727   }
1728 }
1729
1730 // This assumes that all sizers are 'on' the same
1731 // window, i.e. the parent of this window.
1732 void wxWindow::TransformSizerToActual(int *x, int *y) const
1733 {
1734   if (!m_sizerParent || m_sizerParent->IsKindOf(CLASSINFO(wxDialog)) ||
1735                          m_sizerParent->IsKindOf(CLASSINFO(wxFrame)) )
1736     return;
1737
1738   int xp, yp;
1739   m_sizerParent->GetPosition(&xp, &yp);
1740   m_sizerParent->TransformSizerToActual(&xp, &yp);
1741   *x += xp;
1742   *y += yp;
1743 }
1744
1745 void wxWindow::SizerSetSize(int x, int y, int w, int h)
1746 {
1747         int xx = x;
1748         int yy = y;
1749   TransformSizerToActual(&xx, &yy);
1750   SetSize(xx, yy, w, h);
1751 }
1752
1753 void wxWindow::SizerMove(int x, int y)
1754 {
1755         int xx = x;
1756         int yy = y;
1757   TransformSizerToActual(&xx, &yy);
1758   Move(xx, yy);
1759 }
1760
1761 // Only set the size/position of the constraint (if any)
1762 void wxWindow::SetSizeConstraint(int x, int y, int w, int h)
1763 {
1764   wxLayoutConstraints *constr = GetConstraints();
1765   if (constr)
1766   {
1767     if (x != -1)
1768     {
1769       constr->left.SetValue(x);
1770       constr->left.SetDone(TRUE);
1771     }
1772     if (y != -1)
1773     {
1774       constr->top.SetValue(y);
1775       constr->top.SetDone(TRUE);
1776     }
1777     if (w != -1)
1778     {
1779       constr->width.SetValue(w);
1780       constr->width.SetDone(TRUE);
1781     }
1782     if (h != -1)
1783     {
1784       constr->height.SetValue(h);
1785       constr->height.SetDone(TRUE);
1786     }
1787   }
1788 }
1789
1790 void wxWindow::MoveConstraint(int x, int y)
1791 {
1792   wxLayoutConstraints *constr = GetConstraints();
1793   if (constr)
1794   {
1795     if (x != -1)
1796     {
1797       constr->left.SetValue(x);
1798       constr->left.SetDone(TRUE);
1799     }
1800     if (y != -1)
1801     {
1802       constr->top.SetValue(y);
1803       constr->top.SetDone(TRUE);
1804     }
1805   }
1806 }
1807
1808 void wxWindow::GetSizeConstraint(int *w, int *h) const
1809 {
1810   wxLayoutConstraints *constr = GetConstraints();
1811   if (constr)
1812   {
1813     *w = constr->width.GetValue();
1814     *h = constr->height.GetValue();
1815   }
1816   else
1817     GetSize(w, h);
1818 }
1819
1820 void wxWindow::GetClientSizeConstraint(int *w, int *h) const
1821 {
1822   wxLayoutConstraints *constr = GetConstraints();
1823   if (constr)
1824   {
1825     *w = constr->width.GetValue();
1826     *h = constr->height.GetValue();
1827   }
1828   else
1829     GetClientSize(w, h);
1830 }
1831
1832 void wxWindow::GetPositionConstraint(int *x, int *y) const
1833 {
1834   wxLayoutConstraints *constr = GetConstraints();
1835   if (constr)
1836   {
1837     *x = constr->left.GetValue();
1838     *y = constr->top.GetValue();
1839   }
1840   else
1841     GetPosition(x, y);
1842 }
1843
1844 bool wxWindow::Close(bool force)
1845 {
1846   wxCloseEvent event(wxEVT_CLOSE_WINDOW, m_windowId);
1847   event.SetEventObject(this);
1848   event.SetForce(force);
1849
1850   return GetEventHandler()->ProcessEvent(event);
1851 }
1852
1853 wxObject* wxWindow::GetChild(int number) const
1854 {
1855   // Return a pointer to the Nth object in the window
1856   if (!GetChildren())
1857     return(NULL) ;
1858   wxNode *node = GetChildren()->First();
1859   int n = number;
1860   while (node && n--)
1861     node = node->Next() ;
1862   if (node)
1863   {
1864     wxObject *obj = (wxObject *)node->Data();
1865     return(obj) ;
1866   }
1867   else
1868     return NULL ;
1869 }
1870
1871 void wxWindow::OnDefaultAction(wxControl *initiatingItem)
1872 {
1873     // Obsolete function
1874 }
1875
1876 void wxWindow::Clear()
1877 {
1878     wxClientDC dc(this);
1879     wxBrush brush(GetBackgroundColour(), wxSOLID);
1880     dc.SetBackground(brush);
1881     dc.Clear();
1882 }
1883
1884 // Fits the panel around the items
1885 void wxWindow::Fit()
1886 {
1887         int maxX = 0;
1888         int maxY = 0;
1889         wxNode *node = GetChildren()->First();
1890         while ( node )
1891         {
1892                 wxWindow *win = (wxWindow *)node->Data();
1893                 int wx, wy, ww, wh;
1894                 win->GetPosition(&wx, &wy);
1895                 win->GetSize(&ww, &wh);
1896                 if ( wx + ww > maxX )
1897                         maxX = wx + ww;
1898                 if ( wy + wh > maxY )
1899                         maxY = wy + wh;
1900
1901                 node = node->Next();
1902         }
1903         SetClientSize(maxX + 5, maxY + 5);
1904 }
1905
1906 void wxWindow::SetValidator(const wxValidator& validator)
1907 {
1908         if ( m_windowValidator )
1909                 delete m_windowValidator;
1910         m_windowValidator = validator.Clone();
1911
1912         if ( m_windowValidator )
1913                 m_windowValidator->SetWindow(this) ;
1914 }
1915
1916 // Find a window by id or name
1917 wxWindow *wxWindow::FindWindow(long id)
1918 {
1919         if ( GetId() == id)
1920                 return this;
1921
1922         wxNode *node = GetChildren()->First();
1923         while ( node )
1924         {
1925                 wxWindow *child = (wxWindow *)node->Data();
1926                 wxWindow *found = child->FindWindow(id);
1927                 if ( found )
1928                         return found;
1929                 node = node->Next();
1930         }
1931         return NULL;
1932 }
1933
1934 wxWindow *wxWindow::FindWindow(const wxString& name)
1935 {
1936         if ( GetName() == name)
1937                 return this;
1938
1939         wxNode *node = GetChildren()->First();
1940         while ( node )
1941         {
1942                 wxWindow *child = (wxWindow *)node->Data();
1943                 wxWindow *found = child->FindWindow(name);
1944                 if ( found )
1945                         return found;
1946                 node = node->Next();
1947         }
1948         return NULL;
1949 }
1950
1951 void wxWindow::OnIdle(wxIdleEvent& event)
1952 {
1953     // This calls the UI-update mechanism (querying windows for
1954     // menu/toolbar/control state information)
1955     UpdateWindowUI();
1956 }
1957
1958 // Raise the window to the top of the Z order
1959 void wxWindow::Raise()
1960 {
1961     Window window = XtWindow((Widget) GetTopWidget());
1962     XRaiseWindow(XtDisplay((Widget) GetTopWidget()), window);
1963 }
1964
1965 // Lower the window to the bottom of the Z order
1966 void wxWindow::Lower()
1967 {
1968     Window window = XtWindow((Widget) GetTopWidget());
1969     XLowerWindow(XtDisplay((Widget) GetTopWidget()), window);
1970 }
1971
1972 bool wxWindow::AcceptsFocus() const
1973 {
1974   return IsShown() && IsEnabled();
1975 }
1976
1977 // Update region access
1978 wxRegion wxWindow::GetUpdateRegion() const
1979 {
1980     return m_updateRegion;
1981 }
1982
1983 bool wxWindow::IsExposed(int x, int y, int w, int h) const
1984 {
1985     return (m_updateRegion.Contains(x, y, w, h) != wxOutRegion);
1986 }
1987
1988 bool wxWindow::IsExposed(const wxPoint& pt) const
1989 {
1990     return (m_updateRegion.Contains(pt) != wxOutRegion);
1991 }
1992
1993 bool wxWindow::IsExposed(const wxRect& rect) const
1994 {
1995     return (m_updateRegion.Contains(rect) != wxOutRegion);
1996 }
1997
1998 /*
1999  * Allocates control IDs
2000  */
2001
2002 int wxWindow::NewControlId()
2003 {
2004     static int s_controlId = 0;
2005     s_controlId ++;
2006     return s_controlId;
2007 }
2008
2009 void wxWindow::SetAcceleratorTable(const wxAcceleratorTable& accel)
2010 {
2011     m_acceleratorTable = accel;
2012 }
2013
2014 // All widgets should have this as their resize proc.
2015 // OnSize sent to wxWindow via client data.
2016 void wxWidgetResizeProc(Widget w, XConfigureEvent *event, String args[], int *num_args)
2017 {
2018     wxWindow *win = (wxWindow *)wxWidgetHashTable->Get((long)w);
2019     if (!win)
2020         return;
2021
2022     if (win->PreResize())
2023     {
2024         int width, height;
2025         win->GetSize(&width, &height);
2026         wxSizeEvent sizeEvent(wxSize(width, height), win->GetId());
2027         sizeEvent.SetEventObject(win);
2028         win->GetEventHandler()->ProcessEvent(sizeEvent);
2029     }
2030 }
2031
2032 bool wxAddWindowToTable(Widget w, wxWindow *win)
2033 {
2034   wxWindow *oldItem = NULL;
2035 #if DEBUG
2036 //  printf("Adding widget %ld, name = %s\n", w, win->GetClassInfo()->GetClassName());
2037 #endif
2038   if ((oldItem = (wxWindow *)wxWidgetHashTable->Get ((long) w)))
2039   {
2040     char buf[300];
2041     sprintf(buf, "Widget table clash: new widget is %ld, %s", (long)w, win->GetClassInfo()->GetClassName());
2042     wxError (buf);
2043     fflush(stderr);
2044     sprintf(buf, "Old widget was %s", oldItem->GetClassInfo()->GetClassName());
2045     wxError (buf);
2046     return FALSE;
2047   }
2048
2049   wxWidgetHashTable->Put ((long) w, win);
2050   return TRUE;
2051 }
2052
2053 wxWindow *wxGetWindowFromTable(Widget w)
2054 {
2055   return (wxWindow *)wxWidgetHashTable->Get ((long) w);
2056 }
2057
2058 void wxDeleteWindowFromTable(Widget w)
2059 {
2060   wxWidgetHashTable->Delete((long)w);
2061 }
2062
2063 // Get the underlying X window and display
2064 WXWindow wxWindow::GetXWindow() const
2065 {
2066     return (WXWindow) XtWindow((Widget) GetMainWidget());
2067 }
2068
2069 WXDisplay *wxWindow::GetXDisplay() const
2070 {
2071     return (WXDisplay*) XtDisplay((Widget) GetMainWidget());
2072 }
2073
2074 WXWidget wxWindow::GetMainWidget() const
2075 {
2076     if (m_drawingArea)
2077       return m_drawingArea;
2078     else
2079       return m_mainWidget;
2080 }
2081
2082 WXWidget wxWindow::GetClientWidget() const
2083 {
2084     if (m_drawingArea != (WXWidget) 0)
2085         return m_drawingArea;
2086     else
2087         return GetMainWidget();
2088 }
2089
2090 WXWidget wxWindow::GetTopWidget() const
2091 {
2092     return GetMainWidget();
2093 }
2094
2095 void wxCanvasRepaintProc (Widget drawingArea, XtPointer clientData,
2096  XmDrawingAreaCallbackStruct * cbs)
2097 {
2098     if (!wxWidgetHashTable->Get ((long) (Widget) drawingArea))
2099         return;
2100
2101     XEvent * event = cbs->event;
2102     wxWindow * canvas = (wxWindow *) clientData;
2103     Display * display = (Display *) canvas->GetXDisplay();
2104     //    GC gc = (GC) canvas->GetDC()->gc;
2105
2106     switch (event->type)
2107     {
2108       case Expose:
2109       {
2110         /* TODO
2111         wxCanvasDC* canvasDC = canvas->GetDC();
2112         if (canvasDC)
2113         {
2114           if (canvasDC->onpaint_reg)
2115             XDestroyRegion(canvasDC->onpaint_reg);
2116           canvasDC->onpaint_reg = XCreateRegion();
2117
2118         }
2119         */
2120
2121         int n = canvas->m_updateRects.Number();
2122         XRectangle* xrects = new XRectangle[n];
2123         int i;
2124         for (i = 0; i < canvas->m_updateRects.Number(); i++)
2125         {
2126           wxRect* rect = (wxRect*) canvas->m_updateRects.Nth(i)->Data();
2127           xrects[i].x = rect->x;
2128           xrects[i].y = rect->y;
2129           xrects[i].width = rect->width;
2130           xrects[i].height = rect->height;
2131           /* TODO (?) Actually ignore it I think.
2132           if (canvasDC)
2133             XUnionRectWithRegion(&(xrects[i]), canvasDC->onpaint_reg,
2134               canvasDC->onpaint_reg);
2135       */
2136         }
2137         /* TODO must clip the area being repainted. So we need a gc.
2138          * Alternatively, wxPaintDC must do the clipping
2139          * when it's created.
2140         XSetClipRectangles(display, gc, 0, 0, xrects, n, Unsorted);
2141         */
2142
2143         canvas->DoPaint() ; // xrects, n);
2144         delete[] xrects;
2145
2146         canvas->m_updateRects.Clear();
2147
2148         /*
2149         if (canvasDC)
2150         {
2151           XDestroyRegion(canvasDC->onpaint_reg);
2152           canvasDC->onpaint_reg = NULL;
2153         }
2154
2155         XGCValues gc_val;
2156         gc_val.clip_mask = None;
2157         XChangeGC(display, gc, GCClipMask, &gc_val);
2158         */
2159
2160         break;
2161     }
2162     default:
2163     {
2164         cout << "\n\nNew Event ! is = " << event -> type << "\n";
2165         break;
2166     }
2167   }
2168 }
2169
2170 // Unable to deal with Enter/Leave without a separate EventHandler (Motif 1.1.4)
2171 void
2172 wxCanvasEnterLeave (Widget drawingArea, XtPointer clientData, XCrossingEvent * event)
2173 {
2174   XmDrawingAreaCallbackStruct cbs;
2175   XEvent ev;
2176
2177   //if (event->mode!=NotifyNormal)
2178   //  return ;
2179
2180 //  ev = *((XEvent *) event); // Causes Purify error (copying too many bytes)
2181   ((XCrossingEvent &) ev) = *event;
2182
2183   cbs.reason = XmCR_INPUT;
2184   cbs.event = &ev;
2185
2186   wxCanvasInputEvent (drawingArea, (XtPointer) NULL, &cbs);
2187 }
2188
2189 // Fix to make it work under Motif 1.0 (!)
2190 void wxCanvasMotionEvent (Widget drawingArea, XButtonEvent * event)
2191 {
2192 #if   XmVersion<=1000
2193
2194   XmDrawingAreaCallbackStruct cbs;
2195   XEvent ev;
2196
2197   //ev.xbutton = *event;
2198   ev = *((XEvent *) event);
2199   cbs.reason = XmCR_INPUT;
2200   cbs.event = &ev;
2201
2202   wxCanvasInputEvent (drawingArea, (XtPointer) NULL, &cbs);
2203 #endif
2204 }
2205
2206 void wxCanvasInputEvent (Widget drawingArea, XtPointer data, XmDrawingAreaCallbackStruct * cbs)
2207 {
2208   wxWindow *canvas = (wxWindow *) wxWidgetHashTable->Get ((long) (Widget) drawingArea);
2209   XEvent local_event;
2210
2211   if (canvas==NULL)
2212     return ;
2213
2214   if (cbs->reason != XmCR_INPUT)
2215     return;
2216
2217   local_event = *(cbs->event);  // We must keep a copy!
2218
2219   switch (local_event.xany.type)
2220     {
2221     case EnterNotify:
2222     case LeaveNotify:
2223     case ButtonPress:
2224     case ButtonRelease:
2225     case MotionNotify:
2226       {
2227         wxEventType eventType = wxEVT_NULL;
2228
2229         if (local_event.xany.type == EnterNotify)
2230           {
2231             //if (local_event.xcrossing.mode!=NotifyNormal)
2232             //  return ; // Ignore grab events
2233             eventType = wxEVT_ENTER_WINDOW;
2234 //            canvas->GetEventHandler()->OnSetFocus();
2235           }
2236         else if (local_event.xany.type == LeaveNotify)
2237           {
2238             //if (local_event.xcrossing.mode!=NotifyNormal)
2239             //  return ; // Ignore grab events
2240             eventType = wxEVT_LEAVE_WINDOW;
2241 //            canvas->GetEventHandler()->OnKillFocus();
2242           }
2243         else if (local_event.xany.type == MotionNotify)
2244           {
2245             eventType = wxEVT_MOTION;
2246             if (local_event.xmotion.is_hint == NotifyHint)
2247               {
2248                 Window root, child;
2249                 Display *dpy = XtDisplay (drawingArea);
2250
2251                 XQueryPointer (dpy, XtWindow (drawingArea),
2252                                &root, &child,
2253                                &local_event.xmotion.x_root,
2254                                &local_event.xmotion.y_root,
2255                                &local_event.xmotion.x,
2256                                &local_event.xmotion.y,
2257                                &local_event.xmotion.state);
2258               }
2259             else
2260               {
2261               }
2262           }
2263
2264         else if (local_event.xany.type == ButtonPress)
2265           {
2266             if (local_event.xbutton.button == Button1)
2267               {
2268                 eventType = wxEVT_LEFT_DOWN;
2269                 canvas->m_button1Pressed = TRUE;
2270               }
2271             else if (local_event.xbutton.button == Button2)
2272               {
2273                 eventType = wxEVT_MIDDLE_DOWN;
2274                 canvas->m_button2Pressed = TRUE;
2275               }
2276             else if (local_event.xbutton.button == Button3)
2277               {
2278                 eventType = wxEVT_RIGHT_DOWN;
2279                 canvas->m_button3Pressed = TRUE;
2280               }
2281           }
2282         else if (local_event.xany.type == ButtonRelease)
2283           {
2284             if (local_event.xbutton.button == Button1)
2285               {
2286                 eventType = wxEVT_LEFT_UP;
2287                 canvas->m_button1Pressed = FALSE;
2288               }
2289             else if (local_event.xbutton.button == Button2)
2290               {
2291                 eventType = wxEVT_MIDDLE_UP;
2292                 canvas->m_button2Pressed = FALSE;
2293               }
2294             else if (local_event.xbutton.button == Button3)
2295               {
2296                 eventType = wxEVT_RIGHT_UP;
2297                 canvas->m_button3Pressed = FALSE;
2298               }
2299           }
2300
2301         wxMouseEvent wxevent (eventType);
2302         wxevent.m_eventHandle = (char *) &local_event;
2303
2304         wxevent.m_leftDown = ((eventType == wxEVT_LEFT_DOWN)
2305                             || (event_left_is_down (&local_event)
2306                                 && (eventType != wxEVT_LEFT_UP)));
2307         wxevent.m_middleDown = ((eventType == wxEVT_MIDDLE_DOWN)
2308                               || (event_middle_is_down (&local_event)
2309                                   && (eventType != wxEVT_MIDDLE_UP)));
2310         wxevent.m_rightDown = ((eventType == wxEVT_RIGHT_DOWN)
2311                              || (event_right_is_down (&local_event)
2312                                  && (eventType != wxEVT_RIGHT_UP)));
2313
2314         wxevent.m_shiftDown = local_event.xbutton.state & ShiftMask;
2315         wxevent.m_controlDown = local_event.xbutton.state & ControlMask;
2316         wxevent.m_altDown = local_event.xbutton.state & Mod3Mask;
2317         wxevent.m_metaDown = local_event.xbutton.state & Mod1Mask;
2318         wxevent.SetTimestamp(local_event.xbutton.time);
2319
2320     // Now check if we need to translate this event into a double click
2321     if (TRUE) // canvas->doubleClickAllowed)
2322     {
2323        if (wxevent.ButtonDown())
2324        {
2325              long dclickTime = XtGetMultiClickTime((Display*) wxGetDisplay()) ;
2326
2327              // get button and time-stamp
2328              int button = 0;
2329              if      (wxevent.LeftDown())   button = 1;
2330              else if (wxevent.MiddleDown()) button = 2;
2331              else if (wxevent.RightDown())  button = 3;
2332              long ts = wxevent.GetTimestamp();
2333              // check, if single or double click
2334              if (canvas->m_lastButton && canvas->m_lastButton==button && (ts - canvas->m_lastTS) < dclickTime)
2335                {
2336                 // I have a dclick
2337                  canvas->m_lastButton = 0;
2338                  switch ( eventType )
2339                    {
2340                    case wxEVT_LEFT_DOWN:
2341                      wxevent.SetEventType(wxEVT_LEFT_DCLICK);
2342                      break;
2343                    case wxEVT_MIDDLE_DOWN:
2344                      wxevent.SetEventType(wxEVT_MIDDLE_DCLICK);
2345                      break;
2346                    case wxEVT_RIGHT_DOWN:
2347                      wxevent.SetEventType(wxEVT_RIGHT_DCLICK);
2348                      break;
2349
2350                    default :
2351                      break;
2352                    }
2353
2354                }
2355              else
2356                {
2357                  // not fast enough or different button
2358                  canvas->m_lastTS     = ts;
2359                  canvas->m_lastButton = button;
2360                }
2361        }
2362     }
2363
2364         wxevent.SetId(canvas->GetId());
2365         wxevent.SetEventObject(canvas);
2366         wxevent.m_x = local_event.xbutton.x;
2367         wxevent.m_y = local_event.xbutton.y;
2368         canvas->GetEventHandler()->ProcessEvent (wxevent);
2369         /*
2370         if (eventType == wxEVT_ENTER_WINDOW ||
2371             eventType == wxEVT_LEAVE_WINDOW ||
2372             eventType == wxEVT_MOTION
2373           )
2374           return;
2375           */
2376         break;
2377       }
2378     case KeyPress:
2379       {
2380         KeySym keySym;
2381 //      XComposeStatus compose;
2382 //      (void) XLookupString ((XKeyEvent *) & local_event, wxBuffer, 20, &keySym, &compose);
2383         (void) XLookupString ((XKeyEvent *) & local_event, wxBuffer, 20, &keySym, NULL);
2384         int id = wxCharCodeXToWX (keySym);
2385
2386         wxKeyEvent event (wxEVT_CHAR);
2387
2388         if (local_event.xkey.state & ShiftMask)
2389           event.m_shiftDown = TRUE;
2390         if (local_event.xkey.state & ControlMask)
2391           event.m_controlDown = TRUE;
2392         if (local_event.xkey.state & Mod3Mask)
2393           event.m_altDown = TRUE;
2394         if (local_event.xkey.state & Mod1Mask)
2395           event.m_metaDown = TRUE;
2396         event.SetEventObject(canvas);
2397         event.m_keyCode = id;
2398         event.SetTimestamp(local_event.xkey.time);
2399
2400         if (id > -1)
2401         {
2402           // Implement wxFrame::OnCharHook by checking ancestor.
2403           wxWindow *parent = canvas->GetParent();
2404           while (parent && !parent->IsKindOf(CLASSINFO(wxFrame)))
2405             parent = parent->GetParent();
2406
2407           if (parent)
2408           {
2409             event.SetEventType(wxEVT_CHAR_HOOK);
2410             if (parent->GetEventHandler()->ProcessEvent(event))
2411               return;
2412             event.SetEventType(wxEVT_CHAR);
2413           }
2414
2415           canvas->GetEventHandler()->ProcessEvent (event);
2416         }
2417         break;
2418       }
2419     case FocusIn:
2420       {
2421         if (local_event.xfocus.detail != NotifyPointer)
2422         {
2423           wxFocusEvent event(wxEVT_SET_FOCUS, canvas->GetId());
2424           event.SetEventObject(canvas);
2425           canvas->GetEventHandler()->ProcessEvent(event);
2426         }
2427         break;
2428       }
2429     case FocusOut:
2430       {
2431         if (local_event.xfocus.detail != NotifyPointer)
2432         {
2433           wxFocusEvent event(wxEVT_KILL_FOCUS, canvas->GetId());
2434           event.SetEventObject(canvas);
2435           canvas->GetEventHandler()->ProcessEvent(event);
2436         }
2437         break;
2438       }
2439     default:
2440       break;
2441     }
2442 }
2443
2444 void wxWindow::DoPaint()
2445 {
2446   //TODO : make a temporary gc so we can do the XCopyArea below
2447   if (0) // m_backingPixmap)
2448     {
2449       /*
2450       Widget drawingArea = (Widget) m_drawingArea;
2451       //      int orig = GetDC()->GetLogicalFunction();
2452       //      GetDC()->SetLogicalFunction (wxCOPY);
2453
2454       // TODO: it may not be necessary to store m_pixmapOffsetX/Y; we
2455       // should be able to calculate them.
2456       XCopyArea (XtDisplay (drawingArea), m_backingPixmap, XtWindow (drawingArea), GetDC ()->gc,
2457                  m_pixmapOffsetX, m_pixmapOffsetY,
2458                  m_pixmapWidth, m_pixmapHeight,
2459                  0, 0);
2460
2461       //      GetDC()->SetLogicalFunction (orig);
2462       */
2463     }
2464   else
2465     {
2466         wxPaintEvent event(GetId());
2467         event.SetEventObject(this);
2468         GetEventHandler()->ProcessEvent(event);
2469     }
2470 }
2471
2472 // SetSize, but as per old wxCanvas (with drawing widget etc.)
2473 void wxWindow::CanvasSetSize (int x, int y, int w, int h, int sizeFlags)
2474 {
2475   Widget drawingArea = (Widget) m_drawingArea;
2476   bool managed = XtIsManaged(m_borderWidget ? (Widget) m_borderWidget : (Widget) m_scrolledWindow);
2477
2478   if (managed)
2479     XtUnmanageChild (m_borderWidget ? (Widget) m_borderWidget : (Widget) m_scrolledWindow);
2480   XtVaSetValues((Widget) m_drawingArea, XmNresizePolicy, XmRESIZE_ANY, NULL);
2481
2482   int xx = x; int yy = y;
2483   AdjustForParentClientOrigin(xx, yy, sizeFlags);
2484
2485   if (x > -1 || (sizeFlags & wxSIZE_ALLOW_MINUS_ONE))
2486     {
2487       XtVaSetValues (m_borderWidget ? (Widget) m_borderWidget : (Widget) m_scrolledWindow,
2488                      XmNx, xx, NULL);
2489     }
2490
2491   if (y > -1 || (sizeFlags & wxSIZE_ALLOW_MINUS_ONE))
2492     {
2493       XtVaSetValues (m_borderWidget ? (Widget) m_borderWidget : (Widget) m_scrolledWindow,
2494                      XmNy, yy, NULL);
2495     }
2496
2497   if (w > -1)
2498     {
2499       if (m_borderWidget)
2500         {
2501           XtVaSetValues ((Widget) m_borderWidget, XmNwidth, w, NULL);
2502           short thick, margin;
2503           XtVaGetValues ((Widget) m_borderWidget,
2504                          XmNshadowThickness, &thick,
2505                          XmNmarginWidth, &margin,
2506                          NULL);
2507           w -= 2 * (thick + margin);
2508         }
2509
2510       XtVaSetValues ((Widget) m_scrolledWindow, XmNwidth, w, NULL);
2511
2512       Dimension spacing;
2513       Widget sbar;
2514       XtVaGetValues ((Widget) m_scrolledWindow,
2515                      XmNspacing, &spacing,
2516                      XmNverticalScrollBar, &sbar,
2517                      NULL);
2518       Dimension wsbar;
2519       if (sbar)
2520         XtVaGetValues (sbar, XmNwidth, &wsbar, NULL);
2521       else
2522         wsbar = 0;
2523
2524       w -= (spacing + wsbar);
2525
2526       XtVaSetValues ((Widget) m_drawingArea, XmNwidth, w, NULL);
2527     }
2528   if (h > -1)
2529     {
2530       if (m_borderWidget)
2531         {
2532           XtVaSetValues ((Widget) m_borderWidget, XmNheight, h, NULL);
2533           short thick, margin;
2534           XtVaGetValues ((Widget) m_borderWidget,
2535                          XmNshadowThickness, &thick,
2536                          XmNmarginHeight, &margin,
2537                          NULL);
2538           h -= 2 * (thick + margin);
2539         }
2540
2541       XtVaSetValues ((Widget) m_scrolledWindow, XmNheight, h, NULL);
2542
2543       Dimension spacing;
2544       Widget sbar;
2545       XtVaGetValues ((Widget) m_scrolledWindow,
2546                      XmNspacing, &spacing,
2547                      XmNhorizontalScrollBar, &sbar,
2548                      NULL);
2549       Dimension wsbar;
2550       if (sbar)
2551         XtVaGetValues (sbar, XmNheight, &wsbar, NULL);
2552       else
2553         wsbar = 0;
2554
2555       h -= (spacing + wsbar);
2556
2557       XtVaSetValues ((Widget) m_drawingArea, XmNheight, h, NULL);
2558     }
2559   if (managed)
2560     XtManageChild (m_borderWidget ? (Widget) m_borderWidget : (Widget) m_scrolledWindow);
2561   XtVaSetValues((Widget) m_drawingArea, XmNresizePolicy, XmRESIZE_NONE, NULL);
2562
2563   int ww, hh;
2564   GetClientSize (&ww, &hh);
2565   wxSizeEvent sizeEvent(wxSize(ww, hh), GetId());
2566   sizeEvent.SetEventObject(this);
2567
2568   GetEventHandler()->ProcessEvent(sizeEvent);
2569 }
2570
2571 void wxWindow::CanvasSetClientSize (int w, int h)
2572 {
2573   Widget drawingArea = (Widget) m_drawingArea;
2574
2575   XtVaSetValues((Widget) m_drawingArea, XmNresizePolicy, XmRESIZE_ANY, NULL);
2576
2577   if (w > -1)
2578     XtVaSetValues ((Widget) m_drawingArea, XmNwidth, w, NULL);
2579   if (h > -1)
2580     XtVaSetValues ((Widget) m_drawingArea, XmNheight, h, NULL);
2581   /* TODO: is this necessary?
2582   allowRepainting = FALSE;
2583
2584   XSync (XtDisplay (drawingArea), FALSE);
2585   XEvent event;
2586   while (XtAppPending (wxTheApp->appContext))
2587     {
2588       XFlush (XtDisplay (drawingArea));
2589       XtAppNextEvent (wxTheApp->appContext, &event);
2590       XtDispatchEvent (&event);
2591     }
2592     */
2593
2594   XtVaSetValues((Widget) m_drawingArea, XmNresizePolicy, XmRESIZE_NONE, NULL);
2595
2596   /* TODO
2597   allowRepainting = TRUE;
2598   DoRefresh ();
2599   */
2600
2601   wxSizeEvent sizeEvent(wxSize(w, h), GetId());
2602   sizeEvent.SetEventObject(this);
2603
2604   GetEventHandler()->ProcessEvent(sizeEvent);
2605 }
2606
2607 void wxWindow::CanvasGetClientSize (int *w, int *h) const
2608 {
2609   // Must return the same thing that was set via SetClientSize
2610   Dimension xx, yy;
2611   XtVaGetValues ((Widget) m_drawingArea, XmNwidth, &xx, XmNheight, &yy, NULL);
2612   *w = xx;
2613   *h = yy;
2614 }
2615
2616 void wxWindow::CanvasGetSize (int *w, int *h) const
2617 {
2618   Dimension xx, yy;
2619   if ((Widget) m_borderWidget)
2620     XtVaGetValues ((Widget) m_borderWidget, XmNwidth, &xx, XmNheight, &yy, NULL);
2621   else if ((Widget) m_scrolledWindow)
2622     XtVaGetValues ((Widget) m_scrolledWindow, XmNwidth, &xx, XmNheight, &yy, NULL);
2623   else
2624     XtVaGetValues ((Widget) m_drawingArea, XmNwidth, &xx, XmNheight, &yy, NULL);
2625
2626   *w = xx;
2627   *h = yy;
2628 }
2629
2630 void wxWindow::CanvasGetPosition (int *x, int *y) const
2631 {
2632     Position xx, yy;
2633     XtVaGetValues (m_borderWidget ? (Widget) m_borderWidget : (Widget) m_scrolledWindow, XmNx, &xx, XmNy, &yy, NULL);
2634
2635     // We may be faking the client origin.
2636     // So a window that's really at (0, 30) may appear
2637     // (to wxWin apps) to be at (0, 0).
2638     if (GetParent())
2639     {
2640         wxPoint pt(GetParent()->GetClientAreaOrigin());
2641         xx -= pt.x;
2642         yy -= pt.y;
2643     }
2644
2645     *x = xx;
2646     *y = yy;
2647 }
2648
2649 // Add to hash table, add event handler
2650 bool wxWindow::AttachWidget (wxWindow* parent, WXWidget mainWidget,
2651               WXWidget formWidget, int x, int y, int width, int height)
2652 {
2653     wxAddWindowToTable((Widget) mainWidget, this);
2654     if (CanAddEventHandler())
2655     {
2656         XtAddEventHandler((Widget) mainWidget,
2657           ButtonPressMask | ButtonReleaseMask | PointerMotionMask, // | KeyPressMask,
2658         False,
2659         wxPanelItemEventHandler,
2660         (XtPointer) this);
2661     }
2662
2663     if (!formWidget)
2664     {
2665         XtTranslations ptr;
2666         XtOverrideTranslations ((Widget) mainWidget,
2667                ptr = XtParseTranslationTable ("<Configure>: resize()"));
2668         XtFree ((char *) ptr);
2669     }
2670
2671     // Some widgets have a parent form widget, e.g. wxRadioBox
2672     if (formWidget)
2673     {
2674       if (!wxAddWindowToTable((Widget) formWidget, this))
2675         return FALSE;
2676
2677       XtTranslations ptr;
2678       XtOverrideTranslations ((Widget) formWidget,
2679                    ptr = XtParseTranslationTable ("<Configure>: resize()"));
2680       XtFree ((char *) ptr);
2681     }
2682
2683     if (x == -1)
2684       x = 0;
2685     if (y == -1)
2686       y = 0;
2687     SetSize (x, y, width, height);
2688
2689     return TRUE;
2690 }
2691
2692 // Remove event handler, remove from hash table
2693 bool wxWindow::DetachWidget(WXWidget widget)
2694 {
2695     if (CanAddEventHandler())
2696     {
2697       XtRemoveEventHandler((Widget) widget,
2698          ButtonPressMask | ButtonReleaseMask | PointerMotionMask, // | KeyPressMask,
2699          False,
2700          wxPanelItemEventHandler,
2701          (XtPointer)this);
2702     }
2703
2704     wxDeleteWindowFromTable((Widget) widget);
2705     return TRUE;
2706 }
2707
2708 void wxPanelItemEventHandler (Widget    wid,
2709                               XtPointer client_data,
2710                               XEvent*   event,
2711                               Boolean *continueToDispatch)
2712 {
2713   // Widget can be a label or the actual widget.
2714
2715   wxWindow *window = (wxWindow *)wxWidgetHashTable->Get((long)wid);
2716   if (window)
2717   {
2718     wxMouseEvent wxevent(0);
2719     if (wxTranslateMouseEvent(wxevent, window, wid, event))
2720     {
2721       window->GetEventHandler()->ProcessEvent(wxevent);
2722     }
2723   }
2724   // TODO: probably the key to allowing default behaviour
2725   // to happen.
2726   // Say we set a m_doDefault flag to FALSE at the start of this
2727   // function. Then in e.g. wxWindow::OnMouseEvent we can
2728   // call Default() which sets this flag to TRUE, indicating
2729   // that default processing can happen. Thus, behaviour can appear
2730   // to be overridden just by adding an event handler and not calling
2731   // wxWindow::OnWhatever.
2732   // ALSO, maybe we can use this instead of the current way of handling
2733   // drawing area events, to simplify things.
2734   *continueToDispatch = True;
2735 }
2736
2737 void wxScrollBarCallback(Widget scrollbar, XtPointer clientData,
2738                         XmScaleCallbackStruct *cbs)
2739 {
2740     Widget scrolledWindow = XtParent (scrollbar);
2741     wxWindow *win = (wxWindow *) wxWidgetHashTable->Get ((long) scrolledWindow);
2742     int orientation = (int) clientData;
2743
2744     wxEventType eventType = wxEVT_NULL;
2745     switch (cbs->reason)
2746     {
2747         case XmCR_INCREMENT:
2748         {
2749             eventType = wxEVT_SCROLL_LINEDOWN;
2750             break;
2751         }
2752         case XmCR_DECREMENT:
2753         {
2754             eventType = wxEVT_SCROLL_LINEUP;
2755             break;
2756         }
2757         case XmCR_DRAG:
2758         {
2759             eventType = wxEVT_SCROLL_THUMBTRACK;
2760             break;
2761         }
2762         case XmCR_VALUE_CHANGED:
2763         {
2764             // TODO: Should this be intercepted too, or will it cause
2765             // duplicate events?
2766             eventType = wxEVT_SCROLL_THUMBTRACK;
2767             break;
2768         }
2769         case XmCR_PAGE_INCREMENT:
2770         {
2771             eventType = wxEVT_SCROLL_PAGEDOWN;
2772             break;
2773         }
2774         case XmCR_PAGE_DECREMENT:
2775         {
2776             eventType = wxEVT_SCROLL_PAGEUP;
2777             break;
2778         }
2779         case XmCR_TO_TOP:
2780         {
2781             eventType = wxEVT_SCROLL_TOP;
2782             break;
2783         }
2784         case XmCR_TO_BOTTOM:
2785         {
2786             eventType = wxEVT_SCROLL_BOTTOM;
2787             break;
2788         }
2789         default:
2790         {
2791             // Should never get here
2792             wxFAIL_MSG("Unknown scroll event.");
2793             break;
2794         }
2795     }
2796
2797     wxScrollEvent event(eventType, win->GetId());
2798     event.SetEventObject(win);
2799     event.SetPosition(cbs->value);
2800     event.SetOrientation( (orientation == XmHORIZONTAL) ? wxHORIZONTAL : wxVERTICAL );
2801
2802     win->GetEventHandler()->ProcessEvent(event);
2803 }
2804
2805 bool wxTranslateMouseEvent(wxMouseEvent& wxevent, wxWindow *win, Widget widget, XEvent *xevent)
2806 {
2807   switch (xevent->xany.type)
2808   {
2809     case EnterNotify:
2810     case LeaveNotify:
2811     case ButtonPress:
2812     case ButtonRelease:
2813     case MotionNotify:
2814       {
2815         wxEventType eventType = wxEVT_NULL;
2816
2817         if (xevent->xany.type == LeaveNotify)
2818         {
2819           win->m_button1Pressed = FALSE;
2820           win->m_button2Pressed = FALSE;
2821           win->m_button3Pressed = FALSE;
2822           return FALSE;
2823         }
2824         else if (xevent->xany.type == MotionNotify)
2825           {
2826             eventType = wxEVT_MOTION;
2827           }
2828         else if (xevent->xany.type == ButtonPress)
2829           {
2830             if (xevent->xbutton.button == Button1)
2831               {
2832                 eventType = wxEVT_LEFT_DOWN;
2833                 win->m_button1Pressed = TRUE;
2834               }
2835             else if (xevent->xbutton.button == Button2)
2836               {
2837                 eventType = wxEVT_MIDDLE_DOWN;
2838                 win->m_button2Pressed = TRUE;
2839               }
2840             else if (xevent->xbutton.button == Button3)
2841               {
2842                 eventType = wxEVT_RIGHT_DOWN;
2843                 win->m_button3Pressed = TRUE;
2844               }
2845           }
2846         else if (xevent->xany.type == ButtonRelease)
2847           {
2848             if (xevent->xbutton.button == Button1)
2849               {
2850                 eventType = wxEVT_LEFT_UP;
2851                 win->m_button1Pressed = FALSE;
2852               }
2853             else if (xevent->xbutton.button == Button2)
2854               {
2855                 eventType = wxEVT_MIDDLE_UP;
2856                 win->m_button2Pressed = FALSE;
2857               }
2858             else if (xevent->xbutton.button == Button3)
2859               {
2860                 eventType = wxEVT_RIGHT_UP;
2861                 win->m_button3Pressed = FALSE;
2862               }
2863             else return FALSE;
2864           }
2865           else return FALSE;
2866
2867         wxevent.m_eventHandle = (char *)xevent;
2868         wxevent.SetEventType(eventType);
2869
2870         Position x1, y1;
2871         XtVaGetValues(widget, XmNx, &x1, XmNy, &y1, NULL);
2872
2873         int x2, y2;
2874         win->GetPosition(&x2, &y2);
2875
2876         // The button x/y must be translated to wxWindows
2877         // window space - the widget might be a label or button,
2878         // within a form.
2879         int dx = 0;
2880         int dy = 0;
2881         if (widget != (Widget)win->GetMainWidget())
2882         {
2883           dx = x1;
2884           dy = y1;
2885         }
2886
2887         wxevent.m_x = xevent->xbutton.x + dx;
2888         wxevent.m_y = xevent->xbutton.y + dy;
2889
2890         wxevent.m_leftDown = ((eventType == wxEVT_LEFT_DOWN)
2891                             || (event_left_is_down (xevent)
2892                                 && (eventType != wxEVT_LEFT_UP)));
2893         wxevent.m_middleDown = ((eventType == wxEVT_MIDDLE_DOWN)
2894                               || (event_middle_is_down (xevent)
2895                                   && (eventType != wxEVT_MIDDLE_UP)));
2896         wxevent.m_rightDown = ((eventType == wxEVT_RIGHT_DOWN)
2897                              || (event_right_is_down (xevent)
2898                                  && (eventType != wxEVT_RIGHT_UP)));
2899
2900         wxevent.m_shiftDown = xevent->xbutton.state & ShiftMask;
2901         wxevent.m_controlDown = xevent->xbutton.state & ControlMask;
2902         return TRUE;
2903     }
2904   }
2905   return FALSE;
2906 }
2907
2908 bool wxTranslateKeyEvent(wxKeyEvent& wxevent, wxWindow *win, Widget widget, XEvent *xevent)
2909 {
2910   switch (xevent->xany.type)
2911   {
2912     case KeyPress:
2913       {
2914         char buf[20];
2915
2916         KeySym keySym;
2917 //      XComposeStatus compose;
2918 //      (void) XLookupString ((XKeyEvent *) xevent, buf, 20, &keySym, &compose);
2919         (void) XLookupString ((XKeyEvent *) xevent, buf, 20, &keySym, NULL);
2920         int id = wxCharCodeXToWX (keySym);
2921
2922         if (xevent->xkey.state & ShiftMask)
2923           wxevent.m_shiftDown = TRUE;
2924         if (xevent->xkey.state & ControlMask)
2925           wxevent.m_controlDown = TRUE;
2926         if (xevent->xkey.state & Mod3Mask)
2927           wxevent.m_altDown = TRUE;
2928         if (xevent->xkey.state & Mod1Mask)
2929           wxevent.m_metaDown = TRUE;
2930         wxevent.SetEventObject(win);
2931         wxevent.m_keyCode = id;
2932         wxevent.SetTimestamp(xevent->xkey.time);
2933
2934         wxevent.m_x = xevent->xbutton.x;
2935         wxevent.m_y = xevent->xbutton.y;
2936
2937         if (id > -1)
2938           return TRUE;
2939         else
2940           return FALSE;
2941         break;
2942       }
2943     default:
2944       break;
2945   }
2946   return FALSE;
2947 }
2948
2949 #define YAllocColor XAllocColor
2950 XColor g_itemColors[5];
2951 int wxComputeColours (Display *display, wxColour * back, wxColour * fore)
2952 {
2953   int result;
2954   static XmColorProc colorProc;
2955
2956   result = wxNO_COLORS;
2957
2958   if (back)
2959     {
2960       g_itemColors[0].red = (((long) back->Red ()) << 8);
2961       g_itemColors[0].green = (((long) back->Green ()) << 8);
2962       g_itemColors[0].blue = (((long) back->Blue ()) << 8);
2963       g_itemColors[0].flags = DoRed | DoGreen | DoBlue;
2964       if (colorProc == (XmColorProc) NULL)
2965         {
2966           // Get a ptr to the actual function
2967           colorProc = XmSetColorCalculation ((XmColorProc) NULL);
2968           // And set it back to motif.
2969           XmSetColorCalculation (colorProc);
2970         }
2971       (*colorProc) (&g_itemColors[wxBACK_INDEX],
2972                     &g_itemColors[wxFORE_INDEX],
2973                     &g_itemColors[wxSELE_INDEX],
2974                     &g_itemColors[wxTOPS_INDEX],
2975                     &g_itemColors[wxBOTS_INDEX]);
2976       result = wxBACK_COLORS;
2977     }
2978   if (fore)
2979     {
2980       g_itemColors[wxFORE_INDEX].red = (((long) fore->Red ()) << 8);
2981       g_itemColors[wxFORE_INDEX].green = (((long) fore->Green ()) << 8);
2982       g_itemColors[wxFORE_INDEX].blue = (((long) fore->Blue ()) << 8);
2983       g_itemColors[wxFORE_INDEX].flags = DoRed | DoGreen | DoBlue;
2984       if (result == wxNO_COLORS)
2985         result = wxFORE_COLORS;
2986     }
2987
2988   Display *dpy = display;
2989   Colormap cmap = (Colormap) wxTheApp->GetMainColormap((WXDisplay*) dpy);
2990
2991   if (back)
2992     {
2993       /* 5 Colours to allocate */
2994       for (int i = 0; i < 5; i++)
2995         if (!YAllocColor (dpy, cmap, &g_itemColors[i]))
2996           result = wxNO_COLORS;
2997     }
2998   else if (fore)
2999     {
3000       /* Only 1 colour to allocate */
3001       if (!YAllocColor (dpy, cmap, &g_itemColors[wxFORE_INDEX]))
3002         result = wxNO_COLORS;
3003     }
3004
3005   return (result);
3006
3007 }
3008
3009 // Changes the foreground and background colours to be derived
3010 // from the current background colour.
3011 // To change the foreground colour, you must call SetForegroundColour
3012 // explicitly.
3013 void wxWindow::ChangeBackgroundColour()
3014 {
3015     if (GetMainWidget())
3016         DoChangeBackgroundColour(GetMainWidget(), m_backgroundColour);
3017 }
3018
3019 void wxWindow::ChangeForegroundColour()
3020 {
3021     if (GetMainWidget())
3022         DoChangeForegroundColour(GetMainWidget(), m_foregroundColour);
3023 }
3024
3025 // Change a widget's foreground and background colours.
3026
3027 void wxWindow::DoChangeForegroundColour(WXWidget widget, wxColour& foregroundColour)
3028 {
3029   // When should we specify the foreground, if it's calculated
3030   // by wxComputeColours?
3031   // Solution: say we start with the default (computed) foreground colour.
3032   // If we call SetForegroundColour explicitly for a control or window,
3033   // then the foreground is changed.
3034   // Therefore SetBackgroundColour computes the foreground colour, and
3035   // SetForegroundColour changes the foreground colour. The ordering is
3036   // important.
3037
3038   XtVaSetValues ((Widget) widget,
3039                    XmNforeground, foregroundColour.AllocColour(XtDisplay((Widget) widget)),
3040                    NULL);
3041 }
3042
3043 void wxWindow::DoChangeBackgroundColour(WXWidget widget, wxColour& backgroundColour, bool changeArmColour)
3044 {
3045   wxComputeColours (XtDisplay((Widget) widget), & backgroundColour,
3046                             (wxColour*) NULL);
3047
3048   XtVaSetValues ((Widget) widget,
3049                    XmNbackground, g_itemColors[wxBACK_INDEX].pixel,
3050                    XmNtopShadowColor, g_itemColors[wxTOPS_INDEX].pixel,
3051                    XmNbottomShadowColor, g_itemColors[wxBOTS_INDEX].pixel,
3052                    XmNforeground, g_itemColors[wxFORE_INDEX].pixel,
3053                    NULL);
3054
3055   if (changeArmColour)
3056     XtVaSetValues ((Widget) widget,
3057                    XmNarmColor, g_itemColors[wxSELE_INDEX].pixel,
3058                NULL);
3059 }
3060
3061 void wxWindow::SetBackgroundColour(const wxColour& col)
3062 {
3063     m_backgroundColour = col;
3064     ChangeBackgroundColour();
3065 }
3066
3067 void wxWindow::SetForegroundColour(const wxColour& col)
3068 {
3069     m_foregroundColour = col;
3070     ChangeForegroundColour();
3071 }
3072
3073 void wxWindow::ChangeFont(bool keepOriginalSize)
3074 {
3075     // Note that this causes the widget to be resized back
3076     // to its original size! We therefore have to set the size
3077     // back again. TODO: a better way in Motif?
3078     Widget w = (Widget) GetLabelWidget(); // Usually the main widget
3079     if (w && m_windowFont.Ok())
3080     {
3081         int width, height, width1, height1;
3082         GetSize(& width, & height);
3083
3084         XtVaSetValues (w,
3085                    XmNfontList, (XmFontList) m_windowFont.GetFontList(1.0, XtDisplay(w)),
3086                    NULL);
3087
3088         GetSize(& width1, & height1);
3089         if (keepOriginalSize && (width != width1 || height != height1))
3090         {
3091             SetSize(-1, -1, width, height);
3092         }
3093     }
3094 }
3095
3096 void wxWindow::SetFont(const wxFont& font)
3097 {
3098     m_windowFont = font;
3099     ChangeFont();
3100 }
3101
3102