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/audioplaylist.h"
28 #include "ardour/audioregion.h"
29 #include "ardour/region_factory.h"
30 #include "ardour/midi_region.h"
34 #include "public_editor.h"
35 #include "audio_region_view.h"
36 #include "audio_streamview.h"
37 #include "canvas-noevent-text.h"
38 #include "crossfade_view.h"
39 #include "audio_time_axis.h"
40 #include "region_gain_line.h"
41 #include "automation_line.h"
42 #include "automation_time_axis.h"
43 #include "automation_line.h"
44 #include "control_point.h"
45 #include "canvas_impl.h"
46 #include "simplerect.h"
47 #include "editor_drag.h"
48 #include "midi_time_axis.h"
49 #include "editor_regions.h"
50 #include "verbose_cursor.h"
55 using namespace ARDOUR;
58 using namespace ArdourCanvas;
60 using Gtkmm2ext::Keyboard;
63 Editor::track_canvas_scroll (GdkEventScroll* ev)
66 int direction = ev->direction;
71 if (Keyboard::modifier_state_equals (ev->state, Keyboard::PrimaryModifier)) {
72 temporal_zoom_step (false);
74 } else if (Keyboard::modifier_state_equals (ev->state, Keyboard::SecondaryModifier)) {
75 direction = GDK_SCROLL_LEFT;
77 } else if (Keyboard::modifier_state_equals (ev->state, Keyboard::TertiaryModifier)) {
78 if (!current_stepping_trackview) {
79 step_timeout = Glib::signal_timeout().connect (sigc::mem_fun(*this, &Editor::track_height_step_timeout), 500);
80 std::pair<TimeAxisView*, int> const p = trackview_by_y_position (ev->y + vertical_adjustment.get_value() - canvas_timebars_vsize);
81 current_stepping_trackview = p.first;
82 if (!current_stepping_trackview) {
86 last_track_height_step_timestamp = get_microseconds();
87 current_stepping_trackview->step_height (false);
90 scroll_tracks_up_line ();
96 if (Keyboard::modifier_state_equals (ev->state, Keyboard::PrimaryModifier)) {
97 temporal_zoom_step (true);
99 } else if (Keyboard::modifier_state_equals (ev->state, Keyboard::SecondaryModifier)) {
100 direction = GDK_SCROLL_RIGHT;
102 } else if (Keyboard::modifier_state_equals (ev->state, Keyboard::TertiaryModifier)) {
103 if (!current_stepping_trackview) {
104 step_timeout = Glib::signal_timeout().connect (sigc::mem_fun(*this, &Editor::track_height_step_timeout), 500);
105 std::pair<TimeAxisView*, int> const p = trackview_by_y_position (ev->y + vertical_adjustment.get_value() - canvas_timebars_vsize);
106 current_stepping_trackview = p.first;
107 if (!current_stepping_trackview) {
111 last_track_height_step_timestamp = get_microseconds();
112 current_stepping_trackview->step_height (true);
115 scroll_tracks_down_line ();
120 case GDK_SCROLL_LEFT:
121 xdelta = (current_page_frames() / 8);
122 if (leftmost_frame > xdelta) {
123 reset_x_origin (leftmost_frame - xdelta);
129 case GDK_SCROLL_RIGHT:
130 xdelta = (current_page_frames() / 8);
131 if (max_framepos - xdelta > leftmost_frame) {
132 reset_x_origin (leftmost_frame + xdelta);
134 reset_x_origin (max_framepos - current_page_frames());
147 Editor::track_canvas_scroll_event (GdkEventScroll *event)
149 track_canvas->grab_focus();
150 return track_canvas_scroll (event);
154 Editor::track_canvas_button_press_event (GdkEventButton */*event*/)
157 track_canvas->grab_focus();
162 Editor::track_canvas_button_release_event (GdkEventButton *event)
164 if (_drags->active ()) {
165 _drags->end_grab ((GdkEvent*) event);
171 Editor::track_canvas_motion_notify_event (GdkEventMotion */*event*/)
174 /* keep those motion events coming */
175 track_canvas->get_pointer (x, y);
180 Editor::track_canvas_motion (GdkEvent *ev)
182 if (_verbose_cursor->visible ()) {
183 _verbose_cursor->set_position (ev->motion.x + 10, ev->motion.y + 10);
190 Editor::typed_event (ArdourCanvas::Item* item, GdkEvent *event, ItemType type)
194 switch (event->type) {
195 case GDK_BUTTON_PRESS:
196 case GDK_2BUTTON_PRESS:
197 case GDK_3BUTTON_PRESS:
198 ret = button_press_handler (item, event, type);
200 case GDK_BUTTON_RELEASE:
201 ret = button_release_handler (item, event, type);
203 case GDK_MOTION_NOTIFY:
204 ret = motion_handler (item, event);
207 case GDK_ENTER_NOTIFY:
208 ret = enter_handler (item, event, type);
211 case GDK_LEAVE_NOTIFY:
212 ret = leave_handler (item, event, type);
222 Editor::canvas_region_view_event (GdkEvent *event, ArdourCanvas::Item* item, RegionView *rv)
226 if (!rv->sensitive ()) {
230 switch (event->type) {
231 case GDK_BUTTON_PRESS:
232 case GDK_2BUTTON_PRESS:
233 case GDK_3BUTTON_PRESS:
234 clicked_regionview = rv;
235 clicked_control_point = 0;
236 clicked_axisview = &rv->get_time_axis_view();
237 clicked_routeview = dynamic_cast<RouteTimeAxisView*>(clicked_axisview);
238 ret = button_press_handler (item, event, RegionItem);
241 case GDK_BUTTON_RELEASE:
242 ret = button_release_handler (item, event, RegionItem);
245 case GDK_MOTION_NOTIFY:
246 ret = motion_handler (item, event);
249 case GDK_ENTER_NOTIFY:
250 set_entered_track (&rv->get_time_axis_view ());
251 set_entered_regionview (rv);
254 case GDK_LEAVE_NOTIFY:
255 set_entered_track (0);
256 set_entered_regionview (0);
267 Editor::canvas_stream_view_event (GdkEvent *event, ArdourCanvas::Item* item, RouteTimeAxisView *tv)
271 switch (event->type) {
272 case GDK_BUTTON_PRESS:
273 case GDK_2BUTTON_PRESS:
274 case GDK_3BUTTON_PRESS:
275 clicked_regionview = 0;
276 clicked_control_point = 0;
277 clicked_axisview = tv;
278 clicked_routeview = dynamic_cast<RouteTimeAxisView*>(clicked_axisview);
279 ret = button_press_handler (item, event, StreamItem);
282 case GDK_BUTTON_RELEASE:
283 ret = button_release_handler (item, event, StreamItem);
286 case GDK_MOTION_NOTIFY:
287 ret = motion_handler (item, event);
290 case GDK_ENTER_NOTIFY:
291 set_entered_track (tv);
294 case GDK_LEAVE_NOTIFY:
295 set_entered_track (0);
306 Editor::canvas_automation_track_event (GdkEvent *event, ArdourCanvas::Item* item, AutomationTimeAxisView *atv)
310 switch (event->type) {
311 case GDK_BUTTON_PRESS:
312 case GDK_2BUTTON_PRESS:
313 case GDK_3BUTTON_PRESS:
314 clicked_regionview = 0;
315 clicked_control_point = 0;
316 clicked_axisview = atv;
317 clicked_routeview = 0;
318 ret = button_press_handler (item, event, AutomationTrackItem);
321 case GDK_BUTTON_RELEASE:
322 ret = button_release_handler (item, event, AutomationTrackItem);
325 case GDK_MOTION_NOTIFY:
326 ret = motion_handler (item, event);
329 case GDK_ENTER_NOTIFY:
330 ret = enter_handler (item, event, AutomationTrackItem);
333 case GDK_LEAVE_NOTIFY:
334 ret = leave_handler (item, event, AutomationTrackItem);
345 Editor::canvas_fade_in_event (GdkEvent *event, ArdourCanvas::Item* item, AudioRegionView *rv)
347 /* we handle only button 3 press/release events */
349 if (!rv->sensitive()) {
353 switch (event->type) {
354 case GDK_BUTTON_PRESS:
355 clicked_regionview = rv;
356 clicked_control_point = 0;
357 clicked_axisview = &rv->get_time_axis_view();
358 clicked_routeview = dynamic_cast<RouteTimeAxisView*>(clicked_axisview);
359 if (event->button.button == 3) {
360 return button_press_handler (item, event, FadeInItem);
364 case GDK_BUTTON_RELEASE:
365 if (event->button.button == 3) {
366 return button_release_handler (item, event, FadeInItem);
375 /* proxy for the regionview */
377 return canvas_region_view_event (event, rv->get_canvas_group(), rv);
381 Editor::canvas_fade_in_handle_event (GdkEvent *event, ArdourCanvas::Item* item, AudioRegionView *rv)
385 if (!rv->sensitive()) {
389 switch (event->type) {
390 case GDK_BUTTON_PRESS:
391 case GDK_2BUTTON_PRESS:
392 case GDK_3BUTTON_PRESS:
393 clicked_regionview = rv;
394 clicked_control_point = 0;
395 clicked_axisview = &rv->get_time_axis_view();
396 clicked_routeview = dynamic_cast<RouteTimeAxisView*>(clicked_axisview);
397 ret = button_press_handler (item, event, FadeInHandleItem);
400 case GDK_BUTTON_RELEASE:
401 ret = button_release_handler (item, event, FadeInHandleItem);
404 case GDK_MOTION_NOTIFY:
405 ret = motion_handler (item, event);
408 case GDK_ENTER_NOTIFY:
409 set_entered_regionview (rv);
410 ret = enter_handler (item, event, FadeInHandleItem);
413 case GDK_LEAVE_NOTIFY:
414 set_entered_regionview (0);
415 ret = leave_handler (item, event, FadeInHandleItem);
426 Editor::canvas_fade_out_event (GdkEvent *event, ArdourCanvas::Item* item, AudioRegionView *rv)
428 /* we handle only button 3 press/release events */
430 if (!rv->sensitive()) {
434 switch (event->type) {
435 case GDK_BUTTON_PRESS:
436 clicked_regionview = rv;
437 clicked_control_point = 0;
438 clicked_axisview = &rv->get_time_axis_view();
439 clicked_routeview = dynamic_cast<RouteTimeAxisView*>(clicked_axisview);
440 if (event->button.button == 3) {
441 return button_press_handler (item, event, FadeOutItem);
445 case GDK_BUTTON_RELEASE:
446 if (event->button.button == 3) {
447 return button_release_handler (item, event, FadeOutItem);
456 /* proxy for the regionview */
458 return canvas_region_view_event (event, rv->get_canvas_group(), rv);
462 Editor::canvas_fade_out_handle_event (GdkEvent *event, ArdourCanvas::Item* item, AudioRegionView *rv)
466 if (!rv->sensitive()) {
470 switch (event->type) {
471 case GDK_BUTTON_PRESS:
472 case GDK_2BUTTON_PRESS:
473 case GDK_3BUTTON_PRESS:
474 clicked_regionview = rv;
475 clicked_control_point = 0;
476 clicked_axisview = &rv->get_time_axis_view();
477 clicked_routeview = dynamic_cast<RouteTimeAxisView*>(clicked_axisview);
478 ret = button_press_handler (item, event, FadeOutHandleItem);
481 case GDK_BUTTON_RELEASE:
482 ret = button_release_handler (item, event, FadeOutHandleItem);
485 case GDK_MOTION_NOTIFY:
486 ret = motion_handler (item, event);
489 case GDK_ENTER_NOTIFY:
490 set_entered_regionview (rv);
491 ret = enter_handler (item, event, FadeOutHandleItem);
494 case GDK_LEAVE_NOTIFY:
495 set_entered_regionview (0);
496 ret = leave_handler (item, event, FadeOutHandleItem);
506 struct DescendingRegionLayerSorter {
507 bool operator()(boost::shared_ptr<Region> a, boost::shared_ptr<Region> b) {
508 return a->layer() > b->layer();
513 Editor::canvas_crossfade_view_event (GdkEvent* event, ArdourCanvas::Item* item, CrossfadeView* xfv)
515 /* we handle only button 3 press/release events */
517 switch (event->type) {
518 case GDK_BUTTON_PRESS:
519 clicked_crossfadeview = xfv;
520 clicked_axisview = &clicked_crossfadeview->get_time_axis_view();
521 clicked_routeview = dynamic_cast<RouteTimeAxisView*>(clicked_axisview);
522 if (event->button.button == 3) {
523 return button_press_handler (item, event, CrossfadeViewItem);
527 case GDK_BUTTON_RELEASE:
528 if (event->button.button == 3) {
529 bool ret = button_release_handler (item, event, CrossfadeViewItem);
539 /* XXX do not forward double clicks */
541 if (event->type == GDK_2BUTTON_PRESS) {
545 /* proxy for an underlying regionview */
547 /* XXX really need to check if we are in the name highlight,
548 and proxy to that when required.
551 TimeAxisView& tv (xfv->get_time_axis_view());
552 AudioTimeAxisView* atv;
554 if ((atv = dynamic_cast<AudioTimeAxisView*>(&tv)) != 0) {
556 if (atv->is_audio_track()) {
558 boost::shared_ptr<AudioPlaylist> pl;
559 if ((pl = boost::dynamic_pointer_cast<AudioPlaylist> (atv->track()->playlist())) != 0) {
561 Playlist::RegionList* rl = pl->regions_at (event_frame (event));
564 if (atv->layer_display() == Overlaid) {
566 /* we're in overlaid mode; proxy to the uppermost region view */
568 DescendingRegionLayerSorter cmp;
571 RegionView* rv = atv->view()->find_view (rl->front());
576 return canvas_region_view_event (event, rv->get_canvas_group(), rv);
580 /* we're in stacked mode; proxy to the region view under the mouse */
582 /* XXX: FIXME: this is an evil hack; it assumes that any event for which
583 this proxy is being used has its GdkEvent laid out such that the y
584 member is in the same place as that for a GdkEventButton */
586 /* position of the event within the track */
587 double cx = event->button.x;
588 double cy = event->button.y;
589 atv->view()->canvas_item()->w2i (cx, cy);
591 /* hence layer that we're over */
592 double const c = atv->view()->child_height ();
593 layer_t const l = pl->top_layer () + 1 - (cy / c);
596 Playlist::RegionList::iterator i = rl->begin();
597 while (i != rl->end() && (*i)->layer() != l) {
601 if (i != rl->end()) {
602 RegionView* rv = atv->view()->find_view (*i);
606 return canvas_region_view_event (event, rv->get_canvas_group(), rv);
620 Editor::canvas_control_point_event (GdkEvent *event, ArdourCanvas::Item* item, ControlPoint* cp)
622 switch (event->type) {
623 case GDK_BUTTON_PRESS:
624 case GDK_2BUTTON_PRESS:
625 case GDK_3BUTTON_PRESS:
626 clicked_control_point = cp;
627 clicked_axisview = &cp->line().trackview;
628 clicked_routeview = dynamic_cast<RouteTimeAxisView*>(clicked_axisview);
629 clicked_regionview = 0;
635 case GDK_SCROLL_DOWN:
642 return typed_event (item, event, ControlPointItem);
646 Editor::canvas_line_event (GdkEvent *event, ArdourCanvas::Item* item, AutomationLine* al)
650 if (dynamic_cast<AudioRegionGainLine*> (al) != 0) {
653 type = AutomationLineItem;
656 return typed_event (item, event, type);
660 Editor::canvas_selection_rect_event (GdkEvent *event, ArdourCanvas::Item* item, SelectionRect* rect)
664 switch (event->type) {
665 case GDK_BUTTON_PRESS:
666 case GDK_2BUTTON_PRESS:
667 case GDK_3BUTTON_PRESS:
668 clicked_selection = rect->id;
669 ret = button_press_handler (item, event, SelectionItem);
671 case GDK_BUTTON_RELEASE:
672 ret = button_release_handler (item, event, SelectionItem);
674 case GDK_MOTION_NOTIFY:
675 ret = motion_handler (item, event);
677 /* Don't need these at the moment. */
678 case GDK_ENTER_NOTIFY:
679 ret = enter_handler (item, event, SelectionItem);
682 case GDK_LEAVE_NOTIFY:
683 ret = leave_handler (item, event, SelectionItem);
694 Editor::canvas_selection_start_trim_event (GdkEvent *event, ArdourCanvas::Item* item, SelectionRect* rect)
698 switch (event->type) {
699 case GDK_BUTTON_PRESS:
700 case GDK_2BUTTON_PRESS:
701 case GDK_3BUTTON_PRESS:
702 clicked_selection = rect->id;
703 ret = button_press_handler (item, event, StartSelectionTrimItem);
705 case GDK_BUTTON_RELEASE:
706 ret = button_release_handler (item, event, StartSelectionTrimItem);
708 case GDK_MOTION_NOTIFY:
709 ret = motion_handler (item, event);
711 case GDK_ENTER_NOTIFY:
712 ret = enter_handler (item, event, StartSelectionTrimItem);
715 case GDK_LEAVE_NOTIFY:
716 ret = leave_handler (item, event, StartSelectionTrimItem);
727 Editor::canvas_selection_end_trim_event (GdkEvent *event, ArdourCanvas::Item* item, SelectionRect* rect)
731 switch (event->type) {
732 case GDK_BUTTON_PRESS:
733 case GDK_2BUTTON_PRESS:
734 case GDK_3BUTTON_PRESS:
735 clicked_selection = rect->id;
736 ret = button_press_handler (item, event, EndSelectionTrimItem);
738 case GDK_BUTTON_RELEASE:
739 ret = button_release_handler (item, event, EndSelectionTrimItem);
741 case GDK_MOTION_NOTIFY:
742 ret = motion_handler (item, event);
744 case GDK_ENTER_NOTIFY:
745 ret = enter_handler (item, event, EndSelectionTrimItem);
748 case GDK_LEAVE_NOTIFY:
749 ret = leave_handler (item, event, EndSelectionTrimItem);
760 Editor::canvas_frame_handle_event (GdkEvent* event, ArdourCanvas::Item* item, RegionView* rv)
764 /* frame handles are not active when in internal edit mode, because actual notes
765 might be in the area occupied by the handle - we want them to be editable as normal.
768 if (internal_editing() || !rv->sensitive()) {
772 /* NOTE: frame handles pretend to be the colored trim bar from an event handling
773 perspective. XXX change this ??
778 if (item->get_data ("isleft")) {
779 type = LeftFrameHandle;
781 type = RightFrameHandle;
784 switch (event->type) {
785 case GDK_BUTTON_PRESS:
786 case GDK_2BUTTON_PRESS:
787 case GDK_3BUTTON_PRESS:
788 clicked_regionview = rv;
789 clicked_control_point = 0;
790 clicked_axisview = &clicked_regionview->get_time_axis_view();
791 clicked_routeview = dynamic_cast<RouteTimeAxisView*>(clicked_axisview);
792 ret = button_press_handler (item, event, type);
794 case GDK_BUTTON_RELEASE:
795 ret = button_release_handler (item, event, type);
797 case GDK_MOTION_NOTIFY:
798 ret = motion_handler (item, event);
800 case GDK_ENTER_NOTIFY:
801 set_entered_regionview (rv);
802 ret = enter_handler (item, event, type);
805 case GDK_LEAVE_NOTIFY:
806 set_entered_regionview (0);
807 ret = leave_handler (item, event, type);
819 Editor::canvas_region_view_name_highlight_event (GdkEvent* event, ArdourCanvas::Item* item, RegionView* rv)
823 if (!rv->sensitive()) {
827 switch (event->type) {
828 case GDK_BUTTON_PRESS:
829 case GDK_2BUTTON_PRESS:
830 case GDK_3BUTTON_PRESS:
831 clicked_regionview = rv;
832 clicked_control_point = 0;
833 clicked_axisview = &clicked_regionview->get_time_axis_view();
834 clicked_routeview = dynamic_cast<RouteTimeAxisView*>(clicked_axisview);
835 ret = button_press_handler (item, event, RegionViewNameHighlight);
837 case GDK_BUTTON_RELEASE:
838 ret = button_release_handler (item, event, RegionViewNameHighlight);
840 case GDK_MOTION_NOTIFY:
841 motion_handler (item, event);
842 ret = true; // force this to avoid progagating the event into the regionview
844 case GDK_ENTER_NOTIFY:
845 set_entered_regionview (rv);
846 ret = enter_handler (item, event, RegionViewNameHighlight);
849 case GDK_LEAVE_NOTIFY:
850 set_entered_regionview (0);
851 ret = leave_handler (item, event, RegionViewNameHighlight);
862 Editor::canvas_region_view_name_event (GdkEvent *event, ArdourCanvas::Item* item, RegionView* rv)
866 if (!rv->sensitive()) {
870 switch (event->type) {
871 case GDK_BUTTON_PRESS:
872 case GDK_2BUTTON_PRESS:
873 case GDK_3BUTTON_PRESS:
874 clicked_regionview = rv;
875 clicked_control_point = 0;
876 clicked_axisview = &clicked_regionview->get_time_axis_view();
877 clicked_routeview = dynamic_cast<RouteTimeAxisView*>(clicked_axisview);
878 ret = button_press_handler (item, event, RegionViewName);
880 case GDK_BUTTON_RELEASE:
881 ret = button_release_handler (item, event, RegionViewName);
883 case GDK_MOTION_NOTIFY:
884 ret = motion_handler (item, event);
886 case GDK_ENTER_NOTIFY:
887 set_entered_regionview (rv);
888 ret = enter_handler (item, event, RegionViewName);
891 case GDK_LEAVE_NOTIFY:
892 set_entered_regionview (0);
893 ret = leave_handler (item, event, RegionViewName);
904 Editor::canvas_feature_line_event (GdkEvent *event, ArdourCanvas::Item* item, RegionView*)
908 switch (event->type) {
909 case GDK_BUTTON_PRESS:
910 case GDK_2BUTTON_PRESS:
911 case GDK_3BUTTON_PRESS:
912 clicked_regionview = 0;
913 clicked_control_point = 0;
914 clicked_axisview = 0;
915 clicked_routeview = 0; //dynamic_cast<RouteTimeAxisView*>(clicked_axisview);
916 ret = button_press_handler (item, event, FeatureLineItem);
919 case GDK_BUTTON_RELEASE:
920 ret = button_release_handler (item, event, FeatureLineItem);
923 case GDK_MOTION_NOTIFY:
924 ret = motion_handler (item, event);
927 case GDK_ENTER_NOTIFY:
928 ret = enter_handler (item, event, FeatureLineItem);
931 case GDK_LEAVE_NOTIFY:
932 ret = leave_handler (item, event, FeatureLineItem);
943 Editor::canvas_marker_event (GdkEvent *event, ArdourCanvas::Item* item, Marker* /*marker*/)
945 return typed_event (item, event, MarkerItem);
949 Editor::canvas_marker_bar_event (GdkEvent *event, ArdourCanvas::Item* item)
951 return typed_event (item, event, MarkerBarItem);
955 Editor::canvas_range_marker_bar_event (GdkEvent *event, ArdourCanvas::Item* item)
957 return typed_event (item, event, RangeMarkerBarItem);
961 Editor::canvas_transport_marker_bar_event (GdkEvent *event, ArdourCanvas::Item* item)
963 return typed_event (item, event, TransportMarkerBarItem);
967 Editor::canvas_cd_marker_bar_event (GdkEvent *event, ArdourCanvas::Item* item)
969 return typed_event (item, event, CdMarkerBarItem);
973 Editor::canvas_tempo_marker_event (GdkEvent *event, ArdourCanvas::Item* item, TempoMarker* /*marker*/)
975 return typed_event (item, event, TempoMarkerItem);
979 Editor::canvas_meter_marker_event (GdkEvent *event, ArdourCanvas::Item* item, MeterMarker* /*marker*/)
981 return typed_event (item, event, MeterMarkerItem);
985 Editor::canvas_tempo_bar_event (GdkEvent *event, ArdourCanvas::Item* item)
987 return typed_event (item, event, TempoBarItem);
991 Editor::canvas_meter_bar_event (GdkEvent *event, ArdourCanvas::Item* item)
993 return typed_event (item, event, MeterBarItem);
997 Editor::canvas_playhead_cursor_event (GdkEvent *event, ArdourCanvas::Item* item)
999 return typed_event (item, event, PlayheadCursorItem);
1003 Editor::canvas_zoom_rect_event (GdkEvent *event, ArdourCanvas::Item* item)
1005 return typed_event (item, event, NoItem);
1009 Editor::canvas_note_event (GdkEvent *event, ArdourCanvas::Item* item)
1011 if (!internal_editing()) {
1015 return typed_event (item, event, NoteItem);
1019 Editor::track_canvas_drag_motion (Glib::RefPtr<Gdk::DragContext> const & /*c*/, int x, int y, guint /*time*/)
1023 track_canvas->window_to_world (x, y, wx, wy);
1026 event.type = GDK_MOTION_NOTIFY;
1027 event.button.x = wx;
1028 event.button.y = wy;
1029 /* assume we're dragging with button 1 */
1030 event.motion.state = Gdk::BUTTON1_MASK;
1032 if (!_drags->active ()) {
1036 framepos_t const pos = event_frame (&event, &px, &py);
1038 std::pair<TimeAxisView*, int> const tv = trackview_by_y_position (py);
1039 if (tv.first == 0) {
1043 RouteTimeAxisView* rtav = dynamic_cast<RouteTimeAxisView*> (tv.first);
1044 if (rtav == 0 || !rtav->is_track ()) {
1048 boost::shared_ptr<Region> region = _regions->get_dragged_region ();
1054 boost::shared_ptr<Region> region_copy = RegionFactory::create (region);
1056 if (boost::dynamic_pointer_cast<AudioRegion> (region_copy) != 0 &&
1057 dynamic_cast<AudioTimeAxisView*> (tv.first) == 0) {
1059 /* audio -> non-audio */
1063 if (boost::dynamic_pointer_cast<MidiRegion> (region_copy) == 0 &&
1064 dynamic_cast<MidiTimeAxisView*> (tv.first) != 0) {
1066 /* MIDI -> non-MIDI */
1070 _drags->set (new RegionInsertDrag (this, region_copy, rtav, pos), &event);
1073 _drags->motion_handler (&event, false);