2 Copyright (C) 2010 Paul Davis
4 This program is free software; you can redistribute it and/or modify
5 it under the terms of the GNU General Public License as published by
6 the Free Software Foundation; either version 2 of the License, or
7 (at your option) any later version.
9 This program is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 GNU General Public License for more details.
14 You should have received a copy of the GNU General Public License
15 along with this program; if not, write to the Free Software
16 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
22 #include "pbd/file_utils.h"
24 #include "gtkmm2ext/keyboard.h"
25 #include "gtkmm2ext/actions.h"
26 #include "gtkmm2ext/bindings.h"
28 #include "ardour/filesystem_paths.h"
30 #include "ardour_ui.h"
31 #include "midi_channel_selector.h"
32 #include "midi_time_axis.h"
33 #include "step_editor.h"
34 #include "step_entry.h"
46 using namespace Gtkmm2ext;
48 using namespace ARDOUR;
51 _note_off_event_handler (GtkWidget* /*widget*/, int note, gpointer arg)
53 ((StepEntry*)arg)->note_off_event_handler (note);
57 _rest_event_handler (GtkWidget* /*widget*/, gpointer arg)
59 ((StepEntry*)arg)->rest_event_handler ();
62 StepEntry::StepEntry (StepEditor& seditor)
63 : ArdourWindow (string_compose (_("Step Entry: %1"), seditor.name()))
64 , _current_note_length (1.0)
65 , _current_note_velocity (64)
66 , triplet_button ("3")
67 , dot_adjustment (0.0, 0.0, 3.0, 1.0, 1.0)
68 , beat_resync_button (_(">beat"))
69 , bar_resync_button (_(">bar"))
70 , resync_button (_(">EP"))
71 , sustain_button (_("sustain"))
72 , rest_button (_("rest"))
73 , grid_rest_button (_("g-rest"))
74 , back_button (_("back"))
75 , channel_adjustment (1, 1, 16, 1, 4)
76 , channel_spinner (channel_adjustment)
77 , octave_adjustment (4, 0, 10, 1, 4) // start in octave 4
78 , octave_spinner (octave_adjustment)
79 , length_divisor_adjustment (1.0, 1.0, 128, 1.0, 4.0)
80 , length_divisor_spinner (length_divisor_adjustment)
81 , velocity_adjustment (64.0, 0.0, 127.0, 1.0, 4.0)
82 , velocity_spinner (velocity_adjustment)
83 , bank_adjustment (0, 0.0, 127.0, 1.0, 4.0)
84 , bank_spinner (bank_adjustment)
85 , bank_button (_("+"))
86 , program_adjustment (0, 0.0, 127.0, 1.0, 4.0)
87 , program_spinner (program_adjustment)
88 , program_button (_("+"))
97 /* set channel selector to first selected channel. if none
98 are selected, it will remain at the value set in its
99 constructor, above (1)
102 uint16_t chn_mask = se->channel_selector().get_selected_channels();
104 for (uint32_t i = 0; i < 16; ++i) {
105 if (chn_mask & (1<<i)) {
106 channel_adjustment.set_value (i+1);
113 RadioButtonGroup length_group = length_1_button.get_group();
114 length_2_button.set_group (length_group);
115 length_4_button.set_group (length_group);
116 length_8_button.set_group (length_group);
117 length_12_button.set_group (length_group);
118 length_16_button.set_group (length_group);
119 length_32_button.set_group (length_group);
120 length_64_button.set_group (length_group);
124 w = manage (new Image (::get_icon (X_("wholenote"))));
126 length_1_button.add (*w);
127 w = manage (new Image (::get_icon (X_("halfnote"))));
129 length_2_button.add (*w);
130 w = manage (new Image (::get_icon (X_("quarternote"))));
132 length_4_button.add (*w);
133 w = manage (new Image (::get_icon (X_("eighthnote"))));
135 length_8_button.add (*w);
136 w = manage (new Image (::get_icon (X_("sixteenthnote"))));
138 length_16_button.add (*w);
139 w = manage (new Image (::get_icon (X_("thirtysecondnote"))));
141 length_32_button.add (*w);
142 w = manage (new Image (::get_icon (X_("sixtyfourthnote"))));
144 length_64_button.add (*w);
148 act = myactions.find_action ("StepEditing/note-length-whole");
149 gtk_activatable_set_related_action (GTK_ACTIVATABLE (length_1_button.gobj()), act->gobj());
150 act = myactions.find_action ("StepEditing/note-length-half");
151 gtk_activatable_set_related_action (GTK_ACTIVATABLE (length_2_button.gobj()), act->gobj());
152 act = myactions.find_action ("StepEditing/note-length-quarter");
153 gtk_activatable_set_related_action (GTK_ACTIVATABLE (length_4_button.gobj()), act->gobj());
154 act = myactions.find_action ("StepEditing/note-length-eighth");
155 gtk_activatable_set_related_action (GTK_ACTIVATABLE (length_8_button.gobj()), act->gobj());
156 act = myactions.find_action ("StepEditing/note-length-sixteenth");
157 gtk_activatable_set_related_action (GTK_ACTIVATABLE (length_16_button.gobj()), act->gobj());
158 act = myactions.find_action ("StepEditing/note-length-thirtysecond");
159 gtk_activatable_set_related_action (GTK_ACTIVATABLE (length_32_button.gobj()), act->gobj());
160 act = myactions.find_action ("StepEditing/note-length-sixtyfourth");
161 gtk_activatable_set_related_action (GTK_ACTIVATABLE (length_64_button.gobj()), act->gobj());
163 length_1_button.signal_button_press_event().connect (sigc::mem_fun (*this, &StepEntry::radio_button_press), false);
164 length_1_button.signal_button_release_event().connect (sigc::bind (sigc::mem_fun (*this, &StepEntry::radio_button_release), &length_1_button, 1), false);
165 length_2_button.signal_button_press_event().connect (sigc::mem_fun (*this, &StepEntry::radio_button_press), false);
166 length_2_button.signal_button_release_event().connect (sigc::bind (sigc::mem_fun (*this, &StepEntry::radio_button_release), &length_1_button, 2), false);
167 length_4_button.signal_button_press_event().connect (sigc::mem_fun (*this, &StepEntry::radio_button_press), false);
168 length_4_button.signal_button_release_event().connect (sigc::bind (sigc::mem_fun (*this, &StepEntry::radio_button_release), &length_1_button, 4), false);
169 length_8_button.signal_button_press_event().connect (sigc::mem_fun (*this, &StepEntry::radio_button_press), false);
170 length_8_button.signal_button_release_event().connect (sigc::bind (sigc::mem_fun (*this, &StepEntry::radio_button_release), &length_1_button, 8), false);
171 length_16_button.signal_button_press_event().connect (sigc::mem_fun (*this, &StepEntry::radio_button_press), false);
172 length_16_button.signal_button_release_event().connect (sigc::bind (sigc::mem_fun (*this, &StepEntry::radio_button_release), &length_1_button, 16), false);
173 length_32_button.signal_button_press_event().connect (sigc::mem_fun (*this, &StepEntry::radio_button_press), false);
174 length_32_button.signal_button_release_event().connect (sigc::bind (sigc::mem_fun (*this, &StepEntry::radio_button_release), &length_1_button, 32), false);
175 length_64_button.signal_button_press_event().connect (sigc::mem_fun (*this, &StepEntry::radio_button_press), false);
176 length_64_button.signal_button_release_event().connect (sigc::bind (sigc::mem_fun (*this, &StepEntry::radio_button_release), &length_1_button, 64), false);
178 length_1_button.property_draw_indicator() = false;
179 length_2_button.property_draw_indicator() = false;
180 length_4_button.property_draw_indicator() = false;
181 length_8_button.property_draw_indicator() = false;
182 length_16_button.property_draw_indicator() = false;
183 length_32_button.property_draw_indicator() = false;
184 length_64_button.property_draw_indicator() = false;
186 note_length_box.pack_start (length_1_button, false, false);
187 note_length_box.pack_start (length_2_button, false, false);
188 note_length_box.pack_start (length_4_button, false, false);
189 note_length_box.pack_start (length_8_button, false, false);
190 note_length_box.pack_start (length_16_button, false, false);
191 note_length_box.pack_start (length_32_button, false, false);
192 note_length_box.pack_start (length_64_button, false, false);
194 ARDOUR_UI::instance()->set_tip (&length_1_button, _("Set note length to a whole note"), "");
195 ARDOUR_UI::instance()->set_tip (&length_2_button, _("Set note length to a half note"), "");
196 ARDOUR_UI::instance()->set_tip (&length_4_button, _("Set note length to a quarter note"), "");
197 ARDOUR_UI::instance()->set_tip (&length_8_button, _("Set note length to a eighth note"), "");
198 ARDOUR_UI::instance()->set_tip (&length_16_button, _("Set note length to a sixteenth note"), "");
199 ARDOUR_UI::instance()->set_tip (&length_32_button, _("Set note length to a thirty-second note"), "");
200 ARDOUR_UI::instance()->set_tip (&length_64_button, _("Set note length to a sixty-fourth note"), "");
202 RadioButtonGroup velocity_group = velocity_ppp_button.get_group();
203 velocity_pp_button.set_group (velocity_group);
204 velocity_p_button.set_group (velocity_group);
205 velocity_mp_button.set_group (velocity_group);
206 velocity_mf_button.set_group (velocity_group);
207 velocity_f_button.set_group (velocity_group);
208 velocity_ff_button.set_group (velocity_group);
209 velocity_fff_button.set_group (velocity_group);
211 w = manage (new Image (::get_icon (X_("pianississimo"))));
213 velocity_ppp_button.add (*w);
214 w = manage (new Image (::get_icon (X_("pianissimo"))));
216 velocity_pp_button.add (*w);
217 w = manage (new Image (::get_icon (X_("piano"))));
219 velocity_p_button.add (*w);
220 w = manage (new Image (::get_icon (X_("mezzopiano"))));
222 velocity_mp_button.add (*w);
223 w = manage (new Image (::get_icon (X_("mezzoforte"))));
225 velocity_mf_button.add (*w);
226 w = manage (new Image (::get_icon (X_("forte"))));
228 velocity_f_button.add (*w);
229 w = manage (new Image (::get_icon (X_("fortissimo"))));
231 velocity_ff_button.add (*w);
232 w = manage (new Image (::get_icon (X_("fortississimo"))));
234 velocity_fff_button.add (*w);
236 act = myactions.find_action ("StepEditing/note-velocity-ppp");
237 gtk_activatable_set_related_action (GTK_ACTIVATABLE (velocity_ppp_button.gobj()), act->gobj());
238 act = myactions.find_action ("StepEditing/note-velocity-pp");
239 gtk_activatable_set_related_action (GTK_ACTIVATABLE (velocity_pp_button.gobj()), act->gobj());
240 act = myactions.find_action ("StepEditing/note-velocity-p");
241 gtk_activatable_set_related_action (GTK_ACTIVATABLE (velocity_p_button.gobj()), act->gobj());
242 act = myactions.find_action ("StepEditing/note-velocity-mp");
243 gtk_activatable_set_related_action (GTK_ACTIVATABLE (velocity_mp_button.gobj()), act->gobj());
244 act = myactions.find_action ("StepEditing/note-velocity-mf");
245 gtk_activatable_set_related_action (GTK_ACTIVATABLE (velocity_mf_button.gobj()), act->gobj());
246 act = myactions.find_action ("StepEditing/note-velocity-f");
247 gtk_activatable_set_related_action (GTK_ACTIVATABLE (velocity_f_button.gobj()), act->gobj());
248 act = myactions.find_action ("StepEditing/note-velocity-ff");
249 gtk_activatable_set_related_action (GTK_ACTIVATABLE (velocity_ff_button.gobj()), act->gobj());
250 act = myactions.find_action ("StepEditing/note-velocity-fff");
251 gtk_activatable_set_related_action (GTK_ACTIVATABLE (velocity_fff_button.gobj()), act->gobj());
253 velocity_ppp_button.signal_button_press_event().connect (sigc::mem_fun (*this, &StepEntry::radio_button_press), false);
254 velocity_ppp_button.signal_button_release_event().connect (sigc::bind (sigc::mem_fun (*this, &StepEntry::radio_button_release), &velocity_ppp_button, 1), false);
255 velocity_pp_button.signal_button_press_event().connect (sigc::mem_fun (*this, &StepEntry::radio_button_press), false);
256 velocity_pp_button.signal_button_release_event().connect (sigc::bind (sigc::mem_fun (*this, &StepEntry::radio_button_release), &velocity_pp_button, 16), false);
257 velocity_p_button.signal_button_press_event().connect (sigc::mem_fun (*this, &StepEntry::radio_button_press), false);
258 velocity_p_button.signal_button_release_event().connect (sigc::bind (sigc::mem_fun (*this, &StepEntry::radio_button_release), &velocity_p_button, 32), false);
259 velocity_mp_button.signal_button_press_event().connect (sigc::mem_fun (*this, &StepEntry::radio_button_press), false);
260 velocity_mp_button.signal_button_release_event().connect (sigc::bind (sigc::mem_fun (*this, &StepEntry::radio_button_release), &velocity_mp_button, 64), false);
261 velocity_mf_button.signal_button_press_event().connect (sigc::mem_fun (*this, &StepEntry::radio_button_press), false);
262 velocity_mf_button.signal_button_release_event().connect (sigc::bind (sigc::mem_fun (*this, &StepEntry::radio_button_release), &velocity_mf_button, 80), false);
263 velocity_f_button.signal_button_press_event().connect (sigc::mem_fun (*this, &StepEntry::radio_button_press), false);
264 velocity_f_button.signal_button_release_event().connect (sigc::bind (sigc::mem_fun (*this, &StepEntry::radio_button_release), &velocity_f_button, 96), false);
265 velocity_ff_button.signal_button_press_event().connect (sigc::mem_fun (*this, &StepEntry::radio_button_press), false);
266 velocity_ff_button.signal_button_release_event().connect (sigc::bind (sigc::mem_fun (*this, &StepEntry::radio_button_release), &velocity_ff_button, 112), false);
267 velocity_fff_button.signal_button_press_event().connect (sigc::mem_fun (*this, &StepEntry::radio_button_press), false);
268 velocity_fff_button.signal_button_release_event().connect (sigc::bind (sigc::mem_fun (*this, &StepEntry::radio_button_release), &velocity_fff_button, 127), false);
270 velocity_ppp_button.property_draw_indicator() = false;
271 velocity_pp_button.property_draw_indicator() = false;
272 velocity_p_button.property_draw_indicator() = false;
273 velocity_mp_button.property_draw_indicator() = false;
274 velocity_mf_button.property_draw_indicator() = false;
275 velocity_f_button.property_draw_indicator() = false;
276 velocity_ff_button.property_draw_indicator() = false;
277 velocity_fff_button.property_draw_indicator() = false;
279 ARDOUR_UI::instance()->set_tip (&velocity_ppp_button, _("Set volume (velocity) to pianississimo"), "");
280 ARDOUR_UI::instance()->set_tip (&velocity_pp_button, _("Set volume (velocity) to pianissimo"), "");
281 ARDOUR_UI::instance()->set_tip (&velocity_p_button, _("Set volume (velocity) to piano"), "");
282 ARDOUR_UI::instance()->set_tip (&velocity_mp_button, _("Set volume (velocity) to mezzo-piano"), "");
283 ARDOUR_UI::instance()->set_tip (&velocity_mf_button, _("Set volume (velocity) to mezzo-forte"), "");
284 ARDOUR_UI::instance()->set_tip (&velocity_f_button, _("Set volume (velocity) to forte"), "");
285 ARDOUR_UI::instance()->set_tip (&velocity_ff_button, _("Set volume (velocity) to forteissimo"), "");
286 ARDOUR_UI::instance()->set_tip (&velocity_fff_button, _("Set volume (velocity) to forteississimo"), "");
288 note_velocity_box.pack_start (velocity_ppp_button, false, false);
289 note_velocity_box.pack_start (velocity_pp_button, false, false);
290 note_velocity_box.pack_start (velocity_p_button, false, false);
291 note_velocity_box.pack_start (velocity_mp_button, false, false);
292 note_velocity_box.pack_start (velocity_mf_button, false, false);
293 note_velocity_box.pack_start (velocity_f_button, false, false);
294 note_velocity_box.pack_start (velocity_ff_button, false, false);
295 note_velocity_box.pack_start (velocity_fff_button, false, false);
297 Label* l = manage (new Label);
298 l->set_markup ("<b><big>-</big></b>");
300 dot0_button.add (*l);
302 l = manage (new Label);
303 l->set_markup ("<b><big>.</big></b>");
305 dot1_button.add (*l);
307 l = manage (new Label);
308 l->set_markup ("<b><big>..</big></b>");
310 dot2_button.add (*l);
312 l = manage (new Label);
313 l->set_markup ("<b><big>...</big></b>");
315 dot3_button.add (*l);
317 w = manage (new Image (::get_icon (X_("chord"))));
319 chord_button.add (*w);
321 dot_box1.pack_start (dot0_button, true, false);
322 dot_box1.pack_start (dot1_button, true, false);
323 dot_box2.pack_start (dot2_button, true, false);
324 dot_box2.pack_start (dot3_button, true, false);
326 rest_box.pack_start (rest_button, true, false);
327 rest_box.pack_start (grid_rest_button, true, false);
328 rest_box.pack_start (back_button, true, false);
330 resync_box.pack_start (beat_resync_button, true, false);
331 resync_box.pack_start (bar_resync_button, true, false);
332 resync_box.pack_start (resync_button, true, false);
334 ARDOUR_UI::instance()->set_tip (&chord_button, _("Stack inserted notes to form a chord"), "");
335 ARDOUR_UI::instance()->set_tip (&sustain_button, _("Extend selected notes by note length"), "");
336 ARDOUR_UI::instance()->set_tip (&dot0_button, _("Use undotted note lengths"), "");
337 ARDOUR_UI::instance()->set_tip (&dot1_button, _("Use dotted (* 1.5) note lengths"), "");
338 ARDOUR_UI::instance()->set_tip (&dot2_button, _("Use double-dotted (* 1.75) note lengths"), "");
339 ARDOUR_UI::instance()->set_tip (&dot3_button, _("Use triple-dotted (* 1.875) note lengths"), "");
340 ARDOUR_UI::instance()->set_tip (&rest_button, _("Insert a note-length's rest"), "");
341 ARDOUR_UI::instance()->set_tip (&grid_rest_button, _("Insert a grid-unit's rest"), "");
342 ARDOUR_UI::instance()->set_tip (&beat_resync_button, _("Insert a rest until the next beat"), "");
343 ARDOUR_UI::instance()->set_tip (&bar_resync_button, _("Insert a rest until the next bar"), "");
344 ARDOUR_UI::instance()->set_tip (&bank_button, _("Insert a bank change message"), "");
345 ARDOUR_UI::instance()->set_tip (&program_button, _("Insert a program change message"), "");
346 ARDOUR_UI::instance()->set_tip (&back_button, _("Move Insert Position Back by Note Length"), "");
347 ARDOUR_UI::instance()->set_tip (&resync_button, _("Move Insert Position to Edit Point"), "");
349 act = myactions.find_action ("StepEditing/back");
350 gtk_activatable_set_use_action_appearance (GTK_ACTIVATABLE (back_button.gobj()), false);
351 gtk_activatable_set_related_action (GTK_ACTIVATABLE (back_button.gobj()), act->gobj());
352 act = myactions.find_action ("StepEditing/sync-to-edit-point");
353 gtk_activatable_set_use_action_appearance (GTK_ACTIVATABLE (resync_button.gobj()), false);
354 gtk_activatable_set_related_action (GTK_ACTIVATABLE (resync_button.gobj()), act->gobj());
355 act = myactions.find_action ("StepEditing/toggle-triplet");
356 gtk_activatable_set_use_action_appearance (GTK_ACTIVATABLE (triplet_button.gobj()), false);
357 gtk_activatable_set_related_action (GTK_ACTIVATABLE (triplet_button.gobj()), act->gobj());
358 act = myactions.find_action ("StepEditing/no-dotted");
359 gtk_activatable_set_use_action_appearance (GTK_ACTIVATABLE (dot0_button.gobj()), false);
360 gtk_activatable_set_related_action (GTK_ACTIVATABLE (dot0_button.gobj()), act->gobj());
361 act = myactions.find_action ("StepEditing/toggle-dotted");
362 gtk_activatable_set_use_action_appearance (GTK_ACTIVATABLE (dot1_button.gobj()), false);
363 gtk_activatable_set_related_action (GTK_ACTIVATABLE (dot1_button.gobj()), act->gobj());
364 act = myactions.find_action ("StepEditing/toggle-double-dotted");
365 gtk_activatable_set_use_action_appearance (GTK_ACTIVATABLE (dot2_button.gobj()), false);
366 gtk_activatable_set_related_action (GTK_ACTIVATABLE (dot2_button.gobj()), act->gobj());
367 act = myactions.find_action ("StepEditing/toggle-triple-dotted");
368 gtk_activatable_set_use_action_appearance (GTK_ACTIVATABLE (dot3_button.gobj()), false);
369 gtk_activatable_set_related_action (GTK_ACTIVATABLE (dot3_button.gobj()), act->gobj());
370 act = myactions.find_action ("StepEditing/toggle-chord");
371 gtk_activatable_set_use_action_appearance (GTK_ACTIVATABLE (chord_button.gobj()), false);
372 gtk_activatable_set_related_action (GTK_ACTIVATABLE (chord_button.gobj()), act->gobj());
373 act = myactions.find_action ("StepEditing/insert-rest");
374 gtk_activatable_set_use_action_appearance (GTK_ACTIVATABLE (rest_button.gobj()), false);
375 gtk_activatable_set_related_action (GTK_ACTIVATABLE (rest_button.gobj()), act->gobj());
376 act = myactions.find_action ("StepEditing/insert-snap-rest");
377 gtk_activatable_set_use_action_appearance (GTK_ACTIVATABLE (grid_rest_button.gobj()), false);
378 gtk_activatable_set_related_action (GTK_ACTIVATABLE (grid_rest_button.gobj()), act->gobj());
379 act = myactions.find_action ("StepEditing/sustain");
380 gtk_activatable_set_use_action_appearance (GTK_ACTIVATABLE (sustain_button.gobj()), false);
381 gtk_activatable_set_related_action (GTK_ACTIVATABLE (sustain_button.gobj()), act->gobj());
383 upper_box.set_spacing (6);
384 upper_box.pack_start (chord_button, false, false);
385 upper_box.pack_start (note_length_box, false, false, 12);
386 upper_box.pack_start (triplet_button, false, false);
387 upper_box.pack_start (dot_box1, false, false);
388 upper_box.pack_start (dot_box2, false, false);
389 upper_box.pack_start (sustain_button, false, false);
390 upper_box.pack_start (rest_box, false, false);
391 upper_box.pack_start (resync_box, false, false);
392 upper_box.pack_start (note_velocity_box, false, false, 12);
396 v = manage (new VBox);
397 l = manage (new Label (_("Channel")));
399 v->pack_start (*l, false, false);
400 v->pack_start (channel_spinner, false, false);
401 upper_box.pack_start (*v, false, false);
403 v = manage (new VBox);
404 l = manage (new Label (_("1/Note")));
406 v->pack_start (*l, false, false);
407 v->pack_start (length_divisor_spinner, false, false);
408 upper_box.pack_start (*v, false, false);
410 v = manage (new VBox);
411 l = manage (new Label (_("Velocity")));
413 v->pack_start (*l, false, false);
414 v->pack_start (velocity_spinner, false, false);
415 upper_box.pack_start (*v, false, false);
417 v = manage (new VBox);
418 l = manage (new Label (_("Octave")));
420 v->pack_start (*l, false, false);
421 v->pack_start (octave_spinner, false, false);
422 upper_box.pack_start (*v, false, false);
424 v = manage (new VBox);
425 l = manage (new Label (_("Bank")));
427 v->pack_start (*l, false, false);
428 v->pack_start (bank_spinner, false, false);
429 v->pack_start (bank_button, false, false);
430 upper_box.pack_start (*v, false, false);
432 v = manage (new VBox);
433 l = manage (new Label (_("Program")));
435 v->pack_start (*l, false, false);
436 v->pack_start (program_spinner, false, false);
437 v->pack_start (program_button, false, false);
438 upper_box.pack_start (*v, false, false);
440 velocity_adjustment.signal_value_changed().connect (sigc::mem_fun (*this, &StepEntry::velocity_value_change));
441 length_divisor_adjustment.signal_value_changed().connect (sigc::mem_fun (*this, &StepEntry::length_value_change));
442 dot_adjustment.signal_value_changed().connect (sigc::mem_fun (*this, &StepEntry::dot_value_change));
444 _piano = (PianoKeyboard*) piano_keyboard_new ();
445 piano = wrap ((GtkWidget*) _piano);
447 piano->set_flags (Gtk::CAN_FOCUS);
449 g_signal_connect(G_OBJECT(_piano), "note-off", G_CALLBACK(_note_off_event_handler), this);
450 g_signal_connect(G_OBJECT(_piano), "rest", G_CALLBACK(_rest_event_handler), this);
452 program_button.signal_clicked().connect (sigc::mem_fun (*this, &StepEntry::program_click));
453 bank_button.signal_clicked().connect (sigc::mem_fun (*this, &StepEntry::bank_click));
454 beat_resync_button.signal_clicked().connect (sigc::mem_fun (*this, &StepEntry::beat_resync_click));
455 bar_resync_button.signal_clicked().connect (sigc::mem_fun (*this, &StepEntry::bar_resync_click));
457 length_divisor_adjustment.signal_value_changed().connect (sigc::mem_fun (*this, &StepEntry::length_changed));
459 packer.set_spacing (6);
460 packer.pack_start (upper_box, false, false);
461 packer.pack_start (*piano, false, false);
466 /* initial settings: quarter note and mezzo forte */
468 act = myactions.find_action ("StepEditing/note-length-quarter");
469 RefPtr<RadioAction> r = RefPtr<RadioAction>::cast_dynamic (act);
471 r->set_active (true);
473 act = myactions.find_action ("StepEditing/note-velocity-mf");
474 r = RefPtr<RadioAction>::cast_dynamic (act);
476 r->set_active (true);
479 StepEntry::~StepEntry()
484 StepEntry::length_changed ()
486 length_1_button.queue_draw ();
487 length_2_button.queue_draw ();
488 length_4_button.queue_draw ();
489 length_8_button.queue_draw ();
490 length_16_button.queue_draw ();
491 length_32_button.queue_draw ();
492 length_64_button.queue_draw ();
496 StepEntry::on_key_press_event (GdkEventKey* ev)
498 /* focus widget gets first shot, then bindings, otherwise
499 forward to main window
502 if (!gtk_window_propagate_key_event (GTK_WINDOW(gobj()), ev)) {
503 KeyboardKey k (ev->state, ev->keyval);
505 if (bindings.activate (k, Bindings::Press)) {
510 return forward_key_press (ev);
514 StepEntry::on_key_release_event (GdkEventKey* ev)
516 if (!gtk_window_propagate_key_event (GTK_WINDOW(gobj()), ev)) {
517 KeyboardKey k (ev->state, ev->keyval);
519 if (bindings.activate (k, Bindings::Release)) {
524 /* don't forward releases */
530 StepEntry::rest_event_handler ()
532 se->step_edit_rest (0.0);
536 StepEntry::note_length ()
538 Evoral::MusicalTime base_time = 4.0 / (Evoral::MusicalTime) length_divisor_adjustment.get_value();
540 RefPtr<Action> act = myactions.find_action ("StepEditing/toggle-triplet");
541 RefPtr<ToggleAction> tact = RefPtr<ToggleAction>::cast_dynamic (act);
542 bool triplets = tact->get_active ();
545 base_time *= (2.0/3.0);
548 double dots = dot_adjustment.get_value ();
551 dots = pow (2.0, dots);
552 base_time *= 1 + ((dots - 1.0)/dots);
559 StepEntry::note_velocity () const
561 return (Evoral::MusicalTime) velocity_adjustment.get_value();
565 StepEntry::note_channel() const
567 return channel_adjustment.get_value() - 1;
571 StepEntry::note_off_event_handler (int note)
578 StepEntry::on_show ()
580 ArdourWindow::on_show ();
581 //piano->grab_focus ();
585 StepEntry::beat_resync_click ()
587 se->step_edit_beat_sync ();
591 StepEntry::bar_resync_click ()
593 se->step_edit_bar_sync ();
597 StepEntry::register_actions ()
599 /* add named actions for the editor */
601 myactions.register_action ("StepEditing", "insert-a", _("Insert Note A"), sigc::mem_fun (*this, &StepEntry::insert_a));
602 myactions.register_action ("StepEditing", "insert-asharp", _("Insert Note A-sharp"), sigc::mem_fun (*this, &StepEntry::insert_asharp));
603 myactions.register_action ("StepEditing", "insert-b", _("Insert Note B"), sigc::mem_fun (*this, &StepEntry::insert_b));
604 myactions.register_action ("StepEditing", "insert-c", _("Insert Note C"), sigc::mem_fun (*this, &StepEntry::insert_c));
605 myactions.register_action ("StepEditing", "insert-csharp", _("Insert Note C-sharp"), sigc::mem_fun (*this, &StepEntry::insert_csharp));
606 myactions.register_action ("StepEditing", "insert-d", _("Insert Note D"), sigc::mem_fun (*this, &StepEntry::insert_d));
607 myactions.register_action ("StepEditing", "insert-dsharp", _("Insert Note D-sharp"), sigc::mem_fun (*this, &StepEntry::insert_dsharp));
608 myactions.register_action ("StepEditing", "insert-e", _("Insert Note E"), sigc::mem_fun (*this, &StepEntry::insert_e));
609 myactions.register_action ("StepEditing", "insert-f", _("Insert Note F"), sigc::mem_fun (*this, &StepEntry::insert_f));
610 myactions.register_action ("StepEditing", "insert-fsharp", _("Insert Note F-sharp"), sigc::mem_fun (*this, &StepEntry::insert_fsharp));
611 myactions.register_action ("StepEditing", "insert-g", _("Insert Note G"), sigc::mem_fun (*this, &StepEntry::insert_g));
612 myactions.register_action ("StepEditing", "insert-gsharp", _("Insert Note G-sharp"), sigc::mem_fun (*this, &StepEntry::insert_gsharp));
614 myactions.register_action ("StepEditing", "insert-rest", _("Insert a Note-length Rest"), sigc::mem_fun (*this, &StepEntry::insert_rest));
615 myactions.register_action ("StepEditing", "insert-snap-rest", _("Insert a Snap-length Rest"), sigc::mem_fun (*this, &StepEntry::insert_grid_rest));
617 myactions.register_action ("StepEditing", "next-octave", _("Move to next octave"), sigc::mem_fun (*this, &StepEntry::next_octave));
618 myactions.register_action ("StepEditing", "prev-octave", _("Move to next octave"), sigc::mem_fun (*this, &StepEntry::prev_octave));
620 myactions.register_action ("StepEditing", "next-note-length", _("Move to Next Note Length"), sigc::mem_fun (*this, &StepEntry::next_note_length));
621 myactions.register_action ("StepEditing", "prev-note-length", _("Move to Previous Note Length"), sigc::mem_fun (*this, &StepEntry::prev_note_length));
623 myactions.register_action ("StepEditing", "inc-note-length", _("Increase Note Length"), sigc::mem_fun (*this, &StepEntry::inc_note_length));
624 myactions.register_action ("StepEditing", "dec-note-length", _("Decrease Note Length"), sigc::mem_fun (*this, &StepEntry::dec_note_length));
626 myactions.register_action ("StepEditing", "next-note-velocity", _("Move to Next Note Velocity"), sigc::mem_fun (*this, &StepEntry::next_note_velocity));
627 myactions.register_action ("StepEditing", "prev-note-velocity", _("Move to Previous Note Velocity"), sigc::mem_fun (*this, &StepEntry::prev_note_velocity));
629 myactions.register_action ("StepEditing", "inc-note-velocity", _("Increase Note Velocity"), sigc::mem_fun (*this, &StepEntry::inc_note_velocity));
630 myactions.register_action ("StepEditing", "dec-note-velocity", _("Decrease Note Velocity"), sigc::mem_fun (*this, &StepEntry::dec_note_velocity));
632 myactions.register_action ("StepEditing", "octave-0", _("Switch to the 1st octave"), sigc::mem_fun (*this, &StepEntry::octave_0));
633 myactions.register_action ("StepEditing", "octave-1", _("Switch to the 2nd octave"), sigc::mem_fun (*this, &StepEntry::octave_1));
634 myactions.register_action ("StepEditing", "octave-2", _("Switch to the 3rd octave"), sigc::mem_fun (*this, &StepEntry::octave_2));
635 myactions.register_action ("StepEditing", "octave-3", _("Switch to the 4th octave"), sigc::mem_fun (*this, &StepEntry::octave_3));
636 myactions.register_action ("StepEditing", "octave-4", _("Switch to the 5th octave"), sigc::mem_fun (*this, &StepEntry::octave_4));
637 myactions.register_action ("StepEditing", "octave-5", _("Switch to the 6th octave"), sigc::mem_fun (*this, &StepEntry::octave_5));
638 myactions.register_action ("StepEditing", "octave-6", _("Switch to the 7th octave"), sigc::mem_fun (*this, &StepEntry::octave_6));
639 myactions.register_action ("StepEditing", "octave-7", _("Switch to the 8th octave"), sigc::mem_fun (*this, &StepEntry::octave_7));
640 myactions.register_action ("StepEditing", "octave-8", _("Switch to the 9th octave"), sigc::mem_fun (*this, &StepEntry::octave_8));
641 myactions.register_action ("StepEditing", "octave-9", _("Switch to the 10th octave"), sigc::mem_fun (*this, &StepEntry::octave_9));
642 myactions.register_action ("StepEditing", "octave-10", _("Switch to the 11th octave"), sigc::mem_fun (*this, &StepEntry::octave_10));
644 RadioAction::Group note_length_group;
646 myactions.register_radio_action ("StepEditing", note_length_group, "note-length-whole",
647 _("Set Note Length to Whole"), sigc::mem_fun (*this, &StepEntry::note_length_change), 1);
648 myactions.register_radio_action ("StepEditing", note_length_group, "note-length-half",
649 _("Set Note Length to 1/2"), sigc::mem_fun (*this, &StepEntry::note_length_change), 2);
650 myactions.register_radio_action ("StepEditing", note_length_group, "note-length-third",
651 _("Set Note Length to 1/3"), sigc::mem_fun (*this, &StepEntry::note_length_change), 3);
652 myactions.register_radio_action ("StepEditing", note_length_group, "note-length-quarter",
653 _("Set Note Length to 1/4"), sigc::mem_fun (*this, &StepEntry::note_length_change), 4);
654 myactions.register_radio_action ("StepEditing", note_length_group, "note-length-eighth",
655 _("Set Note Length to 1/8"), sigc::mem_fun (*this, &StepEntry::note_length_change), 8);
656 myactions.register_radio_action ("StepEditing", note_length_group, "note-length-sixteenth",
657 _("Set Note Length to 1/16"), sigc::mem_fun (*this, &StepEntry::note_length_change), 16);
658 myactions.register_radio_action ("StepEditing", note_length_group, "note-length-thirtysecond",
659 _("Set Note Length to 1/32"), sigc::mem_fun (*this, &StepEntry::note_length_change), 32);
660 myactions.register_radio_action ("StepEditing", note_length_group, "note-length-sixtyfourth",
661 _("Set Note Length to 1/64"), sigc::mem_fun (*this, &StepEntry::note_length_change), 64);
663 RadioAction::Group note_velocity_group;
665 myactions.register_radio_action ("StepEditing", note_velocity_group, "note-velocity-ppp",
666 _("Set Note Velocity to Pianississimo"), sigc::mem_fun (*this, &StepEntry::note_velocity_change), 1);
667 myactions.register_radio_action ("StepEditing", note_velocity_group, "note-velocity-pp",
668 _("Set Note Velocity to Pianissimo"), sigc::mem_fun (*this, &StepEntry::note_velocity_change), 16);
669 myactions.register_radio_action ("StepEditing", note_velocity_group, "note-velocity-p",
670 _("Set Note Velocity to Piano"), sigc::mem_fun (*this, &StepEntry::note_velocity_change), 32);
671 myactions.register_radio_action ("StepEditing", note_velocity_group, "note-velocity-mp",
672 _("Set Note Velocity to Mezzo-Piano"), sigc::mem_fun (*this, &StepEntry::note_velocity_change), 64);
673 myactions.register_radio_action ("StepEditing", note_velocity_group, "note-velocity-mf",
674 _("Set Note Velocity to Mezzo-Forte"), sigc::mem_fun (*this, &StepEntry::note_velocity_change), 80);
675 myactions.register_radio_action ("StepEditing", note_velocity_group, "note-velocity-f",
676 _("Set Note Velocity to Forte"), sigc::mem_fun (*this, &StepEntry::note_velocity_change), 96);
677 myactions.register_radio_action ("StepEditing", note_velocity_group, "note-velocity-ff",
678 _("Set Note Velocity to Fortississimo"), sigc::mem_fun (*this, &StepEntry::note_velocity_change), 112);
679 myactions.register_radio_action ("StepEditing", note_velocity_group, "note-velocity-fff",
680 _("Set Note Velocity to Fortississimo"), sigc::mem_fun (*this, &StepEntry::note_velocity_change), 127);
682 myactions.register_toggle_action ("StepEditing", "toggle-triplet", _("Toggle Triple Notes"),
683 sigc::mem_fun (*this, &StepEntry::toggle_triplet));
685 RadioAction::Group dot_group;
687 myactions.register_radio_action ("StepEditing", dot_group, "no-dotted", _("No Dotted Notes"),
688 sigc::mem_fun (*this, &StepEntry::dot_change), 0);
689 myactions.register_radio_action ("StepEditing", dot_group, "toggle-dotted", _("Toggled Dotted Notes"),
690 sigc::mem_fun (*this, &StepEntry::dot_change), 1);
691 myactions.register_radio_action ("StepEditing", dot_group, "toggle-double-dotted", _("Toggled Double-Dotted Notes"),
692 sigc::mem_fun (*this, &StepEntry::dot_change), 2);
693 myactions.register_radio_action ("StepEditing", dot_group, "toggle-triple-dotted", _("Toggled Triple-Dotted Notes"),
694 sigc::mem_fun (*this, &StepEntry::dot_change), 3);
696 myactions.register_toggle_action ("StepEditing", "toggle-chord", _("Toggle Chord Entry"),
697 sigc::mem_fun (*this, &StepEntry::toggle_chord));
698 myactions.register_action ("StepEditing", "sustain", _("Sustain Selected Notes by Note Length"),
699 sigc::mem_fun (*this, &StepEntry::do_sustain));
701 myactions.register_action ("StepEditing", "sync-to-edit-point", _("Move Insert Position to Edit Point"),
702 sigc::mem_fun (*this, &StepEntry::sync_to_edit_point));
703 myactions.register_action ("StepEditing", "back", _("Move Insert Position Back by Note Length"),
704 sigc::mem_fun (*this, &StepEntry::back));
708 StepEntry::load_bindings ()
710 /* XXX move this to a better place */
712 bindings.set_action_map (myactions);
714 std::string binding_file;
716 if (find_file_in_search_path (ardour_config_search_path(), "step_editing.bindings", binding_file)) {
717 bindings.load (binding_file);
722 StepEntry::toggle_triplet ()
724 se->set_step_edit_cursor_width (note_length());
728 StepEntry::toggle_chord ()
730 se->step_edit_toggle_chord ();
734 StepEntry::dot_change (GtkAction* act)
736 if (gtk_toggle_action_get_active (GTK_TOGGLE_ACTION(act))) {
737 gint v = gtk_radio_action_get_current_value (GTK_RADIO_ACTION (act));
738 dot_adjustment.set_value (v);
743 StepEntry::dot_value_change ()
746 RefPtr<RadioAction> ract;
747 double val = dot_adjustment.get_value();
748 bool inconsistent = true;
749 vector<const char*> dot_actions;
751 dot_actions.push_back ("StepEditing/no-dotted");
752 dot_actions.push_back ("StepEditing/toggle-dotted");
753 dot_actions.push_back ("StepEditing/toggle-double-dotted");
754 dot_actions.push_back ("StepEditing/toggle-triple-dotted");
756 for (vector<const char*>::iterator i = dot_actions.begin(); i != dot_actions.end(); ++i) {
758 act = myactions.find_action (*i);
761 ract = RefPtr<RadioAction>::cast_dynamic (act);
764 if (ract->property_value() == val) {
765 ract->set_active (true);
766 inconsistent = false;
773 dot1_button.set_inconsistent (inconsistent);
774 dot2_button.set_inconsistent (inconsistent);
775 dot3_button.set_inconsistent (inconsistent);
777 se->set_step_edit_cursor_width (note_length());
781 StepEntry::program_click ()
783 se->step_add_program_change (note_channel(), (int8_t) floor (program_adjustment.get_value()));
787 StepEntry::bank_click ()
789 se->step_add_bank_change (note_channel(), (int8_t) floor (bank_adjustment.get_value()));
793 StepEntry::insert_rest ()
795 se->step_edit_rest (note_length());
799 StepEntry::insert_grid_rest ()
801 se->step_edit_rest (0.0);
805 StepEntry::insert_note (uint8_t note)
811 se->step_add_note (note_channel(), note, note_velocity(), note_length());
814 StepEntry::insert_c ()
816 insert_note (0 + (current_octave() * 12));
819 StepEntry::insert_csharp ()
821 insert_note (1 + (current_octave() * 12));
824 StepEntry::insert_d ()
826 insert_note (2 + (current_octave() * 12));
829 StepEntry::insert_dsharp ()
831 insert_note (3 + (current_octave() * 12));
834 StepEntry::insert_e ()
836 insert_note (4 + (current_octave() * 12));
839 StepEntry::insert_f ()
841 insert_note (5 + (current_octave() * 12));
844 StepEntry::insert_fsharp ()
846 insert_note (6 + (current_octave() * 12));
849 StepEntry::insert_g ()
851 insert_note (7 + (current_octave() * 12));
854 StepEntry::insert_gsharp ()
856 insert_note (8 + (current_octave() * 12));
860 StepEntry::insert_a ()
862 insert_note (9 + (current_octave() * 12));
866 StepEntry::insert_asharp ()
868 insert_note (10 + (current_octave() * 12));
871 StepEntry::insert_b ()
873 insert_note (11 + (current_octave() * 12));
877 StepEntry::note_length_change (GtkAction* act)
879 /* it doesn't matter which note length action we look up - we are interested
880 in the current_value which is global across the whole group of note length
881 actions. this method is called twice for every user operation,
882 once for the action that became "inactive" and once for the action that
883 becaome "active". so ... only bother to actually change the value when this
884 is called for the "active" action.
887 if (gtk_toggle_action_get_active (GTK_TOGGLE_ACTION(act))) {
888 gint v = gtk_radio_action_get_current_value (GTK_RADIO_ACTION (act));
889 length_divisor_adjustment.set_value (v);
894 StepEntry::note_velocity_change (GtkAction* act)
896 /* it doesn't matter which note length action we look up - we are interested
897 in the current_value which is global across the whole group of note length
898 actions. this method is called twice for every user operation,
899 once for the action that became "inactive" and once for the action that
900 becaome "active". so ... only bother to actually change the value when this
901 is called for the "active" action.
904 if (gtk_toggle_action_get_active (GTK_TOGGLE_ACTION(act))) {
905 gint v = gtk_radio_action_get_current_value (GTK_RADIO_ACTION (act));
906 velocity_adjustment.set_value (v);
911 StepEntry::velocity_value_change ()
914 RefPtr<RadioAction> ract;
915 double val = velocity_adjustment.get_value();
916 bool inconsistent = true;
917 vector<const char*> velocity_actions;
919 velocity_actions.push_back ("StepEditing/note-velocity-ppp");
920 velocity_actions.push_back ("StepEditing/note-velocity-pp");
921 velocity_actions.push_back ("StepEditing/note-velocity-p");
922 velocity_actions.push_back ("StepEditing/note-velocity-mp");
923 velocity_actions.push_back ("StepEditing/note-velocity-mf");
924 velocity_actions.push_back ("StepEditing/note-velocity-f");
925 velocity_actions.push_back ("StepEditing/note-velocity-ff");
926 velocity_actions.push_back ("StepEditing/note-velocity-fff");
928 for (vector<const char*>::iterator i = velocity_actions.begin(); i != velocity_actions.end(); ++i) {
930 act = myactions.find_action (*i);
933 ract = RefPtr<RadioAction>::cast_dynamic (act);
936 if (ract->property_value() == val) {
937 ract->set_active (true);
938 inconsistent = false;
945 velocity_ppp_button.set_inconsistent (inconsistent);
946 velocity_pp_button.set_inconsistent (inconsistent);
947 velocity_p_button.set_inconsistent (inconsistent);
948 velocity_mp_button.set_inconsistent (inconsistent);
949 velocity_mf_button.set_inconsistent (inconsistent);
950 velocity_f_button.set_inconsistent (inconsistent);
951 velocity_ff_button.set_inconsistent (inconsistent);
952 velocity_fff_button.set_inconsistent (inconsistent);
956 StepEntry::length_value_change ()
959 RefPtr<RadioAction> ract;
960 double val = length_divisor_adjustment.get_value();
961 bool inconsistent = true;
962 vector<const char*> length_actions;
964 length_actions.push_back ("StepEditing/note-length-whole");
965 length_actions.push_back ("StepEditing/note-length-half");
966 length_actions.push_back ("StepEditing/note-length-quarter");
967 length_actions.push_back ("StepEditing/note-length-eighth");
968 length_actions.push_back ("StepEditing/note-length-sixteenth");
969 length_actions.push_back ("StepEditing/note-length-thirtysecond");
970 length_actions.push_back ("StepEditing/note-length-sixtyfourth");
972 for (vector<const char*>::iterator i = length_actions.begin(); i != length_actions.end(); ++i) {
974 act = myactions.find_action (*i);
977 ract = RefPtr<RadioAction>::cast_dynamic (act);
980 if (ract->property_value() == val) {
981 ract->set_active (true);
982 inconsistent = false;
989 length_1_button.set_inconsistent (inconsistent);
990 length_2_button.set_inconsistent (inconsistent);
991 length_4_button.set_inconsistent (inconsistent);
992 length_8_button.set_inconsistent (inconsistent);
993 length_16_button.set_inconsistent (inconsistent);
994 length_32_button.set_inconsistent (inconsistent);
995 length_64_button.set_inconsistent (inconsistent);
997 se->set_step_edit_cursor_width (note_length());
1001 StepEntry::radio_button_press (GdkEventButton* ev)
1003 if (ev->button == 1) {
1011 StepEntry::radio_button_release (GdkEventButton* ev, RadioButton* btn, int v)
1013 if (ev->button == 1) {
1014 GtkAction* act = gtk_activatable_get_related_action (GTK_ACTIVATABLE (btn->gobj()));
1017 gtk_radio_action_set_current_value (GTK_RADIO_ACTION(act), v);
1027 StepEntry::next_octave ()
1029 octave_adjustment.set_value (octave_adjustment.get_value() + 1.0);
1033 StepEntry::prev_octave ()
1035 octave_adjustment.set_value (octave_adjustment.get_value() - 1.0);
1039 StepEntry::inc_note_length ()
1041 length_divisor_adjustment.set_value (length_divisor_adjustment.get_value() - 1.0);
1045 StepEntry::dec_note_length ()
1047 length_divisor_adjustment.set_value (length_divisor_adjustment.get_value() + 1.0);
1051 StepEntry::prev_note_length ()
1053 double l = length_divisor_adjustment.get_value();
1054 int il = (int) lrintf (l); // round to nearest integer
1055 il = (il/2) * 2; // round to power of 2
1063 length_divisor_adjustment.set_value (il);
1067 StepEntry::next_note_length ()
1069 double l = length_divisor_adjustment.get_value();
1070 int il = (int) lrintf (l); // round to nearest integer
1071 il = (il/2) * 2; // round to power of 2
1080 length_divisor_adjustment.set_value (il);
1085 StepEntry::inc_note_velocity ()
1087 velocity_adjustment.set_value (velocity_adjustment.get_value() + 1.0);
1091 StepEntry::dec_note_velocity ()
1093 velocity_adjustment.set_value (velocity_adjustment.get_value() - 1.0);
1097 StepEntry::next_note_velocity ()
1099 double l = velocity_adjustment.get_value ();
1103 } else if (l < 32) {
1105 } else if (l < 48) {
1107 } else if (l < 64) {
1109 } else if (l < 80) {
1111 } else if (l < 96) {
1113 } else if (l < 112) {
1115 } else if (l < 127) {
1119 velocity_adjustment.set_value (l);
1123 StepEntry::prev_note_velocity ()
1125 double l = velocity_adjustment.get_value ();
1129 } else if (l > 96) {
1131 } else if (l > 80) {
1133 } else if (l > 64) {
1135 } else if (l > 48) {
1137 } else if (l > 32) {
1139 } else if (l > 16) {
1145 velocity_adjustment.set_value (l);
1149 StepEntry::octave_n (int n)
1151 octave_adjustment.set_value (n);
1155 StepEntry::do_sustain ()
1157 se->step_edit_sustain (note_length());
1163 se->move_step_edit_beat_pos (-note_length());
1167 StepEntry::sync_to_edit_point ()
1169 se->resync_step_edit_to_edit_point ();