controllable.h

Go to the documentation of this file.

/*
 * Copyright (C) 2006-2017 Paul Davis <paul@linuxaudiosystems.com>
 * Copyright (C) 2008-2009 David Robillard <d@drobilla.net>
 * Copyright (C) 2009-2012 Carl Hetherington <carl@carlh.net>
 * Copyright (C) 2014 Ben Loftis <ben@harrisonconsoles.com>
 * Copyright (C) 2015-2019 Robin Gareus <robin@gareus.org>
 *
 * 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.
 *
 * 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.
 */
 
#pragma once
 
#include <memory>
#include <string>
#include <set>
 
#include "pbd/libpbd_visibility.h"
#include "pbd/rwlock.h"
#include "pbd/signals.h"
 
#include "pbd/statefuldestructible.h"
 
class XMLNode;
 
namespace PBD {
 
class Controllable;
typedef std::set<std::shared_ptr<Controllable>> ControllableSet;
 
class LIBPBD_API Controllable : public PBD::StatefulDestructible, public std::enable_shared_from_this<Controllable>
{
public:
        enum Flag {
                Toggle         = 0x01,
                GainLike       = 0x02,
                RealTime       = 0x04,
                NotAutomatable = 0x08,
                InlineControl  = 0x10,
                HiddenControl  = 0x20,
                MonitorControl = 0x40,
        };
 
        Controllable (const std::string& name, Flag f = Flag (0));
 
        enum GroupControlDisposition {
                InverseGroup,  
                NoGroup,       
                UseGroup,      
                ForGroup       
        };
 
        virtual void set_value (double value, GroupControlDisposition group_override) = 0;
 
        virtual double get_value (void) const = 0;
 
        virtual double get_save_value () const { return get_value(); }
 
        virtual double internal_to_interface (double i, bool rotary = false) const {
                /* by default, the interface range is just a linear
                 * interpolation between lower and upper values */
                return  (i-lower())/(upper() - lower());
        }
 
        virtual double interface_to_internal (double i, bool rotary = false) const {
                return lower() + i*(upper() - lower());
        }
 
        virtual float get_interface(bool rotary=false) const { return (internal_to_interface(get_value(), rotary)); }
 
        virtual void set_interface (float fraction, bool rotary=false, GroupControlDisposition gcd = NoGroup);
 
        virtual std::string get_user_string() const { return std::string(); }
 
        virtual float numeric_entry_convert (float, bool to_user_value);
 
        PBD::Signal<void()> LearningFinished;
 
        static PBD::Signal<bool(std::weak_ptr<PBD::Controllable> )> StartLearning;
        static PBD::Signal<void(std::weak_ptr<PBD::Controllable> )> StopLearning;
 
        static PBD::Signal<void(std::weak_ptr<PBD::Controllable> )> GUIFocusChanged;
        static PBD::Signal<void(std::weak_ptr<PBD::Controllable> )> ControlTouched;
 
        PBD::Signal<void(bool,PBD::Controllable::GroupControlDisposition)> Changed;
 
        int set_state (const XMLNode&, int version);
        virtual XMLNode& get_state () const;
 
        std::string name() const { return _name; }
 
        bool touching () const { return _touching; }
        PBD::Signal<void()> TouchChanged;
 
        bool is_toggle() const { return _flags & Toggle; }
        bool is_gain_like() const { return _flags & GainLike; }
 
        virtual double lower() const { return 0.0; }
        virtual double upper() const { return 1.0; }
        virtual double normal() const { return 0.0; }  //the default value
 
        Flag flags() const { return _flags; }
        void set_flags (Flag f);
 
        void set_flag (Flag f); 
        void clear_flag (Flag f); 
 
        static std::shared_ptr<Controllable> by_id (const PBD::ID&);
        static void dump_registry ();
        static ControllableSet registered_controllables ();
 
        static const std::string xml_node_name;
 
protected:
        void set_touching (bool yn) {
                if (_touching == yn) { return; }
                _touching = yn;
                TouchChanged (); /* EMIT SIGNAL */
        }
 
        std::function<float (float, bool)> _numeric_entry_convert;
 
private:
        std::string _name;
        std::string _units;
        Flag        _flags;
        bool        _touching;
 
 
        typedef std::set<PBD::Controllable*> Controllables;
 
        static ScopedConnectionList registry_connections;
        static PBD::RWLock registry_lock;
        static Controllables registry;
 
        static void add (Controllable&);
        static void remove (Controllable*);
};
 
}