Guitarix
liveplay.cpp
Go to the documentation of this file.
1 /*
2  * Copyright (C) 2009, 2010 Hermann Meyer, James Warden
3  * Copyright (C) 2011 Pete Shorthose
4  * Copyright (C) 2012 Andreas Degert
5  *
6  * This program is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 2 of the License, or
9  * (at your option) any later version.
10  *
11  * This program is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
19  * ---------------------------------------------------------------------------
20  *
21  * ----------------------------------------------------------------------------
22  */
23 
24 #include <guitarix.h>
25 
26 /****************************************************************
27  ** class KeySwitcher
28  */
29 
31  last_bank_key.clear();
32  if (key_timeout.connected()) {
33  key_timeout.disconnect();
34  display_current();
35  }
36 }
37 
39  display_empty("??", "??");
40 }
41 
42 void KeySwitcher::display_empty(const Glib::ustring& bank, const Glib::ustring& preset) {
43  display(bank, preset);
44  key_timeout.disconnect();
45  if (last_bank_key.empty()) {
46  key_timeout = Glib::signal_timeout().connect(
47  sigc::mem_fun(this, &KeySwitcher::display_current), 400);
48  } else {
49  key_timeout = Glib::signal_timeout().connect(
50  sigc::mem_fun(this, &KeySwitcher::display_selected_bank), 400);
51  }
52 }
53 
54 bool KeySwitcher::display_selected_bank() {
55  display(last_bank_key, "");
56  key_timeout = Glib::signal_timeout().connect(
57  sigc::mem_fun(this, &KeySwitcher::display_current), 2000);
58  return false;
59 }
60 
61 bool KeySwitcher::display_current() {
62  last_bank_key.clear();
63  if (!machine.setting_is_preset()) {
64  display("----","");
65  } else {
66  display(machine.get_current_bank(), machine.get_current_name());
67  }
68  return false;
69 }
70 
72  key_timeout.disconnect();
73  Glib::ustring bank = last_bank_key;
74  if (bank.empty()) {
75  if (!machine.setting_is_preset()) {
76  display_empty("??", gx_system::to_string(idx+1));
77  return false;
78  }
79  bank = machine.get_current_bank();
80  }
81  gx_system::PresetFileGui *f = machine.get_bank_file(bank);
82  if (idx >= f->size()) {
83  display_empty(bank, gx_system::to_string(idx+1)+"?");
84  return false;
85  } else {
86  machine.load_preset(f, f->get_name(idx));
87  return true;
88  }
89 }
90 
92  key_timeout.disconnect();
93  Glib::ustring bank = machine.get_bank_name(machine.bank_size() - idx - 1);
94  if (bank.empty()) {
95  display_empty("--", "--");
96  return false;
97  }
98  last_bank_key = bank;
99  display_selected_bank();
100  return true;
101 }
102 
103 
104 /****************************************************************
105  ** class Liveplay
106  */
107 
108 void Liveplay::display(const Glib::ustring& bank, const Glib::ustring& preset) {
109  liveplay_bank->set_text(bank);
110  liveplay_preset->set_text(preset);
111 }
112 
113 bool Liveplay::do_action(GtkAccelGroup *accel_group, GObject *acceleratable,
114  guint keyval, GdkModifierType modifier,
115  GtkAction* act) {
116  gtk_action_activate(act);
117  return true;
118 }
119 
120 bool Liveplay::on_keyboard_preset_select(GtkAccelGroup *accel_group, GObject *acceleratable,
121  guint keyval, GdkModifierType modifier, Liveplay& self) {
122  if (keyval >= GDK_KEY_0 && keyval <= GDK_KEY_9) {
123  self.keyswitch.process_preset_key(keyval - GDK_KEY_0);
124  return true;
125  }
126  if (keyval >= GDK_KEY_KP_0 && keyval <= GDK_KEY_KP_9) {
127  self.keyswitch.process_preset_key(keyval - GDK_KEY_KP_0);
128  return true;
129  }
130  if (keyval >= GDK_KEY_a && keyval <= GDK_KEY_z) {
131  self.keyswitch.process_bank_key(keyval - GDK_KEY_a);
132  return true;
133  }
134  self.keyswitch.display_key_error();
135  return true;
136 }
137 
138 bool Liveplay::on_keyboard_toggle_mute(GtkAccelGroup *accel_group, GObject *acceleratable,
139  guint keyval, GdkModifierType modifier, Liveplay& self) {
140  self.machine.set_state(self.machine.get_state() == gx_engine::kEngineOff ?
143  return true;
144 }
145 
146 bool Liveplay::on_keyboard_toggle_bypass(GtkAccelGroup *accel_group, GObject *acceleratable,
147  guint keyval, GdkModifierType modifier, Liveplay& self) {
148  self.machine.set_state(self.machine.get_state() == gx_engine::kEngineBypass ?
151  return true;
152 }
153 
154 bool Liveplay::on_keyboard_mode_switch(GtkAccelGroup *accel_group, GObject *acceleratable,
155  guint keyval, GdkModifierType modifier, Liveplay& self) {
156  self.machine.tuner_switcher_toggle(self.actions.livetuner->get_active());
157  return true;
158 }
159 
160 void Liveplay::set_display_state(TunerSwitcher::SwitcherState newstate) {
161  bool sens = true;
162  Gtk::StateType st = Gtk::STATE_NORMAL;
163  switch (newstate) {
165  break;
167  sens = false;
168  st = Gtk::STATE_SELECTED;
169  break;
171  st = Gtk::STATE_SELECTED;
172  break;
174  st = Gtk::STATE_PRELIGHT;
175  break;
176  default:
177  assert(false);
178  break;
179  }
180  liveplay_bank->set_sensitive(sens);
181  liveplay_bank->set_state(st);
182  liveplay_preset->set_sensitive(sens);
183  liveplay_preset->set_state(st);
184 }
185 
186 bool Liveplay::on_keyboard_arrows(GtkAccelGroup *accel_group, GObject *acceleratable,
187  guint keyval, GdkModifierType modifier, Liveplay& self) {
188  if (keyval == GDK_KEY_Left || keyval == GDK_KEY_Right) {
189  Gtk::Adjustment *a = self.brightness_slider->get_adjustment();
190  double val = a->get_value();
191  double step = a->get_step_increment();
192  if (keyval == GDK_KEY_Left) {
193  val -= step;
194  } else {
195  val += step;
196  }
197  a->set_value(val);
198  } else {
199  Gtk::Adjustment *a = self.background_slider->get_adjustment();
200  double val = a->get_value();
201  double step = a->get_step_increment();
202  if (keyval == GDK_KEY_Down) {
203  val -= step;
204  } else {
205  val += step;
206  }
207  a->set_value(val);
208  }
209  return true;
210 }
211 
212 class MyPaintBox: public Gxw::PaintBox {
213 private:
214  Gtk::Adjustment *background_adj;
215  MyPaintBox(BaseObjectType* cobject, Gtk::Adjustment *background_adj_)
216  : Gxw::PaintBox(cobject), background_adj(background_adj_) {}
217 public:
218  static MyPaintBox *create_from_builder(BaseObjectType* cobject, Gtk::Adjustment *background_adj) {
219  return new MyPaintBox(cobject, background_adj); }
220  virtual bool on_expose_event(GdkEventExpose *event);
221 };
222 
223 bool MyPaintBox::on_expose_event(GdkEventExpose *event) {
224  call_paint_func(event);
225  Cairo::RefPtr<Cairo::Context> cr = Glib::wrap(event->window, true)->create_cairo_context();
226  gdk_cairo_region(cr->cobj(), event->region);
227  cr->clip();
228  cr->set_source_rgba(0.0, 0.0, 0.0, 1-background_adj->get_value());
229  cr->paint();
230  foreach(sigc::bind(sigc::mem_fun(this, &MyPaintBox::propagate_expose), event));
231  return true;
232 }
233 
234 
236  const gx_system::CmdlineOptions& options, gx_engine::GxMachineBase& machine_,
237  const std::string& fname, const GxActions& actions_)
238  : bld(),
239  machine(machine_),
240  actions(actions_),
241  use_composite(),
242  brightness_adj(),
243  background_adj(),
244  keyswitch(machine_, sigc::mem_fun(this, &Liveplay::display)),
245  midi_conn(),
246  window(),
247  mouse_hide_conn() {
248  const char *id_list[] = {"LivePlay", 0};
249  bld = gx_gui::GxBuilder::create_from_file(fname, &machine, id_list);
250  bld->get_toplevel("LivePlay", window);
251 
252  bld->find_widget("liveplay_bank", liveplay_bank);
253  bld->find_widget("liveplay_preset", liveplay_preset);
254  bld->find_widget("liveplay_bypass_image", bypass_image);
255  bld->find_widget("liveplay_mute_image", mute_image);
256  bld->find_widget("liveplay_canvas", liveplay_canvas);
257  bld->find_widget("brightness_slider", brightness_slider);
258  bld->find_widget("brightness_box", brightness_box);
259  bld->find_widget("background_slider", background_slider);
260  bld->find_widget("liveplay_exit:barbutton", liveplay_exit);
261  bld->find_widget("liveplay_tuner", tuner);
262  bld->find_widget("liveplay_midictrl_table", midictrl_table);
263  brightness_adj = brightness_slider->get_adjustment();
264  background_adj = background_slider->get_adjustment();
265  MyPaintBox *liveplay_paintbox;
266  bld->find_widget_derived(
267  "liveplay_paintbox", liveplay_paintbox,
268  sigc::bind(
269  sigc::ptr_fun(MyPaintBox::create_from_builder),
270  background_adj));
271  Glib::RefPtr<Gdk::Pixbuf> pb;
272  try {
273  pb = Gdk::Pixbuf::create_from_file(
274  options.get_style_filepath("live_bypass.png"));
275  bypass_image->set(pb);
276  } catch (const Glib::FileError& ex) {
277  gx_print_error("liveplay", ex.what());
278  } catch (const Gdk::PixbufError& ex) {
279  gx_print_error("liveplay", ex.what());
280  } catch(...) {
281  gx_print_error("liveplay", "failed to load pixmap live_bypass.png");
282  }
283  try {
284  pb = Gdk::Pixbuf::create_from_file(
285  options.get_style_filepath("live_mute.png"));
286  mute_image->set(pb);
287  } catch (const Glib::FileError& ex) {
288  gx_print_error("liveplay", ex.what());
289  } catch (const Gdk::PixbufError& ex) {
290  gx_print_error("liveplay", ex.what());
291  } catch(...) {
292  gx_print_error("liveplay", "failed to load pixmap live_mute.png");
293  }
294  use_composite = window->get_display()->supports_composite();
295  if (use_composite) {
296  brightness_adj->signal_value_changed().connect(sigc::mem_fun(this, &Liveplay::on_brightness_changed));
297  liveplay_canvas->signal_realize().connect(sigc::mem_fun(this, &Liveplay::on_realize));
298  window->signal_expose_event().connect(
299  sigc::mem_fun(this, &Liveplay::window_expose_event), true);
300  } else {
301  brightness_box->hide();
302  }
303  background_adj->signal_value_changed().connect(
304  sigc::mem_fun(this, &Liveplay::on_background_changed));
305  Glib::RefPtr<Gdk::Screen> screen = liveplay_canvas->get_screen();
306  Glib::RefPtr<Gdk::Colormap> rgba = screen->get_rgba_colormap();
307  liveplay_canvas->set_colormap(rgba);
308  liveplay_canvas->set_app_paintable(true);
309  window->signal_delete_event().connect(
310  sigc::mem_fun(this, &Liveplay::on_delete));
311  window->add_events(Gdk::POINTER_MOTION_HINT_MASK|Gdk::POINTER_MOTION_MASK);
312  window->signal_motion_notify_event().connect(
313  sigc::mem_fun(*this, &Liveplay::pointer_motion));
314 
315  gtk_activatable_set_related_action(
316  GTK_ACTIVATABLE(liveplay_exit->gobj()), GTK_ACTION(actions.live_play->gobj()));
317  Glib::RefPtr<Gtk::AccelGroup> ag = Gtk::AccelGroup::create();
318  GClosure *cl = g_cclosure_new(G_CALLBACK(do_action), (gpointer)(actions.live_play->gobj()), 0);
319  gtk_accel_group_connect_by_path(ag->gobj(), actions.live_play->get_accel_path().c_str(), cl);
320  cl = g_cclosure_new(G_CALLBACK(do_action), (gpointer)(actions.live_play->gobj()), 0);
321  gtk_accel_group_connect(ag->gobj(), GDK_KEY_Escape, (GdkModifierType)0, (GtkAccelFlags)0, cl);
322 
323  cl = g_cclosure_new(G_CALLBACK(do_action), (gpointer)(actions.livetuner->gobj()), 0);
324  gtk_accel_group_connect(ag->gobj(), GDK_KEY_Return, (GdkModifierType)0, (GtkAccelFlags)0, cl);
325 
326  cl = g_cclosure_new(G_CALLBACK(do_action), (gpointer)(actions.quit->gobj()), 0);
327  gtk_accel_group_connect_by_path(ag->gobj(), actions.quit->get_accel_path().c_str(), cl);
328 
329  cl = g_cclosure_new(G_CALLBACK(on_keyboard_toggle_mute), (gpointer)this, 0);
330  gtk_accel_group_connect(ag->gobj(), GDK_KEY_M, GDK_CONTROL_MASK, (GtkAccelFlags)0, cl);
331 
332  cl = g_cclosure_new(G_CALLBACK(on_keyboard_toggle_bypass), (gpointer)this, 0);
333  gtk_accel_group_connect(ag->gobj(), GDK_KEY_B, GDK_CONTROL_MASK, (GtkAccelFlags)0, cl);
334 
335  cl = g_cclosure_new(G_CALLBACK(on_keyboard_arrows), (gpointer)this, 0);
336  gtk_accel_group_connect(ag->gobj(), GDK_KEY_Left, GDK_CONTROL_MASK, (GtkAccelFlags)0, cl);
337  cl = g_cclosure_new(G_CALLBACK(on_keyboard_arrows), (gpointer)this, 0);
338  gtk_accel_group_connect(ag->gobj(), GDK_KEY_Right, GDK_CONTROL_MASK, (GtkAccelFlags)0, cl);
339  cl = g_cclosure_new(G_CALLBACK(on_keyboard_arrows), (gpointer)this, 0);
340  gtk_accel_group_connect(ag->gobj(), GDK_KEY_Up, GDK_CONTROL_MASK, (GtkAccelFlags)0, cl);
341  cl = g_cclosure_new(G_CALLBACK(on_keyboard_arrows), (gpointer)this, 0);
342  gtk_accel_group_connect(ag->gobj(), GDK_KEY_Down, GDK_CONTROL_MASK, (GtkAccelFlags)0, cl);
343 
344  for (int n = GDK_KEY_0; n <= GDK_KEY_9; ++n) {
345  cl = g_cclosure_new(G_CALLBACK(on_keyboard_preset_select), (gpointer)this, 0);
346  gtk_accel_group_connect(ag->gobj(), n, (GdkModifierType)0, (GtkAccelFlags)0, cl);
347  }
348  for (int n = GDK_KEY_KP_0; n <= GDK_KEY_KP_9; ++n) {
349  cl = g_cclosure_new(G_CALLBACK(on_keyboard_preset_select), (gpointer)this, 0);
350  gtk_accel_group_connect(ag->gobj(), n, (GdkModifierType)0, (GtkAccelFlags)0, cl);
351  }
352  for (int n = GDK_KEY_A; n <= GDK_KEY_Z; ++n) {
353  cl = g_cclosure_new(G_CALLBACK(on_keyboard_preset_select), (gpointer)this, 0);
354  gtk_accel_group_connect(ag->gobj(), n, (GdkModifierType)0, (GtkAccelFlags)0, cl);
355  }
356 
357  cl = g_cclosure_new(G_CALLBACK(on_keyboard_mode_switch), (gpointer)this, 0);
358  gtk_accel_group_connect(ag->gobj(), GDK_KEY_space, (GdkModifierType)0, (GtkAccelFlags)0, cl);
359  machine.tuner_switcher_signal_display().connect(
360  sigc::mem_fun(this, &Liveplay::display));
361  machine.tuner_switcher_signal_set_state().connect(
362  sigc::mem_fun(this, &Liveplay::set_display_state));
363  machine.tuner_switcher_signal_selection_done().connect(
364  sigc::mem_fun(this, &Liveplay::on_selection_done));
365 
366  window->add_accel_group(ag);
367 
368  machine.signal_state_change().connect(
369  sigc::mem_fun(this, &Liveplay::on_engine_state_change));
370  machine.signal_selection_changed().connect(
371  sigc::mem_fun(this, &Liveplay::on_selection_changed));
372 
373  on_engine_state_change(machine.get_state());
374  on_selection_changed();
375 }
376 
378  delete window;
379 }
380 
381 bool Liveplay::pointer_motion(GdkEventMotion* event) {
382  if (event) {
383  gdk_event_request_motions(event);
384  }
385  if (mouse_hide_conn.connected()) {
386  mouse_hide_conn.disconnect();
387  } else {
388  window->get_window()->set_cursor();
389  }
390  mouse_hide_conn = Glib::signal_timeout().connect_seconds(
391  sigc::bind_return(
392  sigc::bind(
393  sigc::mem_fun1(window->get_window().operator->(), &Gdk::Window::set_cursor),
394  Gdk::Cursor(Gdk::BLANK_CURSOR)),
395  false),
396  5);
397  return false;
398 }
399 
400 void Liveplay::on_engine_state_change(gx_engine::GxEngineState state) {
401  switch (state) {
402  case gx_engine::kEngineOff: bypass_image->hide(); mute_image->show(); break;
403  case gx_engine::kEngineOn: bypass_image->hide(); mute_image->hide(); break;
404  case gx_engine::kEngineBypass: bypass_image->show(); mute_image->hide(); break;
405  }
406 }
407 
408 void Liveplay::on_selection_done(bool v) {
409  keyswitch.deactivate();
410  if (!machine.setting_is_preset()) {
411  display("----","");
412  } else {
413  display(machine.get_current_bank(), machine.get_current_name());
414  }
415  actions.livetuner->set_active(v);
416 }
417 
418 void Liveplay::on_selection_changed() {
419  keyswitch.deactivate();
420  if (!machine.setting_is_preset()) {
421  display("----","");
422  } else {
423  display(machine.get_current_bank(), machine.get_current_name());
424  }
425 }
426 
427 void Liveplay::on_live_play(Glib::RefPtr<Gtk::ToggleAction> act) {
428  if (act->get_active()) {
429  window->fullscreen();
430  midi_conn = machine.signal_midi_changed().connect(
431  sigc::mem_fun(this, &Liveplay::add_midi_elements));
432  add_midi_elements();
433  window->show();
434  } else {
435  midi_conn.disconnect();
436  keyswitch.deactivate();
437  machine.tuner_switcher_deactivate();
438  window->hide();
439  }
440  actions.livetuner->toggled();
441 }
442 
443 bool Liveplay::window_expose_event(GdkEventExpose *event) {
444  Cairo::RefPtr<Cairo::Context> cr = Glib::wrap(event->window, true)->create_cairo_context();
445  Gtk::Allocation a = liveplay_canvas->get_allocation();
446  Gdk::Region region(a);
447  region.intersect(Glib::wrap(event->region, true));
448  Gdk::Cairo::add_region_to_path(cr, region);
449  cr->clip();
450  cr->set_operator(Cairo::OPERATOR_SOURCE);
451  cr->set_source_rgb(0,0,0);
452  cr->paint();
453  //gdk_cairo_set_source_window(cr->cobj(), liveplay_canvas->get_window()->gobj(), a.get_x(), a.get_y()); gtk 2.24
454  gdk_cairo_set_source_pixmap(cr->cobj(), liveplay_canvas->get_window()->gobj(), a.get_x(), a.get_y());
455  cr->paint_with_alpha(pow(brightness_adj->get_value(),2.2));
456  return false;
457 }
458 
459 bool Liveplay::on_delete(GdkEventAny *ev) {
460  liveplay_exit->set_active(false);
461  return true;
462 }
463 
464 void Liveplay::on_brightness_changed() {
465  window->queue_draw();
466 }
467 
468 void Liveplay::on_background_changed() {
469  window->queue_draw();
470 }
471 
473  tuner->set_sensitive(v);
474  tuner->set_visible(v);
475 }
476 
477 void Liveplay::on_realize() {
478  liveplay_canvas->get_window()->set_composited(true);
479 }
480 
481 class MidiControllerDisplay: public Gtk::ProgressBar {
482 private:
483  int ctr;
484 private:
485  void midi_value_changed(int ctr, int val);
486 public:
487  MidiControllerDisplay(gx_engine::GxMachineBase& machine, unsigned int n, const gx_engine::midi_controller_list& ctrl, const Glib::ustring& name);
489 };
490 
491 MidiControllerDisplay::MidiControllerDisplay(gx_engine::GxMachineBase& machine, unsigned int n, const gx_engine::midi_controller_list& ctrl, const Glib::ustring& name)
492  : Gtk::ProgressBar(), ctr(n) {
493  machine.signal_midi_value_changed().connect(
494  sigc::mem_fun(this, &MidiControllerDisplay::midi_value_changed));
495  set_size_request(300, 50);
496  set_text(name);
497  machine.request_midi_value_update();
498 }
499 
501 }
502 
503 void MidiControllerDisplay::midi_value_changed(int c, int v) {
504  if (c != ctr) {
505  return;
506  }
507  if (v >= 0) {
508  set_sensitive(true);
509  set_fraction(v / 127.0);
510  } else {
511  set_sensitive(false);
512  }
513 }
514 
515 void Liveplay::add_midi_elements() {
516  int left = 0;
517  int top = 0;
518  int top_max = 3;
519  int left_max = 3;
520  Gtk::Table::TableList& tl = midictrl_table->children();
521  tl.erase(tl.begin(), tl.end());
522  for (int i = 0; i < machine.midi_size(); i++) {
523  gx_engine::midi_controller_list& cl = machine.midi_get(i);
524  if (cl.empty()) {
525  continue;
526  }
527  std::string v = gx_engine::midi_std_ctr[i];
528  if (v.empty()) {
529  v = Glib::ustring::compose("%1: ", i);
530  }
531  for (gx_engine::midi_controller_list::iterator j = cl.begin(); j != cl.end(); ++j) {
532  gx_engine::Parameter& p = j->getParameter();
533  v += Glib::ustring::compose(" %1/%2", p.l_group(), p.l_name());
534  }
535  midictrl_table->attach(
536  *manage(new MidiControllerDisplay(machine, i, cl, v)),
537  left, left+1, top, top+1, Gtk::AttachOptions(0));
538  top += 1;
539  if (top >= top_max) {
540  top = 0;
541  left += 1;
542  }
543  if (left >= left_max) {
544  break;
545  }
546  }
547  midictrl_table->show_all();
548 }
#define GDK_KEY_B
Definition: guitarix.h:51
virtual GxEngineState get_state()=0
void deactivate()
Definition: liveplay.cpp:30
#define GDK_KEY_M
Definition: guitarix.h:58
#define GDK_KEY_Escape
Definition: guitarix.h:53
MidiStandardControllers midi_std_ctr
virtual sigc::signal< void, GxEngineState > & signal_state_change()=0
virtual sigc::signal< void, TunerSwitcher::SwitcherState > & tuner_switcher_signal_set_state()=0
#define GDK_KEY_Z
Definition: guitarix.h:64
#define GDK_KEY_9
Definition: guitarix.h:48
#define GDK_KEY_A
Definition: guitarix.h:50
virtual int bank_size()=0
Glib::RefPtr< UiBoolToggleAction > livetuner
virtual gx_system::PresetFileGui * get_bank_file(const Glib::ustring &bank) const =0
#define GDK_KEY_Left
Definition: guitarix.h:57
virtual bool on_expose_event(GdkEventExpose *event)
Definition: liveplay.cpp:223
virtual Glib::ustring get_bank_name(int n)=0
bool process_bank_key(int idx)
Definition: liveplay.cpp:91
MidiControllerDisplay(gx_engine::GxMachineBase &machine, unsigned int n, const gx_engine::midi_controller_list &ctrl, const Glib::ustring &name)
Definition: liveplay.cpp:491
virtual bool setting_is_preset()=0
std::string get_style_filepath(const std::string &basename) const
Definition: gx_system.h:461
#define GDK_KEY_Down
Definition: guitarix.h:52
static MyPaintBox * create_from_builder(BaseObjectType *cobject, Gtk::Adjustment *background_adj)
Definition: liveplay.cpp:218
void gx_print_error(const char *, const std::string &)
Definition: gx_logging.cpp:166
#define GDK_KEY_0
Definition: guitarix.h:46
virtual const Glib::ustring & get_current_bank()=0
string l_group() const
Definition: gx_parameter.h:175
#define GDK_KEY_Up
Definition: guitarix.h:62
string l_name() const
Definition: gx_parameter.h:177
Glib::RefPtr< Gtk::Action > quit
virtual sigc::signal< void > & signal_midi_changed()=0
virtual void tuner_switcher_deactivate()=0
virtual sigc::signal< void > & signal_selection_changed()=0
std::string to_string(const T &t)
Definition: gx_system.h:525
bool process_preset_key(int idx)
Definition: liveplay.cpp:71
Glib::RefPtr< Gtk::ToggleAction > live_play
virtual void load_preset(gx_system::PresetFileGui *pf, const Glib::ustring &name)=0
Liveplay(const gx_system::CmdlineOptions &options, gx_engine::GxMachineBase &machine, const std::string &fname, const GxActions &actions)
Definition: liveplay.cpp:235
list< MidiController > midi_controller_list
Definition: gx_parameter.h:698
#define GDK_KEY_space
Definition: guitarix.h:61
#define GDK_KEY_z
Definition: guitarix.h:63
virtual sigc::signal< void, const Glib::ustring &, const Glib::ustring & > & tuner_switcher_signal_display()=0
void display_tuner(bool v)
Definition: liveplay.cpp:472
Gxw::BigKnob * wrap(GxBigKnob *object, bool take_copy)
Definition: bigknob.cc:44
virtual sigc::signal< void, bool > & tuner_switcher_signal_selection_done()=0
#define GDK_KEY_KP_9
Definition: guitarix.h:56
const Glib::ustring & get_name(int n)
Definition: gx_json.cpp:1129
virtual const Glib::ustring & get_current_name()=0
GxPaintBox BaseObjectType
Definition: paintbox.h:47
void on_live_play(Glib::RefPtr< Gtk::ToggleAction > act)
Definition: liveplay.cpp:427
#define GDK_KEY_a
Definition: guitarix.h:49
virtual sigc::signal< void, int, int > & signal_midi_value_changed()=0
#define GDK_KEY_Right
Definition: guitarix.h:60
virtual void request_midi_value_update()=0
#define GDK_KEY_KP_0
Definition: guitarix.h:54
#define GDK_KEY_Return
Definition: guitarix.h:59
void display_key_error()
Definition: liveplay.cpp:38