← Back to branch summary

~ubuntu-branches/ubuntu/precise/bamf/precise-updates

« back to all changes in this revision

Viewing changes to .pc/debian-changes-0.2.98-0ubuntu2/lib/libbamf/bamf-view.c

  • Committer: Package Import Robot
  • Author(s): Didier Roche
  • Date: 2011-09-22 15:15:28 UTC
  • mfrom: (1.1.37 upstream)
  • Revision ID: package-import@ubuntu.com-20110922151528-c6eewp8gdys1vdp8
Tags: 0.2.100-0ubuntu1
https://launchpad.net/bugs/692462
* New upstream release.
  - Fix unity confused with chrome web apps (LP: #692462)

Show diffs side-by-side

added added

removed removed

Lines of Context:
.pc/debian-changes-0.2.98-0ubuntu2/lib/libbamf/bamf-view.c
1
 
/*
2
 
 * Copyright 2010 Canonical Ltd.
3
 
 *
4
 
 * This program is free software: you can redistribute it and/or modify it
5
 
 * under the terms of either or both of the following licenses:
6
 
 *
7
 
 * 1) the GNU Lesser General Public License version 3, as published by the
8
 
 * Free Software Foundation; and/or
9
 
 * 2) the GNU Lesser General Public License version 2.1, as published by
10
 
 * the Free Software Foundation.
11
 
 *
12
 
 * This program is distributed in the hope that it will be useful, but
13
 
 * WITHOUT ANY WARRANTY; without even the implied warranties of
14
 
 * MERCHANTABILITY, SATISFACTORY QUALITY or FITNESS FOR A PARTICULAR
15
 
 * PURPOSE.  See the applicable version of the GNU Lesser General Public
16
 
 * License for more details.
17
 
 *
18
 
 * You should have received a copy of both the GNU Lesser General Public
19
 
 * License version 3 and version 2.1 along with this program.  If not, see
20
 
 * <http://www.gnu.org/licenses/>
21
 
 *
22
 
 * Authored by: Jason Smith <jason.smith@canonical.com>
23
 
 *              Neil Jagdish Patel <neil.patel@canonical.com>
24
 
 *
25
 
 */
26
 
/**
27
 
 * SECTION:bamf-view
28
 
 * @short_description: The base class for all views
29
 
 *
30
 
 * #BamfView is the base class that all views need to derive from.
31
 
 */
32
 
 
33
 
#if HAVE_CONFIG_H
34
 
#include <config.h>
35
 
#endif
36
 
 
37
 
#include "bamf-view.h"
38
 
#include "bamf-view-private.h"
39
 
#include "bamf-factory.h"
40
 
#include "bamf-window.h"
41
 
#include "bamf-marshal.h"
42
 
 
43
 
#include <dbus/dbus.h>
44
 
#include <dbus/dbus-glib.h>
45
 
#include <dbus/dbus-glib-lowlevel.h>
46
 
 
47
 
G_DEFINE_TYPE (BamfView, bamf_view, G_TYPE_INITIALLY_UNOWNED);
48
 
 
49
 
#define BAMF_VIEW_GET_PRIVATE(o) \
50
 
  (G_TYPE_INSTANCE_GET_PRIVATE ((o), BAMF_TYPE_VIEW, BamfViewPrivate))
51
 
 
52
 
enum
53
 
{
54
 
  BAMF_VIEW_RUNNING_FLAG = 1 << 0,
55
 
  BAMF_VIEW_URGENT_FLAG  = 1 << 1,
56
 
  BAMF_VIEW_VISIBLE_FLAG = 1 << 2,
57
 
  BAMF_VIEW_ACTIVE_FLAG  = 1 << 3,
58
 
};
59
 
 
60
 
enum
61
 
{
62
 
  ACTIVE_CHANGED,
63
 
  CLOSED,
64
 
  CHILD_ADDED,
65
 
  CHILD_REMOVED,
66
 
  RUNNING_CHANGED,
67
 
  URGENT_CHANGED,
68
 
  VISIBLE_CHANGED,
69
 
  NAME_CHANGED,
70
 
 
71
 
  LAST_SIGNAL,
72
 
};
73
 
 
74
 
enum
75
 
{
76
 
  PROP_0,
77
 
 
78
 
  PROP_PATH,
79
 
  PROP_RUNNING,
80
 
  PROP_ACTIVE,
81
 
  PROP_USER_VISIBLE,
82
 
  PROP_URGENT,
83
 
};
84
 
 
85
 
static guint view_signals[LAST_SIGNAL] = { 0 };
86
 
 
87
 
struct _BamfViewPrivate
88
 
{
89
 
  DBusGConnection *connection;
90
 
  DBusGProxy      *proxy;
91
 
  gchar           *path;
92
 
  gchar           *type;
93
 
  gchar           *local_icon;
94
 
  gchar           *local_name;
95
 
  guint            checked_flags;
96
 
  guint            set_flags;
97
 
  gboolean         is_closed;
98
 
  gboolean         sticky;
99
 
};
100
 
 
101
 
static void
102
 
bamf_view_set_flag (BamfView *view, guint flag, gboolean value)
103
 
{
104
 
  BamfViewPrivate *priv;
105
 
  
106
 
  g_return_if_fail (BAMF_IS_VIEW (view));
107
 
  
108
 
  priv = view->priv;
109
 
  
110
 
  if (value)
111
 
    priv->set_flags |= flag;
112
 
  else
113
 
    priv->set_flags = priv->set_flags & ~flag;
114
 
  
115
 
  priv->checked_flags |= flag;
116
 
}
117
 
 
118
 
static gboolean
119
 
bamf_view_flag_is_set (BamfView *view, guint flag)
120
 
{
121
 
  BamfViewPrivate *priv;
122
 
  
123
 
  g_return_val_if_fail (BAMF_IS_VIEW (view), FALSE);
124
 
  
125
 
  priv = view->priv;
126
 
  
127
 
  return priv->checked_flags & flag;
128
 
}
129
 
 
130
 
static gboolean
131
 
bamf_view_get_flag (BamfView *view, guint flag)
132
 
{
133
 
  BamfViewPrivate *priv;
134
 
  
135
 
  g_return_val_if_fail (BAMF_IS_VIEW (view), FALSE);
136
 
  
137
 
  priv = view->priv;
138
 
  
139
 
  return priv->set_flags & flag;
140
 
}
141
 
 
142
 
GList *
143
 
bamf_view_get_children (BamfView *view)
144
 
{
145
 
  char ** children;
146
 
  int i, len;
147
 
  GList *results = NULL;
148
 
  GError *error = NULL;
149
 
  BamfViewPrivate *priv;
150
 
 
151
 
  g_return_val_if_fail (BAMF_IS_VIEW (view), NULL);
152
 
  
153
 
  if (BAMF_VIEW_GET_CLASS (view)->get_children)
154
 
    return BAMF_VIEW_GET_CLASS (view)->get_children (view);
155
 
 
156
 
  if (!bamf_view_remote_ready (view))
157
 
    return NULL;
158
 
 
159
 
  priv = view->priv;
160
 
 
161
 
  if (!dbus_g_proxy_call (priv->proxy,
162
 
                          "Children",
163
 
                          &error,
164
 
                          G_TYPE_INVALID,
165
 
                          G_TYPE_STRV, &children,
166
 
                          G_TYPE_INVALID))
167
 
    {
168
 
      g_warning ("Unable to fetch children: %s\n", error->message);
169
 
      return NULL;
170
 
    }
171
 
 
172
 
  if (!children)
173
 
    return NULL;
174
 
 
175
 
  len = g_strv_length (children);
176
 
 
177
 
  for (i = 0; i < len; i++)
178
 
    {
179
 
      BamfView *view = bamf_factory_view_for_path (bamf_factory_get_default (), children[i]);
180
 
      results = g_list_prepend (results, view);
181
 
    }
182
 
 
183
 
  return results;
184
 
}
185
 
 
186
 
static gboolean
187
 
bamf_view_get_boolean (BamfView *self, const char *method_name, guint flag)
188
 
{
189
 
  BamfViewPrivate *priv;
190
 
  gboolean result = FALSE;
191
 
  GError *error = NULL;
192
 
 
193
 
  g_return_val_if_fail (BAMF_IS_VIEW (self), FALSE);
194
 
  priv = self->priv;
195
 
  
196
 
  if (bamf_view_flag_is_set (self, flag))
197
 
    return bamf_view_get_flag (self, flag);
198
 
 
199
 
  if (!bamf_view_remote_ready (self))
200
 
    return FALSE;
201
 
 
202
 
  if (!dbus_g_proxy_call (priv->proxy,
203
 
                          method_name,
204
 
                          &error,
205
 
                          G_TYPE_INVALID,
206
 
                          G_TYPE_BOOLEAN, &result,
207
 
                          G_TYPE_INVALID))
208
 
    {
209
 
      g_warning ("Failed to fetch boolean: %s", error->message);
210
 
      g_error_free (error);
211
 
      
212
 
      return FALSE;
213
 
    }
214
 
  
215
 
  bamf_view_set_flag (self, flag, result);
216
 
  return result;
217
 
}
218
 
 
219
 
gboolean
220
 
bamf_view_is_closed (BamfView *view)
221
 
{
222
 
  g_return_val_if_fail (BAMF_IS_VIEW (view), TRUE);
223
 
  
224
 
  return view->priv->is_closed;
225
 
}
226
 
 
227
 
gboolean
228
 
bamf_view_is_active (BamfView *view)
229
 
{
230
 
  g_return_val_if_fail (BAMF_IS_VIEW (view), FALSE);
231
 
  
232
 
  if (BAMF_VIEW_GET_CLASS (view)->is_active)
233
 
    return BAMF_VIEW_GET_CLASS (view)->is_active (view);
234
 
 
235
 
  return bamf_view_get_boolean (view, "IsActive", BAMF_VIEW_ACTIVE_FLAG);
236
 
 
237
 
}
238
 
 
239
 
gboolean          
240
 
bamf_view_user_visible (BamfView *self)
241
 
{
242
 
  g_return_val_if_fail (BAMF_IS_VIEW (self), FALSE);
243
 
  
244
 
  return bamf_view_get_boolean (self, "UserVisible", BAMF_VIEW_VISIBLE_FLAG);
245
 
 
246
 
}
247
 
 
248
 
gboolean
249
 
bamf_view_is_running (BamfView *self)
250
 
{
251
 
  g_return_val_if_fail (BAMF_IS_VIEW (self), FALSE);
252
 
  
253
 
  if (BAMF_VIEW_GET_CLASS (self)->is_running)
254
 
    return BAMF_VIEW_GET_CLASS (self)->is_running (self);
255
 
 
256
 
  return bamf_view_get_boolean (self, "IsRunning", BAMF_VIEW_RUNNING_FLAG);
257
 
}
258
 
 
259
 
gboolean
260
 
bamf_view_is_urgent (BamfView *self)
261
 
{
262
 
  g_return_val_if_fail (BAMF_IS_VIEW (self), FALSE);
263
 
  
264
 
  if (BAMF_VIEW_GET_CLASS (self)->is_urgent)
265
 
    return BAMF_VIEW_GET_CLASS (self)->is_urgent (self);
266
 
 
267
 
  return bamf_view_get_boolean (self, "IsUrgent", BAMF_VIEW_URGENT_FLAG);
268
 
}
269
 
 
270
 
void
271
 
bamf_view_set_name (BamfView *view, const char *name)
272
 
{
273
 
  g_return_if_fail (BAMF_IS_VIEW (view));
274
 
  
275
 
  if (!g_strcmp0 (name, view->priv->local_name))
276
 
    return;
277
 
 
278
 
  view->priv->local_name = g_strdup (name);
279
 
}
280
 
 
281
 
void
282
 
bamf_view_set_icon (BamfView *view, const char *icon)
283
 
{
284
 
  g_return_if_fail (BAMF_IS_VIEW (view));
285
 
  
286
 
  view->priv->local_icon = g_strdup (icon);
287
 
}
288
 
 
289
 
gboolean 
290
 
bamf_view_is_sticky (BamfView *view)
291
 
{
292
 
  g_return_val_if_fail (BAMF_IS_VIEW (view), FALSE);
293
 
  
294
 
  return view->priv->sticky;
295
 
}
296
 
 
297
 
void 
298
 
bamf_view_set_sticky (BamfView *view, gboolean value)
299
 
{
300
 
  g_return_if_fail (BAMF_IS_VIEW (view));
301
 
  
302
 
  if (value == view->priv->sticky)
303
 
    return;
304
 
  
305
 
  if (value)
306
 
    g_object_ref_sink (view);
307
 
  else
308
 
    g_object_unref (view);
309
 
  
310
 
  view->priv->sticky = value;
311
 
}
312
 
 
313
 
gchar *
314
 
bamf_view_get_icon (BamfView *self)
315
 
{
316
 
  BamfViewPrivate *priv;
317
 
  char *icon = NULL;
318
 
  GError *error = NULL;
319
 
 
320
 
  g_return_val_if_fail (BAMF_IS_VIEW (self), NULL);
321
 
  priv = self->priv;
322
 
  
323
 
  if (BAMF_VIEW_GET_CLASS (self)->get_icon)
324
 
    return BAMF_VIEW_GET_CLASS (self)->get_icon (self);
325
 
 
326
 
  if (!bamf_view_remote_ready (self))
327
 
    return g_strdup (priv->local_icon);
328
 
 
329
 
  if (!dbus_g_proxy_call (priv->proxy,
330
 
                          "Icon",
331
 
                          &error,
332
 
                          G_TYPE_INVALID,
333
 
                          G_TYPE_STRING, &icon,
334
 
                          G_TYPE_INVALID))
335
 
    {
336
 
      g_warning ("Failed to fetch icon: %s", error->message);
337
 
      g_error_free (error);
338
 
      
339
 
      return NULL;
340
 
    }
341
 
 
342
 
  return icon;
343
 
}
344
 
 
345
 
gchar *
346
 
bamf_view_get_name (BamfView *self)
347
 
{
348
 
  BamfViewPrivate *priv;
349
 
  char *name = NULL;
350
 
  GError *error = NULL;
351
 
 
352
 
  g_return_val_if_fail (BAMF_IS_VIEW (self), NULL);
353
 
  priv = self->priv;
354
 
  
355
 
  if (BAMF_VIEW_GET_CLASS (self)->get_name)
356
 
    return BAMF_VIEW_GET_CLASS (self)->get_name (self);
357
 
 
358
 
  if (!bamf_view_remote_ready (self))
359
 
    return g_strdup(priv->local_name);
360
 
    
361
 
  if (!dbus_g_proxy_call (priv->proxy,
362
 
                          "Name",
363
 
                          &error,
364
 
                          G_TYPE_INVALID,
365
 
                          G_TYPE_STRING, &name,
366
 
                          G_TYPE_INVALID))
367
 
    {
368
 
      g_warning ("Failed to fetch name: %s", error->message);
369
 
      g_error_free (error);
370
 
      
371
 
      return NULL;
372
 
    }
373
 
 
374
 
  return name;
375
 
}
376
 
 
377
 
gboolean 
378
 
bamf_view_remote_ready (BamfView *view)
379
 
{
380
 
  return BAMF_IS_VIEW (view) && view->priv->proxy;
381
 
}
382
 
 
383
 
const gchar *
384
 
bamf_view_get_view_type (BamfView *self)
385
 
{
386
 
  BamfViewPrivate *priv;
387
 
  char *type = NULL;
388
 
  GError *error = NULL;
389
 
 
390
 
  g_return_val_if_fail (BAMF_IS_VIEW (self), NULL);
391
 
  priv = self->priv;
392
 
  
393
 
  if (BAMF_VIEW_GET_CLASS (self)->view_type)
394
 
    return BAMF_VIEW_GET_CLASS (self)->view_type (self);
395
 
  
396
 
  if (priv->type)
397
 
    return priv->type;
398
 
 
399
 
  if (!dbus_g_proxy_call (priv->proxy,
400
 
                          "ViewType",
401
 
                          &error,
402
 
                          G_TYPE_INVALID,
403
 
                          G_TYPE_STRING, &type,
404
 
                          G_TYPE_INVALID))
405
 
    {
406
 
      g_warning ("Failed to fetch view type at %s: %s", dbus_g_proxy_get_path (priv->proxy), error->message);
407
 
      g_error_free (error);
408
 
      return NULL;
409
 
    }
410
 
 
411
 
  priv->type = type;
412
 
  return type;
413
 
}
414
 
 
415
 
BamfClickBehavior 
416
 
bamf_view_get_click_suggestion (BamfView *self)
417
 
{
418
 
  g_return_val_if_fail (BAMF_IS_VIEW (self), BAMF_CLICK_BEHAVIOR_NONE);
419
 
 
420
 
  if (BAMF_VIEW_GET_CLASS (self)->click_behavior)
421
 
    return BAMF_VIEW_GET_CLASS (self)->click_behavior (self);
422
 
    
423
 
  return BAMF_CLICK_BEHAVIOR_NONE;
424
 
}
425
 
 
426
 
static void
427
 
bamf_view_on_child_added (DBusGProxy *proxy, char *path, BamfView *self)
428
 
{
429
 
  BamfView *view;
430
 
 
431
 
  view = bamf_factory_view_for_path (bamf_factory_get_default (), path);
432
 
  
433
 
  g_signal_emit (G_OBJECT (self), view_signals[CHILD_ADDED], 0, view);
434
 
}
435
 
 
436
 
static void
437
 
bamf_view_on_child_removed (DBusGProxy *proxy, char *path, BamfView *self)
438
 
{
439
 
  BamfView *view;
440
 
 
441
 
  view = bamf_factory_view_for_path (bamf_factory_get_default (), path);
442
 
 
443
 
  g_signal_emit (G_OBJECT (self), view_signals[CHILD_REMOVED], 0, view);
444
 
}
445
 
 
446
 
static void
447
 
bamf_view_on_active_changed (DBusGProxy *proxy, gboolean active, BamfView *self)
448
 
{
449
 
  bamf_view_set_flag (self, BAMF_VIEW_ACTIVE_FLAG, active);
450
 
 
451
 
  g_signal_emit (G_OBJECT(self), view_signals[ACTIVE_CHANGED], 0, active);
452
 
  g_object_notify (G_OBJECT (self), "active");
453
 
}
454
 
 
455
 
static void
456
 
bamf_view_on_name_changed (DBusGProxy*  proxy,
457
 
                           const gchar* old_name,
458
 
                           const gchar* new_name,
459
 
                           BamfView*    self)
460
 
{
461
 
  self->priv->local_name = g_strdup (new_name);
462
 
 
463
 
  g_signal_emit (self, view_signals[NAME_CHANGED], 0, old_name, new_name);
464
 
}
465
 
 
466
 
static void
467
 
bamf_view_on_running_changed (DBusGProxy *proxy, gboolean running, BamfView *self)
468
 
{
469
 
  bamf_view_set_flag (self, BAMF_VIEW_RUNNING_FLAG, running);
470
 
 
471
 
  g_signal_emit (G_OBJECT (self), view_signals[RUNNING_CHANGED], 0, running);
472
 
  g_object_notify (G_OBJECT (self), "running");
473
 
}
474
 
 
475
 
static void
476
 
bamf_view_on_urgent_changed (DBusGProxy *proxy, gboolean urgent, BamfView *self)
477
 
{
478
 
  bamf_view_set_flag (self, BAMF_VIEW_URGENT_FLAG, urgent);
479
 
 
480
 
  g_signal_emit (G_OBJECT (self), view_signals[URGENT_CHANGED], 0, urgent);
481
 
  g_object_notify (G_OBJECT (self), "urgent");
482
 
}
483
 
 
484
 
static void
485
 
bamf_view_on_user_visible_changed (DBusGProxy *proxy, gboolean visible, BamfView *self)
486
 
{
487
 
  bamf_view_set_flag (self, BAMF_VIEW_VISIBLE_FLAG, visible);
488
 
 
489
 
  g_signal_emit (G_OBJECT (self), view_signals[VISIBLE_CHANGED], 0, visible);
490
 
  g_object_notify (G_OBJECT (self), "user-visible");
491
 
}
492
 
 
493
 
static void
494
 
bamf_view_on_closed (DBusGProxy *proxy, BamfView *self)
495
 
{
496
 
  BamfViewPrivate *priv;
497
 
  
498
 
  priv = self->priv;
499
 
 
500
 
  priv->is_closed = TRUE;
501
 
  
502
 
  if (priv->sticky && priv->proxy)
503
 
    {
504
 
      dbus_g_proxy_disconnect_signal (priv->proxy,
505
 
                                      "ActiveChanged",
506
 
                                      (GCallback) bamf_view_on_active_changed,
507
 
                                      self);
508
 
 
509
 
      dbus_g_proxy_disconnect_signal (priv->proxy,
510
 
                                      "Closed",
511
 
                                      (GCallback) bamf_view_on_closed,
512
 
                                      self);
513
 
 
514
 
      dbus_g_proxy_disconnect_signal (priv->proxy,
515
 
                                      "ChildAdded",
516
 
                                      (GCallback) bamf_view_on_child_added,
517
 
                                      self);
518
 
 
519
 
      dbus_g_proxy_disconnect_signal (priv->proxy,
520
 
                                      "ChildRemoved",
521
 
                                      (GCallback) bamf_view_on_child_removed,
522
 
                                      self);
523
 
 
524
 
      dbus_g_proxy_disconnect_signal (priv->proxy,
525
 
                                      "RunningChanged",
526
 
                                      (GCallback) bamf_view_on_running_changed,
527
 
                                      self);
528
 
 
529
 
      dbus_g_proxy_disconnect_signal (priv->proxy,
530
 
                                     "UrgentChanged",
531
 
                                     (GCallback) bamf_view_on_urgent_changed,
532
 
                                     self);
533
 
  
534
 
      dbus_g_proxy_disconnect_signal (priv->proxy,
535
 
                                     "UserVisibleChanged",
536
 
                                     (GCallback) bamf_view_on_user_visible_changed,
537
 
                                     self);
538
 
      g_object_unref (priv->proxy);
539
 
      priv->proxy = NULL;
540
 
    }
541
 
  
542
 
  g_object_ref (self);
543
 
  
544
 
  // must be emitted before path is cleared as path is utilized in cleanup
545
 
  g_signal_emit (G_OBJECT (self), view_signals[CLOSED], 0);
546
 
 
547
 
  if (priv->path)
548
 
    {
549
 
      g_free (priv->path);
550
 
      priv->path = NULL;
551
 
    }
552
 
    
553
 
  g_object_unref (self);
554
 
}
555
 
 
556
 
static void
557
 
bamf_view_set_property (GObject *object, guint property_id, const GValue *value, GParamSpec *pspec)
558
 
{
559
 
  switch (property_id)
560
 
    {
561
 
      default:
562
 
        G_OBJECT_WARN_INVALID_PROPERTY_ID(object, property_id, pspec);
563
 
    }
564
 
}
565
 
 
566
 
static void
567
 
bamf_view_get_property (GObject *object, guint property_id, GValue *value, GParamSpec *pspec)
568
 
{
569
 
  BamfView *self;
570
 
 
571
 
  self = BAMF_VIEW (object);
572
 
 
573
 
  switch (property_id)
574
 
    {
575
 
      case PROP_PATH:
576
 
        g_value_set_string (value, self->priv->path);
577
 
        break;
578
 
      
579
 
      case PROP_ACTIVE:
580
 
        g_value_set_boolean (value, bamf_view_is_active (self));
581
 
        break;
582
 
      
583
 
      case PROP_RUNNING:
584
 
        g_value_set_boolean (value, bamf_view_is_running (self));
585
 
        break;
586
 
      
587
 
      case PROP_URGENT:
588
 
        g_value_set_boolean (value, bamf_view_is_urgent (self));
589
 
        break;
590
 
      
591
 
      case PROP_USER_VISIBLE:
592
 
        g_value_set_boolean (value, bamf_view_user_visible (self));
593
 
        break;
594
 
      
595
 
      default:
596
 
        G_OBJECT_WARN_INVALID_PROPERTY_ID(object, property_id, pspec);
597
 
    }
598
 
}
599
 
 
600
 
static void
601
 
bamf_view_dispose (GObject *object)
602
 
{
603
 
  BamfView *view;
604
 
  BamfViewPrivate *priv;
605
 
 
606
 
  view = BAMF_VIEW (object);
607
 
 
608
 
  priv = view->priv;
609
 
  
610
 
  if (priv->path)
611
 
    {
612
 
      g_free (priv->path);
613
 
      priv->path = NULL;
614
 
    }
615
 
  
616
 
    
617
 
  if (priv->type)
618
 
    {
619
 
      g_free (priv->type);
620
 
      priv->type = NULL;
621
 
    }
622
 
 
623
 
  if (priv->proxy)
624
 
    {
625
 
      dbus_g_proxy_disconnect_signal (priv->proxy,
626
 
                                      "ActiveChanged",
627
 
                                      (GCallback) bamf_view_on_active_changed,
628
 
                                      view);
629
 
 
630
 
      dbus_g_proxy_disconnect_signal (priv->proxy,
631
 
                                      "Closed",
632
 
                                      (GCallback) bamf_view_on_closed,
633
 
                                      view);
634
 
 
635
 
      dbus_g_proxy_disconnect_signal (priv->proxy,
636
 
                                      "ChildAdded",
637
 
                                      (GCallback) bamf_view_on_child_added,
638
 
                                      view);
639
 
 
640
 
      dbus_g_proxy_disconnect_signal (priv->proxy,
641
 
                                      "ChildRemoved",
642
 
                                      (GCallback) bamf_view_on_child_removed,
643
 
                                      view);
644
 
 
645
 
      dbus_g_proxy_disconnect_signal (priv->proxy,
646
 
                                      "RunningChanged",
647
 
                                      (GCallback) bamf_view_on_running_changed,
648
 
                                       view);
649
 
 
650
 
      dbus_g_proxy_disconnect_signal (priv->proxy,
651
 
                                     "UrgentChanged",
652
 
                                     (GCallback) bamf_view_on_urgent_changed,
653
 
                                     view);
654
 
  
655
 
      dbus_g_proxy_disconnect_signal (priv->proxy,
656
 
                                     "UserVisibleChanged",
657
 
                                     (GCallback) bamf_view_on_user_visible_changed,
658
 
                                     view);
659
 
 
660
 
      dbus_g_proxy_disconnect_signal (priv->proxy,
661
 
                                     "NameChanged",
662
 
                                     (GCallback) bamf_view_on_name_changed,
663
 
                                     view);
664
 
 
665
 
      g_object_unref (priv->proxy);
666
 
      priv->proxy = NULL;
667
 
    }
668
 
}
669
 
 
670
 
const char * 
671
 
bamf_view_get_path (BamfView *view)
672
 
{
673
 
  g_return_val_if_fail (BAMF_IS_VIEW (view), NULL);
674
 
  
675
 
  return view->priv->path;
676
 
}
677
 
 
678
 
void
679
 
bamf_view_set_path (BamfView *view, const char *path)
680
 
{
681
 
  BamfViewPrivate *priv;
682
 
  
683
 
  g_return_if_fail (BAMF_IS_VIEW (view));
684
 
  
685
 
  priv = view->priv;
686
 
  priv->is_closed = FALSE;
687
 
 
688
 
  if (priv->path)
689
 
    {
690
 
      g_free (priv->path);
691
 
    }
692
 
  
693
 
  priv->path = g_strdup (path);
694
 
  priv->proxy = dbus_g_proxy_new_for_name (priv->connection,
695
 
                                           "org.ayatana.bamf",
696
 
                                           priv->path,
697
 
                                           "org.ayatana.bamf.view");
698
 
  if (priv->proxy == NULL)
699
 
    {
700
 
      g_critical ("Unable to get org.ayatana.bamf.view view");
701
 
      return;
702
 
    }
703
 
 
704
 
  dbus_g_proxy_add_signal (priv->proxy,
705
 
                           "ActiveChanged",
706
 
                           G_TYPE_BOOLEAN,
707
 
                           G_TYPE_INVALID);
708
 
 
709
 
  dbus_g_proxy_add_signal (priv->proxy,
710
 
                           "Closed",
711
 
                           G_TYPE_INVALID);
712
 
 
713
 
  dbus_g_proxy_add_signal (priv->proxy,
714
 
                           "ChildAdded",
715
 
                           G_TYPE_STRING,
716
 
                           G_TYPE_INVALID);
717
 
 
718
 
  dbus_g_proxy_add_signal (priv->proxy,
719
 
                           "ChildRemoved",
720
 
                           G_TYPE_STRING,
721
 
                           G_TYPE_INVALID);
722
 
 
723
 
  dbus_g_proxy_add_signal (priv->proxy,
724
 
                           "RunningChanged",
725
 
                           G_TYPE_BOOLEAN,
726
 
                           G_TYPE_INVALID);
727
 
  
728
 
  dbus_g_proxy_add_signal (priv->proxy,
729
 
                           "UrgentChanged",
730
 
                           G_TYPE_BOOLEAN, 
731
 
                           G_TYPE_INVALID);
732
 
  
733
 
  dbus_g_proxy_add_signal (priv->proxy,
734
 
                           "UserVisibleChanged",
735
 
                           G_TYPE_BOOLEAN, 
736
 
                           G_TYPE_INVALID);
737
 
 
738
 
  dbus_g_proxy_add_signal (priv->proxy,
739
 
                           "NameChanged",
740
 
                           G_TYPE_STRING,
741
 
                           G_TYPE_STRING,
742
 
                           G_TYPE_INVALID);
743
 
 
744
 
  dbus_g_proxy_connect_signal (priv->proxy,
745
 
                               "ActiveChanged",
746
 
                               (GCallback) bamf_view_on_active_changed,
747
 
                               view,
748
 
                               NULL);
749
 
 
750
 
  dbus_g_proxy_connect_signal (priv->proxy,
751
 
                               "Closed",
752
 
                               (GCallback) bamf_view_on_closed,
753
 
                               view,
754
 
                               NULL);
755
 
 
756
 
  dbus_g_proxy_connect_signal (priv->proxy,
757
 
                               "ChildAdded",
758
 
                               (GCallback) bamf_view_on_child_added,
759
 
                               view,
760
 
                               NULL);
761
 
 
762
 
  dbus_g_proxy_connect_signal (priv->proxy,
763
 
                               "ChildRemoved",
764
 
                               (GCallback) bamf_view_on_child_removed,
765
 
                               view,
766
 
                               NULL);
767
 
 
768
 
  dbus_g_proxy_connect_signal (priv->proxy,
769
 
                               "RunningChanged",
770
 
                               (GCallback) bamf_view_on_running_changed,
771
 
                               view,
772
 
                               NULL);
773
 
 
774
 
  dbus_g_proxy_connect_signal (priv->proxy,
775
 
                               "UrgentChanged",
776
 
                               (GCallback) bamf_view_on_urgent_changed,
777
 
                               view,
778
 
                               NULL);
779
 
  
780
 
  dbus_g_proxy_connect_signal (priv->proxy,
781
 
                               "UserVisibleChanged",
782
 
                               (GCallback) bamf_view_on_user_visible_changed,
783
 
                               view,
784
 
                               NULL);
785
 
 
786
 
  dbus_g_proxy_connect_signal (priv->proxy,
787
 
                               "NameChanged",
788
 
                               (GCallback) bamf_view_on_name_changed,
789
 
                               view,
790
 
                               NULL);
791
 
 
792
 
  if (bamf_view_is_sticky (view))
793
 
    {
794
 
      priv->checked_flags = 0x0;
795
 
      
796
 
      if (bamf_view_user_visible (view))
797
 
        {
798
 
          g_signal_emit (G_OBJECT(view), view_signals[VISIBLE_CHANGED], 0, TRUE);
799
 
          g_object_notify (G_OBJECT (view), "user-visible");
800
 
        }
801
 
      
802
 
      if (bamf_view_is_active (view))
803
 
        {
804
 
          g_signal_emit (G_OBJECT(view), view_signals[ACTIVE_CHANGED], 0, TRUE);
805
 
          g_object_notify (G_OBJECT (view), "active");
806
 
        }
807
 
      
808
 
      if (bamf_view_is_running (view))
809
 
        {
810
 
          g_signal_emit (G_OBJECT(view), view_signals[RUNNING_CHANGED], 0, TRUE);
811
 
          g_object_notify (G_OBJECT (view), "running");
812
 
        }
813
 
        
814
 
      if (bamf_view_is_urgent (view))
815
 
        {
816
 
          g_signal_emit (G_OBJECT(view), view_signals[URGENT_CHANGED], 0, TRUE);
817
 
          g_object_notify (G_OBJECT (view), "urgent");
818
 
        }
819
 
    }
820
 
  if (BAMF_VIEW_GET_CLASS (view)->set_path)
821
 
    BAMF_VIEW_GET_CLASS (view)->set_path (view, path);
822
 
}
823
 
 
824
 
static void
825
 
bamf_view_constructed (GObject *object)
826
 
{
827
 
  if (G_OBJECT_CLASS (bamf_view_parent_class)->constructed)
828
 
    G_OBJECT_CLASS (bamf_view_parent_class)->constructed (object);
829
 
}
830
 
 
831
 
static void
832
 
bamf_view_class_init (BamfViewClass *klass)
833
 
{
834
 
  GParamSpec *pspec;
835
 
  GObjectClass *obj_class = G_OBJECT_CLASS (klass);
836
 
 
837
 
  obj_class->constructed  = bamf_view_constructed;
838
 
  obj_class->dispose      = bamf_view_dispose;
839
 
  obj_class->get_property = bamf_view_get_property;
840
 
  obj_class->set_property = bamf_view_set_property;
841
 
 
842
 
  pspec = g_param_spec_string ("path", "path", "path", NULL, G_PARAM_READABLE);
843
 
  g_object_class_install_property (obj_class, PROP_PATH, pspec);
844
 
  
845
 
  pspec = g_param_spec_boolean ("active", "active", "active", FALSE, G_PARAM_READABLE);
846
 
  g_object_class_install_property (obj_class, PROP_ACTIVE, pspec);
847
 
 
848
 
  pspec = g_param_spec_boolean ("urgent", "urgent", "urgent", FALSE, G_PARAM_READABLE);
849
 
  g_object_class_install_property (obj_class, PROP_URGENT, pspec);
850
 
  
851
 
  pspec = g_param_spec_boolean ("running", "running", "running", FALSE, G_PARAM_READABLE);
852
 
  g_object_class_install_property (obj_class, PROP_RUNNING, pspec);
853
 
  
854
 
  pspec = g_param_spec_boolean ("user-visible", "user-visible", "user-visible", FALSE, G_PARAM_READABLE);
855
 
  g_object_class_install_property (obj_class, PROP_USER_VISIBLE, pspec);
856
 
 
857
 
  g_type_class_add_private (obj_class, sizeof (BamfViewPrivate));
858
 
 
859
 
  view_signals [ACTIVE_CHANGED] = 
860
 
        g_signal_new ("active-changed",
861
 
                      G_OBJECT_CLASS_TYPE (klass),
862
 
                      G_SIGNAL_RUN_FIRST,
863
 
                      G_STRUCT_OFFSET (BamfViewClass, active_changed), 
864
 
                      NULL, NULL,
865
 
                      g_cclosure_marshal_VOID__BOOLEAN,
866
 
                      G_TYPE_NONE, 1, 
867
 
                      G_TYPE_BOOLEAN);
868
 
 
869
 
  view_signals [CLOSED] = 
870
 
        g_signal_new ("closed",
871
 
                      G_OBJECT_CLASS_TYPE (klass),
872
 
                      G_SIGNAL_RUN_FIRST,
873
 
                      G_STRUCT_OFFSET (BamfViewClass, closed), 
874
 
                      NULL, NULL,
875
 
                      g_cclosure_marshal_VOID__VOID,
876
 
                      G_TYPE_NONE, 0);
877
 
 
878
 
  view_signals [CHILD_ADDED] = 
879
 
        g_signal_new ("child-added",
880
 
                      G_OBJECT_CLASS_TYPE (klass),
881
 
                      G_SIGNAL_RUN_FIRST,
882
 
                      G_STRUCT_OFFSET (BamfViewClass, child_added), 
883
 
                      NULL, NULL,
884
 
                      g_cclosure_marshal_VOID__OBJECT,
885
 
                      G_TYPE_NONE, 1, 
886
 
                      BAMF_TYPE_VIEW);
887
 
 
888
 
  view_signals [CHILD_REMOVED] = 
889
 
        g_signal_new ("child-removed",
890
 
                      G_OBJECT_CLASS_TYPE (klass),
891
 
                      G_SIGNAL_RUN_FIRST,
892
 
                      G_STRUCT_OFFSET (BamfViewClass, child_removed), 
893
 
                      NULL, NULL,
894
 
                      g_cclosure_marshal_VOID__OBJECT,
895
 
                      G_TYPE_NONE, 1, 
896
 
                      BAMF_TYPE_VIEW);
897
 
 
898
 
  view_signals [RUNNING_CHANGED] = 
899
 
        g_signal_new ("running-changed",
900
 
                      G_OBJECT_CLASS_TYPE (klass),
901
 
                      G_SIGNAL_RUN_FIRST,
902
 
                      G_STRUCT_OFFSET (BamfViewClass, running_changed), 
903
 
                      NULL, NULL,
904
 
                      g_cclosure_marshal_VOID__BOOLEAN,
905
 
                      G_TYPE_NONE, 1, 
906
 
                      G_TYPE_BOOLEAN);
907
 
 
908
 
  view_signals [URGENT_CHANGED] = 
909
 
        g_signal_new ("urgent-changed",
910
 
                      G_OBJECT_CLASS_TYPE (klass),
911
 
                      G_SIGNAL_RUN_FIRST,
912
 
                      G_STRUCT_OFFSET (BamfViewClass, urgent_changed), 
913
 
                      NULL, NULL,
914
 
                      g_cclosure_marshal_VOID__BOOLEAN,
915
 
                      G_TYPE_NONE, 1, 
916
 
                      G_TYPE_BOOLEAN);
917
 
  
918
 
  view_signals [VISIBLE_CHANGED] = 
919
 
        g_signal_new ("user-visible-changed",
920
 
                      G_OBJECT_CLASS_TYPE (klass),
921
 
                      G_SIGNAL_RUN_FIRST,
922
 
                      G_STRUCT_OFFSET (BamfViewClass, user_visible_changed), 
923
 
                      NULL, NULL,
924
 
                      g_cclosure_marshal_VOID__BOOLEAN,
925
 
                      G_TYPE_NONE, 1, 
926
 
                      G_TYPE_BOOLEAN);
927
 
 
928
 
  view_signals [NAME_CHANGED] =
929
 
        g_signal_new ("name-changed",
930
 
                      G_OBJECT_CLASS_TYPE (klass),
931
 
                      0,
932
 
                      0, NULL, NULL,
933
 
                      bamf_marshal_VOID__STRING_STRING,
934
 
                      G_TYPE_NONE, 2,
935
 
                      G_TYPE_STRING,
936
 
                      G_TYPE_STRING);
937
 
}
938
 
 
939
 
 
940
 
static void
941
 
bamf_view_init (BamfView *self)
942
 
{
943
 
  BamfViewPrivate *priv;
944
 
  GError *error = NULL;
945
 
 
946
 
  priv = self->priv = BAMF_VIEW_GET_PRIVATE (self);
947
 
 
948
 
  priv->is_closed = TRUE;
949
 
 
950
 
  priv->connection = dbus_g_bus_get (DBUS_BUS_SESSION, &error);
951
 
  if (priv->connection == NULL)
952
 
    {
953
 
      g_critical ("Failed to open connection to bus: %s",
954
 
               error != NULL ? error->message : "Unknown");
955
 
      if (error)
956
 
        g_error_free (error);
957
 
      return;
958
 
    }
959
 
}