gtk2_ardour/midi_list_editor.cc

   1 /*
   2     Copyright (C) 2009 Paul Davis
   3
   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.
   8
   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.
  13
  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.
  17 */
  18
  19 #include <cmath>
  20 #include <map>
  21
  22 #include <gtkmm/cellrenderercombo.h>
  23
  24 #include "evoral/midi_util.h"
  25 #include "evoral/Note.hpp"
  26
  27 #include "ardour/beats_frames_converter.h"
  28 #include "ardour/midi_model.h"
  29 #include "ardour/midi_region.h"
  30 #include "ardour/midi_source.h"
  31 #include "ardour/session.h"
  32 #include "ardour/tempo.h"
  33
  34 #include "gtkmm2ext/gui_thread.h"
  35 #include "gtkmm2ext/keyboard.h"
  36 #include "gtkmm2ext/actions.h"
  37
  38 #include "midi_list_editor.h"
  39 #include "note_player.h"
  40
  41 #include "i18n.h"
  42
  43 using namespace std;
  44 using namespace Gtk;
  45 using namespace Gtkmm2ext;
  46 using namespace Glib;
  47 using namespace ARDOUR;
  48 using Timecode::BBT_Time;
  49
  50 static map<int,std::string> note_length_map;
  51
  52 static void
  53 fill_note_length_map ()
  54 {
  55         note_length_map.insert (make_pair<int,string> (BBT_Time::ticks_per_beat, _("Whole")));
  56         note_length_map.insert (make_pair<int,string> (BBT_Time::ticks_per_beat/2, _("Half")));
  57         note_length_map.insert (make_pair<int,string> (BBT_Time::ticks_per_beat/3, _("Triplet")));
  58         note_length_map.insert (make_pair<int,string> (BBT_Time::ticks_per_beat/4, _("Quarter")));
  59         note_length_map.insert (make_pair<int,string> (BBT_Time::ticks_per_beat/8, _("Eighth")));
  60         note_length_map.insert (make_pair<int,string> (BBT_Time::ticks_per_beat/16, _("Sixteenth")));
  61         note_length_map.insert (make_pair<int,string> (BBT_Time::ticks_per_beat/32, _("Thirty-second")));
  62         note_length_map.insert (make_pair<int,string> (BBT_Time::ticks_per_beat/64, _("Sixty-fourth")));
  63 }
  64
  65 MidiListEditor::MidiListEditor (Session* s, boost::shared_ptr<MidiRegion> r, boost::shared_ptr<MidiTrack> tr)
  66         : ArdourWindow (r->name())
  67         , buttons (1, 1)
  68         , region (r)
  69         , track (tr)
  70 {
  71         if (note_length_map.empty()) {
  72                 fill_note_length_map ();
  73         }
  74
  75         /* We do not handle nested sources/regions. Caller should have tackled this */
  76
  77         if (r->max_source_level() > 0) {
  78                 throw failed_constructor();
  79         }
  80
  81         set_session (s);
  82
  83         edit_column = -1;
  84         editing_renderer = 0;
  85         editing_editable = 0;
  86
  87         model = ListStore::create (columns);
  88         view.set_model (model);
  89
  90         note_length_model = ListStore::create (note_length_columns);
  91         TreeModel::Row row;
  92
  93         for (std::map<int,string>::iterator i = note_length_map.begin(); i != note_length_map.end(); ++i) {
  94                 row = *(note_length_model->append());
  95                 row[note_length_columns.ticks] = i->first;
  96                 row[note_length_columns.name] = i->second;
  97         }
  98
  99         view.signal_key_press_event().connect (sigc::mem_fun (*this, &MidiListEditor::key_press), false);
 100         view.signal_key_release_event().connect (sigc::mem_fun (*this, &MidiListEditor::key_release), false);
 101         view.signal_scroll_event().connect (sigc::mem_fun (*this, &MidiListEditor::scroll_event), false);
 102
 103         view.append_column (_("Start"), columns.start);
 104         view.append_column (_("Channel"), columns.channel);
 105         view.append_column (_("Num"), columns.note);
 106         view.append_column (_("Name"), columns.note_name);
 107         view.append_column (_("Vel"), columns.velocity);
 108
 109         /* use a combo renderer for length, so that we can offer a selection
 110            of pre-defined note lengths. we still allow edited values with
 111            arbitrary length (in ticks).
 112          */
 113
 114         Gtk::TreeViewColumn* lenCol = Gtk::manage (new Gtk::TreeViewColumn (_("Length")));
 115         Gtk::CellRendererCombo* comboCell = Gtk::manage(new Gtk::CellRendererCombo);
 116         lenCol->pack_start(*comboCell);
 117         lenCol->add_attribute (comboCell->property_text(), columns.length);
 118
 119         comboCell->property_model() = note_length_model;
 120         comboCell->property_text_column() = 1;
 121         comboCell->property_has_entry() = false;
 122
 123         view.append_column (*lenCol);
 124
 125         view.set_headers_visible (true);
 126         view.set_rules_hint (true);
 127         view.get_selection()->set_mode (SELECTION_MULTIPLE);
 128         view.get_selection()->signal_changed().connect (sigc::mem_fun (*this, &MidiListEditor::selection_changed));
 129
 130         for (int i = 0; i < 6; ++i) {
 131                 CellRendererText* renderer = dynamic_cast<CellRendererText*>(view.get_column_cell_renderer (i));
 132
 133                 TreeViewColumn* col = view.get_column (i);
 134                 col->set_data (X_("colnum"), GUINT_TO_POINTER(i));
 135
 136                 renderer->property_editable() = true;
 137
 138                 renderer->signal_editing_started().connect (sigc::bind (sigc::mem_fun (*this, &MidiListEditor::editing_started), i));
 139                 renderer->signal_editing_canceled().connect (sigc::mem_fun (*this, &MidiListEditor::editing_canceled));
 140                 renderer->signal_edited().connect (sigc::mem_fun (*this, &MidiListEditor::edited));
 141         }
 142
 143         scroller.add (view);
 144         scroller.set_policy (POLICY_NEVER, POLICY_AUTOMATIC);
 145
 146         redisplay_model ();
 147
 148         region->midi_source(0)->model()->ContentsChanged.connect (content_connection, invalidator (*this),
 149                                                                   boost::bind (&MidiListEditor::redisplay_model, this), gui_context());
 150
 151         buttons.attach (sound_notes_button, 0, 1, 0, 1);
 152         Glib::RefPtr<Gtk::Action> act = ActionManager::get_action ("Editor", "sound-midi-notes");
 153         if (act) {
 154                 gtk_activatable_set_related_action (GTK_ACTIVATABLE (sound_notes_button.gobj()), act->gobj());
 155         }
 156
 157         view.show ();
 158         scroller.show ();
 159         buttons.show ();
 160         vbox.show ();
 161         sound_notes_button.show ();
 162
 163         vbox.set_spacing (6);
 164         vbox.set_border_width (6);
 165         vbox.pack_start (buttons, false, false);
 166         vbox.pack_start (scroller, true, true);
 167
 168         add (vbox);
 169         set_size_request (-1, 400);
 170 }
 171
 172 MidiListEditor::~MidiListEditor ()
 173 {
 174 }
 175
 176 bool
 177 MidiListEditor::scroll_event (GdkEventScroll* ev)
 178 {
 179         TreeModel::Path path;
 180         TreeViewColumn* col;
 181         int cellx;
 182         int celly;
 183         int idelta = 0;
 184         double fdelta = 0;
 185         MidiModel::NoteDiffCommand::Property prop (MidiModel::NoteDiffCommand::NoteNumber);
 186         bool apply = false;
 187         bool was_selected = false;
 188         char const * opname;
 189
 190         if (!view.get_path_at_pos (ev->x, ev->y, path, col, cellx, celly)) {
 191                 return false;
 192         }
 193
 194         if (view.get_selection()->count_selected_rows() == 0) {
 195                 was_selected = false;
 196         } else if (view.get_selection()->is_selected (path)) {
 197                 was_selected = true;
 198         } else {
 199                 was_selected = false;
 200         }
 201
 202         int colnum = GPOINTER_TO_UINT (col->get_data (X_("colnum")));
 203
 204         switch (colnum) {
 205         case 0:
 206                 if (Keyboard::modifier_state_equals (ev->state, Keyboard::SecondaryModifier)) {
 207                         fdelta = 1/64.0;
 208                 } else {
 209                         fdelta = 1/4.0;
 210                 }
 211                 if (ev->direction == GDK_SCROLL_DOWN || ev->direction == GDK_SCROLL_LEFT) {
 212                         fdelta = -fdelta;
 213                 }
 214                 prop = MidiModel::NoteDiffCommand::StartTime;
 215                 opname = _("edit note start");
 216                 apply = true;
 217                 break;
 218         case 1:
 219                 idelta = 1;
 220                 if (ev->direction == GDK_SCROLL_DOWN || ev->direction == GDK_SCROLL_LEFT) {
 221                         idelta = -idelta;
 222                 }
 223                 prop = MidiModel::NoteDiffCommand::Channel;
 224                 opname = _("edit note channel");
 225                 apply = true;
 226                 break;
 227         case 2:
 228         case 3:
 229                 idelta = 1;
 230                 if (ev->direction == GDK_SCROLL_DOWN || ev->direction == GDK_SCROLL_LEFT) {
 231                         idelta = -idelta;
 232                 }
 233                 prop = MidiModel::NoteDiffCommand::NoteNumber;
 234                 opname = _("edit note number");
 235                 apply = true;
 236                 break;
 237
 238         case 4:
 239                 idelta = 1;
 240                 if (ev->direction == GDK_SCROLL_DOWN || ev->direction == GDK_SCROLL_LEFT) {
 241                         idelta = -idelta;
 242                 }
 243                 prop = MidiModel::NoteDiffCommand::Velocity;
 244                 opname = _("edit note velocity");
 245                 apply = true;
 246                 break;
 247
 248         case 5:
 249                 if (Keyboard::modifier_state_equals (ev->state, Keyboard::SecondaryModifier)) {
 250                         fdelta = 1/64.0;
 251                 } else {
 252                         fdelta = 1/4.0;
 253                 }
 254                 if (ev->direction == GDK_SCROLL_DOWN || ev->direction == GDK_SCROLL_LEFT) {
 255                         fdelta = -fdelta;
 256                 }
 257                 prop = MidiModel::NoteDiffCommand::Length;
 258                 opname = _("edit note length");
 259                 apply = true;
 260                 break;
 261
 262         default:
 263                 break;
 264         }
 265
 266
 267         if (apply) {
 268
 269                 boost::shared_ptr<MidiModel> m (region->midi_source(0)->model());
 270                 MidiModel::NoteDiffCommand* cmd = m->new_note_diff_command (opname);
 271                 vector<TreeModel::Path> previous_selection;
 272
 273                 if (was_selected) {
 274
 275                         /* use selection */
 276
 277                         TreeView::Selection::ListHandle_Path rows = view.get_selection()->get_selected_rows ();
 278                         TreeModel::iterator iter;
 279                         boost::shared_ptr<NoteType> note;
 280
 281                         for (TreeView::Selection::ListHandle_Path::iterator i = rows.begin(); i != rows.end(); ++i) {
 282
 283                                 previous_selection.push_back (*i);
 284
 285                                 if ((iter = model->get_iter (*i))) {
 286
 287                                         note = (*iter)[columns._note];
 288
 289                                         switch (prop) {
 290                                         case MidiModel::NoteDiffCommand::StartTime:
 291                                                 if (note->time() + fdelta >= 0) {
 292                                                         cmd->change (note, prop, note->time() + fdelta);
 293                                                 } else {
 294                                                         cmd->change (note, prop, Evoral::MusicalTime());
 295                                                 }
 296                                                 break;
 297                                         case MidiModel::NoteDiffCommand::Velocity:
 298                                                 cmd->change (note, prop, (uint8_t) (note->velocity() + idelta));
 299                                                 break;
 300                                         case MidiModel::NoteDiffCommand::Length:
 301                                                 if (note->length().to_double() + fdelta >=
 302                                                     Evoral::MusicalTime::tick().to_double()) {
 303                                                         cmd->change (note, prop, note->length() + fdelta);
 304                                                 } else {
 305                                                         cmd->change (note, prop, Evoral::MusicalTime::tick());
 306                                                 }
 307                                                 break;
 308                                         case MidiModel::NoteDiffCommand::Channel:
 309                                                 cmd->change (note, prop, (uint8_t) (note->channel() + idelta));
 310                                                 break;
 311                                         case MidiModel::NoteDiffCommand::NoteNumber:
 312                                                 cmd->change (note, prop, (uint8_t) (note->note() + idelta));
 313                                                 break;
 314                                         default:
 315                                                 continue;
 316                                         }
 317                                 }
 318                         }
 319
 320                 } else {
 321
 322                         /* just this row */
 323
 324                         TreeModel::iterator iter;
 325                         iter = model->get_iter (path);
 326
 327                         previous_selection.push_back (path);
 328
 329                         if (iter) {
 330                                 boost::shared_ptr<NoteType> note = (*iter)[columns._note];
 331
 332                                 switch (prop) {
 333                                 case MidiModel::NoteDiffCommand::StartTime:
 334                                         if (note->time() + fdelta >= 0) {
 335                                                 cmd->change (note, prop, note->time() + fdelta);
 336                                         } else {
 337                                                 cmd->change (note, prop, Evoral::MusicalTime());
 338                                         }
 339                                         break;
 340                                 case MidiModel::NoteDiffCommand::Velocity:
 341                                         cmd->change (note, prop, (uint8_t) (note->velocity() + idelta));
 342                                         break;
 343                                 case MidiModel::NoteDiffCommand::Length:
 344                                         if (note->length() + fdelta >=
 345                                             Evoral::MusicalTime::tick().to_double()) {
 346                                                 cmd->change (note, prop, note->length() + fdelta);
 347                                         } else {
 348                                                 cmd->change (note, prop, Evoral::MusicalTime::tick());
 349                                         }
 350                                         break;
 351                                 case MidiModel::NoteDiffCommand::Channel:
 352                                         cmd->change (note, prop, (uint8_t) (note->channel() + idelta));
 353                                         break;
 354                                 case MidiModel::NoteDiffCommand::NoteNumber:
 355                                         cmd->change (note, prop, (uint8_t) (note->note() + idelta));
 356                                         break;
 357                                 default:
 358                                         break;
 359                                 }
 360                         }
 361                 }
 362
 363                 m->apply_command (*_session, cmd);
 364
 365                 /* reset selection to be as it was before we rebuilt */
 366
 367                 for (vector<TreeModel::Path>::iterator i = previous_selection.begin(); i != previous_selection.end(); ++i) {
 368                         view.get_selection()->select (*i);
 369                 }
 370         }
 371
 372         return true;
 373 }
 374
 375 bool
 376 MidiListEditor::key_press (GdkEventKey* ev)
 377 {
 378         bool ret = false;
 379         TreeModel::Path path;
 380         TreeViewColumn* col;
 381         int colnum;
 382
 383         switch (ev->keyval) {
 384         case GDK_Tab:
 385                 if (edit_column > 0) {
 386                         colnum = edit_column;
 387                         path = edit_path;
 388                         if (editing_editable) {
 389                                 editing_editable->editing_done ();
 390                         }
 391                         if (colnum >= 5) {
 392                                 /* wrap to next line */
 393                                 colnum = 0;
 394                                 path.next();
 395                         } else {
 396                                 colnum++;
 397                         }
 398                         col = view.get_column (colnum);
 399                         view.set_cursor (path, *col, true);
 400                         ret = true;
 401                 }
 402                 break;
 403
 404         case GDK_Up:
 405         case GDK_uparrow:
 406                 if (edit_column > 0) {
 407                         colnum = edit_column;
 408                         path = edit_path;
 409                         if (editing_editable) {
 410                                 editing_editable->editing_done ();
 411                         }
 412                         path.prev ();
 413                         col = view.get_column (colnum);
 414                         view.set_cursor (path, *col, true);
 415                         ret = true;
 416                 }
 417                 break;
 418
 419         case GDK_Down:
 420         case GDK_downarrow:
 421                 if (edit_column > 0) {
 422                         colnum = edit_column;
 423                         path = edit_path;
 424                         if (editing_editable) {
 425                                 editing_editable->editing_done ();
 426                         }
 427                         path.next ();
 428                         col = view.get_column (colnum);
 429                         view.set_cursor (path, *col, true);
 430                         ret = true;
 431                 }
 432                 break;
 433
 434         case GDK_Escape:
 435                 stop_editing (true);
 436                 break;
 437
 438         }
 439
 440         return ret;
 441 }
 442
 443 bool
 444 MidiListEditor::key_release (GdkEventKey* ev)
 445 {
 446         bool ret = false;
 447         TreeModel::Path path;
 448         TreeViewColumn* col;
 449         TreeModel::iterator iter;
 450         MidiModel::NoteDiffCommand* cmd;
 451         boost::shared_ptr<MidiModel> m (region->midi_source(0)->model());
 452         boost::shared_ptr<NoteType> note;
 453         boost::shared_ptr<NoteType> copy;
 454
 455         switch (ev->keyval) {
 456         case GDK_Insert:
 457                 /* add a new note to the model, based on the note at the cursor
 458                  * pos
 459                  */
 460                 view.get_cursor (path, col);
 461                 iter = model->get_iter (path);
 462                 cmd = m->new_note_diff_command (_("insert new note"));
 463                 note = (*iter)[columns._note];
 464                 copy.reset (new NoteType (*note.get()));
 465                 cmd->add (copy);
 466                 m->apply_command (*_session, cmd);
 467                 /* model has been redisplayed by now */
 468                 path.next ();
 469                 /* select, start editing column 2 (note) */
 470                 col = view.get_column (2);
 471                 view.set_cursor (path, *col, true);
 472                 break;
 473
 474         case GDK_Delete:
 475         case GDK_BackSpace:
 476                 if (edit_column < 0) {
 477                         delete_selected_note ();
 478                 }
 479                 ret = true;
 480                 break;
 481
 482         case GDK_z:
 483                 if (_session && Gtkmm2ext::Keyboard::modifier_state_contains (ev->state, Gtkmm2ext::Keyboard::PrimaryModifier)) {
 484                         _session->undo (1);
 485                         ret = true;
 486                 }
 487                 break;
 488
 489         case GDK_r:
 490                 if (_session && Gtkmm2ext::Keyboard::modifier_state_contains (ev->state, Gtkmm2ext::Keyboard::PrimaryModifier)) {
 491                         _session->redo (1);
 492                         ret = true;
 493                 }
 494                 break;
 495
 496         default:
 497                 break;
 498         }
 499
 500         return ret;
 501 }
 502
 503 void
 504 MidiListEditor::delete_selected_note ()
 505 {
 506         Glib::RefPtr<TreeSelection> selection = view.get_selection();
 507         TreeView::Selection::ListHandle_Path rows = selection->get_selected_rows ();
 508
 509         if (rows.empty()) {
 510                 return;
 511         }
 512
 513         typedef vector<boost::shared_ptr<NoteType> > Notes;
 514         Notes to_delete;
 515
 516         for (TreeView::Selection::ListHandle_Path::iterator i = rows.begin(); i != rows.end(); ++i) {
 517                 TreeIter iter;
 518
 519                 if ((iter = model->get_iter (*i))) {
 520                         boost::shared_ptr<NoteType> note = (*iter)[columns._note];
 521                         to_delete.push_back (note);
 522                 }
 523         }
 524
 525         boost::shared_ptr<MidiModel> m (region->midi_source(0)->model());
 526         MidiModel::NoteDiffCommand* cmd = m->new_note_diff_command (_("delete notes (from list)"));
 527
 528         for (Notes::iterator i = to_delete.begin(); i != to_delete.end(); ++i) {
 529                 cmd->remove (*i);
 530         }
 531
 532         m->apply_command (*_session, cmd);
 533 }
 534
 535 void
 536 MidiListEditor::stop_editing (bool cancelled)
 537 {
 538         if (!cancelled) {
 539                 if (editing_editable) {
 540                         editing_editable->editing_done ();
 541                 }
 542         } else {
 543                 if (editing_renderer) {
 544                         editing_renderer->stop_editing (cancelled);
 545                 }
 546         }
 547 }
 548
 549 void
 550 MidiListEditor::editing_started (CellEditable* ed, const string& path, int colno)
 551 {
 552         edit_path = TreePath (path);
 553         edit_column = colno;
 554         editing_renderer = dynamic_cast<CellRendererText*>(view.get_column_cell_renderer (colno));
 555         editing_editable = ed;
 556
 557         if (ed) {
 558                 Gtk::Entry *e = dynamic_cast<Gtk::Entry*> (ed);
 559                 if (e) {
 560                         e->signal_key_press_event().connect (sigc::mem_fun (*this, &MidiListEditor::key_press), false);
 561                         e->signal_key_release_event().connect (sigc::mem_fun (*this, &MidiListEditor::key_release), false);
 562                 }
 563         }
 564 }
 565
 566 void
 567 MidiListEditor::editing_canceled ()
 568 {
 569         edit_path.clear ();
 570         edit_column = -1;
 571         editing_renderer = 0;
 572         editing_editable = 0;
 573 }
 574
 575 void
 576 MidiListEditor::edited (const std::string& path, const std::string& text)
 577 {
 578         TreeModel::iterator iter = model->get_iter (path);
 579
 580         if (!iter || text.empty()) {
 581                 return;
 582         }
 583
 584         boost::shared_ptr<NoteType> note = (*iter)[columns._note];
 585         MidiModel::NoteDiffCommand::Property prop (MidiModel::NoteDiffCommand::NoteNumber);
 586
 587         double fval;
 588         int    ival;
 589         bool   apply = false;
 590         int    idelta = 0;
 591         double fdelta = 0;
 592         char const * opname;
 593         switch (edit_column) {
 594         case 0: // start
 595                 break;
 596         case 1: // channel
 597                 // correct ival for zero-based counting after scan
 598                 if (sscanf (text.c_str(), "%d", &ival) == 1 && --ival != note->channel()) {
 599                         idelta = ival - note->channel();
 600                         prop = MidiModel::NoteDiffCommand::Channel;
 601                         opname = _("change note channel");
 602                         apply = true;
 603                 }
 604                 break;
 605         case 2: // note
 606                 if (sscanf (text.c_str(), "%d", &ival) == 1 && ival != note->note()) {
 607                         idelta = ival - note->note();
 608                         prop = MidiModel::NoteDiffCommand::NoteNumber;
 609                         opname = _("change note number");
 610                         apply = true;
 611                 }
 612                 break;
 613         case 3: // name
 614                 break;
 615         case 4: // velocity
 616                 if (sscanf (text.c_str(), "%d", &ival) == 1 && ival != note->velocity()) {
 617                         idelta = ival - note->velocity();
 618                         prop = MidiModel::NoteDiffCommand::Velocity;
 619                         opname = _("change note velocity");
 620                         apply = true;
 621                 }
 622                 break;
 623         case 5: // length
 624
 625                 if (sscanf (text.c_str(), "%lf", &fval) == 1) {
 626
 627                         /* numeric value entered */
 628
 629                         if (text.find ('.') == string::npos && text.find (',') == string::npos) {
 630                                 /* integral => units are ticks */
 631                                 fval = fval / BBT_Time::ticks_per_beat;
 632                         } else {
 633                                 /* non-integral => beats, so use as-is */
 634                         }
 635
 636                 } else {
 637
 638                         /* assume its text from the combo. look for the map
 639                          * entry for the actual note ticks
 640                          */
 641
 642                         uint64_t len_ticks = note->length().to_ticks();
 643                         std::map<int,string>::iterator x = note_length_map.find (len_ticks);
 644
 645                         if (x == note_length_map.end()) {
 646
 647                                 /* tick length not in map - was
 648                                  * displaying numeric value ... use new value
 649                                  * from note length map, and convert to beats.
 650                                  */
 651
 652                                 for (x = note_length_map.begin(); x != note_length_map.end(); ++x) {
 653                                         if (x->second == text) {
 654                                                 break;
 655                                         }
 656                                 }
 657
 658                                 if (x != note_length_map.end()) {
 659                                         fval = x->first / BBT_Time::ticks_per_beat;
 660                                 }
 661
 662                         } else {
 663
 664                                 fval = -1.0;
 665
 666                                 if (text != x->second) {
 667
 668                                         /* get ticks for the newly selected
 669                                          * note length
 670                                          */
 671
 672                                         for (x = note_length_map.begin(); x != note_length_map.end(); ++x) {
 673                                                 if (x->second == text) {
 674                                                         break;
 675                                                 }
 676                                         }
 677
 678                                         if (x != note_length_map.end()) {
 679                                                 /* convert to beats */
 680                                                 fval = (double) x->first / BBT_Time::ticks_per_beat;
 681                                         }
 682                                 }
 683                         }
 684                 }
 685
 686                 if (fval > 0.0) {
 687                         fdelta = fval - note->length().to_double();
 688                         prop = MidiModel::NoteDiffCommand::Length;
 689                         opname = _("change note length");
 690                         apply = true;
 691                 }
 692                 break;
 693
 694         default:
 695                 break;
 696         }
 697
 698         if (apply) {
 699
 700                 boost::shared_ptr<MidiModel> m (region->midi_source(0)->model());
 701                 MidiModel::NoteDiffCommand* cmd = m->new_note_diff_command (opname);
 702
 703                 TreeView::Selection::ListHandle_Path rows = view.get_selection()->get_selected_rows ();
 704
 705                 for (TreeView::Selection::ListHandle_Path::iterator i = rows.begin(); i != rows.end(); ++i) {
 706                         if ((iter = model->get_iter (*i))) {
 707
 708                                 note = (*iter)[columns._note];
 709
 710                                 switch (prop) {
 711                                 case MidiModel::NoteDiffCommand::Velocity:
 712                                         cmd->change (note, prop, (uint8_t) (note->velocity() + idelta));
 713                                         break;
 714                                 case MidiModel::NoteDiffCommand::Length:
 715                                         cmd->change (note, prop, note->length() + fdelta);
 716                                         break;
 717                                 case MidiModel::NoteDiffCommand::Channel:
 718                                         cmd->change (note, prop, (uint8_t) (note->channel() + idelta));
 719                                         break;
 720                                 case MidiModel::NoteDiffCommand::NoteNumber:
 721                                         cmd->change (note, prop, (uint8_t) (note->note() + idelta));
 722                                         break;
 723                                 default:
 724                                         continue;
 725                                 }
 726                         }
 727                 }
 728
 729                 m->apply_command (*_session, cmd);
 730
 731                 /* model has been redisplayed by now */
 732                 /* keep selected row(s), move cursor there, don't continue editing */
 733
 734                 TreeViewColumn* col = view.get_column (edit_column);
 735                 view.set_cursor (edit_path, *col, 0);
 736
 737                 /* reset edit info, since we're done */
 738
 739                 edit_path.clear ();
 740                 edit_column = -1;
 741                 editing_renderer = 0;
 742                 editing_editable = 0;
 743         }
 744 }
 745
 746 void
 747 MidiListEditor::redisplay_model ()
 748 {
 749         view.set_model (Glib::RefPtr<Gtk::ListStore>(0));
 750         model->clear ();
 751
 752         if (_session) {
 753
 754                 BeatsFramesConverter conv (_session->tempo_map(), region->position());
 755                 MidiModel::Notes notes = region->midi_source(0)->model()->notes();
 756                 TreeModel::Row row;
 757                 stringstream ss;
 758
 759                 for (MidiModel::Notes::iterator i = notes.begin(); i != notes.end(); ++i) {
 760                         row = *(model->append());
 761                         row[columns.channel] = (*i)->channel() + 1;
 762                         row[columns.note_name] = Evoral::midi_note_name ((*i)->note());
 763                         row[columns.note] = (*i)->note();
 764                         row[columns.velocity] = (*i)->velocity();
 765
 766                         Timecode::BBT_Time bbt;
 767
 768                         _session->tempo_map().bbt_time (conv.to ((*i)->time()), bbt);
 769
 770                         ss.str ("");
 771                         ss << bbt;
 772                         row[columns.start] = ss.str();
 773
 774                         bbt.bars = 0;
 775                         const Evoral::MusicalTime dur = (*i)->end_time() - (*i)->time();
 776                         bbt.beats = dur.get_beats ();
 777                         bbt.ticks = dur.get_ticks ();
 778
 779                         int len_ticks = (*i)->length().to_ticks();
 780                         std::map<int,string>::iterator x = note_length_map.find (len_ticks);
 781
 782                         if (x != note_length_map.end()) {
 783                                 row[columns.length] = x->second;
 784                         } else {
 785                                 ss.str ("");
 786                                 ss << len_ticks;
 787                                 row[columns.length] = ss.str();
 788                         }
 789
 790                         row[columns._note] = (*i);
 791                 }
 792         }
 793
 794         view.set_model (model);
 795 }
 796
 797 void
 798 MidiListEditor::selection_changed ()
 799 {
 800         if (!Config->get_sound_midi_notes()) {
 801                 return;
 802         }
 803
 804         TreeModel::Path path;
 805         TreeModel::iterator iter;
 806         boost::shared_ptr<NoteType> note;
 807         TreeView::Selection::ListHandle_Path rows = view.get_selection()->get_selected_rows ();
 808
 809         NotePlayer* player = new NotePlayer (track);
 810
 811         for (TreeView::Selection::ListHandle_Path::iterator i = rows.begin(); i != rows.end(); ++i) {
 812                 if ((iter = model->get_iter (*i))) {
 813                         note = (*iter)[columns._note];
 814                         player->add (note);
 815                 }
 816         }
 817
 818         player->play ();
 819 }