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