Per-region MIDI CC "automation".
[ardour.git] / gtk2_ardour / audio_streamview.cc
1 /*
2     Copyright (C) 2001, 2006 Paul Davis 
3
4     This program is free software; you can redistribute it and/or modify
5     it under the terms of the GNU General Public License as published by
6     the Free Software Foundation; either version 2 of the License, or
7     (at your option) any later version.
8
9     This program is distributed in the hope that it will be useful,
10     but WITHOUT ANY WARRANTY; without even the implied warranty of
11     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12     GNU General Public License for more details.
13
14     You should have received a copy of the GNU General Public License
15     along with this program; if not, write to the Free Software
16     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
17 */
18
19 #include <cmath>
20 #include <cassert>
21 #include <utility>
22
23 #include <gtkmm.h>
24
25 #include <gtkmm2ext/gtk_ui.h>
26
27 #include <ardour/audioplaylist.h>
28 #include <ardour/audioregion.h>
29 #include <ardour/audiofilesource.h>
30 #include <ardour/audio_diskstream.h>
31 #include <ardour/audio_track.h>
32 #include <ardour/playlist_templates.h>
33 #include <ardour/source.h>
34 #include <ardour/region_factory.h>
35
36 #include "audio_streamview.h"
37 #include "audio_region_view.h"
38 #include "tape_region_view.h"
39 #include "audio_time_axis.h"
40 #include "canvas-waveview.h"
41 #include "canvas-simplerect.h"
42 #include "region_selection.h"
43 #include "selection.h"
44 #include "public_editor.h"
45 #include "ardour_ui.h"
46 #include "crossfade_view.h"
47 #include "rgb_macros.h"
48 #include "gui_thread.h"
49 #include "utils.h"
50
51 #include "i18n.h"
52
53 using namespace std;
54 using namespace ARDOUR;
55 using namespace PBD;
56 using namespace Editing;
57
58 AudioStreamView::AudioStreamView (AudioTimeAxisView& tv)
59         : StreamView (tv)
60 {
61         crossfades_visible = true;
62         _waveform_scale = LinearWaveform;
63         _waveform_shape = Traditional;
64         
65         if (tv.is_track())
66                 stream_base_color = ARDOUR_UI::config()->canvasvar_AudioTrackBase.get();
67         else
68                 stream_base_color = ARDOUR_UI::config()->canvasvar_AudioBusBase.get();
69         
70         canvas_rect->property_fill_color_rgba() = stream_base_color;
71         canvas_rect->property_outline_color_rgba() = RGBA_BLACK;
72
73         _amplitude_above_axis = 1.0;
74
75         use_rec_regions = tv.editor.show_waveforms_recording ();
76
77 }
78
79 AudioStreamView::~AudioStreamView ()
80 {
81 }
82
83 int 
84 AudioStreamView::set_samples_per_unit (gdouble spp)
85 {
86         StreamView::set_samples_per_unit(spp);
87
88         for (CrossfadeViewList::iterator xi = crossfade_views.begin(); xi != crossfade_views.end(); ++xi) {
89                 (*xi)->set_samples_per_unit (spp);
90         }
91
92         return 0;
93 }
94
95 int 
96 AudioStreamView::set_amplitude_above_axis (gdouble app)
97 {
98         RegionViewList::iterator i;
99
100         if (app < 1.0) {
101                 return -1;
102         }
103
104         _amplitude_above_axis = app;
105
106         for (i = region_views.begin(); i != region_views.end(); ++i) {
107                 AudioRegionView* const arv = dynamic_cast<AudioRegionView*>(*i);
108                 if (arv)
109                         arv->set_amplitude_above_axis (app);
110         }
111
112         return 0;
113 }
114
115 RegionView*
116 AudioStreamView::add_region_view_internal (boost::shared_ptr<Region> r, bool wait_for_waves)
117 {
118         AudioRegionView *region_view = 0;
119
120         boost::shared_ptr<AudioRegion> region = boost::dynamic_pointer_cast<AudioRegion> (r);
121
122         if (region == 0) {
123                 return NULL;
124         }
125
126         for (list<RegionView *>::iterator i = region_views.begin(); i != region_views.end(); ++i) {
127                 if ((*i)->region() == r) {
128                         
129                         /* great. we already have a AudioRegionView for this Region. use it again. */
130                         
131                         (*i)->set_valid (true);
132
133                         // this might not be necessary
134                         AudioRegionView* const arv = dynamic_cast<AudioRegionView*>(*i);
135                         if (arv) {
136                                 arv->set_waveform_scale (_waveform_scale);
137                                 arv->set_waveform_shape (_waveform_shape);
138                         }
139                                 
140                         return NULL;
141                 }
142         }
143
144         switch (_trackview.audio_track()->mode()) {
145         case Normal:
146                 region_view = new AudioRegionView (canvas_group, _trackview, region, 
147                                                    _samples_per_unit, region_color);
148                 break;
149         case Destructive:
150                 region_view = new TapeAudioRegionView (canvas_group, _trackview, region, 
151                                                        _samples_per_unit, region_color);
152                 break;
153         default:
154                 fatal << string_compose (_("programming error: %1"), "illegal track mode in ::add_region_view_internal") << endmsg;
155                 /*NOTREACHED*/
156
157         }
158
159         region_view->init (region_color, wait_for_waves);
160         region_view->set_amplitude_above_axis(_amplitude_above_axis);
161         region_views.push_front (region_view);
162
163         
164         /* if its the special single-sample length that we use for rec-regions, make it 
165            insensitive to events 
166         */
167
168         if (region->length() == 1) {
169                 region_view->set_sensitive (false);
170         }
171
172         /* if this was the first one, then lets query the waveform scale and shape.
173            otherwise, we set it to the current value */
174            
175         if (region_views.size() == 1) {
176                 if (region_view->waveform_logscaled()) {
177                         _waveform_scale = LogWaveform;
178                 } else {
179                         _waveform_scale = LinearWaveform;
180                 }
181
182                 if (region_view->waveform_rectified()) {
183                         _waveform_shape = Rectified;
184                 } else {
185                         _waveform_shape = Traditional;
186                 }
187         }
188         else {
189                 region_view->set_waveform_scale(_waveform_scale);
190                 region_view->set_waveform_shape(_waveform_shape);
191         }
192         
193         /* follow global waveform setting */
194
195         region_view->set_waveform_visible(_trackview.editor.show_waveforms());
196
197         /* catch regionview going away */
198         region->GoingAway.connect (bind (mem_fun (*this, &AudioStreamView::remove_region_view), boost::weak_ptr<Region> (r)));
199
200         RegionViewAdded (region_view);
201
202         return region_view;
203 }
204
205 void
206 AudioStreamView::remove_region_view (boost::weak_ptr<Region> weak_r)
207 {
208         ENSURE_GUI_THREAD (bind (mem_fun (*this, &AudioStreamView::remove_region_view), weak_r));
209
210         boost::shared_ptr<Region> r (weak_r.lock());
211
212         if (!r) {
213                 return;
214         }
215
216         if (!_trackview.session().deletion_in_progress()) {
217
218                 for (list<CrossfadeView *>::iterator i = crossfade_views.begin(); i != crossfade_views.end();) {
219                         list<CrossfadeView*>::iterator tmp;
220                         
221                         tmp = i;
222                         ++tmp;
223                         
224                         boost::shared_ptr<AudioRegion> ar = boost::dynamic_pointer_cast<AudioRegion>(r);
225                         if (ar && (*i)->crossfade->involves (ar)) {
226                                 delete *i;
227                                 crossfade_views.erase (i);
228                         }
229                         
230                         i = tmp;
231                 }
232         }
233
234         StreamView::remove_region_view(r);
235 }
236
237 void
238 AudioStreamView::undisplay_diskstream ()
239 {
240         StreamView::undisplay_diskstream();
241
242         for (CrossfadeViewList::iterator i = crossfade_views.begin(); i != crossfade_views.end(); ++i) {
243                 delete *i;
244         }
245
246         crossfade_views.clear ();
247 }
248
249 void
250 AudioStreamView::playlist_modified_weak (boost::weak_ptr<Diskstream> ds)
251 {
252         boost::shared_ptr<Diskstream> sp (ds.lock());
253         if (!sp) {
254                 return;
255         }
256
257         playlist_modified (sp);
258 }
259
260 void
261 AudioStreamView::playlist_modified (boost::shared_ptr<Diskstream> ds)
262 {
263         /* we do not allow shared_ptr<T> to be bound to slots */
264         ENSURE_GUI_THREAD (bind (mem_fun (*this, &AudioStreamView::playlist_modified_weak), ds));
265
266         StreamView::playlist_modified (ds);
267         
268         /* make sure xfades are on top and all the regionviews are stacked correctly. */
269
270         for (list<CrossfadeView *>::iterator i = crossfade_views.begin(); i != crossfade_views.end(); ++i) {
271                 (*i)->get_canvas_group()->raise_to_top();
272         }
273 }
274
275 void
276 AudioStreamView::playlist_changed (boost::shared_ptr<Diskstream> ds)
277 {
278         ENSURE_GUI_THREAD (bind (mem_fun (*this, &AudioStreamView::playlist_changed), ds));
279
280         StreamView::playlist_changed(ds);
281
282         boost::shared_ptr<AudioPlaylist> apl = boost::dynamic_pointer_cast<AudioPlaylist>(ds->playlist());
283         if (apl)
284                 playlist_connections.push_back (apl->NewCrossfade.connect (mem_fun (*this, &AudioStreamView::add_crossfade)));
285 }
286
287 void
288 AudioStreamView::add_crossfade_weak (boost::weak_ptr<Crossfade> crossfade)
289 {
290         boost::shared_ptr<Crossfade> sp (crossfade.lock());
291
292         if (!sp) {
293                 return;
294         }
295
296         add_crossfade (sp);
297 }
298
299 void
300 AudioStreamView::add_crossfade (boost::shared_ptr<Crossfade> crossfade)
301 {
302         AudioRegionView* lview = 0;
303         AudioRegionView* rview = 0;
304
305         /* we do not allow shared_ptr<T> to be bound to slots */
306         
307         ENSURE_GUI_THREAD (bind (mem_fun (*this, &AudioStreamView::add_crossfade_weak), boost::weak_ptr<Crossfade> (crossfade)));
308
309         /* first see if we already have a CrossfadeView for this Crossfade */
310
311         for (list<CrossfadeView *>::iterator i = crossfade_views.begin(); i != crossfade_views.end(); ++i) {
312                 if ((*i)->crossfade == crossfade) {
313                         if (!crossfades_visible || layer_display == Stacked) {
314                                 (*i)->hide();
315                         } else {
316                                 (*i)->show ();
317                         }
318                         (*i)->set_valid (true);
319                         return;
320                 }
321         }
322
323         /* create a new one */
324
325         for (list<RegionView *>::iterator i = region_views.begin(); i != region_views.end(); ++i) {
326                 AudioRegionView* arv = dynamic_cast<AudioRegionView*>(*i);
327
328                 if (!lview && arv && (arv->region() == crossfade->out())) {
329                         lview = arv;
330                 }
331                 if (!rview && arv && (arv->region() == crossfade->in())) {
332                         rview = arv;
333                 }
334         }
335
336         CrossfadeView *cv = new CrossfadeView (_trackview.canvas_display,
337                                                _trackview,
338                                                 crossfade,
339                                                _samples_per_unit,
340                                                region_color,
341                                                *lview, *rview);
342
343         crossfade->Invalidated.connect (mem_fun (*this, &AudioStreamView::remove_crossfade));
344         crossfade_views.push_back (cv);
345
346         if (!Config->get_xfades_visible() || !crossfades_visible || layer_display == Stacked) {
347                 cv->hide ();
348         }
349 }
350
351 void
352 AudioStreamView::remove_crossfade (boost::shared_ptr<Region> r)
353 {
354         ENSURE_GUI_THREAD (bind (mem_fun (*this, &AudioStreamView::remove_crossfade), r));
355
356         boost::shared_ptr<Crossfade> xfade = boost::dynamic_pointer_cast<Crossfade> (r);
357
358         for (list<CrossfadeView*>::iterator i = crossfade_views.begin(); i != crossfade_views.end(); ++i) {
359                 if ((*i)->crossfade == xfade) {
360                         delete *i;
361                         crossfade_views.erase (i);
362                         break;
363                 }
364         }
365 }
366
367 void
368 AudioStreamView::redisplay_diskstream ()
369 {
370         list<RegionView *>::iterator i, tmp;
371         list<CrossfadeView*>::iterator xi, tmpx;
372
373         for (i = region_views.begin(); i != region_views.end(); ++i) {
374                 (*i)->set_valid (false);
375         }
376
377         for (xi = crossfade_views.begin(); xi != crossfade_views.end(); ++xi) {
378                 (*xi)->set_valid (false);
379                 if ((*xi)->visible() && layer_display != Stacked) {
380                         (*xi)->show ();
381                 }
382         }
383
384         if (_trackview.is_audio_track()) {
385                 _trackview.get_diskstream()->playlist()->foreach_region (static_cast<StreamView*>(this), &StreamView::add_region_view);
386
387                 boost::shared_ptr<AudioPlaylist> apl = boost::dynamic_pointer_cast<AudioPlaylist>(_trackview.get_diskstream()->playlist());
388                 if (apl)
389                         apl->foreach_crossfade (this, &AudioStreamView::add_crossfade);
390         }
391
392         for (i = region_views.begin(); i != region_views.end(); ) {
393                 tmp = i;
394                 tmp++;
395
396                 if (!(*i)->is_valid()) {
397                         delete *i;
398                         region_views.erase (i);
399                 } else {
400                         (*i)->enable_display(true);
401                         (*i)->set_y_position_and_height(0, height);
402                 }
403
404                 i = tmp;
405         }
406
407         for (xi = crossfade_views.begin(); xi != crossfade_views.end();) {
408                 tmpx = xi;
409                 tmpx++;
410
411                 if (!(*xi)->valid()) {
412                         delete *xi;
413                         crossfade_views.erase (xi);
414                 }
415
416                 xi = tmpx;
417         }
418
419         /* now fix layering */
420
421         for (RegionViewList::iterator i = region_views.begin(); i != region_views.end(); ++i) {
422                 region_layered (*i);
423         }
424 }
425
426 void
427 AudioStreamView::set_show_waveforms (bool yn)
428 {
429         for (list<RegionView *>::iterator i = region_views.begin(); i != region_views.end(); ++i) {
430                 AudioRegionView* const arv = dynamic_cast<AudioRegionView*>(*i);
431                 if (arv)
432                         arv->set_waveform_visible (yn);
433         }
434 }
435
436 void
437 AudioStreamView::set_waveform_shape (WaveformShape shape)
438 {
439         for (RegionViewList::iterator i = region_views.begin(); i != region_views.end(); ++i) {
440                 AudioRegionView* const arv = dynamic_cast<AudioRegionView*>(*i);
441                 if (arv)
442                         arv->set_waveform_shape (shape);
443         }
444         _waveform_shape = shape;
445 }               
446
447 void
448 AudioStreamView::set_waveform_scale (WaveformScale scale)
449 {
450         for (RegionViewList::iterator i = region_views.begin(); i != region_views.end(); ++i) {
451                 AudioRegionView* const arv = dynamic_cast<AudioRegionView*>(*i);
452                 if (arv) 
453                         arv->set_waveform_scale (scale);
454         }
455         _waveform_scale = scale;
456 }               
457
458 void
459 AudioStreamView::setup_rec_box ()
460 {
461         // cerr << _trackview.name() << " streamview SRB\n";
462
463         if (_trackview.session().transport_rolling()) {
464
465                 // cerr << "\trolling\n";
466
467                 if (!rec_active && 
468                     _trackview.session().record_status() == Session::Recording && 
469                     _trackview.get_diskstream()->record_enabled()) {
470
471                         if (_trackview.audio_track()->mode() == Normal && use_rec_regions && rec_regions.size() == rec_rects.size()) {
472
473                                 /* add a new region, but don't bother if they set use_rec_regions mid-record */
474
475                                 SourceList sources;
476
477                                 for (list<sigc::connection>::iterator prc = rec_data_ready_connections.begin(); prc != rec_data_ready_connections.end(); ++prc) {
478                                         (*prc).disconnect();
479                                 }
480                                 rec_data_ready_connections.clear();
481                                         
482                                 // FIXME
483                                 boost::shared_ptr<AudioDiskstream> ads = boost::dynamic_pointer_cast<AudioDiskstream>(_trackview.get_diskstream());
484                                 assert(ads);
485
486                                 for (uint32_t n=0; n < ads->n_channels().n_audio(); ++n) {
487                                         boost::shared_ptr<AudioFileSource> src = boost::static_pointer_cast<AudioFileSource> (ads->write_source (n));
488                                         if (src) {
489                                                 sources.push_back (src);
490                                                 
491                                                 rec_data_ready_connections.push_back (src->PeakRangeReady.connect (bind
492                                                         (mem_fun (*this, &AudioStreamView::rec_peak_range_ready), boost::weak_ptr<Source>(src)))); 
493                                         }
494                                 }
495
496                                 // handle multi
497                                 
498                                 nframes_t start = 0;
499                                 if (rec_regions.size() > 0) {
500                                         start = rec_regions.back().first->start() + _trackview.get_diskstream()->get_captured_frames(rec_regions.size()-1);
501                                 }
502                                 
503                                 boost::shared_ptr<AudioRegion> region (boost::dynamic_pointer_cast<AudioRegion>
504                                                                        (RegionFactory::create (sources, start, 1 , "", 0, (Region::Flag)(Region::DefaultFlags | Region::DoNotSaveState), false)));
505                                 assert(region);
506                                 region->set_position (_trackview.session().transport_frame(), this);
507
508                                 rec_regions.push_back (make_pair(region, (RegionView*)0));
509                         }
510                         
511                         /* start a new rec box */
512
513                         boost::shared_ptr<AudioTrack> at;
514
515                         at = _trackview.audio_track(); /* we know what it is already */
516                         boost::shared_ptr<AudioDiskstream> ds = at->audio_diskstream();
517                         nframes_t frame_pos = ds->current_capture_start ();
518                         gdouble xstart = _trackview.editor.frame_to_pixel (frame_pos);
519                         gdouble xend;
520                         uint32_t fill_color;
521
522                         switch (_trackview.audio_track()->mode()) {
523                         case Normal:
524                                 xend = xstart;
525                                 fill_color = ARDOUR_UI::config()->canvasvar_RecordingRect.get();
526                                 break;
527
528                         case Destructive:
529                                 xend = xstart + 2;
530                                 fill_color = ARDOUR_UI::config()->canvasvar_RecordingRect.get();
531                                 /* make the recording rect translucent to allow
532                                    the user to see the peak data coming in, etc.
533                                 */
534                                 fill_color = UINT_RGBA_CHANGE_A (fill_color, 120);
535                                 break;
536                         }
537                         
538                         ArdourCanvas::SimpleRect * rec_rect = new Gnome::Canvas::SimpleRect (*canvas_group);
539                         rec_rect->property_x1() = xstart;
540                         rec_rect->property_y1() = 1.0;
541                         rec_rect->property_x2() = xend;
542                         rec_rect->property_y2() = (double) _trackview.height - 1;
543                         rec_rect->property_outline_color_rgba() = ARDOUR_UI::config()->canvasvar_RecordingRect.get();
544                         rec_rect->property_fill_color_rgba() = fill_color;
545                         rec_rect->lower_to_bottom();
546                         
547                         RecBoxInfo recbox;
548                         recbox.rectangle = rec_rect;
549                         recbox.start = _trackview.session().transport_frame();
550                         recbox.length = 0;
551                         
552                         rec_rects.push_back (recbox);
553                         
554                         screen_update_connection.disconnect();
555                         screen_update_connection = ARDOUR_UI::instance()->SuperRapidScreenUpdate.connect (mem_fun (*this, &AudioStreamView::update_rec_box));   
556                         rec_updating = true;
557                         rec_active = true;
558
559                 } else if (rec_active &&
560                            (_trackview.session().record_status() != Session::Recording ||
561                             !_trackview.get_diskstream()->record_enabled())) {
562
563                         screen_update_connection.disconnect();
564                         rec_active = false;
565                         rec_updating = false;
566
567                 }
568                 
569         } else {
570
571                 // cerr << "\tNOT rolling, rec_rects = " << rec_rects.size() << " rec_regions = " << rec_regions.size() << endl;
572
573                 if (!rec_rects.empty() || !rec_regions.empty()) {
574
575                         /* disconnect rapid update */
576                         screen_update_connection.disconnect();
577
578                         for (list<sigc::connection>::iterator prc = rec_data_ready_connections.begin(); prc != rec_data_ready_connections.end(); ++prc) {
579                                 (*prc).disconnect();
580                         }
581                         rec_data_ready_connections.clear();
582
583                         rec_updating = false;
584                         rec_active = false;
585                         
586                         /* remove temp regions */
587
588                         for (list<pair<boost::shared_ptr<Region>,RegionView*> >::iterator iter = rec_regions.begin(); iter != rec_regions.end(); ) {
589                                 list<pair<boost::shared_ptr<Region>,RegionView*> >::iterator tmp;
590
591                                 tmp = iter;
592                                 ++tmp;
593
594                                 (*iter).first->drop_references ();
595
596                                 iter = tmp;
597                         }
598                                 
599                         rec_regions.clear();
600
601                         // cerr << "\tclear " << rec_rects.size() << " rec rects\n";
602
603                         /* transport stopped, clear boxes */
604                         for (vector<RecBoxInfo>::iterator iter=rec_rects.begin(); iter != rec_rects.end(); ++iter) {
605                                 RecBoxInfo &rect = (*iter);
606                                 delete rect.rectangle;
607                         }
608                         
609                         rec_rects.clear();
610                         
611                 }
612         }
613 }
614
615 void
616 AudioStreamView::foreach_crossfadeview (void (CrossfadeView::*pmf)(void))
617 {
618         for (list<CrossfadeView*>::iterator i = crossfade_views.begin(); i != crossfade_views.end(); ++i) {
619                 ((*i)->*pmf) ();
620         }
621 }
622
623 void
624 AudioStreamView::rec_peak_range_ready (nframes_t start, nframes_t cnt, boost::weak_ptr<Source> weak_src)
625 {
626         ENSURE_GUI_THREAD(bind (mem_fun (*this, &AudioStreamView::rec_peak_range_ready), start, cnt, weak_src));
627         
628         boost::shared_ptr<Source> src (weak_src.lock());
629
630         if (!src) {
631                 return; 
632         }
633
634         // this is called from the peak building thread
635         
636         if (rec_data_ready_map.size() == 0 || start+cnt > last_rec_data_frame) {
637                 last_rec_data_frame = start + cnt;
638         }
639         
640         rec_data_ready_map[src] = true;
641         
642         if (rec_data_ready_map.size() == _trackview.get_diskstream()->n_channels().n_audio()) {
643                 this->update_rec_regions ();
644                 rec_data_ready_map.clear();
645         }
646 }
647
648 void
649 AudioStreamView::update_rec_regions ()
650 {
651         if (use_rec_regions) {
652
653                 uint32_t n = 0;
654
655                 for (list<pair<boost::shared_ptr<Region>,RegionView*> >::iterator iter = rec_regions.begin(); iter != rec_regions.end(); n++) {
656
657                         list<pair<boost::shared_ptr<Region>,RegionView*> >::iterator tmp;
658
659                         tmp = iter;
660                         ++tmp;
661
662                         if (!canvas_item_visible (rec_rects[n].rectangle)) {
663                                 /* rect already hidden, this region is done */
664                                 iter = tmp;
665                                 continue;
666                         }
667                         
668                         boost::shared_ptr<AudioRegion> region = boost::dynamic_pointer_cast<AudioRegion>(iter->first);
669                         if (!region) {
670                                 continue;
671                         }
672
673                         nframes_t origlen = region->length();
674
675                         if (region == rec_regions.back().first && rec_active) {
676
677                                 if (last_rec_data_frame > region->start()) {
678
679                                         nframes_t nlen = last_rec_data_frame - region->start();
680
681                                         if (nlen != region->length()) {
682
683                                                 region->freeze ();
684                                                 region->set_position (_trackview.get_diskstream()->get_capture_start_frame(n), this);
685                                                 region->set_length (nlen, this);
686                                                 region->thaw ("updated");
687
688                                                 if (origlen == 1) {
689                                                         /* our special initial length */
690                                                         add_region_view_internal (region, false);
691                                                 }
692
693                                                 /* also update rect */
694                                                 ArdourCanvas::SimpleRect * rect = rec_rects[n].rectangle;
695                                                 gdouble xend = _trackview.editor.frame_to_pixel (region->position() + region->length());
696                                                 rect->property_x2() = xend;
697                                         }
698                                 }
699
700                         } else {
701
702                                 nframes_t nlen = _trackview.get_diskstream()->get_captured_frames(n);
703
704                                 if (nlen != region->length()) {
705
706                                         if (region->source(0)->length() >= region->start() + nlen) {
707
708                                                 region->freeze ();
709                                                 region->set_position (_trackview.get_diskstream()->get_capture_start_frame(n), this);
710                                                 region->set_length (nlen, this);
711                                                 region->thaw ("updated");
712                                                 
713                                                 if (origlen == 1) {
714                                                         /* our special initial length */
715                                                         add_region_view_internal (region, false);
716                                                 }
717                                                 
718                                                 /* also hide rect */
719                                                 ArdourCanvas::Item * rect = rec_rects[n].rectangle;
720                                                 rect->hide();
721
722                                         }
723                                 }
724                         }
725
726                         iter = tmp;
727                 }
728         }
729 }
730
731 void
732 AudioStreamView::show_all_xfades ()
733 {
734         foreach_crossfadeview (&CrossfadeView::show);
735         crossfades_visible = true;
736 }
737
738 void
739 AudioStreamView::hide_all_xfades ()
740 {
741         foreach_crossfadeview (&CrossfadeView::hide);
742         crossfades_visible = false;
743 }
744
745 void
746 AudioStreamView::hide_xfades_involving (AudioRegionView& rv)
747 {
748         for (list<CrossfadeView *>::iterator i = crossfade_views.begin(); i != crossfade_views.end(); ++i) {
749                 if ((*i)->crossfade->involves (rv.audio_region())) {
750                         (*i)->fake_hide ();
751                 }
752         }
753 }
754
755 void
756 AudioStreamView::reveal_xfades_involving (AudioRegionView& rv)
757 {
758         for (list<CrossfadeView *>::iterator i = crossfade_views.begin(); i != crossfade_views.end(); ++i) {
759                 if ((*i)->crossfade->involves (rv.audio_region()) && (*i)->visible() && layer_display != Stacked) {
760                         (*i)->show ();
761                 }
762         }
763 }
764
765 void
766 AudioStreamView::color_handler ()
767 {
768         //case cAudioTrackBase:
769         if (_trackview.is_track()) {
770                 canvas_rect->property_fill_color_rgba() = ARDOUR_UI::config()->canvasvar_AudioTrackBase.get();
771         } 
772
773         //case cAudioBusBase:
774         if (!_trackview.is_track()) {
775                 canvas_rect->property_fill_color_rgba() = ARDOUR_UI::config()->canvasvar_AudioBusBase.get();
776         }
777
778 }
779
780 void
781 AudioStreamView::update_contents_y_position_and_height ()
782 {
783         StreamView::update_contents_y_position_and_height ();
784         
785         for (CrossfadeViewList::iterator i = crossfade_views.begin(); i != crossfade_views.end(); ++i) {
786                 if (layer_display == Overlaid) {
787                         (*i)->show ();
788                         (*i)->set_y_position_and_height (0, height);
789                 } else {
790                         (*i)->hide ();
791                 }
792         }
793 }