← Back to branch summary

~ubuntu-branches/ubuntu/precise/indicator-sound/precise-201111281906

« back to all changes in this revision

Viewing changes to src/volume-widget.c

Tags: upstream-0.6.5
Import upstream version 0.6.5

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/volume-widget.c
128
128
volume_widget_property_update( DbusmenuMenuitem* item, gchar* property, 
129
129
                               GVariant* value, gpointer userdata)
130
130
{ 
131
 
  g_return_if_fail (IS_VOLUME_WIDGET (userdata)); 
 
131
  g_return_if_fail (IS_VOLUME_WIDGET(userdata)); 
132
132
  VolumeWidget* mitem = VOLUME_WIDGET(userdata);
133
133
  VolumeWidgetPrivate * priv = VOLUME_WIDGET_GET_PRIVATE(mitem);
134
134
 
139
139
      GtkRange *range = (GtkRange*)slider;
140
140
      gdouble update = g_variant_get_double (value);
141
141
      gtk_range_set_value(range, update);
 
142
/*
 
143
      g_debug ("volume-widget::volume_widget_property_update - volume - value %f", update);
 
144
*/
142
145
      update_accessible_desc(priv->indicator);
143
146
    }
144
147
  }
145
 
  if(g_ascii_strcasecmp(DBUSMENU_VOLUME_MENUITEM_MUTE, property) == 0){
146
 
    g_debug ("volume widget - mute update ");
 
148
  else if(g_ascii_strcasecmp(DBUSMENU_VOLUME_MENUITEM_MUTE, property) == 0){
 
149
    g_return_if_fail (g_variant_is_of_type (value, G_VARIANT_TYPE_BOOLEAN));
147
150
    if(priv->grabbed == FALSE){
148
151
      GtkWidget *slider = ido_scale_menu_item_get_scale((IdoScaleMenuItem*)priv->ido_volume_slider);
149
152
      GtkRange *range = (GtkRange*)slider;
150
 
      gint update = g_variant_get_int32 (value);
 
153
      gboolean update = g_variant_get_boolean (value);
151
154
      gdouble level;
152
155
 
153
 
      g_debug ("volume widget - mute update %i", update);
154
 
 
155
 
      if (update == 1){
 
156
      if (update == TRUE){
156
157
        level = 0;
157
158
      }
158
159
      else{
159
 
        level = g_variant_get_double (dbusmenu_menuitem_property_get_variant (priv->twin_item,
160
 
                                                                              DBUSMENU_VOLUME_MENUITEM_LEVEL));
 
160
        GVariant* variant = dbusmenu_menuitem_property_get_variant (priv->twin_item,
 
161
                                                                    DBUSMENU_VOLUME_MENUITEM_LEVEL);
 
162
/*
 
163
        g_debug ("variant for the volume - is it null = %i", variant == NULL);
 
164
*/
 
165
        g_return_if_fail (g_variant_is_of_type (variant, G_VARIANT_TYPE_DOUBLE) );
 
166
 
 
167
        level = g_variant_get_double (variant);
161
168
      }
 
169
/*
 
170
      g_debug ("volume-widget::volume_widget_property_update - mute - value %i and level = %f", update, level);
 
171
*/
162
172
      gtk_range_set_value(range, level);
163
 
      g_debug ("volume-widget - update mute with value %i", update);
164
173
    }
165
174
  }
166
175
}
176
185
                   G_CALLBACK(volume_widget_property_update), self);
177
186
  gdouble initial_level = g_variant_get_double (dbusmenu_menuitem_property_get_variant(twin_item,
178
187
                                                DBUSMENU_VOLUME_MENUITEM_LEVEL));
179
 
  gint initial_mute = g_variant_get_int32 (dbusmenu_menuitem_property_get_variant(twin_item,
180
 
                                           DBUSMENU_VOLUME_MENUITEM_MUTE));
 
188
  gboolean initial_mute = g_variant_get_boolean (dbusmenu_menuitem_property_get_variant(twin_item,
 
189
                                                 DBUSMENU_VOLUME_MENUITEM_MUTE));
181
190
 
182
191
  //g_debug("volume_widget_set_twin_item initial level = %f", initial_level);
183
192
  GtkWidget *slider = ido_scale_menu_item_get_scale((IdoScaleMenuItem*)priv->ido_volume_slider);
184
193
  GtkRange *range = (GtkRange*)slider;
185
 
  if(initial_mute == 1){
 
194
  if(initial_mute == TRUE){
186
195
    initial_level = 0;
187
196
  }
188
197
  gtk_range_set_value(range, initial_level);
197
206
{
198
207
  g_return_val_if_fail (IS_VOLUME_WIDGET (user_data), FALSE);
199
208
  VolumeWidget* mitem = VOLUME_WIDGET(user_data);
200
 
  //g_debug ("changed value %f", new_value);
201
 
  volume_widget_update(mitem, new_value);
 
209
 
 
210
/*
 
211
  g_debug ("changed value %f", new_value);
 
212
*/
 
213
 
 
214
  volume_widget_update(mitem, new_value, "change-value");
202
215
  return FALSE;
203
216
}
204
217
 
211
224
{
212
225
 
213
226
  g_return_val_if_fail (IS_VOLUME_WIDGET (user_data), FALSE);
214
 
  VolumeWidget* mitem = VOLUME_WIDGET(user_data);
 
227
  VolumeWidget* mitem = VOLUME_WIDGET (user_data);
215
228
  VolumeWidgetPrivate * priv = VOLUME_WIDGET_GET_PRIVATE(mitem);
216
229
  GtkWidget *slider = ido_scale_menu_item_get_scale((IdoScaleMenuItem*)priv->ido_volume_slider);
217
230
  gdouble current_value =  CLAMP(gtk_range_get_value(GTK_RANGE(slider)), 0, 100);
218
 
  //g_debug ("value changed %f", gtk_range_get_value(GTK_RANGE(slider)));
219
 
  gint mute = g_variant_get_int32 (dbusmenu_menuitem_property_get_variant (priv->twin_item,
220
 
                                                                           DBUSMENU_VOLUME_MENUITEM_MUTE));
221
231
 
222
 
  if((current_value == 0 && mute != 1) || current_value == 100){
223
 
    volume_widget_update(mitem, current_value);
 
232
  gboolean mute = g_variant_get_boolean (dbusmenu_menuitem_property_get_variant (priv->twin_item,
 
233
                                                                                 DBUSMENU_VOLUME_MENUITEM_MUTE));
 
234
  if((current_value == 0 && mute == FALSE) || current_value == 100){
 
235
/*
 
236
    g_debug ("value changed - actual set %f", current_value);
 
237
*/
 
238
    volume_widget_update (mitem, current_value, "value-changed");
224
239
  }
225
240
 
226
241
  return FALSE;
227
242
}
228
243
 
229
244
void 
230
 
volume_widget_update(VolumeWidget* self, gdouble update)
 
245
volume_widget_update(VolumeWidget* self, gdouble update, gchar* label)
231
246
{
 
247
  gchar* source = NULL;
 
248
  source = label;
 
249
  if (label == NULL){
 
250
    source = "v widget update";
 
251
  }
232
252
  VolumeWidgetPrivate * priv = VOLUME_WIDGET_GET_PRIVATE(self);
233
253
  gdouble clamped = CLAMP(update, 0, 100);
234
254
  GVariant* new_volume = g_variant_new_double(clamped);
235
 
  dbusmenu_menuitem_handle_event (priv->twin_item, "update", new_volume, 0);
 
255
  dbusmenu_menuitem_handle_event (priv->twin_item, source, new_volume, 0);
236
256
}
237
257
 
238
258
GtkWidget*