/*
- Copyright (C) 2000-2006 Paul Davis
+ Copyright (C) 2000-2007 Paul Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- $Id$
*/
+/* Note: public Editor methods are documented in public_editor.h */
+
#include <unistd.h>
#include <cstdlib>
#include <cmath>
#include <pbd/convert.h>
#include <pbd/error.h>
-#include <pbd/stacktrace.h>
+#include <pbd/enumwriter.h>
#include <pbd/memento_command.h>
+#include <glibmm/miscutils.h>
#include <gtkmm/image.h>
#include <gdkmm/color.h>
#include <gdkmm/bitmap.h>
+#include <gtkmm2ext/grouped_buttons.h>
#include <gtkmm2ext/gtk_ui.h>
#include <gtkmm2ext/tearoff.h>
#include <gtkmm2ext/utils.h>
+#include <gtkmm2ext/window_title.h>
+#include <gtkmm2ext/choice.h>
#include <ardour/audio_track.h>
#include <ardour/audio_diskstream.h>
#include "ardour_ui.h"
#include "editor.h"
-#include "grouped_buttons.h"
#include "keyboard.h"
#include "marker.h"
#include "playlist_selector.h"
#include "editing.h"
#include "public_editor.h"
#include "crossfade_edit.h"
-#include "audio_time_axis.h"
#include "canvas_impl.h"
#include "actions.h"
#include "gui_thread.h"
#include "i18n.h"
-/* <CMT Additions> */
+#ifdef WITH_CMT
#include "imageframe_socket_handler.h"
-/* </CMT Additions> */
+#endif
using namespace std;
using namespace sigc;
using namespace Gtkmm2ext;
using namespace Editing;
+using PBD::internationalize;
using PBD::atoi;
const double Editor::timebar_height = 15.0;
}
-Editor::Editor (AudioEngine& eng)
- : engine (eng),
-
+Editor::Editor ()
+ :
/* time display buttons */
minsec_label (_("Mins:Secs")),
automation_mode_button (_("mode")),
global_automation_button (_("automation")),
- /* <CMT Additions> */
+#ifdef WITH_CMT
image_socket_listener(0),
- /* </CMT Additions> */
+#endif
/* nudge */
selection->PointsChanged.connect (mem_fun(*this, &Editor::point_selection_changed));
clicked_regionview = 0;
- clicked_trackview = 0;
- clicked_audio_trackview = 0;
+ clicked_axisview = 0;
+ clicked_routeview = 0;
clicked_crossfadeview = 0;
clicked_control_point = 0;
latest_regionview = 0;
no_route_list_redisplay = false;
verbose_cursor_on = true;
route_removal = false;
- track_spacing = 0;
show_automatic_regions_in_region_list = true;
region_list_sort_type = (Editing::RegionListSortType) 0;
have_pending_keyboard_selection = false;
new_transport_marker_menu = 0;
editor_mixer_strip_width = Wide;
show_editor_mixer_when_tracks_arrive = false;
- region_edit_menu_split_item = 0;
temp_location = 0;
- region_edit_menu_split_multichannel_item = 0;
leftmost_frame = 0;
ignore_mouse_mode_toggle = false;
current_stepping_trackview = 0;
button_release_can_deselect = true;
canvas_idle_queued = false;
_dragging_playhead = false;
+ _dragging_hscrollbar = false;
location_marker_color = color_map[cLocationMarker];
location_range_color = color_map[cLocationRange];
edit_vscrollbar.set_adjustment (vertical_adjustment);
edit_hscrollbar.set_adjustment (horizontal_adjustment);
- edit_hscrollbar.signal_button_press_event().connect (mem_fun(*this, &Editor::hscrollbar_button_press));
- edit_hscrollbar.signal_button_release_event().connect (mem_fun(*this, &Editor::hscrollbar_button_release));
+ edit_hscrollbar.signal_button_press_event().connect (mem_fun(*this, &Editor::hscrollbar_button_press), false);
+ edit_hscrollbar.signal_button_release_event().connect (mem_fun(*this, &Editor::hscrollbar_button_release), false);
edit_hscrollbar.signal_size_allocate().connect (mem_fun(*this, &Editor::hscrollbar_allocate));
edit_hscrollbar.set_name ("EditorHScrollbar");
edit_cursor_clock.ValueChanged.connect (mem_fun(*this, &Editor::edit_cursor_clock_changed));
+ time_canvas_vbox.pack_start (*_ruler_separator, false, false);
time_canvas_vbox.pack_start (*minsec_ruler, false, false);
time_canvas_vbox.pack_start (*smpte_ruler, false, false);
time_canvas_vbox.pack_start (*frames_ruler, false, false);
time_canvas_vbox.pack_start (*bbt_ruler, false, false);
time_canvas_vbox.pack_start (time_canvas, true, true);
- time_canvas_vbox.set_size_request (-1, (int)(timebar_height * visible_timebars));
+ time_canvas_vbox.set_size_request (-1, (int)(timebar_height * visible_timebars) + 2);
bbt_label.set_name ("EditorTimeButton");
bbt_label.set_size_request (-1, (int)timebar_height);
time_button_event_box.set_name ("TimebarLabelBase");
time_button_event_box.signal_button_release_event().connect (mem_fun(*this, &Editor::ruler_label_button_release));
+ time_button_frame.add(time_button_event_box);
+ time_button_frame.property_shadow_type() = Gtk::SHADOW_OUT;
+
/* these enable us to have a dedicated window (for cursor setting, etc.)
for the canvas areas.
*/
edit_packer.set_border_width (0);
edit_packer.set_name ("EditorWindow");
- edit_packer.attach (edit_vscrollbar, 0, 1, 1, 3, FILL, FILL|EXPAND, 0, 0);
+ edit_packer.attach (edit_vscrollbar, 3, 4, 1, 2, FILL, FILL|EXPAND, 0, 0);
- edit_packer.attach (time_button_event_box, 1, 2, 0, 1, FILL, FILL, 0, 0);
+ edit_packer.attach (time_button_frame, 0, 2, 0, 1, FILL, FILL, 0, 0);
edit_packer.attach (time_canvas_event_box, 2, 3, 0, 1, FILL|EXPAND, FILL, 0, 0);
edit_packer.attach (controls_layout, 1, 2, 1, 2, FILL, FILL|EXPAND, 0, 0);
edit_group_display.set_name ("EditGroupList");
edit_group_display.get_selection()->set_mode (SELECTION_SINGLE);
- edit_group_display.set_headers_visible (false);
+ edit_group_display.set_headers_visible (true);
edit_group_display.set_reorderable (false);
edit_group_display.set_rules_hint (true);
edit_group_display.set_size_request (75, -1);
set_icon_list (window_icons);
set_default_icon_list (window_icons);
}
- set_title (_("ardour: editor"));
+
+ WindowTitle title(Glib::get_application_name());
+ title += _("Editor");
+ set_title (title.get_string());
set_wmclass (X_("ardour_editor"), "Ardour");
add (vpacker);
Editor::~Editor()
{
- /* <CMT Additions> */
+#ifdef WITH_CMT
if(image_socket_listener)
{
if(image_socket_listener->is_connected())
delete image_socket_listener ;
image_socket_listener = 0 ;
}
- /* </CMT Additions> */
+#endif
}
void
if (new_end > last_canvas_frame) {
last_canvas_frame = new_end;
+ horizontal_adjustment.set_upper (last_canvas_frame / frames_per_unit);
reset_scrolling_region ();
}
if (session) {
bool dirty = session->dirty();
- string wintitle = _("ardour: editor: ");
-
- if (dirty) {
- wintitle += '[';
- }
-
- wintitle += session->name();
+ string session_name;
if (session->snap_name() != session->name()) {
- wintitle += ':';
- wintitle += session->snap_name();
+ session_name = session->snap_name();
+ } else {
+ session_name = session->name();
}
if (dirty) {
- wintitle += ']';
+ session_name = "*" + session_name;
}
- set_title (wintitle);
+ WindowTitle title(session_name);
+ title += Glib::get_application_name();
+ set_title (title.get_string());
}
}
session_connections.push_back (session->TransportStateChange.connect (mem_fun(*this, &Editor::map_transport_state)));
session_connections.push_back (session->PositionChanged.connect (mem_fun(*this, &Editor::map_position_change)));
session_connections.push_back (session->RouteAdded.connect (mem_fun(*this, &Editor::handle_new_route)));
- session_connections.push_back (session->AudioRegionAdded.connect (mem_fun(*this, &Editor::handle_new_audio_region)));
- session_connections.push_back (session->AudioRegionRemoved.connect (mem_fun(*this, &Editor::handle_audio_region_removed)));
+ session_connections.push_back (session->RegionAdded.connect (mem_fun(*this, &Editor::handle_new_region)));
+ session_connections.push_back (session->RegionRemoved.connect (mem_fun(*this, &Editor::handle_region_removed)));
session_connections.push_back (session->DurationChanged.connect (mem_fun(*this, &Editor::handle_new_duration)));
session_connections.push_back (session->edit_group_added.connect (mem_fun(*this, &Editor::add_edit_group)));
session_connections.push_back (session->edit_group_removed.connect (mem_fun(*this, &Editor::edit_groups_changed)));
session_connections.push_back (session->SMPTEOffsetChanged.connect (mem_fun(*this, &Editor::update_just_smpte)));
- session_connections.push_back (session->tempo_map().StateChanged.connect (bind (mem_fun(*this, &Editor::tempo_map_changed), false)));
+ session_connections.push_back (session->tempo_map().StateChanged.connect (mem_fun(*this, &Editor::tempo_map_changed)));
edit_groups_changed ();
}
session->locations()->add (loc, false);
session->set_auto_loop_location (loc);
- }
- else {
+ } else {
// force name
loc->set_name (_("Loop"));
}
}
session->locations()->add (loc, false);
session->set_auto_punch_location (loc);
- }
- else {
+ } else {
// force name
loc->set_name (_("Punch"));
}
for (i = rows.begin(); i != rows.end(); ++i) {
TimeAxisView *tv = (*i)[route_display_columns.tv];
- AudioTimeAxisView *atv;
+ RouteTimeAxisView *rtv;
- if ((atv = dynamic_cast<AudioTimeAxisView*>(tv)) != 0) {
- if (atv->route()->master()) {
+ if ((rtv = dynamic_cast<RouteTimeAxisView*>(tv)) != 0) {
+ if (rtv->route()->master()) {
route_list_display.get_selection()->unselect (i);
}
}
timebar_cursor = new Gdk::Cursor(LEFT_PTR);
}
+/** Pop up a context menu for when the user clicks on a fade in or fade out */
void
Editor::popup_fade_context_menu (int button, int32_t time, ArdourCanvas::Item* item, ItemType item_type)
{
items.push_back (SeparatorElem());
items.push_back (MenuElem (_("Linear"), bind (mem_fun (*this, &Editor::set_fade_in_shape), AudioRegion::Linear)));
- items.push_back (MenuElem (_("Slowest"), bind (mem_fun (*this, &Editor::set_fade_in_shape), AudioRegion::LogB)));
- items.push_back (MenuElem (_("Slow"), bind (mem_fun (*this, &Editor::set_fade_in_shape), AudioRegion::Fast)));
+ items.push_back (MenuElem (_("Slowest"), bind (mem_fun (*this, &Editor::set_fade_in_shape), AudioRegion::Fast)));
+ items.push_back (MenuElem (_("Slow"), bind (mem_fun (*this, &Editor::set_fade_in_shape), AudioRegion::LogB)));
items.push_back (MenuElem (_("Fast"), bind (mem_fun (*this, &Editor::set_fade_in_shape), AudioRegion::LogA)));
items.push_back (MenuElem (_("Fastest"), bind (mem_fun (*this, &Editor::set_fade_in_shape), AudioRegion::Slow)));
break;
items.push_back (SeparatorElem());
items.push_back (MenuElem (_("Linear"), bind (mem_fun (*this, &Editor::set_fade_out_shape), AudioRegion::Linear)));
- items.push_back (MenuElem (_("Slowest"), bind (mem_fun (*this, &Editor::set_fade_out_shape), AudioRegion::Fast)));
- items.push_back (MenuElem (_("Slow"), bind (mem_fun (*this, &Editor::set_fade_out_shape), AudioRegion::LogB)));
- items.push_back (MenuElem (_("Fast"), bind (mem_fun (*this, &Editor::set_fade_out_shape), AudioRegion::LogA)));
- items.push_back (MenuElem (_("Fastest"), bind (mem_fun (*this, &Editor::set_fade_out_shape), AudioRegion::Slow)));
+ items.push_back (MenuElem (_("Slowest"), bind (mem_fun (*this, &Editor::set_fade_out_shape), AudioRegion::Slow)));
+ items.push_back (MenuElem (_("Slow"), bind (mem_fun (*this, &Editor::set_fade_out_shape), AudioRegion::LogA)));
+ items.push_back (MenuElem (_("Fast"), bind (mem_fun (*this, &Editor::set_fade_out_shape), AudioRegion::LogB)));
+ items.push_back (MenuElem (_("Fastest"), bind (mem_fun (*this, &Editor::set_fade_out_shape), AudioRegion::Fast)));
break;
fade_context_menu.popup (button, time);
}
+/* Pop up the general track context menu for when the user clicks pretty much anywhere in a track or bus */
void
-Editor::popup_track_context_menu (int button, int32_t time, ItemType item_type, bool with_selection, nframes_t frame)
+Editor::popup_track_context_menu (int button, int32_t time, nframes_t frame)
{
- using namespace Menu_Helpers;
- Menu* (Editor::*build_menu_function)(nframes_t);
- Menu *menu;
-
- switch (item_type) {
- case RegionItem:
- case RegionViewName:
- case RegionViewNameHighlight:
- if (with_selection) {
- build_menu_function = &Editor::build_track_selection_context_menu;
- } else {
- build_menu_function = &Editor::build_track_region_context_menu;
- }
- break;
-
- case SelectionItem:
- if (with_selection) {
- build_menu_function = &Editor::build_track_selection_context_menu;
- } else {
- build_menu_function = &Editor::build_track_context_menu;
- }
- break;
-
- case CrossfadeViewItem:
- build_menu_function = &Editor::build_track_crossfade_context_menu;
- break;
-
- case StreamItem:
- if (clicked_audio_trackview->get_diskstream()) {
- build_menu_function = &Editor::build_track_context_menu;
- } else {
- build_menu_function = &Editor::build_track_bus_context_menu;
- }
- break;
-
- default:
- /* probably shouldn't happen but if it does, we don't care */
- return;
- }
-
- menu = (this->*build_menu_function)(frame);
- menu->set_name ("ArdourContextMenu");
-
- /* now handle specific situations */
-
- switch (item_type) {
- case RegionItem:
- case RegionViewName:
- case RegionViewNameHighlight:
- if (!with_selection) {
- if (region_edit_menu_split_item) {
- if (clicked_regionview && clicked_regionview->region()->covers (edit_cursor->current_frame)) {
- ActionManager::set_sensitive (ActionManager::edit_cursor_in_region_sensitive_actions, true);
- } else {
- ActionManager::set_sensitive (ActionManager::edit_cursor_in_region_sensitive_actions, false);
- }
- }
- /*
- if (region_edit_menu_split_multichannel_item) {
- if (clicked_regionview && clicked_regionview->region().n_channels() > 1) {
- // GTK2FIX find the action, change its sensitivity
- // region_edit_menu_split_multichannel_item->set_sensitive (true);
- } else {
- // GTK2FIX see above
- // region_edit_menu_split_multichannel_item->set_sensitive (false);
- }
- }*/
- }
- break;
-
- case SelectionItem:
- break;
-
- case CrossfadeViewItem:
- break;
-
- case StreamItem:
- break;
-
- default:
- /* probably shouldn't happen but if it does, we don't care */
- return;
- }
-
- if (clicked_audio_trackview && clicked_audio_trackview->audio_track()) {
-
- /* Bounce to disk */
-
- using namespace Menu_Helpers;
- MenuList& edit_items = menu->items();
-
- edit_items.push_back (SeparatorElem());
-
- switch (clicked_audio_trackview->audio_track()->freeze_state()) {
- case AudioTrack::NoFreeze:
- edit_items.push_back (MenuElem (_("Freeze"), mem_fun(*this, &Editor::freeze_route)));
- break;
-
- case AudioTrack::Frozen:
- edit_items.push_back (MenuElem (_("Unfreeze"), mem_fun(*this, &Editor::unfreeze_route)));
- break;
-
- case AudioTrack::UnFrozen:
- edit_items.push_back (MenuElem (_("Freeze"), mem_fun(*this, &Editor::freeze_route)));
- break;
- }
-
- }
-
- menu->popup (button, time);
+ build_track_context_menu (frame)->popup (button, time);
}
Menu*
-Editor::build_track_context_menu (nframes_t ignored)
+Editor::build_track_context_menu (nframes_t frame)
{
using namespace Menu_Helpers;
- MenuList& edit_items = track_context_menu.items();
- edit_items.clear();
-
- add_dstream_context_items (edit_items);
- return &track_context_menu;
-}
-
-Menu*
-Editor::build_track_bus_context_menu (nframes_t ignored)
-{
- using namespace Menu_Helpers;
-
- MenuList& edit_items = track_context_menu.items();
- edit_items.clear();
-
- add_bus_context_items (edit_items);
- return &track_context_menu;
-}
-
-Menu*
-Editor::build_track_region_context_menu (nframes_t frame)
-{
- using namespace Menu_Helpers;
- MenuList& edit_items = track_region_context_menu.items();
+ Menu* menu = manage (new Menu);
+ MenuList& edit_items = menu->items();
edit_items.clear();
- AudioTimeAxisView* atv = dynamic_cast<AudioTimeAxisView*> (clicked_trackview);
+ /* Build the general `track' context menu, adding what is appropriate given
+ the current selection */
- if (atv) {
- boost::shared_ptr<Diskstream> ds;
- boost::shared_ptr<Playlist> pl;
-
- if ((ds = atv->get_diskstream()) && ((pl = ds->playlist()))) {
- Playlist::RegionList* regions = pl->regions_at ((nframes_t) floor ( (double)frame * ds->speed()));
- for (Playlist::RegionList::iterator i = regions->begin(); i != regions->end(); ++i) {
- add_region_context_items (atv->audio_view(), (*i), edit_items);
- }
- delete regions;
- }
- }
-
- add_dstream_context_items (edit_items);
-
- return &track_region_context_menu;
-}
-
-Menu*
-Editor::build_track_crossfade_context_menu (nframes_t frame)
-{
- using namespace Menu_Helpers;
- MenuList& edit_items = track_crossfade_context_menu.items();
- edit_items.clear ();
-
- AudioTimeAxisView* atv = dynamic_cast<AudioTimeAxisView*> (clicked_trackview);
+ /* XXX: currently crossfades can't be selected, so we can't use the selection
+ to decide which crossfades to mention in the menu. I believe this will
+ change at some point. For now we have to use clicked_trackview to decide. */
+ AudioTimeAxisView* atv = dynamic_cast<AudioTimeAxisView*> (clicked_axisview);
if (atv) {
boost::shared_ptr<Diskstream> ds;
if ((ds = atv->get_diskstream()) && ((pl = ds->playlist()) != 0) && ((apl = boost::dynamic_pointer_cast<AudioPlaylist> (pl)) != 0)) {
- Playlist::RegionList* regions = pl->regions_at (frame);
AudioPlaylist::Crossfades xfades;
-
apl->crossfades_at (frame, xfades);
bool many = xfades.size() > 1;
for (AudioPlaylist::Crossfades::iterator i = xfades.begin(); i != xfades.end(); ++i) {
add_crossfade_context_items (atv->audio_view(), (*i), edit_items, many);
}
+ }
+ }
- for (Playlist::RegionList::iterator i = regions->begin(); i != regions->end(); ++i) {
- add_region_context_items (atv->audio_view(), (*i), edit_items);
- }
+ if (!selection->time.empty()) {
+ add_selection_context_items (edit_items);
+ }
- delete regions;
- }
+ if (!selection->regions.empty()) {
+ add_region_context_items (edit_items);
}
- add_dstream_context_items (edit_items);
+ if (!selection->tracks.empty()) {
+ add_bus_or_audio_track_context_items (edit_items);
+ }
+
+ menu->set_name ("ArdourContextMenu");
- return &track_crossfade_context_menu;
+ return menu;
}
#ifdef FFT_ANALYSIS
#endif /* FFT_ANALYSIS */
-
-Menu*
-Editor::build_track_selection_context_menu (nframes_t ignored)
-{
- using namespace Menu_Helpers;
- MenuList& edit_items = track_selection_context_menu.items();
- edit_items.clear ();
-
- add_selection_context_items (edit_items);
- add_dstream_context_items (edit_items);
-
- return &track_selection_context_menu;
-}
-
+/** Add context menu items relevant to crossfades.
+ * @param edit_items List to add the items to.
+ */
void
Editor::add_crossfade_context_items (AudioStreamView* view, boost::shared_ptr<Crossfade> xfade, Menu_Helpers::MenuList& edit_items, bool many)
{
}
}
+/** Add an element to a menu, settings its sensitivity.
+ * @param m Menu to add to.
+ * @param e Element to add.
+ * @param s true to make sensitive, false to make insensitive
+ */
+void
+Editor::add_item_with_sensitivity (Menu_Helpers::MenuList& m, Menu_Helpers::MenuElem e, bool s) const
+{
+ m.push_back (e);
+ if (!s) {
+ m.back().set_sensitive (false);
+ }
+}
+
+/** Add context menu items relevant to regions.
+ * @param edit_items List to add the items to.
+ */
void
-Editor::add_region_context_items (AudioStreamView* sv, boost::shared_ptr<Region> region, Menu_Helpers::MenuList& edit_items)
+Editor::add_region_context_items (Menu_Helpers::MenuList& edit_items)
{
using namespace Menu_Helpers;
- Menu *region_menu = manage (new Menu);
- MenuList& items = region_menu->items();
+ Menu *region_menu = manage (new Menu);
+ MenuList& items = region_menu->items();
region_menu->set_name ("ArdourContextMenu");
- boost::shared_ptr<AudioRegion> ar;
-
- if (region) {
- ar = boost::dynamic_pointer_cast<AudioRegion> (region);
- }
+ items.push_back (MenuElem (_("Edit..."), mem_fun(*this, &Editor::edit_region)));
+ items.push_back (MenuElem (_("Raise to top layer"), mem_fun(*this, &Editor::raise_region_to_top)));
+ items.push_back (MenuElem (_("Lower to bottom layer"), mem_fun (*this, &Editor::lower_region_to_bottom)));
- /* when this particular menu pops up, make the relevant region
- become selected.
- */
+ Menu* sync_point_menu = manage (new Menu);
+ MenuList& sync_point_items = sync_point_menu->items();
+ sync_point_menu->set_name("ArdourContextMenu");
+
+ sync_point_items.push_back (MenuElem (_("Define"), mem_fun(*this, &Editor::set_region_sync_from_edit_cursor)));
+ sync_point_items.push_back (MenuElem (_("Remove"), mem_fun(*this, &Editor::remove_region_sync)));
- region_menu->signal_map_event().connect (bind (mem_fun(*this, &Editor::set_selected_regionview_from_map_event), sv, boost::weak_ptr<Region>(region)));
+ items.push_back (MenuElem (_("Sync points"), *sync_point_menu));
- items.push_back (MenuElem (_("Popup region editor"), mem_fun(*this, &Editor::edit_region)));
- items.push_back (MenuElem (_("Raise to top layer"), mem_fun(*this, &Editor::raise_region_to_top)));
- items.push_back (MenuElem (_("Lower to bottom layer"), mem_fun (*this, &Editor::lower_region_to_bottom)));
- items.push_back (SeparatorElem());
- items.push_back (MenuElem (_("Define sync point"), mem_fun(*this, &Editor::set_region_sync_from_edit_cursor)));
- items.push_back (MenuElem (_("Remove sync point"), mem_fun(*this, &Editor::remove_region_sync)));
- items.push_back (SeparatorElem());
+ add_item_with_sensitivity (items, MenuElem (_("Audition"), mem_fun(*this, &Editor::audition_selected_region)), selection->regions.size() == 1);
+
+ add_item_with_sensitivity (items, MenuElem (_("Export"), mem_fun(*this, &Editor::export_region)), selection->regions.size() == 1);
- items.push_back (MenuElem (_("Audition"), mem_fun(*this, &Editor::audition_selected_region)));
- items.push_back (MenuElem (_("Export"), mem_fun(*this, &Editor::export_region)));
items.push_back (MenuElem (_("Bounce"), mem_fun(*this, &Editor::bounce_region_selection)));
#ifdef FFT_ANALYSIS
items.push_back (SeparatorElem());
- items.push_back (CheckMenuElem (_("Lock"), mem_fun(*this, &Editor::toggle_region_lock)));
- region_lock_item = static_cast<CheckMenuItem*>(&items.back());
- if (region->locked()) {
- region_lock_item->set_active();
- }
- items.push_back (CheckMenuElem (_("Mute"), mem_fun(*this, &Editor::toggle_region_mute)));
- region_mute_item = static_cast<CheckMenuItem*>(&items.back());
- if (region->muted()) {
- region_mute_item->set_active();
- }
- items.push_back (CheckMenuElem (_("Opaque"), mem_fun(*this, &Editor::toggle_region_opaque)));
- region_opaque_item = static_cast<CheckMenuItem*>(&items.back());
- if (region->opaque()) {
- region_opaque_item->set_active();
- }
+ items.push_back (MenuElem (_("Lock"), bind (mem_fun (*this, &Editor::set_region_lock), true)));
+ items.push_back (MenuElem (_("Unlock"), bind (mem_fun (*this, &Editor::set_region_lock), false)));
+ items.push_back (MenuElem (_("Mute"), bind (mem_fun (*this, &Editor::set_region_mute), true)));
+ items.push_back (MenuElem (_("Unmute"), bind (mem_fun (*this, &Editor::set_region_mute), false)));
+ items.push_back (MenuElem (_("Opaque"), bind (mem_fun (*this, &Editor::set_region_opaque), true)));
+ items.push_back (MenuElem (_("Transparent"), bind (mem_fun (*this, &Editor::set_region_opaque), false)));
- items.push_back (CheckMenuElem (_("Original position"), mem_fun(*this, &Editor::naturalize)));
- if (region->at_natural_position()) {
- items.back().set_sensitive (false);
+ /* We allow "Original position" if at least one region is not at its
+ natural position */
+ RegionSelection::iterator i = selection->regions.begin();
+ while (i != selection->regions.end() && (*i)->region()->at_natural_position() == true) {
+ ++i;
}
+ add_item_with_sensitivity (items, MenuElem (_("Original position"), mem_fun(*this, &Editor::naturalize)), i != selection->regions.end());
+
items.push_back (SeparatorElem());
- if (ar) {
-
- RegionView* rv = sv->find_view (ar);
- AudioRegionView* arv = dynamic_cast<AudioRegionView*>(rv);
-
- items.push_back (MenuElem (_("Reset Envelope"), mem_fun(*this, &Editor::reset_region_gain_envelopes)));
-
- items.push_back (CheckMenuElem (_("Envelope Visible"), mem_fun(*this, &Editor::toggle_gain_envelope_visibility)));
- region_envelope_visible_item = static_cast<CheckMenuItem*> (&items.back());
-
- if (arv->envelope_visible()) {
- region_envelope_visible_item->set_active (true);
- }
+ /* Find out if we have a selected audio region */
+ i = selection->regions.begin();
+ while (i != selection->regions.end() && boost::dynamic_pointer_cast<AudioRegion>((*i)->region()) == 0) {
+ ++i;
+ }
+ bool const have_selected_audio_region = (i != selection->regions.end());
- items.push_back (CheckMenuElem (_("Envelope Active"), mem_fun(*this, &Editor::toggle_gain_envelope_active)));
- region_envelope_active_item = static_cast<CheckMenuItem*> (&items.back());
+ if (have_selected_audio_region) {
- if (ar->envelope_active()) {
- region_envelope_active_item->set_active (true);
- }
+ Menu* envelopes_menu = manage (new Menu);
+ MenuList& envelopes_items = envelopes_menu->items();
+ envelopes_menu->set_name ("ArdourContextMenu");
- items.push_back (SeparatorElem());
+ envelopes_items.push_back (MenuElem (_("Reset"), mem_fun(*this, &Editor::reset_region_gain_envelopes)));
+ envelopes_items.push_back (MenuElem (_("Visible"), bind (mem_fun (*this, &Editor::set_gain_envelope_visibility), true)));
+ envelopes_items.push_back (MenuElem (_("Invisible"), bind (mem_fun (*this, &Editor::set_gain_envelope_visibility), false)));
+ envelopes_items.push_back (MenuElem (_("Active"), bind (mem_fun (*this, &Editor::set_gain_envelope_active), true)));
+ envelopes_items.push_back (MenuElem (_("Inactive"), bind (mem_fun (*this, &Editor::set_gain_envelope_active), false)));
- if (ar->scale_amplitude() != 1.0f) {
- items.push_back (MenuElem (_("DeNormalize"), mem_fun(*this, &Editor::denormalize_region)));
- } else {
- items.push_back (MenuElem (_("Normalize"), mem_fun(*this, &Editor::normalize_region)));
- }
+ items.push_back (MenuElem (_("Envelopes"), *envelopes_menu));
+
+ items.push_back (MenuElem (_("Denormalize"), mem_fun (*this, &Editor::denormalize_regions)));
+ items.push_back (MenuElem (_("Normalize"), mem_fun (*this, &Editor::normalize_regions)));
}
- items.push_back (MenuElem (_("Reverse"), mem_fun(*this, &Editor::reverse_region)));
+
+ items.push_back (MenuElem (_("Reverse"), mem_fun(*this, &Editor::reverse_regions)));
items.push_back (SeparatorElem());
/* range related stuff */
-
- items.push_back (MenuElem (_("Add Range Markers"), mem_fun (*this, &Editor::add_location_from_audio_region)));
- items.push_back (MenuElem (_("Set Range Selection"), mem_fun (*this, &Editor::set_selection_from_audio_region)));
+
+ add_item_with_sensitivity (items, MenuElem (_("Add range markers"), mem_fun (*this, &Editor::add_location_from_audio_region)), selection->regions.size() == 1);
+
+ add_item_with_sensitivity (items, MenuElem (_("Set range selection"), mem_fun (*this, &Editor::set_selection_from_audio_region)), selection->regions.size() == 1);
+
items.push_back (SeparatorElem());
/* Nudge region */
MenuList& nudge_items = nudge_menu->items();
nudge_menu->set_name ("ArdourContextMenu");
- nudge_items.push_back (MenuElem (_("Nudge fwd"), (bind (mem_fun(*this, &Editor::nudge_forward), false))));
- nudge_items.push_back (MenuElem (_("Nudge bwd"), (bind (mem_fun(*this, &Editor::nudge_backward), false))));
- nudge_items.push_back (MenuElem (_("Nudge fwd by capture offset"), (mem_fun(*this, &Editor::nudge_forward_capture_offset))));
- nudge_items.push_back (MenuElem (_("Nudge bwd by capture offset"), (mem_fun(*this, &Editor::nudge_backward_capture_offset))));
+ nudge_items.push_back (MenuElem (_("Nudge forward"), (bind (mem_fun(*this, &Editor::nudge_forward), false))));
+ nudge_items.push_back (MenuElem (_("Nudge backward"), (bind (mem_fun(*this, &Editor::nudge_backward), false))));
+ nudge_items.push_back (MenuElem (_("Nudge forward by capture offset"), (mem_fun(*this, &Editor::nudge_forward_capture_offset))));
+ nudge_items.push_back (MenuElem (_("Nudge backward by capture offset"), (mem_fun(*this, &Editor::nudge_backward_capture_offset))));
items.push_back (MenuElem (_("Nudge"), *nudge_menu));
- items.push_back (SeparatorElem());
Menu *trim_menu = manage (new Menu);
MenuList& trim_items = trim_menu->items();
trim_items.push_back (MenuElem (_("Edit cursor to end"), mem_fun(*this, &Editor::trim_region_to_edit_cursor)));
items.push_back (MenuElem (_("Trim"), *trim_menu));
- items.push_back (SeparatorElem());
-
items.push_back (MenuElem (_("Split"), (mem_fun(*this, &Editor::split_region))));
- region_edit_menu_split_item = &items.back();
-
items.push_back (MenuElem (_("Make mono regions"), (mem_fun(*this, &Editor::split_multichannel_region))));
- region_edit_menu_split_multichannel_item = &items.back();
-
items.push_back (MenuElem (_("Duplicate"), (bind (mem_fun(*this, &Editor::duplicate_dialog), true))));
- items.push_back (MenuElem (_("Fill Track"), (mem_fun(*this, &Editor::region_fill_track))));
+ items.push_back (MenuElem (_("Fill track"), (mem_fun(*this, &Editor::region_fill_track))));
items.push_back (SeparatorElem());
- items.push_back (MenuElem (_("Remove"), mem_fun(*this, &Editor::remove_clicked_region)));
+ items.push_back (MenuElem (_("Remove"), mem_fun(*this, &Editor::remove_selected_regions)));
/* OK, stick the region submenu at the top of the list, and then add
the standard items.
*/
- /* we have to hack up the region name because "_" has a special
- meaning for menu titles.
- */
-
- string::size_type pos = 0;
- string menu_item_name = region->name();
-
- while ((pos = menu_item_name.find ("_", pos)) != string::npos) {
- menu_item_name.replace (pos, 1, "__");
- pos += 2;
- }
-
+ string const menu_item_name = selection->regions.size() > 1 ? _("Regions") : _("Region");
edit_items.push_back (MenuElem (menu_item_name, *region_menu));
- edit_items.push_back (SeparatorElem());
}
+/** Add context menu items relevant to selection ranges.
+ * @param edit_items List to add the items to.
+ */
void
Editor::add_selection_context_items (Menu_Helpers::MenuList& edit_items)
{
items.push_back (SeparatorElem());
items.push_back (MenuElem (_("Select all in range"), mem_fun(*this, &Editor::select_all_selectables_using_time_selection)));
items.push_back (SeparatorElem());
- items.push_back (MenuElem (_("Add Range Markers"), mem_fun (*this, &Editor::add_location_from_selection)));
+ items.push_back (MenuElem (_("Add range markers"), mem_fun (*this, &Editor::add_location_from_selection)));
items.push_back (MenuElem (_("Set range to loop range"), mem_fun(*this, &Editor::set_selection_from_loop)));
items.push_back (MenuElem (_("Set range to punch range"), mem_fun(*this, &Editor::set_selection_from_punch)));
items.push_back (SeparatorElem());
edit_items.push_back (SeparatorElem());
}
+/** Add context menu items relevant to busses or audio tracks.
+ * @param edit_items List to add the items to.
+ */
void
-Editor::add_dstream_context_items (Menu_Helpers::MenuList& edit_items)
+Editor::add_bus_or_audio_track_context_items (Menu_Helpers::MenuList& edit_items)
{
using namespace Menu_Helpers;
+ /* We add every possible action here, and de-sensitize things
+ that aren't allowed. The sensitivity logic is a bit spread out;
+ on the one hand I'm using things like can_cut_copy (), which is
+ reasonably complicated and so perhaps better near the function that
+ it expresses sensitivity for, and on the other hand checks
+ in this function as well. You can't really have can_* for everything
+ or the number of methods would get silly. */
+
+ bool const one_selected_region = selection->regions.size() == 1;
+
+ /* Count the number of selected audio tracks */
+ int n_audio_tracks = 0;
+ for (TrackSelection::iterator i = selection->tracks.begin(); i != selection->tracks.end(); ++i) {
+ RouteTimeAxisView const * r = dynamic_cast<RouteTimeAxisView*>(*i);
+ if (r && r->is_audio_track()) {
+ n_audio_tracks++;
+ }
+ }
+
/* Playback */
Menu *play_menu = manage (new Menu);
play_items.push_back (MenuElem (_("Play from edit cursor"), mem_fun(*this, &Editor::play_from_edit_cursor)));
play_items.push_back (MenuElem (_("Play from start"), mem_fun(*this, &Editor::play_from_start)));
- play_items.push_back (MenuElem (_("Play region"), mem_fun(*this, &Editor::play_selected_region)));
- play_items.push_back (SeparatorElem());
- play_items.push_back (MenuElem (_("Loop Region"), mem_fun(*this, &Editor::loop_selected_region)));
+ add_item_with_sensitivity (play_items, MenuElem (_("Play region"), mem_fun(*this, &Editor::play_selected_region)), one_selected_region);
+
+ add_item_with_sensitivity (play_items, MenuElem (_("Loop region"), mem_fun(*this, &Editor::loop_selected_region)), one_selected_region);
edit_items.push_back (MenuElem (_("Play"), *play_menu));
Menu *select_menu = manage (new Menu);
MenuList& select_items = select_menu->items();
select_menu->set_name ("ArdourContextMenu");
+
+ string str = selection->tracks.size() == 1 ? _("Select all in track") : _("Select all in tracks");
+
+ select_items.push_back (MenuElem (str, bind (mem_fun(*this, &Editor::select_all_in_selected_tracks), Selection::Set)));
+
+ select_items.push_back (MenuElem (_("Select all"), bind (mem_fun(*this, &Editor::select_all), Selection::Set)));
+
+ str = selection->tracks.size() == 1 ? _("Invert selection in track") : _("Invert selection in tracks");
+
+ select_items.push_back (MenuElem (str, mem_fun(*this, &Editor::invert_selection_in_selected_tracks)));
- select_items.push_back (MenuElem (_("Select All in track"), bind (mem_fun(*this, &Editor::select_all_in_track), Selection::Set)));
- select_items.push_back (MenuElem (_("Select All"), bind (mem_fun(*this, &Editor::select_all), Selection::Set)));
- select_items.push_back (MenuElem (_("Invert selection in track"), mem_fun(*this, &Editor::invert_selection_in_track)));
select_items.push_back (MenuElem (_("Invert selection"), mem_fun(*this, &Editor::invert_selection)));
select_items.push_back (SeparatorElem());
- select_items.push_back (MenuElem (_("Set range to loop range"), mem_fun(*this, &Editor::set_selection_from_loop)));
- select_items.push_back (MenuElem (_("Set range to punch range"), mem_fun(*this, &Editor::set_selection_from_punch)));
- select_items.push_back (SeparatorElem());
+
+ if (n_audio_tracks) {
+ select_items.push_back (MenuElem (_("Set range to loop range"), mem_fun(*this, &Editor::set_selection_from_loop)));
+ select_items.push_back (MenuElem (_("Set range to punch range"), mem_fun(*this, &Editor::set_selection_from_punch)));
+ }
+
select_items.push_back (MenuElem (_("Select all after edit cursor"), bind (mem_fun(*this, &Editor::select_all_selectables_using_cursor), edit_cursor, true)));
select_items.push_back (MenuElem (_("Select all before edit cursor"), bind (mem_fun(*this, &Editor::select_all_selectables_using_cursor), edit_cursor, false)));
select_items.push_back (MenuElem (_("Select all after playhead"), bind (mem_fun(*this, &Editor::select_all_selectables_using_cursor), playhead_cursor, true)));
select_items.push_back (MenuElem (_("Select all before playhead"), bind (mem_fun(*this, &Editor::select_all_selectables_using_cursor), playhead_cursor, false)));
- select_items.push_back (MenuElem (_("Select all between cursors"), bind (mem_fun(*this, &Editor::select_all_selectables_between_cursors), playhead_cursor, edit_cursor)));
- select_items.push_back (SeparatorElem());
+
+ if (n_audio_tracks) {
+ select_items.push_back (MenuElem (_("Select all between cursors"), bind (mem_fun(*this, &Editor::select_all_selectables_between_cursors), playhead_cursor, edit_cursor)));
+ }
edit_items.push_back (MenuElem (_("Select"), *select_menu));
Menu *cutnpaste_menu = manage (new Menu);
MenuList& cutnpaste_items = cutnpaste_menu->items();
cutnpaste_menu->set_name ("ArdourContextMenu");
-
- cutnpaste_items.push_back (MenuElem (_("Cut"), mem_fun(*this, &Editor::cut)));
- cutnpaste_items.push_back (MenuElem (_("Copy"), mem_fun(*this, &Editor::copy)));
- cutnpaste_items.push_back (MenuElem (_("Paste at edit cursor"), bind (mem_fun(*this, &Editor::paste), 1.0f)));
- cutnpaste_items.push_back (MenuElem (_("Paste at mouse"), mem_fun(*this, &Editor::mouse_paste)));
-
- cutnpaste_items.push_back (SeparatorElem());
-
- cutnpaste_items.push_back (MenuElem (_("Align"), bind (mem_fun(*this, &Editor::align), ARDOUR::SyncPoint)));
- cutnpaste_items.push_back (MenuElem (_("Align Relative"), bind (mem_fun(*this, &Editor::align_relative), ARDOUR::SyncPoint)));
- cutnpaste_items.push_back (SeparatorElem());
-
- cutnpaste_items.push_back (MenuElem (_("Insert chunk"), bind (mem_fun(*this, &Editor::paste_named_selection), 1.0f)));
-
- edit_items.push_back (MenuElem (_("Edit"), *cutnpaste_menu));
-
- /* Adding new material */
+ add_item_with_sensitivity (cutnpaste_items, MenuElem (_("Cut"), mem_fun(*this, &Editor::cut)), can_cut_copy ());
- edit_items.push_back (SeparatorElem());
- edit_items.push_back (MenuElem (_("Insert Selected Region"), bind (mem_fun(*this, &Editor::insert_region_list_selection), 1.0f)));
- edit_items.push_back (MenuElem (_("Insert Existing Audio"), bind (mem_fun(*this, &Editor::add_external_audio_action), ImportToTrack)));
-
- /* Nudge track */
-
- Menu *nudge_menu = manage (new Menu());
- MenuList& nudge_items = nudge_menu->items();
- nudge_menu->set_name ("ArdourContextMenu");
+ add_item_with_sensitivity (cutnpaste_items, MenuElem (_("Copy"), mem_fun(*this, &Editor::copy)), can_cut_copy ());
- edit_items.push_back (SeparatorElem());
- nudge_items.push_back (MenuElem (_("Nudge entire track fwd"), (bind (mem_fun(*this, &Editor::nudge_track), false, true))));
- nudge_items.push_back (MenuElem (_("Nudge track after edit cursor fwd"), (bind (mem_fun(*this, &Editor::nudge_track), true, true))));
- nudge_items.push_back (MenuElem (_("Nudge entire track bwd"), (bind (mem_fun(*this, &Editor::nudge_track), false, false))));
- nudge_items.push_back (MenuElem (_("Nudge track after edit cursor bwd"), (bind (mem_fun(*this, &Editor::nudge_track), true, false))));
-
- edit_items.push_back (MenuElem (_("Nudge"), *nudge_menu));
-}
-
-void
-Editor::add_bus_context_items (Menu_Helpers::MenuList& edit_items)
-{
- using namespace Menu_Helpers;
+ if (n_audio_tracks) {
+ cutnpaste_items.push_back (MenuElem (_("Paste at edit cursor"), bind (mem_fun(*this, &Editor::paste), 1.0f)));
+ cutnpaste_items.push_back (MenuElem (_("Paste at mouse"), mem_fun(*this, &Editor::mouse_paste)));
+
+ cutnpaste_items.push_back (SeparatorElem());
+
+ cutnpaste_items.push_back (MenuElem (_("Align"), bind (mem_fun(*this, &Editor::align), ARDOUR::SyncPoint)));
+ cutnpaste_items.push_back (MenuElem (_("Align relative"), bind (mem_fun(*this, &Editor::align_relative), ARDOUR::SyncPoint)));
+ cutnpaste_items.push_back (MenuElem (_("Insert chunk"), bind (mem_fun(*this, &Editor::paste_named_selection), 1.0f)));
+ } else {
+ cutnpaste_items.push_back (MenuElem (_("Paste"), bind (mem_fun(*this, &Editor::paste), 1.0f)));
+ }
- /* Playback */
+ edit_items.push_back (MenuElem (_("Edit"), *cutnpaste_menu));
+
+ if (n_audio_tracks) {
- Menu *play_menu = manage (new Menu);
- MenuList& play_items = play_menu->items();
- play_menu->set_name ("ArdourContextMenu");
+ Menu *track_menu = manage (new Menu);
+ MenuList& track_items = track_menu->items();
+ track_menu->set_name ("ArdourContextMenu");
+
+ /* Adding new material */
- play_items.push_back (MenuElem (_("Play from edit cursor"), mem_fun(*this, &Editor::play_from_edit_cursor)));
- play_items.push_back (MenuElem (_("Play from start"), mem_fun(*this, &Editor::play_from_start)));
- edit_items.push_back (MenuElem (_("Play"), *play_menu));
+ add_item_with_sensitivity (track_items, MenuElem (_("Insert selected region"), bind (mem_fun(*this, &Editor::insert_region_list_selection), 1.0f)), n_audio_tracks == 1);
+
+ add_item_with_sensitivity (track_items, MenuElem (_("Insert existing audio"), bind (mem_fun(*this, &Editor::add_external_audio_action), ImportToTrack)), n_audio_tracks == 1);
+
+ /* Nudge */
- /* Selection */
+ Menu *nudge_menu = manage (new Menu());
+ MenuList& nudge_items = nudge_menu->items();
+ nudge_menu->set_name ("ArdourContextMenu");
- Menu *select_menu = manage (new Menu);
- MenuList& select_items = select_menu->items();
- select_menu->set_name ("ArdourContextMenu");
-
- select_items.push_back (MenuElem (_("Select All in track"), bind (mem_fun(*this, &Editor::select_all_in_track), Selection::Set)));
- select_items.push_back (MenuElem (_("Select All"), bind (mem_fun(*this, &Editor::select_all), Selection::Set)));
- select_items.push_back (MenuElem (_("Invert selection in track"), mem_fun(*this, &Editor::invert_selection_in_track)));
- select_items.push_back (MenuElem (_("Invert selection"), mem_fun(*this, &Editor::invert_selection)));
- select_items.push_back (SeparatorElem());
- select_items.push_back (MenuElem (_("Select all after edit cursor"), bind (mem_fun(*this, &Editor::select_all_selectables_using_cursor), edit_cursor, true)));
- select_items.push_back (MenuElem (_("Select all before edit cursor"), bind (mem_fun(*this, &Editor::select_all_selectables_using_cursor), edit_cursor, false)));
- select_items.push_back (MenuElem (_("Select all after playhead"), bind (mem_fun(*this, &Editor::select_all_selectables_using_cursor), playhead_cursor, true)));
- select_items.push_back (MenuElem (_("Select all before playhead"), bind (mem_fun(*this, &Editor::select_all_selectables_using_cursor), playhead_cursor, false)));
+ str = selection->tracks.size() == 1 ? _("Nudge track forward") : _("Nude tracks forward");
+ nudge_items.push_back (MenuElem (str, (bind (mem_fun(*this, &Editor::nudge_selected_tracks), false, true))));
- edit_items.push_back (MenuElem (_("Select"), *select_menu));
+ str = selection->tracks.size() == 1 ? _("Nudge track after edit cursor forward") : _("Nudge tracks after edit cursor forward");
+
+ nudge_items.push_back (MenuElem (str, (bind (mem_fun(*this, &Editor::nudge_selected_tracks), true, true))));
- /* Cut-n-Paste */
+ str = selection->tracks.size() == 1 ? _("Nudge track backward") : _("Nudge tracks backward");
+
+ nudge_items.push_back (MenuElem (str, (bind (mem_fun(*this, &Editor::nudge_selected_tracks), false, false))));
- Menu *cutnpaste_menu = manage (new Menu);
- MenuList& cutnpaste_items = cutnpaste_menu->items();
- cutnpaste_menu->set_name ("ArdourContextMenu");
-
- cutnpaste_items.push_back (MenuElem (_("Cut"), mem_fun(*this, &Editor::cut)));
- cutnpaste_items.push_back (MenuElem (_("Copy"), mem_fun(*this, &Editor::copy)));
- cutnpaste_items.push_back (MenuElem (_("Paste"), bind (mem_fun(*this, &Editor::paste), 1.0f)));
+ str = selection->tracks.size() == 1 ? _("Nudge track after edit cursor backward") : _("Nudge tracks after edit cursor backward");
+
+ nudge_items.push_back (MenuElem (str, (bind (mem_fun(*this, &Editor::nudge_selected_tracks), true, false))));
+
+ track_items.push_back (MenuElem (_("Nudge"), *nudge_menu));
- Menu *nudge_menu = manage (new Menu());
- MenuList& nudge_items = nudge_menu->items();
- nudge_menu->set_name ("ArdourContextMenu");
-
- edit_items.push_back (SeparatorElem());
- nudge_items.push_back (MenuElem (_("Nudge entire track fwd"), (bind (mem_fun(*this, &Editor::nudge_track), false, true))));
- nudge_items.push_back (MenuElem (_("Nudge track after edit cursor fwd"), (bind (mem_fun(*this, &Editor::nudge_track), true, true))));
- nudge_items.push_back (MenuElem (_("Nudge entire track bwd"), (bind (mem_fun(*this, &Editor::nudge_track), false, false))));
- nudge_items.push_back (MenuElem (_("Nudge track after edit cursor bwd"), (bind (mem_fun(*this, &Editor::nudge_track), true, false))));
+ /* Freeze */
+ track_items.push_back (MenuElem (_("Freeze"), mem_fun(*this, &Editor::freeze_routes)));
+ track_items.push_back (MenuElem (_("Unfreeze"), mem_fun(*this, &Editor::unfreeze_routes)));
- edit_items.push_back (MenuElem (_("Nudge"), *nudge_menu));
+ str = selection->tracks.size() == 1 ? _("Track") : _("Tracks");
+ edit_items.push_back (MenuElem (str, *track_menu));
+ }
}
/* CURSOR SETTING AND MARKS AND STUFF */
void
Editor::set_snap_to (SnapType st)
-{
+{
snap_type = st;
string str = snap_type_strings[(int) st];
edit_cursor->set_position (0);
}
+ if ((prop = node.property ("mixer-width"))) {
+ editor_mixer_strip_width = Width (string_2_enum (prop->value(), editor_mixer_strip_width));
+ }
+
if ((prop = node.property ("zoom-focus"))) {
set_zoom_focus ((ZoomFocus) atoi (prop->value()));
}
if ((prop = node.property ("follow-playhead"))) {
bool yn = (prop->value() == "yes");
+ set_follow_playhead (yn);
RefPtr<Action> act = ActionManager::get_action (X_("Editor"), X_("toggle-follow-playhead"));
if (act) {
RefPtr<ToggleAction> tact = RefPtr<ToggleAction>::cast_dynamic(act);
- /* do it twice to force the change */
- tact->set_active (!yn);
- tact->set_active (yn);
+ if (tact->get_active() != yn) {
+ tact->set_active (yn);
+ }
}
}
-
if ((prop = node.property ("region-list-sort-type"))) {
region_list_sort_type = (Editing::RegionListSortType) -1; // force change
reset_region_list_sort_type(str2regionlistsorttype(prop->value()));
node->add_child_nocopy (*geometry);
}
+ maybe_add_mixer_strip_width (*node);
+
snprintf (buf, sizeof(buf), "%d", (int) zoom_focus);
node->add_property ("zoom-focus", buf);
snprintf (buf, sizeof(buf), "%f", frames_per_unit);
if (session->transport_stopped()) {
have_pending_keyboard_selection = false;
}
+
+ update_loop_range_view (true);
}
/* UNDO/REDO */
void
Editor::duplicate_dialog (bool dup_region)
{
- if (dup_region) {
- if (clicked_regionview == 0) {
- return;
- }
- } else {
- if (selection->time.length() == 0) {
- return;
- }
+ if (selection->regions.empty() && (selection->time.length() == 0)) {
+ return;
}
ArdourDialog win ("duplicate dialog");
- Entry entry;
Label label (_("Duplicate how many times?"));
+ Adjustment adjustment (1.0, 1.0, 1000000.0, 1.0, 5.0);
+ SpinButton spinner (adjustment);
+ win.get_vbox()->set_spacing (12);
win.get_vbox()->pack_start (label);
- win.add_action_widget (entry, RESPONSE_ACCEPT);
+
+ /* dialogs have ::add_action_widget() but that puts the spinner in the wrong
+ place, visually. so do this by hand.
+ */
+
+ win.get_vbox()->pack_start (spinner);
+ spinner.signal_activate().connect (sigc::bind (mem_fun (win, &ArdourDialog::response), RESPONSE_ACCEPT));
+
+ label.show ();
+ spinner.show ();
+
win.add_button (Stock::OK, RESPONSE_ACCEPT);
win.add_button (Stock::CANCEL, RESPONSE_CANCEL);
win.set_position (WIN_POS_MOUSE);
- entry.set_text ("1");
- set_size_request_to_display_given_text (entry, X_("12345678"), 20, 15);
- entry.select_region (0, -1);
- entry.grab_focus ();
-
+ spinner.grab_focus ();
switch (win.run ()) {
case RESPONSE_ACCEPT:
return;
}
- string text = entry.get_text();
- float times;
+ float times = adjustment.get_value();
- if (sscanf (text.c_str(), "%f", ×) == 1) {
- if (dup_region) {
- RegionSelection regions;
- regions.add (clicked_regionview);
- duplicate_some_regions (regions, times);
- } else {
- duplicate_selection (times);
- }
+ if (!selection->regions.empty()) {
+ duplicate_some_regions (selection->regions, times);
+ } else {
+ duplicate_selection (times);
}
}
Editor::edit_controls_button_release (GdkEventButton* ev)
{
if (Keyboard::is_context_menu_event (ev)) {
- ARDOUR_UI::instance()->add_route ();
+ ARDOUR_UI::instance()->add_route (this);
}
return TRUE;
}
if ((_show_measures = yn) == true) {
draw_measures ();
}
- DisplayControlChanged (ShowMeasures);
instant_save ();
}
}
/* catch up */
update_current_screen ();
}
- DisplayControlChanged (FollowPlayhead);
instant_save ();
}
}
label.show ();
dialog.add_button (_("Delete playlist"), RESPONSE_ACCEPT);
- dialog.add_button (_("Keep playlist"), RESPONSE_CANCEL);
+ dialog.add_button (_("Keep playlist"), RESPONSE_REJECT);
dialog.add_button (_("Cancel"), RESPONSE_CANCEL);
switch (dialog.run ()) {
return false;
}
+
+/** A new snapshot has been selected.
+ */
void
Editor::snapshot_display_selection_changed ()
{
bool
Editor::snapshot_display_button_press (GdkEventButton* ev)
{
- return false;
+ if (ev->button == 3) {
+ /* Right-click on the snapshot list. Work out which snapshot it
+ was over. */
+ Gtk::TreeModel::Path path;
+ Gtk::TreeViewColumn* col;
+ int cx;
+ int cy;
+ snapshot_display.get_path_at_pos ((int) ev->x, (int) ev->y, path, col, cx, cy);
+ Gtk::TreeModel::iterator iter = snapshot_display_model->get_iter (path);
+ if (iter) {
+ Gtk::TreeModel::Row row = *iter;
+ popup_snapshot_context_menu (ev->button, ev->time, row[snapshot_display_columns.real_name]);
+ }
+ return true;
+ }
+
+ return false;
+}
+
+
+/** Pop up the snapshot display context menu.
+ * @param button Button used to open the menu.
+ * @param time Menu open time.
+ * @snapshot_name Name of the snapshot that the menu click was over.
+ */
+
+void
+Editor::popup_snapshot_context_menu (int button, int32_t time, Glib::ustring snapshot_name)
+{
+ using namespace Menu_Helpers;
+
+ MenuList& items (snapshot_context_menu.items());
+ items.clear ();
+
+ const bool modification_allowed = (session->snap_name() != snapshot_name && session->name() != snapshot_name);
+
+ add_item_with_sensitivity (items, MenuElem (_("Remove"), bind (mem_fun (*this, &Editor::remove_snapshot), snapshot_name)), modification_allowed);
+
+ add_item_with_sensitivity (items, MenuElem (_("Rename"), bind (mem_fun (*this, &Editor::rename_snapshot), snapshot_name)), modification_allowed);
+
+ snapshot_context_menu.popup (button, time);
+}
+
+void
+Editor::rename_snapshot (Glib::ustring old_name)
+{
+ ArdourPrompter prompter(true);
+
+ string new_name;
+
+ prompter.set_name ("Prompter");
+ prompter.add_button (Gtk::Stock::SAVE, Gtk::RESPONSE_ACCEPT);
+ prompter.set_prompt (_("New name of snapshot"));
+ prompter.set_initial_text (old_name);
+
+ if (prompter.run() == RESPONSE_ACCEPT) {
+ prompter.get_result (new_name);
+ if (new_name.length()) {
+ session->rename_state (old_name, new_name);
+ redisplay_snapshots ();
+ }
+ }
+}
+
+
+void
+Editor::remove_snapshot (Glib::ustring name)
+{
+ vector<string> choices;
+
+ std::string prompt = string_compose (_("Do you really want to remove snapshot \"%1\" ?\n(cannot be undone)"), name);
+
+ choices.push_back (_("No, do nothing."));
+ choices.push_back (_("Yes, remove it."));
+
+ Gtkmm2ext::Choice prompter (prompt, choices);
+
+ if (prompter.run () == 1) {
+ session->remove_state (name);
+ redisplay_snapshots ();
+ }
}
void
Editor::new_playlists ()
{
begin_reversible_command (_("new playlists"));
- mapover_audio_tracks (mem_fun (*this, &Editor::mapped_use_new_playlist));
+ mapover_tracks (mem_fun (*this, &Editor::mapped_use_new_playlist));
commit_reversible_command ();
}
Editor::copy_playlists ()
{
begin_reversible_command (_("copy playlists"));
- mapover_audio_tracks (mem_fun (*this, &Editor::mapped_use_copy_playlist));
+ mapover_tracks (mem_fun (*this, &Editor::mapped_use_copy_playlist));
commit_reversible_command ();
}
Editor::clear_playlists ()
{
begin_reversible_command (_("clear playlists"));
- mapover_audio_tracks (mem_fun (*this, &Editor::mapped_clear_playlist));
+ mapover_tracks (mem_fun (*this, &Editor::mapped_clear_playlist));
commit_reversible_command ();
}
void
-Editor::mapped_use_new_playlist (AudioTimeAxisView& atv, uint32_t sz)
+Editor::mapped_use_new_playlist (RouteTimeAxisView& atv, uint32_t sz)
{
atv.use_new_playlist (sz > 1 ? false : true);
}
void
-Editor::mapped_use_copy_playlist (AudioTimeAxisView& atv, uint32_t sz)
+Editor::mapped_use_copy_playlist (RouteTimeAxisView& atv, uint32_t sz)
{
atv.use_copy_playlist (sz > 1 ? false : true);
}
void
-Editor::mapped_clear_playlist (AudioTimeAxisView& atv, uint32_t sz)
+Editor::mapped_clear_playlist (RouteTimeAxisView& atv, uint32_t sz)
{
atv.clear_playlist ();
}
instant_save ();
}
-void
-Editor::canvas_horizontally_scrolled ()
-{
- /* this is the core function that controls horizontal scrolling of the canvas. it is called
- whenever the horizontal_adjustment emits its "value_changed" signal. it executes in an
- idle handler, which is important because tempo_map_changed() should issue redraws immediately
- and not defer them to an idle handler.
- */
-
- leftmost_frame = (nframes_t) floor (horizontal_adjustment.get_value() * frames_per_unit);
- nframes_t rightmost_frame = leftmost_frame + current_page_frames ();
-
- if (rightmost_frame > last_canvas_frame) {
- last_canvas_frame = rightmost_frame;
- reset_scrolling_region ();
- }
-
- update_fixed_rulers ();
- tempo_map_changed (Change (0), true);
-}
-
void
Editor::queue_visual_change (nframes_t where)
{
/* the signal handler will do the rest */
} else {
update_fixed_rulers();
- tempo_map_changed (Change (0), true);
+ redisplay_tempo (true);
}
}
- return 0;
+ return 0; /* this is always a one-shot call */
}
struct EditorOrderTimeAxisSorter {
selection->tracks.sort (cmp);
}
+nframes_t
+Editor::edit_cursor_position(bool sync)
+{
+ if (sync && edit_cursor->current_frame != edit_cursor_clock.current_time()) {
+ edit_cursor_clock.set(edit_cursor->current_frame, true);
+ }
+
+ return edit_cursor->current_frame;
+}
projects / ardour.git / blobdiff