#ifdef __GNUG__
-#pragma implementation "window.h"
+ #pragma implementation "window.h"
#endif
#include "wx/defs.h"
#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 "wx/log.h"
-#include "gdk/gdkprivate.h"
-#include "gdk/gdkkeysyms.h"
#include <math.h>
+#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
//-----------------------------------------------------------------------------
#endif
#endif
+//-----------------------------------------------------------------------------
+// (debug)
+//-----------------------------------------------------------------------------
+
+#ifdef __WXDEBUG__
+
+static gint gtk_debug_focus_in_callback( GtkWidget *WXUNUSED(widget),
+ GdkEvent *WXUNUSED(event),
+ const char *name )
+{
+ printf( "FOCUS NOW AT: " );
+ printf( name );
+ printf( "\n" );
+
+ return FALSE;
+}
+
+void debug_focus_in( GtkWidget* widget, const char* name, const char *window )
+{
+ return;
+
+ wxString tmp = name;
+ tmp += " FROM ";
+ tmp += window;
+
+ char *s = new char[tmp.Length()+1];
+
+ strcpy( s, WXSTRINGCAST tmp );
+
+ gtk_signal_connect( GTK_OBJECT(widget), "focus_in_event",
+ GTK_SIGNAL_FUNC(gtk_debug_focus_in_callback), (gpointer)s );
+}
+
+#endif
+
//-----------------------------------------------------------------------------
// data
//-----------------------------------------------------------------------------
-extern wxList wxPendingDelete;
-extern wxList wxTopLevelWindows;
-extern bool g_blockEventsOnDrag;
-extern bool g_blockEventsOnScroll;
-static bool g_capturing = FALSE;
+extern wxList wxPendingDelete;
+extern wxList wxTopLevelWindows;
+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
}
//-----------------------------------------------------------------------------
-// "key_press_event"
+// "key_press_event" from any window
//-----------------------------------------------------------------------------
static gint gtk_window_key_press_callback( GtkWidget *widget, GdkEventKey *gdk_event, wxWindow *win )
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_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;
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);
}
}
+ // 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)
+ {
+ gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "key_press_event" );
+ }
+
+ return ret;
+}
+
+//-----------------------------------------------------------------------------
+// "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 );
+
+ bool ret = win->GetEventHandler()->ProcessEvent( 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_release_event" );
}
return ret;
while (node)
{
wxWindow *child = (wxWindow*)node->Data();
- 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))
+
+ 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();
}
}
+ wxPoint pt(win->GetClientAreaOrigin());
+ event.m_x -= pt.x;
+ event.m_y -= pt.y;
+
event.SetEventObject( win );
gs_timeLastClick = gdk_event->time;
while (node)
{
wxWindow *child = (wxWindow*)node->Data();
- 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))
+
+ 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();
}
}
+ wxPoint pt(win->GetClientAreaOrigin());
+ event.m_x -= pt.x;
+ event.m_y -= pt.y;
+
event.SetEventObject( win );
if (win->GetEventHandler()->ProcessEvent( event ))
static gint gtk_window_motion_notify_callback( GtkWidget *widget, GdkEventMotion *gdk_event, wxWindow *win )
{
+ 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;
+ }
+
if (!win->IsOwnGtkWindow( gdk_event->window )) return TRUE;
if (g_blockEventsOnDrag) return TRUE;
if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
printf( win->GetClassInfo()->GetClassName() );
printf( ".\n" );
-*/
+*/
wxMouseEvent event( wxEVT_MOTION );
event.m_shiftDown = (gdk_event->state & GDK_SHIFT_MASK);
while (node)
{
wxWindow *child = (wxWindow*)node->Data();
- 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))
+
+ 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();
}
}
+ wxPoint pt(win->GetClientAreaOrigin());
+ event.m_x -= pt.x;
+ event.m_y -= pt.y;
+
event.SetEventObject( win );
if (win->GetEventHandler()->ProcessEvent( event ))
static gint gtk_window_focus_in_callback( GtkWidget *widget, GdkEvent *WXUNUSED(event), wxWindow *win )
{
if (g_blockEventsOnDrag) return TRUE;
+
+ g_focusWindow = win;
+
if (win->m_wxwindow)
{
if (GTK_WIDGET_CAN_FOCUS(win->m_wxwindow))
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 ((widget->window) && (win->m_cursor))
+ gdk_window_set_cursor( widget->window, win->m_cursor->GetCursor() );
+
+ if (widget->window != gdk_event->window) return TRUE;
+
if (!win->HasVMT()) return TRUE;
/*
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_x = (long)x;
event.m_y = (long)y;
-
+
+ wxPoint pt(win->GetClientAreaOrigin());
+ event.m_x -= pt.x;
+ event.m_y -= pt.y;
+
if (win->GetEventHandler()->ProcessEvent( event ))
gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "enter_notify_event" );
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 ((widget->window) && (win->m_cursor))
+ gdk_window_set_cursor( widget->window, wxSTANDARD_CURSOR->GetCursor() );
+
+ if (widget->window != gdk_event->window) return TRUE;
+
if (!win->HasVMT()) return TRUE;
/*
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_x = (long)x;
event.m_y = (long)y;
-
+
+ wxPoint pt(win->GetClientAreaOrigin());
+ event.m_x -= pt.x;
+ event.m_y -= pt.y;
+
if (win->GetEventHandler()->ProcessEvent( event ))
gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "leave_notify_event" );
static gint gtk_scrollbar_button_press_callback( GtkRange *WXUNUSED(widget),
GdkEventButton *WXUNUSED(gdk_event),
- wxWindow *win )
+ wxWindow *win )
{
+// 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;
static gint gtk_scrollbar_button_release_callback( GtkRange *widget,
GdkEventButton *WXUNUSED(gdk_event),
- wxWindow *win )
+ wxWindow *win )
{
-// don't test here as we can reelase the mouse while being over
+// 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;
// 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 );
+ child->m_x,
+ child->m_y );
gtk_widget_set_usize( GTK_WIDGET(child->m_widget),
child->m_width,
- child->m_height );
+ child->m_height );
+
+ if (wxIS_KIND_OF(parent,wxFrame))
+ {
+ parent->m_sizeSet = FALSE;
+ }
+
+ 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;
}
//-----------------------------------------------------------------------------
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()
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_clientObject = (wxClientData*) NULL;
m_clientData = NULL;
+
+ m_isStaticBox = FALSE;
+ m_acceptsFocus = FALSE;
+
+#if wxUSE_TOOLTIPS
+ m_toolTip = (wxToolTip*) NULL;
+#endif // wxUSE_TOOLTIPS
}
wxWindow::wxWindow( wxWindow *parent, wxWindowID id,
m_widget = gtk_scrolled_window_new( (GtkAdjustment *) NULL, (GtkAdjustment *) NULL );
GTK_WIDGET_UNSET_FLAGS( m_widget, GTK_CAN_FOCUS );
+#ifdef __WXDEBUG__
+ debug_focus_in( m_widget, "wxWindow::m_widget", name );
+#endif
+
GtkScrolledWindow *s_window = GTK_SCROLLED_WINDOW(m_widget);
+#ifdef __WXDEBUG__
+ debug_focus_in( s_window->hscrollbar, "wxWindow::hsrcollbar", name );
+ debug_focus_in( s_window->vscrollbar, "wxWindow::vsrcollbar", name );
+#endif
+
GtkScrolledWindowClass *scroll_class = GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT(m_widget)->klass );
scroll_class->scrollbar_spacing = 0;
m_wxwindow = gtk_myfixed_new();
+#ifdef __WXDEBUG__
+ debug_focus_in( m_wxwindow, "wxWindow::m_wxwindow", name );
+#endif
+
#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);
GtkViewport *viewport = GTK_VIEWPORT(s_window->viewport);
#endif
+#ifdef __WXDEBUG__
+ debug_focus_in( GTK_WIDGET(viewport), "wxWindow::viewport", name );
+#endif
+
if (m_windowStyle & wxRAISED_BORDER)
{
gtk_viewport_set_shadow_type( viewport, GTK_SHADOW_OUT );
gtk_viewport_set_shadow_type( viewport, GTK_SHADOW_NONE );
}
- 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;
+ }
// 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) );
{
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 );
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;
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)
{
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_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_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), "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), "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 );
+ gtk_signal_connect( GTK_OBJECT(m_wxwindow), "draw",
+ GTK_SIGNAL_FUNC(gtk_window_draw_callback), (gpointer)this );
}
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 );
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 );
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()
}
}
-void wxWindow::SetSize( int x, int y, int width, int height, int sizeFlags )
+void wxWindow::DoSetSize( 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;
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;
+
+ wxPoint pt( m_parent->GetClientAreaOrigin() );
+ gtk_myfixed_move( GTK_MYFIXED(m_parent->m_wxwindow), m_widget, m_x+pt.x-border, m_y+pt.y-border );
+
+ gtk_widget_set_usize( m_widget, m_width+2*border, m_height+2*border );
+ }
+ else
+ {
+ 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 );
+ }
}
m_sizeSet = TRUE;
m_resizing = FALSE;
}
-void wxWindow::SetSize( int width, int height )
-{
- SetSize( -1, -1, width, height, wxSIZE_USE_EXISTING );
-}
-
-void wxWindow::Move( int x, int y )
+void wxWindow::OnInternalIdle()
{
- 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), "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" );
+ wxCHECK_RET( (m_widget != NULL), "invalid window" );
- if (!m_wxwindow)
- {
- SetSize( width, height );
- }
- else
- {
- int dw = 0;
- int dh = 0;
-
- if (!m_hasScrolling)
+ if (!m_wxwindow)
{
- 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;
- }
+ 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;
+
+ 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 );
#ifdef NEW_GTK_SCROLL_CODE
- GtkWidget *viewport = scroll_window->child;
+ GtkWidget *viewport = scroll_window->child;
#else
- GtkWidget *viewport = scroll_window->viewport;
+ GtkWidget *viewport = scroll_window->viewport;
#endif
- GtkStyleClass *viewport_class = viewport->style->klass;
+ GtkStyleClass *viewport_class = viewport->style->klass;
- GtkWidget *hscrollbar = scroll_window->hscrollbar;
- GtkWidget *vscrollbar = scroll_window->vscrollbar;
+ 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;
- }
+ 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 += vscrollbar->allocation.width;
- dw += scroll_class->scrollbar_spacing;
- }
+ if (scroll_window->vscrollbar_visible)
+ {
+ dw += vscrollbar->allocation.width;
+ dw += scroll_class->scrollbar_spacing;
+ }
- if (scroll_window->hscrollbar_visible)
- {
- dh += hscrollbar->allocation.height;
- dw += scroll_class->scrollbar_spacing;
- }
- }
+ if (scroll_window->hscrollbar_visible)
+ {
+ dh += hscrollbar->allocation.height;
+ dw += scroll_class->scrollbar_spacing;
+ }
+ }
- SetSize( width+dw, height+dh );
- }
+ SetSize( width+dw, height+dh );
+ }
}
void wxWindow::GetClientSize( int *width, int *height ) const
{
- wxASSERT_MSG( (m_widget != NULL), "invalid window" );
+ wxCHECK_RET( (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;
-
- if (!m_hasScrolling)
+ if (!m_wxwindow)
{
- 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;
- }
+ 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;
+
+ 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 );
#ifdef NEW_GTK_SCROLL_CODE
- GtkWidget *viewport = scroll_window->child;
+ GtkWidget *viewport = scroll_window->child;
#else
- GtkWidget *viewport = scroll_window->viewport;
+ GtkWidget *viewport = scroll_window->viewport;
#endif
- GtkStyleClass *viewport_class = viewport->style->klass;
+ 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;
+ }
- if (scroll_window->vscrollbar_visible)
- {
-// dw += vscrollbar->allocation.width;
- dw += 15; // range.slider_width = 11 + 2*2pts edge
- dw += scroll_class->scrollbar_spacing;
- }
+ if (scroll_window->vscrollbar_visible)
+ {
+// dw += vscrollbar->allocation.width;
+ dw += 15; // range.slider_width = 11 + 2*2pts edge
+ dw += scroll_class->scrollbar_spacing;
+ }
- if (scroll_window->hscrollbar_visible)
- {
-// dh += hscrollbar->allocation.height;
- dh += 15;
- dh += scroll_class->scrollbar_spacing;
- }
- }
+ if (scroll_window->hscrollbar_visible)
+ {
+// 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), "invalid window" );
if (x) (*x) = m_x;
if (y) (*y) = m_y;
void wxWindow::ClientToScreen( int *x, int *y )
{
- wxASSERT_MSG( (m_widget != NULL), "invalid window" );
+ wxCHECK_RET( (m_widget != NULL), "invalid window" );
GdkWindow *source = (GdkWindow *) NULL;
if (m_wxwindow)
void wxWindow::ScreenToClient( int *x, int *y )
{
- wxASSERT_MSG( (m_widget != NULL), "invalid window" );
+ wxCHECK_RET( (m_widget != NULL), "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;
+ 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), "invalid window" );
- int x = m_x;
- int y = m_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;
- }
+ 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 );
+ Move( x, y );
}
void wxWindow::Fit()
{
- wxASSERT_MSG( (m_widget != NULL), "invalid window" );
+ wxCHECK_RET( (m_widget != NULL), "invalid window" );
- 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;
+ 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), "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) )
bool wxWindow::Show( bool show )
{
- wxASSERT_MSG( (m_widget != NULL), "invalid window" );
+ wxCHECK_MSG( (m_widget != NULL), FALSE, "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), "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, "invalid window" );
- if (!m_font.Ok())
- {
- wxFAIL_MSG( "invalid font" );
- return -1;
- }
+ wxCHECK_MSG( m_font.Ok(), 12, "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, "invalid window" );
- if (!m_font.Ok())
- {
- wxFAIL_MSG( "invalid font" );
- return -1;
- }
+ wxCHECK_MSG( m_font.Ok(), 8, "invalid font" );
GdkFont *font = m_font.GetInternalFont( 1.0 );
+
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;
- if (!fontToUse.Ok())
- {
- wxFAIL_MSG( "invalid font" );
- return;
- }
- wxASSERT_MSG( (m_font.Ok()), "invalid font" );
+ wxCHECK_RET( fontToUse.Ok(), "invalid font" );
GdkFont *font = fontToUse.GetInternalFont( 1.0 );
if (x) (*x) = gdk_string_width( font, string );
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), "invalid window" );
GtkWidget *connect_widget = GetConnectWidget();
if (connect_widget)
{
- if (GTK_WIDGET_CAN_FOCUS(connect_widget) && !GTK_WIDGET_HAS_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), "invalid window" );
+ wxCHECK_RET( (child != NULL), "invalid child" );
m_children.Append( child );
}
wxWindow *wxWindow::ReParent( wxWindow *newParent )
{
- wxWindow *oldParent = GetParent();
+ wxCHECK_MSG( (m_widget != NULL), (wxWindow*) NULL, "invalid window" );
- if (oldParent) oldParent->RemoveChild( this );
+ wxWindow *oldParent = GetParent();
- gtk_widget_unparent( m_widget );
+ if (oldParent) oldParent->RemoveChild( this );
- if (newParent)
- {
- newParent->AddChild( this );
- (newParent->m_insertCallback)( newParent, this );
- }
+ gtk_widget_unparent( m_widget );
- return oldParent;
+ if (newParent)
+ {
+ newParent->AddChild( this );
+ (newParent->m_insertCallback)( newParent, this );
+ }
+
+ return oldParent;
}
void wxWindow::RemoveChild( wxWindow *child )
void wxWindow::Raise()
{
- wxASSERT_MSG( (m_widget != NULL), "invalid window" );
+ wxCHECK_RET( (m_widget != NULL), "invalid 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), "invalid window" );
if (m_widget) gdk_window_lower( m_widget->window );
}
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() 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), "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 ( 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), "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
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" );
- if (m_wxwindow && m_wxwindow->window) gdk_window_clear( m_wxwindow->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_toolTip)
+ m_toolTip->Apply( this );
+}
+
+void wxWindow::ApplyToolTip( GtkTooltips *tips, const char *tip )
+{
+ gtk_tooltips_set_tip( tips, GetConnectWidget(), tip, (gchar*) NULL );
+}
+#endif // wxUSE_TOOLTIPS
+
wxColour wxWindow::GetBackgroundColour() const
{
return m_backgroundColour;
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)
{
- 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 );
+ /* 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() );
}
- 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();
+ }
}
wxColour wxWindow::GetForegroundColour() const
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 );
+ if (m_widgetStyle) gtk_style_unref( m_widgetStyle );
- m_widgetStyle =
- gtk_style_copy(
- gtk_widget_get_style( m_widget ) );
+ m_widgetStyle =
+ gtk_style_copy(
+ gtk_widget_get_style( m_widget ) );
- return m_widgetStyle;
+ return m_widgetStyle;
}
void wxWindow::SetWidgetStyle()
{
- GtkStyle *style = GetWidgetStyle();
+ GtkStyle *style = GetWidgetStyle();
- gdk_font_unref( style->font );
- style->font = gdk_font_ref( m_font.GetInternalFont( 1.0 ) );
+ 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_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();
- }
+ 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()
bool wxWindow::Validate()
{
- wxCHECK_MSG( m_widget != NULL, FALSE, "invalid window" );
+ wxCHECK_MSG( m_widget != NULL, FALSE, "invalid window" );
- 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;
+ 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, "invalid window" );
- wxNode *node = m_children.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, "invalid window" );
- 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;
+ 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, "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->m_items.First();
+ while (node)
+ {
+ wxMenuItem *menuitem = (wxMenuItem*)node->Data();
+ if (menuitem->IsSubMenu())
+ {
+ SetInvokingWindow( menuitem->GetSubMenu(), win );
+ }
+ node = node->Next();
+ }
}
-bool wxWindow::PopupMenu( wxMenu *menu, int WXUNUSED(x), int WXUNUSED(y) )
+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 x, int y )
{
- wxCHECK_MSG( m_widget != NULL, FALSE, "invalid window" );
+ wxCHECK_MSG( m_widget != NULL, FALSE, "invalid window" );
+
+ wxCHECK_MSG( menu != NULL, FALSE, "invalid popup-menu" );
+
+ SetInvokingWindow( menu, this );
+
+ menu->UpdateUI();
- wxCHECK_MSG( menu != NULL, FALSE, "invalid popup-menu" );
+ gs_pop_x = x;
+ gs_pop_y = y;
- SetInvokingWindow( menu, this );
- gtk_menu_popup(
+ 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, "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" );
+ wxCHECK_RET( m_widget != NULL, "invalid window" );
- if (((wxFont*)&font)->Ok())
- m_font = font;
- else
- m_font = *wxSWISS_FONT;
+ if (((wxFont*)&font)->Ok())
+ m_font = font;
+ else
+ m_font = *wxSWISS_FONT;
- ApplyWidgetStyle();
+ 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, "invalid window" );
- wxCHECK_RET( g_capturing == FALSE, "CaptureMouse called twice" );
+ wxCHECK_RET( g_capturing == FALSE, "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, "invalid window" );
- wxCHECK_RET( g_capturing == TRUE, "ReleaseMouse called twice" );
+ wxCHECK_RET( g_capturing == TRUE, "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) )
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" );
-
- if (!m_wxwindow) return;
+ wxCHECK_RET( m_widget != NULL, "invalid window" );
- m_hasScrolling = TRUE;
+ wxCHECK_RET( m_wxwindow != NULL, "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;
- }
+ 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_oldHorizontalPos = fpos;
+ m_oldHorizontalPos = fpos;
- 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 ((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, "invalid window" );
- wxASSERT_MSG( (m_wxwindow != NULL), "window needs client area" );
+ wxCHECK_RET( m_wxwindow != NULL, "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" );
-
- wxASSERT_MSG( (m_wxwindow != NULL), "window needs client area" );
+ wxCHECK_MSG( m_widget != NULL, 0, "invalid window" );
- if (!m_wxwindow) return 0;
+ wxCHECK_MSG( m_wxwindow != NULL, 0, "window needs client area for scrolling" );
- 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, "invalid window" );
- wxASSERT_MSG( (m_wxwindow != NULL), "window needs client area" );
+ wxCHECK_MSG( m_wxwindow != NULL, 0, "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" );
-
- wxASSERT_MSG( (m_wxwindow != NULL), "window needs client area" );
+ wxCHECK_MSG( m_widget != NULL, 0, "invalid window" );
- if (!m_wxwindow) return 0;
+ wxCHECK_MSG( m_wxwindow != NULL, 0, "window needs client area for scrolling" );
- 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" );
-
- wxASSERT_MSG( (m_wxwindow != NULL), "window needs client area" );
+ wxCHECK_RET( m_widget != NULL, "invalid window" );
- if (!m_wxwindow) return;
+ wxCHECK_RET( m_wxwindow != NULL, "window needs client area for scrolling" );
int cw = 0;
int ch = 0;
int h = ch - abs(dy);
if ((h < 0) || (w < 0))
{
- Refresh();
- return;
+ Refresh();
+ return;
}
int s_x = 0;
int s_y = 0;
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;
winName = "unnamed";
else
winName = GetName();
- wxLogDebug( "Constraint(s) not satisfied for window of type %s, name %s:\n",
- (const char *)windowClass,
- (const char *)winName);
+ wxLogDebug( "Constraint(s) not satisfied for window of type %s, name %s:\n",
+ (const char *)windowClass,
+ (const char *)winName);
if (!constr->left.GetDone()) wxLogDebug( " unsatisfied 'left' constraint.\n" );
if (!constr->right.GetDone()) wxLogDebug( " unsatisfied 'right' constraint.\n" );
if (!constr->width.GetDone()) wxLogDebug( " unsatisfied 'width' constraint.\n" );
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();
GetPosition(x, y);
}
-bool wxWindow::AcceptsFocus() const
-{
- return IsEnabled() && IsShown();
-}
-
-void wxWindow::OnIdle(wxIdleEvent& WXUNUSED(event) )
-{
- UpdateWindowUI();
-}
projects / wxWidgets.git / blobdiff