X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=gtk2_ardour%2Feditor_mouse.cc;h=b2ee2777cfea9845f34853fa41a7eef478f76f88;hb=dd8c5f9144470433bbedf932fcff65fc9630402b;hp=f2d49fa1d711ce812f303b97bb75a697b2174777;hpb=94e069b14a904093fc846de1b4d4c3bd62440d64;p=ardour.git diff --git a/gtk2_ardour/editor_mouse.cc b/gtk2_ardour/editor_mouse.cc index f2d49fa1d7..b2ee2777cf 100644 --- a/gtk2_ardour/editor_mouse.cc +++ b/gtk2_ardour/editor_mouse.cc @@ -24,18 +24,31 @@ #include #include #include +#include #include "pbd/error.h" #include "pbd/enumwriter.h" -#include -#include #include "pbd/memento_command.h" #include "pbd/basename.h" #include "pbd/stateful_diff_command.h" +#include "gtkmm2ext/bindings.h" +#include "gtkmm2ext/utils.h" +#include "gtkmm2ext/tearoff.h" + +#include "canvas/canvas.h" + +#include "ardour/audioregion.h" +#include "ardour/operations.h" +#include "ardour/playlist.h" +#include "ardour/profile.h" +#include "ardour/region_factory.h" +#include "ardour/route.h" +#include "ardour/session.h" +#include "ardour/types.h" + #include "ardour_ui.h" #include "actions.h" -#include "canvas-note.h" #include "editor.h" #include "time_axis_view.h" #include "audio_time_axis.h" @@ -56,24 +69,10 @@ #include "editor_drag.h" #include "automation_region_view.h" #include "edit_note_dialog.h" - -#include "ardour/types.h" -#include "ardour/profile.h" -#include "ardour/route.h" -#include "ardour/audio_track.h" -#include "ardour/audio_diskstream.h" -#include "ardour/midi_diskstream.h" -#include "ardour/playlist.h" -#include "ardour/audioplaylist.h" -#include "ardour/audioregion.h" -#include "ardour/midi_region.h" -#include "ardour/dB.h" -#include "ardour/utils.h" -#include "ardour/region_factory.h" -#include "ardour/source_factory.h" -#include "ardour/session.h" - -#include +#include "mouse_cursors.h" +#include "editor_cursors.h" +#include "verbose_cursor.h" +#include "note.h" #include "i18n.h" @@ -87,104 +86,128 @@ using Gtkmm2ext::Keyboard; bool Editor::mouse_frame (framepos_t& where, bool& in_track_canvas) const { + /* gdk_window_get_pointer() has X11's XQueryPointer semantics in that it only + pays attentions to subwindows. this means that menu windows are ignored, and + if the pointer is in a menu, the return window from the call will be the + the regular subwindow *under* the menu. + + this matters quite a lot if the pointer is moving around in a menu that overlaps + the track canvas because we will believe that we are within the track canvas + when we are not. therefore, we track enter/leave events for the track canvas + and allow that to override the result of gdk_window_get_pointer(). + */ + + if (!within_track_canvas) { + return false; + } + int x, y; - double wx, wy; - Gdk::ModifierType mask; - Glib::RefPtr canvas_window = const_cast(this)->track_canvas->get_window(); - Glib::RefPtr pointer_window; + Glib::RefPtr canvas_window = const_cast(this)->_track_canvas->get_window(); if (!canvas_window) { return false; } - pointer_window = canvas_window->get_pointer (x, y, mask); + Glib::RefPtr pointer_window = Gdk::Display::get_default()->get_window_at_pointer (x, y); - if (pointer_window == track_canvas->get_bin_window()) { - wx = x; - wy = y; - in_track_canvas = true; + if (!pointer_window) { + return false; + } - } else { + if (pointer_window != canvas_window && pointer_window != _time_bars_canvas->get_window()) { in_track_canvas = false; - return false; + return false; } + in_track_canvas = true; + GdkEvent event; event.type = GDK_BUTTON_RELEASE; - event.button.x = wx; - event.button.y = wy; + event.button.x = x; + event.button.y = y; + + where = window_event_frame (&event, 0, 0); - where = event_frame (&event, 0, 0); return true; } framepos_t -Editor::event_frame (GdkEvent const * event, double* pcx, double* pcy) const +Editor::window_event_frame (GdkEvent const * event, double* pcx, double* pcy) const { - double cx, cy; + double x; + double y; - if (pcx == 0) { - pcx = &cx; + if (!gdk_event_get_coords (event, &x, &y)) { + return 0; } - if (pcy == 0) { - pcy = &cy; + + /* event coordinates are in window units, so convert to canvas + * (i.e. account for scrolling) + */ + + ArdourCanvas::Duple d = _track_canvas->window_to_canvas (ArdourCanvas::Duple (x, y)); + + if (pcx) { + *pcx = d.x; } - *pcx = 0; - *pcy = 0; + if (pcy) { + *pcy = d.y; + } - switch (event->type) { - case GDK_BUTTON_RELEASE: - case GDK_BUTTON_PRESS: - case GDK_2BUTTON_PRESS: - case GDK_3BUTTON_PRESS: - *pcx = event->button.x; - *pcy = event->button.y; - _trackview_group->w2i(*pcx, *pcy); - break; - case GDK_MOTION_NOTIFY: - *pcx = event->motion.x; - *pcy = event->motion.y; - _trackview_group->w2i(*pcx, *pcy); - break; - case GDK_ENTER_NOTIFY: - case GDK_LEAVE_NOTIFY: - track_canvas->w2c(event->crossing.x, event->crossing.y, *pcx, *pcy); - break; - case GDK_KEY_PRESS: - case GDK_KEY_RELEASE: - // track_canvas->w2c(event->key.x, event->key.y, *pcx, *pcy); - break; - default: - warning << string_compose (_("Editor::event_frame() used on unhandled event type %1"), event->type) << endmsg; - break; + return pixel_to_sample (d.x); +} + +framepos_t +Editor::canvas_event_frame (GdkEvent const * event, double* pcx, double* pcy) const +{ + double x; + double y; + + /* event coordinates are already in canvas units */ + + if (!gdk_event_get_coords (event, &x, &y)) { + cerr << "!NO c COORDS for event type " << event->type << endl; + return 0; + } + + if (pcx) { + *pcx = x; + } + + if (pcy) { + *pcy = y; } - /* note that pixel_to_frame() never returns less than zero, so even if the pixel + /* note that pixel_to_sample() never returns less than zero, so even if the pixel position is negative (as can be the case with motion events in particular), the frame location is always positive. */ - return pixel_to_frame (*pcx); + return pixel_to_sample (x); } Gdk::Cursor* Editor::which_grabber_cursor () { - Gdk::Cursor* c = grabber_cursor; + Gdk::Cursor* c = _cursors->grabber; if (_internal_editing) { switch (mouse_mode) { - case MouseRange: - c = midi_pencil_cursor; + case MouseDraw: + c = _cursors->midi_pencil; break; case MouseObject: - c = grabber_note_cursor; + c = _cursors->grabber_note; break; case MouseTimeFX: - c = midi_resize_cursor; + c = _cursors->midi_resize; + break; + + case MouseRange: + c = _cursors->grabber_note; break; default: @@ -195,13 +218,13 @@ Editor::which_grabber_cursor () switch (_edit_point) { case EditAtMouse: - c = grabber_edit_point_cursor; + c = _cursors->grabber_edit_point; break; default: - boost::shared_ptr m = _movable.lock(); - if (m && m->locked()) { - c = speaker_cursor; - } + boost::shared_ptr m = _movable.lock(); + if (m && m->locked()) { + c = _cursors->speaker; + } break; } } @@ -212,103 +235,121 @@ Editor::which_grabber_cursor () void Editor::set_current_trimmable (boost::shared_ptr t) { - boost::shared_ptr st = _trimmable.lock(); + boost::shared_ptr st = _trimmable.lock(); - if (!st || st == t) { - _trimmable = t; - set_canvas_cursor (); - } - + if (!st || st == t) { + _trimmable = t; + set_canvas_cursor (); + } } void Editor::set_current_movable (boost::shared_ptr m) { - boost::shared_ptr sm = _movable.lock(); + boost::shared_ptr sm = _movable.lock(); - if (!sm || sm != m) { - _movable = m; - set_canvas_cursor (); - } + if (!sm || sm != m) { + _movable = m; + set_canvas_cursor (); + } } void Editor::set_canvas_cursor () { - if (_internal_editing) { - - switch (mouse_mode) { - case MouseRange: - current_canvas_cursor = midi_pencil_cursor; - break; - - case MouseObject: + switch (mouse_mode) { + case MouseRange: + current_canvas_cursor = _cursors->selector; + if (_internal_editing) { current_canvas_cursor = which_grabber_cursor(); - break; + } + break; - case MouseTimeFX: - current_canvas_cursor = midi_resize_cursor; - break; + case MouseObject: + current_canvas_cursor = which_grabber_cursor(); + break; - default: - return; - } + case MouseDraw: + current_canvas_cursor = _cursors->midi_pencil; + break; - } else { + case MouseGain: + current_canvas_cursor = _cursors->cross_hair; + break; - switch (mouse_mode) { - case MouseRange: - current_canvas_cursor = selector_cursor; - break; + case MouseZoom: + if (Keyboard::the_keyboard().key_is_down (GDK_Control_L)) { + current_canvas_cursor = _cursors->zoom_out; + } else { + current_canvas_cursor = _cursors->zoom_in; + } + break; - case MouseObject: - current_canvas_cursor = which_grabber_cursor(); - break; + case MouseTimeFX: + current_canvas_cursor = _cursors->time_fx; // just use playhead + break; - case MouseGain: - current_canvas_cursor = cross_hair_cursor; - break; + case MouseAudition: + current_canvas_cursor = _cursors->speaker; + break; + } - case MouseZoom: - if (Keyboard::the_keyboard().key_is_down (GDK_Control_L)) { - current_canvas_cursor = zoom_out_cursor; - } else { - current_canvas_cursor = zoom_in_cursor; - } + if (!_internal_editing) { + switch (_join_object_range_state) { + case JOIN_OBJECT_RANGE_NONE: break; - - case MouseTimeFX: - current_canvas_cursor = time_fx_cursor; // just use playhead + case JOIN_OBJECT_RANGE_OBJECT: + current_canvas_cursor = which_grabber_cursor (); break; - - case MouseAudition: - current_canvas_cursor = speaker_cursor; + case JOIN_OBJECT_RANGE_RANGE: + current_canvas_cursor = _cursors->selector; break; } } - switch (_join_object_range_state) { - case JOIN_OBJECT_RANGE_NONE: - break; - case JOIN_OBJECT_RANGE_OBJECT: - current_canvas_cursor = which_grabber_cursor (); - break; - case JOIN_OBJECT_RANGE_RANGE: - current_canvas_cursor = selector_cursor; - break; - } - /* up-down cursor as a cue that automation can be dragged up and down when in join object/range mode */ - if (join_object_range_button.get_active() && last_item_entered) { - if (last_item_entered->property_parent() && (*last_item_entered->property_parent()).get_data (X_("timeselection"))) { - pair tvp = trackview_by_y_position (_last_motion_y + vertical_adjustment.get_value() - canvas_timebars_vsize); - if (dynamic_cast (tvp.first)) { - current_canvas_cursor = up_down_cursor; + if (!_internal_editing && get_smart_mode() ) { + + double x, y; + get_pointer_position (x, y); + + if (x >= 0 && y >= 0) { + + vector items; + + _track_canvas->root()->add_items_at_point (ArdourCanvas::Duple (x,y), items); + + // first item will be the upper most + + if (!items.empty()) { + const ArdourCanvas::Item* i = items.front(); + + if (i && i->parent() && i->parent()->get_data (X_("timeselection"))) { + pair tvp = trackview_by_y_position (_last_motion_y); + if (dynamic_cast (tvp.first)) { + current_canvas_cursor = _cursors->up_down; + } + } } } } - set_canvas_cursor (current_canvas_cursor, true); + set_canvas_cursor (current_canvas_cursor, true); +} + +void +Editor::mouse_mode_object_range_toggled() +{ + MouseMode m = mouse_mode; + + Glib::RefPtr act = ActionManager::get_action (X_("MouseMode"), X_("set-mouse-mode-range")); + assert (act); + Glib::RefPtr tact = Glib::RefPtr::cast_dynamic (act); + assert (tact); + if (tact->get_active()) + m = MouseObject; //Smart mode turned to ON, force editing to Object mode + + set_mouse_mode(m, true); //call this so the button styles can get updated } void @@ -333,6 +374,10 @@ Editor::set_mouse_mode (MouseMode m, bool force) act = ActionManager::get_action (X_("MouseMode"), X_("set-mouse-mode-object")); break; + case MouseDraw: + act = ActionManager::get_action (X_("MouseMode"), X_("set-mouse-mode-draw")); + break; + case MouseGain: act = ActionManager::get_action (X_("MouseMode"), X_("set-mouse-mode-gain")); break; @@ -358,42 +403,102 @@ Editor::set_mouse_mode (MouseMode m, bool force) /* go there and back to ensure that the toggled handler is called to set up mouse_mode */ tact->set_active (false); tact->set_active (true); + + //NOTE: this will result in a call to mouse_mode_toggled which does the heavy lifting } void Editor::mouse_mode_toggled (MouseMode m) { + Glib::RefPtr act; + Glib::RefPtr tact; + + switch (m) { + case MouseRange: + act = ActionManager::get_action (X_("MouseMode"), X_("set-mouse-mode-range")); + break; + + case MouseObject: + act = ActionManager::get_action (X_("MouseMode"), X_("set-mouse-mode-object")); + break; + + case MouseDraw: + act = ActionManager::get_action (X_("MouseMode"), X_("set-mouse-mode-draw")); + break; + + case MouseGain: + act = ActionManager::get_action (X_("MouseMode"), X_("set-mouse-mode-gain")); + break; + + case MouseZoom: + act = ActionManager::get_action (X_("MouseMode"), X_("set-mouse-mode-zoom")); + break; + + case MouseTimeFX: + act = ActionManager::get_action (X_("MouseMode"), X_("set-mouse-mode-timefx")); + break; + + case MouseAudition: + act = ActionManager::get_action (X_("MouseMode"), X_("set-mouse-mode-audition")); + break; + } + + assert (act); + + tact = Glib::RefPtr::cast_dynamic (act); + assert (tact); + + if (!tact->get_active()) { + /* this was just the notification that the old mode has been + * left. we'll get called again with the new mode active in a + * jiffy. + */ + return; + } + + switch (m) { + case MouseDraw: + act = ActionManager::get_action (X_("MouseMode"), X_("toggle-internal-edit")); + tact = Glib::RefPtr::cast_dynamic(act); + tact->set_active (true); + break; + default: + break; + } + + if (_session && mouse_mode == MouseAudition) { + /* stop transport and reset default speed to avoid oddness with + auditioning */ + _session->request_transport_speed (0.0, true); + } + mouse_mode = m; instant_save (); - - if (!internal_editing()) { - if (mouse_mode != MouseRange && _join_object_range_state == JOIN_OBJECT_RANGE_NONE) { - - /* in all modes except range and joined object/range, hide the range selection, - show the object (region) selection. - */ - - for (RegionSelection::iterator i = selection->regions.begin(); i != selection->regions.end(); ++i) { - (*i)->set_should_show_selection (true); - } - for (TrackViewList::iterator i = track_views.begin(); i != track_views.end(); ++i) { - (*i)->hide_selection (); - } - - } else { - - /* - in range or object/range mode, show the range selection. - */ - - for (TrackSelection::iterator i = selection->tracks.begin(); i != selection->tracks.end(); ++i) { - (*i)->show_selection (selection->time); - } - } - } + //TODO: set button styles for smart buttons +/* + if ( smart_mode_action->get_active() ) { + if( mouse_mode == MouseObject ) { //smart active and object active + smart_mode_button.set_active(1); + smart_mode_button.set_name("smart mode button"); + mouse_move_button.set_name("smart mode button"); + } else { //smart active but object inactive + smart_mode_button.set_active(0); + smart_mode_button.set_name("smart mode button"); + mouse_move_button.set_name("mouse mode button"); + } + } else { + smart_mode_button.set_active(0); + smart_mode_button.set_name("mouse mode button"); + mouse_move_button.set_name("mouse mode button"); + } +*/ + set_canvas_cursor (); + set_gain_envelope_visibility (); + + MouseModeChanged (); /* EMIT SIGNAL */ } void @@ -413,10 +518,15 @@ Editor::step_mouse_mode (bool next) break; case MouseRange: - if (next) set_mouse_mode (MouseZoom); + if (next) set_mouse_mode (MouseDraw); else set_mouse_mode (MouseObject); break; + case MouseDraw: + if (next) set_mouse_mode (MouseZoom); + else set_mouse_mode (MouseRange); + break; + case MouseZoom: if (next) { if (Profile->get_sae()) { @@ -428,7 +538,7 @@ Editor::step_mouse_mode (bool next) if (Profile->get_sae()) { set_mouse_mode (MouseObject); } else { - set_mouse_mode (MouseRange); + set_mouse_mode (MouseDraw); } } break; @@ -457,6 +567,22 @@ Editor::step_mouse_mode (bool next) } } +bool +Editor::toggle_internal_editing_from_double_click (GdkEvent* event) +{ + if (_drags->active()) { + _drags->end_grab (event); + } + + ActionManager::do_action ("MouseMode", "toggle-internal-edit"); + + /* prevent reversion of edit cursor on button release */ + + pre_press_cursor = 0; + + return true; +} + void Editor::button_selection (ArdourCanvas::Item* /*item*/, GdkEvent* event, ItemType item_type) { @@ -474,13 +600,12 @@ Editor::button_selection (ArdourCanvas::Item* /*item*/, GdkEvent* event, ItemTyp */ if (((mouse_mode != MouseObject) && - (_join_object_range_state != JOIN_OBJECT_RANGE_OBJECT) && (mouse_mode != MouseAudition || item_type != RegionItem) && (mouse_mode != MouseTimeFX || item_type != RegionItem) && (mouse_mode != MouseGain) && - (mouse_mode != MouseRange)) || + (mouse_mode != MouseDraw)) || ((event->type != GDK_BUTTON_PRESS && event->type != GDK_BUTTON_RELEASE) || event->button.button > 3) || - internal_editing()) { + (internal_editing() && mouse_mode != MouseTimeFX)) { return; } @@ -500,48 +625,58 @@ Editor::button_selection (ArdourCanvas::Item* /*item*/, GdkEvent* event, ItemTyp Selection::Operation op = ArdourKeyboard::selection_type (event->button.state); bool press = (event->type == GDK_BUTTON_PRESS); - // begin_reversible_command (_("select on click")); - switch (item_type) { case RegionItem: - if (mouse_mode != MouseRange || _join_object_range_state == JOIN_OBJECT_RANGE_OBJECT) { - set_selected_regionview_from_click (press, op, true); - } else if (event->type == GDK_BUTTON_PRESS) { - selection->clear_tracks (); - set_selected_track_as_side_effect (op, true); - } - if (_join_object_range_state == JOIN_OBJECT_RANGE_OBJECT && !selection->regions.empty()) { - clicked_selection = select_range_around_region (selection->regions.front()); + if (!get_smart_mode() || (_join_object_range_state != JOIN_OBJECT_RANGE_RANGE)) { + if (press) { + if (mouse_mode != MouseRange) { + set_selected_regionview_from_click (press, op); + } else { + /* don't change the selection unless the + clicked track is not currently selected. if + so, "collapse" the selection to just this + track + */ + if (!selection->selected (clicked_axisview)) { + set_selected_track_as_side_effect (Selection::Set); + } + } + } else { + if (mouse_mode != MouseRange) { + set_selected_regionview_from_click (press, op); + } + } } break; case RegionViewNameHighlight: case RegionViewName: - case LeftFrameHandle: - case RightFrameHandle: - if (mouse_mode != MouseRange || _join_object_range_state == JOIN_OBJECT_RANGE_OBJECT) { - set_selected_regionview_from_click (press, op, true); + case LeftFrameHandle: + case RightFrameHandle: + if ( mouse_mode != MouseRange ) { + set_selected_regionview_from_click (press, op); } else if (event->type == GDK_BUTTON_PRESS) { set_selected_track_as_side_effect (op); } break; - case FadeInHandleItem: case FadeInItem: case FadeOutHandleItem: case FadeOutItem: - if (mouse_mode != MouseRange || _join_object_range_state == JOIN_OBJECT_RANGE_OBJECT) { - set_selected_regionview_from_click (press, op, true); + case StartCrossFadeItem: + case EndCrossFadeItem: + if ( mouse_mode != MouseRange ) { + set_selected_regionview_from_click (press, op); } else if (event->type == GDK_BUTTON_PRESS) { set_selected_track_as_side_effect (op); } break; case ControlPointItem: - set_selected_track_as_side_effect (op, true); - if (mouse_mode != MouseRange || _join_object_range_state == JOIN_OBJECT_RANGE_OBJECT) { - set_selected_control_point_from_click (op, false); + set_selected_track_as_side_effect (op); + if ( mouse_mode != MouseRange ) { + set_selected_control_point_from_click (press, op); } break; @@ -549,12 +684,12 @@ Editor::button_selection (ArdourCanvas::Item* /*item*/, GdkEvent* event, ItemTyp /* for context click, select track */ if (event->button.button == 3) { selection->clear_tracks (); - set_selected_track_as_side_effect (op, true); + set_selected_track_as_side_effect (op); } break; case AutomationTrackItem: - set_selected_track_as_side_effect (op, true); + set_selected_track_as_side_effect (op); break; default: @@ -573,7 +708,7 @@ Editor::button_press_handler_1 (ArdourCanvas::Item* item, GdkEvent* event, ItemT switch (item_type) { case PlayheadCursorItem: - _drags->set (new CursorDrag (this, item, true), event); + _drags->set (new CursorDrag (this, *playhead_cursor, true), event); return true; case MarkerItem: @@ -585,32 +720,53 @@ Editor::button_press_handler_1 (ArdourCanvas::Item* item, GdkEvent* event, ItemT return true; case TempoMarkerItem: - _drags->set ( - new TempoMarkerDrag ( - this, - item, - Keyboard::modifier_state_contains (event->button.state, Keyboard::CopyModifier) - ), - event - ); - return true; + { + TempoMarker* m = reinterpret_cast (item->get_data ("marker")); + assert (m); + if (m->tempo().movable ()) { + _drags->set ( + new TempoMarkerDrag ( + this, + item, + Keyboard::modifier_state_contains (event->button.state, Keyboard::CopyModifier) + ), + event + ); + return true; + } else { + return false; + } + } case MeterMarkerItem: - _drags->set ( - new MeterMarkerDrag ( - this, - item, - Keyboard::modifier_state_contains (event->button.state, Keyboard::CopyModifier) - ), - event - ); + { + MeterMarker* m = reinterpret_cast (item->get_data ("marker")); + assert (m); + if (m->meter().movable ()) { + _drags->set ( + new MeterMarkerDrag ( + this, + item, + Keyboard::modifier_state_contains (event->button.state, Keyboard::CopyModifier) + ), + event + ); + return true; + } else { + return false; + } + } + + case VideoBarItem: + _drags->set (new VideoTimeLineDrag (this, item), event); return true; + break; case MarkerBarItem: case TempoBarItem: case MeterBarItem: if (!Keyboard::modifier_state_equals (event->button.state, Keyboard::PrimaryModifier)) { - _drags->set (new CursorDrag (this, &playhead_cursor->canvas_item, false), event); + _drags->set (new CursorDrag (this, *playhead_cursor, false), event); } return true; break; @@ -618,7 +774,7 @@ Editor::button_press_handler_1 (ArdourCanvas::Item* item, GdkEvent* event, ItemT case RangeMarkerBarItem: if (!Keyboard::modifier_state_equals (event->button.state, Keyboard::PrimaryModifier)) { - _drags->set (new CursorDrag (this, &playhead_cursor->canvas_item, false), event); + _drags->set (new CursorDrag (this, *playhead_cursor, false), event); } else { _drags->set (new RangeMarkerBarDrag (this, item, RangeMarkerBarDrag::CreateRangeMarker), event); } @@ -627,7 +783,7 @@ Editor::button_press_handler_1 (ArdourCanvas::Item* item, GdkEvent* event, ItemT case CdMarkerBarItem: if (!Keyboard::modifier_state_equals (event->button.state, Keyboard::PrimaryModifier)) { - _drags->set (new CursorDrag (this, &playhead_cursor->canvas_item, false), event); + _drags->set (new CursorDrag (this, *playhead_cursor, false), event); } else { _drags->set (new RangeMarkerBarDrag (this, item, RangeMarkerBarDrag::CreateCDMarker), event); } @@ -636,7 +792,7 @@ Editor::button_press_handler_1 (ArdourCanvas::Item* item, GdkEvent* event, ItemT case TransportMarkerBarItem: if (!Keyboard::modifier_state_equals (event->button.state, Keyboard::PrimaryModifier)) { - _drags->set (new CursorDrag (this, &playhead_cursor->canvas_item, false), event); + _drags->set (new CursorDrag (this, *playhead_cursor, false), event); } else { _drags->set (new RangeMarkerBarDrag (this, item, RangeMarkerBarDrag::CreateTransportMarker), event); } @@ -668,6 +824,11 @@ Editor::button_press_handler_1 (ArdourCanvas::Item* item, GdkEvent* event, ItemT eff = MouseObject; } + /* there is no Range mode when in internal edit mode */ + if (eff == MouseRange && internal_editing()) { + eff = MouseObject; + } + switch (eff) { case MouseRange: switch (item_type) { @@ -680,21 +841,20 @@ Editor::button_press_handler_1 (ArdourCanvas::Item* item, GdkEvent* event, ItemT break; case SelectionItem: - if (Keyboard::modifier_state_contains - (event->button.state, Keyboard::ModifierMask(Keyboard::PrimaryModifier))) { - // contains and not equals because I can't use alt as a modifier alone. + if (Keyboard::modifier_state_contains (event->button.state, Keyboard::ModifierMask(Keyboard::PrimaryModifier|Keyboard::SecondaryModifier))) { start_selection_grab (item, event); + return true; } else if (Keyboard::modifier_state_equals (event->button.state, Keyboard::SecondaryModifier)) { /* grab selection for moving */ _drags->set (new SelectionDrag (this, item, SelectionDrag::SelectionMove), event); } else { - double const y = event->button.y + vertical_adjustment.get_value() - canvas_timebars_vsize; + double const y = event->button.y; pair tvp = trackview_by_y_position (y); if (tvp.first) { AutomationTimeAxisView* atv = dynamic_cast (tvp.first); - if (join_object_range_button.get_active() && atv) { + if ( get_smart_mode() && atv) { /* smart "join" mode: drag automation */ - _drags->set (new AutomationRangeDrag (this, atv->base_item(), selection->time), event, up_down_cursor); + _drags->set (new AutomationRangeDrag (this, atv, selection->time), event, _cursors->up_down); } else { /* this was debated, but decided the more common action was to make a new selection */ @@ -704,63 +864,85 @@ Editor::button_press_handler_1 (ArdourCanvas::Item* item, GdkEvent* event, ItemT } break; - case NoteItem: - if (internal_editing()) { - /* trim notes if we're in internal edit mode and near the ends of the note */ - ArdourCanvas::CanvasNote* cn = dynamic_cast (item); - cerr << "NoteItem button press, cursor = " << current_canvas_cursor << endl; - if (cn->mouse_near_ends()) { - _drags->set (new NoteResizeDrag (this, item), event, current_canvas_cursor); - } else { - _drags->set (new NoteDrag (this, item), event); - } - } - return true; - - case StreamItem: - if (internal_editing()) { + case StreamItem: + if (internal_editing()) { if (dynamic_cast (clicked_axisview)) { _drags->set (new RegionCreateDrag (this, item, clicked_axisview), event); return true; + } + } else { + if (Keyboard::modifier_state_equals (event->button.state, Keyboard::RangeSelectModifier)) { + _drags->set (new SelectionDrag (this, item, SelectionDrag::SelectionExtend), event); + } else { + _drags->set (new SelectionDrag (this, item, SelectionDrag::CreateSelection), event); } - } else { - _drags->set (new SelectionDrag (this, item, SelectionDrag::CreateSelection), event); return true; } - break; + break; - case RegionViewNameHighlight: - case LeftFrameHandle: - case RightFrameHandle: - if (!clicked_regionview->region()->locked()) { - RegionSelection s = get_equivalent_regions (selection->regions, Properties::edit.property_id); - _drags->set (new TrimDrag (this, item, clicked_regionview, s.by_layer()), event); - return true; - } - break; + case RegionViewNameHighlight: + if (!clicked_regionview->region()->locked()) { + _drags->set (new TrimDrag (this, item, clicked_regionview, selection->regions.by_layer()), event); + return true; + } + break; default: - if (!internal_editing()) { - _drags->set (new SelectionDrag (this, item, SelectionDrag::CreateSelection), event); - } + if (!internal_editing()) { + if (Keyboard::modifier_state_equals (event->button.state, Keyboard::RangeSelectModifier)) { + _drags->set (new SelectionDrag (this, item, SelectionDrag::SelectionExtend), event); + } else { + _drags->set (new SelectionDrag (this, item, SelectionDrag::CreateSelection), event); + } + } } return true; break; + case MouseDraw: + switch (item_type) { + case NoteItem: + if (internal_editing()) { + /* trim notes if we're in internal edit mode and near the ends of the note */ + NoteBase* cn = reinterpret_cast(item->get_data ("notebase")); + assert (cn); + if (cn && cn->big_enough_to_trim() && cn->mouse_near_ends()) { + _drags->set (new NoteResizeDrag (this, item), event, current_canvas_cursor); + } else { + _drags->set (new NoteDrag (this, item), event); + } + return true; + } + break; + case StreamItem: + if (internal_editing()) { + if (dynamic_cast (clicked_axisview)) { + _drags->set (new RegionCreateDrag (this, item, clicked_axisview), event); + } + return true; + } + break; + + default: + break; + } + break; + case MouseObject: switch (item_type) { case NoteItem: if (internal_editing()) { - ArdourCanvas::CanvasNote* cn = dynamic_cast (item); - if (cn->mouse_near_ends()) { - _drags->set (new NoteResizeDrag (this, item), event, current_canvas_cursor); - } else { - _drags->set (new NoteDrag (this, item), event); - } + NoteBase* cn = reinterpret_cast (item->get_data ("notebase")); + assert (cn); + if (cn->mouse_near_ends()) { + _drags->set (new NoteResizeDrag (this, item), event, current_canvas_cursor); + } else { + _drags->set (new NoteDrag (this, item), event); + } return true; } break; - + default: break; } @@ -768,32 +950,39 @@ Editor::button_press_handler_1 (ArdourCanvas::Item* item, GdkEvent* event, ItemT if (Keyboard::modifier_state_contains (event->button.state, Keyboard::ModifierMask(Keyboard::PrimaryModifier|Keyboard::SecondaryModifier)) && event->type == GDK_BUTTON_PRESS) { - _drags->set (new RubberbandSelectDrag (this, item), event); + _drags->set (new EditorRubberbandSelectDrag (this, item), event); } else if (event->type == GDK_BUTTON_PRESS) { switch (item_type) { case FadeInHandleItem: { - RegionSelection s = get_equivalent_regions (selection->regions, Properties::edit.property_id); - _drags->set (new FadeInDrag (this, item, reinterpret_cast (item->get_data("regionview")), s), event); + _drags->set (new FadeInDrag (this, item, reinterpret_cast (item->get_data("regionview")), selection->regions), event, _cursors->fade_in); return true; } case FadeOutHandleItem: { - RegionSelection s = get_equivalent_regions (selection->regions, Properties::edit.property_id); - _drags->set (new FadeOutDrag (this, item, reinterpret_cast (item->get_data("regionview")), s), event); + _drags->set (new FadeOutDrag (this, item, reinterpret_cast (item->get_data("regionview")), selection->regions), event, _cursors->fade_out); return true; } + case StartCrossFadeItem: + case EndCrossFadeItem: + /* we might allow user to grab inside the fade to trim a region with preserve_fade_anchor. for not this is not fully implemented */ +// if (!clicked_regionview->region()->locked()) { +// _drags->set (new TrimDrag (this, item, clicked_regionview, selection->regions.by_layer(), true), event); +// return true; +// } + break; + case FeatureLineItem: - { + { if (Keyboard::modifier_state_contains (event->button.state, Keyboard::TertiaryModifier)) { remove_transient(item); return true; } - + _drags->set (new FeatureLineDrag (this, item), event); return true; break; @@ -808,33 +997,32 @@ Editor::button_press_handler_1 (ArdourCanvas::Item* item, GdkEvent* event, ItemT } if (internal_editing ()) { - /* no region drags in internal edit mode */ break; } - + /* click on a normal region view */ if (Keyboard::modifier_state_contains (event->button.state, Keyboard::CopyModifier)) { add_region_copy_drag (item, event, clicked_regionview); - } - else if (Keyboard::the_keyboard().key_is_down (GDK_b)) { + } else if (Keyboard::the_keyboard().key_is_down (GDK_b)) { add_region_brush_drag (item, event, clicked_regionview); } else { add_region_drag (item, event, clicked_regionview); } - - if (_join_object_range_state == JOIN_OBJECT_RANGE_OBJECT && !selection->regions.empty()) { - _drags->add (new SelectionDrag (this, clicked_axisview->get_selection_rect (clicked_selection)->rect, SelectionDrag::SelectionMove)); - } + + +// if (!internal_editing() && (_join_object_range_state == JOIN_OBJECT_RANGE_RANGE && !selection->regions.empty())) { +// _drags->add (new SelectionDrag (this, clicked_axisview->get_selection_rect (clicked_selection)->rect, SelectionDrag::SelectionMove)); +// } _drags->start_grab (event); + return true; break; case RegionViewNameHighlight: case LeftFrameHandle: case RightFrameHandle: - if (!internal_editing () && !clicked_regionview->region()->locked()) { - RegionSelection s = get_equivalent_regions (selection->regions, Properties::edit.property_id); - _drags->set (new TrimDrag (this, item, clicked_regionview, s.by_layer()), event); + if (!clicked_regionview->region()->locked()) { + _drags->set (new TrimDrag (this, item, clicked_regionview, selection->regions.by_layer()), event); return true; } break; @@ -842,8 +1030,7 @@ Editor::button_press_handler_1 (ArdourCanvas::Item* item, GdkEvent* event, ItemT case RegionViewName: { /* rename happens on edit clicks */ - RegionSelection s = get_equivalent_regions (selection->regions, Properties::edit.property_id); - _drags->set (new TrimDrag (this, clicked_regionview->get_name_highlight(), clicked_regionview, s.by_layer()), event); + _drags->set (new TrimDrag (this, clicked_regionview->get_name_highlight(), clicked_regionview, selection->regions.by_layer()), event); return true; break; } @@ -865,81 +1052,84 @@ Editor::button_press_handler_1 (ArdourCanvas::Item* item, GdkEvent* event, ItemT } return true; } else { - _drags->set (new RubberbandSelectDrag (this, item), event); + _drags->set (new EditorRubberbandSelectDrag (this, item), event); } break; - + case AutomationTrackItem: - /* rubberband drag to select automation points */ - _drags->set (new RubberbandSelectDrag (this, item), event); + { + TimeAxisView* parent = clicked_axisview->get_parent (); + AutomationTimeAxisView* atv = dynamic_cast (clicked_axisview); + assert (atv); + if (parent && dynamic_cast (parent) && atv->show_regions ()) { + + RouteTimeAxisView* p = dynamic_cast (parent); + assert (p); + boost::shared_ptr pl = p->track()->playlist (); + if (pl->n_regions() == 0) { + /* Parent has no regions; create one so that we have somewhere to put automation */ + _drags->set (new RegionCreateDrag (this, item, parent), event); + } else { + /* See if there's a region before the click that we can extend, and extend it if so */ + framepos_t const t = canvas_event_frame (event); + boost::shared_ptr prev = pl->find_next_region (t, End, -1); + if (!prev) { + _drags->set (new RegionCreateDrag (this, item, parent), event); + } else { + prev->set_length (t - prev->position ()); + } + } + } else { + /* rubberband drag to select automation points */ + _drags->set (new EditorRubberbandSelectDrag (this, item), event); + } break; + } case SelectionItem: { - if (join_object_range_button.get_active()) { + if ( get_smart_mode() ) { /* we're in "smart" joined mode, and we've clicked on a Selection */ - double const y = event->button.y + vertical_adjustment.get_value() - canvas_timebars_vsize; + double const y = event->button.y; pair tvp = trackview_by_y_position (y); if (tvp.first) { /* if we're over an automation track, start a drag of its data */ AutomationTimeAxisView* atv = dynamic_cast (tvp.first); if (atv) { - _drags->set (new AutomationRangeDrag (this, atv->base_item(), selection->time), event, up_down_cursor); + _drags->set (new AutomationRangeDrag (this, atv, selection->time), event, _cursors->up_down); } /* if we're over a track and a region, and in the `object' part of a region, put a selection around the region and drag both */ - RouteTimeAxisView* rtv = dynamic_cast (tvp.first); +/* RouteTimeAxisView* rtv = dynamic_cast (tvp.first); if (rtv && _join_object_range_state == JOIN_OBJECT_RANGE_OBJECT) { boost::shared_ptr t = boost::dynamic_pointer_cast (rtv->route ()); if (t) { boost::shared_ptr pl = t->playlist (); if (pl) { - - boost::shared_ptr r = pl->top_region_at (event_frame (event)); + + boost::shared_ptr r = pl->top_region_at (canvas_event_frame (event)); if (r) { RegionView* rv = rtv->view()->find_view (r); - clicked_selection = select_range_around_region (rv); + clicked_selection = select_range (rv->region()->position(), + rv->region()->last_frame()+1); _drags->add (new SelectionDrag (this, item, SelectionDrag::SelectionMove)); list rvs; rvs.push_back (rv); _drags->add (new RegionMoveDrag (this, item, rv, rvs, false, false)); _drags->start_grab (event); + return true; } } } } +*/ } } break; } -#ifdef WITH_CMT - case ImageFrameHandleStartItem: - imageframe_start_handle_op(item, event) ; - return(true) ; - break ; - case ImageFrameHandleEndItem: - imageframe_end_handle_op(item, event) ; - return(true) ; - break ; - case MarkerViewHandleStartItem: - markerview_item_start_handle_op(item, event) ; - return(true) ; - break ; - case MarkerViewHandleEndItem: - markerview_item_end_handle_op(item, event) ; - return(true) ; - break ; - case MarkerViewItem: - start_markerview_grab(item, event) ; - break ; - case ImageFrameItem: - start_imageframe_grab(item, event) ; - break ; -#endif - case MarkerBarItem: break; @@ -953,13 +1143,6 @@ Editor::button_press_handler_1 (ArdourCanvas::Item* item, GdkEvent* event, ItemT case MouseGain: switch (item_type) { - case RegionItem: - /* start a grab so that if we finish after moving - we can tell what happened. - */ - _drags->set (new RegionGainDrag (this, item), event, current_canvas_cursor); - break; - case GainLineItem: _drags->set (new LineDrag (this, item), event); return true; @@ -969,27 +1152,21 @@ Editor::button_press_handler_1 (ArdourCanvas::Item* item, GdkEvent* event, ItemT return true; break; - default: + case SelectionItem: + { + AudioRegionView* arv = dynamic_cast (clicked_regionview); + if (arv) { + _drags->set (new AutomationRangeDrag (this, arv, selection->time), event, _cursors->up_down); + _drags->start_grab (event); + } + return true; break; } - return true; - break; - - switch (item_type) { - case ControlPointItem: - _drags->set (new ControlPointDrag (this, item), event); - break; case AutomationLineItem: _drags->set (new LineDrag (this, item), event); break; - - case RegionItem: - // XXX need automation mode to identify which - // line to use - // start_line_grab_from_regionview (item, event); - break; - + default: break; } @@ -1009,8 +1186,8 @@ Editor::button_press_handler_1 (ArdourCanvas::Item* item, GdkEvent* event, ItemT /* drag notes if we're in internal edit mode */ _drags->set (new NoteResizeDrag (this, item), event, current_canvas_cursor); return true; - } else if ((!internal_editing() || dynamic_cast (clicked_regionview)) && clicked_regionview) { - /* do time-FX if we're not in internal edit mode, or we are but we clicked on an audio region */ + } else if (clicked_regionview) { + /* do time-FX */ _drags->set (new TimeFXDrag (this, item, clicked_regionview, selection->regions.by_layer()), event); return true; } @@ -1022,7 +1199,7 @@ Editor::button_press_handler_1 (ArdourCanvas::Item* item, GdkEvent* event, ItemT scrub_reverse_distance = 0; last_scrub_x = event->button.x; scrubbing_direction = 0; - set_canvas_cursor (transparent_cursor); + set_canvas_cursor (_cursors->transparent); return true; break; @@ -1041,6 +1218,11 @@ Editor::button_press_handler_2 (ArdourCanvas::Item* item, GdkEvent* event, ItemT case MouseObject: switch (item_type) { case RegionItem: + if (internal_editing ()) { + /* no region drags in internal edit mode */ + return false; + } + if (Keyboard::modifier_state_contains (event->button.state, Keyboard::CopyModifier)) { add_region_copy_drag (item, event, clicked_regionview); } else { @@ -1060,6 +1242,10 @@ Editor::button_press_handler_2 (ArdourCanvas::Item* item, GdkEvent* event, ItemT switch (item_type) { case RegionViewNameHighlight: + _drags->set (new TrimDrag (this, item, clicked_regionview, selection->regions.by_layer()), event); + return true; + break; + case LeftFrameHandle: case RightFrameHandle: if (!internal_editing ()) { @@ -1079,6 +1265,9 @@ Editor::button_press_handler_2 (ArdourCanvas::Item* item, GdkEvent* event, ItemT break; + case MouseDraw: + return false; + case MouseRange: /* relax till release */ return true; @@ -1087,9 +1276,9 @@ Editor::button_press_handler_2 (ArdourCanvas::Item* item, GdkEvent* event, ItemT case MouseZoom: if (Keyboard::modifier_state_equals (event->button.state, Keyboard::PrimaryModifier)) { - temporal_zoom_session(); + temporal_zoom_to_frame (false, canvas_event_frame (event)); } else { - temporal_zoom_to_frame (true, event_frame(event)); + temporal_zoom_to_frame (true, canvas_event_frame(event)); } return true; break; @@ -1100,15 +1289,20 @@ Editor::button_press_handler_2 (ArdourCanvas::Item* item, GdkEvent* event, ItemT return false; } - + bool Editor::button_press_handler (ArdourCanvas::Item* item, GdkEvent* event, ItemType item_type) { + if (event->type == GDK_2BUTTON_PRESS) { + _drags->mark_double_click (); + return false; + } + if (event->type != GDK_BUTTON_PRESS) { return false; } - Glib::RefPtr canvas_window = const_cast(this)->track_canvas->get_window(); + Glib::RefPtr canvas_window = const_cast(this)->_track_canvas_viewport->get_window(); if (canvas_window) { Glib::RefPtr pointer_window; @@ -1118,19 +1312,57 @@ Editor::button_press_handler (ArdourCanvas::Item* item, GdkEvent* event, ItemTyp pointer_window = canvas_window->get_pointer (x, y, mask); - if (pointer_window == track_canvas->get_bin_window()) { - track_canvas->window_to_world (x, y, wx, wy); + if (pointer_window == _track_canvas->get_window()) { + _track_canvas->window_to_canvas (x, y, wx, wy); } } pre_press_cursor = current_canvas_cursor; - - track_canvas->grab_focus(); + + _track_canvas->grab_focus(); if (_session && _session->actively_recording()) { return true; } + if (internal_editing()) { + bool leave_internal_edit_mode = false; + + switch (item_type) { + case NoteItem: + break; + + case RegionItem: + if (!dynamic_cast (clicked_regionview) && !dynamic_cast (clicked_regionview)) { + leave_internal_edit_mode = true; + } + break; + + case PlayheadCursorItem: + case MarkerItem: + case TempoMarkerItem: + case MeterMarkerItem: + case MarkerBarItem: + case TempoBarItem: + case MeterBarItem: + case RangeMarkerBarItem: + case CdMarkerBarItem: + case TransportMarkerBarItem: + case StreamItem: + /* button press on these events never does anything to + change the editing mode. + */ + break; + + default: + break; + } + + if (leave_internal_edit_mode) { + ActionManager::do_action ("MouseMode", "toggle-internal-edit"); + } + } + button_selection (item, event, item_type); if (!_drags->active () && @@ -1142,6 +1374,13 @@ Editor::button_press_handler (ArdourCanvas::Item* item, GdkEvent* event, ItemTyp return true; } + //not rolling, range mode click + join_play_range : locate the PH here + if ( !_drags->active () && !_session->transport_rolling() && ( effective_mouse_mode() == MouseRange ) && Config->get_always_play_range() ) { + framepos_t where = canvas_event_frame (event); + snap_to(where); + _session->request_locate (where, false); + } + switch (event->button.button) { case 1: return button_press_handler_1 (item, event, item_type); @@ -1155,6 +1394,7 @@ Editor::button_press_handler (ArdourCanvas::Item* item, GdkEvent* event, ItemTyp break; default: + return button_press_dispatch (&event->button); break; } @@ -1162,10 +1402,30 @@ Editor::button_press_handler (ArdourCanvas::Item* item, GdkEvent* event, ItemTyp return false; } +bool +Editor::button_press_dispatch (GdkEventButton* ev) +{ + /* this function is intended only for buttons 4 and above. + */ + + Gtkmm2ext::MouseButton b (ev->state, ev->button); + return button_bindings->activate (b, Gtkmm2ext::Bindings::Press); +} + +bool +Editor::button_release_dispatch (GdkEventButton* ev) +{ + /* this function is intended only for buttons 4 and above. + */ + + Gtkmm2ext::MouseButton b (ev->state, ev->button); + return button_bindings->activate (b, Gtkmm2ext::Bindings::Release); +} + bool Editor::button_release_handler (ArdourCanvas::Item* item, GdkEvent* event, ItemType item_type) { - framepos_t where = event_frame (event, 0, 0); + framepos_t where = canvas_event_frame (event); AutomationTimeAxisView* atv = 0; if (pre_press_cursor) { @@ -1192,7 +1452,7 @@ Editor::button_release_handler (ArdourCanvas::Item* item, GdkEvent* event, ItemT were_dragging = true; } - update_region_layering_order_editor (); + update_region_layering_order_editor (); /* edit events get handled here */ @@ -1220,10 +1480,6 @@ Editor::button_release_handler (ArdourCanvas::Item* item, GdkEvent* event, ItemT edit_control_point (item); break; - case NoteItem: - edit_note (item); - break; - default: break; } @@ -1231,9 +1487,10 @@ Editor::button_release_handler (ArdourCanvas::Item* item, GdkEvent* event, ItemT } /* context menu events get handled here */ - if (Keyboard::is_context_menu_event (&event->button)) { + context_click_event = *event; + if (!_drags->active ()) { /* no matter which button pops up the context menu, tell the menu @@ -1248,8 +1505,16 @@ Editor::button_release_handler (ArdourCanvas::Item* item, GdkEvent* event, ItemT popup_fade_context_menu (1, event->button.time, item, item_type); break; + case StartCrossFadeItem: + popup_xfade_in_context_menu (1, event->button.time, item, item_type); + break; + + case EndCrossFadeItem: + popup_xfade_out_context_menu (1, event->button.time, item, item_type); + break; + case StreamItem: - popup_track_context_menu (1, event->button.time, item_type, false, where); + popup_track_context_menu (1, event->button.time, item_type, false); break; case RegionItem: @@ -1257,15 +1522,15 @@ Editor::button_release_handler (ArdourCanvas::Item* item, GdkEvent* event, ItemT case LeftFrameHandle: case RightFrameHandle: case RegionViewName: - popup_track_context_menu (1, event->button.time, item_type, false, where); + popup_track_context_menu (1, event->button.time, item_type, false); break; case SelectionItem: - popup_track_context_menu (1, event->button.time, item_type, true, where); + popup_track_context_menu (1, event->button.time, item_type, true); break; - + case AutomationTrackItem: - popup_track_context_menu (1, event->button.time, item_type, false, where); + popup_track_context_menu (1, event->button.time, item_type, false); break; case MarkerBarItem: @@ -1274,6 +1539,7 @@ Editor::button_release_handler (ArdourCanvas::Item* item, GdkEvent* event, ItemT case CdMarkerBarItem: case TempoBarItem: case MeterBarItem: + case VideoBarItem: popup_ruler_menu (where, item_type); break; @@ -1290,23 +1556,12 @@ Editor::button_release_handler (ArdourCanvas::Item* item, GdkEvent* event, ItemT break; case CrossfadeViewItem: - popup_track_context_menu (1, event->button.time, item_type, false, where); + popup_track_context_menu (1, event->button.time, item_type, false); break; -#ifdef WITH_CMT - case ImageFrameItem: - popup_imageframe_edit_menu(1, event->button.time, item, true) ; - break ; - case ImageFrameTimeAxisItem: - popup_imageframe_edit_menu(1, event->button.time, item, false) ; - break ; - case MarkerViewItem: - popup_marker_time_axis_edit_menu(1, event->button.time, item, true) ; - break ; - case MarkerTimeAxisItem: - popup_marker_time_axis_edit_menu(1, event->button.time, item, false) ; - break ; -#endif + case ControlPointItem: + popup_control_point_context_menu (item, event); + break; default: break; @@ -1342,11 +1597,7 @@ Editor::button_release_handler (ArdourCanvas::Item* item, GdkEvent* event, ItemT break; case ControlPointItem: - if (eff == MouseGain) { - remove_gain_control_point (item, event); - } else { - remove_control_point (item, event); - } + remove_control_point (item); break; case NoteItem: @@ -1396,7 +1647,7 @@ Editor::button_release_handler (ArdourCanvas::Item* item, GdkEvent* event, ItemT case MeterBarItem: if (!_dragging_playhead) { - mouse_add_new_meter_event (pixel_to_frame (event->button.x)); + mouse_add_new_meter_event (pixel_to_sample (event->button.x)); } return true; break; @@ -1411,11 +1662,10 @@ Editor::button_release_handler (ArdourCanvas::Item* item, GdkEvent* event, ItemT case AutomationTrackItem: atv = dynamic_cast(clicked_axisview); if (atv) { - atv->add_automation_event (item, event, where, event->button.y); + atv->add_automation_event (event, where, event->button.y); } return true; break; - default: break; } @@ -1430,7 +1680,7 @@ Editor::button_release_handler (ArdourCanvas::Item* item, GdkEvent* event, ItemT points when doing this. */ AudioRegionView* arv = dynamic_cast (clicked_regionview); - if (were_dragging && arv) { + if (!were_dragging && arv) { arv->add_gain_point_event (item, event); } return true; @@ -1439,7 +1689,7 @@ Editor::button_release_handler (ArdourCanvas::Item* item, GdkEvent* event, ItemT case AutomationTrackItem: dynamic_cast(clicked_axisview)-> - add_automation_event (item, event, where, event->button.y); + add_automation_event (event, where, event->button.y); return true; break; default: @@ -1448,7 +1698,7 @@ Editor::button_release_handler (ArdourCanvas::Item* item, GdkEvent* event, ItemT break; case MouseAudition: - set_canvas_cursor (current_canvas_cursor); + set_canvas_cursor (current_canvas_cursor); if (scrubbing_direction == 0) { /* no drag, just a click */ switch (item_type) { @@ -1469,6 +1719,8 @@ Editor::button_release_handler (ArdourCanvas::Item* item, GdkEvent* event, ItemT } + /* do any (de)selection operations that should occur on button release */ + button_selection (item, event, item_type); return true; break; @@ -1495,8 +1747,10 @@ Editor::button_release_handler (ArdourCanvas::Item* item, GdkEvent* event, ItemT } break; + case MouseDraw: + return true; + case MouseRange: - // x_style_paste (where, 1.0); return true; break; @@ -1513,6 +1767,7 @@ Editor::button_release_handler (ArdourCanvas::Item* item, GdkEvent* event, ItemT default: break; } + return false; } @@ -1524,8 +1779,6 @@ Editor::enter_handler (ArdourCanvas::Item* item, GdkEvent* event, ItemType item_ double fraction; bool ret = true; - last_item_entered = item; - switch (item_type) { case ControlPointItem: if (mouse_mode == MouseGain || mouse_mode == MouseObject) { @@ -1542,78 +1795,60 @@ Editor::enter_handler (ArdourCanvas::Item* item, GdkEvent* event, ItemType item_ fraction = 1.0 - (cp->get_y() / cp->line().height()); if (is_drawable() && !_drags->active ()) { - set_canvas_cursor (fader_cursor); + set_canvas_cursor (_cursors->fader); } - set_verbose_canvas_cursor (cp->line().get_verbose_cursor_string (fraction), at_x, at_y); - show_verbose_canvas_cursor (); + _verbose_cursor->set (cp->line().get_verbose_cursor_string (fraction), at_x, at_y); + _verbose_cursor->show (); } break; case GainLineItem: if (mouse_mode == MouseGain) { ArdourCanvas::Line *line = dynamic_cast (item); - if (line) - line->property_fill_color_rgba() = ARDOUR_UI::config()->canvasvar_EnteredGainLine.get(); + if (line) { + line->set_outline_color (ARDOUR_UI::config()->get_canvasvar_EnteredGainLine()); + } if (is_drawable()) { - set_canvas_cursor (fader_cursor); + set_canvas_cursor (_cursors->fader); } } break; case AutomationLineItem: if (mouse_mode == MouseGain || mouse_mode == MouseObject) { - { - ArdourCanvas::Line *line = dynamic_cast (item); - if (line) - line->property_fill_color_rgba() = ARDOUR_UI::config()->canvasvar_EnteredAutomationLine.get(); + ArdourCanvas::Line *line = dynamic_cast (item); + if (line) { + line->set_outline_color (ARDOUR_UI::config()->get_canvasvar_EnteredAutomationLine()); } if (is_drawable()) { - set_canvas_cursor (fader_cursor); + set_canvas_cursor (_cursors->fader); } } break; case RegionViewNameHighlight: - if (is_drawable() && mouse_mode == MouseObject && !internal_editing()) { - set_canvas_cursor (trimmer_cursor); + if (is_drawable() && effective_mouse_mode() == MouseObject && entered_regionview) { + set_canvas_cursor_for_region_view (event->crossing.x, entered_regionview); + _over_region_trim_target = true; } break; case LeftFrameHandle: - if (is_drawable() && mouse_mode == MouseObject && !internal_editing()) { - if (entered_regionview) { - Trimmable::CanTrim ct = entered_regionview->region()->can_trim(); - if ((ct & Trimmable::EndTrimEarlier) || (ct & Trimmable::EndTrimLater)) { - set_canvas_cursor (left_side_trim_cursor); - } - } - } - break; - case RightFrameHandle: - if (is_drawable() && mouse_mode == MouseObject && !internal_editing()) { - if (entered_regionview) { - Trimmable::CanTrim ct = entered_regionview->region()->can_trim(); - if ((ct & Trimmable::FrontTrimEarlier) || (ct & Trimmable::FrontTrimLater)) { - set_canvas_cursor (right_side_trim_cursor); - } - } + if (is_drawable() && effective_mouse_mode() == MouseObject && !internal_editing() && entered_regionview) { + set_canvas_cursor_for_region_view (event->crossing.x, entered_regionview); } break; case StartSelectionTrimItem: + if (is_drawable()) { + set_canvas_cursor (_cursors->left_side_trim); + } + break; case EndSelectionTrimItem: - -#ifdef WITH_CMT - case ImageFrameHandleStartItem: - case ImageFrameHandleEndItem: - case MarkerViewHandleStartItem: - case MarkerViewHandleEndItem: -#endif - if (is_drawable()) { - set_canvas_cursor (trimmer_cursor); + set_canvas_cursor (_cursors->right_side_trim); } break; @@ -1621,10 +1856,10 @@ Editor::enter_handler (ArdourCanvas::Item* item, GdkEvent* event, ItemType item_ if (is_drawable()) { switch (_edit_point) { case EditAtMouse: - set_canvas_cursor (grabber_edit_point_cursor); + set_canvas_cursor (_cursors->grabber_edit_point); break; default: - set_canvas_cursor (grabber_cursor); + set_canvas_cursor (_cursors->grabber); break; } } @@ -1636,7 +1871,8 @@ Editor::enter_handler (ArdourCanvas::Item* item, GdkEvent* event, ItemType item_ if (!reinterpret_cast (item->get_data ("regionview"))->name_active()) { if (mouse_mode == MouseObject && is_drawable()) { - set_canvas_cursor (trimmer_cursor); + set_canvas_cursor_for_region_view (event->crossing.x, entered_regionview); + _over_region_trim_target = true; } } break; @@ -1647,13 +1883,13 @@ Editor::enter_handler (ArdourCanvas::Item* item, GdkEvent* event, ItemType item_ Gdk::Cursor *cursor; switch (mouse_mode) { case MouseRange: - cursor = selector_cursor; + cursor = _cursors->selector; break; case MouseZoom: - cursor = zoom_in_cursor; + cursor = _cursors->zoom_in; break; default: - cursor = cross_hair_cursor; + cursor = _cursors->cross_hair; break; } @@ -1674,7 +1910,7 @@ Editor::enter_handler (ArdourCanvas::Item* item, GdkEvent* event, ItemType item_ case MeterBarItem: case TempoBarItem: if (is_drawable()) { - set_canvas_cursor (timebar_cursor); + set_canvas_cursor (_cursors->timebar); } break; @@ -1683,46 +1919,47 @@ Editor::enter_handler (ArdourCanvas::Item* item, GdkEvent* event, ItemType item_ break; } entered_marker = marker; - marker->set_color_rgba (ARDOUR_UI::config()->canvasvar_EnteredMarker.get()); + marker->set_color_rgba (ARDOUR_UI::config()->get_canvasvar_EnteredMarker()); // fall through case MeterMarkerItem: case TempoMarkerItem: if (is_drawable()) { - set_canvas_cursor (timebar_cursor); + set_canvas_cursor (_cursors->timebar); } break; case FadeInHandleItem: if (mouse_mode == MouseObject && !internal_editing()) { - ArdourCanvas::SimpleRect *rect = dynamic_cast (item); + ArdourCanvas::Rectangle *rect = dynamic_cast (item); if (rect) { - rect->property_fill_color_rgba() = 0xBBBBBBAA; + rect->set_fill_color (0xBBBBBBAA); } - set_canvas_cursor (fade_in_cursor); + set_canvas_cursor (_cursors->fade_in); } - break; + break; case FadeOutHandleItem: if (mouse_mode == MouseObject && !internal_editing()) { - ArdourCanvas::SimpleRect *rect = dynamic_cast (item); + ArdourCanvas::Rectangle *rect = dynamic_cast (item); if (rect) { - rect->property_fill_color_rgba() = 0xBBBBBBAA; + rect->set_fill_color (0xBBBBBBAA); } - set_canvas_cursor (fade_out_cursor); + set_canvas_cursor (_cursors->fade_out); } break; case FeatureLineItem: - { - ArdourCanvas::SimpleLine *line = dynamic_cast (item); - line->property_color_rgba() = 0xFF0000FF; - } - break; + { + ArdourCanvas::Line *line = dynamic_cast (item); + line->set_outline_color (0xFF0000FF); + } + break; + case SelectionItem: - if (join_object_range_button.get_active()) { + if ( get_smart_mode() ) { set_canvas_cursor (); } break; - + default: break; } @@ -1751,7 +1988,7 @@ Editor::enter_handler (ArdourCanvas::Item* item, GdkEvent* event, ItemType item_ } bool -Editor::leave_handler (ArdourCanvas::Item* item, GdkEvent* event, ItemType item_type) +Editor::leave_handler (ArdourCanvas::Item* item, GdkEvent*, ItemType item_type) { AutomationLine* al; ControlPoint* cp; @@ -1759,7 +1996,7 @@ Editor::leave_handler (ArdourCanvas::Item* item, GdkEvent* event, ItemType item_ Location *loc; RegionView* rv; bool is_start; - bool ret = true; + bool ret = true; switch (item_type) { case ControlPointItem: @@ -1771,10 +2008,10 @@ Editor::leave_handler (ArdourCanvas::Item* item, GdkEvent* event, ItemType item_ } if (is_drawable()) { - set_canvas_cursor (current_canvas_cursor); + set_canvas_cursor (current_canvas_cursor); } - hide_verbose_canvas_cursor (); + _verbose_cursor->hide (); break; case RegionViewNameHighlight: @@ -1784,15 +2021,10 @@ Editor::leave_handler (ArdourCanvas::Item* item, GdkEvent* event, ItemType item_ case EndSelectionTrimItem: case PlayheadCursorItem: -#ifdef WITH_CMT - case ImageFrameHandleStartItem: - case ImageFrameHandleEndItem: - case MarkerViewHandleStartItem: - case MarkerViewHandleEndItem: -#endif + _over_region_trim_target = false; if (is_drawable()) { - set_canvas_cursor (current_canvas_cursor); + set_canvas_cursor (current_canvas_cursor); } break; @@ -1801,19 +2033,22 @@ Editor::leave_handler (ArdourCanvas::Item* item, GdkEvent* event, ItemType item_ al = reinterpret_cast (item->get_data ("line")); { ArdourCanvas::Line *line = dynamic_cast (item); - if (line) - line->property_fill_color_rgba() = al->get_line_color(); + if (line) { + line->set_outline_color (al->get_line_color()); + } } if (is_drawable()) { - set_canvas_cursor (current_canvas_cursor); + set_canvas_cursor (current_canvas_cursor); } break; case RegionViewName: /* see enter_handler() for notes */ + _over_region_trim_target = false; + if (!reinterpret_cast (item->get_data ("regionview"))->name_active()) { if (is_drawable() && mouse_mode == MouseObject) { - set_canvas_cursor (current_canvas_cursor); + set_canvas_cursor (current_canvas_cursor); } } break; @@ -1825,7 +2060,7 @@ Editor::leave_handler (ArdourCanvas::Item* item, GdkEvent* event, ItemType item_ case TempoBarItem: case MarkerBarItem: if (is_drawable()) { - set_canvas_cursor (current_canvas_cursor); + set_canvas_cursor (current_canvas_cursor); } break; @@ -1842,7 +2077,7 @@ Editor::leave_handler (ArdourCanvas::Item* item, GdkEvent* event, ItemType item_ case TempoMarkerItem: if (is_drawable()) { - set_canvas_cursor (timebar_cursor); + set_canvas_cursor (current_canvas_cursor); } break; @@ -1851,26 +2086,25 @@ Editor::leave_handler (ArdourCanvas::Item* item, GdkEvent* event, ItemType item_ case FadeOutHandleItem: rv = static_cast(item->get_data ("regionview")); { - ArdourCanvas::SimpleRect *rect = dynamic_cast (item); + ArdourCanvas::Rectangle *rect = dynamic_cast (item); if (rect) { - rect->property_fill_color_rgba() = rv->get_fill_color(); - rect->property_outline_pixels() = 0; + rect->set_fill_color (rv->get_fill_color()); } } - set_canvas_cursor (current_canvas_cursor); + set_canvas_cursor (current_canvas_cursor); break; case AutomationTrackItem: if (is_drawable()) { - set_canvas_cursor (current_canvas_cursor); + set_canvas_cursor (current_canvas_cursor); clear_entered_track = true; Glib::signal_idle().connect (sigc::mem_fun(*this, &Editor::left_automation_track)); } break; case FeatureLineItem: { - ArdourCanvas::SimpleLine *line = dynamic_cast (item); - line->property_color_rgba() = (guint) ARDOUR_UI::config()->canvasvar_ZeroLine.get();; + ArdourCanvas::Line *line = dynamic_cast (item); + line->set_outline_color (ARDOUR_UI::config()->get_canvasvar_ZeroLine()); } break; @@ -1923,7 +2157,7 @@ Editor::scrub (framepos_t frame, double current_x) scrub_reverse_distance = 0; delta = 0.01 * (last_scrub_x - current_x); - _session->request_transport_speed (_session->transport_speed() - delta); + _session->request_transport_speed_nonzero (_session->transport_speed() - delta); } } else { @@ -1942,7 +2176,7 @@ Editor::scrub (framepos_t frame, double current_x) scrub_reverse_distance = 0; delta = 0.01 * (current_x - last_scrub_x); - _session->request_transport_speed (_session->transport_speed() + delta); + _session->request_transport_speed_nonzero (_session->transport_speed() + delta); } } @@ -1974,7 +2208,7 @@ bool Editor::motion_handler (ArdourCanvas::Item* /*item*/, GdkEvent* event, bool from_autoscroll) { _last_motion_y = event->motion.y; - + if (event->motion.is_hint) { gint x, y; @@ -1987,7 +2221,7 @@ Editor::motion_handler (ArdourCanvas::Item* /*item*/, GdkEvent* event, bool from event might do, its a good tradeoff. */ - track_canvas->get_pointer (x, y); + _track_canvas->get_pointer (x, y); } if (current_stepping_trackview) { @@ -2003,15 +2237,20 @@ Editor::motion_handler (ArdourCanvas::Item* /*item*/, GdkEvent* event, bool from JoinObjectRangeState const old = _join_object_range_state; update_join_object_range_location (event->motion.x, event->motion.y); - if (_join_object_range_state != old) { + + if (!_internal_editing && _join_object_range_state != old) { set_canvas_cursor (); } + if (!_internal_editing && _over_region_trim_target) { + set_canvas_cursor_for_region_view (event->motion.x, entered_regionview); + } + bool handled = false; if (_drags->active ()) { handled = _drags->motion_handler (event, from_autoscroll); } - + if (!handled) { return false; } @@ -2020,8 +2259,8 @@ Editor::motion_handler (ArdourCanvas::Item* /*item*/, GdkEvent* event, bool from return true; } -void -Editor::remove_gain_control_point (ArdourCanvas::Item*item, GdkEvent* /*event*/) +bool +Editor::can_remove_control_point (ArdourCanvas::Item* item) { ControlPoint* control_point; @@ -2030,18 +2269,24 @@ Editor::remove_gain_control_point (ArdourCanvas::Item*item, GdkEvent* /*event*/) /*NOTREACHED*/ } - // We shouldn't remove the first or last gain point - if (control_point->line().is_last_point(*control_point) || - control_point->line().is_first_point(*control_point)) { - return; + AutomationLine& line = control_point->line (); + if (dynamic_cast (&line)) { + /* we shouldn't remove the first or last gain point in region gain lines */ + if (line.is_last_point(*control_point) || line.is_first_point(*control_point)) { + return false; + } } - control_point->line().remove_point (*control_point); + return true; } void -Editor::remove_control_point (ArdourCanvas::Item* item, GdkEvent* /*event*/) +Editor::remove_control_point (ArdourCanvas::Item* item) { + if (!can_remove_control_point (item)) { + return; + } + ControlPoint* control_point; if ((control_point = reinterpret_cast (item->get_data ("control_point"))) == 0) { @@ -2063,7 +2308,6 @@ Editor::edit_control_point (ArdourCanvas::Item* item) } ControlPointDialog d (p); - d.set_position (Gtk::WIN_POS_MOUSE); ensure_float (d); if (d.run () != RESPONSE_ACCEPT) { @@ -2074,18 +2318,33 @@ Editor::edit_control_point (ArdourCanvas::Item* item) } void -Editor::edit_note (ArdourCanvas::Item* item) +Editor::edit_notes (TimeAxisViewItem& tavi) { - ArdourCanvas::CanvasNoteEvent* e = dynamic_cast (item); - assert (e); + MidiRegionView* mrv = dynamic_cast(&tavi); - EditNoteDialog d (&e->region_view(), e); - d.set_position (Gtk::WIN_POS_MOUSE); - ensure_float (d); + if (!mrv) { + return; + } - d.run (); -} + MidiRegionView::Selection const & s = mrv->selection(); + + if (s.empty ()) { + return; + } + EditNoteDialog* d = new EditNoteDialog (&(*s.begin())->region_view(), s); + d->show_all (); + ensure_float (*d); + + d->signal_response().connect (sigc::bind (sigc::mem_fun (*this, &Editor::note_edit_done), d)); +} + +void +Editor::note_edit_done (int r, EditNoteDialog* d) +{ + d->done (r); + delete d; +} void Editor::visible_order_range (int* low, int* high) const @@ -2145,146 +2404,6 @@ Editor::region_view_item_click (AudioRegionView& rv, GdkEventButton* event) } } -void -Editor::show_verbose_time_cursor (framepos_t frame, double offset, double xpos, double ypos) -{ - char buf[128]; - Timecode::Time timecode; - BBT_Time bbt; - int hours, mins; - framepos_t frame_rate; - float secs; - - if (_session == 0) { - return; - } - - AudioClock::Mode m; - - if (Profile->get_sae() || Profile->get_small_screen()) { - m = ARDOUR_UI::instance()->primary_clock.mode(); - } else { - m = ARDOUR_UI::instance()->secondary_clock.mode(); - } - - switch (m) { - case AudioClock::BBT: - _session->bbt_time (frame, bbt); - snprintf (buf, sizeof (buf), "%02" PRIu32 "|%02" PRIu32 "|%02" PRIu32, bbt.bars, bbt.beats, bbt.ticks); - break; - - case AudioClock::Timecode: - _session->timecode_time (frame, timecode); - snprintf (buf, sizeof (buf), "%02" PRId32 ":%02" PRId32 ":%02" PRId32 ":%02" PRId32, timecode.hours, timecode.minutes, timecode.seconds, timecode.frames); - break; - - case AudioClock::MinSec: - /* XXX this is copied from show_verbose_duration_cursor() */ - frame_rate = _session->frame_rate(); - hours = frame / (frame_rate * 3600); - frame = frame % (frame_rate * 3600); - mins = frame / (frame_rate * 60); - frame = frame % (frame_rate * 60); - secs = (float) frame / (float) frame_rate; - snprintf (buf, sizeof (buf), "%02" PRId32 ":%02" PRId32 ":%07.4f", hours, mins, secs); - break; - - default: - snprintf (buf, sizeof(buf), "%" PRIi64, frame); - break; - } - - if (xpos >= 0 && ypos >=0) { - set_verbose_canvas_cursor (buf, xpos + offset, ypos + offset); - } else { - set_verbose_canvas_cursor (buf, _drags->current_pointer_x() + offset - horizontal_position(), _drags->current_pointer_y() + offset - vertical_adjustment.get_value() + canvas_timebars_vsize); - } - show_verbose_canvas_cursor (); -} - -void -Editor::show_verbose_duration_cursor (framepos_t start, framepos_t end, double offset, double xpos, double ypos) -{ - char buf[128]; - Timecode::Time timecode; - BBT_Time sbbt; - BBT_Time ebbt; - int hours, mins; - framepos_t distance, frame_rate; - float secs; - Meter meter_at_start(_session->tempo_map().meter_at(start)); - - if (_session == 0) { - return; - } - - AudioClock::Mode m; - - if (Profile->get_sae() || Profile->get_small_screen()) { - m = ARDOUR_UI::instance()->primary_clock.mode (); - } else { - m = ARDOUR_UI::instance()->secondary_clock.mode (); - } - - switch (m) { - case AudioClock::BBT: - _session->bbt_time (start, sbbt); - _session->bbt_time (end, ebbt); - - /* subtract */ - /* XXX this computation won't work well if the - user makes a selection that spans any meter changes. - */ - - ebbt.bars -= sbbt.bars; - if (ebbt.beats >= sbbt.beats) { - ebbt.beats -= sbbt.beats; - } else { - ebbt.bars--; - ebbt.beats = int(meter_at_start.beats_per_bar()) + ebbt.beats - sbbt.beats; - } - if (ebbt.ticks >= sbbt.ticks) { - ebbt.ticks -= sbbt.ticks; - } else { - ebbt.beats--; - ebbt.ticks = int(Meter::ticks_per_beat) + ebbt.ticks - sbbt.ticks; - } - - snprintf (buf, sizeof (buf), "%02" PRIu32 "|%02" PRIu32 "|%02" PRIu32, ebbt.bars, ebbt.beats, ebbt.ticks); - break; - - case AudioClock::Timecode: - _session->timecode_duration (end - start, timecode); - snprintf (buf, sizeof (buf), "%02" PRId32 ":%02" PRId32 ":%02" PRId32 ":%02" PRId32, timecode.hours, timecode.minutes, timecode.seconds, timecode.frames); - break; - - case AudioClock::MinSec: - /* XXX this stuff should be elsewhere.. */ - distance = end - start; - frame_rate = _session->frame_rate(); - hours = distance / (frame_rate * 3600); - distance = distance % (frame_rate * 3600); - mins = distance / (frame_rate * 60); - distance = distance % (frame_rate * 60); - secs = (float) distance / (float) frame_rate; - snprintf (buf, sizeof (buf), "%02" PRId32 ":%02" PRId32 ":%07.4f", hours, mins, secs); - break; - - default: - snprintf (buf, sizeof(buf), "%" PRIi64, end - start); - break; - } - - if (xpos >= 0 && ypos >=0) { - set_verbose_canvas_cursor (buf, xpos + offset, ypos + offset); - } - else { - set_verbose_canvas_cursor (buf, _drags->current_pointer_x() + offset, _drags->current_pointer_y() + offset); - } - - show_verbose_canvas_cursor (); -} - void Editor::collect_new_region_view (RegionView* rv) { @@ -2309,133 +2428,15 @@ Editor::cancel_selection () clicked_selection = 0; } - -void -Editor::single_contents_trim (RegionView& rv, framepos_t frame_delta, bool left_direction, bool swap_direction) -{ - boost::shared_ptr region (rv.region()); - - if (region->locked()) { - return; - } - - framepos_t new_bound; - - double speed = 1.0; - TimeAxisView* tvp = clicked_axisview; - RouteTimeAxisView* tv = dynamic_cast(tvp); - - if (tv && tv->is_track()) { - speed = tv->track()->speed(); - } - - if (left_direction) { - if (swap_direction) { - new_bound = (framepos_t) (region->position()/speed) + frame_delta; - } else { - new_bound = (framepos_t) (region->position()/speed) - frame_delta; - } - } else { - if (swap_direction) { - new_bound = (framepos_t) (region->position()/speed) - frame_delta; - } else { - new_bound = (framepos_t) (region->position()/speed) + frame_delta; - } - } - - region->trim_start ((framepos_t) (new_bound * speed), this); - rv.region_changed (PropertyChange (ARDOUR::Properties::start)); -} - -void -Editor::single_start_trim (RegionView& rv, framepos_t new_bound, bool no_overlap) -{ - boost::shared_ptr region (rv.region()); - - if (region->locked()) { - return; - } - - double speed = 1.0; - TimeAxisView* tvp = clicked_axisview; - RouteTimeAxisView* tv = dynamic_cast(tvp); - - if (tv && tv->is_track()) { - speed = tv->track()->speed(); - } - - framepos_t pre_trim_first_frame = region->first_frame(); - - region->trim_front ((framepos_t) (new_bound * speed), this); - - if (no_overlap) { - //Get the next region on the left of this region and shrink/expand it. - boost::shared_ptr playlist (region->playlist()); - boost::shared_ptr region_left = playlist->find_next_region (pre_trim_first_frame, End, 0); - - bool regions_touching = false; - - if (region_left != 0 && (pre_trim_first_frame == region_left->last_frame() + 1)){ - regions_touching = true; - } - - //Only trim region on the left if the first frame has gone beyond the left region's last frame. - if (region_left != 0 && - (region_left->last_frame() > region->first_frame() || regions_touching)) - { - region_left->trim_end(region->first_frame() - 1, this); - } - } - - rv.region_changed (ARDOUR::bounds_change); -} - void -Editor::single_end_trim (RegionView& rv, framepos_t new_bound, bool no_overlap) +Editor::cancel_time_selection () { - boost::shared_ptr region (rv.region()); - - if (region->locked()) { - return; - } - - double speed = 1.0; - TimeAxisView* tvp = clicked_axisview; - RouteTimeAxisView* tv = dynamic_cast(tvp); - - if (tv && tv->is_track()) { - speed = tv->track()->speed(); - } - - framepos_t pre_trim_last_frame = region->last_frame(); - - region->trim_end ((framepos_t) (new_bound * speed), this); - - if (no_overlap) { - //Get the next region on the right of this region and shrink/expand it. - boost::shared_ptr playlist (region->playlist()); - boost::shared_ptr region_right = playlist->find_next_region (pre_trim_last_frame, Start, 1); - - bool regions_touching = false; - - if (region_right != 0 && (pre_trim_last_frame == region_right->first_frame() - 1)) { - regions_touching = true; - } - - //Only trim region on the right if the last frame has gone beyond the right region's first frame. - if (region_right != 0 && - (region_right->first_frame() < region->last_frame() || regions_touching)) - { - region_right->trim_front(region->last_frame() + 1, this); - } - - rv.region_changed (ARDOUR::bounds_change); - - } else { - rv.region_changed (PropertyChange (ARDOUR::Properties::length)); + for (TrackViewList::iterator i = track_views.begin(); i != track_views.end(); ++i) { + (*i)->hide_selection (); } -} - + selection->time.clear (); + clicked_selection = 0; +} void Editor::point_trim (GdkEvent* event, framepos_t new_bound) @@ -2451,13 +2452,9 @@ Editor::point_trim (GdkEvent* event, framepos_t new_bound) for (list::const_iterator i = selection->regions.by_layer().begin(); i != selection->regions.by_layer().end(); ++i) { - if ( (*i) == NULL){ - cerr << "region view contains null region" << endl; - } - if (!(*i)->region()->locked()) { (*i)->region()->clear_changes (); - (*i)->region()->trim_front (new_bound, this); + (*i)->region()->trim_front (new_bound); _session->add_command(new StatefulDiffCommand ((*i)->region())); } } @@ -2465,7 +2462,7 @@ Editor::point_trim (GdkEvent* event, framepos_t new_bound) } else { if (!rv->region()->locked()) { rv->region()->clear_changes (); - rv->region()->trim_front (new_bound, this); + rv->region()->trim_front (new_bound); _session->add_command(new StatefulDiffCommand (rv->region())); } } @@ -2482,7 +2479,7 @@ Editor::point_trim (GdkEvent* event, framepos_t new_bound) { if (!(*i)->region()->locked()) { (*i)->region()->clear_changes(); - (*i)->region()->trim_end (new_bound, this); + (*i)->region()->trim_end (new_bound); _session->add_command(new StatefulDiffCommand ((*i)->region())); } } @@ -2491,7 +2488,7 @@ Editor::point_trim (GdkEvent* event, framepos_t new_bound) if (!rv->region()->locked()) { rv->region()->clear_changes (); - rv->region()->trim_end (new_bound, this); + rv->region()->trim_end (new_bound); _session->add_command (new StatefulDiffCommand (rv->region())); } } @@ -2504,24 +2501,6 @@ Editor::point_trim (GdkEvent* event, framepos_t new_bound) } } -void -Editor::thaw_region_after_trim (RegionView& rv) -{ - boost::shared_ptr region (rv.region()); - - if (region->locked()) { - return; - } - - region->resume_property_changes (); - - AudioRegionView* arv = dynamic_cast(&rv); - - if (arv) { - arv->unhide_envelope (); - } -} - void Editor::hide_marker (ArdourCanvas::Item* item, GdkEvent* /*event*/) { @@ -2541,14 +2520,11 @@ Editor::hide_marker (ArdourCanvas::Item* item, GdkEvent* /*event*/) void Editor::reposition_zoom_rect (framepos_t start, framepos_t end) { - double x1 = frame_to_pixel (start); - double x2 = frame_to_pixel (end); - double y2 = full_canvas_height - 1.0; - - zoom_rect->property_x1() = x1; - zoom_rect->property_y1() = 1.0; - zoom_rect->property_x2() = x2; - zoom_rect->property_y2() = y2; + double x1 = sample_to_pixel (start); + double x2 = sample_to_pixel (end); + double y2 = _full_canvas_height - 1.0; + + zoom_rect->set (ArdourCanvas::Rect (x1, 1.0, x2, y2)); } @@ -2612,9 +2588,9 @@ Editor::mouse_brush_insert_region (RegionView* rv, framepos_t pos) boost::shared_ptr playlist = rtv->playlist(); double speed = rtv->track()->speed(); - playlist->clear_changes (); - boost::shared_ptr new_region (RegionFactory::create (rv->region())); - playlist->add_region (new_region, (framepos_t) (pos * speed)); + playlist->clear_changes (); + boost::shared_ptr new_region (RegionFactory::create (rv->region(), true)); + playlist->add_region (new_region, (framepos_t) (pos * speed)); _session->add_command (new StatefulDiffCommand (playlist)); // playlist is frozen, so we have to update manually XXX this is disgusting @@ -2633,59 +2609,53 @@ Editor::track_height_step_timeout () } void -Editor::add_region_drag (ArdourCanvas::Item* item, GdkEvent* event, RegionView* region_view) +Editor::add_region_drag (ArdourCanvas::Item* item, GdkEvent*, RegionView* region_view) { assert (region_view); - if (!region_view->region()->playlist()) { - return; - } + if (!region_view->region()->playlist()) { + return; + } _region_motion_group->raise_to_top (); if (Config->get_edit_mode() == Splice) { _drags->add (new RegionSpliceDrag (this, item, region_view, selection->regions.by_layer())); } else { - RegionSelection s = get_equivalent_regions (selection->regions, ARDOUR::Properties::edit.property_id); - _drags->add (new RegionMoveDrag (this, item, region_view, s.by_layer(), false, false)); + _drags->add (new RegionMoveDrag (this, item, region_view, selection->regions.by_layer(), false, false)); } - - /* sync the canvas to what we think is its current state */ - update_canvas_now(); } void -Editor::add_region_copy_drag (ArdourCanvas::Item* item, GdkEvent* event, RegionView* region_view) +Editor::add_region_copy_drag (ArdourCanvas::Item* item, GdkEvent*, RegionView* region_view) { assert (region_view); - if (!region_view->region()->playlist()) { - return; - } + if (!region_view->region()->playlist()) { + return; + } _region_motion_group->raise_to_top (); - RegionSelection s = get_equivalent_regions (selection->regions, ARDOUR::Properties::edit.property_id); - _drags->add (new RegionMoveDrag (this, item, region_view, s.by_layer(), false, true)); + _drags->add (new RegionMoveDrag (this, item, region_view, selection->regions.by_layer(), false, true)); } void -Editor::add_region_brush_drag (ArdourCanvas::Item* item, GdkEvent* event, RegionView* region_view) +Editor::add_region_brush_drag (ArdourCanvas::Item* item, GdkEvent*, RegionView* region_view) { assert (region_view); - if (!region_view->region()->playlist()) { - return; - } - + if (!region_view->region()->playlist()) { + return; + } + if (Config->get_edit_mode() == Splice) { return; } - RegionSelection s = get_equivalent_regions (selection->regions, ARDOUR::Properties::edit.property_id); - _drags->add (new RegionMoveDrag (this, item, region_view, s.by_layer(), true, false)); + _drags->add (new RegionMoveDrag (this, item, region_view, selection->regions.by_layer(), true, false)); - begin_reversible_command (_("Drag region brush")); + begin_reversible_command (Operations::drag_region_brush); } /** Start a grab where a time range is selected, track(s) are selected, and the @@ -2726,11 +2696,11 @@ Editor::start_selection_grab (ArdourCanvas::Item* /*item*/, GdkEvent* event) creating the new region and another for moving it. */ - begin_reversible_command (_("selection grab")); + begin_reversible_command (Operations::selection_grab); boost::shared_ptr playlist = clicked_axisview->playlist(); - playlist->clear_changes (); + playlist->clear_changes (); clicked_routeview->playlist()->add_region (region, selection->time[clicked_selection].start); _session->add_command(new StatefulDiffCommand (playlist)); @@ -2764,44 +2734,64 @@ Editor::escape () void Editor::set_internal_edit (bool yn) { - _internal_editing = yn; + if (_internal_editing == yn) { + return; + } + _internal_editing = yn; + if (yn) { - mouse_select_button.set_image (*(manage (new Image (::get_icon("midi_tool_pencil"))))); - mouse_select_button.get_image ()->show (); - ARDOUR_UI::instance()->set_tip (mouse_select_button, _("Draw/Edit MIDI Notes")); - set_canvas_cursor (); + pre_internal_mouse_mode = mouse_mode; + pre_internal_snap_type = _snap_type; + pre_internal_snap_mode = _snap_mode; - /* deselect everything to avoid confusion when e.g. we can't now cut a previously selected - region because cut means "cut note" rather than "cut region". - */ - selection->clear (); + for (TrackViewList::iterator i = track_views.begin(); i != track_views.end(); ++i) { + (*i)->enter_internal_edit_mode (); + } + + set_snap_to (internal_snap_type); + set_snap_mode (internal_snap_mode); } else { - mouse_select_button.set_image (*(manage (new Image (::get_icon("tool_range"))))); - mouse_select_button.get_image ()->show (); - ARDOUR_UI::instance()->set_tip (mouse_select_button, _("Select/Move Ranges")); - mouse_mode_toggled (mouse_mode); // sets cursor + internal_snap_mode = _snap_mode; + internal_snap_type = _snap_type; + + for (TrackViewList::iterator i = track_views.begin(); i != track_views.end(); ++i) { + (*i)->leave_internal_edit_mode (); + } + + if (mouse_mode == MouseDraw && pre_internal_mouse_mode != MouseDraw) { + /* we were drawing .. flip back to something sensible */ + set_mouse_mode (pre_internal_mouse_mode); + } + + set_snap_to (pre_internal_snap_type); + set_snap_mode (pre_internal_snap_mode); } + + set_canvas_cursor (); } /** Update _join_object_range_state which indicate whether we are over the top or bottom half of a region view, * used by the `join object/range' tool mode. */ void -Editor::update_join_object_range_location (double x, double y) +Editor::update_join_object_range_location (double /*x*/, double y) { - /* XXX: actually, this decides based on whether the mouse is in the top or bottom half of a RouteTimeAxisView; - entered_{track,regionview} is not always setup (e.g. if the mouse is over a TimeSelection), and to get a Region + /* XXX: actually, this decides based on whether the mouse is in the top + or bottom half of a the waveform part RouteTimeAxisView; + + Note that entered_{track,regionview} is not always setup (e.g. if + the mouse is over a TimeSelection), and to get a Region that we're over requires searching the playlist. */ - - if (join_object_range_button.get_active() == false || (mouse_mode != MouseRange && mouse_mode != MouseObject)) { + + if ( !get_smart_mode() ) { _join_object_range_state = JOIN_OBJECT_RANGE_NONE; return; } - + if (mouse_mode == MouseObject) { _join_object_range_state = JOIN_OBJECT_RANGE_OBJECT; } else if (mouse_mode == MouseRange) { @@ -2809,8 +2799,8 @@ Editor::update_join_object_range_location (double x, double y) } /* XXX: maybe we should make entered_track work in all cases, rather than resorting to this */ - pair tvp = trackview_by_y_position (y + vertical_adjustment.get_value() - canvas_timebars_vsize); - + pair tvp = trackview_by_y_position (y); + if (tvp.first) { RouteTimeAxisView* rtv = dynamic_cast (tvp.first); @@ -2818,13 +2808,11 @@ Editor::update_join_object_range_location (double x, double y) double cx = 0; double cy = y; - rtv->canvas_display()->w2i (cx, cy); + rtv->canvas_display()->canvas_to_item (cx, cy); - double const c = cy / rtv->view()->child_height(); - double d; - double const f = modf (c, &d); + double const c = cy / (rtv->view()->child_height() - TimeAxisViewItem::NAME_HIGHLIGHT_SIZE); - _join_object_range_state = f < 0.5 ? JOIN_OBJECT_RANGE_RANGE : JOIN_OBJECT_RANGE_OBJECT; + _join_object_range_state = c <= 0.5 ? JOIN_OBJECT_RANGE_RANGE : JOIN_OBJECT_RANGE_OBJECT; } } } @@ -2844,8 +2832,57 @@ Editor::effective_mouse_mode () const void Editor::remove_midi_note (ArdourCanvas::Item* item, GdkEvent *) { - ArdourCanvas::CanvasNoteEvent* e = dynamic_cast (item); + NoteBase* e = reinterpret_cast (item->get_data ("notebase")); assert (e); e->region_view().delete_note (e->note ()); } + +void +Editor::set_canvas_cursor_for_region_view (double x, RegionView* rv) +{ + /* XXX: this check should not be necessary */ + if (rv == 0) { + return; + } + + assert (rv); + + ArdourCanvas::Group* g = rv->get_canvas_group (); + ArdourCanvas::Group* p = g->parent (); + + /* Compute x in region view parent coordinates */ + double dy = 0; + p->canvas_to_item (x, dy); + + boost::optional item_bbox = g->bounding_box (); + assert (item_bbox); + ArdourCanvas::Rect parent_bbox = g->item_to_parent (item_bbox.get ()); + + /* Halfway across the region */ + double const h = (parent_bbox.x0 + parent_bbox.x1) / 2; + + Trimmable::CanTrim ct = rv->region()->can_trim (); + if (x <= h) { + if (ct & Trimmable::FrontTrimEarlier) { + set_canvas_cursor (_cursors->left_side_trim); + } else { + set_canvas_cursor (_cursors->left_side_trim_right_only); + } + } else { + if (ct & Trimmable::EndTrimLater) { + set_canvas_cursor (_cursors->right_side_trim); + } else { + set_canvas_cursor (_cursors->right_side_trim_left_only); + } + } +} + +/** Obtain the pointer position in canvas coordinates */ +void +Editor::get_pointer_position (double& x, double& y) const +{ + int px, py; + _track_canvas->get_pointer (px, py); + _track_canvas->window_to_canvas (px, py, x, y); +}