#include "pbd/memento_command.h"
#include "pbd/unknown_type.h"
#include "pbd/unwind.h"
+#include "pbd/stacktrace.h"
#include <glibmm/miscutils.h>
#include <gtkmm/image.h>
#include "ardour/tempo.h"
#include "ardour/utils.h"
+#include "canvas/debug.h"
+#include "canvas/text.h"
+
#include "control_protocol/control_protocol.h"
#include "actions.h"
#include "audio_time_axis.h"
#include "automation_time_axis.h"
#include "bundle_manager.h"
-#include "button_joiner.h"
-#include "canvas-noevent-text.h"
-#include "canvas_impl.h"
#include "crossfade_edit.h"
#include "debug.h"
#include "editing.h"
#include "rhythm_ferret.h"
#include "selection.h"
#include "sfdb_ui.h"
-#include "simpleline.h"
#include "tempo_lines.h"
#include "time_axis_view.h"
#include "utils.h"
};
#endif
-void
-show_me_the_size (Requisition* r, const char* what)
-{
- cerr << "size of " << what << " = " << r->width << " x " << r->height << endl;
-}
-
static void
pane_size_watcher (Paned* pane)
{
, range_mark_label (_("Range Markers"))
, transport_mark_label (_("Loop/Punch Ranges"))
, cd_mark_label (_("CD Markers"))
+ , videotl_label (_("Video Timeline"))
, edit_packer (4, 4, true)
/* the values here don't matter: layout widgets
snap_threshold = 5.0;
bbt_beat_subdivision = 4;
- _canvas_width = 0;
- _canvas_height = 0;
+ _visible_canvas_width = 0;
+ _visible_canvas_height = 0;
last_autoscroll_x = 0;
last_autoscroll_y = 0;
autoscroll_active = false;
_internal_editing = false;
current_canvas_cursor = 0;
- frames_per_unit = 2048; /* too early to use reset_zoom () */
+ frames_per_pixel = 2048; /* too early to use reset_zoom () */
_scroll_callbacks = 0;
set_zoom_focus (ZoomFocusLeft);
zoom_range_clock->ValueChanged.connect (sigc::mem_fun(*this, &Editor::zoom_adjustment_changed));
- bbt_label.set_name ("EditorTimeButton");
+ bbt_label.set_name ("EditorRulerLabel");
bbt_label.set_size_request (-1, (int)timebar_height);
bbt_label.set_alignment (1.0, 0.5);
bbt_label.set_padding (5,0);
bbt_label.hide ();
bbt_label.set_no_show_all();
- minsec_label.set_name ("EditorTimeButton");
+ minsec_label.set_name ("EditorRulerLabel");
minsec_label.set_size_request (-1, (int)timebar_height);
minsec_label.set_alignment (1.0, 0.5);
minsec_label.set_padding (5,0);
minsec_label.hide ();
minsec_label.set_no_show_all();
- timecode_label.set_name ("EditorTimeButton");
+ timecode_label.set_name ("EditorRulerLabel");
timecode_label.set_size_request (-1, (int)timebar_height);
timecode_label.set_alignment (1.0, 0.5);
timecode_label.set_padding (5,0);
timecode_label.hide ();
timecode_label.set_no_show_all();
- samples_label.set_name ("EditorTimeButton");
+ samples_label.set_name ("EditorRulerLabel");
samples_label.set_size_request (-1, (int)timebar_height);
samples_label.set_alignment (1.0, 0.5);
samples_label.set_padding (5,0);
samples_label.hide ();
samples_label.set_no_show_all();
- tempo_label.set_name ("EditorTimeButton");
+ tempo_label.set_name ("EditorRulerLabel");
tempo_label.set_size_request (-1, (int)timebar_height);
tempo_label.set_alignment (1.0, 0.5);
tempo_label.set_padding (5,0);
tempo_label.hide();
tempo_label.set_no_show_all();
- meter_label.set_name ("EditorTimeButton");
+ meter_label.set_name ("EditorRulerLabel");
meter_label.set_size_request (-1, (int)timebar_height);
meter_label.set_alignment (1.0, 0.5);
meter_label.set_padding (5,0);
meter_label.hide();
meter_label.set_no_show_all();
- mark_label.set_name ("EditorTimeButton");
+ mark_label.set_name ("EditorRulerLabel");
mark_label.set_size_request (-1, (int)timebar_height);
mark_label.set_alignment (1.0, 0.5);
mark_label.set_padding (5,0);
mark_label.hide();
mark_label.set_no_show_all();
- cd_mark_label.set_name ("EditorTimeButton");
+ cd_mark_label.set_name ("EditorRulerLabel");
cd_mark_label.set_size_request (-1, (int)timebar_height);
cd_mark_label.set_alignment (1.0, 0.5);
cd_mark_label.set_padding (5,0);
cd_mark_label.hide();
cd_mark_label.set_no_show_all();
- range_mark_label.set_name ("EditorTimeButton");
+ videotl_bar_height = 4;
+ videotl_label.set_name ("EditorRulerLabel");
+ videotl_label.set_size_request (-1, (int)timebar_height * videotl_bar_height);
+ videotl_label.set_alignment (1.0, 0.5);
+ videotl_label.set_padding (5,0);
+ videotl_label.hide();
+ videotl_label.set_no_show_all();
+
+ range_mark_label.set_name ("EditorRulerLabel");
range_mark_label.set_size_request (-1, (int)timebar_height);
range_mark_label.set_alignment (1.0, 0.5);
range_mark_label.set_padding (5,0);
range_mark_label.hide();
range_mark_label.set_no_show_all();
- transport_mark_label.set_name ("EditorTimeButton");
+ transport_mark_label.set_name ("EditorRulerLabel");
transport_mark_label.set_size_request (-1, (int)timebar_height);
transport_mark_label.set_alignment (1.0, 0.5);
transport_mark_label.set_padding (5,0);
edit_controls_vbox.set_spacing (0);
vertical_adjustment.signal_value_changed().connect (sigc::mem_fun(*this, &Editor::tie_vertical_scrolling), true);
- track_canvas->signal_map_event().connect (sigc::mem_fun (*this, &Editor::track_canvas_map_handler));
+ _track_canvas->signal_map_event().connect (sigc::mem_fun (*this, &Editor::track_canvas_map_handler));
HBox* h = manage (new HBox);
_group_tabs = new EditorGroupTabs (this);
_cursors = new MouseCursors;
- ArdourCanvas::Canvas* time_pad = manage(new ArdourCanvas::Canvas());
- ArdourCanvas::SimpleLine* pad_line_1 = manage(new ArdourCanvas::SimpleLine(*time_pad->root(),
- 0.0, 1.0, 100.0, 1.0));
+ ArdourCanvas::GtkCanvas* time_pad = manage (new ArdourCanvas::GtkCanvas ());
- pad_line_1->property_color_rgba() = 0xFF0000FF;
+ ArdourCanvas::Line* pad_line_1 = new ArdourCanvas::Line (time_pad->root());
+ pad_line_1->set (ArdourCanvas::Duple (0.0, 1.0), ArdourCanvas::Duple (100.0, 1.0));
+ pad_line_1->set_outline_color (0xFF0000FF);
pad_line_1->show();
+ // CAIROCANVAS
time_pad->show();
time_canvas_vbox.set_size_request (-1, (int)(timebar_height * visible_timebars) + 2);
ruler_label_event_box.set_events (Gdk::BUTTON_PRESS_MASK|Gdk::BUTTON_RELEASE_MASK);
ruler_label_event_box.signal_button_release_event().connect (sigc::mem_fun(*this, &Editor::ruler_label_button_release));
- time_button_event_box.add (time_button_vbox);
- time_button_event_box.set_events (Gdk::BUTTON_PRESS_MASK|Gdk::BUTTON_RELEASE_MASK);
- time_button_event_box.signal_button_release_event().connect (sigc::mem_fun(*this, &Editor::ruler_label_button_release));
+ time_bars_event_box.add (time_bars_vbox);
+ time_bars_event_box.set_events (Gdk::BUTTON_PRESS_MASK|Gdk::BUTTON_RELEASE_MASK);
+ time_bars_event_box.signal_button_release_event().connect (sigc::mem_fun(*this, &Editor::ruler_label_button_release));
/* these enable us to have a dedicated window (for cursor setting, etc.)
for the canvas areas.
*/
- track_canvas_event_box.add (*track_canvas);
+ track_canvas_event_box.add (*_track_canvas_viewport);
time_canvas_event_box.add (time_canvas_vbox);
time_canvas_event_box.set_events (Gdk::BUTTON_PRESS_MASK|Gdk::BUTTON_RELEASE_MASK|Gdk::POINTER_MOTION_MASK);
/* labels for the rulers */
edit_packer.attach (ruler_label_event_box, 1, 2, 0, 1, FILL, SHRINK, 0, 0);
- /* labels for the marker "tracks" */
- edit_packer.attach (time_button_event_box, 1, 2, 1, 2, FILL, SHRINK, 0, 0);
+ /* labels for the marker "tracks" (time bars) */
+ edit_packer.attach (time_bars_event_box, 1, 2, 1, 2, FILL, SHRINK, 0, 0);
/* the rulers */
edit_packer.attach (time_canvas_event_box, 2, 3, 0, 1, FILL|EXPAND, FILL, 0, 0);
/* track controls */
edit_packer.attach (controls_layout, 0, 2, 2, 3, FILL, FILL|EXPAND, 0, 0);
- /* main canvas */
- edit_packer.attach (track_canvas_event_box, 2, 3, 1, 3, FILL|EXPAND, FILL|EXPAND, 0, 0);
+ /* time bars canvas */
+ edit_packer.attach (*_time_bars_canvas_viewport, 2, 3, 1, 2, FILL, FILL, 0, 0);
+ /* track canvas */
+ edit_packer.attach (track_canvas_event_box, 2, 3, 2, 3, FILL|EXPAND, FILL|EXPAND, 0, 0);
bottom_hbox.set_border_width (2);
bottom_hbox.set_spacing (3);
/* nudge stuff */
- nudge_forward_button.add (*(manage (new Image (::get_icon("nudge_right")))));
- nudge_backward_button.add (*(manage (new Image (::get_icon("nudge_left")))));
+ nudge_forward_button.set_name ("zoom button");
+ nudge_forward_button.add_elements (ArdourButton::FlatFace);
+ nudge_forward_button.set_image(::get_icon("nudge_right"));
- nudge_forward_button.set_name ("TransportButton");
- nudge_backward_button.set_name ("TransportButton");
+ nudge_backward_button.set_name ("zoom button");
+ nudge_backward_button.add_elements (ArdourButton::FlatFace);
+ nudge_backward_button.set_image(::get_icon("nudge_left"));
fade_context_menu.set_name ("ArdourContextMenu");
delete button_bindings;
delete _routes;
delete _route_groups;
- delete track_canvas;
+ delete _track_canvas_viewport;
delete _drags;
}
cont.show_all ();
}
+bool
+Editor::get_smart_mode () const
+{
+ return ( (current_mouse_mode() == Editing::MouseObject) && smart_mode_action->get_active() );
+}
+
void
Editor::catch_vanishing_regionview (RegionView *rv)
{
return;
}
- double fpu = zoom_range_clock->current_duration() / _canvas_width;
- bool clamped = clamp_frames_per_unit (fpu);
+ double fpu = zoom_range_clock->current_duration() / _visible_canvas_width;
+ bool clamped = clamp_frames_per_pixel (fpu);
if (clamped) {
- zoom_range_clock->set ((framepos_t) floor (fpu * _canvas_width));
+ zoom_range_clock->set ((framepos_t) floor (fpu * _visible_canvas_width));
}
temporal_zoom (fpu);
void
Editor::center_screen (framepos_t frame)
{
- double page = _canvas_width * frames_per_unit;
+ double const page = _visible_canvas_width * frames_per_pixel;
/* if we're off the page, then scroll.
*/
WindowTitle title(session_name);
title += Glib::get_application_name();
set_title (title.get_string());
+ } else {
+ /* ::session_going_away() will have taken care of it */
}
}
/* catch up with the playhead */
- _session->request_locate (playhead_cursor->current_frame);
+ _session->request_locate (playhead_cursor->current_frame ());
_pending_initial_locate = true;
update_title ();
_session->locations()->StateChanged.connect (_session_connections, invalidator (*this), boost::bind (&Editor::refresh_location_display, this), gui_context());
_session->history().Changed.connect (_session_connections, invalidator (*this), boost::bind (&Editor::history_changed, this), gui_context());
- playhead_cursor->canvas_item.show ();
+ playhead_cursor->show ();
boost::function<void (string)> pc (boost::bind (&Editor::parameter_changed, this, _1));
Config->map_parameters (pc);
_session->tempo_map().apply_with_metrics (*this, &Editor::draw_metric_marks);
for (TrackViewList::iterator i = track_views.begin(); i != track_views.end(); ++i) {
- (static_cast<TimeAxisView*>(*i))->set_samples_per_unit (frames_per_unit);
+ (static_cast<TimeAxisView*>(*i))->set_frames_per_pixel (frames_per_pixel);
}
super_rapid_screen_update_connection = ARDOUR_UI::instance()->SuperRapidScreenUpdate.connect (
items.push_back (
ImageMenuElem (
- _("ConstantPower"),
+ _("Constant power"),
*(*images)[FadeConstantPower],
sigc::bind (sigc::mem_fun (*this, emf), FadeConstantPower)
));
/** Pop up a context menu for when the user clicks on a start crossfade */
void
-Editor::popup_xfade_in_context_menu (int button, int32_t time, ArdourCanvas::Item* item, ItemType item_type)
+Editor::popup_xfade_in_context_menu (int button, int32_t time, ArdourCanvas::Item* /*item*/, ItemType /*item_type*/)
{
using namespace Menu_Helpers;
/** Pop up a context menu for when the user clicks on an end crossfade */
void
-Editor::popup_xfade_out_context_menu (int button, int32_t time, ArdourCanvas::Item* item, ItemType item_type)
+Editor::popup_xfade_out_context_menu (int button, int32_t time, ArdourCanvas::Item* /*item*/, ItemType /*item_type*/)
{
using namespace Menu_Helpers;
items.push_back (
ImageMenuElem (
- _("Constant Power"),
+ _("Constant power"),
*_fade_in_images[FadeConstantPower],
sigc::bind (sigc::mem_fun (*this, &Editor::set_fade_in_shape), FadeConstantPower)
));
items.push_back (
ImageMenuElem (
- _("Constant Power"),
+ _("Constant power"),
*_fade_out_images[FadeConstantPower],
sigc::bind (sigc::mem_fun (*this, &Editor::set_fade_out_shape), FadeConstantPower)
));
case SnapToBeatDiv5:
case SnapToBeatDiv4:
case SnapToBeatDiv3:
- case SnapToBeatDiv2:
- compute_bbt_ruler_scale (leftmost_frame, leftmost_frame + current_page_frames());
- update_tempo_based_rulers ();
+ case SnapToBeatDiv2: {
+ ARDOUR::TempoMap::BBTPointList::const_iterator current_bbt_points_begin;
+ ARDOUR::TempoMap::BBTPointList::const_iterator current_bbt_points_end;
+
+ compute_current_bbt_points (leftmost_frame, leftmost_frame + current_page_frames(),
+ current_bbt_points_begin, current_bbt_points_end);
+ compute_bbt_ruler_scale (leftmost_frame, leftmost_frame + current_page_frames(),
+ current_bbt_points_begin, current_bbt_points_end);
+ update_tempo_based_rulers (current_bbt_points_begin, current_bbt_points_end);
break;
+ }
case SnapToRegionStart:
case SnapToRegionEnd:
void
Editor::set_snap_mode (SnapMode mode)
{
- _snap_mode = mode;
string str = snap_mode_strings[(int)mode];
+ if (_internal_editing) {
+ internal_snap_mode = mode;
+ } else {
+ pre_internal_snap_mode = mode;
+ }
+
+ _snap_mode = mode;
+
if (str != snap_mode_selector.get_active_text ()) {
snap_mode_selector.set_active_text (str);
}
if ((prop = node.property ("zoom"))) {
reset_zoom (PBD::atof (prop->value()));
} else {
- reset_zoom (frames_per_unit);
+ reset_zoom (frames_per_pixel);
}
if ((prop = node.property ("snap-to"))) {
pre_internal_snap_type = (SnapType) string_2_enum (prop->value(), pre_internal_snap_type);
}
+
if ((prop = node.property ("pre-internal-snap-mode"))) {
pre_internal_snap_mode = (SnapMode) string_2_enum (prop->value(), pre_internal_snap_mode);
}
}
if ((prop = node.property ("join-object-range"))) {
- ActionManager::set_toggle_action ("MouseMode", "set-mouse-mode-object-range", string_is_affirmative (prop->value ()));
+ RefPtr<Action> act = ActionManager::get_action (X_("MouseMode"), X_("set-mouse-mode-object-range"));
+ bool yn = string_is_affirmative (prop->value());
+ if (act) {
+ RefPtr<ToggleAction> tact = RefPtr<ToggleAction>::cast_dynamic(act);
+ tact->set_active (!yn);
+ tact->set_active (yn);
+ }
+ set_mouse_mode(mouse_mode, true);
}
if ((prop = node.property ("edit-point"))) {
maybe_add_mixer_strip_width (*node);
node->add_property ("zoom-focus", enum_2_string (zoom_focus));
- snprintf (buf, sizeof(buf), "%f", frames_per_unit);
+ snprintf (buf, sizeof(buf), "%f", frames_per_pixel);
node->add_property ("zoom", buf);
node->add_property ("snap-to", enum_2_string (_snap_type));
node->add_property ("snap-mode", enum_2_string (_snap_mode));
node->add_property ("pre-internal-snap-mode", enum_2_string (pre_internal_snap_mode));
node->add_property ("edit-point", enum_2_string (_edit_point));
- snprintf (buf, sizeof (buf), "%" PRIi64, playhead_cursor->current_frame);
+ snprintf (buf, sizeof (buf), "%" PRIi64, playhead_cursor->current_frame ());
node->add_property ("playhead", buf);
snprintf (buf, sizeof (buf), "%" PRIi64, leftmost_frame);
node->add_property ("left-frame", buf);
mode_box->set_spacing(4);
HBox* mouse_mode_box = manage (new HBox);
- HBox* mouse_mode_hbox1 = manage (new HBox);
- HBox* mouse_mode_hbox2 = manage (new HBox);
- VBox* mouse_mode_vbox1 = manage (new VBox);
- VBox* mouse_mode_vbox2 = manage (new VBox);
- Alignment* mouse_mode_align1 = manage (new Alignment);
- Alignment* mouse_mode_align2 = manage (new Alignment);
+ HBox* mouse_mode_hbox = manage (new HBox);
+ VBox* mouse_mode_vbox = manage (new VBox);
+ Alignment* mouse_mode_align = manage (new Alignment);
Glib::RefPtr<SizeGroup> mouse_mode_size_group = SizeGroup::create (SIZE_GROUP_BOTH);
+// mouse_mode_size_group->add_widget (smart_mode_button);
mouse_mode_size_group->add_widget (mouse_move_button);
mouse_mode_size_group->add_widget (mouse_select_button);
mouse_mode_size_group->add_widget (mouse_zoom_button);
mouse_mode_size_group->add_widget (internal_edit_button);
/* make them just a bit bigger */
- mouse_move_button.set_size_request (-1, 25);
-
- smart_mode_joiner = manage (new ButtonJoiner ("mouse mode button", mouse_move_button, mouse_select_button, true));
- smart_mode_joiner->set_related_action (smart_mode_action);
+ mouse_move_button.set_size_request (-1, 30);
- mouse_mode_hbox2->set_spacing (2);
- mouse_mode_box->set_spacing (2);
+ mouse_mode_hbox->set_spacing (2);
- mouse_mode_hbox1->pack_start (*smart_mode_joiner, false, false);
- mouse_mode_hbox2->pack_start (mouse_zoom_button, false, false);
- mouse_mode_hbox2->pack_start (mouse_gain_button, false, false);
- mouse_mode_hbox2->pack_start (mouse_timefx_button, false, false);
- mouse_mode_hbox2->pack_start (mouse_audition_button, false, false);
- mouse_mode_hbox2->pack_start (mouse_draw_button, false, false);
- mouse_mode_hbox2->pack_start (internal_edit_button, false, false);
+ mouse_mode_hbox->pack_start (smart_mode_button, false, false);
+ mouse_mode_hbox->pack_start (mouse_move_button, false, false);
+ mouse_mode_hbox->pack_start (mouse_select_button, false, false);
+ mouse_mode_hbox->pack_start (mouse_zoom_button, false, false);
+ mouse_mode_hbox->pack_start (mouse_gain_button, false, false);
+ mouse_mode_hbox->pack_start (mouse_timefx_button, false, false);
+ mouse_mode_hbox->pack_start (mouse_audition_button, false, false);
+ mouse_mode_hbox->pack_start (mouse_draw_button, false, false);
+ mouse_mode_hbox->pack_start (internal_edit_button, false, false, 8);
- mouse_mode_vbox1->pack_start (*mouse_mode_hbox1, false, false);
- mouse_mode_vbox2->pack_start (*mouse_mode_hbox2, false, false);
+ mouse_mode_vbox->pack_start (*mouse_mode_hbox);
- mouse_mode_align1->add (*mouse_mode_vbox1);
- mouse_mode_align1->set (0.5, 1.0, 0.0, 0.0);
- mouse_mode_align2->add (*mouse_mode_vbox2);
- mouse_mode_align2->set (0.5, 1.0, 0.0, 0.0);
+ mouse_mode_align->add (*mouse_mode_vbox);
+ mouse_mode_align->set (0.5, 1.0, 0.0, 0.0);
- mouse_mode_box->pack_start (*mouse_mode_align1, false, false);
- mouse_mode_box->pack_start (*mouse_mode_align2, false, false);
+ mouse_mode_box->pack_start (*mouse_mode_align, false, false);
edit_mode_strings.push_back (edit_mode_to_string (Slide));
if (!Profile->get_sae()) {
RefPtr<Action> act;
zoom_in_button.set_name ("zoom button");
- zoom_in_button.set_image (::get_icon ("zoom_in"));
- zoom_in_button.set_tweaks (ArdourButton::ShowClick);
+ zoom_in_button.add_elements ( ArdourButton::FlatFace );
+ zoom_in_button.set_tweaks ((ArdourButton::Tweaks) (ArdourButton::ShowClick) );
+ zoom_in_button.set_image(::get_icon ("zoom_in"));
act = ActionManager::get_action (X_("Editor"), X_("temporal-zoom-in"));
zoom_in_button.set_related_action (act);
zoom_out_button.set_name ("zoom button");
- zoom_out_button.set_image (::get_icon ("zoom_out"));
- zoom_out_button.set_tweaks (ArdourButton::ShowClick);
+ zoom_out_button.add_elements ( ArdourButton::FlatFace );
+ zoom_out_button.set_tweaks ((ArdourButton::Tweaks) (ArdourButton::ShowClick) );
+ zoom_out_button.set_image(::get_icon ("zoom_out"));
act = ActionManager::get_action (X_("Editor"), X_("temporal-zoom-out"));
zoom_out_button.set_related_action (act);
zoom_out_full_button.set_name ("zoom button");
- zoom_out_full_button.set_image (::get_icon ("zoom_full"));
- zoom_out_full_button.set_tweaks (ArdourButton::ShowClick);
+ zoom_out_full_button.add_elements ( ArdourButton::FlatFace );
+ zoom_out_full_button.set_tweaks ((ArdourButton::Tweaks) (ArdourButton::ShowClick) );
+ zoom_out_full_button.set_image(::get_icon ("zoom_full"));
act = ActionManager::get_action (X_("Editor"), X_("zoom-to-session"));
zoom_out_full_button.set_related_action (act);
_zoom_box.pack_start (zoom_focus_selector, false, false);
/* Track zoom buttons */
- tav_expand_button.set_name ("TrackHeightButton");
+ tav_expand_button.set_name ("zoom button");
+ tav_expand_button.add_elements ( ArdourButton::FlatFace );
+ tav_expand_button.set_tweaks ((ArdourButton::Tweaks) (ArdourButton::ShowClick) );
tav_expand_button.set_size_request (-1, 20);
- tav_expand_button.add (*(manage (new Image (::get_icon ("tav_exp")))));
+ tav_expand_button.set_image(::get_icon ("tav_exp"));
act = ActionManager::get_action (X_("Editor"), X_("expand-tracks"));
- act->connect_proxy (tav_expand_button);
+ tav_expand_button.set_related_action (act);
- tav_shrink_button.set_name ("TrackHeightButton");
+ tav_shrink_button.set_name ("zoom button");
+ tav_shrink_button.add_elements ( ArdourButton::FlatFace );
+ tav_shrink_button.set_tweaks ((ArdourButton::Tweaks) (ArdourButton::ShowClick) );
tav_shrink_button.set_size_request (-1, 20);
- tav_shrink_button.add (*(manage (new Image (::get_icon ("tav_shrink")))));
+ tav_shrink_button.set_image(::get_icon ("tav_shrink"));
act = ActionManager::get_action (X_("Editor"), X_("shrink-tracks"));
- act->connect_proxy (tav_shrink_button);
+ tav_shrink_button.set_related_action (act);
_zoom_box.pack_start (tav_shrink_button);
_zoom_box.pack_start (tav_expand_button);
_zoom_tearoff->Visible.connect (sigc::bind (sigc::mem_fun(*this, &Editor::reattach_tearoff), static_cast<Box*> (&toolbar_hbox),
&_zoom_tearoff->tearoff_window(), 0));
- snap_box.set_spacing (1);
+ snap_box.set_spacing (2);
snap_box.set_border_width (2);
snap_type_selector.set_name ("SnapTypeSelector");
nudge_forward_button.signal_button_release_event().connect (sigc::mem_fun(*this, &Editor::nudge_forward_release), false);
nudge_backward_button.signal_button_release_event().connect (sigc::mem_fun(*this, &Editor::nudge_backward_release), false);
+ nudge_forward_button.set_tweaks ((ArdourButton::Tweaks) (ArdourButton::ShowClick) );
+ nudge_backward_button.set_tweaks ((ArdourButton::Tweaks) (ArdourButton::ShowClick) );
+
nudge_box->pack_start (nudge_backward_button, false, false);
nudge_box->pack_start (nudge_forward_button, false, false);
nudge_box->pack_start (*nudge_clock, false, false);
void
Editor::setup_tooltips ()
{
- ARDOUR_UI::instance()->set_tip (mouse_move_button, _("Select/Move Objects"));
- ARDOUR_UI::instance()->set_tip (mouse_select_button, _("Select/Move Ranges"));
+ ARDOUR_UI::instance()->set_tip (smart_mode_button, _("Smart Mode (add Range functions to Object mode)"));
+ ARDOUR_UI::instance()->set_tip (mouse_move_button, _("Object Mode (select/move Objects)"));
+ ARDOUR_UI::instance()->set_tip (mouse_select_button, _("Range Mode (select/move Ranges)"));
ARDOUR_UI::instance()->set_tip (mouse_draw_button, _("Draw/Edit MIDI Notes"));
ARDOUR_UI::instance()->set_tip (mouse_gain_button, _("Draw Region Gain"));
ARDOUR_UI::instance()->set_tip (mouse_zoom_button, _("Select Zoom Range"));
ARDOUR_UI::instance()->set_tip (mouse_timefx_button, _("Stretch/Shrink Regions and MIDI Notes"));
ARDOUR_UI::instance()->set_tip (mouse_audition_button, _("Listen to Specific Regions"));
- ARDOUR_UI::instance()->set_tip (smart_mode_joiner, _("Smart Mode (Select/Move Objects + Ranges)"));
- ARDOUR_UI::instance()->set_tip (internal_edit_button, _("Edit Region Contents (e.g. notes)"));
+ ARDOUR_UI::instance()->set_tip (internal_edit_button, _("Note Level Editing"));
ARDOUR_UI::instance()->set_tip (*_group_tabs, _("Groups: click to (de)activate\nContext-click for other operations"));
ARDOUR_UI::instance()->set_tip (nudge_forward_button, _("Nudge Region/Selection Later"));
ARDOUR_UI::instance()->set_tip (nudge_backward_button, _("Nudge Region/Selection Earlier"));
const char* q;
p = (const char *) malloc (txt.length() + 1);
- txt.copy ((char *) p, txt.length(), 0);
- ((char*)p)[txt.length()] = '\0';
+ txt.copy (const_cast<char *> (p), txt.length(), 0);
+ const_cast<char*>(p)[txt.length()] = '\0';
while (p)
{
void
Editor::map_transport_state ()
{
- ENSURE_GUI_THREAD (*this, &Editor::map_transport_state)
+ ENSURE_GUI_THREAD (*this, &Editor::map_transport_state);
if (_session && _session->transport_stopped()) {
have_pending_keyboard_selection = false;
{
float times = 1.0f;
- if (mouse_mode == MouseRange) {
- if (selection->time.length() == 0) {
- return;
- }
- }
-
RegionSelection rs = get_regions_from_selection_and_entered ();
- if (mouse_mode != MouseRange && rs.empty()) {
+ if ( selection->time.length() == 0 && rs.empty()) {
return;
}
times = adjustment.get_value();
}
- if (mouse_mode == MouseRange) {
- duplicate_selection (times);
+ if ((current_mouse_mode() == Editing::MouseRange)) {
+ if (selection->time.length()) {
+ duplicate_selection (times);
+ }
+ } else if (get_smart_mode()) {
+ if (selection->time.length()) {
+ duplicate_selection (times);
+ } else
+ duplicate_some_regions (rs, times);
} else {
duplicate_some_regions (rs, times);
}
}
}
+void
+Editor::cycle_zoom_focus ()
+{
+ switch (zoom_focus) {
+ case ZoomFocusLeft:
+ set_zoom_focus (ZoomFocusRight);
+ break;
+ case ZoomFocusRight:
+ set_zoom_focus (ZoomFocusCenter);
+ break;
+ case ZoomFocusCenter:
+ set_zoom_focus (ZoomFocusPlayhead);
+ break;
+ case ZoomFocusPlayhead:
+ set_zoom_focus (ZoomFocusMouse);
+ break;
+ case ZoomFocusMouse:
+ set_zoom_focus (ZoomFocusEdit);
+ break;
+ case ZoomFocusEdit:
+ set_zoom_focus (ZoomFocusLeft);
+ break;
+ }
+}
+
void
Editor::ensure_float (Window& win)
{
hide_measures ();
if ((_show_measures = yn) == true) {
- if (tempo_lines)
+ if (tempo_lines) {
tempo_lines->show();
- draw_measures ();
+ }
+ (void) redraw_measures ();
}
instant_save ();
}
/**
* Make new playlists for a given track and also any others that belong
- * to the same active route group with the `edit' property.
+ * to the same active route group with the `select' property.
* @param v Track.
*/
begin_reversible_command (_("new playlists"));
vector<boost::shared_ptr<ARDOUR::Playlist> > playlists;
_session->playlists->get (playlists);
- mapover_tracks (sigc::bind (sigc::mem_fun (*this, &Editor::mapped_use_new_playlist), playlists), v, ARDOUR::Properties::edit.property_id);
+ mapover_tracks (sigc::bind (sigc::mem_fun (*this, &Editor::mapped_use_new_playlist), playlists), v, ARDOUR::Properties::select.property_id);
commit_reversible_command ();
}
/**
* Use a copy of the current playlist for a given track and also any others that belong
- * to the same active route group with the `edit' property.
+ * to the same active route group with the `select' property.
* @param v Track.
*/
begin_reversible_command (_("copy playlists"));
vector<boost::shared_ptr<ARDOUR::Playlist> > playlists;
_session->playlists->get (playlists);
- mapover_tracks (sigc::bind (sigc::mem_fun (*this, &Editor::mapped_use_copy_playlist), playlists), v, ARDOUR::Properties::edit.property_id);
+ mapover_tracks (sigc::bind (sigc::mem_fun (*this, &Editor::mapped_use_copy_playlist), playlists), v, ARDOUR::Properties::select.property_id);
commit_reversible_command ();
}
/** Clear the current playlist for a given track and also any others that belong
- * to the same active route group with the `edit' property.
+ * to the same active route group with the `select' property.
* @param v Track.
*/
begin_reversible_command (_("clear playlists"));
vector<boost::shared_ptr<ARDOUR::Playlist> > playlists;
_session->playlists->get (playlists);
- mapover_tracks (sigc::mem_fun (*this, &Editor::mapped_clear_playlist), v, ARDOUR::Properties::edit.property_id);
+ mapover_tracks (sigc::mem_fun (*this, &Editor::mapped_clear_playlist), v, ARDOUR::Properties::select.property_id);
commit_reversible_command ();
}
}
void
-Editor::reset_zoom (double fpu)
+Editor::reset_zoom (double fpp)
{
- clamp_frames_per_unit (fpu);
+ clamp_frames_per_pixel (fpp);
- if (fpu == frames_per_unit) {
+ if (fpp == frames_per_pixel) {
return;
}
pending_visual_change.add (VisualChange::ZoomLevel);
- pending_visual_change.frames_per_unit = fpu;
+ pending_visual_change.frames_per_pixel = fpp;
ensure_visual_change_idle_handler ();
}
{
VisualState* vs = new VisualState (with_tracks);
vs->y_position = vertical_adjustment.get_value();
- vs->frames_per_unit = frames_per_unit;
+ vs->frames_per_pixel = frames_per_pixel;
vs->leftmost_frame = leftmost_frame;
vs->zoom_focus = zoom_focus;
vertical_adjustment.set_value (vs.y_position);
set_zoom_focus (vs.zoom_focus);
- reposition_and_zoom (vs.leftmost_frame, vs.frames_per_unit);
+ reposition_and_zoom (vs.leftmost_frame, vs.frames_per_pixel);
if (vs.gui_state) {
*ARDOUR_UI::instance()->gui_object_state = *vs.gui_state;
* @param fpu New frames per unit; should already have been clamped so that it is sensible.
*/
void
-Editor::set_frames_per_unit (double fpu)
+Editor::set_frames_per_pixel (double fpp)
{
if (tempo_lines) {
tempo_lines->tempo_map_changed();
}
- frames_per_unit = fpu;
+ frames_per_pixel = fpp;
/* convert fpu to frame count */
- framepos_t frames = (framepos_t) floor (frames_per_unit * _canvas_width);
+ framepos_t frames = (framepos_t) floor (frames_per_pixel * _visible_canvas_width);
- if (frames_per_unit != zoom_range_clock->current_duration()) {
+ if (frames_per_pixel != zoom_range_clock->current_duration()) {
zoom_range_clock->set (frames);
}
- bool const showing_time_selection =
- mouse_mode == MouseRange ||
- (mouse_mode == MouseObject && _join_object_range_state != JOIN_OBJECT_RANGE_NONE);
+ bool const showing_time_selection = selection->time.length() > 0;
if (showing_time_selection && selection->time.start () != selection->time.end_frame ()) {
for (TrackViewList::iterator i = selection->tracks.begin(); i != selection->tracks.end(); ++i) {
//reset_scrolling_region ();
if (playhead_cursor) {
- playhead_cursor->set_position (playhead_cursor->current_frame);
+ playhead_cursor->set_position (playhead_cursor->current_frame ());
}
refresh_location_display();
instant_save ();
}
+void
+Editor::queue_visual_videotimeline_update ()
+{
+ /* TODO:
+ * pending_visual_change.add (VisualChange::VideoTimeline);
+ * or maybe even more specific: which videotimeline-image
+ * currently it calls update_video_timeline() to update
+ * _all outdated_ images on the video-timeline.
+ * see 'exposeimg()' in video_image_frame.cc
+ */
+ ensure_visual_change_idle_handler ();
+}
+
void
Editor::ensure_visual_change_idle_handler ()
{
if (pending_visual_change.idle_handler_id < 0) {
pending_visual_change.idle_handler_id = g_idle_add (_idle_visual_changer, this);
+ pending_visual_change.being_handled = false;
}
}
super-rapid-screen-update can be dropped if we are still processing
the last one.
*/
+
pending_visual_change.idle_handler_id = -1;
pending_visual_change.being_handled = true;
double const last_time_origin = horizontal_position ();
if (p & VisualChange::ZoomLevel) {
- set_frames_per_unit (pending_visual_change.frames_per_unit);
+ set_frames_per_pixel (pending_visual_change.frames_per_pixel);
compute_fixed_ruler_scale ();
- compute_current_bbt_points(pending_visual_change.time_origin, pending_visual_change.time_origin + current_page_frames());
- compute_bbt_ruler_scale (pending_visual_change.time_origin, pending_visual_change.time_origin + current_page_frames());
- update_tempo_based_rulers ();
+
+ ARDOUR::TempoMap::BBTPointList::const_iterator current_bbt_points_begin;
+ ARDOUR::TempoMap::BBTPointList::const_iterator current_bbt_points_end;
+
+ compute_current_bbt_points (pending_visual_change.time_origin, pending_visual_change.time_origin + current_page_frames(),
+ current_bbt_points_begin, current_bbt_points_end);
+ compute_bbt_ruler_scale (pending_visual_change.time_origin, pending_visual_change.time_origin + current_page_frames(),
+ current_bbt_points_begin, current_bbt_points_end);
+ update_tempo_based_rulers (current_bbt_points_begin, current_bbt_points_end);
}
+
+ if (p & VisualChange::ZoomLevel) {
+ update_video_timeline();
+ }
+
if (p & VisualChange::TimeOrigin) {
- set_horizontal_position (pending_visual_change.time_origin / frames_per_unit);
+ set_horizontal_position (pending_visual_change.time_origin / frames_per_pixel);
}
+
if (p & VisualChange::YOrigin) {
vertical_adjustment.set_value (pending_visual_change.y_origin);
}
redisplay_tempo (true);
}
+ if (!(p & VisualChange::ZoomLevel)) {
+ update_video_timeline();
+ }
+
_summary->set_overlays_dirty ();
pending_visual_change.being_handled = false;
Location* tpl;
if ((tpl = transport_punch_location()) == 0) {
- Location* loc = new Location (*_session, start, end, _("Loop"), Location::IsAutoPunch);
+ Location* loc = new Location (*_session, start, end, _("Punch"), Location::IsAutoPunch);
XMLNode &before = _session->locations()->get_state();
_session->locations()->add (loc, true);
_session->set_auto_loop_location (loc);
RegionView* rv = rtv->view()->find_view (*i);
if (rv) {
- rs.push_back (rv);
+ rs.add (rv);
}
}
}
}
}
-/** Start with regions that are selected. Then add equivalent regions
- * on tracks in the same active edit-enabled route group as any of
- * the regions that we started with.
- */
-
-RegionSelection
-Editor::get_regions_from_selection ()
-{
- return get_equivalent_regions (selection->regions, ARDOUR::Properties::edit.property_id);
-}
-
/** Get regions using the following method:
*
- * Make an initial region list using the selected regions, unless
+ * Make a region list using the selected regions, unless
* the edit point is `mouse' and the mouse is over an unselected
- * region. In this case, start with just that region.
- *
- * Then, add equivalent regions in active edit groups to the region list.
- *
- * Then, search the list of selected tracks to find any selected tracks which
- * do not contain regions already in the region list. If there are no selected
- * tracks and 'No Selection = All Tracks' is active, search all tracks rather
- * than just the selected.
+ * region. In this case, use just that region.
*
- * Add any regions that are under the edit point on these tracks to get the
- * returned region list.
+ * If the edit point is not 'mouse', and there are no regions selected,
+ * search the list of selected tracks and return regions that are under
+ * the edit point on these tracks. If there are no selected tracks and
+ * 'No Selection = All Tracks' is active, search all tracks,
*
* The rationale here is that the mouse edit point is special in that
* its position describes both a time and a track; the other edit
regions = selection->regions;
}
- TrackViewList tracks;
- if (_edit_point != EditAtMouse) {
- tracks = selection->tracks;
- }
+ if (regions.empty() && _edit_point != EditAtMouse) {
+ TrackViewList tracks = selection->tracks;
- /* Add any other regions that are in the same
- edit-activated route group as one of our regions.
- */
- regions = get_equivalent_regions (regions, ARDOUR::Properties::edit.property_id);
- framepos_t const where = get_preferred_edit_position ();
-
- if (_route_groups->all_group_active_button().get_active() && tracks.empty()) {
- /* tracks is empty (no track selected), and 'No Selection = All Tracks'
- * is enabled, so consider all tracks
- */
- tracks = track_views;
- }
-
- if (!tracks.empty()) {
- /* now search the selected tracks for tracks which don't
- already contain regions to be acted upon, and get regions at
- the edit point on those tracks too.
- */
- TrackViewList tracks_without_relevant_regions;
-
- for (TrackViewList::iterator t = tracks.begin (); t != tracks.end (); ++t) {
- if (!regions.involves (**t)) {
- /* there are no equivalent regions on this track */
- tracks_without_relevant_regions.push_back (*t);
- }
+ if (_route_groups->all_group_active_button().get_active() && tracks.empty()) {
+ /* tracks is empty (no track selected), and 'No Selection = All Tracks'
+ * is enabled, so consider all tracks
+ */
+ tracks = track_views;
}
- if (!tracks_without_relevant_regions.empty()) {
- /* there are some selected tracks with neither selected
- * regions or their equivalents: act upon all regions in
- * those tracks
- */
- get_regions_at (regions, where, tracks_without_relevant_regions);
+ if (!tracks.empty()) {
+ /* no region selected or entered, but some selected tracks:
+ * act on all regions on the selected tracks at the edit point
+ */
+ framepos_t const where = get_preferred_edit_position ();
+ get_regions_at(regions, where, tracks);
}
}
-
return regions;
}
regions.add (entered_regionview);
}
- return get_equivalent_regions (regions, ARDOUR::Properties::edit.property_id);
+ return regions;
}
void
-Editor::get_regions_corresponding_to (boost::shared_ptr<Region> region, vector<RegionView*>& regions)
+Editor::get_regions_corresponding_to (boost::shared_ptr<Region> region, vector<RegionView*>& regions, bool src_comparison)
{
for (TrackViewList::iterator i = track_views.begin(); i != track_views.end(); ++i) {
}
if ((pl = (tr->playlist())) != 0) {
- pl->get_region_list_equivalent_regions (region, results);
+ if (src_comparison) {
+ pl->get_source_equivalent_regions (region, results);
+ } else {
+ pl->get_region_list_equivalent_regions (region, results);
+ }
}
for (vector<boost::shared_ptr<Region> >::iterator ir = results.begin(); ir != results.end(); ++ir) {
{
ENSURE_GUI_THREAD (*this, &Editor::located);
- playhead_cursor->set_position (_session->audible_frame ());
- if (_follow_playhead && !_pending_initial_locate) {
- reset_x_origin_to_follow_playhead ();
+ if (_session) {
+ playhead_cursor->set_position (_session->audible_frame ());
+ if (_follow_playhead && !_pending_initial_locate) {
+ reset_x_origin_to_follow_playhead ();
+ }
}
_pending_locate_request = false;
for (RouteList::iterator x = routes.begin(); x != routes.end(); ++x) {
boost::shared_ptr<Route> route = (*x);
- if (route->is_hidden() || route->is_monitor()) {
+ if (route->is_auditioner() || route->is_monitor()) {
continue;
}
DataType dt = route->input()->default_type();
if (dt == ARDOUR::DataType::AUDIO) {
- rtv = new AudioTimeAxisView (*this, _session, *track_canvas);
+ rtv = new AudioTimeAxisView (*this, _session, *_track_canvas);
rtv->set_route (route);
} else if (dt == ARDOUR::DataType::MIDI) {
- rtv = new MidiTimeAxisView (*this, _session, *track_canvas);
+ rtv = new MidiTimeAxisView (*this, _session, *_track_canvas);
rtv->set_route (route);
} else {
throw unknown_type();
void
Editor::reset_x_origin_to_follow_playhead ()
{
- framepos_t const frame = playhead_cursor->current_frame;
+ framepos_t const frame = playhead_cursor->current_frame ();
if (frame < leftmost_frame || frame > leftmost_frame + current_page_frames()) {
*/
#if 0
// FIXME DO SOMETHING THAT WORKS HERE - this is 2.X code
- double target = ((double)frame - (double)current_page_frames()/2.0) / frames_per_unit;
+ double target = ((double)frame - (double)current_page_frames()/2.0) / frames_per_pixel;
if (target <= 0.0) {
target = 0.0;
}
- if (fabs(target - current) < current_page_frames() / frames_per_unit) {
+ if (fabs(target - current) < current_page_frames() / frames_per_pixel) {
target = (target * 0.15) + (current * 0.85);
} else {
/* relax */
last_update_frame = 0;
_drags->abort ();
- playhead_cursor->canvas_item.hide ();
+ playhead_cursor->hide ();
/* rip everything out of the list displays */
hide_measures ();
clear_marker_display ();
- current_bbt_points_begin = current_bbt_points_end;
-
+ stop_step_editing ();
+
/* get rid of any existing editor mixer strip */
WindowTitle title(Glib::get_application_name());
{
_stepping_axis_view = 0;
}
+
+
+void
+Editor::save_canvas_state ()
+{
+ XMLTree* tree = static_cast<ArdourCanvas::Canvas*>(_track_canvas)->get_state ();
+ string path = string_compose ("%1/canvas-state.xml", _session->path());
+ tree->write (path);
+}
projects / ardour.git / blobdiff