Salut les GTK,

bon comme le dit le titre j'ai passer la moitié de la nuit et une bonne partie de la matinée, a essayer de trouver le moyens de détecter quand l'utilisateur de l'interface GTK+3.0 (gtkmm 3.0) active un widget Gtk::Scale pour la première (c.a.d au premier changement de valeur) et la dernière fois (c.a.d au dernier changement de valeurs).

Ce qui correspond a quand l'utilisateur empoigne le slider avec la souris et le relache.

J'ai entre-autres essayer le button-press-event et le button-release-event du Widget Gtk::Widget parent de Gtk::Scale.

Le problème est que dans ce cas là:

1. Il faut que le widget soit un widget avec X event signals (file:///usr/share/doc/gtkmm-documentation/tutorial/html/sec-xeventsignals.html).

Ce qui n'est pas sûr car son parent Gtk::Range est dans la liste des Widgets Without X-Windows (file:///usr/share/doc/gtkmm-documentation/tutorial/html/chapter-widgets-without-xwindows.html)

2. Et puis j'ai suivit les explications a la lettre du tutoriel: file:///usr/share/doc/gtkmm-documentation/tutorial/html/index.html

A cette page: file:///usr/share/doc/gtkmm-documentation/tutorial/html/chapter-widgets-without-xwindows.html

Concernant l'ajout du widget en question dans un widget Gtk::EventBox connectant les signaux en *_event au widget Gtk::EventBox contenant le widget Gtk::Scale.

Sans succès...

A noter que vous pouvez avoir la même doc en téléchargeant le paquet: libgtkmm-3.0-doc.

Je vous propose un petit code comme support.

Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
 
/** Standart libraries: **/
#include <iostream>
 
 
/** gtkmm widgets (only the needed widgets). **/
#include <gtkmm/main.h>
 
#include <gtkmm/window.h>
 
#include <gtkmm/box.h>
#include <gtkmm/frame.h>
 
#include <gtkmm/scale.h>
 
#include <gtkmm/adjustment.h>
 
#include <gtkmm/eventbox.h>
 
/** Other libraries **/
#include <glibmm.h>
 
/** To comil with:
  *
  * $ g++ -std=c++11 main.cpp $(pkg-config --cflags --libs gtkmm-3.0)
  *
  ********************************************************************/
 
class My_Window : public Gtk::Window {
 
  Gtk::Box       main_box       ;
 
  Gtk::Frame     frame_scale    ;
 
  Gtk::EventBox  event_box      ;
 
  Gtk::Scale     scale          ;
 
  public :  // Constructor:
 
    My_Window() ;
 
  public : // Getters:
 
    Gtk::Scale& get_scale() { return scale ; } ;
 
    Gtk::EventBox& get_eventbox() { return event_box ; }
 
  public : // Signals handlers:
 
    bool get_scroll_type(Gtk::ScrollType scroll_type, double value) ;
 
    void get_scale_value(Gtk::Scale &scale) ;
 
    void scale_adjusment_value_change() ;
 
    void scale_adjusment_change() ;
 
    void my_signal_move_slider(Gtk::ScrollType scroll_type) ;
 
    bool on_button_press(GdkEventButton *event) ;
 
    bool on_button_release(GdkEventButton *event) ;
 
    bool on_scroll_event(GdkEventScroll *event) ;
 
  public : // Variables.  
 
    /** The goal is to set this this variable on @true at
        scale activation start and reset on on @false at end.
    */     
    bool start = false ;
 
    /** The goal is to set this this variable on @true at
        scale activation end and reset on @false at start.
    */   
    bool end   = false ;
 
 
} ;
 
My_Window::My_Window() :
 
  main_box(Gtk::ORIENTATION_VERTICAL),
 
  frame_scale("frame"),
 
  event_box(),
 
  scale(Gtk::ORIENTATION_VERTICAL)
 
  {
 
    set_title("My Window")      ;
    set_resizable(false)     ;
    set_border_width(8)      ;
 
 
    scale.set_events(Gdk::BUTTON_PRESS_MASK) ;
    scale.set_events(Gdk::BUTTON_RELEASE_MASK) ;
 
    scale.set_events(Gdk::BUTTON_PRESS_MASK) ;
    scale.set_events(Gdk::BUTTON_RELEASE_MASK) ;
 
    scale.set_events(Gdk::SCROLL_MASK) ;
 
    //scale.set_events(Gdk::BUTTON1_MOTION_MASK) ;
 
 
    event_box.set_events(Gdk::ALL_EVENTS_MASK) ;
 
 
    // Scale widget configuration.
    scale.set_size_request(-1, 256) ;        
    scale.set_digits(0) ;
    scale.set_draw_value(true) ;
    scale.set_has_origin(true) ;
    scale.set_upper_stepper_sensitivity(Gtk::SENSITIVITY_ON) ;
    scale.set_lower_stepper_sensitivity(Gtk::SENSITIVITY_ON) ;
    scale.set_adjustment( scale.get_adjustment() )     ;
    scale.set_range(-255.0, 255.0)     ;
    scale.set_value(0.0)     ;
    scale.set_increments(1.0, 10.0)          ;
    scale.add_mark(0.0, Gtk::POS_RIGHT, "")     ;
    scale.set_margin_left(12)        ;
    scale.set_margin_right(12)       ;
    scale.set_margin_top(8)        ;
    scale.set_margin_bottom(8)     ;
    scale.set_inverted(true)     ;
 
    event_box.add(scale) ;
 
    frame_scale.add(event_box) ;
    //frame_scale.add(scale) ;
 
    main_box.pack_start(frame_scale, true, true, 0) ;
 
    add(main_box) ;
 
    show_all() ;
}   
 
bool My_Window::on_scroll_event(GdkEventScroll *event) {
 
 
  fprintf(stdout,"signal_scroll_event()\n") ;
 
  return true ; // return false to propagate events.
 
}
 
bool My_Window::on_button_press(GdkEventButton *event) {
 
 
  fprintf(stdout,"BUTTON PRESS\n") ;
 
  return true ; // return false to propagate events.
 
}
 
bool My_Window::on_button_release(GdkEventButton *event) {
 
  fprintf(stdout,"BUTTON RELEASE\n") ;   
 
  return true ; // return false to propagate events.
 
}   
 
bool My_Window::get_scroll_type(Gtk::ScrollType scroll_type, double value) {
 
  // By activating it start and ends with this signal handler.
  // But this handler is call every changing unfortunaly...
  // And does only provide a single @ScrollType art.
 
  if (scroll_type == Gtk::ScrollType::SCROLL_START) {
    // Can never catch this Shitty !!!
    fprintf(stdout, "Start scroll !!!\n") ;
  }
  else if (scroll_type == Gtk::ScrollType::SCROLL_END) {
    // Can never catch this Shitty !!!
    fprintf(stdout, "End scroll !!!\n") ;
  }
  else {
    //fprintf(stdout,"ScrollType...................: %d\n", scroll_type) ;
    //fprintf(stdout,"default type is SCROLL_JUMP..: %d\n", Gtk::ScrollType::SCROLL_JUMP) ;
  }
 
  return false ; // return false to propagate events.
 
}    
 
void My_Window::get_scale_value(Gtk::Scale &scale) {
 
  fprintf(stdout,"current scale value..........: %li\n",static_cast<int64_t>(scale.get_value()) ) ;
}
 
void My_Window::scale_adjusment_value_change() {
 
  //fprintf(stdout,"Scale Adjusment: ***signal_value_changed()***\n") ;
 
}
 
void My_Window::scale_adjusment_change() {
 
  /** THis handler is never called. **/
 
  //fprintf(stdout,"Scale Adjusment: ***signal_changed()***\n") ;
 
}   
 
void My_Window::my_signal_move_slider(Gtk::ScrollType scroll_type) {
 
  /** This handler is called by arrow key pressing. **/
 
  if (scroll_type == Gtk::ScrollType::SCROLL_START) {
    // Can never catch this Shitty !!!
    fprintf(stdout, "Start scroll !!!\n") ;
  }
  else if (scroll_type == Gtk::ScrollType::SCROLL_END) {
    // Can never catch this Shitty !!!
    fprintf(stdout, "End scroll !!!\n") ;
  }
  else {
    fprintf(stdout,"ScrollType...................: %d\n", scroll_type) ;
    //fprintf(stdout,"default type is SCROLL_JUMP..: %d\n", Gtk::ScrollType::SCROLL_JUMP) ;
  }
 
}   
 
int main(int argc, char *argv[]) {
 
  Gtk::Main app(argc, argv);
 
  My_Window my_window ;
 
  // Scale widget signals connecting:
  my_window.get_scale().signal_value_changed().connect(sigc::bind<Gtk::Scale &>(sigc::mem_fun(my_window, &My_Window::get_scale_value), my_window.get_scale()) ) ;
  my_window.get_scale().signal_change_value().connect(sigc::mem_fun(my_window, &My_Window::get_scroll_type) ) ;
  my_window.get_scale().signal_move_slider().connect(sigc::mem_fun(my_window, &My_Window::my_signal_move_slider) ) ;
  // _event signals handling:
  my_window.get_scale().signal_button_press_event().connect(sigc::mem_fun(my_window, &My_Window::on_button_press) ) ;
  my_window.get_scale().signal_button_release_event().connect(sigc::mem_fun(my_window, &My_Window::on_button_release) ) ;
  my_window.get_scale().signal_scroll_event().connect(sigc::mem_fun(my_window, &My_Window::on_scroll_event) ) ;
 
  // EventBox wrapping technic.
  my_window.get_eventbox().signal_button_press_event().connect(sigc::mem_fun(my_window, &My_Window::on_button_press) ) ;
  my_window.get_eventbox().signal_button_release_event().connect(sigc::mem_fun(my_window, &My_Window::on_button_release) ) ;
  my_window.get_eventbox().signal_scroll_event().connect(sigc::mem_fun(my_window, &My_Window::on_scroll_event) ) ;
 
 
 
  // Scale adjustment signals connecting:
  my_window.get_scale().get_adjustment()->signal_value_changed().connect(sigc::mem_fun(my_window, &My_Window::scale_adjusment_value_change) ) ;
  my_window.get_scale().get_adjustment()->signal_changed().connect(sigc::mem_fun(my_window, &My_Window::scale_adjusment_change) ) ;
 
  Gtk::Main::run(my_window) ;
 
  return 0 ;
 
}
Sur ceux je n'attends plus rien de la vie... ADIEUX MONDE CRUEL !!!

Couick... rng, rng, rng le numéro que vous avez demander n'est plus en service actuellement.