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);
216 ret = key_press_handler (item, event, type);
219 case GDK_KEY_RELEASE:
220 ret = key_release_handler (item, event, type);
230 Editor::canvas_region_view_event (GdkEvent *event, ArdourCanvas::Item* item, RegionView *rv)
234 if (!rv->sensitive ()) {
238 switch (event->type) {
239 case GDK_BUTTON_PRESS:
240 case GDK_2BUTTON_PRESS:
241 case GDK_3BUTTON_PRESS:
242 clicked_regionview = rv;
243 clicked_control_point = 0;
244 clicked_axisview = &rv->get_time_axis_view();
245 clicked_routeview = dynamic_cast<RouteTimeAxisView*>(clicked_axisview);
246 ret = button_press_handler (item, event, RegionItem);
249 case GDK_BUTTON_RELEASE:
250 ret = button_release_handler (item, event, RegionItem);
253 case GDK_MOTION_NOTIFY:
254 ret = motion_handler (item, event);
257 case GDK_ENTER_NOTIFY:
258 set_entered_track (&rv->get_time_axis_view ());
259 set_entered_regionview (rv);
262 case GDK_LEAVE_NOTIFY:
263 set_entered_track (0);
264 set_entered_regionview (0);
275 Editor::canvas_stream_view_event (GdkEvent *event, ArdourCanvas::Item* item, RouteTimeAxisView *tv)
279 switch (event->type) {
280 case GDK_BUTTON_PRESS:
281 case GDK_2BUTTON_PRESS:
282 case GDK_3BUTTON_PRESS:
283 clicked_regionview = 0;
284 clicked_control_point = 0;
285 clicked_axisview = tv;
286 clicked_routeview = dynamic_cast<RouteTimeAxisView*>(clicked_axisview);
287 ret = button_press_handler (item, event, StreamItem);
290 case GDK_BUTTON_RELEASE:
291 ret = button_release_handler (item, event, StreamItem);
294 case GDK_MOTION_NOTIFY:
295 ret = motion_handler (item, event);
298 case GDK_ENTER_NOTIFY:
299 set_entered_track (tv);
302 case GDK_LEAVE_NOTIFY:
303 set_entered_track (0);
314 Editor::canvas_automation_track_event (GdkEvent *event, ArdourCanvas::Item* item, AutomationTimeAxisView *atv)
318 switch (event->type) {
319 case GDK_BUTTON_PRESS:
320 case GDK_2BUTTON_PRESS:
321 case GDK_3BUTTON_PRESS:
322 clicked_regionview = 0;
323 clicked_control_point = 0;
324 clicked_axisview = atv;
325 clicked_routeview = 0;
326 ret = button_press_handler (item, event, AutomationTrackItem);
329 case GDK_BUTTON_RELEASE:
330 ret = button_release_handler (item, event, AutomationTrackItem);
333 case GDK_MOTION_NOTIFY:
334 ret = motion_handler (item, event);
337 case GDK_ENTER_NOTIFY:
338 ret = enter_handler (item, event, AutomationTrackItem);
341 case GDK_LEAVE_NOTIFY:
342 ret = leave_handler (item, event, AutomationTrackItem);
353 Editor::canvas_fade_in_event (GdkEvent *event, ArdourCanvas::Item* item, AudioRegionView *rv)
355 /* we handle only button 3 press/release events */
357 if (!rv->sensitive()) {
361 switch (event->type) {
362 case GDK_BUTTON_PRESS:
363 clicked_regionview = rv;
364 clicked_control_point = 0;
365 clicked_axisview = &rv->get_time_axis_view();
366 clicked_routeview = dynamic_cast<RouteTimeAxisView*>(clicked_axisview);
367 if (event->button.button == 3) {
368 return button_press_handler (item, event, FadeInItem);
372 case GDK_BUTTON_RELEASE:
373 if (event->button.button == 3) {
374 return button_release_handler (item, event, FadeInItem);
383 /* proxy for the regionview */
385 return canvas_region_view_event (event, rv->get_canvas_group(), rv);
389 Editor::canvas_fade_in_handle_event (GdkEvent *event, ArdourCanvas::Item* item, AudioRegionView *rv)
393 if (!rv->sensitive()) {
397 switch (event->type) {
398 case GDK_BUTTON_PRESS:
399 case GDK_2BUTTON_PRESS:
400 case GDK_3BUTTON_PRESS:
401 clicked_regionview = rv;
402 clicked_control_point = 0;
403 clicked_axisview = &rv->get_time_axis_view();
404 clicked_routeview = dynamic_cast<RouteTimeAxisView*>(clicked_axisview);
405 ret = button_press_handler (item, event, FadeInHandleItem);
408 case GDK_BUTTON_RELEASE:
409 ret = button_release_handler (item, event, FadeInHandleItem);
412 case GDK_MOTION_NOTIFY:
413 ret = motion_handler (item, event);
416 case GDK_ENTER_NOTIFY:
417 set_entered_regionview (rv);
418 ret = enter_handler (item, event, FadeInHandleItem);
421 case GDK_LEAVE_NOTIFY:
422 set_entered_regionview (0);
423 ret = leave_handler (item, event, FadeInHandleItem);
434 Editor::canvas_fade_out_event (GdkEvent *event, ArdourCanvas::Item* item, AudioRegionView *rv)
436 /* we handle only button 3 press/release events */
438 if (!rv->sensitive()) {
442 switch (event->type) {
443 case GDK_BUTTON_PRESS:
444 clicked_regionview = rv;
445 clicked_control_point = 0;
446 clicked_axisview = &rv->get_time_axis_view();
447 clicked_routeview = dynamic_cast<RouteTimeAxisView*>(clicked_axisview);
448 if (event->button.button == 3) {
449 return button_press_handler (item, event, FadeOutItem);
453 case GDK_BUTTON_RELEASE:
454 if (event->button.button == 3) {
455 return button_release_handler (item, event, FadeOutItem);
464 /* proxy for the regionview */
466 return canvas_region_view_event (event, rv->get_canvas_group(), rv);
470 Editor::canvas_fade_out_handle_event (GdkEvent *event, ArdourCanvas::Item* item, AudioRegionView *rv)
474 if (!rv->sensitive()) {
478 switch (event->type) {
479 case GDK_BUTTON_PRESS:
480 case GDK_2BUTTON_PRESS:
481 case GDK_3BUTTON_PRESS:
482 clicked_regionview = rv;
483 clicked_control_point = 0;
484 clicked_axisview = &rv->get_time_axis_view();
485 clicked_routeview = dynamic_cast<RouteTimeAxisView*>(clicked_axisview);
486 ret = button_press_handler (item, event, FadeOutHandleItem);
489 case GDK_BUTTON_RELEASE:
490 ret = button_release_handler (item, event, FadeOutHandleItem);
493 case GDK_MOTION_NOTIFY:
494 ret = motion_handler (item, event);
497 case GDK_ENTER_NOTIFY:
498 set_entered_regionview (rv);
499 ret = enter_handler (item, event, FadeOutHandleItem);
502 case GDK_LEAVE_NOTIFY:
503 set_entered_regionview (0);
504 ret = leave_handler (item, event, FadeOutHandleItem);
514 struct DescendingRegionLayerSorter {
515 bool operator()(boost::shared_ptr<Region> a, boost::shared_ptr<Region> b) {
516 return a->layer() > b->layer();
521 Editor::canvas_crossfade_view_event (GdkEvent* event, ArdourCanvas::Item* item, CrossfadeView* xfv)
523 /* we handle only button 3 press/release events */
525 switch (event->type) {
526 case GDK_BUTTON_PRESS:
527 clicked_crossfadeview = xfv;
528 clicked_axisview = &clicked_crossfadeview->get_time_axis_view();
529 clicked_routeview = dynamic_cast<RouteTimeAxisView*>(clicked_axisview);
530 if (event->button.button == 3) {
531 return button_press_handler (item, event, CrossfadeViewItem);
535 case GDK_BUTTON_RELEASE:
536 if (event->button.button == 3) {
537 bool ret = button_release_handler (item, event, CrossfadeViewItem);
547 /* XXX do not forward double clicks */
549 if (event->type == GDK_2BUTTON_PRESS) {
553 /* proxy for an underlying regionview */
555 /* XXX really need to check if we are in the name highlight,
556 and proxy to that when required.
559 TimeAxisView& tv (xfv->get_time_axis_view());
560 AudioTimeAxisView* atv;
562 if ((atv = dynamic_cast<AudioTimeAxisView*>(&tv)) != 0) {
564 if (atv->is_audio_track()) {
566 boost::shared_ptr<AudioPlaylist> pl;
567 if ((pl = boost::dynamic_pointer_cast<AudioPlaylist> (atv->track()->playlist())) != 0) {
569 Playlist::RegionList* rl = pl->regions_at (event_frame (event));
572 if (atv->layer_display() == Overlaid) {
574 /* we're in overlaid mode; proxy to the uppermost region view */
576 DescendingRegionLayerSorter cmp;
579 RegionView* rv = atv->view()->find_view (rl->front());
584 return canvas_region_view_event (event, rv->get_canvas_group(), rv);
588 /* we're in stacked mode; proxy to the region view under the mouse */
590 /* XXX: FIXME: this is an evil hack; it assumes that any event for which
591 this proxy is being used has its GdkEvent laid out such that the y
592 member is in the same place as that for a GdkEventButton */
594 /* position of the event within the track */
595 double cx = event->button.x;
596 double cy = event->button.y;
597 atv->view()->canvas_item()->w2i (cx, cy);
599 /* hence layer that we're over */
600 double const c = atv->view()->child_height ();
601 layer_t const l = pl->top_layer () + 1 - (cy / c);
604 Playlist::RegionList::iterator i = rl->begin();
605 while (i != rl->end() && (*i)->layer() != l) {
609 if (i != rl->end()) {
610 RegionView* rv = atv->view()->find_view (*i);
614 return canvas_region_view_event (event, rv->get_canvas_group(), rv);
628 Editor::canvas_control_point_event (GdkEvent *event, ArdourCanvas::Item* item, ControlPoint* cp)
630 switch (event->type) {
631 case GDK_BUTTON_PRESS:
632 case GDK_2BUTTON_PRESS:
633 case GDK_3BUTTON_PRESS:
634 clicked_control_point = cp;
635 clicked_axisview = &cp->line().trackview;
636 clicked_routeview = dynamic_cast<RouteTimeAxisView*>(clicked_axisview);
637 clicked_regionview = 0;
643 case GDK_SCROLL_DOWN:
650 return typed_event (item, event, ControlPointItem);
654 Editor::canvas_line_event (GdkEvent *event, ArdourCanvas::Item* item, AutomationLine* al)
658 if (dynamic_cast<AudioRegionGainLine*> (al) != 0) {
661 type = AutomationLineItem;
664 return typed_event (item, event, type);
668 Editor::canvas_selection_rect_event (GdkEvent *event, ArdourCanvas::Item* item, SelectionRect* rect)
672 switch (event->type) {
673 case GDK_BUTTON_PRESS:
674 case GDK_2BUTTON_PRESS:
675 case GDK_3BUTTON_PRESS:
676 clicked_selection = rect->id;
677 ret = button_press_handler (item, event, SelectionItem);
679 case GDK_BUTTON_RELEASE:
680 ret = button_release_handler (item, event, SelectionItem);
682 case GDK_MOTION_NOTIFY:
683 ret = motion_handler (item, event);
685 /* Don't need these at the moment. */
686 case GDK_ENTER_NOTIFY:
687 ret = enter_handler (item, event, SelectionItem);
690 case GDK_LEAVE_NOTIFY:
691 ret = leave_handler (item, event, SelectionItem);
702 Editor::canvas_selection_start_trim_event (GdkEvent *event, ArdourCanvas::Item* item, SelectionRect* rect)
706 switch (event->type) {
707 case GDK_BUTTON_PRESS:
708 case GDK_2BUTTON_PRESS:
709 case GDK_3BUTTON_PRESS:
710 clicked_selection = rect->id;
711 ret = button_press_handler (item, event, StartSelectionTrimItem);
713 case GDK_BUTTON_RELEASE:
714 ret = button_release_handler (item, event, StartSelectionTrimItem);
716 case GDK_MOTION_NOTIFY:
717 ret = motion_handler (item, event);
719 case GDK_ENTER_NOTIFY:
720 ret = enter_handler (item, event, StartSelectionTrimItem);
723 case GDK_LEAVE_NOTIFY:
724 ret = leave_handler (item, event, StartSelectionTrimItem);
735 Editor::canvas_selection_end_trim_event (GdkEvent *event, ArdourCanvas::Item* item, SelectionRect* rect)
739 switch (event->type) {
740 case GDK_BUTTON_PRESS:
741 case GDK_2BUTTON_PRESS:
742 case GDK_3BUTTON_PRESS:
743 clicked_selection = rect->id;
744 ret = button_press_handler (item, event, EndSelectionTrimItem);
746 case GDK_BUTTON_RELEASE:
747 ret = button_release_handler (item, event, EndSelectionTrimItem);
749 case GDK_MOTION_NOTIFY:
750 ret = motion_handler (item, event);
752 case GDK_ENTER_NOTIFY:
753 ret = enter_handler (item, event, EndSelectionTrimItem);
756 case GDK_LEAVE_NOTIFY:
757 ret = leave_handler (item, event, EndSelectionTrimItem);
768 Editor::canvas_frame_handle_event (GdkEvent* event, ArdourCanvas::Item* item, RegionView* rv)
772 /* frame handles are not active when in internal edit mode, because actual notes
773 might be in the area occupied by the handle - we want them to be editable as normal.
776 if (internal_editing() || !rv->sensitive()) {
780 /* NOTE: frame handles pretend to be the colored trim bar from an event handling
781 perspective. XXX change this ??
786 if (item->get_data ("isleft")) {
787 type = LeftFrameHandle;
789 type = RightFrameHandle;
792 switch (event->type) {
793 case GDK_BUTTON_PRESS:
794 case GDK_2BUTTON_PRESS:
795 case GDK_3BUTTON_PRESS:
796 clicked_regionview = rv;
797 clicked_control_point = 0;
798 clicked_axisview = &clicked_regionview->get_time_axis_view();
799 clicked_routeview = dynamic_cast<RouteTimeAxisView*>(clicked_axisview);
800 ret = button_press_handler (item, event, type);
802 case GDK_BUTTON_RELEASE:
803 ret = button_release_handler (item, event, type);
805 case GDK_MOTION_NOTIFY:
806 ret = motion_handler (item, event);
808 case GDK_ENTER_NOTIFY:
809 set_entered_regionview (rv);
810 ret = enter_handler (item, event, type);
813 case GDK_LEAVE_NOTIFY:
814 set_entered_regionview (0);
815 ret = leave_handler (item, event, type);
827 Editor::canvas_region_view_name_highlight_event (GdkEvent* event, ArdourCanvas::Item* item, RegionView* rv)
831 if (!rv->sensitive()) {
835 switch (event->type) {
836 case GDK_BUTTON_PRESS:
837 case GDK_2BUTTON_PRESS:
838 case GDK_3BUTTON_PRESS:
839 clicked_regionview = rv;
840 clicked_control_point = 0;
841 clicked_axisview = &clicked_regionview->get_time_axis_view();
842 clicked_routeview = dynamic_cast<RouteTimeAxisView*>(clicked_axisview);
843 ret = button_press_handler (item, event, RegionViewNameHighlight);
845 case GDK_BUTTON_RELEASE:
846 ret = button_release_handler (item, event, RegionViewNameHighlight);
848 case GDK_MOTION_NOTIFY:
849 motion_handler (item, event);
850 ret = true; // force this to avoid progagating the event into the regionview
852 case GDK_ENTER_NOTIFY:
853 set_entered_regionview (rv);
854 ret = enter_handler (item, event, RegionViewNameHighlight);
857 case GDK_LEAVE_NOTIFY:
858 set_entered_regionview (0);
859 ret = leave_handler (item, event, RegionViewNameHighlight);
870 Editor::canvas_region_view_name_event (GdkEvent *event, ArdourCanvas::Item* item, RegionView* rv)
874 if (!rv->sensitive()) {
878 switch (event->type) {
879 case GDK_BUTTON_PRESS:
880 case GDK_2BUTTON_PRESS:
881 case GDK_3BUTTON_PRESS:
882 clicked_regionview = rv;
883 clicked_control_point = 0;
884 clicked_axisview = &clicked_regionview->get_time_axis_view();
885 clicked_routeview = dynamic_cast<RouteTimeAxisView*>(clicked_axisview);
886 ret = button_press_handler (item, event, RegionViewName);
888 case GDK_BUTTON_RELEASE:
889 ret = button_release_handler (item, event, RegionViewName);
891 case GDK_MOTION_NOTIFY:
892 ret = motion_handler (item, event);
894 case GDK_ENTER_NOTIFY:
895 set_entered_regionview (rv);
896 ret = enter_handler (item, event, RegionViewName);
899 case GDK_LEAVE_NOTIFY:
900 set_entered_regionview (0);
901 ret = leave_handler (item, event, RegionViewName);
912 Editor::canvas_feature_line_event (GdkEvent *event, ArdourCanvas::Item* item, RegionView*)
916 switch (event->type) {
917 case GDK_BUTTON_PRESS:
918 case GDK_2BUTTON_PRESS:
919 case GDK_3BUTTON_PRESS:
920 clicked_regionview = 0;
921 clicked_control_point = 0;
922 clicked_axisview = 0;
923 clicked_routeview = 0; //dynamic_cast<RouteTimeAxisView*>(clicked_axisview);
924 ret = button_press_handler (item, event, FeatureLineItem);
927 case GDK_BUTTON_RELEASE:
928 ret = button_release_handler (item, event, FeatureLineItem);
931 case GDK_MOTION_NOTIFY:
932 ret = motion_handler (item, event);
935 case GDK_ENTER_NOTIFY:
936 ret = enter_handler (item, event, FeatureLineItem);
939 case GDK_LEAVE_NOTIFY:
940 ret = leave_handler (item, event, FeatureLineItem);
951 Editor::canvas_marker_event (GdkEvent *event, ArdourCanvas::Item* item, Marker* /*marker*/)
953 return typed_event (item, event, MarkerItem);
957 Editor::canvas_marker_bar_event (GdkEvent *event, ArdourCanvas::Item* item)
959 return typed_event (item, event, MarkerBarItem);
963 Editor::canvas_range_marker_bar_event (GdkEvent *event, ArdourCanvas::Item* item)
965 return typed_event (item, event, RangeMarkerBarItem);
969 Editor::canvas_transport_marker_bar_event (GdkEvent *event, ArdourCanvas::Item* item)
971 return typed_event (item, event, TransportMarkerBarItem);
975 Editor::canvas_cd_marker_bar_event (GdkEvent *event, ArdourCanvas::Item* item)
977 return typed_event (item, event, CdMarkerBarItem);
981 Editor::canvas_tempo_marker_event (GdkEvent *event, ArdourCanvas::Item* item, TempoMarker* /*marker*/)
983 return typed_event (item, event, TempoMarkerItem);
987 Editor::canvas_meter_marker_event (GdkEvent *event, ArdourCanvas::Item* item, MeterMarker* /*marker*/)
989 return typed_event (item, event, MeterMarkerItem);
993 Editor::canvas_tempo_bar_event (GdkEvent *event, ArdourCanvas::Item* item)
995 return typed_event (item, event, TempoBarItem);
999 Editor::canvas_meter_bar_event (GdkEvent *event, ArdourCanvas::Item* item)
1001 return typed_event (item, event, MeterBarItem);
1005 Editor::canvas_playhead_cursor_event (GdkEvent *event, ArdourCanvas::Item* item)
1007 return typed_event (item, event, PlayheadCursorItem);
1011 Editor::canvas_zoom_rect_event (GdkEvent *event, ArdourCanvas::Item* item)
1013 return typed_event (item, event, NoItem);
1017 Editor::canvas_note_event (GdkEvent *event, ArdourCanvas::Item* item)
1019 if (!internal_editing()) {
1023 return typed_event (item, event, NoteItem);
1027 Editor::track_canvas_drag_motion (Glib::RefPtr<Gdk::DragContext> const & /*c*/, int x, int y, guint /*time*/)
1031 track_canvas->window_to_world (x, y, wx, wy);
1034 event.type = GDK_MOTION_NOTIFY;
1035 event.button.x = wx;
1036 event.button.y = wy;
1037 /* assume we're dragging with button 1 */
1038 event.motion.state = Gdk::BUTTON1_MASK;
1040 if (!_drags->active ()) {
1044 framepos_t const pos = event_frame (&event, &px, &py);
1046 std::pair<TimeAxisView*, int> const tv = trackview_by_y_position (py);
1047 if (tv.first == 0) {
1051 RouteTimeAxisView* rtav = dynamic_cast<RouteTimeAxisView*> (tv.first);
1052 if (rtav == 0 || !rtav->is_track ()) {
1056 boost::shared_ptr<Region> region = _regions->get_dragged_region ();
1062 boost::shared_ptr<Region> region_copy = RegionFactory::create (region);
1064 if (boost::dynamic_pointer_cast<AudioRegion> (region_copy) != 0 &&
1065 dynamic_cast<AudioTimeAxisView*> (tv.first) == 0) {
1067 /* audio -> non-audio */
1071 if (boost::dynamic_pointer_cast<MidiRegion> (region_copy) == 0 &&
1072 dynamic_cast<MidiTimeAxisView*> (tv.first) != 0) {
1074 /* MIDI -> non-MIDI */
1078 _drags->set (new RegionInsertDrag (this, region_copy, rtav, pos), &event);
1081 _drags->motion_handler (&event, false);
1087 Editor::key_press_handler (ArdourCanvas::Item*, GdkEvent*, ItemType)
1093 Editor::key_release_handler (ArdourCanvas::Item* item, GdkEvent* event, ItemType type)
1096 bool handled = false;
1099 case TempoMarkerItem:
1100 switch (event->key.keyval) {
1102 remove_tempo_marker (item);
1110 case MeterMarkerItem:
1111 switch (event->key.keyval) {
1113 remove_meter_marker (item);