Mercurial > pidgin3 / file comparison

comparison: pidgin/plugins/unity.c

pidgin/plugins/unity.c

branch
release-2.x.y
changeset 35122
30af0986aa62
child 35124
7ea89f3b3b58
equal deleted inserted replaced
35121:7544a0882efd 35122:30af0986aa62
1 /*
2 * Integration with Unity's messaging menu and launcher
3 * Copyright (C) 2013 Ankit Vani <a@nevitus.org>
4 *
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License as published by
7 * the Free Software Foundation; either version 2 of the License, or
8 * (at your option) any later version.
9 *
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
14 *
15 * You should have received a copy of the GNU General Public License
16 * along with this program; if not, write to the Free Software
17 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA
18 */
19 #include "internal.h"
20 #include "version.h"
21 #include "account.h"
22 #include "savedstatuses.h"
23
24 #include "gtkplugin.h"
25 #include "gtkconv.h"
26 #include "gtkutils.h"
27
28 #include <unity.h>
29 #include <messaging-menu.h>
30
31 #define UNITY_PLUGIN_ID "gtk-unity-integration"
32
33 static MessagingMenuApp *mmapp = NULL;
34 static UnityLauncherEntry *launcher = NULL;
35 static guint n_sources = 0;
36 static gint launcher_count;
37 static gint messaging_menu_text;
38 static gboolean alert_chat_nick = TRUE;
39
40 enum {
41 LAUNCHER_COUNT_DISABLE,
42 LAUNCHER_COUNT_MESSAGES,
43 LAUNCHER_COUNT_SOURCES,
44 };
45
46 enum {
47 MESSAGING_MENU_COUNT,
48 MESSAGING_MENU_TIME,
49 };
50
51 static int attach_signals(PurpleConversation *conv);
52 static void detach_signals(PurpleConversation *conv);
53
54 static void
55 update_launcher()
56 {
57 guint count = 0;
58 GList *convs = NULL;
59 g_return_if_fail(launcher != NULL && launcher_count != LAUNCHER_COUNT_DISABLE);
60
61 if (launcher_count == LAUNCHER_COUNT_MESSAGES) {
62 for (convs = purple_get_conversations(); convs != NULL; convs = convs->next) {
63 PurpleConversation *conv = convs->data;
64 count += GPOINTER_TO_INT(purple_conversation_get_data(conv,
65 "unity-message-count"));
66 }
67 } else {
68 count = n_sources;
69 }
70
71 if (launcher != NULL) {
72 if (count > 0)
73 unity_launcher_entry_set_count_visible(launcher, TRUE);
74 else
75 unity_launcher_entry_set_count_visible(launcher, FALSE);
76 unity_launcher_entry_set_count(launcher, count);
77 }
78 }
79
80 static gchar *
81 conversation_id(PurpleConversation *conv)
82 {
83 PurpleConversationType conv_type = purple_conversation_get_type(conv);
84 PurpleAccount *account = purple_conversation_get_account(conv);
85 char type[2] = "0";
86 type[0] += conv_type;
87
88 return g_strconcat(type, ":",
89 purple_conversation_get_name(conv), ":",
90 purple_account_get_username(account), ":",
91 purple_account_get_protocol_id(account), NULL);
92 }
93
94 static void
95 messaging_menu_add_conversation(PurpleConversation *conv, gint count)
96 {
97 gchar *id;
98 g_return_if_fail(count > 0);
99 id = conversation_id(conv);
100
101 /* GBytesIcon may be useful for messaging menu source icons using buddy
102 icon data for IMs */
103 if (!messaging_menu_app_has_source(mmapp, id))
104 messaging_menu_app_append_source(mmapp, id, NULL,
105 purple_conversation_get_title(conv));
106
107 if (messaging_menu_text == MESSAGING_MENU_TIME)
108 messaging_menu_app_set_source_time(mmapp, id, g_get_real_time());
109 else if (messaging_menu_text == MESSAGING_MENU_COUNT)
110 messaging_menu_app_set_source_count(mmapp, id, count);
111 messaging_menu_app_draw_attention(mmapp, id);
112
113 g_free(id);
114 }
115
116 static void
117 messaging_menu_remove_conversation(PurpleConversation *conv)
118 {
119 gchar *id = conversation_id(conv);
120 if (messaging_menu_app_has_source(mmapp, id))
121 messaging_menu_app_remove_source(mmapp, id);
122 g_free(id);
123 }
124
125 static void
126 refill_messaging_menu()
127 {
128 GList *convs;
129
130 for (convs = purple_get_conversations(); convs != NULL; convs = convs->next) {
131 PurpleConversation *conv = convs->data;
132 messaging_menu_add_conversation(conv,
133 GPOINTER_TO_INT(purple_conversation_get_data(conv, "unity-message-count")));
134 }
135 }
136
137 static int
138 alert(PurpleConversation *conv)
139 {
140 gint count;
141 PidginWindow *purplewin = NULL;
142 if (conv == NULL || PIDGIN_CONVERSATION(conv) == NULL)
143 return 0;
144
145 purplewin = PIDGIN_CONVERSATION(conv)->win;
146
147 if (!pidgin_conv_window_has_focus(purplewin) ||
148 !pidgin_conv_window_is_active_conversation(conv))
149 {
150 count = GPOINTER_TO_INT(purple_conversation_get_data(conv,
151 "unity-message-count"));
152 if (!count++)
153 ++n_sources;
154
155 purple_conversation_set_data(conv, "unity-message-count",
156 GINT_TO_POINTER(count));
157 messaging_menu_add_conversation(conv, count);
158 update_launcher();
159 }
160
161 return 0;
162 }
163
164 static void
165 unalert(PurpleConversation *conv)
166 {
167 if (GPOINTER_TO_INT(purple_conversation_get_data(conv, "unity-message-count")) > 0)
168 --n_sources;
169 purple_conversation_set_data(conv, "unity-message-count",
170 GINT_TO_POINTER(0));
171 messaging_menu_remove_conversation(conv);
172 update_launcher();
173 }
174
175 static int
176 unalert_cb(GtkWidget *widget, gpointer data, PurpleConversation *conv)
177 {
178 unalert(conv);
179 return 0;
180 }
181
182 static gboolean
183 message_displayed_cb(PurpleAccount *account, const char *who, char *message,
184 PurpleConversation *conv, PurpleMessageFlags flags)
185 {
186 if ((purple_conversation_get_type(conv) == PURPLE_CONV_TYPE_CHAT &&
187 alert_chat_nick && !(flags & PURPLE_MESSAGE_NICK)))
188 return FALSE;
189
190 if ((flags & PURPLE_MESSAGE_RECV) && !(flags & PURPLE_MESSAGE_DELAYED))
191 alert(conv);
192
193 return FALSE;
194 }
195
196 static void
197 im_sent_im(PurpleAccount *account, const char *receiver, const char *message)
198 {
199 PurpleConversation *conv = NULL;
200 conv = purple_find_conversation_with_account(PURPLE_CONV_TYPE_IM, receiver,
201 account);
202 unalert(conv);
203 }
204
205 static void
206 chat_sent_im(PurpleAccount *account, const char *message, int id)
207 {
208 PurpleConversation *conv = NULL;
209 conv = purple_find_chat(purple_account_get_connection(account), id);
210 unalert(conv);
211 }
212
213 static void
214 conv_created(PurpleConversation *conv)
215 {
216 purple_conversation_set_data(conv, "unity-message-count",
217 GINT_TO_POINTER(0));
218 attach_signals(conv);
219 }
220
221 static void
222 deleting_conv(PurpleConversation *conv)
223 {
224 detach_signals(conv);
225 unalert(conv);
226 }
227
228 static void
229 message_source_activated(MessagingMenuApp *app, const gchar *id,
230 gpointer user_data)
231 {
232 gchar **sections = g_strsplit(id, ":", 0);
233 PurpleConversation *conv = NULL;
234 PurpleAccount *account;
235 PidginWindow *purplewin = NULL;
236 PurpleConversationType conv_type;
237
238 char *type = sections[0];
239 char *cname = sections[1];
240 char *aname = sections[2];
241 char *protocol = sections[3];
242
243 conv_type = type[0] - '0';
244 account = purple_accounts_find(aname, protocol);
245 conv = purple_find_conversation_with_account(conv_type, cname, account);
246
247 if (conv) {
248 unalert(conv);
249 purplewin = PIDGIN_CONVERSATION(conv)->win;
250 pidgin_conv_window_switch_gtkconv(purplewin, PIDGIN_CONVERSATION(conv));
251 gdk_window_focus(gtk_widget_get_window(purplewin->window), time(NULL));
252 }
253 g_strfreev (sections);
254 }
255
256 static PurpleSavedStatus *
257 create_transient_status(PurpleStatusPrimitive primitive, PurpleStatusType *status_type)
258 {
259 PurpleSavedStatus *saved_status = purple_savedstatus_new(NULL, primitive);
260
261 if(status_type != NULL) {
262 GList *tmp, *active_accts = purple_accounts_get_all_active();
263 for (tmp = active_accts; tmp != NULL; tmp = tmp->next) {
264 purple_savedstatus_set_substatus(saved_status,
265 (PurpleAccount*) tmp->data, status_type, NULL);
266 }
267 g_list_free(active_accts);
268 }
269
270 return saved_status;
271 }
272
273 static void
274 status_changed_cb(PurpleSavedStatus *saved_status)
275 {
276 MessagingMenuStatus status = MESSAGING_MENU_STATUS_AVAILABLE;
277
278 switch (purple_savedstatus_get_type(saved_status)) {
279 case PURPLE_STATUS_AVAILABLE:
280 case PURPLE_STATUS_MOOD:
281 case PURPLE_STATUS_TUNE:
282 case PURPLE_STATUS_UNSET:
283 status = MESSAGING_MENU_STATUS_AVAILABLE;
284 break;
285
286 case PURPLE_STATUS_AWAY:
287 case PURPLE_STATUS_EXTENDED_AWAY:
288 status = MESSAGING_MENU_STATUS_AWAY;
289 break;
290
291 case PURPLE_STATUS_INVISIBLE:
292 status = MESSAGING_MENU_STATUS_INVISIBLE;
293 break;
294
295 case PURPLE_STATUS_MOBILE:
296 case PURPLE_STATUS_OFFLINE:
297 status = MESSAGING_MENU_STATUS_OFFLINE;
298 break;
299
300 case PURPLE_STATUS_UNAVAILABLE:
301 status = MESSAGING_MENU_STATUS_BUSY;
302 break;
303
304 default:
305 g_assert_not_reached();
306 }
307 messaging_menu_app_set_status(mmapp, status);
308 }
309
310 static void
311 messaging_menu_status_changed(MessagingMenuApp *mmapp,
312 MessagingMenuStatus mm_status, gpointer user_data)
313 {
314 PurpleSavedStatus *saved_status;
315 PurpleStatusPrimitive primitive = PURPLE_STATUS_UNSET;
316
317 switch (mm_status) {
318 case MESSAGING_MENU_STATUS_AVAILABLE:
319 primitive = PURPLE_STATUS_AVAILABLE;
320 break;
321
322 case MESSAGING_MENU_STATUS_AWAY:
323 primitive = PURPLE_STATUS_AWAY;
324 break;
325
326 case MESSAGING_MENU_STATUS_BUSY:
327 primitive = PURPLE_STATUS_UNAVAILABLE;
328 break;
329
330 case MESSAGING_MENU_STATUS_INVISIBLE:
331 primitive = PURPLE_STATUS_INVISIBLE;
332 break;
333
334 case MESSAGING_MENU_STATUS_OFFLINE:
335 primitive = PURPLE_STATUS_OFFLINE;
336 break;
337
338 default:
339 g_assert_not_reached();
340 }
341
342 saved_status = purple_savedstatus_find_transient_by_type_and_message(primitive, NULL);
343 if (saved_status == NULL)
344 saved_status = create_transient_status(primitive, NULL);
345 purple_savedstatus_activate(saved_status);
346 }
347
348 static void
349 alert_config_cb(GtkWidget *widget, gpointer data)
350 {
351 gboolean on = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget));
352 purple_prefs_set_bool("/plugins/gtk/unity/alert_chat_nick", on);
353 alert_chat_nick = on;
354 }
355
356 static void
357 launcher_config_cb(GtkWidget *widget, gpointer data)
358 {
359 gint option = GPOINTER_TO_INT(data);
360 g_return_if_fail(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget)));
361
362 purple_prefs_set_int("/plugins/gtk/unity/launcher_count", option);
363 launcher_count = option;
364 if (option == LAUNCHER_COUNT_DISABLE)
365 unity_launcher_entry_set_count_visible(launcher, FALSE);
366 else
367 update_launcher();
368 }
369
370 static void
371 messaging_menu_config_cb(GtkWidget *widget, gpointer data)
372 {
373 gint option = GPOINTER_TO_INT(data);
374 g_return_if_fail(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget)));
375
376 purple_prefs_set_int("/plugins/gtk/unity/messaging_menu_text", option);
377 messaging_menu_text = option;
378 refill_messaging_menu();
379 }
380
381 static int
382 attach_signals(PurpleConversation *conv)
383 {
384 PidginConversation *gtkconv = NULL;
385 guint id;
386
387 gtkconv = PIDGIN_CONVERSATION(conv);
388 if (!gtkconv)
389 return 0;
390
391 id = g_signal_connect(G_OBJECT(gtkconv->entry), "focus-in-event",
392 G_CALLBACK(unalert_cb), conv);
393 purple_conversation_set_data(conv, "unity-entry-signal", GUINT_TO_POINTER(id));
394
395 id = g_signal_connect(G_OBJECT(gtkconv->imhtml), "focus-in-event",
396 G_CALLBACK(unalert_cb), conv);
397 purple_conversation_set_data(conv, "unity-imhtml-signal", GUINT_TO_POINTER(id));
398
399 return 0;
400 }
401
402 static void
403 detach_signals(PurpleConversation *conv)
404 {
405 PidginConversation *gtkconv = NULL;
406 guint id;
407 gtkconv = PIDGIN_CONVERSATION(conv);
408 if (!gtkconv)
409 return;
410
411 id = GPOINTER_TO_INT(purple_conversation_get_data(conv, "unity-imhtml-signal"));
412 g_signal_handler_disconnect(gtkconv->imhtml, id);
413
414 id = GPOINTER_TO_INT(purple_conversation_get_data(conv, "unity-entry-signal"));
415 g_signal_handler_disconnect(gtkconv->entry, id);
416
417 purple_conversation_set_data(conv, "unity-message-count",
418 GINT_TO_POINTER(0));
419 }
420
421 static GtkWidget *
422 get_config_frame(PurplePlugin *plugin)
423 {
424 GtkWidget *ret = NULL, *frame = NULL;
425 GtkWidget *vbox = NULL, *toggle = NULL;
426
427 ret = gtk_vbox_new(FALSE, 18);
428 gtk_container_set_border_width(GTK_CONTAINER (ret), 12);
429
430 /* Alerts */
431
432 frame = pidgin_make_frame(ret, _("Chatroom alerts"));
433 vbox = gtk_vbox_new(FALSE, 5);
434 gtk_container_add(GTK_CONTAINER(frame), vbox);
435
436 toggle = gtk_check_button_new_with_mnemonic(_("Chatroom message alerts _only where someone says your username"));
437 gtk_box_pack_start(GTK_BOX(vbox), toggle, FALSE, FALSE, 0);
438 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(toggle),
439 purple_prefs_get_bool("/plugins/gtk/unity/alert_chat_nick"));
440 g_signal_connect(G_OBJECT(toggle), "toggled",
441 G_CALLBACK(alert_config_cb), NULL);
442
443 /* Launcher integration */
444
445 frame = pidgin_make_frame(ret, _("Launcher Icon"));
446 vbox = gtk_vbox_new(FALSE, 5);
447 gtk_container_add(GTK_CONTAINER(frame), vbox);
448
449 toggle = gtk_radio_button_new_with_mnemonic(NULL, _("_Disable launcher integration"));
450 gtk_box_pack_start(GTK_BOX(vbox), toggle, FALSE, FALSE, 0);
451 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(toggle),
452 purple_prefs_get_int("/plugins/gtk/unity/launcher_count") == LAUNCHER_COUNT_DISABLE);
453 g_signal_connect(G_OBJECT(toggle), "toggled",
454 G_CALLBACK(launcher_config_cb), GUINT_TO_POINTER(LAUNCHER_COUNT_DISABLE));
455
456 toggle = gtk_radio_button_new_with_mnemonic_from_widget(GTK_RADIO_BUTTON(toggle),
457 _("Show number of unread _messages on launcher icon"));
458 gtk_box_pack_start(GTK_BOX(vbox), toggle, FALSE, FALSE, 0);
459 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(toggle),
460 purple_prefs_get_int("/plugins/gtk/unity/launcher_count") == LAUNCHER_COUNT_MESSAGES);
461 g_signal_connect(G_OBJECT(toggle), "toggled",
462 G_CALLBACK(launcher_config_cb), GUINT_TO_POINTER(LAUNCHER_COUNT_MESSAGES));
463
464 toggle = gtk_radio_button_new_with_mnemonic_from_widget(GTK_RADIO_BUTTON(toggle),
465 _("Show number of unread _conversations on launcher icon"));
466 gtk_box_pack_start(GTK_BOX(vbox), toggle, FALSE, FALSE, 0);
467 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(toggle),
468 purple_prefs_get_int("/plugins/gtk/unity/launcher_count") == LAUNCHER_COUNT_SOURCES);
469 g_signal_connect(G_OBJECT(toggle), "toggled",
470 G_CALLBACK(launcher_config_cb), GUINT_TO_POINTER(LAUNCHER_COUNT_SOURCES));
471
472 /* Messaging menu integration */
473
474 frame = pidgin_make_frame(ret, _("Messaging Menu"));
475 vbox = gtk_vbox_new(FALSE, 5);
476 gtk_container_add(GTK_CONTAINER(frame), vbox);
477
478 toggle = gtk_radio_button_new_with_mnemonic(NULL,
479 _("Show number of _unread messages for conversations in messaging menu"));
480 gtk_box_pack_start(GTK_BOX(vbox), toggle, FALSE, FALSE, 0);
481 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(toggle),
482 purple_prefs_get_int("/plugins/gtk/unity/messaging_menu_text") == MESSAGING_MENU_COUNT);
483 g_signal_connect(G_OBJECT(toggle), "toggled",
484 G_CALLBACK(messaging_menu_config_cb), GUINT_TO_POINTER(MESSAGING_MENU_COUNT));
485
486 toggle = gtk_radio_button_new_with_mnemonic_from_widget(GTK_RADIO_BUTTON(toggle),
487 _("Show _elapsed time for unread conversations in messaging menu"));
488 gtk_box_pack_start(GTK_BOX(vbox), toggle, FALSE, FALSE, 0);
489 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(toggle),
490 purple_prefs_get_int("/plugins/gtk/unity/messaging_menu_text") == MESSAGING_MENU_TIME);
491 g_signal_connect(G_OBJECT(toggle), "toggled",
492 G_CALLBACK(messaging_menu_config_cb), GUINT_TO_POINTER(MESSAGING_MENU_TIME));
493
494 gtk_widget_show_all(ret);
495 return ret;
496 }
497
498 static gboolean
499 plugin_load(PurplePlugin *plugin)
500 {
501 GList *convs = purple_get_conversations();
502 PurpleSavedStatus *saved_status;
503 void *conv_handle = purple_conversations_get_handle();
504 void *gtk_conv_handle = pidgin_conversations_get_handle();
505 void *savedstat_handle = purple_savedstatuses_get_handle();
506
507 alert_chat_nick = purple_prefs_get_bool("/plugins/gtk/unity/alert_chat_nick");
508
509 mmapp = messaging_menu_app_new("pidgin.desktop");
510 g_object_ref(mmapp);
511 messaging_menu_app_register(mmapp);
512 messaging_menu_text = purple_prefs_get_int("/plugins/gtk/unity/messaging_menu_text");
513
514 g_signal_connect(mmapp, "activate-source",
515 G_CALLBACK(message_source_activated), NULL);
516 g_signal_connect(mmapp, "status-changed",
517 G_CALLBACK(messaging_menu_status_changed), NULL);
518
519 saved_status = purple_savedstatus_get_current();
520 status_changed_cb(saved_status);
521
522 purple_signal_connect(savedstat_handle, "savedstatus-changed", plugin,
523 PURPLE_CALLBACK(status_changed_cb), NULL);
524
525 launcher = unity_launcher_entry_get_for_desktop_id("pidgin.desktop");
526 g_object_ref(launcher);
527 launcher_count = purple_prefs_get_int("/plugins/gtk/unity/launcher_count");
528
529 purple_signal_connect(gtk_conv_handle, "displayed-im-msg", plugin,
530 PURPLE_CALLBACK(message_displayed_cb), NULL);
531 purple_signal_connect(gtk_conv_handle, "displayed-chat-msg", plugin,
532 PURPLE_CALLBACK(message_displayed_cb), NULL);
533 purple_signal_connect(conv_handle, "sent-im-msg", plugin,
534 PURPLE_CALLBACK(im_sent_im), NULL);
535 purple_signal_connect(conv_handle, "sent-chat-msg", plugin,
536 PURPLE_CALLBACK(chat_sent_im), NULL);
537 purple_signal_connect(conv_handle, "conversation-created", plugin,
538 PURPLE_CALLBACK(conv_created), NULL);
539 purple_signal_connect(conv_handle, "deleting-conversation", plugin,
540 PURPLE_CALLBACK(deleting_conv), NULL);
541
542 while (convs) {
543 PurpleConversation *conv = (PurpleConversation *)convs->data;
544 attach_signals(conv);
545 convs = convs->next;
546 }
547
548 return TRUE;
549 }
550
551 static gboolean
552 plugin_unload(PurplePlugin *plugin)
553 {
554 GList *convs = purple_get_conversations();
555 while (convs) {
556 PurpleConversation *conv = (PurpleConversation *)convs->data;
557 unalert(conv);
558 detach_signals(conv);
559 convs = convs->next;
560 }
561
562 unity_launcher_entry_set_count_visible(launcher, FALSE);
563 messaging_menu_app_unregister(mmapp);
564
565 g_object_unref(launcher);
566 g_object_unref(mmapp);
567 return TRUE;
568 }
569
570 static PidginPluginUiInfo ui_info =
571 {
572 get_config_frame,
573 0, /* page_num (Reserved) */
574
575 /* padding */
576 NULL,
577 NULL,
578 NULL,
579 NULL
580 };
581
582 static PurplePluginInfo info =
583 {
584 PURPLE_PLUGIN_MAGIC,
585 PURPLE_MAJOR_VERSION,
586 PURPLE_MINOR_VERSION,
587 PURPLE_PLUGIN_STANDARD, /**< type */
588 PIDGIN_PLUGIN_TYPE, /**< ui_requirement */
589 0, /**< flags */
590 NULL, /**< dependencies */
591 PURPLE_PRIORITY_DEFAULT, /**< priority */
592
593 UNITY_PLUGIN_ID, /**< id */
594 N_("Unity Integration"), /**< name */
595 DISPLAY_VERSION, /**< version */
596 /** summary */
597 N_("Provides integration with Unity."),
598 /** description */
599 N_("Provides integration with Unity's messaging "
600 "menu and launcher."),
601 /**< author */
602 "Ankit Vani <a@nevitus.org>",
603 PURPLE_WEBSITE, /**< homepage */
604
605 plugin_load, /**< load */
606 plugin_unload, /**< unload */
607 NULL, /**< destroy */
608
609 &ui_info, /**< ui_info */
610 NULL, /**< extra_info */
611 NULL,
612 NULL,
613
614 /* padding */
615 NULL,
616 NULL,
617 NULL,
618 NULL
619 };
620
621 static void
622 init_plugin(PurplePlugin *plugin)
623 {
624 purple_prefs_add_none("/plugins/gtk");
625 purple_prefs_add_none("/plugins/gtk/unity");
626 purple_prefs_add_int("/plugins/gtk/unity/launcher_count", LAUNCHER_COUNT_SOURCES);
627 purple_prefs_add_int("/plugins/gtk/unity/messaging_menu_text", MESSAGING_MENU_COUNT);
628 purple_prefs_add_bool("/plugins/gtk/unity/alert_chat_nick", TRUE);
629 }
630
631 PURPLE_INIT_PLUGIN(unity, init_plugin, info)

Mercurial Repository: pidgin3

mercurial