shell/rb-shell-clipboard.c

   1 /* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*-
   2  *
   3  *  arch-tag: Implementation of song cut/paste handler object
   4  *
   5  *  Copyright (C) 2002 Jorn Baayen <jorn@nl.linux.org>
   6  *  Copyright (C) 2003,2004 Colin Walters <walters@verbum.org>
   7  *
   8  *  This program is free software; you can redistribute it and/or modify
   9  *  it under the terms of the GNU General Public License as published by
  10  *  the Free Software Foundation; either version 2 of the License, or
  11  *  (at your option) any later version.
  12  *
  13  *  This program is distributed in the hope that it will be useful,
  14  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  *  GNU General Public License for more details.
  17  *
  18  *  You should have received a copy of the GNU General Public License
  19  *  along with this program; if not, write to the Free Software
  20  *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301  USA.
  21  *
  22  */
  23
  24 #include <config.h>
  25
  26 #include <glib/gi18n.h>
  27 #include <gtk/gtk.h>
  28 #include <gtk/gtkstock.h>
  29
  30 #include "rb-shell-clipboard.h"
  31 #include "rb-playlist-manager.h"
  32 #include "rb-play-queue-source.h"
  33 #include "rb-sourcelist-model.h"
  34 #include "rhythmdb.h"
  35 #include "rb-debug.h"
  36
  37 static void rb_shell_clipboard_class_init (RBShellClipboardClass *klass);
  38 static void rb_shell_clipboard_init (RBShellClipboard *shell_clipboard);
  39 static GObject *rb_shell_clipboard_constructor (GType type, guint n_construct_properties,
  40                                                 GObjectConstructParam *construct_properties);
  41 static void rb_shell_clipboard_finalize (GObject *object);
  42 static void rb_shell_clipboard_set_property (GObject *object,
  43                                              guint prop_id,
  44                                              const GValue *value,
  45                                              GParamSpec *pspec);
  46 static void rb_shell_clipboard_get_property (GObject *object,
  47                                              guint prop_id,
  48                                              GValue *value,
  49                                              GParamSpec *pspec);
  50 static void rb_shell_clipboard_sync (RBShellClipboard *clipboard);
  51 static void rb_shell_clipboard_cmd_select_all (GtkAction *action,
  52                                                RBShellClipboard *clipboard);
  53 static void rb_shell_clipboard_cmd_select_none (GtkAction *action,
  54                                                 RBShellClipboard *clipboard);
  55 static void rb_shell_clipboard_cmd_cut (GtkAction *action,
  56                                         RBShellClipboard *clipboard);
  57 static void rb_shell_clipboard_cmd_copy (GtkAction *action,
  58                                          RBShellClipboard *clipboard);
  59 static void rb_shell_clipboard_cmd_paste (GtkAction *action,
  60                                           RBShellClipboard *clipboard);
  61 static void rb_shell_clipboard_cmd_delete (GtkAction *action,
  62                                            RBShellClipboard *clipboard);
  63 static void rb_shell_clipboard_cmd_queue_delete (GtkAction *action,
  64                                                  RBShellClipboard *clipboard);
  65 static void rb_shell_clipboard_cmd_move_to_trash (GtkAction *action,
  66                                                   RBShellClipboard *clipboard);
  67 static void rb_shell_clipboard_set (RBShellClipboard *clipboard,
  68                                     GList *nodes);
  69 static gboolean rb_shell_clipboard_idle_poll_deletions (RBShellClipboard *clipboard);
  70 static void rb_shell_clipboard_playlist_added_cb (RBPlaylistManager *mgr,
  71                                                   RBPlaylistSource *source,
  72                                                   RBShellClipboard *clipboard);
  73 static void rb_shell_clipboard_entry_deleted_cb (RhythmDB *db,
  74                                                  RhythmDBEntry *entry,
  75                                                  RBShellClipboard *clipboard);
  76 static void rb_shell_clipboard_entryview_changed_cb (RBEntryView *view,
  77                                                      RBShellClipboard *clipboard);
  78 static void rb_shell_clipboard_entries_changed_cb (RBEntryView *view,
  79                                                    gpointer stuff,
  80                                                    RBShellClipboard *clipboard);
  81 static void rb_shell_clipboard_cmd_add_to_playlist_new (GtkAction *action,
  82                                                         RBShellClipboard *clipboard);
  83 static void rb_shell_clipboard_cmd_add_song_to_queue (GtkAction *action,
  84                                                       RBShellClipboard *clipboard);
  85 static void rb_shell_clipboard_cmd_song_info (GtkAction *action,
  86                                               RBShellClipboard *clipboard);
  87 static void rb_shell_clipboard_cmd_queue_song_info (GtkAction *action,
  88                                                     RBShellClipboard *clipboard);
  89 static void rebuild_playlist_menu (RBShellClipboard *clipboard);
  90 static gboolean rebuild_playlist_menu_idle (RBShellClipboard *clipboard);
  91
  92 struct RBShellClipboardPrivate
  93 {
  94         RhythmDB *db;
  95         RBSource *source;
  96         RBStaticPlaylistSource *queue_source;
  97         RBPlaylistManager *playlist_manager;
  98
  99         GtkUIManager *ui_mgr;
 100         GtkActionGroup *actiongroup;
 101         guint playlist_menu_ui_id;
 102
 103         GHashTable *signal_hash;
 104
 105         GAsyncQueue *deleted_queue;
 106
 107         guint idle_deletion_id, idle_sync_id, idle_playlist_id;
 108
 109         GList *entries;
 110 };
 111
 112 #define RB_SHELL_CLIPBOARD_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), RB_TYPE_SHELL_CLIPBOARD, RBShellClipboardPrivate))
 113
 114 enum
 115 {
 116         PROP_0,
 117         PROP_SOURCE,
 118         PROP_ACTION_GROUP,
 119         PROP_DB,
 120         PROP_QUEUE_SOURCE,
 121         PROP_PLAYLIST_MANAGER,
 122         PROP_UI_MANAGER,
 123 };
 124
 125 static GtkActionEntry rb_shell_clipboard_actions [] =
 126 {
 127         { "EditSelectAll", NULL, N_("Select _All"), "<control>A",
 128           N_("Select all songs"),
 129           G_CALLBACK (rb_shell_clipboard_cmd_select_all) },
 130         { "EditSelectNone", NULL, N_("D_eselect All"), "<shift><control>A",
 131           N_("Deselect all songs"),
 132           G_CALLBACK (rb_shell_clipboard_cmd_select_none) },
 133         { "EditCut", GTK_STOCK_CUT, N_("Cu_t"), "<control>X",
 134           N_("Cut selection"),
 135           G_CALLBACK (rb_shell_clipboard_cmd_cut) },
 136         { "EditCopy", GTK_STOCK_COPY, N_("_Copy"), "<control>C",
 137           N_("Copy selection"),
 138           G_CALLBACK (rb_shell_clipboard_cmd_copy) },
 139         { "EditPaste", GTK_STOCK_PASTE, N_("_Paste"), "<control>V",
 140           N_("Paste selection"),
 141           G_CALLBACK (rb_shell_clipboard_cmd_paste) },
 142         { "EditDelete", GTK_STOCK_REMOVE, N_("_Remove"), NULL,
 143           N_("Remove selection"),
 144           G_CALLBACK (rb_shell_clipboard_cmd_delete) },
 145         { "EditMovetoTrash", GTK_STOCK_DELETE, N_("_Move to Trash"), "<control>T",
 146           N_("Move selection to the trash"),
 147           G_CALLBACK (rb_shell_clipboard_cmd_move_to_trash) },
 148
 149         { "EditPlaylistAdd", NULL, N_("Add to P_laylist") },
 150         { "EditPlaylistAddNew", GTK_STOCK_ADD, N_("_New Playlist..."), NULL,
 151           N_("Add the selected songs to a new playlist"),
 152           G_CALLBACK (rb_shell_clipboard_cmd_add_to_playlist_new) },
 153         { "AddToQueue", GTK_STOCK_ADD, N_("Add _to Play Queue"), NULL,
 154           N_("Add the selected songs to the play queue"),
 155           G_CALLBACK (rb_shell_clipboard_cmd_add_song_to_queue) },
 156         { "QueueDelete", GTK_STOCK_REMOVE, N_("Remove"), NULL,
 157           N_("Remove selection"),
 158           G_CALLBACK (rb_shell_clipboard_cmd_queue_delete) },
 159
 160         { "MusicProperties", GTK_STOCK_PROPERTIES, N_("_Properties"), "<Alt>Return",
 161           N_("Show information on the selected song"),
 162           G_CALLBACK (rb_shell_clipboard_cmd_song_info) },
 163         { "QueueMusicProperties", GTK_STOCK_PROPERTIES, N_("_Properties"), NULL,
 164           N_("Show information on the selected song"),
 165           G_CALLBACK (rb_shell_clipboard_cmd_queue_song_info) },
 166 };
 167 static guint rb_shell_clipboard_n_actions = G_N_ELEMENTS (rb_shell_clipboard_actions);
 168
 169 static const char *playlist_menu_paths[] = {
 170         "/MenuBar/EditMenu/EditPlaylistAddMenu/EditPlaylistAddPlaceholder",
 171         "/BrowserSourceViewPopup/BrowserSourcePopupPlaylistAdd/BrowserSourcePopupPlaylistAddPlaceholder",
 172         "/PlaylistViewPopup/PlaylistPopupPlaylistAdd/PlaylistPopupPlaylistAddPlaceholder",
 173 };
 174 static guint num_playlist_menu_paths = G_N_ELEMENTS (playlist_menu_paths);
 175
 176 G_DEFINE_TYPE (RBShellClipboard, rb_shell_clipboard, G_TYPE_OBJECT)
 177
 178 static void
 179 rb_shell_clipboard_class_init (RBShellClipboardClass *klass)
 180 {
 181         GObjectClass *object_class = G_OBJECT_CLASS (klass);
 182
 183         object_class->finalize = rb_shell_clipboard_finalize;
 184         object_class->constructor = rb_shell_clipboard_constructor;
 185
 186         object_class->set_property = rb_shell_clipboard_set_property;
 187         object_class->get_property = rb_shell_clipboard_get_property;
 188
 189         g_object_class_install_property (object_class,
 190                                          PROP_SOURCE,
 191                                          g_param_spec_object ("source",
 192                                                               "RBSource",
 193                                                               "RBSource object",
 194                                                               RB_TYPE_SOURCE,
 195                                                               G_PARAM_READWRITE));
 196         g_object_class_install_property (object_class,
 197                                          PROP_ACTION_GROUP,
 198                                          g_param_spec_object ("action-group",
 199                                                               "GtkActionGroup",
 200                                                               "GtkActionGroup object",
 201                                                               GTK_TYPE_ACTION_GROUP,
 202                                                               G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
 203         g_object_class_install_property (object_class,
 204                                          PROP_DB,
 205                                          g_param_spec_object ("db",
 206                                                               "RhythmDB",
 207                                                               "RhythmDB database",
 208                                                               RHYTHMDB_TYPE,
 209                                                               G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
 210         g_object_class_install_property (object_class,
 211                                          PROP_QUEUE_SOURCE,
 212                                          g_param_spec_object ("queue-source",
 213                                                               "RBPlaylistSource",
 214                                                               "RBPlaylistSource object",
 215                                                               RB_TYPE_PLAYLIST_SOURCE,
 216                                                               G_PARAM_READWRITE));
 217         g_object_class_install_property (object_class,
 218                                          PROP_PLAYLIST_MANAGER,
 219                                          g_param_spec_object ("playlist-manager",
 220                                                               "RBPlaylistManager",
 221                                                               "RBPlaylistManager object",
 222                                                               RB_TYPE_PLAYLIST_MANAGER,
 223                                                               G_PARAM_READWRITE));
 224         g_object_class_install_property (object_class,
 225                                          PROP_UI_MANAGER,
 226                                          g_param_spec_object ("ui-manager",
 227                                                               "GtkUIManager",
 228                                                               "GtkUIManager object",
 229                                                               GTK_TYPE_UI_MANAGER,
 230                                                               G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
 231
 232         g_type_class_add_private (klass, sizeof (RBShellClipboardPrivate));
 233 }
 234
 235 static void
 236 rb_shell_clipboard_init (RBShellClipboard *shell_clipboard)
 237 {
 238         shell_clipboard->priv = RB_SHELL_CLIPBOARD_GET_PRIVATE (shell_clipboard);
 239
 240         shell_clipboard->priv->signal_hash = g_hash_table_new_full (g_direct_hash, g_direct_equal,
 241                                                                     NULL, g_free);
 242
 243         shell_clipboard->priv->deleted_queue = g_async_queue_new ();
 244
 245         shell_clipboard->priv->idle_deletion_id = g_idle_add ((GSourceFunc) rb_shell_clipboard_idle_poll_deletions, shell_clipboard);
 246 }
 247
 248 static void
 249 unset_source_internal (RBShellClipboard *clipboard)
 250 {
 251         if (clipboard->priv->source != NULL) {
 252                 RBEntryView *songs = rb_source_get_entry_view (clipboard->priv->source);
 253
 254                 if (songs) {
 255                         g_signal_handlers_disconnect_by_func (G_OBJECT (songs),
 256                                                               G_CALLBACK (rb_shell_clipboard_entryview_changed_cb),
 257                                                               clipboard);
 258                         g_signal_handlers_disconnect_by_func (G_OBJECT (songs),
 259                                                               G_CALLBACK (rb_shell_clipboard_entries_changed_cb),
 260                                                               clipboard);
 261                 }
 262         }
 263         clipboard->priv->source = NULL;
 264 }
 265
 266 static void
 267 rb_shell_clipboard_finalize (GObject *object)
 268 {
 269         RBShellClipboard *shell_clipboard;
 270
 271         g_return_if_fail (object != NULL);
 272         g_return_if_fail (RB_IS_SHELL_CLIPBOARD (object));
 273
 274         shell_clipboard = RB_SHELL_CLIPBOARD (object);
 275
 276         g_return_if_fail (shell_clipboard->priv != NULL);
 277
 278         /* release references to the source */
 279         unset_source_internal (shell_clipboard);
 280
 281         g_hash_table_destroy (shell_clipboard->priv->signal_hash);
 282
 283         g_list_foreach (shell_clipboard->priv->entries, (GFunc)rhythmdb_entry_unref, NULL);
 284         g_list_free (shell_clipboard->priv->entries);
 285
 286         g_async_queue_unref (shell_clipboard->priv->deleted_queue);
 287
 288         if (shell_clipboard->priv->idle_sync_id)
 289                 g_source_remove (shell_clipboard->priv->idle_sync_id);
 290         if (shell_clipboard->priv->idle_deletion_id)
 291                 g_source_remove (shell_clipboard->priv->idle_deletion_id);
 292         if (shell_clipboard->priv->idle_playlist_id)
 293                 g_source_remove (shell_clipboard->priv->idle_playlist_id);
 294
 295         G_OBJECT_CLASS (rb_shell_clipboard_parent_class)->finalize (object);
 296 }
 297
 298 static GObject *
 299 rb_shell_clipboard_constructor (GType type, guint n_construct_properties,
 300                                 GObjectConstructParam *construct_properties)
 301 {
 302         RBShellClipboard *clip;
 303         RBShellClipboardClass *klass;
 304         GObjectClass *parent_class;
 305
 306         klass = RB_SHELL_CLIPBOARD_CLASS (g_type_class_peek (RB_TYPE_SHELL_CLIPBOARD));
 307
 308         parent_class = G_OBJECT_CLASS (rb_shell_clipboard_parent_class);
 309         clip = RB_SHELL_CLIPBOARD (parent_class->constructor (type,
 310                                                               n_construct_properties,
 311                                                               construct_properties));
 312
 313         g_signal_connect_object (G_OBJECT (clip->priv->db),
 314                                  "entry_deleted",
 315                                  G_CALLBACK (rb_shell_clipboard_entry_deleted_cb),
 316                                  clip, 0);
 317
 318         return G_OBJECT (clip);
 319 }
 320
 321 static void
 322 rb_shell_clipboard_set_source_internal (RBShellClipboard *clipboard,
 323                                         RBSource *source)
 324 {
 325         unset_source_internal (clipboard);
 326
 327         clipboard->priv->source = source;
 328         rb_debug ("selected source %p", source);
 329
 330         rb_shell_clipboard_sync (clipboard);
 331
 332         if (clipboard->priv->source != NULL) {
 333                 RBEntryView *songs = rb_source_get_entry_view (clipboard->priv->source);
 334
 335                 if (songs) {
 336                         g_signal_connect_object (G_OBJECT (songs),
 337                                                  "selection-changed",
 338                                                  G_CALLBACK (rb_shell_clipboard_entryview_changed_cb),
 339                                                  clipboard, 0);
 340                         g_signal_connect_object (G_OBJECT (songs),
 341                                                  "entry-added",
 342                                                  G_CALLBACK (rb_shell_clipboard_entries_changed_cb),
 343                                                  clipboard, 0);
 344                         g_signal_connect_object (G_OBJECT (songs),
 345                                                  "entry-deleted",
 346                                                  G_CALLBACK (rb_shell_clipboard_entries_changed_cb),
 347                                                  clipboard, 0);
 348                         g_signal_connect_object (G_OBJECT (songs),
 349                                                  "entries-replaced",
 350                                                  G_CALLBACK (rb_shell_clipboard_entryview_changed_cb),
 351                                                  clipboard, 0);
 352                 }
 353         }
 354
 355         rebuild_playlist_menu (clipboard);
 356 }
 357
 358 static void
 359 rb_shell_clipboard_set_property (GObject *object,
 360                                  guint prop_id,
 361                                  const GValue *value,
 362                                  GParamSpec *pspec)
 363 {
 364         RBShellClipboard *clipboard = RB_SHELL_CLIPBOARD (object);
 365
 366         switch (prop_id)
 367         {
 368         case PROP_SOURCE:
 369                 rb_shell_clipboard_set_source_internal (clipboard, g_value_get_object (value));
 370                 break;
 371         case PROP_ACTION_GROUP:
 372                 clipboard->priv->actiongroup = g_value_get_object (value);
 373                 gtk_action_group_add_actions (clipboard->priv->actiongroup,
 374                                               rb_shell_clipboard_actions,
 375                                               rb_shell_clipboard_n_actions,
 376                                               clipboard);
 377                 break;
 378         case PROP_DB:
 379                 clipboard->priv->db = g_value_get_object (value);
 380                 break;
 381         case PROP_UI_MANAGER:
 382                 clipboard->priv->ui_mgr = g_value_get_object (value);
 383                 break;
 384         case PROP_PLAYLIST_MANAGER:
 385                 if (clipboard->priv->playlist_manager != NULL) {
 386                         g_signal_handlers_disconnect_by_func (clipboard->priv->playlist_manager,
 387                                                               G_CALLBACK (rb_shell_clipboard_playlist_added_cb),
 388                                                               clipboard);
 389                 }
 390
 391                 clipboard->priv->playlist_manager = g_value_get_object (value);
 392                 if (clipboard->priv->playlist_manager != NULL) {
 393                         g_signal_connect_object (G_OBJECT (clipboard->priv->playlist_manager),
 394                                                  "playlist-added", G_CALLBACK (rb_shell_clipboard_playlist_added_cb),
 395                                                  clipboard, 0);
 396
 397                         rebuild_playlist_menu (clipboard);
 398                 }
 399
 400                 break;
 401         case PROP_QUEUE_SOURCE:
 402                 if (clipboard->priv->queue_source != NULL) {
 403                         RBEntryView *sidebar;
 404                         g_object_get (clipboard->priv->queue_source, "sidebar", &sidebar, NULL);
 405                         g_signal_handlers_disconnect_by_func (sidebar,
 406                                                               G_CALLBACK (rb_shell_clipboard_entryview_changed_cb),
 407                                                               clipboard);
 408                         g_object_unref (sidebar);
 409                 }
 410
 411                 clipboard->priv->queue_source = g_value_get_object (value);
 412                 if (clipboard->priv->queue_source != NULL) {
 413                         RBEntryView *sidebar;
 414                         g_object_get (clipboard->priv->queue_source, "sidebar", &sidebar, NULL);
 415                         g_signal_connect_object (G_OBJECT (sidebar), "selection-changed",
 416                                                  G_CALLBACK (rb_shell_clipboard_entryview_changed_cb),
 417                                                  clipboard, 0);
 418                         g_object_unref (sidebar);
 419                 }
 420                 break;
 421         default:
 422                 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 423                 break;
 424         }
 425 }
 426
 427 static void
 428 rb_shell_clipboard_get_property (GObject *object,
 429                                  guint prop_id,
 430                                  GValue *value,
 431                                  GParamSpec *pspec)
 432 {
 433         RBShellClipboard *clipboard = RB_SHELL_CLIPBOARD (object);
 434
 435         switch (prop_id)
 436         {
 437         case PROP_SOURCE:
 438                 g_value_set_object (value, clipboard->priv->source);
 439                 break;
 440         case PROP_ACTION_GROUP:
 441                 g_value_set_object (value, clipboard->priv->actiongroup);
 442                 break;
 443         case PROP_DB:
 444                 g_value_set_object (value, clipboard->priv->db);
 445                 break;
 446         case PROP_UI_MANAGER:
 447                 g_value_set_object (value, clipboard->priv->ui_mgr);
 448                 break;
 449         case PROP_PLAYLIST_MANAGER:
 450                 g_value_set_object (value, clipboard->priv->playlist_manager);
 451                 break;
 452         case PROP_QUEUE_SOURCE:
 453                 g_value_set_object (value, clipboard->priv->queue_source);
 454                 break;
 455         default:
 456                 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 457                 break;
 458         }
 459 }
 460
 461 void
 462 rb_shell_clipboard_set_source (RBShellClipboard *clipboard,
 463                                RBSource *source)
 464 {
 465         g_return_if_fail (RB_IS_SHELL_CLIPBOARD (clipboard));
 466         if (source != NULL)
 467                 g_return_if_fail (RB_IS_SOURCE (source));
 468
 469         g_object_set (G_OBJECT (clipboard), "source", source, NULL);
 470 }
 471
 472 RBShellClipboard *
 473 rb_shell_clipboard_new (GtkActionGroup *actiongroup,
 474                         GtkUIManager *ui_mgr,
 475                         RhythmDB *db)
 476 {
 477         return g_object_new (RB_TYPE_SHELL_CLIPBOARD,
 478                              "action-group", actiongroup,
 479                              "ui-manager", ui_mgr,
 480                              "db", db,
 481                              NULL);
 482 }
 483
 484 static gboolean
 485 rb_shell_clipboard_sync_idle (RBShellClipboard *clipboard)
 486 {
 487         GDK_THREADS_ENTER ();
 488         rb_shell_clipboard_sync (clipboard);
 489         clipboard->priv->idle_sync_id = 0;
 490         GDK_THREADS_LEAVE ();
 491
 492         return FALSE;
 493 }
 494
 495 static void
 496 rb_shell_clipboard_sync (RBShellClipboard *clipboard)
 497 {
 498         RBEntryView *view;
 499         gboolean have_selection = FALSE;
 500         gboolean have_sidebar_selection = FALSE;
 501         gboolean can_cut = FALSE;
 502         gboolean can_paste = FALSE;
 503         gboolean can_delete = FALSE;
 504         gboolean can_copy = FALSE;
 505         gboolean can_add_to_queue = FALSE;
 506         gboolean can_move_to_trash = FALSE;
 507         gboolean can_select_all = FALSE;
 508         GtkAction *action;
 509         RhythmDBEntryType entry_type;
 510
 511         if (!clipboard->priv->source)
 512                 return;
 513
 514         view = rb_source_get_entry_view (clipboard->priv->source);
 515         if (view) {
 516                 have_selection = rb_entry_view_have_selection (view);
 517                 can_select_all = !rb_entry_view_have_complete_selection (view);
 518         }
 519
 520         if (clipboard->priv->queue_source) {
 521                 RBEntryView *sidebar;
 522                 g_object_get (clipboard->priv->queue_source, "sidebar", &sidebar, NULL);
 523                 have_sidebar_selection = rb_entry_view_have_selection (sidebar);
 524                 g_object_unref (sidebar);
 525         }
 526
 527         rb_debug ("syncing clipboard");
 528
 529         if (g_list_length (clipboard->priv->entries) > 0)
 530                 can_paste = rb_source_can_paste (clipboard->priv->source);
 531
 532         if (have_selection) {
 533                 can_cut = rb_source_can_cut (clipboard->priv->source);
 534                 can_delete = rb_source_can_delete (clipboard->priv->source);
 535                 can_copy = rb_source_can_copy (clipboard->priv->source);
 536                 can_move_to_trash = rb_source_can_move_to_trash (clipboard->priv->source);
 537
 538                 if (clipboard->priv->queue_source)
 539                         can_add_to_queue = rb_source_can_add_to_queue (clipboard->priv->source);
 540         }
 541
 542         action = gtk_action_group_get_action (clipboard->priv->actiongroup, "EditCut");
 543         g_object_set (G_OBJECT (action), "sensitive", can_cut, NULL);
 544
 545         action = gtk_action_group_get_action (clipboard->priv->actiongroup, "EditDelete");
 546         g_object_set (G_OBJECT (action), "sensitive", can_delete, NULL);
 547
 548         action = gtk_action_group_get_action (clipboard->priv->actiongroup, "EditMovetoTrash");
 549         g_object_set (G_OBJECT (action), "sensitive", can_move_to_trash, NULL);
 550
 551         action = gtk_action_group_get_action (clipboard->priv->actiongroup, "EditCopy");
 552         g_object_set (G_OBJECT (action), "sensitive", can_copy, NULL);
 553
 554         action = gtk_action_group_get_action (clipboard->priv->actiongroup,"EditPaste");
 555         g_object_set (G_OBJECT (action), "sensitive", can_paste, NULL);
 556
 557         action = gtk_action_group_get_action (clipboard->priv->actiongroup, "EditPlaylistAdd");
 558         g_object_set (G_OBJECT (action), "sensitive", can_copy, NULL);
 559
 560         action = gtk_action_group_get_action (clipboard->priv->actiongroup, "AddToQueue");
 561         g_object_set (G_OBJECT (action), "sensitive", can_add_to_queue, NULL);
 562
 563         action = gtk_action_group_get_action (clipboard->priv->actiongroup, "MusicProperties");
 564         g_object_set (G_OBJECT (action), "sensitive", have_selection, NULL);
 565
 566         action = gtk_action_group_get_action (clipboard->priv->actiongroup, "QueueMusicProperties");
 567         g_object_set (G_OBJECT (action), "sensitive", have_sidebar_selection, NULL);
 568
 569         action = gtk_action_group_get_action (clipboard->priv->actiongroup, "QueueDelete");
 570         g_object_set (G_OBJECT (action), "sensitive", have_sidebar_selection, NULL);
 571
 572         action = gtk_action_group_get_action (clipboard->priv->actiongroup, "EditSelectAll");
 573         g_object_set (G_OBJECT (action), "sensitive", can_select_all, NULL);
 574
 575         action = gtk_action_group_get_action (clipboard->priv->actiongroup, "EditSelectNone");
 576         g_object_set (G_OBJECT (action), "sensitive", have_selection, NULL);
 577
 578         /* disable the whole add-to-playlist menu if we can't add to a playlist
 579          * FIXME: change this when we support non-library playilst adding
 580          */
 581         action = gtk_action_group_get_action (clipboard->priv->actiongroup, "EditPlaylistAdd");
 582         g_object_get (clipboard->priv->source, "entry-type", &entry_type, NULL);
 583         gtk_action_set_sensitive (action, (entry_type == RHYTHMDB_ENTRY_TYPE_SONG));
 584         g_boxed_free (RHYTHMDB_TYPE_ENTRY_TYPE, entry_type);
 585 }
 586
 587 static void
 588 rb_shell_clipboard_cmd_select_all (GtkAction *action,
 589                                    RBShellClipboard *clipboard)
 590 {
 591         RBEntryView *entryview;
 592         rb_debug ("select all");
 593
 594         entryview = rb_source_get_entry_view (clipboard->priv->source);
 595         rb_entry_view_select_all (entryview);
 596 }
 597
 598 static void
 599 rb_shell_clipboard_cmd_select_none (GtkAction *action,
 600                                     RBShellClipboard *clipboard)
 601 {
 602         RBEntryView *entryview;
 603         rb_debug ("select none");
 604
 605         entryview = rb_source_get_entry_view (clipboard->priv->source);
 606         rb_entry_view_select_none (entryview);
 607 }
 608
 609 static void
 610 rb_shell_clipboard_cmd_cut (GtkAction *action,
 611                             RBShellClipboard *clipboard)
 612 {
 613         rb_debug ("cut");
 614         rb_shell_clipboard_set (clipboard,
 615                                 rb_source_cut (clipboard->priv->source));
 616 }
 617
 618 static void
 619 rb_shell_clipboard_cmd_copy (GtkAction *action,
 620                              RBShellClipboard *clipboard)
 621 {
 622         rb_debug ("copy");
 623         rb_shell_clipboard_set (clipboard,
 624                                 rb_source_copy (clipboard->priv->source));
 625 }
 626
 627 static void
 628 rb_shell_clipboard_cmd_paste (GtkAction *action,
 629                               RBShellClipboard *clipboard)
 630 {
 631         rb_debug ("paste");
 632         rb_source_paste (clipboard->priv->source, clipboard->priv->entries);
 633 }
 634
 635 static void
 636 rb_shell_clipboard_cmd_delete (GtkAction *action,
 637                                RBShellClipboard *clipboard)
 638 {
 639         rb_debug ("delete");
 640         rb_source_delete (clipboard->priv->source);
 641 }
 642
 643 static void
 644 rb_shell_clipboard_cmd_queue_delete (GtkAction *action,
 645                                      RBShellClipboard *clipboard)
 646 {
 647         rb_debug ("delete");
 648         rb_play_queue_source_sidebar_delete (RB_PLAY_QUEUE_SOURCE (clipboard->priv->queue_source));
 649 }
 650
 651 static void
 652 rb_shell_clipboard_cmd_move_to_trash (GtkAction *action,
 653                                       RBShellClipboard *clipboard)
 654 {
 655         rb_debug ("movetotrash");
 656         rb_source_move_to_trash (clipboard->priv->source);
 657 }
 658
 659 static void
 660 rb_shell_clipboard_set (RBShellClipboard *clipboard,
 661                         GList *entries)
 662 {
 663         if (clipboard->priv->entries != NULL) {
 664                 g_list_foreach (clipboard->priv->entries, (GFunc)rhythmdb_entry_unref, NULL);
 665                 g_list_free (clipboard->priv->entries);
 666         }
 667
 668         clipboard->priv->entries = entries;
 669 }
 670
 671 static gboolean
 672 rb_shell_clipboard_process_deletions (RBShellClipboard *clipboard)
 673 {
 674         RhythmDBEntry *entry;
 675
 676         if (clipboard->priv->entries) {
 677                 GList *tem, *finished = NULL;
 678                 gboolean processed = FALSE;
 679
 680                 while ((entry = g_async_queue_try_pop (clipboard->priv->deleted_queue)) != NULL) {
 681                         clipboard->priv->entries = g_list_remove (clipboard->priv->entries, entry);
 682                         finished = g_list_prepend (finished, entry);
 683                         processed = TRUE;
 684                 }
 685
 686                 if (processed)
 687                         rb_shell_clipboard_sync (clipboard);
 688
 689                 for (tem = finished; tem; tem = tem->next)
 690                         rhythmdb_entry_unref (tem->data);
 691                 g_list_free (finished);
 692
 693                 return processed;
 694         } else {
 695                 /* Fast path for when there's nothing in the clipboard */
 696                 while ((entry = g_async_queue_try_pop (clipboard->priv->deleted_queue)) != NULL)
 697                         rhythmdb_entry_unref (entry);
 698                 return FALSE;
 699         }
 700 }
 701
 702 static gboolean
 703 rb_shell_clipboard_idle_poll_deletions (RBShellClipboard *clipboard)
 704 {
 705         gboolean did_sync;
 706
 707         GDK_THREADS_ENTER ();
 708
 709         did_sync = rb_shell_clipboard_process_deletions (clipboard);
 710
 711         if (did_sync)
 712                 clipboard->priv->idle_deletion_id =
 713                         g_idle_add_full (G_PRIORITY_LOW,
 714                                          (GSourceFunc) rb_shell_clipboard_idle_poll_deletions,
 715                                          clipboard, NULL);
 716         else
 717                 clipboard->priv->idle_deletion_id =
 718                         g_timeout_add (300,
 719                                        (GSourceFunc) rb_shell_clipboard_idle_poll_deletions,
 720                                        clipboard);
 721
 722         GDK_THREADS_LEAVE ();
 723
 724         return FALSE;
 725 }
 726
 727 static void
 728 rb_shell_clipboard_entry_deleted_cb (RhythmDB *db,
 729                                      RhythmDBEntry *entry,
 730                                      RBShellClipboard *clipboard)
 731 {
 732         rhythmdb_entry_ref (entry);
 733         g_async_queue_push (clipboard->priv->deleted_queue, entry);
 734 }
 735
 736 static void
 737 rb_shell_clipboard_entryview_changed_cb (RBEntryView *view,
 738                                          RBShellClipboard *clipboard)
 739 {
 740         if (clipboard->priv->idle_sync_id == 0)
 741                 clipboard->priv->idle_sync_id = g_idle_add ((GSourceFunc) rb_shell_clipboard_sync_idle,
 742                                                             clipboard);
 743         rb_debug ("entryview changed");
 744 }
 745
 746 static void
 747 rb_shell_clipboard_entries_changed_cb (RBEntryView *view,
 748                                        gpointer stuff,
 749                                        RBShellClipboard *clipboard)
 750 {
 751         rb_debug ("entryview changed");
 752         if (clipboard->priv->idle_sync_id == 0)
 753                 clipboard->priv->idle_sync_id = g_idle_add ((GSourceFunc) rb_shell_clipboard_sync_idle,
 754                                                             clipboard);
 755 }
 756
 757 static void
 758 rb_shell_clipboard_cmd_add_to_playlist_new (GtkAction *action,
 759                                             RBShellClipboard *clipboard)
 760 {
 761         GList *entries;
 762         RBSource *playlist_source;
 763
 764         rb_debug ("add to new playlist");
 765
 766         entries = rb_source_copy (clipboard->priv->source);
 767         playlist_source = rb_playlist_manager_new_playlist (clipboard->priv->playlist_manager,
 768                                                             NULL, FALSE);
 769         rb_source_paste (playlist_source, entries);
 770
 771         g_list_foreach (entries, (GFunc)rhythmdb_entry_unref, NULL);
 772         g_list_free (entries);
 773 }
 774
 775 static void
 776 rb_shell_clipboard_cmd_add_song_to_queue (GtkAction *action,
 777                                           RBShellClipboard *clipboard)
 778 {
 779         rb_debug ("add to queue");
 780         rb_source_add_to_queue (clipboard->priv->source,
 781                                 RB_SOURCE (clipboard->priv->queue_source));
 782 }
 783
 784 static void
 785 rb_shell_clipboard_cmd_song_info (GtkAction *action,
 786                                   RBShellClipboard *clipboard)
 787 {
 788         rb_debug ("song info");
 789
 790         rb_source_song_properties (clipboard->priv->source);
 791 }
 792
 793 static void
 794 rb_shell_clipboard_cmd_queue_song_info (GtkAction *action,
 795                                         RBShellClipboard *clipboard)
 796 {
 797         rb_debug ("song info");
 798         rb_play_queue_source_sidebar_song_info (RB_PLAY_QUEUE_SOURCE (clipboard->priv->queue_source));
 799 }
 800
 801 static void
 802 rb_shell_clipboard_playlist_add_cb (GtkAction *action,
 803                                     RBShellClipboard *clipboard)
 804 {
 805         RBSource *playlist_source;
 806         GList *entries;
 807
 808         rb_debug ("add to exisintg playlist");
 809         playlist_source = g_object_get_data (G_OBJECT (action), "playlist-source");
 810
 811         entries = rb_source_copy (clipboard->priv->source);
 812         rb_source_paste (playlist_source, entries);
 813
 814         g_list_foreach (entries, (GFunc)rhythmdb_entry_unref, NULL);
 815         g_list_free (entries);
 816 }
 817
 818 static char *
 819 generate_action_name (RBStaticPlaylistSource *source,
 820                       RBShellClipboard *clipboard)
 821 {
 822         return g_strdup_printf ("AddToPlaylistClipboardAction%p", source);
 823 }
 824
 825 static void
 826 rb_shell_clipboard_playlist_deleted_cb (RBStaticPlaylistSource *source,
 827                                         RBShellClipboard *clipboard)
 828 {
 829         char *action_name;
 830         GtkAction *action;
 831
 832         /* first rebuild the menu */
 833         rebuild_playlist_menu (clipboard);
 834
 835         /* then remove the 'add to playlist' action for the deleted playlist */
 836         action_name = generate_action_name (source, clipboard);
 837         action = gtk_action_group_get_action (clipboard->priv->actiongroup, action_name);
 838         g_assert (action);
 839         gtk_action_group_remove_action (clipboard->priv->actiongroup, action);
 840         g_free (action_name);
 841 }
 842
 843 static void
 844 rb_shell_clipboard_playlist_renamed_cb (RBStaticPlaylistSource *source,
 845                                         GParamSpec *spec,
 846                                         RBShellClipboard *clipboard)
 847 {
 848         char *name, *action_name;
 849         GtkAction *action;
 850
 851         g_object_get (source, "name", &name, NULL);
 852
 853         action_name = generate_action_name (source, clipboard);
 854         action = gtk_action_group_get_action (clipboard->priv->actiongroup, action_name);
 855         g_assert (action);
 856         g_free (action_name);
 857
 858         g_object_set (action, "label", name, NULL);
 859         g_free (name);
 860         g_object_unref (action);
 861 }
 862
 863 static void
 864 rb_shell_clipboard_playlist_visible_cb (RBStaticPlaylistSource *source,
 865                                         GParamSpec *spec,
 866                                         RBShellClipboard *clipboard)
 867 {
 868         gboolean visible = FALSE;
 869         char *action_name;
 870         GtkAction *action;
 871
 872         g_object_get (source, "visibility", &visible, NULL);
 873
 874         action_name = generate_action_name (source, clipboard);
 875         action = gtk_action_group_get_action (clipboard->priv->actiongroup, action_name);
 876         g_assert (action);
 877         g_free (action_name);
 878
 879         gtk_action_set_visible (action, visible);
 880         g_object_unref (G_OBJECT (action));
 881 }
 882
 883 static gboolean
 884 add_playlist_to_menu (GtkTreeModel *model,
 885                       GtkTreePath *path,
 886                       GtkTreeIter *iter,
 887                       RBShellClipboard *clipboard)
 888 {
 889         RhythmDBEntryType entry_type;
 890         RhythmDBEntryType source_entry_type;
 891         RBSource *source = NULL;
 892         char *action_name;
 893         GtkAction *action;
 894         int i;
 895
 896         gtk_tree_model_get (GTK_TREE_MODEL (model), iter,
 897                             RB_SOURCELIST_MODEL_COLUMN_SOURCE, &source, -1);
 898
 899         if (source == NULL) {
 900                 return FALSE;
 901         }
 902
 903         if (!RB_IS_STATIC_PLAYLIST_SOURCE (source)) {
 904                 g_object_unref (source);
 905                 return FALSE;
 906         }
 907
 908         /* FIXME: allow add-to-playlist for iPods and the like,
 909          * based on the currently selected source
 910          */
 911         entry_type = RHYTHMDB_ENTRY_TYPE_SONG;
 912         g_object_get (source, "entry-type", &source_entry_type, NULL);
 913         if (source_entry_type != entry_type) {
 914                 g_object_unref (source);
 915                 g_boxed_free (RHYTHMDB_TYPE_ENTRY_TYPE, source_entry_type);
 916                 return FALSE;
 917         }
 918
 919         action_name = generate_action_name (RB_STATIC_PLAYLIST_SOURCE (source), clipboard);
 920         action = gtk_action_group_get_action (clipboard->priv->actiongroup, action_name);
 921         if (action == NULL) {
 922                 char *name;
 923
 924                 g_object_get (source, "name", &name, NULL);
 925                 action = gtk_action_new (action_name, name, NULL, NULL);
 926                 gtk_action_group_add_action (clipboard->priv->actiongroup, action);
 927                 g_free (name);
 928
 929                 g_object_set_data (G_OBJECT (action), "playlist-source", source);
 930                 g_signal_connect_object (G_OBJECT (action),
 931                                          "activate", G_CALLBACK (rb_shell_clipboard_playlist_add_cb),
 932                                          clipboard, 0);
 933
 934                 g_signal_connect_object (source,
 935                                          "deleted", G_CALLBACK (rb_shell_clipboard_playlist_deleted_cb),
 936                                          clipboard, 0);
 937                 g_signal_connect_object (source,
 938                                          "notify::name", G_CALLBACK (rb_shell_clipboard_playlist_renamed_cb),
 939                                          clipboard, 0);
 940                 g_signal_connect_object (source,
 941                                          "notify::visibility", G_CALLBACK (rb_shell_clipboard_playlist_visible_cb),
 942                                          clipboard, 0);
 943         }
 944
 945         for (i = 0; i < num_playlist_menu_paths; i++) {
 946                 gtk_ui_manager_add_ui (clipboard->priv->ui_mgr, clipboard->priv->playlist_menu_ui_id,
 947                                        playlist_menu_paths[i],
 948                                        action_name, action_name,
 949                                        GTK_UI_MANAGER_AUTO, FALSE);
 950         }
 951
 952         g_boxed_free (RHYTHMDB_TYPE_ENTRY_TYPE, source_entry_type);
 953         g_free (action_name);
 954         g_object_unref (source);
 955
 956         return FALSE;
 957 }
 958
 959 static void
 960 rebuild_playlist_menu (RBShellClipboard *clipboard)
 961 {
 962         GtkTreeModel *model = NULL;
 963         GObject *sourcelist = NULL;
 964
 965         rb_debug ("rebuilding add-to-playlist menu");
 966
 967         if (clipboard->priv->playlist_menu_ui_id != 0) {
 968                 gtk_ui_manager_remove_ui (clipboard->priv->ui_mgr,
 969                                           clipboard->priv->playlist_menu_ui_id);
 970         } else {
 971                 clipboard->priv->playlist_menu_ui_id =
 972                         gtk_ui_manager_new_merge_id (clipboard->priv->ui_mgr);
 973         }
 974
 975         if (clipboard->priv->playlist_manager != NULL) {
 976                 g_object_get (clipboard->priv->playlist_manager, "sourcelist", &sourcelist, NULL);
 977         }
 978
 979         if (sourcelist != NULL) {
 980                 g_object_get (sourcelist, "model", &model, NULL);
 981                 g_object_unref (sourcelist);
 982         }
 983
 984         if (model != NULL) {
 985                 gtk_tree_model_foreach (model, (GtkTreeModelForeachFunc)add_playlist_to_menu, clipboard);
 986                 g_object_unref (model);
 987         }
 988 }
 989
 990 static gboolean
 991 rebuild_playlist_menu_idle (RBShellClipboard *clipboard)
 992 {
 993         GDK_THREADS_ENTER ();
 994         rebuild_playlist_menu (clipboard);
 995         clipboard->priv->idle_playlist_id = 0;
 996         GDK_THREADS_LEAVE ();
 997         return FALSE;
 998 }
 999
1000 static void
1001 rb_shell_clipboard_playlist_added_cb (RBPlaylistManager *mgr,
1002                                       RBPlaylistSource *source,
1003                                       RBShellClipboard *clipboard)
1004 {
1005         if (!RB_IS_STATIC_PLAYLIST_SOURCE (source))
1006                 return;
1007
1008         if (clipboard->priv->idle_playlist_id == 0) {
1009                 clipboard->priv->idle_playlist_id =
1010                         g_idle_add ((GSourceFunc)rebuild_playlist_menu_idle, clipboard);
1011         }
1012 }