Change playlist to use Esperanza's playlistmodel

src/BrowseDialog.cpp

@@ -0,0 +1,171 @@
+#include "XMMSHandler.h"
+#include "BrowseModel.h"
+#include "BrowseDialog.h"
+
+#include <QDialog>
+#include <QSettings>
+#include <QSize>
+#include <QGridLayout>
+#include <QLabel>
+#include <QComboBox>
+#include <QLineEdit>
+#include <QPushButton>
+#include <QToolButton>
+#include <QTreeView>
+
+BrowseDialog::BrowseDialog (QWidget *parent) : QDialog (parent)
+{
+    setSizeGripEnabled(true);
+    QGridLayout *grid = new QGridLayout (this);
+
+	m_list = new QTreeView (this);
+
+	m_model = new BrowseModel (this);
+	m_list->setModel (m_model);
+    m_list->setSelectionMode (QAbstractItemView::ExtendedSelection);
+    m_list->setSelectionBehavior (QAbstractItemView::SelectRows);
+//	m_list->setWrapping (true);
+	m_list->setIndentation (0);
+    //m_list->setResizeMode (QListView::Adjust);
+    m_list->setEditTriggers (QAbstractItemView::EditKeyPressed);
+    m_list->setContextMenuPolicy (Qt::CustomContextMenu);
+
+    m_selections = new QItemSelectionModel (m_model);
+	m_list->setSelectionModel (m_selections);
+
+	connect (m_model, SIGNAL (dirChanged (QString)),
+			 this, SLOT (dirChanged(const QString &)));
+
+    grid->addWidget(m_list, 1, 0, 1, 6);
+    connect (m_list, SIGNAL (activated (QModelIndex)), 
+	         this, SLOT (setPath(const QModelIndex &)));
+	/*
+    QObject::connect(m_list, SIGNAL(customContextMenuRequested(QPoint)),
+                     q, SLOT(_q_showContextMenu(QPoint)));
+ */
+
+    QHBoxLayout *box = new QHBoxLayout;
+    box->setMargin(3);
+    box->setSpacing(3);
+    QSize tools(22, 22);
+
+    QToolButton *toParentButton = new QToolButton (this);
+    toParentButton->setIcon (style ()->standardPixmap (QStyle::SP_FileDialogToParent));
+    toParentButton->setToolTip (tr("Parent Directory"));
+    toParentButton->setAutoRaise (true);
+    toParentButton->setFixedSize (tools);
+    QObject::connect (toParentButton, SIGNAL(clicked ()), this, SLOT (navigateToPrevious ()));
+    box->addWidget(toParentButton);
+
+    QToolButton *listModeButton = new QToolButton (this);
+    listModeButton->setIcon (style ()->standardPixmap (QStyle::SP_FileDialogListView));
+    listModeButton->setToolTip (tr("List View"));
+    listModeButton->setAutoRaise (true);
+    listModeButton->setDown (true);
+    listModeButton->setFixedSize (tools);
+    box->addWidget(listModeButton);
+
+    QToolButton *detailModeButton = new QToolButton (this);
+    detailModeButton->setIcon(style ()->standardPixmap (QStyle::SP_FileDialogDetailedView));
+    detailModeButton->setToolTip (tr("Detail View"));
+    detailModeButton->setAutoRaise (true);
+    detailModeButton->setFixedSize (tools);
+    box->addWidget (detailModeButton);
+    box->setSizeConstraint (QLayout::SetFixedSize);
+
+    grid->addLayout(box, 0, 4, 1, 2);
+
+    QLabel *lookInLabel = new QLabel (tr ("Look in:"), this);
+    grid->addWidget (lookInLabel, 0, 0);
+
+    // push buttons
+    QPushButton *acceptButton = new QPushButton (tr ("Open"), this);
+    QObject::connect(acceptButton, SIGNAL(clicked()), this, SLOT(accept()));
+    grid->addWidget(acceptButton, 2, 5);
+
+    QPushButton *rejectButton = new QPushButton (tr ("Cancel"), this);
+    QObject::connect(rejectButton, SIGNAL(clicked()), this, SLOT(reject()));
+    grid->addWidget(rejectButton, 2, 4);
+
+    m_lookInCombo = new QComboBox (this);
+    m_lookInCombo->setInsertPolicy (QComboBox::NoInsert);
+    m_lookInCombo->setDuplicatesEnabled (false);
+    m_lookInCombo->setEditable (true);
+    m_lookInCombo->setAutoCompletion (false);
+    QObject::connect(m_lookInCombo, SIGNAL(activated(QString)),
+					 this, SLOT(setPath(QString)));
+
+    m_lookInEdit = new QLineEdit (m_lookInCombo);
+    m_lookInCombo->setLineEdit (m_lookInEdit);
+    m_lookInCombo->setSizePolicy (QSizePolicy::Expanding, QSizePolicy::Fixed);
+    grid->addWidget (m_lookInCombo, 0, 1, 1, 3);
+
+	QSettings s;
+	if (!s.contains ("browsedialog/path"))
+		s.setValue ("browsedialog/path", "");
+	m_model->setPath (s.value("browsedialog/path").toString ());
+
+    resize(530, 340);
+}
+
+QStringList
+BrowseDialog::getFiles ()
+{
+	QStringList ret;
+	if (exec () == QDialog::Accepted) {
+		QModelIndexList list = m_selections->selectedIndexes ();
+		for (int i = 0; i < list.size (); i++) {
+			BrowseModelItem *item = m_model->itemByIndex (list.at (i));
+			if (!item)
+				continue;
+
+			if (!item->isDir ())
+				ret.append (item->data("path"));
+		}
+	}
+	return ret;
+}
+
+void
+BrowseDialog::accept ()
+{
+	QSettings s;
+	s.setValue ("browsedialog/path", m_model->currentPath ());
+	QDialog::accept ();
+}
+
+void
+BrowseDialog::dirChanged (const QString &path)
+{
+	m_lookInCombo->insertItem (0, path);
+	m_lookInCombo->setCurrentIndex (0);
+}
+
+void
+BrowseDialog::navigateToPrevious ()
+{
+	QString dir = m_model->currentPath ();
+	if (dir.endsWith ("/"))
+		m_model->setPath (dir.left (dir.lastIndexOf ("/", -2) + 1));
+	else
+		m_model->setPath (dir.left (dir.lastIndexOf ("/") + 1));
+}
+
+void
+BrowseDialog::setPath (const QModelIndex &index)
+{
+	XMMSHandler &handler = XMMSHandler::getInstance ();
+	BrowseModelItem *item = m_model->itemByIndex (index);
+	if (item->isDir ()) {
+		m_model->setPath (index);
+	} else {
+		handler.playlistAddURL (item->data("path"));
+	}
+}
+
+void
+BrowseDialog::setPath (const QString &path)
+{
+	m_model->setPath (path);
+}
+

src/BrowseDialog.h

@@ -0,0 +1,39 @@
+#ifndef __BROWSEDIALOG_H__
+#define __BROWSEDIALOG_H__
+
+#include "BrowseModel.h"
+
+#include <QDialog>
+#include <QTreeView>
+#include <QListView>
+#include <QGridLayout>
+#include <QPushButton>
+#include <QLabel>
+#include <QComboBox>
+#include <QLineEdit>
+#include <QItemSelectionModel>
+
+class BrowseDialog : public QDialog
+{
+	Q_OBJECT
+	public:
+		BrowseDialog (QWidget *parent);
+
+	public slots:
+		void setPath (const QModelIndex &index);
+		void setPath (const QString &path);
+		void navigateToPrevious ();
+		void dirChanged (const QString &path);
+		void accept ();
+		QStringList getFiles ();
+
+	private:
+		QTreeView *m_list;
+		QComboBox *m_lookInCombo;
+		QLineEdit *m_lookInEdit;
+		QLineEdit *m_fileNameEdit;
+		QComboBox *m_fileTypeCombo;
+		BrowseModel *m_model;
+		QItemSelectionModel *m_selections;
+};
+#endif 

src/BrowseModel.cpp

@@ -0,0 +1,193 @@
+#include "XMMSHandler.h"
+#include "BrowseModel.h"
+
+#include <QAbstractTableModel>
+#include <QString>
+#include <QIcon>
+#include <QWidget>
+
+
+bool
+BrowseModelItem::itemCompare (BrowseModelItem *s1, BrowseModelItem *s2)
+{
+	if (QString::localeAwareCompare (s1->m_vals["name"].toLower (),
+									 s2->m_vals["name"].toLower ()) < 0) {
+		return true;
+	}
+	return false;
+}
+
+BrowseModel::BrowseModel (QWidget *parent) : QAbstractTableModel ()
+{
+	m_columns.append ("Name");
+	m_style = parent->style ();
+	m_client = XMMSHandler::getInstance ().getClient ();
+	m_filter_dot = true;
+	//list_root ();
+}
+
+BrowseModelItem *
+BrowseModel::itemByIndex (const QModelIndex &index)
+{
+	return m_list.at (index.row ());
+}
+
+void
+BrowseModel::setPath (const QModelIndex &index)
+{
+	BrowseModelItem *item = m_list.at (index.row ());
+	m_client->xform.browse (item->data("path").toStdString ()) (Xmms::bind (&BrowseModel::list_cb, this));
+	m_current_dir = item->data ("path");
+}
+
+void
+BrowseModel::setPath (const QString &path)
+{
+	if (path.isEmpty())
+		list_root ();
+
+	m_client->xform.browse (path.toStdString ())(
+							Xmms::bind (&BrowseModel::list_cb, this),
+							Xmms::bind (&BrowseModel::list_err, this));
+	m_current_dir = path;
+}
+
+void
+BrowseModel::list_root ()
+{
+	while (!m_list.isEmpty ()) {
+		delete m_list.takeFirst ();
+	}
+
+	m_list.append (new BrowseModelItem ("file:///", "Files", true));
+	m_list.append (new BrowseModelItem ("daap://", "DAAP", true));
+	emit dirChanged ("");
+
+	reset ();
+
+	m_current_dir = "";
+}
+
+bool
+BrowseModel::list_err (const std::string err)
+{
+	list_root ();
+	return true;
+}
+
+bool
+BrowseModel::list_cb (const Xmms::List< Xmms::Dict > &res)
+{
+	while (!m_list.isEmpty ()) {
+		delete m_list.takeFirst ();
+	}
+
+	for (res.first (); res.isValid (); ++res) {
+		Xmms::Dict d = *res;
+
+		if (!d.contains ("path"))
+			continue;
+
+		QString path = QString::fromStdString (d.get<std::string> ("path"));
+
+		QString name;
+		if (d.contains ("name")) {
+			name = QString::fromStdString (d.get<std::string> ("name"));
+		} else {
+			if (d.contains ("title")) {
+				if (d.contains ("artist")) {
+					name += QString::fromStdString (d.get<std::string> ("artist"));
+					name += " - ";
+				}
+				if (d.contains ("album")) {
+					name += QString::fromStdString (d.get<std::string> ("album"));
+					name += " - ";
+				}
+				if (d.contains ("tracknr")) {
+					name += QString::number (d.get<uint32_t>
+											 ("tracknr")).rightJustified(2, '0');
+					name += " - ";
+				}
+				name += QString::fromStdString (d.get<std::string> ("title"));
+			} else {
+				const char *tmp;
+				QString tmp2 = path.mid (path.lastIndexOf ("/")+1);
+				tmp = xmmsc_result_decode_url (NULL, tmp2.toAscii ());
+				name = QString::fromUtf8 (tmp);
+				free ((char *)tmp);
+			}
+		}
+
+		bool isdir = d.get<int32_t> ("isdir");
+
+		if (m_filter_dot && name.startsWith ("."))
+			// skip these files 
+			continue;
+
+		m_list.append (new BrowseModelItem (path, name, isdir));
+	}
+
+	qSort (m_list.begin (), m_list.end (), BrowseModelItem::itemCompare);
+
+	qDebug ("%s", qPrintable(m_list.at(0)->data("name")));
+
+	reset ();
+
+	emit dirChanged (m_current_dir);
+
+	return true;
+}
+
+/* QModel overrides */
+int
+BrowseModel::rowCount (const QModelIndex &parent) const
+{
+	return m_list.size ();
+}
+
+int
+BrowseModel::columnCount (const QModelIndex &parent) const
+{
+	return m_columns.size ();
+}
+
+QVariant
+BrowseModel::data (const QModelIndex &index,
+						 int role) const
+{
+	if (!index.isValid ())
+		return QVariant ();
+
+	if (index.column () == 0 && role == Qt::DecorationRole)
+		return fileIcon(index);
+
+	if (role != Qt::DisplayRole)
+		return QVariant ();
+
+	QString h = m_columns[index.column ()].toLower ();
+
+	return QVariant (m_list.at (index.row ())->data (h));
+}
+
+QVariant
+BrowseModel::headerData (int section,
+						 Qt::Orientation orientation,
+						 int role) const
+{
+	if (role == Qt::DisplayRole)
+		return QVariant (m_columns[section]);
+	return QVariant ();
+}
+
+QIcon
+BrowseModel::fileIcon (const QModelIndex &index) const
+{
+    if (!index.isValid())
+		return QIcon ();
+
+	BrowseModelItem *item = m_list.at (index.row ());
+	if (item && item->isDir ())
+    	return QIcon (m_style->standardPixmap (QStyle::SP_DirClosedIcon));
+
+	return QIcon (m_style->standardPixmap (QStyle::SP_FileIcon));
+}

src/BrowseModel.h

@@ -0,0 +1,88 @@
+#ifndef __BROWSEMODEL_H__
+#define __BROWSEMODEL_H__
+
+#include <xmmsclient/xmmsclient++.h>
+
+#include <QHash>
+#include <QString>
+#include <QStyle>
+#include <QStringList>
+#include <QAbstractTableModel>
+
+class BrowseModelItem
+{
+	public:
+		BrowseModelItem (const QString &path,
+						 const QString &name = 0,
+						 bool isdir = true)
+		{
+			m_isdir = isdir;
+			m_vals["path"] = path;
+			m_vals["name"] = name;
+		};
+
+		QString data (const QString &key) {
+			return m_vals[key];
+		};
+
+		bool isDir () {
+			return m_isdir;
+		};
+		
+		static bool itemCompare (BrowseModelItem *s1, BrowseModelItem *s2);
+
+	protected:
+		QHash<QString, QString> m_vals;
+		bool m_isdir;
+
+};
+
+class BrowseModel : public QAbstractTableModel
+{
+	Q_OBJECT
+	public:
+		BrowseModel (QWidget *parent);
+
+		QString currentPath () const
+		{
+			return m_current_dir;
+		};
+
+		void setFilterDot (bool b)
+		{
+			m_filter_dot = b;
+		};
+
+		void setPath (const QModelIndex &index);
+		void setPath (const QString &path);
+		BrowseModelItem *itemByIndex (const QModelIndex &index);
+
+		/* QModel overrides */
+		int rowCount (const QModelIndex &parent) const;
+		int columnCount (const QModelIndex &parent) const;
+		QVariant data (const QModelIndex &index,
+					   int role = Qt::DisplayRole) const;
+		QVariant headerData (int section,
+							 Qt::Orientation orientation,
+							 int role = Qt::DisplayRole) const;
+		QIcon fileIcon (const QModelIndex &index) const;
+
+	signals:
+		void dirChanged (QString);
+
+	private:
+		bool list_cb (const Xmms::List< Xmms::Dict > &res);
+		bool list_err (const std::string err);
+
+		void list_root ();
+
+		bool m_filter_dot;
+
+		QList<BrowseModelItem*> m_list;
+		QStringList m_columns;
+		QString m_current_dir;
+		QStyle *m_style;
+		Xmms::Client *m_client;
+};
+
+#endif

src/Button.cpp

@@ -0,0 +1,135 @@
+#include "MainWindow.h"
+#include "Button.h"
+
+#include "Skin.h"
+
+#include <QMouseEvent>
+
+Button::Button (QWidget *parent) : PixWidget (parent)
+{
+	m_name_normal = 0;
+	m_name_pressed = 0;
+}
+
+Button::Button (QWidget *parent, uint normal, uint pressed, bool pls) : PixWidget (parent)
+{
+	m_name_normal = normal;
+	m_name_pressed = pressed;
+	m_diffx = 0;
+	m_diffy = 0;
+	m_pls = pls;
+}
+
+Button::~Button ()
+{
+}
+
+void
+Button::setPixmaps(Skin *skin)
+{
+	if (!m_name_normal && !m_name_pressed) {
+		return;
+	}
+
+	if (m_pls) {
+		m_pixmap_normal = skin->getPls (m_name_normal);
+		m_pixmap_pressed = skin->getPls (m_name_pressed);
+	} else {
+		m_pixmap_normal = skin->getItem (m_name_normal);
+		m_pixmap_pressed = skin->getItem (m_name_pressed);
+	}
+	m_pixmap = m_pixmap_normal;
+
+	if (!m_pixmap_normal || m_pixmap_normal.isNull()) {
+		qDebug ("OPPP! %d return NULL!", m_name_normal);
+	}
+	if (!m_pixmap_pressed || m_pixmap_pressed.isNull()) {
+		qDebug ("OPPP! %d return NULL!", m_name_pressed);
+	}
+
+	setMinimumSize (m_pixmap.size ());
+	setMaximumSize (m_pixmap.size ());
+
+	update();
+}
+
+void 
+Button::mousePressEvent (QMouseEvent *event)
+{
+	m_pixmap = m_pixmap_pressed;
+
+	m_diffx = event->pos().x();
+	m_diffy = event->pos().y();
+
+	update ();
+}
+
+void 
+Button::mouseReleaseEvent (QMouseEvent *event)
+{
+	m_pixmap = m_pixmap_normal;
+	update();
+	emit clicked();
+}
+
+ToggleButton::ToggleButton (QWidget *parent, uint on_normal, uint on_pressed,
+							uint off_normal, uint off_pressed) : 
+					Button (parent, off_normal, off_pressed)
+{
+
+	m_name_on_normal = on_normal;
+	m_name_on_pressed = on_pressed;
+	m_name_off_normal = off_normal;
+	m_name_off_pressed = off_pressed;
+	m_toggled_on = false;
+
+	connect (this, SIGNAL(clicked()), this, SLOT (toggleOn()));
+}
+
+
+void
+ToggleButton::setPixmaps(Skin *skin)
+{
+	m_pixmap_on_normal = skin->getItem(m_name_on_normal);
+	m_pixmap_on_pressed = skin->getItem(m_name_on_pressed);
+	m_pixmap_off_normal = skin->getItem(m_name_off_normal);
+	m_pixmap_off_pressed = skin->getItem(m_name_off_pressed);
+
+	setCurrentPix ();
+
+	setMinimumSize (m_pixmap.size ());
+	setMaximumSize (m_pixmap.size ());
+
+	update();
+}
+
+void
+ToggleButton::setCurrentPix ()
+{
+	if (m_toggled_on) {
+		m_pixmap_normal = m_pixmap_on_normal;
+		m_pixmap_pressed = m_pixmap_on_pressed;
+	} else {
+		m_pixmap_normal = m_pixmap_off_normal;
+		m_pixmap_pressed = m_pixmap_off_pressed;
+	}
+
+	m_pixmap = m_pixmap_normal;
+}
+
+void
+ToggleButton::toggleOn ()
+{
+	if (!m_toggled_on) {
+		m_toggled_on = true;
+	} else {
+		m_toggled_on = false;
+	}
+
+	setCurrentPix ();
+	update ();
+}
+
+ToggleButton::~ToggleButton ()
+{
+}

src/Button.h

@@ -0,0 +1,67 @@
+#ifndef __BUTTON_H__
+#define __BUTTON_H__
+
+#include "PixWidget.h"
+
+class Button : public PixWidget
+{
+	Q_OBJECT
+	public:
+		Button (QWidget *parent, uint btn1, uint btn2, bool pls=false);
+		Button (QWidget *parent);
+		~Button ();
+
+	public slots:
+		void setPixmaps (Skin *skin);
+
+	signals:
+		void clicked (void);
+
+	protected:
+		void mousePressEvent (QMouseEvent *event);
+		void mouseReleaseEvent (QMouseEvent *event);
+		void mouseMoveEvent (QMouseEvent *event) {}
+
+		uint m_name_normal;
+		uint m_name_pressed;
+
+		uint m_diffx;
+		uint m_diffy;
+		
+		QPixmap m_pixmap_normal;
+		QPixmap m_pixmap_pressed;
+
+		bool m_nodrag;
+		bool m_pls;
+};
+
+class ToggleButton : public Button
+{
+	Q_OBJECT
+	public:
+		ToggleButton (QWidget *parent, uint, uint, uint, uint);
+		~ToggleButton ();
+
+		bool getOn () const { return m_toggled_on; }
+
+	public slots:
+		void setPixmaps(Skin *skin);
+		void toggleOn ();
+
+	private:
+		uint m_name_on_normal;
+		uint m_name_on_pressed;
+		uint m_name_off_normal;
+		uint m_name_off_pressed;
+		
+		QPixmap m_pixmap_on_normal;
+		QPixmap m_pixmap_on_pressed;
+		QPixmap m_pixmap_off_normal;
+		QPixmap m_pixmap_off_pressed;
+
+		bool m_toggled_on;
+		
+		void setCurrentPix ();
+};
+
+#endif

src/ClutterBar.cpp

@@ -0,0 +1,62 @@
+#include "ClutterBar.h"
+#include "Skin.h"
+
+ClutterBar::ClutterBar (QWidget *parent) : PixWidget (parent)
+{
+}
+
+ClutterBar::~ClutterBar ()
+{
+}
+
+
+void
+ClutterBar::setPixmaps(Skin *skin)
+{
+	m_clutter_on = skin->getItem(Skin::CLUTTER_ON);
+	m_clutter_off = skin->getItem(Skin::CLUTTER_OFF);
+
+	m_clutter_o = skin->getItem(Skin::CLUTTER_O);
+	m_clutter_a = skin->getItem(Skin::CLUTTER_A);
+	m_clutter_i = skin->getItem(Skin::CLUTTER_I);
+	m_clutter_d = skin->getItem(Skin::CLUTTER_D);
+	m_clutter_v = skin->getItem(Skin::CLUTTER_V);
+
+	m_pixmap = m_clutter_on;
+
+	setMinimumSize (m_clutter_on.size ());
+	setMaximumSize (m_clutter_on.size ());
+
+	update();
+}
+
+void
+ClutterBar::mousePressEvent (QMouseEvent *event)
+{
+	int y = event->pos().y();
+
+	if (y > 2 && y < 11) {
+		m_pixmap = m_clutter_o;
+	} else if (y > 10 && y < 19) {
+		m_pixmap = m_clutter_a;
+	} else if (y > 18 && y < 27) {
+		m_pixmap = m_clutter_i;
+	} else if (y > 26 && y < 35) {
+		m_pixmap = m_clutter_d;
+	} else if (y > 34 && y < 43) {
+		m_pixmap = m_clutter_v;
+	}
+
+	update();
+}
+
+void
+ClutterBar::mouseReleaseEvent (QMouseEvent *event)
+{
+	m_pixmap = m_clutter_on;
+
+	update();
+}
+
+
+

src/ClutterBar.h

@@ -0,0 +1,36 @@
+#ifndef __CLUTTERBAR_H__
+#define __CLUTTERBAR_H__
+
+#include <QMouseEvent>
+#include "PixWidget.h"
+
+class ClutterBar : public PixWidget
+{
+	Q_OBJECT
+	public:
+		ClutterBar (QWidget *parent);
+		~ClutterBar ();
+
+	public slots:
+		void setPixmaps(Skin *skin);
+
+	protected:
+		void mousePressEvent (QMouseEvent *event);
+		void mouseReleaseEvent (QMouseEvent *event);
+
+		QPixmap m_clutter_off;
+		QPixmap m_clutter_on;
+
+		QPixmap m_clutter_o;
+		QPixmap m_clutter_a;
+		QPixmap m_clutter_i;
+		QPixmap m_clutter_d;
+		QPixmap m_clutter_v;
+
+		bool enabled;
+
+		int m_ypos;
+};
+
+
+#endif

src/Display.cpp

@@ -0,0 +1,77 @@
+#include "MainWindow.h"
+#include "Display.h"
+
+#include "TitleBar.h"
+
+#include "FileDialog.h"
+
+SkinDisplay::SkinDisplay (QWidget *parent) : QWidget(parent)
+{
+	Skin *skin = Skin::getInstance ();
+
+	m_mw = parent;
+
+	connect (skin, SIGNAL (skinChanged (Skin *)),
+	         this, SLOT (setPixmaps (Skin *)));
+}
+
+void
+SkinDisplay::setPixmaps (Skin *skin)
+{
+}
+
+void 
+SkinDisplay::mousePressEvent (QMouseEvent *event)
+{
+	dynamic_cast<MainWindow *>(getMW())->raisePL ();
+	m_diffX = event->x();
+	m_diffY = event->y();
+}
+
+void 
+SkinDisplay::mouseMoveEvent (QMouseEvent *event)
+{
+	m_mw->move (event->globalPos().x() - m_diffX,
+				event->globalPos().y() - m_diffY);
+}
+
+void
+SkinDisplay::enterEvent (QEvent *event)
+{
+	dynamic_cast<TitleBar *>(m_tbar)->setActive(true);
+}
+
+void
+SkinDisplay::leaveEvent (QEvent *event)
+{
+	dynamic_cast<TitleBar *>(m_tbar)->setActive(false);
+}
+
+void 
+SkinDisplay::paintEvent (QPaintEvent *event)
+{
+	QPainter(paint);
+
+	paint.begin(this);
+	paint.eraseRect(rect());
+	paint.end();
+}
+
+void
+SkinDisplay::fileOpen (void)
+{
+	FileDialog fd (this, "main_addfiles");
+	QStringList files;
+
+	files = fd.getFiles ();
+
+	XMMSHandler &xmmsh = XMMSHandler::getInstance();
+	if (files.count() > 0) {
+		xmmsh.playlistClear ();
+	}
+
+	for (int i = 0; i < files.count(); i++) {
+		xmmsh.playlistAddURL ("file://" + files.value(i));
+	}
+}
+

src/Display.h

@@ -0,0 +1,40 @@
+#ifndef __SKINDISPLAY_H__
+#define __SKINDISPLAY_H__
+
+#include <iostream>
+
+#include <QPixmap>
+#include <QPainter>
+#include <QWidget>
+#include <QHash>
+#include <QMouseEvent>
+#include <QPaintEvent>
+
+#include "Skin.h"
+
+class SkinDisplay : public QWidget
+{
+	Q_OBJECT
+	public:
+		SkinDisplay (QWidget *parent);
+		QWidget *getMW () const { return m_mw; }
+
+	public slots:
+		virtual void setPixmaps(Skin *skin);
+		void fileOpen (void);
+
+	protected:
+		void mousePressEvent (QMouseEvent *);
+		void mouseMoveEvent (QMouseEvent *);
+		void paintEvent (QPaintEvent *event);
+		void enterEvent (QEvent *event);
+		void leaveEvent (QEvent *event);
+
+		QWidget *m_mw;
+		QWidget *m_tbar;
+		
+		int m_diffX;
+		int m_diffY;
+};
+
+#endif

src/Equalizer.cpp

@@ -0,0 +1,122 @@
+#include "MainWindow.h"
+#include "TitleBar.h"
+#include "Equalizer.h"
+#include "Button.h"
+#include "VolumeSlider.h"
+
+EqualizerWindow::EqualizerWindow (QWidget *parent) : QMainWindow (parent)
+{
+	m_mw = dynamic_cast<MainWindow *>(parent);
+
+	setWindowFlags (Qt::Dialog | Qt::FramelessWindowHint);
+	setAttribute (Qt::WA_DeleteOnClose);
+
+	m_equalizer = new EqualizerWidget (this);
+	m_equalizer->show();
+
+	setCentralWidget (m_equalizer);
+
+	setMinimumSize (275, 116);
+	setMaximumSize (275, 116);
+}
+
+EqualizerWindow::~EqualizerWindow (void)
+{
+}
+
+void
+EqualizerWindow::setEnabled (void)
+{
+	qDebug ("test");
+}
+
+
+void
+EqualizerWindow::mousePressEvent (QMouseEvent *event)
+{
+	m_diffx = event->pos().x();
+	m_diffy = event->pos().y();
+}
+
+void
+EqualizerWindow::mouseMoveEvent (QMouseEvent *event)
+{
+	move(event->globalPos().x() - m_diffx,
+		 event->globalPos().y() - m_diffy);
+}
+
+void
+EqualizerWindow::moveEvent (QMoveEvent *event)
+{
+	QSettings s;
+	s.setValue ("equalizer/pos", pos ());
+}
+
+EqualizerWidget::EqualizerWidget (QWidget *parent) : QWidget (parent)
+{
+	Skin *skin = Skin::getInstance ();
+
+	connect (skin, SIGNAL(skinChanged(Skin *)),
+	         this, SLOT(setPixmaps(Skin *)));
+
+	m_enable = new ToggleButton(this, Skin::EQ_WIN_ON_0, Skin::EQ_WIN_ON_1,
+	                            Skin::EQ_WIN_OFF_0, Skin::EQ_WIN_OFF_1);
+	m_enable->move(14, 18);
+
+	connect(m_enable, SIGNAL(clicked()), parent, SLOT(setEnabled()));
+
+	m_auto = new ToggleButton(this, Skin::EQ_WIN_AUTO_ON_0, Skin::EQ_WIN_AUTO_ON_1,
+	                          Skin::EQ_WIN_AUTO_OFF_0, Skin::EQ_WIN_AUTO_OFF_1);
+	m_auto->move(39, 18);
+
+	connect(m_auto, SIGNAL(clicked()), parent, SLOT(setEnabled()));
+
+	m_preset = new Button(this, Skin::EQ_WIN_PRESET_0, Skin::EQ_WIN_PRESET_1);
+	m_preset->move(217, 18);
+
+	connect(m_preset, SIGNAL(clicked()), parent, SLOT(setEnabled()));
+
+	m_preamp = new Slider(this, Skin::EQ_WIN_BAR_POS_0, Skin::EQ_WIN_BAR_POS_27,
+	                      Skin::EQ_WIN_BAR_BTN_0, Skin::EQ_WIN_BAR_BTN_1, -20, 20);
+	m_preamp->move(21, 38);
+
+	for (int i=0; i < 10; i++) {
+		m_bands[i] = new Slider(this, Skin::EQ_WIN_BAR_POS_0, Skin::EQ_WIN_BAR_POS_27,
+		                        Skin::EQ_WIN_BAR_BTN_0, Skin::EQ_WIN_BAR_BTN_1, -20, 20);
+		m_bands[i]->move(78+i*18, 38);
+	}
+}
+
+EqualizerWidget::~EqualizerWidget (void)
+{
+}
+
+void
+EqualizerWidget::setPixmaps (Skin *skin)
+{
+	m_pixmap = skin->getItem(Skin::EQ_WIN_BG);
+	m_graph = skin->getItem(Skin::EQ_WIN_GRAPH_BG);
+
+	setMinimumSize (m_pixmap.size ());
+	setMaximumSize (m_pixmap.size ());
+
+	update();
+}
+
+void 
+EqualizerWidget::paintEvent (QPaintEvent *event)
+{
+	if (m_pixmap.isNull ()) {
+		return;
+	}
+	QPainter(paint);
+	QRect r;
+
+	paint.begin(this);
+	
+	paint.drawPixmap(rect(), m_pixmap, m_pixmap.rect());
+	r.setRect(86, 17, 113, 19);
+	paint.drawPixmap(r, m_graph, m_graph.rect());
+	
+	paint.end();
+}

src/Equalizer.h

@@ -0,0 +1,62 @@
+#ifndef __EQUALIZER_H__
+#define __EQUALIZER_H__
+
+class Skin;
+class Button;
+class MainWindow;
+class TitleBar;
+class ToggleButton;
+class Slider;
+
+#include <iostream>
+
+#include <QPixmap>
+#include <QWidget>
+#include <QMouseEvent>
+#include <QPaintEvent>
+#include <QMainWindow>
+
+#include "Display.h"
+
+class EqualizerWidget : public QWidget
+{
+	Q_OBJECT
+	public:
+		EqualizerWidget(QWidget *parent);
+		~EqualizerWidget();
+		void paintEvent (QPaintEvent *event);
+
+	public slots:
+		void setPixmaps(Skin *skin);
+	private:
+		QPixmap m_pixmap;
+		QPixmap m_graph;
+		ToggleButton *m_enable;
+		ToggleButton *m_auto;
+		Button *m_preset;
+		Slider *m_preamp;
+		Slider *m_bands[10];
+};
+
+class EqualizerWindow : public QMainWindow
+{
+	Q_OBJECT
+	public:
+		EqualizerWindow(QWidget *parent);
+		~EqualizerWindow();
+		void mouseMoveEvent(QMouseEvent *);
+		void mousePressEvent(QMouseEvent *);
+		void moveEvent(QMoveEvent *event);
+
+	public slots:
+		void setEnabled (void);
+
+	private:
+		MainWindow *m_mw;
+		EqualizerWidget *m_equalizer;
+		int m_diffx;
+		int m_diffy;
+};
+
+
+#endif

src/FileDialog.cpp

@@ -0,0 +1,43 @@
+#include "FileDialog.h"
+
+#include <QSettings>
+#include <QFileDialog>
+#include <QString>
+
+
+FileDialog::FileDialog (QWidget *parent, const QString &name) : QFileDialog (parent)
+{
+	QSettings s;
+	m_name = name;
+
+	if (!s.contains("filedialog/" + name))
+		s.setValue ("filedialog/" + name, QDir::homePath ());
+
+	setDirectory (s.value("filedialog/" + name).toString ());
+}
+
+QStringList
+FileDialog::getFiles ()
+{
+	QSettings s;
+	QStringList ret = getOpenFileNames (NULL, "Choose files");
+	if (ret.size() > 0)
+		s.setValue ("filedialog/" + m_name, directory ().absolutePath ());
+
+	qSort (ret);
+
+	return ret;
+
+}
+
+QString
+FileDialog::getDirectory ()
+{
+	QSettings s;
+	QString ret = getExistingDirectory (NULL, "Choose directory");
+	if (!ret.isNull())
+		s.setValue ("filedialog/" + m_name, directory ().absolutePath ());
+
+	return ret;
+
+}

src/FileDialog.h

@@ -0,0 +1,19 @@
+#ifndef __FILEDIALOG_H__
+#define __FILEDIALOG_H__
+
+#include <QFileDialog>
+
+class FileDialog : public QFileDialog
+{
+	Q_OBJECT
+	public:
+		FileDialog (QWidget *parent, const QString &name);
+		QString getDirectory ();
+		QStringList getFiles ();
+
+	private:
+		QString m_name;
+
+};
+
+#endif

src/MainDisplay.cpp

@@ -0,0 +1,281 @@
+#include <xmmsclient/xmmsclient++.h>
+#include "XMMSHandler.h"
+#include "MainDisplay.h"
+#include "MainWindow.h"
+
+#include "TitleBar.h"
+#include "Button.h"
+#include "TextBar.h"
+#include "NumberDisplay.h"
+#include "TimeDisplay.h"
+#include "SmallNumberDisplay.h"
+#include "StereoMono.h"
+#include "PosBar.h"
+#include "PlayStatus.h"
+#include "VolumeSlider.h"
+#include "Playlist.h"
+#include "ClutterBar.h"
+
+#include <QFileDialog>
+#include <QSettings>
+
+MainDisplay::MainDisplay (QWidget *parent) : SkinDisplay(parent)
+{
+	m_tbar = new TitleBar(this, false);
+	m_tbar->move(0, 0);
+	m_tbar->resize(275, 14);
+
+	m_mw = dynamic_cast<MainWindow *>(parent);
+
+	SetupPushButtons ();
+	SetupToggleButtons ();
+
+	m_text = new TextScroller (this, 154, 10, "main");
+	m_text->move (112, 25);
+
+	m_time = new TimeDisplay(this, 0);
+	connect (m_time, SIGNAL(clicked()), this, SLOT(toggleTime()));
+
+	m_kbps = new SmallNumberDisplay (this, 15);
+	m_kbps->move (111, 43);
+	m_kbps->setNumber (128, 3);
+
+	m_khz = new SmallNumberDisplay (this, 10);
+	m_khz->move (156, 43);
+	m_khz->setNumber (44, 2);
+
+	m_stereo = new StereoMono (this);
+	m_stereo->move (212, 41);
+	m_stereo->setStereoMono (0, 0);
+
+	m_clutterbar = new ClutterBar (this);
+	m_clutterbar->move (10, 22);
+
+	m_posbar = new PosBar (this, Skin::POSBAR, 
+						   Skin::POSBAR_BTN_0, 
+						   Skin::POSBAR_BTN_1);
+	m_posbar->move (16, 72);
+
+	m_playstatus = new PlayStatus (this);
+	m_playstatus->move (24, 28);
+
+	m_vslider = new Slider(this, Skin::VOLUMEBAR_POS_0, Skin::VOLUMEBAR_POS_27,
+	                       Skin::VOLBAR_BTN_0, Skin::VOLBAR_BTN_1, 0, 100);
+	m_vslider->move (107, 57);
+
+	m_bslider = new Slider(this, Skin::BALANCE_POS_0, Skin::BALANCE_POS_27,
+	                       Skin::BALANCE_BTN_0, Skin::BALANCE_BTN_1, -20, 20);
+	m_bslider->move (177, 57);
+
+	XMMSHandler &xmmsh = XMMSHandler::getInstance ();
+	connect (&xmmsh, SIGNAL(currentSong (const Xmms::PropDict &)), 
+			 this, SLOT(setMediainfo (const Xmms::PropDict &)));
+	connect (&xmmsh, SIGNAL(playbackStatusChanged(Xmms::Playback::Status)),
+	         this, SLOT(setStatus(Xmms::Playback::Status)));
+//	connect (&xmmsh, SIGNAL(playtimeChanged(uint)),
+//	         this, SLOT(setPlaytime(uint)));
+	connect (xmmsh.cache () , SIGNAL (playtime (uint32_t)),
+	         this,  SLOT (setPlaytime (uint32_t)));
+	connect (&xmmsh, SIGNAL(getVolume(uint)), this, SLOT(updateVolume(uint)));
+	connect (m_vslider, SIGNAL(valueChanged(int)), this, SLOT(setVolume(int)));
+	xmmsh.volumeGet();
+}
+
+
+void
+MainDisplay::updateVolume (uint volume)
+{
+	m_vslider->setValue((int)volume);
+}
+
+void
+MainDisplay::setVolume (int volume)
+{
+	XMMSHandler &xmmsh = XMMSHandler::getInstance();
+	xmmsh.volumeSet((uint)volume);
+}
+
+void 
+MainDisplay::mouseMoveEvent (QMouseEvent *event)
+{
+	MainWindow *mw = dynamic_cast<MainWindow *>(window ());
+	PlaylistWindow *pl = mw->getPL ();
+
+	m_mw->move (event->globalPos().x() - m_diffX,
+				event->globalPos().y() - m_diffY);
+
+	if (!pl || !pl->isVisible ())
+		return;
+
+	pl->move (event->globalPos().x() - m_diffX,
+			  event->globalPos().y() - m_diffY + size().height());
+}
+
+void
+MainDisplay::setPixmaps (Skin *skin)
+{
+	QPalette palette = QPalette();
+	QBrush brush = QBrush(skin->getItem(Skin::MAIN_WINDOW));
+	palette.setBrush(QPalette::Background, brush);
+	setPalette(palette);
+
+	setMaximumSize(QSize(275, 116));
+	setMinimumSize(QSize(275, 116));
+}
+
+void
+MainDisplay::setStatus (Xmms::Playback::Status status)
+{
+	if (status == Xmms::Playback::STOPPED) {
+		m_time->setTime(0);
+		m_posbar->setPos (0);
+		m_posbar->hideBar (true);
+	}
+}
+
+void
+MainDisplay::setPlaytime (uint32_t time)
+{
+	uint32_t showtime;
+	if (m_mw->isTimemodeReverse()) {
+		uint maxtime = m_posbar->getMax();
+		showtime = -(maxtime - time); 
+	} else {
+		showtime = time;
+	}
+	m_time->setTime (showtime);
+
+	// update slider
+	m_posbar->setPos (time);
+}
+
+void
+MainDisplay::setMediainfo (const Xmms::PropDict &info)
+{
+	QString n;
+	if (info.contains ("title")) {
+		if (info.contains ("artist")) {
+			n = QString::fromUtf8 (info.get<std::string> ("artist").c_str ()) + " - ";
+		}
+		if (info.contains ("album")) {
+			n += QString::fromUtf8 (info.get<std::string> ("album").c_str ()) + " - ";
+		}
+		n += QString::fromUtf8 (info.get<std::string> ("title").c_str ());
+	} else if (info.contains ("channel")) {
+		n = QString::fromUtf8 (info.get<std::string> ("channel").c_str ()) + " - " +
+		    QString::fromUtf8 (info.get<std::string> ("title").c_str ());
+	} else {
+		n = QString::fromUtf8 (info.get<std::string> ("url").c_str ());
+		n = n.section ("/", -1);
+	}
+	m_text->setText (n);
+	
+	if (info.contains ("bitrate")) {
+		m_kbps->setNumber (info.get<int32_t> ("bitrate")/1000, 3);
+	} else {
+		m_kbps->setNumber (0, 1);
+	}
+
+	if (info.contains ("samplerate")) {
+		m_khz->setNumber (info.get<int32_t> ("samplerate")/1000, 2);
+	} else {
+		m_khz->setNumber(0, 1);
+	}
+	if (info.contains ("channels:in") && 
+	    info.get<int32_t> ("channels:in") > 1) {
+		m_stereo->setStereoMono (1, 0);
+	} else {
+		m_stereo->setStereoMono (0, 1);
+	}
+
+	if (info.contains ("duration")) {
+		m_posbar->setMax (info.get<int32_t> ("duration"));
+		m_posbar->hideBar (false);
+	} else {
+		m_posbar->hideBar (true);
+	}
+}
+
+void
+MainDisplay::SetupToggleButtons (void)
+{
+	QSettings s;
+
+	m_pls = new ToggleButton (this, Skin::PLS_ON_0, Skin::PLS_ON_1,
+							  Skin::PLS_OFF_0, Skin::PLS_OFF_1);
+	m_pls->move(242, 58);
+	if (!s.value ("playlist/hidden").toBool ())
+		m_pls->toggleOn ();
+
+	connect (m_pls, SIGNAL(clicked()), this, SLOT(togglePL()));
+
+	m_eq = new ToggleButton (this, Skin::EQ_ON_0, Skin::EQ_ON_1,
+							 Skin::EQ_OFF_0, Skin::EQ_OFF_1);
+	m_eq->move(219, 58);
+	if (!s.value ("equalizer/hidden").toBool ())
+		m_pls->toggleOn ();
+
+	connect (m_eq, SIGNAL(clicked()), this, SLOT(toggleEQ()));
+
+	m_shuffle = new ToggleButton (this, Skin::SHUFFLE_ON_0, Skin::SHUFFLE_ON_1,
+								  Skin::SHUFFLE_OFF_0, Skin::SHUFFLE_OFF_1);
+	m_shuffle->move(164, 89);
+
+	m_repeat = new ToggleButton (this, Skin::REPEAT_ON_0, Skin::REPEAT_ON_1,
+								 Skin::REPEAT_OFF_0, Skin::REPEAT_OFF_1);
+	m_repeat->move(210, 89);
+}
+
+void
+MainDisplay::togglePL (void)
+{
+	m_mw->togglePL(false);
+}
+
+void
+MainDisplay::toggleEQ (void)
+{
+	m_mw->toggleEQ(false);
+}
+
+void
+MainDisplay::toggleTime (void)
+{
+	m_mw->setTimemodeReverse (!m_mw->isTimemodeReverse());
+}
+
+void
+MainDisplay::SetupPushButtons (void)
+{
+	XMMSHandler &xmmsh = XMMSHandler::getInstance ();
+
+	/* Normal buttons */
+	m_prev = new Button (this, Skin::BTN_PREV_0, Skin::BTN_PREV_1);
+	m_prev->move(16, 88);
+	connect (m_prev, SIGNAL(clicked()), &xmmsh, SLOT(prev()));
+	
+	m_play = new Button (this, Skin::BTN_PLAY_0, Skin::BTN_PLAY_1);
+	m_play->move(39, 88);
+	connect (m_play, SIGNAL(clicked()), &xmmsh, SLOT(play()));
+
+	m_pause = new Button (this, Skin::BTN_PAUSE_0, Skin::BTN_PAUSE_1);
+	m_pause->move(62, 88);
+	connect (m_pause, SIGNAL(clicked()), &xmmsh, SLOT(pause()));
+
+	m_stop = new Button (this, Skin::BTN_STOP_0, Skin::BTN_STOP_1);
+	m_stop->move(85, 88);
+	connect (m_stop, SIGNAL(clicked()), &xmmsh, SLOT(stop()));
+
+	m_next = new Button (this, Skin::BTN_NEXT_0, Skin::BTN_NEXT_1);
+	m_next->move(108, 88);
+	connect (m_next, SIGNAL(clicked()), &xmmsh, SLOT(next()));
+
+	m_eject = new Button (this, Skin::BTN_EJECT_0, Skin::BTN_EJECT_1);
+	m_eject->move(136, 89);
+	connect (m_eject, SIGNAL(clicked()), this, SLOT(fileOpen()));
+
+}
+
+MainDisplay::~MainDisplay (void)
+{
+}

src/MainDisplay.h

@@ -0,0 +1,103 @@
+#ifndef __MAINDISPLAY_H__
+#define __MAINDISPLAY_H__
+
+class MainDisplay;
+
+#include <xmmsclient/xmmsclient++.h>
+#include "XMMSHandler.h"
+
+#include <iostream>
+
+#include <QPixmap>
+#include <QPainter>
+#include <QWidget>
+#include <QHash>
+#include <QBrush>
+#include <QPalette>
+
+#include "Display.h"
+/*
+#include "TitleBar.h"
+#include "Button.h"
+#include "TextBar.h"
+#include "NumberDisplay.h"
+#include "TimeDisplay.h"
+#include "SmallNumberDisplay.h"
+#include "StereoMono.h"
+#include "Slider.h"
+#include "PlayStatus.h"
+#include "VolumeSlider.h"
+#include "MainWindow.h"
+*/
+
+class Button;
+class ToggleButton;
+class TextScroller;
+class TimeDisplay;
+class SmallNumberDisplay;
+class StereoMono;
+class PosBar;
+class Slider;
+class PlayStatus;
+class MainWindow;
+class ClutterBar;
+
+class MainDisplay : public SkinDisplay 
+{
+	Q_OBJECT
+	public:
+		MainDisplay (QWidget *parent);
+		~MainDisplay ();
+		ToggleButton *GetPls() {return m_pls;};
+		ToggleButton *GetEq() {return m_eq;};
+
+		TextScroller *m_text;
+		TimeDisplay *m_time;
+
+		SmallNumberDisplay *m_kbps;
+		SmallNumberDisplay *m_khz;
+
+		StereoMono *m_stereo;
+		PosBar *m_posbar;
+		Slider *m_vslider;
+		Slider *m_bslider;
+		
+		PlayStatus *m_playstatus;
+		MainWindow *getMW(void) { return m_mw; }
+
+		void mouseMoveEvent (QMouseEvent *);
+
+	public slots:
+		void setPixmaps(Skin *skin);
+		void setStatus (Xmms::Playback::Status status);
+		void setPlaytime (uint32_t time);
+		void setMediainfo (const Xmms::PropDict &);
+		void togglePL(void);
+		void toggleEQ(void);
+		void toggleTime(void);
+		void updateVolume (uint volume);
+		void setVolume (int volume);
+
+	protected:
+		void SetupPushButtons (void);
+		void SetupToggleButtons (void);
+
+		Button *m_prev;
+		Button *m_play;
+		Button *m_pause;
+		Button *m_stop;
+		Button *m_next;
+		Button *m_eject;
+
+		ToggleButton *m_pls;
+		ToggleButton *m_eq;
+		ToggleButton *m_shuffle;
+		ToggleButton *m_repeat;
+
+		MainWindow *m_mw;
+
+		ClutterBar *m_clutterbar;
+
+};
+
+#endif

src/MainWindow.cpp

@@ -0,0 +1,208 @@
+#include "MainWindow.h"
+
+#ifdef HAVE_SERVERBROWSER
+#include "ServerBrowser.h"
+#endif
+
+#include "Playlist.h"
+#include "MainDisplay.h"
+#include "ShadedDisplay.h"
+#include "Equalizer.h"
+
+#include <QSettings>
+#include <QIcon>
+#include <QPluginLoader>
+#include <qplugin.h>
+
+MainWindow::MainWindow (QWidget *parent) : QMainWindow (parent)
+{
+	QSettings settings;
+
+	setWindowFlags(Qt::FramelessWindowHint);
+	setGeometry(100, 100, 275, 116);
+#ifndef _WIN32
+	setWindowIcon (QIcon (":icon.png"));
+#endif
+
+	if (!settings.contains ("mainwindow/shaded"))
+		setShaded (true);
+	else
+		setShaded (!isShaded ());
+
+	/* 
+	 * The MainDisplay is the mainwindow non-shaded mode
+	 */
+	m_display = new MainDisplay (this);
+	setCentralWidget (m_display);
+	m_display->show ();
+
+	/*
+	 * MainDisplay's shaded mode
+	 */
+	m_shaded = new ShadedDisplay (this);
+	m_shaded->hide ();
+
+	switchDisplay ();
+
+	m_playlistwin = NULL;
+
+	if (!settings.contains ("mainwindow/pos"))
+		settings.setValue ("mainwindow/pos", QPoint (100, 100));
+
+	move (settings.value("mainwindow/pos").toPoint ());
+}
+
+MainWindow::~MainWindow ()
+{
+	delete Skin::getInstance ();
+}
+
+void
+MainWindow::switchDisplay ()
+{
+	QSettings s;
+
+	if (isShaded ()) {
+		m_shaded->hide ();
+		m_display->show ();
+		resize (275, 116);
+		setShaded (false);
+	} else {
+		m_display->hide ();
+		m_shaded->show ();
+		resize (275, 14);
+		setShaded (true);
+	}
+
+	update ();
+
+}
+
+void
+MainWindow::raisePL (void)
+{ 
+	m_playlistwin->raise (); 
+}
+
+void
+MainWindow::moveEvent (QMoveEvent *event)
+{
+	QSettings s;
+	s.setValue ("mainwindow/pos", pos ());
+}
+
+void 
+MainWindow::togglePL (bool UpdateButton) 
+{ 
+	QSettings s;
+
+	if(UpdateButton)
+	{
+		getMD()->GetPls()->toggleOn();
+	}
+
+	if (s.value ("playlist/hidden").toBool ()) {
+		m_playlistwin->move (s.value("playlist/pos").toPoint ());
+		m_playlistwin->show (); 
+		s.setValue ("playlist/hidden", false);
+	} else {
+		m_playlistwin->hide (); 
+		s.setValue ("playlist/hidden", true);
+	} 
+}
+
+
+void 
+MainWindow::toggleEQ (bool UpdateButton) 
+{ 
+	QSettings s;
+
+	if(UpdateButton)
+	{
+		getMD()->GetEq()->toggleOn();
+	}
+
+	if (s.value ("equalizer/hidden").toBool ()) {
+		m_equalizer->move (s.value("equalizer/pos").toPoint ());
+		m_equalizer->show (); 
+		s.setValue ("equalizer/hidden", false);
+	} else {
+		m_equalizer->hide (); 
+		s.setValue ("equalizer/hidden", true);
+	} 
+}
+
+int 
+main (int argc, char **argv)
+{
+	QApplication app(argc, argv);
+
+	QCoreApplication::setOrganizationName("XMMS2 Team");
+	QCoreApplication::setOrganizationDomain("xmms.org");
+	QCoreApplication::setApplicationName("Promoe");
+
+	QSettings settings;
+
+#ifdef Q_OS_MACX 
+	/** This is soooo wrong, there must exsist a flag for
+	  * static plugins
+	Q_IMPORT_PLUGIN(QJpegPlugin);
+	  */
+#endif
+
+	MainWindow *mw = new MainWindow (NULL);
+
+	PlaylistWindow *playlistwin = new PlaylistWindow (mw);
+	EqualizerWindow *eqwin = new EqualizerWindow (mw);
+
+	/*
+	 * Now that everything is initialized
+	 * open the skin and send the
+	 * SkinChanged signal that will cause
+	 * all widgets to get their pixmaps
+	 */
+	if (!settings.contains ("skin/path")) {
+		settings.setValue ("skin/path", ":CleanAMP/");
+	}
+
+	Skin::getInstance()->setSkin (settings.value("skin/path").toString ());
+
+	mw->show ();
+	mw->setPL (playlistwin);
+	mw->setEQ (eqwin);
+
+	if (!settings.contains ("playlist/pos"))
+		settings.setValue ("playlist/pos", QPoint (mw->pos().x(),
+												   mw->pos().y()+mw->size().height()));
+	playlistwin->move (settings.value("playlist/pos").toPoint ());
+
+	if (!settings.contains ("playlist/hidden"))
+		settings.setValue ("playlist/hidden", true);
+
+	if (settings.value("playlist/hidden").toBool ())
+		playlistwin->hide ();
+	else
+		playlistwin->show ();
+
+
+	if (!settings.contains ("equalizer/pos"))
+		settings.setValue ("equalizer/pos", QPoint (mw->pos().x(),
+												   mw->pos().y()+mw->size().height()));
+	eqwin->move (settings.value("equalizer/pos").toPoint ());
+
+	if (!settings.contains ("equalizer/hidden"))
+		settings.setValue ("equalizer/hidden", true);
+
+	if (settings.value("equalizer/hidden").toBool ())
+		eqwin->hide ();
+	else
+		eqwin->show ();
+
+
+#ifdef HAVE_SERVERBROWSER
+	ServerBrowserWindow *browser = new ServerBrowserWindow (mw);
+	browser->show ();
+#endif
+
+	return app.exec();
+}

src/MainWindow.h

@@ -0,0 +1,68 @@
+#ifndef __MAINWINDOW_H__
+#define __MAINWINDOW_H__
+
+class MainWindow;
+
+#include "XMMSHandler.h"
+
+#include <iostream>
+
+#include <QMainWindow>
+#include <QPixmap>
+#include <QPainter>
+#include <QWidget>
+#include <QHash>
+#include <QSettings>
+
+#include "xmmsqt4.h"
+
+/*
+#include "Skin.h"
+#include "MainDisplay.h"
+#include "ShadedDisplay.h"
+#include "Playlist.h"
+*/
+
+class XmmsQT4;
+class Skin;
+class MainDisplay;
+class ShadedDisplay;
+class PlaylistWindow;
+class EqualizerWindow;
+
+class MainWindow : public QMainWindow
+{
+	Q_OBJECT
+	public:
+		MainWindow (QWidget *parent);
+		~MainWindow (void);
+
+		MainDisplay *getMD () { return m_display; }
+		ShadedDisplay *getSD () { return m_shaded; }
+		PlaylistWindow *getPL () { return m_playlistwin; }
+
+		void setPL (PlaylistWindow *p) { m_playlistwin = p; }
+		void setEQ (EqualizerWindow *e) { m_equalizer = e; }
+
+		void raisePL (void);
+		void moveEvent (QMoveEvent *event);
+
+		void togglePL (bool UpdateButton);
+		void toggleEQ (bool UpdateButton);
+		bool isTimemodeReverse(void) { QSettings s; return s.value("MainWindow/timemodereverse").toBool(); }
+		void setTimemodeReverse(bool b) { QSettings s; return s.setValue("MainWindow/timemodereverse",b); }
+
+	public slots:
+		void switchDisplay ();
+
+	private:
+		bool isShaded (void) { QSettings s; return s.value("MainWindow/shaded").toBool(); }
+		void setShaded (bool b) { QSettings s; return s.setValue("MainWindow/shaded", b); }
+		MainDisplay *m_display;
+		ShadedDisplay *m_shaded;
+		PlaylistWindow *m_playlistwin;
+		EqualizerWindow *m_equalizer;
+};
+
+
+#endif

src/MedialibItem.h

@@ -0,0 +1,62 @@
+#ifndef __MEDIALIBITEM_H__
+#define __MEDIALIBITEM_H__
+
+#include <QStringList>
+
+class MedialibItem {
+	public:
+		enum MedialibItemType {
+			NoneItem,
+			ArtistItem,
+			AlbumItem,
+			SongItem
+		};
+
+		MedialibItem (const QStringList &text = QStringList (), MedialibItem *parent = NULL, MedialibItemType type = NoneItem) {
+			m_text = text;
+			m_type = type;
+			m_parent = parent;
+			if (parent) {
+				parent->m_childs.append (this);
+			}
+		};
+
+		bool mayHaveChilds () const {
+			if (m_type == NoneItem || m_type == SongItem)
+				return false;
+			return true;
+		};
+
+		QString data (int c) const {
+			if (m_text.size () > c) {
+				return m_text.at (c);
+			}
+			return QString ();
+		};
+
+		MedialibItem *child (int c) const {
+			return m_childs.value (c);
+		}
+
+		int childCount () const {
+			return m_childs.count ();
+		};
+
+		MedialibItem *parent () const {
+			return m_parent;
+		};
+
+		int row () const {
+			if (m_parent)
+				return m_parent->m_childs.indexOf (const_cast<MedialibItem*> (this));
+			return 0;
+		}
+
+	private:
+		MedialibItemType m_type;
+		QStringList m_text;
+		MedialibItem *m_parent;
+		QList<MedialibItem *> m_childs;
+};
+
+#endif

src/MedialibTreeModel.cpp

@@ -0,0 +1,149 @@
+#include <xmmsclient/xmmsclient++.h>
+#include "XmmsQt4.h"
+#include "MedialibTreeModel.h"
+#include "MedialibItem.h"
+
+#include <QAbstractItemModel>
+#include <QErrorMessage>
+#include <QString>
+
+MedialibTreeModel::MedialibTreeModel (QObject *parent) :
+	QAbstractItemModel (parent), m_client ("PromoeMedialibTree")
+{
+	const char *path = getenv("XMMS_PATH");
+	try {
+		m_client.connect (path ? path : "");
+	}
+	catch (Xmms::connection_error& e) {
+		QErrorMessage *err = new QErrorMessage ();
+		err->showMessage ("Couldn't connect to XMMS2, please try again.");
+		err->exec ();
+		delete err;
+	}
+
+	m_client.setMainloop (new XmmsQT4 (m_client.getConnection ()));
+
+	m_rootitem = new MedialibItem ();
+
+	using Xmms::bind;
+
+	m_client.medialib.select ("select distinct value from Media where key='artist' order by lower(value)",
+							  bind (&MedialibTreeModel::artist_list, this));
+
+}
+
+bool
+MedialibTreeModel::artist_list (const Xmms::List< Xmms::Dict > &artists)
+{
+	QString s;
+
+	for (artists.first (); artists.isValid (); ++artists) {
+		s = QString::fromUtf8 ((*artists).get<std::string> ("value").c_str ());
+		new MedialibItem (QStringList (s), m_rootitem, MedialibItem::ArtistItem);
+	}
+
+	reset ();
+
+	return true;
+}
+
+/* QModel overrides */
+
+Qt::ItemFlags
+MedialibTreeModel::flags (const QModelIndex &index) const
+{
+	if (!index.isValid())
+		return Qt::ItemIsEnabled;
+
+	return Qt::ItemIsEnabled | Qt::ItemIsSelectable;
+}
+
+int
+MedialibTreeModel::rowCount (const QModelIndex &parent) const
+{
+	MedialibItem *item;
+
+	if (!parent.isValid ()) {
+		item = m_rootitem;
+	} else {
+		item = static_cast<MedialibItem*> (parent.internalPointer ());
+	}
+
+	int n = item->childCount ();
+
+	if (n == 0 && item->mayHaveChilds ())
+		n = 1;
+
+	return n;
+}
+
+QModelIndex
+MedialibTreeModel::parent (const QModelIndex &index) const
+{
+	if (!index.isValid ())
+		return QModelIndex ();
+
+	MedialibItem *item = static_cast<MedialibItem*> (index.internalPointer ());
+	MedialibItem *parent = item->parent ();
+
+	if (parent == m_rootitem) {
+		return QModelIndex ();
+	}
+
+	return createIndex (parent->row (), 0, parent);
+}
+
+QModelIndex
+MedialibTreeModel::index (int row, int column,
+						  const QModelIndex &parent) const
+{
+	MedialibItem *p;
+	if (!parent.isValid ()) {
+		p = m_rootitem;
+	} else {
+		p = static_cast<MedialibItem*> (parent.internalPointer ());
+	}
+	
+	MedialibItem *child = p->child (row);
+	if (child) {
+		return createIndex (row, column, child);
+	} else {
+		if (p->columnCount () == 0 && !p->loading ()) {
+			qDebug ("Loading items...");
+			switch (p->type ()) {
+				case MedialibItem::ArtistItem:
+					m_client.medialib.select ("select distinct m1.value as value from Media m1 join Media m2 on m1.id = m2.id and m2.key = 'artist' where m1.key='album' and m2.value = '%s' order by lower(m1.value)", MedialibTreeModel::sub_list);
+
+	return QModelIndex ();
+}
+
+int
+MedialibTreeModel::columnCount (const QModelIndex &parent) const
+{
+	return 1;
+}
+
+QVariant
+MedialibTreeModel::data (const QModelIndex &index,
+						 int role) const
+{
+	if (!index.isValid ())
+		return QVariant ();
+
+	if (role != Qt::DisplayRole)
+		return QVariant ();
+
+	MedialibItem *item = static_cast<MedialibItem *> (index.internalPointer ());
+	return QVariant (item->data (index.column ()));
+}
+
+QVariant
+MedialibTreeModel::headerData (int section,
+							   Qt::Orientation orientation,
+							   int role) const
+{
+	if (role == Qt::DisplayRole)
+		return QVariant("Title");
+	return QVariant ();
+}
+

src/MedialibTreeModel.h

@@ -0,0 +1,33 @@
+#ifndef __MEDIALIBTREEMODEL_H__
+#define __MEDIALIBTREEMODEL_H__
+
+#include <xmmsclient/xmmsclient++.h>
+
+#include "MedialibItem.h"
+
+#include <QAbstractItemModel>
+#include <QStringList>
+
+class MedialibTreeModel : public QAbstractItemModel
+{
+	Q_OBJECT
+	public:
+		MedialibTreeModel (QObject *parent);
+		MedialibTreeModel::~MedialibTreeModel () {};
+
+		/* QModel overrides */
+		int rowCount (const QModelIndex &parent) const;
+		int columnCount (const QModelIndex &parent) const;
+		QVariant data (const QModelIndex &index, int role = Qt::DisplayRole) const;
+		QVariant headerData (int section, Qt::Orientation orientation, int role = Qt::DisplayRole) const;
+		Qt::ItemFlags flags (const QModelIndex &index) const;
+		QModelIndex index (int row, int column, const QModelIndex &parent) const;
+		QModelIndex parent (const QModelIndex &index) const;
+
+	private:
+		bool artist_list (const Xmms::List< Xmms::Dict > &artists);
+		Xmms::Client m_client;
+		MedialibItem *m_rootitem;
+};
+
+#endif

src/MedialibView.cpp

@@ -0,0 +1,10 @@
+#include "MedialibTreeModel.h"
+#include "MedialibView.h"
+#include <QTreeView>
+
+
+MedialibView::MedialibView (QWidget *parent) : QTreeView (parent)
+{
+	setAlternatingRowColors (true);
+	setModel (new MedialibTreeModel (this));
+}

src/MedialibView.h

@@ -0,0 +1,15 @@
+#ifndef __MEDIALIBVIEW_H__
+#define __MEDIALIBVIEW_H__
+
+#include <QTreeView>
+#include <QAbstractItemModel>
+
+class MedialibView : public QTreeView
+{
+	Q_OBJECT
+	public:
+		MedialibView (QWidget *parent);
+};
+
+
+#endif

src/MedialibWindow.cpp

@@ -0,0 +1,21 @@
+#include "XMMSSocket.h"
+#include "MedialibWindow.h"
+#include "MedialibView.h"
+
+#include <QMainWindow>
+
+MedialibWindow::MedialibWindow (QWidget *parent) : QMainWindow (parent)
+{
+#ifndef _WIN32
+	setWindowIcon (QIcon (":icon.png"));
+#endif
+
+	setWindowFlags (Qt::Dialog);
+	setAttribute (Qt::WA_DeleteOnClose);
+
+	m_view = new MedialibView (this);
+
+	setCentralWidget (m_view);
+
+	resize (500, 600);
+}

src/MedialibWindow.h

@@ -0,0 +1,17 @@
+#ifndef __MEDIALIBWINDOW_H__
+#define __MEDIALIBWINDOW_H__
+
+#include "MedialibView.h"
+#include <QMainWindow>
+
+class MedialibWindow : public QMainWindow
+{
+	Q_OBJECT
+	public:
+		MedialibWindow (QWidget *parent);
+
+	private:
+		QTreeView *m_view;
+};
+
+#endif

src/NumberDisplay.cpp

@@ -0,0 +1,63 @@
+#include "MainWindow.h"
+#include "NumberDisplay.h"
+
+#include "TimeDisplay.h"
+#include "Skin.h"
+
+NumberDisplay::NumberDisplay (QWidget *parent, TimeDisplay *td,uint w, uint startpx) : PixWidget (parent)
+{
+	m_td = td;
+	m_w = w;
+	m_startpx = startpx;
+
+	m_pixmap = QPixmap (m_w, 13);
+	
+	setMinimumSize (m_w, 13);
+	setMaximumSize (m_w, 13);
+
+	setNumber (0,0);
+}
+
+void
+NumberDisplay::setPixmaps (Skin *skin)
+{
+	QBrush b (skin->getNumber (10));
+
+	QPainter paint;
+	paint.begin (&m_pixmap);
+	paint.fillRect (m_pixmap.rect (), b);
+	paint.drawPixmap (m_startpx, 0, skin->getNumber (m_n1));
+	paint.drawPixmap (m_startpx+12, 0, skin->getNumber (m_n2));
+	paint.end();
+
+	update ();
+}
+
+void
+NumberDisplay::setNumber (uint n1, uint n2)
+{
+	if (m_n1 != n1 || m_n2 != n2) {
+		Skin *skin = Skin::getInstance ();
+
+		m_n1 = n1;
+		m_n2 = n2;
+
+		setPixmaps (skin);
+	}
+}
+
+NumberDisplay::~NumberDisplay ()
+{
+}
+void
+NumberDisplay::mousePressEvent (QMouseEvent *event)
+{
+}
+void
+NumberDisplay::mouseReleaseEvent (QMouseEvent *event)
+{
+//	TimeDisplay *td = dynamic_cast<TimeDisplay *>(parent());
+	emit clicked();
+	m_td->drawMinus ();
+}
+

src/NumberDisplay.h

@@ -0,0 +1,34 @@
+#ifndef __NUMBERDISPLAY_H__
+#define __NUMBERDISPLAY_H__
+
+class TimeDisplay;
+
+#include "PixWidget.h"
+
+class NumberDisplay : public PixWidget
+{
+	Q_OBJECT
+	public:
+		NumberDisplay (QWidget *parent, TimeDisplay *td, uint, uint);
+		~NumberDisplay ();
+
+		void setNumber (uint, uint);
+
+	public slots:
+		void setPixmaps (Skin *skin);
+	signals:
+		void clicked(void);
+
+	protected:
+		void mousePressEvent (QMouseEvent *event);
+		void mouseReleaseEvent (QMouseEvent *event);
+		int m_w;
+		int m_startpx;
+
+		TimeDisplay *m_td;
+		uint m_n1;
+		uint m_n2;
+};
+
+
+#endif

src/PixWidget.cpp

@@ -0,0 +1,42 @@
+#include "MainWindow.h"
+
+#include "Skin.h"
+#include "PixWidget.h"
+
+PixWidget::PixWidget (QWidget *parent) : QWidget (parent)
+{
+	Skin *skin = Skin::getInstance();
+	m_pixmap = QPixmap(0,0);
+
+	connect (skin, SIGNAL (skinChanged (Skin *)),
+	         this, SLOT (setPixmaps(Skin *)));
+}
+
+
+PixWidget::~PixWidget ()
+{
+}
+
+
+void
+PixWidget::setPixmaps(Skin *skin)
+{
+}
+
+/*
+ * Since almost every Widget I have here
+ * is done by drawing self.pixmap onto self
+ * we define this a generic PaintEvent handler
+ */
+void 
+PixWidget::paintEvent (QPaintEvent *event)
+{
+	if (m_pixmap.isNull ()) {
+		return;
+	}
+
+	QPainter (paint);
+	paint.begin (this);
+	paint.drawPixmap (rect (), m_pixmap, m_pixmap.rect ());
+	paint.end ();
+}

src/PixWidget.h

@@ -0,0 +1,27 @@
+#ifndef __PIXWIDGET_H__
+#define __PIXWIDGET_H__
+
+#include <iostream>
+
+#include <QPixmap>
+#include <QPainter>
+#include <QWidget>
+
+class Skin;
+
+class PixWidget : public QWidget
+{
+	Q_OBJECT
+	public:
+		PixWidget(QWidget *parent = 0);
+		~PixWidget();
+		void paintEvent (QPaintEvent *event);
+		QWidget *getMW (void) { return m_mw; }
+	public slots:
+		virtual void setPixmaps(Skin *skin);
+	protected:
+		QPixmap m_pixmap;
+		QWidget *m_mw;
+};
+
+#endif

src/PlayStatus.cpp

@@ -0,0 +1,41 @@
+#include <xmmsclient/xmmsclient++.h>
+#include "PlayStatus.h"
+#include "Skin.h"
+
+PlayStatus::PlayStatus (QWidget *parent) : PixWidget (parent)
+{
+	setMinimumSize(11, 9);
+	setMaximumSize(11, 9);
+
+	m_status = Xmms::Playback::STOPPED;
+
+	connect (&XMMSHandler::getInstance (),
+	         SIGNAL(playbackStatusChanged(Xmms::Playback::Status)),
+	         this, SLOT(setStatus(Xmms::Playback::Status)));
+}
+
+void
+PlayStatus::setPixmaps (Skin *skin)
+{
+	m_pixmap_play = skin->getItem (Skin::PIC_PLAY);
+	m_pixmap_pause = skin->getItem (Skin::PIC_PAUSE);
+	m_pixmap_stop = skin->getItem (Skin::PIC_STOP);
+
+	setStatus (m_status);
+}
+
+void
+PlayStatus::setStatus (Xmms::Playback::Status status)
+{
+	using Xmms::Playback;
+	if (status == Playback::STOPPED) {
+		m_pixmap = m_pixmap_stop;
+	} else if (status == Playback::PLAYING) {
+		m_pixmap = m_pixmap_play;
+	} else if (status == Playback::PAUSED) {
+		m_pixmap = m_pixmap_pause;
+	}
+
+	update ();
+}
+

src/PlayStatus.h

@@ -0,0 +1,28 @@
+#ifndef __PLAYSTATUS_H__
+#define __PLAYSTATUS_H__
+
+#include <xmmsclient/xmmsclient++.h>
+#include "XMMSHandler.h"
+#include "PixWidget.h"
+
+class PlayStatus : public PixWidget
+{
+	Q_OBJECT
+	public:
+		PlayStatus (QWidget *parent);
+		~PlayStatus () { }
+
+
+	public slots:
+		void setPixmaps (Skin *skin);
+		void setStatus (Xmms::Playback::Status status);
+
+	private:
+		Xmms::Playback::Status m_status;
+
+		QPixmap m_pixmap_stop;
+		QPixmap m_pixmap_play;
+		QPixmap m_pixmap_pause;
+};
+
+#endif

src/Playlist.cpp

@@ -0,0 +1,616 @@
+#include "MainWindow.h"
+#include "BrowseDialog.h"
+#include "Playlist.h"
+#include "PlaylistView.h"
+#include "playlistmodel.h"
+
+#include "PlaylistShade.h"
+#include "PlaylistMenu.h"
+#include "FileDialog.h"
+
+#include <QMouseEvent>
+#include <QPaintEvent>
+#include <QRect>
+#include <QIcon>
+#include <QApplication>
+#include <QSettings>
+#include <QFileDialog>
+
+/*
+ *
+ * PlaylistScrollBar
+ *
+ */
+PlaylistScrollBar::PlaylistScrollBar (QWidget *parent) :
+                   QScrollBar (Qt::Vertical, parent)
+{
+	Skin *skin = Skin::getInstance ();
+
+	setContextMenuPolicy(Qt::NoContextMenu);
+
+	m_pixmap = QPixmap (0, 0);
+	m_slider = QPixmap (0, 0);
+	m_slider_down = QPixmap (0, 0);
+
+	connect (skin, SIGNAL (skinChanged (Skin *)),
+	         this, SLOT (setPixmaps(Skin *)));
+}
+
+void
+PlaylistScrollBar::mouseMoveEvent (QMouseEvent *event)
+{
+	if (!isSliderDown ())
+		return;
+
+	int tmp = sliderValueFromPosition(event->y () - m_sliderOffset);
+	if (tmp == value())
+		return;
+
+	setValue(tmp);
+
+	//TODO only repaint necessyry range
+	repaint ();
+}
+
+void
+PlaylistScrollBar::mousePressEvent (QMouseEvent *event)
+{
+	if (event->button() == Qt::RightButton) {
+		event->ignore();
+		return;
+	}
+
+	if (maximum () == minimum ())
+		return;
+
+	int sliderBase = sliderPositionFromValue();
+	if (event->y () < sliderBase) {
+		triggerAction (QAbstractSlider::SliderPageStepSub);
+	} else if (event->y () > sliderBase + m_slider.height ()) {
+		triggerAction (QAbstractSlider::SliderPageStepAdd);
+	} else {
+		m_sliderOffset = event->y () - sliderBase;
+		setSliderDown (true);
+	}
+
+	//TODO only repaint necessary range
+	repaint ();
+}
+
+void
+PlaylistScrollBar::mouseReleaseEvent (QMouseEvent *event)
+{
+	if (event->button() == Qt::RightButton) {
+		event->ignore();
+		return;
+	}
+
+	if (isSliderDown ()) {
+		setValue(sliderValueFromPosition(event->y () - m_sliderOffset));
+		setSliderDown (false);
+	}
+
+	//TODO only repaint necessary range
+	repaint ();
+}
+
+void
+PlaylistScrollBar::paintEvent (QPaintEvent *event)
+{
+	if (m_pixmap.isNull ()) {
+		return;
+	}
+
+// TODO remove, in here for debuging
+//	qDebug("%i %i %i %i %i %i %i", event->rect ().x(), event->rect ().y(), event->rect ().width(), event->rect ().height(), 
+//	       minimum(), maximum (), sliderPosition ());
+
+	QPainter (paint);
+	paint.begin (this);
+	/* draw background */
+	paint.drawPixmap (event->rect (), m_pixmap, m_pixmap.rect ());
+	/* draw slider */
+	QPixmap *slider = isSliderDown () ? &m_slider_down : &m_slider ;
+	QRect rect (slider->rect ());
+	rect.moveTop (sliderPositionFromValue ());
+	paint.drawPixmap (rect , *slider, slider->rect ());
+	paint.end ();
+}
+
+
+void
+PlaylistScrollBar::setPixmaps (Skin *skin)
+{
+	m_pixmap = skin->getPls (Skin::PLS_RFILL2_0);
+	m_slider = skin->getPls (Skin::PLS_SCROLL_0);
+	m_slider_down = skin->getPls (Skin::PLS_SCROLL_1);
+}
+
+
+int
+PlaylistScrollBar::sliderPositionFromValue ()
+{
+	return QStyle::sliderPositionFromValue (minimum (), maximum (),
+	                                        sliderPosition (),
+	                                        height () - m_slider.height (),
+	                                        false);
+}
+
+int
+PlaylistScrollBar::sliderValueFromPosition (int position)
+{
+	return  QStyle::sliderValueFromPosition (minimum (), maximum (),
+	                                         position,
+	                                         height () - m_slider.height (),
+                                             false);
+}
+
+
+/*
+ * dragButton
+ */
+void
+dragButton::mouseMoveEvent (QMouseEvent *event)
+{
+	PlaylistWindow *pw = dynamic_cast<PlaylistWindow *>(window ());
+	pw->resize (pw->size().width()+(event->pos().x()-m_diffx),
+				pw->size().height()+(event->pos().y()-m_diffy));
+}
+
+
+/*
+ * PlaylistWindow
+ */
+PlaylistWindow::PlaylistWindow (QWidget *parent) : QMainWindow (parent)
+{
+	QSettings s;
+	m_mw = dynamic_cast<MainWindow *>(parent);
+#ifndef _WIN32
+	setWindowIcon (QIcon (":icon.png"));
+#endif
+
+	setWindowFlags (Qt::Dialog | Qt::FramelessWindowHint);
+	setAttribute (Qt::WA_DeleteOnClose);
+
+	s.beginGroup ("playlist");
+	if (!s.contains ("size")) {
+		s.setValue ("size", QSize (275, 350));
+	}
+	resize (s.value("size").toSize ());
+
+	m_playlist = new PlaylistWidget (this);
+	setCentralWidget (m_playlist);
+	m_shaded = new PlaylistShade (this);
+
+	m_shadebtn = new Button (this, Skin::PLS_SHADE_BTN_0, Skin::PLS_SHADE_BTN_1, true);
+	connect (m_shadebtn, SIGNAL (clicked()), this, SLOT (switchDisplay ()));
+	m_shadebtn->move(size().width() - 21, 3);
+
+	m_closebtn = new Button (this, Skin::PLS_CLOSE_BTN_0, Skin::PLS_CLOSE_BTN_1, true);
+	connect (m_closebtn, SIGNAL (clicked()), this, SLOT (togglePL ()));
+	m_closebtn->move(size().width() - 11, 3);
+
+	if (!s.contains ("shaded"))
+		s.setValue ("shaded", false);
+	else
+		s.setValue ("shaded", !s.value("shaded").toBool ());
+	
+	switchDisplay ();
+
+	s.endGroup ();
+
+}
+
+void 
+PlaylistWindow::togglePL (void)
+{
+	m_mw->togglePL(true);
+}
+
+void
+PlaylistWindow::switchDisplay (void)
+{
+	QSettings s;
+
+	s.beginGroup ("playlist");
+
+	if (!s.value("shaded").toBool ()) {
+		m_shaded->hide ();
+
+		m_playlist->show ();
+		s.setValue ("shaded", true);
+		m_playlist->resize (s.value("size").toSize ());
+		resize (s.value("size").toSize ());
+
+	} else {
+		m_playlist->hide ();
+
+		m_shaded->show ();
+		s.setValue ("shaded", false);
+		m_shaded->resize (s.value("size").toSize ().width(), 14);
+		resize (s.value("size").toSize ().width(), 14);
+	}
+
+	s.endGroup ();
+
+	update ();
+
+}
+
+void
+PlaylistWindow::resizeEvent (QResizeEvent *event)
+{
+	QSettings s;
+
+	m_shadebtn->move(size().width() - 21, 3);
+	m_closebtn->move(size().width() - 11, 3);
+
+	if (s.value("playlist/shaded").toBool ()) {
+		s.setValue ("playlist/size", size ());
+	}
+}
+
+void
+PlaylistWindow::mousePressEvent (QMouseEvent *event)
+{
+	m_diffx = event->pos ().x ();
+	m_diffy = event->pos ().y ();
+}
+
+void
+PlaylistWindow::mouseMoveEvent (QMouseEvent *event)
+{
+	move (event->globalPos().x() - m_diffx,
+		  event->globalPos().y() - m_diffy);
+
+}
+
+void
+PlaylistWindow::moveEvent (QMoveEvent *event)
+{
+	QSettings s;
+	s.setValue ("playlist/pos", pos ());
+}
+
+void
+PlaylistWindow::enterEvent (QEvent *event)
+{
+	m_playlist->setActive (true);
+	m_shaded->setActive (true);
+}
+
+
+void
+PlaylistWindow::leaveEvent (QEvent *event)
+{
+	m_playlist->setActive (false);
+	m_shaded->setActive (false);
+}
+
+
+/*
+ * PlaylistWidget
+ */
+PlaylistWidget::PlaylistWidget (QWidget *parent) : QWidget (parent)
+{
+	Skin *skin = Skin::getInstance ();
+
+	connect (skin, SIGNAL (skinChanged (Skin *)),
+	         this, SLOT (setPixmaps(Skin *)));
+
+	setActive (underMouse ());
+
+	m_view = new PlaylistView (this);
+	m_view->move (10, 20);
+	m_view->resize (size().width()-30, size().height()-20-38);
+	m_view->setModel (XMMSHandler::getInstance().getPlaylistModel());
+
+	//m_list = new PlaylistList (m_view);
+
+	/*
+	 * This is a hack to make PlaylistScrollBar work with PlaylistView.
+	 * It is necessery because of limitations and at least one Bug in the
+	 *  QT library (as of Version 4.3
+	 * TODO: This might in a future Qt version. Try to find a better solution
+	 */
+	//m_scroller = new  PlaylistScrollBar (this);
+	m_scrollBar = new PlaylistScrollBar (this);
+	m_view->setVerticalScrollBar (m_scrollBar);
+	m_scrollBar->setParent(this);
+	m_scrollBar->show();
+	/* Workarounds for another QT bug (at least in my opinion) */
+	connect (m_scrollBar, SIGNAL(actionTriggered (int)),
+			 m_view, SLOT(verticalScrollbarAction (int)));
+	connect (m_scrollBar, SIGNAL(valueChanged (int)),
+	         m_view, SLOT(verticalScrollbarValueChanged (int)));
+
+	m_drag = new dragButton (this);
+	m_drag->resize (30, 30);
+	
+	addButtons ();
+
+	setMinimumSize (275, 116);
+	resize (275, 300);
+}
+
+void 
+PlaylistWidget::addButtons (void)
+{
+	PlaylistMenuButton *b;
+
+	m_add = new PlaylistMenu (this, Skin::PLS_ADD,
+							  Skin::PLS_ADD_DEC);
+	b = new PlaylistMenuButton (m_add, Skin::PLS_ADD_URL_0,
+								Skin::PLS_ADD_URL_1);
+	connect (b, SIGNAL(activated ()), this, SLOT (menuAddUrl ()));
+	b = new PlaylistMenuButton (m_add, Skin::PLS_ADD_DIR_0,
+								Skin::PLS_ADD_DIR_1);
+	connect (b, SIGNAL(activated ()), this, SLOT (menuAddDir ()));
+	b = new PlaylistMenuButton (m_add, Skin::PLS_ADD_FIL_0,
+								Skin::PLS_ADD_FIL_1);
+	connect (b, SIGNAL(activated ()), this, SLOT (menuAddFile ()));
+
+
+	m_del = new PlaylistMenu (this, Skin::PLS_DEL,
+							  Skin::PLS_DEL_DEC);
+	b = new PlaylistMenuButton (m_del, Skin::PLS_MSC_BTN_0,
+								Skin::PLS_MSC_BTN_1);
+	b = new PlaylistMenuButton (m_del, Skin::PLS_DEL_ALL_0,
+								Skin::PLS_DEL_ALL_1);
+	connect (b, SIGNAL(activated ()),
+	         &XMMSHandler::getInstance(), SLOT (playlistClear ()));
+	b = new PlaylistMenuButton (m_del, Skin::PLS_DEL_CRP_0,
+								Skin::PLS_DEL_CRP_1);
+	b = new PlaylistMenuButton (m_del, Skin::PLS_DEL_FIL_0,
+								Skin::PLS_DEL_FIL_1);
+//	connect (b, SIGNAL(activated ()), m_list, SLOT (deleteFiles ()));
+
+	m_sel = new PlaylistMenu (this, Skin::PLS_SEL,
+							  Skin::PLS_SEL_DEC);
+	b = new PlaylistMenuButton (m_sel, Skin::PLS_SEL_INV_0,
+								Skin::PLS_SEL_INV_1);
+	b = new PlaylistMenuButton (m_sel, Skin::PLS_SEL_NIL_0,
+								Skin::PLS_SEL_NIL_1);
+	b = new PlaylistMenuButton (m_sel, Skin::PLS_SEL_ALL_0,
+								Skin::PLS_SEL_ALL_1);
+
+	m_msc = new PlaylistMenu (this, Skin::PLS_MSC,
+							  Skin::PLS_MSC_DEC);
+	b = new PlaylistMenuButton (m_msc, Skin::PLS_MSC_SRT_0,
+								Skin::PLS_MSC_SRT_1);
+	b = new PlaylistMenuButton (m_msc, Skin::PLS_MSC_INF_0,
+								Skin::PLS_MSC_INF_1);
+	b = new PlaylistMenuButton (m_msc, Skin::PLS_MSC_OPT_0,
+								Skin::PLS_MSC_OPT_1);
+
+	m_lst = new PlaylistMenu (this, Skin::PLS_LST,
+							  Skin::PLS_LST_DEC);
+	b = new PlaylistMenuButton (m_lst, Skin::PLS_LST_NEW_0,
+								Skin::PLS_LST_NEW_1);
+	b = new PlaylistMenuButton (m_lst, Skin::PLS_LST_SAV_0,
+								Skin::PLS_LST_SAV_1);
+	b = new PlaylistMenuButton (m_lst, Skin::PLS_LST_OPN_0,
+								Skin::PLS_LST_OPN_1);
+}
+
+void
+PlaylistWidget::diveDir (const QString &dir)
+{
+	QDir d (dir);
+
+	d.setFilter (QDir::Files | QDir::Dirs | QDir::NoDotAndDotDot);
+
+	QFileInfoList list = d.entryInfoList();
+	for (int i = 0; i < list.size(); ++i) {
+		QFileInfo fileInfo = list.at(i);
+		if (fileInfo.isDir ()) {
+			diveDir (fileInfo.filePath ());
+		} else {
+			QString fname = fileInfo.filePath();
+			XMMSHandler::getInstance ().playlistAddURL ("file://" + fname);
+		}
+	}
+}
+
+void
+PlaylistWidget::menuAddDir ()
+{
+	/*
+	QString dir;
+	dir = QFileDialog::getExistingDirectory (this, "Select files to play",
+											 QDir::homePath ());
+	diveDir (dir);
+	*/
+
+	FileDialog fd (this, "playlist_add_dir");
+	QString dir = fd.getDirectory ();
+	if (!dir.isNull ())
+		diveDir (dir);
+}
+
+void
+PlaylistWidget::menuAddFile ()
+{
+	QSettings s;
+	QStringList files;
+
+	if (s.value ("playlist/useremote").toBool () == true) {
+		BrowseDialog bd (window ());
+		files = bd.getFiles ();
+		for (int i = 0; i < files.count(); i++) {
+			XMMSHandler::getInstance ().playlistAddURL (files.value (i));
+		}
+	} else {
+		FileDialog fd (this, "playlist_add_files");
+
+		files = fd.getFiles ();
+
+		for (int i = 0; i < files.count(); i++) {
+			XMMSHandler::getInstance ().playlistAddURL ("file://" + files.value(i));
+		}
+	}
+
+}
+
+void
+PlaylistWidget::resizeEvent (QResizeEvent *event)
+{
+	m_view->resize (size().width()-30, size().height()-20-38);
+
+	/* since the sizes has changed we need to move the buttons */
+	m_scrollBar->move (size().width()-m_rfill3.width()-m_rfill2.width(),
+					  m_corner2.height());
+	m_scrollBar->resize (m_rfill2.width(),
+						size().height()-m_corner2.height()-m_corner4.height());
+
+	/* drag corner */
+	m_drag->move (size().width()-30,
+				  size().height()-30);
+
+	/* move menus */
+	m_add->move (11, height() - m_add->height() - 12);
+	m_del->move (40, height() - m_del->height() - 12);
+	m_sel->move (69, height() - m_sel->height() - 12);
+	m_msc->move (98, height() - m_msc->height() - 12);
+	m_lst->move (width()-22-25, height() - m_lst->height() - 12);
+}
+
+void
+PlaylistWidget::setPixmaps (Skin *skin)
+{
+	setActive (m_active);
+	resize (size().width(), size().height());
+}
+
+void
+PlaylistWidget::setActive (bool active)
+{
+	Skin *skin = Skin::getInstance ();
+
+	m_active = active;
+
+	m_corner3 = skin->getPls (Skin::PLS_LCBAR);
+	m_corner4 = skin->getPls (Skin::PLS_RCBAR);
+
+	if (active) {
+		m_corner1 = skin->getPls (Skin::PLS_CORNER_UL_0);
+		m_corner2 = skin->getPls (Skin::PLS_CORNER_UR_0);
+		m_titlebar = skin->getPls (Skin::PLS_TBAR_0);
+		m_tfill = skin->getPls (Skin::PLS_TFILL_0);
+		m_bfill = skin->getPls (Skin::PLS_BFILL_0);
+		m_lfill = skin->getPls (Skin::PLS_LFILL_0);
+		m_rfill = skin->getPls (Skin::PLS_RFILL_0);
+		m_rfill2 = skin->getPls (Skin::PLS_RFILL2_0);
+		m_rfill3 = skin->getPls (Skin::PLS_RFILL3_0);
+	} else {
+		m_corner1 = skin->getPls (Skin::PLS_CORNER_UL_1);
+		m_corner2 = skin->getPls (Skin::PLS_CORNER_UR_1);
+		m_titlebar = skin->getPls (Skin::PLS_TBAR_1);
+		m_tfill = skin->getPls (Skin::PLS_TFILL_1);
+		m_bfill = skin->getPls (Skin::PLS_BFILL_1);
+		m_lfill = skin->getPls (Skin::PLS_LFILL_1);
+		m_rfill = skin->getPls (Skin::PLS_RFILL_1);
+		m_rfill2 = skin->getPls (Skin::PLS_RFILL2_1);
+		m_rfill3 = skin->getPls (Skin::PLS_RFILL3_1);
+	}
+
+	update ();
+}
+
+void
+PlaylistWidget::mouseDoubleClickEvent (QMouseEvent *event)
+{
+	PlaylistWindow *pw = dynamic_cast<PlaylistWindow *>(window ());
+	if (event->pos().y() < 14) {
+		pw->switchDisplay ();
+	}
+
+}
+
+void
+PlaylistWidget::paintEvent (QPaintEvent *event)
+{
+	QPainter paint;
+	QRect r;
+
+	paint.begin (this);
+	
+	/* drawing the upper left corner */
+	r.setRect (0, 0, 
+			   m_corner1.width(),
+			   m_corner1.height());
+	paint.drawPixmap (r, m_corner1, m_corner1.rect ());
+
+	/* drawing the upper right corner */
+	r.setRect (width()-m_corner2.width(), 0, m_corner2.width(), m_corner2.height());
+	paint.drawPixmap (r, m_corner2, m_corner2.rect());
+
+	/* Drawing the lower left corner */
+	r.setRect (0, size().height()-m_corner3.height(), 
+			   m_corner3.width(), m_corner3.height());
+	paint.drawPixmap (r, m_corner3, m_corner3.rect());
+
+	/* drawing the lower right corner */
+	r.setRect (size().width()-m_corner4.width(),
+			   size().height()-m_corner4.height(),
+			   m_corner4.width(),
+			   m_corner4.height());
+	paint.drawPixmap (r, m_corner4, m_corner4.rect());
+
+	/* calculate middle of the bar */
+	int midx = (size().width()/2) - (m_titlebar.width()/2);
+
+	/* Add the titlebar */
+	r.setRect (midx, 0, m_titlebar.width(), m_titlebar.height());
+	paint.drawPixmap (r, m_titlebar, m_titlebar.rect());
+
+	/* left fill */
+	r.setRect (m_corner1.width(), 0, midx - m_corner1.width(), m_tfill.height());
+	paint.drawPixmap (r, m_tfill, m_tfill.rect());
+
+	/* Calculate middle pixel to the right side of the titlebar */
+	int midx2 = midx + m_titlebar.width();
+
+	/* right fill */
+	r.setRect (midx2, 0, width()-midx2-m_corner2.width(), m_tfill.height());
+	paint.drawPixmap (r, m_tfill, m_tfill.rect());
+
+	/* calculate the size of the bottom side */
+	int bsize = m_corner3.width()+m_corner4.width();
+
+	/* if the width is bigger than bottom size we need to pad with
+	 * a bit of generic bottom */
+	if (size().width() > bsize) {
+		/* calculate padding width */
+		int pad_to = size().width() - bsize;
+
+		/* Draw the bottom filling */
+		r.setRect (m_corner3.width(), size().height()-m_bfill.height(), 
+				   pad_to, m_bfill.height());
+		paint.drawPixmap (r, m_bfill, m_bfill.rect());
+	}
+
+	/* The slider bar consists of three elements L|S|R (left, slider, right)
+	 * here we paint L and R and let the slider take care of the rest.
+	 */
+	r.setRect (0, m_corner1.height(), m_lfill.width(), 
+			   size().height()-m_corner3.height()-m_corner1.height());
+	paint.drawPixmap (r,m_lfill, m_lfill.rect());
+
+	r.setRect (size().width()-m_rfill3.width(), m_corner2.height(), m_rfill3.width(),
+			   size().height()-m_corner2.height()-m_corner3.height());
+	paint.drawPixmap (r, m_rfill3, m_rfill3.rect());
+
+	/* figure out where to place the last padding */
+	int x = size().width();
+	x -= m_rfill3.width(); /* minus R */
+	x -= m_rfill2.width(); /* minus slider */
+	x -= m_rfill.width(); /* minus L */
+
+	r.setRect (x, m_corner2.height(), m_rfill.width(), 
+			   size().height()-m_corner2.height()-m_corner3.height());
+	paint.drawPixmap (r, m_rfill, m_rfill.rect());
+
+	paint.end ();
+}
+

src/Playlist.h

@@ -0,0 +1,143 @@
+#ifndef __PLAYLIST_H__
+#define __PLAYLIST_H__
+
+#include "XMMSHandler.h"
+
+#include <QMainWindow>
+#include <QFont>
+#include <QScrollBar>
+
+class MainWindow;
+class PlaylistWidget;
+class PlaylistScroller;
+
+#include "Button.h"
+
+class Skin;
+//class PlaylistList;
+class PlaylistView;
+class PlaylistShade;
+class PlaylistMenu;
+
+
+
+class PlaylistScrollBar : public QScrollBar {
+	Q_OBJECT
+
+	public:
+		PlaylistScrollBar (QWidget *parent = NULL);
+		~PlaylistScrollBar () {}
+
+	public slots:
+		void mouseMoveEvent (QMouseEvent *event);
+		void mousePressEvent (QMouseEvent *event);
+		void mouseReleaseEvent (QMouseEvent *event);
+		void paintEvent (QPaintEvent *event);
+		void setPixmaps (Skin *skin);
+
+	private:
+		int sliderPositionFromValue ();
+		int sliderValueFromPosition (int position);
+
+		int m_sliderOffset;
+		QPixmap m_pixmap;
+		QPixmap m_slider;
+		QPixmap m_slider_down;
+};
+
+
+class dragButton : public Button {
+	public:
+		dragButton (QWidget *parent) : Button (parent) {}
+		~dragButton () {}
+
+		void mouseMoveEvent (QMouseEvent *event);
+};
+
+
+class PlaylistWidget : public QWidget {
+	Q_OBJECT
+
+	public:
+		PlaylistWidget (QWidget *parent);
+		~PlaylistWidget () {}
+
+		void setActive (bool);
+		void switchDisplay (void);
+
+	public slots:
+		void setPixmaps (Skin *skin);
+
+		void menuAddUrl () {}
+		void menuAddDir ();
+		void menuAddFile ();
+
+	private:
+		void resizeEvent (QResizeEvent *event);
+		void paintEvent (QPaintEvent *event);
+		void mouseDoubleClickEvent (QMouseEvent *event);
+		void addButtons (void);
+		void diveDir (const QString &);
+
+		QPixmap m_corner1;
+		QPixmap m_corner2;
+		QPixmap m_corner3;
+		QPixmap m_corner4;
+
+		QPixmap m_titlebar;
+		QPixmap m_tfill;
+		QPixmap m_bfill;
+		QPixmap m_lfill;
+		QPixmap m_rfill;
+		QPixmap m_rfill2;
+		QPixmap m_rfill3;
+
+		bool m_active;
+
+		PlaylistView *m_view;
+		QScrollBar *m_scrollBar;
+		dragButton *m_drag;
+
+		PlaylistMenu *m_add;
+		PlaylistMenu *m_del;
+		PlaylistMenu *m_sel;
+		PlaylistMenu *m_msc;
+		PlaylistMenu *m_lst;
+};
+
+
+class PlaylistWindow : public QMainWindow {
+	Q_OBJECT
+
+	public:
+		PlaylistWindow (QWidget *parent);
+		~PlaylistWindow () {}
+
+		void setActive (bool);
+
+		void mousePressEvent (QMouseEvent *event);
+		void mouseMoveEvent (QMouseEvent *event);
+		void enterEvent (QEvent *event);
+		void leaveEvent (QEvent *event);
+		void moveEvent (QMoveEvent *event);
+		void resizeEvent (QResizeEvent *event);
+
+	public slots:
+		void switchDisplay (void);
+		void togglePL (void);
+
+	private:
+		PlaylistWidget *m_playlist;
+		PlaylistShade *m_shaded;
+
+		int m_diffx;
+		int m_diffy;
+
+		Button *m_shadebtn;
+		Button *m_closebtn;
+		uint getOffset (void);
+		MainWindow *m_mw;
+
+};
+
+#endif

src/PlaylistList.cpp

@@ -0,0 +1,792 @@
+#include <xmmsclient/xmmsclient++.h>
+#include "XMMSHandler.h"
+
+#include "PlaylistList.h"
+#include "Playlist.h"
+
+#include <QStyleOptionHeader>
+#include <QPaintEvent>
+#include <QSettings>
+#include <QCursor>
+#include <QDrag>
+#include <QMenu>
+
+PlaylistItem::PlaylistItem (PlaylistList *pl, uint id)
+{
+	m_pl = pl;
+	m_id = id;
+	m_req = false;
+	m_duration = QString ("00:00");
+	pl->addItem (this);
+}
+
+PlaylistItem::PlaylistItem (PlaylistList *pl, uint id, uint pos)
+{
+	m_pl = pl;
+	m_id = id;
+	m_req = false;
+	m_duration = QString ("00:00");
+	pl->addItem (this, pos);
+}
+
+QString
+PlaylistItem::text (void)
+{
+
+	if (m_text.count() < 1) {
+
+		if (!m_req) {
+			XMMSHandler::getInstance ().requestMediainfo (m_id);
+			m_req = true;
+		}
+
+		QString q;
+		q.setNum (m_id);
+		return q;
+	} else {
+		m_req = false;
+		return m_text;
+	}
+}
+
+PlaylistList::PlaylistList (QWidget *parent) : QWidget (parent)
+{
+	QSettings s;
+	XMMSHandler &xmmsh = XMMSHandler::getInstance ();
+	Skin *skin = Skin::getInstance ();
+
+	if (!s.contains("playlist/fontsize"))
+		s.setValue ("playlist/fontsize", 10);
+
+	setAttribute (Qt::WA_NoBackground);
+	setFocusPolicy (Qt::StrongFocus);
+
+	setAcceptDrops (true);
+
+	connect (skin, SIGNAL (skinChanged (Skin *)),
+	         this, SLOT (setPixmaps(Skin *)));
+
+	m_font = NULL;
+	m_fontmetrics = NULL;
+	m_items = new QList<PlaylistItem *>;
+	m_selected = new QList<uint>;
+	m_itemmap = new QHash<uint, PlaylistItem *>;
+	m_offset = 0;
+	m_status = XMMS_PLAYBACK_STATUS_STOP;
+	m_bar = -2;
+
+	connect (&xmmsh, SIGNAL(playlistList(const Xmms::List< unsigned int > &)),
+	         this, SLOT(playlistList(const Xmms::List< unsigned int > &)));
+
+	connect (&xmmsh, SIGNAL(currentID(uint)),
+	         this, SLOT(currentID(uint)));
+
+	connect (&xmmsh, SIGNAL(mediainfoChanged(uint, const Xmms::PropDict &)), 
+	         this, SLOT(mediainfoChanged(uint, const Xmms::PropDict &)));
+
+	connect (&xmmsh, SIGNAL(playlistChanged(const Xmms::Dict &)),
+	         this, SLOT(playlistChanged(const Xmms::Dict &)));
+
+	connect (&xmmsh, SIGNAL(playbackStatusChanged(Xmms::Playback::Status)),
+	         this, SLOT(setStatus(Xmms::Playback::Status)));
+
+	connect (&xmmsh, SIGNAL(settingsSaved()),
+	         this, SLOT(settingsSaved()));
+}
+
+void
+PlaylistList::settingsSaved ()
+{
+	QSettings s;
+	m_font->setPixelSize (s.value ("playlist/fontsize").toInt ());
+
+	if (m_fontmetrics) {
+		delete m_fontmetrics;
+	}
+	m_fontmetrics = new QFontMetrics (*m_font);
+	update ();
+}
+
+void
+PlaylistList::setStatus (Xmms::Playback::Status s)
+{
+	m_status = s;
+}
+
+void
+PlaylistList::playlistChanged (const Xmms::Dict &change)
+{
+	int signal = change.get<int32_t> ("type");
+	XMMSHandler &xmmsh = XMMSHandler::getInstance ();
+	switch (signal) {
+		case XMMS_PLAYLIST_CHANGED_ADD:
+			{
+				uint id = change.get<uint32_t> ("id");
+				if (m_itemmap->contains (id)) {
+					addItem (m_itemmap->value (id));
+				} else {
+					new PlaylistItem (this, id);
+				}
+			}
+			break;
+		case XMMS_PLAYLIST_CHANGED_INSERT:
+			{
+				uint id = change.get<uint32_t> ("id");
+				int pos = change.get<int32_t> ("position");
+
+				if (m_itemmap->contains (id)) {
+					addItem (m_itemmap->value (id));
+				} else {
+					new PlaylistItem (this, id, pos);
+				}
+
+			}
+			break;
+		case XMMS_PLAYLIST_CHANGED_REMOVE:
+			{
+				int pos = change.get<int32_t> ("position");
+				PlaylistItem *i = m_items->value (pos);
+
+				if (!i) {
+					return;
+				}
+
+				m_items->removeAt (pos);
+				if (!m_items->contains (i)) {
+					m_itemmap->remove (i->getID ());
+					delete i;
+				} 
+
+				if (m_active) {
+					if (m_active > pos) {
+						m_active --;
+					} else if (m_active == pos) {
+						m_active = 0;
+					}
+				}
+
+				doResize ();
+
+			}
+			break;
+		case XMMS_PLAYLIST_CHANGED_MOVE:
+			break;
+		case XMMS_PLAYLIST_CHANGED_CLEAR:
+		case XMMS_PLAYLIST_CHANGED_SHUFFLE:
+		case XMMS_PLAYLIST_CHANGED_SORT:
+			{
+				while (!m_items->isEmpty()) {
+					PlaylistItem *item = m_items->takeFirst();
+					m_items->removeAll (item);
+					delete item;
+				}
+
+				m_itemmap->clear ();
+
+				if (signal != XMMS_PLAYLIST_CHANGED_CLEAR) {
+					xmmsh.requestPlaylistList ();
+				} else {
+					doResize ();
+				}
+			}
+			break;
+	}
+
+	update ();
+}
+
+void
+PlaylistList::currentID (uint id)
+{
+	PlaylistItem *i = m_itemmap->value (id);
+	if (!i) {
+		m_active = -1;
+		return;
+	}
+	
+	m_active = m_items->indexOf (i);
+
+	update ();
+}
+
+void
+PlaylistList::mediainfoChanged (uint id, const Xmms::PropDict &info)
+{
+	PlaylistItem *i = m_itemmap->value (id);
+	if (i) {
+		QString n;
+		if (info.contains ("title")) {
+			if (info.contains ("artist")) {
+				n = QString::fromUtf8 (info.get<std::string> ("artist").c_str ()) + " - ";
+			}
+			if (info.contains ("album")) {
+				n += QString::fromUtf8 (info.get<std::string> ("album").c_str ()) + " - ";
+			}
+			n += QString::fromUtf8 (info.get<std::string> ("title").c_str ());
+		} else if (info.contains ("channel")) {
+			n = QString::fromUtf8 (info.get<std::string> ("channel").c_str ())
+			    + " - " +
+			    QString::fromUtf8 (info.get<std::string> ("title").c_str ());
+		} else {
+			n = QString::fromUtf8 (info.get<std::string> ("url").c_str ());
+			n = n.section ("/", -1);
+		}
+
+		i->setText (n);
+
+		if (info.contains ("duration")) {
+			unsigned int duration = info.get<int32_t> ("duration");
+			if (duration != (uint)-1) {
+				QString dur;
+				dur.sprintf ("%02d:%02d", duration/60000, (duration/1000)%60);
+				i->setDuration (dur);
+			}
+		}
+
+	}
+		
+	update ();
+}
+
+void
+PlaylistList::playlistList (const Xmms::List< unsigned int > &list)
+{
+	for (list.first (); list.isValid (); ++list) {
+		if (m_itemmap->contains (*list)) {
+			addItem (m_itemmap->value (*list));
+		} else {
+			new PlaylistItem (this, *list);
+		}
+	}
+
+	update ();
+}
+
+void
+PlaylistList::mouseDoubleClickEvent (QMouseEvent *event)
+{
+	if (m_items->count() < 1 || m_selected->count() < 1) {
+		return;
+	}
+
+	PlaylistItem *it = m_items->value (m_selected->first());
+	if (!it) {
+		return;
+	}
+
+	XMMSHandler &xmmsh = XMMSHandler::getInstance ();
+	xmmsh.requestTrackChange (m_items->indexOf(it));
+	if (m_status == XMMS_PLAYBACK_STATUS_STOP ||
+		m_status == XMMS_PLAYBACK_STATUS_PAUSE)
+	{
+		xmmsh.play ();
+	}
+}
+
+QPixmap 
+PlaylistList::generatePixmap (int i)
+{
+	QStyleOptionHeader opt;
+	QString t (m_items->value(i)->text());
+
+	QPixmap p (m_fontmetrics->width(t), getFontH());
+
+	QPainter paint;
+	paint.begin (&p);
+	paint.setFont (*m_font);
+	paint.setPen (QPen (m_color_normal));
+	paint.fillRect (p.rect(), QBrush (m_color_normal_bg));
+	paint.drawText (p.rect(), Qt::TextSingleLine, t);
+	paint.end ();
+
+	return p;
+}
+
+void
+PlaylistList::showMenu (void)
+{
+	QMenu qm(this);
+
+	QAction *a;
+
+	a = new QAction (tr ("Show file info"), this);
+	a->setShortcut (tr ("Ctrl+Enter"));
+	/*
+	connect (a, SIGNAL (triggered ()), this, SLOT (showMlib ()));
+	*/
+	qm.addAction (a);
+	qm.addSeparator ();
+
+	a = new QAction (tr ("Add file"), this);
+	a->setShortcut (tr ("Ctrl+F"));
+	qm.addAction (a);
+
+	a = new QAction (tr ("Remove selected"), this);
+	qm.addAction (a);
+
+	qm.addSeparator ();
+
+	a = new QAction (tr ("Medialib browser"), this);
+	qm.addAction (a);
+
+	qm.exec (QCursor::pos ());
+}
+
+void 
+PlaylistList::mousePressEvent (QMouseEvent *event)
+{
+	if (m_items->count() < 1) {
+		return;
+	}
+
+	int i = ((event->pos().y()+m_offset) / getFontH());
+
+	if (i < 0) {
+		i = 0;
+	}
+
+	if (i > (m_items->count () - 1)) {
+		return;
+	}
+
+	if (event->button () == Qt::LeftButton) {
+		if (event->modifiers() & Qt::ShiftModifier) {
+			if (m_selected->count () > 0) {
+				int o = m_selected->last ();
+				if (o < i) {
+					for (int y = o+1; y <= i; y++) {
+						m_selected->append (y);
+					}
+				} else {
+					for (int y = i; y < o; y++) {
+						m_selected->append (y);
+					}
+				}
+			} else {
+				m_selected->append (i);
+			}
+		} else if (event->modifiers () & Qt::ControlModifier) {
+			if (m_selected->contains (i)) {
+				m_selected->removeAll (i);
+			} else {
+				m_selected->append (i);
+			}
+		} else {
+			if (m_selected->contains (i)) {
+				m_selected->clear();
+			} else {
+				m_selected->clear();
+				m_selected->append(i);
+			}
+
+			m_dragstart = event->pos ();
+		}
+	} else if (event->button () == Qt::RightButton) {
+		showMenu ();
+	}
+
+	update ();
+}
+
+void
+PlaylistList::mouseMoveEvent (QMouseEvent *event)
+{
+
+	if (!(event->buttons() & Qt::LeftButton))
+		return;
+	if ((event->pos() - m_dragstart).manhattanLength() < QApplication::startDragDistance())
+		return;
+
+	if (m_selected->count() > 0) {
+		int i = m_selected->last ();
+
+		m_drag = new QDrag (this);
+
+		m_md = new QMimeData();
+		QByteArray encodedData;
+
+		QDataStream stream (&encodedData, QIODevice::WriteOnly);
+		stream << QString::number (m_selected->last ());
+
+		m_md->setData("application/playlist.move", encodedData);
+
+		m_drag->setMimeData (m_md);
+
+		m_drag_id = m_items->value (i)->getID ();
+		m_pos = i;
+
+		QPixmap p = generatePixmap (i);
+
+		m_drag->setPixmap (p);
+		m_items->removeAt (i);
+		m_selected->clear ();
+
+		m_drag->start ();
+	}
+
+}
+
+void
+PlaylistList::dragEnterEvent (QDragEnterEvent *event)
+{
+
+	if (event->mimeData()->hasFormat("application/mlib.album") ||
+		event->mimeData()->hasFormat("application/mlib.artist") ||
+		event->mimeData()->hasFormat("application/mlib.song") ||
+		event->mimeData()->hasFormat("application/playlist.move"))
+		event->acceptProposedAction();
+}
+
+void
+PlaylistList::dragMoveEvent (QDragMoveEvent *event)
+{
+	int i = ((event->pos().y()+m_offset) / getFontH());
+	if (event->pos().y() < getFontH() / 2) {
+		m_bar = -1;
+	} else if (i >= m_items->count ()) {
+		m_bar = m_items->count ()-1;
+	} else {
+		m_bar = i;
+	}
+	update ();
+}
+
+void
+PlaylistList::dragLeaveEvent (QDragLeaveEvent *event)
+{
+	m_bar = -2;
+	update ();
+}
+
+void
+PlaylistList::dropEvent (QDropEvent *event)
+{
+	XMMSHandler &xmmsh = XMMSHandler::getInstance ();
+
+	if (event->mimeData()->hasFormat("application/playlist.move")) {
+		if (m_bar == -2) {
+			m_items->insert (m_pos, m_itemmap->value (m_drag_id));
+		} else {
+			m_items->insert (m_bar + 1, m_itemmap->value (m_drag_id));
+			xmmsh.playlistMove (m_pos, m_bar + 1);
+		}
+		m_selected->append (m_drag_id);
+
+		event->acceptProposedAction ();
+	}
+	/*
+	} else if (event->mimeData()->hasFormat("application/mlib.album")) {
+		const QMimeData *md = event->mimeData ();
+		QByteArray encodedData = md->data("application/mlib.album");
+		QDataStream stream(&encodedData, QIODevice::ReadOnly);
+
+		QString artist;
+		QString album;
+		stream >> artist;
+		stream >> album;
+
+		QString query;
+		if (artist == "Various Artists") {
+			query.sprintf ("select m1.id as id, ifnull(m3.value,-1) as tracknr from Media m1 join Media m2 on m1.id = m2.id and m2.key='compilation' left join Media m3 on m1.id = m3.id and m3.key='tracknr' where m1.key='album' and m1.value='%s' and m2.value=1 order by tracknr", album.toUtf8 ().data ());
+		} else {
+			query.sprintf ("select m1.id as id, ifnull(m3.value,-1) as tracknr from Media m1 join Media m2 on m1.id = m2.id and m2.key='album' left join Media m3 on m1.id = m3.id and m3.key='tracknr' where m1.key='artist' and m1.value='%s' and m2.value='%s' order by tracknr", artist.toUtf8 ().data (), album.toUtf8 ().data ());
+		}
+
+		xmmsh->medialibQueryAdd (query);
+
+		event->acceptProposedAction ();
+	} else if (event->mimeData()->hasFormat("application/mlib.artist")) {
+		const QMimeData *md = event->mimeData ();
+		QByteArray encodedData = md->data("application/mlib.artist");
+		QDataStream stream(&encodedData, QIODevice::ReadOnly);
+
+		QString artist;
+		stream >> artist;
+
+		QString query;
+		if (artist == "Various Artists") {
+			query.sprintf ("select m1.id as id, m2.value as album, ifnull(m3.value,-1) as tracknr from Media m1 left join Media m2 on m1.id = m2.id and m2.key='album' left join Media m3 on m1.id = m3.id and m3.key='tracknr' where m1.key='compilation' and m1.value=1 order by album, tracknr;");
+		} else {
+			query.sprintf ("select m1.id as id, m2.value as album, ifnull(m3.value,-1) as tracknr from Media m1 left join Media m2 on m1.id = m2.id and m2.key='album' left join Media m3 on m1.id = m3.id and m3.key='tracknr' where m1.key='artist' and m1.value='%s' order by album, tracknr", artist.toUtf8 ().data ());
+		}
+
+		xmmsh->medialibQueryAdd (query);
+		event->acceptProposedAction ();
+	} else if (event->mimeData()->hasFormat("application/mlib.song")) {
+		const QMimeData *md = event->mimeData ();
+		QByteArray encodedData = md->data("application/mlib.song");
+		QDataStream stream(&encodedData, QIODevice::ReadOnly);
+
+		QString artist;
+		QString album;
+		QString song;
+		stream >> artist;
+		stream >> album;
+		stream >> song;
+
+		QString query;
+		query.sprintf ("select m1.id as id, ifnull(m1.value, '[unknown]') as artist, ifnull(m2.value,'[unknown]') as album, ifnull(m4.value,m5.value) as song from Media m1 left join Media m2 on m1.id = m2.id and m2.key='album' left join Media m4 on m1.id = m4.id and m4.key='title' left join Media m5 on m1.id = m5.id and m5.key='url' where m1.key='artist' and artist='%s' and album='%s' and song='%s'", artist.toUtf8 ().data (), album.toUtf8 ().data (), song.toUtf8 ().data ());
+
+		xmmsh->medialibQueryAdd (query);
+
+		event->acceptProposedAction ();
+	}
+	m_bar = -2;
+	update ();
+	*/
+}
+
+void
+PlaylistList::keyPressEvent (QKeyEvent *event)
+{
+
+	QWidget *w = dynamic_cast<QWidget*>(parent());
+	QSize s = w->size ();
+	int lastitem = (m_offset + s.height()) / getFontH () - 1;
+	if (lastitem > m_items->count())
+		lastitem = m_items->count() - 1;
+	int firstitem = m_offset / getFontH();
+
+	switch (event->key ()) {
+		case Qt::Key_Down:
+			{
+				int i = m_selected->last ();
+				i ++;
+
+				if (i > (m_items->count () - 1))
+					i = m_items->count () - 1;
+
+				m_selected->clear ();
+				m_selected->append (i);
+
+				if (i > lastitem)
+					setOffset (m_offset += getFontH ());
+
+				update ();
+				emit sizeChanged (size());
+			}
+			break;
+		case Qt::Key_Up:
+			{
+				int i = m_selected->last ();
+				i --;
+				if (i < 0)
+					i = 0;
+				m_selected->clear ();
+				m_selected->append (i);
+				if (i < firstitem)
+					setOffset (m_offset -= getFontH ());
+
+				update ();
+				emit sizeChanged (size());
+			}
+			break;
+		case Qt::Key_Backspace:
+		case Qt::Key_Delete:
+			{
+				deleteFiles ();
+			}
+			break;
+		case Qt::Key_A:
+			{
+				if (event->modifiers() == Qt::ControlModifier) {
+					m_selected->clear ();
+					for (int i = 0; i < m_items->count (); i ++) {
+						m_selected->append (i);
+					}
+					update ();
+				}
+			}
+			break;
+	}
+
+}
+
+void
+PlaylistList::deleteFiles ()
+{
+	XMMSHandler &xmmsh = XMMSHandler::getInstance ();
+
+	//Sort list and remove in reverse order
+	qSort (*m_selected);
+	for (int i = (m_selected->count () - 1); i >= 0; i --) {
+		xmmsh.playlistRemove (m_selected->value (i));
+	}
+	m_selected->clear ();
+}
+
+void
+PlaylistList::paintEvent (QPaintEvent *event)
+{
+	int i;
+	QPainter paint;
+	paint.begin (this);
+	paint.setFont (*m_font);
+	/*
+	paint.setClipping (false);
+	*/
+	paint.setPen (QPen (m_color_normal));
+
+	int cy = event->rect().y () + m_offset;
+	int ch = event->rect().height();
+	int sitem = cy / getFontH();
+	int eitem = (cy + ch) / getFontH();
+	int mod = m_offset - (getFontH() * sitem);
+
+	if (eitem > m_items->count())
+		eitem = m_items->count();
+
+	QString q;
+	QRect fullLine; 
+	QRect textLine;
+	QRect numLine;
+
+	for (i = sitem; i < eitem; i++) {
+		PlaylistItem *item = m_items->value (i);
+
+		int tw = m_fontmetrics->width(item->duration ())+2;
+
+		fullLine.setRect(0, (getFontH()*(i-sitem)) - mod, 
+						 size().width(), getFontH());
+		textLine.setRect(0, (getFontH()*(i-sitem)) - mod, 
+						 size().width()-tw-4, getFontH());
+		numLine.setRect(size().width()-tw, (getFontH()*(i-sitem)) - mod, 
+						 tw, getFontH());
+
+		q = QString::number (i + 1) + ". " + item->text ();
+
+		if (m_selected->contains (i)) {
+			paint.fillRect (fullLine, QBrush (m_color_selected));
+		} else {
+			paint.eraseRect (fullLine);
+		}
+
+		if (m_active == i) {
+			paint.setPen (QPen (m_color_active));
+			paint.drawText (textLine, Qt::TextSingleLine, q);
+			paint.drawText (numLine, item->duration ());
+			paint.setPen (QPen (m_color_normal));
+		} else {
+			paint.drawText (textLine, Qt::TextSingleLine, q);
+			paint.drawText (numLine, item->duration ());
+		}
+
+		if (m_bar == -1) {
+			paint.save ();
+			QPen pen (m_color_active);
+			pen.setWidth (2);
+			paint.setPen (pen);
+			paint.drawLine (2, 0, size().width()-2, 0);
+			paint.restore ();
+		} else if (m_bar == i) {
+			paint.save ();
+			QPen pen (m_color_active);
+			pen.setWidth (5);
+			paint.setPen (pen);
+			paint.drawLine (2, fullLine.y()+getFontH(), size().width()-2, 
+							fullLine.y()+getFontH());
+			paint.restore ();
+		}
+
+	}
+
+	if ((getFontH()*(i-sitem) - mod) < size().height()) {
+		paint.eraseRect (QRect (0, (getFontH()*(i-sitem) - mod), 
+								size().width(), 
+								size().height()-(getFontH()*(i-sitem) - mod)));
+	}
+
+	paint.end ();
+
+}
+
+void
+PlaylistList::doResize (void)
+{
+	QWidget *w = dynamic_cast<QWidget*>(parent());
+	QSize s = w->size ();
+
+	if (m_items->count()*getFontH () > s.height ()) {
+		resize (size().width(), m_items->count ()*getFontH ());
+	} else {
+		resize (size().width(), s.height());
+		setOffset (0);
+	}
+	emit sizeChanged (size());
+}
+
+void
+PlaylistList::addItem (PlaylistItem *i, uint pos)
+{
+	m_items->insert (pos, i);
+	if (!m_itemmap->contains (i->getID())) {
+		m_itemmap->insert (i->getID(), i);
+	}
+	doResize ();
+}
+
+void
+PlaylistList::addItem (PlaylistItem *i)
+{
+	m_items->append (i);
+	if (!m_itemmap->contains (i->getID())) {
+		m_itemmap->insert (i->getID(), i);
+	}
+	doResize ();
+}
+
+int
+PlaylistList::getFontH (void)
+{
+	if (!m_fontmetrics) {
+		return 0;
+	}
+	return m_fontmetrics->height();
+}
+
+void
+PlaylistList::setPixmaps (Skin *skin)
+{
+	QSettings s;
+	QPalette pal;
+	QColor c;
+	c.setNamedColor (skin->getPLeditValue ("normalbg"));
+	QBrush b (c);
+	pal.setBrush (QPalette::Window, b);
+	setPalette (pal);
+
+	if (m_font) {
+		delete m_font;
+	}
+	m_font = new QFont (skin->getPLeditValue ("font"));
+	m_font->setPixelSize (s.value ("playlist/fontsize").toInt ());
+
+	if (m_fontmetrics) {
+		delete m_fontmetrics;
+	}
+	m_fontmetrics = new QFontMetrics (*m_font);
+
+	m_color_active.setNamedColor (skin->getPLeditValue ("current"));
+	m_color_selected.setNamedColor (skin->getPLeditValue ("selectedbg"));
+	m_color_normal.setNamedColor (skin->getPLeditValue ("normal"));
+	m_color_normal_bg.setNamedColor (skin->getPLeditValue ("normalbg"));
+
+	update ();
+}
+
+void
+PlaylistList::setSize (int width, int height)
+{
+	int nx, ny;
+	nx = width;
+
+	if (height > size().height()) {
+		ny = height;
+	} else {
+		ny = size().height();
+	}
+
+	resize (nx, ny);
+}
+
+

src/PlaylistList.h

@@ -0,0 +1,108 @@
+#ifndef __PLAYLISTLIST_H__
+#define __PLAYLISTLIST_H__
+
+#include <xmmsclient/xmmsclient++.h>
+#include "Skin.h"
+#include <QWidget>
+#include <QHash>
+
+#include <QDrag>
+
+class PlaylistItem;
+
+class PlaylistView : public QWidget {
+	public:
+		PlaylistView (QWidget *parent) : QWidget (parent) {}
+		~PlaylistView () {}
+};
+
+class PlaylistList : public QWidget {
+	Q_OBJECT
+
+	public:
+		PlaylistList (QWidget *parent);
+		~PlaylistList () {}
+
+		void setSize (int, int);
+		void addItem (PlaylistItem *i);
+		void addItem (PlaylistItem *i, uint pos);
+		void setOffset (int i) { m_offset = i; }
+		uint getOffset (void) const { return m_offset; }
+		void doResize (void);
+
+	public slots:
+		void setPixmaps (Skin *skin);
+		void playlistList (const Xmms::List< unsigned int > &);
+		void mediainfoChanged (uint, const Xmms::PropDict &);
+		void playlistChanged (const Xmms::Dict &);
+		void currentID (uint);
+		void setStatus (Xmms::Playback::Status s);
+		void settingsSaved ();
+		void deleteFiles ();
+	
+	signals:
+		void sizeChanged (QSize);
+	
+	private:
+		void showMenu (void);
+		void paintEvent (QPaintEvent *event);
+		void mousePressEvent (QMouseEvent *event);
+		void mouseMoveEvent (QMouseEvent *event);
+		void mouseDoubleClickEvent (QMouseEvent *event);
+		void keyPressEvent (QKeyEvent *event);
+
+		void dragMoveEvent (QDragMoveEvent *event);
+		void dragEnterEvent (QDragEnterEvent *event);
+		void dragLeaveEvent (QDragLeaveEvent *event);
+		void dropEvent (QDropEvent *event);
+
+		QPixmap generatePixmap (int);
+
+		QList<PlaylistItem*> *m_items;
+		QList<uint> *m_selected;
+		QHash<uint,PlaylistItem*> *m_itemmap;
+
+		QFont *m_font;
+		QFontMetrics *m_fontmetrics;
+		QColor m_color_active;
+		QColor m_color_selected;
+		QColor m_color_normal;
+		QColor m_color_normal_bg;
+
+		int getFontH (void);
+		int m_offset;
+		int m_active;
+		int m_bar;
+		int m_drag_id;
+		int m_pos;
+		QPoint m_dragstart;
+		Xmms::Playback::Status m_status;
+
+		QDrag *m_drag;
+		QMimeData *m_md;
+};
+
+class PlaylistItem {
+	public:
+		PlaylistItem (PlaylistList *pl, uint, uint);
+		PlaylistItem (PlaylistList *pl, uint);
+		~PlaylistItem () {}
+		
+		QString text (void);
+		QString duration (void) { return m_duration; }
+
+		uint getID (void) { return m_id; }
+		void setDuration (QString s) { m_duration = s; }
+		void setText (QString s) { m_text = s; }
+
+	private:
+		uint m_id;
+		PlaylistList *m_pl;
+
+		bool m_req;
+		QString m_text;
+		QString m_duration;
+};
+
+
+#endif

src/PlaylistMenu.cpp

@@ -0,0 +1,144 @@
+#include "PlaylistMenu.h"
+
+#include <QMouseEvent>
+#include <QWidget>
+#include <QPoint>
+
+PlaylistMenuButton::PlaylistMenuButton (PlaylistMenu *menu, 
+										uint pix1, uint pix2) : QWidget (menu)
+{
+	m_pixid1 = pix1;
+	m_pixid2 = pix2;
+	menu->addButton (this);
+	m_menu = menu;
+	setMinimumSize (22, 18);
+	setMaximumSize (22, 18);
+}
+
+PlaylistMenuButton::~PlaylistMenuButton ()
+{
+	m_menu->rmButton (this);
+}
+
+void
+PlaylistMenuButton::paintEvent (QPaintEvent *event)
+{
+	QPainter p;
+	p.begin (this);
+	p.drawPixmap (rect (), m_pixmap, m_pixmap.rect ());
+	p.end ();
+}
+
+void
+PlaylistMenuButton::setPixmaps (Skin *skin)
+{
+	m_pixmap1 = skin->getPls (m_pixid1);
+	m_pixmap2 = skin->getPls (m_pixid2);
+
+	m_pixmap = m_pixmap1;
+}
+
+PlaylistMenu::PlaylistMenu (QWidget *parent, uint pix,
+							uint decoration) : PixWidget (parent)
+{
+	setMinimumSize (25, 18);
+	setMaximumSize (25, 18);
+
+	m_expanded = new QWidget (parent);
+	m_expanded->hide ();
+
+	m_decbar = new PlaylistMenuBar (m_expanded, decoration);
+	m_decbar->move (0, 0);
+
+	m_pixid = pix;
+}
+
+void
+PlaylistMenu::addButton (PlaylistMenuButton *b)
+{
+	int i = m_items.count ();
+	/* black magic, don't try this at home kids */
+	b->setParent (m_expanded);
+	b->move (3, i * 18);
+	m_items.append (b);
+	i = m_items.count ();
+	m_decbar->resize (3, i * 18);
+	m_expanded->resize (25, i * 18);
+
+}
+
+void
+PlaylistMenu::rmButton (PlaylistMenuButton *b)
+{
+	m_items.removeAll (b);
+}
+
+void
+PlaylistMenu::mousePressEvent (QMouseEvent *event)
+{
+	PlaylistMenuButton *b = m_items.last ();
+	b->setOver ();
+
+	QWidget *w = dynamic_cast<QWidget*>(parent ());
+
+	m_expanded->move (pos ().x (), 
+					  w->height() - m_expanded->height() - 12);
+
+	m_expanded->show ();
+
+}
+
+void
+PlaylistMenu::mouseMoveEvent (QMouseEvent *event)
+{
+	int my_y = event->y() + (m_items.count () - 1) * 18;
+
+	for (int i = 0; i < m_items.count (); i ++) {
+		PlaylistMenuButton *b = m_items.value (i);
+
+		if (my_y > b->pos().y() &&
+			my_y < b->pos().y() + 18) {
+			b->setOver ();
+		} else {
+			b->setNoOver ();
+		}
+
+	}
+	m_expanded->update ();
+
+}
+
+void
+PlaylistMenu::mouseReleaseEvent (QMouseEvent *event)
+{
+	int my_y = event->y() + (m_items.count () - 1) * 18;
+
+	for (int i = 0; i < m_items.count (); i ++) {
+		PlaylistMenuButton *b = m_items.value (i);
+
+		if (my_y > b->pos().y() &&
+			my_y < b->pos().y() + 18) {
+
+			b->clicked ();
+		}
+	}
+	m_expanded->hide ();
+
+	dynamic_cast<QWidget*>(parent ())->update ();
+}
+
+void
+PlaylistMenu::setPixmaps (Skin *skin)
+{
+	for (int i = 0; i < m_items.count (); i++) {
+		PlaylistMenuButton *b = m_items.value (i);
+		if (b) {
+			b->setPixmaps (skin);
+		}
+	}
+
+	m_pixmap = skin->getPls (m_pixid);
+	m_dpixmap = skin->getPls (m_dec);
+
+	update ();
+}

src/PlaylistMenu.h

@@ -0,0 +1,85 @@
+#ifndef __PLAYLISTMENU_H__
+#define __PLAYLISTMENU_H__
+
+class PlaylistMenu;
+
+#include "XMMSHandler.h"
+#include "Skin.h"
+#include "PixWidget.h"
+
+/*
+#include <QWidget>
+#include <QPixmap>
+*/
+
+class PlaylistMenu;
+
+class PlaylistMenuBar : public PixWidget {
+	Q_OBJECT
+	public:
+		PlaylistMenuBar (QWidget *parent, uint id) : PixWidget (parent)
+		{
+			m_id = id;
+		}
+	public slots:
+		void setPixmaps (Skin *skin) { m_pixmap = skin->getPls (m_id); }
+
+	private:
+		uint m_id;
+};
+
+class PlaylistMenuButton : public QWidget {
+	Q_OBJECT
+	public:
+		PlaylistMenuButton (PlaylistMenu *, uint pix1, uint pix2);
+		~PlaylistMenuButton ();
+
+		void paintEvent (QPaintEvent *event);
+		void setPixmaps (Skin *skin);
+
+		void setOver (void) { m_pixmap = m_pixmap2; }
+		void setNoOver (void) { m_pixmap = m_pixmap1; }
+		void clicked (void) { emit activated (); }
+
+	signals:
+		void activated (void);
+
+	private:
+		uint m_pixid1;
+		uint m_pixid2;
+
+		PlaylistMenu *m_menu;
+
+		QPixmap m_pixmap1;
+		QPixmap m_pixmap2;
+		QPixmap m_pixmap;
+};
+
+class PlaylistMenu : public PixWidget {
+	Q_OBJECT
+	public:
+		PlaylistMenu (QWidget *, uint, uint);
+		~PlaylistMenu () {}
+
+		void addButton (PlaylistMenuButton *b);
+		void rmButton (PlaylistMenuButton *b);
+
+		void mousePressEvent (QMouseEvent *event);
+		void mouseReleaseEvent (QMouseEvent *event);
+		void mouseMoveEvent (QMouseEvent *);
+
+	public slots:
+		void setPixmaps (Skin *skin);
+
+	private:
+		uint m_pixid;
+		uint m_dec;
+		QPixmap m_dpixmap;
+		QList<PlaylistMenuButton *> m_items;
+		QWidget *m_expanded;
+
+		PlaylistMenuBar *m_decbar;
+
+};
+
+#endif

src/PlaylistShade.cpp

@@ -0,0 +1,124 @@
+#include "XMMSHandler.h"
+#include <xmmsclient/xmmsclient++.h>
+
+#include "PlaylistShade.h"
+#include "Playlist.h"
+
+#include <QSettings>
+
+PlaylistShade::PlaylistShade (QWidget *parent) : QWidget (parent)
+{
+	QSettings s;
+	XMMSHandler &xmmsh = XMMSHandler::getInstance ();
+
+	if (!s.contains ("playlist/shadedsize"))
+		s.setValue ("playlist/shadedsize", 8);
+
+	Skin *skin = Skin::getInstance ();
+	setMinimumSize (275, 14);
+	connect (skin, SIGNAL (skinChanged (Skin *)),
+	         this, SLOT (setPixmaps(Skin *)));
+
+	connect (&xmmsh, SIGNAL(currentSong (const Xmms::PropDict &)), 
+			 this, SLOT(setMediainfo (const Xmms::PropDict &)));
+
+	connect (&xmmsh, SIGNAL(settingsSaved ()), 
+			 this, SLOT(settingsSaved ()));
+
+	m_text = "Promoe 0.1 - A very neat XMMS2 client";
+}
+
+void
+PlaylistShade::settingsSaved ()
+{
+	QSettings s;
+
+	m_font.setPixelSize (s.value ("playlist/shadedsize").toInt ());
+	update ();
+}
+
+void
+PlaylistShade::setMediainfo (const Xmms::PropDict &info)
+{
+	QString n;
+	if (info.contains ("artist") && info.contains ("album") &&
+	    info.contains ("title")) {
+		n = QString::fromUtf8 (info.get<std::string> ("artist").c_str ())
+		    + " - " +
+		    QString::fromUtf8 (info.get<std::string> ("album").c_str ())
+		    + " - " +
+		    QString::fromUtf8 (info.get<std::string> ("title").c_str ());
+	} else {
+		n = QString::fromUtf8 (info.get<std::string> ("url").c_str ());
+	}
+	m_text = (n);
+
+	update ();
+}
+
+void
+PlaylistShade::setPixmaps (Skin *skin)
+{
+	QSettings s;
+
+	m_pixmap_le = skin->getPls (Skin::PLS_WS_LE_0);
+	m_pixmap_re_0 = skin->getPls (Skin::PLS_WS_RE_0);
+	m_pixmap_re_1 = skin->getPls (Skin::PLS_WS_RE_1);
+	m_pixmap_mid = skin->getPls (Skin::PLS_WS_MID_0);
+	m_pixmap_re = m_pixmap_re_0;
+
+	m_font = QFont (skin->getPLeditValue ("font"));
+	m_font.setPixelSize (s.value ("playlist/shadedsize").toInt ());
+	m_color.setNamedColor (skin->getPLeditValue ("normal"));
+
+	update ();
+
+}
+
+void
+PlaylistShade::setActive (bool b)
+{
+	if (b) {
+		m_pixmap_re = m_pixmap_re_0;
+	} else {
+		m_pixmap_re = m_pixmap_re_1;
+	}
+
+	update ();
+}
+
+void 
+PlaylistShade::mouseDoubleClickEvent (QMouseEvent *event)
+{
+	PlaylistWindow *pw = dynamic_cast<PlaylistWindow*>(window ());
+	pw->switchDisplay ();
+}
+
+void
+PlaylistShade::paintEvent (QPaintEvent *event)
+{
+	QRect r;
+
+	QPainter p;
+	p.begin (this);
+	r.setRect (0, 0, m_pixmap_le.size().width(), m_pixmap_le.size().height());
+	p.drawPixmap (r, m_pixmap_le, m_pixmap_le.rect());
+	int s = size().width() - m_pixmap_le.size().width() - m_pixmap_re.size().width();
+	r.setRect (m_pixmap_le.size().width(), 0, s, m_pixmap_mid.size().height());
+	p.drawPixmap (r, m_pixmap_mid, m_pixmap_mid.rect ());
+	r.setRect (size().width() - m_pixmap_re.size().width(), 0, m_pixmap_re.size().width(),
+			   m_pixmap_re.size().height());
+	p.drawPixmap (r, m_pixmap_re, m_pixmap_re.rect ());
+
+	/* Text */
+	p.setFont (m_font);
+	p.setPen (m_color);
+
+	p.drawText (QRect (5, 4, size().width()-25, 7),
+				Qt::AlignLeft | Qt::AlignVCenter,
+				m_text);
+
+	p.end ();
+
+}
+

src/PlaylistShade.h

@@ -0,0 +1,40 @@
+#ifndef __PLAYLISTSHADE_H__
+#define __PLAYLISTSHADE_H__
+
+#include <xmmsclient/xmmsclient++.h>
+#include "Skin.h"
+
+#include <QWidget>
+#include <QHash>
+
+class PlaylistShade : public QWidget {
+	Q_OBJECT
+
+	public:
+		PlaylistShade (QWidget *parent);
+		~PlaylistShade () {}
+
+		void paintEvent (QPaintEvent *event);
+		void mouseDoubleClickEvent (QMouseEvent *event);
+		void setActive (bool);
+
+	public slots:
+		void setPixmaps (Skin *skin);
+		void setMediainfo (const Xmms::PropDict &info);
+		void settingsSaved ();
+
+	private:
+		QPixmap m_pixmap_le;
+		QPixmap m_pixmap_re;
+		QPixmap m_pixmap_mid;
+
+		QPixmap m_pixmap_re_0;
+		QPixmap m_pixmap_re_1;
+
+		QFont m_font;
+		QColor m_color;
+		QString m_text;
+//		QFontMetrics m_fm;
+};
+
+#endif

src/PlaylistView.cpp

@@ -0,0 +1,221 @@
+// TODO might not need those
+#include <xmmsclient/xmmsclient++.h>
+#include "XMMSHandler.h"
+
+#include "PlaylistView.h"
+#include "playlistmodel.h"
+#include "Playlist.h"
+
+#include <QColor>
+#include <QMenu>
+#include <QPaintEvent>
+#include <QPalette>
+#include <QSettings>
+
+#include <QSizePolicy>
+
+/*
+ * PlaylistDelegate
+ */
+PlaylistDelegate::PlaylistDelegate (QObject *parent) :
+                  QAbstractItemDelegate (parent)
+{
+}
+
+void
+PlaylistDelegate::paint( QPainter *painter, const QStyleOptionViewItem& option,
+                         const QModelIndex &index ) const
+{
+	painter->save ();
+
+	/* Set background color */
+	if ( option.state & QStyle::State_Selected ) {
+		qDrawPlainRect (painter, option.rect, QColor("#FFFFFF"), 0,
+		                &option.palette.brush (QPalette::Highlight));
+	}
+
+	/* Set forground color */
+	if ( index.data (PlaylistModel::CurrentEntryRole).toBool () ) {
+		painter->setPen (option.palette.brush (QPalette::BrightText).color ());
+	} else {
+		painter->setPen (option.palette.brush (QPalette::Text).color ());
+	}
+
+	/* generate string */
+	//TODO Add album and playtime
+	QVariant tmp;
+	QString s = QString ("%1. ").arg (index.row () + 1);
+	tmp = index.data ();
+	if (tmp.isValid ())
+		s.append (tmp.toString ()).append (" - ");
+	QModelIndex m = index.sibling (index.row (), 1);
+	tmp = m.data ();
+	if (tmp.isValid ())
+		s.append (tmp.toString ());
+	s = option.fontMetrics.elidedText(s, Qt::ElideRight, option.rect.width());
+
+	painter->drawText (option.rect, Qt::AlignVCenter, s);
+	painter->restore ();
+}
+
+QSize
+PlaylistDelegate::sizeHint ( const QStyleOptionViewItem &option,
+                             const QModelIndex &index ) const
+{
+	/* For QListModel, width must be > 0, but is otherwise  */
+	return QSize (1, option.font.pixelSize () +3);
+}
+
+
+/*
+ * PlaylistView
+ */
+//PlaylistView::PlaylistView (QWidget *parent) : QTableView (parent)
+PlaylistView::PlaylistView (QWidget *parent) : QListView (parent)
+{
+	QSettings s;
+	Skin *skin = Skin::getInstance ();
+
+	if (!s.contains ("playlist/fontsize"))
+		s.setValue ("playlist/fontsize", 10);
+
+	setAttribute (Qt::WA_NoBackground);
+	// TODO make drag and drop work
+	//setDragEnabled(true);
+	//setAcceptDrops(true);
+	//setDropIndicatorShown (true);
+	// end DragandDrop
+	setFrameStyle(QFrame::NoFrame);
+	setFocusPolicy (Qt::StrongFocus);
+	setSelectionMode (QAbstractItemView::ExtendedSelection);
+	setUniformItemSizes(true);
+	setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
+	setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
+
+	// TODO make sure delegate gets deleted
+	setItemDelegate (new PlaylistDelegate (this));
+
+	connect (skin, SIGNAL (skinChanged (Skin *)),
+	         this, SLOT (setPixmaps(Skin *)));
+
+	m_font = NULL;
+	m_fontmetrics = NULL;
+
+	XMMSHandler &xmmsh = XMMSHandler::getInstance ();
+
+	connect (&xmmsh, SIGNAL(settingsSaved()),
+	         this, SLOT(settingsSaved()));
+
+	connect (&xmmsh, SIGNAL(playbackStatusChanged(Xmms::Playback::Status)),
+	         this, SLOT(handleStatus(Xmms::Playback::Status)));
+}
+
+void
+PlaylistView::setModel (QAbstractItemModel *model) {
+	QListView::setModel (model);
+	setModelColumn(0);
+	updateGeometry();
+}
+
+void
+PlaylistView::contextMenuEvent (QContextMenuEvent *e)
+{
+	QMenu qm(this);
+
+	QAction *a;
+
+	a = new QAction (tr ("Show file info"), this);
+	a->setShortcut (tr ("Ctrl+Enter"));
+	// connect (a, SIGNAL (triggered ()), this, SLOT (showMlib ()));
+	qm.addAction (a);
+	qm.addSeparator ();
+
+	a = new QAction (tr ("Add file"), this);
+	a->setShortcut (tr ("Ctrl+F"));
+	qm.addAction (a);
+
+	a = new QAction (tr ("Remove selected"), this);
+	qm.addAction (a);
+
+	qm.addSeparator ();
+
+	a = new QAction (tr ("Medialib browser"), this);
+	qm.addAction (a);
+
+	e->accept ();
+	qm.exec (e->globalPos ());
+}
+
+void
+PlaylistView::handleStatus (const Xmms::Playback::Status st)
+{
+	m_status = st;
+}
+
+void
+PlaylistView::settingsSaved ()
+{
+	QSettings s;
+	m_font->setPixelSize (s.value ("playlist/fontsize").toInt ());
+
+	if (m_fontmetrics) {
+		delete m_fontmetrics;
+	}
+	m_fontmetrics = new QFontMetrics (*m_font);
+	update ();
+}
+
+void
+PlaylistView::setPixmaps (Skin *skin)
+{
+	QSettings s;
+	QPalette pal;
+	QColor c;
+	c.setNamedColor (skin->getPLeditValue ("normalbg"));
+	QBrush b (c);
+	pal.setBrush (QPalette::Window, b);
+	setPalette (pal);
+
+	if (m_font) {
+		delete m_font;
+	}
+	m_font = new QFont (skin->getPLeditValue ("font"));
+	m_font->setPixelSize (s.value ("playlist/fontsize").toInt ());
+
+	if (m_fontmetrics) {
+		delete m_fontmetrics;
+	}
+	m_fontmetrics = new QFontMetrics (*m_font);
+
+	m_color_active.setNamedColor (skin->getPLeditValue ("current"));
+	m_color_selected.setNamedColor (skin->getPLeditValue ("selectedbg"));
+	m_color_normal.setNamedColor (skin->getPLeditValue ("normal"));
+	m_color_normal_bg.setNamedColor (skin->getPLeditValue ("normalbg"));
+
+	// remove later, in here for testing
+	setFont(*m_font);
+	pal.setColor (QPalette::Text, m_color_normal);
+	pal.setColor (QPalette::BrightText, m_color_active);
+	pal.setColor (QPalette::Base, m_color_normal_bg);
+	pal.setColor (QPalette::Highlight, m_color_selected);
+	setPalette (pal);
+
+	update ();
+}
+
+void
+PlaylistView::mouseDoubleClickEvent (QMouseEvent *event)
+{
+	QModelIndex index = indexAt(event->pos());
+	if (!index.isValid()) {
+		return;
+	}
+
+	XMMSHandler &xmmsh = XMMSHandler::getInstance ();
+	xmmsh.requestTrackChange (index.row());
+	// TODO check for status first. 
+	if (m_status == XMMS_PLAYBACK_STATUS_STOP ||
+	    m_status == XMMS_PLAYBACK_STATUS_PAUSE) {
+			xmmsh.play ();
+	}
+}

src/PlaylistView.h

@@ -0,0 +1,57 @@
+#ifndef __PLAYLISTVIEW_H__
+#define __PLAYLISTVIEW_H__
+
+//include "Playlist.h"
+#include <xmmsclient/xmmsclient++.h>
+#include "Skin.h"
+#include <QObject>
+#include <QAbstractItemDelegate>
+#include <QListView>
+#include <QWidget>
+
+class PlaylistDelegate : public QAbstractItemDelegate {
+	Q_OBJECT
+
+	public:
+		PlaylistDelegate (QObject *parent = NULL);
+		~PlaylistDelegate () { }
+
+		void paint( QPainter * painter, const QStyleOptionViewItem & option,
+		            const QModelIndex & index ) const;
+
+		QSize sizeHint ( const QStyleOptionViewItem &option,
+		                 const QModelIndex &index ) const;
+};
+
+
+class PlaylistView : public QListView {
+	Q_OBJECT
+
+	public:
+		PlaylistView (QWidget *parent);
+		~PlaylistView () {}
+
+		void setModel (QAbstractItemModel *model);
+
+	public slots:
+		void contextMenuEvent (QContextMenuEvent *e);
+
+		void handleStatus (const Xmms::Playback::Status st);
+		void settingsSaved (void);
+		void setPixmaps (Skin *skin);
+
+	protected:
+		void mouseDoubleClickEvent (QMouseEvent *event);
+
+	private:
+		Xmms::Playback::Status m_status;
+		QFont *m_font;
+		QFontMetrics *m_fontmetrics;
+		QColor m_color_active;
+		QColor m_color_selected;
+		QColor m_color_normal;
+		QColor m_color_normal_bg;
+};
+
+
+#endif

src/PosBar.cpp

@@ -0,0 +1,166 @@
+#include "MainWindow.h"
+
+#include "PosBar.h"
+#include "Skin.h"
+
+#include <QWidget>
+#include <QMouseEvent>
+
+PosButton::PosButton (QWidget *parent, uint normal, uint pressed) : Button (parent, normal, pressed)
+{
+	m_slider = dynamic_cast<PosBar *>(parent);
+	setMinimumSize (29, 10);
+	setMaximumSize (29, 10);
+	m_moving = false;
+}
+
+void
+PosButton::setPos (uint pos)
+{
+	m_pos = pos;
+	if (!m_moving) {
+		move (pos, 0);
+	}
+}
+
+uint
+PosButton::getPos (void)
+{
+	return m_pos;
+}
+
+void
+PosButton::mousePressEvent (QMouseEvent *event)
+{
+	QPoint p (event->pos ());
+
+	m_diffx = p.x();
+	m_moving = true;
+}
+
+void
+PosButton::mouseReleaseEvent (QMouseEvent *event)
+{
+	m_moving = false;
+
+	float value = pos().x() / (float)(m_slider->width() - width());
+
+	m_slider->requestPos (value);
+}
+
+void
+PosButton::mouseMoveEvent (QMouseEvent *event)
+{
+	QPoint p (event->pos ());
+
+	/** @todo this could be cleaned up */
+	if (m_slider->getVertical ()) {
+		int npos = pos().x() + p.x() - m_diffx;
+		if (npos >= 0 && (npos + rect().width()) <= m_slider->rect().width()) {
+			move (npos, 0);
+		} else if (npos < 0) {
+			move (0, 0);
+		} else if (npos + rect().width() > m_slider->rect().width()) {
+			move (m_slider->rect().width() - rect().width(), 0);
+		}
+	} else {
+		int npos = pos().y() + p.y() - m_diffy;
+		if (npos >= 0 && (npos + rect().height()) <= m_slider->rect().height()) {
+			move (npos, 0);
+		} else if (npos < 0) {
+			move (0, 0);
+		} else if (npos + rect().height() > m_slider->rect().height()) {
+			move (m_slider->rect().height() - rect().height(), 0);
+		}
+	}
+
+}
+
+
+PosBar::PosBar (QWidget *parent, uint bg, uint bnormal, uint bpressed, bool vertical) : PixWidget (parent)
+{
+	m_bg = bg;
+	m_vertical = vertical;
+
+	setMinimumSize (248, 10);
+	setMaximumSize (248, 10);
+
+	m_max = 0;
+
+	m_button = new PosButton (this, bnormal, bpressed);
+	m_button->move (0, 0);
+
+	if (m_vertical) {
+		m_pix = size().width()-m_button->size().width();
+	} else {
+		m_pix = size().height()-m_button->size().height();
+	}
+	
+	hideBar (true);
+
+}
+
+void
+PosBar::setSize (uint x, uint y)
+{
+	setMinimumSize (x, y);
+	setMaximumSize (x, y);
+
+	if (m_vertical) {
+		m_pix = size().width()-m_button->size().width();
+	} else {
+		m_pix = size().height()-m_button->size().height();
+	}
+
+}
+
+uint
+PosBar::getPos (void)
+{
+
+	if (m_vertical) {
+		return (uint)((float)m_button->pos().x()) / (float)(m_pix) * float(m_max);
+	} else {
+		return (uint)((float)m_button->pos().y())/((float)(m_pix*m_max));
+	}
+}
+
+void
+PosBar::hideBar (bool b)
+{
+	
+	if (b) { 
+		m_button->hide (); 
+	} else { 
+		m_button->show (); 
+	} 
+	update(); 
+
+}
+
+void
+PosBar::setPos (uint p)
+{
+	if (!m_max) {
+		return;
+	}
+
+	uint x = m_pix * p / m_max;
+	if (x < m_pix - m_button->rect().width() && x != m_button->getPos()) {
+		m_button->setPos (x);
+		update ();
+	}
+}
+
+void
+PosBar::requestPos (float value)
+{
+	XMMSHandler::getInstance ().setPlaytime (m_max * value);
+}
+
+void
+PosBar::setPixmaps (Skin *skin)
+{
+	m_pixmap = skin->getItem (m_bg);
+}
+

src/PosBar.h

@@ -0,0 +1,57 @@
+#ifndef __SLIDER_H__
+#define __SLIDER_H__
+
+#include "PixWidget.h"
+#include "Button.h"
+
+class PosBar;
+
+class PosButton : public Button
+{
+	public:
+		PosButton (QWidget *, uint, uint);
+
+		void mouseMoveEvent (QMouseEvent *);
+		void mousePressEvent (QMouseEvent *);
+		void mouseReleaseEvent (QMouseEvent *);
+
+		void setPos (uint pos);
+		uint getPos (void);
+
+	private:
+		PosBar *m_slider;
+		bool m_moving;
+		uint m_pos;
+};
+
+class PosBar : public PixWidget
+{
+	Q_OBJECT
+
+	public:
+		PosBar (QWidget *parent, uint bg, uint bnormal, uint bpressed, bool vertical=true);
+		~PosBar () { }
+
+		void setSize (uint, uint);
+		uint getPos (void);
+		void setPos (uint);
+		void requestPos (float value);
+		
+		void setMax (uint max) { m_max = max; }
+		uint getMax () { return m_max; }
+		void hideBar (bool b); 		
+		bool getVertical () { return m_vertical; }
+
+	public slots:
+		void setPixmaps (Skin *skin);
+
+	private:
+		bool m_vertical;
+		int m_bg;
+		uint m_max;
+		uint m_pix;
+		PosButton *m_button;
+
+};
+
+#endif

src/ServerBrowser.cpp

@@ -0,0 +1,190 @@
+#include "ServerBrowser.h"
+
+#include <QPushButton>
+
+ServerBrowserWindow::ServerBrowserWindow (QWidget *parent) : QMainWindow (parent)
+{
+#ifndef _WIN32
+	setWindowIcon (QIcon (":icon.png"));
+#endif
+	setWindowFlags (Qt::Dialog);
+	setWindowModality (Qt::ApplicationModal);
+	setAttribute (Qt::WA_DeleteOnClose);
+
+	QWidget *c = new QWidget (this);
+	setCentralWidget (c);
+
+	QVBoxLayout *vbox = new QVBoxLayout (c);
+	QLabel *label = new QLabel ("Available XMMS2 servers...", c);
+	label->setFont (QFont ("Helvetica", 16));
+	vbox->addWidget (label);
+
+	m_list = new ServerBrowserList (c);
+	vbox->addWidget (m_list);
+
+	c = new QWidget (c);
+	QHBoxLayout *hbox = new QHBoxLayout (c);
+	vbox->addWidget (c);
+
+	QPushButton *connect = new QPushButton ("Connect", c);
+	hbox->addWidget (new QWidget (), 1);
+	hbox->addWidget (connect);
+
+	resize (300, 400);
+}
+
+ServerBrowserList::ServerBrowserList (QWidget *parent) : QListWidget (parent)
+{
+	setIconSize (QSize (32, 32));
+	setupAvahi ();
+
+
+	connect (this, SIGNAL (itemDoubleClicked (QListWidgetItem *)),
+			 SLOT (connectServer (QListWidgetItem *)));
+}
+
+void
+ServerBrowserList::connectServer (QListWidgetItem *it)
+{
+	ServerBrowserWindow *sw = dynamic_cast<ServerBrowserWindow*> (window ());
+
+	XMMSHandler *xmmsh = XMMSHandler::getInstance ();
+	ServerItem *item = dynamic_cast<ServerItem*> (it);
+	if (xmmsh->connect (item->path ().toAscii())) {
+		sw->close ();
+	}
+}
+
+void
+ServerBrowserList::addServer (const QString &name, const QString &path)
+{
+	new ServerItem (QIcon (":icon.png"), name, path, this);
+	update ();
+}
+
+static void
+resolve_callback (AvahiServiceResolver *r,
+				  AvahiIfIndex interface,
+				  AvahiProtocol protocol,
+				  AvahiResolverEvent event,
+				  const char *name,
+				  const char *type,
+				  const char *domain,
+				  const char *host_name,
+				  const AvahiAddress *address,     
+				  uint16_t port,
+				  AvahiStringList *txt,
+				  AvahiLookupResultFlags flags,
+				  void* userdata)
+{
+	ServerBrowserList *sl = static_cast<ServerBrowserList*> (userdata);
+
+	switch (event) {
+		case AVAHI_RESOLVER_FAILURE:
+			qWarning ("something broke...");
+			break;
+		case AVAHI_RESOLVER_FOUND:
+			char a[AVAHI_ADDRESS_STR_MAX];
+			avahi_address_snprint (a, sizeof (a), address);
+			QString path;
+			path.sprintf ("tcp://%s:%u", a, port);
+
+			sl->addServer (QString::fromLatin1 (name), path);
+			break;
+	}
+}
+
+static void
+browse_callback (AvahiServiceBrowser *b,
+				 AvahiIfIndex interface,
+				 AvahiProtocol protocol,
+				 AvahiBrowserEvent event,
+				 const char *name,
+				 const char *type,
+				 const char *domain,
+				 AvahiLookupResultFlags flags,
+				 void* userdata) 
+{
+	ServerBrowserList *sl = static_cast<ServerBrowserList*> (userdata);
+
+	switch (event) {
+		case AVAHI_BROWSER_FAILURE:
+
+			qWarning("(Browser) %s\n", avahi_strerror (avahi_client_errno(avahi_service_browser_get_client(b))));
+			sl->close ();
+			return;
+
+		case AVAHI_BROWSER_NEW:
+			if (!(avahi_service_resolver_new (sl->client (), interface,
+											  protocol, name,
+											  type, domain,
+											  AVAHI_PROTO_UNSPEC,
+											  (AvahiLookupFlags) 0, 
+											  resolve_callback, userdata)))
+			{
+				qWarning ("couldn't resolv service!");
+				sl->close ();
+			}
+			break;
+
+		case AVAHI_BROWSER_REMOVE:
+			break;
+		case AVAHI_BROWSER_ALL_FOR_NOW:
+			qDebug ("done!");
+			break;
+		case AVAHI_BROWSER_CACHE_EXHAUSTED:
+			break;
+	}
+}
+
+static void
+client_callback (AvahiClient *c,
+				 AvahiClientState state,
+				 void *userdata)
+{
+	ServerBrowserList *sl = static_cast<ServerBrowserList*> (userdata);
+
+	if (state == AVAHI_CLIENT_FAILURE) {
+		qWarning ("Avahi failure!!");
+		sl->close ();
+	}
+}
+
+bool
+ServerBrowserList::setupAvahi (void)
+{
+	int ret = 1;
+	int error;
+
+	m_poll = avahi_qt_poll_get ();
+	m_client = avahi_client_new (m_poll, (AvahiClientFlags)0, client_callback, this, &error);
+
+	if (!m_client) {
+		qWarning ("couldn't create avahi browser!");
+		return false;
+	}
+
+	if (!(m_sb = avahi_service_browser_new (m_client, AVAHI_IF_UNSPEC,
+											AVAHI_PROTO_UNSPEC,
+											"_xmms2._tcp", NULL, (AvahiLookupFlags)0,
+											browse_callback, this))) {
+		qWarning ("couldn't create avahi browser!");
+		return false;
+	}
+
+}
+
+ServerBrowserList::~ServerBrowserList ()
+{
+	/*
+	if (m_poll) {
+		delete m_poll;
+	}
+	if (m_client) {
+		avahi_client_free (m_client);
+	}
+	if (m_sb) {
+		avahi_service_browser_free (m_sb);
+	}
+	*/
+}

src/ServerBrowser.h

@@ -0,0 +1,57 @@
+#ifndef __SERVER_BROWSER_H__
+#define __SERVER_BROWSER_H__
+
+#include "XMMSHandler.h"
+
+#include <QWidget>
+#include <QListWidget>
+#include <QMainWindow>
+#include <QLabel>
+#include <QVBoxLayout>
+
+#include <avahi-client/client.h>
+#include <avahi-client/lookup.h>
+#include <avahi-common/malloc.h>
+#include <avahi-common/error.h>
+#include <avahi-qt4/qt-watch.h>
+
+class ServerItem : public QListWidgetItem {
+	public:
+		ServerItem (QIcon i, const QString &name, const QString &path, QListWidget *parent) :
+			QListWidgetItem (i, name, parent) {
+				m_path = path;
+				setToolTip (m_path);
+			}
+		QString path (void) const { return m_path; }
+	private:
+		QString m_path;
+};
+
+class ServerBrowserList : public QListWidget {
+	Q_OBJECT
+	public:
+		ServerBrowserList (QWidget *parent);
+		~ServerBrowserList ();
+		void addServer (const QString &, const QString &);
+		bool setupAvahi (void);
+		AvahiClient *client (void) const { return m_client; }
+
+	public slots:
+		void connectServer (QListWidgetItem *);
+
+	private:
+		const AvahiPoll *m_poll;
+		AvahiClient *m_client;
+		AvahiServiceBrowser *m_sb;
+};
+
+class ServerBrowserWindow : public QMainWindow {
+	Q_OBJECT
+	public:
+		ServerBrowserWindow (QWidget *parent);
+		~ServerBrowserWindow () {}
+	private:
+		ServerBrowserList *m_list;
+};
+
+#endif

src/SettingsWindow.cpp

@@ -0,0 +1,481 @@
+#include "MainWindow.h"
+#include "SettingsWindow.h"
+
+#include <QCheckBox>
+#include <QSettings>
+
+SettingsWindow::SettingsWindow (QWidget *parent) : QMainWindow (parent)
+{
+#ifndef _WIN32
+	setWindowIcon (QIcon (":icon.png"));
+#endif
+	setWindowTitle ("Promoe - Settings window");
+	setWindowFlags (Qt::Dialog);
+	setWindowModality (Qt::ApplicationModal);
+	setAttribute (Qt::WA_DeleteOnClose);
+
+	resize (400, 500);
+
+	QWidget *dummy = new QWidget (this);
+	setCentralWidget (dummy);
+
+	QVBoxLayout *vbox = new QVBoxLayout (dummy);
+
+	QTabWidget *tab = new QTabWidget (dummy);
+	vbox->addWidget (tab);
+
+	QWidget *dummy2 = new QWidget (dummy);
+	QHBoxLayout *hbox = new QHBoxLayout (dummy2);
+	vbox->addWidget (dummy2);
+
+	QPushButton *cancel = new QPushButton (tr ("Cancel"));
+	cancel->setSizePolicy (QSizePolicy (QSizePolicy::Fixed, QSizePolicy::Fixed));
+	QPushButton *ok = new QPushButton (tr ("OK"));
+	ok->setSizePolicy (QSizePolicy (QSizePolicy::Fixed, QSizePolicy::Fixed));
+	connect (ok, SIGNAL (clicked ()), this, SLOT (okButton ()));
+	connect (cancel, SIGNAL (clicked ()), this, SLOT (close ()));
+
+	hbox->addWidget (new QWidget (dummy2), 1);
+	hbox->addWidget (cancel);
+	hbox->addWidget (ok);
+
+	m_mainwindow = new SettingsTabMain (NULL);
+	m_playlistwin = new SettingsTabPlaylist (NULL);
+	/*
+	m_medialib = new SettingsTabMedialib (NULL);
+	*/
+
+	tab->addTab (m_mainwindow, tr ("Main Window"));
+	tab->addTab (m_playlistwin, tr ("Playlist Window"));
+	/*
+	tab->addTab (m_medialib, tr ("Medialib"));
+	*/
+}
+
+void
+SettingsWindow::okButton (void)
+{
+	m_mainwindow->saveSettings ();
+	m_playlistwin->saveSettings ();
+
+	close ();
+}
+
+/*
+SettingsTabMedialib::SettingsTabMedialib (QWidget *parent) : QWidget (parent)
+{
+	QSettings s;
+
+	if (!s.contains ("medialib_artist/size")) {
+		s.setValue ("medialib_artist/size", tr ("Large"));
+	}
+
+	if (!s.contains ("medialib_album/size")) {
+		s.setValue ("medialib_album/size", tr ("Large"));
+	}
+
+	if (!s.contains ("medialib_song/size")) {
+		s.setValue ("medialib_song/size", tr ("Large"));
+	}
+
+	s.beginGroup("medialib");
+	QWidget *dummy = new QWidget (this);
+
+	QVBoxLayout *vbox = new QVBoxLayout (dummy);
+	QWidget *c = new QWidget (dummy);
+	QHBoxLayout *h = new QHBoxLayout (c);
+
+	vbox->addWidget (c, 1);
+
+	m_selected = new QComboBox (c);
+	m_selected->addItem (tr ("Artists"));
+	m_selected->addItem (tr ("Albums"));
+	m_selected->addItem (tr ("Songs"));
+	m_selected->setEditable (false);
+
+	QString curr = s.value ("selected").toString ();
+	for (int i = 0; i < m_selected->count(); i++) {
+		if (m_selected->itemText (i) == curr) {
+			m_selected->setCurrentIndex (i);
+			break;
+		}
+	}
+
+	h->addWidget (m_selected);
+
+	QLabel *l = new QLabel (tr ("Selected tab on startup"), c);
+	h->addWidget (l, 1);
+
+	s.endGroup ();
+
+	c = new QWidget (dummy);
+	h = new QHBoxLayout (c);
+
+	vbox->addWidget (c, 1);
+
+	s.beginGroup ("medialib_artist");
+
+	l = new QLabel (tr ("Artist view"), c);
+	
+	QFrame *f = new QFrame (c);
+	f->setFrameStyle (QFrame::HLine | QFrame::Raised);
+	h->addWidget (l);
+	h->addWidget (f, 1);
+
+	c = new QWidget (dummy);
+	h = new QHBoxLayout (c);
+
+	vbox->addWidget (c, 1);
+
+	m_artistsize = new QComboBox (c);
+	m_artistsize->addItem (tr ("None"));
+	m_artistsize->addItem (tr ("Small"));
+	m_artistsize->addItem (tr ("Large"));
+	m_artistsize->setEditable (false);
+
+	curr = s.value ("size").toString ();
+	for (int i = 0; i < m_artistsize->count(); i++) {
+		if (m_artistsize->itemText (i) == curr) {
+			m_artistsize->setCurrentIndex (i);
+			break;
+		}
+	}
+
+	h->addWidget (m_artistsize);
+	l = new QLabel (tr ("Size of media art icon"), c);
+	h->addWidget (l, 1);
+
+	s.endGroup ();
+
+	c = new QWidget (dummy);
+	h = new QHBoxLayout (c);
+	vbox->addWidget (c, 1);
+
+	s.beginGroup ("medialib_album");
+
+	l = new QLabel (tr ("Album view"), c);
+	
+	f = new QFrame (c);
+	f->setFrameStyle (QFrame::HLine | QFrame::Raised);
+	h->addWidget (l);
+	h->addWidget (f, 1);
+
+	c = new QWidget (dummy);
+	h = new QHBoxLayout (c);
+	
+	vbox->addWidget (c, 1);
+
+	m_albumsize = new QComboBox (c);
+	m_albumsize->addItem (tr ("None"));
+	m_albumsize->addItem (tr ("Small"));
+	m_albumsize->addItem (tr ("Large"));
+	m_albumsize->setEditable (false);
+
+	curr = s.value ("size").toString ();
+	for (int i = 0; i < m_artistsize->count(); i++) {
+		if (m_albumsize->itemText (i) == curr) {
+			m_albumsize->setCurrentIndex (i);
+			break;
+		}
+	}
+
+	h->addWidget (m_albumsize);
+	l = new QLabel (tr ("Size of media art icon"), c);
+	h->addWidget (l, 1);
+
+	s.endGroup ();
+
+	c = new QWidget (dummy);
+	h = new QHBoxLayout (c);
+	vbox->addWidget (c, 1);
+
+	s.beginGroup ("medialib_song");
+
+	l = new QLabel (tr ("Song view"), c);
+	
+	f = new QFrame (c);
+	f->setFrameStyle (QFrame::HLine | QFrame::Raised);
+	h->addWidget (l);
+	h->addWidget (f, 1);
+
+	c = new QWidget (dummy);
+	h = new QHBoxLayout (c);
+	
+	vbox->addWidget (c, 1);
+
+	m_songsize = new QComboBox (c);
+	m_songsize->addItem (tr ("None"));
+	m_songsize->addItem (tr ("Small"));
+	m_songsize->addItem (tr ("Large"));
+	m_songsize->setEditable (false);
+
+	curr = s.value ("size").toString ();
+	for (int i = 0; i < m_artistsize->count(); i++) {
+		if (m_songsize->itemText (i) == curr) {
+			m_songsize->setCurrentIndex (i);
+			break;
+		}
+	}
+
+	h->addWidget (m_songsize);
+	l = new QLabel (tr ("Size of media art icon"), c);
+	h->addWidget (l, 1);
+
+	s.endGroup ();
+
+}
+
+void
+SettingsTabMedialib::saveSettings ()
+{
+	QSettings s;
+	s.setValue ("medialib/selected", m_selected->currentText ());
+	s.setValue ("medialib_artist/size", m_artistsize->currentText ());
+	s.setValue ("medialib_album/size", m_albumsize->currentText ());
+	s.setValue ("medialib_song/size", m_songsize->currentText ());
+}
+*/
+
+SettingsTabPlaylist::SettingsTabPlaylist (QWidget *parent) : QWidget (parent)
+{
+	QSettings s;
+
+	s.beginGroup("playlist");
+	QWidget *dummy = new QWidget (this);
+
+	QVBoxLayout *vbox = new QVBoxLayout (dummy);
+	QWidget *c = new QWidget (dummy);
+	QHBoxLayout *h = new QHBoxLayout (c);
+
+	vbox->addWidget (c, 1);
+
+	m_fontsize = new QSpinBox (c);
+	m_fontsize->setSizePolicy (QSizePolicy (QSizePolicy::Fixed, QSizePolicy::Fixed));
+	m_fontsize->setMinimum (6);
+	m_fontsize->setMaximum (20);
+	m_fontsize->setValue (s.value("fontsize").toInt ());
+	h->addWidget (m_fontsize);
+
+	QLabel *l = new QLabel (tr ("Playlist fontsize"), c);
+	h->addWidget (l, 1);
+
+	c = new QWidget (dummy);
+	h = new QHBoxLayout (c);
+
+	vbox->addWidget (c, 1);
+
+	m_shadesize = new QSpinBox (c);
+	m_shadesize->setSizePolicy (QSizePolicy (QSizePolicy::Fixed, QSizePolicy::Fixed));
+	m_shadesize->setMinimum (6);
+	m_shadesize->setMaximum (20);
+	m_shadesize->setValue (s.value("shadedsize").toInt ());
+	h->addWidget (m_shadesize);
+
+	l = new QLabel (tr ("Playlist shaded mode fontsize"), c);
+	h->addWidget (l, 1);
+
+	QFrame *f = new QFrame (dummy);
+	f->setFrameStyle (QFrame::HLine | QFrame::Raised);
+	vbox->addWidget (f);
+
+	c = new QWidget (dummy);
+	h = new QHBoxLayout (c);
+	
+	vbox->addWidget (c, 1);
+
+	m_remote_fs = new QCheckBox (c);
+	if (!s.contains ("useremote"))
+		s.setValue ("useremote", false);
+	m_remote_fs->setCheckState (s.value ("useremote").toBool () ? Qt::Checked : Qt::Unchecked);
+	h->addWidget (m_remote_fs);
+
+	l = new QLabel (tr ("Use remote filebrowsing"), c);
+	h->addWidget (l, 1);
+
+	s.endGroup ();
+}
+
+void
+SettingsTabPlaylist::saveSettings (void)
+{
+	QSettings s;
+	s.setValue ("playlist/fontsize", m_fontsize->value ());
+	s.setValue ("playlist/shadedsize", m_shadesize->value ());
+	s.setValue ("playlist/useremote", m_remote_fs->checkState () == Qt::Checked);
+}
+
+SettingsTabMain::SettingsTabMain (QWidget *parent) : QWidget (parent)
+{
+	QSettings s;
+
+	QWidget *dummy = new QWidget (this);
+
+	QVBoxLayout *vbox = new QVBoxLayout (dummy);
+	QWidget *c = new QWidget (dummy);
+	QHBoxLayout *h = new QHBoxLayout (c);
+
+	vbox->addWidget (c, 1);
+
+	m_quitonclose = new QCheckBox (tr ("Quit XMMS2D when closing Promoe"), c);
+	if (s.contains ("promoe/quitonclose"))
+		s.setValue ("promoe/quitonclose", false);
+	m_quitonclose->setCheckState (s.value ("promoe/quitonclose").toBool () ? Qt::Checked : Qt::Unchecked);
+	h->addWidget (m_quitonclose);
+
+	c = new QWidget (dummy);
+	h = new QHBoxLayout (c);
+
+	vbox->addWidget (c, 1);
+
+	QLabel *l = new QLabel (tr ("Unshaded view"), c);
+	
+	QFrame *f = new QFrame (c);
+	f->setFrameStyle (QFrame::HLine | QFrame::Raised);
+	h->addWidget (l);
+	h->addWidget (f, 1);
+
+	c = new QWidget (dummy);
+	h = new QHBoxLayout (c);
+
+	vbox->addWidget (c, 1);
+
+	s.beginGroup ("display_main");
+	m_mainscroll = new QCheckBox (tr ("Scroll titlebar"), c);
+
+	if (s.value("scroll").toBool ()) 
+		m_mainscroll->setCheckState (Qt::Checked);
+	else
+		m_mainscroll->setCheckState (Qt::Unchecked);
+
+	h->addWidget (m_mainscroll);
+
+	m_mainsize = new QSpinBox (c);
+	m_mainsize->setSizePolicy (QSizePolicy (QSizePolicy::Fixed, QSizePolicy::Fixed));
+	m_mainsize->setMinimum (6);
+	m_mainsize->setMaximum (20);
+	m_mainsize->setValue (s.value("fontsize").toInt ());
+	h->addWidget (m_mainsize);
+
+	l = new QLabel (tr ("Titlebar fontsize"), c);
+	l->setSizePolicy (QSizePolicy (QSizePolicy::Fixed, QSizePolicy::Fixed));
+	h->addWidget (l);
+
+	c = new QWidget (dummy);
+	h = new QHBoxLayout (c);
+
+	vbox->addWidget (c, 1);
+
+	m_mainttf = new QCheckBox (tr ("Draw text with TrueType fonts"), c);
+	m_mainttf->setCheckState (s.value ("ttf").toBool () ? Qt::Checked : Qt::Unchecked);
+	h->addWidget (m_mainttf);
+
+	
+	s.endGroup ();
+
+
+	c = new QWidget (dummy);
+	h = new QHBoxLayout (c);
+
+	vbox->addWidget (c, 1);
+
+	l = new QLabel (tr ("Shaded view"), c);
+	
+	f = new QFrame (c);
+	f->setFrameStyle (QFrame::HLine | QFrame::Raised);
+	h->addWidget (l);
+	h->addWidget (f, 1);
+
+	c = new QWidget (dummy);
+	h = new QHBoxLayout (c);
+
+	vbox->addWidget (c, 1);
+
+	s.beginGroup ("display_shaded");
+	m_shadescroll = new QCheckBox (tr ("Scroll titlebar"), c);
+
+	if (s.value("scroll").toBool ()) 
+		m_shadescroll->setCheckState (Qt::Checked);
+	else
+		m_shadescroll->setCheckState (Qt::Unchecked);
+
+	h->addWidget (m_shadescroll);
+
+	m_shadesize = new QSpinBox (c);
+	m_shadesize->setSizePolicy (QSizePolicy (QSizePolicy::Fixed, QSizePolicy::Fixed));
+	m_shadesize->setMinimum (6);
+	m_shadesize->setMaximum (20);
+	m_shadesize->setValue (s.value("fontsize").toInt ());
+	h->addWidget (m_shadesize);
+
+	l = new QLabel (tr ("Titlebar fontsize"), c);
+	l->setSizePolicy (QSizePolicy (QSizePolicy::Fixed, QSizePolicy::Fixed));
+	h->addWidget (l);
+
+	c = new QWidget (dummy);
+	h = new QHBoxLayout (c);
+
+	vbox->addWidget (c, 1);
+
+	m_shadettf = new QCheckBox (tr ("Draw text with TrueType fonts"), c);
+	m_shadettf->setCheckState (s.value ("ttf").toBool () ? Qt::Checked : Qt::Unchecked);
+	h->addWidget (m_shadettf);
+
+	/*
+
+	QFrame *f = new QFrame (dummy);
+	f->setFrameStyle (QFrame::HLine | QFrame::Raised);
+	vbox->addWidget (f, 1);
+
+	c = new QWidget (this);
+	h = new QHBoxLayout (c);
+
+	vbox->addWidget (c);
+
+	m_mainttf = new QCheckBox (tr ("Draw main title with TrueType fonts"), this);
+	m_mainttf->setCheckState (s.value ("mainttf").toBool () ? Qt::Checked : Qt::Unchecked);
+	h->addWidget (m_mainttf);
+
+	c = new QWidget (this);
+	h = new QHBoxLayout (c);
+
+	vbox->addWidget (c);
+
+	m_shadettf = new QCheckBox (tr ("Draw shaded title with TrueType fonts"), this);
+	m_shadettf->setCheckState (s.value ("shadettf").toBool () ? Qt::Checked : Qt::Unchecked);
+	h->addWidget (m_shadettf);
+
+	f = new QFrame (this);
+	f->setFrameStyle (QFrame::HLine | QFrame::Raised);
+	vbox->addWidget (f, 1);
+
+	c = new QWidget (this);
+	h = new QHBoxLayout (c);
+	
+	vbox->addWidget (c);
+
+	
+	
+	s.endGroup ();
+	*/
+
+}
+
+void
+SettingsTabMain::saveSettings (void)
+{
+	QSettings s;
+	
+	s.setValue ("promoe/quitonclose", m_quitonclose->checkState () == Qt::Checked);
+
+	s.beginGroup ("display_main");
+	s.setValue ("scroll", m_mainscroll->checkState () == Qt::Checked);
+	s.setValue ("fontsize", m_mainsize->value ());
+	s.setValue ("ttf", m_mainttf->checkState () == Qt::Checked);
+	s.endGroup ();
+
+	s.beginGroup ("display_shaded");
+	s.setValue ("scroll", m_shadescroll->checkState () == Qt::Checked);
+	s.setValue ("fontsize", m_shadesize->value ());
+	s.setValue ("ttf", m_shadettf->checkState () == Qt::Checked);
+	s.endGroup ();
+}

src/SettingsWindow.h

@@ -0,0 +1,77 @@
+#ifndef __SETTINGSWINDOW_H__
+#define __SETTINGSWINDOW_H__
+
+#include <QMainWindow>
+#include <QTabWidget>
+#include <QPushButton>
+#include <QVBoxLayout>
+#include <QCheckBox>
+#include <QHBoxLayout>
+#include <QSpinBox>
+#include <QLabel>
+#include <QComboBox>
+
+class SettingsTabMedialib : public QWidget {
+	Q_OBJECT
+	public:
+		SettingsTabMedialib (QWidget *parent);
+		~SettingsTabMedialib () {}
+		void saveSettings (void);
+
+	private:
+		QComboBox *m_selected;
+		QComboBox *m_artistsize;
+		QComboBox *m_albumsize;
+		QComboBox *m_songsize;
+};
+
+class SettingsTabPlaylist : public QWidget {
+	Q_OBJECT
+	public:
+		SettingsTabPlaylist (QWidget *parent);
+		~SettingsTabPlaylist () {}
+		void saveSettings (void);
+
+	private:
+		QSpinBox *m_fontsize;
+		QSpinBox *m_shadesize;
+		QCheckBox *m_remote_fs;
+};
+
+class SettingsTabMain : public QWidget {
+	Q_OBJECT
+	public:
+		SettingsTabMain (QWidget *parent);
+		~SettingsTabMain () {}
+		void saveSettings (void);
+
+
+	private:
+		QCheckBox *m_quitonclose;
+
+		QSpinBox *m_mainsize;
+		QCheckBox *m_mainttf;
+		QCheckBox *m_mainscroll;
+		QSpinBox *m_shadesize;
+		QCheckBox *m_shadettf;
+		QCheckBox *m_shadescroll;
+};
+
+class SettingsWindow : public QMainWindow {
+	Q_OBJECT
+	public:
+		SettingsWindow (QWidget *parent);
+		~SettingsWindow () {}
+
+	public slots:
+		void okButton (void);
+
+	private:
+		SettingsTabMain *m_mainwindow;
+		SettingsTabPlaylist *m_playlistwin;
+		SettingsTabMedialib *m_medialib;
+
+};
+
+
+#endif

src/ShadedDisplay.cpp

@@ -0,0 +1,108 @@
+#include <xmmsclient/xmmsclient++.h>
+#include "XMMSHandler.h"
+
+#include "ShadedDisplay.h"
+#include "TitleBar.h"
+#include "Button.h"
+
+#include "SmallNumberDisplay.h"
+#include "TextBar.h"
+
+ShadedDisplay::ShadedDisplay (QWidget *parent) : SkinDisplay (parent)
+{
+	XMMSHandler &xmmsh = XMMSHandler::getInstance ();
+
+	setMinimumSize (275, 14);
+	setMaximumSize (275, 14);
+
+	m_tbar = new TitleBar(this, true);
+	m_tbar->move (0, 0);
+
+	m_number = new SmallNumberDisplay (this, 10);
+	m_number->move (135, 4);
+	m_number->setNumber (0, 2);
+
+	m_number2 = new SmallNumberDisplay (this, 10);
+	m_number2->move (147, 4);
+	m_number2->setNumber (0, 2);
+
+	m_title = new TextScroller (this, 39, 7, "shaded");
+	m_title->move (79, 4);
+
+	m_prev = new Button (this);
+	m_prev->move(169, 4);
+	m_prev->resize (8, 7);
+	connect (m_prev, SIGNAL(clicked()), &xmmsh, SLOT(prev()));
+	
+	m_play = new Button (this);
+	m_play->move(177, 4);
+	m_play->resize (10, 7);
+	connect (m_play, SIGNAL(clicked()), &xmmsh, SLOT(play()));
+
+	m_pause = new Button (this);
+	m_pause->move(187, 4);
+	m_pause->resize (10, 7);
+	connect (m_pause, SIGNAL(clicked()), &xmmsh, SLOT(pause()));
+
+	m_stop = new Button (this);
+	m_stop->move(197, 4);
+	m_stop->resize (9, 7);
+	connect (m_stop, SIGNAL(clicked()), &xmmsh, SLOT(stop()));
+
+	m_next = new Button (this);
+	m_next->move(206, 4);
+	m_next->resize (8, 7);
+	connect (m_next, SIGNAL(clicked()), &xmmsh, SLOT(next()));
+
+	m_eject = new Button (this);
+	m_eject->move(216, 4);
+	m_eject->resize (9, 7);
+	connect (m_eject, SIGNAL(clicked()), this, SLOT(fileOpen()));
+
+	connect (&xmmsh, SIGNAL(playbackStatusChanged(Xmms::Playback::Status)),
+	         this, SLOT(setStatus(Xmms::Playback::Status)));
+	connect (xmmsh.cache (), SIGNAL (playtime (uint32_t)),
+	         this, SLOT ( setPlaytime(uint32_t)));
+	connect (&xmmsh, SIGNAL(currentSong (const Xmms::PropDict &)), 
+			 this, SLOT(setMediainfo (const Xmms::PropDict &)));
+}
+
+void
+ShadedDisplay::setMediainfo (const Xmms::PropDict &info)
+{
+	QString n;
+	if (info.contains ("artist") && info.contains ("album") &&
+	    info.contains ("title")) {
+		n = QString::fromUtf8 (info.get<std::string> ("artist").c_str ())
+		    + " - " +
+		    QString::fromUtf8 (info.get<std::string> ("album").c_str ())
+		    + " - " +
+		    QString::fromUtf8 (info.get<std::string> ("title").c_str ());
+	} else {
+		n = QString::fromUtf8 (info.get<std::string> ("url").c_str ());
+	}
+	m_title->setText (n);
+}
+
+void
+ShadedDisplay::setStatus (Xmms::Playback::Status status)
+{
+	if (status == Xmms::Playback::STOPPED) {
+		m_number->setNumber (0, 2);
+		m_number2->setNumber (0, 2);
+	}
+}
+
+void
+ShadedDisplay::setPlaytime (uint32_t time)
+{
+	uint sec, min;
+
+	sec = (time / 1000) % 60;
+	min = (time / 1000) / 60;
+
+		m_number2->setNumber (sec, 2);
+		m_number->setNumber (min, 2);
+}
+
+

src/ShadedDisplay.h

@@ -0,0 +1,39 @@
+#ifndef __SHADEDDISPLAY_H__
+#define __SHADEDDISPLAY_H__
+
+class ShadedDisplay;
+
+#include <xmmsclient/xmmsclient++.h>
+#include "Display.h"
+
+class MainWindow;
+class Button;
+class SmallNumberDisplay;
+class TextScroller;
+
+class ShadedDisplay : public SkinDisplay
+{
+	Q_OBJECT
+	public:
+		ShadedDisplay (QWidget *parent);
+		~ShadedDisplay () { }
+
+		SmallNumberDisplay *m_number;
+		SmallNumberDisplay *m_number2;
+		TextScroller *m_title;
+
+	private:
+		Button *m_prev;
+		Button *m_play;
+		Button *m_pause;
+		Button *m_stop;
+		Button *m_next;
+		Button *m_eject;
+
+	public slots:
+		void setStatus (Xmms::Playback::Status status);
+		void setPlaytime (uint32_t time);
+		void setMediainfo (const Xmms::PropDict &info);
+};
+
+#endif

src/Skin.cpp

@@ -0,0 +1,604 @@
+#include "Skin.h"
+
+Skin *Skin::singleton = NULL;
+
+Skin *Skin::getInstance (void)
+{
+	if (!singleton) {
+		singleton = new Skin ();
+	}
+
+	return singleton;
+}
+
+void
+Skin::BuildEqualizer (void)
+{
+	QPixmap *img = getPixmap ("eqmain");
+	if (img) {
+		m_items[EQ_WIN_BG] = img->copy (0, 0, 275, 116);
+		m_items[EQ_WIN_ON_0] = img->copy (10, 119, 25, 12);
+		m_items[EQ_WIN_ON_1] = img->copy (128, 119, 25, 12);
+		m_items[EQ_WIN_OFF_1] = img->copy (187, 119, 25, 12);
+		m_items[EQ_WIN_OFF_0] = img->copy (69, 119, 25, 12);
+
+		m_items[EQ_WIN_AUTO_ON_0] = img->copy (35, 119, 33, 12);
+		m_items[EQ_WIN_AUTO_ON_1] = img->copy (153, 119, 33, 12);
+		m_items[EQ_WIN_AUTO_OFF_1] = img->copy (212, 119, 33, 12);
+		m_items[EQ_WIN_AUTO_OFF_0] = img->copy (94, 119, 33, 12);
+
+		m_items[EQ_WIN_PRESET_0] = img->copy (224, 164, 44, 12);
+		m_items[EQ_WIN_PRESET_1] = img->copy (224, 176, 44, 12);
+
+		m_items[EQ_WIN_GRAPH_BG] = img->copy (0, 294, 113, 19);
+
+		for (int i = 0; i < 14; i++) {
+			m_items[EQ_WIN_BAR_POS_0+i] = img->copy (13+15*i, 164, 14, 63);
+		}
+		for (int i = 0; i < 14; i++) {
+			m_items[EQ_WIN_BAR_POS_14+i] = img->copy (13+15*i, 229, 14, 63);
+		}
+
+		m_items[EQ_WIN_BAR_BTN_1] = img->copy (0, 164, 11, 11);
+		m_items[EQ_WIN_BAR_BTN_0] = img->copy (0, 176, 11, 11);
+
+		delete img;
+	} else {
+		setSkin(":CleanAMP/");
+	}
+}
+
+void
+Skin::BuildPlaylist (void)
+{
+	QPixmap tmp;
+
+	QPixmap *img = getPixmap ("pledit");
+
+	if(img)
+	{
+		m_playlist[PLS_CORNER_UL_0] = img->copy(0, 0, 25, 20);
+		m_playlist[PLS_CORNER_UL_1] = img->copy(0, 21, 25, 20);
+		
+		m_playlist[PLS_TBAR_0] = img->copy (26, 0, 100, 20);
+		m_playlist[PLS_TBAR_1] = img->copy (26, 21, 100, 20);
+		
+		m_playlist[PLS_CORNER_UR_0] = img->copy(153, 0, 25, 20);
+		m_playlist[PLS_CORNER_UR_1] = img->copy(153, 21, 25, 20);
+	
+		m_playlist[PLS_TFILL_0] = img->copy(127, 0, 25, 20);
+		m_playlist[PLS_TFILL_1] = img->copy(127, 21, 25, 20);
+	
+		m_playlist[PLS_BFILL_0] = img->copy(179, 0, 25, 38);
+	
+		m_playlist[PLS_VISMINI_0] = img->copy(205, 0, 75, 38);
+	
+		m_playlist[PLS_LFILL_0] = img->copy(0, 42, 12, 29);
+
+		m_playlist[PLS_RFILL_0] = img->copy(31, 42, 5, 29);
+		m_playlist[PLS_RFILL2_0] = img->copy(36, 42, 8, 29);
+		m_playlist[PLS_RFILL3_0] = img->copy(44, 42, 7, 29);
+
+		tmp = m_playlist[PLS_CORNER_UR_0];
+	
+		m_playlist[PLS_CLOSE_BTN_0] = tmp.copy(14, 3, 9, 9);
+		m_playlist[PLS_CLOSE_BTN_1] = img->copy(52, 42, 9, 9);
+	
+		m_playlist[PLS_SHADE_BTN_0] = tmp.copy(14, 3, 9, 9);
+		m_playlist[PLS_SHADE_BTN_1] = img->copy(62, 42, 9, 9);
+	
+		m_playlist[PLS_MAX_BTN_0] = img->copy(150, 42, 9, 9);
+	
+		m_playlist[PLS_SCROLL_0] = img->copy(52, 53, 8, 18);
+		m_playlist[PLS_SCROLL_1] = img->copy(61, 53, 8, 18);
+	
+		m_playlist[PLS_WS_LE_0] = img->copy(72, 42, 25, 14);
+		m_playlist[PLS_WS_RE_0] = img->copy(99, 42, 50, 14);
+		m_playlist[PLS_WS_RE_1] = img->copy(99, 57, 50, 14);
+		m_playlist[PLS_WS_MID_0] = img->copy(72, 57, 25, 14);
+	
+		m_playlist[PLS_LCBAR] = img->copy(0, 72, 125, 38);
+		m_playlist[PLS_RCBAR] = img->copy(126, 72, 150, 38);
+	
+		/* extract the buttons */
+		m_playlist[PLS_ADD] = img->copy(11, 80, 25, 18);
+		m_playlist[PLS_ADD_DEC] = img->copy(48, 111, 3, 54);
+		m_playlist[PLS_ADD_URL_0] = img->copy(0, 111, 22, 18);
+		m_playlist[PLS_ADD_URL_1] = img->copy(23, 111, 22, 18);
+		
+		m_playlist[PLS_ADD_DIR_0] = img->copy(0, 130, 22, 18);
+		m_playlist[PLS_ADD_DIR_1] = img->copy(23, 130, 22, 18);
+	
+		m_playlist[PLS_ADD_FIL_0] = img->copy(0, 149, 22, 18);
+		m_playlist[PLS_ADD_FIL_1] = img->copy(23, 149, 22, 18);
+	
+		/* Delete buttons */
+		m_playlist[PLS_DEL] = img->copy(40, 80, 25, 18);
+		m_playlist[PLS_DEL_DEC] = img->copy(100, 111, 3, 72);
+		m_playlist[PLS_DEL_ALL_0] = img->copy(54, 111, 22, 18);
+		m_playlist[PLS_DEL_ALL_1] = img->copy(77, 111, 22, 18);
+		
+		m_playlist[PLS_DEL_CRP_0] = img->copy(54, 130, 22, 18);
+		m_playlist[PLS_DEL_CRP_1] = img->copy(77, 130, 22, 18);
+		
+		m_playlist[PLS_DEL_FIL_0] = img->copy(54, 149, 22, 18);
+		m_playlist[PLS_DEL_FIL_1] = img->copy(77, 149, 22, 18);
+		
+		/* Select buttons */
+		m_playlist[PLS_SEL] = img->copy(69, 80, 25, 18);
+		m_playlist[PLS_SEL_DEC] = img->copy(150, 111, 3, 54);
+		m_playlist[PLS_SEL_INV_0] = img->copy(104, 111, 22, 18);
+		m_playlist[PLS_SEL_INV_1] = img->copy(127, 111, 22, 18);
+	
+		m_playlist[PLS_SEL_NIL_0] = img->copy(104, 130, 22, 18);
+		m_playlist[PLS_SEL_NIL_1] = img->copy(127, 130, 22, 18);
+		
+		m_playlist[PLS_SEL_ALL_0] = img->copy(104, 149, 22, 18);
+		m_playlist[PLS_SEL_ALL_1] = img->copy(127, 149, 22, 18);
+	
+		/* misc buttons */
+		m_playlist[PLS_MSC] = img->copy(98, 80, 25, 18);
+		m_playlist[PLS_MSC_DEC] = img->copy(200, 111, 3, 54);
+		m_playlist[PLS_MSC_SRT_0] = img->copy(154, 111, 22, 18);
+		m_playlist[PLS_MSC_SRT_1] = img->copy(177, 111, 22, 18);
+	
+		m_playlist[PLS_MSC_INF_0] = img->copy(154, 130, 22, 18);
+		m_playlist[PLS_MSC_INF_1] = img->copy(177, 130, 22, 18);
+		
+		m_playlist[PLS_MSC_OPT_0] = img->copy(154, 149, 22, 18);
+		m_playlist[PLS_MSC_OPT_1] = img->copy(177, 149, 22, 18);
+		
+		/* list buttons */
+		m_playlist[PLS_LST] = img->copy(229, 80, 25, 18);
+		m_playlist[PLS_LST_DEC] = img->copy(250, 111, 3, 54);
+		m_playlist[PLS_LST_NEW_0] = img->copy(204, 111, 22, 18);
+		m_playlist[PLS_LST_NEW_1] = img->copy(227, 111, 22, 18);
+	
+		m_playlist[PLS_LST_SAV_0] = img->copy(204, 130, 22, 18);
+		m_playlist[PLS_LST_SAV_1] = img->copy(227, 130, 22, 18);
+	
+		m_playlist[PLS_LST_OPN_0] = img->copy(204, 149, 22, 18);
+		m_playlist[PLS_LST_OPN_1] = img->copy(227, 149, 22, 18);
+	
+		/* misc button */
+		m_playlist[PLS_MSC_BTN_0] = img->copy(54, 168, 22, 18);
+		m_playlist[PLS_MSC_BTN_1] = img->copy(77, 168, 22, 18);
+	
+		delete img;
+	}
+	else
+		setSkin(":CleanAMP/");
+
+}
+
+void
+Skin::setSkin (const QString& name)
+{
+	m_path = name;
+
+	m_items.clear();
+	BuildButtons();
+	BuildToggleButtons();
+	BuildTitleBar();
+	BuildOther();
+	BuildEqualizer ();
+
+	m_letterMap.clear();
+	BuildLetterMap();
+
+	BuildSliders();
+
+	m_pledit_txt.clear();
+	ParsePLEdit();
+
+	m_numbers.clear();
+	BuildNumbers();
+
+	m_playlist.clear ();
+	BuildPlaylist ();
+
+	emit skinChanged(this);
+}
+
+QPixmap
+Skin::getPixmap (const QString& file, QDir dir)
+{
+	/* check for files in zip and check if file exists */
+
+	dir.setFilter (QDir::Files);
+
+	QFileInfoList list = dir.entryInfoList();
+	for (int i = 0; i < list.size(); ++i) {
+		QFileInfo fileInfo = list.at(i);
+		QString fname = fileInfo.fileName().toLower();
+		if (fname.section(".", 0, 0) == file) {
+			return QPixmap (fileInfo.filePath());
+		}
+	}
+
+	return QPixmap (0,0);
+}
+
+
+QPixmap *
+Skin::getPixmap (const QString& file)
+{
+	QDir dir;
+
+	dir.setPath (m_path);
+	dir.setFilter (QDir::Files);
+
+	QFileInfoList list = dir.entryInfoList();
+	for (int i = 0; i < list.size(); ++i) {
+		QFileInfo fileInfo = list.at(i);
+		QString fname = fileInfo.fileName().toLower();
+		if (fname.section(".", 0, 0) == file) {
+			return new QPixmap (fileInfo.filePath());
+		}
+	}
+
+	return NULL;
+}
+
+
+void
+Skin::BuildLetterMap (void)
+{
+	QPixmap *img = getPixmap("text");
+
+	if(img)
+	{
+		QList<QList<QPixmap> >(letters);
+		for (int i = 0; i < 3; i++) {
+			QList<QPixmap>(l);
+			for (int j = 0; j < 31; j++) {
+				l.append(img->copy(j*5, i*6, 4, 6));
+			}
+			letters.append(l);
+		}
+	
+		delete img;
+	
+	
+		/* alphabet */
+		for (uint i = 97; i < 123; i++) {
+			m_letterMap[i] = letters[0][i-97];
+		}
+	
+		/* digits */
+		for (uint i = 0; i <= 9; i++) {
+			m_letterMap[i+48] = letters[1][i];
+		}
+	
+		/* special characters */
+		m_letterMap['"'] = letters[0][27];
+		m_letterMap['@'] = letters[0][28];
+		m_letterMap['('] = letters[1][13];
+		m_letterMap[')'] = letters[1][14];
+		m_letterMap['-'] = letters[1][15];
+		m_letterMap['\''] = letters[1][16];
+		m_letterMap['`'] = letters[1][16];
+		m_letterMap['!'] = letters[1][17];
+		m_letterMap['_'] = letters[1][18];
+		m_letterMap['+'] = letters[1][19];
+		m_letterMap['\\'] = letters[1][20];
+		m_letterMap['/'] = letters[1][21];
+		m_letterMap['['] = letters[1][22];
+		m_letterMap[']'] = letters[1][23];
+		m_letterMap['^'] = letters[1][24];
+		m_letterMap['&'] = letters[1][25];
+		m_letterMap['%'] = letters[1][26];
+		m_letterMap['.'] = letters[1][27];
+		m_letterMap[','] = letters[1][27];
+		m_letterMap['='] = letters[1][28];
+		m_letterMap['$'] = letters[1][29];
+		m_letterMap['#'] = letters[1][30];
+	
+		m_letterMap[229] = letters[2][0];
+		m_letterMap[246] = letters[2][1];
+		m_letterMap[228] = letters[2][2];
+		m_letterMap['?'] = letters[2][3];
+		m_letterMap['*'] = letters[2][4];
+		m_letterMap[' '] = letters[2][5];
+	
+		/* text background */
+		m_items[TEXTBG] = letters[2][6];
+	}
+	else
+		setSkin(":CleanAMP/");
+}
+
+
+void
+Skin::BuildButtons (void)
+{
+	QPixmap *img = getPixmap("cbuttons");
+	if(img)
+	{
+		m_items[BTN_PREV_0] = img->copy(0,  0, 23, 18);
+		m_items[BTN_PREV_1] = img->copy(0, 18, 23, 18);
+	
+		m_items[BTN_PLAY_0] = img->copy(23,  0, 23, 18);
+		m_items[BTN_PLAY_1] = img->copy(23, 18, 23, 18);
+	
+		m_items[BTN_PAUSE_0] = img->copy(46,  0, 23, 18);
+		m_items[BTN_PAUSE_1] = img->copy(46, 18, 23, 18);
+	
+		m_items[BTN_STOP_0] = img->copy(69,  0, 23, 18);
+		m_items[BTN_STOP_1] = img->copy(69, 18, 23, 18);
+	
+		m_items[BTN_NEXT_0] = img->copy(92,  0, 22, 18);
+		m_items[BTN_NEXT_1] = img->copy(92, 18, 22, 18);
+	
+		m_items[BTN_EJECT_0] = img->copy(114, 0, 22, 16);
+		m_items[BTN_EJECT_1] = img->copy(114, 16, 22, 16);
+	
+		delete img;
+	}
+	else
+		setSkin(":CleanAMP/");
+}
+
+
+void
+Skin::BuildToggleButtons (void)
+{
+	QPixmap *img = getPixmap("shufrep");
+
+	if(img)
+	{
+		m_items[REPEAT_ON_0] = img->copy(0, 30, 28, 15);
+		m_items[REPEAT_ON_1] = img->copy(0, 45, 28, 15);
+	
+		m_items[REPEAT_OFF_0] = img->copy(0,  0, 28, 15);
+		m_items[REPEAT_OFF_1] = img->copy(0, 15, 28, 15);
+	
+		m_items[SHUFFLE_ON_0] = img->copy(28, 30, 46, 15);
+		m_items[SHUFFLE_ON_1] = img->copy(28, 45, 46, 15);
+	
+		m_items[SHUFFLE_OFF_0] = img->copy(28,  0, 46, 15);
+		m_items[SHUFFLE_OFF_1] = img->copy(28, 15, 46, 15);
+	
+		m_items[EQ_ON_0] = img->copy( 0, 73, 23, 12);
+		m_items[EQ_ON_1] = img->copy(46, 73, 23, 12);
+	
+		m_items[EQ_OFF_0] = img->copy( 0, 61, 23, 12);
+		m_items[EQ_OFF_1] = img->copy(46, 61, 23, 12);
+	
+		m_items[PLS_ON_0] = img->copy(23, 73, 23, 12);
+		m_items[PLS_ON_1] = img->copy(69, 73, 23, 12);
+	
+		m_items[PLS_OFF_0] = img->copy(23, 61, 23, 12);
+		m_items[PLS_OFF_1] = img->copy(69, 61, 23, 12);
+	
+		delete img;
+	}
+	else
+		setSkin(":CleanAMP/");
+}
+
+
+void
+Skin::BuildTitleBar (void)
+{
+	QPixmap *img = getPixmap("titlebar");
+
+	if(img)
+	{
+		m_items[MENUBUTTON_0] = img->copy(0, 0, 9, 9);
+		m_items[MENUBUTTON_1] = img->copy(0, 9, 9, 9);
+	
+		m_items[MINIMIZE_0] = img->copy(9, 0, 9, 9);
+		m_items[MINIMIZE_1] = img->copy(9, 9, 9, 9);
+	
+		m_items[CLOSE_0] = img->copy(18, 0, 9, 9);
+		m_items[CLOSE_1] = img->copy(18, 9, 9 ,9);
+	
+		m_items[SHADE_1_0] = img->copy(0, 18, 9, 9);
+		m_items[SHADE_1_1] = img->copy(9, 18, 9, 9);
+	
+		m_items[SHADE_2_0] = img->copy(0, 27, 9, 9);
+		m_items[SHADE_2_1] = img->copy(9, 27, 9, 9);
+	
+		m_items[TITLEBAR_0] = img->copy(27, 0, 275, 14);
+		m_items[TITLEBAR_1] = img->copy(27, 15, 275, 14);
+	
+		m_items[STATUSBAR_0] = img->copy(27, 29, 275, 14);
+		m_items[STATUSBAR_1] = img->copy(27, 29+13, 275, 14);
+	
+		m_items[CLUTTER_ON]  = img->copy(304+8*0, 0, 8, 43);
+		m_items[CLUTTER_OFF] = img->copy(304+8*1, 0, 8, 43);
+
+		m_items[CLUTTER_O] = img->copy(304+8*0, 44, 8, 43);
+		m_items[CLUTTER_A] = img->copy(304+8*1, 44, 8, 43);
+		m_items[CLUTTER_I] = img->copy(304+8*2, 44, 8, 43);
+		m_items[CLUTTER_D] = img->copy(304+8*3, 44, 8, 43);
+		m_items[CLUTTER_V] = img->copy(304+8*4, 44, 8, 43);
+
+		delete img;
+	}
+	else
+		setSkin(":CleanAMP/");
+}
+
+
+void
+Skin::BuildOther (void)
+{
+	QPixmap *img, *part;
+	QPainter(painter);
+	
+	img = getPixmap("monoster");
+	if(img)
+	{
+		m_items[MONO_1] = img->copy(29,  0, 27, 12);
+		m_items[MONO_0] = img->copy(29, 12, 27, 12);
+		m_items[STEREO_1] = img->copy(0,  0, 29, 12);
+		m_items[STEREO_0] = img->copy(0, 12, 29, 12);
+		delete img;
+	}
+	else
+		setSkin(":CleanAMP/");
+
+	img = getPixmap("playpaus");
+	if(img)
+	{
+		part = new QPixmap(11, 9);
+		painter.begin(part);
+		painter.drawPixmap (0, 0, 3, 9, *img, 36, 0, 3, 9);
+		painter.drawPixmap (3, 0, 8, 9, *img,  1, 0, 8, 9);
+		painter.end();
+		m_items[PIC_PLAY] = part->copy();
+		delete part;
+
+		part = new QPixmap(11, 9);
+		painter.begin(part);
+		painter.drawPixmap (0, 0, 2, 9, *img, 27, 0, 2, 9);
+		painter.drawPixmap (2, 0, 9, 9, *img,  9, 0, 9, 9);
+		painter.end();
+		m_items[PIC_PAUSE] = part->copy();
+		delete part;
+	
+		part = new QPixmap(11, 9);
+		painter.begin(part);
+		painter.drawPixmap (0, 0, 2, 9, *img, 27, 0, 2, 9);
+		painter.drawPixmap (2, 0, 9, 9, *img, 18, 0, 9, 9);
+		painter.end();
+		m_items[PIC_STOP] = part->copy();
+		delete part;
+	
+		delete img;
+ 	}
+	else
+		setSkin(":CleanAMP/");
+
+	img = getPixmap ("main");
+	if(img)
+	{
+		m_items[MAIN_WINDOW] = img->copy();
+		m_items[ABOUT_0] = img->copy(247, 83, 20, 25);
+		m_items[ABOUT_1] = img->copy(247, 83, 20, 24);
+		delete img;
+	}
+	else
+		setSkin(":CleanAMP/");
+}
+
+
+void
+Skin::BuildSliders (void)
+{
+	QPixmap *img;
+
+	img = getPixmap("posbar");
+	if (img) {
+		m_items[POSBAR] = img->copy (0, 0, 248, 10);
+		m_items[POSBAR_BTN_0] = img->copy (248, 0, 29, 10);
+		m_items[POSBAR_BTN_1] = img->copy (278, 0, 29, 10);
+
+		delete img;
+	} else {
+		setSkin(":CleanAMP/");
+	}
+
+	img = getPixmap("volume");
+	if (img) {
+		for (int i = 0; i <= 27; i++) {
+			m_items[VOLUMEBAR_POS_0+i] = img->copy(0, i*15, 68, 13);
+		}
+
+		if (img->height() > 420) {
+			m_items[VOLBAR_BTN_1] = img->copy (0, 422, 14, 11);
+			m_items[VOLBAR_BTN_0] = img->copy (15, 422, 14, 11);
+		}
+	
+		delete img;
+	} else {
+		setSkin(":CleanAMP/");
+	}
+
+	img = getPixmap("balance");
+	if (!img) {
+		img = getPixmap("volume");
+	}
+
+	if (img) {
+		for (int i = 0; i < 28; i++) {
+			m_items[BALANCE_POS_0+i] = img->copy(9, i*15, 38, 13);
+		}
+
+		if (img->height() > 421) {
+			m_items[BALANCE_BTN_0] = img->copy(0, 422, 14, 11);
+			m_items[BALANCE_BTN_1] = img->copy(15, 422, 14, 11);
+		}
+
+		delete img;
+	} else {
+		setSkin(":CleanAMP/");
+	}
+}
+
+
+void
+Skin::BuildNumbers (void)
+{
+	uint num = 11;
+
+	QPixmap *img = getPixmap("numbers");
+	if (!img) {
+		num = 12;
+		img = getPixmap ("nums_ex");
+	}
+
+	if(img)
+	{
+		for (uint i = 0; i < num; i++) {
+			m_numbers[i] = img->copy (i*9, 0, 9, 13);
+		}
+		delete img;
+	}
+	else
+		setSkin(":CleanAMP/");
+
+}
+
+
+void
+Skin::ParsePLEdit (void)
+{
+	QDir dir;
+	QString path;
+
+	dir.setPath (m_path);
+	dir.setFilter (QDir::Files);
+
+	QFileInfoList list = dir.entryInfoList();
+	for (int i = 0; i < list.size(); ++i) {
+		QFileInfo fileInfo = list.at(i);
+		if (fileInfo.fileName().toLower() == "pledit.txt") {
+			path += fileInfo.filePath ();
+			break;
+		}
+	}
+
+	if (path.isNull ()) {
+		qDebug ("trasigt!");
+		return;
+	}
+
+	QFile file (path);
+
+	if (!file.open(QIODevice::ReadOnly | QIODevice::Text))
+		return;
+
+	while (!file.atEnd ()) {
+		QByteArray line = file.readLine ();
+		QList<QByteArray> l = line.split ('=');
+		if (l.count () == 2) {
+			m_pledit_txt[l[0].toLower ()] = l[1].trimmed();
+		} else if (line.length() == 0) {
+			break;
+		}
+	}
+
+}

src/Skin.h

@@ -0,0 +1,330 @@
+#ifndef __SKIN_H__
+#define __SKIN_H__
+
+#include <iostream>
+
+#include <QPixmap>
+#include <QPainter>
+#include <QWidget>
+#include <QMap>
+#include <QDir>
+
+class Skin : public QWidget
+{
+	Q_OBJECT
+	public:
+		static Skin *getInstance (void);
+
+		void setSkin (const QString& name);
+		static QPixmap getPixmap (const QString&, QDir);
+		
+		const QPixmap getItem (uint part) const { return m_items[part]; }
+		const QPixmap getPls (uint part) const { return m_playlist[part]; }
+		const QPixmap getLetter (uint c) const { return m_letterMap[c]; }
+		const QPixmap getNumber (uint c) const { return m_numbers[c]; }
+		uint getNumberSize () { return m_numbers.size(); }
+		const QByteArray getPLeditValue (QByteArray c) const { return m_pledit_txt[c]; }
+
+		enum Part {
+			NONE,
+			MAIN_WINDOW,
+			ABOUT_0,
+			ABOUT_1,
+			MONO_0,
+			MONO_1,
+			STEREO_0,
+			STEREO_1,
+			MENUBUTTON_0,
+			MENUBUTTON_1,
+			MINIMIZE_0,
+			MINIMIZE_1,
+			CLOSE_0,
+			CLOSE_1,
+			SHADE_1_0,
+			SHADE_1_1,
+			SHADE_2_0,
+			SHADE_2_1,
+			TITLEBAR_0,
+			TITLEBAR_1,
+			STATUSBAR_0,
+			STATUSBAR_1,
+			SEEKBAR,
+			SEEKBAR_POS_0,
+			SEEKBAR_POS_1,
+			REPEAT_ON_0,
+			REPEAT_ON_1,
+			REPEAT_OFF_0,
+			REPEAT_OFF_1,
+			SHUFFLE_ON_0,
+			SHUFFLE_ON_1,
+			SHUFFLE_OFF_0,
+			SHUFFLE_OFF_1,
+			EQ_ON_0,
+			EQ_ON_1,
+			EQ_OFF_0,
+			EQ_OFF_1,
+			PLS_ON_0,
+			PLS_ON_1,
+			PLS_OFF_0,
+			PLS_OFF_1,
+			BTN_PREV_0,
+			BTN_PREV_1,
+			BTN_PLAY_0,
+			BTN_PLAY_1,
+			BTN_PAUSE_0,
+			BTN_PAUSE_1,
+			BTN_STOP_0,
+			BTN_STOP_1,
+			BTN_NEXT_0,
+			BTN_NEXT_1,
+			BTN_EJECT_0,
+			BTN_EJECT_1,
+			TEXTBG,
+			PIC_PLAY,
+			PIC_PAUSE,
+			PIC_STOP,
+			POSBAR,
+			POSBAR_BTN_0,
+			POSBAR_BTN_1,
+			VOLUMEBAR_POS_0,
+			VOLUMEBAR_POS_1,
+			VOLUMEBAR_POS_2,
+			VOLUMEBAR_POS_3,
+			VOLUMEBAR_POS_4,
+			VOLUMEBAR_POS_5,
+			VOLUMEBAR_POS_6,
+			VOLUMEBAR_POS_7,
+			VOLUMEBAR_POS_8,
+			VOLUMEBAR_POS_9,
+			VOLUMEBAR_POS_10,
+			VOLUMEBAR_POS_11,
+			VOLUMEBAR_POS_12,
+			VOLUMEBAR_POS_13,
+			VOLUMEBAR_POS_14,
+			VOLUMEBAR_POS_15,
+			VOLUMEBAR_POS_16,
+			VOLUMEBAR_POS_17,
+			VOLUMEBAR_POS_18,
+			VOLUMEBAR_POS_19,
+			VOLUMEBAR_POS_20,
+			VOLUMEBAR_POS_21,
+			VOLUMEBAR_POS_22,
+			VOLUMEBAR_POS_23,
+			VOLUMEBAR_POS_24,
+			VOLUMEBAR_POS_25,
+			VOLUMEBAR_POS_26,
+			VOLUMEBAR_POS_27,
+			VOLBAR_BTN_0,
+			VOLBAR_BTN_1,
+			CLUTTER_ON,
+			CLUTTER_OFF,
+			CLUTTER_O,
+			CLUTTER_A,
+			CLUTTER_I,
+			CLUTTER_D,
+			CLUTTER_V,
+			EQ_WIN_BG,
+			EQ_WIN_ON_0,
+			EQ_WIN_ON_1,
+			EQ_WIN_OFF_0,
+			EQ_WIN_OFF_1,
+			EQ_WIN_AUTO_ON_0,
+			EQ_WIN_AUTO_ON_1,
+			EQ_WIN_AUTO_OFF_0,
+			EQ_WIN_AUTO_OFF_1,
+			EQ_WIN_PRESET_0,
+			EQ_WIN_PRESET_1,
+			EQ_WIN_GRAPH_BG,
+			EQ_WIN_BAR_POS_0,
+			EQ_WIN_BAR_POS_1,
+			EQ_WIN_BAR_POS_2,
+			EQ_WIN_BAR_POS_3,
+			EQ_WIN_BAR_POS_4,
+			EQ_WIN_BAR_POS_5,
+			EQ_WIN_BAR_POS_6,
+			EQ_WIN_BAR_POS_7,
+			EQ_WIN_BAR_POS_8,
+			EQ_WIN_BAR_POS_9,
+			EQ_WIN_BAR_POS_10,
+			EQ_WIN_BAR_POS_11,
+			EQ_WIN_BAR_POS_12,
+			EQ_WIN_BAR_POS_13,
+			EQ_WIN_BAR_POS_14,
+			EQ_WIN_BAR_POS_15,
+			EQ_WIN_BAR_POS_16,
+			EQ_WIN_BAR_POS_17,
+			EQ_WIN_BAR_POS_18,
+			EQ_WIN_BAR_POS_19,
+			EQ_WIN_BAR_POS_20,
+			EQ_WIN_BAR_POS_21,
+			EQ_WIN_BAR_POS_22,
+			EQ_WIN_BAR_POS_23,
+			EQ_WIN_BAR_POS_24,
+			EQ_WIN_BAR_POS_25,
+			EQ_WIN_BAR_POS_26,
+			EQ_WIN_BAR_POS_27,
+			EQ_WIN_BAR_BTN_0,
+			EQ_WIN_BAR_BTN_1,
+			BALANCE_POS_0,
+			BALANCE_POS_1,
+			BALANCE_POS_2,
+			BALANCE_POS_3,
+			BALANCE_POS_4,
+			BALANCE_POS_5,
+			BALANCE_POS_6,
+			BALANCE_POS_7,
+			BALANCE_POS_8,
+			BALANCE_POS_9,
+			BALANCE_POS_10,
+			BALANCE_POS_11,
+			BALANCE_POS_12,
+			BALANCE_POS_13,
+			BALANCE_POS_14,
+			BALANCE_POS_15,
+			BALANCE_POS_16,
+			BALANCE_POS_17,
+			BALANCE_POS_18,
+			BALANCE_POS_19,
+			BALANCE_POS_20,
+			BALANCE_POS_21,
+			BALANCE_POS_22,
+			BALANCE_POS_23,
+			BALANCE_POS_24,
+			BALANCE_POS_25,
+			BALANCE_POS_26,
+			BALANCE_POS_27,
+			BALANCE_BTN_0,
+			BALANCE_BTN_1,
+		};
+
+		enum PlaylistParts {
+			PLS_CORNER_UL_0,
+			PLS_CORNER_UL_1,
+			PLS_CORNER_UR_0,
+			PLS_CORNER_UR_1,
+
+			PLS_TBAR_0,
+			PLS_TBAR_1,
+
+			PLS_TFILL_0,
+			PLS_TFILL_1,
+			PLS_BFILL_0,
+			PLS_BFILL_1 = PLS_BFILL_0,
+
+			PLS_VISMINI_0,
+			PLS_VISMINI_1 = PLS_VISMINI_0,
+
+			PLS_LFILL_0,
+			PLS_LFILL_1 = PLS_LFILL_0,
+			PLS_RFILL_0,
+			PLS_RFILL_1 = PLS_RFILL_0,
+			PLS_RFILL2_0,
+			PLS_RFILL2_1 = PLS_RFILL2_0,
+			PLS_RFILL3_0,
+			PLS_RFILL3_1 = PLS_RFILL3_0,
+
+			PLS_CLOSE_BTN_0,
+			PLS_CLOSE_BTN_1,
+			PLS_SHADE_BTN_0,
+			PLS_SHADE_BTN_1,
+			PLS_MAX_BTN_0,
+			PLS_MAX_BTN_1,
+
+			PLS_SCROLL_0,
+			PLS_SCROLL_1,
+			PLS_WS_LE_0,
+			PLS_WS_LE_1 = PLS_WS_LE_0,
+			PLS_WS_RE_0,
+			PLS_WS_RE_1,
+			PLS_WS_MID_0,
+			PLS_WS_MID_1 = PLS_WS_MID_0,
+			PLS_LCBAR,
+			PLS_RCBAR,
+			
+			PLS_MSC_BTN_0,
+			PLS_MSC_BTN_1,
+
+			PLS_ADD,
+			PLS_ADD_DEC,
+			PLS_ADD_URL_0,
+			PLS_ADD_URL_1,
+			PLS_ADD_DIR_0,
+			PLS_ADD_DIR_1,
+			PLS_ADD_FIL_0,
+			PLS_ADD_FIL_1,
+
+			PLS_DEL,
+			PLS_DEL_DEC,
+			PLS_DEL_ALL_0,
+			PLS_DEL_ALL_1,
+			PLS_DEL_CRP_0,
+			PLS_DEL_CRP_1,
+			PLS_DEL_FIL_0,
+			PLS_DEL_FIL_1,
+
+			PLS_SEL,
+			PLS_SEL_DEC,
+			PLS_SEL_INV_0,
+			PLS_SEL_INV_1,
+			PLS_SEL_NIL_0,
+			PLS_SEL_NIL_1,
+			PLS_SEL_ALL_0,
+			PLS_SEL_ALL_1,
+
+			PLS_MSC,
+			PLS_MSC_DEC,
+			PLS_MSC_SRT_0,
+			PLS_MSC_SRT_1,
+			PLS_MSC_INF_0,
+			PLS_MSC_INF_1,
+			PLS_MSC_OPT_0,
+			PLS_MSC_OPT_1,
+
+			PLS_LST,
+			PLS_LST_DEC,
+			PLS_LST_NEW_0,
+			PLS_LST_NEW_1,
+			PLS_LST_SAV_0,
+			PLS_LST_SAV_1,
+			PLS_LST_OPN_0,
+			PLS_LST_OPN_1
+		};
+	private:
+		Skin() {};
+		static Skin *singleton;
+
+		QPixmap *getPixmap (const QString& file);
+		void BuildLetterMap (void);
+		void BuildButtons (void);
+		void BuildToggleButtons (void);
+		void BuildTitleBar (void);
+		void BuildSliders (void);
+		void BuildOther (void);
+		void BuildNumbers (void);
+		void BuildPlaylist (void);
+		void ParsePLEdit (void);
+		void BuildEqualizer (void);
+
+
+		QString m_skinname;
+		QString m_path;
+
+		QMap<uint, QPixmap> m_items;
+		QMap<uint, QPixmap> m_letterMap;
+		QMap<uint, QPixmap> m_volume_bar;
+		QMap<uint, QPixmap> m_balance;
+		QMap<uint, QPixmap> m_numbers;
+		QMap<uint, QPixmap> m_playlist;
+		QMap<uint, QPixmap> m_equalizer;
+
+		QMap<QByteArray, QByteArray> m_pledit_txt;
+		QList<QPixmap *> m_buttons;
+
+		bool m_volbtn;
+		bool m_balbtn;
+
+	signals:
+		void skinChanged (Skin *skin);
+};
+
+#endif

src/SkinChooser.cpp

@@ -0,0 +1,75 @@
+#include "MainWindow.h"
+#include "Skin.h"
+#include "SkinChooser.h"
+
+#include <QDir>
+#include <QIcon>
+#include <QFile>
+#include <QSettings>
+
+SkinChooser::SkinChooser (QWidget *parent) : QMainWindow (parent)
+{
+
+#ifndef _WIN32
+	setWindowIcon (QIcon (":icon.png"));
+#endif
+	setWindowFlags (Qt::Dialog);
+	setWindowModality (Qt::ApplicationModal);
+	setAttribute (Qt::WA_DeleteOnClose);
+
+	m_mw = dynamic_cast<MainWindow *>(parent);
+	m_c = new QWidget (this);
+	setCentralWidget (m_c);
+
+	m_vbox = new QVBoxLayout (m_c);
+	m_label = new QLabel ("Available skins...", m_c);
+	m_label->setFont (QFont ("Helvetica", 16));
+	m_vbox->addWidget (m_label);
+
+	m_skin = new SkinList (m_c);
+	m_vbox->addWidget (m_skin);
+
+	resize (500, 300);
+
+}
+
+SkinList::SkinList (QWidget *parent) : QListWidget (parent)
+{
+
+	setIconSize (QSize (137, 58));
+
+	QString path;
+	path.append (QDir::homePath());
+	path.append ("/.config/xmms2/clients/promoe/skins/");
+	QDir d;
+			
+	new SkinChooserItem (QIcon (":CleanAMP/main.png"), "CleanAMP (default)", ":CleanAMP/", this);
+
+	d.setPath (path);
+	d.setFilter (QDir::Dirs);
+
+	QFileInfoList list = d.entryInfoList();
+	for (int i = 0; i < list.size(); ++i) {
+		QFileInfo fileInfo = list.at(i);
+		QDir dir (fileInfo.filePath());
+		QPixmap p = Skin::getPixmap ("main", dir);
+		if (!p.isNull()) {
+			new SkinChooserItem (QIcon (p), dir.dirName(), dir.absolutePath(), this);
+		}
+	}
+
+	connect (this, SIGNAL (itemClicked (QListWidgetItem *)), this, SLOT (changeSkin (QListWidgetItem *)));
+}
+
+void
+SkinList::changeSkin (QListWidgetItem *item)
+{
+	Skin *skin = Skin::getInstance ();
+	SkinChooserItem *it = dynamic_cast<SkinChooserItem*> (item);
+
+	QSettings settings;
+
+	skin->setSkin (it->getPath ());
+	settings.setValue ("skin/path", it->getPath ());
+}
+

src/SkinChooser.h

@@ -0,0 +1,48 @@
+#include "MainWindow.h"
+
+#include <QListWidget>
+#include <QLabel>
+#include <QVBoxLayout>
+#include <QMainWindow>
+
+class SkinList : public QListWidget
+{
+	Q_OBJECT
+	public:
+		SkinList (QWidget *parent);
+		~SkinList () {}
+
+	public slots:
+		void changeSkin (QListWidgetItem *item);
+};
+
+class SkinChooserItem : public QListWidgetItem
+{
+	public:
+		SkinChooserItem (QIcon i, QString n, QString p, QListWidget *parent) :
+			QListWidgetItem (i, n, parent) {
+				m_path = p;
+			}
+		~SkinChooserItem () {}
+		QString getPath (void) { return m_path; }
+	private:
+		QString m_path;
+
+};
+
+class SkinChooser : public QMainWindow
+{
+	public:
+		SkinChooser (QWidget *parent);
+		~SkinChooser (void) {}
+		MainWindow *getMW (void) { return m_mw; }
+
+	private:
+		QVBoxLayout *m_vbox;
+		SkinList *m_skin;
+		QLabel *m_label;
+		QWidget *m_c;
+		MainWindow *m_mw;
+
+};
+

src/SmallNumberDisplay.cpp

@@ -0,0 +1,48 @@
+#include "SmallNumberDisplay.h"
+#include "Skin.h"
+
+SmallNumberDisplay::SmallNumberDisplay (QWidget *parent, int w) : PixWidget (parent)
+{
+	m_w = w;
+	setMinimumSize (w, 6);
+	setMaximumSize (w, 6);
+	m_pixmap = QPixmap (w, 6);
+}
+
+void
+SmallNumberDisplay::setPixmaps (Skin *skin)
+{
+	drawNumber ();
+}
+
+void
+SmallNumberDisplay::setNumber (int num, int len)
+{
+	snprintf (m_nums, len+1, "%02d", num);
+	m_num = len;
+
+	drawNumber ();
+
+	update ();
+}
+
+void
+SmallNumberDisplay::drawNumber ()
+{
+	Skin *skin = Skin::getInstance ();
+
+	QPainter paint;
+	paint.begin (&m_pixmap);
+	paint.drawPixmap (m_pixmap.rect (),
+					  skin->getItem (Skin::TEXTBG),
+					  m_pixmap.rect ());
+
+	for (int i = 0; i < m_num; i++) {
+		paint.drawPixmap (QRect (i*5, 0, 4, 6),
+						  skin->getLetter (m_nums[i]),
+						  skin->getLetter (m_nums[i]).rect ());
+	}
+
+	paint.end ();
+}
+

src/SmallNumberDisplay.h

@@ -0,0 +1,30 @@
+#ifndef __SMALLNUMBERDISPLAY_H__
+#define __SMALLNUMBERDISPLAY_H__
+
+#include "PixWidget.h"
+#include <QPainter>
+
+
+class SmallNumberDisplay : public PixWidget
+{
+	Q_OBJECT;
+
+	public:
+		SmallNumberDisplay (QWidget *parent, int w);
+		~SmallNumberDisplay () { };
+
+		void setNumber (int num, int len);
+		int getNumber (void) const { return m_num; }
+
+	public slots:
+		void setPixmaps (Skin *skin);
+
+	private:
+		char m_nums[2];
+		int m_num;
+		int m_w;
+
+		void drawNumber (void);
+};
+
+#endif

src/StereoMono.cpp

@@ -0,0 +1,63 @@
+#include "StereoMono.h"
+#include "Skin.h"
+
+StereoMono::StereoMono (QWidget *parent) : PixWidget (parent)
+{
+	setMinimumSize (56, 12);
+	setMaximumSize (56, 12);
+
+	m_pixmap = QPixmap (56, 12);
+}
+
+void
+StereoMono::setPixmaps (Skin *skin)
+{
+	m_pixmap_stereo_on = skin->getItem (Skin::STEREO_1);
+	m_pixmap_stereo_off = skin->getItem (Skin::STEREO_0);
+	m_pixmap_mono_on = skin->getItem (Skin::MONO_1);
+	m_pixmap_mono_off = skin->getItem (Skin::MONO_0);
+
+	setStereoMono (m_stereo, m_mono);
+}
+
+void
+StereoMono::drawPixmaps ()
+{
+	QPainter paint;
+	paint.begin (&m_pixmap);
+
+	paint.drawPixmap (QRect (0, 0, 27, 12),
+					  m_pixmap_mono,
+					  m_pixmap.rect ());
+
+	paint.drawPixmap (QRect (27, 0, 29, 12),
+					  m_pixmap_stereo,
+					  m_pixmap.rect ());
+	paint.end ();
+
+	update();
+}
+
+void
+StereoMono::setStereoMono (bool stereo, bool mono)
+{
+
+	if (stereo) {
+		m_pixmap_stereo = m_pixmap_stereo_on;
+	} else {
+		m_pixmap_stereo = m_pixmap_stereo_off;
+	}
+
+	if (mono) {
+		m_pixmap_mono = m_pixmap_mono_on;
+	} else {
+		m_pixmap_mono = m_pixmap_mono_off;
+	}
+
+	m_stereo = stereo;
+	m_mono = mono;
+
+	drawPixmaps ();
+
+}
+

src/StereoMono.h

@@ -0,0 +1,31 @@
+#ifndef __STEREOMONO_H__
+#define __STEREOMONO_H__
+
+#include "PixWidget.h"
+
+class StereoMono : public PixWidget
+{
+	public:
+		StereoMono (QWidget *parent);
+		~StereoMono () { }
+
+		void setStereoMono (bool, bool);
+
+	public slots:
+		void setPixmaps (Skin *skin);
+
+	private:
+		void drawPixmaps ();
+		bool m_stereo;
+		bool m_mono;
+
+		QPixmap m_pixmap_stereo_on;
+		QPixmap m_pixmap_stereo_off;
+		QPixmap m_pixmap_mono_on;
+		QPixmap m_pixmap_mono_off;
+
+		QPixmap m_pixmap_mono;
+		QPixmap m_pixmap_stereo;
+};
+
+#endif

src/TextBar.cpp

@@ -0,0 +1,229 @@
+#include "MainWindow.h"
+#include "Display.h"
+#include "TextBar.h"
+
+TextScroller::TextScroller (QWidget *parent, uint w, 
+							uint h, const QString &name) : 
+	QWidget (parent)
+{
+	//XMMSHandler *xmmsh = XMMSHandler::getInstance ();
+	Skin *skin = Skin::getInstance ();
+
+	connect (skin, SIGNAL (skinChanged (Skin *)),
+	         this, SLOT (setPixmaps(Skin *)));
+
+	QSettings s;
+
+	s.beginGroup ("display_" + name);
+
+	if (!s.contains("scroll"))
+		s.setValue("scroll", true);
+
+	if (!s.contains("fontsize"))
+		s.setValue("fontsize", 8);
+
+	if (!s.contains("ttf"))
+		s.setValue("ttf", true);
+
+	m_name = name;
+	m_h = h;
+	m_w = w;
+	m_x_off = 0;
+	m_x2_off = 0;
+	m_fontsize = s.value ("fontsize").toInt ();
+	m_ttf = s.value ("ttf").toBool ();
+	m_text = "Promoe 0.1";
+	m_scroll = s.value ("scroll").toBool ();
+
+	s.endGroup ();
+	
+	setMinimumSize(m_w + 2, m_h);
+	setMaximumSize(m_w + 2, m_h);
+
+	m_timer = new QTimer (this);
+	connect (m_timer, SIGNAL (timeout()), this, SLOT (addOffset ()));
+	//connect (xmmsh, SIGNAL (settingsSaved ()), this, SLOT (settingsSaved ()));
+}
+
+void
+TextScroller::settingsSaved (void)
+{
+	QSettings s;
+	s.beginGroup ("display_" + m_name);
+	m_fontsize = s.value ("fontsize").toInt ();
+	m_ttf = s.value ("ttf").toBool ();
+
+	if (m_scroll != s.value ("scroll").toBool ()) {
+		m_x_off = 0;
+		m_x2_off = 0;
+	}
+
+	m_scroll = s.value ("scroll").toBool ();
+	s.endGroup ();
+
+	setText (m_text);
+	update ();
+}
+
+void
+TextScroller::setPixmaps (Skin *skin)
+{
+	QPalette pal = palette ();
+	QBrush b = QBrush (skin->getItem (Skin::TEXTBG));
+	pal.setBrush (QPalette::Window, b);
+	setPalette (pal);
+
+	setText (m_text);
+	update();
+}
+void 
+TextScroller::addOffset ()
+{
+	if (m_x2_off > 0) {
+		m_x2_off --;
+	} else if (m_x_off < m_pixmap.size().width()) {
+		m_x_off ++;
+	} else {
+		m_x_off = 0;
+		m_x2_off = 0;
+	}
+
+	repaint ();
+	m_timer->start (40);
+}
+
+void
+TextScroller::setText (QString text)
+{
+	m_text = text;
+
+	if (m_ttf) {
+		drawQtFont (text);
+	} else {
+		drawBitmapFont (text);
+	}
+	update ();
+}
+
+void
+TextScroller::drawBitmapFont (QString text)
+{
+	Skin *skin = Skin::getInstance ();
+
+	int width = text.length() * 6;
+	QString temp = text.toLower ();
+
+	if (width > m_w) {
+		temp += QString::fromAscii ("  --  ");
+		m_pixmap = QPixmap (width + 6*6, m_h);
+
+		if (m_scroll) {
+			m_timer->start (40);
+		} else {
+			m_timer->stop ();
+		}
+	} else {
+		m_pixmap = QPixmap (m_w, m_h);
+	}
+	QByteArray temp2 = temp.toLatin1();
+	const char *t = temp2.data();
+
+	QPainter (paint);
+
+	paint.begin (&m_pixmap);
+
+	paint.drawPixmap (m_pixmap.rect (),
+	                  skin->getItem (Skin::TEXTBG),
+	                  skin->getItem (Skin::TEXTBG).rect ());
+
+	for (uint i = 0; i < strlen (t); i++) {
+		QPixmap p = skin->getLetter (t[i]);
+		if (p.isNull ()) {
+			p = skin->getLetter(' ');
+		}
+
+		paint.drawPixmap (QRect ((i * 6), 0, 4, 6),
+						  p, p.rect());
+	}
+
+	paint.end();
+
+}
+
+void
+TextScroller::drawQtFont (QString text)
+{
+	Skin *skin = Skin::getInstance ();
+
+	QFont font(skin->getPLeditValue ("font"));
+	font.setPixelSize (m_fontsize);
+
+	QFontMetrics fM(font);
+	QRect rect = fM.boundingRect (text);
+
+	QString (temp) = text;
+
+	if (rect.width() > m_w) {
+		temp += QString::fromAscii ("  --  ");
+		QRect rect = fM.boundingRect (temp);
+
+		m_pixmap = QPixmap (rect.width(), m_h);
+
+		if (m_scroll) {
+			m_timer->start (40);
+		} else {
+			m_timer->stop ();
+		}
+
+	} else {
+		m_pixmap = QPixmap (m_w, m_h);
+	}
+
+	QPainter paint;
+	paint.begin (&m_pixmap);
+	paint.drawPixmap (m_pixmap.rect (),
+	                  skin->getItem (Skin::TEXTBG),
+	                  skin->getItem (Skin::TEXTBG).rect ());
+
+	paint.setFont (font);
+	QColor c;
+	c.setNamedColor (skin->getPLeditValue ("normal"));
+	paint.setPen (c);
+	paint.drawText (m_pixmap.rect (),
+					Qt::AlignLeft | Qt::AlignVCenter,
+					temp);
+	paint.end ();
+
+}
+
+void 
+TextScroller::paintEvent (QPaintEvent *event)
+{
+	int pad = 0;
+
+	if (m_pixmap.isNull ()) {
+		return;
+	}
+
+	int w2 = m_pixmap.size().width() - m_x_off;
+	if (w2 < m_w) {
+		pad = m_w - w2;
+	}
+
+	QPainter (paint);
+	paint.begin (this);
+	paint.drawPixmap (QRect (m_x2_off, 0, m_w - pad, m_h),
+					  m_pixmap, 
+					  QRect (m_x_off, 0, m_w, m_h));
+	if (pad) {
+		paint.drawPixmap (QRect (m_w - pad, 0, pad, m_h),
+						  m_pixmap,
+						  QRect (0, 0, pad, m_h));
+	}
+	paint.end ();
+}
+
+TextScroller::~TextScroller ()
+{
+}
+

src/TextBar.h

@@ -0,0 +1,55 @@
+#ifndef __TEXTBOX_H__
+#define __TEXTBOX_H__
+
+#include <iostream>
+
+#include <QPixmap>
+#include <QPainter>
+#include <QWidget>
+#include <QFont>
+#include <QTimer>
+#include <QBrush>
+#include <QPalette>
+#include <QBitmap>
+
+#include "Skin.h"
+
+class TextScroller : public QWidget
+{
+	Q_OBJECT
+
+	public:
+		TextScroller (QWidget *parent, uint, uint, const QString &);
+		~TextScroller ();
+
+		void setText(QString text);
+		void setFontSize (int i) { m_fontsize = i; }
+		void setTTF (bool b) { m_ttf = b; }
+
+	public slots:
+		void addOffset ();
+		void setPixmaps(Skin *skin);
+		void settingsSaved (void);
+
+	protected:
+		QPixmap m_pixmap;
+		void paintEvent (QPaintEvent *event);
+
+	private:
+		int m_w;
+		int m_h;
+		int m_x_off;
+		int m_x2_off;
+		int m_fontsize;
+		bool m_ttf;
+		bool m_scroll;
+
+		QTimer *m_timer;
+		QString m_text;
+		QString m_name;
+
+		void drawBitmapFont (QString text);
+		void drawQtFont (QString text);
+};
+
+#endif

src/TimeDisplay.cpp

@@ -0,0 +1,101 @@
+#include "MainDisplay.h"
+#include "TimeDisplay.h"
+#include "NumberDisplay.h"
+
+#include "MainWindow.h"
+
+#include <QPen>
+
+TimeDisplay::TimeDisplay (QWidget *parent, int time) : PixWidget (parent)
+{
+	uint w = 12;//+78;
+	
+	m_w = w;
+	
+	m_pixmap = QPixmap (m_w, 13);
+
+	setMinimumSize (m_w, 13);
+	setMaximumSize (m_w, 13);
+	move (37, 26);
+
+	//FIXME: let this be the parent
+/* XXX: colon disappear, how make transparent?
+	m_number_min = new NumberDisplay (this, 24, 0);
+	m_number_min->move (10, 0);
+	m_number_sec = new NumberDisplay (this, 24, 0);
+	m_number_sec->move (78-37, 0);
+*/
+
+	m_number_min = new NumberDisplay (parent, this,24, 0);
+	m_number_min->move (37+10, 26);
+	m_number_sec = new NumberDisplay (parent, this,24, 0);
+	m_number_sec->move (78, 26);
+
+	connect (m_number_min, SIGNAL(clicked()), parent, SLOT(toggleTime()));
+	connect (m_number_sec, SIGNAL(clicked()), parent, SLOT(toggleTime()));
+}
+void TimeDisplay::setPixmaps (Skin *skin)
+{
+	drawMinus();
+	m_number_min->setPixmaps (skin);
+	m_number_sec->setPixmaps (skin);
+}
+TimeDisplay::~TimeDisplay () 
+{
+}
+void TimeDisplay::setTime (int time)
+{
+	if (m_time == time) return;
+	m_time = time;
+
+	uint showtime = abs(time);
+	uint sec, min;
+
+	sec = (showtime / 1000) % 60;
+	min = (showtime / 1000) / 60;
+
+	m_number_min->setNumber (min / 10, min % 10);
+	m_number_sec->setNumber (sec / 10, sec % 10);
+
+	drawMinus ();
+}
+void
+TimeDisplay::drawMinus ()
+{
+	Skin *skin = Skin::getInstance ();
+
+	// Draw background
+	QBrush b (skin->getNumber (10));
+
+	QPainter paint;
+	paint.begin (&m_pixmap);
+	paint.fillRect (m_pixmap.rect (), b);
+	MainDisplay *md = dynamic_cast<MainDisplay *>(parent());
+
+	if (md->getMW()->isTimemodeReverse()) {// draw a minus sign
+		if (skin->getNumberSize() < 12) { // Skin hasn't got any, draw a line in correct color.
+			QByteArray a = skin->getPLeditValue("normal");
+			QColor c;
+			c.setNamedColor(a);
+			QPen pen(c);
+			paint.setPen(pen);
+			paint.drawLine (3,6,8,6);
+		} else {
+			paint.drawPixmap (0, 0, skin->getNumber (11));
+		}
+	}
+	paint.end();
+
+	update ();
+}
+void
+TimeDisplay::mousePressEvent (QMouseEvent *event)
+{
+}
+void
+TimeDisplay::mouseReleaseEvent (QMouseEvent *event)
+{
+	emit clicked();
+	drawMinus ();
+}
+

src/TimeDisplay.h

@@ -0,0 +1,32 @@
+#ifndef __TIMEDISPLAY_H__
+#define __TIMEDISPLAY_H__
+
+class TimeDisplay;
+
+#include "PixWidget.h"
+#include "NumberDisplay.h"
+
+class TimeDisplay : public PixWidget
+{
+	Q_OBJECT
+	public:
+		TimeDisplay (QWidget *parent, int time);
+		~TimeDisplay ();
+		void setTime (int);
+		void drawMinus();
+	public slots:
+		void setPixmaps (Skin *skin);
+	signals:
+		void clicked(void);
+
+	protected:
+		void mousePressEvent (QMouseEvent *event);
+		void mouseReleaseEvent (QMouseEvent *event);
+		int m_time;
+		NumberDisplay *m_number_min;
+		NumberDisplay *m_number_sec;
+
+		uint m_w;
+};
+
+#endif

src/TitleBar.cpp

@@ -0,0 +1,147 @@
+#include "MainWindow.h"
+#include "TitleBar.h"
+#include "Display.h"
+#include "SkinChooser.h"
+#include "MedialibWindow.h"
+#include "SettingsWindow.h"
+#include "Button.h"
+#include "BrowseDialog.h"
+
+#include <QMenu>
+
+TitleBar::TitleBar (QWidget *parent, bool shaded) : PixWidget (parent)
+{
+	MainWindow *mw = dynamic_cast<MainWindow*>(window ());
+	m_shaded = shaded;
+	
+	setMinimumSize (275, 14);
+	setMaximumSize (275, 14);
+
+	m_menubtn = new Button (this, Skin::MENUBUTTON_0, Skin::MENUBUTTON_1);
+	connect (m_menubtn, SIGNAL (clicked ()), this, SLOT (showMenu ()));
+	m_menubtn->move(6, 3);
+
+	m_minimize = new Button (this, Skin::MINIMIZE_0, Skin::MINIMIZE_1);
+	connect (m_minimize, SIGNAL (clicked ()), mw, SLOT (showMinimized ()));
+	m_minimize->move(244, 3);
+
+	m_shadebtn = new Button (this, Skin::SHADE_1_0, Skin::SHADE_1_1);
+	connect (m_shadebtn, SIGNAL (clicked()), mw, SLOT (switchDisplay ()));
+	m_shadebtn->move(254, 3);
+
+	m_closebtn = new Button (this, Skin::CLOSE_0, Skin::CLOSE_1);
+	connect (m_closebtn, SIGNAL (clicked()), qApp, SLOT (quit ()));
+	m_closebtn->move(264, 3);
+
+}
+
+void
+TitleBar::showMenu (void)
+{
+	QMenu qm(this);
+
+	QAction *a;
+
+	a = new QAction (tr ("Medialib browser"), this);
+	a->setShortcut (tr ("Alt+M"));
+	connect (a, SIGNAL (triggered ()), this, SLOT (showMlib ()));
+	qm.addAction (a);
+	a = new QAction (tr ("Server-side browser"), this);
+	a->setShortcut (tr ("Alt+S"));
+	connect (a, SIGNAL (triggered ()), this, SLOT (showServerB ()));
+	qm.addAction (a);
+	qm.addSeparator ();
+	a = new QAction (tr ("Theme settings"), this);
+	a->setShortcut (tr ("Alt+T"));
+	connect (a, SIGNAL (triggered ()), this, SLOT (showTheme ()));
+	qm.addAction (a);
+	a = new QAction (tr ("Application settings"), this);
+	a->setShortcut (tr ("Alt+A"));
+	connect (a, SIGNAL (triggered ()), this, SLOT (showSettings ()));
+	qm.addAction (a);
+	a = new QAction (tr ("Server settings"), this);
+	a->setShortcut (tr ("Alt+S"));
+	qm.addAction (a);
+	qm.addSeparator ();
+	a = new QAction (tr ("Quit"), this);
+	a->setShortcut (tr ("Ctrl+Q"));
+	connect (a, SIGNAL (triggered ()), qApp, SLOT (quit ()));
+	qm.addAction (a);
+
+	qm.exec(QPoint (window()->pos().x()+6, window()->pos().y()+3));
+
+}
+
+void
+TitleBar::showMlib ()
+{
+	/*
+	MedialibWindow *mw = new MedialibWindow (window ());
+	mw->show ();
+	*/
+}
+
+void
+TitleBar::showServerB ()
+{
+	BrowseDialog *bd = new BrowseDialog (window ());
+	bd->show ();
+}
+
+void
+TitleBar::showSettings ()
+{
+	SettingsWindow *sw = new SettingsWindow (window ());
+	sw->show ();
+}
+
+void
+TitleBar::showTheme ()
+{
+	SkinChooser *sk = new SkinChooser (window());
+	sk->show();
+}
+
+void
+TitleBar::setPixmaps (Skin *skin)
+{
+	if (m_shaded) {
+		m_pixmap_active = skin->getItem (Skin::STATUSBAR_0);
+		m_pixmap_inactive = skin->getItem (Skin::STATUSBAR_1);
+	} else { 
+		m_pixmap_active = skin->getItem (Skin::TITLEBAR_0);
+		m_pixmap_inactive = skin->getItem (Skin::TITLEBAR_1);
+	}
+
+	if (underMouse()) {
+		m_pixmap = m_pixmap_active;
+	} else {
+		m_pixmap = m_pixmap_inactive;
+	}
+
+	update ();
+}
+
+TitleBar::~TitleBar ()
+{
+}
+
+void 
+TitleBar::setActive (bool active)
+{
+	if (active) {
+		m_pixmap = m_pixmap_active;
+		update ();
+	} else {
+		m_pixmap = m_pixmap_inactive;
+		update ();
+	}
+}
+
+void 
+TitleBar::mouseDoubleClickEvent (QMouseEvent *event)
+{
+	MainWindow *mw = dynamic_cast<MainWindow*>(window ());
+	mw->switchDisplay ();
+}
+

src/TitleBar.h

@@ -0,0 +1,41 @@
+#ifndef __TITLEBAR_H__
+#define __TITLEBAR_H__
+
+class TitleBar;
+
+#include "PixWidget.h"
+
+class Button;
+
+class TitleBar : public PixWidget
+{
+	Q_OBJECT
+	public:
+		TitleBar (QWidget *parent, bool shaded);
+		~TitleBar ();
+		void setActive (bool active);
+
+	public slots:
+		void setPixmaps (Skin *skin);
+		void showMenu (void);
+		void showServerB (void);
+		void showTheme (void);
+		void showMlib (void);
+		void showSettings (void);
+
+	protected:
+		void mouseDoubleClickEvent (QMouseEvent *event);
+
+	private:
+		QPixmap m_pixmap_active;
+		QPixmap m_pixmap_inactive;
+
+		Button *m_shadebtn;
+		Button *m_menubtn;
+		Button *m_closebtn;
+		Button *m_minimize;
+
+		bool m_shaded;
+};
+
+#endif

src/VolumeSlider.cpp

@@ -0,0 +1,227 @@
+#include "XMMSHandler.h"
+#include <math.h>
+
+#include "VolumeSlider.h"
+#include <QMouseEvent>
+
+#include "Skin.h"
+#include "Button.h"
+
+#define CLAMP(x, low, high)  (((x) > (high)) ? (high) : (((x) < (low)) ? (low) : (x)))
+
+Slider::Slider (QWidget *parent, uint name_min, uint name_max,
+                uint name_on, uint name_off, int min, int max) : PixWidget (parent)
+{
+	m_name_min = name_min;
+	m_name_max = name_max;
+	m_name_on = name_on;
+	m_name_off = name_off;
+	
+	m_min = min;
+	m_max = max;
+
+	m_button = 0;
+
+	m_value = 0;
+	m_value_index = (uint)((abs(m_min) / (double)(abs(m_min)+abs(m_max))) * (name_max-name_min));
+}
+
+void
+Slider::setPixmaps (Skin *skin)
+{
+	m_skin = skin;
+
+	m_pixmap_slider = m_skin->getItem(m_name_min+m_value_index);
+	m_vertical = (m_pixmap_slider.height() > m_pixmap_slider.width()) ? true : false;
+
+	setMinimumSize(m_pixmap_slider.size());
+	setMaximumSize(m_pixmap_slider.size());
+
+	resize(m_pixmap_slider.size());
+
+	if (!skin->getItem(m_name_on).isNull() && !skin->getItem(m_name_off).isNull()) {
+		if (m_button) {
+			delete m_button;
+		}
+
+		m_button = new SliderButton (this, m_name_on, m_name_off, m_vertical);
+		m_button->setPixmaps (m_skin);
+		m_button->show ();
+
+		int tmp = (uint)((ceil(abs(m_min) / (double)(abs(m_min)+abs(m_max)))) * (m_name_max-m_name_min));
+		if (m_vertical) {
+			m_button->move(1, height()-m_button->height()-tmp);
+		} else {
+			m_button->move(tmp, 1);
+		}
+	} else {
+		if (m_button) {
+			delete m_button;
+			m_button = NULL;
+		}
+	}
+
+	update();
+}
+
+void
+Slider::changePixmap ()
+{
+	m_pixmap_slider = m_skin->getItem (m_name_min+m_value_index);
+	update();
+}
+
+void
+Slider::paintEvent (QPaintEvent *event)
+{
+	QPainter paint;
+	paint.begin (this);
+	paint.drawPixmap (rect(), m_pixmap_slider, m_pixmap_slider.rect ());
+	paint.end ();
+}
+
+void 
+Slider::mousePressEvent (QMouseEvent *event)
+{
+	updatePos (event);
+}
+
+void
+Slider::mouseMoveEvent (QMouseEvent *event)
+{
+	updatePos (event);
+}
+
+void
+Slider::mouseReleaseEvent (QMouseEvent *event)
+{
+	updatePos (event);
+}
+
+void
+Slider::updatePos (QMouseEvent *event)
+{
+	QPoint p (event->pos ());
+	int value;
+
+	if (m_vertical) {
+		value = CLAMP(p.y(), 0, height());
+	} else {
+		value = CLAMP(p.x(), 0, width());
+	}
+
+	setPos(value, true);
+	if (m_button != 0) {
+		m_button->setPos(value);
+	}
+
+	emit valueChanged (m_value);
+}
+
+void
+Slider::setValue (int value)
+{
+	double frac;
+	int pos;
+
+   	frac = abs(value)/(double)(abs(m_min)+abs(m_max));
+	if (m_vertical) {
+		pos = (int)(height() * frac);
+	} else {
+		pos = (int)(width() * frac);
+	}
+
+	setPos(pos, false);
+	if (m_button != 0) {
+		m_button->setPos(pos);
+	}
+}
+
+void
+Slider::setPos (int value, bool tell)
+{
+	double frac;
+
+	if (m_vertical) {
+		frac = (height() - value) / (double) height();
+	} else {
+		frac = value / (double) width();
+	}
+
+	/* calculate m_min <= m_value <= m_max */
+	m_value = (uint)(frac * (abs(m_min) + abs(m_max)) + m_min);
+
+	/* calculate m_name_min <= m_value_index <= m_name_max */
+	m_value_index = (uint) ceil (frac * (m_name_max - m_name_min));
+
+
+	changePixmap();
+
+	if (tell) {
+		emit valueChanged (m_value);
+	}
+}
+
+
+SliderButton::SliderButton (QWidget *parent, uint normal, uint pressed,
+                            bool vertical) : Button (parent, normal, pressed, false)
+{
+	m_slider = dynamic_cast<Slider *>(parent);
+	m_vertical = vertical;
+	m_diff = 0;
+	m_moving = false;
+
+	if (m_vertical) {
+		move(1, 0);
+	} else {
+		move(0, 1);
+	}
+}
+
+
+void
+SliderButton::mousePressEvent (QMouseEvent *event)
+{
+	if (m_vertical) {
+		m_diff = y() - event->pos().y();
+	} else {
+		m_diff = x() - event->pos().x();
+	}
+	m_moving = true;
+}
+
+
+void
+SliderButton::mouseReleaseEvent (QMouseEvent *event)
+{
+	m_moving = false;
+}
+
+
+void
+SliderButton::setPos (uint pos)
+{
+	if (m_vertical) {
+		int ypos = MIN(pos, (uint)m_slider->height()-height());
+		move(1, ypos);
+	} else {
+		int xpos = MIN(pos, (uint)m_slider->width()-width());
+		move(xpos, 1);
+	}
+}
+
+
+void
+SliderButton::mouseMoveEvent (QMouseEvent *event)
+{
+	QPoint p = m_slider->mapFromGlobal (event->globalPos ());
+	int value;
+	if (m_vertical) {
+		value = CLAMP(p.y(), 0, m_slider->height());
+	} else {
+		value = CLAMP(p.x(), 0, m_slider->width());
+	}
+
+	m_slider->setPos(value, true);
+	setPos (value);
+}

src/VolumeSlider.h

@@ -0,0 +1,77 @@
+#ifndef __VOLUMESLIDER_H__
+#define __VOLUMESLIDER_H__
+
+class Slider;
+class MainDisplay;
+class Button;
+
+#include "Button.h"
+
+class SliderButton : public Button
+{
+	Q_OBJECT
+	public:
+		SliderButton (QWidget *parent, uint normal, uint pressed, bool dir);
+		void mouseMoveEvent (QMouseEvent *);
+		void mousePressEvent (QMouseEvent *);
+		void mouseReleaseEvent (QMouseEvent *);
+		void setPos (uint);
+
+
+	public slots:
+		//void setValue (uint volume_base100);
+
+	private:
+		void changePixmap (bool pressed);
+		Slider *m_slider;
+		bool m_vertical;
+		int m_diff;
+		bool m_moving;
+};
+
+class Slider : public PixWidget
+{
+	Q_OBJECT
+	public:
+		Slider (QWidget *parent, uint min, uint max, uint on, uint off, int, int);
+
+		void paintEvent (QPaintEvent *event);
+
+		void mouseMoveEvent (QMouseEvent *);
+		void mousePressEvent (QMouseEvent *);
+		void mouseReleaseEvent (QMouseEvent *);
+
+	public slots:
+		void setPixmaps (Skin *skin);
+		void setPos (int value, bool tell);
+		void setValue (int value);
+
+	signals:
+		void valueChanged (int val);
+
+	private:
+		void updatePos (QMouseEvent *event);
+		void changePixmap ();
+
+		QPixmap m_pixmap_slider;
+		SliderButton *m_button;
+
+		Skin *m_skin;
+
+		uint m_value_index;
+		int m_value;
+
+		int m_position;
+
+		uint m_name_min;
+		uint m_name_max;
+		uint m_name_on;
+		uint m_name_off;
+
+		int m_min;
+		int m_max;
+
+		bool m_vertical;
+};
+
+#endif

src/XMMSHandler.cpp

@@ -0,0 +1,351 @@
+#include <xmmsclient/xmmsclient++.h>
+
+#include "xmmsqt4.h"
+#include "XMMSHandler.h"
+#include "playlistmodel.h"
+
+#include <cstdlib>
+#include <string>
+#include <iostream>
+
+#include <QErrorMessage>
+#include <QHash>
+#include <QFile>
+#include <QFileDialog>
+#include <QDir>
+
+static bool log ( /*const std::string& text = ""*/ )
+{
+	return false;
+}
+
+XMMSHandler &XMMSHandler::getInstance ()
+{
+	static XMMSHandler singleton(NULL, "Prome_Main");
+	return singleton;
+}
+
+XMMSHandler::XMMSHandler (QObject *parent, const std::string &name) : XClient (parent, name)
+{
+	connect_handler();
+}
+
+bool
+XMMSHandler::connect_handler (const char *ipcpath, const bool &sync, QWidget *parent)
+{
+/*	try {
+		m_client.connect(path);
+		//TODO reenable checking of path
+		//m_client.connect (path ? path : "");
+	}
+	catch (Xmms::connection_error& e) {
+		QErrorMessage *err = new QErrorMessage ();
+		err->showMessage ("Couldn't connect to XMMS2, please try again.");
+		err->exec ();
+		delete err;
+		return false;
+	}
+
+	m_client.setMainloop (new XmmsQT4 (m_client.getConnection ()));
+*/
+	//TODO must be moved elsewere later
+	m_playlist_model = new PlaylistModel(NULL, this, "_active");
+
+	connect(ipcpath, sync, parent);
+
+	using Xmms::bind;
+//	m_client->playlist.listEntries () (bind (&XMMSHandler::playlist_list, this));
+//	m_client->playlist.broadcastChanged () (bind (&XMMSHandler::playlist_changed, this));
+
+	m_client->medialib.broadcastEntryChanged () (bind (&XMMSHandler::medialib_entry_changed, this));
+
+	m_client->playback.currentID () (bind (&XMMSHandler::playback_current_id, this));
+	m_client->playback.broadcastCurrentID () (bind (&XMMSHandler::playback_current_id, this));
+
+	m_client->playback.getStatus () (bind (&XMMSHandler::playback_status, this));
+	m_client->playback.broadcastStatus () (bind (&XMMSHandler::playback_status, this));
+
+	m_client->playback.broadcastVolumeChanged () (bind (&XMMSHandler::volume_changed, this));
+
+	// TODO: Disabled for now. Seems to cause problems on startup
+//	QObject::connect (&m_playtime_timer, SIGNAL (timeout ()),
+//	                  this, SLOT (restartPlaytime ()));
+//	m_playtime_timer.start(0);
+
+	return true;
+}
+
+
+Xmms::Client *
+XMMSHandler::getClient ()
+{
+	return m_client;
+}
+
+void
+XMMSHandler::restartPlaytime ()
+{
+	m_client->playback.getPlaytime () (Xmms::bind (&XMMSHandler::playback_playtime, this));
+}
+
+bool
+XMMSHandler::medialib_entry_changed (const unsigned int &id)
+{
+	if (id > 0) {
+		requestMediainfo (id);
+	}
+	return true;
+}
+
+void
+XMMSHandler::playlistAddURL (const QString &s)
+{
+	m_client->playlist.addUrl (s.toAscii ().constData ()) ();
+}
+void
+XMMSHandler::playlistRemove (uint pos)
+{ 
+	m_client->playlist.removeEntry (pos) ();
+}
+
+void
+XMMSHandler::playlistMove (uint pos, uint newpos)
+{
+	m_client->playlist.moveEntry (pos, newpos) ();
+}
+
+void
+XMMSHandler::requestMediainfo (uint id)
+{
+	m_client->medialib.getInfo (id) (Xmms::bind (&XMMSHandler::medialib_info, this));
+}
+
+void
+XMMSHandler::requestPlaylistList ()
+{
+//	m_client->playlist.listEntries () (Xmms::bind (&XMMSHandler::playlist_list, this));
+}
+
+void
+XMMSHandler::requestTrackChange (int pos)
+{
+	m_client->playlist.setNext (pos) ();
+	m_client->playback.tickle () ();
+}
+
+bool
+XMMSHandler::playlist_list (const Xmms::List< unsigned int > &playlist)
+{
+	emit playlistList (playlist);
+	return false;
+}
+
+bool
+XMMSHandler::playback_status (const Xmms::Playback::Status &status)
+{
+	emit playbackStatusChanged (status);
+	return true;
+}
+
+bool 
+XMMSHandler::playback_playtime (const unsigned int &time)
+{
+	emit playtimeChanged (time);
+	m_playtime_timer.start (500);
+	return false;
+}
+
+bool 
+XMMSHandler::playback_current_id (const unsigned int &id)
+{
+	m_currentid = id;
+
+	if (id > 0) {
+		requestMediainfo (id);
+	}
+
+	emit currentID(id);
+	return true;
+}
+
+void
+XMMSHandler::setPlaytime (uint pos)
+{
+	m_client->playback.seekMs (pos) ();
+}
+
+void
+XMMSHandler::DictToQHash (const std::string &key,
+                          const Xmms::Dict::Variant &value,
+                          QHash<QString, QString> &hash)
+{
+	if (value.type () == typeid (int32_t)) {
+		hash.insert (QString::fromLatin1 (key.c_str ()),
+		             QString::number (boost::get< int32_t > (value)));
+	} else if (value.type () == typeid (uint32_t)) {
+		hash.insert (QString::fromLatin1 (key.c_str ()),
+		             QString::number (boost::get< uint32_t > (value)));
+	} else if (value.type () == typeid (std::string)) {
+		hash.insert (QString::fromLatin1 (key.c_str ()),
+		             QString::fromUtf8 (boost::get< std::string > (value).c_str ()));
+	}
+}
+
+void
+XMMSHandler::PropDictToQHash (const std::string &key,
+                              const Xmms::Dict::Variant &value,
+                              const std::string &source,
+                              QHash<QString, QString> &hash)
+{
+	if (value.type () == typeid (int32_t)) {
+		hash.insert (QString::fromLatin1 (key.c_str ()),
+		             QString::number (boost::get< int32_t > (value)));
+	} else if (value.type () == typeid (uint32_t)) {
+		hash.insert (QString::fromLatin1 (key.c_str ()),
+		             QString::number (boost::get< uint32_t > (value)));
+	} else {
+		hash.insert (QString::fromLatin1 (key.c_str ()),
+		             QString::fromUtf8 (boost::get< std::string > (value).c_str()));
+	}
+}
+
+/*
+uint
+XMMSHandler::medialibQuery (QString q)
+{
+	XMMSResultDictList *r = m_xmmsc->medialib_select (q.toUtf8 ());
+	r->connect (sigc::mem_fun (this, &XMMSHandler::medialib_select));
+	m_mlibqs->append (r);
+}
+
+void
+XMMSHandler::medialib_select (XMMSResultDictList *res)
+{
+	QList<QHash<QString, QString> > l;
+
+	for (;res->listValid (); res->listNext()) {
+		QHash<QString, QString> h(DictToQHash (static_cast<XMMSResultDict *>(res)));
+		l.append (h);
+	}
+
+	emit medialibResponse (res->getCID (), l);
+}
+*/
+
+bool
+XMMSHandler::playlist_changed (const Xmms::Dict &list)
+{
+	emit playlistChanged (list);
+	return true;
+}
+
+bool 
+XMMSHandler::medialib_info (const Xmms::PropDict &propdict)
+{
+	unsigned int id = propdict.get<int32_t>("id");
+	emit mediainfoChanged (id, propdict);
+
+	if (id == m_currentid) {
+		emit currentSong (propdict);
+	}
+	return false;
+}
+
+bool
+XMMSHandler::volume_error (const std::string &error)
+{
+	qWarning ("couldn't get volume levels!");
+	return false;
+}
+
+void
+XMMSHandler::volumeGet ()
+{
+	m_client->playback.volumeGet () (Xmms::bind (&XMMSHandler::volume_get, this),
+	                             Xmms::bind (&XMMSHandler::volume_error, this));
+}
+
+void
+XMMSHandler::volumeSet (uint volume)
+{
+	if(m_masterchan)
+	{
+		m_client->playback.volumeSet ("master", volume) ();
+	}
+	else
+	{
+		m_client->playback.volumeSet ("left", volume) ();
+		m_client->playback.volumeSet ("right", volume) ();
+	}
+}
+
+bool
+XMMSHandler::volume_changed (const Xmms::Dict &levels)
+{
+	volume_get (levels);
+	return true;
+}
+
+bool
+XMMSHandler::volume_get (const Xmms::Dict &levels)
+{
+	QHash<QString, QString> hash;
+	levels.each (boost::bind (&XMMSHandler::DictToQHash, this,
+	                          _1, _2, boost::ref (hash)));
+	QList<QString> Values = hash.values();
+	QListIterator<QString> vol (Values);
+
+	uint right = atol (vol.next().toAscii());
+	if(vol.hasNext())
+	{
+		uint left = atol (vol.next().toAscii());
+	
+		if(left > right)
+			emit getVolume (left);
+		else
+			emit getVolume (right);
+
+		m_masterchan = false;
+	}
+	else
+	{
+		emit getVolume (right);
+		m_masterchan = true;
+	}
+	return false;
+
+}
+
+
+void XMMSHandler::playlistClear ()
+{
+	m_client->playlist.clear () ();
+}
+
+void XMMSHandler::play ()
+{
+	m_client->playback.start () ();
+}
+
+void XMMSHandler::stop ()
+{
+	m_client->playback.stop () ();
+}
+
+void XMMSHandler::pause ()
+{
+	m_client->playback.pause () ();
+}
+
+void XMMSHandler::next ()
+{
+	m_client->playlist.setNextRel (1) ();
+	m_client->playback.tickle () ();
+}
+
+void XMMSHandler::prev ()
+{
+	m_client->playlist.setNextRel (-1) ();
+	m_client->playback.tickle () ();
+}
+

src/XMMSHandler.h

@@ -0,0 +1,108 @@
+#ifndef __XMMS_HANDLER_H__
+#define __XMMS_HANDLER_H__
+
+#include <xmmsclient/xmmsclient++.h>
+
+#include "xclient.h"
+#include "xmmsqt4.h"
+
+#include <QObject>
+#include <QHash>
+#include <QTimer>
+
+class PlaylistModel;
+
+class XMMSHandler : public XClient {
+	Q_OBJECT
+	public:
+		static XMMSHandler &getInstance ();
+
+		XMMSHandler (QObject *parent, const std::string &name);
+		~XMMSHandler () {};
+
+		bool connect_handler (const char *ipcpath = NULL, const bool &sync = false, QWidget *parent = NULL);
+
+		bool playback_playtime (const unsigned int &time);
+		bool playlist_list (const Xmms::List< unsigned int > &playlist);
+		bool playback_current_id (const unsigned int &id);
+		bool medialib_info (const Xmms::PropDict &propdict);
+		bool medialib_entry_changed (const unsigned int &id);
+		bool playback_status (const Xmms::Playback::Status &status);
+		bool volume_changed (const Xmms::Dict &levels);
+		bool playlist_changed (const Xmms::Dict &list);
+
+		void requestMediainfo (uint id);
+		void requestPlaylistList ();
+		void requestTrackChange (int pos);
+		void playlistAddURL (const QString& url);
+		void playlistRemove (uint pos);
+		void playlistMove (uint pos, uint newpos);
+
+		/*
+		void medialib_select (XMMSResultDictList *res);
+
+
+		*/
+		/*
+		uint medialibQuery (QString);
+		void medialibQueryAdd (QString q) { delete m_xmmsc->medialib_add_to_playlist (q.toUtf8 ()); }
+		*/
+
+		void volumeGet ();
+
+		//const XMMSClient *getXMMS () { return m_xmmsc; }
+
+		void updateSettings () { emit settingsSaved (); }
+
+		Xmms::Client *getClient ();
+
+		PlaylistModel *getPlaylistModel () {return m_playlist_model; }
+
+	public slots:
+		void setPlaytime (uint pos);
+		void restartPlaytime ();
+
+		void playlistClear ();
+		void play ();
+		void stop ();
+		void pause ();
+		void next ();
+		void prev ();
+		void volumeSet (uint volume);
+
+	signals:
+		void settingsSaved ();
+		void playbackStatusChanged (Xmms::Playback::Status status);
+		void playtimeChanged (uint time);
+		void mediainfoChanged (uint, const Xmms::PropDict &);
+		void currentSong (const Xmms::PropDict &);
+		void playlistList (const Xmms::List< unsigned int > &);
+		void currentID (uint);
+		void playlistChanged (const Xmms::Dict &);
+		/*
+		void medialibResponse (uint, const QList<QHash<QString, QString> > &);
+		*/
+		void getVolume (uint);
+
+	private:
+		QTimer m_playtime_timer;
+
+		void DictToQHash (const std::string &key,
+		                  const Xmms::Dict::Variant &value,
+		                  QHash<QString, QString> &hash);
+	void PropDictToQHash (const std::string &key,
+		                      const Xmms::Dict::Variant &value,
+		                      const std::string &source,
+		                      QHash<QString, QString> &hash);
+
+		bool volume_get (const Xmms::Dict &levels);
+		bool volume_error (const std::string &error);
+
+		XmmsQT4 *m_qt4;
+		PlaylistModel *m_playlist_model;
+		unsigned int m_currentid;
+		bool m_masterchan;
+};
+
+#endif
+

src/avahi.prf

@@ -0,0 +1,4 @@
+SOURCES += ServerBrowser.cpp
+HEADERS += ServerBrowser.h
+PKGCONFIG += avahi-client avahi-qt4
+DEFINES += HAVE_SERVERBROWSER

src/promoe.qrc

@@ -0,0 +1,30 @@
+<!DOCTYPE RCC><RCC version="1.0">
+	<qresource>
+		<file>icon.png</file>
+		<file>noartist.png</file>
+		<file>nosong.png</file>
+		<file>noalbum.png</file>
+		<file>CleanAMP/Eq_ex.png</file>
+		<file>CleanAMP/GENEX.png</file>
+		<file>CleanAMP/Gen.png</file>
+		<file>CleanAMP/monoster.png</file>
+		<file>CleanAMP/PLEDIT.TXT</file>
+		<file>CleanAMP/ReadMe.txt</file>
+		<file>CleanAMP/Thumbs.db</file>
+		<file>CleanAMP/VIDEO.png</file>
+		<file>CleanAMP/Volume.png</file>
+		<file>CleanAMP/balance.png</file>
+		<file>CleanAMP/cbuttons.png</file>
+		<file>CleanAMP/eqmain.png</file>
+		<file>CleanAMP/main.png</file>
+		<file>CleanAMP/mb.png</file>
+		<file>CleanAMP/numbers.png</file>
+		<file>CleanAMP/playpaus.png</file>
+		<file>CleanAMP/pledit.png</file>
+		<file>CleanAMP/posbar.png</file>
+		<file>CleanAMP/shufrep.png</file>
+		<file>CleanAMP/text.png</file>
+		<file>CleanAMP/titlebar.png</file>
+		<file>CleanAMP/viscolor.txt</file>
+	</qresource>
+</RCC>

src/qtmd5.cpp

@@ -0,0 +1,348 @@
+/****************************************************************************
+**
+** Copyright (C) 1992-2006 Trolltech AS. All rights reserved.
+**
+** This file is part of the qmake application of the Qt Toolkit.
+**
+** This file may be used under the terms of the GNU General Public
+** License version 2.0 as published by the Free Software Foundation
+** and appearing in the file LICENSE.GPL included in the packaging of
+** this file.  Please review the following information to ensure GNU
+** General Public Licensing requirements will be met:
+** http://www.trolltech.com/products/qt/opensource.html
+**
+** If you are unsure which license is appropriate for your use, please
+** review the following information:
+** http://www.trolltech.com/products/qt/licensing.html or contact the
+** sales department at sales@trolltech.com.
+**
+** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
+** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+**
+****************************************************************************/
+
+/*
+    Copyright (C) 1991-2, RSA Data Security, Inc. Created 1991. All
+    rights reserved.
+
+    RSA Data Security, Inc. makes no representations concerning either
+    the merchantability of this software or the suitability of this
+    software for any particular purpose. It is provided "as is"
+    without express or implied warranty of any kind.
+
+    License to copy and use this software is granted provided that it
+    is identified as the "RSA Data Security, Inc. MD5 Message-Digest
+    Algorithm" in all material mentioning or referencing this software
+    or this function.
+
+    License is also granted to make and use derivative works provided
+    that such works are identified as "derived from the RSA Data
+    Security, Inc. MD5 Message-Digest Algorithm" in all material
+    mentioning or referencing the derived work.
+
+    These notices must be retained in any copies of any part of this
+    documentation and/or software.
+*/
+
+#include "qtmd5.h"
+
+typedef unsigned char *POINTER;
+typedef unsigned short int UINT2;
+typedef unsigned long int UINT4;
+
+typedef struct {
+    UINT4 state[4];            // state(ABCD)
+    UINT4 count[2];            // number of bits, modulo 2^64(lsb first)
+    unsigned char buffer[64];  // input buffer
+} MD5_CTX;
+
+static void MD5Init(MD5_CTX *);
+static void MD5Update(MD5_CTX *, unsigned char *, unsigned int);
+static void MD5Final(unsigned char [16], MD5_CTX *);
+static void MD5Transform(UINT4[4], unsigned char[64]);
+static void Encode(unsigned char *, UINT4 *, unsigned int);
+static void Decode(UINT4 *, unsigned char *, unsigned int);
+static void MD5_memset(POINTER, int, unsigned int);
+static void MD5_memcpy(POINTER output,POINTER input,unsigned int len);
+
+// Constants for MD5Transform routine.
+enum {
+    S11 = 7, S12 = 12, S13 = 17, S14 = 22, S21 = 5, S22 = 9,  S23 = 14, S24 = 20,
+    S31 = 4, S32 = 11, S33 = 16, S34 = 23, S41 = 6, S42 = 10, S43 = 15, S44 = 21
+};
+
+static unsigned char PADDING[64] = {
+    0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
+};
+
+// F, G, H and I are basic MD5 functions.
+static inline UINT4 F(UINT4 x, UINT4 y, UINT4 z)
+{
+    return (x & y) |((~x) & z);
+}
+
+static inline UINT4 G(UINT4 x, UINT4 y, UINT4 z)
+{
+    return (x & z) |(y &(~z));
+}
+
+static inline UINT4 H(UINT4 x, UINT4 y, UINT4 z)
+{
+    return x ^ y ^ z;
+}
+
+static inline UINT4 I(UINT4 x, UINT4 y, UINT4 z)
+{
+    return y ^(x |(~z));
+}
+
+static inline UINT4 rotateLeft(UINT4 x, UINT4 n)
+{
+    return (x << n) |(x >>(32-(n)));
+}
+
+// FF, GG, HH, and II transformations for rounds 1, 2, 3, and 4.
+// Rotation is separate from addition to prevent recomputation.
+static inline void FF(UINT4 &a, UINT4 b, UINT4 c, UINT4 d, UINT4 x, UINT4 s, UINT4 ac)
+{
+    a += F(b, c, d) + x + ac;
+    a = rotateLeft(a, s);
+    a += b;
+}
+
+static inline void GG(UINT4 &a, UINT4 b, UINT4 c, UINT4 d, UINT4 x, UINT4 s, UINT4 ac)
+{
+    a += G(b, c, d) + x +(UINT4)(ac);
+    a = rotateLeft(a, s);
+    a += b;
+}
+
+static inline void HH(UINT4 &a, UINT4 b, UINT4 c, UINT4 d, UINT4 x, UINT4 s, UINT4 ac)
+{
+    a += H(b, c, d) + x +(UINT4)(ac);
+    a = rotateLeft(a, s);
+    a += b;
+}
+
+static inline void II(UINT4 &a, UINT4 b, UINT4 c, UINT4 d, UINT4 x, UINT4 s, UINT4 ac)
+{
+    a += I(b, c, d) + x +(UINT4)(ac);
+    a = rotateLeft(a, s);
+    a += b;
+}
+
+// MD5 initialization. Begins an MD5 operation, writing a new context.
+static void MD5Init(MD5_CTX *context)
+{
+    context->count[0] = context->count[1] = 0;
+
+    // Load magic initialization constants.
+    context->state[0] = 0x67452301;
+    context->state[1] = 0xefcdab89;
+    context->state[2] = 0x98badcfe;
+    context->state[3] = 0x10325476;
+}
+
+// MD5 block update operation. Continues an MD5 message-digest
+// operation, processing another message block, and updating the
+// context.
+static void MD5Update(MD5_CTX *context, unsigned char *input, unsigned int inputLen)
+{
+    unsigned int i, index, partLen;
+    // Compute number of bytes mod 64
+    index =(unsigned int)((context->count[0] >> 3) & 0x3F);
+
+    // Update number of bits
+    if ((context->count[0] +=((UINT4)inputLen << 3)) <((UINT4)inputLen << 3))
+        context->count[1]++;
+
+    context->count[1] +=((UINT4)inputLen >> 29);
+    partLen = 64 - index;
+
+    // Transform as many times as possible.
+    if (inputLen >= partLen) {
+        MD5_memcpy((POINTER)&context->buffer[index],(POINTER)input, partLen);
+        MD5Transform(context->state, context->buffer);
+        for (i = partLen; i + 63 < inputLen; i += 64)
+            MD5Transform(context->state, &input[i]);
+        index = 0;
+    } else {
+        i = 0;
+    }
+
+    // Buffer remaining input
+    MD5_memcpy((POINTER)&context->buffer[index],(POINTER)&input[i],
+               inputLen-i);
+}
+
+// MD5 finalization. Ends an MD5 message-digest operation, writing the
+// the message digest and zeroizing the context.
+static void MD5Final(unsigned char digest[16], MD5_CTX *context)
+{
+    unsigned char bits[8];
+    unsigned int index, padLen;
+
+    // Save number of bits
+    Encode(bits, context->count, 8);
+
+    // Pad out to 56 mod 64.
+    index =(unsigned int)((context->count[0] >> 3) & 0x3f);
+    padLen =(index < 56) ?(56 - index) :(120 - index);
+    MD5Update(context, PADDING, padLen);
+
+    // Append length(before padding)
+    MD5Update(context, bits, 8);
+
+    // Store state in digest
+    Encode(digest, context->state, 16);
+
+    // Zeroize sensitive information.
+    MD5_memset((POINTER)context, 0, sizeof(*context));
+}
+
+// MD5 basic transformation. Transforms state based on block.
+static void MD5Transform(UINT4 state[4], unsigned char block[64])
+{
+    UINT4 a = state[0], b = state[1], c = state[2], d = state[3], x[16];
+    Decode(x, block, 64);
+
+    // Round 1
+    FF(a, b, c, d, x[0], S11, 0xd76aa478); /* 1 */
+    FF(d, a, b, c, x[1], S12, 0xe8c7b756); /* 2 */
+    FF(c, d, a, b, x[2], S13, 0x242070db); /* 3 */
+    FF(b, c, d, a, x[3], S14, 0xc1bdceee); /* 4 */
+    FF(a, b, c, d, x[4], S11, 0xf57c0faf); /* 5 */
+    FF(d, a, b, c, x[5], S12, 0x4787c62a); /* 6 */
+    FF(c, d, a, b, x[6], S13, 0xa8304613); /* 7 */
+    FF(b, c, d, a, x[7], S14, 0xfd469501); /* 8 */
+    FF(a, b, c, d, x[8], S11, 0x698098d8); /* 9 */
+    FF(d, a, b, c, x[9], S12, 0x8b44f7af); /* 10 */
+    FF(c, d, a, b, x[10], S13, 0xffff5bb1); /* 11 */
+    FF(b, c, d, a, x[11], S14, 0x895cd7be); /* 12 */
+    FF(a, b, c, d, x[12], S11, 0x6b901122); /* 13 */
+    FF(d, a, b, c, x[13], S12, 0xfd987193); /* 14 */
+    FF(c, d, a, b, x[14], S13, 0xa679438e); /* 15 */
+    FF(b, c, d, a, x[15], S14, 0x49b40821); /* 16 */
+
+    // Round 2
+    GG(a, b, c, d, x[1], S21, 0xf61e2562); /* 17 */
+    GG(d, a, b, c, x[6], S22, 0xc040b340); /* 18 */
+    GG(c, d, a, b, x[11], S23, 0x265e5a51); /* 19 */
+    GG(b, c, d, a, x[0], S24, 0xe9b6c7aa); /* 20 */
+    GG(a, b, c, d, x[5], S21, 0xd62f105d); /* 21 */
+    GG(d, a, b, c, x[10], S22,  0x2441453); /* 22 */
+    GG(c, d, a, b, x[15], S23, 0xd8a1e681); /* 23 */
+    GG(b, c, d, a, x[4], S24, 0xe7d3fbc8); /* 24 */
+    GG(a, b, c, d, x[9], S21, 0x21e1cde6); /* 25 */
+    GG(d, a, b, c, x[14], S22, 0xc33707d6); /* 26 */
+    GG(c, d, a, b, x[3], S23, 0xf4d50d87); /* 27 */
+    GG(b, c, d, a, x[8], S24, 0x455a14ed); /* 28 */
+    GG(a, b, c, d, x[13], S21, 0xa9e3e905); /* 29 */
+    GG(d, a, b, c, x[2], S22, 0xfcefa3f8); /* 30 */
+    GG(c, d, a, b, x[7], S23, 0x676f02d9); /* 31 */
+    GG(b, c, d, a, x[12], S24, 0x8d2a4c8a); /* 32 */
+
+    // Round 3
+    HH(a, b, c, d, x[5], S31, 0xfffa3942); /* 33 */
+    HH(d, a, b, c, x[8], S32, 0x8771f681); /* 34 */
+    HH(c, d, a, b, x[11], S33, 0x6d9d6122); /* 35 */
+    HH(b, c, d, a, x[14], S34, 0xfde5380c); /* 36 */
+    HH(a, b, c, d, x[1], S31, 0xa4beea44); /* 37 */
+    HH(d, a, b, c, x[4], S32, 0x4bdecfa9); /* 38 */
+    HH(c, d, a, b, x[7], S33, 0xf6bb4b60); /* 39 */
+    HH(b, c, d, a, x[10], S34, 0xbebfbc70); /* 40 */
+    HH(a, b, c, d, x[13], S31, 0x289b7ec6); /* 41 */
+    HH(d, a, b, c, x[0], S32, 0xeaa127fa); /* 42 */
+    HH(c, d, a, b, x[3], S33, 0xd4ef3085); /* 43 */
+    HH(b, c, d, a, x[6], S34,  0x4881d05); /* 44 */
+    HH(a, b, c, d, x[9], S31, 0xd9d4d039); /* 45 */
+    HH(d, a, b, c, x[12], S32, 0xe6db99e5); /* 46 */
+    HH(c, d, a, b, x[15], S33, 0x1fa27cf8); /* 47 */
+    HH(b, c, d, a, x[2], S34, 0xc4ac5665); /* 48 */
+
+    // Round 4
+    II(a, b, c, d, x[0], S41, 0xf4292244); /* 49 */
+    II(d, a, b, c, x[7], S42, 0x432aff97); /* 50 */
+    II(c, d, a, b, x[14], S43, 0xab9423a7); /* 51 */
+    II(b, c, d, a, x[5], S44, 0xfc93a039); /* 52 */
+    II(a, b, c, d, x[12], S41, 0x655b59c3); /* 53 */
+    II(d, a, b, c, x[3], S42, 0x8f0ccc92); /* 54 */
+    II(c, d, a, b, x[10], S43, 0xffeff47d); /* 55 */
+    II(b, c, d, a, x[1], S44, 0x85845dd1); /* 56 */
+    II(a, b, c, d, x[8], S41, 0x6fa87e4f); /* 57 */
+    II(d, a, b, c, x[15], S42, 0xfe2ce6e0); /* 58 */
+    II(c, d, a, b, x[6], S43, 0xa3014314); /* 59 */
+    II(b, c, d, a, x[13], S44, 0x4e0811a1); /* 60 */
+    II(a, b, c, d, x[4], S41, 0xf7537e82); /* 61 */
+    II(d, a, b, c, x[11], S42, 0xbd3af235); /* 62 */
+    II(c, d, a, b, x[2], S43, 0x2ad7d2bb); /* 63 */
+    II(b, c, d, a, x[9], S44, 0xeb86d391); /* 64 */
+    state[0] += a;
+    state[1] += b;
+    state[2] += c;
+    state[3] += d;
+
+    // Zeroize sensitive information.
+    MD5_memset((POINTER)x, 0, sizeof(x));
+}
+
+// Encodes input(UINT4) into output(unsigned char). Assumes len is a
+// multiple of 4.
+static void Encode(unsigned char *output, UINT4 *input, unsigned int len)
+{
+    unsigned int i, j;
+    for (i = 0, j = 0; j < len; i++, j += 4) {
+        output[j] = (unsigned char) (input[i] & 0xff);
+        output[j+1] = (unsigned char) ((input[i] >> 8) & 0xff);
+        output[j+2] = (unsigned char) ((input[i] >> 16) & 0xff);
+        output[j+3] = (unsigned char) ((input[i] >> 24) & 0xff);
+    }
+}
+
+// Decodes input(unsigned char) into output(UINT4). Assumes len is a
+// multiple of 4.
+static void Decode(UINT4 *output, unsigned char *input, unsigned int len)
+{
+    unsigned int i, j;
+    for (i = 0, j = 0; j < len; i++, j += 4)
+        output[i] =((UINT4)input[j]) |(((UINT4)input[j+1]) << 8) |
+                  (((UINT4)input[j+2]) << 16) |(((UINT4)input[j+3]) << 24);
+}
+
+// Note: Replace "for loop" with standard memset if possible.
+static void MD5_memset(POINTER output, int value, unsigned int len)
+{
+    unsigned int i;
+    for (i = 0; i < len; i++)
+        ((char *)output)[i] =(char)value;
+}
+
+// Note: Replace "for loop" with standard memcpy if possible.
+static void MD5_memcpy(POINTER output,POINTER input,unsigned int len)
+{
+    unsigned int i;
+    for (i = 0; i < len; i++)
+        output[i] = input[i];
+}
+
+void qtMD5(const QByteArray &src, unsigned char *digest)
+{
+    MD5_CTX context;
+
+    MD5Init(&context);
+    MD5Update(&context, (unsigned char *) src.data(), src.size());
+    MD5Final(digest, &context);
+}
+
+QString qtMD5(const QByteArray &src)
+{
+    unsigned char digest[16];
+    qtMD5(src, digest);
+
+    QString output, tmp;
+    for (int i = 0; i < 16; ++i)
+        output += tmp.sprintf("%02x", digest[i]);
+    return output;
+}

src/qtmd5.h

@@ -0,0 +1,56 @@
+/****************************************************************************
+**
+** Copyright (C) 1992-2006 Trolltech AS. All rights reserved.
+**
+** This file is part of the qmake application of the Qt Toolkit.
+**
+** This file may be used under the terms of the GNU General Public
+** License version 2.0 as published by the Free Software Foundation
+** and appearing in the file LICENSE.GPL included in the packaging of
+** this file.  Please review the following information to ensure GNU
+** General Public Licensing requirements will be met:
+** http://www.trolltech.com/products/qt/opensource.html
+**
+** If you are unsure which license is appropriate for your use, please
+** review the following information:
+** http://www.trolltech.com/products/qt/licensing.html or contact the
+** sales department at sales@trolltech.com.
+**
+** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
+** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+**
+****************************************************************************/
+
+/*
+    Copyright (C) 1991-2, RSA Data Security, Inc. Created 1991. All
+    rights reserved.
+
+    RSA Data Security, Inc. makes no representations concerning either
+    the merchantability of this software or the suitability of this
+    software for any particular purpose. It is provided "as is"
+    without express or implied warranty of any kind.
+
+    License to copy and use this software is granted provided that it
+    is identified as the "RSA Data Security, Inc. MD5 Message-Digest
+    Algorithm" in all material mentioning or referencing this software
+    or this function.
+
+    License is also granted to make and use derivative works provided
+    that such works are identified as "derived from the RSA Data
+    Security, Inc. MD5 Message-Digest Algorithm" in all material
+    mentioning or referencing the derived work.
+
+    These notices must be retained in any copies of any part of this
+    documentation and/or software.
+*/
+
+#ifndef QTMD5_H
+#define QTMD5_H
+
+#include <qstring.h>
+#include <qbytearray.h>
+
+void qtMD5(const QByteArray &src, unsigned char *digest);
+QString qtMD5(const QByteArray &src);
+
+#endif // QTMD5_H

src/src.pro

@@ -0,0 +1,89 @@
+TEMPLATE = app
+
+include (../config.pri)
+
+COMPONENTS+=../lib/liblib.a
+LIBS += $$COMPONENTS
+PRE_TARGETDEPS = $$COMPONENTS
+
+SOURCES += PixWidget.cpp \
+		   Skin.cpp \
+		   MainWindow.cpp \
+		   Display.cpp \
+		   MainDisplay.cpp \
+		   TitleBar.cpp \
+		   Button.cpp \
+		   TextBar.cpp \
+		   NumberDisplay.cpp \
+		   TimeDisplay.cpp \
+		   XMMSHandler.cpp \
+		   SmallNumberDisplay.cpp \
+		   StereoMono.cpp \
+		   PosBar.cpp \
+		   PlayStatus.cpp \
+		   ShadedDisplay.cpp \
+		   Playlist.cpp \
+		   PlaylistView.cpp \
+		   SkinChooser.cpp \
+		   PlaylistShade.cpp \
+		   qtmd5.cpp \
+		   SettingsWindow.cpp \
+		   PlaylistMenu.cpp \
+		   VolumeSlider.cpp \
+		   ClutterBar.cpp \
+		   Equalizer.cpp \
+		   FileDialog.cpp \
+		   BrowseModel.cpp \
+		   BrowseDialog.cpp
+
+
+HEADERS += PixWidget.h \
+		   Skin.h \
+		   MainWindow.h \
+		   Display.h \
+		   MainDisplay.h \
+		   TitleBar.h \
+		   Button.h \
+		   TextBar.h \
+		   NumberDisplay.h \
+		   TimeDisplay.h \
+		   XMMSHandler.h \
+		   SmallNumberDisplay.h \
+		   StereoMono.h \
+		   PosBar.h \
+		   PlayStatus.h \
+		   ShadedDisplay.h \
+		   Playlist.h \
+		   PlaylistView.h \
+		   SkinChooser.h \
+		   PlaylistShade.h \
+		   qtmd5.h \
+		   SettingsWindow.h \
+		   PlaylistMenu.h \
+		   VolumeSlider.h \
+		   ClutterBar.h \
+		   Equalizer.h \
+		   FileDialog.h \
+		   BrowseModel.h \
+		   BrowseDialog.h
+
+TARGET = promoe
+DESTDIR = $$PWD/..
+
+RESOURCES = promoe.qrc
+macx:RC_FILE = promoe.icns
+macx:INCLUDEPATH = /sw/include
+
+QT += network
+;macx:QTPLUGIN += qjpeg
+QMAKE_LFLAGS += -L$$[QT_INSTALL_PLUGINS]/imageformats
+
+CONFIG += link_pkgconfig
+
+QMAKE_CXXFLAGS += -g
+;CONFIG += debug warn_on
+QMAKE_CXXFLAGS_WARN_ON += -Wno-unused-parameter
+PKGCONFIG += xmms2-client xmms2-client-cpp
+
+;CONFIG += avahi
+

src/xmmsclient_methods.h

@@ -0,0 +1,66 @@
+#ifndef XMMSCLIENTPP_METHODS_H
+#define XMMSCLIENTPP_METHODS_H
+XMMSResult *quit (void) { return new XMMSResult (xmmsc_quit (m_xmmsc)); }
+XMMSResult *plugin_list (uint32_t x) { return new XMMSResult (xmmsc_plugin_list (m_xmmsc, x)); }
+XMMSResult *main_stats (void) { return new XMMSResult (xmmsc_main_stats (m_xmmsc)); }
+XMMSResult *broadcast_quit (void) { return new XMMSResult (xmmsc_broadcast_quit (m_xmmsc)); }
+XMMSResult *playlist_shuffle (void) { return new XMMSResult (xmmsc_playlist_shuffle (m_xmmsc)); }
+XMMSResult *playlist_add (const char * x) { return new XMMSResult (xmmsc_playlist_add (m_xmmsc, x)); }
+XMMSResult *playlist_add_id (uint32_t x) { return new XMMSResult (xmmsc_playlist_add_id (m_xmmsc, x)); }
+XMMSResult *playlist_remove (uint32_t x) { return new XMMSResult (xmmsc_playlist_remove (m_xmmsc, x)); }
+XMMSResult *playlist_clear (void) { return new XMMSResult (xmmsc_playlist_clear (m_xmmsc)); }
+XMMSResultValueList<uint> *playlist_list (void) { return new XMMSResultValueList<uint> (xmmsc_playlist_list (m_xmmsc)); }
+XMMSResult *playlist_sort (char* x) { return new XMMSResult (xmmsc_playlist_sort (m_xmmsc, x)); }
+XMMSResult *playlist_set_next (uint32_t x) { return new XMMSResult (xmmsc_playlist_set_next (m_xmmsc, x)); }
+XMMSResult *playlist_set_next_rel (int32_t x) { return new XMMSResult (xmmsc_playlist_set_next_rel (m_xmmsc, x)); }
+XMMSResult *playlist_move (uint32_t x,uint32_t y) { return new XMMSResult (xmmsc_playlist_move (m_xmmsc, x, y)); }
+XMMSResultValue<uint> *playlist_current_pos (void) { return new XMMSResultValue<uint> (xmmsc_playlist_current_pos (m_xmmsc)); }
+XMMSResult *playlist_insert (int x,char * y) { return new XMMSResult (xmmsc_playlist_insert (m_xmmsc, x, y)); }
+XMMSResult *playlist_insert_id (int x,uint32_t y) { return new XMMSResult (xmmsc_playlist_insert_id (m_xmmsc, x, y)); }
+XMMSResultDict *broadcast_playlist_changed (void) { return new XMMSResultDict (xmmsc_broadcast_playlist_changed (m_xmmsc)); }
+XMMSResultValue<uint> *broadcast_playlist_current_pos (void) { return new XMMSResultValue<uint> (xmmsc_broadcast_playlist_current_pos (m_xmmsc)); }
+XMMSResult *playback_stop (void) { return new XMMSResult (xmmsc_playback_stop (m_xmmsc)); }
+XMMSResult *playback_tickle (void) { return new XMMSResult (xmmsc_playback_tickle (m_xmmsc)); }
+XMMSResult *playback_start (void) { return new XMMSResult (xmmsc_playback_start (m_xmmsc)); }
+XMMSResult *playback_pause (void) { return new XMMSResult (xmmsc_playback_pause (m_xmmsc)); }
+XMMSResultValue<uint> *playback_current_id (void) { return new XMMSResultValue<uint> (xmmsc_playback_current_id (m_xmmsc)); }
+XMMSResult *playback_seek_ms (uint32_t x) { return new XMMSResult (xmmsc_playback_seek_ms (m_xmmsc, x)); }
+XMMSResult *playback_seek_ms_rel (int x) { return new XMMSResult (xmmsc_playback_seek_ms_rel (m_xmmsc, x)); }
+XMMSResult *playback_seek_samples (uint32_t x) { return new XMMSResult (xmmsc_playback_seek_samples (m_xmmsc, x)); }
+XMMSResult *playback_seek_samples_rel (int x) { return new XMMSResult (xmmsc_playback_seek_samples_rel (m_xmmsc, x)); }
+XMMSResultValue<uint> *playback_playtime (void) { return new XMMSResultValue<uint> (xmmsc_playback_playtime (m_xmmsc)); }
+XMMSResultValue<uint> *playback_status (void) { return new XMMSResultValue<uint> (xmmsc_playback_status (m_xmmsc)); }
+XMMSResult *playback_volume_set (const char * x,uint32_t y) { return new XMMSResult (xmmsc_playback_volume_set (m_xmmsc, x, y)); }
+XMMSResultDict *playback_volume_get (void) { return new XMMSResultDict (xmmsc_playback_volume_get (m_xmmsc)); }
+XMMSResult *broadcast_playback_volume_changed (void) { return new XMMSResult (xmmsc_broadcast_playback_volume_changed (m_xmmsc)); }
+XMMSResultValue<uint> *broadcast_playback_status (void) { return new XMMSResultValue<uint> (xmmsc_broadcast_playback_status (m_xmmsc)); }
+XMMSResultValue<uint> *broadcast_playback_current_id (void) { return new XMMSResultValue<uint> (xmmsc_broadcast_playback_current_id (m_xmmsc)); }
+XMMSResultValue<uint> *signal_playback_playtime (void) { return new XMMSResultValue<uint> (xmmsc_signal_playback_playtime (m_xmmsc)); }
+XMMSResult *configval_set (char * x,char * y) { return new XMMSResult (xmmsc_configval_set (m_xmmsc, x, y)); }
+XMMSResultValueList<char*> *configval_list (void) { return new XMMSResultValueList<char*> (xmmsc_configval_list (m_xmmsc)); }
+XMMSResultValue<char*> *configval_get (char * x) { return new XMMSResultValue<char*> (xmmsc_configval_get (m_xmmsc, x)); }
+XMMSResult *configval_register (char * x,char * y) { return new XMMSResult (xmmsc_configval_register (m_xmmsc, x, y)); }
+XMMSResultValue<char*> *broadcast_configval_changed (void) { return new XMMSResultValue<char*> (xmmsc_broadcast_configval_changed (m_xmmsc)); }
+XMMSResult *broadcast_mediainfo_reader_status (void) { return new XMMSResult (xmmsc_broadcast_mediainfo_reader_status (m_xmmsc)); }
+XMMSResult *signal_visualisation_data (void) { return new XMMSResult (xmmsc_signal_visualisation_data (m_xmmsc)); }
+XMMSResult *signal_mediainfo_reader_unindexed (void) { return new XMMSResult (xmmsc_signal_mediainfo_reader_unindexed (m_xmmsc)); }
+XMMSResultDictList *medialib_select (const char * x) { return new XMMSResultDictList (xmmsc_medialib_select (m_xmmsc, x)); }
+XMMSResult *medialib_playlist_save_current (const char * x) { return new XMMSResult (xmmsc_medialib_playlist_save_current (m_xmmsc, x)); }
+XMMSResult *medialib_playlist_load (const char * x) { return new XMMSResult (xmmsc_medialib_playlist_load (m_xmmsc, x)); }
+XMMSResult *medialib_add_entry (const char * x) { return new XMMSResult (xmmsc_medialib_add_entry (m_xmmsc, x)); }
+XMMSResultDict *medialib_get_info (uint32_t x) { return new XMMSResultDict (xmmsc_medialib_get_info (m_xmmsc, x)); }
+XMMSResult *medialib_add_to_playlist (const char * x) { return new XMMSResult (xmmsc_medialib_add_to_playlist (m_xmmsc, x)); }
+XMMSResultValueList<char*> *medialib_playlists_list (void) { return new XMMSResultValueList<char*> (xmmsc_medialib_playlists_list (m_xmmsc)); }
+XMMSResultValueList<uint> *medialib_playlist_list (const char * x) { return new XMMSResultValueList<uint> (xmmsc_medialib_playlist_list (m_xmmsc, x)); }
+XMMSResult *medialib_playlist_import (const char * x,const char * y) { return new XMMSResult (xmmsc_medialib_playlist_import (m_xmmsc, x, y)); }
+XMMSResult *medialib_playlist_export (const char * x,const char * y) { return new XMMSResult (xmmsc_medialib_playlist_export (m_xmmsc, x, y)); }
+XMMSResult *medialib_playlist_remove (const char * x) { return new XMMSResult (xmmsc_medialib_playlist_remove (m_xmmsc, x)); }
+XMMSResult *medialib_path_import (const char * x) { return new XMMSResult (xmmsc_medialib_path_import (m_xmmsc, x)); }
+XMMSResult *medialib_rehash (uint32_t x) { return new XMMSResult (xmmsc_medialib_rehash (m_xmmsc, x)); }
+XMMSResult *medialib_get_id (const char * x) { return new XMMSResult (xmmsc_medialib_get_id (m_xmmsc, x)); }
+XMMSResult *medialib_remove_entry (int32_t x) { return new XMMSResult (xmmsc_medialib_remove_entry (m_xmmsc, x)); }
+XMMSResult *medialib_entry_property_set (uint32_t x,char * y,char * z) { return new XMMSResult (xmmsc_medialib_entry_property_set (m_xmmsc, x, y, z)); }
+XMMSResult *medialib_entry_property_set_with_source (uint32_t x,char * y,char * z,char * w) { return new XMMSResult (xmmsc_medialib_entry_property_set_with_source (m_xmmsc, x, y, z, w)); }
+XMMSResultValue<uint> *broadcast_medialib_entry_changed (void) { return new XMMSResultValue<uint> (xmmsc_broadcast_medialib_entry_changed (m_xmmsc)); }
+XMMSResult *broadcast_medialib_playlist_loaded (void) { return new XMMSResult (xmmsc_broadcast_medialib_playlist_loaded (m_xmmsc)); }
+#endif

src/xmmsclient_promoe.cpp

@@ -0,0 +1,112 @@
+#include <xmmsclient/xmmsclient.h>
+#include <sigc++/sigc++.h>
+
+#include "xmmsclient_promoe.h"
+
+static
+void generic_handler (xmmsc_result_t *res, void *userdata)
+{
+	XMMSResult* r = static_cast<XMMSResult*>(userdata);
+	if (!r) {
+		cout << "********* FATAL ERROR ***********" << endl;
+		cout << "The generic handler was called without a result!" << endl;
+		return;
+	}
+	r->emit ();
+}
+
+XMMSClient::XMMSClient (const char *name)
+{
+	m_xmmsc = xmmsc_init (name);
+}
+
+bool
+XMMSClient::connect (const char *path)
+{
+	if (!xmmsc_connect (m_xmmsc, path)) {
+		return false;
+	}
+
+	return true;
+}
+
+XMMSClient::~XMMSClient ()
+{
+	xmmsc_unref (m_xmmsc);
+}
+
+XMMSResult::XMMSResult (xmmsc_result_t *res)
+  : m_res(res), m_inited(false), m_signal()
+{
+}
+
+XMMSResult::XMMSResult (const XMMSResult &src)
+  : m_res(src.m_res)
+{
+}
+
+void
+XMMSResult::restart (void)
+{
+	xmmsc_result_t *nres;
+	nres = xmmsc_result_restart (m_res);
+	xmmsc_result_unref (m_res);
+	xmmsc_result_unref (nres);
+	m_res = nres;
+}
+
+void
+XMMSResult::connect (const sigc::slot<void, XMMSResult*>& slot_)
+{
+	if (!m_inited) {
+		xmmsc_result_notifier_set (m_res, &generic_handler, this);
+		m_inited = true;
+	}
+	m_signal.connect (slot_);
+}
+
+static void
+dict_foreach (const void *key, 
+			  xmmsc_result_value_type_t type, 
+			  const void *value, 
+			  void *udata)
+{
+	list<const char *> *i (static_cast<list<const char*>*>(udata));
+	i->push_front (static_cast<const char*>(key));
+}
+
+list<const char *>
+XMMSResultDict::getDictKeys (void)
+{
+	list<const char *> i;
+
+	xmmsc_result_dict_foreach (m_res, dict_foreach, static_cast<void*>(&i));
+
+	return i;
+}
+
+static void
+propdict_foreach (const void *key, 
+			  xmmsc_result_value_type_t type, 
+			  const void *value, 
+			  const char *source,
+			  void *udata)
+{
+	list<const char *> *i (static_cast<list<const char*>*>(udata));
+	i->push_front (static_cast<const char*>(key));
+}
+
+list<const char *>
+XMMSResultDict::getPropDictKeys (void)
+{
+	list<const char *> i;
+
+	xmmsc_result_propdict_foreach (m_res, propdict_foreach, static_cast<void*>(&i));
+
+	return i;
+}
+
+XMMSResult::~XMMSResult ()
+{
+	xmmsc_result_unref (m_res);
+}

src/xmmsclient_promoe.h

@@ -0,0 +1,199 @@
+#ifndef __XMMSCLIENTPP_H
+#define __XMMSCLIENTPP_H
+
+#include <sigc++/sigc++.h>
+#include <iostream>
+#include <xmmsclient/xmmsclient.h>
+
+using namespace std;
+
+
+class XMMSResult
+{
+	public:
+		XMMSResult (xmmsc_result_t*);
+		XMMSResult (const XMMSResult &);
+		virtual ~XMMSResult ();
+
+		uint getClass (void) { return xmmsc_result_get_class (m_res); }
+		uint getType (void) { return xmmsc_result_get_type (m_res); }
+		void restart (void);
+		
+		/* error */
+		bool isError (void) { return xmmsc_result_iserror (m_res); }
+		const char *getError (void) { return xmmsc_result_get_error (m_res); }
+
+		/* wait for this resultset */
+		void wait (void) const { xmmsc_result_wait (m_res); }
+
+		void connect (const sigc::slot<void, XMMSResult*>& slot_);
+		void emit (void) { m_signal.emit(this); }
+
+	protected:
+		xmmsc_result_t *m_res;
+
+		bool m_inited;
+		sigc::signal<void, XMMSResult*> m_signal;
+};
+
+
+class XMMSResultList
+{
+	public:
+		XMMSResultList (xmmsc_result_t* res) : m_list_res(res) { }
+		XMMSResultList (const XMMSResultList &src) : m_list_res(src.m_list_res) { }
+		virtual ~XMMSResultList () { }
+
+		bool listValid (void) { return xmmsc_result_list_valid (m_list_res); }
+		bool listNext (void)  { return xmmsc_result_list_next (m_list_res); }
+		bool listFirst (void) { return xmmsc_result_list_first (m_list_res); }
+
+		bool isList (void) { return xmmsc_result_is_list (m_list_res); }
+
+	private:
+		xmmsc_result_t *m_list_res;
+};
+
+
+class XMMSResultDict : public XMMSResult
+{
+	public:
+		XMMSResultDict (xmmsc_result_t* res) : XMMSResult(res) { }
+		XMMSResultDict (const XMMSResultDict &src) : XMMSResult(src) { }
+		virtual ~XMMSResultDict () { }
+	
+		void connect (const sigc::slot<void, XMMSResultDict*>& slot_) {
+			XMMSResult::connect(sigc::retype(slot_));
+		}
+
+		std::list<const char*> getPropDictKeys ();
+		std::list<const char*> getDictKeys ();
+
+		uint getDictValueType (const char *key) {
+			return xmmsc_result_get_dict_entry_type (m_res, key);
+		}
+
+		int entryFormat (char *target, int len, const char *format) {
+			return xmmsc_entry_format (target, len, format, m_res);
+		}
+
+		bool getValue (const char* key, int *var) {
+			return xmmsc_result_get_dict_entry_int32 (m_res, key, var); 
+		}
+		bool getValue (const char* key, uint *var) {
+			return xmmsc_result_get_dict_entry_uint32 (m_res, key, var); 
+		}
+		bool getValue (const char* key, char **var) {
+			return xmmsc_result_get_dict_entry_str (m_res, key, var); 
+		}
+};
+
+
+template <class T>
+class XMMSResultValue : public XMMSResult
+{
+	public:
+		XMMSResultValue (xmmsc_result_t* res) : XMMSResult(res) { }
+		XMMSResultValue (const XMMSResultValue<T> &src) : XMMSResult(src) { }
+		virtual ~XMMSResultValue () { }
+
+		void connect (const sigc::slot<void, XMMSResultValue<T>*>& slot_) = 0;
+		bool getValue (T *var) = 0;
+};
+
+template <>
+class XMMSResultValue<int> : public XMMSResult
+{
+	public:
+		XMMSResultValue (xmmsc_result_t* res) : XMMSResult(res) { }
+		XMMSResultValue (const XMMSResultValue<int> &src) : XMMSResult(src) { }
+		virtual ~XMMSResultValue () { }
+
+		void connect (const sigc::slot<void, XMMSResultValue<int>*>& slot_) {
+			XMMSResult::connect(sigc::retype(slot_));
+		}
+
+		bool getValue (int *var) { return xmmsc_result_get_int (m_res, var); }
+};
+
+template <>
+class XMMSResultValue<uint> : public XMMSResult
+{
+	public:
+		XMMSResultValue (xmmsc_result_t* res) : XMMSResult(res) { }
+		XMMSResultValue (const XMMSResultValue<uint> &src) : XMMSResult(src) { }
+		virtual ~XMMSResultValue () { }
+
+		void connect (const sigc::slot<void, XMMSResultValue<uint>*>& slot_) {
+			XMMSResult::connect(sigc::retype(slot_));
+		}
+
+		bool getValue (uint *var) { return xmmsc_result_get_uint (m_res, var); }
+};
+
+template <>
+class XMMSResultValue<char*> : public XMMSResult
+{
+	public:
+		XMMSResultValue (xmmsc_result_t* res) : XMMSResult(res) { }
+		XMMSResultValue (const XMMSResultValue<char*> &src) : XMMSResult(src) { }
+		virtual ~XMMSResultValue () { }
+
+		void connect (const sigc::slot<void, XMMSResultValue<char*>*>& slot_) {
+			XMMSResult::connect(sigc::retype(slot_));
+		}
+
+		bool getValue (char **var) { return xmmsc_result_get_string (m_res, var); }
+};
+
+
+template <class T>
+class XMMSResultValueList : public XMMSResultList, public XMMSResultValue<T>
+{
+	public:
+		XMMSResultValueList (xmmsc_result_t* res)
+		  : XMMSResultList(res), XMMSResultValue<T>(res) { }
+		XMMSResultValueList (const XMMSResultValueList<T> &src)
+		  : XMMSResultList(src), XMMSResultValue<T>(src) { }
+		virtual ~XMMSResultValueList() { }
+
+		void connect (const sigc::slot<void, XMMSResultValueList<T>*>& slot_) {
+			XMMSResult::connect(sigc::retype(slot_));
+		}
+};
+
+
+class XMMSResultDictList : public XMMSResultList, public XMMSResultDict
+{
+	public:
+		XMMSResultDictList (xmmsc_result_t* res)
+		  : XMMSResultList(res), XMMSResultDict(res) { }
+		XMMSResultDictList (const XMMSResultDictList &src)
+		  : XMMSResultList(src), XMMSResultDict(src) { }
+		virtual ~XMMSResultDictList() { }
+
+		void connect (const sigc::slot<void, XMMSResultDictList*>& slot_) {
+			XMMSResult::connect(sigc::retype(slot_));
+		}
+};
+
+
+
+class XMMSClient
+{
+	public:
+		XMMSClient (const char *name);
+		~XMMSClient ();
+
+		bool connect (const char *path);
+
+		xmmsc_connection_t *getConn(void) { return m_xmmsc; }
+
+#include "xmmsclient_methods.h"
+
+	private:
+		xmmsc_connection_t *m_xmmsc;
+};
+
+#endif
+