// Name: src/gtk/window.cpp
// Purpose: wxWindowGTK implementation
// Author: Robert Roebling
-// Id: $Id$
// Copyright: (c) 1998 Robert Roebling, Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#include "wx/gtk/private/gtk2-compat.h"
#include "wx/gtk/private/event.h"
#include "wx/gtk/private/win_gtk.h"
+#include "wx/private/textmeasure.h"
using namespace wxGTKImpl;
#ifdef GDK_WINDOWING_X11
KeySym keysym = gdk_event->keyval;
- wxLogTrace(TRACE_KEYS, wxT("Key %s event: keysym = %ld"),
+ wxLogTrace(TRACE_KEYS, wxT("Key %s event: keysym = %lu"),
event.GetEventType() == wxEVT_KEY_UP ? wxT("release")
: wxT("press"),
- keysym);
+ static_cast<unsigned long>(keysym));
long key_code = wxTranslateKeySymToWXKey(keysym, false /* !isChar */);
event.m_keyCode = key_code;
#if wxUSE_UNICODE
- event.m_uniChar = gdk_keyval_to_unicode(key_code ? key_code : keysym);
+ event.m_uniChar = gdk_keyval_to_unicode(key_code);
if ( !event.m_uniChar && event.m_keyCode <= WXK_DELETE )
{
// Set Unicode key code to the ASCII equivalent for compatibility. E.g.
}
-struct wxGtkIMData
-{
- GtkIMContext *context;
- GdkEventKey *lastKeyEvent;
-
- wxGtkIMData()
- {
- context = gtk_im_multicontext_new();
- lastKeyEvent = NULL;
- }
- ~wxGtkIMData()
- {
- g_object_unref (context);
- }
-};
-
namespace
{
int command = ancestor->GetAcceleratorTable()->GetCommand( event );
if (command != -1)
{
- wxCommandEvent menu_event( wxEVT_COMMAND_MENU_SELECTED, command );
+ wxCommandEvent menu_event( wxEVT_MENU, command );
ret = ancestor->HandleWindowEvent( menu_event );
if ( !ret )
// if the accelerator wasn't handled as menu event, try
// it as button click (for compatibility with other
// platforms):
- wxCommandEvent button_event( wxEVT_COMMAND_BUTTON_CLICKED, command );
+ wxCommandEvent button_event( wxEVT_BUTTON, command );
ret = ancestor->HandleWindowEvent( button_event );
}
return_after_IM = true;
}
- if (!ret && win->m_imData)
+ if ( !ret )
{
- win->m_imData->lastKeyEvent = gdk_event;
+ // Indicate that IM handling is in process by setting this pointer
+ // (which will remain valid for all the code called during IM key
+ // handling).
+ win->m_imKeyEvent = gdk_event;
// 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.
// we should send the key_down event anyway.
- bool intercepted_by_IM =
- gtk_im_context_filter_keypress(win->m_imData->context, gdk_event) != 0;
- win->m_imData->lastKeyEvent = NULL;
- if (intercepted_by_IM)
+ const int intercepted_by_IM = win->GTKIMFilterKeypress(gdk_event);
+
+ win->m_imKeyEvent = NULL;
+
+ if ( intercepted_by_IM )
{
wxLogTrace(TRACE_KEYS, wxT("Key event intercepted by IM"));
return TRUE;
}
}
+int wxWindowGTK::GTKIMFilterKeypress(GdkEventKey* event) const
+{
+ return m_imContext ? gtk_im_context_filter_keypress(m_imContext, event)
+ : FALSE;
+}
+
extern "C" {
static void
gtk_wxwindow_commit_cb (GtkIMContext * WXUNUSED(context),
const gchar *str,
wxWindow *window)
+{
+ // Ignore the return value here, it doesn't matter for the "commit" signal.
+ window->GTKDoInsertTextFromIM(str);
+}
+}
+
+bool wxWindowGTK::GTKDoInsertTextFromIM(const char* str)
{
wxKeyEvent event( wxEVT_CHAR );
// take modifiers, cursor position, timestamp etc. from the last
// key_press_event that was fed into Input Method:
- if (window->m_imData->lastKeyEvent)
+ if ( m_imKeyEvent )
{
- wxFillOtherKeyEventFields(event,
- window, window->m_imData->lastKeyEvent);
+ wxFillOtherKeyEventFields(event, this, m_imKeyEvent);
}
else
{
- event.SetEventObject( window );
+ event.SetEventObject(this);
}
const wxString data(wxGTK_CONV_BACK_SYS(str));
if( data.empty() )
- return;
+ return false;
+ bool processed = false;
for( wxString::const_iterator pstr = data.begin(); pstr != data.end(); ++pstr )
{
#if wxUSE_UNICODE
AdjustCharEventKeyCodes(event);
- window->HandleWindowEvent(event);
+ if ( HandleWindowEvent(event) )
+ processed = true;
}
+
+ return processed;
}
+
+bool wxWindowGTK::GTKOnInsertText(const char* text)
+{
+ if ( !m_imKeyEvent )
+ {
+ // We're not inside IM key handling at all.
+ return false;
+ }
+
+ return GTKDoInsertTextFromIM(text);
}
{
int x = 0;
int y = 0;
- GdkModifierType state;
- gdk_window_get_pointer(gdk_event->window, &x, &y, &state);
+#ifdef __WXGTK3__
+ gdk_window_get_device_position(gdk_event->window, gdk_event->device, &x, &y, NULL);
+#else
+ gdk_window_get_pointer(gdk_event->window, &x, &y, NULL);
+#endif
gdk_event->x = x;
gdk_event->y = y;
}
if ( g_captureWindow )
{
// synthesise a mouse enter or leave event if needed
- GdkWindow *winUnderMouse = gdk_window_at_pointer(NULL, NULL);
+ GdkWindow* winUnderMouse =
+#ifdef __WXGTK3__
+ gdk_device_get_window_at_position(gdk_event->device, NULL, NULL);
+#else
+ gdk_window_at_pointer(NULL, NULL);
+#endif
// This seems to be necessary and actually been added to
// GDK itself in version 2.0.X
gdk_flush();
// FIXME: Get these values from GTK or GDK
event.m_linesPerAction = 3;
+ event.m_columnsPerAction = 3;
event.m_wheelDelta = 120;
// Determine the scroll direction.
case GDK_SCROLL_LEFT:
event.m_wheelRotation = -120;
break;
-
+#if GTK_CHECK_VERSION(3,4,0)
+ case GDK_SCROLL_SMOOTH:
+ // TODO
+#endif
default:
return false; // Unknown/unhandled direction
}
case GDK_SCROLL_RIGHT:
event.m_wheelAxis = wxMOUSE_WHEEL_HORIZONTAL;
break;
+#if GTK_CHECK_VERSION(3,4,0)
+ case GDK_SCROLL_SMOOTH:
+ // TODO
+ break;
+#endif
}
if (win->GTKProcessEvent(event))
return TRUE;
- GtkRange *range = win->m_scrollBar[wxWindow::ScrollDir_Vert];
+ GtkRange *range;
+ switch (gdk_event->direction)
+ {
+ case GDK_SCROLL_UP:
+ case GDK_SCROLL_DOWN:
+ range = win->m_scrollBar[wxWindow::ScrollDir_Vert];
+ break;
+
+ case GDK_SCROLL_LEFT:
+ case GDK_SCROLL_RIGHT:
+ range = win->m_scrollBar[wxWindow::ScrollDir_Horz];
+ break;
+
+ default:
+ return false;
+ }
if (range && gtk_widget_get_visible(GTK_WIDGET(range)))
{
GtkAdjustment* adj = gtk_range_get_adjustment(range);
double delta = gtk_adjustment_get_step_increment(adj) * 3;
- if (gdk_event->direction == GDK_SCROLL_UP)
+ if (gdk_event->direction == GDK_SCROLL_UP ||
+ gdk_event->direction == GDK_SCROLL_LEFT)
delta = -delta;
gtk_range_set_value(range, gtk_adjustment_get_value(adj) + delta);
//-----------------------------------------------------------------------------
static gboolean
-gtk_window_enter_callback( GtkWidget *widget,
+gtk_window_enter_callback( GtkWidget*,
GdkEventCrossing *gdk_event,
wxWindowGTK *win )
{
// Event was emitted after a grab
if (gdk_event->mode != GDK_CROSSING_NORMAL) return FALSE;
- int x = 0;
- int y = 0;
- GdkModifierType state = (GdkModifierType)0;
-
- gdk_window_get_pointer(gtk_widget_get_window(widget), &x, &y, &state);
-
wxMouseEvent event( wxEVT_ENTER_WINDOW );
InitMouseEvent(win, event, gdk_event);
- wxPoint pt = win->GetClientAreaOrigin();
- event.m_x = x + pt.x;
- event.m_y = y + pt.y;
if ( !g_captureWindow )
{
//-----------------------------------------------------------------------------
static gboolean
-gtk_window_leave_callback( GtkWidget *widget,
+gtk_window_leave_callback( GtkWidget*,
GdkEventCrossing *gdk_event,
wxWindowGTK *win )
{
if (gdk_event->mode != GDK_CROSSING_NORMAL) return FALSE;
wxMouseEvent event( wxEVT_LEAVE_WINDOW );
-
- int x = 0;
- int y = 0;
- GdkModifierType state = (GdkModifierType)0;
-
- gdk_window_get_pointer(gtk_widget_get_window(widget), &x, &y, &state);
-
InitMouseEvent(win, event, gdk_event);
return win->GTKProcessEvent(event);
if (w < 0) w = 0;
if (h < 0) h = 0;
}
- if (win->m_oldClientWidth != w || win->m_oldClientHeight != h)
+ GtkAllocation a;
+ gtk_widget_get_allocation(win->m_widget, &a);
+ // update position for widgets in native containers, such as wxToolBar
+ if (!WX_IS_PIZZA(gtk_widget_get_parent(win->m_widget)))
{
- win->m_oldClientWidth = w;
- win->m_oldClientHeight = h;
+ win->m_x = a.x;
+ win->m_y = a.y;
+ }
+ win->m_useCachedClientSize = true;
+ if (win->m_clientWidth != w || win->m_clientHeight != h)
+ {
+ win->m_clientWidth = w;
+ win->m_clientHeight = h;
// this callback can be connected to m_wxwindow,
// so always get size from m_widget->allocation
- GtkAllocation a;
- gtk_widget_get_allocation(win->m_widget, &a);
win->m_width = a.width;
win->m_height = a.height;
if (!win->m_nativeSizeEvent)
static void style_updated(GtkWidget*, GtkStyle*, wxWindow* win)
#endif
{
- if (win->IsTopLevel())
- {
- wxSysColourChangedEvent event;
- event.SetEventObject(win);
- win->GTKProcessEvent(event);
- }
- else
- {
- // Border width could change, which will change client size.
- // Make sure size event occurs for this
- win->m_oldClientWidth = 0;
- }
+ wxSysColourChangedEvent event;
+ event.SetEventObject(win);
+ win->GTKProcessEvent(event);
}
//-----------------------------------------------------------------------------
if (IsFrozen())
DoFreeze();
- if (m_imData)
+ GdkWindow* const window = GTKGetDrawingWindow();
+
+ if (m_imContext)
{
gtk_im_context_set_client_window
(
- m_imData->context,
- m_wxwindow ? GTKGetDrawingWindow()
+ m_imContext,
+ window ? window
: gtk_widget_get_window(m_widget)
);
}
#if wxGTK_HAS_COMPOSITING_SUPPORT
if (IsTransparentBackgroundSupported())
{
- GdkWindow* const window = GTKGetDrawingWindow();
if (window)
gdk_window_set_composited(window, true);
}
}
}
-
- // We cannot set colours and fonts before the widget
- // been realized, so we do this directly after realization
- // or otherwise in idle time
-
- if (m_needsStyleChange)
+#ifndef __WXGTK3__
+ if (window && (
+ m_backgroundStyle == wxBG_STYLE_PAINT ||
+ m_backgroundStyle == wxBG_STYLE_TRANSPARENT))
{
- SetBackgroundStyle(GetBackgroundStyle());
- m_needsStyleChange = false;
+ gdk_window_set_back_pixmap(window, NULL, false);
}
+#endif
wxWindowCreateEvent event(static_cast<wxWindow*>(this));
event.SetEventObject( this );
GTKUpdateCursor(true, false);
- if (m_wxwindow &&
- (IsTopLevel() || HasFlag(wxBORDER_RAISED | wxBORDER_SUNKEN | wxBORDER_THEME)))
+ if (m_wxwindow && IsTopLevel())
{
// attaching to style changed signal after realization avoids initial
// changes we don't care about
if (m_wxwindow)
{
- if (m_imData)
- gtk_im_context_set_client_window(m_imData->context, NULL);
+ if (m_imContext)
+ gtk_im_context_set_client_window(m_imContext, NULL);
- g_signal_handlers_disconnect_by_func(
- m_wxwindow, (void*)style_updated, this);
+ if (IsTopLevel())
+ {
+ g_signal_handlers_disconnect_by_func(
+ m_wxwindow, (void*)style_updated, this);
+ }
}
}
wxWindow *wxWindowBase::DoFindFocus()
{
+#if wxUSE_MENUS
// For compatibility with wxMSW, pretend that showing a popup menu doesn't
// change the focus and that it remains on the window showing it, even
// though the real focus does change in GTK.
extern wxMenu *wxCurrentPopupMenu;
if ( wxCurrentPopupMenu )
return wxCurrentPopupMenu->GetInvokingWindow();
+#endif // wxUSE_MENUS
wxWindowGTK *focus = gs_pendingFocus ? gs_pendingFocus : gs_currentFocus;
// the cast is necessary when we compile in wxUniversal mode
}
#endif // __WINDOWS__
-static void GetMouseState(int& x, int& y, GdkModifierType& mask)
+static GdkDisplay* GetDisplay()
{
wxWindow* tlw = NULL;
if (!wxTopLevelWindows.empty())
display = gtk_widget_get_display(tlw->m_widget);
else
display = gdk_display_get_default();
- gdk_display_get_pointer(display, NULL, &x, &y, &mask);
+ return display;
}
wxMouseState wxGetMouseState()
gint y;
GdkModifierType mask;
- GetMouseState(x, y, mask);
+ GdkDisplay* display = GetDisplay();
+#ifdef __WXGTK3__
+ GdkDeviceManager* manager = gdk_display_get_device_manager(display);
+ GdkDevice* device = gdk_device_manager_get_client_pointer(manager);
+ GdkScreen* screen;
+ gdk_device_get_position(device, &screen, &x, &y);
+ GdkWindow* window = gdk_screen_get_root_window(screen);
+ gdk_device_get_state(device, window, NULL, &mask);
+#else
+ gdk_display_get_pointer(display, NULL, &x, &y, &mask);
+#endif
ms.SetX(x);
ms.SetY(y);
m_nativeSizeEvent = false;
#ifdef __WXGTK3__
m_paintContext = NULL;
+ m_styleProvider = NULL;
#endif
m_isScrolling = false;
m_scrollPos[dir] = 0;
}
- m_oldClientWidth =
- m_oldClientHeight = 0;
+ m_clientWidth =
+ m_clientHeight = 0;
+ m_useCachedClientSize = false;
m_clipPaintRegion = false;
- m_needsStyleChange = false;
-
m_cursor = *wxSTANDARD_CURSOR;
- m_imData = NULL;
+ m_imContext = NULL;
+ m_imKeyEvent = NULL;
+
m_dirtyTabOrder = false;
}
}
}
- if (HasFlag(wxALWAYS_SHOW_SB))
- {
- gtk_scrolled_window_set_policy( scrolledWindow, GTK_POLICY_ALWAYS, GTK_POLICY_ALWAYS );
- }
- else
- {
- gtk_scrolled_window_set_policy( scrolledWindow, GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC );
- }
+ // If wx[HV]SCROLL is not given, the corresponding scrollbar is not shown
+ // at all. Otherwise it may be shown only on demand (default) or always, if
+ // the wxALWAYS_SHOW_SB is specified.
+ GtkPolicyType horzPolicy = HasFlag(wxHSCROLL)
+ ? HasFlag(wxALWAYS_SHOW_SB)
+ ? GTK_POLICY_ALWAYS
+ : GTK_POLICY_AUTOMATIC
+ : GTK_POLICY_NEVER;
+ GtkPolicyType vertPolicy = HasFlag(wxVSCROLL)
+ ? HasFlag(wxALWAYS_SHOW_SB)
+ ? GTK_POLICY_ALWAYS
+ : GTK_POLICY_AUTOMATIC
+ : GTK_POLICY_NEVER;
+ gtk_scrolled_window_set_policy( scrolledWindow, horzPolicy, vertPolicy );
m_scrollBar[ScrollDir_Horz] = GTK_RANGE(gtk_scrolled_window_get_hscrollbar(scrolledWindow));
m_scrollBar[ScrollDir_Vert] = GTK_RANGE(gtk_scrolled_window_get_vscrollbar(scrolledWindow));
if ( gs_deferredFocusOut == this )
gs_deferredFocusOut = NULL;
- if (m_widget)
- GTKDisconnect(m_widget);
- if (m_wxwindow && m_wxwindow != m_widget)
+ // Unlike the above cases, which can happen in normal circumstances, a
+ // window shouldn't be destroyed while it still has capture, so even though
+ // we still reset the global pointer to avoid leaving it dangling and
+ // crashing afterwards, also complain about it.
+ if ( g_captureWindow == this )
+ {
+ wxFAIL_MSG( wxS("Destroying window with mouse capture") );
+ g_captureWindow = NULL;
+ }
+
+ if (m_wxwindow)
+ {
GTKDisconnect(m_wxwindow);
+ GtkWidget* parent = gtk_widget_get_parent(m_wxwindow);
+ if (parent)
+ GTKDisconnect(parent);
+ }
+ if (m_widget && m_widget != m_wxwindow)
+ GTKDisconnect(m_widget);
// destroy children before destroying this window itself
DestroyChildren();
- if (m_widget)
- Show( false );
-
// delete before the widgets to avoid a crash on solaris
- delete m_imData;
- m_imData = NULL;
+ if ( m_imContext )
+ {
+ g_object_unref(m_imContext);
+ m_imContext = NULL;
+ }
// avoid problem with GTK+ 2.18 where a frozen window causes the whole
// TLW to be frozen, and if the window is then destroyed, nothing ever
while (IsFrozen())
Thaw();
+#ifdef __WXGTK3__
+ if (m_styleProvider)
+ g_object_unref(m_styleProvider);
+#endif
+
if (m_widget)
{
// Note that gtk_widget_destroy() does not destroy the widget, it just
}
// Create input method handler
- m_imData = new wxGtkIMData;
+ m_imContext = gtk_im_multicontext_new();
// Cannot handle drawing preedited text yet
- gtk_im_context_set_use_preedit( m_imData->context, FALSE );
+ gtk_im_context_set_use_preedit( m_imContext, FALSE );
- g_signal_connect (m_imData->context, "commit",
+ g_signal_connect (m_imContext, "commit",
G_CALLBACK (gtk_wxwindow_commit_cb), this);
}
if (!WX_IS_PIZZA(gtk_widget_get_parent(m_widget)) && !GTK_IS_WINDOW(m_widget))
gtk_widget_set_size_request(m_widget, m_width, m_height);
+ // apply any font or color changes made before creation
+ GTKApplyWidgetStyle();
+
InheritAttributes();
SetLayoutDirection(wxLayout_Default);
height = m_height;
const bool sizeChange = m_width != width || m_height != height;
+
+ if (sizeChange)
+ m_useCachedClientSize = false;
+
if (sizeChange || m_x != x || m_y != y)
{
m_x = x;
{
// update these variables to keep size_allocate handler
// from sending another size event for this change
- GetClientSize( &m_oldClientWidth, &m_oldClientHeight );
+ DoGetClientSize(&m_clientWidth, &m_clientHeight);
wxSizeEvent event( wxSize(m_width,m_height), GetId() );
event.SetEventObject( this );
{
wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
+ if (m_useCachedClientSize)
+ {
+ if (width) *width = m_clientWidth;
+ if (height) *height = m_clientHeight;
+ return;
+ }
+
int w = m_width;
int h = m_height;
gtk_scrolled_window_get_policy(GTK_SCROLLED_WINDOW(m_widget),
&policy[ScrollDir_Horz],
&policy[ScrollDir_Vert]);
- const int scrollbar_spacing =
+
+ // get scrollbar spacing the same way the GTK-private function
+ // _gtk_scrolled_window_get_scrollbar_spacing() does it
+ int scrollbar_spacing =
GTK_SCROLLED_WINDOW_GET_CLASS(m_widget)->scrollbar_spacing;
+ if (scrollbar_spacing < 0)
+ {
+ gtk_widget_style_get(
+ m_widget, "scrollbar-spacing", &scrollbar_spacing, NULL);
+ }
for ( int i = 0; i < ScrollDir_Max; i++ )
{
int *externalLeading,
const wxFont *theFont ) const
{
- wxFont fontToUse = theFont ? *theFont : GetFont();
+ // ensure we work with a valid font
+ wxFont fontToUse;
+ if ( !theFont || !theFont->IsOk() )
+ fontToUse = GetFont();
+ else
+ fontToUse = *theFont;
wxCHECK_RET( fontToUse.IsOk(), wxT("invalid font") );
- if (string.empty())
- {
- if (x) (*x) = 0;
- if (y) (*y) = 0;
- return;
- }
-
- PangoContext *context = NULL;
- if (m_widget)
- context = gtk_widget_get_pango_context( m_widget );
-
- if (!context)
- {
- if (x) (*x) = 0;
- if (y) (*y) = 0;
- return;
- }
-
- PangoFontDescription *desc = fontToUse.GetNativeFontInfo()->description;
- PangoLayout *layout = pango_layout_new(context);
- pango_layout_set_font_description(layout, desc);
- {
- const wxCharBuffer data = wxGTK_CONV( string );
- if ( data )
- pango_layout_set_text(layout, data, strlen(data));
- }
-
- PangoRectangle rect;
- pango_layout_get_extents(layout, NULL, &rect);
-
- if (x) (*x) = (wxCoord) PANGO_PIXELS(rect.width);
- if (y) (*y) = (wxCoord) PANGO_PIXELS(rect.height);
- if (descent)
- {
- PangoLayoutIter *iter = pango_layout_get_iter(layout);
- int baseline = pango_layout_iter_get_baseline(iter);
- pango_layout_iter_free(iter);
- *descent = *y - PANGO_PIXELS(baseline);
- }
- if (externalLeading) (*externalLeading) = 0; // ??
-
- g_object_unref (layout);
+ const wxWindow* win = static_cast<const wxWindow*>(this);
+ wxTextMeasure txm(win, &fontToUse);
+ txm.GetTextExtent(string, x, y, descent, externalLeading);
}
void wxWindowGTK::GTKDisableFocusOutEvent()
"handling focus_in event for %s(%p, %s)",
GetClassInfo()->GetClassName(), this, GetLabel());
- if (m_imData)
- gtk_im_context_focus_in(m_imData->context);
+ if (m_imContext)
+ gtk_im_context_focus_in(m_imContext);
gs_currentFocus = this;
gs_pendingFocus = NULL;
"handling focus_out event for %s(%p, %s)",
GetClassInfo()->GetClassName(), this, GetLabel());
- if (m_imData)
- gtk_im_context_focus_out(m_imData->context);
+ if (m_imContext)
+ gtk_im_context_focus_out(m_imContext);
if ( gs_currentFocus != this )
{
void wxWindowGTK::SetCanFocus(bool canFocus)
{
+ wxCHECK_RET(m_widget, "invalid window");
+
gtk_widget_set_can_focus(m_widget, canFocus);
if ( m_wxwindow && (m_widget != m_wxwindow) )
bool wxWindowGTK::SetBackgroundColour( const wxColour &colour )
{
- wxCHECK_MSG( m_widget != NULL, false, wxT("invalid window") );
-
if (!wxWindowBase::SetBackgroundColour(colour))
return false;
-#ifndef __WXGTK3__
- if (colour.IsOk())
+ if (m_widget)
{
- // We need the pixel value e.g. for background clearing.
- m_backgroundColour.CalcPixel(gtk_widget_get_colormap(m_widget));
- }
+#ifndef __WXGTK3__
+ if (colour.IsOk())
+ {
+ // We need the pixel value e.g. for background clearing.
+ m_backgroundColour.CalcPixel(gtk_widget_get_colormap(m_widget));
+ }
#endif
- // apply style change (forceStyle=true so that new style is applied
- // even if the bg colour changed from valid to wxNullColour)
- GTKApplyWidgetStyle(true);
+ // apply style change (forceStyle=true so that new style is applied
+ // even if the bg colour changed from valid to wxNullColour)
+ GTKApplyWidgetStyle(true);
+ }
return true;
}
bool wxWindowGTK::SetForegroundColour( const wxColour &colour )
{
- wxCHECK_MSG( m_widget != NULL, false, wxT("invalid window") );
-
if (!wxWindowBase::SetForegroundColour(colour))
- {
return false;
- }
-#ifndef __WXGTK3__
- if (colour.IsOk())
+ if (m_widget)
{
- // We need the pixel value e.g. for background clearing.
- m_foregroundColour.CalcPixel(gtk_widget_get_colormap(m_widget));
- }
+#ifndef __WXGTK3__
+ if (colour.IsOk())
+ {
+ // We need the pixel value e.g. for background clearing.
+ m_foregroundColour.CalcPixel(gtk_widget_get_colormap(m_widget));
+ }
#endif
- // apply style change (forceStyle=true so that new style is applied
- // even if the bg colour changed from valid to wxNullColour):
- GTKApplyWidgetStyle(true);
+ // apply style change (forceStyle=true so that new style is applied
+ // even if the bg colour changed from valid to wxNullColour):
+ GTKApplyWidgetStyle(true);
+ }
return true;
}
}
#ifndef __WXGTK3__
-GtkRcStyle *wxWindowGTK::GTKCreateWidgetStyle(bool forceStyle)
+GtkRcStyle* wxWindowGTK::GTKCreateWidgetStyle()
{
- // do we need to apply any changes at all?
- if ( !forceStyle &&
- !m_font.IsOk() &&
- !m_foregroundColour.IsOk() && !m_backgroundColour.IsOk() )
- {
- return NULL;
- }
-
GtkRcStyle *style = gtk_rc_style_new();
if ( m_font.IsOk() )
}
#endif // !__WXGTK3__
-void wxWindowGTK::GTKApplyWidgetStyle(bool WXUNUSED_IN_GTK3(forceStyle))
+void wxWindowGTK::GTKApplyWidgetStyle(bool forceStyle)
{
+ if (forceStyle || m_font.IsOk() ||
+ m_foregroundColour.IsOk() || m_backgroundColour.IsOk())
+ {
#ifdef __WXGTK3__
- DoApplyWidgetStyle(NULL);
+ if (m_backgroundColour.IsOk())
+ {
+ // create a GtkStyleProvider to override "background-image"
+ if (m_styleProvider == NULL)
+ m_styleProvider = GTK_STYLE_PROVIDER(gtk_css_provider_new());
+ const char css[] =
+ "*{background-image:-gtk-gradient(linear,0 0,0 1,"
+ "from(rgba(%u,%u,%u,%g)),to(rgba(%u,%u,%u,%g)))}";
+ char buf[sizeof(css) + 20];
+ const unsigned r = m_backgroundColour.Red();
+ const unsigned g = m_backgroundColour.Green();
+ const unsigned b = m_backgroundColour.Blue();
+ const double a = m_backgroundColour.Alpha() / 255.0;
+ g_snprintf(buf, sizeof(buf), css, r, g, b, a, r, g, b, a);
+ gtk_css_provider_load_from_data(GTK_CSS_PROVIDER(m_styleProvider), buf, -1, NULL);
+ }
+ DoApplyWidgetStyle(NULL);
#else
- GtkRcStyle *style = GTKCreateWidgetStyle(forceStyle);
- if ( style )
- {
+ GtkRcStyle* style = GTKCreateWidgetStyle();
DoApplyWidgetStyle(style);
g_object_unref(style);
- }
#endif
+ }
// Style change may affect GTK+'s size calculation:
InvalidateBestSize();
gtk_widget_override_font(widget, pfd);
gtk_widget_override_color(widget, GTK_STATE_FLAG_NORMAL, m_foregroundColour);
gtk_widget_override_background_color(widget, GTK_STATE_FLAG_NORMAL, m_backgroundColour);
+
+ // setting background color has no effect with some themes when the widget style
+ // has a "background-image" property, so we need to override that as well
+
+ GtkStyleContext* context = gtk_widget_get_style_context(widget);
+ if (m_styleProvider)
+ gtk_style_context_remove_provider(context, m_styleProvider);
+ cairo_pattern_t* pattern = NULL;
+ if (m_backgroundColour.IsOk())
+ {
+ gtk_style_context_get(context,
+ GTK_STATE_FLAG_NORMAL, "background-image", &pattern, NULL);
+ }
+ if (pattern)
+ {
+ cairo_pattern_destroy(pattern);
+ gtk_style_context_add_provider(context,
+ m_styleProvider, GTK_STYLE_PROVIDER_PRIORITY_APPLICATION);
+ }
#else
gtk_widget_modify_style(widget, style);
#endif
#ifndef __WXGTK3__
GdkWindow *window;
- if ( m_wxwindow )
+ if ((style == wxBG_STYLE_PAINT || style == wxBG_STYLE_TRANSPARENT) &&
+ (window = GTKGetDrawingWindow()))
{
- window = GTKGetDrawingWindow();
- }
- else
- {
- GtkWidget * const w = GetConnectWidget();
- window = w ? gtk_widget_get_window(w) : NULL;
- }
-
- bool wantNoBackPixmap = style == wxBG_STYLE_PAINT || style == wxBG_STYLE_TRANSPARENT;
-
- if ( wantNoBackPixmap )
- {
- if (window)
- {
- // Make sure GDK/X11 doesn't refresh the window
- // automatically.
- gdk_window_set_back_pixmap( window, NULL, FALSE );
- m_needsStyleChange = false;
- }
- else // window not realized yet
- {
- // Do when window is realized
- m_needsStyleChange = true;
- }
-
- // Don't apply widget style, or we get a grey background
- }
- else
- {
- // apply style change (forceStyle=true so that new style is applied
- // even if the bg colour changed from valid to wxNullColour):
- GTKApplyWidgetStyle(true);
+ gdk_window_set_back_pixmap(window, NULL, false);
}
#endif // !__WXGTK3__
{
// ensure that the menu appears entirely on screen
GtkRequisition req;
+#ifdef __WXGTK3__
+ gtk_widget_get_preferred_size(GTK_WIDGET(menu), &req, NULL);
+#else
gtk_widget_get_child_requisition(GTK_WIDGET(menu), &req);
+#endif
wxSize sizeScreen = wxGetDisplaySize();
wxPoint *pos = (wxPoint*)user_data;
gtk_get_current_event_time()
);
+ // it is possible for gtk_menu_popup() to fail
+ if (!gtk_widget_get_visible(GTK_WIDGET(menu->m_menu)))
+ {
+ menu->m_popupShown = false;
+ return false;
+ }
+
while (menu->m_popupShown)
{
gtk_main_iteration();
bool wxWindowGTK::SetFont( const wxFont &font )
{
- wxCHECK_MSG( m_widget != NULL, false, wxT("invalid window") );
-
if (!wxWindowBase::SetFont(font))
return false;
- // apply style change (forceStyle=true so that new style is applied
- // even if the font changed from valid to wxNullFont):
- GTKApplyWidgetStyle(true);
+ if (m_widget)
+ {
+ // apply style change (forceStyle=true so that new style is applied
+ // even if the font changed from valid to wxNullFont):
+ GTKApplyWidgetStyle(true);
+ }
return true;
}
if (!cursor->IsOk())
cursor = wxSTANDARD_CURSOR;
+ const GdkEventMask mask = GdkEventMask(
+ GDK_BUTTON_PRESS_MASK |
+ GDK_BUTTON_RELEASE_MASK |
+ GDK_POINTER_MOTION_HINT_MASK |
+ GDK_POINTER_MOTION_MASK);
+#ifdef __WXGTK3__
+ GdkDisplay* display = gdk_window_get_display(window);
+ GdkDeviceManager* manager = gdk_display_get_device_manager(display);
+ GdkDevice* device = gdk_device_manager_get_client_pointer(manager);
+ gdk_device_grab(
+ device, window, GDK_OWNERSHIP_NONE, false, mask,
+ cursor->GetCursor(), unsigned(GDK_CURRENT_TIME));
+#else
gdk_pointer_grab( window, FALSE,
- (GdkEventMask)
- (GDK_BUTTON_PRESS_MASK |
- GDK_BUTTON_RELEASE_MASK |
- GDK_POINTER_MOTION_HINT_MASK |
- GDK_POINTER_MOTION_MASK),
+ mask,
NULL,
cursor->GetCursor(),
(guint32)GDK_CURRENT_TIME );
+#endif
g_captureWindow = this;
g_captureWindowHasMouse = true;
}
if (!window)
return;
+#ifdef __WXGTK3__
+ GdkDisplay* display = gdk_window_get_display(window);
+ GdkDeviceManager* manager = gdk_display_get_device_manager(display);
+ GdkDevice* device = gdk_device_manager_get_client_pointer(manager);
+ gdk_device_ungrab(device, unsigned(GDK_CURRENT_TIME));
+#else
gdk_pointer_ungrab ( (guint32)GDK_CURRENT_TIME );
+#endif
}
void wxWindowGTK::GTKReleaseMouseAndNotify()
// difference due to possible inexactness in floating point arithmetic
static inline bool IsScrollIncrement(double increment, double x)
{
- wxASSERT(increment > 0);
+ wxASSERT(increment >= 0);
+ if ( increment == 0. )
+ return false;
const double tolerance = 1.0 / 1024;
return fabs(increment - fabs(x)) < tolerance;
}
}
// Get the current mouse position.
+void wxGetMousePosition(int* x, int* y)
+{
+ GdkDisplay* display = GetDisplay();
+#ifdef __WXGTK3__
+ GdkDeviceManager* manager = gdk_display_get_device_manager(display);
+ GdkDevice* device = gdk_device_manager_get_client_pointer(manager);
+ gdk_device_get_position(device, NULL, x, y);
+#else
+ gdk_display_get_pointer(display, NULL, x, y, NULL);
+#endif
+}
+
wxPoint wxGetMousePosition()
{
- int x, y;
- GdkModifierType unused;
- GetMouseState(x, y, unused);
- return wxPoint(x, y);
+ wxPoint pt;
+ wxGetMousePosition(&pt.x, &pt.y);
+ return pt;
}
GdkWindow* wxWindowGTK::GTKGetDrawingWindow() const