The Me Menu

Merge lp:~ken-vandine/indicator-me/libgwibber-port into lp:indicator-me

  1. libgwibber-port
  2. Merge into trunk
Proposed by Ken VanDine
Status: Merged
Approved by: David Barth
Approved revision: 105
Merge reported by: David Barth
Merged at revision: not available
Proposed branch: lp:~ken-vandine/indicator-me/libgwibber-port
Merge into: lp:indicator-me
Diff against target: 768 lines (+240/-352)
5 files modified
configure.ac (+2/-0)
src/entry-menu-item.c (+2/-2)
src/me-service-gwibber.c (+199/-302)
src/me-service-gwibber.h (+31/-32)
src/me-service.c (+6/-16)
To merge this branch: bzr merge lp:~ken-vandine/indicator-me/libgwibber-port
Reviewer Review Type Date Requested Status
David Barth Approve
Ken VanDine Needs Resubmitting
Review via email: mp+32775@code.launchpad.net

Description of the change

Port to libgwibber

To post a comment you must log in.
Revision history for this message
David Barth (dbarth) wrote :

Sounds good to me and works well on my test build. There are a few changes required though:

Line 343: the test for priv->send_enabled should probably be removed, ie toggling the boolean to true on each loop iteration; what matters is the end result

Line 350: the STATUS_RUNNING flag should be set in all cases, as a reply from gwibber implies that it is available for sending messages; the state name is a bit misleading though, it should be more about gwibber being "available" as a gateway service, but I chose running to make the distinction with the "availability" status of other online/chat services

Line 545: not sure about the void if (!exists), i don't think there is anything particular to do in this case either

Line 625: has_configured_accounts should return a positive value even if the service is temporarily down, ie a send would restart it anyway; i found it difficult to understand as a user that the entry is "sometimes" not there, for no apparent reason; it's better to have it always there, whatever the state of the service; the visibility criteria is only that gwibber is "configured".

review: Needs Fixing
lp:~ken-vandine/indicator-me/libgwibber-port updated
102. By Ken VanDine

remove a noop

103. By Ken VanDine

Don't set status to NOT_RUNNING if we get a response from gwibber

104. By Ken VanDine

Don't set status based on configured accounts

Revision history for this message
Ken VanDine (ken-vandine) wrote :

OK, I think I addressed all of those. It will no longer hide the entry if the service shuts down, but it does hide if you disable all the accounts.

review: Needs Resubmitting
lp:~ken-vandine/indicator-me/libgwibber-port updated
105. By Ken VanDine

check for send_enabled even if configured_accounts was TRUE before

Revision history for this message
David Barth (dbarth) wrote :

Thanks for the branch, I appreciate your help

review: Approve

Preview Diff

[H/L] Next/Prev Comment, [J/K] Next/Prev File, [N/P] Next/Prev Hunk
=== modified file 'configure.ac'
--- configure.ac 2010-03-24 09:42:26 +0000
+++ configure.ac 2010-08-17 14:44:43 +0000
@@ -28,6 +28,7 @@
2828
29GTK_REQUIRED_VERSION=2.1229GTK_REQUIRED_VERSION=2.12
30INDICATOR_REQUIRED_VERSION=0.3.030INDICATOR_REQUIRED_VERSION=0.3.0
31GWIBBER_REQUIRED_VERSION=0.0.4
31DBUSMENUGTK_REQUIRED_VERSION=0.2.232DBUSMENUGTK_REQUIRED_VERSION=0.2.2
32DBUSMENUGLIB_REQUIRED_VERSION=0.2.233DBUSMENUGLIB_REQUIRED_VERSION=0.2.2
33TELEPATHYGLIB_REQUIRED_VERSION=0.9.034TELEPATHYGLIB_REQUIRED_VERSION=0.9.0
@@ -41,6 +42,7 @@
41PKG_CHECK_MODULES(MESERVICE, dbusmenu-glib >= $DBUSMENUGLIB_REQUIRED_VERSION42PKG_CHECK_MODULES(MESERVICE, dbusmenu-glib >= $DBUSMENUGLIB_REQUIRED_VERSION
42 gconf-2.0 >= $GCONF_REQUIRED_VERSION43 gconf-2.0 >= $GCONF_REQUIRED_VERSION
43 indicator >= $INDICATOR_REQUIRED_VERSION44 indicator >= $INDICATOR_REQUIRED_VERSION
45 gwibber >= $GWIBBER_REQUIRED_VERSION
44 telepathy-glib >= $TELEPATHYGLIB_REQUIRED_VERSION)46 telepathy-glib >= $TELEPATHYGLIB_REQUIRED_VERSION)
4547
46###########################48###########################
4749
=== modified file 'src/entry-menu-item.c'
--- src/entry-menu-item.c 2010-03-17 16:19:44 +0000
+++ src/entry-menu-item.c 2010-08-17 14:44:43 +0000
@@ -128,8 +128,8 @@
128128
129 g_debug ("handle_event");129 g_debug ("handle_event");
130 if (g_strcmp0 (name, "send") == 0) {130 if (g_strcmp0 (name, "send") == 0) {
131 GwibberService *gwibber = gwibber_service_get ();131 MeGwibberService *me_gwibber_service = me_gwibber_service_get ();
132 gwibber_service_send (gwibber, g_value_get_string (value));132 me_gwibber_service_send (me_gwibber_service, g_value_get_string (value));
133 dbusmenu_menuitem_property_set (mi, ENTRY_MENUITEM_PROP_TEXT, "");133 dbusmenu_menuitem_property_set (mi, ENTRY_MENUITEM_PROP_TEXT, "");
134 }134 }
135135
136136
=== modified file 'src/me-service-gwibber.c'
--- src/me-service-gwibber.c 2010-03-24 09:38:22 +0000
+++ src/me-service-gwibber.c 2010-08-17 14:44:43 +0000
@@ -24,23 +24,14 @@
2424
25#include <glib.h>25#include <glib.h>
2626
27#include <dbus/dbus-glib.h>27#include <gwibber.h>
28#include <dbus/dbus-glib-bindings.h>
29
30#define DBUS_SERVICE_ADDRESS "com.Gwibber.Service"
31#define DBUS_SERVICE_SERVICE_OBJECT "/com/gwibber/Service"
32#define DBUS_SERVICE_SERVICE_INTERFACE "com.Gwibber.Service"
33
34#define DBUS_SERVICE_ACCOUNTS_OBJECT "/com/gwibber/Accounts"
35#define DBUS_SERVICE_ACCOUNTS_INTERFACE "com.Gwibber.Accounts"
3628
37/* gobject infrastructure */29/* gobject infrastructure */
3830
39typedef struct _GwibberServicePrivate GwibberServicePrivate;31typedef struct _MeGwibberServicePrivate MeGwibberServicePrivate;
40struct _GwibberServicePrivate {32struct _MeGwibberServicePrivate {
41 DBusGProxy * dbus_proxy;33 GwibberService * me_gwibber_service;
42 DBusGProxy * service_proxy;34 GwibberAccounts * me_gwibber_accounts;
43 DBusGProxy * accounts_proxy;
44 int status;35 int status;
45 gboolean has_configured_accounts;36 gboolean has_configured_accounts;
46};37};
@@ -54,35 +45,35 @@
54static guint signals[LAST_SIGNAL] = { 0 };45static guint signals[LAST_SIGNAL] = { 0 };
5546
56/* Prototypes */47/* Prototypes */
57static void gwibber_service_class_init (GwibberServiceClass *klass);48static void me_gwibber_service_class_init (MeGwibberServiceClass *klass);
58static void gwibber_service_init (GwibberService *self);49static void me_gwibber_service_init (MeGwibberService *self);
59static void gwibber_service_dispose (GObject *object);50static void me_gwibber_service_dispose (GObject *object);
60static void gwibber_service_finalize (GObject *object);51static void me_gwibber_service_finalize (GObject *object);
6152
62static void dbus_namechange (DBusGProxy * proxy, const gchar * name, const gchar * prev, const gchar * new, GwibberService * self);53static void me_gwibber_service_exists_cb (GwibberService * me_gwibber_service, gboolean exists, gpointer userdata);
63static void gwibber_exists_cb (DBusGProxy * proxy, gboolean exists, GError * error, gpointer userdata);54static void me_gwibber_accounts_exists_cb (GwibberAccounts * me_gwibber_accounts, gboolean exists, gpointer userdata);
64static void setup_service_proxies (GwibberService *self);55static void setup_service_proxies (MeGwibberService *self);
65static void query_account_manager (GwibberService *self);56static void query_account_manager (MeGwibberService *self);
6657
67G_DEFINE_TYPE (GwibberService, gwibber_service, G_TYPE_OBJECT);58G_DEFINE_TYPE (MeGwibberService, me_gwibber_service, G_TYPE_OBJECT);
6859
69#define GWIBBER_SERVICE_GET_PRIVATE(o) \60#define ME_GWIBBER_SERVICE_GET_PRIVATE(o) \
70(G_TYPE_INSTANCE_GET_PRIVATE ((o), GWIBBER_SERVICE_TYPE, GwibberServicePrivate))61(G_TYPE_INSTANCE_GET_PRIVATE ((o), ME_GWIBBER_SERVICE_TYPE, MeGwibberServicePrivate))
7162
72static void63static void
73gwibber_service_class_init (GwibberServiceClass *klass)64me_gwibber_service_class_init (MeGwibberServiceClass *klass)
74{65{
75 GObjectClass *object_class = G_OBJECT_CLASS (klass);66 GObjectClass *object_class = G_OBJECT_CLASS (klass);
7667
77 g_type_class_add_private (klass, sizeof (GwibberServicePrivate));68 g_type_class_add_private (klass, sizeof (MeGwibberServicePrivate));
7869
79 object_class->dispose = gwibber_service_dispose;70 object_class->dispose = me_gwibber_service_dispose;
80 object_class->finalize = gwibber_service_finalize;71 object_class->finalize = me_gwibber_service_finalize;
8172
82 signals[STATUS_CHANGED] = g_signal_new(GWIBBER_SERVICE_SIGNAL_STATUS_CHANGED,73 signals[STATUS_CHANGED] = g_signal_new(ME_GWIBBER_SERVICE_SIGNAL_STATUS_CHANGED,
83 G_TYPE_FROM_CLASS(klass),74 G_TYPE_FROM_CLASS(klass),
84 G_SIGNAL_RUN_LAST,75 G_SIGNAL_RUN_LAST,
85 G_STRUCT_OFFSET(GwibberServiceClass, status_changed),76 G_STRUCT_OFFSET(MeGwibberServiceClass, status_changed),
86 NULL, NULL,77 NULL, NULL,
87 g_cclosure_marshal_VOID__UINT,78 g_cclosure_marshal_VOID__UINT,
88 G_TYPE_NONE, 1, G_TYPE_UINT);79 G_TYPE_NONE, 1, G_TYPE_UINT);
@@ -90,316 +81,222 @@
90}81}
9182
92static void83static void
93gwibber_service_init (GwibberService *self)84me_gwibber_service_init (MeGwibberService *self)
94{85{
95 GwibberServicePrivate * priv = GWIBBER_SERVICE_GET_PRIVATE(self);86 MeGwibberServicePrivate * priv = ME_GWIBBER_SERVICE_GET_PRIVATE(self);
9687
97 priv->dbus_proxy = NULL;88 priv->me_gwibber_service = NULL;
98 priv->service_proxy = NULL;89 priv->me_gwibber_accounts = NULL;
99 priv->accounts_proxy = NULL;90 priv->status = ME_GWIBBER_SERVICE_STATUS_NOT_RUNNING;
100 priv->status = GWIBBER_SERVICE_STATUS_NOT_RUNNING;91 priv->has_configured_accounts = FALSE;
101 priv->has_configured_accounts = FALSE;92
10293 setup_service_proxies(self);
103 DBusGConnection * bus = dbus_g_bus_get(DBUS_BUS_SESSION, NULL);94 return;
104 g_return_if_fail(bus != NULL); /* Can't do anymore DBus stuff without this,95}
105 all non-DBus stuff should be done */96
10697static void
107 GError * error = NULL;98me_gwibber_service_dispose (GObject *object)
10899{
109 /* Set up the dbus Proxy */100 MeGwibberServicePrivate * priv = ME_GWIBBER_SERVICE_GET_PRIVATE(object);
110 priv->dbus_proxy = dbus_g_proxy_new_for_name_owner (bus,101
111 DBUS_SERVICE_DBUS,102 if (priv->me_gwibber_service != NULL) {
112 DBUS_PATH_DBUS,103 g_object_unref(priv->me_gwibber_service);
113 DBUS_INTERFACE_DBUS,104 priv->me_gwibber_service = NULL;
114 &error);105 }
115 if (error != NULL) {106
116 g_warning("Unable to connect to DBus events: %s", error->message);107 if (priv->me_gwibber_accounts != NULL) {
117 g_error_free(error);108 g_object_unref(priv->me_gwibber_accounts);
118 return;109 priv->me_gwibber_accounts = NULL;
119 }110 }
120111
121 /* Configure the name owner changing */112 G_OBJECT_CLASS (me_gwibber_service_parent_class)->dispose (object);
122 dbus_g_proxy_add_signal(priv->dbus_proxy, "NameOwnerChanged",113 return;
123 G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING,114}
124 G_TYPE_INVALID);115
125 dbus_g_proxy_connect_signal(priv->dbus_proxy, "NameOwnerChanged",116static void
126 G_CALLBACK(dbus_namechange),117me_gwibber_service_finalize (GObject *object)
127 self, NULL);118{
128119 G_OBJECT_CLASS (me_gwibber_service_parent_class)->finalize (object);
129 org_freedesktop_DBus_name_has_owner_async(priv->dbus_proxy, DBUS_SERVICE_ADDRESS, gwibber_exists_cb, self);120 return;
130121}
131 return;122
132}123static gboolean
133124check_account_send_enabled (GHashTable * account_table) {
134static void125 return g_value_get_boolean(g_hash_table_lookup(account_table, "send_enabled"));
135gwibber_service_dispose (GObject *object)126}
136{127
137 GwibberServicePrivate * priv = GWIBBER_SERVICE_GET_PRIVATE(object);128static void
138129query_account_manager (MeGwibberService *self)
139 if (priv->dbus_proxy != NULL) {130{
140 g_object_unref(priv->dbus_proxy);131 g_return_if_fail (IS_ME_GWIBBER_SERVICE (self));
141 priv->dbus_proxy = NULL;132
142 }133 gpointer accounts_table;
143134 gpointer account_table;
144 if (priv->service_proxy != NULL) {135 GHashTableIter accounts_iter;
145 g_object_unref(priv->service_proxy);136 gpointer account;
146 priv->service_proxy = NULL;137 gboolean send_enabled;
147 }138
148139 MeGwibberServicePrivate * priv = ME_GWIBBER_SERVICE_GET_PRIVATE(self);
149 if (priv->accounts_proxy != NULL) {140
150 g_object_unref(priv->accounts_proxy);141 if (priv->me_gwibber_accounts == NULL) {
151 priv->accounts_proxy = NULL;142 g_warning ("no accounts, can't query for accounts");
152 }143 return;
153144 }
154 G_OBJECT_CLASS (gwibber_service_parent_class)->dispose (object);145
155 return;146 accounts_table = gwibber_accounts_list (priv->me_gwibber_accounts);
156}147 if (accounts_table == NULL) {
157148 g_warning ("failed to get accounts list");
158static void149 return;
159gwibber_service_finalize (GObject *object)150 }
160{151
161 G_OBJECT_CLASS (gwibber_service_parent_class)->finalize (object);152 g_hash_table_iter_init (&accounts_iter, accounts_table);
162 return;153
163}154 priv->has_configured_accounts = FALSE;
164155
165156 while (g_hash_table_iter_next (&accounts_iter, &account, &account_table)) {
166/* Watch for Gwibber coming on and off the bus. */157 send_enabled = check_account_send_enabled (account_table);
167static void158 if (send_enabled) {
168dbus_namechange (DBusGProxy * proxy, const gchar * name, const gchar * prev, const gchar * new, GwibberService * self)159 priv->has_configured_accounts = TRUE;
169{160 }
170 g_return_if_fail (IS_GWIBBER_SERVICE (self));161 }
171162
172 GwibberServicePrivate * priv = GWIBBER_SERVICE_GET_PRIVATE(self);163 g_signal_emit (G_OBJECT (self),
173164 ME_GWIBBER_SERVICE_SIGNAL_STATUS_CHANGED_ID,
174 if (prev[0] == '\0' && g_strcmp0(name, DBUS_SERVICE_ADDRESS) == 0) {
175 g_debug("Gwibber Service coming online");
176 priv->status = GWIBBER_SERVICE_STATUS_RUNNING;
177 if (priv->service_proxy == NULL ||
178 priv->accounts_proxy == NULL)
179 setup_service_proxies (self);
180 query_account_manager (self);
181 }
182
183 if (new[0] == '\0' && g_strcmp0(name, DBUS_SERVICE_ADDRESS) == 0) {
184 g_debug("Gwibber Service going offline");
185 priv->status = GWIBBER_SERVICE_STATUS_NOT_RUNNING;
186 g_signal_emit (G_OBJECT (self), GWIBBER_SERVICE_SIGNAL_STATUS_CHANGED_ID, 0, priv->status, TRUE);
187 if (priv->service_proxy != NULL) {
188 g_object_unref(priv->service_proxy);
189 priv->service_proxy = NULL;
190 }
191 if (priv->accounts_proxy != NULL) {
192 g_object_unref(priv->accounts_proxy);
193 priv->accounts_proxy = NULL;
194 }
195 }
196
197 return;
198}
199
200static void
201get_accounts_response (DBusGProxy * proxy, DBusGProxyCall * call, gpointer data)
202{
203 GError *error = NULL;
204 gchar *accounts_string = NULL;
205
206 dbus_g_proxy_end_call (proxy, call, &error,
207 G_TYPE_STRING, &accounts_string,
208 G_TYPE_INVALID);
209
210 if (error != NULL) {
211 g_warning ("GetAccounts: %s", error->message);
212 g_error_free (error);
213 g_free (accounts_string);
214 return;
215 }
216
217 /* don't print the accounts string, it contains passwords */
218 /* g_debug ("GetAccounts: %s", accounts_string); */
219
220 g_return_if_fail (IS_GWIBBER_SERVICE (data));
221 GwibberServicePrivate * priv = GWIBBER_SERVICE_GET_PRIVATE(data);
222 g_return_if_fail (priv != NULL);
223 /* Note: not free'ing accounts_string here, but g_return_if_fail are
224 meant to catch design errors, not runtime ones */
225
226 priv->status = GWIBBER_SERVICE_STATUS_RUNNING;
227 priv->has_configured_accounts = g_strrstr (accounts_string, " \"send_enabled\": true,") ? TRUE : FALSE;
228
229 /* trigger a status update */
230 g_signal_emit (G_OBJECT (data),
231 GWIBBER_SERVICE_SIGNAL_STATUS_CHANGED_ID,
232 0, priv->status, TRUE);165 0, priv->status, TRUE);
233166
234 g_free (accounts_string);167 g_hash_table_destroy(accounts_table);
235
236 return;168 return;
237}169}
238170
239static void171static void
240query_account_manager (GwibberService *self)172accounts_changed (GwibberAccounts *me_gwibber_accounts, GHashTable *account_table, MeGwibberService *self)
241{173{
242 g_return_if_fail (IS_GWIBBER_SERVICE (self));174 g_return_if_fail (IS_ME_GWIBBER_SERVICE (self));
243
244 GwibberServicePrivate * priv = GWIBBER_SERVICE_GET_PRIVATE(self);
245
246 if (priv->service_proxy == NULL) {
247 g_warning ("no service_proxy, can't query for accounts");
248 return;
249 }
250
251 dbus_g_proxy_begin_call(priv->service_proxy,
252 "GetAccounts",
253 get_accounts_response,
254 self,
255 NULL,
256 G_TYPE_INVALID);
257}
258
259static void
260accounts_changed (DBusGProxy *proxy, const gchar *id, GwibberService *self)
261{
262 g_return_if_fail (IS_GWIBBER_SERVICE (self));
263
264 g_debug ("accounts_changed");
265175
266 query_account_manager (self);176 query_account_manager (self);
267177
268 return;178 return;
269}179}
270180
271static void181
272setup_service_proxies (GwibberService *self)182static void
273{183setup_service_proxies (MeGwibberService *self)
274 g_return_if_fail (IS_GWIBBER_SERVICE (self));184{
275185 g_return_if_fail (IS_ME_GWIBBER_SERVICE (self));
276 GwibberServicePrivate * priv = GWIBBER_SERVICE_GET_PRIVATE(self);186
277187 MeGwibberServicePrivate * priv = ME_GWIBBER_SERVICE_GET_PRIVATE(self);
278 DBusGConnection * bus = dbus_g_bus_get(DBUS_BUS_SESSION, NULL);188
279 g_return_if_fail(bus != NULL); /* Can't do anymore DBus stuff without this,189 if (priv->me_gwibber_service == NULL) {
280 all non-DBus stuff should be done */190 priv->me_gwibber_service = gwibber_service_new ();
281191 if (priv->me_gwibber_service == NULL) {
282 if (priv->service_proxy == NULL) {192 g_warning ("can't setup me_gwibber_service");
283 priv->service_proxy = dbus_g_proxy_new_for_name(193 return;
284 bus,194 }
285 DBUS_SERVICE_ADDRESS,195 }
286 DBUS_SERVICE_SERVICE_OBJECT,196
287 DBUS_SERVICE_SERVICE_INTERFACE);197 g_signal_connect (priv->me_gwibber_service, "is-available",
288 if (priv->service_proxy == NULL) {198 G_CALLBACK(me_gwibber_service_exists_cb), ME_GWIBBER_SERVICE (self));
289 g_warning ("can't setup service_proxy");199
290 return;200 if (priv->me_gwibber_accounts == NULL) {
291 }201 priv->me_gwibber_accounts = gwibber_accounts_new ();;
292 }202 if (priv->me_gwibber_accounts == NULL) {
293203 g_warning ("can't setup me_gwibber_accounts");
294 if (priv->accounts_proxy == NULL) {204 return;
295 priv->accounts_proxy =205 }
296 dbus_g_proxy_new_for_name(bus,206 }
297 DBUS_SERVICE_ADDRESS,207
298 DBUS_SERVICE_ACCOUNTS_OBJECT,208 g_signal_connect (priv->me_gwibber_accounts, "is-available",
299 DBUS_SERVICE_ACCOUNTS_INTERFACE);209 G_CALLBACK(me_gwibber_accounts_exists_cb), ME_GWIBBER_SERVICE (self));
300 if (priv->accounts_proxy == NULL) {210}
301 g_warning ("can't setup accounts_proxy");211
302 return;212static void
303 }213me_gwibber_service_exists_cb (GwibberService * me_gwibber_service, gboolean exists, gpointer userdata)
304 }214{
305215 MeGwibberServicePrivate * priv = ME_GWIBBER_SERVICE_GET_PRIVATE(ME_GWIBBER_SERVICE (userdata));
306 /* Monitor signals about account changes */216
307 dbus_g_proxy_add_signal(priv->accounts_proxy, "AccountChanged",217 if (exists) {
308 G_TYPE_STRING,218 priv->status = ME_GWIBBER_SERVICE_STATUS_RUNNING;
309 G_TYPE_INVALID);219 }
310 dbus_g_proxy_connect_signal(priv->accounts_proxy, "AccountChanged",220
311 G_CALLBACK(accounts_changed),221
312 self, NULL);222 if (!exists) {
313 dbus_g_proxy_add_signal(priv->accounts_proxy, "AccountDeleted",223 priv->status = ME_GWIBBER_SERVICE_STATUS_NOT_RUNNING;
314 G_TYPE_STRING,224 g_signal_emit (G_OBJECT (ME_GWIBBER_SERVICE (userdata)), ME_GWIBBER_SERVICE_SIGNAL_STATUS_CHANGED_ID, 0, priv->status, TRUE);
315 G_TYPE_INVALID);225 }
316 dbus_g_proxy_connect_signal(priv->accounts_proxy, "AccountDeleted",226 return;
317 G_CALLBACK(accounts_changed),227}
318 self, NULL);228
319229static void
320}230me_gwibber_accounts_exists_cb (GwibberAccounts * me_gwibber_accounts, gboolean exists, gpointer userdata)
321231{
322static void232 MeGwibberServicePrivate * priv = ME_GWIBBER_SERVICE_GET_PRIVATE(ME_GWIBBER_SERVICE (userdata));
323gwibber_exists_cb (DBusGProxy * proxy, gboolean exists, GError * error, gpointer userdata)233
324{234 if (exists) {
325 if (error) {235 if (priv->me_gwibber_accounts == NULL) {
326 g_warning ("Unable to check if Gwibber is running: %s", error->message);236 priv->me_gwibber_accounts = gwibber_accounts_new ();;
327 return;237 if (priv->me_gwibber_accounts == NULL) {
328 }238 g_warning ("can't setup me_gwibber_accounts");
329239 return;
330 if (exists) {240 }
331 setup_service_proxies (GWIBBER_SERVICE (userdata));241 }
332 query_account_manager (GWIBBER_SERVICE (userdata));242
333 }243 query_account_manager (ME_GWIBBER_SERVICE (userdata));
334244 g_signal_emit (G_OBJECT (ME_GWIBBER_SERVICE (userdata)), ME_GWIBBER_SERVICE_SIGNAL_STATUS_CHANGED_ID, 0, priv->status, TRUE);
335 return;245 g_signal_connect (priv->me_gwibber_accounts, "account-updated",
336}246 G_CALLBACK(accounts_changed), ME_GWIBBER_SERVICE (userdata));
337247 }
338GwibberService * gwibber_service_new (void){248 return;
339 return GWIBBER_SERVICE (g_object_new (GWIBBER_SERVICE_TYPE, NULL));249}
340}250
341251
342static void252MeGwibberService * me_gwibber_service_new (void){
343send_message_response (DBusGProxy * proxy, DBusGProxyCall * call, gpointer data)253 return ME_GWIBBER_SERVICE (g_object_new (ME_GWIBBER_SERVICE_TYPE, NULL));
344{
345 g_debug ("send_message_response");
346
347 return;
348}254}
349255
350void256void
351gwibber_service_send (GwibberService *self, const gchar *msg)257me_gwibber_service_send (MeGwibberService *self, const gchar *msg)
352{258{
353 g_return_if_fail (IS_GWIBBER_SERVICE (self));259 g_return_if_fail (IS_ME_GWIBBER_SERVICE (self));
354260
355 GwibberServicePrivate * priv = GWIBBER_SERVICE_GET_PRIVATE(self);261 MeGwibberServicePrivate * priv = ME_GWIBBER_SERVICE_GET_PRIVATE(self);
356262
357 GValue value = {0};263 GValue value = {0};
358 g_value_init(&value, G_TYPE_STRING);264 g_value_init(&value, G_TYPE_STRING);
359 g_value_set_string(&value, msg);265 g_value_set_string(&value, msg);
360266
361 g_debug ("gwibber_send: %s\n", msg);267 if (priv->me_gwibber_service == NULL) {
362
363 if (priv->service_proxy == NULL) {
364 setup_service_proxies (self);268 setup_service_proxies (self);
365 if (priv->service_proxy == NULL) {269 if (priv->me_gwibber_service == NULL) {
366 g_warning ("can't setup service_proxy");270 g_warning ("can't setup me_gwibber_service");
367 return;271 return;
368 }272 }
369 }273 }
370274
371 dbus_g_proxy_begin_call(priv->service_proxy,275 gwibber_service_send_message (priv->me_gwibber_service, g_value_get_string (&value));
372 "SendMessage",
373 send_message_response,
374 NULL,
375 NULL,
376 G_TYPE_VALUE,
377 &value,
378 G_TYPE_INVALID);
379276
380 g_value_unset(&value);277 g_value_unset(&value);
381278
382 return;279 return;
383}280}
384281
385GwibberService *282MeGwibberService *
386gwibber_service_get (void)283me_gwibber_service_get (void)
387{284{
388 static GwibberService *singleton = NULL;285 static MeGwibberService *singleton = NULL;
389286
390 if (! singleton) {287 if (! singleton) {
391 singleton = gwibber_service_new ();288 singleton = me_gwibber_service_new ();
392 } 289 }
393290
394 return singleton;291 return singleton;
395}292}
396293
397gboolean294gboolean
398gwibber_service_has_configured_accounts (GwibberService *self)295me_gwibber_service_has_configured_accounts (MeGwibberService *self)
399{296{
400 g_return_val_if_fail (IS_GWIBBER_SERVICE (self), FALSE);297 g_return_val_if_fail (IS_ME_GWIBBER_SERVICE (self), FALSE);
401298
402 GwibberServicePrivate * priv = GWIBBER_SERVICE_GET_PRIVATE(self);299 MeGwibberServicePrivate * priv = ME_GWIBBER_SERVICE_GET_PRIVATE(self);
403300
404 return priv->has_configured_accounts;301 return priv->has_configured_accounts;
405}302}
406303
=== modified file 'src/me-service-gwibber.h'
--- src/me-service-gwibber.h 2010-03-17 16:19:44 +0000
+++ src/me-service-gwibber.h 2010-08-17 14:44:43 +0000
@@ -20,57 +20,56 @@
20with this program. If not, see <http://www.gnu.org/licenses/>.20with this program. If not, see <http://www.gnu.org/licenses/>.
21*/21*/
2222
23#ifndef __GWIBBER_SERVICE_H__23#ifndef __ME_GWIBBER_SERVICE_H__
24#define __GWIBBER_SERVICE_H__24#define __ME_GWIBBER_SERVICE_H__
2525
26#include <glib.h>26#include <glib.h>
27#include <glib-object.h>27#include <glib-object.h>
2828
29#include <gwibber.h>
30
29G_BEGIN_DECLS31G_BEGIN_DECLS
3032
31#define GWIBBER_SERVICE_TYPE (gwibber_service_get_type ())33#define ME_GWIBBER_SERVICE_TYPE (me_gwibber_service_get_type ())
32#define GWIBBER_SERVICE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GWIBBER_SERVICE_TYPE, GwibberService))34#define ME_GWIBBER_SERVICE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), ME_GWIBBER_SERVICE_TYPE, MeGwibberService))
33#define GWIBBER_SERVICE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GWIBBER_SERVICE_TYPE, GwibberServiceClass))35#define ME_GWIBBER_SERVICE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), ME_GWIBBER_SERVICE_TYPE, MeGwibberServiceClass))
34#define IS_GWIBBER_SERVICE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GWIBBER_SERVICE_TYPE))36#define IS_ME_GWIBBER_SERVICE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), ME_GWIBBER_SERVICE_TYPE))
35#define IS_GWIBBER_SERVICE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GWIBBER_SERVICE_TYPE))37#define IS_ME_GWIBBER_SERVICE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), ME_GWIBBER_SERVICE_TYPE))
36#define GWIBBER_SERVICE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GWIBBER_SERVICE_TYPE, GwibberServiceClass))38#define ME_GWIBBER_SERVICE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), ME_GWIBBER_SERVICE_TYPE, MeGwibberServiceClass))
3739
38typedef enum40typedef enum
39{41{
40 GWIBBER_SERVICE_STATUS_NOT_RUNNING,42 ME_GWIBBER_SERVICE_STATUS_NOT_RUNNING,
41 /* GWIBBER_SERVICE_STATUS_LOADING_STARTED,43 /* ME_GWIBBER_SERVICE_STATUS_LOADING_STARTED,
42 GWIBBER_SERVICE_STATUS_LOADING_COMPLETE, */44 ME_GWIBBER_SERVICE_STATUS_LOADING_COMPLETE, */
43 GWIBBER_SERVICE_STATUS_RUNNING,45 ME_GWIBBER_SERVICE_STATUS_RUNNING,
44 GWIBBER_SERVICE_STATUS_LAST46 ME_GWIBBER_SERVICE_STATUS_LAST
45}47}
46GwibberServiceStatus;48MeGwibberServiceStatus;
4749
48#define GWIBBER_SERVICE_SIGNAL_STATUS_CHANGED "status-changed"50#define ME_GWIBBER_SERVICE_SIGNAL_STATUS_CHANGED "status-changed"
49#define GWIBBER_SERVICE_SIGNAL_STATUS_CHANGED_ID (g_signal_lookup(GWIBBER_SERVICE_SIGNAL_STATUS_CHANGED, GWIBBER_SERVICE_TYPE))51#define ME_GWIBBER_SERVICE_SIGNAL_STATUS_CHANGED_ID (g_signal_lookup(ME_GWIBBER_SERVICE_SIGNAL_STATUS_CHANGED, ME_GWIBBER_SERVICE_TYPE))
5052
51typedef struct _GwibberServiceClass GwibberServiceClass;53typedef struct _MeGwibberServiceClass MeGwibberServiceClass;
52struct _GwibberServiceClass {54struct _MeGwibberServiceClass {
53 GObjectClass parent_class;55 GObjectClass parent_class;
5456
55 /* Signals */57 /* Signals */
56 void (*status_changed) (GwibberServiceStatus newstatus);58 void (*status_changed) (MeGwibberServiceStatus newstatus);
57};59};
5860
59typedef struct _GwibberService GwibberService;61typedef struct _MeGwibberService MeGwibberService;
60struct _GwibberService {62struct _MeGwibberService {
61 GObject parent;63 GObject parent;
62};64};
6365
64GType gwibber_service_get_type (void) G_GNUC_CONST;66GType me_gwibber_service_get_type (void) G_GNUC_CONST;
65GwibberService * gwibber_service_new (void);67MeGwibberService * me_gwibber_service_new (void);
66GwibberService * gwibber_service_get (void);68MeGwibberService * me_gwibber_service_get (void);
67void gwibber_service_send (GwibberService *self, const gchar *msg);69void me_gwibber_service_send (MeGwibberService *self, const gchar *msg);
68gboolean gwibber_service_has_configured_accounts (GwibberService *self);70gboolean me_gwibber_service_has_configured_accounts (MeGwibberService *self);
69
70/* old API */
71void gwibber_send (const gchar *msg);
7271
73G_END_DECLS72G_END_DECLS
7473
75#endif /* __GWIBBER_SERVICE_H__ */74#endif /* __ME_GWIBBER_SERVICE_H__ */
7675
7776
=== modified file 'src/me-service.c'
--- src/me-service.c 2010-03-25 20:25:31 +0000
+++ src/me-service.c 2010-08-17 14:44:43 +0000
@@ -81,7 +81,7 @@
81 /* STATUS_PROVIDER_STATUS_DISCONNECTED */"user-offline"81 /* STATUS_PROVIDER_STATUS_DISCONNECTED */"user-offline"
82};82};
8383
84static GwibberService * gwibber = NULL;84static MeGwibberService * me_gwibber_service = NULL;
8585
86static DbusmenuMenuitem * root_menuitem = NULL;86static DbusmenuMenuitem * root_menuitem = NULL;
87static DbusmenuMenuitem * status_menuitems[STATUS_PROVIDER_STATUS_LAST] = {0};87static DbusmenuMenuitem * status_menuitems[STATUS_PROVIDER_STATUS_LAST] = {0};
@@ -170,7 +170,7 @@
170}170}
171171
172static void172static void
173gwibber_status_update (GwibberService *instance, GwibberServiceStatus status, gpointer data) {173me_gwibber_status_update (MeGwibberService *instance, MeGwibberServiceStatus status, gpointer data) {
174 g_return_if_fail (instance != NULL);174 g_return_if_fail (instance != NULL);
175175
176 g_debug ("gwibber service status changed to: %d", status);176 g_debug ("gwibber service status changed to: %d", status);
@@ -180,7 +180,7 @@
180 return;180 return;
181 }181 }
182182
183 if (! gwibber_service_has_configured_accounts (instance)) {183 if (! me_gwibber_service_has_configured_accounts (instance)) {
184 g_debug ("no configured accounts detected, so hiding the broadcast field");184 g_debug ("no configured accounts detected, so hiding the broadcast field");
185 dbusmenu_menuitem_property_set_bool (broadcast_field, DBUSMENU_MENUITEM_PROP_VISIBLE, FALSE);185 dbusmenu_menuitem_property_set_bool (broadcast_field, DBUSMENU_MENUITEM_PROP_VISIBLE, FALSE);
186 return;186 return;
@@ -189,16 +189,6 @@
189 if (! dbusmenu_menuitem_property_get_bool (broadcast_field, DBUSMENU_MENUITEM_PROP_VISIBLE))189 if (! dbusmenu_menuitem_property_get_bool (broadcast_field, DBUSMENU_MENUITEM_PROP_VISIBLE))
190 dbusmenu_menuitem_property_set_bool (broadcast_field, DBUSMENU_MENUITEM_PROP_VISIBLE, TRUE);190 dbusmenu_menuitem_property_set_bool (broadcast_field, DBUSMENU_MENUITEM_PROP_VISIBLE, TRUE);
191191
192#if 0
193 if (status == GWIBBER_SERVICE_STATUS_RUNNING) {
194 g_debug ("enabling the broadcast field");
195 dbusmenu_menuitem_property_set_bool (broadcast_field, DBUSMENU_MENUITEM_PROP_ENABLED, TRUE);
196 } else {
197 g_debug ("disabling the broadcast field");
198 dbusmenu_menuitem_property_set_bool (broadcast_field, DBUSMENU_MENUITEM_PROP_ENABLED, FALSE);
199 }
200#endif
201
202 return;192 return;
203}193}
204194
@@ -287,9 +277,9 @@
287277
288 status_update();278 status_update();
289279
290 gwibber = gwibber_service_new ();280 me_gwibber_service = me_gwibber_service_get ();
291 if (gwibber != NULL) {281 if (me_gwibber_service != NULL) {
292 g_signal_connect (G_OBJECT (gwibber), GWIBBER_SERVICE_SIGNAL_STATUS_CHANGED, G_CALLBACK (gwibber_status_update), NULL);282 g_signal_connect (G_OBJECT (me_gwibber_service), ME_GWIBBER_SERVICE_SIGNAL_STATUS_CHANGED, G_CALLBACK (me_gwibber_status_update), NULL);
293 }283 }
294284
295 return FALSE;285 return FALSE;

Subscribers

People subscribed via source and target branches