1 files changed, 295 insertions, 253 deletions

diff --git a/gtk2_ardour/gain_meter.cc b/gtk2_ardour/gain_meter.cc
index 0e51b7a68c..107b0eedfc 100644
--- a/gtk2_ardour/gain_meter.cc
+++ b/gtk2_ardour/gain_meter.cc
@@ -57,42 +57,49 @@ using namespace Gtk;
 using namespace sigc;
 using namespace std;
 
-sigc::signal<void> GainMeter::ResetAllPeakDisplays;
-sigc::signal<void,RouteGroup*> GainMeter::ResetGroupPeakDisplays;
-Glib::RefPtr<Gdk::Pixbuf> GainMeter::slider;
-Glib::RefPtr<Gdk::Pixbuf> GainMeter::rail;
+sigc::signal<void> GainMeterBase::ResetAllPeakDisplays;
+sigc::signal<void,RouteGroup*> GainMeterBase::ResetGroupPeakDisplays;
+
 map<string,Glib::RefPtr<Gdk::Pixmap> > GainMeter::metric_pixmaps;
+Glib::RefPtr<Gdk::Pixbuf> GainMeter::slider;
 
-int
+
+void
 GainMeter::setup_slider_pix ()
 {
-	slider = ::get_icon ("fader_belt");
-	return 0;
+	if ((slider = ::get_icon ("fader_belt")) == 0) {
+		throw failed_constructor();
+	}
 }
 
-GainMeter::GainMeter (boost::shared_ptr<IO> io, Session& s)
+GainMeterBase::GainMeterBase (boost::shared_ptr<IO> io, Session& s, 
+			      const Glib::RefPtr<Gdk::Pixbuf>& pix,
+			      bool horizontal)
 	: _io (io),
 	  _session (s),
-	  gain_slider (0),
 	  // 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 ("")
 	
 {
-	if (slider == 0) {
-		setup_slider_pix ();
-	}
-
 	ignore_toggle = false;
 	meter_menu = 0;
 	next_release_selects = false;
 	style_changed = true;
+	_width = Wide;
 
-	gain_slider = manage (new VSliderController (slider,
-						     &gain_adjustment,
-						     *_io->gain_control().get(),
-						     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);
 
@@ -107,11 +114,6 @@ GainMeter::GainMeter (boost::shared_ptr<IO> io, Session& s)
 	gain_display.signal_focus_in_event().connect (mem_fun (*this, &GainMeter::gain_focused), false);
 	gain_display.signal_focus_out_event().connect (mem_fun (*this, &GainMeter::gain_focused), false);
 
-	gain_display_box.set_name ("MeterMetricsStrip");
-	gain_display_box.set_homogeneous (true);
-	gain_display_box.set_spacing (2);
-	gain_display_box.pack_start (gain_display, true, true);
-
 	peak_display.set_name ("MixerStripPeakDisplay");
 //	peak_display.set_has_frame (false);
 //	peak_display.set_editable (false);
@@ -120,9 +122,6 @@ GainMeter::GainMeter (boost::shared_ptr<IO> io, Session& s)
 	peak_display.set_label (_("-inf"));
 	peak_display.unset_flags (Gtk::CAN_FOCUS);
 
-	meter_metric_area.set_name ("MeterMetricsStrip");
-	set_size_request_to_display_given_text (meter_metric_area, "-50", 0, 0);
-
 	gain_automation_style_button.set_name ("MixerAutomationModeButton");
 	gain_automation_state_button.set_name ("MixerAutomationPlaybackButton");
 
@@ -135,193 +134,67 @@ GainMeter::GainMeter (boost::shared_ptr<IO> io, Session& s)
 	gain_automation_state_button.set_size_request(15, 15);
 	gain_automation_style_button.set_size_request(15, 15);
 
-	HBox* fader_centering_box = manage (new HBox);
-	fader_centering_box->pack_start (*gain_slider, true, false);
-
-	fader_vbox = manage (new Gtk::VBox());
-	fader_vbox->set_spacing (0);
-	fader_vbox->pack_start (*fader_centering_box, false, false, 0);
 
-	hbox.set_spacing (2);
 
-	if (_io->default_type() == ARDOUR::DataType::AUDIO) {
-		hbox.pack_start (*fader_vbox, true, true);
-	}
-	
-	set_width (Narrow);
 
-	Route* r;
 
-	if ((r = dynamic_cast<Route*> (_io.get())) != 0) {
+	boost::shared_ptr<Route> r;
 
-		/* 
-		   if we have a non-hidden route (ie. we're not the click or the auditioner), 
-		   pack some route-dependent stuff.
-		*/
+	if ((r = boost::dynamic_pointer_cast<Route> (_io)) != 0) {
 
-		gain_display_box.pack_end (peak_display, true, true);
-		hbox.pack_end (*level_meter, true, true);
+		if (!r->is_hidden()) {
 
-		using namespace Menu_Helpers;
-	
-		gain_astate_menu.items().push_back (MenuElem (_("Manual"), 
-						      bind (mem_fun (*_io, &IO::set_parameter_automation_state),
-								  Parameter(GainAutomation), (AutoState) Off)));
-		gain_astate_menu.items().push_back (MenuElem (_("Play"),
-						      bind (mem_fun (*_io, &IO::set_parameter_automation_state),
-								  Parameter(GainAutomation), (AutoState) Play)));
-		gain_astate_menu.items().push_back (MenuElem (_("Write"),
-						      bind (mem_fun (*_io, &IO::set_parameter_automation_state),
-								  Parameter(GainAutomation), (AutoState) Write)));
-		gain_astate_menu.items().push_back (MenuElem (_("Touch"),
-						      bind (mem_fun (*_io, &IO::set_parameter_automation_state),
-								  Parameter(GainAutomation), (AutoState) Touch)));
-	
-		gain_astyle_menu.items().push_back (MenuElem (_("Trim")));
-		gain_astyle_menu.items().push_back (MenuElem (_("Abs")));
+			using namespace Menu_Helpers;
 	
-		gain_astate_menu.set_name ("ArdourContextMenu");
-		gain_astyle_menu.set_name ("ArdourContextMenu");
-
-		gain_automation_style_button.signal_button_press_event().connect (mem_fun(*this, &GainMeter::gain_automation_style_button_event), false);
-		gain_automation_state_button.signal_button_press_event().connect (mem_fun(*this, &GainMeter::gain_automation_state_button_event), false);
-		
-		r->gain_control()->list()->automation_state_changed.connect (mem_fun(*this, &GainMeter::gain_automation_state_changed));
-		r->gain_control()->list()->automation_style_changed.connect (mem_fun(*this, &GainMeter::gain_automation_style_changed));
-		fader_vbox->pack_start (gain_automation_state_button, false, false, 0);
+			gain_astate_menu.items().push_back (MenuElem (_("Manual"), 
+								      bind (mem_fun (*_io, &IO::set_parameter_automation_state),
+									    Parameter(GainAutomation), (AutoState) Off)));
+			gain_astate_menu.items().push_back (MenuElem (_("Play"),
+								      bind (mem_fun (*_io, &IO::set_parameter_automation_state),
+									    Parameter(GainAutomation), (AutoState) Play)));
+			gain_astate_menu.items().push_back (MenuElem (_("Write"),
+								      bind (mem_fun (*_io, &IO::set_parameter_automation_state),
+									    Parameter(GainAutomation), (AutoState) Write)));
+			gain_astate_menu.items().push_back (MenuElem (_("Touch"),
+								      bind (mem_fun (*_io, &IO::set_parameter_automation_state),
+									    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");
+			
+			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()->list()->automation_state_changed.connect (mem_fun(*this, &GainMeter::gain_automation_state_changed));
+			r->gain_control()->list()->automation_style_changed.connect (mem_fun(*this, &GainMeter::gain_automation_style_changed));
 
-		gain_automation_state_changed ();
+			gain_automation_state_changed ();
+		}
 	}
 
-	set_spacing (2);
-
-	pack_start (gain_display_box, Gtk::PACK_SHRINK);
-	pack_start (hbox, Gtk::PACK_SHRINK);
-
-	_io->gain_control()->Changed.connect (mem_fun(*this, &GainMeter::gain_changed));
+	_io->gain_control()->Changed.connect (mem_fun(*this, &GainMeterBase::gain_changed));
 
-	meter_metric_area.signal_expose_event().connect (mem_fun(*this, &GainMeter::meter_metrics_expose));
-	gain_adjustment.signal_value_changed().connect (mem_fun(*this, &GainMeter::gain_adjusted));
-	peak_display.signal_button_release_event().connect (mem_fun(*this, &GainMeter::peak_button_release), false);
-	gain_display.signal_key_press_event().connect (mem_fun(*this, &GainMeter::gain_key_press), false);
+	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);
 
 	gain_changed ();
 	show_gain ();
 
 	update_gain_sensitive ();
 	
-	ResetAllPeakDisplays.connect (mem_fun(*this, &GainMeter::reset_peak_display));
-	ResetGroupPeakDisplays.connect (mem_fun(*this, &GainMeter::reset_group_peak_display));
-
-	UI::instance()->theme_changed.connect (mem_fun(*this, &GainMeter::on_theme_changed));
-
-	ColorsChanged.connect (bind (mem_fun (*this, &GainMeter::color_handler), false));
-	DPIReset.connect (bind (mem_fun (*this, &GainMeter::color_handler), true));
+	ResetAllPeakDisplays.connect (mem_fun(*this, &GainMeterBase::reset_peak_display));
+	ResetGroupPeakDisplays.connect (mem_fun(*this, &GainMeterBase::reset_group_peak_display));
 
-	//hide_all();
+	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));
 }
 
-void
-GainMeter::set_width (Width w, int len)
-{
-	_width = w;
-	level_meter->setup_meters (len);
-}
-
-Glib::RefPtr<Gdk::Pixmap>
-GainMeter::render_metrics (Gtk::Widget& w)
-{
-	//cerr << "GainMeter::render_metrics() called, red = " << w.get_style()->get_bg(Gtk::STATE_NORMAL).get_red() << endl;//DEBUG
-	Glib::RefPtr<Gdk::Window> win (w.get_window());
-	Glib::RefPtr<Gdk::GC> fg_gc (w.get_style()->get_fg_gc (Gtk::STATE_NORMAL));
-	Glib::RefPtr<Gdk::GC> bg_gc (w.get_style()->get_bg_gc (Gtk::STATE_NORMAL));
-	gint width, height;
-	int  db_points[] = { -50, -40, -20, -30, -10, -3, 0, 4 };
-	char buf[32];
-
-	win->get_size (width, height);
-	
-	Glib::RefPtr<Gdk::Pixmap> pixmap = Gdk::Pixmap::create (win, width, height);
-
-	metric_pixmaps[w.get_name()] = pixmap;
-
-	pixmap->draw_rectangle (bg_gc, true, 0, 0, width, height);
-
-	Glib::RefPtr<Pango::Layout> layout = w.create_pango_layout("");
-
-	for (uint32_t i = 0; i < sizeof (db_points)/sizeof (db_points[0]); ++i) {
-
-		float fraction = log_meter (db_points[i]);
-		gint pos = height - (gint) floor (height * fraction);
-
-		snprintf (buf, sizeof (buf), "%d", abs (db_points[i]));
-
-		layout->set_text (buf);
-
-		/* we want logical extents, not ink extents here */
-
-		int width, height;
-		layout->get_pixel_size (width, height);
-
-		pixmap->draw_line (fg_gc, 0, pos, 4, pos);
-		pixmap->draw_layout (fg_gc, 6, pos - (height/2), layout);
-	}
-
-	return pixmap;
-}
-
-gint
-GainMeter::meter_metrics_expose (GdkEventExpose *ev)
-{
-	/* Only draw dB scale if we're metering audio */
-	if (_io->n_inputs().n_audio() + _io->n_outputs().n_audio() == 0)
-		return true;
-
-	static Glib::RefPtr<Gtk::Style> meter_style;
-	
-	if (style_changed) {
-		meter_style = meter_metric_area.get_style();
-	}
-		
-	Glib::RefPtr<Gdk::Window> win (meter_metric_area.get_window());
-	Glib::RefPtr<Gdk::GC> fg_gc (meter_style->get_fg_gc (Gtk::STATE_NORMAL));
-	Glib::RefPtr<Gdk::GC> bg_gc (meter_style->get_bg_gc (Gtk::STATE_NORMAL));
-
-	GdkRectangle base_rect;
-	GdkRectangle draw_rect;
-	gint width, height;
-
-	win->get_size (width, height);
-	
-	base_rect.width = width;
-	base_rect.height = height;
-	base_rect.x = 0;
-	base_rect.y = 0;
-
-	Glib::RefPtr<Gdk::Pixmap> pixmap;
-	std::map<string,Glib::RefPtr<Gdk::Pixmap> >::iterator i = metric_pixmaps.find (meter_metric_area.get_name());
-
-	if (i == metric_pixmaps.end() || style_changed || dpi_changed) {
-		pixmap = render_metrics (meter_metric_area);
-	} else {
-		pixmap = i->second;
-	}
-
-	gdk_rectangle_intersect (&ev->area, &base_rect, &draw_rect);
-	win->draw_rectangle (bg_gc, false, draw_rect.x, draw_rect.y, draw_rect.width, draw_rect.height);
-	win->draw_drawable (fg_gc, pixmap, draw_rect.x, draw_rect.y, draw_rect.x, draw_rect.y, draw_rect.width, draw_rect.height);
-	
-	style_changed = false;
-	return true;
-}
-
-void
-GainMeter::on_theme_changed()
-{
-	style_changed = true;
-}
-
-GainMeter::~GainMeter ()
+GainMeterBase::~GainMeterBase ()
 {
 	if (meter_menu) {
 		delete meter_menu;
@@ -333,11 +206,17 @@ GainMeter::~GainMeter ()
 }
 
 void
+GainMeterBase::hide_all_meters ()
+{
+	level_meter->hide_meters();
+}
+
+void
 GainMeter::hide_all_meters ()
 {
 	bool remove_metric_area = false;
 
-	level_meter->hide_meters();
+	GainMeterBase::hide_all_meters ();
 
 	if (remove_metric_area) {
 		if (meter_metric_area.get_parent()) {
@@ -347,24 +226,23 @@ GainMeter::hide_all_meters ()
 }
 
 void
+GainMeterBase::setup_meters (int len)
+{
+	level_meter->setup_meters(len, 5);
+}
+
+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 ();
 	}
-	level_meter->setup_meters(len, 5);
-}
-
-int
-GainMeter::get_gm_width ()
-{
-	Gtk::Requisition sz = hbox.size_request ();
-	return sz.width;
+	GainMeterBase::setup_meters (len);
 }
 
 bool
-GainMeter::gain_key_press (GdkEventKey* ev)
+GainMeterBase::gain_key_press (GdkEventKey* ev)
 {
 	if (key_is_legal_for_numeric_entry (ev->keyval)) {
 		/* drop through to normal handling */
@@ -375,15 +253,16 @@ GainMeter::gain_key_press (GdkEventKey* ev)
 }
 
 bool
-GainMeter::peak_button_release (GdkEventButton* ev)
+GainMeterBase::peak_button_release (GdkEventButton* ev)
 {
 	/* reset peak label */
 
 	if (ev->button == 1 && Keyboard::modifier_state_equals (ev->state, Keyboard::PrimaryModifier|Keyboard::TertiaryModifier)) {
 		ResetAllPeakDisplays ();
 	} else if (ev->button == 1 && Keyboard::modifier_state_equals (ev->state, Keyboard::PrimaryModifier)) {
-		Route* r;
-		if ((r = dynamic_cast<Route*> (_io.get())) != 0) {
+		boost::shared_ptr<Route> r;
+
+		if ((r = boost::dynamic_pointer_cast<Route> (_io)) != 0) {
 			ResetGroupPeakDisplays (r->mix_group());
 		}
 	} else {
@@ -394,10 +273,11 @@ GainMeter::peak_button_release (GdkEventButton* ev)
 }
 
 void
-GainMeter::reset_peak_display ()
+GainMeterBase::reset_peak_display ()
 {
-	Route * r;
-	if ((r = dynamic_cast<Route*> (_io.get())) != 0) {
+	boost::shared_ptr<Route> r;
+
+	if ((r = boost::dynamic_pointer_cast<Route> (_io)) != 0) {
 		r->peak_meter().reset_max();
 	}
 
@@ -408,10 +288,11 @@ GainMeter::reset_peak_display ()
 }
 
 void
-GainMeter::reset_group_peak_display (RouteGroup* group)
+GainMeterBase::reset_group_peak_display (RouteGroup* group)
 {
-	Route* r;
-	if ((r = dynamic_cast<Route*> (_io.get())) != 0) {
+	boost::shared_ptr<Route> r;
+	
+	if ((r = boost::dynamic_pointer_cast<Route> (_io)) != 0) {
 		if (group == r->mix_group()) {
 			reset_peak_display ();
 		}
@@ -419,7 +300,7 @@ GainMeter::reset_group_peak_display (RouteGroup* group)
 }
 
 void
-GainMeter::popup_meter_menu (GdkEventButton *ev)
+GainMeterBase::popup_meter_menu (GdkEventButton *ev)
 {
 	using namespace Menu_Helpers;
 
@@ -440,7 +321,7 @@ GainMeter::popup_meter_menu (GdkEventButton *ev)
 }
 
 bool
-GainMeter::gain_focused (GdkEventFocus* ev)
+GainMeterBase::gain_focused (GdkEventFocus* ev)
 {
 	if (ev->in) {
 		gain_display.select_region (0, -1);
@@ -451,7 +332,7 @@ GainMeter::gain_focused (GdkEventFocus* ev)
 }
 
 void
-GainMeter::gain_activated ()
+GainMeterBase::gain_activated ()
 {
 	float f;
 
@@ -470,7 +351,7 @@ GainMeter::gain_activated ()
 }
 
 void
-GainMeter::show_gain ()
+GainMeterBase::show_gain ()
 {
 	char buf[32];
 
@@ -486,7 +367,7 @@ GainMeter::show_gain ()
 }
 
 void
-GainMeter::gain_adjusted ()
+GainMeterBase::gain_adjusted ()
 {
 	if (!ignore_toggle) {
 		_io->gain_control()->set_value (slider_position_to_gain (gain_adjustment.get_value()));
@@ -495,7 +376,7 @@ GainMeter::gain_adjusted ()
 }
 
 void
-GainMeter::effective_gain_display ()
+GainMeterBase::effective_gain_display ()
 {
 	gfloat value = gain_to_slider_position (_io->effective_gain());
 	
@@ -507,25 +388,25 @@ GainMeter::effective_gain_display ()
 }
 
 void
-GainMeter::gain_changed ()
+GainMeterBase::gain_changed ()
 {
-	Gtkmm2ext::UI::instance()->call_slot (mem_fun(*this, &GainMeter::effective_gain_display));
+	Gtkmm2ext::UI::instance()->call_slot (mem_fun(*this, &GainMeterBase::effective_gain_display));
 }
 
 void
-GainMeter::set_meter_strip_name (const char * name)
+GainMeterBase::set_meter_strip_name (const char * name)
 {
 	meter_metric_area.set_name (name);
 }
 
 void
-GainMeter::set_fader_name (const char * name)
+GainMeterBase::set_fader_name (const char * name)
 {
 	gain_slider->set_name (name);
 }
 
 void
-GainMeter::update_gain_sensitive ()
+GainMeterBase::update_gain_sensitive ()
 {
 	static_cast<Gtkmm2ext::SliderController*>(gain_slider)->set_sensitive (!(_io->gain_control()->list()->automation_state() & Play));
 }
@@ -552,13 +433,13 @@ next_meter_point (MeterPoint mp)
 }
 
 gint
-GainMeter::meter_press(GdkEventButton* ev)
+GainMeterBase::meter_press(GdkEventButton* ev)
 {
-	Route* _route;
+	boost::shared_ptr<Route> _route;
 
 	wait_for_release = false;
-
-	if ((_route = dynamic_cast<Route*>(_io.get())) == 0) {
+	
+	if ((_route = boost::dynamic_pointer_cast<Route>(_io)) == 0) {
 		return FALSE;
 	}
 
@@ -589,7 +470,7 @@ GainMeter::meter_press(GdkEventButton* ev)
 
 					_session.begin_reversible_command (_("meter point change"));
                                         Session::GlobalMeteringStateCommand *cmd = new Session::GlobalMeteringStateCommand (_session, this);
-					_session.foreach_route (this, &GainMeter::set_meter_point, next_meter_point (_route->meter_point()));
+					_session.foreach_route (this, &GainMeterBase::set_meter_point, next_meter_point (_route->meter_point()));
                                         cmd->mark();
 					_session.add_command (cmd);
 					_session.commit_reversible_command ();
@@ -627,26 +508,31 @@ GainMeter::meter_press(GdkEventButton* ev)
 }
 
 gint
-GainMeter::meter_release(GdkEventButton* ev)
+GainMeterBase::meter_release(GdkEventButton* ev)
 {
-
 	if(!ignore_toggle){
 		if (wait_for_release){
 			wait_for_release = false;
-			set_meter_point (*(dynamic_cast<Route*>(_io.get())), old_meter_point);
+			
+			boost::shared_ptr<Route> r;
+			
+			if ((r = boost::dynamic_pointer_cast<Route>(_io)) != 0) {
+				set_meter_point (*r, old_meter_point);
+			}
 		}
 	}
+
 	return true;
 }
 
 void
-GainMeter::set_meter_point (Route& route, MeterPoint mp)
+GainMeterBase::set_meter_point (Route& route, MeterPoint mp)
 {
 	route.set_meter_point (mp, this);
 }
 
 void
-GainMeter::set_mix_group_meter_point (Route& route, MeterPoint mp)
+GainMeterBase::set_mix_group_meter_point (Route& route, MeterPoint mp)
 {
 	RouteGroup* mix_group;
 
@@ -658,31 +544,31 @@ GainMeter::set_mix_group_meter_point (Route& route, MeterPoint mp)
 }
 
 void
-GainMeter::meter_point_clicked ()
+GainMeterBase::meter_point_clicked ()
 {
-	Route* r;
-
-	if ((r = dynamic_cast<Route*> (_io.get())) != 0) {
+	boost::shared_ptr<Route> r;
 
+	if ((r = boost::dynamic_pointer_cast<Route> (_io)) != 0) {
+		/* WHAT? */
 	}
 }
 
 gint
-GainMeter::start_gain_touch (GdkEventButton* ev)
+GainMeterBase::start_gain_touch (GdkEventButton* ev)
 {
 	_io->gain_control()->list()->start_touch ();
 	return FALSE;
 }
 
 gint
-GainMeter::end_gain_touch (GdkEventButton* ev)
+GainMeterBase::end_gain_touch (GdkEventButton* ev)
 {
 	_io->gain_control()->list()->stop_touch ();
 	return FALSE;
 }
 
 gint
-GainMeter::gain_automation_state_button_event (GdkEventButton *ev)
+GainMeterBase::gain_automation_state_button_event (GdkEventButton *ev)
 {
 	if (ev->type == GDK_BUTTON_RELEASE) {
 		return TRUE;
@@ -700,7 +586,7 @@ GainMeter::gain_automation_state_button_event (GdkEventButton *ev)
 }
 
 gint
-GainMeter::gain_automation_style_button_event (GdkEventButton *ev)
+GainMeterBase::gain_automation_style_button_event (GdkEventButton *ev)
 {
 	if (ev->type == GDK_BUTTON_RELEASE) {
 		return TRUE;
@@ -717,19 +603,19 @@ GainMeter::gain_automation_style_button_event (GdkEventButton *ev)
 }
 
 string
-GainMeter::astate_string (AutoState state)
+GainMeterBase::astate_string (AutoState state)
 {
 	return _astate_string (state, false);
 }
 
 string
-GainMeter::short_astate_string (AutoState state)
+GainMeterBase::short_astate_string (AutoState state)
 {
 	return _astate_string (state, true);
 }
 
 string
-GainMeter::_astate_string (AutoState state, bool shrt)
+GainMeterBase::_astate_string (AutoState state, bool shrt)
 {
 	string sstr;
 
@@ -752,19 +638,19 @@ GainMeter::_astate_string (AutoState state, bool shrt)
 }
 
 string
-GainMeter::astyle_string (AutoStyle style)
+GainMeterBase::astyle_string (AutoStyle style)
 {
 	return _astyle_string (style, false);
 }
 
 string
-GainMeter::short_astyle_string (AutoStyle style)
+GainMeterBase::short_astyle_string (AutoStyle style)
 {
 	return _astyle_string (style, true);
 }
 
 string
-GainMeter::_astyle_string (AutoStyle style, bool shrt)
+GainMeterBase::_astyle_string (AutoStyle style, bool shrt)
 {
 	if (style & Trim) {
 		return _("Trim");
@@ -776,9 +662,8 @@ GainMeter::_astyle_string (AutoStyle style, bool shrt)
 }
 
 void
-GainMeter::gain_automation_style_changed ()
+GainMeterBase::gain_automation_style_changed ()
 {
-  // Route* _route = dynamic_cast<Route*>(&_io);
 	switch (_width) {
 	case Wide:
 	        gain_automation_style_button.set_label (astyle_string(_io->gain_control()->list()->automation_style()));
@@ -790,10 +675,9 @@ GainMeter::gain_automation_style_changed ()
 }
 
 void
-GainMeter::gain_automation_state_changed ()
+GainMeterBase::gain_automation_state_changed ()
 {
-	ENSURE_GUI_THREAD(mem_fun(*this, &GainMeter::gain_automation_state_changed));
-	//Route* _route = dynamic_cast<Route*>(&_io);
+	ENSURE_GUI_THREAD(mem_fun(*this, &GainMeterBase::gain_automation_state_changed));
 	
 	bool x;
 
@@ -821,12 +705,12 @@ GainMeter::gain_automation_state_changed ()
 	gain_watching.disconnect();
 
 	if (x) {
-		gain_watching = ARDOUR_UI::RapidScreenUpdate.connect (mem_fun (*this, &GainMeter::effective_gain_display));
+		gain_watching = ARDOUR_UI::RapidScreenUpdate.connect (mem_fun (*this, &GainMeterBase::effective_gain_display));
 	}
 }
 
 void
-GainMeter::update_meters()
+GainMeterBase::update_meters()
 {
 	char buf[32];
 	float mpeak = level_meter->update_meters();
@@ -846,9 +730,167 @@ GainMeter::update_meters()
 	}
 }
 
-void GainMeter::color_handler (bool dpi)
+void GainMeterBase::color_handler(bool dpi)
 {
 	color_changed = true;
 	dpi_changed = (dpi) ? true : false;
 	setup_meters();
 }
+
+void
+GainMeterBase::set_width (Width w, int len)
+{
+	_width = w;
+	level_meter->setup_meters (len);
+}
+
+
+void
+GainMeterBase::on_theme_changed()
+{
+	style_changed = true;
+}
+
+GainMeter::GainMeter (boost::shared_ptr<IO> io, Session& s)
+	: GainMeterBase (io, s, slider, false)
+{
+
+	gain_display_box.set_homogeneous (true);
+	gain_display_box.set_spacing (2);
+	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, "-50", 0, 0);
+
+	gain_automation_style_button.set_name ("MixerAutomationModeButton");
+	gain_automation_state_button.set_name ("MixerAutomationPlaybackButton");
+
+	ARDOUR_UI::instance()->tooltips().set_tip (gain_automation_state_button, _("Fader automation mode"));
+	ARDOUR_UI::instance()->tooltips().set_tip (gain_automation_style_button, _("Fader automation type"));
+
+	gain_automation_style_button.unset_flags (Gtk::CAN_FOCUS);
+	gain_automation_state_button.unset_flags (Gtk::CAN_FOCUS);
+
+	gain_automation_state_button.set_size_request(15, 15);
+	gain_automation_style_button.set_size_request(15, 15);
+
+	HBox* fader_centering_box = manage (new HBox);
+	fader_centering_box->pack_start (*gain_slider, true, false);
+
+	fader_vbox = manage (new Gtk::VBox());
+	fader_vbox->set_spacing (0);
+	fader_vbox->pack_start (*fader_centering_box, false, false, 0);
+
+	hbox.set_spacing (2);
+	hbox.pack_start (*fader_vbox, true, true);
+
+	boost::shared_ptr<Route> r;
+
+	if ((r = boost::dynamic_pointer_cast<Route> (_io)) != 0) {
+		
+		/* 
+		   if we have a non-hidden route (ie. we're not the click or the auditioner), 
+		   pack some route-dependent stuff.
+		*/
+
+		gain_display_box.pack_end (peak_display, true, true);
+		hbox.pack_end (*level_meter, true, true);
+
+		if (!r->is_hidden()) {
+			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 ()
+{
+	Gtk::Requisition sz;
+	hbox.size_request (sz);
+	return sz.width;
+}
+
+Glib::RefPtr<Gdk::Pixmap>
+GainMeter::render_metrics (Gtk::Widget& w)
+{
+	Glib::RefPtr<Gdk::Window> win (w.get_window());
+	Glib::RefPtr<Gdk::GC> fg_gc (w.get_style()->get_fg_gc (Gtk::STATE_NORMAL));
+	Glib::RefPtr<Gdk::GC> bg_gc (w.get_style()->get_bg_gc (Gtk::STATE_NORMAL));
+	gint width, height;
+	int  db_points[] = { -50, -40, -20, -30, -10, -3, 0, 4 };
+	char buf[32];
+
+	win->get_size (width, height);
+	
+	Glib::RefPtr<Gdk::Pixmap> pixmap = Gdk::Pixmap::create (win, width, height);
+
+	metric_pixmaps[w.get_name()] = pixmap;
+
+	pixmap->draw_rectangle (bg_gc, true, 0, 0, width, height);
+
+	Glib::RefPtr<Pango::Layout> layout = w.create_pango_layout("");
+
+	for (uint32_t i = 0; i < sizeof (db_points)/sizeof (db_points[0]); ++i) {
+
+		float fraction = log_meter (db_points[i]);
+		gint pos = height - (gint) floor (height * fraction);
+
+		snprintf (buf, sizeof (buf), "%d", abs (db_points[i]));
+
+		layout->set_text (buf);
+
+		/* we want logical extents, not ink extents here */
+
+		int width, height;
+		layout->get_pixel_size (width, height);
+
+		pixmap->draw_line (fg_gc, 0, pos, 4, pos);
+		pixmap->draw_layout (fg_gc, 6, pos - (height/2), layout);
+	}
+
+	return pixmap;
+}
+
+gint
+GainMeter::meter_metrics_expose (GdkEventExpose *ev)
+{
+	static Glib::RefPtr<Gtk::Style> meter_style;
+	if (style_changed) {
+		meter_style = meter_metric_area.get_style();
+	}
+	Glib::RefPtr<Gdk::Window> win (meter_metric_area.get_window());
+	Glib::RefPtr<Gdk::GC> bg_gc (meter_style->get_bg_gc (Gtk::STATE_INSENSITIVE));
+	GdkRectangle base_rect;
+	GdkRectangle draw_rect;
+	gint width, height;
+
+	win->get_size (width, height);
+	
+	base_rect.width = width;
+	base_rect.height = height;
+	base_rect.x = 0;
+	base_rect.y = 0;
+
+	Glib::RefPtr<Gdk::Pixmap> pixmap;
+	std::map<string,Glib::RefPtr<Gdk::Pixmap> >::iterator i = metric_pixmaps.find (meter_metric_area.get_name());
+
+	if (i == metric_pixmaps.end() || style_changed || dpi_changed) {
+		pixmap = render_metrics (meter_metric_area);
+	} else {
+		pixmap = i->second;
+	}
+
+	gdk_rectangle_intersect (&ev->area, &base_rect, &draw_rect);
+	win->draw_drawable (bg_gc, pixmap, draw_rect.x, draw_rect.y, draw_rect.x, draw_rect.y, draw_rect.width, draw_rect.height);
+	style_changed = false;
+	return true;
+}
+