return false;
}
- MidiStreamView *streamview = _region.midi_stream_view();
- static uint8_t drag_delta_note = 0;
- static double drag_delta_x = 0;
- static double last_x, last_y;
- double event_x, event_y, dx, dy;
- bool select_mod;
-
switch (ev->type) {
case GDK_ENTER_NOTIFY:
_region.note_entered(this);
- //_item->grab_focus();
- //show_velocity();
//Keyboard::magic_widget_grab_focus();
break;
if (!selected()) {
hide_velocity();
}
- //_region.get_canvas_group()->grab_focus();
break;
case GDK_BUTTON_PRESS:
- if (ev->button.button == 1) {
- _state = Pressed;
- } else if (ev->button.button == 3) {
+ if (ev->button.button == 3) {
show_channel_selector();
- }
- return true;
-
- case GDK_MOTION_NOTIFY:
- event_x = ev->motion.x;
- event_y = ev->motion.y;
-
- switch (_state) {
- case Pressed: // Drag begin
- if (editor.current_mouse_mode() == Editing::MouseObject && _region.mouse_state() != MidiRegionView::SelectTouchDragging) {
- _item->grab(GDK_POINTER_MOTION_MASK | GDK_BUTTON_RELEASE_MASK,
- Gdk::Cursor(Gdk::FLEUR), ev->motion.time);
- _state = Dragging;
- _item->property_parent().get_value()->w2i(event_x, event_y);
- event_x = _region.snap_to_pixel(event_x);
- last_x = event_x;
- last_y = event_y;
- drag_delta_x = 0;
- drag_delta_note = 0;
- _region.note_selected(this, true);
- }
- return true;
-
- case Dragging: // Drag motion
- if (ev->motion.is_hint) {
- int t_x;
- int t_y;
- GdkModifierType state;
- gdk_window_get_pointer(ev->motion.window, &t_x, &t_y, &state);
- event_x = t_x;
- event_y = t_y;
- }
- _item->property_parent().get_value()->w2i(event_x, event_y);
-
- event_x = _region.snap_to_pixel(event_x);
-
- dx = event_x - last_x;
- dy = event_y - last_y;
- last_x = event_x;
-
- drag_delta_x += dx;
-
- // Snap to note rows
- if (abs(dy) < streamview->note_height()) {
- dy = 0.0;
- } else {
- int8_t this_delta_note;
- if (dy > 0) {
- this_delta_note = (int8_t)ceil(dy / streamview->note_height() / 2.0);
- } else {
- this_delta_note = (int8_t)floor(dy / streamview->note_height() / 2.0);
- }
- drag_delta_note -= this_delta_note;
- dy = streamview->note_height() * this_delta_note;
- last_y = last_y + dy;
- }
-
- _region.move_selection(dx, dy);
-
return true;
- default:
- break;
}
break;
case GDK_BUTTON_RELEASE:
- select_mod = (ev->motion.state & (Keyboard::PrimaryModifier | Keyboard::SecondaryModifier));
- event_x = ev->button.x;
- event_y = ev->button.y;
- _item->property_parent().get_value()->w2i(event_x, event_y);
-
if (ev->button.button == 3) {
return true;
}
-
- switch (_state) {
- case Pressed: // Clicked
- if (editor.current_mouse_mode() == Editing::MouseRange) {
- _state = None;
- if (_selected) {
- _region.note_deselected(this, select_mod);
- } else {
- bool extend = Keyboard::modifier_state_equals (ev->motion.state, Keyboard::TertiaryModifier);
- bool add = Keyboard::modifier_state_equals (ev->motion.state, Keyboard::PrimaryModifier);
-
- if (!extend && !add && _region.selection_size() > 1) {
- _region.unique_select(this);
- } else {
- _region.note_selected (this, (extend ? true : add), extend);
- }
- }
- }
- return true;
-
- case Dragging: // Dropped
- _item->ungrab(ev->button.time);
- _state = None;
- if (_note) {
- _region.note_dropped(this, drag_delta_x, drag_delta_note);
- }
- return true;
- default:
- break;
- }
+ break;
default:
break;
virtual double y2() = 0;
const boost::shared_ptr<NoteType> note() const { return _note; }
+ MidiRegionView& region_view() const { return _region; }
inline static uint32_t meter_style_fill_color(uint8_t vel) {
if (vel < 64) {
bool
CanvasNote::on_event(GdkEvent* ev)
{
- PublicEditor& editor (_region.get_trackview().editor());
-
- if (!editor.internal_editing()) {
- return false;
- }
-
- double event_x;
- static double middle_point, last_x;
- Gdk::Cursor cursor;
- static NoteEnd note_end;
-
- switch (ev->type) {
- case GDK_BUTTON_PRESS:
- if (ev->button.button == 2 ||
- (ev->button.button == 1 && editor.current_mouse_mode() == Editing::MouseTimeFX)) {
- double region_start = _region.get_position_pixels();
- event_x = ev->button.x;
- middle_point = region_start + x1() + (x2() - x1()) / 2.0L;
-
- if (event_x <= middle_point) {
- cursor = Gdk::Cursor(Gdk::LEFT_SIDE);
- note_end = NOTE_ON;
- } else {
- cursor = Gdk::Cursor(Gdk::RIGHT_SIDE);
- note_end = NOTE_OFF;
- }
-
- _item->grab(GDK_POINTER_MOTION_MASK | GDK_BUTTON_RELEASE_MASK, cursor, ev->motion.time);
-
- if (_region.mouse_state() == MidiRegionView::SelectTouchDragging) {
- _note_state = AbsoluteResize;
- } else {
- _note_state = RelativeResize;
- }
-
- _region.note_selected(this, true);
- _region.begin_resizing(note_end);
- last_x = event_x;
-
- return true;
- }
-
- case GDK_MOTION_NOTIFY:
- event_x = ev->motion.x;
-
- if (_note_state == RelativeResize) {
- _region.update_resizing(note_end, event_x - last_x, true);
- last_x = event_x;
- return true;
- }
-
- if (_note_state == AbsoluteResize) {
- _region.update_resizing(note_end, event_x, false);
- return true;
- }
-
- case GDK_BUTTON_RELEASE:
- event_x = ev->button.x;
-
- switch (_note_state) {
- case RelativeResize: // Clicked
- _item->ungrab(ev->button.time);
- _region.commit_resizing(note_end, event_x, true);
- _note_state = None;
- return true;
-
- case AbsoluteResize: // Clicked
- _item->ungrab(ev->button.time);
- _region.commit_resizing(note_end, event_x, false);
- _note_state = None;
- return true;
-
- default:
- return CanvasNoteEvent::on_event(ev);
- }
-
- default:
- return CanvasNoteEvent::on_event(ev);
+ if (!_region.get_trackview().editor().canvas_note_event (ev, this)) {
+ return CanvasNoteEvent::on_event (ev);
+ } else {
+ return true;
}
}
class CanvasNote : public SimpleRect, public CanvasNoteEvent {
public:
- typedef Evoral::Note<double> NoteType;
+ typedef Evoral::Note<Evoral::MusicalTime> NoteType;
double x1() { return property_x1(); }
double y1() { return property_y1(); }
bool on_event(GdkEvent* ev);
- enum NoteEnd {
- NOTE_ON,
- NOTE_OFF
- };
-
- enum NoteState {
- None,
- RelativeResize,
- AbsoluteResize
- };
-
- CanvasNote(
- MidiRegionView& region,
- Group& group,
- const boost::shared_ptr<NoteType> note = boost::shared_ptr<NoteType>())
- : SimpleRect(group), CanvasNoteEvent(region, this, note), _note_state(None)
+ CanvasNote (MidiRegionView& region,
+ Group& group,
+ const boost::shared_ptr<NoteType> note = boost::shared_ptr<NoteType>())
+ : SimpleRect(group), CanvasNoteEvent(region, this, note)
{
}
-
-protected:
- NoteState _note_state;
};
} // namespace Gnome
bool canvas_tempo_marker_event (GdkEvent* event,ArdourCanvas::Item*, TempoMarker*);
bool canvas_meter_marker_event (GdkEvent* event,ArdourCanvas::Item*, MeterMarker*);
bool canvas_automation_track_event(GdkEvent* event, ArdourCanvas::Item*, AutomationTimeAxisView*) ;
+ bool canvas_note_event (GdkEvent* event, ArdourCanvas::Item*);
bool canvas_tempo_bar_event (GdkEvent* event, ArdourCanvas::Item*);
bool canvas_meter_bar_event (GdkEvent* event, ArdourCanvas::Item*);
return typed_event (item, event, NoItem);
}
+bool
+Editor::canvas_note_event (GdkEvent *event, ArdourCanvas::Item* item)
+{
+ if (!internal_editing()) {
+ return false;
+ }
+
+ return typed_event (item, event, NoteItem);
+}
+
bool
Editor::track_canvas_drag_motion (Glib::RefPtr<Gdk::DragContext> const & /*c*/, int x, int y, guint /*time*/)
{
#include "editor_drag.h"
#include "audio_time_axis.h"
#include "midi_time_axis.h"
+#include "canvas-note.h"
using namespace std;
using namespace ARDOUR;
}
}
+NoteResizeDrag::NoteResizeDrag (Editor* e, ArdourCanvas::Item* i)
+ : Drag (e, i)
+ , region (0)
+{
+
+}
+
+void
+NoteResizeDrag::start_grab (GdkEvent* event, Gdk::Cursor *)
+{
+ Gdk::Cursor cursor;
+ ArdourCanvas::CanvasNote* cnote = dynamic_cast<ArdourCanvas::CanvasNote*>(_item);
+
+ Drag::start_grab (event);
+
+ region = &cnote->region_view();
+
+ double region_start = region->get_position_pixels();
+ double middle_point = region_start + cnote->x1() + (cnote->x2() - cnote->x1()) / 2.0L;
+
+ if (_grab_x <= middle_point) {
+ cursor = Gdk::Cursor(Gdk::LEFT_SIDE);
+ at_front = true;
+ } else {
+ cursor = Gdk::Cursor(Gdk::RIGHT_SIDE);
+ at_front = false;
+ }
+
+ _item->grab(GDK_POINTER_MOTION_MASK | GDK_BUTTON_RELEASE_MASK, cursor, event->motion.time);
+
+ if (event->motion.state & Keyboard::PrimaryModifier) {
+ relative = false;
+ } else {
+ relative = true;
+ }
+
+ region->note_selected (cnote, true);
+ region->begin_resizing (at_front);
+}
+
+void
+NoteResizeDrag::motion (GdkEvent* /*event*/, bool first_move)
+{
+ region->update_resizing (at_front, _current_pointer_x - _grab_x, relative);
+}
+
+void
+NoteResizeDrag::finished (GdkEvent* event, bool movement_occurred)
+{
+ region->commit_resizing (at_front, _current_pointer_x - _grab_x, relative);
+}
+
void
RegionGainDrag::motion (GdkEvent* /*event*/, bool)
{
_editor->zoom_rect->hide();
}
+
+NoteDrag::NoteDrag (Editor* e, ArdourCanvas::Item* i)
+ : Drag (e, i)
+{
+ ArdourCanvas::CanvasNote* cnote = dynamic_cast<ArdourCanvas::CanvasNote*>(_item);
+ region = &cnote->region_view();
+}
+
+void
+NoteDrag::start_grab (GdkEvent* event, Gdk::Cursor *)
+{
+ Drag::start_grab (event);
+
+ drag_delta_x = 0;
+ drag_delta_note = 0;
+
+ double event_x;
+ double event_y;
+
+ event_x = _current_pointer_x;
+ event_y = _current_pointer_y;
+
+ _item->property_parent().get_value()->w2i(event_x, event_y);
+
+ last_x = region->snap_to_pixel(event_x);
+ last_y = event_y;
+
+ ArdourCanvas::CanvasNote* cnote = dynamic_cast<ArdourCanvas::CanvasNote*>(_item);
+ region->note_selected (cnote, true);
+}
+
+void
+NoteDrag::motion (GdkEvent* ev, bool)
+{
+ MidiStreamView* streamview = region->midi_stream_view();
+ double event_x;
+ double event_y;
+
+ event_x = _current_pointer_x;
+ event_y = _current_pointer_y;
+
+ _item->property_parent().get_value()->w2i(event_x, event_y);
+
+ event_x = region->snap_to_pixel(event_x);
+
+ double dx = event_x - last_x;
+ double dy = event_y - last_y;
+ last_x = event_x;
+
+ drag_delta_x += dx;
+
+ // Snap to note rows
+
+ if (abs (dy) < streamview->note_height()) {
+ dy = 0.0;
+ } else {
+ int8_t this_delta_note;
+ if (dy > 0) {
+ this_delta_note = (int8_t)ceil(dy / streamview->note_height() / 2.0);
+ } else {
+ this_delta_note = (int8_t)floor(dy / streamview->note_height() / 2.0);
+ }
+ drag_delta_note -= this_delta_note;
+ dy = streamview->note_height() * this_delta_note;
+ last_y = last_y + dy;
+ }
+
+ region->move_selection (dx, dy);
+}
+
+void
+NoteDrag::finished (GdkEvent* ev, bool moved)
+{
+ ArdourCanvas::CanvasNote* cnote = dynamic_cast<ArdourCanvas::CanvasNote*>(_item);
+
+ if (!moved) {
+ if (_editor->current_mouse_mode() == Editing::MouseObject) {
+
+ bool select_mod = (ev->motion.state & (Keyboard::PrimaryModifier | Keyboard::SecondaryModifier));
+
+ if (cnote->selected()) {
+ region->note_deselected (cnote, select_mod);
+ } else {
+ bool extend = Keyboard::modifier_state_equals (ev->button.state, Keyboard::TertiaryModifier);
+ bool add = Keyboard::modifier_state_equals (ev->button.state, Keyboard::PrimaryModifier);
+
+ if (!extend && !add && region->selection_size() > 1) {
+ region->unique_select(cnote);
+ } else {
+ region->note_selected (cnote, (extend ? true : add), extend);
+ }
+ }
+ }
+ } else {
+ region->note_dropped (cnote, drag_delta_x, drag_delta_note);
+ }
+}
TimeAxisView* _dest_trackview;
};
+/** Drags to resize MIDI notes */
+class NoteResizeDrag : public Drag
+{
+public:
+ NoteResizeDrag (Editor *, ArdourCanvas::Item *);
+
+ void start_grab (GdkEvent *, Gdk::Cursor* c = 0);
+ void motion (GdkEvent *, bool);
+ void finished (GdkEvent *, bool);
+
+private:
+ MidiRegionView* region;
+ bool relative;
+ bool at_front;
+};
+
+class NoteDrag : public Drag
+{
+ public:
+ NoteDrag (Editor*, ArdourCanvas::Item*);
+
+ void start_grab (GdkEvent *, Gdk::Cursor* c = 0);
+ void motion (GdkEvent *, bool);
+ void finished (GdkEvent *, bool);
+
+ private:
+ MidiRegionView* region;
+ double last_x;
+ double last_y;
+ double drag_delta_x;
+ double drag_delta_note;
+};
+
/** Drag of region gain */
class RegionGainDrag : public Drag
{
FadeInHandleItem,
FadeOutItem,
FadeOutHandleItem,
-
+ NoteItem,
+
#ifdef WITH_CMT
MarkerViewItem,
MarkerTimeAxisItem,
_drag = new RegionCreateDrag (this, item, clicked_axisview);
_drag->start_grab (event);
return true;
+ case NoteItem:
+ /* Note: we don't get here if not in internal_editing() mode */
+ if (mouse_mode == MouseTimeFX) {
+ assert (_drag == 0);
+ _drag = new NoteResizeDrag (this, item);
+ _drag->start_grab (event);
+ return true;
+ } else if (mouse_mode == MouseObject) {
+ assert (_drag == 0);
+ _drag = new NoteDrag (this, item);
+ _drag->start_grab (event);
+ return true;
+ } else {
+ return false;
+ }
+ break;
default:
return true;
}
// Select drag start
if (_pressed_button == 1 && editor.current_mouse_mode() == MouseObject) {
+ cerr << "MRV start select grab\n";
group->grab(GDK_POINTER_MOTION_MASK | GDK_BUTTON_RELEASE_MASK,
Gdk::Cursor(Gdk::FLEUR), ev->motion.time);
last_x = event_x;
// Add note drag start
} else if (editor.current_mouse_mode() == MouseRange) {
+ cerr << "MRV start note grab\n";
group->grab(GDK_POINTER_MOTION_MASK | GDK_BUTTON_RELEASE_MASK,
Gdk::Cursor(Gdk::FLEUR), ev->motion.time);
last_x = event_x;
}
void
-MidiRegionView::begin_resizing(CanvasNote::NoteEnd note_end)
+MidiRegionView::begin_resizing(bool at_front)
{
_resize_data.clear();
ARDOUR_UI::config()->canvasvar_MidiNoteSelected.get());
resize_data->resize_rect = resize_rect;
-
- if (note_end == CanvasNote::NOTE_ON) {
- resize_data->current_x = note->x1();
- } else { // NOTE_OFF
- resize_data->current_x = note->x2();
- }
-
_resize_data.push_back(resize_data);
}
}
}
void
-MidiRegionView::update_resizing(CanvasNote::NoteEnd note_end, double x, bool relative)
+MidiRegionView::update_resizing (bool at_front, double delta_x, bool relative)
{
for (std::vector<NoteResizeData *>::iterator i = _resize_data.begin(); i != _resize_data.end(); ++i) {
SimpleRect* resize_rect = (*i)->resize_rect;
CanvasNote* canvas_note = (*i)->canvas_note;
-
const double region_start = get_position_pixels();
+ double current_x;
- if (relative) {
- (*i)->current_x = (*i)->current_x + x;
+ if (at_front) {
+ if (relative) {
+ current_x = canvas_note->x1() + delta_x;
+ } else {
+ // x is in track relative, transform it to region relative
+ current_x = delta_x - region_start;
+ }
} else {
- // x is in track relative, transform it to region relative
- (*i)->current_x = x - region_start;
+ if (relative) {
+ current_x = canvas_note->x2() + delta_x;
+ } else {
+ // x is in track relative, transform it to region relative
+ current_x = delta_x - region_start;
+ }
}
-
- double current_x = (*i)->current_x;
-
- if (note_end == CanvasNote::NOTE_ON) {
+
+ if (at_front) {
resize_rect->property_x1() = snap_to_pixel(current_x);
resize_rect->property_x2() = canvas_note->x2();
} else {
}
void
-MidiRegionView::commit_resizing(CanvasNote::NoteEnd note_end, double event_x, bool relative)
+MidiRegionView::commit_resizing (bool at_front, double delta_x, bool relative)
{
- start_delta_command(_("resize notes"));
+ start_diff_command(_("resize notes"));
for (std::vector<NoteResizeData *>::iterator i = _resize_data.begin(); i != _resize_data.end(); ++i) {
CanvasNote* canvas_note = (*i)->canvas_note;
SimpleRect* resize_rect = (*i)->resize_rect;
- double current_x = (*i)->current_x;
- const double position = get_position_pixels();
+ const double region_start = get_position_pixels();
+ double current_x;
- if (!relative) {
- // event_x is in track relative, transform it to region relative
- current_x = event_x - position;
+ if (at_front) {
+ if (relative) {
+ current_x = canvas_note->x1() + delta_x;
+ } else {
+ // x is in track relative, transform it to region relative
+ current_x = delta_x - region_start;
+ }
+ } else {
+ if (relative) {
+ current_x = canvas_note->x2() + delta_x;
+ } else {
+ // x is in track relative, transform it to region relative
+ current_x = delta_x - region_start;
+ }
}
-
- // because snapping works on world coordinates we have to transform current_x
- // to world coordinates before snapping and transform it back afterwards
- nframes64_t current_frame = snap_pixel_to_frame(current_x);
- // transform to region start relative
- current_frame += _region->start();
- const boost::shared_ptr<NoteType> copy(new NoteType(*(canvas_note->note().get())));
+ current_x = snap_pixel_to_frame (current_x);
+ current_x = frames_to_beats (current_x);
- // resize beginning of note
- if (note_end == CanvasNote::NOTE_ON && current_frame < copy->end_time()) {
- delta_remove_note(canvas_note);
- copy->on_event().time() = current_frame;
- delta_add_note(copy, _selection.find(canvas_note) != _selection.end());
+ if (at_front && current_x < canvas_note->note()->end_time()) {
+
+ diff_add_change (canvas_note, MidiModel::DiffCommand::StartTime, current_x);
}
- // resize end of note
- if (note_end == CanvasNote::NOTE_OFF && current_frame > copy->time()) {
- delta_remove_note(canvas_note);
- copy->off_event().time() = current_frame;
- delta_add_note(copy, _selection.find(canvas_note) != _selection.end());
+
+ if (!at_front) {
+ double len = current_x - canvas_note->note()->time();
+
+ if (len > 0) {
+ /* XXX convert to beats */
+ diff_add_change (canvas_note, MidiModel::DiffCommand::Length, len);
+ }
}
delete resize_rect;
}
_resize_data.clear();
- apply_delta();
+ apply_diff();
}
void
/** Begin resizing of some notes.
* Called by CanvasMidiNote when resizing starts.
- * @param note_end which end of the note, NOTE_ON or NOTE_OFF
+ * @param at_front which end of the note (true == note on, false == note off)
*/
- void begin_resizing(ArdourCanvas::CanvasNote::NoteEnd note_end);
+ void begin_resizing(bool at_front);
/** Update resizing notes while user drags.
- * @param note_end which end of the note, NOTE_ON or NOTE_OFF
+ * @param at_front which end of the note (true == note on, false == note off)
* @param x the difference in mouse motion, ie the motion difference if relative=true
* or the absolute mouse position (track-relative) if relative is false
* @param relative true if relative resizing is taking place, false if absolute resizing
*/
- void update_resizing(ArdourCanvas::CanvasNote::NoteEnd note_end, double x, bool relative);
+ void update_resizing(bool at_front, double x, bool relative);
/** Finish resizing notes when the user releases the mouse button.
- * @param note_end which end of the note, NOTE_ON or NOTE_OFF
+ * @param at_front which end of the note (true == note on, false == note off)
* @param event_x the absolute mouse position (track-relative)
* @param relative true if relative resizing is taking place, false if absolute resizing
*/
- void commit_resizing(ArdourCanvas::CanvasNote::NoteEnd note_end, double event_x, bool relative);
+ void commit_resizing(bool at_front, double event_x, bool relative);
/** Adjust the velocity on a note, and the selection if applicable.
* @param velocity the relative or absolute velocity
struct NoteResizeData {
ArdourCanvas::CanvasNote *canvas_note;
ArdourCanvas::SimpleRect *resize_rect;
- double current_x;
};
/** Snap a region relative pixel coordinate to pixel units.
virtual bool canvas_marker_bar_event (GdkEvent* event, ArdourCanvas::Item*) = 0;
virtual bool canvas_range_marker_bar_event (GdkEvent* event, ArdourCanvas::Item*) = 0;
virtual bool canvas_transport_marker_bar_event (GdkEvent* event, ArdourCanvas::Item*) = 0;
+ virtual bool canvas_note_event (GdkEvent* event, ArdourCanvas::Item*) = 0;
#ifdef WITH_CMT
virtual bool canvas_imageframe_item_view_event(GdkEvent* event, ArdourCanvas::Item*,ImageFrameView*) = 0;
projects / ardour.git / commitdiff