13
0
livetrax/gtk2_ardour/editor_canvas_events.cc
Colin Fletcher 21914c884e Make scroll-wheel modifier keys consistent in main editor window.
Add constants for the keyboard modifiers that should be used for vertical
zoom, horizontal zoom, and horizontal scrolling in the main editor window,
and use these where appropriate rather than using Keyboard::PrimaryModifier
and friends directly.
2013-06-21 20:13:44 +01:00

1193 lines
28 KiB
C++

/*
Copyright (C) 2000 Paul Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
#include <cstdlib>
#include <cmath>
#include <algorithm>
#include <typeinfo>
#include "pbd/stacktrace.h"
#include "ardour/midi_region.h"
#include "ardour/region_factory.h"
#include "ardour/profile.h"
#include "editor.h"
#include "keyboard.h"
#include "public_editor.h"
#include "audio_region_view.h"
#include "audio_streamview.h"
#include "canvas-noevent-text.h"
#include "audio_time_axis.h"
#include "region_gain_line.h"
#include "automation_line.h"
#include "automation_time_axis.h"
#include "automation_line.h"
#include "control_point.h"
#include "canvas_impl.h"
#include "simplerect.h"
#include "editor_drag.h"
#include "midi_time_axis.h"
#include "editor_regions.h"
#include "verbose_cursor.h"
#include "i18n.h"
using namespace std;
using namespace ARDOUR;
using namespace PBD;
using namespace Gtk;
using namespace ArdourCanvas;
using Gtkmm2ext::Keyboard;
bool
Editor::track_canvas_scroll (GdkEventScroll* ev)
{
framepos_t xdelta;
int direction = ev->direction;
retry:
switch (direction) {
case GDK_SCROLL_UP:
if (Keyboard::modifier_state_equals (ev->state, Keyboard::ScrollZoomHorizontalModifier)) {
//for mouse-wheel zoom, force zoom-focus to mouse
Editing::ZoomFocus temp_focus = zoom_focus;
zoom_focus = Editing::ZoomFocusMouse;
temporal_zoom_step (false);
zoom_focus = temp_focus;
return true;
} else if (Keyboard::modifier_state_equals (ev->state, Keyboard::ScrollHorizontalModifier)) {
direction = GDK_SCROLL_LEFT;
goto retry;
} else if (Keyboard::modifier_state_equals (ev->state, Keyboard::ScrollZoomVerticalModifier)) {
if (!current_stepping_trackview) {
step_timeout = Glib::signal_timeout().connect (sigc::mem_fun(*this, &Editor::track_height_step_timeout), 500);
std::pair<TimeAxisView*, int> const p = trackview_by_y_position (ev->y + vertical_adjustment.get_value() - canvas_timebars_vsize);
current_stepping_trackview = p.first;
if (!current_stepping_trackview) {
return false;
}
}
last_track_height_step_timestamp = get_microseconds();
current_stepping_trackview->step_height (false);
return true;
} else {
scroll_tracks_up_line ();
return true;
}
break;
case GDK_SCROLL_DOWN:
if (Keyboard::modifier_state_equals (ev->state, Keyboard::ScrollZoomHorizontalModifier)) {
//for mouse-wheel zoom, force zoom-focus to mouse
Editing::ZoomFocus temp_focus = zoom_focus;
zoom_focus = Editing::ZoomFocusMouse;
temporal_zoom_step (true);
zoom_focus = temp_focus;
return true;
} else if (Keyboard::modifier_state_equals (ev->state, Keyboard::ScrollHorizontalModifier)) {
direction = GDK_SCROLL_RIGHT;
goto retry;
} else if (Keyboard::modifier_state_equals (ev->state, Keyboard::ScrollZoomVerticalModifier)) {
if (!current_stepping_trackview) {
step_timeout = Glib::signal_timeout().connect (sigc::mem_fun(*this, &Editor::track_height_step_timeout), 500);
std::pair<TimeAxisView*, int> const p = trackview_by_y_position (ev->y + vertical_adjustment.get_value() - canvas_timebars_vsize);
current_stepping_trackview = p.first;
if (!current_stepping_trackview) {
return false;
}
}
last_track_height_step_timestamp = get_microseconds();
current_stepping_trackview->step_height (true);
return true;
} else {
scroll_tracks_down_line ();
return true;
}
break;
case GDK_SCROLL_LEFT:
xdelta = (current_page_frames() / 8);
if (leftmost_frame > xdelta) {
reset_x_origin (leftmost_frame - xdelta);
} else {
reset_x_origin (0);
}
break;
case GDK_SCROLL_RIGHT:
xdelta = (current_page_frames() / 8);
if (max_framepos - xdelta > leftmost_frame) {
reset_x_origin (leftmost_frame + xdelta);
} else {
reset_x_origin (max_framepos - current_page_frames());
}
break;
default:
/* what? */
break;
}
return false;
}
bool
Editor::track_canvas_scroll_event (GdkEventScroll *event)
{
track_canvas->grab_focus();
return track_canvas_scroll (event);
}
bool
Editor::track_canvas_button_press_event (GdkEventButton */*event*/)
{
selection->clear ();
track_canvas->grab_focus();
return false;
}
bool
Editor::track_canvas_button_release_event (GdkEventButton *event)
{
if (_drags->active ()) {
_drags->end_grab ((GdkEvent*) event);
}
return false;
}
bool
Editor::track_canvas_motion_notify_event (GdkEventMotion */*event*/)
{
int x, y;
/* keep those motion events coming */
track_canvas->get_pointer (x, y);
return false;
}
bool
Editor::track_canvas_motion (GdkEvent *ev)
{
if (_verbose_cursor->visible ()) {
_verbose_cursor->set_position (ev->motion.x + 10, ev->motion.y + 10);
}
return false;
}
bool
Editor::typed_event (ArdourCanvas::Item* item, GdkEvent *event, ItemType type)
{
gint ret = FALSE;
switch (event->type) {
case GDK_BUTTON_PRESS:
case GDK_2BUTTON_PRESS:
case GDK_3BUTTON_PRESS:
ret = button_press_handler (item, event, type);
break;
case GDK_BUTTON_RELEASE:
ret = button_release_handler (item, event, type);
break;
case GDK_MOTION_NOTIFY:
ret = motion_handler (item, event);
break;
case GDK_ENTER_NOTIFY:
ret = enter_handler (item, event, type);
break;
case GDK_LEAVE_NOTIFY:
ret = leave_handler (item, event, type);
break;
case GDK_KEY_PRESS:
ret = key_press_handler (item, event, type);
break;
case GDK_KEY_RELEASE:
ret = key_release_handler (item, event, type);
break;
default:
break;
}
return ret;
}
bool
Editor::canvas_region_view_event (GdkEvent *event, ArdourCanvas::Item* item, RegionView *rv)
{
bool ret = false;
if (!rv->sensitive ()) {
return false;
}
switch (event->type) {
case GDK_BUTTON_PRESS:
case GDK_2BUTTON_PRESS:
case GDK_3BUTTON_PRESS:
clicked_regionview = rv;
clicked_control_point = 0;
clicked_axisview = &rv->get_time_axis_view();
clicked_routeview = dynamic_cast<RouteTimeAxisView*>(clicked_axisview);
ret = button_press_handler (item, event, RegionItem);
break;
case GDK_BUTTON_RELEASE:
ret = button_release_handler (item, event, RegionItem);
break;
case GDK_MOTION_NOTIFY:
ret = motion_handler (item, event);
break;
case GDK_ENTER_NOTIFY:
set_entered_track (&rv->get_time_axis_view ());
set_entered_regionview (rv);
break;
case GDK_LEAVE_NOTIFY:
set_entered_track (0);
set_entered_regionview (0);
break;
default:
break;
}
return ret;
}
bool
Editor::canvas_stream_view_event (GdkEvent *event, ArdourCanvas::Item* item, RouteTimeAxisView *tv)
{
bool ret = FALSE;
switch (event->type) {
case GDK_BUTTON_PRESS:
case GDK_2BUTTON_PRESS:
case GDK_3BUTTON_PRESS:
clicked_regionview = 0;
clicked_control_point = 0;
clicked_axisview = tv;
clicked_routeview = dynamic_cast<RouteTimeAxisView*>(clicked_axisview);
ret = button_press_handler (item, event, StreamItem);
break;
case GDK_BUTTON_RELEASE:
ret = button_release_handler (item, event, StreamItem);
break;
case GDK_MOTION_NOTIFY:
ret = motion_handler (item, event);
break;
case GDK_ENTER_NOTIFY:
set_entered_track (tv);
break;
case GDK_LEAVE_NOTIFY:
set_entered_track (0);
break;
default:
break;
}
return ret;
}
bool
Editor::canvas_automation_track_event (GdkEvent *event, ArdourCanvas::Item* item, AutomationTimeAxisView *atv)
{
bool ret = false;
switch (event->type) {
case GDK_BUTTON_PRESS:
case GDK_2BUTTON_PRESS:
case GDK_3BUTTON_PRESS:
clicked_regionview = 0;
clicked_control_point = 0;
clicked_axisview = atv;
clicked_routeview = 0;
ret = button_press_handler (item, event, AutomationTrackItem);
break;
case GDK_BUTTON_RELEASE:
ret = button_release_handler (item, event, AutomationTrackItem);
break;
case GDK_MOTION_NOTIFY:
ret = motion_handler (item, event);
break;
case GDK_ENTER_NOTIFY:
ret = enter_handler (item, event, AutomationTrackItem);
break;
case GDK_LEAVE_NOTIFY:
ret = leave_handler (item, event, AutomationTrackItem);
break;
default:
break;
}
return ret;
}
bool
Editor::canvas_start_xfade_event (GdkEvent *event, ArdourCanvas::Item* item, AudioRegionView *rv)
{
if (!rv->sensitive()) {
return false;
}
switch (event->type) {
case GDK_BUTTON_PRESS:
clicked_regionview = rv;
clicked_control_point = 0;
clicked_axisview = &rv->get_time_axis_view();
clicked_routeview = dynamic_cast<RouteTimeAxisView*>(clicked_axisview);
if (event->button.button == 3) {
return button_press_handler (item, event, StartCrossFadeItem);
}
break;
case GDK_BUTTON_RELEASE:
if (event->button.button == 3) {
return button_release_handler (item, event, StartCrossFadeItem);
}
break;
default:
break;
}
/* In Mixbus, the crossfade area is used to trim the region while leaving the fade anchor intact (see preserve_fade_anchor)*/
/* however in A3 this feature is unfinished, and it might be better to do it with a modifier-trim instead, anyway */
/* if we return RegionItem here then we avoid the issue until it is resolved later */
return typed_event (item, event, RegionItem); // StartCrossFadeItem);
}
bool
Editor::canvas_end_xfade_event (GdkEvent *event, ArdourCanvas::Item* item, AudioRegionView *rv)
{
if (!rv->sensitive()) {
return false;
}
switch (event->type) {
case GDK_BUTTON_PRESS:
clicked_regionview = rv;
clicked_control_point = 0;
clicked_axisview = &rv->get_time_axis_view();
clicked_routeview = dynamic_cast<RouteTimeAxisView*>(clicked_axisview);
if (event->button.button == 3) {
return button_press_handler (item, event, EndCrossFadeItem);
}
break;
case GDK_BUTTON_RELEASE:
if (event->button.button == 3) {
return button_release_handler (item, event, EndCrossFadeItem);
}
break;
default:
break;
}
/* In Mixbus, the crossfade area is used to trim the region while leaving the fade anchor intact (see preserve_fade_anchor)*/
/* however in A3 this feature is unfinished, and it might be better to do it with a modifier-trim instead, anyway */
/* if we return RegionItem here then we avoid the issue until it is resolved later */
return typed_event (item, event, RegionItem); // EndCrossFadeItem);
}
bool
Editor::canvas_fade_in_event (GdkEvent *event, ArdourCanvas::Item* item, AudioRegionView *rv)
{
/* we handle only button 3 press/release events */
if (!rv->sensitive()) {
return false;
}
switch (event->type) {
case GDK_BUTTON_PRESS:
clicked_regionview = rv;
clicked_control_point = 0;
clicked_axisview = &rv->get_time_axis_view();
clicked_routeview = dynamic_cast<RouteTimeAxisView*>(clicked_axisview);
if (event->button.button == 3) {
return button_press_handler (item, event, FadeInItem);
}
break;
case GDK_BUTTON_RELEASE:
if (event->button.button == 3) {
return button_release_handler (item, event, FadeInItem);
}
break;
default:
break;
}
/* proxy for the regionview */
return canvas_region_view_event (event, rv->get_canvas_group(), rv);
}
bool
Editor::canvas_fade_in_handle_event (GdkEvent *event, ArdourCanvas::Item* item, AudioRegionView *rv)
{
bool ret = false;
if (!rv->sensitive()) {
return false;
}
switch (event->type) {
case GDK_BUTTON_PRESS:
case GDK_2BUTTON_PRESS:
case GDK_3BUTTON_PRESS:
clicked_regionview = rv;
clicked_control_point = 0;
clicked_axisview = &rv->get_time_axis_view();
clicked_routeview = dynamic_cast<RouteTimeAxisView*>(clicked_axisview);
ret = button_press_handler (item, event, FadeInHandleItem);
break;
case GDK_BUTTON_RELEASE:
ret = button_release_handler (item, event, FadeInHandleItem);
maybe_locate_with_edit_preroll ( rv->region()->position() );
break;
case GDK_MOTION_NOTIFY:
ret = motion_handler (item, event);
break;
case GDK_ENTER_NOTIFY:
set_entered_regionview (rv);
ret = enter_handler (item, event, FadeInHandleItem);
break;
case GDK_LEAVE_NOTIFY:
set_entered_regionview (0);
ret = leave_handler (item, event, FadeInHandleItem);
break;
default:
break;
}
return ret;
}
bool
Editor::canvas_fade_out_event (GdkEvent *event, ArdourCanvas::Item* item, AudioRegionView *rv)
{
/* we handle only button 3 press/release events */
if (!rv->sensitive()) {
return false;
}
switch (event->type) {
case GDK_BUTTON_PRESS:
clicked_regionview = rv;
clicked_control_point = 0;
clicked_axisview = &rv->get_time_axis_view();
clicked_routeview = dynamic_cast<RouteTimeAxisView*>(clicked_axisview);
if (event->button.button == 3) {
return button_press_handler (item, event, FadeOutItem);
}
break;
case GDK_BUTTON_RELEASE:
if (event->button.button == 3) {
return button_release_handler (item, event, FadeOutItem);
}
break;
default:
break;
}
/* proxy for the regionview */
return canvas_region_view_event (event, rv->get_canvas_group(), rv);
}
bool
Editor::canvas_fade_out_handle_event (GdkEvent *event, ArdourCanvas::Item* item, AudioRegionView *rv)
{
bool ret = false;
if (!rv->sensitive()) {
return false;
}
switch (event->type) {
case GDK_BUTTON_PRESS:
case GDK_2BUTTON_PRESS:
case GDK_3BUTTON_PRESS:
clicked_regionview = rv;
clicked_control_point = 0;
clicked_axisview = &rv->get_time_axis_view();
clicked_routeview = dynamic_cast<RouteTimeAxisView*>(clicked_axisview);
ret = button_press_handler (item, event, FadeOutHandleItem);
break;
case GDK_BUTTON_RELEASE:
ret = button_release_handler (item, event, FadeOutHandleItem);
maybe_locate_with_edit_preroll ( rv->region()->last_frame() - rv->get_fade_out_shape_width() );
break;
case GDK_MOTION_NOTIFY:
ret = motion_handler (item, event);
break;
case GDK_ENTER_NOTIFY:
set_entered_regionview (rv);
ret = enter_handler (item, event, FadeOutHandleItem);
break;
case GDK_LEAVE_NOTIFY:
set_entered_regionview (0);
ret = leave_handler (item, event, FadeOutHandleItem);
break;
default:
break;
}
return ret;
}
struct DescendingRegionLayerSorter {
bool operator()(boost::shared_ptr<Region> a, boost::shared_ptr<Region> b) {
return a->layer() > b->layer();
}
};
bool
Editor::canvas_control_point_event (GdkEvent *event, ArdourCanvas::Item* item, ControlPoint* cp)
{
switch (event->type) {
case GDK_BUTTON_PRESS:
case GDK_2BUTTON_PRESS:
case GDK_3BUTTON_PRESS:
clicked_control_point = cp;
clicked_axisview = &cp->line().trackview;
clicked_routeview = dynamic_cast<RouteTimeAxisView*>(clicked_axisview);
clicked_regionview = 0;
break;
case GDK_SCROLL_UP:
break;
case GDK_SCROLL_DOWN:
break;
default:
break;
}
return typed_event (item, event, ControlPointItem);
}
bool
Editor::canvas_line_event (GdkEvent *event, ArdourCanvas::Item* item, AutomationLine* al)
{
ItemType type;
if (dynamic_cast<AudioRegionGainLine*> (al) != 0) {
type = GainLineItem;
} else {
type = AutomationLineItem;
}
return typed_event (item, event, type);
}
bool
Editor::canvas_selection_rect_event (GdkEvent *event, ArdourCanvas::Item* item, SelectionRect* rect)
{
bool ret = false;
switch (event->type) {
case GDK_BUTTON_PRESS:
case GDK_2BUTTON_PRESS:
case GDK_3BUTTON_PRESS:
clicked_selection = rect->id;
ret = button_press_handler (item, event, SelectionItem);
break;
case GDK_BUTTON_RELEASE:
ret = button_release_handler (item, event, SelectionItem);
break;
case GDK_MOTION_NOTIFY:
ret = motion_handler (item, event);
break;
/* Don't need these at the moment. */
case GDK_ENTER_NOTIFY:
ret = enter_handler (item, event, SelectionItem);
break;
case GDK_LEAVE_NOTIFY:
ret = leave_handler (item, event, SelectionItem);
break;
default:
break;
}
return ret;
}
bool
Editor::canvas_selection_start_trim_event (GdkEvent *event, ArdourCanvas::Item* item, SelectionRect* rect)
{
bool ret = false;
switch (event->type) {
case GDK_BUTTON_PRESS:
case GDK_2BUTTON_PRESS:
case GDK_3BUTTON_PRESS:
clicked_selection = rect->id;
ret = button_press_handler (item, event, StartSelectionTrimItem);
break;
case GDK_BUTTON_RELEASE:
ret = button_release_handler (item, event, StartSelectionTrimItem);
break;
case GDK_MOTION_NOTIFY:
ret = motion_handler (item, event);
break;
case GDK_ENTER_NOTIFY:
ret = enter_handler (item, event, StartSelectionTrimItem);
break;
case GDK_LEAVE_NOTIFY:
ret = leave_handler (item, event, StartSelectionTrimItem);
break;
default:
break;
}
return ret;
}
bool
Editor::canvas_selection_end_trim_event (GdkEvent *event, ArdourCanvas::Item* item, SelectionRect* rect)
{
bool ret = false;
switch (event->type) {
case GDK_BUTTON_PRESS:
case GDK_2BUTTON_PRESS:
case GDK_3BUTTON_PRESS:
clicked_selection = rect->id;
ret = button_press_handler (item, event, EndSelectionTrimItem);
break;
case GDK_BUTTON_RELEASE:
ret = button_release_handler (item, event, EndSelectionTrimItem);
break;
case GDK_MOTION_NOTIFY:
ret = motion_handler (item, event);
break;
case GDK_ENTER_NOTIFY:
ret = enter_handler (item, event, EndSelectionTrimItem);
break;
case GDK_LEAVE_NOTIFY:
ret = leave_handler (item, event, EndSelectionTrimItem);
break;
default:
break;
}
return ret;
}
bool
Editor::canvas_frame_handle_event (GdkEvent* event, ArdourCanvas::Item* item, RegionView* rv)
{
bool ret = false;
/* frame handles are not active when in internal edit mode, because actual notes
might be in the area occupied by the handle - we want them to be editable as normal.
*/
if (internal_editing() || !rv->sensitive()) {
return false;
}
/* NOTE: frame handles pretend to be the colored trim bar from an event handling
perspective. XXX change this ??
*/
ItemType type;
if (item->get_data ("isleft")) {
type = LeftFrameHandle;
} else {
type = RightFrameHandle;
}
switch (event->type) {
case GDK_BUTTON_PRESS:
case GDK_2BUTTON_PRESS:
case GDK_3BUTTON_PRESS:
clicked_regionview = rv;
clicked_control_point = 0;
clicked_axisview = &clicked_regionview->get_time_axis_view();
clicked_routeview = dynamic_cast<RouteTimeAxisView*>(clicked_axisview);
ret = button_press_handler (item, event, type);
break;
case GDK_BUTTON_RELEASE:
ret = button_release_handler (item, event, type);
break;
case GDK_MOTION_NOTIFY:
ret = motion_handler (item, event);
break;
case GDK_ENTER_NOTIFY:
set_entered_regionview (rv);
ret = enter_handler (item, event, type);
break;
case GDK_LEAVE_NOTIFY:
set_entered_regionview (0);
ret = leave_handler (item, event, type);
break;
default:
break;
}
return ret;
}
bool
Editor::canvas_region_view_name_highlight_event (GdkEvent* event, ArdourCanvas::Item* item, RegionView* rv)
{
bool ret = false;
if (!rv->sensitive()) {
return false;
}
switch (event->type) {
case GDK_BUTTON_PRESS:
case GDK_2BUTTON_PRESS:
case GDK_3BUTTON_PRESS:
clicked_regionview = rv;
clicked_control_point = 0;
clicked_axisview = &clicked_regionview->get_time_axis_view();
clicked_routeview = dynamic_cast<RouteTimeAxisView*>(clicked_axisview);
ret = button_press_handler (item, event, RegionViewNameHighlight);
break;
case GDK_BUTTON_RELEASE:
ret = button_release_handler (item, event, RegionViewNameHighlight);
break;
case GDK_MOTION_NOTIFY:
motion_handler (item, event);
ret = true; // force this to avoid progagating the event into the regionview
break;
case GDK_ENTER_NOTIFY:
set_entered_regionview (rv);
ret = enter_handler (item, event, RegionViewNameHighlight);
break;
case GDK_LEAVE_NOTIFY:
set_entered_regionview (0);
ret = leave_handler (item, event, RegionViewNameHighlight);
break;
default:
break;
}
return ret;
}
bool
Editor::canvas_region_view_name_event (GdkEvent *event, ArdourCanvas::Item* item, RegionView* rv)
{
bool ret = false;
if (!rv->sensitive()) {
return false;
}
switch (event->type) {
case GDK_BUTTON_PRESS:
case GDK_2BUTTON_PRESS:
case GDK_3BUTTON_PRESS:
clicked_regionview = rv;
clicked_control_point = 0;
clicked_axisview = &clicked_regionview->get_time_axis_view();
clicked_routeview = dynamic_cast<RouteTimeAxisView*>(clicked_axisview);
ret = button_press_handler (item, event, RegionViewName);
break;
case GDK_BUTTON_RELEASE:
ret = button_release_handler (item, event, RegionViewName);
break;
case GDK_MOTION_NOTIFY:
ret = motion_handler (item, event);
break;
case GDK_ENTER_NOTIFY:
set_entered_regionview (rv);
ret = enter_handler (item, event, RegionViewName);
break;
case GDK_LEAVE_NOTIFY:
set_entered_regionview (0);
ret = leave_handler (item, event, RegionViewName);
break;
default:
break;
}
return ret;
}
bool
Editor::canvas_feature_line_event (GdkEvent *event, ArdourCanvas::Item* item, RegionView*)
{
bool ret = false;
switch (event->type) {
case GDK_BUTTON_PRESS:
case GDK_2BUTTON_PRESS:
case GDK_3BUTTON_PRESS:
clicked_regionview = 0;
clicked_control_point = 0;
clicked_axisview = 0;
clicked_routeview = 0; //dynamic_cast<RouteTimeAxisView*>(clicked_axisview);
ret = button_press_handler (item, event, FeatureLineItem);
break;
case GDK_BUTTON_RELEASE:
ret = button_release_handler (item, event, FeatureLineItem);
break;
case GDK_MOTION_NOTIFY:
ret = motion_handler (item, event);
break;
case GDK_ENTER_NOTIFY:
ret = enter_handler (item, event, FeatureLineItem);
break;
case GDK_LEAVE_NOTIFY:
ret = leave_handler (item, event, FeatureLineItem);
break;
default:
break;
}
return ret;
}
bool
Editor::canvas_marker_event (GdkEvent *event, ArdourCanvas::Item* item, Marker* /*marker*/)
{
return typed_event (item, event, MarkerItem);
}
bool
Editor::canvas_marker_bar_event (GdkEvent *event, ArdourCanvas::Item* item)
{
return typed_event (item, event, MarkerBarItem);
}
bool
Editor::canvas_range_marker_bar_event (GdkEvent *event, ArdourCanvas::Item* item)
{
return typed_event (item, event, RangeMarkerBarItem);
}
bool
Editor::canvas_transport_marker_bar_event (GdkEvent *event, ArdourCanvas::Item* item)
{
return typed_event (item, event, TransportMarkerBarItem);
}
bool
Editor::canvas_cd_marker_bar_event (GdkEvent *event, ArdourCanvas::Item* item)
{
return typed_event (item, event, CdMarkerBarItem);
}
bool
Editor::canvas_videotl_bar_event (GdkEvent *event, ArdourCanvas::Item* item)
{
return typed_event (item, event, VideoBarItem);
}
bool
Editor::canvas_tempo_marker_event (GdkEvent *event, ArdourCanvas::Item* item, TempoMarker* /*marker*/)
{
return typed_event (item, event, TempoMarkerItem);
}
bool
Editor::canvas_meter_marker_event (GdkEvent *event, ArdourCanvas::Item* item, MeterMarker* /*marker*/)
{
return typed_event (item, event, MeterMarkerItem);
}
bool
Editor::canvas_tempo_bar_event (GdkEvent *event, ArdourCanvas::Item* item)
{
return typed_event (item, event, TempoBarItem);
}
bool
Editor::canvas_meter_bar_event (GdkEvent *event, ArdourCanvas::Item* item)
{
return typed_event (item, event, MeterBarItem);
}
bool
Editor::canvas_playhead_cursor_event (GdkEvent *event, ArdourCanvas::Item* item)
{
return typed_event (item, event, PlayheadCursorItem);
}
bool
Editor::canvas_zoom_rect_event (GdkEvent *event, ArdourCanvas::Item* item)
{
return typed_event (item, event, NoItem);
}
bool
Editor::canvas_note_event (GdkEvent *event, ArdourCanvas::Item* item)
{
if (!internal_editing()) {
return false;
}
return typed_event (item, event, NoteItem);
}
bool
Editor::track_canvas_drag_motion (Glib::RefPtr<Gdk::DragContext> const& context, int x, int y, guint time)
{
double wx;
double wy;
boost::shared_ptr<Region> region;
boost::shared_ptr<Region> region_copy;
RouteTimeAxisView* rtav;
GdkEvent event;
double px;
double py;
string target = track_canvas->drag_dest_find_target (context, track_canvas->drag_dest_get_target_list());
if (target.empty()) {
return false;
}
track_canvas->window_to_world (x, y, wx, wy);
event.type = GDK_MOTION_NOTIFY;
event.button.x = wx;
event.button.y = wy;
/* assume we're dragging with button 1 */
event.motion.state = Gdk::BUTTON1_MASK;
(void) event_frame (&event, &px, &py);
std::pair<TimeAxisView*, int> const tv = trackview_by_y_position (py);
bool can_drop = false;
if (tv.first != 0) {
/* over a time axis view of some kind */
rtav = dynamic_cast<RouteTimeAxisView*> (tv.first);
if (rtav != 0 && rtav->is_track ()) {
/* over a track, not a bus */
can_drop = true;
}
} else {
/* not over a time axis view, so drop is possible */
can_drop = true;
}
if (can_drop) {
region = _regions->get_dragged_region ();
if (region) {
if ((boost::dynamic_pointer_cast<AudioRegion> (region) != 0 &&
dynamic_cast<AudioTimeAxisView*> (tv.first) != 0) ||
(boost::dynamic_pointer_cast<MidiRegion> (region) != 0 &&
dynamic_cast<MidiTimeAxisView*> (tv.first) != 0)) {
/* audio to audio
OR
midi to midi
*/
context->drag_status (context->get_suggested_action(), time);
return true;
}
} else {
/* DND originating from outside ardour
*
* TODO: check if file is audio/midi, allow drops on same track-type only,
* currently: if audio is dropped on a midi-track, it is only added to the region-list
*/
if (Profile->get_sae() || Config->get_only_copy_imported_files()) {
context->drag_status(Gdk::ACTION_COPY, time);
} else {
if ((context->get_actions() & (Gdk::ACTION_COPY | Gdk::ACTION_LINK | Gdk::ACTION_MOVE)) == Gdk::ACTION_COPY) {
context->drag_status(Gdk::ACTION_COPY, time);
} else {
context->drag_status(Gdk::ACTION_LINK, time);
}
}
return true;
}
}
/* no drop here */
context->drag_status (Gdk::DragAction (0), time);
return false;
}
void
Editor::drop_regions (const Glib::RefPtr<Gdk::DragContext>& /*context*/,
int x, int y,
const SelectionData& /*data*/,
guint /*info*/, guint /*time*/)
{
double wx;
double wy;
boost::shared_ptr<Region> region;
boost::shared_ptr<Region> region_copy;
RouteTimeAxisView* rtav;
GdkEvent event;
double px;
double py;
track_canvas->window_to_world (x, y, wx, wy);
event.type = GDK_MOTION_NOTIFY;
event.button.x = wx;
event.button.y = wy;
/* assume we're dragging with button 1 */
event.motion.state = Gdk::BUTTON1_MASK;
framepos_t const pos = event_frame (&event, &px, &py);
std::pair<TimeAxisView*, int> const tv = trackview_by_y_position (py);
if (tv.first != 0) {
rtav = dynamic_cast<RouteTimeAxisView*> (tv.first);
if (rtav != 0 && rtav->is_track ()) {
boost::shared_ptr<Region> region = _regions->get_dragged_region ();
if (region) {
region_copy = RegionFactory::create (region, true);
if ((boost::dynamic_pointer_cast<AudioRegion> (region_copy) != 0 &&
dynamic_cast<AudioTimeAxisView*> (tv.first) != 0) ||
(boost::dynamic_pointer_cast<MidiRegion> (region_copy) != 0 &&
dynamic_cast<MidiTimeAxisView*> (tv.first) != 0)) {
/* audio to audio
OR
midi to midi
*/
_drags->set (new RegionInsertDrag (this, region_copy, rtav, pos), &event);
_drags->end_grab (0);
}
}
}
}
}
bool
Editor::key_press_handler (ArdourCanvas::Item*, GdkEvent*, ItemType)
{
return false;
}
bool
Editor::key_release_handler (ArdourCanvas::Item* item, GdkEvent* event, ItemType type)
{
bool handled = false;
switch (type) {
case TempoMarkerItem:
switch (event->key.keyval) {
case GDK_Delete:
remove_tempo_marker (item);
handled = true;
break;
default:
break;
}
break;
case MeterMarkerItem:
switch (event->key.keyval) {
case GDK_Delete:
remove_meter_marker (item);
handled = true;
break;
default:
break;
}
break;
default:
break;
}
return handled;
}