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

6 files changed, 304 insertions, 21 deletions

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<Playlist> 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<Region> 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<Region> 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<AudioPlaylist> (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<Region> 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<Region> 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<Region> 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> region, Menu_Helpers::MenuList& edit_items)
+Editor::add_region_context_items (AudioStreamView* sv, boost::shared_ptr<Region> 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<Region>
 	}
 	
 	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<AudioTimeAxisView*> (clicked_trackview);
+
+	if (atv == 0) {
+		return;
+	}
+
+	boost::shared_ptr<Diskstream> ds;
+	boost::shared_ptr<Playlist> 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<ARDOUR::Region>, Gtk::Menu_Helpers::MenuList&);
+	void add_region_context_items (AudioStreamView*, boost::shared_ptr<ARDOUR::Region>, Gtk::Menu_Helpers::MenuList&, nframes64_t position, bool multiple_regions_at_position);
 	void add_crossfade_context_items (AudioStreamView*, boost::shared_ptr<ARDOUR::Crossfade>, 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<TimeAxisView*> 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 <gtkmm/table.h>
+#include <gtkmm/stock.h>
+#include <ardour/region.h>
+
+#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> region = row[layering_order_columns.region];
+
+		region->raise_to_top ();
+	}
+}
+
+typedef boost::shared_ptr<Region> 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<RegionList> 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<Playlist>  & 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 <gtkmm/dialog.h>
+#include <gtkmm/liststore.h>
+#include <gtkmm/treeview.h>
+#include <gtkmm/scrolledwindow.h>
+
+#include <ardour/region.h>
+#include <ardour/playlist.h>
+
+#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<ARDOUR::Playlist>  & pl, nframes64_t position);
+	void maybe_present ();
+	
+  protected:
+	virtual bool on_key_press_event (GdkEventKey* event);
+
+  private:
+	boost::shared_ptr<ARDOUR::Playlist> 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<std::string> name;
+		Gtk::TreeModelColumn<boost::shared_ptr<ARDOUR::Region> > region;
+	};
+	LayeringOrderColumns layering_order_columns;
+	Glib::RefPtr<Gtk::ListStore> 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__ */