← Back to branch summary

~ubuntu-branches/ubuntu/utopic/ardour3/utopic

« back to all changes in this revision

Viewing changes to gtk2_ardour/gain_meter.h

  • Committer: Package Import Robot
  • Author(s): Felipe Sateler
  • Date: 2013-09-21 19:05:02 UTC
  • Revision ID: package-import@ubuntu.com-20130921190502-8gsftrku6jnzhd7v
Tags: upstream-3.4~dfsg
Import upstream version 3.4~dfsg

Show diffs side-by-side

added added

removed removed

Lines of Context:
gtk2_ardour/gain_meter.h
 
1
/*
 
2
    Copyright (C) 2002 Paul Davis
 
3
 
 
4
    This program is free software; you can redistribute it and/or modify
 
5
    it under the terms of the GNU General Public License as published by
 
6
    the Free Software Foundation; either version 2 of the License, or
 
7
    (at your option) any later version.
 
8
 
 
9
    This program is distributed in the hope that it will be useful,
 
10
    but WITHOUT ANY WARRANTY; without even the implied warranty of
 
11
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
12
    GNU General Public License for more details.
 
13
 
 
14
    You should have received a copy of the GNU General Public License
 
15
    along with this program; if not, write to the Free Software
 
16
    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 
17
 
 
18
*/
 
19
 
 
20
#ifndef __ardour_gtk_gain_meter_h__
 
21
#define __ardour_gtk_gain_meter_h__
 
22
 
 
23
#include <vector>
 
24
#include <map>
 
25
 
 
26
#include <gtkmm/box.h>
 
27
#include <gtkmm/adjustment.h>
 
28
#include <gtkmm/frame.h>
 
29
#include <gtkmm/eventbox.h>
 
30
#include <gtkmm/button.h>
 
31
#include <gtkmm/table.h>
 
32
#include <gtkmm/drawingarea.h>
 
33
#include <gdkmm/colormap.h>
 
34
 
 
35
#include "pbd/signals.h"
 
36
 
 
37
#include "ardour/chan_count.h"
 
38
#include "ardour/types.h"
 
39
#include "ardour/session_handle.h"
 
40
 
 
41
#include "ardour_button.h"
 
42
 
 
43
#include "gtkmm2ext/click_box.h"
 
44
#include "gtkmm2ext/focus_entry.h"
 
45
#include "gtkmm2ext/slider_controller.h"
 
46
 
 
47
#include "enums.h"
 
48
#include "level_meter.h"
 
49
 
 
50
namespace ARDOUR {
 
51
        class IO;
 
52
        class Session;
 
53
        class Route;
 
54
        class RouteGroup;
 
55
        class PeakMeter;
 
56
        class Amp;
 
57
        class Automatable;
 
58
}
 
59
namespace Gtkmm2ext {
 
60
        class FastMeter;
 
61
        class BarController;
 
62
}
 
63
namespace Gtk {
 
64
        class Menu;
 
65
}
 
66
 
 
67
class GainMeterBase : virtual public sigc::trackable, ARDOUR::SessionHandlePtr
 
68
{
 
69
  public:
 
70
        GainMeterBase (ARDOUR::Session*, bool horizontal, int, int);
 
71
        virtual ~GainMeterBase ();
 
72
 
 
73
        virtual void set_controls (boost::shared_ptr<ARDOUR::Route> route,
 
74
                                   boost::shared_ptr<ARDOUR::PeakMeter> meter,
 
75
                                   boost::shared_ptr<ARDOUR::Amp> amp);
 
76
 
 
77
        void update_gain_sensitive ();
 
78
        void update_meters ();
 
79
 
 
80
        void effective_gain_display ();
 
81
        void set_width (Width, int len=0);
 
82
        void set_meter_strip_name (const char * name);
 
83
        void set_fader_name (const char * name);
 
84
 
 
85
        void set_flat_buttons ();
 
86
 
 
87
        virtual void setup_meters (int len=0);
 
88
        virtual void set_type (ARDOUR::MeterType);
 
89
 
 
90
        boost::shared_ptr<PBD::Controllable> get_controllable();
 
91
 
 
92
        LevelMeterHBox& get_level_meter() const { return *level_meter; }
 
93
        Gtkmm2ext::SliderController& get_gain_slider() const { return *gain_slider; }
 
94
 
 
95
        /** Emitted in the GUI thread when a button is pressed over the level meter;
 
96
         *  return true if the event is handled.
 
97
         */
 
98
        PBD::Signal1<bool, GdkEventButton *> LevelMeterButtonPress;
 
99
 
 
100
  protected:
 
101
 
 
102
        friend class MixerStrip;
 
103
        friend class MeterStrip;
 
104
        boost::shared_ptr<ARDOUR::Route> _route;
 
105
        boost::shared_ptr<ARDOUR::PeakMeter> _meter;
 
106
        boost::shared_ptr<ARDOUR::Amp> _amp;
 
107
        std::vector<sigc::connection> connections;
 
108
        PBD::ScopedConnectionList model_connections;
 
109
 
 
110
        bool ignore_toggle;
 
111
        bool next_release_selects;
 
112
 
 
113
        Gtkmm2ext::SliderController *gain_slider;
 
114
        Gtk::Adjustment              gain_adjustment;
 
115
        Gtkmm2ext::FocusEntry        gain_display;
 
116
        Gtk::Button                  peak_display;
 
117
        Gtk::DrawingArea             meter_metric_area;
 
118
        Gtk::DrawingArea             meter_ticks1_area;
 
119
        Gtk::DrawingArea             meter_ticks2_area;
 
120
        LevelMeterHBox              *level_meter;
 
121
 
 
122
        sigc::connection gain_watching;
 
123
 
 
124
        ArdourButton gain_automation_style_button;
 
125
        ArdourButton gain_automation_state_button;
 
126
 
 
127
        Gtk::Menu gain_astate_menu;
 
128
        Gtk::Menu gain_astyle_menu;
 
129
 
 
130
        gint gain_automation_style_button_event (GdkEventButton *);
 
131
        gint gain_automation_state_button_event (GdkEventButton *);
 
132
        gint pan_automation_style_button_event (GdkEventButton *);
 
133
        gint pan_automation_state_button_event (GdkEventButton *);
 
134
 
 
135
        void gain_automation_state_changed();
 
136
        void gain_automation_style_changed();
 
137
 
 
138
        void setup_gain_adjustment ();
 
139
 
 
140
        std::string astate_string (ARDOUR::AutoState);
 
141
        std::string short_astate_string (ARDOUR::AutoState);
 
142
        std::string _astate_string (ARDOUR::AutoState, bool);
 
143
 
 
144
        std::string astyle_string (ARDOUR::AutoStyle);
 
145
        std::string short_astyle_string (ARDOUR::AutoStyle);
 
146
        std::string _astyle_string (ARDOUR::AutoStyle, bool);
 
147
 
 
148
        Width _width;
 
149
 
 
150
        void show_gain ();
 
151
        void gain_activated ();
 
152
        bool gain_focused (GdkEventFocus*);
 
153
 
 
154
        float max_peak;
 
155
 
 
156
        void gain_adjusted ();
 
157
        void gain_changed ();
 
158
 
 
159
        void meter_point_clicked ();
 
160
        void gain_unit_changed ();
 
161
 
 
162
        virtual void hide_all_meters ();
 
163
 
 
164
        gint meter_button_press (GdkEventButton*, uint32_t);
 
165
 
 
166
        bool peak_button_release (GdkEventButton*);
 
167
        bool gain_key_press (GdkEventKey*);
 
168
 
 
169
        Gtk::Menu* meter_menu;
 
170
        void popup_meter_menu (GdkEventButton*);
 
171
 
 
172
        bool gain_slider_button_press (GdkEventButton *);
 
173
        bool gain_slider_button_release (GdkEventButton *);
 
174
 
 
175
        void set_route_group_meter_point (ARDOUR::Route&, ARDOUR::MeterPoint);
 
176
        void set_meter_point (ARDOUR::Route&, ARDOUR::MeterPoint);
 
177
        gint meter_release (GdkEventButton*);
 
178
        gint meter_press (GdkEventButton*);
 
179
        bool wait_for_release;
 
180
        ARDOUR::MeterPoint old_meter_point;
 
181
 
 
182
        void parameter_changed (const char*);
 
183
 
 
184
        void reset_peak_display ();
 
185
        void reset_route_peak_display (ARDOUR::Route*);
 
186
        void reset_group_peak_display (ARDOUR::RouteGroup*);
 
187
 
 
188
        void redraw_metrics ();
 
189
        void on_theme_changed ();
 
190
        void color_handler(bool);
 
191
        ARDOUR::DataType _data_type;
 
192
        ARDOUR::ChanCount _previous_amp_output_streams;
 
193
 
 
194
private:
 
195
 
 
196
        bool level_meter_button_press (GdkEventButton *);
 
197
        PBD::ScopedConnection _level_meter_connection;
 
198
};
 
199
 
 
200
class GainMeter : public GainMeterBase, public Gtk::VBox
 
201
{
 
202
  public:
 
203
         GainMeter (ARDOUR::Session*, int);
 
204
        virtual ~GainMeter ();
 
205
 
 
206
        virtual void set_controls (boost::shared_ptr<ARDOUR::Route> route,
 
207
                                   boost::shared_ptr<ARDOUR::PeakMeter> meter,
 
208
                                   boost::shared_ptr<ARDOUR::Amp> amp);
 
209
 
 
210
        int get_gm_width ();
 
211
        void setup_meters (int len=0);
 
212
        void set_type (ARDOUR::MeterType);
 
213
        void route_active_changed ();
 
214
 
 
215
  protected:
 
216
        void hide_all_meters ();
 
217
 
 
218
        gint meter_metrics_expose (GdkEventExpose *);
 
219
        gint meter_ticks1_expose (GdkEventExpose *);
 
220
        gint meter_ticks2_expose (GdkEventExpose *);
 
221
 
 
222
  private:
 
223
 
 
224
        void meter_configuration_changed (ARDOUR::ChanCount);
 
225
        void meter_type_changed (ARDOUR::MeterType);
 
226
 
 
227
        Gtk::HBox  gain_display_box;
 
228
        Gtk::HBox  fader_box;
 
229
        Gtk::VBox* fader_vbox;
 
230
        Gtk::HBox  hbox;
 
231
        Gtk::HBox  meter_hbox;
 
232
        Gtk::Alignment fader_alignment;
 
233
        Gtk::Alignment meter_alignment;
 
234
        std::vector<ARDOUR::DataType> _types;
 
235
};
 
236
 
 
237
#endif /* __ardour_gtk_gain_meter_h__ */
 
238