#if wxUSE_SLIDER
-#ifdef __VMS
- //Missing definition in OpenVMS C++ header files.
- double round(double __x);
-#endif
-
#include "wx/slider.h"
#ifndef WX_PRECOMP
#include "wx/utils.h"
+ #include "wx/math.h"
#endif
-#include "wx/gtk/private.h"
+#include <gtk/gtk.h>
//-----------------------------------------------------------------------------
// data
static void
gtk_value_changed(GtkRange* range, wxSlider* win)
{
- if (g_isIdle) wxapp_install_idle_handler();
-
- if (!win->m_hasVMT) return;
- if (g_blockEventsOnDrag) return;
-
- GtkAdjustment* adj = range->adjustment;
- const int pos = int(round(adj->value));
+ GtkAdjustment* adj = gtk_range_get_adjustment (range);
+ const int pos = wxRound(adj->value);
const double oldPos = win->m_pos;
win->m_pos = adj->value;
+
+ if (!win->m_hasVMT || g_blockEventsOnDrag)
+ return;
+
if (win->m_blockScrollEvent)
{
win->m_scrollEventType = GTK_SCROLL_NONE;
win->m_scrollEventType = GTK_SCROLL_NONE;
// If integral position has changed
- if (int(round(oldPos)) != pos)
+ if (wxRound(oldPos) != pos)
{
- wxCHECK_RET(eventType != wxEVT_NULL, _T("Unknown slider scroll event type"));
ProcessScrollEvent(win, eventType);
win->m_needThumbRelease = eventType == wxEVT_SCROLL_THUMBTRACK;
}
}
}
-// Single shot idle callback, to generate thumb release event, and
-// truncate position to integral value. Idle callback is used
-// because position cannot be changed from button release event.
+//-----------------------------------------------------------------------------
+// "event_after"
+//-----------------------------------------------------------------------------
+
extern "C" {
-static gboolean
-idle_thumbrelease(void* data)
+static void
+gtk_event_after(GtkRange* range, GdkEvent* event, wxSlider* win)
{
- gdk_threads_enter();
- wxSlider* win = (wxSlider*)data;
- win->m_isScrolling = false;
- if (win->m_needThumbRelease)
+ if (event->type == GDK_BUTTON_RELEASE)
{
- win->m_needThumbRelease = false;
- ProcessScrollEvent(win, wxEVT_SCROLL_THUMBRELEASE);
+ g_signal_handlers_block_by_func(range, (gpointer) gtk_event_after, win);
+
+ if (win->m_needThumbRelease)
+ {
+ win->m_needThumbRelease = false;
+ ProcessScrollEvent(win, wxEVT_SCROLL_THUMBRELEASE);
+ }
+ // Keep slider at an integral position
+ win->m_blockScrollEvent = true;
+ gtk_range_set_value(GTK_RANGE (win->m_widget), win->GetValue());
+ win->m_blockScrollEvent = false;
}
- // Keep slider at an integral position
- win->BlockScrollEvent();
- gtk_range_set_value((GtkRange*)win->m_widget, win->GetValue());
- win->UnblockScrollEvent();
- gdk_threads_leave();
- return false;
}
}
extern "C" {
static gboolean
-gtk_button_release_event(GtkWidget*, GdkEventButton*, wxSlider* win)
+gtk_button_release_event(GtkRange* range, GdkEventButton*, wxSlider* win)
{
win->m_mouseButtonDown = false;
if (win->m_isScrolling)
{
- g_idle_add(idle_thumbrelease, win);
+ win->m_isScrolling = false;
+ g_signal_handlers_unblock_by_func(range, (gpointer) gtk_event_after, win);
}
return false;
}
static gchar* gtk_format_value(GtkScale*, double value, void*)
{
// Format value as nearest integer
- return g_strdup_printf("%d", int(round(value)));
+ return g_strdup_printf("%d", wxRound(value));
}
}
wxSlider::wxSlider()
{
m_pos = 0;
- m_scrollEventType = 0;
+ m_scrollEventType = GTK_SCROLL_NONE;
m_needThumbRelease = false;
+ m_blockScrollEvent = false;
}
-bool wxSlider::Create(wxWindow *parent, wxWindowID id,
- int value, int minValue, int maxValue,
- const wxPoint& pos, const wxSize& size,
- long style, const wxValidator& validator, const wxString& name )
+bool wxSlider::Create(wxWindow *parent,
+ wxWindowID id,
+ int value,
+ int minValue,
+ int maxValue,
+ const wxPoint& pos,
+ const wxSize& size,
+ long style,
+ const wxValidator& validator,
+ const wxString& name)
{
- m_acceptsFocus = true;
- m_needParent = true;
+ m_pos = value;
+ m_scrollEventType = GTK_SCROLL_NONE;
if (!PreCreation( parent, pos, size ) ||
!CreateBase( parent, id, pos, size, style, validator, name ))
return false;
}
- m_pos = 0;
- m_scrollEventType = 0;
- m_needThumbRelease = false;
-
if (style & wxSL_VERTICAL)
m_widget = gtk_vscale_new( (GtkAdjustment *) NULL );
else
m_widget = gtk_hscale_new( (GtkAdjustment *) NULL );
- gtk_scale_set_draw_value((GtkScale*)m_widget, (style & wxSL_LABELS) != 0);
+ gtk_scale_set_draw_value(GTK_SCALE (m_widget), (style & wxSL_LABELS) != 0);
// Keep full precision in position value
- gtk_scale_set_digits((GtkScale*)m_widget, -1);
+ gtk_scale_set_digits(GTK_SCALE (m_widget), -1);
if (style & wxSL_INVERSE)
gtk_range_set_inverted( GTK_RANGE(m_widget), TRUE );
g_signal_connect(m_widget, "move_slider", G_CALLBACK(gtk_move_slider), this);
g_signal_connect(m_widget, "format_value", G_CALLBACK(gtk_format_value), NULL);
g_signal_connect(m_widget, "value_changed", G_CALLBACK(gtk_value_changed), this);
+ gulong handler_id = g_signal_connect(m_widget, "event_after", G_CALLBACK(gtk_event_after), this);
+ g_signal_handler_block(m_widget, handler_id);
SetRange( minValue, maxValue );
- SetValue( value );
+
+ // don't call the public SetValue() as it won't do anything unless the
+ // value really changed
+ GTKSetValue( value );
m_parent->DoAddChild( this );
int wxSlider::GetValue() const
{
- return int(round(m_pos));
+ return wxRound(m_pos);
}
void wxSlider::SetValue( int value )
{
if (GetValue() != value)
- {
- BlockScrollEvent();
- gtk_range_set_value((GtkRange*)m_widget, value);
- UnblockScrollEvent();
- }
+ GTKSetValue(value);
+}
+
+void wxSlider::GTKSetValue(int value)
+{
+ m_blockScrollEvent = true;
+ gtk_range_set_value(GTK_RANGE (m_widget), value);
+ m_blockScrollEvent = false;
}
void wxSlider::SetRange( int minValue, int maxValue )
{
- BlockScrollEvent();
- gtk_range_set_range((GtkRange*)m_widget, minValue, maxValue);
- gtk_range_set_increments((GtkRange*)m_widget, 1, (maxValue - minValue + 9) / 10);
- UnblockScrollEvent();
+ m_blockScrollEvent = true;
+ gtk_range_set_range(GTK_RANGE (m_widget), minValue, maxValue);
+ gtk_range_set_increments(GTK_RANGE (m_widget), 1, (maxValue - minValue + 9) / 10);
+ m_blockScrollEvent = false;
}
int wxSlider::GetMin() const
{
- return int(((GtkRange*)m_widget)->adjustment->lower);
+ return int(gtk_range_get_adjustment (GTK_RANGE (m_widget))->lower);
}
int wxSlider::GetMax() const
{
- return int(((GtkRange*)m_widget)->adjustment->upper);
+ return int(gtk_range_get_adjustment (GTK_RANGE (m_widget))->upper);
}
void wxSlider::SetPageSize( int pageSize )
{
- BlockScrollEvent();
- gtk_range_set_increments((GtkRange*)m_widget, 1, pageSize);
- UnblockScrollEvent();
+ m_blockScrollEvent = true;
+ gtk_range_set_increments(GTK_RANGE (m_widget), GetLineSize(), pageSize);
+ m_blockScrollEvent = false;
}
int wxSlider::GetPageSize() const
{
- return int(((GtkRange*)m_widget)->adjustment->page_increment);
+ return int(gtk_range_get_adjustment (GTK_RANGE (m_widget))->page_increment);
}
// GTK does not support changing the size of the slider
return 0;
}
-void wxSlider::SetLineSize( int WXUNUSED(lineSize) )
+void wxSlider::SetLineSize( int lineSize )
{
+ m_blockScrollEvent = true;
+ gtk_range_set_increments(GTK_RANGE (m_widget), lineSize, GetPageSize());
+ m_blockScrollEvent = false;
}
int wxSlider::GetLineSize() const
{
- return 0;
+ return int(gtk_range_get_adjustment (GTK_RANGE (m_widget))->step_increment);
}
-bool wxSlider::IsOwnGtkWindow( GdkWindow *window )
+GdkWindow *wxSlider::GTKGetWindow(wxArrayGdkWindows& WXUNUSED(windows)) const
{
- GtkRange *range = GTK_RANGE(m_widget);
- return (range->event_window == window);
+ return GTK_RANGE(m_widget)->event_window;
}
// static
projects / wxWidgets.git / blobdiff