X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/3208e55e12f7f8509aedf7b85c2864adeb85ffc9..8ca1a013e4e699724040ff1f514dab3b4a11d3c9:/src/gtk/window.cpp?ds=inline diff --git a/src/gtk/window.cpp b/src/gtk/window.cpp index 081370a010..ccb4500d43 100644 --- a/src/gtk/window.cpp +++ b/src/gtk/window.cpp @@ -17,37 +17,24 @@ #include "wx/window.h" #ifndef WX_PRECOMP - #include "wx/intl.h" #include "wx/log.h" #include "wx/app.h" - #include "wx/utils.h" #include "wx/frame.h" #include "wx/dcclient.h" #include "wx/menu.h" - #include "wx/dialog.h" #include "wx/settings.h" #include "wx/msgdlg.h" #include "wx/textctrl.h" + #include "wx/radiobut.h" #include "wx/toolbar.h" #include "wx/combobox.h" #include "wx/layout.h" - #include "wx/statusbr.h" #include "wx/math.h" - #include "wx/module.h" #endif -#if wxUSE_DRAG_AND_DROP - #include "wx/dnd.h" -#endif - -#if wxUSE_TOOLTIPS - #include "wx/tooltip.h" -#endif - -#if wxUSE_CARET - #include "wx/caret.h" -#endif // wxUSE_CARET - +#include "wx/dnd.h" +#include "wx/tooltip.h" +#include "wx/caret.h" #include "wx/fontutil.h" #ifdef __WXDEBUG__ @@ -59,27 +46,16 @@ // FIXME: Due to a hack we use GtkCombo in here, which is deprecated since gtk2.3.0 #include #if defined(GTK_DISABLE_DEPRECATED) && GTK_CHECK_VERSION(2,3,0) -#undef GTK_DISABLE_DEPRECATED + #undef GTK_DISABLE_DEPRECATED + #include + #define GTK_DISABLE_DEPRECATED #endif #include "wx/gtk/private.h" -#include +#include "wx/gtk/win_gtk.h" #include #include -#include -#include - -#include "wx/gtk/win_gtk.h" - -#include - -#ifdef HAVE_XIM - #undef HAVE_XIM -#endif - -extern GtkContainerClass *pizza_parent_class; - //----------------------------------------------------------------------------- // documentation on internals //----------------------------------------------------------------------------- @@ -214,8 +190,10 @@ extern GtkContainerClass *pizza_parent_class; // data //----------------------------------------------------------------------------- -extern bool g_blockEventsOnDrag; -extern bool g_blockEventsOnScroll; +// Don't allow event propagation during drag +bool g_blockEventsOnDrag; +// Don't allow mouse event propagation during scroll +bool g_blockEventsOnScroll; extern wxCursor g_globalCursor; // mouse capture state: the window which has it and if the mouse is currently @@ -234,6 +212,11 @@ wxWindowGTK *g_focusWindowLast = (wxWindowGTK*) NULL; // yet, defer setting the focus to idle time. wxWindowGTK *g_delayedFocus = (wxWindowGTK*) NULL; +// global variables because GTK+ DnD want to have the +// mouse event that caused it +GdkEvent *g_lastMouseEvent = (GdkEvent*) NULL; +int g_lastButtonNumber = 0; + extern bool g_mainThreadLocked; //----------------------------------------------------------------------------- @@ -340,14 +323,6 @@ static void draw_frame( GtkWidget *widget, wxWindowGTK *win ) if (!win->m_hasVMT) return; - int dw = 0; - int dh = 0; - - if (win->m_hasScrolling) - { - GetScrollbarWidth(widget, dw, dh); - } - int dx = 0; int dy = 0; if (GTK_WIDGET_NO_WINDOW (widget)) @@ -356,6 +331,27 @@ static void draw_frame( GtkWidget *widget, wxWindowGTK *win ) dy += widget->allocation.y; } + int x = dx; + int y = dy; + + int dw = 0; + int dh = 0; + if (win->m_hasScrolling) + { + GetScrollbarWidth(widget, dw, dh); + + if (win->GetLayoutDirection() == wxLayout_RightToLeft) + { + // This is actually wrong for old GTK+ version + // which do not display the scrollbar on the + // left side in RTL + x += dw; + } + } + + int w = widget->allocation.width-dw; + int h = widget->allocation.height-dh; + if (win->HasFlag(wxRAISED_BORDER)) { gtk_paint_shadow (widget->style, @@ -363,8 +359,7 @@ static void draw_frame( GtkWidget *widget, wxWindowGTK *win ) GTK_STATE_NORMAL, GTK_SHADOW_OUT, NULL, NULL, NULL, // FIXME: No clipping? - dx, dy, - widget->allocation.width-dw, widget->allocation.height-dh ); + x, y, w, h ); return; } @@ -375,8 +370,7 @@ static void draw_frame( GtkWidget *widget, wxWindowGTK *win ) GTK_STATE_NORMAL, GTK_SHADOW_IN, NULL, NULL, NULL, // FIXME: No clipping? - dx, dy, - widget->allocation.width-dw, widget->allocation.height-dh ); + x, y, w, h ); return; } @@ -385,9 +379,7 @@ static void draw_frame( GtkWidget *widget, wxWindowGTK *win ) GdkGC *gc; gc = gdk_gc_new( widget->window ); gdk_gc_set_foreground( gc, &widget->style->black ); - gdk_draw_rectangle( widget->window, gc, FALSE, - dx, dy, - widget->allocation.width-dw-1, widget->allocation.height-dh-1 ); + gdk_draw_rectangle( widget->window, gc, FALSE, x, y, w-1, h-1 ); g_object_unref (gc); return; } @@ -432,6 +424,8 @@ void wxgtk_window_size_request_callback(GtkWidget *widget, } } +#if wxUSE_COMBOBOX + extern "C" { static void wxgtk_combo_size_request_callback(GtkWidget *widget, @@ -453,14 +447,22 @@ void wxgtk_combo_size_request_callback(GtkWidget *widget, GtkRequisition entry_req; entry_req.width = 2; entry_req.height = 2; + (* GTK_WIDGET_CLASS( GTK_OBJECT_GET_CLASS(gcombo->entry) )->size_request ) + (gcombo->entry, &entry_req ); + + GtkRequisition button_req; + button_req.width = 2; + button_req.height = 2; (* GTK_WIDGET_CLASS( GTK_OBJECT_GET_CLASS(gcombo->button) )->size_request ) - (gcombo->button, &entry_req ); + (gcombo->button, &button_req ); - requisition->width = w - entry_req.width; + requisition->width = w - button_req.width; requisition->height = entry_req.height; } } +#endif // wxUSE_COMBOBOX + //----------------------------------------------------------------------------- // "expose_event" of m_wxwindow //----------------------------------------------------------------------------- @@ -473,14 +475,17 @@ gtk_window_expose_callback( GtkWidget *widget, { DEBUG_MAIN_THREAD - // don't need to install idle handler, its done from "event" signal - // This callback gets called in drawing-idle time under // GTK 2.0, so we don't need to defer anything to idle // time anymore. GtkPizza *pizza = GTK_PIZZA( widget ); - if (gdk_event->window != pizza->bin_window) return FALSE; + if (gdk_event->window != pizza->bin_window) + { + // block expose events on GTK_WIDGET(pizza)->window, + // all drawing is done on pizza->bin_window + return true; + } #if 0 @@ -513,8 +518,6 @@ gtk_window_expose_callback( GtkWidget *widget, win->GtkSendPaintEvents(); // Let parent window draw window-less widgets - (* GTK_WIDGET_CLASS (pizza_parent_class)->expose_event) (widget, gdk_event); - return FALSE; } } @@ -983,8 +986,6 @@ gtk_window_key_press_callback( GtkWidget *widget, { DEBUG_MAIN_THREAD - // don't need to install idle handler, its done from "event" signal - if (!win->m_hasVMT) return FALSE; if (g_blockEventsOnDrag) @@ -1115,30 +1116,6 @@ gtk_window_key_press_callback( GtkWidget *widget, } } - // win is a control: tab can be propagated up - if ( !ret && - ((gdk_event->keyval == GDK_Tab) || (gdk_event->keyval == GDK_ISO_Left_Tab)) && -// 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 -// 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; - new_event.SetEventObject( win->GetParent() ); - // GDK reports GDK_ISO_Left_Tab for SHIFT-TAB - new_event.SetDirection( (gdk_event->keyval == GDK_Tab) ); - // CTRL-TAB changes the (parent) window, i.e. switch notebook page - new_event.SetWindowChange( (gdk_event->state & GDK_CONTROL_MASK) ); - new_event.SetCurrentFocus( win ); - ret = win->GetParent()->GetEventHandler()->ProcessEvent( new_event ); - } - return ret; } } @@ -1158,9 +1135,13 @@ gtk_wxwindow_commit_cb (GtkIMContext *context, wxFillOtherKeyEventFields(event, window, window->m_imData->lastKeyEvent); } + else + { + event.SetEventObject( window ); + } - const wxWxCharBuffer data(wxGTK_CONV_BACK(str)); - if( !data ) + const wxString data(wxGTK_CONV_BACK_SYS(str)); + if( data.empty() ) return; bool ret = false; @@ -1170,7 +1151,7 @@ gtk_wxwindow_commit_cb (GtkIMContext *context, while (parent && !parent->IsTopLevel()) parent = parent->GetParent(); - for( const wxChar* pstr = data; *pstr; pstr++ ) + for( wxString::const_iterator pstr = data.begin(); pstr != data.end(); ++pstr ) { #if wxUSE_UNICODE event.m_uniChar = *pstr; @@ -1178,7 +1159,7 @@ gtk_wxwindow_commit_cb (GtkIMContext *context, 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; + event.m_keyCode = (char)*pstr; #endif // wxUSE_UNICODE // To conform to the docs we need to translate Ctrl-alpha @@ -1225,8 +1206,6 @@ gtk_window_key_release_callback( GtkWidget *widget, { DEBUG_MAIN_THREAD - // don't need to install idle handler, its done from "event" signal - if (!win->m_hasVMT) return FALSE; @@ -1265,20 +1244,11 @@ template void InitMouseEvent(wxWindowGTK *win, 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; - + if ((win->m_wxwindow) && (win->GetLayoutDirection() == wxLayout_RightToLeft)) { // origin in the upper right corner @@ -1403,8 +1373,6 @@ int wxWindowGTK::GTKCallbackCommonPrologue(GdkEventAny *event) const { DEBUG_MAIN_THREAD - // don't need to install idle handler, its done from "event" signal - if (!m_hasVMT) return FALSE; if (g_blockEventsOnDrag) @@ -1468,7 +1436,9 @@ gtk_window_button_press_callback( GtkWidget *widget, { wxCOMMON_CALLBACK_PROLOGUE(gdk_event, win); - if (win->m_wxwindow && (g_focusWindow != win) && win->AcceptsFocus()) + g_lastButtonNumber = gdk_event->button; + + if (win->m_wxwindow && (g_focusWindow != win) && win->IsFocusable()) { gtk_widget_grab_focus( win->m_wxwindow ); } @@ -1476,7 +1446,7 @@ gtk_window_button_press_callback( GtkWidget *widget, // GDK sends surplus button down events // before a double click event. We // need to filter these out. - if (gdk_event->type == GDK_BUTTON_PRESS) + if ((gdk_event->type == GDK_BUTTON_PRESS) && (win->m_wxwindow)) { GdkEvent *peek_event = gdk_event_peek(); if (peek_event) @@ -1570,13 +1540,6 @@ gtk_window_button_press_callback( GtkWidget *widget, ; } } - else if (gdk_event->button == 4 || gdk_event->button == 5) - { - if (gdk_event->type == GDK_BUTTON_PRESS ) - { - event_type = wxEVT_MOUSEWHEEL; - } - } if ( event_type == wxEVT_NULL ) { @@ -1584,6 +1547,8 @@ gtk_window_button_press_callback( GtkWidget *widget, return FALSE; } + g_lastMouseEvent = (GdkEvent*) gdk_event; + wxMouseEvent event( event_type ); InitMouseEvent( win, event, gdk_event ); @@ -1603,9 +1568,15 @@ gtk_window_button_press_callback( GtkWidget *widget, event.SetEventObject( win ); event.SetId( win->GetId() ); - if (win->GTKProcessEvent( event )) - { + bool ret = win->GTKProcessEvent( event ); + g_lastMouseEvent = NULL; + if ( ret ) return TRUE; + + if ((event_type == wxEVT_LEFT_DOWN) && !win->IsOfStandardClass() && + (g_focusWindow != win) && win->IsFocusable()) + { + gtk_widget_grab_focus( win->m_wxwindow ); } if (event_type == wxEVT_RIGHT_DOWN) @@ -1639,6 +1610,8 @@ gtk_window_button_release_callback( GtkWidget *widget, { wxCOMMON_CALLBACK_PROLOGUE(gdk_event, win); + g_lastButtonNumber = 0; + wxEventType event_type = wxEVT_NULL; switch (gdk_event->button) @@ -1660,6 +1633,8 @@ gtk_window_button_release_callback( GtkWidget *widget, return FALSE; } + g_lastMouseEvent = (GdkEvent*) gdk_event; + wxMouseEvent event( event_type ); InitMouseEvent( win, event, gdk_event ); @@ -1675,7 +1650,11 @@ gtk_window_button_release_callback( GtkWidget *widget, event.SetEventObject( win ); event.SetId( win->GetId() ); - return win->GTKProcessEvent(event); + bool ret = win->GTKProcessEvent(event); + + g_lastMouseEvent = NULL; + + return ret; } //----------------------------------------------------------------------------- @@ -1699,6 +1678,8 @@ gtk_window_motion_notify_callback( GtkWidget *widget, gdk_event->y = y; } + g_lastMouseEvent = (GdkEvent*) gdk_event; + wxMouseEvent event( wxEVT_MOTION ); InitMouseEvent(win, event, gdk_event); @@ -1741,11 +1722,15 @@ gtk_window_motion_notify_callback( GtkWidget *widget, } } - return win->GTKProcessEvent(event); + bool ret = win->GTKProcessEvent(event); + + g_lastMouseEvent = NULL; + + return ret; } //----------------------------------------------------------------------------- -// "scroll_event", (mouse wheel event) +// "scroll_event" (mouse wheel event) //----------------------------------------------------------------------------- static gboolean @@ -1753,8 +1738,6 @@ window_scroll_event(GtkWidget*, GdkEventScroll* gdk_event, wxWindow* win) { DEBUG_MAIN_THREAD - // don't need to install idle handler, its done from "event" signal - if (gdk_event->direction != GDK_SCROLL_UP && gdk_event->direction != GDK_SCROLL_DOWN) { @@ -1811,8 +1794,6 @@ gtk_window_focus_in_callback( GtkWidget *widget, { DEBUG_MAIN_THREAD - // don't need to install idle handler, its done from "event" signal - if (win->m_imData) gtk_im_context_focus_in(win->m_imData->context); @@ -1822,11 +1803,6 @@ gtk_window_focus_in_callback( GtkWidget *widget, wxLogTrace(TRACE_FOCUS, _T("%s: focus in"), win->GetName().c_str()); -#ifdef HAVE_XIM - if (win->m_ic) - gdk_im_begin(win->m_ic, win->m_wxwindow->window); -#endif - #if wxUSE_CARET // caret needs to be informed about focus change wxCaret *caret = win->GetCaret(); @@ -1868,8 +1844,6 @@ gtk_window_focus_out_callback( GtkWidget *widget, { DEBUG_MAIN_THREAD - // don't need to install idle handler, its done from "event" signal - if (win->m_imData) gtk_im_context_focus_out(win->m_imData->context); @@ -1883,11 +1857,6 @@ gtk_window_focus_out_callback( GtkWidget *widget, g_focusWindow = (wxWindowGTK *)NULL; -#ifdef HAVE_XIM - if (win->m_ic) - gdk_im_end(); -#endif - #if wxUSE_CARET // caret needs to be informed about focus change wxCaret *caret = win->GetCaret(); @@ -1897,12 +1866,14 @@ gtk_window_focus_out_callback( GtkWidget *widget, } #endif // wxUSE_CARET - gboolean ret = FALSE; - // don't send the window a kill focus event if it thinks that it doesn't // have focus already if ( win->m_hasFocus ) { + // the event handler might delete the window when it loses focus, so + // check whether this is a custom window before calling it + const bool has_wxwindow = win->m_wxwindow != NULL; + win->m_hasFocus = false; wxFocusEvent event( wxEVT_KILL_FOCUS, win->GetId() ); @@ -1910,14 +1881,32 @@ gtk_window_focus_out_callback( GtkWidget *widget, (void)win->GTKProcessEvent( event ); - ret = TRUE; + // Disable default focus handling for custom windows + // since the default GTK+ handler issues a repaint + if ( has_wxwindow ) + return TRUE; } - // Disable default focus handling for custom windows - // since the default GTK+ handler issues a repaint - if (win->m_wxwindow) - return ret; + // continue with normal processing + return FALSE; +} +static gboolean +wx_window_focus_callback(GtkWidget *widget, + GtkDirectionType direction, + wxWindowGTK *win) +{ + // the default handler for focus signal in GtkPizza (or, rather, in + // GtkScrolledWindow from which GtkPizza inherits this behaviour) sets + // focus to the window itself even if it doesn't accept focus, i.e. has no + // GTK_CAN_FOCUS in its style -- work around this by forcibly preventing + // the signal from reaching gtk_scrolled_window_focus() if we don't have + // any children which might accept focus (we know we don't accept the focus + // ourselves as this signal is only connected in this case) + if ( win->GetChildren().empty() ) + g_signal_stop_emission_by_name(widget, "focus"); + + // we didn't change the focus return FALSE; } @@ -2015,13 +2004,11 @@ gtk_scrollbar_value_changed(GtkRange* range, wxWindow* win) wxWindowGTK::ScrollDir dir = win->ScrollDirFromRange(range); // generate the corresponding wx event - const int orient = win->OrientFromScrollDir(dir); + const int orient = wxWindow::OrientFromScrollDir(dir); wxScrollWinEvent event(eventType, win->GetScrollPos(orient), orient); event.SetEventObject(win); - win->m_blockValueChanged[dir] = true; win->GTKProcessEvent(event); - win->m_blockValueChanged[dir] = false; } } @@ -2034,8 +2021,6 @@ gtk_scrollbar_button_press_event(GtkRange*, GdkEventButton*, wxWindow* win) { DEBUG_MAIN_THREAD - // don't need to install idle handler, its done from "event" signal - g_blockEventsOnScroll = true; win->m_mouseButtonDown = true; @@ -2053,7 +2038,7 @@ gtk_scrollbar_event_after(GtkRange* range, GdkEvent* event, wxWindow* win) { g_signal_handlers_block_by_func(range, (void*)gtk_scrollbar_event_after, win); - const int orient = win->OrientFromScrollDir( + const int orient = wxWindow::OrientFromScrollDir( win->ScrollDirFromRange(range)); wxScrollWinEvent event(wxEVT_SCROLLWIN_THUMBRELEASE, win->GetScrollPos(orient), orient); event.SetEventObject(win); @@ -2089,17 +2074,11 @@ gtk_scrollbar_button_release_event(GtkRange* range, GdkEventButton*, wxWindow* w // "realize" from m_widget //----------------------------------------------------------------------------- -/* We cannot set colours and fonts before the widget has - been realized, so we do this directly after realization. */ - static void gtk_window_realized_callback( GtkWidget *m_widget, wxWindow *win ) { DEBUG_MAIN_THREAD - if (g_isIdle) - wxapp_install_idle_handler(); - if (win->m_imData) { GtkPizza *pizza = GTK_PIZZA( m_widget ); @@ -2107,6 +2086,16 @@ gtk_window_realized_callback( GtkWidget *m_widget, wxWindow *win ) pizza->bin_window ); } + // We cannot set colours and fonts before the widget + // been realized, so we do this directly after realization + // or otherwise in idle time + + if (win->m_needsStyleChange) + { + win->SetBackgroundStyle(win->GetBackgroundStyle()); + win->m_needsStyleChange = false; + } + wxWindowCreateEvent event( win ); event.SetEventObject( win ); win->GTKProcessEvent( event ); @@ -2121,27 +2110,17 @@ void gtk_window_size_callback( GtkWidget *WXUNUSED(widget), GtkAllocation *alloc, wxWindow *win ) { - if (g_isIdle) - wxapp_install_idle_handler(); - int client_width = 0; int client_height = 0; win->GetClientSize( &client_width, &client_height ); if ((client_width == win->m_oldClientWidth) && (client_height == win->m_oldClientHeight)) return; -#if 0 - wxPrintf( wxT("size_allocate ") ); - if (win->GetClassInfo() && win->GetClassInfo()->GetClassName()) - wxPrintf( win->GetClassInfo()->GetClassName() ); - wxPrintf( wxT(" %d %d %d %d\n"), - alloc->x, - alloc->y, - alloc->width, - alloc->height ); -#endif - - GTK_PIZZA(win->m_wxwindow)->m_width = alloc->width; + if ( !client_width && !client_height ) + { + // the window is currently unmapped, don't generate size events + return; + } win->m_oldClientWidth = client_width; win->m_oldClientHeight = client_height; @@ -2154,129 +2133,6 @@ void gtk_window_size_callback( GtkWidget *WXUNUSED(widget), } } - -#ifdef HAVE_XIM - #define WXUNUSED_UNLESS_XIM(param) param -#else - #define WXUNUSED_UNLESS_XIM(param) WXUNUSED(param) -#endif - -/* Resize XIM window */ -static -void gtk_wxwindow_size_callback( GtkWidget* WXUNUSED_UNLESS_XIM(widget), - GtkAllocation* WXUNUSED_UNLESS_XIM(alloc), - wxWindowGTK* WXUNUSED_UNLESS_XIM(win) ) -{ - if (g_isIdle) - wxapp_install_idle_handler(); - -#ifdef HAVE_XIM - if (!win->m_ic) - return; - - if (gdk_ic_get_style (win->m_ic) & GDK_IM_PREEDIT_POSITION) - { - gint width, height; - - gdk_drawable_get_size (widget->window, &width, &height); - win->m_icattr->preedit_area.width = width; - win->m_icattr->preedit_area.height = height; - gdk_ic_set_attr (win->m_ic, win->m_icattr, GDK_IC_PREEDIT_AREA); - } -#endif // HAVE_XIM -} - -//----------------------------------------------------------------------------- -// "realize" from m_wxwindow -//----------------------------------------------------------------------------- - -/* Initialize XIM support */ - -static void -gtk_wxwindow_realized_callback( GtkWidget * WXUNUSED_UNLESS_XIM(widget), - wxWindowGTK * WXUNUSED_UNLESS_XIM(win) ) -{ - if (g_isIdle) - wxapp_install_idle_handler(); - -#ifdef HAVE_XIM - if (win->m_ic) return; - if (!widget) return; - if (!gdk_im_ready()) return; - - win->m_icattr = gdk_ic_attr_new(); - if (!win->m_icattr) return; - - gint width, height; - GdkEventMask mask; - GdkColormap *colormap; - GdkICAttr *attr = win->m_icattr; - unsigned attrmask = GDK_IC_ALL_REQ; - GdkIMStyle style; - GdkIMStyle supported_style = (GdkIMStyle) - (GDK_IM_PREEDIT_NONE | - GDK_IM_PREEDIT_NOTHING | - GDK_IM_PREEDIT_POSITION | - GDK_IM_STATUS_NONE | - GDK_IM_STATUS_NOTHING); - - if (widget->style && widget->style->font->type != GDK_FONT_FONTSET) - supported_style = (GdkIMStyle)(supported_style & ~GDK_IM_PREEDIT_POSITION); - - attr->style = style = gdk_im_decide_style (supported_style); - attr->client_window = widget->window; - - if ((colormap = gtk_widget_get_colormap (widget)) != - gtk_widget_get_default_colormap ()) - { - attrmask |= GDK_IC_PREEDIT_COLORMAP; - attr->preedit_colormap = colormap; - } - - attrmask |= GDK_IC_PREEDIT_FOREGROUND; - attrmask |= GDK_IC_PREEDIT_BACKGROUND; - attr->preedit_foreground = widget->style->fg[GTK_STATE_NORMAL]; - attr->preedit_background = widget->style->base[GTK_STATE_NORMAL]; - - switch (style & GDK_IM_PREEDIT_MASK) - { - case GDK_IM_PREEDIT_POSITION: - if (widget->style && widget->style->font->type != GDK_FONT_FONTSET) - { - g_warning ("over-the-spot style requires fontset"); - break; - } - - gdk_drawable_get_size (widget->window, &width, &height); - - attrmask |= GDK_IC_PREEDIT_POSITION_REQ; - attr->spot_location.x = 0; - attr->spot_location.y = height; - attr->preedit_area.x = 0; - attr->preedit_area.y = 0; - attr->preedit_area.width = width; - attr->preedit_area.height = height; - attr->preedit_fontset = widget->style->font; - - break; - } - - win->m_ic = gdk_ic_new (attr, (GdkICAttributesType)attrmask); - - if (win->m_ic == NULL) - g_warning ("Can't create input context."); - else - { - mask = gdk_window_get_events (widget->window); - mask = (GdkEventMask)(mask | gdk_ic_get_events (win->m_ic)); - gdk_window_set_events (widget->window, mask); - - if (GTK_WIDGET_HAS_FOCUS(widget)) - gdk_im_begin (win->m_ic, widget->window); - } -#endif // HAVE_XIM -} - } // extern "C" // ---------------------------------------------------------------------------- @@ -2310,7 +2166,7 @@ static void wxInsertChildInWindow( wxWindowGTK* parent, wxWindowGTK* child ) child->m_y += gtk_pizza_get_yoffset( pizza ); gtk_pizza_put( GTK_PIZZA(parent->m_wxwindow), - GTK_WIDGET(child->m_widget), + child->m_widget, child->m_x, child->m_y, child->m_width, @@ -2376,9 +2232,7 @@ void wxWindowGTK::Init() m_width = 0; m_height = 0; - m_sizeSet = false; m_hasVMT = false; - m_needParent = true; m_isBeingDeleted = false; m_showOnIdle= false; @@ -2396,7 +2250,6 @@ void wxWindowGTK::Init() { m_scrollBar[dir] = NULL; m_scrollPos[dir] = 0; - m_blockValueChanged[dir] = false; } m_oldClientWidth = @@ -2404,9 +2257,8 @@ void wxWindowGTK::Init() m_resizing = false; - m_insertCallback = (wxInsertChildFunction) NULL; + m_insertCallback = wxInsertChildInWindow; - m_acceptsFocus = false; m_hasFocus = false; m_clipPaintRegion = false; @@ -2450,70 +2302,95 @@ bool wxWindowGTK::Create( wxWindow *parent, return false; } - m_insertCallback = wxInsertChildInWindow; + if (!HasFlag(wxHSCROLL) && !HasFlag(wxVSCROLL)) + { + m_wxwindow = gtk_pizza_new_no_scroll(); - m_widget = gtk_scrolled_window_new( (GtkAdjustment *) NULL, (GtkAdjustment *) NULL ); - GTK_WIDGET_UNSET_FLAGS( m_widget, GTK_CAN_FOCUS ); +#ifndef __WXUNIVERSAL__ + if (HasFlag(wxSIMPLE_BORDER)) + gtk_container_set_border_width((GtkContainer*)m_wxwindow, 1); + else if (HasFlag(wxRAISED_BORDER) || HasFlag(wxSUNKEN_BORDER)) + gtk_container_set_border_width((GtkContainer*)m_wxwindow, 2); +#endif // __WXUNIVERSAL__ - GtkScrolledWindow *scrolledWindow = GTK_SCROLLED_WINDOW(m_widget); + m_widget = m_wxwindow; + } + else + { + m_wxwindow = gtk_pizza_new(); - GtkScrolledWindowClass *scroll_class = GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT_GET_CLASS(m_widget) ); - scroll_class->scrollbar_spacing = 0; +#ifndef __WXUNIVERSAL__ + if (HasFlag(wxSIMPLE_BORDER)) + gtk_container_set_border_width((GtkContainer*)m_wxwindow, 1); + else if (HasFlag(wxRAISED_BORDER) || HasFlag(wxSUNKEN_BORDER)) + gtk_container_set_border_width((GtkContainer*)m_wxwindow, 2); +#endif // __WXUNIVERSAL__ - gtk_scrolled_window_set_policy( scrolledWindow, GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC ); + m_widget = gtk_scrolled_window_new( (GtkAdjustment *) NULL, (GtkAdjustment *) NULL ); - m_scrollBar[ScrollDir_Horz] = GTK_RANGE(scrolledWindow->hscrollbar); - m_scrollBar[ScrollDir_Vert] = GTK_RANGE(scrolledWindow->vscrollbar); + GtkScrolledWindow *scrolledWindow = GTK_SCROLLED_WINDOW(m_widget); - m_wxwindow = gtk_pizza_new(); + GtkScrolledWindowClass *scroll_class = GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT_GET_CLASS(m_widget) ); + scroll_class->scrollbar_spacing = 0; -#ifndef __WXUNIVERSAL__ - GtkPizza *pizza = GTK_PIZZA(m_wxwindow); + // There is a conflict with default bindings at GTK+ + // level between scrolled windows and notebooks both of which want to use + // Ctrl-PageUp/Down: scrolled windows for scrolling in the horizontal + // direction and notebooks for changing pages -- we decide that if we don't + // have wxHSCROLL style we can safely sacrifice horizontal scrolling if it + // means we can get working keyboard navigation in notebooks + if ( !HasFlag(wxHSCROLL) ) + { + GtkBindingSet * + bindings = gtk_binding_set_by_class(G_OBJECT_GET_CLASS(m_widget)); + if ( bindings ) + { + gtk_binding_entry_remove(bindings, GDK_Page_Up, GDK_CONTROL_MASK); + gtk_binding_entry_remove(bindings, GDK_Page_Down, GDK_CONTROL_MASK); + } + } - if (HasFlag(wxRAISED_BORDER)) - { - gtk_pizza_set_shadow_type( pizza, GTK_MYSHADOW_OUT ); - } - else if (HasFlag(wxSUNKEN_BORDER)) - { - gtk_pizza_set_shadow_type( pizza, GTK_MYSHADOW_IN ); - } - else if (HasFlag(wxSIMPLE_BORDER)) - { - gtk_pizza_set_shadow_type( pizza, GTK_MYSHADOW_THIN ); - } - else - { - gtk_pizza_set_shadow_type( pizza, GTK_MYSHADOW_NONE ); - } -#endif // __WXUNIVERSAL__ + if (HasFlag(wxALWAYS_SHOW_SB)) + { + gtk_scrolled_window_set_policy( scrolledWindow, GTK_POLICY_ALWAYS, GTK_POLICY_ALWAYS ); + + scrolledWindow->hscrollbar_visible = TRUE; + scrolledWindow->vscrollbar_visible = TRUE; + } + else + { + gtk_scrolled_window_set_policy( scrolledWindow, GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC ); + } - gtk_container_add( GTK_CONTAINER(m_widget), m_wxwindow ); + m_scrollBar[ScrollDir_Horz] = GTK_RANGE(scrolledWindow->hscrollbar); + m_scrollBar[ScrollDir_Vert] = GTK_RANGE(scrolledWindow->vscrollbar); + if (GetLayoutDirection() == wxLayout_RightToLeft) + gtk_range_set_inverted( m_scrollBar[ScrollDir_Horz], TRUE ); - GTK_WIDGET_SET_FLAGS( m_wxwindow, GTK_CAN_FOCUS ); - m_acceptsFocus = true; + gtk_container_add( GTK_CONTAINER(m_widget), m_wxwindow ); - // connect various scroll-related events - for ( int dir = 0; dir < ScrollDir_Max; dir++ ) - { - // these handlers block mouse events to any window during scrolling - // such as motion events and prevent GTK and wxWidgets from fighting - // over where the slider should be - g_signal_connect(m_scrollBar[dir], "button_press_event", + // connect various scroll-related events + for ( int dir = 0; dir < ScrollDir_Max; dir++ ) + { + // these handlers block mouse events to any window during scrolling + // such as motion events and prevent GTK and wxWidgets from fighting + // over where the slider should be + g_signal_connect(m_scrollBar[dir], "button_press_event", G_CALLBACK(gtk_scrollbar_button_press_event), this); - g_signal_connect(m_scrollBar[dir], "button_release_event", + g_signal_connect(m_scrollBar[dir], "button_release_event", G_CALLBACK(gtk_scrollbar_button_release_event), this); - gulong handler_id = g_signal_connect(m_scrollBar[dir], "event_after", + gulong handler_id = g_signal_connect(m_scrollBar[dir], "event_after", G_CALLBACK(gtk_scrollbar_event_after), this); - g_signal_handler_block(m_scrollBar[dir], handler_id); + g_signal_handler_block(m_scrollBar[dir], handler_id); - // these handlers get notified when scrollbar slider moves - g_signal_connect(m_scrollBar[dir], "value_changed", + // these handlers get notified when scrollbar slider moves + g_signal_connect_after(m_scrollBar[dir], "value_changed", G_CALLBACK(gtk_scrollbar_value_changed), this); - } + } - gtk_widget_show( m_wxwindow ); + gtk_widget_show( m_wxwindow ); + } if (m_parent) m_parent->DoAddChild( this ); @@ -2556,17 +2433,10 @@ wxWindowGTK::~wxWindowGTK() if (m_widget) Show( false ); -#ifdef HAVE_XIM - if (m_ic) - gdk_ic_destroy (m_ic); - if (m_icattr) - gdk_ic_attr_destroy (m_icattr); -#endif - // delete before the widgets to avoid a crash on solaris delete m_imData; - if (m_wxwindow) + if (m_wxwindow && (m_wxwindow != m_widget)) { gtk_widget_destroy( m_wxwindow ); m_wxwindow = (GtkWidget*) NULL; @@ -2581,7 +2451,10 @@ wxWindowGTK::~wxWindowGTK() bool wxWindowGTK::PreCreation( wxWindowGTK *parent, const wxPoint &pos, const wxSize &size ) { - wxCHECK_MSG( !m_needParent || parent, false, wxT("Need complete parent.") ); + if ( GTKNeedsParent() ) + { + wxCHECK_MSG( parent, false, wxT("Must have non-NULL parent") ); + } // Use either the given size, or the default if -1 is given. // See wxWindowBase for these functions. @@ -2604,8 +2477,6 @@ void wxWindowGTK::PostCreation() { // these get reported to wxWidgets -> wxPaintEvent - gtk_pizza_set_external( GTK_PIZZA(m_wxwindow), TRUE ); - g_signal_connect (m_wxwindow, "expose_event", G_CALLBACK (gtk_window_expose_callback), this); @@ -2650,6 +2521,14 @@ void wxWindowGTK::PostCreation() } } + if ( !AcceptsFocusFromKeyboard() ) + { + SetCanFocus(false); + + g_signal_connect(m_widget, "focus", + G_CALLBACK(wx_window_focus_callback), this); + } + // connect to the various key and mouse handlers GtkWidget *connect_widget = GetConnectWidget(); @@ -2666,16 +2545,9 @@ void wxWindowGTK::PostCreation() // Catch native resize events g_signal_connect (m_wxwindow, "size_allocate", G_CALLBACK (gtk_window_size_callback), this); - - // Initialize XIM support - g_signal_connect (m_wxwindow, "realize", - G_CALLBACK (gtk_wxwindow_realized_callback), this); - - // And resize XIM window - g_signal_connect (m_wxwindow, "size_allocate", - G_CALLBACK (gtk_wxwindow_size_callback), this); } +#if wxUSE_COMBOBOX if (GTK_IS_COMBO(m_widget)) { GtkCombo *gcombo = GTK_COMBO(m_widget); @@ -2683,17 +2555,18 @@ void wxWindowGTK::PostCreation() g_signal_connect (gcombo->entry, "size_request", G_CALLBACK (wxgtk_combo_size_request_callback), this); - } + } else +#endif // wxUSE_COMBOBOX #ifdef GTK_IS_FILE_CHOOSER_BUTTON - else if (!gtk_check_version(2,6,0) && GTK_IS_FILE_CHOOSER_BUTTON(m_widget)) + if (!gtk_check_version(2,6,0) && GTK_IS_FILE_CHOOSER_BUTTON(m_widget)) { // If we connect to the "size_request" signal of a GtkFileChooserButton // then that control won't be sized properly when placed inside sizers // (this can be tested removing this elseif and running XRC or WIDGETS samples) // FIXME: what should be done here ? - } + } else #endif - else + if ( !IsTopLevel() ) // top level windows use their own callback { // This is needed if we want to add our windows into native // GTK controls, such as the toolbar. With this callback, the @@ -2751,7 +2624,24 @@ void wxWindowGTK::DoMoveWindow(int x, int y, int width, int height) { // inform the parent to perform the move gtk_pizza_set_size( GTK_PIZZA(m_parent->m_wxwindow), m_widget, x, y, width, height ); - + +} + +void wxWindowGTK::ConstrainSize() +{ +#ifdef __WXGPE__ + // GPE's window manager doesn't like size hints at all, esp. when the user + // has to use the virtual keyboard, so don't constrain size there + if (!IsTopLevel()) +#endif + { + const wxSize minSize = GetMinSize(); + const wxSize maxSize = GetMaxSize(); + if (minSize.x > 0 && m_width < minSize.x) m_width = minSize.x; + if (minSize.y > 0 && m_height < minSize.y) m_height = minSize.y; + if (maxSize.x > 0 && m_width > maxSize.x) m_width = maxSize.x; + if (maxSize.y > 0 && m_height > maxSize.y) m_height = maxSize.y; + } } void wxWindowGTK::DoSetSize( int x, int y, int width, int height, int sizeFlags ) @@ -2759,10 +2649,6 @@ void wxWindowGTK::DoSetSize( int x, int y, int width, int height, int sizeFlags wxASSERT_MSG( (m_widget != NULL), wxT("invalid window") ); wxASSERT_MSG( (m_parent != NULL), wxT("wxWindowGTK::SetSize requires parent.\n") ); -/* - printf( "DoSetSize: name %s, x,y,w,h: %d,%d,%d,%d \n", GetName().c_str(), x,y,width,height ); -*/ - if (m_resizing) return; /* I don't like recursions */ m_resizing = true; @@ -2790,21 +2676,13 @@ void wxWindowGTK::DoSetSize( int x, int y, int width, int height, int sizeFlags if (height != -1) m_height = height; - int minWidth = GetMinWidth(), - minHeight = GetMinHeight(), - maxWidth = GetMaxWidth(), - maxHeight = GetMaxHeight(); - - if ((minWidth != -1) && (m_width < minWidth )) m_width = minWidth; - if ((minHeight != -1) && (m_height < minHeight)) m_height = minHeight; - if ((maxWidth != -1) && (m_width > maxWidth )) m_width = maxWidth; - if ((maxHeight != -1) && (m_height > maxHeight)) m_height = maxHeight; + ConstrainSize(); #if wxUSE_TOOLBAR_NATIVE if (wxDynamicCast(GetParent(), wxToolBar)) { // don't take the x,y values, they're wrong because toolbar sets them - GtkWidget *widget = GTK_WIDGET(m_widget); + GtkWidget *widget = m_widget; gtk_widget_set_size_request (widget, m_width, m_height); } else @@ -2847,12 +2725,12 @@ void wxWindowGTK::DoSetSize( int x, int y, int width, int height, int sizeFlags right_border += default_border->right; top_border += default_border->top; bottom_border += default_border->bottom; - g_free( default_border ); + gtk_border_free( default_border ); } } - DoMoveWindow( m_x-top_border, - m_y-left_border, + DoMoveWindow( m_x - left_border, + m_y - top_border, m_width+left_border+right_border, m_height+top_border+bottom_border ); } @@ -2935,7 +2813,7 @@ void wxWindowGTK::OnInternalIdle() windows above so that checking for the current cursor is not possible. */ - if (m_wxwindow) + if (m_wxwindow && (m_wxwindow != m_widget)) { GdkWindow *window = GTK_PIZZA(m_wxwindow)->bin_window; if (window) @@ -2973,36 +2851,9 @@ void wxWindowGTK::DoSetClientSize( int width, int height ) { wxCHECK_RET( (m_widget != NULL), wxT("invalid window") ); - if (m_wxwindow) - { - int dw = 0; - int dh = 0; - - if (m_hasScrolling) - { - GetScrollbarWidth(m_widget, dw, dh); - } - -#ifndef __WXUNIVERSAL__ - if (HasFlag(wxRAISED_BORDER) || HasFlag(wxSUNKEN_BORDER)) - { - // shadow border size is 2 - dw += 2 * 2; - dh += 2 * 2; - } - if (HasFlag(wxSIMPLE_BORDER)) - { - // simple border size is 1 - dw += 1 * 2; - dh += 1 * 2; - } -#endif // __WXUNIVERSAL__ - - width += dw; - height += dh; - } - - SetSize(width, height); + const wxSize size = GetSize(); + const wxSize clientSize = GetClientSize(); + SetSize(width + (size.x - clientSize.x), height + (size.y - clientSize.y)); } void wxWindowGTK::DoGetClientSize( int *width, int *height ) const @@ -3018,24 +2869,11 @@ void wxWindowGTK::DoGetClientSize( int *width, int *height ) const int dh = 0; if (m_hasScrolling) - { GetScrollbarWidth(m_widget, dw, dh); - } -#ifndef __WXUNIVERSAL__ - if (HasFlag(wxRAISED_BORDER) || HasFlag(wxSUNKEN_BORDER)) - { - // shadow border size is 2 - dw += 2 * 2; - dh += 2 * 2; - } - if (HasFlag(wxSIMPLE_BORDER)) - { - // simple border size is 1 - dw += 1 * 2; - dh += 1 * 2; - } -#endif // __WXUNIVERSAL__ + const int border = GTK_CONTAINER(m_wxwindow)->border_width; + dw += 2 * border; + dh += 2 * border; w -= dw; h -= dh; @@ -3076,12 +2914,12 @@ void wxWindowGTK::DoGetPosition( int *x, int *y ) const int org_y = 0; gdk_window_get_origin( source, &org_x, &org_y ); - if (GetParent()) - GetParent()->ScreenToClient(&org_x, &org_y); + if (m_parent) + m_parent->ScreenToClient(&org_x, &org_y); - ((wxWindowGTK*) this)->m_x = org_x; - ((wxWindowGTK*) this)->m_y = org_y; - } + wx_const_cast(wxWindowGTK*, this)->m_x = org_x; + wx_const_cast(wxWindowGTK*, this)->m_y = org_y; + } } if (x) (*x) = m_x - dx; @@ -3113,7 +2951,15 @@ void wxWindowGTK::DoClientToScreen( int *x, int *y ) const } } - if (x) *x += org_x; + + if (x) + { + if (GetLayoutDirection() == wxLayout_RightToLeft) + *x = (GetClientSize().x - *x) + org_x; + else + *x += org_x; + } + if (y) *y += org_y; } @@ -3142,7 +2988,13 @@ void wxWindowGTK::DoScreenToClient( int *x, int *y ) const } } - if (x) *x -= org_x; + if (x) + { + if (GetLayoutDirection() == wxLayout_RightToLeft) + *x = (GetClientSize().x - *x) - org_x; + else + *x -= org_x; + } if (y) *y -= org_y; } @@ -3177,40 +3029,13 @@ bool wxWindowGTK::Show( bool show ) return true; } -static void wxWindowNotifyEnable(wxWindowGTK* win, bool enable) +void wxWindowGTK::DoEnable( bool enable ) { - win->OnParentEnable(enable); - - // Recurse, so that children have the opportunity to Do The Right Thing - // and reset colours that have been messed up by a parent's (really ancestor's) - // Enable call - for ( wxWindowList::compatibility_iterator node = win->GetChildren().GetFirst(); - node; - node = node->GetNext() ) - { - wxWindow *child = node->GetData(); - if (!child->IsKindOf(CLASSINFO(wxDialog)) && !child->IsKindOf(CLASSINFO(wxFrame))) - wxWindowNotifyEnable(child, enable); - } -} - -bool wxWindowGTK::Enable( bool enable ) -{ - wxCHECK_MSG( (m_widget != NULL), false, wxT("invalid window") ); - - if (!wxWindowBase::Enable(enable)) - { - // nothing to do - return false; - } + wxCHECK_RET( (m_widget != NULL), wxT("invalid window") ); gtk_widget_set_sensitive( m_widget, enable ); - if ( m_wxwindow ) + if (m_wxwindow && (m_wxwindow != m_widget)) gtk_widget_set_sensitive( m_wxwindow, enable ); - - wxWindowNotifyEnable(this, enable); - - return true; } int wxWindowGTK::GetCharHeight() const @@ -3360,6 +3185,14 @@ void wxWindowGTK::SetFocus() { if (GTK_IS_CONTAINER(m_widget)) { +#if wxUSE_RADIOBTN + if (IsKindOf(CLASSINFO(wxRadioButton))) + { + gtk_widget_grab_focus (m_widget); + return; + } +#endif // wxUSE_RADIOBTN + gtk_widget_child_focus( m_widget, GTK_DIR_TAB_FORWARD ); } else @@ -3395,9 +3228,20 @@ void wxWindowGTK::SetFocus() } } -bool wxWindowGTK::AcceptsFocus() const +void wxWindowGTK::SetCanFocus(bool canFocus) { - return m_acceptsFocus && wxWindowBase::AcceptsFocus(); + if ( canFocus ) + GTK_WIDGET_SET_FLAGS(m_widget, GTK_CAN_FOCUS); + else + GTK_WIDGET_UNSET_FLAGS(m_widget, GTK_CAN_FOCUS); + + if ( m_wxwindow && (m_widget != m_wxwindow) ) + { + if ( canFocus ) + GTK_WIDGET_SET_FLAGS(m_wxwindow, GTK_CAN_FOCUS); + else + GTK_WIDGET_UNSET_FLAGS(m_wxwindow, GTK_CAN_FOCUS); + } } bool wxWindowGTK::Reparent( wxWindowBase *newParentBase ) @@ -3447,11 +3291,8 @@ bool wxWindowGTK::Reparent( wxWindowBase *newParentBase ) void wxWindowGTK::DoAddChild(wxWindowGTK *child) { wxASSERT_MSG( (m_widget != NULL), wxT("invalid window") ); - wxASSERT_MSG( (child != NULL), wxT("invalid child window") ); - wxASSERT_MSG( (m_insertCallback != NULL), wxT("invalid child insertion function") ); - /* add to list */ AddChild( child ); @@ -3463,22 +3304,20 @@ void wxWindowGTK::AddChild(wxWindowBase *child) { wxWindowBase::AddChild(child); m_dirtyTabOrder = true; - if (g_isIdle) - wxapp_install_idle_handler(); + wxTheApp->WakeUpIdle(); } void wxWindowGTK::RemoveChild(wxWindowBase *child) { wxWindowBase::RemoveChild(child); m_dirtyTabOrder = true; - if (g_isIdle) - wxapp_install_idle_handler(); + wxTheApp->WakeUpIdle(); } /* static */ wxLayoutDirection wxWindowGTK::GTKGetLayout(GtkWidget *widget) { - return gtk_widget_get_direction(GTK_WIDGET(widget)) == GTK_TEXT_DIR_RTL + return gtk_widget_get_direction(widget) == GTK_TEXT_DIR_RTL ? wxLayout_RightToLeft : wxLayout_LeftToRight; } @@ -3488,7 +3327,7 @@ void wxWindowGTK::GTKSetLayout(GtkWidget *widget, wxLayoutDirection dir) { wxASSERT_MSG( dir != wxLayout_Default, _T("invalid layout direction") ); - gtk_widget_set_direction(GTK_WIDGET(widget), + gtk_widget_set_direction(widget, dir == wxLayout_RightToLeft ? GTK_TEXT_DIR_RTL : GTK_TEXT_DIR_LTR); } @@ -3518,8 +3357,8 @@ void wxWindowGTK::SetLayoutDirection(wxLayoutDirection dir) return; GTKSetLayout(m_widget, dir); - - if (m_wxwindow) + + if (m_wxwindow && (m_wxwindow != m_widget)) GTKSetLayout(m_wxwindow, dir); } @@ -3536,8 +3375,31 @@ void wxWindowGTK::DoMoveInTabOrder(wxWindow *win, MoveKind move) { wxWindowBase::DoMoveInTabOrder(win, move); m_dirtyTabOrder = true; - if (g_isIdle) - wxapp_install_idle_handler(); + wxTheApp->WakeUpIdle(); +} + +bool wxWindowGTK::DoNavigateIn(int flags) +{ + if ( flags & wxNavigationKeyEvent::WinChange ) + { + wxFAIL_MSG( _T("not implemented") ); + + return false; + } + else // navigate inside the container + { + wxWindow *parent = wxGetTopLevelParent((wxWindow *)this); + wxCHECK_MSG( parent, false, _T("every window must have a TLW parent") ); + + GtkDirectionType dir; + dir = flags & wxNavigationKeyEvent::IsForward ? GTK_DIR_TAB_FORWARD + : GTK_DIR_TAB_BACKWARD; + + gboolean rc; + g_signal_emit_by_name(parent->m_widget, "focus", dir, &rc); + + return rc == TRUE; + } } bool wxWindowGTK::GTKWidgetNeedsMnemonic() const @@ -3758,14 +3620,15 @@ void wxWindowGTK::Refresh( bool eraseBackground, const wxRect *rect ) gdk_rect.y = rect->y; gdk_rect.width = rect->width; gdk_rect.height = rect->height; + if (GetLayoutDirection() == wxLayout_RightToLeft) + gdk_rect.x = GetClientSize().x - gdk_rect.x - gdk_rect.width; + p = &gdk_rect; } else // invalidate everything { p = NULL; } - - p = NULL; gdk_window_invalidate_rect( GTK_PIZZA(m_wxwindow)->bin_window, p, TRUE ); } @@ -3786,7 +3649,7 @@ void wxWindowGTK::GtkUpdate() { if (m_wxwindow && GTK_PIZZA(m_wxwindow)->bin_window) gdk_window_process_updates( GTK_PIZZA(m_wxwindow)->bin_window, FALSE ); - if (m_widget && m_widget->window) + if (m_widget && m_widget->window && (m_wxwindow != m_widget)) gdk_window_process_updates( m_widget->window, FALSE ); // for consistency with other platforms (and also because it's convenient @@ -3825,18 +3688,18 @@ void wxWindowGTK::GtkSendPaintEvents() // Clip to paint region in wxClientDC m_clipPaintRegion = true; - wxRegion maybe_rtl_region = m_updateRegion; - -#if 0 + m_nativeUpdateRegion = m_updateRegion; + if (GetLayoutDirection() == wxLayout_RightToLeft) { - maybe_rtl_region.Clear(); - + // Transform m_updateRegion under RTL + m_updateRegion.Clear(); + gint width; gdk_window_get_geometry( GTK_PIZZA(m_wxwindow)->bin_window, NULL, NULL, &width, NULL, NULL ); - - wxRegionIterator upd( m_updateRegion ); + + wxRegionIterator upd( m_nativeUpdateRegion ); while (upd) { wxRect rect; @@ -3844,15 +3707,14 @@ void wxWindowGTK::GtkSendPaintEvents() rect.y = upd.GetY(); rect.width = upd.GetWidth(); rect.height = upd.GetHeight(); - + rect.x = width - rect.x - rect.width; - maybe_rtl_region.Union( rect ); - + m_updateRegion.Union( rect ); + ++upd; } } -#endif - + // widget to draw on GtkPizza *pizza = GTK_PIZZA (m_wxwindow); @@ -3865,7 +3727,7 @@ void wxWindowGTK::GtkSendPaintEvents() if (GTK_WIDGET_MAPPED(parent->m_widget)) { - wxRegionIterator upd( m_updateRegion ); + wxRegionIterator upd( m_nativeUpdateRegion ); while (upd) { GdkRectangle rect; @@ -3889,8 +3751,6 @@ void wxWindowGTK::GtkSendPaintEvents() } else { - m_updateRegion = maybe_rtl_region; - wxWindowDC dc( (wxWindow*)this ); dc.SetClippingRegion( m_updateRegion ); @@ -3900,8 +3760,6 @@ void wxWindowGTK::GtkSendPaintEvents() GetEventHandler()->ProcessEvent(erase_event); } - m_updateRegion = maybe_rtl_region; - wxNcPaintEvent nc_paint_event( GetId() ); nc_paint_event.SetEventObject( this ); GetEventHandler()->ProcessEvent( nc_paint_event ); @@ -3913,6 +3771,7 @@ void wxWindowGTK::GtkSendPaintEvents() m_clipPaintRegion = false; m_updateRegion.Clear(); + m_nativeUpdateRegion.Clear(); } void wxWindowGTK::SetDoubleBuffered( bool on ) @@ -3923,6 +3782,11 @@ void wxWindowGTK::SetDoubleBuffered( bool on ) gtk_widget_set_double_buffered( m_wxwindow, on ); } +bool wxWindowGTK::IsDoubleBuffered() const +{ + return GTK_WIDGET_DOUBLE_BUFFERED( m_wxwindow ); +} + void wxWindowGTK::ClearBackground() { wxCHECK_RET( m_widget != NULL, wxT("invalid window") ); @@ -3937,10 +3801,9 @@ void wxWindowGTK::DoSetToolTip( wxToolTip *tip ) m_tooltip->Apply( (wxWindow *)this ); } -void wxWindowGTK::ApplyToolTip( GtkTooltips *tips, const wxChar *tip ) +void wxWindowGTK::ApplyToolTip( GtkTooltips *tips, const gchar *tip ) { - wxString tmp( tip ); - gtk_tooltips_set_tip( tips, GetConnectWidget(), wxGTK_CONV(tmp), (gchar*) NULL ); + gtk_tooltips_set_tip(tips, GetConnectWidget(), tip, NULL); } #endif // wxUSE_TOOLTIPS @@ -4010,45 +3873,54 @@ GtkRcStyle *wxWindowGTK::CreateWidgetStyle(bool forceStyle) pango_font_description_copy( m_font.GetNativeFontInfo()->description ); } + int flagsNormal = 0, + flagsPrelight = 0, + flagsActive = 0, + flagsInsensitive = 0; + if ( m_foregroundColour.Ok() ) { const GdkColor *fg = m_foregroundColour.GetColor(); - style->fg[GTK_STATE_NORMAL] = *fg; - style->color_flags[GTK_STATE_NORMAL] = GTK_RC_FG; + style->fg[GTK_STATE_NORMAL] = + style->text[GTK_STATE_NORMAL] = *fg; + flagsNormal |= GTK_RC_FG | GTK_RC_TEXT; - style->fg[GTK_STATE_PRELIGHT] = *fg; - style->color_flags[GTK_STATE_PRELIGHT] = GTK_RC_FG; + style->fg[GTK_STATE_PRELIGHT] = + style->text[GTK_STATE_PRELIGHT] = *fg; + flagsPrelight |= GTK_RC_FG | GTK_RC_TEXT; - style->fg[GTK_STATE_ACTIVE] = *fg; - style->color_flags[GTK_STATE_ACTIVE] = GTK_RC_FG; + style->fg[GTK_STATE_ACTIVE] = + style->text[GTK_STATE_ACTIVE] = *fg; + flagsActive |= GTK_RC_FG | GTK_RC_TEXT; } if ( m_backgroundColour.Ok() ) { const GdkColor *bg = m_backgroundColour.GetColor(); - style->bg[GTK_STATE_NORMAL] = *bg; + style->bg[GTK_STATE_NORMAL] = 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); + flagsNormal |= GTK_RC_BG | GTK_RC_BASE; - style->bg[GTK_STATE_PRELIGHT] = *bg; + style->bg[GTK_STATE_PRELIGHT] = 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); + flagsPrelight |= GTK_RC_BG | GTK_RC_BASE; - style->bg[GTK_STATE_ACTIVE] = *bg; + style->bg[GTK_STATE_ACTIVE] = 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); + flagsActive |= GTK_RC_BG | GTK_RC_BASE; - style->bg[GTK_STATE_INSENSITIVE] = *bg; + style->bg[GTK_STATE_INSENSITIVE] = 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); + flagsInsensitive |= GTK_RC_BG | GTK_RC_BASE; } + style->color_flags[GTK_STATE_NORMAL] = (GtkRcFlags)flagsNormal; + style->color_flags[GTK_STATE_PRELIGHT] = (GtkRcFlags)flagsPrelight; + style->color_flags[GTK_STATE_ACTIVE] = (GtkRcFlags)flagsActive; + style->color_flags[GTK_STATE_INSENSITIVE] = (GtkRcFlags)flagsInsensitive; + return style; } @@ -4079,11 +3951,16 @@ bool wxWindowGTK::SetBackgroundStyle(wxBackgroundStyle style) if (style == wxBG_STYLE_CUSTOM) { - GdkWindow *window = (GdkWindow*) NULL; - if (m_wxwindow) + GdkWindow *window; + if ( m_wxwindow ) + { window = GTK_PIZZA(m_wxwindow)->bin_window; + } else - window = GetConnectWidget()->window; + { + GtkWidget * const w = GetConnectWidget(); + window = w ? w->window : NULL; + } if (window) { @@ -4096,9 +3973,11 @@ bool wxWindowGTK::SetBackgroundStyle(wxBackgroundStyle style) #endif m_needsStyleChange = false; } - else + else // window not realized yet + { // Do in OnIdle, because the window is not yet available m_needsStyleChange = true; + } // Don't apply widget style, or we get a grey background } @@ -4243,8 +4122,8 @@ void wxWindowGTK::SetScrollbar(int orient, int range, bool WXUNUSED(update)) { - wxCHECK_RET( m_widget != NULL, wxT("invalid window") ); - wxCHECK_RET( m_wxwindow != NULL, wxT("window needs client area for scrolling") ); + GtkRange * const sb = m_scrollBar[ScrollDirFromOrient(orient)]; + wxCHECK_RET( sb, _T("this window is not scrollable") ); if (range > 0) { @@ -4261,7 +4140,7 @@ void wxWindowGTK::SetScrollbar(int orient, pos = range - thumbVisible; if (pos < 0) pos = 0; - GtkAdjustment* adj = m_scrollBar[ScrollDirFromOrient(orient)]->adjustment; + GtkAdjustment * const adj = sb->adjustment; adj->step_increment = 1; adj->page_increment = adj->page_size = thumbVisible; @@ -4272,52 +4151,54 @@ void wxWindowGTK::SetScrollbar(int orient, void wxWindowGTK::SetScrollPos(int orient, int pos, bool WXUNUSED(refresh)) { - wxCHECK_RET( m_widget != NULL, wxT("invalid window") ); - wxCHECK_RET( m_wxwindow != NULL, wxT("window needs client area for scrolling") ); + const int dir = ScrollDirFromOrient(orient); + GtkRange * const sb = m_scrollBar[dir]; + wxCHECK_RET( sb, _T("this window is not scrollable") ); // This check is more than an optimization. Without it, the slider // will not move smoothly while tracking when using wxScrollHelper. if (GetScrollPos(orient) != pos) { - const int dir = ScrollDirFromOrient(orient); - GtkAdjustment* adj = m_scrollBar[dir]->adjustment; + GtkAdjustment* adj = sb->adjustment; const int max = int(adj->upper - adj->page_size); if (pos > max) pos = max; if (pos < 0) pos = 0; - m_scrollPos[dir] = - adj->value = pos; - // If a "value_changed" signal emission is not already in progress - if (!m_blockValueChanged[dir]) - { - gtk_adjustment_value_changed(adj); - } + m_scrollPos[dir] = adj->value = pos; + + g_signal_handlers_block_by_func(m_scrollBar[dir], + (gpointer)gtk_scrollbar_value_changed, this); + + gtk_adjustment_value_changed(adj); + + g_signal_handlers_unblock_by_func(m_scrollBar[dir], + (gpointer)gtk_scrollbar_value_changed, this); } } int wxWindowGTK::GetScrollThumb(int orient) const { - wxCHECK_MSG( m_widget != NULL, 0, wxT("invalid window") ); - wxCHECK_MSG( m_wxwindow != NULL, 0, wxT("window needs client area for scrolling") ); + GtkRange * const sb = m_scrollBar[ScrollDirFromOrient(orient)]; + wxCHECK_MSG( sb, 0, _T("this window is not scrollable") ); - return int(m_scrollBar[ScrollDirFromOrient(orient)]->adjustment->page_size); + return int(sb->adjustment->page_size); } int wxWindowGTK::GetScrollPos( int orient ) const { - wxCHECK_MSG( m_widget != NULL, 0, wxT("invalid window") ); - wxCHECK_MSG( m_wxwindow != NULL, 0, wxT("window needs client area for scrolling") ); + GtkRange * const sb = m_scrollBar[ScrollDirFromOrient(orient)]; + wxCHECK_MSG( sb, 0, _T("this window is not scrollable") ); - return int(m_scrollBar[ScrollDirFromOrient(orient)]->adjustment->value + 0.5); + return int(sb->adjustment->value + 0.5); } int wxWindowGTK::GetScrollRange( int orient ) const { - wxCHECK_MSG( m_widget != NULL, 0, wxT("invalid window") ); - wxCHECK_MSG( m_wxwindow != NULL, 0, wxT("window needs client area for scrolling") ); + GtkRange * const sb = m_scrollBar[ScrollDirFromOrient(orient)]; + wxCHECK_MSG( sb, 0, _T("this window is not scrollable") ); - return int(m_scrollBar[ScrollDirFromOrient(orient)]->adjustment->upper); + return int(sb->adjustment->upper); } // Determine if increment is the same as +/-x, allowing for some small @@ -4333,14 +4214,13 @@ wxEventType wxWindowGTK::GetScrollEventType(GtkRange* range) { DEBUG_MAIN_THREAD - if (g_isIdle) - wxapp_install_idle_handler(); - wxASSERT(range == m_scrollBar[0] || range == m_scrollBar[1]); const int barIndex = range == m_scrollBar[1]; GtkAdjustment* adj = range->adjustment; + const int value = int(adj->value + 0.5); + // save previous position const double oldPos = m_scrollPos[barIndex]; // update current position @@ -4383,12 +4263,37 @@ void wxWindowGTK::ScrollWindow( int dx, int dy, const wxRect* WXUNUSED(rect) ) // No scrolling requested. if ((dx == 0) && (dy == 0)) return; - + m_clipPaintRegion = true; - gtk_pizza_scroll( GTK_PIZZA(m_wxwindow), -dx, -dy ); + if (GetLayoutDirection() == wxLayout_RightToLeft) + gtk_pizza_scroll( GTK_PIZZA(m_wxwindow), dx, -dy ); + else + gtk_pizza_scroll( GTK_PIZZA(m_wxwindow), -dx, -dy ); m_clipPaintRegion = false; + +#if wxUSE_CARET + bool restoreCaret = (GetCaret() != NULL && GetCaret()->IsVisible()); + if (restoreCaret) + { + wxRect caretRect(GetCaret()->GetPosition(), GetCaret()->GetSize()); + if (dx > 0) + caretRect.width += dx; + else + { + caretRect.x += dx; caretRect.width -= dx; + } + if (dy > 0) + caretRect.height += dy; + else + { + caretRect.y += dy; caretRect.height -= dy; + } + + RefreshRect(caretRect); + } +#endif // wxUSE_CARET } void wxWindowGTK::GtkScrolledWindowSetBorder(GtkWidget* w, int wxstyle)