#ifndef WX_PRECOMP
#include "wx/log.h"
#include "wx/app.h"
- #include "wx/frame.h"
+ #include "wx/toplevel.h"
#include "wx/dcclient.h"
#include "wx/menu.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/math.h"
#endif
#include "wx/tooltip.h"
#include "wx/caret.h"
#include "wx/fontutil.h"
-
-#ifdef __WXDEBUG__
- #include "wx/thread.h"
-#endif
+#include "wx/sysopt.h"
#include <ctype.h>
-// FIXME: Due to a hack we use GtkCombo in here, which is deprecated since gtk2.3.0
-#include <gtk/gtkversion.h>
-#if defined(GTK_DISABLE_DEPRECATED) && GTK_CHECK_VERSION(2,3,0)
- #undef GTK_DISABLE_DEPRECATED
- #include <gtk/gtkcombo.h>
- #define GTK_DISABLE_DEPRECATED
-#endif
-
#include "wx/gtk/private.h"
-#include "wx/gtk/win_gtk.h"
+#include "wx/gtk/private/win_gtk.h"
#include <gdk/gdkkeysyms.h>
#include <gdk/gdkx.h>
can find in m_widget (defined in wxWindow)
When the class has a client area for drawing into and for containing children
- it has to handle the client area widget (of the type GtkPizza, defined in
- win_gtk.c), but there could be any number of widgets, handled by a class
+ it has to handle the client area widget (of the type wxPizza, defined in
+ win_gtk.cpp), but there could be any number of widgets, handled by a class.
The common rule for all windows is only, that the widget that interacts with
the rest of GTK must be referenced in m_widget and all other widgets must be
children of this widget on the GTK level. The top-most widget, which also
represents the client area, must be in the m_wxwindow field and must be of
- the type GtkPizza.
+ the type wxPizza.
As I said, the window classes that display a GTK native widget only have
one widget, so in the case of e.g. the wxButton class m_widget holds a
pointer to a GtkButton widget. But windows with client areas (for drawing
and children) have a m_widget field that is a pointer to a GtkScrolled-
- Window and a m_wxwindow field that is pointer to a GtkPizza and this
+ Window and a m_wxwindow field that is pointer to a wxPizza and this
one is (in the GTK sense) a child of the GtkScrolledWindow.
If the m_wxwindow field is set, then all input to this widget is inter-
clicking on a scrollbar belonging to scrolled window will inevitably move
the window. In wxWidgets, the scrollbar will only emit an event, send this
to (normally) a wxScrolledWindow and that class will call ScrollWindow()
- which actually moves the window and its sub-windows. Note that GtkPizza
+ which actually moves the window and its sub-windows. Note that wxPizza
memorizes how much it has been scrolled but that wxWidgets forgets this
so that the two coordinates systems have to be kept in synch. This is done
- in various places using the pizza->xoffset and pizza->yoffset values.
+ in various places using the pizza->m_scroll_x and pizza->m_scroll_y values.
III)
static wxWindowGTK *g_captureWindow = (wxWindowGTK*) NULL;
static bool g_captureWindowHasMouse = false;
-wxWindowGTK *g_focusWindow = (wxWindowGTK*) NULL;
+// The window that currently has focus or is scheduled to get it in the next
+// event loop iteration
+static wxWindowGTK *gs_focusWindow = 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
-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;
+// the window that has deferred focus-out event pending, if any (see
+// GTKAddDeferredFocusOut() for details)
+static wxWindowGTK *gs_deferredFocusOut = 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;
-
//-----------------------------------------------------------------------------
// debug
//-----------------------------------------------------------------------------
-#ifdef __WXDEBUG__
-
-#if wxUSE_THREADS
-# define DEBUG_MAIN_THREAD if (wxThread::IsMain() && g_mainThreadLocked) printf("gui reentrance");
-#else
-# define DEBUG_MAIN_THREAD
-#endif
-#else
-#define DEBUG_MAIN_THREAD
-#endif // Debug
-
// the trace mask used for the focus debugging messages
#define TRACE_FOCUS _T("focus")
}
}
-//-----------------------------------------------------------------------------
-// local code (see below)
-//-----------------------------------------------------------------------------
-
-// returns the child of win which currently has focus or NULL if not found
-//
-// Note: can't be static, needed by textctrl.cpp.
-wxWindow *wxFindFocusedChild(wxWindowGTK *win)
-{
- wxWindow *winFocus = wxWindowGTK::FindFocus();
- if ( !winFocus )
- return (wxWindow *)NULL;
-
- if ( winFocus == win )
- return (wxWindow *)win;
-
- for ( wxWindowList::compatibility_iterator node = win->GetChildren().GetFirst();
- node;
- node = node->GetNext() )
- {
- wxWindow *child = wxFindFocusedChild(node->GetData());
- if ( child )
- return child;
- }
-
- return (wxWindow *)NULL;
-}
-
-static void GetScrollbarWidth(GtkWidget* widget, int& w, int& h)
-{
- GtkScrolledWindow* scroll_window = GTK_SCROLLED_WINDOW(widget);
- GtkScrolledWindowClass* scroll_class = GTK_SCROLLED_WINDOW_CLASS(GTK_OBJECT_GET_CLASS(scroll_window));
- GtkRequisition scroll_req;
-
- w = 0;
- if (scroll_window->vscrollbar_visible)
- {
- scroll_req.width = 2;
- scroll_req.height = 2;
- (* GTK_WIDGET_CLASS( GTK_OBJECT_GET_CLASS(scroll_window->vscrollbar) )->size_request )
- (scroll_window->vscrollbar, &scroll_req );
- w = scroll_req.width +
- scroll_class->scrollbar_spacing;
- }
-
- h = 0;
- if (scroll_window->hscrollbar_visible)
- {
- scroll_req.width = 2;
- scroll_req.height = 2;
- (* GTK_WIDGET_CLASS( GTK_OBJECT_GET_CLASS(scroll_window->hscrollbar) )->size_request )
- (scroll_window->hscrollbar, &scroll_req );
- h = scroll_req.height +
- scroll_class->scrollbar_spacing;
- }
-}
-
-static void draw_frame( GtkWidget *widget, wxWindowGTK *win )
-{
- // wxUniversal widgets draw the borders and scrollbars themselves
-#ifndef __WXUNIVERSAL__
- if (!win->m_hasVMT)
- return;
-
- int dx = 0;
- int dy = 0;
- if (GTK_WIDGET_NO_WINDOW (widget))
- {
- dx += widget->allocation.x;
- 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,
- widget->window,
- GTK_STATE_NORMAL,
- GTK_SHADOW_OUT,
- NULL, NULL, NULL, // FIXME: No clipping?
- x, y, w, h );
- return;
- }
-
- if (win->HasFlag(wxSUNKEN_BORDER))
- {
- gtk_paint_shadow (widget->style,
- widget->window,
- GTK_STATE_NORMAL,
- GTK_SHADOW_IN,
- NULL, NULL, NULL, // FIXME: No clipping?
- x, y, w, h );
- return;
- }
-
- if (win->HasFlag(wxSIMPLE_BORDER))
- {
- GdkGC *gc;
- gc = gdk_gc_new( widget->window );
- gdk_gc_set_foreground( gc, &widget->style->black );
- gdk_draw_rectangle( widget->window, gc, FALSE, x, y, w-1, h-1 );
- g_object_unref (gc);
- return;
- }
-#endif // __WXUNIVERSAL__
-}
-
-//-----------------------------------------------------------------------------
-// "expose_event" of m_widget
-//-----------------------------------------------------------------------------
-
-extern "C" {
-static gboolean
-gtk_window_own_expose_callback( GtkWidget *widget,
- GdkEventExpose *gdk_event,
- wxWindowGTK *win )
-{
- if (gdk_event->count == 0)
- draw_frame(widget, win);
- return false;
-}
-}
//-----------------------------------------------------------------------------
// "size_request" of m_widget
// make it extern because wxStaticText needs to disconnect this one
extern "C" {
-void wxgtk_window_size_request_callback(GtkWidget *widget,
+void wxgtk_window_size_request_callback(GtkWidget * WXUNUSED(widget),
GtkRequisition *requisition,
- wxWindow *win)
+ wxWindow * win)
{
int w, h;
win->GetSize( &w, &h );
}
}
-#if wxUSE_COMBOBOX
-
-extern "C" {
-static
-void wxgtk_combo_size_request_callback(GtkWidget *widget,
- GtkRequisition *requisition,
- wxComboBox *win)
-{
- // This callback is actually hooked into the text entry
- // of the combo box, not the GtkHBox.
-
- int w, h;
- win->GetSize( &w, &h );
- if (w < 2)
- w = 2;
- if (h < 2)
- h = 2;
-
- GtkCombo *gcombo = GTK_COMBO(win->m_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, &button_req );
-
- requisition->width = w - button_req.width;
- requisition->height = entry_req.height;
-}
-}
-
-#endif // wxUSE_COMBOBOX
-
//-----------------------------------------------------------------------------
// "expose_event" of m_wxwindow
//-----------------------------------------------------------------------------
extern "C" {
static gboolean
-gtk_window_expose_callback( GtkWidget *widget,
+gtk_window_expose_callback( GtkWidget*,
GdkEventExpose *gdk_event,
wxWindow *win )
{
- DEBUG_MAIN_THREAD
-
- // 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)
- {
- // block expose events on GTK_WIDGET(pizza)->window,
- // all drawing is done on pizza->bin_window
- return true;
- }
-
-
#if 0
if (win->GetName())
{
}
}
+//-----------------------------------------------------------------------------
+// "expose_event" from m_widget, for drawing border
+//-----------------------------------------------------------------------------
+
+#ifndef __WXUNIVERSAL__
+
+GtkWidget* GetEntryWidget();
+
+extern "C" {
+static gboolean
+expose_event_border(GtkWidget* widget, GdkEventExpose* gdk_event, wxWindow* win)
+{
+ // if this event is not for the GdkWindow the border is drawn on
+ if (win->m_wxwindow == win->m_widget && gdk_event->window == widget->window)
+ return false;
+
+ int x = 0;
+ int y = 0;
+ // GtkScrolledWindow is GTK_NO_WINDOW
+ if (GTK_WIDGET_NO_WINDOW(widget))
+ {
+ x = widget->allocation.x;
+ y = widget->allocation.y;
+ }
+ int w = win->m_wxwindow->allocation.width;
+ int h = win->m_wxwindow->allocation.height;
+ if (win->HasFlag(wxBORDER_SIMPLE))
+ {
+ GdkGC* gc = gdk_gc_new(gdk_event->window);
+ gdk_gc_set_foreground(gc, &widget->style->black);
+ gdk_draw_rectangle(gdk_event->window, gc, false, x, y, w - 1, h - 1);
+ g_object_unref(gc);
+ }
+ else
+ {
+ GtkShadowType shadow = GTK_SHADOW_IN;
+ if (win->HasFlag(wxBORDER_RAISED))
+ shadow = GTK_SHADOW_OUT;
+
+ // Style detail to use
+ const char* detail;
+ if (widget == win->m_wxwindow)
+ // for non-scrollable wxWindows
+ detail = "entry";
+ else
+ // for scrollable ones
+ detail = "viewport";
+
+ GtkWidget* styleWidget = GetEntryWidget();
+ gtk_paint_shadow(
+ styleWidget->style, gdk_event->window, GTK_STATE_NORMAL,
+ shadow, NULL, styleWidget, detail, x, y, w, h);
+ }
+
+ // no further painting is needed for border-only GdkWindow
+ return win->m_wxwindow == win->m_widget;
+}
+}
+#endif // !__WXUNIVERSAL__
+
//-----------------------------------------------------------------------------
// "key_press_event" from any window
//-----------------------------------------------------------------------------
GdkEventKey *gdk_event,
wxWindow *win )
{
- DEBUG_MAIN_THREAD
-
if (!win->m_hasVMT)
return FALSE;
if (g_blockEventsOnDrag)
return FALSE;
+ // GTK+ sends keypress events to the focus widget and then
+ // to all its parent and grandparent widget. We only want
+ // the key events from the focus widget.
+ if (!GTK_WIDGET_HAS_FOCUS(widget))
+ return FALSE;
wxKeyEvent event( wxEVT_KEY_DOWN );
bool ret = false;
if( wxTranslateGTKKeyEventToWx(event, win, gdk_event) )
{
// Emit KEY_DOWN event
- ret = win->GetEventHandler()->ProcessEvent( event );
+ ret = win->HandleWindowEvent( event );
}
else
{
return_after_IM = true;
}
- // 2005.01.26 modified by Hong Jen Yee (hzysoft@sina.com.tw):
- // When we get a key_press event here, it could be originate
- // from the current widget or its child widgets. However, only the widget
- // with the INPUT FOCUS can generate the INITIAL key_press event. That is,
- // if the CURRENT widget doesn't have the FOCUS at all, this event definitely
- // originated from its child widgets and shouldn't be passed to IM context.
- // In fact, what a GTK+ IM should do is filtering keyEvents and convert them
- // into text input ONLY WHEN THE WIDGET HAS INPUT FOCUS. Besides, when current
- // widgets has both IM context and input focus, the event should be filtered
- // by gtk_im_context_filter_keypress().
- // Then, we should, according to GTK+ 2.0 API doc, return whatever it returns.
- if ((!ret) && (win->m_imData != NULL) && ( wxWindow::FindFocus() == win ))
+ if ((!ret) && (win->m_imData != NULL))
{
// We should let GTK+ IM filter key event first. According to GTK+ 2.0 API
// docs, if IM filter returns true, no further processing should be done.
if (command != -1)
{
wxCommandEvent command_event( wxEVT_COMMAND_MENU_SELECTED, command );
- ret = ancestor->GetEventHandler()->ProcessEvent( command_event );
+ ret = ancestor->HandleWindowEvent( command_event );
break;
}
if (ancestor->IsTopLevel())
if (parent)
{
event.SetEventType( wxEVT_CHAR_HOOK );
- ret = parent->GetEventHandler()->ProcessEvent( event );
+ ret = parent->HandleWindowEvent( event );
}
if (!ret)
{
event.SetEventType(wxEVT_CHAR);
- ret = win->GetEventHandler()->ProcessEvent( event );
+ ret = win->HandleWindowEvent( event );
}
}
}
extern "C" {
static void
-gtk_wxwindow_commit_cb (GtkIMContext *context,
+gtk_wxwindow_commit_cb (GtkIMContext * WXUNUSED(context),
const gchar *str,
wxWindow *window)
{
if (parent)
{
event.SetEventType( wxEVT_CHAR_HOOK );
- ret = parent->GetEventHandler()->ProcessEvent( event );
+ ret = parent->HandleWindowEvent( event );
}
if (!ret)
{
event.SetEventType(wxEVT_CHAR);
- ret = window->GetEventHandler()->ProcessEvent( event );
+ ret = window->HandleWindowEvent( event );
}
}
}
extern "C" {
static gboolean
-gtk_window_key_release_callback( GtkWidget *widget,
+gtk_window_key_release_callback( GtkWidget * WXUNUSED(widget),
GdkEventKey *gdk_event,
wxWindowGTK *win )
{
- DEBUG_MAIN_THREAD
-
if (!win->m_hasVMT)
return FALSE;
if ((win->m_wxwindow) && (win->GetLayoutDirection() == wxLayout_RightToLeft))
{
// origin in the upper right corner
- int window_width = gtk_pizza_get_rtl_offset( GTK_PIZZA(win->m_wxwindow) );
+ int window_width = win->m_wxwindow->allocation.width;
event.m_x = window_width - event.m_x;
}
if (win->m_wxwindow)
{
- GtkPizza *pizza = GTK_PIZZA(win->m_wxwindow);
- xx += gtk_pizza_get_xoffset( pizza );
- yy += gtk_pizza_get_yoffset( pizza );
+ wxPizza* pizza = WX_PIZZA(win->m_wxwindow);
+ xx += pizza->m_scroll_x;
+ yy += pizza->m_scroll_y;
}
wxWindowList::compatibility_iterator node = win->GetChildren().GetFirst();
bool wxWindowGTK::GTKProcessEvent(wxEvent& event) const
{
// nothing special at this level
- return GetEventHandler()->ProcessEvent(event);
+ return HandleWindowEvent(event);
}
int wxWindowGTK::GTKCallbackCommonPrologue(GdkEventAny *event) const
{
- DEBUG_MAIN_THREAD
-
if (!m_hasVMT)
return FALSE;
if (g_blockEventsOnDrag)
if ( rc != -1 ) \
return rc
-// send the wxChildFocusEvent and wxFocusEvent, common code of
-// gtk_window_focus_in_callback() and SetFocus()
-static bool DoSendFocusEvents(wxWindow *win)
-{
- // Notify the parent keeping track of focus for the kbd navigation
- // purposes that we got it.
- wxChildFocusEvent eventChildFocus(win);
- (void)win->GetEventHandler()->ProcessEvent(eventChildFocus);
-
- wxFocusEvent eventFocus(wxEVT_SET_FOCUS, win->GetId());
- eventFocus.SetEventObject(win);
-
- return win->GetEventHandler()->ProcessEvent(eventFocus);
-}
-
// all event handlers must have C linkage as they're called from GTK+ C code
extern "C"
{
wxEventType event_type = wxEVT_NULL;
- // GdkDisplay is a GTK+ 2.2.0 thing
-#if defined(__WXGTK20__) && GTK_CHECK_VERSION(2, 2, 0)
if ( gdk_event->type == GDK_2BUTTON_PRESS &&
- !gtk_check_version(2,2,0) &&
gdk_event->button >= 1 && gdk_event->button <= 3 )
{
// Reset GDK internal timestamp variables in order to disable GDK
display->button_click_time[1] = 0;
display->button_click_time[0] = 0;
}
-#endif // GTK 2+
if (gdk_event->button == 1)
{
if ( ret )
return TRUE;
- if ((event_type == wxEVT_LEFT_DOWN) && !win->IsOfStandardClass() &&
- (g_focusWindow != win) /* && win->IsFocusable() */)
+ if ((event_type == wxEVT_LEFT_DOWN) && !win->IsOfStandardClass() &&
+ (gs_focusWindow != win) /* && win->IsFocusable() */)
{
win->SetFocus();
}
//-----------------------------------------------------------------------------
static gboolean
-gtk_window_motion_notify_callback( GtkWidget *widget,
+gtk_window_motion_notify_callback( GtkWidget * WXUNUSED(widget),
GdkEventMotion *gdk_event,
wxWindowGTK *win )
{
static gboolean
window_scroll_event(GtkWidget*, GdkEventScroll* gdk_event, wxWindow* win)
{
- DEBUG_MAIN_THREAD
-
if (gdk_event->direction != GDK_SCROLL_UP &&
gdk_event->direction != GDK_SCROLL_DOWN)
{
wxMouseEvent event(wxEVT_MOUSEWHEEL);
InitMouseEvent(win, event, gdk_event);
+
+ // FIXME: Get these values from GTK or GDK
event.m_linesPerAction = 3;
event.m_wheelDelta = 120;
if (gdk_event->direction == GDK_SCROLL_UP)
//-----------------------------------------------------------------------------
static gboolean
-gtk_window_focus_in_callback( GtkWidget *widget,
+gtk_window_focus_in_callback( GtkWidget * WXUNUSED(widget),
GdkEventFocus *WXUNUSED(event),
- wxWindow *win )
+ wxWindowGTK *win )
{
- DEBUG_MAIN_THREAD
-
- if (win->m_imData)
- gtk_im_context_focus_in(win->m_imData->context);
-
- g_focusWindowLast =
- g_focusWindow = win;
-
- wxLogTrace(TRACE_FOCUS,
- _T("%s: focus in"), win->GetName().c_str());
-
-#if wxUSE_CARET
- // caret needs to be informed about focus change
- wxCaret *caret = win->GetCaret();
- if ( caret )
- {
- caret->OnSetFocus();
- }
-#endif // wxUSE_CARET
-
- gboolean ret = FALSE;
-
- // does the window itself think that it has the focus?
- if ( !win->m_hasFocus )
- {
- // not yet, notify it
- win->m_hasFocus = true;
-
- (void)DoSendFocusEvents(win);
-
- ret = TRUE;
- }
-
- // Disable default focus handling for custom windows
- // since the default GTK+ handler issues a repaint
- if (win->m_wxwindow)
- return ret;
-
- return FALSE;
+ return win->GTKHandleFocusIn();
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
static gboolean
-gtk_window_focus_out_callback( GtkWidget *widget,
- GdkEventFocus *gdk_event,
+gtk_window_focus_out_callback( GtkWidget * WXUNUSED(widget),
+ GdkEventFocus * WXUNUSED(gdk_event),
wxWindowGTK *win )
{
- DEBUG_MAIN_THREAD
-
- if (win->m_imData)
- gtk_im_context_focus_out(win->m_imData->context);
-
- wxLogTrace( TRACE_FOCUS,
- _T("%s: focus out"), win->GetName().c_str() );
-
-
- wxWindowGTK *winFocus = wxFindFocusedChild(win);
- if ( winFocus )
- win = winFocus;
-
- g_focusWindow = (wxWindowGTK *)NULL;
-
-#if wxUSE_CARET
- // caret needs to be informed about focus change
- wxCaret *caret = win->GetCaret();
- if ( caret )
- {
- caret->OnKillFocus();
- }
-#endif // wxUSE_CARET
-
- // 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() );
- event.SetEventObject( win );
-
- (void)win->GTKProcessEvent( event );
-
- // Disable default focus handling for custom windows
- // since the default GTK+ handler issues a repaint
- if ( has_wxwindow )
- {
- return TRUE;
- }
- }
-
- // continue with normal processing
- return FALSE;
+ return win->GTKHandleFocusOut();
}
+//-----------------------------------------------------------------------------
+// "focus"
+//-----------------------------------------------------------------------------
+
static gboolean
wx_window_focus_callback(GtkWidget *widget,
- GtkDirectionType direction,
+ GtkDirectionType WXUNUSED(direction),
wxWindowGTK *win)
{
- // the default handler for focus signal in GtkPizza (or, rather, in
- // GtkScrolledWindow from which GtkPizza inherits this behaviour) sets
+ // the default handler for focus signal in GtkScrolledWindow 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
static gboolean
gtk_scrollbar_button_press_event(GtkRange*, GdkEventButton*, wxWindow* win)
{
- DEBUG_MAIN_THREAD
-
g_blockEventsOnScroll = true;
win->m_mouseButtonDown = true;
const int orient = wxWindow::OrientFromScrollDir(
win->ScrollDirFromRange(range));
- wxScrollWinEvent event(wxEVT_SCROLLWIN_THUMBRELEASE, win->GetScrollPos(orient), orient);
- event.SetEventObject(win);
- win->GTKProcessEvent(event);
+ wxScrollWinEvent evt(wxEVT_SCROLLWIN_THUMBRELEASE,
+ win->GetScrollPos(orient), orient);
+ evt.SetEventObject(win);
+ win->GTKProcessEvent(evt);
}
}
static gboolean
gtk_scrollbar_button_release_event(GtkRange* range, GdkEventButton*, wxWindow* win)
{
- DEBUG_MAIN_THREAD
-
g_blockEventsOnScroll = false;
win->m_mouseButtonDown = false;
// If thumb tracking
//-----------------------------------------------------------------------------
static void
-gtk_window_realized_callback( GtkWidget *m_widget, wxWindow *win )
+gtk_window_realized_callback(GtkWidget* widget, wxWindow* win)
{
- DEBUG_MAIN_THREAD
-
if (win->m_imData)
{
- GtkPizza *pizza = GTK_PIZZA( m_widget );
gtk_im_context_set_client_window( win->m_imData->context,
- pizza->bin_window );
+ widget->window);
}
// We cannot set colours and fonts before the widget
}
//-----------------------------------------------------------------------------
-// "size_allocate"
+// "size_allocate" from m_wxwindow or m_widget
//-----------------------------------------------------------------------------
-static
-void gtk_window_size_callback( GtkWidget *WXUNUSED(widget),
- GtkAllocation *alloc,
- wxWindow *win )
+static void
+size_allocate(GtkWidget*, GtkAllocation* alloc, wxWindow* win)
{
- 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 ( !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;
-
- if (!win->m_nativeSizeEvent)
+ int w = alloc->width;
+ int h = alloc->height;
+ if (win->m_wxwindow)
{
- wxSizeEvent event( win->GetSize(), win->GetId() );
- event.SetEventObject( win );
- win->GTKProcessEvent( event );
+ int border_x, border_y;
+ WX_PIZZA(win->m_wxwindow)->get_border_widths(border_x, border_y);
+ w -= 2 * border_x;
+ h -= 2 * border_y;
+ if (w < 0) w = 0;
+ if (h < 0) h = 0;
+ }
+ if (win->m_oldClientWidth != w || win->m_oldClientHeight != h)
+ {
+ win->m_oldClientWidth = w;
+ win->m_oldClientHeight = h;
+ // this callback can be connected to m_wxwindow,
+ // so always get size from m_widget->allocation
+ win->m_width = win->m_widget->allocation.width;
+ win->m_height = win->m_widget->allocation.height;
+ if (!win->m_nativeSizeEvent)
+ {
+ wxSizeEvent event(win->GetSize(), win->GetId());
+ event.SetEventObject(win);
+ win->GTKProcessEvent(event);
+ }
}
}
//-----------------------------------------------------------------------------
-// "grab_broken"
+// "grab_broken"
//-----------------------------------------------------------------------------
-#ifdef __WXGTK210__
-static void
-gtk_window_grab_broken( GtkWidget *m_widget,
+#if GTK_CHECK_VERSION(2, 8, 0)
+static gboolean
+gtk_window_grab_broken( GtkWidget*,
GdkEventGrabBroken *event,
wxWindow *win )
{
// Mouse capture has been lost involuntarily, notify the application
- if( !event->keyboard && win && wxWindow::GetCapture() == win )
+ if(!event->keyboard && wxWindow::GetCapture() == win)
{
wxMouseCaptureLostEvent evt( win->GetId() );
evt.SetEventObject( win );
- win->GetEventHandler()->ProcessEvent( evt );
+ win->HandleWindowEvent( evt );
}
+ return false;
}
#endif
+//-----------------------------------------------------------------------------
+// "style_set"
+//-----------------------------------------------------------------------------
+
+static
+void gtk_window_style_set_callback( GtkWidget *WXUNUSED(widget),
+ GtkStyle *previous_style,
+ wxWindow* win )
+{
+ if (win && previous_style)
+ {
+ wxSysColourChangedEvent event;
+ event.SetEventObject(win);
+
+ win->GTKProcessEvent( event );
+ }
+}
} // extern "C"
+// Helper to suspend colour change event event processing while we change a widget's style
+class wxSuspendStyleEvents
+{
+public:
+ wxSuspendStyleEvents(wxWindow* win)
+ {
+ m_win = NULL;
+ if (win->m_wxwindow && win->IsTopLevel())
+ {
+ m_win = win;
+ g_signal_handlers_block_by_func(
+ m_win->m_wxwindow, (void*)gtk_window_style_set_callback, m_win);
+ }
+ }
+ ~wxSuspendStyleEvents()
+ {
+ if (m_win)
+ g_signal_handlers_unblock_by_func(
+ m_win->m_wxwindow, (void*)gtk_window_style_set_callback, m_win);
+ }
+
+ wxWindow* m_win;
+};
+
// ----------------------------------------------------------------------------
// this wxWindowBase function is implemented here (in platform-specific file)
// because it is static and so couldn't be made virtual
wxWindow *wxWindowBase::DoFindFocus()
{
// the cast is necessary when we compile in wxUniversal mode
- return (wxWindow *)g_focusWindow;
+ return wx_static_cast(wxWindow*, gs_focusWindow);
}
//-----------------------------------------------------------------------------
{
/* the window might have been scrolled already, do we
have to adapt the position */
- GtkPizza *pizza = GTK_PIZZA(parent->m_wxwindow);
- child->m_x += gtk_pizza_get_xoffset( pizza );
- child->m_y += gtk_pizza_get_yoffset( pizza );
+ wxPizza* pizza = WX_PIZZA(parent->m_wxwindow);
+ child->m_x += pizza->m_scroll_x;
+ child->m_y += pizza->m_scroll_y;
- gtk_pizza_put( GTK_PIZZA(parent->m_wxwindow),
- child->m_widget,
- child->m_x,
- child->m_y,
- child->m_width,
- child->m_height );
+ gtk_widget_set_size_request(
+ child->m_widget, child->m_width, child->m_height);
+ gtk_fixed_put(
+ GTK_FIXED(parent->m_wxwindow), child->m_widget, child->m_x, child->m_y);
}
//-----------------------------------------------------------------------------
m_noExpose = false;
m_nativeSizeEvent = false;
- m_hasScrolling = false;
m_isScrolling = false;
m_mouseButtonDown = false;
m_oldClientWidth =
m_oldClientHeight = 0;
- m_resizing = false;
-
m_insertCallback = wxInsertChildInWindow;
- m_hasFocus = false;
-
m_clipPaintRegion = false;
m_needsStyleChange = false;
long style,
const wxString &name )
{
+ // Get default border
+ wxBorder border = GetBorder(style);
+ style &= ~wxBORDER_MASK;
+ style |= border;
+
if (!PreCreation( parent, pos, size ) ||
!CreateBase( parent, id, pos, size, style, wxDefaultValidator, name ))
{
return false;
}
- if (!HasFlag(wxHSCROLL) && !HasFlag(wxVSCROLL))
- {
- m_wxwindow = gtk_pizza_new_no_scroll();
-
-#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__
+ m_wxwindow = wxPizza::New(m_windowStyle);
+ if (!HasFlag(wxHSCROLL) && !HasFlag(wxVSCROLL))
m_widget = m_wxwindow;
- }
else
{
- m_wxwindow = gtk_pizza_new();
-
-#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__
-
m_widget = gtk_scrolled_window_new( (GtkAdjustment *) NULL, (GtkAdjustment *) NULL );
GtkScrolledWindow *scrolledWindow = GTK_SCROLLED_WINDOW(m_widget);
{
SendDestroyEvent();
- if (g_focusWindow == this)
- g_focusWindow = NULL;
+ if (gs_focusWindow == this)
+ gs_focusWindow = NULL;
- if ( g_delayedFocus == this )
- g_delayedFocus = NULL;
+ if ( gs_deferredFocusOut == this )
+ gs_deferredFocusOut = NULL;
m_isBeingDeleted = true;
m_hasVMT = false;
G_CALLBACK (gtk_window_expose_callback), this);
if (GetLayoutDirection() == wxLayout_LeftToRight)
- gtk_widget_set_redraw_on_allocate( GTK_WIDGET(m_wxwindow), HasFlag( wxFULL_REPAINT_ON_RESIZE ) );
+ gtk_widget_set_redraw_on_allocate(m_wxwindow, HasFlag(wxFULL_REPAINT_ON_RESIZE));
}
// Create input method handler
g_signal_connect (m_imData->context, "commit",
G_CALLBACK (gtk_wxwindow_commit_cb), this);
- // these are called when the "sunken" or "raised" borders are drawn
- g_signal_connect (m_widget, "expose_event",
- G_CALLBACK (gtk_window_own_expose_callback), this);
+ // border drawing
+#ifndef __WXUNIVERSAL__
+ if (HasFlag(wxPizza::BORDER_STYLES))
+ {
+ g_signal_connect(m_widget, "expose_event",
+ G_CALLBACK(expose_event_border), this);
+ }
+#endif
}
// focus handling
g_signal_connect (connect_widget, "realize",
G_CALLBACK (gtk_window_realized_callback), this);
+ if (!IsTopLevel())
+ {
+ g_signal_connect(m_wxwindow ? m_wxwindow : m_widget, "size_allocate",
+ G_CALLBACK(size_allocate), this);
+ }
+
if (m_wxwindow)
{
- // Catch native resize events
- g_signal_connect (m_wxwindow, "size_allocate",
- G_CALLBACK (gtk_window_size_callback), this);
-#ifdef __WXGTK210__
+#if GTK_CHECK_VERSION(2, 8, 0)
if (!gtk_check_version(2,8,0))
{
// Make sure we can notify the app when mouse capture is lost
if ( connect_widget != m_wxwindow )
{
-#ifdef __WXGTK210__
+#if GTK_CHECK_VERSION(2, 8, 0)
if (!gtk_check_version(2,8,0))
{
// Make sure we can notify app code when mouse capture is lost
#endif
}
-#if wxUSE_COMBOBOX
- if (GTK_IS_COMBO(m_widget))
- {
- GtkCombo *gcombo = GTK_COMBO(m_widget);
-
- 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
if (!gtk_check_version(2,6,0) && GTK_IS_FILE_CHOOSER_BUTTON(m_widget))
{
G_CALLBACK (gtk_window_enter_callback), this);
g_signal_connect (widget, "leave_notify_event",
G_CALLBACK (gtk_window_leave_callback), this);
+
+ if (IsTopLevel() && m_wxwindow)
+ g_signal_connect (m_wxwindow, "style_set",
+ G_CALLBACK (gtk_window_style_set_callback), this);
}
bool wxWindowGTK::Destroy()
void wxWindowGTK::DoMoveWindow(int x, int y, int width, int height)
{
+ gtk_widget_set_size_request(m_widget, width, height);
// inform the parent to perform the move
- gtk_pizza_set_size( GTK_PIZZA(m_parent->m_wxwindow), m_widget, x, y, width, height );
-
+ WX_PIZZA(m_parent->m_wxwindow)->move(m_widget, x, y);
}
void wxWindowGTK::ConstrainSize()
wxASSERT_MSG( (m_widget != NULL), wxT("invalid window") );
wxASSERT_MSG( (m_parent != NULL), wxT("wxWindowGTK::SetSize requires parent.\n") );
- if (m_resizing) return; /* I don't like recursions */
- m_resizing = true;
-
int currentX, currentY;
GetPosition(¤tX, ¤tY);
if (x == -1 && !(sizeFlags & wxSIZE_ALLOW_MINUS_ONE))
height = sizeBest.y;
}
+ const wxSize oldSize(m_width, m_height);
if (width != -1)
m_width = width;
if (height != -1)
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 = m_widget;
- gtk_widget_set_size_request (widget, m_width, m_height);
- }
- else
-#endif
- if (m_parent->m_wxwindow == NULL) // i.e. wxNotebook
+ if (m_parent->m_wxwindow)
{
- // don't set the size for children of wxNotebook, just take the values.
- m_x = x;
- m_y = y;
- m_width = width;
- m_height = height;
- }
- else
- {
- GtkPizza *pizza = GTK_PIZZA(m_parent->m_wxwindow);
- if ((sizeFlags & wxSIZE_ALLOW_MINUS_ONE) == 0)
- {
- if (x != -1) m_x = x + gtk_pizza_get_xoffset( pizza );
- if (y != -1) m_y = y + gtk_pizza_get_yoffset( pizza );
- }
- else
- {
- m_x = x + gtk_pizza_get_xoffset( pizza );
- m_y = y + gtk_pizza_get_yoffset( pizza );
- }
+ wxPizza* pizza = WX_PIZZA(m_parent->m_wxwindow);
+ m_x = x + pizza->m_scroll_x;
+ m_y = y + pizza->m_scroll_y;
int left_border = 0;
int right_border = 0;
m_height+top_border+bottom_border );
}
- if (m_hasScrolling)
+ if (m_width != oldSize.x || m_height != oldSize.y)
{
- /* Sometimes the client area changes size without the
- whole windows's size changing, but if the whole
- windows's size doesn't change, no wxSizeEvent will
- normally be sent. Here we add an extra test if
- the client test has been changed and this will
- be used then. */
+ // update these variables to keep size_allocate handler
+ // from sending another size event for this change
GetClientSize( &m_oldClientWidth, &m_oldClientHeight );
- }
-/*
- wxPrintf( "OnSize sent from " );
- if (GetClassInfo() && GetClassInfo()->GetClassName())
- wxPrintf( GetClassInfo()->GetClassName() );
- wxPrintf( " %d %d %d %d\n", (int)m_x, (int)m_y, (int)m_width, (int)m_height );
-*/
-
- if (!m_nativeSizeEvent)
- {
- wxSizeEvent event( wxSize(m_width,m_height), GetId() );
- event.SetEventObject( this );
- GetEventHandler()->ProcessEvent( event );
+ gtk_widget_queue_resize(m_widget);
+ if (!m_nativeSizeEvent)
+ {
+ wxSizeEvent event( wxSize(m_width,m_height), GetId() );
+ event.SetEventObject( this );
+ HandleWindowEvent( event );
+ }
}
-
- m_resizing = false;
}
bool wxWindowGTK::GtkShowFromOnIdle()
gtk_widget_show( m_widget );
wxShowEvent eventShow(GetId(), true);
eventShow.SetEventObject(this);
- GetEventHandler()->ProcessEvent(eventShow);
+ HandleWindowEvent(eventShow);
m_showOnIdle = false;
return true;
}
void wxWindowGTK::OnInternalIdle()
{
+ if ( gs_deferredFocusOut )
+ GTKHandleDeferredFocusOut();
+
// Check if we have to show window now
if (GtkShowFromOnIdle()) return;
if (m_wxwindow && (m_wxwindow != m_widget))
{
- GdkWindow *window = GTK_PIZZA(m_wxwindow)->bin_window;
+ GdkWindow *window = m_wxwindow->window;
if (window)
gdk_window_set_cursor( window, cursor.GetCursor() );
}
}
- if (wxUpdateUIEvent::CanUpdate(this))
+ if (wxUpdateUIEvent::CanUpdate(this) && IsShownOnScreen())
UpdateWindowUI(wxUPDATE_UI_FROMIDLE);
}
if (m_wxwindow)
{
- int dw = 0;
- int dh = 0;
-
- if (m_hasScrolling)
- GetScrollbarWidth(m_widget, dw, dh);
+ // if window is scrollable, account for scrollbars
+ for (int i = 0; i < 2 && m_scrollBar[i]; i++)
+ {
+ GtkRequisition req;
+ GtkAdjustment* adj = gtk_range_get_adjustment(m_scrollBar[i]);
+ // if scrollbar enabled
+ if (adj->upper > adj->page_size)
+ {
+ gtk_widget_size_request(GTK_WIDGET(m_scrollBar[i]), &req);
+ if (i == ScrollDir_Horz)
+ h -= req.height;
+ else
+ w -= req.width;
+ }
+ }
- const int border = GTK_CONTAINER(m_wxwindow)->border_width;
- dw += 2 * border;
- dh += 2 * border;
+ int border_x, border_y;
+ WX_PIZZA(m_wxwindow)->get_border_widths(border_x, border_y);
+ w -= 2 * border_x;
+ h -= 2 * border_y;
- w -= dw;
- h -= dh;
if (w < 0)
w = 0;
if (h < 0)
int dx = 0;
int dy = 0;
- if (m_parent && m_parent->m_wxwindow)
+ if (!IsTopLevel() && m_parent && m_parent->m_wxwindow)
{
- GtkPizza *pizza = GTK_PIZZA(m_parent->m_wxwindow);
- dx = gtk_pizza_get_xoffset( pizza );
- dy = gtk_pizza_get_yoffset( pizza );
+ wxPizza* pizza = WX_PIZZA(m_parent->m_wxwindow);
+ dx = pizza->m_scroll_x;
+ dy = pizza->m_scroll_y;
}
if (m_x == -1 && m_y == -1)
{
GdkWindow *source = (GdkWindow *) NULL;
if (m_wxwindow)
- source = GTK_PIZZA(m_wxwindow)->bin_window;
+ source = m_wxwindow->window;
else
source = m_widget->window;
GdkWindow *source = (GdkWindow *) NULL;
if (m_wxwindow)
- source = GTK_PIZZA(m_wxwindow)->bin_window;
+ source = m_wxwindow->window;
else
source = m_widget->window;
GdkWindow *source = (GdkWindow *) NULL;
if (m_wxwindow)
- source = GTK_PIZZA(m_wxwindow)->bin_window;
+ source = m_wxwindow->window;
else
source = m_widget->window;
return false;
}
- if (show)
+ if (show && m_showOnIdle)
{
- if (!m_showOnIdle)
- {
- gtk_widget_show( m_widget );
- wxShowEvent eventShow(GetId(), show);
- eventShow.SetEventObject(this);
- GetEventHandler()->ProcessEvent(eventShow);
- }
+ // deferred
}
else
{
- gtk_widget_hide( m_widget );
+ if (show)
+ gtk_widget_show(m_widget);
+ else
+ gtk_widget_hide(m_widget);
wxShowEvent eventShow(GetId(), show);
eventShow.SetEventObject(this);
- GetEventHandler()->ProcessEvent(eventShow);
+ HandleWindowEvent(eventShow);
}
return true;
wxFont font = GetFont();
wxCHECK_MSG( font.Ok(), 12, wxT("invalid font") );
- PangoContext *context = NULL;
- if (m_widget)
- context = gtk_widget_get_pango_context( m_widget );
+ PangoContext* context = gtk_widget_get_pango_context(m_widget);
if (!context)
return 0;
wxFont font = GetFont();
wxCHECK_MSG( font.Ok(), 8, wxT("invalid font") );
- PangoContext *context = NULL;
- if (m_widget)
- context = gtk_widget_get_pango_context( m_widget );
+ PangoContext* context = gtk_widget_get_pango_context(m_widget);
if (!context)
return 0;
g_object_unref (layout);
}
-bool wxWindowGTK::GTKSetDelayedFocusIfNeeded()
+
+bool wxWindowGTK::GTKHandleFocusIn()
{
- if ( g_delayedFocus == this )
+ // Disable default focus handling for custom windows since the default GTK+
+ // handler issues a repaint
+ const bool retval = m_wxwindow ? true : false;
+
+
+ // NB: if there's still unprocessed deferred focus-out event (see
+ // GTKHandleFocusOut() for explanation), we need to process it first so
+ // that the order of focus events -- focus-out first, then focus-in
+ // elsewhere -- is preserved
+ if ( gs_deferredFocusOut )
{
- if ( GTK_WIDGET_REALIZED(m_widget) )
+ if ( GTKNeedsToFilterSameWindowFocus() &&
+ gs_deferredFocusOut == this )
{
- gtk_widget_grab_focus(m_widget);
- g_delayedFocus = NULL;
-
- return true;
+ // GTK+ focus changed from this wxWindow back to itself, so don't
+ // emit any events at all
+ wxLogTrace(TRACE_FOCUS,
+ "filtered out spurious focus change within %s(%p, %s)",
+ GetClassInfo()->GetClassName(), this, GetLabel());
+ gs_deferredFocusOut = NULL;
+ return retval;
}
+
+ // otherwise we need to send focus-out first
+ wxASSERT_MSG ( gs_deferredFocusOut != this,
+ "GTKHandleFocusIn(GTKFocus_Normal) called even though focus changed back to itself - derived class should handle this" );
+ GTKHandleDeferredFocusOut();
}
- return false;
+
+ wxLogTrace(TRACE_FOCUS,
+ "handling focus_in event for %s(%p, %s)",
+ GetClassInfo()->GetClassName(), this, GetLabel());
+
+ if (m_imData)
+ gtk_im_context_focus_in(m_imData->context);
+
+ // NB: SetFocus() does this assignment too, but not all focus changes
+ // originate from SetFocus() call
+ gs_focusWindow = this;
+
+#if wxUSE_CARET
+ // caret needs to be informed about focus change
+ wxCaret *caret = GetCaret();
+ if ( caret )
+ {
+ caret->OnSetFocus();
+ }
+#endif // wxUSE_CARET
+
+ // Notify the parent keeping track of focus for the kbd navigation
+ // purposes that we got it.
+ wxChildFocusEvent eventChildFocus(this);
+ GTKProcessEvent(eventChildFocus);
+
+ wxFocusEvent eventFocus(wxEVT_SET_FOCUS, GetId());
+ eventFocus.SetEventObject(this);
+ GTKProcessEvent(eventFocus);
+
+ return retval;
}
-void wxWindowGTK::SetFocus()
+bool wxWindowGTK::GTKHandleFocusOut()
{
- wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
- if ( m_hasFocus )
+ // Disable default focus handling for custom windows since the default GTK+
+ // handler issues a repaint
+ const bool retval = m_wxwindow ? true : false;
+
+
+ // NB: If a control is composed of several GtkWidgets and when focus
+ // changes from one of them to another within the same wxWindow, we get
+ // a focus-out event followed by focus-in for another GtkWidget owned
+ // by the same wx control. We don't want to generate two spurious
+ // wxEVT_SET_FOCUS events in this case, so we defer sending wx events
+ // from GTKHandleFocusOut() until we know for sure it's not coming back
+ // (i.e. in GTKHandleFocusIn() or at idle time).
+ if ( GTKNeedsToFilterSameWindowFocus() )
{
- // don't do anything if we already have focus
- return;
+ wxASSERT_MSG( gs_deferredFocusOut == NULL,
+ "deferred focus out event already pending" );
+ wxLogTrace(TRACE_FOCUS,
+ "deferring focus_out event for %s(%p, %s)",
+ GetClassInfo()->GetClassName(), this, GetLabel());
+ gs_deferredFocusOut = this;
+ return retval;
}
- if (m_wxwindow)
+ GTKHandleFocusOutNoDeferring();
+
+ return retval;
+}
+
+void wxWindowGTK::GTKHandleFocusOutNoDeferring()
+{
+ wxLogTrace(TRACE_FOCUS,
+ "handling focus_out event for %s(%p, %s)",
+ GetClassInfo()->GetClassName(), this, GetLabel());
+
+ if (m_imData)
+ gtk_im_context_focus_out(m_imData->context);
+
+ if ( gs_focusWindow != this )
{
- if (!GTK_WIDGET_HAS_FOCUS (m_wxwindow))
- {
- gtk_widget_grab_focus (m_wxwindow);
- }
+ // Something is terribly wrong, gs_focusWindow is out of sync with the
+ // real focus. We will reset it to NULL anyway, because after this
+ // focus-out event is handled, one of the following with happen:
+ //
+ // * either focus will go out of the app altogether, in which case
+ // gs_focusWindow _should_ be NULL
+ //
+ // * or it goes to another control, in which case focus-in event will
+ // follow immediately and it will set gs_focusWindow to the right
+ // value
+ wxLogDebug("window %s(%p, %s) lost focus even though it didn't have it",
+ GetClassInfo()->GetClassName(), this, GetLabel());
}
- else if (m_widget)
+ gs_focusWindow = NULL;
+
+#if wxUSE_CARET
+ // caret needs to be informed about focus change
+ wxCaret *caret = GetCaret();
+ if ( caret )
{
- if (GTK_IS_CONTAINER(m_widget))
- {
-#if wxUSE_RADIOBTN
- if (IsKindOf(CLASSINFO(wxRadioButton)))
- {
- gtk_widget_grab_focus (m_widget);
- return;
- }
-#endif // wxUSE_RADIOBTN
+ caret->OnKillFocus();
+ }
+#endif // wxUSE_CARET
- gtk_widget_child_focus( m_widget, GTK_DIR_TAB_FORWARD );
- }
- else
- if (GTK_WIDGET_CAN_FOCUS(m_widget) && !GTK_WIDGET_HAS_FOCUS (m_widget) )
- {
+ wxFocusEvent event( wxEVT_KILL_FOCUS, GetId() );
+ event.SetEventObject( this );
+ GTKProcessEvent( event );
+}
- if (!GTK_WIDGET_REALIZED(m_widget))
- {
- // we can't set the focus to the widget now so we remember that
- // it should be focused and will do it later, during the idle
- // time, as soon as we can
- wxLogTrace(TRACE_FOCUS,
- _T("Delaying setting focus to %s(%s)"),
- GetClassInfo()->GetClassName(), GetLabel().c_str());
-
- g_delayedFocus = this;
- }
- else
- {
- wxLogTrace(TRACE_FOCUS,
- _T("Setting focus to %s(%s)"),
- GetClassInfo()->GetClassName(), GetLabel().c_str());
+/*static*/
+void wxWindowGTK::GTKHandleDeferredFocusOut()
+{
+ // NB: See GTKHandleFocusOut() for explanation. This function is called
+ // from either GTKHandleFocusIn() or OnInternalIdle() to process
+ // deferred event.
+ if ( gs_deferredFocusOut )
+ {
+ wxWindowGTK *win = gs_deferredFocusOut;
+ gs_deferredFocusOut = NULL;
- gtk_widget_grab_focus (m_widget);
- }
- }
- else
- {
- wxLogTrace(TRACE_FOCUS,
- _T("Can't set focus to %s(%s)"),
- GetClassInfo()->GetClassName(), GetLabel().c_str());
- }
+ wxLogTrace(TRACE_FOCUS,
+ "processing deferred focus_out event for %s(%p, %s)",
+ win->GetClassInfo()->GetClassName(), win, win->GetLabel());
+
+ win->GTKHandleFocusOutNoDeferring();
+ }
+}
+
+void wxWindowGTK::SetFocus()
+{
+ wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
+
+ // Setting "physical" focus is not immediate in GTK+ and while
+ // gtk_widget_is_focus ("determines if the widget is the focus widget
+ // within its toplevel", i.e. returns true for one widget per TLW, not
+ // globally) returns true immediately after grabbing focus,
+ // GTK_WIDGET_HAS_FOCUS (which returns true only for the one widget that
+ // has focus at the moment) takes affect only after the window is shown
+ // (if it was hidden at the moment of the call) or at the next event loop
+ // iteration.
+ //
+ // Because we want to FindFocus() call immediately following
+ // foo->SetFocus() to return foo, we have to keep track of "pending" focus
+ // ourselves.
+ gs_focusWindow = this;
+
+ GtkWidget *widget = m_wxwindow ? m_wxwindow : m_focusWidget;
+
+ if ( GTK_IS_CONTAINER(widget) &&
+ !GTK_WIDGET_CAN_FOCUS(widget) )
+ {
+ wxLogTrace(TRACE_FOCUS,
+ _T("Setting focus to a child of %s(%p, %s)"),
+ GetClassInfo()->GetClassName(), this, GetLabel().c_str());
+ gtk_widget_child_focus(widget, GTK_DIR_TAB_FORWARD);
+ }
+ else
+ {
+ wxLogTrace(TRACE_FOCUS,
+ _T("Setting focus to %s(%p, %s)"),
+ GetClassInfo()->GetClassName(), this, GetLabel().c_str());
+ gtk_widget_grab_focus(widget);
}
}
wxCoord WXUNUSED(width),
wxCoord WXUNUSED(widthTotal)) const
{
- // We now mirrors the coordinates of RTL windows in GtkPizza
+ // We now mirror the coordinates of RTL windows in wxPizza
return x;
}
-void wxWindowGTK::DoMoveInTabOrder(wxWindow *win, MoveKind move)
+void wxWindowGTK::DoMoveInTabOrder(wxWindow *win, WindowOrder move)
{
wxWindowBase::DoMoveInTabOrder(win, move);
m_dirtyTabOrder = true;
GdkWindow *window = (GdkWindow*) NULL;
if (m_wxwindow)
- window = GTK_PIZZA(m_wxwindow)->bin_window;
+ window = m_wxwindow->window;
else
window = GetConnectWidget()->window;
return DoScrollByUnits(ScrollDir_Vert, ScrollUnit_Page, pages);
}
-void wxWindowGTK::Refresh( bool eraseBackground, const wxRect *rect )
+void wxWindowGTK::Refresh(bool WXUNUSED(eraseBackground),
+ const wxRect *rect)
{
if (!m_widget)
return;
if (m_wxwindow)
{
- if (!GTK_PIZZA(m_wxwindow)->bin_window) return;
+ if (m_wxwindow->window == NULL) return;
GdkRectangle gdk_rect,
*p;
p = NULL;
}
- gdk_window_invalidate_rect( GTK_PIZZA(m_wxwindow)->bin_window, p, TRUE );
+ gdk_window_invalidate_rect(m_wxwindow->window, p, true);
}
}
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_wxwindow && m_wxwindow->window)
+ gdk_window_process_updates(m_wxwindow->window, false);
if (m_widget && m_widget->window && (m_wxwindow != m_widget))
gdk_window_process_updates( m_widget->window, FALSE );
m_updateRegion.Clear();
gint width;
- gdk_window_get_geometry( GTK_PIZZA(m_wxwindow)->bin_window,
- NULL, NULL, &width, NULL, NULL );
+ gdk_drawable_get_size(m_wxwindow->window, &width, NULL);
wxRegionIterator upd( m_nativeUpdateRegion );
while (upd)
}
}
- // widget to draw on
- GtkPizza *pizza = GTK_PIZZA (m_wxwindow);
-
if (GetThemeEnabled() && (GetBackgroundStyle() == wxBG_STYLE_SYSTEM))
{
// find ancestor from which to steal background
rect.height = upd.GetHeight();
gtk_paint_flat_box( parent->m_widget->style,
- pizza->bin_window,
+ m_wxwindow->window,
(GtkStateType)GTK_WIDGET_STATE(m_wxwindow),
GTK_SHADOW_NONE,
&rect,
wxWindowDC dc( (wxWindow*)this );
dc.SetClippingRegion( m_updateRegion );
+ // Work around gtk-qt <= 0.60 bug whereby the window colour
+ // remains grey
+ if (GetBackgroundStyle() == wxBG_STYLE_COLOUR && GetBackgroundColour().Ok() && wxSystemOptions::GetOptionInt(wxT("gtk.window.force-background-colour")) == 1)
+ {
+ dc.SetBackground(wxBrush(GetBackgroundColour()));
+ dc.Clear();
+ }
+
wxEraseEvent erase_event( GetId(), &dc );
erase_event.SetEventObject( this );
- GetEventHandler()->ProcessEvent(erase_event);
+ HandleWindowEvent(erase_event);
}
wxNcPaintEvent nc_paint_event( GetId() );
nc_paint_event.SetEventObject( this );
- GetEventHandler()->ProcessEvent( nc_paint_event );
+ HandleWindowEvent( nc_paint_event );
wxPaintEvent paint_event( GetId() );
paint_event.SetEventObject( this );
- GetEventHandler()->ProcessEvent( paint_event );
+ HandleWindowEvent( paint_event );
m_clipPaintRegion = false;
void wxWindowGTK::DoApplyWidgetStyle(GtkRcStyle *style)
{
+ wxSuspendStyleEvents s(static_cast<wxWindow*>(this));
+
if (m_wxwindow)
gtk_widget_modify_style(m_wxwindow, style);
else
GdkWindow *window;
if ( m_wxwindow )
{
- window = GTK_PIZZA(m_wxwindow)->bin_window;
+ window = m_wxwindow->window;
}
else
{
GdkWindow *wxWindowGTK::GTKGetWindow(wxArrayGdkWindows& WXUNUSED(windows)) const
{
- return m_wxwindow ? GTK_PIZZA(m_wxwindow)->bin_window : m_widget->window;
+ return m_wxwindow ? m_wxwindow->window : m_widget->window;
}
bool wxWindowGTK::SetFont( const wxFont &font )
GdkWindow *window = (GdkWindow*) NULL;
if (m_wxwindow)
- window = GTK_PIZZA(m_wxwindow)->bin_window;
+ window = m_wxwindow->window;
else
window = GetConnectWidget()->window;
GdkWindow *window = (GdkWindow*) NULL;
if (m_wxwindow)
- window = GTK_PIZZA(m_wxwindow)->bin_window;
+ window = m_wxwindow->window;
else
window = GetConnectWidget()->window;
DoReleaseMouse();
wxMouseCaptureLostEvent evt(GetId());
evt.SetEventObject( this );
- GetEventHandler()->ProcessEvent( evt );
+ HandleWindowEvent( evt );
}
/* static */
int range,
bool WXUNUSED(update))
{
- GtkRange * const sb = m_scrollBar[ScrollDirFromOrient(orient)];
+ const int dir = ScrollDirFromOrient(orient);
+ GtkRange* const sb = m_scrollBar[dir];
wxCHECK_RET( sb, _T("this window is not scrollable") );
- if (range > 0)
- {
- m_hasScrolling = true;
- }
- else
+ if (range <= 0)
{
// GtkRange requires upper > lower
range =
thumbVisible = 1;
}
- if (pos > range - thumbVisible)
- pos = range - thumbVisible;
- if (pos < 0)
- pos = 0;
GtkAdjustment * const adj = sb->adjustment;
adj->step_increment = 1;
adj->page_increment =
adj->page_size = thumbVisible;
- adj->upper = range;
- SetScrollPos(orient, pos);
- gtk_adjustment_changed(adj);
+ adj->value = pos;
+
+ g_signal_handlers_block_by_func(
+ sb, (void*)gtk_scrollbar_value_changed, this);
+
+ gtk_range_set_range(sb, 0, range);
+ m_scrollPos[dir] = sb->adjustment->value;
+
+ g_signal_handlers_unblock_by_func(
+ sb, (void*)gtk_scrollbar_value_changed, this);
}
void wxWindowGTK::SetScrollPos(int orient, int pos, bool WXUNUSED(refresh))
// will not move smoothly while tracking when using wxScrollHelper.
if (GetScrollPos(orient) != pos)
{
- 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;
-
- g_signal_handlers_block_by_func(m_scrollBar[dir],
- (gpointer)gtk_scrollbar_value_changed, this);
+ g_signal_handlers_block_by_func(
+ sb, (void*)gtk_scrollbar_value_changed, this);
- gtk_adjustment_value_changed(adj);
+ gtk_range_set_value(sb, pos);
+ m_scrollPos[dir] = sb->adjustment->value;
- g_signal_handlers_unblock_by_func(m_scrollBar[dir],
- (gpointer)gtk_scrollbar_value_changed, this);
+ g_signal_handlers_unblock_by_func(
+ sb, (void*)gtk_scrollbar_value_changed, this);
}
}
wxEventType wxWindowGTK::GetScrollEventType(GtkRange* range)
{
- DEBUG_MAIN_THREAD
-
wxASSERT(range == m_scrollBar[0] || range == m_scrollBar[1]);
const int barIndex = range == m_scrollBar[1];
// No scrolling requested.
if ((dx == 0) && (dy == 0)) return;
-
+
m_clipPaintRegion = true;
- if (GetLayoutDirection() == wxLayout_RightToLeft)
- gtk_pizza_scroll( GTK_PIZZA(m_wxwindow), dx, -dy );
- else
- gtk_pizza_scroll( GTK_PIZZA(m_wxwindow), -dx, -dy );
+ WX_PIZZA(m_wxwindow)->scroll(dx, dy);
m_clipPaintRegion = false;
gtkstyle = GTK_SHADOW_OUT;
else if (wxstyle & wxBORDER_SUNKEN)
gtkstyle = GTK_SHADOW_IN;
+#if 0
+ // Now obsolete
else if (wxstyle & wxBORDER_DOUBLE)
gtkstyle = GTK_SHADOW_ETCHED_IN;
+#endif
else //default
gtkstyle = GTK_SHADOW_IN;
}
-// Needed for implementing e.g. combobox on wxGTK within a modal dialog.
-void wxAddGrab(wxWindow* window)
+GdkWindow* wxWindowGTK::GTKGetDrawingWindow() const
+{
+ GdkWindow* window = NULL;
+ if (m_wxwindow)
+ window = m_wxwindow->window;
+ return window;
+}
+
+// ----------------------------------------------------------------------------
+// freeze/thaw
+// ----------------------------------------------------------------------------
+
+void wxWindowGTK::GTKFreezeWidget(GtkWidget *w)
+{
+ if ( w && !GTK_WIDGET_NO_WINDOW(w) )
+ gdk_window_freeze_updates(w->window);
+}
+
+void wxWindowGTK::GTKThawWidget(GtkWidget *w)
+{
+ if ( w && !GTK_WIDGET_NO_WINDOW(w) )
+ gdk_window_thaw_updates(w->window);
+}
+
+void wxWindowGTK::DoFreeze()
{
- gtk_grab_add( (GtkWidget*) window->GetHandle() );
+ GTKFreezeWidget(m_widget);
+ if ( m_wxwindow && m_widget != m_wxwindow )
+ GTKFreezeWidget(m_wxwindow);
}
-void wxRemoveGrab(wxWindow* window)
+void wxWindowGTK::DoThaw()
{
- gtk_grab_remove( (GtkWidget*) window->GetHandle() );
+ GTKThawWidget(m_widget);
+ if ( m_wxwindow && m_widget != m_wxwindow )
+ GTKThawWidget(m_wxwindow);
}
projects / wxWidgets.git / blobdiff