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 template <class T>
26 class UiToggleAction: public Gtk::ToggleAction {
27 private:
28  gx_engine::GxMachineBase& machine;
29  std::string id;
30  void on_toggled();
31 protected:
33  gx_engine::GxMachineBase& machine_, const std::string& id, const Glib::ustring& name, const Glib::ustring& icon_name,
34  const Glib::ustring& label=Glib::ustring(), const Glib::ustring& tooltip=Glib::ustring(),
35  bool is_active=false);
37 public:
38  static Glib::RefPtr<UiToggleAction> create(
39  gx_engine::GxMachineBase& machine, const std::string& id, const Glib::ustring& name, const Glib::ustring& label=Glib::ustring(),
40  const Glib::ustring& tooltip=Glib::ustring(), bool is_active=false) {
41  return Glib::RefPtr<UiToggleAction>(
42  new UiToggleAction(machine, id, name, Glib::ustring(), label, tooltip, is_active));
43  }
44 };
45 
48 
49 
50 /****************************************************************
51  ** class KeySwitcher
52  */
53 
54 class KeySwitcher: public sigc::trackable {
55 private:
56  gx_engine::GxMachineBase& machine;
57  sigc::slot<void, const Glib::ustring&, const Glib::ustring&> display;
58  sigc::connection key_timeout;
59  Glib::ustring last_bank_key;
60 private:
61  void display_empty(const Glib::ustring& bank, const Glib::ustring& preset);
62  bool display_selected_bank();
63  bool display_current();
64 public:
66  sigc::slot<void, const Glib::ustring&, const Glib::ustring&> display_)
67  : machine(machine_), display(display_) {}
68  bool process_bank_key(int idx);
69  bool process_preset_key(int idx);
70  void display_key_error();
71  void deactivate();
72 };
73 
74 
75 /****************************************************************
76  ** class Liveplay
77  */
78 
79 class Liveplay: public sigc::trackable {
80 private:
81  Glib::RefPtr<gx_gui::GxBuilder> bld;
82  gx_engine::GxMachineBase &machine;
83  const GxActions& actions;
84  bool use_composite;
85  Gtk::Adjustment *brightness_adj;
86  Gtk::Adjustment *background_adj;
87  KeySwitcher keyswitch;
88  sigc::connection midi_conn;
89  Gtk::Window *window;
90  sigc::connection mouse_hide_conn;
91  //
92  Gtk::Image *bypass_image;
93  Gtk::Image *mute_image;
94  Gtk::Label *liveplay_bank;
95  Gtk::Label *liveplay_preset;
96  Gtk::Widget *liveplay_canvas;
97  Gxw::HSlider *brightness_slider;
98  Gtk::Box *brightness_box;
99  Gxw::HSlider *background_slider;
100  Gtk::ToggleButton *liveplay_exit;
101  Gtk::Table *midictrl_table;
102  Gxw::RackTuner *tuner;
103 private:
104  void add_midi_elements();
105  bool on_delete(GdkEventAny *ev);
106  void on_brightness_changed();
107  void on_background_changed();
108  bool transparent_expose(GdkEventExpose *event);
109  bool window_expose_event(GdkEventExpose* event);
110  void on_realize();
111  void on_engine_state_change(gx_engine::GxEngineState state);
112  void on_selection_done(bool v);
113  void on_selection_changed();
114  static bool do_action(
115  GtkAccelGroup *accel_group, GObject *acceleratable,
116  guint keyval, GdkModifierType modifier, GtkAction* act);
117  static bool on_keyboard_preset_select(
118  GtkAccelGroup *accel_group, GObject *acceleratable,
119  guint keyval, GdkModifierType modifier, Liveplay& self);
120  static bool on_keyboard_toggle_mute(
121  GtkAccelGroup *accel_group, GObject *acceleratable,
122  guint keyval, GdkModifierType modifier, Liveplay& self);
123  static bool on_keyboard_toggle_bypass(
124  GtkAccelGroup *accel_group, GObject *acceleratable,
125  guint keyval, GdkModifierType modifier, Liveplay& self);
126  static bool on_keyboard_arrows(
127  GtkAccelGroup *accel_group, GObject *acceleratable,
128  guint keyval, GdkModifierType modifier, Liveplay& self);
129  static bool on_keyboard_mode_switch(
130  GtkAccelGroup *accel_group, GObject *acceleratable,
131  guint keyval, GdkModifierType modifier, Liveplay& self);
132  bool pointer_motion(GdkEventMotion* event);
133  void display(const Glib::ustring& bank, const Glib::ustring& preset);
134  void set_display_state(TunerSwitcher::SwitcherState s);
135 public:
137  const std::string& fname, const GxActions& actions);
138  ~Liveplay();
139  void on_live_play(Glib::RefPtr<Gtk::ToggleAction> act);
140  void display_tuner(bool v);
141  Gxw::RackTuner& get_tuner() { return *tuner; }
142 };
143 
144 
145 /****************************************************************
146  ** class PluginUI
147  */
148 
149 class MainWindow;
150 class RackBox;
151 
152 class PluginUI: public sigc::trackable {
153 private:
154  Gtk::UIManager::ui_merge_id merge_id;
155  Glib::RefPtr<Gtk::ToggleAction> action;
156  void on_action_toggled();
157 public:
159  Glib::ustring tooltip;
160  const char *shortname;
161 
162  // data for ToolPalette entry
163  Glib::RefPtr<Gdk::Pixbuf> icon;
164  Gtk::ToolItemGroup *group;
165  Gtk::ToolItem *toolitem;
166 
169  bool hidden;
171 
172  PluginUI(MainWindow& main, const char* id_,
173  const Glib::ustring& tooltip_="");
174  virtual ~PluginUI();
177  }
178  const char *get_id() const { return plugin->get_pdef()->id; }
179  const char *get_name() const { return plugin->get_pdef()->name; }
180  void display(bool v, bool animate);
181  void display_new(bool unordered = false);
182  void set_ui_merge_id(Gtk::UIManager::ui_merge_id id) { merge_id = id; }
183  void unset_ui_merge_id(Glib::RefPtr<Gtk::UIManager> uimanager);
184  void set_action(Glib::RefPtr<Gtk::ToggleAction>& act);
185  void set_active(bool v) { if (action) action->set_active(v); }
186  Glib::RefPtr<Gtk::ToggleAction> get_action() { return action; }
187  static bool is_registered(gx_engine::GxMachineBase& m, const char *name);
188  virtual void on_plugin_preset_popup();
189  inline const char *get_category() {
190  const char *cat = plugin->get_pdef()->category;
191  return (cat && *cat) ? cat : N_("External");
192  }
193  inline const char *get_shortname() const {
194  const char *name = shortname;
195  if (!name) {
196  name = plugin->get_pdef()->shortname;
197  }
198  if (!name || !*name) {
199  name = get_name();
200  }
201  return name;
202  }
203  void update_rackbox();
204  void compress(bool state);
205  void hide(bool animate);
206  void show(bool animate);
207  friend bool plugins_by_name_less(PluginUI *a, PluginUI *b);
208 };
209 
211 
212 /****************************************************************
213  ** class PluginDict
214  */
215 
216 class PluginDict: private std::map<std::string, PluginUI*> {
217 public:
218  typedef std::map<std::string, PluginUI*>::iterator iterator;
219  PluginDict(): std::map<std::string, PluginUI*>() {}
221  void cleanup();
222  void add(PluginUI *p);
223  void remove(PluginUI *p);
224  PluginUI *operator[](const std::string& s) { return find(s)->second; }
225  using std::map<std::string, PluginUI*>::begin;
227  void compress(bool state);
228 };
229 
230 
231 /****************************************************************
232  ** class DragIcon
233  */
234 
235 class DragIcon {
236 private:
237  enum { gradient_length = 60 };
238  Gtk::Window *window;
239  Glib::RefPtr<Gdk::Pixbuf> drag_icon_pixbuf;
240 private:
241  bool icon_expose_event(GdkEventExpose *ev);
242  void create_drag_icon_pixbuf(const PluginUI& plugin, Glib::RefPtr<Gdk::Colormap> rgba, gx_system::CmdlineOptions& options);
243  bool window_expose_event(GdkEventExpose *event, Gtk::OffscreenWindow& w);
244 public:
245  DragIcon(const PluginUI& plugin, Glib::RefPtr<Gdk::DragContext> context, gx_system::CmdlineOptions& options, int xoff=0);
246  ~DragIcon();
247 };
248 
249 
250 /****************************************************************
251  ** class RackBox, class MiniRackBox
252  */
253 
254 //#define USE_SZG // use a SizeGroup instead of predefined width for Gxw::Switch("switchit")
255 
256 class MiniRackBox;
257 class RackContainer;
258 
259 class RackBox: public Gtk::VBox {
260 private:
261 #ifdef USE_SZG
262  static Glib::RefPtr<Gtk::SizeGroup> szg;
263 #endif
264  PluginUI& plugin;
265  MainWindow& main;
266  bool config_mode;
267  sigc::connection anim_tag;
268  bool compress;
269  bool delete_button;
270  Gxw::PaintBox mbox;
271  MiniRackBox* minibox;
272  Gtk::Widget *fbox;
273  std::string target;
274  int anim_height;
275  int anim_step;
276  DragIcon *drag_icon;
277  int target_height;
278  Gxw::PaintBox box;
279  bool box_visible;
280  Gxw::Switch on_off_switch;
281  gx_gui::uiToggle<bool> toggle_on_off;
282 private:
283  static void set_paintbox(Gxw::PaintBox& pb, PluginType tp);
284  static void set_paintbox_unit(Gxw::PaintBox& pb, const PluginUI& plugin);
285  static void set_paintbox_unit_shrink(Gxw::PaintBox& pb, PluginType tp);
286  static Gtk::Widget *make_label(const PluginUI& plugin, gx_system::CmdlineOptions& options, bool useshort=true);
287  static Gtk::Widget *make_bar(int left=4, int right=4, bool sens=false);
288  Gtk::Widget *wrap_bar(int left=4, int right=4, bool sens=false);
289  void init_dnd();
290  void enable_drag(bool v);
291  bool animate_vanish();
292  void animate_remove();
293  void on_my_drag_begin(const Glib::RefPtr<Gdk::DragContext>& context);
294  bool animate_create();
295  bool on_my_leave_out(GdkEventCrossing *focus);
296  bool on_my_enter_in(GdkEventCrossing *focus);
297  bool on_my_button_press(GdkEventButton* ev);
298  void on_my_drag_end(const Glib::RefPtr<Gdk::DragContext>& context);
299  void on_my_drag_data_get(const Glib::RefPtr<Gdk::DragContext>& context, Gtk::SelectionData& selection, int info, int timestamp);
300  void vis_switch(Gtk::Widget& a, Gtk::Widget& b);
301  void set_visibility(bool v);
302  Gtk::Button *make_expand_button(bool expand);
303  Gtk::Button *make_preset_button();
304  Gtk::HBox *make_full_box(gx_system::CmdlineOptions& options);
305  Gtk::VBox *switcher_vbox(gx_system::CmdlineOptions& options);
306  bool has_delete() const { return delete_button; }
307  void do_expand();
308 public:
309  RackBox(PluginUI& plugin, MainWindow& main, Gtk::Widget* bare=0);
310  static Gtk::Widget *create_drag_widget(const PluginUI& plugin, gx_system::CmdlineOptions& options);
312  bool can_compress() { return compress; }
313  friend class MiniRackBox;
314  const char *get_id() const { return plugin.get_id(); }
315  void set_config_mode(bool mode);
316  void swtch(bool mini);
317  void pack(Gtk::Widget *mainbox, Gtk::Widget *minibox, const Glib::RefPtr<Gtk::SizeGroup>& szg);
318  void animate_insert();
319  static Gtk::Widget *create_icon_widget(const PluginUI& plugin, gx_system::CmdlineOptions& options);
320  void setOrder(int pos, int post_pre);
321  void display(bool v, bool animate);
322  bool get_plug_visible() { return plugin.plugin->get_plug_visible(); }
323  bool get_box_visible() { return box_visible; }
324 };
325 
326 class MiniRackBox: public Gtk::HBox {
327 private:
328  static Glib::RefPtr<Gtk::SizeGroup> szg_label;
329  Gtk::EventBox evbox;
330  Gtk::HBox mconbox;
331  Gtk::Button *mb_expand_button;
332  Gtk::Widget *mb_delete_button;
333  Gtk::Button *preset_button;
334  Gxw::Switch on_off_switch;
335  bool on_my_leave_out(GdkEventCrossing *focus);
336  bool on_my_enter_in(GdkEventCrossing *focus);
337  gx_gui::uiToggle<bool> toggle_on_off;
338 private:
339  Gtk::Widget *make_delete_button(RackBox& rb);
340 public:
342  void set_config_mode(bool mode);
343  void pack(Gtk::Widget *w);
344 };
345 
346 /****************************************************************
347  ** class RackContainer
348  */
349 
350 class RackContainer: public Gtk::VBox {
351 private:
352  PluginType tp;
353  MainWindow& main;
354  bool config_mode;
355  int in_drag;
356  int child_count;
357  std::vector<std::string> targets;
358  std::vector<std::string> othertargets;
359  sigc::connection highlight_connection;
360  sigc::connection autoscroll_connection;
361 private:
362  using Gtk::VBox::add;
363  bool drag_highlight_expose(GdkEventExpose *event, int y0);
364  void find_index(int x, int y, int* len, int *ypos);
365  void on_my_remove(Gtk::Widget*);
366  bool check_targets(const std::vector<std::string>& tgts1, const std::vector<std::string>& tgts2);
367  virtual bool on_drag_motion(const Glib::RefPtr<Gdk::DragContext>& context, int x, int y, guint timestamp);
368  virtual void on_drag_leave(const Glib::RefPtr<Gdk::DragContext>& context, guint timestamp);
369  virtual void on_drag_data_received(const Glib::RefPtr<Gdk::DragContext>& context, int x, int y, const Gtk::SelectionData& data, guint info, guint timestamp);
370  virtual void on_add(Widget* ch);
371  void unit_order_changed(bool stereo);
372  void renumber();
373  bool scroll_timeout();
374  bool scrollother_timeout();
375 public:
376  typedef Glib::ListHandle<const RackBox*> rackbox_const_list;
377  typedef Glib::ListHandle<RackBox*> rackbox_list;
380  return rackbox_list(
381  gtk_container_get_children(GTK_CONTAINER(gobj())),
382  Glib::OWNERSHIP_SHALLOW);
383  }
385  return rackbox_const_list(
386  gtk_container_get_children(const_cast<GtkContainer*>(GTK_CONTAINER(gobj()))),
387  Glib::OWNERSHIP_SHALLOW);
388  }
389  inline bool check_if_animate(const RackBox& rackbox);
390  void show_entries();
391  void hide_entries();
392  void set_config_mode(bool mode);
393  bool empty() const { return child_count == 0; }
394  void add(RackBox& r, int pos=-1);
395  void check_order();
396  void ensure_visible(RackBox& child);
397  void reorder(const std::string& name, unsigned int pos);
398  void increment();
399  void decrement();
400  inline void resize_finished();
401 };
402 
403 
404 /****************************************************************
405  ** class TextLoggingBox
406  */
407 
408 class TextLoggingBox: public Gtk::Window {
409 private:
410  struct tab_table {
411  const char *tagname;
412  const char *tag_color;
413  };
414  Gtk::VBox box;
415  Gtk::Button ok_button;
416  Gtk::HButtonBox buttonbox;
417  Gtk::ScrolledWindow scrollbox;
418  Gtk::TextView tbox;
419  static tab_table tagdefs[GxLogger::kMessageTypeCount];
420  Glib::RefPtr<Gtk::TextTag> tags[GxLogger::kMessageTypeCount];
421  int highest_unseen_msg_level;
422  sigc::signal<void> msg_level_changed;
423 private:
424  virtual bool on_key_press_event(GdkEventKey *event);
425  void show_msg(string msgbuf, GxLogger::MsgType msgtype, bool plugged);
426  virtual void on_show();
427  virtual void on_hide();
428 public:
429  TextLoggingBox();
430  ~TextLoggingBox();
431  void reset_msg_level();
432  int get_unseen_msg_level() { return highest_unseen_msg_level; }
433  sigc::signal<void>& signal_msg_level_changed() { return msg_level_changed; }
434 };
435 
436 
437 /****************************************************************
438  ** class MainWindow
439  */
440 
441 class Freezer {
442 private:
443  Gtk::Window *window;
444  sigc::connection tag;
445  bool need_thaw;
446  int size_x;
447  int size_y;
448  sigc::slot<void> work;
449 private:
450  void do_thaw();
451  bool thaw_timeout();
452  void freeze(Gtk::Window *w, int width, int height);
453  void thaw();
454 public:
455  Freezer();
456  ~Freezer();
457  void freeze_until_width_update(Gtk::Window *w, int width);
458  void set_slot(sigc::slot<void> w);
459  void freeze_and_size_request(Gtk::Window *w, int width, int height);
460  bool check_thaw(int width, int height);
461 };
462 
463 
464 /****************************************************************
465  ** class PluginPresetPopup
466  */
467 
468 class PluginPresetPopup: public Gtk::Menu {
469 private:
470  const PluginDef *pdef;
471  gx_engine::GxMachineBase& machine;
472  const Glib::ustring save_name_default;
473  gx_preset::UnitPresetList presetnames;
474  void set_plugin_std_preset();
475  void set_plugin_preset(bool factory, const Glib::ustring& name);
476  bool add_plugin_preset_list(bool *found);
477  void save_plugin_preset();
478  void remove_plugin_preset();
479 protected:
480  virtual void on_selection_done();
481 public:
483  const Glib::ustring& save_name_default = "");
484  gx_preset::UnitPresetList::const_iterator begin() { return presetnames.begin(); }
485  gx_preset::UnitPresetList::const_iterator end() { return presetnames.end(); }
486  const PluginDef *get_pdef() { return pdef; }
487  gx_engine::GxMachineBase& get_machine() { return machine; }
488 };
489 
490 
491 /****************************************************************
492  ** GxUiRadioMenu
493  ** adds the values of an EnumParameter as Gtk::RadioMenuItem's
494  ** to a Gtk::MenuShell
495  */
496 
498 private:
499  gx_engine::GxMachineBase& machine;
500  const std::string id;
501  Glib::RefPtr<Gtk::RadioAction> action;
502  void set_value(unsigned int v);
503  void on_changed(Glib::RefPtr<Gtk::RadioAction> act);
504 public:
505  GxUiRadioMenu(gx_engine::GxMachineBase& machine, const std::string& id);
506  void setup(const Glib::ustring& prefix, const Glib::ustring& postfix,
507  Glib::RefPtr<Gtk::UIManager>& uimanager, Glib::RefPtr<Gtk::ActionGroup>& actiongroup);
508 };
509 
510 
511 struct GxActions {
512  // Main Window
513  Glib::RefPtr<Gtk::ActionGroup> group;
514  Glib::RefPtr<Gtk::AccelGroup> accels;
515 
516  Glib::RefPtr<Gtk::Action> quit;
517  Glib::RefPtr<Gtk::Action> compress;
518  Glib::RefPtr<Gtk::Action> expand;
519  Glib::RefPtr<Gtk::Action> jack_latency_menu;
520  Glib::RefPtr<Gtk::Action> osc_buffer_menu;
521  Glib::RefPtr<Gtk::Action> jackstartup;
522  Glib::RefPtr<Gtk::Action> loadladspa;
523 
524  Glib::RefPtr<Gtk::ToggleAction> rack_config;
525  Glib::RefPtr<Gtk::ToggleAction> live_play;
526  Glib::RefPtr<Gtk::ToggleAction> engine_mute;
527  sigc::connection engine_mute_conn;
528  Glib::RefPtr<Gtk::ToggleAction> engine_bypass;
529  sigc::connection engine_bypass_conn;
530  Glib::RefPtr<Gtk::ToggleAction> jackserverconnection;
531  Glib::RefPtr<Gtk::ToggleAction> jackports;
532  Glib::RefPtr<Gtk::ToggleAction> midicontroller;
533  Glib::RefPtr<Gtk::ToggleAction> meterbridge;
534  Glib::RefPtr<Gtk::ToggleAction> loggingbox;
535  Glib::RefPtr<Gtk::ToggleAction> animations;
536 
537  Glib::RefPtr<Gtk::ToggleAction> show_plugin_bar;
538  Glib::RefPtr<Gtk::ToggleAction> presets;
539  Glib::RefPtr<Gtk::ToggleAction> show_rack;
540  Glib::RefPtr<UiBoolToggleAction> tuner;
541  Glib::RefPtr<UiBoolToggleAction> tunermove;
542  Glib::RefPtr<UiBoolToggleAction> livetuner;
543  Glib::RefPtr<UiBoolToggleAction> midi_out;
544  Glib::RefPtr<UiBoolToggleAction> midi_out_plug;
545  Glib::RefPtr<Gtk::ToggleAction> show_values;
546  Glib::RefPtr<Gtk::ToggleAction> tooltips;
547  Glib::RefPtr<UiSwitchToggleAction> midi_in_presets;
548  Glib::RefPtr<Gtk::ToggleAction> rackh;
549 
550  Glib::RefPtr<Gtk::RadioAction> skin;
551  Glib::RefPtr<Gtk::RadioAction> latency;
552  Glib::RefPtr<Gtk::RadioAction> osc_buffer_size;
553 
554  // preset window
555  Glib::RefPtr<Gtk::Action> new_bank;
556  Glib::RefPtr<Gtk::Action> save_changes;
557  Glib::RefPtr<Gtk::ToggleAction> organize;
558  Glib::RefPtr<Gtk::Action> online_preset_bank;
559 };
560 
561 
562 
563 class SelectMidiChannel: public Gtk::Window {
564 private:
565  Gtk::Label *description;
566  Gtk::ComboBox *channelcombo;
567  gx_engine::GxMachineBase& machine;
568  sigc::signal<void> close;
569  void on_ok_button();
570  void on_cancel_button();
571  bool on_delete_event(GdkEventAny* event);
572  bool on_key_press_event(GdkEventKey *event);
573  static SelectMidiChannel* create_from_builder(BaseObjectType* cobject, Glib::RefPtr<gx_gui::GxBuilder> bld, gx_engine::GxMachineBase& m) {
574  return new SelectMidiChannel(cobject, bld, m);
575  }
576  SelectMidiChannel(BaseObjectType* cobject, Glib::RefPtr<gx_gui::GxBuilder> bld, gx_engine::GxMachineBase& m);
577 public:
580  sigc::signal<void>& signal_close() { return close; }
581 };
582 
583 
584 
585 class MainWindow: public sigc::trackable {
586 private:
587  gx_system::CmdlineOptions& options;
588  gx_engine::GxMachineBase& machine;
589  Glib::RefPtr<gx_gui::GxBuilder> bld;
590  Freezer freezer;
591  PluginDict plugin_dict;
592  int oldpos;
593  int scrl_size_x;
594  int scrl_size_y;
595  RackContainer monorackcontainer;
596  RackContainer stereorackcontainer;
597  int pre_act;
598  int pool_act;
599  bool is_visible;
600  // bool ui_sleep();
601  DragIcon *drag_icon;
602  Glib::ustring preset_list_menu_bank;
603  Gtk::UIManager::ui_merge_id preset_list_merge_id;
604  Glib::RefPtr<Gtk::ActionGroup> preset_list_actiongroup;
605  Glib::RefPtr<Gtk::UIManager> uimanager;
606  Liveplay *live_play;
607  PresetWindow *preset_window;
608  Gxw::WaveView fWaveView;
609  Gtk::Label convolver_filename_label;
610  Gtk::Label convolver_mono_filename_label;
611  Glib::RefPtr<Gdk::Pixbuf> gx_head_icon;
612  gx_gui::StackBoxBuilder boxbuilder;
613  gx_portmap::PortMapWindow* portmap_window;
614  gx_gui::SelectJackControlPgm *select_jack_control;
615  SelectMidiChannel *select_midi_channel;
616  TextLoggingBox fLoggingWindow;
617  GxUiRadioMenu amp_radio_menu;
618  Glib::RefPtr<Gdk::Pixbuf> pixbuf_insert_on;
619  Glib::RefPtr<Gdk::Pixbuf> pixbuf_insert_off;
620  Glib::RefPtr<Gdk::Pixbuf> pixbuf_on;
621  Glib::RefPtr<Gdk::Pixbuf> pixbuf_off;
622  Glib::RefPtr<Gdk::Pixbuf> pixbuf_bypass;
623  Glib::RefPtr<Gdk::Pixbuf> pixbuf_jack_connected;
624  Glib::RefPtr<Gdk::Pixbuf> pixbuf_jack_disconnected;
625  Glib::RefPtr<Gdk::Pixbuf> pixbuf_log_grey;
626  Glib::RefPtr<Gdk::Pixbuf> pixbuf_log_yellow;
627  Glib::RefPtr<Gdk::Pixbuf> pixbuf_log_red;
628  bool in_session;
629  Glib::RefPtr<Gtk::StatusIcon> status_icon;
630  Glib::RefPtr<Gdk::Pixbuf> gx_head_midi;
631  Glib::RefPtr<Gdk::Pixbuf> gx_head_warn;
632  GxActions actions;
633  KeySwitcher keyswitch;
634  std::map<Glib::ustring, Gtk::ToolItemGroup*> groupmap;
635  ladspa::PluginDisplay *ladspalist_window;
636  Glib::RefPtr<Gtk::SizeGroup> szg_rack_units;
637 
638  // Widget pointers
639  Gxw::PaintBox *tunerbox;
640  Gtk::VBox *tuner_box_no_rack;
641  Gtk::ScrolledWindow *vrack_scrolledbox;
642  Gtk::HBox *stereorackcontainerH;
643  Gtk::HBox *stereorackcontainerV;
644  Gxw::PaintBox *rackcontainer;
645  Gtk::ScrolledWindow *stereorackbox;
646  Gtk::VBox *monocontainer;
647  Gxw::PaintBox *monoampcontainer;
648  Gtk::VPaned *main_vpaned;
649  Gtk::HBox *amp_toplevel_box;
650  Gtk::VBox *monobox;
651  Gtk::VBox *upper_rackbox;
652  Gtk::ScrolledWindow *preset_scrolledbox;
653  Gtk::Box *preset_box_no_rack;
654  Gxw::PaintBox *effects_frame_paintbox;
655  Gtk::Image *insert_image;
656  Gtk::Image *status_image;
657  Gtk::Image *jackd_image;
658  Gtk::Image *logstate_image;
659  Gtk::Window *window;
660  Gtk::HBox *menubox;
661  Gtk::ToggleButton *show_rack_button;
662  Gtk::ToggleButton *rack_order_h_button;
663  Gtk::ToggleButton *config_mode_button;
664  Gtk::ToggleButton *liveplay_button;
665  Gtk::ToggleButton *tuner_button;
666  Gtk::ToggleButton *effects_button;
667  Gtk::ToggleButton *presets_button;
668  Gtk::Button *compress_button;
669  Gtk::Button *expand_button;
670  Gtk::ToolPalette *effects_toolpalette;
671  Gxw::PaintBox *amp_background;
672  Gxw::Switch *tuner_on_off;
673  Gxw::Selector *tuner_mode;
674  Gxw::ValueDisplay *tuner_reference_pitch;
675  Gxw::Selector *tuner_tuning;
676  Gxw::Selector *tuner_temperament;
677  Gxw::RackTuner *racktuner;
678  Gtk::Button *ampdetail_compress;
679  Gtk::Button *ampdetail_expand;
680  Gtk::Widget *ampdetail_mini;
681  Gtk::Widget *ampdetail_normal;
682  Gxw::FastMeter *fastmeter[2];
683  Gtk::Entry *preset_status;
684  Gtk::Container *midi_out_box;
685  Gtk::Container *midi_out_normal;
686  Gtk::Container *midi_out_mini;
687  Gtk::Button *midi_out_compress;
688  Gtk::Button *midi_out_expand;
689  Gtk::Button *midi_out_presets_mini;
690  Gtk::Button *midi_out_presets_normal;
691  Gtk::RadioButton *channel1_button;
692  Gtk::Container *channel1_box;
693  Gtk::RadioButton *channel2_button;
694  Gtk::Container *channel2_box;
695  Gtk::RadioButton *channel3_button;
696  Gtk::Container *channel3_box;
697  Gtk::Alignment *vbam;
698  GdkPixbuf *hanl;
699  GdkPixbuf *hanr;
700 
701 private:
702  bool on_my_leave_out(GdkEventCrossing *focus);
703  bool on_my_enter_in(GdkEventCrossing *focus);
704  void load_widget_pointers();
705  void maybe_shrink_horizontally(bool preset_no_rack=false);
706  void on_show_tuner();
707  void on_move_tuner();
708  bool is_variable_size();
709  void maybe_change_resizable(void);
710  void on_show_rack();
711  void on_preset_action();
712  void on_compress_all();
713  void on_expand_all();
714  void on_show_plugin_bar();
715  void on_rack_configuration();
716  void set_tooltips();
717  void set_animations();
718  void move_widget(Gtk::Widget& w, Gtk::Box& b1, Gtk::Box& b2);
719  int rackbox_stacked_vertical() const;
720  void change_expand(Gtk::Widget& w, bool value);
721  void on_dir_changed();
722  void on_configure_event(GdkEventConfigure *ev);
723  void clear_box(Gtk::Container& box);
724  RackBox *add_rackbox_internal(PluginUI& plugin, Gtk::Widget *mainwidget, Gtk::Widget *miniwidget,
725  bool mini=false, int pos=-1, bool animate=false, Gtk::Widget *bare=0);
726  void on_show_values();
727  void create_actions();
728  void add_toolitem(PluginUI& pl, Gtk::ToolItemGroup *gw);
729  bool on_visibility_notify(GdkEventVisibility *ev);
730  void on_live_play();
731  void on_ti_drag_begin(const Glib::RefPtr<Gdk::DragContext>& context, const PluginUI& plugin);
732  void on_ti_drag_end(const Glib::RefPtr<Gdk::DragContext>& context);
733  void on_ti_drag_data_get(const Glib::RefPtr<Gdk::DragContext>& context, Gtk::SelectionData& selection, int info, int timestamp, const char *effect_id);
734  void on_ti_drag_data_delete(const Glib::RefPtr<Gdk::DragContext>& context, const char *effect_id);
735  bool on_ti_button_press(GdkEventButton *ev, const char *effect_id);
736  void on_tp_drag_data_received(const Glib::RefPtr<Gdk::DragContext>& context, int x, int y, const Gtk::SelectionData& data, int info, int timestamp);
737  void fill_pluginlist();
738  void make_icons(bool force=true);
739  void jack_connection();
740  void on_miditable_toggle();
741  void on_portmap_activate();
742  void on_portmap_response(int);
743  bool connect_jack(bool v, Gtk::Window *splash = 0);
744  int start_jack();
745  void add_skin_menu();
746  void change_skin(Glib::RefPtr<Gtk::RadioAction> action);
747  void on_jack_client_changed();
748  void add_latency_menu();
749  void change_latency(Glib::RefPtr<Gtk::RadioAction> action);
750  void user_disable_latency_warn(Gtk::CheckButton* disable_warn);
751  int gx_wait_latency_warn();
752  void set_latency();
753  void set_osc_size();
754  void add_osc_size_menu();
755  void change_osc_buffer(Glib::RefPtr<Gtk::RadioAction> action);
756  void on_select_jack_control();
757  void on_load_ladspa();
758  void delete_select_jack_control();
759  void on_select_midi_channel();
760  void delete_select_midi_channel();
761  void on_log_activate();
762  bool on_log_activated(GdkEventButton* ev);
763  bool on_log_scrolled(GdkEventScroll* ev);
764  void do_program_change(int pgm);
765  void on_engine_toggled();
766  void on_engine_state_change(gx_engine::GxEngineState state);
767  void set_new_skin(const Glib::ustring& skin_name);
768  void set_tuning(Gxw::RackTuner& tuner);
769  void set_tuner_tet(Gxw::RackTuner& tuner);
770  void set_tuner_ref(Gxw::RackTuner& tuner);
771  void setup_tuner_temperament(Gxw::RackTuner& tuner);
772  void setup_tuner(Gxw::RackTuner& tuner);
773  bool on_toggle_mute(GdkEventButton* ev);
774  bool on_scroll_toggle(GdkEventScroll* ev);
775  bool on_toggle_insert(GdkEventButton* ev);
776  bool on_scroll_toggle_insert(GdkEventScroll* ev);
777  void on_insert_jack_changed(bool s);
778  bool on_jackserverconnection(GdkEventButton* ev);
779  bool on_jackserverconnection_scroll(GdkEventScroll* ev);
780  void on_msg_level_changed();
781  void on_ampdetail_switch(bool compress, bool setparam);
782  void on_show_oscilloscope(bool v);
783  void set_waveview_buffer(unsigned int size);
784  void on_oscilloscope_post_pre(int post_pre);
785  int on_oscilloscope_activate(bool start);
786  bool on_refresh_oscilloscope();
787  bool refresh_meter_level(float falloff);
788  bool survive_jack_shutdown();
789  void gx_jack_is_down();
790  void jack_session_event();
791  void jack_session_event_ins();
792  void set_in_session();
793  void hide_extended_settings();
794  void systray_menu(guint button, guint32 activate_time);
795  void overload_status_changed(gx_engine::MidiAudioBuffer::Load l);
796  bool on_window_state_changed(GdkEventWindowState* event);
797  bool on_meter_button_release(GdkEventButton* ev);
798  void show_selected_preset();
799  void on_select_preset(int idx);
800  void on_next_preset();
801  void on_previus_preset();
802  void set_next_preset_controller();
803  void set_previus_preset_controller();
804  void set_switcher_controller();
805  void set_bypass_controller();
806  void set_vpaned_handle();
807  void rebuild_preset_menu();
808  bool on_key_press_event(GdkEventKey *event);
809  void display_preset_msg(const Glib::ustring& bank, const Glib::ustring& preset);
810  void on_show_midi_out();
811  void on_show_midi_out_plug();
812  void on_midi_out_channel_toggled(Gtk::RadioButton *rb, Gtk::Container *c);
813  void on_livetuner_toggled();
814  Gtk::ToolItemGroup *add_plugin_category(const char *cat, bool collapse = true);
815  Glib::ustring add_plugin_menu_entry(PluginUI *pui);
816  void register_plugin(PluginUI *pui);
817  void on_ladspa_finished(bool reload, bool quit);
818  bool delete_ladspalist_window();
819  bool on_quit();
820  void amp_controls_visible(Gtk::Range *rr);
821  void on_plugin_changed(gx_engine::Plugin *pl, gx_engine::PluginChange::pc c);
822 public:
823  GtkSizeGroup *left_column;
825  Gtk::Window *splash, const Glib::ustring& title);
826  ~MainWindow();
827  void hide_effect(const std::string& name);
828  RackContainer& get_monorackcontainer() { return monorackcontainer; }
829  RackBox *add_rackbox(PluginUI& pl, bool mini=false, int pos=-1, bool animate=false);
830  void add_icon(const std::string& name);
831  PluginUI *get_plugin(const std::string& name) { return plugin_dict[name]; }
832  PluginDict::iterator plugins_begin() { return plugin_dict.begin(); }
833  PluginDict::iterator plugins_end() { return plugin_dict.end(); }
834  void run();
835  gx_system::CmdlineOptions& get_options() { return options; }
836  void plugin_preset_popup(const PluginDef *pdef);
837  void plugin_preset_popup(const PluginDef *pdef, const Glib::ustring& name);
838  gx_engine::GxMachineBase& get_machine() { return machine; }
839  void add_plugin(std::vector<PluginUI*>& p, const char *id, const Glib::ustring& tooltip_="");
840  void set_rackbox_expansion();
841  double stop_at_stereo_bottom(double off, double step_size, double pagesize);
842  double stop_at_mono_top(double off, double step_size);
843  bool use_animations() { return actions.animations->get_active(); }
845  void resize_finished(RackContainer *ch);
846  void update_width();
847 };
848 
849 inline bool RackContainer::check_if_animate(const RackBox& rackbox) { return main.use_animations(); }
850 inline void RackContainer::resize_finished() { main.resize_finished(this); }
DragIcon::~DragIcon
~DragIcon()
Definition: rack.cpp:280
Liveplay
Definition: gx_main_window.h:79
RackContainer::resize_finished
void resize_finished()
Definition: gx_main_window.h:850
SelectMidiChannel::~SelectMidiChannel
~SelectMidiChannel()
Definition: gx_main_window.cpp:191
UiBoolToggleAction
UiToggleAction< bool > UiBoolToggleAction
Definition: gx_main_window.h:46
MainWindow::add_icon
void add_icon(const std::string &name)
Definition: gx_main_window.cpp:1009
RackBox::swtch
void swtch(bool mini)
Definition: rack.cpp:1139
MainWindow::plugin_preset_popup
void plugin_preset_popup(const PluginDef *pdef)
Definition: gx_main_window.cpp:1835
PluginUI::tooltip
Glib::ustring tooltip
Definition: gx_main_window.h:159
GxActions::quit
Glib::RefPtr< Gtk::Action > quit
Definition: gx_main_window.h:516
KeySwitcher::KeySwitcher
KeySwitcher(gx_engine::GxMachineBase &machine_, sigc::slot< void, const Glib::ustring &, const Glib::ustring & > display_)
Definition: gx_main_window.h:67
MainWindow::left_column
GtkSizeGroup * left_column
Definition: gx_main_window.h:823
PluginUI::get_shortname
const char * get_shortname() const
Definition: gx_main_window.h:193
PluginPresetPopup::begin
gx_preset::UnitPresetList::const_iterator begin()
Definition: gx_main_window.h:486
gx_engine::GxMachineBase
Definition: machine.h:53
gx_engine::PluginChange::pc
pc
Definition: gx_engine.h:67
PluginUI::get_action
Glib::RefPtr< Gtk::ToggleAction > get_action()
Definition: gx_main_window.h:186
GxActions::skin
Glib::RefPtr< Gtk::RadioAction > skin
Definition: gx_main_window.h:550
RackBox::set_config_mode
void set_config_mode(bool mode)
Definition: rack.cpp:1150
GxActions::rack_config
Glib::RefPtr< Gtk::ToggleAction > rack_config
Definition: gx_main_window.h:524
Gxw::PaintBox
Definition: paintbox.h:42
PluginDef::category
const char * category
Definition: gx_plugin.h:192
PluginUI::set_ui_merge_id
void set_ui_merge_id(Gtk::UIManager::ui_merge_id id)
Definition: gx_main_window.h:182
MiniRackBox::MiniRackBox
MiniRackBox(RackBox &rb, gx_system::CmdlineOptions &options)
Definition: rack.cpp:379
PluginDef::shortname
const char * shortname
Definition: gx_plugin.h:193
MainWindow::stop_at_stereo_bottom
double stop_at_stereo_bottom(double off, double step_size, double pagesize)
Definition: gx_main_window.cpp:924
PluginUI::on_plugin_preset_popup
virtual void on_plugin_preset_popup()
Definition: rack.cpp:82
gx_gui::uiToggle< bool >
PluginPresetPopup::PluginPresetPopup
PluginPresetPopup(const PluginDef *pdef, gx_engine::GxMachineBase &machine, const Glib::ustring &save_name_default="")
Definition: rack.cpp:778
Freezer::check_thaw
bool check_thaw(int width, int height)
Definition: gx_main_window.cpp:455
GxActions::group
Glib::RefPtr< Gtk::ActionGroup > group
Definition: gx_main_window.h:513
PluginPresetPopup::end
gx_preset::UnitPresetList::const_iterator end()
Definition: gx_main_window.h:487
RackContainer::empty
bool empty() const
Definition: gx_main_window.h:395
Gxw::Switch
Definition: switch.h:44
Freezer::freeze_until_width_update
void freeze_until_width_update(Gtk::Window *w, int width)
Definition: gx_main_window.cpp:400
RackContainer
Definition: gx_main_window.h:350
GxActions::midi_out
Glib::RefPtr< UiBoolToggleAction > midi_out
Definition: gx_main_window.h:543
PluginUI::shortname
const char * shortname
Definition: gx_main_window.h:160
PresetWindow
Definition: gx_preset_window.h:71
Liveplay::display_tuner
void display_tuner(bool v)
Definition: liveplay.cpp:472
MainWindow::stop_at_mono_top
double stop_at_mono_top(double off, double step_size)
Definition: gx_main_window.cpp:933
PluginUI::display
void display(bool v, bool animate)
Definition: rack.cpp:137
Liveplay::get_tuner
Gxw::RackTuner & get_tuner()
Definition: gx_main_window.h:143
gx_engine::MidiAudioBuffer::Load
Load
Definition: gx_internal_plugins.h:179
PluginType
PluginType
Definition: machine.h:34
MainWindow::resize_finished
void resize_finished(RackContainer *ch)
Definition: gx_main_window.cpp:964
MainWindow::get_plugin
PluginUI * get_plugin(const std::string &name)
Definition: gx_main_window.h:831
UiSwitchToggleAction
UiBoolToggleAction UiSwitchToggleAction
Definition: gx_main_window.h:47
GxActions::save_changes
Glib::RefPtr< Gtk::Action > save_changes
Definition: gx_main_window.h:556
Liveplay::Liveplay
Liveplay(const gx_system::CmdlineOptions &options, gx_engine::GxMachineBase &machine, const std::string &fname, const GxActions &actions)
Definition: liveplay.cpp:235
RackContainer::rackbox_list
Glib::ListHandle< RackBox * > rackbox_list
Definition: gx_main_window.h:379
GxActions::jack_latency_menu
Glib::RefPtr< Gtk::Action > jack_latency_menu
Definition: gx_main_window.h:519
ladspa::PluginDisplay
Definition: ladspalist.h:85
UiToggleAction
Definition: gx_main_window.h:26
gx_engine::GxMachineBase::create_default_scratch_preset
virtual void create_default_scratch_preset()=0
PluginPresetPopup::get_pdef
const PluginDef * get_pdef()
Definition: gx_main_window.h:488
UiToggleAction::UiToggleAction
UiToggleAction(gx_engine::GxMachineBase &machine_, const std::string &id, const Glib::ustring &name, const Glib::ustring &icon_name, const Glib::ustring &label=Glib::ustring(), const Glib::ustring &tooltip=Glib::ustring(), bool is_active=false)
Definition: gx_main_window.cpp:488
GxActions::livetuner
Glib::RefPtr< UiBoolToggleAction > livetuner
Definition: gx_main_window.h:542
GxActions::jackserverconnection
Glib::RefPtr< Gtk::ToggleAction > jackserverconnection
Definition: gx_main_window.h:530
RackBox::get_plug_visible
bool get_plug_visible()
Definition: gx_main_window.h:322
gx_preset::UnitPresetList
std::vector< PluginPresetEntry > UnitPresetList
Definition: gx_preset.h:135
PluginDict::~PluginDict
~PluginDict()
Definition: rack.cpp:221
PluginDef::name
const char * name
Definition: gx_plugin.h:188
RackBox::setOrder
void setOrder(int pos, int post_pre)
Definition: rack.cpp:1166
KeySwitcher::display_key_error
void display_key_error()
Definition: liveplay.cpp:38
GxActions::engine_mute_conn
sigc::connection engine_mute_conn
Definition: gx_main_window.h:527
gx_engine::GxEngineState
GxEngineState
Definition: gx_modulesequencer.h:289
GxActions::jackports
Glib::RefPtr< Gtk::ToggleAction > jackports
Definition: gx_main_window.h:531
gx_engine::Plugin::get_plug_visible
bool get_plug_visible() const
Definition: gx_pluginloader.h:62
KeySwitcher
Definition: gx_main_window.h:54
PluginUI
Definition: gx_main_window.h:152
SelectMidiChannel::signal_close
sigc::signal< void > & signal_close()
Definition: gx_main_window.h:580
RackBox::can_compress
bool can_compress()
Definition: gx_main_window.h:312
GxActions::meterbridge
Glib::RefPtr< Gtk::ToggleAction > meterbridge
Definition: gx_main_window.h:533
PluginUI::hidden
bool hidden
Definition: gx_main_window.h:169
GxActions::accels
Glib::RefPtr< Gtk::AccelGroup > accels
Definition: gx_main_window.h:514
TextLoggingBox::TextLoggingBox
TextLoggingBox()
Definition: gx_main_window.cpp:41
RackContainer::check_order
void check_order()
Definition: rack.cpp:1631
PluginDef
Definition: gx_plugin.h:183
GxActions::new_bank
Glib::RefPtr< Gtk::Action > new_bank
Definition: gx_main_window.h:555
GxActions::loadladspa
Glib::RefPtr< Gtk::Action > loadladspa
Definition: gx_main_window.h:522
Gxw::WaveView
Definition: waveview.h:42
PluginUI::hide
void hide(bool animate)
Definition: rack.cpp:116
RackContainer::increment
void increment()
Definition: rack.cpp:1608
RackContainer::show_entries
void show_entries()
Definition: rack.cpp:1564
GxActions::midicontroller
Glib::RefPtr< Gtk::ToggleAction > midicontroller
Definition: gx_main_window.h:532
PluginUI::is_registered
static bool is_registered(gx_engine::GxMachineBase &m, const char *name)
Definition: rack.cpp:86
Gxw::RackTuner
Definition: racktuner.h:42
MainWindow::get_machine
gx_engine::GxMachineBase & get_machine()
Definition: gx_main_window.h:838
RackBox::get_id
const char * get_id() const
Definition: gx_main_window.h:314
TextLoggingBox
Definition: gx_main_window.h:408
MainWindow::get_options
gx_system::CmdlineOptions & get_options()
Definition: gx_main_window.h:835
PluginUI::icon
Glib::RefPtr< Gdk::Pixbuf > icon
Definition: gx_main_window.h:163
GxUiRadioMenu::GxUiRadioMenu
GxUiRadioMenu(gx_engine::GxMachineBase &machine, const std::string &id)
Definition: gx_main_window.cpp:316
RackContainer::ensure_visible
void ensure_visible(RackBox &child)
Definition: rack.cpp:1469
GxActions::rackh
Glib::RefPtr< Gtk::ToggleAction > rackh
Definition: gx_main_window.h:548
MiniRackBox::pack
void pack(Gtk::Widget *w)
Definition: rack.cpp:478
MainWindow::hide_effect
void hide_effect(const std::string &name)
Definition: gx_main_window.cpp:1117
GxActions::online_preset_bank
Glib::RefPtr< Gtk::Action > online_preset_bank
Definition: gx_main_window.h:558
PluginUI::hidden_by_move
bool hidden_by_move
Definition: gx_main_window.h:170
PluginDict
Definition: gx_main_window.h:216
Freezer::set_slot
void set_slot(sigc::slot< void > w)
Definition: gx_main_window.cpp:392
GxActions::tuner
Glib::RefPtr< UiBoolToggleAction > tuner
Definition: gx_main_window.h:540
GxActions::compress
Glib::RefPtr< Gtk::Action > compress
Definition: gx_main_window.h:517
TextLoggingBox::signal_msg_level_changed
sigc::signal< void > & signal_msg_level_changed()
Definition: gx_main_window.h:435
N_
#define N_(String)
Definition: gx_faust_support.h:23
PluginUI::set_action
void set_action(Glib::RefPtr< Gtk::ToggleAction > &act)
Definition: rack.cpp:99
GxActions
Definition: gx_main_window.h:511
MainWindow::add_plugin
void add_plugin(std::vector< PluginUI * > &p, const char *id, const Glib::ustring &tooltip_="")
Definition: gx_main_window.cpp:1993
RackContainer::reorder
void reorder(const std::string &name, unsigned int pos)
Definition: rack.cpp:1588
PluginUI::show
void show(bool animate)
Definition: rack.cpp:124
RackBox::pack
void pack(Gtk::Widget *mainbox, Gtk::Widget *minibox, const Glib::RefPtr< Gtk::SizeGroup > &szg)
Definition: rack.cpp:1220
plugins_by_name_less
bool plugins_by_name_less(PluginUI *a, PluginUI *b)
Definition: rack.cpp:187
GxActions::tunermove
Glib::RefPtr< UiBoolToggleAction > tunermove
Definition: gx_main_window.h:541
gx_portmap::PortMapWindow
Definition: gx_portmap.h:58
TextLoggingBox::~TextLoggingBox
~TextLoggingBox()
Definition: gx_main_window.cpp:97
PluginUI::plugin
gx_engine::Plugin * plugin
Definition: gx_main_window.h:158
GxActions::osc_buffer_menu
Glib::RefPtr< Gtk::Action > osc_buffer_menu
Definition: gx_main_window.h:520
RackBox::create_icon_widget
static Gtk::Widget * create_icon_widget(const PluginUI &plugin, gx_system::CmdlineOptions &options)
Definition: rack.cpp:906
GxActions::latency
Glib::RefPtr< Gtk::RadioAction > latency
Definition: gx_main_window.h:551
PluginUI::toolitem
Gtk::ToolItem * toolitem
Definition: gx_main_window.h:165
Gxw::Selector
Definition: selector.h:43
PluginUI::get_type
PluginType get_type() const
Definition: gx_main_window.h:175
MiniRackBox
Definition: gx_main_window.h:326
RackContainer::RackContainer
RackContainer(PluginType tp, MainWindow &main)
Definition: rack.cpp:1301
Liveplay::on_live_play
void on_live_play(Glib::RefPtr< Gtk::ToggleAction > act)
Definition: liveplay.cpp:427
PluginPresetPopup
Definition: gx_main_window.h:468
KeySwitcher::deactivate
void deactivate()
Definition: liveplay.cpp:30
GxActions::live_play
Glib::RefPtr< Gtk::ToggleAction > live_play
Definition: gx_main_window.h:525
gx_engine::Plugin::get_pdef
PluginDef * get_pdef()
Definition: gx_pluginloader.h:55
MainWindow::plugins_end
PluginDict::iterator plugins_end()
Definition: gx_main_window.h:833
PluginUI::unset_ui_merge_id
void unset_ui_merge_id(Glib::RefPtr< Gtk::UIManager > uimanager)
Definition: rack.cpp:75
MainWindow::create_default_scratch_preset
void create_default_scratch_preset()
Definition: gx_main_window.h:844
PluginUI::set_active
void set_active(bool v)
Definition: gx_main_window.h:185
GxActions::organize
Glib::RefPtr< Gtk::ToggleAction > organize
Definition: gx_main_window.h:557
DragIcon
Definition: gx_main_window.h:235
SelectMidiChannel::create
static SelectMidiChannel * create(gx_system::CmdlineOptions &opt, gx_engine::GxMachineBase &machine)
Definition: gx_main_window.cpp:195
GxActions::midi_out_plug
Glib::RefPtr< UiBoolToggleAction > midi_out_plug
Definition: gx_main_window.h:544
GxActions::animations
Glib::RefPtr< Gtk::ToggleAction > animations
Definition: gx_main_window.h:535
PluginUI::main
MainWindow & main
Definition: gx_main_window.h:167
PluginUI::group
Gtk::ToolItemGroup * group
Definition: gx_main_window.h:164
PluginUI::get_id
const char * get_id() const
Definition: gx_main_window.h:178
PluginDict::remove
void remove(PluginUI *p)
Definition: rack.cpp:208
GxActions::osc_buffer_size
Glib::RefPtr< Gtk::RadioAction > osc_buffer_size
Definition: gx_main_window.h:552
GxActions::jackstartup
Glib::RefPtr< Gtk::Action > jackstartup
Definition: gx_main_window.h:521
RackBox::animate_insert
void animate_insert()
Definition: rack.cpp:1090
RackBox::RackBox
RackBox(PluginUI &plugin, MainWindow &main, Gtk::Widget *bare=0)
Definition: rack.cpp:970
MiniRackBox::set_config_mode
void set_config_mode(bool mode)
Definition: rack.cpp:484
PluginUI::update_rackbox
void update_rackbox()
Definition: rack.cpp:164
PluginDict::compress
void compress(bool state)
Definition: rack.cpp:225
UiToggleAction::~UiToggleAction
~UiToggleAction()
Definition: gx_main_window.cpp:501
Gxw::HSlider
Definition: hslider.h:43
Liveplay::~Liveplay
~Liveplay()
Definition: liveplay.cpp:377
Gxw::ValueDisplay
Definition: valuedisplay.h:43
PluginDef::id
const char * id
Definition: gx_plugin.h:187
PluginPresetPopup::get_machine
gx_engine::GxMachineBase & get_machine()
Definition: gx_main_window.h:489
RackContainer::check_if_animate
bool check_if_animate(const RackBox &rackbox)
Definition: gx_main_window.h:849
KeySwitcher::process_preset_key
bool process_preset_key(int idx)
Definition: liveplay.cpp:71
RackContainer::decrement
void decrement()
Definition: rack.cpp:1615
GxLogger::kMessageTypeCount
@ kMessageTypeCount
Definition: gx_logging.h:45
PluginUI::compress
void compress(bool state)
Definition: rack.cpp:90
MainWindow::add_rackbox
RackBox * add_rackbox(PluginUI &pl, bool mini=false, int pos=-1, bool animate=false)
Definition: gx_main_window.cpp:995
Freezer::Freezer
Freezer()
Definition: gx_main_window.cpp:370
MainWindow::use_animations
bool use_animations()
Definition: gx_main_window.h:843
GxActions::show_rack
Glib::RefPtr< Gtk::ToggleAction > show_rack
Definition: gx_main_window.h:539
TextLoggingBox::reset_msg_level
void reset_msg_level()
Definition: gx_main_window.cpp:118
RackContainer::hide_entries
void hide_entries()
Definition: rack.cpp:1576
RackContainer::rackbox_const_list
Glib::ListHandle< const RackBox * > rackbox_const_list
Definition: gx_main_window.h:378
PluginUI::plugins_by_name_less
friend bool plugins_by_name_less(PluginUI *a, PluginUI *b)
Definition: rack.cpp:187
PGN_STEREO
@ PGN_STEREO
Definition: gx_plugin.h:162
PluginDef::flags
int flags
Definition: gx_plugin.h:185
PluginUI::get_category
const char * get_category()
Definition: gx_main_window.h:189
PluginUI::display_new
void display_new(bool unordered=false)
Definition: rack.cpp:153
Gxw::FastMeter
Definition: fastmeter.h:42
gx_gui::StackBoxBuilder
Definition: gx_stackbox_builder.h:44
MainWindow::get_monorackcontainer
RackContainer & get_monorackcontainer()
Definition: gx_main_window.h:828
GxActions::midi_in_presets
Glib::RefPtr< UiSwitchToggleAction > midi_in_presets
Definition: gx_main_window.h:547
GxActions::engine_mute
Glib::RefPtr< Gtk::ToggleAction > engine_mute
Definition: gx_main_window.h:526
gx_system::CmdlineOptions
Definition: gx_system.h:381
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)
Definition: gx_main_window.cpp:409
TextLoggingBox::get_unseen_msg_level
int get_unseen_msg_level()
Definition: gx_main_window.h:434
PluginUI::rackbox
RackBox * rackbox
Definition: gx_main_window.h:168
RackBox
Definition: gx_main_window.h:259
GxActions::tooltips
Glib::RefPtr< Gtk::ToggleAction > tooltips
Definition: gx_main_window.h:546
MainWindow::update_width
void update_width()
Definition: gx_main_window.cpp:971
KeySwitcher::process_bank_key
bool process_bank_key(int idx)
Definition: liveplay.cpp:91
MainWindow::MainWindow
MainWindow(gx_engine::GxMachineBase &machine, gx_system::CmdlineOptions &options, Gtk::Window *splash, const Glib::ustring &title)
Definition: gx_main_window.cpp:2846
start
CmdConnection::msg_type start
Definition: jsonrpc.cpp:257
PLUGIN_TYPE_MONO
@ PLUGIN_TYPE_MONO
Definition: machine.h:35
MainWindow::set_rackbox_expansion
void set_rackbox_expansion()
Freezer::~Freezer
~Freezer()
Definition: gx_main_window.cpp:374
PluginUI::PluginUI
PluginUI(MainWindow &main, const char *id_, const Glib::ustring &tooltip_="")
Definition: rack.cpp:44
GxUiRadioMenu
Definition: gx_main_window.h:497
SelectMidiChannel
Definition: gx_main_window.h:563
TunerSwitcher::SwitcherState
SwitcherState
Definition: tunerswitcher.h:33
end
CmdConnection::msg_type end
Definition: jsonrpc.cpp:258
gx_gui::SelectJackControlPgm
Definition: gx_jack_options.h:38
RackBox::create_drag_widget
static Gtk::Widget * create_drag_widget(const PluginUI &plugin, gx_system::CmdlineOptions &options)
Definition: rack.cpp:918
GxActions::engine_bypass_conn
sigc::connection engine_bypass_conn
Definition: gx_main_window.h:529
gx_engine::Plugin
Definition: gx_pluginloader.h:45
RackBox::get_box_visible
bool get_box_visible()
Definition: gx_main_window.h:323
GxActions::presets
Glib::RefPtr< Gtk::ToggleAction > presets
Definition: gx_main_window.h:538
PluginDict::cleanup
void cleanup()
Definition: rack.cpp:214
PluginDict::add
void add(PluginUI *p)
Definition: rack.cpp:204
RackContainer::set_config_mode
void set_config_mode(bool mode)
Definition: rack.cpp:1623
GxActions::loggingbox
Glib::RefPtr< Gtk::ToggleAction > loggingbox
Definition: gx_main_window.h:534
MainWindow
Definition: gx_main_window.h:585
GxActions::show_plugin_bar
Glib::RefPtr< Gtk::ToggleAction > show_plugin_bar
Definition: gx_main_window.h:537
RackContainer::add
void add(RackBox &r, int pos=-1)
Definition: rack.cpp:1598
PluginPresetPopup::on_selection_done
virtual void on_selection_done()
Definition: rack.cpp:771
PluginDict::iterator
std::map< std::string, PluginUI * >::iterator iterator
Definition: gx_main_window.h:220
GxActions::expand
Glib::RefPtr< Gtk::Action > expand
Definition: gx_main_window.h:518
PluginUI::~PluginUI
virtual ~PluginUI()
Definition: rack.cpp:64
MainWindow::~MainWindow
~MainWindow()
Definition: gx_main_window.cpp:3304
MainWindow::plugins_begin
PluginDict::iterator plugins_begin()
Definition: gx_main_window.h:832
GxLogger::MsgType
MsgType
Definition: gx_logging.h:39
PluginDict::PluginDict
PluginDict()
Definition: gx_main_window.h:221
RackContainer::get_children
rackbox_list get_children()
Definition: gx_main_window.h:381
main
int main(int argc, char *argv[])
Definition: gxw_demo.cc:67
PluginDict::operator[]
PluginUI * operator[](const std::string &s)
Definition: gx_main_window.h:226
UiToggleAction::create
static Glib::RefPtr< UiToggleAction > create(gx_engine::GxMachineBase &machine, const std::string &id, const Glib::ustring &name, const Glib::ustring &label=Glib::ustring(), const Glib::ustring &tooltip=Glib::ustring(), bool is_active=false)
Definition: gx_main_window.h:38
GxActions::engine_bypass
Glib::RefPtr< Gtk::ToggleAction > engine_bypass
Definition: gx_main_window.h:528
GxActions::show_values
Glib::RefPtr< Gtk::ToggleAction > show_values
Definition: gx_main_window.h:545
DragIcon::DragIcon
DragIcon(const PluginUI &plugin, Glib::RefPtr< Gdk::DragContext > context, gx_system::CmdlineOptions &options, int xoff=0)
Definition: rack.cpp:255
GxUiRadioMenu::setup
void setup(const Glib::ustring &prefix, const Glib::ustring &postfix, Glib::RefPtr< Gtk::UIManager > &uimanager, Glib::RefPtr< Gtk::ActionGroup > &actiongroup)
Definition: gx_main_window.cpp:323
Freezer
Definition: gx_main_window.h:441
PluginUI::get_name
const char * get_name() const
Definition: gx_main_window.h:179
MainWindow::run
void run()
Definition: gx_main_window.cpp:2765
RackBox::display
void display(bool v, bool animate)
Definition: rack.cpp:946
RackBox::get_parent
RackContainer * get_parent()
Definition: rack.cpp:1065