init

.gitignore

@@ -0,0 +1,37 @@
+*.swp
+nrj
+
+# C++ objects and libs
+
+*.slo
+*.lo
+*.o
+*.a
+*.la
+*.lai
+*.so
+*.dll
+*.dylib
+
+# Qt-es
+
+/.qmake.cache
+/.qmake.stash
+*.pro.user
+*.pro.user.*
+*.qbs.user
+*.qbs.user.*
+*.moc
+moc_*.cpp
+qrc_*.cpp
+ui_*.h
+Makefile*
+*-build-*
+
+# QtCreator
+
+*.autosave
+
+#QtCtreator Qml
+*.qmlproject.user
+*.qmlproject.user.*

main.cpp

@@ -0,0 +1,11 @@
+#include <QApplication>
+#include "mainwindow.h"
+
+int main(int argc, char *argv[])
+{
+    QApplication a(argc, argv);
+    MainWindow w;
+    w.show();
+    
+    return a.exec();
+}

mainwindow.cpp

@@ -0,0 +1,75 @@
+#include "mainwindow.h"
+#include "ui_mainwindow.h"
+#include <yaml-cpp/yaml.h>
+
+MainWindow::MainWindow(QWidget *parent) : QMainWindow(parent), ui(new Ui::MainWindow)//, buf(&tmp)
+{
+    ui->setupUi(this);
+
+    //avcodec_register_all();
+
+    QAudioFormat format;
+    format.setSampleRate(44100);
+    format.setChannelCount(2);
+    //format.setFrequency(48000);
+    //format.setChannels(2);
+    format.setSampleSize(128000);
+    format.setCodec("audio/pcm");
+    format.setByteOrder(QAudioFormat::LittleEndian);
+    format.setSampleType(QAudioFormat::SignedInt);
+
+    QAudioDeviceInfo info(QAudioDeviceInfo::defaultOutputDevice());
+    if (!info.isFormatSupported(format))
+        format = info.nearestFormat(format);
+
+    qDebug() << format;
+
+    output=new QAudioOutput(format, this);
+    out=output->start();
+
+    currentRadio = 0;
+    nrj = new NRJ(this);
+    connect(nrj, SIGNAL(setupFinished()), this, SLOT(setupFinished()));
+    nrj->setupPlayer();
+
+}
+
+MainWindow::~MainWindow()
+{
+    delete ui;
+}
+
+void MainWindow::setupFinished()
+{
+    int i = 0;
+    foreach(Radio* r, nrj->getRadios())
+    {
+        RadioWidget* w = new RadioWidget();
+        ui->layRadios->addWidget(w, i / 2, i % 2);
+        connect(w, SIGNAL(clicked(Radio*)), this, SLOT(radioChanged(Radio*)));
+        w->setRadio(r);
+        ++i;
+    }
+    nrj->getAllCur();
+}
+
+void MainWindow::radioChanged(Radio *r)
+{
+    if(currentRadio != 0)
+    {
+        currentRadio->stopStream();
+        currentRadio->disconnect(this);
+    }
+    currentRadio = r;
+    if(currentRadio != 0)
+    {
+        connect(currentRadio, SIGNAL(streamData(QByteArray)), this, SLOT(radioData(QByteArray)));
+        currentRadio->startStream();
+    }
+}
+
+void MainWindow::radioData(QByteArray data)
+{
+    out->write(data);
+    //streamData.append(data);
+}

mainwindow.h

@@ -0,0 +1,38 @@
+#ifndef MAINWINDOW_H
+#define MAINWINDOW_H
+
+#include <QMainWindow>
+#include <QBuffer>
+#include "nrj.h"
+#include "radiowidget.h"
+#include "radio.h"
+#include <QDebug>
+#include <QAudioOutput>
+
+namespace Ui {
+class MainWindow;
+}
+
+class MainWindow : public QMainWindow
+{
+    Q_OBJECT
+
+public:
+    explicit MainWindow(QWidget *parent = 0);
+    ~MainWindow();
+
+private slots:
+    void setupFinished();
+    void radioChanged(Radio* r);
+    void radioData(QByteArray data);
+
+private:
+    Ui::MainWindow *ui;
+    NRJ* nrj;
+    Radio* currentRadio;
+    QAudioOutput* output;
+    QIODevice* out;
+
+};
+
+#endif // MAINWINDOW_H

mainwindow.ui

@@ -0,0 +1,77 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ui version="4.0">
+ <class>MainWindow</class>
+ <widget class="QMainWindow" name="MainWindow">
+  <property name="geometry">
+   <rect>
+    <x>0</x>
+    <y>0</y>
+    <width>658</width>
+    <height>339</height>
+   </rect>
+  </property>
+  <property name="windowTitle">
+   <string>NRJ</string>
+  </property>
+  <property name="windowIcon">
+   <iconset resource="rc.qrc">
+    <normaloff>:/favicon.ico</normaloff>:/favicon.ico</iconset>
+  </property>
+  <widget class="QWidget" name="centralWidget">
+   <layout class="QGridLayout" name="gridLayout">
+    <item row="0" column="0">
+     <widget class="VerticalScrollArea" name="radiosArea">
+      <property name="verticalScrollBarPolicy">
+       <enum>Qt::ScrollBarAlwaysOn</enum>
+      </property>
+      <property name="horizontalScrollBarPolicy">
+       <enum>Qt::ScrollBarAlwaysOff</enum>
+      </property>
+      <property name="widgetResizable">
+       <bool>true</bool>
+      </property>
+      <widget class="QWidget" name="widRadios">
+       <property name="geometry">
+        <rect>
+         <x>0</x>
+         <y>0</y>
+         <width>605</width>
+         <height>299</height>
+        </rect>
+       </property>
+       <layout class="QGridLayout" name="layRadios">
+        <property name="spacing">
+         <number>2</number>
+        </property>
+       </layout>
+      </widget>
+     </widget>
+    </item>
+    <item row="0" column="1">
+     <widget class="QFrame" name="radioFrame">
+      <property name="frameShape">
+       <enum>QFrame::StyledPanel</enum>
+      </property>
+      <property name="frameShadow">
+       <enum>QFrame::Raised</enum>
+      </property>
+     </widget>
+    </item>
+   </layout>
+  </widget>
+  <widget class="QStatusBar" name="statusBar"/>
+ </widget>
+ <layoutdefault spacing="6" margin="11"/>
+ <customwidgets>
+  <customwidget>
+   <class>VerticalScrollArea</class>
+   <extends>QScrollArea</extends>
+   <header>verticalscrollarea.h</header>
+   <container>1</container>
+  </customwidget>
+ </customwidgets>
+ <resources>
+  <include location="rc.qrc"/>
+ </resources>
+ <connections/>
+</ui>

nrj.cpp

@@ -0,0 +1,130 @@
+#include "nrj.h"
+#include "yaml-cpp/yaml.h"
+#include <QDebug>
+#include <QColor>
+#include <QUrlQuery>
+
+NRJ::NRJ(QObject *parent) : QObject(parent)
+{
+    mgr = new QNetworkAccessManager(this);
+    tries = 0;
+}
+
+QList<Radio *> NRJ::getRadios()
+{
+    return radios;
+}
+
+void NRJ::setupPlayer()
+{
+    tries = 0;
+    QNetworkReply* reply = mgr->get(QNetworkRequest(QUrl("http://players.nrjaudio.fm/live-metadata/player/nrj/v1.0/player_setup.yml")));
+    connect(reply, SIGNAL(finished()), this, SLOT(onSetupFinished()));
+    connect(reply, SIGNAL(error(QNetworkReply::NetworkError)), this, SLOT(onSetupError(QNetworkReply::NetworkError)));
+}
+
+void NRJ::getAllCur()
+{
+    if(apiBase.isEmpty())
+        return;
+    tries = 0;
+    QUrl url = apiBase;
+    QUrlQuery query;
+    query.addQueryItem("act", "get_allcur");
+    url.setQuery(query);
+
+    QNetworkReply* reply = mgr->get(QNetworkRequest(url));
+    connect(reply, SIGNAL(finished()), this, SLOT(onGetAllCurFinished()));
+    connect(reply, SIGNAL(error(QNetworkReply::NetworkError)), this, SLOT(onGetAllCurError(QNetworkReply::NetworkError)));
+}
+
+void NRJ::onSetupFinished()
+{
+    QNetworkReply* reply = (QNetworkReply*)sender();
+    YAML::Node root = YAML::Load(reply->readAll().constData());
+    apiBase = QUrl(root["player_api"].as<std::string>().c_str());
+    QUrlQuery query;
+    query.addQueryItem("id_radio", root["id_webradio"].as<std::string>().c_str());
+    apiBase.setQuery(query);
+    coverBase = QUrl(root["radio_pics"].as<std::string>().c_str());
+    YAML::Node webradios = root["webradios"];
+
+    QString logosRootUrl = root["radio_pics"].as<std::string>().c_str();
+    logosRootUrl += "80x80/";
+
+    for(unsigned i = 0;i < webradios.size(); ++i)
+    {
+        YAML::Node node = webradios[i];
+        Radio* radio = new Radio(this);
+        radios.append(radio);
+        radio->setApiBase(apiBase);
+        radio->setCoverBase(coverBase);
+        radio->setNetworkManager(mgr);
+
+        radio->setId(node["id"].as<int>());
+        radio->setName(QString::fromUtf8(node["name"].as<std::string>().c_str()));
+        radio->setClaim(QString::fromUtf8(node["claim"].as<std::string>().c_str()));
+        radio->setTextColor(QColor("#" + QString(node["color"].as<std::string>().c_str())));
+        radio->setLogoUrl(QUrl(logosRootUrl + node["logo"].as<std::string>().c_str()));
+        radio->setStreamUrl(QUrl(node["url_128k_mp3"].as<std::string>().c_str()));
+    }
+    emit setupFinished();
+}
+
+void NRJ::onSetupError(QNetworkReply::NetworkError)
+{
+    if(tries < 3)
+    {
+        ++tries;
+        setupPlayer();
+    }
+    else
+    {
+        tries = 0;
+        emit setupError();
+    }
+}
+
+void NRJ::onGetAllCurFinished()
+{
+    QNetworkReply* reply = (QNetworkReply*)sender();
+    YAML::Node itms = YAML::Load(reply->readAll().constData())["itms"];
+
+    for(unsigned i = 0;i < itms.size(); ++i)
+    {
+        YAML::Node itm = itms[i];
+        int id = itm["id_plst"].as<int>();
+        for(int it = 0;it < radios.size(); ++it)
+        {
+            Radio* r = radios.at(it);
+            if(r->getId() == id)
+            {
+                it = radios.size();
+                Song* song = new Song(r);
+                song->setDuration(qMax((int)(itm["t_dur"].as<int>() - (1000 * (QDateTime::currentDateTime().toTime_t() - itm["ts"].as<int>()))), 0));
+                song->setArtist(itm["art"].as<std::string>().c_str());
+                song->setTitle(itm["tit"].as<std::string>().c_str());
+                //qDebug()<<(QDateTime::currentDateTime().toTime_t() - itm["ts"].as<int>());
+                //song->setStartTime(itm["ts"].as<int>() * 1000);
+                QUrl url = coverBase;
+                url.setPath(url.path() + itm["cov"].as<std::string>().c_str());
+                song->setCoverUrl(url);
+                r->setCurrentSong(song);
+            }
+        }
+    }
+}
+
+void NRJ::onGetAllCurError(QNetworkReply::NetworkError)
+{
+    if(tries < 3)
+    {
+        ++tries;
+        getAllCur();
+    }
+    else
+    {
+        tries = 0;
+        emit getAllCurError();
+    }
+}

nrj.h

@@ -0,0 +1,44 @@
+#ifndef NRJ_H
+#define NRJ_H
+
+#include <QObject>
+#include <QNetworkAccessManager>
+#include <QNetworkRequest>
+#include <QNetworkReply>
+#include "radio.h"
+
+class NRJ : public QObject
+{
+    Q_OBJECT
+public:
+    explicit NRJ(QObject *parent = 0);
+
+    QList<Radio*> getRadios();
+    
+signals:
+    void setupFinished();
+    void setupError();
+
+    void getAllCurError();
+    
+public slots:
+    void setupPlayer();
+    void getAllCur();
+
+private slots:
+    void onSetupFinished();
+    void onSetupError(QNetworkReply::NetworkError);
+
+    void onGetAllCurFinished();
+    void onGetAllCurError(QNetworkReply::NetworkError);
+
+private:
+    QNetworkAccessManager* mgr;
+    QList<Radio*> radios;
+    QUrl apiBase;
+    QUrl coverBase;
+    int tries;
+    
+};
+
+#endif // NRJ_H

nrj.pro

@@ -0,0 +1,37 @@
+#-------------------------------------------------
+#
+# Project created by QtCreator 2013-06-05T22:35:34
+#
+#-------------------------------------------------
+
+QT       += core gui network multimedia widgets
+
+TARGET = nrj
+TEMPLATE = app
+
+INCLUDEPATH += C:/boost_1_53_0/
+
+SOURCES += main.cpp\
+        mainwindow.cpp \
+    nrj.cpp \
+    radio.cpp \
+    radiowidget.cpp \
+    verticalscrollarea.cpp \
+    song.cpp
+
+HEADERS  += mainwindow.h \
+    nrj.h \
+    radio.h \
+    radiowidget.h \
+    verticalscrollarea.h \
+    song.h
+
+FORMS    += mainwindow.ui \
+    radiowidget.ui
+
+
+LIBS += -lyaml-cpp
+#-lavcodec
+
+RESOURCES += \
+    rc.qrc

radio.cpp

@@ -0,0 +1,248 @@
+#include "radio.h"
+#include "yaml-cpp/yaml.h"
+#include <QDebug>
+#include <QUrlQuery>
+
+Radio::Radio(QObject *parent) : QObject(parent), logo(0, 0)
+{
+    mgr = 0;
+    logoTries = 0;
+    currentSong = 0;
+    songsTries = 0;
+    streamTries = 0;
+    stream = 0;
+    songTimer = new QTimer(this);
+    songTimer->setSingleShot(true);
+    connect(songTimer, SIGNAL(timeout()), this, SLOT(songEnded()));
+}
+
+QString Radio::getName()
+{
+    return name;
+}
+
+QString Radio::getClaim()
+{
+    return claim;
+}
+
+QColor Radio::getTextColor()
+{
+    return textColor;
+}
+
+QUrl Radio::getLogoUrl()
+{
+    return logoUrl;
+}
+
+QUrl Radio::getStreamUrl()
+{
+    return streamUrl;
+}
+
+int Radio::getId()
+{
+    return id;
+}
+
+QUrl Radio::getApiBase()
+{
+    return apiBase;
+}
+
+QUrl Radio::getCoverBase()
+{
+    return coverBase;
+}
+
+Song *Radio::getCurrentSong()
+{
+    return currentSong;
+}
+
+QNetworkReply *Radio::getStream()
+{
+    return stream;
+}
+
+void Radio::setName(QString n)
+{
+    name = n;
+}
+
+void Radio::setClaim(QString c)
+{
+    claim = c;
+}
+
+void Radio::setTextColor(QColor c)
+{
+    textColor = c;
+}
+
+void Radio::setLogoUrl(QUrl u)
+{
+    logoUrl = u;
+}
+
+void Radio::setStreamUrl(QUrl u)
+{
+    streamUrl = u;
+}
+
+void Radio::setId(int i)
+{
+    id = i;
+}
+
+void Radio::setApiBase(QUrl u)
+{
+    apiBase = u;
+}
+
+void Radio::setCoverBase(QUrl u)
+{
+    coverBase = u;
+}
+
+void Radio::setCurrentSong(Song *s)
+{
+    if(currentSong != 0)
+        currentSong->deleteLater();
+    currentSong = s;
+    songTimer->stop();
+    if(s->getDuration() < 0)
+        qDebug()<<s->getDuration()<<name;
+    songTimer->setInterval(s->getDuration());
+    songTimer->start();
+    nextSongs.removeOne(currentSong);
+    updateNextSongs();
+    emit songChanged(currentSong);
+}
+
+void Radio::updateNextSongs()
+{
+    songsTries = 0;
+    QUrl url = apiBase;
+    QUrlQuery query;
+    query.addQueryItem("act", "get_plist");
+    query.addQueryItem("id_wr", QString::number(id));
+    url.setQuery(query);
+    QNetworkReply* reply = mgr->get(QNetworkRequest(url));
+    connect(reply, SIGNAL(finished()), this, SLOT(songsFinished()));
+    connect(reply, SIGNAL(error(QNetworkReply::NetworkError)), this, SLOT(songsError(QNetworkReply::NetworkError)));
+}
+
+void Radio::downloadLogo()
+{
+    if(logo.isNull())
+    {
+        logoTries = 0;
+        QNetworkReply* reply = mgr->get(QNetworkRequest(logoUrl));
+        connect(reply, SIGNAL(finished()), this, SLOT(logoFinished()));
+        connect(reply, SIGNAL(error(QNetworkReply::NetworkError)), this, SLOT(logoError(QNetworkReply::NetworkError)));
+    }
+    else
+        emit logoDownloaded(logo);
+}
+
+void Radio::startStream()
+{
+    stopStream();
+    streamTries = 0;
+    stream = mgr->get(QNetworkRequest(streamUrl));
+    stream->setReadBufferSize(128);
+    connect(stream, SIGNAL(readyRead()), this, SLOT(streamRead()));
+    emit streamChanged(stream);
+}
+
+void Radio::stopStream()
+{
+    if(stream != 0)
+    {
+        stream->abort();
+        stream->deleteLater();
+        stream = 0;
+    }
+}
+
+void Radio::logoFinished()
+{
+    QNetworkReply* reply = (QNetworkReply*)sender();
+
+    if(logo.loadFromData(reply->readAll()) && !logo.isNull())
+        emit logoDownloaded(logo);
+}
+
+void Radio::logoError(QNetworkReply::NetworkError)
+{
+    if(logoTries < 3)
+    {
+        ++logoTries;
+        downloadLogo();
+    }
+}
+
+void Radio::songsFinished()
+{
+    QNetworkReply* reply = (QNetworkReply*)sender();
+    YAML::Node itms = YAML::Load(reply->readAll().constData())["itms"];
+    qDeleteAll(nextSongs);
+    for(unsigned i = 1;i < itms.size(); ++i)
+    {
+        YAML::Node itm = itms[i];
+        if(itm["id"].as<int>() == -1)
+            continue;
+        Song* song = new Song(this);
+        song->setDuration(itm["t_dur"].as<int>());
+        song->setArtist(itm["art"].as<std::string>().c_str());
+        song->setTitle(itm["tit"].as<std::string>().c_str());
+        QUrl url = coverBase;
+        url.setPath(url.path() + itm["cov"].as<std::string>().c_str());
+        song->setCoverUrl(url);
+        nextSongs.append(song);
+    }
+}
+
+void Radio::songsError(QNetworkReply::NetworkError)
+{
+    if(songsTries < 3)
+    {
+        ++songsTries;
+        updateNextSongs();
+    }
+}
+
+void Radio::streamRead()
+{
+    if(stream->header(QNetworkRequest::LocationHeader).toUrl().isEmpty())
+        emit streamData(stream->readAll());
+    else
+    {
+        streamUrl = stream->header(QNetworkRequest::LocationHeader).toUrl();
+        stopStream();
+        startStream();
+    }
+}
+
+void Radio::streamError()
+{
+    if(streamTries < 3)
+    {
+        ++streamTries;
+        stopStream();
+        startStream();
+    }
+}
+
+void Radio::songEnded()
+{
+    if(!nextSongs.isEmpty())
+        setCurrentSong(nextSongs.at(0));
+}
+
+void Radio::setNetworkManager(QNetworkAccessManager *m)
+{
+    mgr = m;
+}

radio.h

@@ -0,0 +1,92 @@
+#ifndef RADIO_H
+#define RADIO_H
+
+#include <QObject>
+#include <QColor>
+#include <QUrl>
+#include <QPixmap>
+#include <QNetworkAccessManager>
+#include <QNetworkReply>
+#include <QList>
+#include <QTimer>
+#include "song.h"
+
+class Radio : public QObject
+{
+    Q_OBJECT
+public:
+    explicit Radio(QObject *parent = 0);
+
+    QString getName();
+    QString getClaim();
+    QColor getTextColor();
+    QUrl getLogoUrl();
+    QUrl getStreamUrl();
+    int getId();
+    QUrl getApiBase();
+    QUrl getCoverBase();
+
+    Song* getCurrentSong();
+    QNetworkReply* getStream();
+    
+signals:
+    void logoDownloaded(QPixmap);
+    void songChanged(Song*);
+    void nextSongsUpdated();
+    void streamData(QByteArray);
+    void streamChanged(QNetworkReply*);
+    
+public slots:
+    void setNetworkManager(QNetworkAccessManager* m);
+
+    void setName(QString n);
+    void setClaim(QString c);
+    void setTextColor(QColor c);
+    void setLogoUrl(QUrl u);
+    void setStreamUrl(QUrl u);
+    void setId(int i);
+    void setApiBase(QUrl u);
+    void setCoverBase(QUrl u);
+
+    void setCurrentSong(Song* s);
+    void updateNextSongs();
+    void downloadLogo();
+    void startStream();
+    void stopStream();
+
+private slots:
+    void logoFinished();
+    void logoError(QNetworkReply::NetworkError);
+
+    void songsFinished();
+    void songsError(QNetworkReply::NetworkError);
+
+    void streamRead();
+    void streamError();
+
+    void songEnded();
+
+private:
+    QString name;
+    QString claim;
+    QColor textColor;
+    QUrl logoUrl;
+    QUrl streamUrl;
+    int id;
+    QPixmap logo;
+    QUrl apiBase;
+    QUrl coverBase;
+
+    QList<Song*> nextSongs;
+    Song* currentSong;
+    QTimer* songTimer;
+
+    QNetworkAccessManager* mgr;
+    int logoTries;
+    int songsTries;
+    int streamTries;
+    QNetworkReply* stream;
+    
+};
+
+#endif // RADIO_H

radiowidget.cpp

@@ -0,0 +1,81 @@
+#include "radiowidget.h"
+#include "ui_radiowidget.h"
+#include <QDebug>
+
+RadioWidget::RadioWidget(QWidget *parent) : QFrame(parent), ui(new Ui::RadioWidget)
+{
+    ui->setupUi(this);
+    remaining = 0;
+    timer = new QTimer(this);
+    connect(timer, SIGNAL(timeout()), this, SLOT(countdown()));
+    timer->setInterval(1000);
+}
+
+RadioWidget::~RadioWidget()
+{
+    delete ui;
+}
+
+Radio *RadioWidget::getRadio()
+{
+    return radio;
+}
+
+void RadioWidget::setRadio(Radio *r)
+{
+    radio = r;
+    ui->lblClaim->setText(radio->getClaim());
+    QPalette p = ui->lblClaim->palette();
+    p.setColor(QPalette::Foreground, radio->getTextColor());
+    ui->lblClaim->setPalette(p);
+    songChanged(0);
+    ui->lblLogo->setText(radio->getName());
+    connect(radio, SIGNAL(logoDownloaded(QPixmap)), this, SLOT(logoDownloaded(QPixmap)));
+    connect(radio, SIGNAL(songChanged(Song*)), this, SLOT(songChanged(Song*)));
+    radio->downloadLogo();
+}
+
+void RadioWidget::logoDownloaded(QPixmap l)
+{
+    ui->lblLogo->setText("");
+    ui->lblLogo->setPixmap(l);
+}
+
+void RadioWidget::songChanged(Song *s)
+{
+    if(s == 0)
+    {
+        ui->lblSong->setText("--");
+        ui->lblTime->setText("");
+    }
+    else
+    {
+        ui->lblSong->setText(s->getArtist() + "\n" + s->getTitle());
+        remaining = s->getDuration()/1000;
+
+        ui->lblTime->setText(QString::number(remaining));
+        timer->start();
+    }
+}
+
+void RadioWidget::countdown()
+{
+    --remaining;
+    ui->lblTime->setText(QString::number(remaining));
+}
+
+void RadioWidget::enterEvent(QEvent *)
+{
+    setStyleSheet("background-color: rgb(225, 225, 225);");
+}
+
+void RadioWidget::leaveEvent(QEvent *)
+{
+    setStyleSheet("background-color: none;");
+}
+
+void RadioWidget::mouseReleaseEvent(QMouseEvent *e)
+{
+    if(e->button() == Qt::LeftButton)
+        emit clicked(radio);
+}

radiowidget.h

@@ -0,0 +1,45 @@
+#ifndef RADIOWIDGET_H
+#define RADIOWIDGET_H
+
+#include <QMouseEvent>
+#include <QFrame>
+#include "radio.h"
+
+namespace Ui {
+class RadioWidget;
+}
+
+class RadioWidget : public QFrame
+{
+    Q_OBJECT
+    
+public:
+    explicit RadioWidget(QWidget *parent = 0);
+    ~RadioWidget();
+    
+    Radio* getRadio();
+
+signals:
+    void clicked(Radio*);
+
+public slots:
+    void setRadio(Radio* r);
+
+private slots:
+    void logoDownloaded(QPixmap l);
+    void songChanged(Song* s);
+    void countdown();
+
+protected:
+    void enterEvent(QEvent *);
+    void leaveEvent(QEvent *);
+    void mouseReleaseEvent(QMouseEvent* e);
+
+private:
+    Ui::RadioWidget *ui;
+    Radio* radio;
+    int remaining;
+    QTimer* timer;
+};
+
+#endif // RADIOWIDGET_H

radiowidget.ui

@@ -0,0 +1,126 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ui version="4.0">
+ <class>RadioWidget</class>
+ <widget class="QFrame" name="RadioWidget">
+  <property name="geometry">
+   <rect>
+    <x>0</x>
+    <y>0</y>
+    <width>194</width>
+    <height>104</height>
+   </rect>
+  </property>
+  <property name="sizePolicy">
+   <sizepolicy hsizetype="Preferred" vsizetype="Fixed">
+    <horstretch>0</horstretch>
+    <verstretch>0</verstretch>
+   </sizepolicy>
+  </property>
+  <property name="cursor">
+   <cursorShape>PointingHandCursor</cursorShape>
+  </property>
+  <property name="windowTitle">
+   <string>Form</string>
+  </property>
+  <property name="styleSheet">
+   <string notr="true"/>
+  </property>
+  <layout class="QGridLayout" name="gridLayout">
+   <property name="margin">
+    <number>0</number>
+   </property>
+   <property name="spacing">
+    <number>0</number>
+   </property>
+   <item row="1" column="1">
+    <widget class="QLabel" name="lblSong">
+     <property name="sizePolicy">
+      <sizepolicy hsizetype="Maximum" vsizetype="Preferred">
+       <horstretch>0</horstretch>
+       <verstretch>0</verstretch>
+      </sizepolicy>
+     </property>
+     <property name="maximumSize">
+      <size>
+       <width>200</width>
+       <height>16777215</height>
+      </size>
+     </property>
+     <property name="text">
+      <string>Artist name
+Song name</string>
+     </property>
+     <property name="alignment">
+      <set>Qt::AlignCenter</set>
+     </property>
+     <property name="wordWrap">
+      <bool>true</bool>
+     </property>
+    </widget>
+   </item>
+   <item row="0" column="1">
+    <widget class="QLabel" name="lblClaim">
+     <property name="sizePolicy">
+      <sizepolicy hsizetype="Maximum" vsizetype="Preferred">
+       <horstretch>0</horstretch>
+       <verstretch>0</verstretch>
+      </sizepolicy>
+     </property>
+     <property name="maximumSize">
+      <size>
+       <width>200</width>
+       <height>16777215</height>
+      </size>
+     </property>
+     <property name="font">
+      <font>
+       <pointsize>8</pointsize>
+       <weight>75</weight>
+       <bold>true</bold>
+      </font>
+     </property>
+     <property name="text">
+      <string>Radio claim</string>
+     </property>
+     <property name="wordWrap">
+      <bool>true</bool>
+     </property>
+    </widget>
+   </item>
+   <item row="2" column="1">
+    <widget class="QLabel" name="lblTime">
+     <property name="text">
+      <string>2:00</string>
+     </property>
+     <property name="alignment">
+      <set>Qt::AlignCenter</set>
+     </property>
+    </widget>
+   </item>
+   <item row="0" column="0" rowspan="3">
+    <widget class="QLabel" name="lblLogo">
+     <property name="sizePolicy">
+      <sizepolicy hsizetype="Maximum" vsizetype="Preferred">
+       <horstretch>0</horstretch>
+       <verstretch>0</verstretch>
+      </sizepolicy>
+     </property>
+     <property name="maximumSize">
+      <size>
+       <width>100</width>
+       <height>150</height>
+      </size>
+     </property>
+     <property name="text">
+      <string>Radio name</string>
+     </property>
+     <property name="wordWrap">
+      <bool>true</bool>
+     </property>
+    </widget>
+   </item>
+  </layout>
+ </widget>
+ <resources/>
+ <connections/>
+</ui>

rc.qrc

@@ -0,0 +1,5 @@
+<RCC>
+    <qresource prefix="/" lang="fr">
+        <file>favicon.ico</file>
+    </qresource>
+</RCC>

song.cpp

@@ -0,0 +1,83 @@
+#include "song.h"
+
+Song::Song(QObject *parent) : QObject(parent), cover(0, 0)
+{
+    tries = 0;
+}
+
+QString Song::getArtist() const
+{
+    return artist;
+}
+
+QString Song::getTitle() const
+{
+    return title;
+}
+
+QUrl Song::getCoverUrl() const
+{
+    return coverUrl;
+}
+
+int Song::getDuration() const
+{
+    return duration;
+}
+
+void Song::setArtist(QString a)
+{
+    artist = a;
+}
+
+void Song::setTitle(QString t)
+{
+    title = t;
+}
+
+void Song::setCoverUrl(QUrl u)
+{
+    coverUrl = u;
+}
+
+void Song::setDuration(int d)
+{
+    duration = d;
+}
+
+void Song::downloadCover()
+{
+    if(cover.isNull())
+    {
+        if(mgr != 0)
+        {
+            tries = 0;
+            QNetworkReply* reply = mgr->get(QNetworkRequest(coverUrl));
+            connect(reply, SIGNAL(finished()), this, SLOT(onCoverFinished()));
+            connect(reply, SIGNAL(error(QNetworkReply::NetworkError)), this, SLOT(onCoverError(QNetworkReply::NetworkError)));
+        }
+    }
+    else
+        emit coverDownloaded(cover);
+}
+
+void Song::setNetworkManager(QNetworkAccessManager *m)
+{
+    mgr = m;
+}
+
+void Song::onCoverFinished()
+{
+    QNetworkReply* reply = (QNetworkReply*)sender();
+    if(cover.loadFromData(reply->readAll()) && !cover.isNull())
+        emit coverDownloaded(cover);
+}
+
+void Song::onCoverError(QNetworkReply::NetworkError)
+{
+    if(tries < 3)
+    {
+        ++tries;
+        downloadCover();
+    }
+}

song.h

@@ -0,0 +1,52 @@
+#ifndef SONG_H
+#define SONG_H
+
+#include <QObject>
+#include <QString>
+#include <QTime>
+#include <QUrl>
+#include <QNetworkAccessManager>
+#include <QNetworkReply>
+#include <QNetworkRequest>
+#include <QPixmap>
+
+class Song : public QObject
+{
+    Q_OBJECT
+public:
+    explicit Song(QObject *parent = 0);
+
+    QString getArtist() const;
+    QString getTitle() const;
+    QUrl getCoverUrl() const;
+    int getDuration() const;
+    
+signals:
+    void coverDownloaded(QPixmap);
+    
+public slots:
+    void setArtist(QString a);
+    void setTitle(QString t);
+    void setCoverUrl(QUrl u);
+    void setDuration(int d);
+
+    void downloadCover();
+
+    void setNetworkManager(QNetworkAccessManager* m);
+
+private slots:
+    void onCoverFinished();
+    void onCoverError(QNetworkReply::NetworkError);
+    
+private:
+    QString artist;
+    QString title;
+    QUrl coverUrl;
+    int duration;
+    QPixmap cover;
+
+    QNetworkAccessManager* mgr;
+    int tries;
+};
+
+#endif // SONG_H

verticalscrollarea.cpp

@@ -0,0 +1,22 @@
+#include "verticalscrollarea.h"
+#include <QVBoxLayout>
+
+VerticalScrollArea::VerticalScrollArea(QWidget *parent) : QScrollArea(parent)
+{
+    setWidgetResizable(true);
+}
+
+void VerticalScrollArea::setWidget(QWidget *widget)
+{
+    if(widget != 0)
+        widget->installEventFilter(this);
+    QScrollArea::setWidget(widget);
+}
+
+bool VerticalScrollArea::eventFilter(QObject *o, QEvent *e)
+{
+    if(o == widget() && e->type() == QEvent::Resize)
+        setMinimumWidth(widget()->minimumSizeHint().width() + verticalScrollBar()->width());
+
+    return false;
+}

verticalscrollarea.h

@@ -0,0 +1,21 @@
+#ifndef VERTICALSCROLLAREA_H
+#define VERTICALSCROLLAREA_H
+
+#include <QScrollArea>
+#include <QEvent>
+#include <QScrollBar>
+
+class VerticalScrollArea : public QScrollArea
+{
+    Q_OBJECT
+public:
+    explicit VerticalScrollArea(QWidget *parent = 0);
+    
+    void setWidget(QWidget *widget);
+
+protected:
+    bool eventFilter(QObject *o, QEvent *e);
+    
+};
+
+#endif // VERTICALSCROLLAREA_H