SourceController.h

Go to the documentation of this file.

/*
 * Copyright 2014 Martin Hansen
 *
 * This file is part of SPAOP (Spatial Audio Object Positioner).
 * 
 * SPAOP 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 3 of the License, or
 * (at your option) any later version.
 * 
 * SPAOP 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 SPAOP.  If not, see <http://www.gnu.org/licenses/>.
 */

#ifndef SOURCECONTROLLER_H_INCLUDED
#define SOURCECONTROLLER_H_INCLUDED

#include <memory>

#include "SourceCollection.h"
#include "WonderHeader.h"
#include "ConnectionTimer.h"
#include "VisualStreamReceiver.h"
#include "OscSender.h"
#include "PingControl.h"
#include "XmlParser.h"
#include "Parsetools.h"

#define ABS(x) ((x) > 0 ? (x) : -(x))

namespace wonder {

class SourceController  :   VisualStreamReceiver::Listener,
                            VisualStreamReceiver::PingHandler,
                            PingControl::Listener
{
public:
    
    class Listener
    {
    public:
        virtual ~Listener() {}
        
        virtual void incomingParameterChange (Source::AutomatedParameters index,
                                              float newValue) = 0;
        
        virtual void incomingMaxNoSources(const int maxSources){}
        
        virtual void connectionLost () {}
    };

    SourceController(VisualStreamReceiver::Factory* vsFactory,
                     Listener* listener,
                     ConnectionTimer::Factory* timerFactory,
                     XmlParser* xmlParser,
                     int maxSources);
    
    virtual ~SourceController();
    
    const Source& getSource() const;
    
    std::shared_ptr<const SourceCollection> getSources() const;
    
    bool setSource(const Source &source);
    
    bool setID(int sourceID);
    
    void setParameterAndSendChange (int paramIndex, float normalizedValue);
    
    void setCoordinatesAndSendChange (float normalizedX, float normalizedY);
    
    void updateSourceName(const std::string& newSourceName);
    
    void updateSourceColour(const Colour colour);
    
    void setLinkedToWonder(bool linked, bool notifyPeers = true);
    
    bool isLinkedToWonder() const;
    
    bool setCWonderAddress(const std::string &ip, const std::string &port);
    
    std::string getCWonderHost() const;
    
    std::string getCWonderPort() const;
    
    void setIdIsLocked(bool isLocked);
    
    bool idIsLocked() const;

    ConnectionStates connectionStatus() const;
    
    std::string connectionStatusString() const;
    
    int rcvPort() const;
    
    const std::string getDataDestHostAndPort() const;
    
    std::shared_ptr<const Room> getRoom() const;
    
    void setRoom(const Room& room);

private:
    SourceController(const SourceController& other);            // copying not allowed
    SourceController &operator= (const SourceController other); // assignment not allowed
    
    std::unique_ptr<VisualStreamReceiver> server_;
    std::unique_ptr<OscSenderThread> cWonder_;      // cWONDER
    std::unique_ptr<OscSenderThread> mCaster_;      // the StreamMulticaster
    std::unique_ptr<OscSenderThread> peerGroup_;    // the multicast group
    
    XmlParser* xmlParser_;
    std::shared_ptr<SourceCollection> sources_;     // object might be share with a GUI
                                                    // that might be destructed after
                                                    // this object -> shared_ptr
    int sourceID_;
    std::shared_ptr<Room> room_;
    Listener* listener_;
    PingControl pingControl_;
    bool linkedToWonder_;               // is sending outgoing OSC messages to WONDER
    bool isLocked_;
    ConnectionStates cStatus_;
    float lastValues_[Source::totalNumParams];  // the last values of automated parameters
                                                // that were sent out (denormalized!)
    
    void setIncomingParameter (int sourceID, Source::AutomatedParameters index,
                               float unnormalizedValue);
    
    bool relevantChange(int index);
    
    OscSenderThread& dataDest() const;
    
    OscSenderThread& streamSource() const;
    
    void sendOwnState();
    
    //==============================================================================
    //vvvvv  Implementing ConnectionTimer::Listener
    
    void onTimeout();
    
    //==============================================================================
    //vvvvv  Implementing PingControl::Listener
    
    void connectionLost(const int connectionID);
    
    //==============================================================================
    //vvvvv  OSC-message-handlers implementing wonder::VisualStreamReceiver::Listener
    
    int onSourceActivate(int wondID);
    
    int onSourceDeactivate(int wondID);
    
    int onSourcePosition(int wondID, float xPos, float yPos);
    
    int onSourceAngle(int wondID, float angle);
    
    int onSourceType(int wondID, int type);
    
    int onSourceName(int wondID, const std::string& sourceName);
    
    int onSourceColor(int wondID, int r, int g, int b);
    
    int onSourceGroupId(int wondID, int groupID)
    { return 0; }
    
    int onSourceRotatingDirection(int wondID, int rotDir)
    { return 0; }
    
    int onSourceScalingDirection(int wondID, int scalDir)
    { return 0; }
    
    int onSourceDopplerEffect(int wondID, int doppler);
    
    int onListenerPosition(int listenerID, float x, float y)
    { return 0; }
    
    int onGlobalMaxNoSources(int maxSources);
    
    int onGlobalRenderpolygon(Room& room);
    
    int onProjectXmlDump(int err, const std::string& xmlDump);
    
    int onStreamVisualPing(int pingCount, OscSender* replyTo);
    
    int onStreamVisualPong(int pingCount){ return 0; }
    
    int onStreamVisualConnect(OscSender* replyTo);
    
    int onReply(std::string replyToMsg, int state, std::string msg);
    
    int onPluginStandalone(bool standAloneOn);

};
    
}


#endif  // SOURCECONTROLLER_H_INCLUDED