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_KP_0) {
123  self.keyswitch.process_preset_key(9);
124  return true;
125  }
126  if (keyval >= GDK_KEY_1 && keyval <= GDK_KEY_9) {
127  self.keyswitch.process_preset_key(keyval - GDK_KEY_1);
128  return true;
129  }
130  if (keyval >= GDK_KEY_KP_1 && keyval <= GDK_KEY_KP_9) {
131  self.keyswitch.process_preset_key(keyval - GDK_KEY_KP_1);
132  return true;
133  }
134  if (keyval >= GDK_KEY_a && keyval <= GDK_KEY_z) {
135  self.keyswitch.process_bank_key(keyval - GDK_KEY_a);
136  return true;
137  }
138  self.keyswitch.display_key_error();
139  return true;
140 }
141 
142 bool Liveplay::on_keyboard_toggle_mute(GtkAccelGroup *accel_group, GObject *acceleratable,
143  guint keyval, GdkModifierType modifier, Liveplay& self) {
144  self.machine.set_state(self.machine.get_state() == gx_engine::kEngineOff ?
147  return true;
148 }
149 
150 bool Liveplay::on_keyboard_toggle_bypass(GtkAccelGroup *accel_group, GObject *acceleratable,
151  guint keyval, GdkModifierType modifier, Liveplay& self) {
152  self.machine.set_state(self.machine.get_state() == gx_engine::kEngineBypass ?
155  return true;
156 }
157 
158 bool Liveplay::on_keyboard_mode_switch(GtkAccelGroup *accel_group, GObject *acceleratable,
159  guint keyval, GdkModifierType modifier, Liveplay& self) {
160  self.machine.tuner_switcher_toggle(self.actions.livetuner->get_active());
161  return true;
162 }
163 
164 void Liveplay::set_display_state(TunerSwitcher::SwitcherState newstate) {
165  bool sens = true;
166  Gtk::StateType st = Gtk::STATE_NORMAL;
167  switch (newstate) {
169  break;
171  sens = false;
172  st = Gtk::STATE_SELECTED;
173  break;
175  st = Gtk::STATE_SELECTED;
176  break;
178  st = Gtk::STATE_PRELIGHT;
179  break;
180  default:
181  assert(false);
182  break;
183  }
184  liveplay_bank->set_sensitive(sens);
185  liveplay_bank->set_state(st);
186  liveplay_preset->set_sensitive(sens);
187  liveplay_preset->set_state(st);
188 }
189 
190 bool Liveplay::on_keyboard_arrows(GtkAccelGroup *accel_group, GObject *acceleratable,
191  guint keyval, GdkModifierType modifier, Liveplay& self) {
192  if (keyval == GDK_KEY_Left || keyval == GDK_KEY_Right) {
193  Gtk::Adjustment *a = self.brightness_slider->get_adjustment();
194  double val = a->get_value();
195  double step = a->get_step_increment();
196  if (keyval == GDK_KEY_Left) {
197  val -= step;
198  } else {
199  val += step;
200  }
201  a->set_value(val);
202  } else {
203  Gtk::Adjustment *a = self.background_slider->get_adjustment();
204  double val = a->get_value();
205  double step = a->get_step_increment();
206  if (keyval == GDK_KEY_Down) {
207  val -= step;
208  } else {
209  val += step;
210  }
211  a->set_value(val);
212  }
213  return true;
214 }
215 
216 class MyPaintBox: public Gxw::PaintBox {
217 private:
218  Gtk::Adjustment *background_adj;
219  MyPaintBox(BaseObjectType* cobject, Gtk::Adjustment *background_adj_)
220  : Gxw::PaintBox(cobject), background_adj(background_adj_) {}
221 public:
222  static MyPaintBox *create_from_builder(BaseObjectType* cobject, Gtk::Adjustment *background_adj) {
223  return new MyPaintBox(cobject, background_adj); }
224  virtual bool on_expose_event(GdkEventExpose *event);
225 };
226 
227 bool MyPaintBox::on_expose_event(GdkEventExpose *event) {
228  call_paint_func(event);
229  Cairo::RefPtr<Cairo::Context> cr = Glib::wrap(event->window, true)->create_cairo_context();
230  gdk_cairo_region(cr->cobj(), event->region);
231  cr->clip();
232  cr->set_source_rgba(0.0, 0.0, 0.0, 1-background_adj->get_value());
233  cr->paint();
234  foreach(sigc::bind(sigc::mem_fun(this, &MyPaintBox::propagate_expose), event));
235  return true;
236 }
237 
238 
240  const gx_system::CmdlineOptions& options, gx_engine::GxMachineBase& machine_,
241  const std::string& fname, const GxActions& actions_)
242  : bld(),
243  machine(machine_),
244  actions(actions_),
245  use_composite(),
246  brightness_adj(),
247  background_adj(),
248  keyswitch(machine_, sigc::mem_fun(this, &Liveplay::display)),
249  midi_conn(),
250  window(),
251  mouse_hide_conn() {
252  const char *id_list[] = {"LivePlay", 0};
253  bld = gx_gui::GxBuilder::create_from_file(fname, &machine, id_list);
254  bld->get_toplevel("LivePlay", window);
255 
256  bld->find_widget("liveplay_bank", liveplay_bank);
257  bld->find_widget("liveplay_preset", liveplay_preset);
258  bld->find_widget("liveplay_bypass_image", bypass_image);
259  bld->find_widget("liveplay_mute_image", mute_image);
260  bld->find_widget("liveplay_canvas", liveplay_canvas);
261  bld->find_widget("brightness_slider", brightness_slider);
262  bld->find_widget("brightness_box", brightness_box);
263  bld->find_widget("background_slider", background_slider);
264  bld->find_widget("liveplay_exit:barbutton", liveplay_exit);
265  bld->find_widget("liveplay_tuner", tuner);
266  bld->find_widget("liveplay_midictrl_table", midictrl_table);
267  brightness_adj = brightness_slider->get_adjustment();
268  background_adj = background_slider->get_adjustment();
269  MyPaintBox *liveplay_paintbox;
270  bld->find_widget_derived(
271  "liveplay_paintbox", liveplay_paintbox,
272  sigc::bind(
273  sigc::ptr_fun(MyPaintBox::create_from_builder),
274  background_adj));
275  Glib::RefPtr<Gdk::Pixbuf> pb;
276  try {
277  pb = Gdk::Pixbuf::create_from_file(
278  options.get_style_filepath("live_bypass.png"));
279  bypass_image->set(pb);
280  } catch (const Glib::FileError& ex) {
281  gx_print_error("liveplay", ex.what());
282  } catch (const Gdk::PixbufError& ex) {
283  gx_print_error("liveplay", ex.what());
284  } catch(...) {
285  gx_print_error("liveplay", "failed to load pixmap live_bypass.png");
286  }
287  try {
288  pb = Gdk::Pixbuf::create_from_file(
289  options.get_style_filepath("live_mute.png"));
290  mute_image->set(pb);
291  } catch (const Glib::FileError& ex) {
292  gx_print_error("liveplay", ex.what());
293  } catch (const Gdk::PixbufError& ex) {
294  gx_print_error("liveplay", ex.what());
295  } catch(...) {
296  gx_print_error("liveplay", "failed to load pixmap live_mute.png");
297  }
298  use_composite = window->get_display()->supports_composite();
299  if (use_composite) {
300  brightness_adj->signal_value_changed().connect(sigc::mem_fun(this, &Liveplay::on_brightness_changed));
301  liveplay_canvas->signal_realize().connect(sigc::mem_fun(this, &Liveplay::on_realize));
302  window->signal_expose_event().connect(
303  sigc::mem_fun(this, &Liveplay::window_expose_event), true);
304  } else {
305  brightness_box->hide();
306  }
307  background_adj->signal_value_changed().connect(
308  sigc::mem_fun(this, &Liveplay::on_background_changed));
309  Glib::RefPtr<Gdk::Screen> screen = liveplay_canvas->get_screen();
310  Glib::RefPtr<Gdk::Colormap> rgba = screen->get_rgba_colormap();
311  liveplay_canvas->set_colormap(rgba);
312  liveplay_canvas->set_app_paintable(true);
313  window->signal_delete_event().connect(
314  sigc::mem_fun(this, &Liveplay::on_delete));
315  window->add_events(Gdk::POINTER_MOTION_HINT_MASK|Gdk::POINTER_MOTION_MASK);
316  window->signal_motion_notify_event().connect(
317  sigc::mem_fun(*this, &Liveplay::pointer_motion));
318 
319  gtk_activatable_set_related_action(
320  GTK_ACTIVATABLE(liveplay_exit->gobj()), GTK_ACTION(actions.live_play->gobj()));
321  Glib::RefPtr<Gtk::AccelGroup> ag = Gtk::AccelGroup::create();
322  GClosure *cl = g_cclosure_new(G_CALLBACK(do_action), (gpointer)(actions.live_play->gobj()), 0);
323  gtk_accel_group_connect_by_path(ag->gobj(), actions.live_play->get_accel_path().c_str(), cl);
324  cl = g_cclosure_new(G_CALLBACK(do_action), (gpointer)(actions.live_play->gobj()), 0);
325  gtk_accel_group_connect(ag->gobj(), GDK_KEY_Escape, (GdkModifierType)0, (GtkAccelFlags)0, cl);
326 
327  cl = g_cclosure_new(G_CALLBACK(do_action), (gpointer)(actions.livetuner->gobj()), 0);
328  gtk_accel_group_connect(ag->gobj(), GDK_KEY_Return, (GdkModifierType)0, (GtkAccelFlags)0, cl);
329 
330  cl = g_cclosure_new(G_CALLBACK(do_action), (gpointer)(actions.quit->gobj()), 0);
331  gtk_accel_group_connect_by_path(ag->gobj(), actions.quit->get_accel_path().c_str(), cl);
332 
333  cl = g_cclosure_new(G_CALLBACK(on_keyboard_toggle_mute), (gpointer)this, 0);
334  gtk_accel_group_connect(ag->gobj(), GDK_KEY_M, GDK_CONTROL_MASK, (GtkAccelFlags)0, cl);
335 
336  cl = g_cclosure_new(G_CALLBACK(on_keyboard_toggle_bypass), (gpointer)this, 0);
337  gtk_accel_group_connect(ag->gobj(), GDK_KEY_B, GDK_CONTROL_MASK, (GtkAccelFlags)0, cl);
338 
339  cl = g_cclosure_new(G_CALLBACK(on_keyboard_arrows), (gpointer)this, 0);
340  gtk_accel_group_connect(ag->gobj(), GDK_KEY_Left, 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_Right, GDK_CONTROL_MASK, (GtkAccelFlags)0, cl);
343  cl = g_cclosure_new(G_CALLBACK(on_keyboard_arrows), (gpointer)this, 0);
344  gtk_accel_group_connect(ag->gobj(), GDK_KEY_Up, GDK_CONTROL_MASK, (GtkAccelFlags)0, cl);
345  cl = g_cclosure_new(G_CALLBACK(on_keyboard_arrows), (gpointer)this, 0);
346  gtk_accel_group_connect(ag->gobj(), GDK_KEY_Down, GDK_CONTROL_MASK, (GtkAccelFlags)0, cl);
347 
348  for (int n = GDK_KEY_0; n <= GDK_KEY_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_KP_0; n <= GDK_KEY_KP_9; ++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  for (int n = GDK_KEY_A; n <= GDK_KEY_Z; ++n) {
357  cl = g_cclosure_new(G_CALLBACK(on_keyboard_preset_select), (gpointer)this, 0);
358  gtk_accel_group_connect(ag->gobj(), n, (GdkModifierType)0, (GtkAccelFlags)0, cl);
359  }
360 
361  cl = g_cclosure_new(G_CALLBACK(on_keyboard_mode_switch), (gpointer)this, 0);
362  gtk_accel_group_connect(ag->gobj(), GDK_KEY_space, (GdkModifierType)0, (GtkAccelFlags)0, cl);
363  machine.tuner_switcher_signal_display().connect(
364  sigc::mem_fun(this, &Liveplay::display));
365  machine.tuner_switcher_signal_set_state().connect(
366  sigc::mem_fun(this, &Liveplay::set_display_state));
367  machine.tuner_switcher_signal_selection_done().connect(
368  sigc::mem_fun(this, &Liveplay::on_selection_done));
369 
370  window->add_accel_group(ag);
371 
372  machine.signal_state_change().connect(
373  sigc::mem_fun(this, &Liveplay::on_engine_state_change));
374  machine.signal_selection_changed().connect(
375  sigc::mem_fun(this, &Liveplay::on_selection_changed));
376 
377  on_engine_state_change(machine.get_state());
378  on_selection_changed();
379 }
380 
382  delete window;
383 }
384 
385 bool Liveplay::pointer_motion(GdkEventMotion* event) {
386  if (event) {
387  gdk_event_request_motions(event);
388  }
389  if (mouse_hide_conn.connected()) {
390  mouse_hide_conn.disconnect();
391  } else {
392  window->get_window()->set_cursor();
393  }
394  mouse_hide_conn = Glib::signal_timeout().connect_seconds(
395  sigc::bind_return(
396  sigc::bind(
397  sigc::mem_fun1(window->get_window().operator->(), &Gdk::Window::set_cursor),
398  Gdk::Cursor(Gdk::BLANK_CURSOR)),
399  false),
400  5);
401  return false;
402 }
403 
404 void Liveplay::on_engine_state_change(gx_engine::GxEngineState state) {
405  switch (state) {
406  case gx_engine::kEngineOff: bypass_image->hide(); mute_image->show(); break;
407  case gx_engine::kEngineOn: bypass_image->hide(); mute_image->hide(); break;
408  case gx_engine::kEngineBypass: bypass_image->show(); mute_image->hide(); break;
409  }
410 }
411 
412 void Liveplay::on_selection_done(bool v) {
413  keyswitch.deactivate();
414  if (!machine.setting_is_preset()) {
415  display("----","");
416  } else {
417  display(machine.get_current_bank(), machine.get_current_name());
418  }
419  actions.livetuner->set_active(v);
420 }
421 
422 void Liveplay::on_selection_changed() {
423  keyswitch.deactivate();
424  if (!machine.setting_is_preset()) {
425  display("----","");
426  } else {
427  display(machine.get_current_bank(), machine.get_current_name());
428  }
429 }
430 
431 void Liveplay::on_live_play(Glib::RefPtr<Gtk::ToggleAction> act) {
432  if (act->get_active()) {
433  window->fullscreen();
434  midi_conn = machine.signal_midi_changed().connect(
435  sigc::mem_fun(this, &Liveplay::add_midi_elements));
436  add_midi_elements();
437  window->show();
438  } else {
439  midi_conn.disconnect();
440  keyswitch.deactivate();
441  machine.tuner_switcher_deactivate();
442  window->hide();
443  }
444  actions.livetuner->toggled();
445 }
446 
447 bool Liveplay::window_expose_event(GdkEventExpose *event) {
448  Cairo::RefPtr<Cairo::Context> cr = Glib::wrap(event->window, true)->create_cairo_context();
449  Gtk::Allocation a = liveplay_canvas->get_allocation();
450  Gdk::Region region(a);
451  region.intersect(Glib::wrap(event->region, true));
452  Gdk::Cairo::add_region_to_path(cr, region);
453  cr->clip();
454  cr->set_operator(Cairo::OPERATOR_SOURCE);
455  cr->set_source_rgb(0,0,0);
456  cr->paint();
457  //gdk_cairo_set_source_window(cr->cobj(), liveplay_canvas->get_window()->gobj(), a.get_x(), a.get_y()); gtk 2.24
458  gdk_cairo_set_source_pixmap(cr->cobj(), liveplay_canvas->get_window()->gobj(), a.get_x(), a.get_y());
459  cr->paint_with_alpha(pow(brightness_adj->get_value(),2.2));
460  return false;
461 }
462 
463 bool Liveplay::on_delete(GdkEventAny *ev) {
464  liveplay_exit->set_active(false);
465  return true;
466 }
467 
468 void Liveplay::on_brightness_changed() {
469  window->queue_draw();
470 }
471 
472 void Liveplay::on_background_changed() {
473  window->queue_draw();
474 }
475 
477  tuner->set_sensitive(v);
478  tuner->set_visible(v);
479 }
480 
481 void Liveplay::on_realize() {
482  liveplay_canvas->get_window()->set_composited(true);
483 }
484 
485 class MidiControllerDisplay: public Gtk::ProgressBar {
486 private:
487  int ctr;
488 private:
489  void midi_value_changed(int ctr, int val);
490 public:
491  MidiControllerDisplay(gx_engine::GxMachineBase& machine, unsigned int n, const gx_engine::midi_controller_list& ctrl, const Glib::ustring& name);
493 };
494 
495 MidiControllerDisplay::MidiControllerDisplay(gx_engine::GxMachineBase& machine, unsigned int n, const gx_engine::midi_controller_list& ctrl, const Glib::ustring& name)
496  : Gtk::ProgressBar(), ctr(n) {
497  machine.signal_midi_value_changed().connect(
498  sigc::mem_fun(this, &MidiControllerDisplay::midi_value_changed));
499  set_size_request(300, 50);
500  set_text(name);
501  machine.request_midi_value_update();
502 }
503 
505 }
506 
507 void MidiControllerDisplay::midi_value_changed(int c, int v) {
508  if (c != ctr) {
509  return;
510  }
511  if (v >= 0) {
512  set_sensitive(true);
513  set_fraction(v / 127.0);
514  } else {
515  set_sensitive(false);
516  }
517 }
518 
519 void Liveplay::add_midi_elements() {
520  int left = 0;
521  int top = 0;
522  int top_max = 3;
523  int left_max = 3;
524  Gtk::Table::TableList& tl = midictrl_table->children();
525  tl.erase(tl.begin(), tl.end());
526  for (int i = 0; i < machine.midi_size(); i++) {
527  gx_engine::midi_controller_list& cl = machine.midi_get(i);
528  if (cl.empty()) {
529  continue;
530  }
531  std::string v = gx_engine::midi_std_ctr[i];
532  if (v.empty()) {
533  v = Glib::ustring::compose("%1: ", i);
534  }
535  for (gx_engine::midi_controller_list::iterator j = cl.begin(); j != cl.end(); ++j) {
536  gx_engine::Parameter& p = j->getParameter();
537  v += Glib::ustring::compose(" %1/%2", p.l_group(), p.l_name());
538  }
539  midictrl_table->attach(
540  *manage(new MidiControllerDisplay(machine, i, cl, v)),
541  left, left+1, top, top+1, Gtk::AttachOptions(0));
542  top += 1;
543  if (top >= top_max) {
544  top = 0;
545  left += 1;
546  }
547  if (left >= left_max) {
548  break;
549  }
550  }
551  midictrl_table->show_all();
552 }
#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
#define GDK_KEY_KP_1
Definition: guitarix.h:55
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:227
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:495
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:222
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:173
#define GDK_KEY_Up
Definition: guitarix.h:62
string l_name() const
Definition: gx_parameter.h:175
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:523
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:239
#define GDK_KEY_1
Definition: guitarix.h:47
list< MidiController > midi_controller_list
Definition: gx_parameter.h:692
#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:476
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:431
#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