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
  21 #include "evoral/midi_util.h"
  22
  23 #include "ardour/beats_frames_converter.h"
  24 #include "ardour/midi_region.h"
  25 #include "ardour/session.h"
  26 #include "ardour/tempo.h"
  27
  28 #include "midi_list_editor.h"
  29
  30 #include "i18n.h"
  31
  32 using namespace std;
  33 using namespace Gtk;
  34 using namespace Glib;
  35 using namespace ARDOUR;
  36
  37 MidiListEditor::MidiListEditor (Session* s, boost::shared_ptr<MidiRegion> r)
  38         : ArdourDialog (r->name(), false, false)
  39         , region (r)
  40 {
  41         /* We do not handle nested sources/regions. Caller should have tackled this */
  42
  43         if (r->max_source_level() > 0) {
  44                 throw failed_constructor();
  45         }
  46
  47         set_session (s);
  48
  49         model = ListStore::create (columns);
  50         view.set_model (model);
  51
  52         view.signal_key_press_event().connect (sigc::mem_fun (*this, &MidiListEditor::key_press));
  53         view.signal_key_release_event().connect (sigc::mem_fun (*this, &MidiListEditor::key_release));
  54
  55         view.append_column (_("Start"), columns.start);
  56         view.append_column (_("Channel"), columns.channel);
  57         view.append_column (_("Num"), columns.note);
  58         view.append_column (_("Name"), columns.note_name);
  59         view.append_column (_("Vel"), columns.velocity);
  60         view.append_column (_("Length"), columns.length);
  61         view.append_column (_("End"), columns.end);
  62         view.set_headers_visible (true);
  63         view.set_name (X_("MidiListView"));
  64         view.set_rules_hint (true);
  65
  66         for (int i = 0; i < 6; ++i) {
  67                 CellRendererText* renderer = dynamic_cast<CellRendererText*>(view.get_column_cell_renderer (i));
  68                 renderer->property_editable() = true;
  69
  70                 renderer->signal_editing_started().connect (sigc::bind (sigc::mem_fun (*this, &MidiListEditor::editing_started), i));
  71                 renderer->signal_editing_canceled().connect (sigc::mem_fun (*this, &MidiListEditor::editing_canceled));
  72                 renderer->signal_edited().connect (sigc::mem_fun (*this, &MidiListEditor::edited));
  73         }
  74
  75         scroller.add (view);
  76         scroller.set_policy (POLICY_NEVER, POLICY_AUTOMATIC);
  77
  78         redisplay_model ();
  79
  80         view.show ();
  81         scroller.show ();
  82
  83         get_vbox()->pack_start (scroller);
  84         set_size_request (400, 400);
  85 }
  86
  87 MidiListEditor::~MidiListEditor ()
  88 {
  89 }
  90
  91 bool
  92 MidiListEditor::key_press (GdkEventKey* ev)
  93 {
  94         bool editing = !_current_edit.empty();
  95         bool ret = false;
  96
  97         if (editing) {
  98                 switch (ev->keyval) {
  99                 case GDK_Tab:
 100                         break;
 101                 case GDK_Right:
 102                         break;
 103                 case GDK_Left:
 104                         break;
 105                 case GDK_Up:
 106                         break;
 107                 case GDK_Down:
 108                         break;
 109                 case GDK_Escape:
 110                         break;
 111                 }
 112         }
 113
 114         return ret;
 115 }
 116
 117 bool
 118 MidiListEditor::key_release (GdkEventKey* ev)
 119 {
 120         bool ret = false;
 121
 122         switch (ev->keyval) {
 123         case GDK_Delete:
 124                 delete_selected_note ();
 125                 ret = true;
 126                 break;
 127         default:
 128                 break;
 129         }
 130
 131         return ret;
 132 }
 133
 134 void
 135 MidiListEditor::delete_selected_note ()
 136 {
 137         Glib::RefPtr<TreeSelection> selection = view.get_selection();
 138         TreeView::Selection::ListHandle_Path rows = selection->get_selected_rows ();
 139
 140         if (rows.empty()) {
 141                 return;
 142         }
 143
 144         TreeView::Selection::ListHandle_Path::iterator i = rows.begin();
 145         TreeIter iter;
 146
 147         /* selection mode is single, so rows.begin() is it */
 148
 149         if ((iter = model->get_iter (*i))) {
 150                 boost::shared_ptr<NoteType> note = (*iter)[columns._note];
 151                 cerr << "Would have deleted " << *note << endl;
 152         }
 153
 154 }
 155
 156 void
 157 MidiListEditor::editing_started (CellEditable*, const string& path, int colno)
 158 {
 159         _current_edit = path;
 160         cerr << "Now editing " << _current_edit << " Column " << colno << endl;
 161 }
 162
 163 void
 164 MidiListEditor::editing_canceled ()
 165 {
 166         _current_edit = "";
 167 }
 168
 169 void
 170 MidiListEditor::edited (const std::string& path, const std::string& /* text */)
 171 {
 172         TreeModel::iterator iter = model->get_iter (path);
 173
 174         cerr << "Edit at " << path << endl;
 175
 176         if (!iter) {
 177                 return;
 178         }
 179
 180         boost::shared_ptr<NoteType> note = (*iter)[columns._note];
 181
 182         cerr << "Edited " << *note << endl;
 183
 184         redisplay_model ();
 185
 186         /* keep selected row(s), move cursor there, to allow us to continue editing */
 187 }
 188
 189 void
 190 MidiListEditor::redisplay_model ()
 191 {
 192         view.set_model (Glib::RefPtr<Gtk::ListStore>(0));
 193         model->clear ();
 194
 195         if (_session) {
 196
 197                 BeatsFramesConverter conv (_session->tempo_map(), region->position());
 198                 MidiModel::Notes notes = region->midi_source(0)->model()->notes();
 199                 TreeModel::Row row;
 200                 stringstream ss;
 201
 202                 for (MidiModel::Notes::iterator i = notes.begin(); i != notes.end(); ++i) {
 203                         row = *(model->append());
 204                         row[columns.channel] = (*i)->channel() + 1;
 205                         row[columns.note_name] = Evoral::midi_note_name ((*i)->note());
 206                         row[columns.note] = (*i)->note();
 207                         row[columns.velocity] = (*i)->velocity();
 208
 209                         Timecode::BBT_Time bbt;
 210                         double dur;
 211
 212                         _session->tempo_map().bbt_time (conv.to ((*i)->time()), bbt);
 213
 214                         ss.str ("");
 215                         ss << bbt;
 216                         row[columns.start] = ss.str();
 217
 218                         bbt.bars = 0;
 219                         dur = (*i)->end_time() - (*i)->time();
 220                         bbt.beats = floor (dur);
 221                         bbt.ticks = (uint32_t) lrint (fmod (dur, 1.0) * Timecode::BBT_Time::ticks_per_beat);
 222
 223                         _session->tempo_map().bbt_duration_at (region->position(), bbt, 0);
 224
 225                         ss.str ("");
 226                         ss << bbt;
 227                         row[columns.length] = ss.str();
 228
 229                         _session->tempo_map().bbt_time (conv.to ((*i)->end_time()), bbt);
 230
 231                         ss.str ("");
 232                         ss << bbt;
 233                         row[columns.end] = ss.str();
 234
 235                         row[columns._note] = (*i);
 236                 }
 237         }
 238
 239         view.set_model (model);
 240 }