chiark - git - mdw - disorder/blob - disobedience/playlists.c

   1 /*
   2  * This file is part of DisOrder
   3  * Copyright (C) 2008, 2009 Richard Kettlewell
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation; either version 2 of the License, or
   8  * (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful, but
  11  * WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program; if not, write to the Free Software
  17  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
  18  * USA
  19  */
  20 /** @file disobedience/playlists.c
  21  * @brief Playlist support for Disobedience
  22  *
  23  * The playlists management window contains:
  24  * - the playlist picker (a list of all playlists) TODO should be a tree!
  25  * - an add button
  26  * - a delete button
  27  * - the playlist editor (a d+d-capable view of the currently picked playlist)
  28  * - a close button   TODO
  29  *
  30  * This file also maintains the playlist menu, allowing playlists to be
  31  * activated from the main window's menu.
  32  *
  33  * Internally we maintain the playlist list, which is just the current list of
  34  * playlists.  Changes to this are reflected in the playlist menu and the
  35  * playlist picker.
  36  *
  37  */
  38 #include "disobedience.h"
  39 #include "queue-generic.h"
  40 #include "popup.h"
  41 #include "validity.h"
  42
  43 #if PLAYLISTS
  44
  45 static void playlist_list_received_playlists(void *v,
  46                                              const char *err,
  47                                              int nvec, char **vec);
  48 static void playlist_editor_fill(const char *event,
  49                                  void *eventdata,
  50                                  void *callbackdata);
  51
  52 /** @brief Playlist editing window */
  53 static GtkWidget *playlist_window;
  54
  55 /** @brief Columns for the playlist editor */
  56 static const struct queue_column playlist_columns[] = {
  57   { "Artist", column_namepart, "artist", COL_EXPAND|COL_ELLIPSIZE },
  58   { "Album",  column_namepart, "album",  COL_EXPAND|COL_ELLIPSIZE },
  59   { "Title",  column_namepart, "title",  COL_EXPAND|COL_ELLIPSIZE },
  60   { "Length", column_length,   0,        COL_RIGHT }
  61 };
  62
  63 /** @brief Pop-up menu for playlist editor */
  64 // TODO some of these may not be generic enough yet - check!
  65 static struct menuitem playlist_menuitems[] = {
  66   { "Track properties", ql_properties_activate, ql_properties_sensitive, 0, 0 },
  67   { "Play track", ql_play_activate, ql_play_sensitive, 0, 0 },
  68   //{ "Play playlist", ql_playall_activate, ql_playall_sensitive, 0, 0 },
  69   { "Remove track from queue", ql_remove_activate, ql_remove_sensitive, 0, 0 },
  70   { "Select all tracks", ql_selectall_activate, ql_selectall_sensitive, 0, 0 },
  71   { "Deselect all tracks", ql_selectnone_activate, ql_selectnone_sensitive, 0, 0 },
  72 };
  73
  74 /** @brief Queuelike for editing a playlist */
  75 static struct queuelike ql_playlist = {
  76   .name = "playlist",
  77   .columns = playlist_columns,
  78   .ncolumns = sizeof playlist_columns / sizeof *playlist_columns,
  79   .menuitems = playlist_menuitems,
  80   .nmenuitems = sizeof playlist_menuitems / sizeof *playlist_menuitems,
  81   //.drop = playlist_drop  //TODO
  82 };
  83
  84 /* Maintaining the list of playlists ---------------------------------------- */
  85
  86 /** @brief Current list of playlists or NULL */
  87 char **playlists;
  88
  89 /** @brief Count of playlists */
  90 int nplaylists;
  91
  92 /** @brief Schedule an update to the list of playlists
  93  *
  94  * Called periodically and when a playlist is created or deleted.
  95  */
  96 static void playlist_list_update(const char attribute((unused)) *event,
  97                                  void attribute((unused)) *eventdata,
  98                                  void attribute((unused)) *callbackdata) {
  99   disorder_eclient_playlists(client, playlist_list_received_playlists, 0);
 100 }
 101
 102 /** @brief qsort() callback for playlist name comparison */
 103 static int playlistcmp(const void *ap, const void *bp) {
 104   const char *a = *(char **)ap, *b = *(char **)bp;
 105   const char *ad = strchr(a, '.'), *bd = strchr(b, '.');
 106   int c;
 107
 108   /* Group owned playlists by owner */
 109   if(ad && bd) {
 110     const int adn = ad - a, bdn = bd - b;
 111     if((c = strncmp(a, b, adn < bdn ? adn : bdn)))
 112       return c;
 113     /* Lexical order within playlists of a single owner */
 114     return strcmp(ad + 1, bd + 1);
 115   }
 116
 117   /* Owned playlists after shared ones */
 118   if(ad) {
 119     return 1;
 120   } else if(bd) {
 121     return -1;
 122   }
 123
 124   /* Lexical order of shared playlists */
 125   return strcmp(a, b);
 126 }
 127
 128 /** @brief Called with a new list of playlists */
 129 static void playlist_list_received_playlists(void attribute((unused)) *v,
 130                                              const char *err,
 131                                              int nvec, char **vec) {
 132   if(err) {
 133     playlists = 0;
 134     nplaylists = -1;
 135     /* Probably means server does not support playlists */
 136   } else {
 137     playlists = vec;
 138     nplaylists = nvec;
 139     qsort(playlists, nplaylists, sizeof (char *), playlistcmp);
 140   }
 141   /* Tell our consumers */
 142   event_raise("playlists-updated", 0);
 143 }
 144
 145 /* Playlists menu ----------------------------------------------------------- */
 146
 147 /** @brief Play received playlist contents
 148  *
 149  * Passed as a completion callback by menu_activate_playlist().
 150  */
 151 static void playlist_menu_received_content(void attribute((unused)) *v,
 152                                            const char *err,
 153                                            int nvec, char **vec) {
 154   if(err) {
 155     popup_protocol_error(0, err);
 156     return;
 157   }
 158   for(int n = 0; n < nvec; ++n)
 159     disorder_eclient_play(client, vec[n], NULL, NULL);
 160 }
 161
 162 /** @brief Called to activate a playlist
 163  *
 164  * Called when the menu item for a playlist is clicked.
 165  */
 166 static void playlist_menu_activate(GtkMenuItem *menuitem,
 167                                    gpointer attribute((unused)) user_data) {
 168   GtkLabel *label = GTK_LABEL(GTK_BIN(menuitem)->child);
 169   const char *playlist = gtk_label_get_text(label);
 170
 171   disorder_eclient_playlist_get(client, playlist_menu_received_content,
 172                                 playlist, NULL);
 173 }
 174
 175 /** @brief Called when the playlists change
 176  *
 177  * Naively refills the menu.  The results might be unsettling if the menu is
 178  * currently open, but this is hopefuly fairly rare.
 179  */
 180 static void playlist_menu_changed(const char attribute((unused)) *event,
 181                                   void attribute((unused)) *eventdata,
 182                                   void attribute((unused)) *callbackdata) {
 183   if(!playlists_menu)
 184     return;                             /* OMG too soon */
 185   GtkMenuShell *menu = GTK_MENU_SHELL(playlists_menu);
 186   while(menu->children)
 187     gtk_container_remove(GTK_CONTAINER(menu), GTK_WIDGET(menu->children->data));
 188   /* NB nplaylists can be -1 as well as 0 */
 189   for(int n = 0; n < nplaylists; ++n) {
 190     GtkWidget *w = gtk_menu_item_new_with_label(playlists[n]);
 191     g_signal_connect(w, "activate", G_CALLBACK(playlist_menu_activate), 0);
 192     gtk_widget_show(w);
 193     gtk_menu_shell_append(menu, w);
 194   }
 195   gtk_widget_set_sensitive(menu_playlists_widget,
 196                            nplaylists > 0);
 197   gtk_widget_set_sensitive(menu_editplaylists_widget,
 198                            nplaylists >= 0);
 199 }
 200
 201 /* Popup to create a new playlist ------------------------------------------- */
 202
 203 /** @brief New-playlist popup */
 204 static GtkWidget *playlist_new_window;
 205
 206 /** @brief Text entry in new-playlist popup */
 207 static GtkWidget *playlist_new_entry;
 208
 209 /** @brief Label for displaying feedback on what's wrong */
 210 static GtkWidget *playlist_new_info;
 211
 212 /** @brief "Shared" radio button */
 213 static GtkWidget *playlist_new_shared;
 214
 215 /** @brief "Public" radio button */
 216 static GtkWidget *playlist_new_public;
 217
 218 /** @brief "Private" radio button */
 219 static GtkWidget *playlist_new_private;
 220
 221 /** @brief Get entered new-playlist details
 222  * @param namep Where to store entered name (or NULL)
 223  * @param fullnamep Where to store computed full name (or NULL)
 224  * @param sharep Where to store 'shared' flag (or NULL)
 225  * @param publicp Where to store 'public' flag (or NULL)
 226  * @param privatep Where to store 'private' flag (or NULL)
 227  */
 228 static void playlist_new_details(char **namep,
 229                                  char **fullnamep,
 230                                  gboolean *sharedp,
 231                                  gboolean *publicp,
 232                                  gboolean *privatep) {
 233   gboolean shared, public, private;
 234   g_object_get(playlist_new_shared, "active", &shared, (char *)NULL);
 235   g_object_get(playlist_new_public, "active", &public, (char *)NULL);
 236   g_object_get(playlist_new_private, "active", &private, (char *)NULL);
 237   char *gname = gtk_editable_get_chars(GTK_EDITABLE(playlist_new_entry),
 238                                        0, -1); /* name owned by calle */
 239   char *name = xstrdup(gname);
 240   g_free(gname);
 241   if(sharedp) *sharedp = shared;
 242   if(publicp) *publicp = public;
 243   if(privatep) *privatep = private;
 244   if(namep) *namep = name;
 245   if(fullnamep) {
 246     if(*sharedp) *fullnamep = *namep;
 247     else byte_xasprintf(fullnamep, "%s.%s", config->username, name);
 248   }
 249 }
 250
 251 /** @brief Called when the newly created playlist has unlocked */
 252 static void playlist_new_unlocked(void attribute((unused)) *v, const char *err) {
 253   if(err)
 254     popup_protocol_error(0, err);
 255   /* Pop down the creation window */
 256   gtk_widget_destroy(playlist_new_window);
 257 }
 258
 259 /** @brief Called when the new playlist has been created */
 260 static void playlist_new_created(void attribute((unused)) *v, const char *err) {
 261   if(err) {
 262     popup_protocol_error(0, err);
 263     return;
 264   }
 265   disorder_eclient_playlist_unlock(client, playlist_new_unlocked, NULL);
 266   // TODO arrange for the new playlist to be selected
 267 }
 268
 269 /** @brief Called when the proposed new playlist's contents have been retrieved
 270  *
 271  * ...or rather, normally, when it's been reported that it does not exist.
 272  */
 273 static void playlist_new_retrieved(void *v, const char *err,
 274                                    int nvec,
 275                                    char attribute((unused)) **vec) {
 276   char *fullname = v;
 277   if(!err && nvec != -1)
 278     /* A rare case but not in principle impossible */
 279     err = "A playlist with that name already exists.";
 280   if(err) {
 281     popup_protocol_error(0, err);
 282     disorder_eclient_playlist_unlock(client, playlist_new_unlocked, fullname);
 283     return;
 284   }
 285   gboolean shared, public, private;
 286   playlist_new_details(0, 0, &shared, &public, &private);
 287   disorder_eclient_playlist_set_share(client, playlist_new_created, fullname,
 288                                       public ? "public"
 289                                       : private ? "private"
 290                                       : "shared",
 291                                       fullname);
 292 }
 293
 294 /** @brief Called when the proposed new playlist has been locked */
 295 static void playlist_new_locked(void *v, const char *err) {
 296   char *fullname = v;
 297   if(err) {
 298     popup_protocol_error(0, err);
 299     return;
 300   }
 301   disorder_eclient_playlist_get(client, playlist_new_retrieved,
 302                                 fullname, fullname);
 303 }
 304
 305 /** @brief Called when 'ok' is clicked in new-playlist popup */
 306 static void playlist_new_ok(GtkButton attribute((unused)) *button,
 307                             gpointer attribute((unused)) userdata) {
 308   gboolean shared, public, private;
 309   char *name, *fullname;
 310   playlist_new_details(&name, &fullname, &shared, &public, &private);
 311
 312   /* We need to:
 313    * - lock the playlist
 314    * - check it doesn't exist
 315    * - set sharing (which will create it empty
 316    * - unlock it
 317    *
 318    * TODO we should freeze the window while this is going on to stop a second
 319    * click.
 320    */
 321   disorder_eclient_playlist_lock(client, playlist_new_locked, fullname,
 322                                  fullname);
 323 }
 324
 325 /** @brief Called when 'cancel' is clicked in new-playlist popup */
 326 static void playlist_new_cancel(GtkButton attribute((unused)) *button,
 327                                 gpointer attribute((unused)) userdata) {
 328   gtk_widget_destroy(playlist_new_window);
 329 }
 330
 331 /** @brief Buttons for new-playlist popup */
 332 static struct button playlist_new_buttons[] = {
 333   {
 334     .stock = GTK_STOCK_OK,
 335     .clicked = playlist_new_ok,
 336     .tip = "Create new playlist"
 337   },
 338   {
 339     .stock = GTK_STOCK_CANCEL,
 340     .clicked = playlist_new_cancel,
 341     .tip = "Do not create new playlist"
 342   }
 343 };
 344 #define NPLAYLIST_NEW_BUTTONS (sizeof playlist_new_buttons / sizeof *playlist_new_buttons)
 345
 346 /** @brief Test whether the new-playlist window settings are valid
 347  * @return NULL on success or an error string if not
 348  */
 349 static const char *playlist_new_valid(void) {
 350   gboolean shared, public, private;
 351   char *name, *fullname;
 352   playlist_new_details(&name, &fullname, &shared, &public, &private);
 353   if(!(shared || public || private))
 354     return "No type set.";
 355   if(!*name)
 356     return "";
 357   /* See if the result is valid */
 358   if(!valid_username(name)
 359      || playlist_parse_name(fullname, NULL, NULL))
 360     return "Not a valid playlist name.";
 361   /* See if the result clashes with an existing name.  This is not a perfect
 362    * check, the playlist might be created after this point but before we get a
 363    * chance to disable the "OK" button.  However when we try to create the
 364    * playlist we will first try to retrieve it, with a lock held, so we
 365    * shouldn't end up overwriting anything. */
 366   for(int n = 0; n < nplaylists; ++n)
 367     if(!strcmp(playlists[n], fullname)) {
 368       if(shared)
 369         return "A shared playlist with that name already exists.";
 370       else
 371         return "You already have a playlist with that name.";
 372     }
 373   /* As far as we can tell creation would work */
 374   return NULL;
 375 }
 376
 377 /** @brief Called to update new playlist window state
 378  *
 379  * This is called whenever one the text entry or radio buttons changed, and
 380  * also when the set of known playlists changes.  It determines whether the new
 381  * playlist would be creatable and sets the sensitivity of the OK button
 382  * and info display accordingly.
 383  */
 384 static void playlist_new_changed(const char attribute((unused)) *event,
 385                                  void attribute((unused)) *eventdata,
 386                                  void attribute((unused)) *callbackdata) {
 387   if(!playlist_new_window)
 388     return;
 389   const char *reason = playlist_new_valid();
 390   gtk_widget_set_sensitive(playlist_new_buttons[0].widget,
 391                            !reason);
 392   gtk_label_set_text(GTK_LABEL(playlist_new_info), reason);
 393 }
 394
 395 /** @brief Called when some radio button in the new-playlist popup changes */
 396 static void playlist_new_button_toggled(GtkToggleButton attribute((unused)) tb,
 397                                         gpointer attribute((unused)) userdata) {
 398   playlist_new_changed(0,0,0);
 399 }
 400
 401 /** @brief Called when the text entry field in the new-playlist popup changes */
 402 static void playlist_new_entry_edited(GtkEditable attribute((unused)) *editable,
 403                                       gpointer attribute((unused)) user_data) {
 404   playlist_new_changed(0,0,0);
 405 }
 406
 407 /** @brief Pop up a new window to enter the playlist name and details */
 408 static void playlist_new_playlist(void) {
 409   assert(playlist_new_window == NULL);
 410   playlist_new_window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
 411   g_signal_connect(playlist_new_window, "destroy",
 412                    G_CALLBACK(gtk_widget_destroyed), &playlist_new_window);
 413   gtk_window_set_title(GTK_WINDOW(playlist_new_window), "Create new playlist");
 414   /* Window will be modal, suppressing access to other windows */
 415   gtk_window_set_modal(GTK_WINDOW(playlist_new_window), TRUE);
 416   gtk_window_set_transient_for(GTK_WINDOW(playlist_new_window),
 417                                GTK_WINDOW(playlist_window));
 418
 419   /* Window contents will use a table (grid) layout */
 420   GtkWidget *table = gtk_table_new(3, 3, FALSE/*!homogeneous*/);
 421
 422   /* First row: playlist name */
 423   gtk_table_attach_defaults(GTK_TABLE(table),
 424                             gtk_label_new("Playlist name"),
 425                             0, 1, 0, 1);
 426   playlist_new_entry = gtk_entry_new();
 427   g_signal_connect(playlist_new_entry, "changed",
 428                    G_CALLBACK(playlist_new_entry_edited), NULL);
 429   gtk_table_attach_defaults(GTK_TABLE(table),
 430                             playlist_new_entry,
 431                             1, 3, 0, 1);
 432
 433   /* Second row: radio buttons to choose type */
 434   playlist_new_shared = gtk_radio_button_new_with_label(NULL, "shared");
 435   playlist_new_public
 436     = gtk_radio_button_new_with_label_from_widget(GTK_RADIO_BUTTON(playlist_new_shared),
 437                                                   "public");
 438   playlist_new_private
 439     = gtk_radio_button_new_with_label_from_widget(GTK_RADIO_BUTTON(playlist_new_shared),
 440                                                   "private");
 441   g_signal_connect(playlist_new_shared, "toggled",
 442                    G_CALLBACK(playlist_new_button_toggled), NULL);
 443   g_signal_connect(playlist_new_public, "toggled",
 444                    G_CALLBACK(playlist_new_button_toggled), NULL);
 445   g_signal_connect(playlist_new_private, "toggled",
 446                    G_CALLBACK(playlist_new_button_toggled), NULL);
 447   gtk_table_attach_defaults(GTK_TABLE(table), playlist_new_shared, 0, 1, 1, 2);
 448   gtk_table_attach_defaults(GTK_TABLE(table), playlist_new_public, 1, 2, 1, 2);
 449   gtk_table_attach_defaults(GTK_TABLE(table), playlist_new_private, 2, 3, 1, 2);
 450
 451   /* Third row: info bar saying why not */
 452   playlist_new_info = gtk_label_new("");
 453   gtk_table_attach_defaults(GTK_TABLE(table), playlist_new_info,
 454                             0, 3, 2, 3);
 455
 456   /* Fourth row: ok/cancel buttons */
 457   GtkWidget *hbox = create_buttons_box(playlist_new_buttons,
 458                                        NPLAYLIST_NEW_BUTTONS,
 459                                        gtk_hbox_new(FALSE, 0));
 460   gtk_table_attach_defaults(GTK_TABLE(table), hbox, 0, 3, 3, 4);
 461
 462   gtk_container_add(GTK_CONTAINER(playlist_new_window),
 463                     frame_widget(table, NULL));
 464
 465   /* Set initial state of OK button */
 466   playlist_new_changed(0,0,0);
 467
 468   /* TODO: return should = OK, escape should = cancel */
 469
 470   /* Display the window */
 471   gtk_widget_show_all(playlist_new_window);
 472 }
 473
 474 /* Playlist picker ---------------------------------------------------------- */
 475
 476 /** @brief Delete button */
 477 static GtkWidget *playlist_picker_delete_button;
 478
 479 /** @brief Tree model for list of playlists */
 480 static GtkListStore *playlist_picker_list;
 481
 482 /** @brief Selection for list of playlists */
 483 static GtkTreeSelection *playlist_picker_selection;
 484
 485 /** @brief Currently selected playlist */
 486 static const char *playlist_picker_selected;
 487
 488 /** @brief (Re-)populate the playlist picker tree model */
 489 static void playlist_picker_fill(const char attribute((unused)) *event,
 490                                  void attribute((unused)) *eventdata,
 491                                  void attribute((unused)) *callbackdata) {
 492   GtkTreeIter iter[1];
 493
 494   if(!playlist_window)
 495     return;
 496   if(!playlist_picker_list)
 497     playlist_picker_list = gtk_list_store_new(1, G_TYPE_STRING);
 498   const char *was_selected = playlist_picker_selected;
 499   gtk_list_store_clear(playlist_picker_list); /* clears playlists_selected */
 500   for(int n = 0; n < nplaylists; ++n) {
 501     gtk_list_store_insert_with_values(playlist_picker_list, iter,
 502                                       n                /*position*/,
 503                                       0, playlists[n], /* column 0 */
 504                                       -1);             /* no more cols */
 505     /* Reselect the selected playlist */
 506     if(was_selected && !strcmp(was_selected, playlists[n]))
 507       gtk_tree_selection_select_iter(playlist_picker_selection, iter);
 508   }
 509 }
 510
 511 /** @brief Called when the selection might have changed */
 512 static void playlist_picker_selection_changed(GtkTreeSelection attribute((unused)) *treeselection,
 513                                               gpointer attribute((unused)) user_data) {
 514   GtkTreeIter iter;
 515   char *gselected, *selected;
 516
 517   /* Identify the current selection */
 518   if(gtk_tree_selection_get_selected(playlist_picker_selection, 0, &iter)) {
 519     gtk_tree_model_get(GTK_TREE_MODEL(playlist_picker_list), &iter,
 520                        0, &gselected, -1);
 521     selected = xstrdup(gselected);
 522     g_free(gselected);
 523   } else
 524     selected = 0;
 525   /* Set button sensitivity according to the new state */
 526   if(selected)
 527     gtk_widget_set_sensitive(playlist_picker_delete_button, 1);
 528   else
 529     gtk_widget_set_sensitive(playlist_picker_delete_button, 0);
 530   /* Eliminate no-change cases */
 531   if(!selected && !playlist_picker_selected)
 532     return;
 533   if(selected
 534      && playlist_picker_selected
 535      && !strcmp(selected, playlist_picker_selected))
 536     return;
 537   /* Record the new state */
 538   playlist_picker_selected = selected;
 539   /* Re-initalize the queue */
 540   ql_new_queue(&ql_playlist, NULL);
 541   playlist_editor_fill(NULL, (void *)playlist_picker_selected, NULL);
 542 }
 543
 544 /** @brief Called when the 'add' button is pressed */
 545 static void playlist_picker_add(GtkButton attribute((unused)) *button,
 546                                 gpointer attribute((unused)) userdata) {
 547   /* Unselect whatever is selected TODO why?? */
 548   gtk_tree_selection_unselect_all(playlist_picker_selection);
 549   playlist_new_playlist();
 550 }
 551
 552 /** @brief Called when playlist deletion completes */
 553 static void playlists_picker_delete_completed(void attribute((unused)) *v,
 554                                               const char *err) {
 555   if(err)
 556     popup_protocol_error(0, err);
 557 }
 558
 559 /** @brief Called when the 'Delete' button is pressed */
 560 static void playlist_picker_delete(GtkButton attribute((unused)) *button,
 561                                    gpointer attribute((unused)) userdata) {
 562   GtkWidget *yesno;
 563   int res;
 564
 565   if(!playlist_picker_selected)
 566     return;                             /* shouldn't happen */
 567   yesno = gtk_message_dialog_new(GTK_WINDOW(playlist_window),
 568                                  GTK_DIALOG_MODAL,
 569                                  GTK_MESSAGE_QUESTION,
 570                                  GTK_BUTTONS_YES_NO,
 571                                  "Do you really want to delete playlist %s?"
 572                                  " This action cannot be undone.",
 573                                  playlist_picker_selected);
 574   res = gtk_dialog_run(GTK_DIALOG(yesno));
 575   gtk_widget_destroy(yesno);
 576   if(res == GTK_RESPONSE_YES) {
 577     disorder_eclient_playlist_delete(client,
 578                                      playlists_picker_delete_completed,
 579                                      playlist_picker_selected,
 580                                      NULL);
 581   }
 582 }
 583
 584 /** @brief Table of buttons below the playlist list */
 585 static struct button playlist_picker_buttons[] = {
 586   {
 587     GTK_STOCK_ADD,
 588     playlist_picker_add,
 589     "Create a new playlist",
 590     0
 591   },
 592   {
 593     GTK_STOCK_REMOVE,
 594     playlist_picker_delete,
 595     "Delete a playlist",
 596     0
 597   },
 598 };
 599 #define NPLAYLIST_PICKER_BUTTONS (sizeof playlist_picker_buttons / sizeof *playlist_picker_buttons)
 600
 601 /** @brief Create the list of playlists for the edit playlists window */
 602 static GtkWidget *playlist_picker_create(void) {
 603   /* Create the list of playlist and populate it */
 604   playlist_picker_fill(NULL, NULL, NULL);
 605   /* Create the tree view */
 606   GtkWidget *tree = gtk_tree_view_new_with_model(GTK_TREE_MODEL(playlist_picker_list));
 607   /* ...and the renderers for it */
 608   GtkCellRenderer *cr = gtk_cell_renderer_text_new();
 609   GtkTreeViewColumn *col = gtk_tree_view_column_new_with_attributes("Playlist",
 610                                                                     cr,
 611                                                                     "text", 0,
 612                                                                     NULL);
 613   gtk_tree_view_append_column(GTK_TREE_VIEW(tree), col);
 614   /* Get the selection for the view; set its mode; arrange for a callback when
 615    * it changes */
 616   playlist_picker_selected = NULL;
 617   playlist_picker_selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(tree));
 618   gtk_tree_selection_set_mode(playlist_picker_selection, GTK_SELECTION_BROWSE);
 619   g_signal_connect(playlist_picker_selection, "changed",
 620                    G_CALLBACK(playlist_picker_selection_changed), NULL);
 621
 622   /* Create the control buttons */
 623   GtkWidget *buttons = create_buttons_box(playlist_picker_buttons,
 624                                           NPLAYLIST_PICKER_BUTTONS,
 625                                           gtk_hbox_new(FALSE, 1));
 626   playlist_picker_delete_button = playlist_picker_buttons[1].widget;
 627
 628   playlist_picker_selection_changed(NULL, NULL);
 629
 630   /* Buttons live below the list */
 631   GtkWidget *vbox = gtk_vbox_new(FALSE, 0);
 632   gtk_box_pack_start(GTK_BOX(vbox), scroll_widget(tree), TRUE/*expand*/, TRUE/*fill*/, 0);
 633   gtk_box_pack_start(GTK_BOX(vbox), buttons, FALSE/*expand*/, FALSE, 0);
 634
 635   return vbox;
 636 }
 637
 638 /* Playlist editor ---------------------------------------------------------- */
 639
 640 /** @brief Called with new tracks for the playlist */
 641 static void playlists_editor_received_tracks(void attribute((unused)) *v,
 642                                              const char *err,
 643                                              int nvec, char **vec) {
 644   if(err) {
 645     popup_protocol_error(0, err);
 646     return;
 647   }
 648   if(nvec == -1)
 649     /* No such playlist, presumably we'll get a deleted event shortly */
 650     return;
 651   /* Translate the list of tracks into queue entries */
 652   struct queue_entry *newq, **qq = &newq;
 653   hash *h = hash_new(sizeof(int));
 654   for(int n = 0; n < nvec; ++n) {
 655     struct queue_entry *q = xmalloc(sizeof *q);
 656     q->track = vec[n];
 657     /* Synthesize a unique ID so that the selection survives updates.  Tracks
 658      * can appear more than once in the queue so we can't use raw track names,
 659      * so we add a serial number to the start. */
 660     /* TODO but this doesn't work for some reason */
 661     int *serialp = hash_find(h, vec[n]), serial = serialp ? *serialp : 0;
 662     byte_xasprintf((char **)&q->id, "%d-%s", serial++, vec[n]);
 663     fprintf(stderr, "%s\n", q->id);
 664     hash_add(h, vec[0], &serial, HASH_INSERT_OR_REPLACE);
 665     *qq = q;
 666     qq = &q->next;
 667   }
 668   *qq = NULL;
 669   ql_new_queue(&ql_playlist, newq);
 670 }
 671
 672 /** @brief (Re-)populate the playlist tree model */
 673 static void playlist_editor_fill(const char attribute((unused)) *event,
 674                                  void *eventdata,
 675                                  void attribute((unused)) *callbackdata) {
 676   const char *modified_playlist = eventdata;
 677   if(!playlist_window)
 678     return;
 679   if(!playlist_picker_selected)
 680     return;
 681   if(!strcmp(playlist_picker_selected, modified_playlist))
 682     disorder_eclient_playlist_get(client, playlists_editor_received_tracks,
 683                                   playlist_picker_selected, NULL);
 684 }
 685
 686 static GtkWidget *playlists_editor_create(void) {
 687   assert(ql_playlist.view == NULL);     /* better not be set up already */
 688   GtkWidget *w = init_queuelike(&ql_playlist);
 689   /* Initially empty */
 690   return w;
 691 }
 692
 693 /* Playlists window --------------------------------------------------------- */
 694
 695 /** @brief Keypress handler */
 696 static gboolean playlist_window_keypress(GtkWidget attribute((unused)) *widget,
 697                                          GdkEventKey *event,
 698                                          gpointer attribute((unused)) user_data) {
 699   if(event->state)
 700     return FALSE;
 701   switch(event->keyval) {
 702   case GDK_Escape:
 703     gtk_widget_destroy(playlist_window);
 704     return TRUE;
 705   default:
 706     return FALSE;
 707   }
 708 }
 709
 710 /** @brief Called when the playlist window is destroyed */
 711 static void playlist_window_destroyed(GtkWidget attribute((unused)) *widget,
 712                                       GtkWidget **widget_pointer) {
 713   destroy_queuelike(&ql_playlist);
 714   *widget_pointer = NULL;
 715 }
 716
 717 /** @brief Pop up the playlists window
 718  *
 719  * Called when the playlists menu item is selected
 720  */
 721 void edit_playlists(gpointer attribute((unused)) callback_data,
 722                     guint attribute((unused)) callback_action,
 723                     GtkWidget attribute((unused)) *menu_item) {
 724   /* If the window already exists, raise it */
 725   if(playlist_window) {
 726     gtk_window_present(GTK_WINDOW(playlist_window));
 727     return;
 728   }
 729   /* Create the window */
 730   playlist_window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
 731   gtk_widget_set_style(playlist_window, tool_style);
 732   g_signal_connect(playlist_window, "destroy",
 733                    G_CALLBACK(playlist_window_destroyed), &playlist_window);
 734   gtk_window_set_title(GTK_WINDOW(playlist_window), "Playlists Management");
 735   /* TODO loads of this is very similar to (copied from!) users.c - can we
 736    * de-dupe? */
 737   /* Keyboard shortcuts */
 738   g_signal_connect(playlist_window, "key-press-event",
 739                    G_CALLBACK(playlist_window_keypress), 0);
 740   /* default size is too small */
 741   gtk_window_set_default_size(GTK_WINDOW(playlist_window), 512, 240);
 742
 743   GtkWidget *hbox = gtk_hbox_new(FALSE, 0);
 744   gtk_box_pack_start(GTK_BOX(hbox), playlist_picker_create(),
 745                      FALSE/*expand*/, FALSE, 0);
 746   gtk_box_pack_start(GTK_BOX(hbox), gtk_event_box_new(),
 747                      FALSE/*expand*/, FALSE, 2);
 748   gtk_box_pack_start(GTK_BOX(hbox), playlists_editor_create(),
 749                      TRUE/*expand*/, TRUE/*fill*/, 0);
 750
 751   gtk_container_add(GTK_CONTAINER(playlist_window), frame_widget(hbox, NULL));
 752   gtk_widget_show_all(playlist_window);
 753 }
 754
 755 /** @brief Initialize playlist support */
 756 void playlists_init(void) {
 757   /* We re-get all playlists upon any change... */
 758   event_register("playlist-created", playlist_list_update, 0);
 759   event_register("playlist-modified", playlist_list_update, 0); /* TODO why? */
 760   event_register("playlist-deleted", playlist_list_update, 0);
 761   /* ...and on reconnection */
 762   event_register("log-connected", playlist_list_update, 0);
 763   /* ...and from time to time */
 764   event_register("periodic-slow", playlist_list_update, 0);
 765   /* ...and at startup */
 766   playlist_list_update(0, 0, 0);
 767
 768   /* Update the playlists menu when the set of playlists changes */
 769   event_register("playlists-updated", playlist_menu_changed, 0);
 770   /* Update the new-playlist OK button when the set of playlists changes */
 771   event_register("playlists-updated", playlist_new_changed, 0);
 772   /* Update the list of playlists in the edit window when the set changes */
 773   event_register("playlists-updated", playlist_picker_fill, 0);
 774   /* Update the displayed playlist when it is modified */
 775   event_register("playlist-modified", playlist_editor_fill, 0);
 776 }
 777
 778 #endif
 779
 780 /*
 781 Local Variables:
 782 c-basic-offset:2
 783 comment-column:40
 784 fill-column:79
 785 indent-tabs-mode:nil
 786 End:
 787 */