gtk2_ardour/editor_canvas.cc

   1 /*
   2     Copyright (C) 2005 Paul Davis
   3
   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.
   8
   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.
  13
  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.
  17
  18 */
  19
  20 #ifdef WAF_BUILD
  21 #include "gtk2ardour-config.h"
  22 #endif
  23
  24 #include <jack/types.h>
  25
  26 #include "gtkmm2ext/utils.h"
  27
  28 #include "ardour/profile.h"
  29 #include "ardour/rc_configuration.h"
  30 #include "ardour/smf_source.h"
  31
  32 #include "canvas/canvas.h"
  33 #include "canvas/rectangle.h"
  34 #include "canvas/pixbuf.h"
  35 #include "canvas/text.h"
  36 #include "canvas/debug.h"
  37
  38 #include "ardour_ui.h"
  39 #include "editor.h"
  40 #include "global_signals.h"
  41 #include "editing.h"
  42 #include "rgb_macros.h"
  43 #include "utils.h"
  44 #include "audio_time_axis.h"
  45 #include "editor_drag.h"
  46 #include "region_view.h"
  47 #include "editor_group_tabs.h"
  48 #include "editor_summary.h"
  49 #include "video_timeline.h"
  50 #include "keyboard.h"
  51 #include "editor_cursors.h"
  52 #include "mouse_cursors.h"
  53 #include "verbose_cursor.h"
  54
  55 #include "i18n.h"
  56
  57 using namespace std;
  58 using namespace ARDOUR;
  59 using namespace PBD;
  60 using namespace Gtk;
  61 using namespace Glib;
  62 using namespace Gtkmm2ext;
  63 using namespace Editing;
  64
  65 /* XXX this is a hack. it ought to be the maximum value of an framepos_t */
  66
  67 const double max_canvas_coordinate = (double) JACK_MAX_FRAMES;
  68
  69 void
  70 Editor::initialize_canvas ()
  71 {
  72         _track_canvas_viewport = new ArdourCanvas::GtkCanvasViewport (horizontal_adjustment, vertical_adjustment);
  73         _track_canvas = _track_canvas_viewport->canvas ();
  74
  75         _time_bars_canvas_viewport = new ArdourCanvas::GtkCanvasViewport (horizontal_adjustment, unused_adjustment);
  76         _time_bars_canvas = _time_bars_canvas_viewport->canvas ();
  77
  78         _verbose_cursor = new VerboseCursor (this);
  79
  80         /* on the bottom, an image */
  81
  82         if (Profile->get_sae()) {
  83                 Image img (::get_icon (X_("saelogo")));
  84                 // logo_item = new ArdourCanvas::Pixbuf (_track_canvas->root(), 0.0, 0.0, img.get_pixbuf());
  85                 // logo_item->property_height_in_pixels() = true;
  86                 // logo_item->property_width_in_pixels() = true;
  87                 // logo_item->property_height_set() = true;
  88                 // logo_item->property_width_set() = true;
  89                 logo_item->show ();
  90         }
  91
  92         /*a group to hold global rects like punch/loop indicators */
  93         global_rect_group = new ArdourCanvas::Group (_track_canvas->root());
  94         CANVAS_DEBUG_NAME (global_rect_group, "global rect group");
  95
  96         transport_loop_range_rect = new ArdourCanvas::Rectangle (global_rect_group, ArdourCanvas::Rect (0.0, 0.0, 0.0, ArdourCanvas::COORD_MAX));
  97         CANVAS_DEBUG_NAME (transport_loop_range_rect, "loop rect");
  98         transport_loop_range_rect->hide();
  99
 100         transport_punch_range_rect = new ArdourCanvas::Rectangle (global_rect_group, ArdourCanvas::Rect (0.0, 0.0, 0.0, ArdourCanvas::COORD_MAX));
 101         CANVAS_DEBUG_NAME (transport_punch_range_rect, "punch rect");
 102         transport_punch_range_rect->hide();
 103
 104         /*a group to hold time (measure) lines */
 105         time_line_group = new ArdourCanvas::Group (_track_canvas->root());
 106         CANVAS_DEBUG_NAME (time_line_group, "time line group");
 107
 108         _trackview_group = new ArdourCanvas::Group (_track_canvas->root());
 109         CANVAS_DEBUG_NAME (_trackview_group, "Canvas TrackViews");
 110         _region_motion_group = new ArdourCanvas::Group (_trackview_group);
 111         CANVAS_DEBUG_NAME (_region_motion_group, "Canvas Region Motion");
 112
 113         meter_bar_group = new ArdourCanvas::Group (_time_bars_canvas->root ());
 114         meter_bar = new ArdourCanvas::Rectangle (meter_bar_group, ArdourCanvas::Rect (0.0, 0.0, ArdourCanvas::COORD_MAX, timebar_height));
 115         CANVAS_DEBUG_NAME (meter_bar, "meter Bar");
 116         meter_bar->set_outline_what (ArdourCanvas::Rectangle::BOTTOM);
 117
 118         tempo_bar_group = new ArdourCanvas::Group (_time_bars_canvas->root ());
 119         tempo_bar = new ArdourCanvas::Rectangle (tempo_bar_group, ArdourCanvas::Rect (0.0, 0.0, ArdourCanvas::COORD_MAX, timebar_height));
 120         CANVAS_DEBUG_NAME (tempo_bar, "Tempo  Bar");
 121         tempo_bar->set_outline_what (ArdourCanvas::Rectangle::BOTTOM);
 122
 123         range_marker_bar_group = new ArdourCanvas::Group (_time_bars_canvas->root ());
 124         range_marker_bar = new ArdourCanvas::Rectangle (range_marker_bar_group, ArdourCanvas::Rect (0.0, 0.0, ArdourCanvas::COORD_MAX, timebar_height));
 125         CANVAS_DEBUG_NAME (range_marker_bar, "Range Marker Bar");
 126         range_marker_bar->set_outline_what (ArdourCanvas::Rectangle::BOTTOM);
 127
 128         transport_marker_bar_group = new ArdourCanvas::Group (_time_bars_canvas->root ());
 129         transport_marker_bar = new ArdourCanvas::Rectangle (transport_marker_bar_group, ArdourCanvas::Rect (0.0, 0.0, ArdourCanvas::COORD_MAX, timebar_height));
 130         CANVAS_DEBUG_NAME (transport_marker_bar, "transport Marker Bar");
 131         transport_marker_bar->set_outline_what (ArdourCanvas::Rectangle::BOTTOM);
 132
 133         marker_bar_group = new ArdourCanvas::Group (_time_bars_canvas->root ());
 134         marker_bar = new ArdourCanvas::Rectangle (marker_bar_group, ArdourCanvas::Rect (0.0, 0.0, ArdourCanvas::COORD_MAX, timebar_height));
 135         CANVAS_DEBUG_NAME (marker_bar, "Marker Bar");
 136         marker_bar->set_outline_what (ArdourCanvas::Rectangle::BOTTOM);
 137
 138         cd_marker_bar_group = new ArdourCanvas::Group (_time_bars_canvas->root ());
 139         cd_marker_bar = new ArdourCanvas::Rectangle (cd_marker_bar_group, ArdourCanvas::Rect (0.0, 0.0, ArdourCanvas::COORD_MAX, timebar_height));
 140         CANVAS_DEBUG_NAME (cd_marker_bar, "CD Marker Bar");
 141         cd_marker_bar->set_outline_what (ArdourCanvas::Rectangle::BOTTOM);
 142
 143         _time_markers_group = new ArdourCanvas::Group (_time_bars_canvas->root());
 144
 145         meter_group = new ArdourCanvas::Group (_time_markers_group, ArdourCanvas::Duple (0.0, timebar_height * 5.0));
 146         CANVAS_DEBUG_NAME (meter_group, "meter group");
 147         tempo_group = new ArdourCanvas::Group (_time_markers_group, ArdourCanvas::Duple (0.0, timebar_height * 4.0));
 148         CANVAS_DEBUG_NAME (tempo_group, "tempo group");
 149         range_marker_group = new ArdourCanvas::Group (_time_markers_group, ArdourCanvas::Duple (0.0, timebar_height * 3.0));
 150         CANVAS_DEBUG_NAME (range_marker_group, "range marker group");
 151         transport_marker_group = new ArdourCanvas::Group (_time_markers_group, ArdourCanvas::Duple (0.0, timebar_height * 2.0));
 152         CANVAS_DEBUG_NAME (transport_marker_group, "transport marker group");
 153         marker_group = new ArdourCanvas::Group (_time_markers_group, ArdourCanvas::Duple (0.0, timebar_height));
 154         CANVAS_DEBUG_NAME (marker_group, "marker group");
 155         cd_marker_group = new ArdourCanvas::Group (_time_markers_group, ArdourCanvas::Duple (0.0, 0.0));
 156         CANVAS_DEBUG_NAME (cd_marker_group, "cd marker group");
 157         videotl_group = new ArdourCanvas::Group (_time_markers_group, ArdourCanvas::Duple(0.0, 0.0));
 158         CANVAS_DEBUG_NAME (videotl_group, "videotl group");
 159
 160         ARDOUR_UI::instance()->video_timeline = new VideoTimeLine(this, videotl_group, (timebar_height * videotl_bar_height));
 161
 162         cd_marker_bar_drag_rect = new ArdourCanvas::Rectangle (cd_marker_group, ArdourCanvas::Rect (0.0, 0.0, 100, timebar_height));
 163         CANVAS_DEBUG_NAME (cd_marker_bar_drag_rect, "cd marker drag");
 164         cd_marker_bar_drag_rect->set_outline (false);
 165         cd_marker_bar_drag_rect->hide ();
 166
 167         range_bar_drag_rect = new ArdourCanvas::Rectangle (range_marker_group, ArdourCanvas::Rect (0.0, 0.0, 100, timebar_height));
 168         CANVAS_DEBUG_NAME (range_bar_drag_rect, "range drag");
 169         range_bar_drag_rect->set_outline (false);
 170         range_bar_drag_rect->hide ();
 171
 172         transport_bar_drag_rect = new ArdourCanvas::Rectangle (transport_marker_group, ArdourCanvas::Rect (0.0, 0.0, 100, timebar_height));
 173         CANVAS_DEBUG_NAME (transport_bar_drag_rect, "transport drag");
 174         transport_bar_drag_rect->set_outline (false);
 175         transport_bar_drag_rect->hide ();
 176
 177         transport_punchin_line = new ArdourCanvas::Line (_track_canvas->root());
 178         transport_punchin_line->set_x0 (0);
 179         transport_punchin_line->set_y0 (0);
 180         transport_punchin_line->set_x1 (0);
 181         transport_punchin_line->set_y1 (ArdourCanvas::COORD_MAX);
 182         transport_punchin_line->hide ();
 183
 184         transport_punchout_line  = new ArdourCanvas::Line (_track_canvas->root());
 185         transport_punchout_line->set_x0 (0);
 186         transport_punchout_line->set_y0 (0);
 187         transport_punchout_line->set_x1 (0);
 188         transport_punchout_line->set_y1 (ArdourCanvas::COORD_MAX);
 189         transport_punchout_line->hide();
 190
 191         // used to show zoom mode active zooming
 192         zoom_rect = new ArdourCanvas::Rectangle (_track_canvas->root(), ArdourCanvas::Rect (0.0, 0.0, 0.0, 0.0));
 193         zoom_rect->hide();
 194
 195         zoom_rect->Event.connect (sigc::bind (sigc::mem_fun (*this, &Editor::canvas_zoom_rect_event), (ArdourCanvas::Item*) 0));
 196
 197         // used as rubberband rect
 198         rubberband_rect = new ArdourCanvas::Rectangle (_trackview_group, ArdourCanvas::Rect (0.0, 0.0, 0.0, 0.0));
 199
 200         rubberband_rect->hide();
 201
 202         tempo_bar->Event.connect (sigc::bind (sigc::mem_fun (*this, &Editor::canvas_tempo_bar_event), tempo_bar));
 203         meter_bar->Event.connect (sigc::bind (sigc::mem_fun (*this, &Editor::canvas_meter_bar_event), meter_bar));
 204         marker_bar->Event.connect (sigc::bind (sigc::mem_fun (*this, &Editor::canvas_marker_bar_event), marker_bar));
 205         cd_marker_bar->Event.connect (sigc::bind (sigc::mem_fun (*this, &Editor::canvas_cd_marker_bar_event), cd_marker_bar));
 206         videotl_group->Event.connect (sigc::bind (sigc::mem_fun (*this, &Editor::canvas_videotl_bar_event), videotl_group));
 207         range_marker_bar->Event.connect (sigc::bind (sigc::mem_fun (*this, &Editor::canvas_range_marker_bar_event), range_marker_bar));
 208         transport_marker_bar->Event.connect (sigc::bind (sigc::mem_fun (*this, &Editor::canvas_transport_marker_bar_event), transport_marker_bar));
 209
 210         playhead_cursor = new EditorCursor (*this, &Editor::canvas_playhead_cursor_event);
 211
 212         if (logo_item) {
 213                 logo_item->lower_to_bottom ();
 214         }
 215         /* need to handle 4 specific types of events as catch-alls */
 216
 217         _track_canvas->signal_scroll_event().connect (sigc::mem_fun (*this, &Editor::track_canvas_scroll_event));
 218         _track_canvas->signal_motion_notify_event().connect (sigc::mem_fun (*this, &Editor::track_canvas_motion_notify_event));
 219         _track_canvas->signal_button_press_event().connect (sigc::mem_fun (*this, &Editor::track_canvas_button_press_event));
 220         _track_canvas->signal_button_release_event().connect (sigc::mem_fun (*this, &Editor::track_canvas_button_release_event));
 221         _track_canvas->signal_drag_motion().connect (sigc::mem_fun (*this, &Editor::track_canvas_drag_motion));
 222         _track_canvas->signal_key_press_event().connect (sigc::mem_fun (*this, &Editor::track_canvas_key_press));
 223         _track_canvas->signal_key_release_event().connect (sigc::mem_fun (*this, &Editor::track_canvas_key_release));
 224
 225         _track_canvas->set_name ("EditorMainCanvas");
 226         _track_canvas->add_events (Gdk::POINTER_MOTION_HINT_MASK | Gdk::SCROLL_MASK | Gdk::KEY_PRESS_MASK | Gdk::KEY_RELEASE_MASK);
 227         _track_canvas->signal_leave_notify_event().connect (sigc::mem_fun(*this, &Editor::left_track_canvas), false);
 228         _track_canvas->signal_enter_notify_event().connect (sigc::mem_fun(*this, &Editor::entered_track_canvas), false);
 229         _track_canvas->set_flags (CAN_FOCUS);
 230
 231         /* set up drag-n-drop */
 232
 233         vector<TargetEntry> target_table;
 234
 235         // Drag-N-Drop from the region list can generate this target
 236         target_table.push_back (TargetEntry ("regions"));
 237
 238         target_table.push_back (TargetEntry ("text/plain"));
 239         target_table.push_back (TargetEntry ("text/uri-list"));
 240         target_table.push_back (TargetEntry ("application/x-rootwin-drop"));
 241
 242         _track_canvas->drag_dest_set (target_table);
 243         _track_canvas->signal_drag_data_received().connect (sigc::mem_fun(*this, &Editor::track_canvas_drag_data_received));
 244
 245         _track_canvas_viewport->signal_size_allocate().connect (sigc::mem_fun(*this, &Editor::track_canvas_viewport_allocate));
 246
 247         ColorsChanged.connect (sigc::mem_fun (*this, &Editor::color_handler));
 248         color_handler();
 249
 250 }
 251
 252 void
 253 Editor::track_canvas_viewport_allocate (Gtk::Allocation alloc)
 254 {
 255         _canvas_viewport_allocation = alloc;
 256         track_canvas_viewport_size_allocated ();
 257 }
 258
 259 bool
 260 Editor::track_canvas_viewport_size_allocated ()
 261 {
 262         bool height_changed = _visible_canvas_height != _canvas_viewport_allocation.get_height();
 263
 264         _visible_canvas_width  = _canvas_viewport_allocation.get_width ();
 265         _visible_canvas_height = _canvas_viewport_allocation.get_height ();
 266
 267         // SHOWTRACKS
 268
 269         if (height_changed) {
 270
 271                 for (LocationMarkerMap::iterator i = location_markers.begin(); i != location_markers.end(); ++i) {
 272                         i->second->canvas_height_set (_visible_canvas_height);
 273                 }
 274
 275                 vertical_adjustment.set_page_size (_visible_canvas_height);
 276                 if ((vertical_adjustment.get_value() + _visible_canvas_height) >= vertical_adjustment.get_upper()) {
 277                         /*
 278                            We're increasing the size of the canvas while the bottom is visible.
 279                            We scroll down to keep in step with the controls layout.
 280                         */
 281                         vertical_adjustment.set_value (_full_canvas_height - _visible_canvas_height);
 282                 }
 283         }
 284
 285         update_fixed_rulers();
 286         redisplay_tempo (false);
 287         _summary->set_overlays_dirty ();
 288
 289         return false;
 290 }
 291
 292 void
 293 Editor::reset_controls_layout_width ()
 294 {
 295         GtkRequisition req;
 296         gint w;
 297
 298         edit_controls_vbox.size_request (req);
 299         w = req.width;
 300
 301         if (_group_tabs->is_mapped()) {
 302                 _group_tabs->size_request (req);
 303                 w += req.width;
 304         }
 305
 306         /* the controls layout has no horizontal scrolling, its visible
 307            width is always equal to the total width of its contents.
 308         */
 309
 310         controls_layout.property_width() = w;
 311         controls_layout.property_width_request() = w;
 312 }
 313
 314 void
 315 Editor::reset_controls_layout_height (int32_t h)
 316 {
 317         /* set the height of the scrollable area (i.e. the sum of all contained widgets)
 318          */
 319
 320         controls_layout.property_height() = h;
 321
 322         /* size request is set elsewhere, see ::track_canvas_allocate() */
 323 }
 324
 325 bool
 326 Editor::track_canvas_map_handler (GdkEventAny* /*ev*/)
 327 {
 328         if (current_canvas_cursor) {
 329                 set_canvas_cursor (current_canvas_cursor);
 330         }
 331         return false;
 332 }
 333
 334 /** This is called when something is dropped onto the track canvas */
 335 void
 336 Editor::track_canvas_drag_data_received (const RefPtr<Gdk::DragContext>& context,
 337                                          int x, int y,
 338                                          const SelectionData& data,
 339                                          guint info, guint time)
 340 {
 341         if (data.get_target() == "regions") {
 342                 drop_regions (context, x, y, data, info, time);
 343         } else {
 344                 drop_paths (context, x, y, data, info, time);
 345         }
 346 }
 347
 348 bool
 349 Editor::idle_drop_paths (vector<string> paths, framepos_t frame, double ypos, bool copy)
 350 {
 351         drop_paths_part_two (paths, frame, ypos, copy);
 352         return false;
 353 }
 354
 355 void
 356 Editor::drop_paths_part_two (const vector<string>& paths, framepos_t frame, double ypos, bool copy)
 357 {
 358         RouteTimeAxisView* tv;
 359
 360         /* MIDI files must always be imported, because we consider them
 361          * writable. So split paths into two vectors, and follow the import
 362          * path on the MIDI part.
 363          */
 364
 365         vector<string> midi_paths;
 366         vector<string> audio_paths;
 367
 368         for (vector<string>::const_iterator i = paths.begin(); i != paths.end(); ++i) {
 369                 if (SMFSource::safe_midi_file_extension (*i)) {
 370                         midi_paths.push_back (*i);
 371                 } else {
 372                         audio_paths.push_back (*i);
 373                 }
 374         }
 375
 376
 377         std::pair<TimeAxisView*, int> const tvp = trackview_by_y_position (ypos);
 378         if (tvp.first == 0) {
 379
 380                 /* drop onto canvas background: create new tracks */
 381
 382                 frame = 0;
 383
 384                 do_import (midi_paths, Editing::ImportDistinctFiles, ImportAsTrack, SrcBest, frame);
 385
 386                 if (Profile->get_sae() || Config->get_only_copy_imported_files() || copy) {
 387                         do_import (audio_paths, Editing::ImportDistinctFiles, Editing::ImportAsTrack, SrcBest, frame);
 388                 } else {
 389                         do_embed (audio_paths, Editing::ImportDistinctFiles, ImportAsTrack, frame);
 390                 }
 391
 392         } else if ((tv = dynamic_cast<RouteTimeAxisView*> (tvp.first)) != 0) {
 393
 394                 /* check that its a track, not a bus */
 395
 396                 if (tv->track()) {
 397                         /* select the track, then embed/import */
 398                         selection->set (tv);
 399
 400                         do_import (midi_paths, Editing::ImportSerializeFiles, ImportToTrack, SrcBest, frame);
 401
 402                         if (Profile->get_sae() || Config->get_only_copy_imported_files() || copy) {
 403                                 do_import (audio_paths, Editing::ImportSerializeFiles, Editing::ImportToTrack, SrcBest, frame);
 404                         } else {
 405                                 do_embed (audio_paths, Editing::ImportSerializeFiles, ImportToTrack, frame);
 406                         }
 407                 }
 408         }
 409 }
 410
 411 void
 412 Editor::drop_paths (const RefPtr<Gdk::DragContext>& context,
 413                     int x, int y,
 414                     const SelectionData& data,
 415                     guint info, guint time)
 416 {
 417         vector<string> paths;
 418         GdkEvent ev;
 419         framepos_t frame;
 420         double cy;
 421
 422         if (convert_drop_to_paths (paths, context, x, y, data, info, time) == 0) {
 423
 424                 /* D-n-D coordinates are window-relative, so convert to "world" coordinates
 425                  */
 426
 427                 ev.type = GDK_BUTTON_RELEASE;
 428                 ev.button.x = x;
 429                 ev.button.y = y;
 430
 431                 frame = window_event_frame (&ev, 0, &cy);
 432
 433                 snap_to (frame);
 434
 435                 bool copy = ((context->get_actions() & (Gdk::ACTION_COPY | Gdk::ACTION_LINK | Gdk::ACTION_MOVE)) == Gdk::ACTION_COPY);
 436 #ifdef GTKOSX
 437                 /* We are not allowed to call recursive main event loops from within
 438                    the main event loop with GTK/Quartz. Since import/embed wants
 439                    to push up a progress dialog, defer all this till we go idle.
 440                 */
 441                 Glib::signal_idle().connect (sigc::bind (sigc::mem_fun (*this, &Editor::idle_drop_paths), paths, frame, cy, copy));
 442 #else
 443                 drop_paths_part_two (paths, frame, cy, copy);
 444 #endif
 445         }
 446
 447         context->drag_finish (true, false, time);
 448 }
 449
 450 /** If the editor window is arranged such that the edge of the trackview is right up
 451  *  against the edge of the screen, autoscroll will not work very well.  In this situation,
 452  *  we start autoscrolling some distance in from the right-hand-side of the screen edge;
 453  *  this is the distance at which that happens.
 454  */
 455 int
 456 Editor::autoscroll_fudge_threshold () const
 457 {
 458         return current_page_samples() / 6;
 459 }
 460
 461 /** @param allow_horiz true to allow horizontal autoscroll, otherwise false.
 462  *
 463  *  @param allow_vert true to allow vertical autoscroll, otherwise false.
 464  *
 465  *  @param moving_left true if we are moving left, so we only want to autoscroll on the left of the canvas,
 466  *  otherwise false, so we only want to autoscroll on the right of the canvas.
 467  *
 468  *  @param moving_up true if we are moving up, so we only want to autoscroll at the top of the canvas,
 469  *  otherwise false, so we only want to autoscroll at the bottom of the canvas.
 470  */
 471 void
 472 Editor::maybe_autoscroll (bool allow_horiz, bool allow_vert, bool moving_left, bool moving_up)
 473 {
 474         if (!Config->get_autoscroll_editor ()) {
 475                 return;
 476         }
 477
 478         bool startit = false;
 479
 480         /* Work out the distance between the right hand edge of the trackview and the edge of
 481            the monitor that it is on.
 482         */
 483
 484         Glib::RefPtr<Gdk::Window> gdk_window = get_window ();
 485         Gdk::Rectangle window_rect;
 486         gdk_window->get_frame_extents (window_rect);
 487
 488         Glib::RefPtr<Gdk::Screen> screen = get_screen ();
 489         Gdk::Rectangle root_rect;
 490         screen->get_root_window()->get_frame_extents (root_rect);
 491
 492         Gtk::Allocation editor_list = _the_notebook.get_allocation ();
 493
 494         framecnt_t distance = pixel_to_sample (root_rect.get_x() + root_rect.get_width() - window_rect.get_x() - window_rect.get_width());
 495         if (_the_notebook.is_visible ()) {
 496                 distance += pixel_to_sample (editor_list.get_width());
 497         }
 498
 499         /* Note whether we're fudging the autoscroll (see autoscroll_fudge_threshold) */
 500         _autoscroll_fudging = (distance < autoscroll_fudge_threshold ());
 501
 502         /* ty is in canvas-coordinate space */
 503
 504         double const ty = _drags->current_pointer_y();
 505         ArdourCanvas::Rect visible = _track_canvas->visible_area();
 506
 507         autoscroll_y = 0;
 508         autoscroll_x = 0;
 509         if (ty < visible.y0 && moving_up && allow_vert) {
 510                 autoscroll_y = -1;
 511                 startit = true;
 512         } else if (ty > visible.y1 && !moving_up && allow_vert) {
 513                 autoscroll_y = 1;
 514                 startit = true;
 515         }
 516
 517         framepos_t rightmost_frame = leftmost_frame + current_page_samples();
 518         if (_autoscroll_fudging) {
 519                 rightmost_frame -= autoscroll_fudge_threshold ();
 520         }
 521
 522         if (_drags->current_pointer_frame() > rightmost_frame && allow_horiz) {
 523                 if (rightmost_frame < max_framepos && !moving_left) {
 524                         autoscroll_x = 1;
 525                         startit = true;
 526                 }
 527         } else if (_drags->current_pointer_frame() < leftmost_frame && allow_horiz) {
 528                 if (leftmost_frame > 0 && moving_left) {
 529                         autoscroll_x = -1;
 530                         startit = true;
 531                 }
 532         }
 533
 534         if (autoscroll_active && ((autoscroll_x != last_autoscroll_x) || (autoscroll_y != last_autoscroll_y) || (autoscroll_x == 0 && autoscroll_y == 0))) {
 535                 stop_canvas_autoscroll ();
 536         }
 537
 538         if (startit && autoscroll_timeout_tag < 0) {
 539                 start_canvas_autoscroll (autoscroll_x, autoscroll_y);
 540         }
 541
 542         last_autoscroll_x = autoscroll_x;
 543         last_autoscroll_y = autoscroll_y;
 544 }
 545
 546 gint
 547 Editor::_autoscroll_canvas (void *arg)
 548 {
 549         return ((Editor *) arg)->autoscroll_canvas ();
 550 }
 551
 552 bool
 553 Editor::autoscroll_canvas ()
 554 {
 555         framepos_t new_frame;
 556         framepos_t limit = max_framepos - current_page_samples();
 557         double new_pixel;
 558
 559         if (autoscroll_x_distance != 0) {
 560
 561                 if (autoscroll_x > 0) {
 562                         autoscroll_x_distance = (_drags->current_pointer_frame() - (leftmost_frame + current_page_samples())) / 3;
 563                         if (_autoscroll_fudging) {
 564                                 autoscroll_x_distance += autoscroll_fudge_threshold () / 3;
 565                         }
 566                 } else if (autoscroll_x < 0) {
 567                         autoscroll_x_distance = (leftmost_frame - _drags->current_pointer_frame()) / 3;
 568
 569                 }
 570         }
 571
 572         if (autoscroll_y_distance != 0) {
 573                 if (autoscroll_y > 0) {
 574                         autoscroll_y_distance = (_drags->current_pointer_y() - _visible_canvas_height) / 3;
 575                 } else if (autoscroll_y < 0) {
 576
 577                         autoscroll_y_distance = (vertical_adjustment.get_value () - _drags->current_pointer_y()) / 3;
 578                 }
 579         }
 580
 581         if (autoscroll_x < 0) {
 582                 if (leftmost_frame < autoscroll_x_distance) {
 583                         new_frame = 0;
 584                 } else {
 585                         new_frame = leftmost_frame - autoscroll_x_distance;
 586                 }
 587         } else if (autoscroll_x > 0) {
 588                 if (leftmost_frame > limit - autoscroll_x_distance) {
 589                         new_frame = limit;
 590                 } else {
 591                         new_frame = leftmost_frame + autoscroll_x_distance;
 592                 }
 593         } else {
 594                 new_frame = leftmost_frame;
 595         }
 596
 597         double vertical_pos = vertical_adjustment.get_value();
 598
 599         if (autoscroll_y < 0) {
 600
 601                 if (vertical_pos < autoscroll_y_distance) {
 602                         new_pixel = 0;
 603                 } else {
 604                         new_pixel = vertical_pos - autoscroll_y_distance;
 605                 }
 606
 607         } else if (autoscroll_y > 0) {
 608
 609                 new_pixel = min (_full_canvas_height - _visible_canvas_height, min (_full_canvas_height, (vertical_adjustment.get_value() + autoscroll_y_distance)));
 610
 611         } else {
 612                 new_pixel = vertical_pos;
 613         }
 614
 615         if ((new_frame == 0 || new_frame == limit) && (new_pixel == 0 || new_pixel == DBL_MAX)) {
 616                 /* we are done */
 617                 return false;
 618         }
 619
 620         if (new_frame != leftmost_frame) {
 621                 reset_x_origin (new_frame);
 622         }
 623
 624         if (new_pixel != vertical_pos) {
 625                 vertical_adjustment.set_value (new_pixel);
 626         }
 627
 628         /* fake an event. */
 629
 630         Glib::RefPtr<Gdk::Window> canvas_window = const_cast<Editor*>(this)->_track_canvas->get_window();
 631         gint x, y;
 632         Gdk::ModifierType mask;
 633         GdkEventMotion ev;
 634         canvas_window->get_pointer (x, y, mask);
 635         ev.type = GDK_MOTION_NOTIFY;
 636         ev.state = Gdk::BUTTON1_MASK;
 637
 638         /* the motion handler expects events in canvas coordinate space */
 639         ArdourCanvas::Duple d = _track_canvas->window_to_canvas (ArdourCanvas::Duple (x, y));
 640         ev.x = d.x;
 641         ev.y = d.y;
 642
 643         motion_handler (0, (GdkEvent*) &ev, true);
 644
 645         autoscroll_cnt++;
 646
 647         if (autoscroll_cnt == 1) {
 648
 649                 /* connect the timeout so that we get called repeatedly */
 650
 651                 autoscroll_timeout_tag = g_idle_add ( _autoscroll_canvas, this);
 652                 return false;
 653
 654         }
 655
 656         return true;
 657 }
 658
 659 void
 660 Editor::start_canvas_autoscroll (int dx, int dy)
 661 {
 662         if (!_session || autoscroll_active) {
 663                 return;
 664         }
 665
 666         stop_canvas_autoscroll ();
 667
 668         autoscroll_active = true;
 669         autoscroll_x = dx;
 670         autoscroll_y = dy;
 671         autoscroll_x_distance = (framepos_t) floor (current_page_samples()/50.0);
 672         autoscroll_y_distance = fabs ((double)dy * 5); /* pixels */
 673         autoscroll_cnt = 0;
 674
 675         /* do it right now, which will start the repeated callbacks */
 676
 677         autoscroll_canvas ();
 678 }
 679
 680 void
 681 Editor::stop_canvas_autoscroll ()
 682 {
 683         if (autoscroll_timeout_tag >= 0) {
 684                 g_source_remove (autoscroll_timeout_tag);
 685                 autoscroll_timeout_tag = -1;
 686         }
 687
 688         autoscroll_active = false;
 689 }
 690
 691 bool
 692 Editor::left_track_canvas (GdkEventCrossing */*ev*/)
 693 {
 694         DropDownKeys ();
 695         within_track_canvas = false;
 696         set_entered_track (0);
 697         set_entered_regionview (0);
 698         reset_canvas_action_sensitivity (false);
 699         return false;
 700 }
 701
 702 bool
 703 Editor::entered_track_canvas (GdkEventCrossing */*ev*/)
 704 {
 705         within_track_canvas = true;
 706         reset_canvas_action_sensitivity (true);
 707         return FALSE;
 708 }
 709
 710 void
 711 Editor::ensure_time_axis_view_is_visible (const TimeAxisView& tav)
 712 {
 713         double begin = tav.y_position();
 714
 715         double v = vertical_adjustment.get_value ();
 716
 717         if (begin < v || begin + tav.current_height() > v + _visible_canvas_height) {
 718                 /* try to put the TimeAxisView roughly central */
 719                 if (begin >= _visible_canvas_height/2.0) {
 720                         begin -= _visible_canvas_height/2.0;
 721                 }
 722                 vertical_adjustment.set_value (begin);
 723         }
 724 }
 725
 726 /** Called when the main vertical_adjustment has changed */
 727 void
 728 Editor::tie_vertical_scrolling ()
 729 {
 730         if (pending_visual_change.idle_handler_id < 0) {
 731                 _summary->set_overlays_dirty ();
 732         }
 733 }
 734
 735 void
 736 Editor::set_horizontal_position (double p)
 737 {
 738         horizontal_adjustment.set_value (p);
 739
 740         leftmost_frame = (framepos_t) floor (p * samples_per_pixel);
 741
 742         update_fixed_rulers ();
 743         redisplay_tempo (true);
 744
 745         if (pending_visual_change.idle_handler_id < 0) {
 746                 _summary->set_overlays_dirty ();
 747         }
 748
 749         update_video_timeline();
 750
 751         HorizontalPositionChanged (); /* EMIT SIGNAL */
 752 }
 753
 754 void
 755 Editor::color_handler()
 756 {
 757         playhead_cursor->set_color (ARDOUR_UI::config()->get_canvasvar_PlayHead());
 758         _verbose_cursor->set_color (ARDOUR_UI::config()->get_canvasvar_VerboseCanvasCursor());
 759
 760         meter_bar->set_fill_color (ARDOUR_UI::config()->get_canvasvar_MeterBar());
 761         meter_bar->set_outline_color (ARDOUR_UI::config()->get_canvasvar_MarkerBarSeparator());
 762
 763         tempo_bar->set_fill_color (ARDOUR_UI::config()->get_canvasvar_TempoBar());
 764         tempo_bar->set_outline_color (ARDOUR_UI::config()->get_canvasvar_MarkerBarSeparator());
 765
 766         marker_bar->set_fill_color (ARDOUR_UI::config()->get_canvasvar_MarkerBar());
 767         marker_bar->set_outline_color (ARDOUR_UI::config()->get_canvasvar_MarkerBarSeparator());
 768
 769         cd_marker_bar->set_fill_color (ARDOUR_UI::config()->get_canvasvar_CDMarkerBar());
 770         cd_marker_bar->set_outline_color (ARDOUR_UI::config()->get_canvasvar_MarkerBarSeparator());
 771
 772         range_marker_bar->set_fill_color (ARDOUR_UI::config()->get_canvasvar_RangeMarkerBar());
 773         range_marker_bar->set_outline_color (ARDOUR_UI::config()->get_canvasvar_MarkerBarSeparator());
 774
 775         transport_marker_bar->set_fill_color (ARDOUR_UI::config()->get_canvasvar_TransportMarkerBar());
 776         transport_marker_bar->set_outline_color (ARDOUR_UI::config()->get_canvasvar_MarkerBarSeparator());
 777
 778         cd_marker_bar_drag_rect->set_fill_color (ARDOUR_UI::config()->get_canvasvar_RangeDragBarRect());
 779         cd_marker_bar_drag_rect->set_outline_color (ARDOUR_UI::config()->get_canvasvar_RangeDragBarRect());
 780
 781         range_bar_drag_rect->set_fill_color (ARDOUR_UI::config()->get_canvasvar_RangeDragBarRect());
 782         range_bar_drag_rect->set_outline_color (ARDOUR_UI::config()->get_canvasvar_RangeDragBarRect());
 783
 784         transport_bar_drag_rect->set_fill_color (ARDOUR_UI::config()->get_canvasvar_TransportDragRect());
 785         transport_bar_drag_rect->set_outline_color (ARDOUR_UI::config()->get_canvasvar_TransportDragRect());
 786
 787         transport_loop_range_rect->set_fill_color (ARDOUR_UI::config()->get_canvasvar_TransportLoopRect());
 788         transport_loop_range_rect->set_outline_color (ARDOUR_UI::config()->get_canvasvar_TransportLoopRect());
 789
 790         transport_punch_range_rect->set_fill_color (ARDOUR_UI::config()->get_canvasvar_TransportPunchRect());
 791         transport_punch_range_rect->set_outline_color (ARDOUR_UI::config()->get_canvasvar_TransportPunchRect());
 792
 793         transport_punchin_line->set_outline_color (ARDOUR_UI::config()->get_canvasvar_PunchLine());
 794         transport_punchout_line->set_outline_color (ARDOUR_UI::config()->get_canvasvar_PunchLine());
 795
 796         zoom_rect->set_fill_color (ARDOUR_UI::config()->get_canvasvar_ZoomRect());
 797         zoom_rect->set_outline_color (ARDOUR_UI::config()->get_canvasvar_ZoomRect());
 798
 799         rubberband_rect->set_outline_color (ARDOUR_UI::config()->get_canvasvar_RubberBandRect());
 800         rubberband_rect->set_fill_color ((guint32) ARDOUR_UI::config()->get_canvasvar_RubberBandRect());
 801
 802         location_marker_color = ARDOUR_UI::config()->get_canvasvar_LocationMarker();
 803         location_range_color = ARDOUR_UI::config()->get_canvasvar_LocationRange();
 804         location_cd_marker_color = ARDOUR_UI::config()->get_canvasvar_LocationCDMarker();
 805         location_loop_color = ARDOUR_UI::config()->get_canvasvar_LocationLoop();
 806         location_punch_color = ARDOUR_UI::config()->get_canvasvar_LocationPunch();
 807
 808         refresh_location_display ();
 809 /*
 810         redisplay_tempo (true);
 811
 812         if (_session)
 813               _session->tempo_map().apply_with_metrics (*this, &Editor::draw_metric_marks); // redraw metric markers
 814 */
 815 }
 816
 817 double
 818 Editor::horizontal_position () const
 819 {
 820         return sample_to_pixel (leftmost_frame);
 821 }
 822
 823 void
 824 Editor::set_canvas_cursor (Gdk::Cursor* cursor, bool save)
 825 {
 826         if (save) {
 827                 current_canvas_cursor = cursor;
 828         }
 829
 830         Glib::RefPtr<Gdk::Window> win = _track_canvas->get_window();
 831
 832         if (win) {
 833                 _track_canvas->get_window()->set_cursor (*cursor);
 834         }
 835 }
 836
 837 bool
 838 Editor::track_canvas_key_press (GdkEventKey*)
 839 {
 840         /* XXX: event does not report the modifier key pressed down, AFAICS, so use the Keyboard object instead */
 841         if (mouse_mode == Editing::MouseZoom && Keyboard::the_keyboard().key_is_down (GDK_Control_L)) {
 842                 set_canvas_cursor (_cursors->zoom_out, true);
 843         }
 844
 845         return false;
 846 }
 847
 848 bool
 849 Editor::track_canvas_key_release (GdkEventKey*)
 850 {
 851         if (mouse_mode == Editing::MouseZoom && !Keyboard::the_keyboard().key_is_down (GDK_Control_L)) {
 852                 set_canvas_cursor (_cursors->zoom_in, true);
 853         }
 854
 855         return false;
 856 }
 857
 858 double
 859 Editor::clamp_verbose_cursor_x (double x)
 860 {
 861         if (x < 0) {
 862                 x = 0;
 863         } else {
 864                 x = min (_visible_canvas_width - 200.0, x);
 865         }
 866         return x;
 867 }
 868
 869 double
 870 Editor::clamp_verbose_cursor_y (double y)
 871 {
 872         y = max (0.0, y);
 873         y = min (_visible_canvas_height - 50, y);
 874         return y;
 875 }
 876
 877 ArdourCanvas::Group*
 878 Editor::get_time_bars_group () const
 879 {
 880         return _time_bars_canvas->root();
 881 }
 882
 883 ArdourCanvas::Group*
 884 Editor::get_track_canvas_group() const
 885 {
 886         return _track_canvas->root();
 887 }
 888
 889 ArdourCanvas::GtkCanvasViewport*
 890 Editor::get_time_bars_canvas() const
 891 {
 892         return _time_bars_canvas_viewport;
 893 }
 894
 895 ArdourCanvas::GtkCanvasViewport*
 896 Editor::get_track_canvas() const
 897 {
 898         return _track_canvas_viewport;
 899 }