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