/*
- Copyright (C) 2001-2007 Paul Davis
+ Copyright (C) 2001-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
*/
#include <cmath>
-#include <cassert>
#include <utility>
#include <gtkmm.h>
#include <gtkmm2ext/gtk_ui.h>
-#include <ardour/midi_playlist.h>
-#include <ardour/midi_region.h>
-#include <ardour/midi_source.h>
-#include <ardour/midi_diskstream.h>
-#include <ardour/midi_track.h>
-#include <ardour/smf_source.h>
-#include <ardour/region_factory.h>
+#include "canvas/line_set.h"
+#include "canvas/rectangle.h"
-#include "midi_streamview.h"
-#include "region_view.h"
+#include "ardour/midi_region.h"
+#include "ardour/midi_source.h"
+#include "ardour/midi_track.h"
+#include "ardour/operations.h"
+#include "ardour/region_factory.h"
+#include "ardour/session.h"
+#include "ardour/smf_source.h"
+
+#include "gui_thread.h"
#include "midi_region_view.h"
+#include "midi_streamview.h"
#include "midi_time_axis.h"
-#include "canvas-simplerect.h"
-#include "region_selection.h"
-#include "selection.h"
+#include "midi_util.h"
#include "public_editor.h"
-#include "ardour_ui.h"
+#include "region_selection.h"
+#include "region_view.h"
#include "rgb_macros.h"
-#include "gui_thread.h"
+#include "selection.h"
+#include "ui_config.h"
#include "utils.h"
-#include "simplerect.h"
-#include "lineset.h"
+
+#include "pbd/i18n.h"
using namespace std;
using namespace ARDOUR;
+using namespace ARDOUR_UI_UTILS;
using namespace PBD;
using namespace Editing;
, _highest_note(71)
, _data_note_min(60)
, _data_note_max(71)
+ , _note_lines (0)
+ , _updates_suspended (false)
{
- if (tv.is_track())
- stream_base_color = ARDOUR_UI::config()->canvasvar_MidiTrackBase.get();
- else
- stream_base_color = ARDOUR_UI::config()->canvasvar_MidiBusBase.get();
-
- use_rec_regions = tv.editor().show_waveforms_recording ();
-
/* use a group dedicated to MIDI underlays. Audio underlays are not in this group. */
- midi_underlay_group = new ArdourCanvas::Group (*canvas_group);
+ midi_underlay_group = new ArdourCanvas::Container (_canvas_group);
midi_underlay_group->lower_to_bottom();
- /* put the note lines in the timeaxisview's group, so it
- can be put below ghost regions from MIDI underlays*/
- _note_lines = new ArdourCanvas::LineSet(*canvas_group, ArdourCanvas::LineSet::Horizontal);
+ /* put the note lines in the timeaxisview's group, so it
+ can be put below ghost regions from MIDI underlays
+ */
+ _note_lines = new ArdourCanvas::LineSet (_canvas_group, ArdourCanvas::LineSet::Horizontal);
- _note_lines->property_x1() = 0;
- _note_lines->property_y1() = 0;
- _note_lines->property_x2() = trackview().editor().frame_to_pixel (max_frames);
- _note_lines->property_y2() = 0;
+ _note_lines->Event.connect(
+ sigc::bind(sigc::mem_fun(_trackview.editor(),
+ &PublicEditor::canvas_stream_view_event),
+ _note_lines, &_trackview));
- _note_lines->signal_event().connect (bind (mem_fun (_trackview.editor(), &PublicEditor::canvas_stream_view_event), _note_lines, &_trackview));
_note_lines->lower_to_bottom();
- ColorsChanged.connect(mem_fun(*this, &MidiStreamView::draw_note_lines));
-
+ color_handler ();
+
+ UIConfiguration::instance().ColorsChanged.connect(sigc::mem_fun(*this, &MidiStreamView::color_handler));
+
note_range_adjustment.set_page_size(_highest_note - _lowest_note);
note_range_adjustment.set_value(_lowest_note);
-
- note_range_adjustment.signal_value_changed().connect (mem_fun (*this, &MidiStreamView::note_range_adjustment_changed));
+
+ note_range_adjustment.signal_value_changed().connect(
+ sigc::mem_fun(*this, &MidiStreamView::note_range_adjustment_changed));
}
MidiStreamView::~MidiStreamView ()
{
}
-static void
-veto_note_range(uint8_t& min, uint8_t& max)
+RegionView*
+MidiStreamView::create_region_view (boost::shared_ptr<Region> r, bool /*wfd*/, bool recording)
{
- /* Legal notes, thanks */
- if (max > 127)
- max = 127;
- if (min > 127)
- min = 127;
-
- /* Always display at least one octave in [0, 127] */
- if (max == 127) {
- if (min > (127 - 11)) {
- min = 127 - 11;
- }
- } else if (max < min + 11) {
- uint8_t d = 11 - (max - min);
- if (max + d/2 > 127) {
- min -= d;
- } else {
- min -= d / 2;
- max += d / 2;
- }
+ boost::shared_ptr<MidiRegion> region = boost::dynamic_pointer_cast<MidiRegion> (r);
+
+ if (region == 0) {
+ return 0;
+ }
+
+ RegionView* region_view = NULL;
+ if (recording) {
+ region_view = new MidiRegionView (
+ _canvas_group, _trackview, region,
+ _samples_per_pixel, region_color, recording,
+ TimeAxisViewItem::Visibility(TimeAxisViewItem::ShowFrame));
+ } else {
+ region_view = new MidiRegionView (_canvas_group, _trackview, region,
+ _samples_per_pixel, region_color);
}
- assert(max - min >= 11);
- assert(max < 127);
- assert(min < 127);
+
+ region_view->init (false);
+
+ return region_view;
}
RegionView*
-MidiStreamView::add_region_view_internal (boost::shared_ptr<Region> r, bool wfd, bool recording)
+MidiStreamView::add_region_view_internal (boost::shared_ptr<Region> r, bool wait_for_data, bool recording)
{
boost::shared_ptr<MidiRegion> region = boost::dynamic_pointer_cast<MidiRegion> (r);
- if (region == 0) {
- return NULL;
+ if (!region) {
+ return 0;
}
- MidiRegionView *region_view;
- list<RegionView *>::iterator i;
-
- for (i = region_views.begin(); i != region_views.end(); ++i) {
+ for (list<RegionView*>::iterator i = region_views.begin(); i != region_views.end(); ++i) {
if ((*i)->region() == r) {
-
+
/* great. we already have a MidiRegionView for this Region. use it again. */
(*i)->set_valid (true);
-
- display_region(dynamic_cast<MidiRegionView*>(*i), wfd);
- return NULL;
+ display_region(dynamic_cast<MidiRegionView*>(*i), wait_for_data);
+
+ return 0;
}
}
-
- region_view = new MidiRegionView (canvas_group, _trackview, region,
- _samples_per_unit, region_color);
-
- region_view->init (region_color, false);
+
+ MidiRegionView* region_view = dynamic_cast<MidiRegionView*> (create_region_view (r, wait_for_data, recording));
+ if (region_view == 0) {
+ return 0;
+ }
+
region_views.push_front (region_view);
-
+
/* display events and find note range */
- display_region(region_view, wfd);
+ display_region (region_view, wait_for_data);
+
+ /* fit note range if we are importing */
+ if (_trackview.session()->operation_in_progress (Operations::insert_file)) {
+ set_note_range (ContentsRange);
+ }
/* catch regionview going away */
- region->GoingAway.connect (bind (mem_fun (*this, &MidiStreamView::remove_region_view), region));
-
+ boost::weak_ptr<Region> wr (region); // make this explicit
+ region->DropReferences.connect (*this, invalidator (*this), boost::bind (&MidiStreamView::remove_region_view, this, wr), gui_context());
+
RegionViewAdded (region_view);
return region_view;
void
MidiStreamView::display_region(MidiRegionView* region_view, bool load_model)
{
- if ( ! region_view)
+ if (!region_view) {
return;
-
- region_view->enable_display(true);
+ }
+
+ region_view->enable_display (true);
+ region_view->set_height (child_height());
boost::shared_ptr<MidiSource> source(region_view->midi_region()->midi_source(0));
+ if (!source) {
+ error << _("attempt to display MIDI region with no source") << endmsg;
+ return;
+ }
- if (load_model)
- source->load_model();
+ if (load_model) {
+ Glib::Threads::Mutex::Lock lm(source->mutex());
+ source->load_model(lm);
+ }
+
+ if (!source->model()) {
+ error << _("attempt to display MIDI region with no model") << endmsg;
+ return;
+ }
_range_dirty = update_data_note_range(
- source->model()->lowest_note(),
- source->model()->highest_note());
+ source->model()->lowest_note(),
+ source->model()->highest_note());
// Display region contents
region_view->display_model(source->model());
}
+
void
-MidiStreamView::display_diskstream (boost::shared_ptr<Diskstream> ds)
+MidiStreamView::display_track (boost::shared_ptr<Track> tr)
{
- StreamView::display_diskstream(ds);
+ StreamView::display_track (tr);
+
draw_note_lines();
+
NoteRangeChanged();
}
-
+
+void
+MidiStreamView::update_contents_metrics(boost::shared_ptr<Region> r)
+{
+ boost::shared_ptr<MidiRegion> mr = boost::dynamic_pointer_cast<MidiRegion>(r);
+ if (mr) {
+ Glib::Threads::Mutex::Lock lm(mr->midi_source(0)->mutex());
+ mr->midi_source(0)->load_model(lm);
+ _range_dirty = update_data_note_range(
+ mr->model()->lowest_note(),
+ mr->model()->highest_note());
+ }
+}
+
bool
MidiStreamView::update_data_note_range(uint8_t min, uint8_t max)
{
return dirty;
}
-// FIXME: code duplication with AudioStreamView
void
-MidiStreamView::redisplay_diskstream ()
+MidiStreamView::redisplay_track ()
{
- list<RegionView *>::iterator i, tmp;
+ if (!_trackview.is_midi_track()) {
+ return;
+ }
+
+ list<RegionView*>::iterator i;
+ // Load models if necessary, and find note range of all our contents
_range_dirty = false;
_data_note_min = 127;
_data_note_max = 0;
-
- for (i = region_views.begin(); i != region_views.end(); ++i) {
- (*i)->set_valid (false);
- (*i)->enable_display (false);
-
- // Load model if it isn't already, to get note range
- MidiRegionView* mrv = dynamic_cast<MidiRegionView*>(*i);
- if (mrv) {
- mrv->midi_region()->midi_source(0)->load_model();
- _range_dirty = update_data_note_range(
- mrv->midi_region()->model()->lowest_note(),
- mrv->midi_region()->model()->highest_note());
- }
- }
+ _trackview.track()->playlist()->foreach_region(
+ sigc::mem_fun (*this, &StreamView::update_contents_metrics));
// No notes, use default range
if (!_range_dirty) {
_data_note_min = 60;
_data_note_max = 71;
}
-
- bool range_changed = false;
- // Extend visible range to show newly recorded data, if necessary
- if (_data_note_min < _lowest_note) {
- _lowest_note = _data_note_min;
- range_changed = true;
- }
- if (_data_note_max > _highest_note) {
- _highest_note = _data_note_max;
- range_changed = true;
+ // Flag region views as invalid and disable drawing
+ for (i = region_views.begin(); i != region_views.end(); ++i) {
+ (*i)->set_valid(false);
+ (*i)->enable_display(false);
}
-
- veto_note_range(_lowest_note, _highest_note);
-
- if (_trackview.is_midi_track()) {
- _trackview.get_diskstream()->playlist()->foreach_region (
- static_cast<StreamView*>(this), &StreamView::add_region_view);
- }
-
- RegionViewList copy;
-
- /* Place regions */
- for (i = region_views.begin(); i != region_views.end(); ) {
- tmp = i;
- tmp++;
-
- if (!(*i)->is_valid()) {
- delete *i;
- region_views.erase (i);
- i = tmp;
- continue;
- } else {
- (*i)->enable_display(true);
- (*i)->set_height(height); // apply note range
- }
-
- /* Sort regionviews by layer so that when we call region_layered ()
- the canvas layering works out (in non-stacked mode). */
-
- if (copy.size() == 0) {
- copy.push_front((*i));
- i = tmp;
- continue;
- }
- RegionViewList::iterator k = copy.begin();
- RegionViewList::iterator l = copy.end();
- l--;
-
- if ((*i)->region()->layer() <= (*k)->region()->layer()) {
- copy.push_front((*i));
- i = tmp;
- continue;
- } else if ((*i)->region()->layer() >= (*l)->region()->layer()) {
- copy.push_back((*i));
- i = tmp;
- continue;
- }
+ // Add and display region views, and flag them as valid
+ _trackview.track()->playlist()->foreach_region(
+ sigc::hide_return (sigc::mem_fun (*this, &StreamView::add_region_view)));
- for (RegionViewList::iterator j = copy.begin(); j != copy.end(); ++j) {
- if ((*j)->region()->layer() >= (*i)->region()->layer()) {
- copy.insert(j, (*i));
- break;
- }
- }
+ // Stack regions by layer, and remove invalid regions
+ layer_regions();
- i = tmp;
- }
-
- /* Fix canvas layering */
- for (RegionViewList::iterator j = copy.begin(); j != copy.end(); ++j) {
- region_layered (*j);
- }
-
- /* Update note range and re-draw note lines if necessary */
- apply_note_range(_lowest_note, _highest_note);
- NoteRangeChanged();
+ // Update note range (not regions which are correct) and draw note lines
+ apply_note_range(_lowest_note, _highest_note, false);
}
MidiStreamView::update_contents_height ()
{
StreamView::update_contents_height();
- _note_lines->property_y2() = height;
- draw_note_lines();
+
+ _note_lines->set_extent (ArdourCanvas::COORD_MAX);
+
+ apply_note_range (lowest_note(), highest_note(), true);
}
-
+
void
MidiStreamView::draw_note_lines()
{
+ if (!_note_lines || _updates_suspended) {
+ return;
+ }
+
double y;
- double prev_y = contents_height();
+ double prev_y = .5;
uint32_t color;
_note_lines->clear();
- for (int i = lowest_note(); i <= highest_note(); ++i) {
- y = floor(note_to_y(i));
-
- _note_lines->add_line(prev_y, 1.0, ARDOUR_UI::config()->canvasvar_PianoRollBlackOutline.get());
+ if (child_height() < 140 || note_height() < 3) {
+ /* track is too small for note lines, or there are too many */
+ return;
+ }
+
+ /* do this is order of highest ... lowest since that matches the
+ * coordinate system in which y=0 is at the top
+ */
+
+ for (int i = highest_note() + 1; i >= lowest_note(); --i) {
+
+ y = floor(note_to_y (i)) + .5;
+
+ /* this is the line actually corresponding to the division
+ * between notes
+ */
+
+ if (i <= highest_note()) {
+ _note_lines->add (y, 1.0, UIConfiguration::instance().color ("piano roll black outline"));
+ }
+
+ /* now add a thicker line/bar which covers the entire vertical
+ * height of this note.
+ */
switch (i % 12) {
case 1:
case 6:
case 8:
case 10:
- color = ARDOUR_UI::config()->canvasvar_PianoRollBlack.get();
+ color = UIConfiguration::instance().color_mod ("piano roll black", "piano roll black");
break;
default:
- color = ARDOUR_UI::config()->canvasvar_PianoRollWhite.get();
+ color = UIConfiguration::instance().color_mod ("piano roll white", "piano roll white");
break;
}
- if (i == highest_note()) {
- _note_lines->add_line(y, prev_y - y, color);
- } else {
- _note_lines->add_line(y + 1.0, prev_y - y - 1.0, color);
+ double h = y - prev_y;
+ double mid = y + (h/2.0);
+
+ if (height > 1.0) { // XXX ? should that not be h >= 1 ?
+ _note_lines->add (mid, h, color);
}
prev_y = y;
_highest_note = _data_note_max;
}
- apply_note_range(_lowest_note, _highest_note);
+ apply_note_range(_lowest_note, _highest_note, true);
}
void
-MidiStreamView::apply_note_range(uint8_t lowest, uint8_t highest)
+MidiStreamView::apply_note_range(uint8_t lowest, uint8_t highest, bool to_region_views)
{
_highest_note = highest;
_lowest_note = lowest;
+
+ int const max_note_height = 20; // This should probably be based on text size...
+ int const range = _highest_note - _lowest_note;
+ int const pixels_per_note = floor (child_height () / range);
+
+ /* do not grow note height beyond 10 pixels */
+ if (pixels_per_note > max_note_height) {
+
+ int const available_note_range = floor (child_height() / max_note_height);
+ int additional_notes = available_note_range - range;
+
+ /* distribute additional notes to higher and lower ranges, clamp at 0 and 127 */
+ for (int i = 0; i < additional_notes; i++){
+
+ if (i % 2 && _highest_note < 127){
+ _highest_note++;
+ }
+ else if (i % 2) {
+ _lowest_note--;
+ }
+ else if (_lowest_note > 0){
+ _lowest_note--;
+ }
+ else {
+ _highest_note++;
+ }
+ }
+ }
+
note_range_adjustment.set_page_size(_highest_note - _lowest_note);
note_range_adjustment.set_value(_lowest_note);
+
draw_note_lines();
-
- for (list<RegionView*>::iterator i = region_views.begin(); i != region_views.end(); ++i) {
- ((MidiRegionView*)(*i))->apply_note_range(lowest, highest);
+
+ if (to_region_views) {
+ apply_note_range_to_regions ();
}
NoteRangeChanged();
}
-void
+void
+MidiStreamView::apply_note_range_to_regions ()
+{
+ if (!_updates_suspended) {
+ for (list<RegionView*>::iterator i = region_views.begin(); i != region_views.end(); ++i) {
+ ((MidiRegionView*)(*i))->apply_note_range(_lowest_note, _highest_note);
+ }
+ }
+}
+
+void
MidiStreamView::update_note_range(uint8_t note_num)
{
- assert(note_num <= 127);
_data_note_min = min(_data_note_min, note_num);
_data_note_max = max(_data_note_max, note_num);
}
-
+
void
MidiStreamView::setup_rec_box ()
{
// cerr << _trackview.name() << " streamview SRB\n";
- if (_trackview.session().transport_rolling()) {
+ if (_trackview.session()->transport_rolling()) {
- if (!rec_active &&
- _trackview.session().record_status() == Session::Recording &&
- _trackview.get_diskstream()->record_enabled()) {
+ if (!rec_active &&
+ _trackview.session()->record_status() == Session::Recording &&
+ _trackview.track()->rec_enable_control()->get_value()) {
- if (use_rec_regions && rec_regions.size() == rec_rects.size()) {
+ if (UIConfiguration::instance().get_show_waveforms_while_recording() && rec_regions.size() == rec_rects.size()) {
- /* add a new region, but don't bother if they set use_rec_regions mid-record */
+ /* add a new region, but don't bother if they set show-waveforms-while-recording mid-record */
MidiRegion::SourceList sources;
-
- for (list<sigc::connection>::iterator prc = rec_data_ready_connections.begin(); prc != rec_data_ready_connections.end(); ++prc) {
- (*prc).disconnect();
- }
- rec_data_ready_connections.clear();
- // FIXME
- boost::shared_ptr<MidiDiskstream> mds = boost::dynamic_pointer_cast<MidiDiskstream>(_trackview.get_diskstream());
- assert(mds);
+ rec_data_ready_connections.drop_connections ();
- sources.push_back(mds->write_source());
-
- rec_data_ready_connections.push_back (mds->write_source()->ViewDataRangeReady.connect (bind (mem_fun (*this, &MidiStreamView::rec_data_range_ready), boost::weak_ptr<Source>(mds->write_source()))));
+ sources.push_back (_trackview.midi_track()->write_source());
// handle multi
-
- jack_nframes_t start = 0;
+
+ framepos_t start = 0;
if (rec_regions.size() > 0) {
- start = rec_regions.back().first->position() + _trackview.get_diskstream()->get_captured_frames(rec_regions.size()-1);
+ start = rec_regions.back().first->start()
+ + _trackview.track()->get_captured_frames(rec_regions.size()-1);
}
-
+
+ if (!rec_regions.empty()) {
+ MidiRegionView* mrv = dynamic_cast<MidiRegionView*> (rec_regions.back().second);
+ mrv->end_write ();
+ }
+
+ PropertyList plist;
+
+ plist.add (ARDOUR::Properties::start, start);
+ plist.add (ARDOUR::Properties::length, 1);
+ /* Just above we're setting this nascent region's length to 1. I think this
+ is so that the RegionView gets created with a non-zero width, as apparently
+ creating a RegionView with a zero width causes it never to be displayed
+ (there is a warning in TimeAxisViewItem::init about this). However, we
+ must also set length_beats to something non-zero, otherwise the frame length
+ of 1 causes length_beats to be set to some small quantity << 1. Then
+ when the position is set up below, this length_beats is used to recompute
+ length using BeatsFramesConverter::to, which is slightly innacurate for small
+ beats values because it converts floating point beats to bars, beats and
+ integer ticks. The upshot of which being that length gets set back to 0,
+ meaning no region view is ever seen, meaning no MIDI notes during record (#3820).
+ */
+ plist.add (ARDOUR::Properties::length_beats, 1);
+ plist.add (ARDOUR::Properties::name, string());
+ plist.add (ARDOUR::Properties::layer, 0);
+
boost::shared_ptr<MidiRegion> region (boost::dynamic_pointer_cast<MidiRegion>
- (RegionFactory::create (sources, start, 1 , "", 0, (Region::Flag)(Region::DefaultFlags | Region::DoNotSaveState), false)));
- assert(region);
- region->set_position (_trackview.session().transport_frame(), this);
- rec_regions.push_back (make_pair(region, (RegionView*)0));
-
- // rec regions are destroyed in setup_rec_box
-
- /* we add the region later */
+ (RegionFactory::create (sources, plist, false)));
+ if (region) {
+ region->set_start (_trackview.track()->current_capture_start()
+ - _trackview.track()->get_capture_start_frame (0));
+ region->set_position (_trackview.session()->transport_frame());
+
+ RegionView* rv = add_region_view_internal (region, false, true);
+ MidiRegionView* mrv = dynamic_cast<MidiRegionView*> (rv);
+ mrv->begin_write ();
+
+ /* rec region will be destroyed in setup_rec_box */
+ rec_regions.push_back (make_pair (region, rv));
+
+ /* we add the region later */
+ setup_new_rec_layer_time (region);
+ } else {
+ error << _("failed to create MIDI region") << endmsg;
+ }
}
-
+
/* start a new rec box */
- boost::shared_ptr<MidiTrack> mt = _trackview.midi_track(); /* we know what it is already */
- boost::shared_ptr<MidiDiskstream> ds = mt->midi_diskstream();
- jack_nframes_t frame_pos = ds->current_capture_start ();
- gdouble xstart = _trackview.editor().frame_to_pixel (frame_pos);
- gdouble xend;
- uint32_t fill_color;
-
- assert(_trackview.midi_track()->mode() == Normal);
-
- xend = xstart;
- fill_color = ARDOUR_UI::config()->canvasvar_RecordingRect.get();
-
- ArdourCanvas::SimpleRect * rec_rect = new Gnome::Canvas::SimpleRect (*canvas_group);
- rec_rect->property_x1() = xstart;
- rec_rect->property_y1() = 1.0;
- rec_rect->property_x2() = xend;
- rec_rect->property_y2() = (double) _trackview.current_height() - 1;
- rec_rect->property_outline_color_rgba() = ARDOUR_UI::config()->canvasvar_RecordingRect.get();
- rec_rect->property_fill_color_rgba() = fill_color;
- rec_rect->lower_to_bottom();
-
- RecBoxInfo recbox;
- recbox.rectangle = rec_rect;
- recbox.start = _trackview.session().transport_frame();
- recbox.length = 0;
-
- rec_rects.push_back (recbox);
-
- screen_update_connection.disconnect();
- screen_update_connection = ARDOUR_UI::instance()->SuperRapidScreenUpdate.connect (mem_fun (*this, &MidiStreamView::update_rec_box));
- rec_updating = true;
- rec_active = true;
+ create_rec_box(_trackview.midi_track()->current_capture_start(), 0);
} else if (rec_active &&
- (_trackview.session().record_status() != Session::Recording ||
- !_trackview.get_diskstream()->record_enabled())) {
-
+ (_trackview.session()->record_status() != Session::Recording ||
+ !_trackview.track()->rec_enable_control()->get_value())) {
screen_update_connection.disconnect();
rec_active = false;
rec_updating = false;
-
}
-
+
} else {
// cerr << "\tNOT rolling, rec_rects = " << rec_rects.size() << " rec_regions = " << rec_regions.size() << endl;
/* disconnect rapid update */
screen_update_connection.disconnect();
-
- for (list<sigc::connection>::iterator prc = rec_data_ready_connections.begin(); prc != rec_data_ready_connections.end(); ++prc) {
- (*prc).disconnect();
- }
- rec_data_ready_connections.clear();
-
+ rec_data_ready_connections.drop_connections ();
rec_updating = false;
rec_active = false;
-
+
/* remove temp regions */
-
+
for (list<pair<boost::shared_ptr<Region>,RegionView*> >::iterator iter = rec_regions.begin(); iter != rec_regions.end();) {
list<pair<boost::shared_ptr<Region>,RegionView*> >::iterator tmp;
-
+
tmp = iter;
++tmp;
iter = tmp;
}
-
+
rec_regions.clear();
// cerr << "\tclear " << rec_rects.size() << " rec rects\n";
RecBoxInfo &rect = (*iter);
delete rect.rectangle;
}
-
- rec_rects.clear();
-
- }
- }
-}
-
-void
-MidiStreamView::update_rec_regions (boost::shared_ptr<MidiModel> data, nframes_t start, nframes_t dur)
-{
- ENSURE_GUI_THREAD (bind (mem_fun (*this, &MidiStreamView::update_rec_regions), data, start, dur));
-
- if (use_rec_regions) {
-
- uint32_t n = 0;
- bool update_range = false;
-
- for (list<pair<boost::shared_ptr<Region>,RegionView*> >::iterator iter = rec_regions.begin(); iter != rec_regions.end(); n++) {
-
- list<pair<boost::shared_ptr<Region>,RegionView*> >::iterator tmp;
-
- tmp = iter;
- ++tmp;
-
- boost::shared_ptr<MidiRegion> region = boost::dynamic_pointer_cast<MidiRegion>(iter->first);
- if (!region || !iter->second) {
- iter = tmp;
- continue;
- }
-
- if (!canvas_item_visible (rec_rects[n].rectangle)) {
- /* rect already hidden, this region is done */
- iter = tmp;
- continue;
- }
-
- nframes_t origlen = region->length();
-
- if (region == rec_regions.back().first && rec_active) {
-
- if (start >= region->midi_source(0)->timeline_position()) {
-
- nframes_t nlen = start + dur - region->position();
-
- if (nlen != region->length()) {
-
- region->freeze ();
- region->set_position (_trackview.get_diskstream()->get_capture_start_frame(n), this);
- region->set_length (start + dur - region->position(), this);
- region->thaw ("updated");
-
- if (origlen == 1) {
- /* our special initial length */
- iter->second = add_region_view_internal (region, false);
- ((MidiRegionView*)iter->second)->begin_write();
- }
-
- /* also update rect */
- ArdourCanvas::SimpleRect * rect = rec_rects[n].rectangle;
- gdouble xend = _trackview.editor().frame_to_pixel (region->position() + region->length());
- rect->property_x2() = xend;
-
- /* draw events */
- MidiRegionView* mrv = (MidiRegionView*)iter->second;
- for (size_t i=0; i < data->n_notes(); ++i) {
-
- // FIXME: slooooooooow!
-
- const boost::shared_ptr<Evoral::Note> note = data->note_at(i);
-
- if (note->length() > 0 && note->end_time() + region->position() > start)
- mrv->resolve_note(note->note(), note->end_time());
-
- if (note->time() + region->position() < start)
- continue;
-
- if (note->time() + region->position() > start + dur)
- break;
-
- mrv->add_note(note);
-
- if (note->note() < _lowest_note) {
- _lowest_note = note->note();
- update_range = true;
- } else if (note->note() > _highest_note) {
- _highest_note = note->note();
- update_range = true;
- }
- }
-
- mrv->extend_active_notes();
- }
- }
- } else {
-
- nframes_t nlen = _trackview.get_diskstream()->get_captured_frames(n);
-
- if (nlen != region->length()) {
-
- if (region->source(0)->length() >= region->position() + nlen) {
-
- region->freeze ();
- region->set_position (_trackview.get_diskstream()->get_capture_start_frame(n), this);
- region->set_length (nlen, this);
- region->thaw ("updated");
-
- if (origlen == 1) {
- /* our special initial length */
- iter->second = add_region_view_internal (region, false);
- }
-
- /* also hide rect */
- ArdourCanvas::Item * rect = rec_rects[n].rectangle;
- rect->hide();
-
- }
- }
- }
+ rec_rects.clear();
- iter = tmp;
}
-
- if (update_range)
- update_contents_height();
}
}
-void
-MidiStreamView::rec_data_range_ready (jack_nframes_t start, jack_nframes_t dur, boost::weak_ptr<Source> weak_src)
-{
- // this is called from the butler thread for now
-
- ENSURE_GUI_THREAD(bind (mem_fun (*this, &MidiStreamView::rec_data_range_ready), start, dur, weak_src));
-
- boost::shared_ptr<SMFSource> src (boost::dynamic_pointer_cast<SMFSource>(weak_src.lock()));
-
- this->update_rec_regions (src->model(), start, dur);
-}
-
void
MidiStreamView::color_handler ()
{
- //case cMidiTrackBase:
- if (_trackview.is_midi_track()) {
- //canvas_rect->property_fill_color_rgba() = ARDOUR_UI::config()->canvasvar_MidiTrackBase.get();
- }
+ draw_note_lines ();
- //case cMidiBusBase:
- if (!_trackview.is_midi_track()) {
- //canvas_rect->property_fill_color_rgba() = ARDOUR_UI::config()->canvasvar_MidiBusBase.get();;
+ if (_trackview.is_midi_track()) {
+ canvas_rect->set_fill_color (UIConfiguration::instance().color_mod ("midi track base", "midi track base"));
+ } else {
+ canvas_rect->set_fill_color (UIConfiguration::instance().color ("midi bus base"));
}
}
_lowest_note = lowest;
_highest_note = highest;
- apply_note_range(lowest, highest);
+ apply_note_range(lowest, highest, true);
+}
+
+void
+MidiStreamView::update_rec_box ()
+{
+ StreamView::update_rec_box ();
+
+ if (rec_regions.empty()) {
+ return;
+ }
+
+ /* Update the region being recorded to reflect where we currently are */
+ boost::shared_ptr<ARDOUR::Region> region = rec_regions.back().first;
+ region->set_length (_trackview.track()->current_capture_end () - _trackview.track()->current_capture_start(), 0);
+
+ MidiRegionView* mrv = dynamic_cast<MidiRegionView*> (rec_regions.back().second);
+ mrv->extend_active_notes ();
+}
+
+uint8_t
+MidiStreamView::y_to_note (double y) const
+{
+ int const n = ((contents_height() - y) / contents_height() * (double)contents_note_range())
+ + lowest_note();
+
+ if (n < 0) {
+ return 0;
+ } else if (n > 127) {
+ return 127;
+ }
+
+ /* min due to rounding and/or off-by-one errors */
+ return min ((uint8_t) n, highest_note());
+}
+
+/** Suspend updates to the regions' note ranges and our
+ * note lines until resume_updates() is called.
+ */
+void
+MidiStreamView::suspend_updates ()
+{
+ _updates_suspended = true;
}
+/** Resume updates to region note ranges and note lines,
+ * and update them now.
+ */
+void
+MidiStreamView::resume_updates ()
+{
+ _updates_suspended = false;
+
+ draw_note_lines ();
+ apply_note_range_to_regions ();
+
+ _canvas_group->redraw ();
+}
+
+struct RegionPositionSorter {
+ bool operator() (RegionView* a, RegionView* b) {
+ return a->region()->position() < b->region()->position();
+ }
+};
+
+bool
+MidiStreamView::paste (ARDOUR::framepos_t pos, const Selection& selection, PasteContext& ctx, const int32_t sub_num)
+{
+ /* Paste into the first region which starts on or before pos. Only called when
+ using an internal editing tool. */
+
+ if (region_views.empty()) {
+ return false;
+ }
+
+ region_views.sort (RegionView::PositionOrder());
+
+ list<RegionView*>::const_iterator prev = region_views.begin ();
+
+ for (list<RegionView*>::const_iterator i = region_views.begin(); i != region_views.end(); ++i) {
+ if ((*i)->region()->position() > pos) {
+ break;
+ }
+ prev = i;
+ }
+
+ boost::shared_ptr<Region> r = (*prev)->region ();
+
+ /* If *prev doesn't cover pos, it's no good */
+ if (r->position() > pos || ((r->position() + r->length()) < pos)) {
+ return false;
+ }
+
+ MidiRegionView* mrv = dynamic_cast<MidiRegionView*> (*prev);
+ return mrv ? mrv->paste(pos, selection, ctx, sub_num) : false;
+}
projects / ardour.git / blobdiff