Compare the string returned by backend->driver_name() against driver names in EngineC...
[ardour.git] / gtk2_ardour / engine_dialog.h
1 /*
2     Copyright (C) 2010 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 __gtk2_ardour_engine_dialog_h__
21 #define __gtk2_ardour_engine_dialog_h__
22
23 #include <map>
24 #include <vector>
25 #include <string>
26
27 #include <gtkmm/checkbutton.h>
28 #include <gtkmm/spinbutton.h>
29 #include <gtkmm/comboboxtext.h>
30 #include <gtkmm/table.h>
31 #include <gtkmm/expander.h>
32 #include <gtkmm/box.h>
33 #include <gtkmm/buttonbox.h>
34 #include <gtkmm/button.h>
35
36 #include "pbd/signals.h"
37
38 #include "ardour_dialog.h"
39 #include "ardour_button.h"
40
41 class EngineControl : public ArdourDialog, public PBD::ScopedConnectionList {
42   public:
43     EngineControl ();
44     ~EngineControl ();
45
46     static bool need_setup ();
47
48     XMLNode& get_state ();
49     void set_state (const XMLNode&);
50
51     void set_desired_sample_rate (uint32_t);
52
53   private:
54     Gtk::Notebook notebook;
55
56     Gtk::Label engine_status;
57
58     /* core fields used by all backends */
59
60     Gtk::Table basic_packer;
61     Gtk::HBox basic_hbox;
62     Gtk::VBox basic_vbox;
63
64     Gtk::ComboBoxText backend_combo;
65     Gtk::ComboBoxText driver_combo;
66     Gtk::ComboBoxText device_combo;
67     Gtk::ComboBoxText input_device_combo;
68     Gtk::ComboBoxText output_device_combo;
69     Gtk::ComboBoxText sample_rate_combo;
70     Gtk::ComboBoxText midi_option_combo;
71     Gtk::ComboBoxText buffer_size_combo;
72     Gtk::Label        buffer_size_duration_label;
73     Gtk::Adjustment input_latency_adjustment;
74     Gtk::SpinButton input_latency;
75     Gtk::Adjustment output_latency_adjustment;
76     Gtk::SpinButton output_latency;
77     Gtk::Adjustment input_channels_adjustment;
78     Gtk::SpinButton input_channels;
79     Gtk::Adjustment output_channels_adjustment;
80     Gtk::SpinButton output_channels;
81     Gtk::Adjustment ports_adjustment;
82     Gtk::SpinButton ports_spinner;
83
84     Gtk::Label      have_control_text;
85     Gtk::Button     control_app_button;
86     ArdourButton    midi_devices_button;
87
88     Gtk::Button     connect_disconnect_button;
89
90     /* latency measurement */
91
92     Gtk::ComboBoxText lm_output_channel_combo;
93     Gtk::ComboBoxText lm_input_channel_combo;
94     Gtk::Label        lm_measure_label;
95     Gtk::Button       lm_measure_button;
96     Gtk::Button       lm_use_button;
97     Gtk::Button       lm_back_button;
98     ArdourButton      lm_button_audio;
99     Gtk::Label        lm_title;
100     Gtk::Label        lm_preamble;
101     Gtk::Label        lm_results;
102     Gtk::Table        lm_table;
103     Gtk::VBox         lm_vbox;
104     bool              have_lm_results;
105     bool              lm_running;
106
107     Gtk::Button* cancel_button;
108     Gtk::Button* ok_button;
109     Gtk::Button* apply_button;
110
111     /* MIDI Tab */
112
113     Gtk::VBox midi_vbox;
114     Gtk::Button midi_back_button;
115     Gtk::Table midi_device_table;
116
117     /* MIDI ... JACK */
118
119     Gtk::CheckButton aj_button;
120
121     uint32_t ignore_changes;
122     uint32_t _desired_sample_rate;
123     bool     started_at_least_once;
124     bool     queue_device_changed;
125
126     void driver_changed ();
127     void backend_changed ();
128     void sample_rate_changed ();
129     void buffer_size_changed ();
130     void parameter_changed ();
131     void midi_option_changed ();
132
133     void setup_midi_tab_for_backend ();
134     void setup_midi_tab_for_jack ();
135     void refresh_midi_display (std::string focus = "");
136
137         void update_midi_options ();
138
139     std::string bufsize_as_string (uint32_t);
140
141     float get_rate() const;
142     uint32_t get_buffer_size() const;
143     uint32_t get_input_channels() const;
144     uint32_t get_output_channels() const;
145     uint32_t get_input_latency() const;
146     uint32_t get_output_latency() const;
147     std::string get_device_name() const;
148     std::string get_input_device_name() const;
149     std::string get_output_device_name() const;
150     std::string get_driver() const;
151     std::string get_backend() const;
152     std::string get_midi_option () const;
153
154     void device_changed ();
155     void input_device_changed ();
156     void output_device_changed ();
157     bool set_driver_popdown_strings ();
158     bool set_device_popdown_strings ();
159     bool set_input_device_popdown_strings ();
160     bool set_output_device_popdown_strings ();
161     void set_samplerate_popdown_strings (const std::string& dev_name);
162     void set_buffersize_popdown_strings (const std::string& dev_name);
163     void list_devices ();
164     void show_buffer_duration ();
165
166     void configure_midi_devices ();
167
168     struct MidiDeviceSetting {
169         std::string name;
170         bool enabled;
171         uint32_t input_latency;
172         uint32_t output_latency;
173
174         MidiDeviceSetting (std::string n, bool en = true, uint32_t inl = 0, uint32_t oul = 0)
175             : name (n)
176             , enabled (en)
177             , input_latency (inl)
178             , output_latency (oul)
179         {}
180     };
181
182     typedef boost::shared_ptr<MidiDeviceSetting> MidiDeviceSettings;
183     bool _can_set_midi_latencies;
184     std::vector<MidiDeviceSettings> _midi_devices;
185
186     MidiDeviceSettings find_midi_device(std::string devicename) const {
187         for (std::vector<MidiDeviceSettings>::const_iterator p = _midi_devices.begin(); p != _midi_devices.end(); ++p) {
188             if ((*p)->name == devicename) {
189                 return *p;
190             }
191         }
192         return MidiDeviceSettings();
193     }
194
195     struct StateStruct {
196         std::string backend;
197         std::string driver;
198         std::string device;
199         std::string input_device;
200         std::string output_device;
201         float sample_rate;
202         uint32_t buffer_size;
203         uint32_t input_latency;
204         uint32_t output_latency;
205         uint32_t input_channels;
206         uint32_t output_channels;
207         bool active;
208         std::string midi_option;
209         std::vector<MidiDeviceSettings> midi_devices;
210
211         StateStruct()
212                 : sample_rate (48000)
213                 , buffer_size (1024)
214                 , input_latency (0)
215                 , output_latency (0)
216                 , input_channels (0)
217                 , output_channels (0)
218                 , active (false) {}
219
220     };
221
222     typedef boost::shared_ptr<StateStruct> State;
223     typedef std::list<State> StateList;
224
225     StateList states;
226
227     State get_matching_state (const std::string& backend,
228                                const std::string& driver,
229                                const std::string& device);
230     State get_matching_state (const std::string& backend,
231                                const std::string& driver,
232                                const std::string& input_device,
233                                const std::string& output_device);
234     State get_saved_state_for_currently_displayed_backend_and_device ();
235     void maybe_display_saved_state ();
236     State save_state ();
237     void store_state (State);
238     bool equivalent_states (const State&, const State&);
239
240         void set_current_state (const State& state);
241
242     bool  _have_control;
243
244     static bool print_channel_count (Gtk::SpinButton*);
245
246     void build_notebook ();
247     void build_full_control_notebook ();
248     void build_no_control_notebook ();
249
250         void connect_changed_signals ();
251         void block_changed_signals ();
252         void unblock_changed_signals ();
253
254         class SignalBlocker
255         {
256         public:
257                 SignalBlocker (EngineControl& engine_control, const std::string& reason);
258
259                 ~SignalBlocker ();
260
261         private:
262                 EngineControl& ec;
263                 std::string m_reason;
264         };
265
266         uint32_t block_signals;
267
268         sigc::connection backend_combo_connection;
269         sigc::connection driver_combo_connection;
270         sigc::connection sample_rate_combo_connection;
271         sigc::connection buffer_size_combo_connection;
272         sigc::connection device_combo_connection;
273         sigc::connection input_device_combo_connection;
274         sigc::connection output_device_combo_connection;
275         sigc::connection midi_option_combo_connection;
276         sigc::connection input_latency_connection;
277         sigc::connection output_latency_connection;
278         sigc::connection input_channels_connection;
279         sigc::connection output_channels_connection;
280
281     void on_show ();
282     void on_response (int);
283     void control_app_button_clicked ();
284     void use_latency_button_clicked ();
285     void manage_control_app_sensitivity ();
286     int push_state_to_backend (bool start);
287     void post_push ();
288
289     /* latency measurement */
290     void latency_button_clicked ();
291     bool check_audio_latency_measurement ();
292     bool check_midi_latency_measurement ();
293     sigc::connection latency_timeout;
294     void enable_latency_tab ();
295     void disable_latency_tab ();
296     void start_latency_detection ();
297     void end_latency_detection ();
298
299     void on_switch_page (GtkNotebookPage*, guint page_num);
300     bool on_delete_event (GdkEventAny*);
301
302     void engine_running ();
303     void engine_stopped ();
304     void device_list_changed ();
305
306     PBD::ScopedConnection running_connection;
307     PBD::ScopedConnectionList stopped_connection;
308     PBD::ScopedConnection devicelist_connection;
309
310     void connect_disconnect_click ();
311     void calibrate_audio_latency ();
312     void calibrate_midi_latency (MidiDeviceSettings);
313
314     MidiDeviceSettings _measure_midi;
315     void midi_latency_adjustment_changed(Gtk::Adjustment *, MidiDeviceSettings, bool);
316     void midi_device_enabled_toggled(ArdourButton *, MidiDeviceSettings);
317     sigc::connection lm_back_button_signal;
318 };
319
320 #endif /* __gtk2_ardour_engine_dialog_h__ */