option_editor.h

Go to the documentation of this file.

/*
    Copyright (C) 2009 Paul Davis

    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.

*/

#ifndef __gtk_ardour_option_editor_h__
#define __gtk_ardour_option_editor_h__

#include <gtkmm/notebook.h>
#include <gtkmm/checkbutton.h>
#include <gtkmm/comboboxtext.h>
#include <gtkmm/spinbutton.h>
#include <gtkmm/table.h>
#include "gtkmm2ext/slider_controller.h"
#include "ardour_window.h"
#include "audio_clock.h"
#include "ardour/types.h"

namespace PBD {
        class Configuration;
}

class OptionEditorPage;

class OptionEditorComponent
{
public:
        virtual ~OptionEditorComponent() {}

        virtual void parameter_changed (std::string const & p) = 0;

        virtual void set_state_from_config () = 0;

        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 set_note (std::string const &);

        virtual Gtk::Widget& tip_widget() = 0;

private:
        void maybe_add_note (OptionEditorPage *, int);
        
        std::string _note;
};

class OptionEditorHeading : public OptionEditorComponent
{
public:
        OptionEditorHeading (std::string const &);

        void parameter_changed (std::string const &) {}
        void set_state_from_config () {}
        void add_to_page (OptionEditorPage *);

        Gtk::Widget& tip_widget() { return *_label; }

private:
        Gtk::Label* _label; 
};

class OptionEditorBox : public OptionEditorComponent
{
public:

        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 *);

        Gtk::Widget& tip_widget() { return *_box->children().front().get_widget(); }

protected:

        Gtk::VBox* _box; 
};

class Option : public OptionEditorComponent
{
public:
        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 ();
                }
        }

        virtual void set_state_from_config () = 0;
        virtual void add_to_page (OptionEditorPage*) = 0;

        std::string id () const {
                return _id;
        }

protected:

        std::string _id;
        std::string _name;
};

class BoolOption : public Option
{
public:

        BoolOption (std::string const &, std::string const &, sigc::slot<bool>, sigc::slot<bool, bool>);
        void set_state_from_config ();
        void add_to_page (OptionEditorPage*);

        void set_sensitive (bool yn) {
                _button->set_sensitive (yn);
        }

        Gtk::Widget& tip_widget() { return *_button; }

protected:

        virtual void toggled ();

        sigc::slot<bool>       _get; 
        sigc::slot<bool, bool> _set;  
        Gtk::CheckButton*      _button; 
        Gtk::Label*            _label; 
};

class RouteDisplayBoolOption : public BoolOption
{
public:
        RouteDisplayBoolOption (std::string const &, std::string const &, sigc::slot<bool>, sigc::slot<bool, bool>);
protected:
        virtual void toggled ();
};

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;
};

class EntryOption : public Option
{
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*);
        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<std::string> _get; 
        sigc::slot<bool, std::string> _set;  
        Gtk::Label* _label; 
        Gtk::Entry* _entry; 
        std::string _invalid;
};


template <class T>
class ComboOption : public Option
{
public:

        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)
        {
                _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 () {
                uint32_t r = 0;
                while (r < _options.size() && _get () != _options[r]) {
                        ++r;
                }

                if (r < _options.size()) {
                        _combo->set_active (r);
                }
        }

        void add_to_page (OptionEditorPage* p)
        {
                add_widgets_to_page (p, _label, _combo);
        }

        void add (T e, std::string const & o) {
                _options.push_back (e);
                _combo->append_text (o);
        }

        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<T> _get;
        sigc::slot<bool, T> _set;
        Gtk::Label* _label;
        Gtk::ComboBoxText* _combo;
        std::vector<T> _options;
};


class HSliderOption : public Option
{
public:

        HSliderOption (
                std::string const & i,
                std::string const & n,
                Gtk::Adjustment &adj
                )
                : Option (i, n)
        {
                _label = Gtk::manage (new Gtk::Label (n + ":"));
                _label->set_alignment (0, 0.5);
                _hscale = Gtk::manage (new Gtk::HScale(adj));
                _adj = NULL;
        }

        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)
        {
                _label = Gtk::manage (new Gtk::Label (n + ":"));
                _label->set_alignment (0, 0.5);
                _hscale = Gtk::manage (new Gtk::HScale(*_adj));
                _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 ());
        }

        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; }
        Gtk::HScale& scale() { return *_hscale; }

private:
        sigc::slot<float> _get;
        sigc::slot<bool, float> _set;
        Gtk::Label* _label;
        Gtk::HScale* _hscale;
        Gtk::Adjustment* _adj;
};

class ComboStringOption : public Option
{
public:

        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)
        {
                _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, &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);
        }

        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;
};


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);

        Gtk::Widget& tip_widget() { return *_combo; }

private:

        sigc::slot<bool> _get;
        sigc::slot<bool, bool> _set;
        Gtk::Label* _label;
        Gtk::ComboBoxText* _combo;
};



template <class T>
class SpinOption : public Option
{
public:
        SpinOption (
                std::string const & i,
                std::string const & n,
                sigc::slot<T> g,
                sigc::slot<bool, T> s,
                T min,
                T max,
                T step,
                T page,
                std::string const & unit = "",
                float scale = 1,
                unsigned digits = 0
                )
                : Option (i, n),
                  _get (g),
                  _set (s),
                  _scale (scale)
        {
                _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 () / _scale);
        }

        void add_to_page (OptionEditorPage* p)
        {
                add_widgets_to_page (p, _label, _box);
        }

        void changed ()
        {
                _set (static_cast<T> (_spin->get_value ()) * _scale);
        }

        Gtk::Widget& tip_widget() { return *_spin; }

private:
        sigc::slot<T> _get;
        sigc::slot<bool, T> _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<ARDOUR::gain_t> g, sigc::slot<bool, ARDOUR::gain_t> s);
        void set_state_from_config ();
        void add_to_page (OptionEditorPage *);

        Gtk::Widget& tip_widget() { return *_db_slider; }

private:
        void db_changed ();

        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<ARDOUR::gain_t> _get;
        sigc::slot<bool, ARDOUR::gain_t> _set;
};

class ClockOption : public Option
{
public:
        ClockOption (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 *);
        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<std::string> _get;
        sigc::slot<bool, std::string> _set;
        ARDOUR::Session *_session;
};

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 *);

        Gtk::Widget& tip_widget() { return _file_chooser; }

private:
        void selection_changed ();
        
        sigc::slot<std::string> _get; 
        sigc::slot<bool, std::string> _set;  
        Gtk::FileChooserButton _file_chooser;
};

class OptionEditorPage
{
public:
        OptionEditorPage (Gtk::Notebook&, std::string const &);

        Gtk::VBox box;
        Gtk::Table table;
        std::list<OptionEditorComponent*> components;
};

class OptionEditor : public ArdourWindow
{
public:
        OptionEditor (PBD::Configuration *, std::string const &);
        ~OptionEditor ();

        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:

        virtual void parameter_changed (std::string const &);
        
        PBD::Configuration* _config;

private:

        PBD::ScopedConnection config_connection;

        Gtk::Notebook _notebook;
        std::map<std::string, OptionEditorPage*> _pages;
};

#endif /* __gtk_ardour_option_editor_h__ */