src/gtk/window.cpp

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