2008-06-02 17:41:35 -04:00
|
|
|
/*
|
|
|
|
Copyright (C) 2006,2007 John Anderson
|
|
|
|
|
|
|
|
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., 675 Mass Ave, Cambridge, MA 02139, USA.
|
|
|
|
*/
|
|
|
|
#ifndef mackie_controls_h
|
|
|
|
#define mackie_controls_h
|
|
|
|
|
|
|
|
#include <map>
|
|
|
|
#include <vector>
|
|
|
|
#include <string>
|
|
|
|
|
2009-12-19 15:26:31 -05:00
|
|
|
#include "pbd/signals.h"
|
2009-12-17 13:24:23 -05:00
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
#include "mackie_control_exception.h"
|
|
|
|
|
|
|
|
namespace Mackie
|
|
|
|
{
|
|
|
|
|
|
|
|
class Control;
|
|
|
|
|
|
|
|
/**
|
|
|
|
This is a loose group of controls, eg cursor buttons,
|
|
|
|
transport buttons, functions buttons etc.
|
|
|
|
*/
|
|
|
|
class Group
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
Group( const std::string & name )
|
|
|
|
: _name( name )
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
virtual ~Group() {}
|
|
|
|
|
|
|
|
virtual bool is_strip() const
|
|
|
|
{
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
virtual bool is_master() const
|
|
|
|
{
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
virtual void add( Control & control );
|
|
|
|
|
|
|
|
const std::string & name() const
|
|
|
|
{
|
|
|
|
return _name;
|
|
|
|
}
|
|
|
|
|
|
|
|
// This is for Surface only
|
|
|
|
void name( const std::string & rhs ) { _name = rhs; }
|
|
|
|
|
|
|
|
typedef std::vector<Control*> Controls;
|
|
|
|
const Controls & controls() const { return _controls; }
|
|
|
|
|
|
|
|
protected:
|
|
|
|
Controls _controls;
|
|
|
|
|
|
|
|
private:
|
|
|
|
std::string _name;
|
|
|
|
};
|
|
|
|
|
|
|
|
class Button;
|
|
|
|
class Pot;
|
|
|
|
class Fader;
|
|
|
|
|
|
|
|
/**
|
|
|
|
This is the set of controls that make up a strip.
|
|
|
|
*/
|
|
|
|
class Strip : public Group
|
|
|
|
{
|
|
|
|
public:
|
2008-12-12 17:55:03 -05:00
|
|
|
/**
|
|
|
|
\param is the index of the strip. 0-based.
|
|
|
|
*/
|
2008-06-02 17:41:35 -04:00
|
|
|
Strip( const std::string & name, int index );
|
|
|
|
|
|
|
|
virtual bool is_strip() const
|
|
|
|
{
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
virtual void add( Control & control );
|
|
|
|
|
2008-12-12 17:55:03 -05:00
|
|
|
/// This is the index of the strip. zero-based.
|
2008-06-02 17:41:35 -04:00
|
|
|
int index() const { return _index; }
|
|
|
|
|
|
|
|
/// This is for Surface only
|
2008-12-12 17:55:03 -05:00
|
|
|
/// index is zero-based
|
2008-06-02 17:41:35 -04:00
|
|
|
void index( int rhs ) { _index = rhs; }
|
|
|
|
|
|
|
|
Button & solo();
|
|
|
|
Button & recenable();
|
|
|
|
Button & mute();
|
|
|
|
Button & select();
|
|
|
|
Button & vselect();
|
|
|
|
Button & fader_touch();
|
|
|
|
Pot & vpot();
|
|
|
|
Fader & gain();
|
|
|
|
|
2008-12-12 17:55:03 -05:00
|
|
|
bool has_solo() const { return _solo != 0; }
|
|
|
|
bool has_recenable() const { return _recenable != 0; }
|
|
|
|
bool has_mute() const { return _mute != 0; }
|
|
|
|
bool has_select() const { return _select != 0; }
|
|
|
|
bool has_vselect() const { return _vselect != 0; }
|
|
|
|
bool has_fader_touch() const { return _fader_touch != 0; }
|
|
|
|
bool has_vpot() const { return _vpot != 0; }
|
|
|
|
bool has_gain() const { return _gain != 0; }
|
2008-06-02 17:41:35 -04:00
|
|
|
|
|
|
|
private:
|
|
|
|
Button * _solo;
|
|
|
|
Button * _recenable;
|
|
|
|
Button * _mute;
|
|
|
|
Button * _select;
|
|
|
|
Button * _vselect;
|
|
|
|
Button * _fader_touch;
|
|
|
|
Pot * _vpot;
|
|
|
|
Fader * _gain;
|
|
|
|
int _index;
|
|
|
|
};
|
|
|
|
|
2008-12-12 17:55:03 -05:00
|
|
|
std::ostream & operator << ( std::ostream &, const Strip & );
|
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
class MasterStrip : public Strip
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
MasterStrip( const std::string & name, int index )
|
|
|
|
: Strip( name, index )
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
virtual bool is_master() const
|
|
|
|
{
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
class Led;
|
|
|
|
|
|
|
|
/**
|
|
|
|
The base class for controls on the surface. They deliberately
|
|
|
|
don't know the midi protocol for updating them.
|
|
|
|
*/
|
|
|
|
class Control
|
|
|
|
{
|
|
|
|
public:
|
2008-12-12 17:55:03 -05:00
|
|
|
enum type_t { type_led, type_led_ring, type_fader = 0xe0, type_button = 0x90, type_pot = 0xb0 };
|
2008-06-02 17:41:35 -04:00
|
|
|
|
2008-12-12 17:55:03 -05:00
|
|
|
Control( int id, int ordinal, std::string name, Group & group );
|
2008-06-02 17:41:35 -04:00
|
|
|
virtual ~Control() {}
|
|
|
|
|
|
|
|
virtual const Led & led() const
|
|
|
|
{
|
|
|
|
throw MackieControlException( "no led available" );
|
|
|
|
}
|
|
|
|
|
2008-12-12 17:55:03 -05:00
|
|
|
/// type() << 8 + midi id of the control. This
|
|
|
|
/// provides a unique id for any control on the surface.
|
2008-06-02 17:41:35 -04:00
|
|
|
int id() const
|
|
|
|
{
|
2008-12-12 17:55:03 -05:00
|
|
|
return ( type() << 8 ) + _id;
|
2008-06-02 17:41:35 -04:00
|
|
|
}
|
|
|
|
|
2008-12-12 17:55:03 -05:00
|
|
|
/// the value of the second bytes of the message. It's
|
|
|
|
/// the id of the control, but only guaranteed to be
|
|
|
|
/// unique within the control type.
|
|
|
|
int raw_id() const { return _id; }
|
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
/// The 1-based number of the control
|
2008-12-12 17:55:03 -05:00
|
|
|
int ordinal() const { return _ordinal; }
|
2008-06-02 17:41:35 -04:00
|
|
|
|
|
|
|
const std::string & name() const
|
|
|
|
{
|
|
|
|
return _name;
|
|
|
|
}
|
|
|
|
|
|
|
|
const Group & group() const
|
|
|
|
{
|
|
|
|
return _group;
|
|
|
|
}
|
|
|
|
|
|
|
|
const Strip & strip() const
|
|
|
|
{
|
|
|
|
return dynamic_cast<const Strip&>( _group );
|
|
|
|
}
|
|
|
|
|
|
|
|
Strip & strip()
|
|
|
|
{
|
|
|
|
return dynamic_cast<Strip&>( _group );
|
|
|
|
}
|
|
|
|
|
|
|
|
virtual bool accepts_feedback() const
|
|
|
|
{
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
virtual type_t type() const = 0;
|
|
|
|
|
2008-12-12 17:55:03 -05:00
|
|
|
/// Return true if this control is the one and only Jog Wheel
|
|
|
|
virtual bool is_jog() const { return false; }
|
|
|
|
|
|
|
|
/**
|
2011-05-04 05:21:20 -04:00
|
|
|
Return true if the control is in use, or false otherwise. For buttons
|
2008-12-12 17:55:03 -05:00
|
|
|
this returns true if the button is currently being held down. For
|
|
|
|
faders, the touch button has not been released. For pots, this returns
|
|
|
|
true from the first move event until a timeout after the last move event.
|
|
|
|
*/
|
|
|
|
virtual bool in_use() const;
|
|
|
|
virtual Control & in_use( bool );
|
|
|
|
|
|
|
|
/// The timeout value for this control. Normally defaulted to 250ms, but
|
|
|
|
/// certain controls (ie jog wheel) may want to override it.
|
|
|
|
virtual unsigned int in_use_timeout() { return _in_use_timeout; }
|
|
|
|
|
|
|
|
/// Keep track of the timeout so it can be updated with more incoming events
|
2009-12-20 11:49:55 -05:00
|
|
|
sigc::connection in_use_connection;
|
2008-12-12 17:55:03 -05:00
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
private:
|
|
|
|
int _id;
|
|
|
|
int _ordinal;
|
|
|
|
std::string _name;
|
|
|
|
Group & _group;
|
2008-12-12 17:55:03 -05:00
|
|
|
bool _in_use;
|
|
|
|
unsigned int _in_use_timeout;
|
2008-06-02 17:41:35 -04:00
|
|
|
};
|
|
|
|
|
|
|
|
std::ostream & operator << ( std::ostream & os, const Control & control );
|
|
|
|
|
|
|
|
class Fader : public Control
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
Fader( int id, int ordinal, std::string name, Group & group )
|
|
|
|
: Control( id, ordinal, name, group )
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
virtual type_t type() const { return type_fader; }
|
|
|
|
};
|
|
|
|
|
|
|
|
class Led : public Control
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
Led( int id, int ordinal, std::string name, Group & group )
|
|
|
|
: Control( id, ordinal, name, group )
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
virtual const Led & led() const { return *this; }
|
|
|
|
|
|
|
|
virtual type_t type() const { return type_led; }
|
|
|
|
};
|
|
|
|
|
|
|
|
class Button : public Control
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
Button( int id, int ordinal, std::string name, Group & group )
|
|
|
|
: Control( id, ordinal, name, group )
|
|
|
|
, _led( id, ordinal, name + "_led", group )
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
virtual const Led & led() const
|
|
|
|
{
|
|
|
|
return _led;
|
|
|
|
}
|
|
|
|
|
|
|
|
virtual type_t type() const { return type_button; };
|
2008-12-12 17:55:03 -05:00
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
private:
|
|
|
|
Led _led;
|
|
|
|
};
|
|
|
|
|
|
|
|
class LedRing : public Led
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
LedRing( int id, int ordinal, std::string name, Group & group )
|
|
|
|
: Led( id, ordinal, name, group )
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
virtual type_t type() const { return type_led_ring; }
|
|
|
|
};
|
|
|
|
|
|
|
|
class Pot : public Control
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
Pot( int id, int ordinal, std::string name, Group & group )
|
|
|
|
: Control( id, ordinal, name, group )
|
|
|
|
, _led_ring( id, ordinal, name + "_ring", group )
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
virtual type_t type() const { return type_pot; }
|
|
|
|
|
|
|
|
virtual const LedRing & led_ring() const
|
|
|
|
{
|
|
|
|
return _led_ring;
|
|
|
|
}
|
|
|
|
|
|
|
|
private:
|
|
|
|
LedRing _led_ring;
|
|
|
|
};
|
|
|
|
|
2008-12-12 17:55:03 -05:00
|
|
|
class Jog : public Pot
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
Jog( int id, int ordinal, std::string name, Group & group )
|
|
|
|
: Pot( id, ordinal, name, group )
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
virtual bool is_jog() const { return true; }
|
|
|
|
};
|
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
#endif
|