Port to cpp bindings

Display.cpp

@@ -60,19 +60,19 @@ SkinDisplay::paintEvent (QPaintEvent *event)
 void
 SkinDisplay::fileOpen (void)
 {
-	XMMSHandler *xmmsh = XMMSHandler::getInstance();
 	QStringList files;
 
 	files = QFileDialog::getOpenFileNames (this, "Select files to play",
 	                                       QDir::homePath(),
 	                                       "Music (*.mp3 *.ogg *.flac *.wav *.mpc *.mp4)");
 
+	XMMSHandler &xmmsh = XMMSHandler::getInstance();
 	if (files.count() > 0) {
-		xmmsh->playlistClear ();
+		xmmsh.playlistClear ();
 	}
 
 	for (int i = 0; i < files.count(); i++) {
-		xmmsh->playlistAddURL ("file://" + files.value(i));
+		xmmsh.playlistAddURL ("file://" + files.value(i));
 	}
 }
 

MainDisplay.cpp

@@ -1,3 +1,4 @@
+#include <xmmsclient/xmmsclient++.h>
 #include "XMMSHandler.h"
 #include "MainDisplay.h"
 #include "MainWindow.h"
@@ -19,8 +20,6 @@
 
 MainDisplay::MainDisplay (QWidget *parent) : SkinDisplay(parent)
 {
-	XMMSHandler *xmmsh = XMMSHandler::getInstance ();
-
 	m_tbar = new TitleBar(this, false);
 	m_tbar->move(0, 0);
 	m_tbar->resize(275, 14);
@@ -59,11 +58,12 @@ MainDisplay::MainDisplay (QWidget *parent) : SkinDisplay(parent)
 	m_vslider = new VolumeSlider(this);
 	m_vslider->move (107, 57);
 
-	connect (xmmsh, SIGNAL(currentSong (const QHash<QString, QString> &)), 
+	XMMSHandler &xmmsh = XMMSHandler::getInstance ();
+	connect (&xmmsh, SIGNAL(currentSong (const QHash<QString, QString> &)), 
 			 this, SLOT(setMediainfo (const QHash<QString, QString> &)));
-	connect (xmmsh, SIGNAL(playbackStatusChanged(uint)),
+	connect (&xmmsh, SIGNAL(playbackStatusChanged(Xmms::Playback::Status)),
-	         this, SLOT(setStatus(uint)));
+	         this, SLOT(setStatus(Xmms::Playback::Status)));
-	connect (xmmsh, SIGNAL(playtimeChanged(uint)),
+	connect (&xmmsh, SIGNAL(playtimeChanged(uint)),
 	         this, SLOT(setPlaytime(uint)));
 }
 
@@ -97,9 +97,9 @@ MainDisplay::setPixmaps (Skin *skin)
 }
 
 void
-MainDisplay::setStatus (uint status)
+MainDisplay::setStatus (Xmms::Playback::Status status)
 {
-	if (status == XMMS_PLAYBACK_STATUS_STOP) {
+	if (status == Xmms::Playback::STOPPED) {
 		m_time->setTime(0);
 		m_slider->setPos (0);
 		m_slider->hideBar (true);
@@ -184,28 +184,28 @@ MainDisplay::toggleTime (void)
 void
 MainDisplay::SetupPushButtons (void)
 {
-	XMMSHandler *xmmsh = XMMSHandler::getInstance ();
+	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()));
+	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()));
+	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()));
+	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()));
+	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()));
+	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);

MainDisplay.h

@@ -3,6 +3,7 @@
 
 class MainDisplay;
 
+#include <xmmsclient/xmmsclient++.h>
 #include "XMMSHandler.h"
 
 #include <iostream>
@@ -65,7 +66,7 @@ class MainDisplay : public SkinDisplay
 
 	public slots:
 		void setPixmaps(Skin *skin);
-		void setStatus (uint status);
+		void setStatus (Xmms::Playback::Status status);
 		void setPlaytime (uint time);
 		void setMediainfo (const QHash<QString,QString> &);
 		void togglePL(void);

MainWindow.cpp

@@ -54,7 +54,6 @@ MainWindow::MainWindow (QWidget *parent) : QMainWindow (parent)
 MainWindow::~MainWindow ()
 {
 	delete Skin::getInstance ();
-	delete XMMSHandler::getInstance();
 }
 
 void

PlayStatus.cpp

@@ -1,17 +1,17 @@
+#include <xmmsclient/xmmsclient++.h>
 #include "PlayStatus.h"
 #include "Skin.h"
 
 PlayStatus::PlayStatus (QWidget *parent) : PixWidget (parent)
 {
-	XMMSHandler *xmmsh = XMMSHandler::getInstance();
-
 	setMinimumSize(11, 9);
 	setMaximumSize(11, 9);
 
-	m_status = XMMS_PLAYBACK_STATUS_STOP;
+	m_status = Xmms::Playback::STOPPED;
 
-	connect (xmmsh, SIGNAL(playbackStatusChanged(uint)),
+	connect (&XMMSHandler::getInstance (),
-	         this, SLOT(setStatus(uint)));
+	         SIGNAL(playbackStatusChanged(Xmms::Playback::Status)),
+	         this, SLOT(setStatus(Xmms::Playback::Status)));
 }
 
 void
@@ -25,13 +25,14 @@ PlayStatus::setPixmaps (Skin *skin)
 }
 
 void
-PlayStatus::setStatus (uint status)
+PlayStatus::setStatus (Xmms::Playback::Status status)
 {
-	if (status == XMMS_PLAYBACK_STATUS_STOP) {
+	using Xmms::Playback;
+	if (status == Playback::STOPPED) {
 		m_pixmap = m_pixmap_stop;
-	} else if (status == XMMS_PLAYBACK_STATUS_PLAY) {
+	} else if (status == Playback::PLAYING) {
 		m_pixmap = m_pixmap_play;
-	} else if (status == XMMS_PLAYBACK_STATUS_PAUSE) {
+	} else if (status == Playback::PAUSED) {
 		m_pixmap = m_pixmap_pause;
 	}
 

PlayStatus.h

@@ -1,6 +1,7 @@
 #ifndef __PLAYSTATUS_H__
 #define __PLAYSTATUS_H__
 
+#include <xmmsclient/xmmsclient++.h>
 #include "XMMSHandler.h"
 #include "PixWidget.h"
 
@@ -14,10 +15,10 @@ class PlayStatus : public PixWidget
 
 	public slots:
 		void setPixmaps (Skin *skin);
-		void setStatus (uint status);
+		void setStatus (Xmms::Playback::Status status);
 
 	private:
-		int m_status;
+		Xmms::Playback::Status m_status;
 
 		QPixmap m_pixmap_stop;
 		QPixmap m_pixmap_play;

Playlist.cpp

@@ -266,7 +266,6 @@ void
 PlaylistWidget::addButtons (void)
 {
 	PlaylistMenuButton *b;
-	XMMSHandler *xmmsh = XMMSHandler::getInstance();
 
 	m_add = new PlaylistMenu (this, Skin::PLS_ADD,
 							  Skin::PLS_ADD_DEC);
@@ -287,7 +286,8 @@ PlaylistWidget::addButtons (void)
 								Skin::PLS_MSC_BTN_1);
 	b = new PlaylistMenuButton (m_del, Skin::PLS_DEL_ALL_0,
 								Skin::PLS_DEL_ALL_1);
-	connect (b, SIGNAL(activated ()), xmmsh, SLOT (playlistClear ()));
+	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,
@@ -325,7 +325,6 @@ PlaylistWidget::addButtons (void)
 void
 PlaylistWidget::diveDir (const QString &dir)
 {
-	XMMSHandler *xmmsh = XMMSHandler::getInstance();
 	QDir d (dir);
 
 	d.setFilter (QDir::Files | QDir::Dirs | QDir::NoDotAndDotDot);
@@ -337,7 +336,7 @@ PlaylistWidget::diveDir (const QString &dir)
 			diveDir (fileInfo.filePath ());
 		} else {
 			QString fname = fileInfo.filePath();
-			xmmsh->playlistAddURL ("file://" + fname);
+			XMMSHandler::getInstance ().playlistAddURL ("file://" + fname);
 		}
 	}
 }
@@ -355,7 +354,6 @@ PlaylistWidget::menuAddDir ()
 void
 PlaylistWidget::menuAddFile ()
 {
-	XMMSHandler *xmmsh = XMMSHandler::getInstance();
 	QStringList files;
 
 	files = QFileDialog::getOpenFileNames (this, "Select files to play",
@@ -363,7 +361,7 @@ PlaylistWidget::menuAddFile ()
 	                                       "Music (*.mp3 *.ogg *.flac *.wav *.mpc *.mp4)");
 
 	for (int i = 0; i < files.count(); i++) {
-		xmmsh->playlistAddURL ("file://" + files.value(i));
+		XMMSHandler::getInstance ().playlistAddURL ("file://" + files.value(i));
 	}
 
 }

PlaylistList.cpp

@@ -1,3 +1,4 @@
+#include <xmmsclient/xmmsclient++.h>
 #include "XMMSHandler.h"
 
 #include "PlaylistList.h"
@@ -31,12 +32,11 @@ PlaylistItem::PlaylistItem (PlaylistList *pl, uint id, uint pos)
 QString
 PlaylistItem::text (void)
 {
-	XMMSHandler *xmmsh = XMMSHandler::getInstance ();
 
 	if (m_text.count() < 1) {
 
 		if (!m_req) {
-			xmmsh->requestMediainfo (m_id);
+			XMMSHandler::getInstance ().requestMediainfo (m_id);
 			m_req = true;
 		}
 
@@ -52,7 +52,7 @@ PlaylistItem::text (void)
 PlaylistList::PlaylistList (QWidget *parent) : QWidget (parent)
 {
 	QSettings s;
-	XMMSHandler *xmmsh = XMMSHandler::getInstance ();
+	XMMSHandler &xmmsh = XMMSHandler::getInstance ();
 	Skin *skin = Skin::getInstance ();
 
 	if (!s.contains("playlist/fontsize"))
@@ -75,22 +75,22 @@ PlaylistList::PlaylistList (QWidget *parent) : QWidget (parent)
 	m_status = XMMS_PLAYBACK_STATUS_STOP;
 	m_bar = -2;
 
-	connect (xmmsh, SIGNAL(playlistList(const QList<uint> &)),
+	connect (&xmmsh, SIGNAL(playlistList(const QList<uint> &)),
 	         this, SLOT(playlistList(const QList<uint> &)));
 
-	connect (xmmsh, SIGNAL(currentID(uint)),
+	connect (&xmmsh, SIGNAL(currentID(uint)),
 	         this, SLOT(currentID(uint)));
 
-	connect (xmmsh, SIGNAL(mediainfoChanged(uint, const QHash<QString, QString> &)), 
+	connect (&xmmsh, SIGNAL(mediainfoChanged(uint, const QHash<QString, QString> &)), 
 	         this, SLOT(mediainfoChanged(uint, const QHash<QString, QString> &)));
 
-	connect (xmmsh, SIGNAL(playlistChanged(const QHash<QString, QString> &)),
+	connect (&xmmsh, SIGNAL(playlistChanged(const QHash<QString, QString> &)),
 	         this, SLOT(playlistChanged(const QHash<QString, QString> &)));
 
-	connect (xmmsh, SIGNAL(playbackStatusChanged(uint)),
+	connect (&xmmsh, SIGNAL(playbackStatusChanged(Xmms::Playback::Status)),
-	         this, SLOT(setStatus(uint)));
+	         this, SLOT(setStatus(Xmms::Playback::Status)));
 
-	connect (xmmsh, SIGNAL(settingsSaved()),
+	connect (&xmmsh, SIGNAL(settingsSaved()),
 	         this, SLOT(settingsSaved()));
 }
 
@@ -108,7 +108,7 @@ PlaylistList::settingsSaved ()
 }
 
 void
-PlaylistList::setStatus (uint s)
+PlaylistList::setStatus (Xmms::Playback::Status s)
 {
 	m_status = s;
 }
@@ -117,7 +117,7 @@ void
 PlaylistList::playlistChanged (const QHash<QString,QString> &h)
 {
 	int signal = h.value("type").toUInt();
-	XMMSHandler *xmmsh = XMMSHandler::getInstance ();
+	XMMSHandler &xmmsh = XMMSHandler::getInstance ();
 	switch (signal) {
 		case XMMS_PLAYLIST_CHANGED_ADD:
 			{
@@ -184,7 +184,7 @@ PlaylistList::playlistChanged (const QHash<QString,QString> &h)
 				m_itemmap->clear ();
 
 				if (signal != XMMS_PLAYLIST_CHANGED_CLEAR) {
-					xmmsh->requestPlaylistList ();
+					xmmsh.requestPlaylistList ();
 				} else {
 					doResize ();
 				}
@@ -254,8 +254,6 @@ PlaylistList::playlistList (const QList<uint> &l)
 void
 PlaylistList::mouseDoubleClickEvent (QMouseEvent *event)
 {
-	XMMSHandler *xmmsh = XMMSHandler::getInstance ();
-
 	if (m_items->count() < 1 || m_selected->count() < 1) {
 		return;
 	}
@@ -265,11 +263,12 @@ PlaylistList::mouseDoubleClickEvent (QMouseEvent *event)
 		return;
 	}
 
-	xmmsh->requestTrackChange (m_items->indexOf(it));
+	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 ();
+		xmmsh.play ();
 	}
 }
 
@@ -451,14 +450,14 @@ PlaylistList::dragLeaveEvent (QDragLeaveEvent *event)
 void
 PlaylistList::dropEvent (QDropEvent *event)
 {
-	XMMSHandler *xmmsh = XMMSHandler::getInstance ();
+	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);
+			xmmsh.playlistMove (m_pos, m_bar + 1);
 		}
 		m_selected->append (m_drag_id);
 
@@ -521,9 +520,9 @@ PlaylistList::dropEvent (QDropEvent *event)
 
 		event->acceptProposedAction ();
 	}
-	*/
 	m_bar = -2;
 	update ();
+	*/
 }
 
 void
@@ -595,12 +594,12 @@ PlaylistList::keyPressEvent (QKeyEvent *event)
 void
 PlaylistList::deleteFiles ()
 {
-	XMMSHandler *xmmsh = XMMSHandler::getInstance ();
+	XMMSHandler &xmmsh = XMMSHandler::getInstance ();
 
-	/* Sort list and remove in reverse order */
+	//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));
+		xmmsh.playlistRemove (m_selected->value (i));
 	}
 	m_selected->clear ();
 }

PlaylistList.h

@@ -1,6 +1,7 @@
 #ifndef __PLAYLISTLIST_H__
 #define __PLAYLISTLIST_H__
 
+#include <xmmsclient/xmmsclient++.h>
 #include "Skin.h"
 #include <QWidget>
 #include <QHash>
@@ -29,7 +30,7 @@ class PlaylistList : public QWidget {
 		void mediainfoChanged (uint, const QHash<QString,QString> &);
 		void playlistChanged (const QHash<QString,QString> &);
 		void currentID (uint);
-		void setStatus (uint);
+		void setStatus (Xmms::Playback::Status s);
 		void settingsSaved ();
 		void deleteFiles ();
 	
@@ -69,7 +70,7 @@ class PlaylistList : public QWidget {
 		int m_drag_id;
 		int m_pos;
 		QPoint m_dragstart;
-		uint m_status;
+		Xmms::Playback::Status m_status;
 
 		QDrag *m_drag;
 		QMimeData *m_md;

PlaylistShade.cpp

@@ -8,7 +8,7 @@
 PlaylistShade::PlaylistShade (QWidget *parent) : QWidget (parent)
 {
 	QSettings s;
-	XMMSHandler *xmmsh = XMMSHandler::getInstance ();
+	XMMSHandler &xmmsh = XMMSHandler::getInstance ();
 
 	if (!s.contains ("playlist/shadedsize"))
 		s.setValue ("playlist/shadedsize", 8);
@@ -18,10 +18,10 @@ PlaylistShade::PlaylistShade (QWidget *parent) : QWidget (parent)
 	connect (skin, SIGNAL (skinChanged (Skin *)),
 	         this, SLOT (setPixmaps(Skin *)));
 
-	connect (xmmsh, SIGNAL(currentSong (QHash<QString, QString>)), 
+	connect (&xmmsh, SIGNAL(currentSong (QHash<QString, QString>)), 
 			 this, SLOT(setMediainfo (QHash<QString, QString>)));
 
-	connect (xmmsh, SIGNAL(settingsSaved ()), 
+	connect (&xmmsh, SIGNAL(settingsSaved ()), 
 			 this, SLOT(settingsSaved ()));
 
 	m_text = "Promoe 0.1 - A very neat XMMS2 client";

SettingsWindow.cpp

@@ -51,13 +51,12 @@ SettingsWindow::SettingsWindow (QWidget *parent) : QMainWindow (parent)
 void
 SettingsWindow::okButton (void)
 {
-	XMMSHandler *xmmsh = XMMSHandler::getInstance ();
 	m_mainwindow->saveSettings ();
 	m_playlistwin->saveSettings ();
 	m_medialib->saveSettings ();
 	
 	close ();
-	xmmsh->updateSettings ();
+	XMMSHandler::getInstance ().updateSettings ();
 }
 
 SettingsTabMedialib::SettingsTabMedialib (QWidget *parent) : QWidget (parent)

ShadedDisplay.cpp

@@ -1,3 +1,4 @@
+#include <xmmsclient/xmmsclient++.h>
 #include "XMMSHandler.h"
 
 #include "ShadedDisplay.h"
@@ -9,7 +10,7 @@
 
 ShadedDisplay::ShadedDisplay (QWidget *parent) : SkinDisplay (parent)
 {
-	XMMSHandler *xmmsh = XMMSHandler::getInstance ();
+	XMMSHandler &xmmsh = XMMSHandler::getInstance ();
 
 	setMinimumSize (275, 14);
 	setMaximumSize (275, 14);
@@ -31,38 +32,38 @@ ShadedDisplay::ShadedDisplay (QWidget *parent) : SkinDisplay (parent)
 	m_prev = new Button (this);
 	m_prev->move(169, 4);
 	m_prev->resize (8, 7);
-	connect (m_prev, SIGNAL(clicked()), xmmsh, SLOT(prev()));
+	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()));
+	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()));
+	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()));
+	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()));
+	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(uint)),
+	connect (&xmmsh, SIGNAL(playbackStatusChanged(Xmms::Playback::Status)),
-	         this, SLOT(setStatus(uint)));
+	         this, SLOT(setStatus(Xmms::Playback::Status)));
-	connect (xmmsh, SIGNAL(playtimeChanged(uint)),
+	connect (&xmmsh, SIGNAL(playtimeChanged(uint)),
 	         this, SLOT(setPlaytime(uint)));
-	connect (xmmsh, SIGNAL(currentSong (const QHash<QString, QString> &)), 
+	connect (&xmmsh, SIGNAL(currentSong (const QHash<QString, QString> &)), 
 			 this, SLOT(setMediainfo (const QHash<QString, QString> &)));
 }
 
@@ -79,9 +80,9 @@ ShadedDisplay::setMediainfo (const QHash<QString, QString> &h)
 }
 
 void
-ShadedDisplay::setStatus (uint status)
+ShadedDisplay::setStatus (Xmms::Playback::Status status)
 {
-	if (status == XMMS_PLAYBACK_STATUS_STOP) {
+	if (status == Xmms::Playback::STOPPED) {
 		m_number->setNumber (0, 2);
 		m_number2->setNumber (0, 2);
 	}

ShadedDisplay.h

@@ -3,6 +3,7 @@
 
 class ShadedDisplay;
 
+#include <xmmsclient/xmmsclient++.h>
 #include "Display.h"
 
 class MainWindow;
@@ -30,7 +31,7 @@ class ShadedDisplay : public SkinDisplay
 		Button *m_eject;
 
 	public slots:
-		void setStatus (uint status);
+		void setStatus (Xmms::Playback::Status status);
 		void setPlaytime (uint time);
 		void setMediainfo (const QHash<QString, QString> &h);
 };

Slider.cpp

@@ -152,10 +152,7 @@ Slider::setPos (uint p)
 void
 Slider::requestPos (float value)
 {
-	XMMSHandler *xmmsh = XMMSHandler::getInstance();
+	XMMSHandler::getInstance ().setPlaytime (m_max * value);
-
-	uint new_pos = (uint)(m_max * value);
-	xmmsh->setPlaytime (new_pos);
 }
 
 void

TextBar.cpp

@@ -6,7 +6,7 @@ TextScroller::TextScroller (QWidget *parent, uint w,
 							uint h, const QString &name) : 
 	QWidget (parent)
 {
-	XMMSHandler *xmmsh = XMMSHandler::getInstance ();
+	//XMMSHandler *xmmsh = XMMSHandler::getInstance ();
 	Skin *skin = Skin::getInstance ();
 
 	connect (skin, SIGNAL (skinChanged (Skin *)),
@@ -42,7 +42,7 @@ TextScroller::TextScroller (QWidget *parent, uint w,
 
 	m_timer = new QTimer (this);
 	connect (m_timer, SIGNAL (timeout()), this, SLOT (addOffset ()));
-	connect (xmmsh, SIGNAL (settingsSaved ()), this, SLOT (settingsSaved ()));
+	//connect (xmmsh, SIGNAL (settingsSaved ()), this, SLOT (settingsSaved ()));
 }
 
 void

VolumeSlider.cpp

@@ -12,7 +12,7 @@
 
 VolumeSlider::VolumeSlider (QWidget *parent) : PixWidget (parent)
 {
-	XMMSHandler *xmmsh = XMMSHandler::getInstance ();
+	XMMSHandler &xmmsh = XMMSHandler::getInstance ();
 
 	setMinimumSize (68, 13);
 	setMaximumSize (68, 13);
@@ -23,10 +23,10 @@ VolumeSlider::VolumeSlider (QWidget *parent) : PixWidget (parent)
 
 	m_pixmap = QPixmap (68, 13);
 
-	connect (xmmsh, SIGNAL(getVolume (uint)),
+	connect (&xmmsh, SIGNAL(getVolume (uint)),
 	         this, SLOT(setVolume (uint)));
 
-	xmmsh->volumeGet ();
+	xmmsh.volumeGet ();
 }
 
 VolumeSlider::~VolumeSlider ()
@@ -86,8 +86,7 @@ VolumeSlider::setPixmaps (Skin *skin)
 void
 VolumeSlider::changePixmap ()
 {
-	XMMSHandler *xmmsh = XMMSHandler::getInstance ();
+	XMMSHandler::getInstance ().volumeSet (m_volume_base100);
-	xmmsh->volumeSet (m_volume_base100);
 
 	m_volslider = m_skin->getVol (m_volume);
 	drawPixmaps ();

XMMSHandler.cpp

@@ -1,7 +1,11 @@
-#include "xmmsclient_promoe.h"
+#include <xmmsclient/xmmsclient++.h>
 
 #include "XmmsQT4.h"
 #include "XMMSHandler.h"
+#include <iostream>
+
+#include <cstdlib>
+#include <string>
 
 #include <QErrorMessage>
 #include <QHash>
@@ -9,245 +13,200 @@
 #include <QFileDialog>
 #include <QDir>
 
-XMMSHandler *XMMSHandler::singleton = NULL;
+static bool log ( /*const std::string& text = ""*/ )
-
-XMMSHandler *XMMSHandler::getInstance (void)
 {
-	if (!singleton) {
+	return false;
-		singleton = new XMMSHandler ();
+}
-#ifndef HAVE_SERVERBROWSER
-		singleton->connect (getenv ("XMMS_PATH"));
-#endif
-	}
 
+static bool logUint ( const unsigned int & /*, const std::string& text = "" */ )
+{
+	return false;
+}
+
+XMMSHandler &XMMSHandler::getInstance ()
+{
+	static XMMSHandler singleton;
 	return singleton;
 }
 
-XMMSHandler::XMMSHandler () : QObject (), sigc::trackable ()
+XMMSHandler::XMMSHandler () : QObject (), m_client ("promoe")
 {
-	m_xmmsc = new XMMSClient ("promoe");
+	connect (std::getenv ( "XMMS_PATH" ));
 }
 
 bool
 XMMSHandler::connect (const char *path)
 {
-	if (!m_xmmsc->connect (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;
 		return false;
 	}
-	m_qt4 = new XmmsQT4 (m_xmmsc->getConn (), qApp);
+	m_qt4 = new XmmsQT4 (m_client.getConnection (), qApp);
 
-	XMMSResultValueList<uint> *l = m_xmmsc->playlist_list ();
+	using Xmms::bind;
-	l->connect (sigc::mem_fun (this, &XMMSHandler::playlist_list));
+	m_client.playlist.list (bind (&XMMSHandler::playlist_list, this));
+	m_client.playlist.broadcastChanged (
+		bind (&XMMSHandler::playlist_changed, this));
 
-	XMMSResultDict *p = m_xmmsc->broadcast_playlist_changed ();
+	m_client.medialib.broadcastEntryChanged (
-	p->connect (sigc::mem_fun (this, &XMMSHandler::playlist_changed));
+		bind (&XMMSHandler::medialib_entry_changed, this));
 
-	XMMSResultValue<uint> *r = m_xmmsc->signal_playback_playtime ();
+	m_client.playback.currentID (
-	r->connect (sigc::mem_fun (this, &XMMSHandler::playback_playtime));
+		bind (&XMMSHandler::playback_current_id, this));
+	m_client.playback.broadcastCurrentID (
+		bind (&XMMSHandler::playback_current_id, this));
 
-	r = m_xmmsc->playback_current_id ();
+	m_client.playback.getStatus (bind (&XMMSHandler::playback_status, this));
-	r->connect (sigc::mem_fun (this, &XMMSHandler::playback_current_id));
+	m_client.playback.broadcastStatus (
+		bind (&XMMSHandler::playback_status, this));
 
-	r = m_xmmsc->broadcast_playback_current_id ();
+	m_client.playback.broadcastVolumeChanged (
-	r->connect (sigc::mem_fun (this, &XMMSHandler::playback_current_id));
+		bind (&XMMSHandler::volume_changed, this));
 
-	r = m_xmmsc->playback_status ();
+	QObject::connect (&m_playtime_timer, SIGNAL (timeout ()),
-	r->connect (sigc::mem_fun (this, &XMMSHandler::playback_status));
+	                  this, SLOT (restartPlaytime ()));
-
+	m_playtime_timer.start(0);
-	r = m_xmmsc->broadcast_playback_status ();
-	r->connect (sigc::mem_fun (this, &XMMSHandler::playback_status));
-
-	r = m_xmmsc->broadcast_medialib_entry_changed ();
-	r->connect (sigc::mem_fun (this, &XMMSHandler::medialib_entry_changed));
-
-	XMMSResult *xr = m_xmmsc->broadcast_playback_volume_changed ();
-	xr->connect (sigc::mem_fun (this, &XMMSHandler::volume_changed));
-
-	QObject::connect (&m_playtime_timer, SIGNAL (timeout ()), this, SLOT (restartPlaytime ()));
 
 	return true;
 }
 
 void
-XMMSHandler::restartPlaytime (void)
+XMMSHandler::restartPlaytime ()
 {
-	m_playtime->restart ();
+	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::medialib_entry_changed (XMMSResultValue<uint> *res)
+XMMSHandler::playlistAddURL (const QString &s)
 {
-	uint i;
+	m_client.playlist.addUrl (s.toAscii ().constData (), &log);
-	res->getValue (&i);
+}
-
+void
-	if (i > 0) {
+XMMSHandler::playlistRemove (uint pos)
-		XMMSResultDict *r = m_xmmsc->medialib_get_info (i);
+{ 
-		r->connect (sigc::mem_fun (this, &XMMSHandler::medialib_info));
+	m_client.playlist.remove (pos, &log);
-	}
-
-	if (res->getClass() == XMMSC_RESULT_CLASS_DEFAULT) {
-		delete res;
-	}
 }
 
 void
-XMMSHandler::playlistAddURL (QString s)
+XMMSHandler::playlistMove (uint pos, uint newpos)
 {
-	delete m_xmmsc->playlist_add (s.toAscii ().constData ());
+	m_client.playlist.move (pos, newpos, &log);
 }
 
 void
 XMMSHandler::requestMediainfo (uint id)
 {
-	XMMSResultDict *r = m_xmmsc->medialib_get_info (id);
+	m_client.medialib.getInfo (id,
-	r->connect (sigc::mem_fun (this, &XMMSHandler::medialib_info));
+	                           Xmms::bind (&XMMSHandler::medialib_info, this));
 }
 
 void
-XMMSHandler::requestPlaylistList (void)
+XMMSHandler::requestPlaylistList ()
 {
-	XMMSResultValueList<uint> *r = m_xmmsc->playlist_list ();
+	m_client.playlist.list (Xmms::bind (&XMMSHandler::playlist_list, this));
-	r->connect (sigc::mem_fun (this, &XMMSHandler::playlist_list));
 }
 
 void
 XMMSHandler::requestTrackChange (int pos)
 {
-	XMMSResult *r = m_xmmsc->playlist_set_next (pos);
+	m_client.playlist.setNext (pos, &logUint);
-	delete r;
+	m_client.playback.tickle (&log);
-	XMMSResult *r2 = m_xmmsc->playback_tickle ();
-	delete r2;
 }
 
-void
+bool
-XMMSHandler::playlist_list (XMMSResultValueList<uint> *res) 
+XMMSHandler::playlist_list (const Xmms::List< unsigned int > &playlist)
 {
 	QList<uint> list;
-	for (;res->listValid (); res->listNext()) {
+	for (;playlist.isValid (); ++playlist) {
-		uint i;
+		list.append (*playlist);
-		if (res->getValue (&i)) {
-			list.append (i);
-		}
 	}
 	emit playlistList (list);
-
+	return false;
-	delete res;
 }
 
-void
+bool
-XMMSHandler::playback_status (XMMSResultValue<uint> *res)
+XMMSHandler::playback_status (const Xmms::Playback::Status &status)
 {
-	uint status;
-	res->getValue (&status);
-
 	emit playbackStatusChanged (status);
-
+	return true;
-	if (res->getClass() == XMMSC_RESULT_CLASS_DEFAULT) {
-		delete res;
-	}
 }
 
-void 
+bool 
-XMMSHandler::playback_playtime (XMMSResultValue<uint> *res)
+XMMSHandler::playback_playtime (const unsigned int &time)
 {
-	uint i;
+	emit playtimeChanged (time);
-	res->getValue (&i);
-
-	emit playtimeChanged (i);
-	
-	m_playtime = res;
 	m_playtime_timer.start (500);
+	return false;
 }
 
-void 
+bool 
-XMMSHandler::playback_current_id (XMMSResultValue<uint> *res)
+XMMSHandler::playback_current_id (const unsigned int &id)
 {
-	uint i;
+	m_currentid = id;
-	res->getValue (&i);
 
-	m_currentid = i;
+	if (id > 0) {
-
+		requestMediainfo (id);
-	if (i > 0) {
-		XMMSResultDict *r = m_xmmsc->medialib_get_info (i);
-		r->connect (sigc::mem_fun (this, &XMMSHandler::medialib_info));
 	}
 
-	emit currentID(i);
+	emit currentID(id);
-
+	return true;
-	if (res->getClass() == XMMSC_RESULT_CLASS_DEFAULT) {
-		delete res;
-	}
 }
 
 void
 XMMSHandler::setPlaytime (uint pos)
 {
-	delete m_xmmsc->playback_seek_ms (pos);
+	m_client.playback.seekMs (pos, &log);
 }
 
-QHash<QString, QString>
+void
-XMMSHandler::DictToQHash (XMMSResultDict *res)
+XMMSHandler::DictToQHash (const std::string &key,
+                          const Xmms::Dict::Variant &value,
+                          QHash<QString, QString> &hash)
 {
-	QHash<QString, QString> h;
+	if (value.type () == typeid (int)) {
-	std::list<const char *> l = res->getDictKeys ();
+		hash.insert (QString::fromLatin1 (key.c_str ()),
-
+		             QString::number (boost::get< int > (value)));
-	std::list<const char *>::const_iterator it;
+	} else if (value.type () == typeid (unsigned int)) {
-	for(it=l.begin(); it!=l.end(); ++it)
+		hash.insert (QString::fromLatin1 (key.c_str ()),
-	{
+		             QString::number (boost::get< unsigned int > (value)));
-		if (res->getDictValueType (*it) == XMMSC_RESULT_VALUE_TYPE_UINT32) {
+	} else if (value.type () == typeid (unsigned int)) {
-			uint i;
+		hash.insert (QString::fromLatin1 (key.c_str ()),
-			res->getValue (*it, &i);
+		             QString::fromUtf8 (boost::get< std::string > (value).c_str ()));
-			QString t;
-			t.setNum (i);
-			h.insert (QString::fromLatin1(*it), t);
-		} else if (res->getDictValueType (*it) == XMMSC_RESULT_VALUE_TYPE_INT32) {
-			int i;
-			res->getValue (*it, &i);
-			QString t;
-			t.setNum (i);
-			h.insert (QString::fromLatin1(*it), t);
-		} else if (res->getDictValueType (*it) == XMMSC_RESULT_VALUE_TYPE_STRING) {
-			char *c;
-			res->getValue (*it, &c);
-			h.insert (QString::fromLatin1(*it), QString::fromUtf8 (c));
 	}
-	}
-
-	return h;
 }
 
-QHash<QString, QString>
+void
-XMMSHandler::PropDictToQHash (XMMSResultDict *res)
+XMMSHandler::PropDictToQHash (const std::string &key,
+                              const Xmms::Dict::Variant &value,
+                              const std::string &source,
+                              QHash<QString, QString> &hash)
 {
-	QHash<QString, QString> h;
+	if (value.type () == typeid (int)) {
-	std::list<const char *> l = res->getPropDictKeys ();
+		hash.insert (QString::fromLatin1 (key.c_str ()),
-
+		             QString::number (boost::get< int > (value)));
-	std::list<const char *>::const_iterator it;
+	} else if (value.type () == typeid (unsigned int)) {
-	for(it=l.begin(); it!=l.end(); ++it)
+		hash.insert (QString::fromLatin1 (key.c_str ()),
-	{
+		             QString::number (boost::get< unsigned int > (value)));
-		if (res->getDictValueType (*it) == XMMSC_RESULT_VALUE_TYPE_UINT32) {
+	} else {
-			uint i;
+		hash.insert (QString::fromLatin1 (key.c_str ()),
-			res->getValue (*it, &i);
+		             QString::fromUtf8 (boost::get< std::string > (value).c_str()));
-			QString t;
-			t.setNum (i);
-			h.insert (QString::fromLatin1(*it), t);
-		} else if (res->getDictValueType (*it) == XMMSC_RESULT_VALUE_TYPE_INT32) {
-			int i;
-			res->getValue (*it, &i);
-			QString t;
-			t.setNum (i);
-			h.insert (QString::fromLatin1(*it), t);
-		} else if (res->getDictValueType (*it) == XMMSC_RESULT_VALUE_TYPE_STRING) {
-			char *c;
-			res->getValue (*it, &c);
-			h.insert (QString::fromLatin1(*it), QString::fromUtf8 (c));
 	}
-	}
-
-	return h;
 }
 
 /*
@@ -273,68 +232,83 @@ XMMSHandler::medialib_select (XMMSResultDictList *res)
 }
 */
 
-void
+bool
-XMMSHandler::playlist_changed (XMMSResultDict *res)
+XMMSHandler::playlist_changed (const Xmms::Dict &list)
 {
-	QHash<QString, QString> h(DictToQHash (res));
+	QHash<QString, QString> hash;
-	emit playlistChanged (h);
+#ifdef foreach
+#undef foreach
+#endif
+	list.foreach (boost::bind (&XMMSHandler::DictToQHash, this,
+	                           _1, _2, boost::ref (hash)));
+	emit playlistChanged (hash);
+	return true;
 }
 
-void 
+bool 
-XMMSHandler::medialib_info (XMMSResultDict *res)
+XMMSHandler::medialib_info (const Xmms::PropDict &propdict)
 {
-	int id;
-	QHash<QString, QString> h(PropDictToQHash (res));
 
-	res->getValue ("id", &id);
+	QHash<QString, QString> hash;	
-
+#ifdef foreach
-	emit mediainfoChanged (id, h);
+#undef foreach
+#endif
+	propdict.foreach (boost::bind (&XMMSHandler::PropDictToQHash, this,
+	                               _1, _2, _3, boost::ref (hash)));
+	unsigned int id = propdict.get<int>("id");
+	emit mediainfoChanged (id, hash);
 
 	if (id == m_currentid) {
-		emit currentSong (h);
+		emit currentSong (hash);
 	}
+	return false;
+}
 
-	delete res;
+bool
+XMMSHandler::volume_error (const std::string &error)
+{
+	qWarning ("couldn't get volume levels!");
+	return false;
 }
 
 void
-XMMSHandler::volumeGet (void)
+XMMSHandler::volumeGet ()
 {
-	XMMSResultDict *p = m_xmmsc->playback_volume_get ();
+	m_client.playback.volumeGet (Xmms::bind (&XMMSHandler::volume_get, this),
-	p->connect (sigc::mem_fun (this, &XMMSHandler::volume_get));
+	                             Xmms::bind (&XMMSHandler::volume_error, this));
 }
 
-
 void
 XMMSHandler::volumeSet (uint volume)
 {
 	if(m_masterchan)
 	{
-		delete m_xmmsc->playback_volume_set ("master", volume);
+		m_client.playback.volumeSet ("master", volume, &log);
 	}
 	else
 	{
-		delete m_xmmsc->playback_volume_set ("left", volume);
+		m_client.playback.volumeSet ("left", volume, &log);
-		delete m_xmmsc->playback_volume_set ("right", volume);
+		m_client.playback.volumeSet ("right", volume, &log);
 	}
 }
 
-void
+bool
-XMMSHandler::volume_changed (XMMSResult *res)
+XMMSHandler::volume_changed (const Xmms::Dict &levels)
 {
-	volumeGet ();
+	volume_get (levels);
+	return true;
 }
 
-void
+bool
-XMMSHandler::volume_get (XMMSResultDict *res)
+XMMSHandler::volume_get (const Xmms::Dict &levels)
 {
-	if (res->isError()) {
+	QHash<QString, QString> hash;
-		qWarning ("couldn't get volume levels!");
+#ifdef foreach
-		return;
+#undef foreach
-	}
+#endif
-
+	levels.foreach (boost::bind (&XMMSHandler::DictToQHash, this,
-	QHash<QString, QString> h (DictToQHash (res));
+	                             _1, _2, boost::ref (hash)));
-	QList<QString> Values = h.values();
+	QList<QString> Values = hash.values();
 	QListIterator<QString> vol (Values);
 
 	uint right = atol (vol.next().toAscii());
@@ -354,11 +328,43 @@ XMMSHandler::volume_get (XMMSResultDict *res)
 		emit getVolume (right);
 		m_masterchan = true;
 	}
+	return false;
 
 }
 
+
+void XMMSHandler::playlistClear ()
+{
+	m_client.playlist.clear (&log);
+}
+
+void XMMSHandler::play ()
+{
+	m_client.playback.start (&log);
+}
+
+void XMMSHandler::stop ()
+{
+	m_client.playback.stop (&log);
+}
+
+void XMMSHandler::pause ()
+{
+	m_client.playback.pause (&log);
+}
+
+void XMMSHandler::next ()
+{
+	m_client.playlist.setNextRel (1, &logUint);
+	m_client.playback.tickle (&log);
+}
+
+void XMMSHandler::prev ()
+{
+	m_client.playlist.setNextRel (-1, &logUint);
+	m_client.playback.tickle (&log);
+}
+
 XMMSHandler::~XMMSHandler ()
 {
-	delete m_xmmsc;
 }
-

XMMSHandler.h

@@ -1,7 +1,7 @@
 #ifndef __XMMS_HANDLER_H__
 #define __XMMS_HANDLER_H__
 
-#include "xmmsclient_promoe.h"
+#include <xmmsclient/xmmsclient++.h>
 
 #include "XmmsQT4.h"
 
@@ -9,64 +9,61 @@
 #include <QHash>
 #include <QTimer>
 
-class XMMSHandler : public QObject, public sigc::trackable {
+class XMMSHandler : public QObject {
 	Q_OBJECT
 	public:
-		static XMMSHandler *getInstance (void);
+		static XMMSHandler &getInstance ();
 		~XMMSHandler ();
 
 		bool connect (const char *path);
 
-		void playback_playtime (XMMSResultValue<uint> *res);
+		bool playback_playtime (const unsigned int &time);
-		void playback_current_id (XMMSResultValue<uint> *res);
+		bool playlist_list (const Xmms::List< unsigned int > &playlist);
-		void medialib_info (XMMSResultDict *res);
+		bool playback_current_id (const unsigned int &id);
-		void playlist_changed (XMMSResultDict *res);
+		bool medialib_info (const Xmms::PropDict &propdict);
-		void playback_status (XMMSResultValue<uint> *res);
+		bool medialib_entry_changed (const unsigned int &id);
-		void playlist_list (XMMSResultValueList<uint> *res);
+		bool playback_status (const Xmms::Playback::Status &status);
-		void medialib_entry_changed (XMMSResultValue<uint> *res);
+		bool volume_changed (const Xmms::Dict &levels);
-		void medialib_select (XMMSResultDictList *res);
+		bool playlist_changed (const Xmms::Dict &list);
-		void volume_changed (XMMSResult *res);
-		void volume_get (XMMSResultDict *res);
 
 		void requestMediainfo (uint id);
-		void requestPlaylistList (void);
+		void requestPlaylistList ();
 		void requestTrackChange (int pos);
+		void playlistAddURL (const QString& url);
+		void playlistRemove (uint pos);
+		void playlistMove (uint pos, uint newpos);
 
-		void playlistAddURL (QString);
+		/*
-		void playlistRemove (uint pos) { delete m_xmmsc->playlist_remove (pos); }
+		void medialib_select (XMMSResultDictList *res);
-		void playlistMove (uint pos, uint newpos) { delete m_xmmsc->playlist_move (pos, newpos); }
+
+
+		*/
 		/*
 		uint medialibQuery (QString);
 		void medialibQueryAdd (QString q) { delete m_xmmsc->medialib_add_to_playlist (q.toUtf8 ()); }
 		*/
-		void volumeGet (void);
+
 		void volumeSet (uint volume);
+		void volumeGet ();
 
+		//const XMMSClient *getXMMS () { return m_xmmsc; }
 
-		const XMMSClient *getXMMS () { return m_xmmsc; }
+		void updateSettings () { emit settingsSaved (); }
-
-		void updateSettings (void) { emit settingsSaved (); }
 
 	public slots:
 		void setPlaytime (uint pos);
-		void restartPlaytime (void);
+		void restartPlaytime ();
 
-		void playlistClear () { delete m_xmmsc->playlist_clear (); }
+		void playlistClear ();
-		void play () { delete m_xmmsc->playback_start (); }
+		void play ();
-		void stop () { delete m_xmmsc->playback_stop (); }
+		void stop ();
-		void pause () { delete m_xmmsc->playback_pause (); }
+		void pause ();
-		void next () { 
+		void next ();
-			delete m_xmmsc->playlist_set_next_rel (1); 
+		void prev ();
-			delete m_xmmsc->playback_tickle (); 
-		}
-		void prev () { 
-			delete m_xmmsc->playlist_set_next_rel (-1); 
-			delete m_xmmsc->playback_tickle (); 
-		}
 
 	signals:
-		void settingsSaved (void);
+		void settingsSaved ();
-		void playbackStatusChanged (uint status);
+		void playbackStatusChanged (Xmms::Playback::Status status);
 		void playtimeChanged (uint time);
 		void mediainfoChanged (uint, const QHash<QString, QString> &);
 		void currentSong (const QHash<QString, QString> &);
@@ -79,16 +76,23 @@ class XMMSHandler : public QObject, public sigc::trackable {
 		void getVolume (uint);
 
 	private:
-		XMMSResultValue<uint> *m_playtime;
+		Xmms::Client m_client;
+
 		QTimer m_playtime_timer;
 
-		XMMSHandler (void);
+		XMMSHandler ();
-		QHash<QString, QString> PropDictToQHash (XMMSResultDict *res);
+		void DictToQHash (const std::string &key,
-		QHash<QString, QString> DictToQHash (XMMSResultDict *res);
+		                  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;
-		XMMSClient *m_xmmsc;
-		static XMMSHandler *singleton;
 		int m_currentid;
 		bool m_masterchan;
 };

XmmsQT4.cpp

@@ -1,7 +1,5 @@
 #include "XmmsQT4.h"
 
-using namespace std;
-
 static void CheckWrite (int i, void *userdata);
 
 XmmsQT4::XmmsQT4 (xmmsc_connection_t *xmmsc, QObject *parent) : QObject (parent)

promoe.pro

@@ -22,8 +22,7 @@ SOURCES += XmmsQT4.cpp \
 		   qtmd5.cpp \
 		   SettingsWindow.cpp \
 		   PlaylistMenu.cpp \
-		   VolumeSlider.cpp \
+		   VolumeSlider.cpp
-		   xmmsclient_promoe.cpp
 
 HEADERS += XmmsQT4.h \
 		   PixWidget.h \
@@ -50,8 +49,6 @@ HEADERS += XmmsQT4.h \
 		   SettingsWindow.h \
 		   PlaylistMenu.h \
 		   VolumeSlider.h \
-		   xmmsclient_promoe.h \
-		   xmmsclient_methods.h
 
 
 
@@ -67,7 +64,7 @@ CONFIG += link_pkgconfig
 ;QMAKE_CXXFLAGS += -g
 ;CONFIG += debug warn_on
 QMAKE_CXXFLAGS_WARN_ON += -Wno-unused-parameter
-PKGCONFIG += xmms2-client sigc++-2.0 
+PKGCONFIG += xmms2-client sigc++-2.0 xmms2-client-cpp
 
 ;CONFIG += avahi