#include "surface.h"
#include "control_group.h"
+using namespace ArdourSurface;
using namespace Mackie;
Control*
#include "controls.h"
#include "led.h"
+namespace ArdourSurface {
+
namespace Mackie {
class Surface;
Led _led;
};
-}
+} // Mackie namespace
+} // ArdourSurface namespace
#endif
#include <vector>
+namespace ArdourSurface {
namespace Mackie {
class Control;
std::string _name;
};
+}
}
#endif
#include "meter.h"
-using namespace Mackie;
using namespace std;
+using namespace ArdourSurface;
+using namespace Mackie;
+
using ARDOUR::AutomationControl;
void Group::add (Control& control)
_in_use = in_use;
}
-ostream & Mackie::operator << (ostream & os, const Mackie::Control & control)
-{
- os << typeid (control).name();
- os << " { ";
- os << "name: " << control.name();
- os << ", ";
- os << "id: " << "0x" << setw(2) << setfill('0') << hex << control.id() << setfill(' ');
- os << ", ";
- os << "group: " << control.group().name();
- os << " }";
-
- return os;
-}
-
void
Control::set_control (boost::shared_ptr<AutomationControl> ac)
{
}
}
+ostream & operator << (ostream & os, const ArdourSurface::Mackie::Control & control)
+{
+ os << typeid (control).name();
+ os << " { ";
+ os << "name: " << control.name();
+ os << ", ";
+ os << "id: " << "0x" << setw(2) << setfill('0') << hex << control.id() << setfill(' ');
+ os << ", ";
+ os << "group: " << control.group().name();
+ os << " }";
+
+ return os;
+}
+
class AutomationControl;
}
-namespace Mackie
-{
+namespace ArdourSurface {
+
+namespace Mackie {
class Strip;
class Group;
class Surface;
-class Control
-{
+class Control {
public:
Control (int id, std::string name, Group& group);
virtual ~Control() {}
bool in_use () const;
void set_in_use (bool);
- /// Keep track of the timeout so it can be updated with more incoming events
+ // Keep track of the timeout so it can be updated with more incoming events
sigc::connection in_use_connection;
virtual MidiByteArray zero() = 0;
bool _in_use;
};
-std::ostream & operator << (std::ostream & os, const Control & control);
-
}
+}
+
+std::ostream & operator << (std::ostream & os, const ArdourSurface::Mackie::Control & control);
#endif /* __mackie_controls_h__ */
#include "i18n.h"
-using namespace Mackie;
using namespace PBD;
using namespace ARDOUR;
+using namespace ArdourSurface;
+using namespace Mackie;
+
using std::string;
using std::vector;
class XMLNode;
+namespace ArdourSurface {
+
namespace Mackie {
struct GlobalButtonInfo {
};
-}
+} // Mackie namespace
+} // ArdourSurface namespace
-std::ostream& operator<< (std::ostream& os, const Mackie::DeviceInfo& di);
+std::ostream& operator<< (std::ostream& os, const ArdourSurface::Mackie::DeviceInfo& di);
#endif /* __ardour_mackie_control_protocol_device_info_h__ */
#include "i18n.h"
-using namespace Mackie;
using namespace PBD;
using namespace ARDOUR;
+using namespace ArdourSurface;
+using namespace Mackie;
+
using std::string;
using std::vector;
class XMLNode;
+namespace ArdourSurface {
+
namespace Mackie {
class DeviceProfile
void save ();
};
+}
}
#endif /* __ardour_mackie_control_protocol_device_profile_h__ */
#include "control_group.h"
#include "mackie_control_protocol.h"
+using namespace ArdourSurface;
using namespace Mackie;
Control*
#include "controls.h"
+namespace ArdourSurface {
+
namespace Mackie {
class Fader : public Control
float position;
};
+}
}
#endif
#include "i18n.h"
using namespace std;
-using namespace Mackie;
using namespace Gtk;
+using namespace ArdourSurface;
+using namespace Mackie;
void*
MackieControlProtocol::get_gui () const
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
-
#include <gtkmm/comboboxtext.h>
#include <gtkmm/box.h>
#include <gtkmm/spinbutton.h>
class CellRendererCombo;
}
-class MackieControlProtocol;
-
#include "button.h"
#include "i18n.h"
+namespace ArdourSurface {
+
+class MackieControlProtocol;
+
class MackieControlProtocolGUI : public Gtk::Notebook
{
public:
void discover_clicked ();
};
+}
+
using namespace ARDOUR;
using namespace PBD;
using namespace std;
+using namespace ArdourSurface;
+using namespace Mackie;
static ControlProtocol*
new_mackie_protocol (ControlProtocolDescriptor*, Session* s)
#include "surface.h"
#include "control_group.h"
+using namespace ArdourSurface;
using namespace Mackie;
const int Jog::ID = 0x3c;
#include "controls.h"
#include "pot.h"
+namespace ArdourSurface {
namespace Mackie {
class Jog : public Pot
static Control* factory (Surface&, int id, const char*, Group&);
};
+}
}
#endif /* __ardour_mackie_control_protocol_jog_h__ */
#include <algorithm>
+using namespace ArdourSurface;
using namespace Mackie;
JogWheel::JogWheel (MackieControlProtocol & mcp)
#include <deque>
#include <queue>
+namespace ArdourSurface {
+
class MackieControlProtocol;
namespace Mackie
Mode _mode;
};
+}
}
#endif
#include "surface.h"
#include "control_group.h"
+using namespace ArdourSurface;
using namespace Mackie;
const int Led::FaderTouch = 0x70;
#include "midi_byte_array.h"
#include "types.h"
+namespace ArdourSurface {
+
namespace Mackie {
class Led : public Control
LedState state;
};
+}
}
#endif /* __ardour_mackie_control_protocol_led_h__ */
#include <stdexcept>
-namespace Mackie
-{
+namespace ArdourSurface {
+namespace Mackie {
class MackieControlException : public std::exception
{
std::string _msg;
};
+}
}
#endif
using namespace ARDOUR;
using namespace std;
-using namespace Mackie;
using namespace PBD;
using namespace Glib;
+using namespace ArdourSurface;
+using namespace Mackie;
#include "i18n.h"
}
gboolean
-ipmidi_input_handler (GIOChannel*, GIOCondition condition, void *data)
+ArdourSurface::ipmidi_input_handler (GIOChannel*, GIOCondition condition, void *data)
{
- MackieControlProtocol::ipMIDIHandler* ipm = static_cast<MackieControlProtocol::ipMIDIHandler*>(data);
+ ArdourSurface::MackieControlProtocol::ipMIDIHandler* ipm = static_cast<ArdourSurface::MackieControlProtocol::ipMIDIHandler*>(data);
return ipm->mcp->midi_input_handler (Glib::IOCondition (condition), ipm->port);
}
class Port;
}
+namespace ArdourSurface {
+
namespace Mackie {
class Surface;
class Control;
class Button;
}
+gboolean ipmidi_input_handler (GIOChannel*, GIOCondition condition, void *data);
+
/**
This handles the plugin duties, and the midi encoding and decoding,
and the signal callbacks, mostly from ARDOUR::Route.
MIDI::Port* port;
};
friend struct ipMIDIHandler; /* is this necessary */
- friend gboolean ipmidi_input_handler (GIOChannel*, GIOCondition condition, void *data);
+ friend gboolean ArdourSurface::ipmidi_input_handler (GIOChannel*, GIOCondition condition, void *data);
int create_surfaces ();
bool periodic();
Mackie::LedState view_release (Mackie::Button&);
};
+} // namespace
+
#endif // ardour_mackie_control_protocol_h
* mackie_control_protocol.cc
*/
-using namespace Mackie;
+using std::string;
using namespace ARDOUR;
using namespace PBD;
-using std::string;
+using namespace ArdourSurface;
+using namespace Mackie;
LedState
MackieControlProtocol::shift_press (Button &)
#include "surface_port.h"
#include "control_group.h"
-using namespace Mackie;
using namespace PBD;
+using namespace ArdourSurface;
+using namespace Mackie;
Control*
Meter::factory (Surface& surface, int id, const char* name, Group& group)
#include "controls.h"
#include "midi_byte_array.h"
+namespace ArdourSurface {
+
namespace Mackie {
class SurfacePort;
bool overload_on;
};
-}
+} // Mackie namespace
+} // ArdourSurface namespace
#endif /* __ardour_mackie_control_protocol_meter_h__ */
#include "surface.h"
#include "control_group.h"
+using namespace ArdourSurface;
using namespace Mackie;
int const Pot::External = 0x2e; /* specific ID for "vpot" representing external control */
#include "controls.h"
+namespace ArdourSurface {
+
namespace Mackie {
class Pot : public Control
};
+}
}
#endif /* __ardour_mackie_control_protocol_pot_h__ */
#include "jog.h"
#include "meter.h"
-using namespace Mackie;
using namespace std;
using namespace ARDOUR;
using namespace PBD;
+using namespace ArdourSurface;
+using namespace Mackie;
#ifndef timeradd /// only avail with __USE_BSD
#define timeradd(a,b,result) \
class ChannelCount;
}
+namespace ArdourSurface {
+
namespace Mackie {
class Control;
std::map<Evoral::Parameter,Control*> control_by_parameter;
};
+}
}
#endif /* __ardour_mackie_control_protocol_strip_h__ */
using namespace std;
using namespace PBD;
-using namespace Mackie;
using ARDOUR::Route;
using ARDOUR::Panner;
using ARDOUR::Pannable;
using ARDOUR::AutomationControl;
+using namespace ArdourSurface;
+using namespace Mackie;
#define ui_context() MackieControlProtocol::instance() /* a UICallback-derived object that specifies the event loop for signal handling */
}
class MidiByteArray;
+
+namespace ArdourSurface {
+
class MackieControlProtocol;
namespace Mackie
void master_gain_changed ();
};
+}
}
#endif
#include "i18n.h"
using namespace std;
-using namespace Mackie;
using namespace PBD;
using namespace ARDOUR;
+using namespace ArdourSurface;
+using namespace Mackie;
SurfacePort::SurfacePort (Surface& s)
: _surface (&s)
class Port;
}
-class MackieControlProtocol;
namespace ARDOUR {
class AsyncMIDIPort;
class Port;
}
+namespace ArdourSurface {
+
+class MackieControlProtocol;
+
namespace Mackie
{
std::ostream& operator << (std::ostream& , const SurfacePort& port);
+}
}
#endif
#include <sys/time.h>
#endif
+namespace ArdourSurface {
+
namespace Mackie
{
bool running;
};
-}
+} // Mackie namespace
+} // ArdourSurface namespace
#endif
#include "types.h"
-namespace Mackie
-{
+namespace ArdourSurface {
+
+namespace Mackie {
+
LedState on( LedState::on );
LedState off( LedState::off );
LedState flashing( LedState::flashing );
LedState none( LedState::none );
-std::ostream & operator << ( std::ostream & os, const ControlState & cs )
+}
+}
+
+std::ostream & operator << ( std::ostream & os, const ArdourSurface::Mackie::ControlState & cs )
{
os << "ControlState { ";
os << "pos: " << cs.pos;
return os;
}
-
-}
#include <iostream>
-namespace Mackie
-{
+namespace ArdourSurface {
+namespace Mackie {
enum surface_type_t {
mcu,
class Pot;
class Led;
+}
}
#endif