chiark / gitweb /
0b6e099d0145f9517f4d9478ab0644df13172574
[disorder] / disobedience / disobedience.c
1 /*
2  * This file is part of DisOrder.
3  * Copyright (C) 2006-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 3 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,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13  * GNU 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, see <http://www.gnu.org/licenses/>.
17  */
18 /** @file disobedience/disobedience.c
19  * @brief Main Disobedience program
20  */
21
22 #include "disobedience.h"
23 #include "version.h"
24
25 #include <getopt.h>
26 #include <locale.h>
27 #include <pcre.h>
28 #include <gcrypt.h>
29
30 /* Apologies for the numerous de-consting casts, but GLib et al do not seem to
31  * have heard of const. */
32
33 /* Variables --------------------------------------------------------------- */
34
35 /** @brief Event loop */
36 GMainLoop *mainloop;
37
38 /** @brief Top-level window */
39 GtkWidget *toplevel;
40
41 /** @brief Label for progress indicator */
42 GtkWidget *report_label;
43
44 /** @brief Main tab group */
45 GtkWidget *tabs;
46
47 /** @brief Mini-mode widget for playing track */
48 GtkWidget *playing_mini;
49
50 /** @brief Main client */
51 disorder_eclient *client;
52
53 /** @brief Log client */
54 disorder_eclient *logclient;
55
56 /** @brief Last reported state
57  *
58  * This is updated by log_state().
59  */
60 unsigned long last_state;
61
62 /** @brief True if some track is playing
63  *
64  * This ought to be removed in favour of last_state & DISORDER_PLAYING
65  */
66 int playing;
67
68 /** @brief Left channel volume */
69 int volume_l;
70
71 /** @brief Right channel volume */
72 int volume_r;
73
74 /** @brief Audio backend */
75 const struct uaudio *backend;
76
77 double goesupto = 10;                   /* volume upper bound */
78
79 /** @brief True if a NOP is in flight */
80 static int nop_in_flight;
81
82 /** @brief True if an rtp-address command is in flight */
83 static int rtp_address_in_flight;
84
85 /** @brief True if a rights lookup is in flight */
86 static int rights_lookup_in_flight;
87
88 /** @brief Current rights bitmap */
89 rights_type last_rights;
90
91 /** @brief True if RTP play is available
92  *
93  * This is a bit of a bodge...
94  */
95 int rtp_supported;
96
97 /** @brief True if RTP play is enabled */
98 int rtp_is_running;
99
100 /** @brief Server version */
101 const char *server_version;
102
103 /** @brief Parsed server version */
104 long server_version_bytes;
105
106 static GtkWidget *queue;
107
108 static GtkWidget *notebook_box;
109
110 static void check_rtp_address(const char *event,
111                               void *eventdata,
112                               void *callbackdata);
113
114 /* Window creation --------------------------------------------------------- */
115
116 /* Note that all the client operations kicked off from here will only complete
117  * after we've entered the event loop. */
118
119 /** @brief Called when main window is deleted
120  *
121  * Terminates the program.
122  */
123 static gboolean delete_event(GtkWidget attribute((unused)) *widget,
124                              GdkEvent attribute((unused)) *event,
125                              gpointer attribute((unused)) data) {
126   D(("delete_event"));
127   exit(0);                              /* die immediately */
128 }
129
130 /** @brief Called when the current tab is switched
131  *
132  * Updates the menu settings to correspond to the new page.
133  */
134 static void tab_switched(GtkNotebook *notebook,
135                          GtkNotebookPage attribute((unused)) *page,
136                          guint page_num,
137                          gpointer attribute((unused)) user_data) {
138   GtkWidget *const tab = gtk_notebook_get_nth_page(notebook, page_num);
139   const struct tabtype *const t = g_object_get_data(G_OBJECT(tab), "type");
140   assert(t != 0);
141   if(t->selected)
142     t->selected();
143 }
144
145 /** @brief Create the report box */
146 static GtkWidget *report_box(void) {
147   GtkWidget *vbox = gtk_vbox_new(FALSE, 0);
148
149   report_label = gtk_label_new("");
150   gtk_label_set_ellipsize(GTK_LABEL(report_label), PANGO_ELLIPSIZE_END);
151   gtk_misc_set_alignment(GTK_MISC(report_label), 0, 0);
152   gtk_container_add(GTK_CONTAINER(vbox), gtk_hseparator_new());
153   gtk_container_add(GTK_CONTAINER(vbox), report_label);
154   return vbox;
155 }
156
157 /** @brief Create and populate the main tab group */
158 static GtkWidget *notebook(void) {
159   tabs = gtk_notebook_new();
160   /* The current tab is _NORMAL, the rest are _ACTIVE, which is bizarre but
161    * produces not too dreadful appearance */
162   gtk_widget_set_style(tabs, tool_style);
163   g_signal_connect(tabs, "switch-page", G_CALLBACK(tab_switched), 0);
164   gtk_notebook_append_page(GTK_NOTEBOOK(tabs), queue = queue_widget(),
165                            gtk_label_new("Queue"));
166   gtk_notebook_append_page(GTK_NOTEBOOK(tabs), recent_widget(),
167                            gtk_label_new("Recent"));
168   gtk_notebook_append_page(GTK_NOTEBOOK(tabs), choose_widget(),
169                            gtk_label_new("Choose"));
170   gtk_notebook_append_page(GTK_NOTEBOOK(tabs), added_widget(),
171                            gtk_label_new("Added"));
172   return tabs;
173 }
174
175 /* Tracking of window sizes */
176 static int toplevel_width = 640, toplevel_height = 480;
177 static int mini_width = 480, mini_height = 140;
178 static struct timeval last_mode_switch;
179
180 static void main_minimode(const char attribute((unused)) *event,
181                           void attribute((unused)) *evendata,
182                           void attribute((unused)) *callbackdata) {
183   if(full_mode) {
184     gtk_window_resize(GTK_WINDOW(toplevel), toplevel_width, toplevel_height);
185     gtk_widget_show(tabs);
186     gtk_widget_hide(playing_mini);
187     /* Show the queue (bit confusing otherwise!) */
188     gtk_notebook_set_current_page(GTK_NOTEBOOK(tabs), 0);
189   } else {
190     gtk_window_resize(GTK_WINDOW(toplevel), mini_width, mini_height);
191     gtk_widget_hide(tabs);
192     gtk_widget_show(playing_mini);
193   }
194   xgettimeofday(&last_mode_switch, NULL);
195 }
196
197 /* Called when the window size is allocate */
198 static void toplevel_size_allocate(GtkWidget attribute((unused)) *w,
199                                    GtkAllocation *a,
200                                    gpointer attribute((unused)) user_data) {
201   struct timeval now;
202   xgettimeofday(&now, NULL);
203   if(tvdouble(tvsub(now, last_mode_switch)) < 0.5) {
204     /* Suppress size-allocate signals that are within half a second of a mode
205      * switch: they are quite likely to be the result of re-arranging widgets
206      * within the old size, not the application of the new size.  Yes, this is
207      * a disgusting hack! */
208     return;                             /* OMG too soon! */
209   }
210   if(full_mode) {
211     toplevel_width = a->width;
212     toplevel_height = a->height;
213   } else {
214     mini_width = a->width;
215     mini_height = a->height;
216   }
217 }
218
219 /* Periodically check the toplevel's size
220  * (the hack in toplevel_size_allocate() means we could in principle
221  * miss a user-initiated resize)
222  */
223 static void check_toplevel_size(const char attribute((unused)) *event,
224                                 void attribute((unused)) *evendata,
225                                 void attribute((unused)) *callbackdata) {
226   GtkAllocation a;
227   gtk_window_get_size(GTK_WINDOW(toplevel), &a.width, &a.height);
228   toplevel_size_allocate(NULL, &a, NULL);
229 }
230
231 /** @brief Create and populate the main window */
232 static void make_toplevel_window(void) {
233   GtkWidget *const vbox = gtk_vbox_new(FALSE/*homogeneous*/, 1/*spacing*/);
234   GtkWidget *const rb = report_box();
235
236   D(("top_window"));
237   toplevel = gtk_window_new(GTK_WINDOW_TOPLEVEL);
238   /* default size is too small */
239   gtk_window_set_default_size(GTK_WINDOW(toplevel),
240                               toplevel_width, toplevel_height);
241   /* terminate on close */
242   g_signal_connect(G_OBJECT(toplevel), "delete_event",
243                    G_CALLBACK(delete_event), NULL);
244   /* track size */
245   g_signal_connect(G_OBJECT(toplevel), "size-allocate",
246                    G_CALLBACK(toplevel_size_allocate), NULL);
247   /* lay out the window */
248   gtk_window_set_title(GTK_WINDOW(toplevel), "Disobedience");
249   gtk_container_add(GTK_CONTAINER(toplevel), vbox);
250   /* lay out the vbox */
251   gtk_box_pack_start(GTK_BOX(vbox),
252                      menubar(toplevel),
253                      FALSE,             /* expand */
254                      FALSE,             /* fill */
255                      0);
256   gtk_box_pack_start(GTK_BOX(vbox),
257                      control_widget(),
258                      FALSE,             /* expand */
259                      FALSE,             /* fill */
260                      0);
261   playing_mini = playing_widget();
262   gtk_box_pack_start(GTK_BOX(vbox),
263                      playing_mini,
264                      FALSE,
265                      FALSE,
266                      0);
267   notebook_box = gtk_vbox_new(FALSE, 0);
268   gtk_container_add(GTK_CONTAINER(notebook_box), notebook());
269   gtk_container_add(GTK_CONTAINER(vbox), notebook_box);
270   gtk_box_pack_end(GTK_BOX(vbox),
271                    rb,
272                    FALSE,             /* expand */
273                    FALSE,             /* fill */
274                    0);
275   gtk_widget_set_style(toplevel, tool_style);
276   event_register("mini-mode-changed", main_minimode, 0);
277   event_register("periodic-fast", check_toplevel_size, 0);
278 }
279
280 static void userinfo_rights_completed(void attribute((unused)) *v,
281                                       const char *err,
282                                       const char *value) {
283   rights_type r;
284
285   if(err) {
286     popup_protocol_error(0, err);
287     r = 0;
288   } else {
289     if(parse_rights(value, &r, 0))
290       r = 0;
291   }
292   /* If rights have changed, signal everything that cares */
293   if(r != last_rights) {
294     last_rights = r;
295     ++suppress_actions;
296     event_raise("rights-changed", 0);
297     --suppress_actions;
298   }
299   rights_lookup_in_flight = 0;
300 }
301
302 static void check_rights(void) {
303   if(!rights_lookup_in_flight) {
304     rights_lookup_in_flight = 1;
305     disorder_eclient_userinfo(client,
306                               userinfo_rights_completed,
307                               config->username, "rights",
308                               0);
309   }
310 }
311
312 /** @brief Called occasionally */
313 static gboolean periodic_slow(gpointer attribute((unused)) data) {
314   D(("periodic_slow"));
315   /* Expire cached data */
316   cache_expire();
317   /* Update everything to be sure that the connection to the server hasn't
318    * mysteriously gone stale on us. */
319   all_update();
320   event_raise("periodic-slow", 0);
321   /* Recheck RTP status too */
322   check_rtp_address(0, 0, 0);
323   return TRUE;                          /* don't remove me */
324 }
325
326 /** @brief Called frequently */
327 static gboolean periodic_fast(gpointer attribute((unused)) data) {
328 #if 0                                   /* debugging hack */
329   static struct timeval last;
330   struct timeval now;
331   double delta;
332
333   xgettimeofday(&now, 0);
334   if(last.tv_sec) {
335     delta = (now.tv_sec + now.tv_sec / 1.0E6) 
336       - (last.tv_sec + last.tv_sec / 1.0E6);
337     if(delta >= 1.0625)
338       fprintf(stderr, "%f: %fs between 1s heartbeats\n", 
339               now.tv_sec + now.tv_sec / 1.0E6,
340               delta);
341   }
342   last = now;
343 #endif
344   if(rtp_supported && backend && backend->get_volume) {
345     int nl, nr;
346     backend->get_volume(&nl, &nr);
347     if(nl != volume_l || nr != volume_r) {
348       volume_l = nl;
349       volume_r = nr;
350       event_raise("volume-changed", 0);
351     }
352   }
353   /* Periodically check what our rights are */
354   int recheck_rights = 1;
355   if(server_version_bytes >= 0x04010000)
356     /* Server versions after 4.1 will send updates */
357     recheck_rights = 0;
358   if((server_version_bytes & 0xFF) == 0x01)
359     /* Development servers might do regardless of their version number */
360     recheck_rights = 0;
361   if(recheck_rights)
362     check_rights();
363   event_raise("periodic-fast", 0);
364   return TRUE;
365 }
366
367 /** @brief Called when a NOP completes */
368 static void nop_completed(void attribute((unused)) *v,
369                           const char attribute((unused)) *err) {
370   /* TODO report the error somewhere */
371   nop_in_flight = 0;
372 }
373
374 /** @brief Called from time to time to arrange for a NOP to be sent
375  *
376  * At most one NOP remains in flight at any moment.  If the client is not
377  * currently connected then no NOP is sent.
378  */
379 static gboolean maybe_send_nop(gpointer attribute((unused)) data) {
380   if(!nop_in_flight && (disorder_eclient_state(client) & DISORDER_CONNECTED)) {
381     nop_in_flight = 1;
382     disorder_eclient_nop(client, nop_completed, 0);
383   }
384   if(rtp_supported) {
385     const int rtp_was_running = rtp_is_running;
386     rtp_is_running = rtp_running();
387     if(rtp_was_running != rtp_is_running)
388       event_raise("rtp-changed", 0);
389   }
390   return TRUE;                          /* keep call me please */
391 }
392
393 /** @brief Called when a rtp-address command succeeds */
394 static void got_rtp_address(void attribute((unused)) *v,
395                             const char *err,
396                             int attribute((unused)) nvec,
397                             char attribute((unused)) **vec) {
398   const int rtp_was_supported = rtp_supported;
399   const int rtp_was_running = rtp_is_running;
400
401   ++suppress_actions;
402   rtp_address_in_flight = 0;
403   if(err) {
404     /* An error just means that we're not using network play */
405     rtp_supported = 0;
406     rtp_is_running = 0;
407   } else {
408     rtp_supported = 1;
409     rtp_is_running = rtp_running();
410   }
411   /*fprintf(stderr, "rtp supported->%d, running->%d\n",
412           rtp_supported, rtp_is_running);*/
413   if(rtp_supported != rtp_was_supported
414      || rtp_is_running != rtp_was_running)
415     event_raise("rtp-changed", 0);
416   --suppress_actions;
417 }
418
419 /** @brief Called to check whether RTP play is available */
420 static void check_rtp_address(const char attribute((unused)) *event,
421                               void attribute((unused)) *eventdata,
422                               void attribute((unused)) *callbackdata) {
423   if(!rtp_address_in_flight) {
424     //fprintf(stderr, "checking rtp\n");
425     disorder_eclient_rtp_address(client, got_rtp_address, NULL);
426   }
427 }
428
429 /* main -------------------------------------------------------------------- */
430
431 static const struct option options[] = {
432   { "help", no_argument, 0, 'h' },
433   { "version", no_argument, 0, 'V' },
434   { "config", required_argument, 0, 'c' },
435   { "tufnel", no_argument, 0, 't' },
436   { "debug", no_argument, 0, 'd' },
437   { 0, 0, 0, 0 }
438 };
439
440 /* display usage message and terminate */
441 static void help(void) {
442   xprintf("Disobedience - GUI client for DisOrder\n"
443           "\n"
444           "Usage:\n"
445           "  disobedience [OPTIONS]\n"
446           "Options:\n"
447           "  --help, -h              Display usage message\n"
448           "  --version, -V           Display version number\n"
449           "  --config PATH, -c PATH  Set configuration file\n"
450           "  --debug, -d             Turn on debugging\n"
451           "\n"
452           "Also GTK+ options will work.\n");
453   xfclose(stdout);
454   exit(0);
455 }
456
457 static void version_completed(void attribute((unused)) *v,
458                               const char attribute((unused)) *err,
459                               const char *ver) {
460   long major, minor, patch, dev;
461
462   if(!ver) {
463     server_version = 0;
464     server_version_bytes = 0;
465     return;
466   }
467   server_version = ver;
468   server_version_bytes = 0;
469   major = strtol(ver, (char **)&ver, 10);
470   if(*ver != '.')
471     return;
472   ++ver;
473   minor = strtol(ver, (char **)&ver, 10);
474   if(*ver == '.') {
475     ++ver;
476     patch = strtol(ver, (char **)&ver, 10);
477   } else
478     patch = 0;
479   if(*ver) {
480     if(*ver == '+') {
481       dev = 1;
482       ++ver;
483     }
484     if(*ver)
485       dev = 2;
486   } else
487     dev = 0;
488   server_version_bytes = (major << 24) + (minor << 16) + (patch << 8) + dev;
489 }
490
491 void logged_in(void) {
492   /* reset the clients */
493   disorder_eclient_close(client);
494   disorder_eclient_close(logclient);
495   rtp_supported = 0;
496   event_raise("logged-in", 0);
497   /* Force the periodic checks */
498   periodic_slow(0);
499   periodic_fast(0);
500   /* Recheck server version */
501   disorder_eclient_version(client, version_completed, 0);
502   disorder_eclient_enable_connect(client);
503   disorder_eclient_enable_connect(logclient);
504 }
505
506 int main(int argc, char **argv) {
507   int n;
508   gboolean gtkok;
509
510   mem_init();
511   /* garbage-collect PCRE's memory */
512   pcre_malloc = xmalloc;
513   pcre_free = xfree;
514   if(!setlocale(LC_CTYPE, "")) disorder_fatal(errno, "error calling setlocale");
515   gtkok = gtk_init_check(&argc, &argv);
516   while((n = getopt_long(argc, argv, "hVc:dtHC", options, 0)) >= 0) {
517     switch(n) {
518     case 'h': help();
519     case 'V': version("disobedience");
520     case 'c': configfile = optarg; break;
521     case 'd': debugging = 1; break;
522     case 't': goesupto = 11; break;
523     default: disorder_fatal(0, "invalid option");
524     }
525   }
526   if(!gtkok)
527     disorder_fatal(0, "failed to initialize GTK+");
528   /* gcrypt initialization */
529   if(!gcry_check_version(NULL))
530     disorder_fatal(0, "gcry_check_version failed");
531   gcry_control(GCRYCTL_INIT_SECMEM, 0);
532   gcry_control (GCRYCTL_INITIALIZATION_FINISHED, 0);
533   signal(SIGPIPE, SIG_IGN);
534   init_styles();
535   load_settings();
536   /* create the event loop */
537   D(("create main loop"));
538   mainloop = g_main_loop_new(0, 0);
539   if(config_read(0, NULL)) disorder_fatal(0, "cannot read configuration");
540   /* we'll need mixer support */
541   backend = uaudio_apis[0];
542   if(backend->configure)
543     backend->configure();
544   if(backend->open_mixer)
545     backend->open_mixer();
546   /* create the clients */
547   if(!(client = gtkclient())
548      || !(logclient = gtkclient()))
549     return 1;                           /* already reported an error */
550   /* periodic operations (e.g. expiring the cache, checking local volume) */
551   g_timeout_add(600000/*milliseconds*/, periodic_slow, 0);
552   g_timeout_add(1000/*milliseconds*/, periodic_fast, 0);
553   make_toplevel_window();
554   /* reset styles now everything has its name */
555   gtk_rc_reset_styles(gtk_settings_get_for_screen(gdk_screen_get_default()));
556   gtk_widget_show_all(toplevel);
557   gtk_widget_hide(playing_mini);
558   /* issue a NOP every so often */
559   g_timeout_add_full(G_PRIORITY_LOW,
560                      2000/*interval, ms*/,
561                      maybe_send_nop,
562                      0/*data*/,
563                      0/*notify*/);
564   /* Start monitoring the log */
565   disorder_eclient_log(logclient, &log_callbacks, 0);
566   /* Initiate all the checks */
567   periodic_fast(0);
568   disorder_eclient_version(client, version_completed, 0);
569   event_register("log-connected", check_rtp_address, 0);
570   suppress_actions = 0;
571   playlists_init();
572   globals_init();
573   /* If no password is set yet pop up a login box */
574   if(!config->password)
575     login_box();
576   D(("enter main loop"));
577   g_main_loop_run(mainloop);
578   return 0;
579 }
580
581 /*
582 Local Variables:
583 c-basic-offset:2
584 comment-column:40
585 fill-column:79
586 indent-tabs-mode:nil
587 End:
588 */