SignalManager.h

Go to the documentation of this file.

/***************************************************************************
         SignalManager.h -  manager class for multi channel signals
                             -------------------
    begin                : Sun Oct 15 2000
    copyright            : (C) 2000 by Thomas Eschenbacher
    email                : Thomas.Eschenbacher@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 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 ***************************************************************************/

#ifndef SIGNAL_MANAGER_H
#define SIGNAL_MANAGER_H

#include "config.h"
#include <limits.h>
#include <stdio.h>

#include <QtGlobal>
#include <QList>
#include <QMap>
#include <QMutex>
#include <QObject>
#include <QString>

#include "libkwave/FileInfo.h"
#include "libkwave/Label.h"
#include "libkwave/MetaData.h"
#include "libkwave/MetaDataList.h"
#include "libkwave/PlaybackController.h"
#include "libkwave/ReaderMode.h"
#include "libkwave/Selection.h"
#include "libkwave/Signal.h"
#include "libkwave/undo/UndoManager.h"

class QBitmap;
class QFile;
class QUrl;

#define NEW_FILENAME i18n("New File")

namespace Kwave
{

    class UndoAction;
    class UndoInsertAction;
    class UndoTransaction;
    class UndoTransactionGuard;
    class MultiTrackWriter;
    class SampleReader;
    class SignalWidget;
    class Track;
    class Writer;

    class Q_DECL_EXPORT SignalManager: public QObject
    {
        Q_OBJECT

    public:
        explicit SignalManager(QWidget *parent);

        virtual ~SignalManager();

        int loadFile(const QUrl &url);

        void newSignal(sample_index_t samples, double rate,
                       unsigned int bits, unsigned int tracks);

        void close();

        inline bool isClosed() { return m_closed; }

        inline bool isEmpty() { return m_empty; }

        inline bool isModified() { return m_modified; }

        Kwave::PlaybackController &playbackController();

        int executeCommand(const QString &command);

        QString signalName();

        inline unsigned int bits() const {
            return Kwave::FileInfo(m_meta_data).bits();
        }

        inline double rate() const {
            return Kwave::FileInfo(m_meta_data).rate();
        }

        inline unsigned int tracks() { return m_signal.tracks(); }

        inline sample_index_t length() { return m_signal.length(); }

        inline Kwave::Selection &selection() { return m_selection; }

        inline bool trackSelected(unsigned int track) {
            return (m_signal.trackSelected(track));
        }

        const QList<unsigned int> selectedTracks();

        const QList<unsigned int> allTracks();

        int save(const QUrl &url, bool selection);

        bool deleteRange(sample_index_t offset, sample_index_t length,
                         const QList<unsigned int> &track_list);

        bool deleteRange(sample_index_t offset, sample_index_t length);

        bool insertSpace(sample_index_t offset, sample_index_t length,
                         const QList<unsigned int> &track_list);

        void selectRange(sample_index_t offset, sample_index_t length);

        void appendTrack();

        void insertTrack(unsigned int index);

        void deleteTrack(unsigned int index);

        void selectTracks(QList<unsigned int> &track_list);

        void selectTrack(unsigned int track, bool select);

        inline Kwave::Writer *openWriter(Kwave::InsertMode mode,
            unsigned int track,
            sample_index_t left = 0, sample_index_t right = 0)
        {
            return m_signal.openWriter(mode, track, left, right);
        }

        inline Kwave::SampleReader *openReader(Kwave::ReaderMode mode,
            unsigned int track,
            sample_index_t left = 0, sample_index_t right = SAMPLE_INDEX_MAX)
        {
            return m_signal.openReader(mode, track, left, right);
        }


        QList<Kwave::Stripe::List> stripes(
            const QList<unsigned int> &track_list,
            sample_index_t left = 0,
            sample_index_t right = SAMPLE_INDEX_MAX);

        bool mergeStripes(const QList<Kwave::Stripe::List> &stripes,
                          const QList<unsigned int> &track_list);

        inline Kwave::UndoManager &undoManager() { return m_undo_manager; }

        inline bool undoEnabled() const { return m_undo_enabled; }

        inline bool canUndo() const {
            return !m_undo_buffer.isEmpty() && undoEnabled();
        }

        inline bool canRedo() const {
            return !m_redo_buffer.isEmpty() && undoEnabled();
        }

        void enableUndo();

        void disableUndo();

        void setFileInfo(const Kwave::FileInfo &new_info, bool with_undo);

        Kwave::Label addLabel(sample_index_t pos, const QString &name);

        void deleteLabel(int index, bool with_undo);

        bool modifyLabel(int index, sample_index_t pos, const QString &name,
                         bool with_undo);

        int labelIndex(const Kwave::Label &label) const;

        Kwave::Label findLabel(sample_index_t pos);

        Kwave::MetaDataList &metaData() { return m_meta_data; }

        const Kwave::MetaDataList &metaData() const { return m_meta_data; }

        void mergeMetaData(const Kwave::MetaDataList &meta_data);

        QUuid uuidOfTrack(unsigned int track) {
            return m_signal.uuidOfTrack(track);
        }

        inline void setParentWidget(QWidget *new_parent) {
            m_parent_widget = new_parent;
        }

    signals:

        void sigSelectionChanged(sample_index_t offset, sample_index_t length);

        void sigTrackInserted(unsigned int index, Kwave::Track *track);

        void sigTrackDeleted(unsigned int index, Kwave::Track *track);

        void sigTrackSelectionChanged(bool enabled);

        void sigSamplesInserted(unsigned int track, sample_index_t offset,
                                sample_index_t length);

        void sigSamplesDeleted(unsigned int track, sample_index_t offset,
                               sample_index_t length);

        void sigSamplesModified(unsigned int track, sample_index_t offset,
                                sample_index_t length);

        void sigMetaDataChanged(Kwave::MetaDataList meta);

        void sigUndoRedoInfo(const QString &undo, const QString &redo);

        void sigModified();

    public slots:

        void undo();

        void redo();

    private slots:

        void slotTrackInserted(unsigned int index, Kwave::Track *track);

        void slotTrackDeleted(unsigned int index, Kwave::Track *track);

        void slotSamplesInserted(unsigned int track, sample_index_t offset,
                                 sample_index_t length);

        void slotSamplesDeleted(unsigned int track, sample_index_t offset,
                                sample_index_t length);

        void slotSamplesModified(unsigned int track, sample_index_t offset,
                                 sample_index_t length);

        void closeUndoTransaction();

        void emitUndoRedoInfo();

    protected:

        friend class Kwave::UndoInsertAction;

        inline void deleteRange(unsigned int track, sample_index_t offset,
                                sample_index_t length)
        {
            m_signal.deleteRange(track, offset, length);
        }

    protected:

        friend class MultiTrackWriter;
        friend class PlaybackController;
        friend class PluginManager;
        friend class MainWidget;
        friend class UndoTransactionGuard;

        bool registerUndoAction(Kwave::UndoAction *action);

        bool saveUndoDelete(QList<unsigned int> &track_list,
                            sample_index_t offset, sample_index_t length);

        void abortUndoTransaction();

        void startUndoTransaction(const QString &name = QString());

        void flushUndoBuffers();

        void flushRedoBuffer();

        void setModified(bool mod);

        QWidget *parentWidget() const { return m_parent_widget; }

    private:

        bool continueWithoutUndo();

        qint64 usedUndoRedoMemory();

        void freeUndoMemory(qint64 needed);

        void enableModifiedChange(bool en);

        void rememberCurrentSelection();

        void checkSelectionChange();

    private:

        QWidget *m_parent_widget;

        bool m_closed;

        bool m_empty;

        bool m_modified;

        bool m_modified_enabled;

        Kwave::Signal m_signal;

        Kwave::Selection m_selection;

        Kwave::Selection m_last_selection;

        QList <unsigned int> m_last_track_selection;

        sample_index_t m_last_length;

        Kwave::PlaybackController m_playback_controller;

        bool m_undo_enabled;

        QList<Kwave::UndoTransaction *> m_undo_buffer;

        QList<Kwave::UndoTransaction *> m_redo_buffer;

        Kwave::UndoTransaction *m_undo_transaction;

        unsigned int m_undo_transaction_level;

        QMutex m_undo_transaction_lock;

        Kwave::UndoManager m_undo_manager;

        Kwave::MetaDataList m_meta_data;

    };
}

#endif  /* SIGNAL_MANAGER_H */

//***************************************************************************
//***************************************************************************