X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=gtk2_ardour%2Fmidi_streamview.cc;h=5bb232bdedf116d8b39e70a5daf966a2cd5a5137;hb=2e1332f74f803a1be4c8bb4911266aef4b63f145;hp=6f0718bdda0cec936728056cd8149f448017556a;hpb=9091ba932d9f440c73b35f02b3f0a89c12f92185;p=ardour.git diff --git a/gtk2_ardour/midi_streamview.cc b/gtk2_ardour/midi_streamview.cc index 6f0718bdda..5bb232bded 100644 --- a/gtk2_ardour/midi_streamview.cc +++ b/gtk2_ardour/midi_streamview.cc @@ -1,5 +1,5 @@ /* - Copyright (C) 2001, 2006 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 @@ -24,28 +24,29 @@ #include +#include #include #include #include -#include #include -#include #include +#include -#include "midi_streamview.h" -#include "region_view.h" +#include "ardour_ui.h" +#include "canvas-simplerect.h" +#include "gui_thread.h" +#include "lineset.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 "utils.h" -#include "color.h" +#include "selection.h" #include "simplerect.h" +#include "utils.h" using namespace std; using namespace ARDOUR; @@ -54,26 +55,82 @@ using namespace Editing; MidiStreamView::MidiStreamView (MidiTimeAxisView& tv) : StreamView (tv) + , note_range_adjustment(0.0f, 0.0f, 0.0f) + , _range_dirty(false) + , _range_sum_cache(-1.0) + , _lowest_note(60) + , _highest_note(71) + , _data_note_min(60) + , _data_note_max(71) { - if (tv.is_track()) - stream_base_color = color_map[cMidiTrackBase]; - else - stream_base_color = color_map[cMidiBusBase]; - - canvas_rect->property_fill_color_rgba() = stream_base_color; - canvas_rect->property_outline_color_rgba() = color_map[cAudioTrackOutline]; + 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->lower_to_bottom(); - //use_rec_regions = tv.editor.show_waveforms_recording (); - use_rec_regions = true; + /* 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->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)); + + 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)); } MidiStreamView::~MidiStreamView () { } +static void +veto_note_range(uint8_t& min, uint8_t& max) +{ + /* Legal notes, thanks */ + clamp_to_0_127(min); + clamp_to_0_127(max); + + /* 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; + } + } + assert(max - min >= 11); + assert(max < 127); + assert(min < 127); +} RegionView* -MidiStreamView::add_region_view_internal (boost::shared_ptr r, bool wait_for_waves) +MidiStreamView::add_region_view_internal (boost::shared_ptr r, bool wfd, bool recording) { boost::shared_ptr region = boost::dynamic_pointer_cast (r); @@ -90,29 +147,21 @@ MidiStreamView::add_region_view_internal (boost::shared_ptr r, bool wait /* great. we already have a MidiRegionView for this Region. use it again. */ (*i)->set_valid (true); + + display_region(dynamic_cast(*i), wfd); + return NULL; } } - // can't we all just get along? - assert(_trackview.midi_track()->mode() != Destructive); - region_view = new MidiRegionView (canvas_group, _trackview, region, _samples_per_unit, region_color); - - region_view->init (region_color, wait_for_waves); + + region_view->init (region_color, false); region_views.push_front (region_view); - - /* follow global waveform setting */ - - // FIXME - //region_view->set_waveform_visible(_trackview.editor.show_waveforms()); - - /* display events */ - region_view->begin_write(); - for (size_t i=0; i < region->midi_source(0)->model()->n_events(); ++i) - region_view->add_event(region->midi_source(0)->model()->event_at(i)); - region_view->end_write(); + + /* display events and find note range */ + display_region(region_view, wfd); /* catch regionview going away */ region->GoingAway.connect (bind (mem_fun (*this, &MidiStreamView::remove_region_view), region)); @@ -122,40 +171,197 @@ MidiStreamView::add_region_view_internal (boost::shared_ptr r, bool wait return region_view; } -// FIXME: code duplication with AudioStreamVIew void -MidiStreamView::redisplay_diskstream () +MidiStreamView::display_region(MidiRegionView* region_view, bool load_model) { - list::iterator i, tmp; + if ( ! region_view) + return; - for (i = region_views.begin(); i != region_views.end(); ++i) { - (*i)->set_valid (false); + region_view->enable_display(true); + + boost::shared_ptr source(region_view->midi_region()->midi_source(0)); + + if (load_model) { + source->load_model(); } - if (_trackview.is_midi_track()) { - _trackview.get_diskstream()->playlist()->foreach_region (static_cast(this), &StreamView::add_region_view); + _range_dirty = update_data_note_range( + source->model()->lowest_note(), + source->model()->highest_note()); + + // Display region contents + region_view->set_height(height); + region_view->display_model(source->model()); +} + +void +MidiStreamView::display_diskstream (boost::shared_ptr ds) +{ + StreamView::display_diskstream(ds); + draw_note_lines(); + NoteRangeChanged(); +} + +void +MidiStreamView::update_contents_metrics(boost::shared_ptr r) +{ + boost::shared_ptr mr = boost::dynamic_pointer_cast(r); + if (mr) { + mr->midi_source(0)->load_model(); + _range_dirty = update_data_note_range( + mr->model()->lowest_note(), + mr->model()->highest_note()); } +} - for (i = region_views.begin(); i != region_views.end(); ) { - tmp = i; - tmp++; +bool +MidiStreamView::update_data_note_range(uint8_t min, uint8_t max) +{ + bool dirty = false; + if (min < _data_note_min) { + _data_note_min = min; + dirty = true; + } + if (max > _data_note_max) { + _data_note_max = max; + dirty = true; + } + return dirty; +} - if (!(*i)->is_valid()) { - delete *i; - region_views.erase (i); - } +void +MidiStreamView::redisplay_diskstream () +{ + if (!_trackview.is_midi_track()) { + return; + } + + list::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; + _trackview.get_diskstream()->playlist()->foreach_region( + static_cast(this), + &StreamView::update_contents_metrics); - i = tmp; + // No notes, use default range + if (!_range_dirty) { + _data_note_min = 60; + _data_note_max = 71; } + + // Extend visible range to show newly recorded data, if necessary + _lowest_note = std::min(_lowest_note, _data_note_min); + _highest_note = std::max(_highest_note, _data_note_max); + + veto_note_range(_lowest_note, _highest_note); + + // 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); + } + + // Add and display region views, and flag them as valid + _trackview.get_diskstream()->playlist()->foreach_region( + static_cast(this), + &StreamView::add_region_view); - /* now fix layering */ + // Stack regions by layer, and remove invalid regions + layer_regions(); - for (RegionViewList::iterator i = region_views.begin(); i != region_views.end(); ++i) { - region_layered (*i); + // Update note range (not regions which are correct) and draw note lines + apply_note_range(_lowest_note, _highest_note, false); +} + + +void +MidiStreamView::update_contents_height () +{ + StreamView::update_contents_height(); + _note_lines->property_y2() = height; + draw_note_lines(); +} + +void +MidiStreamView::draw_note_lines() +{ + double y; + double prev_y = contents_height(); + 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()); + + switch (i % 12) { + case 1: + case 3: + case 6: + case 8: + case 10: + color = ARDOUR_UI::config()->canvasvar_PianoRollBlack.get(); + break; + default: + color = ARDOUR_UI::config()->canvasvar_PianoRollWhite.get(); + 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); + } + + prev_y = y; } } +void +MidiStreamView::set_note_range(VisibleNoteRange r) +{ + if (r == FullRange) { + _lowest_note = 0; + _highest_note = 127; + } else { + _lowest_note = _data_note_min; + _highest_note = _data_note_max; + } + + apply_note_range(_lowest_note, _highest_note, true); +} +void +MidiStreamView::apply_note_range(uint8_t lowest, uint8_t highest, bool to_region_views) +{ + _highest_note = highest; + _lowest_note = lowest; + note_range_adjustment.set_page_size(_highest_note - _lowest_note); + note_range_adjustment.set_value(_lowest_note); + draw_note_lines(); + + if (to_region_views) { + for (list::iterator i = region_views.begin(); i != region_views.end(); ++i) { + ((MidiRegionView*)(*i))->apply_note_range(lowest, highest); + } + } + + NoteRangeChanged(); +} + +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 () { @@ -190,7 +396,7 @@ MidiStreamView::setup_rec_box () jack_nframes_t start = 0; if (rec_regions.size() > 0) { - start = rec_regions.back().first->start() + _trackview.get_diskstream()->get_captured_frames(rec_regions.size()-1); + start = rec_regions.back().first->position() + _trackview.get_diskstream()->get_captured_frames(rec_regions.size()-1); } boost::shared_ptr region (boost::dynamic_pointer_cast @@ -206,24 +412,24 @@ MidiStreamView::setup_rec_box () /* start a new rec box */ - MidiTrack* mt = _trackview.midi_track(); /* we know what it is already */ + boost::shared_ptr mt = _trackview.midi_track(); /* we know what it is already */ boost::shared_ptr ds = mt->midi_diskstream(); jack_nframes_t frame_pos = ds->current_capture_start (); - gdouble xstart = _trackview.editor.frame_to_pixel (frame_pos); + 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 = color_map[cRecordingRectFill]; + 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.height - 1; - rec_rect->property_outline_color_rgba() = color_map[cRecordingRectOutline]; + 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(); @@ -296,13 +502,14 @@ MidiStreamView::setup_rec_box () } void -MidiStreamView::update_rec_regions (boost::shared_ptr data, nframes_t start, nframes_t dur) +MidiStreamView::update_rec_regions (boost::shared_ptr 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,RegionView*> >::iterator iter = rec_regions.begin(); iter != rec_regions.end(); n++) { @@ -310,36 +517,34 @@ MidiStreamView::update_rec_regions (boost::shared_ptr data, nframes_ tmp = iter; ++tmp; - - if (!canvas_item_visible (rec_rects[n].rectangle)) { - /* rect already hidden, this region is done */ + + boost::shared_ptr region = boost::dynamic_pointer_cast(iter->first); + if (!region || !iter->second) { iter = tmp; continue; } - boost::shared_ptr region = boost::dynamic_pointer_cast(iter->first); - if (!region) { + if (!canvas_item_visible (rec_rects[n].rectangle)) { + /* rect already hidden, this region is done */ + iter = tmp; continue; } - + nframes_t origlen = region->length(); - //cerr << "MIDI URR: " << start << " * " << dur - // << " (origlen " << origlen << ")" << endl; - if (region == rec_regions.back().first && rec_active) { - if (start >= region->start()) { - - nframes_t nlen = start + dur - region->start(); + 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 (nlen, 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); @@ -348,27 +553,48 @@ MidiStreamView::update_rec_regions (boost::shared_ptr data, nframes_ /* also update rect */ ArdourCanvas::SimpleRect * rect = rec_rects[n].rectangle; - gdouble xend = _trackview.editor.frame_to_pixel (region->position() + region->length()); + 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->size(); ++i) { - const MidiEvent& ev = (*data.get())[i]; - mrv->add_event(ev); - mrv->extend_active_notes(); - } + for (size_t i=0; i < data->n_notes(); ++i) { + + // FIXME: slooooooooow! + + const boost::shared_ptr 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->start() + nlen) { + if (region->source(0)->length() >= region->position() + nlen) { region->freeze (); region->set_position (_trackview.get_diskstream()->get_capture_start_frame(n), this); @@ -390,43 +616,63 @@ MidiStreamView::update_rec_regions (boost::shared_ptr data, nframes_ iter = tmp; } + + if (update_range) + update_contents_height(); } } void -MidiStreamView::rec_data_range_ready (boost::shared_ptr data, jack_nframes_t start, jack_nframes_t dur, boost::weak_ptr weak_src) +MidiStreamView::rec_data_range_ready (jack_nframes_t start, jack_nframes_t dur, boost::weak_ptr weak_src) { // this is called from the butler thread for now - ENSURE_GUI_THREAD(bind (mem_fun (*this, &MidiStreamView::rec_data_range_ready), data, start, dur, weak_src)); + ENSURE_GUI_THREAD(bind (mem_fun (*this, &MidiStreamView::rec_data_range_ready), start, dur, weak_src)); boost::shared_ptr src (boost::dynamic_pointer_cast(weak_src.lock())); - //cerr << src.get() << " MIDI READY: " << start << " * " << dur - // << " -- " << data->size() << " events!" << endl; - - this->update_rec_regions (data, start, dur); + this->update_rec_regions (src->model(), start, dur); } void -MidiStreamView::color_handler (ColorID id, uint32_t val) +MidiStreamView::color_handler () { - switch (id) { - case cMidiTrackBase: - if (_trackview.is_midi_track()) { - canvas_rect->property_fill_color_rgba() = val; - } - break; - case cMidiBusBase: - if (!_trackview.is_midi_track()) { - canvas_rect->property_fill_color_rgba() = val; - } - break; - case cMidiTrackOutline: - canvas_rect->property_outline_color_rgba() = val; - break; + //case cMidiTrackBase: + if (_trackview.is_midi_track()) { + //canvas_rect->property_fill_color_rgba() = ARDOUR_UI::config()->canvasvar_MidiTrackBase.get(); + } - default: - break; + //case cMidiBusBase: + if (!_trackview.is_midi_track()) { + //canvas_rect->property_fill_color_rgba() = ARDOUR_UI::config()->canvasvar_MidiBusBase.get();; } } + +void +MidiStreamView::note_range_adjustment_changed() +{ + double sum = note_range_adjustment.get_value() + note_range_adjustment.get_page_size(); + int lowest = (int) floor(note_range_adjustment.get_value()); + int highest; + + if (sum == _range_sum_cache) { + //cerr << "cached" << endl; + highest = (int) floor(sum); + } else { + //cerr << "recalc" << endl; + highest = lowest + (int) floor(note_range_adjustment.get_page_size()); + _range_sum_cache = sum; + } + + if (lowest == _lowest_note && highest == _highest_note) { + return; + } + + //cerr << "note range adjustment changed: " << lowest << " " << highest << endl; + //cerr << " val=" << v_zoom_adjustment.get_value() << " page=" << v_zoom_adjustment.get_page_size() << " sum=" << v_zoom_adjustment.get_value() + v_zoom_adjustment.get_page_size() << endl; + + _lowest_note = lowest; + _highest_note = highest; + apply_note_range(lowest, highest, true); +} +