refactor GainMeter so that it can used by RouteTimeAxisView, and thus bring automatio...

git-svn-id: svn://localhost/ardour2/branches/2.0-ongoing@3468 d708f5d6-7413-0410-9779-e7cbd77b26cf

diff --git a/gtk2_ardour/ardour_ui.cc b/gtk2_ardour/ardour_ui.cc
index 8c9a965826416272129538f94e7b24bc09b99d8b..2800c6803790e1732cd13613e233861f446e5ff5 100644 (file)
--- a/gtk2_ardour/ardour_ui.cc
+++ b/gtk2_ardour/ardour_ui.cc
@@ -82,6 +82,8 @@ typedef uint64_t microseconds_t;
 #include "gui_thread.h"
 #include "theme_manager.h"
 #include "engine_dialog.h"
+#include "gain_meter.h"
+#include "route_time_axis.h"
 
 #include "i18n.h"
 
@@ -237,6 +239,9 @@ ARDOUR_UI::ARDOUR_UI (int *argcp, char **argvp[])
                Config->set_current_owner (ConfigVariableBase::Interface);
                setup_profile ();
 
+               GainMeter::setup_slider_pix ();
+               RouteTimeAxisView::setup_slider_pix ();
+
        } catch (failed_constructor& err) {
                error << _("could not initialize Ardour.") << endmsg;
                // pass it on up

diff --git a/gtk2_ardour/editor.cc b/gtk2_ardour/editor.cc
index 14c7ec0301b4e6cee2ffac168a4c2e0cf61beaa9..a8d37f90226b32be7675e21be58fd0b4fac14513 100644 (file)
--- a/gtk2_ardour/editor.cc
+++ b/gtk2_ardour/editor.cc
@@ -4743,7 +4743,6 @@ Editor::on_expose_event (GdkEventExpose* ev)
                
                int xroot, yroot, discard;
                int controls_width;
-               int scrollbar_offset;
 
                /* Our root coordinates for drawing the line will be the left edge 
                   of the track controls, and the upper left edge of our own window.

diff --git a/gtk2_ardour/gain_meter.cc b/gtk2_ardour/gain_meter.cc
index e723dcffb4664e51f5dd518fc65796b4a44b1208..4b598a06f4ad1de744bcca34792136bd332e73f4 100644 (file)
--- a/gtk2_ardour/gain_meter.cc
+++ b/gtk2_ardour/gain_meter.cc
@@ -53,42 +53,48 @@ using namespace Gtk;
 using namespace sigc;
 using namespace std;
 
-sigc::signal<void> GainMeter::ResetAllPeakDisplays;
-sigc::signal<void,RouteGroup*> GainMeter::ResetGroupPeakDisplays;
+sigc::signal<void> GainMeterBase::ResetAllPeakDisplays;
+sigc::signal<void,RouteGroup*> GainMeterBase::ResetGroupPeakDisplays;
+map<string,Glib::RefPtr<Gdk::Pixmap> > GainMeterBase::metric_pixmaps;
+
 Glib::RefPtr<Gdk::Pixbuf> GainMeter::slider;
-Glib::RefPtr<Gdk::Pixbuf> GainMeter::rail;
-map<string,Glib::RefPtr<Gdk::Pixmap> > GainMeter::metric_pixmaps;
 
-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;
 
-       gain_slider = manage (new VSliderController (slider,
-                                                    &gain_adjustment,
-                                                    _io->gain_control(),
-                                                    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);
 
@@ -103,10 +109,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_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);
@@ -115,9 +117,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 ("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");
 
@@ -130,28 +129,10 @@ 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);
-       hbox.pack_start (*fader_vbox, true, true);
-
        Route* r;
 
        if ((r = dynamic_cast<Route*> (_io.get())) != 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->hidden()) {
 
                        using namespace Menu_Helpers;
@@ -171,143 +152,36 @@ GainMeter::GainMeter (boost::shared_ptr<IO> io, Session& s)
                        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);
+                       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_automation_curve().automation_state_changed.connect (mem_fun(*this, &GainMeter::gain_automation_state_changed));
-                       r->gain_automation_curve().automation_style_changed.connect (mem_fun(*this, &GainMeter::gain_automation_style_changed));
+                       r->gain_automation_curve().automation_state_changed.connect (mem_fun(*this, &GainMeterBase::gain_automation_state_changed));
+                       r->gain_automation_curve().automation_style_changed.connect (mem_fun(*this, &GainMeterBase::gain_automation_style_changed));
                        
-                       fader_vbox->pack_start (gain_automation_state_button, false, false, 0);
                        gain_automation_state_changed ();
                }
        }
 
-       set_spacing (2);
-
-       pack_start (gain_display_box, Gtk::PACK_SHRINK);
-       pack_start (hbox, Gtk::PACK_SHRINK);
+       _io->gain_changed.connect (mem_fun(*this, &GainMeterBase::gain_changed));
 
-       _io->gain_changed.connect (mem_fun(*this, &GainMeter::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 (0);
        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));
-       //hide_all();
-}
-
-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 << "name: " << w.get_name();//DEBUG
-       //cerr << " bg_red = " << w.get_style()->get_bg(Gtk::STATE_NORMAL).get_red();//DEBUG
-       //cerr << " fg_red = " << w.get_style()->get_fg(Gtk::STATE_NORMAL).get_red();//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)
-{
-       static Glib::RefPtr<Gtk::Style> meter_style;
-       //cerr << "GainMeter::meter_metrics_expose() called on " << meter_metric_area.get_name();//DEBUG
-       //cerr << " style_changed = " << style_changed;//DEBUG
-       if (style_changed) {
-               meter_style = meter_metric_area.get_style();
-       //      cerr << " get_style() called ";//DEBUG
-       }
-       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_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;
-       //      cerr << " re-used " << i->first;//DEBUG
-       }
+       ResetAllPeakDisplays.connect (mem_fun(*this, &GainMeterBase::reset_peak_display));
+       ResetGroupPeakDisplays.connect (mem_fun(*this, &GainMeterBase::reset_group_peak_display));
 
-       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 (bg_gc, pixmap, draw_rect.x, draw_rect.y, draw_rect.x, draw_rect.y, draw_rect.width, draw_rect.height);
-       //cerr << endl;//DEBUG
-       style_changed = false;
-       return true;
+       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::on_theme_changed()
-{
-       style_changed = true;
-}
-
-GainMeter::~GainMeter ()
+GainMeterBase::~GainMeterBase ()
 {
        if (meter_menu) {
                delete meter_menu;
@@ -318,12 +192,18 @@ 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()) {
@@ -333,25 +213,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 (sz);
-       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 */
@@ -362,7 +240,7 @@ GainMeter::gain_key_press (GdkEventKey* ev)
 }
 
 bool
-GainMeter::peak_button_release (GdkEventButton* ev)
+GainMeterBase::peak_button_release (GdkEventButton* ev)
 {
        /* reset peak label */
 
@@ -381,7 +259,7 @@ 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) {
@@ -395,7 +273,7 @@ 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) {
@@ -406,7 +284,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;
 
@@ -427,7 +305,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);
@@ -438,7 +316,7 @@ GainMeter::gain_focused (GdkEventFocus* ev)
 }
 
 void
-GainMeter::gain_activated ()
+GainMeterBase::gain_activated ()
 {
        float f;
 
@@ -457,7 +335,7 @@ GainMeter::gain_activated ()
 }
 
 void
-GainMeter::show_gain ()
+GainMeterBase::show_gain ()
 {
        char buf[32];
 
@@ -473,7 +351,7 @@ GainMeter::show_gain ()
 }
 
 void
-GainMeter::gain_adjusted ()
+GainMeterBase::gain_adjusted ()
 {
        if (!ignore_toggle) {
                _io->set_gain (slider_position_to_gain (gain_adjustment.get_value()), this);
@@ -482,7 +360,7 @@ GainMeter::gain_adjusted ()
 }
 
 void
-GainMeter::effective_gain_display ()
+GainMeterBase::effective_gain_display ()
 {
        gfloat value = gain_to_slider_position (_io->effective_gain());
 
@@ -494,26 +372,26 @@ GainMeter::effective_gain_display ()
 }
 
 void
-GainMeter::gain_changed (void *src)
+GainMeterBase::gain_changed (void *src)
 {
-       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);
        style_changed = true;
 }
 
 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_automation_state() & Play));
 }
@@ -540,7 +418,7 @@ next_meter_point (MeterPoint mp)
 }
 
 gint
-GainMeter::meter_press(GdkEventButton* ev)
+GainMeterBase::meter_press(GdkEventButton* ev)
 {
        Route* _route;
 
@@ -577,7 +455,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 ();
@@ -615,7 +493,7 @@ GainMeter::meter_press(GdkEventButton* ev)
 }
 
 gint
-GainMeter::meter_release(GdkEventButton* ev)
+GainMeterBase::meter_release(GdkEventButton* ev)
 {
 
        if(!ignore_toggle){
@@ -628,13 +506,13 @@ GainMeter::meter_release(GdkEventButton* ev)
 }
 
 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;
 
@@ -646,7 +524,7 @@ GainMeter::set_mix_group_meter_point (Route& route, MeterPoint mp)
 }
 
 void
-GainMeter::meter_point_clicked ()
+GainMeterBase::meter_point_clicked ()
 {
        Route* r;
 
@@ -656,21 +534,21 @@ GainMeter::meter_point_clicked ()
 }
 
 gint
-GainMeter::start_gain_touch (GdkEventButton* ev)
+GainMeterBase::start_gain_touch (GdkEventButton* ev)
 {
        _io->start_gain_touch ();
        return FALSE;
 }
 
 gint
-GainMeter::end_gain_touch (GdkEventButton* ev)
+GainMeterBase::end_gain_touch (GdkEventButton* ev)
 {
        _io->end_gain_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;
@@ -688,7 +566,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;
@@ -705,19 +583,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;
 
@@ -740,19 +618,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");
@@ -764,7 +642,7 @@ 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) {
@@ -778,10 +656,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;
 
@@ -809,12 +686,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();
@@ -834,9 +711,169 @@ 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);
+}
+
+Glib::RefPtr<Gdk::Pixmap>
+GainMeterBase::render_metrics (Gtk::Widget& w)
+{
+       //cerr << "name: " << w.get_name();//DEBUG
+       //cerr << " bg_red = " << w.get_style()->get_bg(Gtk::STATE_NORMAL).get_red();//DEBUG
+       //cerr << " fg_red = " << w.get_style()->get_fg(Gtk::STATE_NORMAL).get_red();//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
+GainMeterBase::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;
+}
+
+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);
+
+       Route* r;
+
+       if ((r = dynamic_cast<Route*> (_io.get())) != 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->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;
+}
+

diff --git a/gtk2_ardour/gain_meter.h b/gtk2_ardour/gain_meter.h
index 239d165d14ec3e7dc25521b6f39f2efff56b5fa1..dc75b5599673fb3ce48b7eaf60fb08237431143a 100644 (file)
--- a/gtk2_ardour/gain_meter.h
+++ b/gtk2_ardour/gain_meter.h
@@ -54,28 +54,27 @@ namespace Gtk {
        class Menu;
 }
 
-class GainMeter : public Gtk::VBox
+class GainMeterBase
 {
   public:
-       GainMeter (boost::shared_ptr<ARDOUR::IO>, ARDOUR::Session&);
-       ~GainMeter ();
+       GainMeterBase (boost::shared_ptr<ARDOUR::IO>, ARDOUR::Session&, const Glib::RefPtr<Gdk::Pixbuf>& pix,
+                      bool horizontal);
+       virtual ~GainMeterBase ();
 
        void update_gain_sensitive ();
-
        void update_meters ();
-
        void effective_gain_display ();
-
        void set_width (Width, int len=0);
-       void setup_meters (int len=0);
-
-       int get_gm_width ();
-
        void set_meter_strip_name (const char * name);
        void set_fader_name (const char * name);
-       PBD::Controllable& get_controllable() { return _io->gain_control(); }
 
-  private:
+       virtual void setup_meters (int len=0);
+
+       PBD::Controllable& get_controllable() { return _io->gain_control(); }
+       LevelMeter& get_level_meter() const { return *level_meter; }
+       Gtkmm2ext::SliderController& get_gain_slider() const { return *gain_slider; }
+       
+  protected:
 
        friend class MixerStrip;
        boost::shared_ptr<ARDOUR::IO> _io;
@@ -84,14 +83,12 @@ class GainMeter : public Gtk::VBox
        bool ignore_toggle;
        bool next_release_selects;
 
-       Gtkmm2ext::VSliderController *gain_slider;
+       Gtkmm2ext::SliderController *gain_slider;
        Gtk::Adjustment              gain_adjustment;
        Gtkmm2ext::FocusEntry        gain_display;
        Gtk::Button                  peak_display;
-       Gtk::HBox                    gain_display_box;
-       Gtk::HBox                    fader_box;
        Gtk::DrawingArea             meter_metric_area;
-       LevelMeter                                       *level_meter;
+       LevelMeter                  *level_meter;
 
        sigc::connection gain_watching;
 
@@ -130,16 +127,13 @@ class GainMeter : public Gtk::VBox
 
        float       max_peak;
        
-       Gtk::VBox*   fader_vbox;
-       Gtk::HBox   hbox;
-
        void gain_adjusted ();
        void gain_changed (void *);
        
        void meter_point_clicked ();
        void gain_unit_changed ();
        
-       void hide_all_meters ();
+       virtual void hide_all_meters ();
 
        gint meter_button_press (GdkEventButton*, uint32_t);
 
@@ -167,10 +161,6 @@ class GainMeter : public Gtk::VBox
        static sigc::signal<void> ResetAllPeakDisplays;
        static sigc::signal<void,ARDOUR::RouteGroup*> ResetGroupPeakDisplays;
 
-       static Glib::RefPtr<Gdk::Pixbuf> slider;
-       static Glib::RefPtr<Gdk::Pixbuf> rail;
-       static int setup_slider_pix ();
-
        void on_theme_changed ();
        bool style_changed;
        bool dpi_changed;
@@ -178,5 +168,29 @@ class GainMeter : public Gtk::VBox
        void color_handler(bool);
 };
 
+class GainMeter : public GainMeterBase, public Gtk::VBox
+{
+  public:
+       GainMeter (boost::shared_ptr<ARDOUR::IO>, ARDOUR::Session&);
+       ~GainMeter () {}
+
+       int get_gm_width ();
+       void setup_meters (int len=0);
+
+       static void setup_slider_pix ();
+
+  protected:
+       void hide_all_meters ();
+
+
+  private:
+       Gtk::HBox  gain_display_box;
+       Gtk::HBox  fader_box;
+       Gtk::VBox* fader_vbox;
+       Gtk::HBox  hbox;
+
+       static Glib::RefPtr<Gdk::Pixbuf> slider;
+};
+
 #endif /* __ardour_gtk_gain_meter_h__ */
 

diff --git a/gtk2_ardour/route_time_axis.cc b/gtk2_ardour/route_time_axis.cc
index f465de79d399728fc4749e101f0aad19fdbde216..600f0877ed94ab2f37d4307e356a0c01a7aa80ae 100644 (file)
--- a/gtk2_ardour/route_time_axis.cc
+++ b/gtk2_ardour/route_time_axis.cc
@@ -86,11 +86,12 @@ using namespace std;
 
 Glib::RefPtr<Gdk::Pixbuf> RouteTimeAxisView::slider;
 
-int
+void
 RouteTimeAxisView::setup_slider_pix ()
 {
-       slider = ::get_icon ("fader_belt_h");
-       return 0;
+       if ((slider = ::get_icon ("fader_belt_h")) == 0) {
+               throw failed_constructor ();
+       }
 }
 
 RouteTimeAxisView::RouteTimeAxisView (PublicEditor& ed, Session& sess, boost::shared_ptr<Route> rt, Canvas& canvas)
@@ -104,17 +105,11 @@ RouteTimeAxisView::RouteTimeAxisView (PublicEditor& ed, Session& sess, boost::sh
          size_button (_("h")), // height
          automation_button (_("a")),
          visual_button (_("v")),
-         lm (rt, sess),
-         gain_slider (0),
-         gain_adjustment (0.781787, 0.0, 1.0, 0.01, 0.1),
-         ignore_gain_adjustment (false)
+         gm (rt, sess, slider, true)
 {
-       if (slider == 0) {
-               setup_slider_pix ();
-       }
+       gm.get_level_meter().set_no_show_all();
+       gm.get_level_meter().setup_meters(50);
 
-       lm.set_no_show_all();
-       lm.setup_meters(50);
        _has_state = true;
        playlist_menu = 0;
        playlist_action_menu = 0;
@@ -125,8 +120,6 @@ RouteTimeAxisView::RouteTimeAxisView (PublicEditor& ed, Session& sess, boost::sh
        destructive_track_mode_item = 0;
        normal_track_mode_item = 0;
 
-       gain_slider = manage (new HSliderController (slider, &gain_adjustment, _route->gain_control(), false));
-
        ignore_toggle = false;
 
        edit_group_button.set_name ("TrackGroupButton");
@@ -173,7 +166,7 @@ RouteTimeAxisView::RouteTimeAxisView (PublicEditor& ed, Session& sess, boost::sh
 
        }
 
-       controls_hbox.pack_start(lm, false, false);
+       controls_hbox.pack_start(gm.get_level_meter(), false, false);
        _route->meter_change.connect (mem_fun(*this, &RouteTimeAxisView::meter_changed));
        _route->input_changed.connect (mem_fun(*this, &RouteTimeAxisView::io_changed));
        _route->output_changed.connect (mem_fun(*this, &RouteTimeAxisView::io_changed));
@@ -182,7 +175,7 @@ RouteTimeAxisView::RouteTimeAxisView (PublicEditor& ed, Session& sess, boost::sh
        controls_table.attach (*solo_button, 7, 8, 0, 1, Gtk::FILL|Gtk::EXPAND, Gtk::FILL|Gtk::EXPAND, 0, 0);
 
        controls_table.attach (edit_group_button, 7, 8, 1, 2, Gtk::FILL|Gtk::EXPAND, Gtk::FILL|Gtk::EXPAND, 0, 0);
-       controls_table.attach (*gain_slider, 0, 5, 1, 2, Gtk::SHRINK, Gtk::SHRINK, 0, 0);
+       controls_table.attach (gm.get_gain_slider(), 0, 5, 1, 2, Gtk::SHRINK, Gtk::SHRINK, 0, 0);
 
        ARDOUR_UI::instance()->tooltips().set_tip(*solo_button,_("Solo"));
        ARDOUR_UI::instance()->tooltips().set_tip(*mute_button,_("Mute"));
@@ -233,14 +226,7 @@ RouteTimeAxisView::RouteTimeAxisView (PublicEditor& ed, Session& sess, boost::sh
        editor.ZoomChanged.connect (mem_fun(*this, &RouteTimeAxisView::reset_samples_per_unit));
        ColorsChanged.connect (mem_fun (*this, &RouteTimeAxisView::color_handler));
 
-       gain_slider->signal_button_press_event().connect (mem_fun(*this, &RouteTimeAxisView::start_gain_touch));
-       gain_slider->signal_button_release_event().connect (mem_fun(*this, &RouteTimeAxisView::end_gain_touch));
-       gain_slider->set_name ("TrackGainFader");
-
-       gain_adjustment.signal_value_changed().connect (mem_fun(*this, &RouteTimeAxisView::gain_adjusted));
-       _route->gain_changed.connect (mem_fun(*this, &RouteTimeAxisView::gain_changed));
-
-       gain_slider->show_all();
+       gm.get_gain_slider().set_name ("TrackGainFader");
 }
 
 RouteTimeAxisView::~RouteTimeAxisView ()
@@ -698,7 +684,7 @@ RouteTimeAxisView::set_height (uint32_t h)
 {
        int gmlen = h - 5;
        bool height_changed = (height == 0) || (h != height);
-       lm.setup_meters (gmlen);
+       gm.get_level_meter().setup_meters (gmlen);
 
        TimeAxisView::set_height (h);
 
@@ -717,7 +703,7 @@ RouteTimeAxisView::set_height (uint32_t h)
                show_name_entry ();
                hide_name_label ();
 
-               gain_slider->show();
+               gm.get_gain_slider().show();
                mute_button->show();
                solo_button->show();
                if (rec_enable_button)
@@ -739,7 +725,7 @@ RouteTimeAxisView::set_height (uint32_t h)
                show_name_entry ();
                hide_name_label ();
 
-               gain_slider->hide();
+               gm.get_gain_slider().hide();
                mute_button->show();
                solo_button->show();
                if (rec_enable_button)
@@ -761,7 +747,7 @@ RouteTimeAxisView::set_height (uint32_t h)
                hide_name_entry ();
                show_name_label ();
                
-               gain_slider->hide();
+               gm.get_gain_slider().hide();
                mute_button->hide();
                solo_button->hide();
                if (rec_enable_button)
@@ -1826,14 +1812,14 @@ RouteTimeAxisView::update_rec_display ()
 void
 RouteTimeAxisView::fast_update ()
 {
-       lm.update_meters ();
+       gm.get_level_meter().update_meters ();
 }
 
 void
 RouteTimeAxisView::hide_meter ()
 {
        clear_meter ();
-       lm.hide_meters ();
+       gm.get_level_meter().hide_meters ();
 }
 
 void
@@ -1846,7 +1832,7 @@ void
 RouteTimeAxisView::reset_meter ()
 {
        if (Config->get_show_track_meters()) {
-               lm.setup_meters (height-5);
+               gm.get_level_meter().setup_meters (height-5);
        } else {
                hide_meter ();
        }
@@ -1855,7 +1841,7 @@ RouteTimeAxisView::reset_meter ()
 void
 RouteTimeAxisView::clear_meter ()
 {
-       lm.clear_meters ();
+       gm.get_level_meter().clear_meters ();
 }
 
 void
@@ -1871,41 +1857,3 @@ RouteTimeAxisView::io_changed (IOChange change, void *src)
        reset_meter ();
 }
 
-gint
-RouteTimeAxisView::start_gain_touch (GdkEventButton* ev)
-{
-       _route->start_gain_touch ();
-       return FALSE;
-}
-
-gint
-RouteTimeAxisView::end_gain_touch (GdkEventButton* ev)
-{
-       _route->end_gain_touch ();
-       return FALSE;
-}
-
-void
-RouteTimeAxisView::gain_adjusted ()
-{
-       if (ignore_gain_adjustment) {
-               return;
-       }
-
-       _route->set_gain (slider_position_to_gain (gain_adjustment.get_value()), this);
-}
-
-void
-RouteTimeAxisView::gain_changed (void *src)
-{
-       Gtkmm2ext::UI::instance()->call_slot (mem_fun(*this, &RouteTimeAxisView::effective_gain_display));
-}
-
-void
-RouteTimeAxisView::effective_gain_display ()
-{
-       gfloat value = gain_to_slider_position (_route->effective_gain());
-       ignore_gain_adjustment = true;
-       gain_adjustment.set_value (value);
-       ignore_gain_adjustment = false;
-}

diff --git a/gtk2_ardour/route_time_axis.h b/gtk2_ardour/route_time_axis.h
index 37404cdc4002366b2df87c46ab4546a863502bde..992c1a01c57b533c10bee411a0e5e99401d7cce7 100644 (file)
--- a/gtk2_ardour/route_time_axis.h
+++ b/gtk2_ardour/route_time_axis.h
@@ -40,7 +40,7 @@
 #include "enums.h"
 #include "time_axis_view.h"
 #include "canvas.h"
-#include "level_meter.h"
+#include "gain_meter.h"
 
 
 namespace ARDOUR {
@@ -110,7 +110,9 @@ public:
        void clear_meter ();
        void io_changed (ARDOUR::IOChange, void *);
        void meter_changed (void *);
-       void effective_gain_display ();
+       void effective_gain_display () { gm.effective_gain_display(); }
+
+       static void setup_slider_pix ();
 
 protected:
        friend class StreamView;
@@ -257,18 +259,9 @@ protected:
 
        void post_construct ();
        
-       LevelMeter      lm;
+       GainMeterBase gm;
 
-       Gtkmm2ext::HSliderController *gain_slider;
-       Gtk::Adjustment              gain_adjustment;
-       bool                         ignore_gain_adjustment;
        static Glib::RefPtr<Gdk::Pixbuf> slider;
-       static int setup_slider_pix ();
-       void gain_adjusted();
-
-       gint start_gain_touch (GdkEventButton*);
-       gint end_gain_touch (GdkEventButton*);
-       void gain_changed (void *);
 };
 
 #endif /* __ardour_route_time_axis_h__ */