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 static 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     m_clientObject = (wxClientData*) NULL;
 112     m_clientData = NULL;
 113
 114     /// Motif-specific
 115     m_mainWidget = (WXWidget) 0;
 116     m_button1Pressed = FALSE;
 117     m_button2Pressed = FALSE;
 118     m_button3Pressed = FALSE;
 119     m_winCaptured = FALSE;
 120     m_isShown = TRUE;
 121     m_hScrollBar = (WXWidget) 0;
 122     m_vScrollBar = (WXWidget) 0;
 123     m_borderWidget = (WXWidget) 0;
 124     m_scrolledWindow = (WXWidget) 0;
 125     m_drawingArea = (WXWidget) 0;
 126     m_hScroll = FALSE;
 127     m_vScroll = FALSE;
 128     m_backingPixmap = (WXPixmap) 0;
 129     m_pixmapWidth = 0;
 130     m_pixmapHeight = 0;
 131     m_pixmapOffsetX = 0;
 132     m_pixmapOffsetY = 0;
 133     m_lastTS = 0;
 134     m_lastButton = 0;
 135     m_canAddEventHandler = FALSE;
 136     m_scrollPosX = 0;
 137     m_scrollPosY = 0;
 138 }
 139
 140 // Destructor
 141 wxWindow::~wxWindow()
 142 {
 143     //// Motif-specific
 144
 145     if (GetMainWidget())
 146         DetachWidget(GetMainWidget()); // Removes event handlers
 147
 148     // If m_drawingArea, we're a fully-fledged window with drawing area, scrollbars etc. (what wxCanvas used to be)
 149     if (m_drawingArea)
 150     {
 151         // Destroy children before destroying self
 152         DestroyChildren();
 153
 154         if (m_backingPixmap)
 155         XFreePixmap (XtDisplay ((Widget) GetMainWidget()), (Pixmap) m_backingPixmap);
 156
 157         Widget w = (Widget) m_drawingArea;
 158         wxDeleteWindowFromTable(w);
 159
 160         if (w)
 161             XtDestroyWidget(w);
 162         m_mainWidget = (WXWidget) 0;
 163
 164         // Only if we're _really_ a canvas (not a dialog box/panel)
 165         if (m_scrolledWindow)
 166         {
 167             wxDeleteWindowFromTable((Widget) m_scrolledWindow);
 168         }
 169
 170         if (m_hScrollBar)
 171         {
 172             XtUnmanageChild ((Widget) m_hScrollBar);
 173             XtDestroyWidget ((Widget) m_hScrollBar);
 174         }
 175         if (m_vScrollBar)
 176         {
 177             XtUnmanageChild ((Widget) m_vScrollBar);
 178             XtDestroyWidget ((Widget) m_vScrollBar);
 179         }
 180         if (m_scrolledWindow)
 181         {
 182             XtUnmanageChild ((Widget) m_scrolledWindow);
 183             XtDestroyWidget ((Widget) m_scrolledWindow);
 184         }
 185
 186         if (m_borderWidget)
 187         {
 188             XtDestroyWidget ((Widget) m_borderWidget);
 189             m_borderWidget = (WXWidget) 0;
 190         }
 191     }
 192
 193     //// Generic stuff
 194
 195         // Have to delete constraints/sizer FIRST otherwise
 196         // sizers may try to look at deleted windows as they
 197         // delete themselves.
 198 #if wxUSE_CONSTRAINTS
 199     DeleteRelatedConstraints();
 200     if (m_constraints)
 201     {
 202         // This removes any dangling pointers to this window
 203         // in other windows' constraintsInvolvedIn lists.
 204         UnsetConstraints(m_constraints);
 205         delete m_constraints;
 206         m_constraints = NULL;
 207     }
 208     if (m_windowSizer)
 209     {
 210         delete m_windowSizer;
 211         m_windowSizer = NULL;
 212     }
 213     // If this is a child of a sizer, remove self from parent
 214     if (m_sizerParent)
 215         m_sizerParent->RemoveChild((wxWindow *)this);
 216 #endif
 217
 218     if (m_windowParent)
 219         m_windowParent->RemoveChild(this);
 220
 221     DestroyChildren();
 222
 223     // Destroy the window
 224     if (GetMainWidget())
 225     {
 226       wxDeleteWindowFromTable((Widget) GetMainWidget());
 227       XtDestroyWidget((Widget) GetMainWidget());
 228       SetMainWidget((WXWidget) NULL);
 229     }
 230
 231     delete m_children;
 232     m_children = NULL;
 233
 234     // Just in case the window has been Closed, but
 235     // we're then deleting immediately: don't leave
 236     // dangling pointers.
 237     wxPendingDelete.DeleteObject(this);
 238
 239     if ( m_windowValidator ) delete m_windowValidator;
 240     if (m_clientObject) delete m_clientObject;
 241
 242     ClearUpdateRects();
 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 wxUSE_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     m_clientObject = (wxClientData*) NULL;
 285     m_clientData = NULL;
 286
 287     // Motif-specific
 288     m_canAddEventHandler = FALSE;
 289     m_mainWidget = (WXWidget) 0;
 290     m_button1Pressed = FALSE;
 291     m_button2Pressed = FALSE;
 292     m_button3Pressed = FALSE;
 293     m_winCaptured = FALSE;
 294     m_isShown = TRUE;
 295     m_hScrollBar = (WXWidget) 0;
 296     m_vScrollBar = (WXWidget) 0;
 297     m_borderWidget = (WXWidget) 0;
 298     m_scrolledWindow = (WXWidget) 0;
 299     m_drawingArea = (WXWidget) 0;
 300     m_hScroll = FALSE;
 301     m_vScroll = FALSE;
 302     m_backingPixmap = (WXPixmap) 0;
 303     m_pixmapWidth = 0;
 304     m_pixmapHeight = 0;
 305     m_pixmapOffsetX = 0;
 306     m_pixmapOffsetY = 0;
 307     m_scrollPosX = 0;
 308     m_scrollPosY = 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            if (m_drawingArea)
 744              XtMapWidget((Widget) m_drawingArea);
 745            XtMapWidget(m_borderWidget ? (Widget) m_borderWidget : (Widget) m_scrolledWindow);
 746        }
 747        else
 748        {
 749            XtMapWidget((Widget) GetTopWidget());
 750        }
 751     }
 752     else
 753     {
 754        if (m_borderWidget || m_scrolledWindow)
 755        {
 756            if (m_drawingArea)
 757              XtUnmapWidget((Widget) m_drawingArea);
 758            XtUnmapWidget(m_borderWidget ? (Widget) m_borderWidget : (Widget) m_scrolledWindow);
 759        }
 760        else
 761        {
 762            XtUnmapWidget((Widget) GetTopWidget());
 763        }
 764     }
 765
 766   /*
 767     Window xwin = (Window) GetXWindow();
 768     Display *xdisp = (Display*) GetXDisplay();
 769     if (show)
 770         XMapWindow(xdisp, xwin);
 771     else
 772         XUnmapWindow(xdisp, xwin);
 773    */
 774
 775     m_isShown = show;
 776
 777     return TRUE;
 778 }
 779
 780 bool wxWindow::IsShown() const
 781 {
 782     return m_isShown;
 783 }
 784
 785 int wxWindow::GetCharHeight() const
 786 {
 787   if (!m_windowFont.Ok())
 788     return 0;
 789
 790   WXFontStructPtr pFontStruct = m_windowFont.GetFontStruct(1.0, GetXDisplay());
 791
 792   int direction, ascent, descent;
 793   XCharStruct overall;
 794   XTextExtents ((XFontStruct*) pFontStruct, "x", 1, &direction, &ascent,
 795         &descent, &overall);
 796 //  return (overall.ascent + overall.descent);
 797   return (ascent + descent);
 798 }
 799
 800 int wxWindow::GetCharWidth() const
 801 {
 802   if (!m_windowFont.Ok())
 803     return 0;
 804
 805   WXFontStructPtr pFontStruct = m_windowFont.GetFontStruct(1.0, GetXDisplay());
 806
 807   int direction, ascent, descent;
 808   XCharStruct overall;
 809   XTextExtents ((XFontStruct*) pFontStruct, "x", 1, &direction, &ascent,
 810         &descent, &overall);
 811   return overall.width;
 812 }
 813
 814 /* Helper function for 16-bit fonts */
 815 static int str16len(const char *s)
 816 {
 817   int count = 0;
 818
 819   while (s[0] && s[1]) {
 820     count++;
 821     s += 2;
 822   }
 823
 824   return count;
 825 }
 826
 827 void wxWindow::GetTextExtent(const wxString& string, int *x, int *y,
 828                            int *descent, int *externalLeading, const wxFont *theFont, bool use16) const
 829 {
 830   wxFont *fontToUse = (wxFont *)theFont;
 831   if (!fontToUse)
 832     fontToUse = (wxFont *) & m_windowFont;
 833
 834   if (!fontToUse->Ok())
 835     return;
 836
 837   WXFontStructPtr pFontStruct = theFont->GetFontStruct(1.0, GetXDisplay());
 838
 839   int direction, ascent, descent2;
 840   XCharStruct overall;
 841   int slen;
 842
 843   if (use16) slen = str16len(string); else slen = strlen(string);
 844
 845   if (use16)
 846     XTextExtents16((XFontStruct*) pFontStruct, (XChar2b *) (char*) (const char*) string, slen, &direction,
 847            &ascent, &descent2, &overall);
 848   else
 849      XTextExtents((XFontStruct*) pFontStruct, (char*) (const char*) string, slen, &direction,
 850          &ascent, &descent2, &overall);
 851
 852   *x = (overall.width);
 853   *y = (ascent + descent2);
 854   if (descent)
 855     *descent = descent2;
 856   if (externalLeading)
 857     *externalLeading = 0;
 858 }
 859
 860 void wxWindow::Refresh(bool eraseBack, const wxRectangle *rect)
 861 {
 862     Display *display = XtDisplay((Widget) GetMainWidget());
 863     Window thisWindow = XtWindow((Widget) GetMainWidget());
 864
 865     XExposeEvent dummyEvent;
 866     int width, height;
 867     GetSize(&width, &height);
 868
 869     dummyEvent.type = Expose;
 870     dummyEvent.display = display;
 871     dummyEvent.send_event = True;
 872     dummyEvent.window = thisWindow;
 873     if (rect)
 874     {
 875       dummyEvent.x = rect->x;
 876       dummyEvent.y = rect->y;
 877       dummyEvent.width = rect->width;
 878       dummyEvent.height = rect->height;
 879     }
 880     else
 881     {
 882       dummyEvent.x = 0;
 883       dummyEvent.y = 0;
 884       dummyEvent.width = width;
 885       dummyEvent.height = height;
 886     }
 887     dummyEvent.count = 0;
 888
 889     if (eraseBack)
 890     {
 891         wxClientDC dc(this);
 892         wxBrush backgroundBrush(GetBackgroundColour(), wxSOLID);
 893         dc.SetBackground(backgroundBrush);
 894         dc.Clear();
 895     }
 896
 897     XSendEvent(display, thisWindow, False, ExposureMask, (XEvent *)&dummyEvent);
 898 }
 899
 900 // Responds to colour changes: passes event on to children.
 901 void wxWindow::OnSysColourChanged(wxSysColourChangedEvent& event)
 902 {
 903     wxNode *node = GetChildren()->First();
 904     while ( node )
 905     {
 906         // Only propagate to non-top-level windows
 907         wxWindow *win = (wxWindow *)node->Data();
 908         if ( win->GetParent() )
 909         {
 910             wxSysColourChangedEvent event2;
 911             event.m_eventObject = win;
 912             win->GetEventHandler()->ProcessEvent(event2);
 913         }
 914
 915         node = node->Next();
 916     }
 917 }
 918
 919 // This can be called by the app (or wxWindows) to do default processing for the current
 920 // event. Save message/event info in wxWindow so they can be used in this function.
 921 long wxWindow::Default()
 922 {
 923     // TODO
 924     return 0;
 925 }
 926
 927 void wxWindow::InitDialog()
 928 {
 929   wxInitDialogEvent event(GetId());
 930   event.SetEventObject( this );
 931   GetEventHandler()->ProcessEvent(event);
 932 }
 933
 934 // Default init dialog behaviour is to transfer data to window
 935 void wxWindow::OnInitDialog(wxInitDialogEvent& event)
 936 {
 937   TransferDataToWindow();
 938 }
 939
 940 // Caret manipulation
 941 void wxWindow::CreateCaret(int w, int h)
 942 {
 943   m_caretWidth = w;
 944   m_caretHeight = h;
 945   m_caretEnabled = TRUE;
 946 }
 947
 948 void wxWindow::CreateCaret(const wxBitmap *WXUNUSED(bitmap))
 949 {
 950     // TODO
 951 }
 952
 953 void wxWindow::ShowCaret(bool show)
 954 {
 955     // TODO
 956 }
 957
 958 void wxWindow::DestroyCaret()
 959 {
 960     // TODO
 961     m_caretEnabled = FALSE;
 962 }
 963
 964 void wxWindow::SetCaretPos(int x, int y)
 965 {
 966     // TODO
 967 }
 968
 969 void wxWindow::GetCaretPos(int *x, int *y) const
 970 {
 971     // TODO
 972 }
 973
 974 wxWindow *wxGetActiveWindow()
 975 {
 976     // TODO
 977     return NULL;
 978 }
 979
 980 void wxWindow::SetSizeHints(int minW, int minH, int maxW, int maxH, int incW, int incH)
 981 {
 982     m_minSizeX = minW;
 983     m_minSizeY = minH;
 984     m_maxSizeX = maxW;
 985     m_maxSizeY = maxH;
 986
 987     if (!this->IsKindOf(CLASSINFO(wxFrame)))
 988       return;
 989
 990     wxFrame *frame = (wxFrame *)this;
 991     Widget widget = (Widget) frame->GetShellWidget();
 992
 993     if (minW > -1)
 994       XtVaSetValues(widget, XmNminWidth, minW, NULL);
 995     if (minH > -1)
 996       XtVaSetValues(widget, XmNminHeight, minH, NULL);
 997     if (maxW > -1)
 998       XtVaSetValues(widget, XmNmaxWidth, maxW, NULL);
 999     if (maxH > -1)
1000       XtVaSetValues(widget, XmNmaxHeight, maxH, NULL);
1001     if (incW > -1)
1002       XtVaSetValues(widget, XmNwidthInc, incW, NULL);
1003     if (incH > -1)
1004       XtVaSetValues(widget, XmNheightInc, incH, NULL);
1005 }
1006
1007 void wxWindow::Centre(int direction)
1008 {
1009   int x, y, width, height, panel_width, panel_height, new_x, new_y;
1010
1011   wxWindow *father = (wxWindow *)GetParent();
1012   if (!father)
1013     return;
1014
1015   father->GetClientSize(&panel_width, &panel_height);
1016   GetSize(&width, &height);
1017   GetPosition(&x, &y);
1018
1019   new_x = -1;
1020   new_y = -1;
1021
1022   if (direction & wxHORIZONTAL)
1023     new_x = (int)((panel_width - width)/2);
1024
1025   if (direction & wxVERTICAL)
1026     new_y = (int)((panel_height - height)/2);
1027
1028   SetSize(new_x, new_y, -1, -1);
1029
1030 }
1031
1032 // Coordinates relative to the window
1033 void wxWindow::WarpPointer (int x, int y)
1034 {
1035   XWarpPointer (XtDisplay((Widget) GetClientWidget()), None, XtWindow((Widget) GetClientWidget()), 0, 0, 0, 0, x, y);
1036 }
1037
1038 void wxWindow::OnEraseBackground(wxEraseEvent& event)
1039 {
1040     // TODO
1041     Default();
1042 }
1043
1044 int wxWindow::GetScrollPos(int orient) const
1045 {
1046     if (orient == wxHORIZONTAL)
1047         return m_scrollPosX;
1048     else
1049         return m_scrollPosY;
1050 /*
1051         Widget scrollBar = (Widget) ((orient == wxHORIZONTAL) ? m_hScrollBar : m_vScrollBar);
1052         if (scrollBar)
1053         {
1054         int pos;
1055         XtVaGetValues(scrollBar,
1056             XmNvalue, &pos, NULL);
1057         return pos;
1058     }
1059     else
1060         return 0;
1061 */
1062 }
1063
1064 // This now returns the whole range, not just the number
1065 // of positions that we can scroll.
1066 int wxWindow::GetScrollRange(int orient) const
1067 {
1068         Widget scrollBar = (Widget) ((orient == wxHORIZONTAL) ? m_hScrollBar : m_vScrollBar);
1069         if (scrollBar)
1070         {
1071         int range;
1072         XtVaGetValues(scrollBar,
1073             XmNmaximum, &range, NULL);
1074         return range;
1075     }
1076     else
1077         return 0;
1078 }
1079
1080 int wxWindow::GetScrollThumb(int orient) const
1081 {
1082         Widget scrollBar = (Widget) ((orient == wxHORIZONTAL) ? m_hScrollBar : m_vScrollBar);
1083         if (scrollBar)
1084         {
1085         int thumb;
1086         XtVaGetValues(scrollBar,
1087             XmNsliderSize, &thumb, NULL);
1088         return thumb;
1089     }
1090     else
1091         return 0;
1092 }
1093
1094 void wxWindow::SetScrollPos(int orient, int pos, bool WXUNUSED(refresh))
1095 {
1096         Widget scrollBar = (Widget) ((orient == wxHORIZONTAL) ? m_hScrollBar : m_vScrollBar);
1097         if (scrollBar)
1098         {
1099                 XtVaSetValues (scrollBar,
1100                                 XmNvalue, pos,
1101                                 NULL);
1102         }
1103         if (orient == wxHORIZONTAL)
1104           m_scrollPosX = pos;
1105         else
1106           m_scrollPosY = pos;
1107
1108 }
1109
1110 // New function that will replace some of the above.
1111 void wxWindow::SetScrollbar(int orient, int pos, int thumbVisible,
1112     int range, bool WXUNUSED(refresh))
1113 {
1114     Widget scrollBar = (Widget) ((orient == wxHORIZONTAL) ? m_hScrollBar : m_vScrollBar );
1115     if (!scrollBar)
1116         return;
1117
1118     if (range == 0)
1119       range = 1;
1120     if (thumbVisible == 0)
1121       thumbVisible = 1;
1122
1123     XtVaSetValues(scrollBar,
1124          XmNvalue, pos,
1125          XmNminimum, 0,
1126          XmNmaximum, range,
1127          XmNsliderSize, thumbVisible,
1128          NULL);
1129
1130     if (orient == wxHORIZONTAL)
1131         m_scrollPosX = pos;
1132     else
1133         m_scrollPosY = pos;
1134 }
1135
1136 // Does a physical scroll
1137 void wxWindow::ScrollWindow(int dx, int dy, const wxRectangle *rect)
1138 {
1139 //  cerr << "Scrolling. delta = " << dx << ", " << dy << endl;
1140   int x, y, w, h;
1141   if (rect)
1142   {
1143     // Use specified rectangle
1144     x = rect->x; y = rect->y; w = rect->width; h = rect->height;
1145   }
1146   else
1147   {
1148     // Use whole client area
1149     x = 0; y = 0;
1150     GetClientSize(& w, & h);
1151   }
1152
1153   int x1 = (dx >= 0) ? x : x - dx ;
1154   int y1 = (dy >= 0) ? y : y - dy;
1155   int w1 = w - abs(dx);
1156   int h1 = h - abs(dy);
1157   int x2 = (dx >= 0) ? x + dx : x;
1158   int y2 = (dy >= 0) ? y + dy : y;
1159
1160   wxClientDC dc(this);
1161
1162   dc.SetLogicalFunction (wxCOPY);
1163
1164   Widget widget = (Widget) GetMainWidget();
1165   Window window = XtWindow(widget);
1166   Display* display = XtDisplay(widget);
1167
1168   XCopyArea(display, window,
1169     window, (GC) dc.GetGC(),
1170     x1, y1,
1171     w1, h1,
1172     x2, y2);
1173
1174   dc.SetAutoSetting(TRUE);
1175   wxBrush brush(GetBackgroundColour(), wxSOLID);
1176   dc.SetBrush(brush); // ??
1177
1178   // We'll add rectangles to the list of update rectangles
1179   // according to which bits we've exposed.
1180   wxList updateRects;
1181
1182   if (dx > 0)
1183   {
1184     wxRect *rect = new wxRect;
1185     rect->x = x;
1186     rect->y = y;
1187     rect->width = dx;
1188     rect->height = h;
1189
1190     XFillRectangle(display, window,
1191       (GC) dc.GetGC(), rect->x, rect->y, rect->width, rect->height);
1192
1193     rect->x = rect->x;
1194     rect->y = rect->y;
1195     rect->width = rect->width;
1196     rect->height = rect->height;
1197
1198     updateRects.Append((wxObject*) rect);
1199   }
1200   else if (dx < 0)
1201   {
1202     wxRect *rect = new wxRect;
1203
1204     rect->x = x + w + dx;
1205     rect->y = y;
1206     rect->width = -dx;
1207     rect->height = h;
1208
1209     XFillRectangle(display, window,
1210       (GC) dc.GetGC(), rect->x, rect->y, rect->width,
1211       rect->height);
1212
1213     rect->x = rect->x;
1214     rect->y = rect->y;
1215     rect->width = rect->width;
1216     rect->height = rect->height;
1217
1218     updateRects.Append((wxObject*) rect);
1219   }
1220   if (dy > 0)
1221   {
1222     wxRect *rect = new wxRect;
1223
1224     rect->x = x;
1225     rect->y = y;
1226     rect->width = w;
1227     rect->height = dy;
1228
1229     XFillRectangle(display, window,
1230       (GC) dc.GetGC(), rect->x, rect->y, rect->width, rect->height);
1231
1232     rect->x = rect->x;
1233     rect->y = rect->y;
1234     rect->width = rect->width;
1235     rect->height = rect->height;
1236
1237     updateRects.Append((wxObject*) rect);
1238   }
1239   else if (dy < 0)
1240   {
1241     wxRect *rect = new wxRect;
1242
1243     rect->x = x;
1244     rect->y = y + h + dy;
1245     rect->width = w;
1246     rect->height = -dy;
1247
1248     XFillRectangle(display, window,
1249       (GC) dc.GetGC(), rect->x, rect->y, rect->width, rect->height);
1250
1251     rect->x = rect->x;
1252     rect->y = rect->y;
1253     rect->width = rect->width;
1254     rect->height = rect->height;
1255
1256     updateRects.Append((wxObject*) rect);
1257   }
1258   dc.SetBrush(wxNullBrush);
1259
1260   // Now send expose events
1261
1262   wxNode* node = updateRects.First();
1263   while (node)
1264   {
1265     wxRect* rect = (wxRect*) node->Data();
1266     XExposeEvent event;
1267
1268     event.type = Expose;
1269     event.display = display;
1270     event.send_event = True;
1271     event.window = window;
1272
1273     event.x = rect->x;
1274     event.y = rect->y;
1275     event.width = rect->width;
1276     event.height = rect->height;
1277
1278     event.count = 0;
1279
1280     XSendEvent(display, window, False, ExposureMask, (XEvent *)&event);
1281
1282     node = node->Next();
1283
1284   }
1285 }
1286
1287 void wxWindow::OnChar(wxKeyEvent& event)
1288 {
1289     if ( event.KeyCode() == WXK_TAB ) {
1290         // propagate the TABs to the parent - it's up to it to decide what
1291         // to do with it
1292         if ( GetParent() ) {
1293             if ( GetParent()->ProcessEvent(event) )
1294                 return;
1295         }
1296     }
1297 }
1298
1299 void wxWindow::OnPaint(wxPaintEvent& event)
1300 {
1301         Default();
1302 }
1303
1304 bool wxWindow::IsEnabled() const
1305 {
1306     // TODO. Is this right?
1307     // return XtGetSensitive((Widget) GetMainWidget());
1308     return FALSE;
1309 }
1310
1311 // Dialog support: override these and call
1312 // base class members to add functionality
1313 // that can't be done using validators.
1314 // NOTE: these functions assume that controls
1315 // are direct children of this window, not grandchildren
1316 // or other levels of descendant.
1317
1318 // Transfer values to controls. If returns FALSE,
1319 // it's an application error (pops up a dialog)
1320 bool wxWindow::TransferDataToWindow()
1321 {
1322         wxNode *node = GetChildren()->First();
1323         while ( node )
1324         {
1325                 wxWindow *child = (wxWindow *)node->Data();
1326                 if ( child->GetValidator() &&
1327                      !child->GetValidator()->TransferToWindow() )
1328                 {
1329                         wxMessageBox("Application Error", "Could not transfer data to window", wxOK|wxICON_EXCLAMATION);
1330                         return FALSE;
1331                 }
1332
1333                 node = node->Next();
1334         }
1335         return TRUE;
1336 }
1337
1338 // Transfer values from controls. If returns FALSE,
1339 // validation failed: don't quit
1340 bool wxWindow::TransferDataFromWindow()
1341 {
1342         wxNode *node = GetChildren()->First();
1343         while ( node )
1344         {
1345                 wxWindow *child = (wxWindow *)node->Data();
1346                 if ( child->GetValidator() && !child->GetValidator()->TransferFromWindow() )
1347                 {
1348                         return FALSE;
1349                 }
1350
1351                 node = node->Next();
1352         }
1353         return TRUE;
1354 }
1355
1356 bool wxWindow::Validate()
1357 {
1358         wxNode *node = GetChildren()->First();
1359         while ( node )
1360         {
1361                 wxWindow *child = (wxWindow *)node->Data();
1362                 if ( child->GetValidator() && /* child->GetValidator()->Ok() && */ !child->GetValidator()->Validate(this) )
1363                 {
1364                         return FALSE;
1365                 }
1366
1367                 node = node->Next();
1368         }
1369         return TRUE;
1370 }
1371
1372 // Get the window with the focus
1373 wxWindow *wxWindow::FindFocus()
1374 {
1375     // TODO
1376     return NULL;
1377 }
1378
1379 void wxWindow::AddChild(wxWindow *child)
1380 {
1381     GetChildren()->Append(child);
1382     child->m_windowParent = this;
1383 }
1384
1385 void wxWindow::RemoveChild(wxWindow *child)
1386 {
1387     if (GetChildren())
1388         GetChildren()->DeleteObject(child);
1389     child->m_windowParent = NULL;
1390 }
1391
1392 void wxWindow::DestroyChildren()
1393 {
1394   if (GetChildren())
1395   {
1396     wxNode *node = GetChildren()->First();
1397     while (node)
1398     {
1399       wxNode* next = node->Next();
1400       wxWindow* child = (wxWindow*) node->Data();
1401       delete child;
1402       node = next;
1403     }
1404     GetChildren()->Clear();
1405 #if 0
1406     wxNode *node;
1407     while ((node = GetChildren()->First()) != (wxNode *)NULL) {
1408       wxWindow *child;
1409       if ((child = (wxWindow *)node->Data()) != (wxWindow *)NULL) {
1410         delete child;
1411                 if ( GetChildren()->Member(child) )
1412                         delete node;
1413       }
1414     } /* while */
1415 #endif
1416   }
1417 }
1418
1419 void wxWindow::MakeModal(bool modal)
1420 {
1421   // Disable all other windows
1422   if (this->IsKindOf(CLASSINFO(wxDialog)) || this->IsKindOf(CLASSINFO(wxFrame)))
1423   {
1424     wxNode *node = wxTopLevelWindows.First();
1425     while (node)
1426     {
1427       wxWindow *win = (wxWindow *)node->Data();
1428       if (win != this)
1429         win->Enable(!modal);
1430
1431       node = node->Next();
1432     }
1433   }
1434 }
1435
1436 // If nothing defined for this, try the parent.
1437 // E.g. we may be a button loaded from a resource, with no callback function
1438 // defined.
1439 void wxWindow::OnCommand(wxWindow& win, wxCommandEvent& event)
1440 {
1441   if (GetEventHandler()->ProcessEvent(event) )
1442     return;
1443   if (m_windowParent)
1444     m_windowParent->GetEventHandler()->OnCommand(win, event);
1445 }
1446
1447 void wxWindow::SetConstraints(wxLayoutConstraints *c)
1448 {
1449   if (m_constraints)
1450   {
1451     UnsetConstraints(m_constraints);
1452     delete m_constraints;
1453   }
1454   m_constraints = c;
1455   if (m_constraints)
1456   {
1457     // Make sure other windows know they're part of a 'meaningful relationship'
1458     if (m_constraints->left.GetOtherWindow() && (m_constraints->left.GetOtherWindow() != this))
1459       m_constraints->left.GetOtherWindow()->AddConstraintReference((wxWindow *)this);
1460     if (m_constraints->top.GetOtherWindow() && (m_constraints->top.GetOtherWindow() != this))
1461       m_constraints->top.GetOtherWindow()->AddConstraintReference((wxWindow *)this);
1462     if (m_constraints->right.GetOtherWindow() && (m_constraints->right.GetOtherWindow() != this))
1463       m_constraints->right.GetOtherWindow()->AddConstraintReference((wxWindow *)this);
1464     if (m_constraints->bottom.GetOtherWindow() && (m_constraints->bottom.GetOtherWindow() != this))
1465       m_constraints->bottom.GetOtherWindow()->AddConstraintReference((wxWindow *)this);
1466     if (m_constraints->width.GetOtherWindow() && (m_constraints->width.GetOtherWindow() != this))
1467       m_constraints->width.GetOtherWindow()->AddConstraintReference((wxWindow *)this);
1468     if (m_constraints->height.GetOtherWindow() && (m_constraints->height.GetOtherWindow() != this))
1469       m_constraints->height.GetOtherWindow()->AddConstraintReference((wxWindow *)this);
1470     if (m_constraints->centreX.GetOtherWindow() && (m_constraints->centreX.GetOtherWindow() != this))
1471       m_constraints->centreX.GetOtherWindow()->AddConstraintReference((wxWindow *)this);
1472     if (m_constraints->centreY.GetOtherWindow() && (m_constraints->centreY.GetOtherWindow() != this))
1473       m_constraints->centreY.GetOtherWindow()->AddConstraintReference((wxWindow *)this);
1474   }
1475 }
1476
1477 // This removes any dangling pointers to this window
1478 // in other windows' constraintsInvolvedIn lists.
1479 void wxWindow::UnsetConstraints(wxLayoutConstraints *c)
1480 {
1481   if (c)
1482   {
1483     if (c->left.GetOtherWindow() && (c->top.GetOtherWindow() != this))
1484       c->left.GetOtherWindow()->RemoveConstraintReference((wxWindow *)this);
1485     if (c->top.GetOtherWindow() && (c->top.GetOtherWindow() != this))
1486       c->top.GetOtherWindow()->RemoveConstraintReference((wxWindow *)this);
1487     if (c->right.GetOtherWindow() && (c->right.GetOtherWindow() != this))
1488       c->right.GetOtherWindow()->RemoveConstraintReference((wxWindow *)this);
1489     if (c->bottom.GetOtherWindow() && (c->bottom.GetOtherWindow() != this))
1490       c->bottom.GetOtherWindow()->RemoveConstraintReference((wxWindow *)this);
1491     if (c->width.GetOtherWindow() && (c->width.GetOtherWindow() != this))
1492       c->width.GetOtherWindow()->RemoveConstraintReference((wxWindow *)this);
1493     if (c->height.GetOtherWindow() && (c->height.GetOtherWindow() != this))
1494       c->height.GetOtherWindow()->RemoveConstraintReference((wxWindow *)this);
1495     if (c->centreX.GetOtherWindow() && (c->centreX.GetOtherWindow() != this))
1496       c->centreX.GetOtherWindow()->RemoveConstraintReference((wxWindow *)this);
1497     if (c->centreY.GetOtherWindow() && (c->centreY.GetOtherWindow() != this))
1498       c->centreY.GetOtherWindow()->RemoveConstraintReference((wxWindow *)this);
1499   }
1500 }
1501
1502 // Back-pointer to other windows we're involved with, so if we delete
1503 // this window, we must delete any constraints we're involved with.
1504 void wxWindow::AddConstraintReference(wxWindow *otherWin)
1505 {
1506   if (!m_constraintsInvolvedIn)
1507     m_constraintsInvolvedIn = new wxList;
1508   if (!m_constraintsInvolvedIn->Member(otherWin))
1509     m_constraintsInvolvedIn->Append(otherWin);
1510 }
1511
1512 // REMOVE back-pointer to other windows we're involved with.
1513 void wxWindow::RemoveConstraintReference(wxWindow *otherWin)
1514 {
1515   if (m_constraintsInvolvedIn)
1516     m_constraintsInvolvedIn->DeleteObject(otherWin);
1517 }
1518
1519 // Reset any constraints that mention this window
1520 void wxWindow::DeleteRelatedConstraints()
1521 {
1522   if (m_constraintsInvolvedIn)
1523   {
1524     wxNode *node = m_constraintsInvolvedIn->First();
1525     while (node)
1526     {
1527       wxWindow *win = (wxWindow *)node->Data();
1528       wxNode *next = node->Next();
1529       wxLayoutConstraints *constr = win->GetConstraints();
1530
1531       // Reset any constraints involving this window
1532       if (constr)
1533       {
1534         constr->left.ResetIfWin((wxWindow *)this);
1535         constr->top.ResetIfWin((wxWindow *)this);
1536         constr->right.ResetIfWin((wxWindow *)this);
1537         constr->bottom.ResetIfWin((wxWindow *)this);
1538         constr->width.ResetIfWin((wxWindow *)this);
1539         constr->height.ResetIfWin((wxWindow *)this);
1540         constr->centreX.ResetIfWin((wxWindow *)this);
1541         constr->centreY.ResetIfWin((wxWindow *)this);
1542       }
1543       delete node;
1544       node = next;
1545     }
1546     delete m_constraintsInvolvedIn;
1547     m_constraintsInvolvedIn = NULL;
1548   }
1549 }
1550
1551 void wxWindow::SetSizer(wxSizer *sizer)
1552 {
1553   m_windowSizer = sizer;
1554   if (sizer)
1555     sizer->SetSizerParent((wxWindow *)this);
1556 }
1557
1558 /*
1559  * New version
1560  */
1561
1562 bool wxWindow::Layout()
1563 {
1564   if (GetConstraints())
1565   {
1566     int w, h;
1567     GetClientSize(&w, &h);
1568     GetConstraints()->width.SetValue(w);
1569     GetConstraints()->height.SetValue(h);
1570   }
1571
1572   // If top level (one sizer), evaluate the sizer's constraints.
1573   if (GetSizer())
1574   {
1575     int noChanges;
1576     GetSizer()->ResetConstraints();   // Mark all constraints as unevaluated
1577     GetSizer()->LayoutPhase1(&noChanges);
1578     GetSizer()->LayoutPhase2(&noChanges);
1579     GetSizer()->SetConstraintSizes(); // Recursively set the real window sizes
1580     return TRUE;
1581   }
1582   else
1583   {
1584     // Otherwise, evaluate child constraints
1585     ResetConstraints();   // Mark all constraints as unevaluated
1586     DoPhase(1);           // Just one phase need if no sizers involved
1587     DoPhase(2);
1588     SetConstraintSizes(); // Recursively set the real window sizes
1589   }
1590   return TRUE;
1591 }
1592
1593
1594 // Do a phase of evaluating constraints:
1595 // the default behaviour. wxSizers may do a similar
1596 // thing, but also impose their own 'constraints'
1597 // and order the evaluation differently.
1598 bool wxWindow::LayoutPhase1(int *noChanges)
1599 {
1600   wxLayoutConstraints *constr = GetConstraints();
1601   if (constr)
1602   {
1603     return constr->SatisfyConstraints((wxWindow *)this, noChanges);
1604   }
1605   else
1606     return TRUE;
1607 }
1608
1609 bool wxWindow::LayoutPhase2(int *noChanges)
1610 {
1611   *noChanges = 0;
1612
1613   // Layout children
1614   DoPhase(1);
1615   DoPhase(2);
1616   return TRUE;
1617 }
1618
1619 // Do a phase of evaluating child constraints
1620 bool wxWindow::DoPhase(int phase)
1621 {
1622   int noIterations = 0;
1623   int maxIterations = 500;
1624   int noChanges = 1;
1625   int noFailures = 0;
1626   wxList succeeded;
1627   while ((noChanges > 0) && (noIterations < maxIterations))
1628   {
1629     noChanges = 0;
1630     noFailures = 0;
1631     wxNode *node = GetChildren()->First();
1632     while (node)
1633     {
1634       wxWindow *child = (wxWindow *)node->Data();
1635       if (!child->IsKindOf(CLASSINFO(wxFrame)) && !child->IsKindOf(CLASSINFO(wxDialog)))
1636       {
1637         wxLayoutConstraints *constr = child->GetConstraints();
1638         if (constr)
1639         {
1640           if (succeeded.Member(child))
1641           {
1642           }
1643           else
1644           {
1645             int tempNoChanges = 0;
1646             bool success = ( (phase == 1) ? child->LayoutPhase1(&tempNoChanges) : child->LayoutPhase2(&tempNoChanges) ) ;
1647             noChanges += tempNoChanges;
1648             if (success)
1649             {
1650               succeeded.Append(child);
1651             }
1652           }
1653         }
1654       }
1655       node = node->Next();
1656     }
1657     noIterations ++;
1658   }
1659   return TRUE;
1660 }
1661
1662 void wxWindow::ResetConstraints()
1663 {
1664   wxLayoutConstraints *constr = GetConstraints();
1665   if (constr)
1666   {
1667     constr->left.SetDone(FALSE);
1668     constr->top.SetDone(FALSE);
1669     constr->right.SetDone(FALSE);
1670     constr->bottom.SetDone(FALSE);
1671     constr->width.SetDone(FALSE);
1672     constr->height.SetDone(FALSE);
1673     constr->centreX.SetDone(FALSE);
1674     constr->centreY.SetDone(FALSE);
1675   }
1676   wxNode *node = GetChildren()->First();
1677   while (node)
1678   {
1679     wxWindow *win = (wxWindow *)node->Data();
1680     if (!win->IsKindOf(CLASSINFO(wxFrame)) && !win->IsKindOf(CLASSINFO(wxDialog)))
1681       win->ResetConstraints();
1682     node = node->Next();
1683   }
1684 }
1685
1686 // Need to distinguish between setting the 'fake' size for
1687 // windows and sizers, and setting the real values.
1688 void wxWindow::SetConstraintSizes(bool recurse)
1689 {
1690   wxLayoutConstraints *constr = GetConstraints();
1691   if (constr && constr->left.GetDone() && constr->right.GetDone() &&
1692                 constr->width.GetDone() && constr->height.GetDone())
1693   {
1694     int x = constr->left.GetValue();
1695     int y = constr->top.GetValue();
1696     int w = constr->width.GetValue();
1697     int h = constr->height.GetValue();
1698
1699     // If we don't want to resize this window, just move it...
1700     if ((constr->width.GetRelationship() != wxAsIs) ||
1701         (constr->height.GetRelationship() != wxAsIs))
1702     {
1703       // Calls Layout() recursively. AAAGH. How can we stop that.
1704       // Simply take Layout() out of non-top level OnSizes.
1705       SizerSetSize(x, y, w, h);
1706     }
1707     else
1708     {
1709       SizerMove(x, y);
1710     }
1711   }
1712   else if (constr)
1713   {
1714     char *windowClass = this->GetClassInfo()->GetClassName();
1715
1716     wxString winName;
1717         if (GetName() == "")
1718                 winName = "unnamed";
1719         else
1720                 winName = GetName();
1721     wxDebugMsg("Constraint(s) not satisfied for window of type %s, name %s:\n", (const char *)windowClass, (const char *)winName);
1722     if (!constr->left.GetDone())
1723       wxDebugMsg("  unsatisfied 'left' constraint.\n");
1724     if (!constr->right.GetDone())
1725       wxDebugMsg("  unsatisfied 'right' constraint.\n");
1726     if (!constr->width.GetDone())
1727       wxDebugMsg("  unsatisfied 'width' constraint.\n");
1728     if (!constr->height.GetDone())
1729       wxDebugMsg("  unsatisfied 'height' constraint.\n");
1730     wxDebugMsg("Please check constraints: try adding AsIs() constraints.\n");
1731   }
1732
1733   if (recurse)
1734   {
1735     wxNode *node = GetChildren()->First();
1736     while (node)
1737     {
1738       wxWindow *win = (wxWindow *)node->Data();
1739       if (!win->IsKindOf(CLASSINFO(wxFrame)) && !win->IsKindOf(CLASSINFO(wxDialog)))
1740         win->SetConstraintSizes();
1741       node = node->Next();
1742     }
1743   }
1744 }
1745
1746 // This assumes that all sizers are 'on' the same
1747 // window, i.e. the parent of this window.
1748 void wxWindow::TransformSizerToActual(int *x, int *y) const
1749 {
1750   if (!m_sizerParent || m_sizerParent->IsKindOf(CLASSINFO(wxDialog)) ||
1751                          m_sizerParent->IsKindOf(CLASSINFO(wxFrame)) )
1752     return;
1753
1754   int xp, yp;
1755   m_sizerParent->GetPosition(&xp, &yp);
1756   m_sizerParent->TransformSizerToActual(&xp, &yp);
1757   *x += xp;
1758   *y += yp;
1759 }
1760
1761 void wxWindow::SizerSetSize(int x, int y, int w, int h)
1762 {
1763         int xx = x;
1764         int yy = y;
1765   TransformSizerToActual(&xx, &yy);
1766   SetSize(xx, yy, w, h);
1767 }
1768
1769 void wxWindow::SizerMove(int x, int y)
1770 {
1771         int xx = x;
1772         int yy = y;
1773   TransformSizerToActual(&xx, &yy);
1774   Move(xx, yy);
1775 }
1776
1777 // Only set the size/position of the constraint (if any)
1778 void wxWindow::SetSizeConstraint(int x, int y, int w, int h)
1779 {
1780   wxLayoutConstraints *constr = GetConstraints();
1781   if (constr)
1782   {
1783     if (x != -1)
1784     {
1785       constr->left.SetValue(x);
1786       constr->left.SetDone(TRUE);
1787     }
1788     if (y != -1)
1789     {
1790       constr->top.SetValue(y);
1791       constr->top.SetDone(TRUE);
1792     }
1793     if (w != -1)
1794     {
1795       constr->width.SetValue(w);
1796       constr->width.SetDone(TRUE);
1797     }
1798     if (h != -1)
1799     {
1800       constr->height.SetValue(h);
1801       constr->height.SetDone(TRUE);
1802     }
1803   }
1804 }
1805
1806 void wxWindow::MoveConstraint(int x, int y)
1807 {
1808   wxLayoutConstraints *constr = GetConstraints();
1809   if (constr)
1810   {
1811     if (x != -1)
1812     {
1813       constr->left.SetValue(x);
1814       constr->left.SetDone(TRUE);
1815     }
1816     if (y != -1)
1817     {
1818       constr->top.SetValue(y);
1819       constr->top.SetDone(TRUE);
1820     }
1821   }
1822 }
1823
1824 void wxWindow::GetSizeConstraint(int *w, int *h) const
1825 {
1826   wxLayoutConstraints *constr = GetConstraints();
1827   if (constr)
1828   {
1829     *w = constr->width.GetValue();
1830     *h = constr->height.GetValue();
1831   }
1832   else
1833     GetSize(w, h);
1834 }
1835
1836 void wxWindow::GetClientSizeConstraint(int *w, int *h) const
1837 {
1838   wxLayoutConstraints *constr = GetConstraints();
1839   if (constr)
1840   {
1841     *w = constr->width.GetValue();
1842     *h = constr->height.GetValue();
1843   }
1844   else
1845     GetClientSize(w, h);
1846 }
1847
1848 void wxWindow::GetPositionConstraint(int *x, int *y) const
1849 {
1850   wxLayoutConstraints *constr = GetConstraints();
1851   if (constr)
1852   {
1853     *x = constr->left.GetValue();
1854     *y = constr->top.GetValue();
1855   }
1856   else
1857     GetPosition(x, y);
1858 }
1859
1860 bool wxWindow::Close(bool force)
1861 {
1862   wxCloseEvent event(wxEVT_CLOSE_WINDOW, m_windowId);
1863   event.SetEventObject(this);
1864   event.SetForce(force);
1865
1866   return GetEventHandler()->ProcessEvent(event);
1867 }
1868
1869 wxObject* wxWindow::GetChild(int number) const
1870 {
1871   // Return a pointer to the Nth object in the window
1872   if (!GetChildren())
1873     return(NULL) ;
1874   wxNode *node = GetChildren()->First();
1875   int n = number;
1876   while (node && n--)
1877     node = node->Next() ;
1878   if (node)
1879   {
1880     wxObject *obj = (wxObject *)node->Data();
1881     return(obj) ;
1882   }
1883   else
1884     return NULL ;
1885 }
1886
1887 void wxWindow::OnDefaultAction(wxControl *initiatingItem)
1888 {
1889     // Obsolete function
1890 }
1891
1892 void wxWindow::Clear()
1893 {
1894     wxClientDC dc(this);
1895     wxBrush brush(GetBackgroundColour(), wxSOLID);
1896     dc.SetBackground(brush);
1897     dc.Clear();
1898 }
1899
1900 // Fits the panel around the items
1901 void wxWindow::Fit()
1902 {
1903         int maxX = 0;
1904         int maxY = 0;
1905         wxNode *node = GetChildren()->First();
1906         while ( node )
1907         {
1908                 wxWindow *win = (wxWindow *)node->Data();
1909                 int wx, wy, ww, wh;
1910                 win->GetPosition(&wx, &wy);
1911                 win->GetSize(&ww, &wh);
1912                 if ( wx + ww > maxX )
1913                         maxX = wx + ww;
1914                 if ( wy + wh > maxY )
1915                         maxY = wy + wh;
1916
1917                 node = node->Next();
1918         }
1919         SetClientSize(maxX + 5, maxY + 5);
1920 }
1921
1922 void wxWindow::SetValidator(const wxValidator& validator)
1923 {
1924         if ( m_windowValidator )
1925                 delete m_windowValidator;
1926         m_windowValidator = validator.Clone();
1927
1928         if ( m_windowValidator )
1929                 m_windowValidator->SetWindow(this) ;
1930 }
1931
1932 void wxWindow::SetClientObject( wxClientData *data )
1933 {
1934   if (m_clientObject) delete m_clientObject;
1935   m_clientObject = data;
1936 }
1937
1938 wxClientData *wxWindow::GetClientObject()
1939 {
1940   return m_clientObject;
1941 }
1942
1943 void wxWindow::SetClientData( void *data )
1944 {
1945   m_clientData = data;
1946 }
1947
1948 void *wxWindow::GetClientData()
1949 {
1950   return m_clientData;
1951 }
1952
1953 // Find a window by id or name
1954 wxWindow *wxWindow::FindWindow(long id)
1955 {
1956         if ( GetId() == id)
1957                 return this;
1958
1959         wxNode *node = GetChildren()->First();
1960         while ( node )
1961         {
1962                 wxWindow *child = (wxWindow *)node->Data();
1963                 wxWindow *found = child->FindWindow(id);
1964                 if ( found )
1965                         return found;
1966                 node = node->Next();
1967         }
1968         return NULL;
1969 }
1970
1971 wxWindow *wxWindow::FindWindow(const wxString& name)
1972 {
1973         if ( GetName() == name)
1974                 return this;
1975
1976         wxNode *node = GetChildren()->First();
1977         while ( node )
1978         {
1979                 wxWindow *child = (wxWindow *)node->Data();
1980                 wxWindow *found = child->FindWindow(name);
1981                 if ( found )
1982                         return found;
1983                 node = node->Next();
1984         }
1985         return NULL;
1986 }
1987
1988 void wxWindow::OnIdle(wxIdleEvent& event)
1989 {
1990     // This calls the UI-update mechanism (querying windows for
1991     // menu/toolbar/control state information)
1992     UpdateWindowUI();
1993 }
1994
1995 // Raise the window to the top of the Z order
1996 void wxWindow::Raise()
1997 {
1998     Window window = XtWindow((Widget) GetTopWidget());
1999     XRaiseWindow(XtDisplay((Widget) GetTopWidget()), window);
2000 }
2001
2002 // Lower the window to the bottom of the Z order
2003 void wxWindow::Lower()
2004 {
2005     Window window = XtWindow((Widget) GetTopWidget());
2006     XLowerWindow(XtDisplay((Widget) GetTopWidget()), window);
2007 }
2008
2009 bool wxWindow::AcceptsFocus() const
2010 {
2011   return IsShown() && IsEnabled();
2012 }
2013
2014 // Update region access
2015 wxRegion& wxWindow::GetUpdateRegion() const
2016 {
2017     return (wxRegion&) m_updateRegion;
2018 }
2019
2020 bool wxWindow::IsExposed(int x, int y, int w, int h) const
2021 {
2022     return (m_updateRegion.Contains(x, y, w, h) != wxOutRegion);
2023 }
2024
2025 bool wxWindow::IsExposed(const wxPoint& pt) const
2026 {
2027     return (m_updateRegion.Contains(pt) != wxOutRegion);
2028 }
2029
2030 bool wxWindow::IsExposed(const wxRect& rect) const
2031 {
2032     return (m_updateRegion.Contains(rect) != wxOutRegion);
2033 }
2034
2035 /*
2036  * Allocates control IDs
2037  */
2038
2039 int wxWindow::NewControlId()
2040 {
2041     static int s_controlId = 0;
2042     s_controlId ++;
2043     return s_controlId;
2044 }
2045
2046 void wxWindow::SetAcceleratorTable(const wxAcceleratorTable& accel)
2047 {
2048     m_acceleratorTable = accel;
2049 }
2050
2051 // All widgets should have this as their resize proc.
2052 // OnSize sent to wxWindow via client data.
2053 void wxWidgetResizeProc(Widget w, XConfigureEvent *event, String args[], int *num_args)
2054 {
2055     wxWindow *win = (wxWindow *)wxWidgetHashTable->Get((long)w);
2056     if (!win)
2057         return;
2058
2059     if (win->PreResize())
2060     {
2061         int width, height;
2062         win->GetSize(&width, &height);
2063         wxSizeEvent sizeEvent(wxSize(width, height), win->GetId());
2064         sizeEvent.SetEventObject(win);
2065         win->GetEventHandler()->ProcessEvent(sizeEvent);
2066     }
2067 }
2068
2069 bool wxAddWindowToTable(Widget w, wxWindow *win)
2070 {
2071   wxWindow *oldItem = NULL;
2072 //  printf("Adding widget %ld, name = %s\n", w, win->GetClassInfo()->GetClassName());
2073   if ((oldItem = (wxWindow *)wxWidgetHashTable->Get ((long) w)))
2074   {
2075     char buf[300];
2076     sprintf(buf, "Widget table clash: new widget is %ld, %s", (long)w, win->GetClassInfo()->GetClassName());
2077     wxError (buf);
2078     fflush(stderr);
2079     sprintf(buf, "Old widget was %s", oldItem->GetClassInfo()->GetClassName());
2080     wxError (buf);
2081     return FALSE;
2082   }
2083
2084   wxWidgetHashTable->Put ((long) w, win);
2085   return TRUE;
2086 }
2087
2088 wxWindow *wxGetWindowFromTable(Widget w)
2089 {
2090   return (wxWindow *)wxWidgetHashTable->Get ((long) w);
2091 }
2092
2093 void wxDeleteWindowFromTable(Widget w)
2094 {
2095   wxWidgetHashTable->Delete((long)w);
2096 }
2097
2098 // Get the underlying X window and display
2099 WXWindow wxWindow::GetXWindow() const
2100 {
2101     return (WXWindow) XtWindow((Widget) GetMainWidget());
2102 }
2103
2104 WXDisplay *wxWindow::GetXDisplay() const
2105 {
2106     return (WXDisplay*) XtDisplay((Widget) GetMainWidget());
2107 }
2108
2109 WXWidget wxWindow::GetMainWidget() const
2110 {
2111     if (m_drawingArea)
2112       return m_drawingArea;
2113     else
2114       return m_mainWidget;
2115 }
2116
2117 WXWidget wxWindow::GetClientWidget() const
2118 {
2119     if (m_drawingArea != (WXWidget) 0)
2120         return m_drawingArea;
2121     else
2122         return GetMainWidget();
2123 }
2124
2125 WXWidget wxWindow::GetTopWidget() const
2126 {
2127     return GetMainWidget();
2128 }
2129
2130 void wxCanvasRepaintProc (Widget drawingArea, XtPointer clientData,
2131  XmDrawingAreaCallbackStruct * cbs)
2132 {
2133     if (!wxWidgetHashTable->Get ((long) (Widget) drawingArea))
2134             return;
2135
2136     XEvent * event = cbs->event;
2137     wxWindow * win = (wxWindow *) clientData;
2138     Display * display = (Display *) win->GetXDisplay();
2139
2140     switch (event->type)
2141     {
2142         case Expose:
2143         {
2144             wxRect* rect = new wxRect(event->xexpose.x, event->xexpose.y,
2145                                        event->xexpose.width, event->xexpose.height);
2146             /*
2147             cout << "Expose proc. wxRect: " << rect->x << ", " << rect->y << ", ";
2148             cout << rect->width << ", " << rect->height << "\n\n";
2149             */
2150
2151             win->m_updateRects.Append((wxObject*) rect);
2152
2153             if (event -> xexpose.count == 0)
2154             {
2155                 wxPaintEvent event(win->GetId());
2156                 event.SetEventObject(win);
2157                 win->GetEventHandler()->ProcessEvent(event);
2158
2159                 win->ClearUpdateRects();
2160             }
2161             break;
2162         }
2163         default:
2164         {
2165                 cout << "\n\nNew Event ! is = " << event -> type << "\n";
2166                 break;
2167         }
2168     }
2169 }
2170
2171 // Unable to deal with Enter/Leave without a separate EventHandler (Motif 1.1.4)
2172 void
2173 wxCanvasEnterLeave (Widget drawingArea, XtPointer clientData, XCrossingEvent * event)
2174 {
2175   XmDrawingAreaCallbackStruct cbs;
2176   XEvent ev;
2177
2178   //if (event->mode!=NotifyNormal)
2179   //  return ;
2180
2181 //  ev = *((XEvent *) event); // Causes Purify error (copying too many bytes)
2182   ((XCrossingEvent &) ev) = *event;
2183
2184   cbs.reason = XmCR_INPUT;
2185   cbs.event = &ev;
2186
2187   wxCanvasInputEvent (drawingArea, (XtPointer) NULL, &cbs);
2188 }
2189
2190 // Fix to make it work under Motif 1.0 (!)
2191 void wxCanvasMotionEvent (Widget drawingArea, XButtonEvent * event)
2192 {
2193 #if   XmVersion<=1000
2194
2195   XmDrawingAreaCallbackStruct cbs;
2196   XEvent ev;
2197
2198   //ev.xbutton = *event;
2199   ev = *((XEvent *) event);
2200   cbs.reason = XmCR_INPUT;
2201   cbs.event = &ev;
2202
2203   wxCanvasInputEvent (drawingArea, (XtPointer) NULL, &cbs);
2204 #endif
2205 }
2206
2207 void wxCanvasInputEvent (Widget drawingArea, XtPointer data, XmDrawingAreaCallbackStruct * cbs)
2208 {
2209   wxWindow *canvas = (wxWindow *) wxWidgetHashTable->Get ((long) (Widget) drawingArea);
2210   XEvent local_event;
2211
2212   if (canvas==NULL)
2213     return ;
2214
2215   if (cbs->reason != XmCR_INPUT)
2216     return;
2217
2218   local_event = *(cbs->event);  // We must keep a copy!
2219
2220   /*
2221   switch (local_event.xany.type)
2222     {
2223     case EnterNotify:
2224       cout << "EnterNotify\n";
2225       break;
2226     case LeaveNotify:
2227       cout << "LeaveNotify\n";
2228       break;
2229     case ButtonPress:
2230       cout << "ButtonPress\n";
2231       break;
2232     case ButtonRelease:
2233       cout << "ButtonRelease\n";
2234       break;
2235     case MotionNotify:
2236       cout << "MotionNotify\n";
2237       break;
2238     default:
2239       cout << "Something else\n";
2240       break;
2241   }
2242   */
2243
2244   switch (local_event.xany.type)
2245     {
2246     case EnterNotify:
2247     case LeaveNotify:
2248     case ButtonPress:
2249     case ButtonRelease:
2250     case MotionNotify:
2251       {
2252         wxEventType eventType = wxEVT_NULL;
2253
2254         if (local_event.xany.type == EnterNotify)
2255           {
2256             //if (local_event.xcrossing.mode!=NotifyNormal)
2257             //  return ; // Ignore grab events
2258             eventType = wxEVT_ENTER_WINDOW;
2259 //            canvas->GetEventHandler()->OnSetFocus();
2260           }
2261         else if (local_event.xany.type == LeaveNotify)
2262           {
2263             //if (local_event.xcrossing.mode!=NotifyNormal)
2264             //  return ; // Ignore grab events
2265             eventType = wxEVT_LEAVE_WINDOW;
2266 //            canvas->GetEventHandler()->OnKillFocus();
2267           }
2268         else if (local_event.xany.type == MotionNotify)
2269           {
2270             eventType = wxEVT_MOTION;
2271             if (local_event.xmotion.is_hint == NotifyHint)
2272               {
2273                 Window root, child;
2274                 Display *dpy = XtDisplay (drawingArea);
2275
2276                 XQueryPointer (dpy, XtWindow (drawingArea),
2277                                &root, &child,
2278                                &local_event.xmotion.x_root,
2279                                &local_event.xmotion.y_root,
2280                                &local_event.xmotion.x,
2281                                &local_event.xmotion.y,
2282                                &local_event.xmotion.state);
2283               }
2284             else
2285               {
2286               }
2287           }
2288
2289         else if (local_event.xany.type == ButtonPress)
2290           {
2291             if (local_event.xbutton.button == Button1)
2292               {
2293                 eventType = wxEVT_LEFT_DOWN;
2294                 canvas->m_button1Pressed = TRUE;
2295               }
2296             else if (local_event.xbutton.button == Button2)
2297               {
2298                 eventType = wxEVT_MIDDLE_DOWN;
2299                 canvas->m_button2Pressed = TRUE;
2300               }
2301             else if (local_event.xbutton.button == Button3)
2302               {
2303                 eventType = wxEVT_RIGHT_DOWN;
2304                 canvas->m_button3Pressed = TRUE;
2305               }
2306           }
2307         else if (local_event.xany.type == ButtonRelease)
2308           {
2309             if (local_event.xbutton.button == Button1)
2310               {
2311                 eventType = wxEVT_LEFT_UP;
2312                 canvas->m_button1Pressed = FALSE;
2313               }
2314             else if (local_event.xbutton.button == Button2)
2315               {
2316                 eventType = wxEVT_MIDDLE_UP;
2317                 canvas->m_button2Pressed = FALSE;
2318               }
2319             else if (local_event.xbutton.button == Button3)
2320               {
2321                 eventType = wxEVT_RIGHT_UP;
2322                 canvas->m_button3Pressed = FALSE;
2323               }
2324           }
2325
2326         wxMouseEvent wxevent (eventType);
2327         wxevent.m_eventHandle = (char *) &local_event;
2328
2329         wxevent.m_leftDown = ((eventType == wxEVT_LEFT_DOWN)
2330                             || (event_left_is_down (&local_event)
2331                                 && (eventType != wxEVT_LEFT_UP)));
2332         wxevent.m_middleDown = ((eventType == wxEVT_MIDDLE_DOWN)
2333                               || (event_middle_is_down (&local_event)
2334                                   && (eventType != wxEVT_MIDDLE_UP)));
2335         wxevent.m_rightDown = ((eventType == wxEVT_RIGHT_DOWN)
2336                              || (event_right_is_down (&local_event)
2337                                  && (eventType != wxEVT_RIGHT_UP)));
2338
2339         wxevent.m_shiftDown = local_event.xbutton.state & ShiftMask;
2340         wxevent.m_controlDown = local_event.xbutton.state & ControlMask;
2341         wxevent.m_altDown = local_event.xbutton.state & Mod3Mask;
2342         wxevent.m_metaDown = local_event.xbutton.state & Mod1Mask;
2343         wxevent.SetTimestamp(local_event.xbutton.time);
2344
2345     // Now check if we need to translate this event into a double click
2346     if (TRUE) // canvas->doubleClickAllowed)
2347     {
2348        if (wxevent.ButtonDown())
2349        {
2350              long dclickTime = XtGetMultiClickTime((Display*) wxGetDisplay()) ;
2351
2352              // get button and time-stamp
2353              int button = 0;
2354              if      (wxevent.LeftDown())   button = 1;
2355              else if (wxevent.MiddleDown()) button = 2;
2356              else if (wxevent.RightDown())  button = 3;
2357              long ts = wxevent.GetTimestamp();
2358              // check, if single or double click
2359              if (canvas->m_lastButton && canvas->m_lastButton==button && (ts - canvas->m_lastTS) < dclickTime)
2360                {
2361                 // I have a dclick
2362                  canvas->m_lastButton = 0;
2363                  switch ( eventType )
2364                    {
2365                    case wxEVT_LEFT_DOWN:
2366                      wxevent.SetEventType(wxEVT_LEFT_DCLICK);
2367                      break;
2368                    case wxEVT_MIDDLE_DOWN:
2369                      wxevent.SetEventType(wxEVT_MIDDLE_DCLICK);
2370                      break;
2371                    case wxEVT_RIGHT_DOWN:
2372                      wxevent.SetEventType(wxEVT_RIGHT_DCLICK);
2373                      break;
2374
2375                    default :
2376                      break;
2377                    }
2378
2379                }
2380              else
2381                {
2382                  // not fast enough or different button
2383                  canvas->m_lastTS     = ts;
2384                  canvas->m_lastButton = button;
2385                }
2386        }
2387     }
2388
2389         wxevent.SetId(canvas->GetId());
2390         wxevent.SetEventObject(canvas);
2391         wxevent.m_x = local_event.xbutton.x;
2392         wxevent.m_y = local_event.xbutton.y;
2393         canvas->GetEventHandler()->ProcessEvent (wxevent);
2394         /*
2395         if (eventType == wxEVT_ENTER_WINDOW ||
2396             eventType == wxEVT_LEAVE_WINDOW ||
2397             eventType == wxEVT_MOTION
2398           )
2399           return;
2400           */
2401         break;
2402       }
2403     case KeyPress:
2404       {
2405         KeySym keySym;
2406 //      XComposeStatus compose;
2407 //      (void) XLookupString ((XKeyEvent *) & local_event, wxBuffer, 20, &keySym, &compose);
2408         (void) XLookupString ((XKeyEvent *) & local_event, wxBuffer, 20, &keySym, NULL);
2409         int id = wxCharCodeXToWX (keySym);
2410
2411         wxKeyEvent event (wxEVT_CHAR);
2412
2413         if (local_event.xkey.state & ShiftMask)
2414           event.m_shiftDown = TRUE;
2415         if (local_event.xkey.state & ControlMask)
2416           event.m_controlDown = TRUE;
2417         if (local_event.xkey.state & Mod3Mask)
2418           event.m_altDown = TRUE;
2419         if (local_event.xkey.state & Mod1Mask)
2420           event.m_metaDown = TRUE;
2421         event.SetEventObject(canvas);
2422         event.m_keyCode = id;
2423         event.SetTimestamp(local_event.xkey.time);
2424
2425         if (id > -1)
2426         {
2427           // Implement wxFrame::OnCharHook by checking ancestor.
2428           wxWindow *parent = canvas->GetParent();
2429           while (parent && !parent->IsKindOf(CLASSINFO(wxFrame)))
2430             parent = parent->GetParent();
2431
2432           if (parent)
2433           {
2434             event.SetEventType(wxEVT_CHAR_HOOK);
2435             if (parent->GetEventHandler()->ProcessEvent(event))
2436               return;
2437             event.SetEventType(wxEVT_CHAR);
2438           }
2439
2440           canvas->GetEventHandler()->ProcessEvent (event);
2441         }
2442         break;
2443       }
2444     case FocusIn:
2445       {
2446         if (local_event.xfocus.detail != NotifyPointer)
2447         {
2448           wxFocusEvent event(wxEVT_SET_FOCUS, canvas->GetId());
2449           event.SetEventObject(canvas);
2450           canvas->GetEventHandler()->ProcessEvent(event);
2451         }
2452         break;
2453       }
2454     case FocusOut:
2455       {
2456         if (local_event.xfocus.detail != NotifyPointer)
2457         {
2458           wxFocusEvent event(wxEVT_KILL_FOCUS, canvas->GetId());
2459           event.SetEventObject(canvas);
2460           canvas->GetEventHandler()->ProcessEvent(event);
2461         }
2462         break;
2463       }
2464     default:
2465       break;
2466     }
2467 }
2468
2469 void wxWindow::DoPaint()
2470 {
2471   //TODO : make a temporary gc so we can do the XCopyArea below
2472   if (0) // m_backingPixmap)
2473     {
2474       /*
2475       Widget drawingArea = (Widget) m_drawingArea;
2476       //      int orig = GetDC()->GetLogicalFunction();
2477       //      GetDC()->SetLogicalFunction (wxCOPY);
2478
2479       // TODO: it may not be necessary to store m_pixmapOffsetX/Y; we
2480       // should be able to calculate them.
2481       XCopyArea (XtDisplay (drawingArea), m_backingPixmap, XtWindow (drawingArea), GetDC ()->gc,
2482                  m_pixmapOffsetX, m_pixmapOffsetY,
2483                  m_pixmapWidth, m_pixmapHeight,
2484                  0, 0);
2485
2486       //      GetDC()->SetLogicalFunction (orig);
2487       */
2488     }
2489   else
2490     {
2491         wxPaintEvent event(GetId());
2492         event.SetEventObject(this);
2493         GetEventHandler()->ProcessEvent(event);
2494     }
2495 }
2496
2497 // SetSize, but as per old wxCanvas (with drawing widget etc.)
2498 void wxWindow::CanvasSetSize (int x, int y, int w, int h, int sizeFlags)
2499 {
2500   Widget drawingArea = (Widget) m_drawingArea;
2501   bool managed = XtIsManaged(m_borderWidget ? (Widget) m_borderWidget : (Widget) m_scrolledWindow);
2502
2503   if (managed)
2504     XtUnmanageChild (m_borderWidget ? (Widget) m_borderWidget : (Widget) m_scrolledWindow);
2505   XtVaSetValues((Widget) m_drawingArea, XmNresizePolicy, XmRESIZE_ANY, NULL);
2506
2507   int xx = x; int yy = y;
2508   AdjustForParentClientOrigin(xx, yy, sizeFlags);
2509
2510   if (x > -1 || (sizeFlags & wxSIZE_ALLOW_MINUS_ONE))
2511     {
2512       XtVaSetValues (m_borderWidget ? (Widget) m_borderWidget : (Widget) m_scrolledWindow,
2513                      XmNx, xx, NULL);
2514     }
2515
2516   if (y > -1 || (sizeFlags & wxSIZE_ALLOW_MINUS_ONE))
2517     {
2518       XtVaSetValues (m_borderWidget ? (Widget) m_borderWidget : (Widget) m_scrolledWindow,
2519                      XmNy, yy, NULL);
2520     }
2521
2522   if (w > -1)
2523     {
2524       if (m_borderWidget)
2525         {
2526           XtVaSetValues ((Widget) m_borderWidget, XmNwidth, w, NULL);
2527           short thick, margin;
2528           XtVaGetValues ((Widget) m_borderWidget,
2529                          XmNshadowThickness, &thick,
2530                          XmNmarginWidth, &margin,
2531                          NULL);
2532           w -= 2 * (thick + margin);
2533         }
2534
2535       XtVaSetValues ((Widget) m_scrolledWindow, XmNwidth, w, NULL);
2536
2537       Dimension spacing;
2538       Widget sbar;
2539       XtVaGetValues ((Widget) m_scrolledWindow,
2540                      XmNspacing, &spacing,
2541                      XmNverticalScrollBar, &sbar,
2542                      NULL);
2543       Dimension wsbar;
2544       if (sbar)
2545         XtVaGetValues (sbar, XmNwidth, &wsbar, NULL);
2546       else
2547         wsbar = 0;
2548
2549       w -= (spacing + wsbar);
2550
2551       XtVaSetValues ((Widget) m_drawingArea, XmNwidth, w, NULL);
2552     }
2553   if (h > -1)
2554     {
2555       if (m_borderWidget)
2556         {
2557           XtVaSetValues ((Widget) m_borderWidget, XmNheight, h, NULL);
2558           short thick, margin;
2559           XtVaGetValues ((Widget) m_borderWidget,
2560                          XmNshadowThickness, &thick,
2561                          XmNmarginHeight, &margin,
2562                          NULL);
2563           h -= 2 * (thick + margin);
2564         }
2565
2566       XtVaSetValues ((Widget) m_scrolledWindow, XmNheight, h, NULL);
2567
2568       Dimension spacing;
2569       Widget sbar;
2570       XtVaGetValues ((Widget) m_scrolledWindow,
2571                      XmNspacing, &spacing,
2572                      XmNhorizontalScrollBar, &sbar,
2573                      NULL);
2574       Dimension wsbar;
2575       if (sbar)
2576         XtVaGetValues (sbar, XmNheight, &wsbar, NULL);
2577       else
2578         wsbar = 0;
2579
2580       h -= (spacing + wsbar);
2581
2582       XtVaSetValues ((Widget) m_drawingArea, XmNheight, h, NULL);
2583     }
2584   if (managed)
2585     XtManageChild (m_borderWidget ? (Widget) m_borderWidget : (Widget) m_scrolledWindow);
2586   XtVaSetValues((Widget) m_drawingArea, XmNresizePolicy, XmRESIZE_NONE, NULL);
2587
2588   int ww, hh;
2589   GetClientSize (&ww, &hh);
2590   wxSizeEvent sizeEvent(wxSize(ww, hh), GetId());
2591   sizeEvent.SetEventObject(this);
2592
2593   GetEventHandler()->ProcessEvent(sizeEvent);
2594 }
2595
2596 void wxWindow::CanvasSetClientSize (int w, int h)
2597 {
2598   Widget drawingArea = (Widget) m_drawingArea;
2599
2600   XtVaSetValues((Widget) m_drawingArea, XmNresizePolicy, XmRESIZE_ANY, NULL);
2601
2602   if (w > -1)
2603     XtVaSetValues ((Widget) m_drawingArea, XmNwidth, w, NULL);
2604   if (h > -1)
2605     XtVaSetValues ((Widget) m_drawingArea, XmNheight, h, NULL);
2606   /* TODO: is this necessary?
2607   allowRepainting = FALSE;
2608
2609   XSync (XtDisplay (drawingArea), FALSE);
2610   XEvent event;
2611   while (XtAppPending (wxTheApp->appContext))
2612     {
2613       XFlush (XtDisplay (drawingArea));
2614       XtAppNextEvent (wxTheApp->appContext, &event);
2615       XtDispatchEvent (&event);
2616     }
2617     */
2618
2619   XtVaSetValues((Widget) m_drawingArea, XmNresizePolicy, XmRESIZE_NONE, NULL);
2620
2621   /* TODO
2622   allowRepainting = TRUE;
2623   DoRefresh ();
2624   */
2625
2626   wxSizeEvent sizeEvent(wxSize(w, h), GetId());
2627   sizeEvent.SetEventObject(this);
2628
2629   GetEventHandler()->ProcessEvent(sizeEvent);
2630 }
2631
2632 void wxWindow::CanvasGetClientSize (int *w, int *h) const
2633 {
2634   // Must return the same thing that was set via SetClientSize
2635   Dimension xx, yy;
2636   XtVaGetValues ((Widget) m_drawingArea, XmNwidth, &xx, XmNheight, &yy, NULL);
2637   *w = xx;
2638   *h = yy;
2639 }
2640
2641 void wxWindow::CanvasGetSize (int *w, int *h) const
2642 {
2643   Dimension xx, yy;
2644   if ((Widget) m_borderWidget)
2645     XtVaGetValues ((Widget) m_borderWidget, XmNwidth, &xx, XmNheight, &yy, NULL);
2646   else if ((Widget) m_scrolledWindow)
2647     XtVaGetValues ((Widget) m_scrolledWindow, XmNwidth, &xx, XmNheight, &yy, NULL);
2648   else
2649     XtVaGetValues ((Widget) m_drawingArea, XmNwidth, &xx, XmNheight, &yy, NULL);
2650
2651   *w = xx;
2652   *h = yy;
2653 }
2654
2655 void wxWindow::CanvasGetPosition (int *x, int *y) const
2656 {
2657     Position xx, yy;
2658     XtVaGetValues (m_borderWidget ? (Widget) m_borderWidget : (Widget) m_scrolledWindow, XmNx, &xx, XmNy, &yy, NULL);
2659
2660     // We may be faking the client origin.
2661     // So a window that's really at (0, 30) may appear
2662     // (to wxWin apps) to be at (0, 0).
2663     if (GetParent())
2664     {
2665         wxPoint pt(GetParent()->GetClientAreaOrigin());
2666         xx -= pt.x;
2667         yy -= pt.y;
2668     }
2669
2670     *x = xx;
2671     *y = yy;
2672 }
2673
2674 // Add to hash table, add event handler
2675 bool wxWindow::AttachWidget (wxWindow* parent, WXWidget mainWidget,
2676               WXWidget formWidget, int x, int y, int width, int height)
2677 {
2678     wxAddWindowToTable((Widget) mainWidget, this);
2679     if (CanAddEventHandler())
2680     {
2681         XtAddEventHandler((Widget) mainWidget,
2682           ButtonPressMask | ButtonReleaseMask | PointerMotionMask, // | KeyPressMask,
2683         False,
2684         wxPanelItemEventHandler,
2685         (XtPointer) this);
2686     }
2687
2688     if (!formWidget)
2689     {
2690         XtTranslations ptr;
2691         XtOverrideTranslations ((Widget) mainWidget,
2692                ptr = XtParseTranslationTable ("<Configure>: resize()"));
2693         XtFree ((char *) ptr);
2694     }
2695
2696     // Some widgets have a parent form widget, e.g. wxRadioBox
2697     if (formWidget)
2698     {
2699       if (!wxAddWindowToTable((Widget) formWidget, this))
2700         return FALSE;
2701
2702       XtTranslations ptr;
2703       XtOverrideTranslations ((Widget) formWidget,
2704                    ptr = XtParseTranslationTable ("<Configure>: resize()"));
2705       XtFree ((char *) ptr);
2706     }
2707
2708     if (x == -1)
2709       x = 0;
2710     if (y == -1)
2711       y = 0;
2712     SetSize (x, y, width, height);
2713
2714     return TRUE;
2715 }
2716
2717 // Remove event handler, remove from hash table
2718 bool wxWindow::DetachWidget(WXWidget widget)
2719 {
2720     if (CanAddEventHandler())
2721     {
2722       XtRemoveEventHandler((Widget) widget,
2723          ButtonPressMask | ButtonReleaseMask | PointerMotionMask, // | KeyPressMask,
2724          False,
2725          wxPanelItemEventHandler,
2726          (XtPointer)this);
2727     }
2728
2729     wxDeleteWindowFromTable((Widget) widget);
2730     return TRUE;
2731 }
2732
2733 void wxPanelItemEventHandler (Widget    wid,
2734                               XtPointer client_data,
2735                               XEvent*   event,
2736                               Boolean *continueToDispatch)
2737 {
2738   // Widget can be a label or the actual widget.
2739
2740   wxWindow *window = (wxWindow *)wxWidgetHashTable->Get((long)wid);
2741   if (window)
2742   {
2743     wxMouseEvent wxevent(0);
2744     if (wxTranslateMouseEvent(wxevent, window, wid, event))
2745     {
2746       window->GetEventHandler()->ProcessEvent(wxevent);
2747     }
2748   }
2749   // TODO: probably the key to allowing default behaviour
2750   // to happen.
2751   // Say we set a m_doDefault flag to FALSE at the start of this
2752   // function. Then in e.g. wxWindow::OnMouseEvent we can
2753   // call Default() which sets this flag to TRUE, indicating
2754   // that default processing can happen. Thus, behaviour can appear
2755   // to be overridden just by adding an event handler and not calling
2756   // wxWindow::OnWhatever.
2757   // ALSO, maybe we can use this instead of the current way of handling
2758   // drawing area events, to simplify things.
2759   *continueToDispatch = True;
2760 }
2761
2762 static void wxScrollBarCallback(Widget scrollbar, XtPointer clientData,
2763                         XmScaleCallbackStruct *cbs)
2764 {
2765     Widget scrolledWindow = XtParent (scrollbar);
2766     wxWindow *win = (wxWindow *) wxWidgetHashTable->Get ((long) scrolledWindow);
2767     int orientation = (int) clientData;
2768
2769     wxEventType eventType = wxEVT_NULL;
2770     switch (cbs->reason)
2771     {
2772         case XmCR_INCREMENT:
2773         {
2774             eventType = wxEVT_SCROLL_LINEDOWN;
2775             break;
2776         }
2777         case XmCR_DECREMENT:
2778         {
2779             eventType = wxEVT_SCROLL_LINEUP;
2780             break;
2781         }
2782         case XmCR_DRAG:
2783         {
2784             eventType = wxEVT_SCROLL_THUMBTRACK;
2785             break;
2786         }
2787         case XmCR_VALUE_CHANGED:
2788         {
2789             // TODO: Should this be intercepted too, or will it cause
2790             // duplicate events?
2791             eventType = wxEVT_SCROLL_THUMBTRACK;
2792             break;
2793         }
2794         case XmCR_PAGE_INCREMENT:
2795         {
2796             eventType = wxEVT_SCROLL_PAGEDOWN;
2797             break;
2798         }
2799         case XmCR_PAGE_DECREMENT:
2800         {
2801             eventType = wxEVT_SCROLL_PAGEUP;
2802             break;
2803         }
2804         case XmCR_TO_TOP:
2805         {
2806             eventType = wxEVT_SCROLL_TOP;
2807             break;
2808         }
2809         case XmCR_TO_BOTTOM:
2810         {
2811             eventType = wxEVT_SCROLL_BOTTOM;
2812             break;
2813         }
2814         default:
2815         {
2816             // Should never get here
2817             wxFAIL_MSG("Unknown scroll event.");
2818             break;
2819         }
2820     }
2821
2822     wxScrollEvent event(eventType, win->GetId());
2823     event.SetEventObject(win);
2824     event.SetPosition(cbs->value);
2825     event.SetOrientation( (orientation == XmHORIZONTAL) ? wxHORIZONTAL : wxVERTICAL );
2826
2827     win->GetEventHandler()->ProcessEvent(event);
2828 }
2829
2830 bool wxTranslateMouseEvent(wxMouseEvent& wxevent, wxWindow *win, Widget widget, XEvent *xevent)
2831 {
2832   switch (xevent->xany.type)
2833   {
2834     case EnterNotify:
2835     case LeaveNotify:
2836     case ButtonPress:
2837     case ButtonRelease:
2838     case MotionNotify:
2839       {
2840         wxEventType eventType = wxEVT_NULL;
2841
2842         if (xevent->xany.type == LeaveNotify)
2843         {
2844           win->m_button1Pressed = FALSE;
2845           win->m_button2Pressed = FALSE;
2846           win->m_button3Pressed = FALSE;
2847           return FALSE;
2848         }
2849         else if (xevent->xany.type == MotionNotify)
2850           {
2851             eventType = wxEVT_MOTION;
2852           }
2853         else if (xevent->xany.type == ButtonPress)
2854           {
2855             if (xevent->xbutton.button == Button1)
2856               {
2857                 eventType = wxEVT_LEFT_DOWN;
2858                 win->m_button1Pressed = TRUE;
2859               }
2860             else if (xevent->xbutton.button == Button2)
2861               {
2862                 eventType = wxEVT_MIDDLE_DOWN;
2863                 win->m_button2Pressed = TRUE;
2864               }
2865             else if (xevent->xbutton.button == Button3)
2866               {
2867                 eventType = wxEVT_RIGHT_DOWN;
2868                 win->m_button3Pressed = TRUE;
2869               }
2870           }
2871         else if (xevent->xany.type == ButtonRelease)
2872           {
2873             if (xevent->xbutton.button == Button1)
2874               {
2875                 eventType = wxEVT_LEFT_UP;
2876                 win->m_button1Pressed = FALSE;
2877               }
2878             else if (xevent->xbutton.button == Button2)
2879               {
2880                 eventType = wxEVT_MIDDLE_UP;
2881                 win->m_button2Pressed = FALSE;
2882               }
2883             else if (xevent->xbutton.button == Button3)
2884               {
2885                 eventType = wxEVT_RIGHT_UP;
2886                 win->m_button3Pressed = FALSE;
2887               }
2888             else return FALSE;
2889           }
2890           else return FALSE;
2891
2892         wxevent.m_eventHandle = (char *)xevent;
2893         wxevent.SetEventType(eventType);
2894
2895         Position x1, y1;
2896         XtVaGetValues(widget, XmNx, &x1, XmNy, &y1, NULL);
2897
2898         int x2, y2;
2899         win->GetPosition(&x2, &y2);
2900
2901         // The button x/y must be translated to wxWindows
2902         // window space - the widget might be a label or button,
2903         // within a form.
2904         int dx = 0;
2905         int dy = 0;
2906         if (widget != (Widget)win->GetMainWidget())
2907         {
2908           dx = x1;
2909           dy = y1;
2910         }
2911
2912         wxevent.m_x = xevent->xbutton.x + dx;
2913         wxevent.m_y = xevent->xbutton.y + dy;
2914
2915         wxevent.m_leftDown = ((eventType == wxEVT_LEFT_DOWN)
2916                             || (event_left_is_down (xevent)
2917                                 && (eventType != wxEVT_LEFT_UP)));
2918         wxevent.m_middleDown = ((eventType == wxEVT_MIDDLE_DOWN)
2919                               || (event_middle_is_down (xevent)
2920                                   && (eventType != wxEVT_MIDDLE_UP)));
2921         wxevent.m_rightDown = ((eventType == wxEVT_RIGHT_DOWN)
2922                              || (event_right_is_down (xevent)
2923                                  && (eventType != wxEVT_RIGHT_UP)));
2924
2925         wxevent.m_shiftDown = xevent->xbutton.state & ShiftMask;
2926         wxevent.m_controlDown = xevent->xbutton.state & ControlMask;
2927         return TRUE;
2928     }
2929   }
2930   return FALSE;
2931 }
2932
2933 bool wxTranslateKeyEvent(wxKeyEvent& wxevent, wxWindow *win, Widget widget, XEvent *xevent)
2934 {
2935   switch (xevent->xany.type)
2936   {
2937     case KeyPress:
2938       {
2939         char buf[20];
2940
2941         KeySym keySym;
2942 //      XComposeStatus compose;
2943 //      (void) XLookupString ((XKeyEvent *) xevent, buf, 20, &keySym, &compose);
2944         (void) XLookupString ((XKeyEvent *) xevent, buf, 20, &keySym, NULL);
2945         int id = wxCharCodeXToWX (keySym);
2946
2947         if (xevent->xkey.state & ShiftMask)
2948           wxevent.m_shiftDown = TRUE;
2949         if (xevent->xkey.state & ControlMask)
2950           wxevent.m_controlDown = TRUE;
2951         if (xevent->xkey.state & Mod3Mask)
2952           wxevent.m_altDown = TRUE;
2953         if (xevent->xkey.state & Mod1Mask)
2954           wxevent.m_metaDown = TRUE;
2955         wxevent.SetEventObject(win);
2956         wxevent.m_keyCode = id;
2957         wxevent.SetTimestamp(xevent->xkey.time);
2958
2959         wxevent.m_x = xevent->xbutton.x;
2960         wxevent.m_y = xevent->xbutton.y;
2961
2962         if (id > -1)
2963           return TRUE;
2964         else
2965           return FALSE;
2966         break;
2967       }
2968     default:
2969       break;
2970   }
2971   return FALSE;
2972 }
2973
2974 #define YAllocColor XAllocColor
2975 XColor g_itemColors[5];
2976 int wxComputeColours (Display *display, wxColour * back, wxColour * fore)
2977 {
2978   int result;
2979   static XmColorProc colorProc;
2980
2981   result = wxNO_COLORS;
2982
2983   if (back)
2984     {
2985       g_itemColors[0].red = (((long) back->Red ()) << 8);
2986       g_itemColors[0].green = (((long) back->Green ()) << 8);
2987       g_itemColors[0].blue = (((long) back->Blue ()) << 8);
2988       g_itemColors[0].flags = DoRed | DoGreen | DoBlue;
2989       if (colorProc == (XmColorProc) NULL)
2990         {
2991           // Get a ptr to the actual function
2992           colorProc = XmSetColorCalculation ((XmColorProc) NULL);
2993           // And set it back to motif.
2994           XmSetColorCalculation (colorProc);
2995         }
2996       (*colorProc) (&g_itemColors[wxBACK_INDEX],
2997                     &g_itemColors[wxFORE_INDEX],
2998                     &g_itemColors[wxSELE_INDEX],
2999                     &g_itemColors[wxTOPS_INDEX],
3000                     &g_itemColors[wxBOTS_INDEX]);
3001       result = wxBACK_COLORS;
3002     }
3003   if (fore)
3004     {
3005       g_itemColors[wxFORE_INDEX].red = (((long) fore->Red ()) << 8);
3006       g_itemColors[wxFORE_INDEX].green = (((long) fore->Green ()) << 8);
3007       g_itemColors[wxFORE_INDEX].blue = (((long) fore->Blue ()) << 8);
3008       g_itemColors[wxFORE_INDEX].flags = DoRed | DoGreen | DoBlue;
3009       if (result == wxNO_COLORS)
3010         result = wxFORE_COLORS;
3011     }
3012
3013   Display *dpy = display;
3014   Colormap cmap = (Colormap) wxTheApp->GetMainColormap((WXDisplay*) dpy);
3015
3016   if (back)
3017     {
3018       /* 5 Colours to allocate */
3019       for (int i = 0; i < 5; i++)
3020         if (!YAllocColor (dpy, cmap, &g_itemColors[i]))
3021           result = wxNO_COLORS;
3022     }
3023   else if (fore)
3024     {
3025       /* Only 1 colour to allocate */
3026       if (!YAllocColor (dpy, cmap, &g_itemColors[wxFORE_INDEX]))
3027         result = wxNO_COLORS;
3028     }
3029
3030   return (result);
3031
3032 }
3033
3034 // Changes the foreground and background colours to be derived
3035 // from the current background colour.
3036 // To change the foreground colour, you must call SetForegroundColour
3037 // explicitly.
3038 void wxWindow::ChangeBackgroundColour()
3039 {
3040     if (GetMainWidget())
3041         DoChangeBackgroundColour(GetMainWidget(), m_backgroundColour);
3042 }
3043
3044 void wxWindow::ChangeForegroundColour()
3045 {
3046     if (GetMainWidget())
3047         DoChangeForegroundColour(GetMainWidget(), m_foregroundColour);
3048 }
3049
3050 // Change a widget's foreground and background colours.
3051
3052 void wxWindow::DoChangeForegroundColour(WXWidget widget, wxColour& foregroundColour)
3053 {
3054   // When should we specify the foreground, if it's calculated
3055   // by wxComputeColours?
3056   // Solution: say we start with the default (computed) foreground colour.
3057   // If we call SetForegroundColour explicitly for a control or window,
3058   // then the foreground is changed.
3059   // Therefore SetBackgroundColour computes the foreground colour, and
3060   // SetForegroundColour changes the foreground colour. The ordering is
3061   // important.
3062
3063   XtVaSetValues ((Widget) widget,
3064                    XmNforeground, foregroundColour.AllocColour(XtDisplay((Widget) widget)),
3065                    NULL);
3066 }
3067
3068 void wxWindow::DoChangeBackgroundColour(WXWidget widget, wxColour& backgroundColour, bool changeArmColour)
3069 {
3070   wxComputeColours (XtDisplay((Widget) widget), & backgroundColour,
3071                             (wxColour*) NULL);
3072
3073   XtVaSetValues ((Widget) widget,
3074                    XmNbackground, g_itemColors[wxBACK_INDEX].pixel,
3075                    XmNtopShadowColor, g_itemColors[wxTOPS_INDEX].pixel,
3076                    XmNbottomShadowColor, g_itemColors[wxBOTS_INDEX].pixel,
3077                    XmNforeground, g_itemColors[wxFORE_INDEX].pixel,
3078                    NULL);
3079
3080   if (changeArmColour)
3081     XtVaSetValues ((Widget) widget,
3082                    XmNarmColor, g_itemColors[wxSELE_INDEX].pixel,
3083                NULL);
3084 }
3085
3086 void wxWindow::SetBackgroundColour(const wxColour& col)
3087 {
3088     m_backgroundColour = col;
3089     ChangeBackgroundColour();
3090 }
3091
3092 void wxWindow::SetForegroundColour(const wxColour& col)
3093 {
3094     m_foregroundColour = col;
3095     ChangeForegroundColour();
3096 }
3097
3098 void wxWindow::ChangeFont(bool keepOriginalSize)
3099 {
3100     // Note that this causes the widget to be resized back
3101     // to its original size! We therefore have to set the size
3102     // back again. TODO: a better way in Motif?
3103     Widget w = (Widget) GetLabelWidget(); // Usually the main widget
3104     if (w && m_windowFont.Ok())
3105     {
3106         int width, height, width1, height1;
3107         GetSize(& width, & height);
3108
3109         XtVaSetValues (w,
3110                    XmNfontList, (XmFontList) m_windowFont.GetFontList(1.0, XtDisplay(w)),
3111                    NULL);
3112
3113         GetSize(& width1, & height1);
3114         if (keepOriginalSize && (width != width1 || height != height1))
3115         {
3116             SetSize(-1, -1, width, height);
3117         }
3118     }
3119 }
3120
3121 void wxWindow::SetFont(const wxFont& font)
3122 {
3123     m_windowFont = font;
3124     ChangeFont();
3125 }
3126
3127 void wxWindow::ClearUpdateRects()
3128 {
3129     wxNode* node = m_updateRects.First();
3130     while (node)
3131     {
3132         wxRect* rect = (wxRect*) node->Data();
3133         delete rect;
3134         node = node->Next();
3135     }
3136     m_updateRects.Clear();
3137 }
3138
3139 bool wxWindow::ProcessAccelerator(wxKeyEvent& event)
3140 {
3141     if (!m_acceleratorTable.Ok())
3142         return FALSE;
3143
3144     int count = m_acceleratorTable.GetCount();
3145     wxAcceleratorEntry* entries = m_acceleratorTable.GetEntries();
3146     int i;
3147     for (i = 0; i < count; i++)
3148     {
3149         wxAcceleratorEntry* entry = & (entries[i]);
3150         if (entry->MatchesEvent(event))
3151         {
3152             // Bingo, we have a match. Now find a control
3153             // that matches the entry command id.
3154
3155             // Need to go up to the top of the window hierarchy,
3156             // since it might be e.g. a menu item
3157             wxWindow* parent = this;
3158             while (parent && !parent->IsKindOf(CLASSINFO(wxFrame)) && !parent->IsKindOf(CLASSINFO(wxDialog)))
3159                 parent = parent->GetParent();
3160
3161             if (!parent)
3162                 return FALSE;
3163
3164             if (parent->IsKindOf(CLASSINFO(wxFrame)))
3165             {
3166                 // Try for a menu command
3167                 wxFrame* frame = (wxFrame*) parent;
3168                 if (frame->GetMenuBar())
3169                 {
3170                     wxMenuItem* item = frame->GetMenuBar()->FindItemForId(entry->GetCommand());
3171                     if (item)
3172                     {
3173                         wxCommandEvent commandEvent(wxEVT_COMMAND_MENU_SELECTED, entry->GetCommand());
3174                         commandEvent.SetEventObject(frame);
3175
3176                         // If ProcessEvent returns TRUE (it was handled), then
3177                         // the calling code will skip the event handling.
3178                         return frame->GetEventHandler()->ProcessEvent(commandEvent);
3179                     }
3180                 }
3181             }
3182
3183             // Find a child matching the command id
3184             wxWindow* child = parent->FindWindow(entry->GetCommand());
3185
3186             // No such child
3187             if (!child)
3188                 return FALSE;
3189
3190             // Now we process those kinds of windows that we can.
3191             // For now, only buttons.
3192             if (child->IsKindOf(CLASSINFO(wxButton)))
3193             {
3194                 wxCommandEvent commandEvent (wxEVT_COMMAND_BUTTON_CLICKED, child->GetId());
3195                 commandEvent.SetEventObject(child);
3196                 return child->GetEventHandler()->ProcessEvent(commandEvent);
3197             }
3198
3199             return FALSE;
3200         } // matches event
3201     }// for
3202
3203     // We didn't match the key event against an accelerator.
3204     return FALSE;
3205 }
3206