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

   1 /*
   2  * This file is part of DisOrder.
   3  * Copyright (C) 2006, 2007 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
  21 #include "disobedience.h"
  22
  23 #include <getopt.h>
  24 #include <locale.h>
  25 #include <pcre.h>
  26
  27 /* Apologies for the numerous de-consting casts, but GLib et al do not seem to
  28  * have heard of const. */
  29
  30 #include "style.h"                      /* generated style */
  31
  32 /* Functions --------------------------------------------------------------- */
  33
  34 static void log_connected(void *v);
  35 static void log_completed(void *v, const char *track);
  36 static void log_failed(void *v, const char *track, const char *status);
  37 static void log_moved(void *v, const char *user);
  38 static void log_playing(void *v, const char *track, const char *user);
  39 static void log_queue(void *v, struct queue_entry *q);
  40 static void log_recent_added(void *v, struct queue_entry *q);
  41 static void log_recent_removed(void *v, const char *id);
  42 static void log_removed(void *v, const char *id, const char *user);
  43 static void log_scratched(void *v, const char *track, const char *user);
  44 static void log_state(void *v, unsigned long state);
  45 static void log_volume(void *v, int l, int r);
  46
  47 /* Variables --------------------------------------------------------------- */
  48
  49 GMainLoop *mainloop;                    /* event loop */
  50 GtkWidget *toplevel;                    /* top level window */
  51 GtkWidget *report_label;                /* label for progress indicator */
  52 GtkWidget *tabs;                        /* main tabs */
  53
  54 disorder_eclient *client;               /* main client */
  55
  56 unsigned long last_state;               /* last reported state */
  57 int playing;                            /* true if playing some track */
  58 int volume_l, volume_r;                 /* volume */
  59 double goesupto = 10;                   /* volume upper bound */
  60 int choosealpha;                        /* break up choose by letter */
  61
  62 static const disorder_eclient_log_callbacks gdisorder_log_callbacks = {
  63   log_connected,
  64   log_completed,
  65   log_failed,
  66   log_moved,
  67   log_playing,
  68   log_queue,
  69   log_recent_added,
  70   log_recent_removed,
  71   log_removed,
  72   log_scratched,
  73   log_state,
  74   log_volume
  75 };
  76
  77 /* Window creation --------------------------------------------------------- */
  78
  79 /* Note that all the client operations kicked off from here will only complete
  80  * after we've entered the event loop. */
  81
  82 static gboolean delete_event(GtkWidget attribute((unused)) *widget,
  83                              GdkEvent attribute((unused)) *event,
  84                              gpointer attribute((unused)) data) {
  85   D(("delete_event"));
  86   exit(0);                              /* die immediately */
  87 }
  88
  89 /* Called when the current tab is switched. */
  90 static void tab_switched(GtkNotebook attribute((unused)) *notebook,
  91                          GtkNotebookPage attribute((unused)) *page,
  92                          guint page_num,
  93                          gpointer attribute((unused)) user_data) {
  94   menu_update(page_num);
  95 }
  96
  97 static GtkWidget *report_box(void) {
  98   GtkWidget *vbox = gtk_vbox_new(FALSE, 0);
  99
 100   report_label = gtk_label_new("");
 101   gtk_label_set_ellipsize(GTK_LABEL(report_label), PANGO_ELLIPSIZE_END);
 102   gtk_misc_set_alignment(GTK_MISC(report_label), 0, 0);
 103   gtk_container_add(GTK_CONTAINER(vbox), gtk_hseparator_new());
 104   gtk_container_add(GTK_CONTAINER(vbox), report_label);
 105   return vbox;
 106 }
 107
 108 static GtkWidget *notebook(void) {
 109   tabs = gtk_notebook_new();
 110   g_signal_connect(tabs, "switch-page", G_CALLBACK(tab_switched), 0);
 111   gtk_notebook_append_page(GTK_NOTEBOOK(tabs), queue_widget(),
 112                            gtk_label_new("Queue"));
 113   gtk_notebook_append_page(GTK_NOTEBOOK(tabs), recent_widget(),
 114                            gtk_label_new("Recent"));
 115   gtk_notebook_append_page(GTK_NOTEBOOK(tabs), choose_widget(),
 116                            gtk_label_new("Choose"));
 117   return tabs;
 118 }
 119
 120 static void make_toplevel_window(void) {
 121   GtkWidget *const vbox = gtk_vbox_new(FALSE, 1);
 122   GtkWidget *const rb = report_box();
 123
 124   D(("top_window"));
 125   toplevel = gtk_window_new(GTK_WINDOW_TOPLEVEL);
 126   /* default size is too small */
 127   gtk_window_set_default_size(GTK_WINDOW(toplevel), 640, 480);
 128   /* terminate on close */
 129   g_signal_connect(G_OBJECT(toplevel), "delete_event",
 130                    G_CALLBACK(delete_event), NULL);
 131   /* lay out the window */
 132   gtk_window_set_title(GTK_WINDOW(toplevel), "Disobedience");
 133   gtk_container_add(GTK_CONTAINER(toplevel), vbox);
 134   /* lay out the vbox */
 135   gtk_box_pack_start(GTK_BOX(vbox),
 136                      menubar(toplevel),
 137                      FALSE,             /* expand */
 138                      FALSE,             /* fill */
 139                      0);
 140   gtk_box_pack_start(GTK_BOX(vbox),
 141                      control_widget(),
 142                      FALSE,             /* expand */
 143                      FALSE,             /* fill */
 144                      0);
 145   gtk_container_add(GTK_CONTAINER(vbox), notebook());
 146   gtk_box_pack_end(GTK_BOX(vbox),
 147                    rb,
 148                    FALSE,             /* expand */
 149                    FALSE,             /* fill */
 150                    0);
 151   gtk_widget_set_name(toplevel, "disobedience");
 152 }
 153
 154 /* State monitoring -------------------------------------------------------- */
 155
 156 static void all_update(void) {
 157   playing_update();
 158   queue_update();
 159   recent_update();
 160   control_update();
 161 }
 162
 163 static void log_connected(void attribute((unused)) *v) {
 164   struct callbackdata *cbd;
 165
 166   /* Don't know what we might have missed while disconnected so update
 167    * everything.  We get this at startup too and this is how we do the initial
 168    * state fetch. */
 169   all_update();
 170   /* Re-get the volume */
 171   cbd = xmalloc(sizeof *cbd);
 172   cbd->onerror = 0;
 173   disorder_eclient_volume(client, log_volume, -1, -1, cbd);
 174 }
 175
 176 static void log_completed(void attribute((unused)) *v,
 177                           const char attribute((unused)) *track) {
 178   playing = 0;
 179   playing_update();
 180   control_update();
 181 }
 182
 183 static void log_failed(void attribute((unused)) *v,
 184                        const char attribute((unused)) *track,
 185                        const char attribute((unused)) *status) {
 186   playing = 0;
 187   playing_update();
 188   control_update();
 189 }
 190
 191 static void log_moved(void attribute((unused)) *v,
 192                       const char attribute((unused)) *user) {
 193    queue_update();
 194 }
 195
 196 static void log_playing(void attribute((unused)) *v,
 197                         const char attribute((unused)) *track,
 198                         const char attribute((unused)) *user) {
 199   playing = 1;
 200   playing_update();
 201   control_update();
 202   /* we get a log_removed() anyway so we don't need to update_queue() from
 203    * here */
 204 }
 205
 206 static void log_queue(void attribute((unused)) *v,
 207                       struct queue_entry attribute((unused)) *q) {
 208   queue_update();
 209 }
 210
 211 static void log_recent_added(void attribute((unused)) *v,
 212                              struct queue_entry attribute((unused)) *q) {
 213   recent_update();
 214 }
 215
 216 static void log_recent_removed(void attribute((unused)) *v,
 217                                const char attribute((unused)) *id) {
 218   /* nothing - log_recent_added() will trigger the relevant update */
 219 }
 220
 221 static void log_removed(void attribute((unused)) *v,
 222                         const char attribute((unused)) *id,
 223                         const char attribute((unused)) *user) {
 224   queue_update();
 225 }
 226
 227 static void log_scratched(void attribute((unused)) *v,
 228                           const char attribute((unused)) *track,
 229                           const char attribute((unused)) *user) {
 230   playing = 0;
 231   playing_update();
 232   control_update();
 233 }
 234
 235 static void log_state(void attribute((unused)) *v,
 236                       unsigned long state) {
 237   last_state = state;
 238   control_update();
 239   /* If the track is paused or resume then the currently playing track is
 240    * refetched so that we can continue to correctly calculate the played so-far
 241    * field */
 242   playing_update();
 243 }
 244
 245 static void log_volume(void attribute((unused)) *v,
 246                        int l, int r) {
 247   if(volume_l != l || volume_r != r) {
 248     volume_l = l;
 249     volume_r = r;
 250     control_update();
 251   }
 252 }
 253
 254 #if MDEBUG
 255 static int widget_count, container_count;
 256
 257 static void count_callback(GtkWidget *w,
 258                            gpointer attribute((unused)) data) {
 259   ++widget_count;
 260   if(GTK_IS_CONTAINER(w)) {
 261     ++container_count;
 262     gtk_container_foreach(GTK_CONTAINER(w), count_callback, 0);
 263   }
 264 }
 265
 266 static void count_widgets(void) {
 267   widget_count = 0;
 268   container_count = 1;
 269   if(toplevel)
 270     gtk_container_foreach(GTK_CONTAINER(toplevel), count_callback, 0);
 271   fprintf(stderr, "widget count: %8d  container count: %8d\n",
 272           widget_count, container_count);
 273 }
 274 #endif
 275
 276 #if MTRACK
 277 const char *mtag = "init";
 278 static hash *mtrack_hash;
 279
 280 static int *mthfind(const char *tag) {
 281   static const int zero = 0;
 282   int *cp = hash_find(mtrack_hash, tag);
 283   if(!cp) {
 284     hash_add(mtrack_hash, tag, &zero, HASH_INSERT);
 285     cp = hash_find(mtrack_hash, tag);
 286   }
 287   return cp;
 288 }
 289
 290 static void *trap_malloc(size_t n) {
 291   void *ptr = malloc(n + sizeof(char *));
 292
 293   *(const char **)ptr = mtag;
 294   ++*mthfind(mtag);
 295   return (char *)ptr + sizeof(char *);
 296 }
 297
 298 static void trap_free(void *ptr) {
 299   const char *tag;
 300   if(!ptr)
 301     return;
 302   ptr = (char *)ptr - sizeof(char *);
 303   tag = *(const char **)ptr;
 304   --*mthfind(tag);
 305   free(ptr);
 306 }
 307
 308 static void *trap_realloc(void *ptr, size_t n) {
 309   if(!ptr)
 310     return trap_malloc(n);
 311   if(!n) {
 312     trap_free(ptr);
 313     return 0;
 314   }
 315   ptr = (char *)ptr - sizeof(char *);
 316   ptr = realloc(ptr, n + sizeof(char *));
 317   *(const char **)ptr = mtag;
 318   return (char *)ptr + sizeof(char *);
 319 }
 320
 321 static int report_tags_callback(const char *key, void *value,
 322                                 void attribute((unused)) *u) {
 323   fprintf(stderr, "%16s: %d\n", key, *(int *)value);
 324   return 0;
 325 }
 326
 327 static void report_tags(void) {
 328   hash_foreach(mtrack_hash, report_tags_callback, 0);
 329   fprintf(stderr, "\n");
 330 }
 331
 332 static const GMemVTable glib_memvtable = {
 333   trap_malloc,
 334   trap_realloc,
 335   trap_free,
 336   0,
 337   0,
 338   0
 339 };
 340 #endif
 341
 342 /* Called once every 10 minutes */
 343 static gboolean periodic(gpointer attribute((unused)) data) {
 344   D(("periodic"));
 345   /* Expire cached data */
 346   cache_expire();
 347   /* Update everything to be sure that the connection to the server hasn't
 348    * mysteriously gone stale on us. */
 349   all_update();
 350 #if MDEBUG
 351   count_widgets();
 352   fprintf(stderr, "cache size: %zu\n", cache_count());
 353 #endif
 354 #if MTRACK
 355   report_tags();
 356 #endif
 357   return TRUE;                          /* don't remove me */
 358 }
 359
 360 static gboolean heartbeat(gpointer attribute((unused)) data) {
 361   static struct timeval last;
 362   struct timeval now;
 363   double delta;
 364
 365   xgettimeofday(&now, 0);
 366   if(last.tv_sec) {
 367     delta = (now.tv_sec + now.tv_sec / 1.0E6)
 368       - (last.tv_sec + last.tv_sec / 1.0E6);
 369     if(delta >= 1.0625)
 370       fprintf(stderr, "%f: %fs between 1s heartbeats\n",
 371               now.tv_sec + now.tv_sec / 1.0E6,
 372               delta);
 373   }
 374   last = now;
 375   return TRUE;
 376 }
 377
 378 /* main -------------------------------------------------------------------- */
 379
 380 static const struct option options[] = {
 381   { "help", no_argument, 0, 'h' },
 382   { "version", no_argument, 0, 'V' },
 383   { "config", required_argument, 0, 'c' },
 384   { "tufnel", no_argument, 0, 't' },
 385   { "choosealpha", no_argument, 0, 'C' },
 386   { "debug", no_argument, 0, 'd' },
 387   { 0, 0, 0, 0 }
 388 };
 389
 390 /* display usage message and terminate */
 391 static void help(void) {
 392   xprintf("Disobedience - GUI client for DisOrder\n"
 393           "\n"
 394           "Usage:\n"
 395           "  disobedience [OPTIONS]\n"
 396           "Options:\n"
 397           "  --help, -h              Display usage message\n"
 398           "  --version, -V           Display version number\n"
 399           "  --config PATH, -c PATH  Set configuration file\n"
 400           "  --debug, -d             Turn on debugging\n"
 401           "\n"
 402           "Also GTK+ options will work.\n");
 403   xfclose(stdout);
 404   exit(0);
 405 }
 406
 407 /* display version number and terminate */
 408 static void version(void) {
 409   xprintf("disorder version %s\n", disorder_version_string);
 410   xfclose(stdout);
 411   exit(0);
 412 }
 413
 414 int main(int argc, char **argv) {
 415   int n;
 416   disorder_eclient *logclient;
 417
 418   mem_init();
 419   /* garbage-collect PCRE's memory */
 420   pcre_malloc = xmalloc;
 421   pcre_free = xfree;
 422 #if MTRACK
 423   mtrack_hash = hash_new(sizeof (int));
 424   g_mem_set_vtable((GMemVTable *)&glib_memvtable);
 425 #endif
 426   if(!setlocale(LC_CTYPE, "")) fatal(errno, "error calling setlocale");
 427   gtk_init(&argc, &argv);
 428   gtk_rc_parse_string(style);
 429   while((n = getopt_long(argc, argv, "hVc:dtH", options, 0)) >= 0) {
 430     switch(n) {
 431     case 'h': help();
 432     case 'V': version();
 433     case 'c': configfile = optarg; break;
 434     case 'd': debugging = 1; break;
 435     case 't': goesupto = 11; break;
 436     case 'C': choosealpha = 1; break;   /* not well tested any more */
 437     default: fatal(0, "invalid option");
 438     }
 439   }
 440   signal(SIGPIPE, SIG_IGN);
 441   /* create the event loop */
 442   D(("create main loop"));
 443   mainloop = g_main_loop_new(0, 0);
 444   if(config_read()) fatal(0, "cannot read configuration");
 445   /* create the clients */
 446   if(!(client = gtkclient())
 447      || !(logclient = gtkclient()))
 448     return 1;                           /* already reported an error */
 449   disorder_eclient_log(logclient, &gdisorder_log_callbacks, 0);
 450   /* periodic operations (e.g. expiring the cache) */
 451 #if MDEBUG || MTRACK
 452   g_timeout_add(5000/*milliseconds*/, periodic, 0);
 453 #else
 454   g_timeout_add(600000/*milliseconds*/, periodic, 0);
 455 #endif
 456   /* The point of this is to try and get a handle on mysterious
 457    * unresponsiveness.  It's not very useful in production use. */
 458   if(0)
 459     g_timeout_add(1000/*milliseconds*/, heartbeat, 0);
 460   make_toplevel_window();
 461   /* reset styles now everything has its name */
 462   gtk_rc_reset_styles(gtk_settings_get_for_screen(gdk_screen_get_default()));
 463   gtk_widget_show_all(toplevel);
 464   D(("enter main loop"));
 465   MTAG("misc");
 466   g_main_loop_run(mainloop);
 467   return 0;
 468 }
 469
 470 /*
 471 Local Variables:
 472 c-basic-offset:2
 473 comment-column:40
 474 fill-column:79
 475 indent-tabs-mode:nil
 476 End:
 477 */