pidgin/gtkdocklet.c

   1 /*
   2  * System tray icon (aka docklet) plugin for Purple
   3  *
   4  * Copyright (C) 2002-3 Robert McQueen <robot101@debian.org>
   5  * Copyright (C) 2003 Herman Bloggs <hermanator12002@yahoo.com>
   6  * Inspired by a similar plugin by:
   7  *  John (J5) Palmieri <johnp@martianrock.com>
   8  *
   9  * This program is free software; you can redistribute it and/or
  10  * modify it under the terms of the GNU General Public License as
  11  * published by the Free Software Foundation; either version 2 of the
  12  * License, or (at your option) any later version.
  13  *
  14  * This program is distributed in the hope that it will be useful, but
  15  * WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17  * General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU General Public License
  20  * along with this program; if not, write to the Free Software
  21  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  22  * 02111-1301, USA.
  23  */
  24 #include "internal.h"
  25 #include "pidgin.h"
  26
  27 #include "core.h"
  28 #include "conversation.h"
  29 #include "debug.h"
  30 #include "prefs.h"
  31 #include "signals.h"
  32 #include "sound.h"
  33
  34 #include "gtkaccount.h"
  35 #include "gtkblist.h"
  36 #include "gtkconv.h"
  37 #include "gtkplugin.h"
  38 #include "gtkprefs.h"
  39 #include "gtksavedstatuses.h"
  40 #include "gtksound.h"
  41 #include "gtkstatusbox.h"
  42 #include "gtkutils.h"
  43 #include "pidginstock.h"
  44 #include "gtkdocklet.h"
  45 #include "gtkdialogs.h"
  46
  47 #ifndef DOCKLET_TOOLTIP_LINE_LIMIT
  48 #define DOCKLET_TOOLTIP_LINE_LIMIT 5
  49 #endif
  50
  51 /* globals */
  52 static struct docklet_ui_ops *ui_ops = NULL;
  53 static PurpleStatusPrimitive status = PURPLE_STATUS_OFFLINE;
  54 static gboolean pending = FALSE;
  55 static gboolean connecting = FALSE;
  56 static gboolean enable_join_chat = FALSE;
  57 static guint docklet_blinking_timer = 0;
  58 static gboolean visible = FALSE;
  59 static gboolean visibility_manager = FALSE;
  60
  61 /**************************************************************************
  62  * docklet status and utility functions
  63  **************************************************************************/
  64 static gboolean
  65 docklet_blink_icon(gpointer data)
  66 {
  67         static gboolean blinked = FALSE;
  68         gboolean ret = FALSE; /* by default, don't keep blinking */
  69
  70         blinked = !blinked;
  71
  72         if(pending && !connecting) {
  73                 if (blinked) {
  74                         if (ui_ops && ui_ops->blank_icon)
  75                                 ui_ops->blank_icon();
  76                 } else {
  77                         pidgin_docklet_update_icon();
  78                 }
  79                 ret = TRUE; /* keep blinking */
  80         } else {
  81                 docklet_blinking_timer = 0;
  82                 blinked = FALSE;
  83         }
  84
  85         return ret;
  86 }
  87
  88 static GList *
  89 get_pending_list(guint max)
  90 {
  91         GList *l_im, *l_chat;
  92
  93         l_im = pidgin_conversations_find_unseen_list(PURPLE_CONV_TYPE_IM,
  94                                                        PIDGIN_UNSEEN_TEXT,
  95                                                        FALSE, max);
  96
  97         /* Short circuit if we have our information already */
  98         if (max == 1 && l_im != NULL)
  99                 return l_im;
 100
 101         l_chat = pidgin_conversations_find_unseen_list(PURPLE_CONV_TYPE_CHAT,
 102                                                          PIDGIN_UNSEEN_NICK,
 103                                                          FALSE, max);
 104
 105         if (l_im != NULL && l_chat != NULL)
 106                 return g_list_concat(l_im, l_chat);
 107         else if (l_im != NULL)
 108                 return l_im;
 109         else
 110                 return l_chat;
 111 }
 112
 113 static gboolean
 114 docklet_update_status(void)
 115 {
 116         GList *convs, *l;
 117         int count;
 118         PurpleSavedStatus *saved_status;
 119         PurpleStatusPrimitive newstatus = PURPLE_STATUS_OFFLINE;
 120         gboolean newpending = FALSE, newconnecting = FALSE;
 121
 122         /* get the current savedstatus */
 123         saved_status = purple_savedstatus_get_current();
 124
 125         /* determine if any ims have unseen messages */
 126         convs = get_pending_list(DOCKLET_TOOLTIP_LINE_LIMIT);
 127
 128         if (!strcmp(purple_prefs_get_string(PIDGIN_PREFS_ROOT "/docklet/show"), "pending")) {
 129                 if (convs && ui_ops->create && !visible) {
 130                         g_list_free(convs);
 131                         ui_ops->create();
 132                         return FALSE;
 133                 } else if (!convs && ui_ops->destroy && visible) {
 134                         ui_ops->destroy();
 135                         return FALSE;
 136                 }
 137         }
 138
 139         if (!visible) {
 140                 g_list_free(convs);
 141                 return FALSE;
 142         }
 143
 144         if (convs != NULL) {
 145                 newpending = TRUE;
 146
 147                 /* set tooltip if messages are pending */
 148                 if (ui_ops->set_tooltip) {
 149                         GString *tooltip_text = g_string_new("");
 150                         for (l = convs, count = 0 ; l != NULL ; l = l->next, count++) {
 151                                 PurpleConversation *conv = (PurpleConversation *)l->data;
 152                                 PidginConversation *gtkconv = PIDGIN_CONVERSATION(conv);
 153
 154                                 if (count == DOCKLET_TOOLTIP_LINE_LIMIT - 1) {
 155                                         g_string_append(tooltip_text, _("Right-click for more unread messages...\n"));
 156                                 } else if(gtkconv) {
 157                                         g_string_append_printf(tooltip_text,
 158                                                 ngettext("%d unread message from %s\n", "%d unread messages from %s\n", gtkconv->unseen_count),
 159                                                 gtkconv->unseen_count,
 160                                                 purple_conversation_get_title(conv));
 161                                 } else {
 162                                         g_string_append_printf(tooltip_text,
 163                                                 ngettext("%d unread message from %s\n", "%d unread messages from %s\n",
 164                                                 GPOINTER_TO_INT(purple_conversation_get_data(conv, "unseen-count"))),
 165                                                 GPOINTER_TO_INT(purple_conversation_get_data(conv, "unseen-count")),
 166                                                 purple_conversation_get_title(conv));
 167                                 }
 168                         }
 169
 170                         /* get rid of the last newline */
 171                         if (tooltip_text->len > 0)
 172                                 tooltip_text = g_string_truncate(tooltip_text, tooltip_text->len - 1);
 173
 174                         ui_ops->set_tooltip(tooltip_text->str);
 175
 176                         g_string_free(tooltip_text, TRUE);
 177                 }
 178
 179                 g_list_free(convs);
 180
 181         } else if (ui_ops->set_tooltip) {
 182                 char *tooltip_text = g_strconcat(PIDGIN_NAME, " - ",
 183                         purple_savedstatus_get_title(saved_status), NULL);
 184                 ui_ops->set_tooltip(tooltip_text);
 185                 g_free(tooltip_text);
 186         }
 187
 188         for(l = purple_accounts_get_all(); l != NULL; l = l->next) {
 189
 190                 PurpleAccount *account = (PurpleAccount*)l->data;
 191                 PurpleStatus *account_status;
 192
 193                 if (!purple_account_get_enabled(account, PIDGIN_UI))
 194                         continue;
 195
 196                 if (purple_account_is_disconnected(account))
 197                         continue;
 198
 199                 account_status = purple_account_get_active_status(account);
 200                 if (purple_account_is_connecting(account))
 201                         newconnecting = TRUE;
 202         }
 203
 204         newstatus = purple_savedstatus_get_type(saved_status);
 205
 206         /* update the icon if we changed status */
 207         if (status != newstatus || pending!=newpending || connecting!=newconnecting) {
 208                 status = newstatus;
 209                 pending = newpending;
 210                 connecting = newconnecting;
 211
 212                 pidgin_docklet_update_icon();
 213
 214                 /* and schedule the blinker function if messages are pending */
 215                 if (purple_prefs_get_bool(PIDGIN_PREFS_ROOT "/docklet/blink")
 216                         && pending && !connecting && docklet_blinking_timer == 0) {
 217                         docklet_blinking_timer = g_timeout_add(500, docklet_blink_icon, NULL);
 218                 }
 219         }
 220
 221         return FALSE; /* for when we're called by the glib idle handler */
 222 }
 223
 224 static gboolean
 225 online_account_supports_chat(void)
 226 {
 227         GList *c = NULL;
 228         c = purple_connections_get_all();
 229
 230         while(c != NULL) {
 231                 PurpleConnection *gc = c->data;
 232                 PurplePluginProtocolInfo *prpl_info = PURPLE_PLUGIN_PROTOCOL_INFO(gc->prpl);
 233                 if (prpl_info != NULL && prpl_info->chat_info != NULL)
 234                         return TRUE;
 235                 c = c->next;
 236         }
 237
 238         return FALSE;
 239 }
 240
 241 /**************************************************************************
 242  * callbacks and signal handlers
 243  **************************************************************************/
 244 #if 0
 245 static void
 246 pidgin_quit_cb()
 247 {
 248         /* TODO: confirm quit while pending */
 249 }
 250 #endif
 251
 252 static void
 253 docklet_update_status_cb(void *data)
 254 {
 255         docklet_update_status();
 256 }
 257
 258 static void
 259 docklet_conv_updated_cb(PurpleConversation *conv, PurpleConvUpdateType type)
 260 {
 261         if (type == PURPLE_CONV_UPDATE_UNSEEN)
 262                 docklet_update_status();
 263 }
 264
 265 static void
 266 docklet_signed_on_cb(PurpleConnection *gc)
 267 {
 268         if (!enable_join_chat) {
 269                 if (PURPLE_PLUGIN_PROTOCOL_INFO(gc->prpl)->chat_info != NULL)
 270                         enable_join_chat = TRUE;
 271         }
 272         docklet_update_status();
 273 }
 274
 275 static void
 276 docklet_signed_off_cb(PurpleConnection *gc)
 277 {
 278         if (enable_join_chat) {
 279                 if (PURPLE_PLUGIN_PROTOCOL_INFO(gc->prpl)->chat_info != NULL)
 280                         enable_join_chat = online_account_supports_chat();
 281         }
 282         docklet_update_status();
 283 }
 284
 285 static void
 286 docklet_show_pref_changed_cb(const char *name, PurplePrefType type,
 287                              gconstpointer value, gpointer data)
 288 {
 289         const char *val = value;
 290         if (!strcmp(val, "always")) {
 291                 if (ui_ops->create) {
 292                         if (!visible)
 293                                 ui_ops->create();
 294                         else if (!visibility_manager) {
 295                                 pidgin_blist_visibility_manager_add();
 296                                 visibility_manager = TRUE;
 297                         }
 298                 }
 299         } else if (!strcmp(val, "never")) {
 300                 if (visible && ui_ops->destroy)
 301                         ui_ops->destroy();
 302         } else {
 303                 if (visibility_manager) {
 304                         pidgin_blist_visibility_manager_remove();
 305                         visibility_manager = FALSE;
 306                 }
 307                 docklet_update_status();
 308         }
 309
 310 }
 311
 312 /**************************************************************************
 313  * docklet pop-up menu
 314  **************************************************************************/
 315 static void
 316 docklet_toggle_mute(GtkWidget *toggle, void *data)
 317 {
 318         purple_prefs_set_bool(PIDGIN_PREFS_ROOT "/sound/mute", GTK_CHECK_MENU_ITEM(toggle)->active);
 319 }
 320
 321 static void
 322 docklet_toggle_blink(GtkWidget *toggle, void *data)
 323 {
 324         purple_prefs_set_bool(PIDGIN_PREFS_ROOT "/docklet/blink", GTK_CHECK_MENU_ITEM(toggle)->active);
 325 }
 326
 327 static void
 328 docklet_toggle_blist(GtkWidget *toggle, void *data)
 329 {
 330         purple_blist_set_visible(GTK_CHECK_MENU_ITEM(toggle)->active);
 331 }
 332
 333 #ifdef _WIN32
 334 /* This is a workaround for a bug in windows GTK+. Clicking outside of the
 335    menu does not get rid of it, so instead we get rid of it as soon as the
 336    pointer leaves the menu. */
 337 static gboolean
 338 hide_docklet_menu(gpointer data)
 339 {
 340         if (data != NULL) {
 341                 gtk_menu_popdown(GTK_MENU(data));
 342         }
 343         return FALSE;
 344 }
 345
 346 static gboolean
 347 docklet_menu_leave_enter(GtkWidget *menu, GdkEventCrossing *event, void *data)
 348 {
 349         static guint hide_docklet_timer = 0;
 350
 351         if (event->type == GDK_LEAVE_NOTIFY && (event->detail == GDK_NOTIFY_ANCESTOR ||
 352                         event->detail == GDK_NOTIFY_UNKNOWN)) {
 353                 purple_debug(PURPLE_DEBUG_INFO, "docklet", "menu leave-notify-event\n");
 354                 /* Add some slop so that the menu doesn't annoyingly disappear when mousing around */
 355                 if (hide_docklet_timer == 0) {
 356                         hide_docklet_timer = purple_timeout_add(500,
 357                                         hide_docklet_menu, menu);
 358                 }
 359         } else if (event->type == GDK_ENTER_NOTIFY && event->detail == GDK_NOTIFY_ANCESTOR) {
 360                 purple_debug(PURPLE_DEBUG_INFO, "docklet", "menu enter-notify-event\n");
 361                 if (hide_docklet_timer != 0) {
 362                         /* Cancel the hiding if we reenter */
 363
 364                         purple_timeout_remove(hide_docklet_timer);
 365                         hide_docklet_timer = 0;
 366                 }
 367         }
 368         return FALSE;
 369 }
 370 #endif
 371
 372 /* There is a lot of code here for handling the status submenu, much of
 373  * which is duplicated from the gtkstatusbox. It'd be nice to add API
 374  * somewhere to simplify this (either in the statusbox, or in libpurple).
 375  */
 376 static void
 377 show_custom_status_editor_cb(GtkMenuItem *menuitem, gpointer user_data)
 378 {
 379         PurpleSavedStatus *saved_status;
 380         saved_status = purple_savedstatus_get_current();
 381
 382         if (purple_savedstatus_get_type(saved_status) == PURPLE_STATUS_AVAILABLE)
 383                 saved_status = purple_savedstatus_new(NULL, PURPLE_STATUS_AWAY);
 384
 385         pidgin_status_editor_show(FALSE,
 386                 purple_savedstatus_is_transient(saved_status) ? saved_status : NULL);
 387 }
 388
 389 static PurpleSavedStatus *
 390 create_transient_status(PurpleStatusPrimitive primitive, PurpleStatusType *status_type)
 391 {
 392         PurpleSavedStatus *saved_status = purple_savedstatus_new(NULL, primitive);
 393
 394         if(status_type != NULL) {
 395                 GList *tmp, *active_accts = purple_accounts_get_all_active();
 396                 for (tmp = active_accts; tmp != NULL; tmp = tmp->next) {
 397                         purple_savedstatus_set_substatus(saved_status,
 398                                 (PurpleAccount*) tmp->data, status_type, NULL);
 399                 }
 400                 g_list_free(active_accts);
 401         }
 402
 403         return saved_status;
 404 }
 405
 406 static void
 407 activate_status_account_cb(GtkMenuItem *menuitem, gpointer user_data)
 408 {
 409         PurpleStatusType *status_type;
 410         PurpleStatusPrimitive primitive;
 411         PurpleSavedStatus *saved_status = NULL;
 412         GList *iter = purple_savedstatuses_get_all();
 413         GList *tmp, *active_accts = purple_accounts_get_all_active();
 414
 415         status_type = (PurpleStatusType *)user_data;
 416         primitive = purple_status_type_get_primitive(status_type);
 417
 418         for (; iter != NULL; iter = iter->next) {
 419                 PurpleSavedStatus *ss = iter->data;
 420                 if ((purple_savedstatus_get_type(ss) == primitive) && purple_savedstatus_is_transient(ss) &&
 421                         purple_savedstatus_has_substatuses(ss))
 422                 {
 423                         gboolean found = FALSE;
 424                         /* The currently enabled accounts must have substatuses for all the active accts */
 425                         for(tmp = active_accts; tmp != NULL; tmp = tmp->next) {
 426                                 PurpleAccount *acct = tmp->data;
 427                                 PurpleSavedStatusSub *sub = purple_savedstatus_get_substatus(ss, acct);
 428                                 if (sub) {
 429                                         const PurpleStatusType *sub_type = purple_savedstatus_substatus_get_type(sub);
 430                                         const char *subtype_status_id = purple_status_type_get_id(sub_type);
 431                                         if (subtype_status_id && !strcmp(subtype_status_id,
 432                                                         purple_status_type_get_id(status_type)))
 433                                                 found = TRUE;
 434                                 }
 435                         }
 436                         if (!found)
 437                                 continue;
 438                         saved_status = ss;
 439                         break;
 440                 }
 441         }
 442
 443         g_list_free(active_accts);
 444
 445         /* Create a new transient saved status if we weren't able to find one */
 446         if (saved_status == NULL)
 447                 saved_status = create_transient_status(primitive, status_type);
 448
 449         /* Set the status for each account */
 450         purple_savedstatus_activate(saved_status);
 451 }
 452
 453 static void
 454 activate_status_primitive_cb(GtkMenuItem *menuitem, gpointer user_data)
 455 {
 456         PurpleStatusPrimitive primitive;
 457         PurpleSavedStatus *saved_status;
 458
 459         primitive = GPOINTER_TO_INT(user_data);
 460
 461         /* Try to lookup an already existing transient saved status */
 462         saved_status = purple_savedstatus_find_transient_by_type_and_message(primitive, NULL);
 463
 464         /* Create a new transient saved status if we weren't able to find one */
 465         if (saved_status == NULL)
 466                 saved_status = create_transient_status(primitive, NULL);
 467
 468         /* Set the status for each account */
 469         purple_savedstatus_activate(saved_status);
 470 }
 471
 472 static void
 473 activate_saved_status_cb(GtkMenuItem *menuitem, gpointer user_data)
 474 {
 475         time_t creation_time;
 476         PurpleSavedStatus *saved_status;
 477
 478         creation_time = GPOINTER_TO_INT(user_data);
 479         saved_status = purple_savedstatus_find_by_creation_time(creation_time);
 480         if (saved_status != NULL)
 481                 purple_savedstatus_activate(saved_status);
 482 }
 483
 484 static GtkWidget *
 485 new_menu_item_with_status_icon(GtkWidget *menu, const char *str, PurpleStatusPrimitive primitive, GCallback cb, gpointer data, guint accel_key, guint accel_mods, char *mod)
 486 {
 487         GtkWidget *menuitem;
 488         GdkPixbuf *pixbuf;
 489         GtkWidget *image;
 490
 491         menuitem = gtk_image_menu_item_new_with_label(str);
 492
 493         if (menu)
 494                 gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem);
 495
 496         if (cb)
 497                 g_signal_connect(G_OBJECT(menuitem), "activate", cb, data);
 498
 499         pixbuf = pidgin_create_status_icon(primitive, menu, PIDGIN_ICON_SIZE_TANGO_EXTRA_SMALL);
 500         image = gtk_image_new_from_pixbuf(pixbuf);
 501         g_object_unref(pixbuf);
 502         gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(menuitem), image);
 503
 504         gtk_widget_show_all(menuitem);
 505
 506         return menuitem;
 507 }
 508
 509 static void
 510 add_account_statuses(GtkWidget *menu, PurpleAccount *account)
 511 {
 512         GList *l;
 513
 514         for (l = purple_account_get_status_types(account); l != NULL; l = l->next) {
 515                 PurpleStatusType *status_type = (PurpleStatusType *)l->data;
 516                 PurpleStatusPrimitive prim;
 517
 518                 if (!purple_status_type_is_user_settable(status_type))
 519                         continue;
 520
 521                 prim = purple_status_type_get_primitive(status_type);
 522
 523                 new_menu_item_with_status_icon(menu,
 524                         purple_status_type_get_name(status_type),
 525                         prim, G_CALLBACK(activate_status_account_cb),
 526                         status_type, 0, 0, NULL);
 527         }
 528 }
 529
 530 static GtkWidget *
 531 docklet_status_submenu(void)
 532 {
 533         GtkWidget *submenu, *menuitem;
 534         GList *popular_statuses, *cur;
 535         PidginStatusBox *statusbox = NULL;
 536
 537         submenu = gtk_menu_new();
 538         menuitem = gtk_menu_item_new_with_mnemonic(_("_Change Status"));
 539         gtk_menu_item_set_submenu(GTK_MENU_ITEM(menuitem), submenu);
 540
 541         if(pidgin_blist_get_default_gtk_blist() != NULL) {
 542                 statusbox = PIDGIN_STATUS_BOX(pidgin_blist_get_default_gtk_blist()->statusbox);
 543         }
 544
 545         if(statusbox && statusbox->account != NULL) {
 546                 add_account_statuses(submenu, statusbox->account);
 547         } else if(statusbox && statusbox->token_status_account != NULL) {
 548                 add_account_statuses(submenu, statusbox->token_status_account);
 549         } else {
 550                 new_menu_item_with_status_icon(submenu, _("Available"),
 551                         PURPLE_STATUS_AVAILABLE, G_CALLBACK(activate_status_primitive_cb),
 552                         GINT_TO_POINTER(PURPLE_STATUS_AVAILABLE), 0, 0, NULL);
 553
 554                 new_menu_item_with_status_icon(submenu, _("Away"),
 555                         PURPLE_STATUS_AWAY, G_CALLBACK(activate_status_primitive_cb),
 556                         GINT_TO_POINTER(PURPLE_STATUS_AWAY), 0, 0, NULL);
 557
 558                 new_menu_item_with_status_icon(submenu, _("Do not disturb"),
 559                         PURPLE_STATUS_UNAVAILABLE, G_CALLBACK(activate_status_primitive_cb),
 560                         GINT_TO_POINTER(PURPLE_STATUS_UNAVAILABLE), 0, 0, NULL);
 561
 562                 new_menu_item_with_status_icon(submenu, _("Invisible"),
 563                         PURPLE_STATUS_INVISIBLE, G_CALLBACK(activate_status_primitive_cb),
 564                         GINT_TO_POINTER(PURPLE_STATUS_INVISIBLE), 0, 0, NULL);
 565
 566                 new_menu_item_with_status_icon(submenu, _("Offline"),
 567                         PURPLE_STATUS_OFFLINE, G_CALLBACK(activate_status_primitive_cb),
 568                         GINT_TO_POINTER(PURPLE_STATUS_OFFLINE), 0, 0, NULL);
 569         }
 570
 571         popular_statuses = purple_savedstatuses_get_popular(6);
 572         if (popular_statuses != NULL)
 573                 pidgin_separator(submenu);
 574         for (cur = popular_statuses; cur != NULL; cur = cur->next)
 575         {
 576                 PurpleSavedStatus *saved_status = cur->data;
 577                 time_t creation_time = purple_savedstatus_get_creation_time(saved_status);
 578                 new_menu_item_with_status_icon(submenu,
 579                         purple_savedstatus_get_title(saved_status),
 580                         purple_savedstatus_get_type(saved_status), G_CALLBACK(activate_saved_status_cb),
 581                         GINT_TO_POINTER(creation_time), 0, 0, NULL);
 582         }
 583         g_list_free(popular_statuses);
 584
 585         pidgin_separator(submenu);
 586
 587         pidgin_new_item_from_stock(submenu, _("New..."), NULL, G_CALLBACK(show_custom_status_editor_cb), NULL, 0, 0, NULL);
 588         pidgin_new_item_from_stock(submenu, _("Saved..."), NULL, G_CALLBACK(pidgin_status_window_show), NULL, 0, 0, NULL);
 589
 590         return menuitem;
 591 }
 592
 593
 594
 595 static void
 596 plugin_act(GtkObject *obj, PurplePluginAction *pam)
 597 {
 598         if (pam && pam->callback)
 599                 pam->callback(pam);
 600 }
 601
 602 static void
 603 build_plugin_actions(GtkWidget *menu, PurplePlugin *plugin,
 604                 gpointer context)
 605 {
 606         GtkWidget *menuitem;
 607         PurplePluginAction *action = NULL;
 608         GList *actions, *l;
 609
 610         actions = PURPLE_PLUGIN_ACTIONS(plugin, context);
 611
 612         for (l = actions; l != NULL; l = l->next)
 613         {
 614                 if (l->data)
 615                 {
 616                         action = (PurplePluginAction *) l->data;
 617                         action->plugin = plugin;
 618                         action->context = context;
 619
 620                         menuitem = gtk_menu_item_new_with_label(action->label);
 621                         gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem);
 622
 623                         g_signal_connect(G_OBJECT(menuitem), "activate",
 624                                         G_CALLBACK(plugin_act), action);
 625                         g_object_set_data_full(G_OBJECT(menuitem), "plugin_action",
 626                                                                    action,
 627                                                                    (GDestroyNotify)purple_plugin_action_free);
 628                         gtk_widget_show(menuitem);
 629                 }
 630                 else
 631                         pidgin_separator(menu);
 632         }
 633
 634         g_list_free(actions);
 635 }
 636
 637
 638 static void
 639 docklet_plugin_actions(GtkWidget *menu)
 640 {
 641         GtkWidget *menuitem, *submenu;
 642         PurplePlugin *plugin = NULL;
 643         GList *l;
 644         int c = 0;
 645
 646         g_return_if_fail(menu != NULL);
 647
 648         /* Add a submenu for each plugin with custom actions */
 649         for (l = purple_plugins_get_loaded(); l; l = l->next) {
 650                 plugin = (PurplePlugin *) l->data;
 651
 652                 if (PURPLE_IS_PROTOCOL_PLUGIN(plugin))
 653                         continue;
 654
 655                 if (!PURPLE_PLUGIN_HAS_ACTIONS(plugin))
 656                         continue;
 657
 658                 menuitem = gtk_image_menu_item_new_with_label(_(plugin->info->name));
 659                 gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem);
 660
 661                 submenu = gtk_menu_new();
 662                 gtk_menu_item_set_submenu(GTK_MENU_ITEM(menuitem), submenu);
 663
 664                 build_plugin_actions(submenu, plugin, NULL);
 665
 666                 c++;
 667         }
 668         if(c>0)
 669                 pidgin_separator(menu);
 670 }
 671
 672 static void
 673 docklet_menu(void)
 674 {
 675         static GtkWidget *menu = NULL;
 676         GtkWidget *menuitem;
 677
 678         if (menu) {
 679                 gtk_widget_destroy(menu);
 680         }
 681
 682         menu = gtk_menu_new();
 683
 684         menuitem = gtk_check_menu_item_new_with_mnemonic(_("Show Buddy _List"));
 685         gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(menuitem), purple_prefs_get_bool(PIDGIN_PREFS_ROOT "/blist/list_visible"));
 686         g_signal_connect(G_OBJECT(menuitem), "toggled", G_CALLBACK(docklet_toggle_blist), NULL);
 687         gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem);
 688
 689         menuitem = gtk_menu_item_new_with_mnemonic(_("_Unread Messages"));
 690
 691         if (pending) {
 692                 GtkWidget *submenu = gtk_menu_new();
 693                 GList *l = get_pending_list(0);
 694                 if (l == NULL) {
 695                         gtk_widget_set_sensitive(menuitem, FALSE);
 696                         purple_debug_warning("docklet",
 697                                 "status indicates messages pending, but no conversations with unseen messages were found.");
 698                 } else {
 699                         pidgin_conversations_fill_menu(submenu, l);
 700                         g_list_free(l);
 701                         gtk_menu_item_set_submenu(GTK_MENU_ITEM(menuitem), submenu);
 702                 }
 703         } else {
 704                 gtk_widget_set_sensitive(menuitem, FALSE);
 705         }
 706         gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem);
 707
 708         pidgin_separator(menu);
 709
 710         menuitem = pidgin_new_item_from_stock(menu, _("New _Message..."), PIDGIN_STOCK_TOOLBAR_MESSAGE_NEW, G_CALLBACK(pidgin_dialogs_im), NULL, 0, 0, NULL);
 711         if (status == PURPLE_STATUS_OFFLINE)
 712                 gtk_widget_set_sensitive(menuitem, FALSE);
 713
 714         menuitem = pidgin_new_item_from_stock(menu, _("Join Chat..."), PIDGIN_STOCK_CHAT,
 715                         G_CALLBACK(pidgin_blist_joinchat_show), NULL, 0, 0, NULL);
 716         if (status == PURPLE_STATUS_OFFLINE)
 717                 gtk_widget_set_sensitive(menuitem, FALSE);
 718
 719         menuitem = docklet_status_submenu();
 720         gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem);
 721
 722         pidgin_separator(menu);
 723
 724         pidgin_new_item_from_stock(menu, _("_Accounts"), NULL, G_CALLBACK(pidgin_accounts_window_show), NULL, 0, 0, NULL);
 725         pidgin_new_item_from_stock(menu, _("Plu_gins"), PIDGIN_STOCK_TOOLBAR_PLUGINS, G_CALLBACK(pidgin_plugin_dialog_show), NULL, 0, 0, NULL);
 726         pidgin_new_item_from_stock(menu, _("Pr_eferences"), GTK_STOCK_PREFERENCES, G_CALLBACK(pidgin_prefs_show), NULL, 0, 0, NULL);
 727
 728         pidgin_separator(menu);
 729
 730         menuitem = gtk_check_menu_item_new_with_mnemonic(_("Mute _Sounds"));
 731         gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(menuitem), purple_prefs_get_bool(PIDGIN_PREFS_ROOT "/sound/mute"));
 732         if (!strcmp(purple_prefs_get_string(PIDGIN_PREFS_ROOT "/sound/method"), "none"))
 733                 gtk_widget_set_sensitive(GTK_WIDGET(menuitem), FALSE);
 734         g_signal_connect(G_OBJECT(menuitem), "toggled", G_CALLBACK(docklet_toggle_mute), NULL);
 735         gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem);
 736
 737         menuitem = gtk_check_menu_item_new_with_mnemonic(_("_Blink on New Message"));
 738         gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(menuitem), purple_prefs_get_bool(PIDGIN_PREFS_ROOT "/docklet/blink"));
 739         g_signal_connect(G_OBJECT(menuitem), "toggled", G_CALLBACK(docklet_toggle_blink), NULL);
 740         gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem);
 741
 742         pidgin_separator(menu);
 743
 744         /* add plugin actions */
 745         docklet_plugin_actions(menu);
 746
 747         pidgin_new_item_from_stock(menu, _("_Quit"), GTK_STOCK_QUIT, G_CALLBACK(purple_core_quit), NULL, 0, 0, NULL);
 748
 749 #ifdef _WIN32
 750         g_signal_connect(menu, "leave-notify-event", G_CALLBACK(docklet_menu_leave_enter), NULL);
 751         g_signal_connect(menu, "enter-notify-event", G_CALLBACK(docklet_menu_leave_enter), NULL);
 752 #endif
 753         gtk_widget_show_all(menu);
 754         gtk_menu_popup(GTK_MENU(menu), NULL, NULL,
 755                        ui_ops->position_menu,
 756                        NULL, 0, gtk_get_current_event_time());
 757 }
 758
 759 /**************************************************************************
 760  * public api for ui_ops
 761  **************************************************************************/
 762 void
 763 pidgin_docklet_update_icon()
 764 {
 765         if (ui_ops && ui_ops->update_icon)
 766                 ui_ops->update_icon(status, connecting, pending);
 767 }
 768
 769 void
 770 pidgin_docklet_clicked(int button_type)
 771 {
 772         switch (button_type) {
 773                 case 1:
 774                         if (pending) {
 775                                 GList *l = get_pending_list(1);
 776                                 if (l != NULL) {
 777                                         pidgin_conv_present_conversation((PurpleConversation *)l->data);
 778                                         g_list_free(l);
 779                                 }
 780                         } else {
 781                                 pidgin_blist_toggle_visibility();
 782                         }
 783                         break;
 784                 case 3:
 785                         docklet_menu();
 786                         break;
 787         }
 788 }
 789
 790 void
 791 pidgin_docklet_embedded()
 792 {
 793         if (!visibility_manager
 794             && strcmp(purple_prefs_get_string(PIDGIN_PREFS_ROOT "/docklet/show"), "pending")) {
 795                 pidgin_blist_visibility_manager_add();
 796                 visibility_manager = TRUE;
 797         }
 798         visible = TRUE;
 799         docklet_update_status();
 800         pidgin_docklet_update_icon();
 801 }
 802
 803 void
 804 pidgin_docklet_remove()
 805 {
 806         if (visible) {
 807                 if (visibility_manager) {
 808                         pidgin_blist_visibility_manager_remove();
 809                         visibility_manager = FALSE;
 810                 }
 811                 if (docklet_blinking_timer) {
 812                         g_source_remove(docklet_blinking_timer);
 813                         docklet_blinking_timer = 0;
 814                 }
 815                 visible = FALSE;
 816                 status = PURPLE_STATUS_OFFLINE;
 817         }
 818 }
 819
 820 void
 821 pidgin_docklet_set_ui_ops(struct docklet_ui_ops *ops)
 822 {
 823         ui_ops = ops;
 824 }
 825
 826 void*
 827 pidgin_docklet_get_handle()
 828 {
 829         static int i;
 830         return &i;
 831 }
 832
 833 void
 834 pidgin_docklet_init()
 835 {
 836         void *conn_handle = purple_connections_get_handle();
 837         void *conv_handle = purple_conversations_get_handle();
 838         void *accounts_handle = purple_accounts_get_handle();
 839         void *status_handle = purple_savedstatuses_get_handle();
 840         void *docklet_handle = pidgin_docklet_get_handle();
 841
 842         purple_prefs_add_none(PIDGIN_PREFS_ROOT "/docklet");
 843         purple_prefs_add_bool(PIDGIN_PREFS_ROOT "/docklet/blink", FALSE);
 844         purple_prefs_add_string(PIDGIN_PREFS_ROOT "/docklet/show", "always");
 845         purple_prefs_connect_callback(docklet_handle, PIDGIN_PREFS_ROOT "/docklet/show",
 846                                     docklet_show_pref_changed_cb, NULL);
 847
 848         docklet_ui_init();
 849         if (!strcmp(purple_prefs_get_string(PIDGIN_PREFS_ROOT "/docklet/show"), "always") && ui_ops && ui_ops->create)
 850                 ui_ops->create();
 851
 852         purple_signal_connect(conn_handle, "signed-on",
 853                             docklet_handle, PURPLE_CALLBACK(docklet_signed_on_cb), NULL);
 854         purple_signal_connect(conn_handle, "signed-off",
 855                             docklet_handle, PURPLE_CALLBACK(docklet_signed_off_cb), NULL);
 856         purple_signal_connect(accounts_handle, "account-connecting",
 857                             docklet_handle, PURPLE_CALLBACK(docklet_update_status_cb), NULL);
 858         purple_signal_connect(conv_handle, "received-im-msg",
 859                             docklet_handle, PURPLE_CALLBACK(docklet_update_status_cb), NULL);
 860         purple_signal_connect(conv_handle, "conversation-created",
 861                             docklet_handle, PURPLE_CALLBACK(docklet_update_status_cb), NULL);
 862         purple_signal_connect(conv_handle, "deleting-conversation",
 863                             docklet_handle, PURPLE_CALLBACK(docklet_update_status_cb), NULL);
 864         purple_signal_connect(conv_handle, "conversation-updated",
 865                             docklet_handle, PURPLE_CALLBACK(docklet_conv_updated_cb), NULL);
 866         purple_signal_connect(status_handle, "savedstatus-changed",
 867                             docklet_handle, PURPLE_CALLBACK(docklet_update_status_cb), NULL);
 868 #if 0
 869         purple_signal_connect(purple_get_core(), "quitting",
 870                             docklet_handle, PURPLE_CALLBACK(purple_quit_cb), NULL);
 871 #endif
 872
 873         enable_join_chat = online_account_supports_chat();
 874 }
 875
 876 void
 877 pidgin_docklet_uninit()
 878 {
 879         if (visible && ui_ops && ui_ops->destroy)
 880                 ui_ops->destroy();
 881 }