X-Git-Url: https://git.carlh.net/gitweb/?a=blobdiff_plain;f=gtk2_ardour%2Feditor_canvas.cc;h=d923489d7cb12f7388126174ffc5dec5fa12a14a;hb=5fef65538040fbac1b9edd1847a269aa925a49c9;hp=9c00efff151535eb14b8665402f9a791ecfd466c;hpb=144033e55c004a68c9b6433ba26d92baf5cfa6d1;p=ardour.git diff --git a/gtk2_ardour/editor_canvas.cc b/gtk2_ardour/editor_canvas.cc index 9c00efff15..d923489d7c 100644 --- a/gtk2_ardour/editor_canvas.cc +++ b/gtk2_ardour/editor_canvas.cc @@ -35,6 +35,7 @@ #include "canvas/debug.h" #include "ardour_ui.h" +#include "automation_time_axis.h" #include "editor.h" #include "global_signals.h" #include "editing.h" @@ -55,6 +56,7 @@ using namespace std; using namespace ARDOUR; +using namespace ARDOUR_UI_UTILS; using namespace PBD; using namespace Gtk; using namespace Glib; @@ -67,6 +69,13 @@ Editor::initialize_canvas () _track_canvas_viewport = new ArdourCanvas::GtkCanvasViewport (horizontal_adjustment, vertical_adjustment); _track_canvas = _track_canvas_viewport->canvas (); + _track_canvas->set_background_color (ARDOUR_UI::config()->color ("arrange base")); + + /* scroll group for items that should not automatically scroll + * (e.g verbose cursor). It shares the canvas coordinate space. + */ + no_scroll_group = new ArdourCanvas::Container (_track_canvas->root()); + ArdourCanvas::ScrollGroup* hsg; ArdourCanvas::ScrollGroup* hg; ArdourCanvas::ScrollGroup* vg; @@ -100,7 +109,7 @@ Editor::initialize_canvas () } /*a group to hold global rects like punch/loop indicators */ - global_rect_group = new ArdourCanvas::Group (hv_scroll_group); + global_rect_group = new ArdourCanvas::Container (hv_scroll_group); CANVAS_DEBUG_NAME (global_rect_group, "global rect group"); transport_loop_range_rect = new ArdourCanvas::Rectangle (global_rect_group, ArdourCanvas::Rect (0.0, 0.0, 0.0, ArdourCanvas::COORD_MAX)); @@ -112,17 +121,12 @@ Editor::initialize_canvas () transport_punch_range_rect->hide(); /*a group to hold time (measure) lines */ - time_line_group = new ArdourCanvas::Group (hv_scroll_group); + time_line_group = new ArdourCanvas::Container (hv_scroll_group); CANVAS_DEBUG_NAME (time_line_group, "time line group"); - _trackview_group = new ArdourCanvas::Group (hv_scroll_group); + _trackview_group = new ArdourCanvas::Container (hv_scroll_group); CANVAS_DEBUG_NAME (_trackview_group, "Canvas TrackViews"); - // used to show zoom mode active zooming - zoom_rect = new ArdourCanvas::Rectangle (hv_scroll_group, ArdourCanvas::Rect (0.0, 0.0, 0.0, 0.0)); - zoom_rect->hide(); - zoom_rect->Event.connect (sigc::bind (sigc::mem_fun (*this, &Editor::canvas_zoom_rect_event), (ArdourCanvas::Item*) 0)); - // used as rubberband rect rubberband_rect = new ArdourCanvas::Rectangle (hv_scroll_group, ArdourCanvas::Rect (0.0, 0.0, 0.0, 0.0)); rubberband_rect->hide(); @@ -130,30 +134,30 @@ Editor::initialize_canvas () /* a group to hold stuff while it gets dragged around. Must be the * uppermost (last) group with hv_scroll_group as a parent */ - _drag_motion_group = new ArdourCanvas::Group (hv_scroll_group); + _drag_motion_group = new ArdourCanvas::Container (hv_scroll_group); CANVAS_DEBUG_NAME (_drag_motion_group, "Canvas Drag Motion"); /* TIME BAR CANVAS */ - _time_markers_group = new ArdourCanvas::Group (h_scroll_group); + _time_markers_group = new ArdourCanvas::Container (h_scroll_group); CANVAS_DEBUG_NAME (_time_markers_group, "time bars"); - cd_marker_group = new ArdourCanvas::Group (_time_markers_group, ArdourCanvas::Duple (0.0, 0.0)); + cd_marker_group = new ArdourCanvas::Container (_time_markers_group, ArdourCanvas::Duple (0.0, 0.0)); CANVAS_DEBUG_NAME (cd_marker_group, "cd marker group"); /* the vide is temporarily placed a the same location as the cd_marker_group, but is moved later. */ - videotl_group = new ArdourCanvas::Group (_time_markers_group, ArdourCanvas::Duple(0.0, 0.0)); + videotl_group = new ArdourCanvas::Container (_time_markers_group, ArdourCanvas::Duple(0.0, 0.0)); CANVAS_DEBUG_NAME (videotl_group, "videotl group"); - marker_group = new ArdourCanvas::Group (_time_markers_group, ArdourCanvas::Duple (0.0, timebar_height + 1.0)); + marker_group = new ArdourCanvas::Container (_time_markers_group, ArdourCanvas::Duple (0.0, timebar_height + 1.0)); CANVAS_DEBUG_NAME (marker_group, "marker group"); - transport_marker_group = new ArdourCanvas::Group (_time_markers_group, ArdourCanvas::Duple (0.0, (timebar_height * 2.0) + 1.0)); + transport_marker_group = new ArdourCanvas::Container (_time_markers_group, ArdourCanvas::Duple (0.0, (timebar_height * 2.0) + 1.0)); CANVAS_DEBUG_NAME (transport_marker_group, "transport marker group"); - range_marker_group = new ArdourCanvas::Group (_time_markers_group, ArdourCanvas::Duple (0.0, (timebar_height * 3.0) + 1.0)); + range_marker_group = new ArdourCanvas::Container (_time_markers_group, ArdourCanvas::Duple (0.0, (timebar_height * 3.0) + 1.0)); CANVAS_DEBUG_NAME (range_marker_group, "range marker group"); - tempo_group = new ArdourCanvas::Group (_time_markers_group, ArdourCanvas::Duple (0.0, (timebar_height * 4.0) + 1.0)); + tempo_group = new ArdourCanvas::Container (_time_markers_group, ArdourCanvas::Duple (0.0, (timebar_height * 4.0) + 1.0)); CANVAS_DEBUG_NAME (tempo_group, "tempo group"); - meter_group = new ArdourCanvas::Group (_time_markers_group, ArdourCanvas::Duple (0.0, (timebar_height * 5.0) + 1.0)); + meter_group = new ArdourCanvas::Container (_time_markers_group, ArdourCanvas::Duple (0.0, (timebar_height * 5.0) + 1.0)); CANVAS_DEBUG_NAME (meter_group, "meter group"); meter_bar = new ArdourCanvas::Rectangle (meter_group, ArdourCanvas::Rect (0.0, 0.0, ArdourCanvas::COORD_MAX, timebar_height)); @@ -236,7 +240,7 @@ Editor::initialize_canvas () handlers. */ - _track_canvas->signal_scroll_event().connect (sigc::mem_fun (*this, &Editor::canvas_scroll_event)); + _track_canvas->signal_scroll_event().connect (sigc::bind (sigc::mem_fun (*this, &Editor::canvas_scroll_event), true)); _track_canvas->signal_motion_notify_event().connect (sigc::mem_fun (*this, &Editor::track_canvas_motion_notify_event)); _track_canvas->signal_button_press_event().connect (sigc::mem_fun (*this, &Editor::track_canvas_button_press_event)); _track_canvas->signal_button_release_event().connect (sigc::mem_fun (*this, &Editor::track_canvas_button_release_event)); @@ -266,6 +270,8 @@ Editor::initialize_canvas () _track_canvas_viewport->signal_size_allocate().connect (sigc::mem_fun(*this, &Editor::track_canvas_viewport_allocate)); + initialize_rulers (); + ColorsChanged.connect (sigc::mem_fun (*this, &Editor::color_handler)); color_handler(); @@ -316,7 +322,7 @@ Editor::track_canvas_viewport_size_allocated () void Editor::reset_controls_layout_width () { - GtkRequisition req; + GtkRequisition req = { 0, 0 }; gint w; edit_controls_vbox.size_request (req); @@ -410,7 +416,7 @@ Editor::drop_paths_part_two (const vector& paths, framepos_t frame, doub } - std::pair const tvp = trackview_by_y_position (ypos); + std::pair const tvp = trackview_by_y_position (ypos, false); if (tvp.first == 0) { /* drop onto canvas background: create new tracks */ @@ -491,18 +497,43 @@ Editor::drop_paths (const RefPtr& context, void Editor::maybe_autoscroll (bool allow_horiz, bool allow_vert, bool from_headers) { - if (!Config->get_autoscroll_editor ()) { + if (!Config->get_autoscroll_editor () || autoscroll_active ()) { return; } + /* define a rectangular boundary for scrolling. If the mouse moves + * outside of this area and/or continue to be outside of this area, + * then we will continuously auto-scroll the canvas in the appropriate + * direction(s) + * + * the boundary is defined in coordinates relative to the toplevel + * window since that is what we're going to call ::get_pointer() on + * during autoscrolling to determine if we're still outside the + * boundary or not. + */ + ArdourCanvas::Rect scrolling_boundary; Gtk::Allocation alloc; - + if (from_headers) { alloc = controls_layout.get_allocation (); - } else { + } else { alloc = _track_canvas_viewport->get_allocation (); + + /* reduce height by the height of the timebars, which happens + to correspond to the position of the hv_scroll_group. + */ + alloc.set_height (alloc.get_height() - hv_scroll_group->position().y); + alloc.set_y (alloc.get_y() + hv_scroll_group->position().y); + + /* now reduce it again so that we start autoscrolling before we + * move off the top or bottom of the canvas + */ + + alloc.set_height (alloc.get_height() - 20); + alloc.set_y (alloc.get_y() + 10); + /* the effective width of the autoscroll boundary so that we start scrolling before we hit the edge. @@ -515,19 +546,18 @@ Editor::maybe_autoscroll (bool allow_horiz, bool allow_vert, bool from_headers) alloc.set_width (alloc.get_width() - 20); alloc.set_x (alloc.get_x() + 10); } + } - scrolling_boundary = ArdourCanvas::Rect (alloc.get_x(), alloc.get_y(), - alloc.get_x() + alloc.get_width(), - alloc.get_y() + alloc.get_height()); + scrolling_boundary = ArdourCanvas::Rect (alloc.get_x(), alloc.get_y(), alloc.get_x() + alloc.get_width(), alloc.get_y() + alloc.get_height()); int x, y; Gdk::ModifierType mask; get_window()->get_pointer (x, y, mask); - if ((allow_horiz && (x < scrolling_boundary.x0 || x >= scrolling_boundary.x1)) || - (allow_vert && (y < scrolling_boundary.y0 || y >= scrolling_boundary.y1))) { + if ((allow_horiz && ((x < scrolling_boundary.x0 && leftmost_frame > 0) || x >= scrolling_boundary.x1)) || + (allow_vert && ((y < scrolling_boundary.y0 && vertical_adjustment.get_value() > 0)|| y >= scrolling_boundary.y1))) { start_canvas_autoscroll (allow_horiz, allow_vert, scrolling_boundary); } } @@ -545,11 +575,11 @@ Editor::autoscroll_canvas () Gdk::ModifierType mask; frameoffset_t dx = 0; bool no_stop = false; - bool y_motion = false; get_window()->get_pointer (x, y, mask); VisualChange vc; + bool vertical_motion = false; if (autoscroll_horizontal_allowed) { @@ -597,8 +627,8 @@ Editor::autoscroll_canvas () if (autoscroll_vertical_allowed) { - const double vertical_pos = vertical_adjustment.get_value(); - const int speed_factor = 20; + // const double vertical_pos = vertical_adjustment.get_value(); + const int speed_factor = 10; /* vertical */ @@ -607,21 +637,22 @@ Editor::autoscroll_canvas () /* scroll to make higher tracks visible */ if (autoscroll_cnt && (autoscroll_cnt % speed_factor == 0)) { - y_motion = scroll_up_one_track (); + scroll_up_one_track (); + vertical_motion = true; } } else if (y > autoscroll_boundary.y1) { if (autoscroll_cnt && (autoscroll_cnt % speed_factor == 0)) { - y_motion = scroll_down_one_track (); - + scroll_down_one_track (); + vertical_motion = true; } } no_stop = true; } - if (vc.pending) { + if (vc.pending || vertical_motion) { /* change horizontal first */ @@ -640,26 +671,33 @@ Editor::autoscroll_canvas () /* the motion handler expects events in canvas coordinate space */ - /* first convert from Editor window coordinates to canvas - * window coordinates + /* we asked for the mouse position above (::get_pointer()) via + * our own top level window (we being the Editor). Convert into + * coordinates within the canvas window. */ int cx; int cy; - /* clamp x and y to remain within the visible area */ + translate_coordinates (*_track_canvas, x, y, cx, cy); - x = min (max ((ArdourCanvas::Coord) x, autoscroll_boundary.x0), autoscroll_boundary.x1); - y = min (max ((ArdourCanvas::Coord) y, autoscroll_boundary.y0), autoscroll_boundary.y1); + /* clamp x and y to remain within the autoscroll boundary, + * which is defined in window coordinates + */ - translate_coordinates (*_track_canvas_viewport, x, y, cx, cy); + x = min (max ((ArdourCanvas::Coord) cx, autoscroll_boundary.x0), autoscroll_boundary.x1); + y = min (max ((ArdourCanvas::Coord) cy, autoscroll_boundary.y0), autoscroll_boundary.y1); + + /* now convert from Editor window coordinates to canvas + * window coordinates + */ ArdourCanvas::Duple d = _track_canvas->window_to_canvas (ArdourCanvas::Duple (cx, cy)); ev.x = d.x; ev.y = d.y; motion_handler (0, (GdkEvent*) &ev, true); - + } else if (no_stop) { /* not changing visual state but pointer is outside the scrolling boundary @@ -699,7 +737,7 @@ Editor::autoscroll_canvas () ev.y = d.y; motion_handler (0, (GdkEvent*) &ev, true); - + } else { stop_canvas_autoscroll (); return false; @@ -760,26 +798,48 @@ Editor::entered_track_canvas (GdkEventCrossing */*ev*/) } void -Editor::_ensure_time_axis_view_is_visible (const TimeAxisView& tav, bool at_top) +Editor::ensure_time_axis_view_is_visible (TimeAxisView const & track, bool at_top) { - double begin = tav.y_position(); - double v = vertical_adjustment.get_value (); - - if (!at_top && (begin < v || begin + tav.current_height() > v + _visible_canvas_height)) { - /* try to put the TimeAxisView roughly central */ - if (begin >= _visible_canvas_height/2.0) { - begin -= _visible_canvas_height/2.0; - } + if (track.hidden()) { + return; } - /* Clamp the y pos so that we do not extend beyond the canvas full - * height. + /* compute visible area of trackview group, as offsets from top of + * trackview group. */ - if (_full_canvas_height - begin < _visible_canvas_height){ - begin = _full_canvas_height - _visible_canvas_height; + + double const current_view_min_y = vertical_adjustment.get_value(); + double const current_view_max_y = current_view_min_y + vertical_adjustment.get_page_size(); + + double const track_min_y = track.y_position (); + double const track_max_y = track.y_position () + track.effective_height (); + + if (!at_top && + (track_min_y >= current_view_min_y && + track_max_y < current_view_max_y)) { + /* already visible, and caller did not ask to place it at the + * top of the track canvas + */ + return; + } + + double new_value; + + if (at_top) { + new_value = track_min_y; + } else { + if (track_min_y < current_view_min_y) { + // Track is above the current view + new_value = track_min_y; + } else if (track_max_y > current_view_max_y) { + // Track is below the current view + new_value = track.y_position () + track.effective_height() - vertical_adjustment.get_page_size(); + } else { + new_value = track_min_y; + } } - vertical_adjustment.set_value (begin); + vertical_adjustment.set_value(new_value); } /** Called when the main vertical_adjustment has changed */ @@ -811,58 +871,69 @@ Editor::set_horizontal_position (double p) void Editor::color_handler() { - playhead_cursor->set_color (ARDOUR_UI::config()->get_canvasvar_PlayHead()); - _verbose_cursor->set_color (ARDOUR_UI::config()->get_canvasvar_VerboseCanvasCursor()); - - meter_bar->set_fill_color (ARDOUR_UI::config()->get_canvasvar_MeterBar()); - meter_bar->set_outline_color (ARDOUR_UI::config()->get_canvasvar_MarkerBarSeparator()); + ArdourCanvas::Color base = ARDOUR_UI::config()->color ("ruler base"); + ArdourCanvas::Color text = ARDOUR_UI::config()->color ("ruler text"); + timecode_ruler->set_fill_color (base); + timecode_ruler->set_outline_color (text); + minsec_ruler->set_fill_color (base); + minsec_ruler->set_outline_color (text); + samples_ruler->set_fill_color (base); + samples_ruler->set_outline_color (text); + bbt_ruler->set_fill_color (base); + bbt_ruler->set_outline_color (text); + + playhead_cursor->set_color (ARDOUR_UI::config()->color ("play head")); - tempo_bar->set_fill_color (ARDOUR_UI::config()->get_canvasvar_TempoBar()); - tempo_bar->set_outline_color (ARDOUR_UI::config()->get_canvasvar_MarkerBarSeparator()); + meter_bar->set_fill_color (ARDOUR_UI::config()->color ("meter bar")); + meter_bar->set_outline_color (ARDOUR_UI::config()->color ("marker bar separator")); - marker_bar->set_fill_color (ARDOUR_UI::config()->get_canvasvar_MarkerBar()); - marker_bar->set_outline_color (ARDOUR_UI::config()->get_canvasvar_MarkerBarSeparator()); + tempo_bar->set_fill_color (ARDOUR_UI::config()->color ("tempo bar")); + tempo_bar->set_outline_color (ARDOUR_UI::config()->color ("marker bar separator")); - cd_marker_bar->set_fill_color (ARDOUR_UI::config()->get_canvasvar_CDMarkerBar()); - cd_marker_bar->set_outline_color (ARDOUR_UI::config()->get_canvasvar_MarkerBarSeparator()); + marker_bar->set_fill_color (ARDOUR_UI::config()->color ("marker bar")); + marker_bar->set_outline_color (ARDOUR_UI::config()->color ("marker bar separator")); - range_marker_bar->set_fill_color (ARDOUR_UI::config()->get_canvasvar_RangeMarkerBar()); - range_marker_bar->set_outline_color (ARDOUR_UI::config()->get_canvasvar_MarkerBarSeparator()); + cd_marker_bar->set_fill_color (ARDOUR_UI::config()->color ("cd marker bar")); + cd_marker_bar->set_outline_color (ARDOUR_UI::config()->color ("marker bar separator")); - transport_marker_bar->set_fill_color (ARDOUR_UI::config()->get_canvasvar_TransportMarkerBar()); - transport_marker_bar->set_outline_color (ARDOUR_UI::config()->get_canvasvar_MarkerBarSeparator()); + range_marker_bar->set_fill_color (ARDOUR_UI::config()->color ("range marker bar")); + range_marker_bar->set_outline_color (ARDOUR_UI::config()->color ("marker bar separator")); - cd_marker_bar_drag_rect->set_fill_color (ARDOUR_UI::config()->get_canvasvar_RangeDragBarRect()); - cd_marker_bar_drag_rect->set_outline_color (ARDOUR_UI::config()->get_canvasvar_RangeDragBarRect()); + transport_marker_bar->set_fill_color (ARDOUR_UI::config()->color ("transport marker bar")); + transport_marker_bar->set_outline_color (ARDOUR_UI::config()->color ("marker bar separator")); - range_bar_drag_rect->set_fill_color (ARDOUR_UI::config()->get_canvasvar_RangeDragBarRect()); - range_bar_drag_rect->set_outline_color (ARDOUR_UI::config()->get_canvasvar_RangeDragBarRect()); + cd_marker_bar_drag_rect->set_fill_color (ARDOUR_UI::config()->color ("range drag bar rect")); + cd_marker_bar_drag_rect->set_outline_color (ARDOUR_UI::config()->color ("range drag bar rect")); - transport_bar_drag_rect->set_fill_color (ARDOUR_UI::config()->get_canvasvar_TransportDragRect()); - transport_bar_drag_rect->set_outline_color (ARDOUR_UI::config()->get_canvasvar_TransportDragRect()); + range_bar_drag_rect->set_fill_color (ARDOUR_UI::config()->color ("range drag bar rect")); + range_bar_drag_rect->set_outline_color (ARDOUR_UI::config()->color ("range drag bar rect")); - transport_loop_range_rect->set_fill_color (ARDOUR_UI::config()->get_canvasvar_TransportLoopRect()); - transport_loop_range_rect->set_outline_color (ARDOUR_UI::config()->get_canvasvar_TransportLoopRect()); + transport_bar_drag_rect->set_fill_color (ARDOUR_UI::config()->color ("transport drag rect")); + transport_bar_drag_rect->set_outline_color (ARDOUR_UI::config()->color ("transport drag rect")); - transport_punch_range_rect->set_fill_color (ARDOUR_UI::config()->get_canvasvar_TransportPunchRect()); - transport_punch_range_rect->set_outline_color (ARDOUR_UI::config()->get_canvasvar_TransportPunchRect()); + transport_loop_range_rect->set_fill_color (ARDOUR_UI::config()->color_mod ("transport loop rect", "loop rectangle")); + transport_loop_range_rect->set_outline_color (ARDOUR_UI::config()->color ("transport loop rect")); - transport_punchin_line->set_outline_color (ARDOUR_UI::config()->get_canvasvar_PunchLine()); - transport_punchout_line->set_outline_color (ARDOUR_UI::config()->get_canvasvar_PunchLine()); + transport_punch_range_rect->set_fill_color (ARDOUR_UI::config()->color ("transport punch rect")); + transport_punch_range_rect->set_outline_color (ARDOUR_UI::config()->color ("transport punch rect")); - zoom_rect->set_fill_color (ARDOUR_UI::config()->get_canvasvar_ZoomRect()); - zoom_rect->set_outline_color (ARDOUR_UI::config()->get_canvasvar_ZoomRect()); + transport_punchin_line->set_outline_color (ARDOUR_UI::config()->color ("punch line")); + transport_punchout_line->set_outline_color (ARDOUR_UI::config()->color ("punch line")); - rubberband_rect->set_outline_color (ARDOUR_UI::config()->get_canvasvar_RubberBandRect()); - rubberband_rect->set_fill_color ((guint32) ARDOUR_UI::config()->get_canvasvar_RubberBandRect()); + rubberband_rect->set_outline_color (ARDOUR_UI::config()->color ("rubber band rect")); + rubberband_rect->set_fill_color (ARDOUR_UI::config()->color_mod ("rubber band rect", "selection rect")); - location_marker_color = ARDOUR_UI::config()->get_canvasvar_LocationMarker(); - location_range_color = ARDOUR_UI::config()->get_canvasvar_LocationRange(); - location_cd_marker_color = ARDOUR_UI::config()->get_canvasvar_LocationCDMarker(); - location_loop_color = ARDOUR_UI::config()->get_canvasvar_LocationLoop(); - location_punch_color = ARDOUR_UI::config()->get_canvasvar_LocationPunch(); + location_marker_color = ARDOUR_UI::config()->color ("location marker"); + location_range_color = ARDOUR_UI::config()->color ("location range"); + location_cd_marker_color = ARDOUR_UI::config()->color ("location cd marker"); + location_loop_color = ARDOUR_UI::config()->color ("location loop"); + location_punch_color = ARDOUR_UI::config()->color ("location punch"); refresh_location_display (); + + /* redraw the whole thing */ + _track_canvas->queue_draw (); + /* redisplay_tempo (true); @@ -877,44 +948,15 @@ Editor::horizontal_position () const return sample_to_pixel (leftmost_frame); } -void -Editor::set_canvas_cursor (Gdk::Cursor* cursor, bool save) -{ - /* do not allow cursors to change during a drag */ - - if (_drags->active()) { - return; - } - - if (save) { - current_canvas_cursor = cursor; - } - - Glib::RefPtr win = _track_canvas->get_window(); - - if (win) { - _track_canvas->get_window()->set_cursor (*cursor); - } -} - bool Editor::track_canvas_key_press (GdkEventKey*) { - /* XXX: event does not report the modifier key pressed down, AFAICS, so use the Keyboard object instead */ - if (mouse_mode == Editing::MouseZoom && Keyboard::the_keyboard().key_is_down (GDK_Control_L)) { - set_canvas_cursor (_cursors->zoom_out, true); - } - return false; } bool Editor::track_canvas_key_release (GdkEventKey*) { - if (mouse_mode == Editing::MouseZoom && !Keyboard::the_keyboard().key_is_down (GDK_Control_L)) { - set_canvas_cursor (_cursors->zoom_in, true); - } - return false; } @@ -942,3 +984,345 @@ Editor::get_track_canvas() const { return _track_canvas_viewport; } + +void +Editor::set_canvas_cursor (Gdk::Cursor* cursor, bool save) +{ + if (save) { + current_canvas_cursor = cursor; + } + + Glib::RefPtr win = _track_canvas->get_window(); + + if (win && cursor) { + win->set_cursor (*cursor); + } +} + +void +Editor::push_canvas_cursor (Gdk::Cursor* cursor) +{ + if (cursor) { + _cursor_stack.push (cursor); + set_canvas_cursor (cursor, false); + } +} + +void +Editor::pop_canvas_cursor () +{ + if (!_cursor_stack.empty()) { + Gdk::Cursor* cursor = _cursor_stack.top (); + _cursor_stack.pop (); + set_canvas_cursor (cursor, false); + } +} + +Gdk::Cursor* +Editor::which_grabber_cursor () const +{ + Gdk::Cursor* c = _cursors->grabber; + + switch (_edit_point) { + case EditAtMouse: + c = _cursors->grabber_edit_point; + break; + default: + boost::shared_ptr m = _movable.lock(); + if (m && m->locked()) { + c = _cursors->speaker; + } + break; + } + + return c; +} + +Gdk::Cursor* +Editor::which_trim_cursor (bool left) const +{ + if (!entered_regionview) { + return 0; + } + + Trimmable::CanTrim ct = entered_regionview->region()->can_trim (); + + if (left) { + + if (ct & Trimmable::FrontTrimEarlier) { + return _cursors->left_side_trim; + } else { + return _cursors->left_side_trim_right_only; + } + } else { + if (ct & Trimmable::EndTrimLater) { + return _cursors->right_side_trim; + } else { + return _cursors->right_side_trim_left_only; + } + } +} + +Gdk::Cursor* +Editor::which_mode_cursor () const +{ + Gdk::Cursor* mode_cursor = 0; + + switch (mouse_mode) { + case MouseRange: + mode_cursor = _cursors->selector; + break; + + case MouseCut: + mode_cursor = _cursors->scissors; + break; + + case MouseObject: + case MouseContent: + /* don't use mode cursor, pick a grabber cursor based on the item */ + break; + + case MouseDraw: + mode_cursor = _cursors->midi_pencil; + break; + + case MouseTimeFX: + mode_cursor = _cursors->time_fx; // just use playhead + break; + + case MouseAudition: + mode_cursor = _cursors->speaker; + break; + } + + /* up-down cursor as a cue that automation can be dragged up and down when in join object/range mode */ + if (get_smart_mode()) { + + double x, y; + get_pointer_position (x, y); + + if (x >= 0 && y >= 0) { + + vector items; + + /* Note how we choose a specific scroll group to get + * items from. This could be problematic. + */ + + hv_scroll_group->add_items_at_point (ArdourCanvas::Duple (x,y), items); + + // first item will be the upper most + + if (!items.empty()) { + const ArdourCanvas::Item* i = items.front(); + + if (i && i->parent() && i->parent()->get_data (X_("timeselection"))) { + pair tvp = trackview_by_y_position (_last_motion_y); + if (dynamic_cast (tvp.first)) { + mode_cursor = _cursors->up_down; + } + } + } + } + } + + return mode_cursor; +} + +Gdk::Cursor* +Editor::which_track_cursor () const +{ + Gdk::Cursor* cursor = 0; + + switch (_join_object_range_state) { + case JOIN_OBJECT_RANGE_NONE: + case JOIN_OBJECT_RANGE_OBJECT: + cursor = which_grabber_cursor (); + break; + case JOIN_OBJECT_RANGE_RANGE: + cursor = _cursors->selector; + break; + } + + return cursor; +} + +bool +Editor::reset_canvas_cursor () +{ + if (!is_drawable()) { + return false; + } + + Gdk::Cursor* cursor = which_mode_cursor (); + + if (!cursor) { + cursor = which_grabber_cursor (); + } + + if (cursor) { + set_canvas_cursor (cursor); + return true; + } + + return false; +} + +void +Editor::choose_canvas_cursor_on_entry (GdkEventCrossing* /*event*/, ItemType type) +{ + Gdk::Cursor* cursor = 0; + + if (_drags->active()) { + return; + } + + cursor = which_mode_cursor (); + + if (mouse_mode == MouseObject || get_smart_mode ()) { + + /* find correct cursor to use in object/smart mode */ + + switch (type) { + case RegionItem: + case RegionViewNameHighlight: + case RegionViewName: + case WaveItem: + case StreamItem: + case AutomationTrackItem: + cursor = which_track_cursor (); + break; + case PlayheadCursorItem: + switch (_edit_point) { + case EditAtMouse: + cursor = _cursors->grabber_edit_point; + break; + default: + cursor = _cursors->grabber; + break; + } + break; + case SelectionItem: + cursor = _cursors->selector; + break; + case ControlPointItem: + cursor = _cursors->fader; + break; + case GainLineItem: + cursor = which_track_cursor (); + break; + case AutomationLineItem: + cursor = _cursors->cross_hair; + break; + case StartSelectionTrimItem: + cursor = _cursors->left_side_trim; + break; + case EndSelectionTrimItem: + cursor = _cursors->right_side_trim; + break; + case FadeInItem: + cursor = _cursors->fade_in; + break; + case FadeInHandleItem: + cursor = _cursors->fade_in; + break; + case FadeInTrimHandleItem: + cursor = _cursors->fade_in; + break; + case FadeOutItem: + cursor = _cursors->fade_out; + break; + case FadeOutHandleItem: + cursor = _cursors->fade_out; + break; + case FadeOutTrimHandleItem: + cursor = _cursors->fade_out; + break; + case NoteItem: + cursor = which_grabber_cursor(); + break; + case FeatureLineItem: + cursor = _cursors->cross_hair; + break; + case LeftFrameHandle: + if ( effective_mouse_mode() == MouseObject ) // (smart mode): if the user is in the top half, override the trim cursor, since they are in the range zone + cursor = which_trim_cursor (true); //alternatively, one could argue that we _should_ allow trims here, and disallow range selection + break; + case RightFrameHandle: + if ( effective_mouse_mode() == MouseObject ) //see above + cursor = which_trim_cursor (false); + break; + case StartCrossFadeItem: + cursor = _cursors->fade_in; + break; + case EndCrossFadeItem: + cursor = _cursors->fade_out; + break; + case CrossfadeViewItem: + cursor = _cursors->cross_hair; + break; + default: + break; + } + + } else if (mouse_mode == MouseDraw) { + + /* ControlPointItem is not really specific to region gain mode + but it is the same cursor so don't worry about this for now. + The result is that we'll see the fader cursor if we enter + non-region-gain-line control points while in MouseDraw + mode, even though we can't edit them in this mode. + */ + + switch (type) { + case GainLineItem: + case ControlPointItem: + cursor = _cursors->fader; + break; + default: + break; + } + } + + switch (type) { + /* These items use the timebar cursor at all times */ + case TimecodeRulerItem: + case MinsecRulerItem: + case BBTRulerItem: + case SamplesRulerItem: + cursor = _cursors->timebar; + break; + + /* These items use the grabber cursor at all times */ + case MeterMarkerItem: + case TempoMarkerItem: + case MeterBarItem: + case TempoBarItem: + case MarkerItem: + case MarkerBarItem: + case RangeMarkerBarItem: + case CdMarkerBarItem: + case VideoBarItem: + case TransportMarkerBarItem: + case DropZoneItem: + cursor = which_grabber_cursor(); + break; + + default: + break; + } + + if (cursor) { + set_canvas_cursor (cursor, true); + } +} + +double +Editor::trackviews_height() const +{ + if (!_trackview_group) { + return 0; + } + + return _visible_canvas_height - _trackview_group->canvas_origin().y; +}