Guitarix
gx_main_window.h
Go to the documentation of this file.
1 /*
2  * Copyright (C) 2009, 2010 Hermann Meyer, James Warden, Andreas Degert
3  * Copyright (C) 2011 Pete Shorthose
4  *
5  * This program is free software; you can redistribute it and/or modify
6  * it under the terms of the GNU General Public License as published by
7  * the Free Software Foundation; either version 2 of the License, or
8  * (at your option) any later version.
9  *
10  * This program is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13  * GNU General Public License for more details.
14  *
15  * You should have received a copy of the GNU General Public License
16  * along with this program; if not, write to the Free Software
17  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
18  * ---------------------------------------------------------------------------
19  *
20  * This is the gx_head GUI main class
21  *
22  * ----------------------------------------------------------------------------
23  */
24 
25 /****************************************************************
26  ** class GxTheme
27  */
28 
29 class GxTheme {
30 private:
32  Glib::RefPtr<Gtk::CssProvider> css_provider;
33  Glib::RefPtr<Gtk::CssProvider> css_show_values;
34  Glib::RefPtr<Gtk::StyleContext> style_context;
35 #ifndef NDEBUG
36  Gtk::Window *window;
39 #endif
40 public:
41  GxTheme() {}
43  bool set_new_skin(const Glib::ustring& skin_name);
45 #ifndef NDEBUG
46  void reload_css();
47  void set_window(Gtk::Window *window_) { window = window_; }
48 #endif
49 };
50 
51 
52 /****************************************************************
53  ** Actions:
54  ** class ToggleAction
55  ** class RadioAction
56  ** template class UiToggleAction
57  */
58 
59 class ToggleAction: public Gio::SimpleAction {
60 protected:
61  ToggleAction(const Glib::ustring& name, bool state)
62  : Gio::SimpleAction(name, Glib::Variant<bool>::create(state)) {}
63 public:
64  static Glib::RefPtr<ToggleAction> create(const Glib::ustring& name, bool state=false) {
65  return Glib::RefPtr<ToggleAction>(new ToggleAction(name, state)); }
66  Glib::SignalProxyProperty signal_toggled() { return property_state().signal_changed(); }
67  bool get_active() const { bool v; get_state(v); return v; }
68  void set_active(bool v);
69 };
70 
71 class RadioAction: public Gio::SimpleAction {
72 protected:
73  RadioAction(const Glib::ustring& name);
74 public:
75  static Glib::RefPtr<RadioAction> create(const Glib::ustring& name) {
76  return Glib::RefPtr<RadioAction>(new RadioAction(name)); }
77 
78  bool get_current_value() const { int v; get_state(v); return v; }
79  void set_current_value(int v) { change_state(v); }
80 };
81 
82 template <class T>
84 private:
86  std::string id;
87  void on_toggled();
88 protected:
90  gx_engine::GxMachineBase& machine_, const std::string& id,
91  const Glib::ustring& name, bool is_active=false);
93 public:
94  static Glib::RefPtr<UiToggleAction> create(
95  gx_engine::GxMachineBase& machine, const std::string& id,
96  const Glib::ustring& name, bool is_active=false) {
97  return Glib::RefPtr<UiToggleAction>(
98  new UiToggleAction(machine, id, name, is_active));
99  }
100 };
101 
103 
104 
105 /****************************************************************
106  ** class UIManager
107  */
108 
109 class UIManager {
110 public:
111  typedef std::function<bool(const Glib::ustring&, Glib::RefPtr<Gio::Menu>&, int, int)> search_func;
112 private:
113  Glib::RefPtr<Gio::Menu> menu;
114  Glib::RefPtr<Gtk::AccelGroup> accelgroup;
115  Glib::RefPtr<Gio::SimpleActionGroup> actiongroup;
116  Gtk::MenuBar *menubar;
117  void set_accelerators_from_menu(Glib::RefPtr<Gio::Menu>& menu);
118  bool foreach_menu_(Glib::RefPtr<Gio::Menu>& menu, search_func& func, int& startpos);
119 public:
120  UIManager(const std::string& file, Gtk::MenuBar *bar);
121  Glib::RefPtr<Gtk::AccelGroup>& get_accel_group() { return accelgroup; }
122  Glib::RefPtr<Gio::SimpleActionGroup>& get_action_group() { return actiongroup; }
123  void insert_action_group(Glib::RefPtr<Gio::SimpleActionGroup>& group) { actiongroup = group; }
124 
125 
127  bool foreach_menu(search_func func) { int pos = 0; return foreach_menu_(menu, func, pos); }
128  Glib::RefPtr<Gio::SimpleAction> add_action(const Glib::ustring& action);
129  Glib::RefPtr<Gio::SimpleAction> add_action(const Glib::ustring& action, sigc::slot<void()> slot);
130  Glib::RefPtr<ToggleAction> add_toggle_action(const Glib::ustring& action, bool state = false);
131  Glib::RefPtr<RadioAction> add_radio_action(const Glib::ustring& action);
132  Glib::RefPtr<UiBoolToggleAction> add_ui_bool_action(
133  gx_engine::GxMachineBase& machine, const std::string& id,
134  const Glib::ustring& name, bool is_active=false);
135  static void add_accelerator(Glib::RefPtr<Gtk::AccelGroup>& group,
136  Glib::RefPtr<Gio::Action> action,
137  const Glib::ustring& accelerator,
138  Glib::VariantBase& target);
139  void add_accelerator(Glib::RefPtr<Gio::Action> action, Glib::VariantBase& target,
140  const Glib::ustring& accelerator);
141  Glib::RefPtr<Gio::Menu> get_linked_menu(const Glib::ustring& action);
142  Gtk::MenuItem *find_item(const Glib::ustring& action);
143  bool remove_item(const Glib::ustring& action);
144  static void set_widget_action(Gtk::Widget *w, const Glib::ustring& action);
145  static void set_widget_action(Gtk::Widget *w, const Glib::RefPtr<Gio::Action>& action);
146 };
147 
148 /****************************************************************
149  ** class KeySwitcher
150  */
151 
152 class KeySwitcher: public sigc::trackable {
153 private:
155  sigc::slot<void, const Glib::ustring&, const Glib::ustring&> display;
156  sigc::connection key_timeout;
157  Glib::ustring last_bank_key;
158 private:
159  void display_empty(const Glib::ustring& bank, const Glib::ustring& preset);
162 public:
164  sigc::slot<void, const Glib::ustring&, const Glib::ustring&> display_)
165  : machine(machine_), display(display_) {}
166  bool process_bank_key(int key);
167  bool process_preset_key(int key);
169  void deactivate();
170  static char idx_to_char(int idx);
171  static int key_offset_to_idx(int offset);
172  static char bank_idx_to_char(int idx, int bank_size);
173  static int key_offset_to_bank_idx(int offset, int bank_size);
174  static int next_idx(int idx = -1);
175 };
176 
177 
178 /****************************************************************
179  ** class Liveplay
180  */
181 
182 class Liveplay: public sigc::trackable {
183 private:
184  Glib::RefPtr<gx_gui::GxBuilder> bld;
188  Glib::RefPtr<Gtk::Adjustment> brightness_adj;
189  Glib::RefPtr<Gtk::Adjustment> background_adj;
191  sigc::connection midi_conn;
192  Gtk::Window *window;
193  sigc::connection mouse_hide_conn;
194  //
195  Gtk::Image *bypass_image;
196  Gtk::Image *mute_image;
197  Gtk::Label *liveplay_bank;
198  Gtk::Label *liveplay_preset;
199  Gtk::Widget *liveplay_canvas;
200  Gxw::HSlider *brightness_slider;
201  Gtk::Box *brightness_box;
202  Gxw::HSlider *background_slider;
203  Gtk::ToggleButton *liveplay_exit;
204  Gtk::Grid *midictrl_table;
205  Gxw::RackTuner *tuner;
206 private:
208  bool on_delete(GdkEventAny *ev);
211  bool transparent_draw(const Cairo::RefPtr<Cairo::Context> &cr);
212  bool window_draw(const Cairo::RefPtr<Cairo::Context> &cr);
213  void on_realize();
215  void on_selection_done(bool v);
218  GtkAccelGroup *accel_group, GObject *acceleratable,
219  guint keyval, GdkModifierType modifier, Liveplay& self);
221  GtkAccelGroup *accel_group, GObject *acceleratable,
222  guint keyval, GdkModifierType modifier, Liveplay& self);
224  GtkAccelGroup *accel_group, GObject *acceleratable,
225  guint keyval, GdkModifierType modifier, Liveplay& self);
226  static bool on_keyboard_arrows(
227  GtkAccelGroup *accel_group, GObject *acceleratable,
228  guint keyval, GdkModifierType modifier, Liveplay& self);
230  GtkAccelGroup *accel_group, GObject *acceleratable,
231  guint keyval, GdkModifierType modifier, Liveplay& self);
232  bool pointer_motion(GdkEventMotion* event);
233  void display(const Glib::ustring& bank, const Glib::ustring& preset);
235 public:
237  const std::string& fname, const GxActions& actions,
238  Glib::RefPtr<Gio::SimpleActionGroup>& group);
240  void on_live_play(Glib::RefPtr<ToggleAction> act);
241  void display_tuner(bool v);
242  Gxw::RackTuner& get_tuner() { return *tuner; }
243 };
244 
245 
246 /****************************************************************
247  ** class DragIcon
248  */
249 
250 class DragIcon {
251 private:
252  enum { gradient_length = 60 };
253  Gtk::Window *window;
254  Glib::RefPtr<Gdk::Pixbuf> drag_icon_pixbuf;
255 private:
256  bool icon_draw(const Cairo::RefPtr<Cairo::Context> &cr);
257  void create_drag_icon_pixbuf(const PluginUI& plugin, Glib::RefPtr<Gdk::Visual> rgba, gx_system::CmdlineOptions& options);
258  bool window_draw(const Cairo::RefPtr<Cairo::Context> &cr, Gtk::OffscreenWindow& w);
259 public:
260  DragIcon(PluginUI& plugin, Glib::RefPtr<Gdk::DragContext> context, gx_system::CmdlineOptions& options, int xoff=0);
262 };
263 
264 
265 /****************************************************************
266  ** class RackBox, class MiniRackBox
267  */
268 
269 class MainWindow;
270 class RackContainer;
271 class MiniRackBox;
272 
273 class RackBox: public Gtk::VBox {
274  friend class PluginUI;
275 private:
278  sigc::connection anim_tag;
279  bool compress;
281  Gxw::PaintBox mbox;
283  Gtk::Widget *fbox;
284  std::string target;
289  Gxw::PaintBox box;
290  Gxw::Switch on_off_switch;
291 private:
292  static void set_paintbox(Gxw::PaintBox& pb, PluginType tp);
293  static void set_paintbox_unit(Gxw::PaintBox& pb, const PluginUI& plugin);
294  static void set_paintbox_unit_shrink(Gxw::PaintBox& pb, PluginType tp);
295  static Gtk::Widget *make_label(const PluginUI& plugin, gx_system::CmdlineOptions& options, bool useshort=true);
296  static Gtk::Widget *make_bar(int left=4, int right=4, bool sens=false);
297  Gtk::Widget *wrap_bar(int left=4, int right=4, bool sens=false);
298  void init_dnd();
299  void enable_drag(bool v);
300  void on_my_drag_begin(const Glib::RefPtr<Gdk::DragContext>& context);
302  bool on_my_leave_out(GdkEventCrossing *focus);
303  bool on_my_enter_in(GdkEventCrossing *focus);
304  void on_my_drag_end(const Glib::RefPtr<Gdk::DragContext>& context);
305  bool on_my_drag_failed(const Glib::RefPtr<Gdk::DragContext>& context, Gtk::DragResult result);
306  void on_my_drag_data_get(const Glib::RefPtr<Gdk::DragContext>& context, Gtk::SelectionData& selection, int info, int timestamp);
307  void vis_switch(Gtk::Widget& a, Gtk::Widget& b);
308  void set_visibility(bool v);
309  Gtk::Button *make_expand_button(bool expand);
310  Gtk::Button *make_preset_button();
312  bool has_delete() const { return delete_button; }
313  void do_expand();
314 public:
315  RackBox(PluginUI& plugin, PluginDict& plugin_dict, Gtk::Widget* bare=0);
316  static Gtk::Widget *create_drag_widget(const PluginUI& plugin, gx_system::CmdlineOptions& options);
318  bool can_compress() { return compress; }
319  friend class MiniRackBox;
320  const char *get_id() const;
321  void set_config_mode(bool mode);
322  void swtch(bool mini);
323  void pack(Gtk::Widget *mainbox, Gtk::Widget *minibox);
325  static Gtk::Widget *create_icon_widget(const PluginUI& plugin, gx_system::CmdlineOptions& options);
326  void set_position(int pos, int post_pre);
327  bool compare_position(int pos, int post_pre);
328  void display(bool v, bool animate);
329  bool get_plug_visible();
330 };
331 
332 class MiniRackBox: public Gtk::HBox {
333 private:
334  static Glib::RefPtr<Gtk::SizeGroup> szg_label;
335  Gtk::EventBox evbox;
336  Gtk::HBox mconbox;
337  Gtk::Button *mb_expand_button;
338  Gtk::Widget *mb_delete_button;
339  Gtk::Button *preset_button;
340  Gxw::Switch on_off_switch;
341  bool on_my_leave_out(GdkEventCrossing *focus);
342  bool on_my_enter_in(GdkEventCrossing *focus);
343  sigc::connection evbox_button;
344 private:
345  Gtk::Widget *make_delete_button(RackBox& rb);
346 public:
348  void set_config_mode(bool mode, PluginUI& plugin);
349  void pack(Gtk::Widget *w);
350 };
351 
352 /****************************************************************
353  ** class RackContainer
354  */
355 
356 class PluginDict;
357 
358 class RackContainer: public Gtk::VBox {
359 private:
361  int in_drag;
362  int count;
363  std::vector<std::string> targets;
364  std::vector<std::string> othertargets;
365  sigc::connection highlight_connection;
366  sigc::connection autoscroll_connection;
367 private:
368  using Gtk::VBox::add;
369  bool drag_highlight_draw(const Cairo::RefPtr<Cairo::Context>&, int y0);
370  void find_index(int x, int y, string* before, int *ypos);
371  bool check_targets(const std::vector<std::string>& tgts1, const std::vector<std::string>& tgts2);
372  virtual bool on_drag_motion(const Glib::RefPtr<Gdk::DragContext>& context, int x, int y, guint timestamp);
373  virtual void on_drag_leave(const Glib::RefPtr<Gdk::DragContext>& context, guint timestamp);
374  virtual void on_drag_data_received(const Glib::RefPtr<Gdk::DragContext>& context, int x, int y, const Gtk::SelectionData& data, guint info, guint timestamp);
375  virtual void on_add(Widget* ch);
378 public:
379  typedef Glib::ListHandle<const RackBox*> rackbox_const_list;
380  typedef Glib::ListHandle<RackBox*> rackbox_list;
383  return rackbox_list(
384  gtk_container_get_children(GTK_CONTAINER(gobj())),
385  Glib::OWNERSHIP_SHALLOW);
386  }
388  return rackbox_const_list(
389  gtk_container_get_children(const_cast<GtkContainer*>(GTK_CONTAINER(gobj()))),
390  Glib::OWNERSHIP_SHALLOW);
391  }
392  void add(RackBox& r, int pos=-1);
393  void ensure_visible(RackBox& child);
394  void renumber();
395  double stop_at_bottom(double off, double step_size, double pagesize);
396  double stop_at_top(double off, double step_size);
397  void set_list_targets(const std::vector<Gtk::TargetEntry>& listTargets,
398  const std::vector<std::string>& targets_,
399  const std::vector<std::string>& othertargets_);
400  void set_child_count(int n);
402  inline void reorder(const std::string& name, const std::string& before);
403 };
404 
405 
406 /****************************************************************
407  ** class PluginUI
408  */
409 
410 class PluginUI: public sigc::trackable {
411  friend class PluginDict;
412  friend class RackContainer;
413 private:
414  Glib::RefPtr<ToggleAction> action;
415  // data for ToolPalette entry
416  Gtk::ToolItemGroup *group;
417  Gtk::ToolItem *toolitem;
419  bool hidden;
420  bool active;
421  sigc::signal<void(bool)> output_widget_state;
423  Glib::ustring tooltip;
424  const char *shortname;
425 private:
428 protected:
429  PluginUI(PluginDict& plugin_dict, const char* id_, const Glib::ustring& tooltip_="");
430  virtual ~PluginUI();
431 public:
433 
434 
436 
439  }
440  bool has_gui() const {
441  PluginDef const * const pdef = plugin->get_pdef();
442  return pdef->flags & PGN_GUI || pdef->load_ui;
443  }
444  const char *get_id() const { return plugin->get_pdef()->id; }
445  const char *get_name() const { return plugin->get_pdef()->name; }
446  void activate(bool animate);
447  void decativate(bool animate);
448  void set_action(Glib::RefPtr<ToggleAction>& act);
449  void set_active(bool v) { if (action) action->set_active(v); }
450  Glib::RefPtr<ToggleAction> get_action() { return action; }
451  static bool is_registered(gx_engine::GxMachineBase& m, const char *name);
452  virtual void on_plugin_preset_popup();
453  inline const char *get_category() {
454  const char *cat = plugin->get_pdef()->category;
455  return (cat && *cat) ? cat : N_("External");
456  }
457  inline const char *get_shortname() const {
458  const char *name = shortname;
459  if (!name) {
460  name = plugin->get_pdef()->shortname;
461  }
462  if (!name || !*name) {
463  name = get_name();
464  }
465  return name;
466  }
468  void compress(bool state);
469  void hide(bool animate);
470  void show(bool animate);
471  void set_config_mode(bool state);
473  void on_ti_drag_begin(const Glib::RefPtr<Gdk::DragContext>& context);
474  void on_ti_drag_end(const Glib::RefPtr<Gdk::DragContext>& context);
475  void on_ti_drag_data_get(const Glib::RefPtr<Gdk::DragContext>& context, Gtk::SelectionData& selection, int info, int timestamp);
476  void on_ti_drag_data_delete(const Glib::RefPtr<Gdk::DragContext>& context);
477  bool on_ti_button_press(GdkEventButton *ev);
478  bool on_my_leave_out(GdkEventCrossing *focus);
479  bool on_my_enter_in(GdkEventCrossing *focus);
480  void add_toolitem(Gtk::ToolItemGroup *gw);
481  void activate(bool animate, const string& before);
482  void deactivate(bool animate);
484  void set_update_state(bool state);
486  void remove(bool animate);
488  bool on_rack_handle_press(GdkEventButton* ev);
489  Glib::ustring get_displayname(bool useshort) const;
490  sigc::signal<void(bool)> *get_output_widget_state() { return &output_widget_state; }
491 };
492 
494 
495 inline const char *RackBox::get_id() const { return plugin.get_id(); }
497 
498 /****************************************************************
499  ** class PluginDict
500  */
501 
502 class PluginDict: private std::map<std::string, PluginUI*> {
503 private:
506  std::map<Glib::ustring, Gtk::ToolItemGroup*> groupmap;
507  std::vector<std::string> monotargets;
508  std::vector<std::string> stereotargets;
512  Gtk::ToolPalette& toolpalette;
516 public:
518 private:
519  Glib::ustring category_id(const std::string& group, bool stereo);
521  Gtk::ToolItemGroup *add_plugin_category(const char *cat, bool collapse = true);
522  Glib::ustring add_plugin_menu_entry(PluginUI *pui);
526 public:
527  typedef std::map<std::string, PluginUI*>::iterator iterator;
529  Gtk::ToolPalette& toolpalette, gx_gui::StackBoxBuilder& boxbuilder,
532  void cleanup();
533  void add_bare(const char * id, Gtk::Container *box);
534  void add(PluginUI *p);
535  void remove(PluginUI *p);
536  PluginUI *operator[](const std::string& s) { return find(s)->second; }
537  using std::map<std::string, PluginUI*>::begin;
538  using std::map<std::string, PluginUI*>::end;
539  void compress(bool state);
541  void set_config_mode(bool state);
542  bool get_config_mode() { return config_mode; }
545  double stop_at(RackContainer *container, double off, double step_size, double page_size);
546  void show_entries();
547  void hide_entries();
548  void check_order();
549  void check_order(PluginType tp, bool animate);
550  void unit_order_changed(bool stereo);
551  void reorder(RackContainer *container, const std::string& name, const std::string& before);
553  void on_tp_drag_data_received(const Glib::RefPtr<Gdk::DragContext>& context, int x, int y, const Gtk::SelectionData& data, int info, int timestamp);
556  void plugin_preset_popup(const PluginDef *pdef);
557  void plugin_preset_popup(const PluginDef *pdef, const Glib::ustring& name);
558  RackBox *add_rackbox_internal(PluginUI& plugin, Gtk::Widget *mainwidget, Gtk::Widget *miniwidget,
559  bool mini=false, int pos=-1, bool animate=false, Gtk::Widget *bare=0);
560  RackBox *add_rackbox(PluginUI& pl, bool mini=false, int pos=-1, bool animate=false);
561  void pluginlist_append(std::vector<PluginUI*>& p);
562  void add_plugin(std::vector<PluginUI*>& p, const char *id, const Glib::ustring& tooltip_="");
563  PluginUI *activate(const string& id, const string& before, bool animate);
564  PluginUI *deactivate(const string& id, bool animate);
565 };
566 
567 
568 /****************************************************************
569  ** class TextLoggingBox
570  */
571 
572 class TextLoggingBox: public Gtk::Window {
573 private:
574  struct tab_table {
575  const char *tagname;
576  const char *tag_color;
577  };
578  Gtk::VBox box;
579  Gtk::Button ok_button;
580  Gtk::HButtonBox buttonbox;
581  Gtk::ScrolledWindow scrollbox;
582  Gtk::TextView tbox;
584  Glib::RefPtr<Gtk::TextTag> tags[GxLogger::kMessageTypeCount];
586  sigc::signal<void> msg_level_changed;
587 private:
588  virtual bool on_key_press_event(GdkEventKey *event);
589  void show_msg(string msgbuf, GxLogger::MsgType msgtype, bool plugged);
590  virtual void on_show();
591  virtual void on_hide();
592 public:
597  sigc::signal<void>& signal_msg_level_changed() { return msg_level_changed; }
598 };
599 
600 
601 /****************************************************************
602  ** class NsmSignals
603  **
604  ** signal messages from GxNsmHandler to MainWindow and back.
605  **
606  */
607 
608 class NsmSignals {
609 
610 private:
611 
612 public: // GxNsmHandler to MainWindow
614 
615  sigc::signal<void > trigger_nsm_show_gui;
616  sigc::signal<void >& signal_trigger_nsm_show_gui() { return trigger_nsm_show_gui; }
617 
618  sigc::signal<void > trigger_nsm_hide_gui;
619  sigc::signal<void >& signal_trigger_nsm_hide_gui() { return trigger_nsm_hide_gui; }
620 
621  sigc::signal<void > trigger_nsm_save_gui;
622  sigc::signal<void >& signal_trigger_nsm_save_gui() { return trigger_nsm_save_gui; }
623 
624 public: // MainWindow to GxNsmHandler
625  sigc::signal<void > trigger_nsm_gui_is_shown;
627 
628  sigc::signal<void > trigger_nsm_gui_is_hidden;
630 
633 };
634 
635 
636 /****************************************************************
637  ** class MainWindow
638  */
639 
640 class Freezer {
641 private:
642  Gtk::Window *window;
643  sigc::connection tag;
644  bool need_thaw;
645  int size_x;
646  int size_y;
647  sigc::slot<void> work;
648 private:
649  void do_thaw();
650  bool thaw_timeout();
651  void freeze(Gtk::Window *w, int width, int height);
652  void thaw();
653 public:
656  void freeze_until_width_update(Gtk::Window *w, int width);
657  void set_slot(sigc::slot<void> w);
658  void freeze_and_size_request(Gtk::Window *w, int width, int height);
659  bool check_thaw(int width, int height);
660 };
661 
662 
663 /****************************************************************
664  ** class PluginPresetPopup
665  */
666 
667 class PluginPresetPopup: public Gtk::Menu {
668 private:
669  const PluginDef *pdef;
671  const Glib::ustring save_name_default;
674  void set_plugin_preset(bool factory, const Glib::ustring& name);
675  bool add_plugin_preset_list(bool *found);
678 protected:
679  virtual void on_selection_done();
680 public:
682  const Glib::ustring& save_name_default = "");
683  gx_preset::UnitPresetList::const_iterator begin() { return presetnames.begin(); }
684  gx_preset::UnitPresetList::const_iterator end() { return presetnames.end(); }
685  const PluginDef *get_pdef() { return pdef; }
687 };
688 
689 
690 /****************************************************************
691  ** GxUiRadioMenu
692  ** adds the values of an EnumParameter as Gio::MenuItem's
693  ** to a Gio::Menu
694  */
695 
697 private:
699  const std::string id;
700  Glib::RefPtr<Gio::SimpleAction> action;
701  void set_value(int v);
702  void on_changed(const Glib::VariantBase& value);
703 public:
705  void setup(UIManager& uimanager);
706 };
707 
708 
709 class GxActions {
710 public:
711  // Main Window
712  Glib::RefPtr<Gio::SimpleAction> quit;
713  Glib::RefPtr<Gio::SimpleAction> compress;
714  Glib::RefPtr<Gio::SimpleAction> expand;
715  Glib::RefPtr<Gio::SimpleAction> jackstartup;
716  Glib::RefPtr<Gio::SimpleAction> loadladspa;
717 
718  Glib::RefPtr<ToggleAction> rack_config;
719  Glib::RefPtr<ToggleAction> live_play;
720  Glib::RefPtr<ToggleAction> engine_mute;
721  sigc::connection engine_mute_conn;
722  Glib::RefPtr<ToggleAction> engine_bypass;
723  sigc::connection engine_bypass_conn;
724  Glib::RefPtr<ToggleAction> jackserverconnection;
725  Glib::RefPtr<ToggleAction> jackports;
726  Glib::RefPtr<ToggleAction> midicontroller;
727  Glib::RefPtr<ToggleAction> meterbridge;
728  Glib::RefPtr<ToggleAction> loggingbox;
729  Glib::RefPtr<ToggleAction> animations;
730 
731  Glib::RefPtr<ToggleAction> show_plugin_bar;
732  Glib::RefPtr<ToggleAction> presets;
733  Glib::RefPtr<ToggleAction> show_rack;
734  Glib::RefPtr<UiBoolToggleAction> tuner;
735  Glib::RefPtr<UiBoolToggleAction> tunermove;
736  Glib::RefPtr<UiBoolToggleAction> tunermidiout;
737  Glib::RefPtr<UiBoolToggleAction> livetuner;
738  Glib::RefPtr<ToggleAction> show_values;
739  Glib::RefPtr<ToggleAction> tooltips;
740  Glib::RefPtr<UiBoolToggleAction> midi_in_presets;
741  Glib::RefPtr<ToggleAction> rackh;
742  Glib::RefPtr<ToggleAction> midiout;
743 
744  Glib::RefPtr<RadioAction> skin;
745  Glib::RefPtr<RadioAction> latency;
746  Glib::RefPtr<RadioAction> osc_buffer_size;
747  Glib::RefPtr<RadioAction> preset_list_menu;
748 
749  // preset window
750  Glib::RefPtr<Gio::SimpleAction> new_bank;
751  Glib::RefPtr<Gio::SimpleAction> save_changes;
752  Glib::RefPtr<ToggleAction> organize;
753  Glib::RefPtr<Gio::SimpleAction> online_preset_bank;
754 };
755 
756 
757 
758 class SelectMidiChannel: public Gtk::Window {
759 private:
760  Gtk::Label *description;
761  Gtk::ComboBox *channelcombo;
763  sigc::signal<void> close;
764  void on_ok_button();
766  bool on_delete_event(GdkEventAny* event);
767  bool on_key_press_event(GdkEventKey *event);
768  static SelectMidiChannel* create_from_builder(BaseObjectType* cobject, Glib::RefPtr<gx_gui::GxBuilder> bld, gx_engine::GxMachineBase& m) {
769  return new SelectMidiChannel(cobject, bld, m);
770  }
771  SelectMidiChannel(BaseObjectType* cobject, Glib::RefPtr<gx_gui::GxBuilder> bld, gx_engine::GxMachineBase& m);
772 public:
775  sigc::signal<void>& signal_close() { return close; }
776 };
777 
778 class MainWindowBuilder: public Glib::RefPtr<gx_gui::GxBuilder> {
779 public:
780  Gxw::PaintBox *tunerbox;
781  Gtk::Box *tuner_box_no_rack;
782  Gtk::ScrolledWindow *vrack_scrolledbox;
783  Gtk::Scrollbar *monorackscroller;
786  Gxw::PaintBox *rackcontainer;
787  Gtk::ScrolledWindow *stereorackbox;
788  Gtk::Box *monocontainer;
789  Gxw::PaintBox *monoampcontainer;
790  Gtk::Paned *main_vpaned;
791  Gtk::Box *monobox;
792  Gtk::Box *upper_rackbox;
793  Gtk::ScrolledWindow *preset_scrolledbox;
795  Gxw::PaintBox *effects_frame_paintbox;
796  Gtk::Image *insert_image;
797  Gtk::Image *status_image;
798  Gtk::Image *jackd_image;
799  Gtk::Image *logstate_image;
800  Gtk::Window *window;
801  Gtk::ToggleButton *show_rack_button;
802  Gtk::ToggleButton *rack_order_h_button;
803  Gtk::ToggleButton *config_mode_button;
804  Gtk::ToggleButton *liveplay_button;
805  Gtk::ToggleButton *tuner_button;
806  Gtk::ToggleButton *effects_button;
807  Gtk::ToggleButton *presets_button;
808  Gtk::Button *compress_button;
809  Gtk::Button *expand_button;
810  Gtk::ToolPalette *effects_toolpalette;
811  Gxw::PaintBox *amp_background;
812  Gxw::Switch *tuner_on_off;
813  Gxw::Selector *tuner_mode;
814  Gxw::ValueDisplay *tuner_reference_pitch;
815  Gxw::Selector *tuner_tuning;
816  Gxw::Selector *tuner_temperament;
817  Gxw::RackTuner *racktuner;
818  Gtk::Button *ampdetail_compress;
819  Gtk::Button *ampdetail_expand;
820  Gtk::Widget *ampdetail_mini;
821  Gtk::Widget *ampdetail_normal;
822  Gxw::FastMeter *fastmeter[2];
823  Gtk::Entry *preset_status;
824  Gtk::MenuBar *menubar;
825 private:
827 public:
830 };
831 
832 class MainWindow: public sigc::trackable {
833 private:
840  Glib::RefPtr<Gdk::Pixbuf> gx_head_icon;
845  int oldpos;
848  int pre_act;
849  int pool_act;
851  Glib::ustring preset_list_menu_bank;
859  Glib::RefPtr<Gdk::Pixbuf> pixbuf_insert_on;
860  Glib::RefPtr<Gdk::Pixbuf> pixbuf_insert_off;
861  Glib::RefPtr<Gdk::Pixbuf> pixbuf_on;
862  Glib::RefPtr<Gdk::Pixbuf> pixbuf_off;
863  Glib::RefPtr<Gdk::Pixbuf> pixbuf_bypass;
864  Glib::RefPtr<Gdk::Pixbuf> pixbuf_jack_connected;
865  Glib::RefPtr<Gdk::Pixbuf> pixbuf_jack_disconnected;
866  Glib::RefPtr<Gdk::Pixbuf> pixbuf_log_grey;
867  Glib::RefPtr<Gdk::Pixbuf> pixbuf_log_yellow;
868  Glib::RefPtr<Gdk::Pixbuf> pixbuf_log_red;
870  Glib::RefPtr<Gtk::StatusIcon> status_icon;
873 
874 private:
875  bool on_my_leave_out(GdkEventCrossing *focus);
876  bool on_my_enter_in(GdkEventCrossing *focus);
877  void maybe_shrink_horizontally(bool preset_no_rack=false);
883  void on_show_rack();
889  void set_tooltips();
891  void move_widget(Gtk::Widget& w, Gtk::Box& b1, Gtk::Box& b2);
893  void change_expand(Gtk::Widget& w, bool value);
895  void on_configure_event(GdkEventConfigure *ev);
896  void clear_box(Gtk::Container& box);
899  bool on_visibility_notify(GdkEventVisibility *ev);
900  void on_live_play();
905  bool connect_jack(bool v, Gtk::Window *splash = 0);
906  int start_jack();
908  void change_skin(const Glib::VariantBase& value);
911  void change_latency(const Glib::VariantBase& value);
912  void user_disable_latency_warn(Gtk::CheckButton* disable_warn);
914  void set_latency();
915  void set_osc_size();
917  void change_osc_buffer(const Glib::VariantBase& value);
924  bool on_log_activated(GdkEventButton* ev);
925  bool on_log_scrolled(GdkEventScroll* ev);
928  void set_tuning(Gxw::RackTuner& tuner);
929  void set_tuner_tet(Gxw::RackTuner& tuner);
930  void set_tuner_ref(Gxw::RackTuner& tuner);
931  void setup_tuner_temperament(Gxw::RackTuner& tuner);
932  void setup_tuner(Gxw::RackTuner& tuner);
933  bool on_toggle_mute(GdkEventButton* ev);
934  bool on_scroll_toggle(GdkEventScroll* ev);
935  bool on_toggle_insert(GdkEventButton* ev);
936  bool on_scroll_toggle_insert(GdkEventScroll* ev);
938  bool on_jackserverconnection(GdkEventButton* ev);
939  bool on_jackserverconnection_scroll(GdkEventScroll* ev);
941  void on_ampdetail_switch(bool compress, bool setparam);
942  bool refresh_meter_level(float falloff);
949  void systray_menu(guint button, guint32 activate_time);
950  bool on_window_state_changed(GdkEventWindowState* event);
951  bool on_meter_button_release(GdkEventButton* ev);
953  void on_select_preset(const Glib::VariantBase& value);
963  bool on_key_press_event(GdkEventKey *event);
964  void display_preset_msg(const Glib::ustring& bank, const Glib::ustring& preset);
966  void on_ladspa_finished(bool reload, bool quit);
968  bool on_quit();
969  void on_nsm_quit();
970  void on_nsm_save();
971  void amp_controls_visible(Gtk::Range *rr);
972  void gx_show_help();
974  void set_midiout();
975 public:
976  Glib::RefPtr<Gtk::SizeGroup> left_column;
978  Gtk::Window *splash, const Glib::ustring& title);
980  PluginUI *get_plugin(const std::string& name) { return plugin_dict[name]; }
983  void run();
987  bool use_animations() { return actions.animations->get_active(); }
989  void update_width();
990 };
991 
992 inline void RackContainer::reorder(const std::string& name, const std::string& before) {
993  plugin_dict.reorder(this, name, before); }
MainWindow::pool_act
int pool_act
Definition: gx_main_window.h:849
Liveplay::window
Gtk::Window * window
Definition: gx_main_window.h:192
GxActions::loggingbox
Glib::RefPtr< ToggleAction > loggingbox
Definition: gx_main_window.h:728
MainWindow::delete_select_jack_control
void delete_select_jack_control()
UIManager::set_accelerators_from_menu
void set_accelerators_from_menu()
Definition: gx_main_window.h:126
PluginUI::PluginUI
PluginUI(PluginDict &plugin_dict, const char *id_, const Glib::ustring &tooltip_="")
DragIcon::~DragIcon
~DragIcon()
MainWindowBuilder::stereorackbox
Gtk::ScrolledWindow * stereorackbox
Definition: gx_main_window.h:787
PluginDict::stop_at
double stop_at(RackContainer *container, double off, double step_size, double page_size)
Liveplay
Definition: gx_main_window.h:182
MainWindow::on_window_state_changed
bool on_window_state_changed(GdkEventWindowState *event)
GxActions
Definition: gx_main_window.h:709
MainWindow::on_nsm_save
void on_nsm_save()
SelectMidiChannel::~SelectMidiChannel
~SelectMidiChannel()
GxActions::loadladspa
Glib::RefPtr< Gio::SimpleAction > loadladspa
Definition: gx_main_window.h:716
NsmSignals::trigger_nsm_save_gui
sigc::signal< void > trigger_nsm_save_gui
Definition: gx_main_window.h:621
Liveplay::brightness_adj
Glib::RefPtr< Gtk::Adjustment > brightness_adj
Definition: gx_main_window.h:188
UiBoolToggleAction
UiToggleAction< bool > UiBoolToggleAction
Definition: gx_main_window.h:102
GxUiRadioMenu::id
const std::string id
Definition: gx_main_window.h:699
UIManager::actiongroup
Glib::RefPtr< Gio::SimpleActionGroup > actiongroup
Definition: gx_main_window.h:115
RackBox::swtch
void swtch(bool mini)
MainWindow::pixbuf_jack_connected
Glib::RefPtr< Gdk::Pixbuf > pixbuf_jack_connected
Definition: gx_main_window.h:864
ToggleAction::set_active
void set_active(bool v)
MainWindowBuilder::ampdetail_mini
Gtk::Widget * ampdetail_mini
Definition: gx_main_window.h:820
MainWindow::on_meter_button_release
bool on_meter_button_release(GdkEventButton *ev)
PluginUI::tooltip
Glib::ustring tooltip
Definition: gx_main_window.h:423
MainWindow::on_preset_action
void on_preset_action()
RackBox::set_visibility
void set_visibility(bool v)
PluginDict::check_order
void check_order()
GxActions::skin
Glib::RefPtr< RadioAction > skin
Definition: gx_main_window.h:744
PluginDict::monorackcontainer
RackContainer monorackcontainer
Definition: gx_main_window.h:504
KeySwitcher::KeySwitcher
KeySwitcher(gx_engine::GxMachineBase &machine_, sigc::slot< void, const Glib::ustring &, const Glib::ustring & > display_)
Definition: gx_main_window.h:163
RackBox::plugin
PluginUI & plugin
Definition: gx_main_window.h:276
MainWindow::move_widget
void move_widget(Gtk::Widget &w, Gtk::Box &b1, Gtk::Box &b2)
SelectMidiChannel::create
static SelectMidiChannel * create(gx_system::CmdlineOptions &opt, gx_engine::GxMachineBase &machine)
UiToggleAction::id
std::string id
Definition: gx_main_window.h:86
RackBox::make_bar
static Gtk::Widget * make_bar(int left=4, int right=4, bool sens=false)
MainWindowBuilder::config_mode_button
Gtk::ToggleButton * config_mode_button
Definition: gx_main_window.h:803
MainWindowBuilder::rack_order_h_button
Gtk::ToggleButton * rack_order_h_button
Definition: gx_main_window.h:802
PluginDict::PluginDict
PluginDict(gx_engine::GxMachineBase &machine, gx_system::CmdlineOptions &options, Gtk::ToolPalette &toolpalette, gx_gui::StackBoxBuilder &boxbuilder, UIManager &uimanager)
MiniRackBox::evbox_button
sigc::connection evbox_button
Definition: gx_main_window.h:343
PluginUI::get_shortname
const char * get_shortname() const
Definition: gx_main_window.h:457
Freezer::window
Gtk::Window * window
Definition: gx_main_window.h:642
GxActions::engine_mute
Glib::RefPtr< ToggleAction > engine_mute
Definition: gx_main_window.h:720
Liveplay::add_midi_elements
void add_midi_elements()
MainWindowBuilder::effects_frame_paintbox
Gxw::PaintBox * effects_frame_paintbox
Definition: gx_main_window.h:795
GxTheme::css_show_values
Glib::RefPtr< Gtk::CssProvider > css_show_values
Definition: gx_main_window.h:33
PluginPresetPopup::begin
gx_preset::UnitPresetList::const_iterator begin()
Definition: gx_main_window.h:683
PluginDict::get_monorackcontainer
RackContainer & get_monorackcontainer()
Definition: gx_main_window.h:543
GxUiRadioMenu::machine
gx_engine::GxMachineBase & machine
Definition: gx_main_window.h:698
PluginDict::toolpalette
Gtk::ToolPalette & toolpalette
Definition: gx_main_window.h:512
MainWindow::MainWindow
MainWindow(gx_engine::GxMachineBase &machine, gx_system::CmdlineOptions &options, NsmSignals &nsmsig, GxTheme &theme, Gtk::Window *splash, const Glib::ustring &title)
MainWindow::user_disable_latency_warn
void user_disable_latency_warn(Gtk::CheckButton *disable_warn)
UIManager::menubar
Gtk::MenuBar * menubar
Definition: gx_main_window.h:116
MainWindow::live_play
Liveplay * live_play
Definition: gx_main_window.h:852
RackBox::pack
void pack(Gtk::Widget *mainbox, Gtk::Widget *minibox)
MiniRackBox::make_delete_button
Gtk::Widget * make_delete_button(RackBox &rb)
MainWindow::connect_jack
bool connect_jack(bool v, Gtk::Window *splash=0)
ToggleAction::create
static Glib::RefPtr< ToggleAction > create(const Glib::ustring &name, bool state=false)
Definition: gx_main_window.h:64
PluginUI::on_ti_drag_data_delete
void on_ti_drag_data_delete(const Glib::RefPtr< Gdk::DragContext > &context)
RackBox::init_dnd
void init_dnd()
GxTheme::set_new_skin
bool set_new_skin(const Glib::ustring &skin_name)
GxActions::compress
Glib::RefPtr< Gio::SimpleAction > compress
Definition: gx_main_window.h:713
RackBox::delete_button
bool delete_button
Definition: gx_main_window.h:280
gx_engine::GxMachineBase
Definition: machine.h:55
gx_engine::PluginChange::pc
pc
Definition: gx_engine.h:65
MainWindowBuilder::effects_button
Gtk::ToggleButton * effects_button
Definition: gx_main_window.h:806
Liveplay::mouse_hide_conn
sigc::connection mouse_hide_conn
Definition: gx_main_window.h:193
PluginDict::plugin_preset_popup
void plugin_preset_popup(const PluginDef *pdef)
MainWindow::on_log_scrolled
bool on_log_scrolled(GdkEventScroll *ev)
UIManager::remove_item
bool remove_item(const Glib::ustring &action)
PluginDict::options
gx_system::CmdlineOptions & options
Definition: gx_main_window.h:511
UIManager::get_accel_group
Glib::RefPtr< Gtk::AccelGroup > & get_accel_group()
Definition: gx_main_window.h:121
TextLoggingBox::buttonbox
Gtk::HButtonBox buttonbox
Definition: gx_main_window.h:580
MainWindow::pixbuf_off
Glib::RefPtr< Gdk::Pixbuf > pixbuf_off
Definition: gx_main_window.h:862
MainWindow::on_jackserverconnection
bool on_jackserverconnection(GdkEventButton *ev)
MainWindow::jack_connection
void jack_connection()
RackBox::on_my_leave_out
bool on_my_leave_out(GdkEventCrossing *focus)
PluginDict::uimanager
UIManager & uimanager
Definition: gx_main_window.h:513
ToggleAction::signal_toggled
Glib::SignalProxyProperty signal_toggled()
Definition: gx_main_window.h:66
KeySwitcher::key_offset_to_bank_idx
static int key_offset_to_bank_idx(int offset, int bank_size)
MainWindow::set_in_session
void set_in_session()
Liveplay::machine
gx_engine::GxMachineBase & machine
Definition: gx_main_window.h:185
KeySwitcher::display_empty
void display_empty(const Glib::ustring &bank, const Glib::ustring &preset)
GxTheme::css_provider
Glib::RefPtr< Gtk::CssProvider > css_provider
Definition: gx_main_window.h:32
Freezer::work
sigc::slot< void > work
Definition: gx_main_window.h:647
GxActions::tunermidiout
Glib::RefPtr< UiBoolToggleAction > tunermidiout
Definition: gx_main_window.h:736
PluginDict::get_plugins_hidden
bool get_plugins_hidden()
Definition: gx_main_window.h:540
MiniRackBox::evbox
Gtk::EventBox evbox
Definition: gx_main_window.h:335
KeySwitcher::display_selected_bank
bool display_selected_bank()
RackBox::set_config_mode
void set_config_mode(bool mode)
Freezer::need_thaw
bool need_thaw
Definition: gx_main_window.h:644
RackBox::compare_position
bool compare_position(int pos, int post_pre)
GxActions::livetuner
Glib::RefPtr< UiBoolToggleAction > livetuner
Definition: gx_main_window.h:737
MainWindowBuilder::ampdetail_normal
Gtk::Widget * ampdetail_normal
Definition: gx_main_window.h:821
RackBox::enable_drag
void enable_drag(bool v)
DragIcon::window_draw
bool window_draw(const Cairo::RefPtr< Cairo::Context > &cr, Gtk::OffscreenWindow &w)
MainWindow::on_rack_configuration
void on_rack_configuration()
PluginDef::category
const char * category
Definition: gx_plugin.h:204
MainWindow::oldpos
int oldpos
Definition: gx_main_window.h:845
MainWindow::set_latency
void set_latency()
UIManager::search_func
std::function< bool(const Glib::ustring &, Glib::RefPtr< Gio::Menu > &, int, int)> search_func
Definition: gx_main_window.h:111
UIManager::foreach_menu
bool foreach_menu(search_func func)
Definition: gx_main_window.h:127
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)
GxActions::midicontroller
Glib::RefPtr< ToggleAction > midicontroller
Definition: gx_main_window.h:726
UIManager::accelgroup
Glib::RefPtr< Gtk::AccelGroup > accelgroup
Definition: gx_main_window.h:114
GxActions::tooltips
Glib::RefPtr< ToggleAction > tooltips
Definition: gx_main_window.h:739
PluginUI::on_ti_drag_end
void on_ti_drag_end(const Glib::RefPtr< Gdk::DragContext > &context)
MainWindow::on_scroll_toggle
bool on_scroll_toggle(GdkEventScroll *ev)
RackBox::make_preset_button
Gtk::Button * make_preset_button()
MiniRackBox::MiniRackBox
MiniRackBox(RackBox &rb, gx_system::CmdlineOptions &options)
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
Freezer::thaw_timeout
bool thaw_timeout()
PluginDef::shortname
const char * shortname
Definition: gx_plugin.h:205
PluginUI::add_toolitem
void add_toolitem(Gtk::ToolItemGroup *gw)
PluginUI::active
bool active
Plugin is in rack (effect bar icon not visible)
Definition: gx_main_window.h:420
Liveplay::midictrl_table
Gtk::Grid * midictrl_table
Definition: gx_main_window.h:204
MainWindow::gx_head_icon
Glib::RefPtr< Gdk::Pixbuf > gx_head_icon
Definition: gx_main_window.h:840
KeySwitcher::bank_idx_to_char
static char bank_idx_to_char(int idx, int bank_size)
PluginPresetPopup::PluginPresetPopup
PluginPresetPopup(const PluginDef *pdef, gx_engine::GxMachineBase &machine, const Glib::ustring &save_name_default="")
PluginUI::action
Glib::RefPtr< ToggleAction > action
Definition: gx_main_window.h:414
UiToggleAction::machine
gx_engine::GxMachineBase & machine
Definition: gx_main_window.h:85
MainWindow::change_latency
void change_latency(const Glib::VariantBase &value)
Freezer::check_thaw
bool check_thaw(int width, int height)
MainWindow::uimanager
UIManager uimanager
Definition: gx_main_window.h:842
MainWindow::on_previus_preset
void on_previus_preset()
Liveplay::bypass_image
Gtk::Image * bypass_image
Definition: gx_main_window.h:195
PluginPresetPopup::end
gx_preset::UnitPresetList::const_iterator end()
Definition: gx_main_window.h:684
MainWindow::on_load_ladspa
void on_load_ladspa()
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_)
Freezer::freeze_until_width_update
void freeze_until_width_update(Gtk::Window *w, int width)
MainWindowBuilder::preset_status
Gtk::Entry * preset_status
Definition: gx_main_window.h:823
RackContainer::plugin_dict
PluginDict & plugin_dict
Definition: gx_main_window.h:360
RackContainer
Definition: gx_main_window.h:358
PluginPresetPopup::save_name_default
const Glib::ustring save_name_default
Definition: gx_main_window.h:671
GxTheme::options
gx_system::CmdlineOptions * options
Definition: gx_main_window.h:31
GxActions::preset_list_menu
Glib::RefPtr< RadioAction > preset_list_menu
Definition: gx_main_window.h:747
PluginUI::shortname
const char * shortname
Definition: gx_main_window.h:424
PresetWindow
Definition: gx_preset_window.h:76
GxActions::osc_buffer_size
Glib::RefPtr< RadioAction > osc_buffer_size
Definition: gx_main_window.h:746
Liveplay::display_tuner
void display_tuner(bool v)
Liveplay::transparent_draw
bool transparent_draw(const Cairo::RefPtr< Cairo::Context > &cr)
MainWindow::on_toggle_mute
bool on_toggle_mute(GdkEventButton *ev)
PluginDict::activate
PluginUI * activate(const string &id, const string &before, bool animate)
MainWindow::setup_tuner_temperament
void setup_tuner_temperament(Gxw::RackTuner &tuner)
MainWindow::options
gx_system::CmdlineOptions & options
Definition: gx_main_window.h:834
Liveplay::get_tuner
Gxw::RackTuner & get_tuner()
Definition: gx_main_window.h:242
NsmSignals::signal_trigger_nsm_gui_is_shown
sigc::signal< void > & signal_trigger_nsm_gui_is_shown()
Definition: gx_main_window.h:626
GxActions::presets
Glib::RefPtr< ToggleAction > presets
Definition: gx_main_window.h:732
Liveplay::window_draw
bool window_draw(const Cairo::RefPtr< Cairo::Context > &cr)
GxActions::rack_config
Glib::RefPtr< ToggleAction > rack_config
Definition: gx_main_window.h:718
PluginUI::dispose_rackbox
void dispose_rackbox()
Liveplay::on_selection_changed
void on_selection_changed()
PluginType
PluginType
Definition: machine.h:34
GxActions::live_play
Glib::RefPtr< ToggleAction > live_play
Definition: gx_main_window.h:719
MainWindow::pixbuf_jack_disconnected
Glib::RefPtr< Gdk::Pixbuf > pixbuf_jack_disconnected
Definition: gx_main_window.h:865
MainWindow::get_plugin
PluginUI * get_plugin(const std::string &name)
Definition: gx_main_window.h:980
PluginDef::load_ui
uiloader load_ui
Definition: gx_plugin.h:215
MainWindow::on_jackserverconnection_scroll
bool on_jackserverconnection_scroll(GdkEventScroll *ev)
NsmSignals::signal_trigger_nsm_gui_is_hidden
sigc::signal< void > & signal_trigger_nsm_gui_is_hidden()
Definition: gx_main_window.h:629
MainWindow::on_quit
bool on_quit()
MainWindow::add_skin_menu
void add_skin_menu()
UiToggleAction::UiToggleAction
UiToggleAction(gx_engine::GxMachineBase &machine_, const std::string &id, const Glib::ustring &name, bool is_active=false)
MainWindow::on_toggle_insert
bool on_toggle_insert(GdkEventButton *ev)
TextLoggingBox::tagdefs
static tab_table tagdefs[GxLogger::kMessageTypeCount]
Definition: gx_main_window.h:583
PluginDict::add_plugin_category
Gtk::ToolItemGroup * add_plugin_category(const char *cat, bool collapse=true)
PluginUI::on_ti_drag_begin
void on_ti_drag_begin(const Glib::RefPtr< Gdk::DragContext > &context)
RackContainer::rackbox_list
Glib::ListHandle< RackBox * > rackbox_list
Definition: gx_main_window.h:380
RackBox::make_expand_button
Gtk::Button * make_expand_button(bool expand)
KeySwitcher::display
sigc::slot< void, const Glib::ustring &, const Glib::ustring & > display
Definition: gx_main_window.h:155
RackBox::has_delete
bool has_delete() const
Definition: gx_main_window.h:312
MainWindowBuilder::jackd_image
Gtk::Image * jackd_image
Definition: gx_main_window.h:798
Freezer::freeze
void freeze(Gtk::Window *w, int width, int height)
RackBox::on_my_drag_end
void on_my_drag_end(const Glib::RefPtr< Gdk::DragContext > &context)
RackContainer::renumber
void renumber()
ToggleAction::ToggleAction
ToggleAction(const Glib::ustring &name, bool state)
Definition: gx_main_window.h:61
MainWindow::set_tuning
void set_tuning(Gxw::RackTuner &tuner)
ladspa::PluginDisplay
Definition: ladspalist.h:85
SelectMidiChannel::on_cancel_button
void on_cancel_button()
NsmSignals::~NsmSignals
~NsmSignals()
Definition: gx_main_window.h:632
UiToggleAction
Definition: gx_main_window.h:83
RackContainer::RackContainer
RackContainer(PluginDict &plugin_dict)
KeySwitcher::idx_to_char
static char idx_to_char(int idx)
gx_engine::GxMachineBase::create_default_scratch_preset
virtual void create_default_scratch_preset()=0
MainWindowBuilder::main_vpaned
Gtk::Paned * main_vpaned
Definition: gx_main_window.h:790
MainWindow::set_osc_size
void set_osc_size()
PluginUI::is_registered
static bool is_registered(gx_engine::GxMachineBase &m, const char *name)
PluginPresetPopup::get_pdef
const PluginDef * get_pdef()
Definition: gx_main_window.h:685
PluginUI::plugin_dict
PluginDict & plugin_dict
Definition: gx_main_window.h:435
Liveplay::on_live_play
void on_live_play(Glib::RefPtr< ToggleAction > act)
MainWindow::on_select_preset
void on_select_preset(const Glib::VariantBase &value)
UIManager::add_action
Glib::RefPtr< Gio::SimpleAction > add_action(const Glib::ustring &action)
RackBox::get_plug_visible
bool get_plug_visible()
Definition: gx_main_window.h:496
gx_preset::UnitPresetList
std::vector< PluginPresetEntry > UnitPresetList
Definition: gx_preset.h:138
MainWindow::on_midiout_tuner
void on_midiout_tuner()
UIManager::insert_action_group
void insert_action_group(Glib::RefPtr< Gio::SimpleActionGroup > &group)
Definition: gx_main_window.h:123
PluginDict::~PluginDict
~PluginDict()
RackBox::vis_switch
void vis_switch(Gtk::Widget &a, Gtk::Widget &b)
MainWindow::hide_extended_settings
void hide_extended_settings()
MainWindow::add_latency_menu
void add_latency_menu()
PluginDef::name
const char * name
Definition: gx_plugin.h:200
KeySwitcher::display_key_error
void display_key_error()
UIManager::menu
Glib::RefPtr< Gio::Menu > menu
Definition: gx_main_window.h:113
MiniRackBox::preset_button
Gtk::Button * preset_button
Definition: gx_main_window.h:339
gx_engine::GxEngineState
GxEngineState
Definition: gx_modulesequencer.h:289
MainWindowBuilder::racktuner
Gxw::RackTuner * racktuner
Definition: gx_main_window.h:817
MainWindow::nsmsig
NsmSignals & nsmsig
Definition: gx_main_window.h:836
PluginUI::on_my_leave_out
bool on_my_leave_out(GdkEventCrossing *focus)
RackContainer::targets
std::vector< std::string > targets
Definition: gx_main_window.h:363
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)
RackBox::animate_create
bool animate_create()
gx_engine::Plugin::get_plug_visible
bool get_plug_visible() const
Definition: gx_pluginloader.h:63
KeySwitcher
Definition: gx_main_window.h:152
RackContainer::othertargets
std::vector< std::string > othertargets
Definition: gx_main_window.h:364
PluginUI
Definition: gx_main_window.h:410
Freezer::tag
sigc::connection tag
Definition: gx_main_window.h:643
SelectMidiChannel::signal_close
sigc::signal< void > & signal_close()
Definition: gx_main_window.h:775
NsmSignals::trigger_nsm_show_gui
sigc::signal< void > trigger_nsm_show_gui
Definition: gx_main_window.h:615
RackBox::can_compress
bool can_compress()
Definition: gx_main_window.h:318
MainWindow::on_show_rack
void on_show_rack()
PluginDict::use_animations
bool use_animations()
Definition: gx_main_window.h:552
PluginDict::show_entries
void show_entries()
MainWindow::setup_tuner
void setup_tuner(Gxw::RackTuner &tuner)
GxTheme::update_show_values
void update_show_values()
PluginUI::hidden
bool hidden
Plugin not visible (but might be in rack, e.g. "Rack" is off)
Definition: gx_main_window.h:419
TextLoggingBox::TextLoggingBox
TextLoggingBox()
NsmSignals::signal_trigger_nsm_hide_gui
sigc::signal< void > & signal_trigger_nsm_hide_gui()
Definition: gx_main_window.h:619
RackContainer::drag_highlight_draw
bool drag_highlight_draw(const Cairo::RefPtr< Cairo::Context > &, int y0)
RackContainer::reorder
void reorder(const std::string &name, const std::string &before)
Definition: gx_main_window.h:992
RackBox::set_paintbox_unit_shrink
static void set_paintbox_unit_shrink(Gxw::PaintBox &pb, PluginType tp)
PluginDef
Definition: gx_plugin.h:195
MainWindowBuilder::monocontainer
Gtk::Box * monocontainer
Definition: gx_main_window.h:788
MainWindow::on_livetuner_toggled
void on_livetuner_toggled()
PluginPresetPopup::on_selection_done
virtual void on_selection_done()
PluginUI::hide
void hide(bool animate)
RackBox::minibox
MiniRackBox * minibox
Definition: gx_main_window.h:282
Liveplay::liveplay_canvas
Gtk::Widget * liveplay_canvas
Definition: gx_main_window.h:199
Liveplay::on_keyboard_preset_select
static bool on_keyboard_preset_select(GtkAccelGroup *accel_group, GObject *acceleratable, guint keyval, GdkModifierType modifier, Liveplay &self)
RackBox::on_my_drag_failed
bool on_my_drag_failed(const Glib::RefPtr< Gdk::DragContext > &context, Gtk::DragResult result)
PluginPresetPopup::remove_plugin_preset
void remove_plugin_preset()
Liveplay::liveplay_bank
Gtk::Label * liveplay_bank
Definition: gx_main_window.h:197
MainWindow::set_tooltips
void set_tooltips()
KeySwitcher::process_preset_key
bool process_preset_key(int key)
PluginUI::get_update_cond
bool get_update_cond()
TextLoggingBox::tab_table::tagname
const char * tagname
Definition: gx_main_window.h:575
MainWindow::set_vpaned_handle
void set_vpaned_handle()
Liveplay::set_display_state
void set_display_state(TunerSwitcher::SwitcherState s)
MiniRackBox::on_my_leave_out
bool on_my_leave_out(GdkEventCrossing *focus)
MainWindowBuilder::tuner_reference_pitch
Gxw::ValueDisplay * tuner_reference_pitch
Definition: gx_main_window.h:814
ToggleAction::get_active
bool get_active() const
Definition: gx_main_window.h:67
MainWindow::on_nsm_quit
void on_nsm_quit()
PluginDict::add_bare
void add_bare(const char *id, Gtk::Container *box)
RackBox::set_paintbox
static void set_paintbox(Gxw::PaintBox &pb, PluginType tp)
MiniRackBox::on_off_switch
Gxw::Switch on_off_switch
Definition: gx_main_window.h:340
TextLoggingBox::show_msg
void show_msg(string msgbuf, GxLogger::MsgType msgtype, bool plugged)
RackBox::get_parent
RackContainer * get_parent()
PluginUI::set_update_state
void set_update_state(bool state)
MainWindowBuilder::logstate_image
Gtk::Image * logstate_image
Definition: gx_main_window.h:799
GxActions::online_preset_bank
Glib::RefPtr< Gio::SimpleAction > online_preset_bank
Definition: gx_main_window.h:753
MainWindow::set_tuner_tet
void set_tuner_tet(Gxw::RackTuner &tuner)
MainWindow::on_ampdetail_switch
void on_ampdetail_switch(bool compress, bool setparam)
KeySwitcher::display_current
bool display_current()
MiniRackBox::set_config_mode
void set_config_mode(bool mode, PluginUI &plugin)
UIManager::add_accelerator
void add_accelerator(Glib::RefPtr< Gio::Action > action, Glib::VariantBase &target, const Glib::ustring &accelerator)
MainWindow::on_portmap_response
void on_portmap_response(int)
MainWindow::get_machine
gx_engine::GxMachineBase & get_machine()
Definition: gx_main_window.h:985
MainWindow::on_move_tuner
void on_move_tuner()
TextLoggingBox
Definition: gx_main_window.h:572
MiniRackBox::mb_expand_button
Gtk::Button * mb_expand_button
Definition: gx_main_window.h:337
MainWindow::get_options
gx_system::CmdlineOptions & get_options()
Definition: gx_main_window.h:984
RackBox::set_position
void set_position(int pos, int post_pre)
MainWindow::status_icon
Glib::RefPtr< Gtk::StatusIcon > status_icon
Definition: gx_main_window.h:870
MainWindow::delete_ladspalist_window
bool delete_ladspalist_window()
GxUiRadioMenu::GxUiRadioMenu
GxUiRadioMenu(gx_engine::GxMachineBase &machine, const std::string &id)
RackContainer::ensure_visible
void ensure_visible(RackBox &child)
GxActions::animations
Glib::RefPtr< ToggleAction > animations
Definition: gx_main_window.h:729
RackBox::target_height
int target_height
Definition: gx_main_window.h:288
UIManager::UIManager
UIManager(const std::string &file, Gtk::MenuBar *bar)
MainWindowBuilder::tuner_box_no_rack
Gtk::Box * tuner_box_no_rack
Definition: gx_main_window.h:781
MiniRackBox::pack
void pack(Gtk::Widget *w)
RackContainer::highlight_connection
sigc::connection highlight_connection
Definition: gx_main_window.h:365
RackContainer::count
int count
count of visible children
Definition: gx_main_window.h:362
GxActions::save_changes
Glib::RefPtr< Gio::SimpleAction > save_changes
Definition: gx_main_window.h:751
MainWindow::actions
GxActions actions
Definition: gx_main_window.h:843
MainWindow::maybe_shrink_horizontally
void maybe_shrink_horizontally(bool preset_no_rack=false)
GxTheme
Definition: gx_main_window.h:29
MainWindow::add_osc_size_menu
void add_osc_size_menu()
PluginDict
Definition: gx_main_window.h:502
Freezer::set_slot
void set_slot(sigc::slot< void > w)
PluginUI::animate_vanish
bool animate_vanish()
MainWindow::select_midi_channel
SelectMidiChannel * select_midi_channel
Definition: gx_main_window.h:856
RackBox::on_my_drag_begin
void on_my_drag_begin(const Glib::RefPtr< Gdk::DragContext > &context)
Liveplay::brightness_slider
Gxw::HSlider * brightness_slider
Definition: gx_main_window.h:200
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)
MainWindow::on_portmap_activate
void on_portmap_activate()
MainWindow::survive_jack_shutdown
bool survive_jack_shutdown()
RadioAction::set_current_value
void set_current_value(int v)
Definition: gx_main_window.h:79
Freezer::thaw
void thaw()
NsmSignals::NsmSignals
NsmSignals()
Liveplay::brightness_box
Gtk::Box * brightness_box
Definition: gx_main_window.h:201
TextLoggingBox::signal_msg_level_changed
sigc::signal< void > & signal_msg_level_changed()
Definition: gx_main_window.h:597
N_
#define N_(String)
Definition: gx_faust_support.h:23
MainWindow::freezer
Freezer freezer
Definition: gx_main_window.h:839
Liveplay::keyswitch
KeySwitcher keyswitch
Definition: gx_main_window.h:190
MainWindowBuilder::~MainWindowBuilder
~MainWindowBuilder()
MainWindow::on_engine_toggled
void on_engine_toggled()
MainWindow::show_selected_preset
void show_selected_preset()
KeySwitcher::key_offset_to_idx
static int key_offset_to_idx(int offset)
MainWindowBuilder::vrack_scrolledbox
Gtk::ScrolledWindow * vrack_scrolledbox
Definition: gx_main_window.h:782
MainWindow::delete_select_midi_channel
void delete_select_midi_channel()
MainWindow::pixbuf_insert_on
Glib::RefPtr< Gdk::Pixbuf > pixbuf_insert_on
Definition: gx_main_window.h:859
MainWindow::on_show_tuner
void on_show_tuner()
MainWindow::gx_jack_is_down
void gx_jack_is_down()
RackContainer::autoscroll_connection
sigc::connection autoscroll_connection
Definition: gx_main_window.h:366
Liveplay::mute_image
Gtk::Image * mute_image
Definition: gx_main_window.h:196
PluginUI::show
void show(bool animate)
GxActions::tunermove
Glib::RefPtr< UiBoolToggleAction > tunermove
Definition: gx_main_window.h:735
MainWindowBuilder::rackcontainer
Gxw::PaintBox * rackcontainer
Definition: gx_main_window.h:786
MainWindow::refresh_meter_level
bool refresh_meter_level(float falloff)
UIManager
Definition: gx_main_window.h:109
MainWindowBuilder::ampdetail_compress
Gtk::Button * ampdetail_compress
Definition: gx_main_window.h:818
PluginDict::unit_order_changed
void unit_order_changed(bool stereo)
plugins_by_name_less
bool plugins_by_name_less(PluginUI *a, PluginUI *b)
MainWindowBuilder::expand_button
Gtk::Button * expand_button
Definition: gx_main_window.h:809
RackBox::anim_height
int anim_height
Definition: gx_main_window.h:285
PluginDict::plugins_hidden
bool plugins_hidden
Definition: gx_main_window.h:515
gx_portmap::PortMapWindow
Definition: gx_portmap.h:58
GxActions::show_values
Glib::RefPtr< ToggleAction > show_values
Definition: gx_main_window.h:738
MainWindowBuilder::tuner_button
Gtk::ToggleButton * tuner_button
Definition: gx_main_window.h:805
Liveplay::liveplay_exit
Gtk::ToggleButton * liveplay_exit
Definition: gx_main_window.h:203
RackContainer::in_drag
int in_drag
Definition: gx_main_window.h:361
MainWindow::portmap_window
gx_portmap::PortMapWindow * portmap_window
Definition: gx_main_window.h:854
MainWindowBuilder::compress_button
Gtk::Button * compress_button
Definition: gx_main_window.h:808
RackBox::anim_step
int anim_step
Definition: gx_main_window.h:286
TextLoggingBox::~TextLoggingBox
~TextLoggingBox()
PluginUI::plugin
gx_engine::Plugin * plugin
Definition: gx_main_window.h:432
MainWindow::pixbuf_bypass
Glib::RefPtr< Gdk::Pixbuf > pixbuf_bypass
Definition: gx_main_window.h:863
PluginUI::toolitem
Gtk::ToolItem * toolitem
Definition: gx_main_window.h:417
PluginDict::monotargets
std::vector< std::string > monotargets
Definition: gx_main_window.h:507
PluginUI::get_type
PluginType get_type() const
Definition: gx_main_window.h:437
UIManager::get_linked_menu
Glib::RefPtr< Gio::Menu > get_linked_menu(const Glib::ustring &action)
MiniRackBox
Definition: gx_main_window.h:332
RackContainer::stop_at_top
double stop_at_top(double off, double step_size)
MainWindow::on_show_plugin_bar
void on_show_plugin_bar()
MainWindow::bld
MainWindowBuilder bld
Definition: gx_main_window.h:838
MainWindow::in_session
bool in_session
Definition: gx_main_window.h:869
PluginUI::remove
void remove(bool animate)
MainWindow::preset_window
PresetWindow * preset_window
Definition: gx_main_window.h:853
PluginDict::on_plugin_changed
void on_plugin_changed(gx_engine::Plugin *pl, gx_engine::PluginChange::pc c)
MainWindow::set_bypass_controller
void set_bypass_controller()
PluginPresetPopup
Definition: gx_main_window.h:667
PluginUI::has_gui
bool has_gui() const
Definition: gx_main_window.h:440
KeySwitcher::deactivate
void deactivate()
Liveplay::on_realize
void on_realize()
PluginDict::config_mode
bool config_mode
Definition: gx_main_window.h:514
UIManager::set_accelerators_from_menu
void set_accelerators_from_menu(Glib::RefPtr< Gio::Menu > &menu)
MainWindow::machine
gx_engine::GxMachineBase & machine
Definition: gx_main_window.h:835
Liveplay::on_background_changed
void on_background_changed()
gx_engine::Plugin::get_pdef
PluginDef * get_pdef()
Definition: gx_pluginloader.h:56
GxTheme::window_y
int window_y
Definition: gx_main_window.h:37
MainWindow::change_skin
void change_skin(const Glib::VariantBase &value)
MainWindow::plugins_end
PluginDict::iterator plugins_end()
Definition: gx_main_window.h:982
DragIcon::window
Gtk::Window * window
Definition: gx_main_window.h:253
GxActions::engine_bypass
Glib::RefPtr< ToggleAction > engine_bypass
Definition: gx_main_window.h:722
Liveplay::use_composite
bool use_composite
Definition: gx_main_window.h:187
RackContainer::check_targets
bool check_targets(const std::vector< std::string > &tgts1, const std::vector< std::string > &tgts2)
GxTheme::set_window
void set_window(Gtk::Window *window_)
Definition: gx_main_window.h:47
RackContainer::scroll_timeout
bool scroll_timeout()
RackBox::create_drag_widget
static Gtk::Widget * create_drag_widget(const PluginUI &plugin, gx_system::CmdlineOptions &options)
GxActions::engine_bypass_conn
sigc::connection engine_bypass_conn
Definition: gx_main_window.h:723
RackBox::compress
bool compress
Definition: gx_main_window.h:279
PluginDict::get_machine
gx_engine::GxMachineBase & get_machine()
Definition: gx_main_window.h:554
MainWindow::create_default_scratch_preset
void create_default_scratch_preset()
Definition: gx_main_window.h:988
PluginUI::set_active
void set_active(bool v)
Definition: gx_main_window.h:449
PluginPresetPopup::save_plugin_preset
void save_plugin_preset()
MainWindow::on_visibility_notify
bool on_visibility_notify(GdkEventVisibility *ev)
MainWindowBuilder::upper_rackbox
Gtk::Box * upper_rackbox
Definition: gx_main_window.h:792
MainWindow::on_show_values
void on_show_values()
GxActions::new_bank
Glib::RefPtr< Gio::SimpleAction > new_bank
Definition: gx_main_window.h:750
MainWindow::on_select_jack_control
void on_select_jack_control()
MainWindow::ladspalist_window
ladspa::PluginDisplay * ladspalist_window
Definition: gx_main_window.h:872
MainWindow::keyswitch
KeySwitcher keyswitch
Definition: gx_main_window.h:871
DragIcon
Definition: gx_main_window.h:250
PluginDict::fill_pluginlist
void fill_pluginlist()
GxTheme::reload_css_post
void reload_css_post()
PluginPresetPopup::set_plugin_preset
void set_plugin_preset(bool factory, const Glib::ustring &name)
MainWindow::clear_box
void clear_box(Gtk::Container &box)
MiniRackBox::mconbox
Gtk::HBox mconbox
Definition: gx_main_window.h:336
MainWindow::rebuild_preset_menu
void rebuild_preset_menu()
PluginDict::add_plugin
void add_plugin(std::vector< PluginUI * > &p, const char *id, const Glib::ustring &tooltip_="")
RackContainer::stop_at_bottom
double stop_at_bottom(double off, double step_size, double pagesize)
MainWindow::set_switcher_controller
void set_switcher_controller()
PluginDict::stereorackcontainer
RackContainer stereorackcontainer
Definition: gx_main_window.h:505
PluginDict::category_id
Glib::ustring category_id(const std::string &group, bool stereo)
MainWindowBuilder::preset_scrolledbox
Gtk::ScrolledWindow * preset_scrolledbox
Definition: gx_main_window.h:793
MainWindow::systray_menu
void systray_menu(guint button, guint32 activate_time)
PluginUI::group
Gtk::ToolItemGroup * group
Definition: gx_main_window.h:416
MainWindow::jack_session_event_ins
void jack_session_event_ins()
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
PluginUI::get_id
const char * get_id() const
Definition: gx_main_window.h:444
MainWindow::on_live_play
void on_live_play()
PluginDict::remove
void remove(PluginUI *p)
MainWindowBuilder::window
Gtk::Window * window
Definition: gx_main_window.h:800
MainWindow::is_visible
bool is_visible
Definition: gx_main_window.h:850
MainWindow::on_jack_client_changed
void on_jack_client_changed()
MainWindow::fLoggingWindow
TextLoggingBox fLoggingWindow
Definition: gx_main_window.h:857
MainWindow::select_jack_control
gx_gui::SelectJackControlPgm * select_jack_control
Definition: gx_main_window.h:855
GxActions::quit
Glib::RefPtr< Gio::SimpleAction > quit
Definition: gx_main_window.h:712
MiniRackBox::on_my_enter_in
bool on_my_enter_in(GdkEventCrossing *focus)
MainWindow::left_column
Glib::RefPtr< Gtk::SizeGroup > left_column
Definition: gx_main_window.h:976
RadioAction::create
static Glib::RefPtr< RadioAction > create(const Glib::ustring &name)
Definition: gx_main_window.h:75
RackBox::wrap_bar
Gtk::Widget * wrap_bar(int left=4, int right=4, bool sens=false)
MainWindow::maybe_change_resizable
void maybe_change_resizable(void)
PluginDict::stereotargets
std::vector< std::string > stereotargets
Definition: gx_main_window.h:508
UIManager::get_action_group
Glib::RefPtr< Gio::SimpleActionGroup > & get_action_group()
Definition: gx_main_window.h:122
MainWindow::pixbuf_insert_off
Glib::RefPtr< Gdk::Pixbuf > pixbuf_insert_off
Definition: gx_main_window.h:860
RackContainer::set_child_count
void set_child_count(int n)
MainWindow::on_select_midi_channel
void on_select_midi_channel()
MainWindow::change_expand
void change_expand(Gtk::Widget &w, bool value)
RackBox::box
Gxw::PaintBox box
Definition: gx_main_window.h:289
MainWindow::on_engine_state_change
void on_engine_state_change(gx_engine::GxEngineState state)
RackBox::animate_insert
void animate_insert()
MainWindowBuilder::show_rack_button
Gtk::ToggleButton * show_rack_button
Definition: gx_main_window.h:801
MainWindow::start_jack
int start_jack()
MainWindow::set_previus_preset_controller
void set_previus_preset_controller()
PluginUI::output_widget_state
sigc::signal< void(bool)> output_widget_state
state of output_widgets_active changed
Definition: gx_main_window.h:421
UIManager::set_widget_action
static void set_widget_action(Gtk::Widget *w, const Glib::RefPtr< Gio::Action > &action)
Liveplay::on_selection_done
void on_selection_done(bool v)
DragIcon::icon_draw
bool icon_draw(const Cairo::RefPtr< Cairo::Context > &cr)
UiToggleAction::on_toggled
void on_toggled()
GxTheme::window_x
int window_x
Definition: gx_main_window.h:37
UIManager::add_toggle_action
Glib::RefPtr< ToggleAction > add_toggle_action(const Glib::ustring &action, bool state=false)
MainWindow::is_variable_size
bool is_variable_size()
PluginUI::update_rackbox
void update_rackbox()
PluginDict::compress
void compress(bool state)
UiToggleAction::~UiToggleAction
~UiToggleAction()
MainWindow::on_my_leave_out
bool on_my_leave_out(GdkEventCrossing *focus)
Liveplay::~Liveplay
~Liveplay()
PluginDef::id
const char * id
Definition: gx_plugin.h:199
DragIcon::DragIcon
DragIcon(PluginUI &plugin, Glib::RefPtr< Gdk::DragContext > context, gx_system::CmdlineOptions &options, int xoff=0)
MainWindowBuilder::ampdetail_expand
Gtk::Button * ampdetail_expand
Definition: gx_main_window.h:819
MainWindow::set_next_preset_controller
void set_next_preset_controller()
TextLoggingBox::on_key_press_event
virtual bool on_key_press_event(GdkEventKey *event)
MainWindow::on_log_activate
void on_log_activate()
TextLoggingBox::on_hide
virtual void on_hide()
PluginDict::get_options
gx_system::CmdlineOptions & get_options()
Definition: gx_main_window.h:555
KeySwitcher::process_bank_key
bool process_bank_key(int key)
KeySwitcher::machine
gx_engine::GxMachineBase & machine
Definition: gx_main_window.h:154
Liveplay::on_keyboard_toggle_bypass
static bool on_keyboard_toggle_bypass(GtkAccelGroup *accel_group, GObject *acceleratable, guint keyval, GdkModifierType modifier, Liveplay &self)
UIManager::add_radio_action
Glib::RefPtr< RadioAction > add_radio_action(const Glib::ustring &action)
RackContainer::on_drag_motion
virtual bool on_drag_motion(const Glib::RefPtr< Gdk::DragContext > &context, int x, int y, guint timestamp)
PluginPresetPopup::get_machine
gx_engine::GxMachineBase & get_machine()
Definition: gx_main_window.h:686
NsmSignals::trigger_nsm_hide_gui
sigc::signal< void > trigger_nsm_hide_gui
Definition: gx_main_window.h:618
RackContainer::find_index
void find_index(int x, int y, string *before, int *ypos)
PluginUI::on_ti_button_press
bool on_ti_button_press(GdkEventButton *ev)
MainWindowBuilder::tuner_mode
Gxw::Selector * tuner_mode
Definition: gx_main_window.h:813
MainWindowBuilder::monobox
Gtk::Box * monobox
Definition: gx_main_window.h:791
KeySwitcher::last_bank_key
Glib::ustring last_bank_key
Definition: gx_main_window.h:157
RackBox::mbox
Gxw::PaintBox mbox
Definition: gx_main_window.h:281
TextLoggingBox::highest_unseen_msg_level
int highest_unseen_msg_level
Definition: gx_main_window.h:585
PluginUI::on_state_change
void on_state_change()
PluginUI::activate
void activate(bool animate)
RackBox::drag_icon
DragIcon * drag_icon
Definition: gx_main_window.h:287
Liveplay::liveplay_preset
Gtk::Label * liveplay_preset
Definition: gx_main_window.h:198
PluginDict::remove_plugin_menu_entry
void remove_plugin_menu_entry(PluginUI *pui)
NsmSignals::trigger_nsm_gui_is_shown
sigc::signal< void > trigger_nsm_gui_is_shown
Definition: gx_main_window.h:625
GxLogger::kMessageTypeCount
@ kMessageTypeCount
Definition: gx_logging.h:41
PluginUI::compress
void compress(bool state)
GxActions::midiout
Glib::RefPtr< ToggleAction > midiout
Definition: gx_main_window.h:742
RackContainer::scrollother_timeout
bool scrollother_timeout()
MainWindow::pixbuf_on
Glib::RefPtr< Gdk::Pixbuf > pixbuf_on
Definition: gx_main_window.h:861
Freezer::do_thaw
void do_thaw()
Freezer::Freezer
Freezer()
MainWindow::use_animations
bool use_animations()
Definition: gx_main_window.h:987
MainWindow::change_osc_buffer
void change_osc_buffer(const Glib::VariantBase &value)
RadioAction::RadioAction
RadioAction(const Glib::ustring &name)
MainWindow::on_log_activated
bool on_log_activated(GdkEventButton *ev)
Liveplay::bld
Glib::RefPtr< gx_gui::GxBuilder > bld
Definition: gx_main_window.h:184
RackBox::on_off_switch
Gxw::Switch on_off_switch
Definition: gx_main_window.h:290
UIManager::find_item
Gtk::MenuItem * find_item(const Glib::ustring &action)
KeySwitcher::next_idx
static int next_idx(int idx=-1)
TextLoggingBox::tags
Glib::RefPtr< Gtk::TextTag > tags[GxLogger::kMessageTypeCount]
Definition: gx_main_window.h:584
MainWindowBuilder::tuner_on_off
Gxw::Switch * tuner_on_off
Definition: gx_main_window.h:812
RackBox::anim_tag
sigc::connection anim_tag
Definition: gx_main_window.h:278
TextLoggingBox::reset_msg_level
void reset_msg_level()
RackBox::target
std::string target
Definition: gx_main_window.h:284
NsmSignals::nsm_session_control
bool nsm_session_control
Definition: gx_main_window.h:613
MainWindow::on_next_preset
void on_next_preset()
RackContainer::rackbox_const_list
Glib::ListHandle< const RackBox * > rackbox_const_list
Definition: gx_main_window.h:379
PluginUI::plugins_by_name_less
friend bool plugins_by_name_less(PluginUI *a, PluginUI *b)
PGN_STEREO
@ PGN_STEREO
Definition: gx_plugin.h:174
PluginDef::flags
int flags
Definition: gx_plugin.h:197
MainWindow::rackbox_stacked_vertical
int rackbox_stacked_vertical() const
RackBox::create_icon_widget
static Gtk::Widget * create_icon_widget(const PluginUI &plugin, gx_system::CmdlineOptions &options)
PluginUI::get_category
const char * get_category()
Definition: gx_main_window.h:453
MainWindowBuilder::presets_button
Gtk::ToggleButton * presets_button
Definition: gx_main_window.h:807
MainWindow::plugin_dict
PluginDict plugin_dict
Definition: gx_main_window.h:844
PluginPresetPopup::pdef
const PluginDef * pdef
Definition: gx_main_window.h:669
MainWindowBuilder::menubar
Gtk::MenuBar * menubar
Definition: gx_main_window.h:824
gx_gui::StackBoxBuilder
Definition: gx_stackbox_builder.h:44
PluginDict::add_rackbox
RackBox * add_rackbox(PluginUI &pl, bool mini=false, int pos=-1, bool animate=false)
PluginUI::decativate
void decativate(bool animate)
PluginDict::machine
gx_engine::GxMachineBase & machine
Definition: gx_main_window.h:510
KeySwitcher::key_timeout
sigc::connection key_timeout
Definition: gx_main_window.h:156
RackContainer::on_drag_leave
virtual void on_drag_leave(const Glib::RefPtr< Gdk::DragContext > &context, guint timestamp)
ToggleAction
Definition: gx_main_window.h:59
PluginDict::get_stereorackcontainer
RackContainer & get_stereorackcontainer()
Definition: gx_main_window.h:544
MainWindowBuilder::tunerbox
Gxw::PaintBox * tunerbox
Definition: gx_main_window.h:780
PluginDict::deactivate
PluginUI * deactivate(const string &id, bool animate)
RadioAction::get_current_value
bool get_current_value() const
Definition: gx_main_window.h:78
gx_system::CmdlineOptions
Definition: gx_system.h:384
MainWindowBuilder::preset_box_no_rack
Gtk::Box * preset_box_no_rack
Definition: gx_main_window.h:794
GxActions::midi_in_presets
Glib::RefPtr< UiBoolToggleAction > midi_in_presets
Definition: gx_main_window.h:740
MainWindow::on_scroll_toggle_insert
bool on_scroll_toggle_insert(GdkEventScroll *ev)
GxActions::show_plugin_bar
Glib::RefPtr< ToggleAction > show_plugin_bar
Definition: gx_main_window.h:731
PluginDict::check_order
void check_order(PluginType tp, bool animate)
RackBox::do_expand
void do_expand()
GxTheme::reload_css
void reload_css()
MainWindow::set_midiout
void set_midiout()
PLUGIN_TYPE_STEREO
@ PLUGIN_TYPE_STEREO
Definition: machine.h:36
Freezer::freeze_and_size_request
void freeze_and_size_request(Gtk::Window *w, int width, int height)
TextLoggingBox::get_unseen_msg_level
int get_unseen_msg_level()
Definition: gx_main_window.h:596
PluginUI::rackbox
RackBox * rackbox
rack widget or nullptr
Definition: gx_main_window.h:418
MainWindow::on_dir_changed
void on_dir_changed()
MainWindow::pixbuf_log_red
Glib::RefPtr< Gdk::Pixbuf > pixbuf_log_red
Definition: gx_main_window.h:868
MainWindowBuilder::load_widget_pointers
void load_widget_pointers()
TextLoggingBox::on_show
virtual void on_show()
PluginUI::get_output_widget_state
sigc::signal< void(bool)> * get_output_widget_state()
Definition: gx_main_window.h:490
NsmSignals::signal_trigger_nsm_show_gui
sigc::signal< void > & signal_trigger_nsm_show_gui()
Definition: gx_main_window.h:616
PluginUI::get_action
Glib::RefPtr< ToggleAction > get_action()
Definition: gx_main_window.h:450
RackBox
Definition: gx_main_window.h:273
RackBox::plugin_dict
PluginDict & plugin_dict
Definition: gx_main_window.h:277
RackBox::make_label
static Gtk::Widget * make_label(const PluginUI &plugin, gx_system::CmdlineOptions &options, bool useshort=true)
MainWindow::gx_wait_latency_warn
int gx_wait_latency_warn()
PluginDict::groupmap
std::map< Glib::ustring, Gtk::ToolItemGroup * > groupmap
Definition: gx_main_window.h:506
Freezer::size_x
int size_x
Definition: gx_main_window.h:645
DragIcon::drag_icon_pixbuf
Glib::RefPtr< Gdk::Pixbuf > drag_icon_pixbuf
Definition: gx_main_window.h:254
GxActions::show_rack
Glib::RefPtr< ToggleAction > show_rack
Definition: gx_main_window.h:733
Liveplay::tuner
Gxw::RackTuner * tuner
Definition: gx_main_window.h:205
SelectMidiChannel::SelectMidiChannel
SelectMidiChannel(BaseObjectType *cobject, Glib::RefPtr< gx_gui::GxBuilder > bld, gx_engine::GxMachineBase &m)
MainWindowBuilder::fastmeter
Gxw::FastMeter * fastmeter[2]
Definition: gx_main_window.h:822
PluginDict::set_config_mode
void set_config_mode(bool state)
PluginDict::register_plugin
void register_plugin(PluginUI *pui)
MainWindow::on_compress_all
void on_compress_all()
SelectMidiChannel::on_ok_button
void on_ok_button()
Liveplay::Liveplay
Liveplay(const gx_system::CmdlineOptions &options, gx_engine::GxMachineBase &machine, const std::string &fname, const GxActions &actions, Glib::RefPtr< Gio::SimpleActionGroup > &group)
GxActions::engine_mute_conn
sigc::connection engine_mute_conn
Definition: gx_main_window.h:721
MainWindow::amp_controls_visible
void amp_controls_visible(Gtk::Range *rr)
GxActions::tuner
Glib::RefPtr< UiBoolToggleAction > tuner
Definition: gx_main_window.h:734
PluginUI::activate
void activate(bool animate, const string &before)
MainWindow::scrl_size_y
int scrl_size_y
Definition: gx_main_window.h:847
MainWindow::update_width
void update_width()
SelectMidiChannel::description
Gtk::Label * description
Definition: gx_main_window.h:760
MainWindowBuilder::tuner_tuning
Gxw::Selector * tuner_tuning
Definition: gx_main_window.h:815
RackBox::make_full_box
Gtk::HBox * make_full_box(gx_system::CmdlineOptions &options)
GxActions::jackstartup
Glib::RefPtr< Gio::SimpleAction > jackstartup
Definition: gx_main_window.h:715
PluginPresetPopup::presetnames
gx_preset::UnitPresetList presetnames
Definition: gx_main_window.h:672
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)
SelectMidiChannel::machine
gx_engine::GxMachineBase & machine
Definition: gx_main_window.h:762
GxTheme::style_context
Glib::RefPtr< Gtk::StyleContext > style_context
Definition: gx_main_window.h:34
PluginDict::drag_icon
DragIcon * drag_icon
Definition: gx_main_window.h:517
MainWindow::theme
GxTheme & theme
Definition: gx_main_window.h:837
PLUGIN_TYPE_MONO
@ PLUGIN_TYPE_MONO
Definition: machine.h:35
GxUiRadioMenu::on_changed
void on_changed(const Glib::VariantBase &value)
GxActions::expand
Glib::RefPtr< Gio::SimpleAction > expand
Definition: gx_main_window.h:714
MainWindow::set_rackbox_expansion
void set_rackbox_expansion()
MainWindow::gx_show_help
void gx_show_help()
Freezer::~Freezer
~Freezer()
Liveplay::background_adj
Glib::RefPtr< Gtk::Adjustment > background_adj
Definition: gx_main_window.h:189
UIManager::add_action
Glib::RefPtr< Gio::SimpleAction > add_action(const Glib::ustring &action, sigc::slot< void()> slot)
GxUiRadioMenu
Definition: gx_main_window.h:696
GxTheme::GxTheme
GxTheme()
Definition: gx_main_window.h:41
Liveplay::on_keyboard_mode_switch
static bool on_keyboard_mode_switch(GtkAccelGroup *accel_group, GObject *acceleratable, guint keyval, GdkModifierType modifier, Liveplay &self)
PluginUI::deactivate
void deactivate(bool animate)
SelectMidiChannel
Definition: gx_main_window.h:758
PluginPresetPopup::add_plugin_preset_list
bool add_plugin_preset_list(bool *found)
MainWindowBuilder::MainWindowBuilder
MainWindowBuilder(const gx_system::CmdlineOptions &options, gx_engine::GxMachineBase &machine)
RackBox::on_my_enter_in
bool on_my_enter_in(GdkEventCrossing *focus)
Liveplay::on_delete
bool on_delete(GdkEventAny *ev)
MainWindowBuilder::effects_toolpalette
Gtk::ToolPalette * effects_toolpalette
Definition: gx_main_window.h:810
TunerSwitcher::SwitcherState
SwitcherState
Definition: tunerswitcher.h:31
GxActions::organize
Glib::RefPtr< ToggleAction > organize
Definition: gx_main_window.h:752
MainWindowBuilder::monoampcontainer
Gxw::PaintBox * monoampcontainer
Definition: gx_main_window.h:789
Liveplay::pointer_motion
bool pointer_motion(GdkEventMotion *event)
SelectMidiChannel::close
sigc::signal< void > close
Definition: gx_main_window.h:763
PluginPresetPopup::machine
gx_engine::GxMachineBase & machine
Definition: gx_main_window.h:670
RadioAction
Definition: gx_main_window.h:71
MiniRackBox::mb_delete_button
Gtk::Widget * mb_delete_button
Definition: gx_main_window.h:338
MainWindow::on_insert_jack_changed
void on_insert_jack_changed(bool s)
RackBox::fbox
Gtk::Widget * fbox
Definition: gx_main_window.h:283
NsmSignals::signal_trigger_nsm_save_gui
sigc::signal< void > & signal_trigger_nsm_save_gui()
Definition: gx_main_window.h:622
PluginDict::boxbuilder
gx_gui::StackBoxBuilder & boxbuilder
Definition: gx_main_window.h:509
gx_gui::SelectJackControlPgm
Definition: gx_jack_options.h:38
RackContainer::change_child_count
void change_child_count(int n)
Definition: gx_main_window.h:401
RackBox::get_id
const char * get_id() const
Definition: gx_main_window.h:495
Liveplay::display
void display(const Glib::ustring &bank, const Glib::ustring &preset)
PluginDict::add_plugin_menu_entry
Glib::ustring add_plugin_menu_entry(PluginUI *pui)
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)
PluginPresetPopup::set_plugin_std_preset
void set_plugin_std_preset()
SelectMidiChannel::channelcombo
Gtk::ComboBox * channelcombo
Definition: gx_main_window.h:761
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)
gx_engine::Plugin
Definition: gx_pluginloader.h:45
Liveplay::actions
const GxActions & actions
Definition: gx_main_window.h:186
MainWindowBuilder::monorackscroller
Gtk::Scrollbar * monorackscroller
Definition: gx_main_window.h:783
PluginDict::plugin_preset_popup
void plugin_preset_popup(const PluginDef *pdef, const Glib::ustring &name)
GxUiRadioMenu::setup
void setup(UIManager &uimanager)
Liveplay::on_keyboard_arrows
static bool on_keyboard_arrows(GtkAccelGroup *accel_group, GObject *acceleratable, guint keyval, GdkModifierType modifier, Liveplay &self)
MainWindow::scrl_size_x
int scrl_size_x
Definition: gx_main_window.h:846
PluginDict::cleanup
void cleanup()
PluginUI::set_action
void set_action(Glib::RefPtr< ToggleAction > &act)
PluginDict::add
void add(PluginUI *p)
MainWindow::pixbuf_log_grey
Glib::RefPtr< Gdk::Pixbuf > pixbuf_log_grey
Definition: gx_main_window.h:866
PluginUI::on_action_toggled
void on_action_toggled()
TextLoggingBox::ok_button
Gtk::Button ok_button
Definition: gx_main_window.h:579
TextLoggingBox::tab_table::tag_color
const char * tag_color
Definition: gx_main_window.h:576
GxTheme::init
void init(gx_system::CmdlineOptions *options_)
PluginUI::on_rack_handle_press
bool on_rack_handle_press(GdkEventButton *ev)
MainWindowBuilder
Definition: gx_main_window.h:778
MainWindow::on_key_press_event
bool on_key_press_event(GdkEventKey *event)
GxUiRadioMenu::action
Glib::RefPtr< Gio::SimpleAction > action
Definition: gx_main_window.h:700
GxActions::jackports
Glib::RefPtr< ToggleAction > jackports
Definition: gx_main_window.h:725
Liveplay::on_brightness_changed
void on_brightness_changed()
GxUiRadioMenu::set_value
void set_value(int v)
RackContainer::get_children
rackbox_const_list get_children() const
Definition: gx_main_window.h:387
Liveplay::on_engine_state_change
void on_engine_state_change(gx_engine::GxEngineState state)
TextLoggingBox::tab_table
Definition: gx_main_window.h:574
PluginUI::on_my_enter_in
bool on_my_enter_in(GdkEventCrossing *focus)
MainWindow::preset_list_menu_bank
Glib::ustring preset_list_menu_bank
Definition: gx_main_window.h:851
MainWindow
Definition: gx_main_window.h:832
MainWindow::boxbuilder
gx_gui::StackBoxBuilder boxbuilder
Definition: gx_main_window.h:841
MainWindowBuilder::amp_background
Gxw::PaintBox * amp_background
Definition: gx_main_window.h:811
TextLoggingBox::box
Gtk::VBox box
Definition: gx_main_window.h:578
UIManager::set_widget_action
static void set_widget_action(Gtk::Widget *w, const Glib::ustring &action)
MainWindow::show_forum_help
void show_forum_help()
TextLoggingBox::tbox
Gtk::TextView tbox
Definition: gx_main_window.h:582
PluginDict::hide_entries
void hide_entries()
TextLoggingBox::msg_level_changed
sigc::signal< void > msg_level_changed
Definition: gx_main_window.h:586
RackContainer::add
void add(RackBox &r, int pos=-1)
PluginDict::reorder
void reorder(RackContainer *container, const std::string &name, const std::string &before)
NsmSignals::trigger_nsm_gui_is_hidden
sigc::signal< void > trigger_nsm_gui_is_hidden
Definition: gx_main_window.h:628
DragIcon::create_drag_icon_pixbuf
void create_drag_icon_pixbuf(const PluginUI &plugin, Glib::RefPtr< Gdk::Visual > rgba, gx_system::CmdlineOptions &options)
MainWindow::on_configure_event
void on_configure_event(GdkEventConfigure *ev)
PluginDict::iterator
std::map< std::string, PluginUI * >::iterator iterator
Definition: gx_main_window.h:527
GxActions::latency
Glib::RefPtr< RadioAction > latency
Definition: gx_main_window.h:745
Freezer::size_y
int size_y
Definition: gx_main_window.h:646
PluginUI::on_plugin_preset_popup
virtual void on_plugin_preset_popup()
MainWindow::on_miditable_toggle
void on_miditable_toggle()
MainWindow::on_msg_level_changed
void on_msg_level_changed()
MainWindow::create_actions
void create_actions()
PluginUI::~PluginUI
virtual ~PluginUI()
PluginDict::get_config_mode
bool get_config_mode()
Definition: gx_main_window.h:542
UIManager::add_accelerator
static void add_accelerator(Glib::RefPtr< Gtk::AccelGroup > &group, Glib::RefPtr< Gio::Action > action, const Glib::ustring &accelerator, Glib::VariantBase &target)
MainWindow::on_ladspa_finished
void on_ladspa_finished(bool reload, bool quit)
NsmSignals
Definition: gx_main_window.h:608
GxActions::rackh
Glib::RefPtr< ToggleAction > rackh
Definition: gx_main_window.h:741
GxTheme::window
Gtk::Window * window
Definition: gx_main_window.h:36
MainWindowBuilder::stereorackcontainerV
Gtk::Box * stereorackcontainerV
Definition: gx_main_window.h:785
UIManager::foreach_menu_
bool foreach_menu_(Glib::RefPtr< Gio::Menu > &menu, search_func &func, int &startpos)
MainWindow::display_preset_msg
void display_preset_msg(const Glib::ustring &bank, const Glib::ustring &preset)
MainWindow::add_preset_key_accelerators
void add_preset_key_accelerators()
PluginDict::pluginlist_append
void pluginlist_append(std::vector< PluginUI * > &p)
Liveplay::background_slider
Gxw::HSlider * background_slider
Definition: gx_main_window.h:202
Liveplay::midi_conn
sigc::connection midi_conn
Definition: gx_main_window.h:191
MainWindow::~MainWindow
~MainWindow()
RackBox::set_paintbox_unit
static void set_paintbox_unit(Gxw::PaintBox &pb, const PluginUI &plugin)
MainWindow::plugins_begin
PluginDict::iterator plugins_begin()
Definition: gx_main_window.h:981
GxLogger::MsgType
MsgType
Definition: gx_logging.h:37
MainWindowBuilder::tuner_temperament
Gxw::Selector * tuner_temperament
Definition: gx_main_window.h:816
MiniRackBox::szg_label
static Glib::RefPtr< Gtk::SizeGroup > szg_label
Definition: gx_main_window.h:334
MainWindowBuilder::liveplay_button
Gtk::ToggleButton * liveplay_button
Definition: gx_main_window.h:804
PGN_GUI
@ PGN_GUI
Definition: gx_plugin.h:177
MainWindowBuilder::stereorackcontainerH
Gtk::Box * stereorackcontainerH
Definition: gx_main_window.h:784
PluginUI::output_widgets_active
bool output_widgets_active
send data updates for output variables
Definition: gx_main_window.h:422
SelectMidiChannel::on_delete_event
bool on_delete_event(GdkEventAny *event)
Liveplay::on_keyboard_toggle_mute
static bool on_keyboard_toggle_mute(GtkAccelGroup *accel_group, GObject *acceleratable, guint keyval, GdkModifierType modifier, Liveplay &self)
RackContainer::get_children
rackbox_list get_children()
Definition: gx_main_window.h:382
MainWindow::pre_act
int pre_act
Definition: gx_main_window.h:848
PluginUI::set_config_mode
void set_config_mode(bool state)
MainWindowBuilder::status_image
Gtk::Image * status_image
Definition: gx_main_window.h:797
PluginDict::operator[]
PluginUI * operator[](const std::string &s)
Definition: gx_main_window.h:536
MainWindow::amp_radio_menu
GxUiRadioMenu amp_radio_menu
Definition: gx_main_window.h:858
SelectMidiChannel::on_key_press_event
bool on_key_press_event(GdkEventKey *event)
RackBox::RackBox
RackBox(PluginUI &plugin, PluginDict &plugin_dict, Gtk::Widget *bare=0)
gx_system::CmdlineOptions::system_animations
bool system_animations
Definition: gx_system.h:457
MainWindow::set_tuner_ref
void set_tuner_ref(Gxw::RackTuner &tuner)
MainWindowBuilder::insert_image
Gtk::Image * insert_image
Definition: gx_main_window.h:796
PluginUI::get_displayname
Glib::ustring get_displayname(bool useshort) const
MainWindow::set_animations
void set_animations()
MainWindow::jack_session_event
void jack_session_event()
DragIcon::gradient_length
@ gradient_length
Definition: gx_main_window.h:252
Freezer
Definition: gx_main_window.h:640
PluginUI::get_name
const char * get_name() const
Definition: gx_main_window.h:445
GxActions::meterbridge
Glib::RefPtr< ToggleAction > meterbridge
Definition: gx_main_window.h:727
MainWindow::on_my_enter_in
bool on_my_enter_in(GdkEventCrossing *focus)
GxActions::jackserverconnection
Glib::RefPtr< ToggleAction > jackserverconnection
Definition: gx_main_window.h:724
MainWindow::pixbuf_log_yellow
Glib::RefPtr< Gdk::Pixbuf > pixbuf_log_yellow
Definition: gx_main_window.h:867
MainWindow::run
void run()
RackBox::display
void display(bool v, bool animate)
TextLoggingBox::scrollbox
Gtk::ScrolledWindow scrollbox
Definition: gx_main_window.h:581
RackContainer::on_add
virtual void on_add(Widget *ch)
MainWindow::on_expand_all
void on_expand_all()