X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/39b44a399f090256ec313711e61567d2a05e3407..a83ea9c15a7ac7bbdc6686164cfcbbc21ae5031a:/src/gtk1/window.cpp?ds=sidebyside diff --git a/src/gtk1/window.cpp b/src/gtk1/window.cpp index d468e1b8e8..11167b3844 100644 --- a/src/gtk1/window.cpp +++ b/src/gtk1/window.cpp @@ -73,11 +73,6 @@ #include #endif -#ifdef __WXGTK20__ - #define SET_CONTAINER_FOCUS(w, d) gtk_widget_child_focus((w), (d)) -#else - #define SET_CONTAINER_FOCUS(w, d) gtk_container_focus(GTK_CONTAINER(w), (d)) -#endif #ifdef __WXGTK20__ #ifdef HAVE_XIM @@ -145,7 +140,7 @@ extern GtkContainerClass *pizza_parent_class; thw wxWindow class has a member variable called m_widget which holds a pointer to this widget. When the window class represents a GTK native widget, this is (in most cases) the only GTK widget the class manages. E.g. the - wxStatitText class handles only a GtkLabel widget a pointer to which you + wxStaticText class handles only a GtkLabel widget a pointer to which you can find in m_widget (defined in wxWindow) When the class has a client area for drawing into and for containing children @@ -235,28 +230,17 @@ static GdkGC *g_eraseGC = NULL; static wxWindowGTK *g_captureWindow = (wxWindowGTK*) NULL; static bool g_captureWindowHasMouse = FALSE; -/* extern */ wxWindowGTK *g_focusWindow = (wxWindowGTK*) NULL; +wxWindowGTK *g_focusWindow = (wxWindowGTK*) NULL; // the last window which had the focus - this is normally never NULL (except // if we never had focus at all) as even when g_focusWindow is NULL it still // keeps its previous value -static wxWindowGTK *g_focusWindowLast = (wxWindowGTK*) NULL; - -// the frame that is currently active (i.e. its child has focus). It is -// used to generate wxActivateEvents -static wxWindowGTK *g_activeFrame = (wxWindowGTK*) NULL; -static bool g_activeFrameLostFocus = FALSE; +wxWindowGTK *g_focusWindowLast = (wxWindowGTK*) NULL; // If a window get the focus set but has not been realized // yet, defer setting the focus to idle time. wxWindowGTK *g_delayedFocus = (wxWindowGTK*) NULL; -// if we detect that the app has got/lost the focus, we set this variable to -// either TRUE or FALSE and an activate event will be sent during the next -// OnIdle() call and it is reset to -1: this value means that we shouldn't -// send any activate events at all -static int g_sendActivateEvent = -1; - // 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; @@ -267,10 +251,6 @@ extern bool g_mainThreadLocked; // debug //----------------------------------------------------------------------------- -#ifndef __WXGTK20__ -#define DISABLE_STYLE_IF_BROKEN_THEME 0 -#endif - #ifdef __WXDEBUG__ #if wxUSE_THREADS @@ -636,7 +616,7 @@ static void gtk_window_draw_callback( GtkWidget *widget, #ifndef __WXUNIVERSAL__ GtkPizza *pizza = GTK_PIZZA (widget); - if (win->GetThemeEnabled()) + if (win->GetThemeEnabled() && win->GetBackgroundStyle() == wxBG_STYLE_SYSTEM) { wxWindow *parent = win->GetParent(); while (parent && !parent->IsTopLevel()) @@ -969,6 +949,33 @@ static inline bool wxIsAsciiKeysym(KeySym ks) return ks < 256; } +static void wxFillOtherKeyEventFields(wxKeyEvent& event, + wxWindowGTK *win, + GdkEventKey *gdk_event) +{ + int x = 0; + int y = 0; + GdkModifierType state; + if (gdk_event->window) + gdk_window_get_pointer(gdk_event->window, &x, &y, &state); + + event.SetTimestamp( gdk_event->time ); + event.m_shiftDown = (gdk_event->state & GDK_SHIFT_MASK) != 0; + event.m_controlDown = (gdk_event->state & GDK_CONTROL_MASK) != 0; + event.m_altDown = (gdk_event->state & GDK_MOD1_MASK) != 0; + event.m_metaDown = (gdk_event->state & GDK_MOD2_MASK) != 0; + event.m_scanCode = gdk_event->keyval; + event.m_rawCode = (wxUint32) gdk_event->keyval; + event.m_rawFlags = 0; +#if wxUSE_UNICODE + event.m_uniChar = gdk_keyval_to_unicode(gdk_event->keyval); +#endif + event.m_x = x; + event.m_y = y; + event.SetEventObject( win ); +} + + static bool wxTranslateGTKKeyEventToWx(wxKeyEvent& event, wxWindowGTK *win, @@ -1064,29 +1071,32 @@ wxTranslateGTKKeyEventToWx(wxKeyEvent& event, return FALSE; // now fill all the other fields - int x = 0; - int y = 0; - GdkModifierType state; - if (gdk_event->window) - gdk_window_get_pointer(gdk_event->window, &x, &y, &state); - - event.SetTimestamp( gdk_event->time ); - event.m_shiftDown = (gdk_event->state & GDK_SHIFT_MASK) != 0; - event.m_controlDown = (gdk_event->state & GDK_CONTROL_MASK) != 0; - event.m_altDown = (gdk_event->state & GDK_MOD1_MASK) != 0; - event.m_metaDown = (gdk_event->state & GDK_MOD2_MASK) != 0; + wxFillOtherKeyEventFields(event, win, gdk_event); + event.m_keyCode = key_code; - event.m_scanCode = gdk_event->keyval; - event.m_rawCode = (wxUint32) gdk_event->keyval; - event.m_rawFlags = 0; - event.m_x = x; - event.m_y = y; - event.SetEventObject( win ); return TRUE; } +#ifdef __WXGTK20__ +struct wxGtkIMData +{ + GtkIMContext *context; + GdkEventKey *lastKeyEvent; + + wxGtkIMData() + { + context = gtk_im_multicontext_new(); + lastKeyEvent = NULL; + } + ~wxGtkIMData() + { + g_object_unref(context); + } +}; +#endif + static gint gtk_window_key_press_callback( GtkWidget *widget, GdkEventKey *gdk_event, wxWindow *win ) @@ -1100,12 +1110,43 @@ static gint gtk_window_key_press_callback( GtkWidget *widget, return FALSE; if (g_blockEventsOnDrag) return FALSE; - - + +#ifdef __WXGTK20__ + // We have to pass key press events through GTK+'s Input Method context + // object in order to get correct characters. By doing so, we loose the + // ability to let other GTK+'s handlers (namely, widgets' default signal + // handlers) handle the signal by returning false from this callback. + // Because GTK+ sends the events to parent widgets as well, we can't + // afford loosing it, otherwise native widgets inserted into wxPanel + // would break in subtle ways (e.g. spacebar would no longer toggle + // wxCheckButton's state). Therefore, we only pass the event to IM if it + // originated in this window's widget, which we detect by checking if we've + // seen the same event before (no events from children are lost this way, + // because gtk_window_key_press_callback is installed for native controls + // as well and the wxKeyEvent it creates propagates upwards). + static GdkEventKey s_lastEvent; + + bool useIM = (win->m_imData != NULL) && + memcmp(gdk_event, &s_lastEvent, sizeof(GdkEventKey)) != 0; + + s_lastEvent = *gdk_event; +#endif + wxKeyEvent event( wxEVT_KEY_DOWN ); if ( !wxTranslateGTKKeyEventToWx(event, win, gdk_event) ) { // unknown key pressed, ignore (the event would be useless anyhow) +#ifdef __WXGTK20__ + if ( useIM ) + { + // it may be useful for the input method, though: + win->m_imData->lastKeyEvent = gdk_event; + bool ret = gtk_im_context_filter_keypress(win->m_imData->context, + gdk_event); + win->m_imData->lastKeyEvent = NULL; + return ret; + } +#endif return FALSE; } @@ -1136,58 +1177,64 @@ static gint gtk_window_key_press_callback( GtkWidget *widget, // will only be sent if it is not in an accelerator table. if (!ret) { - long key_code; - KeySym keysym = gdk_event->keyval; #ifdef __WXGTK20__ - // In GTK 2.0, we need to hand over the key event to an input method - // and the IM will emit a "commit" event containing the actual utf8 - // character. In that case the EVT_CHAR events will be sent from - // there. But only do it this way for non-KeySym keys. - key_code = wxTranslateKeySymToWXKey(gdk_event->keyval, FALSE /* isChar */); - if ( !key_code && win->m_imContext ) + if (useIM) { - gtk_im_context_filter_keypress ( (GtkIMContext*) win->m_imContext, gdk_event ); - ret = TRUE; + // In GTK 2.0, we need to hand over the key event to an input method + // and the IM will emit a "commit" event containing the actual utf8 + // character. In that case the EVT_CHAR events will be sent from + // there. + win->m_imData->lastKeyEvent = gdk_event; + if ( gtk_im_context_filter_keypress(win->m_imData->context, + gdk_event) ) + { + win->m_imData->lastKeyEvent = NULL; + wxLogTrace(TRACE_KEYS, _T("Key event intercepted by IM")); + return TRUE; + } + else + win->m_imData->lastKeyEvent = NULL; } - else #endif + + long key_code; + KeySym keysym = gdk_event->keyval; + // Find key code for EVT_CHAR and EVT_CHAR_HOOK events + key_code = wxTranslateKeySymToWXKey(keysym, TRUE /* isChar */); + if ( !key_code ) { - // Find key code for EVT_CHAR and EVT_CHAR_HOOK events - key_code = wxTranslateKeySymToWXKey(keysym, TRUE /* isChar */); - if ( !key_code ) + if ( wxIsAsciiKeysym(keysym) ) { - if ( gdk_event->length == 1 ) - { - key_code = (unsigned char)gdk_event->string[0]; - } - else if ( wxIsAsciiKeysym(keysym) ) - { - // ASCII key - key_code = (unsigned char)keysym; - } + // ASCII key + key_code = (unsigned char)keysym; } - - if ( key_code ) + // gdk_event->string is actually deprecated + else if ( gdk_event->length == 1 ) { - wxLogTrace(TRACE_KEYS, _T("Char event: %ld"), key_code); + key_code = (unsigned char)gdk_event->string[0]; + } + } - event.m_keyCode = key_code; + if ( key_code ) + { + wxLogTrace(TRACE_KEYS, _T("Char event: %ld"), key_code); - // Implement OnCharHook by checking ancesteror top level windows - wxWindow *parent = win; - while (parent && !parent->IsTopLevel()) - parent = parent->GetParent(); - if (parent) - { - event.SetEventType( wxEVT_CHAR_HOOK ); - ret = parent->GetEventHandler()->ProcessEvent( event ); - } + event.m_keyCode = key_code; - if (!ret) - { - event.SetEventType(wxEVT_CHAR); - ret = win->GetEventHandler()->ProcessEvent( event ); - } + // Implement OnCharHook by checking ancesteror top level windows + wxWindow *parent = win; + while (parent && !parent->IsTopLevel()) + parent = parent->GetParent(); + if (parent) + { + event.SetEventType( wxEVT_CHAR_HOOK ); + ret = parent->GetEventHandler()->ProcessEvent( event ); + } + + if (!ret) + { + event.SetEventType(wxEVT_CHAR); + ret = win->GetEventHandler()->ProcessEvent( event ); } } } @@ -1198,9 +1245,12 @@ static gint gtk_window_key_press_callback( GtkWidget *widget, // VZ: testing for wxTE_PROCESS_TAB shouldn't be done here the control may // have this style, yet choose not to process this particular TAB in which // case TAB must still work as a navigational character -#if 0 - !win->HasFlag(wxTE_PROCESS_TAB) && -#endif // 0 +// JS: enabling again to make consistent with other platforms +// (with wxTE_PROCESS_TAB you have to call Navigate to get default +// navigation behaviour) +#if wxUSE_TEXTCTRL + (! (win->HasFlag(wxTE_PROCESS_TAB) && win->IsKindOf(CLASSINFO(wxTextCtrl)) )) && +#endif win->GetParent() && (win->GetParent()->HasFlag( wxTAB_TRAVERSAL)) ) { wxNavigationKeyEvent new_event; @@ -1264,43 +1314,53 @@ static void gtk_wxwindow_commit_cb (GtkIMContext *context, const gchar *str, wxWindow *window) { - bool ret = FALSE; - wxKeyEvent event( wxEVT_KEY_DOWN ); -#if wxUSE_UNICODE - event.m_uniChar = g_utf8_get_char( str ); + // take modifiers, cursor position, timestamp etc. from the last + // key_press_event that was fed into Input Method: + if (window->m_imData->lastKeyEvent) + { + wxFillOtherKeyEventFields(event, + window, window->m_imData->lastKeyEvent); + } - // Backward compatible for ISO-8859 - if (event.m_uniChar < 256) - event.m_keyCode = event.m_uniChar; +#if wxUSE_UNICODE + const wxWCharBuffer data = wxConvUTF8.cMB2WC( (char*)str ); #else - gunichar uniChar = g_utf8_get_char( str ); - // We cannot handle Unicode in non-Unicode mode - if (uniChar > 255) return; - - event.m_keyCode = uniChar; -#endif - - - // TODO: We still need to set all the extra attributes of the - // event, modifiers and such... + const wxWCharBuffer wdata = wxConvUTF8.cMB2WC( (char*)str ); + const wxCharBuffer data = wxConvLocal.cWC2MB( wdata ); +#endif // wxUSE_UNICODE + if( !(const wxChar*)data ) + return; + bool ret = false; // Implement OnCharHook by checking ancestor top level windows wxWindow *parent = window; while (parent && !parent->IsTopLevel()) parent = parent->GetParent(); - if (parent) - { - event.SetEventType( wxEVT_CHAR_HOOK ); - ret = parent->GetEventHandler()->ProcessEvent( event ); - } - if (!ret) + for( const wxChar* pstr = data; *pstr; pstr++ ) { - event.SetEventType(wxEVT_CHAR); - ret = window->GetEventHandler()->ProcessEvent( event ); +#if wxUSE_UNICODE + event.m_uniChar = *pstr; + // Backward compatible for ISO-8859 + event.m_keyCode = *pstr < 256 ? event.m_uniChar : 0; + wxLogTrace(TRACE_KEYS, _T("IM sent character '%c'"), event.m_uniChar); +#else + event.m_keyCode = *pstr; +#endif // wxUSE_UNICODE + if (parent) + { + event.SetEventType( wxEVT_CHAR_HOOK ); + ret = parent->GetEventHandler()->ProcessEvent( event ); + } + + if (!ret) + { + event.SetEventType(wxEVT_CHAR); + ret = window->GetEventHandler()->ProcessEvent( event ); + } } } #endif @@ -1347,39 +1407,37 @@ static gint gtk_window_key_release_callback( GtkWidget *widget, // mouse event processing helpers // ---------------------------------------------------------------------------- -// init wxMouseEvent with the info from gdk_event -// -// NB: this has to be a macro as gdk_event type is different for different -// events we're used with -#define InitMouseEvent(/* wxWindowGTK * */ win, \ - /* wxMouseEvent& */ event, \ - /* GdkEventXXX * */ gdk_event) \ -{ \ - 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_leftDown = (gdk_event->state & GDK_BUTTON1_MASK); \ - event.m_middleDown = (gdk_event->state & GDK_BUTTON2_MASK); \ - event.m_rightDown = (gdk_event->state & GDK_BUTTON3_MASK); \ - if (event.GetEventType()==wxEVT_MOUSEWHEEL) \ - { \ - event.m_linesPerAction = 3; \ - if (((GdkEventButton*)gdk_event)->button == 4) \ - event.m_wheelRotation = 120; \ - else if (((GdkEventButton*)gdk_event)->button == 5) \ - event.m_wheelRotation = -120; \ - } \ - \ - wxPoint pt = win->GetClientAreaOrigin(); \ - event.m_x = (wxCoord)gdk_event->x - pt.x; \ - event.m_y = (wxCoord)gdk_event->y - pt.y; \ - \ - event.SetEventObject( win ); \ - event.SetId( win->GetId() ); \ - event.SetTimestamp( gdk_event->time ); \ -} \ +// init wxMouseEvent with the info from GdkEventXXX struct +template void InitMouseEvent(wxWindowGTK *win, + wxMouseEvent& event, + T *gdk_event) +{ + 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_leftDown = (gdk_event->state & GDK_BUTTON1_MASK); + event.m_middleDown = (gdk_event->state & GDK_BUTTON2_MASK); + event.m_rightDown = (gdk_event->state & GDK_BUTTON3_MASK); + if (event.GetEventType() == wxEVT_MOUSEWHEEL) + { + event.m_linesPerAction = 3; + event.m_wheelDelta = 120; + if (((GdkEventButton*)gdk_event)->button == 4) + event.m_wheelRotation = 120; + else if (((GdkEventButton*)gdk_event)->button == 5) + event.m_wheelRotation = -120; + } + + wxPoint pt = win->GetClientAreaOrigin(); + event.m_x = (wxCoord)gdk_event->x - pt.x; + event.m_y = (wxCoord)gdk_event->y - pt.y; + + event.SetEventObject( win ); + event.SetId( win->GetId() ); + event.SetTimestamp( gdk_event->time ); +} static void AdjustEventButtonState(wxMouseEvent& event) { @@ -1538,8 +1596,8 @@ static gint gtk_window_button_press_callback( GtkWidget *widget, wxEventType event_type = wxEVT_NULL; - // GdkDisplay is a GTK+ 2.1.0 thing -#if defined(__WXGTK20__) && GTK_CHECK_VERSION(2, 1, 0) + // GdkDisplay is a GTK+ 2.2.0 thing +#if defined(__WXGTK20__) && GTK_CHECK_VERSION(2, 2, 0) if ( gdk_event->type == GDK_2BUTTON_PRESS && gdk_event->button >= 1 && gdk_event->button <= 3 ) { @@ -1634,6 +1692,21 @@ static gint gtk_window_button_press_callback( GtkWidget *widget, // a chance to correct this win->FixUpMouseEvent(widget, event.m_x, event.m_y); + if ( event_type == wxEVT_RIGHT_DOWN ) + { + // generate a "context menu" event: this is similar to right mouse + // click under many GUIs except that it is generated differently + // (right up under MSW, ctrl-click under Mac, right down here) and + // + // (a) it's a command event and so is propagated to the parent + // (b) under MSW it can be generated from kbd too + // (c) it uses screen coords (because of (a)) + wxContextMenuEvent evtCtx(wxEVT_CONTEXT_MENU, + win->GetId(), + win->ClientToScreen(event.GetPosition())); + (void)win->GetEventHandler()->ProcessEvent(evtCtx); + } + // find the correct window to send the event too: it may be a different one // from the one which got it at GTK+ level because some control don't have // their own X window and thus cannot get any events. @@ -1642,13 +1715,6 @@ static gint gtk_window_button_press_callback( GtkWidget *widget, gs_timeLastClick = gdk_event->time; -/* - wxPrintf( wxT("2) OnButtonPress from ") ); - if (win->GetClassInfo() && win->GetClassInfo()->GetClassName()) - wxPrintf( win->GetClassInfo()->GetClassName() ); - wxPrintf( wxT(".\n") ); -*/ - #ifndef __WXGTK20__ if (event_type == wxEVT_LEFT_DCLICK) { @@ -1720,20 +1786,6 @@ static gint gtk_window_button_release_callback( GtkWidget *widget, // same wxListBox hack as above win->FixUpMouseEvent(widget, event.m_x, event.m_y); - if ( event_type == wxEVT_RIGHT_UP ) - { - // generate a "context menu" event: this is similar to wxEVT_RIGHT_UP - // except that: - // - // (a) it's a command event and so is propagated to the parent - // (b) under MSW it can be generated from kbd too - // (c) it uses screen coords (because of (a)) - wxContextMenuEvent evtCtx(wxEVT_CONTEXT_MENU, - win->GetId(), - win->ClientToScreen(event.GetPosition())); - (void)win->GetEventHandler()->ProcessEvent(evtCtx); - } - if ( !g_captureWindow ) win = FindWindowForMouseEvent(win, event.m_x, event.m_y); @@ -1853,6 +1905,7 @@ static gint gtk_window_wheel_callback (GtkWidget * widget, event.m_middleDown = (gdk_event->state & GDK_BUTTON2_MASK); event.m_rightDown = (gdk_event->state & GDK_BUTTON3_MASK); event.m_linesPerAction = 3; + event.m_wheelDelta = 120; if (gdk_event->direction == GDK_SCROLL_UP) event.m_wheelRotation = 120; else @@ -1900,26 +1953,14 @@ static gint gtk_window_focus_in_callback( GtkWidget *widget, wxWindow *win ) { DEBUG_MAIN_THREAD - + if (g_isIdle) wxapp_install_idle_handler(); - if (!win->m_hasVMT) return FALSE; - if (g_blockEventsOnDrag) return FALSE; - - switch ( g_sendActivateEvent ) - { - case -1: - // we've got focus from outside, synthetize wxActivateEvent - g_sendActivateEvent = 1; - break; - - case 0: - // another our window just lost focus, it was already ours before - // - don't send any wxActivateEvent - g_sendActivateEvent = -1; - break; - } +#ifdef __WXGTK20__ + if (win->m_imData) + gtk_im_context_focus_in(win->m_imData->context); +#endif g_focusWindowLast = g_focusWindow = win; @@ -1941,36 +1982,12 @@ static gint gtk_window_focus_in_callback( GtkWidget *widget, } #endif // wxUSE_CARET - g_activeFrameLostFocus = FALSE; - - wxWindowGTK *active = wxGetTopLevelParent(win); - if ( active != g_activeFrame ) - { - if ( g_activeFrame ) - { - wxLogTrace(wxT("activate"), wxT("Deactivating frame %p (from focus_in)"), g_activeFrame); - wxActivateEvent event(wxEVT_ACTIVATE, FALSE, g_activeFrame->GetId()); - event.SetEventObject(g_activeFrame); - g_activeFrame->GetEventHandler()->ProcessEvent(event); - } - - wxLogTrace(wxT("activate"), wxT("Activating frame %p (from focus_in)"), active); - g_activeFrame = active; - wxActivateEvent event(wxEVT_ACTIVATE, TRUE, g_activeFrame->GetId()); - event.SetEventObject(g_activeFrame); - g_activeFrame->GetEventHandler()->ProcessEvent(event); - - // Don't send focus events in addition to activate - // if (win == g_activeFrame) - // return TRUE; - } - // does the window itself think that it has the focus? if ( !win->m_hasFocus ) { // not yet, notify it win->m_hasFocus = TRUE; - + if ( DoSendFocusEvents(win) ) { gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "focus_in_event" ); @@ -1992,29 +2009,14 @@ static gint gtk_window_focus_out_callback( GtkWidget *widget, GdkEventFocus *gdk if (g_isIdle) wxapp_install_idle_handler(); - if (!win->m_hasVMT) return FALSE; - if (g_blockEventsOnDrag) return FALSE; +#ifdef __WXGTK20__ + if (win->m_imData) + gtk_im_context_focus_out(win->m_imData->context); +#endif wxLogTrace( TRACE_FOCUS, _T("%s: focus out"), win->GetName().c_str() ); - if ( !g_activeFrameLostFocus && g_activeFrame ) - { - // VZ: commenting this out because it does happen (although not easy - // to reproduce, I only see it when using wxMiniFrame and not - // always) and makes using Mahogany quite annoying -#if 0 - wxASSERT_MSG( wxGetTopLevelParent(win) == g_activeFrame, - wxT("unfocusing window that hasn't gained focus properly") ); -#endif // 0 - - g_activeFrameLostFocus = TRUE; - } - - // if the focus goes out of our app alltogether, OnIdle() will send - // wxActivateEvent, otherwise gtk_window_focus_in_callback() will reset - // g_sendActivateEvent to -1 - g_sendActivateEvent = 0; wxWindowGTK *winFocus = wxFindFocusedChild(win); if ( winFocus ) @@ -2045,11 +2047,11 @@ static gint gtk_window_focus_out_callback( GtkWidget *widget, GdkEventFocus *gdk wxFocusEvent event( wxEVT_KILL_FOCUS, win->GetId() ); event.SetEventObject( win ); - if (win->GetEventHandler()->ProcessEvent( event )) - { - gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "focus_out_event" ); - return TRUE; - } + // even if we did process the event in wx code, still let GTK itself + // process it too as otherwise bad things happen, especially in GTK2 + // where the text control simply aborts the program if it doesn't get + // the matching focus out event + (void)win->GetEventHandler()->ProcessEvent( event ); } return FALSE; @@ -2289,7 +2291,7 @@ static gint gtk_scrollbar_button_release_callback( GtkRange *widget, // because it is static and so couldn't be made virtual // ---------------------------------------------------------------------------- -wxWindow *wxWindowBase::FindFocus() +wxWindow *wxWindowBase::DoFindFocus() { // the cast is necessary when we compile in wxUniversal mode return (wxWindow *)g_focusWindow; @@ -2311,17 +2313,12 @@ gtk_window_realized_callback( GtkWidget *m_widget, wxWindow *win ) if (g_isIdle) wxapp_install_idle_handler(); - if (win->m_delayedBackgroundColour && !win->GetThemeEnabled()) - win->GtkSetBackgroundColour( win->GetBackgroundColour() ); - - if (win->m_delayedForegroundColour && !win->GetThemeEnabled()) - win->GtkSetForegroundColour( win->GetForegroundColour() ); - #ifdef __WXGTK20__ - if (win->m_imContext) + if (win->m_imData) { GtkPizza *pizza = GTK_PIZZA( m_widget ); - gtk_im_context_set_client_window( (GtkIMContext*) win->m_imContext, pizza->bin_window ); + gtk_im_context_set_client_window( win->m_imData->context, + pizza->bin_window ); } #endif @@ -2569,7 +2566,6 @@ void wxWindowGTK::Init() m_oldClientHeight = 0; m_resizing = FALSE; - m_widgetStyle = (GtkStyle*) NULL; m_insertCallback = (wxInsertChildFunction) NULL; @@ -2578,14 +2574,14 @@ void wxWindowGTK::Init() m_clipPaintRegion = FALSE; - m_cursor = *wxSTANDARD_CURSOR; + m_needsStyleChange = false; - m_delayedForegroundColour = FALSE; - m_delayedBackgroundColour = FALSE; + m_cursor = *wxSTANDARD_CURSOR; #ifdef __WXGTK20__ - m_imContext = NULL; + m_imData = NULL; m_x11Context = NULL; + m_dirtyTabOrder = false; #else #ifdef HAVE_XIM m_ic = (GdkIC*) NULL; @@ -2627,9 +2623,6 @@ bool wxWindowGTK::Create( wxWindow *parent, m_insertCallback = wxInsertChildInWindow; - // always needed for background clearing - m_delayedBackgroundColour = TRUE; - m_widget = gtk_scrolled_window_new( (GtkAdjustment *) NULL, (GtkAdjustment *) NULL ); GTK_WIDGET_UNSET_FLAGS( m_widget, GTK_CAN_FOCUS ); @@ -2712,17 +2705,6 @@ bool wxWindowGTK::Create( wxWindow *parent, gtk_signal_connect( GTK_OBJECT(m_vAdjust), "value_changed", (GtkSignalFunc) gtk_window_vscroll_callback, (gpointer) this ); -#ifdef __WXGTK20__ - // Create input method handler - m_imContext = (GtkIMMulticontext*) gtk_im_multicontext_new (); - - // Cannot handle drawing preedited text yet - gtk_im_context_set_use_preedit( (GtkIMContext*) m_imContext, FALSE ); - - g_signal_connect (G_OBJECT (m_imContext), "commit", - G_CALLBACK (gtk_wxwindow_commit_cb), this); -#endif - gtk_widget_show( m_wxwindow ); if (m_parent) @@ -2742,9 +2724,6 @@ wxWindowGTK::~wxWindowGTK() if (g_focusWindow == this) g_focusWindow = NULL; - if (g_activeFrame == this) - g_activeFrame = NULL; - if ( g_delayedFocus == this ) g_delayedFocus = NULL; @@ -2763,16 +2742,6 @@ wxWindowGTK::~wxWindowGTK() gdk_ic_attr_destroy (m_icattr); #endif - if (m_widgetStyle) - { -#if DISABLE_STYLE_IF_BROKEN_THEME - // don't delete if it's a pixmap theme style - if (!m_widgetStyle->engine_data) - gtk_style_unref( m_widgetStyle ); -#endif - m_widgetStyle = (GtkStyle*) NULL; - } - if (m_wxwindow) { gtk_widget_destroy( m_wxwindow ); @@ -2784,6 +2753,10 @@ wxWindowGTK::~wxWindowGTK() gtk_widget_destroy( m_widget ); m_widget = (GtkWidget*) NULL; } + +#ifdef __WXGTK20__ + delete m_imData; +#endif } bool wxWindowGTK::PreCreation( wxWindowGTK *parent, const wxPoint &pos, const wxSize &size ) @@ -2828,18 +2801,18 @@ void wxWindowGTK::PostCreation() #else // gtk_widget_set_redraw_on_allocate( GTK_WIDGET(m_wxwindow), !HasFlag( wxFULL_REPAINT_ON_RESIZE ) ); #endif + } #ifdef __WXGTK20__ // Create input method handler - m_imContext = (GtkIMMulticontext*) gtk_im_multicontext_new (); + m_imData = new wxGtkIMData; // Cannot handle drawing preedited text yet - gtk_im_context_set_use_preedit( (GtkIMContext*) m_imContext, FALSE ); + gtk_im_context_set_use_preedit( m_imData->context, FALSE ); - g_signal_connect (G_OBJECT (m_imContext), "commit", - G_CALLBACK (gtk_wxwindow_commit_cb), this); + g_signal_connect (G_OBJECT (m_imData->context), "commit", + G_CALLBACK (gtk_wxwindow_commit_cb), this); #endif - } // these are called when the "sunken" or "raised" borders are drawn gtk_signal_connect( GTK_OBJECT(m_widget), "expose_event", @@ -2853,14 +2826,17 @@ void wxWindowGTK::PostCreation() // focus handling - if (m_focusWidget == NULL) - m_focusWidget = m_widget; - - gtk_signal_connect( GTK_OBJECT(m_focusWidget), "focus_in_event", - GTK_SIGNAL_FUNC(gtk_window_focus_in_callback), (gpointer)this ); + if (!GTK_IS_WINDOW(m_widget)) + { + if (m_focusWidget == NULL) + m_focusWidget = m_widget; + + gtk_signal_connect( GTK_OBJECT(m_focusWidget), "focus_in_event", + GTK_SIGNAL_FUNC(gtk_window_focus_in_callback), (gpointer)this ); - gtk_signal_connect( GTK_OBJECT(m_focusWidget), "focus_out_event", - GTK_SIGNAL_FUNC(gtk_window_focus_out_callback), (gpointer)this ); + gtk_signal_connect( GTK_OBJECT(m_focusWidget), "focus_out_event", + GTK_SIGNAL_FUNC(gtk_window_focus_out_callback), (gpointer)this ); + } // connect to the various key and mouse handlers @@ -2900,6 +2876,8 @@ void wxWindowGTK::PostCreation() (gpointer) this ); } + InheritAttributes(); + m_hasVMT = TRUE; // unless the window was created initially hidden (i.e. Hide() had been @@ -3067,32 +3045,20 @@ void wxWindowGTK::DoSetSize( int x, int y, int width, int height, int sizeFlags void wxWindowGTK::OnInternalIdle() { - // Update invalidated regions. - GtkUpdate(); - - // Synthetize activate events. - if ( g_sendActivateEvent != -1 ) +#ifdef __WXGTK20__ + if ( m_dirtyTabOrder ) + RealizeTabOrder(); +#endif + // Update style if the window was not yet realized + // and SetBackgroundStyle(wxBG_STYLE_CUSTOM) was called + if (m_needsStyleChange) { - bool activate = g_sendActivateEvent != 0; - - // do it only once - g_sendActivateEvent = -1; - - wxTheApp->SetActive(activate, (wxWindow *)g_focusWindowLast); + SetBackgroundStyle(GetBackgroundStyle()); + m_needsStyleChange = false; } - if ( g_activeFrameLostFocus ) - { - if ( g_activeFrame ) - { - wxLogTrace(wxT("activate"), wxT("Deactivating frame %p (from idle)"), g_activeFrame); - wxActivateEvent event(wxEVT_ACTIVATE, FALSE, g_activeFrame->GetId()); - event.SetEventObject(g_activeFrame); - g_activeFrame->GetEventHandler()->ProcessEvent(event); - g_activeFrame = NULL; - } - g_activeFrameLostFocus = FALSE; - } + // Update invalidated regions. + GtkUpdate(); wxCursor cursor = m_cursor; if (g_globalCursor.Ok()) cursor = g_globalCursor; @@ -3435,7 +3401,7 @@ int wxWindowGTK::GetCharHeight() const g_object_unref( G_OBJECT( layout ) ); - return (int) (rect.height / PANGO_SCALE); + return (int) PANGO_PIXELS(rect.height); #else GdkFont *gfont = font.GetInternalFont( 1.0 ); @@ -3469,7 +3435,7 @@ int wxWindowGTK::GetCharWidth() const g_object_unref( G_OBJECT( layout ) ); - return (int) (rect.width / PANGO_SCALE); + return (int) PANGO_PIXELS(rect.width); #else GdkFont *gfont = font.GetInternalFont( 1.0 ); @@ -3520,17 +3486,18 @@ void wxWindowGTK::GetTextExtent( const wxString& string, pango_layout_set_text(layout, (const char*) data, strlen( (const char*) data )); #endif } - PangoLayoutLine *line = (PangoLayoutLine *)pango_layout_get_lines(layout)->data; PangoRectangle rect; - pango_layout_line_get_extents(line, NULL, &rect); + pango_layout_get_extents(layout, NULL, &rect); - if (x) (*x) = (wxCoord) (rect.width / PANGO_SCALE); - if (y) (*y) = (wxCoord) (rect.height / PANGO_SCALE); + if (x) (*x) = (wxCoord) PANGO_PIXELS(rect.width); + if (y) (*y) = (wxCoord) PANGO_PIXELS(rect.height); if (descent) { - // Do something about metrics here - (*descent) = 0; + PangoLayoutIter *iter = pango_layout_get_iter(layout); + int baseline = pango_layout_iter_get_baseline(iter); + pango_layout_iter_free(iter); + *descent = *y - PANGO_PIXELS(baseline); } if (externalLeading) (*externalLeading) = 0; // ?? @@ -3547,7 +3514,6 @@ void wxWindowGTK::GetTextExtent( const wxString& string, void wxWindowGTK::SetFocus() { wxCHECK_RET( m_widget != NULL, wxT("invalid window") ); - if ( m_hasFocus ) { // don't do anything if we already have focus @@ -3563,8 +3529,16 @@ void wxWindowGTK::SetFocus() } else if (m_widget) { +#ifdef __WXGTK20__ + if (GTK_IS_CONTAINER(m_widget)) + { + gtk_widget_child_focus( m_widget, GTK_DIR_TAB_FORWARD ); + } + else +#endif if (GTK_WIDGET_CAN_FOCUS(m_widget) && !GTK_WIDGET_HAS_FOCUS (m_widget) ) { + if (!GTK_WIDGET_REALIZED(m_widget)) { // we can't set the focus to the widget now so we remember that @@ -3585,11 +3559,14 @@ void wxWindowGTK::SetFocus() gtk_widget_grab_focus (m_widget); } } - else if (GTK_IS_CONTAINER(m_widget)) + else +#ifndef __WXGTK20__ + if (GTK_IS_CONTAINER(m_widget)) { - SET_CONTAINER_FOCUS( m_widget, GTK_DIR_TAB_FORWARD ); + gtk_container_focus( GTK_CONTAINER(m_widget), GTK_DIR_TAB_FORWARD ); } else +#endif { wxLogTrace(TRACE_FOCUS, _T("Can't set focus to %s(%s)"), @@ -3654,6 +3631,62 @@ void wxWindowGTK::DoAddChild(wxWindowGTK *child) (*m_insertCallback)(this, child); } +#ifdef __WXGTK20__ + +void wxWindowGTK::AddChild(wxWindowBase *child) +{ + wxWindowBase::AddChild(child); + m_dirtyTabOrder = true; + if (g_isIdle) + wxapp_install_idle_handler(); +} + +void wxWindowGTK::RemoveChild(wxWindowBase *child) +{ + wxWindowBase::RemoveChild(child); + m_dirtyTabOrder = true; + if (g_isIdle) + wxapp_install_idle_handler(); +} + +void wxWindowGTK::DoMoveInTabOrder(wxWindow *win, MoveKind move) +{ + wxWindowBase::DoMoveInTabOrder(win, move); + m_dirtyTabOrder = true; + if (g_isIdle) + wxapp_install_idle_handler(); +} + +void wxWindowGTK::RealizeTabOrder() +{ + if (m_wxwindow) + { + if (m_children.size() > 0) + { + GList *chain = NULL; + + for (wxWindowList::const_iterator i = m_children.begin(); + i != m_children.end(); ++i) + { + chain = g_list_prepend(chain, (*i)->m_widget); + } + + chain = g_list_reverse(chain); + + gtk_container_set_focus_chain(GTK_CONTAINER(m_wxwindow), chain); + g_list_free(chain); + } + else + { + gtk_container_unset_focus_chain(GTK_CONTAINER(m_wxwindow)); + } + } + + m_dirtyTabOrder = false; +} + +#endif // __WXGTK20__ + void wxWindowGTK::Raise() { wxCHECK_RET( (m_widget != NULL), wxT("invalid window") ); @@ -3822,12 +3855,10 @@ void wxWindowGTK::GtkSendPaintEvents() // Clip to paint region in wxClientDC m_clipPaintRegion = TRUE; -#ifndef __WXGTK20__ // widget to draw on GtkPizza *pizza = GTK_PIZZA (m_wxwindow); - // later for GTK 2.0, too. - if (GetThemeEnabled()) + if (GetThemeEnabled() && GetBackgroundStyle() == wxBG_STYLE_SYSTEM) { // find ancestor from which to steal background wxWindow *parent = GetParent(); @@ -3847,7 +3878,7 @@ void wxWindowGTK::GtkSendPaintEvents() gtk_paint_flat_box( parent->m_widget->style, pizza->bin_window, - GTK_STATE_NORMAL, + (GtkStateType)GTK_WIDGET_STATE(m_wxwindow), GTK_SHADOW_NONE, &rect, parent->m_widget, @@ -3858,7 +3889,6 @@ void wxWindowGTK::GtkSendPaintEvents() } } else -#endif #ifdef __WXGTK20__ { @@ -3882,7 +3912,7 @@ void wxWindowGTK::GtkSendPaintEvents() wxEraseEvent erase_event( GetId(), &dc ); erase_event.SetEventObject( this ); - if (!GetEventHandler()->ProcessEvent(erase_event)) + if (!GetEventHandler()->ProcessEvent(erase_event) && GetBackgroundStyle() != wxBG_STYLE_CUSTOM) { if (!g_eraseGC) { @@ -3993,68 +4023,25 @@ void wxWindowGTK::ApplyToolTip( GtkTooltips *tips, const wxChar *tip ) } #endif // wxUSE_TOOLTIPS -void wxWindowGTK::GtkSetBackgroundColour( const wxColour &colour ) -{ - GdkWindow *window = (GdkWindow*) NULL; - if (m_wxwindow) - window = GTK_PIZZA(m_wxwindow)->bin_window; - else - window = GetConnectWidget()->window; - - wxASSERT( window ); - - // We need the pixel value e.g. for background clearing. - m_backgroundColour.CalcPixel( gdk_window_get_colormap( window ) ); - - if (m_wxwindow) - { - // wxMSW doesn't clear the window here, either. - gdk_window_set_background( window, m_backgroundColour.GetColor() ); - } - - ApplyWidgetStyle(); -} - bool wxWindowGTK::SetBackgroundColour( const wxColour &colour ) { wxCHECK_MSG( m_widget != NULL, FALSE, wxT("invalid window") ); if (!wxWindowBase::SetBackgroundColour(colour)) - return FALSE; - - GdkWindow *window = (GdkWindow*) NULL; - if (m_wxwindow) - window = GTK_PIZZA(m_wxwindow)->bin_window; - else - window = GetConnectWidget()->window; + return false; - if (!window) + if (colour.Ok()) { - // 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; - return TRUE; - } - else - { - GtkSetBackgroundColour( colour ); + // We need the pixel value e.g. for background clearing. + m_backgroundColour.CalcPixel(gtk_widget_get_colormap(m_widget)); } - return TRUE; -} - -void wxWindowGTK::GtkSetForegroundColour( const wxColour &colour ) -{ - GdkWindow *window = (GdkWindow*) NULL; - if (m_wxwindow) - window = GTK_PIZZA(m_wxwindow)->bin_window; - else - window = GetConnectWidget()->window; - - wxASSERT( window ); + // apply style change (forceStyle=true so that new style is applied + // even if the bg colour changed from valid to wxNullColour) + if (GetBackgroundStyle() != wxBG_STYLE_CUSTOM) + ApplyWidgetStyle(true); - ApplyWidgetStyle(); + return true; } bool wxWindowGTK::SetForegroundColour( const wxColour &colour ) @@ -4063,30 +4050,20 @@ bool wxWindowGTK::SetForegroundColour( const wxColour &colour ) if (!wxWindowBase::SetForegroundColour(colour)) { - // don't leave if the GTK widget has just - // been realized - if (!m_delayedForegroundColour) return FALSE; + return false; } - - GdkWindow *window = (GdkWindow*) NULL; - if (m_wxwindow) - window = GTK_PIZZA(m_wxwindow)->bin_window; - else - window = GetConnectWidget()->window; - - if (!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; - } - else + + if (colour.Ok()) { - GtkSetForegroundColour( colour ); + // We need the pixel value e.g. for background clearing. + m_foregroundColour.CalcPixel(gtk_widget_get_colormap(m_widget)); } - return TRUE; + // apply style change (forceStyle=true so that new style is applied + // even if the bg colour changed from valid to wxNullColour): + ApplyWidgetStyle(true); + + return true; } #ifdef __WXGTK20__ @@ -4103,135 +4080,128 @@ PangoContext *wxWindowGTK::GtkGetPangoX11Context() return m_x11Context; } #endif - -GtkStyle *wxWindowGTK::GetWidgetStyle() + +GtkRcStyle *wxWindowGTK::CreateWidgetStyle(bool forceStyle) { - if (m_widgetStyle) + // do we need to apply any changes at all? + if ( !forceStyle && + !m_font.Ok() && + !m_foregroundColour.Ok() && !m_backgroundColour.Ok() ) { - GtkStyle *remake = gtk_style_copy( m_widgetStyle ); + return NULL; + } - // FIXME: no more klass in 2.0 -#ifndef __WXGTK20__ - remake->klass = m_widgetStyle->klass; -#endif + GtkRcStyle *style = gtk_rc_style_new(); - gtk_style_unref( m_widgetStyle ); - m_widgetStyle = remake; - } - else + if ( m_font.Ok() ) { - GtkStyle *def = gtk_rc_get_style( m_widget ); +#ifdef __WXGTK20__ + style->font_desc = + pango_font_description_copy( m_font.GetNativeFontInfo()->description ); +#else + wxString xfontname = m_font.GetNativeFontInfo()->GetXFontName(); + style->fontset_name = g_strdup(xfontname.c_str()); +#endif + } - if (!def) - def = gtk_widget_get_default_style(); + if ( m_foregroundColour.Ok() ) + { + GdkColor *fg = m_foregroundColour.GetColor(); + + style->fg[GTK_STATE_NORMAL] = *fg; + style->color_flags[GTK_STATE_NORMAL] = GTK_RC_FG; + + style->fg[GTK_STATE_PRELIGHT] = *fg; + style->color_flags[GTK_STATE_PRELIGHT] = GTK_RC_FG; + + style->fg[GTK_STATE_ACTIVE] = *fg; + style->color_flags[GTK_STATE_ACTIVE] = GTK_RC_FG; + } - m_widgetStyle = gtk_style_copy( def ); + if ( m_backgroundColour.Ok() ) + { + GdkColor *bg = m_backgroundColour.GetColor(); - // FIXME: no more klass in 2.0 -#ifndef __WXGTK20__ - m_widgetStyle->klass = def->klass; -#endif + style->bg[GTK_STATE_NORMAL] = *bg; + style->base[GTK_STATE_NORMAL] = *bg; + style->color_flags[GTK_STATE_NORMAL] = (GtkRcFlags) + (style->color_flags[GTK_STATE_NORMAL] | GTK_RC_BG | GTK_RC_BASE); + + style->bg[GTK_STATE_PRELIGHT] = *bg; + style->base[GTK_STATE_PRELIGHT] = *bg; + style->color_flags[GTK_STATE_PRELIGHT] = (GtkRcFlags) + (style->color_flags[GTK_STATE_PRELIGHT] | GTK_RC_BG | GTK_RC_BASE); + + style->bg[GTK_STATE_ACTIVE] = *bg; + style->base[GTK_STATE_ACTIVE] = *bg; + style->color_flags[GTK_STATE_ACTIVE] = (GtkRcFlags) + (style->color_flags[GTK_STATE_ACTIVE] | GTK_RC_BG | GTK_RC_BASE); + + style->bg[GTK_STATE_INSENSITIVE] = *bg; + style->base[GTK_STATE_INSENSITIVE] = *bg; + style->color_flags[GTK_STATE_INSENSITIVE] = (GtkRcFlags) + (style->color_flags[GTK_STATE_INSENSITIVE] | GTK_RC_BG | GTK_RC_BASE); } - - return m_widgetStyle; + + return style; } -void wxWindowGTK::SetWidgetStyle() +void wxWindowGTK::ApplyWidgetStyle(bool forceStyle) { -#if DISABLE_STYLE_IF_BROKEN_THEME - if (m_widget->style->engine_data) + GtkRcStyle *style = CreateWidgetStyle(forceStyle); + if ( style ) { - static bool s_warningPrinted = FALSE; - if (!s_warningPrinted) - { - printf( "wxWidgets warning: Widget styles disabled due to buggy GTK theme.\n" ); - s_warningPrinted = TRUE; - } - m_widgetStyle = m_widget->style; - return; + DoApplyWidgetStyle(style); + gtk_rc_style_unref(style); } -#endif - GtkStyle *style = GetWidgetStyle(); + // Style change may affect GTK+'s size calculation: + InvalidateBestSize(); +} - if ( m_hasFont ) - { -#ifdef __WXGTK20__ - pango_font_description_free( style->font_desc ); - style->font_desc = pango_font_description_copy( m_font.GetNativeFontInfo()->description ); -#else - gdk_font_unref( style->font ); - style->font = gdk_font_ref( m_font.GetInternalFont( 1.0 ) ); -#endif - } +void wxWindowGTK::DoApplyWidgetStyle(GtkRcStyle *style) +{ + if (m_wxwindow) + gtk_widget_modify_style(m_wxwindow, style); + gtk_widget_modify_style(m_widget, style); +} - if ( m_hasFgCol ) +bool wxWindowGTK::SetBackgroundStyle(wxBackgroundStyle style) +{ + wxWindowBase::SetBackgroundStyle(style); + + if (style == wxBG_STYLE_CUSTOM) { - m_foregroundColour.CalcPixel( gtk_widget_get_colormap( m_widget ) ); - if (m_foregroundColour != wxSystemSettings::GetColour(wxSYS_COLOUR_BTNTEXT)) - { - style->fg[GTK_STATE_NORMAL] = *m_foregroundColour.GetColor(); - style->fg[GTK_STATE_PRELIGHT] = *m_foregroundColour.GetColor(); - style->fg[GTK_STATE_ACTIVE] = *m_foregroundColour.GetColor(); - } + GdkWindow *window = (GdkWindow*) NULL; + if (m_wxwindow) + window = GTK_PIZZA(m_wxwindow)->bin_window; else - { - // Try to restore the gtk default style. This is still a little - // oversimplified for what is probably really needed here for controls - // other than buttons, but is better than not being able to (re)set a - // control's foreground colour to *wxBLACK -- RL - GtkStyle *def = gtk_rc_get_style( m_widget ); - - if (!def) - def = gtk_widget_get_default_style(); - - style->fg[GTK_STATE_NORMAL] = def->fg[GTK_STATE_NORMAL]; - style->fg[GTK_STATE_PRELIGHT] = def->fg[GTK_STATE_PRELIGHT]; - style->fg[GTK_STATE_ACTIVE] = def->fg[GTK_STATE_ACTIVE]; - } - } + window = GetConnectWidget()->window; - if ( m_hasBgCol && m_backgroundColour.Ok() ) - { - m_backgroundColour.CalcPixel( gtk_widget_get_colormap( m_widget ) ); - if (m_backgroundColour != wxSystemSettings::GetColour(wxSYS_COLOUR_BTNFACE)) + if (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(); + // Make sure GDK/X11 doesn't refresh the window + // automatically. + gdk_window_set_back_pixmap( window, None, False ); +#ifdef __X__ + Display* display = GDK_WINDOW_DISPLAY(window); + XFlush(display); +#endif + m_needsStyleChange = false; } else - { - // Try to restore the gtk default style. This is still a little - // oversimplified for what is probably really needed here for controls - // other than buttons, but is better than not being able to (re)set a - // control's background colour to default grey and means resetting a - // button to wxSYS_COLOUR_BTNFACE will restore its usual highlighting - // behavior -- RL - GtkStyle *def = gtk_rc_get_style( m_widget ); - - if (!def) - def = gtk_widget_get_default_style(); - - style->bg[GTK_STATE_NORMAL] = def->bg[GTK_STATE_NORMAL]; - style->base[GTK_STATE_NORMAL] = def->base[GTK_STATE_NORMAL]; - style->bg[GTK_STATE_PRELIGHT] = def->bg[GTK_STATE_PRELIGHT]; - style->base[GTK_STATE_PRELIGHT] = def->base[GTK_STATE_PRELIGHT]; - style->bg[GTK_STATE_ACTIVE] = def->bg[GTK_STATE_ACTIVE]; - style->base[GTK_STATE_ACTIVE] = def->base[GTK_STATE_ACTIVE]; - style->bg[GTK_STATE_INSENSITIVE] = def->bg[GTK_STATE_INSENSITIVE]; - style->base[GTK_STATE_INSENSITIVE] = def->base[GTK_STATE_INSENSITIVE]; - } + // Do in OnIdle, because the window is not yet available + m_needsStyleChange = true; + + // Don't apply widget style, or we get a grey background } -} - -void wxWindowGTK::ApplyWidgetStyle() -{ + else + { + // apply style change (forceStyle=true so that new style is applied + // even if the bg colour changed from valid to wxNullColour): + ApplyWidgetStyle(true); + } + return true; } //----------------------------------------------------------------------------- @@ -4285,30 +4255,44 @@ extern "C" void wxPopupMenuPositionCallback( GtkMenu *menu, bool wxWindowGTK::DoPopupMenu( wxMenu *menu, int x, int y ) { - wxCHECK_MSG( m_widget != NULL, FALSE, wxT("invalid window") ); + wxCHECK_MSG( m_widget != NULL, false, wxT("invalid window") ); - wxCHECK_MSG( menu != NULL, FALSE, wxT("invalid popup-menu") ); + wxCHECK_MSG( menu != NULL, false, wxT("invalid popup-menu") ); SetInvokingWindow( menu, this ); menu->UpdateUI(); - wxPoint pos(ClientToScreen(wxPoint(x, y))); + bool is_waiting = true; - bool is_waiting = TRUE; + gulong handler = gtk_signal_connect( GTK_OBJECT(menu->m_menu), + "hide", + GTK_SIGNAL_FUNC(gtk_pop_hide_callback), + (gpointer)&is_waiting ); - gtk_signal_connect( GTK_OBJECT(menu->m_menu), - "hide", - GTK_SIGNAL_FUNC(gtk_pop_hide_callback), - (gpointer)&is_waiting ); + wxPoint pos; + gpointer userdata; + GtkMenuPositionFunc posfunc; + if ( x == -1 && y == -1 ) + { + // use GTK's default positioning algorithm + userdata = NULL; + posfunc = NULL; + } + else + { + pos = ClientToScreen(wxPoint(x, y)); + userdata = &pos; + posfunc = wxPopupMenuPositionCallback; + } gtk_menu_popup( GTK_MENU(menu->m_menu), (GtkWidget *) NULL, // parent menu shell (GtkWidget *) NULL, // parent menu item - wxPopupMenuPositionCallback, // function to position it - &pos, // client data - 0 /* FIXME! */, // button used to activate it + posfunc, // function to position it + userdata, // client data + 0, // button used to activate it #ifdef __WXGTK20__ gtk_get_current_event_time() #else @@ -4321,7 +4305,9 @@ bool wxWindowGTK::DoPopupMenu( wxMenu *menu, int x, int y ) gtk_main_iteration(); } - return TRUE; + gtk_signal_disconnect(GTK_OBJECT(menu->m_menu), handler); + + return true; } #endif // wxUSE_MENUS_NATIVE @@ -4362,24 +4348,16 @@ bool wxWindowGTK::IsOwnGtkWindow( GdkWindow *window ) bool wxWindowGTK::SetFont( const wxFont &font ) { - if (!wxWindowBase::SetFont(font) || !m_widget) - { - return FALSE; - } + wxCHECK_MSG( m_widget != NULL, FALSE, wxT("invalid window") ); - wxColour sysbg = wxSystemSettings::GetColour( wxSYS_COLOUR_BTNFACE ); - if ( sysbg == m_backgroundColour ) - { - m_backgroundColour = wxNullColour; - ApplyWidgetStyle(); - m_backgroundColour = sysbg; - } - else - { - ApplyWidgetStyle(); - } + if (!wxWindowBase::SetFont(font)) + return false; - return TRUE; + // apply style change (forceStyle=true so that new style is applied + // even if the font changed from valid to wxNullFont): + ApplyWidgetStyle(true); + + return true; } void wxWindowGTK::DoCaptureMouse()