← Back to branch summary

~abreu-alexandre/libunity-webapps/bump-2.4.4-fix-distcheck

« back to all changes in this revision

Viewing changes to src/unity-webapps-indicator-context.c

  • Committer: Robert Carr
  • Date: 2012-02-04 06:17:39 UTC
  • mfrom: (503.1.2 build-system-fixes)
  • Revision ID: racarr@canonical.com-20120204061739-9ws9mbfc1n78f1kw
Merge lp:~robertcarr/libunity-webapps/build-system-fixes

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/unity-webapps-indicator-context.c
1
 
/*
2
 
 * unity-webapps-indicator-context.c
3
 
 * Copyright (C) Canonical LTD 2011
4
 
 *
5
 
 * Author: Robert Carr <racarr@canonical.com>
6
 
 * 
7
 
 unity-webapps is free software: you can redistribute it and/or modify it
8
 
 * under the terms of the GNU Lesser General Public License as published
9
 
 * by the Free Software Foundation, either version 3 of the License, or
10
 
 * (at your option) any later version.
11
 
 * 
12
 
 * unity-webapps is distributed in the hope that it will be useful, but
13
 
 * WITHOUT ANY WARRANTY; without even the implied warranty of
14
 
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
15
 
 * See the GNU Lesser General Public License for more details.
16
 
 * 
17
 
 * You should have received a copy of the GNU Lesser General Public License
18
 
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.";
19
 
 */
20
 
 
21
 
#include <stdio.h>
22
 
 
23
 
#include "unity-webapps-indicator-context.h"
24
 
#include "unity-webapps-context-private.h"
25
 
 
26
 
#include "unity-webapps-sanitizer.h"
27
 
 
28
 
#include "unity-webapps-debug.h"
29
 
 
30
 
static void
31
 
_indicator_context_action_invoked (UnityWebappsGenIndicator *indicator,
32
 
                                   const gchar *label,
33
 
                                   gpointer user_data)
34
 
{
35
 
  UnityWebappsIndicatorContext *indicator_context;
36
 
  UnityWebappsIndicatorCallback callback;
37
 
  
38
 
  indicator_context = (UnityWebappsIndicatorContext *)user_data;
39
 
  
40
 
  callback = g_hash_table_lookup (indicator_context->menu_callbacks_by_name, label);
41
 
  
42
 
  if (callback != NULL)
43
 
    {
44
 
      UNITY_WEBAPPS_NOTE (INDICATOR, "Menu action invoked: %s", label);
45
 
      callback();
46
 
      return;
47
 
    }
48
 
  
49
 
  callback = g_hash_table_lookup (indicator_context->indicator_callbacks_by_name, label);
50
 
  
51
 
  if (callback != NULL)
52
 
    {
53
 
      UNITY_WEBAPPS_NOTE (INDICATOR, "Indicator action invoked: %s", label);
54
 
      callback();
55
 
      return;
56
 
    }
57
 
 
58
 
}
59
 
 
60
 
 
61
 
static void
62
 
presence_changed_notify (GObject *object,
63
 
                         GParamSpec *pspec,
64
 
                         gpointer user_data)
65
 
{
66
 
  UnityWebappsIndicatorContext *indicator_context = (UnityWebappsIndicatorContext *)user_data;
67
 
  GList *walk;
68
 
  
69
 
  UNITY_WEBAPPS_NOTE (INDICATOR, "Presence changed notification");
70
 
  
71
 
  for (walk = indicator_context->presence_callbacks_list; walk != NULL; walk = g_list_next (walk))
72
 
    {
73
 
      UnityWebappsPresenceCallback callback;
74
 
      
75
 
      callback = (UnityWebappsPresenceCallback)(walk->data);
76
 
      
77
 
      if (callback)
78
 
        callback();
79
 
    }
80
 
}
81
 
 
82
 
UnityWebappsIndicatorContext *
83
 
unity_webapps_indicator_context_new (GDBusConnection *connection, const gchar *name, GError **error)
84
 
{
85
 
  UnityWebappsIndicatorContext *context;
86
 
  
87
 
  g_return_val_if_fail (connection != NULL, NULL);
88
 
  g_return_val_if_fail (name != NULL, NULL);
89
 
  g_return_val_if_fail (g_dbus_is_name (name), NULL);
90
 
  
91
 
  context = g_malloc0 (sizeof (UnityWebappsIndicatorContext));
92
 
  context->indicator_rate = 0;
93
 
  context->presence_callbacks_list = NULL;
94
 
  
95
 
  context->menu_callbacks_by_name = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, NULL);
96
 
  context->indicator_callbacks_by_name = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, NULL);
97
 
  
98
 
  context->indicator_proxy = 
99
 
    unity_webapps_gen_indicator_proxy_new_sync (connection ,
100
 
                                                G_DBUS_PROXY_FLAGS_NONE,
101
 
                                                name,
102
 
                                                UNITY_WEBAPPS_INDICATOR_PATH, 
103
 
                                                NULL /* Cancellable */,
104
 
                                                error);
105
 
  
106
 
  if (error && (*error != NULL))
107
 
    {
108
 
      g_critical ("Error creating indicator context proxy object for %s: %s", name, (*error)->message);
109
 
      
110
 
      return NULL;
111
 
    }
112
 
  
113
 
  g_signal_connect (context->indicator_proxy, "action-invoked", G_CALLBACK (_indicator_context_action_invoked), context);
114
 
  g_signal_connect (context->indicator_proxy, "notify::presence", G_CALLBACK (presence_changed_notify), context);
115
 
  
116
 
  return context;
117
 
}
118
 
 
119
 
void 
120
 
unity_webapps_indicator_context_free (UnityWebappsIndicatorContext *context)
121
 
{
122
 
  g_return_if_fail (context != NULL);
123
 
 
124
 
  g_hash_table_destroy (context->menu_callbacks_by_name);
125
 
  g_hash_table_destroy (context->indicator_callbacks_by_name);
126
 
  g_list_free (context->presence_callbacks_list);
127
 
 
128
 
 
129
 
  g_object_unref (G_OBJECT (context->indicator_proxy));
130
 
  
131
 
  g_free (context);
132
 
}
133
 
 
134
 
static void
135
 
show_indicator_complete_callback (GObject *source_object,
136
 
                                  GAsyncResult *res,
137
 
                                  gpointer user_data)
138
 
{
139
 
  UnityWebappsGenIndicator *proxy;
140
 
  GError *error;
141
 
  
142
 
  proxy = UNITY_WEBAPPS_GEN_INDICATOR (source_object);
143
 
  
144
 
  error = NULL;
145
 
  
146
 
  unity_webapps_gen_indicator_call_show_indicator_finish (proxy, res, &error);
147
 
  
148
 
  if (error != NULL)
149
 
    {
150
 
      g_warning ("Error calling ShowIndicator method of Indicator context: %s", error->message);
151
 
      
152
 
      g_error_free (error);
153
 
      
154
 
      return;
155
 
    }
156
 
  
157
 
  UNITY_WEBAPPS_NOTE (INDICATOR, "Received response, indicator successfully showed");
158
 
}
159
 
 
160
 
#define MAXIMUM_NAME_LENGTH 45
161
 
 
162
 
void
163
 
unity_webapps_indicator_show_indicator (UnityWebappsContext *context,
164
 
                                        const gchar *name)
165
 
{
166
 
  gchar *sanitized_name;
167
 
 
168
 
  g_return_if_fail (context != NULL);
169
 
  g_return_if_fail (UNITY_WEBAPPS_IS_CONTEXT (context));
170
 
  g_return_if_fail (name != NULL);
171
 
  
172
 
  if (unity_webapps_rate_check_indicator_rate_limit (context) == FALSE)
173
 
    {
174
 
      return;
175
 
    }
176
 
  
177
 
  sanitized_name = unity_webapps_sanitizer_limit_string_argument (name, MAXIMUM_NAME_LENGTH);
178
 
  unity_webapps_gen_indicator_call_show_indicator (context->priv->indicator_context->indicator_proxy,
179
 
                                                   sanitized_name,
180
 
                                                   NULL /* Cancellable */,
181
 
                                                   show_indicator_complete_callback,
182
 
                                                   context);
183
 
 
184
 
  g_free (sanitized_name);
185
 
 
186
 
  UNITY_WEBAPPS_NOTE (INDICATOR, "Showed indicator: %s", name);
187
 
}
188
 
 
189
 
static void
190
 
clear_indicator_complete_callback (GObject *source_object,
191
 
                                  GAsyncResult *res,
192
 
                                  gpointer user_data)
193
 
{
194
 
  UnityWebappsGenIndicator *proxy;
195
 
  GError *error;
196
 
  
197
 
  proxy = UNITY_WEBAPPS_GEN_INDICATOR (source_object);
198
 
  
199
 
  error = NULL;
200
 
  
201
 
  unity_webapps_gen_indicator_call_clear_indicator_finish (proxy, res, &error);
202
 
  
203
 
  if (error != NULL)
204
 
    {
205
 
      g_warning ("Error calling ShowIndicator method of Indicator context: %s", error->message);
206
 
      
207
 
      g_error_free (error);
208
 
      
209
 
      return;
210
 
    }
211
 
  
212
 
  UNITY_WEBAPPS_NOTE (INDICATOR, "Received response, indicator successfully cleared");
213
 
}
214
 
 
215
 
 
216
 
void
217
 
unity_webapps_indicator_clear_indicator (UnityWebappsContext *context,
218
 
                                         const gchar *name)
219
 
{
220
 
  gchar *sanitized_name;
221
 
 
222
 
  g_return_if_fail (context != NULL);
223
 
  g_return_if_fail (UNITY_WEBAPPS_IS_CONTEXT (context));
224
 
  g_return_if_fail (name != NULL);
225
 
  
226
 
  sanitized_name = unity_webapps_sanitizer_limit_string_argument (name, MAXIMUM_NAME_LENGTH);
227
 
 
228
 
  if (unity_webapps_rate_check_indicator_rate_limit (context) == FALSE)
229
 
    {
230
 
      return;
231
 
    }
232
 
  
233
 
  g_return_if_fail (name != NULL);
234
 
  
235
 
  unity_webapps_gen_indicator_call_clear_indicator (context->priv->indicator_context->indicator_proxy,
236
 
                                                    sanitized_name,
237
 
                                                    NULL /* Cancellable */,
238
 
                                                    clear_indicator_complete_callback,
239
 
                                                    context);
240
 
  
241
 
  g_free (sanitized_name);
242
 
  UNITY_WEBAPPS_NOTE (INDICATOR, "Cleared indicator: %s", name);
243
 
  
244
 
}
245
 
 
246
 
static void
247
 
add_action_complete_callback (GObject *source_object,
248
 
                              GAsyncResult *res,
249
 
                              gpointer user_data)
250
 
{
251
 
  UnityWebappsGenIndicator *proxy;
252
 
  GError *error;
253
 
  
254
 
  proxy = UNITY_WEBAPPS_GEN_INDICATOR (source_object);
255
 
  
256
 
  error = NULL;
257
 
  
258
 
  unity_webapps_gen_indicator_call_add_action_finish (proxy, res, &error);
259
 
  
260
 
  if (error != NULL)
261
 
    {
262
 
      g_warning ("Error calling AddAction method of Indicator context: %s", error->message);
263
 
      
264
 
      g_error_free (error);
265
 
      
266
 
      return;
267
 
    }
268
 
  
269
 
  UNITY_WEBAPPS_NOTE (INDICATOR, "Received response, action succesfully added");
270
 
}
271
 
 
272
 
#define MAXIMUM_LABEL_LENGTH 60
273
 
 
274
 
void
275
 
unity_webapps_indicator_add_action (UnityWebappsContext *context,
276
 
                                    const gchar *label,
277
 
                                    UnityWebappsIndicatorCallback callback)
278
 
{
279
 
  gchar *sanitized_label;
280
 
 
281
 
  g_return_if_fail (context != NULL);
282
 
  g_return_if_fail (UNITY_WEBAPPS_IS_CONTEXT (context));
283
 
  g_return_if_fail (label != NULL);
284
 
  g_return_if_fail (callback != NULL);
285
 
 
286
 
  if (unity_webapps_rate_check_indicator_rate_limit (context) == FALSE)
287
 
    {
288
 
      return;
289
 
    }
290
 
  
291
 
  sanitized_label = unity_webapps_sanitizer_limit_string_argument (label, MAXIMUM_LABEL_LENGTH);
292
 
 
293
 
  unity_webapps_gen_indicator_call_add_action (context->priv->indicator_context->indicator_proxy,
294
 
                                               sanitized_label,
295
 
                                               NULL /* Cancellable */,
296
 
                                               add_action_complete_callback,
297
 
                                               context);
298
 
  
299
 
  
300
 
  // TODO: Analyze the error case with duplicates.
301
 
  g_hash_table_insert (context->priv->indicator_context->menu_callbacks_by_name, g_strdup (label), callback);
302
 
  
303
 
  g_free (sanitized_label);
304
 
  
305
 
  UNITY_WEBAPPS_NOTE (INDICATOR, "Added action: %s", label);
306
 
}
307
 
 
308
 
static void
309
 
set_property_complete_callback (GObject *source_object,
310
 
                              GAsyncResult *res,
311
 
                              gpointer user_data)
312
 
{
313
 
  UnityWebappsGenIndicator *proxy;
314
 
  GError *error;
315
 
  
316
 
  proxy = UNITY_WEBAPPS_GEN_INDICATOR (source_object);
317
 
  
318
 
  error = NULL;
319
 
  
320
 
  unity_webapps_gen_indicator_call_set_property_finish (proxy, res, &error);
321
 
  
322
 
  if (error != NULL)
323
 
    {
324
 
      g_warning ("Error calling SetProperty of Indicator context: %s", error->message);
325
 
      
326
 
      g_error_free (error);
327
 
      
328
 
      return;
329
 
    }
330
 
  
331
 
  UNITY_WEBAPPS_NOTE (INDICATOR, "Received response, property succesfully set");
332
 
}
333
 
 
334
 
#define MAXIMUM_PROPERTY_LENGTH 40
335
 
#define MAXIMUM_VALUE_LENGTH 1024
336
 
 
337
 
 
338
 
void 
339
 
unity_webapps_indicator_set_property (UnityWebappsContext *context, 
340
 
                                      const gchar *name, 
341
 
                                      const gchar *property, 
342
 
                                      const gchar *value)
343
 
{
344
 
  gchar *sanitized_name, *sanitized_property, *sanitized_value;
345
 
 
346
 
  g_return_if_fail (context != NULL);
347
 
  g_return_if_fail (UNITY_WEBAPPS_IS_CONTEXT (context));
348
 
  g_return_if_fail (name != NULL);
349
 
  g_return_if_fail (property != NULL);
350
 
  g_return_if_fail (value != NULL);
351
 
 
352
 
  if (unity_webapps_rate_check_indicator_rate_limit (context) == FALSE)
353
 
    {
354
 
      return;
355
 
    }
356
 
  
357
 
  sanitized_name = unity_webapps_sanitizer_limit_string_argument (name, MAXIMUM_NAME_LENGTH);
358
 
  sanitized_property = unity_webapps_sanitizer_limit_string_argument (property, MAXIMUM_PROPERTY_LENGTH);
359
 
  sanitized_value = unity_webapps_sanitizer_limit_string_argument (value, MAXIMUM_VALUE_LENGTH);
360
 
  
361
 
  unity_webapps_gen_indicator_call_set_property (context->priv->indicator_context->indicator_proxy,
362
 
                                                 sanitized_name,
363
 
                                                 sanitized_property,
364
 
                                                 sanitized_value,
365
 
                                                 NULL /* Cancellable */,
366
 
                                                 set_property_complete_callback,
367
 
                                                 context);
368
 
  
369
 
  g_free (sanitized_name);
370
 
  g_free (sanitized_property);
371
 
  g_free (sanitized_value);
372
 
  
373
 
  UNITY_WEBAPPS_NOTE (INDICATOR, "Setting property of indicator %s: %s->%s", name, property, value);
374
 
}
375
 
 
376
 
 
377
 
static void
378
 
set_property_icon_complete_callback (GObject *source_object,
379
 
                                     GAsyncResult *res,
380
 
                                     gpointer user_data)
381
 
{
382
 
  UnityWebappsGenIndicator *proxy;
383
 
  GError *error;
384
 
  
385
 
  proxy = UNITY_WEBAPPS_GEN_INDICATOR (source_object);
386
 
  
387
 
  error = NULL;
388
 
  
389
 
  unity_webapps_gen_indicator_call_set_property_icon_finish (proxy, res, &error);
390
 
  
391
 
  if (error != NULL)
392
 
    {
393
 
      g_warning ("Error calling SetPropertyIcon of Indicator context: %s", error->message);
394
 
      
395
 
      g_error_free (error);
396
 
      
397
 
      return;
398
 
    }
399
 
  
400
 
  UNITY_WEBAPPS_NOTE (INDICATOR, "Received response, icon property succesfully set");
401
 
}
402
 
 
403
 
 
404
 
 
405
 
void 
406
 
unity_webapps_indicator_set_property_icon (UnityWebappsContext *context, 
407
 
                                      const gchar *name, 
408
 
                                      const gchar *property, 
409
 
                                      const gchar *value)
410
 
{
411
 
  gchar *sanitized_name, *sanitized_property, *sanitized_value;
412
 
 
413
 
  g_return_if_fail (context != NULL);
414
 
  g_return_if_fail (UNITY_WEBAPPS_IS_CONTEXT (context));
415
 
  g_return_if_fail (name != NULL);
416
 
  g_return_if_fail (property != NULL);
417
 
  g_return_if_fail (value != NULL);
418
 
 
419
 
  if (unity_webapps_rate_check_indicator_rate_limit (context) == FALSE)
420
 
    {
421
 
      return;
422
 
    }
423
 
 
424
 
  sanitized_name = unity_webapps_sanitizer_limit_string_argument (name, MAXIMUM_NAME_LENGTH);
425
 
  sanitized_property = unity_webapps_sanitizer_limit_string_argument (property, MAXIMUM_PROPERTY_LENGTH);
426
 
  sanitized_value = unity_webapps_sanitizer_limit_string_argument (value, MAXIMUM_VALUE_LENGTH);
427
 
  
428
 
  
429
 
  unity_webapps_gen_indicator_call_set_property_icon (context->priv->indicator_context->indicator_proxy,
430
 
                                                      sanitized_name,
431
 
                                                      sanitized_property,
432
 
                                                      sanitized_value,
433
 
                                                      NULL /* Cancellable */,
434
 
                                                      set_property_icon_complete_callback,
435
 
                                                      context);
436
 
 
437
 
  g_free (sanitized_name);
438
 
  g_free (sanitized_property);
439
 
  g_free (sanitized_value);
440
 
  
441
 
  UNITY_WEBAPPS_NOTE (INDICATOR, "Setting icon property of indicator %s: %s->%s", name,
442
 
                      property, value);
443
 
}
444
 
 
445
 
void 
446
 
unity_webapps_indicator_set_callback (UnityWebappsContext *context, 
447
 
                                      const gchar *name, 
448
 
                                      UnityWebappsIndicatorCallback callback)
449
 
{
450
 
  UnityWebappsIndicatorContext *indicator_context;
451
 
  gchar *sanitized_name;
452
 
 
453
 
  g_return_if_fail (context != NULL);
454
 
  g_return_if_fail (UNITY_WEBAPPS_IS_CONTEXT (context));
455
 
  g_return_if_fail (name != NULL);
456
 
  g_return_if_fail (callback != NULL);
457
 
  
458
 
  // The hash table takes ownership of this.
459
 
  sanitized_name = unity_webapps_sanitizer_limit_string_argument (name, MAXIMUM_NAME_LENGTH);
460
 
                   
461
 
  
462
 
  indicator_context = context->priv->indicator_context;
463
 
  
464
 
  g_hash_table_insert (indicator_context->indicator_callbacks_by_name, 
465
 
                       (gpointer) sanitized_name, 
466
 
                       (gpointer) callback);
467
 
}
468
 
 
469
 
gchar *
470
 
unity_webapps_indicator_get_presence (UnityWebappsContext *context)
471
 
{
472
 
  g_return_val_if_fail (context != NULL, NULL);
473
 
  g_return_val_if_fail (UNITY_WEBAPPS_IS_CONTEXT (context), NULL);
474
 
  
475
 
  if (unity_webapps_rate_check_indicator_rate_limit (context) == FALSE)
476
 
    {
477
 
      return FALSE;
478
 
    }
479
 
  return g_strdup (unity_webapps_gen_indicator_get_presence (context->priv->indicator_context->indicator_proxy));
480
 
}
481
 
 
482
 
void 
483
 
unity_webapps_indicator_on_presence_changed_callback (UnityWebappsContext *context,
484
 
                                                      UnityWebappsPresenceCallback callback)
485
 
{
486
 
  g_return_if_fail (context != NULL);
487
 
  g_return_if_fail (UNITY_WEBAPPS_IS_CONTEXT (context));
488
 
  g_return_if_fail (callback != NULL);
489
 
  
490
 
  context->priv->indicator_context->presence_callbacks_list = g_list_append (context->priv->indicator_context->presence_callbacks_list, callback);
491
 
}