#include "gdk/gdkkeysyms.h"
#include "wx/gtk/win_gtk.h"
+#include "gdk/gdkx.h"
+
//-----------------------------------------------------------------------------
// documentation on internals
//-----------------------------------------------------------------------------
extern wxList wxPendingDelete;
extern bool g_blockEventsOnDrag;
extern bool g_blockEventsOnScroll;
-static bool g_capturing = FALSE;
+extern wxCursor g_globalCursor;
+static wxWindow *g_captureWindow = (wxWindow*) NULL;
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 */
static guint32 gs_timeLastClick = 0;
-#if (GTK_MINOR_VERSION > 0)
+//-----------------------------------------------------------------------------
+// debug
+//-----------------------------------------------------------------------------
+
+#ifdef __WXDEBUG__
+
+static gint gtk_debug_focus_in_callback( GtkWidget *WXUNUSED(widget),
+ GdkEvent *WXUNUSED(event),
+ const wxChar *name )
+{
+/*
+ static bool s_done = FALSE;
+ if ( !s_done )
+ {
+ wxLog::AddTraceMask("focus");
+ s_done = TRUE;
+ }
+ wxLogTrace(_T("FOCUS NOW AT: %s"), name);
+*/
+
+ return FALSE;
+}
+
+void debug_focus_in( GtkWidget* widget, const wxChar* name, const wxChar *window )
+{
+ wxString tmp = name;
+ tmp += _T(" FROM ");
+ tmp += window;
+
+ wxChar *s = new wxChar[tmp.Length()+1];
+
+ wxStrcpy( s, tmp );
+
+ gtk_signal_connect( GTK_OBJECT(widget), "focus_in_event",
+ GTK_SIGNAL_FUNC(gtk_debug_focus_in_callback), (gpointer)s );
+}
+
+#endif // Debug
+
+//-----------------------------------------------------------------------------
+// missing gdk functions
+//-----------------------------------------------------------------------------
+
+void
+gdk_window_warp_pointer (GdkWindow *window,
+ gint x,
+ gint y)
+{
+ GdkWindowPrivate *priv;
+
+ if (!window)
+ window = (GdkWindow*) &gdk_root_parent;
+
+ priv = (GdkWindowPrivate*) window;
+
+ if (!priv->destroyed)
+ {
+ XWarpPointer (priv->xdisplay,
+ None, /* not source window -> move from anywhere */
+ priv->xwindow, /* dest window */
+ 0, 0, 0, 0, /* not source window -> move from anywhere */
+ x, y );
+ }
+}
+
+//-----------------------------------------------------------------------------
+// idle system
+//-----------------------------------------------------------------------------
+
+extern void wxapp_install_idle_handler();
+extern bool g_isIdle;
+
+//-----------------------------------------------------------------------------
+// key event conversion routines
+//-----------------------------------------------------------------------------
+
+#if (GTK_MINOR_VERSION == 0)
+/* these functions are copied verbatim from GTK 1.2 */
+static void
+gdkx_XConvertCase (KeySym symbol,
+ KeySym *lower,
+ KeySym *upper)
+{
+ register KeySym sym = symbol;
+
+ g_return_if_fail (lower != NULL);
+ g_return_if_fail (upper != NULL);
+
+ *lower = sym;
+ *upper = sym;
+
+ switch (sym >> 8)
+ {
+#if defined (GDK_A) && defined (GDK_Ooblique)
+ case 0: /* Latin 1 */
+ if ((sym >= GDK_A) && (sym <= GDK_Z))
+ *lower += (GDK_a - GDK_A);
+ else if ((sym >= GDK_a) && (sym <= GDK_z))
+ *upper -= (GDK_a - GDK_A);
+ else if ((sym >= GDK_Agrave) && (sym <= GDK_Odiaeresis))
+ *lower += (GDK_agrave - GDK_Agrave);
+ else if ((sym >= GDK_agrave) && (sym <= GDK_odiaeresis))
+ *upper -= (GDK_agrave - GDK_Agrave);
+ else if ((sym >= GDK_Ooblique) && (sym <= GDK_Thorn))
+ *lower += (GDK_oslash - GDK_Ooblique);
+ else if ((sym >= GDK_oslash) && (sym <= GDK_thorn))
+ *upper -= (GDK_oslash - GDK_Ooblique);
+ break;
+#endif /* LATIN1 */
+
+#if defined (GDK_Aogonek) && defined (GDK_tcedilla)
+ case 1: /* Latin 2 */
+ /* Assume the KeySym is a legal value (ignore discontinuities) */
+ if (sym == GDK_Aogonek)
+ *lower = GDK_aogonek;
+ else if (sym >= GDK_Lstroke && sym <= GDK_Sacute)
+ *lower += (GDK_lstroke - GDK_Lstroke);
+ else if (sym >= GDK_Scaron && sym <= GDK_Zacute)
+ *lower += (GDK_scaron - GDK_Scaron);
+ else if (sym >= GDK_Zcaron && sym <= GDK_Zabovedot)
+ *lower += (GDK_zcaron - GDK_Zcaron);
+ else if (sym == GDK_aogonek)
+ *upper = GDK_Aogonek;
+ else if (sym >= GDK_lstroke && sym <= GDK_sacute)
+ *upper -= (GDK_lstroke - GDK_Lstroke);
+ else if (sym >= GDK_scaron && sym <= GDK_zacute)
+ *upper -= (GDK_scaron - GDK_Scaron);
+ else if (sym >= GDK_zcaron && sym <= GDK_zabovedot)
+ *upper -= (GDK_zcaron - GDK_Zcaron);
+ else if (sym >= GDK_Racute && sym <= GDK_Tcedilla)
+ *lower += (GDK_racute - GDK_Racute);
+ else if (sym >= GDK_racute && sym <= GDK_tcedilla)
+ *upper -= (GDK_racute - GDK_Racute);
+ break;
+#endif /* LATIN2 */
+
+#if defined (GDK_Hstroke) && defined (GDK_Cabovedot)
+ case 2: /* Latin 3 */
+ /* Assume the KeySym is a legal value (ignore discontinuities) */
+ if (sym >= GDK_Hstroke && sym <= GDK_Hcircumflex)
+ *lower += (GDK_hstroke - GDK_Hstroke);
+ else if (sym >= GDK_Gbreve && sym <= GDK_Jcircumflex)
+ *lower += (GDK_gbreve - GDK_Gbreve);
+ else if (sym >= GDK_hstroke && sym <= GDK_hcircumflex)
+ *upper -= (GDK_hstroke - GDK_Hstroke);
+ else if (sym >= GDK_gbreve && sym <= GDK_jcircumflex)
+ *upper -= (GDK_gbreve - GDK_Gbreve);
+ else if (sym >= GDK_Cabovedot && sym <= GDK_Scircumflex)
+ *lower += (GDK_cabovedot - GDK_Cabovedot);
+ else if (sym >= GDK_cabovedot && sym <= GDK_scircumflex)
+ *upper -= (GDK_cabovedot - GDK_Cabovedot);
+ break;
+#endif /* LATIN3 */
+
+#if defined (GDK_Rcedilla) && defined (GDK_Amacron)
+ case 3: /* Latin 4 */
+ /* Assume the KeySym is a legal value (ignore discontinuities) */
+ if (sym >= GDK_Rcedilla && sym <= GDK_Tslash)
+ *lower += (GDK_rcedilla - GDK_Rcedilla);
+ else if (sym >= GDK_rcedilla && sym <= GDK_tslash)
+ *upper -= (GDK_rcedilla - GDK_Rcedilla);
+ else if (sym == GDK_ENG)
+ *lower = GDK_eng;
+ else if (sym == GDK_eng)
+ *upper = GDK_ENG;
+ else if (sym >= GDK_Amacron && sym <= GDK_Umacron)
+ *lower += (GDK_amacron - GDK_Amacron);
+ else if (sym >= GDK_amacron && sym <= GDK_umacron)
+ *upper -= (GDK_amacron - GDK_Amacron);
+ break;
+#endif /* LATIN4 */
+
+#if defined (GDK_Serbian_DJE) && defined (GDK_Cyrillic_yu)
+ case 6: /* Cyrillic */
+ /* Assume the KeySym is a legal value (ignore discontinuities) */
+ if (sym >= GDK_Serbian_DJE && sym <= GDK_Serbian_DZE)
+ *lower -= (GDK_Serbian_DJE - GDK_Serbian_dje);
+ else if (sym >= GDK_Serbian_dje && sym <= GDK_Serbian_dze)
+ *upper += (GDK_Serbian_DJE - GDK_Serbian_dje);
+ else if (sym >= GDK_Cyrillic_YU && sym <= GDK_Cyrillic_HARDSIGN)
+ *lower -= (GDK_Cyrillic_YU - GDK_Cyrillic_yu);
+ else if (sym >= GDK_Cyrillic_yu && sym <= GDK_Cyrillic_hardsign)
+ *upper += (GDK_Cyrillic_YU - GDK_Cyrillic_yu);
+ break;
+#endif /* CYRILLIC */
+
+#if defined (GDK_Greek_ALPHAaccent) && defined (GDK_Greek_finalsmallsigma)
+ case 7: /* Greek */
+ /* Assume the KeySym is a legal value (ignore discontinuities) */
+ if (sym >= GDK_Greek_ALPHAaccent && sym <= GDK_Greek_OMEGAaccent)
+ *lower += (GDK_Greek_alphaaccent - GDK_Greek_ALPHAaccent);
+ else if (sym >= GDK_Greek_alphaaccent && sym <= GDK_Greek_omegaaccent &&
+ sym != GDK_Greek_iotaaccentdieresis &&
+ sym != GDK_Greek_upsilonaccentdieresis)
+ *upper -= (GDK_Greek_alphaaccent - GDK_Greek_ALPHAaccent);
+ else if (sym >= GDK_Greek_ALPHA && sym <= GDK_Greek_OMEGA)
+ *lower += (GDK_Greek_alpha - GDK_Greek_ALPHA);
+ else if (sym >= GDK_Greek_alpha && sym <= GDK_Greek_omega &&
+ sym != GDK_Greek_finalsmallsigma)
+ *upper -= (GDK_Greek_alpha - GDK_Greek_ALPHA);
+ break;
+#endif /* GREEK */
+ }
+}
+
+static guint
+gdk_keyval_to_upper (guint keyval)
+{
+ if (keyval)
+ {
+ KeySym lower_val = 0;
+ KeySym upper_val = 0;
+
+ gdkx_XConvertCase (keyval, &lower_val, &upper_val);
+ return upper_val;
+ }
+ return 0;
+}
+#endif
+
+static long map_to_unmodified_wx_keysym( KeySym keysym )
+{
+ guint key_code = 0;
+
+ switch (keysym)
+ {
+ case GDK_Shift_L:
+ case GDK_Shift_R: key_code = WXK_SHIFT; break;
+ case GDK_Control_L:
+ case GDK_Control_R: key_code = WXK_CONTROL; break;
+ case GDK_Meta_L:
+ case GDK_Meta_R:
+ case GDK_Alt_L:
+ case GDK_Alt_R:
+ case GDK_Super_L:
+ case GDK_Super_R: key_code = WXK_ALT; break;
+ case GDK_Menu: key_code = WXK_MENU; break;
+ case GDK_Help: key_code = WXK_HELP; break;
+ case GDK_BackSpace: key_code = WXK_BACK; break;
+ case GDK_ISO_Left_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_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_NUMPAD8; break;
+ case GDK_KP_9: key_code = WXK_NUMPAD9; break;
+ case GDK_KP_Space: key_code = WXK_NUMPAD_SPACE; break;
+ case GDK_KP_Tab: key_code = WXK_NUMPAD_TAB; break;
+ case GDK_KP_Enter: key_code = WXK_NUMPAD_ENTER; break;
+ case GDK_KP_F1: key_code = WXK_NUMPAD_F1; break;
+ case GDK_KP_F2: key_code = WXK_NUMPAD_F2; break;
+ case GDK_KP_F3: key_code = WXK_NUMPAD_F3; break;
+ case GDK_KP_F4: key_code = WXK_NUMPAD_F4; break;
+ case GDK_KP_Home: key_code = WXK_NUMPAD_HOME; break;
+ case GDK_KP_Left: key_code = WXK_NUMPAD_LEFT; break;
+ case GDK_KP_Up: key_code = WXK_NUMPAD_UP; break;
+ case GDK_KP_Right: key_code = WXK_NUMPAD_RIGHT; break;
+ case GDK_KP_Down: key_code = WXK_NUMPAD_DOWN; break;
+ case GDK_KP_Prior: key_code = WXK_NUMPAD_PRIOR; break;
+// case GDK_KP_Page_Up: key_code = WXK_NUMPAD_PAGEUP; break;
+ case GDK_KP_Next: key_code = WXK_NUMPAD_NEXT; break;
+// case GDK_KP_Page_Down: key_code = WXK_NUMPAD_PAGEDOWN; break;
+ case GDK_KP_End: key_code = WXK_NUMPAD_END; break;
+ case GDK_KP_Begin: key_code = WXK_NUMPAD_BEGIN; break;
+ case GDK_KP_Insert: key_code = WXK_NUMPAD_INSERT; break;
+ case GDK_KP_Delete: key_code = WXK_NUMPAD_DELETE; break;
+ case GDK_KP_Equal: key_code = WXK_NUMPAD_EQUAL; break;
+ case GDK_KP_Multiply: key_code = WXK_NUMPAD_MULTIPLY; break;
+ case GDK_KP_Add: key_code = WXK_NUMPAD_ADD; break;
+ case GDK_KP_Separator: key_code = WXK_NUMPAD_SEPARATOR; break;
+ case GDK_KP_Subtract: key_code = WXK_NUMPAD_SUBTRACT; break;
+ case GDK_KP_Decimal: key_code = WXK_NUMPAD_DECIMAL; break;
+ case GDK_KP_Divide: key_code = WXK_NUMPAD_DIVIDE; 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 (keysym <= 0xFF)
+ {
+ guint upper = gdk_keyval_to_upper( keysym );
+ keysym = (upper != 0 ? upper : keysym ); /* to be MSW compatible */
+ key_code = keysym;
+ }
+ }
+ }
+
+ return (key_code);
+}
+
+static long map_to_wx_keysym( KeySym keysym )
+{
+ guint key_code = 0;
+
+ switch (keysym)
+ {
+ case GDK_Menu: key_code = WXK_MENU; break;
+ case GDK_Help: key_code = WXK_HELP; break;
+ case GDK_BackSpace: key_code = WXK_BACK; break;
+ case GDK_ISO_Left_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_0: key_code = '0'; break;
+ case GDK_KP_1: key_code = '1'; break;
+ case GDK_KP_2: key_code = '2'; break;
+ case GDK_KP_3: key_code = '3'; break;
+ case GDK_KP_4: key_code = '4'; break;
+ case GDK_KP_5: key_code = '5'; break;
+ case GDK_KP_6: key_code = '6'; break;
+ case GDK_KP_7: key_code = '7'; break;
+ case GDK_KP_8: key_code = '8'; break;
+ case GDK_KP_9: key_code = '9'; break;
+ case GDK_KP_Space: key_code = ' '; break;
+ case GDK_KP_Tab: key_code = WXK_TAB; break; /* or '\t' ??? */
+ case GDK_KP_Enter: key_code = WXK_RETURN; break; /* or '\r' ??? */
+ case GDK_KP_F1: key_code = WXK_NUMPAD_F1; break;
+ case GDK_KP_F2: key_code = WXK_NUMPAD_F2; break;
+ case GDK_KP_F3: key_code = WXK_NUMPAD_F3; break;
+ case GDK_KP_F4: key_code = WXK_NUMPAD_F4; 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_Equal: key_code = '='; break;
+ case GDK_KP_Multiply: key_code = '*'; break;
+ case GDK_KP_Add: key_code = '+'; break;
+ case GDK_KP_Separator: key_code = ','; break;
+ case GDK_KP_Subtract: key_code = '-'; break;
+ case GDK_KP_Decimal: key_code = '.'; break;
+ case GDK_KP_Divide: key_code = '/'; 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 (keysym <= 0xFF)
+ {
+ key_code = keysym;
+ }
+ }
+ }
+
+ return (key_code);
+}
//-----------------------------------------------------------------------------
// local code (see below)
//-----------------------------------------------------------------------------
+#if (GTK_MINOR_VERSION > 0)
+
static void draw_frame( GtkWidget *widget, wxWindow *win )
{
- if (!win->HasVMT()) return;
+ if (!win->m_hasVMT)
+ return;
int dw = 0;
int dh = 0;
-
- if (win->m_hasScrolling)
+
+ if (win->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
+
+ we use this instead: range.slider_width = 11 + 2*2pts edge
*/
if (scroll_window->vscrollbar_visible)
if (scroll_window->hscrollbar_visible)
{
dh += 15; /* dh += hscrollbar->allocation.height; */
- dw += scroll_class->scrollbar_spacing;
+ dh += 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)
+
+ if (win->HasFlag(wxRAISED_BORDER))
{
- gtk_draw_shadow( widget->style,
+ 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,
+ GTK_STATE_NORMAL,
+ GTK_SHADOW_OUT,
+ dx, dy,
+ win->m_width-dw, win->m_height-dh );
+ return;
+ }
+
+ if (win->HasFlag(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;
+ GTK_STATE_NORMAL,
+ GTK_SHADOW_IN,
+ dx, dy,
+ win->m_width-dw, win->m_height-dh );
+ return;
}
}
draw_frame( widget, win );
}
-#endif
+#endif // GTK_MINOR_VERSION > 0
//-----------------------------------------------------------------------------
// "expose_event" of m_wxwindow
static void gtk_window_expose_callback( GtkWidget *WXUNUSED(widget), GdkEventExpose *gdk_event, wxWindow *win )
{
- if (!win->HasVMT()) return;
+ if (!win->m_hasVMT)
+ return;
- win->m_updateRegion.Union( gdk_event->area.x,
- gdk_event->area.y,
- gdk_event->area.width,
- gdk_event->area.height );
+ if (gdk_event->window != win->m_wxwindow->window)
+ return;
- if (gdk_event->count > 0) return;
+ win->GetUpdateRegion().Union( gdk_event->area.x,
+ gdk_event->area.y,
+ gdk_event->area.width,
+ gdk_event->area.height );
-/*
- printf( "OnExpose from " );
- if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
- printf( win->GetClassInfo()->GetClassName() );
- printf( ".\n" );
-*/
+ if (gdk_event->count > 0)
+ return;
wxPaintEvent event( win->GetId() );
event.SetEventObject( win );
win->GetEventHandler()->ProcessEvent( event );
- win->m_updateRegion.Clear();
+/*
+ wxPrintf( "OnExpose from " );
+ if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
+ wxPrintf( win->GetClassInfo()->GetClassName() );
+ wxPrintf( " %d %d %d %d\n", (int)gdk_event->area.x,
+ (int)gdk_event->area.y,
+ (int)gdk_event->area.width,
+ (int)gdk_event->area.height );
+*/
+
+ win->GetUpdateRegion().Clear();
}
//-----------------------------------------------------------------------------
static void gtk_window_draw_callback( GtkWidget *WXUNUSED(widget), GdkRectangle *rect, wxWindow *win )
{
- if (!win->HasVMT()) return;
+ if (g_isIdle)
+ wxapp_install_idle_handler();
- win->m_updateRegion.Union( rect->x, rect->y, rect->width, rect->height );
+ if (!win->m_hasVMT)
+ return;
+
+ win->GetUpdateRegion().Union( rect->x, rect->y,
+ rect->width, rect->height );
wxPaintEvent event( win->GetId() );
event.SetEventObject( win );
+
+/*
+ wxPrintf( "OnDraw from " );
+ if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
+ printf( win->GetClassInfo()->GetClassName() );
+ wxPrintf( " %d %d %d %d\n", (int)rect->x,
+ (int)rect->y,
+ (int)rect->width,
+ (int)rect->height );
+*/
+
win->GetEventHandler()->ProcessEvent( event );
- win->m_updateRegion.Clear();
+ win->GetUpdateRegion().Clear();
}
//-----------------------------------------------------------------------------
static gint gtk_window_key_press_callback( GtkWidget *widget, GdkEventKey *gdk_event, wxWindow *win )
{
- if (!win->HasVMT()) return FALSE;
+ if (g_isIdle)
+ wxapp_install_idle_handler();
+
+ if (!win->m_hasVMT) return FALSE;
if (g_blockEventsOnDrag) return FALSE;
/*
- printf( "OnKeyPress from " );
- if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
- printf( win->GetClassInfo()->GetClassName() );
- printf( ".\n" );
+ printf( "KeyDown-ScanCode is: %d.\n", gdk_event->keyval );
+ if (gdk_event->state & GDK_SHIFT_MASK)
+ printf( "ShiftDown.\n" );
+ else
+ printf( "ShiftUp.\n" );
+ if (gdk_event->state & GDK_CONTROL_MASK)
+ printf( "ControlDown.\n" );
+ else
+ printf( "ControlUp.\n" );
+ printf( "\n" );
*/
+ int x = 0;
+ int y = 0;
+ GdkModifierType state;
+ if (gdk_event->window) gdk_window_get_pointer(gdk_event->window, &x, &y, &state);
- 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;
- }
- }
+ long key_code = map_to_unmodified_wx_keysym( gdk_event->keyval );
- if (!key_code) return FALSE;
+ /* sending unknown key events doesn't really make sense */
+ if (key_code == 0) return FALSE;
+
+ bool ret = FALSE;
wxKeyEvent event( wxEVT_KEY_DOWN );
+ event.SetTimestamp( gdk_event->time );
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.m_scanCode = gdk_event->keyval;
+ event.m_x = x;
+ event.m_y = y;
event.SetEventObject( win );
+ ret = win->GetEventHandler()->ProcessEvent( event );
- bool ret = win->GetEventHandler()->ProcessEvent( event );
+ key_code = map_to_wx_keysym( gdk_event->keyval );
+#if wxUSE_ACCEL
if (!ret)
{
wxWindow *ancestor = win;
ancestor = ancestor->GetParent();
}
}
-
- // win is a control: tab can be propagated up
- if ( (!ret) &&
+#endif // wxUSE_ACCEL
+ /* wxMSW doesn't send char events with Alt pressed */
+ /* Only send wxEVT_CHAR event if not processed yet. Thus, ALT-x
+ will only be sent if it is not a menu accelerator. */
+ if ((key_code != 0) && ! ret )
+ {
+ wxKeyEvent event2( wxEVT_CHAR );
+ event2.SetTimestamp( gdk_event->time );
+ event2.m_shiftDown = (gdk_event->state & GDK_SHIFT_MASK);
+ event2.m_controlDown = (gdk_event->state & GDK_CONTROL_MASK);
+ event2.m_altDown = (gdk_event->state & GDK_MOD1_MASK);
+ event2.m_metaDown = (gdk_event->state & GDK_MOD2_MASK);
+ event2.m_keyCode = key_code;
+ event2.m_scanCode = gdk_event->keyval;
+ event2.m_x = x;
+ event2.m_y = y;
+ event2.SetEventObject( win );
+ ret = (ret || win->GetEventHandler()->ProcessEvent( event2 ));
+ }
+
+
+ /* 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))
+ (win->HasFlag(wxTE_PROCESS_TAB) == 0))
{
wxNavigationKeyEvent new_event;
- /* GDK reports GDK_ISO_Left_Tab for SHIFT-TAB */
+ /* 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 */
+ /* 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) &&
+ /* generate wxID_CANCEL if <esc> has been pressed (typically in dialogs) */
+ 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 );
}
-
+
+#if (GTK_MINOR_VERSION > 0)
+ /* pressing F10 will activate the menu bar of the top frame */
+ if ( (!ret) &&
+ (gdk_event->keyval == GDK_F10) )
+ {
+ wxWindow *ancestor = win;
+ while (ancestor)
+ {
+ if (wxIsKindOf(ancestor,wxFrame))
+ {
+ wxFrame *frame = (wxFrame*) ancestor;
+ wxMenuBar *menubar = frame->GetMenuBar();
+ if (menubar)
+ {
+ wxNode *node = menubar->GetMenus().First();
+ if (node)
+ {
+ // doesn't work correctly
+ // wxMenu *firstMenu = (wxMenu*) node->Data();
+ // gtk_menu_item_select( GTK_MENU_ITEM(firstMenu->m_owner) );
+ // ret = TRUE;
+ break;
+ }
+ }
+ }
+ ancestor = ancestor->GetParent();
+ }
+ }
+#endif
+
/*
Damn, I forgot why this didn't work, but it didn't work.
// 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 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;
- }
+ ((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 TRUE;
}
- if (!key_code) return FALSE;
+ return FALSE;
+}
+
+//-----------------------------------------------------------------------------
+// "key_release_event" from any window
+//-----------------------------------------------------------------------------
+
+static gint gtk_window_key_release_callback( GtkWidget *widget, GdkEventKey *gdk_event, wxWindow *win )
+{
+ if (g_isIdle)
+ wxapp_install_idle_handler();
+
+ if (!win->m_hasVMT) return FALSE;
+ if (g_blockEventsOnDrag) return FALSE;
+
+/*
+ printf( "KeyUp-ScanCode is: %d.\n", gdk_event->keyval );
+ if (gdk_event->state & GDK_SHIFT_MASK)
+ printf( "ShiftDown.\n" );
+ else
+ printf( "ShiftUp.\n" );
+ if (gdk_event->state & GDK_CONTROL_MASK)
+ printf( "ControlDown.\n" );
+ else
+ printf( "ControlUp.\n" );
+ printf( "\n" );
+*/
+
+ long key_code = map_to_unmodified_wx_keysym( gdk_event->keyval );
+
+ /* sending unknown key events doesn't really make sense */
+ if (key_code == 0) return FALSE;
+
+ int x = 0;
+ int y = 0;
+ GdkModifierType state;
+ if (gdk_event->window) gdk_window_get_pointer(gdk_event->window, &x, &y, &state);
wxKeyEvent event( wxEVT_KEY_UP );
+ event.SetTimestamp( gdk_event->time );
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.m_scanCode = gdk_event->keyval;
+ event.m_x = x;
+ event.m_y = y;
event.SetEventObject( win );
if (win->GetEventHandler()->ProcessEvent( event ))
{
gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "key_release_event" );
- return TRUE;
+ return TRUE;
}
return FALSE;
static gint gtk_window_button_press_callback( GtkWidget *widget, GdkEventButton *gdk_event, wxWindow *win )
{
- if (!win->HasVMT()) return FALSE;
+ if (g_isIdle)
+ wxapp_install_idle_handler();
+
+/*
+ wxPrintf( _T("1) OnButtonPress from ") );
+ if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
+ wxPrintf( win->GetClassInfo()->GetClassName() );
+ wxPrintf( _T(".\n") );
+*/
+ if (!win->m_hasVMT) return FALSE;
if (g_blockEventsOnDrag) return TRUE;
if (g_blockEventsOnScroll) return TRUE;
gtk_widget_grab_focus (win->m_wxwindow);
/*
- printf( "GrabFocus from " );
+ wxPrintf( _T("GrabFocus from ") );
if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
- printf( win->GetClassInfo()->GetClassName() );
- printf( ".\n" );
+ wxPrintf( win->GetClassInfo()->GetClassName() );
+ wxPrintf( _T(".\n") );
*/
}
}
/*
- printf( "OnButtonPress from " );
+ wxPrintf( _T("2) OnButtonPress from ") );
if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
- printf( win->GetClassInfo()->GetClassName() );
- printf( ".\n" );
+ wxPrintf( win->GetClassInfo()->GetClassName() );
+ wxPrintf( _T(".\n") );
*/
wxEventType event_type = wxEVT_LEFT_DOWN;
}
wxMouseEvent event( event_type );
+ event.SetTimestamp( gdk_event->time );
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);
// Some control don't have their own X window and thus cannot get
// any events.
- if (!g_capturing)
+ if (!g_captureWindow)
{
wxNode *node = win->GetChildren().First();
while (node)
if (win->GetEventHandler()->ProcessEvent( event ))
{
gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "button_press_event" );
- return TRUE;
+ return TRUE;
}
return FALSE;
static gint gtk_window_button_release_callback( GtkWidget *widget, GdkEventButton *gdk_event, wxWindow *win )
{
- if (!win->HasVMT()) return FALSE;
+ if (g_isIdle)
+ wxapp_install_idle_handler();
+
+ if (!win->m_hasVMT) return FALSE;
if (g_blockEventsOnDrag) return FALSE;
if (g_blockEventsOnScroll) return FALSE;
}
wxMouseEvent event( event_type );
+ event.SetTimestamp( gdk_event->time );
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);
// Some control don't have their own X window and thus cannot get
// any events.
- if (!g_capturing)
+ if (!g_captureWindow)
{
wxNode *node = win->GetChildren().First();
while (node)
if (win->GetEventHandler()->ProcessEvent( event ))
{
gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "button_release_event" );
- return TRUE;
+ return TRUE;
}
return FALSE;
static gint gtk_window_motion_notify_callback( GtkWidget *widget, GdkEventMotion *gdk_event, wxWindow *win )
{
- if (!win->HasVMT()) return FALSE;
+ if (g_isIdle)
+ wxapp_install_idle_handler();
+
+ if (!win->m_hasVMT) return FALSE;
if (g_blockEventsOnDrag) return FALSE;
if (g_blockEventsOnScroll) return FALSE;
*/
wxMouseEvent event( wxEVT_MOTION );
+ event.SetTimestamp( gdk_event->time );
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);
// Some control don't have their own X window and thus cannot get
// any events.
- if (!g_capturing)
+ if (!g_captureWindow)
{
wxNode *node = win->GetChildren().First();
while (node)
if (win->GetEventHandler()->ProcessEvent( event ))
{
gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "motion_notify_event" );
- return TRUE;
+ return TRUE;
}
return FALSE;
static gint gtk_window_focus_in_callback( GtkWidget *widget, GdkEvent *WXUNUSED(event), wxWindow *win )
{
- if (!win->HasVMT()) return FALSE;
+ if (g_isIdle)
+ wxapp_install_idle_handler();
+
+ if (!win->m_hasVMT) return FALSE;
if (g_blockEventsOnDrag) return FALSE;
g_focusWindow = win;
gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "focus_in_event" );
return TRUE;
}
-
+
return FALSE;
}
static gint gtk_window_focus_out_callback( GtkWidget *widget, GdkEvent *WXUNUSED(event), wxWindow *win )
{
- if (!win->HasVMT()) return FALSE;
+ if (g_isIdle)
+ wxapp_install_idle_handler();
+
+ if (!win->m_hasVMT) return FALSE;
if (g_blockEventsOnDrag) return FALSE;
-
+
if (win->m_wxwindow)
{
if (GTK_WIDGET_CAN_FOCUS(win->m_wxwindow))
gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "focus_out_event" );
return TRUE;
}
-
+
return FALSE;
}
static gint gtk_window_enter_callback( GtkWidget *widget, GdkEventCrossing *gdk_event, wxWindow *win )
{
- if (!win->HasVMT()) return FALSE;
- if (g_blockEventsOnDrag) return FALSE;
-
- if (widget->window != gdk_event->window) return FALSE;
+ if (g_isIdle)
+ wxapp_install_idle_handler();
- if ((widget->window) && (win->m_cursor))
- gdk_window_set_cursor( widget->window, win->m_cursor->GetCursor() );
+ if (!win->m_hasVMT) return FALSE;
+ if (g_blockEventsOnDrag) return FALSE;
-/*
- printf( "OnEnter from " );
- if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
- printf( win->GetClassInfo()->GetClassName() );
- printf( ".\n" );
-*/
+ if (!win->IsOwnGtkWindow( gdk_event->window )) return FALSE;
wxMouseEvent event( wxEVT_ENTER_WINDOW );
+#if (GTK_MINOR_VERSION > 0)
+ event.SetTimestamp( gdk_event->time );
+#endif
event.SetEventObject( win );
int x = 0;
gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "enter_notify_event" );
return TRUE;
}
-
+
return FALSE;
}
static gint gtk_window_leave_callback( GtkWidget *widget, GdkEventCrossing *gdk_event, wxWindow *win )
{
- if (!win->HasVMT()) return FALSE;
- if (g_blockEventsOnDrag) return FALSE;
+ if (g_isIdle)
+ wxapp_install_idle_handler();
- if (widget->window != gdk_event->window) return FALSE;
-
- if ((widget->window) && (win->m_cursor))
- gdk_window_set_cursor( widget->window, wxSTANDARD_CURSOR->GetCursor() );
+ if (!win->m_hasVMT) return FALSE;
+ if (g_blockEventsOnDrag) return FALSE;
-/*
- printf( "OnLeave from " );
- if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
- printf( win->GetClassInfo()->GetClassName() );
- printf( ".\n" );
-*/
+ if (!win->IsOwnGtkWindow( gdk_event->window )) return FALSE;
wxMouseEvent event( wxEVT_LEAVE_WINDOW );
+#if (GTK_MINOR_VERSION > 0)
+ event.SetTimestamp( gdk_event->time );
+#endif
event.SetEventObject( win );
int x = 0;
gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "leave_notify_event" );
return TRUE;
}
-
+
return FALSE;
}
static void gtk_window_vscroll_callback( GtkWidget *WXUNUSED(widget), wxWindow *win )
{
- if (g_blockEventsOnDrag) return;
+ if (g_isIdle)
+ wxapp_install_idle_handler();
-/*
- printf( "OnVScroll from " );
- if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
- printf( win->GetClassInfo()->GetClassName() );
- printf( ".\n" );
-*/
+ if (g_blockEventsOnDrag) return;
- if (!win->HasVMT()) return;
+ if (!win->m_hasVMT) return;
float diff = win->m_vAdjust->value - win->m_oldVerticalPos;
if (fabs(diff) < 0.2) return;
float line_step = win->m_vAdjust->step_increment;
float page_step = win->m_vAdjust->page_increment;
- if (win->m_isScrolling)
+ if (win->IsScrolling())
{
- command = wxEVT_SCROLL_THUMBTRACK;
+ command = wxEVT_SCROLLWIN_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;
+ if (fabs(win->m_vAdjust->value-win->m_vAdjust->lower) < 0.2) command = wxEVT_SCROLLWIN_BOTTOM;
+ else if (fabs(win->m_vAdjust->value-win->m_vAdjust->upper) < 0.2) command = wxEVT_SCROLLWIN_TOP;
+ else if (fabs(diff-line_step) < 0.2) command = wxEVT_SCROLLWIN_LINEDOWN;
+ else if (fabs(diff+line_step) < 0.2) command = wxEVT_SCROLLWIN_LINEUP;
+ else if (fabs(diff-page_step) < 0.2) command = wxEVT_SCROLLWIN_PAGEDOWN;
+ else if (fabs(diff+page_step) < 0.2) command = wxEVT_SCROLLWIN_PAGEUP;
+ else command = wxEVT_SCROLLWIN_THUMBTRACK;
}
int value = (int)(win->m_vAdjust->value+0.5);
- wxScrollEvent event( command, win->GetId(), value, wxVERTICAL );
+ wxScrollWinEvent event( command, value, wxVERTICAL );
event.SetEventObject( win );
win->GetEventHandler()->ProcessEvent( event );
}
static void gtk_window_hscroll_callback( GtkWidget *WXUNUSED(widget), wxWindow *win )
{
- if (g_blockEventsOnDrag) return;
-
-/*
- printf( "OnHScroll from " );
- if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
- printf( win->GetClassInfo()->GetClassName() );
- printf( ".\n" );
-*/
+ if (g_isIdle)
+ wxapp_install_idle_handler();
- if (!win->HasVMT()) return;
+ if (g_blockEventsOnDrag) return;
+ if (!win->m_hasVMT) return;
float diff = win->m_hAdjust->value - win->m_oldHorizontalPos;
if (fabs(diff) < 0.2) return;
float line_step = win->m_hAdjust->step_increment;
float page_step = win->m_hAdjust->page_increment;
- if (win->m_isScrolling)
+ if (win->IsScrolling())
{
- command = wxEVT_SCROLL_THUMBTRACK;
+ command = wxEVT_SCROLLWIN_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;
+ if (fabs(win->m_hAdjust->value-win->m_hAdjust->lower) < 0.2) command = wxEVT_SCROLLWIN_BOTTOM;
+ else if (fabs(win->m_hAdjust->value-win->m_hAdjust->upper) < 0.2) command = wxEVT_SCROLLWIN_TOP;
+ else if (fabs(diff-line_step) < 0.2) command = wxEVT_SCROLLWIN_LINEDOWN;
+ else if (fabs(diff+line_step) < 0.2) command = wxEVT_SCROLLWIN_LINEUP;
+ else if (fabs(diff-page_step) < 0.2) command = wxEVT_SCROLLWIN_PAGEDOWN;
+ else if (fabs(diff+page_step) < 0.2) command = wxEVT_SCROLLWIN_PAGEUP;
+ else command = wxEVT_SCROLLWIN_THUMBTRACK;
}
int value = (int)(win->m_hAdjust->value+0.5);
- wxScrollEvent event( command, win->GetId(), value, wxHORIZONTAL );
+ wxScrollWinEvent event( command, value, wxHORIZONTAL );
event.SetEventObject( win );
win->GetEventHandler()->ProcessEvent( event );
}
static void gtk_window_vscroll_change_callback( GtkWidget *WXUNUSED(widget), wxWindow *win )
{
- if (g_blockEventsOnDrag) return;
-
-/*
- printf( "OnVScroll change from " );
- if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
- printf( win->GetClassInfo()->GetClassName() );
- printf( ".\n" );
-*/
+ if (g_isIdle)
+ wxapp_install_idle_handler();
- if (!win->HasVMT()) return;
+ if (g_blockEventsOnDrag) return;
+ if (!win->m_hasVMT) return;
- wxEventType command = wxEVT_SCROLL_THUMBTRACK;
+ wxEventType command = wxEVT_SCROLLWIN_THUMBTRACK;
int value = (int)(win->m_vAdjust->value+0.5);
- wxScrollEvent event( command, win->GetId(), value, wxVERTICAL );
+ wxScrollWinEvent event( command, value, wxVERTICAL );
event.SetEventObject( win );
win->GetEventHandler()->ProcessEvent( event );
}
static void gtk_window_hscroll_change_callback( GtkWidget *WXUNUSED(widget), wxWindow *win )
{
- if (g_blockEventsOnDrag) return;
-
-/*
- printf( "OnHScroll change from " );
- if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
- printf( win->GetClassInfo()->GetClassName() );
- printf( ".\n" );
-*/
+ if (g_isIdle)
+ wxapp_install_idle_handler();
- if (!win->HasVMT()) return;
+ if (g_blockEventsOnDrag) return;
+ if (!win->m_hasVMT) return;
- wxEventType command = wxEVT_SCROLL_THUMBTRACK;
+ wxEventType command = wxEVT_SCROLLWIN_THUMBTRACK;
int value = (int)(win->m_hAdjust->value+0.5);
- wxScrollEvent event( command, win->GetId(), value, wxHORIZONTAL );
+ wxScrollWinEvent event( command, value, wxHORIZONTAL );
event.SetEventObject( win );
win->GetEventHandler()->ProcessEvent( event );
}
GdkEventButton *WXUNUSED(gdk_event),
wxWindow *win )
{
+ if (g_isIdle)
+ wxapp_install_idle_handler();
+
// 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;
+ win->SetScrolling( TRUE );
return FALSE;
}
//
// if (gdk_event->window != widget->slider) return FALSE;
- GtkScrolledWindow *s_window = GTK_SCROLLED_WINDOW(win->m_widget);
+ GtkScrolledWindow *scrolledWindow = GTK_SCROLLED_WINDOW(win->m_widget);
- if (widget == GTK_RANGE(s_window->vscrollbar))
+ if (widget == GTK_RANGE(scrolledWindow->vscrollbar))
gtk_signal_emit_by_name( GTK_OBJECT(win->m_hAdjust), "value_changed" );
else
gtk_signal_emit_by_name( GTK_OBJECT(win->m_vAdjust), "value_changed" );
- win->m_isScrolling = FALSE;
- g_blockEventsOnScroll = FALSE;
+ win->SetScrolling( FALSE );
+
+ return FALSE;
+}
+
+// ----------------------------------------------------------------------------
+// this wxWindowBase function is implemented here (in platform-specific file)
+// because it is static and so couldn't be made virtual
+// ----------------------------------------------------------------------------
+
+wxWindow *wxWindowBase::FindFocus()
+{
+ return g_focusWindow;
+}
+
+//-----------------------------------------------------------------------------
+// "realize" from m_widget
+//-----------------------------------------------------------------------------
+
+/* we cannot set colours, fonts and cursors before the widget has
+ been realized, so we do this directly after realization */
+
+static gint
+gtk_window_realized_callback( GtkWidget * WXUNUSED(widget), wxWindow *win )
+{
+ if (g_isIdle)
+ wxapp_install_idle_handler();
+
+ if (win->m_delayedFont)
+ win->SetFont( win->GetFont() );
+
+ if (win->m_delayedBackgroundColour)
+ win->SetBackgroundColour( win->GetBackgroundColour() );
+
+ if (win->m_delayedForegroundColour)
+ win->SetForegroundColour( win->GetForegroundColour() );
+
+ win->SetCursor( win->GetCursor() );
+
+ wxWindowCreateEvent event( win );
+ event.SetEventObject( win );
+ win->GetEventHandler()->ProcessEvent( event );
return FALSE;
}
{
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 );
+ child->m_x,
+ child->m_y,
+ child->m_width,
+ child->m_height );
- if (parent->m_windowStyle & wxTAB_TRAVERSAL)
+ if (parent->HasFlag(wxTAB_TRAVERSAL))
{
/* we now allow a window to get the focus as long as it
doesn't have any children. */
wxWindow* wxGetActiveWindow()
{
- return g_focusWindow;
+ return g_focusWindow;
}
//-----------------------------------------------------------------------------
// wxWindow
//-----------------------------------------------------------------------------
-IMPLEMENT_DYNAMIC_CLASS(wxWindow,wxEvtHandler)
-
-BEGIN_EVENT_TABLE(wxWindow, wxEvtHandler)
- EVT_SIZE(wxWindow::OnSize)
- EVT_SYS_COLOUR_CHANGED(wxWindow::OnSysColourChanged)
- EVT_INIT_DIALOG(wxWindow::OnInitDialog)
- EVT_KEY_DOWN(wxWindow::OnKeyDown)
-END_EVENT_TABLE()
+IMPLEMENT_DYNAMIC_CLASS(wxWindow, wxWindowBase)
void wxWindow::Init()
{
- m_isWindow = TRUE;
+ // common init
+ InitBase();
+ // GTK specific
m_widget = (GtkWidget *) NULL;
m_wxwindow = (GtkWidget *) NULL;
- m_parent = (wxWindow *) NULL;
- m_children.DeleteContents( FALSE );
+ // position/size
m_x = 0;
m_y = 0;
m_width = 0;
m_height = 0;
- m_minWidth = -1;
- 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_isBeingDeleted = 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_scrollGC = (GdkGC*) NULL;
m_widgetStyle = (GtkStyle*) NULL;
- m_insertCallback = wxInsertChildInWindow;
-
- m_clientObject = (wxClientData*) NULL;
- m_clientData = NULL;
+ m_insertCallback = (wxInsertChildFunction) NULL;
m_isStaticBox = FALSE;
m_acceptsFocus = FALSE;
-
-#if wxUSE_TOOLTIPS
- m_toolTip = (wxToolTip*) NULL;
-#endif // wxUSE_TOOLTIPS
}
wxWindow::wxWindow()
const wxPoint &pos, const wxSize &size,
long style, const wxString &name )
{
- wxASSERT_MSG( m_isWindow, "Init() must have been called before!" );
-
PreCreation( parent, id, pos, size, style, name );
+ m_insertCallback = wxInsertChildInWindow;
+
m_widget = gtk_scrolled_window_new( (GtkAdjustment *) NULL, (GtkAdjustment *) NULL );
GTK_WIDGET_UNSET_FLAGS( m_widget, GTK_CAN_FOCUS );
- GtkScrolledWindow *s_window = GTK_SCROLLED_WINDOW(m_widget);
+#ifdef __WXDEBUG__
+ debug_focus_in( m_widget, _T("wxWindow::m_widget"), name );
+#endif
+
+ GtkScrolledWindow *scrolledWindow = GTK_SCROLLED_WINDOW(m_widget);
+
+#ifdef __WXDEBUG__
+ debug_focus_in( scrolledWindow->hscrollbar, _T("wxWindow::hsrcollbar"), name );
+ debug_focus_in( scrolledWindow->vscrollbar, _T("wxWindow::vsrcollbar"), name );
+#endif
GtkScrolledWindowClass *scroll_class = GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT(m_widget)->klass );
scroll_class->scrollbar_spacing = 0;
- gtk_scrolled_window_set_policy( s_window, GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC );
-
- m_oldHorizontalPos = 0.0;
- m_oldVerticalPos = 0.0;
+ gtk_scrolled_window_set_policy( scrolledWindow, GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC );
- m_hAdjust = gtk_range_get_adjustment( GTK_RANGE(s_window->hscrollbar) );
- m_vAdjust = gtk_range_get_adjustment( GTK_RANGE(s_window->vscrollbar) );
+ m_hAdjust = gtk_range_get_adjustment( GTK_RANGE(scrolledWindow->hscrollbar) );
+ m_vAdjust = gtk_range_get_adjustment( GTK_RANGE(scrolledWindow->vscrollbar) );
m_wxwindow = gtk_myfixed_new();
+#ifdef __WXDEBUG__
+ debug_focus_in( m_wxwindow, _T("wxWindow::m_wxwindow"), name );
+#endif
+
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)
+ if (HasFlag(wxRAISED_BORDER))
{
gtk_myfixed_set_shadow_type( myfixed, GTK_SHADOW_OUT );
}
- else if (m_windowStyle & wxSUNKEN_BORDER)
+ else if (HasFlag(wxSUNKEN_BORDER))
{
gtk_myfixed_set_shadow_type( myfixed, GTK_SHADOW_IN );
}
{
gtk_myfixed_set_shadow_type( myfixed, GTK_SHADOW_NONE );
}
-#else
- GtkViewport *viewport = GTK_VIEWPORT(s_window->viewport);
+#else // GTK_MINOR_VERSION == 0
+ GtkViewport *viewport = GTK_VIEWPORT(scrolledWindow->viewport);
- if (m_windowStyle & wxRAISED_BORDER)
+ if (HasFlag(wxRAISED_BORDER))
{
gtk_viewport_set_shadow_type( viewport, GTK_SHADOW_OUT );
}
- else if (m_windowStyle & wxSUNKEN_BORDER)
+ else if (HasFlag(wxSUNKEN_BORDER))
{
gtk_viewport_set_shadow_type( viewport, GTK_SHADOW_IN );
}
{
gtk_viewport_set_shadow_type( viewport, GTK_SHADOW_NONE );
}
-#endif
+#endif // GTK_MINOR_VERSION
- if (m_windowStyle & wxTAB_TRAVERSAL)
+ if (HasFlag(wxTAB_TRAVERSAL))
{
/* we now allow a window to get the focus as long as it
doesn't have any children. */
// 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
+#endif // GTK_MINOR_VERSION == 0
// I _really_ don't want scrollbars in the beginning
m_vAdjust->lower = 0.0;
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
+ // 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",
+ gtk_signal_connect( GTK_OBJECT(scrolledWindow->vscrollbar), "button_press_event",
(GtkSignalFunc)gtk_scrollbar_button_press_callback, (gpointer) this );
- gtk_signal_connect( GTK_OBJECT(s_window->hscrollbar), "button_press_event",
+ gtk_signal_connect( GTK_OBJECT(scrolledWindow->hscrollbar), "button_press_event",
(GtkSignalFunc)gtk_scrollbar_button_press_callback, (gpointer) this );
- gtk_signal_connect( GTK_OBJECT(s_window->vscrollbar), "button_release_event",
+ gtk_signal_connect( GTK_OBJECT(scrolledWindow->vscrollbar), "button_release_event",
(GtkSignalFunc)gtk_scrollbar_button_release_callback, (gpointer) this );
- gtk_signal_connect( GTK_OBJECT(s_window->hscrollbar), "button_release_event",
+ gtk_signal_connect( GTK_OBJECT(scrolledWindow->hscrollbar), "button_release_event",
(GtkSignalFunc)gtk_scrollbar_button_release_callback, (gpointer) this );
// these handlers get notified when screen updates are required either when
gtk_widget_show( m_wxwindow );
- if (m_parent) m_parent->AddChild( this );
-
- (m_parent->m_insertCallback)( m_parent, this );
+ if (m_parent)
+ m_parent->DoAddChild( this );
PostCreation();
wxWindow::~wxWindow()
{
+ m_isBeingDeleted = TRUE;
m_hasVMT = FALSE;
-#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_widget) Show( FALSE );
+ 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;
+ if (m_parent)
+ m_parent->RemoveChild( this );
- DeleteRelatedConstraints();
- if (m_constraints)
+ if (m_widgetStyle)
{
- /* This removes any dangling pointers to this window
- * in other windows' constraintsInvolvedIn lists. */
- UnsetConstraints(m_constraints);
- delete m_constraints;
- m_constraints = (wxLayoutConstraints *) NULL;
+ gtk_style_unref( m_widgetStyle );
+ m_widgetStyle = (GtkStyle*) NULL;
}
-
- if (m_windowSizer)
+
+ if (m_scrollGC)
{
- delete m_windowSizer;
- m_windowSizer = (wxSizer *) NULL;
+ gdk_gc_unref( m_scrollGC );
+ m_scrollGC = (GdkGC*) NULL;
}
- /* 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. */
- wxPendingDelete.DeleteObject(this);
- /* 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_wxwindow)
+ {
+ gtk_widget_destroy( m_wxwindow );
+ m_wxwindow = (GtkWidget*) NULL;
+ }
- if (m_clientObject) delete m_clientObject;
+ if (m_widget)
+ {
+ gtk_widget_destroy( m_widget );
+ m_widget = (GtkWidget*) NULL;
+ }
}
-void wxWindow::PreCreation( wxWindow *parent, wxWindowID id,
- const wxPoint &pos, const wxSize &size,
- long style, const wxString &name )
+void wxWindow::PreCreation( wxWindow *parent,
+ wxWindowID id,
+ const wxPoint &pos,
+ const wxSize &size,
+ long style,
+ const wxString &name )
{
- wxASSERT_MSG( (!m_needParent) || (parent), "Need complete parent." );
+ 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 );
+ if ( !CreateBase(parent, id, pos, size, style, name) )
+ {
+ wxFAIL_MSG(_T("window creation failed"));
+ }
- m_width = size.x;
- if (m_width == -1) m_width = 20;
- m_height = size.y;
- if (m_height == -1) m_height = 20;
+ m_width = WidthDefault(size.x);
+ m_height = HeightDefault(size.y);
m_x = (int)pos.x;
m_y = (int)pos.y;
- if (!m_needParent) /* some reasonable defaults */
+ if (!parent) /* some reasonable defaults */
{
if (m_x == -1)
{
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 == -1 ? wxNewId() : id;
-
- m_sizeSet = FALSE;
-
- m_cursor = new wxCursor( wxCURSOR_ARROW );
- m_font = *wxSWISS_FONT;
- 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), "invalid window" );
-
+ wxASSERT_MSG( (m_widget != NULL), _T("invalid window") );
+
if (m_wxwindow)
{
/* these get reported to wxWindows -> wxPaintEvent */
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 */
+ /* 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 );
#endif
}
- ConnectWidget( GetConnectWidget() );
-
- /* we force the creation of wxFrame and wxDialog in the respective code */
- if (m_parent) gtk_widget_realize( m_widget );
+ GtkWidget *connect_widget = GetConnectWidget();
- if (m_wxwindow) gtk_widget_realize( m_wxwindow );
+ ConnectWidget( connect_widget );
- SetCursor( *wxSTANDARD_CURSOR );
+ /* we cannot set colours, fonts and cursors before the widget has
+ been realized, so we do this directly after realization */
+ gtk_signal_connect( GTK_OBJECT(connect_widget), "realize",
+ GTK_SIGNAL_FUNC(gtk_window_realized_callback), (gpointer) this );
m_hasVMT = TRUE;
}
GTK_SIGNAL_FUNC(gtk_window_leave_callback), (gpointer)this );
}
-bool wxWindow::HasVMT()
-{
- return m_hasVMT;
-}
-
-bool wxWindow::Close( bool force )
-{
- wxASSERT_MSG( (m_widget != NULL), "invalid window" );
-
- wxCloseEvent event(wxEVT_CLOSE_WINDOW, m_windowId);
- event.SetEventObject(this);
- event.SetCanVeto(!force);
-
- /* 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;
- return TRUE;
-}
-
-bool wxWindow::DestroyChildren()
-{
- wxNode *node;
- while ((node = m_children.First()) != (wxNode *)NULL)
- {
- wxWindow *child;
- if ((child = (wxWindow *)node->Data()) != (wxWindow *)NULL)
- {
- delete child;
- if (m_children.Member(child)) delete node;
- }
- }
- return TRUE;
-}
-void wxWindow::PrepareDC( wxDC &WXUNUSED(dc) )
-{
- // are we to set fonts here ?
+ return wxWindowBase::Destroy();
}
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" );
+ wxASSERT_MSG( (m_widget != NULL), _T("invalid window") );
+ wxASSERT_MSG( (m_parent != NULL), _T("wxWindow::SetSize requires parent.\n") );
if (m_resizing) return; /* I don't like recursions */
m_resizing = TRUE;
}
else
{
- int old_width = m_width;
- int old_height = m_height;
-
- if ((sizeFlags & wxSIZE_USE_EXISTING) == wxSIZE_USE_EXISTING)
+ if ((sizeFlags & wxSIZE_ALLOW_MINUS_ONE) == 0)
{
if (x != -1) m_x = x;
if (y != -1) m_y = y;
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 );
+ int border = 0;
+ int bottom_border = 0;
- 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 (GTK_WIDGET_CAN_DEFAULT(m_widget))
+ {
+ /* the default button has a border around it */
+ border = 6;
+ bottom_border = 5;
+ }
- if ((old_width != m_width) || (old_height != m_height))
- gtk_widget_set_usize( m_widget, m_width, m_height );
- }
+ /* this is the result of hours of debugging: the following code
+ means that if we have a m_wxwindow and we set the size of
+ m_widget, m_widget (which is a GtkScrolledWindow) does NOT
+ automatically propagate its size down to its m_wxwindow,
+ which is its client area. therefore, we have to tell the
+ client area directly that it has to resize itself.
+ this will lead to that m_widget (GtkScrolledWindow) will
+ calculate how much size it needs for scrollbars etc and
+ it will then call XXX_size_allocate of its child, which
+ is m_wxwindow. m_wxwindow in turn will do the same with its
+ children and so on. problems can arise if this happens
+ before all the children have been realized as some widgets
+ stupidy need to be realized during XXX_size_allocate (e.g.
+ GtkNotebook) and they will segv if called otherwise. this
+ emergency is tested in gtk_myfixed_size_allocate. Normally
+ this shouldn't be needed and only gtk_widget_queue_resize()
+ should be enough to provoke a resize at the next appropriate
+ moment, but this seems to fail, e.g. when a wxNotebook contains
+ a wxSplitterWindow: the splitter window's children won't
+ show up properly resized then. */
+
+ gtk_myfixed_set_size( GTK_MYFIXED(m_parent->m_wxwindow),
+ m_widget,
+ m_x-border,
+ m_y-border,
+ m_width+2*border,
+ m_height+border+bottom_border );
}
m_sizeSet = TRUE;
void wxWindow::OnInternalIdle()
{
+ wxCursor cursor = m_cursor;
+ if (g_globalCursor.Ok()) cursor = g_globalCursor;
+
+ if (cursor.Ok() && m_currentGdkCursor != cursor)
+ {
+ m_currentGdkCursor = cursor;
+
+ if (m_wxwindow)
+ {
+ GdkWindow *window = m_wxwindow->window;
+ if (window)
+ gdk_window_set_cursor( window, cursor.GetCursor() );
+
+ if (!g_globalCursor.Ok())
+ cursor = *wxSTANDARD_CURSOR;
+
+ window = m_widget->window;
+ if (window)
+ gdk_window_set_cursor( window, cursor.GetCursor() );
+ }
+ else
+ {
+ GdkWindow *window = m_widget->window;
+ if (window)
+ gdk_window_set_cursor( window, cursor.GetCursor() );
+ }
+ }
+
UpdateWindowUI();
}
-void wxWindow::GetSize( int *width, int *height ) const
+void wxWindow::DoGetSize( int *width, int *height ) const
{
- wxCHECK_RET( (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::DoSetClientSize( int width, int height )
{
- wxCHECK_RET( (m_widget != NULL), "invalid window" );
+ wxCHECK_RET( (m_widget != NULL), _T("invalid window") );
if (!m_wxwindow)
{
int dw = 0;
int dh = 0;
- if (!m_hasScrolling)
+#if (GTK_MINOR_VERSION == 0)
+ if (HasFlag(wxRAISED_BORDER) || HasFlag(wxSUNKEN_BORDER))
{
- GtkStyleClass *window_class = m_wxwindow->style->klass;
-
- if ((m_windowStyle & wxRAISED_BORDER) ||
- (m_windowStyle & wxSUNKEN_BORDER))
+ if (HasScrolling())
{
- 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 );
+ GtkScrolledWindow *scroll_window = GTK_SCROLLED_WINDOW(m_widget);
+ GtkScrolledWindowClass *scroll_class = GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT(m_widget)->klass );
-#if (GTK_MINOR_VERSION == 0)
- GtkWidget *viewport = scroll_window->viewport;
- GtkStyleClass *viewport_class = viewport->style->klass;
+ 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;
}
+ }
+#else
+ if (HasFlag(wxRAISED_BORDER) || HasFlag(wxSUNKEN_BORDER))
+ {
+ /* when using GTK 1.2 we set the border size to 2 */
+ dw += 2 * 2;
+ dh += 2 * 2;
+ }
#endif
+ if (HasScrolling())
+ {
/*
GtkWidget *hscrollbar = scroll_window->hscrollbar;
GtkWidget *vscrollbar = scroll_window->vscrollbar;
-
- we use this instead: range.slider_width = 11 + 2*2pts edge
+
+ we use this instead: range.slider_width = 11 + 2*2pts edge
*/
+ GtkScrolledWindow *scroll_window = GTK_SCROLLED_WINDOW(m_widget);
+ GtkScrolledWindowClass *scroll_class = GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT(m_widget)->klass );
+
if (scroll_window->vscrollbar_visible)
{
dw += 15; /* dw += vscrollbar->allocation.width; */
if (scroll_window->hscrollbar_visible)
{
dh += 15; /* dh += hscrollbar->allocation.height; */
- dw += scroll_class->scrollbar_spacing;
+ dh += scroll_class->scrollbar_spacing;
}
}
}
}
-void wxWindow::GetClientSize( int *width, int *height ) const
+void wxWindow::DoGetClientSize( int *width, int *height ) const
{
- wxCHECK_RET( (m_widget != NULL), "invalid window" );
+ wxCHECK_RET( (m_widget != NULL), _T("invalid window") );
if (!m_wxwindow)
{
int dw = 0;
int dh = 0;
- if (!m_hasScrolling)
+#if (GTK_MINOR_VERSION == 0)
+ if (HasFlag(wxRAISED_BORDER) || HasFlag(wxSUNKEN_BORDER))
{
- GtkStyleClass *window_class = m_wxwindow->style->klass;
-
- if ((m_windowStyle & wxRAISED_BORDER) ||
- (m_windowStyle & wxSUNKEN_BORDER))
+ if (HasScrolling())
{
- 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 );
+ GtkScrolledWindow *scroll_window = GTK_SCROLLED_WINDOW(m_widget);
+ GtkScrolledWindowClass *scroll_class = GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT(m_widget)->klass );
-#if (GTK_MINOR_VERSION == 0)
- GtkWidget *viewport = scroll_window->viewport;
- GtkStyleClass *viewport_class = viewport->style->klass;
+ 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;
}
+ }
+#else
+ if (HasFlag(wxRAISED_BORDER) || HasFlag(wxSUNKEN_BORDER))
+ {
+ /* when using GTK 1.2 we set the border size to 2 */
+ dw += 2 * 2;
+ dh += 2 * 2;
+ }
#endif
+ if (HasScrolling())
+ {
/*
GtkWidget *hscrollbar = scroll_window->hscrollbar;
GtkWidget *vscrollbar = scroll_window->vscrollbar;
-
- we use this instead: range.slider_width = 11 + 2*2pts edge
+
+ we use this instead: range.slider_width = 11 + 2*2pts edge
*/
+ GtkScrolledWindow *scroll_window = GTK_SCROLLED_WINDOW(m_widget);
+ GtkScrolledWindowClass *scroll_class = GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT(m_widget)->klass );
+
if (scroll_window->vscrollbar_visible)
{
dw += 15; /* dw += vscrollbar->allocation.width; */
}
}
-void wxWindow::GetPosition( int *x, int *y ) const
+void wxWindow::DoGetPosition( int *x, int *y ) const
{
- wxCHECK_RET( (m_widget != NULL), "invalid window" );
+ wxCHECK_RET( (m_widget != NULL), _T("invalid window") );
if (x) (*x) = m_x;
if (y) (*y) = m_y;
}
-void wxWindow::ClientToScreen( int *x, int *y )
+void wxWindow::DoClientToScreen( int *x, int *y ) const
{
- wxCHECK_RET( (m_widget != NULL), "invalid window" );
+ wxCHECK_RET( (m_widget != NULL), _T("invalid window") );
+
+ if (!m_widget->window) return;
GdkWindow *source = (GdkWindow *) NULL;
if (m_wxwindow)
if (y) *y += org_y;
}
-void wxWindow::ScreenToClient( int *x, int *y )
+void wxWindow::DoScreenToClient( int *x, int *y ) const
{
- wxCHECK_RET( (m_widget != NULL), "invalid window" );
+ wxCHECK_RET( (m_widget != NULL), _T("invalid window") );
+
+ if (!m_widget->window) return;
GdkWindow *source = (GdkWindow *) NULL;
if (m_wxwindow)
if (y) *y -= org_y;
}
-void wxWindow::Centre( int direction )
-{
- wxCHECK_RET( (m_widget != NULL), "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 );
-}
-
-void wxWindow::Fit()
+bool wxWindow::Show( bool show )
{
- wxCHECK_RET( (m_widget != NULL), "invalid window" );
+ wxCHECK_MSG( (m_widget != NULL), FALSE, _T("invalid window") );
- int maxX = 0;
- int maxY = 0;
- wxNode *node = m_children.First();
- while (node)
+ if (!wxWindowBase::Show(show))
{
- 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();
+ // nothing to do
+ return FALSE;
}
- SetClientSize(maxX + 7, maxY + 14);
-}
-
-void wxWindow::SetSizeHints( int minW, int minH, int maxW, int maxH, int WXUNUSED(incW), int WXUNUSED(incH) )
-{
- wxCHECK_RET( (m_widget != NULL), "invalid window" );
-
- m_minWidth = minW;
- m_minHeight = minH;
- m_maxWidth = maxW;
- m_maxHeight = maxH;
-}
-
-void wxWindow::OnSize( wxSizeEvent &WXUNUSED(event) )
-{
-// if (GetAutoLayout()) Layout();
-}
-
-bool wxWindow::Show( bool show )
-{
- wxCHECK_MSG( (m_widget != NULL), FALSE, "invalid window" );
-
- 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 )
+bool wxWindow::Enable( bool enable )
{
- wxCHECK_RET( (m_widget != NULL), "invalid window" );
+ wxCHECK_MSG( (m_widget != NULL), FALSE, _T("invalid window") );
- m_isEnabled = enable;
+ if (!wxWindowBase::Enable(enable))
+ {
+ // nothing to do
+ return FALSE;
+ }
gtk_widget_set_sensitive( m_widget, enable );
- if (m_wxwindow) gtk_widget_set_sensitive( m_wxwindow, enable );
+ if ( m_wxwindow )
+ gtk_widget_set_sensitive( m_wxwindow, enable );
+
+ return TRUE;
}
int wxWindow::GetCharHeight() const
{
- wxCHECK_MSG( (m_widget != NULL), 12, "invalid window" );
+ wxCHECK_MSG( (m_widget != NULL), 12, _T("invalid window") );
- wxCHECK_MSG( m_font.Ok(), 12, "invalid font" );
+ wxCHECK_MSG( m_font.Ok(), 12, _T("invalid font") );
GdkFont *font = m_font.GetInternalFont( 1.0 );
int wxWindow::GetCharWidth() const
{
- wxCHECK_MSG( (m_widget != NULL), 8, "invalid window" );
+ wxCHECK_MSG( (m_widget != NULL), 8, _T("invalid window") );
- wxCHECK_MSG( m_font.Ok(), 8, "invalid font" );
+ wxCHECK_MSG( m_font.Ok(), 8, _T("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
+void wxWindow::GetTextExtent( const wxString& string,
+ int *x,
+ int *y,
+ int *descent,
+ int *externalLeading,
+ const wxFont *theFont ) const
{
wxFont fontToUse = m_font;
if (theFont) fontToUse = *theFont;
- wxCHECK_RET( fontToUse.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 (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)
- {
- wxWindow *win = (wxWindow *)node->Data();
- if (win != this) win->Enable(!modal);
-
- node = node->Next();
- }
- }
-}
-
-void wxWindow::OnKeyDown( wxKeyEvent &event )
-{
- event.SetEventType( wxEVT_CHAR );
-
- if (!GetEventHandler()->ProcessEvent( event ))
- {
- event.Skip();
- }
-}
-
void wxWindow::SetFocus()
{
- wxCHECK_RET( (m_widget != NULL), "invalid window" );
+ wxCHECK_RET( (m_widget != NULL), _T("invalid window") );
GtkWidget *connect_widget = GetConnectWidget();
if (connect_widget)
}
}
-wxWindow *wxWindow::FindFocus()
-{
- return g_focusWindow;
-}
-
bool wxWindow::AcceptsFocus() const
{
- return IsEnabled() && IsShown() && m_acceptsFocus;
-}
-
-void wxWindow::AddChild( wxWindow *child )
-{
- wxCHECK_RET( (m_widget != NULL), "invalid window" );
- wxCHECK_RET( (child != NULL), "invalid child" );
-
- m_children.Append( child );
+ return m_acceptsFocus && wxWindowBase::AcceptsFocus();
}
-wxWindow *wxWindow::ReParent( wxWindow *newParent )
+bool wxWindow::Reparent( wxWindow *newParent )
{
- wxCHECK_MSG( (m_widget != NULL), (wxWindow*) NULL, "invalid window" );
+ wxCHECK_MSG( (m_widget != NULL), FALSE, _T("invalid window") );
- wxWindow *oldParent = GetParent();
+ wxWindow *oldParent = m_parent;
- if (oldParent) oldParent->RemoveChild( this );
+ if ( !wxWindowBase::Reparent(newParent) )
+ return FALSE;
- gtk_widget_unparent( m_widget );
+ if (oldParent)
+ {
+ gtk_container_remove( GTK_CONTAINER(oldParent->m_wxwindow), m_widget );
+ }
if (newParent)
{
- newParent->AddChild( this );
- (newParent->m_insertCallback)( newParent, this );
+ /* insert GTK representation */
+ (*(newParent->m_insertCallback))(newParent, this);
}
- return oldParent;
-}
-
-void wxWindow::RemoveChild( wxWindow *child )
-{
- m_children.DeleteObject( child );
- child->m_parent = (wxWindow *) NULL;
-}
-
-void wxWindow::SetReturnCode( int retCode )
-{
- m_retCode = retCode;
-}
-
-int wxWindow::GetReturnCode()
-{
- return m_retCode;
+ return TRUE;
}
-void wxWindow::Raise()
+void wxWindow::DoAddChild(wxWindow *child)
{
- wxCHECK_RET( (m_widget != NULL), "invalid window" );
+ wxASSERT_MSG( (m_widget != NULL), _T("invalid window") );
- if (m_widget) gdk_window_raise( m_widget->window );
-}
+ wxASSERT_MSG( (child != NULL), _T("invalid child window") );
-void wxWindow::Lower()
-{
- wxCHECK_RET( (m_widget != NULL), "invalid window" );
+ wxASSERT_MSG( (m_insertCallback != NULL), _T("invalid child insertion function") );
- if (m_widget) gdk_window_lower( m_widget->window );
-}
+ /* add to list */
+ AddChild( child );
-wxEvtHandler *wxWindow::GetEventHandler() const
-{
- return m_eventHandler;
+ /* insert GTK representation */
+ (*m_insertCallback)(this, child);
}
-void wxWindow::SetEventHandler( wxEvtHandler *handler )
+void wxWindow::Raise()
{
- m_eventHandler = handler;
-}
+ wxCHECK_RET( (m_widget != NULL), _T("invalid window") );
-void wxWindow::PushEventHandler(wxEvtHandler *handler)
-{
- handler->SetNextHandler(GetEventHandler());
- SetEventHandler(handler);
-}
+ if (!m_widget->window) return;
-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;
+ gdk_window_raise( m_widget->window );
}
-wxValidator *wxWindow::GetValidator()
+void wxWindow::Lower()
{
- return m_windowValidator;
-}
+ wxCHECK_RET( (m_widget != NULL), _T("invalid 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_widget->window) return;
-void wxWindow::SetClientObject( wxClientData *data )
-{
- if (m_clientObject) delete m_clientObject;
- m_clientObject = data;
+ gdk_window_lower( m_widget->window );
}
-wxClientData *wxWindow::GetClientObject()
+bool wxWindow::SetCursor( const wxCursor &cursor )
{
- return m_clientObject;
-}
+ wxCHECK_MSG( (m_widget != NULL), FALSE, _T("invalid window") );
-void wxWindow::SetClientData( void *data )
-{
- m_clientData = data;
-}
+ if (!wxWindowBase::SetCursor(cursor))
+ {
+ // don't leave if the GTK widget has just
+ // been realized
+ if (!m_delayedCursor) return FALSE;
+ }
-void *wxWindow::GetClientData()
-{
- return m_clientData;
-}
+ GtkWidget *connect_widget = GetConnectWidget();
+ if (!connect_widget->window)
+ {
+ // indicate that a new style has been set
+ // but it couldn't get applied as the
+ // widget hasn't been realized yet.
+ m_delayedCursor = TRUE;
-bool wxWindow::IsBeingDeleted()
-{
- return FALSE;
-}
+ // pretend we have done something
+ return TRUE;
+ }
-void wxWindow::SetId( wxWindowID id )
-{
- m_windowId = id;
-}
+// gdk_window_set_cursor( connect_widget->window, GetCursor().GetCursor() );
-wxWindowID wxWindow::GetId() const
-{
- return m_windowId;
+ // cursor was set
+ return TRUE;
}
-void wxWindow::SetCursor( const wxCursor &cursor )
+void wxWindow::WarpPointer( int x, int y )
{
- wxCHECK_RET( (m_widget != NULL), "invalid window" );
+ wxCHECK_RET( (m_widget != NULL), _T("invalid window") );
- if (cursor.Ok())
- {
- if (cursor == *m_cursor) return;
- *m_cursor = cursor;
- }
- else
+ GtkWidget *connect_widget = GetConnectWidget();
+ if (connect_widget->window)
{
- *m_cursor = *wxSTANDARD_CURSOR;
+ /* we provide this function ourselves as it is
+ missing in GDK */
+ gdk_window_warp_pointer( connect_widget->window, x, y );
}
-
- 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() );
-}
-
-void wxWindow::WarpPointer( int WXUNUSED(x), int WXUNUSED(y) )
-{
- // TODO
}
void wxWindow::Refresh( bool eraseBackground, const wxRect *rect )
{
- wxCHECK_RET( (m_widget != NULL), "invalid window" );
+ wxCHECK_RET( (m_widget != NULL), _T("invalid window") );
+
+ if (!m_widget->window) return;
if (eraseBackground && m_wxwindow && m_wxwindow->window)
{
}
}
-wxRegion wxWindow::GetUpdateRegion() const
-{
- return m_updateRegion;
-}
-
-bool wxWindow::IsExposed( int x, int y) const
-{
- 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 );
-}
-
-bool wxWindow::IsExposed( const wxPoint& pt ) const
-{
- 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 );
-}
-
void wxWindow::Clear()
{
- wxCHECK_RET( m_widget != NULL, "invalid window" );
+ wxCHECK_RET( m_widget != NULL, _T("invalid window") );
+
+ if (!m_widget->window) return;
if (m_wxwindow && 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 )
+void wxWindow::DoSetToolTip( wxToolTip *tip )
{
- if (m_toolTip)
- {
- m_toolTip->SetTip( (char*) NULL );
- delete m_toolTip;
- }
+ wxWindowBase::DoSetToolTip(tip);
- m_toolTip = tip;
-
- if (m_toolTip)
- m_toolTip->Apply( this );
+ if (m_tooltip)
+ m_tooltip->Apply( this );
}
-void wxWindow::ApplyToolTip( GtkTooltips *tips, const char *tip )
+void wxWindow::ApplyToolTip( GtkTooltips *tips, const wxChar *tip )
{
- gtk_tooltips_set_tip( tips, GetConnectWidget(), tip, (gchar*) NULL );
+ gtk_tooltips_set_tip( tips, GetConnectWidget(), wxConvCurrent->cWX2MB(tip), (gchar*) NULL );
}
#endif // wxUSE_TOOLTIPS
-wxColour wxWindow::GetBackgroundColour() const
+bool wxWindow::SetBackgroundColour( const wxColour &colour )
{
- return m_backgroundColour;
-}
+ wxCHECK_MSG( m_widget != NULL, FALSE, _T("invalid window") );
-void wxWindow::SetBackgroundColour( const wxColour &colour )
-{
- wxCHECK_RET( m_widget != NULL, "invalid window" );
+ if (!wxWindowBase::SetBackgroundColour(colour))
+ {
+ // don't leave if the GTK widget has just
+ // been realized
+ if (!m_delayedBackgroundColour) return FALSE;
+ }
- if (m_backgroundColour == colour) return;
+ GtkWidget *connect_widget = GetConnectWidget();
+ if (!connect_widget->window)
+ {
+ // indicate that a new style has been set
+ // but it couldn't get applied as the
+ // widget hasn't been realized yet.
+ m_delayedBackgroundColour = TRUE;
- m_backgroundColour = colour;
- if (!m_backgroundColour.Ok()) return;
+ // pretend we have done something
+ return TRUE;
+ }
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. */
-
+ /* 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())
+ if (sysbg == m_backgroundColour)
{
m_backgroundColour = wxNullColour;
ApplyWidgetStyle();
{
ApplyWidgetStyle();
}
-}
-wxColour wxWindow::GetForegroundColour() const
-{
- return m_foregroundColour;
+ return TRUE;
}
-void wxWindow::SetForegroundColour( const wxColour &colour )
+bool wxWindow::SetForegroundColour( const wxColour &colour )
{
- wxCHECK_RET( m_widget != NULL, "invalid window" );
+ wxCHECK_MSG( m_widget != NULL, FALSE, _T("invalid window") );
+
+ if (!wxWindowBase::SetForegroundColour(colour))
+ {
+ // don't leave if the GTK widget has just
+ // been realized
+ if (!m_delayedForegroundColour) return FALSE;
+ }
- if (m_foregroundColour == colour) return;
+ GtkWidget *connect_widget = GetConnectWidget();
+ if (!connect_widget->window)
+ {
+ // indicate that a new style has been set
+ // but it couldn't get applied as the
+ // widget hasn't been realized yet.
+ m_delayedForegroundColour = TRUE;
- m_foregroundColour = colour;
- if (!m_foregroundColour.Ok()) return;
+ // pretend we have done something
+ return TRUE;
+ }
wxColour sysbg = wxSystemSettings::GetSystemColour( wxSYS_COLOUR_BTNFACE );
- if (sysbg.Red() == colour.Red() &&
- sysbg.Green() == colour.Green() &&
- sysbg.Blue() == colour.Blue())
+ if ( sysbg == m_backgroundColour )
{
m_backgroundColour = wxNullColour;
ApplyWidgetStyle();
{
ApplyWidgetStyle();
}
+
+ return TRUE;
}
GtkStyle *wxWindow::GetWidgetStyle()
{
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;
}
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()
-{
-}
-
-bool wxWindow::Validate()
-{
- 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;
-}
-
-bool wxWindow::TransferDataToWindow()
-{
- 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() )
- {
- wxMessageBox( _("Application Error"), _("Could not transfer data to window"), wxOK|wxICON_EXCLAMATION );
- return FALSE;
- }
- node = node->Next();
- }
- return TRUE;
-}
-
-bool wxWindow::TransferDataFromWindow()
-{
- wxCHECK_MSG( m_widget != NULL, FALSE, "invalid window" );
-
- wxNode *node = m_children.First();
- while (node)
+ if (m_backgroundColour.Ok())
{
- wxWindow *child = (wxWindow *)node->Data();
- if ( child->GetValidator() && /* child->GetValidator()->Ok() && */ !child->GetValidator()->TransferFromWindow() )
- {
- return FALSE;
- }
- node = node->Next();
+ 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();
}
- return TRUE;
}
-void wxWindow::SetAcceleratorTable( const wxAcceleratorTable& accel )
-{
- m_acceleratorTable = accel;
-}
-
-void wxWindow::OnInitDialog( wxInitDialogEvent &WXUNUSED(event) )
-{
- TransferDataToWindow();
-}
-
-void wxWindow::InitDialog()
+void wxWindow::ApplyWidgetStyle()
{
- wxCHECK_RET( m_widget != NULL, "invalid window" );
-
- wxInitDialogEvent event(GetId());
- event.SetEventObject( this );
- GetEventHandler()->ProcessEvent(event);
}
static void SetInvokingWindow( wxMenu *menu, wxWindow *win )
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 )
+static void pop_pos_callback( GtkMenu * WXUNUSED(menu),
+ gint *x, gint *y,
+ wxWindow *win )
{
win->ClientToScreen( &gs_pop_x, &gs_pop_y );
*x = gs_pop_x;
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, "invalid popup-menu" );
+ wxCHECK_MSG( menu != NULL, FALSE, _T("invalid popup-menu") );
SetInvokingWindow( menu, this );
void wxWindow::SetDropTarget( wxDropTarget *dropTarget )
{
- wxCHECK_RET( m_widget != NULL, "invalid window" );
+ wxCHECK_RET( m_widget != NULL, _T("invalid window") );
GtkWidget *dnd_widget = GetConnectWidget();
if (m_dropTarget) m_dropTarget->RegisterWidget( dnd_widget );
}
-wxDropTarget *wxWindow::GetDropTarget() const
-{
- return m_dropTarget;
-}
-
-#endif
+#endif // wxUSE_DRAG_AND_DROP
GtkWidget* wxWindow::GetConnectWidget()
{
return (window == m_widget->window);
}
-void wxWindow::SetFont( const wxFont &font )
+bool wxWindow::SetFont( const wxFont &font )
{
- wxCHECK_RET( m_widget != NULL, "invalid window" );
-
- if (m_font == font) return;
-
- if (((wxFont*)&font)->Ok())
- m_font = font;
- else
- m_font = *wxSWISS_FONT;
+ wxCHECK_MSG( m_widget != NULL, FALSE, _T( "invalid window") );
+
+ if (!wxWindowBase::SetFont(font))
+ {
+ // don't leave if the GTK widget has just
+ // been realized
+ if (!m_delayedFont) return FALSE;
+ }
+
+ GtkWidget *connect_widget = GetConnectWidget();
+ if (!connect_widget->window)
+ {
+ // indicate that a new style has been set
+ // but it couldn't get applied as the
+ // widget hasn't been realized yet.
+ m_delayedFont = TRUE;
+
+ // pretend we have done something
+ return TRUE;
+ }
wxColour sysbg = wxSystemSettings::GetSystemColour( wxSYS_COLOUR_BTNFACE );
- if (sysbg.Red() == m_backgroundColour.Red() &&
- sysbg.Green() == m_backgroundColour.Green() &&
- sysbg.Blue() == m_backgroundColour.Blue())
+ if ( sysbg == m_backgroundColour )
{
m_backgroundColour = wxNullColour;
ApplyWidgetStyle();
{
ApplyWidgetStyle();
}
-}
-void wxWindow::SetWindowStyleFlag( long flag )
-{
- m_windowStyle = flag;
-}
-
-long wxWindow::GetWindowStyleFlag() const
-{
- return m_windowStyle;
+ return TRUE;
}
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_captureWindow == NULL, _T("CaptureMouse called twice") );
GtkWidget *connect_widget = GetConnectWidget();
- gtk_grab_add( connect_widget );
+ if (!connect_widget->window) return;
+
gdk_pointer_grab( connect_widget->window, FALSE,
(GdkEventMask)
(GDK_BUTTON_PRESS_MASK |
GDK_BUTTON_RELEASE_MASK |
GDK_POINTER_MOTION_MASK),
(GdkWindow *) NULL,
- (GdkCursor *) NULL,
+ m_cursor.GetCursor(),
GDK_CURRENT_TIME );
- g_capturing = TRUE;
+ g_captureWindow = this;
}
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_captureWindow, _T("ReleaseMouse called twice") );
GtkWidget *connect_widget = GetConnectWidget();
- gtk_grab_remove( connect_widget );
- gdk_pointer_ungrab ( GDK_CURRENT_TIME );
- g_capturing = FALSE;
-}
+ if (!connect_widget->window) return;
-void wxWindow::SetTitle( const wxString &WXUNUSED(title) )
-{
-}
-
-wxString wxWindow::GetTitle() const
-{
- return (wxString&)m_windowName;
-}
-
-wxString wxWindow::GetLabel() const
-{
- return GetTitle();
-}
-
-void wxWindow::SetName( const wxString &name )
-{
- m_windowName = name;
-}
-
-wxString wxWindow::GetName() const
-{
- return (wxString&)m_windowName;
-}
-
-bool wxWindow::IsShown() const
-{
- return m_isShown;
+ gdk_pointer_ungrab ( GDK_CURRENT_TIME );
+ g_captureWindow = (wxWindow*) NULL;
}
-bool wxWindow::IsRetained()
+bool wxWindow::IsRetained() const
{
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;
-}
-
-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;
-}
-
void wxWindow::SetScrollbar( int orient, int pos, int thumbVisible,
int range, bool refresh )
{
- wxCHECK_RET( m_widget != NULL, "invalid window" );
+ wxCHECK_RET( m_widget != NULL, _T("invalid window") );
- wxCHECK_RET( m_wxwindow != NULL, "window needs client area for scrolling" );
+ wxCHECK_RET( m_wxwindow != NULL, _T("window needs client area for scrolling") );
m_hasScrolling = TRUE;
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" );
-
- gtk_widget_set_usize( m_widget, m_width, m_height );
- }
+ if (orient == wxHORIZONTAL)
+ gtk_signal_emit_by_name( GTK_OBJECT(m_hAdjust), "changed" );
+ else
+ gtk_signal_emit_by_name( GTK_OBJECT(m_vAdjust), "changed" );
}
void wxWindow::SetScrollPos( int orient, int pos, bool WXUNUSED(refresh) )
{
- wxCHECK_RET( m_widget != NULL, "invalid window" );
+ wxCHECK_RET( m_widget != NULL, _T("invalid window") );
- wxCHECK_RET( m_wxwindow != NULL, "window needs client area for scrolling" );
+ wxCHECK_RET( m_wxwindow != NULL, _T("window needs client area for scrolling") );
if (orient == wxHORIZONTAL)
{
m_vAdjust->value = fpos;
}
- if (!m_isScrolling)
+ if (!m_isScrolling) /* prevent recursion */
{
if (m_wxwindow->window)
{
int wxWindow::GetScrollThumb( int orient ) const
{
- wxCHECK_MSG( m_widget != NULL, 0, "invalid window" );
+ wxCHECK_MSG( m_widget != NULL, 0, _T("invalid window") );
- wxCHECK_MSG( m_wxwindow != NULL, 0, "window needs client area for scrolling" );
+ wxCHECK_MSG( m_wxwindow != NULL, 0, _T("window needs client area for scrolling") );
if (orient == wxHORIZONTAL)
return (int)(m_hAdjust->page_size+0.5);
int wxWindow::GetScrollPos( int orient ) const
{
- wxCHECK_MSG( m_widget != NULL, 0, "invalid window" );
+ wxCHECK_MSG( m_widget != NULL, 0, _T("invalid window") );
- wxCHECK_MSG( m_wxwindow != NULL, 0, "window needs client area for scrolling" );
+ wxCHECK_MSG( m_wxwindow != NULL, 0, _T("window needs client area for scrolling") );
if (orient == wxHORIZONTAL)
return (int)(m_hAdjust->value+0.5);
int wxWindow::GetScrollRange( int orient ) const
{
- wxCHECK_MSG( m_widget != NULL, 0, "invalid window" );
+ wxCHECK_MSG( m_widget != NULL, 0, _T("invalid window") );
- wxCHECK_MSG( m_wxwindow != NULL, 0, "window needs client area for scrolling" );
+ wxCHECK_MSG( m_wxwindow != NULL, 0, _T("window needs client area for scrolling") );
if (orient == wxHORIZONTAL)
return (int)(m_hAdjust->upper+0.5);
void wxWindow::ScrollWindow( int dx, int dy, const wxRect* WXUNUSED(rect) )
{
- wxCHECK_RET( m_widget != NULL, "invalid window" );
+ wxCHECK_RET( m_widget != NULL, _T("invalid window") );
+
+ wxCHECK_RET( m_wxwindow != NULL, _T("window needs client area for scrolling") );
- wxCHECK_RET( m_wxwindow != NULL, "window needs client area for scrolling" );
+ if (!m_scrollGC)
+ {
+ m_scrollGC = gdk_gc_new( m_wxwindow->window );
+ gdk_gc_set_exposures( m_scrollGC, TRUE );
+ }
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 sx = 0;
+ int sy = 0;
+ child->GetSize( &sx, &sy );
+ child->SetSize( child->m_x + dx, child->m_y + dy, sx, sy, wxSIZE_ALLOW_MINUS_ONE );
+ node = node->Next();
}
int cw = 0;
int ch = 0;
GetClientSize( &cw, &ch );
-
int w = cw - abs(dx);
int h = ch - abs(dy);
+
if ((h < 0) || (w < 0))
{
Refresh();
- return;
- }
- int s_x = 0;
- int s_y = 0;
- if (dx < 0) s_x = -dx;
- if (dy < 0) s_y = -dy;
- int d_x = 0;
- 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 );
- }
-
- gdk_window_copy_area( m_wxwindow->window, m_scrollGC, d_x, d_y,
- m_wxwindow->window, s_x, s_y, w, h );
-
- wxRect rect;
- if (dx < 0) rect.x = cw+dx; else rect.x = 0;
- if (dy < 0) rect.y = ch+dy; else rect.y = 0;
- if (dy != 0) rect.width = cw; else rect.width = abs(dx);
- if (dx != 0) rect.height = ch; else rect.height = abs(dy);
-
- Refresh( TRUE, &rect );
-}
-
-//-------------------------------------------------------------------------------------
-// Layout
-//-------------------------------------------------------------------------------------
-
-wxLayoutConstraints *wxWindow::GetConstraints() const
-{
- return m_constraints;
-}
-
-void wxWindow::SetConstraints( wxLayoutConstraints *constraints )
-{
- if (m_constraints)
- {
- UnsetConstraints(m_constraints);
- delete m_constraints;
- }
- m_constraints = constraints;
- if (m_constraints)
- {
- // Make sure other windows know they're part of a 'meaningful relationship'
- if (m_constraints->left.GetOtherWindow() && (m_constraints->left.GetOtherWindow() != this))
- m_constraints->left.GetOtherWindow()->AddConstraintReference((wxWindow *)this);
- if (m_constraints->top.GetOtherWindow() && (m_constraints->top.GetOtherWindow() != this))
- m_constraints->top.GetOtherWindow()->AddConstraintReference((wxWindow *)this);
- if (m_constraints->right.GetOtherWindow() && (m_constraints->right.GetOtherWindow() != this))
- m_constraints->right.GetOtherWindow()->AddConstraintReference((wxWindow *)this);
- if (m_constraints->bottom.GetOtherWindow() && (m_constraints->bottom.GetOtherWindow() != this))
- m_constraints->bottom.GetOtherWindow()->AddConstraintReference((wxWindow *)this);
- if (m_constraints->width.GetOtherWindow() && (m_constraints->width.GetOtherWindow() != this))
- m_constraints->width.GetOtherWindow()->AddConstraintReference((wxWindow *)this);
- if (m_constraints->height.GetOtherWindow() && (m_constraints->height.GetOtherWindow() != this))
- m_constraints->height.GetOtherWindow()->AddConstraintReference((wxWindow *)this);
- if (m_constraints->centreX.GetOtherWindow() && (m_constraints->centreX.GetOtherWindow() != this))
- m_constraints->centreX.GetOtherWindow()->AddConstraintReference((wxWindow *)this);
- if (m_constraints->centreY.GetOtherWindow() && (m_constraints->centreY.GetOtherWindow() != this))
- m_constraints->centreY.GetOtherWindow()->AddConstraintReference((wxWindow *)this);
- }
-;
-}
-;
-
-void wxWindow::SetAutoLayout( bool autoLayout )
-{
- m_autoLayout = autoLayout;
-}
-
-bool wxWindow::GetAutoLayout() const
-{
- return m_autoLayout;
-}
-
-wxSizer *wxWindow::GetSizer() const
-{
- return m_windowSizer;
-}
-
-void wxWindow::SetSizerParent( wxWindow *win )
-{
- m_sizerParent = win;
-}
-
-wxWindow *wxWindow::GetSizerParent() const
-{
- return m_sizerParent;
-}
-
-// This removes any dangling pointers to this window
-// in other windows' constraintsInvolvedIn lists.
-void wxWindow::UnsetConstraints(wxLayoutConstraints *c)
-{
- if (c)
- {
- if (c->left.GetOtherWindow() && (c->top.GetOtherWindow() != this))
- c->left.GetOtherWindow()->RemoveConstraintReference((wxWindow *)this);
- if (c->top.GetOtherWindow() && (c->top.GetOtherWindow() != this))
- c->top.GetOtherWindow()->RemoveConstraintReference((wxWindow *)this);
- if (c->right.GetOtherWindow() && (c->right.GetOtherWindow() != this))
- c->right.GetOtherWindow()->RemoveConstraintReference((wxWindow *)this);
- if (c->bottom.GetOtherWindow() && (c->bottom.GetOtherWindow() != this))
- c->bottom.GetOtherWindow()->RemoveConstraintReference((wxWindow *)this);
- if (c->width.GetOtherWindow() && (c->width.GetOtherWindow() != this))
- c->width.GetOtherWindow()->RemoveConstraintReference((wxWindow *)this);
- if (c->height.GetOtherWindow() && (c->height.GetOtherWindow() != this))
- c->height.GetOtherWindow()->RemoveConstraintReference((wxWindow *)this);
- if (c->centreX.GetOtherWindow() && (c->centreX.GetOtherWindow() != this))
- c->centreX.GetOtherWindow()->RemoveConstraintReference((wxWindow *)this);
- if (c->centreY.GetOtherWindow() && (c->centreY.GetOtherWindow() != this))
- c->centreY.GetOtherWindow()->RemoveConstraintReference((wxWindow *)this);
- }
-}
-
-// Back-pointer to other windows we're involved with, so if we delete
-// this window, we must delete any constraints we're involved with.
-void wxWindow::AddConstraintReference(wxWindow *otherWin)
-{
- if (!m_constraintsInvolvedIn)
- m_constraintsInvolvedIn = new wxList;
- if (!m_constraintsInvolvedIn->Member(otherWin))
- m_constraintsInvolvedIn->Append(otherWin);
-}
-
-// REMOVE back-pointer to other windows we're involved with.
-void wxWindow::RemoveConstraintReference(wxWindow *otherWin)
-{
- if (m_constraintsInvolvedIn)
- m_constraintsInvolvedIn->DeleteObject(otherWin);
-}
-
-// Reset any constraints that mention this window
-void wxWindow::DeleteRelatedConstraints()
-{
- if (m_constraintsInvolvedIn)
- {
- wxNode *node = m_constraintsInvolvedIn->First();
- while (node)
- {
- wxWindow *win = (wxWindow *)node->Data();
- wxNode *next = node->Next();
- wxLayoutConstraints *constr = win->GetConstraints();
-
- // Reset any constraints involving this window
- if (constr)
- {
- constr->left.ResetIfWin((wxWindow *)this);
- constr->top.ResetIfWin((wxWindow *)this);
- constr->right.ResetIfWin((wxWindow *)this);
- constr->bottom.ResetIfWin((wxWindow *)this);
- constr->width.ResetIfWin((wxWindow *)this);
- constr->height.ResetIfWin((wxWindow *)this);
- constr->centreX.ResetIfWin((wxWindow *)this);
- constr->centreY.ResetIfWin((wxWindow *)this);
- }
- delete node;
- node = next;
- }
- delete m_constraintsInvolvedIn;
- m_constraintsInvolvedIn = (wxList *) NULL;
- }
-}
-
-void wxWindow::SetSizer(wxSizer *sizer)
-{
- m_windowSizer = sizer;
- if (sizer)
- sizer->SetSizerParent((wxWindow *)this);
-}
-
-/*
- * New version
- */
-
-bool wxWindow::Layout()
-{
- if (GetConstraints())
- {
- int w, h;
- GetClientSize(&w, &h);
- GetConstraints()->width.SetValue(w);
- GetConstraints()->height.SetValue(h);
- }
-
- // If top level (one sizer), evaluate the sizer's constraints.
- if (GetSizer())
- {
- int noChanges;
- GetSizer()->ResetConstraints(); // Mark all constraints as unevaluated
- GetSizer()->LayoutPhase1(&noChanges);
- GetSizer()->LayoutPhase2(&noChanges);
- GetSizer()->SetConstraintSizes(); // Recursively set the real window sizes
- return TRUE;
- }
- else
- {
- // Otherwise, evaluate child constraints
- ResetConstraints(); // Mark all constraints as unevaluated
- DoPhase(1); // Just one phase need if no sizers involved
- DoPhase(2);
- SetConstraintSizes(); // Recursively set the real window sizes
- }
- return TRUE;
-}
-
-
-// Do a phase of evaluating constraints:
-// the default behaviour. wxSizers may do a similar
-// thing, but also impose their own 'constraints'
-// and order the evaluation differently.
-bool wxWindow::LayoutPhase1(int *noChanges)
-{
- wxLayoutConstraints *constr = GetConstraints();
- if (constr)
- {
- return constr->SatisfyConstraints((wxWindow *)this, noChanges);
- }
- else
- return TRUE;
-}
-
-bool wxWindow::LayoutPhase2(int *noChanges)
-{
- *noChanges = 0;
-
- // Layout children
- DoPhase(1);
- DoPhase(2);
- return TRUE;
-}
-
-// Do a phase of evaluating child constraints
-bool wxWindow::DoPhase(int phase)
-{
- int noIterations = 0;
- int maxIterations = 500;
- int noChanges = 1;
- int noFailures = 0;
- wxList succeeded;
- while ((noChanges > 0) && (noIterations < maxIterations))
- {
- noChanges = 0;
- noFailures = 0;
- wxNode *node = m_children.First();
- while (node)
- {
- wxWindow *child = (wxWindow *)node->Data();
- if (!child->IsKindOf(CLASSINFO(wxFrame)) && !child->IsKindOf(CLASSINFO(wxDialog)))
- {
- wxLayoutConstraints *constr = child->GetConstraints();
- if (constr)
- {
- if (succeeded.Member(child))
- {
- }
- else
- {
- int tempNoChanges = 0;
- bool success = ( (phase == 1) ? child->LayoutPhase1(&tempNoChanges) : child->LayoutPhase2(&tempNoChanges) ) ;
- noChanges += tempNoChanges;
- if (success)
- {
- succeeded.Append(child);
- }
- }
- }
- }
- node = node->Next();
- }
- noIterations ++;
- }
- return TRUE;
-}
-
-void wxWindow::ResetConstraints()
-{
- wxLayoutConstraints *constr = GetConstraints();
- if (constr)
- {
- constr->left.SetDone(FALSE);
- constr->top.SetDone(FALSE);
- constr->right.SetDone(FALSE);
- constr->bottom.SetDone(FALSE);
- constr->width.SetDone(FALSE);
- constr->height.SetDone(FALSE);
- constr->centreX.SetDone(FALSE);
- constr->centreY.SetDone(FALSE);
- }
- wxNode *node = m_children.First();
- while (node)
- {
- wxWindow *win = (wxWindow *)node->Data();
- if (!win->IsKindOf(CLASSINFO(wxFrame)) && !win->IsKindOf(CLASSINFO(wxDialog)))
- win->ResetConstraints();
- node = node->Next();
- }
-}
-
-// Need to distinguish between setting the 'fake' size for
-// windows and sizers, and setting the real values.
-void wxWindow::SetConstraintSizes(bool recurse)
-{
- wxLayoutConstraints *constr = GetConstraints();
- if (constr && constr->left.GetDone() && constr->right.GetDone() &&
- constr->width.GetDone() && constr->height.GetDone())
- {
- int x = constr->left.GetValue();
- int y = constr->top.GetValue();
- int w = constr->width.GetValue();
- int h = constr->height.GetValue();
-
- // If we don't want to resize this window, just move it...
- if ((constr->width.GetRelationship() != wxAsIs) ||
- (constr->height.GetRelationship() != wxAsIs))
- {
- // Calls Layout() recursively. AAAGH. How can we stop that.
- // Simply take Layout() out of non-top level OnSizes.
- SizerSetSize(x, y, w, h);
}
else
{
- SizerMove(x, y);
- }
- }
- else if (constr)
- {
- char *windowClass = this->GetClassInfo()->GetClassName();
-
- wxString winName;
- if (GetName() == "")
- winName = "unnamed";
- else
- winName = GetName();
- 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" );
- if (!constr->height.GetDone()) wxLogDebug( " unsatisfied 'height' constraint.\n" );
- wxLogDebug( "Please check constraints: try adding AsIs() constraints.\n" );
- }
-
- if (recurse)
- {
- wxNode *node = m_children.First();
- while (node)
- {
- wxWindow *win = (wxWindow *)node->Data();
- if (!win->IsKindOf(CLASSINFO(wxFrame)) && !win->IsKindOf(CLASSINFO(wxDialog)))
- win->SetConstraintSizes();
- node = node->Next();
- }
- }
-}
+ int s_x = 0;
+ int s_y = 0;
+ if (dx < 0) s_x = -dx;
+ if (dy < 0) s_y = -dy;
+ int d_x = 0;
+ int d_y = 0;
+ if (dx > 0) d_x = dx;
+ if (dy > 0) d_y = dy;
-// This assumes that all sizers are 'on' the same
-// window, i.e. the parent of this window.
-void wxWindow::TransformSizerToActual(int *x, int *y) const
-{
- if (!m_sizerParent || m_sizerParent->IsKindOf(CLASSINFO(wxDialog)) ||
- m_sizerParent->IsKindOf(CLASSINFO(wxFrame)) )
- return;
-
- int xp, yp;
- m_sizerParent->GetPosition(&xp, &yp);
- m_sizerParent->TransformSizerToActual(&xp, &yp);
- *x += xp;
- *y += yp;
-}
-
-void wxWindow::SizerSetSize(int x, int y, int w, int h)
-{
- int xx = x;
- int yy = y;
- TransformSizerToActual(&xx, &yy);
- SetSize(xx, yy, w, h);
-}
-
-void wxWindow::SizerMove(int x, int y)
-{
- int xx = x;
- int yy = y;
- TransformSizerToActual(&xx, &yy);
- Move(xx, yy);
-}
+ gdk_window_copy_area( m_wxwindow->window, m_scrollGC, d_x, d_y,
+ m_wxwindow->window, s_x, s_y, w, h );
-// Only set the size/position of the constraint (if any)
-void wxWindow::SetSizeConstraint(int x, int y, int w, int h)
-{
- wxLayoutConstraints *constr = GetConstraints();
- if (constr)
- {
- if (x != -1)
- {
- constr->left.SetValue(x);
- constr->left.SetDone(TRUE);
- }
- if (y != -1)
- {
- constr->top.SetValue(y);
- constr->top.SetDone(TRUE);
- }
- if (w != -1)
- {
- constr->width.SetValue(w);
- constr->width.SetDone(TRUE);
- }
- if (h != -1)
- {
- constr->height.SetValue(h);
- constr->height.SetDone(TRUE);
- }
- }
-}
+ wxRect rect;
+ if (dx < 0) rect.x = cw+dx; else rect.x = 0;
+ if (dy < 0) rect.y = ch+dy; else rect.y = 0;
+ if (dy != 0) rect.width = cw; else rect.width = abs(dx);
+ if (dx != 0) rect.height = ch; else rect.height = abs(dy);
-void wxWindow::MoveConstraint(int x, int y)
-{
- wxLayoutConstraints *constr = GetConstraints();
- if (constr)
- {
- if (x != -1)
- {
- constr->left.SetValue(x);
- constr->left.SetDone(TRUE);
+ Refresh( TRUE, &rect );
}
- if (y != -1)
- {
- constr->top.SetValue(y);
- constr->top.SetDone(TRUE);
- }
- }
-}
-
-void wxWindow::GetSizeConstraint(int *w, int *h) const
-{
- wxLayoutConstraints *constr = GetConstraints();
- if (constr)
- {
- *w = constr->width.GetValue();
- *h = constr->height.GetValue();
- }
- else
- GetSize(w, h);
}
-void wxWindow::GetClientSizeConstraint(int *w, int *h) const
+void wxWindow::SetScrolling(bool scroll)
{
- wxLayoutConstraints *constr = GetConstraints();
- if (constr)
- {
- *w = constr->width.GetValue();
- *h = constr->height.GetValue();
- }
- else
- GetClientSize(w, h);
-}
-
-void wxWindow::GetPositionConstraint(int *x, int *y) const
-{
- wxLayoutConstraints *constr = GetConstraints();
- if (constr)
- {
- *x = constr->left.GetValue();
- *y = constr->top.GetValue();
- }
- else
- GetPosition(x, y);
+ m_isScrolling = g_blockEventsOnScroll = scroll;
}
-
projects / wxWidgets.git / blobdiff