pl.c

   1 /*
   2  * Copyright 2006 Timo Hirvonen
   3  */
   4
   5 #include "pl.h"
   6 #include "editable.h"
   7 #include "options.h"
   8 #include "xmalloc.h"
   9
  10 struct editable pl_editable;
  11 struct simple_track *pl_cur_track = NULL;
  12
  13 static LIST_HEAD(pl_shuffle_head);
  14
  15 static void pl_free_track(struct list_head *item)
  16 {
  17         struct simple_track *track = to_simple_track(item);
  18
  19         if (track == pl_cur_track)
  20                 pl_cur_track = NULL;
  21
  22         list_del(&((struct shuffle_track *)track)->node);
  23         track_info_unref(track->info);
  24         free(track);
  25 }
  26
  27 void pl_init(void)
  28 {
  29         editable_init(&pl_editable, pl_free_track);
  30 }
  31
  32 static int dummy_filter(const struct simple_track *track)
  33 {
  34         return 1;
  35 }
  36
  37 static struct track_info *set_track(struct simple_track *track)
  38 {
  39         struct track_info *ti = NULL;
  40
  41         if (track) {
  42                 pl_cur_track = track;
  43                 ti = track->info;
  44                 track_info_ref(ti);
  45                 pl_editable.win->changed = 1;
  46         }
  47         return ti;
  48 }
  49
  50 struct track_info *pl_set_next(void)
  51 {
  52         struct simple_track *track;
  53
  54         if (list_empty(&pl_editable.head))
  55                 return NULL;
  56
  57         if (shuffle) {
  58                 track = (struct simple_track *)shuffle_list_get_next(&pl_shuffle_head,
  59                                 (struct shuffle_track *)pl_cur_track, dummy_filter);
  60         } else {
  61                 track = simple_list_get_next(&pl_editable.head, pl_cur_track, dummy_filter);
  62         }
  63         return set_track(track);
  64 }
  65
  66 struct track_info *pl_set_prev(void)
  67 {
  68         struct simple_track *track;
  69
  70         if (list_empty(&pl_editable.head))
  71                 return NULL;
  72
  73         if (shuffle) {
  74                 track = (struct simple_track *)shuffle_list_get_prev(&pl_shuffle_head,
  75                                 (struct shuffle_track *)pl_cur_track, dummy_filter);
  76         } else {
  77                 track = simple_list_get_prev(&pl_editable.head, pl_cur_track, dummy_filter);
  78         }
  79         return set_track(track);
  80 }
  81
  82 struct track_info *pl_set_selected(void)
  83 {
  84         struct iter sel;
  85
  86         if (list_empty(&pl_editable.head))
  87                 return NULL;
  88
  89         window_get_sel(pl_editable.win, &sel);
  90         return set_track(iter_to_simple_track(&sel));
  91 }
  92
  93 void pl_sel_current(void)
  94 {
  95         if (pl_cur_track) {
  96                 struct iter iter;
  97
  98                 editable_track_to_iter(&pl_editable, pl_cur_track, &iter);
  99                 window_set_sel(pl_editable.win, &iter);
 100         }
 101 }
 102
 103 void pl_add_track(struct track_info *ti)
 104 {
 105         struct shuffle_track *track = xnew(struct shuffle_track, 1);
 106
 107         track_info_ref(ti);
 108         simple_track_init((struct simple_track *)track, ti);
 109         list_add_rand(&pl_shuffle_head, &track->node, pl_editable.nr_tracks);
 110         editable_add(&pl_editable, (struct simple_track *)track);
 111 }
 112
 113 void pl_reshuffle(void)
 114 {
 115         reshuffle(&pl_shuffle_head);
 116 }
 117
 118 int pl_for_each(int (*cb)(void *data, struct track_info *ti), void *data)
 119 {
 120         struct simple_track *track;
 121         int rc = 0;
 122
 123         list_for_each_entry(track, &pl_editable.head, node) {
 124                 rc = cb(data, track->info);
 125                 if (rc)
 126                         break;
 127         }
 128         return rc;
 129 }