src/gtk1/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) && ((win->m_windowStyle & wxTE_PROCESS_TAB) == 0))
 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     if (parent->m_windowStyle & wxTAB_TRAVERSAL)
1262     {
1263         /* we now allow a window to get the focus as long as it
1264            doesn't have any children. */
1265         GTK_WIDGET_UNSET_FLAGS( parent->m_wxwindow, GTK_CAN_FOCUS );
1266     }
1267 }
1268
1269 //-----------------------------------------------------------------------------
1270 // global functions
1271 //-----------------------------------------------------------------------------
1272
1273 wxWindow* wxGetActiveWindow()
1274 {
1275   return g_focusWindow;
1276 }
1277
1278 //-----------------------------------------------------------------------------
1279 // wxWindow
1280 //-----------------------------------------------------------------------------
1281
1282 IMPLEMENT_DYNAMIC_CLASS(wxWindow,wxEvtHandler)
1283
1284 BEGIN_EVENT_TABLE(wxWindow, wxEvtHandler)
1285     EVT_SIZE(wxWindow::OnSize)
1286     EVT_SYS_COLOUR_CHANGED(wxWindow::OnSysColourChanged)
1287     EVT_INIT_DIALOG(wxWindow::OnInitDialog)
1288     EVT_KEY_DOWN(wxWindow::OnKeyDown)
1289 END_EVENT_TABLE()
1290
1291 wxWindow::wxWindow()
1292 {
1293     m_widget = (GtkWidget *) NULL;
1294     m_wxwindow = (GtkWidget *) NULL;
1295     m_parent = (wxWindow *) NULL;
1296     m_children.DeleteContents( FALSE );
1297
1298     m_x = 0;
1299     m_y = 0;
1300     m_width = 0;
1301     m_height = 0;
1302     m_minWidth = -1;
1303     m_minHeight = -1;
1304     m_maxWidth = -1;
1305     m_maxHeight = -1;
1306
1307     m_retCode = 0;
1308
1309     m_eventHandler = this;
1310     m_windowValidator = (wxValidator *) NULL;
1311
1312     m_windowId = -1;
1313
1314     m_cursor = (wxCursor *) NULL;
1315     m_font = *wxSWISS_FONT;
1316     m_windowStyle = 0;
1317     m_windowName = "noname";
1318
1319     m_constraints = (wxLayoutConstraints *) NULL;
1320     m_constraintsInvolvedIn = (wxList *) NULL;
1321     m_windowSizer = (wxSizer *) NULL;
1322     m_sizerParent = (wxWindow *) NULL;
1323     m_autoLayout = FALSE;
1324
1325     m_sizeSet = FALSE;
1326     m_hasVMT = FALSE;
1327     m_needParent = TRUE;
1328
1329     m_hasScrolling = FALSE;
1330     m_isScrolling = FALSE;
1331     m_hAdjust = (GtkAdjustment*) NULL;
1332     m_vAdjust = (GtkAdjustment*) NULL;
1333     m_oldHorizontalPos = 0.0;
1334     m_oldVerticalPos = 0.0;
1335
1336     m_isShown = FALSE;
1337     m_isEnabled = TRUE;
1338
1339 #if wxUSE_DRAG_AND_DROP
1340     m_dropTarget = (wxDropTarget*) NULL;
1341 #endif
1342     m_resizing = FALSE;
1343     m_scrollGC = (GdkGC*) NULL;
1344     m_widgetStyle = (GtkStyle*) NULL;
1345
1346     m_insertCallback = wxInsertChildInWindow;
1347
1348     m_clientObject = (wxClientData*) NULL;
1349     m_clientData = NULL;
1350
1351     m_isStaticBox = FALSE;
1352     m_acceptsFocus = FALSE;
1353
1354 #if wxUSE_TOOLTIPS
1355     m_toolTip = (wxToolTip*) NULL;
1356 #endif // wxUSE_TOOLTIPS
1357 }
1358
1359 wxWindow::wxWindow( wxWindow *parent, wxWindowID id,
1360                     const wxPoint &pos, const wxSize &size,
1361                     long style, const wxString &name  )
1362 {
1363     m_insertCallback = wxInsertChildInWindow;
1364     Create( parent, id, pos, size, style, name );
1365 }
1366
1367 bool wxWindow::Create( wxWindow *parent, wxWindowID id,
1368                        const wxPoint &pos, const wxSize &size,
1369                        long style, const wxString &name  )
1370 {
1371     m_isShown = FALSE;
1372     m_isEnabled = TRUE;
1373     m_needParent = TRUE;
1374
1375     PreCreation( parent, id, pos, size, style, name );
1376
1377     m_widget = gtk_scrolled_window_new( (GtkAdjustment *) NULL, (GtkAdjustment *) NULL );
1378     GTK_WIDGET_UNSET_FLAGS( m_widget, GTK_CAN_FOCUS );
1379
1380 #ifdef __WXDEBUG__
1381     debug_focus_in( m_widget, "wxWindow::m_widget", name );
1382 #endif
1383
1384     GtkScrolledWindow *s_window = GTK_SCROLLED_WINDOW(m_widget);
1385
1386 #ifdef __WXDEBUG__
1387     debug_focus_in( s_window->hscrollbar, "wxWindow::hsrcollbar", name );
1388     debug_focus_in( s_window->vscrollbar, "wxWindow::vsrcollbar", name );
1389 #endif
1390
1391     GtkScrolledWindowClass *scroll_class = GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT(m_widget)->klass );
1392     scroll_class->scrollbar_spacing = 0;
1393
1394     gtk_scrolled_window_set_policy( s_window, GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC );
1395
1396     m_oldHorizontalPos = 0.0;
1397     m_oldVerticalPos = 0.0;
1398
1399     m_hAdjust = gtk_range_get_adjustment( GTK_RANGE(s_window->hscrollbar) );
1400     m_vAdjust = gtk_range_get_adjustment( GTK_RANGE(s_window->vscrollbar) );
1401
1402     m_wxwindow = gtk_myfixed_new();
1403
1404 #ifdef __WXDEBUG__
1405     debug_focus_in( m_wxwindow, "wxWindow::m_wxwindow", name );
1406 #endif
1407
1408 #ifdef NEW_GTK_SCROLL_CODE
1409     gtk_scrolled_window_add_with_viewport( GTK_SCROLLED_WINDOW(m_widget), m_wxwindow );
1410     GtkViewport *viewport = GTK_VIEWPORT(s_window->child);
1411 #else
1412     gtk_container_add( GTK_CONTAINER(m_widget), m_wxwindow );
1413     GtkViewport *viewport = GTK_VIEWPORT(s_window->viewport);
1414 #endif
1415
1416 #ifdef __WXDEBUG__
1417     debug_focus_in( GTK_WIDGET(viewport), "wxWindow::viewport", name );
1418 #endif
1419
1420     if (m_windowStyle & wxRAISED_BORDER)
1421     {
1422         gtk_viewport_set_shadow_type( viewport, GTK_SHADOW_OUT );
1423     }
1424     else if (m_windowStyle & wxSUNKEN_BORDER)
1425     {
1426         gtk_viewport_set_shadow_type( viewport, GTK_SHADOW_IN );
1427     }
1428     else
1429     {
1430         gtk_viewport_set_shadow_type( viewport, GTK_SHADOW_NONE );
1431     }
1432
1433     if (m_windowStyle & wxTAB_TRAVERSAL)
1434     {
1435         /* we now allow a window to get the focus as long as it
1436            doesn't have any children. */
1437         GTK_WIDGET_SET_FLAGS( m_wxwindow, GTK_CAN_FOCUS );
1438         m_acceptsFocus = FALSE;
1439     }
1440     else
1441     {
1442         GTK_WIDGET_SET_FLAGS( m_wxwindow, GTK_CAN_FOCUS );
1443         m_acceptsFocus = TRUE;
1444     }
1445
1446     // shut the viewport up
1447     gtk_viewport_set_hadjustment( viewport, (GtkAdjustment*) gtk_adjustment_new( 0.0, 0.0, 0.0, 0.0, 0.0, 0.0) );
1448     gtk_viewport_set_vadjustment( viewport, (GtkAdjustment*) gtk_adjustment_new( 0.0, 0.0, 0.0, 0.0, 0.0, 0.0) );
1449
1450     // I _really_ don't want scrollbars in the beginning
1451     m_vAdjust->lower = 0.0;
1452     m_vAdjust->upper = 1.0;
1453     m_vAdjust->value = 0.0;
1454     m_vAdjust->step_increment = 1.0;
1455     m_vAdjust->page_increment = 1.0;
1456     m_vAdjust->page_size = 5.0;
1457     gtk_signal_emit_by_name( GTK_OBJECT(m_vAdjust), "changed" );
1458     m_hAdjust->lower = 0.0;
1459     m_hAdjust->upper = 1.0;
1460     m_hAdjust->value = 0.0;
1461     m_hAdjust->step_increment = 1.0;
1462     m_hAdjust->page_increment = 1.0;
1463     m_hAdjust->page_size = 5.0;
1464     gtk_signal_emit_by_name( GTK_OBJECT(m_hAdjust), "changed" );
1465
1466     // these handlers block mouse events to any window during scrolling
1467     // such as motion events and prevent GTK and wxWindows from fighting
1468     // over where the slider should be
1469
1470     gtk_signal_connect( GTK_OBJECT(s_window->vscrollbar), "button_press_event",
1471           (GtkSignalFunc)gtk_scrollbar_button_press_callback, (gpointer) this );
1472
1473     gtk_signal_connect( GTK_OBJECT(s_window->hscrollbar), "button_press_event",
1474           (GtkSignalFunc)gtk_scrollbar_button_press_callback, (gpointer) this );
1475
1476     gtk_signal_connect( GTK_OBJECT(s_window->vscrollbar), "button_release_event",
1477           (GtkSignalFunc)gtk_scrollbar_button_release_callback, (gpointer) this );
1478
1479     gtk_signal_connect( GTK_OBJECT(s_window->hscrollbar), "button_release_event",
1480           (GtkSignalFunc)gtk_scrollbar_button_release_callback, (gpointer) this );
1481
1482     // these handers het notified when screen updates are required either when
1483     // scrolling or when the window size (and therefore scrollbar configuration)
1484     // has changed
1485
1486     gtk_signal_connect( GTK_OBJECT(m_hAdjust), "value_changed",
1487           (GtkSignalFunc) gtk_window_hscroll_callback, (gpointer) this );
1488     gtk_signal_connect( GTK_OBJECT(m_vAdjust), "value_changed",
1489           (GtkSignalFunc) gtk_window_vscroll_callback, (gpointer) this );
1490
1491     gtk_signal_connect( GTK_OBJECT(m_hAdjust), "changed",
1492           (GtkSignalFunc) gtk_window_hscroll_change_callback, (gpointer) this );
1493     gtk_signal_connect(GTK_OBJECT(m_vAdjust), "changed",
1494           (GtkSignalFunc) gtk_window_vscroll_change_callback, (gpointer) this );
1495
1496     gtk_widget_show( m_wxwindow );
1497
1498     if (m_parent) m_parent->AddChild( this );
1499
1500     (m_parent->m_insertCallback)( m_parent, this );
1501
1502     PostCreation();
1503
1504     Show( TRUE );
1505
1506     return TRUE;
1507 }
1508
1509 wxWindow::~wxWindow()
1510 {
1511     m_hasVMT = FALSE;
1512
1513 #if wxUSE_DRAG_AND_DROP
1514     wxDELETE(m_dropTarget);
1515 #endif
1516
1517 #if wxUSE_TOOLTIPS
1518     wxDELETE(m_toolTip);
1519 #endif // wxUSE_TOOLTIPS
1520
1521     if (m_parent) m_parent->RemoveChild( this );
1522     if (m_widget) Show( FALSE );
1523
1524     DestroyChildren();
1525
1526     if (m_widgetStyle) gtk_style_unref( m_widgetStyle );
1527
1528     if (m_scrollGC) gdk_gc_unref( m_scrollGC );
1529
1530     if (m_wxwindow) gtk_widget_destroy( m_wxwindow );
1531
1532     if (m_widget) gtk_widget_destroy( m_widget );
1533
1534     if (m_cursor) delete m_cursor;
1535
1536     DeleteRelatedConstraints();
1537     if (m_constraints)
1538     {
1539         // This removes any dangling pointers to this window
1540         // in other windows' constraintsInvolvedIn lists.
1541         UnsetConstraints(m_constraints);
1542         delete m_constraints;
1543         m_constraints = (wxLayoutConstraints *) NULL;
1544     }
1545     if (m_windowSizer)
1546     {
1547         delete m_windowSizer;
1548         m_windowSizer = (wxSizer *) NULL;
1549     }
1550     // If this is a child of a sizer, remove self from parent
1551     if (m_sizerParent) m_sizerParent->RemoveChild((wxWindow *)this);
1552
1553     // Just in case the window has been Closed, but
1554     // we're then deleting immediately: don't leave
1555     // dangling pointers.
1556     wxPendingDelete.DeleteObject(this);
1557
1558     // Just in case we've loaded a top-level window via
1559     // wxWindow::LoadNativeDialog but we weren't a dialog
1560     // class
1561     wxTopLevelWindows.DeleteObject(this);
1562
1563     if (m_windowValidator) delete m_windowValidator;
1564
1565     if (m_clientObject) delete m_clientObject;
1566 }
1567
1568 void wxWindow::PreCreation( wxWindow *parent, wxWindowID id,
1569       const wxPoint &pos, const wxSize &size,
1570       long style, const wxString &name )
1571 {
1572     wxASSERT_MSG( (!m_needParent) || (parent), "Need complete parent." );
1573
1574     m_widget = (GtkWidget*) NULL;
1575     m_wxwindow = (GtkWidget*) NULL;
1576     m_hasVMT = FALSE;
1577     m_parent = parent;
1578     m_children.DeleteContents( FALSE );
1579
1580     m_width = size.x;
1581     if (m_width == -1) m_width = 20;
1582     m_height = size.y;
1583     if (m_height == -1) m_height = 20;
1584
1585     m_x = (int)pos.x;
1586     m_y = (int)pos.y;
1587
1588     if (!m_needParent)  // some reasonable defaults
1589     {
1590         if (m_x == -1)
1591         {
1592             m_x = (gdk_screen_width () - m_width) / 2;
1593             if (m_x < 10) m_x = 10;
1594         }
1595         if (m_y == -1)
1596         {
1597             m_y = (gdk_screen_height () - m_height) / 2;
1598             if (m_y < 10) m_y = 10;
1599         }
1600     }
1601
1602     m_minWidth = -1;
1603     m_minHeight = -1;
1604     m_maxWidth = -1;
1605     m_maxHeight = -1;
1606
1607     m_retCode = 0;
1608
1609     m_eventHandler = this;
1610
1611     m_windowId = id == -1 ? wxNewId() : id;
1612
1613     m_sizeSet = FALSE;
1614
1615     m_cursor = new wxCursor( wxCURSOR_ARROW );
1616     m_font = *wxSWISS_FONT;
1617     m_backgroundColour = wxSystemSettings::GetSystemColour( wxSYS_COLOUR_BTNFACE );
1618     m_foregroundColour = *wxBLACK;
1619     m_windowStyle = style;
1620     m_windowName = name;
1621
1622     m_constraints = (wxLayoutConstraints *) NULL;
1623     m_constraintsInvolvedIn = (wxList *) NULL;
1624     m_windowSizer = (wxSizer *) NULL;
1625     m_sizerParent = (wxWindow *) NULL;
1626     m_autoLayout = FALSE;
1627
1628     m_hasScrolling = FALSE;
1629     m_isScrolling = FALSE;
1630     m_hAdjust = (GtkAdjustment *) NULL;
1631     m_vAdjust = (GtkAdjustment *) NULL;
1632     m_oldHorizontalPos = 0.0;
1633     m_oldVerticalPos = 0.0;
1634
1635     m_isShown = FALSE;
1636     m_isEnabled = TRUE;
1637
1638 #if wxUSE_DRAG_AND_DROP
1639     m_dropTarget = (wxDropTarget *) NULL;
1640 #endif
1641     m_resizing = FALSE;
1642     m_windowValidator = (wxValidator *) NULL;
1643     m_scrollGC = (GdkGC*) NULL;
1644     m_widgetStyle = (GtkStyle*) NULL;
1645
1646     m_clientObject = (wxClientData*)NULL;
1647     m_clientData = NULL;
1648
1649     m_isStaticBox = FALSE;
1650
1651 #if wxUSE_TOOLTIPS
1652     m_toolTip = (wxToolTip*) NULL;
1653 #endif // wxUSE_TOOLTIPS
1654 }
1655
1656 void wxWindow::PostCreation()
1657 {
1658     if (m_wxwindow)
1659     {
1660       gtk_signal_connect( GTK_OBJECT(m_wxwindow), "expose_event",
1661         GTK_SIGNAL_FUNC(gtk_window_expose_callback), (gpointer)this );
1662
1663       gtk_signal_connect( GTK_OBJECT(m_wxwindow), "draw",
1664         GTK_SIGNAL_FUNC(gtk_window_draw_callback), (gpointer)this );
1665     }
1666
1667     ConnectWidget( GetConnectWidget() );
1668
1669     if (m_widget && m_parent) gtk_widget_realize( m_widget );
1670
1671     if (m_wxwindow) gtk_widget_realize( m_wxwindow );
1672
1673     SetCursor( *wxSTANDARD_CURSOR );
1674
1675     m_hasVMT = TRUE;
1676 }
1677
1678 void wxWindow::ConnectWidget( GtkWidget *widget )
1679 {
1680     gtk_signal_connect( GTK_OBJECT(widget), "key_press_event",
1681       GTK_SIGNAL_FUNC(gtk_window_key_press_callback), (gpointer)this );
1682
1683     gtk_signal_connect( GTK_OBJECT(widget), "key_release_event",
1684       GTK_SIGNAL_FUNC(gtk_window_key_release_callback), (gpointer)this );
1685
1686     gtk_signal_connect( GTK_OBJECT(widget), "button_press_event",
1687       GTK_SIGNAL_FUNC(gtk_window_button_press_callback), (gpointer)this );
1688
1689     gtk_signal_connect( GTK_OBJECT(widget), "button_release_event",
1690       GTK_SIGNAL_FUNC(gtk_window_button_release_callback), (gpointer)this );
1691
1692     gtk_signal_connect( GTK_OBJECT(widget), "motion_notify_event",
1693       GTK_SIGNAL_FUNC(gtk_window_motion_notify_callback), (gpointer)this );
1694
1695     gtk_signal_connect( GTK_OBJECT(widget), "focus_in_event",
1696       GTK_SIGNAL_FUNC(gtk_window_focus_in_callback), (gpointer)this );
1697
1698     gtk_signal_connect( GTK_OBJECT(widget), "focus_out_event",
1699       GTK_SIGNAL_FUNC(gtk_window_focus_out_callback), (gpointer)this );
1700
1701     gtk_signal_connect( GTK_OBJECT(widget), "enter_notify_event",
1702       GTK_SIGNAL_FUNC(gtk_window_enter_callback), (gpointer)this );
1703
1704     gtk_signal_connect( GTK_OBJECT(widget), "leave_notify_event",
1705       GTK_SIGNAL_FUNC(gtk_window_leave_callback), (gpointer)this );
1706 }
1707
1708 bool wxWindow::HasVMT()
1709 {
1710     return m_hasVMT;
1711 }
1712
1713 bool wxWindow::Close( bool force )
1714 {
1715     wxASSERT_MSG( (m_widget != NULL), "invalid window" );
1716
1717     wxCloseEvent event(wxEVT_CLOSE_WINDOW, m_windowId);
1718     event.SetEventObject(this);
1719     event.SetCanVeto(!force);
1720
1721     // return FALSE if window wasn't closed because the application vetoed the
1722     // close event
1723     return GetEventHandler()->ProcessEvent(event) && !event.GetVeto();
1724 }
1725
1726 bool wxWindow::Destroy()
1727 {
1728     wxASSERT_MSG( (m_widget != NULL), "invalid window" );
1729
1730     m_hasVMT = FALSE;
1731     delete this;
1732     return TRUE;
1733 }
1734
1735 bool wxWindow::DestroyChildren()
1736 {
1737     wxNode *node;
1738     while ((node = m_children.First()) != (wxNode *)NULL)
1739     {
1740         wxWindow *child;
1741         if ((child = (wxWindow *)node->Data()) != (wxWindow *)NULL)
1742         {
1743             delete child;
1744             if (m_children.Member(child)) delete node;
1745         }
1746     }
1747     return TRUE;
1748 }
1749
1750 void wxWindow::PrepareDC( wxDC &WXUNUSED(dc) )
1751 {
1752     // are we to set fonts here ?
1753 }
1754
1755 wxPoint wxWindow::GetClientAreaOrigin() const
1756 {
1757     return wxPoint(0,0);
1758 }
1759
1760 void wxWindow::AdjustForParentClientOrigin( int& x, int& y, int sizeFlags )
1761 {
1762     if (((sizeFlags & wxSIZE_NO_ADJUSTMENTS) == 0) && GetParent())
1763     {
1764         wxPoint pt(GetParent()->GetClientAreaOrigin());
1765         x += pt.x;
1766         y += pt.y;
1767     }
1768 }
1769
1770 void wxWindow::SetSize( int x, int y, int width, int height, int sizeFlags )
1771 {
1772     wxASSERT_MSG( (m_widget != NULL), "invalid window" );
1773     wxASSERT_MSG( (m_parent != NULL), "wxWindow::SetSize requires parent.\n" );
1774
1775     if (m_resizing) return; // I don't like recursions
1776     m_resizing = TRUE;
1777
1778     if (m_parent->m_wxwindow == NULL) // i.e. wxNotebook
1779     {
1780         // don't set the size for children of wxNotebook, just take the values.
1781         m_x = x;
1782         m_y = y;
1783         m_width = width;
1784         m_height = height;
1785     }
1786     else
1787     {
1788         int old_width = m_width;
1789         int old_height = m_height;
1790
1791         if ((sizeFlags & wxSIZE_USE_EXISTING) == wxSIZE_USE_EXISTING)
1792         {
1793             if (x != -1) m_x = x;
1794             if (y != -1) m_y = y;
1795             if (width != -1) m_width = width;
1796             if (height != -1) m_height = height;
1797         }
1798         else
1799         {
1800             m_x = x;
1801             m_y = y;
1802             m_width = width;
1803             m_height = height;
1804         }
1805
1806         if ((sizeFlags & wxSIZE_AUTO_WIDTH) == wxSIZE_AUTO_WIDTH)
1807         {
1808              if (width == -1) m_width = 80;
1809         }
1810
1811         if ((sizeFlags & wxSIZE_AUTO_HEIGHT) == wxSIZE_AUTO_HEIGHT)
1812         {
1813              if (height == -1) m_height = 26;
1814         }
1815
1816         if ((m_minWidth != -1) && (m_width < m_minWidth)) m_width = m_minWidth;
1817         if ((m_minHeight != -1) && (m_height < m_minHeight)) m_height = m_minHeight;
1818         if ((m_maxWidth != -1) && (m_width > m_maxWidth)) m_width = m_maxWidth;
1819         if ((m_maxHeight != -1) && (m_height > m_maxHeight)) m_height = m_maxHeight;
1820
1821         wxPoint pt( m_parent->GetClientAreaOrigin() );
1822         gtk_myfixed_move( GTK_MYFIXED(m_parent->m_wxwindow), m_widget, m_x+pt.x, m_y+pt.y );
1823
1824         if ((old_width != m_width) || (old_height != m_height))
1825              gtk_widget_set_usize( m_widget, m_width, m_height );
1826     }
1827
1828     m_sizeSet = TRUE;
1829
1830     wxSizeEvent event( wxSize(m_width,m_height), GetId() );
1831     event.SetEventObject( this );
1832     GetEventHandler()->ProcessEvent( event );
1833
1834     m_resizing = FALSE;
1835 }
1836
1837 void wxWindow::OnInternalIdle()
1838 {
1839     UpdateWindowUI();
1840 }
1841
1842 void wxWindow::SetSize( int width, int height )
1843 {
1844     SetSize( -1, -1, width, height, wxSIZE_USE_EXISTING );
1845 }
1846
1847 void wxWindow::Move( int x, int y )
1848 {
1849     SetSize( x, y, -1, -1, wxSIZE_USE_EXISTING );
1850 }
1851
1852 void wxWindow::GetSize( int *width, int *height ) const
1853 {
1854     wxCHECK_RET( (m_widget != NULL), "invalid window" );
1855
1856     if (width) (*width) = m_width;
1857     if (height) (*height) = m_height;
1858 }
1859
1860 void wxWindow::SetClientSize( int width, int height )
1861 {
1862     wxCHECK_RET( (m_widget != NULL), "invalid window" );
1863
1864     if (!m_wxwindow)
1865     {
1866         SetSize( width, height );
1867     }
1868     else
1869     {
1870         int dw = 0;
1871         int dh = 0;
1872
1873         if (!m_hasScrolling)
1874         {
1875             GtkStyleClass *window_class = m_wxwindow->style->klass;
1876
1877             if ((m_windowStyle & wxRAISED_BORDER) ||
1878                 (m_windowStyle & wxSUNKEN_BORDER))
1879             {
1880                 dw += 2 * window_class->xthickness;
1881                 dh += 2 * window_class->ythickness;
1882             }
1883         }
1884         else
1885         {
1886             GtkScrolledWindow *scroll_window = GTK_SCROLLED_WINDOW(m_widget);
1887             GtkScrolledWindowClass *scroll_class = GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT(m_widget)->klass );
1888
1889 #ifdef NEW_GTK_SCROLL_CODE
1890             GtkWidget *viewport = scroll_window->child;
1891 #else
1892             GtkWidget *viewport = scroll_window->viewport;
1893 #endif
1894
1895             GtkStyleClass *viewport_class = viewport->style->klass;
1896
1897             GtkWidget *hscrollbar = scroll_window->hscrollbar;
1898             GtkWidget *vscrollbar = scroll_window->vscrollbar;
1899
1900             if ((m_windowStyle & wxRAISED_BORDER) ||
1901                 (m_windowStyle & wxSUNKEN_BORDER))
1902             {
1903                 dw += 2 * viewport_class->xthickness;
1904                 dh += 2 * viewport_class->ythickness;
1905             }
1906
1907             if (scroll_window->vscrollbar_visible)
1908             {
1909                 dw += vscrollbar->allocation.width;
1910                 dw += scroll_class->scrollbar_spacing;
1911             }
1912
1913             if (scroll_window->hscrollbar_visible)
1914             {
1915                 dh += hscrollbar->allocation.height;
1916                 dw += scroll_class->scrollbar_spacing;
1917             }
1918        }
1919
1920       SetSize( width+dw, height+dh );
1921     }
1922 }
1923
1924 void wxWindow::GetClientSize( int *width, int *height ) const
1925 {
1926     wxCHECK_RET( (m_widget != NULL), "invalid window" );
1927
1928     if (!m_wxwindow)
1929     {
1930         if (width) (*width) = m_width;
1931         if (height) (*height) = m_height;
1932     }
1933     else
1934     {
1935         int dw = 0;
1936         int dh = 0;
1937
1938         if (!m_hasScrolling)
1939         {
1940             GtkStyleClass *window_class = m_wxwindow->style->klass;
1941
1942             if ((m_windowStyle & wxRAISED_BORDER) ||
1943                 (m_windowStyle & wxSUNKEN_BORDER))
1944             {
1945                 dw += 2 * window_class->xthickness;
1946                 dh += 2 * window_class->ythickness;
1947             }
1948         }
1949         else
1950         {
1951             GtkScrolledWindow *scroll_window = GTK_SCROLLED_WINDOW(m_widget);
1952             GtkScrolledWindowClass *scroll_class = GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT(m_widget)->klass );
1953
1954 #ifdef NEW_GTK_SCROLL_CODE
1955             GtkWidget *viewport = scroll_window->child;
1956 #else
1957             GtkWidget *viewport = scroll_window->viewport;
1958 #endif
1959
1960             GtkStyleClass *viewport_class = viewport->style->klass;
1961
1962             if ((m_windowStyle & wxRAISED_BORDER) ||
1963                 (m_windowStyle & wxSUNKEN_BORDER))
1964             {
1965                 dw += 2 * viewport_class->xthickness;
1966                 dh += 2 * viewport_class->ythickness;
1967             }
1968
1969             if (scroll_window->vscrollbar_visible)
1970             {
1971 //              dw += vscrollbar->allocation.width;
1972                 dw += 15;                               // range.slider_width = 11 + 2*2pts edge
1973                 dw += scroll_class->scrollbar_spacing;
1974             }
1975
1976             if (scroll_window->hscrollbar_visible)
1977             {
1978 //              dh += hscrollbar->allocation.height;
1979                 dh += 15;
1980                 dh += scroll_class->scrollbar_spacing;
1981             }
1982         }
1983
1984         if (width) (*width) = m_width - dw;
1985         if (height) (*height) = m_height - dh;
1986     }
1987 }
1988
1989 void wxWindow::GetPosition( int *x, int *y ) const
1990 {
1991     wxCHECK_RET( (m_widget != NULL), "invalid window" );
1992
1993     if (x) (*x) = m_x;
1994     if (y) (*y) = m_y;
1995 }
1996
1997 void wxWindow::ClientToScreen( int *x, int *y )
1998 {
1999     wxCHECK_RET( (m_widget != NULL), "invalid window" );
2000
2001     GdkWindow *source = (GdkWindow *) NULL;
2002     if (m_wxwindow)
2003         source = m_wxwindow->window;
2004     else
2005         source = m_widget->window;
2006
2007     int org_x = 0;
2008     int org_y = 0;
2009     gdk_window_get_origin( source, &org_x, &org_y );
2010
2011     if (!m_wxwindow)
2012     {
2013         if (GTK_WIDGET_NO_WINDOW (m_widget))
2014         {
2015             org_x += m_widget->allocation.x;
2016             org_y += m_widget->allocation.y;
2017         }
2018     }
2019
2020     wxPoint pt(GetClientAreaOrigin());
2021     org_x += pt.x;
2022     org_y += pt.y;
2023
2024     if (x) *x += org_x;
2025     if (y) *y += org_y;
2026 }
2027
2028 void wxWindow::ScreenToClient( int *x, int *y )
2029 {
2030     wxCHECK_RET( (m_widget != NULL), "invalid window" );
2031
2032     GdkWindow *source = (GdkWindow *) NULL;
2033     if (m_wxwindow)
2034         source = m_wxwindow->window;
2035     else
2036         source = m_widget->window;
2037
2038     int org_x = 0;
2039     int org_y = 0;
2040     gdk_window_get_origin( source, &org_x, &org_y );
2041
2042     if (!m_wxwindow)
2043     {
2044         if (GTK_WIDGET_NO_WINDOW (m_widget))
2045         {
2046             org_x += m_widget->allocation.x;
2047             org_y += m_widget->allocation.y;
2048         }
2049     }
2050
2051     wxPoint pt(GetClientAreaOrigin());
2052     org_x -= pt.x;
2053     org_y -= pt.y;
2054
2055     if (x) *x -= org_x;
2056     if (y) *y -= org_y;
2057 }
2058
2059 void wxWindow::Centre( int direction )
2060 {
2061     wxCHECK_RET( (m_widget != NULL), "invalid window" );
2062
2063     int x = m_x;
2064     int y = m_y;
2065
2066     if (m_parent)
2067     {
2068         int p_w = 0;
2069         int p_h = 0;
2070         m_parent->GetSize( &p_w, &p_h );
2071         if (direction & wxHORIZONTAL == wxHORIZONTAL) x = (p_w - m_width) / 2;
2072         if (direction & wxVERTICAL == wxVERTICAL) y = (p_h - m_height) / 2;
2073     }
2074     else
2075     {
2076         if (direction & wxHORIZONTAL == wxHORIZONTAL) x = (gdk_screen_width () - m_width) / 2;
2077         if (direction & wxVERTICAL == wxVERTICAL) y = (gdk_screen_height () - m_height) / 2;
2078     }
2079
2080     Move( x, y );
2081 }
2082
2083 void wxWindow::Fit()
2084 {
2085     wxCHECK_RET( (m_widget != NULL), "invalid window" );
2086
2087     int maxX = 0;
2088     int maxY = 0;
2089     wxNode *node = m_children.First();
2090     while (node)
2091     {
2092         wxWindow *win = (wxWindow *)node->Data();
2093         int wx, wy, ww, wh;
2094         win->GetPosition(&wx, &wy);
2095         win->GetSize(&ww, &wh);
2096         if (wx + ww > maxX) maxX = wx + ww;
2097         if (wy + wh > maxY) maxY = wy + wh;
2098
2099         node = node->Next();
2100     }
2101
2102     SetClientSize(maxX + 7, maxY + 14);
2103 }
2104
2105 void wxWindow::SetSizeHints( int minW, int minH, int maxW, int maxH, int WXUNUSED(incW), int WXUNUSED(incH) )
2106 {
2107     wxCHECK_RET( (m_widget != NULL), "invalid window" );
2108
2109     m_minWidth = minW;
2110     m_minHeight = minH;
2111     m_maxWidth = maxW;
2112     m_maxHeight = maxH;
2113 }
2114
2115 void wxWindow::OnSize( wxSizeEvent &WXUNUSED(event) )
2116 {
2117 //  if (GetAutoLayout()) Layout();
2118 }
2119
2120 bool wxWindow::Show( bool show )
2121 {
2122     wxCHECK_MSG( (m_widget != NULL), FALSE, "invalid window" );
2123
2124     if (show)
2125         gtk_widget_show( m_widget );
2126     else
2127         gtk_widget_hide( m_widget );
2128
2129     m_isShown = show;
2130
2131     return TRUE;
2132 }
2133
2134 void wxWindow::Enable( bool enable )
2135 {
2136     wxCHECK_RET( (m_widget != NULL), "invalid window" );
2137
2138     m_isEnabled = enable;
2139
2140     gtk_widget_set_sensitive( m_widget, enable );
2141     if (m_wxwindow) gtk_widget_set_sensitive( m_wxwindow, enable );
2142 }
2143
2144 int wxWindow::GetCharHeight() const
2145 {
2146     wxCHECK_MSG( (m_widget != NULL), 12, "invalid window" );
2147
2148     wxCHECK_MSG( m_font.Ok(), 12, "invalid font" );
2149
2150     GdkFont *font = m_font.GetInternalFont( 1.0 );
2151
2152     return font->ascent + font->descent;
2153 }
2154
2155 int wxWindow::GetCharWidth() const
2156 {
2157     wxCHECK_MSG( (m_widget != NULL), 8, "invalid window" );
2158
2159     wxCHECK_MSG( m_font.Ok(), 8, "invalid font" );
2160
2161     GdkFont *font = m_font.GetInternalFont( 1.0 );
2162
2163     return gdk_string_width( font, "H" );
2164 }
2165
2166 void wxWindow::GetTextExtent( const wxString& string, int *x, int *y,
2167   int *descent, int *externalLeading, const wxFont *theFont, bool WXUNUSED(use16) ) const
2168 {
2169     wxFont fontToUse = m_font;
2170     if (theFont) fontToUse = *theFont;
2171
2172     wxCHECK_RET( fontToUse.Ok(), "invalid font" );
2173
2174     GdkFont *font = fontToUse.GetInternalFont( 1.0 );
2175     if (x) (*x) = gdk_string_width( font, string );
2176     if (y) (*y) = font->ascent + font->descent;
2177     if (descent) (*descent) = font->descent;
2178     if (externalLeading) (*externalLeading) = 0;  // ??
2179 }
2180
2181 void wxWindow::MakeModal( bool modal )
2182 {
2183     return;
2184
2185     // Disable all other windows
2186     if (this->IsKindOf(CLASSINFO(wxDialog)) || this->IsKindOf(CLASSINFO(wxFrame)))
2187     {
2188         wxNode *node = wxTopLevelWindows.First();
2189         while (node)
2190         {
2191             wxWindow *win = (wxWindow *)node->Data();
2192             if (win != this) win->Enable(!modal);
2193
2194             node = node->Next();
2195         }
2196     }
2197 }
2198
2199 void wxWindow::OnKeyDown( wxKeyEvent &event )
2200 {
2201     event.SetEventType( wxEVT_CHAR );
2202
2203     if (!GetEventHandler()->ProcessEvent( event ))
2204     {
2205         event.Skip();
2206     }
2207 }
2208
2209 void wxWindow::SetFocus()
2210 {
2211     wxCHECK_RET( (m_widget != NULL), "invalid window" );
2212
2213     GtkWidget *connect_widget = GetConnectWidget();
2214     if (connect_widget)
2215     {
2216         if (GTK_WIDGET_CAN_FOCUS(connect_widget) /*&& !GTK_WIDGET_HAS_FOCUS (connect_widget)*/ )
2217         {
2218             gtk_widget_grab_focus (connect_widget);
2219         }
2220         else if (GTK_IS_CONTAINER(connect_widget))
2221         {
2222             gtk_container_focus( GTK_CONTAINER(connect_widget), GTK_DIR_TAB_FORWARD );
2223         }
2224         else
2225         {
2226         }
2227     }
2228 }
2229
2230 wxWindow *wxWindow::FindFocus()
2231 {
2232     return g_focusWindow;
2233 }
2234
2235 bool wxWindow::AcceptsFocus() const
2236 {
2237     return IsEnabled() && IsShown() && m_acceptsFocus;
2238 }
2239
2240 void wxWindow::AddChild( wxWindow *child )
2241 {
2242     wxCHECK_RET( (m_widget != NULL), "invalid window" );
2243     wxCHECK_RET( (child != NULL), "invalid child" );
2244
2245     m_children.Append( child );
2246 }
2247
2248 wxWindow *wxWindow::ReParent( wxWindow *newParent )
2249 {
2250     wxCHECK_MSG( (m_widget != NULL), (wxWindow*) NULL, "invalid window" );
2251
2252     wxWindow *oldParent = GetParent();
2253
2254     if (oldParent) oldParent->RemoveChild( this );
2255
2256     gtk_widget_unparent( m_widget );
2257
2258     if (newParent)
2259     {
2260         newParent->AddChild( this );
2261         (newParent->m_insertCallback)( newParent, this );
2262     }
2263
2264     return oldParent;
2265 }
2266
2267 void wxWindow::RemoveChild( wxWindow *child )
2268 {
2269     m_children.DeleteObject( child );
2270     child->m_parent = (wxWindow *) NULL;
2271 }
2272
2273 void wxWindow::SetReturnCode( int retCode )
2274 {
2275     m_retCode = retCode;
2276 }
2277
2278 int wxWindow::GetReturnCode()
2279 {
2280     return m_retCode;
2281 }
2282
2283 void wxWindow::Raise()
2284 {
2285     wxCHECK_RET( (m_widget != NULL), "invalid window" );
2286
2287     if (m_widget) gdk_window_raise( m_widget->window );
2288 }
2289
2290 void wxWindow::Lower()
2291 {
2292     wxCHECK_RET( (m_widget != NULL), "invalid window" );
2293
2294     if (m_widget) gdk_window_lower( m_widget->window );
2295 }
2296
2297 wxEvtHandler *wxWindow::GetEventHandler() const
2298 {
2299     return m_eventHandler;
2300 }
2301
2302 void wxWindow::SetEventHandler( wxEvtHandler *handler )
2303 {
2304     m_eventHandler = handler;
2305 }
2306
2307 void wxWindow::PushEventHandler(wxEvtHandler *handler)
2308 {
2309     handler->SetNextHandler(GetEventHandler());
2310     SetEventHandler(handler);
2311 }
2312
2313 wxEvtHandler *wxWindow::PopEventHandler(bool deleteHandler)
2314 {
2315     if (GetEventHandler())
2316     {
2317         wxEvtHandler *handlerA = GetEventHandler();
2318         wxEvtHandler *handlerB = handlerA->GetNextHandler();
2319         handlerA->SetNextHandler((wxEvtHandler *) NULL);
2320         SetEventHandler(handlerB);
2321         if (deleteHandler)
2322         {
2323             delete handlerA;
2324             return (wxEvtHandler*) NULL;
2325         }
2326         else
2327             return handlerA;
2328      }
2329      else
2330         return (wxEvtHandler *) NULL;
2331 }
2332
2333 wxValidator *wxWindow::GetValidator()
2334 {
2335     return m_windowValidator;
2336 }
2337
2338 void wxWindow::SetValidator( const wxValidator& validator )
2339 {
2340     if (m_windowValidator) delete m_windowValidator;
2341     m_windowValidator = validator.Clone();
2342     if (m_windowValidator) m_windowValidator->SetWindow(this);
2343 }
2344
2345 void wxWindow::SetClientObject( wxClientData *data )
2346 {
2347     if (m_clientObject) delete m_clientObject;
2348     m_clientObject = data;
2349 }
2350
2351 wxClientData *wxWindow::GetClientObject()
2352 {
2353     return m_clientObject;
2354 }
2355
2356 void wxWindow::SetClientData( void *data )
2357 {
2358     m_clientData = data;
2359 }
2360
2361 void *wxWindow::GetClientData()
2362 {
2363     return m_clientData;
2364 }
2365
2366 bool wxWindow::IsBeingDeleted()
2367 {
2368     return FALSE;
2369 }
2370
2371 void wxWindow::SetId( wxWindowID id )
2372 {
2373     m_windowId = id;
2374 }
2375
2376 wxWindowID wxWindow::GetId() const
2377 {
2378     return m_windowId;
2379 }
2380
2381 void wxWindow::SetCursor( const wxCursor &cursor )
2382 {
2383     wxCHECK_RET( (m_widget != NULL), "invalid window" );
2384
2385     if (cursor.Ok())
2386     {
2387         if (cursor == *m_cursor) return;
2388         *m_cursor = cursor;
2389     }
2390     else
2391     {
2392         *m_cursor = *wxSTANDARD_CURSOR;
2393     }
2394
2395     if ((m_widget) && (m_widget->window))
2396          gdk_window_set_cursor( m_widget->window, m_cursor->GetCursor() );
2397
2398     if ((m_wxwindow) && (m_wxwindow->window))
2399          gdk_window_set_cursor( m_wxwindow->window, m_cursor->GetCursor() );
2400 }
2401
2402 void wxWindow::WarpPointer( int WXUNUSED(x), int WXUNUSED(y) )
2403 {
2404   // TODO
2405 }
2406
2407 void wxWindow::Refresh( bool eraseBackground, const wxRect *rect )
2408 {
2409     wxCHECK_RET( (m_widget != NULL), "invalid window" );
2410
2411     if (eraseBackground && m_wxwindow && m_wxwindow->window)
2412     {
2413         if (rect)
2414         {
2415             gdk_window_clear_area( m_wxwindow->window,
2416                                    rect->x, rect->y,
2417                                    rect->width,
2418                                    rect->height );
2419         }
2420         else
2421         {
2422             Clear();
2423         }
2424     }
2425
2426     if (!rect)
2427     {
2428         if (m_wxwindow)
2429             gtk_widget_draw( m_wxwindow, (GdkRectangle*) NULL );
2430         else
2431             gtk_widget_draw( m_widget, (GdkRectangle*) NULL );
2432     }
2433     else
2434     {
2435         GdkRectangle gdk_rect;
2436         gdk_rect.x = rect->x;
2437         gdk_rect.y = rect->y;
2438         gdk_rect.width = rect->width;
2439         gdk_rect.height = rect->height;
2440
2441         if (m_wxwindow)
2442             gtk_widget_draw( m_wxwindow, &gdk_rect );
2443         else
2444             gtk_widget_draw( m_widget, &gdk_rect );
2445     }
2446 }
2447
2448 wxRegion wxWindow::GetUpdateRegion() const
2449 {
2450   return m_updateRegion;
2451 }
2452
2453 bool wxWindow::IsExposed( int x, int y) const
2454 {
2455     return (m_updateRegion.Contains( x, y ) != wxOutRegion );
2456 }
2457
2458 bool wxWindow::IsExposed( int x, int y, int w, int h ) const
2459 {
2460     return (m_updateRegion.Contains( x, y, w, h ) != wxOutRegion );
2461 }
2462
2463 bool wxWindow::IsExposed( const wxPoint& pt ) const
2464 {
2465     return (m_updateRegion.Contains( pt.x, pt.y ) != wxOutRegion );
2466 }
2467
2468 bool wxWindow::IsExposed( const wxRect& rect ) const
2469 {
2470     return (m_updateRegion.Contains( rect.x, rect.y, rect.width, rect.height ) != wxOutRegion );
2471 }
2472
2473 void wxWindow::Clear()
2474 {
2475     wxCHECK_RET( m_widget != NULL, "invalid window" );
2476
2477     if (m_wxwindow && m_wxwindow->window) gdk_window_clear( m_wxwindow->window );
2478 }
2479
2480 #if wxUSE_TOOLTIPS
2481 void wxWindow::SetToolTip( const wxString &tip )
2482 {
2483     if (m_toolTip)
2484     {
2485         m_toolTip->SetTip( tip );
2486     }
2487     else
2488     {
2489         SetToolTip( new wxToolTip( tip ) );
2490     }
2491
2492     // setting empty tooltip text does not remove the tooltip any more for
2493     // wxMSW compatibility - use SetToolTip((wxToolTip *)NULL) for this
2494 }
2495
2496 void wxWindow::SetToolTip( wxToolTip *tip )
2497 {
2498     if (m_toolTip)
2499     {
2500         m_toolTip->SetTip( (char*) NULL );
2501         delete m_toolTip;
2502     }
2503
2504     m_toolTip = tip;
2505
2506     if (m_toolTip)
2507         m_toolTip->Apply( this );
2508 }
2509
2510 void wxWindow::ApplyToolTip( GtkTooltips *tips, const char *tip )
2511 {
2512     gtk_tooltips_set_tip( tips, GetConnectWidget(), tip, (gchar*) NULL );
2513 }
2514 #endif // wxUSE_TOOLTIPS
2515
2516 wxColour wxWindow::GetBackgroundColour() const
2517 {
2518     return m_backgroundColour;
2519 }
2520
2521 void wxWindow::SetBackgroundColour( const wxColour &colour )
2522 {
2523     wxCHECK_RET( m_widget != NULL, "invalid window" );
2524
2525     if (m_backgroundColour == colour) return;
2526
2527     m_backgroundColour = colour;
2528     if (!m_backgroundColour.Ok()) return;
2529
2530     if (m_wxwindow)
2531     {
2532         GdkWindow *window = m_wxwindow->window;
2533         m_backgroundColour.CalcPixel( gdk_window_get_colormap( window ) );
2534         gdk_window_set_background( window, m_backgroundColour.GetColor() );
2535     }
2536
2537     wxColour sysbg = wxSystemSettings::GetSystemColour( wxSYS_COLOUR_BTNFACE );
2538     if (sysbg.Red() == colour.Red() &&
2539         sysbg.Green() == colour.Green() &&
2540         sysbg.Blue() == colour.Blue())
2541     {
2542         m_backgroundColour = wxNullColour;
2543         ApplyWidgetStyle();
2544         m_backgroundColour = sysbg;
2545     }
2546     else
2547     {
2548         ApplyWidgetStyle();
2549     }
2550 }
2551
2552 wxColour wxWindow::GetForegroundColour() const
2553 {
2554     return m_foregroundColour;
2555 }
2556
2557 void wxWindow::SetForegroundColour( const wxColour &colour )
2558 {
2559     wxCHECK_RET( m_widget != NULL, "invalid window" );
2560
2561     if (m_foregroundColour == colour) return;
2562
2563     m_foregroundColour = colour;
2564     if (!m_foregroundColour.Ok()) return;
2565
2566     wxColour sysbg = wxSystemSettings::GetSystemColour( wxSYS_COLOUR_BTNFACE );
2567     if (sysbg.Red() == colour.Red() &&
2568         sysbg.Green() == colour.Green() &&
2569         sysbg.Blue() == colour.Blue())
2570     {
2571         m_backgroundColour = wxNullColour;
2572         ApplyWidgetStyle();
2573         m_backgroundColour = sysbg;
2574     }
2575     else
2576     {
2577         ApplyWidgetStyle();
2578     }
2579 }
2580
2581 GtkStyle *wxWindow::GetWidgetStyle()
2582 {
2583     if (m_widgetStyle) gtk_style_unref( m_widgetStyle );
2584
2585     m_widgetStyle =
2586       gtk_style_copy(
2587         gtk_widget_get_style( m_widget ) );
2588
2589     return m_widgetStyle;
2590 }
2591
2592 void wxWindow::SetWidgetStyle()
2593 {
2594     GtkStyle *style = GetWidgetStyle();
2595
2596     gdk_font_unref( style->font );
2597     style->font = gdk_font_ref( m_font.GetInternalFont( 1.0 ) );
2598
2599     if (m_foregroundColour.Ok())
2600     {
2601         m_foregroundColour.CalcPixel( gdk_window_get_colormap( m_widget->window ) );
2602         style->fg[GTK_STATE_NORMAL] = *m_foregroundColour.GetColor();
2603         style->fg[GTK_STATE_PRELIGHT] = *m_foregroundColour.GetColor();
2604         style->fg[GTK_STATE_ACTIVE] = *m_foregroundColour.GetColor();
2605     }
2606
2607     if (m_backgroundColour.Ok())
2608     {
2609         m_backgroundColour.CalcPixel( gdk_window_get_colormap( m_widget->window ) );
2610         style->bg[GTK_STATE_NORMAL] = *m_backgroundColour.GetColor();
2611         style->base[GTK_STATE_NORMAL] = *m_backgroundColour.GetColor();
2612         style->bg[GTK_STATE_PRELIGHT] = *m_backgroundColour.GetColor();
2613         style->base[GTK_STATE_PRELIGHT] = *m_backgroundColour.GetColor();
2614         style->bg[GTK_STATE_ACTIVE] = *m_backgroundColour.GetColor();
2615         style->base[GTK_STATE_ACTIVE] = *m_backgroundColour.GetColor();
2616         style->bg[GTK_STATE_INSENSITIVE] = *m_backgroundColour.GetColor();
2617         style->base[GTK_STATE_INSENSITIVE] = *m_backgroundColour.GetColor();
2618     }
2619 }
2620
2621 void wxWindow::ApplyWidgetStyle()
2622 {
2623 }
2624
2625 bool wxWindow::Validate()
2626 {
2627     wxCHECK_MSG( m_widget != NULL, FALSE, "invalid window" );
2628
2629     wxNode *node = m_children.First();
2630     while (node)
2631     {
2632         wxWindow *child = (wxWindow *)node->Data();
2633         if (child->GetValidator() && /* child->GetValidator()->Ok() && */ !child->GetValidator()->Validate(this))
2634         {
2635             return FALSE;
2636         }
2637         node = node->Next();
2638     }
2639     return TRUE;
2640 }
2641
2642 bool wxWindow::TransferDataToWindow()
2643 {
2644     wxCHECK_MSG( m_widget != NULL, FALSE, "invalid window" );
2645
2646     wxNode *node = m_children.First();
2647     while (node)
2648     {
2649         wxWindow *child = (wxWindow *)node->Data();
2650         if (child->GetValidator() && /* child->GetValidator()->Ok() && */
2651             !child->GetValidator()->TransferToWindow() )
2652         {
2653             wxMessageBox( _("Application Error"), _("Could not transfer data to window"), wxOK|wxICON_EXCLAMATION );
2654             return FALSE;
2655         }
2656         node = node->Next();
2657     }
2658     return TRUE;
2659 }
2660
2661 bool wxWindow::TransferDataFromWindow()
2662 {
2663     wxCHECK_MSG( m_widget != NULL, FALSE, "invalid window" );
2664
2665     wxNode *node = m_children.First();
2666     while (node)
2667     {
2668         wxWindow *child = (wxWindow *)node->Data();
2669         if ( child->GetValidator() && /* child->GetValidator()->Ok() && */ !child->GetValidator()->TransferFromWindow() )
2670         {
2671             return FALSE;
2672         }
2673         node = node->Next();
2674     }
2675     return TRUE;
2676 }
2677
2678 void wxWindow::SetAcceleratorTable( const wxAcceleratorTable& accel )
2679 {
2680     m_acceleratorTable = accel;
2681 }
2682
2683 void wxWindow::OnInitDialog( wxInitDialogEvent &WXUNUSED(event) )
2684 {
2685     TransferDataToWindow();
2686 }
2687
2688 void wxWindow::InitDialog()
2689 {
2690     wxCHECK_RET( m_widget != NULL, "invalid window" );
2691
2692     wxInitDialogEvent event(GetId());
2693     event.SetEventObject( this );
2694     GetEventHandler()->ProcessEvent(event);
2695 }
2696
2697 static void SetInvokingWindow( wxMenu *menu, wxWindow *win )
2698 {
2699     menu->SetInvokingWindow( win );
2700     wxNode *node = menu->m_items.First();
2701     while (node)
2702     {
2703         wxMenuItem *menuitem = (wxMenuItem*)node->Data();
2704         if (menuitem->IsSubMenu())
2705         {
2706             SetInvokingWindow( menuitem->GetSubMenu(), win );
2707         }
2708         node = node->Next();
2709     }
2710 }
2711
2712 static gint gs_pop_x = 0;
2713 static gint gs_pop_y = 0;
2714
2715 static void pop_pos_callback( GtkMenu *menu, gint *x, gint *y, wxWindow *win )
2716 {
2717     win->ClientToScreen( &gs_pop_x, &gs_pop_y );
2718     *x = gs_pop_x;
2719     *y = gs_pop_y;
2720 }
2721
2722 bool wxWindow::PopupMenu( wxMenu *menu, int x, int y )
2723 {
2724     wxCHECK_MSG( m_widget != NULL, FALSE, "invalid window" );
2725
2726     wxCHECK_MSG( menu != NULL, FALSE, "invalid popup-menu" );
2727
2728     SetInvokingWindow( menu, this );
2729
2730     menu->UpdateUI();
2731
2732     gs_pop_x = x;
2733     gs_pop_y = y;
2734
2735     gtk_menu_popup(
2736                   GTK_MENU(menu->m_menu),
2737                   (GtkWidget *) NULL,          // parent menu shell
2738                   (GtkWidget *) NULL,          // parent menu item
2739                   (GtkMenuPositionFunc) pop_pos_callback,
2740                   (gpointer) this,             // client data
2741                   0,                           // button used to activate it
2742                   0 //gs_timeLastClick         // the time of activation
2743                 );
2744     return TRUE;
2745 }
2746
2747 #if wxUSE_DRAG_AND_DROP
2748
2749 void wxWindow::SetDropTarget( wxDropTarget *dropTarget )
2750 {
2751     wxCHECK_RET( m_widget != NULL, "invalid window" );
2752
2753     GtkWidget *dnd_widget = GetConnectWidget();
2754
2755     if (m_dropTarget) m_dropTarget->UnregisterWidget( dnd_widget );
2756
2757     if (m_dropTarget) delete m_dropTarget;
2758     m_dropTarget = dropTarget;
2759
2760     if (m_dropTarget) m_dropTarget->RegisterWidget( dnd_widget );
2761 }
2762
2763 wxDropTarget *wxWindow::GetDropTarget() const
2764 {
2765     return m_dropTarget;
2766 }
2767
2768 #endif
2769
2770 GtkWidget* wxWindow::GetConnectWidget()
2771 {
2772     GtkWidget *connect_widget = m_widget;
2773     if (m_wxwindow) connect_widget = m_wxwindow;
2774
2775     return connect_widget;
2776 }
2777
2778 bool wxWindow::IsOwnGtkWindow( GdkWindow *window )
2779 {
2780     if (m_wxwindow) return (window == m_wxwindow->window);
2781     return (window == m_widget->window);
2782 }
2783
2784 void wxWindow::SetFont( const wxFont &font )
2785 {
2786     wxCHECK_RET( m_widget != NULL, "invalid window" );
2787
2788     if (((wxFont*)&font)->Ok())
2789         m_font = font;
2790     else
2791         m_font = *wxSWISS_FONT;
2792
2793     wxColour sysbg = wxSystemSettings::GetSystemColour( wxSYS_COLOUR_BTNFACE );
2794     if (sysbg.Red() == m_backgroundColour.Red() &&
2795         sysbg.Green() == m_backgroundColour.Green() &&
2796         sysbg.Blue() == m_backgroundColour.Blue())
2797     {
2798         m_backgroundColour = wxNullColour;
2799         ApplyWidgetStyle();
2800         m_backgroundColour = sysbg;
2801     }
2802     else
2803     {
2804         ApplyWidgetStyle();
2805     }
2806 }
2807
2808 void wxWindow::SetWindowStyleFlag( long flag )
2809 {
2810     m_windowStyle = flag;
2811 }
2812
2813 long wxWindow::GetWindowStyleFlag() const
2814 {
2815     return m_windowStyle;
2816 }
2817
2818 void wxWindow::CaptureMouse()
2819 {
2820     wxCHECK_RET( m_widget != NULL, "invalid window" );
2821
2822     wxCHECK_RET( g_capturing == FALSE, "CaptureMouse called twice" );
2823
2824     GtkWidget *connect_widget = GetConnectWidget();
2825     gtk_grab_add( connect_widget );
2826     gdk_pointer_grab( connect_widget->window, FALSE,
2827                       (GdkEventMask)
2828                          (GDK_BUTTON_PRESS_MASK |
2829                           GDK_BUTTON_RELEASE_MASK |
2830                           GDK_POINTER_MOTION_MASK),
2831                       (GdkWindow *) NULL,
2832                       (GdkCursor *) NULL,
2833                       GDK_CURRENT_TIME );
2834     g_capturing = TRUE;
2835 }
2836
2837 void wxWindow::ReleaseMouse()
2838 {
2839     wxCHECK_RET( m_widget != NULL, "invalid window" );
2840
2841     wxCHECK_RET( g_capturing == TRUE, "ReleaseMouse called twice" );
2842
2843     GtkWidget *connect_widget = GetConnectWidget();
2844     gtk_grab_remove( connect_widget );
2845     gdk_pointer_ungrab ( GDK_CURRENT_TIME );
2846     g_capturing = FALSE;
2847 }
2848
2849 void wxWindow::SetTitle( const wxString &WXUNUSED(title) )
2850 {
2851 }
2852
2853 wxString wxWindow::GetTitle() const
2854 {
2855     return (wxString&)m_windowName;
2856 }
2857
2858 wxString wxWindow::GetLabel() const
2859 {
2860     return GetTitle();
2861 }
2862
2863 void wxWindow::SetName( const wxString &name )
2864 {
2865     m_windowName = name;
2866 }
2867
2868 wxString wxWindow::GetName() const
2869 {
2870     return (wxString&)m_windowName;
2871 }
2872
2873 bool wxWindow::IsShown() const
2874 {
2875     return m_isShown;
2876 }
2877
2878 bool wxWindow::IsRetained()
2879 {
2880     return FALSE;
2881 }
2882
2883 wxWindow *wxWindow::FindWindow( long id )
2884 {
2885     if (id == m_windowId) return this;
2886     wxNode *node = m_children.First();
2887     while (node)
2888     {
2889         wxWindow *child = (wxWindow*)node->Data();
2890         wxWindow *res = child->FindWindow( id );
2891         if (res) return res;
2892         node = node->Next();
2893     }
2894     return (wxWindow *) NULL;
2895 }
2896
2897 wxWindow *wxWindow::FindWindow( const wxString& name )
2898 {
2899     if (name == m_windowName) return this;
2900     wxNode *node = m_children.First();
2901     while (node)
2902     {
2903         wxWindow *child = (wxWindow*)node->Data();
2904         wxWindow *res = child->FindWindow( name );
2905         if (res) return res;
2906         node = node->Next();
2907     }
2908     return (wxWindow *) NULL;
2909 }
2910
2911 void wxWindow::SetScrollbar( int orient, int pos, int thumbVisible,
2912       int range, bool refresh )
2913 {
2914     wxCHECK_RET( m_widget != NULL, "invalid window" );
2915
2916     wxCHECK_RET( m_wxwindow != NULL, "window needs client area for scrolling" );
2917
2918     m_hasScrolling = TRUE;
2919
2920     if (orient == wxHORIZONTAL)
2921     {
2922         float fpos = (float)pos;
2923         float frange = (float)range;
2924         float fthumb = (float)thumbVisible;
2925         if (fpos > frange-fthumb) fpos = frange-fthumb;
2926         if (fpos < 0.0) fpos = 0.0;
2927
2928         if ((fabs(frange-m_hAdjust->upper) < 0.2) &&
2929             (fabs(fthumb-m_hAdjust->page_size) < 0.2))
2930         {
2931             SetScrollPos( orient, pos, refresh );
2932             return;
2933         }
2934
2935         m_oldHorizontalPos = fpos;
2936
2937         m_hAdjust->lower = 0.0;
2938         m_hAdjust->upper = frange;
2939         m_hAdjust->value = fpos;
2940         m_hAdjust->step_increment = 1.0;
2941         m_hAdjust->page_increment = (float)(wxMax(fthumb,0));
2942         m_hAdjust->page_size = fthumb;
2943     }
2944     else
2945     {
2946         float fpos = (float)pos;
2947         float frange = (float)range;
2948         float fthumb = (float)thumbVisible;
2949         if (fpos > frange-fthumb) fpos = frange-fthumb;
2950         if (fpos < 0.0) fpos = 0.0;
2951
2952         if ((fabs(frange-m_vAdjust->upper) < 0.2) &&
2953             (fabs(fthumb-m_vAdjust->page_size) < 0.2))
2954         {
2955             SetScrollPos( orient, pos, refresh );
2956             return;
2957         }
2958
2959         m_oldVerticalPos = fpos;
2960
2961         m_vAdjust->lower = 0.0;
2962         m_vAdjust->upper = frange;
2963         m_vAdjust->value = fpos;
2964         m_vAdjust->step_increment = 1.0;
2965         m_vAdjust->page_increment = (float)(wxMax(fthumb,0));
2966         m_vAdjust->page_size = fthumb;
2967     }
2968
2969     if (m_wxwindow->window)
2970     {
2971         if (orient == wxHORIZONTAL)
2972             gtk_signal_emit_by_name( GTK_OBJECT(m_hAdjust), "changed" );
2973         else
2974             gtk_signal_emit_by_name( GTK_OBJECT(m_vAdjust), "changed" );
2975
2976         gtk_widget_set_usize( m_widget, m_width, m_height );
2977     }
2978 }
2979
2980 void wxWindow::SetScrollPos( int orient, int pos, bool WXUNUSED(refresh) )
2981 {
2982     wxCHECK_RET( m_widget != NULL, "invalid window" );
2983
2984     wxCHECK_RET( m_wxwindow != NULL, "window needs client area for scrolling" );
2985
2986     if (orient == wxHORIZONTAL)
2987     {
2988         float fpos = (float)pos;
2989         if (fpos > m_hAdjust->upper - m_hAdjust->page_size) fpos = m_hAdjust->upper - m_hAdjust->page_size;
2990         if (fpos < 0.0) fpos = 0.0;
2991         m_oldHorizontalPos = fpos;
2992
2993         if (fabs(fpos-m_hAdjust->value) < 0.2) return;
2994         m_hAdjust->value = fpos;
2995     }
2996     else
2997     {
2998         float fpos = (float)pos;
2999         if (fpos > m_vAdjust->upper - m_vAdjust->page_size) fpos = m_vAdjust->upper - m_vAdjust->page_size;
3000         if (fpos < 0.0) fpos = 0.0;
3001         m_oldVerticalPos = fpos;
3002
3003         if (fabs(fpos-m_vAdjust->value) < 0.2) return;
3004         m_vAdjust->value = fpos;
3005     }
3006
3007     if (!m_isScrolling)
3008     {
3009         if (m_wxwindow->window)
3010         {
3011             if (orient == wxHORIZONTAL)
3012                 gtk_signal_emit_by_name( GTK_OBJECT(m_hAdjust), "value_changed" );
3013             else
3014                 gtk_signal_emit_by_name( GTK_OBJECT(m_vAdjust), "value_changed" );
3015         }
3016     }
3017 }
3018
3019 int wxWindow::GetScrollThumb( int orient ) const
3020 {
3021     wxCHECK_MSG( m_widget != NULL, 0, "invalid window" );
3022
3023     wxCHECK_MSG( m_wxwindow != NULL, 0, "window needs client area for scrolling" );
3024
3025     if (orient == wxHORIZONTAL)
3026         return (int)(m_hAdjust->page_size+0.5);
3027     else
3028         return (int)(m_vAdjust->page_size+0.5);
3029 }
3030
3031 int wxWindow::GetScrollPos( int orient ) const
3032 {
3033     wxCHECK_MSG( m_widget != NULL, 0, "invalid window" );
3034
3035     wxCHECK_MSG( m_wxwindow != NULL, 0, "window needs client area for scrolling" );
3036
3037     if (orient == wxHORIZONTAL)
3038         return (int)(m_hAdjust->value+0.5);
3039     else
3040         return (int)(m_vAdjust->value+0.5);
3041 }
3042
3043 int wxWindow::GetScrollRange( int orient ) const
3044 {
3045     wxCHECK_MSG( m_widget != NULL, 0, "invalid window" );
3046
3047     wxCHECK_MSG( m_wxwindow != NULL, 0, "window needs client area for scrolling" );
3048
3049     if (orient == wxHORIZONTAL)
3050         return (int)(m_hAdjust->upper+0.5);
3051     else
3052         return (int)(m_vAdjust->upper+0.5);
3053 }
3054
3055 void wxWindow::ScrollWindow( int dx, int dy, const wxRect* WXUNUSED(rect) )
3056 {
3057     wxCHECK_RET( m_widget != NULL, "invalid window" );
3058
3059     wxCHECK_RET( m_wxwindow != NULL, "window needs client area for scrolling" );
3060
3061     int cw = 0;
3062     int ch = 0;
3063     GetClientSize( &cw, &ch );
3064
3065     int w = cw - abs(dx);
3066     int h = ch - abs(dy);
3067     if ((h < 0) || (w < 0))
3068     {
3069         Refresh();
3070         return;
3071     }
3072     int s_x = 0;
3073     int s_y = 0;
3074     if (dx < 0) s_x = -dx;
3075     if (dy < 0) s_y = -dy;
3076     int d_x = 0;
3077     int d_y = 0;
3078     if (dx > 0) d_x = dx;
3079     if (dy > 0) d_y = dy;
3080
3081     if (!m_scrollGC)
3082     {
3083         m_scrollGC = gdk_gc_new( m_wxwindow->window );
3084         gdk_gc_set_exposures( m_scrollGC, TRUE );
3085     }
3086
3087     gdk_window_copy_area( m_wxwindow->window, m_scrollGC, d_x, d_y,
3088         m_wxwindow->window, s_x, s_y, w, h );
3089
3090     wxRect rect;
3091     if (dx < 0) rect.x = cw+dx; else rect.x = 0;
3092     if (dy < 0) rect.y = ch+dy; else rect.y = 0;
3093     if (dy != 0) rect.width = cw; else rect.width = abs(dx);
3094     if (dx != 0) rect.height = ch; else rect.height = abs(dy);
3095
3096     Refresh( TRUE, &rect );
3097 }
3098
3099 //-------------------------------------------------------------------------------------
3100 //          Layout
3101 //-------------------------------------------------------------------------------------
3102
3103 wxLayoutConstraints *wxWindow::GetConstraints() const
3104 {
3105   return m_constraints;
3106 }
3107
3108 void wxWindow::SetConstraints( wxLayoutConstraints *constraints )
3109 {
3110   if (m_constraints)
3111   {
3112     UnsetConstraints(m_constraints);
3113     delete m_constraints;
3114   }
3115   m_constraints = constraints;
3116   if (m_constraints)
3117   {
3118     // Make sure other windows know they're part of a 'meaningful relationship'
3119     if (m_constraints->left.GetOtherWindow() && (m_constraints->left.GetOtherWindow() != this))
3120       m_constraints->left.GetOtherWindow()->AddConstraintReference((wxWindow *)this);
3121     if (m_constraints->top.GetOtherWindow() && (m_constraints->top.GetOtherWindow() != this))
3122       m_constraints->top.GetOtherWindow()->AddConstraintReference((wxWindow *)this);
3123     if (m_constraints->right.GetOtherWindow() && (m_constraints->right.GetOtherWindow() != this))
3124       m_constraints->right.GetOtherWindow()->AddConstraintReference((wxWindow *)this);
3125     if (m_constraints->bottom.GetOtherWindow() && (m_constraints->bottom.GetOtherWindow() != this))
3126       m_constraints->bottom.GetOtherWindow()->AddConstraintReference((wxWindow *)this);
3127     if (m_constraints->width.GetOtherWindow() && (m_constraints->width.GetOtherWindow() != this))
3128       m_constraints->width.GetOtherWindow()->AddConstraintReference((wxWindow *)this);
3129     if (m_constraints->height.GetOtherWindow() && (m_constraints->height.GetOtherWindow() != this))
3130       m_constraints->height.GetOtherWindow()->AddConstraintReference((wxWindow *)this);
3131     if (m_constraints->centreX.GetOtherWindow() && (m_constraints->centreX.GetOtherWindow() != this))
3132       m_constraints->centreX.GetOtherWindow()->AddConstraintReference((wxWindow *)this);
3133     if (m_constraints->centreY.GetOtherWindow() && (m_constraints->centreY.GetOtherWindow() != this))
3134       m_constraints->centreY.GetOtherWindow()->AddConstraintReference((wxWindow *)this);
3135   }
3136 ;
3137 }
3138 ;
3139
3140 void wxWindow::SetAutoLayout( bool autoLayout )
3141 {
3142   m_autoLayout = autoLayout;
3143 }
3144
3145 bool wxWindow::GetAutoLayout() const
3146 {
3147   return m_autoLayout;
3148 }
3149
3150 wxSizer *wxWindow::GetSizer() const
3151 {
3152   return m_windowSizer;
3153 }
3154
3155 void wxWindow::SetSizerParent( wxWindow *win )
3156 {
3157   m_sizerParent = win;
3158 }
3159
3160 wxWindow *wxWindow::GetSizerParent() const
3161 {
3162   return m_sizerParent;
3163 }
3164
3165 // This removes any dangling pointers to this window
3166 // in other windows' constraintsInvolvedIn lists.
3167 void wxWindow::UnsetConstraints(wxLayoutConstraints *c)
3168 {
3169   if (c)
3170   {
3171     if (c->left.GetOtherWindow() && (c->top.GetOtherWindow() != this))
3172       c->left.GetOtherWindow()->RemoveConstraintReference((wxWindow *)this);
3173     if (c->top.GetOtherWindow() && (c->top.GetOtherWindow() != this))
3174       c->top.GetOtherWindow()->RemoveConstraintReference((wxWindow *)this);
3175     if (c->right.GetOtherWindow() && (c->right.GetOtherWindow() != this))
3176       c->right.GetOtherWindow()->RemoveConstraintReference((wxWindow *)this);
3177     if (c->bottom.GetOtherWindow() && (c->bottom.GetOtherWindow() != this))
3178       c->bottom.GetOtherWindow()->RemoveConstraintReference((wxWindow *)this);
3179     if (c->width.GetOtherWindow() && (c->width.GetOtherWindow() != this))
3180       c->width.GetOtherWindow()->RemoveConstraintReference((wxWindow *)this);
3181     if (c->height.GetOtherWindow() && (c->height.GetOtherWindow() != this))
3182       c->height.GetOtherWindow()->RemoveConstraintReference((wxWindow *)this);
3183     if (c->centreX.GetOtherWindow() && (c->centreX.GetOtherWindow() != this))
3184       c->centreX.GetOtherWindow()->RemoveConstraintReference((wxWindow *)this);
3185     if (c->centreY.GetOtherWindow() && (c->centreY.GetOtherWindow() != this))
3186       c->centreY.GetOtherWindow()->RemoveConstraintReference((wxWindow *)this);
3187   }
3188 }
3189
3190 // Back-pointer to other windows we're involved with, so if we delete
3191 // this window, we must delete any constraints we're involved with.
3192 void wxWindow::AddConstraintReference(wxWindow *otherWin)
3193 {
3194   if (!m_constraintsInvolvedIn)
3195     m_constraintsInvolvedIn = new wxList;
3196   if (!m_constraintsInvolvedIn->Member(otherWin))
3197     m_constraintsInvolvedIn->Append(otherWin);
3198 }
3199
3200 // REMOVE back-pointer to other windows we're involved with.
3201 void wxWindow::RemoveConstraintReference(wxWindow *otherWin)
3202 {
3203   if (m_constraintsInvolvedIn)
3204     m_constraintsInvolvedIn->DeleteObject(otherWin);
3205 }
3206
3207 // Reset any constraints that mention this window
3208 void wxWindow::DeleteRelatedConstraints()
3209 {
3210   if (m_constraintsInvolvedIn)
3211   {
3212     wxNode *node = m_constraintsInvolvedIn->First();
3213     while (node)
3214     {
3215       wxWindow *win = (wxWindow *)node->Data();
3216       wxNode *next = node->Next();
3217       wxLayoutConstraints *constr = win->GetConstraints();
3218
3219       // Reset any constraints involving this window
3220       if (constr)
3221       {
3222         constr->left.ResetIfWin((wxWindow *)this);
3223         constr->top.ResetIfWin((wxWindow *)this);
3224         constr->right.ResetIfWin((wxWindow *)this);
3225         constr->bottom.ResetIfWin((wxWindow *)this);
3226         constr->width.ResetIfWin((wxWindow *)this);
3227         constr->height.ResetIfWin((wxWindow *)this);
3228         constr->centreX.ResetIfWin((wxWindow *)this);
3229         constr->centreY.ResetIfWin((wxWindow *)this);
3230       }
3231       delete node;
3232       node = next;
3233     }
3234     delete m_constraintsInvolvedIn;
3235     m_constraintsInvolvedIn = (wxList *) NULL;
3236   }
3237 }
3238
3239 void wxWindow::SetSizer(wxSizer *sizer)
3240 {
3241   m_windowSizer = sizer;
3242   if (sizer)
3243     sizer->SetSizerParent((wxWindow *)this);
3244 }
3245
3246 /*
3247  * New version
3248  */
3249
3250 bool wxWindow::Layout()
3251 {
3252   if (GetConstraints())
3253   {
3254     int w, h;
3255     GetClientSize(&w, &h);
3256     GetConstraints()->width.SetValue(w);
3257     GetConstraints()->height.SetValue(h);
3258   }
3259
3260   // If top level (one sizer), evaluate the sizer's constraints.
3261   if (GetSizer())
3262   {
3263     int noChanges;
3264     GetSizer()->ResetConstraints();   // Mark all constraints as unevaluated
3265     GetSizer()->LayoutPhase1(&noChanges);
3266     GetSizer()->LayoutPhase2(&noChanges);
3267     GetSizer()->SetConstraintSizes(); // Recursively set the real window sizes
3268     return TRUE;
3269   }
3270   else
3271   {
3272     // Otherwise, evaluate child constraints
3273     ResetConstraints();   // Mark all constraints as unevaluated
3274     DoPhase(1);           // Just one phase need if no sizers involved
3275     DoPhase(2);
3276     SetConstraintSizes(); // Recursively set the real window sizes
3277   }
3278   return TRUE;
3279 }
3280
3281
3282 // Do a phase of evaluating constraints:
3283 // the default behaviour. wxSizers may do a similar
3284 // thing, but also impose their own 'constraints'
3285 // and order the evaluation differently.
3286 bool wxWindow::LayoutPhase1(int *noChanges)
3287 {
3288   wxLayoutConstraints *constr = GetConstraints();
3289   if (constr)
3290   {
3291     return constr->SatisfyConstraints((wxWindow *)this, noChanges);
3292   }
3293   else
3294     return TRUE;
3295 }
3296
3297 bool wxWindow::LayoutPhase2(int *noChanges)
3298 {
3299   *noChanges = 0;
3300
3301   // Layout children
3302   DoPhase(1);
3303   DoPhase(2);
3304   return TRUE;
3305 }
3306
3307 // Do a phase of evaluating child constraints
3308 bool wxWindow::DoPhase(int phase)
3309 {
3310   int noIterations = 0;
3311   int maxIterations = 500;
3312   int noChanges = 1;
3313   int noFailures = 0;
3314   wxList succeeded;
3315   while ((noChanges > 0) && (noIterations < maxIterations))
3316   {
3317     noChanges = 0;
3318     noFailures = 0;
3319     wxNode *node = m_children.First();
3320     while (node)
3321     {
3322       wxWindow *child = (wxWindow *)node->Data();
3323       if (!child->IsKindOf(CLASSINFO(wxFrame)) && !child->IsKindOf(CLASSINFO(wxDialog)))
3324       {
3325         wxLayoutConstraints *constr = child->GetConstraints();
3326         if (constr)
3327         {
3328           if (succeeded.Member(child))
3329           {
3330           }
3331           else
3332           {
3333             int tempNoChanges = 0;
3334             bool success = ( (phase == 1) ? child->LayoutPhase1(&tempNoChanges) : child->LayoutPhase2(&tempNoChanges) ) ;
3335             noChanges += tempNoChanges;
3336             if (success)
3337             {
3338               succeeded.Append(child);
3339             }
3340           }
3341         }
3342       }
3343       node = node->Next();
3344     }
3345     noIterations ++;
3346   }
3347   return TRUE;
3348 }
3349
3350 void wxWindow::ResetConstraints()
3351 {
3352   wxLayoutConstraints *constr = GetConstraints();
3353   if (constr)
3354   {
3355     constr->left.SetDone(FALSE);
3356     constr->top.SetDone(FALSE);
3357     constr->right.SetDone(FALSE);
3358     constr->bottom.SetDone(FALSE);
3359     constr->width.SetDone(FALSE);
3360     constr->height.SetDone(FALSE);
3361     constr->centreX.SetDone(FALSE);
3362     constr->centreY.SetDone(FALSE);
3363   }
3364   wxNode *node = m_children.First();
3365   while (node)
3366   {
3367     wxWindow *win = (wxWindow *)node->Data();
3368     if (!win->IsKindOf(CLASSINFO(wxFrame)) && !win->IsKindOf(CLASSINFO(wxDialog)))
3369       win->ResetConstraints();
3370     node = node->Next();
3371   }
3372 }
3373
3374 // Need to distinguish between setting the 'fake' size for
3375 // windows and sizers, and setting the real values.
3376 void wxWindow::SetConstraintSizes(bool recurse)
3377 {
3378   wxLayoutConstraints *constr = GetConstraints();
3379   if (constr && constr->left.GetDone() && constr->right.GetDone() &&
3380                 constr->width.GetDone() && constr->height.GetDone())
3381   {
3382     int x = constr->left.GetValue();
3383     int y = constr->top.GetValue();
3384     int w = constr->width.GetValue();
3385     int h = constr->height.GetValue();
3386
3387     // If we don't want to resize this window, just move it...
3388     if ((constr->width.GetRelationship() != wxAsIs) ||
3389         (constr->height.GetRelationship() != wxAsIs))
3390     {
3391       // Calls Layout() recursively. AAAGH. How can we stop that.
3392       // Simply take Layout() out of non-top level OnSizes.
3393       SizerSetSize(x, y, w, h);
3394     }
3395     else
3396     {
3397       SizerMove(x, y);
3398     }
3399   }
3400   else if (constr)
3401   {
3402     char *windowClass = this->GetClassInfo()->GetClassName();
3403
3404     wxString winName;
3405   if (GetName() == "")
3406     winName = "unnamed";
3407   else
3408     winName = GetName();
3409     wxLogDebug( "Constraint(s) not satisfied for window of type %s, name %s:\n",
3410                 (const char *)windowClass,
3411                 (const char *)winName);
3412     if (!constr->left.GetDone()) wxLogDebug( "  unsatisfied 'left' constraint.\n" );
3413     if (!constr->right.GetDone()) wxLogDebug( "  unsatisfied 'right' constraint.\n" );
3414     if (!constr->width.GetDone()) wxLogDebug( "  unsatisfied 'width' constraint.\n" );
3415     if (!constr->height.GetDone())  wxLogDebug( "  unsatisfied 'height' constraint.\n" );
3416     wxLogDebug( "Please check constraints: try adding AsIs() constraints.\n" );
3417   }
3418
3419   if (recurse)
3420   {
3421     wxNode *node = m_children.First();
3422     while (node)
3423     {
3424       wxWindow *win = (wxWindow *)node->Data();
3425       if (!win->IsKindOf(CLASSINFO(wxFrame)) && !win->IsKindOf(CLASSINFO(wxDialog)))
3426         win->SetConstraintSizes();
3427       node = node->Next();
3428     }
3429   }
3430 }
3431
3432 // This assumes that all sizers are 'on' the same
3433 // window, i.e. the parent of this window.
3434 void wxWindow::TransformSizerToActual(int *x, int *y) const
3435 {
3436   if (!m_sizerParent || m_sizerParent->IsKindOf(CLASSINFO(wxDialog)) ||
3437          m_sizerParent->IsKindOf(CLASSINFO(wxFrame)) )
3438     return;
3439
3440   int xp, yp;
3441   m_sizerParent->GetPosition(&xp, &yp);
3442   m_sizerParent->TransformSizerToActual(&xp, &yp);
3443   *x += xp;
3444   *y += yp;
3445 }
3446
3447 void wxWindow::SizerSetSize(int x, int y, int w, int h)
3448 {
3449   int xx = x;
3450   int yy = y;
3451   TransformSizerToActual(&xx, &yy);
3452   SetSize(xx, yy, w, h);
3453 }
3454
3455 void wxWindow::SizerMove(int x, int y)
3456 {
3457   int xx = x;
3458   int yy = y;
3459   TransformSizerToActual(&xx, &yy);
3460   Move(xx, yy);
3461 }
3462
3463 // Only set the size/position of the constraint (if any)
3464 void wxWindow::SetSizeConstraint(int x, int y, int w, int h)
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     if (w != -1)
3480     {
3481       constr->width.SetValue(w);
3482       constr->width.SetDone(TRUE);
3483     }
3484     if (h != -1)
3485     {
3486       constr->height.SetValue(h);
3487       constr->height.SetDone(TRUE);
3488     }
3489   }
3490 }
3491
3492 void wxWindow::MoveConstraint(int x, int y)
3493 {
3494   wxLayoutConstraints *constr = GetConstraints();
3495   if (constr)
3496   {
3497     if (x != -1)
3498     {
3499       constr->left.SetValue(x);
3500       constr->left.SetDone(TRUE);
3501     }
3502     if (y != -1)
3503     {
3504       constr->top.SetValue(y);
3505       constr->top.SetDone(TRUE);
3506     }
3507   }
3508 }
3509
3510 void wxWindow::GetSizeConstraint(int *w, int *h) const
3511 {
3512   wxLayoutConstraints *constr = GetConstraints();
3513   if (constr)
3514   {
3515     *w = constr->width.GetValue();
3516     *h = constr->height.GetValue();
3517   }
3518   else
3519     GetSize(w, h);
3520 }
3521
3522 void wxWindow::GetClientSizeConstraint(int *w, int *h) const
3523 {
3524   wxLayoutConstraints *constr = GetConstraints();
3525   if (constr)
3526   {
3527     *w = constr->width.GetValue();
3528     *h = constr->height.GetValue();
3529   }
3530   else
3531     GetClientSize(w, h);
3532 }
3533
3534 void wxWindow::GetPositionConstraint(int *x, int *y) const
3535 {
3536  wxLayoutConstraints *constr = GetConstraints();
3537     if (constr)
3538   {
3539     *x = constr->left.GetValue();
3540     *y = constr->top.GetValue();
3541   }
3542   else
3543     GetPosition(x, y);
3544 }
3545