Loading...
Searching...
No Matches
gx_main_window.h
Go to the documentation of this file.
/*
* Copyright (C) 2009, 2010 Hermann Meyer, James Warden, Andreas Degert
* Copyright (C) 2011 Pete Shorthose
*
* 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
* ---------------------------------------------------------------------------
*
* This is the gx_head GUI main class
*
* ----------------------------------------------------------------------------
*/
/****************************************************************
** class GxTheme
*/
class GxTheme {
private:
gx_system::CmdlineOptions* options;
Glib::RefPtr<Gtk::CssProvider> css_provider;
Glib::RefPtr<Gtk::CssProvider> css_show_values;
Glib::RefPtr<Gtk::StyleContext> style_context;
#ifndef NDEBUG
Gtk::Window *window;
int window_x, window_y;
void reload_css_post();
#endif
public:
GxTheme() {}
void init(gx_system::CmdlineOptions *options_);
bool set_new_skin(const Glib::ustring& skin_name);
void update_show_values();
#ifndef NDEBUG
void reload_css();
void set_window(Gtk::Window *window_) { window = window_; }
#endif
};
/****************************************************************
** Actions:
** class ToggleAction
** class RadioAction
** template class UiToggleAction
*/
class ToggleAction: public Gio::SimpleAction {
protected:
ToggleAction(const Glib::ustring& name, bool state)
: Gio::SimpleAction(name, Glib::Variant<bool>::create(state)) {}
public:
static Glib::RefPtr<ToggleAction> create(const Glib::ustring& name, bool state=false) {
return Glib::RefPtr<ToggleAction>(new ToggleAction(name, state)); }
Glib::SignalProxyProperty signal_toggled() { return property_state().signal_changed(); }
bool get_active() const { bool v; get_state(v); return v; }
void set_active(bool v);
};
class RadioAction: public Gio::SimpleAction {
protected:
RadioAction(const Glib::ustring& name);
public:
static Glib::RefPtr<RadioAction> create(const Glib::ustring& name) {
return Glib::RefPtr<RadioAction>(new RadioAction(name)); }
bool get_current_value() const { int v; get_state(v); return v; }
void set_current_value(int v) { change_state(v); }
};
template <class T>
class UiToggleAction: public ToggleAction {
private:
gx_engine::GxMachineBase& machine;
std::string id;
void on_toggled();
protected:
UiToggleAction(
gx_engine::GxMachineBase& machine_, const std::string& id,
const Glib::ustring& name, bool is_active=false);
~UiToggleAction();
public:
static Glib::RefPtr<UiToggleAction> create(
gx_engine::GxMachineBase& machine, const std::string& id,
const Glib::ustring& name, bool is_active=false) {
return Glib::RefPtr<UiToggleAction>(
new UiToggleAction(machine, id, name, is_active));
}
};
typedef UiToggleAction<bool> UiBoolToggleAction;
/****************************************************************
** class UIManager
*/
class UIManager {
public:
typedef std::function<bool(const Glib::ustring&, Glib::RefPtr<Gio::Menu>&, int, int)> search_func;
private:
Glib::RefPtr<Gio::Menu> menu;
Glib::RefPtr<Gtk::AccelGroup> accelgroup;
Glib::RefPtr<Gio::SimpleActionGroup> actiongroup;
Gtk::MenuBar *menubar;
void set_accelerators_from_menu(Glib::RefPtr<Gio::Menu>& menu);
bool foreach_menu_(Glib::RefPtr<Gio::Menu>& menu, search_func& func, int& startpos);
public:
UIManager(const std::string& file, Gtk::MenuBar *bar);
Glib::RefPtr<Gtk::AccelGroup>& get_accel_group() { return accelgroup; }
Glib::RefPtr<Gio::SimpleActionGroup>& get_action_group() { return actiongroup; }
void insert_action_group(Glib::RefPtr<Gio::SimpleActionGroup>& group) { actiongroup = group; }
void set_accelerators_from_menu() { set_accelerators_from_menu(menu); }
bool foreach_menu(search_func func) { int pos = 0; return foreach_menu_(menu, func, pos); }
Glib::RefPtr<Gio::SimpleAction> add_action(const Glib::ustring& action);
Glib::RefPtr<Gio::SimpleAction> add_action(const Glib::ustring& action, sigc::slot<void()> slot);
Glib::RefPtr<ToggleAction> add_toggle_action(const Glib::ustring& action, bool state = false);
Glib::RefPtr<RadioAction> add_radio_action(const Glib::ustring& action);
Glib::RefPtr<UiBoolToggleAction> add_ui_bool_action(
gx_engine::GxMachineBase& machine, const std::string& id,
const Glib::ustring& name, bool is_active=false);
static void add_accelerator(Glib::RefPtr<Gtk::AccelGroup>& group,
Glib::RefPtr<Gio::Action> action,
const Glib::ustring& accelerator,
Glib::VariantBase& target);
void add_accelerator(Glib::RefPtr<Gio::Action> action, Glib::VariantBase& target,
const Glib::ustring& accelerator);
Glib::RefPtr<Gio::Menu> get_linked_menu(const Glib::ustring& action);
Gtk::MenuItem *find_item(const Glib::ustring& action);
bool remove_item(const Glib::ustring& action);
static void set_widget_action(Gtk::Widget *w, const Glib::ustring& action);
static void set_widget_action(Gtk::Widget *w, const Glib::RefPtr<Gio::Action>& action);
};
/****************************************************************
** class KeySwitcher
*/
class KeySwitcher: public sigc::trackable {
private:
gx_engine::GxMachineBase& machine;
sigc::slot<void, const Glib::ustring&, const Glib::ustring&> display;
sigc::connection key_timeout;
Glib::ustring last_bank_key;
private:
void display_empty(const Glib::ustring& bank, const Glib::ustring& preset);
bool display_selected_bank();
bool display_current();
public:
KeySwitcher(gx_engine::GxMachineBase& machine_,
sigc::slot<void, const Glib::ustring&, const Glib::ustring&> display_)
: machine(machine_), display(display_) {}
bool process_bank_key(int key);
bool process_preset_key(int key);
void display_key_error();
void deactivate();
static char idx_to_char(int idx);
static int key_offset_to_idx(int offset);
static char bank_idx_to_char(int idx, int bank_size);
static int key_offset_to_bank_idx(int offset, int bank_size);
static int next_idx(int idx = -1);
};
/****************************************************************
** class Liveplay
*/
class Liveplay: public sigc::trackable {
private:
Glib::RefPtr<gx_gui::GxBuilder> bld;
gx_engine::GxMachineBase &machine;
const GxActions& actions;
bool use_composite;
Glib::RefPtr<Gtk::Adjustment> brightness_adj;
Glib::RefPtr<Gtk::Adjustment> background_adj;
KeySwitcher keyswitch;
sigc::connection midi_conn;
Gtk::Window *window;
sigc::connection mouse_hide_conn;
//
Gtk::Image *bypass_image;
Gtk::Image *mute_image;
Gtk::Label *liveplay_bank;
Gtk::Label *liveplay_preset;
Gtk::Widget *liveplay_canvas;
Gxw::HSlider *brightness_slider;
Gtk::Box *brightness_box;
Gxw::HSlider *background_slider;
Gtk::ToggleButton *liveplay_exit;
Gtk::Grid *midictrl_table;
Gxw::RackTuner *tuner;
private:
void add_midi_elements();
bool on_delete(GdkEventAny *ev);
void on_brightness_changed();
void on_background_changed();
bool transparent_draw(const Cairo::RefPtr<Cairo::Context> &cr);
bool window_draw(const Cairo::RefPtr<Cairo::Context> &cr);
void on_realize();
void on_engine_state_change(gx_engine::GxEngineState state);
void on_selection_done(bool v);
void on_selection_changed();
static bool on_keyboard_preset_select(
GtkAccelGroup *accel_group, GObject *acceleratable,
guint keyval, GdkModifierType modifier, Liveplay& self);
static bool on_keyboard_toggle_mute(
GtkAccelGroup *accel_group, GObject *acceleratable,
guint keyval, GdkModifierType modifier, Liveplay& self);
static bool on_keyboard_toggle_bypass(
GtkAccelGroup *accel_group, GObject *acceleratable,
guint keyval, GdkModifierType modifier, Liveplay& self);
static bool on_keyboard_arrows(
GtkAccelGroup *accel_group, GObject *acceleratable,
guint keyval, GdkModifierType modifier, Liveplay& self);
static bool on_keyboard_mode_switch(
GtkAccelGroup *accel_group, GObject *acceleratable,
guint keyval, GdkModifierType modifier, Liveplay& self);
bool pointer_motion(GdkEventMotion* event);
void display(const Glib::ustring& bank, const Glib::ustring& preset);
void set_display_state(TunerSwitcher::SwitcherState s);
public:
Liveplay(const gx_system::CmdlineOptions& options, gx_engine::GxMachineBase& machine,
const std::string& fname, const GxActions& actions,
Glib::RefPtr<Gio::SimpleActionGroup>& group);
~Liveplay();
void on_live_play(Glib::RefPtr<ToggleAction> act);
void display_tuner(bool v);
Gxw::RackTuner& get_tuner() { return *tuner; }
};
/****************************************************************
** class DragIcon
*/
class DragIcon {
private:
enum { gradient_length = 60 };
Gtk::Window *window;
Glib::RefPtr<Gdk::Pixbuf> drag_icon_pixbuf;
private:
bool icon_draw(const Cairo::RefPtr<Cairo::Context> &cr);
void create_drag_icon_pixbuf(const PluginUI& plugin, Glib::RefPtr<Gdk::Visual> rgba, gx_system::CmdlineOptions& options);
bool window_draw(const Cairo::RefPtr<Cairo::Context> &cr, Gtk::OffscreenWindow& w);
public:
DragIcon(PluginUI& plugin, Glib::RefPtr<Gdk::DragContext> context, gx_system::CmdlineOptions& options, int xoff=0);
~DragIcon();
};
/****************************************************************
** class RackBox, class MiniRackBox
*/
class MainWindow;
class RackContainer;
class MiniRackBox;
class RackBox: public Gtk::VBox {
friend class PluginUI;
private:
PluginUI& plugin;
PluginDict& plugin_dict;
sigc::connection anim_tag;
bool compress;
bool delete_button;
Gxw::PaintBox mbox;
MiniRackBox* minibox;
Gtk::Widget *fbox;
std::string target;
int anim_height;
int anim_step;
DragIcon *drag_icon;
int target_height;
Gxw::PaintBox box;
Gxw::Switch on_off_switch;
private:
static void set_paintbox(Gxw::PaintBox& pb, PluginType tp);
static void set_paintbox_unit(Gxw::PaintBox& pb, const PluginUI& plugin);
static void set_paintbox_unit_shrink(Gxw::PaintBox& pb, PluginType tp);
static Gtk::Widget *make_label(const PluginUI& plugin, gx_system::CmdlineOptions& options, bool useshort=true);
static Gtk::Widget *make_bar(int left=4, int right=4, bool sens=false);
Gtk::Widget *wrap_bar(int left=4, int right=4, bool sens=false);
void init_dnd();
void enable_drag(bool v);
void on_my_drag_begin(const Glib::RefPtr<Gdk::DragContext>& context);
bool animate_create();
bool on_my_leave_out(GdkEventCrossing *focus);
bool on_my_enter_in(GdkEventCrossing *focus);
void on_my_drag_end(const Glib::RefPtr<Gdk::DragContext>& context);
bool on_my_drag_failed(const Glib::RefPtr<Gdk::DragContext>& context, Gtk::DragResult result);
void on_my_drag_data_get(const Glib::RefPtr<Gdk::DragContext>& context, Gtk::SelectionData& selection, int info, int timestamp);
void vis_switch(Gtk::Widget& a, Gtk::Widget& b);
void set_visibility(bool v);
Gtk::Button *make_expand_button(bool expand);
Gtk::Button *make_preset_button();
Gtk::HBox *make_full_box(gx_system::CmdlineOptions& options);
bool has_delete() const { return delete_button; }
void do_expand();
public:
RackBox(PluginUI& plugin, PluginDict& plugin_dict, Gtk::Widget* bare=0);
static Gtk::Widget *create_drag_widget(const PluginUI& plugin, gx_system::CmdlineOptions& options);
RackContainer *get_parent();
bool can_compress() { return compress; }
friend class MiniRackBox;
const char *get_id() const;
void set_config_mode(bool mode);
void swtch(bool mini);
void pack(Gtk::Widget *mainbox, Gtk::Widget *minibox);
void animate_insert();
static Gtk::Widget *create_icon_widget(const PluginUI& plugin, gx_system::CmdlineOptions& options);
void set_position(int pos, int post_pre);
bool compare_position(int pos, int post_pre);
void display(bool v, bool animate);
bool get_plug_visible();
};
class MiniRackBox: public Gtk::HBox {
private:
static Glib::RefPtr<Gtk::SizeGroup> szg_label;
Gtk::EventBox evbox;
Gtk::HBox mconbox;
Gtk::Button *mb_expand_button;
Gtk::Widget *mb_delete_button;
Gtk::Button *preset_button;
Gxw::Switch on_off_switch;
bool on_my_leave_out(GdkEventCrossing *focus);
bool on_my_enter_in(GdkEventCrossing *focus);
sigc::connection evbox_button;
private:
Gtk::Widget *make_delete_button(RackBox& rb);
public:
MiniRackBox(RackBox& rb, gx_system::CmdlineOptions& options);
void set_config_mode(bool mode, PluginUI& plugin);
void pack(Gtk::Widget *w);
};
/****************************************************************
** class RackContainer
*/
class PluginDict;
class RackContainer: public Gtk::VBox {
private:
PluginDict& plugin_dict;
int in_drag;
int count;
std::vector<std::string> targets;
std::vector<std::string> othertargets;
sigc::connection highlight_connection;
sigc::connection autoscroll_connection;
private:
using Gtk::VBox::add;
bool drag_highlight_draw(const Cairo::RefPtr<Cairo::Context>&, int y0);
void find_index(int x, int y, string* before, int *ypos);
bool check_targets(const std::vector<std::string>& tgts1, const std::vector<std::string>& tgts2);
virtual bool on_drag_motion(const Glib::RefPtr<Gdk::DragContext>& context, int x, int y, guint timestamp);
virtual void on_drag_leave(const Glib::RefPtr<Gdk::DragContext>& context, guint timestamp);
virtual void on_drag_data_received(const Glib::RefPtr<Gdk::DragContext>& context, int x, int y, const Gtk::SelectionData& data, guint info, guint timestamp);
virtual void on_add(Widget* ch);
bool scroll_timeout();
bool scrollother_timeout();
public:
typedef Glib::ListHandle<const RackBox*> rackbox_const_list;
typedef Glib::ListHandle<RackBox*> rackbox_list;
RackContainer(PluginDict& plugin_dict);
rackbox_list get_children() {
return rackbox_list(
gtk_container_get_children(GTK_CONTAINER(gobj())),
Glib::OWNERSHIP_SHALLOW);
}
rackbox_const_list get_children() const {
return rackbox_const_list(
gtk_container_get_children(const_cast<GtkContainer*>(GTK_CONTAINER(gobj()))),
Glib::OWNERSHIP_SHALLOW);
}
void add(RackBox& r, int pos=-1);
void ensure_visible(RackBox& child);
void renumber();
double stop_at_bottom(double off, double step_size, double pagesize);
double stop_at_top(double off, double step_size);
void set_list_targets(const std::vector<Gtk::TargetEntry>& listTargets,
const std::vector<std::string>& targets_,
const std::vector<std::string>& othertargets_);
void set_child_count(int n);
void change_child_count(int n) { set_child_count(count + n); }
inline void reorder(const std::string& name, const std::string& before);
};
/****************************************************************
** class PluginUI
*/
class PluginUI: public sigc::trackable {
friend class PluginDict;
friend class RackContainer;
private:
Glib::RefPtr<ToggleAction> action;
// data for ToolPalette entry
Gtk::ToolItemGroup *group;
Gtk::ToolItem *toolitem;
RackBox *rackbox;
bool hidden;
bool active;
sigc::signal<void(bool)> output_widget_state;
bool output_widgets_active;
Glib::ustring tooltip;
const char *shortname;
private:
void on_action_toggled();
bool animate_vanish();
protected:
PluginUI(PluginDict& plugin_dict, const char* id_, const Glib::ustring& tooltip_="");
virtual ~PluginUI();
public:
gx_engine::Plugin *plugin;
PluginDict& plugin_dict;
PluginType get_type() const {
return (plugin->get_pdef()->flags & PGN_STEREO) ? PLUGIN_TYPE_STEREO : PLUGIN_TYPE_MONO;
}
bool has_gui() const {
PluginDef const * const pdef = plugin->get_pdef();
return pdef->flags & PGN_GUI || pdef->load_ui;
}
const char *get_id() const { return plugin->get_pdef()->id; }
const char *get_name() const { return plugin->get_pdef()->name; }
void activate(bool animate);
void decativate(bool animate);
void set_action(Glib::RefPtr<ToggleAction>& act);
void set_active(bool v) { if (action) action->set_active(v); }
Glib::RefPtr<ToggleAction> get_action() { return action; }
static bool is_registered(gx_engine::GxMachineBase& m, const char *name);
virtual void on_plugin_preset_popup();
inline const char *get_category() {
const char *cat = plugin->get_pdef()->category;
return (cat && *cat) ? cat : N_("External");
}
inline const char *get_shortname() const {
const char *name = shortname;
if (!name) {
name = plugin->get_pdef()->shortname;
}
if (!name || !*name) {
name = get_name();
}
return name;
}
void update_rackbox();
void compress(bool state);
void hide(bool animate);
void show(bool animate);
void set_config_mode(bool state);
friend bool plugins_by_name_less(PluginUI *a, PluginUI *b);
void on_ti_drag_begin(const Glib::RefPtr<Gdk::DragContext>& context);
void on_ti_drag_end(const Glib::RefPtr<Gdk::DragContext>& context);
void on_ti_drag_data_get(const Glib::RefPtr<Gdk::DragContext>& context, Gtk::SelectionData& selection, int info, int timestamp);
void on_ti_drag_data_delete(const Glib::RefPtr<Gdk::DragContext>& context);
bool on_ti_button_press(GdkEventButton *ev);
bool on_my_leave_out(GdkEventCrossing *focus);
bool on_my_enter_in(GdkEventCrossing *focus);
void add_toolitem(Gtk::ToolItemGroup *gw);
void activate(bool animate, const string& before);
void deactivate(bool animate);
bool get_update_cond();
void set_update_state(bool state);
void on_state_change();
void remove(bool animate);
void dispose_rackbox();
bool on_rack_handle_press(GdkEventButton* ev);
Glib::ustring get_displayname(bool useshort) const;
sigc::signal<void(bool)> *get_output_widget_state() { return &output_widget_state; }
};
bool plugins_by_name_less(PluginUI *a, PluginUI *b);
inline const char *RackBox::get_id() const { return plugin.get_id(); }
inline bool RackBox::get_plug_visible() { return plugin.plugin->get_plug_visible(); }
/****************************************************************
** class PluginDict
*/
class PluginDict: private std::map<std::string, PluginUI*> {
private:
RackContainer monorackcontainer;
RackContainer stereorackcontainer;
std::map<Glib::ustring, Gtk::ToolItemGroup*> groupmap;
std::vector<std::string> monotargets;
std::vector<std::string> stereotargets;
gx_gui::StackBoxBuilder& boxbuilder;
gx_engine::GxMachineBase& machine;
gx_system::CmdlineOptions& options;
Gtk::ToolPalette& toolpalette;
UIManager& uimanager;
bool config_mode;
bool plugins_hidden;
public:
DragIcon *drag_icon;
private:
Glib::ustring category_id(const std::string& group, bool stereo);
void on_plugin_changed(gx_engine::Plugin *pl, gx_engine::PluginChange::pc c);
Gtk::ToolItemGroup *add_plugin_category(const char *cat, bool collapse = true);
Glib::ustring add_plugin_menu_entry(PluginUI *pui);
void remove_plugin_menu_entry(PluginUI *pui);
void register_plugin(PluginUI *pui);
void fill_pluginlist();
public:
typedef std::map<std::string, PluginUI*>::iterator iterator;
PluginDict(gx_engine::GxMachineBase& machine, gx_system::CmdlineOptions& options,
Gtk::ToolPalette& toolpalette, gx_gui::StackBoxBuilder& boxbuilder,
UIManager& uimanager);
~PluginDict();
void cleanup();
void add_bare(const char * id, Gtk::Container *box);
void add(PluginUI *p);
void remove(PluginUI *p);
PluginUI *operator[](const std::string& s) { return find(s)->second; }
using std::map<std::string, PluginUI*>::begin;
using std::map<std::string, PluginUI*>::end;
void compress(bool state);
bool get_plugins_hidden() { return plugins_hidden; }
void set_config_mode(bool state);
bool get_config_mode() { return config_mode; }
RackContainer& get_monorackcontainer() { return monorackcontainer; }
RackContainer& get_stereorackcontainer() { return stereorackcontainer; }
double stop_at(RackContainer *container, double off, double step_size, double page_size);
void show_entries();
void hide_entries();
void check_order();
void check_order(PluginType tp, bool animate);
void unit_order_changed(bool stereo);
void reorder(RackContainer *container, const std::string& name, const std::string& before);
bool use_animations() { return options.system_animations; }
void on_tp_drag_data_received(const Glib::RefPtr<Gdk::DragContext>& context, int x, int y, const Gtk::SelectionData& data, int info, int timestamp);
gx_engine::GxMachineBase& get_machine() { return machine; }
gx_system::CmdlineOptions& get_options() { return options; }
void plugin_preset_popup(const PluginDef *pdef);
void plugin_preset_popup(const PluginDef *pdef, const Glib::ustring& name);
RackBox *add_rackbox_internal(PluginUI& plugin, Gtk::Widget *mainwidget, Gtk::Widget *miniwidget,
bool mini=false, int pos=-1, bool animate=false, Gtk::Widget *bare=0);
RackBox *add_rackbox(PluginUI& pl, bool mini=false, int pos=-1, bool animate=false);
void pluginlist_append(std::vector<PluginUI*>& p);
void add_plugin(std::vector<PluginUI*>& p, const char *id, const Glib::ustring& tooltip_="");
PluginUI *activate(const string& id, const string& before, bool animate);
PluginUI *deactivate(const string& id, bool animate);
};
/****************************************************************
** class TextLoggingBox
*/
class TextLoggingBox: public Gtk::Window {
private:
struct tab_table {
const char *tagname;
const char *tag_color;
};
Gtk::VBox box;
Gtk::Button ok_button;
Gtk::HButtonBox buttonbox;
Gtk::ScrolledWindow scrollbox;
Gtk::TextView tbox;
static tab_table tagdefs[GxLogger::kMessageTypeCount];
Glib::RefPtr<Gtk::TextTag> tags[GxLogger::kMessageTypeCount];
int highest_unseen_msg_level;
sigc::signal<void> msg_level_changed;
private:
virtual bool on_key_press_event(GdkEventKey *event);
void show_msg(string msgbuf, GxLogger::MsgType msgtype, bool plugged);
virtual void on_show();
virtual void on_hide();
public:
TextLoggingBox();
~TextLoggingBox();
void reset_msg_level();
int get_unseen_msg_level() { return highest_unseen_msg_level; }
sigc::signal<void>& signal_msg_level_changed() { return msg_level_changed; }
};
/****************************************************************
** class NsmSignals
**
** signal messages from GxNsmHandler to MainWindow and back.
**
*/
class NsmSignals {
private:
public: // GxNsmHandler to MainWindow
bool nsm_session_control;
sigc::signal<void > trigger_nsm_show_gui;
sigc::signal<void >& signal_trigger_nsm_show_gui() { return trigger_nsm_show_gui; }
sigc::signal<void > trigger_nsm_hide_gui;
sigc::signal<void >& signal_trigger_nsm_hide_gui() { return trigger_nsm_hide_gui; }
sigc::signal<void > trigger_nsm_save_gui;
sigc::signal<void >& signal_trigger_nsm_save_gui() { return trigger_nsm_save_gui; }
public: // MainWindow to GxNsmHandler
sigc::signal<void > trigger_nsm_gui_is_shown;
sigc::signal<void >& signal_trigger_nsm_gui_is_shown() { return trigger_nsm_gui_is_shown; }
sigc::signal<void > trigger_nsm_gui_is_hidden;
sigc::signal<void >& signal_trigger_nsm_gui_is_hidden() { return trigger_nsm_gui_is_hidden; }
NsmSignals();
~NsmSignals() {};
};
/****************************************************************
** class MainWindow
*/
class Freezer {
private:
Gtk::Window *window;
sigc::connection tag;
bool need_thaw;
int size_x;
int size_y;
sigc::slot<void> work;
private:
void do_thaw();
bool thaw_timeout();
void freeze(Gtk::Window *w, int width, int height);
void thaw();
public:
Freezer();
~Freezer();
void freeze_until_width_update(Gtk::Window *w, int width);
void set_slot(sigc::slot<void> w);
void freeze_and_size_request(Gtk::Window *w, int width, int height);
bool check_thaw(int width, int height);
};
/****************************************************************
** class PluginPresetPopup
*/
class PluginPresetPopup: public Gtk::Menu {
private:
const PluginDef *pdef;
gx_engine::GxMachineBase& machine;
const Glib::ustring save_name_default;
gx_preset::UnitPresetList presetnames;
void set_plugin_std_preset();
void set_plugin_preset(bool factory, const Glib::ustring& name);
bool add_plugin_preset_list(bool *found);
void save_plugin_preset();
void remove_plugin_preset();
protected:
virtual void on_selection_done();
public:
PluginPresetPopup(const PluginDef *pdef, gx_engine::GxMachineBase& machine,
const Glib::ustring& save_name_default = "");
gx_preset::UnitPresetList::const_iterator begin() { return presetnames.begin(); }
gx_preset::UnitPresetList::const_iterator end() { return presetnames.end(); }
const PluginDef *get_pdef() { return pdef; }
gx_engine::GxMachineBase& get_machine() { return machine; }
};
/****************************************************************
** GxUiRadioMenu
** adds the values of an EnumParameter as Gio::MenuItem's
** to a Gio::Menu
*/
class GxUiRadioMenu {
private:
gx_engine::GxMachineBase& machine;
const std::string id;
Glib::RefPtr<Gio::SimpleAction> action;
void set_value(int v);
void on_changed(const Glib::VariantBase& value);
public:
GxUiRadioMenu(gx_engine::GxMachineBase& machine, const std::string& id);
void setup(UIManager& uimanager);
};
class GxActions {
public:
// Main Window
Glib::RefPtr<Gio::SimpleAction> quit;
Glib::RefPtr<Gio::SimpleAction> compress;
Glib::RefPtr<Gio::SimpleAction> expand;
Glib::RefPtr<Gio::SimpleAction> jackstartup;
Glib::RefPtr<Gio::SimpleAction> loadladspa;
Glib::RefPtr<ToggleAction> rack_config;
Glib::RefPtr<ToggleAction> live_play;
Glib::RefPtr<ToggleAction> engine_mute;
sigc::connection engine_mute_conn;
Glib::RefPtr<ToggleAction> engine_bypass;
sigc::connection engine_bypass_conn;
Glib::RefPtr<ToggleAction> jackserverconnection;
Glib::RefPtr<ToggleAction> jackports;
Glib::RefPtr<ToggleAction> midicontroller;
Glib::RefPtr<ToggleAction> meterbridge;
Glib::RefPtr<ToggleAction> loggingbox;
Glib::RefPtr<ToggleAction> animations;
Glib::RefPtr<ToggleAction> show_plugin_bar;
Glib::RefPtr<ToggleAction> presets;
Glib::RefPtr<ToggleAction> show_rack;
Glib::RefPtr<UiBoolToggleAction> tuner;
Glib::RefPtr<UiBoolToggleAction> tunermove;
Glib::RefPtr<UiBoolToggleAction> tunermidiout;
Glib::RefPtr<UiBoolToggleAction> livetuner;
Glib::RefPtr<ToggleAction> show_values;
Glib::RefPtr<ToggleAction> tooltips;
Glib::RefPtr<UiBoolToggleAction> midi_in_presets;
Glib::RefPtr<ToggleAction> rackh;
Glib::RefPtr<ToggleAction> midiout;
Glib::RefPtr<RadioAction> skin;
Glib::RefPtr<RadioAction> latency;
Glib::RefPtr<RadioAction> osc_buffer_size;
Glib::RefPtr<RadioAction> preset_list_menu;
// preset window
Glib::RefPtr<Gio::SimpleAction> new_bank;
Glib::RefPtr<Gio::SimpleAction> save_changes;
Glib::RefPtr<ToggleAction> organize;
Glib::RefPtr<Gio::SimpleAction> online_preset_bank;
};
class SelectMidiChannel: public Gtk::Window {
private:
Gtk::Label *description;
Gtk::ComboBox *channelcombo;
gx_engine::GxMachineBase& machine;
sigc::signal<void> close;
void on_ok_button();
void on_cancel_button();
bool on_delete_event(GdkEventAny* event);
bool on_key_press_event(GdkEventKey *event);
static SelectMidiChannel* create_from_builder(BaseObjectType* cobject, Glib::RefPtr<gx_gui::GxBuilder> bld, gx_engine::GxMachineBase& m) {
return new SelectMidiChannel(cobject, bld, m);
}
SelectMidiChannel(BaseObjectType* cobject, Glib::RefPtr<gx_gui::GxBuilder> bld, gx_engine::GxMachineBase& m);
public:
~SelectMidiChannel();
static SelectMidiChannel* create(gx_system::CmdlineOptions& opt, gx_engine::GxMachineBase& machine);
sigc::signal<void>& signal_close() { return close; }
};
class MainWindowBuilder: public Glib::RefPtr<gx_gui::GxBuilder> {
public:
Gxw::PaintBox *tunerbox;
Gtk::Box *tuner_box_no_rack;
Gtk::ScrolledWindow *vrack_scrolledbox;
Gtk::Scrollbar *monorackscroller;
Gtk::Box *stereorackcontainerH;
Gtk::Box *stereorackcontainerV;
Gxw::PaintBox *rackcontainer;
Gtk::ScrolledWindow *stereorackbox;
Gtk::Box *monocontainer;
Gxw::PaintBox *monoampcontainer;
Gtk::Paned *main_vpaned;
Gtk::Box *monobox;
Gtk::Box *upper_rackbox;
Gtk::ScrolledWindow *preset_scrolledbox;
Gtk::Box *preset_box_no_rack;
Gxw::PaintBox *effects_frame_paintbox;
Gtk::Image *insert_image;
Gtk::Image *status_image;
Gtk::Image *jackd_image;
Gtk::Image *logstate_image;
Gtk::Window *window;
Gtk::ToggleButton *show_rack_button;
Gtk::ToggleButton *rack_order_h_button;
Gtk::ToggleButton *config_mode_button;
Gtk::ToggleButton *liveplay_button;
Gtk::ToggleButton *tuner_button;
Gtk::ToggleButton *effects_button;
Gtk::ToggleButton *presets_button;
Gtk::Button *compress_button;
Gtk::Button *expand_button;
Gtk::ToolPalette *effects_toolpalette;
Gxw::PaintBox *amp_background;
Gxw::Switch *tuner_on_off;
Gxw::Selector *tuner_mode;
Gxw::ValueDisplay *tuner_reference_pitch;
Gxw::Selector *tuner_tuning;
Gxw::Selector *tuner_temperament;
Gxw::RackTuner *racktuner;
Gtk::Button *ampdetail_compress;
Gtk::Button *ampdetail_expand;
Gtk::Widget *ampdetail_mini;
Gtk::Widget *ampdetail_normal;
Gxw::FastMeter *fastmeter[2];
Gtk::Entry *preset_status;
Gtk::MenuBar *menubar;
private:
void load_widget_pointers();
public:
MainWindowBuilder(const gx_system::CmdlineOptions& options, gx_engine::GxMachineBase& machine);
~MainWindowBuilder();
};
class MainWindow: public sigc::trackable {
private:
gx_system::CmdlineOptions& options;
gx_engine::GxMachineBase& machine;
NsmSignals& nsmsig;
GxTheme& theme;
MainWindowBuilder bld;
Freezer freezer;
Glib::RefPtr<Gdk::Pixbuf> gx_head_icon;
gx_gui::StackBoxBuilder boxbuilder;
UIManager uimanager;
GxActions actions;
PluginDict plugin_dict;
int oldpos;
int scrl_size_x;
int scrl_size_y;
int pre_act;
int pool_act;
bool is_visible;
Glib::ustring preset_list_menu_bank;
Liveplay *live_play;
PresetWindow *preset_window;
gx_portmap::PortMapWindow* portmap_window;
gx_gui::SelectJackControlPgm *select_jack_control;
SelectMidiChannel *select_midi_channel;
TextLoggingBox fLoggingWindow;
GxUiRadioMenu amp_radio_menu;
Glib::RefPtr<Gdk::Pixbuf> pixbuf_insert_on;
Glib::RefPtr<Gdk::Pixbuf> pixbuf_insert_off;
Glib::RefPtr<Gdk::Pixbuf> pixbuf_on;
Glib::RefPtr<Gdk::Pixbuf> pixbuf_off;
Glib::RefPtr<Gdk::Pixbuf> pixbuf_bypass;
Glib::RefPtr<Gdk::Pixbuf> pixbuf_jack_connected;
Glib::RefPtr<Gdk::Pixbuf> pixbuf_jack_disconnected;
Glib::RefPtr<Gdk::Pixbuf> pixbuf_log_grey;
Glib::RefPtr<Gdk::Pixbuf> pixbuf_log_yellow;
Glib::RefPtr<Gdk::Pixbuf> pixbuf_log_red;
bool in_session;
Glib::RefPtr<Gtk::StatusIcon> status_icon;
KeySwitcher keyswitch;
ladspa::PluginDisplay *ladspalist_window;
private:
bool on_my_leave_out(GdkEventCrossing *focus);
bool on_my_enter_in(GdkEventCrossing *focus);
void maybe_shrink_horizontally(bool preset_no_rack=false);
void on_show_tuner();
void on_move_tuner();
void on_midiout_tuner();
bool is_variable_size();
void maybe_change_resizable(void);
void on_show_rack();
void on_preset_action();
void on_compress_all();
void on_expand_all();
void on_show_plugin_bar();
void on_rack_configuration();
void set_tooltips();
void set_animations();
void move_widget(Gtk::Widget& w, Gtk::Box& b1, Gtk::Box& b2);
int rackbox_stacked_vertical() const;
void change_expand(Gtk::Widget& w, bool value);
void on_dir_changed();
void on_configure_event(GdkEventConfigure *ev);
void clear_box(Gtk::Container& box);
void on_show_values();
void create_actions();
bool on_visibility_notify(GdkEventVisibility *ev);
void on_live_play();
void jack_connection();
void on_miditable_toggle();
void on_portmap_activate();
void on_portmap_response(int);
bool connect_jack(bool v, Gtk::Window *splash = 0);
int start_jack();
void add_skin_menu();
void change_skin(const Glib::VariantBase& value);
void on_jack_client_changed();
void add_latency_menu();
void change_latency(const Glib::VariantBase& value);
void user_disable_latency_warn(Gtk::CheckButton* disable_warn);
int gx_wait_latency_warn();
void set_latency();
void set_osc_size();
void add_osc_size_menu();
void change_osc_buffer(const Glib::VariantBase& value);
void on_select_jack_control();
void on_load_ladspa();
void delete_select_jack_control();
void on_select_midi_channel();
void delete_select_midi_channel();
void on_log_activate();
bool on_log_activated(GdkEventButton* ev);
bool on_log_scrolled(GdkEventScroll* ev);
void on_engine_toggled();
void on_engine_state_change(gx_engine::GxEngineState state);
void set_tuning(Gxw::RackTuner& tuner);
void set_tuner_tet(Gxw::RackTuner& tuner);
void set_tuner_ref(Gxw::RackTuner& tuner);
void setup_tuner_temperament(Gxw::RackTuner& tuner);
void setup_tuner(Gxw::RackTuner& tuner);
bool on_toggle_mute(GdkEventButton* ev);
bool on_scroll_toggle(GdkEventScroll* ev);
bool on_toggle_insert(GdkEventButton* ev);
bool on_scroll_toggle_insert(GdkEventScroll* ev);
void on_insert_jack_changed(bool s);
bool on_jackserverconnection(GdkEventButton* ev);
bool on_jackserverconnection_scroll(GdkEventScroll* ev);
void on_msg_level_changed();
void on_ampdetail_switch(bool compress, bool setparam);
bool refresh_meter_level(float falloff);
bool survive_jack_shutdown();
void gx_jack_is_down();
void jack_session_event();
void jack_session_event_ins();
void set_in_session();
void hide_extended_settings();
void systray_menu(guint button, guint32 activate_time);
bool on_window_state_changed(GdkEventWindowState* event);
bool on_meter_button_release(GdkEventButton* ev);
void show_selected_preset();
void on_select_preset(const Glib::VariantBase& value);
void on_next_preset();
void on_previus_preset();
void set_next_preset_controller();
void set_previus_preset_controller();
void set_switcher_controller();
void set_bypass_controller();
void set_vpaned_handle();
void add_preset_key_accelerators();
void rebuild_preset_menu();
bool on_key_press_event(GdkEventKey *event);
void display_preset_msg(const Glib::ustring& bank, const Glib::ustring& preset);
void on_livetuner_toggled();
void on_ladspa_finished(bool reload, bool quit);
bool delete_ladspalist_window();
bool on_quit();
void on_nsm_quit();
void on_nsm_save();
void amp_controls_visible(Gtk::Range *rr);
void gx_show_help();
void show_forum_help();
void gx_show_tonehunt();
void show_tonehunt();
void gx_show_rtneural();
void show_rtneural();
void set_midiout();
public:
Glib::RefPtr<Gtk::SizeGroup> left_column;
MainWindow(gx_engine::GxMachineBase& machine, gx_system::CmdlineOptions& options, NsmSignals& nsmsig, GxTheme& theme,
Gtk::Window *splash, const Glib::ustring& title);
~MainWindow();
PluginUI *get_plugin(const std::string& name) { return plugin_dict[name]; }
PluginDict::iterator plugins_begin() { return plugin_dict.begin(); }
PluginDict::iterator plugins_end() { return plugin_dict.end(); }
void run();
gx_system::CmdlineOptions& get_options() { return options; }
gx_engine::GxMachineBase& get_machine() { return machine; }
void set_rackbox_expansion();
bool use_animations() { return actions.animations->get_active(); }
void create_default_scratch_preset() { machine.create_default_scratch_preset(); }
void update_width();
};
inline void RackContainer::reorder(const std::string& name, const std::string& before) {
plugin_dict.reorder(this, name, before); }
DragIcon
Definition gx_main_window.h:250
DragIcon::~DragIcon
~DragIcon()
DragIcon::gradient_length
@ gradient_length
Definition gx_main_window.h:252
DragIcon::icon_draw
bool icon_draw(const Cairo::RefPtr< Cairo::Context > &cr)
DragIcon::drag_icon_pixbuf
Glib::RefPtr< Gdk::Pixbuf > drag_icon_pixbuf
Definition gx_main_window.h:254
DragIcon::window_draw
bool window_draw(const Cairo::RefPtr< Cairo::Context > &cr, Gtk::OffscreenWindow &w)
DragIcon::DragIcon
DragIcon(PluginUI &plugin, Glib::RefPtr< Gdk::DragContext > context, gx_system::CmdlineOptions &options, int xoff=0)
DragIcon::window
Gtk::Window * window
Definition gx_main_window.h:253
DragIcon::create_drag_icon_pixbuf
void create_drag_icon_pixbuf(const PluginUI &plugin, Glib::RefPtr< Gdk::Visual > rgba, gx_system::CmdlineOptions &options)
Freezer
Definition gx_main_window.h:640
Freezer::need_thaw
bool need_thaw
Definition gx_main_window.h:644
Freezer::do_thaw
void do_thaw()
Freezer::thaw_timeout
bool thaw_timeout()
Freezer::freeze_until_width_update
void freeze_until_width_update(Gtk::Window *w, int width)
Freezer::freeze_and_size_request
void freeze_and_size_request(Gtk::Window *w, int width, int height)
Freezer::window
Gtk::Window * window
Definition gx_main_window.h:642
Freezer::freeze
void freeze(Gtk::Window *w, int width, int height)
Freezer::size_y
int size_y
Definition gx_main_window.h:646
Freezer::size_x
int size_x
Definition gx_main_window.h:645
Freezer::check_thaw
bool check_thaw(int width, int height)
Freezer::set_slot
void set_slot(sigc::slot< void > w)
Freezer::tag
sigc::connection tag
Definition gx_main_window.h:643
Freezer::work
sigc::slot< void > work
Definition gx_main_window.h:647
Freezer::thaw
void thaw()
Freezer::~Freezer
~Freezer()
Freezer::Freezer
Freezer()
GxActions
Definition gx_main_window.h:709
GxActions::quit
Glib::RefPtr< Gio::SimpleAction > quit
Definition gx_main_window.h:712
GxActions::online_preset_bank
Glib::RefPtr< Gio::SimpleAction > online_preset_bank
Definition gx_main_window.h:753
GxActions::live_play
Glib::RefPtr< ToggleAction > live_play
Definition gx_main_window.h:719
GxActions::midi_in_presets
Glib::RefPtr< UiBoolToggleAction > midi_in_presets
Definition gx_main_window.h:740
GxActions::new_bank
Glib::RefPtr< Gio::SimpleAction > new_bank
Definition gx_main_window.h:750
GxActions::jackserverconnection
Glib::RefPtr< ToggleAction > jackserverconnection
Definition gx_main_window.h:724
GxActions::compress
Glib::RefPtr< Gio::SimpleAction > compress
Definition gx_main_window.h:713
GxActions::midicontroller
Glib::RefPtr< ToggleAction > midicontroller
Definition gx_main_window.h:726
GxActions::osc_buffer_size
Glib::RefPtr< RadioAction > osc_buffer_size
Definition gx_main_window.h:746
GxActions::tooltips
Glib::RefPtr< ToggleAction > tooltips
Definition gx_main_window.h:739
GxActions::skin
Glib::RefPtr< RadioAction > skin
Definition gx_main_window.h:744
GxActions::show_plugin_bar
Glib::RefPtr< ToggleAction > show_plugin_bar
Definition gx_main_window.h:731
GxActions::engine_mute
Glib::RefPtr< ToggleAction > engine_mute
Definition gx_main_window.h:720
GxActions::tuner
Glib::RefPtr< UiBoolToggleAction > tuner
Definition gx_main_window.h:734
GxActions::jackstartup
Glib::RefPtr< Gio::SimpleAction > jackstartup
Definition gx_main_window.h:715
GxActions::loadladspa
Glib::RefPtr< Gio::SimpleAction > loadladspa
Definition gx_main_window.h:716
GxActions::show_values
Glib::RefPtr< ToggleAction > show_values
Definition gx_main_window.h:738
GxActions::midiout
Glib::RefPtr< ToggleAction > midiout
Definition gx_main_window.h:742
GxActions::preset_list_menu
Glib::RefPtr< RadioAction > preset_list_menu
Definition gx_main_window.h:747
GxActions::engine_bypass
Glib::RefPtr< ToggleAction > engine_bypass
Definition gx_main_window.h:722
GxActions::animations
Glib::RefPtr< ToggleAction > animations
Definition gx_main_window.h:729
GxActions::jackports
Glib::RefPtr< ToggleAction > jackports
Definition gx_main_window.h:725
GxActions::show_rack
Glib::RefPtr< ToggleAction > show_rack
Definition gx_main_window.h:733
GxActions::engine_bypass_conn
sigc::connection engine_bypass_conn
Definition gx_main_window.h:723
GxActions::rack_config
Glib::RefPtr< ToggleAction > rack_config
Definition gx_main_window.h:718
GxActions::organize
Glib::RefPtr< ToggleAction > organize
Definition gx_main_window.h:752
GxActions::latency
Glib::RefPtr< RadioAction > latency
Definition gx_main_window.h:745
GxActions::meterbridge
Glib::RefPtr< ToggleAction > meterbridge
Definition gx_main_window.h:727
GxActions::engine_mute_conn
sigc::connection engine_mute_conn
Definition gx_main_window.h:721
GxActions::presets
Glib::RefPtr< ToggleAction > presets
Definition gx_main_window.h:732
GxActions::save_changes
Glib::RefPtr< Gio::SimpleAction > save_changes
Definition gx_main_window.h:751
GxActions::tunermidiout
Glib::RefPtr< UiBoolToggleAction > tunermidiout
Definition gx_main_window.h:736
GxActions::tunermove
Glib::RefPtr< UiBoolToggleAction > tunermove
Definition gx_main_window.h:735
GxActions::rackh
Glib::RefPtr< ToggleAction > rackh
Definition gx_main_window.h:741
GxActions::expand
Glib::RefPtr< Gio::SimpleAction > expand
Definition gx_main_window.h:714
GxActions::livetuner
Glib::RefPtr< UiBoolToggleAction > livetuner
Definition gx_main_window.h:737
GxActions::loggingbox
Glib::RefPtr< ToggleAction > loggingbox
Definition gx_main_window.h:728
GxLogger::MsgType
MsgType
Definition gx_logging.h:37
GxLogger::kMessageTypeCount
@ kMessageTypeCount
Definition gx_logging.h:41
GxTheme
Definition gx_main_window.h:29
GxTheme::set_window
void set_window(Gtk::Window *window_)
Definition gx_main_window.h:47
GxTheme::window_y
int window_y
Definition gx_main_window.h:37
GxTheme::options
gx_system::CmdlineOptions * options
Definition gx_main_window.h:31
GxTheme::window_x
int window_x
Definition gx_main_window.h:37
GxTheme::GxTheme
GxTheme()
Definition gx_main_window.h:41
GxTheme::style_context
Glib::RefPtr< Gtk::StyleContext > style_context
Definition gx_main_window.h:34
GxTheme::window
Gtk::Window * window
Definition gx_main_window.h:36
GxTheme::set_new_skin
bool set_new_skin(const Glib::ustring &skin_name)
GxTheme::reload_css_post
void reload_css_post()
GxTheme::reload_css
void reload_css()
GxTheme::init
void init(gx_system::CmdlineOptions *options_)
GxTheme::update_show_values
void update_show_values()
GxTheme::css_show_values
Glib::RefPtr< Gtk::CssProvider > css_show_values
Definition gx_main_window.h:33
GxTheme::css_provider
Glib::RefPtr< Gtk::CssProvider > css_provider
Definition gx_main_window.h:32
KeySwitcher
Definition gx_main_window.h:152
KeySwitcher::display_key_error
void display_key_error()
KeySwitcher::bank_idx_to_char
static char bank_idx_to_char(int idx, int bank_size)
KeySwitcher::next_idx
static int next_idx(int idx=-1)
KeySwitcher::deactivate
void deactivate()
KeySwitcher::KeySwitcher
KeySwitcher(gx_engine::GxMachineBase &machine_, sigc::slot< void, const Glib::ustring &, const Glib::ustring & > display_)
Definition gx_main_window.h:163
KeySwitcher::process_bank_key
bool process_bank_key(int key)
KeySwitcher::display_empty
void display_empty(const Glib::ustring &bank, const Glib::ustring &preset)
KeySwitcher::display
sigc::slot< void, const Glib::ustring &, const Glib::ustring & > display
Definition gx_main_window.h:155
KeySwitcher::display_selected_bank
bool display_selected_bank()
KeySwitcher::key_timeout
sigc::connection key_timeout
Definition gx_main_window.h:156
KeySwitcher::last_bank_key
Glib::ustring last_bank_key
Definition gx_main_window.h:157
KeySwitcher::key_offset_to_bank_idx
static int key_offset_to_bank_idx(int offset, int bank_size)
KeySwitcher::display_current
bool display_current()
KeySwitcher::process_preset_key
bool process_preset_key(int key)
KeySwitcher::machine
gx_engine::GxMachineBase & machine
Definition gx_main_window.h:154
KeySwitcher::idx_to_char
static char idx_to_char(int idx)
KeySwitcher::key_offset_to_idx
static int key_offset_to_idx(int offset)
Liveplay
Definition gx_main_window.h:182
Liveplay::on_keyboard_preset_select
static bool on_keyboard_preset_select(GtkAccelGroup *accel_group, GObject *acceleratable, guint keyval, GdkModifierType modifier, Liveplay &self)
Liveplay::on_keyboard_mode_switch
static bool on_keyboard_mode_switch(GtkAccelGroup *accel_group, GObject *acceleratable, guint keyval, GdkModifierType modifier, Liveplay &self)
Liveplay::Liveplay
Liveplay(const gx_system::CmdlineOptions &options, gx_engine::GxMachineBase &machine, const std::string &fname, const GxActions &actions, Glib::RefPtr< Gio::SimpleActionGroup > &group)
Liveplay::on_keyboard_toggle_bypass
static bool on_keyboard_toggle_bypass(GtkAccelGroup *accel_group, GObject *acceleratable, guint keyval, GdkModifierType modifier, Liveplay &self)
Liveplay::get_tuner
Gxw::RackTuner & get_tuner()
Definition gx_main_window.h:242
Liveplay::liveplay_preset
Gtk::Label * liveplay_preset
Definition gx_main_window.h:198
Liveplay::on_selection_done
void on_selection_done(bool v)
Liveplay::mute_image
Gtk::Image * mute_image
Definition gx_main_window.h:196
Liveplay::background_slider
Gxw::HSlider * background_slider
Definition gx_main_window.h:202
Liveplay::window_draw
bool window_draw(const Cairo::RefPtr< Cairo::Context > &cr)
Liveplay::pointer_motion
bool pointer_motion(GdkEventMotion *event)
Liveplay::actions
const GxActions & actions
Definition gx_main_window.h:186
Liveplay::liveplay_exit
Gtk::ToggleButton * liveplay_exit
Definition gx_main_window.h:203
Liveplay::bypass_image
Gtk::Image * bypass_image
Definition gx_main_window.h:195
Liveplay::use_composite
bool use_composite
Definition gx_main_window.h:187
Liveplay::keyswitch
KeySwitcher keyswitch
Definition gx_main_window.h:190
Liveplay::on_keyboard_arrows
static bool on_keyboard_arrows(GtkAccelGroup *accel_group, GObject *acceleratable, guint keyval, GdkModifierType modifier, Liveplay &self)
Liveplay::midictrl_table
Gtk::Grid * midictrl_table
Definition gx_main_window.h:204
Liveplay::on_background_changed
void on_background_changed()
Liveplay::add_midi_elements
void add_midi_elements()
Liveplay::brightness_slider
Gxw::HSlider * brightness_slider
Definition gx_main_window.h:200
Liveplay::on_keyboard_toggle_mute
static bool on_keyboard_toggle_mute(GtkAccelGroup *accel_group, GObject *acceleratable, guint keyval, GdkModifierType modifier, Liveplay &self)
Liveplay::liveplay_bank
Gtk::Label * liveplay_bank
Definition gx_main_window.h:197
Liveplay::machine
gx_engine::GxMachineBase & machine
Definition gx_main_window.h:185
Liveplay::liveplay_canvas
Gtk::Widget * liveplay_canvas
Definition gx_main_window.h:199
Liveplay::tuner
Gxw::RackTuner * tuner
Definition gx_main_window.h:205
Liveplay::~Liveplay
~Liveplay()
Liveplay::on_delete
bool on_delete(GdkEventAny *ev)
Liveplay::on_live_play
void on_live_play(Glib::RefPtr< ToggleAction > act)
Liveplay::bld
Glib::RefPtr< gx_gui::GxBuilder > bld
Definition gx_main_window.h:184
Liveplay::on_brightness_changed
void on_brightness_changed()
Liveplay::on_selection_changed
void on_selection_changed()
Liveplay::set_display_state
void set_display_state(TunerSwitcher::SwitcherState s)
Liveplay::on_realize
void on_realize()
Liveplay::window
Gtk::Window * window
Definition gx_main_window.h:192
Liveplay::background_adj
Glib::RefPtr< Gtk::Adjustment > background_adj
Definition gx_main_window.h:189
Liveplay::brightness_box
Gtk::Box * brightness_box
Definition gx_main_window.h:201
Liveplay::mouse_hide_conn
sigc::connection mouse_hide_conn
Definition gx_main_window.h:193
Liveplay::display
void display(const Glib::ustring &bank, const Glib::ustring &preset)
Liveplay::display_tuner
void display_tuner(bool v)
Liveplay::midi_conn
sigc::connection midi_conn
Definition gx_main_window.h:191
Liveplay::on_engine_state_change
void on_engine_state_change(gx_engine::GxEngineState state)
Liveplay::transparent_draw
bool transparent_draw(const Cairo::RefPtr< Cairo::Context > &cr)
Liveplay::brightness_adj
Glib::RefPtr< Gtk::Adjustment > brightness_adj
Definition gx_main_window.h:188
MainWindowBuilder
Definition gx_main_window.h:778
MainWindowBuilder::monocontainer
Gtk::Box * monocontainer
Definition gx_main_window.h:788
MainWindowBuilder::monorackscroller
Gtk::Scrollbar * monorackscroller
Definition gx_main_window.h:783
MainWindowBuilder::liveplay_button
Gtk::ToggleButton * liveplay_button
Definition gx_main_window.h:804
MainWindowBuilder::racktuner
Gxw::RackTuner * racktuner
Definition gx_main_window.h:817
MainWindowBuilder::effects_frame_paintbox
Gxw::PaintBox * effects_frame_paintbox
Definition gx_main_window.h:795
MainWindowBuilder::expand_button
Gtk::Button * expand_button
Definition gx_main_window.h:809
MainWindowBuilder::upper_rackbox
Gtk::Box * upper_rackbox
Definition gx_main_window.h:792
MainWindowBuilder::show_rack_button
Gtk::ToggleButton * show_rack_button
Definition gx_main_window.h:801
MainWindowBuilder::monoampcontainer
Gxw::PaintBox * monoampcontainer
Definition gx_main_window.h:789
MainWindowBuilder::main_vpaned
Gtk::Paned * main_vpaned
Definition gx_main_window.h:790
MainWindowBuilder::ampdetail_expand
Gtk::Button * ampdetail_expand
Definition gx_main_window.h:819
MainWindowBuilder::status_image
Gtk::Image * status_image
Definition gx_main_window.h:797
MainWindowBuilder::tuner_reference_pitch
Gxw::ValueDisplay * tuner_reference_pitch
Definition gx_main_window.h:814
MainWindowBuilder::~MainWindowBuilder
~MainWindowBuilder()
MainWindowBuilder::ampdetail_mini
Gtk::Widget * ampdetail_mini
Definition gx_main_window.h:820
MainWindowBuilder::compress_button
Gtk::Button * compress_button
Definition gx_main_window.h:808
MainWindowBuilder::effects_button
Gtk::ToggleButton * effects_button
Definition gx_main_window.h:806
MainWindowBuilder::rackcontainer
Gxw::PaintBox * rackcontainer
Definition gx_main_window.h:786
MainWindowBuilder::tuner_box_no_rack
Gtk::Box * tuner_box_no_rack
Definition gx_main_window.h:781
MainWindowBuilder::stereorackcontainerV
Gtk::Box * stereorackcontainerV
Definition gx_main_window.h:785
MainWindowBuilder::effects_toolpalette
Gtk::ToolPalette * effects_toolpalette
Definition gx_main_window.h:810
MainWindowBuilder::tunerbox
Gxw::PaintBox * tunerbox
Definition gx_main_window.h:780
MainWindowBuilder::amp_background
Gxw::PaintBox * amp_background
Definition gx_main_window.h:811
MainWindowBuilder::ampdetail_compress
Gtk::Button * ampdetail_compress
Definition gx_main_window.h:818
MainWindowBuilder::fastmeter
Gxw::FastMeter * fastmeter[2]
Definition gx_main_window.h:822
MainWindowBuilder::tuner_button
Gtk::ToggleButton * tuner_button
Definition gx_main_window.h:805
MainWindowBuilder::presets_button
Gtk::ToggleButton * presets_button
Definition gx_main_window.h:807
MainWindowBuilder::monobox
Gtk::Box * monobox
Definition gx_main_window.h:791
MainWindowBuilder::menubar
Gtk::MenuBar * menubar
Definition gx_main_window.h:824
MainWindowBuilder::tuner_tuning
Gxw::Selector * tuner_tuning
Definition gx_main_window.h:815
MainWindowBuilder::tuner_mode
Gxw::Selector * tuner_mode
Definition gx_main_window.h:813
MainWindowBuilder::tuner_temperament
Gxw::Selector * tuner_temperament
Definition gx_main_window.h:816
MainWindowBuilder::preset_box_no_rack
Gtk::Box * preset_box_no_rack
Definition gx_main_window.h:794
MainWindowBuilder::stereorackbox
Gtk::ScrolledWindow * stereorackbox
Definition gx_main_window.h:787
MainWindowBuilder::jackd_image
Gtk::Image * jackd_image
Definition gx_main_window.h:798
MainWindowBuilder::vrack_scrolledbox
Gtk::ScrolledWindow * vrack_scrolledbox
Definition gx_main_window.h:782
MainWindowBuilder::stereorackcontainerH
Gtk::Box * stereorackcontainerH
Definition gx_main_window.h:784
MainWindowBuilder::rack_order_h_button
Gtk::ToggleButton * rack_order_h_button
Definition gx_main_window.h:802
MainWindowBuilder::MainWindowBuilder
MainWindowBuilder(const gx_system::CmdlineOptions &options, gx_engine::GxMachineBase &machine)
MainWindowBuilder::insert_image
Gtk::Image * insert_image
Definition gx_main_window.h:796
MainWindowBuilder::tuner_on_off
Gxw::Switch * tuner_on_off
Definition gx_main_window.h:812
MainWindowBuilder::preset_scrolledbox
Gtk::ScrolledWindow * preset_scrolledbox
Definition gx_main_window.h:793
MainWindowBuilder::preset_status
Gtk::Entry * preset_status
Definition gx_main_window.h:823
MainWindowBuilder::load_widget_pointers
void load_widget_pointers()
MainWindowBuilder::config_mode_button
Gtk::ToggleButton * config_mode_button
Definition gx_main_window.h:803
MainWindowBuilder::window
Gtk::Window * window
Definition gx_main_window.h:800
MainWindowBuilder::logstate_image
Gtk::Image * logstate_image
Definition gx_main_window.h:799
MainWindowBuilder::ampdetail_normal
Gtk::Widget * ampdetail_normal
Definition gx_main_window.h:821
MainWindow
Definition gx_main_window.h:832
MainWindow::on_select_midi_channel
void on_select_midi_channel()
MainWindow::on_engine_toggled
void on_engine_toggled()
MainWindow::on_my_enter_in
bool on_my_enter_in(GdkEventCrossing *focus)
MainWindow::bld
MainWindowBuilder bld
Definition gx_main_window.h:838
MainWindow::refresh_meter_level
bool refresh_meter_level(float falloff)
MainWindow::maybe_shrink_horizontally
void maybe_shrink_horizontally(bool preset_no_rack=false)
MainWindow::on_visibility_notify
bool on_visibility_notify(GdkEventVisibility *ev)
MainWindow::on_previus_preset
void on_previus_preset()
MainWindow::is_variable_size
bool is_variable_size()
MainWindow::show_rtneural
void show_rtneural()
MainWindow::on_my_leave_out
bool on_my_leave_out(GdkEventCrossing *focus)
MainWindow::options
gx_system::CmdlineOptions & options
Definition gx_main_window.h:834
MainWindow::left_column
Glib::RefPtr< Gtk::SizeGroup > left_column
Definition gx_main_window.h:980
MainWindow::on_move_tuner
void on_move_tuner()
MainWindow::on_ladspa_finished
void on_ladspa_finished(bool reload, bool quit)
MainWindow::gx_jack_is_down
void gx_jack_is_down()
MainWindow::set_osc_size
void set_osc_size()
MainWindow::create_default_scratch_preset
void create_default_scratch_preset()
Definition gx_main_window.h:992
MainWindow::on_log_activate
void on_log_activate()
MainWindow::on_load_ladspa
void on_load_ladspa()
MainWindow::plugins_begin
PluginDict::iterator plugins_begin()
Definition gx_main_window.h:985
MainWindow::on_select_jack_control
void on_select_jack_control()
MainWindow::set_tuner_ref
void set_tuner_ref(Gxw::RackTuner &tuner)
MainWindow::on_insert_jack_changed
void on_insert_jack_changed(bool s)
MainWindow::show_selected_preset
void show_selected_preset()
MainWindow::on_jackserverconnection
bool on_jackserverconnection(GdkEventButton *ev)
MainWindow::get_options
gx_system::CmdlineOptions & get_options()
Definition gx_main_window.h:988
MainWindow::on_log_activated
bool on_log_activated(GdkEventButton *ev)
MainWindow::set_tooltips
void set_tooltips()
MainWindow::portmap_window
gx_portmap::PortMapWindow * portmap_window
Definition gx_main_window.h:854
MainWindow::set_vpaned_handle
void set_vpaned_handle()
MainWindow::pool_act
int pool_act
Definition gx_main_window.h:849
MainWindow::delete_select_midi_channel
void delete_select_midi_channel()
MainWindow::on_show_tuner
void on_show_tuner()
MainWindow::amp_radio_menu
GxUiRadioMenu amp_radio_menu
Definition gx_main_window.h:858
MainWindow::set_tuner_tet
void set_tuner_tet(Gxw::RackTuner &tuner)
MainWindow::fLoggingWindow
TextLoggingBox fLoggingWindow
Definition gx_main_window.h:857
MainWindow::scrl_size_y
int scrl_size_y
Definition gx_main_window.h:847
MainWindow::gx_wait_latency_warn
int gx_wait_latency_warn()
MainWindow::on_jackserverconnection_scroll
bool on_jackserverconnection_scroll(GdkEventScroll *ev)
MainWindow::set_tuning
void set_tuning(Gxw::RackTuner &tuner)
MainWindow::boxbuilder
gx_gui::StackBoxBuilder boxbuilder
Definition gx_main_window.h:841
MainWindow::pixbuf_off
Glib::RefPtr< Gdk::Pixbuf > pixbuf_off
Definition gx_main_window.h:862
MainWindow::on_miditable_toggle
void on_miditable_toggle()
MainWindow::pixbuf_jack_disconnected
Glib::RefPtr< Gdk::Pixbuf > pixbuf_jack_disconnected
Definition gx_main_window.h:865
MainWindow::start_jack
int start_jack()
MainWindow::set_midiout
void set_midiout()
MainWindow::connect_jack
bool connect_jack(bool v, Gtk::Window *splash=0)
MainWindow::nsmsig
NsmSignals & nsmsig
Definition gx_main_window.h:836
MainWindow::show_tonehunt
void show_tonehunt()
MainWindow::amp_controls_visible
void amp_controls_visible(Gtk::Range *rr)
MainWindow::display_preset_msg
void display_preset_msg(const Glib::ustring &bank, const Glib::ustring &preset)
MainWindow::on_ampdetail_switch
void on_ampdetail_switch(bool compress, bool setparam)
MainWindow::pre_act
int pre_act
Definition gx_main_window.h:848
MainWindow::add_preset_key_accelerators
void add_preset_key_accelerators()
MainWindow::plugins_end
PluginDict::iterator plugins_end()
Definition gx_main_window.h:986
MainWindow::machine
gx_engine::GxMachineBase & machine
Definition gx_main_window.h:835
MainWindow::plugin_dict
PluginDict plugin_dict
Definition gx_main_window.h:844
MainWindow::rebuild_preset_menu
void rebuild_preset_menu()
MainWindow::user_disable_latency_warn
void user_disable_latency_warn(Gtk::CheckButton *disable_warn)
MainWindow::MainWindow
MainWindow(gx_engine::GxMachineBase &machine, gx_system::CmdlineOptions &options, NsmSignals &nsmsig, GxTheme &theme, Gtk::Window *splash, const Glib::ustring &title)
MainWindow::add_skin_menu
void add_skin_menu()
MainWindow::set_next_preset_controller
void set_next_preset_controller()
MainWindow::systray_menu
void systray_menu(guint button, guint32 activate_time)
MainWindow::update_width
void update_width()
MainWindow::on_nsm_save
void on_nsm_save()
MainWindow::on_scroll_toggle_insert
bool on_scroll_toggle_insert(GdkEventScroll *ev)
MainWindow::setup_tuner_temperament
void setup_tuner_temperament(Gxw::RackTuner &tuner)
MainWindow::on_show_plugin_bar
void on_show_plugin_bar()
MainWindow::on_meter_button_release
bool on_meter_button_release(GdkEventButton *ev)
MainWindow::gx_head_icon
Glib::RefPtr< Gdk::Pixbuf > gx_head_icon
Definition gx_main_window.h:840
MainWindow::on_window_state_changed
bool on_window_state_changed(GdkEventWindowState *event)
MainWindow::get_plugin
PluginUI * get_plugin(const std::string &name)
Definition gx_main_window.h:984
MainWindow::on_show_values
void on_show_values()
MainWindow::ladspalist_window
ladspa::PluginDisplay * ladspalist_window
Definition gx_main_window.h:872
MainWindow::pixbuf_log_red
Glib::RefPtr< Gdk::Pixbuf > pixbuf_log_red
Definition gx_main_window.h:868
MainWindow::freezer
Freezer freezer
Definition gx_main_window.h:839
MainWindow::pixbuf_jack_connected
Glib::RefPtr< Gdk::Pixbuf > pixbuf_jack_connected
Definition gx_main_window.h:864
MainWindow::gx_show_help
void gx_show_help()
MainWindow::live_play
Liveplay * live_play
Definition gx_main_window.h:852
MainWindow::on_live_play
void on_live_play()
MainWindow::actions
GxActions actions
Definition gx_main_window.h:843
MainWindow::on_log_scrolled
bool on_log_scrolled(GdkEventScroll *ev)
MainWindow::on_show_rack
void on_show_rack()
MainWindow::survive_jack_shutdown
bool survive_jack_shutdown()
MainWindow::oldpos
int oldpos
Definition gx_main_window.h:845
MainWindow::set_rackbox_expansion
void set_rackbox_expansion()
MainWindow::show_forum_help
void show_forum_help()
MainWindow::on_engine_state_change
void on_engine_state_change(gx_engine::GxEngineState state)
MainWindow::on_rack_configuration
void on_rack_configuration()
MainWindow::theme
GxTheme & theme
Definition gx_main_window.h:837
MainWindow::pixbuf_on
Glib::RefPtr< Gdk::Pixbuf > pixbuf_on
Definition gx_main_window.h:861
MainWindow::change_latency
void change_latency(const Glib::VariantBase &value)
MainWindow::jack_connection
void jack_connection()
MainWindow::on_midiout_tuner
void on_midiout_tuner()
MainWindow::on_select_preset
void on_select_preset(const Glib::VariantBase &value)
MainWindow::on_compress_all
void on_compress_all()
MainWindow::maybe_change_resizable
void maybe_change_resizable(void)
MainWindow::hide_extended_settings
void hide_extended_settings()
MainWindow::on_scroll_toggle
bool on_scroll_toggle(GdkEventScroll *ev)
MainWindow::on_key_press_event
bool on_key_press_event(GdkEventKey *event)
MainWindow::status_icon
Glib::RefPtr< Gtk::StatusIcon > status_icon
Definition gx_main_window.h:870
MainWindow::preset_window
PresetWindow * preset_window
Definition gx_main_window.h:853
MainWindow::get_machine
gx_engine::GxMachineBase & get_machine()
Definition gx_main_window.h:989
MainWindow::run
void run()
MainWindow::scrl_size_x
int scrl_size_x
Definition gx_main_window.h:846
MainWindow::set_animations
void set_animations()
MainWindow::set_switcher_controller
void set_switcher_controller()
MainWindow::jack_session_event
void jack_session_event()
MainWindow::pixbuf_log_yellow
Glib::RefPtr< Gdk::Pixbuf > pixbuf_log_yellow
Definition gx_main_window.h:867
MainWindow::change_expand
void change_expand(Gtk::Widget &w, bool value)
MainWindow::on_next_preset
void on_next_preset()
MainWindow::delete_ladspalist_window
bool delete_ladspalist_window()
MainWindow::create_actions
void create_actions()
MainWindow::on_expand_all
void on_expand_all()
MainWindow::on_msg_level_changed
void on_msg_level_changed()
MainWindow::pixbuf_bypass
Glib::RefPtr< Gdk::Pixbuf > pixbuf_bypass
Definition gx_main_window.h:863
MainWindow::on_portmap_activate
void on_portmap_activate()
MainWindow::set_in_session
void set_in_session()
MainWindow::on_portmap_response
void on_portmap_response(int)
MainWindow::set_previus_preset_controller
void set_previus_preset_controller()
MainWindow::on_jack_client_changed
void on_jack_client_changed()
MainWindow::rackbox_stacked_vertical
int rackbox_stacked_vertical() const
MainWindow::set_bypass_controller
void set_bypass_controller()
MainWindow::gx_show_rtneural
void gx_show_rtneural()
MainWindow::on_nsm_quit
void on_nsm_quit()
MainWindow::select_jack_control
gx_gui::SelectJackControlPgm * select_jack_control
Definition gx_main_window.h:855
MainWindow::on_preset_action
void on_preset_action()
MainWindow::pixbuf_insert_off
Glib::RefPtr< Gdk::Pixbuf > pixbuf_insert_off
Definition gx_main_window.h:860
MainWindow::keyswitch
KeySwitcher keyswitch
Definition gx_main_window.h:871
MainWindow::on_dir_changed
void on_dir_changed()
MainWindow::pixbuf_log_grey
Glib::RefPtr< Gdk::Pixbuf > pixbuf_log_grey
Definition gx_main_window.h:866
MainWindow::on_toggle_mute
bool on_toggle_mute(GdkEventButton *ev)
MainWindow::on_livetuner_toggled
void on_livetuner_toggled()
MainWindow::set_latency
void set_latency()
MainWindow::use_animations
bool use_animations()
Definition gx_main_window.h:991
MainWindow::clear_box
void clear_box(Gtk::Container &box)
MainWindow::jack_session_event_ins
void jack_session_event_ins()
MainWindow::in_session
bool in_session
Definition gx_main_window.h:869
MainWindow::move_widget
void move_widget(Gtk::Widget &w, Gtk::Box &b1, Gtk::Box &b2)
MainWindow::preset_list_menu_bank
Glib::ustring preset_list_menu_bank
Definition gx_main_window.h:851
MainWindow::on_quit
bool on_quit()
MainWindow::setup_tuner
void setup_tuner(Gxw::RackTuner &tuner)
MainWindow::is_visible
bool is_visible
Definition gx_main_window.h:850
MainWindow::change_skin
void change_skin(const Glib::VariantBase &value)
MainWindow::on_toggle_insert
bool on_toggle_insert(GdkEventButton *ev)
MainWindow::pixbuf_insert_on
Glib::RefPtr< Gdk::Pixbuf > pixbuf_insert_on
Definition gx_main_window.h:859
MainWindow::~MainWindow
~MainWindow()
MainWindow::select_midi_channel
SelectMidiChannel * select_midi_channel
Definition gx_main_window.h:856
MainWindow::gx_show_tonehunt
void gx_show_tonehunt()
MainWindow::add_osc_size_menu
void add_osc_size_menu()
MainWindow::change_osc_buffer
void change_osc_buffer(const Glib::VariantBase &value)
MainWindow::on_configure_event
void on_configure_event(GdkEventConfigure *ev)
MainWindow::uimanager
UIManager uimanager
Definition gx_main_window.h:842
MainWindow::add_latency_menu
void add_latency_menu()
MainWindow::delete_select_jack_control
void delete_select_jack_control()
MiniRackBox
Definition gx_main_window.h:332
MiniRackBox::szg_label
static Glib::RefPtr< Gtk::SizeGroup > szg_label
Definition gx_main_window.h:334
MiniRackBox::preset_button
Gtk::Button * preset_button
Definition gx_main_window.h:339
MiniRackBox::mconbox
Gtk::HBox mconbox
Definition gx_main_window.h:336
MiniRackBox::on_my_leave_out
bool on_my_leave_out(GdkEventCrossing *focus)
MiniRackBox::evbox_button
sigc::connection evbox_button
Definition gx_main_window.h:343
MiniRackBox::mb_delete_button
Gtk::Widget * mb_delete_button
Definition gx_main_window.h:338
MiniRackBox::mb_expand_button
Gtk::Button * mb_expand_button
Definition gx_main_window.h:337
MiniRackBox::pack
void pack(Gtk::Widget *w)
MiniRackBox::make_delete_button
Gtk::Widget * make_delete_button(RackBox &rb)
MiniRackBox::evbox
Gtk::EventBox evbox
Definition gx_main_window.h:335
MiniRackBox::set_config_mode
void set_config_mode(bool mode, PluginUI &plugin)
MiniRackBox::MiniRackBox
MiniRackBox(RackBox &rb, gx_system::CmdlineOptions &options)
MiniRackBox::on_off_switch
Gxw::Switch on_off_switch
Definition gx_main_window.h:340
MiniRackBox::on_my_enter_in
bool on_my_enter_in(GdkEventCrossing *focus)
NsmSignals
Definition gx_main_window.h:608
NsmSignals::~NsmSignals
~NsmSignals()
Definition gx_main_window.h:632
NsmSignals::trigger_nsm_gui_is_shown
sigc::signal< void > trigger_nsm_gui_is_shown
Definition gx_main_window.h:625
NsmSignals::trigger_nsm_hide_gui
sigc::signal< void > trigger_nsm_hide_gui
Definition gx_main_window.h:618
NsmSignals::trigger_nsm_show_gui
sigc::signal< void > trigger_nsm_show_gui
Definition gx_main_window.h:615
NsmSignals::signal_trigger_nsm_gui_is_hidden
sigc::signal< void > & signal_trigger_nsm_gui_is_hidden()
Definition gx_main_window.h:629
NsmSignals::NsmSignals
NsmSignals()
NsmSignals::signal_trigger_nsm_save_gui
sigc::signal< void > & signal_trigger_nsm_save_gui()
Definition gx_main_window.h:622
NsmSignals::trigger_nsm_save_gui
sigc::signal< void > trigger_nsm_save_gui
Definition gx_main_window.h:621
NsmSignals::signal_trigger_nsm_gui_is_shown
sigc::signal< void > & signal_trigger_nsm_gui_is_shown()
Definition gx_main_window.h:626
NsmSignals::signal_trigger_nsm_hide_gui
sigc::signal< void > & signal_trigger_nsm_hide_gui()
Definition gx_main_window.h:619
NsmSignals::nsm_session_control
bool nsm_session_control
Definition gx_main_window.h:613
NsmSignals::trigger_nsm_gui_is_hidden
sigc::signal< void > trigger_nsm_gui_is_hidden
Definition gx_main_window.h:628
NsmSignals::signal_trigger_nsm_show_gui
sigc::signal< void > & signal_trigger_nsm_show_gui()
Definition gx_main_window.h:616
PluginDict
Definition gx_main_window.h:502
PluginDict::use_animations
bool use_animations()
Definition gx_main_window.h:552
PluginDict::add_plugin_category
Gtk::ToolItemGroup * add_plugin_category(const char *cat, bool collapse=true)
PluginDict::check_order
void check_order()
PluginDict::check_order
void check_order(PluginType tp, bool animate)
PluginDict::uimanager
UIManager & uimanager
Definition gx_main_window.h:513
PluginDict::compress
void compress(bool state)
PluginDict::reorder
void reorder(RackContainer *container, const std::string &name, const std::string &before)
PluginDict::activate
PluginUI * activate(const string &id, const string &before, bool animate)
PluginDict::register_plugin
void register_plugin(PluginUI *pui)
PluginDict::deactivate
PluginUI * deactivate(const string &id, bool animate)
PluginDict::unit_order_changed
void unit_order_changed(bool stereo)
PluginDict::remove
void remove(PluginUI *p)
PluginDict::add_plugin_menu_entry
Glib::ustring add_plugin_menu_entry(PluginUI *pui)
PluginDict::get_options
gx_system::CmdlineOptions & get_options()
Definition gx_main_window.h:555
PluginDict::set_config_mode
void set_config_mode(bool state)
PluginDict::stereorackcontainer
RackContainer stereorackcontainer
Definition gx_main_window.h:505
PluginDict::iterator
std::map< std::string, PluginUI * >::iterator iterator
Definition gx_main_window.h:527
PluginDict::stereotargets
std::vector< std::string > stereotargets
Definition gx_main_window.h:508
PluginDict::plugin_preset_popup
void plugin_preset_popup(const PluginDef *pdef)
PluginDict::machine
gx_engine::GxMachineBase & machine
Definition gx_main_window.h:510
PluginDict::on_tp_drag_data_received
void on_tp_drag_data_received(const Glib::RefPtr< Gdk::DragContext > &context, int x, int y, const Gtk::SelectionData &data, int info, int timestamp)
PluginDict::category_id
Glib::ustring category_id(const std::string &group, bool stereo)
PluginDict::add_plugin
void add_plugin(std::vector< PluginUI * > &p, const char *id, const Glib::ustring &tooltip_="")
PluginDict::add
void add(PluginUI *p)
PluginDict::plugin_preset_popup
void plugin_preset_popup(const PluginDef *pdef, const Glib::ustring &name)
PluginDict::on_plugin_changed
void on_plugin_changed(gx_engine::Plugin *pl, gx_engine::PluginChange::pc c)
PluginDict::monotargets
std::vector< std::string > monotargets
Definition gx_main_window.h:507
PluginDict::PluginDict
PluginDict(gx_engine::GxMachineBase &machine, gx_system::CmdlineOptions &options, Gtk::ToolPalette &toolpalette, gx_gui::StackBoxBuilder &boxbuilder, UIManager &uimanager)
PluginDict::get_stereorackcontainer
RackContainer & get_stereorackcontainer()
Definition gx_main_window.h:544
PluginDict::boxbuilder
gx_gui::StackBoxBuilder & boxbuilder
Definition gx_main_window.h:509
PluginDict::groupmap
std::map< Glib::ustring, Gtk::ToolItemGroup * > groupmap
Definition gx_main_window.h:506
PluginDict::fill_pluginlist
void fill_pluginlist()
PluginDict::remove_plugin_menu_entry
void remove_plugin_menu_entry(PluginUI *pui)
PluginDict::plugins_hidden
bool plugins_hidden
Definition gx_main_window.h:515
PluginDict::add_rackbox_internal
RackBox * add_rackbox_internal(PluginUI &plugin, Gtk::Widget *mainwidget, Gtk::Widget *miniwidget, bool mini=false, int pos=-1, bool animate=false, Gtk::Widget *bare=0)
PluginDict::add_bare
void add_bare(const char *id, Gtk::Container *box)
PluginDict::hide_entries
void hide_entries()
PluginDict::toolpalette
Gtk::ToolPalette & toolpalette
Definition gx_main_window.h:512
PluginDict::get_machine
gx_engine::GxMachineBase & get_machine()
Definition gx_main_window.h:554
PluginDict::drag_icon
DragIcon * drag_icon
Definition gx_main_window.h:517
PluginDict::monorackcontainer
RackContainer monorackcontainer
Definition gx_main_window.h:504
PluginDict::get_config_mode
bool get_config_mode()
Definition gx_main_window.h:542
PluginDict::cleanup
void cleanup()
PluginDict::~PluginDict
~PluginDict()
PluginDict::get_monorackcontainer
RackContainer & get_monorackcontainer()
Definition gx_main_window.h:543
PluginDict::operator[]
PluginUI * operator[](const std::string &s)
Definition gx_main_window.h:536
PluginDict::add_rackbox
RackBox * add_rackbox(PluginUI &pl, bool mini=false, int pos=-1, bool animate=false)
PluginDict::stop_at
double stop_at(RackContainer *container, double off, double step_size, double page_size)
PluginDict::get_plugins_hidden
bool get_plugins_hidden()
Definition gx_main_window.h:540
PluginDict::pluginlist_append
void pluginlist_append(std::vector< PluginUI * > &p)
PluginDict::options
gx_system::CmdlineOptions & options
Definition gx_main_window.h:511
PluginDict::config_mode
bool config_mode
Definition gx_main_window.h:514
PluginDict::show_entries
void show_entries()
PluginPresetPopup::set_plugin_std_preset
void set_plugin_std_preset()
PluginPresetPopup::PluginPresetPopup
PluginPresetPopup(const PluginDef *pdef, gx_engine::GxMachineBase &machine, const Glib::ustring &save_name_default="")
PluginPresetPopup::get_pdef
const PluginDef * get_pdef()
Definition gx_main_window.h:685
PluginPresetPopup::on_selection_done
virtual void on_selection_done()
PluginPresetPopup::pdef
const PluginDef * pdef
Definition gx_main_window.h:669
PluginPresetPopup::begin
gx_preset::UnitPresetList::const_iterator begin()
Definition gx_main_window.h:683
PluginPresetPopup::machine
gx_engine::GxMachineBase & machine
Definition gx_main_window.h:670
PluginPresetPopup::save_name_default
const Glib::ustring save_name_default
Definition gx_main_window.h:671
PluginPresetPopup::remove_plugin_preset
void remove_plugin_preset()
PluginPresetPopup::end
gx_preset::UnitPresetList::const_iterator end()
Definition gx_main_window.h:684
PluginPresetPopup::save_plugin_preset
void save_plugin_preset()
PluginPresetPopup::add_plugin_preset_list
bool add_plugin_preset_list(bool *found)
PluginPresetPopup::get_machine
gx_engine::GxMachineBase & get_machine()
Definition gx_main_window.h:686
PluginPresetPopup::presetnames
gx_preset::UnitPresetList presetnames
Definition gx_main_window.h:672
PluginPresetPopup::set_plugin_preset
void set_plugin_preset(bool factory, const Glib::ustring &name)
PluginUI
Definition gx_main_window.h:410
PluginUI::get_name
const char * get_name() const
Definition gx_main_window.h:445
PluginUI::output_widget_state
sigc::signal< void(bool)> output_widget_state
state of output_widgets_active changed
Definition gx_main_window.h:421
PluginUI::plugins_by_name_less
friend bool plugins_by_name_less(PluginUI *a, PluginUI *b)
PluginUI::deactivate
void deactivate(bool animate)
PluginUI::activate
void activate(bool animate, const string &before)
PluginUI::RackContainer
friend class RackContainer
Definition gx_main_window.h:412
PluginUI::shortname
const char * shortname
Definition gx_main_window.h:424
PluginUI::on_plugin_preset_popup
virtual void on_plugin_preset_popup()
PluginUI::remove
void remove(bool animate)
PluginUI::get_type
PluginType get_type() const
Definition gx_main_window.h:437
PluginUI::has_gui
bool has_gui() const
Definition gx_main_window.h:440
PluginUI::on_my_leave_out
bool on_my_leave_out(GdkEventCrossing *focus)
PluginUI::action
Glib::RefPtr< ToggleAction > action
Definition gx_main_window.h:414
PluginUI::set_active
void set_active(bool v)
Definition gx_main_window.h:449
PluginUI::on_ti_drag_begin
void on_ti_drag_begin(const Glib::RefPtr< Gdk::DragContext > &context)
PluginUI::set_update_state
void set_update_state(bool state)
PluginUI::on_ti_drag_data_delete
void on_ti_drag_data_delete(const Glib::RefPtr< Gdk::DragContext > &context)
PluginUI::PluginUI
PluginUI(PluginDict &plugin_dict, const char *id_, const Glib::ustring &tooltip_="")
PluginUI::decativate
void decativate(bool animate)
PluginUI::hidden
bool hidden
Plugin not visible (but might be in rack, e.g. "Rack" is off).
Definition gx_main_window.h:419
PluginUI::dispose_rackbox
void dispose_rackbox()
PluginUI::~PluginUI
virtual ~PluginUI()
PluginUI::show
void show(bool animate)
PluginUI::get_id
const char * get_id() const
Definition gx_main_window.h:444
PluginUI::on_state_change
void on_state_change()
PluginUI::animate_vanish
bool animate_vanish()
PluginUI::on_my_enter_in
bool on_my_enter_in(GdkEventCrossing *focus)
PluginUI::tooltip
Glib::ustring tooltip
Definition gx_main_window.h:423
PluginUI::on_ti_drag_data_get
void on_ti_drag_data_get(const Glib::RefPtr< Gdk::DragContext > &context, Gtk::SelectionData &selection, int info, int timestamp)
PluginUI::group
Gtk::ToolItemGroup * group
Definition gx_main_window.h:416
PluginUI::is_registered
static bool is_registered(gx_engine::GxMachineBase &m, const char *name)
PluginUI::compress
void compress(bool state)
PluginUI::get_action
Glib::RefPtr< ToggleAction > get_action()
Definition gx_main_window.h:450
PluginUI::active
bool active
Plugin is in rack (effect bar icon not visible).
Definition gx_main_window.h:420
PluginUI::on_rack_handle_press
bool on_rack_handle_press(GdkEventButton *ev)
PluginUI::toolitem
Gtk::ToolItem * toolitem
Definition gx_main_window.h:417
PluginUI::output_widgets_active
bool output_widgets_active
send data updates for output variables
Definition gx_main_window.h:422
PluginUI::get_update_cond
bool get_update_cond()
PluginUI::plugin
gx_engine::Plugin * plugin
Definition gx_main_window.h:432
PluginUI::set_config_mode
void set_config_mode(bool state)
PluginUI::get_output_widget_state
sigc::signal< void(bool)> * get_output_widget_state()
Definition gx_main_window.h:490
PluginUI::on_ti_button_press
bool on_ti_button_press(GdkEventButton *ev)
PluginUI::on_ti_drag_end
void on_ti_drag_end(const Glib::RefPtr< Gdk::DragContext > &context)
PluginUI::get_category
const char * get_category()
Definition gx_main_window.h:453
PluginUI::update_rackbox
void update_rackbox()
PluginUI::plugin_dict
PluginDict & plugin_dict
Definition gx_main_window.h:435
PluginUI::PluginDict
friend class PluginDict
Definition gx_main_window.h:411
PluginUI::hide
void hide(bool animate)
PluginUI::rackbox
RackBox * rackbox
rack widget or nullptr
Definition gx_main_window.h:418
PluginUI::get_shortname
const char * get_shortname() const
Definition gx_main_window.h:457
PluginUI::set_action
void set_action(Glib::RefPtr< ToggleAction > &act)
PluginUI::add_toolitem
void add_toolitem(Gtk::ToolItemGroup *gw)
PluginUI::on_action_toggled
void on_action_toggled()
PluginUI::activate
void activate(bool animate)
PluginUI::get_displayname
Glib::ustring get_displayname(bool useshort) const
PresetWindow
Definition gx_preset_window.h:76
RackBox
Definition gx_main_window.h:273
RackBox::has_delete
bool has_delete() const
Definition gx_main_window.h:312
RackBox::PluginUI
friend class PluginUI
Definition gx_main_window.h:274
RackBox::plugin
PluginUI & plugin
Definition gx_main_window.h:276
RackBox::set_position
void set_position(int pos, int post_pre)
RackBox::on_my_drag_begin
void on_my_drag_begin(const Glib::RefPtr< Gdk::DragContext > &context)
RackBox::box
Gxw::PaintBox box
Definition gx_main_window.h:289
RackBox::anim_height
int anim_height
Definition gx_main_window.h:285
RackBox::set_config_mode
void set_config_mode(bool mode)
RackBox::on_my_drag_failed
bool on_my_drag_failed(const Glib::RefPtr< Gdk::DragContext > &context, Gtk::DragResult result)
RackBox::on_my_drag_end
void on_my_drag_end(const Glib::RefPtr< Gdk::DragContext > &context)
RackBox::compress
bool compress
Definition gx_main_window.h:279
RackBox::display
void display(bool v, bool animate)
RackBox::wrap_bar
Gtk::Widget * wrap_bar(int left=4, int right=4, bool sens=false)
RackBox::set_paintbox
static void set_paintbox(Gxw::PaintBox &pb, PluginType tp)
RackBox::delete_button
bool delete_button
Definition gx_main_window.h:280
RackBox::vis_switch
void vis_switch(Gtk::Widget &a, Gtk::Widget &b)
RackBox::mbox
Gxw::PaintBox mbox
Definition gx_main_window.h:281
RackBox::RackBox
RackBox(PluginUI &plugin, PluginDict &plugin_dict, Gtk::Widget *bare=0)
RackBox::make_label
static Gtk::Widget * make_label(const PluginUI &plugin, gx_system::CmdlineOptions &options, bool useshort=true)
RackBox::MiniRackBox
friend class MiniRackBox
Definition gx_main_window.h:319
RackBox::target_height
int target_height
Definition gx_main_window.h:288
RackBox::can_compress
bool can_compress()
Definition gx_main_window.h:318
RackBox::drag_icon
DragIcon * drag_icon
Definition gx_main_window.h:287
RackBox::animate_create
bool animate_create()
RackBox::fbox
Gtk::Widget * fbox
Definition gx_main_window.h:283
RackBox::minibox
MiniRackBox * minibox
Definition gx_main_window.h:282
RackBox::create_icon_widget
static Gtk::Widget * create_icon_widget(const PluginUI &plugin, gx_system::CmdlineOptions &options)
RackBox::get_plug_visible
bool get_plug_visible()
Definition gx_main_window.h:496
RackBox::enable_drag
void enable_drag(bool v)
RackBox::make_expand_button
Gtk::Button * make_expand_button(bool expand)
RackBox::on_my_enter_in
bool on_my_enter_in(GdkEventCrossing *focus)
RackBox::on_my_leave_out
bool on_my_leave_out(GdkEventCrossing *focus)
RackBox::create_drag_widget
static Gtk::Widget * create_drag_widget(const PluginUI &plugin, gx_system::CmdlineOptions &options)
RackBox::init_dnd
void init_dnd()
RackBox::anim_step
int anim_step
Definition gx_main_window.h:286
RackBox::swtch
void swtch(bool mini)
RackBox::get_parent
RackContainer * get_parent()
RackBox::plugin_dict
PluginDict & plugin_dict
Definition gx_main_window.h:277
RackBox::pack
void pack(Gtk::Widget *mainbox, Gtk::Widget *minibox)
RackBox::do_expand
void do_expand()
RackBox::make_preset_button
Gtk::Button * make_preset_button()
RackBox::set_paintbox_unit
static void set_paintbox_unit(Gxw::PaintBox &pb, const PluginUI &plugin)
RackBox::on_off_switch
Gxw::Switch on_off_switch
Definition gx_main_window.h:290
RackBox::animate_insert
void animate_insert()
RackBox::anim_tag
sigc::connection anim_tag
Definition gx_main_window.h:278
RackBox::get_id
const char * get_id() const
Definition gx_main_window.h:495
RackBox::make_bar
static Gtk::Widget * make_bar(int left=4, int right=4, bool sens=false)
RackBox::set_paintbox_unit_shrink
static void set_paintbox_unit_shrink(Gxw::PaintBox &pb, PluginType tp)
RackBox::set_visibility
void set_visibility(bool v)
RackBox::make_full_box
Gtk::HBox * make_full_box(gx_system::CmdlineOptions &options)
RackBox::target
std::string target
Definition gx_main_window.h:284
RackBox::compare_position
bool compare_position(int pos, int post_pre)
RackBox::on_my_drag_data_get
void on_my_drag_data_get(const Glib::RefPtr< Gdk::DragContext > &context, Gtk::SelectionData &selection, int info, int timestamp)
RackContainer
Definition gx_main_window.h:358
RackContainer::ensure_visible
void ensure_visible(RackBox &child)
RackContainer::on_drag_leave
virtual void on_drag_leave(const Glib::RefPtr< Gdk::DragContext > &context, guint timestamp)
RackContainer::scroll_timeout
bool scroll_timeout()
RackContainer::scrollother_timeout
bool scrollother_timeout()
RackContainer::rackbox_const_list
Glib::ListHandle< const RackBox * > rackbox_const_list
Definition gx_main_window.h:379
RackContainer::count
int count
count of visible children
Definition gx_main_window.h:362
RackContainer::change_child_count
void change_child_count(int n)
Definition gx_main_window.h:401
RackContainer::stop_at_bottom
double stop_at_bottom(double off, double step_size, double pagesize)
RackContainer::get_children
rackbox_const_list get_children() const
Definition gx_main_window.h:387
RackContainer::add
void add(RackBox &r, int pos=-1)
RackContainer::targets
std::vector< std::string > targets
Definition gx_main_window.h:363
RackContainer::stop_at_top
double stop_at_top(double off, double step_size)
RackContainer::drag_highlight_draw
bool drag_highlight_draw(const Cairo::RefPtr< Cairo::Context > &, int y0)
RackContainer::rackbox_list
Glib::ListHandle< RackBox * > rackbox_list
Definition gx_main_window.h:380
RackContainer::set_list_targets
void set_list_targets(const std::vector< Gtk::TargetEntry > &listTargets, const std::vector< std::string > &targets_, const std::vector< std::string > &othertargets_)
RackContainer::othertargets
std::vector< std::string > othertargets
Definition gx_main_window.h:364
RackContainer::RackContainer
RackContainer(PluginDict &plugin_dict)
RackContainer::autoscroll_connection
sigc::connection autoscroll_connection
Definition gx_main_window.h:366
RackContainer::set_child_count
void set_child_count(int n)
RackContainer::check_targets
bool check_targets(const std::vector< std::string > &tgts1, const std::vector< std::string > &tgts2)
RackContainer::on_drag_motion
virtual bool on_drag_motion(const Glib::RefPtr< Gdk::DragContext > &context, int x, int y, guint timestamp)
RackContainer::highlight_connection
sigc::connection highlight_connection
Definition gx_main_window.h:365
RackContainer::on_add
virtual void on_add(Widget *ch)
RackContainer::renumber
void renumber()
RackContainer::plugin_dict
PluginDict & plugin_dict
Definition gx_main_window.h:360
RackContainer::on_drag_data_received
virtual void on_drag_data_received(const Glib::RefPtr< Gdk::DragContext > &context, int x, int y, const Gtk::SelectionData &data, guint info, guint timestamp)
RackContainer::get_children
rackbox_list get_children()
Definition gx_main_window.h:382
RackContainer::reorder
void reorder(const std::string &name, const std::string &before)
Definition gx_main_window.h:996
RackContainer::in_drag
int in_drag
Definition gx_main_window.h:361
RackContainer::find_index
void find_index(int x, int y, string *before, int *ypos)
RadioAction::get_current_value
bool get_current_value() const
Definition gx_main_window.h:78
RadioAction::create
static Glib::RefPtr< RadioAction > create(const Glib::ustring &name)
Definition gx_main_window.h:75
RadioAction::set_current_value
void set_current_value(int v)
Definition gx_main_window.h:79
RadioAction::RadioAction
RadioAction(const Glib::ustring &name)
SelectMidiChannel
Definition gx_main_window.h:758
SelectMidiChannel::create
static SelectMidiChannel * create(gx_system::CmdlineOptions &opt, gx_engine::GxMachineBase &machine)
SelectMidiChannel::description
Gtk::Label * description
Definition gx_main_window.h:760
SelectMidiChannel::on_delete_event
bool on_delete_event(GdkEventAny *event)
SelectMidiChannel::on_key_press_event
bool on_key_press_event(GdkEventKey *event)
SelectMidiChannel::on_ok_button
void on_ok_button()
SelectMidiChannel::SelectMidiChannel
SelectMidiChannel(BaseObjectType *cobject, Glib::RefPtr< gx_gui::GxBuilder > bld, gx_engine::GxMachineBase &m)
SelectMidiChannel::machine
gx_engine::GxMachineBase & machine
Definition gx_main_window.h:762
SelectMidiChannel::signal_close
sigc::signal< void > & signal_close()
Definition gx_main_window.h:775
SelectMidiChannel::~SelectMidiChannel
~SelectMidiChannel()
SelectMidiChannel::on_cancel_button
void on_cancel_button()
SelectMidiChannel::channelcombo
Gtk::ComboBox * channelcombo
Definition gx_main_window.h:761
SelectMidiChannel::create_from_builder
static SelectMidiChannel * create_from_builder(BaseObjectType *cobject, Glib::RefPtr< gx_gui::GxBuilder > bld, gx_engine::GxMachineBase &m)
Definition gx_main_window.h:768
SelectMidiChannel::close
sigc::signal< void > close
Definition gx_main_window.h:763
TextLoggingBox
Definition gx_main_window.h:572
TextLoggingBox::on_hide
virtual void on_hide()
TextLoggingBox::box
Gtk::VBox box
Definition gx_main_window.h:578
TextLoggingBox::signal_msg_level_changed
sigc::signal< void > & signal_msg_level_changed()
Definition gx_main_window.h:597
TextLoggingBox::get_unseen_msg_level
int get_unseen_msg_level()
Definition gx_main_window.h:596
TextLoggingBox::reset_msg_level
void reset_msg_level()
TextLoggingBox::ok_button
Gtk::Button ok_button
Definition gx_main_window.h:579
TextLoggingBox::tbox
Gtk::TextView tbox
Definition gx_main_window.h:582
TextLoggingBox::scrollbox
Gtk::ScrolledWindow scrollbox
Definition gx_main_window.h:581
TextLoggingBox::TextLoggingBox
TextLoggingBox()
TextLoggingBox::highest_unseen_msg_level
int highest_unseen_msg_level
Definition gx_main_window.h:585
TextLoggingBox::msg_level_changed
sigc::signal< void > msg_level_changed
Definition gx_main_window.h:586
TextLoggingBox::buttonbox
Gtk::HButtonBox buttonbox
Definition gx_main_window.h:580
TextLoggingBox::show_msg
void show_msg(string msgbuf, GxLogger::MsgType msgtype, bool plugged)
TextLoggingBox::tags
Glib::RefPtr< Gtk::TextTag > tags[GxLogger::kMessageTypeCount]
Definition gx_main_window.h:584
TextLoggingBox::~TextLoggingBox
~TextLoggingBox()
TextLoggingBox::on_key_press_event
virtual bool on_key_press_event(GdkEventKey *event)
TextLoggingBox::on_show
virtual void on_show()
TextLoggingBox::tagdefs
static tab_table tagdefs[GxLogger::kMessageTypeCount]
Definition gx_main_window.h:583
ToggleAction::set_active
void set_active(bool v)
ToggleAction::ToggleAction
ToggleAction(const Glib::ustring &name, bool state)
Definition gx_main_window.h:61
ToggleAction::signal_toggled
Glib::SignalProxyProperty signal_toggled()
Definition gx_main_window.h:66
ToggleAction::get_active
bool get_active() const
Definition gx_main_window.h:67
ToggleAction::create
static Glib::RefPtr< ToggleAction > create(const Glib::ustring &name, bool state=false)
Definition gx_main_window.h:64
TunerSwitcher::SwitcherState
SwitcherState
Definition tunerswitcher.h:31
UIManager
Definition gx_main_window.h:109
UIManager::remove_item
bool remove_item(const Glib::ustring &action)
UIManager::insert_action_group
void insert_action_group(Glib::RefPtr< Gio::SimpleActionGroup > &group)
Definition gx_main_window.h:123
UIManager::menubar
Gtk::MenuBar * menubar
Definition gx_main_window.h:116
UIManager::foreach_menu
bool foreach_menu(search_func func)
Definition gx_main_window.h:127
UIManager::menu
Glib::RefPtr< Gio::Menu > menu
Definition gx_main_window.h:113
UIManager::UIManager
UIManager(const std::string &file, Gtk::MenuBar *bar)
UIManager::add_toggle_action
Glib::RefPtr< ToggleAction > add_toggle_action(const Glib::ustring &action, bool state=false)
UIManager::set_accelerators_from_menu
void set_accelerators_from_menu()
Definition gx_main_window.h:126
UIManager::add_accelerator
void add_accelerator(Glib::RefPtr< Gio::Action > action, Glib::VariantBase &target, const Glib::ustring &accelerator)
UIManager::set_widget_action
static void set_widget_action(Gtk::Widget *w, const Glib::ustring &action)
UIManager::add_accelerator
static void add_accelerator(Glib::RefPtr< Gtk::AccelGroup > &group, Glib::RefPtr< Gio::Action > action, const Glib::ustring &accelerator, Glib::VariantBase &target)
UIManager::find_item
Gtk::MenuItem * find_item(const Glib::ustring &action)
UIManager::get_linked_menu
Glib::RefPtr< Gio::Menu > get_linked_menu(const Glib::ustring &action)
UIManager::add_action
Glib::RefPtr< Gio::SimpleAction > add_action(const Glib::ustring &action, sigc::slot< void()> slot)
UIManager::add_ui_bool_action
Glib::RefPtr< UiBoolToggleAction > add_ui_bool_action(gx_engine::GxMachineBase &machine, const std::string &id, const Glib::ustring &name, bool is_active=false)
UIManager::actiongroup
Glib::RefPtr< Gio::SimpleActionGroup > actiongroup
Definition gx_main_window.h:115
UIManager::search_func
std::function< bool(const Glib::ustring &, Glib::RefPtr< Gio::Menu > &, int, int)> search_func
Definition gx_main_window.h:111
UIManager::accelgroup
Glib::RefPtr< Gtk::AccelGroup > accelgroup
Definition gx_main_window.h:114
UIManager::set_accelerators_from_menu
void set_accelerators_from_menu(Glib::RefPtr< Gio::Menu > &menu)
UIManager::set_widget_action
static void set_widget_action(Gtk::Widget *w, const Glib::RefPtr< Gio::Action > &action)
UIManager::add_action
Glib::RefPtr< Gio::SimpleAction > add_action(const Glib::ustring &action)
UIManager::foreach_menu_
bool foreach_menu_(Glib::RefPtr< Gio::Menu > &menu, search_func &func, int &startpos)
UIManager::get_action_group
Glib::RefPtr< Gio::SimpleActionGroup > & get_action_group()
Definition gx_main_window.h:122
UIManager::add_radio_action
Glib::RefPtr< RadioAction > add_radio_action(const Glib::ustring &action)
UIManager::get_accel_group
Glib::RefPtr< Gtk::AccelGroup > & get_accel_group()
Definition gx_main_window.h:121
UiToggleAction
Definition gx_main_window.h:83
UiToggleAction::~UiToggleAction
~UiToggleAction()
UiToggleAction::UiToggleAction
UiToggleAction(gx_engine::GxMachineBase &machine_, const std::string &id, const Glib::ustring &name, bool is_active=false)
UiToggleAction< bool >::machine
gx_engine::GxMachineBase & machine
Definition gx_main_window.h:85
UiToggleAction::create
static Glib::RefPtr< UiToggleAction > create(gx_engine::GxMachineBase &machine, const std::string &id, const Glib::ustring &name, bool is_active=false)
Definition gx_main_window.h:94
UiToggleAction< bool >::id
std::string id
Definition gx_main_window.h:86
UiToggleAction::on_toggled
void on_toggled()
gx_engine::GxMachineBase
Definition machine.h:59
gx_engine::Plugin
Definition gx_pluginloader.h:45
gx_gui::SelectJackControlPgm
Definition gx_jack_options.h:38
gx_gui::StackBoxBuilder
Definition gx_stackbox_builder.h:44
gx_portmap::PortMapWindow
Definition gx_portmap.h:58
gx_system::CmdlineOptions
Definition gx_system.h:395
ladspa::PluginDisplay
Definition ladspalist.h:85
N_
#define N_(String)
Definition gx_faust_support.h:25
plugins_by_name_less
bool plugins_by_name_less(PluginUI *a, PluginUI *b)
UiBoolToggleAction
UiToggleAction< bool > UiBoolToggleAction
Definition gx_main_window.h:102
PGN_GUI
@ PGN_GUI
Definition gx_plugin.h:177
PGN_STEREO
@ PGN_STEREO
Definition gx_plugin.h:174
PluginType
PluginType
Definition machine.h:38
PLUGIN_TYPE_MONO
@ PLUGIN_TYPE_MONO
Definition machine.h:39
PLUGIN_TYPE_STEREO
@ PLUGIN_TYPE_STEREO
Definition machine.h:40
gx_engine::GxEngineState
GxEngineState
Definition gx_modulesequencer.h:301
gx_preset::UnitPresetList
std::vector< PluginPresetEntry > UnitPresetList
Definition gx_preset.h:138
PluginDef
Definition gx_plugin.h:195
PluginDef::flags
int flags
Definition gx_plugin.h:197
PluginDef::load_ui
uiloader load_ui
Definition gx_plugin.h:215
TextLoggingBox::tab_table
Definition gx_main_window.h:574
TextLoggingBox::tab_table::tagname
const char * tagname
Definition gx_main_window.h:575
TextLoggingBox::tab_table::tag_color
const char * tag_color
Definition gx_main_window.h:576
gx_engine::PluginChange::pc
pc
Definition gx_engine.h:66