kcompactdisc.h

Go to the documentation of this file.

/*
 *  KCompactDisc - A CD drive interface for the KDE Project.
 *
 *  Copyright (C) 2005 Shaheedur R. Haque <srhaque@iee.org>
 *  Copyright (C) 2007 Alexander Kern <alex.kern@gmx.de>
 *
 *  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, 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 Street, Fifth Floor, Boston, MA 02110-1301, USA.
 */

#ifndef KCOMPACTDISC_H
#define KCOMPACTDISC_H

#include <QtCore/QObject>
#include <QtCore/QTimer>
#include <QtCore/QStringList>

#include <kdemacros.h>
#include <kurl.h>

#if defined Q_OS_WIN

#ifndef KCOMPACTDISC_EXPORT
# ifdef MAKE_KCOMPACTDISC_LIB
#  define KCOMPACTDISC_EXPORT KDE_EXPORT
# else
#  define KCOMPACTDISC_EXPORT KDE_IMPORT
# endif
#endif

#else /* UNIX */

/* export statements for unix */
#define KCOMPACTDISC_EXPORT KDE_EXPORT
#endif

class KCompactDiscPrivate;

class KCOMPACTDISC_EXPORT KCompactDisc : public QObject
{
    Q_OBJECT
/*
    Q_CLASSINFO("D-Bus Interface", "org.kde.KSCD")

public Q_SLOTS:
    Q_SCRIPTABLE bool playing();
    Q_SCRIPTABLE void play() { play(); }
    Q_SCRIPTABLE void stop() { stop(); }
    Q_SCRIPTABLE void previous() { prev(); }
    Q_SCRIPTABLE void next() { next(); }
    Q_SCRIPTABLE void jumpTo(int seconds) { jumpToTime(seconds); }
    Q_SCRIPTABLE void eject() { eject(); }
    Q_SCRIPTABLE void toggleLoop() { loop(); }
    Q_SCRIPTABLE void toggleShuffle() { random(); }
    Q_SCRIPTABLE void toggleTimeDisplay() { cycleplaytimemode(); }
    Q_SCRIPTABLE void cddbDialog() { CDDialogSelected(); }
    Q_SCRIPTABLE void optionDialog() { showConfig(); }
    Q_SCRIPTABLE void setTrack(int t) { trackSelected(t > 0 ? t - 1 : 0); }
    Q_SCRIPTABLE void volumeDown() { decVolume(); }
    Q_SCRIPTABLE void volumeUp() { incVolume(); }
    Q_SCRIPTABLE void setVolume(int v);
    Q_SCRIPTABLE void setDevice(const QString& dev);
    Q_SCRIPTABLE int  getVolume() { return Prefs::volume(); }
    Q_SCRIPTABLE int currentTrack();
    Q_SCRIPTABLE int currentTrackLength();
    Q_SCRIPTABLE int currentPosition();
    Q_SCRIPTABLE int getStatus();
    Q_SCRIPTABLE QString currentTrackTitle();
    Q_SCRIPTABLE QString currentAlbum();
    Q_SCRIPTABLE QString currentArtist();
    Q_SCRIPTABLE QStringList trackList();
*/
public:
    enum InformationMode
    {
        Synchronous, // Return and emit signal when cdrom and cddb information arrives.
        Asynchronous // Block until cdrom and cddb infromation has been obtained
    };

    enum DiscCommand
    {
        Play,
        Pause,
        Next,
        Prev,
        Stop,
        Eject,
        Loop,
        Random
    };
    
    enum DiscStatus
    {
        Playing,
        Paused,
        Stopped,
        Ejected,
        NoDisc,
        NotReady,
        Error
    };

    enum DiscInfo
    {
        Cdtext,
        Cddb,
        PhononMetadata
    };

    KCompactDisc(InformationMode = KCompactDisc::Synchronous);
    virtual ~KCompactDisc();

    bool setDevice(
        const QString &device,
        unsigned volume = 50,
        bool digitalPlayback = true,
        const QString &audioSystem = QString(),
        const QString &audioDevice = QString());

    static QString urlToDevice(const KUrl& url);

    static const QStringList audioSystems();

    static const QStringList cdromDeviceNames();

    static const QString defaultCdromDeviceName();

    static const KUrl defaultCdromDeviceUrl();

    static const KUrl cdromDeviceUrl(const QString &);

    static const QString defaultCdromDeviceUdi();

    static const QString cdromDeviceUdi(const QString &);

    const QString &deviceVendor();

    const QString &deviceModel();

    const QString &deviceRevision();

    const QString &deviceName();

    const KUrl deviceUrl();

    unsigned discId();

    const QList<unsigned> &discSignature();

    const QString &discArtist();

    const QString &discTitle();

    unsigned discLength();

    unsigned discPosition();

    KCompactDisc::DiscStatus discStatus();

    QString discStatusString(KCompactDisc::DiscStatus status);

    QString trackArtist();

    QString trackArtist(unsigned track);

    QString trackTitle();

    QString trackTitle(unsigned track);

    unsigned trackLength();

    unsigned trackLength(unsigned track);

    unsigned track();

    unsigned trackPosition();

    unsigned tracks();

    bool isPlaying();

    bool isPaused();

    bool isNoDisc();

    bool isAudio(unsigned track);


public Q_SLOTS:

    void playTrack(unsigned int track);

    void playPosition(unsigned int position);

    /* GUI bindings */
    void play();

    void next();

    void prev();

    void pause();

    void stop();

    void eject();

    void loop();

    void random();

    void doCommand(KCompactDisc::DiscCommand);


    void metadataLookup();


Q_SIGNALS:
    void playoutPositionChanged(unsigned int position);

    void playoutTrackChanged(unsigned int track);


public Q_SLOTS:

    void setRandomPlaylist(bool);
    void setLoopPlaylist(bool);
    void setAutoMetadataLookup(bool);


Q_SIGNALS:

    void randomPlaylistChanged(bool);
    void loopPlaylistChanged(bool);


Q_SIGNALS:

    void discChanged(unsigned int tracks);

    void discInformation(KCompactDisc::DiscInfo info);

    void discStatusChanged(KCompactDisc::DiscStatus status);


public Q_SLOTS:

    void setVolume(unsigned int volume);

    void setBalance(unsigned int balance);

Q_SIGNALS:

    void volumeChanged(unsigned int volume);

    void balanceChanged(unsigned int balance);


protected:
    KCompactDiscPrivate * d_ptr;
    KCompactDisc(KCompactDiscPrivate &dd, QObject *parent);

private:
    Q_DECLARE_PRIVATE(KCompactDisc)
#ifdef USE_WMLIB
    friend class KWMLibCompactDiscPrivate;
#endif
    friend class KPhononCompactDiscPrivate;
};

#endif