Implement wxSL_VALUE_LABEL and wxSL_MIN_MAX_LABELS for GTK+

git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@62635 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775

include/wx/gtk/slider.h

@@ -60,12 +60,19 @@ public:
     GetClassDefaultAttributes(wxWindowVariant variant = wxWINDOW_VARIANT_NORMAL);
 
     // implementation
+    void GTKDisableEvents();
+    void GTKEnableEvents();
+    bool GTKEventsDisabled() const;
+    
     double m_pos;
     int m_scrollEventType;
     bool m_needThumbRelease;
-    bool m_blockScrollEvent;
+    GtkWidget *m_scale;
 
 protected:
+    GtkWidget *m_minLabel,*m_maxLabel;
+    bool m_blockScrollEvent;
+
     virtual GdkWindow *GTKGetWindow(wxArrayGdkWindows& windows) const;
 
     // set the slider value unconditionally

src/gtk/slider.cpp

@@ -132,7 +132,7 @@ gtk_value_changed(GtkRange* range, wxSlider* win)
     if (!win->m_hasVMT || g_blockEventsOnDrag)
         return;
 
-    if (win->m_blockScrollEvent)
+    if (win->GTKEventsDisabled())
     {
         win->m_scrollEventType = GTK_SCROLL_NONE;
         return;
@@ -231,9 +231,9 @@ gtk_event_after(GtkRange* range, GdkEvent* event, wxSlider* win)
             ProcessScrollEvent(win, wxEVT_SCROLL_THUMBRELEASE);
         }
         // Keep slider at an integral position
-        win->m_blockScrollEvent = true;
+        win->GTKDisableEvents();
-        gtk_range_set_value(GTK_RANGE (win->m_widget), win->GetValue());
+        gtk_range_set_value(GTK_RANGE (win->m_scale), win->GetValue());
-        win->m_blockScrollEvent = false;
+        win->GTKEnableEvents();
     }
 }
 }
@@ -303,26 +303,78 @@ bool wxSlider::Create(wxWindow *parent,
         return false;
     }
     
-    if (style & wxSL_VERTICAL)
-        m_widget = gtk_vscale_new( NULL );
-    else
-        m_widget = gtk_hscale_new( NULL );
-    g_object_ref(m_widget);
 
-    gtk_scale_set_draw_value(GTK_SCALE (m_widget), (style & wxSL_LABELS) != 0);
+    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;
+    }
+    
+    gtk_scale_set_draw_value(GTK_SCALE (m_scale), (style & wxSL_VALUE_LABEL) != 0);
+    
+    if ((style & wxSL_MIN_MAX_LABELS) && (style & wxSL_VERTICAL))
+        gtk_scale_set_value_pos( GTK_SCALE(m_scale), GTK_POS_LEFT );
+    
     // Keep full precision in position value
-    gtk_scale_set_digits(GTK_SCALE (m_widget), -1);
+    gtk_scale_set_digits(GTK_SCALE (m_scale), -1);
 
     if (style & wxSL_INVERSE)
-        gtk_range_set_inverted( GTK_RANGE(m_widget), TRUE );
+        gtk_range_set_inverted( GTK_RANGE(m_scale), TRUE );
 
-    g_signal_connect(m_widget, "button_press_event", G_CALLBACK(gtk_button_press_event), this);
+    g_signal_connect(m_scale, "button_press_event", G_CALLBACK(gtk_button_press_event), this);
-    g_signal_connect(m_widget, "button_release_event", G_CALLBACK(gtk_button_release_event), this);
+    g_signal_connect(m_scale, "button_release_event", G_CALLBACK(gtk_button_release_event), this);
-    g_signal_connect(m_widget, "move_slider", G_CALLBACK(gtk_move_slider), this);
+    g_signal_connect(m_scale, "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_scale, "format_value", G_CALLBACK(gtk_format_value), NULL);
-    g_signal_connect(m_widget, "value_changed", G_CALLBACK(gtk_value_changed), this);
+    g_signal_connect(m_scale, "value_changed", G_CALLBACK(gtk_value_changed), this);
-    gulong handler_id = g_signal_connect(m_widget, "event_after", G_CALLBACK(gtk_event_after), this);
+    gulong handler_id = g_signal_connect(m_scale, "event_after", G_CALLBACK(gtk_event_after), this);
-    g_signal_handler_block(m_widget, handler_id);
+    g_signal_handler_block(m_scale, handler_id);
 
     SetRange( minValue, maxValue );
 
@@ -337,6 +389,21 @@ bool wxSlider::Create(wxWindow *parent,
     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);
@@ -350,41 +417,59 @@ void wxSlider::SetValue( int value )
 
 void wxSlider::GTKSetValue(int value)
 {
-    m_blockScrollEvent = true;
+    GTKDisableEvents();
-    gtk_range_set_value(GTK_RANGE (m_widget), value);
+    gtk_range_set_value(GTK_RANGE (m_scale), value);
-    m_blockScrollEvent = false;
+    GTKEnableEvents();
 }
 
 void wxSlider::SetRange( int minValue, int maxValue )
 {
-    m_blockScrollEvent = true;
+    GTKDisableEvents();
     if (minValue == maxValue)
        maxValue++;
-    gtk_range_set_range(GTK_RANGE (m_widget), minValue, maxValue);
+    gtk_range_set_range(GTK_RANGE (m_scale), minValue, maxValue);
-    gtk_range_set_increments(GTK_RANGE (m_widget), 1, (maxValue - minValue + 9) / 10);
+    gtk_range_set_increments(GTK_RANGE (m_scale), 1, (maxValue - minValue + 9) / 10);
-    m_blockScrollEvent = false;
+    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_widget))->lower);
+    return int(gtk_range_get_adjustment (GTK_RANGE (m_scale))->lower);
 }
 
 int wxSlider::GetMax() const
 {
-    return int(gtk_range_get_adjustment (GTK_RANGE (m_widget))->upper);
+    return int(gtk_range_get_adjustment (GTK_RANGE (m_scale))->upper);
 }
 
 void wxSlider::SetPageSize( int pageSize )
 {
-    m_blockScrollEvent = true;
+    GTKDisableEvents();
-    gtk_range_set_increments(GTK_RANGE (m_widget), GetLineSize(), pageSize);
+    gtk_range_set_increments(GTK_RANGE (m_scale), GetLineSize(), pageSize);
-    m_blockScrollEvent = false;
+    GTKEnableEvents();
 }
 
 int wxSlider::GetPageSize() const
 {
-    return int(gtk_range_get_adjustment (GTK_RANGE (m_widget))->page_increment);
+    return int(gtk_range_get_adjustment (GTK_RANGE (m_scale))->page_increment);
 }
 
 // GTK does not support changing the size of the slider
@@ -399,19 +484,19 @@ int wxSlider::GetThumbLength() const
 
 void wxSlider::SetLineSize( int lineSize )
 {
-    m_blockScrollEvent = true;
+    GTKDisableEvents();
-    gtk_range_set_increments(GTK_RANGE (m_widget), lineSize, GetPageSize());
+    gtk_range_set_increments(GTK_RANGE (m_scale), lineSize, GetPageSize());
-    m_blockScrollEvent = false;
+    GTKEnableEvents();
 }
 
 int wxSlider::GetLineSize() const
 {
-    return int(gtk_range_get_adjustment (GTK_RANGE (m_widget))->step_increment);
+    return int(gtk_range_get_adjustment (GTK_RANGE (m_scale))->step_increment);
 }
 
 GdkWindow *wxSlider::GTKGetWindow(wxArrayGdkWindows& WXUNUSED(windows)) const
 {
-    return GTK_RANGE(m_widget)->event_window;
+    return GTK_RANGE(m_scale)->event_window;
 }
 
 // static