src/gtk/slider.cpp

/////////////////////////////////////////////////////////////////////////////
// Name:        src/gtk/slider.cpp
// Purpose:
// Author:      Robert Roebling
// Id:          $Id$
// Copyright:   (c) 1998 Robert Roebling
// Licence:     wxWindows licence
/////////////////////////////////////////////////////////////////////////////

// For compilers that support precompilation, includes "wx.h".
#include "wx/wxprec.h"

#if wxUSE_SLIDER

#include "wx/slider.h"

#ifndef WX_PRECOMP
    #include "wx/utils.h"
    #include "wx/math.h"
#endif

#include <gtk/gtk.h>

//-----------------------------------------------------------------------------
// data
//-----------------------------------------------------------------------------

extern bool g_blockEventsOnDrag;

// ----------------------------------------------------------------------------
// helper functions
// ----------------------------------------------------------------------------

// process a scroll event
static void
ProcessScrollEvent(wxSlider *win, wxEventType evtType)
{
    const int orient = win->HasFlag(wxSL_VERTICAL) ? wxVERTICAL
                                                   : wxHORIZONTAL;

    const int value = win->GetValue();

    // if we have any "special" event (i.e. the value changed by a line or a
    // page), send this specific event first
    if ( evtType != wxEVT_NULL )
    {
        wxScrollEvent event( evtType, win->GetId(), value, orient );
        event.SetEventObject( win );
        win->HandleWindowEvent( event );
    }

    // but, in any case, except if we're dragging the slider (and so the change
    // is not definitive), send a generic "changed" event
    if ( evtType != wxEVT_SCROLL_THUMBTRACK )
    {
        wxScrollEvent event(wxEVT_SCROLL_CHANGED, win->GetId(), value, orient);
        event.SetEventObject( win );
        win->HandleWindowEvent( event );
    }

    // and also generate a command event for compatibility
    wxCommandEvent event( wxEVT_COMMAND_SLIDER_UPDATED, win->GetId() );
    event.SetEventObject( win );
    event.SetInt( value );
    win->HandleWindowEvent( event );
}

static inline wxEventType GtkScrollTypeToWx(int scrollType)
{
    wxEventType eventType;
    switch (scrollType)
    {
    case GTK_SCROLL_STEP_BACKWARD:
    case GTK_SCROLL_STEP_LEFT:
    case GTK_SCROLL_STEP_UP:
        eventType = wxEVT_SCROLL_LINEUP;
        break;
    case GTK_SCROLL_STEP_DOWN:
    case GTK_SCROLL_STEP_FORWARD:
    case GTK_SCROLL_STEP_RIGHT:
        eventType = wxEVT_SCROLL_LINEDOWN;
        break;
    case GTK_SCROLL_PAGE_BACKWARD:
    case GTK_SCROLL_PAGE_LEFT:
    case GTK_SCROLL_PAGE_UP:
        eventType = wxEVT_SCROLL_PAGEUP;
        break;
    case GTK_SCROLL_PAGE_DOWN:
    case GTK_SCROLL_PAGE_FORWARD:
    case GTK_SCROLL_PAGE_RIGHT:
        eventType = wxEVT_SCROLL_PAGEDOWN;
        break;
    case GTK_SCROLL_START:
        eventType = wxEVT_SCROLL_TOP;
        break;
    case GTK_SCROLL_END:
        eventType = wxEVT_SCROLL_BOTTOM;
        break;
    case GTK_SCROLL_JUMP:
        eventType = wxEVT_SCROLL_THUMBTRACK;
        break;
    default:
        wxFAIL_MSG(wxT("Unknown GtkScrollType"));
        eventType = wxEVT_NULL;
        break;
    }
    return eventType;
}

// Determine if increment is the same as +/-x, allowing for some small
//   difference due to possible inexactness in floating point arithmetic
static inline bool IsScrollIncrement(double increment, double x)
{
    wxASSERT(increment > 0);
    const double tolerance = 1.0 / 1024;
    return fabs(increment - fabs(x)) < tolerance;
}

//-----------------------------------------------------------------------------
// "value_changed"
//-----------------------------------------------------------------------------

extern "C" {
static void
gtk_value_changed(GtkRange* range, wxSlider* win)
{
    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->GTKEventsDisabled())
    {
        win->m_scrollEventType = GTK_SCROLL_NONE;
        return;
    }

    wxEventType eventType = wxEVT_NULL;
    if (win->m_isScrolling)
    {
        eventType = wxEVT_SCROLL_THUMBTRACK;
    }
    else if (win->m_scrollEventType != GTK_SCROLL_NONE)
    {
        // Scroll event from "move-slider" (keyboard)
        eventType = GtkScrollTypeToWx(win->m_scrollEventType);
    }
    else if (win->m_mouseButtonDown)
    {
        // Difference from last change event
        const double diff = adj->value - oldPos;
        const bool isDown = diff > 0;

        if (IsScrollIncrement(adj->page_increment, diff))
        {
            eventType = isDown ? wxEVT_SCROLL_PAGEDOWN : wxEVT_SCROLL_PAGEUP;
        }
        else if (wxIsSameDouble(adj->value, 0))
        {
            eventType = wxEVT_SCROLL_PAGEUP;
        }
        else if (wxIsSameDouble(adj->value, adj->upper))
        {
            eventType = wxEVT_SCROLL_PAGEDOWN;
        }
        else
        {
            // Assume track event
            eventType = wxEVT_SCROLL_THUMBTRACK;
            // Remember that we're tracking
            win->m_isScrolling = true;
        }
    }

    win->m_scrollEventType = GTK_SCROLL_NONE;

    // If integral position has changed
    if (wxRound(oldPos) != pos)
    {
        ProcessScrollEvent(win, eventType);
        win->m_needThumbRelease = eventType == wxEVT_SCROLL_THUMBTRACK;
    }
}
}

//-----------------------------------------------------------------------------
// "move_slider" (keyboard event)
//-----------------------------------------------------------------------------

extern "C" {
static void
gtk_move_slider(GtkRange*, GtkScrollType scrollType, wxSlider* win)
{
    // Save keyboard scroll type for "value_changed" handler
    win->m_scrollEventType = scrollType;
}
}

//-----------------------------------------------------------------------------
// "button_press_event"
//-----------------------------------------------------------------------------

extern "C" {
static gboolean
gtk_button_press_event(GtkWidget*, GdkEventButton*, wxSlider* win)
{
    win->m_mouseButtonDown = true;

    return false;
}
}

//-----------------------------------------------------------------------------
// "event_after"
//-----------------------------------------------------------------------------

extern "C" {
static void
gtk_event_after(GtkRange* range, GdkEvent* event, wxSlider* win)
{
    if (event->type == GDK_BUTTON_RELEASE)
    {
        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->GTKDisableEvents();
        gtk_range_set_value(GTK_RANGE (win->m_scale), win->GetValue());
        win->GTKEnableEvents();
    }
}
}

//-----------------------------------------------------------------------------
// "button_release_event"
//-----------------------------------------------------------------------------

extern "C" {
static gboolean
gtk_button_release_event(GtkRange* range, GdkEventButton*, wxSlider* win)
{
    win->m_mouseButtonDown = false;
    if (win->m_isScrolling)
    {
        win->m_isScrolling = false;
        g_signal_handlers_unblock_by_func(range, (gpointer) gtk_event_after, win);
    }
    return false;
}
}

//-----------------------------------------------------------------------------
// "format_value"
//-----------------------------------------------------------------------------

extern "C" {
static gchar* gtk_format_value(GtkScale*, double value, void*)
{
    // Format value as nearest integer
    return g_strdup_printf("%d", wxRound(value));
}
}

//-----------------------------------------------------------------------------
// wxSlider
//-----------------------------------------------------------------------------

IMPLEMENT_DYNAMIC_CLASS(wxSlider,wxControl)

wxSlider::wxSlider()
{
    m_pos = 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)
{
    m_pos = value;
    m_scrollEventType = GTK_SCROLL_NONE;

    if (!PreCreation( parent, pos, size ) ||
        !CreateBase( parent, id, pos, size, style, validator, name ))
    {
        wxFAIL_MSG( wxT("wxSlider creation failed") );
        return false;
    }


    if (style & wxSL_VERTICAL)
        m_scale = gtk_vscale_new( NULL );
    else
        m_scale = gtk_hscale_new( NULL );
    g_object_ref(m_scale);

    if (style & wxSL_MIN_MAX_LABELS)
    {
        gtk_widget_show( m_scale );

        if (style & wxSL_VERTICAL)
            m_widget = gtk_hbox_new(false, 0);
        else
            m_widget = gtk_vbox_new(false, 0);
        g_object_ref(m_widget);
        gtk_widget_show( m_widget );
        gtk_container_add( GTK_CONTAINER(m_widget), m_scale );

        GtkWidget *box;
        if (style & wxSL_VERTICAL)
            box = gtk_vbox_new(false,0);
        else
            box = gtk_hbox_new(false,0);
        g_object_ref(box);
        gtk_widget_show(box);
        gtk_container_add( GTK_CONTAINER(m_widget), box );

        m_minLabel = gtk_label_new(NULL);
        g_object_ref(m_minLabel);
        gtk_widget_show( m_minLabel );
        gtk_container_add( GTK_CONTAINER(box), m_minLabel );
        gtk_box_set_child_packing( GTK_BOX(box), m_minLabel, FALSE, FALSE, 0, GTK_PACK_START );

        // expanding empty space between the min/max labels
        GtkWidget *space = gtk_label_new(NULL);
        g_object_ref(space);
        gtk_widget_show( space );
        gtk_container_add( GTK_CONTAINER(box), space );
        gtk_box_set_child_packing( GTK_BOX(box), space, TRUE, FALSE, 0, GTK_PACK_START );

        m_maxLabel = gtk_label_new(NULL);
        g_object_ref(m_maxLabel);
        gtk_widget_show( m_maxLabel );
        gtk_container_add( GTK_CONTAINER(box), m_maxLabel );
        gtk_box_set_child_packing( GTK_BOX(box), m_maxLabel, FALSE, FALSE, 0, GTK_PACK_END );
    }
    else
    {
        m_widget = m_scale;
        m_maxLabel = NULL;
        m_minLabel = NULL;
    }

    const bool showValueLabel = (style & wxSL_VALUE_LABEL) != 0;
    gtk_scale_set_draw_value(GTK_SCALE (m_scale), showValueLabel );
    if ( showValueLabel )
    {
        // position the label appropriately: notice that wxSL_DIRECTION flags
        // specify the position of the ticks, not label, under MSW and so the
        // label is on the opposite side
        GtkPositionType posLabel;
        if ( style & wxSL_VERTICAL )
        {
            if ( style & wxSL_LEFT )
                posLabel = GTK_POS_RIGHT;
            else // if ( style & wxSL_RIGHT ) -- this is also the default
                posLabel = GTK_POS_LEFT;
        }
        else // horizontal slider
        {
            if ( style & wxSL_TOP )
                posLabel = GTK_POS_BOTTOM;
            else // if ( style & wxSL_BOTTOM) -- this is again the default
                posLabel = GTK_POS_TOP;
        }

        gtk_scale_set_value_pos( GTK_SCALE(m_scale), posLabel );
    }

    // Keep full precision in position value
    gtk_scale_set_digits(GTK_SCALE (m_scale), -1);

    if (style & wxSL_INVERSE)
        gtk_range_set_inverted( GTK_RANGE(m_scale), TRUE );

    g_signal_connect(m_scale, "button_press_event", G_CALLBACK(gtk_button_press_event), this);
    g_signal_connect(m_scale, "button_release_event", G_CALLBACK(gtk_button_release_event), this);
    g_signal_connect(m_scale, "move_slider", G_CALLBACK(gtk_move_slider), this);
    g_signal_connect(m_scale, "format_value", G_CALLBACK(gtk_format_value), NULL);
    g_signal_connect(m_scale, "value_changed", G_CALLBACK(gtk_value_changed), this);
    gulong handler_id = g_signal_connect(m_scale, "event_after", G_CALLBACK(gtk_event_after), this);
    g_signal_handler_block(m_scale, handler_id);

    SetRange( minValue, maxValue );

    // don't call the public SetValue() as it won't do anything unless the
    // value really changed
    GTKSetValue( value );

    m_parent->DoAddChild( this );

    PostCreation(size);

    return true;
}

void wxSlider::GTKDisableEvents()
{
    m_blockScrollEvent = true;
}

void wxSlider::GTKEnableEvents()
{
    m_blockScrollEvent = false;
}

bool wxSlider::GTKEventsDisabled() const
{
   return m_blockScrollEvent;
}

int wxSlider::GetValue() const
{
    return wxRound(m_pos);
}

void wxSlider::SetValue( int value )
{
    if (GetValue() != value)
        GTKSetValue(value);
}

void wxSlider::GTKSetValue(int value)
{
    GTKDisableEvents();
    gtk_range_set_value(GTK_RANGE (m_scale), value);
    GTKEnableEvents();
}

void wxSlider::SetRange( int minValue, int maxValue )
{
    GTKDisableEvents();
    if (minValue == maxValue)
       maxValue++;
    gtk_range_set_range(GTK_RANGE (m_scale), minValue, maxValue);
    gtk_range_set_increments(GTK_RANGE (m_scale), 1, (maxValue - minValue + 9) / 10);
    GTKEnableEvents();

    if (HasFlag(wxSL_MIN_MAX_LABELS))
    {
        wxString str;

        str.Printf( "%d", minValue );
        if (HasFlag(wxSL_INVERSE))
            gtk_label_set_text( GTK_LABEL(m_maxLabel), str.utf8_str() );
        else
            gtk_label_set_text( GTK_LABEL(m_minLabel), str.utf8_str() );

        str.Printf( "%d", maxValue );
        if (HasFlag(wxSL_INVERSE))
            gtk_label_set_text( GTK_LABEL(m_minLabel), str.utf8_str() );
        else
            gtk_label_set_text( GTK_LABEL(m_maxLabel), str.utf8_str() );

    }
}

int wxSlider::GetMin() const
{
    return int(gtk_range_get_adjustment (GTK_RANGE (m_scale))->lower);
}

int wxSlider::GetMax() const
{
    return int(gtk_range_get_adjustment (GTK_RANGE (m_scale))->upper);
}

void wxSlider::SetPageSize( int pageSize )
{
    GTKDisableEvents();
    gtk_range_set_increments(GTK_RANGE (m_scale), GetLineSize(), pageSize);
    GTKEnableEvents();
}

int wxSlider::GetPageSize() const
{
    return int(gtk_range_get_adjustment (GTK_RANGE (m_scale))->page_increment);
}

// GTK does not support changing the size of the slider
void wxSlider::SetThumbLength(int)
{
}

int wxSlider::GetThumbLength() const
{
    return 0;
}

void wxSlider::SetLineSize( int lineSize )
{
    GTKDisableEvents();
    gtk_range_set_increments(GTK_RANGE (m_scale), lineSize, GetPageSize());
    GTKEnableEvents();
}

int wxSlider::GetLineSize() const
{
    return int(gtk_range_get_adjustment (GTK_RANGE (m_scale))->step_increment);
}

GdkWindow *wxSlider::GTKGetWindow(wxArrayGdkWindows& WXUNUSED(windows)) const
{
    return GTK_RANGE(m_scale)->event_window;
}

// static
wxVisualAttributes
wxSlider::GetClassDefaultAttributes(wxWindowVariant WXUNUSED(variant))
{
    return GetDefaultAttributesFromGTKWidget(gtk_vscale_new);
}

#endif // wxUSE_SLIDER
Commit	Line	Data
	1	/////////////////////////////////////////////////////////////////////////////
	2	// Name: src/gtk/slider.cpp
	3	// Purpose:
	4	// Author: Robert Roebling
	5	// Id: $Id$
	6	// Copyright: (c) 1998 Robert Roebling
	7	// Licence: wxWindows licence
	8	/////////////////////////////////////////////////////////////////////////////
	9
	10	// For compilers that support precompilation, includes "wx.h".
	11	#include "wx/wxprec.h"
	12
	13	#if wxUSE_SLIDER
	14
	15	#include "wx/slider.h"
	16
	17	#ifndef WX_PRECOMP
	18	#include "wx/utils.h"
	19	#include "wx/math.h"
	20	#endif
	21
	22	#include <gtk/gtk.h>
	23
	24	//-----------------------------------------------------------------------------
	25	// data
	26	//-----------------------------------------------------------------------------
	27
	28	extern bool g_blockEventsOnDrag;
	29
	30	// ----------------------------------------------------------------------------
	31	// helper functions
	32	// ----------------------------------------------------------------------------
	33
	34	// process a scroll event
	35	static void
	36	ProcessScrollEvent(wxSlider *win, wxEventType evtType)
	37	{
	38	const int orient = win->HasFlag(wxSL_VERTICAL) ? wxVERTICAL
	39	: wxHORIZONTAL;
	40
	41	const int value = win->GetValue();
	42
	43	// if we have any "special" event (i.e. the value changed by a line or a
	44	// page), send this specific event first
	45	if ( evtType != wxEVT_NULL )
	46	{
	47	wxScrollEvent event( evtType, win->GetId(), value, orient );
	48	event.SetEventObject( win );
	49	win->HandleWindowEvent( event );
	50	}
	51
	52	// but, in any case, except if we're dragging the slider (and so the change
	53	// is not definitive), send a generic "changed" event
	54	if ( evtType != wxEVT_SCROLL_THUMBTRACK )
	55	{
	56	wxScrollEvent event(wxEVT_SCROLL_CHANGED, win->GetId(), value, orient);
	57	event.SetEventObject( win );
	58	win->HandleWindowEvent( event );
	59	}
	60
	61	// and also generate a command event for compatibility
	62	wxCommandEvent event( wxEVT_COMMAND_SLIDER_UPDATED, win->GetId() );
	63	event.SetEventObject( win );
	64	event.SetInt( value );
	65	win->HandleWindowEvent( event );
	66	}
	67
	68	static inline wxEventType GtkScrollTypeToWx(int scrollType)
	69	{
	70	wxEventType eventType;
	71	switch (scrollType)
	72	{
	73	case GTK_SCROLL_STEP_BACKWARD:
	74	case GTK_SCROLL_STEP_LEFT:
	75	case GTK_SCROLL_STEP_UP:
	76	eventType = wxEVT_SCROLL_LINEUP;
	77	break;
	78	case GTK_SCROLL_STEP_DOWN:
	79	case GTK_SCROLL_STEP_FORWARD:
	80	case GTK_SCROLL_STEP_RIGHT:
	81	eventType = wxEVT_SCROLL_LINEDOWN;
	82	break;
	83	case GTK_SCROLL_PAGE_BACKWARD:
	84	case GTK_SCROLL_PAGE_LEFT:
	85	case GTK_SCROLL_PAGE_UP:
	86	eventType = wxEVT_SCROLL_PAGEUP;
	87	break;
	88	case GTK_SCROLL_PAGE_DOWN:
	89	case GTK_SCROLL_PAGE_FORWARD:
	90	case GTK_SCROLL_PAGE_RIGHT:
	91	eventType = wxEVT_SCROLL_PAGEDOWN;
	92	break;
	93	case GTK_SCROLL_START:
	94	eventType = wxEVT_SCROLL_TOP;
	95	break;
	96	case GTK_SCROLL_END:
	97	eventType = wxEVT_SCROLL_BOTTOM;
	98	break;
	99	case GTK_SCROLL_JUMP:
	100	eventType = wxEVT_SCROLL_THUMBTRACK;
	101	break;
	102	default:
	103	wxFAIL_MSG(wxT("Unknown GtkScrollType"));
	104	eventType = wxEVT_NULL;
	105	break;
	106	}
	107	return eventType;
	108	}
	109
	110	// Determine if increment is the same as +/-x, allowing for some small
	111	// difference due to possible inexactness in floating point arithmetic
	112	static inline bool IsScrollIncrement(double increment, double x)
	113	{
	114	wxASSERT(increment > 0);
	115	const double tolerance = 1.0 / 1024;
	116	return fabs(increment - fabs(x)) < tolerance;
	117	}
	118
	119	//-----------------------------------------------------------------------------
	120	// "value_changed"
	121	//-----------------------------------------------------------------------------
	122
	123	extern "C" {
	124	static void
	125	gtk_value_changed(GtkRange* range, wxSlider* win)
	126	{
	127	GtkAdjustment* adj = gtk_range_get_adjustment (range);
	128	const int pos = wxRound(adj->value);
	129	const double oldPos = win->m_pos;
	130	win->m_pos = adj->value;
	131
	132	if (!win->m_hasVMT \|\| g_blockEventsOnDrag)
	133	return;
	134
	135	if (win->GTKEventsDisabled())
	136	{
	137	win->m_scrollEventType = GTK_SCROLL_NONE;
	138	return;
	139	}
	140
	141	wxEventType eventType = wxEVT_NULL;
	142	if (win->m_isScrolling)
	143	{
	144	eventType = wxEVT_SCROLL_THUMBTRACK;
	145	}
	146	else if (win->m_scrollEventType != GTK_SCROLL_NONE)
	147	{
	148	// Scroll event from "move-slider" (keyboard)
	149	eventType = GtkScrollTypeToWx(win->m_scrollEventType);
	150	}
	151	else if (win->m_mouseButtonDown)
	152	{
	153	// Difference from last change event
	154	const double diff = adj->value - oldPos;
	155	const bool isDown = diff > 0;
	156
	157	if (IsScrollIncrement(adj->page_increment, diff))
	158	{
	159	eventType = isDown ? wxEVT_SCROLL_PAGEDOWN : wxEVT_SCROLL_PAGEUP;
	160	}
	161	else if (wxIsSameDouble(adj->value, 0))
	162	{
	163	eventType = wxEVT_SCROLL_PAGEUP;
	164	}
	165	else if (wxIsSameDouble(adj->value, adj->upper))
	166	{
	167	eventType = wxEVT_SCROLL_PAGEDOWN;
	168	}
	169	else
	170	{
	171	// Assume track event
	172	eventType = wxEVT_SCROLL_THUMBTRACK;
	173	// Remember that we're tracking
	174	win->m_isScrolling = true;
	175	}
	176	}
	177
	178	win->m_scrollEventType = GTK_SCROLL_NONE;
	179
	180	// If integral position has changed
	181	if (wxRound(oldPos) != pos)
	182	{
	183	ProcessScrollEvent(win, eventType);
	184	win->m_needThumbRelease = eventType == wxEVT_SCROLL_THUMBTRACK;
	185	}
	186	}
	187	}
	188
	189	//-----------------------------------------------------------------------------
	190	// "move_slider" (keyboard event)
	191	//-----------------------------------------------------------------------------
	192
	193	extern "C" {
	194	static void
	195	gtk_move_slider(GtkRange, GtkScrollType scrollType, wxSlider win)
	196	{
	197	// Save keyboard scroll type for "value_changed" handler
	198	win->m_scrollEventType = scrollType;
	199	}
	200	}
	201
	202	//-----------------------------------------------------------------------------
	203	// "button_press_event"
	204	//-----------------------------------------------------------------------------
	205
	206	extern "C" {
	207	static gboolean
	208	gtk_button_press_event(GtkWidget, GdkEventButton, wxSlider* win)
	209	{
	210	win->m_mouseButtonDown = true;
	211
	212	return false;
	213	}
	214	}
	215
	216	//-----------------------------------------------------------------------------
	217	// "event_after"
	218	//-----------------------------------------------------------------------------
	219
	220	extern "C" {
	221	static void
	222	gtk_event_after(GtkRange* range, GdkEvent* event, wxSlider* win)
	223	{
	224	if (event->type == GDK_BUTTON_RELEASE)
	225	{
	226	g_signal_handlers_block_by_func(range, (gpointer) gtk_event_after, win);
	227
	228	if (win->m_needThumbRelease)
	229	{
	230	win->m_needThumbRelease = false;
	231	ProcessScrollEvent(win, wxEVT_SCROLL_THUMBRELEASE);
	232	}
	233	// Keep slider at an integral position
	234	win->GTKDisableEvents();
	235	gtk_range_set_value(GTK_RANGE (win->m_scale), win->GetValue());
	236	win->GTKEnableEvents();
	237	}
	238	}
	239	}
	240
	241	//-----------------------------------------------------------------------------
	242	// "button_release_event"
	243	//-----------------------------------------------------------------------------
	244
	245	extern "C" {
	246	static gboolean
	247	gtk_button_release_event(GtkRange* range, GdkEventButton, wxSlider win)
	248	{
	249	win->m_mouseButtonDown = false;
	250	if (win->m_isScrolling)
	251	{
	252	win->m_isScrolling = false;
	253	g_signal_handlers_unblock_by_func(range, (gpointer) gtk_event_after, win);
	254	}
	255	return false;
	256	}
	257	}
	258
	259	//-----------------------------------------------------------------------------
	260	// "format_value"
	261	//-----------------------------------------------------------------------------
	262
	263	extern "C" {
	264	static gchar* gtk_format_value(GtkScale, double value, void)
	265	{
	266	// Format value as nearest integer
	267	return g_strdup_printf("%d", wxRound(value));
	268	}
	269	}
	270
	271	//-----------------------------------------------------------------------------
	272	// wxSlider
	273	//-----------------------------------------------------------------------------
	274
	275	IMPLEMENT_DYNAMIC_CLASS(wxSlider,wxControl)
	276
	277	wxSlider::wxSlider()
	278	{
	279	m_pos = 0;
	280	m_scrollEventType = GTK_SCROLL_NONE;
	281	m_needThumbRelease = false;
	282	m_blockScrollEvent = false;
	283	}
	284
	285	bool wxSlider::Create(wxWindow *parent,
	286	wxWindowID id,
	287	int value,
	288	int minValue,
	289	int maxValue,
	290	const wxPoint& pos,
	291	const wxSize& size,
	292	long style,
	293	const wxValidator& validator,
	294	const wxString& name)
	295	{
	296	m_pos = value;
	297	m_scrollEventType = GTK_SCROLL_NONE;
	298
	299	if (!PreCreation( parent, pos, size ) \|\|
	300	!CreateBase( parent, id, pos, size, style, validator, name ))
	301	{
	302	wxFAIL_MSG( wxT("wxSlider creation failed") );
	303	return false;
	304	}
	305
	306
	307	if (style & wxSL_VERTICAL)
	308	m_scale = gtk_vscale_new( NULL );
	309	else
	310	m_scale = gtk_hscale_new( NULL );
	311	g_object_ref(m_scale);
	312
	313	if (style & wxSL_MIN_MAX_LABELS)
	314	{
	315	gtk_widget_show( m_scale );
	316
	317	if (style & wxSL_VERTICAL)
	318	m_widget = gtk_hbox_new(false, 0);
	319	else
	320	m_widget = gtk_vbox_new(false, 0);
	321	g_object_ref(m_widget);
	322	gtk_widget_show( m_widget );
	323	gtk_container_add( GTK_CONTAINER(m_widget), m_scale );
	324
	325	GtkWidget *box;
	326	if (style & wxSL_VERTICAL)
	327	box = gtk_vbox_new(false,0);
	328	else
	329	box = gtk_hbox_new(false,0);
	330	g_object_ref(box);
	331	gtk_widget_show(box);
	332	gtk_container_add( GTK_CONTAINER(m_widget), box );
	333
	334	m_minLabel = gtk_label_new(NULL);
	335	g_object_ref(m_minLabel);
	336	gtk_widget_show( m_minLabel );
	337	gtk_container_add( GTK_CONTAINER(box), m_minLabel );
	338	gtk_box_set_child_packing( GTK_BOX(box), m_minLabel, FALSE, FALSE, 0, GTK_PACK_START );
	339
	340	// expanding empty space between the min/max labels
	341	GtkWidget *space = gtk_label_new(NULL);
	342	g_object_ref(space);
	343	gtk_widget_show( space );
	344	gtk_container_add( GTK_CONTAINER(box), space );
	345	gtk_box_set_child_packing( GTK_BOX(box), space, TRUE, FALSE, 0, GTK_PACK_START );
	346
	347	m_maxLabel = gtk_label_new(NULL);
	348	g_object_ref(m_maxLabel);
	349	gtk_widget_show( m_maxLabel );
	350	gtk_container_add( GTK_CONTAINER(box), m_maxLabel );
	351	gtk_box_set_child_packing( GTK_BOX(box), m_maxLabel, FALSE, FALSE, 0, GTK_PACK_END );
	352	}
	353	else
	354	{
	355	m_widget = m_scale;
	356	m_maxLabel = NULL;
	357	m_minLabel = NULL;
	358	}
	359
	360	const bool showValueLabel = (style & wxSL_VALUE_LABEL) != 0;
	361	gtk_scale_set_draw_value(GTK_SCALE (m_scale), showValueLabel );
	362	if ( showValueLabel )
	363	{
	364	// position the label appropriately: notice that wxSL_DIRECTION flags
	365	// specify the position of the ticks, not label, under MSW and so the
	366	// label is on the opposite side
	367	GtkPositionType posLabel;
	368	if ( style & wxSL_VERTICAL )
	369	{
	370	if ( style & wxSL_LEFT )
	371	posLabel = GTK_POS_RIGHT;
	372	else // if ( style & wxSL_RIGHT ) -- this is also the default
	373	posLabel = GTK_POS_LEFT;
	374	}
	375	else // horizontal slider
	376	{
	377	if ( style & wxSL_TOP )
	378	posLabel = GTK_POS_BOTTOM;
	379	else // if ( style & wxSL_BOTTOM) -- this is again the default
	380	posLabel = GTK_POS_TOP;
	381	}
	382
	383	gtk_scale_set_value_pos( GTK_SCALE(m_scale), posLabel );
	384	}
	385
	386	// Keep full precision in position value
	387	gtk_scale_set_digits(GTK_SCALE (m_scale), -1);
	388
	389	if (style & wxSL_INVERSE)
	390	gtk_range_set_inverted( GTK_RANGE(m_scale), TRUE );
	391
	392	g_signal_connect(m_scale, "button_press_event", G_CALLBACK(gtk_button_press_event), this);
	393	g_signal_connect(m_scale, "button_release_event", G_CALLBACK(gtk_button_release_event), this);
	394	g_signal_connect(m_scale, "move_slider", G_CALLBACK(gtk_move_slider), this);
	395	g_signal_connect(m_scale, "format_value", G_CALLBACK(gtk_format_value), NULL);
	396	g_signal_connect(m_scale, "value_changed", G_CALLBACK(gtk_value_changed), this);
	397	gulong handler_id = g_signal_connect(m_scale, "event_after", G_CALLBACK(gtk_event_after), this);
	398	g_signal_handler_block(m_scale, handler_id);
	399
	400	SetRange( minValue, maxValue );
	401
	402	// don't call the public SetValue() as it won't do anything unless the
	403	// value really changed
	404	GTKSetValue( value );
	405
	406	m_parent->DoAddChild( this );
	407
	408	PostCreation(size);
	409
	410	return true;
	411	}
	412
	413	void wxSlider::GTKDisableEvents()
	414	{
	415	m_blockScrollEvent = true;
	416	}
	417
	418	void wxSlider::GTKEnableEvents()
	419	{
	420	m_blockScrollEvent = false;
	421	}
	422
	423	bool wxSlider::GTKEventsDisabled() const
	424	{
	425	return m_blockScrollEvent;
	426	}
	427
	428	int wxSlider::GetValue() const
	429	{
	430	return wxRound(m_pos);
	431	}
	432
	433	void wxSlider::SetValue( int value )
	434	{
	435	if (GetValue() != value)
	436	GTKSetValue(value);
	437	}
	438
	439	void wxSlider::GTKSetValue(int value)
	440	{
	441	GTKDisableEvents();
	442	gtk_range_set_value(GTK_RANGE (m_scale), value);
	443	GTKEnableEvents();
	444	}
	445
	446	void wxSlider::SetRange( int minValue, int maxValue )
	447	{
	448	GTKDisableEvents();
	449	if (minValue == maxValue)
	450	maxValue++;
	451	gtk_range_set_range(GTK_RANGE (m_scale), minValue, maxValue);
	452	gtk_range_set_increments(GTK_RANGE (m_scale), 1, (maxValue - minValue + 9) / 10);
	453	GTKEnableEvents();
	454
	455	if (HasFlag(wxSL_MIN_MAX_LABELS))
	456	{
	457	wxString str;
	458
	459	str.Printf( "%d", minValue );
	460	if (HasFlag(wxSL_INVERSE))
	461	gtk_label_set_text( GTK_LABEL(m_maxLabel), str.utf8_str() );
	462	else
	463	gtk_label_set_text( GTK_LABEL(m_minLabel), str.utf8_str() );
	464
	465	str.Printf( "%d", maxValue );
	466	if (HasFlag(wxSL_INVERSE))
	467	gtk_label_set_text( GTK_LABEL(m_minLabel), str.utf8_str() );
	468	else
	469	gtk_label_set_text( GTK_LABEL(m_maxLabel), str.utf8_str() );
	470
	471	}
	472	}
	473
	474	int wxSlider::GetMin() const
	475	{
	476	return int(gtk_range_get_adjustment (GTK_RANGE (m_scale))->lower);
	477	}
	478
	479	int wxSlider::GetMax() const
	480	{
	481	return int(gtk_range_get_adjustment (GTK_RANGE (m_scale))->upper);
	482	}
	483
	484	void wxSlider::SetPageSize( int pageSize )
	485	{
	486	GTKDisableEvents();
	487	gtk_range_set_increments(GTK_RANGE (m_scale), GetLineSize(), pageSize);
	488	GTKEnableEvents();
	489	}
	490
	491	int wxSlider::GetPageSize() const
	492	{
	493	return int(gtk_range_get_adjustment (GTK_RANGE (m_scale))->page_increment);
	494	}
	495
	496	// GTK does not support changing the size of the slider
	497	void wxSlider::SetThumbLength(int)
	498	{
	499	}
	500
	501	int wxSlider::GetThumbLength() const
	502	{
	503	return 0;
	504	}
	505
	506	void wxSlider::SetLineSize( int lineSize )
	507	{
	508	GTKDisableEvents();
	509	gtk_range_set_increments(GTK_RANGE (m_scale), lineSize, GetPageSize());
	510	GTKEnableEvents();
	511	}
	512
	513	int wxSlider::GetLineSize() const
	514	{
	515	return int(gtk_range_get_adjustment (GTK_RANGE (m_scale))->step_increment);
	516	}
	517
	518	GdkWindow *wxSlider::GTKGetWindow(wxArrayGdkWindows& WXUNUSED(windows)) const
	519	{
	520	return GTK_RANGE(m_scale)->event_window;
	521	}
	522
	523	// static
	524	wxVisualAttributes
	525	wxSlider::GetClassDefaultAttributes(wxWindowVariant WXUNUSED(variant))
	526	{
	527	return GetDefaultAttributesFromGTKWidget(gtk_vscale_new);
	528	}
	529
	530	#endif // wxUSE_SLIDER