X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=gtk2_ardour%2Fmidi_streamview.cc;h=0d50c8910f2275400aa503954573e209953a502f;hb=8e59a26ccf13de93ac681d761bad09cd6bcf0c90;hp=47fae246e0129e1744c9908cfcd849fc1e3517f4;hpb=9a4a9cbb63958484553ed981822ca97ceb1dc4f5;p=ardour.git diff --git a/gtk2_ardour/midi_streamview.cc b/gtk2_ardour/midi_streamview.cc index 47fae246e0..0d50c8910f 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 @@ -18,145 +18,375 @@ #include #include +#include #include #include -#include -#include -#include -#include -#include -#include -#include +#include "ardour/midi_diskstream.h" +#include "ardour/midi_playlist.h" +#include "ardour/midi_region.h" +#include "ardour/midi_source.h" +#include "ardour/midi_track.h" +#include "ardour/region_factory.h" +#include "ardour/smf_source.h" +#include "ardour/session.h" -#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 "selection.h" +#include "simplerect.h" #include "utils.h" -#include "color.h" +using namespace std; using namespace ARDOUR; using namespace PBD; 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]; - - //use_rec_regions = tv.editor.show_waveforms_recording (); - use_rec_regions = true; + 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(); + + /* 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(sigc::bind( + sigc::mem_fun(_trackview.editor(), &PublicEditor::canvas_stream_view_event), + _note_lines, &_trackview)); + + _note_lines->lower_to_bottom(); + + ColorsChanged.connect(sigc::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( + sigc::mem_fun(*this, &MidiStreamView::note_range_adjustment_changed)); } MidiStreamView::~MidiStreamView () { } - -void -MidiStreamView::add_region_view_internal (boost::shared_ptr r, bool wait_for_waves) +static void +veto_note_range(uint8_t& min, uint8_t& max) { - ENSURE_GUI_THREAD (bind (mem_fun (*this, &MidiStreamView::add_region_view), r)); + /* 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::create_region_view (boost::shared_ptr r, bool /*wfd*/, bool) +{ boost::shared_ptr region = boost::dynamic_pointer_cast (r); if (region == 0) { - return; + return 0; } - MidiRegionView *region_view; - list::iterator i; + RegionView* region_view = new MidiRegionView (canvas_group, _trackview, region, + _samples_per_unit, region_color); - for (i = region_views.begin(); i != region_views.end(); ++i) { + region_view->init (region_color, false); + + return region_view; +} + +RegionView* +MidiStreamView::add_region_view_internal (boost::shared_ptr r, bool wfd, bool recording) +{ + boost::shared_ptr region = boost::dynamic_pointer_cast (r); + + if (region == 0) { + return 0; + } + + for (list::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); - return; + + display_region(dynamic_cast(*i), wfd); + + return 0; } } - - // 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); + MidiRegionView* region_view = dynamic_cast (create_region_view (r, wfd, recording)); + if (region_view == 0) { + return 0; + } - region_view->init (region_color, wait_for_waves); region_views.push_front (region_view); - - /* follow global waveform setting */ - // FIXME - //region_view->set_waveform_visible(_trackview.editor.show_waveforms()); + /* display events and find note range */ + display_region (region_view, wfd); /* catch regionview going away */ + region->GoingAway.connect (*this, boost::bind (&MidiStreamView::remove_region_view, this, region), gui_context()); - region->GoingAway.connect (bind (mem_fun (*this, &MidiStreamView::remove_region_view), region)); - RegionViewAdded (region_view); + + return region_view; +} + +void +MidiStreamView::display_region(MidiRegionView* region_view, bool load_model) +{ + if ( ! region_view) + return; + + region_view->enable_display(true); + + boost::shared_ptr source(region_view->midi_region()->midi_source(0)); + + if (load_model) { + source->load_model(); + } + + _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()); + } +} + +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; } -// FIXME: code duplication with AudioStreamVIew void MidiStreamView::redisplay_diskstream () { - list::iterator i, tmp; + if (!_trackview.is_midi_track()) { + return; + } - for (i = region_views.begin(); i != region_views.end(); ++i) { - (*i)->set_valid (false); + 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( + sigc::mem_fun (*this, &StreamView::update_contents_metrics) + ); + + // No notes, use default range + if (!_range_dirty) { + _data_note_min = 60; + _data_note_max = 71; } - if (_trackview.is_midi_track()) { - _trackview.get_diskstream()->playlist()->foreach_region (static_cast(this), &StreamView::add_region_view); + // 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); } - for (i = region_views.begin(); i != region_views.end(); ) { - tmp = i; - tmp++; + // Add and display region views, and flag them as valid + _trackview.get_diskstream()->playlist()->foreach_region( + sigc::hide_return (sigc::mem_fun (*this, &StreamView::add_region_view)) + ); + + // Stack regions by layer, and remove invalid regions + layer_regions(); - if (!(*i)->is_valid()) { - delete *i; - region_views.erase (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(); +} - i = tmp; +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; } - /* now fix layering */ + apply_note_range(_lowest_note, _highest_note, true); +} - for (RegionViewList::iterator i = region_views.begin(); i != region_views.end(); ++i) { - region_layered (*i); +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 () { // 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 && + if (!rec_active && + _trackview.session()->record_status() == Session::Recording && _trackview.get_diskstream()->record_enabled()) { if (use_rec_regions && rec_regions.size() == rec_rects.size()) { @@ -165,76 +395,82 @@ MidiStreamView::setup_rec_box () MidiRegion::SourceList sources; - // FIXME - boost::shared_ptr mds = boost::dynamic_pointer_cast(_trackview.get_diskstream()); - assert(mds); + rec_data_ready_connections.drop_connections (); + + boost::shared_ptr mds = _trackview.midi_track()->midi_diskstream(); 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), mds->write_source()))); + + mds->write_source()->ViewDataRangeReady.connect + (rec_data_ready_connections, + ui_bind (&MidiStreamView::rec_data_range_ready, this, _1, _2, boost::weak_ptr(mds->write_source())), + gui_context()); // handle multi - - jack_nframes_t start = 0; + + nframes_t start = 0; if (rec_regions.size() > 0) { - start = rec_regions.back()->start() + _trackview.get_diskstream()->get_captured_frames(rec_regions.size()-1); + start = rec_regions.back().first->start() + + _trackview.get_diskstream()->get_captured_frames(rec_regions.size()-1); } - + boost::shared_ptr region (boost::dynamic_pointer_cast - (RegionFactory::create (sources, start, 1 , "", 0, (Region::Flag)(Region::DefaultFlags | Region::DoNotSaveState), false))); + (RegionFactory::create (sources, start, 1 , "", 0, Region::DefaultFlags, false))); + assert(region); - region->set_position (_trackview.session().transport_frame(), this); - rec_regions.push_back (region); - + region->block_property_changes (); + 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 */ } - + /* 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); + 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 = 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(); + RecBoxInfo recbox; recbox.rectangle = rec_rect; - recbox.start = _trackview.session().transport_frame(); + 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)); + screen_update_connection = ARDOUR_UI::instance()->SuperRapidScreenUpdate.connect ( + sigc::mem_fun (*this, &MidiStreamView::update_rec_box)); rec_updating = true; rec_active = true; } else if (rec_active && - (_trackview.session().record_status() != Session::Recording || + (_trackview.session()->record_status() != Session::Recording || !_trackview.get_diskstream()->record_enabled())) { - 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; @@ -243,26 +479,24 @@ MidiStreamView::setup_rec_box () /* disconnect rapid update */ screen_update_connection.disconnect(); - - for (list::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; - last_rec_data_frame = 0; - + /* remove temp regions */ - - for (list >::iterator iter = rec_regions.begin(); iter != rec_regions.end();) { - list >::iterator tmp; + + for (list,RegionView*> >::iterator iter = rec_regions.begin(); iter != rec_regions.end();) { + list,RegionView*> >::iterator tmp; + tmp = iter; ++tmp; - (*iter)->drop_references (); + + (*iter).first->drop_references (); + iter = tmp; } - + rec_regions.clear(); // cerr << "\tclear " << rec_rects.size() << " rec rects\n"; @@ -272,26 +506,27 @@ MidiStreamView::setup_rec_box () RecBoxInfo &rect = (*iter); delete rect.rectangle; } - + rec_rects.clear(); - + } } } void -MidiStreamView::update_rec_regions () +MidiStreamView::update_rec_regions (boost::shared_ptr data, nframes_t start, nframes_t dur) { - if (use_rec_regions) { + ENSURE_GUI_THREAD (*this, &MidiStreamView::update_rec_regions, data, start, dur) + if (use_rec_regions) { uint32_t n = 0; + bool update_range = false; - for (list >::iterator iter = rec_regions.begin(); iter != rec_regions.end(); n++) { + for (list,RegionView*> >::iterator iter = rec_regions.begin(); + iter != rec_regions.end(); n++) { - list >::iterator tmp; - - tmp = iter; + list,RegionView*> >::iterator tmp = iter; ++tmp; if (!canvas_item_visible (rec_rects[n].rectangle)) { @@ -299,55 +534,97 @@ MidiStreamView::update_rec_regions () iter = tmp; continue; } - - boost::shared_ptr region = boost::dynamic_pointer_cast(*iter); - assert(region); - jack_nframes_t origlen = region->length(); + boost::shared_ptr region = boost::dynamic_pointer_cast(iter->first); + if (!region) { + iter = tmp; + continue; + } + + nframes_t origlen = region->length(); - if (region == rec_regions.back() && rec_active) { + if (region == rec_regions.back().first && rec_active) { - if (last_rec_data_frame > region->start()) { + if (start >= region->midi_source(0)->timeline_position()) { - jack_nframes_t nlen = last_rec_data_frame - region->start(); + 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 */ - add_region_view_internal (region, false); + 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()); + gdouble xend = _trackview.editor().frame_to_pixel (region->position() + region->length()); rect->property_x2() = xend; + + ARDOUR::BeatsFramesConverter tconv(_trackview.session()->tempo_map(), region->position()); + const MidiModel::TimeType start_beats = tconv.from(start); + + /* draw events */ + MidiRegionView* mrv = (MidiRegionView*)iter->second; + + for (MidiModel::Notes::const_iterator i = data->note_lower_bound(start_beats); + i != data->notes().end(); ++i) { + + const boost::shared_ptr& note = *i; + + nframes_t note_start_frames = tconv.to(note->time()); + nframes_t note_end_frames = tconv.to(note->end_time()); + + if (note->length() > 0 && note_end_frames + region->position() > start) + mrv->resolve_note(note->note(), note_end_frames); + + if (note_start_frames + region->position() < start) { + continue; + } + + if (note_start_frames + region->position() > start + dur) { + break; + } + + 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->add_note (note, !update_range); + } + + mrv->extend_active_notes(); } } } else { - jack_nframes_t nlen = _trackview.get_diskstream()->get_captured_frames(n); + 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_length(0) >= 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 */ - add_region_view_internal (region, false); + iter->second = add_region_view_internal (region, false); } - + /* also hide rect */ ArdourCanvas::Item * rect = rec_rects[n].rectangle; rect->hide(); @@ -358,51 +635,71 @@ MidiStreamView::update_rec_regions () iter = tmp; } + + if (update_range) + update_contents_height(); } } void -MidiStreamView::rec_data_range_ready (jack_nframes_t start, jack_nframes_t cnt, boost::shared_ptr src) +MidiStreamView::rec_data_range_ready (nframes_t start, nframes_t cnt, boost::weak_ptr weak_src) { // this is called from the butler thread for now - // yeah we need a "peak" building thread or something, though there's not really any - // work for it to do... whatever. :) - - ENSURE_GUI_THREAD(bind (mem_fun (*this, &MidiStreamView::rec_data_range_ready), start, cnt, src)); - - //cerr << "REC DATA: " << start << " --- " << cnt << endl; - - if (rec_data_ready_map.size() == 0 || start+cnt > last_rec_data_frame) { + + ENSURE_GUI_THREAD (*this, &MidiStreamView::rec_data_range_ready, start, cnt, weak_src) + + boost::shared_ptr src (boost::dynamic_pointer_cast(weak_src.lock())); + + if (!src) { + return; + } + + if (start + cnt > last_rec_data_frame) { last_rec_data_frame = start + cnt; } - rec_data_ready_map[src] = true; + this->update_rec_regions (src->model(), start, cnt); +} + +void +MidiStreamView::color_handler () +{ + //case cMidiTrackBase: + if (_trackview.is_midi_track()) { + //canvas_rect->property_fill_color_rgba() = ARDOUR_UI::config()->canvasvar_MidiTrackBase.get(); + } - if (rec_data_ready_map.size() == _trackview.get_diskstream()->n_channels().n_midi()) { - this->update_rec_regions (); - rec_data_ready_map.clear(); + //case cMidiBusBase: + if (!_trackview.is_midi_track()) { + //canvas_rect->property_fill_color_rgba() = ARDOUR_UI::config()->canvasvar_MidiBusBase.get();; } } void -MidiStreamView::color_handler (ColorID id, uint32_t val) +MidiStreamView::note_range_adjustment_changed() { - 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; + double sum = note_range_adjustment.get_value() + note_range_adjustment.get_page_size(); + int lowest = (int) floor(note_range_adjustment.get_value()); + int highest; - default: - break; + 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); } +