(request)->metaData();
// Copy new stuff into our own m_currentTrack
m_currentTrack.setArtist( metadata.artist() );
m_currentTrack.setTrack( metadata.track() );
m_currentTrack.setTrackPageUrl( metadata.trackPageUrl() );
if ( !metadata.album().isEmpty() )
{
m_currentTrack.setAlbum( metadata.album() );
m_currentTrack.setAlbumPageUrl( metadata.albumPageUrl() );
}
m_currentTrack.setAlbumPicUrl( metadata.albumPicUrl() );
m_currentTrack.setLabel( metadata.label() );
m_currentTrack.setLabelUrl( metadata.labelUrl() );
m_currentTrack.setNumTracks( metadata.numTracks() );
m_currentTrack.setReleaseDate( metadata.releaseDate() );
m_currentTrack.setBuyTrackString( metadata.buyTrackString() );
m_currentTrack.setBuyTrackUrl( metadata.buyTrackUrl() );
m_currentTrack.setBuyAlbumString( metadata.buyAlbumString() );
m_currentTrack.setBuyAlbumUrl( metadata.buyAlbumUrl() );
// if track has changed before we got this metadata, don't emit the event ;)
emit event( Event::TrackMetaDataAvailable, QVariant::fromValue( m_currentTrack ) );
}
break;
default:
break;
}
}
void
LastFmApplication::onListenerException( const QString& msg )
{
#ifndef LASTFM_MULTI_PROCESS_HACK
// Can't do much else than fire up a dialog box of doom at this stage
LastMessageBox::critical( tr( "Plugin Listener Error" ), msg );
#else
// don't make debugging a pita, clearly this isn't meant for release builds though
m_container->statusBar()->showMessage( msg );
#endif
}
void
LastFmApplication::onControlConnect()
{
// Incoming connection from either a webbrowser or
// some other program like the firefox extension.
QTcpSocket* socket = m_control->nextPendingConnection();
connect( socket, SIGNAL( readyRead() ), SLOT( onControlRequest() ) );
}
void
LastFmApplication::onControlRequest()
{
QTcpSocket* socket = (QTcpSocket*)sender();
QString request = socket->readAll();
LOGL( 3, "clientRequest (old instance): " << request );
foreach( QString cmd, request.split( " " ) )
parseCommand( cmd );
socket->flush();
socket->close();
socket->deleteLater();
}
void
LastFmApplication::parseCommand( const QString& request )
{
Q_DEBUG_BLOCK << request;
if ( request.contains( "lastfm://" ) )
{
#ifndef HIDE_RADIO
LOGL( 3, "Calling radio with station" );
if ( !m_handshaked )
m_preloadStation = StationUrl( request );
else
m_radio->playStation( StationUrl( request ) );
#endif // HIDE_RADIO
}
if ( request.contains( "container://show" ) )
{
m_container->restoreWindow();
}
#ifndef Q_WS_X11
if ( request.contains( "container://SubmitScrobbleCache/Device" ) )
{
QStringList const params = request.split( "container://SubmitScrobbleCache/Device/" ).value( 1 ).split( "/" );
int const vid = params.value( 2 ).toInt(); //vendor id
int const pid = params.value( 3 ).toInt(); //product id
QString const uid = params.value( 0 ) + '/' + params.value( 1 );
QString username = The::settings().usernameForDeviceId( uid );
if ( username.isEmpty() )
{
username = The::currentUsername();
The::settings().addMediaDevice( uid, username );
}
if ( The::currentUsername() != username )
{
LastMessageBox::warning( tr("iPod Scrobbling"),
tr("This iPod is associated with a different Last.fm account."
"
Please log in as %1 to submit the scrobbles."
"
You can change the user association in the Options dialog.").arg( username ),
QMessageBox::Ok,
QMessageBox::Ok );
}
else
{
IPodScrobbler( username, m_container ).exec();
}
}
if ( request.startsWith( "container://Notification" ) && !ConfigWizard::isActive() )
{
QString title, message;
QStringList keys = request.mid( 12 ).split( '/' );
if (keys.value( 1 ) == "Twiddly")
{
title = tr("iPod Scrobbling");
QString key = keys.value( 2 );
// ask Toby if you wonder why we don't show any of these messages
// by default
if (The::currentUser().giveMoreIPodScrobblingFeedback())
{
if ( key == "Started" )
message = tr( "Your iPod scrobbles are being determined. Please don't exit iTunes." );
if ( key == "Error" )
{
title = tr( "iPod Scrobbling Error" );
message = keys.value( 3 ).replace( '_', ' ' );
}
if ( key == "Finished" )
{
int const n = keys.value( 3 ).toInt();
if (n)
message = tr( "Last.fm found %n scrobbles on your iPod.", "", n );
else
message = tr( "No scrobbles were found on your iPod." );
}
}
if (key == "Bootstrap")
{
key = keys.value( 3 );
if (key == "Started")
message = tr("Preparing for iPod scrobbling, please don't exit iTunes or sync your iPod.");
if (key == "Finished")
message = tr("Last.fm is now ready for iPod scrobbling.");
}
}
else
{
QString key = keys.value( 2 );
if ( key == "IPodDetected" )
{
title = tr( "iPod detected" );
message = tr( "Your iPod will be scrobbled to your Last.fm profile from now on." );
}
}
if (!message.isEmpty())
{
m_container->showNotification( title, message );
}
}
#endif
}
void
LastFmApplication::onBootstrapReady( QString userName, QString pluginId )
{
#ifndef Q_WS_X11
// Ignore the bootstrap if we're not currently logged in as the user who initiated it.
// (The bootstrap file will be detected when the user who initiated it logs back in.)
if ( userName != The::currentUsername() )
{
LastMessageBox::warning( "Bootstrap detected",
QString( "Bootstrap information was detected for user %1.\n"
"Please log in as %1 to submit this." ).arg( userName ),
QMessageBox::Ok,
QMessageBox::Ok );
return;
}
PluginBootstrapper* bootstrapper = new PluginBootstrapper( pluginId, this );
bootstrapper->submitBootstrap();
#endif
}
void
LastFmApplication::onFingerprintQueryDone( TrackInfo track, bool fullFpRequested )
{
// We're using the path here as the track metadata could have been changed by
// a metadata request in-between requesting the fp and getting it.
if ( m_currentTrack.path() != track.path() )
return;
m_currentTrack.setFpId( track.fpId() );
if ( fullFpRequested && The::settings().currentUser().fingerprintingEnabled() )
{
m_fpCollector->fingerprint( QList() << m_currentTrack );
}
if ( qApp->arguments().contains( "--norman" ) )
{
if ( track.fpId() != "0" && !track.fpId().isEmpty() && !fullFpRequested )
{
m_activeNorman = new FrikkinNormanRequest();
m_activeNorman->setFpId( track.fpId() );
connect( m_activeNorman, SIGNAL( result( Request* ) ), SLOT( onNormanRequestDone( Request* ) ) );
m_activeNorman->start();
}
else
{
m_activeNorman = 0;
//m_container->statusBar()->showMessage( "Norman sez: I not know dis one" );
}
}
}
void
LastFmApplication::onNormanRequestDone( Request* r )
{
FrikkinNormanRequest* req = static_cast( r );
if ( req != m_activeNorman || req->failed() )
return;
//m_container->statusBar()->showMessage( req->metadata() );
m_activeNorman = 0;
}
namespace The
{
User& user() { return The::app().user(); }
Radio& radio() { return The::app().radio(); }
ScrobblerManager& scrobbler() { return The::app().scrobbler(); }
}
lastfm-1.5.4.27091+dfsg1/src/simplewizard.cpp 0000644 0000000 0000000 00000007606 11031266061 017200 0 ustar root root /***************************************************************************
* Copyright (C) 2005 - 2007 by *
* Christian Muehlhaeuser, Last.fm Ltd *
* Erik Jaelevik, Last.fm Ltd *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 2 of the License, or *
* (at your option) any later version. *
* *
* This program is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with this program; if not, write to the *
* Free Software Foundation, Inc., *
* 51 Franklin Steet, Fifth Floor, Boston, MA 02110-1301, USA. *
***************************************************************************/
#include "simplewizard.h"
#include
SimpleWizard::SimpleWizard(QWidget *parent)
: QDialog(parent)
{
ui.setupUi(this);
// This stretch pushes all wizard pages upward, we don't want that
//ui.vboxLayout->insertStretch(0, 1);
#ifdef WIN32
ui.line->setFrameShadow(QFrame::Sunken);
#endif
connect(ui.cancelButton, SIGNAL(clicked()), this, SLOT(reject()));
connect(ui.backButton, SIGNAL(clicked()), this, SLOT(backButtonClicked()));
connect(ui.nextButton, SIGNAL(clicked()), this, SLOT(nextButtonClicked()));
}
void
SimpleWizard::enableNext(
bool enable)
{
ui.nextButton->setEnabled(enable);
}
void
SimpleWizard::enableBack(
bool enable)
{
ui.backButton->setEnabled(enable);
}
void SimpleWizard::setNumPages(int n)
{
mNumPages = n;
//mHistory.append(createPage(0));
//switchPage(NULL, mHistory.last());
}
void SimpleWizard::backButtonClicked()
{
ui.nextButton->setEnabled(true);
QWidget *oldPage = mHistory.takeLast();
switchPage(oldPage, mHistory.last());
delete oldPage;
}
void SimpleWizard::nextButtonClicked()
{
ui.nextButton->setEnabled(true);
if (mHistory.size() == mNumPages)
{
// We're on last page and Finish was just clicked
accept();
}
else
{
QWidget *oldPage = mHistory.isEmpty() ? NULL : mHistory.last();
QWidget* newPage = createPage( mHistory.size() );
if ( newPage )
{
mHistory += newPage;
switchPage(oldPage, mHistory.last());
}
else
nextButtonClicked();
}
}
void SimpleWizard::switchPage(QWidget* oldPage, QWidget* newPage)
{
if (oldPage) {
oldPage->hide();
ui.vboxLayout->removeWidget(oldPage);
}
ui.vboxLayout->insertWidget(0, newPage);
newPage->show();
newPage->setFocus();
updateButtons();
}
void
SimpleWizard::updateButtons()
{
if (mHistory.size() == 1)
{
// Always disable Back on first page
ui.backButton->setEnabled(false);
}
if (mHistory.size() == mNumPages)
{
// Change Next into Finish
ui.nextButton->setText(tr("Finish"));
}
else
{
#ifdef Q_WS_MAC
ui.nextButton->setText(tr("Continue"));
#else
ui.nextButton->setText(tr("Next >"));
#endif
ui.nextButton->setDefault(true);
}
setWindowTitle( mTitle );
}
lastfm-1.5.4.27091+dfsg1/src/ProxyOutput.cpp 0000644 0000000 0000000 00000006476 11031266061 017034 0 ustar root root /***************************************************************************
* Copyright (C) 2005 - 2007 by *
* Christian Muehlhaeuser, Last.fm Ltd *
* Erik Jaelevik, Last.fm Ltd *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 2 of the License, or *
* (at your option) any later version. *
* *
* This program is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with this program; if not, write to the *
* Free Software Foundation, Inc., *
* 51 Franklin Steet, Fifth Floor, Boston, MA 02110-1301, USA. *
***************************************************************************/
#include "ProxyOutput.h"
#include "logger.h"
#include "LastFmSettings.h"
ProxyOutput::ProxyOutput() :
m_active( false ),
m_socket( new QTcpServer( this ) )
{
Q_DEBUG_BLOCK;
connect( m_socket, SIGNAL( newConnection() ),
this, SLOT( onClientConnected() ) );
if ( The::settings().musicProxyPort() )
m_socket->listen( QHostAddress::LocalHost, The::settings().musicProxyPort() );
}
ProxyOutput::~ProxyOutput()
{
Q_DEBUG_BLOCK;
}
void
ProxyOutput::startPlayback()
{
qDebug() << "Playback started";
}
void
ProxyOutput::stopPlayback()
{
qDebug() << "Playback stopped";
m_active = false;
foreach( QTcpSocket* socket, m_clients )
{
m_clients.removeAll( socket );
socket->close();
delete socket;
}
m_buffer.clear();
}
void
ProxyOutput::processData( const QByteArray &buffer )
{
m_active = ( m_clients.count() > 0 );
if ( m_active )
{
m_buffer.append( buffer );
if ( needsData() )
return;
QByteArray avail = buffer.left( 8192 );
foreach( QTcpSocket* socket, m_clients )
{
if ( socket->state() == QTcpSocket::UnconnectedState )
{
m_clients.removeAll( socket );
delete socket;
}
else
{
socket->write( avail, avail.size() );
socket->flush();
}
}
m_buffer.remove( 0, avail.size() );
}
}
void
ProxyOutput::clearBuffers()
{
}
void
ProxyOutput::onClientConnected()
{
QTcpSocket* socket = m_socket->nextPendingConnection();
m_clients << socket;
QByteArray token( "HTTP/1.1 200 OK\nContent-Type: audio/mpeg\n\n" );
socket->write( token, token.length() );
m_active = ( m_clients.count() > 0 );
}
lastfm-1.5.4.27091+dfsg1/src/wizardloginpage.cpp 0000644 0000000 0000000 00000004573 10725516002 017656 0 ustar root root /***************************************************************************
* Copyright (C) 2005 - 2007 by *
* Christian Muehlhaeuser, Last.fm Ltd *
* Erik Jaelevik, Last.fm Ltd *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 2 of the License, or *
* (at your option) any later version. *
* *
* This program is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with this program; if not, write to the *
* Free Software Foundation, Inc., *
* 51 Franklin Steet, Fifth Floor, Boston, MA 02110-1301, USA. *
***************************************************************************/
#include "wizardloginpage.h"
#include "simplewizard.h"
WizardLoginPage::WizardLoginPage(
SimpleWizard* wizard) :
LoginWidget(wizard, ADD_USER),
m_Wizard(wizard)
{
wizard->enableNext(false);
wizard->enableBack(true);
connect(ui.userEdit, SIGNAL(textChanged(const QString &)),
this, SLOT(pageTouched()));
connect(ui.userCombo, SIGNAL(editTextChanged(const QString &)),
this, SLOT(pageTouched()));
connect(ui.passwordEdit, SIGNAL(textChanged(const QString &)),
this, SLOT(pageTouched()));
}
void
WizardLoginPage::pageTouched()
{
if ( (ui.userCombo->currentText().size() != 0 ||
ui.userEdit->text().size() != 0) &&
ui.passwordEdit->text().size() != 0)
{
m_Wizard->enableNext(true);
}
else
{
m_Wizard->enableNext(false);
}
}
lastfm-1.5.4.27091+dfsg1/src/Cleaner/ 0000755 0000000 0000000 00000000000 11750117522 015327 5 ustar root root lastfm-1.5.4.27091+dfsg1/src/Cleaner/Cleaner.vcproj 0000644 0000000 0000000 00000004407 10661076271 020137 0 ustar root root
lastfm-1.5.4.27091+dfsg1/src/Cleaner/Cleaner.rc 0000644 0000000 0000000 00000002121 11474563364 017236 0 ustar root root IDI_ICON1 ICON DISCARDABLE "..\\as.ico"
// The first entry ('1') on the below line is normally written as the define
// VS_VERSION_INFO, but we can't always be sure that value has been included
// in a Qt build so we just hardcode 1 in.
1 VERSIONINFO
FILEVERSION 0,0,0,0
PRODUCTVERSION 0,0,0,0
FILEFLAGSMASK 0x3fL
#ifdef _DEBUG
FILEFLAGS 0x1L
#else
FILEFLAGS 0x0L
#endif
FILEOS 0x4L
FILETYPE 0x1L
FILESUBTYPE 0x0L
BEGIN
BLOCK "StringFileInfo"
BEGIN
BLOCK "040904b0"
BEGIN
VALUE "Comments", "http://www.last.fm"
VALUE "CompanyName", "Last.fm"
VALUE "FileDescription", "Last.fm settings cleaner"
VALUE "FileVersion", "0.0.0.0\0"
VALUE "InternalName", "Cleaner"
VALUE "LegalCopyright", "Copyright (C) 2010"
VALUE "OriginalFilename", "Cleaner.exe"
VALUE "ProductName", "Last.fm Cleaner"
VALUE "ProductVersion", "0.0.0.0\0"
END
END
BLOCK "VarFileInfo"
BEGIN
VALUE "Translation", 0x409, 1200
END
END
lastfm-1.5.4.27091+dfsg1/src/Cleaner/Cleaner.pro 0000644 0000000 0000000 00000000273 11031266061 017417 0 ustar root root TEMPLATE = app
QT -= gui
CONFIG += console
include( ../../definitions.pro.inc )
HEADERS = Cleaner.h
SOURCES = main.cpp \
Cleaner.cpp
RC_FILE = Cleaner.rc
LIBS += -luser32
lastfm-1.5.4.27091+dfsg1/src/Cleaner/trustInfo.manifest 0000644 0000000 0000000 00000001470 10665061421 021056 0 ustar root root
Small utility for cleaning out user-specific settings for the Last.fm software.
lastfm-1.5.4.27091+dfsg1/src/Cleaner/Cleaner.h 0000644 0000000 0000000 00000004325 10725516002 017052 0 ustar root root /***************************************************************************
* Copyright (C) 2005 - 2007 by *
* Last.fm Ltd *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 2 of the License, or *
* (at your option) any later version. *
* *
* This program is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with this program; if not, write to the *
* Free Software Foundation, Inc., *
* 51 Franklin Steet, Fifth Floor, Boston, MA 02110-1301, USA. *
***************************************************************************/
#ifndef CLEANER_H
#define CLEANER_H
#include
#include
/**
* @author
*
* Small tool for clearing out user-space settings for the Last.fm client
* on Windows.
*
* Because of Vista's security design, we can't clear user settings from
* an admin-run uninstaller, so need this separate exe that we run in user-
* space to clean the installation.
*
* The locations it clears are HKEY_CURRENT_USER/Software/Last.fm/Client
* in the registry and CSIDL_LOCAL_APPDATA, e.g. C:\\AppData\Local\
* Last.fm\Client on the hard drive.
*/
class Cleaner
{
public:
Cleaner( const QStringList& argv );
// Returns true on success
bool
clean();
private:
void
cleanRegistry();
bool
cleanFiles();
};
#endif // CLEANER_H
lastfm-1.5.4.27091+dfsg1/src/Cleaner/main.cpp 0000644 0000000 0000000 00000003237 10725516002 016761 0 ustar root root /***************************************************************************
* Copyright (C) 2005 - 2007 by *
* Last.fm Ltd *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 2 of the License, or *
* (at your option) any later version. *
* *
* This program is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with this program; if not, write to the *
* Free Software Foundation, Inc., *
* 51 Franklin Steet, Fifth Floor, Boston, MA 02110-1301, USA. *
***************************************************************************/
#include "Cleaner.h"
#include
/**
* @author
*/
int main( int argc, char* argv[] )
{
QCoreApplication app( argc, argv );
Cleaner c( app.arguments() );
return c.clean() ? 0 : 1;
}
lastfm-1.5.4.27091+dfsg1/src/Cleaner/Cleaner.cpp 0000644 0000000 0000000 00000004462 10725516002 017407 0 ustar root root /***************************************************************************
* Copyright (C) 2005 - 2007 by *
* Last.fm Ltd *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 2 of the License, or *
* (at your option) any later version. *
* *
* This program is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with this program; if not, write to the *
* Free Software Foundation, Inc., *
* 51 Franklin Steet, Fifth Floor, Boston, MA 02110-1301, USA. *
***************************************************************************/
#include "Cleaner.h"
#include "MooseCommon.h"
#include
#include
#include
#include
#include // for system
Cleaner::Cleaner( const QStringList& args )
{
}
bool
Cleaner::clean()
{
cleanRegistry();
return cleanFiles();
}
void
Cleaner::cleanRegistry()
{
QSettings hkcu( "HKEY_CURRENT_USER\\Software\\Last.fm\\Client", QSettings::NativeFormat );
hkcu.clear();
}
bool
Cleaner::cleanFiles()
{
QDir userDir( MooseUtils::savePath( "" ) );
Q_ASSERT( userDir.path().endsWith( "Client" ) || userDir.path().endsWith( "Client/" ) );
// Only works on 2000/XP and upwards, but that's all we support anyway
QString cmd( "rmdir /S /Q \"" + QDir::toNativeSeparators( userDir.path() ) + "\"" );
int retCode = _wsystem( reinterpret_cast( cmd.utf16() ) );
return retCode == 0;
}
lastfm-1.5.4.27091+dfsg1/src/loginwidget.ui 0000644 0000000 0000000 00000017511 10725516002 016633 0 ustar root root
LoginWidget
0
0
350
236
0
0
16
16
16
16
-
Qt::NoFocus
QFrame::NoFrame
Please enter your Last.fm username and password.
-
Qt::Vertical
QSizePolicy::Fixed
293
16
-
-
0
0
Username:
userEdit
-
0
0
190
21
0
0
0
0
0
0
0
0
-
0
21
true
0
0
0
21
0
0
0
0
0
-
-
Qt::Horizontal
40
10
-
0
0
Password:
passwordEdit
-
0
0
190
0
200
16777215
QLineEdit::Password
-
Qt::Horizontal
40
10
-
Remember my password
true
-
Qt::Vertical
QSizePolicy::Expanding
20
30
-
Sign up for a Last.fm account
-
Forgot your password?
URLLabel
QLabel
userEdit
userCombo
passwordEdit
rememberCheck
lastfm-1.5.4.27091+dfsg1/src/failedlogindialog.ui 0000644 0000000 0000000 00000020070 10725516002 017746 0 ustar root root
FailedLoginDialog
0
0
364
269
0
0
Connection Error
0
0
0
0
-
12
16
16
16
16
-
Qt::AlignLeading|Qt::AlignLeft|Qt::AlignTop
-
0
0
Qt::AlignLeading|Qt::AlignLeft|Qt::AlignTop
-
-
Qt::Horizontal
QSizePolicy::Fixed
52
20
-
Proxy Settings...
-
Qt::Horizontal
40
20
-
Qt::Horizontal
-
0
0
16
40
QFrame::NoFrame
QFrame::Raised
-
-
-
Password
-
QLineEdit::Password
-
-
0
0
50
0
50
16777215
Host
-
Port
-
0
0
40
0
40
16777215
-
0
0
0
0
Username
-
Qt::Horizontal
-
-
Qt::Horizontal
131
31
-
OK
-
Cancel
okButton
clicked()
FailedLoginDialog
accept()
278
253
96
254
cancelButton
clicked()
FailedLoginDialog
reject()
369
253
179
282
lastfm-1.5.4.27091+dfsg1/src/iconshack.h 0000644 0000000 0000000 00000011722 11031266061 016067 0 ustar root root /***************************************************************************
* Copyright (C) 2005 - 2007 by *
* Christian Muehlhaeuser, Last.fm Ltd *
* Erik Jaelevik, Last.fm Ltd *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 2 of the License, or *
* (at your option) any later version. *
* *
* This program is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with this program; if not, write to the *
* Free Software Foundation, Inc., *
* 51 Franklin Steet, Fifth Floor, Boston, MA 02110-1301, USA. *
***************************************************************************/
#ifndef ICONSHACK_H
#define ICONSHACK_H
#include "MooseCommon.h"
#include
#include
/*************************************************************************/ /**
Loads and dishes out icons.
******************************************************************************/
class IconShack
{
IconShack() : mbIconsLoaded( false ) {}
public:
~IconShack()
{
Q_ASSERT( true );
}
/*********************************************************************/ /**
Singleton instance
**************************************************************************/
static IconShack& instance()
{
static IconShack instance;
return instance;
}
/*********************************************************************/ /**
Returns the standard user icon in the requested colour.
**************************************************************************/
QPixmap GetGoodUserIcon( MooseEnums::UserIconColour eColour );
/*********************************************************************/ /**
Returns the 32px user icon in the requested colour.
**************************************************************************/
QPixmap GetGoodUserIconCollapsed( MooseEnums::UserIconColour eColour );
/*********************************************************************/ /**
Returns the 32px user icon in the requested colour.
**************************************************************************/
QPixmap GetGoodUserIconExpanded( MooseEnums::UserIconColour eColour );
/*********************************************************************/ /**
Returns the exclamation mark user icon in the requested colour.
**************************************************************************/
QPixmap GetExclUserIcon( MooseEnums::UserIconColour eColour);
/*********************************************************************/ /**
Returns the cross user icon in the requested colour.
**************************************************************************/
QPixmap GetDisabledUserIcon( MooseEnums::UserIconColour eColour);
/*********************************************************************/ /**
Returns a list of frames with the standard coloured user icon,
overlayed by an in progress animation.
**************************************************************************/
QList GetIpodScrobblingIcons( MooseEnums::UserIconColour eColour );
private:
/*********************************************************************/ /**
Load icons from resources.
**************************************************************************/
void LoadIcons();
QPixmap icon( QPixmap[], MooseEnums::UserIconColour );
QPixmap maGoodIcons[ MooseEnums::eColorMax ];
QPixmap maGoodIconsCollapsed[ MooseEnums::eColorMax ];
QPixmap maGoodIconsExpanded[ MooseEnums::eColorMax ];
QPixmap maExclIcons[ MooseEnums::eColorMax ];
QPixmap maDisabledIcons[ MooseEnums::eColorMax ];
QList mIpodScrobblingIcons[ MooseEnums::eColorMax ];
/*********************************************************************/ /**
Generate iPod scrobbling overlay animation.
**************************************************************************/
void GenerateIpodScrobblingIcons( MooseEnums::UserIconColour eColour );
bool mbIconsLoaded;
};
#endif // ICONSHACK_H
lastfm-1.5.4.27091+dfsg1/src/RestStateMessage.cpp 0000644 0000000 0000000 00000013135 11474563364 017724 0 ustar root root /***************************************************************************
* Copyright (C) 2005 - 2007 by *
* Christian Muehlhaeuser, Last.fm Ltd *
* Max Howell, Last.fm Ltd *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 2 of the License, or *
* (at your option) any later version. *
* *
* This program is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with this program; if not, write to the *
* Free Software Foundation, Inc., *
* 51 Franklin Steet, Fifth Floor, Boston, MA 02110-1301, USA. *
***************************************************************************/
#include "RestStateMessage.h"
#include "imagebutton.h"
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
class RestStateWidget;
RestStateMessage::RestStateMessage( QWidget* parent )
: QWidget( (QWidget*)parent )
{
parent->installEventFilter( this );
setAutoFillBackground( true );
setBackgroundRole( QPalette::Window );
QHBoxLayout* h = new QHBoxLayout( this );
h->addWidget( ui.icon = new QLabel );
h->addWidget( ui.text = new QLabel );
ui.text->setOpenExternalLinks( true );
ui.faq = new ImageButton;
ui.faq->setPixmap( QPixmap( ":/button/MoreHelp.png" ) );
ui.faq->setPixmapDown( QPixmap( ":/button/MoreHelpActive.png" ) );
ui.faq->setPixmapHover( QPixmap( ":/button/MoreHelpHover.png" ) );
ui.faq->setCursor( Qt::PointingHandCursor );
h->addWidget( ui.faq );
connect( ui.faq, SIGNAL(clicked()), SIGNAL(moreHelpClicked()) );
h->addWidget( ui.accept = new QPushButton );
ui.accept->setHidden( true );
h->setSpacing( 6 );
ImageButton* close = new ImageButton;
QPixmap const q( ":/button/Close.png" );
close->setPixmap( q );
close->setPixmapDown( QPixmap( ":/button/CloseActive.png" ) );
h->addWidget( close );
connect( close, SIGNAL(clicked()), SLOT(deleteLater()) );
QMessageBox box;
box.setIcon( QMessageBox::Question );
ui.icon->setPixmap( box.iconPixmap() );
// add 6px spacing to icon width for aesthetics
ui.icon->setFixedSize( ui.icon->sizeHint() + QSize( 6, 0 ) );
#ifdef Q_WS_MAC
QPalette p = palette();
p.setColor( QPalette::Window, QColor( 0xff, 0xfc, 0xd1 ) );
p.setColor( QPalette::WindowText, QColor( 0x59, 0x59, 0x59 ) );
setPalette( p );
delete ui.icon; //there is no graphic on mac! *shrug*
QFont f = ui.text->font();
f.setPointSize( 11 );
ui.text->setFont( f );
ui.text->setPalette( p );
#else
setPalette( QToolTip::palette() );
#endif
ui.text->setWordWrap( true );
ui.accept->setSizePolicy( QSizePolicy::Maximum, QSizePolicy::Fixed );
m_timeline = new QTimeLine( 500 /*duration in ms*/, this );
m_timeline->setUpdateInterval( 10 );
connect( m_timeline, SIGNAL(frameChanged( int )), SLOT(onSlideStep( int )) );
connect( m_timeline, SIGNAL(finished()), SLOT(onSlideFinished()) );
connect( ui.accept, SIGNAL(clicked()), SIGNAL(accepted()) );
resize( parent->width(), height());
//explicitly hide or parent() shows us
move( 3000, 3000 );
}
void
RestStateMessage::setMessage( const QString& text )
{
ui.text->setText( text );
}
void
RestStateMessage::setAcceptText( const QString& text )
{
ui.accept->setText( text );
ui.accept->setVisible( true );
}
void
RestStateMessage::onSlideStep( int y )
{
move( 0, parentWidget()->height() - y );
}
void
RestStateMessage::onSlideFinished()
{
// parentWidget()->layout()->addWidget( this );
raise();
m_timeline->deleteLater();
m_timeline = 0;
}
void
RestStateMessage::paintEvent( QPaintEvent* e )
{
QWidget::paintEvent( e );
QPainter p( this );
p.setPen( Qt::gray );
p.drawLine( QPoint(), QPoint( width(), 0 ) );
}
void
RestStateMessage::showEvent( QShowEvent* )
{
if (m_timeline)
{
QTimer::singleShot( 2000, m_timeline, SLOT(start()) );
int const w = parentWidget()->width();
int const h = heightForWidth( w );
resize( w, h );
m_timeline->setFrameRange( 0, h );
}
}
void
RestStateMessage::setFaqVisible( bool visible )
{
ui.faq->setVisible( visible );
}
bool
RestStateMessage::eventFilter( QObject* obj, QEvent* ev )
{
if( ev->type() != QEvent::Resize ) return false;
QResizeEvent* re = static_cast( ev );
move( 0, re->size().height() - height());
resize( re->size().width(), height());
return false;
}
lastfm-1.5.4.27091+dfsg1/src/updateinfogetter.h 0000644 0000000 0000000 00000014674 10725516002 017511 0 ustar root root /***************************************************************************
* Copyright (C) 2005 - 2007 by *
* Christian Muehlhaeuser, Last.fm Ltd *
* Erik Jaelevik, Last.fm Ltd *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 2 of the License, or *
* (at your option) any later version. *
* *
* This program is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with this program; if not, write to the *
* Free Software Foundation, Inc., *
* 51 Franklin Steet, Fifth Floor, Boston, MA 02110-1301, USA. *
***************************************************************************/
#ifndef UPDATEINFOGETTER_H
#define UPDATEINFOGETTER_H
#include "componentinfo.h"
#include "plugininfo.h"
#include "exceptions.h"
#include
#include
class QDomNode;
class CachedHttp;
/*************************************************************************/ /**
Downloads information about our apps and plugins from the last.fm
server.
******************************************************************************/
class CUpdateInfoGetter : public QObject
{
Q_OBJECT
public:
/*********************************************************************/ /**
Ctor/Dtor
**************************************************************************/
CUpdateInfoGetter();
virtual ~CUpdateInfoGetter();
/*********************************************************************/ /**
Fill info with downloaded information about the Audioscrobbler
application itself. Asynchronous, sends signal appInfoReceived when
done.
**************************************************************************/
void
GetUpdateInfo(
CComponentInfo* appInfo,
std::vector* vecPluginInfo,
bool bForceRefresh = true);
/*********************************************************************/ /**
Stops the download.
**************************************************************************/
void
Cancel();
signals:
/*********************************************************************/ /**
Application info downloaded.
**************************************************************************/
void
updateInfoDone(
bool error,
QString errorMsg);
/*********************************************************************/ /**
Plugin info downloaded.
**************************************************************************/
/*
void
pluginInfoDone(
bool error,
QString errorMsg);
*/
/*********************************************************************/ /**
Report a new progress percentage for the current operation.
**************************************************************************/
void
progressMade(
int percentage,
int total);
/*********************************************************************/ /**
Report a new status message for the current operation.
**************************************************************************/
void
statusChange(
QString message);
private:
/*********************************************************************/ /**
Pulls the info down from server.
**************************************************************************/
void
DownloadInfo();
/*********************************************************************/ /**
Populates a component info object.
**************************************************************************/
void
PopulateComponent(
const QDomNode& appNode,
CComponentInfo& info);
/*********************************************************************/ /**
Populates a plugin info object.
**************************************************************************/
void
PopulatePlugin(
const QDomNode& pluginNode,
CPluginInfo& info);
CComponentInfo mApp;
std::vector mPlugins;
CComponentInfo* mExtApp;
std::vector* mExtPlugins;
CachedHttp* mHttp;
int mGetId;
bool mbCancelled;
private slots:
/*********************************************************************/ /**
Called by QHttp when done.
**************************************************************************/
void
downloadFinished(
int requestId,
bool error);
/*********************************************************************/ /**
Called by QHttp when its state changes.
**************************************************************************/
void
statusChanged(
int state);
void sendProgress(int /*p*/, int /*t*/) {
//LOGL(3, "sendProgress made: " << p << "/" << t);
}
void readyRead(const class QHttpResponseHeader & /*resp*/) {
//LOGL(3, "statusCode: " << resp.statusCode() );
//LOGL(3, "reason: " << resp.reasonPhrase() );
}
void requestStarted(int /*id*/) {
//LOGL(3, "id: " << id );
}
void responseHeaderReceived ( const QHttpResponseHeader & /*resp*/ ) {
//LOGL(3, "statusCode: " << resp.statusCode() );
//LOGL(3, "reason: " << resp.reasonPhrase() );
}
};
#endif // UPDATEINFOGETTER_H
lastfm-1.5.4.27091+dfsg1/src/wizardbootstrappage.h 0000644 0000000 0000000 00000004135 10725516002 020222 0 ustar root root /***************************************************************************
* Copyright (C) 2005 - 2007 by *
* Christian Muehlhaeuser, Last.fm Ltd *
* Erik Jaelevik, Last.fm Ltd *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 2 of the License, or *
* (at your option) any later version. *
* *
* This program is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with this program; if not, write to the *
* Free Software Foundation, Inc., *
* 51 Franklin Steet, Fifth Floor, Boston, MA 02110-1301, USA. *
***************************************************************************/
#ifndef WIZARDBOOTSTRAPPAGE_H
#define WIZARDBOOTSTRAPPAGE_H
#include "ui_progresswidget.h"
#include "TrackInfo.h"
class SimpleWizard;
class WizardBootstrapPage : public QWidget
{
Q_OBJECT
public:
WizardBootstrapPage( SimpleWizard* wizard, const QString& info );
public slots:
void onTrackFound( int percentage, const TrackInfo& track );
void onUploadProgress( int percentage );
void setInfo( QString info );
signals:
void infoChanged( QString info );
private:
Ui::ProgressWidget uiProgress;
friend class SimpleWizard;
};
#endif // WIZARDBOOTSTRAPPAGE_H
lastfm-1.5.4.27091+dfsg1/src/WizardTwiddlyBootstrapPage.h 0000644 0000000 0000000 00000003566 11031266061 021430 0 ustar root root /***************************************************************************
* Copyright 2008 Last.fm Ltd. *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 2 of the License, or *
* (at your option) any later version. *
* *
* This program is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with this program; if not, write to the *
* Free Software Foundation, Inc., *
* 51 Franklin Steet, Fifth Floor, Boston, MA 02110-1301, USA. *
***************************************************************************/
#ifndef WIZARD_TWIDDLY_BOOTSTRAP_PAGE_H
#define WIZARD_TWIDDLY_BOOTSTRAP_PAGE_H
#include "ui_progresswidget.h"
/** @author
*/
class WizardTwiddlyBootstrapPage : public QWidget
{
Q_OBJECT
public:
WizardTwiddlyBootstrapPage( QWidget* parent );
signals:
void done();
private slots:
void onStdOut();
void onFinished();
void onError();
private:
virtual void showEvent( QShowEvent* );
private:
Ui::ProgressWidget ui;
class QProcess* m_process;
};
#endif
lastfm-1.5.4.27091+dfsg1/src/settingsdialog.cpp 0000644 0000000 0000000 00000073372 11276145317 017524 0 ustar root root /***************************************************************************
* Copyright (C) 2005 - 2008 by *
* Christian Muehlhaeuser, Last.fm Ltd *
* Erik Jaelevik, Last.fm Ltd *
* Jono Cole, Last.fm Ltd *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 2 of the License, or *
* (at your option) any later version. *
* *
* This program is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with this program; if not, write to the *
* Free Software Foundation, Inc., *
* 51 Franklin Steet, Fifth Floor, Boston, MA 02110-1301, USA. *
***************************************************************************/
#ifdef WIN32
#include
#endif
#include "MooseCommon.h"
#include "UnicornCommon.h"
#include "logger.h"
#include
#include
#include
#include
#include "Radio.h"
#include "LastFmSettings.h"
#include "settingsdialog.h"
#include "lastfmapplication.h"
#include "container.h"
#include "LastMessageBox.h"
#include "loginwidget.h"
// This is a terrible way of entering strings but I couldn't get VS to recognise
// the Unicode chars in any other way.
static const unsigned char kChinese[] =
{ 0xE4, 0xB8, 0xAD, 0xE6, 0x96, 0x87, 0x0 };
static const unsigned char kRussian[] =
{ 0xD0, 0xA0, 0xD1, 0x83, 0xD1, 0x81, 0xD1, 0x81, 0xD0, 0xBA,
0xD0, 0xB8, 0xD0, 0xB9, 0x0 };
static const unsigned char kJapanese[] =
{ 0xE6, 0x97, 0xA5, 0xE6, 0x9C, 0xAC, 0xE8, 0xAA, 0x9E, 0x0 };
SettingsDialog::SettingsDialog( QWidget *parent )
: QDialog( parent ),
m_reconnect( false ),
m_reAudio( false ),
m_populating( false ),
m_closeAfterVerification( false )
{
ui.setupUi( this );
#ifdef Q_WS_MAC
setWindowTitle( tr( "Last.fm Preferences" ) );
#else
setWindowTitle( tr( "Last.fm Options" ) );
#endif
// Create pages and add them to stack widget
QWidget* accountWidget = new QWidget();
ui_account.setupUi( accountWidget );
ui.pageStack->addWidget( accountWidget );
m_loginWidget = new LoginWidget( this, LoginWidget::CHANGE_PASS, The::settings().currentUsername() );
ui_account.accountBox->layout()->addWidget( m_loginWidget );
QWidget* radioWidget = new QWidget();
ui_radio.setupUi( radioWidget );
ui.pageStack->addWidget( radioWidget );
QWidget* scrobWidget = new QWidget();
ui_scrobbling.setupUi( scrobWidget );
ui.pageStack->addWidget( scrobWidget );
QWidget* connWidget = new QWidget();
ui_connection.setupUi( connWidget );
ui.pageStack->addWidget( connWidget );
#ifndef Q_WS_X11
QWidget* mediadeviceWidget = new QWidget();
ui_mediadevices.setupUi( mediadeviceWidget );
ui_mediadevices.deviceWidget->header()->setResizeMode( QHeaderView::ResizeToContents );
ui.pageStack->addWidget( mediadeviceWidget );
#endif
#ifdef NBREAKPAD
ui_connection.crashReportCheck->hide();
#endif
// Add icons to user icon dropdown
QPixmap pixmap( MooseUtils::dataPath( "icons/user_red.png" ) );
ui_account.colourCombo->setItemIcon( 0, pixmap );
pixmap.load( MooseUtils::dataPath( "icons/user_blue.png" ) );
ui_account.colourCombo->setItemIcon( 1, pixmap );
pixmap.load( MooseUtils::dataPath( "icons/user_green.png" ) );
ui_account.colourCombo->setItemIcon( 2, pixmap );
pixmap.load( MooseUtils::dataPath( "icons/user_orange.png" ) );
ui_account.colourCombo->setItemIcon( 3, pixmap );
pixmap.load( MooseUtils::dataPath( "icons/user_black.png" ) );
ui_account.colourCombo->setItemIcon( 4, pixmap );
// Add languages to language drop-down
ui_account.languageCombo->addItem( tr( "System Language" ), "" );
ui_account.languageCombo->addItem( "English",
UnicornUtils::qtLanguageToLfmLangCode( QLocale::English ) );
ui_account.languageCombo->addItem( QString( "Fran" ) + QChar( 0xe7 ) + QString( "ais" ),
UnicornUtils::qtLanguageToLfmLangCode( QLocale::French ) );
ui_account.languageCombo->addItem( "Italiano",
UnicornUtils::qtLanguageToLfmLangCode( QLocale::Italian ) );
ui_account.languageCombo->addItem( "Deutsch",
UnicornUtils::qtLanguageToLfmLangCode( QLocale::German ) );
ui_account.languageCombo->addItem( QString( "Espa" ) + QChar( 0xf1 ) + QString( "ol" ),
UnicornUtils::qtLanguageToLfmLangCode( QLocale::Spanish ) );
ui_account.languageCombo->addItem( QString( "Portugu" ) + QChar( 0xea ) + QString( "s" ),
UnicornUtils::qtLanguageToLfmLangCode( QLocale::Portuguese ) );
ui_account.languageCombo->addItem( "Polski",
UnicornUtils::qtLanguageToLfmLangCode( QLocale::Polish ) );
ui_account.languageCombo->addItem( "Svenska",
UnicornUtils::qtLanguageToLfmLangCode( QLocale::Swedish ) );
ui_account.languageCombo->addItem( QString::fromUtf8( "Türkçe" ),
UnicornUtils::qtLanguageToLfmLangCode( QLocale::Turkish ) );
ui_account.languageCombo->addItem( QString::fromUtf8( (const char*) kRussian ),
UnicornUtils::qtLanguageToLfmLangCode( QLocale::Russian ) );
ui_account.languageCombo->addItem( QString::fromUtf8( (const char*) kChinese ),
UnicornUtils::qtLanguageToLfmLangCode( QLocale::Chinese ) );
ui_account.languageCombo->addItem( QString::fromUtf8( "日本語" ),
UnicornUtils::qtLanguageToLfmLangCode( QLocale::Japanese ) );
// Add icons to sidebar
pixmap.load( MooseUtils::dataPath( "/icons/options_account.png" ) );
//pixmap.scaled( 48, 48, Qt::IgnoreAspectRatio, Qt::SmoothTransformation );
ui.pageList->item( 0 )->setIcon( pixmap );
pixmap.load( MooseUtils::dataPath( "/icons/options_radio.png" ) );
//pixmap.scaled( 48, 48, Qt::IgnoreAspectRatio, Qt::SmoothTransformation );
ui.pageList->item( 1 )->setIcon( pixmap );
#ifdef HIDE_RADIO
ui.pageList->setItemHidden( ui.pageList->item( 1 ), true );
#endif // HIDE_RADIO
pixmap.load( MooseUtils::dataPath( "/icons/options_scrobbling.png" ) );
//pixmap.scaled( 48, 48, Qt::IgnoreAspectRatio, Qt::SmoothTransformation );
ui.pageList->item( 2 )->setIcon( pixmap );
pixmap.load( MooseUtils::dataPath( "/icons/options_connection.png" ) );
//pixmap.scaled( 48, 48, Qt::IgnoreAspectRatio, Qt::SmoothTransformation );
ui.pageList->item( 3 )->setIcon( pixmap );
pixmap.load( MooseUtils::dataPath( "/icons/options_mediadevices.png" ) );
//pixmap.scaled( 48, 48, Qt::IgnoreAspectRatio, Qt::SmoothTransformation );
ui.pageList->item( 4 )->setIcon( pixmap );
#ifdef Q_WS_X11
ui.pageList->setRowHidden( 4, true );
#endif
#ifdef HIDE_RADIO
// Need to disable this as the language choice is hardcoded at startup
// (see LastfmApp::initTranslator) for the jp version.
ui_account.languageCombo->hide();
ui_account.languageLabel->hide();
#endif
#ifdef Q_WS_MAC
ui_account.colourCombo->hide();
ui_account.colourLabel->hide();
#else
ui_account.showInDockCheck->hide();
#endif
ui_scrobbling.scrobblePointSlider->setMinimum( MooseConstants::kScrobblePointMin );
ui_scrobbling.scrobblePointSlider->setMaximum( MooseConstants::kScrobblePointMax );
// Fix width of scrobble point label so it doesn't make the slider jump about
int maxWidth = ui_scrobbling.scrobblePointLabel->fontMetrics().width( "100" );
ui_scrobbling.scrobblePointLabel->setFixedWidth( maxWidth );
#ifdef Q_WS_MAC
ui_scrobbling.launchWithMediaPlayerCheck->setText( tr( "Launch Last.fm with iTunes" ) );
#else
ui_scrobbling.launchWithMediaPlayerCheck->hide();
#endif
adjustSize();
connect( ui.buttonBox, SIGNAL( accepted() ), SLOT( onOkClicked() ) );
connect( ui.buttonBox, SIGNAL( rejected() ), SLOT( reject() ) );
connect( ui.buttonBox->button( QDialogButtonBox::Apply ), SIGNAL( clicked() ), SLOT( applyPressed() ) );
connect( ui.pageList, SIGNAL( currentRowChanged( int ) ), SLOT( pageSwitched( int ) ) );
connect( ui_connection.clearCacheButton, SIGNAL( clicked() ), SLOT( clearCache() ) );
connect( m_loginWidget, SIGNAL( verifyResult( bool, bool ) ), SLOT( verifiedAccount( bool, bool ) ) );
connect( m_loginWidget, SIGNAL( widgetChanged() ), this, SLOT( configChanged() ) );
connect( ui_account.colourCombo, SIGNAL( currentIndexChanged( int ) ), this, SLOT( configChanged() ) );
connect( ui_account.languageCombo, SIGNAL( currentIndexChanged( int ) ), this, SLOT( configChanged() ) );
connect( ui_account.showInTrayCheck, SIGNAL( toggled( bool ) ), this, SLOT( configChanged() ) );
connect( ui_radio.resumeCheckBox, SIGNAL( toggled( bool ) ), this, SLOT( configChanged() ) );
connect( ui_radio.cardBox, SIGNAL( currentIndexChanged( int ) ), this, SLOT( configChanged() ) );
connect( ui_radio.systemBox, SIGNAL( currentIndexChanged( int ) ), this, SLOT( configChanged() ) );
connect( ui_radio.automaticBufferCheck, SIGNAL( toggled( bool ) ), this, SLOT( configChanged() ) );
connect( ui_radio.bufferEdit, SIGNAL( textChanged( QString ) ), this, SLOT( configChanged() ) );
connect( ui_radio.musicProxyPort, SIGNAL( valueChanged( int ) ), this, SLOT( configChanged() ) );
connect( ui_scrobbling.dirTree, SIGNAL( dataChanged() ), this, SLOT( configChanged() ) );
connect( ui_scrobbling.scrobblePointSlider, SIGNAL( valueChanged( int ) ), this, SLOT( configChanged() ) );
connect( ui_scrobbling.launchWithMediaPlayerCheck, SIGNAL( toggled( bool ) ), this, SLOT( configChanged() ) );
connect( ui_scrobbling.fingerprintCheckBox, SIGNAL( stateChanged( int ) ), this, SLOT( configChanged() ) );
connect( ui_connection.proxyBox, SIGNAL( toggled( bool ) ), this, SLOT( configChanged() ) );
connect( ui_connection.proxyHostEdit, SIGNAL( textChanged( QString ) ), this, SLOT( configChanged() ) );
connect( ui_connection.proxyPortEdit, SIGNAL( textChanged( QString ) ), this, SLOT( configChanged() ) );
connect( ui_connection.proxyUsernameEdit, SIGNAL( textChanged( QString ) ), this, SLOT( configChanged() ) );
connect( ui_connection.proxyPasswordEdit, SIGNAL( textChanged( QString ) ), this, SLOT( configChanged() ) );
connect( ui_connection.automaticProxyButton, SIGNAL( toggled( bool ) ), this, SLOT( configChanged() ) );
connect( ui_connection.manualProxyButton, SIGNAL( toggled( bool ) ), this, SLOT( configChanged() ) );
connect( ui_connection.downloadMetadataCheck, SIGNAL( toggled( bool ) ), this, SLOT( configChanged() ) );
#ifndef NBREAKPAD
connect( ui_connection.crashReportCheck, SIGNAL( toggled( bool ) ), this, SLOT( configChanged() ) );
#endif
#ifndef Q_WS_X11
connect( ui_mediadevices.enableIPodScrobbling, SIGNAL( toggled( bool ) ), SLOT( configChanged() ) );
connect( ui_mediadevices.alwaysConfirmIPodScrobbles, SIGNAL( toggled( bool ) ), SLOT( configChanged() ) );
connect( ui_mediadevices.giveMoreFeedback, SIGNAL( toggled( bool ) ), SLOT( configChanged() ) );
connect( ui_mediadevices.clearUserAssociations, SIGNAL( clicked() ), SLOT( clearUserIPodAssociations() ) );
#endif
#ifdef Q_WS_MAC
connect( ui_scrobbling.launchWithMediaPlayerCheck, SIGNAL( toggled( bool ) ), this, SLOT( configChanged() ) );
connect( ui_account.showInDockCheck, SIGNAL( toggled( bool ) ), this, SLOT( configChanged() ) );
#endif
}
int
SettingsDialog::exec( int startPage )
{
m_reconnect = false;
m_reAudio = false;
m_loginWidget->resetWidget( The::settings().currentUsername() );
originalUsername = The::settings().currentUser().username();
originalPassword = The::settings().currentUser().password();
originalProxyHost = The::settings().getProxyHost();
originalProxyUsername = The::settings().getProxyUser();
originalProxyPassword = The::settings().getProxyPassword();
originalProxyPort = The::settings().getProxyPort();
originalProxyUsage = The::settings().isUseProxy();
originalSoundCard = The::settings().soundCard();
originalSoundSystem = The::settings().soundSystem();
// This bool is just to prevent signals emitted by the programmatic
// populating of widgets from being mistakenly interpreted as user
// interaction.
m_populating = true;
populateAccount();
populateRadio();
populateScrobbling();
populateConnection();
#ifndef Q_WS_X11
populateMediaDevices();
#endif
loadExtensions();
foreach ( ExtensionInterface* i, m_extensions )
i->populateSettings();
m_populating = false;
pageSwitched( startPage );
ui.buttonBox->button( QDialogButtonBox::Apply )->setEnabled( false );
return QDialog::exec();
}
void
SettingsDialog::loadExtensions()
{
foreach( QString path, Moose::extensionPaths() )
{
// NOTE we should test isLoaded() first really, but for some reason
// this wasn't working on Windows with Qt 4.3.1
QObject* plugin = QPluginLoader( path ).instance();
if ( !plugin )
{
LOGL( 2, "Failed to retrieve instance from loaded plugin: " << path );
continue;
}
ExtensionInterface* iExtension = qobject_cast( plugin );
if ( iExtension && iExtension->hasSettingsPane() )
{
LOGL( 3, "Loaded a settings extension from: " << path );
addExtension( iExtension ); //adds page to dialog
}
}
}
#ifdef Q_WS_MAC
static bool appHasDockIcon()
{
QProcess p;
p.start( "defaults", QStringList() << "read" << Moose::bundleDirPath() + "/Contents/Info" << "LSUIElement" );
p.waitForFinished();
if (p.exitCode() == 0)
return p.readAllStandardOutput().trimmed() != "1";
else
// nonzero exit code means no LSUIElement, thus shown
return true;
}
#endif
void
SettingsDialog::populateAccount()
{
LastFmUserSettings* user = &The::settings().currentUser();
ui_account.colourCombo->setCurrentIndex( user->icon() < ui_account.colourCombo->count() ? user->icon() : 0 );
#ifdef Q_WS_MAC
ui_account.showInTrayCheck->setText( tr( "Show application icon in menu bar" ) );
ui_account.showInDockCheck->setChecked( appHasDockIcon() );
#endif
ui_account.showInTrayCheck->setChecked( The::settings().showTrayIcon() );
#ifndef HIDE_RADIO
QString langCode = The::settings().customAppLanguage();
for( int i = 0; i < ui_account.languageCombo->count(); ++i )
{
QString code = ui_account.languageCombo->itemData( i ).toString();
if ( code == langCode )
{
ui_account.languageCombo->setCurrentIndex( i );
}
}
#endif // HIDE_RADIO
}
void
SettingsDialog::populateRadio()
{
ui_radio.resumeCheckBox->setChecked( The::settings().currentUser().resumePlayback() );
ui_radio.systemBox->clear();
ui_radio.cardBox->clear();
Radio& radio = The::radio();
ui_radio.systemBox->addItems( radio.soundSystems() );
ui_radio.cardBox->addItems( radio.devices() );
ui_radio.systemBox->setCurrentIndex( The::settings().soundSystem() >= 0 ? The::settings().soundSystem() : 0 );
ui_radio.cardBox->setCurrentIndex( The::settings().soundCard() >= 0 ? The::settings().soundCard() : 0 );
ui_radio.automaticBufferCheck->setChecked( The::settings().isBufferManagedAutomatically() );
ui_radio.bufferEdit->setText( QString::number( The::settings().httpBufferSize() / 1024 ) );
ui_radio.musicProxyPort->setValue( The::settings().musicProxyPort() );
}
void
SettingsDialog::populateScrobbling()
{
LastFmUserSettings& user = The::settings().currentUser();
ui_scrobbling.scrobblePointSlider->setValue( user.scrobblePoint() );
ui_scrobbling.scrobblePointLabel->setText( QString::number( user.scrobblePoint() ) );
ui_scrobbling.launchWithMediaPlayerCheck->setChecked( The::settings().launchWithMediaPlayer() );
ui_scrobbling.fingerprintCheckBox->setChecked( user.fingerprintingEnabled() );
ui_scrobbling.dirTree->setExclusions( user.excludedDirs() );
}
void
SettingsDialog::populateConnection()
{
ui_connection.proxyBox->setChecked( The::settings().isUseProxy() );
ui_connection.proxyHostEdit->setText( The::settings().getProxyHost() );
ui_connection.proxyPortEdit->setText( QString::number( The::settings().getProxyPort() ) );
ui_connection.proxyUsernameEdit->setText( The::settings().getProxyUser() );
ui_connection.proxyPasswordEdit->setText( The::settings().getProxyPassword() );
ui_connection.downloadMetadataCheck->setChecked( The::settings().currentUser().isMetaDataEnabled() );
#ifndef NBREAKPAD
ui_connection.crashReportCheck->setChecked( The::settings().currentUser().crashReportingEnabled() );
#endif
ui_connection.manualProxyButton->setChecked( The::settings().isUseProxy() );
}
void
SettingsDialog::populateMediaDevices()
{
ui_mediadevices.enableIPodScrobbling->setChecked( The::settings().isIPodScrobblingEnabled() );
ui_mediadevices.alwaysConfirmIPodScrobbles->setChecked( The::currentUser().isAlwaysConfirmIPodScrobbles() );
ui_mediadevices.giveMoreFeedback->setChecked( The::currentUser().giveMoreIPodScrobblingFeedback() );
QList items;
foreach( QString device, The::settings().allMediaDevices() )
{
QString username = The::settings().usernameForDeviceId( device );
items += new QTreeWidgetItem( QStringList() << device << username );
}
ui_mediadevices.deviceWidget->clear();
ui_mediadevices.deviceWidget->insertTopLevelItems( 0, items );
ui_mediadevices.clearUserAssociations->setEnabled( items.count() );
//NOTE manual scrobbling is disabled on Windows and Mac and this option
// is irrelevent on Linux since manual is the only supported option
ui_mediadevices.deviceWidget->hideColumn( 2 );
}
void
SettingsDialog::pageSwitched( int currentRow )
{
ui.pageList->setCurrentRow( currentRow );
ui.pageStack->setCurrentIndex( currentRow + 1 );
}
void
SettingsDialog::applyPressed()
{
// Do hardcoded sections
if ( m_pagesToSave.contains( 1 ) ) saveRadio();
if ( m_pagesToSave.contains( 2 ) ) saveScrobbling();
if ( m_pagesToSave.contains( 3 ) ) saveConnection();
if ( m_pagesToSave.contains( 4 ) ) saveMediaDevices();
// Do extensions
foreach ( int page, m_pagesToSave )
{
if( page < 5)
continue;
int idx = page - 5;
m_extensions[idx]->saveSettings();
m_pagesToSave.remove( page );
}
// Account has to be the last section we handle here:
// It relies on signals being received and in case
// the user pressed Ok, this will close and free the
// dialog asap.
if ( m_pagesToSave.contains( 0 ) )
saveAccount();
ui.buttonBox->button( QDialogButtonBox::Apply )->setEnabled( false );
}
void
SettingsDialog::saveAccount()
{
m_loginWidget->verify();
}
void
SettingsDialog::verifiedAccount( bool verified, bool /* bootstrap */ )
{
if ( verified )
// FIXME: why specify false? Better specify true and cause a rehandshake straight away.
m_loginWidget->save( false );
else
m_loginWidget->resetWidget( The::settings().currentUsername() );
LastFmUserSettings& user = The::settings().currentUser();
int iconIndex = ui_account.colourCombo->currentIndex() >= 0 ? ui_account.colourCombo->currentIndex() : 0;
user.setIcon( static_cast( iconIndex ) );
The::settings().setShowTrayIcon( ui_account.showInTrayCheck->isChecked() );
#ifdef Q_WS_MAC
if (appHasDockIcon() != ui_account.showInDockCheck->isChecked())
{
QProcess p;
p.start( "defaults", QStringList() << "write"
<< Moose::bundleDirPath() + "/Contents/Info"
<< "LSUIElement"
<< (ui_account.showInDockCheck->isChecked() ? "0" : "1") );
p.waitForFinished();
p.start( "touch", QStringList() << Moose::bundleDirPath() ); //no need to wait
LastMessageBox::say( tr("You need to restart the application for the dock icon appearance change to take effect.") );
}
#endif
#ifndef HIDE_RADIO
// Store language in config
int langIdx = ui_account.languageCombo->currentIndex();
QString langCode = ui_account.languageCombo->itemData( langIdx ).toString();
QString oldLang = The::settings().customAppLanguage();
if ( langCode != oldLang )
{
LastMessageBox dlg( QMessageBox::Information,
tr( "Restart needed" ),
tr( "You need to restart the application for the language "
"change to take effect." ),
QMessageBox::Ok, this );
dlg.exec();
}
The::settings().setAppLanguage( langCode );
#endif
if( !verified )
{
//verification failed so don't close the dialog after saving.
return;
}
else
{
if ( m_loginWidget->detailsChanged() )
m_reconnect = true;
}
pageSaved( 0 );
if ( m_closeAfterVerification )
accept();
}
void
SettingsDialog::saveRadio()
{
The::settings().currentUser().setResumePlayback( ui_radio.resumeCheckBox->isChecked() );
The::settings().setSoundCard( ui_radio.cardBox->currentIndex() >= 0 ? ui_radio.cardBox->currentIndex() : 0 );
The::settings().setSoundSystem( ui_radio.systemBox->currentIndex() >= 0 ? ui_radio.systemBox->currentIndex() : 0 );
The::settings().setBufferManagedAutomatically( ui_radio.automaticBufferCheck->isChecked() );
// Returns 0 if the conversion fails so is safe
int bufSize = ui_radio.bufferEdit->text().toInt() * 1024;
if ( bufSize <= 0 ) bufSize = MooseConstants::kHttpBufferMinSize;
The::settings().setHttpBufferSize( bufSize );
The::settings().setMusicProxyPort( ui_radio.musicProxyPort->value() );
m_reAudio = ui_radio.cardBox->currentIndex() != originalSoundCard ||
ui_radio.systemBox->currentIndex() != originalSoundSystem ||
m_reAudio;
pageSaved( 1 );
}
void
SettingsDialog::saveScrobbling()
{
LastFmUserSettings& user = The::settings().currentUser();
user.setScrobblePoint( ui_scrobbling.scrobblePointSlider->value() );
user.setExcludedDirs( ui_scrobbling.dirTree->getExclusions() );
The::settings().setLaunchWithMediaPlayer( ui_scrobbling.launchWithMediaPlayerCheck->isChecked() );
user.setFingerprintingEnabled( ui_scrobbling.fingerprintCheckBox->checkState() == Qt::Checked ? true : false );
pageSaved( 2 );
}
void
SettingsDialog::saveConnection()
{
The::settings().setProxyUser( ui_connection.proxyUsernameEdit->text() );
The::settings().setProxyPassword( ui_connection.proxyPasswordEdit->text() );
The::settings().setProxyHost( ui_connection.proxyHostEdit->text() );
The::settings().setProxyPort( ui_connection.proxyPortEdit->text().toInt() );
The::settings().setUseProxy( ui_connection.manualProxyButton->isChecked() );
The::settings().currentUser().setMetaDataEnabled( ui_connection.downloadMetadataCheck->isChecked() );
#ifndef NBREAKPAD
The::settings().currentUser().setCrashReportingEnabled( ui_connection.crashReportCheck->isChecked() );
#endif
m_reconnect = ui_connection.proxyHostEdit->text() != originalProxyHost ||
ui_connection.proxyUsernameEdit->text() != originalProxyUsername ||
ui_connection.proxyPasswordEdit->text() != originalProxyPassword ||
ui_connection.proxyPortEdit->text().toInt() != originalProxyPort ||
ui_connection.manualProxyButton->isChecked() != originalProxyUsage ||
m_reconnect;
pageSaved( 3 );
}
// EJ: Umm, surely this ought to be taken care of by the plugin itself,
// and not coded straight into the Container? Like how the Skype
// plugin does it.
void
SettingsDialog::saveMediaDevices()
{
bool changed = ui_mediadevices.enableIPodScrobbling->isChecked() != The::settings().isIPodScrobblingEnabled();
if (changed)
{
if (ui_mediadevices.enableIPodScrobbling->isChecked())
{
LastMessageBox::say( tr("You must restart iTunes before Last.fm can scrobble your iPod" ) );
}
else
{
#ifdef Q_OS_MAC
// we delete the plugin db when iTunes restarts as we can't delete
// it now, on Windows at least it's in use, but it's safe to leave
// it, ie, there can be no miss-scrobbles, and we ignore any
// twiddles here in the client from now on
#endif
}
}
The::settings().setIPodScrobblingEnabled( ui_mediadevices.enableIPodScrobbling->isChecked() );
The::currentUser().setAlwaysConfirmIPodScrobbles( ui_mediadevices.alwaysConfirmIPodScrobbles->isChecked() );
The::currentUser().setGiveMoreIPodScrobblingFeedback( ui_mediadevices.giveMoreFeedback->isChecked() );
for (int x = 0; x < ui_mediadevices.deviceWidget->topLevelItemCount(); ++x)
{
QTreeWidgetItem* item = ui_mediadevices.deviceWidget->topLevelItem( x );
QString const uid = item->text( 0 );
The::settings().setIsManualIpod( uid, item->checkState( 2 ) == Qt::Checked );
}
pageSaved( 4 );
}
void
SettingsDialog::onOkClicked()
{
m_closeAfterVerification = true;
if( m_pagesToSave.size() > 0 )
applyPressed();
if ( !m_pagesToSave.contains( 0 ) )
accept();
}
void
SettingsDialog::pageSaved(int page)
{
m_pagesToSave.remove( page );
if ( m_pagesToSave.size() == 0 )
{
if ( m_reconnect )
The::app().setUser( The::currentUsername() );
if ( m_reAudio )
{
LastMessageBox dlg( QMessageBox::Information,
tr( "Restart needed" ),
tr( "You need to restart the application for the audio device "
"change to take effect." ),
QMessageBox::Ok, this );
dlg.exec();
}
m_reconnect = m_reAudio = false;
}
}
void
SettingsDialog::configChanged()
{
if ( m_populating ) return;
if( !m_pagesToSave.contains( ui.pageList->currentRow() ) && ui.pageList->currentRow() >= 0 )
m_pagesToSave.insert( ui.pageList->currentRow() );
ui.buttonBox->button( QDialogButtonBox::Apply )->setEnabled( true );
}
void
SettingsDialog::addExtension( ExtensionInterface* ext )
{
m_extensions.append( ext );
ext->setOwner( this );
ui.pageStack->addWidget( ext->settingsPane() );
ui.pageList->addItem( ext->tabCaption() );
int idx = ui.pageList->count() - 1;
ui.pageList->item( idx )->setIcon( *ext->settingsIcon() );
// God knows why I have to give it the name again, but I do
ui.pageList->item( idx )->setText( ext->tabCaption() );
connect( ext, SIGNAL( settingsChanged() ),
this, SLOT( configChanged() ) );
}
void
SettingsDialog::clearCache()
{
// Doesn't really belong here but...
int sure = LastMessageBox::question(
tr( "Confirm" ),
tr( "Are you sure you want to delete all\ncached images and bios?" ),
QMessageBox::Yes,
QMessageBox::No,
QStringList(), this );
if ( sure == QMessageBox::Yes )
{
QApplication::setOverrideCursor( QCursor( Qt::WaitCursor ) );
QDir dir( MooseUtils::cachePath() );
QStringList files = dir.entryList( QDir::Files );
bool success = true;
int count = 0;
foreach( QString filename, files )
{
bool deleted = dir.remove( filename );
if ( deleted ) { count++; }
success &= deleted;
if ( count % 25 == 0 )
{
QApplication::processEvents();
}
}
QApplication::restoreOverrideCursor();
QString result;
if ( success )
{
result = tr( "Cache emptied. %n files deleted.", "", count );
}
else
{
result = tr( "Not all items could be deleted. You might need "
"to delete some items manually from\n'%1'." )
.arg( dir.absolutePath() );
}
LastMessageBox::information(
tr( "Finished" ),
result,
QMessageBox::Ok,
QMessageBox::NoButton,
QStringList(), this );
LOGL( 3, "Emptied cache, files: " << count << ", success: " << success );
}
}
void
SettingsDialog::clearUserIPodAssociations()
{
// useful no?
#define LOG_IF_FAIL( b, x ) bool b = x; if (!b) LOGL( 3, "Failed" #x )
MediaDeviceSettings().remove( "" );
ui_mediadevices.deviceWidget->clear();
ui_mediadevices.clearUserAssociations->setEnabled( false );
// On Windows QFile::remove() may always fail due to file locking.
// XP users can uninstall to delete the cache, but Vista users are screwed.
// Indeed, it is safe to delete it when iTunes is running, Twiddly handles
// it robustly and even shows an error message.
LOG_IF_FAIL( b, QFile::remove( Moose::savePath( "iTunesPlays.db" ) ) );
if (b) LastMessageBox::information(
tr("Additional Action Required"),
tr("You must restart iTunes before you next try to scrobble your iPod.") );
}
lastfm-1.5.4.27091+dfsg1/src/simplewizard.h 0000644 0000000 0000000 00000005052 10725516002 016640 0 ustar root root /***************************************************************************
* Copyright (C) 2005 - 2007 by *
* Christian Muehlhaeuser, Last.fm Ltd *
* Erik Jaelevik, Last.fm Ltd *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 2 of the License, or *
* (at your option) any later version. *
* *
* This program is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with this program; if not, write to the *
* Free Software Foundation, Inc., *
* 51 Franklin Steet, Fifth Floor, Boston, MA 02110-1301, USA. *
***************************************************************************/
#ifndef SIMPLEWIZARD_H
#define SIMPLEWIZARD_H
#include
#include
class QHBoxLayout;
class QPushButton;
class QVBoxLayout;
#ifdef WIN32
#include "ui_wizarddialog_win.h"
#elif defined Q_OS_MAC
#undef Q_OS_MAC
#include "ui_wizarddialog_mac.h"
#define Q_OS_MAC
#else
#include "ui_wizarddialog_mac.h"
#endif
class SimpleWizard : public QDialog
{
Q_OBJECT
public:
SimpleWizard(QWidget* parent = 0);
void enableNext(bool enable);
void enableBack(bool enable);
void setTitle(const QString& title) { mTitle = title; }
int currentPage() { return mHistory.size() - 1; }
int numPages() { return mNumPages; }
protected:
virtual QWidget* createPage(int index) = 0;
void setNumPages(int n);
virtual void switchPage(QWidget* oldPage, QWidget* newPage);
void updateButtons();
Ui::WizardDialog ui;
protected slots:
virtual void backButtonClicked();
virtual void nextButtonClicked();
private:
QList mHistory;
int mNumPages;
QString mTitle;
};
#endif
lastfm-1.5.4.27091+dfsg1/src/deleteuserdialog.h 0000644 0000000 0000000 00000003572 10725516002 017454 0 ustar root root /***************************************************************************
* Copyright (C) 2005 - 2007 by *
* Christian Muehlhaeuser, Last.fm Ltd *
* Erik Jaelevik, Last.fm Ltd *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 2 of the License, or *
* (at your option) any later version. *
* *
* This program is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with this program; if not, write to the *
* Free Software Foundation, Inc., *
* 51 Franklin Steet, Fifth Floor, Boston, MA 02110-1301, USA. *
***************************************************************************/
#ifndef DELETEUSERDIALOG_H
#define DELETEUSERDIALOG_H
#include
#include
#include "ui_deleteuserdialog.h"
class DeleteUserDialog : public QDialog
{
Q_OBJECT
public:
DeleteUserDialog( QWidget *parent = 0 );
protected:
virtual void accept();
private:
Ui::DeleteUserDialog ui;
};
#endif // DELETEUSERDIALOG_H
lastfm-1.5.4.27091+dfsg1/src/interfaces/ 0000755 0000000 0000000 00000000000 11750117524 016103 5 ustar root root lastfm-1.5.4.27091+dfsg1/src/interfaces/InputInterface.h 0000644 0000000 0000000 00000007200 10725516002 021166 0 ustar root root /***************************************************************************
* Copyright (C) 2005 - 2007 by *
* Christian Muehlhaeuser, Last.fm Ltd *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 2 of the License, or *
* (at your option) any later version. *
* *
* This program is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with this program; if not, write to the *
* Free Software Foundation, Inc., *
* 51 Franklin Steet, Fifth Floor, Boston, MA 02110-1301, USA. *
***************************************************************************/
/*! \class InputInterface
\brief Interface to Input plugins.
Interface to Input plugins which take care of retrieving and streaming
from local as well as remote data-sources.
*/
#ifndef INPUT_INTERFACE_H
#define INPUT_INTERFACE_H
#include
#include "TrackInfo.h"
#include "RadioEnums.h"
class InputInterface : public QObject
{
public:
virtual ~InputInterface() {}
/** \brief Returns true if new data is available. */
virtual bool hasData() = 0;
/** \brief Returns the data buffer and empties it afterwards. */
virtual void data( QByteArray& fillMe, int numBytes ) = 0;
/** \brief Returns the buffer capacity. */
virtual int bufferCapacity() = 0;
/** \brief Returns the actual buffer size. */
virtual int bufferSize() = 0;
/** \brief Changes the buffer-size.
* \param size The new buffer-size. */
virtual void setBufferCapacity( int size ) = 0;
/** \brief Returns the current state. */
virtual RadioState state() = 0;
public slots:
/** \brief Starts the streaming. */
virtual void startStreaming() = 0;
/** \brief Stops streaming. */
virtual void stopStreaming() = 0;
/** \brief Changes the current stream url. */
virtual void load( const QString& url ) = 0;
virtual void setSession( const QString& session ) = 0;
signals:
/** \brief Emits a state from the RadioState enum. */
virtual void stateChanged( RadioState newState ) = 0;
/** \brief Gets emitted whenever an error occurs during streaming or retrieving a url. */
virtual void error( int errorCode, const QString& reason ) = 0;
/*********************************************************************/ /**
Emitted if the stream has to rebuffer. Buffering finishes when
size == total.
@param size - current buffer size
@param total - total buffer size
**************************************************************************/
virtual void buffering( int size, int total ) = 0;
};
Q_DECLARE_INTERFACE( InputInterface, "fm.last.Input/1.0" )
#endif
lastfm-1.5.4.27091+dfsg1/src/interfaces/TranscodeInterface.h 0000644 0000000 0000000 00000010574 10725516002 022021 0 ustar root root /***************************************************************************
* Copyright (C) 2005 - 2007 by *
* Christian Muehlhaeuser, Last.fm Ltd *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 2 of the License, or *
* (at your option) any later version. *
* *
* This program is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with this program; if not, write to the *
* Free Software Foundation, Inc., *
* 51 Franklin Steet, Fifth Floor, Boston, MA 02110-1301, USA. *
***************************************************************************/
#ifndef TRANSCODE_INTERFACE_H
#define TRANSCODE_INTERFACE_H
#include "MooseCommon.h"
#include
#include
#include
#include
#include
class TranscodeInterface : public QObject
{
public:
virtual ~TranscodeInterface() {}
virtual QStringList supportedMimeTypes() const = 0;
virtual QStringList supportedFileExtensions() const = 0;
virtual bool needsData() = 0;
virtual bool hasData() = 0;
virtual void setBufferCapacity( int bytes ) = 0;
virtual int bufferSize() = 0;
virtual void data( QByteArray& fillMe, int numBytes ) = 0;
/**
* Using the QPluginLoader::instance will always return the same
* instance of the plugin. If you want a separate instance, use
* this function and it will create and return a new instance.
*/
virtual TranscodeInterface* newInstance() = 0;
/**
* When you've used newInstance, you should always call deleteInstance
* for it when you're done with it.
*/
virtual void deleteInstance( TranscodeInterface* i ) = 0;
static TranscodeInterface* getDecoder( QString fileExt )
{
QDir dir( MooseUtils::servicePath( "" ) );
QStringList files = dir.entryList( QDir::Files | QDir::NoDotAndDotDot | QDir::NoSymLinks );
for ( int i = 0; i < files.count(); ++i )
{
QString file = files.at( i );
QString fullPath = dir.absoluteFilePath( file );
if ( file.contains( "transcode" ) && QLibrary::isLibrary( fullPath ) )
{
QObject* plugin = QPluginLoader( fullPath ).instance();
if ( plugin == 0 )
continue;
// HACK to get round compiler template error when using qobject_cast
TranscodeInterface* transcoder =
reinterpret_cast( plugin->qt_metacast("fm.last.Transcode/1.0") );
if ( transcoder == 0 )
continue;
if ( transcoder->supportedFileExtensions().contains( fileExt, Qt::CaseInsensitive ) )
return transcoder;
}
}
return 0;
};
public slots:
virtual void clearBuffers() = 0;
/**
* Slight hack. The noDecode causes it to just read ahead without decoding
* any data. It's an optimisation used by the fingerprinter for skipping
* ahead into files. Calling data afterwards will just return the correct
* number of 0-filled bytes.
*/
virtual bool processData( const QByteArray& data, bool noDecode = false ) = 0;
signals:
virtual void streamInitialized( long sampleRate, int channels ) = 0;
};
Q_DECLARE_INTERFACE( TranscodeInterface, "fm.last.Transcode/1.0" )
#endif
lastfm-1.5.4.27091+dfsg1/src/interfaces/MediaDeviceInterface.h 0000644 0000000 0000000 00000004600 10725516002 022227 0 ustar root root /***************************************************************************
* Copyright (C) 2005 - 2007 by *
* Christian Muehlhaeuser, Last.fm Ltd *
* Erik Jaelevik, Last.fm Ltd *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 2 of the License, or *
* (at your option) any later version. *
* *
* This program is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with this program; if not, write to the *
* Free Software Foundation, Inc., *
* 51 Franklin Steet, Fifth Floor, Boston, MA 02110-1301, USA. *
***************************************************************************/
#ifndef MEDIADEVICE_INTERFACE_H
#define MEDIADEVICE_INTERFACE_H
#include "TrackInfo.h"
#include
class MediaDeviceInterface : public QObject
{
public:
virtual ~MediaDeviceInterface() {}
virtual QString LibraryPath() = 0;
virtual TrackInfo firstTrack( const QString& file ) = 0;
virtual TrackInfo nextTrack() = 0;
virtual void forceDetection( const QString& path ) = 0;
virtual void setupWatchers() = 0;
signals:
void deviceAdded( const QString& uid );
void deviceChangeStart( const QString& uid, QDateTime lastItunesUpdateTime );
void deviceChangeEnd( const QString& uid );
void progress( int percentage, const TrackInfo& track );
void trackChanged( const TrackInfo& track, int playCounter );
};
Q_DECLARE_INTERFACE( MediaDeviceInterface, "fm.last.MediaDevice/1.0" )
#endif
lastfm-1.5.4.27091+dfsg1/src/interfaces/ExtensionInterface.h 0000644 0000000 0000000 00000005701 10725516002 022047 0 ustar root root /***************************************************************************
* Copyright (C) 2005 - 2007 by *
* Christian Muehlhaeuser, Last.fm Ltd *
* Erik Jaelevik, Last.fm Ltd *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 2 of the License, or *
* (at your option) any later version. *
* *
* This program is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with this program; if not, write to the *
* Free Software Foundation, Inc., *
* 51 Franklin Steet, Fifth Floor, Boston, MA 02110-1301, USA. *
***************************************************************************/
#ifndef EXTENSION_INTERFACE_H
#define EXTENSION_INTERFACE_H
#include
/// where's the documentation? --mxcl
class ExtensionInterface : public QObject
{
public:
virtual ~ExtensionInterface() {}
virtual QString name() const = 0;
virtual QString version() const = 0;
virtual bool hasGui() { return false; }
virtual QWidget* gui() { return NULL; }
virtual bool guiEnabled() { return false; }
virtual QString tabCaption() const { return ""; }
virtual bool hasSettingsPane() { return false; } //cool
virtual QWidget* settingsPane() { return NULL; } //that
virtual bool settingsEnabled() { return false; } //these
virtual QPixmap* settingsIcon() { return NULL; } //line
virtual QString settingsCaption() { return ""; } //up :)
// The host for the extension MUST call this function during initialisation
// to provide the extension with a valid QSettings object initialised to the
// correct location.
virtual void setSettings( class QSettings* ) {}
/** does this mean the settings object or the settings gui pane? */
virtual void populateSettings() {}
virtual void saveSettings() {}
virtual QWidget* owner() = 0;
virtual void setOwner( QWidget* parent ) = 0;
virtual void terminate() {}
};
Q_DECLARE_INTERFACE( ExtensionInterface, "fm.last.Extension.General/1.0" )
#endif
lastfm-1.5.4.27091+dfsg1/src/interfaces/OutputInterface.h 0000644 0000000 0000000 00000007640 10725516002 021377 0 ustar root root /***************************************************************************
* Copyright (C) 2005 - 2007 by *
* Christian Muehlhaeuser, Last.fm Ltd *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 2 of the License, or *
* (at your option) any later version. *
* *
* This program is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with this program; if not, write to the *
* Free Software Foundation, Inc., *
* 51 Franklin Steet, Fifth Floor, Boston, MA 02110-1301, USA. *
***************************************************************************/
/*! \class OutputInterface
\brief Interface to Sound Output plugins.
Interface to Output plugins which usually access the sound-card
for audio output - or possibly even stream or write data elsewhere.
*/
#ifndef OUTPUT_INTERFACE_H
#define OUTPUT_INTERFACE_H
#include
class OutputInterface : public QObject
{
public:
virtual ~OutputInterface() {}
/** \brief Initialises the audio device.
* \param sampelRate The sample-rate that will be used for audio data.
* \param channels How many channels will be used. */
virtual void initAudio( long sampleRate, int channels ) = 0;
/** \brief Returns the current volume. (range: 0 to 1.0) */
virtual float volume() = 0;
/** \brief Pauses playback. */
virtual void pause() = 0;
/** \brief Resumes playback. */
virtual void resume() = 0;
/** \brief Returns true if there's any data in the output buffer. */
virtual bool hasData() = 0;
/** \brief Returns true if the buffer needs to be refilled. */
virtual bool needsData() = 0;
/** \brief Appends audio data for playback.
* \param data The audio data in PCM. */
virtual void processData( const QByteArray& data ) = 0;
/** \brief Returns a list of supported Sound Systems. */
virtual QStringList soundSystems() = 0;
/** \brief Returns a list of available devices. */
virtual QStringList devices() = 0;
/** \brief Tell the output which sound device to use.
* \param n is the ordinal from the list returned by devices. */
virtual void setDevice( int n ) = 0;
/** \brief Sets the buffer capacity. */
virtual void setBufferCapacity( int size ) = 0;
/** \brief Returns the actual buffer size. */
virtual int bufferSize() = 0;
/** \brief Returns if the output plugin is currently active. */
virtual bool isActive() = 0;
public slots:
/** \brief Clears the internal audio buffers. */
virtual void clearBuffers() = 0;
/** \brief Starts playback. */
virtual void startPlayback() = 0;
/** \brief Stops playback. */
virtual void stopPlayback() = 0;
/** \brief Changes the current volume. */
virtual void setVolume( int volume ) = 0;
signals:
virtual void error( int error, const QString& reason ) = 0;
};
Q_DECLARE_INTERFACE( OutputInterface, "fm.last.Output/1.0" )
#endif
lastfm-1.5.4.27091+dfsg1/src/wizardprogresspage.h 0000644 0000000 0000000 00000004271 10725516002 020052 0 ustar root root /***************************************************************************
* Copyright (C) 2005 - 2007 by *
* Christian Muehlhaeuser, Last.fm Ltd *
* Erik Jaelevik, Last.fm Ltd *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 2 of the License, or *
* (at your option) any later version. *
* *
* This program is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with this program; if not, write to the *
* Free Software Foundation, Inc., *
* 51 Franklin Steet, Fifth Floor, Boston, MA 02110-1301, USA. *
***************************************************************************/
#ifndef WIZARDPROGRESSPAGE_H
#define WIZARDPROGRESSPAGE_H
#include "wizardinfopage.h"
#include "ui_progresswidget.h"
class SimpleWizard;
class WizardProgressPage : public QWidget
{
Q_OBJECT
public:
WizardProgressPage(
SimpleWizard* wizard,
const QString& info,
const QString& detailedInfo);
public slots:
void
setProgress(
int percentage,
int total);
void
setInfo(
QString info);
signals:
void
infoChanged(
QString info);
void
detailedInfoChanged(
QString info);
private:
Ui::ProgressWidget uiProgress;
friend class SimpleWizard;
};
#endif // WIZARDPROGRESSPAGE_H
lastfm-1.5.4.27091+dfsg1/src/checkdirtree.h 0000644 0000000 0000000 00000006644 10725516002 016572 0 ustar root root /***************************************************************************
* Copyright (C) 2005 - 2007 by *
* Christian Muehlhaeuser, Last.fm Ltd *
* Erik Jaelevik, Last.fm Ltd *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 2 of the License, or *
* (at your option) any later version. *
* *
* This program is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with this program; if not, write to the *
* Free Software Foundation, Inc., *
* 51 Franklin Steet, Fifth Floor, Boston, MA 02110-1301, USA. *
***************************************************************************/
#ifndef CHECKDIRTREE_H
#define CHECKDIRTREE_H
#include
#include
class CheckDirModel : public QDirModel
{
Q_OBJECT
public:
CheckDirModel(
QWidget* parent = NULL) : QDirModel(parent) { }
virtual Qt::ItemFlags
flags(
const QModelIndex& index) const;
virtual QVariant
data(
const QModelIndex & index,
int role = Qt::DisplayRole ) const;
virtual bool
setData(
const QModelIndex & index,
const QVariant & value,
int role = Qt::EditRole);
void
setCheck(
const QModelIndex& index,
const QVariant& value);
Qt::CheckState
getCheck(
const QModelIndex& index);
signals:
void
dataChangedByUser(
const QModelIndex & index);
private:
QHash m_checkTable;
};
class CheckDirTree : public QTreeView
{
Q_OBJECT
public:
CheckDirTree(
QWidget* parent);
void
checkPath( QString path,
Qt::CheckState state );
void
setExclusions(
QStringList list);
QStringList
getExclusions();
signals:
void
dataChanged();
private:
CheckDirModel m_dirModel;
QSet m_expandedSet;
void
fillDown(
const QModelIndex& index);
void
updateParent(
const QModelIndex& index);
void
getExclusionsForNode(
const QModelIndex& index,
QStringList& exclusions);
private slots:
void
onCollapse(
const QModelIndex& idx);
void
onExpand(
const QModelIndex& idx);
void
updateNode(
const QModelIndex& idx);
};
#endif // CHECKDIRTREE_H
lastfm-1.5.4.27091+dfsg1/src/simplewizard_mac.cpp 0000644 0000000 0000000 00000004173 10725516002 020016 0 ustar root root /***************************************************************************
* Copyright (C) 2005 - 2007 by *
* Christian Muehlhaeuser, Last.fm Ltd *
* Erik Jaelevik, Last.fm Ltd *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 2 of the License, or *
* (at your option) any later version. *
* *
* This program is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with this program; if not, write to the *
* Free Software Foundation, Inc., *
* 51 Franklin Steet, Fifth Floor, Boston, MA 02110-1301, USA. *
***************************************************************************/
#include "simplewizard_mac.h"
#include "MooseCommon.h"
SimpleWizardMac::SimpleWizardMac( QWidget *parent )
: SimpleWizard( parent )
{
uiInt.setupUi(&m_IntShell);
ui.vboxLayout->insertWidget(0, &m_IntShell);
}
void
SimpleWizardMac::switchPage( QWidget* oldPage, QWidget* newPage )
{
// ui is the base class shell
if (oldPage) {
oldPage->hide();
uiInt.pageFrame->layout()->removeWidget(oldPage);
}
uiInt.pageFrame->layout()->addWidget(newPage);
uiInt.headerLabel->setText(headerForPage(currentPage()));
newPage->show();
newPage->setFocus();
updateButtons();
}
lastfm-1.5.4.27091+dfsg1/src/SideBarRevealPopup.cpp 0000644 0000000 0000000 00000006447 10725516002 020166 0 ustar root root /***************************************************************************
* Copyright (C) 2005 - 2007 by *
* Christian Muehlhaeuser, Last.fm Ltd *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 2 of the License, or *
* (at your option) any later version. *
* *
* This program is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with this program; if not, write to the *
* Free Software Foundation, Inc., *
* 51 Franklin Steet, Fifth Floor, Boston, MA 02110-1301, USA. *
***************************************************************************/
#include
#include
#include "SideBarRevealPopup.h"
RevealPopup::RevealPopup( QWidget* parent ) :
ToolTipLabel( parent )
{
setMouseTracking( true );
}
bool
RevealPopup::event( QEvent *e )
{
switch (e->type())
{
case QEvent::MouseMove:
case QEvent::MouseButtonPress:
case QEvent::MouseButtonRelease:
case QEvent::MouseButtonDblClick:
{
// propogate mouse events up to the treeview as we are
// a "transparent" widget, ie clicks should just pass thru
#define e static_cast(e)
QMouseEvent mouse_event( e->type(),
parentWidget()->mapFromGlobal( e->globalPos() ),
e->globalPos(),
e->button(),
e->buttons(),
e->modifiers() );
#undef e
qApp->notify( parentWidget(), &mouse_event );
return true;
}
case QEvent::Wheel:
{
// as above
#define e static_cast(e)
QWheelEvent wheel_event( e->pos(),
parentWidget()->mapFromGlobal( e->globalPos() ),
e->delta(),
e->buttons(),
e->modifiers(),
e->orientation() );
#undef e
qApp->notify( parentWidget(), &wheel_event );
return true;
}
case QEvent::Paint:
break;
case QEvent::Hide:
deleteLater();
break;
default:
//qApp->notify( parentWidget(), e );
break;
}
return ToolTipLabel::event( e );
}
lastfm-1.5.4.27091+dfsg1/src/libMoose/ 0000755 0000000 0000000 00000000000 11750117524 015531 5 ustar root root lastfm-1.5.4.27091+dfsg1/src/libMoose/libMoose.vcproj 0000644 0000000 0000000 00000004562 10725516002 020531 0 ustar root root
lastfm-1.5.4.27091+dfsg1/src/libMoose/MooseCommon.h 0000644 0000000 0000000 00000015415 11031266061 020134 0 ustar root root /***************************************************************************
* Copyright (C) 2005 - 2008 by *
* Last.fm Ltd *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 2 of the License, or *
* (at your option) any later version. *
* *
* This program is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with this program; if not, write to the *
* Free Software Foundation, Inc., *
* 51 Franklin Steet, Fifth Floor, Boston, MA 02110-1301, USA. *
***************************************************************************/
#ifndef MOOSECOMMON_H
#define MOOSECOMMON_H
/** @author */
#include "MooseDllExportMacro.h"
#include "TrackInfo.h"
#include
#include
#ifdef QT_GUI_LIB
#include
#endif
#ifdef WIN32
#define EXTENSION_PREFIX "ext_"
#define SERVICE_PREFIX "srv_"
#define DEBUG_SUFFIX "d"
#define LIB_EXTENSION ".dll"
#elif defined Q_WS_X11
#define EXTENSION_PREFIX "libext_"
#define SERVICE_PREFIX "libsrv_"
#define DEBUG_SUFFIX "_debug"
#define LIB_EXTENSION ".so"
#elif defined Q_WS_MAC
#define EXTENSION_PREFIX "libext_"
#define SERVICE_PREFIX "libsrv_"
#define DEBUG_SUFFIX "_debug"
#define LIB_EXTENSION ".dylib"
#endif
class LastFmSettings;
class WebService;
namespace The
{
LastFmSettings& settings();
WebService* webService();
}
namespace MooseEnums
{
enum ScrobblableStatus
{
OkToScrobble,
NoTimeStamp,
TooShort,
ArtistNameMissing,
TrackNameMissing,
ExcludedDir,
ArtistInvalid,
FromTheFuture,
FromTheDistantPast
};
enum UserIconColour
{
eNone = -1,
eRed = 0,
eBlue,
eGreen,
eOrange,
eBlack,
eColorMax
};
enum StartNewInstanceBehaviour
{
StartNewInstance,
DontStartNewInstance
};
}
namespace MooseUtils
{
/**
* Returns path to named file in the app's bin/data directory.
*/
MOOSE_DLLEXPORT QString
dataPath( QString file = "" );
/**
* Returns path to named file in the app's user-writable save directory.
* E.g. C:\Documents and Settings\user\Local Settings\Application Data\Last.fm\Client on Windows.
* ~/Library/Application Support/Last.fm/ on OS X.
* ~/.local/share/Last.fm/ on Unix.
*/
MOOSE_DLLEXPORT QString
savePath( QString file = "" );
/**
* Returns path to named file in the preferred (OS-dependant) logging directory.
* E.g. C:\Documents and Settings\user\Local Settings\Application Data\Last.fm\Client on Windows.
* ~/Library/Logs/ on OS X.
* ~/.local/share/Last.fm/ on Unix.
*/
MOOSE_DLLEXPORT QString
logPath( QString file );
/**
* Returns path to directory for storing cached images etc.
*/
MOOSE_DLLEXPORT QString
cachePath();
/**
* Returns path to named service plugin.
*/
MOOSE_DLLEXPORT QString
servicePath( QString name );
/**
* Helper function to load up a named service plugin.
*/
MOOSE_DLLEXPORT QObject*
loadService( QString name );
// Not exported because implementation is in header.
// Seeing as it's a template living in a DLL, it has to be that way.
template T*
loadService( const QString& name )
{
return static_cast(loadService( name ));
}
/**
* Helper function to load a named icon from disk.
*/
#ifdef QT_GUI_LIB
MOOSE_DLLEXPORT QIcon
icon( const char *name );
#endif
/**
* Checks whether the passed-in path is in a directory that the user has
* excluded from scrobbling.
*/
MOOSE_DLLEXPORT bool
isDirExcluded( const QString& path );
/**
* Works out if passed-in track can be scrobbled and returns the status.
*/
MOOSE_DLLEXPORT MooseEnums::ScrobblableStatus
scrobblableStatus( TrackInfo& track );
/**
* Returns the second at which passed-in track reached the scrobble point.
*/
MOOSE_DLLEXPORT int
scrobbleTime( TrackInfo& track );
/**
* @returns true if the client is already running
*/
MOOSE_DLLEXPORT bool
isAlreadyRunning();
/**
* Sends the command to the running client instance, or starts the client
* then sends it, NOTE we don't currently support spaces in @p command
*/
MOOSE_DLLEXPORT bool
sendToInstance( const QString& command,
MooseEnums::StartNewInstanceBehaviour = MooseEnums::DontStartNewInstance );
#ifdef WIN32
/**
* Stop the helper from autolaunching.
* This is still needed on Windows to remove the autolaunch entry that was added by
* versions prior to 1.5.
*/
MOOSE_DLLEXPORT void
disableHelperApp();
#endif
MOOSE_DLLEXPORT QStringList
extensionPaths();
#ifdef Q_OS_MAC
/** eg. /Applications/Last.fm.app/ */
QString bundleDirPath();
#endif
} //namespace MooseUtils
namespace MooseConstants
{
// SCROBBLING CONSTANTS
// The plugin ID used by HttpInput when submitting radio tracks to the player listener
const QString kRadioPluginId = "radio";
// Limits for user-configurable scrobble point (%)
const int kScrobblePointMin = 50;
const int kScrobblePointMax = 100;
// Shortest track length allowed to scrobble (s)
const int kScrobbleMinLength = 31;
// Upper limit for scrobble time (s)
const int kScrobbleTimeMax = 240;
// Min size of buffer holding streamed http data, i.e the size the http
// buffer needs to get to before we start streaming.
const int kHttpBufferMinSize = 16 * 1024;
// Max
const int kHttpBufferMaxSize = 256 * 1024;
};
namespace MooseDefaults
{
// Percentage of track length at which to scrobble
const int kScrobblePoint = 50;
};
namespace Moose
{
using namespace MooseUtils;
using namespace MooseEnums;
}
#endif // MOOSECOMMON_H
lastfm-1.5.4.27091+dfsg1/src/libMoose/libMoose.pro 0000644 0000000 0000000 00000001070 11474563364 020034 0 ustar root root TEMPLATE = lib
VERSION = 1.0.0
CONFIG += dll
TARGET = Moose
QT += xml network gui
include( ../../definitions.pro.inc )
FORMS += \
confirmdialog.ui
HEADERS += \
confirmdialog.h \
MooseCommon.h \
LastFmSettings.h
SOURCES += \
confirmdialog.cpp \
MooseCommon.cpp \
LastFmSettings.cpp
mac {
SOURCES += QtOverrides/SystemTrayIcon.cpp
}
win32 {
DEFINES += MOOSE_DLLEXPORT_PRO
LIBS += -lshell32
}
# This is added in definitions.pro.inc, get rid of it
LIBS -= -lMoose$$EXT
LIBS += -lLastFmTools$$EXT
lastfm-1.5.4.27091+dfsg1/src/libMoose/LastFmSettings.h 0000644 0000000 0000000 00000033771 11474563364 020636 0 ustar root root /***************************************************************************
* Copyright 2005-2007 Last.fm Ltd *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 2 of the License, or *
* (at your option) any later version. *
* *
* This program is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with this program; if not, write to the *
* Free Software Foundation, Inc., *
* 51 Franklin Steet, Fifth Floor, Boston, MA 02110-1301, USA. *
***************************************************************************/
#ifndef LASTFMSETTINGS_H
#define LASTFMSETTINGS_H
#include "Settings.h"
#include "MooseDllExportMacro.h"
#include "StationUrl.h"
#include "MooseCommon.h"
#include
#include
#include
#include
#include
#include
#include
#include
static const int kDefaultControlPort = 32213;
#if 1
# define CURRENT_USER_KEY "CurrentUser"
#else
# define CURRENT_USER_KEY "DebugBuildCurrentUser"
#endif
/**
* Note we operate on separate QSettings objects always to be thread-safe.
* Note the silly classes for each group are because you can't copy QSettings objects
* so we couldn't just return one through a function, which would be neater.
*/
#ifdef WIN32
class HklmSettings : public QSettings
{
public:
HklmSettings( QObject* parent = 0 ) :
QSettings( "HKEY_LOCAL_MACHINE\\Software\\Last.fm\\Client",
QSettings::NativeFormat,
parent )
{}
};
/** Due to historical reasons, we store windows settings "wrongly", but
* migrate settings on other platforms to the "correct" location. To make
* the code all the same though we use this class below and macro it to
* the QSettings token */
class HkcuSettings : public QSettings
{
public:
HkcuSettings( QObject* parent = 0 ) :
QSettings( "HKEY_CURRENT_USER\\Software\\Last.fm\\Client",
QSettings::NativeFormat,
parent )
{}
};
// set QSettings to HkcuSettings
// FIXME this causes unexpected bugs, but what's the work around?
#define QSettings HkcuSettings
#else
// set HklmSettings to QSettings
typedef QSettings HklmSettings;
#endif // WIN32
class PluginsSettings : public HklmSettings
{
public:
PluginsSettings()
{
beginGroup( "Plugins" );
}
};
class MediaDeviceSettings : public QSettings
{
public:
MediaDeviceSettings()
{
beginGroup( "MediaDevices" );
}
};
class MOOSE_DLLEXPORT LastFmUserSettings : public UserSettings
{
Q_OBJECT
public:
LastFmUserSettings( const QString& username )
: UserSettings( username )
{}
MooseEnums::UserIconColour icon() const;
void setIcon( MooseEnums::UserIconColour colour );
bool isLogToProfile() const;
void setLogToProfile( bool state );
void toggleLogToProfile() { setLogToProfile( !isLogToProfile() ); }
bool isDiscovery() const;
void setDiscovery( bool state );
bool sidebarEnabled() const;
void setSidebarEnabled( bool state );
int sidebarWidth() const { return QSettings().value( "sidebarWidth", 190 ).toInt(); }
void setSidebarWidth( const int width ) { QSettings().setValue( "sidebarWidth", width ); }
int lastTagType( int type = 0 ) const { return MyQSettings( this ).value( "lasttagtype", type ).toInt(); }
void setLastTagType( int type ) { MyQSettings( this ).setValue( "lasttagtype", type ); }
int lastRecommendType() const { return MyQSettings( this ).value( "lastrecommendtype", 1 ).toInt(); /*Track is default*/ }
void setLastRecommendType( int type ) { MyQSettings( this ).setValue( "lastrecommendtype", type ); }
bool resumePlayback() const { return MyQSettings( this ).value( "resumeplayback", 0 ).toInt() == 1; }
void setResumePlayback( bool enabled );
void setLovedRadioHidden( bool b ) { return MyQSettings( this ).setValue( "lovedRadioHidden", b); }
bool lovedRadioHidden() const { return MyQSettings( this ).value( "lovedRadioHidden", false ).toBool(); }
void setUserTagsRadioHidden( bool b ) { return MyQSettings( this ).setValue( "userTagsRadioHidden", b); }
bool userTagsRadioHidden() const { return MyQSettings( this ).value( "userTagsRadioHidden", false ).toBool(); }
StationUrl resumeStation() const
{
return StationUrl( MyQSettings( this ).value( "resumestation" ).toString() );
}
void setResumeStation( StationUrl station );
void addRecentStation( const class Station& );
void removeRecentStation( int list_index );
void clearRecentStations( bool emit_signal );
QList recentStations();
QStringList excludedDirs() const;
void setExcludedDirs( QStringList dirs );
QString bootStrapPluginId() const;
void setBootStrapPluginId( QString id );
QStringList includedDirs() const;
void setIncludedDirs( QStringList dirs );
bool isMetaDataEnabled();
void setMetaDataEnabled( bool enabled );
bool crashReportingEnabled();
void setCrashReportingEnabled( bool enabled );
int scrobblePoint();
void setScrobblePoint( int scrobblePoint );
bool fingerprintingEnabled();
void setFingerprintingEnabled( bool enabled );
QString lastRecommendee() const { return MyQSettings( this ).value( "LastRecommendee" ).toString(); }
void setLastRecommendee( QString v ) { MyQSettings( this ).setValue( "LastRecommendee", v ); }
int personalTagsListSortOrder() const { return MyQSettings( this ).value( "PersonalTagListSortOrder" ).toInt(); };
void setPersonalTagsListSortOrder( int sortOrder ) { MyQSettings( this ).setValue( "PersonalTagListSortOrder", sortOrder ); };
int publicTagsListSortOrder() const { return MyQSettings( this ).value( "PublicTagListSortOrder" ).toInt(); };
void setPublicTagsListSortOrder( int sortOrder ) { MyQSettings( this ).setValue( "PublicTagListSortOrder", sortOrder ); };
int sideBarTagsSortOrder() const { return MyQSettings( this ).value( "SideBarTagsSortOrder" ).toInt(); };
void setSideBarTagsSortOrder( int sortOrder ) { MyQSettings( this ).setValue( "SideBarTagsSortOrder", sortOrder ); };
int sideBarNeighbourSortOrder() const { return MyQSettings( this ).value( "SideBarNeighbourSortOrder" ).toInt(); };
void setSideBarNeighbourSortOrder( int sortOrder ) { MyQSettings( this ).setValue( "SideBarNeighbourSortOrder", sortOrder ); };
void setTrackFrameClockMode( bool trackTimeEnabled );
bool trackFrameClockMode();
void setAlwaysConfirmIPodScrobbles( bool );
bool isAlwaysConfirmIPodScrobbles() const;
bool giveMoreIPodScrobblingFeedback() const
{
return MyQSettings( this ).value( "GiveMoreIPodScrobblingFeedback", false ).toBool();
}
void setGiveMoreIPodScrobblingFeedback( bool b )
{
MyQSettings( this ).setValue( "GiveMoreIPodScrobblingFeedback", b );
}
void setFreeTrialRanOut()
{
MyQSettings( this ).setValue( "FreeTrialRanOut", true );
emit userChanged( username() );
}
bool freeTrialRanOut() const
{
return MyQSettings( this ).value( "FreeTrialRanOut", false ).toBool();
}
signals:
void userChanged( QString username );
void historyChanged();
private:
};
class MOOSE_DLLEXPORT LastFmSettings : public AppSettings
{
Q_OBJECT
LastFmSettings( QObject* parent );
friend LastFmSettings &The::settings();
public:
QStringList allUsers() const { return UsersSettings().childGroups(); }
void setCurrentUsername( QString username );
QString currentUsername() const { return UsersSettings().value( CURRENT_USER_KEY ).toString(); }
LastFmUserSettings& user( QString username ) const;
LastFmUserSettings& currentUser();
bool deleteUser( QString username );
bool isExistingUser( QString username ) const { return UsersSettings().contains( username + "/Password" ); }
QStringList allPlugins( bool withVersions = true );
// Returns "" if QSettings().value not found
QString pluginVersion( QString pluginId );
QString pluginPlayerPath( QString pluginId );
void setPluginPlayerPath( QString pluginId, QString path );
QStringList allMediaDevices();
QString usernameForDeviceId( const QString& uid ) const;
QStringList iPodIdsForUsername( const QString& username ) const;
void addMediaDevice( QString uid, QString username );
void removeMediaDevice( QString uid );
void setIPodScrobblingEnabled( bool );
bool isIPodScrobblingEnabled() const;
void setLastIPodScrobbleTime( QString uid, int time ) { MediaDeviceSettings().setValue( uid + "/lastIPodScrobbleTime", time ); }
int lastIPodScrobbleTime( QString uid ) const { return MediaDeviceSettings().value( uid + "/lastIPodScrobbleTime", 0 ).toInt(); }
void setIsManualIpod( QString uid, bool b ) { MediaDeviceSettings().setValue( uid + "/isManualIpod", b ); }
bool isManualIpod( QString uid ) const { return MediaDeviceSettings().value( uid + "/isManualIpod", false ).toBool(); }
void setLaunchWithMediaPlayer( bool en );
bool launchWithMediaPlayer();
int volume() const { return QSettings().value( "volume", 50 ).toInt(); }
void setVolume( int v ) { QSettings().setValue( "volume", v ); }
int soundCard() const { return QSettings().value( "soundcard", 0 ).toInt(); }
void setSoundCard( int v ) { QSettings().setValue( "soundcard", v ); }
int soundSystem() const { return QSettings().value( "soundsystem", 0 ).toInt(); }
void setSoundSystem( int v ) { QSettings().setValue( "soundsystem", v ); }
bool isBufferManagedAutomatically() const { return QSettings().value( "BufferManagedAutomatically", 1 ).toBool(); }
void setBufferManagedAutomatically( bool v ) { QSettings().setValue( "BufferManagedAutomatically", v ); }
int httpBufferSize() const { return QSettings().value( "HttpBufferSize", MooseConstants::kHttpBufferMinSize ).toInt(); }
void setHttpBufferSize( int v ) { QSettings().setValue( "HttpBufferSize", v ); }
int externalSoundSystem();
QString browser() const { return QSettings().value( "Browser" ).toString(); }
void setBrowser( QString browser ) { QSettings().setValue( "Browser", browser ); }
int musicProxyPort() const { return QSettings().value( "MusicProxyPort" ).toInt(); }
void setMusicProxyPort( int v ) { QSettings().setValue( "MusicProxyPort", v ); }
int controlPort() const { return QSettings().value( "ControlPort", kDefaultControlPort ).toInt(); }
void setControlPort( int v ) { QSettings().setValue( "ControlPort", v ); }
// This is a string for legacy reasons
bool isFirstRun() const;
void setFirstRunDone();
// This is a string for legacy reasons
bool isBootstrapDone() const { return QSettings().value( "BootStrapDone", "0" ).toBool(); }
void setBootstrapDone() { QSettings().setValue( "BootStrapDone", "1" ); }
bool isDontAsk( QString operation_name ) const;
void setDontAsk( QString operation_name, bool );
bool showTrayIcon() const { return QSettings().value( "ShowTrayIcon", "1" ).toBool(); }
void setShowTrayIcon( bool en );
QString fingerprintUploadUrl() const { return QSettings().value( "FingerprintUploadUrl" ).toString(); }
void setFingerprintUploadUrl( QString v ) { QSettings().setValue( "FingerprintUploadUrl", v ); }
MooseEnums::UserIconColour getFreeColour();
signals:
/// Some property belonging to the current user changed
void userSettingsChanged( LastFmUserSettings& user );
/// Some appearance property changed (e.g. tray-icon)
void appearanceSettingsChanged();
/// The current user changed to a different user
void userSwitched( LastFmUserSettings& newUser );
private slots:
void userChanged( QString username );
private:
// because we have to return by reference :(
LastFmUserSettings m_nullUser;
};
class UserQSettings : public UsersSettings
{
public:
UserQSettings( LastFmUserSettings* user, QObject* parent = 0 ) :
UsersSettings( parent )
{
beginGroup( user->username() );
}
};
namespace The
{
inline LastFmSettings &settings()
{
//TODO maybe better to have a static instantiate() function
// thus we lose the need for a mutex
static QMutex mutex;
static LastFmSettings* settings = 0;
QMutexLocker locker( &mutex );
if (!settings)
{
settings = QCoreApplication::instance()->findChild( "Settings-Instance" );
if (!settings)
{
settings = new LastFmSettings( QCoreApplication::instance() );
settings->setObjectName( "Settings-Instance" );
}
}
return *settings;
}
inline LastFmUserSettings ¤tUser()
{
return The::settings().currentUser();
}
inline QString currentUsername()
{
return The::settings().currentUsername();
}
}
class CurrentUserSettings : public UserQSettings
{
public:
CurrentUserSettings( QObject* parent = 0 )
: UserQSettings( &The::currentUser(), parent )
{}
};
#endif
lastfm-1.5.4.27091+dfsg1/src/libMoose/confirmdialog.ui 0000644 0000000 0000000 00000007363 11031266061 020707 0 ustar root root
ConfirmDialog
0
0
300
124
Confirm
true
true
0
0
-
16
6
-
Don't ask me again
false
-
0
0
32
16777215
Qt::AlignLeading|Qt::AlignLeft|Qt::AlignTop
-
Qt::AlignLeading|Qt::AlignLeft|Qt::AlignTop
true
-
Qt::Horizontal
QSizePolicy::Fixed
8
8
-
Qt::Vertical
QSizePolicy::Expanding
300
0
-
Qt::Horizontal
-
0
7
-
Qt::Horizontal
40
20
-
QDialogButtonBox::Cancel|QDialogButtonBox::Ok
lastfm-1.5.4.27091+dfsg1/src/libMoose/LastFmSettings.cpp 0000644 0000000 0000000 00000041607 11031266061 021145 0 ustar root root /***************************************************************************
* Copyright (C) 2005 - 2007 by *
* Last.fm Ltd *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 2 of the License, or *
* (at your option) any later version. *
* *
* This program is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with this program; if not, write to the *
* Free Software Foundation, Inc., *
* 51 Franklin Steet, Fifth Floor, Boston, MA 02110-1301, USA. *
***************************************************************************/
#include "LastFmSettings.h"
#include "UnicornCommon.h" // md5Digest
#include "MooseCommon.h"
#include "Settings.h"
#include "Station.h"
#include "logger.h"
#include
#include
#include
#include
#ifdef Q_WS_MAC
#include
#endif
/******************************************************************************
* LastFmUserSettings
******************************************************************************/
MooseEnums::UserIconColour
LastFmUserSettings::icon() const
{
MyQSettings s( this );
// This will return eRed if there is no entry. Don't want that.
if (s.contains( "Icon" ))
return (MooseEnums::UserIconColour) s.value( "Icon" ).toInt();
else
return MooseEnums::eNone;
}
void
LastFmUserSettings::setIcon( MooseEnums::UserIconColour colour )
{
MyQSettings( this ).setValue( "Icon", static_cast(colour) );
emit userChanged( username() );
}
/// Written as int for backwards compatibility with the MFC Audioscrobbler
bool
LastFmUserSettings::isLogToProfile() const
{
return static_cast(MyQSettings( this ).value( "LogToProfile", 1 ).toInt());
}
/// Written as int for backwards compatibility with the MFC Audioscrobbler
void
LastFmUserSettings::setLogToProfile( bool state )
{
MyQSettings( this ).setValue( "LogToProfile", static_cast(state) );
emit userChanged( username() );
}
bool
LastFmUserSettings::isDiscovery() const
{
return MyQSettings( this ).value( "DiscoveryEnabled", false ).toBool();
}
void
LastFmUserSettings::setDiscovery( bool state )
{
MyQSettings( this ).setValue( "DiscoveryEnabled", state );
emit userChanged( username() );
}
bool
LastFmUserSettings::sidebarEnabled() const
{
return MyQSettings( this ).value( "SidebarEnabled", false ).toBool();
}
void
LastFmUserSettings::setSidebarEnabled( bool state )
{
MyQSettings( this ).setValue( "SidebarEnabled", state );
emit userChanged( username() );
}
void
LastFmUserSettings::setResumePlayback( bool enabled )
{
MyQSettings( this ).setValue( "resumeplayback", enabled ? "1" : "0" );
emit userChanged( username() );
}
void
LastFmUserSettings::setResumeStation( StationUrl station )
{
MyQSettings( this ).setValue( "resumestation", station );
emit userChanged( username() );
}
void
LastFmUserSettings::addRecentStation( const Station& station )
{
MyQSettings s( this );
QList stations = recentStations();
// remove duplicates
for ( int i = 0; i < stations.count(); ++i )
if ( stations[i].url() == station.url() )
stations.removeAt( i-- );
stations.prepend( station );
s.remove( "RecentStations" );
s.beginGroup( "RecentStations" );
int j = stations.count();
while (j--)
s.setValue( QString::number( j ), stations[j].url() );
s.endGroup();
s.setValue( "StationNames/" + station.url(), station.name() );
s.sync();
emit userChanged( username() );
emit historyChanged();
}
void
LastFmUserSettings::removeRecentStation( int n )
{
MyQSettings s( this );
QString const N = QString::number( n );
s.beginGroup( "RecentStations" );
QString const url = s.value( N ).toString();
s.remove( N );
// now renumber in correct order (maps are auto-sorted by key)
QMap urls;
foreach (QString key, s.childKeys())
urls[key.toInt()] = s.value( key ).toString();
s.remove( "" ); //current group
int i = 0;
foreach (QString url, urls)
s.setValue( QString::number( i++ ), url );
s.endGroup();
s.remove( "StationNames/" + url );
s.sync();
emit userChanged( username() );
emit historyChanged();
}
void
LastFmUserSettings::clearRecentStations( bool emitting )
{
MyQSettings( this ).remove( "RecentStations" );
//TODO needed still?
if ( emitting )
emit historyChanged();
}
QList
LastFmUserSettings::recentStations()
{
MyQSettings s( this );
s.beginGroup( "RecentStations" );
QStringList const keys = s.childKeys();
s.endGroup();
QMap stations;
foreach (QString key, keys) {
Station station;
station.setUrl( s.value( "RecentStations/" + key ).toString() );
station.setName( s.value( "StationNames/" + station.url() ).toString() );
stations[key.toInt()] = station;
}
return stations.values();
}
void
LastFmUserSettings::setExcludedDirs( QStringList dirs )
{
#ifdef WIN32
QMutableStringListIterator i( dirs );
while (i.hasNext()) {
QString& s = i.next();
s = s.toLower();
}
#endif
MyQSettings( this ).setValue( "ExclusionDirs", dirs );
emit userChanged( username() );
}
QStringList
LastFmUserSettings::excludedDirs() const
{
QStringList paths = MyQSettings( this ).value( "ExclusionDirs" ).toStringList();
paths.removeAll( "" );
return paths;
}
void
LastFmUserSettings::setIncludedDirs( QStringList dirs )
{
MyQSettings( this ).setValue( "InclusionDirs", dirs );
emit userChanged( username() );
}
QString
LastFmUserSettings::bootStrapPluginId() const
{
return MyQSettings( this ).value( "BootStrapPluginId" ).toString();
}
void
LastFmUserSettings::setBootStrapPluginId( QString id )
{
MyQSettings( this ).setValue( "BootStrapPluginId", id );
emit userChanged( username() );
}
QStringList
LastFmUserSettings::includedDirs() const
{
return MyQSettings( this ).value( "InclusionDirs" ).toStringList();
}
void
LastFmUserSettings::setMetaDataEnabled( bool enabled )
{
MyQSettings( this ).setValue( "DownloadMetadata", enabled );
emit userChanged( username() );
}
bool
LastFmUserSettings::isMetaDataEnabled()
{
return MyQSettings( this ).value( "DownloadMetadata", true ).toBool();
}
void
LastFmUserSettings::setCrashReportingEnabled( bool enabled )
{
MyQSettings( this ).setValue( "ReportCrashes", enabled );
emit userChanged( username() );
}
bool
LastFmUserSettings::crashReportingEnabled()
{
return MyQSettings( this ).value( "ReportCrashes", true ).toBool();
}
void
LastFmUserSettings::setScrobblePoint( int scrobblePoint )
{
MyQSettings( this ).setValue( "ScrobblePoint", scrobblePoint );
emit userChanged( username() );
}
int
LastFmUserSettings::scrobblePoint()
{
return MyQSettings( this ).value( "ScrobblePoint", MooseDefaults::kScrobblePoint ).toInt();
}
void
LastFmUserSettings::setFingerprintingEnabled( bool enabled )
{
MyQSettings( this ).setValue( "Fingerprint", enabled );
emit userChanged( username() );
}
bool
LastFmUserSettings::fingerprintingEnabled()
{
return MyQSettings( this ).value( "Fingerprint", true ).toBool();
}
void
LastFmUserSettings::setTrackFrameClockMode( bool trackTimeEnabled )
{
MyQSettings( this ).setValue( "TrackFrameShowsTrackTime", trackTimeEnabled );
emit userChanged( username() );
}
bool
LastFmUserSettings::trackFrameClockMode()
{
return MyQSettings( this ).value( "TrackFrameShowsTrackTime", true ).toBool();
}
void
LastFmUserSettings::setAlwaysConfirmIPodScrobbles( bool b )
{
MyQSettings( this ).setValue( "alwaysConfirmIPodScrobbles", b );
}
bool
LastFmUserSettings::isAlwaysConfirmIPodScrobbles() const
{
//TODO false after 1.5 beta
return MyQSettings( this ).value( "alwaysConfirmIPodScrobbles", false ).toBool();
}
/******************************************************************************
* Settings
******************************************************************************/
LastFmSettings::LastFmSettings( QObject* parent ) :
AppSettings( parent ),
m_nullUser( "" )
{
#ifndef WIN32
QSettings new_config;
if (!QFile( new_config.fileName() ).exists())
{
//attempt to upgrade settings object from old and broken location
foreach (QString const name, QStringList() << "Client" << "Users" << "Plugins" << "MediaDevices")
{
QSettings old_config( QSettings::IniFormat, QSettings::UserScope, "Last.fm", name );
old_config.setFallbacksEnabled( false );
if (!QFile::exists( old_config.fileName() ))
continue;
foreach (QString const key, old_config.allKeys()) {
if (name != "Client")
//Client now becomes [General] group as this makes most sense
new_config.beginGroup( name );
new_config.setValue( key, old_config.value( key ) );
#ifndef QT_NO_DEBUG
if (name != "Client") // otherwise qWarning and aborts
#endif
new_config.endGroup();
}
new_config.sync();
QFile f( old_config.fileName() );
f.remove();
QFileInfo( f ).dir().rmdir( "." ); //safe as won't remove a non empty dir
}
}
#endif
s_instance = this;
}
LastFmUserSettings&
LastFmSettings::user( QString username ) const
{
Q_ASSERT( username != "" );
LastFmUserSettings *user = findChild( username );
if (!user) {
user = new LastFmUserSettings( username );
user->setParent( const_cast(this) );
user->setObjectName( username );
connect( user, SIGNAL(userChanged( QString )), SLOT(userChanged( QString )) );
}
return *user;
}
LastFmUserSettings&
LastFmSettings::currentUser()
{
return currentUsername() == ""
? m_nullUser
: user( currentUsername() );
}
void
LastFmSettings::setCurrentUsername( QString username )
{
UsersSettings().setValue( CURRENT_USER_KEY, username );
emit userSettingsChanged( currentUser() );
emit userSwitched( currentUser() );
}
bool
LastFmSettings::deleteUser( QString username )
{
if (isExistingUser( username ))
{
delete &user( username );
UsersSettings().remove( username );
return true;
}
else
return false;
}
// Don't rename registry key. Used by player plugins!
void
LastFmSettings::setLaunchWithMediaPlayer( bool en )
{
QSettings( this ).setValue( "LaunchWithMediaPlayer", en );
// emit userChanged( username() );
}
bool
LastFmSettings::launchWithMediaPlayer()
{
return QSettings( this ).value( "LaunchWithMediaPlayer", true ).toBool();
}
int
LastFmSettings::externalSoundSystem()
{
int externalSystem = -1;
#ifdef WIN32
externalSystem = 1;
#endif
#ifdef Q_WS_X11
externalSystem = 2;
#endif
#ifdef Q_WS_MAC
externalSystem = 1;
#endif
return externalSystem;
}
void
LastFmSettings::setDontAsk( const QString op, bool value )
{
QSettings().setValue( op + "DontAsk", value );
}
bool
LastFmSettings::isDontAsk( const QString op ) const
{
return QSettings().value( op + "DontAsk" ).toBool();
}
void
LastFmSettings::setShowTrayIcon( bool en )
{
QSettings().setValue( "ShowTrayIcon", en );
emit appearanceSettingsChanged();
}
bool
LastFmSettings::isFirstRun() const
{
// We fallback on HKLM here as versions of the client prior to 1.3.2
// stored the value there
QSettings s;
if ( s.contains( "FirstRun" ) )
return s.value( "FirstRun", "1" ).toBool();
else
return HklmSettings().value( "FirstRun", "1" ).toBool();
}
void
LastFmSettings::setFirstRunDone()
{
QSettings().setValue( "FirstRun", "0" );
}
QStringList
LastFmSettings::allPlugins( bool withVersions )
{
// These valued are written by the plugin installers and hence live in
// PluginsSettings, i.e. HKLM.
PluginsSettings s;
QStringList plugins;
foreach (QString group, s.childGroups()) {
s.beginGroup( group );
QString name = s.value( "Name" ).toString();
//If the plugin has been added but not installed name.size() == 0
if ( name.size() != 0 )
{
if ( withVersions )
{
QString version = s.value( "Version" ).toString();
plugins += name + ' ' + tr("plugin, version") + ' ' + version;
}
else
{
plugins += name;
}
}
s.endGroup();
}
return plugins;
}
QString
LastFmSettings::pluginVersion( QString id )
{
Q_ASSERT( !id.isEmpty() );
// These valued are written by the plugin installers and hence live in
// PluginsSettings, i.e. HKLM.
return PluginsSettings().value( id + "/Version" ).toString();
}
QString
LastFmSettings::pluginPlayerPath( QString id )
{
Q_ASSERT( !id.isEmpty() );
QString key = "Plugins/" + id + "/PlayerPath";
// We fallback on HKLM here as versions of the client prior to 1.3.2
// stored the value there
QSettings s;
if ( s.contains( key ) )
return s.value( key, "" ).toString();
else
return HklmSettings().value( key, "" ).toString();
}
void
LastFmSettings::setPluginPlayerPath( QString id,
QString path )
{
Q_ASSERT( !id.isEmpty() );
// Does not go in PluginsSettings since that's in HKLM (written by the installer),
// and a standard user does not have write access to that.
QSettings().setValue( "Plugins/" + id + "/PlayerPath", path );
}
void
LastFmSettings::setIPodScrobblingEnabled( bool en )
{
QSettings().setValue( "iPodScrobblingEnabled", en );
}
bool
LastFmSettings::isIPodScrobblingEnabled() const
{
return QSettings().value( "iPodScrobblingEnabled", true ).toBool();
}
QStringList
LastFmSettings::allMediaDevices()
{
MediaDeviceSettings s;
QStringList uids;
foreach (QString group, s.childGroups())
{
s.beginGroup( group );
foreach (QString childgroup, s.childGroups())
uids += group + '/' + childgroup;
s.endGroup();
}
return uids;
}
QString
LastFmSettings::usernameForDeviceId( const QString& uid ) const
{
MediaDeviceSettings s;
s.beginGroup( uid );
return s.value( "user" ).toString();
}
QStringList
LastFmSettings::iPodIdsForUsername( const QString& username ) const
{
MediaDeviceSettings s;
QStringList uids;
foreach (QString type, s.childGroups())
{
s.beginGroup( type );
foreach (QString uid, s.childGroups())
if (s.value( uid + "/user" ) == username)
uids += type + '/' + uid;
s.endGroup();
}
return uids;
}
void
LastFmSettings::addMediaDevice( QString uid, QString username )
{
MediaDeviceSettings s;
s.beginGroup( uid );
s.setValue( "user", username );
s.sync();
}
void
LastFmSettings::removeMediaDevice( QString uid )
{
MediaDeviceSettings s;
s.beginGroup( uid );
s.remove( "user" );
s.sync();
}
MooseEnums::UserIconColour
LastFmSettings::getFreeColour()
{
UsersSettings s;
QList unused;
// Fill it with all colours
for (int i = 0; i < 5; ++i)
{
unused.push_back(i);
}
// Remove the ones in use
foreach (QString username, s.childGroups())
{
MooseEnums::UserIconColour col = LastFmUserSettings( username ).icon();
if (col != MooseEnums::eNone)
unused.removeAll( int(col) );
if (unused.isEmpty()) {
LOG( 2, "We ran out of colours, returning random\n" );
return static_cast(rand() % 5);
}
}
return static_cast(unused.front());
}
void
LastFmSettings::userChanged( QString username )
{
if ( username == currentUsername() )
emit userSettingsChanged( currentUser() );
}
lastfm-1.5.4.27091+dfsg1/src/libMoose/QtOverrides/ 0000755 0000000 0000000 00000000000 11750117524 020000 5 ustar root root lastfm-1.5.4.27091+dfsg1/src/libMoose/QtOverrides/SystemTrayIcon.cpp 0000644 0000000 0000000 00000007333 11031266061 023440 0 ustar root root /***************************************************************************
* Copyright 2008 Last.fm Ltd. *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 2 of the License, or *
* (at your option) any later version. *
* *
* This program is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with this program; if not, write to the *
* Free Software Foundation, Inc., *
* 51 Franklin Steet, Fifth Floor, Boston, MA 02110-1301, USA. *
***************************************************************************/
#include "./QSystemTrayIcon"
#undef QSystemTrayIcon
#include "UnicornCommonMac.h"
#include "libUnicorn/AppleScript.h"
#include "libUnicorn/logger.h"
#include "MooseCommon.h"
#include
#include
#include
#include
#include
class GrowlClone : public QWidget
{
public:
GrowlClone( const QString& title, const QString& description );
protected:
virtual void mousePressEvent( QMouseEvent* )
{
deleteLater();
}
};
void
Moose::QSystemTrayIcon::showMessage( const QString& title,
const QString& description,
MessageIcon icon,
int ms )
{
if (!UnicornUtils::isGrowlInstalled())
{
static QPointer w;
delete w;
w = new GrowlClone( title, description );
}
else
::QSystemTrayIcon::showMessage( title, description, icon, ms );
}
GrowlClone::GrowlClone( const QString& title, const QString& description )
{
QLabel* ltitle = new QLabel( title );
QLabel* ldescription = new QLabel( description );
QLabel* logo = new QLabel;
logo->setPixmap( Moose::dataPath( "app_55.png" ) );
logo->setFixedSize( 55, 55 );
ltitle->setFixedWidth( 200 );
ldescription->setFixedWidth( 200 );
ldescription->setWordWrap( true );
setPalette( Qt::black ); //should be recursive
ltitle->setPalette( palette() ); //but Qt docs
ldescription->setPalette( palette() ); //lie
QFont f = ltitle->font();
f.setBold( true );
ltitle->setFont( f );
f.setBold( false );
f.setPixelSize( 10 );
ldescription->setFont( f );
QVBoxLayout* v = new QVBoxLayout;
v->addWidget( ltitle );
v->addWidget( ldescription );
v->setSpacing( 3 );
QHBoxLayout* h = new QHBoxLayout( this );
h->addWidget( logo );
h->addLayout( v );
h->setMargin( 12 );
h->setSizeConstraint( QLayout::SetFixedSize );
h->setAlignment( logo, Qt::AlignCenter );
h->setAlignment( v, Qt::AlignTop );
setWindowFlags( Qt::FramelessWindowHint | Qt::WindowStaysOnTopHint );
setWindowOpacity( 0.85 );
int x = QDesktopWidget().availableGeometry().right() - sizeHint().width() - 20;
int y = 50;
move( x, y );
show();
QTimer::singleShot( 10 * 1000, this, SLOT(deleteLater()) );
}
lastfm-1.5.4.27091+dfsg1/src/libMoose/QtOverrides/README 0000644 0000000 0000000 00000001067 11031266061 020655 0 ustar root root Brief
=====
Force this directory first in the -I g++ directives to use these overrides.
With QMake: CXX = $$CXX -IlibMoose/QtOverrides
There is danger with this system. But it beats the system where developers
could accidentally use the Qt version of a class or function and for some
reason it is absolutely essential our override is used.
NOTE, the cpp files are named without the Q as this seems to break qmake, heh :)
Implementations
===============
QSystemTrayIcon
---------------
For sendMessage() on mac, to show a notification when Growl is not installed.
lastfm-1.5.4.27091+dfsg1/src/libMoose/QtOverrides/QSystemTrayIcon 0000644 0000000 0000000 00000003760 11031266061 023000 0 ustar root root /***************************************************************************
* Copyright 2008 Last.fm Ltd. *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 2 of the License, or *
* (at your option) any later version. *
* *
* This program is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with this program; if not, write to the *
* Free Software Foundation, Inc., *
* 51 Franklin Steet, Fifth Floor, Boston, MA 02110-1301, USA. *
***************************************************************************/
#ifndef QT_OVERRIDES_SYSTEM_TRAY_ICON_H
#define QT_OVERRIDES_SYSTEM_TRAY_ICON_H
#include
#ifdef Q_OS_MAC
namespace Moose
{
/** @author Max Howell
*/
class QSystemTrayIcon : public ::QSystemTrayIcon
{
public:
QSystemTrayIcon( QObject* parent ) : ::QSystemTrayIcon( parent )
{}
void showMessage( const QString& title,
const QString& text,
MessageIcon icon = Information,
int millisecondsTimeoutHint = 10000 );
};
}
#define QSystemTrayIcon Moose::QSystemTrayIcon
#endif
#endif
lastfm-1.5.4.27091+dfsg1/src/libMoose/MooseCommon.cpp 0000644 0000000 0000000 00000026372 11031266061 020473 0 ustar root root /***************************************************************************
* Copyright (C) 2005 - 2007 by *
* Last.fm Ltd *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 2 of the License, or *
* (at your option) any later version. *
* *
* This program is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with this program; if not, write to the *
* Free Software Foundation, Inc., *
* 51 Franklin Steet, Fifth Floor, Boston, MA 02110-1301, USA. *
***************************************************************************/
#include "MooseCommon.h"
#include "logger.h"
#include "UnicornCommon.h"
#include "LastFmSettings.h"
#include
#include
#include
#include
#include
#include
#include
#include
#include
#ifdef WIN32
#include
#include
#endif
namespace MooseUtils
{
QString
dataPath( QString file )
{
return QApplication::applicationDirPath() + "/data/" + file;
}
QString
savePath( QString file )
{
QString path;
#ifdef WIN32
path = UnicornUtils::appDataPath();
if ( path.isEmpty() )
path = QApplication::applicationDirPath();
else
path += "/Last.fm/Client";
#else
path = UnicornUtils::appDataPath() + "/Last.fm";
#endif
QDir d( path );
d.mkpath( path );
return d.filePath( file );
}
QString
logPath( QString file )
{
#ifndef Q_WS_MAC
return savePath( file );
#else
return QDir( QDir::homePath() + "/Library/Logs" ).filePath( file );
#endif
}
QString
cachePath()
{
#ifdef Q_WS_MAC
QString appSupportFolder = UnicornUtils::applicationSupportFolderPath();
QDir cacheDir( appSupportFolder + "/Last.fm/Cache" );
if (!cacheDir.exists())
{
cacheDir.mkpath( appSupportFolder + "/Last.fm/Cache" );
}
return cacheDir.path() + "/";
#else
return savePath( "cache/" );
#endif
}
QString
servicePath( QString name )
{
QString dirPath;
#ifdef WIN32
// Hack to get it working with VS2005
dirPath = qApp->applicationDirPath();
#else
dirPath = qApp->applicationDirPath() + "/services";
#endif
#ifndef QT_NO_DEBUG
dirPath += "/debug";
#endif
if ( name.isEmpty() )
{
return dirPath;
}
#ifndef QT_NO_DEBUG
name += DEBUG_SUFFIX;
#endif
QDir servicesDir( dirPath );
QString fileName = SERVICE_PREFIX + name + LIB_EXTENSION;
return servicesDir.absoluteFilePath( fileName );
}
// This is the kind of beastly function that Max will throw a hissy fit if he can't have.
static void
loadServiceError( QString name )
{
QMessageBox::critical( 0,
QCoreApplication::translate( "Container", "Error" ),
QCoreApplication::translate( "Container", "Couldn't load service: %1. The application won't be able to start." ).arg( name ) );
QCoreApplication::exit( 1 );
}
QObject*
loadService( QString name )
{
QString path = servicePath( name );
qDebug() << "Loading service: " << name << "at" << path;
QObject* plugin = QPluginLoader( path ).instance();
if ( plugin == NULL )
{
loadServiceError( name );
return NULL;
}
return plugin;
}
QIcon
icon( const char *name )
{
return QIcon( MooseUtils::dataPath( QString("icons/") + name + ".png" ) );
}
MooseEnums::ScrobblableStatus
scrobblableStatus( TrackInfo& track )
{
using namespace MooseEnums;
// Check duration
if ( track.duration() < MooseConstants::kScrobbleMinLength )
{
LOG( 3, "Track length is " << track.duration() << " s which is too short, will not submit.\n" );
return TooShort;
}
// Radio tracks above preview length always scrobble
if ( track.source() == TrackInfo::Radio )
{
return OkToScrobble;
}
// Check timestamp
if ( track.timeStamp() == 0 )
{
LOG( 3, "Track has no timestamp, will not submit.\n" );
return NoTimeStamp;
}
// actual spam prevention is something like 12 hours, but we are only
// trying to weed out obviously bad data, server side criteria for
// "the future" may change, so we should let the server decide, not us
if ( track.timeStamp() > QDateTime::currentDateTime().addMonths( 1 ).toTime_t() )
{
LOGL( 3, "Track is more than a month in the future, will not submit" );
return FromTheFuture;
}
if ( track.timeStamp() < QDateTime::fromString( "2003-01-01", Qt::ISODate ).toTime_t() )
{
LOGL( 3, "Track was played before the Audioscrobbler project was founded! Will not submit" );
return FromTheDistantPast;
}
// Check if any required fields are empty
if ( track.artist().isEmpty() )
{
LOG( 3, "Artist was missing, will not submit.\n" );
return ArtistNameMissing;
}
if ( track.track().isEmpty() )
{
LOG( 3, "Artist, track or duration was missing, will not submit.\n" );
return TrackNameMissing;
}
// Check if dir excluded
if ( isDirExcluded( track.path() ) )
{
LOG( 3, "Track is in excluded directory `" << track.path() << "', " << "will not submit.\n" );
return ExcludedDir;
}
QStringList invalidList;
invalidList << "unknown artist"
<< "unknown"
<< "[unknown]"
<< "[unknown artist]";
// Check if artist name is an invalid one like "unknown"
foreach( QString invalid, invalidList )
{
if ( track.artist().toLower() == invalid )
{
LOG( 3, "Artist '" << track.artist() << "' is an invalid artist name, will not submit.\n" );
return ArtistInvalid;
}
}
// All tests passed!
return OkToScrobble;
}
bool
isDirExcluded( const QString& path )
{
QString pathToTest = QDir( path ).absolutePath();
#ifdef WIN32
pathToTest = pathToTest.toLower();
#endif
if (pathToTest.isEmpty())
return false;
foreach ( QString bannedPath, The::currentUser().excludedDirs() )
{
bannedPath = QDir( bannedPath ).absolutePath();
#ifdef WIN32
bannedPath = bannedPath.toLower();
#endif
// Try and match start of given path with banned dir
if ( pathToTest.startsWith( bannedPath ) )
{
// Found, this path is from a banned dir
return true;
}
}
// The path wasn't found in exclusions list
return false;
}
int
scrobbleTime( TrackInfo& track )
{
// If we don't have a length or it's less than the minimum, return the
// threshold
if ( track.duration() <= 0 || track.duration() < MooseConstants::kScrobbleMinLength )
return MooseConstants::kScrobbleTimeMax;
float scrobPoint = qBound( MooseConstants::kScrobblePointMin,
The::currentUser().scrobblePoint(),
MooseConstants::kScrobblePointMax );
scrobPoint /= 100.0f;
return qMin( MooseConstants::kScrobbleTimeMax, int( track.duration() * scrobPoint ) );
}
bool
isAlreadyRunning()
{
#ifdef WIN32
QString id( "Lastfm-F396D8C8-9595-4f48-A319-48DCB827AD8F" );
::CreateMutexA( NULL, false, id.toAscii() );
// The call fails with ERROR_ACCESS_DENIED if the Mutex was
// created in a different users session because of passing
// NULL for the SECURITY_ATTRIBUTES on Mutex creation);
return ::GetLastError() == ERROR_ALREADY_EXISTS || ::GetLastError() == ERROR_ACCESS_DENIED;
#else
return sendToInstance( "", MooseEnums::DontStartNewInstance );
#endif
}
bool
sendToInstance( const QString& data, MooseEnums::StartNewInstanceBehaviour behaviour )
{
LOGL( 3, "sendToInstance (new instance): " << data );
QTcpSocket socket;
socket.connectToHost( QHostAddress::LocalHost, The::settings().controlPort() );
if ( socket.waitForConnected( 500 ) )
{
if ( data.length() > 0 )
{
QByteArray utf8Data = data.toUtf8();
socket.write( utf8Data, utf8Data.length() );
socket.flush();
}
socket.close();
return true;
}
else if ( behaviour == MooseEnums::StartNewInstance )
{
qDebug() << "Starting instance" << The::settings().path();
//FIXME doesn't work for some reason
return QProcess::startDetached( The::settings().path(), QStringList() << data );
}
return false;
}
QStringList
extensionPaths()
{
QStringList paths;
#ifdef WIN32
// Hack to get it working with VS2005
QString path = qApp->applicationDirPath();
#else
QString path = qApp->applicationDirPath() + "/extensions";
#endif
#ifndef QT_NO_DEBUG
path += "/debug";
#endif
QDir d( path );
foreach( QString fileName, d.entryList( QDir::Files ) )
{
if (!fileName.startsWith( EXTENSION_PREFIX ))
continue;
QString const path = d.absoluteFilePath( fileName );
if (!QLibrary::isLibrary( path ))
continue;
paths += path;
}
return paths;
}
#ifdef WIN32
static QString
helperStartupShortcutPath()
{
wchar_t acPath[MAX_PATH];
HRESULT h = SHGetFolderPathW( NULL, CSIDL_STARTUP | CSIDL_FLAG_CREATE,
NULL, 0, acPath );
if ( h == S_OK )
{
QString shortcutPath;
shortcutPath = QString::fromUtf16( reinterpret_cast( acPath ) );
if ( !shortcutPath.endsWith( "\\" ) && !shortcutPath.endsWith( "/" ) )
shortcutPath += "\\";
shortcutPath += "Last.fm Helper.lnk";
return shortcutPath;
}
else
{
LOGL( 1, "Uh oh, Windows returned no STARTUP path, not going to be able to disable helper" );
return "";
}
}
void
disableHelperApp()
{
// Delete the shortcut from startup and kill process
QString shortcutPath = helperStartupShortcutPath();
if ( !shortcutPath.isEmpty() && QFile::exists( shortcutPath ) )
{
bool fine = QFile::remove( shortcutPath );
if ( !fine )
{
LOGL( 1, "Deletion of shortcut failed, helper will still autolaunch" );
}
else
{
LOGL( 3, "Helper shortcut removed from Startup" );
}
}
}
#endif // WIN32
#ifdef Q_OS_MAC
QString bundleDirPath()
{
return QDir( qApp->applicationDirPath() ).filePath( "../.." );
}
#endif
} // namespace MooseUtils
lastfm-1.5.4.27091+dfsg1/src/libMoose/README 0000644 0000000 0000000 00000000260 11031266061 016400 0 ustar root root Moose applications have a number of requirements:
* They must reside in the SAME directory as the Last.fm executable.
* A Logger instance must be created for logging to work.
lastfm-1.5.4.27091+dfsg1/src/libMoose/MooseDllExportMacro.h 0000644 0000000 0000000 00000004002 10725516002 021573 0 ustar root root /***************************************************************************
* Copyright (C) 2005 - 2007 by *
* Last.fm Ltd *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 2 of the License, or *
* (at your option) any later version. *
* *
* This program is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with this program; if not, write to the *
* Free Software Foundation, Inc., *
* 51 Franklin Steet, Fifth Floor, Boston, MA 02110-1301, USA. *
***************************************************************************/
#ifndef MOOSEDLLEXPORTMACRO_H
#define MOOSEDLLEXPORTMACRO_H
// When we compile the header in a DLL as part of the DLL, we need
// dllexport for the functions to be exported. When including the header
// as part of the client modules, we need dllimport. X_DLLEXPORT_PRO
// should only be defined in the DLL .pro.
#if defined(_WIN32) || defined(WIN32)
#ifdef MOOSE_DLLEXPORT_PRO
#define MOOSE_DLLEXPORT __declspec(dllexport)
#else
#define MOOSE_DLLEXPORT __declspec(dllimport)
#endif
#else
#define MOOSE_DLLEXPORT
#endif
#endif // MOOSEDLLEXPORTMACRO_H
lastfm-1.5.4.27091+dfsg1/src/libMoose/confirmdialog.h 0000644 0000000 0000000 00000006060 10725516002 020514 0 ustar root root /***************************************************************************
* Copyright (C) 2005 - 2007 by *
* Christian Muehlhaeuser, Last.fm Ltd *
* Erik Jaelevik, Last.fm Ltd *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 2 of the License, or *
* (at your option) any later version. *
* *
* This program is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with this program; if not, write to the *
* Free Software Foundation, Inc., *
* 51 Franklin Steet, Fifth Floor, Boston, MA 02110-1301, USA. *
***************************************************************************/
#ifndef CONFIRMDIALOG_H
#define CONFIRMDIALOG_H
#include "MooseDllExportMacro.h"
#include
#include
class TrackInfo;
// Qt 4.3.x UIC adds some wierd defines that fuck up our layouts! :(
#ifdef Q_OS_MAC
#undef Q_OS_MAC
#include "ui_confirmdialog.h"
#define Q_OS_MAC
#else
#include "ui_confirmdialog.h"
#endif
class MOOSE_DLLEXPORT ConfirmDialog : public QDialog
{
Q_OBJECT
public:
ConfirmDialog( QWidget *parent = 0 );
~ConfirmDialog();
/** shows the dialog with exec and returns true if the user clicked the Confirm button */
static bool share( const TrackInfo&, const QString& username, QWidget* parent );
static bool tag( const QString&, const QString& username, QWidget* parent );
static bool playlist( const TrackInfo&, QWidget* parent );
static bool love( const TrackInfo&, QWidget* parent );
static bool ban( const TrackInfo&, QWidget* parent );
static bool quit( QWidget* parent );
#ifndef Q_WS_X11
static bool hide( QWidget* parent );
#endif
int exec();
bool isDontAskChecked();
void setIcon( const QPixmap& );
void setIcon( const QString& path );
void setText( const QString& );
void setConfirmButtonText( const QString&, bool visible = true );
void setCancelButtonText( const QString&, bool visible = true );
void setDontAskText( const QString& );
void setOperationString( const QString& s ) { m_op = s; }
protected:
virtual void done( int );
private:
Ui::ConfirmDialog ui;
QString m_op;
};
#endif // CONFIRMDIALOG_H
lastfm-1.5.4.27091+dfsg1/src/libMoose/confirmdialog.cpp 0000644 0000000 0000000 00000015724 11031266061 021054 0 ustar root root /***************************************************************************
* Copyright (C) 2005 - 2007 by *
* Christian Muehlhaeuser, Last.fm Ltd *
* Erik Jaelevik, Last.fm Ltd *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 2 of the License, or *
* (at your option) any later version. *
* *
* This program is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with this program; if not, write to the *
* Free Software Foundation, Inc., *
* 51 Franklin Steet, Fifth Floor, Boston, MA 02110-1301, USA. *
***************************************************************************/
#include "confirmdialog.h"
#include "LastFmSettings.h"
#include "TrackInfo.h"
#include "logger.h"
#include "MooseCommon.h"
#include
using namespace MooseUtils;
ConfirmDialog::ConfirmDialog( QWidget *parent )
: QDialog( parent, Qt::Sheet )
{
/// if a drop operation asks for a confirm, cursor is set
/// to a drag mode, so we have to override it for duration
qApp->setOverrideCursor( Qt::ArrowCursor );
ui.setupUi( this );
ui.line->setFrameShadow( QFrame::Sunken ); // Want etched, not flat
ui.buttonBox->button( QDialogButtonBox::Ok )->setText( tr( "Confirm" ) );
setIcon( dataPath( "app_55.png" ) );
#ifdef Q_WS_MAC
ui.line->hide();
QFont f = font();
f.setPointSize( 12 );
setFont( f );
ui.messageLabel->setFont( f );
#if QT_VERSION >= 0x00040300
ui.gridLayout->setVerticalSpacing( 9 );
#endif
ui.hboxLayout->setMargin( 16 );
#endif
layout()->setSizeConstraint( QLayout::SetFixedSize );
connect( ui.buttonBox, SIGNAL( accepted() ), SLOT( accept() ) );
connect( ui.buttonBox, SIGNAL( rejected() ), SLOT( reject() ) );
adjustSize();
}
ConfirmDialog::~ConfirmDialog()
{
///@see ctor
qApp->restoreOverrideCursor();
}
void
ConfirmDialog::setIcon( const QPixmap& icon )
{
ui.iconLabel->setPixmap( icon );
}
void
ConfirmDialog::setIcon( const QString& file )
{
QPixmap p( file );
p = p.scaled( 32, 32, Qt::IgnoreAspectRatio, Qt::SmoothTransformation );
ui.iconLabel->setPixmap( p );
}
void
ConfirmDialog::setText( const QString& text )
{
ui.messageLabel->setText( text );
}
void
ConfirmDialog::setConfirmButtonText( const QString& text, bool visible )
{
ui.buttonBox->button( QDialogButtonBox::Ok )->setText( text );
ui.buttonBox->button( QDialogButtonBox::Ok )->setVisible( visible );
}
void
ConfirmDialog::setCancelButtonText( const QString& text, bool visible )
{
ui.buttonBox->button( QDialogButtonBox::Cancel )->setText( text );
ui.buttonBox->button( QDialogButtonBox::Cancel )->setVisible( visible );
}
void
ConfirmDialog::setDontAskText( const QString& text )
{
ui.dontAskCheck->setText( text );
}
bool
ConfirmDialog::isDontAskChecked()
{
return ui.dontAskCheck->checkState() == Qt::Checked;
}
int
ConfirmDialog::exec()
{
return The::settings().isDontAsk( m_op )
? QDialog::Accepted
: QDialog::exec();
}
void
ConfirmDialog::done( int r )
{
The::settings().setDontAsk( m_op, isDontAskChecked() );
QDialog::done( r );
}
bool //static
ConfirmDialog::share( const TrackInfo& track, const QString& username, QWidget* parent )
{
ConfirmDialog d( parent );
d.setText( tr( "Are you sure you want to share %1 with %2?" ).arg( track.track() ).arg( username ) );
d.setIcon( ":/action/Share.png" );
d.setOperationString( "share" );
d.setConfirmButtonText( tr("Share") );
return d.exec();
}
bool //static
ConfirmDialog::tag( const QString& itemData, const QString& username, QWidget* parent )
{
ConfirmDialog d( parent );
d.setText( tr( "Are you sure you want to tag %1 as %2?" ).arg( itemData ).arg( username ) );
d.setIcon( ":/action/tag.png" );
d.setOperationString( "tag" );
d.setConfirmButtonText( tr("Tag") );
return d.exec();
}
bool //static
ConfirmDialog::playlist( const TrackInfo& track, QWidget* parent )
{
ConfirmDialog d( parent );
d.setText( tr( "Are you sure you want to add %1 to your playlist?" ).arg( track.track() ) );
d.setIcon( ":/action/Playlist.png" );
d.setOperationString( "addToPlaylist" );
d.setConfirmButtonText( tr("Add") );
return d.exec();
}
bool //static
ConfirmDialog::love( const TrackInfo& track, QWidget* parent )
{
ConfirmDialog d( parent );
d.setText( tr( "Are you sure you want to add %1 to your loved tracks?" ).arg( track.track() ) );
d.setIcon( ":/action/love.png" );
d.setOperationString( "love" );
d.setConfirmButtonText( tr("Love") );
return d.exec();
}
bool //static
ConfirmDialog::ban( const TrackInfo& track, QWidget* parent )
{
ConfirmDialog d( parent );
d.setText( tr( "Are you sure you want to ban %1? This means the radio will never play this track again." ).arg( track.track() ) );
d.setIcon( ":/action/ban.png" );
d.setOperationString( "ban" );
d.setConfirmButtonText( tr("Ban") );
return d.exec();
}
bool //static
ConfirmDialog::quit( QWidget* parent )
{
ConfirmDialog d( parent );
d.setText( tr( "Really quit Last.fm? Any music you listen to will not be scrobbled to your profile." ) );
d.setOperationString( "quit" );
d.setConfirmButtonText( tr("Quit") );
return d.exec();
}
#ifndef Q_WS_X11
bool //static
ConfirmDialog::hide( QWidget* parent )
{
ConfirmDialog d( parent );
#ifdef WIN32
d.setText( tr( "The application will keep running in the background. "
"You can access it again by launching it from the Start Menu.\n\n"
"Use File > Exit to shut down permanently.\n" ) );
#else
d.setText( tr( "The application will keep running in the background. "
"You can access it again by launching it from the Applications folder.\n\n"
"Choose Quit from the application menu to shut down permanently.\n" ) );
#endif
d.setOperationString( "hide" );
d.setConfirmButtonText( tr("OK") );
d.setCancelButtonText( "", false );
d.setDontAskText( tr( "Don't tell me again" ) );
return d.exec();
}
#endif
lastfm-1.5.4.27091+dfsg1/src/Scrobbler-1.2.h 0000644 0000000 0000000 00000023610 11031266061 016337 0 ustar root root /***************************************************************************
* Copyright (C) 2007 by *
* Max Howell, Last.fm Ltd. *
* Christian Muehlhaeuser, Last.fm Ltd *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 2 of the License, or *
* (at your option) any later version. *
* *
* This program is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with this program; if not, write to the *
* Free Software Foundation, Inc., *
* 51 Franklin Steet, Fifth Floor, Boston, MA 02110-1301, USA. *
***************************************************************************/
#ifndef SCROBBLER_H
#define SCROBBLER_H
/** @author Max Howell
* @brief You should be able to drop this file into another project and submit scrobbles to Last.fm
*
* Instantiate a ScrobbleManager class. Pass it username and password
* information.
*
* Songs that have passed the scrobble point should be submitted to Last.fm
* when they _end_, using submit(), you can announce just started tracks using,
* announce() - this is the NowPlaying notification.
*
* You may want to strip down TrackInfo (see libUnicorn) to something more
* manageable. CachedHttp can be replaced with QHttp with no consequences.
*
* Determining the scrobble point and what constitutes a legal scrobble is up
* to you!
*
* http://www.audioscrobbler.net/development/protocol/
*/
#include
#include "libUnicorn/CachedHttp.h"
#include "libUnicorn/TrackInfo.h"
class ScrobbleCache;
class ScrobblerHandshakeRequest;
class ScrobblerNowPlayingRequest;
class ScrobblerPostRequest;
///////////////////////////////////////////////////////////////////////////////>
class Scrobbler : public QObject
{
Q_OBJECT
void hardFailure();
private slots:
void onHandshakeReturn( const QString& );
void onNowPlayingReturn( const QString& );
void onSubmissionReturn( const QString& );
void onHandshakeHeaderReceived( const QHttpResponseHeader& );
public:
struct Init
{
QString username;
QString password;
QString client_version;
};
explicit Scrobbler( const Init& );
enum Status
{
Connecting,
Handshaken,
Scrobbling,
TracksScrobbled,
TracksNotScrobbled,
StatusMax
};
enum Error
{
ErrorBadSession = StatusMax,
ErrorBannedClient,
ErrorBadAuthorisation,
ErrorBadTime,
ErrorNotInitialized,
NoError
};
bool canSubmit() const { return m_session_id.length() && m_submitted_tracks.isEmpty(); }
bool canAnnounce() const { return m_session_id.length(); }
QString username() const { return m_init.username; }
Init init() const { return m_init; }
/** @returns the number of tracks being scrobbled, 0 if empty cache or
* scrobbler is busy or scrobbler not handshaken yet, to test for that
* you can examine the result of canSubmit() */
int submit( const ScrobbleCache& );
/** Will update the now-playing status at the Last.fm website */
void announce( const TrackInfo& );
/** resets the running count of the number of scrobbled tracks */
void resetScrobbleCount() { m_scrobbled = 0; }
uint scrobbled() const { return m_scrobbled; }
Error lastError() const { return m_lastError; }
static QString errorDescription( Scrobbler::Error error );
signals:
void handshaken( Scrobbler* );
void scrobbled( const QList& );
void invalidated( int = NoError );
private:
ScrobblerHandshakeRequest* m_handshake;
ScrobblerNowPlayingRequest* m_now_playing;
ScrobblerPostRequest* m_submission;
Init m_init;
QString m_session_id;
uint m_hard_failures;
uint m_scrobbled;
Error m_lastError;
class QTimer* m_timer;
QList m_submitted_tracks;
};
///////////////////////////////////////////////////////////////////////////////>
///////////////////////////////////////////////////////////////////////////////>
class ScrobblerManager : public QObject
{
Q_OBJECT
/** one scrobbler per user */
QList m_scrobblers;
public:
ScrobblerManager( QObject* parent = 0 );
~ScrobblerManager();
void handshake( const Scrobbler::Init& );
bool canScrobble( const QString& username ) const { return scrobblerForUser( username ); }
Scrobbler::Error
lastError( const QString& username ) const
{
return scrobblerForUser( username )
? scrobblerForUser( username )->lastError()
: Scrobbler::ErrorNotInitialized;
}
public slots:
void scrobble( TrackInfo );
void nowPlaying( const TrackInfo& );
void scrobble( const class ScrobbleCache& );
signals:
/** the controller should show status in an appropriate manner */
void status( int code, QVariant data = QVariant() );
private slots:
/** a scrobbler is now invalid, delete it and handshake a new one */
void onInvalidated( int errorcode );
void onHandshaken( Scrobbler* );
void onScrobbled( const QList& );
private:
Scrobbler* scrobblerForUser( const QString& username ) const;
};
///////////////////////////////////////////////////////////////////////////////>
///////////////////////////////////////////////////////////////////////////////>
class ScrobblerHttp : public CachedHttp
{
Q_OBJECT
protected:
ScrobblerHttp( QObject* parent );
int m_id;
QTimer *m_retry_timer;
private slots:
void onRequestFinished( int id, bool error );
signals:
void done( const QString& data );
protected slots:
virtual void request() = 0;
public:
void resetRetryTimer();
int retry();
int id() const { return m_id; }
};
///////////////////////////////////////////////////////////////////////////////>
///////////////////////////////////////////////////////////////////////////////>
class ScrobblerHandshakeRequest : public ScrobblerHttp
{
Scrobbler::Init m_init;
virtual void request();
public:
ScrobblerHandshakeRequest( QObject* parent ) : ScrobblerHttp( parent )
{}
virtual void request( const Scrobbler::Init& init)
{
m_init = init;
request();
}
};
///////////////////////////////////////////////////////////////////////////////>
///////////////////////////////////////////////////////////////////////////////>
class ScrobblerPostRequest : public ScrobblerHttp
{
QString m_host;
QString m_path;
QByteArray m_data;
protected:
virtual void request();
public:
ScrobblerPostRequest( QObject* parent ) : ScrobblerHttp( parent )
{}
void setUrl( const QUrl& url );
void request( const QByteArray& data );
};
///////////////////////////////////////////////////////////////////////////////>
///////////////////////////////////////////////////////////////////////////////>
/** class exists to allow us to delay 5 seconds before we announce new tracks
* because if a user skips many tracks in quick succession, eg searching for a
* good track in iTunes shuffle, it breaks facebook and teh intertubes */
class ScrobblerNowPlayingRequest : public ScrobblerPostRequest
{
QTimer* m_timer;
virtual void request();
public:
ScrobblerNowPlayingRequest( QObject* );
};
///////////////////////////////////////////////////////////////////////////////>
///////////////////////////////////////////////////////////////////////////////>
class ScrobbleCache
{
protected:
QString m_path;
QString m_username;
QList m_tracks;
ScrobbleCache() //used by mediaDeviceCache()
{}
/** forces only one of each track for a specific timestamp */
void merge( const TrackInfo& );
void read(); /// reads from m_path into m_tracks
void write(); /// writes m_tracks to m_path
/// m_username needs to be set by the caller
static ScrobbleCache fromFile( const QString& );
public:
explicit ScrobbleCache( const QString& username );
/** note this is unique for TrackInfo::sameAs() and equal timestamps
* obviously playcounts will not be increased for the same timestamp */
void append( const TrackInfo& );
void append( const QList