← Back to branch summary

~bratsche/indicator-sound/icon-placement

« back to all changes in this revision

Viewing changes to src/scrub-widget.c

  • Committer: Conor Curran
  • Date: 2010-07-22 18:21:22 UTC
  • mfrom: (104.1.3 indicator-sound)
  • Revision ID: conor.curran@canonical.com-20100722182122-sw2f1gydszx846r5
ido scrub bar in but there are some bugs

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/scrub-widget.c
25
25
#include "scrub-widget.h"
26
26
#include "common-defs.h"
27
27
#include <libido/idoscalemenuitem.h>
 
28
#include <libido/idotimeline.h>
28
29
 
29
30
typedef struct _ScrubWidgetPrivate ScrubWidgetPrivate;
30
31
 
32
33
{
33
34
        DbusmenuMenuitem* twin_item;    
34
35
        GtkWidget* ido_scrub_bar;
 
36
        IdoTimeline* time_line;
 
37
        gboolean scrubbing;
35
38
};
36
39
 
37
40
#define SCRUB_WIDGET_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), SCRUB_WIDGET_TYPE, ScrubWidgetPrivate))
54
57
                                                                                        gdouble       value,
55
58
                                                                                        gpointer      user_data);
56
59
 
 
60
static void scrub_widget_timeline_frame_cb(IdoTimeline *timeline,
 
61
                                                                                                                                                        gdouble      progress,
 
62
                                                                gpointer                userdata);
 
63
static void scrub_widget_timeline_started_cb(IdoTimeline *timeline,
 
64
                                                                gpointer                userdata);
 
65
static void scrub_widget_timeline_finished_cb(IdoTimeline *timeline,
 
66
                                                                gpointer                userdata);
 
67
static gdouble scrub_widget_calculate_progress(ScrubWidget* widget);
 
68
static void scrub_widget_check_play_state(ScrubWidget* self);
 
69
static void scrub_widget_slider_grabbed(GtkWidget *widget, gpointer user_data);
 
70
static void scrub_widget_slider_released(GtkWidget *widget, gpointer user_data);
 
71
 
 
72
 
57
73
 
58
74
G_DEFINE_TYPE (ScrubWidget, scrub_widget, G_TYPE_OBJECT);
59
75
 
68
84
        gobject_class->finalize = scrub_widget_finalize;
69
85
}
70
86
 
71
 
 
72
87
static void
73
88
scrub_widget_init (ScrubWidget *self)
74
89
{
76
91
        ScrubWidgetPrivate * priv = SCRUB_WIDGET_GET_PRIVATE(self);
77
92
 
78
93
  priv->ido_scrub_bar = ido_scale_menu_item_new_with_range ("Scrub", IDO_RANGE_STYLE_SMALL,  0, 0, 100, 1);
 
94
        priv->time_line = ido_timeline_new(0);
 
95
        
79
96
        ido_scale_menu_item_set_style (IDO_SCALE_MENU_ITEM(priv->ido_scrub_bar), IDO_SCALE_MENU_ITEM_STYLE_LABEL);      
80
 
        
81
97
        g_object_set(priv->ido_scrub_bar, "reverse-scroll-events", TRUE, NULL);
 
98
        priv->scrubbing = FALSE;
82
99
        
83
100
  // register slider changes listening on the range
84
101
  GtkWidget* scrub_widget = ido_scale_menu_item_get_scale((IdoScaleMenuItem*)priv->ido_scrub_bar);      
85
102
  g_signal_connect(scrub_widget, "change-value", G_CALLBACK(scrub_widget_change_value_cb), self);       
 
103
        g_signal_connect(priv->time_line, "frame", G_CALLBACK(scrub_widget_timeline_frame_cb), self);   
 
104
        g_signal_connect(priv->time_line, "started", G_CALLBACK(scrub_widget_timeline_started_cb), self);               
 
105
        g_signal_connect(priv->time_line, "finished", G_CALLBACK(scrub_widget_timeline_finished_cb), self);             
 
106
  g_signal_connect(priv->ido_scrub_bar, "slider-grabbed", G_CALLBACK(scrub_widget_slider_grabbed), self);
 
107
  g_signal_connect(priv->ido_scrub_bar, "slider-released", G_CALLBACK(scrub_widget_slider_released), self);
86
108
}
87
109
 
88
110
static void
110
132
        if(g_ascii_strcasecmp(DBUSMENU_SCRUB_MENUITEM_DURATION, property) == 0){
111
133
                g_debug("scrub-widget::update length = %i", g_value_get_int(value)); 
112
134
                ido_scale_menu_item_set_secondary_label(IDO_SCALE_MENU_ITEM(priv->ido_scrub_bar),
113
 
                                                      scrub_widget_format_time(g_value_get_int(value)));                        
 
135
                                                        scrub_widget_format_time(g_value_get_int(value)));                      
 
136
                                
 
137
                ido_timeline_set_duration(priv->time_line, g_value_get_int(value) * 1000);      
 
138
                ido_timeline_rewind(priv->time_line);
 
139
                scrub_widget_check_play_state(mitem);
 
140
                g_debug("timeline is running: %i", (gint)ido_timeline_is_running(priv->time_line));
 
141
                g_debug("timeline duration = %i", ido_timeline_get_duration(priv->time_line));
 
142
 
 
143
                scrub_widget_set_ido_position(mitem, 
 
144
                                      dbusmenu_menuitem_property_get_int(priv->twin_item, DBUSMENU_SCRUB_MENUITEM_POSITION)/1000,
 
145
                                                                                                                                dbusmenu_menuitem_property_get_int(priv->twin_item, DBUSMENU_SCRUB_MENUITEM_DURATION));                                                 
114
146
        }
115
147
        else if(g_ascii_strcasecmp(DBUSMENU_SCRUB_MENUITEM_POSITION, property) == 0){
116
148
                g_debug("scrub-widget::update position = %i", g_value_get_int(value)); 
 
149
                ido_timeline_pause(priv->time_line);
117
150
                ido_scale_menu_item_set_primary_label(IDO_SCALE_MENU_ITEM(priv->ido_scrub_bar),
118
151
                                                      scrub_widget_format_time(g_value_get_int(value)/1000));                                   
119
 
        }       
120
 
        scrub_widget_set_ido_position(mitem, 
121
 
                                        dbusmenu_menuitem_property_get_int(priv->twin_item, DBUSMENU_SCRUB_MENUITEM_POSITION)/1000,
122
 
                                                                                                                                        dbusmenu_menuitem_property_get_int(priv->twin_item, DBUSMENU_SCRUB_MENUITEM_DURATION));                                 
 
152
                                                                                                                                                                        
 
153
                ido_timeline_set_progress(priv->time_line, scrub_widget_calculate_progress(mitem)*1000);
 
154
                scrub_widget_set_ido_position(mitem, g_value_get_int(value)/1000,
 
155
                                                                                                                                dbusmenu_menuitem_property_get_int(priv->twin_item, DBUSMENU_SCRUB_MENUITEM_DURATION));
 
156
                ido_timeline_start(priv->time_line);            
 
157
 
 
158
        }
 
159
        else if(g_ascii_strcasecmp(DBUSMENU_SCRUB_MENUITEM_PLAY_STATE, property) == 0){
 
160
                scrub_widget_check_play_state(mitem);
 
161
        }
 
162
}
 
163
 
 
164
static void 
 
165
scrub_widget_check_play_state(ScrubWidget* self)
 
166
{
 
167
        ScrubWidgetPrivate * priv = SCRUB_WIDGET_GET_PRIVATE(self);
 
168
        gint play_state = dbusmenu_menuitem_property_get_int(priv->twin_item,
 
169
                                                             DBUSMENU_SCRUB_MENUITEM_PLAY_STATE);
123
170
        
 
171
        if(play_state == 0){
 
172
                g_debug("START TIMELINE");
 
173
                ido_timeline_start(priv->time_line);
 
174
        }
 
175
        else{
 
176
                g_debug("PAUSE TIMELINE");                      
 
177
                ido_timeline_pause(priv->time_line);
 
178
        }               
124
179
}
125
180
 
126
181
static void
133
188
        g_signal_connect(G_OBJECT(twin_item), "property-changed", 
134
189
                         G_CALLBACK(scrub_widget_property_update), self);
135
190
 
136
 
        gchar* left_text = scrub_widget_format_time(dbusmenu_menuitem_property_get_int(priv->twin_item,
137
 
                                                                                       DBUSMENU_SCRUB_MENUITEM_POSITION)/1000);         
 
191
        gchar* left_text = scrub_widget_format_time(dbusmenu_menuitem_property_get_int(priv->twin_item,                                                                                DBUSMENU_SCRUB_MENUITEM_POSITION)/1000);         
138
192
        gchar* right_text = scrub_widget_format_time(dbusmenu_menuitem_property_get_int(priv->twin_item, 
139
193
                                                                                        DBUSMENU_SCRUB_MENUITEM_DURATION));     
140
194
        scrub_widget_set_ido_position(self, 
141
 
                                        dbusmenu_menuitem_property_get_int(priv->twin_item, DBUSMENU_SCRUB_MENUITEM_POSITION)/1000,
142
 
                                                                                                                                        dbusmenu_menuitem_property_get_int(priv->twin_item, DBUSMENU_SCRUB_MENUITEM_DURATION));                                 
 
195
                                      dbusmenu_menuitem_property_get_int(priv->twin_item, DBUSMENU_SCRUB_MENUITEM_POSITION)/1000,
 
196
                                                                                                                                dbusmenu_menuitem_property_get_int(priv->twin_item, DBUSMENU_SCRUB_MENUITEM_DURATION));                                 
143
197
                                        
144
198
        ido_scale_menu_item_set_primary_label(IDO_SCALE_MENU_ITEM(priv->ido_scrub_bar), left_text);     
145
199
        ido_scale_menu_item_set_secondary_label(IDO_SCALE_MENU_ITEM(priv->ido_scrub_bar), right_text);
153
207
                                                                        gdouble       new_value,
154
208
                                                                        gpointer      user_data)
155
209
{
156
 
        g_return_val_if_fail (IS_SCRUB_WIDGET (user_data), FALSE);
 
210
        /*g_return_val_if_fail (IS_SCRUB_WIDGET (user_data), FALSE);
157
211
        ScrubWidget* mitem = SCRUB_WIDGET(user_data);
158
212
        ScrubWidgetPrivate * priv = SCRUB_WIDGET_GET_PRIVATE(mitem);
159
213
 
161
215
  g_value_init(&value, G_TYPE_DOUBLE);
162
216
        gdouble clamped = CLAMP(new_value, 0, 100);
163
217
  g_value_set_double(&value, clamped);
164
 
  g_debug("scrub-widget-change-value callback - = %f", clamped);
165
 
  dbusmenu_menuitem_handle_event (priv->twin_item, "scrubbing", &value, 0);
 
218
  //g_debug("scrub-widget-change-value callback - = %f", clamped);
 
219
        if(priv->scrubbing == FALSE){
 
220
        dbusmenu_menuitem_handle_event (priv->twin_item, "scrubbing", &value, 0);
 
221
        }
 
222
        else{
 
223
                g_debug("blocking scrubbing because the slider is still grabbed"
 
224
        }*/
166
225
        return FALSE;
167
226
}
168
227
 
203
262
        gtk_range_set_value(range, ido_position);
204
263
}
205
264
 
 
265
static gdouble 
 
266
scrub_widget_calculate_progress(ScrubWidget* widget)
 
267
{
 
268
        ScrubWidgetPrivate * priv = SCRUB_WIDGET_GET_PRIVATE(widget);
 
269
        gint position = dbusmenu_menuitem_property_get_int(priv->twin_item,
 
270
                                                           DBUSMENU_SCRUB_MENUITEM_POSITION)/1000;
 
271
        gint duration = dbusmenu_menuitem_property_get_int(priv->twin_item,
 
272
                                                           DBUSMENU_SCRUB_MENUITEM_DURATION);
 
273
        gdouble ido_position = position/(gdouble)duration;
 
274
        g_debug("scrub_widget_calculate_progress %f", ido_position);
 
275
                
 
276
        return ido_position;
 
277
}
 
278
 
 
279
 
 
280
static void
 
281
scrub_widget_timeline_frame_cb( IdoTimeline *timeline,
 
282
                                                                                                        gdouble         progress,
 
283
                                                        gpointer                user_data)
 
284
{
 
285
        
 
286
        //g_debug("Timeline CB : %f", progress);
 
287
        g_return_if_fail (IS_SCRUB_WIDGET (user_data));
 
288
        ScrubWidget* mitem = SCRUB_WIDGET(user_data);
 
289
        ScrubWidgetPrivate * priv = SCRUB_WIDGET_GET_PRIVATE(mitem);
 
290
        if(priv->scrubbing == TRUE)
 
291
        {
 
292
                //g_debug("don't update the slider or timeline, slider is being scrubbed");
 
293
                return;
 
294
        }
 
295
        gint position = progress * dbusmenu_menuitem_property_get_int(priv->twin_item, 
 
296
                                                                                                                                                        DBUSMENU_SCRUB_MENUITEM_DURATION);      
 
297
        gchar* left_text = scrub_widget_format_time(position);  
 
298
        ido_scale_menu_item_set_primary_label(IDO_SCALE_MENU_ITEM(priv->ido_scrub_bar), left_text);     
 
299
  GtkWidget *slider = ido_scale_menu_item_get_scale((IdoScaleMenuItem*)priv->ido_scrub_bar);
 
300
  GtkRange *range = (GtkRange*)slider;
 
301
        gtk_range_set_value(range, progress * 100);
 
302
 
 
303
        /*g_debug("position in seconds %i and in words %s", position, left_text);
 
304
        g_debug("timeline is running: %i", (gint)ido_timeline_is_running(priv->time_line));
 
305
        g_debug("timeline duration = %i", ido_timeline_get_duration(priv->time_line));  
 
306
        */
 
307
        g_free(left_text);
 
308
}
 
309
 
 
310
 
 
311
static void
 
312
scrub_widget_slider_released(GtkWidget *widget, gpointer user_data)
 
313
{
 
314
        ScrubWidget* mitem = SCRUB_WIDGET(user_data);
 
315
        ScrubWidgetPrivate * priv = SCRUB_WIDGET_GET_PRIVATE(mitem);
 
316
        priv->scrubbing = FALSE;
 
317
        GtkWidget *slider = ido_scale_menu_item_get_scale((IdoScaleMenuItem*)priv->ido_scrub_bar);
 
318
  gdouble new_value = gtk_range_get_value(GTK_RANGE(slider));
 
319
        g_debug("okay set the scrub position with %f", new_value);      
 
320
        GValue value = {0};
 
321
  g_value_init(&value, G_TYPE_DOUBLE);
 
322
        gdouble clamped = CLAMP(new_value, 0, 100);
 
323
  g_value_set_double(&value, clamped);
 
324
  dbusmenu_menuitem_handle_event (priv->twin_item, "scrubbing", &value, 0);
 
325
}
 
326
 
 
327
static void
 
328
scrub_widget_slider_grabbed(GtkWidget *widget, gpointer user_data)
 
329
{
 
330
        ScrubWidget* mitem = SCRUB_WIDGET(user_data);
 
331
        ScrubWidgetPrivate * priv = SCRUB_WIDGET_GET_PRIVATE(mitem);
 
332
        priv->scrubbing = TRUE; 
 
333
        
 
334
}
 
335
 
 
336
static void
 
337
scrub_widget_timeline_started_cb(       IdoTimeline *timeline,
 
338
                                                                gpointer                user_data)
 
339
{
 
340
        g_debug("Timeline Started!");   
 
341
}
206
342
                           
207
 
 /**
 
343
static void
 
344
scrub_widget_timeline_finished_cb(IdoTimeline *timeline,
 
345
                                                                gpointer                user_data)
 
346
{
 
347
        g_debug("Timeline Finished!");  
 
348
        /*g_return_if_fail (IS_SCRUB_WIDGET (user_data));
 
349
        ScrubWidget* mitem = SCRUB_WIDGET(user_data);
 
350
        ScrubWidgetPrivate * priv = SCRUB_WIDGET_GET_PRIVATE(mitem);
 
351
        ido_timeline_rewind(priv->time_line);*/
 
352
}
 
353
 
 
354
/**
208
355
 * scrub_widget_new:
209
356
 * @returns: a new #ScrubWidget.
210
357
 **/
216
363
        return widget;
217
364
}
218
365
 
 
366