2 Copyright (C) 2000 Paul Davis
4 This program is free software; you can redistribute it and/or modify
5 it under the terms of the GNU General Public License as published by
6 the Free Software Foundation; either version 2 of the License, or
7 (at your option) any later version.
9 This program is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 GNU General Public License for more details.
14 You should have received a copy of the GNU General Public License
15 along with this program; if not, write to the Free Software
16 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
25 #include "pbd/stacktrace.h"
27 #include "ardour/midi_region.h"
28 #include "ardour/region_factory.h"
29 #include "ardour/profile.h"
33 #include "public_editor.h"
34 #include "audio_region_view.h"
35 #include "audio_streamview.h"
36 #include "canvas-noevent-text.h"
37 #include "audio_time_axis.h"
38 #include "region_gain_line.h"
39 #include "automation_line.h"
40 #include "automation_time_axis.h"
41 #include "automation_line.h"
42 #include "control_point.h"
43 #include "canvas_impl.h"
44 #include "simplerect.h"
45 #include "editor_drag.h"
46 #include "midi_time_axis.h"
47 #include "editor_regions.h"
48 #include "verbose_cursor.h"
53 using namespace ARDOUR;
56 using namespace ArdourCanvas;
58 using Gtkmm2ext::Keyboard;
61 Editor::track_canvas_scroll (GdkEventScroll* ev)
64 int direction = ev->direction;
69 if (Keyboard::modifier_state_equals (ev->state, Keyboard::PrimaryModifier)) {
70 //for mouse-wheel zoom, force zoom-focus to mouse
71 Editing::ZoomFocus temp_focus = zoom_focus;
72 zoom_focus = Editing::ZoomFocusMouse;
73 temporal_zoom_step (false);
74 zoom_focus = temp_focus;
76 } else if (Keyboard::modifier_state_equals (ev->state, Keyboard::SecondaryModifier)) {
77 direction = GDK_SCROLL_LEFT;
79 } else if (Keyboard::modifier_state_equals (ev->state, Keyboard::TertiaryModifier)) {
80 if (!current_stepping_trackview) {
81 step_timeout = Glib::signal_timeout().connect (sigc::mem_fun(*this, &Editor::track_height_step_timeout), 500);
82 std::pair<TimeAxisView*, int> const p = trackview_by_y_position (ev->y + vertical_adjustment.get_value() - canvas_timebars_vsize);
83 current_stepping_trackview = p.first;
84 if (!current_stepping_trackview) {
88 last_track_height_step_timestamp = get_microseconds();
89 current_stepping_trackview->step_height (false);
92 scroll_tracks_up_line ();
98 if (Keyboard::modifier_state_equals (ev->state, Keyboard::PrimaryModifier)) {
99 //for mouse-wheel zoom, force zoom-focus to mouse
100 Editing::ZoomFocus temp_focus = zoom_focus;
101 zoom_focus = Editing::ZoomFocusMouse;
102 temporal_zoom_step (true);
103 zoom_focus = temp_focus;
105 } else if (Keyboard::modifier_state_equals (ev->state, Keyboard::SecondaryModifier)) {
106 direction = GDK_SCROLL_RIGHT;
108 } else if (Keyboard::modifier_state_equals (ev->state, Keyboard::TertiaryModifier)) {
109 if (!current_stepping_trackview) {
110 step_timeout = Glib::signal_timeout().connect (sigc::mem_fun(*this, &Editor::track_height_step_timeout), 500);
111 std::pair<TimeAxisView*, int> const p = trackview_by_y_position (ev->y + vertical_adjustment.get_value() - canvas_timebars_vsize);
112 current_stepping_trackview = p.first;
113 if (!current_stepping_trackview) {
117 last_track_height_step_timestamp = get_microseconds();
118 current_stepping_trackview->step_height (true);
121 scroll_tracks_down_line ();
126 case GDK_SCROLL_LEFT:
127 xdelta = (current_page_frames() / 8);
128 if (leftmost_frame > xdelta) {
129 reset_x_origin (leftmost_frame - xdelta);
135 case GDK_SCROLL_RIGHT:
136 xdelta = (current_page_frames() / 8);
137 if (max_framepos - xdelta > leftmost_frame) {
138 reset_x_origin (leftmost_frame + xdelta);
140 reset_x_origin (max_framepos - current_page_frames());
153 Editor::track_canvas_scroll_event (GdkEventScroll *event)
155 track_canvas->grab_focus();
156 return track_canvas_scroll (event);
160 Editor::track_canvas_button_press_event (GdkEventButton */*event*/)
163 track_canvas->grab_focus();
168 Editor::track_canvas_button_release_event (GdkEventButton *event)
170 if (_drags->active ()) {
171 _drags->end_grab ((GdkEvent*) event);
177 Editor::track_canvas_motion_notify_event (GdkEventMotion */*event*/)
180 /* keep those motion events coming */
181 track_canvas->get_pointer (x, y);
186 Editor::track_canvas_motion (GdkEvent *ev)
188 if (_verbose_cursor->visible ()) {
189 _verbose_cursor->set_position (ev->motion.x + 10, ev->motion.y + 10);
196 Editor::typed_event (ArdourCanvas::Item* item, GdkEvent *event, ItemType type)
200 switch (event->type) {
201 case GDK_BUTTON_PRESS:
202 case GDK_2BUTTON_PRESS:
203 case GDK_3BUTTON_PRESS:
204 ret = button_press_handler (item, event, type);
206 case GDK_BUTTON_RELEASE:
207 ret = button_release_handler (item, event, type);
209 case GDK_MOTION_NOTIFY:
210 ret = motion_handler (item, event);
213 case GDK_ENTER_NOTIFY:
214 ret = enter_handler (item, event, type);
217 case GDK_LEAVE_NOTIFY:
218 ret = leave_handler (item, event, type);
222 ret = key_press_handler (item, event, type);
225 case GDK_KEY_RELEASE:
226 ret = key_release_handler (item, event, type);
236 Editor::canvas_region_view_event (GdkEvent *event, ArdourCanvas::Item* item, RegionView *rv)
240 if (!rv->sensitive ()) {
244 switch (event->type) {
245 case GDK_BUTTON_PRESS:
246 case GDK_2BUTTON_PRESS:
247 case GDK_3BUTTON_PRESS:
248 clicked_regionview = rv;
249 clicked_control_point = 0;
250 clicked_axisview = &rv->get_time_axis_view();
251 clicked_routeview = dynamic_cast<RouteTimeAxisView*>(clicked_axisview);
252 ret = button_press_handler (item, event, RegionItem);
255 case GDK_BUTTON_RELEASE:
256 ret = button_release_handler (item, event, RegionItem);
259 case GDK_MOTION_NOTIFY:
260 ret = motion_handler (item, event);
263 case GDK_ENTER_NOTIFY:
264 set_entered_track (&rv->get_time_axis_view ());
265 set_entered_regionview (rv);
268 case GDK_LEAVE_NOTIFY:
269 set_entered_track (0);
270 set_entered_regionview (0);
281 Editor::canvas_stream_view_event (GdkEvent *event, ArdourCanvas::Item* item, RouteTimeAxisView *tv)
285 switch (event->type) {
286 case GDK_BUTTON_PRESS:
287 case GDK_2BUTTON_PRESS:
288 case GDK_3BUTTON_PRESS:
289 clicked_regionview = 0;
290 clicked_control_point = 0;
291 clicked_axisview = tv;
292 clicked_routeview = dynamic_cast<RouteTimeAxisView*>(clicked_axisview);
293 ret = button_press_handler (item, event, StreamItem);
296 case GDK_BUTTON_RELEASE:
297 ret = button_release_handler (item, event, StreamItem);
300 case GDK_MOTION_NOTIFY:
301 ret = motion_handler (item, event);
304 case GDK_ENTER_NOTIFY:
305 set_entered_track (tv);
308 case GDK_LEAVE_NOTIFY:
309 set_entered_track (0);
320 Editor::canvas_automation_track_event (GdkEvent *event, ArdourCanvas::Item* item, AutomationTimeAxisView *atv)
324 switch (event->type) {
325 case GDK_BUTTON_PRESS:
326 case GDK_2BUTTON_PRESS:
327 case GDK_3BUTTON_PRESS:
328 clicked_regionview = 0;
329 clicked_control_point = 0;
330 clicked_axisview = atv;
331 clicked_routeview = 0;
332 ret = button_press_handler (item, event, AutomationTrackItem);
335 case GDK_BUTTON_RELEASE:
336 ret = button_release_handler (item, event, AutomationTrackItem);
339 case GDK_MOTION_NOTIFY:
340 ret = motion_handler (item, event);
343 case GDK_ENTER_NOTIFY:
344 ret = enter_handler (item, event, AutomationTrackItem);
347 case GDK_LEAVE_NOTIFY:
348 ret = leave_handler (item, event, AutomationTrackItem);
359 Editor::canvas_start_xfade_event (GdkEvent *event, ArdourCanvas::Item* item, AudioRegionView *rv)
361 if (!rv->sensitive()) {
365 switch (event->type) {
366 case GDK_BUTTON_PRESS:
367 clicked_regionview = rv;
368 clicked_control_point = 0;
369 clicked_axisview = &rv->get_time_axis_view();
370 clicked_routeview = dynamic_cast<RouteTimeAxisView*>(clicked_axisview);
371 if (event->button.button == 3) {
372 return button_press_handler (item, event, StartCrossFadeItem);
376 case GDK_BUTTON_RELEASE:
377 if (event->button.button == 3) {
378 return button_release_handler (item, event, StartCrossFadeItem);
387 /* In Mixbus, the crossfade area is used to trim the region while leaving the fade anchor intact (see preserve_fade_anchor)*/
388 /* however in A3 this feature is unfinished, and it might be better to do it with a modifier-trim instead, anyway */
389 /* if we return RegionItem here then we avoid the issue until it is resolved later */
390 return typed_event (item, event, RegionItem); // StartCrossFadeItem);
394 Editor::canvas_end_xfade_event (GdkEvent *event, ArdourCanvas::Item* item, AudioRegionView *rv)
396 if (!rv->sensitive()) {
400 switch (event->type) {
401 case GDK_BUTTON_PRESS:
402 clicked_regionview = rv;
403 clicked_control_point = 0;
404 clicked_axisview = &rv->get_time_axis_view();
405 clicked_routeview = dynamic_cast<RouteTimeAxisView*>(clicked_axisview);
406 if (event->button.button == 3) {
407 return button_press_handler (item, event, EndCrossFadeItem);
411 case GDK_BUTTON_RELEASE:
412 if (event->button.button == 3) {
413 return button_release_handler (item, event, EndCrossFadeItem);
422 /* In Mixbus, the crossfade area is used to trim the region while leaving the fade anchor intact (see preserve_fade_anchor)*/
423 /* however in A3 this feature is unfinished, and it might be better to do it with a modifier-trim instead, anyway */
424 /* if we return RegionItem here then we avoid the issue until it is resolved later */
425 return typed_event (item, event, RegionItem); // EndCrossFadeItem);
429 Editor::canvas_fade_in_event (GdkEvent *event, ArdourCanvas::Item* item, AudioRegionView *rv)
431 /* we handle only button 3 press/release events */
433 if (!rv->sensitive()) {
437 switch (event->type) {
438 case GDK_BUTTON_PRESS:
439 clicked_regionview = rv;
440 clicked_control_point = 0;
441 clicked_axisview = &rv->get_time_axis_view();
442 clicked_routeview = dynamic_cast<RouteTimeAxisView*>(clicked_axisview);
443 if (event->button.button == 3) {
444 return button_press_handler (item, event, FadeInItem);
448 case GDK_BUTTON_RELEASE:
449 if (event->button.button == 3) {
450 return button_release_handler (item, event, FadeInItem);
459 /* proxy for the regionview */
461 return canvas_region_view_event (event, rv->get_canvas_group(), rv);
465 Editor::canvas_fade_in_handle_event (GdkEvent *event, ArdourCanvas::Item* item, AudioRegionView *rv)
469 if (!rv->sensitive()) {
473 switch (event->type) {
474 case GDK_BUTTON_PRESS:
475 case GDK_2BUTTON_PRESS:
476 case GDK_3BUTTON_PRESS:
477 clicked_regionview = rv;
478 clicked_control_point = 0;
479 clicked_axisview = &rv->get_time_axis_view();
480 clicked_routeview = dynamic_cast<RouteTimeAxisView*>(clicked_axisview);
481 ret = button_press_handler (item, event, FadeInHandleItem);
484 case GDK_BUTTON_RELEASE:
485 ret = button_release_handler (item, event, FadeInHandleItem);
486 maybe_locate_with_edit_preroll ( rv->region()->position() );
489 case GDK_MOTION_NOTIFY:
490 ret = motion_handler (item, event);
493 case GDK_ENTER_NOTIFY:
494 set_entered_regionview (rv);
495 ret = enter_handler (item, event, FadeInHandleItem);
498 case GDK_LEAVE_NOTIFY:
499 set_entered_regionview (0);
500 ret = leave_handler (item, event, FadeInHandleItem);
511 Editor::canvas_fade_out_event (GdkEvent *event, ArdourCanvas::Item* item, AudioRegionView *rv)
513 /* we handle only button 3 press/release events */
515 if (!rv->sensitive()) {
519 switch (event->type) {
520 case GDK_BUTTON_PRESS:
521 clicked_regionview = rv;
522 clicked_control_point = 0;
523 clicked_axisview = &rv->get_time_axis_view();
524 clicked_routeview = dynamic_cast<RouteTimeAxisView*>(clicked_axisview);
525 if (event->button.button == 3) {
526 return button_press_handler (item, event, FadeOutItem);
530 case GDK_BUTTON_RELEASE:
531 if (event->button.button == 3) {
532 return button_release_handler (item, event, FadeOutItem);
541 /* proxy for the regionview */
543 return canvas_region_view_event (event, rv->get_canvas_group(), rv);
547 Editor::canvas_fade_out_handle_event (GdkEvent *event, ArdourCanvas::Item* item, AudioRegionView *rv)
551 if (!rv->sensitive()) {
555 switch (event->type) {
556 case GDK_BUTTON_PRESS:
557 case GDK_2BUTTON_PRESS:
558 case GDK_3BUTTON_PRESS:
559 clicked_regionview = rv;
560 clicked_control_point = 0;
561 clicked_axisview = &rv->get_time_axis_view();
562 clicked_routeview = dynamic_cast<RouteTimeAxisView*>(clicked_axisview);
563 ret = button_press_handler (item, event, FadeOutHandleItem);
566 case GDK_BUTTON_RELEASE:
567 ret = button_release_handler (item, event, FadeOutHandleItem);
568 maybe_locate_with_edit_preroll ( rv->region()->last_frame() - rv->get_fade_out_shape_width() );
571 case GDK_MOTION_NOTIFY:
572 ret = motion_handler (item, event);
575 case GDK_ENTER_NOTIFY:
576 set_entered_regionview (rv);
577 ret = enter_handler (item, event, FadeOutHandleItem);
580 case GDK_LEAVE_NOTIFY:
581 set_entered_regionview (0);
582 ret = leave_handler (item, event, FadeOutHandleItem);
592 struct DescendingRegionLayerSorter {
593 bool operator()(boost::shared_ptr<Region> a, boost::shared_ptr<Region> b) {
594 return a->layer() > b->layer();
599 Editor::canvas_control_point_event (GdkEvent *event, ArdourCanvas::Item* item, ControlPoint* cp)
601 switch (event->type) {
602 case GDK_BUTTON_PRESS:
603 case GDK_2BUTTON_PRESS:
604 case GDK_3BUTTON_PRESS:
605 clicked_control_point = cp;
606 clicked_axisview = &cp->line().trackview;
607 clicked_routeview = dynamic_cast<RouteTimeAxisView*>(clicked_axisview);
608 clicked_regionview = 0;
614 case GDK_SCROLL_DOWN:
621 return typed_event (item, event, ControlPointItem);
625 Editor::canvas_line_event (GdkEvent *event, ArdourCanvas::Item* item, AutomationLine* al)
629 if (dynamic_cast<AudioRegionGainLine*> (al) != 0) {
632 type = AutomationLineItem;
635 return typed_event (item, event, type);
639 Editor::canvas_selection_rect_event (GdkEvent *event, ArdourCanvas::Item* item, SelectionRect* rect)
643 switch (event->type) {
644 case GDK_BUTTON_PRESS:
645 case GDK_2BUTTON_PRESS:
646 case GDK_3BUTTON_PRESS:
647 clicked_selection = rect->id;
648 ret = button_press_handler (item, event, SelectionItem);
650 case GDK_BUTTON_RELEASE:
651 ret = button_release_handler (item, event, SelectionItem);
653 case GDK_MOTION_NOTIFY:
654 ret = motion_handler (item, event);
656 /* Don't need these at the moment. */
657 case GDK_ENTER_NOTIFY:
658 ret = enter_handler (item, event, SelectionItem);
661 case GDK_LEAVE_NOTIFY:
662 ret = leave_handler (item, event, SelectionItem);
673 Editor::canvas_selection_start_trim_event (GdkEvent *event, ArdourCanvas::Item* item, SelectionRect* rect)
677 switch (event->type) {
678 case GDK_BUTTON_PRESS:
679 case GDK_2BUTTON_PRESS:
680 case GDK_3BUTTON_PRESS:
681 clicked_selection = rect->id;
682 ret = button_press_handler (item, event, StartSelectionTrimItem);
684 case GDK_BUTTON_RELEASE:
685 ret = button_release_handler (item, event, StartSelectionTrimItem);
687 case GDK_MOTION_NOTIFY:
688 ret = motion_handler (item, event);
690 case GDK_ENTER_NOTIFY:
691 ret = enter_handler (item, event, StartSelectionTrimItem);
694 case GDK_LEAVE_NOTIFY:
695 ret = leave_handler (item, event, StartSelectionTrimItem);
706 Editor::canvas_selection_end_trim_event (GdkEvent *event, ArdourCanvas::Item* item, SelectionRect* rect)
710 switch (event->type) {
711 case GDK_BUTTON_PRESS:
712 case GDK_2BUTTON_PRESS:
713 case GDK_3BUTTON_PRESS:
714 clicked_selection = rect->id;
715 ret = button_press_handler (item, event, EndSelectionTrimItem);
717 case GDK_BUTTON_RELEASE:
718 ret = button_release_handler (item, event, EndSelectionTrimItem);
720 case GDK_MOTION_NOTIFY:
721 ret = motion_handler (item, event);
723 case GDK_ENTER_NOTIFY:
724 ret = enter_handler (item, event, EndSelectionTrimItem);
727 case GDK_LEAVE_NOTIFY:
728 ret = leave_handler (item, event, EndSelectionTrimItem);
739 Editor::canvas_frame_handle_event (GdkEvent* event, ArdourCanvas::Item* item, RegionView* rv)
743 /* frame handles are not active when in internal edit mode, because actual notes
744 might be in the area occupied by the handle - we want them to be editable as normal.
747 if (internal_editing() || !rv->sensitive()) {
751 /* NOTE: frame handles pretend to be the colored trim bar from an event handling
752 perspective. XXX change this ??
757 if (item->get_data ("isleft")) {
758 type = LeftFrameHandle;
760 type = RightFrameHandle;
763 switch (event->type) {
764 case GDK_BUTTON_PRESS:
765 case GDK_2BUTTON_PRESS:
766 case GDK_3BUTTON_PRESS:
767 clicked_regionview = rv;
768 clicked_control_point = 0;
769 clicked_axisview = &clicked_regionview->get_time_axis_view();
770 clicked_routeview = dynamic_cast<RouteTimeAxisView*>(clicked_axisview);
771 ret = button_press_handler (item, event, type);
773 case GDK_BUTTON_RELEASE:
774 ret = button_release_handler (item, event, type);
776 case GDK_MOTION_NOTIFY:
777 ret = motion_handler (item, event);
779 case GDK_ENTER_NOTIFY:
780 set_entered_regionview (rv);
781 ret = enter_handler (item, event, type);
784 case GDK_LEAVE_NOTIFY:
785 set_entered_regionview (0);
786 ret = leave_handler (item, event, type);
798 Editor::canvas_region_view_name_highlight_event (GdkEvent* event, ArdourCanvas::Item* item, RegionView* rv)
802 if (!rv->sensitive()) {
806 switch (event->type) {
807 case GDK_BUTTON_PRESS:
808 case GDK_2BUTTON_PRESS:
809 case GDK_3BUTTON_PRESS:
810 clicked_regionview = rv;
811 clicked_control_point = 0;
812 clicked_axisview = &clicked_regionview->get_time_axis_view();
813 clicked_routeview = dynamic_cast<RouteTimeAxisView*>(clicked_axisview);
814 ret = button_press_handler (item, event, RegionViewNameHighlight);
816 case GDK_BUTTON_RELEASE:
817 ret = button_release_handler (item, event, RegionViewNameHighlight);
819 case GDK_MOTION_NOTIFY:
820 motion_handler (item, event);
821 ret = true; // force this to avoid progagating the event into the regionview
823 case GDK_ENTER_NOTIFY:
824 set_entered_regionview (rv);
825 ret = enter_handler (item, event, RegionViewNameHighlight);
828 case GDK_LEAVE_NOTIFY:
829 set_entered_regionview (0);
830 ret = leave_handler (item, event, RegionViewNameHighlight);
841 Editor::canvas_region_view_name_event (GdkEvent *event, ArdourCanvas::Item* item, RegionView* rv)
845 if (!rv->sensitive()) {
849 switch (event->type) {
850 case GDK_BUTTON_PRESS:
851 case GDK_2BUTTON_PRESS:
852 case GDK_3BUTTON_PRESS:
853 clicked_regionview = rv;
854 clicked_control_point = 0;
855 clicked_axisview = &clicked_regionview->get_time_axis_view();
856 clicked_routeview = dynamic_cast<RouteTimeAxisView*>(clicked_axisview);
857 ret = button_press_handler (item, event, RegionViewName);
859 case GDK_BUTTON_RELEASE:
860 ret = button_release_handler (item, event, RegionViewName);
862 case GDK_MOTION_NOTIFY:
863 ret = motion_handler (item, event);
865 case GDK_ENTER_NOTIFY:
866 set_entered_regionview (rv);
867 ret = enter_handler (item, event, RegionViewName);
870 case GDK_LEAVE_NOTIFY:
871 set_entered_regionview (0);
872 ret = leave_handler (item, event, RegionViewName);
883 Editor::canvas_feature_line_event (GdkEvent *event, ArdourCanvas::Item* item, RegionView*)
887 switch (event->type) {
888 case GDK_BUTTON_PRESS:
889 case GDK_2BUTTON_PRESS:
890 case GDK_3BUTTON_PRESS:
891 clicked_regionview = 0;
892 clicked_control_point = 0;
893 clicked_axisview = 0;
894 clicked_routeview = 0; //dynamic_cast<RouteTimeAxisView*>(clicked_axisview);
895 ret = button_press_handler (item, event, FeatureLineItem);
898 case GDK_BUTTON_RELEASE:
899 ret = button_release_handler (item, event, FeatureLineItem);
902 case GDK_MOTION_NOTIFY:
903 ret = motion_handler (item, event);
906 case GDK_ENTER_NOTIFY:
907 ret = enter_handler (item, event, FeatureLineItem);
910 case GDK_LEAVE_NOTIFY:
911 ret = leave_handler (item, event, FeatureLineItem);
922 Editor::canvas_marker_event (GdkEvent *event, ArdourCanvas::Item* item, Marker* /*marker*/)
924 return typed_event (item, event, MarkerItem);
928 Editor::canvas_marker_bar_event (GdkEvent *event, ArdourCanvas::Item* item)
930 return typed_event (item, event, MarkerBarItem);
934 Editor::canvas_range_marker_bar_event (GdkEvent *event, ArdourCanvas::Item* item)
936 return typed_event (item, event, RangeMarkerBarItem);
940 Editor::canvas_transport_marker_bar_event (GdkEvent *event, ArdourCanvas::Item* item)
942 return typed_event (item, event, TransportMarkerBarItem);
946 Editor::canvas_cd_marker_bar_event (GdkEvent *event, ArdourCanvas::Item* item)
948 return typed_event (item, event, CdMarkerBarItem);
952 Editor::canvas_videotl_bar_event (GdkEvent *event, ArdourCanvas::Item* item)
954 return typed_event (item, event, VideoBarItem);
958 Editor::canvas_tempo_marker_event (GdkEvent *event, ArdourCanvas::Item* item, TempoMarker* /*marker*/)
960 return typed_event (item, event, TempoMarkerItem);
964 Editor::canvas_meter_marker_event (GdkEvent *event, ArdourCanvas::Item* item, MeterMarker* /*marker*/)
966 return typed_event (item, event, MeterMarkerItem);
970 Editor::canvas_tempo_bar_event (GdkEvent *event, ArdourCanvas::Item* item)
972 return typed_event (item, event, TempoBarItem);
976 Editor::canvas_meter_bar_event (GdkEvent *event, ArdourCanvas::Item* item)
978 return typed_event (item, event, MeterBarItem);
982 Editor::canvas_playhead_cursor_event (GdkEvent *event, ArdourCanvas::Item* item)
984 return typed_event (item, event, PlayheadCursorItem);
988 Editor::canvas_zoom_rect_event (GdkEvent *event, ArdourCanvas::Item* item)
990 return typed_event (item, event, NoItem);
994 Editor::canvas_note_event (GdkEvent *event, ArdourCanvas::Item* item)
996 if (!internal_editing()) {
1000 return typed_event (item, event, NoteItem);
1004 Editor::track_canvas_drag_motion (Glib::RefPtr<Gdk::DragContext> const& context, int x, int y, guint time)
1008 boost::shared_ptr<Region> region;
1009 boost::shared_ptr<Region> region_copy;
1010 RouteTimeAxisView* rtav;
1015 string target = track_canvas->drag_dest_find_target (context, track_canvas->drag_dest_get_target_list());
1017 if (target.empty()) {
1021 track_canvas->window_to_world (x, y, wx, wy);
1023 event.type = GDK_MOTION_NOTIFY;
1024 event.button.x = wx;
1025 event.button.y = wy;
1026 /* assume we're dragging with button 1 */
1027 event.motion.state = Gdk::BUTTON1_MASK;
1029 (void) event_frame (&event, &px, &py);
1031 std::pair<TimeAxisView*, int> const tv = trackview_by_y_position (py);
1032 bool can_drop = false;
1034 if (tv.first != 0) {
1036 /* over a time axis view of some kind */
1038 rtav = dynamic_cast<RouteTimeAxisView*> (tv.first);
1040 if (rtav != 0 && rtav->is_track ()) {
1041 /* over a track, not a bus */
1047 /* not over a time axis view, so drop is possible */
1052 region = _regions->get_dragged_region ();
1056 if ((boost::dynamic_pointer_cast<AudioRegion> (region) != 0 &&
1057 dynamic_cast<AudioTimeAxisView*> (tv.first) != 0) ||
1058 (boost::dynamic_pointer_cast<MidiRegion> (region) != 0 &&
1059 dynamic_cast<MidiTimeAxisView*> (tv.first) != 0)) {
1066 context->drag_status (context->get_suggested_action(), time);
1070 /* DND originating from outside ardour
1072 * TODO: check if file is audio/midi, allow drops on same track-type only,
1073 * currently: if audio is dropped on a midi-track, it is only added to the region-list
1075 if (Profile->get_sae() || Config->get_only_copy_imported_files()) {
1076 context->drag_status(Gdk::ACTION_COPY, time);
1078 if ((context->get_actions() & (Gdk::ACTION_COPY | Gdk::ACTION_LINK | Gdk::ACTION_MOVE)) == Gdk::ACTION_COPY) {
1079 context->drag_status(Gdk::ACTION_COPY, time);
1081 context->drag_status(Gdk::ACTION_LINK, time);
1089 context->drag_status (Gdk::DragAction (0), time);
1094 Editor::drop_regions (const Glib::RefPtr<Gdk::DragContext>& /*context*/,
1096 const SelectionData& /*data*/,
1097 guint /*info*/, guint /*time*/)
1101 boost::shared_ptr<Region> region;
1102 boost::shared_ptr<Region> region_copy;
1103 RouteTimeAxisView* rtav;
1108 track_canvas->window_to_world (x, y, wx, wy);
1110 event.type = GDK_MOTION_NOTIFY;
1111 event.button.x = wx;
1112 event.button.y = wy;
1113 /* assume we're dragging with button 1 */
1114 event.motion.state = Gdk::BUTTON1_MASK;
1116 framepos_t const pos = event_frame (&event, &px, &py);
1118 std::pair<TimeAxisView*, int> const tv = trackview_by_y_position (py);
1120 if (tv.first != 0) {
1122 rtav = dynamic_cast<RouteTimeAxisView*> (tv.first);
1124 if (rtav != 0 && rtav->is_track ()) {
1126 boost::shared_ptr<Region> region = _regions->get_dragged_region ();
1130 region_copy = RegionFactory::create (region, true);
1133 if ((boost::dynamic_pointer_cast<AudioRegion> (region_copy) != 0 &&
1134 dynamic_cast<AudioTimeAxisView*> (tv.first) != 0) ||
1135 (boost::dynamic_pointer_cast<MidiRegion> (region_copy) != 0 &&
1136 dynamic_cast<MidiTimeAxisView*> (tv.first) != 0)) {
1144 _drags->set (new RegionInsertDrag (this, region_copy, rtav, pos), &event);
1145 _drags->end_grab (0);
1153 Editor::key_press_handler (ArdourCanvas::Item*, GdkEvent*, ItemType)
1159 Editor::key_release_handler (ArdourCanvas::Item* item, GdkEvent* event, ItemType type)
1162 bool handled = false;
1165 case TempoMarkerItem:
1166 switch (event->key.keyval) {
1168 remove_tempo_marker (item);
1176 case MeterMarkerItem:
1177 switch (event->key.keyval) {
1179 remove_meter_marker (item);