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