#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
#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
//-----------------------------------------------------------------------------
// 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;
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_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_PRIOR; 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_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_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_PRIOR; 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_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;
if (scroll_window->hscrollbar_visible)
{
dh += 15; /* dh += hscrollbar->allocation.height; */
- dw += scroll_class->scrollbar_spacing;
+ dh += scroll_class->scrollbar_spacing;
}
}
static void gtk_window_expose_callback( GtkWidget *WXUNUSED(widget), GdkEventExpose *gdk_event, wxWindow *win )
{
- if ( !win->m_hasVMT )
+ if (!win->m_hasVMT)
+ return;
+
+ if (gdk_event->window != win->m_wxwindow->window)
return;
win->GetUpdateRegion().Union( gdk_event->area.x,
gdk_event->area.width,
gdk_event->area.height );
- if ( gdk_event->count > 0 )
+ if (gdk_event->count > 0)
return;
-/*
- printf( "OnExpose from " );
- if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
- printf( win->GetClassInfo()->GetClassName() );
- printf( ".\n" );
-*/
-
wxPaintEvent event( win->GetId() );
event.SetEventObject( win );
win->GetEventHandler()->ProcessEvent( event );
+/*
+ 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 (g_isIdle)
+ if (g_isIdle)
wxapp_install_idle_handler();
if (!win->m_hasVMT)
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->GetUpdateRegion().Clear();
static gint gtk_window_key_press_callback( GtkWidget *widget, GdkEventKey *gdk_event, wxWindow *win )
{
- if (g_isIdle)
+ if (g_isIdle)
wxapp_install_idle_handler();
if (!win->m_hasVMT) return FALSE;
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 = map_to_unmodified_wx_keysym( gdk_event->keyval );
-
+
/* sending unknown key events doesn't really make sense */
if (key_code == 0) return FALSE;
bool ret = FALSE;
-
- wxKeyEvent event( wxEVT_KEY_DOWN );
+
+ 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_y = y;
event.SetEventObject( win );
ret = win->GetEventHandler()->ProcessEvent( event );
-
- key_code = map_to_wx_keysym( gdk_event->keyval );
- /* wxMSW doesn't send char events with Alt pressed */
- if ((key_code != 0) &&
- ((gdk_event->state & GDK_MOD1_MASK) == 0) &&
- ((gdk_event->state & GDK_MOD1_MASK) == 0))
- {
- 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 ));
- }
+ key_code = map_to_wx_keysym( gdk_event->keyval );
+#if wxUSE_ACCEL
if (!ret)
{
wxWindow *ancestor = win;
ancestor = ancestor->GetParent();
}
}
+#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
+
+ /* win is a control: tab can be propagated up */
if ( (!ret) &&
((gdk_event->keyval == GDK_Tab) || (gdk_event->keyval == GDK_ISO_Left_Tab)) &&
(win->HasFlag(wxTE_PROCESS_TAB) == 0))
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) )
while (ancestor)
{
if (wxIsKindOf(ancestor,wxFrame))
- {
- wxFrame *frame = (wxFrame*) ancestor;
+ {
+ wxFrame *frame = (wxFrame*) ancestor;
wxMenuBar *menubar = frame->GetMenuBar();
- if (menubar)
- {
+ if (menubar)
+ {
wxNode *node = menubar->GetMenus().First();
- if (node)
- {
- wxMenu *firstMenu = (wxMenu*) node->Data();
- gtk_menu_shell_select_item(
- GTK_MENU_SHELL(menubar->m_menubar),
- firstMenu->m_owner );
-
- ret = TRUE;
- break;
- }
- }
- }
+ 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.
static gint gtk_window_key_release_callback( GtkWidget *widget, GdkEventKey *gdk_event, wxWindow *win )
{
- if (g_isIdle)
+ if (g_isIdle)
wxapp_install_idle_handler();
if (!win->m_hasVMT) return FALSE;
*/
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;
static gint gtk_window_button_press_callback( GtkWidget *widget, GdkEventButton *gdk_event, wxWindow *win )
{
- if (g_isIdle)
+ if (g_isIdle)
wxapp_install_idle_handler();
/*
// 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)
static gint gtk_window_button_release_callback( GtkWidget *widget, GdkEventButton *gdk_event, wxWindow *win )
{
- if (g_isIdle)
+ if (g_isIdle)
wxapp_install_idle_handler();
if (!win->m_hasVMT) return FALSE;
// 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)
static gint gtk_window_motion_notify_callback( GtkWidget *widget, GdkEventMotion *gdk_event, wxWindow *win )
{
- if (g_isIdle)
+ if (g_isIdle)
wxapp_install_idle_handler();
if (!win->m_hasVMT) return FALSE;
// 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)
static gint gtk_window_focus_in_callback( GtkWidget *widget, GdkEvent *WXUNUSED(event), wxWindow *win )
{
- if (g_isIdle)
+ if (g_isIdle)
wxapp_install_idle_handler();
if (!win->m_hasVMT) return FALSE;
static gint gtk_window_focus_out_callback( GtkWidget *widget, GdkEvent *WXUNUSED(event), wxWindow *win )
{
- if (g_isIdle)
+ if (g_isIdle)
wxapp_install_idle_handler();
if (!win->m_hasVMT) return FALSE;
static gint gtk_window_enter_callback( GtkWidget *widget, GdkEventCrossing *gdk_event, wxWindow *win )
{
- if (g_isIdle)
+ if (g_isIdle)
wxapp_install_idle_handler();
if (!win->m_hasVMT) return FALSE;
if (!win->IsOwnGtkWindow( gdk_event->window )) return FALSE;
- if (widget->window && win->GetCursor().Ok() )
- gdk_window_set_cursor( widget->window, win->GetCursor().GetCursor() );
-
wxMouseEvent event( wxEVT_ENTER_WINDOW );
+#if (GTK_MINOR_VERSION > 0)
event.SetTimestamp( gdk_event->time );
+#endif
event.SetEventObject( win );
int x = 0;
static gint gtk_window_leave_callback( GtkWidget *widget, GdkEventCrossing *gdk_event, wxWindow *win )
{
- if (g_isIdle)
+ if (g_isIdle)
wxapp_install_idle_handler();
if (!win->m_hasVMT) return FALSE;
if (g_blockEventsOnDrag) return FALSE;
if (!win->IsOwnGtkWindow( gdk_event->window )) return FALSE;
-
- if (widget->window && win->GetCursor().Ok() )
- gdk_window_set_cursor( widget->window, wxSTANDARD_CURSOR->GetCursor() );
wxMouseEvent event( wxEVT_LEAVE_WINDOW );
+#if (GTK_MINOR_VERSION > 0)
event.SetTimestamp( gdk_event->time );
+#endif
event.SetEventObject( win );
int x = 0;
static void gtk_window_vscroll_callback( GtkWidget *WXUNUSED(widget), wxWindow *win )
{
- if (g_isIdle)
+ if (g_isIdle)
wxapp_install_idle_handler();
if (g_blockEventsOnDrag) return;
static void gtk_window_hscroll_callback( GtkWidget *WXUNUSED(widget), wxWindow *win )
{
- if (g_isIdle)
+ if (g_isIdle)
wxapp_install_idle_handler();
if (g_blockEventsOnDrag) return;
static void gtk_window_vscroll_change_callback( GtkWidget *WXUNUSED(widget), wxWindow *win )
{
- if (g_isIdle)
+ if (g_isIdle)
wxapp_install_idle_handler();
if (g_blockEventsOnDrag) return;
static void gtk_window_hscroll_change_callback( GtkWidget *WXUNUSED(widget), wxWindow *win )
{
- if (g_isIdle)
+ if (g_isIdle)
wxapp_install_idle_handler();
if (g_blockEventsOnDrag) return;
GdkEventButton *WXUNUSED(gdk_event),
wxWindow *win )
{
- if (g_isIdle)
+ if (g_isIdle)
wxapp_install_idle_handler();
// don't test here as we can release the mouse while being over
static gint
gtk_window_realized_callback( GtkWidget * WXUNUSED(widget), wxWindow *win )
{
- if (g_isIdle)
+ if (g_isIdle)
wxapp_install_idle_handler();
if (win->m_delayedFont)
win->SetCursor( win->GetCursor() );
+ wxWindowCreateEvent event( win );
+ event.SetEventObject( win );
+ win->GetEventHandler()->ProcessEvent( event );
+
return FALSE;
}
m_scrollGC = (GdkGC*) NULL;
m_widgetStyle = (GtkStyle*) NULL;
- m_insertCallback = wxInsertChildInWindow;
+ m_insertCallback = (wxInsertChildFunction) NULL;
m_isStaticBox = FALSE;
+ m_isRadioButton = FALSE;
m_acceptsFocus = FALSE;
}
const wxPoint &pos, const wxSize &size,
long style, const wxString &name )
{
- PreCreation( parent, id, pos, size, style, name );
+ if (!PreCreation( parent, pos, size ) ||
+ !CreateBase( parent, id, pos, size, style, wxDefaultValidator, name ))
+ {
+ wxFAIL_MSG( _T("wxWindow creation failed") );
+ return FALSE;
+ }
+
+ m_insertCallback = wxInsertChildInWindow;
m_widget = gtk_scrolled_window_new( (GtkAdjustment *) NULL, (GtkAdjustment *) NULL );
GTK_WIDGET_UNSET_FLAGS( m_widget, GTK_CAN_FOCUS );
if (m_widgetStyle)
{
gtk_style_unref( m_widgetStyle );
- m_widgetStyle = (GtkStyle*) NULL;
+ m_widgetStyle = (GtkStyle*) NULL;
}
if (m_scrollGC)
{
gdk_gc_unref( m_scrollGC );
- m_scrollGC = (GdkGC*) NULL;
+ m_scrollGC = (GdkGC*) NULL;
}
if (m_wxwindow)
{
gtk_widget_destroy( m_wxwindow );
- m_wxwindow = (GtkWidget*) NULL;
+ m_wxwindow = (GtkWidget*) NULL;
}
if (m_widget)
{
gtk_widget_destroy( m_widget );
- m_widget = (GtkWidget*) NULL;
+ m_widget = (GtkWidget*) NULL;
}
}
-void wxWindow::PreCreation( wxWindow *parent,
- wxWindowID id,
- const wxPoint &pos,
- const wxSize &size,
- long style,
- const wxString &name )
+bool wxWindow::PreCreation( wxWindow *parent, const wxPoint &pos, const wxSize &size )
{
- wxASSERT_MSG( !m_needParent || parent, _T("Need complete parent.") );
-
- if ( !CreateBase(parent, id, pos, size, style, name) )
- {
- wxFAIL_MSG(_T("window creation failed"));
- }
+ wxCHECK_MSG( !m_needParent || parent, FALSE, _T("Need complete parent.") );
+ /* this turns -1 into 20 so that a minimal window is
+ visible even although -1,-1 has been given as the
+ size of the window. the same trick is used in other
+ ports and should make debugging easier */
m_width = WidthDefault(size.x);
m_height = HeightDefault(size.y);
m_x = (int)pos.x;
m_y = (int)pos.y;
- if (!parent) /* some reasonable defaults */
+ /* some reasonable defaults */
+ if (!parent)
{
if (m_x == -1)
{
if (m_y < 10) m_y = 10;
}
}
+
+ return TRUE;
}
void wxWindow::PostCreation()
/* 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 );
+ GTK_SIGNAL_FUNC(gtk_window_realized_callback), (gpointer) this );
m_hasVMT = TRUE;
}
}
else
{
- 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_maxHeight != -1) && (m_height > m_maxHeight)) m_height = m_maxHeight;
int border = 0;
+ int bottom_border = 0;
+
+ if (GTK_WIDGET_CAN_DEFAULT(m_widget))
+ {
+ /* the default button has a border around it */
+ border = 6;
+ bottom_border = 5;
+ }
- if (GTK_WIDGET_HAS_DEFAULT(m_widget))
- {
- /* the default button has a border around it */
- border = 5;
- }
-
- /* 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+2*border );
+ /* 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();
}
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 (HasFlag(wxRAISED_BORDER) || HasFlag(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 (HasFlag(wxRAISED_BORDER) || HasFlag(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
*/
+ 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;
}
}
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 (HasFlag(wxRAISED_BORDER) || HasFlag(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 ( HasFlag(wxRAISED_BORDER) || HasFlag(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
*/
+ 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; */
bool wxWindow::Reparent( wxWindow *newParent )
{
- wxCHECK_MSG( (m_widget != NULL), (wxWindow*) NULL, _T("invalid window") );
+ wxCHECK_MSG( (m_widget != NULL), FALSE, _T("invalid window") );
- gtk_widget_unparent( m_widget );
+ wxWindow *oldParent = m_parent;
if ( !wxWindowBase::Reparent(newParent) )
return FALSE;
+ if (oldParent)
+ {
+ gtk_container_remove( GTK_CONTAINER(oldParent->m_wxwindow), m_widget );
+ }
+
+ if (newParent)
+ {
+ /* insert GTK representation */
+ (*(newParent->m_insertCallback))(newParent, this);
+ }
+
return TRUE;
}
+void wxWindow::DoAddChild(wxWindow *child)
+{
+ wxASSERT_MSG( (m_widget != NULL), _T("invalid window") );
+
+ wxASSERT_MSG( (child != NULL), _T("invalid child window") );
+
+ wxASSERT_MSG( (m_insertCallback != NULL), _T("invalid child insertion function") );
+
+ /* add to list */
+ AddChild( child );
+
+ /* insert GTK representation */
+ (*m_insertCallback)(this, child);
+}
+
void wxWindow::Raise()
{
wxCHECK_RET( (m_widget != NULL), _T("invalid window") );
// been realized
if (!m_delayedCursor) 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_delayedCursor = TRUE;
-
- // pretend we have done something
+ // but it couldn't get applied as the
+ // widget hasn't been realized yet.
+ m_delayedCursor = TRUE;
+
+ // pretend we have done something
return TRUE;
}
- if ((m_widget) && (m_widget->window))
- gdk_window_set_cursor( m_widget->window, GetCursor().GetCursor() );
-
- if ((m_wxwindow) && (m_wxwindow->window))
- gdk_window_set_cursor( m_wxwindow->window, GetCursor().GetCursor() );
+// gdk_window_set_cursor( connect_widget->window, GetCursor().GetCursor() );
// cursor was set
return TRUE;
}
-void wxWindow::WarpPointer( int WXUNUSED(x), int WXUNUSED(y) )
+void wxWindow::WarpPointer( int x, int y )
{
- // TODO
+ wxCHECK_RET( (m_widget != NULL), _T("invalid window") );
+
+ GtkWidget *connect_widget = GetConnectWidget();
+ if (connect_widget->window)
+ {
+ /* we provide this function ourselves as it is
+ missing in GDK */
+ gdk_window_warp_pointer( connect_widget->window, x, y );
+ }
}
void wxWindow::Refresh( bool eraseBackground, const wxRect *rect )
void wxWindow::ApplyToolTip( GtkTooltips *tips, const wxChar *tip )
{
- gtk_tooltips_set_tip( tips, GetConnectWidget(), wxConv_current->cWX2MB(tip), (gchar*) NULL );
+ gtk_tooltips_set_tip( tips, GetConnectWidget(), wxConvCurrent->cWX2MB(tip), (gchar*) NULL );
}
#endif // wxUSE_TOOLTIPS
// been realized
if (!m_delayedBackgroundColour) 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_delayedBackgroundColour = TRUE;
-
- // pretend we have done something
+ // but it couldn't get applied as the
+ // widget hasn't been realized yet.
+ m_delayedBackgroundColour = TRUE;
+
+ // pretend we have done something
return TRUE;
}
}
wxColour sysbg = wxSystemSettings::GetSystemColour( wxSYS_COLOUR_BTNFACE );
-
if (sysbg == m_backgroundColour)
{
m_backgroundColour = wxNullColour;
// been realized
if (!m_delayedForegroundColour) 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_delayedForegroundColour = TRUE;
-
- // pretend we have done something
+ // but it couldn't get applied as the
+ // widget hasn't been realized yet.
+ m_delayedForegroundColour = TRUE;
+
+ // pretend we have done something
return TRUE;
}
wxColour sysbg = wxSystemSettings::GetSystemColour( wxSYS_COLOUR_BTNFACE );
- if (sysbg == m_foregroundColour)
+ if ( sysbg == m_backgroundColour )
{
m_backgroundColour = wxNullColour;
ApplyWidgetStyle();
{
}
+//-----------------------------------------------------------------------------
+// Pop-up menu stuff
+//-----------------------------------------------------------------------------
+
+static void gtk_pop_hide_callback( GtkWidget *WXUNUSED(widget), bool* is_waiting )
+{
+ *is_waiting = FALSE;
+}
+
static void SetInvokingWindow( wxMenu *menu, wxWindow *win )
{
menu->SetInvokingWindow( win );
*y = gs_pop_y;
}
-bool wxWindow::PopupMenu( wxMenu *menu, int x, int y )
+bool wxWindow::DoPopupMenu( wxMenu *menu, int x, int y )
{
wxCHECK_MSG( m_widget != NULL, FALSE, _T("invalid window") );
gs_pop_x = x;
gs_pop_y = y;
+ bool is_waiting = TRUE;
+
+ gtk_signal_connect( GTK_OBJECT(menu->m_menu), "hide",
+ GTK_SIGNAL_FUNC(gtk_pop_hide_callback), (gpointer)&is_waiting );
+
gtk_menu_popup(
GTK_MENU(menu->m_menu),
(GtkWidget *) NULL, // parent menu shell
0, // button used to activate it
0 //gs_timeLastClick // the time of activation
);
+
+ while (is_waiting)
+ {
+ while (gtk_events_pending())
+ gtk_main_iteration();
+ }
+
return TRUE;
}
bool wxWindow::SetFont( const wxFont &font )
{
- wxCHECK_MSG( m_widget != NULL, FALSE, _T( "invalid window") );
+ wxCHECK_MSG( m_widget != NULL, FALSE, _T( "invalid window") );
if (!wxWindowBase::SetFont(font))
{
// 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
+ // but it couldn't get applied as the
+ // widget hasn't been realized yet.
+ m_delayedFont = TRUE;
+
+ // pretend we have done something
return TRUE;
}
{
wxCHECK_RET( m_widget != NULL, _T("invalid window") );
- wxCHECK_RET( g_capturing == FALSE, _T("CaptureMouse called twice") );
+ wxCHECK_RET( g_captureWindow == NULL, _T("CaptureMouse called twice") );
GtkWidget *connect_widget = GetConnectWidget();
if (!connect_widget->window) return;
-
- gtk_grab_add( connect_widget );
+
gdk_pointer_grab( connect_widget->window, FALSE,
(GdkEventMask)
(GDK_BUTTON_PRESS_MASK |
GDK_BUTTON_RELEASE_MASK |
GDK_POINTER_MOTION_MASK),
(GdkWindow *) NULL,
- (GdkCursor *) NULL,
+ m_cursor.GetCursor(),
GDK_CURRENT_TIME );
- g_capturing = TRUE;
+ g_captureWindow = this;
}
void wxWindow::ReleaseMouse()
{
wxCHECK_RET( m_widget != NULL, _T("invalid window") );
- wxCHECK_RET( g_capturing == TRUE, _T("ReleaseMouse called twice") );
+ wxCHECK_RET( g_captureWindow, _T("ReleaseMouse called twice") );
GtkWidget *connect_widget = GetConnectWidget();
if (!connect_widget->window) return;
-
- gtk_grab_remove( connect_widget );
+
gdk_pointer_ungrab ( GDK_CURRENT_TIME );
- g_capturing = FALSE;
+ g_captureWindow = (wxWindow*) NULL;
}
bool wxWindow::IsRetained() const
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;
GetClientSize( &cw, &ch );
int w = cw - abs(dx);
int h = ch - abs(dy);
-
+
if ((h < 0) || (w < 0))
{
Refresh();
projects / wxWidgets.git / blobdiff