gtk2_ardour/canvas-note-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-note-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 CanvasNoteEvent::CanvasNoteEvent(MidiRegionView& region, Item* item,
  35                 const boost::shared_ptr<ARDOUR::Note> note)
  36         : _region(region)
  37         , _item(item)
  38         , _text(0)
  39         , _channel_selector_widget()
  40         , _state(None)
  41         , _note(note)
  42         , _selected(false)
  43 {
  44 }
  45
  46 CanvasNoteEvent::~CanvasNoteEvent()
  47 {
  48         if (_text)
  49                 delete _text;
  50
  51         if (_channel_selector_widget)
  52                 delete _channel_selector_widget;
  53 }
  54
  55 void
  56 CanvasNoteEvent::move_event(double dx, double dy)
  57 {
  58         _item->move(dx, dy);
  59         if (_text)
  60                 _text->move(dx, dy);
  61 }
  62
  63 void
  64 CanvasNoteEvent::show_velocity(void)
  65 {
  66         _text = new Text(*(_item->property_parent()));
  67         _text->property_x() = (x1() + x2()) /2;
  68         _text->property_y() = (y1() + y2()) /2;
  69         ostringstream velo(ios::ate);
  70         velo << int(_note->velocity());
  71         _text->property_text() = velo.str();
  72         _text->property_justification() = Gtk::JUSTIFY_CENTER;
  73         _text->property_fill_color_rgba() = ARDOUR_UI::config()->canvasvar_MidiNoteSelectedOutline.get();
  74         _text->show();
  75         _text->lower_to_bottom();
  76         _text->raise(2);
  77 }
  78
  79 void
  80 CanvasNoteEvent::hide_velocity(void)
  81 {
  82         delete _text;
  83         _text = NULL;
  84 }
  85
  86 void
  87 CanvasNoteEvent::on_channel_selection_change(uint16_t selection)
  88 {
  89         // make note change its color if its channel is not marked active
  90         if ( (selection & (1 << _note->channel())) == 0 ) {
  91                 set_fill_color(ARDOUR_UI::config()->canvasvar_MidiNoteFillInactiveChannel.get());
  92                 set_outline_color(ARDOUR_UI::config()->canvasvar_MidiNoteOutlineInactiveChannel.get());
  93         } else {
  94                 set_fill_color(note_fill_color(_note->velocity()));
  95                 set_outline_color(note_outline_color(_note->velocity()));
  96         }
  97         // this forces the item to update..... maybe slow...
  98         _item->hide();
  99         _item->show();
 100 }
 101
 102 void
 103 CanvasNoteEvent::on_channel_change(uint8_t channel)
 104 {
 105         _region.note_selected(this, true);
 106         hide_channel_selector();
 107         _region.change_channel(channel);
 108 }
 109
 110 void
 111 CanvasNoteEvent::show_channel_selector(void)
 112 {
 113         if (_channel_selector_widget == 0) {
 114                 cerr << "Note has channel: " << int(_note->channel()) << endl;
 115                 SingleMidiChannelSelector* _channel_selector = new SingleMidiChannelSelector(_note->channel());
 116                 _channel_selector->show_all();
 117                 _channel_selector->channel_selected.connect(
 118                         sigc::mem_fun(this, &CanvasNoteEvent::on_channel_change));
 119
 120                 _channel_selector_widget =
 121                         new Widget(*(_item->property_parent()),
 122                                    x1(),
 123                                    y2() + 2,
 124                                    (Gtk::Widget &) *_channel_selector);
 125
 126                 _channel_selector_widget->hide();
 127                 _channel_selector_widget->property_height() = 100;
 128                 _channel_selector_widget->property_width() = 100;
 129                 _channel_selector_widget->raise_to_top();
 130                 _channel_selector_widget->show();
 131         } else {
 132                 hide_channel_selector();
 133         }
 134 }
 135
 136 void
 137 CanvasNoteEvent::hide_channel_selector(void)
 138 {
 139         if (_channel_selector_widget) {
 140                 _channel_selector_widget->hide();
 141                 delete _channel_selector_widget;
 142                 _channel_selector_widget = 0;
 143         }
 144 }
 145
 146 void
 147 CanvasNoteEvent::selected(bool yn)
 148 {
 149         if (!_note) {
 150                 return;
 151         } else if (yn) {
 152                 set_fill_color(UINT_INTERPOLATE(note_fill_color(_note->velocity()),
 153                                         ARDOUR_UI::config()->canvasvar_MidiNoteSelectedOutline.get(), 0.1));
 154                 set_outline_color(ARDOUR_UI::config()->canvasvar_MidiNoteSelectedOutline.get());
 155                 show_velocity();
 156         } else {
 157                 set_fill_color(note_fill_color(_note->velocity()));
 158                 set_outline_color(note_outline_color(_note->velocity()));
 159                 hide_velocity();
 160         }
 161
 162         _selected = yn;
 163 }
 164
 165
 166 bool
 167 CanvasNoteEvent::on_event(GdkEvent* ev)
 168 {
 169         MidiStreamView *streamview = _region.midi_stream_view();
 170         static uint8_t drag_delta_note = 0;
 171         static double  drag_delta_x = 0;
 172         static double last_x, last_y;
 173         double event_x, event_y, dx, dy;
 174         bool select_mod;
 175         uint8_t d_velocity = 10;
 176
 177         if (_region.get_time_axis_view().editor.current_mouse_mode() != Editing::MouseNote)
 178                 return false;
 179
 180         switch (ev->type) {
 181         case GDK_SCROLL:
 182                 if (Keyboard::modifier_state_equals (ev->scroll.state, Keyboard::Level4Modifier)) {
 183                         d_velocity = 1;
 184                 }
 185
 186                 if (ev->scroll.direction == GDK_SCROLL_UP) {
 187                         _region.note_selected(this, true);
 188                         if (_region.mouse_state() == MidiRegionView::SelectTouchDragging) {
 189                                 // TODO: absolute velocity
 190                         } else {
 191                                 _region.change_velocity(d_velocity, true);
 192                         }
 193                         return true;
 194                 } else if (ev->scroll.direction == GDK_SCROLL_DOWN) {
 195                         _region.note_selected(this, true);
 196                         if (_region.mouse_state() == MidiRegionView::SelectTouchDragging) {
 197                                 // TODO: absolute velocity
 198                         } else {
 199                                 _region.change_velocity(-d_velocity, true);
 200                         }
 201                         return true;
 202                 } else {
 203                         return false;
 204                 }
 205
 206         case GDK_KEY_PRESS:
 207                 if (_note && ev->key.keyval == GDK_Delete) {
 208                         selected(true);
 209                         _region.start_delta_command();
 210                         _region.command_remove_note(this);
 211                 }
 212                 break;
 213
 214         case GDK_KEY_RELEASE:
 215                 if (ev->key.keyval == GDK_Delete) {
 216                         _region.apply_command();
 217                 }
 218                 break;
 219
 220         case GDK_ENTER_NOTIFY:
 221                 _region.note_entered(this);
 222                 _item->grab_focus();
 223                 show_velocity();
 224                 Keyboard::magic_widget_grab_focus();
 225                 break;
 226
 227         case GDK_LEAVE_NOTIFY:
 228                 Keyboard::magic_widget_drop_focus();
 229                 if (! selected()) {
 230                         hide_velocity();
 231                 }
 232                 _region.get_canvas_group()->grab_focus();
 233                 break;
 234
 235         case GDK_BUTTON_PRESS:
 236                 if (ev->button.button == 1) {
 237                         _state = Pressed;
 238                 } else if (ev->button.button == 3) {
 239                         show_channel_selector();
 240                 }
 241                 return true;
 242
 243         case GDK_MOTION_NOTIFY:
 244                 event_x = ev->motion.x;
 245                 event_y = ev->motion.y;
 246
 247                 switch (_state) {
 248                 case Pressed: // Drag begin
 249                         if (_region.mouse_state() != MidiRegionView::SelectTouchDragging) {
 250                                 _item->grab(GDK_POINTER_MOTION_MASK | GDK_BUTTON_RELEASE_MASK,
 251                                                 Gdk::Cursor(Gdk::FLEUR), ev->motion.time);
 252                                 _state = Dragging;
 253                                 _item->property_parent().get_value()->w2i(event_x, event_y);
 254                                 event_x = _region.snap_to_pixel(event_x);
 255                                 last_x = event_x;
 256                                 last_y = event_y;
 257                                 drag_delta_x = 0;
 258                                 drag_delta_note = 0;
 259                                 _region.note_selected(this, true);
 260                         }
 261                         return true;
 262
 263                 case Dragging: // Drag motion
 264                         if (ev->motion.is_hint) {
 265                                 int t_x;
 266                                 int t_y;
 267                                 GdkModifierType state;
 268                                 gdk_window_get_pointer(ev->motion.window, &t_x, &t_y, &state);
 269                                 event_x = t_x;
 270                                 event_y = t_y;
 271                         }
 272                         _item->property_parent().get_value()->w2i(event_x, event_y);
 273
 274                         // Snap
 275                         event_x = _region.snap_to_pixel(event_x);
 276
 277                         dx = event_x - last_x;
 278                         dy = event_y - last_y;
 279
 280                         last_x = event_x;
 281
 282                         drag_delta_x += dx;
 283
 284                         // Snap to note rows
 285                         if (abs(dy) < streamview->note_height()) {
 286                                 dy = 0.0;
 287                         } else {
 288                                 int8_t this_delta_note;
 289                                 if (dy > 0) {
 290                                         this_delta_note = (int8_t)ceil(dy / streamview->note_height() / 2.0);
 291                                 } else {
 292                                         this_delta_note = (int8_t)floor(dy / streamview->note_height() / 2.0);
 293                                 }
 294                                 drag_delta_note -= this_delta_note;
 295                                 dy = streamview->note_height() * this_delta_note;
 296                                 last_y = last_y + dy;
 297                         }
 298
 299                         _region.move_selection(dx, dy);
 300
 301                         return true;
 302                 default:
 303                         break;
 304                 }
 305                 break;
 306
 307         case GDK_BUTTON_RELEASE:
 308                 select_mod = (ev->motion.state & (GDK_CONTROL_MASK | GDK_SHIFT_MASK));
 309                 event_x = ev->button.x;
 310                 event_y = ev->button.y;
 311                 _item->property_parent().get_value()->w2i(event_x, event_y);
 312
 313                 if (ev->button.button == 3) {
 314                         return true;
 315                 }
 316
 317                 switch (_state) {
 318                 case Pressed: // Clicked
 319                         if (_region.midi_view()->editor.current_midi_edit_mode() == Editing::MidiEditSelect) {
 320                                 _state = None;
 321
 322                                 if (_selected && !select_mod && _region.selection_size() > 1)
 323                                         _region.unique_select(this);
 324                                 else if (_selected)
 325                                         _region.note_deselected(this, select_mod);
 326                                 else
 327                                         _region.note_selected(this, select_mod);
 328                         } else if (_region.midi_view()->editor.current_midi_edit_mode() == Editing::MidiEditErase) {
 329                                 _region.start_delta_command();
 330                                 _region.command_remove_note(this);
 331                                 _region.apply_command();
 332                         }
 333
 334                         return true;
 335                 case Dragging: // Dropped
 336                         _item->ungrab(ev->button.time);
 337                         _state = None;
 338
 339                         if (_note)
 340                                 _region.note_dropped(this,
 341                                                 _region.midi_view()->editor.pixel_to_frame(abs(drag_delta_x))
 342                                                                 * ((drag_delta_x < 0.0) ? -1 : 1),
 343                                                 drag_delta_note);
 344                         return true;
 345                 default:
 346                         break;
 347                 }
 348
 349         default:
 350                 break;
 351         }
 352
 353         return false;
 354 }
 355
 356 } // namespace Canvas
 357 } // namespace Gnome
 358