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
#include "sfdb_ui.h"
#include "rhythm_ferret.h"
#include "actions.h"
+#include "region_layering_order_editor.h"
#ifdef FFT_ANALYSIS
#include "analysis_window.h"
_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;
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;
}
}
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);
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;
}
}
}
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;
}
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());
}
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);
+ }
+}
class ControlPoint;
class SoundFileOmega;
class RhythmFerret;
+class RegionLayeringOrderEditor;
#ifdef FFT_ANALYSIS
class AnalysisWindow;
#endif
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&);
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 ();
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__ */
}
button_selection (item, event, item_type);
+ update_region_layering_order_editor (where);
/* edit events get handled here */
--- /dev/null
+#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 ();
+}
--- /dev/null
+#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__ */
boost::shared_ptr<Playlist> copy (list<AudioRange>&, bool result_is_hidden = true);
int paste (boost::shared_ptr<Playlist>, 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);
#include <pbd/stl_delete.h>
#include <pbd/xml++.h>
#include <pbd/stacktrace.h>
+#include <pbd/memento_command.h>
#include <ardour/playlist.h>
#include <ardour/session.h>
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<Region>
Playlist::top_region_at (nframes_t frame)
void
Playlist::raise_region (boost::shared_ptr<Region> 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;
}
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)
*/
list<LayerInfo> layerinfo;
layer_t dest;
+ _session.begin_reversible_command (_("change region layer"));
+
+ XMLNode& before (get_state());
+
{
RegionLock rlock (const_cast<Playlist *> (this));
check_dependents (region, false);
#endif
-
+
+ XMLNode& after (get_state());
+
+ _session.add_command (new MementoCommand<Playlist>(*this, &before, &after));
+
+ _session.commit_reversible_command ();
+
return 0;
}
projects / ardour.git / commitdiff