context.h

Go to the documentation of this file.

/*
 * libsynthclone - a plugin API for `synthclone`
 * Copyright (C) 2011 Devin Anderson
 *
 * This library is free software; you can redistribute it and/or modify it
 * under the terms of the GNU Lesser General Public License as published by the
 * Free Software Foundation; either version 2.1 of the License, or (at your
 * option) any later version.
 *
 * This library 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 Lesser General Public License
 * for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with this library; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 */
 
#ifndef __SYNTHCLONE_CONTEXT_H__
#define __SYNTHCLONE_CONTEXT_H__
 
#include <QtCore/QDir>
#include <QtCore/QStringList>
 
#include <synthclone/effect.h>
#include <synthclone/effectjob.h>
#include <synthclone/menuaction.h>
#include <synthclone/menuseparator.h>
#include <synthclone/registration.h>
#include <synthclone/sampler.h>
#include <synthclone/target.h>
#include <synthclone/zonecomparer.h>
 
namespace synthclone {
 
    class Participant;

 
    class Context: public QObject {
 
        Q_OBJECT
 
    public:

 
        virtual const EffectJob *
        getCurrentEffectJob() const = 0;

 
        virtual const SamplerJob *
        getCurrentSamplerJob() const = 0;

 
        virtual const Effect *
        getEffect(int index) const = 0;

 
        virtual int
        getEffectCount() const = 0;

 
        virtual int
        getEffectIndex(const Effect *effect) const = 0;

 
        virtual const EffectJob *
        getEffectJob(int index) const = 0;

 
        virtual int
        getEffectJobCount() const = 0;

 
        virtual int
        getEffectJobIndex(const synthclone::EffectJob *job) const = 0;

 
        virtual const Component *
        getFocusedComponent() const = 0;

 
        virtual int
        getMajorVersion() const = 0;

 
        virtual int
        getMinorVersion() const = 0;

 
        virtual const Participant *
        getParticipant(const QByteArray &id) const = 0;

 
        virtual const Participant *
        getParticipant(int index, const Participant *parent=0) const = 0;

 
        virtual int
        getParticipantCount(const Participant *parent=0) const = 0;

 
        virtual QByteArray
        getParticipantId(const Participant *participant) const = 0;

 
        virtual const Participant *
        getParticipantParent(const Participant *participant) const = 0;

 
        virtual int
        getRevision() const = 0;

 
        virtual SampleChannelCount
        getSampleChannelCount() const = 0;

 
        virtual const Sampler *
        getSampler() const = 0;

 
        virtual const SamplerJob *
        getSamplerJob(int index) const = 0;

 
        virtual int
        getSamplerJobCount() const = 0;

 
        virtual int
        getSamplerJobIndex(const synthclone::SamplerJob *job) const = 0;

 
        virtual SampleRate
        getSampleRate() const = 0;

 
        virtual const Effect *
        getSelectedEffect() const = 0;

 
        virtual const Target *
        getSelectedTarget() const = 0;

 
        virtual Zone *
        getSelectedZone(int index) = 0;

 
        virtual int
        getSelectedZoneCount() const = 0;

 
        virtual const QDir *
        getSessionDirectory() const = 0;

 
        virtual SessionState
        getSessionState() const = 0;

 
        virtual const Target *
        getTarget(int index) const = 0;

 
        virtual int
        getTargetCount() const = 0;

 
        virtual int
        getTargetIndex(const Target *target) const = 0;

 
        virtual Zone *
        getZone(int index) = 0;

 
        virtual int
        getZoneCount() const = 0;

 
        virtual int
        getZoneIndex(const Zone *zone) const = 0;

 
        virtual bool
        isAftertouchPropertyVisible() const = 0;

 
        virtual bool
        isChannelPressurePropertyVisible() const = 0;

 
        virtual bool
        isChannelPropertyVisible() const = 0;

 
        virtual bool
        isControlPropertyVisible(MIDIData control) const = 0;

 
        virtual bool
        isDrySamplePropertyVisible() const = 0;

 
        virtual bool
        isNotePropertyVisible() const = 0;

 
        virtual bool
        isParticipantActivated(const Participant *participant) const = 0;

 
        virtual bool
        isReleaseTimePropertyVisible() const = 0;

 
        virtual bool
        isSampleTimePropertyVisible() const = 0;

 
        virtual bool
        isSessionDirectory(const QDir &directory) const = 0;

 
        virtual bool
        isStatusPropertyVisible() const = 0;

 
        virtual bool
        isVelocityPropertyVisible() const = 0;

 
        virtual bool
        isWetSamplePropertyVisible() const = 0;

 
        virtual bool
        isZoneSelected(const Zone *zone) const = 0;

 
        virtual bool
        isZoneSelected(int index) const = 0;
 
    public slots:

 
        virtual void
        abortCurrentSamplerJob() = 0;

 
        virtual void
        activateParticipant(const synthclone::Participant *participant) = 0;

 
        virtual const Registration &
        addEffect(Effect *effect, int index=-1) = 0;

 
        virtual const EffectJob *
        addEffectJob(Zone *zone) = 0;

 
        virtual const Registration &
        addMenuAction(MenuAction *action, Menu menu,
                      const QStringList &subMenus=QStringList()) = 0;

 
        virtual const Registration &
        addMenuAction(MenuAction *action, const Effect *effect,
                      const QStringList &subMenus=QStringList()) = 0;

 
        virtual const Registration &
        addMenuAction(MenuAction *action, const Sampler *sampler,
                      const QStringList &subMenus=QStringList()) = 0;

 
        virtual const Registration &
        addMenuAction(MenuAction *action, const Target *target,
                      const QStringList &subMenus=QStringList()) = 0;

 
        virtual const Registration &
        addMenuSeparator(MenuSeparator *separator, Menu menu,
                         const QStringList &subMenus=QStringList()) = 0;

 
        virtual const Registration &
        addMenuSeparator(MenuSeparator *separator, const Effect *effect,
                         const QStringList &subMenus=QStringList()) = 0;

 
        virtual const Registration &
        addMenuSeparator(MenuSeparator *separator, const Sampler *sampler,
                         const QStringList &subMenus=QStringList()) = 0;

 
        virtual const Registration &
        addMenuSeparator(MenuSeparator *separator, const Target *target,
                         const QStringList &subMenus=QStringList()) = 0;

 
        virtual const Registration &
        addParticipant(Participant *participant, const QByteArray &subId) = 0;

 
        virtual const Registration &
        addSampler(Sampler *sampler) = 0;

 
        virtual const SamplerJob *
        addSamplerJob(SamplerJob::Type type, Zone *zone) = 0;

 
        virtual const Registration &
        addTarget(Target *target, int index=-1) = 0;

 
        virtual Zone *
        addZone(int index=-1) = 0;

 
        virtual void
        buildTargets() = 0;

 
        virtual void
        createSession(const QDir &directory, SampleRate sampleRate,
                      SampleChannelCount count) = 0;

 
        virtual void
        deactivateParticipant(const Participant *participant) = 0;

 
        virtual void
        loadSession(const QDir &directory) = 0;

 
        virtual void
        moveEffect(int fromIndex, int toIndex) = 0;

 
        virtual void
        moveEffectJob(int fromIndex, int toIndex) = 0;

 
        virtual void
        moveSamplerJob(int fromIndex, int toIndex) = 0;

 
        virtual void
        moveTarget(int fromIndex, int toIndex) = 0;

 
        virtual void
        moveZone(int fromIndex, int toIndex) = 0;

 
        virtual void
        quit() = 0;

 
        virtual void
        removeEffect(const Effect *effect) = 0;

 
        virtual void
        removeEffect(int index) = 0;

 
        virtual void
        removeEffectJob(const EffectJob *job) = 0;

 
        virtual void
        removeEffectJob(int index) = 0;

 
        virtual void
        removeMenuAction(const MenuAction *action) = 0;

 
        virtual void
        removeMenuSeparator(const MenuSeparator *separator) = 0;

 
        virtual void
        removeParticipant(const Participant *participant) = 0;

 
        virtual void
        removeSampler() = 0;

 
        virtual void
        removeSamplerJob(const SamplerJob *job) = 0;

 
        virtual void
        removeSamplerJob(int index) = 0;

 
        virtual void
        removeTarget(const Target *target) = 0;

 
        virtual void
        removeTarget(int index) = 0;

 
        virtual void
        removeZone(Zone *zone) = 0;

 
        virtual void
        removeZone(int index) = 0;

 
        virtual void
        reportError(const QString &message) = 0;

 
        virtual void
        saveSession() = 0;

 
        virtual void
        saveSession(const QDir &directory) = 0;

 
        virtual void
        setAftertouchPropertyVisible(bool visible) = 0;

 
        virtual void
        setChannelPressurePropertyVisible(bool visible) = 0;

 
        virtual void
        setChannelPropertyVisible(bool visible) = 0;

 
        virtual void
        setControlPropertyVisible(MIDIData control, bool visible) = 0;

 
        virtual void
        setDrySamplePropertyVisible(bool visible) = 0;

 
        virtual void
        setFocusedComponent(const Component *component) = 0;

 
        virtual void
        setNotePropertyVisible(bool visible) = 0;

 
        virtual void
        setReleaseTimePropertyVisible(bool visible) = 0;

 
        virtual void
        setSampleChannelCount(SampleChannelCount sampleChannelCount) = 0;

 
        virtual void
        setSampleRate(SampleRate sampleRate) = 0;

 
        virtual void
        setSampleTimePropertyVisible(bool visible) = 0;

 
        virtual void
        setSelectedEffect(const Effect *effect) = 0;

 
        virtual void
        setSelectedEffect(int index) = 0;

 
        virtual void
        setSelectedTarget(const Target *target) = 0;

 
        virtual void
        setSelectedTarget(int index) = 0;

 
        virtual void
        setSessionModified() = 0;

 
        virtual void
        setStatusPropertyVisible(bool visible) = 0;

 
        virtual void
        setVelocityPropertyVisible(bool visible) = 0;

 
        virtual void
        setWetSamplePropertyVisible(bool visible) = 0;

 
        virtual void
        setZoneSelected(const Zone *zone, bool selected) = 0;

 
        virtual void
        setZoneSelected(int index, bool selected) = 0;

 
        virtual void
        sortZones(const ZoneComparer &comparer, bool ascending=true) = 0;

 
        virtual void
        unloadSession() = 0;
 
    signals:

 
        void
        activatingParticipant(const synthclone::Participant *participant,
                              const synthclone::Participant *parent,
                              const QByteArray &id);

 
        void
        addingEffect(const synthclone::Effect *effect, int index);

 
        void
        addingEffectJob(const synthclone::EffectJob *job, int index);

 
        void
        addingMenuAction(const synthclone::MenuAction *action,
                         synthclone::Menu menu, const QStringList &subMenus);

 
        void
        addingMenuAction(const synthclone::MenuAction *action,
                         const synthclone::Effect *effect,
                         const QStringList &subMenus);

 
        void
        addingMenuAction(const synthclone::MenuAction *action,
                         const synthclone::Sampler *sampler,
                         const QStringList &subMenus);

 
        void
        addingMenuAction(const synthclone::MenuAction *action,
                         const synthclone::Target *target,
                         const QStringList &subMenus);

 
        void
        addingMenuSeparator(const synthclone::MenuSeparator *separator,
                            synthclone::Menu menu,
                            const QStringList &subMenus);

 
        void
        addingMenuSeparator(const synthclone::MenuSeparator *separator,
                            const synthclone::Effect *effect,
                            const QStringList &subMenus);

 
        void
        addingMenuSeparator(const synthclone::MenuSeparator *separator,
                            const synthclone::Sampler *sampler,
                            const QStringList &subMenus);

 
        void
        addingMenuSeparator(const synthclone::MenuSeparator *separator,
                            const synthclone::Target *target,
                            const QStringList &subMenus);

 
        void
        addingParticipant(const synthclone::Participant *participant,
                          const synthclone::Participant *parent,
                          const QByteArray &id);

 
        void
        addingSampler(const synthclone::Sampler *sampler);

 
        void
        addingSamplerJob(const synthclone::SamplerJob *job, int index);

 
        void
        addingTarget(const synthclone::Target *target, int index);

 
        void
        addingZone(const synthclone::Zone *zone, int index);

 
        void
        aftertouchPropertyVisibilityChanged(bool visible);

 
        void
        buildingTarget(const synthclone::Target *target);

 
        void
        buildingTargets();

 
        void
        channelPressurePropertyVisibilityChanged(bool visible);

 
        void
        channelPropertyVisibilityChanged(bool visible);

 
        void
        controlPropertyVisibilityChanged(synthclone::MIDIData control,
                                         bool visible);

 
        void
        currentEffectJobChanged(const synthclone::EffectJob *job);

 
        void
        currentSamplerJobChanged(const synthclone::SamplerJob *job);

 
        void
        deactivatingParticipant(const synthclone::Participant *participant,
                                const synthclone::Participant *parent,
                                const QByteArray &id);

 
        void
        drySamplePropertyVisibilityChanged(bool visible);

 
        void
        effectAdded(const synthclone::Effect *effect, int index);

 
        void
        effectJobAdded(const synthclone::EffectJob *job, int index);

 
        void
        effectJobMoved(const synthclone::EffectJob *job, int fromIndex,
                       int toIndex);

 
        void
        effectJobRemoved(const synthclone::EffectJob *job, int index);

 
        void
        effectMoved(const synthclone::Effect *effect, int fromIndex,
                    int toIndex);

 
        void
        effectRemoved(const synthclone::Effect *effect, int index);

 
        void
        errorReported(const QString &message);

 
        void
        focusedComponentChanged(const synthclone::Component *component);

 
        void
        menuActionAdded(const synthclone::MenuAction *action,
                        synthclone::Menu menu, const QStringList &subMenus);

 
        void
        menuActionAdded(const synthclone::MenuAction *action,
                        const synthclone::Effect *effect,
                        const QStringList &subMenus);

 
        void
        menuActionAdded(const synthclone::MenuAction *action,
                        const synthclone::Sampler *sampler,
                        const QStringList &subMenus);

 
        void
        menuActionAdded(const synthclone::MenuAction *action,
                        const synthclone::Target *target,
                        const QStringList &subMenus);

 
        void
        menuActionRemoved(const synthclone::MenuAction *action,
                          synthclone::Menu menu, const QStringList &subMenus);

 
        void
        menuActionRemoved(const synthclone::MenuAction *action,
                          const synthclone::Effect *effect,
                          const QStringList &subMenus);

 
        void
        menuActionRemoved(const synthclone::MenuAction *action,
                          const synthclone::Sampler *sampler,
                          const QStringList &subMenus);

 
        void
        menuActionRemoved(const synthclone::MenuAction *action,
                          const synthclone::Target *target,
                          const QStringList &subMenus);

 
        void
        menuSeparatorAdded(const synthclone::MenuSeparator *separator,
                           synthclone::Menu menu, const QStringList &subMenus);

 
        void
        menuSeparatorAdded(const synthclone::MenuSeparator *separator,
                           const synthclone::Effect *effect,
                           const QStringList &subMenus);

 
        void
        menuSeparatorAdded(const synthclone::MenuSeparator *separator,
                           const synthclone::Sampler *sampler,
                           const QStringList &subMenus);

 
        void
        menuSeparatorAdded(const synthclone::MenuSeparator *separator,
                           const synthclone::Target *target,
                           const QStringList &subMenus);

 
        void
        menuSeparatorRemoved(const synthclone::MenuSeparator *separator,
                             synthclone::Menu menu,
                             const QStringList &subMenus);

 
        void
        menuSeparatorRemoved(const synthclone::MenuSeparator *separator,
                             const synthclone::Effect *effect,
                             const QStringList &subMenus);

 
        void
        menuSeparatorRemoved(const synthclone::MenuSeparator *separator,
                             const synthclone::Sampler *sampler,
                             const QStringList &subMenus);

 
        void
        menuSeparatorRemoved(const synthclone::MenuSeparator *separator,
                             const synthclone::Target *target,
                             const QStringList &subMenus);

 
        void
        movingEffect(const synthclone::Effect *effect, int fromIndex,
                     int toIndex);

 
        void
        movingEffectJob(const synthclone::EffectJob *job, int fromIndex,
                        int toIndex);

 
        void
        movingSamplerJob(const synthclone::SamplerJob *job, int fromIndex,
                         int toIndex);

 
        void
        movingTarget(const synthclone::Target *target, int fromIndex,
                     int toIndex);

 
        void
        movingZone(const synthclone::Zone *zone, int fromIndex, int toIndex);

 
        void
        notePropertyVisibilityChanged(bool visible);

 
        void
        participantActivated(const synthclone::Participant *participant,
                             const synthclone::Participant *parent,
                             const QByteArray &id);

 
        void
        participantAdded(const synthclone::Participant *participant,
                         const synthclone::Participant *parent,
                         const QByteArray &id);

 
        void
        participantDeactivated(const synthclone::Participant *participant,
                               const synthclone::Participant *parent,
                               const QByteArray &id);

 
        void
        participantRemoved(const synthclone::Participant *participant,
                           const synthclone::Participant *parent,
                           const QByteArray &id);

 
        void
        releaseTimePropertyVisibilityChanged(bool visible);

 
        void
        removingEffect(const synthclone::Effect *effect, int index);

 
        void
        removingEffectJob(const synthclone::EffectJob *job, int index);

 
        void
        removingMenuAction(const synthclone::MenuAction *action,
                           synthclone::Menu menu, const QStringList &subMenus);

 
        void
        removingMenuAction(const synthclone::MenuAction *action,
                           const synthclone::Effect *effect,
                           const QStringList &subMenus);

 
        void
        removingMenuAction(const synthclone::MenuAction *action,
                           const synthclone::Sampler *sampler,
                           const QStringList &subMenus);

 
        void
        removingMenuAction(const synthclone::MenuAction *action,
                           const synthclone::Target *target,
                           const QStringList &subMenus);

 
        void
        removingMenuSeparator(const synthclone::MenuSeparator *separator,
                              synthclone::Menu menu,
                              const QStringList &subMenus);

 
        void
        removingMenuSeparator(const synthclone::MenuSeparator *separator,
                              const synthclone::Effect *effect,
                              const QStringList &subMenus);

 
        void
        removingMenuSeparator(const synthclone::MenuSeparator *separator,
                              const synthclone::Sampler *sampler,
                              const QStringList &subMenus);

 
        void
        removingMenuSeparator(const synthclone::MenuSeparator *separator,
                              const synthclone::Target *target,
                              const QStringList &subMenus);

 
        void
        removingParticipant(const synthclone::Participant *participant,
                            const synthclone::Participant *parent,
                            const QByteArray &id);

 
        void
        removingSampler(const synthclone::Sampler *sampler);

 
        void
        removingSamplerJob(const synthclone::SamplerJob *job, int index);

 
        void
        removingTarget(const synthclone::Target *target, int index);

 
        void
        removingZone(const synthclone::Zone *zone, int index);

 
        void
        sampleChannelCountChanged(synthclone::SampleChannelCount count);

 
        void
        samplerAdded(const synthclone::Sampler *sampler);

 
        void
        sampleRateChanged(synthclone::SampleRate sampleRate);

 
        void
        samplerJobAdded(const synthclone::SamplerJob *job, int index);

 
        void
        samplerJobMoved(const synthclone::SamplerJob *job, int fromIndex,
                        int toIndex);

 
        void
        samplerJobRemoved(const synthclone::SamplerJob *job, int index);

 
        void
        samplerRemoved(const synthclone::Sampler *sampler);

 
        void
        sampleTimePropertyVisibilityChanged(bool visible);

 
        void
        selectedEffectChanged(const synthclone::Effect *effect, int index);

 
        void
        selectedTargetChanged(const synthclone::Target *target, int index);

 
        void
        sessionStateChanged(synthclone::SessionState state,
                            const QDir *directory);

 
        void
        statusPropertyVisibilityChanged(bool visible);

 
        void
        targetAdded(const synthclone::Target *target, int index);

 
        void
        targetBuildError(const synthclone::Target *target,
                         const QString &message);

 
        void
        targetBuilt(const synthclone::Target *target);

 
        void
        targetsBuilt();

 
        void
        targetMoved(const synthclone::Target *target, int fromIndex,
                    int toIndex);

 
        void
        targetRemoved(const synthclone::Target *target, int index);

 
        void
        velocityPropertyVisibilityChanged(bool visible);

 
        void
        wetSamplePropertyVisibilityChanged(bool visible);

 
        void
        zoneAdded(const synthclone::Zone *zone, int index);

 
        void
        zoneMoved(const synthclone::Zone *zone, int fromIndex, int toIndex);

 
        void
        zoneRemoved(const synthclone::Zone *zone, int index);

 
        void
        zoneSelectionChanged(const synthclone::Zone *zone, bool selected);
 
    protected:

 
        explicit
        Context(QObject *parent=0);

 
        virtual
        ~Context();
 
    };
 
}
 
#endif