location_ui.cc
main.cc
marker.cc
+matrix.cc
midi_channel_selector.cc
midi_port_dialog.cc
midi_region_view.cc
_("\
JACK has either been shutdown or it\n\
disconnected Ardour because Ardour\n\
-was not fast enough. You can save the\n\
-session and/or try to reconnect to JACK ."));
+was not fast enough. Try to restart\n\
+JACK, reconnect and save the session."));
pop_back_splash ();
msg.run ();
}
setup_fade_handle_positions ();
+ if (!Config->get_show_region_fades()) {
+ set_fade_visibility (false);
+ }
+
string line_name = _region->name();
line_name += ':';
line_name += "gain";
fade_in_handle->hide();
fade_out_handle->hide();
} else {
- fade_in_handle->show();
- fade_out_handle->show();
+ if (Config->get_show_region_fades()) {
+ fade_in_handle->show();
+ fade_out_handle->show();
+ }
}
}
}
Width editor_mixer_strip_width;
void maybe_add_mixer_strip_width (XMLNode&);
void show_editor_mixer (bool yn);
+ void create_editor_mixer ();
void show_editor_list (bool yn);
void set_selected_mixer_strip (TimeAxisView&);
void hide_track_in_display (TimeAxisView& tv, bool temporary = false);
}
}
-void
-Editor::cms_new (boost::shared_ptr<ARDOUR::Route> r)
-{
- current_mixer_strip = new MixerStrip (*ARDOUR_UI::instance()->the_mixer(), *session, r);
- current_mixer_strip->GoingAway.connect (mem_fun (*this, &Editor::cms_deleted));
-}
-
void
Editor::cms_deleted ()
{
void
Editor::show_editor_mixer (bool yn)
{
+ boost::shared_ptr<ARDOUR::Route> r;
+
show_editor_mixer_when_tracks_arrive = false;
+ if (!session) {
+ show_editor_mixer_when_tracks_arrive = yn;
+ return;
+ }
+
if (yn) {
- if (current_mixer_strip == 0) {
+ if (selection->tracks.empty()) {
+
+ if (track_views.empty()) {
+ show_editor_mixer_when_tracks_arrive = true;
+ return;
+ }
- if (selection->tracks.empty()) {
-
- if (track_views.empty()) {
- show_editor_mixer_when_tracks_arrive = true;
- return;
- }
+ for (TrackViewList::iterator i = track_views.begin(); i != track_views.end(); ++i) {
+ AudioTimeAxisView* atv;
- for (TrackViewList::iterator i = track_views.begin(); i != track_views.end(); ++i) {
- AudioTimeAxisView* atv;
-
- if ((atv = dynamic_cast<AudioTimeAxisView*> (*i)) != 0) {
- cms_new (atv->route ());
- break;
- }
+ if ((atv = dynamic_cast<AudioTimeAxisView*> (*i)) != 0) {
+ r = atv->route();
+ break;
}
+ }
- } else {
-
- sort_track_selection ();
-
- for (TrackSelection::iterator i = selection->tracks.begin(); i != selection->tracks.end(); ++i) {
- AudioTimeAxisView* atv;
+ } else {
- if ((atv = dynamic_cast<AudioTimeAxisView*> (*i)) != 0) {
- cms_new (atv->route ());
- break;
- }
+ sort_track_selection ();
+
+ for (TrackSelection::iterator i = selection->tracks.begin(); i != selection->tracks.end(); ++i) {
+ AudioTimeAxisView* atv;
+
+ if ((atv = dynamic_cast<AudioTimeAxisView*> (*i)) != 0) {
+ r = atv->route();
+ break;
}
-
}
+ }
+
+ if (r) {
+ bool created;
if (current_mixer_strip == 0) {
- return;
- }
+ create_editor_mixer ();
+ created = true;
+ } else {
+ created = false;
+ }
+
+ current_mixer_strip->set_route (r);
+
+ if (created) {
+ current_mixer_strip->set_width (editor_mixer_strip_width, (void*) this);
+ }
}
if (current_mixer_strip->get_parent() == 0) {
- current_mixer_strip->set_embedded (true);
- current_mixer_strip->Hiding.connect (mem_fun(*this, &Editor::current_mixer_strip_hidden));
- current_mixer_strip->GoingAway.connect (mem_fun(*this, &Editor::current_mixer_strip_removed));
- current_mixer_strip->set_width (editor_mixer_strip_width, (void*) this);
-
global_hpacker.pack_start (*current_mixer_strip, Gtk::PACK_SHRINK );
global_hpacker.reorder_child (*current_mixer_strip, 0);
-
current_mixer_strip->show_all ();
}
} else {
if (current_mixer_strip) {
- editor_mixer_strip_width = current_mixer_strip->get_width ();
if (current_mixer_strip->get_parent() != 0) {
global_hpacker.remove (*current_mixer_strip);
}
}
}
+
#ifdef GTKOSX
/* XXX gtk problem here */
+ ensure_all_elements_drawn();
+#endif
+}
+
+#ifdef GTKOSX
+void
+Editor::ensure_all_elements_drawn ()
+{
+ controls_layout.queue_draw ();
ruler_label_event_box.queue_draw ();
time_button_event_box.queue_draw ();
- controls_layout.queue_draw ();
-#endif
}
+#endif
+
+void
+Editor::create_editor_mixer ()
+{
+ current_mixer_strip = new MixerStrip (*ARDOUR_UI::instance()->the_mixer(),
+ *session,
+ false);
+ current_mixer_strip->Hiding.connect (mem_fun(*this, &Editor::current_mixer_strip_hidden));
+ current_mixer_strip->GoingAway.connect (mem_fun(*this, &Editor::current_mixer_strip_removed));
+#ifdef GTKOSX
+ current_mixer_strip->WidthChanged.connect (mem_fun(*this, &Editor::ensure_all_elements_drawn));
+#endif
+ current_mixer_strip->set_embedded (true);
+}
void
Editor::show_editor_list (bool yn)
void
Editor::set_selected_mixer_strip (TimeAxisView& view)
{
- RouteTimeAxisView* rt;
+ AudioTimeAxisView* at;
bool show = false;
+ bool created;
- if (!session || (rt = dynamic_cast<RouteTimeAxisView*>(&view)) == 0) {
+ if (!session || (at = dynamic_cast<AudioTimeAxisView*>(&view)) == 0) {
return;
}
-
- if (current_mixer_strip) {
- /* might be nothing to do */
-
- if (current_mixer_strip->route() == rt->route()) {
+ Glib::RefPtr<Gtk::Action> act = ActionManager::get_action (X_("Editor"), X_("show-editor-mixer"));
+ if (act) {
+ Glib::RefPtr<Gtk::ToggleAction> tact = Glib::RefPtr<Gtk::ToggleAction>::cast_dynamic(act);
+ if (!tact || !tact->get_active()) {
+ /* not showing mixer strip presently */
return;
}
+ }
- if (current_mixer_strip->get_parent()) {
- show = true;
- }
- delete current_mixer_strip;
- current_mixer_strip = 0;
+ if (current_mixer_strip == 0) {
+ create_editor_mixer ();
+ created = true;
+ } else {
+ created = false;
}
- current_mixer_strip = new MixerStrip (*ARDOUR_UI::instance()->the_mixer(),
- *session,
- rt->route(), false);
- current_mixer_strip->GoingAway.connect (mem_fun(*this, &Editor::cms_deleted));
+ /* might be nothing to do */
+ if (current_mixer_strip->route() == at->route()) {
+ return;
+ }
+
+ if (current_mixer_strip->get_parent()) {
+ show = true;
+ }
+
+ current_mixer_strip->set_route (at->route());
+
+ if (created) {
+ current_mixer_strip->set_width (editor_mixer_strip_width, (void*) this);
+ }
+
if (show) {
show_editor_mixer (true);
}
}
+
double current = 0.0;
bool currentInitialized = 0;
Editor::current_mixer_strip_removed ()
{
if (current_mixer_strip) {
- /* it is being deleted */
+ /* it is being deleted elsewhere */
current_mixer_strip = 0;
}
}
}
}
-GainMeterBase::GainMeterBase (boost::shared_ptr<IO> io, Session& s,
+GainMeterBase::GainMeterBase (Session& s,
const Glib::RefPtr<Gdk::Pixbuf>& pix,
bool horizontal)
- : _io (io),
- _session (s),
+ : _session (s),
// 0.781787 is the value needed for gain to be set to 0.
gain_adjustment (0.781787, 0.0, 1.0, 0.01, 0.1),
gain_automation_style_button (""),
gain_automation_state_button ("")
{
+ using namespace Menu_Helpers;
+
ignore_toggle = false;
meter_menu = 0;
next_release_selects = false;
if (horizontal) {
gain_slider = manage (new HSliderController (pix,
&gain_adjustment,
- _io->gain_control(),
false));
} else {
gain_slider = manage (new VSliderController (pix,
&gain_adjustment,
- _io->gain_control(),
false));
}
- level_meter = new LevelMeter(_io, _session);
+ level_meter = new LevelMeter(_session);
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_automation_state_button.set_size_request(15, 15);
gain_automation_style_button.set_size_request(15, 15);
+
+ gain_astyle_menu.items().push_back (MenuElem (_("Trim")));
+ gain_astyle_menu.items().push_back (MenuElem (_("Abs")));
+
+ gain_astate_menu.set_name ("ArdourContextMenu");
+ gain_astyle_menu.set_name ("ArdourContextMenu");
+ gain_adjustment.signal_value_changed().connect (mem_fun(*this, &GainMeterBase::gain_adjusted));
+ peak_display.signal_button_release_event().connect (mem_fun(*this, &GainMeterBase::peak_button_release), false);
+ gain_display.signal_key_press_event().connect (mem_fun(*this, &GainMeterBase::gain_key_press), false);
+ ResetAllPeakDisplays.connect (mem_fun(*this, &GainMeterBase::reset_peak_display));
+ ResetGroupPeakDisplays.connect (mem_fun(*this, &GainMeterBase::reset_group_peak_display));
+ UI::instance()->theme_changed.connect (mem_fun(*this, &GainMeterBase::on_theme_changed));
+ ColorsChanged.connect (bind(mem_fun (*this, &GainMeterBase::color_handler), false));
+ DPIReset.connect (bind(mem_fun (*this, &GainMeterBase::color_handler), true));
+}
+
+GainMeterBase::~GainMeterBase ()
+{
+ delete meter_menu;
+ delete level_meter;
+}
+void
+GainMeterBase::set_io (boost::shared_ptr<IO> io)
+{
+ connections.clear ();
+
+ _io = io;
+
+ level_meter->set_io (_io);
+ gain_slider->set_controllable (_io->gain_control());
boost::shared_ptr<Route> r;
using namespace Menu_Helpers;
+ gain_astate_menu.items().clear ();
+
gain_astate_menu.items().push_back (MenuElem (_("Manual"),
bind (mem_fun (*_io, &IO::set_parameter_automation_state),
Evoral::Parameter(GainAutomation), (AutoState) Off)));
bind (mem_fun (*_io, &IO::set_parameter_automation_state),
Evoral::Parameter(GainAutomation), (AutoState) Touch)));
- gain_astyle_menu.items().push_back (MenuElem (_("Trim")));
- gain_astyle_menu.items().push_back (MenuElem (_("Abs")));
-
- gain_astate_menu.set_name ("ArdourContextMenu");
- gain_astyle_menu.set_name ("ArdourContextMenu");
+ connections.push_back (gain_automation_style_button.signal_button_press_event().connect (mem_fun(*this, &GainMeterBase::gain_automation_style_button_event), false));
+ connections.push_back (gain_automation_state_button.signal_button_press_event().connect (mem_fun(*this, &GainMeterBase::gain_automation_state_button_event), false));
- gain_automation_style_button.signal_button_press_event().connect (mem_fun(*this, &GainMeterBase::gain_automation_style_button_event), false);
- gain_automation_state_button.signal_button_press_event().connect (mem_fun(*this, &GainMeterBase::gain_automation_state_button_event), false);
-
- r->gain_control()->alist()->automation_state_changed.connect (mem_fun(*this, &GainMeter::gain_automation_state_changed));
- r->gain_control()->alist()->automation_style_changed.connect (mem_fun(*this, &GainMeter::gain_automation_style_changed));
+ connections.push_back (r->gain_control()->alist()->automation_state_changed.connect (mem_fun(*this, &GainMeter::gain_automation_state_changed)));
+ connections.push_back (r->gain_control()->alist()->automation_style_changed.connect (mem_fun(*this, &GainMeter::gain_automation_style_changed)));
gain_automation_state_changed ();
}
}
- _io->gain_control()->Changed.connect (mem_fun(*this, &GainMeterBase::gain_changed));
-
- gain_adjustment.signal_value_changed().connect (mem_fun(*this, &GainMeterBase::gain_adjusted));
- peak_display.signal_button_release_event().connect (mem_fun(*this, &GainMeterBase::peak_button_release), false);
- gain_display.signal_key_press_event().connect (mem_fun(*this, &GainMeterBase::gain_key_press), false);
+ connections.push_back (_io->gain_control()->Changed.connect (mem_fun(*this, &GainMeterBase::gain_changed)));
gain_changed ();
show_gain ();
-
update_gain_sensitive ();
-
- ResetAllPeakDisplays.connect (mem_fun(*this, &GainMeterBase::reset_peak_display));
- ResetGroupPeakDisplays.connect (mem_fun(*this, &GainMeterBase::reset_group_peak_display));
-
- UI::instance()->theme_changed.connect (mem_fun(*this, &GainMeterBase::on_theme_changed));
- ColorsChanged.connect (bind(mem_fun (*this, &GainMeterBase::color_handler), false));
- DPIReset.connect (bind(mem_fun (*this, &GainMeterBase::color_handler), true));
-}
-
-GainMeterBase::~GainMeterBase ()
-{
- if (meter_menu) {
- delete meter_menu;
- }
-
- if (level_meter) {
- delete level_meter;
- }
}
void
style_changed = true;
}
-GainMeter::GainMeter (boost::shared_ptr<IO> io, Session& s)
- : GainMeterBase (io, s, slider, false)
+GainMeter::GainMeter (Session& s)
+ : GainMeterBase (s, slider, false)
{
-
gain_display_box.set_homogeneous (true);
gain_display_box.set_spacing (2);
gain_display_box.pack_start (gain_display, true, true);
hbox.set_spacing (2);
hbox.pack_start (*fader_vbox, true, true);
+ set_spacing (2);
+
+ pack_start (gain_display_box, Gtk::PACK_SHRINK);
+ pack_start (hbox, Gtk::PACK_SHRINK);
+
+ meter_metric_area.signal_expose_event().connect (mem_fun(*this, &GainMeter::meter_metrics_expose));
+}
+
+void
+GainMeter::set_io (boost::shared_ptr<IO> io)
+{
+ if (level_meter->get_parent()) {
+ hbox.remove (*level_meter);
+ }
+
+ if (peak_display.get_parent()) {
+ gain_display_box.remove (peak_display);
+ }
+
+ if (gain_automation_state_button.get_parent()) {
+ fader_vbox->remove (gain_automation_state_button);
+ }
+
+ GainMeterBase::set_io (io);
+
boost::shared_ptr<Route> r;
if ((r = boost::dynamic_pointer_cast<Route> (_io)) != 0) {
fader_vbox->pack_start (gain_automation_state_button, false, false, 0);
}
}
-
- set_spacing (2);
-
- pack_start (gain_display_box, Gtk::PACK_SHRINK);
- pack_start (hbox, Gtk::PACK_SHRINK);
-
- meter_metric_area.signal_expose_event().connect (mem_fun(*this, &GainMeter::meter_metrics_expose));
}
-
int
GainMeter::get_gm_width ()
{
class GainMeterBase : virtual public sigc::trackable
{
public:
- GainMeterBase (boost::shared_ptr<ARDOUR::IO>, ARDOUR::Session&, const Glib::RefPtr<Gdk::Pixbuf>& pix,
+ GainMeterBase ( ARDOUR::Session&, const Glib::RefPtr<Gdk::Pixbuf>& pix,
bool horizontal);
virtual ~GainMeterBase ();
+ virtual void set_io (boost::shared_ptr<ARDOUR::IO>);
+
void update_gain_sensitive ();
void update_meters ();
friend class MixerStrip;
boost::shared_ptr<ARDOUR::IO> _io;
ARDOUR::Session& _session;
+ std::vector<sigc::connection> connections;
bool ignore_toggle;
bool next_release_selects;
class GainMeter : public GainMeterBase, public Gtk::VBox
{
public:
- GainMeter (boost::shared_ptr<ARDOUR::IO>, ARDOUR::Session&);
+ GainMeter (ARDOUR::Session&);
~GainMeter () {}
+ void set_io (boost::shared_ptr<ARDOUR::IO>);
+
int get_gm_width ();
void setup_meters (int len=0);
//sigc::signal<void,RouteGroup*> LevelMeter::ResetGroupPeakDisplays;
-LevelMeter::LevelMeter (boost::shared_ptr<IO> io, Session& s)
- : _io (io),
- _session (s)
+LevelMeter::LevelMeter (Session& s)
+ : _session (s)
{
set_spacing (1);
}
}
+void
+LevelMeter::set_io (boost::shared_ptr<IO> io)
+{
+ _io = io;
+}
+
float
LevelMeter::update_meters ()
{
void
LevelMeter::setup_meters (int len, int initial_width)
{
+ if (!_io) {
+ return; /* do it later */
+ }
+
uint32_t nmeters = _io->n_outputs().n_total();
regular_meter_width = initial_width;
class LevelMeter : public Gtk::HBox
{
public:
- LevelMeter (boost::shared_ptr<ARDOUR::IO>, ARDOUR::Session&);
+ LevelMeter (ARDOUR::Session&);
~LevelMeter ();
+ virtual void set_io (boost::shared_ptr<ARDOUR::IO> io);
+
void update_gain_sensitive ();
float update_meters ();
Glib::ustring path;
const char *cstr = getenv ("PATH");
- /* ensure that we find any bundled executables (e.g. JACK) */
+ /* ensure that we find any bundled executables (e.g. JACK),
+ and find them before any instances of the same name
+ elsewhere in PATH
+ */
path = dir_path;
if (cstr) {
if (cstr) {
path = cstr;
path += ':';
+ } else {
+ path = "";
}
- path = dir_path;
+ path += dir_path;
path += "/../Plugins";
setenv ("LADSPA_PATH", path.c_str(), 1);
if (cstr) {
path = cstr;
path += ':';
+ } else {
+ path = "";
}
- path = dir_path;
+ path += dir_path;
path += "/../Frameworks";
setenv ("VAMP_PATH", path.c_str(), 1);
if (cstr) {
path = cstr;
path += ':';
+ } else {
+ path = "";
}
- path = dir_path;
+ path += dir_path;
path += "/../Surfaces";
setenv ("ARDOUR_CONTROL_SURFACE_PATH", path.c_str(), 1);
if (cstr) {
path = cstr;
path += ':';
+ } else {
+ path = "";
}
- path = dir_path;
+ path += dir_path;
path += "/../Plugins";
setenv ("LV2_PATH", path.c_str(), 1);
--- /dev/null
+#include <gtkmm.h>
+#include <cairo/cairo.h>
+#include <stdlib.h>
+#include <iostream>
+#include <algorithm>
+#include <stdint.h>
+#include <cmath>
+#include <map>
+#include <vector>
+
+#include "matrix.h"
+
+using namespace std;
+using namespace Gtk;
+using namespace ARDOUR;
+
+Matrix::Matrix ()
+{
+ alloc_width = 0;
+ alloc_height = 0;
+ line_width = 0;
+ line_height = 0;
+ labels_y_shift = 0;
+ labels_x_shift = 0;
+ arc_radius = 0;
+ xstep = 0;
+ ystep = 0;
+ pixmap = 0;
+ drawn = false;
+ angle_radians = M_PI/4.0;
+ motion_x = -1;
+ motion_y = -1;
+
+ add_events (Gdk::POINTER_MOTION_MASK|Gdk::LEAVE_NOTIFY_MASK);
+}
+
+void
+Matrix::set_ports (const list<string>& ports)
+{
+ ours = ports;
+ reset_size ();
+}
+
+void
+Matrix::add_group (PortGroup& pg)
+{
+ for (vector<string>::const_iterator s = pg.ports.begin(); s != pg.ports.end(); ++s) {
+ others.push_back (OtherPort (*s, pg));
+ }
+ reset_size ();
+}
+
+void
+Matrix::remove_group (PortGroup& pg)
+{
+ for (list<OtherPort>::iterator o = others.begin(); o != others.end(); ) {
+ if (&(*o).group() == &pg) {
+ o = others.erase (o);
+ } else {
+ ++o;
+ }
+ }
+ reset_size ();
+}
+
+void
+Matrix::hide_group (PortGroup& pg)
+{
+ reset_size();
+}
+
+void
+Matrix::show_group (PortGroup& pg)
+{
+ reset_size ();
+}
+
+void
+Matrix::setup_nodes ()
+{
+ int n, x, y;
+ list<string>::iterator m;
+ list<OtherPort>::iterator s;
+
+ for (vector<MatrixNode*>::iterator p = nodes.begin(); p != nodes.end(); ++p) {
+ delete *p;
+ }
+ nodes.clear ();
+
+ list<OtherPort>::size_type visible_others = 0;
+
+ for (list<OtherPort>::iterator s = others.begin(); s != others.end(); ++s) {
+ if ((*s).visible()) {
+ ++visible_others;
+ }
+ }
+
+ nodes.assign (ours.size() * visible_others, 0);
+
+ for (n = 0, y = 0, m = ours.begin(); m != ours.end(); ++m, ++y) {
+ for (x = 0, s = others.begin(); s != others.end(); ++s) {
+ if ((*s).visible()) {
+ nodes[n] = new MatrixNode (*m, *s, x, y);
+ n++;
+ x++;
+ }
+ }
+ }
+}
+
+void
+Matrix::reset_size ()
+{
+ list<OtherPort>::size_type visible_others = 0;
+
+ for (list<OtherPort>::iterator s = others.begin(); s != others.end(); ++s) {
+ if ((*s).visible()) {
+ ++visible_others;
+ }
+ }
+
+ border = 10;
+
+ if (alloc_width > line_width) {
+
+ xstep = (alloc_width - labels_x_shift - (2 * border) - (2 * arc_radius)) / visible_others;
+ line_width = xstep * (others.size() - 1);
+
+ ystep = (alloc_height - labels_y_shift - (2 * border) - (2 * arc_radius)) / (ours.size() - 1);
+ line_height = ystep * (ours.size() - 1);
+
+ } else {
+
+ xstep = 20;
+ ystep = 20;
+
+ line_height = (ours.size() - 1) * ystep;
+ line_width = visible_others * xstep;
+ }
+
+ int half_step = min (ystep/2,xstep/2);
+ if (half_step > 3) {
+ arc_radius = half_step - 5;
+ } else {
+ arc_radius = 3;
+ }
+
+ arc_radius = min (arc_radius, 10);
+
+ /* scan all the port names that will be rotated, and compute
+ how much space we need for them
+ */
+
+ float w = 0;
+ float w1;
+ float h = 0;
+ cairo_text_extents_t extents;
+ cairo_t* cr;
+ GdkPixmap* pm;
+
+ pm = gdk_pixmap_new (NULL, 1, 1, 24);
+ gdk_drawable_set_colormap (pm, gdk_colormap_get_system());
+
+ cr = gdk_cairo_create (pm);
+
+ for (list<OtherPort>::iterator s = others.begin(); s != others.end(); ++s) {
+ if ((*s).visible()) {
+ cairo_text_extents (cr, (*s).name().c_str(), &extents);
+ w = max ((float) extents.width, w);
+ h = max ((float) extents.height, h);
+ }
+ }
+
+ cairo_destroy (cr);
+ gdk_pixmap_unref (pm);
+
+ /* transform */
+
+ w = fabs (w * cos (angle_radians) + h * sin (angle_radians));
+ h = fabs (w * sin (angle_radians) + h * cos (angle_radians));
+
+ labels_y_shift = (int) ceil (h) + 10;
+ labels_x_shift = (int) ceil (w);
+
+ setup_nodes ();
+}
+
+bool
+Matrix::on_motion_notify_event (GdkEventMotion* ev)
+{
+ motion_x = ev->x;
+ motion_y = ev->y;
+ queue_draw ();
+ return false;
+}
+
+bool
+Matrix::on_leave_notify_event (GdkEventCrossing *ev)
+{
+ motion_x = -1;
+ motion_y = -1;
+ queue_draw ();
+ return false;
+}
+
+void
+Matrix::on_size_request (Requisition* req)
+{
+ req->width = labels_x_shift + line_width + (2*border) + (2*arc_radius);
+ req->height = labels_y_shift + line_height + (2*border) + (2*arc_radius);
+}
+
+MatrixNode*
+Matrix::get_node (int32_t x, int32_t y)
+{
+ int half_xstep = xstep / 2;
+ int half_ystep = ystep / 2;
+
+ x -= labels_x_shift - border;
+ if (x < half_xstep) {
+ return 0;
+ }
+
+ y -= labels_y_shift - border;
+ if (y < half_ystep) {
+ return 0;
+ }
+
+ x = (x - half_xstep) / xstep;
+ y = (y - half_ystep) / ystep;
+
+ x = y*ours.size() + x;
+
+ if (x >= nodes.size()) {
+ return 0;
+ }
+
+ return nodes[x];
+}
+
+bool
+Matrix::on_button_press_event (GdkEventButton* ev)
+{
+ MatrixNode* node;
+
+ if ((node = get_node (ev->x, ev->y)) != 0) {
+ cerr << "Event in node " << node->our_name() << " x " << node->their_name () << endl;
+ node->set_connected (!node->connected());
+ drawn = false;
+ queue_draw();
+ }
+}
+
+void
+Matrix::alloc_pixmap ()
+{
+ if (pixmap) {
+ gdk_pixmap_unref (pixmap);
+ }
+
+ pixmap = gdk_pixmap_new (get_window()->gobj(),
+ alloc_width,
+ alloc_height,
+ -1);
+
+ drawn = false;
+}
+
+void
+Matrix::on_size_allocate (Allocation& alloc)
+{
+ EventBox::on_size_allocate (alloc);
+
+ alloc_width = alloc.get_width();
+ alloc_height = alloc.get_height();
+
+ if (is_realized()) {
+ alloc_pixmap ();
+ reset_size ();
+#ifdef MATRIX_USE_BACKING_PIXMAP
+ redraw (pixmap, 0, 0, alloc_width, alloc_height);
+#endif
+ }
+}
+
+void
+Matrix::on_realize ()
+{
+ EventBox::on_realize ();
+ alloc_pixmap ();
+}
+
+void
+Matrix::redraw (GdkDrawable* drawable, GdkRectangle* rect)
+{
+ list<string>::iterator o;
+ list<OtherPort>::iterator t;
+ int x, y;
+ uint32_t top_shift, bottom_shift, left_shift, right_shift;
+ cairo_t* cr;
+
+ cr = gdk_cairo_create (drawable);
+
+ cairo_set_source_rgb (cr, 0.83, 0.83, 0.83);
+ cairo_rectangle (cr, rect->x, rect->y, rect->width, rect->height);
+ cairo_fill (cr);
+
+ cairo_set_line_width (cr, 0.5);
+
+ top_shift = labels_y_shift + border;
+ left_shift = labels_x_shift + border;
+ bottom_shift = 0;
+ right_shift = 0;
+
+ /* horizontal grid lines and side labels */
+
+ for (y = top_shift, o = ours.begin(); o != ours.end(); ++o, y += ystep) {
+
+ cairo_set_source_rgb (cr, 0.0, 0.0, 0.0);
+ cairo_move_to (cr, left_shift, y);
+ cairo_line_to (cr, left_shift+line_width, y);
+ cairo_stroke (cr);
+#if 0
+
+ cairo_text_extents_t extents;
+ cairo_text_extents (cr, (*o).c_str(),&extents);
+ cairo_move_to (cr, border, y+extents.height/2);
+ cairo_show_text (cr, (*o).c_str());
+#endif
+
+ }
+
+ /* vertical grid lines and rotated labels*/
+
+ for (x = left_shift, t = others.begin(); t != others.end(); ++t, x += xstep) {
+
+ cairo_set_source_rgb (cr, 0.0, 0.0, 0.0);
+ cairo_move_to (cr, x, top_shift);
+ cairo_line_to (cr, x, top_shift+line_height);
+ cairo_stroke (cr);
+
+ cairo_move_to (cr, x-left_shift+12, border);
+ cairo_set_source_rgb (cr, 0, 0, 1.0);
+
+ cairo_save (cr);
+ cairo_rotate (cr, angle_radians);
+ cairo_show_text (cr, (*t).name().c_str());
+ cairo_restore (cr);
+
+ }
+
+ /* nodes */
+
+ for (vector<MatrixNode*>::iterator n = nodes.begin(); n != nodes.end(); ++n) {
+
+ x = (*n)->x() * xstep;
+ y = (*n)->y() * ystep;
+
+ cairo_new_path (cr);
+
+ if (arc_radius) {
+ cairo_arc (cr, left_shift+x, top_shift+y, arc_radius, 0, 2.0 * M_PI);
+ if ((*n)->connected()) {
+ cairo_set_source_rgba (cr, 1.0, 0, 0, 1.0);
+ cairo_stroke (cr);
+ } else {
+ cairo_set_source_rgba (cr, 1.0, 0, 0, 0.7);
+ cairo_fill (cr);
+ }
+ }
+ }
+
+ /* motion indicators */
+
+ if (motion_x >= left_shift && motion_y >= top_shift) {
+
+ int col_left = left_shift + ((motion_x - left_shift) / xstep) * xstep;
+ int row_top = top_shift + ((motion_y - top_shift) / ystep) * ystep;
+
+ cairo_set_line_width (cr, 5);
+ cairo_set_source_rgba (cr, 1.0, 0.0, 0.0, 0.3);
+
+ /* horizontal (row) */
+
+ cairo_line_to (cr, left_shift, row_top);
+ cairo_line_to (cr, left_shift + line_width, row_top);
+ cairo_stroke (cr);
+
+ /* vertical (col) */
+
+ cairo_move_to (cr, col_left, top_shift);
+ cairo_line_to (cr, col_left, top_shift + line_height);
+ cairo_stroke (cr);
+ }
+
+ cairo_destroy (cr);
+
+#ifdef MATRIX_USE_BACKING_PIXMAP
+ drawn = true;
+#endif
+}
+
+bool
+Matrix::on_expose_event (GdkEventExpose* event)
+{
+#ifdef MATRIX_USE_BACKING_PIXMAP
+ if (!drawn) {
+ redraw (pixmap, 0, 0, alloc_width, alloc_height);
+ }
+
+ gdk_draw_drawable (get_window()->gobj(),
+ get_style()->get_fg_gc (STATE_NORMAL)->gobj(),
+ pixmap,
+ event->area.x,
+ event->area.y,
+ event->area.x,
+ event->area.y,
+ event->area.width,
+ event->area.height);
+#else
+ redraw (get_window()->gobj(), &event->area);
+#endif
+
+
+
+ return true;
+}
--- /dev/null
+#ifndef __gtk_ardour_matrix_h__
+#define __gtk_ardour_matrix_h__
+
+#include <list>
+#include <vector>
+#include <string>
+#include <stdint.h>
+
+#include <gtkmm/eventbox.h>
+#include <gtkmm/widget.h>
+
+#include "port_group.h"
+
+class OtherPort {
+public:
+ OtherPort (const std::string& n, PortGroup& g)
+ : _name (n), _group (g) {}
+
+ std::string name() const { return _name; }
+ PortGroup& group() const { return _group; }
+ bool visible() const { return _group.visible; }
+
+public:
+ std::string _name;
+ PortGroup& _group;
+};
+
+class MatrixNode {
+ public:
+ MatrixNode (std::string a, OtherPort o, int32_t x, int32_t y)
+ : _name (a), them (o), _connected (random()%3), _x(x), _y(y) {}
+ ~MatrixNode() {}
+
+ PortGroup& get_group() const { return them.group(); }
+
+ std::string our_name() const { return _name; }
+ std::string their_name() const { return them.name(); }
+
+ bool connected() const { return _connected; }
+ void set_connected (bool yn) { _connected = yn; }
+ int32_t x() const { return _x; }
+ int32_t y() const { return _y; }
+
+ private:
+ std::string _name;
+ OtherPort them;
+ bool _connected;
+ int32_t _x;
+ int32_t _y;
+};
+
+class Matrix : public Gtk::EventBox
+{
+ public:
+ Matrix();
+
+ void set_ports (const std::list<std::string>&);
+ void add_group (PortGroup&);
+ void remove_group (PortGroup&);
+ void hide_group (PortGroup&);
+ void show_group (PortGroup&);
+
+ int row_spacing () const { return xstep; }
+
+ protected:
+ bool on_button_press_event (GdkEventButton* ev);
+ bool on_expose_event (GdkEventExpose* ev);
+ void on_size_allocate (Gtk::Allocation&);
+ void on_size_request (Gtk::Requisition*);
+ void on_realize ();
+ bool on_motion_notify_event (GdkEventMotion*);
+ bool on_leave_notify_event (GdkEventCrossing*);
+
+ MatrixNode* get_node (int32_t x, int32_t y);
+
+private:
+ int height;
+ int width;
+ int alloc_width;
+ int alloc_height;
+ bool drawn;
+ int labels_y_shift;
+ int labels_x_shift;
+ float angle_radians;
+ int border;
+ int ystep;
+ int xstep;
+ uint32_t line_height;
+ uint32_t line_width;
+ int arc_radius;
+ int32_t motion_x;
+ int32_t motion_y;
+
+ std::list<std::string> ours;
+ std::list<OtherPort> others;
+ std::vector<MatrixNode*> nodes;
+
+ void reset_size ();
+ void redraw (GdkDrawable*, GdkRectangle*);
+ void alloc_pixmap ();
+ void setup_nodes ();
+
+ GdkPixmap* pixmap;
+};
+
+#endif /* __gtk_ardour_matrix_h__ */
}
#endif
-MixerStrip::MixerStrip (Mixer_UI& mx, Session& sess, boost::shared_ptr<Route> rt, bool in_mixer)
- : AxisView(sess),
- RouteUI (rt, sess, _("Mute"), _("Solo"), _("Record")),
- _mixer(mx),
- _mixer_owned (in_mixer),
- pre_processor_box (PreFader, sess, rt, mx.plugin_selector(), mx.selection(), in_mixer),
- post_processor_box (PostFader, sess, rt, mx.plugin_selector(), mx.selection(), in_mixer),
- gpm (_route, sess),
- panners (_route, sess),
- button_table (3, 2),
- middle_button_table (1, 2),
- bottom_button_table (1, 2),
- meter_point_label (_("pre")),
- comment_button (_("Comments")),
- speed_adjustment (1.0, 0.001, 4.0, 0.001, 0.1),
- speed_spinner (&speed_adjustment, "MixerStripSpeedBase", true)
+MixerStrip::MixerStrip (Mixer_UI& mx, Session& sess, bool in_mixer)
+ : AxisView(sess)
+ , RouteUI (sess, _("Mute"), _("Solo"), _("Record"))
+ ,_mixer(mx)
+ , _mixer_owned (in_mixer)
+ , pre_processor_box (PreFader, sess, mx.plugin_selector(), mx.selection(), in_mixer)
+ , post_processor_box (PostFader, sess, mx.plugin_selector(), mx.selection(), in_mixer)
+ , gpm (sess)
+ , panners (sess)
+ , button_table (3, 2)
+ , middle_button_table (1, 2)
+ , bottom_button_table (1, 2)
+ , meter_point_label (_("pre"))
+ , comment_button (_("Comments"))
+ , speed_adjustment (1.0, 0.001, 4.0, 0.001, 0.1)
+ , speed_spinner (&speed_adjustment, "MixerStripSpeedBase", true)
+
+{
+ init ();
+}
+MixerStrip::MixerStrip (Mixer_UI& mx, Session& sess, boost::shared_ptr<Route> rt, bool in_mixer)
+ : AxisView(sess)
+ , RouteUI (sess, _("Mute"), _("Solo"), _("Record"))
+ ,_mixer(mx)
+ , _mixer_owned (in_mixer)
+ , pre_processor_box (PreFader, sess, mx.plugin_selector(), mx.selection(), in_mixer)
+ , post_processor_box (PostFader, sess, mx.plugin_selector(), mx.selection(), in_mixer)
+ , gpm (sess)
+ , panners (sess)
+ , button_table (3, 2)
+ , middle_button_table (1, 2)
+ , bottom_button_table (1, 2)
+ , meter_point_label (_("pre"))
+ , comment_button (_("Comments"))
+ , speed_adjustment (1.0, 0.001, 4.0, 0.001, 0.1)
+ , speed_spinner (&speed_adjustment, "MixerStripSpeedBase", true)
+
{
- if (set_color_from_route()) {
- set_color (unique_random_color());
- }
+ init ();
+ set_route (rt);
+}
+void
+MixerStrip::init ()
+{
input_selector = 0;
output_selector = 0;
group_menu = 0;
- if (!_route->is_hidden()) {
- _marked_for_display = true;
- }
+ _marked_for_display = false;
route_ops_menu = 0;
ignore_comment_edit = false;
ignore_toggle = false;
comment_area = 0;
_width_owner = 0;
- Gtk::Image *width_icon = manage (new Gtk::Image (::get_icon("strip_width")));
- Gtk::Image *hide_icon = manage (new Gtk::Image (::get_icon("hide")));
- width_button.add (*width_icon);
- hide_button.add (*hide_icon);
+ width_button.add (*(manage (new Gtk::Image (::get_icon("strip_width")))));
+ hide_button.add (*(manage (new Gtk::Image (::get_icon("hide")))));
input_label.set_text (_("Input"));
+ ARDOUR_UI::instance()->set_tip (&input_button, _("Click to choose inputs"), "");
input_button.add (input_label);
input_button.set_name ("MixerIOButton");
input_label.set_name ("MixerIOButtonLabel");
output_label.set_text (_("Output"));
+ ARDOUR_UI::instance()->set_tip (&output_button, _("Click to choose outputs"), "");
output_button.add (output_label);
output_button.set_name ("MixerIOButton");
output_label.set_name ("MixerIOButtonLabel");
- _route->meter_change.connect (mem_fun(*this, &MixerStrip::meter_changed));
+ ARDOUR_UI::instance()->set_tip (&meter_point_button, _("Select metering point"), "");
meter_point_button.add (meter_point_label);
meter_point_button.set_name ("MixerStripMeterPreButton");
meter_point_label.set_name ("MixerStripMeterPreButton");
- switch (_route->meter_point()) {
- case MeterInput:
- meter_point_label.set_text (_("input"));
- break;
-
- case MeterPreFader:
- meter_point_label.set_text (_("pre"));
- break;
-
- case MeterPostFader:
- meter_point_label.set_text (_("post"));
- break;
- }
-
/* TRANSLATORS: this string should be longest of the strings
used to describe meter points. In english, it's "input".
*/
bottom_button_table.set_homogeneous (true);
bottom_button_table.attach (group_button, 0, 1, 0, 1);
- if (is_audio_track()) {
- boost::shared_ptr<AudioTrack> at = audio_track();
-
- at->FreezeChange.connect (mem_fun(*this, &MixerStrip::map_frozen));
-
-#ifdef VARISPEED_IN_MIXER_STRIP
- speed_adjustment.signal_value_changed().connect (mem_fun(*this, &MixerStrip::speed_adjustment_changed));
-
- speed_frame.set_name ("BaseFrame");
- speed_frame.set_shadow_type (Gtk::SHADOW_IN);
- speed_frame.add (speed_spinner);
-
- speed_spinner.set_print_func (speed_printer, 0);
-
- ARDOUR_UI::instance()->tooltips().set_tip (speed_spinner, _("Varispeed"));
-
- button_table.attach (speed_frame, 0, 2, 5, 6);
-#endif /* VARISPEED_IN_MIXER_STRIP */
-
- }
-
- if(rec_enable_button) {
- rec_enable_button->signal_button_press_event().connect (mem_fun(*this, &RouteUI::rec_enable_press), false);
- rec_enable_button->signal_button_release_event().connect (mem_fun(*this, &RouteUI::rec_enable_release));
-
- rec_enable_button->set_name ("MixerRecordEnableButton");
- button_table.attach (*rec_enable_button, 0, 2, 2, 3);
- }
-
name_button.add (name_label);
name_button.set_name ("MixerNameButton");
Gtkmm2ext::set_size_request_to_display_given_text (name_button, "longest label", 2, 2);
name_label.set_name ("MixerNameButtonLabel");
- if (_route->phase_invert()) {
- name_label.set_text (X_("Ø ") + name_label.get_text());
- } else {
- name_label.set_text (_route->name());
- }
-
+ ARDOUR_UI::instance()->set_tip (&group_button, _("Mix group"), "");
group_button.add (group_label);
group_button.set_name ("MixerGroupButton");
group_label.set_name ("MixerGroupButtonLabel");
comment_button.set_name ("MixerCommentButton");
- ARDOUR_UI::instance()->tooltips().set_tip (comment_button, _route->comment()=="" ?
- _("Click to Add/Edit Comments"):
- _route->comment());
-
comment_button.signal_clicked().connect (mem_fun(*this, &MixerStrip::comment_button_clicked));
global_vpacker.set_border_width (0);
global_vpacker.pack_start (output_button, Gtk::PACK_SHRINK);
global_vpacker.pack_start (comment_button, Gtk::PACK_SHRINK);
- if (route()->is_master() || route()->is_control()) {
-
- if (scrollbar_height == 0) {
- HScrollbar scrollbar;
- Gtk::Requisition requisition(scrollbar.size_request ());
- scrollbar_height = requisition.height;
- }
-
- EventBox* spacer = manage (new EventBox);
- spacer->set_size_request (-1, scrollbar_height);
- global_vpacker.pack_start (*spacer, false, false);
- }
-
global_frame.add (global_vpacker);
global_frame.set_shadow_type (Gtk::SHADOW_IN);
global_frame.set_name ("BaseFrame");
_session.engine().Stopped.connect (mem_fun(*this, &MixerStrip::engine_stopped));
_session.engine().Running.connect (mem_fun(*this, &MixerStrip::engine_running));
- _route->input_changed.connect (mem_fun(*this, &MixerStrip::input_changed));
- _route->output_changed.connect (mem_fun(*this, &MixerStrip::output_changed));
- _route->mute_changed.connect (mem_fun(*this, &RouteUI::mute_changed));
- _route->solo_changed.connect (mem_fun(*this, &RouteUI::solo_changed));
- _route->solo_safe_changed.connect (mem_fun(*this, &RouteUI::solo_changed));
- _route->mix_group_changed.connect (mem_fun(*this, &MixerStrip::mix_group_changed));
- _route->panner().Changed.connect (mem_fun(*this, &MixerStrip::connect_to_pan));
-
- if (is_audio_track()) {
- audio_track()->DiskstreamChanged.connect (mem_fun(*this, &MixerStrip::diskstream_changed));
- get_diskstream()->SpeedChanged.connect (mem_fun(*this, &MixerStrip::speed_changed));
- }
-
- _route->NameChanged.connect (mem_fun(*this, &RouteUI::name_changed));
- _route->comment_changed.connect (mem_fun(*this, &MixerStrip::comment_changed));
- _route->gui_changed.connect (mem_fun(*this, &MixerStrip::route_gui_changed));
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);
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);
+ /* we don't need this if its not an audio track, but we don't know that yet and it doesn't
+ hurt (much).
+ */
+
+ rec_enable_button->set_name ("MixerRecordEnableButton");
+ rec_enable_button->signal_button_press_event().connect (mem_fun(*this, &RouteUI::rec_enable_press), false);
+ rec_enable_button->signal_button_release_event().connect (mem_fun(*this, &RouteUI::rec_enable_release));
+
name_button.signal_button_press_event().connect (mem_fun(*this, &MixerStrip::name_button_button_press), false);
group_button.signal_button_press_event().connect (mem_fun(*this, &MixerStrip::select_mix_group), false);
_width = (Width) -1;
- set_stuff_from_route ();
+
+ /* start off as a passthru strip. we'll correct this, if necessary,
+ in update_diskstream_display().
+ */
/* start off as a passthru strip. we'll correct this, if necessary,
in update_diskstream_display().
else
set_name ("AudioTrackStripBase");
+ add_events (Gdk::BUTTON_RELEASE_MASK);
+}
+
+MixerStrip::~MixerStrip ()
+{
+ GoingAway(); /* EMIT_SIGNAL */
+
+ if (input_selector) {
+ delete input_selector;
+ }
+
+ if (output_selector) {
+ delete output_selector;
+ }
+}
+
+void
+MixerStrip::set_route (boost::shared_ptr<Route> rt)
+{
+ if (rec_enable_button->get_parent()) {
+ button_table.remove (*rec_enable_button);
+ }
+
+#ifdef VARISPEED_IN_MIXER_STRIP
+ if (speed_frame->get_parent()) {
+ button_table.remove (*speed_frame);
+ }
+#endif
+
+ RouteUI::set_route (rt);
+
+ panners.set_io (rt);
+ gpm.set_io (rt);
+ pre_processor_box.set_route (rt);
+ post_processor_box.set_route (rt);
+
+ if (set_color_from_route()) {
+ set_color (unique_random_color());
+ }
+
+ if (_mixer_owned && (route()->is_master() || route()->is_control())) {
+
+ if (scrollbar_height == 0) {
+ HScrollbar scrollbar;
+ Gtk::Requisition requisition(scrollbar.size_request ());
+ scrollbar_height = requisition.height;
+ }
+
+ EventBox* spacer = manage (new EventBox);
+ spacer->set_size_request (-1, scrollbar_height);
+ global_vpacker.pack_start (*spacer, false, false);
+ }
+
+ if (is_audio_track()) {
+
+ boost::shared_ptr<AudioTrack> at = audio_track();
+
+ connections.push_back (at->FreezeChange.connect (mem_fun(*this, &MixerStrip::map_frozen)));
+
+#ifdef VARISPEED_IN_MIXER_STRIP
+ speed_adjustment.signal_value_changed().connect (mem_fun(*this, &MixerStrip::speed_adjustment_changed));
+
+ speed_frame.set_name ("BaseFrame");
+ speed_frame.set_shadow_type (Gtk::SHADOW_IN);
+ speed_frame.add (speed_spinner);
+
+ speed_spinner.set_print_func (speed_printer, 0);
+
+ ARDOUR_UI::instance()->tooltips().set_tip (speed_spinner, _("Varispeed"));
+
+ button_table.attach (speed_frame, 0, 2, 5, 6);
+#endif /* VARISPEED_IN_MIXER_STRIP */
+
+ button_table.attach (*rec_enable_button, 0, 2, 2, 3);
+ }
+
+ if (_route->phase_invert()) {
+ name_label.set_text (X_("Ø ") + name_label.get_text());
+ } else {
+ name_label.set_text (_route->name());
+ }
+
+ switch (_route->meter_point()) {
+ case MeterInput:
+ meter_point_label.set_text (_("input"));
+ break;
+
+ case MeterPreFader:
+ meter_point_label.set_text (_("pre"));
+ break;
+
+ case MeterPostFader:
+ meter_point_label.set_text (_("post"));
+ break;
+ }
+
+ ARDOUR_UI::instance()->tooltips().set_tip (comment_button, _route->comment().empty() ?
+ _("Click to Add/Edit Comments"):
+ _route->comment());
+
+ connections.push_back (_route->meter_change.connect (mem_fun(*this, &MixerStrip::meter_changed)));
+ connections.push_back (_route->input_changed.connect (mem_fun(*this, &MixerStrip::input_changed)));
+ connections.push_back (_route->output_changed.connect (mem_fun(*this, &MixerStrip::output_changed)));
+ connections.push_back (_route->mute_changed.connect (mem_fun(*this, &RouteUI::mute_changed)));
+ connections.push_back (_route->solo_changed.connect (mem_fun(*this, &RouteUI::solo_changed)));
+ connections.push_back (_route->solo_safe_changed.connect (mem_fun(*this, &RouteUI::solo_changed)));
+ connections.push_back (_route->mix_group_changed.connect (mem_fun(*this, &MixerStrip::mix_group_changed)));
+ connections.push_back (_route->panner().Changed.connect (mem_fun(*this, &MixerStrip::connect_to_pan)));
+
+ if (is_audio_track()) {
+ connections.push_back (audio_track()->DiskstreamChanged.connect (mem_fun(*this, &MixerStrip::diskstream_changed)));
+ connections.push_back (get_diskstream()->SpeedChanged.connect (mem_fun(*this, &MixerStrip::speed_changed)));
+ }
+
+ connections.push_back (_route->NameChanged.connect (mem_fun(*this, &RouteUI::name_changed)));
+ connections.push_back (_route->comment_changed.connect (mem_fun(*this, &MixerStrip::comment_changed)));
+ connections.push_back (_route->gui_changed.connect (mem_fun(*this, &MixerStrip::route_gui_changed)));
+
+ set_stuff_from_route ();
+
/* now force an update of all the various elements */
pre_processor_box.update();
add_events (Gdk::BUTTON_RELEASE_MASK);
- whvbox->show();
- hide_icon->show();
- width_icon->show();
- gain_meter_alignment->show_all();
-
pre_processor_box.show();
if (!route()->is_master() && !route()->is_control()) {
show();
}
-MixerStrip::~MixerStrip ()
-{
- GoingAway(); /* EMIT_SIGNAL */
-
- if (input_selector) {
- delete input_selector;
- }
-
- if (output_selector) {
- delete output_selector;
- }
-}
-
void
MixerStrip::set_stuff_from_route ()
{
break;
}
}
+
gpm.setup_meters ();
panners.setup_pan ();
}
ENSURE_GUI_THREAD (bind (mem_fun(*this, &MixerStrip::meter_changed), src));
switch (_route->meter_point()) {
- case MeterInput:
- meter_point_label.set_text (_("input"));
- break;
-
- case MeterPreFader:
- meter_point_label.set_text (_("pre"));
- break;
+ case MeterInput:
+ meter_point_label.set_text (_("input"));
+ break;
- case MeterPostFader:
- meter_point_label.set_text (_("post"));
- break;
+ case MeterPreFader:
+ meter_point_label.set_text (_("pre"));
+ break;
+
+ case MeterPostFader:
+ meter_point_label.set_text (_("post"));
+ break;
}
gpm.setup_meters ();
- // reset peak when meter point changes
- gpm.reset_peak_display();
- set_width(_width, this);
+ // reset peak when meter point changes
+ gpm.reset_peak_display();
+ set_width(_width, this);
}
{
public:
MixerStrip (Mixer_UI&, ARDOUR::Session&, boost::shared_ptr<ARDOUR::Route>, bool in_mixer = true);
+ MixerStrip (Mixer_UI&, ARDOUR::Session&, bool in_mixer = true);
~MixerStrip ();
void set_width (Width, void* owner);
void set_embedded (bool);
ARDOUR::RouteGroup* mix_group() const;
+ void set_route (boost::shared_ptr<ARDOUR::Route>);
protected:
friend class Mixer_UI;
private:
Mixer_UI& _mixer;
+ void init ();
+
bool _embedded;
bool _packed;
bool _mixer_owned;
click_emphasis_path_entry.set_sensitive (true);
click_io_selector = new IOSelector (*session, session->click_io(), false);
- click_gpm = new GainMeter (session->click_io(), *session);
+ click_gpm = new GainMeter (*session);
+ click_gpm->set_io (session->click_io());
click_hpacker.pack_start (*click_io_selector, false, false);
click_hpacker.pack_start (*click_gpm, false, false);
OptionEditor::connect_audition_editor ()
{
auditioner_io_selector = new IOSelector (*session, session->the_auditioner(), false);
- auditioner_gpm = new GainMeter (session->the_auditioner(), *session);
+ auditioner_gpm = new GainMeter (*session);
+ auditioner_gpm->set_io (session->the_auditioner());
audition_hpacker.pack_start (*auditioner_io_selector, false, false);
audition_hpacker.pack_start (*auditioner_gpm, false, false);
const int PannerUI::pan_bar_height = 30;
-PannerUI::PannerUI (boost::shared_ptr<IO> io, Session& s)
- : _io (io),
- _session (s),
+PannerUI::PannerUI (Session& s)
+ : _session (s),
hAdjustment(0.0, 0.0, 0.0),
vAdjustment(0.0, 0.0, 0.0),
panning_viewport(hAdjustment, vAdjustment),
{
ignore_toggle = false;
pan_menu = 0;
+ pan_astate_menu = 0;
+ pan_astyle_menu = 0;
in_pan_update = false;
pan_automation_style_button.set_name ("MixerAutomationModeButton");
pan_automation_style_button.unset_flags (Gtk::CAN_FOCUS);
pan_automation_state_button.unset_flags (Gtk::CAN_FOCUS);
- using namespace Menu_Helpers;
- pan_astate_menu.items().push_back (MenuElem (_("Manual"),
- bind (mem_fun (_io->panner(), &Panner::set_automation_state), (AutoState) Off)));
- pan_astate_menu.items().push_back (MenuElem (_("Play"),
- bind (mem_fun (_io->panner(), &Panner::set_automation_state), (AutoState) Play)));
- pan_astate_menu.items().push_back (MenuElem (_("Write"),
- bind (mem_fun (_io->panner(), &Panner::set_automation_state), (AutoState) Write)));
- pan_astate_menu.items().push_back (MenuElem (_("Touch"),
- bind (mem_fun (_io->panner(), &Panner::set_automation_state), (AutoState) Touch)));
-
- pan_astyle_menu.items().push_back (MenuElem (_("Trim")));
- pan_astyle_menu.items().push_back (MenuElem (_("Abs")));
-
- pan_astate_menu.set_name ("ArdourContextMenu");
- pan_astyle_menu.set_name ("ArdourContextMenu");
-
pan_automation_style_button.signal_button_press_event().connect (mem_fun(*this, &PannerUI::pan_automation_style_button_event), false);
pan_automation_state_button.signal_button_press_event().connect (mem_fun(*this, &PannerUI::pan_automation_state_button_event), false);
panner = 0;
set_width(Narrow);
-
- _io->panner().Changed.connect (mem_fun(*this, &PannerUI::panner_changed));
- _io->panner().LinkStateChanged.connect (mem_fun(*this, &PannerUI::update_pan_linkage));
- _io->panner().StateChanged.connect (mem_fun(*this, &PannerUI::update_pan_state));
+}
+
+void
+PannerUI::set_io (boost::shared_ptr<IO> io)
+{
+ connections.clear ();
+
+ if (pan_astyle_menu) {
+ delete pan_astyle_menu;
+ pan_astyle_menu = 0;
+ }
+
+ if (pan_astate_menu) {
+ delete pan_astate_menu;
+ pan_astate_menu = 0;
+ }
+
+ _io = io;
+
+ connections.push_back (_io->panner().Changed.connect (mem_fun(*this, &PannerUI::panner_changed)));
+ connections.push_back (_io->panner().LinkStateChanged.connect (mem_fun(*this, &PannerUI::update_pan_linkage)));
+ connections.push_back (_io->panner().StateChanged.connect (mem_fun(*this, &PannerUI::update_pan_state)));
+
+ if (panner) {
+ delete panner;
+ panner = 0;
+ }
+
pan_changed (0);
update_pan_sensitive ();
update_pan_linkage ();
pan_automation_state_changed ();
+#if WHERE_DOES_THIS_LIVE
pan_bar_packer.show();
panning_viewport.show();
panning_up.show();
pan_automation_style_button.show();
pan_automation_state_button.show();
show();
+#endif
+}
+
+void
+PannerUI::build_astate_menu ()
+{
+ using namespace Menu_Helpers;
+
+ if (pan_astate_menu == 0) {
+ pan_astate_menu = new Menu;
+ pan_astate_menu->set_name ("ArdourContextMenu");
+ } else {
+ pan_astate_menu->items().clear ();
+ }
+
+ pan_astate_menu->items().push_back (MenuElem (_("Manual"),
+ bind (mem_fun (_io->panner(), &Panner::set_automation_state), (AutoState) Off)));
+ pan_astate_menu->items().push_back (MenuElem (_("Play"),
+ bind (mem_fun (_io->panner(), &Panner::set_automation_state), (AutoState) Play)));
+ pan_astate_menu->items().push_back (MenuElem (_("Write"),
+ bind (mem_fun (_io->panner(), &Panner::set_automation_state), (AutoState) Write)));
+ pan_astate_menu->items().push_back (MenuElem (_("Touch"),
+ bind (mem_fun (_io->panner(), &Panner::set_automation_state), (AutoState) Touch)));
+
+}
+
+void
+PannerUI::build_astyle_menu ()
+{
+ using namespace Menu_Helpers;
+
+ if (pan_astyle_menu == 0) {
+ pan_astyle_menu = new Menu;
+ pan_astyle_menu->set_name ("ArdourContextMenu");
+ } else {
+ pan_astyle_menu->items().clear();
+ }
+
+ pan_astyle_menu->items().push_back (MenuElem (_("Trim")));
+ pan_astyle_menu->items().push_back (MenuElem (_("Abs")));
}
boost::shared_ptr<PBD::Controllable>
if (pan_menu) {
delete pan_menu;
}
-
+
+ if (pan_astyle_menu) {
+ delete pan_astyle_menu;
+ }
+
+ if (pan_astate_menu) {
+ delete pan_astate_menu;
+ }
}
switch (ev->button) {
case 1:
- pan_astate_menu.popup (1, ev->time);
+ if (pan_astate_menu == 0) {
+ build_astate_menu ();
+ }
+ pan_astate_menu->popup (1, ev->time);
break;
default:
break;
switch (ev->button) {
case 1:
- pan_astyle_menu.popup (1, ev->time);
+ if (pan_astyle_menu == 0) {
+ build_astyle_menu ();
+ }
+ pan_astyle_menu->popup (1, ev->time);
break;
default:
break;
class PannerUI : public Gtk::HBox
{
public:
- PannerUI (boost::shared_ptr<ARDOUR::IO>, ARDOUR::Session&);
+ PannerUI (ARDOUR::Session&);
~PannerUI ();
+ virtual void set_io (boost::shared_ptr<ARDOUR::IO>);
+
void pan_changed (void *);
void update_pan_sensitive ();
boost::shared_ptr<ARDOUR::IO> _io;
ARDOUR::Session& _session;
+ std::vector<sigc::connection> connections;
bool ignore_toggle;
bool in_pan_update;
bool panning_link_button_press (GdkEventButton*);
bool panning_link_button_release (GdkEventButton*);
- Gtk::Menu pan_astate_menu;
- Gtk::Menu pan_astyle_menu;
+ Gtk::Menu* pan_astate_menu;
+ Gtk::Menu* pan_astyle_menu;
Gtk::Button pan_automation_style_button;
Gtk::ToggleButton pan_automation_state_button;
void update_pan_bars (bool only_if_aplay);
void update_pan_linkage ();
void update_pan_state ();
+ void build_astate_menu ();
+ void build_astyle_menu ();
void panner_changed ();
--- /dev/null
+#ifndef __gtk_ardour_port_group_h__
+#define __gtk_ardour_port_group_h__
+
+#include <vector>
+#include <string>
+
+#include <gtkmm/widget.h>
+#include <gtkmm/checkbutton.h>
+
+#include <ardour/data_type.h>
+
+namespace ARDOUR {
+ class Session;
+ class IO;
+ class PortInsert;
+}
+
+class PortMatrix;
+
+/// A list of port names, grouped by some aspect of their type e.g. busses, tracks, system
+class PortGroup
+{
+ public:
+ /** PortGroup constructor.
+ * @param n Name.
+ * @param p Port name prefix.
+ * @param v true if group should be visible in the UI, otherwise false.
+ */
+ PortGroup (std::string const & n, std::string const & p, bool v) : name (n), prefix (p), visible (v) {}
+
+ void add (std::string const & p);
+
+ std::string name; ///< name for the group
+ std::string prefix; ///< prefix (before colon) e.g. "ardour:"
+ std::vector<std::string> ports; ///< port names
+ bool visible; ///< true if the group is visible in the UI
+};
+
+/// The UI for a PortGroup
+class PortGroupUI
+{
+ public:
+ PortGroupUI (PortMatrix&, PortGroup&);
+
+ Gtk::Widget& get_visibility_checkbutton ();
+ PortGroup& port_group () { return _port_group; }
+ void setup_visibility ();
+
+ private:
+ void port_checkbutton_toggled (Gtk::CheckButton*, int, int);
+ bool port_checkbutton_release (GdkEventButton* ev, Gtk::CheckButton* b, int r, int c);
+ void visibility_checkbutton_toggled ();
+
+ PortMatrix& _port_matrix; ///< the PortMatrix that we are working for
+ PortGroup& _port_group; ///< the PortGroup that we are representing
+ bool _ignore_check_button_toggle;
+ Gtk::CheckButton _visibility_checkbutton;
+};
+
+/// A list of PortGroups
+class PortGroupList : public std::list<PortGroup*>
+{
+ public:
+ enum Mask {
+ BUSS = 0x1,
+ TRACK = 0x2,
+ SYSTEM = 0x4,
+ OTHER = 0x8
+ };
+
+ PortGroupList (ARDOUR::Session &, ARDOUR::DataType, bool, Mask);
+
+ void refresh ();
+ int n_visible_ports () const;
+ std::string get_port_by_index (int, bool with_prefix = true) const;
+ void set_type (ARDOUR::DataType);
+ void set_offer_inputs (bool);
+
+ private:
+ ARDOUR::Session& _session;
+ ARDOUR::DataType _type;
+ bool _offer_inputs;
+
+ PortGroup buss;
+ PortGroup track;
+ PortGroup system;
+ PortGroup other;
+};
+
+#endif /* __gtk_ardour_port_group_h__ */
, _ignore_check_button_toggle (false)
, _visibility_checkbutton (g.name)
{
- int const ports = _port_group.ports.size();
- int const rows = _port_matrix.n_rows ();
-
- if (rows == 0 || ports == 0) {
- return;
- }
-
- /* Sort out the table and the checkbuttons inside it */
-
- _table.resize (rows, ports);
- _port_checkbuttons.resize (rows);
- for (int i = 0; i < rows; ++i) {
- _port_checkbuttons[i].resize (ports);
- }
-
-
- for (int i = 0; i < rows; ++i) {
- for (uint32_t j = 0; j < _port_group.ports.size(); ++j) {
- CheckButton* b = new CheckButton;
-
- b->signal_toggled().connect (
- sigc::bind (sigc::mem_fun (*this, &PortGroupUI::port_checkbutton_toggled), b, i, j));
-
- b->signal_button_release_event().connect (
- sigc::bind (sigc::mem_fun (*this, &PortGroupUI::port_checkbutton_release), b, i, j), false);
-
- _port_checkbuttons[i][j] = b;
-
- cerr << this << " bind to " << &_port_checkbuttons << " via " << b
- << endl;
-
- _table.attach (*b, j, j + 1, i, i + 1);
- }
- }
-
- _table_box.add (_table);
-
- _ignore_check_button_toggle = true;
-
- /* Set the state of the check boxes according to current connections */
- for (int i = 0; i < rows; ++i) {
- for (uint32_t j = 0; j < _port_group.ports.size(); ++j) {
- std::string const t = _port_group.prefix + _port_group.ports[j];
- bool const s = _port_matrix.get_state (i, t);
- _port_checkbuttons[i][j]->set_active (s);
- if (s) {
- _port_group.visible = true;
- }
- }
- }
-
+ _port_group.visible = true;
_ignore_check_button_toggle = false;
-
_visibility_checkbutton.signal_toggled().connect (sigc::mem_fun (*this, &PortGroupUI::visibility_checkbutton_toggled));
}
_port_group.visible = _visibility_checkbutton.get_active ();
}
-/** @return Width and height of a single checkbutton in a port group table */
-std::pair<int, int>
-PortGroupUI::unit_size () const
-{
- if (_port_checkbuttons.empty() || _port_checkbuttons[0].empty())
- {
- return std::pair<int, int> (0, 0);
- }
-
- int r = 0;
- /* We can't ask for row spacing unless there >1 rows, otherwise we get a warning */
- if (_table.property_n_rows() > 1) {
- r = _table.get_row_spacing (0);
- }
-
- return std::make_pair (
- _port_checkbuttons[0][0]->get_width() + _table.get_col_spacing (0),
- _port_checkbuttons[0][0]->get_height() + r
- );
-}
-
-/** @return Table widget containing the port checkbuttons */
-Widget&
-PortGroupUI::get_table ()
-{
- return _table_box;
-}
-
/** @return Checkbutton used to toggle visibility */
Widget&
PortGroupUI::get_visibility_checkbutton ()
PortGroupUI::port_checkbutton_toggled (CheckButton* b, int r, int c)
{
if (_ignore_check_button_toggle == false) {
- _port_matrix.set_state (r, _port_group.prefix + _port_group.ports[c], b->get_active(), 0);
+ // _port_matrix.hide_group (_port_group);
}
}
-bool
-PortGroupUI::port_checkbutton_release (GdkEventButton* ev, CheckButton* b, int r, int c)
-{
- cerr << this << " RELEASE on " << b << " state = " << ev->state << endl;
-
- if (ev->state == 0) {
- /* let usual toggle handler take care of it */
- return false;
- }
-
- /* The fun starts here
- */
-
- const size_t ports = _port_group.ports.size();
- const size_t rows = _port_matrix.n_rows ();
-
- if (rows == 0 || ports == 0) {
- return true;
- }
-
- /* For each port in the group, change the state of
- the connection for the corresponding "connector" port.
- */
-
- for (size_t j = c; j < ports; ++j) {
-
- /* we've got a port to connect, now lets find the thing to
- connect it too ... (search "down" the rows)
- */
-
- cerr << "we're going to connect port " << j << " of " << ports << endl;
-
- for (size_t i = r; i < rows; ++i) {
-
- cerr << this << " going to connect to row " << i << " of " << rows << endl;
- cerr << "access [" << i << "][" << j << "]\n";
- cerr << " @ " << &_port_checkbuttons << endl;
-
- _port_checkbuttons[i][j]->set_active (!_port_checkbuttons[i][j]->get_active());
-
- /* next time, get at least as far as this port before looking
- for more.
- */
-
- r = i + 1;
-
- /* changed connection state, stop looking for more */
-
- break;
- }
- }
-
- return true;
-}
-
/** Set up visibility of the port group according to PortGroup::visible */
void
PortGroupUI::setup_visibility ()
{
- if (!_port_group.ports.empty() && _port_group.visible) {
- _table_box.show ();
- } else {
- _table_box.hide ();
- }
-
if (_visibility_checkbutton.get_active () != _port_group.visible) {
-
_visibility_checkbutton.set_active (_port_group.visible);
}
}
-RotatedLabelSet::RotatedLabelSet (PortGroupList& g)
- : Glib::ObjectBase ("RotatedLabelSet"), Widget (), _port_group_list (g), _base_width (128)
-{
- set_flags (NO_WINDOW);
- if (getenv ("AD_ANGLE") != 0) {
- set_angle (atoi (getenv ("AD_ANGLE")));
- } else {
- set_angle (45);
- }
-}
-
-RotatedLabelSet::~RotatedLabelSet ()
-{
-
-}
-
-
-/** Set the angle that the labels are drawn at.
- * @param degrees New angle in degrees.
- */
-
-void
-RotatedLabelSet::set_angle (int degrees)
-{
- _angle_degrees = degrees;
- _angle_radians = M_PI * _angle_degrees / 180;
-
- queue_resize ();
-}
-
-void
-RotatedLabelSet::on_size_request (Requisition* requisition)
-{
- *requisition = Requisition ();
-
- if (_pango_layout == 0) {
- return;
- }
-
- /* Our height is the highest label */
- requisition->height = 0;
- for (PortGroupList::const_iterator i = _port_group_list.begin(); i != _port_group_list.end(); ++i) {
- for (std::vector<std::string>::const_iterator j = (*i)->ports.begin(); j != (*i)->ports.end(); ++j) {
- std::pair<int, int> const d = setup_layout (*j);
- if (d.second > requisition->height) {
- requisition->height = d.second;
- }
- }
- }
-
- /* And our width is the base plus the width of the last label */
- requisition->width = _base_width;
- int const n = _port_group_list.n_visible_ports ();
- if (n > 0) {
- std::pair<int, int> const d = setup_layout (_port_group_list.get_port_by_index (n - 1, false));
- requisition->width += d.first;
- }
-
- cerr << "Labels will be " << requisition->width << " x " << requisition->height << endl;
-}
-
-void
-RotatedLabelSet::on_size_allocate (Allocation& allocation)
-{
- set_allocation (allocation);
-
- if (_gdk_window) {
- _gdk_window->move_resize (allocation.get_x(), allocation.get_y(), allocation.get_width(), allocation.get_height());
- }
-}
-
-void
-RotatedLabelSet::on_realize ()
-{
- Widget::on_realize ();
-
- Glib::RefPtr<Style> style = get_style ();
-
- if (!_gdk_window) {
- GdkWindowAttr attributes;
- memset (&attributes, 0, sizeof (attributes));
-
- Allocation allocation = get_allocation ();
- attributes.x = allocation.get_x ();
- attributes.y = allocation.get_y ();
- attributes.width = allocation.get_width ();
- attributes.height = allocation.get_height ();
-
- attributes.event_mask = get_events () | Gdk::EXPOSURE_MASK;
- attributes.window_type = GDK_WINDOW_CHILD;
- attributes.wclass = GDK_INPUT_OUTPUT;
-
- _gdk_window = Gdk::Window::create (get_window (), &attributes, GDK_WA_X | GDK_WA_Y);
- unset_flags (NO_WINDOW);
- set_window (_gdk_window);
-
- _bg_colour = style->get_bg (STATE_NORMAL );
- modify_bg (STATE_NORMAL, _bg_colour);
- _fg_colour = style->get_fg (STATE_NORMAL);
-
- _gdk_window->set_user_data (gobj ());
-
- /* Set up Pango stuff */
- _pango_context = create_pango_context ();
-
- Pango::Matrix matrix = PANGO_MATRIX_INIT;
- pango_matrix_rotate (&matrix, _angle_degrees);
- _pango_context->set_matrix (matrix);
-
- _pango_layout = Pango::Layout::create (_pango_context);
- _gc = Gdk::GC::create (get_window ());
- }
-}
-
-void
-RotatedLabelSet::on_unrealize()
-{
- _gdk_window.clear ();
-
- Widget::on_unrealize ();
-}
-
-
-/** Set up our Pango layout to plot a given string, and compute its dimensions once
- * it has been rotated.
- * @param s String to use.
- * @return width and height of the rotated string, in pixels.
- */
-
-std::pair<int, int>
-RotatedLabelSet::setup_layout (std::string const & s)
-{
- _pango_layout->set_text (s);
-
- /* Here's the unrotated size */
- int w;
- int h;
- _pango_layout->get_pixel_size (w, h);
-
- /* Rotate the width and height as appropriate. I thought Pango might be able
- to do this for us, but I can't find out how...
- */
-
- std::pair<int, int> d;
-
- // cerr << "\"" << s << "\" was " << w << " x " << h << endl;
-
- d.first = int (fabs (w * cos (_angle_radians) + h * sin (_angle_radians)));
- d.second = int (fabs (w * sin (_angle_radians) + h * cos (_angle_radians)));
-
- // cerr << "\trotated by " << _angle_degrees << " = " << d.first << " x " << d.second << endl;
-
- return d;
-}
-
-bool
-RotatedLabelSet::on_expose_event (GdkEventExpose* event)
-{
- if (!_gdk_window) {
- return true;
- }
-
- int const height = get_allocation().get_height ();
- double const spacing = double (_base_width) / _port_group_list.n_visible_ports();
-
- /* Plot all the visible labels; really we should clip for efficiency */
- int n = 0;
- for (PortGroupList::const_iterator i = _port_group_list.begin(); i != _port_group_list.end(); ++i) {
- if ((*i)->visible) {
- for (uint32_t j = 0; j < (*i)->ports.size(); ++j) {
- std::pair<int, int> const d = setup_layout ((*i)->ports[j]);
- int x, y;
- if (getenv ("AD_X_SHIFT") != 0) {
- x = atoi (getenv ("AD_X_SHIFT"));
- } else {
- x = 0;
- }
- if (getenv ("AD_Y_SHIFT") != 0) {
- y = atoi (getenv ("AD_Y_SHIFT"));
- } else {
- y = 0;
- }
- get_window()->draw_layout (_gc, int ((n + 0.25) * spacing) + x, height - d.second + y, _pango_layout, _fg_colour, _bg_colour);
- ++n;
- }
- }
- }
-
- return true;
-}
-
-/** Set the `base width'. This is the width of the base of the label set, ie:
- *
- * L L L L
- * E E E E
- * B B B B
- * A A A A
- * L L L L
- * <--w-->
- */
-
-void
-RotatedLabelSet::set_base_width (int w)
-{
- _base_width = w;
- queue_resize ();
-}
-
-
PortMatrix::PortMatrix (ARDOUR::Session& session, ARDOUR::DataType type, bool offer_inputs, PortGroupList::Mask mask)
- : _offer_inputs (offer_inputs), _port_group_list (session, type, offer_inputs, mask), _type (type),
- _column_labels (_port_group_list)
+ : _offer_inputs (offer_inputs), _port_group_list (session, type, offer_inputs, mask), _type (type)
{
_row_labels_vbox = 0;
_side_vbox_pad = 0;
_visibility_checkbutton_box.pack_start (*(manage (new Label (_("Connections displayed: ")))), false, false, 10);
pack_start (_visibility_checkbutton_box, false, false);
-
+
_scrolled_window.set_policy (POLICY_ALWAYS, POLICY_AUTOMATIC);
_scrolled_window.set_shadow_type (SHADOW_NONE);
VBox* b = manage (new VBox);
- if (offer_inputs) {
- b->pack_start (_port_group_hbox, false, false);
- b->pack_start (_column_labels, false, false);
- } else {
- b->pack_start (_column_labels, false, false);
- b->pack_start (_port_group_hbox, false, false);
- }
+ b->pack_start (_port_group_hbox, false, false);
+ b->pack_start (_port_group_hbox, false, false);
- Alignment* a;
-
- if (offer_inputs) {
- a = manage (new Alignment (1, 0, 0, 0));
- } else {
- a = manage (new Alignment (0, 1, 0, 0));
- }
-
- a->add (*b);
-
- _scrolled_window.add (*a);
+ _scrolled_window.add (matrix);
if (offer_inputs) {
_overall_hbox.pack_start (_side_vbox, false, false, 6);
}
for (std::vector<PortGroupUI*>::iterator i = _port_group_ui.begin(); i != _port_group_ui.end(); ++i) {
- _port_group_hbox.remove ((*i)->get_table());
_visibility_checkbutton_box.remove ((*i)->get_visibility_checkbutton());
delete *i;
}
void
PortMatrix::setup_dimensions ()
{
- /* Get some dimensions from various places */
- int const scrollbar_height = _scrolled_window.get_hscrollbar()->get_height();
-
- std::pair<int, int> unit_size (0, 0);
- int port_group_tables_height = 0;
- for (std::vector<PortGroupUI*>::iterator i = _port_group_ui.begin(); i != _port_group_ui.end(); ++i) {
- std::pair<int, int> const u = (*i)->unit_size ();
- unit_size.first = std::max (unit_size.first, u.first);
- unit_size.second = std::max (unit_size.second, u.second);
- port_group_tables_height = std::max (
- port_group_tables_height, (*i)->get_table().get_height()
- );
- }
-
- /* Column labels */
- _column_labels.set_base_width (_port_group_list.n_visible_ports () * unit_size.first);
-
- /* Scrolled window */
- /* XXX: really shouldn't set a minimum horizontal size here, but if we don't
- the window starts up very small.
- The constant value in the set_size_request() computation will control
- how big the scrolled window will be if we fill the port matrix will a gajillion
- ports.
- */
-
- _scrolled_window.set_size_request (
- std::min (_column_labels.get_width(), 400),
- _column_labels.get_height() + port_group_tables_height + scrollbar_height + 16
- );
-
/* Row labels */
for (std::vector<EventBox*>::iterator j = _row_labels.begin(); j != _row_labels.end(); ++j) {
- (*j)->get_child()->set_size_request (-1, unit_size.second);
+ (*j)->get_child()->set_size_request (-1, matrix.row_spacing());
}
if (_side_vbox_pad) {
if (_offer_inputs) {
- _side_vbox_pad->set_size_request (-1, unit_size.second / 4);
+ _side_vbox_pad->set_size_request (-1, matrix.row_spacing() / 4);
} else {
- _side_vbox_pad->set_size_request (-1, scrollbar_height + unit_size.second / 4);
+ _side_vbox_pad->set_size_request (-1, matrix.row_spacing() / 4);
}
}
}
PortGroupUI* t = new PortGroupUI (*this, **i);
_port_group_ui.push_back (t);
- _port_group_hbox.pack_start (t->get_table(), false, false);
_visibility_checkbutton_box.pack_start (t->get_visibility_checkbutton(), false, false);
void
PortMatrix::reset_visibility ()
{
- /* now adjust visibility and coloring */
-
- bool even = true;
- Gdk::Color odd_bg (color_from_style ("OddPortGroups", STATE_NORMAL, "fg"));
- Gdk::Color even_bg (color_from_style ("EvenPortGroups", STATE_NORMAL, "fg"));
-
for (std::vector<PortGroupUI*>::iterator i = _port_group_ui.begin(); i != _port_group_ui.end(); ++i) {
(*i)->setup_visibility ();
if ((*i)->port_group().visible) {
- if (even) {
- (*i)->get_table().modify_bg (STATE_NORMAL, even_bg);
- } else {
- (*i)->get_table().modify_bg (STATE_NORMAL, odd_bg);
- }
- even = !even;
+ matrix.show_group ((*i)->port_group());
+ } else {
+ matrix.hide_group ((*i)->port_group());
}
}
}
#include <gtkmm/scrolledwindow.h>
#include "ardour_dialog.h"
+#include "port_group.h"
+#include "matrix.h"
namespace ARDOUR {
class Session;
class PortInsert;
}
-class PortMatrix;
-
-/// A list of port names, grouped by some aspect of their type e.g. busses, tracks, system
-class PortGroup
-{
- public:
- /** PortGroup constructor.
- * @param n Name.
- * @param p Port name prefix.
- * @param v true if group should be visible in the UI, otherwise false.
- */
- PortGroup (std::string const & n, std::string const & p, bool v) : name (n), prefix (p), visible (v) {}
-
- void add (std::string const & p);
-
- std::string name; ///< name for the group
- std::string prefix; ///< prefix (before colon) e.g. "ardour:"
- std::vector<std::string> ports; ///< port names
- bool visible; ///< true if the group is visible in the UI
-};
-
-/// The UI for a PortGroup
-class PortGroupUI
-{
- public:
- PortGroupUI (PortMatrix&, PortGroup&);
-
- Gtk::Widget& get_table ();
- Gtk::Widget& get_visibility_checkbutton ();
- std::pair<int, int> unit_size () const;
- PortGroup& port_group () { return _port_group; }
- void setup_visibility ();
-
- private:
- void port_checkbutton_toggled (Gtk::CheckButton*, int, int);
- bool port_checkbutton_release (GdkEventButton* ev, Gtk::CheckButton* b, int r, int c);
- void visibility_checkbutton_toggled ();
-
- PortMatrix& _port_matrix; ///< the PortMatrix that we are working for
- PortGroup& _port_group; ///< the PortGroup that we are representing
- bool _ignore_check_button_toggle;
- Gtk::Table _table;
- Gtk::EventBox _table_box;
- std::vector<std::vector<Gtk::CheckButton* > > _port_checkbuttons;
- Gtk::CheckButton _visibility_checkbutton;
-};
-
-/// A list of PortGroups
-class PortGroupList : public std::list<PortGroup*>
-{
- public:
- enum Mask {
- BUSS = 0x1,
- TRACK = 0x2,
- SYSTEM = 0x4,
- OTHER = 0x8
- };
-
- PortGroupList (ARDOUR::Session &, ARDOUR::DataType, bool, Mask);
-
- void refresh ();
- int n_visible_ports () const;
- std::string get_port_by_index (int, bool with_prefix = true) const;
- void set_type (ARDOUR::DataType);
- void set_offer_inputs (bool);
-
- private:
- ARDOUR::Session& _session;
- ARDOUR::DataType _type;
- bool _offer_inputs;
-
- PortGroup buss;
- PortGroup track;
- PortGroup system;
- PortGroup other;
-};
-
-
-/// A widget which provides a set of rotated text labels
-class RotatedLabelSet : public Gtk::Widget {
- public:
- RotatedLabelSet (PortGroupList&);
- virtual ~RotatedLabelSet ();
-
- void set_angle (int);
- void set_base_width (int);
- void update_visibility ();
-
- protected:
- virtual void on_size_request (Gtk::Requisition*);
- virtual void on_size_allocate (Gtk::Allocation&);
- virtual void on_realize ();
- virtual void on_unrealize ();
- virtual bool on_expose_event (GdkEventExpose*);
-
- Glib::RefPtr<Gdk::Window> _gdk_window;
-
- private:
- std::pair<int, int> setup_layout (std::string const &);
-
- PortGroupList& _port_group_list; ///< list of ports to display
- int _angle_degrees; ///< label rotation angle in degrees
- double _angle_radians; ///< label rotation angle in radians
- int _base_width; ///< width of labels; see set_base_width() for more details
- Glib::RefPtr<Pango::Context> _pango_context;
- Glib::RefPtr<Pango::Layout> _pango_layout;
- Glib::RefPtr<Gdk::GC> _gc;
- Gdk::Color _fg_colour;
- Gdk::Color _bg_colour;
-};
-
-
class PortMatrix : public Gtk::VBox {
public:
PortMatrix (ARDOUR::Session&, ARDOUR::DataType, bool, PortGroupList::Mask);
private:
PortGroupList _port_group_list;
ARDOUR::DataType _type;
+ Matrix matrix;
std::vector<PortGroupUI*> _port_group_ui;
std::vector<Gtk::EventBox*> _row_labels;
Gtk::VBox* _row_labels_vbox;
- RotatedLabelSet _column_labels;
Gtk::HBox _overall_hbox;
Gtk::VBox _side_vbox;
Gtk::HBox _port_group_hbox;
Gdk::Color* ProcessorBox::active_processor_color;
Gdk::Color* ProcessorBox::inactive_processor_color;
-ProcessorBox::ProcessorBox (Placement pcmnt, Session& sess, boost::shared_ptr<Route> rt, PluginSelector &plugsel,
- RouteRedirectSelection & rsel, bool owner_is_mixer)
- : _route(rt),
- _session(sess),
+ProcessorBox::ProcessorBox (Placement pcmnt, Session& sess, PluginSelector &plugsel,
+ RouteRedirectSelection & rsel, bool owner_is_mixer)
+ : _session(sess),
_owner_is_mixer (owner_is_mixer),
_placement(pcmnt),
_plugin_selector(plugsel),
pack_start (processor_eventbox, true, true);
- _route->processors_changed.connect (mem_fun(*this, &ProcessorBox::redisplay_processors));
- _route->GoingAway.connect (mem_fun (*this, &ProcessorBox::route_going_away));
-
processor_eventbox.signal_enter_notify_event().connect (bind (sigc::ptr_fun (ProcessorBox::enter_box), this));
processor_display.signal_button_press_event().connect (mem_fun(*this, &ProcessorBox::processor_button_press_event), false);
processor_display.signal_button_release_event().connect (mem_fun(*this, &ProcessorBox::processor_button_release_event));
-
- /* start off as a passthru strip. we'll correct this, if necessary,
- in update_diskstream_display().
- */
-
- /* now force an update of all the various elements */
-
- redisplay_processors ();
}
ProcessorBox::~ProcessorBox ()
{
}
+void
+ProcessorBox::set_route (boost::shared_ptr<Route> r)
+{
+ connections.clear ();
+
+ _route = r;
+
+ connections.push_back (_route->processors_changed.connect (mem_fun(*this, &ProcessorBox::redisplay_processors)));
+ connections.push_back (_route->GoingAway.connect (mem_fun (*this, &ProcessorBox::route_going_away)));
+
+ redisplay_processors ();
+}
+
void
ProcessorBox::route_going_away ()
{
class ProcessorBox : public Gtk::HBox, public PluginInterestedObject
{
public:
- ProcessorBox (ARDOUR::Placement, ARDOUR::Session&,
- boost::shared_ptr<ARDOUR::Route>, PluginSelector &, RouteRedirectSelection &, bool owner_is_mixer = false);
+ ProcessorBox (ARDOUR::Placement, ARDOUR::Session&, PluginSelector &, RouteRedirectSelection &, bool owner_is_mixer = false);
~ProcessorBox ();
+ void set_route (boost::shared_ptr<ARDOUR::Route>);
void set_width (Width);
void update();
static void register_actions();
- protected:
- void set_stuff_from_route ();
-
private:
boost::shared_ptr<ARDOUR::Route> _route;
ARDOUR::Session & _session;
bool _owner_is_mixer;
bool ab_direction;
+ std::vector<sigc::connection> connections;
ARDOUR::Placement _placement;
cleanup_processor_boxes();
// construct new redirect boxes
- pre_insert_box = new ProcessorBox(PreFader, *session, _route, *_plugin_selector, _rr_selection);
- post_insert_box = new ProcessorBox(PostFader, *session, _route, *_plugin_selector, _rr_selection);
+ pre_insert_box = new ProcessorBox(PreFader, *session, *_plugin_selector, _rr_selection);
+ post_insert_box = new ProcessorBox(PostFader, *session, *_plugin_selector, _rr_selection);
+
+ pre_insert_box->set_route (_route);
+ post_insert_box->set_route (_route);
pre_redir_hpane.pack1 (*pre_insert_box);
post_redir_hpane.pack1 (*post_insert_box);
size_button (_("h")), // height
automation_button (_("a")),
visual_button (_("v")),
- gm (rt, sess, slider, true)
-
+ gm (sess, slider, true)
{
+ gm.set_io (rt);
gm.get_level_meter().set_no_show_all();
gm.get_level_meter().setup_meters(50);
using namespace ARDOUR;
using namespace PBD;
-RouteUI::RouteUI (boost::shared_ptr<ARDOUR::Route> rt, ARDOUR::Session& sess, const char* m_name,
- const char* s_name, const char* r_name)
- : AxisView(sess),
- _route(rt),
- mute_button(0),
- solo_button(0),
- rec_enable_button(0)
+RouteUI::RouteUI (ARDOUR::Session& sess, const char* mute_name, const char* solo_name, const char* rec_name)
+ : AxisView(sess)
+{
+ init ();
+ set_button_names (mute_name, solo_name, rec_name);
+}
+
+RouteUI::RouteUI (boost::shared_ptr<ARDOUR::Route> rt,
+ ARDOUR::Session& sess, const char* mute_name, const char* solo_name, const char* rec_name)
+ : AxisView(sess)
+{
+ init ();
+ set_button_names (mute_name, solo_name, rec_name);
+ set_route (rt);
+}
+
+RouteUI::~RouteUI()
+{
+ GoingAway (); /* EMIT SIGNAL */
+
+ delete solo_menu;
+ delete mute_menu;
+ delete remote_control_menu;
+}
+
+void
+RouteUI::init ()
{
xml_node = 0;
mute_menu = 0;
polarity_menu_item = 0;
denormal_menu_item = 0;
- if (set_color_from_route()) {
- set_color (unique_random_color());
+ mute_button = manage (new BindableToggleButton (""));
+ mute_button->set_self_managed (true);
+ mute_button->set_name ("MuteButton");
+
+ solo_button = manage (new BindableToggleButton (""));
+ solo_button->set_self_managed (true);
+ solo_button->set_name ("SoloButton");
+
+ rec_enable_button = manage (new BindableToggleButton (""));
+ rec_enable_button->set_name ("RecordEnableButton");
+ rec_enable_button->set_self_managed (true);
+
+ _session.SoloChanged.connect (mem_fun(*this, &RouteUI::solo_changed_so_update_mute));
+}
+
+void
+RouteUI::reset ()
+{
+ connections.clear ();
+
+ if (solo_menu) {
+ delete solo_menu;
+ solo_menu = 0;
}
- new PairedShiva<Route,RouteUI> (*_route, *this);
+ if (mute_menu) {
+ delete mute_menu;
+ mute_menu = 0;
+ }
+
+ if (remote_control_menu) {
+ delete remote_control_menu;
+ remote_control_menu = 0;
+ }
- _route->active_changed.connect (mem_fun (*this, &RouteUI::route_active_changed));
+ if (xml_node) {
+ /* do not delete the node - its owned by the route */
+ xml_node = 0;
+ }
- mute_button = manage (new BindableToggleButton (_route->mute_control(), m_name ));
- mute_button->set_self_managed (true);
+ route_active_menu_item = 0;
+ polarity_menu_item = 0;
+ denormal_menu_item = 0;
+}
- solo_button = manage (new BindableToggleButton (_route->solo_control(), s_name ));
- solo_button->set_self_managed (true);
+void
+RouteUI::set_button_names (const char* mute, const char* solo, const char* rec)
+{
+ m_name = mute;
+ s_name = solo;
+ r_name = rec;
+}
- mute_button->set_name ("MuteButton");
- solo_button->set_name ("SoloButton");
+void
+RouteUI::set_route (boost::shared_ptr<Route> rp)
+{
+ reset ();
+
+ _route = rp;
+
+ if (set_color_from_route()) {
+ set_color (unique_random_color());
+ }
- _route->mute_changed.connect (mem_fun(*this, &RouteUI::mute_changed));
- _route->solo_changed.connect (mem_fun(*this, &RouteUI::solo_changed));
- _route->solo_safe_changed.connect (mem_fun(*this, &RouteUI::solo_changed));
+ /* no, there is no memory leak here. This object cleans itself (and other stuff)
+ up when the route is destroyed.
+ */
+ new PairedShiva<Route,RouteUI> (*_route, *this);
+
+ mute_button->set_controllable (_route->mute_control());
+ mute_button->set_label (m_name);
+
+ solo_button->set_controllable (_route->solo_control());
+ solo_button->set_label (s_name);
+
+ connections.push_back (_route->active_changed.connect (mem_fun (*this, &RouteUI::route_active_changed)));
+ connections.push_back (_route->mute_changed.connect (mem_fun(*this, &RouteUI::mute_changed)));
+ connections.push_back (_route->solo_changed.connect (mem_fun(*this, &RouteUI::solo_changed)));
+ connections.push_back (_route->solo_safe_changed.connect (mem_fun(*this, &RouteUI::solo_changed)));
+
/* when solo changes, update mute state too, in case the user wants us to display it */
_session.SoloChanged.connect (mem_fun(*this, &RouteUI::solo_changed_so_update_mute));
if (is_track()) {
boost::shared_ptr<Track> t = boost::dynamic_pointer_cast<Track>(_route);
- t->diskstream()->RecordEnableChanged.connect (mem_fun (*this, &RouteUI::route_rec_enable_changed));
-
- _session.RecordStateChanged.connect (mem_fun (*this, &RouteUI::session_rec_enable_changed));
+ connections.push_back (t->diskstream()->RecordEnableChanged.connect (mem_fun (*this, &RouteUI::route_rec_enable_changed)));
+ connections.push_back (_session.RecordStateChanged.connect (mem_fun (*this, &RouteUI::session_rec_enable_changed)));
- rec_enable_button = manage (new BindableToggleButton (t->rec_enable_control(), r_name ));
- rec_enable_button->set_name ("RecordEnableButton");
- rec_enable_button->set_self_managed (true);
-
rec_enable_button->show();
+ rec_enable_button->set_controllable (t->rec_enable_control());
+ rec_enable_button->set_label (r_name);
+
update_rec_display ();
}
mute_button->show();
solo_button->show();
- _route->RemoteControlIDChanged.connect (mem_fun(*this, &RouteUI::refresh_remote_control_menu));
+ connections.push_back (_route->RemoteControlIDChanged.connect (mem_fun(*this, &RouteUI::refresh_remote_control_menu)));
/* map the current state */
map_frozen ();
}
-RouteUI::~RouteUI()
-{
- GoingAway (); /* EMIT SIGNAL */
- delete mute_menu;
-}
-
bool
RouteUI::mute_press(GdkEventButton* ev)
{
class RouteUI : public virtual AxisView
{
public:
+ RouteUI(ARDOUR::Session&, const char*, const char*, const char*);
RouteUI(boost::shared_ptr<ARDOUR::Route>, ARDOUR::Session&, const char*, const char*, const char*);
+
virtual ~RouteUI();
+ virtual void set_route (boost::shared_ptr<ARDOUR::Route>);
+ void set_button_names (const char*, const char*, const char*);
+
bool is_track() const;
bool is_audio_track() const;
bool is_midi_track() const;
void reversibly_apply_track_boolean (string name, void (ARDOUR::Track::*func)(bool, void*), bool, void *);
void adjust_latency ();
+
+ protected:
+ std::vector<sigc::connection> connections;
+ std::string s_name;
+ std::string m_name;
+ std::string r_name;
+
+ void init ();
+ void reset ();
};
#endif /* __ardour_route_ui__ */
using namespace PBD;
SendUI::SendUI (boost::shared_ptr<Send> s, Session& se)
- : _send (s),
- _session (se),
- gpm (s->io(), se),
- panners (s->io(), se)
+ : _send (s)
+ , _session (se)
+ , gpm (se)
+ , panners (se)
{
+ panners.set_io (s->io());
+ gpm.set_io (s->io());
+
hbox.pack_start (gpm, true, true);
set_name ("SendUIFrame");
delete gm;
}
- gm = new GainMeter (session->the_auditioner(), *session);
+ gm = new GainMeter (*session);
+ gm->set_io (session->the_auditioner());
meter_packer.set_border_width (12);
meter_packer.pack_start (*gm, false, true);
void
PluginManager::ladspa_refresh ()
{
- _ladspa_plugin_info.clear ();
-
- if (ladspa_path.length() == 0) {
- ladspa_path = "/usr/local/lib64/ladspa:/usr/local/lib/ladspa:/usr/lib64/ladspa:/usr/lib/ladspa:/Library/Audio/Plug-Ins/LADSPA";
- }
-
+ _ladspa_plugin_info.clear ();
+
+ static const char *standard_paths[] = {
+ "/usr/local/lib64/ladspa",
+ "/usr/local/lib/ladspa",
+ "/usr/lib64/ladspa",
+ "/usr/lib/ladspa",
+ "/Library/Audio/Plug-Ins/LADSPA",
+ ""
+ };
+
+ /* allow LADSPA_PATH to augment, not override standard locations */
+
+ /* Only add standard locations to ladspa_path if it doesn't
+ * already contain them. Check for trailing '/'s too.
+ */
+
+ int i;
+ for (i = 0; standard_paths[i][0]; i++) {
+ size_t found = ladspa_path.find(standard_paths[i]);
+ if (found != ladspa_path.npos) {
+ switch (ladspa_path[found + strlen(standard_paths[i])]) {
+ case ':' :
+ case '\0':
+ continue;
+ case '/' :
+ if (ladspa_path[found + strlen(standard_paths[i]) + 1] == ':' ||
+ ladspa_path[found + strlen(standard_paths[i]) + 1] == '\0') {
+ continue;
+ }
+ }
+ }
+ if (!ladspa_path.empty())
+ ladspa_path += ":";
+
+ ladspa_path += standard_paths[i];
+
+ }
+
ladspa_discover_from_path (ladspa_path);
}
{
}
+BindingProxy::BindingProxy ()
+ : prompter (0),
+ bind_button (2),
+ bind_statemask (Gdk::CONTROL_MASK)
+
+{
+}
+
BindingProxy::~BindingProxy ()
{
if (prompter) {
}
}
+void
+BindingProxy::set_controllable (boost::shared_ptr<Controllable> c)
+{
+ learning_finished ();
+ controllable = c;
+}
+
void
BindingProxy::set_bind_button_state (guint button, guint statemask)
{
bool
BindingProxy::button_press_handler (GdkEventButton *ev)
{
- if ((ev->state & bind_statemask) && ev->button == bind_button) {
+ if (controllable && (ev->state & bind_statemask) && ev->button == bind_button) {
if (Controllable::StartLearning (controllable.get())) {
string prompt = _("operate controller now");
if (prompter == 0) {
BindingProxy::prompter_hiding (GdkEventAny *ev)
{
learning_connection.disconnect ();
- Controllable::StopLearning (controllable.get());
+ if (controllable) {
+ Controllable::StopLearning (controllable.get());
+ }
return false;
}
/* export this to allow direct connection to button events */
Gtk::Widget& event_widget() { return darea; }
+
boost::shared_ptr<PBD::Controllable> get_controllable() { return binding_proxy.get_controllable(); }
+ void set_controllable(boost::shared_ptr<PBD::Controllable> c) { binding_proxy.set_controllable(c); }
protected:
Gtk::Adjustment& adjustment;
class BindableToggleButton : public Gtkmm2ext::StatefulToggleButton
{
public:
- BindableToggleButton (boost::shared_ptr<PBD::Controllable> c) : binding_proxy (c) {}
-
- explicit BindableToggleButton (boost::shared_ptr<PBD::Controllable> c, const std::string &label)
- : Gtkmm2ext::StatefulToggleButton (label), binding_proxy (c) {}
+ BindableToggleButton (const std::string &label)
+ : Gtkmm2ext::StatefulToggleButton (label) {}
virtual ~BindableToggleButton() {}
}
boost::shared_ptr<PBD::Controllable> get_controllable() { return binding_proxy.get_controllable(); }
-
+ void set_controllable (boost::shared_ptr<PBD::Controllable> c) { binding_proxy.set_controllable (c); }
+
private:
BindingProxy binding_proxy;
};
{
public:
BindableButton (boost::shared_ptr<PBD::Controllable> c) : binding_proxy (c) {}
-
- explicit BindableButton (boost::shared_ptr<PBD::Controllable> c, const std::string &label)
- : Gtkmm2ext::StatefulButton (label), binding_proxy (c) {}
-
~BindableButton() {}
bool on_button_press_event (GdkEventButton *ev) {
}
boost::shared_ptr<PBD::Controllable> get_controllable() { return binding_proxy.get_controllable(); }
+ void set_controllable (boost::shared_ptr<PBD::Controllable> c) { binding_proxy.set_controllable (c); }
private:
BindingProxy binding_proxy;
{
public:
BindingProxy (boost::shared_ptr<PBD::Controllable>);
+ BindingProxy ();
virtual ~BindingProxy();
void set_bind_button_state (guint button, guint statemask);
bool button_press_handler (GdkEventButton *);
boost::shared_ptr<PBD::Controllable> get_controllable() { return controllable; }
+ void set_controllable (boost::shared_ptr<PBD::Controllable>);
protected:
Gtkmm2ext::PopUp* prompter;
public:
SliderController (Glib::RefPtr<Gdk::Pixbuf> image,
Gtk::Adjustment* adj, int orientation,
- boost::shared_ptr<PBD::Controllable>,
bool with_numeric = true);
virtual ~SliderController () {}
bool on_button_press_event (GdkEventButton *ev);
+ void set_controllable (boost::shared_ptr<PBD::Controllable> c) { binding_proxy.set_controllable (c); }
+
protected:
BindingProxy binding_proxy;
Glib::RefPtr<Gdk::Pixbuf> slider;
Gtk::SpinButton spin;
Gtk::Frame spin_frame;
Gtk::HBox spin_hbox;
+
+ void init ();
};
class VSliderController : public SliderController
public:
VSliderController (Glib::RefPtr<Gdk::Pixbuf> image,
Gtk::Adjustment *adj,
- boost::shared_ptr<PBD::Controllable>,
bool with_numeric = true);
};
public:
HSliderController (Glib::RefPtr<Gdk::Pixbuf> image,
Gtk::Adjustment *adj,
- boost::shared_ptr<PBD::Controllable>,
bool with_numeric = true);
};
SliderController::SliderController (Glib::RefPtr<Gdk::Pixbuf> image,
Gtk::Adjustment *adj, int orientation,
- boost::shared_ptr<Controllable> c,
bool with_numeric)
: PixFader (image, *adj, orientation),
- binding_proxy (c),
spin (*adj, 0, 2)
{
spin.set_name ("SliderControllerValue");
if (binding_proxy.button_press_handler (ev)) {
return true;
}
+
return PixFader::on_button_press_event (ev);
}
VSliderController::VSliderController (Glib::RefPtr<Gdk::Pixbuf> image,
Gtk::Adjustment *adj,
- boost::shared_ptr<Controllable> control,
bool with_numeric)
- : SliderController (image, adj, VERT, control, with_numeric)
+ : SliderController (image, adj, VERT, with_numeric)
{
if (with_numeric) {
spin_frame.add (spin);
HSliderController::HSliderController (Glib::RefPtr<Gdk::Pixbuf> image,
Gtk::Adjustment *adj,
- boost::shared_ptr<Controllable> control,
bool with_numeric)
- : SliderController (image, adj, HORIZ, control, with_numeric)
+ : SliderController (image, adj, HORIZ, with_numeric)
{
if (with_numeric) {
spin_frame.add (spin);
projects / ardour.git / commitdiff