brian/promoe
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Port to cpp bindings

Browse source
This commit is contained in:
Jonne Lehtinen 2006-05-25 21:50:53 +03:00 • committed by Tobias
parent 0f06c83484
commit 70da726f52
20 changed files with 333 additions and 331 deletions
Download patch file Download diff file Expand all files Collapse all files

6
Display.cpp
View file

@ -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));
}
}

28
MainDisplay.cpp
View file

@ -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)),
this, SLOT(setStatus(uint)));
connect (xmmsh, SIGNAL(playtimeChanged(uint)),
connect (&xmmsh, SIGNAL(playbackStatusChanged(Xmms::Playback::Status)),
this, SLOT(setStatus(Xmms::Playback::Status)));
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);

3
MainDisplay.h
View file

@ -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);

1
MainWindow.cpp
View file

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

19
PlayStatus.cpp
View file

@ -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)),
this, SLOT(setStatus(uint)));
connect (&XMMSHandler::getInstance (),
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;
}

5
PlayStatus.h
View file

@ -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;

10
Playlist.cpp
View file

@ -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));
}
}

45
PlaylistList.cpp
View file

@ -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)),
this, SLOT(setStatus(uint)));
connect (&xmmsh, SIGNAL(playbackStatusChanged(Xmms::Playback::Status)),
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 ();
}

5
PlaylistList.h
View file

@ -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;

6
PlaylistShade.cpp
View file

@ -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";

3
SettingsWindow.cpp
View file

@ -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)

25
ShadedDisplay.cpp
View file

@ -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)),
this, SLOT(setStatus(uint)));
connect (xmmsh, SIGNAL(playtimeChanged(uint)),
connect (&xmmsh, SIGNAL(playbackStatusChanged(Xmms::Playback::Status)),
this, SLOT(setStatus(Xmms::Playback::Status)));
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);
}

3
ShadedDisplay.h
View file

@ -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);
};

5
Slider.cpp
View file

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

4
TextBar.cpp
View file

@ -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

11
VolumeSlider.cpp
View file

@ -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)),
this, SLOT(setVolume (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 ();
xmmsh->volumeSet (m_volume_base100);
XMMSHandler::getInstance ().volumeSet (m_volume_base100);
m_volslider = m_skin->getVol (m_volume);
drawPixmaps ();

388
XMMSHandler.cpp
View file

@ -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;
XMMSHandler *XMMSHandler::getInstance (void)
static bool log ( /*const std::string& text = ""*/ )
{
if (!singleton) {
singleton = new XMMSHandler ();
#ifndef HAVE_SERVERBROWSER
singleton->connect (getenv ("XMMS_PATH"));
#endif
}
return false;
}
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 ();
l->connect (sigc::mem_fun (this, &XMMSHandler::playlist_list));
using Xmms::bind;
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 ();
p->connect (sigc::mem_fun (this, &XMMSHandler::playlist_changed));
m_client.medialib.broadcastEntryChanged (
bind (&XMMSHandler::medialib_entry_changed, this));
XMMSResultValue<uint> *r = m_xmmsc->signal_playback_playtime ();
r->connect (sigc::mem_fun (this, &XMMSHandler::playback_playtime));
m_client.playback.currentID (
bind (&XMMSHandler::playback_current_id, this));
m_client.playback.broadcastCurrentID (
bind (&XMMSHandler::playback_current_id, this));
r = m_xmmsc->playback_current_id ();
r->connect (sigc::mem_fun (this, &XMMSHandler::playback_current_id));
m_client.playback.getStatus (bind (&XMMSHandler::playback_status, this));
m_client.playback.broadcastStatus (
bind (&XMMSHandler::playback_status, this));
r = m_xmmsc->broadcast_playback_current_id ();
r->connect (sigc::mem_fun (this, &XMMSHandler::playback_current_id));
m_client.playback.broadcastVolumeChanged (
bind (&XMMSHandler::volume_changed, this));
r = m_xmmsc->playback_status ();
r->connect (sigc::mem_fun (this, &XMMSHandler::playback_status));
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 ()));
QObject::connect (&m_playtime_timer, SIGNAL (timeout ()),
this, SLOT (restartPlaytime ()));
m_playtime_timer.start(0);
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;
res->getValue (&i);
if (i > 0) {
XMMSResultDict *r = m_xmmsc->medialib_get_info (i);
r->connect (sigc::mem_fun (this, &XMMSHandler::medialib_info));
}
if (res->getClass() == XMMSC_RESULT_CLASS_DEFAULT) {
delete res;
}
m_client.playlist.addUrl (s.toAscii ().constData (), &log);
}
void
XMMSHandler::playlistRemove (uint pos)
{
m_client.playlist.remove (pos, &log);
}
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);
r->connect (sigc::mem_fun (this, &XMMSHandler::medialib_info));
m_client.medialib.getInfo (id,
Xmms::bind (&XMMSHandler::medialib_info, this));
}
void
XMMSHandler::requestPlaylistList (void)
XMMSHandler::requestPlaylistList ()
{
XMMSResultValueList<uint> *r = m_xmmsc->playlist_list ();
r->connect (sigc::mem_fun (this, &XMMSHandler::playlist_list));
m_client.playlist.list (Xmms::bind (&XMMSHandler::playlist_list, this));
}
void
XMMSHandler::requestTrackChange (int pos)
{
XMMSResult *r = m_xmmsc->playlist_set_next (pos);
delete r;
XMMSResult *r2 = m_xmmsc->playback_tickle ();
delete r2;
m_client.playlist.setNext (pos, &logUint);
m_client.playback.tickle (&log);
}
void
XMMSHandler::playlist_list (XMMSResultValueList<uint> *res)
bool
XMMSHandler::playlist_list (const Xmms::List< unsigned int > &playlist)
{
QList<uint> list;
for (;res->listValid (); res->listNext()) {
uint i;
if (res->getValue (&i)) {
list.append (i);
}
for (;playlist.isValid (); ++playlist) {
list.append (*playlist);
}
emit playlistList (list);
delete res;
return false;
}
void
XMMSHandler::playback_status (XMMSResultValue<uint> *res)
bool
XMMSHandler::playback_status (const Xmms::Playback::Status &status)
{
uint status;
res->getValue (&status);
emit playbackStatusChanged (status);
if (res->getClass() == XMMSC_RESULT_CLASS_DEFAULT) {
delete res;
}
return true;
}
void
XMMSHandler::playback_playtime (XMMSResultValue<uint> *res)
bool
XMMSHandler::playback_playtime (const unsigned int &time)
{
uint i;
res->getValue (&i);
emit playtimeChanged (i);
m_playtime = res;
emit playtimeChanged (time);
m_playtime_timer.start (500);
return false;
}
void
XMMSHandler::playback_current_id (XMMSResultValue<uint> *res)
bool
XMMSHandler::playback_current_id (const unsigned int &id)
{
uint i;
res->getValue (&i);
m_currentid = id;
m_currentid = i;
if (i > 0) {
XMMSResultDict *r = m_xmmsc->medialib_get_info (i);
r->connect (sigc::mem_fun (this, &XMMSHandler::medialib_info));
if (id > 0) {
requestMediainfo (id);
}
emit currentID(i);
if (res->getClass() == XMMSC_RESULT_CLASS_DEFAULT) {
delete res;
}
emit currentID(id);
return true;
}
void
XMMSHandler::setPlaytime (uint pos)
{
delete m_xmmsc->playback_seek_ms (pos);
m_client.playback.seekMs (pos, &log);
}
QHash<QString, QString>
XMMSHandler::DictToQHash (XMMSResultDict *res)
void
XMMSHandler::DictToQHash (const std::string &key,
const Xmms::Dict::Variant &value,
QHash<QString, QString> &hash)
{
QHash<QString, QString> h;
std::list<const char *> l = res->getDictKeys ();
std::list<const char *>::const_iterator it;
for(it=l.begin(); it!=l.end(); ++it)
{
if (res->getDictValueType (*it) == XMMSC_RESULT_VALUE_TYPE_UINT32) {
uint 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_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));
}
if (value.type () == typeid (int)) {
hash.insert (QString::fromLatin1 (key.c_str ()),
QString::number (boost::get< int > (value)));
} else if (value.type () == typeid (unsigned int)) {
hash.insert (QString::fromLatin1 (key.c_str ()),
QString::number (boost::get< unsigned int > (value)));
} else if (value.type () == typeid (unsigned int)) {
hash.insert (QString::fromLatin1 (key.c_str ()),
QString::fromUtf8 (boost::get< std::string > (value).c_str ()));
}
return h;
}
QHash<QString, QString>
XMMSHandler::PropDictToQHash (XMMSResultDict *res)
void
XMMSHandler::PropDictToQHash (const std::string &key,
const Xmms::Dict::Variant &value,
const std::string &source,
QHash<QString, QString> &hash)
{
QHash<QString, QString> h;
std::list<const char *> l = res->getPropDictKeys ();
std::list<const char *>::const_iterator it;
for(it=l.begin(); it!=l.end(); ++it)
{
if (res->getDictValueType (*it) == XMMSC_RESULT_VALUE_TYPE_UINT32) {
uint 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_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));
}
if (value.type () == typeid (int)) {
hash.insert (QString::fromLatin1 (key.c_str ()),
QString::number (boost::get< int > (value)));
} else if (value.type () == typeid (unsigned int)) {
hash.insert (QString::fromLatin1 (key.c_str ()),
QString::number (boost::get< unsigned int > (value)));
} else {
hash.insert (QString::fromLatin1 (key.c_str ()),
QString::fromUtf8 (boost::get< std::string > (value).c_str()));
}
return h;
}
/*
@ -273,68 +232,83 @@ XMMSHandler::medialib_select (XMMSResultDictList *res)
}
*/
void
XMMSHandler::playlist_changed (XMMSResultDict *res)
bool
XMMSHandler::playlist_changed (const Xmms::Dict &list)
{
QHash<QString, QString> h(DictToQHash (res));
emit playlistChanged (h);
QHash<QString, QString> hash;
#ifdef foreach
#undef foreach
#endif
list.foreach (boost::bind (&XMMSHandler::DictToQHash, this,
_1, _2, boost::ref (hash)));
emit playlistChanged (hash);
return true;
}
void
XMMSHandler::medialib_info (XMMSResultDict *res)
bool
XMMSHandler::medialib_info (const Xmms::PropDict &propdict)
{
int id;
QHash<QString, QString> h(PropDictToQHash (res));
res->getValue ("id", &id);
emit mediainfoChanged (id, h);
QHash<QString, QString> hash;
#ifdef foreach
#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 ();
p->connect (sigc::mem_fun (this, &XMMSHandler::volume_get));
m_client.playback.volumeGet (Xmms::bind (&XMMSHandler::volume_get, this),
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);
delete m_xmmsc->playback_volume_set ("right", volume);
m_client.playback.volumeSet ("left", volume, &log);
m_client.playback.volumeSet ("right", volume, &log);
}
}
void
XMMSHandler::volume_changed (XMMSResult *res)
bool
XMMSHandler::volume_changed (const Xmms::Dict &levels)
{
volumeGet ();
volume_get (levels);
return true;
}
void
XMMSHandler::volume_get (XMMSResultDict *res)
bool
XMMSHandler::volume_get (const Xmms::Dict &levels)
{
if (res->isError()) {
qWarning ("couldn't get volume levels!");
return;
}
QHash<QString, QString> h (DictToQHash (res));
QList<QString> Values = h.values();
QHash<QString, QString> hash;
#ifdef foreach
#undef foreach
#endif
levels.foreach (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());
@ -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;
}

88
XMMSHandler.h
View file

@ -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);
void playback_current_id (XMMSResultValue<uint> *res);
void medialib_info (XMMSResultDict *res);
void playlist_changed (XMMSResultDict *res);
void playback_status (XMMSResultValue<uint> *res);
void playlist_list (XMMSResultValueList<uint> *res);
void medialib_entry_changed (XMMSResultValue<uint> *res);
void medialib_select (XMMSResultDictList *res);
void volume_changed (XMMSResult *res);
void volume_get (XMMSResultDict *res);
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);
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 playlistMove (uint pos, uint newpos) { delete m_xmmsc->playlist_move (pos, newpos); }
/*
void medialib_select (XMMSResultDictList *res);
*/
/*
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 (void) { emit settingsSaved (); }
void updateSettings () { emit settingsSaved (); }
public slots:
void setPlaytime (uint pos);
void restartPlaytime (void);
void restartPlaytime ();
void playlistClear () { delete m_xmmsc->playlist_clear (); }
void play () { delete m_xmmsc->playback_start (); }
void stop () { delete m_xmmsc->playback_stop (); }
void pause () { delete m_xmmsc->playback_pause (); }
void next () {
delete m_xmmsc->playlist_set_next_rel (1);
delete m_xmmsc->playback_tickle ();
}
void prev () {
delete m_xmmsc->playlist_set_next_rel (-1);
delete m_xmmsc->playback_tickle ();
}
void playlistClear ();
void play ();
void stop ();
void pause ();
void next ();
void prev ();
signals:
void settingsSaved (void);
void playbackStatusChanged (uint status);
void settingsSaved ();
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);
QHash<QString, QString> PropDictToQHash (XMMSResultDict *res);
QHash<QString, QString> DictToQHash (XMMSResultDict *res);
XMMSHandler ();
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;
XMMSClient *m_xmmsc;
static XMMSHandler *singleton;
int m_currentid;
bool m_masterchan;
};

2
XmmsQT4.cpp
View file

@ -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)

7
promoe.pro
View file

@ -22,8 +22,7 @@ SOURCES += XmmsQT4.cpp \
qtmd5.cpp \
SettingsWindow.cpp \
PlaylistMenu.cpp \
VolumeSlider.cpp \
xmmsclient_promoe.cpp
VolumeSlider.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