X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/7be4c5946c4d0754cc5bb25e3d2906364df89227..434d2cb3c67c7afc1637e867e47010d13ee8903f:/src/gtk1/window.cpp diff --git a/src/gtk1/window.cpp b/src/gtk1/window.cpp index b2b8e025a8..a84758ad85 100644 --- a/src/gtk1/window.cpp +++ b/src/gtk1/window.cpp @@ -9,7 +9,7 @@ #ifdef __GNUG__ -#pragma implementation "window.h" + #pragma implementation "window.h" #endif #include "wx/defs.h" @@ -21,17 +21,29 @@ #include "wx/utils.h" #include "wx/dialog.h" #include "wx/msgdlg.h" -#include "wx/dcclient.h" -#include "wx/dnd.h" + +#if wxUSE_DRAG_AND_DROP + #include "wx/dnd.h" +#endif + +#if wxUSE_TOOLTIPS + #include "wx/tooltip.h" +#endif + #include "wx/menu.h" #include "wx/statusbr.h" #include "wx/intl.h" #include "wx/settings.h" -#include "gdk/gdkprivate.h" -#include "gdk/gdkkeysyms.h" +#include "wx/log.h" #include +#include "gdk/gdk.h" +#include "gtk/gtk.h" +#include "gdk/gdkprivate.h" +#include "gdk/gdkkeysyms.h" +#include "wx/gtk/win_gtk.h" + //----------------------------------------------------------------------------- // documentation on internals //----------------------------------------------------------------------------- @@ -86,14 +98,14 @@ this is (in most cases) the only GTK widget the class manages. E.g. the wxStatitText class handles only a GtkLabel widget a pointer to which you can find in m_widget (defined in wxWindow) - + When the class has a client area for drawing into and for containing children - it has to handle the client area widget (of the type GtkMyFixed, defined in - win_gtk.c), but there could be any number of widgets, handled by a class - The common rule for all windows is only, that the widget that interacts with - the rest of GTK must be referenced in m_widget and all other widgets must be - children of this widget on the GTK level. The top-most widget, which also - represents the client area, must be in the m_wxwindow field and must be of + it has to handle the client area widget (of the type GtkMyFixed, defined in + win_gtk.c), but there could be any number of widgets, handled by a class + The common rule for all windows is only, that the widget that interacts with + the rest of GTK must be referenced in m_widget and all other widgets must be + children of this widget on the GTK level. The top-most widget, which also + represents the client area, must be in the m_wxwindow field and must be of the type GtkMyFixed. As I said, the window classes that display a GTK native widget only have @@ -109,37 +121,117 @@ */ -//------------------------------------------------------------------------- -// conditional compilation -//------------------------------------------------------------------------- - -#if (GTK_MINOR_VERSION == 1) -#if (GTK_MICRO_VERSION >= 5) -#define NEW_GTK_SCROLL_CODE -#endif -#endif - //----------------------------------------------------------------------------- // data //----------------------------------------------------------------------------- -extern wxList wxPendingDelete; -extern wxList wxTopLevelWindows; -extern bool g_blockEventsOnDrag; -static bool g_capturing = FALSE; +extern wxList wxPendingDelete; +extern bool g_blockEventsOnDrag; +extern bool g_blockEventsOnScroll; +static bool g_capturing = FALSE; +static wxWindow *g_focusWindow = (wxWindow*) NULL; -// hack: we need something to pass to gtk_menu_popup, so we store the time of -// the last click here +/* hack: we need something to pass to gtk_menu_popup, so we store the time of + the last click here */ static guint32 gs_timeLastClick = 0; +#if (GTK_MINOR_VERSION > 0) + +//----------------------------------------------------------------------------- +// local code (see below) +//----------------------------------------------------------------------------- + +static void draw_frame( GtkWidget *widget, wxWindow *win ) +{ + if (!win->HasVMT()) return; + + int dw = 0; + int dh = 0; + + if (win->m_hasScrolling) + { + GtkScrolledWindow *scroll_window = GTK_SCROLLED_WINDOW(widget); + GtkScrolledWindowClass *scroll_class = GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT(widget)->klass ); + +/* + GtkWidget *hscrollbar = scroll_window->hscrollbar; + GtkWidget *vscrollbar = scroll_window->vscrollbar; + + we use this instead: range.slider_width = 11 + 2*2pts edge +*/ + + if (scroll_window->vscrollbar_visible) + { + dw += 15; /* dw += vscrollbar->allocation.width; */ + dw += scroll_class->scrollbar_spacing; + } + + if (scroll_window->hscrollbar_visible) + { + dh += 15; /* dh += hscrollbar->allocation.height; */ + dw += scroll_class->scrollbar_spacing; + } + } + + int dx = 0; + int dy = 0; + if (GTK_WIDGET_NO_WINDOW (widget)) + { + dx += widget->allocation.x; + dy += widget->allocation.y; + } + + if (win->m_windowStyle & wxRAISED_BORDER) + { + gtk_draw_shadow( widget->style, + widget->window, + GTK_STATE_NORMAL, + GTK_SHADOW_OUT, + dx, dy, + win->m_width-dw, win->m_height-dh ); + return; + } + + if (win->m_windowStyle & wxSUNKEN_BORDER) + { + gtk_draw_shadow( widget->style, + widget->window, + GTK_STATE_NORMAL, + GTK_SHADOW_IN, + dx, dy, + win->m_width-dw, win->m_height-dh ); + return; + } +} + +//----------------------------------------------------------------------------- +// "expose_event" of m_widget +//----------------------------------------------------------------------------- + +static void gtk_window_own_expose_callback( GtkWidget *widget, GdkEventExpose *gdk_event, wxWindow *win ) +{ + if (gdk_event->count > 0) return; + draw_frame( widget, win ); +} + +//----------------------------------------------------------------------------- +// "draw" of m_wxwindow +//----------------------------------------------------------------------------- + +static void gtk_window_own_draw_callback( GtkWidget *widget, GdkRectangle *WXUNUSED(rect), wxWindow *win ) +{ + draw_frame( widget, win ); +} + +#endif + //----------------------------------------------------------------------------- -// "expose_event" (of m_wxwindow, not of m_widget) +// "expose_event" of m_wxwindow //----------------------------------------------------------------------------- static void gtk_window_expose_callback( GtkWidget *WXUNUSED(widget), GdkEventExpose *gdk_event, wxWindow *win ) { if (!win->HasVMT()) return; - if (g_blockEventsOnDrag) return; win->m_updateRegion.Union( gdk_event->area.x, gdk_event->area.y, @@ -163,13 +255,12 @@ static void gtk_window_expose_callback( GtkWidget *WXUNUSED(widget), GdkEventExp } //----------------------------------------------------------------------------- -// "draw" (of m_wxwindow, not of m_widget) +// "draw" of m_wxwindow //----------------------------------------------------------------------------- static void gtk_window_draw_callback( GtkWidget *WXUNUSED(widget), GdkRectangle *rect, wxWindow *win ) { if (!win->HasVMT()) return; - if (g_blockEventsOnDrag) return; win->m_updateRegion.Union( rect->x, rect->y, rect->width, rect->height ); @@ -181,7 +272,7 @@ static void gtk_window_draw_callback( GtkWidget *WXUNUSED(widget), GdkRectangle } //----------------------------------------------------------------------------- -// "key_press_event" +// "key_press_event" from any window //----------------------------------------------------------------------------- static gint gtk_window_key_press_callback( GtkWidget *widget, GdkEventKey *gdk_event, wxWindow *win ) @@ -200,6 +291,8 @@ static gint gtk_window_key_press_callback( GtkWidget *widget, GdkEventKey *gdk_e switch (gdk_event->keyval) { case GDK_BackSpace: key_code = WXK_BACK; break; + case GDK_ISO_Left_Tab: + case GDK_KP_Tab: case GDK_Tab: key_code = WXK_TAB; break; case GDK_Linefeed: key_code = WXK_RETURN; break; case GDK_Clear: key_code = WXK_CLEAR; break; @@ -224,7 +317,6 @@ static gint gtk_window_key_press_callback( GtkWidget *widget, GdkEventKey *gdk_e case GDK_Execute: key_code = WXK_EXECUTE; break; case GDK_Insert: key_code = WXK_INSERT; break; case GDK_Num_Lock: key_code = WXK_NUMLOCK; break; - case GDK_KP_Tab: key_code = WXK_TAB; break; case GDK_KP_Enter: key_code = WXK_RETURN; break; case GDK_KP_Home: key_code = WXK_HOME; break; case GDK_KP_Left: key_code = WXK_LEFT; break; @@ -276,7 +368,7 @@ static gint gtk_window_key_press_callback( GtkWidget *widget, GdkEventKey *gdk_e if (!key_code) return FALSE; - wxKeyEvent event( wxEVT_CHAR ); + wxKeyEvent event( wxEVT_KEY_DOWN ); event.m_shiftDown = (gdk_event->state & GDK_SHIFT_MASK); event.m_controlDown = (gdk_event->state & GDK_CONTROL_MASK); event.m_altDown = (gdk_event->state & GDK_MOD1_MASK); @@ -304,13 +396,174 @@ static gint gtk_window_key_press_callback( GtkWidget *widget, GdkEventKey *gdk_e } } + // win is a control: tab can be propagated up + if ( (!ret) && + ((gdk_event->keyval == GDK_Tab) || (gdk_event->keyval == GDK_ISO_Left_Tab)) && + ((win->m_windowStyle & wxTE_PROCESS_TAB) == 0)) + { + wxNavigationKeyEvent new_event; + /* GDK reports GDK_ISO_Left_Tab for SHIFT-TAB */ + new_event.SetDirection( (gdk_event->keyval == GDK_Tab) ); + /* CTRL-TAB changes the (parent) window, i.e. switch notebook page */ + new_event.SetWindowChange( (gdk_event->state & GDK_CONTROL_MASK) ); + new_event.SetCurrentFocus( win ); + ret = win->GetEventHandler()->ProcessEvent( new_event ); + } + + if ( (!ret) && + (gdk_event->keyval == GDK_Escape) ) + { + wxCommandEvent new_event(wxEVT_COMMAND_BUTTON_CLICKED,wxID_CANCEL); + new_event.SetEventObject( win ); + ret = win->GetEventHandler()->ProcessEvent( new_event ); + } + +/* + Damn, I forgot why this didn't work, but it didn't work. + + // win is a panel: up can be propagated to the panel + if ((!ret) && (win->m_wxwindow) && (win->m_parent) && (win->m_parent->AcceptsFocus()) && + (gdk_event->keyval == GDK_Up)) + { + win->m_parent->SetFocus(); + ret = TRUE; + } + + // win is a panel: left/right can be propagated to the panel + if ((!ret) && (win->m_wxwindow) && + ((gdk_event->keyval == GDK_Right) || (gdk_event->keyval == GDK_Left) || + (gdk_event->keyval == GDK_Up) || (gdk_event->keyval == GDK_Down))) + { + wxNavigationKeyEvent new_event; + new_event.SetDirection( (gdk_event->keyval == GDK_Right) || (gdk_event->keyval == GDK_Down) ); + new_event.SetCurrentFocus( win ); + ret = win->GetEventHandler()->ProcessEvent( new_event ); + } +*/ + if (ret) { - if ((gdk_event->keyval >= 0x20) && (gdk_event->keyval <= 0xFF)) - gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "key_press_event" ); + gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "key_press_event" ); + return TRUE; + } + + return FALSE; +} + +//----------------------------------------------------------------------------- +// "key_release_event" from any window +//----------------------------------------------------------------------------- + +static gint gtk_window_key_release_callback( GtkWidget *widget, GdkEventKey *gdk_event, wxWindow *win ) +{ + if (!win->HasVMT()) return FALSE; + if (g_blockEventsOnDrag) return FALSE; + +/* + printf( "OnKeyRelease from " ); + if (win->GetClassInfo() && win->GetClassInfo()->GetClassName()) + printf( win->GetClassInfo()->GetClassName() ); + printf( ".\n" ); +*/ + + long key_code = 0; + switch (gdk_event->keyval) + { + case GDK_BackSpace: key_code = WXK_BACK; break; + case GDK_ISO_Left_Tab: + case GDK_KP_Tab: + case GDK_Tab: key_code = WXK_TAB; break; + case GDK_Linefeed: key_code = WXK_RETURN; break; + case GDK_Clear: key_code = WXK_CLEAR; break; + case GDK_Return: key_code = WXK_RETURN; break; + case GDK_Pause: key_code = WXK_PAUSE; break; + case GDK_Scroll_Lock: key_code = WXK_SCROLL; break; + case GDK_Escape: key_code = WXK_ESCAPE; break; + case GDK_Delete: key_code = WXK_DELETE; break; + case GDK_Home: key_code = WXK_HOME; break; + case GDK_Left: key_code = WXK_LEFT; break; + case GDK_Up: key_code = WXK_UP; break; + case GDK_Right: key_code = WXK_RIGHT; break; + case GDK_Down: key_code = WXK_DOWN; break; + case GDK_Prior: key_code = WXK_PRIOR; break; +// case GDK_Page_Up: key_code = WXK_PAGEUP; break; + case GDK_Next: key_code = WXK_NEXT; break; +// case GDK_Page_Down: key_code = WXK_PAGEDOWN; break; + case GDK_End: key_code = WXK_END; break; + case GDK_Begin: key_code = WXK_HOME; break; + case GDK_Select: key_code = WXK_SELECT; break; + case GDK_Print: key_code = WXK_PRINT; break; + case GDK_Execute: key_code = WXK_EXECUTE; break; + case GDK_Insert: key_code = WXK_INSERT; break; + case GDK_Num_Lock: key_code = WXK_NUMLOCK; break; + case GDK_KP_Enter: key_code = WXK_RETURN; break; + case GDK_KP_Home: key_code = WXK_HOME; break; + case GDK_KP_Left: key_code = WXK_LEFT; break; + case GDK_KP_Up: key_code = WXK_UP; break; + case GDK_KP_Right: key_code = WXK_RIGHT; break; + case GDK_KP_Down: key_code = WXK_DOWN; break; + case GDK_KP_Prior: key_code = WXK_PRIOR; break; +// case GDK_KP_Page_Up: key_code = WXK_PAGEUP; break; + case GDK_KP_Next: key_code = WXK_NEXT; break; +// case GDK_KP_Page_Down: key_code = WXK_PAGEDOWN; break; + case GDK_KP_End: key_code = WXK_END; break; + case GDK_KP_Begin: key_code = WXK_HOME; break; + case GDK_KP_Insert: key_code = WXK_INSERT; break; + case GDK_KP_Delete: key_code = WXK_DELETE; break; + case GDK_KP_Multiply: key_code = WXK_MULTIPLY; break; + case GDK_KP_Add: key_code = WXK_ADD; break; + case GDK_KP_Separator: key_code = WXK_SEPARATOR; break; + case GDK_KP_Subtract: key_code = WXK_SUBTRACT; break; + case GDK_KP_Decimal: key_code = WXK_DECIMAL; break; + case GDK_KP_Divide: key_code = WXK_DIVIDE; break; + case GDK_KP_0: key_code = WXK_NUMPAD0; break; + case GDK_KP_1: key_code = WXK_NUMPAD1; break; + case GDK_KP_2: key_code = WXK_NUMPAD2; break; + case GDK_KP_3: key_code = WXK_NUMPAD3; break; + case GDK_KP_4: key_code = WXK_NUMPAD4; break; + case GDK_KP_5: key_code = WXK_NUMPAD5; break; + case GDK_KP_6: key_code = WXK_NUMPAD6; break; + case GDK_KP_7: key_code = WXK_NUMPAD7; break; + case GDK_KP_8: key_code = WXK_NUMPAD7; break; + case GDK_KP_9: key_code = WXK_NUMPAD9; break; + case GDK_F1: key_code = WXK_F1; break; + case GDK_F2: key_code = WXK_F2; break; + case GDK_F3: key_code = WXK_F3; break; + case GDK_F4: key_code = WXK_F4; break; + case GDK_F5: key_code = WXK_F5; break; + case GDK_F6: key_code = WXK_F6; break; + case GDK_F7: key_code = WXK_F7; break; + case GDK_F8: key_code = WXK_F8; break; + case GDK_F9: key_code = WXK_F9; break; + case GDK_F10: key_code = WXK_F10; break; + case GDK_F11: key_code = WXK_F11; break; + case GDK_F12: key_code = WXK_F12; break; + default: + { + if ((gdk_event->keyval >= 0x20) && (gdk_event->keyval <= 0xFF)) + key_code = gdk_event->keyval; + } + } + + if (!key_code) return FALSE; + + wxKeyEvent event( wxEVT_KEY_UP ); + event.m_shiftDown = (gdk_event->state & GDK_SHIFT_MASK); + event.m_controlDown = (gdk_event->state & GDK_CONTROL_MASK); + event.m_altDown = (gdk_event->state & GDK_MOD1_MASK); + event.m_metaDown = (gdk_event->state & GDK_MOD2_MASK); + event.m_keyCode = key_code; + event.m_x = 0; + event.m_y = 0; + event.SetEventObject( win ); + + if (win->GetEventHandler()->ProcessEvent( event )) + { + gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "key_release_event" ); + return TRUE; } - return ret; + return FALSE; } //----------------------------------------------------------------------------- @@ -319,9 +572,11 @@ static gint gtk_window_key_press_callback( GtkWidget *widget, GdkEventKey *gdk_e static gint gtk_window_button_press_callback( GtkWidget *widget, GdkEventButton *gdk_event, wxWindow *win ) { - if (!win->IsOwnGtkWindow( gdk_event->window )) return TRUE; - + if (!win->HasVMT()) return FALSE; if (g_blockEventsOnDrag) return TRUE; + if (g_blockEventsOnScroll) return TRUE; + + if (!win->IsOwnGtkWindow( gdk_event->window )) return FALSE; if (win->m_wxwindow) { @@ -339,8 +594,6 @@ static gint gtk_window_button_press_callback( GtkWidget *widget, GdkEventButton } } - if (!win->HasVMT()) return TRUE; - /* printf( "OnButtonPress from " ); if (win->GetClassInfo() && win->GetClassInfo()->GetClassName()) @@ -395,19 +648,50 @@ static gint gtk_window_button_press_callback( GtkWidget *widget, GdkEventButton if (!g_capturing) { - wxNode *node = win->GetChildren()->First(); + wxNode *node = win->GetChildren().First(); while (node) { wxWindow *child = (wxWindow*)node->Data(); - if ((child->m_x <= event.m_x) && - (child->m_y <= event.m_y) && - (child->m_x+child->m_width >= event.m_x) && - (child->m_y+child->m_height >= event.m_y)) + + if (child->m_isStaticBox) { - win = child; - event.m_x -= child->m_x; - event.m_y -= child->m_y; - break; + // wxStaticBox is transparent in the box itself + int x = event.m_x; + int y = event.m_y; + int xx1 = child->m_x; + int yy1 = child->m_y; + int xx2 = child->m_x + child->m_width; + int yy2 = child->m_x + child->m_height; + + // left + if (((x >= xx1) && (x <= xx1+10) && (y >= yy1) && (y <= yy2)) || + // right + ((x >= xx2-10) && (x <= xx2) && (y >= yy1) && (y <= yy2)) || + // top + ((x >= xx1) && (x <= xx2) && (y >= yy1) && (y <= yy1+10)) || + // bottom + ((x >= xx1) && (x <= xx2) && (y >= yy2-1) && (y <= yy2))) + { + win = child; + event.m_x -= child->m_x; + event.m_y -= child->m_y; + break; + } + + } + else + { + if ((child->m_wxwindow == (GtkWidget*) NULL) && + (child->m_x <= event.m_x) && + (child->m_y <= event.m_y) && + (child->m_x+child->m_width >= event.m_x) && + (child->m_y+child->m_height >= event.m_y)) + { + win = child; + event.m_x -= child->m_x; + event.m_y -= child->m_y; + break; + } } node = node->Next(); } @@ -418,9 +702,12 @@ static gint gtk_window_button_press_callback( GtkWidget *widget, GdkEventButton gs_timeLastClick = gdk_event->time; if (win->GetEventHandler()->ProcessEvent( event )) + { gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "button_press_event" ); + return TRUE; + } - return TRUE; + return FALSE; } //----------------------------------------------------------------------------- @@ -429,11 +716,11 @@ static gint gtk_window_button_press_callback( GtkWidget *widget, GdkEventButton static gint gtk_window_button_release_callback( GtkWidget *widget, GdkEventButton *gdk_event, wxWindow *win ) { - if (!win->IsOwnGtkWindow( gdk_event->window )) return TRUE; - - if (g_blockEventsOnDrag) return TRUE; + if (!win->HasVMT()) return FALSE; + if (g_blockEventsOnDrag) return FALSE; + if (g_blockEventsOnScroll) return FALSE; - if (!win->HasVMT()) return TRUE; + if (!win->IsOwnGtkWindow( gdk_event->window )) return FALSE; /* printf( "OnButtonRelease from " ); @@ -467,19 +754,50 @@ static gint gtk_window_button_release_callback( GtkWidget *widget, GdkEventButto if (!g_capturing) { - wxNode *node = win->GetChildren()->First(); + wxNode *node = win->GetChildren().First(); while (node) { wxWindow *child = (wxWindow*)node->Data(); - if ((child->m_x <= event.m_x) && - (child->m_y <= event.m_y) && - (child->m_x+child->m_width >= event.m_x) && - (child->m_y+child->m_height >= event.m_y)) + + if (child->m_isStaticBox) { - win = child; - event.m_x -= child->m_x; - event.m_y -= child->m_y; - break; + // wxStaticBox is transparent in the box itself + int x = event.m_x; + int y = event.m_y; + int xx1 = child->m_x; + int yy1 = child->m_y; + int xx2 = child->m_x + child->m_width; + int yy2 = child->m_x + child->m_height; + + // left + if (((x >= xx1) && (x <= xx1+10) && (y >= yy1) && (y <= yy2)) || + // right + ((x >= xx2-10) && (x <= xx2) && (y >= yy1) && (y <= yy2)) || + // top + ((x >= xx1) && (x <= xx2) && (y >= yy1) && (y <= yy1+10)) || + // bottom + ((x >= xx1) && (x <= xx2) && (y >= yy2-1) && (y <= yy2))) + { + win = child; + event.m_x -= child->m_x; + event.m_y -= child->m_y; + break; + } + + } + else + { + if ((child->m_wxwindow == (GtkWidget*) NULL) && + (child->m_x <= event.m_x) && + (child->m_y <= event.m_y) && + (child->m_x+child->m_width >= event.m_x) && + (child->m_y+child->m_height >= event.m_y)) + { + win = child; + event.m_x -= child->m_x; + event.m_y -= child->m_y; + break; + } } node = node->Next(); } @@ -488,9 +806,12 @@ static gint gtk_window_button_release_callback( GtkWidget *widget, GdkEventButto event.SetEventObject( win ); if (win->GetEventHandler()->ProcessEvent( event )) + { gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "button_release_event" ); + return TRUE; + } - return TRUE; + return FALSE; } //----------------------------------------------------------------------------- @@ -499,11 +820,22 @@ static gint gtk_window_button_release_callback( GtkWidget *widget, GdkEventButto static gint gtk_window_motion_notify_callback( GtkWidget *widget, GdkEventMotion *gdk_event, wxWindow *win ) { - if (!win->IsOwnGtkWindow( gdk_event->window )) return TRUE; + if (!win->HasVMT()) return FALSE; + if (g_blockEventsOnDrag) return FALSE; + if (g_blockEventsOnScroll) return FALSE; - if (g_blockEventsOnDrag) return TRUE; + if (!win->IsOwnGtkWindow( gdk_event->window )) return FALSE; - if (!win->HasVMT()) return TRUE; + if (gdk_event->is_hint) + { + int x = 0; + int y = 0; + GdkModifierType state; + gdk_window_get_pointer(gdk_event->window, &x, &y, &state); + gdk_event->x = x; + gdk_event->y = y; + gdk_event->state = state; + } /* printf( "OnMotion from " ); @@ -529,19 +861,50 @@ static gint gtk_window_motion_notify_callback( GtkWidget *widget, GdkEventMotion if (!g_capturing) { - wxNode *node = win->GetChildren()->First(); + wxNode *node = win->GetChildren().First(); while (node) { wxWindow *child = (wxWindow*)node->Data(); - if ((child->m_x <= event.m_x) && - (child->m_y <= event.m_y) && - (child->m_x+child->m_width >= event.m_x) && - (child->m_y+child->m_height >= event.m_y)) + + if (child->m_isStaticBox) { - win = child; - event.m_x -= child->m_x; - event.m_y -= child->m_y; - break; + // wxStaticBox is transparent in the box itself + int x = event.m_x; + int y = event.m_y; + int xx1 = child->m_x; + int yy1 = child->m_y; + int xx2 = child->m_x + child->m_width; + int yy2 = child->m_x + child->m_height; + + // left + if (((x >= xx1) && (x <= xx1+10) && (y >= yy1) && (y <= yy2)) || + // right + ((x >= xx2-10) && (x <= xx2) && (y >= yy1) && (y <= yy2)) || + // top + ((x >= xx1) && (x <= xx2) && (y >= yy1) && (y <= yy1+10)) || + // bottom + ((x >= xx1) && (x <= xx2) && (y >= yy2-1) && (y <= yy2))) + { + win = child; + event.m_x -= child->m_x; + event.m_y -= child->m_y; + break; + } + + } + else + { + if ((child->m_wxwindow == (GtkWidget*) NULL) && + (child->m_x <= event.m_x) && + (child->m_y <= event.m_y) && + (child->m_x+child->m_width >= event.m_x) && + (child->m_y+child->m_height >= event.m_y)) + { + win = child; + event.m_x -= child->m_x; + event.m_y -= child->m_y; + break; + } } node = node->Next(); } @@ -550,9 +913,12 @@ static gint gtk_window_motion_notify_callback( GtkWidget *widget, GdkEventMotion event.SetEventObject( win ); if (win->GetEventHandler()->ProcessEvent( event )) + { gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "motion_notify_event" ); + return TRUE; + } - return TRUE; + return FALSE; } //----------------------------------------------------------------------------- @@ -561,7 +927,11 @@ static gint gtk_window_motion_notify_callback( GtkWidget *widget, GdkEventMotion static gint gtk_window_focus_in_callback( GtkWidget *widget, GdkEvent *WXUNUSED(event), wxWindow *win ) { - if (g_blockEventsOnDrag) return TRUE; + if (!win->HasVMT()) return FALSE; + if (g_blockEventsOnDrag) return FALSE; + + g_focusWindow = win; + if (win->m_wxwindow) { if (GTK_WIDGET_CAN_FOCUS(win->m_wxwindow)) @@ -576,7 +946,6 @@ static gint gtk_window_focus_in_callback( GtkWidget *widget, GdkEvent *WXUNUSED( } } - if (!win->HasVMT()) return TRUE; /* printf( "OnSetFocus from " ); @@ -591,9 +960,12 @@ static gint gtk_window_focus_in_callback( GtkWidget *widget, GdkEvent *WXUNUSED( event.SetEventObject( win ); if (win->GetEventHandler()->ProcessEvent( event )) + { gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "focus_in_event" ); - - return TRUE; + return TRUE; + } + + return FALSE; } //----------------------------------------------------------------------------- @@ -602,15 +974,15 @@ static gint gtk_window_focus_in_callback( GtkWidget *widget, GdkEvent *WXUNUSED( static gint gtk_window_focus_out_callback( GtkWidget *widget, GdkEvent *WXUNUSED(event), wxWindow *win ) { - if (g_blockEventsOnDrag) return TRUE; + if (!win->HasVMT()) return FALSE; + if (g_blockEventsOnDrag) return FALSE; + if (win->m_wxwindow) { if (GTK_WIDGET_CAN_FOCUS(win->m_wxwindow)) GTK_WIDGET_UNSET_FLAGS (win->m_wxwindow, GTK_HAS_FOCUS); } - if (!win->HasVMT()) return TRUE; - /* printf( "OnKillFocus from " ); if (win->GetClassInfo() && win->GetClassInfo()->GetClassName()) @@ -622,9 +994,12 @@ static gint gtk_window_focus_out_callback( GtkWidget *widget, GdkEvent *WXUNUSED event.SetEventObject( win ); if (win->GetEventHandler()->ProcessEvent( event )) + { gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "focus_out_event" ); - - return TRUE; + return TRUE; + } + + return FALSE; } //----------------------------------------------------------------------------- @@ -633,11 +1008,13 @@ static gint gtk_window_focus_out_callback( GtkWidget *widget, GdkEvent *WXUNUSED static gint gtk_window_enter_callback( GtkWidget *widget, GdkEventCrossing *gdk_event, wxWindow *win ) { - if (widget->window != gdk_event->window) return TRUE; - - if (g_blockEventsOnDrag) return TRUE; + if (!win->HasVMT()) return FALSE; + if (g_blockEventsOnDrag) return FALSE; + + if (widget->window != gdk_event->window) return FALSE; - if (!win->HasVMT()) return TRUE; + if ((widget->window) && (win->m_cursor)) + gdk_window_set_cursor( widget->window, win->m_cursor->GetCursor() ); /* printf( "OnEnter from " ); @@ -646,16 +1023,33 @@ static gint gtk_window_enter_callback( GtkWidget *widget, GdkEventCrossing *gdk_ printf( ".\n" ); */ - if ((widget->window) && (win->m_cursor)) - gdk_window_set_cursor( widget->window, win->m_cursor->GetCursor() ); - wxMouseEvent event( wxEVT_ENTER_WINDOW ); event.SetEventObject( win ); + int x = 0; + int y = 0; + GdkModifierType state = (GdkModifierType)0; + + gdk_window_get_pointer( widget->window, &x, &y, &state ); + + event.m_shiftDown = (state & GDK_SHIFT_MASK); + event.m_controlDown = (state & GDK_CONTROL_MASK); + event.m_altDown = (state & GDK_MOD1_MASK); + event.m_metaDown = (state & GDK_MOD2_MASK); + event.m_leftDown = (state & GDK_BUTTON1_MASK); + event.m_middleDown = (state & GDK_BUTTON2_MASK); + event.m_rightDown = (state & GDK_BUTTON3_MASK); + + event.m_x = (long)x; + event.m_y = (long)y; + if (win->GetEventHandler()->ProcessEvent( event )) + { gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "enter_notify_event" ); - - return TRUE; + return TRUE; + } + + return FALSE; } //----------------------------------------------------------------------------- @@ -664,11 +1058,13 @@ static gint gtk_window_enter_callback( GtkWidget *widget, GdkEventCrossing *gdk_ static gint gtk_window_leave_callback( GtkWidget *widget, GdkEventCrossing *gdk_event, wxWindow *win ) { - if (widget->window != gdk_event->window) return TRUE; - - if (g_blockEventsOnDrag) return TRUE; + if (!win->HasVMT()) return FALSE; + if (g_blockEventsOnDrag) return FALSE; - if (!win->HasVMT()) return TRUE; + if (widget->window != gdk_event->window) return FALSE; + + if ((widget->window) && (win->m_cursor)) + gdk_window_set_cursor( widget->window, wxSTANDARD_CURSOR->GetCursor() ); /* printf( "OnLeave from " ); @@ -677,16 +1073,33 @@ static gint gtk_window_leave_callback( GtkWidget *widget, GdkEventCrossing *gdk_ printf( ".\n" ); */ - if ((widget->window) && (win->m_cursor)) - gdk_window_set_cursor( widget->window, wxSTANDARD_CURSOR->GetCursor() ); - wxMouseEvent event( wxEVT_LEAVE_WINDOW ); event.SetEventObject( win ); + int x = 0; + int y = 0; + GdkModifierType state = (GdkModifierType)0; + + gdk_window_get_pointer( widget->window, &x, &y, &state ); + + event.m_shiftDown = (state & GDK_SHIFT_MASK); + event.m_controlDown = (state & GDK_CONTROL_MASK); + event.m_altDown = (state & GDK_MOD1_MASK); + event.m_metaDown = (state & GDK_MOD2_MASK); + event.m_leftDown = (state & GDK_BUTTON1_MASK); + event.m_middleDown = (state & GDK_BUTTON2_MASK); + event.m_rightDown = (state & GDK_BUTTON3_MASK); + + event.m_x = (long)x; + event.m_y = (long)y; + if (win->GetEventHandler()->ProcessEvent( event )) + { gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "leave_notify_event" ); - - return TRUE; + return TRUE; + } + + return FALSE; } //----------------------------------------------------------------------------- @@ -708,19 +1121,27 @@ static void gtk_window_vscroll_callback( GtkWidget *WXUNUSED(widget), wxWindow * float diff = win->m_vAdjust->value - win->m_oldVerticalPos; if (fabs(diff) < 0.2) return; + win->m_oldVerticalPos = win->m_vAdjust->value; wxEventType command = wxEVT_NULL; float line_step = win->m_vAdjust->step_increment; float page_step = win->m_vAdjust->page_increment; - if (fabs(win->m_vAdjust->value-win->m_vAdjust->lower) < 0.2) command = wxEVT_SCROLL_BOTTOM; - else if (fabs(win->m_vAdjust->value-win->m_vAdjust->upper) < 0.2) command = wxEVT_SCROLL_TOP; - else if (fabs(diff-line_step) < 0.2) command = wxEVT_SCROLL_LINEDOWN; - else if (fabs(diff+line_step) < 0.2) command = wxEVT_SCROLL_LINEUP; - else if (fabs(diff-page_step) < 0.2) command = wxEVT_SCROLL_PAGEDOWN; - else if (fabs(diff+page_step) < 0.2) command = wxEVT_SCROLL_PAGEUP; - else command = wxEVT_SCROLL_THUMBTRACK; + if (win->m_isScrolling) + { + command = wxEVT_SCROLL_THUMBTRACK; + } + else + { + if (fabs(win->m_vAdjust->value-win->m_vAdjust->lower) < 0.2) command = wxEVT_SCROLL_BOTTOM; + else if (fabs(win->m_vAdjust->value-win->m_vAdjust->upper) < 0.2) command = wxEVT_SCROLL_TOP; + else if (fabs(diff-line_step) < 0.2) command = wxEVT_SCROLL_LINEDOWN; + else if (fabs(diff+line_step) < 0.2) command = wxEVT_SCROLL_LINEUP; + else if (fabs(diff-page_step) < 0.2) command = wxEVT_SCROLL_PAGEDOWN; + else if (fabs(diff+page_step) < 0.2) command = wxEVT_SCROLL_PAGEUP; + else command = wxEVT_SCROLL_THUMBTRACK; + } int value = (int)(win->m_vAdjust->value+0.5); @@ -748,19 +1169,27 @@ static void gtk_window_hscroll_callback( GtkWidget *WXUNUSED(widget), wxWindow * float diff = win->m_hAdjust->value - win->m_oldHorizontalPos; if (fabs(diff) < 0.2) return; + win->m_oldHorizontalPos = win->m_hAdjust->value; wxEventType command = wxEVT_NULL; float line_step = win->m_hAdjust->step_increment; float page_step = win->m_hAdjust->page_increment; - - if (fabs(win->m_hAdjust->value-win->m_hAdjust->lower) < 0.2) command = wxEVT_SCROLL_BOTTOM; - else if (fabs(win->m_hAdjust->value-win->m_hAdjust->upper) < 0.2) command = wxEVT_SCROLL_TOP; - else if (fabs(diff-line_step) < 0.2) command = wxEVT_SCROLL_LINEDOWN; - else if (fabs(diff+line_step) < 0.2) command = wxEVT_SCROLL_LINEUP; - else if (fabs(diff-page_step) < 0.2) command = wxEVT_SCROLL_PAGEDOWN; - else if (fabs(diff+page_step) < 0.2) command = wxEVT_SCROLL_PAGEUP; - else command = wxEVT_SCROLL_THUMBTRACK; + + if (win->m_isScrolling) + { + command = wxEVT_SCROLL_THUMBTRACK; + } + else + { + if (fabs(win->m_hAdjust->value-win->m_hAdjust->lower) < 0.2) command = wxEVT_SCROLL_BOTTOM; + else if (fabs(win->m_hAdjust->value-win->m_hAdjust->upper) < 0.2) command = wxEVT_SCROLL_TOP; + else if (fabs(diff-line_step) < 0.2) command = wxEVT_SCROLL_LINEDOWN; + else if (fabs(diff+line_step) < 0.2) command = wxEVT_SCROLL_LINEUP; + else if (fabs(diff-page_step) < 0.2) command = wxEVT_SCROLL_PAGEDOWN; + else if (fabs(diff+page_step) < 0.2) command = wxEVT_SCROLL_PAGEUP; + else command = wxEVT_SCROLL_THUMBTRACK; + } int value = (int)(win->m_hAdjust->value+0.5); @@ -823,11 +1252,17 @@ static void gtk_window_hscroll_change_callback( GtkWidget *WXUNUSED(widget), wxW // "button_press_event" from scrollbar //----------------------------------------------------------------------------- -static gint gtk_scrollbar_button_press_callback( GtkRange *widget, GdkEventButton *gdk_event, wxWindow *win ) +static gint gtk_scrollbar_button_press_callback( GtkRange *WXUNUSED(widget), + GdkEventButton *WXUNUSED(gdk_event), + wxWindow *win ) { - if (gdk_event->window != widget->slider) return FALSE; +// don't test here as we can release the mouse while being over +// a different window then the slider +// +// if (gdk_event->window != widget->slider) return FALSE; win->m_isScrolling = TRUE; + g_blockEventsOnScroll = TRUE; return FALSE; } @@ -836,9 +1271,15 @@ static gint gtk_scrollbar_button_press_callback( GtkRange *widget, GdkEventButto // "button_release_event" from scrollbar //----------------------------------------------------------------------------- -static gint gtk_scrollbar_button_release_callback( GtkRange *widget, GdkEventButton *gdk_event, wxWindow *win ) +static gint gtk_scrollbar_button_release_callback( GtkRange *widget, + GdkEventButton *WXUNUSED(gdk_event), + wxWindow *win ) { - if (gdk_event->window != widget->slider) return FALSE; + +// don't test here as we can release the mouse while being over +// a different window then the slider +// +// if (gdk_event->window != widget->slider) return FALSE; GtkScrolledWindow *s_window = GTK_SCROLLED_WINDOW(win->m_widget); @@ -848,6 +1289,7 @@ static gint gtk_scrollbar_button_release_callback( GtkRange *widget, GdkEventBut gtk_signal_emit_by_name( GTK_OBJECT(win->m_vAdjust), "value_changed" ); win->m_isScrolling = FALSE; + g_blockEventsOnScroll = FALSE; return FALSE; } @@ -856,23 +1298,39 @@ static gint gtk_scrollbar_button_release_callback( GtkRange *widget, GdkEventBut // InsertChild for wxWindow. //----------------------------------------------------------------------------- -// Callback for wxWindow. This very strange beast has to be used because -// C++ has no virtual methods in a constructor. We have to emulate a -// virtual function here as wxNotebook requires a different way to insert -// a child in it. I had opted for creating a wxNotebookPage window class -// which would have made this superflouus (such in the MDI window system), -// but no-one is listening to me... +/* Callback for wxWindow. This very strange beast has to be used because + * C++ has no virtual methods in a constructor. We have to emulate a + * virtual function here as wxNotebook requires a different way to insert + * a child in it. I had opted for creating a wxNotebookPage window class + * which would have made this superfluous (such in the MDI window system), + * but no-one was listening to me... */ static void wxInsertChildInWindow( wxWindow* parent, wxWindow* child ) { - gtk_myfixed_put( GTK_MYFIXED(parent->m_wxwindow), - GTK_WIDGET(child->m_widget), - child->m_x, - child->m_y ); + gtk_myfixed_put( GTK_MYFIXED(parent->m_wxwindow), + GTK_WIDGET(child->m_widget), + child->m_x, + child->m_y ); - gtk_widget_set_usize( GTK_WIDGET(child->m_widget), - child->m_width, - child->m_height ); + gtk_widget_set_usize( GTK_WIDGET(child->m_widget), + child->m_width, + child->m_height ); + + if (parent->m_windowStyle & wxTAB_TRAVERSAL) + { + /* we now allow a window to get the focus as long as it + doesn't have any children. */ + GTK_WIDGET_UNSET_FLAGS( parent->m_wxwindow, GTK_CAN_FOCUS ); + } +} + +//----------------------------------------------------------------------------- +// global functions +//----------------------------------------------------------------------------- + +wxWindow* wxGetActiveWindow() +{ + return g_focusWindow; } //----------------------------------------------------------------------------- @@ -885,16 +1343,18 @@ BEGIN_EVENT_TABLE(wxWindow, wxEvtHandler) EVT_SIZE(wxWindow::OnSize) EVT_SYS_COLOUR_CHANGED(wxWindow::OnSysColourChanged) EVT_INIT_DIALOG(wxWindow::OnInitDialog) - EVT_IDLE(wxWindow::OnIdle) + EVT_KEY_DOWN(wxWindow::OnKeyDown) END_EVENT_TABLE() -wxWindow::wxWindow() +void wxWindow::Init() { + m_isWindow = TRUE; + m_widget = (GtkWidget *) NULL; m_wxwindow = (GtkWidget *) NULL; m_parent = (wxWindow *) NULL; m_children.DeleteContents( FALSE ); - + m_x = 0; m_y = 0; m_width = 0; @@ -903,65 +1363,78 @@ wxWindow::wxWindow() m_minHeight = -1; m_maxWidth = -1; m_maxHeight = -1; - + m_retCode = 0; - + m_eventHandler = this; m_windowValidator = (wxValidator *) NULL; - + m_windowId = -1; - + m_cursor = (wxCursor *) NULL; m_font = *wxSWISS_FONT; m_windowStyle = 0; m_windowName = "noname"; - + m_constraints = (wxLayoutConstraints *) NULL; m_constraintsInvolvedIn = (wxList *) NULL; m_windowSizer = (wxSizer *) NULL; m_sizerParent = (wxWindow *) NULL; m_autoLayout = FALSE; - + m_sizeSet = FALSE; m_hasVMT = FALSE; m_needParent = TRUE; - + m_hasScrolling = FALSE; m_isScrolling = FALSE; m_hAdjust = (GtkAdjustment*) NULL; m_vAdjust = (GtkAdjustment*) NULL; m_oldHorizontalPos = 0.0; m_oldVerticalPos = 0.0; - + m_isShown = FALSE; m_isEnabled = TRUE; - + +#if wxUSE_DRAG_AND_DROP m_dropTarget = (wxDropTarget*) NULL; +#endif m_resizing = FALSE; m_scrollGC = (GdkGC*) NULL; m_widgetStyle = (GtkStyle*) NULL; - + m_insertCallback = wxInsertChildInWindow; - + m_clientObject = (wxClientData*) NULL; m_clientData = NULL; + + m_isStaticBox = FALSE; + m_acceptsFocus = FALSE; + +#if wxUSE_TOOLTIPS + m_toolTip = (wxToolTip*) NULL; +#endif // wxUSE_TOOLTIPS +} + +wxWindow::wxWindow() +{ + Init(); } wxWindow::wxWindow( wxWindow *parent, wxWindowID id, const wxPoint &pos, const wxSize &size, long style, const wxString &name ) { - m_insertCallback = wxInsertChildInWindow; + Init(); + Create( parent, id, pos, size, style, name ); } - + bool wxWindow::Create( wxWindow *parent, wxWindowID id, const wxPoint &pos, const wxSize &size, long style, const wxString &name ) { - m_isShown = FALSE; - m_isEnabled = TRUE; - m_needParent = TRUE; + wxASSERT_MSG( m_isWindow, _T("Init() must have been called before!") ); PreCreation( parent, id, pos, size, style, name ); @@ -970,18 +1443,6 @@ bool wxWindow::Create( wxWindow *parent, wxWindowID id, GtkScrolledWindow *s_window = GTK_SCROLLED_WINDOW(m_widget); - gtk_signal_connect( GTK_OBJECT(s_window->vscrollbar), "button_press_event", - (GtkSignalFunc)gtk_scrollbar_button_press_callback, (gpointer) this ); - - gtk_signal_connect( GTK_OBJECT(s_window->hscrollbar), "button_press_event", - (GtkSignalFunc)gtk_scrollbar_button_press_callback, (gpointer) this ); - - gtk_signal_connect( GTK_OBJECT(s_window->vscrollbar), "button_release_event", - (GtkSignalFunc)gtk_scrollbar_button_release_callback, (gpointer) this ); - - gtk_signal_connect( GTK_OBJECT(s_window->hscrollbar), "button_release_event", - (GtkSignalFunc)gtk_scrollbar_button_release_callback, (gpointer) this ); - GtkScrolledWindowClass *scroll_class = GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT(m_widget)->klass ); scroll_class->scrollbar_spacing = 0; @@ -993,25 +1454,27 @@ bool wxWindow::Create( wxWindow *parent, wxWindowID id, m_hAdjust = gtk_range_get_adjustment( GTK_RANGE(s_window->hscrollbar) ); m_vAdjust = gtk_range_get_adjustment( GTK_RANGE(s_window->vscrollbar) ); - gtk_signal_connect( GTK_OBJECT(m_hAdjust), "value_changed", - (GtkSignalFunc) gtk_window_hscroll_callback, (gpointer) this ); - gtk_signal_connect( GTK_OBJECT(m_vAdjust), "value_changed", - (GtkSignalFunc) gtk_window_vscroll_callback, (gpointer) this ); - - gtk_signal_connect( GTK_OBJECT(m_hAdjust), "changed", - (GtkSignalFunc) gtk_window_hscroll_change_callback, (gpointer) this ); - gtk_signal_connect(GTK_OBJECT(m_vAdjust), "changed", - (GtkSignalFunc) gtk_window_vscroll_change_callback, (gpointer) this ); - m_wxwindow = gtk_myfixed_new(); -#ifdef NEW_GTK_SCROLL_CODE - gtk_scrolled_window_add_with_viewport( GTK_SCROLLED_WINDOW(m_widget), m_wxwindow ); - GtkViewport *viewport = GTK_VIEWPORT(s_window->child); -#else gtk_container_add( GTK_CONTAINER(m_widget), m_wxwindow ); + +#if (GTK_MINOR_VERSION > 0) + GtkMyFixed *myfixed = GTK_MYFIXED(m_wxwindow); + + if (m_windowStyle & wxRAISED_BORDER) + { + gtk_myfixed_set_shadow_type( myfixed, GTK_SHADOW_OUT ); + } + else if (m_windowStyle & wxSUNKEN_BORDER) + { + gtk_myfixed_set_shadow_type( myfixed, GTK_SHADOW_IN ); + } + else + { + gtk_myfixed_set_shadow_type( myfixed, GTK_SHADOW_NONE ); + } +#else GtkViewport *viewport = GTK_VIEWPORT(s_window->viewport); -#endif if (m_windowStyle & wxRAISED_BORDER) { @@ -1025,15 +1488,26 @@ bool wxWindow::Create( wxWindow *parent, wxWindowID id, { gtk_viewport_set_shadow_type( viewport, GTK_SHADOW_NONE ); } +#endif - if (m_windowStyle & wxTAB_TRAVERSAL == wxTAB_TRAVERSAL) - GTK_WIDGET_UNSET_FLAGS( m_wxwindow, GTK_CAN_FOCUS ); + if (m_windowStyle & wxTAB_TRAVERSAL) + { + /* we now allow a window to get the focus as long as it + doesn't have any children. */ + GTK_WIDGET_SET_FLAGS( m_wxwindow, GTK_CAN_FOCUS ); + m_acceptsFocus = FALSE; + } else + { GTK_WIDGET_SET_FLAGS( m_wxwindow, GTK_CAN_FOCUS ); + m_acceptsFocus = TRUE; + } +#if (GTK_MINOR_VERSION == 0) // shut the viewport up gtk_viewport_set_hadjustment( viewport, (GtkAdjustment*) gtk_adjustment_new( 0.0, 0.0, 0.0, 0.0, 0.0, 0.0) ); gtk_viewport_set_vadjustment( viewport, (GtkAdjustment*) gtk_adjustment_new( 0.0, 0.0, 0.0, 0.0, 0.0, 0.0) ); +#endif // I _really_ don't want scrollbars in the beginning m_vAdjust->lower = 0.0; @@ -1051,14 +1525,44 @@ bool wxWindow::Create( wxWindow *parent, wxWindowID id, m_hAdjust->page_size = 5.0; gtk_signal_emit_by_name( GTK_OBJECT(m_hAdjust), "changed" ); + // these handlers block mouse events to any window during scrolling + // such as motion events and prevent GTK and wxWindows from fighting + // over where the slider should be + + gtk_signal_connect( GTK_OBJECT(s_window->vscrollbar), "button_press_event", + (GtkSignalFunc)gtk_scrollbar_button_press_callback, (gpointer) this ); + + gtk_signal_connect( GTK_OBJECT(s_window->hscrollbar), "button_press_event", + (GtkSignalFunc)gtk_scrollbar_button_press_callback, (gpointer) this ); + + gtk_signal_connect( GTK_OBJECT(s_window->vscrollbar), "button_release_event", + (GtkSignalFunc)gtk_scrollbar_button_release_callback, (gpointer) this ); + + gtk_signal_connect( GTK_OBJECT(s_window->hscrollbar), "button_release_event", + (GtkSignalFunc)gtk_scrollbar_button_release_callback, (gpointer) this ); + + // these handlers get notified when screen updates are required either when + // scrolling or when the window size (and therefore scrollbar configuration) + // has changed + + gtk_signal_connect( GTK_OBJECT(m_hAdjust), "value_changed", + (GtkSignalFunc) gtk_window_hscroll_callback, (gpointer) this ); + gtk_signal_connect( GTK_OBJECT(m_vAdjust), "value_changed", + (GtkSignalFunc) gtk_window_vscroll_callback, (gpointer) this ); + + gtk_signal_connect( GTK_OBJECT(m_hAdjust), "changed", + (GtkSignalFunc) gtk_window_hscroll_change_callback, (gpointer) this ); + gtk_signal_connect(GTK_OBJECT(m_vAdjust), "changed", + (GtkSignalFunc) gtk_window_vscroll_change_callback, (gpointer) this ); + gtk_widget_show( m_wxwindow ); - + if (m_parent) m_parent->AddChild( this ); (m_parent->m_insertCallback)( m_parent, this ); - + PostCreation(); - + Show( TRUE ); return TRUE; @@ -1068,52 +1572,68 @@ wxWindow::~wxWindow() { m_hasVMT = FALSE; - if (m_dropTarget) delete m_dropTarget; +#if wxUSE_DRAG_AND_DROP + if (m_dropTarget) + { + delete m_dropTarget; + m_dropTarget = (wxDropTarget*) NULL; + } +#endif + +#if wxUSE_TOOLTIPS + if (m_toolTip) + { + delete m_toolTip; + m_toolTip = (wxToolTip*) NULL; + } +#endif // wxUSE_TOOLTIPS - if (m_parent) m_parent->RemoveChild( this ); if (m_widget) Show( FALSE ); DestroyChildren(); + if (m_parent) m_parent->RemoveChild( this ); + if (m_widgetStyle) gtk_style_unref( m_widgetStyle ); - + if (m_scrollGC) gdk_gc_unref( m_scrollGC ); - + if (m_wxwindow) gtk_widget_destroy( m_wxwindow ); if (m_widget) gtk_widget_destroy( m_widget ); - + if (m_cursor) delete m_cursor; DeleteRelatedConstraints(); if (m_constraints) { - // This removes any dangling pointers to this window - // in other windows' constraintsInvolvedIn lists. + /* This removes any dangling pointers to this window + * in other windows' constraintsInvolvedIn lists. */ UnsetConstraints(m_constraints); delete m_constraints; m_constraints = (wxLayoutConstraints *) NULL; } + if (m_windowSizer) { delete m_windowSizer; m_windowSizer = (wxSizer *) NULL; } - // If this is a child of a sizer, remove self from parent + /* If this is a child of a sizer, remove self from parent */ if (m_sizerParent) m_sizerParent->RemoveChild((wxWindow *)this); - // Just in case the window has been Closed, but - // we're then deleting immediately: don't leave - // dangling pointers. + /* Just in case the window has been Closed, but + * we're then deleting immediately: don't leave + * dangling pointers. */ wxPendingDelete.DeleteObject(this); - // Just in case we've loaded a top-level window via - // wxWindow::LoadNativeDialog but we weren't a dialog - // class + /* Just in case we've loaded a top-level window via + * wxWindow::LoadNativeDialog but we weren't a dialog + * class */ wxTopLevelWindows.DeleteObject(this); if (m_windowValidator) delete m_windowValidator; - + if (m_clientObject) delete m_clientObject; } @@ -1121,24 +1641,23 @@ void wxWindow::PreCreation( wxWindow *parent, wxWindowID id, const wxPoint &pos, const wxSize &size, long style, const wxString &name ) { - if (m_needParent && (parent == NULL)) - wxFatalError( "Need complete parent.", name ); - + wxASSERT_MSG( (!m_needParent) || (parent), _T("Need complete parent.") ); + m_widget = (GtkWidget*) NULL; m_wxwindow = (GtkWidget*) NULL; m_hasVMT = FALSE; m_parent = parent; m_children.DeleteContents( FALSE ); - + m_width = size.x; if (m_width == -1) m_width = 20; m_height = size.y; if (m_height == -1) m_height = 20; - + m_x = (int)pos.x; m_y = (int)pos.y; - - if (!m_needParent) // some reasonable defaults + + if (!m_needParent) /* some reasonable defaults */ { if (m_x == -1) { @@ -1151,67 +1670,88 @@ void wxWindow::PreCreation( wxWindow *parent, wxWindowID id, if (m_y < 10) m_y = 10; } } - + m_minWidth = -1; m_minHeight = -1; m_maxWidth = -1; m_maxHeight = -1; - + m_retCode = 0; - + m_eventHandler = this; - - m_windowId = id; - + + m_windowId = id == -1 ? wxNewId() : id; + m_sizeSet = FALSE; - + m_cursor = new wxCursor( wxCURSOR_ARROW ); m_font = *wxSWISS_FONT; -// m_backgroundColour = wxWHITE; -// m_foregroundColour = wxBLACK; + m_backgroundColour = wxSystemSettings::GetSystemColour( wxSYS_COLOUR_BTNFACE ); + m_foregroundColour = *wxBLACK; m_windowStyle = style; m_windowName = name; - + m_constraints = (wxLayoutConstraints *) NULL; m_constraintsInvolvedIn = (wxList *) NULL; m_windowSizer = (wxSizer *) NULL; m_sizerParent = (wxWindow *) NULL; m_autoLayout = FALSE; - + m_hasScrolling = FALSE; m_isScrolling = FALSE; m_hAdjust = (GtkAdjustment *) NULL; m_vAdjust = (GtkAdjustment *) NULL; m_oldHorizontalPos = 0.0; m_oldVerticalPos = 0.0; - + m_isShown = FALSE; m_isEnabled = TRUE; - + +#if wxUSE_DRAG_AND_DROP m_dropTarget = (wxDropTarget *) NULL; +#endif m_resizing = FALSE; m_windowValidator = (wxValidator *) NULL; m_scrollGC = (GdkGC*) NULL; m_widgetStyle = (GtkStyle*) NULL; - + m_clientObject = (wxClientData*)NULL; m_clientData = NULL; + + m_isStaticBox = FALSE; + +#if wxUSE_TOOLTIPS + m_toolTip = (wxToolTip*) NULL; +#endif // wxUSE_TOOLTIPS } void wxWindow::PostCreation() { + wxASSERT_MSG( (m_widget != NULL), _T("invalid window") ); + if (m_wxwindow) { - gtk_signal_connect( GTK_OBJECT(m_wxwindow), "expose_event", - GTK_SIGNAL_FUNC(gtk_window_expose_callback), (gpointer)this ); - - gtk_signal_connect( GTK_OBJECT(m_wxwindow), "draw", - GTK_SIGNAL_FUNC(gtk_window_draw_callback), (gpointer)this ); + /* these get reported to wxWindows -> wxPaintEvent */ + gtk_signal_connect( GTK_OBJECT(m_wxwindow), "expose_event", + GTK_SIGNAL_FUNC(gtk_window_expose_callback), (gpointer)this ); + + gtk_signal_connect( GTK_OBJECT(m_wxwindow), "draw", + GTK_SIGNAL_FUNC(gtk_window_draw_callback), (gpointer)this ); + +#if (GTK_MINOR_VERSION > 0) + /* these are called when the "sunken" or "raised" borders are drawn */ + gtk_signal_connect( GTK_OBJECT(m_widget), "expose_event", + GTK_SIGNAL_FUNC(gtk_window_own_expose_callback), (gpointer)this ); + + gtk_signal_connect( GTK_OBJECT(m_widget), "draw", + GTK_SIGNAL_FUNC(gtk_window_own_draw_callback), (gpointer)this ); +#endif } ConnectWidget( GetConnectWidget() ); - if (m_widget && m_parent) gtk_widget_realize( m_widget ); + /* we force the creation of wxFrame and wxDialog in the respective code */ + if (m_parent) gtk_widget_realize( m_widget ); if (m_wxwindow) gtk_widget_realize( m_wxwindow ); @@ -1225,6 +1765,9 @@ void wxWindow::ConnectWidget( GtkWidget *widget ) gtk_signal_connect( GTK_OBJECT(widget), "key_press_event", GTK_SIGNAL_FUNC(gtk_window_key_press_callback), (gpointer)this ); + gtk_signal_connect( GTK_OBJECT(widget), "key_release_event", + GTK_SIGNAL_FUNC(gtk_window_key_release_callback), (gpointer)this ); + gtk_signal_connect( GTK_OBJECT(widget), "button_press_event", GTK_SIGNAL_FUNC(gtk_window_button_press_callback), (gpointer)this ); @@ -1254,18 +1797,20 @@ bool wxWindow::HasVMT() bool wxWindow::Close( bool force ) { - wxASSERT_MSG( (m_widget != NULL), "invalid window" ); + wxASSERT_MSG( (m_widget != NULL), _T("invalid window") ); wxCloseEvent event(wxEVT_CLOSE_WINDOW, m_windowId); event.SetEventObject(this); - event.SetForce(force); + event.SetCanVeto(!force); - return GetEventHandler()->ProcessEvent(event); + /* return FALSE if window wasn't closed because the application vetoed the + * close event */ + return GetEventHandler()->ProcessEvent(event) && !event.GetVeto(); } bool wxWindow::Destroy() { - wxASSERT_MSG( (m_widget != NULL), "invalid window" ); + wxASSERT_MSG( (m_widget != NULL), _T("invalid window") ); m_hasVMT = FALSE; delete this; @@ -1274,17 +1819,14 @@ bool wxWindow::Destroy() bool wxWindow::DestroyChildren() { - if (GetChildren()) + wxNode *node; + while ((node = m_children.First()) != (wxNode *)NULL) { - wxNode *node; - while ((node = GetChildren()->First()) != (wxNode *)NULL) + wxWindow *child; + if ((child = (wxWindow *)node->Data()) != (wxWindow *)NULL) { - wxWindow *child; - if ((child = (wxWindow *)node->Data()) != (wxWindow *)NULL) - { - delete child; - if (GetChildren()->Member(child)) delete node; - } + delete child; + if (m_children.Member(child)) delete node; } } return TRUE; @@ -1295,32 +1837,17 @@ void wxWindow::PrepareDC( wxDC &WXUNUSED(dc) ) // are we to set fonts here ? } -wxPoint wxWindow::GetClientAreaOrigin() const +void wxWindow::DoSetSize( int x, int y, int width, int height, int sizeFlags ) { - return wxPoint(0,0); -} + wxASSERT_MSG( (m_widget != NULL), _T("invalid window") ); + wxASSERT_MSG( (m_parent != NULL), _T("wxWindow::SetSize requires parent.\n") ); -void wxWindow::AdjustForParentClientOrigin( int& x, int& y, int sizeFlags ) -{ - if (((sizeFlags & wxSIZE_NO_ADJUSTMENTS) == 0) && GetParent()) - { - wxPoint pt(GetParent()->GetClientAreaOrigin()); - x += pt.x; - y += pt.y; - } -} - -void wxWindow::SetSize( int x, int y, int width, int height, int sizeFlags ) -{ - wxASSERT_MSG( (m_widget != NULL), "invalid window" ); - wxASSERT_MSG( (m_parent != NULL), "wxWindow::SetSize requires parent.\n" ); - - if (m_resizing) return; // I don't like recursions + if (m_resizing) return; /* I don't like recursions */ m_resizing = TRUE; - if (m_parent->m_wxwindow == NULL) // i.e. wxNotebook + if (m_parent->m_wxwindow == NULL) /* i.e. wxNotebook */ { - // don't set the size for children of wxNotebook, just take the values. + /* don't set the size for children of wxNotebook, just take the values. */ m_x = x; m_y = y; m_width = width; @@ -1330,7 +1857,7 @@ void wxWindow::SetSize( int x, int y, int width, int height, int sizeFlags ) { int old_width = m_width; int old_height = m_height; - + if ((sizeFlags & wxSIZE_USE_EXISTING) == wxSIZE_USE_EXISTING) { if (x != -1) m_x = x; @@ -1355,19 +1882,30 @@ void wxWindow::SetSize( int x, int y, int width, int height, int sizeFlags ) { if (height == -1) m_height = 26; } - + if ((m_minWidth != -1) && (m_width < m_minWidth)) m_width = m_minWidth; if ((m_minHeight != -1) && (m_height < m_minHeight)) m_height = m_minHeight; - if ((m_maxWidth != -1) && (m_width > m_maxWidth)) m_width = m_minWidth; - if ((m_maxHeight != -1) && (m_height > m_maxHeight)) m_height = m_minHeight; - - wxPoint pt( m_parent->GetClientAreaOrigin() ); - gtk_myfixed_move( GTK_MYFIXED(m_parent->m_wxwindow), m_widget, m_x+pt.x, m_y+pt.y ); - - if ((old_width != m_width) || (old_height != m_height)) - gtk_widget_set_usize( m_widget, m_width, m_height ); + if ((m_maxWidth != -1) && (m_width > m_maxWidth)) m_width = m_maxWidth; + if ((m_maxHeight != -1) && (m_height > m_maxHeight)) m_height = m_maxHeight; + + if (GTK_WIDGET_HAS_DEFAULT(m_widget)) + { + /* the default button has a border around it */ + int border = 5; + + gtk_myfixed_move( GTK_MYFIXED(m_parent->m_wxwindow), m_widget, m_x-border, m_y-border ); + + gtk_widget_set_usize( m_widget, m_width+2*border, m_height+2*border ); + } + else + { + gtk_myfixed_move( GTK_MYFIXED(m_parent->m_wxwindow), m_widget, m_x, m_y ); + + if ((old_width != m_width) || (old_height != m_height)) + gtk_widget_set_usize( m_widget, m_width, m_height ); + } } - + m_sizeSet = TRUE; wxSizeEvent event( wxSize(m_width,m_height), GetId() ); @@ -1377,159 +1915,153 @@ void wxWindow::SetSize( int x, int y, int width, int height, int sizeFlags ) m_resizing = FALSE; } -void wxWindow::SetSize( int width, int height ) +void wxWindow::OnInternalIdle() { - SetSize( -1, -1, width, height, wxSIZE_USE_EXISTING ); -} - -void wxWindow::Move( int x, int y ) -{ - SetSize( x, y, -1, -1, wxSIZE_USE_EXISTING ); + UpdateWindowUI(); } void wxWindow::GetSize( int *width, int *height ) const { - wxASSERT_MSG( (m_widget != NULL), "invalid window" ); + wxCHECK_RET( (m_widget != NULL), _T("invalid window") ); if (width) (*width) = m_width; if (height) (*height) = m_height; } -void wxWindow::SetClientSize( int width, int height ) +void wxWindow::DoSetClientSize( int width, int height ) { - wxASSERT_MSG( (m_widget != NULL), "invalid window" ); - - if (!m_wxwindow) - { - SetSize( width, height ); - } - else - { - int dw = 0; - int dh = 0; + wxCHECK_RET( (m_widget != NULL), _T("invalid window") ); - if (!m_hasScrolling) + if (!m_wxwindow) { -/* - do we have sunken dialogs ? - - GtkStyleClass *window_class = m_wxwindow->style->klass; - - dw += 2 * window_class->xthickness; - dh += 2 * window_class->ythickness; -*/ + SetSize( width, height ); } else { - GtkScrolledWindow *scroll_window = GTK_SCROLLED_WINDOW(m_widget); - GtkScrolledWindowClass *scroll_class = GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT(m_widget)->klass ); + int dw = 0; + int dh = 0; -#ifdef NEW_GTK_SCROLL_CODE - GtkWidget *viewport = scroll_window->child; -#else - GtkWidget *viewport = scroll_window->viewport; -#endif + if (!m_hasScrolling) + { + GtkStyleClass *window_class = m_wxwindow->style->klass; - GtkStyleClass *viewport_class = viewport->style->klass; + if ((m_windowStyle & wxRAISED_BORDER) || + (m_windowStyle & wxSUNKEN_BORDER)) + { + dw += 2 * window_class->xthickness; + dh += 2 * window_class->ythickness; + } + } + else + { + GtkScrolledWindow *scroll_window = GTK_SCROLLED_WINDOW(m_widget); + GtkScrolledWindowClass *scroll_class = GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT(m_widget)->klass ); - GtkWidget *hscrollbar = scroll_window->hscrollbar; - GtkWidget *vscrollbar = scroll_window->vscrollbar; +#if (GTK_MINOR_VERSION == 0) + GtkWidget *viewport = scroll_window->viewport; + GtkStyleClass *viewport_class = viewport->style->klass; - if ((m_windowStyle & wxRAISED_BORDER) || - (m_windowStyle & wxSUNKEN_BORDER)) - { - dw += 2 * viewport_class->xthickness; - dh += 2 * viewport_class->ythickness; - } + if ((m_windowStyle & wxRAISED_BORDER) || + (m_windowStyle & wxSUNKEN_BORDER)) + { + dw += 2 * viewport_class->xthickness; + dh += 2 * viewport_class->ythickness; + } +#endif - if (GTK_WIDGET_VISIBLE(vscrollbar)) - { - dw += vscrollbar->allocation.width; - dw += scroll_class->scrollbar_spacing; - } +/* + GtkWidget *hscrollbar = scroll_window->hscrollbar; + GtkWidget *vscrollbar = scroll_window->vscrollbar; + + we use this instead: range.slider_width = 11 + 2*2pts edge +*/ - if (GTK_WIDGET_VISIBLE(hscrollbar)) - { - dh += hscrollbar->allocation.height; - dw += scroll_class->scrollbar_spacing; - } - } + if (scroll_window->vscrollbar_visible) + { + dw += 15; /* dw += vscrollbar->allocation.width; */ + dw += scroll_class->scrollbar_spacing; + } - SetSize( width+dw, height+dh ); - } + if (scroll_window->hscrollbar_visible) + { + dh += 15; /* dh += hscrollbar->allocation.height; */ + dw += scroll_class->scrollbar_spacing; + } + } + + SetSize( width+dw, height+dh ); + } } void wxWindow::GetClientSize( int *width, int *height ) const { - wxASSERT_MSG( (m_widget != NULL), "invalid window" ); - - if (!m_wxwindow) - { - if (width) (*width) = m_width; - if (height) (*height) = m_height; - } - else - { - int dw = 0; - int dh = 0; + wxCHECK_RET( (m_widget != NULL), _T("invalid window") ); - if (!m_hasScrolling) + if (!m_wxwindow) { -/* - do we have sunken dialogs ? - - GtkStyleClass *window_class = m_wxwindow->style->klass; - - dw += 2 * window_class->xthickness; - dh += 2 * window_class->ythickness; -*/ + if (width) (*width) = m_width; + if (height) (*height) = m_height; } else { - GtkScrolledWindow *scroll_window = GTK_SCROLLED_WINDOW(m_widget); - GtkScrolledWindowClass *scroll_class = GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT(m_widget)->klass ); + int dw = 0; + int dh = 0; -#ifdef NEW_GTK_SCROLL_CODE - GtkWidget *viewport = scroll_window->child; -#else - GtkWidget *viewport = scroll_window->viewport; -#endif + if (!m_hasScrolling) + { + GtkStyleClass *window_class = m_wxwindow->style->klass; + + if ((m_windowStyle & wxRAISED_BORDER) || + (m_windowStyle & wxSUNKEN_BORDER)) + { + dw += 2 * window_class->xthickness; + dh += 2 * window_class->ythickness; + } + } + else + { + GtkScrolledWindow *scroll_window = GTK_SCROLLED_WINDOW(m_widget); + GtkScrolledWindowClass *scroll_class = GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT(m_widget)->klass ); - GtkStyleClass *viewport_class = viewport->style->klass; +#if (GTK_MINOR_VERSION == 0) + GtkWidget *viewport = scroll_window->viewport; + GtkStyleClass *viewport_class = viewport->style->klass; - GtkWidget *hscrollbar = scroll_window->hscrollbar; - GtkWidget *vscrollbar = scroll_window->vscrollbar; + if ((m_windowStyle & wxRAISED_BORDER) || + (m_windowStyle & wxSUNKEN_BORDER)) + { + dw += 2 * viewport_class->xthickness; + dh += 2 * viewport_class->ythickness; + } +#endif +/* + GtkWidget *hscrollbar = scroll_window->hscrollbar; + GtkWidget *vscrollbar = scroll_window->vscrollbar; + + we use this instead: range.slider_width = 11 + 2*2pts edge +*/ - if ((m_windowStyle & wxRAISED_BORDER) || - (m_windowStyle & wxSUNKEN_BORDER)) - { - dw += 2 * viewport_class->xthickness; - dh += 2 * viewport_class->ythickness; - } + if (scroll_window->vscrollbar_visible) + { + dw += 15; /* dw += vscrollbar->allocation.width; */ + dw += scroll_class->scrollbar_spacing; + } - if (GTK_WIDGET_VISIBLE(vscrollbar)) - { -// dw += vscrollbar->allocation.width; - dw += 15; // range.slider_width = 11 + 2*2pts edge - dw += scroll_class->scrollbar_spacing; - } + if (scroll_window->hscrollbar_visible) + { + dh += 15; /* dh += hscrollbar->allocation.height; */ + dh += scroll_class->scrollbar_spacing; + } + } - if (GTK_WIDGET_VISIBLE(hscrollbar)) - { -// dh += hscrollbar->allocation.height; - dh += 15; - dh += scroll_class->scrollbar_spacing; - } + if (width) (*width) = m_width - dw; + if (height) (*height) = m_height - dh; } - - if (width) (*width) = m_width - dw; - if (height) (*height) = m_height - dh; - } } void wxWindow::GetPosition( int *x, int *y ) const { - wxASSERT_MSG( (m_widget != NULL), "invalid window" ); + wxCHECK_RET( (m_widget != NULL), _T("invalid window") ); if (x) (*x) = m_x; if (y) (*y) = m_y; @@ -1537,7 +2069,7 @@ void wxWindow::GetPosition( int *x, int *y ) const void wxWindow::ClientToScreen( int *x, int *y ) { - wxASSERT_MSG( (m_widget != NULL), "invalid window" ); + wxCHECK_RET( (m_widget != NULL), _T("invalid window") ); GdkWindow *source = (GdkWindow *) NULL; if (m_wxwindow) @@ -1558,413 +2090,425 @@ void wxWindow::ClientToScreen( int *x, int *y ) } } - wxPoint pt(GetClientAreaOrigin()); - org_x += pt.x; - org_y += pt.y; - if (x) *x += org_x; if (y) *y += org_y; } void wxWindow::ScreenToClient( int *x, int *y ) { - wxASSERT_MSG( (m_widget != NULL), "invalid window" ); + wxCHECK_RET( (m_widget != NULL), _T("invalid window") ); - GdkWindow *source = (GdkWindow *) NULL; - if (m_wxwindow) - source = m_wxwindow->window; - else - source = m_widget->window; + GdkWindow *source = (GdkWindow *) NULL; + if (m_wxwindow) + source = m_wxwindow->window; + else + source = m_widget->window; - int org_x = 0; - int org_y = 0; - gdk_window_get_origin( source, &org_x, &org_y ); + int org_x = 0; + int org_y = 0; + gdk_window_get_origin( source, &org_x, &org_y ); - if (!m_wxwindow) - { - if (GTK_WIDGET_NO_WINDOW (m_widget)) + if (!m_wxwindow) { - org_x += m_widget->allocation.x; - org_y += m_widget->allocation.y; + if (GTK_WIDGET_NO_WINDOW (m_widget)) + { + org_x += m_widget->allocation.x; + org_y += m_widget->allocation.y; + } } - } - wxPoint pt(GetClientAreaOrigin()); - org_x -= pt.x; - org_y -= pt.y; - - if (x) *x -= org_x; - if (y) *y -= org_y; + if (x) *x -= org_x; + if (y) *y -= org_y; } void wxWindow::Centre( int direction ) { - wxASSERT_MSG( (m_widget != NULL), "invalid window" ); + wxCHECK_RET( (m_widget != NULL), _T("invalid window") ); - int x = m_x; - int y = m_y; - - if (m_parent) - { - int p_w = 0; - int p_h = 0; - m_parent->GetSize( &p_w, &p_h ); - if (direction & wxHORIZONTAL == wxHORIZONTAL) x = (p_w - m_width) / 2; - if (direction & wxVERTICAL == wxVERTICAL) y = (p_h - m_height) / 2; - } - else - { - if (direction & wxHORIZONTAL == wxHORIZONTAL) x = (gdk_screen_width () - m_width) / 2; - if (direction & wxVERTICAL == wxVERTICAL) y = (gdk_screen_height () - m_height) / 2; - } - - Move( x, y ); + int x = m_x; + int y = m_y; + + if (m_parent) + { + int p_w = 0; + int p_h = 0; + m_parent->GetSize( &p_w, &p_h ); + if (direction & wxHORIZONTAL == wxHORIZONTAL) x = (p_w - m_width) / 2; + if (direction & wxVERTICAL == wxVERTICAL) y = (p_h - m_height) / 2; + } + else + { + if (direction & wxHORIZONTAL == wxHORIZONTAL) x = (gdk_screen_width () - m_width) / 2; + if (direction & wxVERTICAL == wxVERTICAL) y = (gdk_screen_height () - m_height) / 2; + } + + Move( x, y ); } void wxWindow::Fit() { - wxASSERT_MSG( (m_widget != NULL), "invalid window" ); + wxCHECK_RET( (m_widget != NULL), _T("invalid window") ); - int maxX = 0; - int maxY = 0; - wxNode *node = GetChildren()->First(); - while ( node ) - { - wxWindow *win = (wxWindow *)node->Data(); - int wx, wy, ww, wh; - win->GetPosition(&wx, &wy); - win->GetSize(&ww, &wh); - if ( wx + ww > maxX ) - maxX = wx + ww; - if ( wy + wh > maxY ) - maxY = wy + wh; + int maxX = 0; + int maxY = 0; + wxNode *node = m_children.First(); + while (node) + { + wxWindow *win = (wxWindow *)node->Data(); + int wx, wy, ww, wh; + win->GetPosition(&wx, &wy); + win->GetSize(&ww, &wh); + if (wx + ww > maxX) maxX = wx + ww; + if (wy + wh > maxY) maxY = wy + wh; + + node = node->Next(); + } - node = node->Next(); - } - SetClientSize(maxX + 5, maxY + 10); + SetClientSize(maxX + 7, maxY + 14); } void wxWindow::SetSizeHints( int minW, int minH, int maxW, int maxH, int WXUNUSED(incW), int WXUNUSED(incH) ) { - wxASSERT_MSG( (m_widget != NULL), "invalid window" ); + wxCHECK_RET( (m_widget != NULL), _T("invalid window") ); - m_minWidth = minW; - m_minHeight = minH; - m_maxWidth = maxW; - m_maxHeight = maxH; + m_minWidth = minW; + m_minHeight = minH; + m_maxWidth = maxW; + m_maxHeight = maxH; } void wxWindow::OnSize( wxSizeEvent &WXUNUSED(event) ) { - //if (GetAutoLayout()) Layout(); +// if (GetAutoLayout()) Layout(); } bool wxWindow::Show( bool show ) { - wxASSERT_MSG( (m_widget != NULL), "invalid window" ); + wxCHECK_MSG( (m_widget != NULL), FALSE, _T("invalid window") ); - if (show) - gtk_widget_show( m_widget ); - else - gtk_widget_hide( m_widget ); - m_isShown = show; - return TRUE; + if (show == m_isShown) return TRUE; + + if (show) + gtk_widget_show( m_widget ); + else + gtk_widget_hide( m_widget ); + + m_isShown = show; + + return TRUE; } void wxWindow::Enable( bool enable ) { - wxASSERT_MSG( (m_widget != NULL), "invalid window" ); + wxCHECK_RET( (m_widget != NULL), _T("invalid window") ); + + m_isEnabled = enable; - m_isEnabled = enable; - gtk_widget_set_sensitive( m_widget, enable ); - if (m_wxwindow) gtk_widget_set_sensitive( m_wxwindow, enable ); + gtk_widget_set_sensitive( m_widget, enable ); + if (m_wxwindow) gtk_widget_set_sensitive( m_wxwindow, enable ); } int wxWindow::GetCharHeight() const { - wxASSERT_MSG( (m_widget != NULL), "invalid window" ); + wxCHECK_MSG( (m_widget != NULL), 12, _T("invalid window") ); - if (!m_font.Ok()) - { - wxFAIL_MSG( "invalid font" ); - return -1; - } + wxCHECK_MSG( m_font.Ok(), 12, _T("invalid font") ); + + GdkFont *font = m_font.GetInternalFont( 1.0 ); - GdkFont *font = m_font.GetInternalFont( 1.0 ); - return font->ascent + font->descent; + return font->ascent + font->descent; } int wxWindow::GetCharWidth() const { - wxASSERT_MSG( (m_widget != NULL), "invalid window" ); + wxCHECK_MSG( (m_widget != NULL), 8, _T("invalid window") ); - if (!m_font.Ok()) - { - wxFAIL_MSG( "invalid font" ); - return -1; - } + wxCHECK_MSG( m_font.Ok(), 8, _T("invalid font") ); + + GdkFont *font = m_font.GetInternalFont( 1.0 ); - GdkFont *font = m_font.GetInternalFont( 1.0 ); - return gdk_string_width( font, "H" ); + return gdk_string_width( font, "H" ); } void wxWindow::GetTextExtent( const wxString& string, int *x, int *y, int *descent, int *externalLeading, const wxFont *theFont, bool WXUNUSED(use16) ) const { - wxASSERT_MSG( (m_widget != NULL), "invalid window" ); - - wxFont fontToUse = m_font; - if (theFont) fontToUse = *theFont; + wxFont fontToUse = m_font; + if (theFont) fontToUse = *theFont; - if (!fontToUse.Ok()) - { - wxFAIL_MSG( "invalid font" ); - return; - } - wxASSERT_MSG( (m_font.Ok()), "invalid font" ); + wxCHECK_RET( fontToUse.Ok(), _T("invalid font") ); - GdkFont *font = fontToUse.GetInternalFont( 1.0 ); - if (x) (*x) = gdk_string_width( font, string ); - if (y) (*y) = font->ascent + font->descent; - if (descent) (*descent) = font->descent; - if (externalLeading) (*externalLeading) = 0; // ?? + GdkFont *font = fontToUse.GetInternalFont( 1.0 ); + if (x) (*x) = gdk_string_width( font, string.mbc_str() ); + if (y) (*y) = font->ascent + font->descent; + if (descent) (*descent) = font->descent; + if (externalLeading) (*externalLeading) = 0; // ?? } void wxWindow::MakeModal( bool modal ) { - return; - // Disable all other windows - if (this->IsKindOf(CLASSINFO(wxDialog)) || this->IsKindOf(CLASSINFO(wxFrame))) - { - wxNode *node = wxTopLevelWindows.First(); - while (node) + return; + + // Disable all other windows + if (this->IsKindOf(CLASSINFO(wxDialog)) || this->IsKindOf(CLASSINFO(wxFrame))) { - wxWindow *win = (wxWindow *)node->Data(); - if (win != this) - win->Enable(!modal); + wxNode *node = wxTopLevelWindows.First(); + while (node) + { + wxWindow *win = (wxWindow *)node->Data(); + if (win != this) win->Enable(!modal); - node = node->Next(); + node = node->Next(); + } + } +} + +void wxWindow::OnKeyDown( wxKeyEvent &event ) +{ + event.SetEventType( wxEVT_CHAR ); + + if (!GetEventHandler()->ProcessEvent( event )) + { + event.Skip(); } - } } void wxWindow::SetFocus() { - wxASSERT_MSG( (m_widget != NULL), "invalid window" ); + wxCHECK_RET( (m_widget != NULL), _T("invalid window") ); - GtkWidget *connect_widget = GetConnectWidget(); - if (connect_widget) - { - if (GTK_WIDGET_CAN_FOCUS(connect_widget) && !GTK_WIDGET_HAS_FOCUS (connect_widget) ) + GtkWidget *connect_widget = GetConnectWidget(); + if (connect_widget) { - gtk_widget_grab_focus (connect_widget); + if (GTK_WIDGET_CAN_FOCUS(connect_widget) /*&& !GTK_WIDGET_HAS_FOCUS (connect_widget)*/ ) + { + gtk_widget_grab_focus (connect_widget); + } + else if (GTK_IS_CONTAINER(connect_widget)) + { + gtk_container_focus( GTK_CONTAINER(connect_widget), GTK_DIR_TAB_FORWARD ); + } + else + { + } } - } } -bool wxWindow::OnClose() +wxWindow *wxWindow::FindFocus() { - return TRUE; + return g_focusWindow; +} + +bool wxWindow::AcceptsFocus() const +{ + return IsEnabled() && IsShown() && m_acceptsFocus; } void wxWindow::AddChild( wxWindow *child ) { - wxASSERT_MSG( (m_widget != NULL), "invalid window" ); - wxASSERT_MSG( (child != NULL), "invalid child" ); + wxCHECK_RET( (m_widget != NULL), _T("invalid window") ); + wxCHECK_RET( (child != NULL), _T("invalid child") ); - m_children.Append( child ); + m_children.Append( child ); } -wxList *wxWindow::GetChildren() +wxWindow *wxWindow::ReParent( wxWindow *newParent ) { - return (&m_children); + wxCHECK_MSG( (m_widget != NULL), (wxWindow*) NULL, _T("invalid window") ); + + wxWindow *oldParent = GetParent(); + + if (oldParent) oldParent->RemoveChild( this ); + + gtk_widget_unparent( m_widget ); + + if (newParent) + { + newParent->AddChild( this ); + (newParent->m_insertCallback)( newParent, this ); + } + + return oldParent; } void wxWindow::RemoveChild( wxWindow *child ) { - if (GetChildren()) GetChildren()->DeleteObject( child ); - child->m_parent = (wxWindow *) NULL; + m_children.DeleteObject( child ); + child->m_parent = (wxWindow *) NULL; } void wxWindow::SetReturnCode( int retCode ) { - m_retCode = retCode; + m_retCode = retCode; } int wxWindow::GetReturnCode() { - return m_retCode; + return m_retCode; } void wxWindow::Raise() { - wxASSERT_MSG( (m_widget != NULL), "invalid window" ); + wxCHECK_RET( (m_widget != NULL), _T("invalid window") ); - if (m_widget) gdk_window_raise( m_widget->window ); + if (m_widget) gdk_window_raise( m_widget->window ); } void wxWindow::Lower() { - wxASSERT_MSG( (m_widget != NULL), "invalid window" ); + wxCHECK_RET( (m_widget != NULL), _T("invalid window") ); - if (m_widget) gdk_window_lower( m_widget->window ); + if (m_widget) gdk_window_lower( m_widget->window ); } -wxEvtHandler *wxWindow::GetEventHandler() +wxEvtHandler *wxWindow::GetEventHandler() const { - return m_eventHandler; + return m_eventHandler; } void wxWindow::SetEventHandler( wxEvtHandler *handler ) { - m_eventHandler = handler; + m_eventHandler = handler; } void wxWindow::PushEventHandler(wxEvtHandler *handler) { - handler->SetNextHandler(GetEventHandler()); - SetEventHandler(handler); + handler->SetNextHandler(GetEventHandler()); + SetEventHandler(handler); } wxEvtHandler *wxWindow::PopEventHandler(bool deleteHandler) -{ - if (GetEventHandler()) - { - wxEvtHandler *handlerA = GetEventHandler(); - wxEvtHandler *handlerB = handlerA->GetNextHandler(); - handlerA->SetNextHandler((wxEvtHandler *) NULL); - SetEventHandler(handlerB); - if (deleteHandler) - { - delete handlerA; - return (wxEvtHandler*) NULL; - } - else - return handlerA; - } - else - return (wxEvtHandler *) NULL; +{ + if (GetEventHandler()) + { + wxEvtHandler *handlerA = GetEventHandler(); + wxEvtHandler *handlerB = handlerA->GetNextHandler(); + handlerA->SetNextHandler((wxEvtHandler *) NULL); + SetEventHandler(handlerB); + if (deleteHandler) + { + delete handlerA; + return (wxEvtHandler*) NULL; + } + else + return handlerA; + } + else + return (wxEvtHandler *) NULL; } wxValidator *wxWindow::GetValidator() { - return m_windowValidator; + return m_windowValidator; } void wxWindow::SetValidator( const wxValidator& validator ) { - if (m_windowValidator) delete m_windowValidator; - m_windowValidator = validator.Clone(); - if (m_windowValidator) m_windowValidator->SetWindow(this); + if (m_windowValidator) delete m_windowValidator; + m_windowValidator = validator.Clone(); + if (m_windowValidator) m_windowValidator->SetWindow(this); } void wxWindow::SetClientObject( wxClientData *data ) { - if (m_clientObject) delete m_clientObject; - m_clientObject = data; + if (m_clientObject) delete m_clientObject; + m_clientObject = data; } wxClientData *wxWindow::GetClientObject() { - return m_clientObject; + return m_clientObject; } void wxWindow::SetClientData( void *data ) { - m_clientData = data; + m_clientData = data; } void *wxWindow::GetClientData() { - return m_clientData; + return m_clientData; } bool wxWindow::IsBeingDeleted() { - return FALSE; + return FALSE; } void wxWindow::SetId( wxWindowID id ) { - m_windowId = id; + m_windowId = id; } -wxWindowID wxWindow::GetId() +wxWindowID wxWindow::GetId() const { - return m_windowId; + return m_windowId; } void wxWindow::SetCursor( const wxCursor &cursor ) { - wxASSERT_MSG( (m_widget != NULL), "invalid window" ); + wxCHECK_RET( (m_widget != NULL), _T("invalid window") ); - if (m_cursor == NULL) - { - wxFAIL_MSG( "wxWindow::SetCursor m_cursor == NULL" ); - m_cursor = new wxCursor( wxCURSOR_ARROW ); - } + if (cursor.Ok()) + { + if (cursor == *m_cursor) return; + *m_cursor = cursor; + } + else + { + *m_cursor = *wxSTANDARD_CURSOR; + } - if (cursor.Ok()) - { - if (*((wxCursor*)&cursor) == m_cursor) return; - *m_cursor = cursor; - } - else - { - *m_cursor = *wxSTANDARD_CURSOR; - } + if ((m_widget) && (m_widget->window)) + gdk_window_set_cursor( m_widget->window, m_cursor->GetCursor() ); - if ((m_widget) && (m_widget->window)) - gdk_window_set_cursor( m_widget->window, m_cursor->GetCursor() ); + if ((m_wxwindow) && (m_wxwindow->window)) + gdk_window_set_cursor( m_wxwindow->window, m_cursor->GetCursor() ); +} - if ((m_wxwindow) && (m_wxwindow->window)) - gdk_window_set_cursor( m_wxwindow->window, m_cursor->GetCursor() ); +void wxWindow::WarpPointer( int WXUNUSED(x), int WXUNUSED(y) ) +{ + // TODO } void wxWindow::Refresh( bool eraseBackground, const wxRect *rect ) { - wxASSERT_MSG( (m_widget != NULL), "invalid window" ); + wxCHECK_RET( (m_widget != NULL), _T("invalid window") ); - if (eraseBackground && m_wxwindow && m_wxwindow->window) - { - if (rect) - gdk_window_clear_area( m_wxwindow->window, - rect->x, - rect->y, - rect->width, - rect->height ); - else - Clear(); - } - if (!rect) - { - if (m_wxwindow) + if (eraseBackground && m_wxwindow && m_wxwindow->window) { - int w = 0; - int h = 0; - GetClientSize( &w, &h ); - - GdkRectangle gdk_rect; - gdk_rect.x = 0; - gdk_rect.y = 0; - gdk_rect.width = w; - gdk_rect.height = h; - gtk_widget_draw( m_wxwindow, &gdk_rect ); + if (rect) + { + gdk_window_clear_area( m_wxwindow->window, + rect->x, rect->y, + rect->width, rect->height ); + } + else + { + gdk_window_clear( m_wxwindow->window ); + } } - } - else - { - GdkRectangle gdk_rect; - gdk_rect.x = rect->x; - gdk_rect.y = rect->y; - gdk_rect.width = rect->width; - gdk_rect.height = rect->height; - if (m_wxwindow) - gtk_widget_draw( m_wxwindow, &gdk_rect ); + if (!rect) + { + if (m_wxwindow) + gtk_widget_draw( m_wxwindow, (GdkRectangle*) NULL ); + else + gtk_widget_draw( m_widget, (GdkRectangle*) NULL ); + } else - gtk_widget_draw( m_widget, &gdk_rect ); - } + { + GdkRectangle gdk_rect; + gdk_rect.x = rect->x; + gdk_rect.y = rect->y; + gdk_rect.width = rect->width; + gdk_rect.height = rect->height; + + if (m_wxwindow) + gtk_widget_draw( m_wxwindow, &gdk_rect ); + else + gtk_widget_draw( m_widget, &gdk_rect ); + } } wxRegion wxWindow::GetUpdateRegion() const @@ -1974,31 +2518,70 @@ wxRegion wxWindow::GetUpdateRegion() const bool wxWindow::IsExposed( int x, int y) const { - return (m_updateRegion.Contains( x, y ) != wxOutRegion ); + return (m_updateRegion.Contains( x, y ) != wxOutRegion ); } bool wxWindow::IsExposed( int x, int y, int w, int h ) const { - return (m_updateRegion.Contains( x, y, w, h ) != wxOutRegion ); + return (m_updateRegion.Contains( x, y, w, h ) != wxOutRegion ); } bool wxWindow::IsExposed( const wxPoint& pt ) const { - return (m_updateRegion.Contains( pt.x, pt.y ) != wxOutRegion ); + return (m_updateRegion.Contains( pt.x, pt.y ) != wxOutRegion ); } bool wxWindow::IsExposed( const wxRect& rect ) const { - return (m_updateRegion.Contains( rect.x, rect.y, rect.width, rect.height ) != wxOutRegion ); + return (m_updateRegion.Contains( rect.x, rect.y, rect.width, rect.height ) != wxOutRegion ); } void wxWindow::Clear() { - wxCHECK_RET( m_widget != NULL, "invalid window" ); + wxCHECK_RET( m_widget != NULL, _T("invalid window") ); + + if (m_wxwindow && m_wxwindow->window) + { + gdk_window_clear( m_wxwindow->window ); + } +} + +#if wxUSE_TOOLTIPS +void wxWindow::SetToolTip( const wxString &tip ) +{ + if (m_toolTip) + { + m_toolTip->SetTip( tip ); + } + else + { + SetToolTip( new wxToolTip( tip ) ); + } + + // setting empty tooltip text does not remove the tooltip any more for + // wxMSW compatibility - use SetToolTip((wxToolTip *)NULL) for this +} + +void wxWindow::SetToolTip( wxToolTip *tip ) +{ + if (m_toolTip) + { + m_toolTip->SetTip( (char*) NULL ); + delete m_toolTip; + } + + m_toolTip = tip; - if (m_wxwindow && m_wxwindow->window) gdk_window_clear( m_wxwindow->window ); + if (m_toolTip) + m_toolTip->Apply( this ); } +void wxWindow::ApplyToolTip( GtkTooltips *tips, const wxChar *tip ) +{ + gtk_tooltips_set_tip( tips, GetConnectWidget(), wxConv_current->cWX2MB(tip), (gchar*) NULL ); +} +#endif // wxUSE_TOOLTIPS + wxColour wxWindow::GetBackgroundColour() const { return m_backgroundColour; @@ -2006,25 +2589,37 @@ wxColour wxWindow::GetBackgroundColour() const void wxWindow::SetBackgroundColour( const wxColour &colour ) { - wxCHECK_RET( m_widget != NULL, "invalid window" ); + wxCHECK_RET( m_widget != NULL, _T("invalid window") ); if (m_backgroundColour == colour) return; - - if (!m_backgroundColour.Ok()) - if (wxSystemSettings::GetSystemColour( wxSYS_COLOUR_BTNFACE ) == colour) return; - + m_backgroundColour = colour; if (!m_backgroundColour.Ok()) return; - - if (m_wxwindow) + + if (m_wxwindow && m_wxwindow->window) + { + /* wxMSW doesn't clear the window here. I don't do that + either to provide compatibility. call Clear() to do + the job. */ + + m_backgroundColour.CalcPixel( gdk_window_get_colormap( m_wxwindow->window ) ); + gdk_window_set_background( m_wxwindow->window, m_backgroundColour.GetColor() ); + } + + wxColour sysbg = wxSystemSettings::GetSystemColour( wxSYS_COLOUR_BTNFACE ); + + if (sysbg.Red() == colour.Red() && + sysbg.Green() == colour.Green() && + sysbg.Blue() == colour.Blue()) + { + m_backgroundColour = wxNullColour; + ApplyWidgetStyle(); + m_backgroundColour = sysbg; + } + else { - GdkWindow *window = m_wxwindow->window; - m_backgroundColour.CalcPixel( gdk_window_get_colormap( window ) ); - gdk_window_set_background( window, m_backgroundColour.GetColor() ); - gdk_window_clear( window ); + ApplyWidgetStyle(); } - - ApplyWidgetStyle(); } wxColour wxWindow::GetForegroundColour() const @@ -2034,54 +2629,66 @@ wxColour wxWindow::GetForegroundColour() const void wxWindow::SetForegroundColour( const wxColour &colour ) { - wxCHECK_RET( m_widget != NULL, "invalid window" ); + wxCHECK_RET( m_widget != NULL, _T("invalid window") ); if (m_foregroundColour == colour) return; - + m_foregroundColour = colour; if (!m_foregroundColour.Ok()) return; - - ApplyWidgetStyle(); + + wxColour sysbg = wxSystemSettings::GetSystemColour( wxSYS_COLOUR_BTNFACE ); + if (sysbg.Red() == colour.Red() && + sysbg.Green() == colour.Green() && + sysbg.Blue() == colour.Blue()) + { + m_backgroundColour = wxNullColour; + ApplyWidgetStyle(); + m_backgroundColour = sysbg; + } + else + { + ApplyWidgetStyle(); + } } GtkStyle *wxWindow::GetWidgetStyle() { - if (m_widgetStyle) gtk_style_unref( m_widgetStyle ); - - m_widgetStyle = - gtk_style_copy( - gtk_widget_get_style( m_widget ) ); - - return m_widgetStyle; + if (m_widgetStyle) gtk_style_unref( m_widgetStyle ); + + m_widgetStyle = + gtk_style_copy( + gtk_widget_get_style( m_widget ) ); + + return m_widgetStyle; } void wxWindow::SetWidgetStyle() { - GtkStyle *style = GetWidgetStyle(); - - gdk_font_unref( style->font ); - style->font = gdk_font_ref( m_font.GetInternalFont( 1.0 ) ); - - if (m_foregroundColour.Ok()) - { - m_foregroundColour.CalcPixel( gdk_window_get_colormap( m_widget->window ) ); - style->fg[GTK_STATE_NORMAL] = *m_foregroundColour.GetColor(); - style->fg[GTK_STATE_PRELIGHT] = *m_foregroundColour.GetColor(); - style->fg[GTK_STATE_ACTIVE] = *m_foregroundColour.GetColor(); - } - - if (m_backgroundColour.Ok()) - { - m_backgroundColour.CalcPixel( gdk_window_get_colormap( m_widget->window ) ); - style->bg[GTK_STATE_NORMAL] = *m_backgroundColour.GetColor(); - style->base[GTK_STATE_NORMAL] = *m_backgroundColour.GetColor(); - style->bg[GTK_STATE_PRELIGHT] = *m_backgroundColour.GetColor(); - style->base[GTK_STATE_PRELIGHT] = *m_backgroundColour.GetColor(); - style->bg[GTK_STATE_ACTIVE] = *m_backgroundColour.GetColor(); - style->base[GTK_STATE_ACTIVE] = *m_backgroundColour.GetColor(); - style->bg[GTK_STATE_INSENSITIVE] = *m_backgroundColour.GetColor(); - style->base[GTK_STATE_INSENSITIVE] = *m_backgroundColour.GetColor(); - } + GtkStyle *style = GetWidgetStyle(); + + gdk_font_unref( style->font ); + style->font = gdk_font_ref( m_font.GetInternalFont( 1.0 ) ); + + if (m_foregroundColour.Ok()) + { + m_foregroundColour.CalcPixel( gdk_window_get_colormap( m_widget->window ) ); + style->fg[GTK_STATE_NORMAL] = *m_foregroundColour.GetColor(); + style->fg[GTK_STATE_PRELIGHT] = *m_foregroundColour.GetColor(); + style->fg[GTK_STATE_ACTIVE] = *m_foregroundColour.GetColor(); + } + + if (m_backgroundColour.Ok()) + { + m_backgroundColour.CalcPixel( gdk_window_get_colormap( m_widget->window ) ); + style->bg[GTK_STATE_NORMAL] = *m_backgroundColour.GetColor(); + style->base[GTK_STATE_NORMAL] = *m_backgroundColour.GetColor(); + style->bg[GTK_STATE_PRELIGHT] = *m_backgroundColour.GetColor(); + style->base[GTK_STATE_PRELIGHT] = *m_backgroundColour.GetColor(); + style->bg[GTK_STATE_ACTIVE] = *m_backgroundColour.GetColor(); + style->base[GTK_STATE_ACTIVE] = *m_backgroundColour.GetColor(); + style->bg[GTK_STATE_INSENSITIVE] = *m_backgroundColour.GetColor(); + style->base[GTK_STATE_INSENSITIVE] = *m_backgroundColour.GetColor(); + } } void wxWindow::ApplyWidgetStyle() @@ -2090,191 +2697,228 @@ void wxWindow::ApplyWidgetStyle() bool wxWindow::Validate() { - wxCHECK_MSG( m_widget != NULL, FALSE, "invalid window" ); + wxCHECK_MSG( m_widget != NULL, FALSE, _T("invalid window") ); - wxNode *node = GetChildren()->First(); - while (node) - { - wxWindow *child = (wxWindow *)node->Data(); - if (child->GetValidator() && /* child->GetValidator()->Ok() && */ !child->GetValidator()->Validate(this)) - { return FALSE; } - node = node->Next(); - } - return TRUE; + wxNode *node = m_children.First(); + while (node) + { + wxWindow *child = (wxWindow *)node->Data(); + if (child->GetValidator() && /* child->GetValidator()->Ok() && */ !child->GetValidator()->Validate(this)) + { + return FALSE; + } + node = node->Next(); + } + return TRUE; } bool wxWindow::TransferDataToWindow() { - wxCHECK_MSG( m_widget != NULL, FALSE, "invalid window" ); + wxCHECK_MSG( m_widget != NULL, FALSE, _T("invalid window") ); - wxNode *node = GetChildren()->First(); - while (node) - { - wxWindow *child = (wxWindow *)node->Data(); - if (child->GetValidator() && /* child->GetValidator()->Ok() && */ - !child->GetValidator()->TransferToWindow() ) + wxNode *node = m_children.First(); + while (node) { - wxMessageBox( _("Application Error"), _("Could not transfer data to window"), wxOK|wxICON_EXCLAMATION ); - return FALSE; + wxWindow *child = (wxWindow *)node->Data(); + if (child->GetValidator() && /* child->GetValidator()->Ok() && */ + !child->GetValidator()->TransferToWindow() ) + { + wxMessageBox( _("Application Error"), _("Could not transfer data to window"), wxOK|wxICON_EXCLAMATION ); + return FALSE; + } + node = node->Next(); } - node = node->Next(); - } - return TRUE; + return TRUE; } bool wxWindow::TransferDataFromWindow() { - wxASSERT_MSG( (m_widget != NULL), "invalid window" ); + wxCHECK_MSG( m_widget != NULL, FALSE, _T("invalid window") ); - wxNode *node = GetChildren()->First(); - while (node) - { - wxWindow *child = (wxWindow *)node->Data(); - if ( child->GetValidator() && /* child->GetValidator()->Ok() && */ !child->GetValidator()->TransferFromWindow() ) - { return FALSE; } - node = node->Next(); - } - return TRUE; + wxNode *node = m_children.First(); + while (node) + { + wxWindow *child = (wxWindow *)node->Data(); + if ( child->GetValidator() && /* child->GetValidator()->Ok() && */ !child->GetValidator()->TransferFromWindow() ) + { + return FALSE; + } + node = node->Next(); + } + return TRUE; } void wxWindow::SetAcceleratorTable( const wxAcceleratorTable& accel ) { - m_acceleratorTable = accel; + m_acceleratorTable = accel; } void wxWindow::OnInitDialog( wxInitDialogEvent &WXUNUSED(event) ) { - TransferDataToWindow(); + TransferDataToWindow(); } void wxWindow::InitDialog() { - wxCHECK_RET( m_widget != NULL, "invalid window" ); + wxCHECK_RET( m_widget != NULL, _T("invalid window") ); - wxInitDialogEvent event(GetId()); - event.SetEventObject( this ); - GetEventHandler()->ProcessEvent(event); + wxInitDialogEvent event(GetId()); + event.SetEventObject( this ); + GetEventHandler()->ProcessEvent(event); } static void SetInvokingWindow( wxMenu *menu, wxWindow *win ) { - menu->SetInvokingWindow( win ); - wxNode *node = menu->m_items.First(); - while (node) - { - wxMenuItem *menuitem = (wxMenuItem*)node->Data(); - if (menuitem->IsSubMenu()) - SetInvokingWindow( menuitem->GetSubMenu(), win ); - node = node->Next(); - } + menu->SetInvokingWindow( win ); + wxNode *node = menu->GetItems().First(); + while (node) + { + wxMenuItem *menuitem = (wxMenuItem*)node->Data(); + if (menuitem->IsSubMenu()) + { + SetInvokingWindow( menuitem->GetSubMenu(), win ); + } + node = node->Next(); + } +} + +static gint gs_pop_x = 0; +static gint gs_pop_y = 0; + +static void pop_pos_callback( GtkMenu *menu, gint *x, gint *y, wxWindow *win ) +{ + win->ClientToScreen( &gs_pop_x, &gs_pop_y ); + *x = gs_pop_x; + *y = gs_pop_y; } -bool wxWindow::PopupMenu( wxMenu *menu, int WXUNUSED(x), int WXUNUSED(y) ) +bool wxWindow::PopupMenu( wxMenu *menu, int x, int y ) { - wxCHECK_MSG( m_widget != NULL, FALSE, "invalid window" ); + wxCHECK_MSG( m_widget != NULL, FALSE, _T("invalid window") ); + + wxCHECK_MSG( menu != NULL, FALSE, _T("invalid popup-menu") ); - wxCHECK_MSG( menu != NULL, FALSE, "invalid popup-menu" ); - - SetInvokingWindow( menu, this ); - gtk_menu_popup( + SetInvokingWindow( menu, this ); + + menu->UpdateUI(); + + gs_pop_x = x; + gs_pop_y = y; + + gtk_menu_popup( GTK_MENU(menu->m_menu), - (GtkWidget *)NULL, // parent menu shell - (GtkWidget *)NULL, // parent menu item - (GtkMenuPositionFunc)NULL, - NULL, // client data - 0, // button used to activate it - 0//gs_timeLastClick // the time of activation + (GtkWidget *) NULL, // parent menu shell + (GtkWidget *) NULL, // parent menu item + (GtkMenuPositionFunc) pop_pos_callback, + (gpointer) this, // client data + 0, // button used to activate it + 0 //gs_timeLastClick // the time of activation ); - return TRUE; + return TRUE; } +#if wxUSE_DRAG_AND_DROP + void wxWindow::SetDropTarget( wxDropTarget *dropTarget ) { - wxCHECK_RET( m_widget != NULL, "invalid window" ); + wxCHECK_RET( m_widget != NULL, _T("invalid window") ); - GtkWidget *dnd_widget = GetConnectWidget(); + GtkWidget *dnd_widget = GetConnectWidget(); - if (m_dropTarget) m_dropTarget->UnregisterWidget( dnd_widget ); + if (m_dropTarget) m_dropTarget->UnregisterWidget( dnd_widget ); - if (m_dropTarget) delete m_dropTarget; - m_dropTarget = dropTarget; + if (m_dropTarget) delete m_dropTarget; + m_dropTarget = dropTarget; - if (m_dropTarget) m_dropTarget->RegisterWidget( dnd_widget ); + if (m_dropTarget) m_dropTarget->RegisterWidget( dnd_widget ); } wxDropTarget *wxWindow::GetDropTarget() const { - return m_dropTarget; + return m_dropTarget; } +#endif + GtkWidget* wxWindow::GetConnectWidget() { - GtkWidget *connect_widget = m_widget; - if (m_wxwindow) connect_widget = m_wxwindow; + GtkWidget *connect_widget = m_widget; + if (m_wxwindow) connect_widget = m_wxwindow; - return connect_widget; + return connect_widget; } bool wxWindow::IsOwnGtkWindow( GdkWindow *window ) { - if (m_wxwindow) return (window == m_wxwindow->window); - return (window == m_widget->window); + if (m_wxwindow) return (window == m_wxwindow->window); + return (window == m_widget->window); } void wxWindow::SetFont( const wxFont &font ) { - wxCHECK_RET( m_widget != NULL, "invalid window" ); - - if (((wxFont*)&font)->Ok()) - m_font = font; - else - m_font = *wxSWISS_FONT; + wxCHECK_RET( m_widget != NULL, _T("invalid window") ); - ApplyWidgetStyle(); -} + if (m_font == font) return; + + if (((wxFont*)&font)->Ok()) + m_font = font; + else + m_font = *wxSWISS_FONT; -wxFont *wxWindow::GetFont() -{ - return &m_font; + wxColour sysbg = wxSystemSettings::GetSystemColour( wxSYS_COLOUR_BTNFACE ); + if (sysbg.Red() == m_backgroundColour.Red() && + sysbg.Green() == m_backgroundColour.Green() && + sysbg.Blue() == m_backgroundColour.Blue()) + { + m_backgroundColour = wxNullColour; + ApplyWidgetStyle(); + m_backgroundColour = sysbg; + } + else + { + ApplyWidgetStyle(); + } } void wxWindow::SetWindowStyleFlag( long flag ) { - m_windowStyle = flag; + m_windowStyle = flag; } long wxWindow::GetWindowStyleFlag() const { - return m_windowStyle; + return m_windowStyle; } void wxWindow::CaptureMouse() { - wxCHECK_RET( m_widget != NULL, "invalid window" ); + wxCHECK_RET( m_widget != NULL, _T("invalid window") ); - wxCHECK_RET( g_capturing == FALSE, "CaptureMouse called twice" ); + wxCHECK_RET( g_capturing == FALSE, _T("CaptureMouse called twice") ); - GtkWidget *connect_widget = GetConnectWidget(); - gtk_grab_add( connect_widget ); - gdk_pointer_grab ( connect_widget->window, FALSE, - (GdkEventMask) - (GDK_BUTTON_PRESS_MASK | - GDK_BUTTON_RELEASE_MASK | - GDK_POINTER_MOTION_MASK), - (GdkWindow *) NULL, (GdkCursor *) NULL, GDK_CURRENT_TIME ); - g_capturing = TRUE; + GtkWidget *connect_widget = GetConnectWidget(); + gtk_grab_add( connect_widget ); + gdk_pointer_grab( connect_widget->window, FALSE, + (GdkEventMask) + (GDK_BUTTON_PRESS_MASK | + GDK_BUTTON_RELEASE_MASK | + GDK_POINTER_MOTION_MASK), + (GdkWindow *) NULL, + (GdkCursor *) NULL, + GDK_CURRENT_TIME ); + g_capturing = TRUE; } void wxWindow::ReleaseMouse() { - wxCHECK_RET( m_widget != NULL, "invalid window" ); + wxCHECK_RET( m_widget != NULL, _T("invalid window") ); - wxCHECK_RET( g_capturing == TRUE, "ReleaseMouse called twice" ); + wxCHECK_RET( g_capturing == TRUE, _T("ReleaseMouse called twice") ); - GtkWidget *connect_widget = GetConnectWidget(); - gtk_grab_remove( connect_widget ); - gdk_pointer_ungrab ( GDK_CURRENT_TIME ); - g_capturing = FALSE; + GtkWidget *connect_widget = GetConnectWidget(); + gtk_grab_remove( connect_widget ); + gdk_pointer_ungrab ( GDK_CURRENT_TIME ); + g_capturing = FALSE; } void wxWindow::SetTitle( const wxString &WXUNUSED(title) ) @@ -2283,214 +2927,219 @@ void wxWindow::SetTitle( const wxString &WXUNUSED(title) ) wxString wxWindow::GetTitle() const { - return (wxString&)m_windowName; + return (wxString&)m_windowName; } wxString wxWindow::GetLabel() const { - return GetTitle(); + return GetTitle(); } void wxWindow::SetName( const wxString &name ) { - m_windowName = name; + m_windowName = name; } wxString wxWindow::GetName() const { - return (wxString&)m_windowName; + return (wxString&)m_windowName; } bool wxWindow::IsShown() const { - return m_isShown; + return m_isShown; } bool wxWindow::IsRetained() { - return FALSE; + return FALSE; } wxWindow *wxWindow::FindWindow( long id ) { - if (id == m_windowId) return this; - wxNode *node = m_children.First(); - while (node) - { - wxWindow *child = (wxWindow*)node->Data(); - wxWindow *res = child->FindWindow( id ); - if (res) return res; - node = node->Next(); - } - return (wxWindow *) NULL; + if (id == m_windowId) return this; + wxNode *node = m_children.First(); + while (node) + { + wxWindow *child = (wxWindow*)node->Data(); + wxWindow *res = child->FindWindow( id ); + if (res) return res; + node = node->Next(); + } + return (wxWindow *) NULL; } wxWindow *wxWindow::FindWindow( const wxString& name ) { - if (name == m_windowName) return this; - wxNode *node = m_children.First(); - while (node) - { - wxWindow *child = (wxWindow*)node->Data(); - wxWindow *res = child->FindWindow( name ); - if (res) return res; - node = node->Next(); - } - return (wxWindow *) NULL; + if (name == m_windowName) return this; + wxNode *node = m_children.First(); + while (node) + { + wxWindow *child = (wxWindow*)node->Data(); + wxWindow *res = child->FindWindow( name ); + if (res) return res; + node = node->Next(); + } + return (wxWindow *) NULL; } void wxWindow::SetScrollbar( int orient, int pos, int thumbVisible, int range, bool refresh ) { - wxASSERT_MSG( (m_widget != NULL), "invalid window" ); - - wxASSERT_MSG( (m_wxwindow != NULL), "window needs client area" ); + wxCHECK_RET( m_widget != NULL, _T("invalid window") ); - if (!m_wxwindow) return; - - m_hasScrolling = TRUE; + wxCHECK_RET( m_wxwindow != NULL, _T("window needs client area for scrolling") ); - if (orient == wxHORIZONTAL) - { - float fpos = (float)pos; - float frange = (float)range; - float fthumb = (float)thumbVisible; + m_hasScrolling = TRUE; - if ((fabs(frange-m_hAdjust->upper) < 0.2) && - (fabs(fthumb-m_hAdjust->page_size) < 0.2)) + if (orient == wxHORIZONTAL) { - SetScrollPos( orient, pos, refresh ); - return; - } - - m_oldHorizontalPos = fpos; + float fpos = (float)pos; + float frange = (float)range; + float fthumb = (float)thumbVisible; + if (fpos > frange-fthumb) fpos = frange-fthumb; + if (fpos < 0.0) fpos = 0.0; + + if ((fabs(frange-m_hAdjust->upper) < 0.2) && + (fabs(fthumb-m_hAdjust->page_size) < 0.2)) + { + SetScrollPos( orient, pos, refresh ); + return; + } - m_hAdjust->lower = 0.0; - m_hAdjust->upper = frange; - m_hAdjust->value = fpos; - m_hAdjust->step_increment = 1.0; - m_hAdjust->page_increment = (float)(wxMax(fthumb,0)); - m_hAdjust->page_size = fthumb; - } - else - { - float fpos = (float)pos; - float frange = (float)range; - float fthumb = (float)thumbVisible; + m_oldHorizontalPos = fpos; - if ((fabs(frange-m_vAdjust->upper) < 0.2) && - (fabs(fthumb-m_vAdjust->page_size) < 0.2)) - { - SetScrollPos( orient, pos, refresh ); - return; + m_hAdjust->lower = 0.0; + m_hAdjust->upper = frange; + m_hAdjust->value = fpos; + m_hAdjust->step_increment = 1.0; + m_hAdjust->page_increment = (float)(wxMax(fthumb,0)); + m_hAdjust->page_size = fthumb; } + else + { + float fpos = (float)pos; + float frange = (float)range; + float fthumb = (float)thumbVisible; + if (fpos > frange-fthumb) fpos = frange-fthumb; + if (fpos < 0.0) fpos = 0.0; + + if ((fabs(frange-m_vAdjust->upper) < 0.2) && + (fabs(fthumb-m_vAdjust->page_size) < 0.2)) + { + SetScrollPos( orient, pos, refresh ); + return; + } - m_oldVerticalPos = fpos; + m_oldVerticalPos = fpos; - m_vAdjust->lower = 0.0; - m_vAdjust->upper = frange; - m_vAdjust->value = fpos; - m_vAdjust->step_increment = 1.0; - m_vAdjust->page_increment = (float)(wxMax(fthumb,0)); - m_vAdjust->page_size = fthumb; - } + m_vAdjust->lower = 0.0; + m_vAdjust->upper = frange; + m_vAdjust->value = fpos; + m_vAdjust->step_increment = 1.0; + m_vAdjust->page_increment = (float)(wxMax(fthumb,0)); + m_vAdjust->page_size = fthumb; + } - if (m_wxwindow->window) - { - if (orient == wxHORIZONTAL) - gtk_signal_emit_by_name( GTK_OBJECT(m_hAdjust), "changed" ); - else - gtk_signal_emit_by_name( GTK_OBJECT(m_vAdjust), "changed" ); + if (m_wxwindow->window) + { + if (orient == wxHORIZONTAL) + gtk_signal_emit_by_name( GTK_OBJECT(m_hAdjust), "changed" ); + else + gtk_signal_emit_by_name( GTK_OBJECT(m_vAdjust), "changed" ); - gtk_widget_set_usize( m_widget, m_width, m_height ); - } + gtk_widget_set_usize( m_widget, m_width, m_height ); + } } void wxWindow::SetScrollPos( int orient, int pos, bool WXUNUSED(refresh) ) { - wxASSERT_MSG( (m_widget != NULL), "invalid window" ); + wxCHECK_RET( m_widget != NULL, _T("invalid window") ); - wxASSERT_MSG( (m_wxwindow != NULL), "window needs client area" ); + wxCHECK_RET( m_wxwindow != NULL, _T("window needs client area for scrolling") ); - if (!m_wxwindow) return; + if (orient == wxHORIZONTAL) + { + float fpos = (float)pos; + if (fpos > m_hAdjust->upper - m_hAdjust->page_size) fpos = m_hAdjust->upper - m_hAdjust->page_size; + if (fpos < 0.0) fpos = 0.0; + m_oldHorizontalPos = fpos; - if (orient == wxHORIZONTAL) - { - float fpos = (float)pos; - m_oldHorizontalPos = fpos; + if (fabs(fpos-m_hAdjust->value) < 0.2) return; + m_hAdjust->value = fpos; + } + else + { + float fpos = (float)pos; + if (fpos > m_vAdjust->upper - m_vAdjust->page_size) fpos = m_vAdjust->upper - m_vAdjust->page_size; + if (fpos < 0.0) fpos = 0.0; + m_oldVerticalPos = fpos; - if (fabs(fpos-m_hAdjust->value) < 0.2) return; - m_hAdjust->value = fpos; - } - else - { - float fpos = (float)pos; - m_oldVerticalPos = fpos; - if (fabs(fpos-m_vAdjust->value) < 0.2) return; - m_vAdjust->value = fpos; - } + if (fabs(fpos-m_vAdjust->value) < 0.2) return; + m_vAdjust->value = fpos; + } - if (!m_isScrolling) - { - if (m_wxwindow->window) + if (!m_isScrolling) { - if (orient == wxHORIZONTAL) - gtk_signal_emit_by_name( GTK_OBJECT(m_hAdjust), "value_changed" ); - else - gtk_signal_emit_by_name( GTK_OBJECT(m_vAdjust), "value_changed" ); + if (m_wxwindow->window) + { + if (orient == wxHORIZONTAL) + gtk_signal_emit_by_name( GTK_OBJECT(m_hAdjust), "value_changed" ); + else + gtk_signal_emit_by_name( GTK_OBJECT(m_vAdjust), "value_changed" ); + } } - } } int wxWindow::GetScrollThumb( int orient ) const { - wxASSERT_MSG( (m_widget != NULL), "invalid window" ); + wxCHECK_MSG( m_widget != NULL, 0, _T("invalid window") ); - wxASSERT_MSG( (m_wxwindow != NULL), "window needs client area" ); + wxCHECK_MSG( m_wxwindow != NULL, 0, _T("window needs client area for scrolling") ); - if (!m_wxwindow) return 0; - - if (orient == wxHORIZONTAL) - return (int)(m_hAdjust->page_size+0.5); - else - return (int)(m_vAdjust->page_size+0.5); + if (orient == wxHORIZONTAL) + return (int)(m_hAdjust->page_size+0.5); + else + return (int)(m_vAdjust->page_size+0.5); } int wxWindow::GetScrollPos( int orient ) const { - wxASSERT_MSG( (m_widget != NULL), "invalid window" ); + wxCHECK_MSG( m_widget != NULL, 0, _T("invalid window") ); - wxASSERT_MSG( (m_wxwindow != NULL), "window needs client area" ); + wxCHECK_MSG( m_wxwindow != NULL, 0, _T("window needs client area for scrolling") ); - if (!m_wxwindow) return 0; - - if (orient == wxHORIZONTAL) - return (int)(m_hAdjust->value+0.5); - else - return (int)(m_vAdjust->value+0.5); + if (orient == wxHORIZONTAL) + return (int)(m_hAdjust->value+0.5); + else + return (int)(m_vAdjust->value+0.5); } int wxWindow::GetScrollRange( int orient ) const { - wxASSERT_MSG( (m_widget != NULL), "invalid window" ); + wxCHECK_MSG( m_widget != NULL, 0, _T("invalid window") ); - wxASSERT_MSG( (m_wxwindow != NULL), "window needs client area" ); + wxCHECK_MSG( m_wxwindow != NULL, 0, _T("window needs client area for scrolling") ); - if (!m_wxwindow) return 0; - - if (orient == wxHORIZONTAL) - return (int)(m_hAdjust->upper+0.5); - else - return (int)(m_vAdjust->upper+0.5); + if (orient == wxHORIZONTAL) + return (int)(m_hAdjust->upper+0.5); + else + return (int)(m_vAdjust->upper+0.5); } void wxWindow::ScrollWindow( int dx, int dy, const wxRect* WXUNUSED(rect) ) { - wxASSERT_MSG( (m_widget != NULL), "invalid window" ); + wxCHECK_RET( m_widget != NULL, _T("invalid window") ); - wxASSERT_MSG( (m_wxwindow != NULL), "window needs client area" ); + wxCHECK_RET( m_wxwindow != NULL, _T("window needs client area for scrolling") ); - if (!m_wxwindow) return; + wxNode *node = m_children.First(); + while (node) + { + wxWindow *child = (wxWindow*) node->Data(); + child->Move( child->m_x + dx, child->m_y + dy ); + node = node->Next(); + } int cw = 0; int ch = 0; @@ -2500,8 +3149,8 @@ void wxWindow::ScrollWindow( int dx, int dy, const wxRect* WXUNUSED(rect) ) int h = ch - abs(dy); if ((h < 0) || (w < 0)) { - Refresh(); - return; + Refresh(); + return; } int s_x = 0; int s_y = 0; @@ -2511,15 +3160,15 @@ void wxWindow::ScrollWindow( int dx, int dy, const wxRect* WXUNUSED(rect) ) int d_y = 0; if (dx > 0) d_x = dx; if (dy > 0) d_y = dy; - + if (!m_scrollGC) { - m_scrollGC = gdk_gc_new( m_wxwindow->window ); - gdk_gc_set_exposures( m_scrollGC, TRUE ); + m_scrollGC = gdk_gc_new( m_wxwindow->window ); + gdk_gc_set_exposures( m_scrollGC, TRUE ); } - + gdk_window_copy_area( m_wxwindow->window, m_scrollGC, d_x, d_y, - m_wxwindow->window, s_x, s_y, w, h ); + m_wxwindow->window, s_x, s_y, w, h ); wxRect rect; if (dx < 0) rect.x = cw+dx; else rect.x = 0; @@ -2750,7 +3399,7 @@ bool wxWindow::DoPhase(int phase) { noChanges = 0; noFailures = 0; - wxNode *node = GetChildren()->First(); + wxNode *node = m_children.First(); while (node) { wxWindow *child = (wxWindow *)node->Data(); @@ -2795,7 +3444,7 @@ void wxWindow::ResetConstraints() constr->centreX.SetDone(FALSE); constr->centreY.SetDone(FALSE); } - wxNode *node = GetChildren()->First(); + wxNode *node = m_children.First(); while (node) { wxWindow *win = (wxWindow *)node->Data(); @@ -2833,28 +3482,26 @@ void wxWindow::SetConstraintSizes(bool recurse) } else if (constr) { - char *windowClass = this->GetClassInfo()->GetClassName(); + wxChar *windowClass = this->GetClassInfo()->GetClassName(); wxString winName; - if (GetName() == "") - winName = _("unnamed"); + if (GetName() == _T("")) + winName = _T("unnamed"); else winName = GetName(); - wxDebugMsg(_("Constraint(s) not satisfied for window of type %s, name %s:\n"), (const char *)windowClass, (const char *)winName); - if (!constr->left.GetDone()) - wxDebugMsg(_(" unsatisfied 'left' constraint.\n")); - if (!constr->right.GetDone()) - wxDebugMsg(_(" unsatisfied 'right' constraint.\n")); - if (!constr->width.GetDone()) - wxDebugMsg(_(" unsatisfied 'width' constraint.\n")); - if (!constr->height.GetDone()) - wxDebugMsg(_(" unsatisfied 'height' constraint.\n")); - wxDebugMsg(_("Please check constraints: try adding AsIs() constraints.\n")); + wxLogDebug( _T("Constraint(s) not satisfied for window of type %s, name %s:\n"), + (const wxChar *)windowClass, + (const wxChar *)winName); + if (!constr->left.GetDone()) wxLogDebug( _T(" unsatisfied 'left' constraint.\n") ); + if (!constr->right.GetDone()) wxLogDebug( _T(" unsatisfied 'right' constraint.\n") ); + if (!constr->width.GetDone()) wxLogDebug( _T(" unsatisfied 'width' constraint.\n") ); + if (!constr->height.GetDone()) wxLogDebug( _T(" unsatisfied 'height' constraint.\n") ); + wxLogDebug( _T("Please check constraints: try adding AsIs() constraints.\n") ); } if (recurse) { - wxNode *node = GetChildren()->First(); + wxNode *node = m_children.First(); while (node) { wxWindow *win = (wxWindow *)node->Data(); @@ -2969,8 +3616,8 @@ void wxWindow::GetClientSizeConstraint(int *w, int *h) const void wxWindow::GetPositionConstraint(int *x, int *y) const { - wxLayoutConstraints *constr = GetConstraints(); - if (constr) + wxLayoutConstraints *constr = GetConstraints(); + if (constr) { *x = constr->left.GetValue(); *y = constr->top.GetValue(); @@ -2979,12 +3626,3 @@ void wxWindow::GetPositionConstraint(int *x, int *y) const GetPosition(x, y); } -bool wxWindow::AcceptsFocus() const -{ - return IsEnabled() && IsShown(); -} - -void wxWindow::OnIdle(wxIdleEvent& WXUNUSED(event) ) -{ - UpdateWindowUI(); -}