src/gtk/window.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        window.cpp
   3 // Purpose:
   4 // Author:      Robert Roebling
   5 // Id:          $Id$
   6 // Copyright:   (c) 1998 Robert Roebling, Julian Smart
   7 // Licence:     wxWindows licence
   8 /////////////////////////////////////////////////////////////////////////////
   9
  10
  11 #ifdef __GNUG__
  12 #pragma implementation "window.h"
  13 #endif
  14
  15 #include "wx/defs.h"
  16 #include "wx/window.h"
  17 #include "wx/dc.h"
  18 #include "wx/frame.h"
  19 #include "wx/app.h"
  20 #include "wx/layout.h"
  21 #include "wx/utils.h"
  22 #include "wx/dialog.h"
  23 #include "wx/msgdlg.h"
  24 #if wxUSE_DRAG_AND_DROP
  25 #include "wx/dnd.h"
  26 #endif
  27 #include "wx/tooltip.h"
  28 #include "wx/menu.h"
  29 #include "wx/statusbr.h"
  30 #include "wx/intl.h"
  31 #include "wx/settings.h"
  32 #include "wx/log.h"
  33
  34 #include <math.h>
  35
  36 #include "gdk/gdk.h"
  37 #include "gtk/gtk.h"
  38 #include "gdk/gdkprivate.h"
  39 #include "gdk/gdkkeysyms.h"
  40 #include "wx/gtk/win_gtk.h"
  41
  42 //-----------------------------------------------------------------------------
  43 // documentation on internals
  44 //-----------------------------------------------------------------------------
  45
  46 /*
  47    I have been asked several times about writing some documentation about
  48    the GTK port of wxWindows, especially its internal structures. Obviously,
  49    you cannot understand wxGTK without knowing a little about the GTK, but
  50    some more information about what the wxWindow, which is the base class
  51    for all other window classes, does seems required as well.
  52
  53    What does wxWindow do? It contains the common interface for the following
  54    jobs of its descendants:
  55
  56    1) Define the rudimentary behaviour common to all window classes, such as
  57    resizing, intercepting user input (so as to make it possible to use these
  58    events for special purposes in a derived class), window names etc.
  59
  60    2) Provide the possibility to contain and manage children, if the derived
  61    class is allowed to contain children, which holds true for those window
  62    classes which do not display a native GTK widget. To name them, these
  63    classes are wxPanel, wxScrolledWindow, wxDialog, wxFrame. The MDI frame-
  64    work classes are a special case and are handled a bit differently from
  65    the rest. The same holds true for the wxNotebook class.
  66
  67    3) Provide the possibility to draw into a client area of a window. This,
  68    too, only holds true for classes that do not display a native GTK widget
  69    as above.
  70
  71    4) Provide the entire mechanism for scrolling widgets. This actual inter-
  72    face for this is usually in wxScrolledWindow, but the GTK implementation
  73    is in this class.
  74
  75    5) A multitude of helper or extra methods for special purposes, such as
  76    Drag'n'Drop, managing validators etc.
  77
  78    Normally one might expect, that one wxWindows window would always correspond
  79    to one GTK widget. Under GTK, there is no such allround widget that has all
  80    the functionality. Moreover, the GTK defines a client area as a different
  81    widget from the actual widget you are handling. Last but not least some
  82    special classes (e.g. wxFrame) handle different categories of widgets and
  83    still have the possibility to draw something in the client area.
  84    It was therefore required to write a special purpose GTK widget, that would
  85    represent a client area in the sense of wxWindows capable to do the jobs
  86    2), 3) and 4). I have written this class and it resides in win_gtk.c of
  87    this directory.
  88
  89    All windows must have a widget, with which they interact with other under-
  90    lying GTK widgets. It is this widget, e.g. that has to be resized etc and
  91    thw wxWindow class has a member variable called m_widget which holds a
  92    pointer to this widget. When the window class represents a GTK native widget,
  93    this is (in most cases) the only GTK widget the class manages. E.g. the
  94    wxStatitText class handles only a GtkLabel widget a pointer to which you
  95    can find in m_widget (defined in wxWindow)
  96
  97    When the class has a client area for drawing into and for containing children
  98    it has to handle the client area widget (of the type GtkMyFixed, defined in
  99    win_gtk.c), but there could be any number of widgets, handled by a class
 100    The common rule for all windows is only, that the widget that interacts with
 101    the rest of GTK must be referenced in m_widget and all other widgets must be
 102    children of this widget on the GTK level. The top-most widget, which also
 103    represents the client area, must be in the m_wxwindow field and must be of
 104    the type GtkMyFixed.
 105
 106    As I said, the window classes that display a GTK native widget only have
 107    one widget, so in the case of e.g. the wxButton class m_widget holds a
 108    pointer to a GtkButton widget. But windows with client areas (for drawing
 109    and children) have a m_widget field that is a pointer to a GtkScrolled-
 110    Window and a m_wxwindow field that is pointer to a GtkMyFixed and this
 111    one is (in the GTK sense) a child of the GtkScrolledWindow.
 112
 113    If the m_wxwindow field is set, then all input to this widget is inter-
 114    cepted and sent to the wxWindows class. If not, all input to the widget
 115    that gets pointed to by m_widget gets intercepted and sent to the class.
 116
 117 */
 118
 119 //-------------------------------------------------------------------------
 120 // conditional compilation
 121 //-------------------------------------------------------------------------
 122
 123 #if (GTK_MINOR_VERSION == 1)
 124 #if (GTK_MICRO_VERSION >= 5)
 125 #define NEW_GTK_SCROLL_CODE
 126 #endif
 127 #endif
 128
 129 //-----------------------------------------------------------------------------
 130 // (debug)
 131 //-----------------------------------------------------------------------------
 132
 133 #ifdef __WXDEBUG__
 134
 135 static gint gtk_debug_focus_in_callback( GtkWidget *WXUNUSED(widget),
 136                                          GdkEvent *WXUNUSED(event),
 137                                          const char *name )
 138 {
 139     printf( "FOCUS NOW AT: " );
 140     printf( name );
 141     printf( "\n" );
 142
 143     return FALSE;
 144 }
 145
 146 void debug_focus_in( GtkWidget* widget, const char* name, const char *window )
 147 {
 148     return;
 149
 150     wxString tmp = name;
 151     tmp += " FROM ";
 152     tmp += window;
 153
 154     char *s = new char[tmp.Length()+1];
 155
 156     strcpy( s, WXSTRINGCAST tmp );
 157
 158     gtk_signal_connect( GTK_OBJECT(widget), "focus_in_event",
 159       GTK_SIGNAL_FUNC(gtk_debug_focus_in_callback), (gpointer)s );
 160 }
 161
 162 #endif
 163
 164 //-----------------------------------------------------------------------------
 165 // data
 166 //-----------------------------------------------------------------------------
 167
 168 extern wxList     wxPendingDelete;
 169 extern wxList     wxTopLevelWindows;
 170 extern bool       g_blockEventsOnDrag;
 171 extern bool       g_blockEventsOnScroll;
 172 static bool       g_capturing = FALSE;
 173 static wxWindow  *g_focusWindow = (wxWindow*) NULL;
 174
 175 // hack: we need something to pass to gtk_menu_popup, so we store the time of
 176 // the last click here
 177 static guint32 gs_timeLastClick = 0;
 178
 179 //-----------------------------------------------------------------------------
 180 // "expose_event" (of m_wxwindow, not of m_widget)
 181 //-----------------------------------------------------------------------------
 182
 183 static void gtk_window_expose_callback( GtkWidget *WXUNUSED(widget), GdkEventExpose *gdk_event, wxWindow *win )
 184 {
 185     if (!win->HasVMT()) return;
 186
 187     win->m_updateRegion.Union( gdk_event->area.x,
 188                                gdk_event->area.y,
 189                                gdk_event->area.width,
 190                                gdk_event->area.height );
 191
 192     if (gdk_event->count > 0) return;
 193
 194 /*
 195     printf( "OnExpose from " );
 196     if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
 197         printf( win->GetClassInfo()->GetClassName() );
 198     printf( ".\n" );
 199 */
 200
 201     wxPaintEvent event( win->GetId() );
 202     event.SetEventObject( win );
 203     win->GetEventHandler()->ProcessEvent( event );
 204
 205     win->m_updateRegion.Clear();
 206 }
 207
 208 //-----------------------------------------------------------------------------
 209 // "draw" (of m_wxwindow, not of m_widget)
 210 //-----------------------------------------------------------------------------
 211
 212 static void gtk_window_draw_callback( GtkWidget *WXUNUSED(widget), GdkRectangle *rect, wxWindow *win )
 213 {
 214     if (!win->HasVMT()) return;
 215
 216     win->m_updateRegion.Union( rect->x, rect->y, rect->width, rect->height );
 217
 218     wxPaintEvent event( win->GetId() );
 219     event.SetEventObject( win );
 220     win->GetEventHandler()->ProcessEvent( event );
 221
 222     win->m_updateRegion.Clear();
 223 }
 224
 225 //-----------------------------------------------------------------------------
 226 // "key_press_event" from any window
 227 //-----------------------------------------------------------------------------
 228
 229 static gint gtk_window_key_press_callback( GtkWidget *widget, GdkEventKey *gdk_event, wxWindow *win )
 230 {
 231     if (!win->HasVMT()) return FALSE;
 232     if (g_blockEventsOnDrag) return FALSE;
 233
 234 /*
 235     printf( "OnKeyPress from " );
 236     if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
 237         printf( win->GetClassInfo()->GetClassName() );
 238     printf( ".\n" );
 239 */
 240
 241     long key_code = 0;
 242     switch (gdk_event->keyval)
 243     {
 244         case GDK_BackSpace:     key_code = WXK_BACK;        break;
 245         case GDK_Tab:           key_code = WXK_TAB;         break;
 246         case GDK_Linefeed:      key_code = WXK_RETURN;      break;
 247         case GDK_Clear:         key_code = WXK_CLEAR;       break;
 248         case GDK_Return:        key_code = WXK_RETURN;      break;
 249         case GDK_Pause:         key_code = WXK_PAUSE;       break;
 250         case GDK_Scroll_Lock:   key_code = WXK_SCROLL;      break;
 251         case GDK_Escape:        key_code = WXK_ESCAPE;      break;
 252         case GDK_Delete:        key_code = WXK_DELETE;      break;
 253         case GDK_Home:          key_code = WXK_HOME;        break;
 254         case GDK_Left:          key_code = WXK_LEFT;        break;
 255         case GDK_Up:            key_code = WXK_UP;          break;
 256         case GDK_Right:         key_code = WXK_RIGHT;       break;
 257         case GDK_Down:          key_code = WXK_DOWN;        break;
 258         case GDK_Prior:         key_code = WXK_PRIOR;       break;
 259 //      case GDK_Page_Up:       key_code = WXK_PAGEUP;      break;
 260         case GDK_Next:          key_code = WXK_NEXT;        break;
 261 //      case GDK_Page_Down:     key_code = WXK_PAGEDOWN;    break;
 262         case GDK_End:           key_code = WXK_END;         break;
 263         case GDK_Begin:         key_code = WXK_HOME;        break;
 264         case GDK_Select:        key_code = WXK_SELECT;      break;
 265         case GDK_Print:         key_code = WXK_PRINT;       break;
 266         case GDK_Execute:       key_code = WXK_EXECUTE;     break;
 267         case GDK_Insert:        key_code = WXK_INSERT;      break;
 268         case GDK_Num_Lock:      key_code = WXK_NUMLOCK;     break;
 269         case GDK_KP_Tab:        key_code = WXK_TAB;         break;
 270         case GDK_KP_Enter:      key_code = WXK_RETURN;      break;
 271         case GDK_KP_Home:       key_code = WXK_HOME;        break;
 272         case GDK_KP_Left:       key_code = WXK_LEFT;        break;
 273         case GDK_KP_Up:         key_code = WXK_UP;          break;
 274         case GDK_KP_Right:      key_code = WXK_RIGHT;       break;
 275         case GDK_KP_Down:       key_code = WXK_DOWN;        break;
 276         case GDK_KP_Prior:      key_code = WXK_PRIOR;       break;
 277 //      case GDK_KP_Page_Up:    key_code = WXK_PAGEUP;      break;
 278         case GDK_KP_Next:       key_code = WXK_NEXT;        break;
 279 //      case GDK_KP_Page_Down:  key_code = WXK_PAGEDOWN;    break;
 280         case GDK_KP_End:        key_code = WXK_END;         break;
 281         case GDK_KP_Begin:      key_code = WXK_HOME;        break;
 282         case GDK_KP_Insert:     key_code = WXK_INSERT;      break;
 283         case GDK_KP_Delete:     key_code = WXK_DELETE;      break;
 284         case GDK_KP_Multiply:   key_code = WXK_MULTIPLY;    break;
 285         case GDK_KP_Add:        key_code = WXK_ADD;         break;
 286         case GDK_KP_Separator:  key_code = WXK_SEPARATOR;   break;
 287         case GDK_KP_Subtract:   key_code = WXK_SUBTRACT;    break;
 288         case GDK_KP_Decimal:    key_code = WXK_DECIMAL;     break;
 289         case GDK_KP_Divide:     key_code = WXK_DIVIDE;      break;
 290         case GDK_KP_0:          key_code = WXK_NUMPAD0;     break;
 291         case GDK_KP_1:          key_code = WXK_NUMPAD1;     break;
 292         case GDK_KP_2:          key_code = WXK_NUMPAD2;     break;
 293         case GDK_KP_3:          key_code = WXK_NUMPAD3;     break;
 294         case GDK_KP_4:          key_code = WXK_NUMPAD4;     break;
 295         case GDK_KP_5:          key_code = WXK_NUMPAD5;     break;
 296         case GDK_KP_6:          key_code = WXK_NUMPAD6;     break;
 297         case GDK_KP_7:          key_code = WXK_NUMPAD7;     break;
 298         case GDK_KP_8:          key_code = WXK_NUMPAD7;     break;
 299         case GDK_KP_9:          key_code = WXK_NUMPAD9;     break;
 300         case GDK_F1:            key_code = WXK_F1;          break;
 301         case GDK_F2:            key_code = WXK_F2;          break;
 302         case GDK_F3:            key_code = WXK_F3;          break;
 303         case GDK_F4:            key_code = WXK_F4;          break;
 304         case GDK_F5:            key_code = WXK_F5;          break;
 305         case GDK_F6:            key_code = WXK_F6;          break;
 306         case GDK_F7:            key_code = WXK_F7;          break;
 307         case GDK_F8:            key_code = WXK_F8;          break;
 308         case GDK_F9:            key_code = WXK_F9;          break;
 309         case GDK_F10:           key_code = WXK_F10;         break;
 310         case GDK_F11:           key_code = WXK_F11;         break;
 311         case GDK_F12:           key_code = WXK_F12;         break;
 312         default:
 313         {
 314             if ((gdk_event->keyval >= 0x20) && (gdk_event->keyval <= 0xFF))
 315                 key_code = gdk_event->keyval;
 316         }
 317     }
 318
 319     if (!key_code) return FALSE;
 320
 321     wxKeyEvent event( wxEVT_KEY_DOWN );
 322     event.m_shiftDown = (gdk_event->state & GDK_SHIFT_MASK);
 323     event.m_controlDown = (gdk_event->state & GDK_CONTROL_MASK);
 324     event.m_altDown = (gdk_event->state & GDK_MOD1_MASK);
 325     event.m_metaDown = (gdk_event->state & GDK_MOD2_MASK);
 326     event.m_keyCode = key_code;
 327     event.m_x = 0;
 328     event.m_y = 0;
 329     event.SetEventObject( win );
 330
 331     bool ret = win->GetEventHandler()->ProcessEvent( event );
 332
 333     if (!ret)
 334     {
 335         wxWindow *ancestor = win;
 336         while (ancestor)
 337         {
 338             int command = ancestor->GetAcceleratorTable()->GetCommand( event );
 339             if (command != -1)
 340             {
 341                 wxCommandEvent command_event( wxEVT_COMMAND_MENU_SELECTED, command );
 342                 ret = ancestor->GetEventHandler()->ProcessEvent( command_event );
 343                 break;
 344             }
 345             ancestor = ancestor->GetParent();
 346         }
 347     }
 348
 349     // win is a control: tab can be propagated up
 350     if ((!ret) && (gdk_event->keyval == GDK_Tab))
 351     {
 352         wxNavigationKeyEvent new_event;
 353         new_event.SetDirection( !(gdk_event->state & GDK_SHIFT_MASK) );
 354         new_event.SetWindowChange( FALSE );
 355         new_event.SetCurrentFocus( win );
 356         ret = win->GetEventHandler()->ProcessEvent( new_event );
 357     }
 358
 359 /*
 360     // win is a panel: up can be propagated to the panel
 361     if ((!ret) && (win->m_wxwindow) && (win->m_parent) && (win->m_parent->AcceptsFocus()) &&
 362         (gdk_event->keyval == GDK_Up))
 363     {
 364         win->m_parent->SetFocus();
 365         ret = TRUE;
 366     }
 367
 368     // win is a panel: left/right can be propagated to the panel
 369     if ((!ret) && (win->m_wxwindow) &&
 370         ((gdk_event->keyval == GDK_Right) || (gdk_event->keyval == GDK_Left) ||
 371          (gdk_event->keyval == GDK_Up) || (gdk_event->keyval == GDK_Down)))
 372     {
 373         wxNavigationKeyEvent new_event;
 374         new_event.SetDirection( (gdk_event->keyval == GDK_Right) || (gdk_event->keyval == GDK_Down) );
 375         new_event.SetCurrentFocus( win );
 376         ret = win->GetEventHandler()->ProcessEvent( new_event );
 377     }
 378 */
 379
 380     if (ret)
 381     {
 382         gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "key_press_event" );
 383     }
 384
 385     return ret;
 386 }
 387
 388 //-----------------------------------------------------------------------------
 389 // "key_release_event" from any window
 390 //-----------------------------------------------------------------------------
 391
 392 static gint gtk_window_key_release_callback( GtkWidget *widget, GdkEventKey *gdk_event, wxWindow *win )
 393 {
 394     if (!win->HasVMT()) return FALSE;
 395     if (g_blockEventsOnDrag) return FALSE;
 396
 397 /*
 398     printf( "OnKeyRelease from " );
 399     if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
 400         printf( win->GetClassInfo()->GetClassName() );
 401     printf( ".\n" );
 402 */
 403
 404     long key_code = 0;
 405     switch (gdk_event->keyval)
 406     {
 407         case GDK_BackSpace:     key_code = WXK_BACK;        break;
 408         case GDK_Tab:           key_code = WXK_TAB;         break;
 409         case GDK_Linefeed:      key_code = WXK_RETURN;      break;
 410         case GDK_Clear:         key_code = WXK_CLEAR;       break;
 411         case GDK_Return:        key_code = WXK_RETURN;      break;
 412         case GDK_Pause:         key_code = WXK_PAUSE;       break;
 413         case GDK_Scroll_Lock:   key_code = WXK_SCROLL;      break;
 414         case GDK_Escape:        key_code = WXK_ESCAPE;      break;
 415         case GDK_Delete:        key_code = WXK_DELETE;      break;
 416         case GDK_Home:          key_code = WXK_HOME;        break;
 417         case GDK_Left:          key_code = WXK_LEFT;        break;
 418         case GDK_Up:            key_code = WXK_UP;          break;
 419         case GDK_Right:         key_code = WXK_RIGHT;       break;
 420         case GDK_Down:          key_code = WXK_DOWN;        break;
 421         case GDK_Prior:         key_code = WXK_PRIOR;       break;
 422 //      case GDK_Page_Up:       key_code = WXK_PAGEUP;      break;
 423         case GDK_Next:          key_code = WXK_NEXT;        break;
 424 //      case GDK_Page_Down:     key_code = WXK_PAGEDOWN;    break;
 425         case GDK_End:           key_code = WXK_END;         break;
 426         case GDK_Begin:         key_code = WXK_HOME;        break;
 427         case GDK_Select:        key_code = WXK_SELECT;      break;
 428         case GDK_Print:         key_code = WXK_PRINT;       break;
 429         case GDK_Execute:       key_code = WXK_EXECUTE;     break;
 430         case GDK_Insert:        key_code = WXK_INSERT;      break;
 431         case GDK_Num_Lock:      key_code = WXK_NUMLOCK;     break;
 432         case GDK_KP_Tab:        key_code = WXK_TAB;         break;
 433         case GDK_KP_Enter:      key_code = WXK_RETURN;      break;
 434         case GDK_KP_Home:       key_code = WXK_HOME;        break;
 435         case GDK_KP_Left:       key_code = WXK_LEFT;        break;
 436         case GDK_KP_Up:         key_code = WXK_UP;          break;
 437         case GDK_KP_Right:      key_code = WXK_RIGHT;       break;
 438         case GDK_KP_Down:       key_code = WXK_DOWN;        break;
 439         case GDK_KP_Prior:      key_code = WXK_PRIOR;       break;
 440 //      case GDK_KP_Page_Up:    key_code = WXK_PAGEUP;      break;
 441         case GDK_KP_Next:       key_code = WXK_NEXT;        break;
 442 //      case GDK_KP_Page_Down:  key_code = WXK_PAGEDOWN;    break;
 443         case GDK_KP_End:        key_code = WXK_END;         break;
 444         case GDK_KP_Begin:      key_code = WXK_HOME;        break;
 445         case GDK_KP_Insert:     key_code = WXK_INSERT;      break;
 446         case GDK_KP_Delete:     key_code = WXK_DELETE;      break;
 447         case GDK_KP_Multiply:   key_code = WXK_MULTIPLY;    break;
 448         case GDK_KP_Add:        key_code = WXK_ADD;         break;
 449         case GDK_KP_Separator:  key_code = WXK_SEPARATOR;   break;
 450         case GDK_KP_Subtract:   key_code = WXK_SUBTRACT;    break;
 451         case GDK_KP_Decimal:    key_code = WXK_DECIMAL;     break;
 452         case GDK_KP_Divide:     key_code = WXK_DIVIDE;      break;
 453         case GDK_KP_0:          key_code = WXK_NUMPAD0;     break;
 454         case GDK_KP_1:          key_code = WXK_NUMPAD1;     break;
 455         case GDK_KP_2:          key_code = WXK_NUMPAD2;     break;
 456         case GDK_KP_3:          key_code = WXK_NUMPAD3;     break;
 457         case GDK_KP_4:          key_code = WXK_NUMPAD4;     break;
 458         case GDK_KP_5:          key_code = WXK_NUMPAD5;     break;
 459         case GDK_KP_6:          key_code = WXK_NUMPAD6;     break;
 460         case GDK_KP_7:          key_code = WXK_NUMPAD7;     break;
 461         case GDK_KP_8:          key_code = WXK_NUMPAD7;     break;
 462         case GDK_KP_9:          key_code = WXK_NUMPAD9;     break;
 463         case GDK_F1:            key_code = WXK_F1;          break;
 464         case GDK_F2:            key_code = WXK_F2;          break;
 465         case GDK_F3:            key_code = WXK_F3;          break;
 466         case GDK_F4:            key_code = WXK_F4;          break;
 467         case GDK_F5:            key_code = WXK_F5;          break;
 468         case GDK_F6:            key_code = WXK_F6;          break;
 469         case GDK_F7:            key_code = WXK_F7;          break;
 470         case GDK_F8:            key_code = WXK_F8;          break;
 471         case GDK_F9:            key_code = WXK_F9;          break;
 472         case GDK_F10:           key_code = WXK_F10;         break;
 473         case GDK_F11:           key_code = WXK_F11;         break;
 474         case GDK_F12:           key_code = WXK_F12;         break;
 475         default:
 476         {
 477             if ((gdk_event->keyval >= 0x20) && (gdk_event->keyval <= 0xFF))
 478                 key_code = gdk_event->keyval;
 479         }
 480     }
 481
 482     if (!key_code) return FALSE;
 483
 484     wxKeyEvent event( wxEVT_KEY_UP );
 485     event.m_shiftDown = (gdk_event->state & GDK_SHIFT_MASK);
 486     event.m_controlDown = (gdk_event->state & GDK_CONTROL_MASK);
 487     event.m_altDown = (gdk_event->state & GDK_MOD1_MASK);
 488     event.m_metaDown = (gdk_event->state & GDK_MOD2_MASK);
 489     event.m_keyCode = key_code;
 490     event.m_x = 0;
 491     event.m_y = 0;
 492     event.SetEventObject( win );
 493
 494     bool ret = win->GetEventHandler()->ProcessEvent( event );
 495
 496     if (ret)
 497     {
 498         gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "key_press_event" );
 499     }
 500
 501     return ret;
 502 }
 503
 504 //-----------------------------------------------------------------------------
 505 // "button_press_event"
 506 //-----------------------------------------------------------------------------
 507
 508 static gint gtk_window_button_press_callback( GtkWidget *widget, GdkEventButton *gdk_event, wxWindow *win )
 509 {
 510     if (!win->IsOwnGtkWindow( gdk_event->window )) return TRUE;
 511
 512     if (g_blockEventsOnDrag) return TRUE;
 513     if (g_blockEventsOnScroll) return TRUE;
 514
 515     if (win->m_wxwindow)
 516     {
 517         if (GTK_WIDGET_CAN_FOCUS(win->m_wxwindow) && !GTK_WIDGET_HAS_FOCUS (win->m_wxwindow) )
 518         {
 519             gtk_widget_grab_focus (win->m_wxwindow);
 520
 521 /*
 522             printf( "GrabFocus from " );
 523             if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
 524                 printf( win->GetClassInfo()->GetClassName() );
 525             printf( ".\n" );
 526 */
 527
 528         }
 529     }
 530
 531     if (!win->HasVMT()) return TRUE;
 532
 533 /*
 534     printf( "OnButtonPress from " );
 535     if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
 536         printf( win->GetClassInfo()->GetClassName() );
 537     printf( ".\n" );
 538 */
 539
 540     wxEventType event_type = wxEVT_LEFT_DOWN;
 541
 542     if (gdk_event->button == 1)
 543     {
 544         switch (gdk_event->type)
 545         {
 546             case GDK_BUTTON_PRESS: event_type = wxEVT_LEFT_DOWN; break;
 547             case GDK_2BUTTON_PRESS: event_type = wxEVT_LEFT_DCLICK; break;
 548             default:  break;
 549         }
 550     }
 551     else if (gdk_event->button == 2)
 552     {
 553         switch (gdk_event->type)
 554         {
 555             case GDK_BUTTON_PRESS: event_type = wxEVT_MIDDLE_DOWN; break;
 556             case GDK_2BUTTON_PRESS: event_type = wxEVT_MIDDLE_DCLICK; break;
 557             default:  break;
 558         }
 559     }
 560     else if (gdk_event->button == 3)
 561     {
 562         switch (gdk_event->type)
 563         {
 564             case GDK_BUTTON_PRESS: event_type = wxEVT_RIGHT_DOWN; break;
 565             case GDK_2BUTTON_PRESS: event_type = wxEVT_RIGHT_DCLICK; break;
 566             default:  break;
 567         }
 568     }
 569
 570     wxMouseEvent event( event_type );
 571     event.m_shiftDown = (gdk_event->state & GDK_SHIFT_MASK);
 572     event.m_controlDown = (gdk_event->state & GDK_CONTROL_MASK);
 573     event.m_altDown = (gdk_event->state & GDK_MOD1_MASK);
 574     event.m_metaDown = (gdk_event->state & GDK_MOD2_MASK);
 575     event.m_leftDown = (gdk_event->state & GDK_BUTTON1_MASK);
 576     event.m_middleDown = (gdk_event->state & GDK_BUTTON2_MASK);
 577     event.m_rightDown = (gdk_event->state & GDK_BUTTON3_MASK);
 578
 579     event.m_x = (long)gdk_event->x;
 580     event.m_y = (long)gdk_event->y;
 581
 582     // Some control don't have their own X window and thus cannot get
 583     // any events.
 584
 585     if (!g_capturing)
 586     {
 587         wxNode *node = win->GetChildren().First();
 588         while (node)
 589         {
 590             wxWindow *child = (wxWindow*)node->Data();
 591
 592             if (child->m_isStaticBox)
 593             {
 594                 // wxStaticBox is transparent in the box itself
 595                 int x = event.m_x;
 596                 int y = event.m_y;
 597                 int xx1 = child->m_x;
 598                 int yy1 = child->m_y;
 599                 int xx2 = child->m_x + child->m_width;
 600                 int yy2 = child->m_x + child->m_height;
 601
 602                 // left
 603                 if (((x >= xx1) && (x <= xx1+10) && (y >= yy1) && (y <= yy2)) ||
 604                 // right
 605                     ((x >= xx2-10) && (x <= xx2) && (y >= yy1) && (y <= yy2)) ||
 606                 // top
 607                     ((x >= xx1) && (x <= xx2) && (y >= yy1) && (y <= yy1+10)) ||
 608                 // bottom
 609                     ((x >= xx1) && (x <= xx2) && (y >= yy2-1) && (y <= yy2)))
 610                 {
 611                     win = child;
 612                     event.m_x -= child->m_x;
 613                     event.m_y -= child->m_y;
 614                     break;
 615                 }
 616
 617             }
 618             else
 619             {
 620                 if ((child->m_wxwindow == (GtkWidget*) NULL) &&
 621                     (child->m_x <= event.m_x) &&
 622                     (child->m_y <= event.m_y) &&
 623                     (child->m_x+child->m_width  >= event.m_x) &&
 624                     (child->m_y+child->m_height >= event.m_y))
 625                 {
 626                     win = child;
 627                     event.m_x -= child->m_x;
 628                     event.m_y -= child->m_y;
 629                     break;
 630                 }
 631             }
 632             node = node->Next();
 633         }
 634     }
 635
 636     wxPoint pt(win->GetClientAreaOrigin());
 637     event.m_x -= pt.x;
 638     event.m_y -= pt.y;
 639
 640     event.SetEventObject( win );
 641
 642     gs_timeLastClick = gdk_event->time;
 643
 644     if (win->GetEventHandler()->ProcessEvent( event ))
 645         gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "button_press_event" );
 646
 647     return TRUE;
 648 }
 649
 650 //-----------------------------------------------------------------------------
 651 // "button_release_event"
 652 //-----------------------------------------------------------------------------
 653
 654 static gint gtk_window_button_release_callback( GtkWidget *widget, GdkEventButton *gdk_event, wxWindow *win )
 655 {
 656     if (!win->IsOwnGtkWindow( gdk_event->window )) return TRUE;
 657
 658     if (g_blockEventsOnDrag) return TRUE;
 659     if (g_blockEventsOnScroll) return TRUE;
 660
 661     if (!win->HasVMT()) return TRUE;
 662
 663 /*
 664     printf( "OnButtonRelease from " );
 665     if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
 666         printf( win->GetClassInfo()->GetClassName() );
 667     printf( ".\n" );
 668 */
 669
 670     wxEventType event_type = wxEVT_NULL;
 671
 672     switch (gdk_event->button)
 673     {
 674         case 1: event_type = wxEVT_LEFT_UP; break;
 675         case 2: event_type = wxEVT_MIDDLE_UP; break;
 676         case 3: event_type = wxEVT_RIGHT_UP; break;
 677     }
 678
 679     wxMouseEvent event( event_type );
 680     event.m_shiftDown = (gdk_event->state & GDK_SHIFT_MASK);
 681     event.m_controlDown = (gdk_event->state & GDK_CONTROL_MASK);
 682     event.m_altDown = (gdk_event->state & GDK_MOD1_MASK);
 683     event.m_metaDown = (gdk_event->state & GDK_MOD2_MASK);
 684     event.m_leftDown = (gdk_event->state & GDK_BUTTON1_MASK);
 685     event.m_middleDown = (gdk_event->state & GDK_BUTTON2_MASK);
 686     event.m_rightDown = (gdk_event->state & GDK_BUTTON3_MASK);
 687     event.m_x = (long)gdk_event->x;
 688     event.m_y = (long)gdk_event->y;
 689
 690     // Some control don't have their own X window and thus cannot get
 691     // any events.
 692
 693     if (!g_capturing)
 694     {
 695         wxNode *node = win->GetChildren().First();
 696         while (node)
 697         {
 698             wxWindow *child = (wxWindow*)node->Data();
 699
 700             if (child->m_isStaticBox)
 701             {
 702                 // wxStaticBox is transparent in the box itself
 703                 int x = event.m_x;
 704                 int y = event.m_y;
 705                 int xx1 = child->m_x;
 706                 int yy1 = child->m_y;
 707                 int xx2 = child->m_x + child->m_width;
 708                 int yy2 = child->m_x + child->m_height;
 709
 710                 // left
 711                 if (((x >= xx1) && (x <= xx1+10) && (y >= yy1) && (y <= yy2)) ||
 712                 // right
 713                     ((x >= xx2-10) && (x <= xx2) && (y >= yy1) && (y <= yy2)) ||
 714                 // top
 715                     ((x >= xx1) && (x <= xx2) && (y >= yy1) && (y <= yy1+10)) ||
 716                 // bottom
 717                     ((x >= xx1) && (x <= xx2) && (y >= yy2-1) && (y <= yy2)))
 718                 {
 719                     win = child;
 720                     event.m_x -= child->m_x;
 721                     event.m_y -= child->m_y;
 722                     break;
 723                 }
 724
 725             }
 726             else
 727             {
 728                 if ((child->m_wxwindow == (GtkWidget*) NULL) &&
 729                     (child->m_x <= event.m_x) &&
 730                     (child->m_y <= event.m_y) &&
 731                     (child->m_x+child->m_width  >= event.m_x) &&
 732                     (child->m_y+child->m_height >= event.m_y))
 733                 {
 734                     win = child;
 735                     event.m_x -= child->m_x;
 736                     event.m_y -= child->m_y;
 737                     break;
 738                 }
 739             }
 740             node = node->Next();
 741         }
 742     }
 743
 744     wxPoint pt(win->GetClientAreaOrigin());
 745     event.m_x -= pt.x;
 746     event.m_y -= pt.y;
 747
 748     event.SetEventObject( win );
 749
 750     if (win->GetEventHandler()->ProcessEvent( event ))
 751         gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "button_release_event" );
 752
 753     return TRUE;
 754 }
 755
 756 //-----------------------------------------------------------------------------
 757 // "motion_notify_event"
 758 //-----------------------------------------------------------------------------
 759
 760 static gint gtk_window_motion_notify_callback( GtkWidget *widget, GdkEventMotion *gdk_event, wxWindow *win )
 761 {
 762     if (gdk_event->is_hint)
 763     {
 764        int x = 0;
 765        int y = 0;
 766        GdkModifierType state;
 767        gdk_window_get_pointer(gdk_event->window, &x, &y, &state);
 768        gdk_event->x = x;
 769        gdk_event->y = y;
 770        gdk_event->state = state;
 771     }
 772
 773     if (!win->IsOwnGtkWindow( gdk_event->window )) return TRUE;
 774
 775     if (g_blockEventsOnDrag) return TRUE;
 776     if (g_blockEventsOnScroll) return TRUE;
 777
 778     if (!win->HasVMT()) return TRUE;
 779
 780 /*
 781     printf( "OnMotion from " );
 782     if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
 783       printf( win->GetClassInfo()->GetClassName() );
 784     printf( ".\n" );
 785 */
 786
 787     wxMouseEvent event( wxEVT_MOTION );
 788     event.m_shiftDown = (gdk_event->state & GDK_SHIFT_MASK);
 789     event.m_controlDown = (gdk_event->state & GDK_CONTROL_MASK);
 790     event.m_altDown = (gdk_event->state & GDK_MOD1_MASK);
 791     event.m_metaDown = (gdk_event->state & GDK_MOD2_MASK);
 792     event.m_leftDown = (gdk_event->state & GDK_BUTTON1_MASK);
 793     event.m_middleDown = (gdk_event->state & GDK_BUTTON2_MASK);
 794     event.m_rightDown = (gdk_event->state & GDK_BUTTON3_MASK);
 795
 796     event.m_x = (long)gdk_event->x;
 797     event.m_y = (long)gdk_event->y;
 798
 799     // Some control don't have their own X window and thus cannot get
 800     // any events.
 801
 802     if (!g_capturing)
 803     {
 804         wxNode *node = win->GetChildren().First();
 805         while (node)
 806         {
 807             wxWindow *child = (wxWindow*)node->Data();
 808
 809             if (child->m_isStaticBox)
 810             {
 811                 // wxStaticBox is transparent in the box itself
 812                 int x = event.m_x;
 813                 int y = event.m_y;
 814                 int xx1 = child->m_x;
 815                 int yy1 = child->m_y;
 816                 int xx2 = child->m_x + child->m_width;
 817                 int yy2 = child->m_x + child->m_height;
 818
 819                 // left
 820                 if (((x >= xx1) && (x <= xx1+10) && (y >= yy1) && (y <= yy2)) ||
 821                 // right
 822                     ((x >= xx2-10) && (x <= xx2) && (y >= yy1) && (y <= yy2)) ||
 823                 // top
 824                     ((x >= xx1) && (x <= xx2) && (y >= yy1) && (y <= yy1+10)) ||
 825                 // bottom
 826                     ((x >= xx1) && (x <= xx2) && (y >= yy2-1) && (y <= yy2)))
 827                 {
 828                     win = child;
 829                     event.m_x -= child->m_x;
 830                     event.m_y -= child->m_y;
 831                     break;
 832                 }
 833
 834             }
 835             else
 836             {
 837                 if ((child->m_wxwindow == (GtkWidget*) NULL) &&
 838                     (child->m_x <= event.m_x) &&
 839                     (child->m_y <= event.m_y) &&
 840                     (child->m_x+child->m_width  >= event.m_x) &&
 841                     (child->m_y+child->m_height >= event.m_y))
 842                 {
 843                     win = child;
 844                     event.m_x -= child->m_x;
 845                     event.m_y -= child->m_y;
 846                     break;
 847                 }
 848             }
 849             node = node->Next();
 850         }
 851     }
 852
 853     wxPoint pt(win->GetClientAreaOrigin());
 854     event.m_x -= pt.x;
 855     event.m_y -= pt.y;
 856
 857     event.SetEventObject( win );
 858
 859     if (win->GetEventHandler()->ProcessEvent( event ))
 860         gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "motion_notify_event" );
 861
 862     return TRUE;
 863 }
 864
 865 //-----------------------------------------------------------------------------
 866 // "focus_in_event"
 867 //-----------------------------------------------------------------------------
 868
 869 static gint gtk_window_focus_in_callback( GtkWidget *widget, GdkEvent *WXUNUSED(event), wxWindow *win )
 870 {
 871     if (g_blockEventsOnDrag) return TRUE;
 872
 873     g_focusWindow = win;
 874
 875     if (win->m_wxwindow)
 876     {
 877         if (GTK_WIDGET_CAN_FOCUS(win->m_wxwindow))
 878         {
 879             GTK_WIDGET_SET_FLAGS (win->m_wxwindow, GTK_HAS_FOCUS);
 880 /*
 881             printf( "SetFocus flag from " );
 882             if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
 883                 printf( win->GetClassInfo()->GetClassName() );
 884             printf( ".\n" );
 885 */
 886         }
 887     }
 888
 889     if (!win->HasVMT()) return TRUE;
 890
 891 /*
 892     printf( "OnSetFocus from " );
 893     if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
 894         printf( win->GetClassInfo()->GetClassName() );
 895     printf( "   " );
 896     printf( WXSTRINGCAST win->GetLabel() );
 897     printf( ".\n" );
 898 */
 899
 900     wxFocusEvent event( wxEVT_SET_FOCUS, win->GetId() );
 901     event.SetEventObject( win );
 902
 903     if (win->GetEventHandler()->ProcessEvent( event ))
 904         gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "focus_in_event" );
 905
 906     return TRUE;
 907 }
 908
 909 //-----------------------------------------------------------------------------
 910 // "focus_out_event"
 911 //-----------------------------------------------------------------------------
 912
 913 static gint gtk_window_focus_out_callback( GtkWidget *widget, GdkEvent *WXUNUSED(event), wxWindow *win )
 914 {
 915     if (g_blockEventsOnDrag) return TRUE;
 916     if (win->m_wxwindow)
 917     {
 918       if (GTK_WIDGET_CAN_FOCUS(win->m_wxwindow))
 919           GTK_WIDGET_UNSET_FLAGS (win->m_wxwindow, GTK_HAS_FOCUS);
 920     }
 921
 922     if (!win->HasVMT()) return TRUE;
 923
 924 /*
 925     printf( "OnKillFocus from " );
 926     if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
 927         printf( win->GetClassInfo()->GetClassName() );
 928     printf( ".\n" );
 929 */
 930
 931     wxFocusEvent event( wxEVT_KILL_FOCUS, win->GetId() );
 932     event.SetEventObject( win );
 933
 934     if (win->GetEventHandler()->ProcessEvent( event ))
 935         gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "focus_out_event" );
 936
 937     return TRUE;
 938 }
 939
 940 //-----------------------------------------------------------------------------
 941 // "enter_notify_event"
 942 //-----------------------------------------------------------------------------
 943
 944 static gint gtk_window_enter_callback( GtkWidget *widget, GdkEventCrossing *gdk_event, wxWindow *win )
 945 {
 946     if (g_blockEventsOnDrag) return TRUE;
 947
 948     if ((widget->window) && (win->m_cursor))
 949         gdk_window_set_cursor( widget->window, win->m_cursor->GetCursor() );
 950
 951     if (widget->window != gdk_event->window) return TRUE;
 952
 953     if (!win->HasVMT()) return TRUE;
 954
 955 /*
 956     printf( "OnEnter from " );
 957     if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
 958         printf( win->GetClassInfo()->GetClassName() );
 959     printf( ".\n" );
 960 */
 961
 962     wxMouseEvent event( wxEVT_ENTER_WINDOW );
 963     event.SetEventObject( win );
 964
 965     int x = 0;
 966     int y = 0;
 967     GdkModifierType state = (GdkModifierType)0;
 968
 969     gdk_window_get_pointer( widget->window, &x, &y, &state );
 970
 971     event.m_shiftDown = (state & GDK_SHIFT_MASK);
 972     event.m_controlDown = (state & GDK_CONTROL_MASK);
 973     event.m_altDown = (state & GDK_MOD1_MASK);
 974     event.m_metaDown = (state & GDK_MOD2_MASK);
 975     event.m_leftDown = (state & GDK_BUTTON1_MASK);
 976     event.m_middleDown = (state & GDK_BUTTON2_MASK);
 977     event.m_rightDown = (state & GDK_BUTTON3_MASK);
 978
 979     event.m_x = (long)x;
 980     event.m_y = (long)y;
 981
 982     wxPoint pt(win->GetClientAreaOrigin());
 983     event.m_x -= pt.x;
 984     event.m_y -= pt.y;
 985
 986     if (win->GetEventHandler()->ProcessEvent( event ))
 987        gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "enter_notify_event" );
 988
 989     return TRUE;
 990 }
 991
 992 //-----------------------------------------------------------------------------
 993 // "leave_notify_event"
 994 //-----------------------------------------------------------------------------
 995
 996 static gint gtk_window_leave_callback( GtkWidget *widget, GdkEventCrossing *gdk_event, wxWindow *win )
 997 {
 998     if (g_blockEventsOnDrag) return TRUE;
 999
1000     if ((widget->window) && (win->m_cursor))
1001         gdk_window_set_cursor( widget->window, wxSTANDARD_CURSOR->GetCursor() );
1002
1003     if (widget->window != gdk_event->window) return TRUE;
1004
1005     if (!win->HasVMT()) return TRUE;
1006
1007 /*
1008     printf( "OnLeave from " );
1009     if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
1010         printf( win->GetClassInfo()->GetClassName() );
1011     printf( ".\n" );
1012 */
1013
1014     wxMouseEvent event( wxEVT_LEAVE_WINDOW );
1015     event.SetEventObject( win );
1016
1017     int x = 0;
1018     int y = 0;
1019     GdkModifierType state = (GdkModifierType)0;
1020
1021     gdk_window_get_pointer( widget->window, &x, &y, &state );
1022
1023     event.m_shiftDown = (state & GDK_SHIFT_MASK);
1024     event.m_controlDown = (state & GDK_CONTROL_MASK);
1025     event.m_altDown = (state & GDK_MOD1_MASK);
1026     event.m_metaDown = (state & GDK_MOD2_MASK);
1027     event.m_leftDown = (state & GDK_BUTTON1_MASK);
1028     event.m_middleDown = (state & GDK_BUTTON2_MASK);
1029     event.m_rightDown = (state & GDK_BUTTON3_MASK);
1030
1031     event.m_x = (long)x;
1032     event.m_y = (long)y;
1033
1034     wxPoint pt(win->GetClientAreaOrigin());
1035     event.m_x -= pt.x;
1036     event.m_y -= pt.y;
1037
1038     if (win->GetEventHandler()->ProcessEvent( event ))
1039         gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "leave_notify_event" );
1040
1041     return TRUE;
1042 }
1043
1044 //-----------------------------------------------------------------------------
1045 // "value_changed" from m_vAdjust
1046 //-----------------------------------------------------------------------------
1047
1048 static void gtk_window_vscroll_callback( GtkWidget *WXUNUSED(widget), wxWindow *win )
1049 {
1050     if (g_blockEventsOnDrag) return;
1051
1052 /*
1053     printf( "OnVScroll from " );
1054     if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
1055         printf( win->GetClassInfo()->GetClassName() );
1056     printf( ".\n" );
1057 */
1058
1059     if (!win->HasVMT()) return;
1060
1061     float diff = win->m_vAdjust->value - win->m_oldVerticalPos;
1062     if (fabs(diff) < 0.2) return;
1063
1064     wxEventType command = wxEVT_NULL;
1065
1066     float line_step = win->m_vAdjust->step_increment;
1067     float page_step = win->m_vAdjust->page_increment;
1068
1069     if (win->m_isScrolling)
1070     {
1071         command = wxEVT_SCROLL_THUMBTRACK;
1072     }
1073     else
1074     {
1075         if (fabs(win->m_vAdjust->value-win->m_vAdjust->lower) < 0.2) command = wxEVT_SCROLL_BOTTOM;
1076         else if (fabs(win->m_vAdjust->value-win->m_vAdjust->upper) < 0.2) command = wxEVT_SCROLL_TOP;
1077         else if (fabs(diff-line_step) < 0.2) command = wxEVT_SCROLL_LINEDOWN;
1078         else if (fabs(diff+line_step) < 0.2) command = wxEVT_SCROLL_LINEUP;
1079         else if (fabs(diff-page_step) < 0.2) command = wxEVT_SCROLL_PAGEDOWN;
1080         else if (fabs(diff+page_step) < 0.2) command = wxEVT_SCROLL_PAGEUP;
1081         else command = wxEVT_SCROLL_THUMBTRACK;
1082     }
1083
1084     int value = (int)(win->m_vAdjust->value+0.5);
1085
1086     wxScrollEvent event( command, win->GetId(), value, wxVERTICAL );
1087     event.SetEventObject( win );
1088     win->GetEventHandler()->ProcessEvent( event );
1089 }
1090
1091 //-----------------------------------------------------------------------------
1092 // "value_changed" from m_hAdjust
1093 //-----------------------------------------------------------------------------
1094
1095 static void gtk_window_hscroll_callback( GtkWidget *WXUNUSED(widget), wxWindow *win )
1096 {
1097     if (g_blockEventsOnDrag) return;
1098
1099 /*
1100     printf( "OnHScroll from " );
1101     if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
1102         printf( win->GetClassInfo()->GetClassName() );
1103     printf( ".\n" );
1104 */
1105
1106     if (!win->HasVMT()) return;
1107
1108     float diff = win->m_hAdjust->value - win->m_oldHorizontalPos;
1109     if (fabs(diff) < 0.2) return;
1110
1111     wxEventType command = wxEVT_NULL;
1112
1113     float line_step = win->m_hAdjust->step_increment;
1114     float page_step = win->m_hAdjust->page_increment;
1115
1116     if (win->m_isScrolling)
1117     {
1118         command = wxEVT_SCROLL_THUMBTRACK;
1119     }
1120     else
1121     {
1122         if (fabs(win->m_hAdjust->value-win->m_hAdjust->lower) < 0.2) command = wxEVT_SCROLL_BOTTOM;
1123         else if (fabs(win->m_hAdjust->value-win->m_hAdjust->upper) < 0.2) command = wxEVT_SCROLL_TOP;
1124         else if (fabs(diff-line_step) < 0.2) command = wxEVT_SCROLL_LINEDOWN;
1125         else if (fabs(diff+line_step) < 0.2) command = wxEVT_SCROLL_LINEUP;
1126         else if (fabs(diff-page_step) < 0.2) command = wxEVT_SCROLL_PAGEDOWN;
1127         else if (fabs(diff+page_step) < 0.2) command = wxEVT_SCROLL_PAGEUP;
1128         else command = wxEVT_SCROLL_THUMBTRACK;
1129     }
1130
1131     int value = (int)(win->m_hAdjust->value+0.5);
1132
1133     wxScrollEvent event( command, win->GetId(), value, wxHORIZONTAL );
1134     event.SetEventObject( win );
1135     win->GetEventHandler()->ProcessEvent( event );
1136 }
1137
1138 //-----------------------------------------------------------------------------
1139 // "changed" from m_vAdjust
1140 //-----------------------------------------------------------------------------
1141
1142 static void gtk_window_vscroll_change_callback( GtkWidget *WXUNUSED(widget), wxWindow *win )
1143 {
1144     if (g_blockEventsOnDrag) return;
1145
1146 /*
1147     printf( "OnVScroll change from " );
1148     if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
1149         printf( win->GetClassInfo()->GetClassName() );
1150     printf( ".\n" );
1151 */
1152
1153     if (!win->HasVMT()) return;
1154
1155     wxEventType command = wxEVT_SCROLL_THUMBTRACK;
1156     int value = (int)(win->m_vAdjust->value+0.5);
1157
1158     wxScrollEvent event( command, win->GetId(), value, wxVERTICAL );
1159     event.SetEventObject( win );
1160     win->GetEventHandler()->ProcessEvent( event );
1161 }
1162
1163 //-----------------------------------------------------------------------------
1164 // "changed" from m_hAdjust
1165 //-----------------------------------------------------------------------------
1166
1167 static void gtk_window_hscroll_change_callback( GtkWidget *WXUNUSED(widget), wxWindow *win )
1168 {
1169     if (g_blockEventsOnDrag) return;
1170
1171 /*
1172     printf( "OnHScroll change from " );
1173     if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
1174         printf( win->GetClassInfo()->GetClassName() );
1175     printf( ".\n" );
1176 */
1177
1178     if (!win->HasVMT()) return;
1179
1180     wxEventType command = wxEVT_SCROLL_THUMBTRACK;
1181     int value = (int)(win->m_hAdjust->value+0.5);
1182
1183     wxScrollEvent event( command, win->GetId(), value, wxHORIZONTAL );
1184     event.SetEventObject( win );
1185     win->GetEventHandler()->ProcessEvent( event );
1186 }
1187
1188 //-----------------------------------------------------------------------------
1189 // "button_press_event" from scrollbar
1190 //-----------------------------------------------------------------------------
1191
1192 static gint gtk_scrollbar_button_press_callback( GtkRange *WXUNUSED(widget),
1193                                                  GdkEventButton *WXUNUSED(gdk_event),
1194                                                  wxWindow *win )
1195 {
1196 //  don't test here as we can release the mouse while being over
1197 //  a different window then the slider
1198 //
1199 //    if (gdk_event->window != widget->slider) return FALSE;
1200
1201     win->m_isScrolling = TRUE;
1202     g_blockEventsOnScroll = TRUE;
1203
1204     return FALSE;
1205 }
1206
1207 //-----------------------------------------------------------------------------
1208 // "button_release_event" from scrollbar
1209 //-----------------------------------------------------------------------------
1210
1211 static gint gtk_scrollbar_button_release_callback( GtkRange *widget,
1212                                                    GdkEventButton *WXUNUSED(gdk_event),
1213                                                    wxWindow *win )
1214 {
1215
1216 //  don't test here as we can release the mouse while being over
1217 //  a different window then the slider
1218 //
1219 //    if (gdk_event->window != widget->slider) return FALSE;
1220
1221     GtkScrolledWindow *s_window = GTK_SCROLLED_WINDOW(win->m_widget);
1222
1223     if (widget == GTK_RANGE(s_window->vscrollbar))
1224         gtk_signal_emit_by_name( GTK_OBJECT(win->m_hAdjust), "value_changed" );
1225     else
1226         gtk_signal_emit_by_name( GTK_OBJECT(win->m_vAdjust), "value_changed" );
1227
1228     win->m_isScrolling = FALSE;
1229     g_blockEventsOnScroll = FALSE;
1230
1231     return FALSE;
1232 }
1233
1234 //-----------------------------------------------------------------------------
1235 // InsertChild for wxWindow.
1236 //-----------------------------------------------------------------------------
1237
1238 /* Callback for wxWindow. This very strange beast has to be used because
1239  * C++ has no virtual methods in a constructor. We have to emulate a
1240  * virtual function here as wxNotebook requires a different way to insert
1241  * a child in it. I had opted for creating a wxNotebookPage window class
1242  * which would have made this superfluous (such in the MDI window system),
1243  * but no-one was listening to me... */
1244
1245 static void wxInsertChildInWindow( wxWindow* parent, wxWindow* child )
1246 {
1247     gtk_myfixed_put( GTK_MYFIXED(parent->m_wxwindow),
1248                      GTK_WIDGET(child->m_widget),
1249                      child->m_x,
1250                      child->m_y );
1251
1252     gtk_widget_set_usize( GTK_WIDGET(child->m_widget),
1253                           child->m_width,
1254                           child->m_height );
1255
1256     if (wxIS_KIND_OF(parent,wxFrame))
1257     {
1258         parent->m_sizeSet = FALSE;
1259     }
1260 }
1261
1262 //-----------------------------------------------------------------------------
1263 // global functions
1264 //-----------------------------------------------------------------------------
1265
1266 wxWindow* wxGetActiveWindow()
1267 {
1268   return g_focusWindow;
1269 }
1270
1271 //-----------------------------------------------------------------------------
1272 // wxWindow
1273 //-----------------------------------------------------------------------------
1274
1275 IMPLEMENT_DYNAMIC_CLASS(wxWindow,wxEvtHandler)
1276
1277 BEGIN_EVENT_TABLE(wxWindow, wxEvtHandler)
1278     EVT_SIZE(wxWindow::OnSize)
1279     EVT_SYS_COLOUR_CHANGED(wxWindow::OnSysColourChanged)
1280     EVT_INIT_DIALOG(wxWindow::OnInitDialog)
1281     EVT_KEY_DOWN(wxWindow::OnKeyDown)
1282 END_EVENT_TABLE()
1283
1284 wxWindow::wxWindow()
1285 {
1286     m_widget = (GtkWidget *) NULL;
1287     m_wxwindow = (GtkWidget *) NULL;
1288     m_parent = (wxWindow *) NULL;
1289     m_children.DeleteContents( FALSE );
1290
1291     m_x = 0;
1292     m_y = 0;
1293     m_width = 0;
1294     m_height = 0;
1295     m_minWidth = -1;
1296     m_minHeight = -1;
1297     m_maxWidth = -1;
1298     m_maxHeight = -1;
1299
1300     m_retCode = 0;
1301
1302     m_eventHandler = this;
1303     m_windowValidator = (wxValidator *) NULL;
1304
1305     m_windowId = -1;
1306
1307     m_cursor = (wxCursor *) NULL;
1308     m_font = *wxSWISS_FONT;
1309     m_windowStyle = 0;
1310     m_windowName = "noname";
1311
1312     m_constraints = (wxLayoutConstraints *) NULL;
1313     m_constraintsInvolvedIn = (wxList *) NULL;
1314     m_windowSizer = (wxSizer *) NULL;
1315     m_sizerParent = (wxWindow *) NULL;
1316     m_autoLayout = FALSE;
1317
1318     m_sizeSet = FALSE;
1319     m_hasVMT = FALSE;
1320     m_needParent = TRUE;
1321
1322     m_hasScrolling = FALSE;
1323     m_isScrolling = FALSE;
1324     m_hAdjust = (GtkAdjustment*) NULL;
1325     m_vAdjust = (GtkAdjustment*) NULL;
1326     m_oldHorizontalPos = 0.0;
1327     m_oldVerticalPos = 0.0;
1328
1329     m_isShown = FALSE;
1330     m_isEnabled = TRUE;
1331
1332 #if wxUSE_DRAG_AND_DROP
1333     m_dropTarget = (wxDropTarget*) NULL;
1334 #endif
1335     m_resizing = FALSE;
1336     m_scrollGC = (GdkGC*) NULL;
1337     m_widgetStyle = (GtkStyle*) NULL;
1338
1339     m_insertCallback = wxInsertChildInWindow;
1340
1341     m_clientObject = (wxClientData*) NULL;
1342     m_clientData = NULL;
1343
1344     m_isStaticBox = FALSE;
1345     m_acceptsFocus = FALSE;
1346
1347     m_toolTip = (wxToolTip*) NULL;
1348 }
1349
1350 wxWindow::wxWindow( wxWindow *parent, wxWindowID id,
1351                     const wxPoint &pos, const wxSize &size,
1352                     long style, const wxString &name  )
1353 {
1354     m_insertCallback = wxInsertChildInWindow;
1355     Create( parent, id, pos, size, style, name );
1356 }
1357
1358 bool wxWindow::Create( wxWindow *parent, wxWindowID id,
1359                        const wxPoint &pos, const wxSize &size,
1360                        long style, const wxString &name  )
1361 {
1362     m_isShown = FALSE;
1363     m_isEnabled = TRUE;
1364     m_needParent = TRUE;
1365
1366     PreCreation( parent, id, pos, size, style, name );
1367
1368     m_widget = gtk_scrolled_window_new( (GtkAdjustment *) NULL, (GtkAdjustment *) NULL );
1369     GTK_WIDGET_UNSET_FLAGS( m_widget, GTK_CAN_FOCUS );
1370
1371 #ifdef __WXDEBUG__
1372     debug_focus_in( m_widget, "wxWindow::m_widget", name );
1373 #endif
1374
1375     GtkScrolledWindow *s_window = GTK_SCROLLED_WINDOW(m_widget);
1376
1377 #ifdef __WXDEBUG__
1378     debug_focus_in( s_window->hscrollbar, "wxWindow::hsrcollbar", name );
1379     debug_focus_in( s_window->vscrollbar, "wxWindow::vsrcollbar", name );
1380 #endif
1381
1382     GtkScrolledWindowClass *scroll_class = GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT(m_widget)->klass );
1383     scroll_class->scrollbar_spacing = 0;
1384
1385     gtk_scrolled_window_set_policy( s_window, GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC );
1386
1387     m_oldHorizontalPos = 0.0;
1388     m_oldVerticalPos = 0.0;
1389
1390     m_hAdjust = gtk_range_get_adjustment( GTK_RANGE(s_window->hscrollbar) );
1391     m_vAdjust = gtk_range_get_adjustment( GTK_RANGE(s_window->vscrollbar) );
1392
1393     m_wxwindow = gtk_myfixed_new();
1394
1395 #ifdef __WXDEBUG__
1396     debug_focus_in( m_wxwindow, "wxWindow::m_wxwindow", name );
1397 #endif
1398
1399 #ifdef NEW_GTK_SCROLL_CODE
1400     gtk_scrolled_window_add_with_viewport( GTK_SCROLLED_WINDOW(m_widget), m_wxwindow );
1401     GtkViewport *viewport = GTK_VIEWPORT(s_window->child);
1402 #else
1403     gtk_container_add( GTK_CONTAINER(m_widget), m_wxwindow );
1404     GtkViewport *viewport = GTK_VIEWPORT(s_window->viewport);
1405 #endif
1406
1407 #ifdef __WXDEBUG__
1408     debug_focus_in( GTK_WIDGET(viewport), "wxWindow::viewport", name );
1409 #endif
1410
1411     if (m_windowStyle & wxRAISED_BORDER)
1412     {
1413         gtk_viewport_set_shadow_type( viewport, GTK_SHADOW_OUT );
1414     }
1415     else if (m_windowStyle & wxSUNKEN_BORDER)
1416     {
1417         gtk_viewport_set_shadow_type( viewport, GTK_SHADOW_IN );
1418     }
1419     else
1420     {
1421         gtk_viewport_set_shadow_type( viewport, GTK_SHADOW_NONE );
1422     }
1423
1424     if ((m_windowStyle & wxTAB_TRAVERSAL) != 0)
1425     {
1426         GTK_WIDGET_SET_FLAGS( m_wxwindow, GTK_CAN_FOCUS );  /* changed from UNSET */
1427         m_acceptsFocus = FALSE;
1428     }
1429     else
1430     {
1431         GTK_WIDGET_SET_FLAGS( m_wxwindow, GTK_CAN_FOCUS );
1432         m_acceptsFocus = TRUE;
1433     }
1434
1435     // shut the viewport up
1436     gtk_viewport_set_hadjustment( viewport, (GtkAdjustment*) gtk_adjustment_new( 0.0, 0.0, 0.0, 0.0, 0.0, 0.0) );
1437     gtk_viewport_set_vadjustment( viewport, (GtkAdjustment*) gtk_adjustment_new( 0.0, 0.0, 0.0, 0.0, 0.0, 0.0) );
1438
1439     // I _really_ don't want scrollbars in the beginning
1440     m_vAdjust->lower = 0.0;
1441     m_vAdjust->upper = 1.0;
1442     m_vAdjust->value = 0.0;
1443     m_vAdjust->step_increment = 1.0;
1444     m_vAdjust->page_increment = 1.0;
1445     m_vAdjust->page_size = 5.0;
1446     gtk_signal_emit_by_name( GTK_OBJECT(m_vAdjust), "changed" );
1447     m_hAdjust->lower = 0.0;
1448     m_hAdjust->upper = 1.0;
1449     m_hAdjust->value = 0.0;
1450     m_hAdjust->step_increment = 1.0;
1451     m_hAdjust->page_increment = 1.0;
1452     m_hAdjust->page_size = 5.0;
1453     gtk_signal_emit_by_name( GTK_OBJECT(m_hAdjust), "changed" );
1454
1455     // these handlers block mouse events to any window during scrolling
1456     // such as motion events and prevent GTK and wxWindows from fighting
1457     // over where the slider should be
1458
1459     gtk_signal_connect( GTK_OBJECT(s_window->vscrollbar), "button_press_event",
1460           (GtkSignalFunc)gtk_scrollbar_button_press_callback, (gpointer) this );
1461
1462     gtk_signal_connect( GTK_OBJECT(s_window->hscrollbar), "button_press_event",
1463           (GtkSignalFunc)gtk_scrollbar_button_press_callback, (gpointer) this );
1464
1465     gtk_signal_connect( GTK_OBJECT(s_window->vscrollbar), "button_release_event",
1466           (GtkSignalFunc)gtk_scrollbar_button_release_callback, (gpointer) this );
1467
1468     gtk_signal_connect( GTK_OBJECT(s_window->hscrollbar), "button_release_event",
1469           (GtkSignalFunc)gtk_scrollbar_button_release_callback, (gpointer) this );
1470
1471     // these handers het notified when screen updates are required either when
1472     // scrolling or when the window size (and therefore scrollbar configuration)
1473     // has changed
1474
1475     gtk_signal_connect( GTK_OBJECT(m_hAdjust), "value_changed",
1476           (GtkSignalFunc) gtk_window_hscroll_callback, (gpointer) this );
1477     gtk_signal_connect( GTK_OBJECT(m_vAdjust), "value_changed",
1478           (GtkSignalFunc) gtk_window_vscroll_callback, (gpointer) this );
1479
1480     gtk_signal_connect( GTK_OBJECT(m_hAdjust), "changed",
1481           (GtkSignalFunc) gtk_window_hscroll_change_callback, (gpointer) this );
1482     gtk_signal_connect(GTK_OBJECT(m_vAdjust), "changed",
1483           (GtkSignalFunc) gtk_window_vscroll_change_callback, (gpointer) this );
1484
1485     gtk_widget_show( m_wxwindow );
1486
1487     if (m_parent) m_parent->AddChild( this );
1488
1489     (m_parent->m_insertCallback)( m_parent, this );
1490
1491     PostCreation();
1492
1493     Show( TRUE );
1494
1495     return TRUE;
1496 }
1497
1498 wxWindow::~wxWindow()
1499 {
1500     m_hasVMT = FALSE;
1501
1502 #if wxUSE_DRAG_AND_DROP
1503     if (m_dropTarget) delete m_dropTarget;
1504 #endif
1505
1506     if (m_toolTip) delete m_toolTip;
1507
1508     if (m_parent) m_parent->RemoveChild( this );
1509     if (m_widget) Show( FALSE );
1510
1511     DestroyChildren();
1512
1513     if (m_widgetStyle) gtk_style_unref( m_widgetStyle );
1514
1515     if (m_scrollGC) gdk_gc_unref( m_scrollGC );
1516
1517     if (m_wxwindow) gtk_widget_destroy( m_wxwindow );
1518
1519     if (m_widget) gtk_widget_destroy( m_widget );
1520
1521     if (m_cursor) delete m_cursor;
1522
1523     DeleteRelatedConstraints();
1524     if (m_constraints)
1525     {
1526         // This removes any dangling pointers to this window
1527         // in other windows' constraintsInvolvedIn lists.
1528         UnsetConstraints(m_constraints);
1529         delete m_constraints;
1530         m_constraints = (wxLayoutConstraints *) NULL;
1531     }
1532     if (m_windowSizer)
1533     {
1534         delete m_windowSizer;
1535         m_windowSizer = (wxSizer *) NULL;
1536     }
1537     // If this is a child of a sizer, remove self from parent
1538     if (m_sizerParent) m_sizerParent->RemoveChild((wxWindow *)this);
1539
1540     // Just in case the window has been Closed, but
1541     // we're then deleting immediately: don't leave
1542     // dangling pointers.
1543     wxPendingDelete.DeleteObject(this);
1544
1545     // Just in case we've loaded a top-level window via
1546     // wxWindow::LoadNativeDialog but we weren't a dialog
1547     // class
1548     wxTopLevelWindows.DeleteObject(this);
1549
1550     if (m_windowValidator) delete m_windowValidator;
1551
1552     if (m_clientObject) delete m_clientObject;
1553 }
1554
1555 void wxWindow::PreCreation( wxWindow *parent, wxWindowID id,
1556       const wxPoint &pos, const wxSize &size,
1557       long style, const wxString &name )
1558 {
1559     wxASSERT_MSG( (!m_needParent) || (parent), "Need complete parent." );
1560
1561     m_widget = (GtkWidget*) NULL;
1562     m_wxwindow = (GtkWidget*) NULL;
1563     m_hasVMT = FALSE;
1564     m_parent = parent;
1565     m_children.DeleteContents( FALSE );
1566
1567     m_width = size.x;
1568     if (m_width == -1) m_width = 20;
1569     m_height = size.y;
1570     if (m_height == -1) m_height = 20;
1571
1572     m_x = (int)pos.x;
1573     m_y = (int)pos.y;
1574
1575     if (!m_needParent)  // some reasonable defaults
1576     {
1577         if (m_x == -1)
1578         {
1579             m_x = (gdk_screen_width () - m_width) / 2;
1580             if (m_x < 10) m_x = 10;
1581         }
1582         if (m_y == -1)
1583         {
1584             m_y = (gdk_screen_height () - m_height) / 2;
1585             if (m_y < 10) m_y = 10;
1586         }
1587     }
1588
1589     m_minWidth = -1;
1590     m_minHeight = -1;
1591     m_maxWidth = -1;
1592     m_maxHeight = -1;
1593
1594     m_retCode = 0;
1595
1596     m_eventHandler = this;
1597
1598     m_windowId = id == -1 ? wxNewId() : id;
1599
1600     m_sizeSet = FALSE;
1601
1602     m_cursor = new wxCursor( wxCURSOR_ARROW );
1603     m_font = *wxSWISS_FONT;
1604     m_backgroundColour = wxSystemSettings::GetSystemColour( wxSYS_COLOUR_BTNFACE );
1605     m_foregroundColour = *wxBLACK;
1606     m_windowStyle = style;
1607     m_windowName = name;
1608
1609     m_constraints = (wxLayoutConstraints *) NULL;
1610     m_constraintsInvolvedIn = (wxList *) NULL;
1611     m_windowSizer = (wxSizer *) NULL;
1612     m_sizerParent = (wxWindow *) NULL;
1613     m_autoLayout = FALSE;
1614
1615     m_hasScrolling = FALSE;
1616     m_isScrolling = FALSE;
1617     m_hAdjust = (GtkAdjustment *) NULL;
1618     m_vAdjust = (GtkAdjustment *) NULL;
1619     m_oldHorizontalPos = 0.0;
1620     m_oldVerticalPos = 0.0;
1621
1622     m_isShown = FALSE;
1623     m_isEnabled = TRUE;
1624
1625 #if wxUSE_DRAG_AND_DROP
1626     m_dropTarget = (wxDropTarget *) NULL;
1627 #endif
1628     m_resizing = FALSE;
1629     m_windowValidator = (wxValidator *) NULL;
1630     m_scrollGC = (GdkGC*) NULL;
1631     m_widgetStyle = (GtkStyle*) NULL;
1632
1633     m_clientObject = (wxClientData*)NULL;
1634     m_clientData = NULL;
1635
1636     m_isStaticBox = FALSE;
1637     m_toolTip = (wxToolTip*) NULL;
1638 }
1639
1640 void wxWindow::PostCreation()
1641 {
1642     if (m_wxwindow)
1643     {
1644       gtk_signal_connect( GTK_OBJECT(m_wxwindow), "expose_event",
1645         GTK_SIGNAL_FUNC(gtk_window_expose_callback), (gpointer)this );
1646
1647       gtk_signal_connect( GTK_OBJECT(m_wxwindow), "draw",
1648         GTK_SIGNAL_FUNC(gtk_window_draw_callback), (gpointer)this );
1649     }
1650
1651     ConnectWidget( GetConnectWidget() );
1652
1653     if (m_widget && m_parent) gtk_widget_realize( m_widget );
1654
1655     if (m_wxwindow) gtk_widget_realize( m_wxwindow );
1656
1657     SetCursor( *wxSTANDARD_CURSOR );
1658
1659     m_hasVMT = TRUE;
1660 }
1661
1662 void wxWindow::ConnectWidget( GtkWidget *widget )
1663 {
1664     gtk_signal_connect( GTK_OBJECT(widget), "key_press_event",
1665       GTK_SIGNAL_FUNC(gtk_window_key_press_callback), (gpointer)this );
1666
1667     gtk_signal_connect( GTK_OBJECT(widget), "key_release_event",
1668       GTK_SIGNAL_FUNC(gtk_window_key_release_callback), (gpointer)this );
1669
1670     gtk_signal_connect( GTK_OBJECT(widget), "button_press_event",
1671       GTK_SIGNAL_FUNC(gtk_window_button_press_callback), (gpointer)this );
1672
1673     gtk_signal_connect( GTK_OBJECT(widget), "button_release_event",
1674       GTK_SIGNAL_FUNC(gtk_window_button_release_callback), (gpointer)this );
1675
1676     gtk_signal_connect( GTK_OBJECT(widget), "motion_notify_event",
1677       GTK_SIGNAL_FUNC(gtk_window_motion_notify_callback), (gpointer)this );
1678
1679     gtk_signal_connect( GTK_OBJECT(widget), "focus_in_event",
1680       GTK_SIGNAL_FUNC(gtk_window_focus_in_callback), (gpointer)this );
1681
1682     gtk_signal_connect( GTK_OBJECT(widget), "focus_out_event",
1683       GTK_SIGNAL_FUNC(gtk_window_focus_out_callback), (gpointer)this );
1684
1685     gtk_signal_connect( GTK_OBJECT(widget), "enter_notify_event",
1686       GTK_SIGNAL_FUNC(gtk_window_enter_callback), (gpointer)this );
1687
1688     gtk_signal_connect( GTK_OBJECT(widget), "leave_notify_event",
1689       GTK_SIGNAL_FUNC(gtk_window_leave_callback), (gpointer)this );
1690 }
1691
1692 bool wxWindow::HasVMT()
1693 {
1694     return m_hasVMT;
1695 }
1696
1697 bool wxWindow::Close( bool force )
1698 {
1699     wxASSERT_MSG( (m_widget != NULL), "invalid window" );
1700
1701     wxCloseEvent event(wxEVT_CLOSE_WINDOW, m_windowId);
1702     event.SetEventObject(this);
1703     event.SetForce(force);
1704
1705     return GetEventHandler()->ProcessEvent(event);
1706 }
1707
1708 bool wxWindow::Destroy()
1709 {
1710     wxASSERT_MSG( (m_widget != NULL), "invalid window" );
1711
1712     m_hasVMT = FALSE;
1713     delete this;
1714     return TRUE;
1715 }
1716
1717 bool wxWindow::DestroyChildren()
1718 {
1719     wxNode *node;
1720     while ((node = m_children.First()) != (wxNode *)NULL)
1721     {
1722         wxWindow *child;
1723         if ((child = (wxWindow *)node->Data()) != (wxWindow *)NULL)
1724         {
1725             delete child;
1726             if (m_children.Member(child)) delete node;
1727         }
1728     }
1729     return TRUE;
1730 }
1731
1732 void wxWindow::PrepareDC( wxDC &WXUNUSED(dc) )
1733 {
1734     // are we to set fonts here ?
1735 }
1736
1737 wxPoint wxWindow::GetClientAreaOrigin() const
1738 {
1739     return wxPoint(0,0);
1740 }
1741
1742 void wxWindow::AdjustForParentClientOrigin( int& x, int& y, int sizeFlags )
1743 {
1744     if (((sizeFlags & wxSIZE_NO_ADJUSTMENTS) == 0) && GetParent())
1745     {
1746         wxPoint pt(GetParent()->GetClientAreaOrigin());
1747         x += pt.x;
1748         y += pt.y;
1749     }
1750 }
1751
1752 void wxWindow::SetSize( int x, int y, int width, int height, int sizeFlags )
1753 {
1754     wxASSERT_MSG( (m_widget != NULL), "invalid window" );
1755     wxASSERT_MSG( (m_parent != NULL), "wxWindow::SetSize requires parent.\n" );
1756
1757     if (m_resizing) return; // I don't like recursions
1758     m_resizing = TRUE;
1759
1760     if (m_parent->m_wxwindow == NULL) // i.e. wxNotebook
1761     {
1762         // don't set the size for children of wxNotebook, just take the values.
1763         m_x = x;
1764         m_y = y;
1765         m_width = width;
1766         m_height = height;
1767     }
1768     else
1769     {
1770         int old_width = m_width;
1771         int old_height = m_height;
1772
1773         if ((sizeFlags & wxSIZE_USE_EXISTING) == wxSIZE_USE_EXISTING)
1774         {
1775             if (x != -1) m_x = x;
1776             if (y != -1) m_y = y;
1777             if (width != -1) m_width = width;
1778             if (height != -1) m_height = height;
1779         }
1780         else
1781         {
1782             m_x = x;
1783             m_y = y;
1784             m_width = width;
1785             m_height = height;
1786         }
1787
1788         if ((sizeFlags & wxSIZE_AUTO_WIDTH) == wxSIZE_AUTO_WIDTH)
1789         {
1790              if (width == -1) m_width = 80;
1791         }
1792
1793         if ((sizeFlags & wxSIZE_AUTO_HEIGHT) == wxSIZE_AUTO_HEIGHT)
1794         {
1795              if (height == -1) m_height = 26;
1796         }
1797
1798         if ((m_minWidth != -1) && (m_width < m_minWidth)) m_width = m_minWidth;
1799         if ((m_minHeight != -1) && (m_height < m_minHeight)) m_height = m_minHeight;
1800         if ((m_maxWidth != -1) && (m_width > m_maxWidth)) m_width = m_maxWidth;
1801         if ((m_maxHeight != -1) && (m_height > m_maxHeight)) m_height = m_maxHeight;
1802
1803         wxPoint pt( m_parent->GetClientAreaOrigin() );
1804         gtk_myfixed_move( GTK_MYFIXED(m_parent->m_wxwindow), m_widget, m_x+pt.x, m_y+pt.y );
1805
1806         if ((old_width != m_width) || (old_height != m_height))
1807              gtk_widget_set_usize( m_widget, m_width, m_height );
1808     }
1809
1810     m_sizeSet = TRUE;
1811
1812     wxSizeEvent event( wxSize(m_width,m_height), GetId() );
1813     event.SetEventObject( this );
1814     GetEventHandler()->ProcessEvent( event );
1815
1816     m_resizing = FALSE;
1817 }
1818
1819 void wxWindow::OnInternalIdle()
1820 {
1821     UpdateWindowUI();
1822 }
1823
1824 void wxWindow::SetSize( int width, int height )
1825 {
1826     SetSize( -1, -1, width, height, wxSIZE_USE_EXISTING );
1827 }
1828
1829 void wxWindow::Move( int x, int y )
1830 {
1831     SetSize( x, y, -1, -1, wxSIZE_USE_EXISTING );
1832 }
1833
1834 void wxWindow::GetSize( int *width, int *height ) const
1835 {
1836     wxCHECK_RET( (m_widget != NULL), "invalid window" );
1837
1838     if (width) (*width) = m_width;
1839     if (height) (*height) = m_height;
1840 }
1841
1842 void wxWindow::SetClientSize( int width, int height )
1843 {
1844     wxCHECK_RET( (m_widget != NULL), "invalid window" );
1845
1846     if (!m_wxwindow)
1847     {
1848         SetSize( width, height );
1849     }
1850     else
1851     {
1852         int dw = 0;
1853         int dh = 0;
1854
1855         if (!m_hasScrolling)
1856         {
1857             GtkStyleClass *window_class = m_wxwindow->style->klass;
1858
1859             if ((m_windowStyle & wxRAISED_BORDER) ||
1860                 (m_windowStyle & wxSUNKEN_BORDER))
1861             {
1862                 dw += 2 * window_class->xthickness;
1863                 dh += 2 * window_class->ythickness;
1864             }
1865         }
1866         else
1867         {
1868             GtkScrolledWindow *scroll_window = GTK_SCROLLED_WINDOW(m_widget);
1869             GtkScrolledWindowClass *scroll_class = GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT(m_widget)->klass );
1870
1871 #ifdef NEW_GTK_SCROLL_CODE
1872             GtkWidget *viewport = scroll_window->child;
1873 #else
1874             GtkWidget *viewport = scroll_window->viewport;
1875 #endif
1876
1877             GtkStyleClass *viewport_class = viewport->style->klass;
1878
1879             GtkWidget *hscrollbar = scroll_window->hscrollbar;
1880             GtkWidget *vscrollbar = scroll_window->vscrollbar;
1881
1882             if ((m_windowStyle & wxRAISED_BORDER) ||
1883                 (m_windowStyle & wxSUNKEN_BORDER))
1884             {
1885                 dw += 2 * viewport_class->xthickness;
1886                 dh += 2 * viewport_class->ythickness;
1887             }
1888
1889             if (scroll_window->vscrollbar_visible)
1890             {
1891                 dw += vscrollbar->allocation.width;
1892                 dw += scroll_class->scrollbar_spacing;
1893             }
1894
1895             if (scroll_window->hscrollbar_visible)
1896             {
1897                 dh += hscrollbar->allocation.height;
1898                 dw += scroll_class->scrollbar_spacing;
1899             }
1900        }
1901
1902       SetSize( width+dw, height+dh );
1903     }
1904 }
1905
1906 void wxWindow::GetClientSize( int *width, int *height ) const
1907 {
1908     wxCHECK_RET( (m_widget != NULL), "invalid window" );
1909
1910     if (!m_wxwindow)
1911     {
1912         if (width) (*width) = m_width;
1913         if (height) (*height) = m_height;
1914     }
1915     else
1916     {
1917         int dw = 0;
1918         int dh = 0;
1919
1920         if (!m_hasScrolling)
1921         {
1922             GtkStyleClass *window_class = m_wxwindow->style->klass;
1923
1924             if ((m_windowStyle & wxRAISED_BORDER) ||
1925                 (m_windowStyle & wxSUNKEN_BORDER))
1926             {
1927                 dw += 2 * window_class->xthickness;
1928                 dh += 2 * window_class->ythickness;
1929             }
1930         }
1931         else
1932         {
1933             GtkScrolledWindow *scroll_window = GTK_SCROLLED_WINDOW(m_widget);
1934             GtkScrolledWindowClass *scroll_class = GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT(m_widget)->klass );
1935
1936 #ifdef NEW_GTK_SCROLL_CODE
1937             GtkWidget *viewport = scroll_window->child;
1938 #else
1939             GtkWidget *viewport = scroll_window->viewport;
1940 #endif
1941
1942             GtkStyleClass *viewport_class = viewport->style->klass;
1943
1944             if ((m_windowStyle & wxRAISED_BORDER) ||
1945                 (m_windowStyle & wxSUNKEN_BORDER))
1946             {
1947                 dw += 2 * viewport_class->xthickness;
1948                 dh += 2 * viewport_class->ythickness;
1949             }
1950
1951             if (scroll_window->vscrollbar_visible)
1952             {
1953 //              dw += vscrollbar->allocation.width;
1954                 dw += 15;                               // range.slider_width = 11 + 2*2pts edge
1955                 dw += scroll_class->scrollbar_spacing;
1956             }
1957
1958             if (scroll_window->hscrollbar_visible)
1959             {
1960 //              dh += hscrollbar->allocation.height;
1961                 dh += 15;
1962                 dh += scroll_class->scrollbar_spacing;
1963             }
1964         }
1965
1966         if (width) (*width) = m_width - dw;
1967         if (height) (*height) = m_height - dh;
1968     }
1969 }
1970
1971 void wxWindow::GetPosition( int *x, int *y ) const
1972 {
1973     wxCHECK_RET( (m_widget != NULL), "invalid window" );
1974
1975     if (x) (*x) = m_x;
1976     if (y) (*y) = m_y;
1977 }
1978
1979 void wxWindow::ClientToScreen( int *x, int *y )
1980 {
1981     wxCHECK_RET( (m_widget != NULL), "invalid window" );
1982
1983     GdkWindow *source = (GdkWindow *) NULL;
1984     if (m_wxwindow)
1985         source = m_wxwindow->window;
1986     else
1987         source = m_widget->window;
1988
1989     int org_x = 0;
1990     int org_y = 0;
1991     gdk_window_get_origin( source, &org_x, &org_y );
1992
1993     if (!m_wxwindow)
1994     {
1995         if (GTK_WIDGET_NO_WINDOW (m_widget))
1996         {
1997             org_x += m_widget->allocation.x;
1998             org_y += m_widget->allocation.y;
1999         }
2000     }
2001
2002     wxPoint pt(GetClientAreaOrigin());
2003     org_x += pt.x;
2004     org_y += pt.y;
2005
2006     if (x) *x += org_x;
2007     if (y) *y += org_y;
2008 }
2009
2010 void wxWindow::ScreenToClient( int *x, int *y )
2011 {
2012     wxCHECK_RET( (m_widget != NULL), "invalid window" );
2013
2014     GdkWindow *source = (GdkWindow *) NULL;
2015     if (m_wxwindow)
2016         source = m_wxwindow->window;
2017     else
2018         source = m_widget->window;
2019
2020     int org_x = 0;
2021     int org_y = 0;
2022     gdk_window_get_origin( source, &org_x, &org_y );
2023
2024     if (!m_wxwindow)
2025     {
2026         if (GTK_WIDGET_NO_WINDOW (m_widget))
2027         {
2028             org_x += m_widget->allocation.x;
2029             org_y += m_widget->allocation.y;
2030         }
2031     }
2032
2033     wxPoint pt(GetClientAreaOrigin());
2034     org_x -= pt.x;
2035     org_y -= pt.y;
2036
2037     if (x) *x -= org_x;
2038     if (y) *y -= org_y;
2039 }
2040
2041 void wxWindow::Centre( int direction )
2042 {
2043     wxCHECK_RET( (m_widget != NULL), "invalid window" );
2044
2045     int x = m_x;
2046     int y = m_y;
2047
2048     if (m_parent)
2049     {
2050         int p_w = 0;
2051         int p_h = 0;
2052         m_parent->GetSize( &p_w, &p_h );
2053         if (direction & wxHORIZONTAL == wxHORIZONTAL) x = (p_w - m_width) / 2;
2054         if (direction & wxVERTICAL == wxVERTICAL) y = (p_h - m_height) / 2;
2055     }
2056     else
2057     {
2058         if (direction & wxHORIZONTAL == wxHORIZONTAL) x = (gdk_screen_width () - m_width) / 2;
2059         if (direction & wxVERTICAL == wxVERTICAL) y = (gdk_screen_height () - m_height) / 2;
2060     }
2061
2062     Move( x, y );
2063 }
2064
2065 void wxWindow::Fit()
2066 {
2067     wxCHECK_RET( (m_widget != NULL), "invalid window" );
2068
2069     int maxX = 0;
2070     int maxY = 0;
2071     wxNode *node = m_children.First();
2072     while (node)
2073     {
2074         wxWindow *win = (wxWindow *)node->Data();
2075         int wx, wy, ww, wh;
2076         win->GetPosition(&wx, &wy);
2077         win->GetSize(&ww, &wh);
2078         if (wx + ww > maxX) maxX = wx + ww;
2079         if (wy + wh > maxY) maxY = wy + wh;
2080
2081         node = node->Next();
2082     }
2083
2084     SetClientSize(maxX + 7, maxY + 14);
2085 }
2086
2087 void wxWindow::SetSizeHints( int minW, int minH, int maxW, int maxH, int WXUNUSED(incW), int WXUNUSED(incH) )
2088 {
2089     wxCHECK_RET( (m_widget != NULL), "invalid window" );
2090
2091     m_minWidth = minW;
2092     m_minHeight = minH;
2093     m_maxWidth = maxW;
2094     m_maxHeight = maxH;
2095 }
2096
2097 void wxWindow::OnSize( wxSizeEvent &WXUNUSED(event) )
2098 {
2099 //  if (GetAutoLayout()) Layout();
2100 }
2101
2102 bool wxWindow::Show( bool show )
2103 {
2104     wxCHECK_MSG( (m_widget != NULL), FALSE, "invalid window" );
2105
2106     if (show)
2107         gtk_widget_show( m_widget );
2108     else
2109         gtk_widget_hide( m_widget );
2110
2111     m_isShown = show;
2112
2113     return TRUE;
2114 }
2115
2116 void wxWindow::Enable( bool enable )
2117 {
2118     wxCHECK_RET( (m_widget != NULL), "invalid window" );
2119
2120     m_isEnabled = enable;
2121
2122     gtk_widget_set_sensitive( m_widget, enable );
2123     if (m_wxwindow) gtk_widget_set_sensitive( m_wxwindow, enable );
2124 }
2125
2126 int wxWindow::GetCharHeight() const
2127 {
2128     wxCHECK_MSG( (m_widget != NULL), 12, "invalid window" );
2129
2130     wxCHECK_MSG( m_font.Ok(), 12, "invalid font" );
2131
2132     GdkFont *font = m_font.GetInternalFont( 1.0 );
2133
2134     return font->ascent + font->descent;
2135 }
2136
2137 int wxWindow::GetCharWidth() const
2138 {
2139     wxCHECK_MSG( (m_widget != NULL), 8, "invalid window" );
2140
2141     wxCHECK_MSG( m_font.Ok(), 8, "invalid font" );
2142
2143     GdkFont *font = m_font.GetInternalFont( 1.0 );
2144
2145     return gdk_string_width( font, "H" );
2146 }
2147
2148 void wxWindow::GetTextExtent( const wxString& string, int *x, int *y,
2149   int *descent, int *externalLeading, const wxFont *theFont, bool WXUNUSED(use16) ) const
2150 {
2151     wxFont fontToUse = m_font;
2152     if (theFont) fontToUse = *theFont;
2153
2154     wxCHECK_RET( fontToUse.Ok(), "invalid font" );
2155
2156     GdkFont *font = fontToUse.GetInternalFont( 1.0 );
2157     if (x) (*x) = gdk_string_width( font, string );
2158     if (y) (*y) = font->ascent + font->descent;
2159     if (descent) (*descent) = font->descent;
2160     if (externalLeading) (*externalLeading) = 0;  // ??
2161 }
2162
2163 void wxWindow::MakeModal( bool modal )
2164 {
2165     return;
2166
2167     // Disable all other windows
2168     if (this->IsKindOf(CLASSINFO(wxDialog)) || this->IsKindOf(CLASSINFO(wxFrame)))
2169     {
2170         wxNode *node = wxTopLevelWindows.First();
2171         while (node)
2172         {
2173             wxWindow *win = (wxWindow *)node->Data();
2174             if (win != this) win->Enable(!modal);
2175
2176             node = node->Next();
2177         }
2178     }
2179 }
2180
2181 void wxWindow::OnKeyDown( wxKeyEvent &event )
2182 {
2183     event.SetEventType( wxEVT_CHAR );
2184
2185     if (!GetEventHandler()->ProcessEvent( event ))
2186     {
2187         event.Skip();
2188     }
2189 }
2190
2191 void wxWindow::SetFocus()
2192 {
2193     wxCHECK_RET( (m_widget != NULL), "invalid window" );
2194
2195     GtkWidget *connect_widget = GetConnectWidget();
2196     if (connect_widget)
2197     {
2198         if (GTK_WIDGET_CAN_FOCUS(connect_widget) /*&& !GTK_WIDGET_HAS_FOCUS (connect_widget)*/ )
2199         {
2200             gtk_widget_grab_focus (connect_widget);
2201         }
2202         else if (GTK_IS_CONTAINER(connect_widget))
2203         {
2204             gtk_container_focus( GTK_CONTAINER(connect_widget), GTK_DIR_TAB_FORWARD );
2205         }
2206         else
2207         {
2208         }
2209     }
2210 }
2211
2212 wxWindow *wxWindow::FindFocus()
2213 {
2214     return g_focusWindow;
2215 }
2216
2217 bool wxWindow::AcceptsFocus() const
2218 {
2219     return IsEnabled() && IsShown() && m_acceptsFocus;
2220 }
2221
2222 bool wxWindow::OnClose()
2223 {
2224     return TRUE;
2225 }
2226
2227 void wxWindow::AddChild( wxWindow *child )
2228 {
2229     wxCHECK_RET( (m_widget != NULL), "invalid window" );
2230     wxCHECK_RET( (child != NULL), "invalid child" );
2231
2232     m_children.Append( child );
2233 }
2234
2235 wxWindow *wxWindow::ReParent( wxWindow *newParent )
2236 {
2237     wxCHECK_MSG( (m_widget != NULL), (wxWindow*) NULL, "invalid window" );
2238
2239     wxWindow *oldParent = GetParent();
2240
2241     if (oldParent) oldParent->RemoveChild( this );
2242
2243     gtk_widget_unparent( m_widget );
2244
2245     if (newParent)
2246     {
2247         newParent->AddChild( this );
2248         (newParent->m_insertCallback)( newParent, this );
2249     }
2250
2251     return oldParent;
2252 }
2253
2254 void wxWindow::RemoveChild( wxWindow *child )
2255 {
2256     m_children.DeleteObject( child );
2257     child->m_parent = (wxWindow *) NULL;
2258 }
2259
2260 void wxWindow::SetReturnCode( int retCode )
2261 {
2262     m_retCode = retCode;
2263 }
2264
2265 int wxWindow::GetReturnCode()
2266 {
2267     return m_retCode;
2268 }
2269
2270 void wxWindow::Raise()
2271 {
2272     wxCHECK_RET( (m_widget != NULL), "invalid window" );
2273
2274     if (m_widget) gdk_window_raise( m_widget->window );
2275 }
2276
2277 void wxWindow::Lower()
2278 {
2279     wxCHECK_RET( (m_widget != NULL), "invalid window" );
2280
2281     if (m_widget) gdk_window_lower( m_widget->window );
2282 }
2283
2284 wxEvtHandler *wxWindow::GetEventHandler() const
2285 {
2286     return m_eventHandler;
2287 }
2288
2289 void wxWindow::SetEventHandler( wxEvtHandler *handler )
2290 {
2291     m_eventHandler = handler;
2292 }
2293
2294 void wxWindow::PushEventHandler(wxEvtHandler *handler)
2295 {
2296     handler->SetNextHandler(GetEventHandler());
2297     SetEventHandler(handler);
2298 }
2299
2300 wxEvtHandler *wxWindow::PopEventHandler(bool deleteHandler)
2301 {
2302     if (GetEventHandler())
2303     {
2304         wxEvtHandler *handlerA = GetEventHandler();
2305         wxEvtHandler *handlerB = handlerA->GetNextHandler();
2306         handlerA->SetNextHandler((wxEvtHandler *) NULL);
2307         SetEventHandler(handlerB);
2308         if (deleteHandler)
2309         {
2310             delete handlerA;
2311             return (wxEvtHandler*) NULL;
2312         }
2313         else
2314             return handlerA;
2315      }
2316      else
2317         return (wxEvtHandler *) NULL;
2318 }
2319
2320 wxValidator *wxWindow::GetValidator()
2321 {
2322     return m_windowValidator;
2323 }
2324
2325 void wxWindow::SetValidator( const wxValidator& validator )
2326 {
2327     if (m_windowValidator) delete m_windowValidator;
2328     m_windowValidator = validator.Clone();
2329     if (m_windowValidator) m_windowValidator->SetWindow(this);
2330 }
2331
2332 void wxWindow::SetClientObject( wxClientData *data )
2333 {
2334     if (m_clientObject) delete m_clientObject;
2335     m_clientObject = data;
2336 }
2337
2338 wxClientData *wxWindow::GetClientObject()
2339 {
2340     return m_clientObject;
2341 }
2342
2343 void wxWindow::SetClientData( void *data )
2344 {
2345     m_clientData = data;
2346 }
2347
2348 void *wxWindow::GetClientData()
2349 {
2350     return m_clientData;
2351 }
2352
2353 bool wxWindow::IsBeingDeleted()
2354 {
2355     return FALSE;
2356 }
2357
2358 void wxWindow::SetId( wxWindowID id )
2359 {
2360     m_windowId = id;
2361 }
2362
2363 wxWindowID wxWindow::GetId() const
2364 {
2365     return m_windowId;
2366 }
2367
2368 void wxWindow::SetCursor( const wxCursor &cursor )
2369 {
2370     wxCHECK_RET( (m_widget != NULL), "invalid window" );
2371
2372     if (cursor.Ok())
2373     {
2374         if (cursor == *m_cursor) return;
2375         *m_cursor = cursor;
2376     }
2377     else
2378     {
2379         *m_cursor = *wxSTANDARD_CURSOR;
2380     }
2381
2382     if ((m_widget) && (m_widget->window))
2383          gdk_window_set_cursor( m_widget->window, m_cursor->GetCursor() );
2384
2385     if ((m_wxwindow) && (m_wxwindow->window))
2386          gdk_window_set_cursor( m_wxwindow->window, m_cursor->GetCursor() );
2387 }
2388
2389 void wxWindow::WarpPointer( int WXUNUSED(x), int WXUNUSED(y) )
2390 {
2391   // TODO
2392 }
2393
2394 void wxWindow::Refresh( bool eraseBackground, const wxRect *rect )
2395 {
2396     wxCHECK_RET( (m_widget != NULL), "invalid window" );
2397
2398     if (eraseBackground && m_wxwindow && m_wxwindow->window)
2399     {
2400         if (rect)
2401         {
2402             gdk_window_clear_area( m_wxwindow->window,
2403                                    rect->x, rect->y,
2404                                    rect->width,
2405                                    rect->height );
2406         }
2407         else
2408         {
2409             Clear();
2410         }
2411     }
2412
2413     if (!rect)
2414     {
2415         if (m_wxwindow)
2416             gtk_widget_draw( m_wxwindow, (GdkRectangle*) NULL );
2417         else
2418             gtk_widget_draw( m_widget, (GdkRectangle*) NULL );
2419     }
2420     else
2421     {
2422         GdkRectangle gdk_rect;
2423         gdk_rect.x = rect->x;
2424         gdk_rect.y = rect->y;
2425         gdk_rect.width = rect->width;
2426         gdk_rect.height = rect->height;
2427
2428         if (m_wxwindow)
2429             gtk_widget_draw( m_wxwindow, &gdk_rect );
2430         else
2431             gtk_widget_draw( m_widget, &gdk_rect );
2432     }
2433 }
2434
2435 wxRegion wxWindow::GetUpdateRegion() const
2436 {
2437   return m_updateRegion;
2438 }
2439
2440 bool wxWindow::IsExposed( int x, int y) const
2441 {
2442     return (m_updateRegion.Contains( x, y ) != wxOutRegion );
2443 }
2444
2445 bool wxWindow::IsExposed( int x, int y, int w, int h ) const
2446 {
2447     return (m_updateRegion.Contains( x, y, w, h ) != wxOutRegion );
2448 }
2449
2450 bool wxWindow::IsExposed( const wxPoint& pt ) const
2451 {
2452     return (m_updateRegion.Contains( pt.x, pt.y ) != wxOutRegion );
2453 }
2454
2455 bool wxWindow::IsExposed( const wxRect& rect ) const
2456 {
2457     return (m_updateRegion.Contains( rect.x, rect.y, rect.width, rect.height ) != wxOutRegion );
2458 }
2459
2460 void wxWindow::Clear()
2461 {
2462     wxCHECK_RET( m_widget != NULL, "invalid window" );
2463
2464     if (m_wxwindow && m_wxwindow->window) gdk_window_clear( m_wxwindow->window );
2465 }
2466
2467 void wxWindow::SetToolTip( const wxString &tip )
2468 {
2469     SetToolTip( new wxToolTip( tip ) );
2470 }
2471
2472 void wxWindow::SetToolTip( wxToolTip *tip )
2473 {
2474     if (m_toolTip) delete m_toolTip;
2475
2476     m_toolTip = tip;
2477
2478     if (m_toolTip) m_toolTip->Create( GetConnectWidget() );
2479 }
2480
2481 wxToolTip& wxWindow::GetToolTip()
2482 {
2483     if (!m_toolTip)
2484         wxLogError( "No tooltip set." );
2485
2486     return *m_toolTip;
2487 }
2488
2489 wxColour wxWindow::GetBackgroundColour() const
2490 {
2491     return m_backgroundColour;
2492 }
2493
2494 void wxWindow::SetBackgroundColour( const wxColour &colour )
2495 {
2496     wxCHECK_RET( m_widget != NULL, "invalid window" );
2497
2498     if (m_backgroundColour == colour) return;
2499
2500     m_backgroundColour = colour;
2501     if (!m_backgroundColour.Ok()) return;
2502
2503     if (m_wxwindow)
2504     {
2505         GdkWindow *window = m_wxwindow->window;
2506         m_backgroundColour.CalcPixel( gdk_window_get_colormap( window ) );
2507         gdk_window_set_background( window, m_backgroundColour.GetColor() );
2508         gdk_window_clear( window );
2509     }
2510
2511     wxColour sysbg = wxSystemSettings::GetSystemColour( wxSYS_COLOUR_BTNFACE );
2512     if (sysbg.Red() == colour.Red() &&
2513         sysbg.Green() == colour.Green() &&
2514         sysbg.Blue() == colour.Blue())
2515     {
2516         m_backgroundColour = wxNullColour;
2517         ApplyWidgetStyle();
2518         m_backgroundColour = sysbg;
2519     }
2520     else
2521     {
2522         ApplyWidgetStyle();
2523     }
2524 }
2525
2526 wxColour wxWindow::GetForegroundColour() const
2527 {
2528     return m_foregroundColour;
2529 }
2530
2531 void wxWindow::SetForegroundColour( const wxColour &colour )
2532 {
2533     wxCHECK_RET( m_widget != NULL, "invalid window" );
2534
2535     if (m_foregroundColour == colour) return;
2536
2537     m_foregroundColour = colour;
2538     if (!m_foregroundColour.Ok()) return;
2539
2540     wxColour sysbg = wxSystemSettings::GetSystemColour( wxSYS_COLOUR_BTNFACE );
2541     if (sysbg.Red() == colour.Red() &&
2542         sysbg.Green() == colour.Green() &&
2543         sysbg.Blue() == colour.Blue())
2544     {
2545         m_backgroundColour = wxNullColour;
2546         ApplyWidgetStyle();
2547         m_backgroundColour = sysbg;
2548     }
2549     else
2550     {
2551         ApplyWidgetStyle();
2552     }
2553 }
2554
2555 GtkStyle *wxWindow::GetWidgetStyle()
2556 {
2557     if (m_widgetStyle) gtk_style_unref( m_widgetStyle );
2558
2559     m_widgetStyle =
2560       gtk_style_copy(
2561         gtk_widget_get_style( m_widget ) );
2562
2563     return m_widgetStyle;
2564 }
2565
2566 void wxWindow::SetWidgetStyle()
2567 {
2568     GtkStyle *style = GetWidgetStyle();
2569
2570     gdk_font_unref( style->font );
2571     style->font = gdk_font_ref( m_font.GetInternalFont( 1.0 ) );
2572
2573     if (m_foregroundColour.Ok())
2574     {
2575         m_foregroundColour.CalcPixel( gdk_window_get_colormap( m_widget->window ) );
2576         style->fg[GTK_STATE_NORMAL] = *m_foregroundColour.GetColor();
2577         style->fg[GTK_STATE_PRELIGHT] = *m_foregroundColour.GetColor();
2578         style->fg[GTK_STATE_ACTIVE] = *m_foregroundColour.GetColor();
2579     }
2580
2581     if (m_backgroundColour.Ok())
2582     {
2583         m_backgroundColour.CalcPixel( gdk_window_get_colormap( m_widget->window ) );
2584         style->bg[GTK_STATE_NORMAL] = *m_backgroundColour.GetColor();
2585         style->base[GTK_STATE_NORMAL] = *m_backgroundColour.GetColor();
2586         style->bg[GTK_STATE_PRELIGHT] = *m_backgroundColour.GetColor();
2587         style->base[GTK_STATE_PRELIGHT] = *m_backgroundColour.GetColor();
2588         style->bg[GTK_STATE_ACTIVE] = *m_backgroundColour.GetColor();
2589         style->base[GTK_STATE_ACTIVE] = *m_backgroundColour.GetColor();
2590         style->bg[GTK_STATE_INSENSITIVE] = *m_backgroundColour.GetColor();
2591         style->base[GTK_STATE_INSENSITIVE] = *m_backgroundColour.GetColor();
2592     }
2593 }
2594
2595 void wxWindow::ApplyWidgetStyle()
2596 {
2597 }
2598
2599 bool wxWindow::Validate()
2600 {
2601     wxCHECK_MSG( m_widget != NULL, FALSE, "invalid window" );
2602
2603     wxNode *node = m_children.First();
2604     while (node)
2605     {
2606         wxWindow *child = (wxWindow *)node->Data();
2607         if (child->GetValidator() && /* child->GetValidator()->Ok() && */ !child->GetValidator()->Validate(this))
2608         {
2609             return FALSE;
2610         }
2611         node = node->Next();
2612     }
2613     return TRUE;
2614 }
2615
2616 bool wxWindow::TransferDataToWindow()
2617 {
2618     wxCHECK_MSG( m_widget != NULL, FALSE, "invalid window" );
2619
2620     wxNode *node = m_children.First();
2621     while (node)
2622     {
2623         wxWindow *child = (wxWindow *)node->Data();
2624         if (child->GetValidator() && /* child->GetValidator()->Ok() && */
2625             !child->GetValidator()->TransferToWindow() )
2626         {
2627             wxMessageBox( _("Application Error"), _("Could not transfer data to window"), wxOK|wxICON_EXCLAMATION );
2628             return FALSE;
2629         }
2630         node = node->Next();
2631     }
2632     return TRUE;
2633 }
2634
2635 bool wxWindow::TransferDataFromWindow()
2636 {
2637     wxCHECK_MSG( m_widget != NULL, FALSE, "invalid window" );
2638
2639     wxNode *node = m_children.First();
2640     while (node)
2641     {
2642         wxWindow *child = (wxWindow *)node->Data();
2643         if ( child->GetValidator() && /* child->GetValidator()->Ok() && */ !child->GetValidator()->TransferFromWindow() )
2644         {
2645             return FALSE;
2646         }
2647         node = node->Next();
2648     }
2649     return TRUE;
2650 }
2651
2652 void wxWindow::SetAcceleratorTable( const wxAcceleratorTable& accel )
2653 {
2654     m_acceleratorTable = accel;
2655 }
2656
2657 void wxWindow::OnInitDialog( wxInitDialogEvent &WXUNUSED(event) )
2658 {
2659     TransferDataToWindow();
2660 }
2661
2662 void wxWindow::InitDialog()
2663 {
2664     wxCHECK_RET( m_widget != NULL, "invalid window" );
2665
2666     wxInitDialogEvent event(GetId());
2667     event.SetEventObject( this );
2668     GetEventHandler()->ProcessEvent(event);
2669 }
2670
2671 static void SetInvokingWindow( wxMenu *menu, wxWindow *win )
2672 {
2673     menu->SetInvokingWindow( win );
2674     wxNode *node = menu->m_items.First();
2675     while (node)
2676     {
2677         wxMenuItem *menuitem = (wxMenuItem*)node->Data();
2678         if (menuitem->IsSubMenu())
2679         {
2680             SetInvokingWindow( menuitem->GetSubMenu(), win );
2681         }
2682         node = node->Next();
2683     }
2684 }
2685
2686 static gint gs_pop_x = 0;
2687 static gint gs_pop_y = 0;
2688
2689 static void pop_pos_callback( GtkMenu *menu, gint *x, gint *y, wxWindow *win )
2690 {
2691     win->ClientToScreen( &gs_pop_x, &gs_pop_y );
2692     *x = gs_pop_x;
2693     *y = gs_pop_y;
2694 }
2695
2696 bool wxWindow::PopupMenu( wxMenu *menu, int x, int y )
2697 {
2698     wxCHECK_MSG( m_widget != NULL, FALSE, "invalid window" );
2699
2700     wxCHECK_MSG( menu != NULL, FALSE, "invalid popup-menu" );
2701
2702     SetInvokingWindow( menu, this );
2703
2704     gs_pop_x = x;
2705     gs_pop_y = y;
2706
2707     gtk_menu_popup(
2708                   GTK_MENU(menu->m_menu),
2709                   (GtkWidget *) NULL,          // parent menu shell
2710                   (GtkWidget *) NULL,          // parent menu item
2711                   (GtkMenuPositionFunc) pop_pos_callback,
2712                   (gpointer) this,             // client data
2713                   0,                           // button used to activate it
2714                   0 //gs_timeLastClick         // the time of activation
2715                 );
2716     return TRUE;
2717 }
2718
2719 #if wxUSE_DRAG_AND_DROP
2720
2721 void wxWindow::SetDropTarget( wxDropTarget *dropTarget )
2722 {
2723     wxCHECK_RET( m_widget != NULL, "invalid window" );
2724
2725     GtkWidget *dnd_widget = GetConnectWidget();
2726
2727     if (m_dropTarget) m_dropTarget->UnregisterWidget( dnd_widget );
2728
2729     if (m_dropTarget) delete m_dropTarget;
2730     m_dropTarget = dropTarget;
2731
2732     if (m_dropTarget) m_dropTarget->RegisterWidget( dnd_widget );
2733 }
2734
2735 wxDropTarget *wxWindow::GetDropTarget() const
2736 {
2737     return m_dropTarget;
2738 }
2739
2740 #endif
2741
2742 GtkWidget* wxWindow::GetConnectWidget()
2743 {
2744     GtkWidget *connect_widget = m_widget;
2745     if (m_wxwindow) connect_widget = m_wxwindow;
2746
2747     return connect_widget;
2748 }
2749
2750 bool wxWindow::IsOwnGtkWindow( GdkWindow *window )
2751 {
2752     if (m_wxwindow) return (window == m_wxwindow->window);
2753     return (window == m_widget->window);
2754 }
2755
2756 void wxWindow::SetFont( const wxFont &font )
2757 {
2758     wxCHECK_RET( m_widget != NULL, "invalid window" );
2759
2760     if (((wxFont*)&font)->Ok())
2761         m_font = font;
2762     else
2763         m_font = *wxSWISS_FONT;
2764
2765     wxColour sysbg = wxSystemSettings::GetSystemColour( wxSYS_COLOUR_BTNFACE );
2766     if (sysbg.Red() == m_backgroundColour.Red() &&
2767         sysbg.Green() == m_backgroundColour.Green() &&
2768         sysbg.Blue() == m_backgroundColour.Blue())
2769     {
2770         m_backgroundColour = wxNullColour;
2771         ApplyWidgetStyle();
2772         m_backgroundColour = sysbg;
2773     }
2774     else
2775     {
2776         ApplyWidgetStyle();
2777     }
2778 }
2779
2780 void wxWindow::SetWindowStyleFlag( long flag )
2781 {
2782     m_windowStyle = flag;
2783 }
2784
2785 long wxWindow::GetWindowStyleFlag() const
2786 {
2787     return m_windowStyle;
2788 }
2789
2790 void wxWindow::CaptureMouse()
2791 {
2792     wxCHECK_RET( m_widget != NULL, "invalid window" );
2793
2794     wxCHECK_RET( g_capturing == FALSE, "CaptureMouse called twice" );
2795
2796     GtkWidget *connect_widget = GetConnectWidget();
2797     gtk_grab_add( connect_widget );
2798     gdk_pointer_grab( connect_widget->window, FALSE,
2799                       (GdkEventMask)
2800                          (GDK_BUTTON_PRESS_MASK |
2801                           GDK_BUTTON_RELEASE_MASK |
2802                           GDK_POINTER_MOTION_MASK),
2803                       (GdkWindow *) NULL,
2804                       (GdkCursor *) NULL,
2805                       GDK_CURRENT_TIME );
2806     g_capturing = TRUE;
2807 }
2808
2809 void wxWindow::ReleaseMouse()
2810 {
2811     wxCHECK_RET( m_widget != NULL, "invalid window" );
2812
2813     wxCHECK_RET( g_capturing == TRUE, "ReleaseMouse called twice" );
2814
2815     GtkWidget *connect_widget = GetConnectWidget();
2816     gtk_grab_remove( connect_widget );
2817     gdk_pointer_ungrab ( GDK_CURRENT_TIME );
2818     g_capturing = FALSE;
2819 }
2820
2821 void wxWindow::SetTitle( const wxString &WXUNUSED(title) )
2822 {
2823 }
2824
2825 wxString wxWindow::GetTitle() const
2826 {
2827     return (wxString&)m_windowName;
2828 }
2829
2830 wxString wxWindow::GetLabel() const
2831 {
2832     return GetTitle();
2833 }
2834
2835 void wxWindow::SetName( const wxString &name )
2836 {
2837     m_windowName = name;
2838 }
2839
2840 wxString wxWindow::GetName() const
2841 {
2842     return (wxString&)m_windowName;
2843 }
2844
2845 bool wxWindow::IsShown() const
2846 {
2847     return m_isShown;
2848 }
2849
2850 bool wxWindow::IsRetained()
2851 {
2852     return FALSE;
2853 }
2854
2855 wxWindow *wxWindow::FindWindow( long id )
2856 {
2857     if (id == m_windowId) return this;
2858     wxNode *node = m_children.First();
2859     while (node)
2860     {
2861         wxWindow *child = (wxWindow*)node->Data();
2862         wxWindow *res = child->FindWindow( id );
2863         if (res) return res;
2864         node = node->Next();
2865     }
2866     return (wxWindow *) NULL;
2867 }
2868
2869 wxWindow *wxWindow::FindWindow( const wxString& name )
2870 {
2871     if (name == m_windowName) return this;
2872     wxNode *node = m_children.First();
2873     while (node)
2874     {
2875         wxWindow *child = (wxWindow*)node->Data();
2876         wxWindow *res = child->FindWindow( name );
2877         if (res) return res;
2878         node = node->Next();
2879     }
2880     return (wxWindow *) NULL;
2881 }
2882
2883 void wxWindow::SetScrollbar( int orient, int pos, int thumbVisible,
2884       int range, bool refresh )
2885 {
2886     wxCHECK_RET( m_widget != NULL, "invalid window" );
2887
2888     wxCHECK_RET( m_wxwindow != NULL, "window needs client area for scrolling" );
2889
2890     m_hasScrolling = TRUE;
2891
2892     if (orient == wxHORIZONTAL)
2893     {
2894         float fpos = (float)pos;
2895         float frange = (float)range;
2896         float fthumb = (float)thumbVisible;
2897         if (fpos > frange-fthumb) fpos = frange-fthumb;
2898         if (fpos < 0.0) fpos = 0.0;
2899
2900         if ((fabs(frange-m_hAdjust->upper) < 0.2) &&
2901             (fabs(fthumb-m_hAdjust->page_size) < 0.2))
2902         {
2903             SetScrollPos( orient, pos, refresh );
2904             return;
2905         }
2906
2907         m_oldHorizontalPos = fpos;
2908
2909         m_hAdjust->lower = 0.0;
2910         m_hAdjust->upper = frange;
2911         m_hAdjust->value = fpos;
2912         m_hAdjust->step_increment = 1.0;
2913         m_hAdjust->page_increment = (float)(wxMax(fthumb,0));
2914         m_hAdjust->page_size = fthumb;
2915     }
2916     else
2917     {
2918         float fpos = (float)pos;
2919         float frange = (float)range;
2920         float fthumb = (float)thumbVisible;
2921         if (fpos > frange-fthumb) fpos = frange-fthumb;
2922         if (fpos < 0.0) fpos = 0.0;
2923
2924         if ((fabs(frange-m_vAdjust->upper) < 0.2) &&
2925             (fabs(fthumb-m_vAdjust->page_size) < 0.2))
2926         {
2927             SetScrollPos( orient, pos, refresh );
2928             return;
2929         }
2930
2931         m_oldVerticalPos = fpos;
2932
2933         m_vAdjust->lower = 0.0;
2934         m_vAdjust->upper = frange;
2935         m_vAdjust->value = fpos;
2936         m_vAdjust->step_increment = 1.0;
2937         m_vAdjust->page_increment = (float)(wxMax(fthumb,0));
2938         m_vAdjust->page_size = fthumb;
2939     }
2940
2941     if (m_wxwindow->window)
2942     {
2943         if (orient == wxHORIZONTAL)
2944             gtk_signal_emit_by_name( GTK_OBJECT(m_hAdjust), "changed" );
2945         else
2946             gtk_signal_emit_by_name( GTK_OBJECT(m_vAdjust), "changed" );
2947
2948         gtk_widget_set_usize( m_widget, m_width, m_height );
2949     }
2950 }
2951
2952 void wxWindow::SetScrollPos( int orient, int pos, bool WXUNUSED(refresh) )
2953 {
2954     wxCHECK_RET( m_widget != NULL, "invalid window" );
2955
2956     wxCHECK_RET( m_wxwindow != NULL, "window needs client area for scrolling" );
2957
2958     if (orient == wxHORIZONTAL)
2959     {
2960         float fpos = (float)pos;
2961         if (fpos > m_hAdjust->upper - m_hAdjust->page_size) fpos = m_hAdjust->upper - m_hAdjust->page_size;
2962         if (fpos < 0.0) fpos = 0.0;
2963         m_oldHorizontalPos = fpos;
2964
2965         if (fabs(fpos-m_hAdjust->value) < 0.2) return;
2966         m_hAdjust->value = fpos;
2967     }
2968     else
2969     {
2970         float fpos = (float)pos;
2971         if (fpos > m_vAdjust->upper - m_vAdjust->page_size) fpos = m_vAdjust->upper - m_vAdjust->page_size;
2972         if (fpos < 0.0) fpos = 0.0;
2973         m_oldVerticalPos = fpos;
2974
2975         if (fabs(fpos-m_vAdjust->value) < 0.2) return;
2976         m_vAdjust->value = fpos;
2977     }
2978
2979     if (!m_isScrolling)
2980     {
2981         if (m_wxwindow->window)
2982         {
2983             if (orient == wxHORIZONTAL)
2984                 gtk_signal_emit_by_name( GTK_OBJECT(m_hAdjust), "value_changed" );
2985             else
2986                 gtk_signal_emit_by_name( GTK_OBJECT(m_vAdjust), "value_changed" );
2987         }
2988     }
2989 }
2990
2991 int wxWindow::GetScrollThumb( int orient ) const
2992 {
2993     wxCHECK_MSG( m_widget != NULL, 0, "invalid window" );
2994
2995     wxCHECK_MSG( m_wxwindow != NULL, 0, "window needs client area for scrolling" );
2996
2997     if (orient == wxHORIZONTAL)
2998         return (int)(m_hAdjust->page_size+0.5);
2999     else
3000         return (int)(m_vAdjust->page_size+0.5);
3001 }
3002
3003 int wxWindow::GetScrollPos( int orient ) const
3004 {
3005     wxCHECK_MSG( m_widget != NULL, 0, "invalid window" );
3006
3007     wxCHECK_MSG( m_wxwindow != NULL, 0, "window needs client area for scrolling" );
3008
3009     if (orient == wxHORIZONTAL)
3010         return (int)(m_hAdjust->value+0.5);
3011     else
3012         return (int)(m_vAdjust->value+0.5);
3013 }
3014
3015 int wxWindow::GetScrollRange( int orient ) const
3016 {
3017     wxCHECK_MSG( m_widget != NULL, 0, "invalid window" );
3018
3019     wxCHECK_MSG( m_wxwindow != NULL, 0, "window needs client area for scrolling" );
3020
3021     if (orient == wxHORIZONTAL)
3022         return (int)(m_hAdjust->upper+0.5);
3023     else
3024         return (int)(m_vAdjust->upper+0.5);
3025 }
3026
3027 void wxWindow::ScrollWindow( int dx, int dy, const wxRect* WXUNUSED(rect) )
3028 {
3029     wxCHECK_RET( m_widget != NULL, "invalid window" );
3030
3031     wxCHECK_RET( m_wxwindow != NULL, "window needs client area for scrolling" );
3032
3033     int cw = 0;
3034     int ch = 0;
3035     GetClientSize( &cw, &ch );
3036
3037     int w = cw - abs(dx);
3038     int h = ch - abs(dy);
3039     if ((h < 0) || (w < 0))
3040     {
3041         Refresh();
3042         return;
3043     }
3044     int s_x = 0;
3045     int s_y = 0;
3046     if (dx < 0) s_x = -dx;
3047     if (dy < 0) s_y = -dy;
3048     int d_x = 0;
3049     int d_y = 0;
3050     if (dx > 0) d_x = dx;
3051     if (dy > 0) d_y = dy;
3052
3053     if (!m_scrollGC)
3054     {
3055         m_scrollGC = gdk_gc_new( m_wxwindow->window );
3056         gdk_gc_set_exposures( m_scrollGC, TRUE );
3057     }
3058
3059     gdk_window_copy_area( m_wxwindow->window, m_scrollGC, d_x, d_y,
3060         m_wxwindow->window, s_x, s_y, w, h );
3061
3062     wxRect rect;
3063     if (dx < 0) rect.x = cw+dx; else rect.x = 0;
3064     if (dy < 0) rect.y = ch+dy; else rect.y = 0;
3065     if (dy != 0) rect.width = cw; else rect.width = abs(dx);
3066     if (dx != 0) rect.height = ch; else rect.height = abs(dy);
3067
3068     Refresh( TRUE, &rect );
3069 }
3070
3071 //-------------------------------------------------------------------------------------
3072 //          Layout
3073 //-------------------------------------------------------------------------------------
3074
3075 wxLayoutConstraints *wxWindow::GetConstraints() const
3076 {
3077   return m_constraints;
3078 }
3079
3080 void wxWindow::SetConstraints( wxLayoutConstraints *constraints )
3081 {
3082   if (m_constraints)
3083   {
3084     UnsetConstraints(m_constraints);
3085     delete m_constraints;
3086   }
3087   m_constraints = constraints;
3088   if (m_constraints)
3089   {
3090     // Make sure other windows know they're part of a 'meaningful relationship'
3091     if (m_constraints->left.GetOtherWindow() && (m_constraints->left.GetOtherWindow() != this))
3092       m_constraints->left.GetOtherWindow()->AddConstraintReference((wxWindow *)this);
3093     if (m_constraints->top.GetOtherWindow() && (m_constraints->top.GetOtherWindow() != this))
3094       m_constraints->top.GetOtherWindow()->AddConstraintReference((wxWindow *)this);
3095     if (m_constraints->right.GetOtherWindow() && (m_constraints->right.GetOtherWindow() != this))
3096       m_constraints->right.GetOtherWindow()->AddConstraintReference((wxWindow *)this);
3097     if (m_constraints->bottom.GetOtherWindow() && (m_constraints->bottom.GetOtherWindow() != this))
3098       m_constraints->bottom.GetOtherWindow()->AddConstraintReference((wxWindow *)this);
3099     if (m_constraints->width.GetOtherWindow() && (m_constraints->width.GetOtherWindow() != this))
3100       m_constraints->width.GetOtherWindow()->AddConstraintReference((wxWindow *)this);
3101     if (m_constraints->height.GetOtherWindow() && (m_constraints->height.GetOtherWindow() != this))
3102       m_constraints->height.GetOtherWindow()->AddConstraintReference((wxWindow *)this);
3103     if (m_constraints->centreX.GetOtherWindow() && (m_constraints->centreX.GetOtherWindow() != this))
3104       m_constraints->centreX.GetOtherWindow()->AddConstraintReference((wxWindow *)this);
3105     if (m_constraints->centreY.GetOtherWindow() && (m_constraints->centreY.GetOtherWindow() != this))
3106       m_constraints->centreY.GetOtherWindow()->AddConstraintReference((wxWindow *)this);
3107   }
3108 ;
3109 }
3110 ;
3111
3112 void wxWindow::SetAutoLayout( bool autoLayout )
3113 {
3114   m_autoLayout = autoLayout;
3115 }
3116
3117 bool wxWindow::GetAutoLayout() const
3118 {
3119   return m_autoLayout;
3120 }
3121
3122 wxSizer *wxWindow::GetSizer() const
3123 {
3124   return m_windowSizer;
3125 }
3126
3127 void wxWindow::SetSizerParent( wxWindow *win )
3128 {
3129   m_sizerParent = win;
3130 }
3131
3132 wxWindow *wxWindow::GetSizerParent() const
3133 {
3134   return m_sizerParent;
3135 }
3136
3137 // This removes any dangling pointers to this window
3138 // in other windows' constraintsInvolvedIn lists.
3139 void wxWindow::UnsetConstraints(wxLayoutConstraints *c)
3140 {
3141   if (c)
3142   {
3143     if (c->left.GetOtherWindow() && (c->top.GetOtherWindow() != this))
3144       c->left.GetOtherWindow()->RemoveConstraintReference((wxWindow *)this);
3145     if (c->top.GetOtherWindow() && (c->top.GetOtherWindow() != this))
3146       c->top.GetOtherWindow()->RemoveConstraintReference((wxWindow *)this);
3147     if (c->right.GetOtherWindow() && (c->right.GetOtherWindow() != this))
3148       c->right.GetOtherWindow()->RemoveConstraintReference((wxWindow *)this);
3149     if (c->bottom.GetOtherWindow() && (c->bottom.GetOtherWindow() != this))
3150       c->bottom.GetOtherWindow()->RemoveConstraintReference((wxWindow *)this);
3151     if (c->width.GetOtherWindow() && (c->width.GetOtherWindow() != this))
3152       c->width.GetOtherWindow()->RemoveConstraintReference((wxWindow *)this);
3153     if (c->height.GetOtherWindow() && (c->height.GetOtherWindow() != this))
3154       c->height.GetOtherWindow()->RemoveConstraintReference((wxWindow *)this);
3155     if (c->centreX.GetOtherWindow() && (c->centreX.GetOtherWindow() != this))
3156       c->centreX.GetOtherWindow()->RemoveConstraintReference((wxWindow *)this);
3157     if (c->centreY.GetOtherWindow() && (c->centreY.GetOtherWindow() != this))
3158       c->centreY.GetOtherWindow()->RemoveConstraintReference((wxWindow *)this);
3159   }
3160 }
3161
3162 // Back-pointer to other windows we're involved with, so if we delete
3163 // this window, we must delete any constraints we're involved with.
3164 void wxWindow::AddConstraintReference(wxWindow *otherWin)
3165 {
3166   if (!m_constraintsInvolvedIn)
3167     m_constraintsInvolvedIn = new wxList;
3168   if (!m_constraintsInvolvedIn->Member(otherWin))
3169     m_constraintsInvolvedIn->Append(otherWin);
3170 }
3171
3172 // REMOVE back-pointer to other windows we're involved with.
3173 void wxWindow::RemoveConstraintReference(wxWindow *otherWin)
3174 {
3175   if (m_constraintsInvolvedIn)
3176     m_constraintsInvolvedIn->DeleteObject(otherWin);
3177 }
3178
3179 // Reset any constraints that mention this window
3180 void wxWindow::DeleteRelatedConstraints()
3181 {
3182   if (m_constraintsInvolvedIn)
3183   {
3184     wxNode *node = m_constraintsInvolvedIn->First();
3185     while (node)
3186     {
3187       wxWindow *win = (wxWindow *)node->Data();
3188       wxNode *next = node->Next();
3189       wxLayoutConstraints *constr = win->GetConstraints();
3190
3191       // Reset any constraints involving this window
3192       if (constr)
3193       {
3194         constr->left.ResetIfWin((wxWindow *)this);
3195         constr->top.ResetIfWin((wxWindow *)this);
3196         constr->right.ResetIfWin((wxWindow *)this);
3197         constr->bottom.ResetIfWin((wxWindow *)this);
3198         constr->width.ResetIfWin((wxWindow *)this);
3199         constr->height.ResetIfWin((wxWindow *)this);
3200         constr->centreX.ResetIfWin((wxWindow *)this);
3201         constr->centreY.ResetIfWin((wxWindow *)this);
3202       }
3203       delete node;
3204       node = next;
3205     }
3206     delete m_constraintsInvolvedIn;
3207     m_constraintsInvolvedIn = (wxList *) NULL;
3208   }
3209 }
3210
3211 void wxWindow::SetSizer(wxSizer *sizer)
3212 {
3213   m_windowSizer = sizer;
3214   if (sizer)
3215     sizer->SetSizerParent((wxWindow *)this);
3216 }
3217
3218 /*
3219  * New version
3220  */
3221
3222 bool wxWindow::Layout()
3223 {
3224   if (GetConstraints())
3225   {
3226     int w, h;
3227     GetClientSize(&w, &h);
3228     GetConstraints()->width.SetValue(w);
3229     GetConstraints()->height.SetValue(h);
3230   }
3231
3232   // If top level (one sizer), evaluate the sizer's constraints.
3233   if (GetSizer())
3234   {
3235     int noChanges;
3236     GetSizer()->ResetConstraints();   // Mark all constraints as unevaluated
3237     GetSizer()->LayoutPhase1(&noChanges);
3238     GetSizer()->LayoutPhase2(&noChanges);
3239     GetSizer()->SetConstraintSizes(); // Recursively set the real window sizes
3240     return TRUE;
3241   }
3242   else
3243   {
3244     // Otherwise, evaluate child constraints
3245     ResetConstraints();   // Mark all constraints as unevaluated
3246     DoPhase(1);           // Just one phase need if no sizers involved
3247     DoPhase(2);
3248     SetConstraintSizes(); // Recursively set the real window sizes
3249   }
3250   return TRUE;
3251 }
3252
3253
3254 // Do a phase of evaluating constraints:
3255 // the default behaviour. wxSizers may do a similar
3256 // thing, but also impose their own 'constraints'
3257 // and order the evaluation differently.
3258 bool wxWindow::LayoutPhase1(int *noChanges)
3259 {
3260   wxLayoutConstraints *constr = GetConstraints();
3261   if (constr)
3262   {
3263     return constr->SatisfyConstraints((wxWindow *)this, noChanges);
3264   }
3265   else
3266     return TRUE;
3267 }
3268
3269 bool wxWindow::LayoutPhase2(int *noChanges)
3270 {
3271   *noChanges = 0;
3272
3273   // Layout children
3274   DoPhase(1);
3275   DoPhase(2);
3276   return TRUE;
3277 }
3278
3279 // Do a phase of evaluating child constraints
3280 bool wxWindow::DoPhase(int phase)
3281 {
3282   int noIterations = 0;
3283   int maxIterations = 500;
3284   int noChanges = 1;
3285   int noFailures = 0;
3286   wxList succeeded;
3287   while ((noChanges > 0) && (noIterations < maxIterations))
3288   {
3289     noChanges = 0;
3290     noFailures = 0;
3291     wxNode *node = m_children.First();
3292     while (node)
3293     {
3294       wxWindow *child = (wxWindow *)node->Data();
3295       if (!child->IsKindOf(CLASSINFO(wxFrame)) && !child->IsKindOf(CLASSINFO(wxDialog)))
3296       {
3297         wxLayoutConstraints *constr = child->GetConstraints();
3298         if (constr)
3299         {
3300           if (succeeded.Member(child))
3301           {
3302           }
3303           else
3304           {
3305             int tempNoChanges = 0;
3306             bool success = ( (phase == 1) ? child->LayoutPhase1(&tempNoChanges) : child->LayoutPhase2(&tempNoChanges) ) ;
3307             noChanges += tempNoChanges;
3308             if (success)
3309             {
3310               succeeded.Append(child);
3311             }
3312           }
3313         }
3314       }
3315       node = node->Next();
3316     }
3317     noIterations ++;
3318   }
3319   return TRUE;
3320 }
3321
3322 void wxWindow::ResetConstraints()
3323 {
3324   wxLayoutConstraints *constr = GetConstraints();
3325   if (constr)
3326   {
3327     constr->left.SetDone(FALSE);
3328     constr->top.SetDone(FALSE);
3329     constr->right.SetDone(FALSE);
3330     constr->bottom.SetDone(FALSE);
3331     constr->width.SetDone(FALSE);
3332     constr->height.SetDone(FALSE);
3333     constr->centreX.SetDone(FALSE);
3334     constr->centreY.SetDone(FALSE);
3335   }
3336   wxNode *node = m_children.First();
3337   while (node)
3338   {
3339     wxWindow *win = (wxWindow *)node->Data();
3340     if (!win->IsKindOf(CLASSINFO(wxFrame)) && !win->IsKindOf(CLASSINFO(wxDialog)))
3341       win->ResetConstraints();
3342     node = node->Next();
3343   }
3344 }
3345
3346 // Need to distinguish between setting the 'fake' size for
3347 // windows and sizers, and setting the real values.
3348 void wxWindow::SetConstraintSizes(bool recurse)
3349 {
3350   wxLayoutConstraints *constr = GetConstraints();
3351   if (constr && constr->left.GetDone() && constr->right.GetDone() &&
3352                 constr->width.GetDone() && constr->height.GetDone())
3353   {
3354     int x = constr->left.GetValue();
3355     int y = constr->top.GetValue();
3356     int w = constr->width.GetValue();
3357     int h = constr->height.GetValue();
3358
3359     // If we don't want to resize this window, just move it...
3360     if ((constr->width.GetRelationship() != wxAsIs) ||
3361         (constr->height.GetRelationship() != wxAsIs))
3362     {
3363       // Calls Layout() recursively. AAAGH. How can we stop that.
3364       // Simply take Layout() out of non-top level OnSizes.
3365       SizerSetSize(x, y, w, h);
3366     }
3367     else
3368     {
3369       SizerMove(x, y);
3370     }
3371   }
3372   else if (constr)
3373   {
3374     char *windowClass = this->GetClassInfo()->GetClassName();
3375
3376     wxString winName;
3377   if (GetName() == "")
3378     winName = "unnamed";
3379   else
3380     winName = GetName();
3381     wxLogDebug( "Constraint(s) not satisfied for window of type %s, name %s:\n",
3382                 (const char *)windowClass,
3383                 (const char *)winName);
3384     if (!constr->left.GetDone()) wxLogDebug( "  unsatisfied 'left' constraint.\n" );
3385     if (!constr->right.GetDone()) wxLogDebug( "  unsatisfied 'right' constraint.\n" );
3386     if (!constr->width.GetDone()) wxLogDebug( "  unsatisfied 'width' constraint.\n" );
3387     if (!constr->height.GetDone())  wxLogDebug( "  unsatisfied 'height' constraint.\n" );
3388     wxLogDebug( "Please check constraints: try adding AsIs() constraints.\n" );
3389   }
3390
3391   if (recurse)
3392   {
3393     wxNode *node = m_children.First();
3394     while (node)
3395     {
3396       wxWindow *win = (wxWindow *)node->Data();
3397       if (!win->IsKindOf(CLASSINFO(wxFrame)) && !win->IsKindOf(CLASSINFO(wxDialog)))
3398         win->SetConstraintSizes();
3399       node = node->Next();
3400     }
3401   }
3402 }
3403
3404 // This assumes that all sizers are 'on' the same
3405 // window, i.e. the parent of this window.
3406 void wxWindow::TransformSizerToActual(int *x, int *y) const
3407 {
3408   if (!m_sizerParent || m_sizerParent->IsKindOf(CLASSINFO(wxDialog)) ||
3409          m_sizerParent->IsKindOf(CLASSINFO(wxFrame)) )
3410     return;
3411
3412   int xp, yp;
3413   m_sizerParent->GetPosition(&xp, &yp);
3414   m_sizerParent->TransformSizerToActual(&xp, &yp);
3415   *x += xp;
3416   *y += yp;
3417 }
3418
3419 void wxWindow::SizerSetSize(int x, int y, int w, int h)
3420 {
3421   int xx = x;
3422   int yy = y;
3423   TransformSizerToActual(&xx, &yy);
3424   SetSize(xx, yy, w, h);
3425 }
3426
3427 void wxWindow::SizerMove(int x, int y)
3428 {
3429   int xx = x;
3430   int yy = y;
3431   TransformSizerToActual(&xx, &yy);
3432   Move(xx, yy);
3433 }
3434
3435 // Only set the size/position of the constraint (if any)
3436 void wxWindow::SetSizeConstraint(int x, int y, int w, int h)
3437 {
3438   wxLayoutConstraints *constr = GetConstraints();
3439   if (constr)
3440   {
3441     if (x != -1)
3442     {
3443       constr->left.SetValue(x);
3444       constr->left.SetDone(TRUE);
3445     }
3446     if (y != -1)
3447     {
3448       constr->top.SetValue(y);
3449       constr->top.SetDone(TRUE);
3450     }
3451     if (w != -1)
3452     {
3453       constr->width.SetValue(w);
3454       constr->width.SetDone(TRUE);
3455     }
3456     if (h != -1)
3457     {
3458       constr->height.SetValue(h);
3459       constr->height.SetDone(TRUE);
3460     }
3461   }
3462 }
3463
3464 void wxWindow::MoveConstraint(int x, int y)
3465 {
3466   wxLayoutConstraints *constr = GetConstraints();
3467   if (constr)
3468   {
3469     if (x != -1)
3470     {
3471       constr->left.SetValue(x);
3472       constr->left.SetDone(TRUE);
3473     }
3474     if (y != -1)
3475     {
3476       constr->top.SetValue(y);
3477       constr->top.SetDone(TRUE);
3478     }
3479   }
3480 }
3481
3482 void wxWindow::GetSizeConstraint(int *w, int *h) const
3483 {
3484   wxLayoutConstraints *constr = GetConstraints();
3485   if (constr)
3486   {
3487     *w = constr->width.GetValue();
3488     *h = constr->height.GetValue();
3489   }
3490   else
3491     GetSize(w, h);
3492 }
3493
3494 void wxWindow::GetClientSizeConstraint(int *w, int *h) const
3495 {
3496   wxLayoutConstraints *constr = GetConstraints();
3497   if (constr)
3498   {
3499     *w = constr->width.GetValue();
3500     *h = constr->height.GetValue();
3501   }
3502   else
3503     GetClientSize(w, h);
3504 }
3505
3506 void wxWindow::GetPositionConstraint(int *x, int *y) const
3507 {
3508  wxLayoutConstraints *constr = GetConstraints();
3509     if (constr)
3510   {
3511     *x = constr->left.GetValue();
3512     *y = constr->top.GetValue();
3513   }
3514   else
3515     GetPosition(x, y);
3516 }
3517