1531 lines
76 KiB
C++
1531 lines
76 KiB
C++
#include <PythonQt.h>
|
|
#include <QObject>
|
|
#include <QVariant>
|
|
#include <albumcoverfetcher.h>
|
|
#include <albumcoverfetchersearch.h>
|
|
#include <coverprovider.h>
|
|
#include <coverproviders.h>
|
|
#include <directory.h>
|
|
#include <librarybackend.h>
|
|
#include <libraryquery.h>
|
|
#include <network.h>
|
|
#include <player.h>
|
|
#include <playlist.h>
|
|
#include <playlistbackend.h>
|
|
#include <playlistcontainer.h>
|
|
#include <playlistitem.h>
|
|
#include <playlistmanager.h>
|
|
#include <playlistparser.h>
|
|
#include <playlistsequence.h>
|
|
#include <qabstractitemmodel.h>
|
|
#include <qabstractnetworkcache.h>
|
|
#include <qbytearray.h>
|
|
#include <qcoreevent.h>
|
|
#include <qcursor.h>
|
|
#include <qdatastream.h>
|
|
#include <qdir.h>
|
|
#include <qfont.h>
|
|
#include <qicon.h>
|
|
#include <qimage.h>
|
|
#include <qiodevice.h>
|
|
#include <qitemselectionmodel.h>
|
|
#include <qkeysequence.h>
|
|
#include <qlist.h>
|
|
#include <qlocale.h>
|
|
#include <qmargins.h>
|
|
#include <qnetworkrequest.h>
|
|
#include <qobject.h>
|
|
#include <qpaintdevice.h>
|
|
#include <qpalette.h>
|
|
#include <qpixmap.h>
|
|
#include <qpoint.h>
|
|
#include <qrect.h>
|
|
#include <qregion.h>
|
|
#include <qsize.h>
|
|
#include <qsizepolicy.h>
|
|
#include <qstandarditemmodel.h>
|
|
#include <qstringlist.h>
|
|
#include <qurl.h>
|
|
#include <qwidget.h>
|
|
#include <radiomodel.h>
|
|
#include <radioservice.h>
|
|
#include <song.h>
|
|
#include <specialplaylisttype.h>
|
|
#include <taskmanager.h>
|
|
#include <urlhandler.h>
|
|
|
|
|
|
|
|
class PythonQtWrapper_AlbumCoverFetcherSearch : public QObject
|
|
{ Q_OBJECT
|
|
public:
|
|
public slots:
|
|
void delete_AlbumCoverFetcherSearch(AlbumCoverFetcherSearch* obj) { delete obj; }
|
|
void Cancel(AlbumCoverFetcherSearch* theWrappedObject);
|
|
void Start(AlbumCoverFetcherSearch* theWrappedObject);
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
class PythonQtShell_CoverProvider : public CoverProvider
|
|
{
|
|
public:
|
|
PythonQtShell_CoverProvider(const QString& name, QObject* parent):CoverProvider(name, parent),_wrapper(NULL) {};
|
|
|
|
virtual void CancelSearch(int id);
|
|
virtual bool StartSearch(const QString& artist, const QString& album, int id);
|
|
virtual void childEvent(QChildEvent* arg__1);
|
|
virtual void customEvent(QEvent* arg__1);
|
|
virtual bool event(QEvent* arg__1);
|
|
virtual bool eventFilter(QObject* arg__1, QEvent* arg__2);
|
|
virtual void timerEvent(QTimerEvent* arg__1);
|
|
|
|
PythonQtInstanceWrapper* _wrapper;
|
|
};
|
|
|
|
class PythonQtPublicPromoter_CoverProvider : public CoverProvider
|
|
{ public:
|
|
inline void promoted_CancelSearch(int id) { CoverProvider::CancelSearch(id); }
|
|
};
|
|
|
|
class PythonQtWrapper_CoverProvider : public QObject
|
|
{ Q_OBJECT
|
|
public:
|
|
public slots:
|
|
CoverProvider* new_CoverProvider(const QString& name, QObject* parent);
|
|
void delete_CoverProvider(CoverProvider* obj) { delete obj; }
|
|
void CancelSearch(CoverProvider* theWrappedObject, int id);
|
|
QString name(CoverProvider* theWrappedObject) const;
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
class PythonQtWrapper_CoverProviders : public QObject
|
|
{ Q_OBJECT
|
|
public:
|
|
public slots:
|
|
void AddProvider(CoverProviders* theWrappedObject, CoverProvider* provider);
|
|
bool HasAnyProviders(CoverProviders* theWrappedObject) const;
|
|
QList<CoverProvider* > List(CoverProviders* theWrappedObject) const;
|
|
int NextId(CoverProviders* theWrappedObject);
|
|
void RemoveProvider(CoverProviders* theWrappedObject, CoverProvider* provider);
|
|
CoverProviders* static_CoverProviders_instance();
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
class PythonQtShell_CoverSearchResult : public CoverSearchResult
|
|
{
|
|
public:
|
|
PythonQtShell_CoverSearchResult():CoverSearchResult(),_wrapper(NULL) {};
|
|
|
|
|
|
PythonQtInstanceWrapper* _wrapper;
|
|
};
|
|
|
|
class PythonQtWrapper_CoverSearchResult : public QObject
|
|
{ Q_OBJECT
|
|
public:
|
|
public slots:
|
|
CoverSearchResult* new_CoverSearchResult();
|
|
CoverSearchResult* new_CoverSearchResult(const CoverSearchResult& other) {
|
|
PythonQtShell_CoverSearchResult* a = new PythonQtShell_CoverSearchResult();
|
|
*((CoverSearchResult*)a) = other;
|
|
return a; }
|
|
void delete_CoverSearchResult(CoverSearchResult* obj) { delete obj; }
|
|
void py_set_provider(CoverSearchResult* theWrappedObject, QString provider){ theWrappedObject->provider = provider; }
|
|
QString py_get_provider(CoverSearchResult* theWrappedObject){ return theWrappedObject->provider; }
|
|
void py_set_description(CoverSearchResult* theWrappedObject, QString description){ theWrappedObject->description = description; }
|
|
QString py_get_description(CoverSearchResult* theWrappedObject){ return theWrappedObject->description; }
|
|
void py_set_image_url(CoverSearchResult* theWrappedObject, QString image_url){ theWrappedObject->image_url = image_url; }
|
|
QString py_get_image_url(CoverSearchResult* theWrappedObject){ return theWrappedObject->image_url; }
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
class PythonQtShell_Directory : public Directory
|
|
{
|
|
public:
|
|
PythonQtShell_Directory():Directory(),_wrapper(NULL) {};
|
|
|
|
|
|
PythonQtInstanceWrapper* _wrapper;
|
|
};
|
|
|
|
class PythonQtWrapper_Directory : public QObject
|
|
{ Q_OBJECT
|
|
public:
|
|
public slots:
|
|
Directory* new_Directory();
|
|
Directory* new_Directory(const Directory& other) {
|
|
PythonQtShell_Directory* a = new PythonQtShell_Directory();
|
|
*((Directory*)a) = other;
|
|
return a; }
|
|
void delete_Directory(Directory* obj) { delete obj; }
|
|
void py_set_path(Directory* theWrappedObject, QString path){ theWrappedObject->path = path; }
|
|
QString py_get_path(Directory* theWrappedObject){ return theWrappedObject->path; }
|
|
void py_set_id(Directory* theWrappedObject, int id){ theWrappedObject->id = id; }
|
|
int py_get_id(Directory* theWrappedObject){ return theWrappedObject->id; }
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
class PythonQtShell_LibraryBackend : public LibraryBackend
|
|
{
|
|
public:
|
|
PythonQtShell_LibraryBackend(QObject* parent = 0):LibraryBackend(parent),_wrapper(NULL) {};
|
|
|
|
virtual void AddDirectory(const QString& path);
|
|
virtual void ChangeDirPath(int id, const QString& old_path, const QString& new_path);
|
|
virtual bool ExecQuery(LibraryQuery* q);
|
|
virtual QList<Song > FindSongsInDirectory(int id);
|
|
virtual LibraryBackendInterface::Album GetAlbumArt(const QString& artist, const QString& album);
|
|
virtual QList<LibraryBackendInterface::Album > GetAlbumsByArtist(const QString& artist, const QueryOptions& opt = QueryOptions());
|
|
virtual QList<LibraryBackendInterface::Album > GetAllAlbums(const QueryOptions& opt = QueryOptions());
|
|
virtual QStringList GetAllArtists(const QueryOptions& opt = QueryOptions());
|
|
virtual QStringList GetAllArtistsWithAlbums(const QueryOptions& opt = QueryOptions());
|
|
virtual QList<Directory > GetAllDirectories();
|
|
virtual QList<LibraryBackendInterface::Album > GetCompilationAlbums(const QueryOptions& opt = QueryOptions());
|
|
virtual QList<Song > GetCompilationSongs(const QString& album, const QueryOptions& opt = QueryOptions());
|
|
virtual Song GetSongById(int id);
|
|
virtual Song GetSongByUrl(const QUrl& url, qint64 beginning = 0);
|
|
virtual QList<Song > GetSongs(const QString& artist, const QString& album, const QueryOptions& opt = QueryOptions());
|
|
virtual QList<Song > GetSongsByUrl(const QUrl& url);
|
|
virtual bool HasCompilations(const QueryOptions& opt = QueryOptions());
|
|
virtual void LoadDirectoriesAsync();
|
|
virtual void RemoveDirectory(const Directory& dir);
|
|
virtual QList<Subdirectory > SubdirsInDirectory(int id);
|
|
virtual void UpdateManualAlbumArtAsync(const QString& artist, const QString& album, const QString& art);
|
|
virtual void UpdateTotalSongCountAsync();
|
|
virtual void childEvent(QChildEvent* arg__1);
|
|
virtual void customEvent(QEvent* arg__1);
|
|
virtual bool event(QEvent* arg__1);
|
|
virtual bool eventFilter(QObject* arg__1, QEvent* arg__2);
|
|
virtual void timerEvent(QTimerEvent* arg__1);
|
|
|
|
PythonQtInstanceWrapper* _wrapper;
|
|
};
|
|
|
|
class PythonQtPublicPromoter_LibraryBackend : public LibraryBackend
|
|
{ public:
|
|
inline void promoted_AddDirectory(const QString& path) { LibraryBackend::AddDirectory(path); }
|
|
inline void promoted_ChangeDirPath(int id, const QString& old_path, const QString& new_path) { LibraryBackend::ChangeDirPath(id, old_path, new_path); }
|
|
inline bool promoted_ExecQuery(LibraryQuery* q) { return LibraryBackend::ExecQuery(q); }
|
|
inline QList<Song > promoted_FindSongsInDirectory(int id) { return LibraryBackend::FindSongsInDirectory(id); }
|
|
inline LibraryBackendInterface::Album promoted_GetAlbumArt(const QString& artist, const QString& album) { return LibraryBackend::GetAlbumArt(artist, album); }
|
|
inline QList<LibraryBackendInterface::Album > promoted_GetAlbumsByArtist(const QString& artist, const QueryOptions& opt = QueryOptions()) { return LibraryBackend::GetAlbumsByArtist(artist, opt); }
|
|
inline QList<LibraryBackendInterface::Album > promoted_GetAllAlbums(const QueryOptions& opt = QueryOptions()) { return LibraryBackend::GetAllAlbums(opt); }
|
|
inline QStringList promoted_GetAllArtists(const QueryOptions& opt = QueryOptions()) { return LibraryBackend::GetAllArtists(opt); }
|
|
inline QStringList promoted_GetAllArtistsWithAlbums(const QueryOptions& opt = QueryOptions()) { return LibraryBackend::GetAllArtistsWithAlbums(opt); }
|
|
inline QList<Directory > promoted_GetAllDirectories() { return LibraryBackend::GetAllDirectories(); }
|
|
inline QList<LibraryBackendInterface::Album > promoted_GetCompilationAlbums(const QueryOptions& opt = QueryOptions()) { return LibraryBackend::GetCompilationAlbums(opt); }
|
|
inline QList<Song > promoted_GetCompilationSongs(const QString& album, const QueryOptions& opt = QueryOptions()) { return LibraryBackend::GetCompilationSongs(album, opt); }
|
|
inline Song promoted_GetSongById(int id) { return LibraryBackend::GetSongById(id); }
|
|
inline Song promoted_GetSongByUrl(const QUrl& url, qint64 beginning = 0) { return LibraryBackend::GetSongByUrl(url, beginning); }
|
|
inline QList<Song > promoted_GetSongs(const QString& artist, const QString& album, const QueryOptions& opt = QueryOptions()) { return LibraryBackend::GetSongs(artist, album, opt); }
|
|
inline QList<Song > promoted_GetSongsByUrl(const QUrl& url) { return LibraryBackend::GetSongsByUrl(url); }
|
|
inline bool promoted_HasCompilations(const QueryOptions& opt = QueryOptions()) { return LibraryBackend::HasCompilations(opt); }
|
|
inline void promoted_LoadDirectoriesAsync() { LibraryBackend::LoadDirectoriesAsync(); }
|
|
inline void promoted_RemoveDirectory(const Directory& dir) { LibraryBackend::RemoveDirectory(dir); }
|
|
inline QList<Subdirectory > promoted_SubdirsInDirectory(int id) { return LibraryBackend::SubdirsInDirectory(id); }
|
|
inline void promoted_UpdateManualAlbumArtAsync(const QString& artist, const QString& album, const QString& art) { LibraryBackend::UpdateManualAlbumArtAsync(artist, album, art); }
|
|
inline void promoted_UpdateTotalSongCountAsync() { LibraryBackend::UpdateTotalSongCountAsync(); }
|
|
};
|
|
|
|
class PythonQtWrapper_LibraryBackend : public QObject
|
|
{ Q_OBJECT
|
|
public:
|
|
public slots:
|
|
LibraryBackend* new_LibraryBackend(QObject* parent = 0);
|
|
void delete_LibraryBackend(LibraryBackend* obj) { delete obj; }
|
|
void AddDirectory(LibraryBackend* theWrappedObject, const QString& path);
|
|
void ChangeDirPath(LibraryBackend* theWrappedObject, int id, const QString& old_path, const QString& new_path);
|
|
void DeleteAll(LibraryBackend* theWrappedObject);
|
|
bool ExecQuery(LibraryBackend* theWrappedObject, LibraryQuery* q);
|
|
QList<Song > FindSongsInDirectory(LibraryBackend* theWrappedObject, int id);
|
|
LibraryBackendInterface::Album GetAlbumArt(LibraryBackend* theWrappedObject, const QString& artist, const QString& album);
|
|
QList<LibraryBackendInterface::Album > GetAlbumsByArtist(LibraryBackend* theWrappedObject, const QString& artist, const QueryOptions& opt = QueryOptions());
|
|
QStringList GetAll(LibraryBackend* theWrappedObject, const QString& column, const QueryOptions& opt = QueryOptions());
|
|
QList<LibraryBackendInterface::Album > GetAllAlbums(LibraryBackend* theWrappedObject, const QueryOptions& opt = QueryOptions());
|
|
QStringList GetAllArtists(LibraryBackend* theWrappedObject, const QueryOptions& opt = QueryOptions());
|
|
QStringList GetAllArtistsWithAlbums(LibraryBackend* theWrappedObject, const QueryOptions& opt = QueryOptions());
|
|
QList<Directory > GetAllDirectories(LibraryBackend* theWrappedObject);
|
|
QList<LibraryBackendInterface::Album > GetCompilationAlbums(LibraryBackend* theWrappedObject, const QueryOptions& opt = QueryOptions());
|
|
QList<Song > GetCompilationSongs(LibraryBackend* theWrappedObject, const QString& album, const QueryOptions& opt = QueryOptions());
|
|
Song GetSongById(LibraryBackend* theWrappedObject, int id);
|
|
Song GetSongByUrl(LibraryBackend* theWrappedObject, const QUrl& url, qint64 beginning = 0);
|
|
QList<Song > GetSongs(LibraryBackend* theWrappedObject, const QString& artist, const QString& album, const QueryOptions& opt = QueryOptions());
|
|
QList<Song > GetSongsByForeignId(LibraryBackend* theWrappedObject, const QStringList& ids, const QString& table, const QString& column);
|
|
QList<Song > GetSongsById(LibraryBackend* theWrappedObject, const QList<int >& ids);
|
|
QList<Song > GetSongsById(LibraryBackend* theWrappedObject, const QStringList& ids);
|
|
QList<Song > GetSongsByUrl(LibraryBackend* theWrappedObject, const QUrl& url);
|
|
bool HasCompilations(LibraryBackend* theWrappedObject, const QueryOptions& opt = QueryOptions());
|
|
void IncrementPlayCountAsync(LibraryBackend* theWrappedObject, int id);
|
|
void IncrementSkipCountAsync(LibraryBackend* theWrappedObject, int id, float progress);
|
|
void LoadDirectoriesAsync(LibraryBackend* theWrappedObject);
|
|
void RemoveDirectory(LibraryBackend* theWrappedObject, const Directory& dir);
|
|
void ResetStatisticsAsync(LibraryBackend* theWrappedObject, int id);
|
|
QList<Subdirectory > SubdirsInDirectory(LibraryBackend* theWrappedObject, int id);
|
|
void UpdateManualAlbumArtAsync(LibraryBackend* theWrappedObject, const QString& artist, const QString& album, const QString& art);
|
|
void UpdateSongRatingAsync(LibraryBackend* theWrappedObject, int id, float rating);
|
|
void UpdateTotalSongCountAsync(LibraryBackend* theWrappedObject);
|
|
QString dirs_table(LibraryBackend* theWrappedObject) const;
|
|
QString songs_table(LibraryBackend* theWrappedObject) const;
|
|
QString subdirs_table(LibraryBackend* theWrappedObject) const;
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
class PythonQtShell_LibraryBackendInterface : public LibraryBackendInterface
|
|
{
|
|
public:
|
|
PythonQtShell_LibraryBackendInterface(QObject* parent = 0):LibraryBackendInterface(parent),_wrapper(NULL) {};
|
|
|
|
virtual void AddDirectory(const QString& path);
|
|
virtual void ChangeDirPath(int id, const QString& old_path, const QString& new_path);
|
|
virtual bool ExecQuery(LibraryQuery* q);
|
|
virtual QList<Song > FindSongsInDirectory(int id);
|
|
virtual LibraryBackendInterface::Album GetAlbumArt(const QString& artist, const QString& album);
|
|
virtual QList<LibraryBackendInterface::Album > GetAlbumsByArtist(const QString& artist, const QueryOptions& opt = QueryOptions());
|
|
virtual QList<LibraryBackendInterface::Album > GetAllAlbums(const QueryOptions& opt = QueryOptions());
|
|
virtual QStringList GetAllArtists(const QueryOptions& opt = QueryOptions());
|
|
virtual QStringList GetAllArtistsWithAlbums(const QueryOptions& opt = QueryOptions());
|
|
virtual QList<Directory > GetAllDirectories();
|
|
virtual QList<LibraryBackendInterface::Album > GetCompilationAlbums(const QueryOptions& opt = QueryOptions());
|
|
virtual QList<Song > GetCompilationSongs(const QString& album, const QueryOptions& opt = QueryOptions());
|
|
virtual Song GetSongById(int id);
|
|
virtual Song GetSongByUrl(const QUrl& url, qint64 beginning = 0);
|
|
virtual QList<Song > GetSongs(const QString& artist, const QString& album, const QueryOptions& opt = QueryOptions());
|
|
virtual QList<Song > GetSongsByUrl(const QUrl& url);
|
|
virtual bool HasCompilations(const QueryOptions& opt = QueryOptions());
|
|
virtual void LoadDirectoriesAsync();
|
|
virtual void RemoveDirectory(const Directory& dir);
|
|
virtual QList<Subdirectory > SubdirsInDirectory(int id);
|
|
virtual void UpdateManualAlbumArtAsync(const QString& artist, const QString& album, const QString& art);
|
|
virtual void UpdateTotalSongCountAsync();
|
|
virtual void childEvent(QChildEvent* arg__1);
|
|
virtual void customEvent(QEvent* arg__1);
|
|
virtual bool event(QEvent* arg__1);
|
|
virtual bool eventFilter(QObject* arg__1, QEvent* arg__2);
|
|
virtual void timerEvent(QTimerEvent* arg__1);
|
|
|
|
PythonQtInstanceWrapper* _wrapper;
|
|
};
|
|
|
|
class PythonQtWrapper_LibraryBackendInterface : public QObject
|
|
{ Q_OBJECT
|
|
public:
|
|
public slots:
|
|
LibraryBackendInterface* new_LibraryBackendInterface(QObject* parent = 0);
|
|
void delete_LibraryBackendInterface(LibraryBackendInterface* obj) { delete obj; }
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
class PythonQtShell_LibraryBackendInterface_Album : public LibraryBackendInterface::Album
|
|
{
|
|
public:
|
|
PythonQtShell_LibraryBackendInterface_Album():LibraryBackendInterface::Album(),_wrapper(NULL) {};
|
|
PythonQtShell_LibraryBackendInterface_Album(const QString& _artist, const QString& _album_name, const QString& _art_automatic, const QString& _art_manual, const QUrl& _first_url):LibraryBackendInterface::Album(_artist, _album_name, _art_automatic, _art_manual, _first_url),_wrapper(NULL) {};
|
|
|
|
|
|
PythonQtInstanceWrapper* _wrapper;
|
|
};
|
|
|
|
class PythonQtWrapper_LibraryBackendInterface_Album : public QObject
|
|
{ Q_OBJECT
|
|
public:
|
|
public slots:
|
|
LibraryBackendInterface::Album* new_LibraryBackendInterface_Album();
|
|
LibraryBackendInterface::Album* new_LibraryBackendInterface_Album(const QString& _artist, const QString& _album_name, const QString& _art_automatic, const QString& _art_manual, const QUrl& _first_url);
|
|
LibraryBackendInterface::Album* new_LibraryBackendInterface_Album(const LibraryBackendInterface::Album& other) {
|
|
PythonQtShell_LibraryBackendInterface_Album* a = new PythonQtShell_LibraryBackendInterface_Album();
|
|
*((LibraryBackendInterface::Album*)a) = other;
|
|
return a; }
|
|
void delete_LibraryBackendInterface_Album(LibraryBackendInterface::Album* obj) { delete obj; }
|
|
void py_set_art_automatic(LibraryBackendInterface::Album* theWrappedObject, QString art_automatic){ theWrappedObject->art_automatic = art_automatic; }
|
|
QString py_get_art_automatic(LibraryBackendInterface::Album* theWrappedObject){ return theWrappedObject->art_automatic; }
|
|
void py_set_artist(LibraryBackendInterface::Album* theWrappedObject, QString artist){ theWrappedObject->artist = artist; }
|
|
QString py_get_artist(LibraryBackendInterface::Album* theWrappedObject){ return theWrappedObject->artist; }
|
|
void py_set_album_name(LibraryBackendInterface::Album* theWrappedObject, QString album_name){ theWrappedObject->album_name = album_name; }
|
|
QString py_get_album_name(LibraryBackendInterface::Album* theWrappedObject){ return theWrappedObject->album_name; }
|
|
void py_set_first_url(LibraryBackendInterface::Album* theWrappedObject, QUrl first_url){ theWrappedObject->first_url = first_url; }
|
|
QUrl py_get_first_url(LibraryBackendInterface::Album* theWrappedObject){ return theWrappedObject->first_url; }
|
|
void py_set_art_manual(LibraryBackendInterface::Album* theWrappedObject, QString art_manual){ theWrappedObject->art_manual = art_manual; }
|
|
QString py_get_art_manual(LibraryBackendInterface::Album* theWrappedObject){ return theWrappedObject->art_manual; }
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
class PythonQtWrapper_LibraryQuery : public QObject
|
|
{ Q_OBJECT
|
|
public:
|
|
public slots:
|
|
LibraryQuery* new_LibraryQuery(const QueryOptions& options = QueryOptions());
|
|
void delete_LibraryQuery(LibraryQuery* obj) { delete obj; }
|
|
void AddCompilationRequirement(LibraryQuery* theWrappedObject, bool compilation);
|
|
void AddWhere(LibraryQuery* theWrappedObject, const QString& column, const QVariant& value, const QString& op = "=");
|
|
bool Next(LibraryQuery* theWrappedObject);
|
|
void SetColumnSpec(LibraryQuery* theWrappedObject, const QString& spec);
|
|
void SetIncludeUnavailable(LibraryQuery* theWrappedObject, bool include_unavailable);
|
|
void SetLimit(LibraryQuery* theWrappedObject, int limit);
|
|
void SetOrderBy(LibraryQuery* theWrappedObject, const QString& order_by);
|
|
QVariant Value(LibraryQuery* theWrappedObject, int column) const;
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
class PythonQtShell_NetworkAccessManager : public NetworkAccessManager
|
|
{
|
|
public:
|
|
PythonQtShell_NetworkAccessManager(QObject* parent = 0):NetworkAccessManager(parent),_wrapper(NULL) {};
|
|
|
|
virtual void childEvent(QChildEvent* arg__1);
|
|
virtual QNetworkReply* createRequest(QNetworkAccessManager::Operation op, const QNetworkRequest& request, QIODevice* outgoingData);
|
|
virtual void customEvent(QEvent* arg__1);
|
|
virtual bool event(QEvent* arg__1);
|
|
virtual bool eventFilter(QObject* arg__1, QEvent* arg__2);
|
|
virtual void timerEvent(QTimerEvent* arg__1);
|
|
|
|
PythonQtInstanceWrapper* _wrapper;
|
|
};
|
|
|
|
class PythonQtPublicPromoter_NetworkAccessManager : public NetworkAccessManager
|
|
{ public:
|
|
inline QNetworkReply* promoted_createRequest(QNetworkAccessManager::Operation op, const QNetworkRequest& request, QIODevice* outgoingData) { return NetworkAccessManager::createRequest(op, request, outgoingData); }
|
|
};
|
|
|
|
class PythonQtWrapper_NetworkAccessManager : public QObject
|
|
{ Q_OBJECT
|
|
public:
|
|
public slots:
|
|
NetworkAccessManager* new_NetworkAccessManager(QObject* parent = 0);
|
|
void delete_NetworkAccessManager(NetworkAccessManager* obj) { delete obj; }
|
|
QNetworkReply* createRequest(NetworkAccessManager* theWrappedObject, QNetworkAccessManager::Operation op, const QNetworkRequest& request, QIODevice* outgoingData);
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
class PythonQtShell_NetworkTimeouts : public NetworkTimeouts
|
|
{
|
|
public:
|
|
PythonQtShell_NetworkTimeouts(int timeout_msec, QObject* parent = 0):NetworkTimeouts(timeout_msec, parent),_wrapper(NULL) {};
|
|
|
|
virtual void childEvent(QChildEvent* arg__1);
|
|
virtual void customEvent(QEvent* arg__1);
|
|
virtual bool event(QEvent* arg__1);
|
|
virtual bool eventFilter(QObject* arg__1, QEvent* arg__2);
|
|
virtual void timerEvent(QTimerEvent* arg__1);
|
|
|
|
PythonQtInstanceWrapper* _wrapper;
|
|
};
|
|
|
|
class PythonQtWrapper_NetworkTimeouts : public QObject
|
|
{ Q_OBJECT
|
|
public:
|
|
public slots:
|
|
NetworkTimeouts* new_NetworkTimeouts(int timeout_msec, QObject* parent = 0);
|
|
void delete_NetworkTimeouts(NetworkTimeouts* obj) { delete obj; }
|
|
void AddReply(NetworkTimeouts* theWrappedObject, QNetworkReply* reply);
|
|
void SetTimeout(NetworkTimeouts* theWrappedObject, int msec);
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
class PythonQtShell_Player : public Player
|
|
{
|
|
public:
|
|
PythonQtShell_Player(PlaylistManagerInterface* playlists, QObject* parent = 0):Player(playlists, parent),_wrapper(NULL) {};
|
|
|
|
virtual void CurrentMetadataChanged(const Song& metadata);
|
|
virtual PlaylistItemPtr GetCurrentItem() const;
|
|
virtual PlaylistItemPtr GetItemAt(int pos) const;
|
|
virtual Engine::State GetState() const;
|
|
virtual int GetVolume() const;
|
|
virtual void Mute();
|
|
virtual void Next();
|
|
virtual void Pause();
|
|
virtual void Play();
|
|
virtual void PlayAt(int i, Engine::TrackChangeFlags change, bool reshuffle);
|
|
virtual void PlayPause();
|
|
virtual void Previous();
|
|
virtual void RegisterUrlHandler(UrlHandler* handler);
|
|
virtual void ReloadSettings();
|
|
virtual void SeekBackward();
|
|
virtual void SeekForward();
|
|
virtual void SeekTo(int seconds);
|
|
virtual void SetVolume(int value);
|
|
virtual void ShowOSD();
|
|
virtual void Stop();
|
|
virtual void UnregisterUrlHandler(UrlHandler* handler);
|
|
virtual void VolumeDown();
|
|
virtual void VolumeUp();
|
|
virtual void childEvent(QChildEvent* arg__1);
|
|
virtual void customEvent(QEvent* arg__1);
|
|
virtual Engine::Base* engine() const;
|
|
virtual bool event(QEvent* arg__1);
|
|
virtual bool eventFilter(QObject* arg__1, QEvent* arg__2);
|
|
virtual PlaylistManagerInterface* playlists() const;
|
|
virtual void timerEvent(QTimerEvent* arg__1);
|
|
|
|
PythonQtInstanceWrapper* _wrapper;
|
|
};
|
|
|
|
class PythonQtPublicPromoter_Player : public Player
|
|
{ public:
|
|
inline void promoted_CurrentMetadataChanged(const Song& metadata) { Player::CurrentMetadataChanged(metadata); }
|
|
inline PlaylistItemPtr promoted_GetCurrentItem() const { return Player::GetCurrentItem(); }
|
|
inline PlaylistItemPtr promoted_GetItemAt(int pos) const { return Player::GetItemAt(pos); }
|
|
inline Engine::State promoted_GetState() const { return Player::GetState(); }
|
|
inline int promoted_GetVolume() const { return Player::GetVolume(); }
|
|
inline void promoted_Mute() { Player::Mute(); }
|
|
inline void promoted_Next() { Player::Next(); }
|
|
inline void promoted_Pause() { Player::Pause(); }
|
|
inline void promoted_Play() { Player::Play(); }
|
|
inline void promoted_PlayAt(int i, Engine::TrackChangeFlags change, bool reshuffle) { Player::PlayAt(i, change, reshuffle); }
|
|
inline void promoted_PlayPause() { Player::PlayPause(); }
|
|
inline void promoted_Previous() { Player::Previous(); }
|
|
inline void promoted_RegisterUrlHandler(UrlHandler* handler) { Player::RegisterUrlHandler(handler); }
|
|
inline void promoted_ReloadSettings() { Player::ReloadSettings(); }
|
|
inline void promoted_SeekBackward() { Player::SeekBackward(); }
|
|
inline void promoted_SeekForward() { Player::SeekForward(); }
|
|
inline void promoted_SeekTo(int seconds) { Player::SeekTo(seconds); }
|
|
inline void promoted_SetVolume(int value) { Player::SetVolume(value); }
|
|
inline void promoted_ShowOSD() { Player::ShowOSD(); }
|
|
inline void promoted_Stop() { Player::Stop(); }
|
|
inline void promoted_UnregisterUrlHandler(UrlHandler* handler) { Player::UnregisterUrlHandler(handler); }
|
|
inline void promoted_VolumeDown() { Player::VolumeDown(); }
|
|
inline void promoted_VolumeUp() { Player::VolumeUp(); }
|
|
inline Engine::Base* promoted_engine() const { return Player::engine(); }
|
|
inline PlaylistManagerInterface* promoted_playlists() const { return Player::playlists(); }
|
|
};
|
|
|
|
class PythonQtWrapper_Player : public QObject
|
|
{ Q_OBJECT
|
|
public:
|
|
public slots:
|
|
Player* new_Player(PlaylistManagerInterface* playlists, QObject* parent = 0);
|
|
void delete_Player(Player* obj) { delete obj; }
|
|
PlaylistItemPtr GetCurrentItem(Player* theWrappedObject) const;
|
|
PlaylistItemPtr GetItemAt(Player* theWrappedObject, int pos) const;
|
|
Engine::State GetState(Player* theWrappedObject) const;
|
|
int GetVolume(Player* theWrappedObject) const;
|
|
void Init(Player* theWrappedObject);
|
|
void RegisterUrlHandler(Player* theWrappedObject, UrlHandler* handler);
|
|
void UnregisterUrlHandler(Player* theWrappedObject, UrlHandler* handler);
|
|
Engine::Base* engine(Player* theWrappedObject) const;
|
|
PlaylistManagerInterface* playlists(Player* theWrappedObject) const;
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
class PythonQtShell_PlayerInterface : public PlayerInterface
|
|
{
|
|
public:
|
|
PythonQtShell_PlayerInterface(QObject* parent = 0):PlayerInterface(parent),_wrapper(NULL) {};
|
|
|
|
virtual void CurrentMetadataChanged(const Song& metadata);
|
|
virtual PlaylistItemPtr GetCurrentItem() const;
|
|
virtual PlaylistItemPtr GetItemAt(int pos) const;
|
|
virtual Engine::State GetState() const;
|
|
virtual int GetVolume() const;
|
|
virtual void Mute();
|
|
virtual void Next();
|
|
virtual void Pause();
|
|
virtual void Play();
|
|
virtual void PlayAt(int i, Engine::TrackChangeFlags change, bool reshuffle);
|
|
virtual void PlayPause();
|
|
virtual void Previous();
|
|
virtual void RegisterUrlHandler(UrlHandler* handler);
|
|
virtual void ReloadSettings();
|
|
virtual void SeekBackward();
|
|
virtual void SeekForward();
|
|
virtual void SeekTo(int seconds);
|
|
virtual void SetVolume(int value);
|
|
virtual void ShowOSD();
|
|
virtual void Stop();
|
|
virtual void UnregisterUrlHandler(UrlHandler* handler);
|
|
virtual void VolumeDown();
|
|
virtual void VolumeUp();
|
|
virtual void childEvent(QChildEvent* arg__1);
|
|
virtual void customEvent(QEvent* arg__1);
|
|
virtual Engine::Base* engine() const;
|
|
virtual bool event(QEvent* arg__1);
|
|
virtual bool eventFilter(QObject* arg__1, QEvent* arg__2);
|
|
virtual PlaylistManagerInterface* playlists() const;
|
|
virtual void timerEvent(QTimerEvent* arg__1);
|
|
|
|
PythonQtInstanceWrapper* _wrapper;
|
|
};
|
|
|
|
class PythonQtWrapper_PlayerInterface : public QObject
|
|
{ Q_OBJECT
|
|
public:
|
|
public slots:
|
|
PlayerInterface* new_PlayerInterface(QObject* parent = 0);
|
|
void delete_PlayerInterface(PlayerInterface* obj) { delete obj; }
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
class PythonQtShell_Playlist : public Playlist
|
|
{
|
|
public:
|
|
PythonQtShell_Playlist(PlaylistBackend* backend, TaskManager* task_manager, LibraryBackend* library, int id, const QString& special_type = QString(), QObject* parent = 0):Playlist(backend, task_manager, library, id, special_type, parent),_wrapper(NULL) {};
|
|
|
|
virtual QModelIndex buddy(const QModelIndex& index) const;
|
|
virtual bool canFetchMore(const QModelIndex& parent) const;
|
|
virtual void childEvent(QChildEvent* arg__1);
|
|
virtual int columnCount(const QModelIndex& arg__1 = QModelIndex()) const;
|
|
virtual void customEvent(QEvent* arg__1);
|
|
virtual QVariant data(const QModelIndex& index, int role = Qt::DisplayRole) const;
|
|
virtual bool dropMimeData(const QMimeData* data, Qt::DropAction action, int row, int column, const QModelIndex& parent);
|
|
virtual bool event(QEvent* arg__1);
|
|
virtual bool eventFilter(QObject* arg__1, QEvent* arg__2);
|
|
virtual void fetchMore(const QModelIndex& parent);
|
|
virtual Qt::ItemFlags flags(const QModelIndex& index) const;
|
|
virtual QVariant headerData(int section, Qt::Orientation orientation, int role = Qt::DisplayRole) const;
|
|
virtual QModelIndex index(int row, int column, const QModelIndex& parent) const;
|
|
virtual bool insertColumns(int column, int count, const QModelIndex& parent);
|
|
virtual bool insertRows(int row, int count, const QModelIndex& parent);
|
|
virtual QMap<int , QVariant > itemData(const QModelIndex& index) const;
|
|
virtual QList<QModelIndex > match(const QModelIndex& start, int role, const QVariant& value, int hits, Qt::MatchFlags flags) const;
|
|
virtual QMimeData* mimeData(const QList<QModelIndex >& indexes) const;
|
|
virtual QStringList mimeTypes() const;
|
|
virtual bool removeColumns(int column, int count, const QModelIndex& parent);
|
|
virtual bool removeRows(int row, int count, const QModelIndex& parent = QModelIndex());
|
|
virtual void revert();
|
|
virtual int rowCount(const QModelIndex& arg__1 = QModelIndex()) const;
|
|
virtual bool setData(const QModelIndex& index, const QVariant& value, int role);
|
|
virtual bool setHeaderData(int section, Qt::Orientation orientation, const QVariant& value, int role);
|
|
virtual bool setItemData(const QModelIndex& index, const QMap<int , QVariant >& roles);
|
|
virtual void sort(int column, Qt::SortOrder order);
|
|
virtual QSize span(const QModelIndex& index) const;
|
|
virtual bool submit();
|
|
virtual Qt::DropActions supportedDropActions() const;
|
|
virtual void timerEvent(QTimerEvent* arg__1);
|
|
|
|
PythonQtInstanceWrapper* _wrapper;
|
|
};
|
|
|
|
class PythonQtPublicPromoter_Playlist : public Playlist
|
|
{ public:
|
|
inline int promoted_columnCount(const QModelIndex& arg__1 = QModelIndex()) const { return Playlist::columnCount(arg__1); }
|
|
inline QVariant promoted_data(const QModelIndex& index, int role = Qt::DisplayRole) const { return Playlist::data(index, role); }
|
|
inline bool promoted_dropMimeData(const QMimeData* data, Qt::DropAction action, int row, int column, const QModelIndex& parent) { return Playlist::dropMimeData(data, action, row, column, parent); }
|
|
inline Qt::ItemFlags promoted_flags(const QModelIndex& index) const { return Playlist::flags(index); }
|
|
inline QVariant promoted_headerData(int section, Qt::Orientation orientation, int role = Qt::DisplayRole) const { return Playlist::headerData(section, orientation, role); }
|
|
inline QMimeData* promoted_mimeData(const QList<QModelIndex >& indexes) const { return Playlist::mimeData(indexes); }
|
|
inline QStringList promoted_mimeTypes() const { return Playlist::mimeTypes(); }
|
|
inline bool promoted_removeRows(int row, int count, const QModelIndex& parent = QModelIndex()) { return Playlist::removeRows(row, count, parent); }
|
|
inline int promoted_rowCount(const QModelIndex& arg__1 = QModelIndex()) const { return Playlist::rowCount(arg__1); }
|
|
inline bool promoted_setData(const QModelIndex& index, const QVariant& value, int role) { return Playlist::setData(index, value, role); }
|
|
inline void promoted_sort(int column, Qt::SortOrder order) { Playlist::sort(column, order); }
|
|
inline Qt::DropActions promoted_supportedDropActions() const { return Playlist::supportedDropActions(); }
|
|
};
|
|
|
|
class PythonQtWrapper_Playlist : public QObject
|
|
{ Q_OBJECT
|
|
public:
|
|
Q_ENUMS(Column Role LastFMStatus )
|
|
enum Column{
|
|
Column_Title = Playlist::Column_Title, Column_Artist = Playlist::Column_Artist, Column_Album = Playlist::Column_Album, Column_AlbumArtist = Playlist::Column_AlbumArtist, Column_Composer = Playlist::Column_Composer, Column_Length = Playlist::Column_Length, Column_Track = Playlist::Column_Track, Column_Disc = Playlist::Column_Disc, Column_Year = Playlist::Column_Year, Column_Genre = Playlist::Column_Genre, Column_BPM = Playlist::Column_BPM, Column_Bitrate = Playlist::Column_Bitrate, Column_Samplerate = Playlist::Column_Samplerate, Column_Filename = Playlist::Column_Filename, Column_BaseFilename = Playlist::Column_BaseFilename, Column_Filesize = Playlist::Column_Filesize, Column_Filetype = Playlist::Column_Filetype, Column_DateCreated = Playlist::Column_DateCreated, Column_DateModified = Playlist::Column_DateModified, Column_Rating = Playlist::Column_Rating, Column_PlayCount = Playlist::Column_PlayCount, Column_SkipCount = Playlist::Column_SkipCount, Column_LastPlayed = Playlist::Column_LastPlayed, Column_Score = Playlist::Column_Score, Column_Comment = Playlist::Column_Comment, ColumnCount = Playlist::ColumnCount};
|
|
enum Role{
|
|
Role_IsCurrent = Playlist::Role_IsCurrent, Role_IsPaused = Playlist::Role_IsPaused, Role_StopAfter = Playlist::Role_StopAfter, Role_QueuePosition = Playlist::Role_QueuePosition, Role_CanSetRating = Playlist::Role_CanSetRating};
|
|
enum LastFMStatus{
|
|
LastFM_New = Playlist::LastFM_New, LastFM_Scrobbled = Playlist::LastFM_Scrobbled, LastFM_Seeked = Playlist::LastFM_Seeked, LastFM_Error = Playlist::LastFM_Error, LastFM_Invalid = Playlist::LastFM_Invalid, LastFM_Queued = Playlist::LastFM_Queued};
|
|
public slots:
|
|
Playlist* new_Playlist(PlaylistBackend* backend, TaskManager* task_manager, LibraryBackend* library, int id, const QString& special_type = QString(), QObject* parent = 0);
|
|
void delete_Playlist(Playlist* obj) { delete obj; }
|
|
void AddSongInsertVetoListener(Playlist* theWrappedObject, SongInsertVetoListener* listener);
|
|
bool ApplyValidityOnCurrentSong(Playlist* theWrappedObject, const QUrl& url, bool valid);
|
|
bool static_Playlist_CompareItems(int column, Qt::SortOrder order, PlaylistItemPtr a, PlaylistItemPtr b);
|
|
QList<PlaylistItemPtr > GetAllItems(Playlist* theWrappedObject) const;
|
|
QList<Song > GetAllSongs(Playlist* theWrappedObject) const;
|
|
quint64 GetTotalLength(Playlist* theWrappedObject) const;
|
|
void InsertItems(Playlist* theWrappedObject, const QList<PlaylistItemPtr >& items, int pos = -1, bool play_now = false, bool enqueue = false);
|
|
void InsertLibraryItems(Playlist* theWrappedObject, const QList<Song >& items, int pos = -1, bool play_now = false, bool enqueue = false);
|
|
void InsertSmartPlaylist(Playlist* theWrappedObject, smart_playlists::GeneratorPtr gen, int pos = -1, bool play_now = false, bool enqueue = false);
|
|
void InsertSongs(Playlist* theWrappedObject, const QList<Song >& items, int pos = -1, bool play_now = false, bool enqueue = false);
|
|
void InsertSongsOrLibraryItems(Playlist* theWrappedObject, const QList<Song >& items, int pos = -1, bool play_now = false, bool enqueue = false);
|
|
void InsertUrls(Playlist* theWrappedObject, const QList<QUrl >& urls, int pos = -1, bool play_now = false, bool enqueue = false);
|
|
void InvalidateDeletedSongs(Playlist* theWrappedObject);
|
|
void RateSong(Playlist* theWrappedObject, const QModelIndex& index, double rating);
|
|
void ReloadItems(Playlist* theWrappedObject, const QList<int >& rows);
|
|
void RemoveDeletedSongs(Playlist* theWrappedObject);
|
|
void RemoveItemsWithoutUndo(Playlist* theWrappedObject, const QList<int >& indices);
|
|
void RemoveSongInsertVetoListener(Playlist* theWrappedObject, SongInsertVetoListener* listener);
|
|
void Restore(Playlist* theWrappedObject);
|
|
void Save(Playlist* theWrappedObject) const;
|
|
void StopAfter(Playlist* theWrappedObject, int row);
|
|
void UpdateItems(Playlist* theWrappedObject, const QList<Song >& songs);
|
|
int columnCount(Playlist* theWrappedObject, const QModelIndex& arg__1 = QModelIndex()) const;
|
|
QMap<int , Qt::Alignment > column_alignments(Playlist* theWrappedObject) const;
|
|
bool static_Playlist_column_is_editable(Playlist::Column column);
|
|
QString static_Playlist_column_name(Playlist::Column column);
|
|
const QModelIndex current_index(Playlist* theWrappedObject) const;
|
|
PlaylistItemPtr current_item(Playlist* theWrappedObject) const;
|
|
Song current_item_metadata(Playlist* theWrappedObject) const;
|
|
int current_row(Playlist* theWrappedObject) const;
|
|
QVariant data(Playlist* theWrappedObject, const QModelIndex& index, int role = Qt::DisplayRole) const;
|
|
bool dropMimeData(Playlist* theWrappedObject, const QMimeData* data, Qt::DropAction action, int row, int column, const QModelIndex& parent);
|
|
Qt::ItemFlags flags(Playlist* theWrappedObject, const QModelIndex& index) const;
|
|
Playlist::LastFMStatus get_lastfm_status(Playlist* theWrappedObject) const;
|
|
const bool has_item_at(Playlist* theWrappedObject, int index) const;
|
|
bool have_incremented_playcount(Playlist* theWrappedObject) const;
|
|
QVariant headerData(Playlist* theWrappedObject, int section, Qt::Orientation orientation, int role = Qt::DisplayRole) const;
|
|
int id(Playlist* theWrappedObject) const;
|
|
bool is_dynamic(Playlist* theWrappedObject) const;
|
|
const PlaylistItemPtr* item_at(Playlist* theWrappedObject, int index) const;
|
|
int last_played_row(Playlist* theWrappedObject) const;
|
|
QList<PlaylistItemPtr > library_items_by_id(Playlist* theWrappedObject, int id) const;
|
|
QMimeData* mimeData(Playlist* theWrappedObject, const QList<QModelIndex >& indexes) const;
|
|
QStringList mimeTypes(Playlist* theWrappedObject) const;
|
|
int next_row(Playlist* theWrappedObject) const;
|
|
int previous_row(Playlist* theWrappedObject) const;
|
|
QSortFilterProxyModel* proxy(Playlist* theWrappedObject) const;
|
|
bool removeRows(Playlist* theWrappedObject, int row, int count, const QModelIndex& parent = QModelIndex());
|
|
int rowCount(Playlist* theWrappedObject, const QModelIndex& arg__1 = QModelIndex()) const;
|
|
qint64 scrobble_point_nanosec(Playlist* theWrappedObject) const;
|
|
PlaylistSequence* sequence(Playlist* theWrappedObject) const;
|
|
bool setData(Playlist* theWrappedObject, const QModelIndex& index, const QVariant& value, int role);
|
|
void set_column_align_center(Playlist* theWrappedObject, int column);
|
|
void set_column_align_left(Playlist* theWrappedObject, int column);
|
|
void set_column_align_right(Playlist* theWrappedObject, int column);
|
|
void set_column_alignments(Playlist* theWrappedObject, const QMap<int , Qt::Alignment >& column_alignments);
|
|
bool static_Playlist_set_column_value(Song& song, Playlist::Column column, const QVariant& value);
|
|
void set_have_incremented_playcount(Playlist* theWrappedObject);
|
|
void set_lastfm_status(Playlist* theWrappedObject, Playlist::LastFMStatus status);
|
|
void set_sequence(Playlist* theWrappedObject, PlaylistSequence* v);
|
|
void set_special_type(Playlist* theWrappedObject, const QString& v);
|
|
void sort(Playlist* theWrappedObject, int column, Qt::SortOrder order);
|
|
QString special_type(Playlist* theWrappedObject) const;
|
|
bool stop_after_current(Playlist* theWrappedObject) const;
|
|
Qt::DropActions supportedDropActions(Playlist* theWrappedObject) const;
|
|
QUndoStack* undo_stack(Playlist* theWrappedObject) const;
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
class PythonQtShell_PlaylistBackend : public PlaylistBackend
|
|
{
|
|
public:
|
|
PythonQtShell_PlaylistBackend(QObject* parent = 0):PlaylistBackend(parent),_wrapper(NULL) {};
|
|
|
|
virtual void childEvent(QChildEvent* arg__1);
|
|
virtual void customEvent(QEvent* arg__1);
|
|
virtual bool event(QEvent* arg__1);
|
|
virtual bool eventFilter(QObject* arg__1, QEvent* arg__2);
|
|
virtual void timerEvent(QTimerEvent* arg__1);
|
|
|
|
PythonQtInstanceWrapper* _wrapper;
|
|
};
|
|
|
|
class PythonQtWrapper_PlaylistBackend : public QObject
|
|
{ Q_OBJECT
|
|
public:
|
|
public slots:
|
|
PlaylistBackend* new_PlaylistBackend(QObject* parent = 0);
|
|
void delete_PlaylistBackend(PlaylistBackend* obj) { delete obj; }
|
|
int CreatePlaylist(PlaylistBackend* theWrappedObject, const QString& name, const QString& special_type);
|
|
void RemovePlaylist(PlaylistBackend* theWrappedObject, int id);
|
|
void RenamePlaylist(PlaylistBackend* theWrappedObject, int id, const QString& new_name);
|
|
void SavePlaylistAsync(PlaylistBackend* theWrappedObject, int playlist, const QList<PlaylistItemPtr >& items, int last_played, smart_playlists::GeneratorPtr dynamic);
|
|
void SetLibrary(PlaylistBackend* theWrappedObject, LibraryBackend* library);
|
|
void SetPlaylistOrder(PlaylistBackend* theWrappedObject, const QList<int >& ids);
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
class PythonQtShell_PlaylistContainer : public PlaylistContainer
|
|
{
|
|
public:
|
|
PythonQtShell_PlaylistContainer(QWidget* parent = 0):PlaylistContainer(parent),_wrapper(NULL) {};
|
|
|
|
virtual void actionEvent(QActionEvent* arg__1);
|
|
virtual void changeEvent(QEvent* arg__1);
|
|
virtual void childEvent(QChildEvent* arg__1);
|
|
virtual void closeEvent(QCloseEvent* arg__1);
|
|
virtual void contextMenuEvent(QContextMenuEvent* arg__1);
|
|
virtual void customEvent(QEvent* arg__1);
|
|
virtual int devType() const;
|
|
virtual void dragEnterEvent(QDragEnterEvent* arg__1);
|
|
virtual void dragLeaveEvent(QDragLeaveEvent* arg__1);
|
|
virtual void dragMoveEvent(QDragMoveEvent* arg__1);
|
|
virtual void dropEvent(QDropEvent* arg__1);
|
|
virtual void enterEvent(QEvent* arg__1);
|
|
virtual bool event(QEvent* arg__1);
|
|
virtual bool eventFilter(QObject* arg__1, QEvent* arg__2);
|
|
virtual void focusInEvent(QFocusEvent* arg__1);
|
|
virtual bool focusNextPrevChild(bool next);
|
|
virtual void focusOutEvent(QFocusEvent* arg__1);
|
|
virtual int heightForWidth(int arg__1) const;
|
|
virtual void hideEvent(QHideEvent* arg__1);
|
|
virtual void inputMethodEvent(QInputMethodEvent* arg__1);
|
|
virtual QVariant inputMethodQuery(Qt::InputMethodQuery arg__1) const;
|
|
virtual void keyPressEvent(QKeyEvent* arg__1);
|
|
virtual void keyReleaseEvent(QKeyEvent* arg__1);
|
|
virtual void languageChange();
|
|
virtual void leaveEvent(QEvent* arg__1);
|
|
virtual int metric(QPaintDevice::PaintDeviceMetric arg__1) const;
|
|
virtual QSize minimumSizeHint() const;
|
|
virtual void mouseDoubleClickEvent(QMouseEvent* arg__1);
|
|
virtual void mouseMoveEvent(QMouseEvent* arg__1);
|
|
virtual void mousePressEvent(QMouseEvent* arg__1);
|
|
virtual void mouseReleaseEvent(QMouseEvent* arg__1);
|
|
virtual void moveEvent(QMoveEvent* arg__1);
|
|
virtual QPaintEngine* paintEngine() const;
|
|
virtual void paintEvent(QPaintEvent* arg__1);
|
|
virtual void resizeEvent(QResizeEvent* arg__1);
|
|
virtual void showEvent(QShowEvent* arg__1);
|
|
virtual QSize sizeHint() const;
|
|
virtual void tabletEvent(QTabletEvent* arg__1);
|
|
virtual void timerEvent(QTimerEvent* arg__1);
|
|
virtual void wheelEvent(QWheelEvent* arg__1);
|
|
|
|
PythonQtInstanceWrapper* _wrapper;
|
|
};
|
|
|
|
class PythonQtPublicPromoter_PlaylistContainer : public PlaylistContainer
|
|
{ public:
|
|
inline void promoted_resizeEvent(QResizeEvent* arg__1) { PlaylistContainer::resizeEvent(arg__1); }
|
|
};
|
|
|
|
class PythonQtWrapper_PlaylistContainer : public QObject
|
|
{ Q_OBJECT
|
|
public:
|
|
public slots:
|
|
PlaylistContainer* new_PlaylistContainer(QWidget* parent = 0);
|
|
void delete_PlaylistContainer(PlaylistContainer* obj) { delete obj; }
|
|
void SetActions(PlaylistContainer* theWrappedObject, QAction* new_playlist, QAction* save_playlist, QAction* load_playlist, QAction* next_playlist, QAction* previous_playlist);
|
|
void SetManager(PlaylistContainer* theWrappedObject, PlaylistManager* manager);
|
|
void resizeEvent(PlaylistContainer* theWrappedObject, QResizeEvent* arg__1);
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
class PythonQtShell_PlaylistItemPtr : public PlaylistItemPtr
|
|
{
|
|
public:
|
|
PythonQtShell_PlaylistItemPtr():PlaylistItemPtr(),_wrapper(NULL) {};
|
|
|
|
|
|
PythonQtInstanceWrapper* _wrapper;
|
|
};
|
|
|
|
class PythonQtWrapper_PlaylistItemPtr : public QObject
|
|
{ Q_OBJECT
|
|
public:
|
|
public slots:
|
|
PlaylistItemPtr* new_PlaylistItemPtr();
|
|
PlaylistItemPtr* new_PlaylistItemPtr(const PlaylistItemPtr& other) {
|
|
PythonQtShell_PlaylistItemPtr* a = new PythonQtShell_PlaylistItemPtr();
|
|
*((PlaylistItemPtr*)a) = other;
|
|
return a; }
|
|
void delete_PlaylistItemPtr(PlaylistItemPtr* obj) { delete obj; }
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
class PythonQtShell_PlaylistManager : public PlaylistManager
|
|
{
|
|
public:
|
|
PythonQtShell_PlaylistManager(TaskManager* task_manager, QObject* parent = 0):PlaylistManager(task_manager, parent),_wrapper(NULL) {};
|
|
|
|
virtual void ChangePlaylistOrder(const QList<int >& ids);
|
|
virtual void ClearCurrent();
|
|
virtual QList<Playlist* > GetAllPlaylists() const;
|
|
virtual SpecialPlaylistType* GetPlaylistType(const QString& type) const;
|
|
virtual void InvalidateDeletedSongs();
|
|
virtual void Load(const QString& filename);
|
|
virtual void New(const QString& name, const QList<Song >& songs = SongList(), const QString& special_type = QString());
|
|
virtual void PlaySmartPlaylist(smart_playlists::GeneratorPtr generator, bool as_new, bool clear);
|
|
virtual void RateCurrentSong(double rating);
|
|
virtual void RateCurrentSong(int rating);
|
|
virtual void RegisterSpecialPlaylistType(SpecialPlaylistType* type);
|
|
virtual void Remove(int id);
|
|
virtual void RemoveDeletedSongs();
|
|
virtual void Rename(int id, const QString& new_name);
|
|
virtual void Save(int id, const QString& filename);
|
|
virtual void SelectionChanged(const QItemSelection& selection);
|
|
virtual void SetActivePaused();
|
|
virtual void SetActivePlaying();
|
|
virtual void SetActivePlaylist(int id);
|
|
virtual void SetActiveStopped();
|
|
virtual void SetActiveStreamMetadata(const QUrl& url, const Song& song);
|
|
virtual void SetActiveToCurrent();
|
|
virtual void SetCurrentPlaylist(int id);
|
|
virtual void ShuffleCurrent();
|
|
virtual void SongChangeRequestProcessed(const QUrl& url, bool valid);
|
|
virtual void UnregisterSpecialPlaylistType(SpecialPlaylistType* type);
|
|
virtual Playlist* active() const;
|
|
virtual int active_id() const;
|
|
virtual QItemSelection active_selection() const;
|
|
virtual void childEvent(QChildEvent* arg__1);
|
|
virtual Playlist* current() const;
|
|
virtual int current_id() const;
|
|
virtual QItemSelection current_selection() const;
|
|
virtual void customEvent(QEvent* arg__1);
|
|
virtual bool event(QEvent* arg__1);
|
|
virtual bool eventFilter(QObject* arg__1, QEvent* arg__2);
|
|
virtual LibraryBackend* library_backend() const;
|
|
virtual QString name(int index) const;
|
|
virtual PlaylistParser* parser() const;
|
|
virtual Playlist* playlist(int id) const;
|
|
virtual PlaylistBackend* playlist_backend() const;
|
|
virtual PlaylistContainer* playlist_container() const;
|
|
virtual QItemSelection selection(int id) const;
|
|
virtual PlaylistSequence* sequence() const;
|
|
virtual TaskManager* task_manager() const;
|
|
virtual void timerEvent(QTimerEvent* arg__1);
|
|
|
|
PythonQtInstanceWrapper* _wrapper;
|
|
};
|
|
|
|
class PythonQtPublicPromoter_PlaylistManager : public PlaylistManager
|
|
{ public:
|
|
inline void promoted_ChangePlaylistOrder(const QList<int >& ids) { PlaylistManager::ChangePlaylistOrder(ids); }
|
|
inline void promoted_ClearCurrent() { PlaylistManager::ClearCurrent(); }
|
|
inline QList<Playlist* > promoted_GetAllPlaylists() const { return PlaylistManager::GetAllPlaylists(); }
|
|
inline SpecialPlaylistType* promoted_GetPlaylistType(const QString& type) const { return PlaylistManager::GetPlaylistType(type); }
|
|
inline void promoted_InvalidateDeletedSongs() { PlaylistManager::InvalidateDeletedSongs(); }
|
|
inline void promoted_Load(const QString& filename) { PlaylistManager::Load(filename); }
|
|
inline void promoted_New(const QString& name, const QList<Song >& songs = SongList(), const QString& special_type = QString()) { PlaylistManager::New(name, songs, special_type); }
|
|
inline void promoted_PlaySmartPlaylist(smart_playlists::GeneratorPtr generator, bool as_new, bool clear) { PlaylistManager::PlaySmartPlaylist(generator, as_new, clear); }
|
|
inline void promoted_RateCurrentSong(double rating) { PlaylistManager::RateCurrentSong(rating); }
|
|
inline void promoted_RateCurrentSong(int rating) { PlaylistManager::RateCurrentSong(rating); }
|
|
inline void promoted_RegisterSpecialPlaylistType(SpecialPlaylistType* type) { PlaylistManager::RegisterSpecialPlaylistType(type); }
|
|
inline void promoted_Remove(int id) { PlaylistManager::Remove(id); }
|
|
inline void promoted_RemoveDeletedSongs() { PlaylistManager::RemoveDeletedSongs(); }
|
|
inline void promoted_Rename(int id, const QString& new_name) { PlaylistManager::Rename(id, new_name); }
|
|
inline void promoted_Save(int id, const QString& filename) { PlaylistManager::Save(id, filename); }
|
|
inline void promoted_SelectionChanged(const QItemSelection& selection) { PlaylistManager::SelectionChanged(selection); }
|
|
inline void promoted_SetActivePaused() { PlaylistManager::SetActivePaused(); }
|
|
inline void promoted_SetActivePlaying() { PlaylistManager::SetActivePlaying(); }
|
|
inline void promoted_SetActivePlaylist(int id) { PlaylistManager::SetActivePlaylist(id); }
|
|
inline void promoted_SetActiveStopped() { PlaylistManager::SetActiveStopped(); }
|
|
inline void promoted_SetActiveStreamMetadata(const QUrl& url, const Song& song) { PlaylistManager::SetActiveStreamMetadata(url, song); }
|
|
inline void promoted_SetActiveToCurrent() { PlaylistManager::SetActiveToCurrent(); }
|
|
inline void promoted_SetCurrentPlaylist(int id) { PlaylistManager::SetCurrentPlaylist(id); }
|
|
inline void promoted_ShuffleCurrent() { PlaylistManager::ShuffleCurrent(); }
|
|
inline void promoted_SongChangeRequestProcessed(const QUrl& url, bool valid) { PlaylistManager::SongChangeRequestProcessed(url, valid); }
|
|
inline void promoted_UnregisterSpecialPlaylistType(SpecialPlaylistType* type) { PlaylistManager::UnregisterSpecialPlaylistType(type); }
|
|
inline Playlist* promoted_active() const { return PlaylistManager::active(); }
|
|
inline int promoted_active_id() const { return PlaylistManager::active_id(); }
|
|
inline QItemSelection promoted_active_selection() const { return PlaylistManager::active_selection(); }
|
|
inline Playlist* promoted_current() const { return PlaylistManager::current(); }
|
|
inline int promoted_current_id() const { return PlaylistManager::current_id(); }
|
|
inline QItemSelection promoted_current_selection() const { return PlaylistManager::current_selection(); }
|
|
inline LibraryBackend* promoted_library_backend() const { return PlaylistManager::library_backend(); }
|
|
inline QString promoted_name(int index) const { return PlaylistManager::name(index); }
|
|
inline PlaylistParser* promoted_parser() const { return PlaylistManager::parser(); }
|
|
inline Playlist* promoted_playlist(int id) const { return PlaylistManager::playlist(id); }
|
|
inline PlaylistBackend* promoted_playlist_backend() const { return PlaylistManager::playlist_backend(); }
|
|
inline PlaylistContainer* promoted_playlist_container() const { return PlaylistManager::playlist_container(); }
|
|
inline QItemSelection promoted_selection(int id) const { return PlaylistManager::selection(id); }
|
|
inline PlaylistSequence* promoted_sequence() const { return PlaylistManager::sequence(); }
|
|
inline TaskManager* promoted_task_manager() const { return PlaylistManager::task_manager(); }
|
|
};
|
|
|
|
class PythonQtWrapper_PlaylistManager : public QObject
|
|
{ Q_OBJECT
|
|
public:
|
|
public slots:
|
|
PlaylistManager* new_PlaylistManager(TaskManager* task_manager, QObject* parent = 0);
|
|
void delete_PlaylistManager(PlaylistManager* obj) { delete obj; }
|
|
QList<Playlist* > GetAllPlaylists(PlaylistManager* theWrappedObject) const;
|
|
QString static_PlaylistManager_GetNameForNewPlaylist(const QList<Song >& songs);
|
|
SpecialPlaylistType* GetPlaylistType(PlaylistManager* theWrappedObject, const QString& type) const;
|
|
void Init(PlaylistManager* theWrappedObject, LibraryBackend* library_backend, PlaylistBackend* playlist_backend, PlaylistSequence* sequence, PlaylistContainer* playlist_container);
|
|
void InvalidateDeletedSongs(PlaylistManager* theWrappedObject);
|
|
void RegisterSpecialPlaylistType(PlaylistManager* theWrappedObject, SpecialPlaylistType* type);
|
|
void RemoveDeletedSongs(PlaylistManager* theWrappedObject);
|
|
void UnregisterSpecialPlaylistType(PlaylistManager* theWrappedObject, SpecialPlaylistType* type);
|
|
Playlist* active(PlaylistManager* theWrappedObject) const;
|
|
int active_id(PlaylistManager* theWrappedObject) const;
|
|
QItemSelection active_selection(PlaylistManager* theWrappedObject) const;
|
|
Playlist* current(PlaylistManager* theWrappedObject) const;
|
|
int current_id(PlaylistManager* theWrappedObject) const;
|
|
QItemSelection current_selection(PlaylistManager* theWrappedObject) const;
|
|
LibraryBackend* library_backend(PlaylistManager* theWrappedObject) const;
|
|
QString name(PlaylistManager* theWrappedObject, int index) const;
|
|
PlaylistParser* parser(PlaylistManager* theWrappedObject) const;
|
|
Playlist* playlist(PlaylistManager* theWrappedObject, int id) const;
|
|
PlaylistBackend* playlist_backend(PlaylistManager* theWrappedObject) const;
|
|
PlaylistContainer* playlist_container(PlaylistManager* theWrappedObject) const;
|
|
QItemSelection selection(PlaylistManager* theWrappedObject, int id) const;
|
|
PlaylistSequence* sequence(PlaylistManager* theWrappedObject) const;
|
|
TaskManager* task_manager(PlaylistManager* theWrappedObject) const;
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
class PythonQtShell_PlaylistManagerInterface : public PlaylistManagerInterface
|
|
{
|
|
public:
|
|
PythonQtShell_PlaylistManagerInterface(QObject* parent):PlaylistManagerInterface(parent),_wrapper(NULL) {};
|
|
|
|
virtual void ChangePlaylistOrder(const QList<int >& ids);
|
|
virtual void ClearCurrent();
|
|
virtual QList<Playlist* > GetAllPlaylists() const;
|
|
virtual SpecialPlaylistType* GetPlaylistType(const QString& type) const;
|
|
virtual void InvalidateDeletedSongs();
|
|
virtual void Load(const QString& filename);
|
|
virtual void New(const QString& name, const QList<Song >& songs = SongList(), const QString& special_type = QString());
|
|
virtual void PlaySmartPlaylist(smart_playlists::GeneratorPtr generator, bool as_new, bool clear);
|
|
virtual void RateCurrentSong(double rating);
|
|
virtual void RateCurrentSong(int rating);
|
|
virtual void RegisterSpecialPlaylistType(SpecialPlaylistType* type);
|
|
virtual void Remove(int id);
|
|
virtual void RemoveDeletedSongs();
|
|
virtual void Rename(int id, const QString& new_name);
|
|
virtual void Save(int id, const QString& filename);
|
|
virtual void SelectionChanged(const QItemSelection& selection);
|
|
virtual void SetActivePaused();
|
|
virtual void SetActivePlaying();
|
|
virtual void SetActivePlaylist(int id);
|
|
virtual void SetActiveStopped();
|
|
virtual void SetActiveStreamMetadata(const QUrl& url, const Song& song);
|
|
virtual void SetActiveToCurrent();
|
|
virtual void SetCurrentPlaylist(int id);
|
|
virtual void ShuffleCurrent();
|
|
virtual void SongChangeRequestProcessed(const QUrl& url, bool valid);
|
|
virtual void UnregisterSpecialPlaylistType(SpecialPlaylistType* type);
|
|
virtual Playlist* active() const;
|
|
virtual int active_id() const;
|
|
virtual QItemSelection active_selection() const;
|
|
virtual void childEvent(QChildEvent* arg__1);
|
|
virtual Playlist* current() const;
|
|
virtual int current_id() const;
|
|
virtual QItemSelection current_selection() const;
|
|
virtual void customEvent(QEvent* arg__1);
|
|
virtual bool event(QEvent* arg__1);
|
|
virtual bool eventFilter(QObject* arg__1, QEvent* arg__2);
|
|
virtual LibraryBackend* library_backend() const;
|
|
virtual QString name(int index) const;
|
|
virtual PlaylistParser* parser() const;
|
|
virtual Playlist* playlist(int id) const;
|
|
virtual PlaylistBackend* playlist_backend() const;
|
|
virtual PlaylistContainer* playlist_container() const;
|
|
virtual QItemSelection selection(int id) const;
|
|
virtual PlaylistSequence* sequence() const;
|
|
virtual TaskManager* task_manager() const;
|
|
virtual void timerEvent(QTimerEvent* arg__1);
|
|
|
|
PythonQtInstanceWrapper* _wrapper;
|
|
};
|
|
|
|
class PythonQtWrapper_PlaylistManagerInterface : public QObject
|
|
{ Q_OBJECT
|
|
public:
|
|
public slots:
|
|
PlaylistManagerInterface* new_PlaylistManagerInterface(QObject* parent);
|
|
void delete_PlaylistManagerInterface(PlaylistManagerInterface* obj) { delete obj; }
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
class PythonQtShell_PlaylistParser : public PlaylistParser
|
|
{
|
|
public:
|
|
PythonQtShell_PlaylistParser(LibraryBackendInterface* library, QObject* parent = 0):PlaylistParser(library, parent),_wrapper(NULL) {};
|
|
|
|
virtual void childEvent(QChildEvent* arg__1);
|
|
virtual void customEvent(QEvent* arg__1);
|
|
virtual bool event(QEvent* arg__1);
|
|
virtual bool eventFilter(QObject* arg__1, QEvent* arg__2);
|
|
virtual void timerEvent(QTimerEvent* arg__1);
|
|
|
|
PythonQtInstanceWrapper* _wrapper;
|
|
};
|
|
|
|
class PythonQtWrapper_PlaylistParser : public QObject
|
|
{ Q_OBJECT
|
|
public:
|
|
public slots:
|
|
PlaylistParser* new_PlaylistParser(LibraryBackendInterface* library, QObject* parent = 0);
|
|
void delete_PlaylistParser(PlaylistParser* obj) { delete obj; }
|
|
QList<Song > LoadFromDevice(PlaylistParser* theWrappedObject, QIODevice* device, const QString& path_hint = QString(), const QDir& dir_hint = QDir()) const;
|
|
QList<Song > LoadFromFile(PlaylistParser* theWrappedObject, const QString& filename) const;
|
|
void Save(PlaylistParser* theWrappedObject, const QList<Song >& songs, const QString& filename) const;
|
|
QString default_extension(PlaylistParser* theWrappedObject) const;
|
|
QString default_filter(PlaylistParser* theWrappedObject) const;
|
|
QStringList file_extensions(PlaylistParser* theWrappedObject) const;
|
|
QString filters(PlaylistParser* theWrappedObject) const;
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
class PythonQtWrapper_PlaylistSequence : public QObject
|
|
{ Q_OBJECT
|
|
public:
|
|
Q_ENUMS(ShuffleMode RepeatMode )
|
|
enum ShuffleMode{
|
|
Shuffle_Off = PlaylistSequence::Shuffle_Off, Shuffle_All = PlaylistSequence::Shuffle_All, Shuffle_Album = PlaylistSequence::Shuffle_Album};
|
|
enum RepeatMode{
|
|
Repeat_Off = PlaylistSequence::Repeat_Off, Repeat_Track = PlaylistSequence::Repeat_Track, Repeat_Album = PlaylistSequence::Repeat_Album, Repeat_Playlist = PlaylistSequence::Repeat_Playlist};
|
|
public slots:
|
|
void delete_PlaylistSequence(PlaylistSequence* obj) { delete obj; }
|
|
QMenu* repeat_menu(PlaylistSequence* theWrappedObject) const;
|
|
PlaylistSequence::RepeatMode repeat_mode(PlaylistSequence* theWrappedObject) const;
|
|
QMenu* shuffle_menu(PlaylistSequence* theWrappedObject) const;
|
|
PlaylistSequence::ShuffleMode shuffle_mode(PlaylistSequence* theWrappedObject) const;
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
class PythonQtWrapper_QueryOptions : public QObject
|
|
{ Q_OBJECT
|
|
public:
|
|
Q_ENUMS(QueryMode )
|
|
enum QueryMode{
|
|
QueryMode_All = QueryOptions::QueryMode_All, QueryMode_Duplicates = QueryOptions::QueryMode_Duplicates, QueryMode_Untagged = QueryOptions::QueryMode_Untagged};
|
|
public slots:
|
|
QueryOptions* new_QueryOptions();
|
|
QueryOptions* new_QueryOptions(const QueryOptions& other) {
|
|
QueryOptions* a = new QueryOptions();
|
|
*((QueryOptions*)a) = other;
|
|
return a; }
|
|
void delete_QueryOptions(QueryOptions* obj) { delete obj; }
|
|
bool Matches(QueryOptions* theWrappedObject, const Song& song) const;
|
|
QString filter(QueryOptions* theWrappedObject) const;
|
|
int max_age(QueryOptions* theWrappedObject) const;
|
|
QueryOptions::QueryMode query_mode(QueryOptions* theWrappedObject) const;
|
|
void set_filter(QueryOptions* theWrappedObject, const QString& filter);
|
|
void set_max_age(QueryOptions* theWrappedObject, int max_age);
|
|
void set_query_mode(QueryOptions* theWrappedObject, QueryOptions::QueryMode query_mode);
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
class PythonQtPublicPromoter_RadioModel : public RadioModel
|
|
{ public:
|
|
inline Qt::ItemFlags promoted_flags(const QModelIndex& index) const { return RadioModel::flags(index); }
|
|
inline bool promoted_hasChildren(const QModelIndex& parent) const { return RadioModel::hasChildren(parent); }
|
|
inline QMimeData* promoted_mimeData(const QList<QModelIndex >& indexes) const { return RadioModel::mimeData(indexes); }
|
|
inline QStringList promoted_mimeTypes() const { return RadioModel::mimeTypes(); }
|
|
inline int promoted_rowCount(const QModelIndex& parent) const { return RadioModel::rowCount(parent); }
|
|
};
|
|
|
|
class PythonQtWrapper_RadioModel : public QObject
|
|
{ Q_OBJECT
|
|
public:
|
|
Q_ENUMS(PlayBehaviour Role Type )
|
|
enum PlayBehaviour{
|
|
PlayBehaviour_None = RadioModel::PlayBehaviour_None, PlayBehaviour_UseSongLoader = RadioModel::PlayBehaviour_UseSongLoader, PlayBehaviour_SingleItem = RadioModel::PlayBehaviour_SingleItem, PlayBehaviour_DoubleClickAction = RadioModel::PlayBehaviour_DoubleClickAction};
|
|
enum Role{
|
|
Role_Type = RadioModel::Role_Type, Role_PlayBehaviour = RadioModel::Role_PlayBehaviour, Role_Url = RadioModel::Role_Url, Role_SongMetadata = RadioModel::Role_SongMetadata, Role_CanLazyLoad = RadioModel::Role_CanLazyLoad, Role_Service = RadioModel::Role_Service, RoleCount = RadioModel::RoleCount};
|
|
enum Type{
|
|
Type_Service = RadioModel::Type_Service, TypeCount = RadioModel::TypeCount};
|
|
public slots:
|
|
void delete_RadioModel(RadioModel* obj) { delete obj; }
|
|
void AddService(RadioModel* theWrappedObject, RadioService* service);
|
|
bool IsPlayable(RadioModel* theWrappedObject, const QModelIndex& index) const;
|
|
void ReloadSettings(RadioModel* theWrappedObject);
|
|
void RemoveService(RadioModel* theWrappedObject, RadioService* service);
|
|
RadioService* static_RadioModel_ServiceByName(const QString& name);
|
|
RadioService* ServiceForIndex(RadioModel* theWrappedObject, const QModelIndex& index) const;
|
|
RadioService* ServiceForItem(RadioModel* theWrappedObject, const QStandardItem* item) const;
|
|
void ShowContextMenu(RadioModel* theWrappedObject, const QModelIndex& merged_model_index, const QPoint& global_pos);
|
|
Qt::ItemFlags flags(RadioModel* theWrappedObject, const QModelIndex& index) const;
|
|
bool hasChildren(RadioModel* theWrappedObject, const QModelIndex& parent) const;
|
|
QMimeData* mimeData(RadioModel* theWrappedObject, const QList<QModelIndex >& indexes) const;
|
|
QStringList mimeTypes(RadioModel* theWrappedObject) const;
|
|
PlayerInterface* player(RadioModel* theWrappedObject) const;
|
|
int rowCount(RadioModel* theWrappedObject, const QModelIndex& parent) const;
|
|
TaskManager* task_manager(RadioModel* theWrappedObject) const;
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
class PythonQtShell_RadioService : public RadioService
|
|
{
|
|
public:
|
|
PythonQtShell_RadioService(const QString& name, RadioModel* model, QObject* parent = NULL):RadioService(name, model, parent),_wrapper(NULL) {};
|
|
|
|
virtual QStandardItem* CreateRootItem();
|
|
virtual QModelIndex GetCurrentIndex();
|
|
virtual QWidget* HeaderWidget() const;
|
|
virtual QString Icon();
|
|
virtual void ItemDoubleClicked(QStandardItem* item);
|
|
virtual void LazyPopulate(QStandardItem* parent);
|
|
virtual void ReloadSettings();
|
|
virtual void ShowContextMenu(const QModelIndex& index, const QPoint& global_pos);
|
|
virtual void childEvent(QChildEvent* arg__1);
|
|
virtual void customEvent(QEvent* arg__1);
|
|
virtual bool event(QEvent* arg__1);
|
|
virtual bool eventFilter(QObject* arg__1, QEvent* arg__2);
|
|
virtual void timerEvent(QTimerEvent* arg__1);
|
|
|
|
PythonQtInstanceWrapper* _wrapper;
|
|
};
|
|
|
|
class PythonQtPublicPromoter_RadioService : public RadioService
|
|
{ public:
|
|
inline QWidget* promoted_HeaderWidget() const { return RadioService::HeaderWidget(); }
|
|
inline QString promoted_Icon() { return RadioService::Icon(); }
|
|
inline void promoted_ItemDoubleClicked(QStandardItem* item) { RadioService::ItemDoubleClicked(item); }
|
|
inline void promoted_ReloadSettings() { RadioService::ReloadSettings(); }
|
|
inline void promoted_ShowContextMenu(const QModelIndex& index, const QPoint& global_pos) { RadioService::ShowContextMenu(index, global_pos); }
|
|
};
|
|
|
|
class PythonQtWrapper_RadioService : public QObject
|
|
{ Q_OBJECT
|
|
public:
|
|
public slots:
|
|
RadioService* new_RadioService(const QString& name, RadioModel* model, QObject* parent = NULL);
|
|
void delete_RadioService(RadioService* obj) { delete obj; }
|
|
QWidget* HeaderWidget(RadioService* theWrappedObject) const;
|
|
QString Icon(RadioService* theWrappedObject);
|
|
void ItemDoubleClicked(RadioService* theWrappedObject, QStandardItem* item);
|
|
void ReloadSettings(RadioService* theWrappedObject);
|
|
void ShowContextMenu(RadioService* theWrappedObject, const QModelIndex& index, const QPoint& global_pos);
|
|
RadioModel* model(RadioService* theWrappedObject) const;
|
|
QString name(RadioService* theWrappedObject) const;
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
class PythonQtShell_Song : public Song
|
|
{
|
|
public:
|
|
PythonQtShell_Song():Song(),_wrapper(NULL) {};
|
|
PythonQtShell_Song(const Song& other):Song(other),_wrapper(NULL) {};
|
|
|
|
|
|
PythonQtInstanceWrapper* _wrapper;
|
|
};
|
|
|
|
class PythonQtWrapper_Song : public QObject
|
|
{ Q_OBJECT
|
|
public:
|
|
Q_ENUMS(FileType )
|
|
enum FileType{
|
|
Type_Unknown = Song::Type_Unknown, Type_Asf = Song::Type_Asf, Type_Flac = Song::Type_Flac, Type_Mp4 = Song::Type_Mp4, Type_Mpc = Song::Type_Mpc, Type_Mpeg = Song::Type_Mpeg, Type_OggFlac = Song::Type_OggFlac, Type_OggSpeex = Song::Type_OggSpeex, Type_OggVorbis = Song::Type_OggVorbis, Type_Aiff = Song::Type_Aiff, Type_Wav = Song::Type_Wav, Type_TrueAudio = Song::Type_TrueAudio, Type_Cdda = Song::Type_Cdda, Type_Stream = Song::Type_Stream};
|
|
public slots:
|
|
Song* new_Song();
|
|
Song* new_Song(const Song& other);
|
|
void delete_Song(Song* obj) { delete obj; }
|
|
QString static_Song_Decode(const QString& tag, const QTextCodec* codec = NULL);
|
|
bool HasProperMediaFile(Song* theWrappedObject) const;
|
|
void Init(Song* theWrappedObject, const QString& title, const QString& artist, const QString& album, qint64 beginning, qint64 end);
|
|
void Init(Song* theWrappedObject, const QString& title, const QString& artist, const QString& album, qint64 length_nanosec);
|
|
void InitFromFile(Song* theWrappedObject, const QString& filename, int directory_id);
|
|
void InitFromFilePartial(Song* theWrappedObject, const QString& filename);
|
|
bool IsEditable(Song* theWrappedObject) const;
|
|
bool IsMetadataEqual(Song* theWrappedObject, const Song& other) const;
|
|
bool IsOnSameAlbum(Song* theWrappedObject, const Song& other) const;
|
|
QString static_Song_JoinSpec(const QString& table);
|
|
QImage static_Song_LoadEmbeddedArt(const QString& filename);
|
|
QString PrettyLength(Song* theWrappedObject) const;
|
|
QString PrettyTitle(Song* theWrappedObject) const;
|
|
QString PrettyTitleWithArtist(Song* theWrappedObject) const;
|
|
QString PrettyYear(Song* theWrappedObject) const;
|
|
bool Save(Song* theWrappedObject) const;
|
|
QString TextForFiletype(Song* theWrappedObject) const;
|
|
QString static_Song_TextForFiletype(Song::FileType type);
|
|
QString TitleWithCompilationArtist(Song* theWrappedObject) const;
|
|
const QString* album(Song* theWrappedObject) const;
|
|
const QString* albumartist(Song* theWrappedObject) const;
|
|
const QString* art_automatic(Song* theWrappedObject) const;
|
|
const QString* art_manual(Song* theWrappedObject) const;
|
|
const QString* artist(Song* theWrappedObject) const;
|
|
const QString* basefilename(Song* theWrappedObject) const;
|
|
qint64 beginning_nanosec(Song* theWrappedObject) const;
|
|
int bitrate(Song* theWrappedObject) const;
|
|
float bpm(Song* theWrappedObject) const;
|
|
const QString* comment(Song* theWrappedObject) const;
|
|
const QString* composer(Song* theWrappedObject) const;
|
|
uint ctime(Song* theWrappedObject) const;
|
|
const QString* cue_path(Song* theWrappedObject) const;
|
|
int directory_id(Song* theWrappedObject) const;
|
|
int disc(Song* theWrappedObject) const;
|
|
qint64 end_nanosec(Song* theWrappedObject) const;
|
|
int filesize(Song* theWrappedObject) const;
|
|
Song::FileType filetype(Song* theWrappedObject) const;
|
|
const QString* genre(Song* theWrappedObject) const;
|
|
bool has_cue(Song* theWrappedObject) const;
|
|
bool has_embedded_cover(Song* theWrappedObject) const;
|
|
bool has_manually_unset_cover(Song* theWrappedObject) const;
|
|
int id(Song* theWrappedObject) const;
|
|
const QImage* image(Song* theWrappedObject) const;
|
|
bool is_cdda(Song* theWrappedObject) const;
|
|
bool is_compilation(Song* theWrappedObject) const;
|
|
bool is_stream(Song* theWrappedObject) const;
|
|
bool is_unavailable(Song* theWrappedObject) const;
|
|
bool is_valid(Song* theWrappedObject) const;
|
|
int lastplayed(Song* theWrappedObject) const;
|
|
qint64 length_nanosec(Song* theWrappedObject) const;
|
|
void manually_unset_cover(Song* theWrappedObject);
|
|
uint mtime(Song* theWrappedObject) const;
|
|
bool __eq__(Song* theWrappedObject, const Song& other) const;
|
|
int playcount(Song* theWrappedObject) const;
|
|
float rating(Song* theWrappedObject) const;
|
|
int samplerate(Song* theWrappedObject) const;
|
|
int score(Song* theWrappedObject) const;
|
|
void set_album(Song* theWrappedObject, const QString& v);
|
|
void set_albumartist(Song* theWrappedObject, const QString& v);
|
|
void set_art_automatic(Song* theWrappedObject, const QString& v);
|
|
void set_art_manual(Song* theWrappedObject, const QString& v);
|
|
void set_artist(Song* theWrappedObject, const QString& v);
|
|
void set_basefilename(Song* theWrappedObject, const QString& v);
|
|
void set_beginning_nanosec(Song* theWrappedObject, qint64 v);
|
|
void set_bitrate(Song* theWrappedObject, int v);
|
|
void set_bpm(Song* theWrappedObject, float v);
|
|
void set_comment(Song* theWrappedObject, const QString& v);
|
|
void set_compilation(Song* theWrappedObject, bool v);
|
|
void set_composer(Song* theWrappedObject, const QString& v);
|
|
void set_ctime(Song* theWrappedObject, int v);
|
|
void set_cue_path(Song* theWrappedObject, const QString& v);
|
|
void set_directory_id(Song* theWrappedObject, int v);
|
|
void set_disc(Song* theWrappedObject, int v);
|
|
void set_embedded_cover(Song* theWrappedObject);
|
|
void set_end_nanosec(Song* theWrappedObject, qint64 v);
|
|
void set_filesize(Song* theWrappedObject, int v);
|
|
void set_filetype(Song* theWrappedObject, Song::FileType v);
|
|
void set_forced_compilation_off(Song* theWrappedObject, bool v);
|
|
void set_forced_compilation_on(Song* theWrappedObject, bool v);
|
|
void set_genre(Song* theWrappedObject, const QString& v);
|
|
void set_genre_id3(Song* theWrappedObject, int id);
|
|
void set_id(Song* theWrappedObject, int id);
|
|
void set_image(Song* theWrappedObject, const QImage& i);
|
|
void set_lastplayed(Song* theWrappedObject, int v);
|
|
void set_length_nanosec(Song* theWrappedObject, qint64 v);
|
|
void set_mtime(Song* theWrappedObject, int v);
|
|
void set_playcount(Song* theWrappedObject, int v);
|
|
void set_rating(Song* theWrappedObject, float v);
|
|
void set_sampler(Song* theWrappedObject, bool v);
|
|
void set_samplerate(Song* theWrappedObject, int v);
|
|
void set_score(Song* theWrappedObject, int v);
|
|
void set_skipcount(Song* theWrappedObject, int v);
|
|
void set_title(Song* theWrappedObject, const QString& v);
|
|
void set_track(Song* theWrappedObject, int v);
|
|
void set_unavailable(Song* theWrappedObject, bool v);
|
|
void set_url(Song* theWrappedObject, const QUrl& v);
|
|
void set_valid(Song* theWrappedObject, bool v);
|
|
void set_year(Song* theWrappedObject, int v);
|
|
int skipcount(Song* theWrappedObject) const;
|
|
const QString* title(Song* theWrappedObject) const;
|
|
int track(Song* theWrappedObject) const;
|
|
const QUrl* url(Song* theWrappedObject) const;
|
|
int year(Song* theWrappedObject) const;
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
class PythonQtShell_SongInsertVetoListener : public SongInsertVetoListener
|
|
{
|
|
public:
|
|
PythonQtShell_SongInsertVetoListener():SongInsertVetoListener(),_wrapper(NULL) {};
|
|
|
|
virtual QList<Song > AboutToInsertSongs(const QList<Song >& old_songs, const QList<Song >& new_songs);
|
|
virtual void childEvent(QChildEvent* arg__1);
|
|
virtual void customEvent(QEvent* arg__1);
|
|
virtual bool event(QEvent* arg__1);
|
|
virtual bool eventFilter(QObject* arg__1, QEvent* arg__2);
|
|
virtual void timerEvent(QTimerEvent* arg__1);
|
|
|
|
PythonQtInstanceWrapper* _wrapper;
|
|
};
|
|
|
|
class PythonQtWrapper_SongInsertVetoListener : public QObject
|
|
{ Q_OBJECT
|
|
public:
|
|
public slots:
|
|
SongInsertVetoListener* new_SongInsertVetoListener();
|
|
void delete_SongInsertVetoListener(SongInsertVetoListener* obj) { delete obj; }
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
class PythonQtShell_SpecialPlaylistType : public SpecialPlaylistType
|
|
{
|
|
public:
|
|
PythonQtShell_SpecialPlaylistType():SpecialPlaylistType(),_wrapper(NULL) {};
|
|
|
|
virtual void DidYouMeanClicked(const QString& text, Playlist* playlist);
|
|
virtual void Search(const QString& text, Playlist* playlist);
|
|
virtual QString empty_playlist_text(Playlist* playlist) const;
|
|
virtual bool has_special_search_behaviour(Playlist* playlist) const;
|
|
virtual QIcon icon(Playlist* playlist) const;
|
|
virtual QString name() const;
|
|
virtual QString search_hint_text(Playlist* playlist) const;
|
|
|
|
PythonQtInstanceWrapper* _wrapper;
|
|
};
|
|
|
|
class PythonQtPublicPromoter_SpecialPlaylistType : public SpecialPlaylistType
|
|
{ public:
|
|
inline void promoted_DidYouMeanClicked(const QString& text, Playlist* playlist) { SpecialPlaylistType::DidYouMeanClicked(text, playlist); }
|
|
inline void promoted_Search(const QString& text, Playlist* playlist) { SpecialPlaylistType::Search(text, playlist); }
|
|
inline QString promoted_empty_playlist_text(Playlist* playlist) const { return SpecialPlaylistType::empty_playlist_text(playlist); }
|
|
inline bool promoted_has_special_search_behaviour(Playlist* playlist) const { return SpecialPlaylistType::has_special_search_behaviour(playlist); }
|
|
inline QIcon promoted_icon(Playlist* playlist) const { return SpecialPlaylistType::icon(playlist); }
|
|
inline QString promoted_search_hint_text(Playlist* playlist) const { return SpecialPlaylistType::search_hint_text(playlist); }
|
|
};
|
|
|
|
class PythonQtWrapper_SpecialPlaylistType : public QObject
|
|
{ Q_OBJECT
|
|
public:
|
|
public slots:
|
|
SpecialPlaylistType* new_SpecialPlaylistType();
|
|
void delete_SpecialPlaylistType(SpecialPlaylistType* obj) { delete obj; }
|
|
void DidYouMeanClicked(SpecialPlaylistType* theWrappedObject, const QString& text, Playlist* playlist);
|
|
void Search(SpecialPlaylistType* theWrappedObject, const QString& text, Playlist* playlist);
|
|
QString empty_playlist_text(SpecialPlaylistType* theWrappedObject, Playlist* playlist) const;
|
|
bool has_special_search_behaviour(SpecialPlaylistType* theWrappedObject, Playlist* playlist) const;
|
|
QIcon icon(SpecialPlaylistType* theWrappedObject, Playlist* playlist) const;
|
|
QString search_hint_text(SpecialPlaylistType* theWrappedObject, Playlist* playlist) const;
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
class PythonQtShell_Subdirectory : public Subdirectory
|
|
{
|
|
public:
|
|
PythonQtShell_Subdirectory():Subdirectory(),_wrapper(NULL) {};
|
|
|
|
|
|
PythonQtInstanceWrapper* _wrapper;
|
|
};
|
|
|
|
class PythonQtWrapper_Subdirectory : public QObject
|
|
{ Q_OBJECT
|
|
public:
|
|
public slots:
|
|
Subdirectory* new_Subdirectory();
|
|
Subdirectory* new_Subdirectory(const Subdirectory& other) {
|
|
PythonQtShell_Subdirectory* a = new PythonQtShell_Subdirectory();
|
|
*((Subdirectory*)a) = other;
|
|
return a; }
|
|
void delete_Subdirectory(Subdirectory* obj) { delete obj; }
|
|
void py_set_mtime(Subdirectory* theWrappedObject, uint mtime){ theWrappedObject->mtime = mtime; }
|
|
uint py_get_mtime(Subdirectory* theWrappedObject){ return theWrappedObject->mtime; }
|
|
void py_set_path(Subdirectory* theWrappedObject, QString path){ theWrappedObject->path = path; }
|
|
QString py_get_path(Subdirectory* theWrappedObject){ return theWrappedObject->path; }
|
|
void py_set_directory_id(Subdirectory* theWrappedObject, int directory_id){ theWrappedObject->directory_id = directory_id; }
|
|
int py_get_directory_id(Subdirectory* theWrappedObject){ return theWrappedObject->directory_id; }
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
class PythonQtShell_TaskManager : public TaskManager
|
|
{
|
|
public:
|
|
PythonQtShell_TaskManager(QObject* parent = 0):TaskManager(parent),_wrapper(NULL) {};
|
|
|
|
virtual void childEvent(QChildEvent* arg__1);
|
|
virtual void customEvent(QEvent* arg__1);
|
|
virtual bool event(QEvent* arg__1);
|
|
virtual bool eventFilter(QObject* arg__1, QEvent* arg__2);
|
|
virtual void timerEvent(QTimerEvent* arg__1);
|
|
|
|
PythonQtInstanceWrapper* _wrapper;
|
|
};
|
|
|
|
class PythonQtWrapper_TaskManager : public QObject
|
|
{ Q_OBJECT
|
|
public:
|
|
public slots:
|
|
TaskManager* new_TaskManager(QObject* parent = 0);
|
|
void delete_TaskManager(TaskManager* obj) { delete obj; }
|
|
QList<TaskManager_Task > GetTasks(TaskManager* theWrappedObject);
|
|
void SetTaskBlocksLibraryScans(TaskManager* theWrappedObject, int id);
|
|
void SetTaskFinished(TaskManager* theWrappedObject, int id);
|
|
void SetTaskProgress(TaskManager* theWrappedObject, int id, int progress, int max = 0);
|
|
int StartTask(TaskManager* theWrappedObject, const QString& name);
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
class PythonQtShell_TaskManager_Task : public TaskManager_Task
|
|
{
|
|
public:
|
|
PythonQtShell_TaskManager_Task():TaskManager_Task(),_wrapper(NULL) {};
|
|
|
|
|
|
PythonQtInstanceWrapper* _wrapper;
|
|
};
|
|
|
|
class PythonQtWrapper_TaskManager_Task : public QObject
|
|
{ Q_OBJECT
|
|
public:
|
|
public slots:
|
|
TaskManager_Task* new_TaskManager_Task();
|
|
TaskManager_Task* new_TaskManager_Task(const TaskManager_Task& other) {
|
|
PythonQtShell_TaskManager_Task* a = new PythonQtShell_TaskManager_Task();
|
|
*((TaskManager_Task*)a) = other;
|
|
return a; }
|
|
void delete_TaskManager_Task(TaskManager_Task* obj) { delete obj; }
|
|
void py_set_progress_max(TaskManager_Task* theWrappedObject, int progress_max){ theWrappedObject->progress_max = progress_max; }
|
|
int py_get_progress_max(TaskManager_Task* theWrappedObject){ return theWrappedObject->progress_max; }
|
|
void py_set_progress(TaskManager_Task* theWrappedObject, int progress){ theWrappedObject->progress = progress; }
|
|
int py_get_progress(TaskManager_Task* theWrappedObject){ return theWrappedObject->progress; }
|
|
void py_set_id(TaskManager_Task* theWrappedObject, int id){ theWrappedObject->id = id; }
|
|
int py_get_id(TaskManager_Task* theWrappedObject){ return theWrappedObject->id; }
|
|
void py_set_name(TaskManager_Task* theWrappedObject, QString name){ theWrappedObject->name = name; }
|
|
QString py_get_name(TaskManager_Task* theWrappedObject){ return theWrappedObject->name; }
|
|
void py_set_blocks_library_scans(TaskManager_Task* theWrappedObject, bool blocks_library_scans){ theWrappedObject->blocks_library_scans = blocks_library_scans; }
|
|
bool py_get_blocks_library_scans(TaskManager_Task* theWrappedObject){ return theWrappedObject->blocks_library_scans; }
|
|
};
|
|
|
|
|