gtk2_ardour/canvas-midi-event.cc

   1 /*
   2     Copyright (C) 2007 Paul Davis
   3     Author: Dave Robillard
   4
   5     This program is free software; you can redistribute it and/or modify
   6     it under the terms of the GNU General Public License as published by
   7     the Free Software Foundation; either version 2 of the License, or
   8     (at your option) any later version.
   9
  10     This program is distributed in the hope that it will be useful,
  11     but WITHOUT ANY WARRANTY; without even the implied warranty of
  12     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13     GNU General Public License for more details.
  14
  15     You should have received a copy of the GNU General Public License
  16     along with this program; if not, write to the Free Software
  17     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  18 */
  19
  20 #include <iostream>
  21 #include "canvas-midi-event.h"
  22 #include "midi_region_view.h"
  23 #include "public_editor.h"
  24 #include "editing_syms.h"
  25 #include "keyboard.h"
  26
  27 using namespace std;
  28 using ARDOUR::MidiModel;
  29
  30 namespace Gnome {
  31 namespace Canvas {
  32
  33
  34 CanvasMidiEvent::CanvasMidiEvent(MidiRegionView& region, Item* item, const ARDOUR::MidiModel::Note* note)
  35         : _region(region)
  36         , _item(item)
  37         , _state(None)
  38         , _note(note)
  39         , _selected(false)
  40 {
  41 }
  42
  43 void
  44 CanvasMidiEvent::selected(bool yn)
  45 {
  46         if (!_note) {
  47                 return;
  48         } else if (yn) {
  49                 set_fill_color(UINT_INTERPOLATE(note_fill_color(_note->velocity()),
  50                                         ARDOUR_UI::config()->canvasvar_MidiNoteSelectedOutline.get(), 0.85));
  51                 set_outline_color(ARDOUR_UI::config()->canvasvar_MidiNoteSelectedOutline.get());
  52         } else {
  53                 set_fill_color(note_fill_color(_note->velocity()));
  54                 set_outline_color(note_outline_color(_note->velocity()));
  55         }
  56
  57         _selected = yn;
  58 }
  59
  60
  61 bool
  62 CanvasMidiEvent::on_event(GdkEvent* ev)
  63 {
  64         static uint8_t drag_delta_note = 0;
  65         static double  drag_delta_x = 0;
  66         static double last_x, last_y;
  67         double event_x, event_y, dx, dy;
  68         nframes_t event_frame;
  69         bool select_mod = false;
  70
  71         if (_region.get_time_axis_view().editor.current_mouse_mode() != Editing::MouseNote)
  72                 return false;
  73
  74         switch (ev->type) {
  75         case GDK_KEY_PRESS:
  76                 cerr << "EV KEY\n";
  77                 if (_note && ev->key.keyval == GDK_Delete) {
  78                         cerr << "EV DELETE KEY\n";
  79                         selected(true);
  80                         _region.start_remove_command();
  81                         _region.command_remove_note(this);
  82                 }
  83                 break;
  84
  85         case GDK_KEY_RELEASE:
  86                 if (ev->key.keyval == GDK_Delete) {
  87                         _region.apply_command();
  88                 }
  89                 break;
  90
  91         case GDK_ENTER_NOTIFY:
  92                 select_mod = (ev->motion.state & (GDK_CONTROL_MASK | GDK_SHIFT_MASK));
  93                 cerr << "ENTER: " << select_mod << " - " << ev->motion.state << endl;
  94                 if (select_mod) {
  95                         _region.note_selected(this, true);
  96                 }
  97                 _item->grab_focus();
  98                 Keyboard::magic_widget_grab_focus();
  99                 _region.note_entered(this);
 100                 break;
 101
 102         case GDK_LEAVE_NOTIFY:
 103                 Keyboard::magic_widget_drop_focus();
 104                 _region.get_canvas_group()->grab_focus();
 105                 break;
 106
 107         case GDK_BUTTON_PRESS:
 108                 _state = Pressed;
 109                 return true;
 110
 111         case GDK_MOTION_NOTIFY:
 112                 select_mod = (ev->motion.state & (GDK_CONTROL_MASK | GDK_SHIFT_MASK));
 113                 event_x = ev->motion.x;
 114                 event_y = ev->motion.y;
 115                 //cerr << "MOTION @ " << event_x << ", " << event_y << endl;
 116                 _item->property_parent().get_value()->w2i(event_x, event_y);
 117
 118                 switch (_state) {
 119                 case Pressed: // Drag begin
 120                         if (!select_mod) {
 121                                 _item->grab(GDK_POINTER_MOTION_MASK | GDK_BUTTON_RELEASE_MASK,
 122                                                 Gdk::Cursor(Gdk::FLEUR), ev->motion.time);
 123                                 _state = Dragging;
 124                                 last_x = event_x;
 125                                 last_y = event_y;
 126                                 drag_delta_x = 0;
 127                                 drag_delta_note = 0;
 128                                 _region.note_selected(this, true);
 129                         }
 130                         return true;
 131
 132                 case Dragging: // Drag motion
 133                         if (ev->motion.is_hint) {
 134                                 int t_x;
 135                                 int t_y;
 136                                 GdkModifierType state;
 137                                 gdk_window_get_pointer(ev->motion.window, &t_x, &t_y, &state);
 138                                 event_x = t_x;
 139                                 event_y = t_y;
 140                         }
 141
 142                         // Snap
 143                         event_frame = _region.midi_view()->editor.pixel_to_frame(event_x);
 144                         _region.midi_view()->editor.snap_to(event_frame);
 145                         event_x = _region.midi_view()->editor.frame_to_pixel(event_frame);
 146
 147                         dx = event_x - last_x;
 148                         dy = event_y - last_y;
 149
 150                         last_x = event_x;
 151
 152                         drag_delta_x += dx;
 153
 154                         // Snap to note rows
 155                         if (abs(dy) < _region.midi_stream_view()->note_height()) {
 156                                 dy = 0.0;
 157                         } else {
 158                                 int8_t this_delta_note;
 159                                 if (dy > 0)
 160                                         this_delta_note = (int8_t)ceil(dy / _region.midi_stream_view()->note_height() / 2.0);
 161                                 else
 162                                         this_delta_note = (int8_t)floor(dy / _region.midi_stream_view()->note_height() / 2.0);
 163                                 drag_delta_note -= this_delta_note;
 164                                 dy = _region.midi_stream_view()->note_height() * this_delta_note;
 165                                 last_y = last_y + dy;
 166                         }
 167
 168                         _region.move_selection(dx, dy);
 169
 170                         return true;
 171                 default:
 172                         break;
 173                 }
 174                 break;
 175
 176         case GDK_BUTTON_RELEASE:
 177                 select_mod = (ev->motion.state & (GDK_CONTROL_MASK | GDK_SHIFT_MASK));
 178                 event_x = ev->button.x;
 179                 event_y = ev->button.y;
 180                 _item->property_parent().get_value()->w2i(event_x, event_y);
 181
 182                 switch (_state) {
 183                 case Pressed: // Clicked
 184                         if (_region.midi_view()->editor.current_midi_edit_mode() == Editing::MidiEditSelect) {
 185                                 _state = None;
 186
 187                                 if (_selected && !select_mod && _region.selection_size() > 1)
 188                                         _region.unique_select(this);
 189                                 else if (_selected)
 190                                         _region.note_deselected(this, select_mod);
 191                                 else
 192                                         _region.note_selected(this, select_mod);
 193                         } else if (_region.midi_view()->editor.current_midi_edit_mode() == Editing::MidiEditErase) {
 194                                 _region.start_remove_command();
 195                                 _region.command_remove_note(this);
 196                                 _region.apply_command();
 197                         }
 198
 199                         return true;
 200                 case Dragging: // Dropped
 201                         _item->ungrab(ev->button.time);
 202                         _state = None;
 203
 204                         if (_note)
 205                                 _region.note_dropped(this,
 206                                                 _region.midi_view()->editor.pixel_to_frame(abs(drag_delta_x))
 207                                                                 * ((drag_delta_x < 0.0) ? -1 : 1),
 208                                                 drag_delta_note);
 209                         return true;
 210                 default:
 211                         break;
 212                 }
 213
 214         default:
 215                 break;
 216         }
 217
 218         return false;
 219 }
 220
 221 } // namespace Canvas
 222 } // namespace Gnome
 223