← Back to branch summary

~azzar1/unity/fix-839717-5.0

« back to all changes in this revision

Viewing changes to UnityCore/DBusIndicators.cpp

  • Committer: Neil Jagdish Patel
  • Date: 2011-07-19 13:09:54 UTC
  • mfrom: (1270.2.34 gobject-signals)
  • Revision ID: neil.patel@canonical.com-20110719130954-t79rw31hr14z8z0z
[merge] GLibSignal branch that makes signal connection a fun and joyous occasion\!

Show diffs side-by-side

added added

removed removed

Lines of Context:
UnityCore/DBusIndicators.cpp
27
27
#include <X11/Xlib.h>
28
28
 
29
29
#include "config.h"
 
30
#include "GLibSignal.h"
30
31
#include "GLibWrapper.h"
31
32
#include "Variant.h"
32
33
 
83
84
bool run_local_panel_service();
84
85
gboolean reconnect_to_service(gpointer data);
85
86
void on_proxy_ready_cb(GObject* source, GAsyncResult* res, gpointer data);
86
 
void on_proxy_name_owner_changed(GDBusProxy* proxy, GParamSpec* pspec,
87
 
                                 DBusIndicators::Impl* remote);
88
 
void on_proxy_signal_received(GDBusProxy* proxy,
89
 
                              char* sender_name, char* signal_name,
90
 
                              GVariant* parameters,
91
 
                              DBusIndicators::Impl* remote);
92
87
void request_sync(GDBusProxy* proxy, const char* method, GVariant* name,
93
88
                  SyncData* data);
94
89
void on_sync_ready_cb(GObject* source, GAsyncResult* res, gpointer data);
113
108
  void Sync(GVariant* args, SyncData* data);
114
109
  void SyncGeometries(std::string const& name,
115
110
                      EntryLocationMap const& locations);
 
111
  void OnProxyNameOwnerChanged(GDBusProxy*proxy, GParamSpec *pspec);
 
112
  void OnProxySignalReceived(GDBusProxy* proxy,
 
113
                             char* sender_name,
 
114
                             char* signal_name_,
 
115
                             GVariant* parameters);
116
116
 
117
117
  virtual void OnEntryScroll(std::string const& entry_id, int delta);
118
118
  virtual void OnEntryShowMenu(std::string const& entry_id,
124
124
 
125
125
  DBusIndicators* owner_;
126
126
  GDBusProxy* proxy_;
127
 
  guint32 proxy_signal_id_;
128
 
  guint32 proxy_name_id_;
129
127
  typedef std::vector<SyncDataPtr> PendingSyncs;
130
128
  PendingSyncs pending_syncs_;
 
129
  
 
130
  glib::SignalManager signal_manager_;
131
131
};
132
132
 
133
133
 
143
143
{
144
144
  if (G_IS_OBJECT (proxy_))
145
145
  {
146
 
    g_signal_handler_disconnect(proxy_, proxy_signal_id_);
147
 
    g_signal_handler_disconnect(proxy_, proxy_name_id_);
148
146
    g_object_unref(proxy_);
149
147
  }
150
148
}
178
176
  {
179
177
    proxy_ = proxy;
180
178
    // Connect to interesting signals
181
 
    proxy_signal_id_ = g_signal_connect(proxy_, "g-signal",
182
 
                                        G_CALLBACK(on_proxy_signal_received),
183
 
                                        this);
184
 
    proxy_name_id_ = g_signal_connect(proxy_, "notify::g-name-owner",
185
 
                                      G_CALLBACK(on_proxy_name_owner_changed),
186
 
                                      this);
 
179
    signal_manager_.Add (new glib::Signal<void, GDBusProxy*, char*, char*, GVariant*>
 
180
      (proxy_, "g-signal", sigc::mem_fun(this, &Impl::OnProxySignalReceived)));
 
181
 
 
182
    signal_manager_.Add(new glib::Signal<void, GDBusProxy*,GParamSpec*>
 
183
      (proxy_, "notify::g-name-owner", sigc::mem_fun(this, &Impl::OnProxyNameOwnerChanged)));
187
184
  }
188
185
  RequestSyncAll();
189
186
}
373
370
  return g_getenv("PANEL_USE_LOCAL_SERVICE") != NULL;
374
371
}
375
372
 
 
373
void DBusIndicators::Impl::OnProxyNameOwnerChanged(GDBusProxy* proxy,
 
374
                                                   GParamSpec* pspec)
 
375
{
 
376
  char* name_owner = g_dbus_proxy_get_name_owner(proxy);
 
377
 
 
378
  if (name_owner == NULL)
 
379
  {
 
380
    // The panel service has stopped for some reason.  Restart it if not in
 
381
    // dev mode
 
382
    if (!g_getenv("UNITY_DEV_MODE"))
 
383
      Reconnect();
 
384
  }
 
385
 
 
386
  g_free (name_owner);
 
387
}
 
388
 
 
389
void DBusIndicators::Impl::OnProxySignalReceived(GDBusProxy* proxy,
 
390
                                                 char* sender_name,
 
391
                                                 char* signal_name_,
 
392
                                                 GVariant* parameters)
 
393
{
 
394
  std::string signal_name(signal_name_);
 
395
  if (signal_name == "EntryActivated")
 
396
  {
 
397
    const char* entry_name = g_variant_get_string(g_variant_get_child_value(parameters, 0), NULL);
 
398
    if (entry_name) {
 
399
      owner_->ActivateEntry(entry_name);
 
400
    }
 
401
  }
 
402
  else if (signal_name == "EntryActivateRequest")
 
403
  {
 
404
    const char* entry_name = g_variant_get_string(g_variant_get_child_value(parameters, 0), NULL);
 
405
    if (entry_name) {
 
406
      owner_->on_entry_activate_request.emit(entry_name);
 
407
    }
 
408
  }
 
409
  else if (signal_name == "ReSync")
 
410
  {
 
411
    const char* id = g_variant_get_string(g_variant_get_child_value(parameters, 0), NULL);
 
412
    bool sync_one = !g_strcmp0 (id, "") == 0;
 
413
 
 
414
    if (sync_one) {
 
415
      RequestSyncIndicator(id);
 
416
    }
 
417
    else {
 
418
      RequestSyncAll();
 
419
    }
 
420
  }
 
421
  else if (signal_name == "ActiveMenuPointerMotion")
 
422
  {
 
423
    int x = 0;
 
424
    int y = 0;
 
425
    g_variant_get (parameters, "(ii)", &x, &y);
 
426
    owner_->on_menu_pointer_moved.emit(x, y);
 
427
  }
 
428
  else if (signal_name == "EntryShowNowChanged")
 
429
  {
 
430
    gchar    *id = NULL;
 
431
    gboolean  show_now;
 
432
 
 
433
    g_variant_get (parameters, "(sb)", &id, &show_now);
 
434
    owner_->SetEntryShowNow(id, show_now);
 
435
 
 
436
    g_free (id);
 
437
  }
 
438
}
376
439
 
377
440
DBusIndicators::DBusIndicators()
378
441
  : pimpl(new Impl(this))
495
558
  return true;
496
559
}
497
560
 
498
 
void on_proxy_signal_received(GDBusProxy* proxy,
499
 
                              char* sender_name, char* signal_name_,
500
 
                              GVariant* parameters,
501
 
                              DBusIndicators::Impl* remote)
502
 
{
503
 
  std::string signal_name(signal_name_);
504
 
  if (signal_name == "EntryActivated")
505
 
  {
506
 
    const char* entry_name = g_variant_get_string(g_variant_get_child_value(parameters, 0), NULL);
507
 
    if (entry_name) {
508
 
      remote->owner_->ActivateEntry(entry_name);
509
 
    }
510
 
  }
511
 
  else if (signal_name == "EntryActivateRequest")
512
 
  {
513
 
    const char* entry_name = g_variant_get_string(g_variant_get_child_value(parameters, 0), NULL);
514
 
    if (entry_name) {
515
 
      remote->owner_->on_entry_activate_request.emit(entry_name);
516
 
    }
517
 
  }
518
 
  else if (signal_name == "ReSync")
519
 
  {
520
 
    const char* id = g_variant_get_string(g_variant_get_child_value(parameters, 0), NULL);
521
 
    bool sync_one = !g_strcmp0 (id, "") == 0;
522
 
 
523
 
    if (sync_one) {
524
 
      remote->RequestSyncIndicator(id);
525
 
    }
526
 
    else {
527
 
      remote->RequestSyncAll();
528
 
    }
529
 
  }
530
 
  else if (signal_name == "ActiveMenuPointerMotion")
531
 
  {
532
 
    int x = 0;
533
 
    int y = 0;
534
 
    g_variant_get (parameters, "(ii)", &x, &y);
535
 
    remote->owner_->on_menu_pointer_moved.emit(x, y);
536
 
  }
537
 
  else if (signal_name == "EntryShowNowChanged")
538
 
  {
539
 
    gchar    *id = NULL;
540
 
    gboolean  show_now;
541
 
 
542
 
    g_variant_get (parameters, "(sb)", &id, &show_now);
543
 
    remote->owner_->SetEntryShowNow(id, show_now);
544
 
 
545
 
    g_free (id);
546
 
  }
547
 
}
548
 
 
549
 
void on_proxy_name_owner_changed(GDBusProxy* proxy, GParamSpec* pspec,
550
 
                                 DBusIndicators::Impl* remote)
551
 
{
552
 
  char* name_owner = g_dbus_proxy_get_name_owner(proxy);
553
 
 
554
 
  if (name_owner == NULL)
555
 
  {
556
 
    // The panel service has stopped for some reason.  Restart it if not in
557
 
    // dev mode
558
 
    if (!g_getenv("UNITY_DEV_MODE"))
559
 
      remote->Reconnect();
560
 
  }
561
 
 
562
 
  g_free (name_owner);
563
 
}
564
 
 
565
561
void request_sync(GDBusProxy* proxy, const char* method, GVariant* name, SyncData* data)
566
562
{
567
563
  g_dbus_proxy_call(proxy, method, name, G_DBUS_CALL_FLAGS_NONE,