2005-09-25 14:42:24 -04:00
|
|
|
/*
|
2009-05-13 20:13:27 -04:00
|
|
|
Copyright (C) 2009 Paul Davis
|
2005-09-25 14:42:24 -04:00
|
|
|
|
|
|
|
This program is free software; you can redistribute it and/or modify
|
|
|
|
it under the terms of the GNU General Public License as published by
|
|
|
|
the Free Software Foundation; either version 2 of the License, or
|
|
|
|
(at your option) any later version.
|
|
|
|
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
GNU General Public License for more details.
|
|
|
|
|
|
|
|
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.
|
|
|
|
|
|
|
|
*/
|
|
|
|
|
2009-05-13 20:13:27 -04:00
|
|
|
#ifndef __gtk_ardour_option_editor_h__
|
|
|
|
#define __gtk_ardour_option_editor_h__
|
2005-09-25 14:42:24 -04:00
|
|
|
|
2005-09-26 10:33:53 -04:00
|
|
|
#include <gtkmm/notebook.h>
|
|
|
|
#include <gtkmm/checkbutton.h>
|
|
|
|
#include <gtkmm/comboboxtext.h>
|
2009-05-13 20:13:27 -04:00
|
|
|
#include <gtkmm/spinbutton.h>
|
|
|
|
#include <gtkmm/table.h>
|
2010-05-19 21:30:35 -04:00
|
|
|
#include "gtkmm2ext/slider_controller.h"
|
2011-11-18 19:56:35 -05:00
|
|
|
#include "ardour_window.h"
|
2010-12-01 15:49:22 -05:00
|
|
|
#include "audio_clock.h"
|
2010-05-19 21:30:35 -04:00
|
|
|
#include "ardour/types.h"
|
2005-09-25 14:42:24 -04:00
|
|
|
|
2009-05-13 20:13:27 -04:00
|
|
|
/** @file option_editor.h
|
|
|
|
* @brief Base class for option editing dialog boxes.
|
|
|
|
*
|
|
|
|
* Code to provided the basis for dialogs which allow the user to edit options
|
|
|
|
* from an ARDOUR::Configuration class.
|
|
|
|
*
|
|
|
|
* The idea is that we have an OptionEditor class which is the dialog box.
|
|
|
|
* This is essentially a GTK Notebook. OptionEditorComponent objects can
|
|
|
|
* then be added to the OptionEditor, and these components are arranged on
|
|
|
|
* the pages of the Notebook. There is also an OptionEditorComponent hierarchy
|
|
|
|
* here, providing things like boolean and combobox option components.
|
|
|
|
*
|
|
|
|
* It is intended that OptionEditor be subclassed to implement a particular
|
|
|
|
* options dialog.
|
|
|
|
*/
|
|
|
|
|
|
|
|
namespace ARDOUR {
|
|
|
|
class Configuration;
|
|
|
|
}
|
|
|
|
|
|
|
|
class OptionEditorPage;
|
|
|
|
|
|
|
|
/** Base class for components of an OptionEditor dialog */
|
|
|
|
class OptionEditorComponent
|
2005-09-25 14:42:24 -04:00
|
|
|
{
|
2009-05-13 20:13:27 -04:00
|
|
|
public:
|
Merged revisions 6293,6296-6306,6308 via svnmerge from
svn+ssh://ardoursvn@subversion.ardour.org/ardour2/branches/build_fixes
........
r6293 | trutkin | 2009-12-05 08:49:37 -0500 (Sat, 05 Dec 2009) | 2 lines
fix if-statement in build script
........
r6296 | trutkin | 2009-12-05 09:30:19 -0500 (Sat, 05 Dec 2009) | 5 lines
rearrange GTKOSX and darwin dependencies
- moved some GTKOSX include paths to generic darwin
- made GTKOSX dependent on being on darwin anyways
........
r6297 | trutkin | 2009-12-05 09:35:09 -0500 (Sat, 05 Dec 2009) | 2 lines
move coreaudio and audiounit handling to darwin section
........
r6298 | trutkin | 2009-12-05 09:53:40 -0500 (Sat, 05 Dec 2009) | 3 lines
use True/False instead of 1/0
fix another if-statement where it should be an elif-statement
........
r6299 | trutkin | 2009-12-05 14:11:09 -0500 (Sat, 05 Dec 2009) | 10 lines
fixes to get libardour building
- can't cast away volatile, so copy _transport_frame before emitting it.
- const_reverse_iterator::operator!=() isn't defined in this version of gcc.
- removed annoying HERE WE ARE CAAudioFile.h #warning.
- removed unnecessary include of sndfile.h in session.h.
- we don't want to set -march=i686 on the mac, so indent this if-statement so
it's only run on linux.
- DEBUG_STR() fails in the NDEBUG case, so wrap its use in an #ifndef NDEBUG
........
r6300 | trutkin | 2009-12-05 15:48:29 -0500 (Sat, 05 Dec 2009) | 2 lines
remove old scons-style CXXFLAGS_FOO in favor of just CXXFLAGS
........
r6301 | trutkin | 2009-12-05 16:01:10 -0500 (Sat, 05 Dec 2009) | 8 lines
clean up configure flags
- removed useless --aubio and --syslibs flags. The syslibs value is ignored
as we don't bring our own libraries with us anymoreand we use aubio
automatically if it's available
- added ways to turn off fpu_optimization and NLS
- fixed compiling on the mac without fpu_optimization
........
r6302 | trutkin | 2009-12-05 18:12:46 -0500 (Sat, 05 Dec 2009) | 5 lines
go back to prior uselib method for COREAUDIO, AUDIOUNIT, and GTKOSX
- fixed compile of CoreAudioSource
- re-did inclusion of coremidi_midiport.cc to depend on COREAUDIO presence
........
r6303 | trutkin | 2009-12-05 18:59:02 -0500 (Sat, 05 Dec 2009) | 5 lines
fixed compiler warnings about classes with virtual member functions, but no virtual destructor.
- Changed Metering to not use foo() = 0; to indicate it shouldn't be instantiated, but
private: Metering(), which is more idiomatic.
........
r6304 | trutkin | 2009-12-05 19:25:41 -0500 (Sat, 05 Dec 2009) | 2 lines
TOP_MENUBAR isn't used when building ardour.menus. Removed.
........
r6305 | trutkin | 2009-12-05 19:46:11 -0500 (Sat, 05 Dec 2009) | 5 lines
fix some AudioUnit compile errors
- update AudioUnit to use ChanCount
- fix some namespacing issues in audio_unit.h
........
r6306 | trutkin | 2009-12-05 20:08:48 -0500 (Sat, 05 Dec 2009) | 2 lines
make --extra-warn useful
........
r6308 | trutkin | 2009-12-05 22:59:42 -0500 (Sat, 05 Dec 2009) | 10 lines
fix compiling/linking with --coreaudio
- rearrange ardour_ui.h header in editor.cc to avoid conflict
- midi++ depends on OSX as well as COREAUDIO
- fixed including frameworks
- tweaked --extra-warn again. it's kinda redundent with --strict
- improved indentation in wscript
- use #ifdef HAVE_COREMIDI, not #if HAVE_COREMIDI. #if isn't interchangable
with #ifdef and won't work if HAVE_COREMIDI is defined with no value.
........
git-svn-id: svn://localhost/ardour2/branches/3.0@6310 d708f5d6-7413-0410-9779-e7cbd77b26cf
2009-12-05 23:35:48 -05:00
|
|
|
virtual ~OptionEditorComponent() {}
|
|
|
|
|
2009-05-13 20:13:27 -04:00
|
|
|
/** Called when a configuration parameter's value has changed.
|
|
|
|
* @param p parameter name
|
|
|
|
*/
|
|
|
|
virtual void parameter_changed (std::string const & p) = 0;
|
2007-10-11 18:07:47 -04:00
|
|
|
|
2009-05-13 20:13:27 -04:00
|
|
|
/** Called to instruct the object to set its UI state from the configuration */
|
|
|
|
virtual void set_state_from_config () = 0;
|
2005-09-25 14:42:24 -04:00
|
|
|
|
2009-05-13 20:13:27 -04:00
|
|
|
/** Called to instruct the object to add itself to an OptionEditorPage */
|
|
|
|
virtual void add_to_page (OptionEditorPage *) = 0;
|
2005-09-25 14:42:24 -04:00
|
|
|
|
2009-05-13 20:13:27 -04:00
|
|
|
void add_widget_to_page (OptionEditorPage*, Gtk::Widget*);
|
|
|
|
void add_widgets_to_page (OptionEditorPage*, Gtk::Widget*, Gtk::Widget*);
|
2012-01-22 07:28:49 -05:00
|
|
|
|
|
|
|
void set_note (std::string const &);
|
|
|
|
|
2012-10-10 19:28:07 -04:00
|
|
|
virtual Gtk::Widget& tip_widget() = 0;
|
|
|
|
|
2012-01-22 07:28:49 -05:00
|
|
|
private:
|
|
|
|
void maybe_add_note (OptionEditorPage *, int);
|
|
|
|
|
|
|
|
std::string _note;
|
2009-05-13 20:13:27 -04:00
|
|
|
};
|
2005-09-25 14:42:24 -04:00
|
|
|
|
2009-05-13 20:13:27 -04:00
|
|
|
/** A component which provides a subheading within the dialog */
|
|
|
|
class OptionEditorHeading : public OptionEditorComponent
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
OptionEditorHeading (std::string const &);
|
2005-09-25 14:42:24 -04:00
|
|
|
|
2009-05-13 20:13:27 -04:00
|
|
|
void parameter_changed (std::string const &) {}
|
|
|
|
void set_state_from_config () {}
|
|
|
|
void add_to_page (OptionEditorPage *);
|
2005-09-25 14:42:24 -04:00
|
|
|
|
2012-10-10 19:28:07 -04:00
|
|
|
Gtk::Widget& tip_widget() { return *_label; }
|
|
|
|
|
2009-05-13 20:13:27 -04:00
|
|
|
private:
|
|
|
|
Gtk::Label* _label; ///< the label used for the heading
|
|
|
|
};
|
2005-11-12 17:07:07 -05:00
|
|
|
|
2009-05-13 20:13:27 -04:00
|
|
|
/** A component which provides a box into which a subclass can put arbitrary widgets */
|
|
|
|
class OptionEditorBox : public OptionEditorComponent
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
|
|
|
|
/** Construct an OpenEditorBox */
|
|
|
|
OptionEditorBox ()
|
|
|
|
{
|
|
|
|
_box = Gtk::manage (new Gtk::VBox);
|
|
|
|
_box->set_spacing (4);
|
|
|
|
}
|
|
|
|
|
|
|
|
void parameter_changed (std::string const &) = 0;
|
|
|
|
void set_state_from_config () = 0;
|
|
|
|
void add_to_page (OptionEditorPage *);
|
|
|
|
|
2012-10-10 19:28:07 -04:00
|
|
|
Gtk::Widget& tip_widget() { return *_box->children().front().get_widget(); }
|
|
|
|
|
2009-05-13 20:13:27 -04:00
|
|
|
protected:
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2009-05-13 20:13:27 -04:00
|
|
|
Gtk::VBox* _box; ///< constituent box for subclasses to add widgets to
|
|
|
|
};
|
2007-08-06 10:19:19 -04:00
|
|
|
|
2009-05-13 20:13:27 -04:00
|
|
|
/** Base class for components which provide UI to change an option */
|
2010-05-19 21:30:35 -04:00
|
|
|
class Option : public OptionEditorComponent
|
|
|
|
{
|
2009-05-13 20:13:27 -04:00
|
|
|
public:
|
|
|
|
/** Construct an Option.
|
|
|
|
* @param i Option id (e.g. "plugins-stop-with-transport")
|
|
|
|
* @param n User-visible name (e.g. "Stop plugins when the transport is stopped")
|
|
|
|
*/
|
|
|
|
Option (std::string const & i,
|
|
|
|
std::string const & n
|
|
|
|
)
|
|
|
|
: _id (i),
|
|
|
|
_name (n)
|
|
|
|
{}
|
|
|
|
|
|
|
|
void parameter_changed (std::string const & p)
|
|
|
|
{
|
|
|
|
if (p == _id) {
|
|
|
|
set_state_from_config ();
|
|
|
|
}
|
|
|
|
}
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2009-05-13 20:13:27 -04:00
|
|
|
virtual void set_state_from_config () = 0;
|
|
|
|
virtual void add_to_page (OptionEditorPage*) = 0;
|
|
|
|
|
|
|
|
std::string id () const {
|
|
|
|
return _id;
|
|
|
|
}
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2010-11-09 01:03:51 -05:00
|
|
|
protected:
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2009-05-13 20:13:27 -04:00
|
|
|
std::string _id;
|
|
|
|
std::string _name;
|
|
|
|
};
|
2007-02-20 16:26:20 -05:00
|
|
|
|
2009-05-13 20:13:27 -04:00
|
|
|
/** Component which provides the UI to handle a boolean option using a GTK CheckButton */
|
2010-05-19 21:30:35 -04:00
|
|
|
class BoolOption : public Option
|
|
|
|
{
|
2009-05-13 20:13:27 -04:00
|
|
|
public:
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2009-05-13 20:13:27 -04:00
|
|
|
BoolOption (std::string const &, std::string const &, sigc::slot<bool>, sigc::slot<bool, bool>);
|
|
|
|
void set_state_from_config ();
|
|
|
|
void add_to_page (OptionEditorPage*);
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2011-01-04 15:52:30 -05:00
|
|
|
void set_sensitive (bool yn) {
|
|
|
|
_button->set_sensitive (yn);
|
|
|
|
}
|
2011-06-01 13:00:29 -04:00
|
|
|
|
2014-09-02 10:16:36 -04:00
|
|
|
Gtk::Widget& tip_widget() { return *_button; }
|
2012-10-10 19:28:07 -04:00
|
|
|
|
2014-09-02 10:16:36 -04:00
|
|
|
protected:
|
2009-05-15 21:22:43 -04:00
|
|
|
|
2014-09-02 10:16:36 -04:00
|
|
|
virtual void toggled ();
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2013-01-23 13:34:55 -05:00
|
|
|
sigc::slot<bool> _get; ///< slot to get the configuration variable's value
|
2009-05-13 20:13:27 -04:00
|
|
|
sigc::slot<bool, bool> _set; ///< slot to set the configuration variable's value
|
2013-01-23 13:34:55 -05:00
|
|
|
Gtk::CheckButton* _button; ///< UI button
|
|
|
|
Gtk::Label* _label; ///< label for button, so we can use markup
|
2009-05-13 20:13:27 -04:00
|
|
|
};
|
2008-08-04 18:37:24 -04:00
|
|
|
|
2014-09-02 10:16:36 -04:00
|
|
|
class RouteDisplayBoolOption : public BoolOption
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
RouteDisplayBoolOption (std::string const &, std::string const &, sigc::slot<bool>, sigc::slot<bool, bool>);
|
|
|
|
protected:
|
|
|
|
virtual void toggled ();
|
|
|
|
};
|
|
|
|
|
2014-06-29 09:45:34 -04:00
|
|
|
/** 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;
|
|
|
|
};
|
|
|
|
|
2009-05-15 21:22:43 -04:00
|
|
|
/** Component which provides the UI to handle a string option using a GTK Entry */
|
2010-05-19 21:30:35 -04:00
|
|
|
class EntryOption : public Option
|
|
|
|
{
|
2009-05-15 21:22:43 -04:00
|
|
|
public:
|
|
|
|
|
|
|
|
EntryOption (std::string const &, std::string const &, sigc::slot<std::string>, sigc::slot<bool, std::string>);
|
|
|
|
void set_state_from_config ();
|
|
|
|
void add_to_page (OptionEditorPage*);
|
2014-06-25 18:46:59 -04:00
|
|
|
void set_sensitive (bool);
|
|
|
|
void set_invalid_chars (std::string i) { _invalid = i; }
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2014-06-25 18:46:59 -04:00
|
|
|
Gtk::Widget& tip_widget() { return *_entry; }
|
2012-10-10 19:28:07 -04:00
|
|
|
|
2009-05-15 21:22:43 -04:00
|
|
|
private:
|
|
|
|
|
|
|
|
void activated ();
|
2014-06-25 18:46:59 -04:00
|
|
|
bool focus_out (GdkEventFocus*);
|
|
|
|
void filter_text (const Glib::ustring&, int*);
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2009-05-15 21:22:43 -04:00
|
|
|
sigc::slot<std::string> _get; ///< slot to get the configuration variable's value
|
|
|
|
sigc::slot<bool, std::string> _set; ///< slot to set the configuration variable's value
|
|
|
|
Gtk::Label* _label; ///< UI label
|
|
|
|
Gtk::Entry* _entry; ///< UI entry
|
2014-06-25 18:46:59 -04:00
|
|
|
std::string _invalid;
|
2009-05-15 21:22:43 -04:00
|
|
|
};
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2009-05-15 21:22:43 -04:00
|
|
|
|
2012-06-19 18:05:04 -04:00
|
|
|
/** Component which provides the UI to handle an enumerated option using a GTK ComboBox.
|
2009-05-13 20:13:27 -04:00
|
|
|
* The template parameter is the enumeration.
|
|
|
|
*/
|
|
|
|
template <class T>
|
2010-05-19 21:30:35 -04:00
|
|
|
class ComboOption : public Option
|
|
|
|
{
|
2009-05-13 20:13:27 -04:00
|
|
|
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.
|
|
|
|
*/
|
|
|
|
ComboOption (
|
|
|
|
std::string const & i,
|
|
|
|
std::string const & n,
|
|
|
|
sigc::slot<T> g,
|
|
|
|
sigc::slot<bool, T> s
|
|
|
|
)
|
|
|
|
: Option (i, n),
|
|
|
|
_get (g),
|
|
|
|
_set (s)
|
|
|
|
{
|
2013-09-26 06:47:17 -04:00
|
|
|
_label = Gtk::manage (new Gtk::Label (n + ":"));
|
2009-11-15 21:18:51 -05:00
|
|
|
_label->set_alignment (0, 0.5);
|
2013-09-26 06:47:17 -04:00
|
|
|
_combo = Gtk::manage (new Gtk::ComboBoxText);
|
2009-05-13 20:13:27 -04:00
|
|
|
_combo->signal_changed().connect (sigc::mem_fun (*this, &ComboOption::changed));
|
|
|
|
}
|
|
|
|
|
|
|
|
void set_state_from_config () {
|
|
|
|
uint32_t r = 0;
|
|
|
|
while (r < _options.size() && _get () != _options[r]) {
|
|
|
|
++r;
|
|
|
|
}
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2009-05-13 20:13:27 -04:00
|
|
|
if (r < _options.size()) {
|
|
|
|
_combo->set_active (r);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void add_to_page (OptionEditorPage* p)
|
|
|
|
{
|
|
|
|
add_widgets_to_page (p, _label, _combo);
|
|
|
|
}
|
|
|
|
|
|
|
|
/** Add an allowed value for this option.
|
|
|
|
* @param e Enumeration.
|
|
|
|
* @param o User-visible name for this value.
|
|
|
|
*/
|
|
|
|
void add (T e, std::string const & o) {
|
|
|
|
_options.push_back (e);
|
|
|
|
_combo->append_text (o);
|
|
|
|
}
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2009-11-09 15:05:18 -05:00
|
|
|
void clear () {
|
|
|
|
_combo->clear_items();
|
|
|
|
_options.clear ();
|
|
|
|
}
|
|
|
|
|
2009-05-13 20:13:27 -04:00
|
|
|
void changed () {
|
|
|
|
uint32_t const r = _combo->get_active_row_number ();
|
|
|
|
if (r < _options.size()) {
|
|
|
|
_set (_options[r]);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-11-09 23:30:08 -05:00
|
|
|
void set_sensitive (bool yn) {
|
|
|
|
_combo->set_sensitive (yn);
|
|
|
|
}
|
|
|
|
|
2012-10-10 19:28:07 -04:00
|
|
|
Gtk::Widget& tip_widget() { return *_combo; }
|
|
|
|
|
2009-05-13 20:13:27 -04:00
|
|
|
private:
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2009-05-13 20:13:27 -04:00
|
|
|
sigc::slot<T> _get;
|
|
|
|
sigc::slot<bool, T> _set;
|
|
|
|
Gtk::Label* _label;
|
|
|
|
Gtk::ComboBoxText* _combo;
|
|
|
|
std::vector<T> _options;
|
|
|
|
};
|
2005-09-25 14:42:24 -04:00
|
|
|
|
2007-02-20 16:26:20 -05:00
|
|
|
|
2012-10-23 19:32:36 -04:00
|
|
|
/** Component which provides the UI for a GTK HScale.
|
|
|
|
*/
|
|
|
|
class HSliderOption : 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.
|
|
|
|
*/
|
|
|
|
HSliderOption (
|
|
|
|
std::string const & i,
|
|
|
|
std::string const & n,
|
|
|
|
Gtk::Adjustment &adj
|
|
|
|
)
|
|
|
|
: Option (i, n)
|
|
|
|
{
|
2013-09-26 06:47:17 -04:00
|
|
|
_label = Gtk::manage (new Gtk::Label (n + ":"));
|
2012-10-23 19:32:36 -04:00
|
|
|
_label->set_alignment (0, 0.5);
|
2013-09-26 06:47:17 -04:00
|
|
|
_hscale = Gtk::manage (new Gtk::HScale(adj));
|
2013-07-06 10:10:00 -04:00
|
|
|
_adj = NULL;
|
2012-10-23 19:32:36 -04:00
|
|
|
}
|
|
|
|
|
2013-07-05 19:40:17 -04:00
|
|
|
HSliderOption (
|
|
|
|
std::string const & i,
|
|
|
|
std::string const & n,
|
|
|
|
Gtk::Adjustment *adj,
|
|
|
|
sigc::slot<float> g,
|
|
|
|
sigc::slot<bool, float> s
|
|
|
|
)
|
|
|
|
: Option (i, n)
|
|
|
|
, _get (g)
|
|
|
|
, _set (s)
|
|
|
|
, _adj (adj)
|
|
|
|
{
|
2013-09-26 06:47:17 -04:00
|
|
|
_label = Gtk::manage (new Gtk::Label (n + ":"));
|
2013-07-05 19:40:17 -04:00
|
|
|
_label->set_alignment (0, 0.5);
|
2013-09-26 06:47:17 -04:00
|
|
|
_hscale = Gtk::manage (new Gtk::HScale(*_adj));
|
2013-07-05 19:40:17 -04:00
|
|
|
_adj->signal_value_changed().connect (sigc::mem_fun (*this, &HSliderOption::changed));
|
|
|
|
}
|
|
|
|
|
|
|
|
void set_state_from_config () {
|
|
|
|
if (_adj) _adj->set_value (_get());
|
|
|
|
}
|
|
|
|
|
|
|
|
void changed () {
|
|
|
|
if (_adj) _set (_adj->get_value ());
|
|
|
|
}
|
2012-10-23 19:32:36 -04:00
|
|
|
|
|
|
|
void add_to_page (OptionEditorPage* p)
|
|
|
|
{
|
|
|
|
add_widgets_to_page (p, _label, _hscale);
|
|
|
|
}
|
|
|
|
|
|
|
|
void set_sensitive (bool yn) {
|
|
|
|
_hscale->set_sensitive (yn);
|
|
|
|
}
|
|
|
|
|
|
|
|
Gtk::Widget& tip_widget() { return *_hscale; }
|
2014-06-25 12:11:43 -04:00
|
|
|
Gtk::HScale& scale() { return *_hscale; }
|
2012-10-23 19:32:36 -04:00
|
|
|
|
|
|
|
private:
|
2013-07-05 19:40:17 -04:00
|
|
|
sigc::slot<float> _get;
|
|
|
|
sigc::slot<bool, float> _set;
|
2012-10-23 19:32:36 -04:00
|
|
|
Gtk::Label* _label;
|
|
|
|
Gtk::HScale* _hscale;
|
2013-07-05 19:40:17 -04:00
|
|
|
Gtk::Adjustment* _adj;
|
2012-10-23 19:32:36 -04:00
|
|
|
};
|
|
|
|
|
2012-10-15 11:57:35 -04:00
|
|
|
/** 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<std::string> g,
|
|
|
|
sigc::slot<bool, std::string> s
|
|
|
|
)
|
|
|
|
: Option (i, n),
|
|
|
|
_get (g),
|
|
|
|
_set (s)
|
|
|
|
{
|
2013-09-26 06:47:17 -04:00
|
|
|
_label = Gtk::manage (new Gtk::Label (n + ":"));
|
2012-10-15 11:57:35 -04:00
|
|
|
_label->set_alignment (0, 0.5);
|
2013-09-26 06:47:17 -04:00
|
|
|
_combo = Gtk::manage (new Gtk::ComboBoxText);
|
2012-10-15 11:57:35 -04:00
|
|
|
_combo->signal_changed().connect (sigc::mem_fun (*this, &ComboStringOption::changed));
|
|
|
|
}
|
|
|
|
|
|
|
|
void set_state_from_config () {
|
|
|
|
_combo->set_active_text (_get());
|
|
|
|
}
|
|
|
|
|
|
|
|
void add_to_page (OptionEditorPage* p)
|
|
|
|
{
|
|
|
|
add_widgets_to_page (p, _label, _combo);
|
|
|
|
}
|
|
|
|
|
|
|
|
/** Set the allowed strings for this option
|
|
|
|
* @param strings a vector of allowed strings
|
|
|
|
*/
|
|
|
|
void set_popdown_strings (const std::vector<std::string>& strings) {
|
|
|
|
_combo->clear_items ();
|
|
|
|
for (std::vector<std::string>::const_iterator i = strings.begin(); i != strings.end(); ++i) {
|
|
|
|
_combo->append_text (*i);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void clear () {
|
|
|
|
_combo->clear_items();
|
|
|
|
}
|
|
|
|
|
|
|
|
void changed () {
|
|
|
|
_set (_combo->get_active_text ());
|
|
|
|
}
|
|
|
|
|
|
|
|
void set_sensitive (bool yn) {
|
|
|
|
_combo->set_sensitive (yn);
|
|
|
|
}
|
|
|
|
|
|
|
|
Gtk::Widget& tip_widget() { return *_combo; }
|
|
|
|
|
|
|
|
private:
|
|
|
|
sigc::slot<std::string> _get;
|
|
|
|
sigc::slot<bool, std::string> _set;
|
|
|
|
Gtk::Label* _label;
|
|
|
|
Gtk::ComboBoxText* _combo;
|
|
|
|
};
|
|
|
|
|
|
|
|
|
2012-06-19 18:05:04 -04:00
|
|
|
/** 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<bool>,
|
|
|
|
sigc::slot<bool, bool>
|
|
|
|
);
|
|
|
|
|
|
|
|
void set_state_from_config ();
|
|
|
|
void add_to_page (OptionEditorPage *);
|
|
|
|
void changed ();
|
|
|
|
void set_sensitive (bool);
|
|
|
|
|
2012-10-10 19:28:07 -04:00
|
|
|
Gtk::Widget& tip_widget() { return *_combo; }
|
|
|
|
|
2012-06-19 18:05:04 -04:00
|
|
|
private:
|
|
|
|
|
|
|
|
sigc::slot<bool> _get;
|
|
|
|
sigc::slot<bool, bool> _set;
|
|
|
|
Gtk::Label* _label;
|
|
|
|
Gtk::ComboBoxText* _combo;
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
2009-05-13 20:13:27 -04:00
|
|
|
/** Component which provides the UI to handle an numeric option using a GTK SpinButton */
|
|
|
|
template <class T>
|
|
|
|
class SpinOption : public Option
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
/** Construct an SpinOption.
|
|
|
|
* @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.
|
|
|
|
* @param min Variable minimum value.
|
|
|
|
* @param max Variable maximum value.
|
|
|
|
* @param step Step for the spin button.
|
|
|
|
* @param page Page step for the spin button.
|
2009-05-15 21:22:43 -04:00
|
|
|
* @param unit Unit name.
|
|
|
|
* @param scale Scaling factor (such that for a value x in the spinbutton, x * scale is written to the config)
|
2009-05-13 20:13:27 -04:00
|
|
|
*/
|
|
|
|
SpinOption (
|
|
|
|
std::string const & i,
|
|
|
|
std::string const & n,
|
|
|
|
sigc::slot<T> g,
|
|
|
|
sigc::slot<bool, T> s,
|
|
|
|
T min,
|
|
|
|
T max,
|
|
|
|
T step,
|
2009-05-15 21:22:43 -04:00
|
|
|
T page,
|
|
|
|
std::string const & unit = "",
|
|
|
|
float scale = 1
|
2009-05-13 20:13:27 -04:00
|
|
|
)
|
|
|
|
: Option (i, n),
|
|
|
|
_get (g),
|
2009-05-15 21:22:43 -04:00
|
|
|
_set (s),
|
|
|
|
_scale (scale)
|
2009-05-13 20:13:27 -04:00
|
|
|
{
|
2013-09-26 06:47:17 -04:00
|
|
|
_label = Gtk::manage (new Gtk::Label (n + ":"));
|
2009-11-15 21:18:51 -05:00
|
|
|
_label->set_alignment (0, 0.5);
|
2009-05-15 21:22:43 -04:00
|
|
|
|
2013-09-26 06:47:17 -04:00
|
|
|
_spin = Gtk::manage (new Gtk::SpinButton);
|
2009-05-13 20:13:27 -04:00
|
|
|
_spin->set_range (min, max);
|
|
|
|
_spin->set_increments (step, page);
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2013-09-26 06:47:17 -04:00
|
|
|
_box = Gtk::manage (new Gtk::HBox);
|
2009-05-15 21:22:43 -04:00
|
|
|
_box->pack_start (*_spin, true, true);
|
|
|
|
_box->set_spacing (4);
|
|
|
|
if (unit.length()) {
|
2013-09-26 06:47:17 -04:00
|
|
|
_box->pack_start (*Gtk::manage (new Gtk::Label (unit)), false, false);
|
2009-05-15 21:22:43 -04:00
|
|
|
}
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2009-05-13 20:13:27 -04:00
|
|
|
_spin->signal_value_changed().connect (sigc::mem_fun (*this, &SpinOption::changed));
|
|
|
|
}
|
|
|
|
|
|
|
|
void set_state_from_config ()
|
|
|
|
{
|
2009-05-15 21:22:43 -04:00
|
|
|
_spin->set_value (_get () / _scale);
|
2009-05-13 20:13:27 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
void add_to_page (OptionEditorPage* p)
|
|
|
|
{
|
2009-05-15 21:22:43 -04:00
|
|
|
add_widgets_to_page (p, _label, _box);
|
2009-05-13 20:13:27 -04:00
|
|
|
}
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2009-05-13 20:13:27 -04:00
|
|
|
void changed ()
|
|
|
|
{
|
2009-05-15 21:22:43 -04:00
|
|
|
_set (static_cast<T> (_spin->get_value ()) * _scale);
|
2009-05-13 20:13:27 -04:00
|
|
|
}
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2012-10-10 19:28:07 -04:00
|
|
|
Gtk::Widget& tip_widget() { return *_spin; }
|
|
|
|
|
2009-05-13 20:13:27 -04:00
|
|
|
private:
|
|
|
|
sigc::slot<T> _get;
|
|
|
|
sigc::slot<bool, T> _set;
|
2009-05-15 21:22:43 -04:00
|
|
|
float _scale;
|
2009-05-13 20:13:27 -04:00
|
|
|
Gtk::Label* _label;
|
2009-05-15 21:22:43 -04:00
|
|
|
Gtk::HBox* _box;
|
2009-05-13 20:13:27 -04:00
|
|
|
Gtk::SpinButton* _spin;
|
|
|
|
};
|
2008-10-09 10:15:45 -04:00
|
|
|
|
2010-05-19 21:30:35 -04:00
|
|
|
class FaderOption : public Option
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
|
|
|
|
FaderOption (std::string const &, std::string const &, sigc::slot<ARDOUR::gain_t> g, sigc::slot<bool, ARDOUR::gain_t> s);
|
|
|
|
void set_state_from_config ();
|
|
|
|
void add_to_page (OptionEditorPage *);
|
|
|
|
|
2012-10-10 19:28:07 -04:00
|
|
|
Gtk::Widget& tip_widget() { return *_db_slider; }
|
|
|
|
|
2010-05-19 21:30:35 -04:00
|
|
|
private:
|
|
|
|
void db_changed ();
|
2011-06-01 13:00:29 -04:00
|
|
|
|
2010-05-19 21:30:35 -04:00
|
|
|
Gtk::Adjustment _db_adjustment;
|
|
|
|
Gtkmm2ext::HSliderController* _db_slider;
|
|
|
|
Gtk::Entry _db_display;
|
|
|
|
Gtk::Label _label;
|
|
|
|
Gtk::HBox _box;
|
2012-01-27 17:58:52 -05:00
|
|
|
Gtk::VBox _fader_centering_box;
|
2010-05-19 21:30:35 -04:00
|
|
|
sigc::slot<ARDOUR::gain_t> _get;
|
|
|
|
sigc::slot<bool, ARDOUR::gain_t> _set;
|
|
|
|
};
|
|
|
|
|
2010-12-01 15:49:22 -05:00
|
|
|
class ClockOption : public Option
|
|
|
|
{
|
|
|
|
public:
|
2012-11-13 15:29:28 -05:00
|
|
|
ClockOption (std::string const &, std::string const &, sigc::slot<std::string>, sigc::slot<bool, std::string>);
|
2010-12-01 15:49:22 -05:00
|
|
|
void set_state_from_config ();
|
|
|
|
void add_to_page (OptionEditorPage *);
|
|
|
|
void set_session (ARDOUR::Session *);
|
|
|
|
|
2012-10-10 19:28:07 -04:00
|
|
|
Gtk::Widget& tip_widget() { return _clock; }
|
2012-11-11 17:20:40 -05:00
|
|
|
AudioClock& clock() { return _clock; }
|
2012-10-10 19:28:07 -04:00
|
|
|
|
2010-12-01 15:49:22 -05:00
|
|
|
private:
|
2012-11-09 12:27:30 -05:00
|
|
|
void save_clock_time ();
|
2010-12-01 15:49:22 -05:00
|
|
|
Gtk::Label _label;
|
|
|
|
AudioClock _clock;
|
2012-11-13 15:29:28 -05:00
|
|
|
sigc::slot<std::string> _get;
|
|
|
|
sigc::slot<bool, std::string> _set;
|
|
|
|
ARDOUR::Session *_session;
|
2010-12-01 15:49:22 -05:00
|
|
|
};
|
|
|
|
|
2011-11-04 11:05:49 -04:00
|
|
|
class DirectoryOption : public Option
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
DirectoryOption (std::string const &, std::string const &, sigc::slot<std::string>, sigc::slot<bool, std::string>);
|
|
|
|
|
|
|
|
void set_state_from_config ();
|
|
|
|
void add_to_page (OptionEditorPage *);
|
|
|
|
|
2012-10-10 19:28:07 -04:00
|
|
|
Gtk::Widget& tip_widget() { return _file_chooser; }
|
|
|
|
|
2011-11-04 11:05:49 -04:00
|
|
|
private:
|
|
|
|
void file_set ();
|
2011-11-19 07:01:52 -05:00
|
|
|
void current_folder_set ();
|
2011-11-04 11:05:49 -04:00
|
|
|
|
|
|
|
sigc::slot<std::string> _get; ///< slot to get the configuration variable's value
|
|
|
|
sigc::slot<bool, std::string> _set; ///< slot to set the configuration variable's value
|
|
|
|
Gtk::FileChooserButton _file_chooser;
|
|
|
|
};
|
|
|
|
|
2009-05-13 20:13:27 -04:00
|
|
|
/** 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.
|
|
|
|
*/
|
|
|
|
class OptionEditorPage
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
OptionEditorPage (Gtk::Notebook&, std::string const &);
|
2005-09-25 14:42:24 -04:00
|
|
|
|
2009-05-13 20:13:27 -04:00
|
|
|
Gtk::VBox box;
|
|
|
|
Gtk::Table table;
|
|
|
|
std::list<OptionEditorComponent*> components;
|
|
|
|
};
|
2005-09-25 14:42:24 -04:00
|
|
|
|
2009-05-13 20:13:27 -04:00
|
|
|
/** The OptionEditor dialog base class */
|
2011-11-18 19:56:35 -05:00
|
|
|
class OptionEditor : public ArdourWindow
|
2009-05-13 20:13:27 -04:00
|
|
|
{
|
|
|
|
public:
|
|
|
|
OptionEditor (ARDOUR::Configuration *, std::string const &);
|
|
|
|
~OptionEditor ();
|
2005-09-25 14:42:24 -04:00
|
|
|
|
2009-05-15 17:36:37 -04:00
|
|
|
void add_option (std::string const &, OptionEditorComponent *);
|
2014-12-15 12:32:41 -05:00
|
|
|
void add_page (std::string const &, Gtk::Widget& page_widget);
|
|
|
|
|
2011-02-17 13:53:31 -05:00
|
|
|
void set_current_page (std::string const &);
|
|
|
|
|
2009-05-13 20:13:27 -04:00
|
|
|
protected:
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2011-01-04 15:52:30 -05:00
|
|
|
virtual void parameter_changed (std::string const &);
|
2011-06-01 13:00:29 -04:00
|
|
|
|
2009-05-13 20:13:27 -04:00
|
|
|
ARDOUR::Configuration* _config;
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2009-05-13 20:13:27 -04:00
|
|
|
private:
|
2009-05-15 21:22:43 -04:00
|
|
|
|
2009-12-19 15:26:31 -05:00
|
|
|
PBD::ScopedConnection config_connection;
|
2005-09-25 14:42:24 -04:00
|
|
|
|
2009-05-13 20:13:27 -04:00
|
|
|
Gtk::Notebook _notebook;
|
|
|
|
std::map<std::string, OptionEditorPage*> _pages;
|
2005-09-25 14:42:24 -04:00
|
|
|
};
|
|
|
|
|
|
|
|
#endif /* __gtk_ardour_option_editor_h__ */
|
|
|
|
|
|
|
|
|