X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=gtk2_ardour%2Foption_editor.h;h=93e217f7e7b3f88789fe9f911f771e5376eaf1a0;hb=ae3c50c495ffadbc62103cc1d3a61af2b48f423e;hp=5b22cf4cc51fe239590c5f202cdcd286651ecfec;hpb=015fc7b39fab97cee1875231694adce43155ceb5;p=ardour.git diff --git a/gtk2_ardour/option_editor.h b/gtk2_ardour/option_editor.h index 5b22cf4cc5..93e217f7e7 100644 --- a/gtk2_ardour/option_editor.h +++ b/gtk2_ardour/option_editor.h @@ -14,7 +14,6 @@ You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. - */ #ifndef __gtk_ardour_option_editor_h__ @@ -25,7 +24,13 @@ #include #include #include -#include "ardour_dialog.h" +#include + +#include "gtkmm2ext/slider_controller.h" + +#include "ardour_window.h" +#include "audio_clock.h" +#include "ardour/types.h" /** @file option_editor.h * @brief Base class for option editing dialog boxes. @@ -43,7 +48,7 @@ * options dialog. */ -namespace ARDOUR { +namespace PBD { class Configuration; } @@ -53,6 +58,8 @@ class OptionEditorPage; class OptionEditorComponent { public: + virtual ~OptionEditorComponent() {} + /** Called when a configuration parameter's value has changed. * @param p parameter name */ @@ -65,7 +72,16 @@ public: virtual void add_to_page (OptionEditorPage *) = 0; void add_widget_to_page (OptionEditorPage*, Gtk::Widget*); - void add_widgets_to_page (OptionEditorPage*, Gtk::Widget*, Gtk::Widget*); + void add_widgets_to_page (OptionEditorPage*, Gtk::Widget*, Gtk::Widget*, bool expand = true); + + void set_note (std::string const &); + + virtual Gtk::Widget& tip_widget() = 0; + +protected: + void maybe_add_note (OptionEditorPage *, int); + + std::string _note; }; /** A component which provides a subheading within the dialog */ @@ -78,34 +94,63 @@ public: void set_state_from_config () {} void add_to_page (OptionEditorPage *); + Gtk::Widget& tip_widget() { return *_label; } + private: Gtk::Label* _label; ///< the label used for the heading }; -/** A component which provides a box into which a subclass can put arbitrary widgets */ -class OptionEditorBox : public OptionEditorComponent +/** Expanding layout helper to push elements to the left on a single column page */ +class OptionEditorBlank : public OptionEditorComponent { public: + OptionEditorBlank () {} - /** Construct an OpenEditorBox */ - OptionEditorBox () - { - _box = Gtk::manage (new Gtk::VBox); - _box->set_spacing (4); - } + void parameter_changed (std::string const &) {} + void set_state_from_config () {} + void add_to_page (OptionEditorPage *); - void parameter_changed (std::string const &) = 0; - void set_state_from_config () = 0; + Gtk::Widget& tip_widget() { return _dummy; } + +private: + Gtk::EventBox _dummy; +}; + +class RcConfigDisplay : public OptionEditorComponent +{ +public: + RcConfigDisplay (std::string const &, std::string const &, sigc::slot, char s = '\0'); void add_to_page (OptionEditorPage *); + void parameter_changed (std::string const & p); + void set_state_from_config (); + Gtk::Widget& tip_widget() { return *_info; } +protected: + sigc::slot _get; + Gtk::Label* _label; + Gtk::Label* _info; + std::string _id; + char _sep; +}; + +class RcActionButton : public OptionEditorComponent +{ +public: + RcActionButton (std::string const & t, const Glib::SignalProxy0< void >::SlotType & slot, std::string const & l = ""); + void add_to_page (OptionEditorPage *); + + void parameter_changed (std::string const & p) {} + void set_state_from_config () {} + Gtk::Widget& tip_widget() { return *_button; } protected: - - Gtk::VBox* _box; ///< constituent box for subclasses to add widgets to + Gtk::Button* _button; + Gtk::Label* _label; + std::string _name; }; /** Base class for components which provide UI to change an option */ -class Option : public OptionEditorComponent { - +class Option : public OptionEditorComponent +{ public: /** Construct an Option. * @param i Option id (e.g. "plugins-stop-with-transport") @@ -124,45 +169,100 @@ public: set_state_from_config (); } } - + virtual void set_state_from_config () = 0; virtual void add_to_page (OptionEditorPage*) = 0; std::string id () const { return _id; } - -private: - + +protected: std::string _id; std::string _name; }; /** Component which provides the UI to handle a boolean option using a GTK CheckButton */ -class BoolOption : public Option { - +class BoolOption : public Option +{ public: - BoolOption (std::string const &, std::string const &, sigc::slot, sigc::slot); void set_state_from_config (); - void toggled (); void add_to_page (OptionEditorPage*); - -private: - - sigc::slot _get; ///< slot to get the configuration variable's value + + void set_sensitive (bool yn) { + _button->set_sensitive (yn); + } + + Gtk::Widget& tip_widget() { return *_button; } + +protected: + virtual void toggled (); + + sigc::slot _get; ///< slot to get the configuration variable's value sigc::slot _set; ///< slot to set the configuration variable's value - Gtk::CheckButton* _button; ///< UI button + Gtk::CheckButton* _button; ///< UI button + Gtk::Label* _label; ///< label for button, so we can use markup +}; + +class RouteDisplayBoolOption : public BoolOption +{ +public: + RouteDisplayBoolOption (std::string const &, std::string const &, sigc::slot, sigc::slot); + +protected: + virtual void toggled (); +}; + +/** Component which allows to add any GTK Widget - intended for single buttons and custom stateless objects */ +class FooOption : public OptionEditorComponent +{ +public: + FooOption (Gtk::Widget *w) : _w (w) {} + + void add_to_page (OptionEditorPage* p) { + add_widget_to_page (p, _w); + } + + Gtk::Widget& tip_widget() { return *_w; } + void set_state_from_config () {} + void parameter_changed (std::string const &) {} +private: + Gtk::Widget *_w; }; -/** Component which provides the UI to handle an enumerated option using a GTK CheckButton. +/** Component which provides the UI to handle a string option using a GTK Entry */ +class EntryOption : public Option +{ +public: + EntryOption (std::string const &, std::string const &, sigc::slot, sigc::slot); + void set_state_from_config (); + void add_to_page (OptionEditorPage*); + void set_sensitive (bool); + void set_invalid_chars (std::string i) { _invalid = i; } + + Gtk::Widget& tip_widget() { return *_entry; } + +private: + void activated (); + bool focus_out (GdkEventFocus*); + void filter_text (const Glib::ustring&, int*); + + sigc::slot _get; ///< slot to get the configuration variable's value + sigc::slot _set; ///< slot to set the configuration variable's value + Gtk::Label* _label; ///< UI label + Gtk::Entry* _entry; ///< UI entry + std::string _invalid; +}; + + +/** Component which provides the UI to handle an enumerated option using a GTK ComboBox. * The template parameter is the enumeration. */ template -class ComboOption : public Option { - +class ComboOption : public Option +{ public: - /** Construct an ComboOption. * @param i id * @param n User-visible name. @@ -175,22 +275,23 @@ public: sigc::slot g, sigc::slot s ) - : Option (i, n), - _get (g), - _set (s) + : Option (i, n) + , _get (g) + , _set (s) { - _label = manage (new Gtk::Label (n + ":")); - _label->set_alignment (1, 0.5); - _combo = manage (new Gtk::ComboBoxText); + _label = Gtk::manage (new Gtk::Label (n + ":")); + _label->set_alignment (0, 0.5); + _combo = Gtk::manage (new Gtk::ComboBoxText); _combo->signal_changed().connect (sigc::mem_fun (*this, &ComboOption::changed)); } - void set_state_from_config () { + void set_state_from_config () + { uint32_t r = 0; while (r < _options.size() && _get () != _options[r]) { ++r; } - + if (r < _options.size()) { _combo->set_active (r); } @@ -205,20 +306,33 @@ public: * @param e Enumeration. * @param o User-visible name for this value. */ - void add (T e, std::string const & o) { + void add (T e, std::string const & o) + { _options.push_back (e); _combo->append_text (o); } - - void changed () { + + void clear () + { + _combo->clear_items(); + _options.clear (); + } + + void changed () + { uint32_t const r = _combo->get_active_row_number (); if (r < _options.size()) { _set (_options[r]); } } + void set_sensitive (bool yn) + { + _combo->set_sensitive (yn); + } + + Gtk::Widget& tip_widget() { return *_combo; } private: - sigc::slot _get; sigc::slot _set; Gtk::Label* _label; @@ -227,6 +341,113 @@ private: }; +/** Component which provides the UI for a GTK HScale. + */ +class HSliderOption : public Option +{ +public: + HSliderOption ( + std::string const& i, + std::string const& n, + sigc::slot g, + sigc::slot s, + double lower, double upper, + double step_increment = 1, + double page_increment = 10, + double mult = 1.0, + bool logarithmic = false + ); + + void set_state_from_config (); + virtual void changed (); + void add_to_page (OptionEditorPage* p); + void set_sensitive (bool yn); + + Gtk::Widget& tip_widget() { return _hscale; } + Gtk::HScale& scale() { return _hscale; } + +protected: + sigc::slot _get; + sigc::slot _set; + Gtk::Adjustment _adj; + Gtk::HScale _hscale; + Gtk::Label _label; + double _mult; + bool _log; +}; + + +/** Component which provides the UI to handle an enumerated option using a GTK ComboBox. + * The template parameter is the enumeration. + */ +class ComboStringOption : public Option +{ +public: + /** Construct an ComboOption. + * @param i id + * @param n User-visible name. + * @param g Slot to get the variable's value. + * @param s Slot to set the variable's value. + */ + ComboStringOption ( + std::string const & i, + std::string const & n, + sigc::slot g, + sigc::slot s + ); + + void set_state_from_config (); + void add_to_page (OptionEditorPage* p); + + /** Set the allowed strings for this option + * @param strings a vector of allowed strings + */ + void set_popdown_strings (const std::vector& strings); + + void clear (); + void changed (); + void set_sensitive (bool yn); + + Gtk::Widget& tip_widget() { return *_combo; } + +private: + sigc::slot _get; + sigc::slot _set; + Gtk::Label* _label; + Gtk::ComboBoxText* _combo; +}; + + +/** Component which provides the UI to handle a boolean option which needs + * to be represented as a ComboBox to be clear to the user. + */ +class BoolComboOption : public Option +{ +public: + BoolComboOption ( + std::string const &, + std::string const &, + std::string const &, + std::string const &, + sigc::slot, + sigc::slot + ); + + void set_state_from_config (); + void add_to_page (OptionEditorPage *); + void changed (); + void set_sensitive (bool); + + Gtk::Widget& tip_widget() { return *_combo; } + +private: + sigc::slot _get; + sigc::slot _set; + Gtk::Label* _label; + Gtk::ComboBoxText* _combo; +}; + + /** Component which provides the UI to handle an numeric option using a GTK SpinButton */ template class SpinOption : public Option @@ -241,6 +462,9 @@ public: * @param max Variable maximum value. * @param step Step for the spin button. * @param page Page step for the spin button. + * @param unit Unit name. + * @param scale Scaling factor (such that for a value x in the spinbutton, x * scale is written to the config) + * @param digits Number of decimal digits to show. */ SpinOption ( std::string const & i, @@ -250,42 +474,123 @@ public: T min, T max, T step, - T page + T page, + std::string const & unit = "", + float scale = 1, + unsigned digits = 0 ) - : Option (i, n), - _get (g), - _set (s) + : Option (i, n) + , _get (g) + , _set (s) + , _scale (scale) { - _label = manage (new Gtk::Label (n + ":")); - _label->set_alignment (1, 0.5); - _spin = manage (new Gtk::SpinButton); + _label = Gtk::manage (new Gtk::Label (n + ":")); + _label->set_alignment (0, 0.5); + + _spin = Gtk::manage (new Gtk::SpinButton); _spin->set_range (min, max); _spin->set_increments (step, page); + _spin->set_digits(digits); + + _box = Gtk::manage (new Gtk::HBox); + _box->pack_start (*_spin, true, true); + _box->set_spacing (4); + if (unit.length()) { + _box->pack_start (*Gtk::manage (new Gtk::Label (unit)), false, false); + } + _spin->signal_value_changed().connect (sigc::mem_fun (*this, &SpinOption::changed)); } void set_state_from_config () { - _spin->set_value (_get ()); + _spin->set_value (_get () / _scale); } void add_to_page (OptionEditorPage* p) { - add_widgets_to_page (p, _label, _spin); + add_widgets_to_page (p, _label, _box, false); } - + void changed () { - _set (static_cast (_spin->get_value ())); + _set (static_cast (_spin->get_value ()) * _scale); } - + + Gtk::Widget& tip_widget() { return *_spin; } + private: sigc::slot _get; sigc::slot _set; + float _scale; Gtk::Label* _label; + Gtk::HBox* _box; Gtk::SpinButton* _spin; }; +class FaderOption : public Option +{ +public: + + FaderOption (std::string const &, std::string const &, sigc::slot g, sigc::slot s); + void set_state_from_config (); + void add_to_page (OptionEditorPage *); + + Gtk::Widget& tip_widget() { return *_db_slider; } + +private: + void db_changed (); + void on_activate (); + bool on_key_press (GdkEventKey* ev); + + Gtk::Adjustment _db_adjustment; + Gtkmm2ext::HSliderController* _db_slider; + Gtk::Entry _db_display; + Gtk::Label _label; + Gtk::HBox _box; + Gtk::VBox _fader_centering_box; + sigc::slot _get; + sigc::slot _set; +}; + +class ClockOption : public Option +{ +public: + ClockOption (std::string const &, std::string const &, sigc::slot, sigc::slot); + void set_state_from_config (); + void add_to_page (OptionEditorPage *); + void set_session (ARDOUR::Session *); + + Gtk::Widget& tip_widget() { return _clock; } + AudioClock& clock() { return _clock; } + +private: + void save_clock_time (); + Gtk::Label _label; + AudioClock _clock; + sigc::slot _get; + sigc::slot _set; + ARDOUR::Session *_session; +}; + +class DirectoryOption : public Option +{ +public: + DirectoryOption (std::string const &, std::string const &, sigc::slot, sigc::slot); + + void set_state_from_config (); + void add_to_page (OptionEditorPage *); + + Gtk::Widget& tip_widget() { return _file_chooser; } + +private: + void selection_changed (); + + sigc::slot _get; ///< slot to get the configuration variable's value + sigc::slot _set; ///< slot to set the configuration variable's value + Gtk::FileChooserButton _file_chooser; +}; + /** Class to represent a single page in an OptionEditor's notebook. * Pages are laid out using a 3-column table; the 1st column is used * to indent non-headings, and the 2nd and 3rd for actual content. @@ -294,32 +599,97 @@ class OptionEditorPage { public: OptionEditorPage (Gtk::Notebook&, std::string const &); + OptionEditorPage (); Gtk::VBox box; Gtk::Table table; std::list components; + +private: + void init (); +}; + +class OptionEditorMiniPage : public OptionEditorComponent, public OptionEditorPage +{ +public: + OptionEditorMiniPage () + { + box.pack_start (table, false, false); + box.set_border_width (0); + } + + void parameter_changed (std::string const &) = 0; + void set_state_from_config () = 0; + virtual void add_to_page (OptionEditorPage*); + + Gtk::Widget& tip_widget() { return *table.children().front().get_widget(); } }; /** The OptionEditor dialog base class */ -class OptionEditor : public ArdourDialog +class OptionEditor : virtual public sigc::trackable { public: - OptionEditor (ARDOUR::Configuration *, std::string const &); - ~OptionEditor (); + OptionEditor (PBD::Configuration *); + virtual ~OptionEditor (); - void add (std::string const &, OptionEditorComponent *); + void add_option (std::string const &, OptionEditorComponent *); + void add_page (std::string const &, Gtk::Widget& page_widget); + + void set_current_page (std::string const &); protected: - - ARDOUR::Configuration* _config; - -private: - void parameter_changed (std::string const &); + virtual void parameter_changed (std::string const &); + + PBD::Configuration* _config; + Gtk::Notebook& notebook() { return _notebook; } + Gtk::TreeView& treeview() { return option_treeview; } + + class OptionColumns : public Gtk::TreeModel::ColumnRecord + { + public: + Gtk::TreeModelColumn name; + Gtk::TreeModelColumn widget; + + OptionColumns() { + add (name); + add (widget); + } + }; + OptionColumns option_columns; + Glib::RefPtr option_tree; + +private: + PBD::ScopedConnection config_connection; Gtk::Notebook _notebook; + Gtk::TreeView option_treeview; std::map _pages; + + void add_path_to_treeview (std::string const &, Gtk::Widget&); + Gtk::TreeModel::iterator find_path_in_treemodel (std::string const & pn, + bool create_missing = false); + void treeview_row_selected (); }; -#endif /* __gtk_ardour_option_editor_h__ */ +/** The OptionEditor dialog-as-container base class */ +class OptionEditorContainer : public OptionEditor, public Gtk::VBox +{ +public: + OptionEditorContainer (PBD::Configuration *, std::string const &); + ~OptionEditorContainer() {} +private: + Gtk::HBox hpacker; +}; +/** The OptionEditor dialog-as-container base class */ +class OptionEditorWindow : public OptionEditor, public ArdourWindow +{ +public: + OptionEditorWindow (PBD::Configuration *, std::string const &); + ~OptionEditorWindow() {} +private: + Gtk::VBox container; + Gtk::HBox hpacker; +}; +#endif /* __gtk_ardour_option_editor_h__ */