conf.CheckLib ('FLAC', 'FLAC__stream_decoder_new')
libraries['flac'] = conf.Finish ()
+#
+# Check for UUID stuff
+
+libraries['uuid'] = LibraryInfo ()
+
+conf = Configure (libraries['uuid'])
+conf.CheckLib ('uuid', 'uuid_generate')
+libraries['uuid'] = conf.Finish ()
+
#
# Check for liblo
libraries['gdkmm2'],
libraries['sigc2'],
libraries['gtk2'],
+ libraries['uuid'],
libraries['xml'],
libraries['xslt'],
libraries['soundtouch'],
export ARDOUR_PATH=./glade:./pixmaps:.
-export LD_LIBRARY_PATH=../libs/surfaces/control_protocol:../libs/ardour:../libs/midi++2:../libs/pbd3:../libs/soundtouch:../libs/gtkmm2ext:../libs/sigc++2:../libs/glibmm2:../libs/gtkmm2/atk:../libs/gtkmm2/pango:../libs/gtkmm2/gdk:../libs/gtkmm2/gtk:../libs/libgnomecanvasmm:../libs/libsndfile:$LD_LIBRARY_PATH
+export LD_LIBRARY_PATH=../libs/surfaces/control_protocol:../libs/ardour:../libs/midi++2:../libs/pbd:../libs/soundtouch:../libs/gtkmm2ext:../libs/sigc++2:../libs/glibmm2:../libs/gtkmm2/atk:../libs/gtkmm2/pango:../libs/gtkmm2/gdk:../libs/gtkmm2/gtk:../libs/libgnomecanvasmm:../libs/libsndfile:$LD_LIBRARY_PATH
# DYLD_LIBRARY_PATH is for darwin.
export DYLD_LIBRARY_PATH=$LD_LIBRARY_PATH
if (session && session->dirty()) {
switch (ask_about_saving_session(_("quit"))) {
case -1:
+ cerr << "dialog return -1\n";
return;
break;
case 1:
+ cerr << "dialog return +1\n";
/* use the default name */
if (save_state_canfail ("")) {
/* failed - don't quit */
}
break;
case 0:
+ cerr << "dialog return 0\n";
break;
+ default:
+ cerr << "dialog return other\n";
}
}
Config->save_state();
}
void
-ARDOUR_UI::toggle_monitor_enable (guint32 dstream)
+ARDOUR_UI::toggle_record_enable (uint32_t dstream)
{
if (session == 0) {
return;
}
- AudioDiskstream *ds;
-
- if ((ds = session->diskstream_by_id (dstream)) != 0) {
- Port *port = ds->io()->input (0);
- port->request_monitor_input (!port->monitoring_input());
- }
-}
-
-void
-ARDOUR_UI::toggle_record_enable (guint32 dstream)
-{
- if (session == 0) {
- return;
- }
+ Route* r;
+
+ if ((r = session->route_by_remote_id (dstream)) != 0) {
- AudioDiskstream *ds;
+ AudioTrack* at;
- if ((ds = session->diskstream_by_id (dstream)) != 0) {
- ds->set_record_enabled (!ds->record_enabled(), this);
+ if ((at = dynamic_cast<AudioTrack*>(r)) != 0) {
+ at->disk_stream().set_record_enabled (!at->disk_stream().record_enabled(), this);
+ }
}
}
}
}
-
-void
-ARDOUR_UI::add_diskstream_to_menu (AudioDiskstream& dstream)
-{
- using namespace Gtk;
- using namespace Menu_Helpers;
-
- if (dstream.hidden()) {
- return;
- }
-
- MenuList& items = diskstream_menu->items();
- items.push_back (MenuElem (dstream.name(), bind (mem_fun(*this, &ARDOUR_UI::diskstream_selected), (gint32) dstream.id())));
-}
-
-void
-ARDOUR_UI::diskstream_selected (gint32 id)
-{
- selected_dstream = id;
- Main::quit ();
-}
-
-gint32
-ARDOUR_UI::select_diskstream (GdkEventButton *ev)
-{
- using namespace Gtk;
- using namespace Menu_Helpers;
-
- if (session == 0) {
- return -1;
- }
-
- diskstream_menu = new Menu();
- diskstream_menu->set_name ("ArdourContextMenu");
- using namespace Gtk;
- using namespace Menu_Helpers;
-
- MenuList& items = diskstream_menu->items();
- items.push_back (MenuElem (_("No Stream"), (bind (mem_fun(*this, &ARDOUR_UI::diskstream_selected), -1))));
-
- session->foreach_audio_diskstream (this, &ARDOUR_UI::add_diskstream_to_menu);
-
- if (ev) {
- diskstream_menu->popup (ev->button, ev->time);
- } else {
- diskstream_menu->popup (0, 0);
- }
-
- selected_dstream = -1;
-
- Main::run ();
-
- delete diskstream_menu;
-
- return selected_dstream;
-}
-
void
ARDOUR_UI::name_io_setup (AudioEngine& engine,
string& buf,
void toggle_tempo_window ();
void toggle_editing_space();
- gint32 select_diskstream (GdkEventButton *ev);
-
Gtk::Tooltips& tooltips() { return _tooltips; }
static sigc::signal<void,bool> Blink;
void save_template ();
-
void session_add_audio_route (bool disk, int32_t input_channels, int32_t output_channels, ARDOUR::TrackMode mode);
- void add_diskstream_to_menu (ARDOUR::AudioDiskstream&);
- void diskstream_selected (gint32);
- Gtk::Menu *diskstream_menu;
- gint32 selected_dstream;
-
void set_transport_sensitivity (bool);
void remove_last_capture ();
void test_binding_action (const char *);
void start_keyboard_prefix();
- void toggle_record_enable (guint32);
- void toggle_monitor_enable (guint32);
+ void toggle_record_enable (uint32_t);
uint32_t rec_enabled_diskstreams;
void count_recenabled_diskstreams (ARDOUR::AudioDiskstream&);
#include <pbd/stl_delete.h>
#include <pbd/whitespace.h>
-#include <gtkmm2ext/bindable_button.h>
#include <gtkmm2ext/gtk_ui.h>
#include <gtkmm2ext/selector.h>
#include <gtkmm2ext/stop_signal.h>
+#include <gtkmm2ext/bindable_button.h>
#include <gtkmm2ext/utils.h>
#include <ardour/audioplaylist.h>
ignore_toggle = false;
- rec_enable_button->set_active (false);
mute_button->set_active (false);
solo_button->set_active (false);
- rec_enable_button->set_name ("TrackRecordEnableButton");
mute_button->set_name ("TrackMuteButton");
solo_button->set_name ("SoloButton");
edit_group_button.set_name ("TrackGroupButton");
solo_button->signal_button_press_event().connect (mem_fun (*this, &AudioTimeAxisView::select_me), false);
mute_button->signal_button_press_event().connect (mem_fun (*this, &AudioTimeAxisView::select_me), false);
- rec_enable_button->signal_button_press_event().connect (mem_fun (*this, &AudioTimeAxisView::select_me), false);
playlist_button.signal_button_press_event().connect (mem_fun (*this, &AudioTimeAxisView::select_me), false);
automation_button.signal_button_press_event().connect (mem_fun (*this, &AudioTimeAxisView::select_me), false);
size_button.signal_button_press_event().connect (mem_fun (*this, &AudioTimeAxisView::select_me), false);
solo_button->signal_button_release_event().connect (mem_fun(*this, &RouteUI::solo_release), false);
mute_button->signal_button_press_event().connect (mem_fun(*this, &RouteUI::mute_press), false);
mute_button->signal_button_release_event().connect (mem_fun(*this, &RouteUI::mute_release), false);
- rec_enable_button->signal_button_press_event().connect (mem_fun(*this, &RouteUI::rec_enable_press));
edit_group_button.signal_button_release_event().connect (mem_fun(*this, &AudioTimeAxisView::edit_click), false);
playlist_button.signal_clicked().connect (mem_fun(*this, &AudioTimeAxisView::playlist_click));
automation_button.signal_clicked().connect (mem_fun(*this, &AudioTimeAxisView::automation_click));
hide_button.signal_clicked().connect (mem_fun(*this, &AudioTimeAxisView::hide_click));
if (is_audio_track()) {
+ rec_enable_button->set_active (false);
+ rec_enable_button->set_name ("TrackRecordEnableButton");
+ rec_enable_button->signal_button_press_event().connect (mem_fun (*this, &AudioTimeAxisView::select_me), false);
+ rec_enable_button->signal_button_press_event().connect (mem_fun(*this, &RouteUI::rec_enable_press));
controls_table.attach (*rec_enable_button, 5, 6, 0, 1, Gtk::FILL|Gtk::EXPAND, Gtk::FILL|Gtk::EXPAND, 0, 0);
+ ARDOUR_UI::instance()->tooltips().set_tip(*rec_enable_button, _("Record"));
}
+
controls_table.attach (*mute_button, 6, 7, 0, 1, Gtk::FILL|Gtk::EXPAND, Gtk::FILL|Gtk::EXPAND, 0, 0);
controls_table.attach (*solo_button, 7, 8, 0, 1, Gtk::FILL|Gtk::EXPAND, Gtk::FILL|Gtk::FILL|Gtk::EXPAND, 0, 0);
controls_table.attach (edit_group_button, 6, 7, 1, 2, Gtk::FILL|Gtk::EXPAND, Gtk::FILL|Gtk::EXPAND, 0, 0);
- ARDOUR_UI::instance()->tooltips().set_tip(*rec_enable_button, _("Record"));
ARDOUR_UI::instance()->tooltips().set_tip(*solo_button,_("Solo"));
ARDOUR_UI::instance()->tooltips().set_tip(*mute_button,_("Mute"));
ARDOUR_UI::instance()->tooltips().set_tip(edit_group_button,_("Edit Group"));
ENSURE_GUI_THREAD (mem_fun(*this, &AudioTimeAxisView::map_frozen));
-
switch (audio_track()->freeze_state()) {
case AudioTrack::Frozen:
playlist_button.set_sensitive (false);
#include <gtkmm2ext/click_box.h>
#include <gtkmm2ext/dndtreeview.h>
-#include <ardour/stateful.h>
+#include <pbd/stateful.h>
#include <ardour/session.h>
#include <ardour/tempo.h>
#include <ardour/location.h>
gain_slider = manage (new VSliderController (slider, rail,
&gain_adjustment,
- & _io.midi_gain_control(),
+ _io.gain_control(),
false));
gain_slider->signal_button_press_event().connect (mem_fun(*this, &GainMeter::start_gain_touch));
gain_slider->signal_button_release_event().connect (mem_fun(*this, &GainMeter::end_gain_touch));
gain_slider->set_name ("MixerGainMeter");
- if (_session.midi_port()) {
- _io.set_midi_to_gain_function (slider_position_to_gain);
- _io.set_gain_to_midi_function (gain_to_slider_position);
- }
-
gain_display.set_print_func (_gain_printer, this);
gain_display_box.set_spacing (2);
#include <ardour/types.h>
-#include <gtkmm2ext/slider_controller.h>
#include <gtkmm2ext/click_box.h>
+#include <gtkmm2ext/slider_controller.h>
#include "enums.h"
#include <gtk/gtk.h>
#include <ardour/types.h>
-#include <ardour/stateful.h>
+#include <pbd/stateful.h>
#include "selection.h"
#include <gtkmm2ext/gtk_ui.h>
#include <gtkmm2ext/utils.h>
#include <gtkmm2ext/choice.h>
-#include <gtkmm2ext/slider_controller.h>
#include <gtkmm2ext/stop_signal.h>
-#include <gtkmm2ext/bindable_button.h>
#include <gtkmm2ext/doi.h>
+#include <gtkmm2ext/slider_controller.h>
+#include <gtkmm2ext/bindable_button.h>
#include <ardour/ardour.h>
#include <ardour/session.h>
#include "keyboard.h"
#include "plugin_selector.h"
#include "public_editor.h"
-
#include "plugin_ui.h"
#include "send_ui.h"
#include "io_selector.h"
/* XXX what is this meant to do? */
//meter_point_button.signal_button_release_event().connect (mem_fun (gpm, &GainMeter::meter_release), false);
- rec_enable_button->set_name ("MixerRecordEnableButton");
- rec_enable_button->unset_flags (Gtk::CAN_FOCUS);
-
solo_button->set_name ("MixerSoloButton");
mute_button->set_name ("MixerMuteButton");
if (is_audio_track()) {
+ rec_enable_button->set_name ("MixerRecordEnableButton");
+ rec_enable_button->unset_flags (Gtk::CAN_FOCUS);
+ rec_enable_button->signal_button_press_event().connect (mem_fun(*this, &RouteUI::rec_enable_press));
+
AudioTrack* at = dynamic_cast<AudioTrack*>(&_route);
at->FreezeChange.connect (mem_fun(*this, &MixerStrip::map_frozen));
input_button.signal_button_press_event().connect (mem_fun(*this, &MixerStrip::input_press), false);
output_button.signal_button_press_event().connect (mem_fun(*this, &MixerStrip::output_press), false);
- rec_enable_button->signal_button_press_event().connect (mem_fun(*this, &RouteUI::rec_enable_press));
solo_button->signal_button_press_event().connect (mem_fun(*this, &RouteUI::solo_press), false);
solo_button->signal_button_release_event().connect (mem_fun(*this, &RouteUI::solo_release), false);
mute_button->signal_button_press_event().connect (mem_fun(*this, &RouteUI::mute_press), false);
set_size_request (-1, -1);
xml_node->add_property ("strip_width", "wide");
- rec_enable_button->set_label (_("record"));
+ if (rec_enable_button) {
+ rec_enable_button->set_label (_("record"));
+ }
mute_button->set_label (_("mute"));
solo_button->set_label (_("solo"));
set_size_request (50, -1);
xml_node->add_property ("strip_width", "narrow");
- rec_enable_button->set_label (_("Rec"));
+ if (rec_enable_button) {
+ rec_enable_button->set_label (_("Rec"));
+ }
mute_button->set_label (_("M"));
solo_button->set_label (_("S"));
MixerStrip::engine_stopped ()
{
input_button.set_sensitive (false);
- rec_enable_button->set_sensitive (false);
+ if (rec_enable_button) {
+ rec_enable_button->set_sensitive (false);
+ }
output_button.set_sensitive (false);
}
MixerStrip::engine_running ()
{
input_button.set_sensitive (true);
- rec_enable_button->set_sensitive (true);
+ if (rec_enable_button) {
+ rec_enable_button->set_sensitive (true);
+ }
output_button.set_sensitive (true);
}
#include <gtkmm/adjustment.h>
#include <gtkmm2ext/auto_spin.h>
-#include <gtkmm2ext/slider_controller.h>
#include <gtkmm2ext/click_box.h>
+#include <gtkmm2ext/slider_controller.h>
+
+#include <pbd/stateful.h>
#include <ardour/types.h>
#include <ardour/ardour.h>
#include <ardour/io.h>
#include <ardour/insert.h>
-#include <ardour/stateful.h>
#include <ardour/redirect.h>
#include <pbd/fastlog.h>
#include <gtkmm/menu.h>
#include <gtkmm/treeview.h>
+#include <pbd/stateful.h>
+
#include <ardour/ardour.h>
-#include <ardour/stateful.h>
#include <ardour/io.h>
#include "keyboard_target.h"
_io.panner()[asz]->Changed.connect (bind (mem_fun(*this, &PannerUI::pan_value_changed), (uint32_t) asz));
bc = new BarController (*pan_adjustments[asz],
- &_io.panner()[asz]->midi_control(),
+ _io.panner()[asz]->control(),
bind (mem_fun(*this, &PannerUI::pan_printer), pan_adjustments[asz]));
- if (_session.midi_port()) {
- _io.panner()[asz]->reset_midi_control (_session.midi_port(), true);
- }
-
bc->set_name ("PanSlider");
bc->set_shadow_type (Gtk::SHADOW_NONE);
bc->set_style (BarController::Line);
#include <gtkmm/togglebutton.h>
#include <gtkmm/button.h>
-#include <gtkmm2ext/slider_controller.h>
#include <gtkmm2ext/click_box.h>
+#include <gtkmm2ext/slider_controller.h>
#include "enums.h"
if ((x = dspl_map.find (apl->get_orig_diskstream_id())) == dspl_map.end()) {
- pair<
ARDOUR::id_t,list<Playlist*>*> newp (apl->get_orig_diskstream_id(), new list<Playlist*>);
+ pair<
PBD::ID,list<Playlist*>*> newp (apl->get_orig_diskstream_id(), new list<Playlist*>);
x = dspl_map.insert (dspl_map.end(), newp);
}
void show_for (RouteUI*);
private:
- typedef std::map<
ARDOUR::id_t,std::list<ARDOUR::Playlist*>*> DSPL_Map;
+ typedef std::map<
PBD::ID,std::list<ARDOUR::Playlist*>*> DSPL_Map;
ARDOUR::Session* session;
Gtk::ScrolledWindow scroller;
#include <gtkmm2ext/click_box.h>
#include <gtkmm2ext/fastmeter.h>
-#include <gtkmm2ext/slider_controller.h>
#include <gtkmm2ext/barcontroller.h>
#include <gtkmm2ext/utils.h>
#include <gtkmm2ext/doi.h>
+#include <gtkmm2ext/slider_controller.h>
#include <midi++/manager.h>
}
}
- if ((cui = build_control_ui (engine, i, plugin.get_nth_midi_control (i))) == 0) {
+ if ((cui = build_control_ui (engine, i, plugin.get_nth_control (i))) == 0) {
error << string_compose(_("Plugin Editor: could not build control element for port %1"), i) << endmsg;
continue;
}
}
PluginUI::ControlUI*
-PluginUI::build_control_ui (AudioEngine &engine, guint32 port_index, MIDI::Controllable* mcontrol)
+PluginUI::build_control_ui (AudioEngine &engine, guint32 port_index, PBD::Controllable* mcontrol)
{
ControlUI* control_ui;
} else {
sigc::slot<void,char*,uint32_t> pslot = sigc::bind (mem_fun(*this, &PluginUI::print_parameter), (uint32_t) port_index);
- control_ui->control = new BarController (*control_ui->adjustment, mcontrol, pslot);
+ control_ui->control = new BarController (*control_ui->adjustment, *mcontrol, pslot);
// should really match the height of the text in the automation button+label
control_ui->control->set_size_request (200, 22);
control_ui->control->set_name (X_("PluginSlider"));
class Redirect;
}
-namespace MIDI {
+namespace PBD {
class Controllable;
}
void output_update();
void build (ARDOUR::AudioEngine &);
- ControlUI* build_control_ui (ARDOUR::AudioEngine &, guint32 port_index, MIDI::Controllable *);
+ ControlUI* build_control_ui (ARDOUR::AudioEngine &, guint32 port_index, PBD::Controllable *);
std::vector<string> setup_scale_values(guint32 port_index, ControlUI* cui);
void control_adjustment_changed (ControlUI* cui);
void parameter_changed (uint32_t, float, ControlUI* cui);
#include <gtkmm2ext/click_box.h>
#include <gtkmm2ext/dndtreeview.h>
+#include <pbd/stateful.h>
+
#include <ardour/types.h>
#include <ardour/ardour.h>
#include <ardour/io.h>
#include <ardour/insert.h>
-#include <ardour/stateful.h>
#include <ardour/redirect.h>
#include <pbd/fastlog.h>
#include <gtkmm/togglebutton.h>
#include <gtkmm/treeview.h>
+#include <pbd/stateful.h>
+
#include <ardour/ardour.h>
-#include <ardour/stateful.h>
#include <ardour/io.h>
#include <ardour/redirect.h>
#include <gtkmm2ext/gtk_ui.h>
#include <gtkmm2ext/stop_signal.h>
#include <gtkmm2ext/choice.h>
-#include <gtkmm2ext/bindable_button.h>
#include <gtkmm2ext/doi.h>
+#include <gtkmm2ext/bindable_button.h>
#include <ardour/route_group.h>
_route.GoingAway.connect (mem_fun (*this, &RouteUI::route_removed));
_route.active_changed.connect (mem_fun (*this, &RouteUI::route_active_changed));
- mute_button = manage (new BindableToggleButton (& _route.midi_mute_control(), m_name ));
- mute_button->set_bind_button_state (2, GDK_CONTROL_MASK);
- solo_button = manage (new BindableToggleButton (& _route.midi_solo_control(), s_name ));
- solo_button->set_bind_button_state (2, GDK_CONTROL_MASK);
-
+ mute_button = manage (new BindableToggleButton (_route.mute_control(), m_name ));
+ solo_button = manage (new BindableToggleButton (_route.solo_control(), s_name ));
+
if (is_audio_track()) {
AudioTrack* at = dynamic_cast<AudioTrack*>(&_route);
_session.RecordStateChanged.connect (mem_fun (*this, &RouteUI::session_rec_enable_changed));
- rec_enable_button = manage (new BindableToggleButton (& at->midi_rec_enable_control(), r_name ));
- rec_enable_button->set_bind_button_state (2, GDK_CONTROL_MASK);
+ rec_enable_button = manage (new BindableToggleButton (at->rec_enable_control(), r_name ));
- } else {
- rec_enable_button = manage (new BindableToggleButton (0, r_name ));
- }
+ rec_enable_button->unset_flags (Gtk::CAN_FOCUS);
+
+ update_rec_display ();
+ }
mute_button->unset_flags (Gtk::CAN_FOCUS);
solo_button->unset_flags (Gtk::CAN_FOCUS);
- rec_enable_button->unset_flags (Gtk::CAN_FOCUS);
/* map the current state */
- update_rec_display ();
map_frozen ();
}
gint
RouteUI::rec_enable_press(GdkEventButton* ev)
{
- if (!ignore_toggle && is_audio_track()) {
+ if (!ignore_toggle && is_audio_track() && rec_enable_button) {
if (ev->button == 2 && Keyboard::modifier_state_equals (ev->state, Keyboard::Control)) {
// do nothing on midi bind event
check->show_all();
items.push_back (SeparatorElem());
- items.push_back (MenuElem (_("MIDI Bind"), mem_fun (*mute_button, &BindableToggleButton::midi_learn)));
+ // items.push_back (MenuElem (_("MIDI Bind"), mem_fun (*mute_button, &BindableToggleButton::midi_learn)));
}
check->show_all();
items.push_back (SeparatorElem());
- items.push_back (MenuElem (_("MIDI Bind"), mem_fun (*mute_button, &BindableToggleButton::midi_learn)));
+ // items.push_back (MenuElem (_("MIDI Bind"), mem_fun (*mute_button, &BindableToggleButton::midi_learn)));
}
void
#include "axis_view.h"
-namespace Gtkmm2ext {
- class BindableToggleButton;
-}
-
namespace ARDOUR {
class AudioTrack;
}
class Widget;
}
+class BindableToggleButton;
+
class RouteUI : public virtual AxisView
{
public:
bool ignore_toggle;
bool wait_for_release;
- Gtkmm2ext::BindableToggleButton * mute_button;
- Gtkmm2ext::BindableToggleButton * solo_button;
- Gtkmm2ext::BindableToggleButton * rec_enable_button;
+ BindableToggleButton* mute_button;
+ BindableToggleButton* solo_button;
+ BindableToggleButton* rec_enable_button;
virtual string solo_button_name () const { return "SoloButton"; }
virtual string safe_solo_button_name () const { return "SafeSoloButton"; }
sndfilesource.cc
source.cc
state_manager.cc
-stateful.cc
tempo.cc
utils.cc
version.cc
const layer_t max_layer = UCHAR_MAX;
- id_t new_id();
+ microseconds_t get_microseconds ();
Change new_change ();
#include <pbd/fastlog.h>
#include <pbd/ringbufferNPT.h>
-
+#include <pbd/stateful.h>
#include <ardour/ardour.h>
#include <ardour/configuration.h>
#include <ardour/route.h>
#include <ardour/port.h>
#include <ardour/utils.h>
-#include <ardour/stateful.h>
struct tm;
void handle_input_change (IOChange, void *src);
- id_t id() const { return _id; }
+ const PBD::ID& id() const { return _id; }
XMLNode* deprecated_io_node;
ARDOUR::IO* _io;
ChannelList channels;
uint32_t _n_channels;
- id_t _id;
+ PBD::ID _id;
mutable gint _record_enabled;
AudioPlaylist* _playlist;
AudioDiskstream& disk_stream() const { return *diskstream; }
int set_diskstream (AudioDiskstream&, void *);
int use_diskstream (string name);
- int use_diskstream (id_t id);
+ int use_diskstream (const PBD::ID& id);
TrackMode mode() const { return _mode; }
void set_mode (TrackMode m);
XMLNode& get_template();
int set_state(const XMLNode& node);
- MIDI::Controllable& midi_rec_enable_control() {
- return _midi_rec_enable_control;
+ PBD::Controllable& rec_enable_control() {
+ return _rec_enable_control;
}
- void reset_midi_control (MIDI::Port*, bool);
- void send_all_midi_feedback ();
-
bool record_enabled() const;
void set_meter_point (MeterPoint, void* src);
FreezeRecordInsertInfo(XMLNode& st)
: state (st), insert (0) {}
- XMLNode state;
- Insert* insert;
- id_t id;
+ XMLNode state;
+ Insert* insert;
+ PBD::ID id;
UndoAction memento;
};
void set_state_part_two ();
void set_state_part_three ();
- struct MIDIRecEnableControl : public MIDI::Controllable {
- MIDIRecEnableControl (AudioTrack&, MIDI::Port *);
- void set_value (float);
- void send_feedback (bool);
- MIDI::byte* write_feedback (MIDI::byte* buf, int32_t& bufsize, bool val, bool force = false);
- AudioTrack& track;
- bool setting;
- bool last_written;
+ struct RecEnableControllable : public PBD::Controllable {
+ RecEnableControllable (AudioTrack&);
+
+ void set_value (float);
+ float get_value (void) const;
+
+ AudioTrack& track;
};
- MIDIRecEnableControl _midi_rec_enable_control;
+ RecEnableControllable _rec_enable_control;
bool _destructive;
};
#include <ardour/source.h>
#include <ardour/ardour.h>
-#include <ardour/stateful.h>
+#include <pbd/stateful.h>
#include <pbd/xml++.h>
using std::list;
#include <sys/types.h>
#include <string>
+#include <pbd/stateful.h>
+
#include <ardour/types.h>
-#include <ardour/stateful.h>
#include <ardour/utils.h>
#include <ardour/configuration_variable.h>
#include <string>
#include <sigc++/signal.h>
#include <glibmm/thread.h>
-#include <ardour/stateful.h>
+#include <pbd/stateful.h>
using std::vector;
using std::string;
#include <glibmm/thread.h>
-#include <ardour/stateful.h>
+#include <pbd/stateful.h>
namespace ARDOUR {
bool is_generator() const;
- void reset_midi_control (MIDI::Port*, bool);
- void send_all_midi_feedback ();
-
void set_parameter (uint32_t port, float val);
AutoState get_port_automation_state (uint32_t port);
#include <pbd/fastlog.h>
#include <pbd/undo.h>
-
-#include <midi++/controllable.h>
+#include <pbd/stateful.h>
+#include <pbd/controllable.h>
#include <ardour/ardour.h>
-#include <ardour/stateful.h>
#include <ardour/utils.h>
#include <ardour/state_manager.h>
#include <ardour/curve.h>
static sigc::signal<void,uint32_t> MoreOutputs;
static sigc::signal<int> PortsCreated;
- /* MIDI control */
-
- void set_midi_to_gain_function (gain_t (*function)(double val)) {
- _midi_gain_control.midi_to_gain = function;
- }
-
- void set_gain_to_midi_function (double (*function)(gain_t gain)) {
- _midi_gain_control.gain_to_midi = function;
- }
-
- MIDI::Controllable& midi_gain_control() {
- return _midi_gain_control;
+ PBD::Controllable& gain_control() {
+ return _gain_control;
}
- virtual void reset_midi_control (MIDI::Port*, bool on);
-
- virtual void send_all_midi_feedback ();
- virtual MIDI::byte* write_midi_feedback (MIDI::byte*, int32_t& bufsize);
-
/* Peak metering */
float peak_input_power (uint32_t n) {
void start_pan_touch (uint32_t which);
void end_pan_touch (uint32_t which);
- id_t id() const { return _id; }
+ const PBD::ID& id() const { return _id; }
void defer_pan_reset ();
void allow_pan_reset ();
string _name;
Connection* _input_connection;
Connection* _output_connection;
- id_t _id;
+ PBD::ID _id;
bool no_panner_reset;
XMLNode* deferred_state;
static void apply_declick (vector<Sample*>&, uint32_t nbufs, jack_nframes_t nframes,
gain_t initial, gain_t target, bool invert_polarity);
- struct MIDIGainControl : public MIDI::Controllable {
- MIDIGainControl (IO&, MIDI::Port *);
- void set_value (float);
-
- void send_feedback (gain_t);
- MIDI::byte* write_feedback (MIDI::byte* buf, int32_t& bufsize, gain_t val, bool force = false);
-
+ struct GainControllable : public PBD::Controllable {
+ GainControllable (IO& i) : io (i) {}
+
+ void set_value (float val);
+ float get_value (void) const;
+
IO& io;
- bool setting;
- MIDI::byte last_written;
-
- gain_t (*midi_to_gain) (double val);
- double (*gain_to_midi) (gain_t gain);
};
- MIDIGainControl _midi_gain_control;
+ GainControllable _gain_control;
/* state management */
Change restore_state (State&);
StateManager::State* state_factory (std::string why) const;
- bool get_midi_node_info (XMLNode * node, MIDI::eventType & ev, MIDI::channel_t & chan, MIDI::byte & additional);
- bool set_midi_node_info (XMLNode * node, MIDI::eventType ev, MIDI::channel_t chan, MIDI::byte additional);
-
/* automation */
jack_nframes_t last_automation_snapshot;
#include <string>
#include <dlfcn.h>
-#include <midi++/controllable.h>
#include <sigc++/signal.h>
+#include <pbd/stateful.h>
+
#include <jack/types.h>
#include <ardour/ladspa.h>
-#include <ardour/stateful.h>
#include <ardour/plugin_state.h>
#include <ardour/plugin.h>
#include <ardour/ladspa_plugin.h>
#include <glibmm/thread.h>
#include <pbd/undo.h>
+#include <pbd/stateful.h>
-#include "ardour.h"
-#include "stateful.h"
-#include "state_manager.h"
+#include <ardour/ardour.h>
+#include <ardour/state_manager.h>
using std::string;
#include <string>
#include <list>
-#include <ardour/stateful.h>
+#include <pbd/stateful.h>
class XMLNode;
#include <iostream>
#include <sigc++/signal.h>
-#include <midi++/controllable.h>
+#include <pbd/stateful.h>
+#include <pbd/controllable.h>
#include <ardour/types.h>
-#include <ardour/stateful.h>
#include <ardour/curve.h>
using std::istream;
virtual void set_automation_state (AutoState) = 0;
virtual void set_automation_style (AutoStyle) = 0;
- /* MIDI control */
-
- struct MIDIControl : public MIDI::Controllable {
- MIDIControl (StreamPanner&, MIDI::Port *);
- void set_value (float);
- void send_feedback (gain_t);
- MIDI::byte* write_feedback (MIDI::byte* buf, int32_t& bufsize, gain_t val, bool force = false);
-
- pan_t (*midi_to_pan)(double val);
- double (*pan_to_midi)(pan_t p);
-
- StreamPanner& sp;
- bool setting;
- gain_t last_written;
- };
-
- MIDIControl& midi_control() { return _midi_control; }
- void reset_midi_control (MIDI::Port *, bool);
+ PBD::Controllable& control() { return _control; }
/* XXX this is wrong. for multi-dimensional panners, there
must surely be more than 1 automation curve.
virtual Curve& automation() = 0;
-
virtual int load (istream&, string path, uint32_t&) = 0;
virtual int save (ostream&) const = 0;
float effective_z;
bool _muted;
- MIDIControl _midi_control;
- void add_state (XMLNode&);
- bool get_midi_node_info (XMLNode * node, MIDI::eventType & ev, MIDI::channel_t & chan, MIDI::byte & additional);
- bool set_midi_node_info (XMLNode * node, MIDI::eventType ev, MIDI::channel_t chan, MIDI::byte additional);
+ struct PanControllable : public PBD::Controllable {
+ PanControllable (StreamPanner& p) : panner (p) {}
+
+ StreamPanner& panner;
+
+ void set_value (float);
+ float get_value (void) const;
+ bool can_send_feedback() const;
+ };
+ PanControllable _control;
+
+ void add_state (XMLNode&);
virtual void update () = 0;
};
std::vector<Output> outputs;
Session& session() const { return _session; }
- void reset_midi_control (MIDI::Port *, bool);
- void send_all_midi_feedback ();
- MIDI::byte* write_midi_feedback (MIDI::byte*, int32_t& bufsize);
-
enum LinkDirection {
SameDirection,
OppositeDirection
#include <glib.h>
#include <sigc++/signal.h>
+
#include <pbd/undo.h>
+#include <pbd/stateful.h>
#include <ardour/ardour.h>
#include <ardour/crossfade_compare.h>
#include <ardour/location.h>
-#include <ardour/stateful.h>
#include <ardour/state_manager.h>
namespace ARDOUR {
void duplicate (Region&, jack_nframes_t position, float times);
void nudge_after (jack_nframes_t start, jack_nframes_t distance, bool forwards);
- Region* find_region (id_t) const;
+ Region* find_region (const PBD::ID&) const;
Playlist* cut (list<AudioRange>&, bool result_is_hidden = true);
Playlist* copy (list<AudioRange>&, bool result_is_hidden = true);
Session& session() { return _session; }
- id_t get_orig_diskstream_id () const { return _orig_diskstream_id; }
- void set_orig_diskstream_id (id_t did) { _orig_diskstream_id = did; }
+ const PBD::ID& get_orig_diskstream_id () const { return _orig_diskstream_id; }
+ void set_orig_diskstream_id (const PBD::ID& did) { _orig_diskstream_id = did; }
/* destructive editing */
bool _frozen;
uint32_t subcnt;
uint32_t _read_data_count;
- id_t _orig_diskstream_id;
+ PBD::ID _orig_diskstream_id;
uint64_t layer_op_counter;
jack_nframes_t freeze_length;
#ifndef __ardour_ladspa_h__
#define __ardour_ladspa_h__
-#include <midi++/controllable.h>
#include <sigc++/signal.h>
+#include <pbd/stateful.h>
+#include <pbd/controllable.h>
+
#include <jack/types.h>
#include <ardour/types.h>
-#include <ardour/stateful.h>
#include <ardour/plugin_state.h>
#include <ardour/cycles.h>
sigc::signal<void,uint32_t,float> ParameterChanged;
sigc::signal<void,Plugin *> GoingAway;
- void reset_midi_control (MIDI::Port*, bool);
- void send_all_midi_feedback ();
- MIDI::byte* write_midi_feedback (MIDI::byte*, int32_t& bufsize);
- MIDI::Controllable *get_nth_midi_control (uint32_t);
+ PBD::Controllable *get_nth_control (uint32_t);
PluginInfo & get_info() { return _info; }
void set_info (const PluginInfo &inf) { _info = inf; }
map<string,string> presets;
bool save_preset(string name, string domain /* vst, ladspa etc. */);
- void setup_midi_controls ();
-
+ void setup_controls ();
- struct MIDIPortControl : public MIDI::Controllable {
- MIDIPortControl (Plugin&, uint32_t abs_port_id, MIDI::Port *,
- float lower, float upper, bool toggled, bool logarithmic);
+ struct PortControllable : public PBD::Controllable {
+ PortControllable (Plugin&, uint32_t abs_port_id,
+ float lower, float upper, bool toggled, bool logarithmic);
void set_value (float);
- void send_feedback (float);
- MIDI::byte* write_feedback (MIDI::byte* buf, int32_t& bufsize, float val, bool force = false);
+ float get_value () const;
Plugin& plugin;
uint32_t absolute_port;
float range;
bool toggled;
bool logarithmic;
-
- bool setting;
- float last_written;
};
- vector<MIDIPortControl*> midi_controls;
-
-
+ vector<PortControllable*> controls;
};
/* this is actually defined in plugin_manager.cc */
Region (const XMLNode&);
~Region();
- ARDOUR::id_t id() const { return _id; }
+ const PBD::ID& id() const { return _id; }
/* Note: changing the name of a Region does not constitute an edit */
mutable RegionEditState _first_edit;
int _frozen;
Glib::Mutex lock;
- ARDOUR::id_t _id;
+ PBD::ID _id;
ARDOUR::Playlist* _playlist;
mutable uint32_t _read_data_count; // modified in read()
Change pending_changed;
#include <glibmm/thread.h>
#include <pbd/xml++.h>
#include <pbd/undo.h>
-#include <midi++/controllable.h>
+#include <pbd/stateful.h>
+#include <pbd/controllable.h>
#include <ardour/ardour.h>
-#include <ardour/stateful.h>
#include <ardour/io.h>
#include <ardour/session.h>
#include <ardour/redirect.h>
bool feeds (Route *);
set<Route *> fed_by;
- struct MIDIToggleControl : public MIDI::Controllable {
- enum ToggleType {
- MuteControl = 0,
- SoloControl
- };
-
- MIDIToggleControl (Route&, ToggleType, MIDI::Port *);
- void set_value (float);
- void send_feedback (bool);
- MIDI::byte* write_feedback (MIDI::byte* buf, int32_t& bufsize, bool val, bool force = false);
-
- Route& route;
- ToggleType type;
- bool setting;
- bool last_written;
+ struct ToggleControllable : public PBD::Controllable {
+ enum ToggleType {
+ MuteControl = 0,
+ SoloControl
+ };
+
+ ToggleControllable (Route&, ToggleType);
+ void set_value (float);
+ float get_value (void) const;
+
+ Route& route;
+ ToggleType type;
};
- MIDI::Controllable& midi_solo_control() {
- return _midi_solo_control;
+ PBD::Controllable& solo_control() {
+ return _solo_control;
}
- MIDI::Controllable& midi_mute_control() {
- return _midi_mute_control;
+
+ PBD::Controllable& mute_control() {
+ return _mute_control;
}
- virtual void reset_midi_control (MIDI::Port*, bool);
- virtual void send_all_midi_feedback ();
- virtual MIDI::byte* write_midi_feedback (MIDI::byte*, int32_t& bufsize);
-
void automation_snapshot (jack_nframes_t now);
void protect_automation ();
std::string _comment;
bool _have_internal_generator;
- MIDIToggleControl _midi_solo_control;
- MIDIToggleControl _midi_mute_control;
+ ToggleControllable _solo_control;
+ ToggleControllable _mute_control;
void passthru (jack_nframes_t start_frame, jack_nframes_t end_frame,
jack_nframes_t nframes, jack_nframes_t offset, int declick, bool meter_inputs);
#include <string>
#include <stdint.h>
#include <sigc++/signal.h>
-#include <ardour/stateful.h>
+#include <pbd/stateful.h>
#include <ardour/types.h>
using std::string;
#include <sigc++/signal.h>
#include <string>
+
+#include <pbd/stateful.h>
#include <ardour/ardour.h>
#include <ardour/audioengine.h>
-
-#include "io.h"
-#include "stateful.h"
-#include "redirect.h"
+#include <ardour/io.h>
+#include <ardour/redirect.h>
namespace ARDOUR {
#include <midi++/types.h>
#include <midi++/mmc.h>
+#include <pbd/stateful.h>
+
#include <ardour/ardour.h>
#include <ardour/configuration.h>
#include <ardour/location.h>
-#include <ardour/stateful.h>
#include <ardour/gain.h>
#include <ardour/io.h>
class Port;
}
+namespace PBD {
+ class Controllable;
+}
+
namespace ARDOUR {
class Port;
vector<Sample*>& get_silent_buffers (uint32_t howmany);
vector<Sample*>& get_send_buffers () { return _send_buffers; }
- AudioDiskstream *diskstream_by_id (id_t id);
+ AudioDiskstream *diskstream_by_id (const PBD::ID& id);
AudioDiskstream *diskstream_by_name (string name);
bool have_captured() const { return _have_captured; }
AudioFileSource *create_audio_source_for_session (ARDOUR::AudioDiskstream&, uint32_t which_channel, bool destructive);
- Source *get_source (ARDOUR::id_t);
+ Source *source_by_id (const PBD::ID&);
/* playlist management */
static apply_gain_to_buffer_t apply_gain_to_buffer;
static mix_buffers_with_gain_t mix_buffers_with_gain;
static mix_buffers_no_gain_t mix_buffers_no_gain;
-
+
+ static sigc::signal<void> SendFeedback;
+
+ /* Controllables */
+
+ PBD::Controllable* controllable_by_id (const PBD::ID&);
+
protected:
friend class AudioEngine;
void set_block_size (jack_nframes_t nframes);
/* REGION MANAGEMENT */
mutable Glib::Mutex region_lock;
- typedef map<ARDOUR::id_t,AudioRegion *> AudioRegionList;
+ typedef map<PBD::ID,AudioRegion *> AudioRegionList;
AudioRegionList audio_regions;
void region_renamed (Region *);
/* SOURCES */
mutable Glib::Mutex audio_source_lock;
- typedef std::map<id_t, AudioSource *> AudioSourceList;
+ typedef std::map<PBD::ID,AudioSource *> AudioSourceList;
AudioSourceList audio_sources;
LayerModel layer_model;
CrossfadeModel xfade_model;
+
+ typedef std::list<PBD::Controllable*> Controllables;
+ Glib::Mutex controllables_lock;
+ Controllables controllables;
+
+ void add_controllable (PBD::Controllable*);
+ void remove_controllable (PBD::Controllable*);
};
}; /* namespace ARDOUR */
{
Glib::Mutex::Lock lm (region_lock);
for (AudioRegionList::iterator i = audio_regions.begin(); i != audio_regions.end(); i++) {
- (obj->*func) ((*i).second);
+ (obj->*func) (i->second);
}
}
#include <sigc++/signal.h>
+#include <pbd/stateful.h>
+
#include <ardour/ardour.h>
-#include <ardour/stateful.h>
namespace ARDOUR {
std::string name() const { return _name; }
int set_name (std::string str, bool destructive);
- ARDOUR::id_t id() const { return _id; }
+ const PBD::ID& id() const { return _id; }
uint32_t use_cnt() const { return _use_cnt; }
void use ();
time_t _timestamp;
private:
- ARDOUR::id_t _id;
+ PBD::ID _id;
};
}
+++ /dev/null
-/*
- Copyright (C) 2000 Paul Davis
-
- 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.
-
- $Id$
-*/
-
-#ifndef __ardour_stateful_h__
-#define __ardour_stateful_h__
-
-#include <string>
-
-class XMLNode;
-
-class Stateful {
- public:
- Stateful();
- virtual ~Stateful();
-
- virtual XMLNode& get_state (void) = 0;
-
- virtual int set_state (const XMLNode&) = 0;
-
- /* Extra XML nodes */
-
- void add_extra_xml (XMLNode&);
- XMLNode *extra_xml (const std::string& str);
-
- virtual void add_instant_xml (XMLNode&, const std::string& dir);
- XMLNode *instant_xml (const std::string& str, const std::string& dir);
-
- protected:
- XMLNode *_extra_xml;
- XMLNode *_instant_xml;
-};
-
-#endif /* __ardour_stateful_h__ */
-
#include <cmath>
#include <glibmm/thread.h>
#include <pbd/undo.h>
+#include <pbd/stateful.h>
#include <sigc++/signal.h>
#include <ardour/ardour.h>
-#include <ardour/stateful.h>
#include <ardour/state_manager.h>
class XMLNode;
#include <inttypes.h>
#include <jack/types.h>
#include <control_protocol/smpte.h>
+#include <pbd/id.h>
+
#include <map>
#if __GNUC__ < 3
typedef float pan_t;
typedef float gain_t;
typedef uint32_t layer_t;
- typedef uint64_t id_t;
+ typedef uint64_t microseconds_t;
enum IOChange {
NoChange = 0,
int touch_file(std::string path);
-uint32_t long get_uid();
-
std::string region_name_from_path (std::string path);
std::string path_expand (std::string);
#include <string>
#include <dlfcn.h>
-#include <midi++/controllable.h>
#include <sigc++/signal.h>
-
+#include <pbd/stateful.h>
#include <jack/types.h>
-#include <ardour/stateful.h>
#include <ardour/plugin_state.h>
#include <ardour/plugin.h>
void
AudioDiskstream::init (Flag f)
{
- _id = new_id();
_refcnt = 0;
_flags = f;
_io = 0;
node->add_property ("speed", buf);
node->add_property("name", _name);
- snprintf (buf, sizeof(buf), "%" PRIu64, id());
+ id().print (buf);
node->add_property("id", buf);
if (!capturing_sources.empty() && _session.get_record_enabled()) {
if (deprecated_io_node) {
if ((prop = deprecated_io_node->property ("id")) != 0) {
- sscanf (prop->value().c_str(), "%" PRIu64, &_id);
+ _id = prop->value ();
}
} else {
if ((prop = node.property ("id")) != 0) {
- sscanf (prop->value().c_str(), "%" PRIu64, &_id);
+ _id = prop->value ();
}
}
AudioTrack::AudioTrack (Session& sess, string name, Route::Flag flag, TrackMode mode)
: Route (sess, name, 1, -1, -1, -1, flag),
diskstream (0),
- _midi_rec_enable_control (*this, _session.midi_port())
+ _rec_enable_control (*this)
{
AudioDiskstream::Flag dflags = AudioDiskstream::Flag (0);
_mode = mode;
set_diskstream (*ds, this);
-
- // session.SMPTEOffsetChanged.connect (mem_fun (*this, &AudioTrack::handle_smpte_offset_change));
-
- // we do this even though Route already did it in it's init
- reset_midi_control (_session.midi_port(), _session.get_midi_control());
-
}
AudioTrack::AudioTrack (Session& sess, const XMLNode& node)
: Route (sess, "to be renamed", 0, 0, -1, -1),
diskstream (0),
- _midi_rec_enable_control (*this, _session.midi_port())
+ _rec_enable_control (*this)
{
_freeze_record.state = NoFreeze;
set_state (node);
_declickable = true;
_saved_meter_point = _meter_point;
-
- // we do this even though Route already did it in it's init
- reset_midi_control (_session.midi_port(), _session.get_midi_control());
}
AudioTrack::~AudioTrack ()
}
int
-AudioTrack::use_diskstream (id_t id)
+AudioTrack::use_diskstream (const PBD::ID& id)
{
AudioDiskstream *dstream;
set_meter_point (_saved_meter_point, this);
}
- if (_session.get_midi_feedback()) {
- _midi_rec_enable_control.send_feedback (record_enabled());
- }
-
+ _rec_enable_control.Changed ();
}
void
{
const XMLProperty *prop;
XMLNodeConstIterator iter;
- XMLNodeList midi_kids;
if (Route::set_state (node)) {
return -1;
_mode = Normal;
}
- midi_kids = node.children ("MIDI");
-
- for (iter = midi_kids.begin(); iter != midi_kids.end(); ++iter) {
-
- XMLNodeList kids;
- XMLNodeConstIterator miter;
- XMLNode* child;
-
- kids = (*iter)->children ();
-
- for (miter = kids.begin(); miter != kids.end(); ++miter) {
-
- child =* miter;
-
- if (child->name() == "rec_enable") {
-
- MIDI::eventType ev = MIDI::on; /* initialize to keep gcc happy */
- MIDI::byte additional = 0; /* ditto */
- MIDI::channel_t chn = 0; /* ditto */
-
- if (get_midi_node_info (child, ev, chn, additional)) {
- _midi_rec_enable_control.set_control_type (chn, ev, additional);
- } else {
- error << string_compose(_("MIDI rec_enable control specification for %1 is incomplete, so it has been ignored"), _name) << endmsg;
- }
- }
- }
- }
-
-
if ((prop = node.property ("diskstream-id")) == 0) {
/* some old sessions use the diskstream name rather than the ID */
} else {
- id_t id = strtoull (prop->value().c_str(), 0, 10);
+ PBD::ID id (prop->value());
if (use_diskstream (id)) {
return -1;
{
XMLNode& root (Route::state(full_state));
XMLNode* freeze_node;
- char buf[32];
+ char buf[64];
if (_freeze_record.playlist) {
XMLNode* inode;
for (vector<FreezeRecordInsertInfo*>::iterator i = _freeze_record.insert_info.begin(); i != _freeze_record.insert_info.end(); ++i) {
inode = new XMLNode (X_("insert"));
- snprintf (buf, sizeof (buf), "%" PRIu64, (*i)->id);
+ (*i)->id.print (buf);
inode->add_property (X_("id"), buf);
inode->add_child_copy ((*i)->state);
align_node->add_property (X_("style"), buf);
root.add_child_nocopy (*align_node);
- /* MIDI control */
-
- MIDI::channel_t chn;
- MIDI::eventType ev;
- MIDI::byte additional;
- XMLNode* midi_node = 0;
- XMLNode* child;
- XMLNodeList midikids;
-
- midikids = root.children ("MIDI");
- if (!midikids.empty()) {
- midi_node = midikids.front();
- }
- else {
- midi_node = root.add_child ("MIDI");
- }
-
- if (_midi_rec_enable_control.get_control_info (chn, ev, additional) && midi_node) {
-
- child = midi_node->add_child ("rec_enable");
- set_midi_node_info (child, ev, chn, additional);
- }
-
XMLNode* remote_control_node = new XMLNode (X_("remote_control"));
snprintf (buf, sizeof (buf), "%d", _remote_control_id);
remote_control_node->add_property (X_("id"), buf);
diskstream.
*/
- snprintf (buf, sizeof (buf), "%" PRIu64, diskstream->id());
+ diskstream->id().print (buf);
root.add_property ("diskstream-id", buf);
return root;
FreezeRecordInsertInfo* frii = new FreezeRecordInsertInfo (*((*citer)->children().front()));
frii->insert = 0;
- sscanf (prop->value().c_str(), "%" PRIu64, &frii->id);
+ frii->id = prop->value ();
_freeze_record.insert_info.push_back (frii);
}
}
return _freeze_record.state;
}
-
-void
-AudioTrack::reset_midi_control (MIDI::Port* port, bool on)
+AudioTrack::RecEnableControllable::RecEnableControllable (AudioTrack& s)
+ : track (s)
{
- MIDI::channel_t chn;
- MIDI::eventType ev;
- MIDI::byte extra;
-
- Route::reset_midi_control (port, on);
-
- _midi_rec_enable_control.get_control_info (chn, ev, extra);
- if (!on) {
- chn = -1;
- }
- _midi_rec_enable_control.midi_rebind (port, chn);
}
void
-AudioTrack::send_all_midi_feedback ()
-{
- if (_session.get_midi_feedback()) {
-
- Route::send_all_midi_feedback();
-
- _midi_rec_enable_control.send_feedback (record_enabled());
- }
-}
-
-
-AudioTrack::MIDIRecEnableControl::MIDIRecEnableControl (AudioTrack& s, MIDI::Port* port)
- : MIDI::Controllable (port, 0), track (s), setting(false)
-{
- last_written = false; /* XXX need a good out of bound value */
-}
-
-void
-AudioTrack::MIDIRecEnableControl::set_value (float val)
+AudioTrack::RecEnableControllable::set_value (float val)
{
bool bval = ((val >= 0.5f) ? true: false);
-
- setting = true;
track.set_record_enable (bval, this);
- setting = false;
-}
-
-void
-AudioTrack::MIDIRecEnableControl::send_feedback (bool value)
-{
-
- if (!setting && get_midi_feedback()) {
- MIDI::byte val = (MIDI::byte) (value ? 127: 0);
- MIDI::channel_t ch = 0;
- MIDI::eventType ev = MIDI::none;
- MIDI::byte additional = 0;
- MIDI::EventTwoBytes data;
-
- if (get_control_info (ch, ev, additional)) {
- data.controller_number = additional;
- data.value = val;
-
- track._session.send_midi_message (get_port(), ev, ch, data);
- }
- }
-
}
-MIDI::byte*
-AudioTrack::MIDIRecEnableControl::write_feedback (MIDI::byte* buf, int32_t& bufsize, bool val, bool force)
+float
+AudioTrack::RecEnableControllable::get_value (void) const
{
- if (get_midi_feedback()) {
-
- MIDI::channel_t ch = 0;
- MIDI::eventType ev = MIDI::none;
- MIDI::byte additional = 0;
-
- if (get_control_info (ch, ev, additional)) {
- if (val != last_written || force) {
- *buf++ = ev & ch;
- *buf++ = additional; /* controller number */
- *buf++ = (MIDI::byte) (val ? 127: 0);
- last_written = val;
- bufsize -= 3;
- }
- }
- }
-
- return buf;
+ if (track.record_enabled()) { return 1.0f; }
+ return 0.0f;
}
void
void
AudioFileSource::handle_header_position_change ()
{
+ cerr << _path << " handling header position change " << writable() << endl;
+
if (writable()) {
set_header_timeline_position ();
flush_header ();
_fade_out (0.0, 2.0, 1.0, false),
_envelope (0.0, 2.0, 1.0, false)
{
- /* basic AudioRegion constructor */
-
set<AudioSource*> unique_srcs;
for (SourceList::iterator i=srcs.begin(); i != srcs.end(); ++i) {
for (uint32_t n=0; n < sources.size(); ++n) {
snprintf (buf2, sizeof(buf2), "source-%d", n);
- snprintf (buf, sizeof(buf), "%" PRIu64, sources[n]->id());
+ sources[n]->id().print (buf2);
node.add_property (buf2, buf);
}
{
Region* r;
XMLProperty* prop;
- id_t id;
LocaleGuard lg (X_("POSIX"));
/* we have to find the in/out regions before we can do anything else */
throw failed_constructor();
}
- sscanf (prop->value().c_str(), "%" PRIu64, &id);
+ PBD::ID id (prop->value());
if ((r = playlist.find_region (id)) == 0) {
error << string_compose (_("Crossfade: no \"in\" region %1 found in playlist %2"), id, playlist.name())
throw failed_constructor();
}
- sscanf (prop->value().c_str(), "%" PRIu64, &id);
+ PBD::ID id2 (prop->value());
- if ((r = playlist.find_region (id)) == 0) {
- error << string_compose (_("Crossfade: no \"out\" region %1 found in playlist %2"), id, playlist.name())
+ if ((r = playlist.find_region (id2)) == 0) {
+ error << string_compose (_("Crossfade: no \"out\" region %1 found in playlist %2"), id2, playlist.name())
<< endmsg;
throw failed_constructor();
}
char buf[64];
LocaleGuard lg (X_("POSIX"));
- snprintf (buf, sizeof(buf), "%" PRIu64, _out->id());
+ _out->id().print (buf);
node->add_property ("out", buf);
- snprintf (buf, sizeof(buf), "%" PRIu64, _in->id());
+ _in->id().print (buf);
node->add_property ("in", buf);
node->add_property ("active", (_active ? "yes" : "no"));
node->add_property ("follow-overlap", (_follow_overlap ? "yes" : "no"));
return 0;
}
-ARDOUR::id_t
-ARDOUR::new_id ()
+
+microseconds_t
+ARDOUR::get_microseconds ()
{
- return get_uid();
+ /* XXX need JACK to export its functionality */
+
+ struct timeval now;
+ gettimeofday (&now, 0);
+ return now.tv_sec * 1000000ULL + now.tv_usec;
}
ARDOUR::Change
node->add_property("id", string(buf));
if (_plugins[0]->state_node_name() == "ladspa") {
char buf[32];
- snprintf (buf, 31, "%ld", _plugins[0]->get_info().unique_id);
+ snprintf (buf, sizeof (buf), "%ld", _plugins[0]->get_info().unique_id);
node->add_property("unique-id", string(buf));
}
node->add_property("count", string_compose("%1", _plugins.size()));
return _plugins[0]->describe_parameter (what);
}
-void
-PluginInsert::reset_midi_control (MIDI::Port* port, bool on)
-{
- _plugins[0]->reset_midi_control (port, on);
-}
-
-void
-PluginInsert::send_all_midi_feedback ()
-{
- _plugins[0]->send_all_midi_feedback();
-}
-
jack_nframes_t
PluginInsert::latency()
{
Glib::StaticMutex IO::m_meter_signal_lock = GLIBMM_STATIC_MUTEX_INIT;
-/* this is a default mapper of MIDI control values to a gain coefficient.
- others can be imagined. see IO::set_midi_to_gain_function().
+/* this is a default mapper of [0 .. 1.0] control values to a gain coefficient.
+ others can be imagined.
*/
-static gain_t direct_midi_to_gain (double fract) {
+static gain_t direct_control_to_gain (double fract) {
/* XXX Marcus writes: this doesn't seem right to me. but i don't have a better answer ... */
/* this maxes at +6dB */
return pow (2.0,(sqrt(sqrt(sqrt(fract)))*198.0-192.0)/6.0);
}
-static double direct_gain_to_midi (gain_t gain) {
+static double direct_gain_to_control (gain_t gain) {
/* XXX Marcus writes: this doesn't seem right to me. but i don't have a better answer ... */
if (gain == 0) return 0.0;
int input_min, int input_max, int output_min, int output_max)
: _session (s),
_name (name),
- _midi_gain_control (*this, _session.midi_port()),
+ _gain_control (*this),
_gain_automation_curve (0.0, 2.0, 1.0),
_input_minimum (input_min),
_input_maximum (input_max),
_output_minimum (output_min),
_output_maximum (output_max)
{
- _id = new_id();
_panner = new Panner (name, _session);
_gain = 1.0;
_desired_gain = 1.0;
no_panner_reset = false;
deferred_state = 0;
- _midi_gain_control.midi_to_gain = direct_midi_to_gain;
- _midi_gain_control.gain_to_midi = direct_gain_to_midi;
-
apply_gain_automation = false;
last_automation_snapshot = 0;
IO::state (bool full_state)
{
XMLNode* node = new XMLNode (state_node_name);
- char buf[32];
+ char buf[64];
string str;
bool need_ins = true;
bool need_outs = true;
Glib::Mutex::Lock lm (io_lock);
node->add_property("name", _name);
- snprintf (buf, sizeof(buf), "%" PRIu64, id());
+ id().print (buf);
node->add_property("id", buf);
str = "";
node->add_property ("iolimits", buf);
- /* MIDI control */
-
- MIDI::channel_t chn;
- MIDI::eventType ev;
- MIDI::byte additional;
- XMLNode* midi_node = 0;
- XMLNode* child;
-
- if (_midi_gain_control.get_control_info (chn, ev, additional)) {
-
- midi_node = node->add_child ("MIDI");
-
- child = midi_node->add_child ("gain");
- set_midi_node_info (child, ev, chn, additional);
- }
-
/* automation */
if (full_state) {
{
const XMLProperty* prop;
XMLNodeConstIterator iter;
- XMLNodeList midi_kids;
LocaleGuard lg (X_("POSIX"));
/* force use of non-localized representation of decimal point,
}
if ((prop = node.property ("id")) != 0) {
- sscanf (prop->value().c_str(), "%" PRIu64, &_id);
+ _id = prop->value ();
}
if ((prop = node.property ("iolimits")) != 0) {
}
}
- midi_kids = node.children ("MIDI");
-
- for (iter = midi_kids.begin(); iter != midi_kids.end(); ++iter) {
-
- XMLNodeList kids;
- XMLNodeConstIterator miter;
- XMLNode* child;
-
- kids = (*iter)->children ();
-
- for (miter = kids.begin(); miter != kids.end(); ++miter) {
-
- child =* miter;
-
- if (child->name() == "gain") {
-
- MIDI::eventType ev = MIDI::on; /* initialize to keep gcc happy */
- MIDI::byte additional = 0; /* ditto */
- MIDI::channel_t chn = 0; /* ditto */
-
- if (get_midi_node_info (child, ev, chn, additional)) {
- _midi_gain_control.set_control_type (chn, ev, additional);
- } else {
- error << string_compose(_("MIDI gain control specification for %1 is incomplete, so it has been ignored"), _name) << endmsg;
- }
- }
- }
- }
-
if ((prop = node.property ("automation-state")) != 0) {
long int x;
return 0;
}
-bool
-IO::get_midi_node_info (XMLNode * node, MIDI::eventType & ev, MIDI::channel_t & chan, MIDI::byte & additional)
-{
- bool ok = true;
- const XMLProperty* prop;
- int xx;
-
- if ((prop = node->property ("event")) != 0) {
- sscanf (prop->value().c_str(), "0x%x", &xx);
- ev = (MIDI::eventType) xx;
- } else {
- ok = false;
- }
-
- if (ok && ((prop = node->property ("channel")) != 0)) {
- sscanf (prop->value().c_str(), "%d", &xx);
- chan = (MIDI::channel_t) xx;
- } else {
- ok = false;
- }
-
- if (ok && ((prop = node->property ("additional")) != 0)) {
- sscanf (prop->value().c_str(), "0x%x", &xx);
- additional = (MIDI::byte) xx;
- }
-
- return ok;
-}
-
-bool
-IO::set_midi_node_info (XMLNode * node, MIDI::eventType ev, MIDI::channel_t chan, MIDI::byte additional)
-{
- char buf[32];
-
- snprintf (buf, sizeof(buf), "0x%x", ev);
- node->add_property ("event", buf);
- snprintf (buf, sizeof(buf), "%d", chan);
- node->add_property ("channel", buf);
- snprintf (buf, sizeof(buf), "0x%x", additional);
- node->add_property ("additional", buf);
-
- return true;
-}
-
int
IO::make_connections (const XMLNode& node)
use_output_connection (*_output_connection, this);
}
-IO::MIDIGainControl::MIDIGainControl (IO& i, MIDI::Port* port)
- : MIDI::Controllable (port, 0), io (i), setting(false)
-{
- midi_to_gain = 0;
- gain_to_midi = 0;
- setting = false;
- last_written = 0; /* XXX need a good out-of-bound-value */
-}
-
void
-IO::MIDIGainControl::set_value (float val)
+IO::GainControllable::set_value (float val)
{
- if (midi_to_gain == 0) return;
-
- setting = true;
- io.set_gain (midi_to_gain (val), this);
- setting = false;
-}
-
-void
-IO::MIDIGainControl::send_feedback (gain_t gain)
-{
- if (!setting && get_midi_feedback() && gain_to_midi) {
- MIDI::byte val = (MIDI::byte) (gain_to_midi (gain) * 127.0);
- MIDI::channel_t ch = 0;
- MIDI::eventType ev = MIDI::none;
- MIDI::byte additional = 0;
- MIDI::EventTwoBytes data;
-
- if (get_control_info (ch, ev, additional)) {
- data.controller_number = additional;
- data.value = val;
- last_written = val;
-
- io._session.send_midi_message (get_port(), ev, ch, data);
- }
- //send_midi_feedback (gain_to_midi (gain));
- }
+ io.set_gain (direct_control_to_gain (val), this);
}
-MIDI::byte*
-IO::MIDIGainControl::write_feedback (MIDI::byte* buf, int32_t& bufsize, gain_t val, bool force)
+float
+IO::GainControllable::get_value (void) const
{
- if (get_midi_feedback() && gain_to_midi && bufsize > 2) {
- MIDI::channel_t ch = 0;
- MIDI::eventType ev = MIDI::none;
- MIDI::byte additional = 0;
- MIDI::byte gm;
-
- if (get_control_info (ch, ev, additional)) {
- gm = (MIDI::byte) (gain_to_midi (val) * 127.0);
-
- if (gm != last_written) {
- *buf++ = (0xF0 & ev) | (0xF & ch);
- *buf++ = additional; /* controller number */
- *buf++ = gm;
- last_written = gm;
- bufsize -= 3;
- }
- }
- }
-
- return buf;
+ return direct_gain_to_control (io.effective_gain());
}
void
}
}
-void
-IO::reset_midi_control (MIDI::Port* port, bool on)
-{
- MIDI::channel_t chn;
- MIDI::eventType ev;
- MIDI::byte extra;
-
- _midi_gain_control.get_control_info (chn, ev, extra);
- if (!on) {
- chn = -1;
- }
- _midi_gain_control.midi_rebind (port, chn);
-
- _panner->reset_midi_control (port, on);
-}
-
-
int
IO::save_automation (const string& path)
{
}
gain_changed (src);
-
- if (_session.get_midi_feedback()) {
- _midi_gain_control.send_feedback (_desired_gain);
- }
+ _gain_control.Changed (); /* EMIT SIGNAL */
if (_session.transport_stopped() && src != 0 && src != this && gain_automation_recording()) {
_gain_automation_curve.add (_session.transport_frame(), val);
_session.set_dirty();
}
-void
-IO::send_all_midi_feedback ()
-{
- if (_session.get_midi_feedback()) {
- _midi_gain_control.send_feedback (_effective_gain);
-
- // panners
- _panner->send_all_midi_feedback();
- }
-}
-
-MIDI::byte*
-IO::write_midi_feedback (MIDI::byte* buf, int32_t& bufsize)
-{
- if (_session.get_midi_feedback()) {
- if (gain_automation_playback ()) {
- buf = _midi_gain_control.write_feedback (buf, bufsize, _effective_gain);
- }
- buf = _panner->write_midi_feedback (buf, bufsize);
- }
-
- return buf;
-}
-
void
IO::start_gain_touch ()
{
}
}
- Plugin::setup_midi_controls ();
+ Plugin::setup_controls ();
latency_compute_run ();
-
- MIDI::Controllable *mcontrol;
-
- for (uint32_t i = 0; i < parameter_count(); ++i) {
- if (LADSPA_IS_PORT_INPUT(port_descriptor (i)) &&
- LADSPA_IS_PORT_CONTROL(port_descriptor (i))) {
- if ((mcontrol = get_nth_midi_control (i)) != 0) {
- mcontrol->midi_rebind (_session.midi_port(), 0);
- }
- }
- }
}
LadspaPlugin::~LadspaPlugin ()
shadow_data[which] = (LADSPA_Data) val;
ParameterChanged (which, val); /* EMIT SIGNAL */
- if (session().get_midi_feedback()) {
-
- if (which < parameter_count() && midi_controls[which]) {
- midi_controls[which]->send_feedback (val);
- }
+ if (which < parameter_count() && controls[which]) {
+ controls[which]->Changed ();
}
-
+
} else {
warning << string_compose (_("illegal parameter number used with plugin \"%1\". This may"
- "indicate a change in the plugin design, and presets may be"
- "invalid"), name())
+ "indicate a change in the plugin design, and presets may be"
+ "invalid"), name())
<< endmsg;
}
}
snprintf(buf, sizeof(buf), "%+f", shadow_data[i]);
child->add_property("value", string(buf));
root->add_child_nocopy (*child);
-
- MIDI::Controllable *pcontrol = get_nth_midi_control (i);
-
- if (pcontrol) {
-
- MIDI::eventType ev;
- MIDI::byte additional;
- MIDI::channel_t chn;
- XMLNode* midi_node;
-
- if (pcontrol->get_control_info (chn, ev, additional)) {
-
- midi_node = child->add_child ("midi-control");
-
- snprintf (buf, sizeof(buf), "0x%x", ev);
- midi_node->add_property ("event", buf);
- snprintf (buf, sizeof(buf), "%d", chn);
- midi_node->add_property ("channel", buf);
- snprintf (buf, sizeof(buf), "0x%x", additional);
- midi_node->add_property ("additional", buf);
- }
- }
}
}
sscanf (port, "%" PRIu32, &port_id);
set_parameter (port_id, atof(data));
-
- XMLNodeList midi_kids;
- XMLNodeConstIterator iter;
-
- midi_kids = child->children ("midi-control");
-
- for (iter = midi_kids.begin(); iter != midi_kids.end(); ++iter) {
-
- child = *iter;
-
- MIDI::eventType ev = MIDI::on; /* initialize to keep gcc happy */
- MIDI::byte additional = 0; /* initialize to keep gcc happy */
- MIDI::channel_t chn = 0; /* initialize to keep gcc happy */
- bool ok = true;
- int xx;
-
- if ((prop = child->property ("event")) != 0) {
- sscanf (prop->value().c_str(), "0x%x", &xx);
- ev = (MIDI::eventType) xx;
- } else {
- ok = false;
- }
-
- if (ok && ((prop = child->property ("channel")) != 0)) {
- sscanf (prop->value().c_str(), "%d", &xx);
- chn = (MIDI::channel_t) xx;
- } else {
- ok = false;
- }
-
- if (ok && ((prop = child->property ("additional")) != 0)) {
- sscanf (prop->value().c_str(), "0x%x", &xx);
- additional = (MIDI::byte) xx;
- }
-
- if (ok) {
- MIDI::Controllable* pcontrol = get_nth_midi_control (port_id);
-
- if (pcontrol) {
- pcontrol->set_control_type (chn, ev, additional);
- }
-
- } else {
- error << string_compose(_("LADSPA LadspaPlugin MIDI control specification for port %1 is incomplete, so it has been ignored"), port) << endl;
- }
- }
}
latency_compute_run ();
string EqualPowerStereoPanner::name = "Equal Power Stereo";
string Multi2dPanner::name = "Multiple (2D)";
-/* this is a default mapper of MIDI control values to a pan position
- others can be imagined. see Panner::set_midi_to_pan_function().
+/* this is a default mapper of control values to a pan position
+ others can be imagined.
*/
-static pan_t direct_midi_to_pan (double fract) {
+static pan_t direct_control_to_pan (double fract) {
return fract;
}
-static double direct_pan_to_midi (pan_t val) {
+static double direct_pan_to_control (pan_t val) {
return val;
}
StreamPanner::StreamPanner (Panner& p)
: parent (p),
- _midi_control (*this, (MIDI::Port*) 0)
+ _control (*this)
{
_muted = false;
{
}
-StreamPanner::MIDIControl::MIDIControl (StreamPanner& s, MIDI::Port* port)
- : MIDI::Controllable (port, 0), sp (s), setting(false)
-{
- midi_to_pan = direct_midi_to_pan;
- pan_to_midi = direct_pan_to_midi;
- last_written = 0; /* XXX need a good out-of-bound-value */
-}
-
void
-StreamPanner::MIDIControl::set_value (float val)
+StreamPanner::PanControllable::set_value (float val)
{
- setting = true;
- sp.set_position (midi_to_pan (val));
- setting = false;
-}
-
-void
-StreamPanner::MIDIControl::send_feedback (pan_t value)
-{
-
- if (!setting && get_midi_feedback() && pan_to_midi) {
- MIDI::byte val = (MIDI::byte) (pan_to_midi (value) * 127.0f);
- MIDI::channel_t ch = 0;
- MIDI::eventType ev = MIDI::none;
- MIDI::byte additional = 0;
- MIDI::EventTwoBytes data;
-
- if (get_control_info (ch, ev, additional)) {
- data.controller_number = additional;
- data.value = val;
- last_written = val;
-
- sp.get_parent().session().send_midi_message (get_port(), ev, ch, data);
- }
-
- // send_midi_feedback (pan_to_midi (val));
- }
-
+ panner.set_position (direct_control_to_pan (val));
}
-MIDI::byte*
-StreamPanner::MIDIControl::write_feedback (MIDI::byte* buf, int32_t& bufsize, pan_t val, bool force)
+float
+StreamPanner::PanControllable::get_value (void) const
{
- if (get_midi_feedback() && pan_to_midi && bufsize > 2) {
- MIDI::channel_t ch = 0;
- MIDI::eventType ev = MIDI::none;
- MIDI::byte additional = 0;
- MIDI::byte pm;
- if (get_control_info (ch, ev, additional)) {
-
- pm = (MIDI::byte) (pan_to_midi (val) * 127.0);
-
- if (pm != last_written || force) {
- *buf++ = (0xF0 & ev) | (0xF & ch);
- *buf++ = additional; /* controller number */
- *buf++ = pm;
- last_written = pm;
- bufsize -= 3;
- }
- }
- }
-
- return buf;
+ float xpos;
+ panner.get_effective_position (xpos);
+ return direct_pan_to_control (xpos);
}
-
-void
-StreamPanner::reset_midi_control (MIDI::Port* port, bool on)
+bool
+StreamPanner::PanControllable::can_send_feedback () const
{
- MIDI::channel_t chn;
- MIDI::eventType ev;
- MIDI::byte extra;
+ AutoState astate = panner.get_parent().automation_state ();
- _midi_control.get_control_info (chn, ev, extra);
- if (!on) {
- chn = -1;
+ if ((astate == Play) || (astate == Touch && !panner.get_parent().touching())) {
+ return true;
}
- _midi_control.midi_rebind (port, chn);
+
+ return false;
}
void
x = xpos;
update ();
Changed ();
-
- if (parent.session().get_midi_feedback()) {
- _midi_control.send_feedback (x);
- }
+ _control.Changed ();
}
}
{
const XMLProperty* prop;
XMLNodeConstIterator iter;
- XMLNodeList midi_kids;
if ((prop = node.property (X_("muted")))) {
set_muted (prop->value() == "yes");
}
- midi_kids = node.children ("MIDI");
-
- for (iter = midi_kids.begin(); iter != midi_kids.end(); ++iter) {
-
- XMLNodeList kids;
- XMLNodeConstIterator miter;
- XMLNode* child;
-
- kids = (*iter)->children ();
-
- for (miter = kids.begin(); miter != kids.end(); ++miter) {
-
- child =* miter;
-
- if (child->name() == "pan") {
-
- MIDI::eventType ev = MIDI::on; /* initialize to keep gcc happy */
- MIDI::byte additional = 0; /* ditto */
- MIDI::channel_t chn = 0; /* ditto */
-
- if (get_midi_node_info (child, ev, chn, additional)) {
- _midi_control.set_control_type (chn, ev, additional);
- } else {
- error << _("MIDI pan control specification is incomplete, so it has been ignored") << endmsg;
- }
- }
- }
- }
-
-
return 0;
}
StreamPanner::add_state (XMLNode& node)
{
node.add_property (X_("muted"), (muted() ? "yes" : "no"));
-
- /* MIDI control */
-
- MIDI::channel_t chn;
- MIDI::eventType ev;
- MIDI::byte additional;
- XMLNode* midi_node = 0;
- XMLNode* child;
-
- if (_midi_control.get_control_info (chn, ev, additional)) {
-
- midi_node = node.add_child ("MIDI");
-
- child = midi_node->add_child ("pan");
- set_midi_node_info (child, ev, chn, additional);
- }
-
-}
-
-
-bool
-StreamPanner::get_midi_node_info (XMLNode * node, MIDI::eventType & ev, MIDI::channel_t & chan, MIDI::byte & additional)
-{
- bool ok = true;
- const XMLProperty* prop;
- int xx;
-
- if ((prop = node->property ("event")) != 0) {
- sscanf (prop->value().c_str(), "0x%x", &xx);
- ev = (MIDI::eventType) xx;
- } else {
- ok = false;
- }
-
- if (ok && ((prop = node->property ("channel")) != 0)) {
- sscanf (prop->value().c_str(), "%d", &xx);
- chan = (MIDI::channel_t) xx;
- } else {
- ok = false;
- }
-
- if (ok && ((prop = node->property ("additional")) != 0)) {
- sscanf (prop->value().c_str(), "0x%x", &xx);
- additional = (MIDI::byte) xx;
- }
-
- return ok;
-}
-
-bool
-StreamPanner::set_midi_node_info (XMLNode * node, MIDI::eventType ev, MIDI::channel_t chan, MIDI::byte additional)
-{
- char buf[32];
-
- snprintf (buf, sizeof(buf), "0x%x", ev);
- node->add_property ("event", buf);
- snprintf (buf, sizeof(buf), "%d", chan);
- node->add_property ("channel", buf);
- snprintf (buf, sizeof(buf), "0x%x", additional);
- node->add_property ("additional", buf);
-
- return true;
}
/*---------------------------------------------------------------------- */
_linked = false;
_link_direction = SameDirection;
_bypassed = false;
-
- reset_midi_control (_session.mmc_port(), _session.get_mmc_control());
}
Panner::~Panner ()
(*x)->update ();
}
- reset_midi_control (_session.mmc_port(), _session.get_mmc_control());
-
/* force hard left/right panning in a common case: 2in/2out
*/
return false;
}
-void
-Panner::reset_midi_control (MIDI::Port* port, bool on)
-{
- for (vector<StreamPanner*>::const_iterator i = begin(); i != end(); ++i) {
- (*i)->reset_midi_control (port, on);
- }
-}
-
void
Panner::set_position (float xpos, StreamPanner& orig)
{
}
}
}
-
-void
-Panner::send_all_midi_feedback ()
-{
- if (_session.get_midi_feedback()) {
- float xpos;
-
- // do feedback for all panners
- for (vector<StreamPanner*>::iterator i = begin(); i != end(); ++i) {
- (*i)->get_effective_position (xpos);
-
- (*i)->midi_control().send_feedback (xpos);
- }
-
- }
-}
-
-MIDI::byte*
-Panner::write_midi_feedback (MIDI::byte* buf, int32_t& bufsize)
-{
- AutoState astate = automation_state ();
-
- if (_session.get_midi_feedback() &&
- (astate == Play || (astate == Touch && !touching()))) {
-
- float xpos;
-
- // do feedback for all panners
- for (vector<StreamPanner*>::iterator i = begin(); i != end(); ++i) {
- (*i)->get_effective_position (xpos);
-
- buf = (*i)->midi_control().write_feedback (buf, bufsize, xpos);
- }
-
- }
-
- return buf;
-}
-
{
init (hide);
_name = nom;
- _orig_diskstream_id = 0;
}
{
init (hide);
_name = "unnamed"; /* reset by set_state */
- _orig_diskstream_id = 0;
if (set_state (node)) {
throw failed_constructor();
if (prop->name() == X_("name")) {
_name = prop->value();
} else if (prop->name() == X_("orig_diskstream_id")) {
- sscanf (prop->value().c_str(), "%" PRIu64, &_orig_diskstream_id);
+ _orig_diskstream_id = prop->value ();
} else if (prop->name() == X_("frozen")) {
_frozen = (prop->value() == X_("yes"));
}
node->add_property (X_("name"), _name);
- snprintf (buf, sizeof(buf), "%" PRIu64, _orig_diskstream_id);
+ _orig_diskstream_id.print (buf);
node->add_property (X_("orig_diskstream_id"), buf);
node->add_property (X_("frozen"), _frozen ? "yes" : "no");
}
Region*
-Playlist::find_region (id_t id) const
+Playlist::find_region (const ID& id) const
{
RegionLock rlock (const_cast<Playlist*> (this));
RegionList::const_iterator i;
#include <pbd/pathscanner.h>
#include <pbd/xml++.h>
-#include <midi++/manager.h>
-
#include <ardour/ardour.h>
#include <ardour/session.h>
#include <ardour/audioengine.h>
}
void
-Plugin::setup_midi_controls ()
+Plugin::setup_controls ()
{
- uint32_t port_cnt;
-
- port_cnt = parameter_count();
+ uint32_t port_cnt = parameter_count();
- /* set up a vector of null pointers for the MIDI controls.
+ /* set up a vector of null pointers for the controls.
we'll fill this in on an as-needed basis.
*/
for (uint32_t i = 0; i < port_cnt; ++i) {
- midi_controls.push_back (0);
+ controls.push_back (0);
}
}
Plugin::~Plugin ()
{
- for (vector<MIDIPortControl*>::iterator i = midi_controls.begin(); i != midi_controls.end(); ++i) {
+ for (vector<PortControllable*>::iterator i = controls.begin(); i != controls.end(); ++i) {
if (*i) {
delete *i;
}
}
}
-MIDI::Controllable *
-Plugin::get_nth_midi_control (uint32_t n)
+Controllable *
+Plugin::get_nth_control (uint32_t n)
{
if (n >= parameter_count()) {
return 0;
}
- if (midi_controls[n] == 0) {
+ if (controls[n] == 0) {
Plugin::ParameterDescriptor desc;
get_parameter_descriptor (n, desc);
-
- midi_controls[n] = new MIDIPortControl (*this, n, _session.midi_port(), desc.lower, desc.upper, desc.toggled, desc.logarithmic);
+
+ controls[n] = new PortControllable (*this, n, desc.lower, desc.upper, desc.toggled, desc.logarithmic);
}
- return midi_controls[n];
+ return controls[n];
}
-Plugin::MIDIPortControl::MIDIPortControl (Plugin& p, uint32_t port_id, MIDI::Port *port,
- float low, float up, bool t, bool loga)
- : MIDI::Controllable (port, 0), plugin (p), absolute_port (port_id)
+Plugin::PortControllable::PortControllable (Plugin& p, uint32_t port_id, float low, float up, bool t, bool loga)
+ : plugin (p), absolute_port (port_id)
{
toggled = t;
logarithmic = loga;
lower = low;
upper = up;
range = upper - lower;
- last_written = 0; /* XXX need a good out-of-bound-value */
- setting = false;
}
void
-Plugin::MIDIPortControl::set_value (float value)
+Plugin::PortControllable::set_value (float value)
{
if (toggled) {
if (value > 0.5) {
}
}
- setting = true;
plugin.set_parameter (absolute_port, value);
- setting = false;
-}
-
-void
-Plugin::MIDIPortControl::send_feedback (float value)
-{
-
- if (!setting && get_midi_feedback()) {
- MIDI::byte val;
- MIDI::channel_t ch = 0;
- MIDI::eventType ev = MIDI::none;
- MIDI::byte additional = 0;
- MIDI::EventTwoBytes data;
-
- if (toggled) {
- val = (MIDI::byte) (value * 127.0f);
- } else {
- if (logarithmic) {
- value = log(value);
- }
-
- val = (MIDI::byte) (((value - lower) / range) * 127.0f);
- }
-
- if (get_control_info (ch, ev, additional)) {
- data.controller_number = additional;
- data.value = val;
- last_written = val;
-
- plugin.session().send_midi_message (get_port(), ev, ch, data);
- }
- }
-
}
-MIDI::byte*
-Plugin::MIDIPortControl::write_feedback (MIDI::byte* buf, int32_t& bufsize, float value, bool force)
+float
+Plugin::PortControllable::get_value (void) const
{
- if (get_midi_feedback() && bufsize > 2) {
- MIDI::channel_t ch = 0;
- MIDI::eventType ev = MIDI::none;
- MIDI::byte additional = 0;
-
- if (get_control_info (ch, ev, additional)) {
-
- MIDI::byte val;
-
- if (toggled) {
+ float val = plugin.get_parameter (absolute_port);
- val = (MIDI::byte) (value * 127.0f);
-
- } else {
-
- if (logarithmic) {
- value = log(value);
- }
-
- val = (MIDI::byte) (((value - lower) / range) * 127.0f);
- }
-
- if (val != last_written || force) {
- *buf++ = MIDI::controller & ch;
- *buf++ = additional; /* controller number */
- *buf++ = val;
- last_written = val;
- bufsize -= 3;
- }
- }
- }
-
- return buf;
-}
-
-
-void
-Plugin::reset_midi_control (MIDI::Port* port, bool on)
-{
- MIDI::channel_t chn;
- MIDI::eventType ev;
- MIDI::byte extra;
-
- for (vector<MIDIPortControl*>::iterator i = midi_controls.begin(); i != midi_controls.end(); ++i) {
- if (*i == 0)
- continue;
- (*i)->get_control_info (chn, ev, extra);
- if (!on) {
- chn = -1;
- }
- (*i)->midi_rebind (port, chn);
- }
-}
-
-void
-Plugin::send_all_midi_feedback ()
-{
- if (_session.get_midi_feedback()) {
- float val = 0.0;
- uint32_t n = 0;
+ if (toggled) {
- for (vector<MIDIPortControl*>::iterator i = midi_controls.begin(); i != midi_controls.end(); ++i, ++n) {
- if (*i == 0) {
- continue;
- }
-
- val = (*i)->plugin.get_parameter (n);
- (*i)->send_feedback (val);
- }
+ return val;
- }
-}
-
-MIDI::byte*
-Plugin::write_midi_feedback (MIDI::byte* buf, int32_t& bufsize)
-{
- if (_session.get_midi_feedback()) {
- float val = 0.0;
- uint32_t n = 0;
+ } else {
- for (vector<MIDIPortControl*>::iterator i = midi_controls.begin(); i != midi_controls.end(); ++i, ++n) {
- if (*i == 0) {
- continue;
- }
-
- val = (*i)->plugin.get_parameter (n);
- buf = (*i)->write_feedback (buf, bufsize, val);
+ if (logarithmic) {
+ val = log(val);
}
+
+ return ((val - lower) / range);
}
-
- return buf;
-}
+}
vector<string>
Plugin::get_presets()
msgstr ""
"Project-Id-Version: libardour 0.664.0\n"
"Report-Msgid-Bugs-To: \n"
-"POT-Creation-Date: 2006-06-27 13:00-0400\n"
+"POT-Creation-Date: 2006-06-29 21:03-0400\n"
"PO-Revision-Date: 2003-05-21 12:50+0500\n"
"Last-Translator: Muadibas\n"
"Language-Team: Hellenic(Greek)\n"
msgstr ""
"DiskStream \"%1\": δεν γίνεται να απορριφθούν δειγματοληψίες στο δίσκο!"
-#: libs/ardour/audio_diskstream.cc:1795
+#: libs/ardour/audio_diskstream.cc:1796
msgid "%1: could not create region for complete audio file"
msgstr "%1: δεν μπόρεσα να δημιουργήσω περιοχή για ολόκληρο audio file"
-#: libs/ardour/audio_diskstream.cc:1818
+#: libs/ardour/audio_diskstream.cc:1819
#, fuzzy
msgid "AudioDiskstream: could not create region for captured audio!"
msgstr "DiskStream: δεν μπόρεσα να δημιουργήσω περιοχή για δειγματοληψίες!"
-#: libs/ardour/audio_diskstream.cc:1873
+#: libs/ardour/audio_diskstream.cc:1874
#, fuzzy
msgid "programmer error: %1"
msgstr "σφάλμα προγραμματισμού: %1"
-#: libs/ardour/audio_diskstream.cc:2145
+#: libs/ardour/audio_diskstream.cc:2146
#, fuzzy
msgid "AudioDiskstream: channel %1 out of range"
msgstr "DiskStream: κανάλι εκτός διαστήματος"
-#: libs/ardour/audio_diskstream.cc:2170
+#: libs/ardour/audio_diskstream.cc:2171
msgid "%1:%2 new capture file not initialized correctly"
msgstr "%1:%2 νέα δειγματοληψία δεν εκκινήθη σωστά"
-#: libs/ardour/audio_diskstream.cc:2403
+#: libs/ardour/audio_diskstream.cc:2404
msgid "Location \"%1\" not valid for track loop (start >= end)"
msgstr "Η Τοποθεσία \"%1\" δεν είναι ικανή για track loop (αρχή >= τέλος)"
-#: libs/ardour/audio_diskstream.cc:2484
+#: libs/ardour/audio_diskstream.cc:2485
#, fuzzy
msgid "%1: cannot restore pending capture source file %2"
msgstr "Εισαγωγή: δεν μπορώ να ανοίξω το εισαγμένο αρχείο ήχου \"%1\""
-#: libs/ardour/audio_diskstream.cc:2506
+#: libs/ardour/audio_diskstream.cc:2507
msgid "%1: incorrect number of pending sources listed - ignoring them all"
msgstr ""
-#: libs/ardour/audio_diskstream.cc:2522
+#: libs/ardour/audio_diskstream.cc:2523
msgid "%1: cannot create whole-file region from pending capture sources"
msgstr ""
-#: libs/ardour/audio_diskstream.cc:2534
+#: libs/ardour/audio_diskstream.cc:2535
#, fuzzy
msgid "%1: cannot create region from pending capture sources"
msgstr "%1: δεν μπόρεσα να δημιουργήσω περιοχή για ολόκληρο audio file"
msgid "region modified"
msgstr "η περιοχή μετεβλήθη"
-#: libs/ardour/audio_track.cc:133 libs/ardour/io.cc:1716
+#: libs/ardour/audio_track.cc:125 libs/ardour/io.cc:1716
#: libs/ardour/io.cc:1826
msgid "Unknown connection \"%1\" listed for input of %2"
msgstr "Άγνωστη σύνδεση \"%1\" στη λίστα εισόδου του %2"
-#: libs/ardour/audio_track.cc:135 libs/ardour/io.cc:1718
+#: libs/ardour/audio_track.cc:127 libs/ardour/io.cc:1718
#: libs/ardour/io.cc:1828
#, fuzzy
msgid "in 1"
msgstr "in %lu"
-#: libs/ardour/audio_track.cc:136 libs/ardour/io.cc:1719
+#: libs/ardour/audio_track.cc:128 libs/ardour/io.cc:1719
#: libs/ardour/io.cc:1829
msgid "No input connections available as a replacement"
msgstr ""
-#: libs/ardour/audio_track.cc:140 libs/ardour/io.cc:1723
+#: libs/ardour/audio_track.cc:132 libs/ardour/io.cc:1723
#: libs/ardour/io.cc:1833
msgid "Connection %1 was not available - \"in 1\" used instead"
msgstr ""
-#: libs/ardour/audio_track.cc:149 libs/ardour/io.cc:1842
+#: libs/ardour/audio_track.cc:141 libs/ardour/io.cc:1842
msgid "improper input channel list in XML node (%1)"
msgstr "ακατάλληλη λίστα καναλιών εισόδου στον κόμβο XML (%1)"
-#: libs/ardour/audio_track.cc:194 libs/ardour/audio_track.cc:207
+#: libs/ardour/audio_track.cc:186 libs/ardour/audio_track.cc:199
msgid "AudioTrack: diskstream \"%1\" not known by session"
msgstr "AudioTrack: το diskstream \"%1\" είναι μή αναγνωρίσιμο από τη συνεδρία"
-#: libs/ardour/audio_track.cc:305
+#: libs/ardour/audio_track.cc:297
#, fuzzy
msgid ""
"MIDI rec_enable control specification for %1 is incomplete, so it has been "
"Η προδιαγραφή ελέγχου του MIDI gain για το %1 είναι ημιτελής, με αποτέλεσμα "
"να αγνοηθεί"
-#: libs/ardour/audio_track.cc:317
+#: libs/ardour/audio_track.cc:309
msgid "programming error: AudioTrack given state without diskstream!"
msgstr ""
"σφάλμα προγραμματισμού: εδόθη κατάσταση στην AudioTrack δίχως diskstream!"
msgid "could not reconnect %1 and %2 (err = %3)"
msgstr ""
-#: libs/ardour/audiofilesource.cc:445 libs/ardour/session_state.cc:3095
+#: libs/ardour/audiofilesource.cc:444 libs/ardour/session_state.cc:3095
msgid ""
"there are already 1000 files with names like %1; versioning discontinued"
msgstr "Υπάρχουν ήδη 1000 αρχεία με ονόματα όπως %1; μη-συνεχές versioning"
-#: libs/ardour/audiofilesource.cc:459 libs/ardour/session_state.cc:3109
+#: libs/ardour/audiofilesource.cc:458 libs/ardour/session_state.cc:3109
msgid "cannot rename audio file source from %1 to %2 (%3)"
msgstr "δεν μπορώ να μετονομάσω την πηγή του audio file από %1 σε %2 (%3)"
-#: libs/ardour/audiofilesource.cc:466 libs/ardour/session_state.cc:3124
+#: libs/ardour/audiofilesource.cc:465 libs/ardour/session_state.cc:3124
msgid "cannot remove peakfile %1 for %2 (%3)"
msgstr "δεν μπορώ να απαλοίψω το peakfile %1 για %2 (%3)"
-#: libs/ardour/audiofilesource.cc:510
+#: libs/ardour/audiofilesource.cc:509
msgid "FileSource: search path not set"
msgstr "FileSource: μονοπάτι αναζητήσεως δεν ετέθη"
-#: libs/ardour/audiofilesource.cc:534
+#: libs/ardour/audiofilesource.cc:533
msgid ""
"FileSource: \"%1\" is ambigous when searching %2\n"
"\t"
"FileSource: \"%1\" είναι αμφίβολο κατά την αναζήτηση του %2\n"
"\t"
-#: libs/ardour/audiofilesource.cc:540
+#: libs/ardour/audiofilesource.cc:539
#, fuzzy
msgid "Filesource: cannot find required file (%1): while searching %2"
msgstr "Filesource: δεν ευρέθη το απαιτούμενο αρχείο (%1): %2"
-#: libs/ardour/audiofilesource.cc:563
+#: libs/ardour/audiofilesource.cc:562
msgid "Filesource: cannot find required file (%1): %2"
msgstr "Filesource: δεν ευρέθη το απαιτούμενο αρχείο (%1): %2"
-#: libs/ardour/audiofilesource.cc:568
+#: libs/ardour/audiofilesource.cc:567
msgid "Filesource: cannot check for existing file (%1): %2"
msgstr "Filesource: δεν μπορώ να ελέγξω για το υπάρχον αρχείο (%1): %2"
-#: libs/ardour/audiofilesource.cc:640 libs/ardour/insert.cc:525
-#: libs/ardour/sndfilesource.cc:112
+#: libs/ardour/audiofilesource.cc:636 libs/ardour/insert.cc:525
+#: libs/ardour/sndfilesource.cc:113
msgid "programming error: %1"
msgstr "σφάλμα προγραμματισμού: %1"
-#: libs/ardour/audiofilesource.cc:645
+#: libs/ardour/audiofilesource.cc:641
#, fuzzy
msgid "cannot rename audio file for %1 to %2"
msgstr "δεν μπορώ να μετονομάσω την πηγή του audio file από %1 σε %2 (%3)"
msgid "cannot remove dead sound file %1 (%2)"
msgstr "δεν μπορώ να απαλοίψω το 'νεκρο' ηχο-αρχείο %1 (%2)"
-#: libs/ardour/session_time.cc:375
+#: libs/ardour/session_time.cc:374
msgid "Unknown JACK transport state %1 in sync callback"
msgstr "Άγνωστη κατάσταση του JACK transport %1 στην ανάκληση sync"
msgid "Big-endian (Mac)"
msgstr "Big-endian (Mac)"
-#: libs/ardour/sndfilesource.cc:146
+#: libs/ardour/sndfilesource.cc:147
msgid "FileSource: cannot get host information for BWF header (%1)"
msgstr ""
"FileSource: δεν μπορώ να βρώ πληροφορίες οικοδεσπότη(host) για επικεφαλίδα "
"BWF (%1)"
-#: libs/ardour/sndfilesource.cc:168
+#: libs/ardour/sndfilesource.cc:169
msgid ""
"cannot set broadcast info for audio file %1 (%2); dropping broadcast info "
"for this file"
msgstr ""
-#: libs/ardour/sndfilesource.cc:224
+#: libs/ardour/sndfilesource.cc:220
#, fuzzy
msgid "SndFileSource: cannot open file \"%1\" for %2 (%3)"
msgstr "SndFileSource: δεν μπορώ να ανοίξω το αρχείο \"%1\" (%2)"
-#: libs/ardour/sndfilesource.cc:230
+#: libs/ardour/sndfilesource.cc:226
msgid ""
"SndFileSource: file only contains %1 channels; %2 is invalid as a channel "
"number"
"SndFileSource: το αρχείο περιέχει μόνο %1 κανάλια; %2 δεν έχει αξία σαν "
"κανάλι number"
-#: libs/ardour/sndfilesource.cc:307
+#: libs/ardour/sndfilesource.cc:327
msgid "SndFileSource: could not seek to frame %1 within %2 (%3)"
msgstr "SndFileSource: δεν μπορούσα να αναζητήσω στο frame %1 μέσα στο %2 (%3)"
-#: libs/ardour/sndfilesource.cc:358
+#: libs/ardour/sndfilesource.cc:378
#, fuzzy
msgid "programming error: %1 %2"
msgstr "σφάλμα προγραμματισμού: %1"
-#: libs/ardour/sndfilesource.cc:458
+#: libs/ardour/sndfilesource.cc:487 libs/ardour/sndfilesource.cc:533
msgid ""
"cannot set broadcast info for audio file %1; Dropping broadcast info for "
"this file"
msgstr ""
-#: libs/ardour/sndfilesource.cc:500
+#: libs/ardour/sndfilesource.cc:544
#, fuzzy
msgid "%1: cannot seek to %2"
msgstr "%1: δεν μπορώ να αναζητήσω στο %2 για εξαγωγή"
msgstr ""
"καμμία υποστήριξη αυτή τη στιγμή για ρυθμίσεις που χρησιμοποιούν κομμάτια"
-#: libs/ardour/coreaudio_source.cc:99
+#: libs/ardour/coreaudiosource.cc:97
#, fuzzy
msgid ""
"CoreAudioSource: file only contains %1 channels; %2 is invalid as a channel "
"SndFileSource: το αρχείο περιέχει μόνο %1 κανάλια; %2 δεν έχει αξία σαν "
"κανάλι number"
-#: libs/ardour/coreaudio_source.cc:164
+#: libs/ardour/coreaudiosource.cc:162
#, fuzzy
msgid "CoreAudioSource: could not seek to frame %1 within %2 (%3)"
msgstr "SndFileSource: δεν μπορούσα να αναζητήσω στο frame %1 μέσα στο %2 (%3)"
msgstr ""
"Project-Id-Version: libardour 0.664.0\n"
"Report-Msgid-Bugs-To: \n"
-"POT-Creation-Date: 2006-06-27 13:00-0400\n"
+"POT-Creation-Date: 2006-06-29 21:03-0400\n"
"PO-Revision-Date: 2003-05-21 12:50+0500\n"
"Last-Translator: Filippo Pappalardo <filippo@email.it>\n"
"Language-Team: Italian\n"
msgid "AudioDiskstream \"%1\": cannot flush captured data to disk!"
msgstr "DiskStream \"%1\": impossibile scaricare i dati acquisiti sul disco!"
-#: libs/ardour/audio_diskstream.cc:1795
+#: libs/ardour/audio_diskstream.cc:1796
msgid "%1: could not create region for complete audio file"
msgstr "%1: impossibile creare una regione per il file audio completo"
-#: libs/ardour/audio_diskstream.cc:1818
+#: libs/ardour/audio_diskstream.cc:1819
#, fuzzy
msgid "AudioDiskstream: could not create region for captured audio!"
msgstr "DiskStream: impossibile creare una regione per l'audio registrato!"
-#: libs/ardour/audio_diskstream.cc:1873
+#: libs/ardour/audio_diskstream.cc:1874
#, fuzzy
msgid "programmer error: %1"
msgstr "errore di programmazione: %1"
-#: libs/ardour/audio_diskstream.cc:2145
+#: libs/ardour/audio_diskstream.cc:2146
#, fuzzy
msgid "AudioDiskstream: channel %1 out of range"
msgstr "DiskStream: canale fuori margine"
-#: libs/ardour/audio_diskstream.cc:2170
+#: libs/ardour/audio_diskstream.cc:2171
msgid "%1:%2 new capture file not initialized correctly"
msgstr "%1:%2 nuovo file di registrazione non � stato avviato correttamente"
-#: libs/ardour/audio_diskstream.cc:2403
+#: libs/ardour/audio_diskstream.cc:2404
msgid "Location \"%1\" not valid for track loop (start >= end)"
msgstr "La Location \"%1\" non valida per il loop (inizio >= fine)"
-#: libs/ardour/audio_diskstream.cc:2484
+#: libs/ardour/audio_diskstream.cc:2485
#, fuzzy
msgid "%1: cannot restore pending capture source file %2"
msgstr "Import: impossibile aprire il file audio di input \"%1\""
-#: libs/ardour/audio_diskstream.cc:2506
+#: libs/ardour/audio_diskstream.cc:2507
msgid "%1: incorrect number of pending sources listed - ignoring them all"
msgstr ""
-#: libs/ardour/audio_diskstream.cc:2522
+#: libs/ardour/audio_diskstream.cc:2523
#, fuzzy
msgid "%1: cannot create whole-file region from pending capture sources"
msgstr "Playlist: impossibile creare la Regione dal file di stato"
-#: libs/ardour/audio_diskstream.cc:2534
+#: libs/ardour/audio_diskstream.cc:2535
#, fuzzy
msgid "%1: cannot create region from pending capture sources"
msgstr "Playlist: impossibile creare la Regione dal file di stato"
msgid "region modified"
msgstr "regione modificata"
-#: libs/ardour/audio_track.cc:133 libs/ardour/io.cc:1716
+#: libs/ardour/audio_track.cc:125 libs/ardour/io.cc:1716
#: libs/ardour/io.cc:1826
msgid "Unknown connection \"%1\" listed for input of %2"
msgstr "Connessione sconosciuta \"%1\" come input di %2"
-#: libs/ardour/audio_track.cc:135 libs/ardour/io.cc:1718
+#: libs/ardour/audio_track.cc:127 libs/ardour/io.cc:1718
#: libs/ardour/io.cc:1828
msgid "in 1"
msgstr ""
-#: libs/ardour/audio_track.cc:136 libs/ardour/io.cc:1719
+#: libs/ardour/audio_track.cc:128 libs/ardour/io.cc:1719
#: libs/ardour/io.cc:1829
msgid "No input connections available as a replacement"
msgstr ""
-#: libs/ardour/audio_track.cc:140 libs/ardour/io.cc:1723
+#: libs/ardour/audio_track.cc:132 libs/ardour/io.cc:1723
#: libs/ardour/io.cc:1833
msgid "Connection %1 was not available - \"in 1\" used instead"
msgstr ""
-#: libs/ardour/audio_track.cc:149 libs/ardour/io.cc:1842
+#: libs/ardour/audio_track.cc:141 libs/ardour/io.cc:1842
msgid "improper input channel list in XML node (%1)"
msgstr ""
-#: libs/ardour/audio_track.cc:194 libs/ardour/audio_track.cc:207
+#: libs/ardour/audio_track.cc:186 libs/ardour/audio_track.cc:199
msgid "AudioTrack: diskstream \"%1\" not known by session"
msgstr "AudioTrack: diskstream \"%1\" non riconosciuto dalla sessione"
-#: libs/ardour/audio_track.cc:305
+#: libs/ardour/audio_track.cc:297
msgid ""
"MIDI rec_enable control specification for %1 is incomplete, so it has been "
"ignored"
msgstr ""
-#: libs/ardour/audio_track.cc:317
+#: libs/ardour/audio_track.cc:309
msgid "programming error: AudioTrack given state without diskstream!"
msgstr ""
msgid "could not reconnect %1 and %2 (err = %3)"
msgstr ""
-#: libs/ardour/audiofilesource.cc:445 libs/ardour/session_state.cc:3095
+#: libs/ardour/audiofilesource.cc:444 libs/ardour/session_state.cc:3095
msgid ""
"there are already 1000 files with names like %1; versioning discontinued"
msgstr ""
"ci sono gia' 1000 file con nomi come %1; tracciamento di versione interrotto"
-#: libs/ardour/audiofilesource.cc:459 libs/ardour/session_state.cc:3109
+#: libs/ardour/audiofilesource.cc:458 libs/ardour/session_state.cc:3109
msgid "cannot rename audio file source from %1 to %2 (%3)"
msgstr "impossibile rinominare file audio sorgente da %1 a %2 (%3)"
-#: libs/ardour/audiofilesource.cc:466 libs/ardour/session_state.cc:3124
+#: libs/ardour/audiofilesource.cc:465 libs/ardour/session_state.cc:3124
msgid "cannot remove peakfile %1 for %2 (%3)"
msgstr "impossibile eliminare il peakfile %1 per %2 (%3)"
-#: libs/ardour/audiofilesource.cc:510
+#: libs/ardour/audiofilesource.cc:509
msgid "FileSource: search path not set"
msgstr "FileSource: percorso di ricerca non specificato"
-#: libs/ardour/audiofilesource.cc:534
+#: libs/ardour/audiofilesource.cc:533
msgid ""
"FileSource: \"%1\" is ambigous when searching %2\n"
"\t"
"FileSource: \"%1\" � risultato ambiguo nel cercare %2\n"
"\t"
-#: libs/ardour/audiofilesource.cc:540
+#: libs/ardour/audiofilesource.cc:539
#, fuzzy
msgid "Filesource: cannot find required file (%1): while searching %2"
msgstr "FileSource: impossibile trovare il file richiesto (%1): %2"
-#: libs/ardour/audiofilesource.cc:563
+#: libs/ardour/audiofilesource.cc:562
msgid "Filesource: cannot find required file (%1): %2"
msgstr "FileSource: impossibile trovare il file richiesto (%1): %2"
-#: libs/ardour/audiofilesource.cc:568
+#: libs/ardour/audiofilesource.cc:567
msgid "Filesource: cannot check for existing file (%1): %2"
msgstr "FileSource: impossibile controllare il file esistente (%1): %2"
-#: libs/ardour/audiofilesource.cc:640 libs/ardour/insert.cc:525
-#: libs/ardour/sndfilesource.cc:112
+#: libs/ardour/audiofilesource.cc:636 libs/ardour/insert.cc:525
+#: libs/ardour/sndfilesource.cc:113
msgid "programming error: %1"
msgstr "errore di programmazione: %1"
-#: libs/ardour/audiofilesource.cc:645
+#: libs/ardour/audiofilesource.cc:641
#, fuzzy
msgid "cannot rename audio file for %1 to %2"
msgstr "impossibile rinominare file audio sorgente da %1 a %2 (%3)"
msgid "cannot remove dead sound file %1 (%2)"
msgstr "impossibile accedere al file audio per il click %1 (%2)"
-#: libs/ardour/session_time.cc:375
+#: libs/ardour/session_time.cc:374
msgid "Unknown JACK transport state %1 in sync callback"
msgstr ""
msgid "Big-endian (Mac)"
msgstr ""
-#: libs/ardour/sndfilesource.cc:146
+#: libs/ardour/sndfilesource.cc:147
msgid "FileSource: cannot get host information for BWF header (%1)"
msgstr "FileSource: impossibile ottenere info sull'host dall'header BWF (%1)"
-#: libs/ardour/sndfilesource.cc:168
+#: libs/ardour/sndfilesource.cc:169
msgid ""
"cannot set broadcast info for audio file %1 (%2); dropping broadcast info "
"for this file"
msgstr ""
-#: libs/ardour/sndfilesource.cc:224
+#: libs/ardour/sndfilesource.cc:220
#, fuzzy
msgid "SndFileSource: cannot open file \"%1\" for %2 (%3)"
msgstr "SndFileSource: impossibile accedere al file \"%1\" (%2)"
-#: libs/ardour/sndfilesource.cc:230
+#: libs/ardour/sndfilesource.cc:226
msgid ""
"SndFileSource: file only contains %1 channels; %2 is invalid as a channel "
"number"
"SndFileSource: il file contiene solo %1 canali; %2 non � valido come numero "
"di canale"
-#: libs/ardour/sndfilesource.cc:307
+#: libs/ardour/sndfilesource.cc:327
msgid "SndFileSource: could not seek to frame %1 within %2 (%3)"
msgstr ""
-#: libs/ardour/sndfilesource.cc:358
+#: libs/ardour/sndfilesource.cc:378
#, fuzzy
msgid "programming error: %1 %2"
msgstr "errore di programmazione: %1"
-#: libs/ardour/sndfilesource.cc:458
+#: libs/ardour/sndfilesource.cc:487 libs/ardour/sndfilesource.cc:533
msgid ""
"cannot set broadcast info for audio file %1; Dropping broadcast info for "
"this file"
msgstr ""
-#: libs/ardour/sndfilesource.cc:500
+#: libs/ardour/sndfilesource.cc:544
msgid "%1: cannot seek to %2"
msgstr ""
msgid "no support for presets using chunks at this time"
msgstr ""
-#: libs/ardour/coreaudio_source.cc:99
+#: libs/ardour/coreaudiosource.cc:97
#, fuzzy
msgid ""
"CoreAudioSource: file only contains %1 channels; %2 is invalid as a channel "
"SndFileSource: il file contiene solo %1 canali; %2 non � valido come numero "
"di canale"
-#: libs/ardour/coreaudio_source.cc:164
+#: libs/ardour/coreaudiosource.cc:162
msgid "CoreAudioSource: could not seek to frame %1 within %2 (%3)"
msgstr ""
msgstr ""
"Project-Id-Version: libardour 0.716.1\n"
"Report-Msgid-Bugs-To: \n"
-"POT-Creation-Date: 2006-06-27 13:00-0400\n"
+"POT-Creation-Date: 2006-06-29 21:03-0400\n"
"PO-Revision-Date: 2004-03-31 00:55+0300\n"
"Last-Translator: Igor Blinov pitstop@nm.ru\n"
"Language-Team: Russian\n"
msgid "AudioDiskstream \"%1\": cannot flush captured data to disk!"
msgstr ""
-#: libs/ardour/audio_diskstream.cc:1795
+#: libs/ardour/audio_diskstream.cc:1796
msgid "%1: could not create region for complete audio file"
msgstr ""
-#: libs/ardour/audio_diskstream.cc:1818
+#: libs/ardour/audio_diskstream.cc:1819
msgid "AudioDiskstream: could not create region for captured audio!"
msgstr ""
-#: libs/ardour/audio_diskstream.cc:1873
+#: libs/ardour/audio_diskstream.cc:1874
#, fuzzy
msgid "programmer error: %1"
msgstr "������ ���������: "
-#: libs/ardour/audio_diskstream.cc:2145
+#: libs/ardour/audio_diskstream.cc:2146
msgid "AudioDiskstream: channel %1 out of range"
msgstr ""
-#: libs/ardour/audio_diskstream.cc:2170
+#: libs/ardour/audio_diskstream.cc:2171
msgid "%1:%2 new capture file not initialized correctly"
msgstr ""
-#: libs/ardour/audio_diskstream.cc:2403
+#: libs/ardour/audio_diskstream.cc:2404
msgid "Location \"%1\" not valid for track loop (start >= end)"
msgstr ""
-#: libs/ardour/audio_diskstream.cc:2484
+#: libs/ardour/audio_diskstream.cc:2485
msgid "%1: cannot restore pending capture source file %2"
msgstr ""
-#: libs/ardour/audio_diskstream.cc:2506
+#: libs/ardour/audio_diskstream.cc:2507
msgid "%1: incorrect number of pending sources listed - ignoring them all"
msgstr ""
-#: libs/ardour/audio_diskstream.cc:2522
+#: libs/ardour/audio_diskstream.cc:2523
msgid "%1: cannot create whole-file region from pending capture sources"
msgstr ""
-#: libs/ardour/audio_diskstream.cc:2534
+#: libs/ardour/audio_diskstream.cc:2535
msgid "%1: cannot create region from pending capture sources"
msgstr ""
msgid "region modified"
msgstr ""
-#: libs/ardour/audio_track.cc:133 libs/ardour/io.cc:1716
+#: libs/ardour/audio_track.cc:125 libs/ardour/io.cc:1716
#: libs/ardour/io.cc:1826
msgid "Unknown connection \"%1\" listed for input of %2"
msgstr ""
-#: libs/ardour/audio_track.cc:135 libs/ardour/io.cc:1718
+#: libs/ardour/audio_track.cc:127 libs/ardour/io.cc:1718
#: libs/ardour/io.cc:1828
msgid "in 1"
msgstr ""
-#: libs/ardour/audio_track.cc:136 libs/ardour/io.cc:1719
+#: libs/ardour/audio_track.cc:128 libs/ardour/io.cc:1719
#: libs/ardour/io.cc:1829
msgid "No input connections available as a replacement"
msgstr ""
-#: libs/ardour/audio_track.cc:140 libs/ardour/io.cc:1723
+#: libs/ardour/audio_track.cc:132 libs/ardour/io.cc:1723
#: libs/ardour/io.cc:1833
msgid "Connection %1 was not available - \"in 1\" used instead"
msgstr ""
-#: libs/ardour/audio_track.cc:149 libs/ardour/io.cc:1842
+#: libs/ardour/audio_track.cc:141 libs/ardour/io.cc:1842
msgid "improper input channel list in XML node (%1)"
msgstr ""
-#: libs/ardour/audio_track.cc:194 libs/ardour/audio_track.cc:207
+#: libs/ardour/audio_track.cc:186 libs/ardour/audio_track.cc:199
msgid "AudioTrack: diskstream \"%1\" not known by session"
msgstr ""
-#: libs/ardour/audio_track.cc:305
+#: libs/ardour/audio_track.cc:297
msgid ""
"MIDI rec_enable control specification for %1 is incomplete, so it has been "
"ignored"
msgstr ""
-#: libs/ardour/audio_track.cc:317
+#: libs/ardour/audio_track.cc:309
msgid "programming error: AudioTrack given state without diskstream!"
msgstr ""
msgid "could not reconnect %1 and %2 (err = %3)"
msgstr ""
-#: libs/ardour/audiofilesource.cc:445 libs/ardour/session_state.cc:3095
+#: libs/ardour/audiofilesource.cc:444 libs/ardour/session_state.cc:3095
msgid ""
"there are already 1000 files with names like %1; versioning discontinued"
msgstr ""
-#: libs/ardour/audiofilesource.cc:459 libs/ardour/session_state.cc:3109
+#: libs/ardour/audiofilesource.cc:458 libs/ardour/session_state.cc:3109
msgid "cannot rename audio file source from %1 to %2 (%3)"
msgstr ""
-#: libs/ardour/audiofilesource.cc:466 libs/ardour/session_state.cc:3124
+#: libs/ardour/audiofilesource.cc:465 libs/ardour/session_state.cc:3124
msgid "cannot remove peakfile %1 for %2 (%3)"
msgstr ""
-#: libs/ardour/audiofilesource.cc:510
+#: libs/ardour/audiofilesource.cc:509
msgid "FileSource: search path not set"
msgstr ""
-#: libs/ardour/audiofilesource.cc:534
+#: libs/ardour/audiofilesource.cc:533
msgid ""
"FileSource: \"%1\" is ambigous when searching %2\n"
"\t"
msgstr ""
-#: libs/ardour/audiofilesource.cc:540
+#: libs/ardour/audiofilesource.cc:539
msgid "Filesource: cannot find required file (%1): while searching %2"
msgstr ""
-#: libs/ardour/audiofilesource.cc:563
+#: libs/ardour/audiofilesource.cc:562
msgid "Filesource: cannot find required file (%1): %2"
msgstr ""
-#: libs/ardour/audiofilesource.cc:568
+#: libs/ardour/audiofilesource.cc:567
msgid "Filesource: cannot check for existing file (%1): %2"
msgstr ""
-#: libs/ardour/audiofilesource.cc:640 libs/ardour/insert.cc:525
-#: libs/ardour/sndfilesource.cc:112
+#: libs/ardour/audiofilesource.cc:636 libs/ardour/insert.cc:525
+#: libs/ardour/sndfilesource.cc:113
#, fuzzy
msgid "programming error: %1"
msgstr "������ ���������: "
-#: libs/ardour/audiofilesource.cc:645
+#: libs/ardour/audiofilesource.cc:641
msgid "cannot rename audio file for %1 to %2"
msgstr ""
msgid "cannot remove dead sound file %1 (%2)"
msgstr ""
-#: libs/ardour/session_time.cc:375
+#: libs/ardour/session_time.cc:374
msgid "Unknown JACK transport state %1 in sync callback"
msgstr ""
msgid "Big-endian (Mac)"
msgstr ""
-#: libs/ardour/sndfilesource.cc:146
+#: libs/ardour/sndfilesource.cc:147
msgid "FileSource: cannot get host information for BWF header (%1)"
msgstr ""
-#: libs/ardour/sndfilesource.cc:168
+#: libs/ardour/sndfilesource.cc:169
msgid ""
"cannot set broadcast info for audio file %1 (%2); dropping broadcast info "
"for this file"
msgstr ""
-#: libs/ardour/sndfilesource.cc:224
+#: libs/ardour/sndfilesource.cc:220
msgid "SndFileSource: cannot open file \"%1\" for %2 (%3)"
msgstr ""
-#: libs/ardour/sndfilesource.cc:230
+#: libs/ardour/sndfilesource.cc:226
msgid ""
"SndFileSource: file only contains %1 channels; %2 is invalid as a channel "
"number"
msgstr ""
-#: libs/ardour/sndfilesource.cc:307
+#: libs/ardour/sndfilesource.cc:327
msgid "SndFileSource: could not seek to frame %1 within %2 (%3)"
msgstr ""
-#: libs/ardour/sndfilesource.cc:358
+#: libs/ardour/sndfilesource.cc:378
#, fuzzy
msgid "programming error: %1 %2"
msgstr "������ ���������: "
-#: libs/ardour/sndfilesource.cc:458
+#: libs/ardour/sndfilesource.cc:487 libs/ardour/sndfilesource.cc:533
msgid ""
"cannot set broadcast info for audio file %1; Dropping broadcast info for "
"this file"
msgstr ""
-#: libs/ardour/sndfilesource.cc:500
+#: libs/ardour/sndfilesource.cc:544
msgid "%1: cannot seek to %2"
msgstr ""
msgid "no support for presets using chunks at this time"
msgstr ""
-#: libs/ardour/coreaudio_source.cc:99
+#: libs/ardour/coreaudiosource.cc:97
msgid ""
"CoreAudioSource: file only contains %1 channels; %2 is invalid as a channel "
"number"
msgstr ""
-#: libs/ardour/coreaudio_source.cc:164
+#: libs/ardour/coreaudiosource.cc:162
msgid "CoreAudioSource: could not seek to frame %1 within %2 (%3)"
msgstr ""
string path;
string legal_name;
- snprintf (buf, sizeof(buf), "%" PRIu64, id());
path = _session.snap_name();
path += "-redirect-";
+ id().print (buf);
path += buf;
path += ".automation";
{
/* basic Region constructor */
- _id = ARDOUR::new_id();
_flags = flags;
_playlist = 0;
_read_data_count = 0;
{
/* create a new Region from part of an existing one */
- _id = ARDOUR::new_id();
_frozen = 0;
pending_changed = Change (0);
_playlist = 0;
{
/* Pure copy constructor */
- _id = ARDOUR::new_id();
_frozen = 0;
pending_changed = Change (0);
_playlist = 0;
Region::Region (const XMLNode& node)
{
- _id = 0;
_frozen = 0;
pending_changed = Change (0);
_playlist = 0;
XMLNode *node = new XMLNode ("Region");
char buf[64];
- snprintf (buf, sizeof (buf), "%" PRIu64, _id);
+ _id.print (buf);
node->add_property ("id", buf);
node->add_property ("name", _name);
snprintf (buf, sizeof (buf), "%u", _start);
return -1;
}
- sscanf (prop->value().c_str(), "%" PRIu64, &_id);
+ _id = prop->value();
if ((prop = node.property ("name")) == 0) {
error << _("Session: XMLNode describing a Region is incomplete (no name)") << endmsg;
Route::Route (Session& sess, string name, int input_min, int input_max, int output_min, int output_max, Flag flg)
: IO (sess, name, input_min, input_max, output_min, output_max),
_flags (flg),
- _midi_solo_control (*this, MIDIToggleControl::SoloControl, _session.midi_port()),
- _midi_mute_control (*this, MIDIToggleControl::MuteControl, _session.midi_port())
+ _solo_control (*this, ToggleControllable::SoloControl),
+ _mute_control (*this, ToggleControllable::MuteControl)
{
init ();
}
Route::Route (Session& sess, const XMLNode& node)
: IO (sess, "route"),
- _midi_solo_control (*this, MIDIToggleControl::SoloControl, _session.midi_port()),
- _midi_mute_control (*this, MIDIToggleControl::MuteControl, _session.midi_port())
+ _solo_control (*this, ToggleControllable::SoloControl),
+ _mute_control (*this, ToggleControllable::MuteControl)
{
init ();
set_state (node);
input_changed.connect (mem_fun (this, &Route::input_change_handler));
output_changed.connect (mem_fun (this, &Route::output_change_handler));
-
- reset_midi_control (_session.midi_port(), _session.get_midi_control());
}
Route::~Route ()
if (_soloed != yn) {
_soloed = yn;
- solo_changed (src); /* EMIT SIGNAL */
-
- if (_session.get_midi_feedback()) {
- _midi_solo_control.send_feedback (_soloed);
- }
+ solo_changed (src); /* EMIT SIGNAL */
+ _solo_control.Changed (); /* EMIT SIGNAL */
}
}
_muted = yn;
mute_changed (src); /* EMIT SIGNAL */
- if (_session.get_midi_feedback()) {
- _midi_mute_control.send_feedback (_muted);
- }
+ _mute_control.Changed (); /* EMIT SIGNAL */
Glib::Mutex::Lock lm (declick_lock);
desired_mute_gain = (yn?0.0f:1.0f);
node->add_property("mix-group", _mix_group->name());
}
- /* MIDI control */
-
- MIDI::channel_t chn;
- MIDI::eventType ev;
- MIDI::byte additional;
- XMLNode* midi_node = 0;
- XMLNode* child;
-
- midi_node = node->add_child ("MIDI");
-
- if (_midi_mute_control.get_control_info (chn, ev, additional)) {
- child = midi_node->add_child ("mute");
- set_midi_node_info (child, ev, chn, additional);
- }
- if (_midi_solo_control.get_control_info (chn, ev, additional)) {
- child = midi_node->add_child ("solo");
- set_midi_node_info (child, ev, chn, additional);
- }
-
-
string order_string;
OrderKeys::iterator x = order_keys.begin();
XMLNode *child;
XMLPropertyList plist;
const XMLProperty *prop;
- XMLNodeList midi_kids;
-
if (node.name() != "Route"){
error << string_compose(_("Bad node sent to Route::set_state() [%1]"), node.name()) << endmsg;
}
}
- midi_kids = node.children ("MIDI");
-
- for (niter = midi_kids.begin(); niter != midi_kids.end(); ++niter) {
-
- XMLNodeList kids;
- XMLNodeConstIterator miter;
- XMLNode* child;
-
- kids = (*niter)->children ();
-
- for (miter = kids.begin(); miter != kids.end(); ++miter) {
-
- child =* miter;
-
- MIDI::eventType ev = MIDI::on; /* initialize to keep gcc happy */
- MIDI::byte additional = 0; /* ditto */
- MIDI::channel_t chn = 0; /* ditto */
-
- if (child->name() == "mute") {
-
- if (get_midi_node_info (child, ev, chn, additional)) {
- _midi_mute_control.set_control_type (chn, ev, additional);
- } else {
- error << string_compose(_("MIDI mute control specification for %1 is incomplete, so it has been ignored"), _name) << endmsg;
- }
- }
- else if (child->name() == "solo") {
-
- if (get_midi_node_info (child, ev, chn, additional)) {
- _midi_solo_control.set_control_type (chn, ev, additional);
- } else {
- error << string_compose(_("MIDI mute control specification for %1 is incomplete, so it has been ignored"), _name) << endmsg;
- }
- }
-
- }
- }
-
-
return 0;
}
return false;
}
-void
-Route::reset_midi_control (MIDI::Port* port, bool on)
-{
- MIDI::channel_t chn;
- MIDI::eventType ev;
- MIDI::byte extra;
-
- for (RedirectList::iterator i = _redirects.begin(); i != _redirects.end(); ++i) {
- (*i)->reset_midi_control (port, on);
- }
-
- IO::reset_midi_control (port, on);
-
- _midi_solo_control.get_control_info (chn, ev, extra);
- if (!on) {
- chn = -1;
- }
- _midi_solo_control.midi_rebind (port, chn);
-
- _midi_mute_control.get_control_info (chn, ev, extra);
- if (!on) {
- chn = -1;
- }
- _midi_mute_control.midi_rebind (port, chn);
-}
-
-void
-Route::send_all_midi_feedback ()
-{
- if (_session.get_midi_feedback()) {
-
- {
- Glib::RWLock::ReaderLock lm (redirect_lock);
- for (RedirectList::iterator i = _redirects.begin(); i != _redirects.end(); ++i) {
- (*i)->send_all_midi_feedback ();
- }
- }
-
- IO::send_all_midi_feedback();
-
- _midi_solo_control.send_feedback (_soloed);
- _midi_mute_control.send_feedback (_muted);
- }
-}
-
-MIDI::byte*
-Route::write_midi_feedback (MIDI::byte* buf, int32_t& bufsize)
-{
- buf = _midi_solo_control.write_feedback (buf, bufsize, _soloed);
- buf = _midi_mute_control.write_feedback (buf, bufsize, _muted);
-
- {
- Glib::RWLock::ReaderLock lm (redirect_lock);
- for (RedirectList::iterator i = _redirects.begin(); i != _redirects.end(); ++i) {
- buf = (*i)->write_midi_feedback (buf, bufsize);
- }
- }
-
- return IO::write_midi_feedback (buf, bufsize);
-}
-
void
Route::flush_redirects ()
{
}
}
-Route::MIDIToggleControl::MIDIToggleControl (Route& s, ToggleType tp, MIDI::Port* port)
- : MIDI::Controllable (port, true), route (s), type(tp), setting(false)
+Route::ToggleControllable::ToggleControllable (Route& s, ToggleType tp)
+ : route (s), type(tp)
{
- last_written = false; /* XXX need a good out-of-bound-value */
+
}
void
-Route::MIDIToggleControl::set_value (float val)
+Route::ToggleControllable::set_value (float val)
{
- MIDI::eventType et;
- MIDI::channel_t chn;
- MIDI::byte additional;
-
- get_control_info (chn, et, additional);
-
- setting = true;
-
-#ifdef HOLD_TOGGLE_VALUES
- if (et == MIDI::off || et == MIDI::on) {
-
- /* literal toggle */
-
- switch (type) {
- case MuteControl:
- route.set_mute (!route.muted(), this);
- break;
- case SoloControl:
- route.set_solo (!route.soloed(), this);
- break;
- default:
- break;
- }
-
- } else {
-#endif
-
- /* map full control range to a boolean */
-
- bool bval = ((val >= 0.5f) ? true: false);
-
- switch (type) {
- case MuteControl:
- route.set_mute (bval, this);
- break;
- case SoloControl:
- route.set_solo (bval, this);
- break;
- default:
- break;
- }
-
-#ifdef HOLD_TOGGLE_VALUES
+ bool bval = ((val >= 0.5f) ? true: false);
+
+ switch (type) {
+ case MuteControl:
+ route.set_mute (bval, this);
+ break;
+ case SoloControl:
+ route.set_solo (bval, this);
+ break;
+ default:
+ break;
}
-#endif
-
- setting = false;
}
-void
-Route::MIDIToggleControl::send_feedback (bool value)
+float
+Route::ToggleControllable::get_value (void) const
{
-
- if (!setting && get_midi_feedback()) {
- MIDI::byte val = (MIDI::byte) (value ? 127: 0);
- MIDI::channel_t ch = 0;
- MIDI::eventType ev = MIDI::none;
- MIDI::byte additional = 0;
- MIDI::EventTwoBytes data;
-
- if (get_control_info (ch, ev, additional)) {
- data.controller_number = additional;
- data.value = val;
- last_written = value;
-
- route._session.send_midi_message (get_port(), ev, ch, data);
- }
- }
+ float val = 0.0f;
-}
-
-MIDI::byte*
-Route::MIDIToggleControl::write_feedback (MIDI::byte* buf, int32_t& bufsize, bool val, bool force)
-{
- if (get_midi_feedback() && bufsize > 2) {
- MIDI::channel_t ch = 0;
- MIDI::eventType ev = MIDI::none;
- MIDI::byte additional = 0;
-
- if (get_control_info (ch, ev, additional)) {
- if (val != last_written || force) {
- *buf++ = (0xF0 & ev) | (0xF & ch);
- *buf++ = additional; /* controller number */
- *buf++ = (MIDI::byte) (val ? 127 : 0);
- bufsize -= 3;
- last_written = val;
- }
- }
+ switch (type) {
+ case MuteControl:
+ val = route.muted() ? 1.0f : 0.0f;
+ break;
+ case SoloControl:
+ val = route.soloed() ? 1.0f : 0.0f;
+ break;
+ default:
+ break;
}
- return buf;
+ return val;
}
void
sigc::signal<int> Session::AskAboutPendingState;
sigc::signal<void> Session::SMPTEOffsetChanged;
+sigc::signal<void> Session::SendFeedback;
+
int
Session::find_session (string str, string& path, string& snapshot, bool& isnew)
tmp =i;
++tmp;
- delete (*i).second;
+ delete i->second;
i = tmp;
}
tmp = i;
++tmp;
- delete (*i).second;
+ delete i->second;
i = tmp;
}
}
AudioDiskstream *
-Session::diskstream_by_id (id_t id)
+Session::diskstream_by_id (const PBD::ID& id)
{
Glib::RWLock::ReaderLock lm (diskstream_lock);
sbuf = buf;
for (i = audio_regions.begin(); i != audio_regions.end(); ++i) {
- if ((*i).second->name() == sbuf) {
+ if (i->second->name() == sbuf) {
break;
}
}
name_taken = false;
for (AudioRegionList::const_iterator i = audio_regions.begin(); i != audio_regions.end(); ++i) {
- if ((*i).second->name() == result) {
+ if (i->second->name() == result) {
name_taken = true;
break;
}
if (x == audio_regions.end()) {
- pair<AudioRegionList::key_type, AudioRegionList::mapped_type> entry;
-
+ pair<AudioRegionList::key_type,AudioRegionList::mapped_type> entry;
+
entry.first = region->id();
entry.second = ar;
AudioRegionList::iterator i;
AudioRegion* ar = 0;
bool removed = false;
-
+
{
Glib::Mutex::Lock lm (region_lock);
- if ((ar = dynamic_cast<AudioRegion*> (region)) != 0) {
+ if ((ar = dynamic_cast<AudioRegion*> (region)) != 0) {
if ((i = audio_regions.find (region->id())) != audio_regions.end()) {
audio_regions.erase (i);
removed = true;
- }
+ }
+
} else {
+
fatal << _("programming error: ")
<< X_("unknown region type passed to Session::remove_region()")
<< endmsg;
for (i = audio_regions.begin(); i != audio_regions.end(); ++i) {
- region = (*i).second;
+ region = i->second;
if (region->whole_file()) {
{
pair<AudioSourceList::key_type, AudioSourceList::mapped_type> entry;
- {
- Glib::Mutex::Lock lm (audio_source_lock);
+ {
+ Glib::Mutex::Lock lm (audio_source_lock);
entry.first = source->id();
entry.second = source;
audio_sources.insert (entry);
- }
+ }
source->GoingAway.connect (mem_fun (this, &Session::remove_source));
set_dirty();
if ((i = audio_sources.find (source->id())) != audio_sources.end()) {
audio_sources.erase (i);
- }
+ }
}
if (!_state_of_the_state & InCleanup) {
}
Source *
-Session::get_source (ARDOUR::id_t id)
+Session::source_by_id (const PBD::ID& id)
{
Glib::Mutex::Lock lm (audio_source_lock);
AudioSourceList::iterator i;
Source* source = 0;
if ((i = audio_sources.find (id)) != audio_sources.end()) {
- source = (*i).second;
- }
-
- if (source) {
- return source;
+ source = i->second;
}
/* XXX search MIDI or other searches here */
- return 0;
+ return source;
}
string
set_dirty();
poke_midi_thread ();
- if (_midi_port) {
- Glib::RWLock::ReaderLock guard (route_lock);
- for (RouteList::iterator i = routes.begin(); i != routes.end(); ++i) {
- (*i)->reset_midi_control (_midi_port, midi_control);
- }
- }
-
ControlChanged (MidiControl); /* EMIT SIGNAL */
}
}
(this->*process_function) (nframes);
+
+ SendFeedback (); /* EMIT SIGNAL */
}
void
AudioDiskstream::AudioDiskstreamCreated.connect (mem_fun (*this, &Session::add_diskstream));
NamedSelection::NamedSelectionCreated.connect (mem_fun (*this, &Session::add_named_selection));
+ Controllable::Created.connect (mem_fun (*this, &Session::add_controllable));
+ Controllable::GoingAway.connect (mem_fun (*this, &Session::remove_controllable));
+
IO::MoreOutputs.connect (mem_fun (*this, &Session::ensure_passthru_buffers));
/* stop IO objects from doing stuff until we're ready for them */
AudioFileSource* fs;
- if ((fs = dynamic_cast<AudioFileSource*> ((*siter).second)) != 0) {
+ if ((fs = dynamic_cast<AudioFileSource*> (siter->second)) != 0) {
DestructiveFileSource* dfs = dynamic_cast<DestructiveFileSource*> (fs);
/* destructive file sources are OK if they are empty, because
}
}
- child->add_child_nocopy ((*siter).second->get_state());
+ child->add_child_nocopy (siter->second->get_state());
}
}
/* only store regions not attached to playlists */
- if ((*i).second->playlist() == 0) {
+ if (i->second->playlist() == 0) {
child->add_child_nocopy (i->second->state (true));
}
}
set_dirty();
for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
-
if ((region = XMLRegionFactory (**niter, false)) == 0) {
error << _("Session: cannot create Region from XML description.") << endmsg;
}
}
-
return 0;
}
Session::XMLRegionFactory (const XMLNode& node, bool full)
{
const XMLProperty* prop;
- id_t s_id;
Source* source;
AudioSource* as;
AudioRegion::SourceList sources;
}
}
- sscanf (prop->value().c_str(), "%" PRIu64, &s_id);
+ PBD::ID s_id (prop->value());
- if ((source = get_source (s_id)) == 0) {
+ if ((source = source_by_id (s_id)) == 0) {
error << string_compose(_("Session: XMLNode describing a AudioRegion references an unknown source id =%1"), s_id) << endmsg;
return 0;
}
for (uint32_t n=1; n < nchans; ++n) {
snprintf (buf, sizeof(buf), X_("source-%d"), n);
if ((prop = node.property (buf)) != 0) {
- sscanf (prop->value().c_str(), "%" PRIu64, &s_id);
- if ((source = get_source (s_id)) == 0) {
- error << string_compose(_("Session: XMLNode describing a AudioRegion references an unknown source id =%1"), s_id) << endmsg;
+ PBD::ID id2 (prop->value());
+
+ if ((source = source_by_id (id2)) == 0) {
+ error << string_compose(_("Session: XMLNode describing a AudioRegion references an unknown source id =%1"), id2) << endmsg;
return 0;
}
as = dynamic_cast<AudioSource*>(source);
if (!as) {
- error << string_compose(_("Session: XMLNode describing a AudioRegion references a non-audio source id =%1"), s_id) << endmsg;
+ error << string_compose(_("Session: XMLNode describing a AudioRegion references a non-audio source id =%1"), id2) << endmsg;
return 0;
}
sources.push_back (as);
}
}
-
try {
return new AudioRegion (sources, node);
}
Glib::Mutex::Lock lm (audio_source_lock);
for (AudioSourceList::iterator i = audio_sources.begin(); i != audio_sources.end(); ++i) {
- node->add_child_nocopy ((*i).second->get_state());
+ node->add_child_nocopy (i->second->get_state());
}
/* XXX get MIDI and other sources here */
capture files.
*/
- if ((*i).second->use_cnt() == 0 && (*i).second->length() > 0) {
+ if (i->second->use_cnt() == 0 && i->second->length() > 0) {
dead_sources.push_back (i->second);
/* remove this source from our own list to avoid us
tmp = r;
++tmp;
- ar = (*r).second;
+ ar = r->second;
for (uint32_t n = 0; n < ar->n_channels(); ++n) {
if (&ar->source (n) == (*i)) {
for (AudioSourceList::iterator i = audio_sources.begin(); i != audio_sources.end(); ++i) {
AudioFileSource* fs;
- if ((fs = dynamic_cast<AudioFileSource*> ((*i).second)) != 0) {
+ if ((fs = dynamic_cast<AudioFileSource*> (i->second)) != 0) {
all_sources.insert (fs->path());
}
}
}
}
+void
+Session::add_controllable (Controllable* c)
+{
+ Glib::Mutex::Lock lm (controllables_lock);
+ controllables.push_back (c);
+}
+
+void
+Session::remove_controllable (Controllable* c)
+{
+ Glib::Mutex::Lock lm (controllables_lock);
+ controllables.remove (c);
+}
+
+Controllable*
+Session::controllable_by_id (const PBD::ID& id)
+{
+ Glib::Mutex::Lock lm (controllables_lock);
+
+ for (Controllables::iterator i = controllables.begin(); i != controllables.end(); ++i) {
+ if ((*i)->id() == id) {
+ return *i;
+ }
+ }
+
+ return 0;
+}
_flags = Flag (_flags & ~Broadcast);
}
+ set_timeline_position (0);
+
} else {
/* XXX 64 bit alert: when JACK switches to a 64 bit frame count, this needs to use the high bits
}
if (_broadcast_info) {
- free (_broadcast_info);
+ delete _broadcast_info;
}
}
return;
}
+ cerr << "timeline pos = " << timeline_position << " offset = " << header_position_offset << endl;
+
_broadcast_info->time_reference_high = 0;
if (header_position_negative) {
_broadcast_info->time_reference_high = (pos >> 32);
_broadcast_info->time_reference_low = (pos & 0xffffffff);
+ cerr << "set binfo pos to " << _broadcast_info->time_reference_high << " + " << _broadcast_info->time_reference_low << endl;
+
if (sf_command (sf, SFC_SET_BROADCAST_INFO, _broadcast_info, sizeof (*_broadcast_info)) != SF_TRUE) {
error << string_compose (_("cannot set broadcast info for audio file %1; Dropping broadcast info for this file"), _path) << endmsg;
_flags = Flag (_flags & ~Broadcast);
Source::Source (string name)
{
_name = name;
- _id = ARDOUR::new_id();
_use_cnt = 0;
_timestamp = 0;
}
char buf[64];
node->add_property ("name", _name);
- snprintf (buf, sizeof(buf)-1, "%" PRIu64, _id);
+ _id.print (buf);
node->add_property ("id", buf);
if (_timestamp != 0) {
}
if ((prop = node.property ("id")) != 0) {
- sscanf (prop->value().c_str(), "%" PRIu64, &_id);
+ _id = prop->value ();
} else {
return -1;
}
+++ /dev/null
-/*
- Copyright (C) 2000-2001 Paul Davis
-
- 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.
-
- $Id$
-*/
-
-#include <cstdio>
-#include <unistd.h>
-
-#include <ardour/stateful.h>
-#include <ardour/utils.h>
-#include <pbd/xml++.h>
-
-#include "i18n.h"
-
-using namespace PBD;
-
-Stateful::Stateful ()
-{
- _extra_xml = 0;
- _instant_xml = 0;
-}
-
-Stateful::~Stateful ()
-{
- // Do not delete _extra_xml. The use of add_child_nocopy()
- // means it needs to live on indefinately.
- delete _instant_xml;
-}
-
-void
-Stateful::add_extra_xml (XMLNode& node)
-{
- if (_extra_xml == 0) {
- _extra_xml = new XMLNode ("extra");
- }
-
- _extra_xml->remove_nodes (node.name());
- _extra_xml->add_child_nocopy (node);
-}
-
-XMLNode *
-Stateful::extra_xml (const string& str)
-{
- if (_extra_xml == 0) {
- return 0;
- }
-
- const XMLNodeList& nlist = _extra_xml->children();
- XMLNodeConstIterator i;
-
- for (i = nlist.begin(); i != nlist.end(); ++i) {
- if ((*i)->name() == str) {
- return (*i);
- }
- }
-
- return 0;
-}
-
-void
-Stateful::add_instant_xml (XMLNode& node, const string& dir)
-{
- if (_instant_xml == 0) {
- _instant_xml = new XMLNode ("instant");
- }
-
- _instant_xml->remove_nodes_and_delete (node.name());
- _instant_xml->add_child_copy (node);
-
- XMLTree tree;
- tree.set_filename(dir+"/instant.xml");
-
- /* Important: the destructor for an XMLTree deletes
- all of its nodes, starting at _root. We therefore
- cannot simply hand it our persistent _instant_xml
- node as its _root, because we will lose it whenever
- the Tree goes out of scope.
-
- So instead, copy the _instant_xml node (which does
- a deep copy), and hand that to the tree.
- */
-
- XMLNode* copy = new XMLNode (*_instant_xml);
- tree.set_root (copy);
-
- if (!tree.write()) {
- error << string_compose(_("Error: could not write %1"), dir+"/instant.xml") << endmsg;
- }
-}
-
-XMLNode *
-Stateful::instant_xml (const string& str, const string& dir)
-{
- if (_instant_xml == 0) {
- string instant_file = dir + "/instant.xml";
- if (access(instant_file.c_str(), F_OK) == 0) {
- XMLTree tree;
- if (tree.read(dir+"/instant.xml")) {
- _instant_xml = new XMLNode(*(tree.root()));
- } else {
- warning << string_compose(_("Could not understand XML file %1"), instant_file) << endmsg;
- return 0;
- }
- } else {
- return 0;
- }
- }
-
- const XMLNodeList& nlist = _instant_xml->children();
- XMLNodeConstIterator i;
-
- for (i = nlist.begin(); i != nlist.end(); ++i) {
- if ((*i)->name() == str) {
- return (*i);
- }
- }
-
- return 0;
-}
-
return 1;
}
-uint32_t long
-get_uid()
-{
- struct timeval tv;
- gettimeofday(&tv, 0);
-
- return (uint32_t long) tv.tv_sec * 1000000 + tv.tv_usec;
-}
-
string
placement_as_string (Placement p)
{
gtkmm2ext.Merge ([
libraries['sigc2'],
libraries['pbd'],
- libraries['midi++2'],
libraries['gtk2'],
libraries['glibmm2'],
libraries['pangomm'],
gtkmm2ext.Append(DOMAIN=domain,MAJOR=0,MINOR=8,MICRO=2)
gtkmm2ext.Append(CXXFLAGS="-DPACKAGE=\\\"" + domain + "\\\"")
gtkmm2ext.Append(CXXFLAGS="-DLIBSIGC_DISABLE_DEPRECATED")
+gtkmm2ext.Append(CPPPATH='#libs/surfaces/control_protocol')
gtkmm2ext.Append(PACKAGE=domain)
gtkmm2ext.Append(POTFILE=domain + '.pot')
gtkmm2ext_files = Split("""
auto_spin.cc
barcontroller.cc
-bindable_button.cc
+binding_proxy.cc
choice.cc
click_box.cc
-controller.cc
dndtreeview.cc
fastmeter.cc
gtk_ui.cc
#include <cmath>
#include <algorithm>
-#include <midi++/controllable.h>
+#include <pbd/controllable.h>
#include <gtkmm2ext/gtk_ui.h>
#include <gtkmm2ext/utils.h>
using namespace Gtkmm2ext;
BarController::BarController (Gtk::Adjustment& adj,
- MIDI::Controllable *mc,
+ PBD::Controllable& mc,
sigc::slot<void,char*,unsigned int> lc)
: adjustment (adj),
- prompter (Gtk::WIN_POS_MOUSE, 30000, false),
- midi_control (mc),
+ binding_proxy (mc),
label_callback (lc),
- spinner (adjustment),
- bind_button (2),
- bind_statemask (Gdk::CONTROL_MASK)
+ spinner (adjustment)
{
_style = LeftToRight;
darea.signal_button_release_event().connect (mem_fun (*this, &BarController::button_release));
darea.signal_scroll_event().connect (mem_fun (*this, &BarController::scroll));
- prompter.signal_unmap_event().connect (mem_fun (*this, &BarController::prompter_hiding));
-
- prompting = false;
- unprompting = false;
-
- if (mc) {
- mc->learning_started.connect (mem_fun (*this, &BarController::midicontrol_prompt));
- mc->learning_stopped.connect (mem_fun (*this, &BarController::midicontrol_unprompt));
- }
-
spinner.signal_activate().connect (mem_fun (*this, &BarController::entry_activated));
spinner.signal_focus_out_event().connect (mem_fun (*this, &BarController::entry_focus_out));
spinner.set_digits (3);
show_all ();
}
-void
-BarController::set_bind_button_state (guint button, guint statemask)
-{
- bind_button = button;
- bind_statemask = statemask;
-}
-
-void
-BarController::get_bind_button_state (guint &button, guint &statemask)
-{
- button = bind_button;
- statemask = bind_statemask;
-}
-
-
bool
BarController::button_press (GdkEventButton* ev)
{
+ if (binding_proxy.button_press_handler (ev)) {
+ return true;
+ }
+
switch (ev->button) {
case 1:
if (ev->type == GDK_2BUTTON_PRESS) {
break;
case 2:
- if ((ev->state & bind_statemask) && bind_button == 2) {
- midi_learn ();
+ if (true) { // XXX FIX ME
+ /* relax */
} else {
double fract;
fract = ev->x / (darea.get_width() - 2.0);
return true;
case 3:
- if ((ev->state & bind_statemask) && bind_button == 3) {
- midi_learn ();
- return TRUE;
- }
return false;
default:
}
}
-void
-BarController::midicontrol_set_tip ()
-{
- if (midi_control) {
- // Gtkmm2ext::UI::instance()->set_tip (&darea, midi_control->control_description());
- }
-}
-
-void
-BarController::midi_learn()
-{
- if (midi_control) {
- prompting = true;
- midi_control->learn_about_external_control ();
- }
-}
-
-
-void
-BarController::midicontrol_prompt ()
-{
- if (prompting) {
- string prompt = _("operate MIDI controller now");
- prompter.set_text (prompt);
- Gtkmm2ext::UI::instance()->touch_display (&prompter);
-
- unprompting = true;
- prompting = false;
- }
-}
-
-void
-BarController::midicontrol_unprompt ()
-{
- if (unprompting) {
- Gtkmm2ext::UI::instance()->touch_display (&prompter);
-
- unprompting = false;
- }
-}
-
-gint
-BarController::prompter_hiding (GdkEventAny *ev)
-{
- if (unprompting) {
- if (midi_control) {
- midi_control->stop_learning();
- }
- unprompting = false;
- }
-
- return FALSE;
-}
-
-
void
BarController::set_style (Style s)
{
+++ /dev/null
-/*
- Copyright (C) 1998-99 Paul Davis
- 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.
-
- $Id$
-*/
-
-#include <string>
-#include <climits>
-
-#include <midi++/channel.h>
-#include <gtkmm2ext/gtk_ui.h>
-#include <gtkmm2ext/controller.h>
-
-#include "i18n.h"
-
-using namespace Gtkmm2ext;
-
-Controller::Controller (Gtk::Adjustment *adj, MIDI::Port *p)
- : MIDI::Controllable (p),
- adjustment (adj),
- prompter (Gtk::WIN_POS_MOUSE, 30000, false)
-{
- new_value_pending = false;
-
- /* hear about MIDI control learning */
-
- learning_started.connect
- (mem_fun (*this, &Controller::midicontrol_prompt));
- learning_stopped.connect
- (mem_fun (*this, &Controller::midicontrol_unprompt));
-}
-
-void
-Controller::midicontrol_prompt ()
-
-{
- string prompt = _("operate MIDI controller now");
-
- prompter.set_text (prompt);
- Gtkmm2ext::UI::instance()->touch_display (&prompter);
-}
-
-void
-Controller::midicontrol_unprompt ()
-
-{
- Gtkmm2ext::UI::instance()->touch_display (&prompter);
-}
-
-int
-Controller::update_controller_value (void *arg)
-
-{
- Controller *c = (Controller *) arg;
-
- c->adjustment->set_value (c->new_value);
- c->new_value_pending = false;
-
- return FALSE;
-}
-
-void
-Controller::set_value (float v)
-
-{
- /* This is called from a MIDI callback. It could happen
- a thousand times a second, or more. Therefore, instead
- of going straight to the X server, which may not work for
- thread-related reasons, simply request an update whenever
- the GTK main loop is idle.
- */
-
- new_value = v;
-
- if (!new_value_pending) {
- new_value_pending = true;
- Gtkmm2ext::UI::instance()->idle_add (update_controller_value, this);
- }
-}
#define __gtkmm2ext_bar_controller_h__
#include <gtkmm.h>
-#include <gtkmm2ext/popup.h>
+#include <gtkmm2ext/binding_proxy.h>
-namespace MIDI {
+namespace ARDOUR {
class Controllable;
}
class BarController : public Gtk::Frame
{
public:
- BarController (Gtk::Adjustment& adj, MIDI::Controllable*, sigc::slot<void,char*,unsigned int>);
+ BarController (Gtk::Adjustment& adj, PBD::Controllable&, sigc::slot<void,char*,unsigned int>);
virtual ~BarController () {}
- void set_bind_button_state (guint button, guint statemask);
- void get_bind_button_state (guint &button, guint &statemask);
- void midicontrol_set_tip ();
- void midi_learn ();
-
void set_sensitive (bool yn) {
darea.set_sensitive (yn);
}
protected:
Gtk::Adjustment& adjustment;
+ BindingProxy binding_proxy;
Gtk::DrawingArea darea;
- Gtkmm2ext::PopUp prompter;
- MIDI::Controllable* midi_control;
sigc::slot<void,char*,unsigned int> label_callback;
Glib::RefPtr<Pango::Layout> layout;
Style _style;
Gtk::SpinButton spinner;
bool use_parent;
- guint bind_button;
- guint bind_statemask;
- bool prompting, unprompting;
-
bool button_press (GdkEventButton *);
bool button_release (GdkEventButton *);
bool motion (GdkEventMotion *);
gint mouse_control (double x, GdkWindow* w, double scaling);
- gint prompter_hiding (GdkEventAny *);
- void midicontrol_prompt ();
- void midicontrol_unprompt ();
- void update_midi_control ();
-
gint switch_to_bar ();
gint switch_to_spinner ();
$Id$
*/
-#ifndef __pbd_gtkmm_bindable_button_h__
-#define __pbd_gtkmm_bindable_button_h__
+#ifndef __bindable_button_h__
+#define __bindable_button_h__
#include <string>
#include <gtkmm2ext/stateful_button.h>
-#include <gtkmm2ext/popup.h>
+#include "binding_proxy.h"
-namespace MIDI {
+namespace PBD {
class Controllable;
}
-namespace Gtkmm2ext {
-
class BindableToggleButton : public Gtk::ToggleButton
{
public:
- BindableToggleButton(MIDI::Controllable *);
-
- //: Create a check button with a label.
- //- You won't be able
- //- to add a widget in this button since it already has a {\class Gtk_Label}
- //- in it.
- explicit BindableToggleButton(MIDI::Controllable *, const std::string &label);
-
+ BindableToggleButton (PBD::Controllable& c) : binding_proxy (c) {}
+ explicit BindableToggleButton (PBD::Controllable& c, const std::string &label) : Gtk::ToggleButton (label), binding_proxy (c) {}
virtual ~BindableToggleButton() {}
- void set_bind_button_state (guint button, guint statemask);
- void get_bind_button_state (guint &button, guint &statemask);
-
- void midicontrol_set_tip ();
-
- void midi_learn ();
-
- protected:
-
- Gtkmm2ext::PopUp prompter;
-
- MIDI::Controllable* midi_control;
-
- guint bind_button;
- guint bind_statemask;
-
- bool prompting, unprompting;
-
- void init_events ();
- bool prompter_hiding (GdkEventAny *);
- void midicontrol_prompt ();
- void midicontrol_unprompt ();
-
- bool on_button_press_event (GdkEventButton *);
-};
+ bool on_button_press_event (GdkEventButton *ev) {
+ return binding_proxy.button_press_handler (ev);
+ }
+ private:
+ BindingProxy binding_proxy;
};
#endif
+++ /dev/null
-/*
- Copyright (C) 1998-99 Paul Davis
- 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.
-
- $Id$
-*/
-
-#ifndef __gtkmm2ext_controller_h__
-#define __gtkmm2ext_controller_h__
-
-#include <gtkmm.h>
-#include <gtkmm2ext/popup.h>
-#include <midi++/controllable.h>
-
-namespace Gtkmm2ext {
-
-class Controller : public MIDI::Controllable
-
-{
- public:
- Controller (Gtk::Adjustment *, MIDI::Port *);
- virtual ~Controller () {}
-
- void set_value (float);
- float lower () { return adjustment->get_lower(); }
- float upper () { return adjustment->get_upper(); }
- float range () { return upper() - lower() /* XXX +1 ??? */ ; }
-
- void midicontrol_prompt ();
- void midicontrol_unprompt ();
-
- protected:
- Gtk::Adjustment *adjustment;
-
- private:
- Gtkmm2ext::PopUp prompter;
- gfloat new_value;
- bool new_value_pending;
-
- static gint update_controller_value (void *);
-};
-
-}; /* namespace */
-
-#endif // __gtkmm2ext_controller_h__
-
-
/*
- Copyright (C) 1998-99 Paul Davis
+ Copyright (C) 1998-2006 Paul Davis
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
$Id$
*/
-#ifndef __gtkmm2ext_motion_controller_h__
-#define __gtkmm2ext_motion_controller_h__
+#ifndef __gtkmm2ext_slider_controller_h__
+#define __gtkmm2ext_slider_controller_h__
#include <gtkmm.h>
#include <gtkmm2ext/popup.h>
#include <gtkmm2ext/pixscroller.h>
+#include <gtkmm2ext/binding_proxy.h>
namespace Gtkmm2ext {
class Pix;
}
-namespace MIDI {
+namespace PBD {
class Controllable;
}
SliderController (Glib::RefPtr<Gdk::Pixbuf> slider,
Glib::RefPtr<Gdk::Pixbuf> rail,
Gtk::Adjustment* adj,
- MIDI::Controllable*,
+ PBD::Controllable&,
bool with_numeric = true);
virtual ~SliderController () {}
- void set_bind_button_state (guint button, guint statemask);
- void get_bind_button_state (guint &button, guint &statemask);
- void midicontrol_set_tip ();
- void midi_learn ();
-
void set_value (float);
- // void set_sensitive (bool yn) {
- // spin.set_sensitive (yn);
- // }
- Gtk::SpinButton & get_spin_button () { return spin; }
+ Gtk::SpinButton& get_spin_button () { return spin; }
+ bool on_button_press_event (GdkEventButton *ev) {
+ return binding_proxy.button_press_handler (ev);
+ }
+
protected:
+ BindingProxy binding_proxy;
Glib::RefPtr<Gdk::Pixbuf> slider;
Glib::RefPtr<Gdk::Pixbuf> rail;
Gtk::SpinButton spin;
Gtk::Frame spin_frame;
Gtk::HBox spin_hbox;
- Gtkmm2ext::PopUp prompter;
- MIDI::Controllable* midi_control;
-
- guint bind_button;
- guint bind_statemask;
- bool prompting, unprompting;
-
- bool button_press (GdkEventButton *);
- bool prompter_hiding (GdkEventAny *);
- void midicontrol_prompt ();
- void midicontrol_unprompt ();
- void update_midi_control ();
};
class VSliderController : public SliderController
VSliderController (Glib::RefPtr<Gdk::Pixbuf> slider,
Glib::RefPtr<Gdk::Pixbuf> rail,
Gtk::Adjustment *adj,
- MIDI::Controllable *,
+ PBD::Controllable&,
bool with_numeric = true);
};
HSliderController (Glib::RefPtr<Gdk::Pixbuf> slider,
Glib::RefPtr<Gdk::Pixbuf> rail,
Gtk::Adjustment *adj,
- MIDI::Controllable *,
+ PBD::Controllable&,
bool with_numeric = true);
};
}; /* namespace */
-#endif // __gtkmm2ext_motion_controller_h__
+#endif // __gtkmm2ext_slider_controller_h__
*/
#include <string>
-#include <climits>
-
-#include <midi++/controllable.h>
#include <gtkmm2ext/gtk_ui.h>
-#include <gtkmm2ext/slider_controller.h>
#include <gtkmm2ext/pixscroller.h>
+#include <gtkmm2ext/slider_controller.h>
#include "i18n.h"
using namespace Gtkmm2ext;
+using namespace PBD;
SliderController::SliderController (Glib::RefPtr<Gdk::Pixbuf> slide,
Glib::RefPtr<Gdk::Pixbuf> rail,
Gtk::Adjustment *adj,
- MIDI::Controllable *mc,
+ Controllable& c,
bool with_numeric)
: PixScroller (*adj, slide, rail),
- spin (*adj, 0, 2),
- prompter (Gtk::WIN_POS_MOUSE, 30000, false),
- midi_control (mc),
- bind_button (2),
- bind_statemask (Gdk::CONTROL_MASK)
-
+ binding_proxy (c),
+ spin (*adj, 0, 2)
{
- signal_button_press_event().connect (mem_fun (this, &SliderController::button_press));
spin.set_name ("SliderControllerValue");
spin.set_size_request (70,-1); // should be based on font size somehow
spin.set_numeric (true);
spin.set_snap_to_ticks (false);
-
- prompter.signal_unmap_event().connect (mem_fun (*this, &SliderController::prompter_hiding));
-
- prompting = false;
- unprompting = false;
-
- if (mc) {
- mc->learning_started.connect (mem_fun (*this, &SliderController::midicontrol_prompt));
- mc->learning_stopped.connect (mem_fun (*this, &SliderController::midicontrol_unprompt));
- }
}
void
adj.set_value (v);
}
-void
-SliderController::set_bind_button_state (guint button, guint statemask)
-{
- bind_button = button;
- bind_statemask = statemask;
-}
-
-void
-SliderController::get_bind_button_state (guint &button, guint &statemask)
-{
- button = bind_button;
- statemask = bind_statemask;
-}
-
-void
-SliderController::midi_learn()
-{
- if (midi_control) {
- prompting = true;
- midi_control->learn_about_external_control ();
- }
-}
-
-bool
-SliderController::button_press (GdkEventButton *ev)
-{
- if ((ev->state & bind_statemask) && ev->button == bind_button) {
- midi_learn ();
- return true;
- }
-
- return false;
-}
-
-void
-SliderController::midicontrol_set_tip ()
-
-{
- if (midi_control) {
- // Gtkmm2ext::UI::instance()->set_tip (this, midi_control->control_description());
- }
-}
-
-bool
-SliderController::prompter_hiding (GdkEventAny *ev)
-{
- if (unprompting) {
- if (midi_control) {
- midi_control->stop_learning();
- }
- unprompting = false;
- }
-
- return false;
-}
-
-void
-SliderController::midicontrol_prompt ()
-
-{
- if (prompting) {
-
- string prompt = _("operate MIDI controller now");
- prompter.set_text (prompt);
- Gtkmm2ext::UI::instance()->touch_display (&prompter);
-
- unprompting = true;
- prompting = false;
- }
-}
-
-void
-SliderController::midicontrol_unprompt ()
-
-{
- if (unprompting) {
- Gtkmm2ext::UI::instance()->touch_display (&prompter);
- unprompting = false;
- }
-}
-
-
VSliderController::VSliderController (Glib::RefPtr<Gdk::Pixbuf> slide,
Glib::RefPtr<Gdk::Pixbuf> rail,
Gtk::Adjustment *adj,
- MIDI::Controllable *mcontrol,
+ Controllable& control,
bool with_numeric)
- : SliderController (slide, rail, adj, mcontrol, with_numeric)
+ : SliderController (slide, rail, adj, control, with_numeric)
{
if (with_numeric) {
spin_frame.add (spin);
HSliderController::HSliderController (Glib::RefPtr<Gdk::Pixbuf> slide,
Glib::RefPtr<Gdk::Pixbuf> rail,
Gtk::Adjustment *adj,
- MIDI::Controllable *mcontrol,
+ Controllable& control,
bool with_numeric)
- : SliderController (slide, rail, adj, mcontrol, with_numeric)
+ : SliderController (slide, rail, adj, control, with_numeric)
{
if (with_numeric) {
spin_frame.add (spin);
basename.cc
base_ui.cc
convert.cc
+controllable.cc
dmalloc.cc
error.cc
+id.cc
mountpoint.cc
path.cc
pathscanner.cc
pthread_utils.cc
receiver.cc
stacktrace.cc
+stateful.cc
strsplit.cc
textreceiver.cc
transmitter.cc
conf.env.Append(CXXFLAGS="-DHAVE_EXECINFO")
pbd = conf.Finish()
-pbd.Merge ([ libraries['sigc2'], libraries['xml'], libraries['glibmm2'], libraries['glib2'] ])
+pbd.Merge ([ libraries['sigc2'],
+ libraries['uuid'],
+ libraries['xml'],
+ libraries['glibmm2'],
+ libraries['glib2'] ])
pbd.VersionBuild(['version.cc','pbd/version.h'], 'SConscript')
--- /dev/null
+#include <pbd/controllable.h>
+#include <pbd/xml++.h>
+
+#include "i18n.h"
+
+using namespace PBD;
+
+sigc::signal<void,Controllable*> Controllable::Created;
+sigc::signal<void,Controllable*> Controllable::GoingAway;
+sigc::signal<bool,Controllable*> Controllable::StartLearning;
+sigc::signal<void,Controllable*> Controllable::StopLearning;
+
+Controllable::Controllable ()
+{
+ Created (this);
+}
+
+XMLNode&
+Controllable::get_state ()
+{
+ XMLNode* node = new XMLNode (X_("Controllable"));
+ char buf[64];
+ _id.print (buf);
+ node->add_property (X_("id"), buf);
+ return *node;
+}
--- /dev/null
+#include <ostream>
+#include <iostream>
+
+#include <string.h>
+#include <uuid/uuid.h>
+
+#include <pbd/id.h>
+
+using namespace std;
+using namespace PBD;
+
+ID::ID ()
+{
+ uuid_generate (id);
+}
+
+ID::ID (string str)
+{
+ string_assign (str);
+}
+
+int
+ID::string_assign (string str)
+{
+ /* first check for old-style all-numeric ID's */
+
+ if (strcspn (str.c_str(), "0123456789") == 0) {
+ /* all chars are numeric. just render the existing ID into the space in
+ which we would otherwise store a UUID.
+ */
+
+ memset (id, ' ', sizeof (id));
+ snprintf ((char*) id, sizeof (id), str.c_str());
+
+ } else {
+
+ /* OK, its UUID, probably */
+
+ if (uuid_parse (str.c_str(), id)) {
+ /* XXX error */
+ return -1;
+ }
+ }
+
+ return 0;
+}
+
+void
+ID::print (char* buf) const
+{
+ uuid_unparse (id, buf);
+}
+
+ID&
+ID::operator= (string str)
+{
+ string_assign (str);
+ return *this;
+}
+
+bool
+ID::operator== (const ID& other) const
+{
+ return memcmp (id, other.id, sizeof (id)) == 0;
+}
+
+ostream&
+operator<< (ostream& ostr, const ID& id)
+{
+ char buf[37];
+ id.print (buf);
+ ostr << buf;
+ return ostr;
+}
+
--- /dev/null
+#ifndef __pbd_controllable_h__
+#define __pbd_controllable_h__
+
+#include <sigc++/trackable.h>
+#include <sigc++/signal.h>
+
+#include <pbd/stateful.h>
+#include <pbd/id.h>
+
+class XMLNode;
+
+namespace PBD {
+
+class Controllable : public virtual sigc::trackable, public Stateful {
+ public:
+ Controllable ();
+ virtual ~Controllable() { GoingAway (this); }
+
+ virtual void set_value (float) = 0;
+ virtual float get_value (void) const = 0;
+
+ virtual bool can_send_feedback() const { return true; }
+
+ static sigc::signal<void,Controllable*> Created;
+ static sigc::signal<void,Controllable*> GoingAway;
+
+
+ static sigc::signal<bool,PBD::Controllable*> StartLearning;
+ static sigc::signal<void,PBD::Controllable*> StopLearning;
+
+ sigc::signal<void> Changed;
+
+ const PBD::ID& id() const { return _id; }
+
+ int set_state (const XMLNode&) { return 0; }
+ XMLNode& get_state ();
+
+ private:
+ PBD::ID _id;
+};
+
+}
+
+#endif /* __pbd_controllable_h__ */
--- /dev/null
+#ifndef __pbd_id_h__
+#define __pbd_id_h__
+
+#include <uuid/uuid.h>
+#include <string>
+
+namespace PBD {
+
+class ID {
+ public:
+ ID ();
+ ID (std::string);
+
+ bool operator== (const ID& other) const;
+ bool operator!= (const ID& other) const {
+ return !operator== (other);
+ }
+ ID& operator= (std::string);
+
+ bool operator< (const ID& other) const {
+ return memcmp (id, other.id, sizeof (id)) < 0;
+ }
+
+ void print (char* buf) const;
+
+ private:
+ uuid_t id;
+ int string_assign (std::string);
+};
+
+}
+std::ostream& operator<< (std::ostream& ostr, const PBD::ID&);
+
+#endif /* __pbd_id_h__ */
--- /dev/null
+/*
+ Copyright (C) 2000 Paul Davis
+
+ 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.
+
+ $Id: stateful.h 17 2005-09-24 19:13:41Z taybin $
+*/
+
+#ifndef __pbd_stateful_h__
+#define __pbd_stateful_h__
+
+#include <string>
+
+class XMLNode;
+
+class Stateful {
+ public:
+ Stateful();
+ virtual ~Stateful();
+
+ virtual XMLNode& get_state (void) = 0;
+
+ virtual int set_state (const XMLNode&) = 0;
+
+ /* Extra XML nodes */
+
+ void add_extra_xml (XMLNode&);
+ XMLNode *extra_xml (const std::string& str);
+
+ virtual void add_instant_xml (XMLNode&, const std::string& dir);
+ XMLNode *instant_xml (const std::string& str, const std::string& dir);
+
+ protected:
+ XMLNode *_extra_xml;
+ XMLNode *_instant_xml;
+};
+
+#endif /* __pbd_stateful_h__ */
+
--- /dev/null
+/*
+ Copyright (C) 2000-2001 Paul Davis
+
+ 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.
+
+ $Id: stateful.cc 629 2006-06-21 23:01:03Z paul $
+*/
+
+#include <unistd.h>
+
+#include <pbd/stateful.h>
+#include <pbd/xml++.h>
+#include <pbd/error.h>
+
+#include "i18n.h"
+
+using namespace PBD;
+
+Stateful::Stateful ()
+{
+ _extra_xml = 0;
+ _instant_xml = 0;
+}
+
+Stateful::~Stateful ()
+{
+ // Do not delete _extra_xml. The use of add_child_nocopy()
+ // means it needs to live on indefinately.
+
+ if (_instant_xml) {
+ delete _instant_xml;
+ }
+}
+
+void
+Stateful::add_extra_xml (XMLNode& node)
+{
+ if (_extra_xml == 0) {
+ _extra_xml = new XMLNode ("extra");
+ }
+
+ _extra_xml->remove_nodes (node.name());
+ _extra_xml->add_child_nocopy (node);
+}
+
+XMLNode *
+Stateful::extra_xml (const string& str)
+{
+ if (_extra_xml == 0) {
+ return 0;
+ }
+
+ const XMLNodeList& nlist = _extra_xml->children();
+ XMLNodeConstIterator i;
+
+ for (i = nlist.begin(); i != nlist.end(); ++i) {
+ if ((*i)->name() == str) {
+ return (*i);
+ }
+ }
+
+ return 0;
+}
+
+void
+Stateful::add_instant_xml (XMLNode& node, const string& dir)
+{
+ if (_instant_xml == 0) {
+ _instant_xml = new XMLNode ("instant");
+ }
+
+ _instant_xml->remove_nodes_and_delete (node.name());
+ _instant_xml->add_child_copy (node);
+
+ XMLTree tree;
+ tree.set_filename(dir+"/instant.xml");
+
+ /* Important: the destructor for an XMLTree deletes
+ all of its nodes, starting at _root. We therefore
+ cannot simply hand it our persistent _instant_xml
+ node as its _root, because we will lose it whenever
+ the Tree goes out of scope.
+
+ So instead, copy the _instant_xml node (which does
+ a deep copy), and hand that to the tree.
+ */
+
+ XMLNode* copy = new XMLNode (*_instant_xml);
+ tree.set_root (copy);
+
+ if (!tree.write()) {
+ error << string_compose(_("Error: could not write %1"), dir+"/instant.xml") << endmsg;
+ }
+}
+
+XMLNode *
+Stateful::instant_xml (const string& str, const string& dir)
+{
+ if (_instant_xml == 0) {
+ string instant_file = dir + "/instant.xml";
+ if (access(instant_file.c_str(), F_OK) == 0) {
+ XMLTree tree;
+ if (tree.read(dir+"/instant.xml")) {
+ _instant_xml = new XMLNode(*(tree.root()));
+ } else {
+ warning << string_compose(_("Could not understand XML file %1"), instant_file) << endmsg;
+ return 0;
+ }
+ } else {
+ return 0;
+ }
+ }
+
+ const XMLNodeList& nlist = _instant_xml->children();
+ XMLNodeConstIterator i;
+
+ for (i = nlist.begin(); i != nlist.end(); ++i) {
+ if ((*i)->name() == str) {
+ return (*i);
+ }
+ }
+
+ return 0;
+}
+
genericmidi_files=Split("""
interface.cc
generic_midi_control_protocol.cc
+midicontrollable.cc
""")
genericmidi.Append(CCFLAGS="-D_REENTRANT -D_LARGEFILE_SOURCE -D_LARGEFILE64_SOURCE")
+/*
+ Copyright (C) 2006 Paul Davis
+
+ 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.
+
+ $Id$
+*/
+
+#include <algorithm>
+
#include <midi++/port.h>
+#include <midi++/manager.h>
+#include <midi++/port_request.h>
#include <ardour/route.h>
#include <ardour/session.h>
#include "generic_midi_control_protocol.h"
+#include "midicontrollable.h"
using namespace ARDOUR;
+using namespace PBD;
#include "i18n.h"
GenericMidiControlProtocol::GenericMidiControlProtocol (Session& s)
: ControlProtocol (s, _("GenericMIDI"))
{
- _port = s.midi_port();
- s.MIDI_PortChanged.connect (mem_fun (*this, &GenericMidiControlProtocol::port_change));
+ MIDI::Manager* mm = MIDI::Manager::instance();
+ MIDI::PortRequest pr ("ardour:MIDI control", "ardour:MIDI control", "duplex", "alsa/seq");
+ _port = mm->add_port (pr);
+
+ _feedback_interval = 10000; // microseconds
+ last_feedback_time = 0;
+
+ Controllable::StartLearning.connect (mem_fun (*this, &GenericMidiControlProtocol::start_learning));
+ Controllable::StopLearning.connect (mem_fun (*this, &GenericMidiControlProtocol::stop_learning));
+ Session::SendFeedback.connect (mem_fun (*this, &GenericMidiControlProtocol::send_feedback));
}
GenericMidiControlProtocol::~GenericMidiControlProtocol ()
int
GenericMidiControlProtocol::set_active (bool yn)
{
- /* start delivery/outbound thread */
+ /* start/stop delivery/outbound thread */
return 0;
}
void
-GenericMidiControlProtocol::port_change ()
+GenericMidiControlProtocol::set_feedback_interval (microseconds_t ms)
{
- _port = session->midi_port ();
+ _feedback_interval = ms;
}
-void
-GenericMidiControlProtocol::set_port (MIDI::Port* p)
+void
+GenericMidiControlProtocol::send_feedback ()
{
- _port = p;
+ microseconds_t now = get_microseconds ();
+
+ if (last_feedback_time != 0) {
+ if ((now - last_feedback_time) < _feedback_interval) {
+ return;
+ }
+ }
+
+ _send_feedback ();
+
+ last_feedback_time = now;
}
void
-GenericMidiControlProtocol::send_route_feedback (list<Route*>& routes)
+GenericMidiControlProtocol::_send_feedback ()
{
- if (_port != 0) {
-
- const int32_t bufsize = 16 * 1024;
- MIDI::byte buf[bufsize];
- int32_t bsize = bufsize;
- MIDI::byte* end = buf;
-
- for (list<Route*>::iterator r = routes.begin(); r != routes.end(); ++r) {
- end = (*r)->write_midi_feedback (end, bsize);
- }
-
- if (end == buf) {
- return;
- }
-
- _port->write (buf, (int32_t) (end - buf));
- //cerr << "MIDI feedback: wrote " << (int32_t) (end - buf) << " to midi port\n";
+ const int32_t bufsize = 16 * 1024;
+ MIDI::byte buf[bufsize];
+ int32_t bsize = bufsize;
+ MIDI::byte* end = buf;
+
+ for (MIDIControllables::iterator r = controllables.begin(); r != controllables.end(); ++r) {
+ end = (*r)->write_feedback (end, bsize);
+ }
+
+ if (end == buf) {
+ return;
+ }
+
+ _port->write (buf, (int32_t) (end - buf));
+}
+
+bool
+GenericMidiControlProtocol::start_learning (Controllable* c)
+{
+ if (c == 0) {
+ return false;
+ }
+
+ MIDIControllable* mc = new MIDIControllable (*_port, *c);
+
+
+ {
+ Glib::Mutex::Lock lm (pending_lock);
+ pending_controllables.push_back (mc);
+ mc->learning_stopped.connect (bind (mem_fun (*this, &GenericMidiControlProtocol::learning_stopped), mc));
+ }
+
+ mc->learn_about_external_control ();
+ return true;
+}
+
+void
+GenericMidiControlProtocol::learning_stopped (MIDIControllable* mc)
+{
+ Glib::Mutex::Lock lm (pending_lock);
+ Glib::Mutex::Lock lm2 (controllables_lock);
+
+ MIDIControllables::iterator i = find (pending_controllables.begin(), pending_controllables.end(), mc);
+
+ if (i != pending_controllables.end()) {
+ pending_controllables.erase (i);
}
+
+ controllables.push_back (mc);
}
+void
+GenericMidiControlProtocol::stop_learning (Controllable* c)
+{
+ Glib::Mutex::Lock lm (pending_lock);
+
+ /* learning timed out, and we've been told to consider this attempt to learn to be cancelled. find the
+ relevant MIDIControllable and remove it from the pending list.
+ */
+
+ for (MIDIControllables::iterator i = pending_controllables.begin(); i != pending_controllables.end(); ++i) {
+ if (&(*i)->get_controllable() == c) {
+ (*i)->stop_learning ();
+ delete (*i);
+ pending_controllables.erase (i);
+ break;
+ }
+ }
+}
#ifndef ardour_generic_midi_control_protocol_h
#define ardour_generic_midi_control_protocol_h
+#include <vector>
+#include <glibmm/thread.h>
+#include <ardour/types.h>
+
#include <control_protocol/control_protocol.h>
namespace MIDI {
class Port;
}
+namespace PBD {
+ class Controllable;
+}
+
namespace ARDOUR {
+ class Session;
+}
-class GenericMidiControlProtocol : public ControlProtocol {
+class MIDIControllable;
+
+class GenericMidiControlProtocol : public ARDOUR::ControlProtocol {
public:
- GenericMidiControlProtocol (Session&);
+ GenericMidiControlProtocol (ARDOUR::Session&);
virtual ~GenericMidiControlProtocol();
int set_active (bool yn);
static bool probe() { return true; }
- void set_port (MIDI::Port*);
MIDI::Port* port () const { return _port; }
+ void set_feedback_interval (ARDOUR::microseconds_t);
- void send_route_feedback (std::list<Route*>&);
-
private:
- void route_feedback (ARDOUR::Route&, bool);
MIDI::Port* _port;
+ ARDOUR::microseconds_t _feedback_interval;
+ ARDOUR::microseconds_t last_feedback_time;
- void port_change ();
-};
+ void _send_feedback ();
+ void send_feedback ();
-}
+ typedef std::vector<MIDIControllable*> MIDIControllables;
+ MIDIControllables controllables;
+ MIDIControllables pending_controllables;
+ Glib::Mutex controllables_lock;
+ Glib::Mutex pending_lock;
+
+ bool start_learning (PBD::Controllable*);
+ void stop_learning (PBD::Controllable*);
+
+ void learning_stopped (MIDIControllable*);
+};
-#endif // ardour_generic_midi_control_protocol_h
+#endif /* ardour_generic_midi_control_protocol_h */
--- /dev/null
+/*
+ Copyright (C) 1998-2006 Paul Davis
+
+ 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.
+
+ $Id: midicontrollable.cc 629 2006-06-21 23:01:03Z paul $
+*/
+
+#include <cstdio> /* for sprintf, sigh */
+#include <climits>
+#include <pbd/error.h>
+#include <pbd/xml++.h>
+#include <midi++/port.h>
+#include <midi++/channel.h>
+
+#include "midicontrollable.h"
+
+using namespace sigc;
+using namespace MIDI;
+using namespace PBD;
+using namespace ARDOUR;
+
+bool MIDIControllable::_send_feedback = false;
+
+MIDIControllable::MIDIControllable (Port& p, Controllable& c, bool is_bistate)
+ : controllable (c), _port (p), bistate (is_bistate)
+{
+ setting = false;
+ last_written = 0; // got a better idea ?
+ control_type = none;
+ _control_description = "MIDI Control: none";
+ control_additional = (byte) -1;
+ connections = 0;
+ feedback = true; // for now
+
+ /* use channel 0 ("1") as the initial channel */
+
+ midi_rebind (0);
+}
+
+MIDIControllable::~MIDIControllable ()
+{
+ drop_external_control ();
+}
+
+void
+MIDIControllable::midi_forget ()
+{
+ /* stop listening for incoming messages, but retain
+ our existing event + type information.
+ */
+
+ if (connections > 0) {
+ midi_sense_connection[0].disconnect ();
+ }
+
+ if (connections > 1) {
+ midi_sense_connection[1].disconnect ();
+ }
+
+ connections = 0;
+ midi_learn_connection.disconnect ();
+
+}
+
+void
+MIDIControllable::midi_rebind (channel_t c)
+{
+ if (c >= 0) {
+ bind_midi (c, control_type, control_additional);
+ } else {
+ midi_forget ();
+ }
+}
+
+void
+MIDIControllable::learn_about_external_control ()
+{
+ drop_external_control ();
+ midi_learn_connection = _port.input()->any.connect (mem_fun (*this, &MIDIControllable::midi_receiver));
+ learning_started ();
+}
+
+void
+MIDIControllable::stop_learning ()
+{
+ midi_learn_connection.disconnect ();
+}
+
+void
+MIDIControllable::drop_external_control ()
+{
+ if (connections > 0) {
+ midi_sense_connection[0].disconnect ();
+ }
+ if (connections > 1) {
+ midi_sense_connection[1].disconnect ();
+ }
+
+ connections = 0;
+ midi_learn_connection.disconnect ();
+
+ control_type = none;
+ control_additional = (byte) -1;
+}
+
+void
+MIDIControllable::midi_sense_note_on (Parser &p, EventTwoBytes *tb)
+{
+ midi_sense_note (p, tb, true);
+}
+
+void
+MIDIControllable::midi_sense_note_off (Parser &p, EventTwoBytes *tb)
+{
+ midi_sense_note (p, tb, false);
+}
+
+void
+MIDIControllable::midi_sense_note (Parser &p, EventTwoBytes *msg, bool is_on)
+{
+ if (!bistate) {
+ controllable.set_value (msg->note_number/127.0);
+ } else {
+
+ /* Note: parser handles the use of zero velocity to
+ mean note off. if we get called with is_on=true, then we
+ got a *real* note on.
+ */
+
+ if (msg->note_number == control_additional) {
+ controllable.set_value (is_on ? 1 : 0);
+ }
+ }
+}
+
+void
+MIDIControllable::midi_sense_controller (Parser &, EventTwoBytes *msg)
+{
+ if (control_additional == msg->controller_number) {
+ if (!bistate) {
+ controllable.set_value (msg->value/127.0);
+ } else {
+ if (msg->value > 64.0) {
+ controllable.set_value (1);
+ } else {
+ controllable.set_value (0);
+ }
+ }
+ }
+}
+
+void
+MIDIControllable::midi_sense_program_change (Parser &p, byte msg)
+{
+ /* XXX program change messages make no sense for bistates */
+
+ if (!bistate) {
+ controllable.set_value (msg/127.0);
+ }
+}
+
+void
+MIDIControllable::midi_sense_pitchbend (Parser &p, pitchbend_t pb)
+{
+ /* pitchbend messages make no sense for bistates */
+
+ /* XXX gack - get rid of assumption about typeof pitchbend_t */
+
+ controllable.set_value ((pb/(float) SHRT_MAX));
+}
+
+void
+MIDIControllable::midi_receiver (Parser &p, byte *msg, size_t len)
+{
+ /* we only respond to channel messages */
+
+ if ((msg[0] & 0xF0) < 0x80 || (msg[0] & 0xF0) > 0xE0) {
+ return;
+ }
+
+ /* if the our port doesn't do input anymore, forget it ... */
+
+ if (!_port.input()) {
+ return;
+ }
+
+ bind_midi ((channel_t) (msg[0] & 0xf), eventType (msg[0] & 0xF0), msg[1]);
+
+ learning_stopped ();
+}
+
+void
+MIDIControllable::bind_midi (channel_t chn, eventType ev, MIDI::byte additional)
+{
+ char buf[64];
+
+ drop_external_control ();
+
+ control_type = ev;
+ control_channel = chn;
+ control_additional = additional;
+
+ if (_port.input() == 0) {
+ return;
+ }
+
+ Parser& p = *_port.input();
+
+ int chn_i = chn;
+ switch (ev) {
+ case MIDI::off:
+ midi_sense_connection[0] = p.channel_note_off[chn_i].connect
+ (mem_fun (*this, &MIDIControllable::midi_sense_note_off));
+
+ /* if this is a bistate, connect to noteOn as well,
+ and we'll toggle back and forth between the two.
+ */
+
+ if (bistate) {
+ midi_sense_connection[1] = p.channel_note_on[chn_i].connect
+ (mem_fun (*this, &MIDIControllable::midi_sense_note_on));
+ connections = 2;
+ } else {
+ connections = 1;
+ }
+ _control_description = "MIDI control: NoteOff";
+ break;
+
+ case MIDI::on:
+ midi_sense_connection[0] = p.channel_note_on[chn_i].connect
+ (mem_fun (*this, &MIDIControllable::midi_sense_note_on));
+ if (bistate) {
+ midi_sense_connection[1] = p.channel_note_off[chn_i].connect
+ (mem_fun (*this, &MIDIControllable::midi_sense_note_off));
+ connections = 2;
+ } else {
+ connections = 1;
+ }
+ _control_description = "MIDI control: NoteOn";
+ break;
+
+ case MIDI::controller:
+ midi_sense_connection[0] = p.channel_controller[chn_i].connect
+ (mem_fun (*this, &MIDIControllable::midi_sense_controller));
+ connections = 1;
+ snprintf (buf, sizeof (buf), "MIDI control: Controller %d", control_additional);
+ _control_description = buf;
+ break;
+
+ case MIDI::program:
+ if (!bistate) {
+ midi_sense_connection[0] = p.channel_program_change[chn_i].connect
+ (mem_fun (*this,
+ &MIDIControllable::midi_sense_program_change));
+ connections = 1;
+ _control_description = "MIDI control: ProgramChange";
+ }
+ break;
+
+ case MIDI::pitchbend:
+ if (!bistate) {
+ midi_sense_connection[0] = p.channel_pitchbend[chn_i].connect
+ (mem_fun (*this, &MIDIControllable::midi_sense_pitchbend));
+ connections = 1;
+ _control_description = "MIDI control: Pitchbend";
+ }
+ break;
+
+ default:
+ break;
+ }
+}
+
+void
+MIDIControllable::send_feedback ()
+{
+ byte msg[3];
+
+ if (setting || !_send_feedback || control_type == none) {
+ return;
+ }
+
+ msg[0] = (control_type & 0xF0) | (control_channel & 0xF);
+ msg[1] = control_additional;
+ msg[2] = (byte) (controllable.get_value() * 127.0f);
+
+ _port.write (msg, 3);
+}
+
+MIDI::byte*
+MIDIControllable::write_feedback (MIDI::byte* buf, int32_t& bufsize, bool force)
+{
+ if (control_type != none &&_send_feedback && bufsize > 2) {
+
+ MIDI::byte gm = (MIDI::byte) (controllable.get_value() * 127.0);
+
+ if (gm != last_written) {
+ *buf++ = (0xF0 & control_type) | (0xF & control_channel);
+ *buf++ = control_additional; /* controller number */
+ *buf++ = gm;
+ last_written = gm;
+ bufsize -= 3;
+ }
+ }
+
+ return buf;
+}
+
+int
+MIDIControllable::set_state (const XMLNode& node)
+{
+ const XMLProperty* prop;
+ int xx;
+
+ if ((prop = node.property ("event")) != 0) {
+ sscanf (prop->value().c_str(), "0x%x", &xx);
+ control_type = (MIDI::eventType) xx;
+ } else {
+ return -1;
+ }
+
+ if ((prop = node.property ("channel")) != 0) {
+ sscanf (prop->value().c_str(), "%d", &xx);
+ control_channel = (MIDI::channel_t) xx;
+ } else {
+ return -1;
+ }
+
+ if ((prop = node.property ("additional")) != 0) {
+ sscanf (prop->value().c_str(), "0x%x", &xx);
+ control_additional = (MIDI::byte) xx;
+ } else {
+ return -1;
+ }
+
+ return 0;
+}
+
+XMLNode&
+MIDIControllable::get_state ()
+{
+ char buf[32];
+ XMLNode& node (controllable.get_state ());
+
+ snprintf (buf, sizeof(buf), "0x%x", (int) control_type);
+ node.add_property ("event", buf);
+ snprintf (buf, sizeof(buf), "%d", (int) control_channel);
+ node.add_property ("channel", buf);
+ snprintf (buf, sizeof(buf), "0x%x", (int) control_additional);
+ node.add_property ("additional", buf);
+
+ return node;
+}
+
--- /dev/null
+/*
+ Copyright (C) 1998-2006 Paul Davis
+
+ 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.
+
+ $Id: controllable.h 4 2005-05-13 20:47:18Z taybin $
+*/
+
+#ifndef __gm_midicontrollable_h__
+#define __gm_midicontrollable_h__
+
+#include <string>
+
+#include <sigc++/sigc++.h>
+
+#include <midi++/types.h>
+#include <pbd/controllable.h>
+#include <pbd/stateful.h>
+#include <ardour/types.h>
+
+namespace MIDI {
+
+class Channel;
+class Port;
+class Parser;
+
+}
+
+class MIDIControllable : public Stateful
+{
+ public:
+ MIDIControllable (MIDI::Port&, PBD::Controllable&, bool bistate = false);
+ virtual ~MIDIControllable ();
+
+ void send_feedback ();
+ MIDI::byte* write_feedback (MIDI::byte* buf, int32_t& bufsize, bool force = false);
+
+ void midi_rebind (MIDI::channel_t channel=-1);
+ void midi_forget ();
+ void learn_about_external_control ();
+ void stop_learning ();
+ void drop_external_control ();
+
+ sigc::signal<void> learning_started;
+ sigc::signal<void> learning_stopped;
+
+ bool get_midi_feedback () { return feedback; }
+ void set_midi_feedback (bool val) { feedback = val; }
+
+ MIDI::Port& get_port() const { return _port; }
+ PBD::Controllable& get_controllable() const { return controllable; }
+
+ std::string control_description() const { return _control_description; }
+
+ XMLNode& get_state (void);
+ int set_state (const XMLNode&);
+
+ private:
+ PBD::Controllable& controllable;
+ MIDI::Port& _port;
+ bool setting;
+ MIDI::byte last_written;
+ bool bistate;
+ int midi_msg_id; /* controller ID or note number */
+ sigc::connection midi_sense_connection[2];
+ sigc::connection midi_learn_connection;
+ size_t connections;
+ MIDI::eventType control_type;
+ MIDI::byte control_additional;
+ MIDI::channel_t control_channel;
+ std::string _control_description;
+ bool feedback;
+
+ static bool _send_feedback;
+
+ void midi_receiver (MIDI::Parser &p, MIDI::byte *, size_t);
+ void midi_sense_note (MIDI::Parser &, MIDI::EventTwoBytes *, bool is_on);
+ void midi_sense_note_on (MIDI::Parser &p, MIDI::EventTwoBytes *tb);
+ void midi_sense_note_off (MIDI::Parser &p, MIDI::EventTwoBytes *tb);
+ void midi_sense_controller (MIDI::Parser &, MIDI::EventTwoBytes *);
+ void midi_sense_program_change (MIDI::Parser &, MIDI::byte);
+ void midi_sense_pitchbend (MIDI::Parser &, MIDI::pitchbend_t);
+
+ void bind_midi (MIDI::channel_t, MIDI::eventType, MIDI::byte);
+};
+
+#endif // __gm_midicontrollable_h__
+
if ((err = pthread_setschedparam (pthread_self(), SCHED_FIFO, &rtparam)) != 0) {
// do we care? not particularly.
- info << string_compose (_("%1: thread not running with realtime scheduling (%2)"), name(), strerror (errno)) << endmsg;
+ PBD::info << string_compose (_("%1: thread not running with realtime scheduling (%2)"), name(), strerror (errno)) << endmsg;
}
pthread_setcancelstate (PTHREAD_CANCEL_ENABLE, 0);
"""
)
-ardour_vst.Append (CCFLAGS="-DVST_SUPPORT", CPPPATH="#libs/fst", LIBPATH='#gtk2_ardour')
-ardour_vst.Append (LINKFLAGS='-L/usr/X11R6/lib -lasound -lardourgtk -lX11 -lpthread')
+ardour_vst.Append (CCFLAGS="-DVST_SUPPORT", CPPPATH="#libs/fst", LIBPATH='#gtk2_ardour', LIBS="ardourgtk")
+ardour_vst.Append (LINKFLAGS='-L/usr/X11R6/lib -lasound -lX11 -lpthread')
ardour_vst["CC"] ="winegcc"
ardour_vst["LINK"] ="wineg++ -mwindows"
projects / ardour.git / commitdiff