765079df94
Signed-off-by: Anna Schumaker <Anna@OcarinaProject.net>
237 lines
4.2 KiB
C++
237 lines
4.2 KiB
C++
/**
|
|
* Copyright 2013 (c) Anna Schumaker.
|
|
*/
|
|
#include <core/deck.h>
|
|
#include <core/file.h>
|
|
#include <core/library.h>
|
|
|
|
|
|
class RecentQueue : public Queue
|
|
{
|
|
public:
|
|
RecentQueue() : Queue(Q_ENABLED | Q_REPEAT | Q_NO_SORT) {}
|
|
|
|
unsigned int add(struct track *track)
|
|
{
|
|
del(track);
|
|
_cur = 0;
|
|
return _add_at(track, 0);
|
|
}
|
|
};
|
|
|
|
|
|
static std::list<TempQueue> queue_deck;
|
|
static RecentQueue recent_queue;
|
|
static struct file deck_file;
|
|
|
|
|
|
TempQueue :: TempQueue() {}
|
|
TempQueue :: TempQueue(bool random)
|
|
: Queue(Q_ENABLED | (random ? Q_RANDOM : 0)) {}
|
|
|
|
void TempQueue :: set_flag(queue_flags flag)
|
|
{
|
|
Queue :: set_flag(flag);
|
|
deck :: write();
|
|
}
|
|
|
|
void TempQueue :: unset_flag(queue_flags flag)
|
|
{
|
|
Queue :: unset_flag(flag);
|
|
deck :: write();
|
|
}
|
|
|
|
unsigned int TempQueue :: add(struct track *track)
|
|
{
|
|
unsigned int res = Queue :: add(track);
|
|
deck :: write();
|
|
return res;
|
|
}
|
|
|
|
void TempQueue :: del(struct track *track)
|
|
{
|
|
Queue :: del(track);
|
|
deck :: write();
|
|
}
|
|
|
|
void TempQueue :: del(unsigned int id)
|
|
{
|
|
Queue :: del(id);
|
|
deck :: write();
|
|
}
|
|
|
|
void TempQueue :: sort(sort_t field, bool ascending)
|
|
{
|
|
Queue :: sort(field, ascending);
|
|
deck :: write();
|
|
}
|
|
|
|
|
|
static void upgrade_v0()
|
|
{
|
|
int random, ascending;
|
|
unsigned int num, field;
|
|
Queue *library = collection :: get_queue();
|
|
|
|
file_readf(&deck_file, "%d %u", &random, &num);
|
|
if (random)
|
|
library->set_flag(Q_RANDOM);
|
|
|
|
for (unsigned int i = 0; i < num; i++) {
|
|
file_readf(&deck_file, "%u %d", &field, &ascending);
|
|
library->sort((sort_t)field, (i == 0) ? true : false);
|
|
if (!ascending)
|
|
library->sort((sort_t)field, false);
|
|
}
|
|
}
|
|
|
|
void deck :: init()
|
|
{
|
|
unsigned int num;
|
|
bool upgraded = false;
|
|
std::list<TempQueue>::iterator it;
|
|
|
|
file_init(&deck_file, "deck", 1);
|
|
if (!file_open(&deck_file, OPEN_READ))
|
|
return;
|
|
|
|
if (file_version(&deck_file) == 0) {
|
|
upgrade_v0();
|
|
upgraded = true;
|
|
}
|
|
|
|
file_readf(&deck_file, "%u", &num);
|
|
queue_deck.resize(num);
|
|
|
|
for (it = queue_deck.begin(); it != queue_deck.end(); it++)
|
|
it->read(deck_file);
|
|
file_close(&deck_file);
|
|
|
|
if (upgraded)
|
|
deck :: write();
|
|
}
|
|
|
|
void deck :: write()
|
|
{
|
|
std::list<TempQueue>::iterator it;
|
|
|
|
if (!file_open(&deck_file, OPEN_WRITE))
|
|
return;
|
|
|
|
file_writef(&deck_file, "%zu\n", queue_deck.size());
|
|
for (it = queue_deck.begin(); it != queue_deck.end(); it++) {
|
|
it->write(deck_file);
|
|
file_writef(&deck_file, "\n");
|
|
}
|
|
|
|
file_close(&deck_file);
|
|
}
|
|
|
|
Queue *deck :: create(bool random)
|
|
{
|
|
queue_deck.push_back(TempQueue(random));
|
|
return &queue_deck.back();
|
|
}
|
|
|
|
static void _destroy(std::list<TempQueue>::iterator &it)
|
|
{
|
|
queue_deck.erase(it);
|
|
deck :: write();
|
|
}
|
|
|
|
void deck :: destroy(Queue *queue)
|
|
{
|
|
std::list<TempQueue>::iterator it;
|
|
|
|
for (it = queue_deck.begin(); it != queue_deck.end(); it++) {
|
|
if (&(*it) == queue) {
|
|
_destroy(it);
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
void deck :: move(Queue *queue, unsigned int index)
|
|
{
|
|
unsigned int old_pos = deck :: index(queue);
|
|
std::list<TempQueue>::iterator it_old = queue_deck.begin();
|
|
std::list<TempQueue>::iterator it_new = queue_deck.begin();
|
|
|
|
for (unsigned int i = 0; i < queue_deck.size(); i++) {
|
|
if (i < old_pos)
|
|
it_old++;
|
|
|
|
if (i < index)
|
|
it_new++;
|
|
}
|
|
|
|
if (index > old_pos)
|
|
it_new++;
|
|
|
|
queue_deck.splice(it_new, queue_deck, it_old);
|
|
write();
|
|
}
|
|
|
|
unsigned int deck :: index(Queue *queue)
|
|
{
|
|
unsigned int i = 0;
|
|
std::list<TempQueue>::iterator it;
|
|
|
|
for (it = queue_deck.begin(); it != queue_deck.end(); it++) {
|
|
if (&(*it) == queue)
|
|
return i;
|
|
i++;
|
|
}
|
|
|
|
return queue_deck.size();
|
|
}
|
|
|
|
Queue *deck :: get(unsigned int index)
|
|
{
|
|
std::list<TempQueue>::iterator it;
|
|
|
|
for (it = queue_deck.begin(); it != queue_deck.end(); it++) {
|
|
if (index == 0)
|
|
return &(*it);
|
|
index--;
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
struct track *deck :: next()
|
|
{
|
|
struct track *track = NULL;
|
|
std::list<TempQueue>::iterator it;
|
|
|
|
for (it = queue_deck.begin(); it != queue_deck.end(); it++) {
|
|
if (it->has_flag(Q_ENABLED) == false)
|
|
continue;
|
|
|
|
track = it->next();
|
|
if (it->size() == 0)
|
|
_destroy(it);
|
|
break;
|
|
}
|
|
|
|
if (!track)
|
|
track = collection :: get_queue()->next();
|
|
if (track)
|
|
recent_queue.add(track);
|
|
return track;
|
|
}
|
|
|
|
struct track *deck :: prev()
|
|
{
|
|
return recent_queue.next();
|
|
}
|
|
|
|
std::list<TempQueue> &deck :: get_queues()
|
|
{
|
|
return queue_deck;
|
|
}
|
|
|
|
Queue *deck :: get_queue()
|
|
{
|
|
return &recent_queue;
|
|
}
|