pidgin/plugins/musicmessaging/musicmessaging.c

   1 /*
   2  * Music messaging plugin for Purple
   3  *
   4  * Copyright (C) 2005 Christian Muise.
   5  *
   6  * This program is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU General Public License as
   8  * published by the Free Software Foundation; either version 2 of the
   9  * License, or (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful, but
  12  * WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  19  * 02111-1301, USA.
  20  */
  21
  22 #include "internal.h"
  23 #include "pidgin.h"
  24
  25 #include "conversation.h"
  26
  27 #include "gtk3compat.h"
  28 #include "gtkconv.h"
  29 #include "gtkplugin.h"
  30 #include "gtkutils.h"
  31
  32 #include "notify.h"
  33 #include "version.h"
  34 #include "debug.h"
  35
  36 #define DBUS_API_SUBJECT_TO_CHANGE
  37 #include <dbus/dbus.h>
  38 #include "dbus-maybe.h"
  39 #include "dbus-bindings.h"
  40 #include "dbus-server.h"
  41 #include "dbus-purple.h"
  42
  43 #define MUSICMESSAGING_PLUGIN_ID "gtk-hazure-musicmessaging"
  44 #define MUSICMESSAGING_PREFIX "##MM##"
  45 #define MUSICMESSAGING_START_MSG _("A music messaging session has been requested. Please click the MM icon to accept.")
  46 #define MUSICMESSAGING_CONFIRM_MSG _("Music messaging session confirmed.")
  47
  48 typedef struct {
  49         PurpleConversation *conv; /* pointer to the conversation */
  50         GtkWidget *seperator; /* seperator in the conversation */
  51         GtkWidget *button; /* button in the conversation */
  52         GPid pid; /* the pid of the score editor */
  53
  54         gboolean started; /* session has started and editor run */
  55         gboolean originator; /* started the mm session */
  56         gboolean requested; /* received a request to start a session */
  57
  58 } MMConversation;
  59
  60 static gboolean start_session(MMConversation *mmconv);
  61 static void run_editor(MMConversation *mmconv);
  62 static void kill_editor(MMConversation *mmconv);
  63 static void add_button (MMConversation *mmconv);
  64 static void remove_widget (GtkWidget *button);
  65 static void init_conversation (PurpleConversation *conv);
  66 static void conv_destroyed(PurpleConversation *conv);
  67 static gboolean intercept_sent(PurpleAccount *account, PurpleMessage *msg, void* pData);
  68 static gboolean intercept_received(PurpleAccount *account, char **sender, char **message, PurpleConversation *conv, int *flags);
  69 static gboolean send_change_request (const int session, const char *id, const char *command, const char *parameters);
  70 static gboolean send_change_confirmed (const int session, const char *command, const char *parameters);
  71 static void session_end (MMConversation *mmconv);
  72
  73 /* Globals */
  74 /* List of sessions */
  75 static GList *conversations;
  76
  77 /* Pointer to this plugin */
  78 static PurplePlugin *plugin_pointer;
  79
  80 /* Define types needed for DBus */
  81 DBusGConnection *connection;
  82 DBusGProxy *proxy;
  83 #define DBUS_SERVICE_GSCORE "org.gscore.GScoreService"
  84 #define DBUS_PATH_GSCORE "/org/gscore/GScoreObject"
  85 #define DBUS_INTERFACE_GSCORE "org.gscore.GScoreInterface"
  86
  87 /* Define the functions to export for use with DBus */
  88 DBUS_EXPORT void
  89 music_messaging_change_request(const int session, const char *command,
  90         const char *parameters);
  91
  92 DBUS_EXPORT void
  93 music_messaging_change_confirmed(const int session, const char *command,
  94         const char *parameters);
  95
  96 DBUS_EXPORT void
  97 music_messaging_change_failed(const int session, const char *id,
  98         const char *command, const char *parameters);
  99
 100 DBUS_EXPORT void
 101 music_messaging_done_session(const int session);
 102
 103 /* This file has been generated by the #dbus-analize-functions.py
 104    script.  It contains dbus wrappers for the four functions declared
 105    above. */
 106 #include "music-messaging-bindings.c"
 107
 108 /* Exported functions */
 109 DBUS_EXPORT void
 110 music_messaging_change_request(const int session, const char *command,
 111         const char *parameters)
 112 {
 113
 114         MMConversation *mmconv = (MMConversation *)g_list_nth_data(conversations, session);
 115
 116         if (mmconv->started)
 117         {
 118                 if (mmconv->originator)
 119                 {
 120                         const char *name = purple_conversation_get_name(mmconv->conv);
 121                         send_change_request (session, name, command, parameters);
 122                 } else
 123                 {
 124                         GString *to_send = g_string_new("");
 125                         g_string_append_printf(to_send, "##MM## request %s %s##MM##", command, parameters);
 126
 127                         purple_conversation_send(mmconv->conv, to_send->str);
 128
 129                         purple_debug_misc("musicmessaging", "Sent request: %s\n", to_send->str);
 130                 }
 131         }
 132
 133 }
 134
 135 DBUS_EXPORT void
 136 music_messaging_change_confirmed(const int session, const char *command,
 137         const char *parameters)
 138 {
 139
 140         MMConversation *mmconv = (MMConversation *)g_list_nth_data(conversations, session);
 141
 142         if (mmconv->started)
 143         {
 144                 if (mmconv->originator)
 145                 {
 146                         GString *to_send = g_string_new("");
 147                         g_string_append_printf(to_send, "##MM## confirm %s %s##MM##", command, parameters);
 148
 149                         purple_conversation_send(mmconv->conv, to_send->str);
 150                 } else
 151                 {
 152                         /* Do nothing. If they aren't the originator, then they can't confirm. */
 153                 }
 154         }
 155
 156 }
 157
 158 DBUS_EXPORT void
 159 music_messaging_change_failed(const int session, const char *id,
 160         const char *command, const char *parameters)
 161 {
 162         MMConversation *mmconv = (MMConversation *)g_list_nth_data(conversations, session);
 163
 164         purple_notify_message(plugin_pointer, PURPLE_NOTIFY_MSG_INFO, command,
 165                         parameters, NULL, NULL, NULL, NULL);
 166
 167         if (mmconv->started)
 168         {
 169                 if (mmconv->originator)
 170                 {
 171                         GString *to_send = g_string_new("");
 172                         g_string_append_printf(to_send, "##MM## failed %s %s %s##MM##", id, command, parameters);
 173
 174                         purple_conversation_send(mmconv->conv, to_send->str);
 175                 } else
 176                 {
 177                         /* Do nothing. If they aren't the originator, then they can't confirm. */
 178                 }
 179         }
 180 }
 181
 182 DBUS_EXPORT void
 183 music_messaging_done_session(const int session)
 184 {
 185         MMConversation *mmconv = (MMConversation *)g_list_nth_data(conversations, session);
 186
 187         purple_notify_message(plugin_pointer, PURPLE_NOTIFY_MSG_INFO, "Session",
 188                                                 "Session Complete", NULL, NULL, NULL, NULL);
 189
 190         session_end(mmconv);
 191 }
 192
 193
 194 /* DBus commands that can be sent to the editor */
 195 G_BEGIN_DECLS
 196 DBusConnection *purple_dbus_get_connection(void);
 197 G_END_DECLS
 198
 199 static gboolean send_change_request (const int session, const char *id, const char *command, const char *parameters)
 200 {
 201         DBusMessage *message;
 202
 203         /* Create the signal we need */
 204         message = dbus_message_new_signal (PURPLE_DBUS_PATH, PURPLE_DBUS_INTERFACE, "GscoreChangeRequest");
 205
 206         /* Append the string "Ping!" to the signal */
 207         dbus_message_append_args (message,
 208                                                         DBUS_TYPE_INT32, &session,
 209                                                         DBUS_TYPE_STRING, &id,
 210                                                         DBUS_TYPE_STRING, &command,
 211                                                         DBUS_TYPE_STRING, &parameters,
 212                                                         DBUS_TYPE_INVALID);
 213
 214         /* Send the signal */
 215         dbus_connection_send (purple_dbus_get_connection(), message, NULL);
 216
 217         /* Free the signal now we have finished with it */
 218         dbus_message_unref (message);
 219
 220         /* Tell the user we sent a signal */
 221         g_printerr("Sent change request signal: %d %s %s %s\n", session, id, command, parameters);
 222
 223         return TRUE;
 224 }
 225
 226 static gboolean send_change_confirmed (const int session, const char *command, const char *parameters)
 227 {
 228         DBusMessage *message;
 229
 230         /* Create the signal we need */
 231         message = dbus_message_new_signal (PURPLE_DBUS_PATH, PURPLE_DBUS_INTERFACE, "GscoreChangeConfirmed");
 232
 233         /* Append the string "Ping!" to the signal */
 234         dbus_message_append_args (message,
 235                                                         DBUS_TYPE_INT32, &session,
 236                                                         DBUS_TYPE_STRING, &command,
 237                                                         DBUS_TYPE_STRING, &parameters,
 238                                                         DBUS_TYPE_INVALID);
 239
 240         /* Send the signal */
 241         dbus_connection_send (purple_dbus_get_connection(), message, NULL);
 242
 243         /* Free the signal now we have finished with it */
 244         dbus_message_unref (message);
 245
 246         /* Tell the user we sent a signal */
 247         g_printerr("Sent change confirmed signal.\n");
 248
 249         return TRUE;
 250 }
 251
 252
 253 static int
 254 mmconv_from_conv_loc(PurpleConversation *conv)
 255 {
 256         GList *l;
 257         MMConversation *mmconv_current = NULL;
 258         guint i;
 259
 260         i = 0;
 261         for (l = conversations; l != NULL; l = l->next)
 262         {
 263                 mmconv_current = l->data;
 264                 if (conv == mmconv_current->conv)
 265                 {
 266                         return i;
 267                 }
 268                 i++;
 269         }
 270         return -1;
 271 }
 272
 273 static MMConversation*
 274 mmconv_from_conv(PurpleConversation *conv)
 275 {
 276         return (MMConversation *)g_list_nth_data(conversations, mmconv_from_conv_loc(conv));
 277 }
 278
 279 static gboolean
 280 intercept_sent(PurpleAccount *account, PurpleMessage *msg, void* pData)
 281 {
 282         const gchar *cont = purple_message_get_contents(msg);
 283
 284         if (purple_message_is_empty(msg))
 285                 return FALSE;
 286
 287         if (0 == strncmp(cont, MUSICMESSAGING_PREFIX, strlen(MUSICMESSAGING_PREFIX)))
 288         {
 289                 purple_debug_misc("purple-musicmessaging", "Sent MM Message: %s\n", cont);
 290         }
 291         else if (0 == strncmp(cont, MUSICMESSAGING_START_MSG, strlen(MUSICMESSAGING_START_MSG)))
 292         {
 293                 purple_debug_misc("purple-musicmessaging", "Sent MM request.\n");
 294                 return FALSE;
 295         }
 296         else if (0 == strncmp(cont, MUSICMESSAGING_CONFIRM_MSG, strlen(MUSICMESSAGING_CONFIRM_MSG)))
 297         {
 298                 purple_debug_misc("purple-musicmessaging", "Sent MM confirm.\n");
 299                 return FALSE;
 300         }
 301         else if (0 == strncmp(cont, "test1", strlen("test1")))
 302         {
 303                 purple_debug_misc("purple-musicmessaging", "\n\nTEST 1\n\n");
 304                 send_change_request(0, "test-id", "test-command", "test-parameters");
 305                 return FALSE;
 306         }
 307         else if (0 == strncmp(cont, "test2", strlen("test2")))
 308         {
 309                 purple_debug_misc("purple-musicmessaging", "\n\nTEST 2\n\n");
 310                 send_change_confirmed(1, "test-command", "test-parameters");
 311                 return FALSE;
 312         }
 313         else
 314         {
 315                 return FALSE;
 316                 /* Do nothing...procceed as normal */
 317         }
 318         return TRUE;
 319 }
 320
 321 static gboolean
 322 intercept_received(PurpleAccount *account, char **sender, char **message, PurpleConversation *conv, int *flags)
 323 {
 324         MMConversation *mmconv;
 325
 326         if (conv == NULL) {
 327                 /* XXX: This is just to avoid a crash (#2726).
 328                  *      We may want to create the conversation instead of returning from here
 329                  */
 330                 return FALSE;
 331         }
 332
 333         mmconv = mmconv_from_conv(conv);
 334
 335         purple_debug_misc("purple-musicmessaging", "Intercepted: %s\n", *message);
 336         if (strstr(*message, MUSICMESSAGING_PREFIX))
 337         {
 338                 char *parsed_message = strtok(strstr(*message, MUSICMESSAGING_PREFIX), "<");
 339                 purple_debug_misc("purple-musicmessaging", "Received an MM Message: %s\n", parsed_message);
 340
 341                 if (mmconv->started)
 342                 {
 343                         if (strstr(parsed_message, "request"))
 344                         {
 345                                 if (mmconv->originator)
 346                                 {
 347                                         int session = mmconv_from_conv_loc(conv);
 348                                         const char *id = purple_conversation_get_name(mmconv->conv);
 349                                         char *command;
 350                                         char *parameters;
 351
 352                                         purple_debug_misc("purple-musicmessaging", "Sending request to gscore.\n");
 353
 354                                         /* Get past the first two terms - '##MM##' and 'request' */
 355                                         strtok(parsed_message, " "); /* '##MM##' */
 356                                         strtok(NULL, " "); /* 'request' */
 357
 358                                         command = strtok(NULL, " ");
 359                                         parameters = strtok(NULL, "#");
 360
 361                                         send_change_request (session, id, command, parameters);
 362
 363                                 }
 364                         } else if (strstr(parsed_message, "confirm"))
 365                         {
 366                                 if (!mmconv->originator)
 367                                 {
 368                                         int session = mmconv_from_conv_loc(conv);
 369                                         char *command;
 370                                         char *parameters;
 371
 372                                         purple_debug_misc("purple-musicmessaging", "Sending confirmation to gscore.\n");
 373
 374                                         /* Get past the first two terms - '##MM##' and 'confirm' */
 375                                         strtok(parsed_message, " "); /* '##MM##' */
 376                                         strtok(NULL, " "); /* 'confirm' */
 377
 378                                         command = strtok(NULL, " ");
 379                                         parameters = strtok(NULL, "#");
 380
 381                                         send_change_confirmed (session, command, parameters);
 382                                 }
 383                         } else if (strstr(parsed_message, "failed"))
 384                         {
 385                                 char *id;
 386                                 char *command;
 387
 388                                 /* Get past the first two terms - '##MM##' and 'confirm' */
 389                                 strtok(parsed_message, " "); /* '##MM##' */
 390                                 strtok(NULL, " "); /* 'failed' */
 391
 392                                 id = strtok(NULL, " ");
 393                                 command = strtok(NULL, " ");
 394                                 /* char *parameters = strtok(NULL, "#"); DONT NEED PARAMETERS */
 395
 396                                 // TODO: Shouldn't this be strcmp() ?
 397                                 if (purple_conversation_get_name(mmconv->conv) == id)
 398                                 {
 399                                         purple_notify_message(plugin_pointer, PURPLE_NOTIFY_MSG_ERROR,
 400                                                             _("Music Messaging"),
 401                                                             _("There was a conflict in running the command:"), command, NULL, NULL, NULL);
 402                                 }
 403                         }
 404                 }
 405
 406                 message = NULL;
 407         }
 408         else if (strstr(*message, MUSICMESSAGING_START_MSG))
 409         {
 410                 purple_debug_misc("purple-musicmessaging", "Received MM request.\n");
 411                 if (!(mmconv->originator))
 412                 {
 413                         mmconv->requested = TRUE;
 414                         return FALSE;
 415                 }
 416
 417         }
 418         else if (strstr(*message, MUSICMESSAGING_CONFIRM_MSG))
 419         {
 420                 purple_debug_misc("purple-musicmessagin", "Received MM confirm.\n");
 421
 422                 if (mmconv->originator)
 423                 {
 424                         start_session(mmconv);
 425                         return FALSE;
 426                 }
 427         }
 428         else
 429         {
 430                 return FALSE;
 431                 /* Do nothing. */
 432         }
 433         return TRUE;
 434 }
 435
 436 static void send_request(MMConversation *mmconv)
 437 {
 438         PurpleConnection *connection = purple_conversation_get_connection(mmconv->conv);
 439         const char *convName = purple_conversation_get_name(mmconv->conv);
 440         purple_serv_send_im(connection, purple_message_new_outgoing(
 441                 convName, MUSICMESSAGING_START_MSG, 0));
 442 }
 443
 444 static void send_request_confirmed(MMConversation *mmconv)
 445 {
 446         PurpleConnection *connection = purple_conversation_get_connection(mmconv->conv);
 447         const char *convName = purple_conversation_get_name(mmconv->conv);
 448         purple_serv_send_im(connection, purple_message_new_outgoing(
 449                 convName, MUSICMESSAGING_CONFIRM_MSG, 0));
 450 }
 451
 452
 453 static gboolean
 454 start_session(MMConversation *mmconv)
 455 {
 456         run_editor(mmconv);
 457         return TRUE;
 458 }
 459
 460 static void session_end (MMConversation *mmconv)
 461 {
 462         mmconv->started = FALSE;
 463         mmconv->originator = FALSE;
 464         mmconv->requested = FALSE;
 465         kill_editor(mmconv);
 466 }
 467
 468 static void music_button_toggled (GtkWidget *widget, gpointer data)
 469 {
 470         MMConversation *mmconv = mmconv_from_conv(((MMConversation *) data)->conv);
 471         if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (widget)))
 472     {
 473                 if (((MMConversation *) data)->requested)
 474                 {
 475                         start_session(mmconv);
 476                         send_request_confirmed(mmconv);
 477                 }
 478                 else
 479                 {
 480                         ((MMConversation *) data)->originator = TRUE;
 481                         send_request((MMConversation *) data);
 482                 }
 483     } else {
 484                 session_end((MMConversation *)data);
 485     }
 486 }
 487
 488 static void set_editor_path (GtkWidget *button, GtkWidget *text_field)
 489 {
 490         const char * path = gtk_entry_get_text((GtkEntry*)text_field);
 491         purple_prefs_set_string("/plugins/gtk/musicmessaging/editor_path", path);
 492
 493 }
 494
 495 static void run_editor (MMConversation *mmconv)
 496 {
 497         GError *spawn_error = NULL;
 498         GString *session_id;
 499         gchar * args[4];
 500         args[0] = (gchar *)purple_prefs_get_string("/plugins/gtk/musicmessaging/editor_path");
 501
 502         args[1] = "-session_id";
 503         session_id = g_string_new("");
 504         g_string_append_printf(session_id, "%d", mmconv_from_conv_loc(mmconv->conv));
 505         args[2] = session_id->str;
 506
 507         args[3] = NULL;
 508
 509         if (!(g_spawn_async (".", args, NULL, 4, NULL, NULL, &(mmconv->pid), &spawn_error)))
 510         {
 511                 purple_notify_error(plugin_pointer, _("Error Running Editor"),
 512                                   _("The following error has occurred:"), spawn_error->message, NULL);
 513                 mmconv->started = FALSE;
 514         }
 515         else
 516         {
 517                 mmconv->started = TRUE;
 518         }
 519 }
 520
 521 static void kill_editor (MMConversation *mmconv)
 522 {
 523         if (mmconv->pid)
 524         {
 525                 kill(mmconv->pid, SIGINT);
 526                 mmconv->pid = 0;
 527         }
 528 }
 529
 530 static void init_conversation (PurpleConversation *conv)
 531 {
 532         MMConversation *mmconv;
 533         mmconv = g_malloc(sizeof(MMConversation));
 534
 535         mmconv->conv = conv;
 536         mmconv->started = FALSE;
 537         mmconv->originator = FALSE;
 538         mmconv->requested = FALSE;
 539
 540         add_button(mmconv);
 541
 542         conversations = g_list_append(conversations, mmconv);
 543 }
 544
 545 static void conv_destroyed (PurpleConversation *conv)
 546 {
 547         MMConversation *mmconv = mmconv_from_conv(conv);
 548
 549         remove_widget(mmconv->button);
 550         remove_widget(mmconv->seperator);
 551         if (mmconv->started)
 552         {
 553                 kill_editor(mmconv);
 554         }
 555         conversations = g_list_remove(conversations, mmconv);
 556 }
 557
 558 static void add_button (MMConversation *mmconv)
 559 {
 560 #if 0
 561         PurpleConversation *conv = mmconv->conv;
 562 #endif
 563
 564         GtkWidget *button, *image, *sep;
 565         gchar *file_path;
 566
 567         button = gtk_toggle_button_new();
 568         gtk_button_set_relief(GTK_BUTTON(button), GTK_RELIEF_NONE);
 569
 570         g_signal_connect(G_OBJECT(button), "toggled", G_CALLBACK(music_button_toggled), mmconv);
 571
 572         file_path = g_build_filename(PURPLE_DATADIR,
 573                 "pixmaps", "purple", "buttons", "music.png", NULL);
 574         image = gtk_image_new_from_file(file_path);
 575         g_free(file_path);
 576
 577         gtk_container_add((GtkContainer *)button, image);
 578
 579         sep = gtk_separator_new(GTK_ORIENTATION_VERTICAL);
 580
 581         mmconv->seperator = sep;
 582         mmconv->button = button;
 583
 584         gtk_widget_show(sep);
 585         gtk_widget_show(image);
 586         gtk_widget_show(button);
 587
 588 #if 0
 589         gtk_box_pack_start(GTK_BOX(PIDGIN_CONVERSATION(conv)->toolbar), sep, FALSE, FALSE, 0);
 590         gtk_box_pack_start(GTK_BOX(PIDGIN_CONVERSATION(conv)->toolbar), button, FALSE, FALSE, 0);
 591 #endif
 592 }
 593
 594 static void remove_widget (GtkWidget *button)
 595 {
 596         gtk_widget_hide(button);
 597         gtk_widget_destroy(button);
 598 }
 599
 600 static GtkWidget *
 601 get_config_frame(PurplePlugin *plugin)
 602 {
 603         GtkWidget *ret;
 604         GtkWidget *vbox;
 605
 606         GtkWidget *editor_path;
 607         GtkWidget *editor_path_label;
 608         GtkWidget *editor_path_button;
 609
 610         /* Outside container */
 611         ret = gtk_box_new(GTK_ORIENTATION_VERTICAL, 18);
 612         gtk_container_set_border_width(GTK_CONTAINER(ret), 10);
 613
 614         /* Configuration frame */
 615         vbox = pidgin_make_frame(ret, _("Music Messaging Configuration"));
 616
 617         /* Path to the score editor */
 618         editor_path = gtk_entry_new();
 619         editor_path_label = gtk_label_new(_("Score Editor Path"));
 620         editor_path_button = gtk_button_new_with_mnemonic(_("_Apply"));
 621
 622         gtk_entry_set_text((GtkEntry*)editor_path, "/usr/local/bin/gscore");
 623
 624         g_signal_connect(G_OBJECT(editor_path_button), "clicked",
 625                                          G_CALLBACK(set_editor_path), editor_path);
 626
 627         gtk_box_pack_start(GTK_BOX(vbox), editor_path_label, FALSE, FALSE, 0);
 628         gtk_box_pack_start(GTK_BOX(vbox), editor_path, FALSE, FALSE, 0);
 629         gtk_box_pack_start(GTK_BOX(vbox), editor_path_button, FALSE, FALSE, 0);
 630
 631         gtk_widget_show_all(ret);
 632
 633         return ret;
 634 }
 635
 636 static PidginPluginInfo *
 637 plugin_query(GError **error) {
 638         const gchar * const authors[] = {
 639                 "Christian Muise <christian.muise@gmail.com>",
 640                 NULL
 641         };
 642
 643         return pidgin_plugin_info_new(
 644                 "id",                   MUSICMESSAGING_PLUGIN_ID,
 645                 "name",                 N_("Music Messaging"),
 646                 "version",              DISPLAY_VERSION,
 647                 "category",             N_("Music"),
 648                 "summary",              N_("Music Messaging Plugin for "
 649                                            "collaborative composition."),
 650                 "description",          N_("The Music Messaging Plugin allows a "
 651                                            "number of users to simultaneously work "
 652                                            "on a piece of music by editing a common "
 653                                            "score in real-time."),
 654                 "authors",              authors,
 655                 "website",              PURPLE_WEBSITE,
 656                 "abi-version",          PURPLE_ABI_VERSION,
 657                 "gtk-config-frame-cb",  get_config_frame,
 658                 NULL
 659         );
 660 }
 661
 662 static gboolean
 663 plugin_load(PurplePlugin *plugin, GError **error) {
 664         void *conv_list_handle;
 665         GList *l;
 666
 667         PURPLE_DBUS_RETURN_FALSE_IF_DISABLED(plugin);
 668
 669         purple_prefs_add_none("/plugins/gtk/musicmessaging");
 670         purple_prefs_add_string("/plugins/gtk/musicmessaging/editor_path", "/usr/bin/gscore");
 671
 672     /* First, we have to register our four exported functions with the
 673        main purple dbus loop.  Without this statement, the purple dbus
 674        code wouldn't know about our functions. */
 675     PURPLE_DBUS_REGISTER_BINDINGS(plugin);
 676
 677         /* Keep the plugin for reference (needed for notify's) */
 678         plugin_pointer = plugin;
 679
 680         /* Add the button to all the current conversations */
 681         for (l = purple_conversations_get_all(); l != NULL; l = l->next)
 682                 init_conversation((PurpleConversation *)l->data);
 683
 684         /* Listen for any new conversations */
 685         conv_list_handle = purple_conversations_get_handle();
 686
 687         purple_signal_connect(conv_list_handle, "conversation-created",
 688                                         plugin, PURPLE_CALLBACK(init_conversation), NULL);
 689
 690         /* Listen for conversations that are ending */
 691         purple_signal_connect(conv_list_handle, "deleting-conversation",
 692                                         plugin, PURPLE_CALLBACK(conv_destroyed), NULL);
 693
 694         /* Listen for sending/receiving messages to replace tags */
 695         purple_signal_connect(conv_list_handle, "sending-im-msg",
 696                                         plugin, PURPLE_CALLBACK(intercept_sent), NULL);
 697         purple_signal_connect(conv_list_handle, "receiving-im-msg",
 698                                         plugin, PURPLE_CALLBACK(intercept_received), NULL);
 699
 700         return TRUE;
 701 }
 702
 703 static gboolean
 704 plugin_unload(PurplePlugin *plugin, GError **error) {
 705         MMConversation *mmconv = NULL;
 706
 707         while (conversations != NULL)
 708         {
 709                 mmconv = conversations->data;
 710                 conv_destroyed(mmconv->conv);
 711         }
 712         return TRUE;
 713 }
 714
 715 PURPLE_PLUGIN_INIT(musicmessaging, plugin_query, plugin_load, plugin_unload);