Amebis/wxWidgets
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

avoid deprecated functions and direct struct access

Browse Source 
git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@67326 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775
This commit is contained in:
Paul Cornett
2011-03-28 06:27:49 +00:00
parent 989d151ce2
commit 385e8575dd
50 changed files with 535 additions and 375 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
include/wx/gtk/mdi.h
View File

@@ -120,7 +120,6 @@ public:
void OnMenuHighlight( wxMenuEvent& event ); void OnMenuHighlight( wxMenuEvent& event );
wxMenuBar *m_menuBar; wxMenuBar *m_menuBar;
GtkNotebookPage *m_page;
bool m_justInserted; bool m_justInserted;
private: private:

53
include/wx/gtk/private/gtk2-compat.h
View File

@@ -54,6 +54,15 @@ static inline gpointer wx_g_object_ref_sink(gpointer object)
} }
#define g_object_ref_sink wx_g_object_ref_sink #define g_object_ref_sink wx_g_object_ref_sink
// ----------------------------------------------------------------------------
// the following were introduced in GTK+ 2.12
static inline void wx_gtk_about_dialog_set_program_name(GtkAboutDialog* about, const gchar* name)
{
gtk_about_dialog_set_name(about, name);
}
#define gtk_about_dialog_set_program_name wx_gtk_about_dialog_set_program_name
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
// the following were introduced in GTK+ 2.14 // the following were introduced in GTK+ 2.14
@@ -87,6 +96,12 @@ static inline gdouble wx_gtk_adjustment_get_upper(GtkAdjustment* adjustment)
} }
#define gtk_adjustment_get_upper wx_gtk_adjustment_get_upper #define gtk_adjustment_get_upper wx_gtk_adjustment_get_upper
static inline void wx_gtk_adjustment_set_page_size(GtkAdjustment* adjustment, gdouble page_size)
{
adjustment->page_size = page_size;
}
#define gtk_adjustment_set_page_size wx_gtk_adjustment_set_page_size
static inline GtkWidget* wx_gtk_color_selection_dialog_get_color_selection(GtkColorSelectionDialog* csd) static inline GtkWidget* wx_gtk_color_selection_dialog_get_color_selection(GtkColorSelectionDialog* csd)
{ {
return csd->colorsel; return csd->colorsel;
@@ -105,6 +120,12 @@ static inline GtkWidget* wx_gtk_dialog_get_action_area(GtkDialog* dialog)
} }
#define gtk_dialog_get_action_area wx_gtk_dialog_get_action_area #define gtk_dialog_get_action_area wx_gtk_dialog_get_action_area
static inline guint16 wx_gtk_entry_get_text_length(GtkEntry* entry)
{
return entry->text_length;
}
#define gtk_entry_get_text_length wx_gtk_entry_get_text_length
static inline GtkWidget* wx_gtk_font_selection_dialog_get_cancel_button(GtkFontSelectionDialog* fsd) static inline GtkWidget* wx_gtk_font_selection_dialog_get_cancel_button(GtkFontSelectionDialog* fsd)
{ {
return fsd->cancel_button; return fsd->cancel_button;
@@ -117,6 +138,12 @@ static inline GtkWidget* wx_gtk_font_selection_dialog_get_ok_button(GtkFontSelec
} }
#define gtk_font_selection_dialog_get_ok_button wx_gtk_font_selection_dialog_get_ok_button #define gtk_font_selection_dialog_get_ok_button wx_gtk_font_selection_dialog_get_ok_button
static inline const guchar* wx_gtk_selection_data_get_data(GtkSelectionData* selection_data)
{
return selection_data->data;
}
#define gtk_selection_data_get_data wx_gtk_selection_data_get_data
static inline GdkAtom wx_gtk_selection_data_get_data_type(GtkSelectionData* selection_data) static inline GdkAtom wx_gtk_selection_data_get_data_type(GtkSelectionData* selection_data)
{ {
return selection_data->type; return selection_data->type;
@@ -147,6 +174,12 @@ static inline GdkWindow* wx_gtk_widget_get_window(GtkWidget* widget)
} }
#define gtk_widget_get_window wx_gtk_widget_get_window #define gtk_widget_get_window wx_gtk_widget_get_window
static inline GtkWidget* wx_gtk_window_get_default_widget(GtkWindow* window)
{
return window->default_widget;
}
#define gtk_window_get_default_widget wx_gtk_window_get_default_widget
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
// the following were introduced in GTK+ 2.16 // the following were introduced in GTK+ 2.16
@@ -159,6 +192,20 @@ static inline GdkAtom wx_gtk_selection_data_get_selection(GtkSelectionData* sele
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
// the following were introduced in GTK+ 2.18 // the following were introduced in GTK+ 2.18
static inline void wx_gtk_cell_renderer_get_alignment(GtkCellRenderer* cell, gfloat* xalign, gfloat* yalign)
{
*xalign = cell->xalign;
*yalign = cell->yalign;
}
#define gtk_cell_renderer_get_alignment wx_gtk_cell_renderer_get_alignment
static inline void wx_gtk_cell_renderer_get_padding(GtkCellRenderer* cell, gint* xpad, gint* ypad)
{
*xpad = cell->xpad;
*ypad = cell->ypad;
}
#define gtk_cell_renderer_get_padding wx_gtk_cell_renderer_get_padding
static inline void wx_gtk_widget_get_allocation(GtkWidget* widget, GtkAllocation* allocation) static inline void wx_gtk_widget_get_allocation(GtkWidget* widget, GtkAllocation* allocation)
{ {
*allocation = widget->allocation; *allocation = widget->allocation;
@@ -280,6 +327,12 @@ inline gboolean wx_gtk_widget_get_mapped(GtkWidget *widget)
} }
#define gtk_widget_get_mapped wx_gtk_widget_get_mapped #define gtk_widget_get_mapped wx_gtk_widget_get_mapped
static inline void wx_gtk_widget_get_requisition(GtkWidget* widget, GtkRequisition* requisition)
{
*requisition = widget->requisition;
}
#define gtk_widget_get_requisition wx_gtk_widget_get_requisition
static inline GdkWindow* wx_gtk_entry_get_text_window(GtkEntry* entry) static inline GdkWindow* wx_gtk_entry_get_text_window(GtkEntry* entry)
{ {
return entry->text_area; return entry->text_area;

12
include/wx/gtk/scrolbar.h
View File

@@ -10,14 +10,6 @@
#ifndef _WX_GTK_SCROLLBAR_H_ #ifndef _WX_GTK_SCROLLBAR_H_
#define _WX_GTK_SCROLLBAR_H_ #define _WX_GTK_SCROLLBAR_H_
#include "wx/defs.h"
//-----------------------------------------------------------------------------
// classes
//-----------------------------------------------------------------------------
class WXDLLIMPEXP_FWD_CORE wxScrollBar;
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// wxScrollBar // wxScrollBar
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
@@ -57,10 +49,6 @@ public:
static wxVisualAttributes static wxVisualAttributes
GetClassDefaultAttributes(wxWindowVariant variant = wxWINDOW_VARIANT_NORMAL); GetClassDefaultAttributes(wxWindowVariant variant = wxWINDOW_VARIANT_NORMAL);
protected:
virtual GdkWindow *GTKGetWindow(wxArrayGdkWindows& windows) const;
private:
DECLARE_DYNAMIC_CLASS(wxScrollBar) DECLARE_DYNAMIC_CLASS(wxScrollBar)
}; };

1
include/wx/gtk/textctrl.h
View File

@@ -214,6 +214,7 @@ private:
GtkTextBuffer *m_buffer; GtkTextBuffer *m_buffer;
GtkTextMark* m_showPositionOnThaw; GtkTextMark* m_showPositionOnThaw;
GSList* m_anonymousMarkList;
// For wxTE_AUTO_URL // For wxTE_AUTO_URL
void OnUrlMouseEvent(wxMouseEvent&); void OnUrlMouseEvent(wxMouseEvent&);

8
include/wx/gtk/treeentry_gtk.h
View File

@@ -19,9 +19,9 @@ extern "C" {
#include "wx/dlimpexp.h" #include "wx/dlimpexp.h"
#define GTK_TYPE_TREE_ENTRY (gtk_tree_entry_get_type()) #define GTK_TYPE_TREE_ENTRY (gtk_tree_entry_get_type())
#define GTK_TREE_ENTRY(obj) (GTK_CHECK_CAST (obj, gtk_tree_entry_get_type (), GtkTreeEntry)) #define GTK_TREE_ENTRY(obj) (G_TYPE_CHECK_INSTANCE_CAST (obj, gtk_tree_entry_get_type (), GtkTreeEntry))
#define GTK_TREE_ENTRY_CLASS(klass) (GTK_CHECK_CLASS_CAST (klass, gtk_tree_entry_get_type (), GtkTreeEntryClass)) #define GTK_TREE_ENTRY_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST (klass, gtk_tree_entry_get_type (), GtkTreeEntryClass))
#define GTK_IS_TREE_ENTRY(obj) (GTK_CHECK_TYPE (obj, gtk_tree_entry_get_type ())) #define GTK_IS_TREE_ENTRY(obj) (G_TYPE_CHECK_INSTANCE_TYPE (obj, gtk_tree_entry_get_type ()))
typedef struct _GtkTreeEntry GtkTreeEntry; typedef struct _GtkTreeEntry GtkTreeEntry;
typedef struct _GtkTreeEntryClass GtkTreeEntryClass; typedef struct _GtkTreeEntryClass GtkTreeEntryClass;
@@ -47,7 +47,7 @@ WXDLLIMPEXP_CORE
GtkTreeEntry* gtk_tree_entry_new (void); GtkTreeEntry* gtk_tree_entry_new (void);
WXDLLIMPEXP_CORE WXDLLIMPEXP_CORE
GtkType gtk_tree_entry_get_type (void); GType gtk_tree_entry_get_type (void);
WXDLLIMPEXP_CORE WXDLLIMPEXP_CORE
gchar* gtk_tree_entry_get_collate_key (GtkTreeEntry* entry); gchar* gtk_tree_entry_get_collate_key (GtkTreeEntry* entry);

2
src/aui/dockart.cpp
View File

@@ -414,7 +414,7 @@ void wxAuiDefaultDockArt::DrawSash(wxDC& dc, wxWindow *window, int orientation,
gtk_paint_handle gtk_paint_handle
( (
window->m_wxwindow->style, gtk_widget_get_style(window->m_wxwindow),
window->GTKGetDrawingWindow(), window->GTKGetDrawingWindow(),
// flags & wxCONTROL_CURRENT ? GTK_STATE_PRELIGHT : GTK_STATE_NORMAL, // flags & wxCONTROL_CURRENT ? GTK_STATE_PRELIGHT : GTK_STATE_NORMAL,
GTK_STATE_NORMAL, GTK_STATE_NORMAL,

3
src/aui/framemanager.cpp
View File

@@ -223,6 +223,7 @@ END_EVENT_TABLE()
// __WXGTK20__ // __WXGTK20__
#include <gtk/gtk.h> #include <gtk/gtk.h>
#include "wx/gtk/private/gtk2-compat.h"
static void static void
gtk_pseudo_window_realized_callback( GtkWidget *m_widget, void *WXUNUSED(win) ) gtk_pseudo_window_realized_callback( GtkWidget *m_widget, void *WXUNUSED(win) )
@@ -237,7 +238,7 @@ gtk_pseudo_window_realized_callback( GtkWidget *m_widget, void *WXUNUSED(win) )
if ((j*16+8)<amount) if ((j*16+8)<amount)
region.Union(0, y, disp.x, 1); region.Union(0, y, disp.x, 1);
} }
gdk_window_shape_combine_region(m_widget->window, region.GetRegion(), 0, 0); gdk_window_shape_combine_region(gtk_widget_get_window(m_widget), region.GetRegion(), 0, 0);
} }

3
src/common/popupcmn.cpp
View File

@@ -44,6 +44,7 @@
#ifdef __WXGTK__ #ifdef __WXGTK__
#include <gtk/gtk.h> #include <gtk/gtk.h>
#include "wx/gtk/private/gtk2-compat.h"
#elif defined(__WXMSW__) #elif defined(__WXMSW__)
#include "wx/msw/private.h" #include "wx/msw/private.h"
#elif defined(__WXX11__) #elif defined(__WXX11__)
@@ -343,7 +344,7 @@ bool wxPopupTransientWindow::Show( bool show )
{ {
gtk_grab_add( m_widget ); gtk_grab_add( m_widget );
gdk_pointer_grab( m_widget->window, TRUE, gdk_pointer_grab( gtk_widget_get_window(m_widget), true,
(GdkEventMask) (GdkEventMask)
(GDK_BUTTON_PRESS_MASK | (GDK_BUTTON_PRESS_MASK |
GDK_BUTTON_RELEASE_MASK | GDK_BUTTON_RELEASE_MASK |

2
src/generic/statusbr.cpp
View File

@@ -414,7 +414,7 @@ void wxStatusBarGeneric::OnPaint(wxPaintEvent& WXUNUSED(event) )
GdkWindowEdge edge = GdkWindowEdge edge =
GetLayoutDirection() == wxLayout_RightToLeft ? GDK_WINDOW_EDGE_SOUTH_WEST : GetLayoutDirection() == wxLayout_RightToLeft ? GDK_WINDOW_EDGE_SOUTH_WEST :
GDK_WINDOW_EDGE_SOUTH_EAST; GDK_WINDOW_EDGE_SOUTH_EAST;
gtk_paint_resize_grip( m_widget->style, gtk_paint_resize_grip(gtk_widget_get_style(m_widget),
GTKGetDrawingWindow(), GTKGetDrawingWindow(),
gtk_widget_get_state(m_widget), gtk_widget_get_state(m_widget),
NULL, NULL,

2
src/gtk/aboutdlg.cpp
View File

@@ -126,7 +126,7 @@ void wxAboutBox(const wxAboutDialogInfo& info, wxWindow* WXUNUSED(parent))
gs_aboutDialog = GTK_ABOUT_DIALOG(gtk_about_dialog_new()); gs_aboutDialog = GTK_ABOUT_DIALOG(gtk_about_dialog_new());
GtkAboutDialog * const dlg = gs_aboutDialog; GtkAboutDialog * const dlg = gs_aboutDialog;
gtk_about_dialog_set_name(dlg, wxGTK_CONV_SYS(info.GetName())); gtk_about_dialog_set_program_name(dlg, wxGTK_CONV_SYS(info.GetName()));
if ( info.HasVersion() ) if ( info.HasVersion() )
gtk_about_dialog_set_version(dlg, wxGTK_CONV_SYS(info.GetVersion())); gtk_about_dialog_set_version(dlg, wxGTK_CONV_SYS(info.GetVersion()));
else else

4
src/gtk/artgtk.cpp
View File

@@ -203,7 +203,7 @@ GdkPixbuf *CreateStockIcon(const char *stockid, GtkIconSize size)
// with "stock-id" representation (in addition to pixmap and pixbuf // with "stock-id" representation (in addition to pixmap and pixbuf
// ones) and would convert it to pixbuf when rendered. // ones) and would convert it to pixbuf when rendered.
GtkStyle* style = wxGTKPrivate::GetButtonWidget()->style; GtkStyle* style = gtk_widget_get_style(wxGTKPrivate::GetButtonWidget());
GtkIconSet* iconset = gtk_style_lookup_icon_set(style, stockid); GtkIconSet* iconset = gtk_style_lookup_icon_set(style, stockid);
if (!iconset) if (!iconset)
@@ -310,7 +310,7 @@ wxGTK2ArtProvider::CreateIconBundle(const wxArtID& id,
const wxString stockid = wxArtIDToStock(id); const wxString stockid = wxArtIDToStock(id);
// try to load the bundle as stock icon first // try to load the bundle as stock icon first
GtkStyle* style = wxGTKPrivate::GetButtonWidget()->style; GtkStyle* style = gtk_widget_get_style(wxGTKPrivate::GetButtonWidget());
GtkIconSet* iconset = gtk_style_lookup_icon_set(style, stockid.utf8_str()); GtkIconSet* iconset = gtk_style_lookup_icon_set(style, stockid.utf8_str());
if ( iconset ) if ( iconset )
{ {

4
src/gtk/bmpcbox.cpp
View File

@@ -122,8 +122,8 @@ void wxBitmapComboBox::GTKCreateComboBoxWidget()
else else
{ {
m_widget = gtk_combo_box_entry_new_with_model( GTK_TREE_MODEL(store), m_stringCellIndex ); m_widget = gtk_combo_box_entry_new_with_model( GTK_TREE_MODEL(store), m_stringCellIndex );
m_entry = GTK_ENTRY( GTK_BIN(m_widget)->child ); m_entry = GTK_ENTRY(gtk_bin_get_child(GTK_BIN(m_widget)));
gtk_entry_set_editable( m_entry, TRUE ); gtk_editable_set_editable(GTK_EDITABLE(m_entry), true);
} }
g_object_ref(m_widget); g_object_ref(m_widget);

25
src/gtk/button.cpp
View File

@@ -287,7 +287,7 @@ bool wxButton::Enable( bool enable )
if (!base_type::Enable(enable)) if (!base_type::Enable(enable))
return false; return false;
gtk_widget_set_sensitive(GTK_BIN(m_widget)->child, enable); gtk_widget_set_sensitive(gtk_bin_get_child(GTK_BIN(m_widget)), enable);
if (enable) if (enable)
GTKFixSensitivity(); GTKFixSensitivity();
@@ -304,18 +304,21 @@ GdkWindow *wxButton::GTKGetWindow(wxArrayGdkWindows& WXUNUSED(windows)) const
GtkLabel *wxButton::GTKGetLabel() const GtkLabel *wxButton::GTKGetLabel() const
{ {
GtkWidget *child = GTK_BIN(m_widget)->child; GtkWidget* child = gtk_bin_get_child(GTK_BIN(m_widget));
if ( GTK_IS_ALIGNMENT(child) ) if ( GTK_IS_ALIGNMENT(child) )
{ {
GtkWidget *box = GTK_BIN(child)->child; GtkWidget* box = gtk_bin_get_child(GTK_BIN(child));
for (GList* item = GTK_BOX(box)->children; item; item = item->next) GtkLabel* label = NULL;
GList* list = gtk_container_get_children(GTK_CONTAINER(box));
for (GList* item = list; item; item = item->next)
{ {
GtkBoxChild* boxChild = static_cast<GtkBoxChild*>(item->data); GtkBoxChild* boxChild = static_cast<GtkBoxChild*>(item->data);
if ( GTK_IS_LABEL(boxChild->widget) ) if ( GTK_IS_LABEL(boxChild->widget) )
return GTK_LABEL(boxChild->widget); label = GTK_LABEL(boxChild->widget);
} }
g_list_free(list);
return NULL; return label;
} }
return GTK_LABEL(child); return GTK_LABEL(child);
@@ -324,21 +327,23 @@ GtkLabel *wxButton::GTKGetLabel() const
void wxButton::DoApplyWidgetStyle(GtkRcStyle *style) void wxButton::DoApplyWidgetStyle(GtkRcStyle *style)
{ {
gtk_widget_modify_style(m_widget, style); gtk_widget_modify_style(m_widget, style);
GtkWidget *child = GTK_BIN(m_widget)->child; GtkWidget* child = gtk_bin_get_child(GTK_BIN(m_widget));
gtk_widget_modify_style(child, style); gtk_widget_modify_style(child, style);
// for buttons with images, the path to the label is (at least in 2.12) // for buttons with images, the path to the label is (at least in 2.12)
// GtkButton -> GtkAlignment -> GtkHBox -> GtkLabel // GtkButton -> GtkAlignment -> GtkHBox -> GtkLabel
if ( GTK_IS_ALIGNMENT(child) ) if ( GTK_IS_ALIGNMENT(child) )
{ {
GtkWidget *box = GTK_BIN(child)->child; GtkWidget* box = gtk_bin_get_child(GTK_BIN(child));
if ( GTK_IS_BOX(box) ) if ( GTK_IS_BOX(box) )
{ {
for (GList* item = GTK_BOX(box)->children; item; item = item->next) GList* list = gtk_container_get_children(GTK_CONTAINER(box));
for (GList* item = list; item; item = item->next)
{ {
GtkBoxChild* boxChild = static_cast<GtkBoxChild*>(item->data); GtkBoxChild* boxChild = static_cast<GtkBoxChild*>(item->data);
gtk_widget_modify_style(boxChild->widget, style); gtk_widget_modify_style(boxChild->widget, style);
} }
g_list_free(list);
} }
} }
} }
@@ -460,7 +465,7 @@ void wxButton::GTKDoShowBitmap(const wxBitmap& bitmap)
GtkWidget *image; GtkWidget *image;
if ( DontShowLabel() ) if ( DontShowLabel() )
{ {
image = GTK_BIN(m_widget)->child; image = gtk_bin_get_child(GTK_BIN(m_widget));
} }
else // have both label and bitmap else // have both label and bitmap
{ {

2
src/gtk/checkbox.cpp
View File

@@ -131,7 +131,7 @@ bool wxCheckBox::Create(wxWindow *parent,
else else
{ {
m_widgetCheckbox = gtk_check_button_new_with_label(""); m_widgetCheckbox = gtk_check_button_new_with_label("");
m_widgetLabel = GTK_BIN(m_widgetCheckbox)->child; m_widgetLabel = gtk_bin_get_child(GTK_BIN(m_widgetCheckbox));
m_widget = m_widgetCheckbox; m_widget = m_widgetCheckbox;
} }
g_object_ref(m_widget); g_object_ref(m_widget);

4
src/gtk/choice.cpp
View File

@@ -334,7 +334,7 @@ void wxChoice::GTKEnableEvents()
GdkWindow *wxChoice::GTKGetWindow(wxArrayGdkWindows& WXUNUSED(windows)) const GdkWindow *wxChoice::GTKGetWindow(wxArrayGdkWindows& WXUNUSED(windows)) const
{ {
return m_widget->window; return gtk_widget_get_window(m_widget);
} }
// Notice that this method shouldn't be necessary, because GTK calculates // Notice that this method shouldn't be necessary, because GTK calculates
@@ -371,7 +371,7 @@ wxSize wxChoice::DoGetBestSize() const
void wxChoice::DoApplyWidgetStyle(GtkRcStyle *style) void wxChoice::DoApplyWidgetStyle(GtkRcStyle *style)
{ {
gtk_widget_modify_style(m_widget, style); gtk_widget_modify_style(m_widget, style);
gtk_widget_modify_style(GTK_BIN(m_widget)->child, style); gtk_widget_modify_style(gtk_bin_get_child(GTK_BIN(m_widget)), style);
} }

51
src/gtk/clipbrd.cpp
View File

@@ -133,11 +133,15 @@ targets_selection_received( GtkWidget *WXUNUSED(widget),
wxON_BLOCK_EXIT1(wxClipboardSync::OnDone, clipboard); wxON_BLOCK_EXIT1(wxClipboardSync::OnDone, clipboard);
if ( !selection_data || selection_data->length <= 0 ) if (!selection_data)
return;
const int selection_data_length = gtk_selection_data_get_length(selection_data);
if (selection_data_length <= 0)
return; return;
// make sure we got the data in the correct form // make sure we got the data in the correct form
GdkAtom type = selection_data->type; GdkAtom type = gtk_selection_data_get_data_type(selection_data);
if ( type != GDK_SELECTION_TYPE_ATOM ) if ( type != GDK_SELECTION_TYPE_ATOM )
{ {
if ( strcmp(wxGtkString(gdk_atom_name(type)), "TARGETS") != 0 ) if ( strcmp(wxGtkString(gdk_atom_name(type)), "TARGETS") != 0 )
@@ -151,14 +155,14 @@ targets_selection_received( GtkWidget *WXUNUSED(widget),
// it's not really a format, of course, but we can reuse its GetId() method // it's not really a format, of course, but we can reuse its GetId() method
// to format this atom as string // to format this atom as string
wxDataFormat clip(selection_data->selection); wxDataFormat clip(gtk_selection_data_get_selection(selection_data));
wxLogTrace( TRACE_CLIPBOARD, wxLogTrace( TRACE_CLIPBOARD,
wxT("Received available formats for clipboard %s"), wxT("Received available formats for clipboard %s"),
clip.GetId().c_str() ); clip.GetId().c_str() );
// the atoms we received, holding a list of targets (= formats) // the atoms we received, holding a list of targets (= formats)
const GdkAtom * const atoms = (GdkAtom *)selection_data->data; const GdkAtom* const atoms = (GdkAtom*)gtk_selection_data_get_data(selection_data);
for ( size_t i = 0; i < selection_data->length/sizeof(GdkAtom); i++ ) for (size_t i = 0; i < selection_data_length / sizeof(GdkAtom); i++)
{ {
const wxDataFormat format(atoms[i]); const wxDataFormat format(atoms[i]);
@@ -195,7 +199,7 @@ selection_received( GtkWidget *WXUNUSED(widget),
wxON_BLOCK_EXIT1(wxClipboardSync::OnDone, clipboard); wxON_BLOCK_EXIT1(wxClipboardSync::OnDone, clipboard);
if ( !selection_data || selection_data->length <= 0 ) if (!selection_data || gtk_selection_data_get_length(selection_data) <= 0)
return; return;
clipboard->GTKOnSelectionReceived(*selection_data); clipboard->GTKOnSelectionReceived(*selection_data);
@@ -262,7 +266,8 @@ selection_handler( GtkWidget *WXUNUSED(widget),
if ( !clipboard ) if ( !clipboard )
return; return;
wxDataObject * const data = clipboard->GTKGetDataObject(selection_data->selection); wxDataObject * const data = clipboard->GTKGetDataObject(
gtk_selection_data_get_selection(selection_data));
if ( !data ) if ( !data )
return; return;
@@ -270,7 +275,7 @@ selection_handler( GtkWidget *WXUNUSED(widget),
// In particular, it satisfies Klipper, which polls // In particular, it satisfies Klipper, which polls
// TIMESTAMP to see if the clipboards content has changed. // TIMESTAMP to see if the clipboards content has changed.
// It shall return the time which was used to set the data. // It shall return the time which was used to set the data.
if (selection_data->target == g_timestampAtom) if (gtk_selection_data_get_target(selection_data) == g_timestampAtom)
{ {
guint timestamp = GPOINTER_TO_UINT (signal_data); guint timestamp = GPOINTER_TO_UINT (signal_data);
gtk_selection_data_set(selection_data, gtk_selection_data_set(selection_data,
@@ -284,14 +289,14 @@ selection_handler( GtkWidget *WXUNUSED(widget),
return; return;
} }
wxDataFormat format( selection_data->target ); wxDataFormat format(gtk_selection_data_get_target(selection_data));
wxLogTrace(TRACE_CLIPBOARD, wxLogTrace(TRACE_CLIPBOARD,
wxT("clipboard data in format %s, GtkSelectionData is target=%s type=%s selection=%s timestamp=%u"), wxT("clipboard data in format %s, GtkSelectionData is target=%s type=%s selection=%s timestamp=%u"),
format.GetId().c_str(), format.GetId().c_str(),
wxString::FromAscii(wxGtkString(gdk_atom_name(selection_data->target))).c_str(), wxString::FromAscii(wxGtkString(gdk_atom_name(gtk_selection_data_get_target(selection_data)))).c_str(),
wxString::FromAscii(wxGtkString(gdk_atom_name(selection_data->type))).c_str(), wxString::FromAscii(wxGtkString(gdk_atom_name(gtk_selection_data_get_data_type(selection_data)))).c_str(),
wxString::FromAscii(wxGtkString(gdk_atom_name(selection_data->selection))).c_str(), wxString::FromAscii(wxGtkString(gdk_atom_name(gtk_selection_data_get_selection(selection_data)))).c_str(),
GPOINTER_TO_UINT( signal_data ) GPOINTER_TO_UINT( signal_data )
); );
@@ -335,14 +340,16 @@ void wxClipboard::GTKOnSelectionReceived(const GtkSelectionData& sel)
{ {
wxCHECK_RET( m_receivedData, wxT("should be inside GetData()") ); wxCHECK_RET( m_receivedData, wxT("should be inside GetData()") );
const wxDataFormat format(sel.target); const wxDataFormat format(gtk_selection_data_get_target(const_cast<GtkSelectionData*>(&sel)));
wxLogTrace(TRACE_CLIPBOARD, wxT("Received selection %s"), wxLogTrace(TRACE_CLIPBOARD, wxT("Received selection %s"),
format.GetId().c_str()); format.GetId().c_str());
if ( !m_receivedData->IsSupportedFormat(format) ) if ( !m_receivedData->IsSupportedFormat(format) )
return; return;
m_receivedData->SetData(format, sel.length, sel.data); m_receivedData->SetData(format,
gtk_selection_data_get_length(const_cast<GtkSelectionData*>(&sel)),
gtk_selection_data_get_data(const_cast<GtkSelectionData*>(&sel)));
m_formatSupported = true; m_formatSupported = true;
} }
@@ -366,7 +373,11 @@ async_targets_selection_received( GtkWidget *WXUNUSED(widget),
wxClipboardEvent *event = new wxClipboardEvent(wxEVT_CLIPBOARD_CHANGED); wxClipboardEvent *event = new wxClipboardEvent(wxEVT_CLIPBOARD_CHANGED);
event->SetEventObject( clipboard ); event->SetEventObject( clipboard );
if ( !selection_data || selection_data->length <= 0 ) int selection_data_length = 0;
if (selection_data)
selection_data_length = gtk_selection_data_get_length(selection_data);
if (selection_data_length <= 0)
{ {
clipboard->m_sink->QueueEvent( event ); clipboard->m_sink->QueueEvent( event );
clipboard->m_sink.Release(); clipboard->m_sink.Release();
@@ -374,7 +385,7 @@ async_targets_selection_received( GtkWidget *WXUNUSED(widget),
} }
// make sure we got the data in the correct form // make sure we got the data in the correct form
GdkAtom type = selection_data->type; GdkAtom type = gtk_selection_data_get_data_type(selection_data);
if ( type != GDK_SELECTION_TYPE_ATOM ) if ( type != GDK_SELECTION_TYPE_ATOM )
{ {
if ( strcmp(wxGtkString(gdk_atom_name(type)), "TARGETS") != 0 ) if ( strcmp(wxGtkString(gdk_atom_name(type)), "TARGETS") != 0 )
@@ -390,14 +401,14 @@ async_targets_selection_received( GtkWidget *WXUNUSED(widget),
// it's not really a format, of course, but we can reuse its GetId() method // it's not really a format, of course, but we can reuse its GetId() method
// to format this atom as string // to format this atom as string
wxDataFormat clip(selection_data->selection); wxDataFormat clip(gtk_selection_data_get_selection(selection_data));
wxLogTrace( TRACE_CLIPBOARD, wxLogTrace( TRACE_CLIPBOARD,
wxT("Received available formats for clipboard %s"), wxT("Received available formats for clipboard %s"),
clip.GetId().c_str() ); clip.GetId().c_str() );
// the atoms we received, holding a list of targets (= formats) // the atoms we received, holding a list of targets (= formats)
const GdkAtom * const atoms = (GdkAtom *)selection_data->data; const GdkAtom* const atoms = (GdkAtom*)gtk_selection_data_get_data(selection_data);
for ( size_t i = 0; i < selection_data->length/sizeof(GdkAtom); i++ ) for (size_t i = 0; i < selection_data_length / sizeof(GdkAtom); i++)
{ {
const wxDataFormat format(atoms[i]); const wxDataFormat format(atoms[i]);
@@ -568,7 +579,7 @@ void wxClipboard::Clear()
gtk_selection_clear_targets( m_clipboardWidget, GTKGetClipboardAtom() ); gtk_selection_clear_targets( m_clipboardWidget, GTKGetClipboardAtom() );
if ( gdk_selection_owner_get(GTKGetClipboardAtom()) == if ( gdk_selection_owner_get(GTKGetClipboardAtom()) ==
m_clipboardWidget->window ) gtk_widget_get_window(m_clipboardWidget) )
{ {
wxClipboardSync sync(*this); wxClipboardSync sync(*this);

4
src/gtk/collpane.cpp
View File

@@ -281,8 +281,8 @@ void wxCollapsiblePane::OnSize(wxSizeEvent &ev)
GdkWindow *wxCollapsiblePane::GTKGetWindow(wxArrayGdkWindows& windows) const GdkWindow *wxCollapsiblePane::GTKGetWindow(wxArrayGdkWindows& windows) const
{ {
GtkWidget *label = gtk_expander_get_label_widget( GTK_EXPANDER(m_widget) ); GtkWidget *label = gtk_expander_get_label_widget( GTK_EXPANDER(m_widget) );
windows.Add( label->window ); windows.Add(gtk_widget_get_window(label));
windows.Add( m_widget->window ); windows.Add(gtk_widget_get_window(m_widget));
return NULL; return NULL;
} }

15
src/gtk/colordlg.cpp
View File

@@ -69,8 +69,9 @@ bool wxColourDialog::Create(wxWindow *parent, wxColourData *data)
} }
#if !wxUSE_LIBHILDON && !wxUSE_LIBHILDON2 #if !wxUSE_LIBHILDON && !wxUSE_LIBHILDON2
GtkColorSelection *sel = GtkColorSelection* sel = GTK_COLOR_SELECTION(
GTK_COLOR_SELECTION(GTK_COLOR_SELECTION_DIALOG(m_widget)->colorsel); gtk_color_selection_dialog_get_color_selection(
GTK_COLOR_SELECTION_DIALOG(m_widget)));
gtk_color_selection_set_has_palette(sel, true); gtk_color_selection_set_has_palette(sel, true);
#endif // !wxUSE_LIBHILDON && !wxUSE_LIBHILDON2 #endif // !wxUSE_LIBHILDON && !wxUSE_LIBHILDON2
@@ -123,8 +124,9 @@ void wxColourDialog::ColourDataToDialog()
hildon_color_chooser_dialog_set_color((HildonColorChooserDialog *)m_widget, &clr); hildon_color_chooser_dialog_set_color((HildonColorChooserDialog *)m_widget, &clr);
#else // !wxUSE_LIBHILDON2/!wxUSE_LIBHILDON && !wxUSE_LIBHILDON2 #else // !wxUSE_LIBHILDON2/!wxUSE_LIBHILDON && !wxUSE_LIBHILDON2
GtkColorSelection *sel = GtkColorSelection* sel = GTK_COLOR_SELECTION(
GTK_COLOR_SELECTION(GTK_COLOR_SELECTION_DIALOG(m_widget)->colorsel); gtk_color_selection_dialog_get_color_selection(
GTK_COLOR_SELECTION_DIALOG(m_widget)));
if ( col ) if ( col )
gtk_color_selection_set_current_color(sel, col); gtk_color_selection_set_current_color(sel, col);
@@ -176,8 +178,9 @@ void wxColourDialog::DialogToColourData()
m_data.SetColour(new_color); m_data.SetColour(new_color);
#else // !wxUSE_LIBHILDON2 #else // !wxUSE_LIBHILDON2
GtkColorSelection *sel = GtkColorSelection* sel = GTK_COLOR_SELECTION(
GTK_COLOR_SELECTION(GTK_COLOR_SELECTION_DIALOG(m_widget)->colorsel); gtk_color_selection_dialog_get_color_selection(
GTK_COLOR_SELECTION_DIALOG(m_widget)));
GdkColor clr; GdkColor clr;
gtk_color_selection_get_current_color(sel, &clr); gtk_color_selection_get_current_color(sel, &clr);

14
src/gtk/combobox.cpp
View File

@@ -134,7 +134,7 @@ bool wxComboBox::Create( wxWindow *parent, wxWindowID id, const wxString& value,
gtk_entry_set_activates_default( entry, gtk_entry_set_activates_default( entry,
!HasFlag(wxTE_PROCESS_ENTER) ); !HasFlag(wxTE_PROCESS_ENTER) );
gtk_entry_set_editable( entry, TRUE ); gtk_editable_set_editable(GTK_EDITABLE(entry), true);
} }
Append(n, choices); Append(n, choices);
@@ -155,7 +155,7 @@ bool wxComboBox::Create( wxWindow *parent, wxWindowID id, const wxString& value,
// wxMSW and also because it doesn't make sense to have a string // wxMSW and also because it doesn't make sense to have a string
// which is not a possible choice in a read-only combobox) // which is not a possible choice in a read-only combobox)
SetStringSelection(value); SetStringSelection(value);
gtk_entry_set_editable( entry, FALSE ); gtk_editable_set_editable(GTK_EDITABLE(entry), false);
} }
else // editable combobox else // editable combobox
{ {
@@ -186,12 +186,12 @@ void wxComboBox::GTKCreateComboBoxWidget()
m_widget = gtk_combo_box_entry_new_text(); m_widget = gtk_combo_box_entry_new_text();
g_object_ref(m_widget); g_object_ref(m_widget);
m_entry = GTK_ENTRY(GTK_BIN(m_widget)->child); m_entry = GTK_ENTRY(gtk_bin_get_child(GTK_BIN(m_widget)));
} }
GtkEditable *wxComboBox::GetEditable() const GtkEditable *wxComboBox::GetEditable() const
{ {
return GTK_EDITABLE( GTK_BIN(m_widget)->child ); return GTK_EDITABLE(gtk_bin_get_child(GTK_BIN(m_widget)));
} }
void wxComboBox::OnChar( wxKeyEvent &event ) void wxComboBox::OnChar( wxKeyEvent &event )
@@ -227,12 +227,12 @@ void wxComboBox::EnableTextChangedEvents(bool enable)
if ( enable ) if ( enable )
{ {
g_signal_handlers_unblock_by_func(GTK_BIN(m_widget)->child, g_signal_handlers_unblock_by_func(gtk_bin_get_child(GTK_BIN(m_widget)),
(gpointer)gtkcombobox_text_changed_callback, this); (gpointer)gtkcombobox_text_changed_callback, this);
} }
else // disable else // disable
{ {
g_signal_handlers_block_by_func(GTK_BIN(m_widget)->child, g_signal_handlers_block_by_func(gtk_bin_get_child(GTK_BIN(m_widget)),
(gpointer)gtkcombobox_text_changed_callback, this); (gpointer)gtkcombobox_text_changed_callback, this);
} }
} }
@@ -264,7 +264,7 @@ GtkWidget* wxComboBox::GetConnectWidget()
GdkWindow* wxComboBox::GTKGetWindow(wxArrayGdkWindows& /* windows */) const GdkWindow* wxComboBox::GTKGetWindow(wxArrayGdkWindows& /* windows */) const
{ {
return GetEntry()->text_area; return gtk_entry_get_text_window(GetEntry());
} }
// static // static

19
src/gtk/cursor.cpp
View File

@@ -22,6 +22,7 @@
#include <gtk/gtk.h> #include <gtk/gtk.h>
#include "wx/gtk/private/object.h" #include "wx/gtk/private/object.h"
#include "wx/gtk/private/gtk2-compat.h"
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// wxCursorRefData // wxCursorRefData
@@ -109,8 +110,10 @@ wxCursor::wxCursor(const char bits[], int width, int height,
if (hotSpotY < 0 || hotSpotY >= height) if (hotSpotY < 0 || hotSpotY >= height)
hotSpotY = 0; hotSpotY = 0;
GdkBitmap *data = gdk_bitmap_create_from_data( wxGetRootWindow()->window, (gchar *) bits, width, height ); GdkBitmap* data = gdk_bitmap_create_from_data(
GdkBitmap *mask = gdk_bitmap_create_from_data( wxGetRootWindow()->window, (gchar *) maskBits, width, height); gtk_widget_get_window(wxGetRootWindow()), const_cast<char*>(bits), width, height);
GdkBitmap* mask = gdk_bitmap_create_from_data(
gtk_widget_get_window(wxGetRootWindow()), const_cast<char*>(maskBits), width, height);
m_refData = new wxCursorRefData; m_refData = new wxCursorRefData;
M_CURSORDATA->m_cursor = gdk_cursor_new_from_pixmap( M_CURSORDATA->m_cursor = gdk_cursor_new_from_pixmap(
@@ -221,7 +224,7 @@ void wxCursor::InitFromImage( const wxImage & image )
m_refData = new wxCursorRefData; m_refData = new wxCursorRefData;
wxImage image_copy(image); wxImage image_copy(image);
GdkDisplay* display = gdk_drawable_get_display(wxGetRootWindow()->window); GdkDisplay* display = gdk_drawable_get_display(gtk_widget_get_window(wxGetRootWindow()));
if (gdk_display_supports_cursor_color(display)) if (gdk_display_supports_cursor_color(display))
{ {
if (!image.HasAlpha()) if (!image.HasAlpha())
@@ -257,7 +260,7 @@ void wxCursor::InitFromImage( const wxImage & image )
char* bits = new char[size]; char* bits = new char[size];
memset(bits, 0xff, size); memset(bits, 0xff, size);
maskRaw = gdk_bitmap_create_from_data( maskRaw = gdk_bitmap_create_from_data(
wxGetRootWindow()->window, bits, w, h); gtk_widget_get_window(wxGetRootWindow()), bits, w, h);
delete[] bits; delete[] bits;
} }
@@ -393,8 +396,12 @@ static void UpdateCursors(const wxWindowList& list, GdkDisplay*& display)
for (size_t n = list.size(); n--; ++i) for (size_t n = list.size(); n--; ++i)
{ {
wxWindow* win = *i; wxWindow* win = *i;
if (display == NULL && win->m_widget && win->m_widget->window) if (display == NULL && win->m_widget)
display = gdk_drawable_get_display(win->m_widget->window); {
GdkWindow* w = gtk_widget_get_window(win->m_widget);
if (w)
display = gdk_drawable_get_display(w);
}
win->GTKUpdateCursor(true, false); win->GTKUpdateCursor(true, false);
UpdateCursors(win->GetChildren(), display); UpdateCursors(win->GetChildren(), display);
} }

58
src/gtk/dataview.cpp
View File

@@ -493,11 +493,11 @@ static void wxgtk_tree_model_set_sort_func (GtkTreeSortable *s
gint sort_column_id, gint sort_column_id,
GtkTreeIterCompareFunc func, GtkTreeIterCompareFunc func,
gpointer data, gpointer data,
GtkDestroyNotify destroy); GDestroyNotify destroy);
static void wxgtk_tree_model_set_default_sort_func (GtkTreeSortable *sortable, static void wxgtk_tree_model_set_default_sort_func (GtkTreeSortable *sortable,
GtkTreeIterCompareFunc func, GtkTreeIterCompareFunc func,
gpointer data, gpointer data,
GtkDestroyNotify destroy); GDestroyNotify destroy);
static gboolean wxgtk_tree_model_has_default_sort_func (GtkTreeSortable *sortable); static gboolean wxgtk_tree_model_has_default_sort_func (GtkTreeSortable *sortable);
/* drag'n'drop */ /* drag'n'drop */
@@ -966,7 +966,7 @@ wxgtk_tree_model_set_sort_func (GtkTreeSortable *sortable,
gint WXUNUSED(sort_column_id), gint WXUNUSED(sort_column_id),
GtkTreeIterCompareFunc func, GtkTreeIterCompareFunc func,
gpointer WXUNUSED(data), gpointer WXUNUSED(data),
GtkDestroyNotify WXUNUSED(destroy)) GDestroyNotify WXUNUSED(destroy))
{ {
g_return_if_fail (GTK_IS_WX_TREE_MODEL (sortable) ); g_return_if_fail (GTK_IS_WX_TREE_MODEL (sortable) );
g_return_if_fail (func != NULL); g_return_if_fail (func != NULL);
@@ -976,7 +976,7 @@ static void
wxgtk_tree_model_set_default_sort_func (GtkTreeSortable *sortable, wxgtk_tree_model_set_default_sort_func (GtkTreeSortable *sortable,
GtkTreeIterCompareFunc func, GtkTreeIterCompareFunc func,
gpointer WXUNUSED(data), gpointer WXUNUSED(data),
GtkDestroyNotify WXUNUSED(destroy)) GDestroyNotify WXUNUSED(destroy))
{ {
g_return_if_fail (GTK_IS_WX_TREE_MODEL (sortable) ); g_return_if_fail (GTK_IS_WX_TREE_MODEL (sortable) );
g_return_if_fail (func != NULL); g_return_if_fail (func != NULL);
@@ -1333,8 +1333,10 @@ gtk_wx_cell_renderer_get_size (GtkCellRenderer *renderer,
wxSize size = cell->GetSize(); wxSize size = cell->GetSize();
gint calc_width = (gint) renderer->xpad * 2 + size.x; int xpad, ypad;
gint calc_height = (gint) renderer->ypad * 2 + size.y; gtk_cell_renderer_get_padding(renderer, &xpad, &ypad);
int calc_width = xpad * 2 + size.x;
int calc_height = ypad * 2 + size.y;
if (x_offset) if (x_offset)
*x_offset = 0; *x_offset = 0;
@@ -1343,17 +1345,17 @@ gtk_wx_cell_renderer_get_size (GtkCellRenderer *renderer,
if (cell_area && size.x > 0 && size.y > 0) if (cell_area && size.x > 0 && size.y > 0)
{ {
float xalign, yalign;
gtk_cell_renderer_get_alignment(renderer, &xalign, &yalign);
if (x_offset) if (x_offset)
{ {
*x_offset = (gint)((renderer->xalign * *x_offset = int(xalign * (cell_area->width - calc_width - 2 * xpad));
(cell_area->width - calc_width - 2 * renderer->xpad))); *x_offset = MAX(*x_offset, 0) + xpad;
*x_offset = MAX (*x_offset, 0) + renderer->xpad;
} }
if (y_offset) if (y_offset)
{ {
*y_offset = (gint)((renderer->yalign * *y_offset = int(yalign * (cell_area->height - calc_height - 2 * ypad));
(cell_area->height - calc_height - 2 * renderer->ypad))); *y_offset = MAX(*y_offset, 0) + ypad;
*y_offset = MAX (*y_offset, 0) + renderer->ypad;
} }
} }
@@ -1381,7 +1383,9 @@ gtk_wx_cell_renderer_render (GtkCellRenderer *renderer,
background_area, expose_area, flags); background_area, expose_area, flags);
wxRect rect(wxRectFromGDKRect(cell_area)); wxRect rect(wxRectFromGDKRect(cell_area));
rect = rect.Deflate(renderer->xpad, renderer->ypad); int xpad, ypad;
gtk_cell_renderer_get_padding(renderer, &xpad, &ypad);
rect = rect.Deflate(xpad, ypad);
wxWindowDC* dc = (wxWindowDC*) cell->GetDC(); wxWindowDC* dc = (wxWindowDC*) cell->GetDC();
wxWindowDCImpl *impl = (wxWindowDCImpl *) dc->GetImpl(); wxWindowDCImpl *impl = (wxWindowDCImpl *) dc->GetImpl();
@@ -1431,8 +1435,10 @@ gtk_wx_cell_renderer_activate(
rect.x += cell_area->x; rect.x += cell_area->x;
rect.y += cell_area->y; rect.y += cell_area->y;
rect.width -= renderer->xpad * 2; int xpad, ypad;
rect.height -= renderer->ypad * 2; gtk_cell_renderer_get_padding(renderer, &xpad, &ypad);
rect.width -= xpad * 2;
rect.height -= ypad * 2;
wxRect renderrect(wxRectFromGDKRect(&rect)); wxRect renderrect(wxRectFromGDKRect(&rect));
@@ -2303,7 +2309,7 @@ public:
m_context = window->GTKGetPangoDefaultContext(); m_context = window->GTKGetPangoDefaultContext();
m_layout = pango_layout_new( m_context ); m_layout = pango_layout_new( m_context );
m_fontdesc = pango_font_description_copy( widget->style->font_desc ); m_fontdesc = pango_font_description_copy(gtk_widget_get_style(widget)->font_desc);
m_cmap = gtk_widget_get_colormap( widget ? widget : window->m_widget ); m_cmap = gtk_widget_get_colormap( widget ? widget : window->m_widget );
@@ -2349,6 +2355,7 @@ GtkCellRendererText *wxDataViewCustomRenderer::GtkGetTextRenderer() const
// we create it on demand so need to do it even from a const function // we create it on demand so need to do it even from a const function
const_cast<wxDataViewCustomRenderer *>(this)-> const_cast<wxDataViewCustomRenderer *>(this)->
m_text_renderer = GTK_CELL_RENDERER_TEXT(gtk_cell_renderer_text_new()); m_text_renderer = GTK_CELL_RENDERER_TEXT(gtk_cell_renderer_text_new());
g_object_ref_sink(m_text_renderer);
} }
return m_text_renderer; return m_text_renderer;
@@ -2406,7 +2413,7 @@ wxDataViewCustomRenderer::~wxDataViewCustomRenderer()
delete m_dc; delete m_dc;
if (m_text_renderer) if (m_text_renderer)
gtk_object_sink( GTK_OBJECT(m_text_renderer) ); g_object_unref(m_text_renderer);
} }
wxDC *wxDataViewCustomRenderer::GetDC() wxDC *wxDataViewCustomRenderer::GetDC()
@@ -3565,21 +3572,22 @@ gboolean wxDataViewCtrlInternal::drag_data_get( GtkTreeDragSource *WXUNUSED(drag
if ( !item ) if ( !item )
return FALSE; return FALSE;
if (!m_dragDataObject->IsSupported( selection_data->target )) GdkAtom target = gtk_selection_data_get_target(selection_data);
if (!m_dragDataObject->IsSupported(target))
return FALSE; return FALSE;
size_t size = m_dragDataObject->GetDataSize( selection_data->target ); size_t size = m_dragDataObject->GetDataSize(target);
if (size == 0) if (size == 0)
return FALSE; return FALSE;
void *buf = malloc( size ); void *buf = malloc( size );
gboolean res = FALSE; gboolean res = FALSE;
if (m_dragDataObject->GetDataHere( selection_data->target, buf )) if (m_dragDataObject->GetDataHere(target, buf))
{ {
res = TRUE; res = TRUE;
gtk_selection_data_set( selection_data, selection_data->target, gtk_selection_data_set(selection_data, target,
8, (const guchar*) buf, size ); 8, (const guchar*) buf, size );
} }
@@ -3601,9 +3609,9 @@ wxDataViewCtrlInternal::drag_data_received(GtkTreeDragDest *WXUNUSED(drag_dest),
event.SetEventObject( m_owner ); event.SetEventObject( m_owner );
event.SetItem( item ); event.SetItem( item );
event.SetModel( m_wx_model ); event.SetModel( m_wx_model );
event.SetDataFormat( selection_data->target ); event.SetDataFormat(gtk_selection_data_get_target(selection_data));
event.SetDataSize( selection_data->length ); event.SetDataSize(gtk_selection_data_get_length(selection_data));
event.SetDataBuffer( selection_data->data ); event.SetDataBuffer(const_cast<guchar*>(gtk_selection_data_get_data(selection_data)));
if (!m_owner->HandleWindowEvent( event )) if (!m_owner->HandleWindowEvent( event ))
return FALSE; return FALSE;
@@ -3626,7 +3634,7 @@ wxDataViewCtrlInternal::row_drop_possible(GtkTreeDragDest *WXUNUSED(drag_dest),
event.SetEventObject( m_owner ); event.SetEventObject( m_owner );
event.SetItem( item ); event.SetItem( item );
event.SetModel( m_wx_model ); event.SetModel( m_wx_model );
event.SetDataFormat( selection_data->target ); event.SetDataFormat(gtk_selection_data_get_target(selection_data));
if (!m_owner->HandleWindowEvent( event )) if (!m_owner->HandleWindowEvent( event ))
return FALSE; return FALSE;

15
src/gtk/dnd.cpp
View File

@@ -26,6 +26,7 @@
#include "wx/scopeguard.h" #include "wx/scopeguard.h"
#include <gtk/gtk.h> #include <gtk/gtk.h>
#include "wx/gtk/private/gtk2-compat.h"
//---------------------------------------------------------------------------- //----------------------------------------------------------------------------
// global data // global data
@@ -363,7 +364,7 @@ static void target_drag_data_received( GtkWidget *WXUNUSED(widget),
/* Owen Taylor: "call gtk_drag_finish() with /* Owen Taylor: "call gtk_drag_finish() with
success == TRUE" */ success == TRUE" */
if ((data->length <= 0) || (data->format != 8)) if (gtk_selection_data_get_length(data) <= 0 || gtk_selection_data_get_format(data) != 8)
{ {
/* negative data length and non 8-bit data format /* negative data length and non 8-bit data format
qualifies for junk */ qualifies for junk */
@@ -533,12 +534,14 @@ bool wxDropTarget::GetData()
if (!m_dataObject) if (!m_dataObject)
return false; return false;
wxDataFormat dragFormat( m_dragData->target ); wxDataFormat dragFormat(gtk_selection_data_get_target(m_dragData));
if (!m_dataObject->IsSupportedFormat( dragFormat )) if (!m_dataObject->IsSupportedFormat( dragFormat ))
return false; return false;
m_dataObject->SetData( dragFormat, (size_t)m_dragData->length, (const void*)m_dragData->data ); m_dataObject->SetData(dragFormat,
(size_t)gtk_selection_data_get_length(m_dragData),
(const void*)gtk_selection_data_get_data(m_dragData));
return true; return true;
} }
@@ -605,7 +608,7 @@ source_drag_data_get (GtkWidget *WXUNUSED(widget),
guint WXUNUSED(time), guint WXUNUSED(time),
wxDropSource *drop_source ) wxDropSource *drop_source )
{ {
wxDataFormat format( selection_data->target ); wxDataFormat format(gtk_selection_data_get_target(selection_data));
wxLogTrace(TRACE_DND, wxT("Drop source: format requested: %s"), wxLogTrace(TRACE_DND, wxT("Drop source: format requested: %s"),
format.GetId().c_str()); format.GetId().c_str());
@@ -647,7 +650,7 @@ source_drag_data_get (GtkWidget *WXUNUSED(widget),
drop_source->m_retValue = ConvertFromGTK( context->action ); drop_source->m_retValue = ConvertFromGTK( context->action );
gtk_selection_data_set( selection_data, gtk_selection_data_set( selection_data,
selection_data->target, gtk_selection_data_get_target(selection_data),
8, // 8-bit 8, // 8-bit
d, d,
size ); size );
@@ -783,7 +786,7 @@ void wxDropSource::PrepareIcon( int action, GdkDragContext *context )
g_signal_connect (m_iconWindow, "configure_event", g_signal_connect (m_iconWindow, "configure_event",
G_CALLBACK (gtk_dnd_window_configure_callback), this); G_CALLBACK (gtk_dnd_window_configure_callback), this);
gdk_window_set_back_pixmap (m_iconWindow->window, pixmap, FALSE); gdk_window_set_back_pixmap(gtk_widget_get_window(m_iconWindow), pixmap, false);
if (mask) if (mask)
gtk_widget_shape_combine_mask (m_iconWindow, mask, 0, 0); gtk_widget_shape_combine_mask (m_iconWindow, mask, 0, 0);

4
src/gtk/fontdlg.cpp
View File

@@ -106,10 +106,10 @@ bool wxFontDialog::DoCreate(wxWindow *parent)
GtkFontSelectionDialog *sel = GTK_FONT_SELECTION_DIALOG(m_widget); GtkFontSelectionDialog *sel = GTK_FONT_SELECTION_DIALOG(m_widget);
g_signal_connect (sel->ok_button, "clicked", g_signal_connect (gtk_font_selection_dialog_get_ok_button(sel), "clicked",
G_CALLBACK (gtk_fontdialog_ok_callback), this); G_CALLBACK (gtk_fontdialog_ok_callback), this);
g_signal_connect (sel->cancel_button, "clicked", g_signal_connect (gtk_font_selection_dialog_get_cancel_button(sel), "clicked",
G_CALLBACK (gtk_fontdialog_cancel_callback), this); G_CALLBACK (gtk_fontdialog_cancel_callback), this);
g_signal_connect (m_widget, "delete_event", g_signal_connect (m_widget, "delete_event",

2
src/gtk/frame.cpp
View File

@@ -332,7 +332,7 @@ void wxFrame::SetToolBar(wxToolBar *toolbar)
{ {
// Vertical toolbar and m_wxwindow go into an hbox, inside the // Vertical toolbar and m_wxwindow go into an hbox, inside the
// vbox (m_mainWidget). hbox is created on demand. // vbox (m_mainWidget). hbox is created on demand.
GtkWidget* hbox = m_wxwindow->parent; GtkWidget* hbox = gtk_widget_get_parent(m_wxwindow);
if (!GTK_IS_HBOX(hbox)) if (!GTK_IS_HBOX(hbox))
{ {
hbox = gtk_hbox_new(false, 0); hbox = gtk_hbox_new(false, 0);

2
src/gtk/listbox.cpp
View File

@@ -433,7 +433,7 @@ void wxListBox::Update()
wxWindow::Update(); wxWindow::Update();
if (m_treeview) if (m_treeview)
gdk_window_process_updates(GTK_WIDGET(m_treeview)->window, TRUE); gdk_window_process_updates(gtk_widget_get_window(GTK_WIDGET(m_treeview)), true);
} }
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------

24
src/gtk/mdi.cpp
View File

@@ -27,10 +27,7 @@
extern "C" { extern "C" {
static void static void
gtk_mdi_page_change_callback( GtkNotebook *WXUNUSED(widget), switch_page(GtkNotebook* widget, GtkNotebookPage*, guint page_num, wxMDIParentFrame* parent)
GtkNotebookPage *page,
gint WXUNUSED(page_num),
wxMDIParentFrame *parent )
{ {
// send deactivate event to old child // send deactivate event to old child
@@ -49,6 +46,7 @@ gtk_mdi_page_change_callback( GtkNotebook *WXUNUSED(widget),
return; return;
child = NULL; child = NULL;
GtkWidget* page = gtk_notebook_get_nth_page(widget, page_num);
wxWindowList::compatibility_iterator node = client_window->GetChildren().GetFirst(); wxWindowList::compatibility_iterator node = client_window->GetChildren().GetFirst();
while ( node ) while ( node )
@@ -58,7 +56,7 @@ gtk_mdi_page_change_callback( GtkNotebook *WXUNUSED(widget),
// child_frame can be NULL when this is called from dtor, probably // child_frame can be NULL when this is called from dtor, probably
// because g_signal_connect (m_widget, "switch_page", (see below) // because g_signal_connect (m_widget, "switch_page", (see below)
// isn't deleted early enough // isn't deleted early enough
if ( child_frame && child_frame->m_page == page ) if (child_frame && child_frame->m_widget == page)
{ {
child = child_frame; child = child_frame;
break; break;
@@ -114,7 +112,7 @@ void wxMDIParentFrame::OnInternalIdle()
if (m_justInserted) if (m_justInserted)
{ {
GtkNotebook *notebook = GTK_NOTEBOOK(m_clientWindow->m_widget); GtkNotebook *notebook = GTK_NOTEBOOK(m_clientWindow->m_widget);
gtk_notebook_set_current_page( notebook, g_list_length( notebook->children ) - 1 ); gtk_notebook_set_current_page(notebook, -1);
/* need to set the menubar of the child */ /* need to set the menubar of the child */
wxMDIChildFrame *active_child_frame = GetActiveChild(); wxMDIChildFrame *active_child_frame = GetActiveChild();
@@ -220,7 +218,7 @@ wxMDIChildFrame *wxMDIParentFrame::GetActiveChild() const
gint i = gtk_notebook_get_current_page( notebook ); gint i = gtk_notebook_get_current_page( notebook );
if (i < 0) return NULL; if (i < 0) return NULL;
GtkNotebookPage* page = (GtkNotebookPage*) (g_list_nth(notebook->children,i)->data); GtkWidget* page = gtk_notebook_get_nth_page(notebook, i);
if (!page) return NULL; if (!page) return NULL;
wxWindowList::compatibility_iterator node = m_clientWindow->GetChildren().GetFirst(); wxWindowList::compatibility_iterator node = m_clientWindow->GetChildren().GetFirst();
@@ -234,7 +232,7 @@ wxMDIChildFrame *wxMDIParentFrame::GetActiveChild() const
if (!child_frame) if (!child_frame)
return NULL; return NULL;
if (child_frame->m_page == page) if (child_frame->m_widget == page)
return child_frame; return child_frame;
node = node->GetNext(); node = node->GetNext();
@@ -269,7 +267,6 @@ END_EVENT_TABLE()
void wxMDIChildFrame::Init() void wxMDIChildFrame::Init()
{ {
m_menuBar = NULL; m_menuBar = NULL;
m_page = NULL;
} }
bool wxMDIChildFrame::Create(wxMDIParentFrame *parent, bool wxMDIChildFrame::Create(wxMDIParentFrame *parent,
@@ -391,9 +388,7 @@ wxMDIClientWindow::~wxMDIClientWindow()
// a call to gtk_mdi_page_change_callback with an invalid parent // a call to gtk_mdi_page_change_callback with an invalid parent
// (because gtk_mdi_page_change_callback expects a wxMDIClientWindow but // (because gtk_mdi_page_change_callback expects a wxMDIClientWindow but
// at that point of the dtor chain we are a simple wxWindow!) // at that point of the dtor chain we are a simple wxWindow!)
g_signal_handlers_disconnect_by_func(m_widget, g_signal_handlers_disconnect_by_func(m_widget, (void*)switch_page, GetParent());
(gpointer)gtk_mdi_page_change_callback,
GetParent());
} }
bool wxMDIClientWindow::CreateClient(wxMDIParentFrame *parent, long style) bool wxMDIClientWindow::CreateClient(wxMDIParentFrame *parent, long style)
@@ -409,8 +404,7 @@ bool wxMDIClientWindow::CreateClient(wxMDIParentFrame *parent, long style)
m_widget = gtk_notebook_new(); m_widget = gtk_notebook_new();
g_object_ref(m_widget); g_object_ref(m_widget);
g_signal_connect (m_widget, "switch_page", g_signal_connect(m_widget, "switch_page", G_CALLBACK(switch_page), parent);
G_CALLBACK (gtk_mdi_page_change_callback), parent);
gtk_notebook_set_scrollable( GTK_NOTEBOOK(m_widget), 1 ); gtk_notebook_set_scrollable( GTK_NOTEBOOK(m_widget), 1 );
@@ -437,8 +431,6 @@ void wxMDIClientWindow::AddChildGTK(wxWindowGTK* child)
gtk_notebook_append_page( notebook, child->m_widget, label_widget ); gtk_notebook_append_page( notebook, child->m_widget, label_widget );
child_frame->m_page = (GtkNotebookPage*) (g_list_last(notebook->children)->data);
wxMDIParentFrame* parent_frame = static_cast<wxMDIParentFrame*>(GetParent()); wxMDIParentFrame* parent_frame = static_cast<wxMDIParentFrame*>(GetParent());
parent_frame->m_justInserted = true; parent_frame->m_justInserted = true;
} }

9
src/gtk/menu.cpp
View File

@@ -440,7 +440,7 @@ void wxMenuBar::SetMenuLabel( size_t pos, const wxString& label )
menu->SetTitle( str ); menu->SetTitle( str );
if (menu->m_owner) if (menu->m_owner)
gtk_label_set_text_with_mnemonic( GTK_LABEL( GTK_BIN(menu->m_owner)->child), wxGTK_CONV(str) ); gtk_label_set_text_with_mnemonic(GTK_LABEL(gtk_bin_get_child(GTK_BIN(menu->m_owner))), wxGTK_CONV(str));
} }
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
@@ -581,7 +581,7 @@ void wxMenuItem::SetItemLabel( const wxString& str )
void wxMenuItem::SetGtkLabel() void wxMenuItem::SetGtkLabel()
{ {
const wxString text = wxConvertMnemonicsToGTK(m_text.BeforeFirst('\t')); const wxString text = wxConvertMnemonicsToGTK(m_text.BeforeFirst('\t'));
GtkLabel* label = GTK_LABEL(GTK_BIN(m_menuItem)->child); GtkLabel* label = GTK_LABEL(gtk_bin_get_child(GTK_BIN(m_menuItem)));
gtk_label_set_text_with_mnemonic(label, wxGTK_CONV_SYS(text)); gtk_label_set_text_with_mnemonic(label, wxGTK_CONV_SYS(text));
#if wxUSE_ACCEL #if wxUSE_ACCEL
guint accel_key; guint accel_key;
@@ -640,7 +640,7 @@ bool wxMenuItem::IsChecked() const
wxCHECK_MSG( IsCheckable(), false, wxCHECK_MSG( IsCheckable(), false,
wxT("can't get state of uncheckable item!") ); wxT("can't get state of uncheckable item!") );
return ((GtkCheckMenuItem*)m_menuItem)->active != 0; return gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(m_menuItem)) != 0;
} }
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
@@ -682,8 +682,7 @@ void wxMenu::Init()
m_menu = gtk_menu_new(); m_menu = gtk_menu_new();
// NB: keep reference to the menu so that it is not destroyed behind // NB: keep reference to the menu so that it is not destroyed behind
// our back by GTK+ e.g. when it is removed from menubar: // our back by GTK+ e.g. when it is removed from menubar:
g_object_ref(m_menu); g_object_ref_sink(m_menu);
gtk_object_sink(GTK_OBJECT(m_menu));
m_owner = NULL; m_owner = NULL;

39
src/gtk/minifram.cpp
View File

@@ -23,6 +23,7 @@
#include "wx/gtk/dcclient.h" #include "wx/gtk/dcclient.h"
#include <gtk/gtk.h> #include <gtk/gtk.h>
#include "wx/gtk/private/gtk2-compat.h"
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// data // data
@@ -61,13 +62,13 @@ extern "C" {
static gboolean gtk_window_own_expose_callback(GtkWidget* widget, GdkEventExpose* gdk_event, wxMiniFrame* win) static gboolean gtk_window_own_expose_callback(GtkWidget* widget, GdkEventExpose* gdk_event, wxMiniFrame* win)
{ {
if (!win->m_hasVMT || gdk_event->count > 0 || if (!win->m_hasVMT || gdk_event->count > 0 ||
gdk_event->window != widget->window) gdk_event->window != gtk_widget_get_window(widget))
{ {
return false; return false;
} }
gtk_paint_shadow (widget->style, gtk_paint_shadow (gtk_widget_get_style(widget),
widget->window, gtk_widget_get_window(widget),
GTK_STATE_NORMAL, GTK_STATE_NORMAL,
GTK_SHADOW_OUT, GTK_SHADOW_OUT,
NULL, NULL, NULL, // FIXME: No clipping? NULL, NULL, NULL, // FIXME: No clipping?
@@ -80,7 +81,7 @@ static gboolean gtk_window_own_expose_callback(GtkWidget* widget, GdkEventExpose
wxDCImpl *impl = dc.GetImpl(); wxDCImpl *impl = dc.GetImpl();
wxClientDCImpl *gtk_impl = wxDynamicCast( impl, wxClientDCImpl ); wxClientDCImpl *gtk_impl = wxDynamicCast( impl, wxClientDCImpl );
gtk_impl->m_gdkwindow = widget->window; // Hack alert gtk_impl->m_gdkwindow = gtk_widget_get_window(widget); // Hack alert
if (style & wxRESIZE_BORDER) if (style & wxRESIZE_BORDER)
{ {
@@ -120,7 +121,7 @@ extern "C" {
static gboolean static gboolean
gtk_window_button_press_callback(GtkWidget* widget, GdkEventButton* gdk_event, wxMiniFrame* win) gtk_window_button_press_callback(GtkWidget* widget, GdkEventButton* gdk_event, wxMiniFrame* win)
{ {
if (!win->m_hasVMT || gdk_event->window != widget->window) if (!win->m_hasVMT || gdk_event->window != gtk_widget_get_window(widget))
return false; return false;
if (g_blockEventsOnDrag) return TRUE; if (g_blockEventsOnDrag) return TRUE;
if (g_blockEventsOnScroll) return TRUE; if (g_blockEventsOnScroll) return TRUE;
@@ -137,7 +138,7 @@ gtk_window_button_press_callback(GtkWidget* widget, GdkEventButton* gdk_event, w
{ {
GtkWidget *ancestor = gtk_widget_get_toplevel( widget ); GtkWidget *ancestor = gtk_widget_get_toplevel( widget );
GdkWindow *source = widget->window; GdkWindow *source = gtk_widget_get_window(widget);
int org_x = 0; int org_x = 0;
int org_y = 0; int org_y = 0;
@@ -165,9 +166,9 @@ gtk_window_button_press_callback(GtkWidget* widget, GdkEventButton* gdk_event, w
if (y >= win->m_miniEdge + win->m_miniTitle) if (y >= win->m_miniEdge + win->m_miniTitle)
return true; return true;
gdk_window_raise( win->m_widget->window ); gdk_window_raise(gtk_widget_get_window(win->m_widget));
gdk_pointer_grab( widget->window, FALSE, gdk_pointer_grab( gtk_widget_get_window(widget), false,
(GdkEventMask) (GdkEventMask)
(GDK_BUTTON_PRESS_MASK | (GDK_BUTTON_PRESS_MASK |
GDK_BUTTON_RELEASE_MASK | GDK_BUTTON_RELEASE_MASK |
@@ -198,7 +199,7 @@ extern "C" {
static gboolean static gboolean
gtk_window_button_release_callback(GtkWidget* widget, GdkEventButton* gdk_event, wxMiniFrame* win) gtk_window_button_release_callback(GtkWidget* widget, GdkEventButton* gdk_event, wxMiniFrame* win)
{ {
if (!win->m_hasVMT || gdk_event->window != widget->window) if (!win->m_hasVMT || gdk_event->window != gtk_widget_get_window(widget))
return false; return false;
if (g_blockEventsOnDrag) return TRUE; if (g_blockEventsOnDrag) return TRUE;
if (g_blockEventsOnScroll) return TRUE; if (g_blockEventsOnScroll) return TRUE;
@@ -212,7 +213,7 @@ gtk_window_button_release_callback(GtkWidget* widget, GdkEventButton* gdk_event,
gdk_pointer_ungrab ( (guint32)GDK_CURRENT_TIME ); gdk_pointer_ungrab ( (guint32)GDK_CURRENT_TIME );
int org_x = 0; int org_x = 0;
int org_y = 0; int org_y = 0;
gdk_window_get_origin( widget->window, &org_x, &org_y ); gdk_window_get_origin(gtk_widget_get_window(widget), &org_x, &org_y);
x += org_x - win->m_diffX; x += org_x - win->m_diffX;
y += org_y - win->m_diffY; y += org_y - win->m_diffY;
win->m_x = x; win->m_x = x;
@@ -235,10 +236,10 @@ gtk_window_leave_callback(GtkWidget *widget,
{ {
if (!win->m_hasVMT) return FALSE; if (!win->m_hasVMT) return FALSE;
if (g_blockEventsOnDrag) return FALSE; if (g_blockEventsOnDrag) return FALSE;
if (gdk_event->window != widget->window) if (gdk_event->window != gtk_widget_get_window(widget))
return false; return false;
gdk_window_set_cursor( widget->window, NULL ); gdk_window_set_cursor(gtk_widget_get_window(widget), NULL);
return FALSE; return FALSE;
} }
@@ -252,7 +253,7 @@ extern "C" {
static gboolean static gboolean
gtk_window_motion_notify_callback( GtkWidget *widget, GdkEventMotion *gdk_event, wxMiniFrame *win ) gtk_window_motion_notify_callback( GtkWidget *widget, GdkEventMotion *gdk_event, wxMiniFrame *win )
{ {
if (!win->m_hasVMT || gdk_event->window != widget->window) if (!win->m_hasVMT || gdk_event->window != gtk_widget_get_window(widget))
return false; return false;
if (g_blockEventsOnDrag) return TRUE; if (g_blockEventsOnDrag) return TRUE;
if (g_blockEventsOnScroll) return TRUE; if (g_blockEventsOnScroll) return TRUE;
@@ -278,9 +279,9 @@ gtk_window_motion_notify_callback( GtkWidget *widget, GdkEventMotion *gdk_event,
if (style & wxRESIZE_BORDER) if (style & wxRESIZE_BORDER)
{ {
if ((x > win->m_width-14) && (y > win->m_height-14)) if ((x > win->m_width-14) && (y > win->m_height-14))
gdk_window_set_cursor( widget->window, gdk_cursor_new( GDK_BOTTOM_RIGHT_CORNER ) ); gdk_window_set_cursor(gtk_widget_get_window(widget), gdk_cursor_new(GDK_BOTTOM_RIGHT_CORNER));
else else
gdk_window_set_cursor( widget->window, NULL ); gdk_window_set_cursor(gtk_widget_get_window(widget), NULL);
win->GTKUpdateCursor(false); win->GTKUpdateCursor(false);
} }
return TRUE; return TRUE;
@@ -291,7 +292,7 @@ gtk_window_motion_notify_callback( GtkWidget *widget, GdkEventMotion *gdk_event,
int org_x = 0; int org_x = 0;
int org_y = 0; int org_y = 0;
gdk_window_get_origin( widget->window, &org_x, &org_y ); gdk_window_get_origin(gtk_widget_get_window(widget), &org_x, &org_y);
x += org_x - win->m_diffX; x += org_x - win->m_diffX;
y += org_y - win->m_diffY; y += org_y - win->m_diffY;
win->m_x = x; win->m_x = x;
@@ -423,9 +424,9 @@ void wxMiniFrame::SetTitle( const wxString &title )
{ {
wxFrame::SetTitle( title ); wxFrame::SetTitle( title );
GtkWidget* widget = GTK_BIN(m_widget)->child; GdkWindow* window = gtk_widget_get_window(gtk_bin_get_child(GTK_BIN(m_widget)));
if (widget->window) if (window)
gdk_window_invalidate_rect(widget->window, NULL, false); gdk_window_invalidate_rect(window, NULL, false);
} }
#endif // wxUSE_MINIFRAME #endif // wxUSE_MINIFRAME

5
src/gtk/nativewin.cpp
View File

@@ -29,6 +29,7 @@
#include "wx/nativewin.h" #include "wx/nativewin.h"
#include <gtk/gtk.h> #include <gtk/gtk.h>
#include "wx/gtk/private/gtk2-compat.h"
#ifdef GDK_WINDOWING_X11 #ifdef GDK_WINDOWING_X11
#include <X11/Xlib.h> #include <X11/Xlib.h>
@@ -71,7 +72,7 @@ bool wxNativeContainerWindow::Create(wxNativeContainerWindowHandle win)
// we need to realize the window first before reparenting it // we need to realize the window first before reparenting it
gtk_widget_realize(m_widget); gtk_widget_realize(m_widget);
gdk_window_reparent(m_widget->window, win, 0, 0); gdk_window_reparent(gtk_widget_get_window(m_widget), win, 0, 0);
#ifdef GDK_WINDOWING_X11 #ifdef GDK_WINDOWING_X11
// if the native window is destroyed, our own window will be destroyed too // if the native window is destroyed, our own window will be destroyed too
@@ -79,7 +80,7 @@ bool wxNativeContainerWindow::Create(wxNativeContainerWindowHandle win)
// destroyed" GdkWindow, so intercept to DestroyNotify ourselves to fix // destroyed" GdkWindow, so intercept to DestroyNotify ourselves to fix
// this and also destroy the associated C++ object when its window is // this and also destroy the associated C++ object when its window is
// destroyed // destroyed
gdk_window_add_filter(m_widget->window, wxNativeContainerWindowFilter, this); gdk_window_add_filter(gtk_widget_get_window(m_widget), wxNativeContainerWindowFilter, this);
#endif // GDK_WINDOWING_X11 #endif // GDK_WINDOWING_X11
// we should be initially visible as we suppose that the native window we // we should be initially visible as we suppose that the native window we

22
src/gtk/notebook.cpp
View File

@@ -434,7 +434,7 @@ bool wxNotebook::InsertPage( size_t position,
if ( style ) if ( style )
{ {
gtk_widget_modify_style(pageData->m_label, style); gtk_widget_modify_style(pageData->m_label, style);
gtk_rc_style_unref(style); g_object_unref(style);
} }
if (select && GetPageCount() > 1) if (select && GetPageCount() > 1)
@@ -453,24 +453,30 @@ static bool
IsPointInsideWidget(const wxPoint& pt, GtkWidget *w, IsPointInsideWidget(const wxPoint& pt, GtkWidget *w,
gint x, gint y, gint border = 0) gint x, gint y, gint border = 0)
{ {
GtkAllocation a;
gtk_widget_get_allocation(w, &a);
return return
(pt.x >= w->allocation.x - x - border) && (pt.x >= a.x - x - border) &&
(pt.x <= w->allocation.x - x + border + w->allocation.width) && (pt.x <= a.x - x + border + a.width) &&
(pt.y >= w->allocation.y - y - border) && (pt.y >= a.y - y - border) &&
(pt.y <= w->allocation.y - y + border + w->allocation.height); (pt.y <= a.y - y + border + a.height);
} }
int wxNotebook::HitTest(const wxPoint& pt, long *flags) const int wxNotebook::HitTest(const wxPoint& pt, long *flags) const
{ {
const gint x = m_widget->allocation.x; GtkAllocation a;
const gint y = m_widget->allocation.y; gtk_widget_get_allocation(m_widget, &a);
const int x = a.x;
const int y = a.y;
const size_t count = GetPageCount(); const size_t count = GetPageCount();
size_t i = 0; size_t i = 0;
#if !GTK_CHECK_VERSION(3,0,0) && !defined(GSEAL_ENABLE)
GtkNotebook * notebook = GTK_NOTEBOOK(m_widget); GtkNotebook * notebook = GTK_NOTEBOOK(m_widget);
if (gtk_notebook_get_scrollable(notebook)) if (gtk_notebook_get_scrollable(notebook))
i = g_list_position( notebook->children, notebook->first_tab ); i = g_list_position( notebook->children, notebook->first_tab );
#endif
for ( ; i < count; i++ ) for ( ; i < count; i++ )
{ {
@@ -556,7 +562,7 @@ void wxNotebook::DoApplyWidgetStyle(GtkRcStyle *style)
GdkWindow *wxNotebook::GTKGetWindow(wxArrayGdkWindows& windows) const GdkWindow *wxNotebook::GTKGetWindow(wxArrayGdkWindows& windows) const
{ {
windows.push_back(m_widget->window); windows.push_back(gtk_widget_get_window(m_widget));
windows.push_back(GTK_NOTEBOOK(m_widget)->event_window); windows.push_back(GTK_NOTEBOOK(m_widget)->event_window);
return NULL; return NULL;

2
src/gtk/popupwin.cpp
View File

@@ -46,7 +46,7 @@ static gint gtk_popup_button_press (GtkWidget *widget, GdkEvent *gdk_event, wxPo
{ {
if (child == widget) if (child == widget)
return FALSE; return FALSE;
child = child->parent; child = gtk_widget_get_parent(child);
} }
} }

20
src/gtk/radiobox.cpp
View File

@@ -59,7 +59,7 @@ static void gtk_radiobutton_clicked_callback( GtkToggleButton *button, wxRadioBo
if (!rb->m_hasVMT) return; if (!rb->m_hasVMT) return;
if (g_blockEventsOnDrag) return; if (g_blockEventsOnDrag) return;
if (!button->active) return; if (!gtk_toggle_button_get_active(button)) return;
wxCommandEvent event( wxEVT_COMMAND_RADIOBOX_SELECTED, rb->GetId() ); wxCommandEvent event( wxEVT_COMMAND_RADIOBOX_SELECTED, rb->GetId() );
event.SetInt( rb->GetSelection() ); event.SetInt( rb->GetSelection() );
@@ -379,7 +379,7 @@ int wxRadioBox::GetSelection(void) const
while (node) while (node)
{ {
GtkToggleButton *button = GTK_TOGGLE_BUTTON( node->GetData()->button ); GtkToggleButton *button = GTK_TOGGLE_BUTTON( node->GetData()->button );
if (button->active) return count; if (gtk_toggle_button_get_active(button)) return count;
count++; count++;
node = node->GetNext(); node = node->GetNext();
} }
@@ -397,7 +397,7 @@ wxString wxRadioBox::GetString(unsigned int n) const
wxCHECK_MSG( node, wxEmptyString, wxT("radiobox wrong index") ); wxCHECK_MSG( node, wxEmptyString, wxT("radiobox wrong index") );
GtkLabel *label = GTK_LABEL(GTK_BIN(node->GetData()->button)->child); GtkLabel* label = GTK_LABEL(gtk_bin_get_child(GTK_BIN(node->GetData()->button)));
wxString str( wxGTK_CONV_BACK( gtk_label_get_text(label) ) ); wxString str( wxGTK_CONV_BACK( gtk_label_get_text(label) ) );
@@ -419,7 +419,7 @@ void wxRadioBox::SetString(unsigned int item, const wxString& label)
wxCHECK_RET( node, wxT("radiobox wrong index") ); wxCHECK_RET( node, wxT("radiobox wrong index") );
GtkLabel *g_label = GTK_LABEL(GTK_BIN(node->GetData()->button)->child); GtkLabel* g_label = GTK_LABEL(gtk_bin_get_child(GTK_BIN(node->GetData()->button)));
gtk_label_set_text( g_label, wxGTK_CONV( label ) ); gtk_label_set_text( g_label, wxGTK_CONV( label ) );
} }
@@ -433,7 +433,7 @@ bool wxRadioBox::Enable( bool enable )
while (node) while (node)
{ {
GtkButton *button = GTK_BUTTON( node->GetData()->button ); GtkButton *button = GTK_BUTTON( node->GetData()->button );
GtkLabel *label = GTK_LABEL(GTK_BIN(button)->child); GtkLabel *label = GTK_LABEL(gtk_bin_get_child(GTK_BIN(button)));
gtk_widget_set_sensitive( GTK_WIDGET(button), enable ); gtk_widget_set_sensitive( GTK_WIDGET(button), enable );
gtk_widget_set_sensitive( GTK_WIDGET(label), enable ); gtk_widget_set_sensitive( GTK_WIDGET(label), enable );
@@ -455,7 +455,7 @@ bool wxRadioBox::Enable(unsigned int item, bool enable)
wxCHECK_MSG( node, false, wxT("radiobox wrong index") ); wxCHECK_MSG( node, false, wxT("radiobox wrong index") );
GtkButton *button = GTK_BUTTON( node->GetData()->button ); GtkButton *button = GTK_BUTTON( node->GetData()->button );
GtkLabel *label = GTK_LABEL(GTK_BIN(button)->child); GtkLabel *label = GTK_LABEL(gtk_bin_get_child(GTK_BIN(button)));
gtk_widget_set_sensitive( GTK_WIDGET(button), enable ); gtk_widget_set_sensitive( GTK_WIDGET(button), enable );
gtk_widget_set_sensitive( GTK_WIDGET(label), enable ); gtk_widget_set_sensitive( GTK_WIDGET(label), enable );
@@ -548,7 +548,7 @@ void wxRadioBox::DoApplyWidgetStyle(GtkRcStyle *style)
GtkWidget *widget = GTK_WIDGET( node->GetData()->button ); GtkWidget *widget = GTK_WIDGET( node->GetData()->button );
gtk_widget_modify_style( widget, style ); gtk_widget_modify_style( widget, style );
gtk_widget_modify_style(GTK_BIN(widget)->child, style); gtk_widget_modify_style(gtk_bin_get_child(GTK_BIN(widget)), style);
node = node->GetNext(); node = node->GetNext();
} }
@@ -595,7 +595,7 @@ void wxRadioBox::DoSetItemToolTip(unsigned int n, wxToolTip *tooltip)
GdkWindow *wxRadioBox::GTKGetWindow(wxArrayGdkWindows& windows) const GdkWindow *wxRadioBox::GTKGetWindow(wxArrayGdkWindows& windows) const
{ {
windows.push_back(m_widget->window); windows.push_back(gtk_widget_get_window(m_widget));
wxRadioBoxButtonsInfoList::compatibility_iterator node = m_buttonsInfo.GetFirst(); wxRadioBoxButtonsInfoList::compatibility_iterator node = m_buttonsInfo.GetFirst();
while (node) while (node)
@@ -603,8 +603,8 @@ GdkWindow *wxRadioBox::GTKGetWindow(wxArrayGdkWindows& windows) const
GtkWidget *button = GTK_WIDGET( node->GetData()->button ); GtkWidget *button = GTK_WIDGET( node->GetData()->button );
// don't put NULL pointers in the 'windows' array! // don't put NULL pointers in the 'windows' array!
if (button->window) if (gtk_widget_get_window(button))
windows.push_back(button->window); windows.push_back(gtk_widget_get_window(button));
node = node->GetNext(); node = node->GetNext();
} }

10
src/gtk/radiobut.cpp
View File

@@ -34,7 +34,7 @@ void gtk_radiobutton_clicked_callback( GtkToggleButton *button, wxRadioButton *r
if (g_blockEventsOnDrag) return; if (g_blockEventsOnDrag) return;
if (!button->active) return; if (!gtk_toggle_button_get_active(button)) return;
wxCommandEvent event( wxEVT_COMMAND_RADIOBUTTON_SELECTED, rb->GetId()); wxCommandEvent event( wxEVT_COMMAND_RADIOBUTTON_SELECTED, rb->GetId());
event.SetInt( rb->GetValue() ); event.SetInt( rb->GetValue() );
@@ -102,7 +102,7 @@ void wxRadioButton::SetLabel( const wxString& label )
// save the original label // save the original label
wxControlBase::SetLabel(label); wxControlBase::SetLabel(label);
GTKSetLabelForLabel(GTK_LABEL(GTK_BIN(m_widget)->child), label); GTKSetLabelForLabel(GTK_LABEL(gtk_bin_get_child(GTK_BIN(m_widget))), label);
} }
void wxRadioButton::SetValue( bool val ) void wxRadioButton::SetValue( bool val )
@@ -134,7 +134,7 @@ bool wxRadioButton::GetValue() const
{ {
wxCHECK_MSG( m_widget != NULL, false, wxT("invalid radiobutton") ); wxCHECK_MSG( m_widget != NULL, false, wxT("invalid radiobutton") );
return GTK_TOGGLE_BUTTON(m_widget)->active; return gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(m_widget)) != 0;
} }
bool wxRadioButton::Enable( bool enable ) bool wxRadioButton::Enable( bool enable )
@@ -142,7 +142,7 @@ bool wxRadioButton::Enable( bool enable )
if (!base_type::Enable(enable)) if (!base_type::Enable(enable))
return false; return false;
gtk_widget_set_sensitive(GTK_BIN(m_widget)->child, enable); gtk_widget_set_sensitive(gtk_bin_get_child(GTK_BIN(m_widget)), enable);
if (enable) if (enable)
GTKFixSensitivity(); GTKFixSensitivity();
@@ -153,7 +153,7 @@ bool wxRadioButton::Enable( bool enable )
void wxRadioButton::DoApplyWidgetStyle(GtkRcStyle *style) void wxRadioButton::DoApplyWidgetStyle(GtkRcStyle *style)
{ {
gtk_widget_modify_style(m_widget, style); gtk_widget_modify_style(m_widget, style);
gtk_widget_modify_style(GTK_BIN(m_widget)->child, style); gtk_widget_modify_style(gtk_bin_get_child(GTK_BIN(m_widget)), style);
} }
GdkWindow * GdkWindow *

38
src/gtk/renderer.cpp
View File

@@ -205,7 +205,7 @@ wxRendererGTK::DrawHeaderButton(wxWindow *win,
gtk_paint_box gtk_paint_box
( (
button->style, gtk_widget_get_style(button),
gdk_window, gdk_window,
state, state,
GTK_SHADOW_OUT, GTK_SHADOW_OUT,
@@ -260,7 +260,7 @@ wxRendererGTK::DrawTreeItemButton(wxWindow* win,
// in the given rectangle, +2/3 below is just what looks good here... // in the given rectangle, +2/3 below is just what looks good here...
gtk_paint_expander gtk_paint_expander
( (
tree->style, gtk_widget_get_style(tree),
gdk_window, gdk_window,
state, state,
NULL, NULL,
@@ -315,7 +315,7 @@ wxRendererGTK::DrawSplitterSash(wxWindow* win,
wxOrientation orient, wxOrientation orient,
int flags) int flags)
{ {
if ( !win->m_wxwindow->window ) if (gtk_widget_get_window(win->m_wxwindow) == NULL)
{ {
// window not realized yet // window not realized yet
return; return;
@@ -353,7 +353,7 @@ wxRendererGTK::DrawSplitterSash(wxWindow* win,
gtk_paint_handle gtk_paint_handle
( (
win->m_wxwindow->style, gtk_widget_get_style(win->m_wxwindow),
gdk_window, gdk_window,
flags & wxCONTROL_CURRENT ? GTK_STATE_PRELIGHT : GTK_STATE_NORMAL, flags & wxCONTROL_CURRENT ? GTK_STATE_PRELIGHT : GTK_STATE_NORMAL,
GTK_SHADOW_NONE, GTK_SHADOW_NONE,
@@ -409,7 +409,7 @@ wxRendererGTK::DrawDropArrow(wxWindow* win,
// draw arrow on button // draw arrow on button
gtk_paint_arrow gtk_paint_arrow
( (
button->style, gtk_widget_get_style(button),
gdk_window, gdk_window,
state, state,
flags & wxCONTROL_PRESSED ? GTK_SHADOW_IN : GTK_SHADOW_OUT, flags & wxCONTROL_PRESSED ? GTK_SHADOW_IN : GTK_SHADOW_OUT,
@@ -488,7 +488,7 @@ wxRendererGTK::DrawCheckBox(wxWindow* win,
gtk_paint_check gtk_paint_check
( (
button->style, gtk_widget_get_style(button),
gdk_window, gdk_window,
state, state,
shadow_type, shadow_type,
@@ -527,7 +527,7 @@ wxRendererGTK::DrawPushButton(wxWindow* win,
gtk_paint_box gtk_paint_box
( (
button->style, gtk_widget_get_style(button),
gdk_window, gdk_window,
state, state,
flags & wxCONTROL_PRESSED ? GTK_SHADOW_IN : GTK_SHADOW_OUT, flags & wxCONTROL_PRESSED ? GTK_SHADOW_IN : GTK_SHADOW_OUT,
@@ -559,7 +559,7 @@ wxRendererGTK::DrawItemSelectionRect(wxWindow* win,
// the wxCONTROL_FOCUSED state is deduced // the wxCONTROL_FOCUSED state is deduced
// directly from the m_wxwindow by GTK+ // directly from the m_wxwindow by GTK+
gtk_paint_flat_box(wxGTKPrivate::GetTreeWidget()->style, gtk_paint_flat_box(gtk_widget_get_style(wxGTKPrivate::GetTreeWidget()),
gdk_window, gdk_window,
GTK_STATE_SELECTED, GTK_STATE_SELECTED,
GTK_SHADOW_NONE, GTK_SHADOW_NONE,
@@ -588,7 +588,7 @@ void wxRendererGTK::DrawFocusRect(wxWindow* win, wxDC& dc, const wxRect& rect, i
else else
state = GTK_STATE_NORMAL; state = GTK_STATE_NORMAL;
gtk_paint_focus( win->m_widget->style, gtk_paint_focus( gtk_widget_get_style(win->m_widget),
gdk_window, gdk_window,
state, state,
NULL, NULL,
@@ -611,14 +611,11 @@ void wxRendererGTK::DrawTextCtrl(wxWindow* win, wxDC& dc, const wxRect& rect, in
if ( flags & wxCONTROL_DISABLED ) if ( flags & wxCONTROL_DISABLED )
state = GTK_STATE_INSENSITIVE; state = GTK_STATE_INSENSITIVE;
if (flags & wxCONTROL_CURRENT ) gtk_widget_set_can_focus(entry, (flags & wxCONTROL_CURRENT) != 0);
GTK_WIDGET_SET_FLAGS( entry, GTK_HAS_FOCUS );
else
GTK_WIDGET_UNSET_FLAGS( entry, GTK_HAS_FOCUS );
gtk_paint_shadow gtk_paint_shadow
( (
entry->style, gtk_widget_get_style(entry),
gdk_window, gdk_window,
state, state,
GTK_SHADOW_OUT, GTK_SHADOW_OUT,
@@ -643,14 +640,11 @@ void wxRendererGTK::DrawComboBox(wxWindow* win, wxDC& dc, const wxRect& rect, in
if ( flags & wxCONTROL_DISABLED ) if ( flags & wxCONTROL_DISABLED )
state = GTK_STATE_INSENSITIVE; state = GTK_STATE_INSENSITIVE;
if (flags & wxCONTROL_CURRENT ) gtk_widget_set_can_focus(combo, (flags & wxCONTROL_CURRENT) != 0);
GTK_WIDGET_SET_FLAGS( combo, GTK_HAS_FOCUS );
else
GTK_WIDGET_UNSET_FLAGS( combo, GTK_HAS_FOCUS );
gtk_paint_shadow gtk_paint_shadow
( (
combo->style, gtk_widget_get_style(combo),
gdk_window, gdk_window,
state, state,
GTK_SHADOW_OUT, GTK_SHADOW_OUT,
@@ -672,7 +666,7 @@ void wxRendererGTK::DrawComboBox(wxWindow* win, wxDC& dc, const wxRect& rect, in
gtk_paint_arrow gtk_paint_arrow
( (
combo->style, gtk_widget_get_style(combo),
gdk_window, gdk_window,
state, state,
GTK_SHADOW_OUT, GTK_SHADOW_OUT,
@@ -693,7 +687,7 @@ void wxRendererGTK::DrawComboBox(wxWindow* win, wxDC& dc, const wxRect& rect, in
gtk_paint_box gtk_paint_box
( (
combo->style, gtk_widget_get_style(combo),
gdk_window, gdk_window,
state, state,
GTK_SHADOW_ETCHED_OUT, GTK_SHADOW_ETCHED_OUT,
@@ -740,7 +734,7 @@ void wxRendererGTK::DrawRadioBitmap(wxWindow* win, wxDC& dc, const wxRect& rect,
gtk_paint_option gtk_paint_option
( (
button->style, gtk_widget_get_style(button),
gdk_window, gdk_window,
state, state,
shadow_type, shadow_type,

33
src/gtk/scrolbar.cpp
View File

@@ -167,26 +167,25 @@ bool wxScrollBar::Create(wxWindow *parent, wxWindowID id,
int wxScrollBar::GetThumbPosition() const int wxScrollBar::GetThumbPosition() const
{ {
GtkAdjustment* adj = ((GtkRange*)m_widget)->adjustment; return wxRound(gtk_range_get_value(GTK_RANGE(m_widget)));
return int(adj->value + 0.5);
} }
int wxScrollBar::GetThumbSize() const int wxScrollBar::GetThumbSize() const
{ {
GtkAdjustment* adj = ((GtkRange*)m_widget)->adjustment; GtkAdjustment* adj = gtk_range_get_adjustment(GTK_RANGE(m_widget));
return int(adj->page_size); return int(gtk_adjustment_get_page_size(adj));
} }
int wxScrollBar::GetPageSize() const int wxScrollBar::GetPageSize() const
{ {
GtkAdjustment* adj = ((GtkRange*)m_widget)->adjustment; GtkAdjustment* adj = gtk_range_get_adjustment(GTK_RANGE(m_widget));
return int(adj->page_increment); return int(gtk_adjustment_get_page_increment(adj));
} }
int wxScrollBar::GetRange() const int wxScrollBar::GetRange() const
{ {
GtkAdjustment* adj = ((GtkRange*)m_widget)->adjustment; GtkAdjustment* adj = gtk_range_get_adjustment(GTK_RANGE(m_widget));
return int(adj->upper); return int(gtk_adjustment_get_upper(adj));
} }
void wxScrollBar::SetThumbPosition( int viewStart ) void wxScrollBar::SetThumbPosition( int viewStart )
@@ -212,14 +211,13 @@ void wxScrollBar::SetScrollbar(int position, int thumbSize, int range, int pageS
range = range =
thumbSize = 1; thumbSize = 1;
} }
GtkAdjustment* adj = ((GtkRange*)m_widget)->adjustment;
adj->step_increment = 1;
adj->page_increment = pageSize;
adj->page_size = thumbSize;
adj->value = position;
g_signal_handlers_block_by_func(m_widget, (void*)gtk_value_changed, this); g_signal_handlers_block_by_func(m_widget, (void*)gtk_value_changed, this);
gtk_range_set_range((GtkRange*)m_widget, 0, range); GtkRange* widget = GTK_RANGE(m_widget);
m_scrollPos[0] = adj->value; gtk_adjustment_set_page_size(gtk_range_get_adjustment(widget), thumbSize);
gtk_range_set_increments(widget, 1, pageSize);
gtk_range_set_range(widget, 0, range);
gtk_range_set_value(widget, position);
m_scrollPos[0] = gtk_range_get_value(widget);
g_signal_handlers_unblock_by_func(m_widget, (void*)gtk_value_changed, this); g_signal_handlers_unblock_by_func(m_widget, (void*)gtk_value_changed, this);
} }
@@ -233,11 +231,6 @@ void wxScrollBar::SetRange(int range)
SetScrollbar(GetThumbPosition(), GetThumbSize(), range, GetPageSize()); SetScrollbar(GetThumbPosition(), GetThumbSize(), range, GetPageSize());
} }
GdkWindow *wxScrollBar::GTKGetWindow(wxArrayGdkWindows& WXUNUSED(windows)) const
{
return m_widget->window;
}
// static // static
wxVisualAttributes wxVisualAttributes
wxScrollBar::GetClassDefaultAttributes(wxWindowVariant WXUNUSED(variant)) wxScrollBar::GetClassDefaultAttributes(wxWindowVariant WXUNUSED(variant))

18
src/gtk/scrolwin.cpp
View File

@@ -20,6 +20,7 @@
#include "wx/scrolwin.h" #include "wx/scrolwin.h"
#include <gtk/gtk.h> #include <gtk/gtk.h>
#include "wx/gtk/private/gtk2-compat.h"
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
// wxScrollHelper implementation // wxScrollHelper implementation
@@ -30,12 +31,15 @@ void wxScrollHelper::SetScrollbars(int pixelsPerUnitX, int pixelsPerUnitY,
int xPos, int yPos, int xPos, int yPos,
bool noRefresh) bool noRefresh)
{ {
m_win->m_scrollPos[wxWindow::ScrollDir_Horz] =
m_win->m_scrollBar[wxWindow::ScrollDir_Horz]->adjustment->value = xPos;
m_win->m_scrollPos[wxWindow::ScrollDir_Vert] =
m_win->m_scrollBar[wxWindow::ScrollDir_Vert]->adjustment->value = yPos;
base_type::SetScrollbars( base_type::SetScrollbars(
pixelsPerUnitX, pixelsPerUnitY, noUnitsX, noUnitsY, xPos, yPos, noRefresh); pixelsPerUnitX, pixelsPerUnitY, noUnitsX, noUnitsY, xPos, yPos, noRefresh);
gtk_range_set_value(m_win->m_scrollBar[wxWindow::ScrollDir_Horz], m_xScrollPosition);
gtk_range_set_value(m_win->m_scrollBar[wxWindow::ScrollDir_Vert], m_yScrollPosition);
m_win->m_scrollPos[wxWindow::ScrollDir_Horz] =
gtk_range_get_value(m_win->m_scrollBar[wxWindow::ScrollDir_Horz]);
m_win->m_scrollPos[wxWindow::ScrollDir_Vert] =
gtk_range_get_value(m_win->m_scrollBar[wxWindow::ScrollDir_Vert]);
} }
void wxScrollHelper::DoAdjustScrollbar(GtkRange* range, void wxScrollHelper::DoAdjustScrollbar(GtkRange* range,
@@ -68,10 +72,8 @@ void wxScrollHelper::DoAdjustScrollbar(GtkRange* range,
*linesPerPage = 0; *linesPerPage = 0;
} }
GtkAdjustment* adj = range->adjustment; gtk_range_set_increments(range, 1, page_size);
adj->step_increment = 1; gtk_adjustment_set_page_size(gtk_range_get_adjustment(range), page_size);
adj->page_increment =
adj->page_size = page_size;
gtk_range_set_range(range, 0, upper); gtk_range_set_range(range, 0, upper);
// ensure that the scroll position is always in valid range // ensure that the scroll position is always in valid range

17
src/gtk/settings.cpp
View File

@@ -22,6 +22,7 @@
#include <gtk/gtk.h> #include <gtk/gtk.h>
#include "wx/gtk/private/win_gtk.h" #include "wx/gtk/private/win_gtk.h"
#include "wx/gtk/private/gtk2-compat.h"
bool wxGetFrameExtents(GdkWindow* window, int* left, int* right, int* top, int* bottom); bool wxGetFrameExtents(GdkWindow* window, int* left, int* right, int* top, int* bottom);
@@ -60,7 +61,7 @@ static const GtkStyle* ButtonStyle()
gtk_widget_ensure_style(s_widget); gtk_widget_ensure_style(s_widget);
g_signal_connect(s_widget, "style_set", G_CALLBACK(style_set), NULL); g_signal_connect(s_widget, "style_set", G_CALLBACK(style_set), NULL);
} }
return s_widget->style; return gtk_widget_get_style(s_widget);
} }
static const GtkStyle* ListStyle() static const GtkStyle* ListStyle()
@@ -73,7 +74,7 @@ static const GtkStyle* ListStyle()
gtk_container_add(ContainerWidget(), s_widget); gtk_container_add(ContainerWidget(), s_widget);
gtk_widget_ensure_style(s_widget); gtk_widget_ensure_style(s_widget);
} }
return s_widget->style; return gtk_widget_get_style(s_widget);
} }
static const GtkStyle* TextCtrlStyle() static const GtkStyle* TextCtrlStyle()
@@ -85,7 +86,7 @@ static const GtkStyle* TextCtrlStyle()
gtk_container_add(ContainerWidget(), s_widget); gtk_container_add(ContainerWidget(), s_widget);
gtk_widget_ensure_style(s_widget); gtk_widget_ensure_style(s_widget);
} }
return s_widget->style; return gtk_widget_get_style(s_widget);
} }
static const GtkStyle* MenuItemStyle() static const GtkStyle* MenuItemStyle()
@@ -97,7 +98,7 @@ static const GtkStyle* MenuItemStyle()
gtk_container_add(ContainerWidget(), s_widget); gtk_container_add(ContainerWidget(), s_widget);
gtk_widget_ensure_style(s_widget); gtk_widget_ensure_style(s_widget);
} }
return s_widget->style; return gtk_widget_get_style(s_widget);
} }
static const GtkStyle* MenuBarStyle() static const GtkStyle* MenuBarStyle()
@@ -109,7 +110,7 @@ static const GtkStyle* MenuBarStyle()
gtk_container_add(ContainerWidget(), s_widget); gtk_container_add(ContainerWidget(), s_widget);
gtk_widget_ensure_style(s_widget); gtk_widget_ensure_style(s_widget);
} }
return s_widget->style; return gtk_widget_get_style(s_widget);
} }
static const GtkStyle* ToolTipStyle() static const GtkStyle* ToolTipStyle()
@@ -124,7 +125,7 @@ static const GtkStyle* ToolTipStyle()
gtk_widget_set_name(s_widget, name); gtk_widget_set_name(s_widget, name);
gtk_widget_ensure_style(s_widget); gtk_widget_ensure_style(s_widget);
} }
return s_widget->style; return gtk_widget_get_style(s_widget);
} }
wxColour wxSystemSettingsNative::GetColour( wxSystemColour index ) wxColour wxSystemSettingsNative::GetColour( wxSystemColour index )
@@ -316,8 +317,8 @@ static int GetBorderWidth(wxSystemMetric index, wxWindow* win)
int wxSystemSettingsNative::GetMetric( wxSystemMetric index, wxWindow* win ) int wxSystemSettingsNative::GetMetric( wxSystemMetric index, wxWindow* win )
{ {
GdkWindow *window = NULL; GdkWindow *window = NULL;
if(win && gtk_widget_get_realized(win->GetHandle())) if (win)
window = win->GetHandle()->window; window = gtk_widget_get_window(win->GetHandle());
switch (index) switch (index)
{ {

29
src/gtk/slider.cpp
View File

@@ -20,6 +20,7 @@
#endif #endif
#include <gtk/gtk.h> #include <gtk/gtk.h>
#include "wx/gtk/private/gtk2-compat.h"
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// data // data
@@ -124,10 +125,9 @@ extern "C" {
static void static void
gtk_value_changed(GtkRange* range, wxSlider* win) gtk_value_changed(GtkRange* range, wxSlider* win)
{ {
GtkAdjustment* adj = gtk_range_get_adjustment (range); const double value = gtk_range_get_value(range);
const int pos = wxRound(adj->value);
const double oldPos = win->m_pos; const double oldPos = win->m_pos;
win->m_pos = adj->value; win->m_pos = value;
if (!win->m_hasVMT || g_blockEventsOnDrag) if (!win->m_hasVMT || g_blockEventsOnDrag)
return; return;
@@ -151,18 +151,19 @@ gtk_value_changed(GtkRange* range, wxSlider* win)
else if (win->m_mouseButtonDown) else if (win->m_mouseButtonDown)
{ {
// Difference from last change event // Difference from last change event
const double diff = adj->value - oldPos; const double diff = value - oldPos;
const bool isDown = diff > 0; const bool isDown = diff > 0;
if (IsScrollIncrement(adj->page_increment, diff)) GtkAdjustment* adj = gtk_range_get_adjustment(range);
if (IsScrollIncrement(gtk_adjustment_get_page_increment(adj), diff))
{ {
eventType = isDown ? wxEVT_SCROLL_PAGEDOWN : wxEVT_SCROLL_PAGEUP; eventType = isDown ? wxEVT_SCROLL_PAGEDOWN : wxEVT_SCROLL_PAGEUP;
} }
else if (wxIsSameDouble(adj->value, 0)) else if (wxIsSameDouble(value, 0))
{ {
eventType = wxEVT_SCROLL_PAGEUP; eventType = wxEVT_SCROLL_PAGEUP;
} }
else if (wxIsSameDouble(adj->value, adj->upper)) else if (wxIsSameDouble(value, gtk_adjustment_get_upper(adj)))
{ {
eventType = wxEVT_SCROLL_PAGEDOWN; eventType = wxEVT_SCROLL_PAGEDOWN;
} }
@@ -178,7 +179,7 @@ gtk_value_changed(GtkRange* range, wxSlider* win)
win->m_scrollEventType = GTK_SCROLL_NONE; win->m_scrollEventType = GTK_SCROLL_NONE;
// If integral position has changed // If integral position has changed
if (wxRound(oldPos) != pos) if (wxRound(oldPos) != wxRound(value))
{ {
ProcessScrollEvent(win, eventType); ProcessScrollEvent(win, eventType);
win->m_needThumbRelease = eventType == wxEVT_SCROLL_THUMBTRACK; win->m_needThumbRelease = eventType == wxEVT_SCROLL_THUMBTRACK;
@@ -471,12 +472,14 @@ void wxSlider::SetRange( int minValue, int maxValue )
int wxSlider::GetMin() const int wxSlider::GetMin() const
{ {
return int(gtk_range_get_adjustment (GTK_RANGE (m_scale))->lower); GtkAdjustment* adj = gtk_range_get_adjustment(GTK_RANGE(m_scale));
return int(gtk_adjustment_get_lower(adj));
} }
int wxSlider::GetMax() const int wxSlider::GetMax() const
{ {
return int(gtk_range_get_adjustment (GTK_RANGE (m_scale))->upper); GtkAdjustment* adj = gtk_range_get_adjustment(GTK_RANGE(m_scale));
return int(gtk_adjustment_get_upper(adj));
} }
void wxSlider::SetPageSize( int pageSize ) void wxSlider::SetPageSize( int pageSize )
@@ -488,7 +491,8 @@ void wxSlider::SetPageSize( int pageSize )
int wxSlider::GetPageSize() const int wxSlider::GetPageSize() const
{ {
return int(gtk_range_get_adjustment (GTK_RANGE (m_scale))->page_increment); GtkAdjustment* adj = gtk_range_get_adjustment(GTK_RANGE(m_scale));
return int(gtk_adjustment_get_page_increment(adj));
} }
// GTK does not support changing the size of the slider // GTK does not support changing the size of the slider
@@ -510,7 +514,8 @@ void wxSlider::SetLineSize( int lineSize )
int wxSlider::GetLineSize() const int wxSlider::GetLineSize() const
{ {
return int(gtk_range_get_adjustment (GTK_RANGE (m_scale))->step_increment); GtkAdjustment* adj = gtk_range_get_adjustment(GTK_RANGE(m_scale));
return int(gtk_adjustment_get_step_increment(adj));
} }
GdkWindow *wxSlider::GTKGetWindow(wxArrayGdkWindows& WXUNUSED(windows)) const GdkWindow *wxSlider::GTKGetWindow(wxArrayGdkWindows& WXUNUSED(windows)) const

29
src/gtk/sockgtk.cpp
View File

@@ -17,17 +17,14 @@
#include "wx/apptrait.h" #include "wx/apptrait.h"
#include "wx/private/fdiomanager.h" #include "wx/private/fdiomanager.h"
#include <gdk/gdk.h> #include <glib.h>
extern "C" { extern "C" {
static static gboolean wxSocket_Input(GIOChannel*, GIOCondition condition, gpointer data)
void wxSocket_GDK_Input(gpointer data,
gint WXUNUSED(source),
GdkInputCondition condition)
{ {
wxFDIOHandler * const handler = static_cast<wxFDIOHandler *>(data); wxFDIOHandler * const handler = static_cast<wxFDIOHandler *>(data);
if ( condition & GDK_INPUT_READ ) if (condition & G_IO_IN)
{ {
handler->OnReadWaiting(); handler->OnReadWaiting();
@@ -35,11 +32,13 @@ void wxSocket_GDK_Input(gpointer data,
// shouldn't call OnWriteWaiting() as the socket is now closed and it // shouldn't call OnWriteWaiting() as the socket is now closed and it
// would assert // would assert
if ( !handler->IsOk() ) if ( !handler->IsOk() )
return; return true;
} }
if ( condition & GDK_INPUT_WRITE ) if (condition & G_IO_OUT)
handler->OnWriteWaiting(); handler->OnWriteWaiting();
return true;
} }
} }
@@ -48,19 +47,17 @@ class GTKFDIOManager : public wxFDIOManager
public: public:
virtual int AddInput(wxFDIOHandler *handler, int fd, Direction d) virtual int AddInput(wxFDIOHandler *handler, int fd, Direction d)
{ {
return gdk_input_add return g_io_add_watch(
( g_io_channel_unix_new(fd),
fd, d == OUTPUT ? G_IO_OUT : G_IO_IN,
d == OUTPUT ? GDK_INPUT_WRITE : GDK_INPUT_READ, wxSocket_Input,
wxSocket_GDK_Input, handler);
handler
);
} }
virtual void virtual void
RemoveInput(wxFDIOHandler* WXUNUSED(handler), int fd, Direction WXUNUSED(d)) RemoveInput(wxFDIOHandler* WXUNUSED(handler), int fd, Direction WXUNUSED(d))
{ {
gdk_input_remove(fd); g_source_remove(fd);
} }
}; };

14
src/gtk/spinctrl.cpp
View File

@@ -152,12 +152,14 @@ double wxSpinCtrlGTKBase::DoGetValue() const
g_signal_emit(m_widget, sig_id, 0, &value, &handled); g_signal_emit(m_widget, sig_id, 0, &value, &handled);
if (!handled) if (!handled)
value = g_strtod(gtk_entry_get_text(GTK_ENTRY(m_widget)), NULL); value = g_strtod(gtk_entry_get_text(GTK_ENTRY(m_widget)), NULL);
const GtkAdjustment* adj = GtkAdjustment* adj =
gtk_spin_button_get_adjustment(GTK_SPIN_BUTTON(m_widget)); gtk_spin_button_get_adjustment(GTK_SPIN_BUTTON(m_widget));
if (value < adj->lower) const double lower = gtk_adjustment_get_lower(adj);
value = adj->lower; const double upper = gtk_adjustment_get_upper(adj);
else if (value > adj->upper) if (value < lower)
value = adj->upper; value = lower;
else if (value > upper)
value = upper;
return value; return value;
} }
@@ -297,7 +299,7 @@ void wxSpinCtrlGTKBase::OnChar( wxKeyEvent &event )
GtkWindow *window = GTK_WINDOW(top_frame->m_widget); GtkWindow *window = GTK_WINDOW(top_frame->m_widget);
if ( window ) if ( window )
{ {
GtkWidget *widgetDef = window->default_widget; GtkWidget* widgetDef = gtk_window_get_default_widget(window);
if ( widgetDef ) if ( widgetDef )
{ {

12
src/gtk/statbox.cpp
View File

@@ -16,6 +16,7 @@
#include "wx/gtk/private/win_gtk.h" // for wxPizza #include "wx/gtk/private/win_gtk.h" // for wxPizza
#include <gtk/gtk.h> #include <gtk/gtk.h>
#include "wx/gtk/private/gtk2-compat.h"
// constants taken from GTK sources // constants taken from GTK sources
#define LABEL_PAD 1 #define LABEL_PAD 1
@@ -31,15 +32,16 @@ static void size_allocate(GtkWidget* widget, GtkAllocation* alloc, void*)
// clip label as GTK >= 2.12 does // clip label as GTK >= 2.12 does
GtkWidget* label_widget = gtk_frame_get_label_widget(GTK_FRAME(widget)); GtkWidget* label_widget = gtk_frame_get_label_widget(GTK_FRAME(widget));
int w = alloc->width - int w = alloc->width -
2 * widget->style->xthickness - 2 * LABEL_PAD - 2 * LABEL_SIDE_PAD; 2 * gtk_widget_get_style(widget)->xthickness - 2 * LABEL_PAD - 2 * LABEL_SIDE_PAD;
if (w < 0) if (w < 0)
w = 0; w = 0;
if (label_widget->allocation.width > w) GtkAllocation a;
gtk_widget_get_allocation(label_widget, &a);
if (a.width > w)
{ {
GtkAllocation alloc2 = label_widget->allocation; a.width = w;
alloc2.width = w; gtk_widget_size_allocate(label_widget, &a);
gtk_widget_size_allocate(label_widget, &alloc2);
} }
} }
} }

23
src/gtk/taskbar.cpp
View File

@@ -180,7 +180,7 @@ void wxTaskBarIcon::Private::SetIcon()
m_size = 0; m_size = 0;
if (m_eggTrayIcon) if (m_eggTrayIcon)
{ {
GtkWidget* image = GTK_BIN(m_eggTrayIcon)->child; GtkWidget* image = gtk_bin_get_child(GTK_BIN(m_eggTrayIcon));
gtk_image_set_from_pixbuf(GTK_IMAGE(image), m_bitmap.GetPixbuf()); gtk_image_set_from_pixbuf(GTK_IMAGE(image), m_bitmap.GetPixbuf());
} }
else else
@@ -207,10 +207,22 @@ void wxTaskBarIcon::Private::SetIcon()
#if GTK_CHECK_VERSION(2,10,0) #if GTK_CHECK_VERSION(2,10,0)
if (m_statusIcon) if (m_statusIcon)
gtk_status_icon_set_tooltip(m_statusIcon, tip_text);
else
#endif
{ {
#if GTK_CHECK_VERSION(2,16,0)
if (GTK_CHECK_VERSION(3,0,0) || gtk_check_version(2,16,0) == NULL)
gtk_status_icon_set_tooltip_text(m_statusIcon, tip_text);
else
#endif
{
#if !GTK_CHECK_VERSION(3,0,0) && !defined(GTK_DISABLE_DEPRECATED)
gtk_status_icon_set_tooltip(m_statusIcon, tip_text);
#endif
}
}
else
#endif // GTK_CHECK_VERSION(2,10,0)
{
#if !GTK_CHECK_VERSION(3,0,0) && !defined(GTK_DISABLE_DEPRECATED)
if (tip_text && m_tooltips == NULL) if (tip_text && m_tooltips == NULL)
{ {
m_tooltips = gtk_tooltips_new(); m_tooltips = gtk_tooltips_new();
@@ -219,6 +231,7 @@ void wxTaskBarIcon::Private::SetIcon()
} }
if (m_tooltips) if (m_tooltips)
gtk_tooltips_set_tip(m_tooltips, m_eggTrayIcon, tip_text, ""); gtk_tooltips_set_tip(m_tooltips, m_eggTrayIcon, tip_text, "");
#endif
} }
#endif // wxUSE_TOOLTIPS #endif // wxUSE_TOOLTIPS
} }
@@ -240,7 +253,7 @@ void wxTaskBarIcon::Private::size_allocate(int width, int height)
if (h > size) h = size; if (h > size) h = size;
GdkPixbuf* pixbuf = GdkPixbuf* pixbuf =
gdk_pixbuf_scale_simple(m_bitmap.GetPixbuf(), w, h, GDK_INTERP_BILINEAR); gdk_pixbuf_scale_simple(m_bitmap.GetPixbuf(), w, h, GDK_INTERP_BILINEAR);
GtkImage* image = GTK_IMAGE(GTK_BIN(m_eggTrayIcon)->child); GtkImage* image = GTK_IMAGE(gtk_bin_get_child(GTK_BIN(m_eggTrayIcon)));
gtk_image_set_from_pixbuf(image, pixbuf); gtk_image_set_from_pixbuf(image, pixbuf);
g_object_unref(pixbuf); g_object_unref(pixbuf);
} }

64
src/gtk/textctrl.cpp
View File

@@ -579,6 +579,18 @@ gtk_paste_clipboard_callback( GtkWidget *widget, wxTextCtrl *win )
} }
} }
//-----------------------------------------------------------------------------
// "mark_set"
//-----------------------------------------------------------------------------
extern "C" {
static void mark_set(GtkTextBuffer*, GtkTextIter*, GtkTextMark* mark, GSList** markList)
{
if (gtk_text_mark_get_name(mark) == NULL)
*markList = g_slist_prepend(*markList, mark);
}
}
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// wxTextCtrl // wxTextCtrl
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
@@ -620,10 +632,13 @@ void wxTextCtrl::Init()
m_text = NULL; m_text = NULL;
m_showPositionOnThaw = NULL; m_showPositionOnThaw = NULL;
m_anonymousMarkList = NULL;
} }
wxTextCtrl::~wxTextCtrl() wxTextCtrl::~wxTextCtrl()
{ {
if (m_anonymousMarkList)
g_slist_free(m_anonymousMarkList);
} }
wxTextCtrl::wxTextCtrl( wxWindow *parent, wxTextCtrl::wxTextCtrl( wxWindow *parent,
@@ -660,10 +675,13 @@ bool wxTextCtrl::Create( wxWindow *parent,
if (multi_line) if (multi_line)
{ {
m_buffer = gtk_text_buffer_new(NULL);
gulong sig_id = g_signal_connect(m_buffer, "mark_set", G_CALLBACK(mark_set), &m_anonymousMarkList);
// Create view // Create view
m_text = gtk_text_view_new(); m_text = gtk_text_view_new_with_buffer(m_buffer);
// gtk_text_view_set_buffer adds its own reference
m_buffer = gtk_text_view_get_buffer( GTK_TEXT_VIEW(m_text) ); g_object_unref(m_buffer);
g_signal_handler_disconnect(m_buffer, sig_id);
// create "ShowPosition" marker // create "ShowPosition" marker
GtkTextIter iter; GtkTextIter iter;
@@ -678,7 +696,7 @@ bool wxTextCtrl::Create( wxWindow *parent,
? GTK_POLICY_NEVER ? GTK_POLICY_NEVER
: GTK_POLICY_AUTOMATIC ); : GTK_POLICY_AUTOMATIC );
// for ScrollLines/Pages // for ScrollLines/Pages
m_scrollBar[1] = (GtkRange*)((GtkScrolledWindow*)m_widget)->vscrollbar; m_scrollBar[1] = GTK_RANGE(gtk_scrolled_window_get_vscrollbar(GTK_SCROLLED_WINDOW(m_widget)));
// Insert view into scrolled window // Insert view into scrolled window
gtk_container_add( GTK_CONTAINER(m_widget), m_text ); gtk_container_add( GTK_CONTAINER(m_widget), m_text );
@@ -1082,13 +1100,19 @@ void wxTextCtrl::WriteText( const wxString &text )
// Insert the text // Insert the text
wxGtkTextInsert( m_text, m_buffer, m_defaultStyle, buffer ); wxGtkTextInsert( m_text, m_buffer, m_defaultStyle, buffer );
GtkAdjustment *adj = gtk_scrolled_window_get_vadjustment( GTK_SCROLLED_WINDOW(m_widget) );
// Scroll to cursor, but only if scrollbar thumb is at the very bottom // Scroll to cursor, but only if scrollbar thumb is at the very bottom
// won't work when frozen, text view is not using m_buffer then // won't work when frozen, text view is not using m_buffer then
if (!IsFrozen() && wxIsSameDouble(adj->value, adj->upper - adj->page_size)) if (!IsFrozen())
{ {
gtk_text_view_scroll_to_mark( GTK_TEXT_VIEW(m_text), GtkAdjustment* adj = gtk_scrolled_window_get_vadjustment(GTK_SCROLLED_WINDOW(m_widget));
gtk_text_buffer_get_insert( m_buffer ), 0.0, FALSE, 0.0, 1.0 ); const double value = gtk_adjustment_get_value(adj);
const double upper = gtk_adjustment_get_upper(adj);
const double page_size = gtk_adjustment_get_page_size(adj);
if (wxIsSameDouble(value, upper - page_size))
{
gtk_text_view_scroll_to_mark(GTK_TEXT_VIEW(m_text),
gtk_text_buffer_get_insert(m_buffer), 0, false, 0, 1);
}
} }
} }
@@ -1141,7 +1165,7 @@ bool wxTextCtrl::PositionToXY(long pos, long *x, long *y ) const
} }
else // single line control else // single line control
{ {
if ( pos <= GTK_ENTRY(m_text)->text_length ) if (pos <= gtk_entry_get_text_length(GTK_ENTRY(m_text)))
{ {
if ( y ) if ( y )
*y = 0; *y = 0;
@@ -1578,7 +1602,7 @@ GdkWindow *wxTextCtrl::GTKGetWindow(wxArrayGdkWindows& WXUNUSED(windows)) const
} }
else else
{ {
return GTK_ENTRY(m_text)->text_area; return gtk_entry_get_text_window(GTK_ENTRY(m_text));
} }
} }
@@ -1804,16 +1828,24 @@ void wxTextCtrl::DoFreeze()
// removing buffer dramatically speeds up insertion: // removing buffer dramatically speeds up insertion:
g_object_ref(m_buffer); g_object_ref(m_buffer);
GtkTextBuffer* buf_new = gtk_text_buffer_new(NULL); GtkTextBuffer* buf_new = gtk_text_buffer_new(NULL);
GtkTextMark* mark = GTK_TEXT_VIEW(m_text)->first_para_mark;
gtk_text_view_set_buffer(GTK_TEXT_VIEW(m_text), buf_new); gtk_text_view_set_buffer(GTK_TEXT_VIEW(m_text), buf_new);
// gtk_text_view_set_buffer adds its own reference // gtk_text_view_set_buffer adds its own reference
g_object_unref(buf_new); g_object_unref(buf_new);
// This mark should be deleted when the buffer is changed, // These marks should be deleted when the buffer is changed,
// but it's not (in GTK+ up to at least 2.10.6). // but they are not (in GTK+ up to at least 3.0.1).
// Otherwise these anonymous marks start to build up in the buffer, // Otherwise these anonymous marks start to build up in the buffer,
// and Freeze takes longer and longer each time it is called. // and Freeze takes longer and longer each time it is called.
if (GTK_IS_TEXT_MARK(mark) && !gtk_text_mark_get_deleted(mark)) if (m_anonymousMarkList)
gtk_text_buffer_delete_mark(m_buffer, mark); {
for (GSList* item = m_anonymousMarkList; item; item = item->next)
{
GtkTextMark* mark = static_cast<GtkTextMark*>(item->data);
if (GTK_IS_TEXT_MARK(mark) && !gtk_text_mark_get_deleted(mark))
gtk_text_buffer_delete_mark(m_buffer, mark);
}
g_slist_free(m_anonymousMarkList);
m_anonymousMarkList = NULL;
}
} }
} }
@@ -1822,8 +1854,10 @@ void wxTextCtrl::DoThaw()
if ( HasFlag(wxTE_MULTILINE) ) if ( HasFlag(wxTE_MULTILINE) )
{ {
// reattach buffer: // reattach buffer:
gulong sig_id = g_signal_connect(m_buffer, "mark_set", G_CALLBACK(mark_set), &m_anonymousMarkList);
gtk_text_view_set_buffer(GTK_TEXT_VIEW(m_text), m_buffer); gtk_text_view_set_buffer(GTK_TEXT_VIEW(m_text), m_buffer);
g_object_unref(m_buffer); g_object_unref(m_buffer);
g_signal_handler_disconnect(m_buffer, sig_id);
if (m_showPositionOnThaw != NULL) if (m_showPositionOnThaw != NULL)
{ {

12
src/gtk/textentry.cpp
View File

@@ -52,13 +52,19 @@ wx_gtk_insert_text_callback(GtkEditable *editable,
// we should only be called if we have a max len limit at all // we should only be called if we have a max len limit at all
GtkEntry *entry = GTK_ENTRY (editable); GtkEntry *entry = GTK_ENTRY (editable);
wxCHECK_RET( entry->text_max_length, wxT("shouldn't be called") ); const int text_length = gtk_entry_get_text_length(entry);
#if GTK_CHECK_VERSION(3,0,0) || defined(GSEAL_ENABLE)
const int text_max_length = gtk_entry_buffer_get_max_length(gtk_entry_get_buffer(entry));
#else
const int text_max_length = entry->text_max_length;
#endif
wxCHECK_RET(text_max_length, "shouldn't be called");
// check that we don't overflow the max length limit // check that we don't overflow the max length limit
// //
// FIXME: this doesn't work when we paste a string which is going to be // FIXME: this doesn't work when we paste a string which is going to be
// truncated // truncated
if ( entry->text_length == entry->text_max_length ) if (text_length == text_max_length)
{ {
// we don't need to run the base class version at all // we don't need to run the base class version at all
g_signal_stop_emission_by_name (editable, "insert_text"); g_signal_stop_emission_by_name (editable, "insert_text");
@@ -179,7 +185,7 @@ long wxTextEntry::GetLastPosition() const
// GtkEntries // GtkEntries
GtkEntry * const entry = GTK_ENTRY(GetEditable()); GtkEntry * const entry = GTK_ENTRY(GetEditable());
return entry ? entry->text_length : - 1; return entry ? gtk_entry_get_text_length(entry) : -1;
} }
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------

12
src/gtk/tglbtn.cpp
View File

@@ -132,7 +132,7 @@ void wxBitmapToggleButton::OnSetBitmap()
{ {
if (!m_bitmap.Ok()) return; if (!m_bitmap.Ok()) return;
GtkWidget* image = ((GtkBin*)m_widget)->child; GtkWidget* image = gtk_bin_get_child(GTK_BIN(m_widget));
if (image == NULL) if (image == NULL)
{ {
image = gtk_image_new(); image = gtk_image_new();
@@ -151,7 +151,7 @@ bool wxBitmapToggleButton::Enable(bool enable /*=true*/)
if (!wxControl::Enable(enable)) if (!wxControl::Enable(enable))
return false; return false;
gtk_widget_set_sensitive(GTK_BIN(m_widget)->child, enable); gtk_widget_set_sensitive(gtk_bin_get_child(GTK_BIN(m_widget)), enable);
if (!isEnabled && enable) if (!isEnabled && enable)
{ {
@@ -164,7 +164,7 @@ bool wxBitmapToggleButton::Enable(bool enable /*=true*/)
void wxBitmapToggleButton::DoApplyWidgetStyle(GtkRcStyle *style) void wxBitmapToggleButton::DoApplyWidgetStyle(GtkRcStyle *style)
{ {
gtk_widget_modify_style(m_widget, style); gtk_widget_modify_style(m_widget, style);
gtk_widget_modify_style(GTK_BIN(m_widget)->child, style); gtk_widget_modify_style(gtk_bin_get_child(GTK_BIN(m_widget)), style);
} }
GdkWindow * GdkWindow *
@@ -267,7 +267,7 @@ bool wxToggleButton::GetValue() const
{ {
wxCHECK_MSG(m_widget != NULL, false, wxT("invalid toggle button")); wxCHECK_MSG(m_widget != NULL, false, wxT("invalid toggle button"));
return GTK_TOGGLE_BUTTON(m_widget)->active; return gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(m_widget)) != 0;
} }
void wxToggleButton::SetLabel(const wxString& label) void wxToggleButton::SetLabel(const wxString& label)
@@ -288,7 +288,7 @@ bool wxToggleButton::Enable(bool enable /*=true*/)
if (!base_type::Enable(enable)) if (!base_type::Enable(enable))
return false; return false;
gtk_widget_set_sensitive(GTK_BIN(m_widget)->child, enable); gtk_widget_set_sensitive(gtk_bin_get_child(GTK_BIN(m_widget)), enable);
if (enable) if (enable)
GTKFixSensitivity(); GTKFixSensitivity();
@@ -299,7 +299,7 @@ bool wxToggleButton::Enable(bool enable /*=true*/)
void wxToggleButton::DoApplyWidgetStyle(GtkRcStyle *style) void wxToggleButton::DoApplyWidgetStyle(GtkRcStyle *style)
{ {
gtk_widget_modify_style(m_widget, style); gtk_widget_modify_style(m_widget, style);
gtk_widget_modify_style(GTK_BIN(m_widget)->child, style); gtk_widget_modify_style(gtk_bin_get_child(GTK_BIN(m_widget)), style);
} }
GdkWindow * GdkWindow *

40
src/gtk/toolbar.cpp
View File

@@ -195,12 +195,15 @@ image_expose_event(GtkWidget* widget, GdkEventExpose*, wxToolBarTool* tool)
return false; return false;
// draw disabled bitmap ourselves, GtkImage has no way to specify it // draw disabled bitmap ourselves, GtkImage has no way to specify it
const GtkAllocation& alloc = widget->allocation; GtkAllocation alloc;
gtk_widget_get_allocation(widget, &alloc);
GtkRequisition req;
gtk_widget_get_requisition(widget, &req);
gdk_draw_pixbuf( gdk_draw_pixbuf(
widget->window, widget->style->black_gc, bitmap.GetPixbuf(), gtk_widget_get_window(widget), gtk_widget_get_style(widget)->black_gc, bitmap.GetPixbuf(),
0, 0, 0, 0,
alloc.x + (alloc.width - widget->requisition.width) / 2, alloc.x + (alloc.width - req.width) / 2,
alloc.y + (alloc.height - widget->requisition.height) / 2, alloc.y + (alloc.height - req.height) / 2,
-1, -1, GDK_RGB_DITHER_NORMAL, 0, 0); -1, -1, GDK_RGB_DITHER_NORMAL, 0, 0);
return true; return true;
} }
@@ -250,7 +253,7 @@ void wxToolBar::AddChildGTK(wxWindowGTK* child)
GtkToolItem* item = gtk_tool_item_new(); GtkToolItem* item = gtk_tool_item_new();
gtk_container_add(GTK_CONTAINER(item), align); gtk_container_add(GTK_CONTAINER(item), align);
// position will be corrected in DoInsertTool if necessary // position will be corrected in DoInsertTool if necessary
gtk_toolbar_insert(GTK_TOOLBAR(GTK_BIN(m_widget)->child), item, -1); gtk_toolbar_insert(GTK_TOOLBAR(gtk_bin_get_child(GTK_BIN(m_widget))), item, -1);
} }
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
@@ -284,7 +287,7 @@ void wxToolBarTool::CreateDropDown()
box = gtk_hbox_new(false, 0); box = gtk_hbox_new(false, 0);
arrow = gtk_arrow_new(GTK_ARROW_DOWN, GTK_SHADOW_NONE); arrow = gtk_arrow_new(GTK_ARROW_DOWN, GTK_SHADOW_NONE);
} }
GtkWidget* tool_button = GTK_BIN(m_item)->child; GtkWidget* tool_button = gtk_bin_get_child(GTK_BIN(m_item));
gtk_widget_reparent(tool_button, box); gtk_widget_reparent(tool_button, box);
GtkWidget* arrow_button = gtk_toggle_button_new(); GtkWidget* arrow_button = gtk_toggle_button_new();
gtk_button_set_relief(GTK_BUTTON(arrow_button), gtk_button_set_relief(GTK_BUTTON(arrow_button),
@@ -308,7 +311,8 @@ void wxToolBarTool::ShowDropdown(GtkToggleButton* button)
wxMenu* menu = GetDropdownMenu(); wxMenu* menu = GetDropdownMenu();
if (menu) if (menu)
{ {
const GtkAllocation& alloc = GTK_WIDGET(button)->allocation; GtkAllocation alloc;
gtk_widget_set_allocation(GTK_WIDGET(button), &alloc);
int x = alloc.x; int x = alloc.x;
int y = alloc.y; int y = alloc.y;
if (toolbar->HasFlag(wxTB_LEFT | wxTB_RIGHT)) if (toolbar->HasFlag(wxTB_LEFT | wxTB_RIGHT))
@@ -376,12 +380,14 @@ bool wxToolBar::Create( wxWindow *parent,
FixupStyle(); FixupStyle();
m_toolbar = GTK_TOOLBAR( gtk_toolbar_new() ); m_toolbar = GTK_TOOLBAR( gtk_toolbar_new() );
#if !GTK_CHECK_VERSION(3,0,0) && !defined(GTK_DISABLE_DEPRECATED)
if (gtk_check_version(2, 12, 0)) if (gtk_check_version(2, 12, 0))
{ {
m_tooltips = gtk_tooltips_new(); m_tooltips = gtk_tooltips_new();
g_object_ref(m_tooltips); g_object_ref(m_tooltips);
gtk_object_sink(GTK_OBJECT(m_tooltips)); gtk_object_sink(GTK_OBJECT(m_tooltips));
} }
#endif
GtkSetStyle(); GtkSetStyle();
if (style & wxTB_DOCKABLE) if (style & wxTB_DOCKABLE)
@@ -417,7 +423,7 @@ bool wxToolBar::Create( wxWindow *parent,
GdkWindow *wxToolBar::GTKGetWindow(wxArrayGdkWindows& WXUNUSED(windows)) const GdkWindow *wxToolBar::GTKGetWindow(wxArrayGdkWindows& WXUNUSED(windows)) const
{ {
return GTK_WIDGET(m_toolbar)->window; return gtk_widget_get_window(GTK_WIDGET(m_toolbar));
} }
void wxToolBar::GtkSetStyle() void wxToolBar::GtkSetStyle()
@@ -436,7 +442,11 @@ void wxToolBar::GtkSetStyle()
style = GTK_TOOLBAR_BOTH_HORIZ; style = GTK_TOOLBAR_BOTH_HORIZ;
} }
#if GTK_CHECK_VERSION(3,0,0) || defined(GTK_DISABLE_DEPRECATED)
gtk_orientable_set_orientation(GTK_ORIENTABLE(m_toolbar), orient);
#else
gtk_toolbar_set_orientation(m_toolbar, orient); gtk_toolbar_set_orientation(m_toolbar, orient);
#endif
gtk_toolbar_set_style(m_toolbar, style); gtk_toolbar_set_style(m_toolbar, style);
} }
@@ -533,7 +543,7 @@ bool wxToolBar::DoInsertTool(size_t pos, wxToolBarToolBase *toolBase)
if (!HasFlag(wxTB_NO_TOOLTIPS) && !tool->GetShortHelp().empty()) if (!HasFlag(wxTB_NO_TOOLTIPS) && !tool->GetShortHelp().empty())
{ {
#if GTK_CHECK_VERSION(2, 12, 0) #if GTK_CHECK_VERSION(2, 12, 0)
if (!gtk_check_version(2, 12, 0)) if (GTK_CHECK_VERSION(3,0,0) || gtk_check_version(2,12,0) == NULL)
{ {
gtk_tool_item_set_tooltip_text(tool->m_item, gtk_tool_item_set_tooltip_text(tool->m_item,
wxGTK_CONV(tool->GetShortHelp())); wxGTK_CONV(tool->GetShortHelp()));
@@ -541,8 +551,10 @@ bool wxToolBar::DoInsertTool(size_t pos, wxToolBarToolBase *toolBase)
else else
#endif #endif
{ {
#if !GTK_CHECK_VERSION(3,0,0) && !defined(GTK_DISABLE_DEPRECATED)
gtk_tool_item_set_tooltip(tool->m_item, gtk_tool_item_set_tooltip(tool->m_item,
m_tooltips, wxGTK_CONV(tool->GetShortHelp()), ""); m_tooltips, wxGTK_CONV(tool->GetShortHelp()), "");
#endif
} }
} }
bin_child = gtk_bin_get_child(GTK_BIN(tool->m_item)); bin_child = gtk_bin_get_child(GTK_BIN(tool->m_item));
@@ -574,9 +586,9 @@ bool wxToolBar::DoInsertTool(size_t pos, wxToolBarToolBase *toolBase)
case wxTOOL_STYLE_CONTROL: case wxTOOL_STYLE_CONTROL:
wxWindow* control = tool->GetControl(); wxWindow* control = tool->GetControl();
if (control->m_widget->parent == NULL) if (gtk_widget_get_parent(control->m_widget) == NULL)
AddChildGTK(control); AddChildGTK(control);
tool->m_item = GTK_TOOL_ITEM(control->m_widget->parent->parent); tool->m_item = GTK_TOOL_ITEM(gtk_widget_get_parent(gtk_widget_get_parent(control->m_widget)));
if (gtk_toolbar_get_item_index(m_toolbar, tool->m_item) != int(pos)) if (gtk_toolbar_get_item_index(m_toolbar, tool->m_item) != int(pos))
{ {
g_object_ref(tool->m_item); g_object_ref(tool->m_item);
@@ -611,7 +623,7 @@ bool wxToolBar::DoDeleteTool(size_t /* pos */, wxToolBarToolBase* toolBase)
// while if we're called from DeleteTool() the control will // while if we're called from DeleteTool() the control will
// be destroyed when wxToolBarToolBase itself is deleted // be destroyed when wxToolBarToolBase itself is deleted
GtkWidget* widget = tool->GetControl()->m_widget; GtkWidget* widget = tool->GetControl()->m_widget;
gtk_container_remove(GTK_CONTAINER(widget->parent), widget); gtk_container_remove(GTK_CONTAINER(gtk_widget_get_parent(widget)), widget);
} }
gtk_object_destroy(GTK_OBJECT(tool->m_item)); gtk_object_destroy(GTK_OBJECT(tool->m_item));
tool->m_item = NULL; tool->m_item = NULL;
@@ -711,7 +723,7 @@ void wxToolBar::SetToolShortHelp( int id, const wxString& helpString )
if (tool->m_item) if (tool->m_item)
{ {
#if GTK_CHECK_VERSION(2, 12, 0) #if GTK_CHECK_VERSION(2, 12, 0)
if (!gtk_check_version(2, 12, 0)) if (GTK_CHECK_VERSION(3,0,0) || gtk_check_version(2,12,0) == NULL)
{ {
gtk_tool_item_set_tooltip_text(tool->m_item, gtk_tool_item_set_tooltip_text(tool->m_item,
wxGTK_CONV(helpString)); wxGTK_CONV(helpString));
@@ -719,8 +731,10 @@ void wxToolBar::SetToolShortHelp( int id, const wxString& helpString )
else else
#endif #endif
{ {
#if !GTK_CHECK_VERSION(3,0,0) && !defined(GTK_DISABLE_DEPRECATED)
gtk_tool_item_set_tooltip(tool->m_item, gtk_tool_item_set_tooltip(tool->m_item,
m_tooltips, wxGTK_CONV(helpString), ""); m_tooltips, wxGTK_CONV(helpString), "");
#endif
} }
} }
} }

14
src/gtk/tooltip.cpp
View File

@@ -24,7 +24,9 @@
// global data // global data
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
#if !GTK_CHECK_VERSION(3,0,0) && !defined(GTK_DISABLE_DEPRECATED)
static GtkTooltips *gs_tooltips = NULL; static GtkTooltips *gs_tooltips = NULL;
#endif
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// wxToolTip // wxToolTip
@@ -56,22 +58,24 @@ void wxToolTip::GTKSetWindow(wxWindow* win)
void wxToolTip::GTKApply(GtkWidget* widget, const char* tip) void wxToolTip::GTKApply(GtkWidget* widget, const char* tip)
{ {
#if GTK_CHECK_VERSION(2, 12, 0) #if GTK_CHECK_VERSION(2, 12, 0)
if (!gtk_check_version(2, 12, 0)) if (GTK_CHECK_VERSION(3,0,0) || gtk_check_version(2,12,0) == NULL)
gtk_widget_set_tooltip_text(widget, tip); gtk_widget_set_tooltip_text(widget, tip);
else else
#endif #endif
{ {
#if !GTK_CHECK_VERSION(3,0,0) && !defined(GTK_DISABLE_DEPRECATED)
if ( !gs_tooltips ) if ( !gs_tooltips )
gs_tooltips = gtk_tooltips_new(); gs_tooltips = gtk_tooltips_new();
gtk_tooltips_set_tip(gs_tooltips, widget, tip, NULL); gtk_tooltips_set_tip(gs_tooltips, widget, tip, NULL);
#endif
} }
} }
void wxToolTip::Enable( bool flag ) void wxToolTip::Enable( bool flag )
{ {
#if GTK_CHECK_VERSION(2, 12, 0) #if GTK_CHECK_VERSION(2, 12, 0)
if (!gtk_check_version(2, 12, 0)) if (GTK_CHECK_VERSION(3,0,0) || gtk_check_version(2,12,0) == NULL)
{ {
GtkSettings* settings = gtk_settings_get_default(); GtkSettings* settings = gtk_settings_get_default();
if (settings) if (settings)
@@ -80,6 +84,7 @@ void wxToolTip::Enable( bool flag )
else else
#endif #endif
{ {
#if !GTK_CHECK_VERSION(3,0,0) && !defined(GTK_DISABLE_DEPRECATED)
if (!gs_tooltips) if (!gs_tooltips)
gs_tooltips = gtk_tooltips_new(); gs_tooltips = gtk_tooltips_new();
@@ -87,13 +92,14 @@ void wxToolTip::Enable( bool flag )
gtk_tooltips_enable( gs_tooltips ); gtk_tooltips_enable( gs_tooltips );
else else
gtk_tooltips_disable( gs_tooltips ); gtk_tooltips_disable( gs_tooltips );
#endif
} }
} }
void wxToolTip::SetDelay( long msecs ) void wxToolTip::SetDelay( long msecs )
{ {
#if GTK_CHECK_VERSION(2, 12, 0) #if GTK_CHECK_VERSION(2, 12, 0)
if (!gtk_check_version(2, 12, 0)) if (GTK_CHECK_VERSION(3,0,0) || gtk_check_version(2,12,0) == NULL)
{ {
GtkSettings* settings = gtk_settings_get_default(); GtkSettings* settings = gtk_settings_get_default();
if (settings) if (settings)
@@ -102,10 +108,12 @@ void wxToolTip::SetDelay( long msecs )
else else
#endif #endif
{ {
#if !GTK_CHECK_VERSION(3,0,0) && !defined(GTK_DISABLE_DEPRECATED)
if (!gs_tooltips) if (!gs_tooltips)
gs_tooltips = gtk_tooltips_new(); gs_tooltips = gtk_tooltips_new();
gtk_tooltips_set_delay( gs_tooltips, (int)msecs ); gtk_tooltips_set_delay( gs_tooltips, (int)msecs );
#endif
} }
} }

85
src/gtk/toplevel.cpp
View File

@@ -80,9 +80,8 @@ extern "C" {
static void wxgtk_window_set_urgency_hint (GtkWindow *win, static void wxgtk_window_set_urgency_hint (GtkWindow *win,
gboolean setting) gboolean setting)
{ {
wxASSERT_MSG( gtk_widget_get_realized(GTK_WIDGET(win)), GdkWindow* window = gtk_widget_get_window(GTK_WIDGET(win));
wxT("wxgtk_window_set_urgency_hint: GdkWindow not realized") ); wxASSERT_MSG(window, "wxgtk_window_set_urgency_hint: GdkWindow not realized");
GdkWindow *window = GTK_WIDGET(win)->window;
XWMHints *wm_hints; XWMHints *wm_hints;
wm_hints = XGetWMHints(GDK_WINDOW_XDISPLAY(window), GDK_WINDOW_XWINDOW(window)); wm_hints = XGetWMHints(GDK_WINDOW_XDISPLAY(window), GDK_WINDOW_XWINDOW(window));
@@ -219,8 +218,9 @@ size_allocate(GtkWidget*, GtkAllocation* alloc, wxTopLevelWindowGTK* win)
win->m_oldClientWidth = alloc->width; win->m_oldClientWidth = alloc->width;
win->m_oldClientHeight = alloc->height; win->m_oldClientHeight = alloc->height;
wxSize size(win->m_widget->allocation.width, GtkAllocation a;
win->m_widget->allocation.height); gtk_widget_get_allocation(win->m_widget, &a);
wxSize size(a.width, a.height);
size += win->m_decorSize; size += win->m_decorSize;
win->m_width = size.x; win->m_width = size.x;
win->m_height = size.y; win->m_height = size.y;
@@ -309,16 +309,18 @@ static void
gtk_frame_realized_callback( GtkWidget * WXUNUSED(widget), gtk_frame_realized_callback( GtkWidget * WXUNUSED(widget),
wxTopLevelWindowGTK *win ) wxTopLevelWindowGTK *win )
{ {
gdk_window_set_decorations(win->m_widget->window, gdk_window_set_decorations(gtk_widget_get_window(win->m_widget),
(GdkWMDecoration)win->m_gdkDecor); (GdkWMDecoration)win->m_gdkDecor);
gdk_window_set_functions(win->m_widget->window, gdk_window_set_functions(gtk_widget_get_window(win->m_widget),
(GdkWMFunction)win->m_gdkFunc); (GdkWMFunction)win->m_gdkFunc);
// GTK's shrinking/growing policy // GTK's shrinking/growing policy
if ( !(win->m_gdkFunc & GDK_FUNC_RESIZE) ) if ( !(win->m_gdkFunc & GDK_FUNC_RESIZE) )
gtk_window_set_resizable(GTK_WINDOW(win->m_widget), FALSE); gtk_window_set_resizable(GTK_WINDOW(win->m_widget), FALSE);
#if !GTK_CHECK_VERSION(3,0,0) && !defined(GTK_DISABLE_DEPRECATED)
else else
gtk_window_set_policy(GTK_WINDOW(win->m_widget), 1, 1, 1); gtk_window_set_policy(GTK_WINDOW(win->m_widget), 1, 1, 1);
#endif
const wxIconBundle& icons = win->GetIcons(); const wxIconBundle& icons = win->GetIcons();
if (icons.GetIconCount()) if (icons.GetIconCount())
@@ -565,7 +567,7 @@ bool wxTopLevelWindowGTK::Create( wxWindow *parent,
#endif #endif
gtk_window_set_title( GTK_WINDOW(m_widget), wxGTK_CONV( title ) ); gtk_window_set_title( GTK_WINDOW(m_widget), wxGTK_CONV( title ) );
GTK_WIDGET_UNSET_FLAGS( m_widget, GTK_CAN_FOCUS ); gtk_widget_set_can_focus(m_widget, false);
g_signal_connect (m_widget, "delete_event", g_signal_connect (m_widget, "delete_event",
G_CALLBACK (gtk_frame_delete_callback), this); G_CALLBACK (gtk_frame_delete_callback), this);
@@ -573,7 +575,7 @@ bool wxTopLevelWindowGTK::Create( wxWindow *parent,
// m_mainWidget is a GtkVBox, holding the bars and client area (m_wxwindow) // m_mainWidget is a GtkVBox, holding the bars and client area (m_wxwindow)
m_mainWidget = gtk_vbox_new(false, 0); m_mainWidget = gtk_vbox_new(false, 0);
gtk_widget_show( m_mainWidget ); gtk_widget_show( m_mainWidget );
GTK_WIDGET_UNSET_FLAGS( m_mainWidget, GTK_CAN_FOCUS ); gtk_widget_set_can_focus(m_mainWidget, false);
gtk_container_add( GTK_CONTAINER(m_widget), m_mainWidget ); gtk_container_add( GTK_CONTAINER(m_widget), m_mainWidget );
// m_wxwindow is the client area // m_wxwindow is the client area
@@ -583,7 +585,7 @@ bool wxTopLevelWindowGTK::Create( wxWindow *parent,
// we donm't allow the frame to get the focus as otherwise // we donm't allow the frame to get the focus as otherwise
// the frame will grab it at arbitrary focus changes // the frame will grab it at arbitrary focus changes
GTK_WIDGET_UNSET_FLAGS( m_wxwindow, GTK_CAN_FOCUS ); gtk_widget_set_can_focus(m_wxwindow, false);
if (m_parent) m_parent->AddChild( this ); if (m_parent) m_parent->AddChild( this );
@@ -594,8 +596,10 @@ bool wxTopLevelWindowGTK::Create( wxWindow *parent,
G_CALLBACK (wxgtk_tlw_size_request_callback), this); G_CALLBACK (wxgtk_tlw_size_request_callback), this);
PostCreation(); PostCreation();
#if !GTK_CHECK_VERSION(3,0,0) && !defined(GTK_DISABLE_DEPRECATED)
if ((m_x != -1) || (m_y != -1)) if ((m_x != -1) || (m_y != -1))
gtk_widget_set_uposition( m_widget, m_x, m_y ); gtk_widget_set_uposition( m_widget, m_x, m_y );
#endif
// we cannot set MWM hints and icons before the widget has // we cannot set MWM hints and icons before the widget has
// been realized, so we do this directly after realization // been realized, so we do this directly after realization
@@ -714,8 +718,9 @@ bool wxTopLevelWindowGTK::EnableCloseButton( bool enable )
else else
m_gdkFunc &= ~GDK_FUNC_CLOSE; m_gdkFunc &= ~GDK_FUNC_CLOSE;
if (gtk_widget_get_realized(m_widget) && (m_widget->window)) GdkWindow* window = gtk_widget_get_window(m_widget);
gdk_window_set_functions( m_widget->window, (GdkWMFunction)m_gdkFunc ); if (window)
gdk_window_set_functions(window, (GdkWMFunction)m_gdkFunc);
return true; return true;
} }
@@ -744,7 +749,7 @@ bool wxTopLevelWindowGTK::ShowFullScreen(bool show, long)
} }
else else
{ {
GdkWindow *window = m_widget->window; GdkWindow* window = gtk_widget_get_window(m_widget);
if (show) if (show)
{ {
@@ -763,12 +768,11 @@ bool wxTopLevelWindowGTK::ShowFullScreen(bool show, long)
gdk_window_set_decorations(window, (GdkWMDecoration)0); gdk_window_set_decorations(window, (GdkWMDecoration)0);
gdk_window_set_functions(window, (GdkWMFunction)0); gdk_window_set_functions(window, (GdkWMFunction)0);
gdk_window_get_origin (m_widget->window, &root_x, &root_y); gdk_window_get_origin(window, &root_x, &root_y);
gdk_window_get_geometry (m_widget->window, &client_x, &client_y, gdk_window_get_geometry(window, &client_x, &client_y, &width, &height, NULL);
&width, &height, NULL);
gdk_window_move_resize (m_widget->window, -client_x, -client_y, gdk_window_move_resize(
screen_width + 1, screen_height + 1); window, -client_x, -client_y, screen_width + 1, screen_height + 1);
wxSetFullScreenStateX11((WXDisplay*)GDK_DISPLAY(), wxSetFullScreenStateX11((WXDisplay*)GDK_DISPLAY(),
(WXWindow)GDK_ROOT_WINDOW(), (WXWindow)GDK_ROOT_WINDOW(),
@@ -810,8 +814,11 @@ void wxTopLevelWindowGTK::Refresh( bool WXUNUSED(eraseBackground), const wxRect
gtk_widget_queue_draw( m_widget ); gtk_widget_queue_draw( m_widget );
if (m_wxwindow && m_wxwindow->window) GdkWindow* window = NULL;
gdk_window_invalidate_rect( m_wxwindow->window, NULL, TRUE ); if (m_wxwindow)
window = gtk_widget_get_window(m_wxwindow);
if (window)
gdk_window_invalidate_rect(window, NULL, true);
} }
bool wxTopLevelWindowGTK::Show( bool show ) bool wxTopLevelWindowGTK::Show( bool show )
@@ -864,23 +871,32 @@ bool wxTopLevelWindowGTK::Show( bool show )
// causes the widget tree to be size_allocated, which generates size // causes the widget tree to be size_allocated, which generates size
// events in the wrong order. However, the size_allocates will not be // events in the wrong order. However, the size_allocates will not be
// done if the allocation is not the default (1,1). // done if the allocation is not the default (1,1).
const int alloc_width = m_widget->allocation.width; GtkAllocation alloc;
gtk_widget_get_allocation(m_widget, &alloc);
const int alloc_width = alloc.width;
if (alloc_width == 1) if (alloc_width == 1)
m_widget->allocation.width = 2; {
alloc.width = 2;
gtk_widget_set_allocation(m_widget, &alloc);
}
gtk_widget_realize(m_widget); gtk_widget_realize(m_widget);
if (alloc_width == 1) if (alloc_width == 1)
m_widget->allocation.width = 1; {
alloc.width = 1;
gtk_widget_set_allocation(m_widget, &alloc);
}
// send _NET_REQUEST_FRAME_EXTENTS // send _NET_REQUEST_FRAME_EXTENTS
XClientMessageEvent xevent; XClientMessageEvent xevent;
memset(&xevent, 0, sizeof(xevent)); memset(&xevent, 0, sizeof(xevent));
xevent.type = ClientMessage; xevent.type = ClientMessage;
xevent.window = gdk_x11_drawable_get_xid(m_widget->window); GdkWindow* window = gtk_widget_get_window(m_widget);
xevent.window = gdk_x11_drawable_get_xid(window);
xevent.message_type = gdk_x11_atom_to_xatom_for_display( xevent.message_type = gdk_x11_atom_to_xatom_for_display(
gdk_drawable_get_display(m_widget->window), gdk_drawable_get_display(window),
gdk_atom_intern("_NET_REQUEST_FRAME_EXTENTS", false)); gdk_atom_intern("_NET_REQUEST_FRAME_EXTENTS", false));
xevent.format = 32; xevent.format = 32;
Display* display = gdk_x11_drawable_get_xdisplay(m_widget->window); Display* display = gdk_x11_drawable_get_xdisplay(window);
XSendEvent(display, DefaultRootWindow(display), false, XSendEvent(display, DefaultRootWindow(display), false,
SubstructureNotifyMask | SubstructureRedirectMask, SubstructureNotifyMask | SubstructureRedirectMask,
(XEvent*)&xevent); (XEvent*)&xevent);
@@ -1219,8 +1235,8 @@ void wxTopLevelWindowGTK::Maximize(bool maximize)
bool wxTopLevelWindowGTK::IsMaximized() const bool wxTopLevelWindowGTK::IsMaximized() const
{ {
return m_widget->window && GdkWindow* window = gtk_widget_get_window(m_widget);
(gdk_window_get_state(m_widget->window) & GDK_WINDOW_STATE_MAXIMIZED); return window && (gdk_window_get_state(window) & GDK_WINDOW_STATE_MAXIMIZED);
} }
void wxTopLevelWindowGTK::Restore() void wxTopLevelWindowGTK::Restore()
@@ -1299,9 +1315,9 @@ bool wxTopLevelWindowGTK::SetShape(const wxRegion& region)
if ( gtk_widget_get_realized(m_widget) ) if ( gtk_widget_get_realized(m_widget) )
{ {
if ( m_wxwindow ) if ( m_wxwindow )
do_shape_combine_region(m_wxwindow->window, region); do_shape_combine_region(gtk_widget_get_window(m_wxwindow), region);
return do_shape_combine_region(m_widget->window, region); return do_shape_combine_region(gtk_widget_get_window(m_widget), region);
} }
else // not realized yet else // not realized yet
{ {
@@ -1403,14 +1419,17 @@ static Window wxGetTopmostWindowX11(Display *dpy, Window child)
bool wxTopLevelWindowGTK::SetTransparent(wxByte alpha) bool wxTopLevelWindowGTK::SetTransparent(wxByte alpha)
{ {
if (!m_widget || !m_widget->window) GdkWindow* window = NULL;
if (m_widget)
window = gtk_widget_get_window(m_widget);
if (window == NULL)
return false; return false;
Display* dpy = GDK_WINDOW_XDISPLAY (m_widget->window); Display* dpy = GDK_WINDOW_XDISPLAY(window);
// We need to get the X Window that has the root window as the immediate parent // We need to get the X Window that has the root window as the immediate parent
// and m_widget->window as a child. This should be the X Window that the WM manages and // and m_widget->window as a child. This should be the X Window that the WM manages and
// from which the opacity property is checked from. // from which the opacity property is checked from.
Window win = wxGetTopmostWindowX11(dpy, GDK_WINDOW_XID (m_widget->window)); Window win = wxGetTopmostWindowX11(dpy, GDK_WINDOW_XID(window));
// Using pure Xlib to not have a GTK version check mess due to gtk2.0 not having GdkDisplay // Using pure Xlib to not have a GTK version check mess due to gtk2.0 not having GdkDisplay

7
src/gtk/treeentry_gtk.c
View File

@@ -9,9 +9,6 @@
#ifdef __VMS #ifdef __VMS
#include <types.h> #include <types.h>
typedef pid_t GPid;
#define G_GNUC_INTERNAL
#define GSEAL(x) x
#endif #endif
#include "wx/gtk/treeentry_gtk.h" #include "wx/gtk/treeentry_gtk.h"
@@ -46,10 +43,10 @@ gtk_tree_entry_new()
return GTK_TREE_ENTRY(g_object_new(GTK_TYPE_TREE_ENTRY, NULL)); return GTK_TREE_ENTRY(g_object_new(GTK_TYPE_TREE_ENTRY, NULL));
} }
GtkType GType
gtk_tree_entry_get_type () gtk_tree_entry_get_type ()
{ {
static GtkType tree_entry_type = 0; static GType tree_entry_type = 0;
if (!tree_entry_type) if (!tree_entry_type)
{ {

22
src/gtk/utilsgtk.cpp
View File

@@ -100,7 +100,7 @@ bool wxColourDisplay()
int wxDisplayDepth() int wxDisplayDepth()
{ {
return gdk_drawable_get_visual( wxGetRootWindow()->window )->depth; return gtk_widget_get_visual(wxGetRootWindow())->depth;
} }
wxWindow* wxFindWindowAtPoint(const wxPoint& pt) wxWindow* wxFindWindowAtPoint(const wxPoint& pt)
@@ -186,31 +186,25 @@ const gchar *wx_pango_version_check (int major, int minor, int micro)
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
extern "C" { extern "C" {
static static gboolean EndProcessDetector(GIOChannel* source, GIOCondition, void* data)
void GTK_EndProcessDetector(gpointer data, gint source,
GdkInputCondition WXUNUSED(condition))
{ {
wxEndProcessData * const wxEndProcessData * const
proc_data = static_cast<wxEndProcessData *>(data); proc_data = static_cast<wxEndProcessData *>(data);
// child exited, end waiting // child exited, end waiting
close(source); close(g_io_channel_unix_get_fd(source));
// don't call us again!
gdk_input_remove(proc_data->tag);
wxHandleProcessTermination(proc_data); wxHandleProcessTermination(proc_data);
// don't call us again!
return false;
} }
} }
int wxGUIAppTraits::AddProcessCallback(wxEndProcessData *proc_data, int fd) int wxGUIAppTraits::AddProcessCallback(wxEndProcessData *proc_data, int fd)
{ {
int tag = gdk_input_add(fd, return g_io_add_watch(
GDK_INPUT_READ, g_io_channel_unix_new(fd), G_IO_IN, EndProcessDetector, proc_data);
GTK_EndProcessDetector,
(gpointer)proc_data);
return tag;
} }