From 72d9f9df468981dc06536a51db8f92b79d429c58 Mon Sep 17 00:00:00 2001 From: Paul Davis Date: Thu, 12 Nov 2009 01:14:21 +0000 Subject: [PATCH] JAG's new region layer editor, tweaked by me to (a) hide editor if we click in a location with just 1 region under the mouse (b) automatically update to reflect playlist modification outside of the layering editor (c) add a clock and a track name to give a bit more context to the editor git-svn-id: svn://localhost/ardour2/branches/2.0-ongoing@6067 d708f5d6-7413-0410-9779-e7cbd77b26cf --- gtk2_ardour/SConscript | 1 + gtk2_ardour/editor.cc | 81 ++++++--- gtk2_ardour/editor.h | 8 +- gtk2_ardour/editor_mouse.cc | 1 + gtk2_ardour/region_layering_order_editor.cc | 172 ++++++++++++++++++++ gtk2_ardour/region_layering_order_editor.h | 62 +++++++ libs/ardour/ardour/playlist.h | 1 + libs/ardour/playlist.cc | 38 ++++- 8 files changed, 337 insertions(+), 27 deletions(-) create mode 100644 gtk2_ardour/region_layering_order_editor.cc create mode 100644 gtk2_ardour/region_layering_order_editor.h diff --git a/gtk2_ardour/SConscript b/gtk2_ardour/SConscript index 8aaffc042e..2ebbe8b63c 100644 --- a/gtk2_ardour/SConscript +++ b/gtk2_ardour/SConscript @@ -208,6 +208,7 @@ redirect_automation_line.cc redirect_automation_time_axis.cc redirect_box.cc region_gain_line.cc +region_layering_order_editor.cc region_selection.cc region_view.cc rhythm_ferret.cc diff --git a/gtk2_ardour/editor.cc b/gtk2_ardour/editor.cc index a0b01c06c4..bbb589e74f 100644 --- a/gtk2_ardour/editor.cc +++ b/gtk2_ardour/editor.cc @@ -82,6 +82,7 @@ #include "sfdb_ui.h" #include "rhythm_ferret.h" #include "actions.h" +#include "region_layering_order_editor.h" #ifdef FFT_ANALYSIS #include "analysis_window.h" @@ -367,6 +368,7 @@ Editor::Editor () _dragging_hscrollbar = false; select_new_marker = false; rhythm_ferret = 0; + layering_order_editor = 0; allow_vertical_scroll = false; no_save_visual = false; need_resize_line = false; @@ -1660,21 +1662,21 @@ Editor::build_track_region_context_menu (nframes64_t frame) boost::shared_ptr pl; if ((ds = atv->get_diskstream()) && ((pl = ds->playlist()))) { - Playlist::RegionList* regions = pl->regions_at ((nframes64_t) floor ( (double)frame * ds->speed())); + + nframes64_t frame_pos = (nframes64_t) floor ((double)frame * ds->speed()); + uint32_t regions_at = pl->count_regions_at (frame_pos); if (selection->regions.size() > 1) { // there's already a multiple selection: just add a // single region context menu that will act on all // selected regions boost::shared_ptr dummy_region; // = NULL - add_region_context_items (atv->audio_view(), dummy_region, edit_items); + add_region_context_items (atv->audio_view(), dummy_region, edit_items, frame_pos, regions_at > 1); } else { - for (Playlist::RegionList::reverse_iterator i = regions->rbegin(); i != regions->rend(); ++i) { - add_region_context_items (atv->audio_view(), (*i), edit_items); - } + // Find the topmost region and make the context menu for it + boost::shared_ptr top_region = pl->top_region_at (frame_pos); + add_region_context_items (atv->audio_view(), top_region, edit_items, frame_pos, regions_at > 1); } - - delete regions; } } @@ -1699,7 +1701,6 @@ Editor::build_track_crossfade_context_menu (nframes64_t frame) if ((ds = atv->get_diskstream()) && ((pl = ds->playlist()) != 0) && ((apl = boost::dynamic_pointer_cast (pl)) != 0)) { - Playlist::RegionList* regions = pl->regions_at (frame); AudioPlaylist::Crossfades xfades; apl->crossfades_at (frame, xfades); @@ -1710,18 +1711,20 @@ Editor::build_track_crossfade_context_menu (nframes64_t frame) add_crossfade_context_items (atv->audio_view(), (*i), edit_items, many); } - if (selection->regions.size() > 1) { - // there's already a multiple selection: just add a - // single region context menu that will act on all - // selected regions - boost::shared_ptr dummy_region; // = NULL - add_region_context_items (atv->audio_view(), dummy_region, edit_items); - } else { - for (Playlist::RegionList::reverse_iterator i = regions->rbegin(); i != regions->rend(); ++i) { - add_region_context_items (atv->audio_view(), (*i), edit_items); - } + nframes64_t frame_pos = (nframes64_t) floor ((double)frame * ds->speed()); + uint32_t regions_at = pl->count_regions_at (frame_pos); + + if (selection->regions.size() > 1) { + // there's already a multiple selection: just add a + // single region context menu that will act on all + // selected regions + boost::shared_ptr dummy_region; // = NULL + add_region_context_items (atv->audio_view(), dummy_region, edit_items, frame_pos, regions_at > 1); // OR frame ??? + } else { + // Find the topmost region and make the context menu for it + boost::shared_ptr top_region = pl->top_region_at (frame_pos); + add_region_context_items (atv->audio_view(), top_region, edit_items, frame_pos, regions_at > 1); // OR frame ??? } - delete regions; } } @@ -1842,7 +1845,8 @@ Editor::xfade_edit_right_region () } void -Editor::add_region_context_items (AudioStreamView* sv, boost::shared_ptr region, Menu_Helpers::MenuList& edit_items) +Editor::add_region_context_items (AudioStreamView* sv, boost::shared_ptr region, Menu_Helpers::MenuList& edit_items, + nframes64_t position, bool multiple_region_at_position) { using namespace Menu_Helpers; Gtk::MenuItem* foo_item; @@ -2068,6 +2072,9 @@ Editor::add_region_context_items (AudioStreamView* sv, boost::shared_ptr } edit_items.push_back (MenuElem (menu_item_name, *region_menu)); + if (multiple_region_at_position && (layering_order_editor == 0 || !layering_order_editor->is_visible ())) { + edit_items.push_back (MenuElem (_("Choose top region"), (bind (mem_fun(*this, &Editor::change_region_layering_order), position)))); + } edit_items.push_back (SeparatorElem()); } @@ -5108,3 +5115,37 @@ Editor::idle_resize () resize_idle_id = -1; return false; } + +void +Editor::change_region_layering_order (nframes64_t position) +{ + if (clicked_regionview == 0) { + return; + } + + AudioTimeAxisView* atv = dynamic_cast (clicked_trackview); + + if (atv == 0) { + return; + } + + boost::shared_ptr ds; + boost::shared_ptr pl; + + if ((ds = atv->get_diskstream()) && ((pl = ds->playlist()))) { + + if (layering_order_editor == 0) { + layering_order_editor = new RegionLayeringOrderEditor(*this); + } + layering_order_editor->set_context (atv->name(), session, pl, position); + layering_order_editor->maybe_present (); + } +} + +void +Editor::update_region_layering_order_editor (nframes64_t frame) +{ + if (layering_order_editor && layering_order_editor->is_visible ()) { + change_region_layering_order (frame); + } +} diff --git a/gtk2_ardour/editor.h b/gtk2_ardour/editor.h index 3a246e2f2d..32d1305c90 100644 --- a/gtk2_ardour/editor.h +++ b/gtk2_ardour/editor.h @@ -108,6 +108,7 @@ class AudioStreamView; class ControlPoint; class SoundFileOmega; class RhythmFerret; +class RegionLayeringOrderEditor; #ifdef FFT_ANALYSIS class AnalysisWindow; #endif @@ -577,7 +578,7 @@ class Editor : public PublicEditor Gtk::Menu* build_track_selection_context_menu (nframes64_t); void add_dstream_context_items (Gtk::Menu_Helpers::MenuList&); void add_bus_context_items (Gtk::Menu_Helpers::MenuList&); - void add_region_context_items (AudioStreamView*, boost::shared_ptr, Gtk::Menu_Helpers::MenuList&); + void add_region_context_items (AudioStreamView*, boost::shared_ptr, Gtk::Menu_Helpers::MenuList&, nframes64_t position, bool multiple_regions_at_position); void add_crossfade_context_items (AudioStreamView*, boost::shared_ptr, Gtk::Menu_Helpers::MenuList&, bool many); void add_selection_context_items (Gtk::Menu_Helpers::MenuList&); @@ -1069,6 +1070,7 @@ class Editor : public PublicEditor void set_region_lock_style (ARDOUR::Region::PositionLockStyle); void raise_region (); void raise_region_to_top (); + void change_region_layering_order (nframes64_t); void lower_region (); void lower_region_to_bottom (); void split_region (); @@ -2238,6 +2240,10 @@ public: bool idle_resize(); friend gboolean _idle_resize (gpointer); std::vector pending_resizes; + + RegionLayeringOrderEditor* layering_order_editor; + + void update_region_layering_order_editor (nframes64_t frame); }; #endif /* __ardour_editor_h__ */ diff --git a/gtk2_ardour/editor_mouse.cc b/gtk2_ardour/editor_mouse.cc index 980f3709cb..c239a98d52 100644 --- a/gtk2_ardour/editor_mouse.cc +++ b/gtk2_ardour/editor_mouse.cc @@ -922,6 +922,7 @@ Editor::button_release_handler (ArdourCanvas::Item* item, GdkEvent* event, ItemT } button_selection (item, event, item_type); + update_region_layering_order_editor (where); /* edit events get handled here */ diff --git a/gtk2_ardour/region_layering_order_editor.cc b/gtk2_ardour/region_layering_order_editor.cc new file mode 100644 index 0000000000..84ef12dd9d --- /dev/null +++ b/gtk2_ardour/region_layering_order_editor.cc @@ -0,0 +1,172 @@ +#include +#include +#include + +#include "region_layering_order_editor.h" +#include "i18n.h" +#include "public_editor.h" +#include "utils.h" + +using namespace Gtk; +using namespace ARDOUR; + +RegionLayeringOrderEditor::RegionLayeringOrderEditor (PublicEditor& pe) +: ArdourDialog (pe, _("RegionLayeringOrderEditor"), false, false) + , playlist () + , position () + , in_row_change (false) + , regions_at_position (0) + , layering_order_columns () + , layering_order_model (Gtk::ListStore::create (layering_order_columns)) + , layering_order_display () + , clock ("layer dialog", true, "TransportClock", false, false, false) + , scroller () + , the_editor(pe) +{ + set_name ("RegionLayeringOrderEditorWindow"); + + layering_order_display.set_model (layering_order_model); + + layering_order_display.append_column (_("Region Name"), layering_order_columns.name); + layering_order_display.set_headers_visible (true); + layering_order_display.set_headers_clickable (true); + layering_order_display.set_reorderable (false); + layering_order_display.set_rules_hint (true); + + scroller.set_border_width (10); + scroller.set_policy (Gtk::POLICY_AUTOMATIC, Gtk::POLICY_AUTOMATIC); + scroller.add (layering_order_display); + + Gtk::Table* table = manage (new Gtk::Table (7, 11)); + table->set_size_request (300, 250); + table->attach (scroller, 0, 7, 0, 5); + + clock.set_mode (AudioClock::BBT); + + HBox* hbox = manage (new HBox); + hbox->pack_start (clock, true, false); + + get_vbox()->set_spacing (6); + get_vbox()->pack_start (label, false, false); + get_vbox()->pack_start (*hbox, false, false); + get_vbox()->pack_start (*table); + + table->set_name ("RegionLayeringOrderTable"); + layering_order_display.set_name ("RegionLayeringOrderDisplay"); + + layering_order_display.get_selection ()->signal_changed ().connect (mem_fun (*this, &RegionLayeringOrderEditor::row_clicked)); + + layering_order_display.grab_focus (); + + set_title (_("Choose Top Region")); + show_all(); +} + +RegionLayeringOrderEditor::~RegionLayeringOrderEditor () +{ +} + +void +RegionLayeringOrderEditor::row_clicked () +{ + if (in_row_change) { + return; + } + + TreeModel::iterator iter = layering_order_display.get_selection()->get_selected(); + + if (iter) { + TreeModel::Row row = *iter; + boost::shared_ptr region = row[layering_order_columns.region]; + + region->raise_to_top (); + } +} + +typedef boost::shared_ptr RegionPtr; + +struct RegionCompareByLayer { + bool operator() (RegionPtr a, RegionPtr b) const { + return a->layer() > b->layer(); + } +}; + +void +RegionLayeringOrderEditor::refill () +{ + regions_at_position = 0; + + if (!playlist) { + return; + } + + typedef Playlist::RegionList RegionList; + + in_row_change = true; + + layering_order_model->clear (); + + boost::shared_ptr region_list(playlist->regions_at (position)); + + regions_at_position = region_list->size(); + + if (regions_at_position < 2) { + playlist_modified_connection.disconnect (); + hide (); + in_row_change = false; + return; + } + + RegionCompareByLayer cmp; + region_list->sort (cmp); + + for (RegionList::const_iterator i = region_list->begin(); i != region_list->end(); ++i) { + TreeModel::Row newrow = *(layering_order_model->append()); + newrow[layering_order_columns.name] = (*i)->name(); + newrow[layering_order_columns.region] = *i; + } + + in_row_change = false; +} + +void +RegionLayeringOrderEditor::set_context (const string& a_name, Session* s, const boost::shared_ptr & pl, nframes64_t pos) +{ + label.set_text (a_name); + + clock.set_session (s); + clock.set (pos, true, 0, 0); + + playlist_modified_connection.disconnect (); + playlist = pl; + playlist_modified_connection = playlist->Modified.connect (mem_fun (*this, &RegionLayeringOrderEditor::playlist_modified)); + + position = pos; + refill (); +} + +bool +RegionLayeringOrderEditor::on_key_press_event (GdkEventKey* ev) +{ + bool result = key_press_focus_accelerator_handler (the_editor, ev); + if (!result) { + result = ArdourDialog::on_key_press_event (ev); + } + return result; +} + +void +RegionLayeringOrderEditor::maybe_present () +{ + if (regions_at_position < 2) { + hide (); + return; + } + present (); +} + +void +RegionLayeringOrderEditor::playlist_modified () +{ + refill (); +} diff --git a/gtk2_ardour/region_layering_order_editor.h b/gtk2_ardour/region_layering_order_editor.h new file mode 100644 index 0000000000..d8b76e951e --- /dev/null +++ b/gtk2_ardour/region_layering_order_editor.h @@ -0,0 +1,62 @@ +#ifndef __gtk2_ardour_region_layering_order_editor_h__ +#define __gtk2_ardour_region_layering_order_editor_h__ + +#include +#include +#include +#include + +#include +#include + +#include "ardour_dialog.h" +#include "audio_clock.h" + +class PublicEditor; + +namespace ARDOUR { + class Session; +} + +class RegionLayeringOrderEditor : public ArdourDialog +{ + public: + RegionLayeringOrderEditor (PublicEditor&); + virtual ~RegionLayeringOrderEditor (); + + void set_context(const std::string& name, ARDOUR::Session* s, const boost::shared_ptr & pl, nframes64_t position); + void maybe_present (); + + protected: + virtual bool on_key_press_event (GdkEventKey* event); + + private: + boost::shared_ptr playlist; + nframes64_t position; + bool in_row_change; + uint32_t regions_at_position; + + sigc::connection playlist_modified_connection; + + struct LayeringOrderColumns : public Gtk::TreeModel::ColumnRecord { + LayeringOrderColumns () { + add (name); + add (region); + } + Gtk::TreeModelColumn name; + Gtk::TreeModelColumn > region; + }; + LayeringOrderColumns layering_order_columns; + Glib::RefPtr layering_order_model; + Gtk::TreeView layering_order_display; + AudioClock clock; + Gtk::Label label; + Gtk::ScrolledWindow scroller; // Available layers + PublicEditor& the_editor; + + void row_clicked(); + void refill (); + void playlist_modified (); +}; + +#endif /* __gtk2_ardour_region_layering_order_editor_h__ */ diff --git a/libs/ardour/ardour/playlist.h b/libs/ardour/ardour/playlist.h index 9e30130d75..4848573f1e 100644 --- a/libs/ardour/ardour/playlist.h +++ b/libs/ardour/ardour/playlist.h @@ -103,6 +103,7 @@ class Playlist : public PBD::StatefulDestructible, public boost::enable_shared_f boost::shared_ptr copy (list&, bool result_is_hidden = true); int paste (boost::shared_ptr, nframes_t position, float times); + uint32_t count_regions_at (nframes_t frame); RegionList* regions_at (nframes_t frame); RegionList* regions_touched (nframes_t start, nframes_t end); RegionList* regions_to_read (nframes_t start, nframes_t end); diff --git a/libs/ardour/playlist.cc b/libs/ardour/playlist.cc index 3bd4b84781..e8f51d361a 100644 --- a/libs/ardour/playlist.cc +++ b/libs/ardour/playlist.cc @@ -31,6 +31,7 @@ #include #include #include +#include #include #include @@ -1371,6 +1372,21 @@ Playlist::regions_at (nframes_t frame) return find_regions_at (frame); } +uint32_t +Playlist::count_regions_at (nframes_t frame) +{ + RegionLock rlock (this); + uint32_t cnt = 0; + + for (RegionList::iterator i = regions.begin(); i != regions.end(); ++i) { + if ((*i)->covers (frame)) { + cnt++; + } + } + + return cnt; +} + boost::shared_ptr Playlist::top_region_at (nframes_t frame) @@ -1989,10 +2005,10 @@ Playlist::relayer () void Playlist::raise_region (boost::shared_ptr region) { - uint32_t rsz = regions.size(); + layer_t top = regions.size() - 1; layer_t target = region->layer() + 1U; - if (target >= rsz) { + if (target >= top) { /* its already at the effective top */ return; } @@ -2024,14 +2040,14 @@ Playlist::raise_region_to_top (boost::shared_ptr region) break; } - RegionList::size_type sz = regions.size(); + layer_t top = regions.size() - 1; - if (region->layer() >= (sz - 1)) { + if (region->layer() >= top) { /* already on the top */ return; } - move_region_to_layer (sz, region, 1); + move_region_to_layer (top, region, 1); /* mark the region's last_layer_op as now, so that it remains on top when doing future relayers (until something else takes over) */ @@ -2069,6 +2085,10 @@ Playlist::move_region_to_layer (layer_t target_layer, boost::shared_ptr list layerinfo; layer_t dest; + _session.begin_reversible_command (_("change region layer")); + + XMLNode& before (get_state()); + { RegionLock rlock (const_cast (this)); @@ -2130,7 +2150,13 @@ Playlist::move_region_to_layer (layer_t target_layer, boost::shared_ptr check_dependents (region, false); #endif - + + XMLNode& after (get_state()); + + _session.add_command (new MementoCommand(*this, &before, &after)); + + _session.commit_reversible_command (); + return 0; } -- 2.30.2