using namespace Gtk;
using namespace std;
using Gtkmm2ext::Keyboard;
-
-sigc::signal<void> GainMeterBase::ResetAllPeakDisplays;
-sigc::signal<void,RouteGroup*> GainMeterBase::ResetGroupPeakDisplays;
+using namespace ArdourMeter;
GainMeterBase::GainMeterBase (Session* s, bool horizontal, int fader_length, int fader_girth)
: gain_adjustment (gain_to_slider_position_with_max (1.0, Config->get_max_gain()), 0.0, 1.0, 0.01, 0.1)
gain_slider = manage (new VSliderController (&gain_adjustment, fader_length, fader_girth, false));
}
- level_meter = new LevelMeter(_session);
+ level_meter = new LevelMeterHBox(_session);
level_meter->ButtonPress.connect_same_thread (_level_meter_connection, boost::bind (&GainMeterBase::level_meter_button_press, this, _1));
meter_metric_area.signal_button_press_event().connect (sigc::mem_fun (*this, &GainMeterBase::level_meter_button_press));
gain_display.signal_key_press_event().connect (sigc::mem_fun(*this, &GainMeterBase::gain_key_press), false);
ResetAllPeakDisplays.connect (sigc::mem_fun(*this, &GainMeterBase::reset_peak_display));
+ ResetRoutePeakDisplays.connect (sigc::mem_fun(*this, &GainMeterBase::reset_route_peak_display));
ResetGroupPeakDisplays.connect (sigc::mem_fun(*this, &GainMeterBase::reset_group_peak_display));
+ RedrawMetrics.connect (sigc::mem_fun(*this, &GainMeterBase::redraw_metrics));
UI::instance()->theme_changed.connect (sigc::mem_fun(*this, &GainMeterBase::on_theme_changed));
ColorsChanged.connect (sigc::bind(sigc::mem_fun (*this, &GainMeterBase::color_handler), false));
void
GainMeter::hide_all_meters ()
{
- bool remove_metric_area = false;
-
GainMeterBase::hide_all_meters ();
-
- if (remove_metric_area) {
- if (meter_metric_area.get_parent()) {
- level_meter->remove (meter_metric_area);
- }
- }
}
void
GainMeterBase::setup_meters (int len)
{
int meter_width = 5;
- if (_width == Wide && _route && _route->shared_peak_meter()->input_streams().n_total() == 1) {
- meter_width = 10;
+
+ switch (_width) {
+ case Wide:
+ meter_ticks1_area.show();
+ meter_ticks2_area.show();
+ if (_route && _route->shared_peak_meter()->input_streams().n_total() == 1) {
+ meter_width = 10;
+ }
+ break;
+ case Narrow:
+ meter_width = 2;
+ meter_ticks1_area.hide();
+ meter_ticks2_area.hide();
+ break;
}
level_meter->setup_meters(len, meter_width);
}
+void
+GainMeterBase::set_type (MeterType t)
+{
+ level_meter->set_type(t);
+}
+
void
GainMeter::setup_meters (int len)
{
- if (!meter_metric_area.get_parent()) {
- level_meter->pack_end (meter_metric_area, false, false);
- meter_metric_area.show_all ();
+ switch (_width) {
+ case Wide:
+ hbox.set_homogeneous(true);
+ break;
+ case Narrow:
+ hbox.set_homogeneous(false);
+ break;
}
GainMeterBase::setup_meters (len);
}
+void
+GainMeter::set_type (MeterType t)
+{
+ GainMeterBase::set_type (t);
+}
+
bool
GainMeterBase::gain_key_press (GdkEventKey* ev)
{
ResetGroupPeakDisplays (_route->route_group());
}
} else {
- reset_peak_display ();
+ ResetRoutePeakDisplays (_route.get());
}
return true;
peak_display.set_name ("MixerStripPeakDisplay");
}
+void
+GainMeterBase::reset_route_peak_display (Route* route)
+{
+ if (_route && _route.get() == route) {
+ reset_peak_display ();
+ }
+}
+
void
GainMeterBase::reset_group_peak_display (RouteGroup* group)
{
void
GainMeterBase::set_meter_strip_name (const char * name)
{
+ char tmp[256];
meter_metric_area.set_name (name);
+ sprintf(tmp, "Mark%sLeft", name);
+ meter_ticks1_area.set_name (tmp);
+ sprintf(tmp, "Mark%sRight", name);
+ meter_ticks2_area.set_name (tmp);
}
void
snprintf (buf, sizeof(buf), "%.1f", mpeak);
peak_display.set_label (buf);
}
-
- if (mpeak >= 0.0f) {
- peak_display.set_name ("MixerStripPeakDisplayPeak");
- }
+ }
+ if (mpeak >= Config->get_meter_peak()) {
+ peak_display.set_name ("MixerStripPeakDisplayPeak");
}
}
void GainMeterBase::color_handler(bool dpi)
{
- meter_clear_pattern_cache();
setup_meters();
- meter_metric_area.queue_draw ();
}
void
void
GainMeterBase::on_theme_changed()
{
- meter_clear_pattern_cache();
+}
+
+void
+GainMeterBase::redraw_metrics()
+{
meter_metric_area.queue_draw ();
+ meter_ticks1_area.queue_draw ();
+ meter_ticks2_area.queue_draw ();
}
GainMeter::GainMeter (Session* s, int fader_length)
gain_display_box.pack_start (gain_display, true, true);
meter_metric_area.set_name ("AudioTrackMetrics");
- set_size_request_to_display_given_text (meter_metric_area, "-8888", 1, 0);
+ meter_metric_area.set_size_request(24, -1);
gain_automation_style_button.set_name ("mixer strip button");
gain_automation_state_button.set_name ("mixer strip button");
meter_metric_area.signal_expose_event().connect (
sigc::mem_fun(*this, &GainMeter::meter_metrics_expose));
+
+ meter_ticks1_area.set_size_request(3,-1);
+ meter_ticks2_area.set_size_request(3,-1);
+
+ meter_ticks1_area.signal_expose_event().connect (
+ sigc::mem_fun(*this, &GainMeter::meter_ticks1_expose));
+ meter_ticks2_area.signal_expose_event().connect (
+ sigc::mem_fun(*this, &GainMeter::meter_ticks2_expose));
+
+ meter_hbox.pack_start (meter_ticks1_area, false, false);
+ meter_hbox.pack_start (meter_alignment, false, false);
+ meter_hbox.pack_start (meter_ticks2_area, false, false);
+ meter_hbox.pack_start (meter_metric_area, false, false);
}
+GainMeter::~GainMeter () { }
+
void
GainMeter::set_controls (boost::shared_ptr<Route> r,
boost::shared_ptr<PeakMeter> meter,
boost::shared_ptr<Amp> amp)
{
- if (meter_alignment.get_parent()) {
- hbox.remove (meter_alignment);
+ if (meter_hbox.get_parent()) {
+ hbox.remove (meter_hbox);
}
// if (gain_automation_state_button.get_parent()) {
_meter->ConfigurationChanged.connect (
model_connections, invalidator (*this), boost::bind (&GainMeter::meter_configuration_changed, this, _1), gui_context()
);
+ _meter->TypeChanged.connect (
+ model_connections, invalidator (*this), boost::bind (&GainMeter::meter_type_changed, this, _1), gui_context()
+ );
meter_configuration_changed (_meter->input_streams ());
}
+ if (_route) {
+ _route->active_changed.connect (model_connections, invalidator (*this), boost::bind (&GainMeter::route_active_changed, this), gui_context ());
+ }
+
/*
if we have a non-hidden route (ie. we're not the click or the auditioner),
pack some route-dependent stuff.
*/
- hbox.pack_start (meter_alignment, true, true);
+ hbox.pack_start (meter_hbox, true, true);
// if (r && !r->is_auditioner()) {
// fader_vbox->pack_start (gain_automation_state_button, false, false, 0);
// }
- setup_meters ();
hbox.show_all ();
+ setup_meters ();
}
int
GainMeter::get_gm_width ()
{
Gtk::Requisition sz;
- hbox.size_request (sz);
- return sz.width;
+ int min_w = 0;
+ meter_metric_area.size_request (sz);
+ min_w += sz.width;
+ level_meter->size_request (sz);
+ min_w += sz.width;
+
+ fader_alignment.size_request (sz);
+ if (_width == Wide)
+ return max(sz.width * 2, min_w * 2) + 6;
+ else
+ return sz.width + min_w + 6;
+
}
gint
GainMeter::meter_metrics_expose (GdkEventExpose *ev)
{
- return meter_expose_metrics(ev, _types, &meter_metric_area);
+ if (!_route) {
+ if (_types.empty()) { _types.push_back(DataType::AUDIO); }
+ return meter_expose_metrics(ev, MeterPeak, _types, &meter_metric_area);
+ }
+ return meter_expose_metrics(ev, _route->meter_type(), _types, &meter_metric_area);
+}
+
+gint
+GainMeter::meter_ticks1_expose (GdkEventExpose *ev)
+{
+ if (!_route) {
+ if (_types.empty()) { _types.push_back(DataType::AUDIO); }
+ return meter_expose_ticks(ev, MeterPeak, _types, &meter_ticks1_area);
+ }
+ return meter_expose_ticks(ev, _route->meter_type(), _types, &meter_ticks1_area);
+}
+
+gint
+GainMeter::meter_ticks2_expose (GdkEventExpose *ev)
+{
+ if (!_route) {
+ if (_types.empty()) { _types.push_back(DataType::AUDIO); }
+ return meter_expose_ticks(ev, MeterPeak, _types, &meter_ticks2_area);
+ }
+ return meter_expose_ticks(ev, _route->meter_type(), _types, &meter_ticks2_area);
}
boost::shared_ptr<PBD::Controllable>
set_meter_strip_name ("AudioBusMetricsInactive");
}
}
- else if (type == (1 << DataType::AUDIO)) {
+ else if (
+ (type == (1 << DataType::MIDI))
+ || (_route && boost::dynamic_pointer_cast<MidiTrack>(_route))
+ ) {
if (!_route || _route->active()) {
- set_meter_strip_name ("AudioTrackMetrics");
+ set_meter_strip_name ("MidiTrackMetrics");
} else {
- set_meter_strip_name ("AudioTrackMetricsInactive");
+ set_meter_strip_name ("MidiTrackMetricsInactive");
}
}
- else if (type == (1 << DataType::MIDI)) {
+ else if (type == (1 << DataType::AUDIO)) {
if (!_route || _route->active()) {
- set_meter_strip_name ("MidiTrackMetrics");
+ set_meter_strip_name ("AudioTrackMetrics");
} else {
- set_meter_strip_name ("MidiTrackMetricsInactive");
+ set_meter_strip_name ("AudioTrackMetricsInactive");
}
} else {
if (!_route || _route->active()) {
}
}
- meter_clear_pattern_cache();
- meter_metric_area.queue_draw ();
+ setup_meters();
+ meter_clear_pattern_cache(4);
}
+void
+GainMeter::route_active_changed ()
+{
+ if (_meter) {
+ meter_configuration_changed (_meter->input_streams ());
+ }
+}
+
+void
+GainMeter::meter_type_changed (MeterType t)
+{
+ _route->set_meter_type(t);
+ RedrawMetrics();
+}
projects / ardour.git / blobdiff