gtk2_ardour/streamview.cc

   1 #include <cmath>
   2
   3 #include <gtkmm.h>
   4
   5 #include <gtkmm2ext/gtk_ui.h>
   6
   7 #include <ardour/audioplaylist.h>
   8 #include <ardour/audioregion.h>
   9 #include <ardour/audiosource.h>
  10 #include <ardour/audio_diskstream.h>
  11 #include <ardour/audio_track.h>
  12 #include <ardour/playlist_templates.h>
  13 #include <ardour/source.h>
  14
  15 #include "streamview.h"
  16 #include "regionview.h"
  17 #include "taperegionview.h"
  18 #include "audio_time_axis.h"
  19 #include "canvas-waveview.h"
  20 #include "canvas-simplerect.h"
  21 #include "region_selection.h"
  22 #include "selection.h"
  23 #include "public_editor.h"
  24 #include "ardour_ui.h"
  25 #include "crossfade_view.h"
  26 #include "rgb_macros.h"
  27 #include "gui_thread.h"
  28 #include "utils.h"
  29 #include "color.h"
  30
  31 using namespace ARDOUR;
  32 using namespace Editing;
  33
  34 StreamView::StreamView (AudioTimeAxisView& tv)
  35         : _trackview (tv)
  36 {
  37         region_color = _trackview.color();
  38         crossfades_visible = true;
  39
  40         if (tv.is_audio_track()) {
  41                 /* TRACK */
  42                 //stream_base_color = RGBA_TO_UINT (222,223,218,255);
  43                 stream_base_color = color_map[cAudioTrackBase];
  44         } else {
  45                 /* BUS */
  46                 //stream_base_color = RGBA_TO_UINT (230,226,238,255);
  47                 stream_base_color = color_map[cAudioBusBase];
  48         }
  49
  50         /* set_position() will position the group */
  51
  52         canvas_group = new ArdourCanvas::Group(*_trackview.canvas_display);
  53
  54         canvas_rect = new ArdourCanvas::SimpleRect (*canvas_group);
  55         canvas_rect->property_x1() = 0.0;
  56         canvas_rect->property_y1() = 0.0;
  57         canvas_rect->property_x2() = 1000000.0;
  58         canvas_rect->property_y2() = (double) tv.height;
  59         canvas_rect->property_outline_color_rgba() = color_map[cAudioTrackOutline];
  60         canvas_rect->property_outline_what() = (guint32) (0x1|0x2|0x8);  // outline ends and bottom
  61         canvas_rect->property_fill_color_rgba() = stream_base_color;
  62
  63         canvas_rect->signal_event().connect (bind (mem_fun (_trackview.editor, &PublicEditor::canvas_stream_view_event), canvas_rect, &_trackview));
  64
  65         _samples_per_unit = _trackview.editor.get_current_zoom();
  66         _amplitude_above_axis = 1.0;
  67
  68         if (_trackview.is_audio_track()) {
  69                 _trackview.audio_track()->diskstream_changed.connect (mem_fun (*this, &StreamView::diskstream_changed));
  70                 _trackview.session().TransportStateChange.connect (mem_fun (*this, &StreamView::transport_changed));
  71                 _trackview.get_diskstream()->record_enable_changed.connect (mem_fun (*this, &StreamView::rec_enable_changed));
  72                 _trackview.session().RecordStateChanged.connect (mem_fun (*this, &StreamView::sess_rec_enable_changed));
  73         }
  74
  75         rec_updating = false;
  76         rec_active = false;
  77         use_rec_regions = tv.editor.show_waveforms_recording ();
  78         last_rec_peak_frame = 0;
  79
  80         ColorChanged.connect (mem_fun (*this, &StreamView::color_handler));
  81 }
  82
  83 StreamView::~StreamView ()
  84 {
  85         undisplay_diskstream ();
  86         delete canvas_group;
  87 }
  88
  89 void
  90 StreamView::attach ()
  91 {
  92         if (_trackview.is_audio_track()) {
  93                 display_diskstream (_trackview.get_diskstream());
  94         }
  95 }
  96
  97 int
  98 StreamView::set_position (gdouble x, gdouble y)
  99
 100 {
 101         canvas_group->property_x() = x;
 102         canvas_group->property_y() = y;
 103         return 0;
 104 }
 105
 106 int
 107 StreamView::set_height (gdouble h)
 108 {
 109         /* limit the values to something sane-ish */
 110
 111         if (h < 10.0 || h > 1000.0) {
 112                 return -1;
 113         }
 114
 115         canvas_rect->property_y2() = h;
 116
 117         for (AudioRegionViewList::iterator i = region_views.begin(); i != region_views.end(); ++i) {
 118                 (*i)->set_height (h);
 119         }
 120
 121         for (CrossfadeViewList::iterator i = crossfade_views.begin(); i != crossfade_views.end(); ++i) {
 122                 (*i)->set_height (h);
 123         }
 124
 125         for (vector<RecBoxInfo>::iterator i = rec_rects.begin(); i != rec_rects.end(); ++i) {
 126                 RecBoxInfo &recbox = (*i);
 127                 recbox.rectangle->property_y2() = h - 1.0;
 128         }
 129
 130         return 0;
 131 }
 132
 133 int
 134 StreamView::set_samples_per_unit (gdouble spp)
 135 {
 136         AudioRegionViewList::iterator i;
 137
 138         if (spp < 1.0) {
 139                 return -1;
 140         }
 141
 142         _samples_per_unit = spp;
 143
 144         for (i = region_views.begin(); i != region_views.end(); ++i) {
 145                 (*i)->set_samples_per_unit (spp);
 146         }
 147
 148         for (CrossfadeViewList::iterator xi = crossfade_views.begin(); xi != crossfade_views.end(); ++xi) {
 149                 (*xi)->set_samples_per_unit (spp);
 150         }
 151
 152         for (vector<RecBoxInfo>::iterator xi = rec_rects.begin(); xi != rec_rects.end(); ++xi) {
 153                 RecBoxInfo &recbox = (*xi);
 154
 155                 gdouble xstart = _trackview.editor.frame_to_pixel ( recbox.start );
 156                 gdouble xend = _trackview.editor.frame_to_pixel ( recbox.start + recbox.length );
 157
 158                 recbox.rectangle->property_x1() = xstart;
 159                 recbox.rectangle->property_x2() = xend;
 160         }
 161
 162         return 0;
 163 }
 164
 165 int
 166 StreamView::set_amplitude_above_axis (gdouble app)
 167
 168 {
 169         AudioRegionViewList::iterator i;
 170
 171         if (app < 1.0) {
 172                 return -1;
 173         }
 174
 175         _amplitude_above_axis = app;
 176
 177         for (i = region_views.begin(); i != region_views.end(); ++i) {
 178                 (*i)->set_amplitude_above_axis (app);
 179         }
 180
 181         return 0;
 182 }
 183
 184 void
 185 StreamView::add_region_view (Region *r)
 186 {
 187         add_region_view_internal (r, true);
 188 }
 189
 190 void
 191 StreamView::add_region_view_internal (Region *r, bool wait_for_waves)
 192 {
 193         ENSURE_GUI_THREAD (bind (mem_fun (*this, &StreamView::add_region_view), r));
 194
 195         AudioRegion* region = dynamic_cast<AudioRegion*> (r);
 196
 197         if (region == 0) {
 198                 return;
 199         }
 200
 201         AudioRegionView *region_view;
 202         list<AudioRegionView *>::iterator i;
 203
 204         for (i = region_views.begin(); i != region_views.end(); ++i) {
 205                 if (&(*i)->region == region) {
 206
 207                         /* great. we already have a AudioRegionView for this Region. use it again.
 208                          */
 209
 210                         (*i)->set_valid (true);
 211                         return;
 212                 }
 213         }
 214
 215         switch (_trackview.audio_track()->mode()) {
 216         case Normal:
 217                 region_view = new AudioRegionView (canvas_group, _trackview, *region,
 218                                                    _samples_per_unit, region_color);
 219                 break;
 220         case Destructive:
 221                 region_view = new TapeAudioRegionView (canvas_group, _trackview, *region,
 222                                                        _samples_per_unit, region_color);
 223                 break;
 224         }
 225
 226         region_view->init (_amplitude_above_axis, region_color, wait_for_waves);
 227         region_views.push_front (region_view);
 228
 229         /* follow global waveform setting */
 230
 231         region_view->set_waveform_visible(_trackview.editor.show_waveforms());
 232
 233         /* catch regionview going away */
 234
 235         region->GoingAway.connect (mem_fun (*this, &StreamView::remove_region_view));
 236
 237         AudioRegionViewAdded (region_view);
 238 }
 239
 240 void
 241 StreamView::remove_region_view (Region *r)
 242 {
 243         ENSURE_GUI_THREAD (bind (mem_fun (*this, &StreamView::remove_region_view), r));
 244
 245         AudioRegion* ar = dynamic_cast<AudioRegion*> (r);
 246
 247         if (ar == 0) {
 248                 return;
 249         }
 250
 251         for (list<AudioRegionView *>::iterator i = region_views.begin(); i != region_views.end(); ++i) {
 252                 if (&((*i)->region) == ar) {
 253                         delete *i;
 254                         region_views.erase (i);
 255                         break;
 256                 }
 257         }
 258
 259         for (list<CrossfadeView *>::iterator i = crossfade_views.begin(); i != crossfade_views.end();) {
 260                 list<CrossfadeView*>::iterator tmp;
 261
 262                 tmp = i;
 263                 ++tmp;
 264
 265                 if ((*i)->crossfade.involves (*ar)) {
 266                         delete *i;
 267                         crossfade_views.erase (i);
 268                 }
 269
 270                 i = tmp;
 271         }
 272 }
 273
 274 void
 275 StreamView::remove_rec_region (Region *r)
 276 {
 277         ENSURE_GUI_THREAD(bind (mem_fun (*this, &StreamView::remove_rec_region), r));
 278
 279         if (!Gtkmm2ext::UI::instance()->caller_is_ui_thread()) {
 280                 fatal << "region deleted from non-GUI thread!" << endmsg;
 281                 /*NOTREACHED*/
 282         }
 283
 284         AudioRegion* ar = dynamic_cast<AudioRegion*> (r);
 285
 286         if (ar == 0) {
 287                 return;
 288         }
 289
 290         for (list<AudioRegion *>::iterator i = rec_regions.begin(); i != rec_regions.end(); ++i) {
 291                 if (*i == ar) {
 292                         rec_regions.erase (i);
 293                         break;
 294                 }
 295         }
 296 }
 297
 298 void
 299 StreamView::undisplay_diskstream ()
 300 {
 301
 302         for (AudioRegionViewList::iterator i = region_views.begin(); i != region_views.end(); ++i) {
 303                 delete *i;
 304         }
 305
 306         for (CrossfadeViewList::iterator i = crossfade_views.begin(); i != crossfade_views.end(); ++i) {
 307                 delete *i;
 308         }
 309
 310         region_views.clear();
 311         crossfade_views.clear ();
 312 }
 313
 314 void
 315 StreamView::display_diskstream (AudioDiskstream *ds)
 316 {
 317         playlist_change_connection.disconnect();
 318         playlist_changed (ds);
 319         playlist_change_connection = ds->PlaylistChanged.connect (bind (mem_fun (*this, &StreamView::playlist_changed), ds));
 320 }
 321
 322 void
 323 StreamView::playlist_modified ()
 324 {
 325         ENSURE_GUI_THREAD (mem_fun (*this, &StreamView::playlist_modified));
 326
 327         /* if the playlist is modified, make sure xfades are on top and all the regionviews are stacked
 328            correctly.
 329         */
 330
 331         for (AudioRegionViewList::iterator i = region_views.begin(); i != region_views.end(); ++i) {
 332                 region_layered (*i);
 333         }
 334
 335         for (list<CrossfadeView *>::iterator i = crossfade_views.begin(); i != crossfade_views.end(); ++i) {
 336                 (*i)->get_canvas_group()->raise_to_top();
 337         }
 338 }
 339
 340 void
 341 StreamView::playlist_changed (AudioDiskstream *ds)
 342 {
 343         ENSURE_GUI_THREAD (bind (mem_fun (*this, &StreamView::playlist_changed), ds));
 344
 345         /* disconnect from old playlist */
 346
 347         for (vector<sigc::connection>::iterator i = playlist_connections.begin(); i != playlist_connections.end(); ++i) {
 348                 (*i).disconnect();
 349         }
 350
 351         playlist_connections.clear();
 352         undisplay_diskstream ();
 353
 354         /* draw it */
 355
 356         redisplay_diskstream ();
 357
 358         /* catch changes */
 359
 360         playlist_connections.push_back (ds->playlist()->RegionAdded.connect (mem_fun (*this, &StreamView::add_region_view)));
 361         playlist_connections.push_back (ds->playlist()->RegionRemoved.connect (mem_fun (*this, &StreamView::remove_region_view)));
 362         playlist_connections.push_back (ds->playlist()->StateChanged.connect (mem_fun (*this, &StreamView::playlist_state_changed)));
 363         playlist_connections.push_back (ds->playlist()->Modified.connect (mem_fun (*this, &StreamView::playlist_modified)));
 364         playlist_connections.push_back (ds->playlist()->NewCrossfade.connect (mem_fun (*this, &StreamView::add_crossfade)));
 365 }
 366
 367 void
 368 StreamView::add_crossfade (Crossfade *crossfade)
 369 {
 370         AudioRegionView* lview = 0;
 371         AudioRegionView* rview = 0;
 372
 373         ENSURE_GUI_THREAD (bind (mem_fun (*this, &StreamView::add_crossfade), crossfade));
 374
 375         /* first see if we already have a CrossfadeView for this Crossfade */
 376
 377         for (list<CrossfadeView *>::iterator i = crossfade_views.begin(); i != crossfade_views.end(); ++i) {
 378                 if (&(*i)->crossfade == crossfade) {
 379                         if (!crossfades_visible) {
 380                                 (*i)->hide();
 381                         } else {
 382                                 (*i)->show ();
 383                         }
 384                         (*i)->set_valid (true);
 385                         return;
 386                 }
 387         }
 388
 389         /* create a new one */
 390
 391         for (list<AudioRegionView *>::iterator i = region_views.begin(); i != region_views.end(); ++i) {
 392                 if (!lview && &((*i)->region) == &crossfade->out()) {
 393                         lview = *i;
 394                 }
 395                 if (!rview && &((*i)->region) == &crossfade->in()) {
 396                         rview = *i;
 397                 }
 398         }
 399
 400         CrossfadeView *cv = new CrossfadeView (_trackview.canvas_display,
 401                                                _trackview,
 402                                                *crossfade,
 403                                                _samples_per_unit,
 404                                                region_color,
 405                                                *lview, *rview);
 406
 407         crossfade->Invalidated.connect (mem_fun (*this, &StreamView::remove_crossfade));
 408         crossfade_views.push_back (cv);
 409
 410         if (!crossfades_visible) {
 411                 cv->hide ();
 412         }
 413 }
 414
 415 void
 416 StreamView::remove_crossfade (Crossfade *xfade)
 417 {
 418         ENSURE_GUI_THREAD (bind (mem_fun (*this, &StreamView::remove_crossfade), xfade));
 419
 420         for (list<CrossfadeView*>::iterator i = crossfade_views.begin(); i != crossfade_views.end(); ++i) {
 421                 if (&(*i)->crossfade == xfade) {
 422                         delete *i;
 423                         crossfade_views.erase (i);
 424                         break;
 425                 }
 426         }
 427 }
 428
 429 void
 430 StreamView::playlist_state_changed (Change ignored)
 431 {
 432         ENSURE_GUI_THREAD (bind (mem_fun (*this, &StreamView::playlist_state_changed), ignored));
 433
 434         redisplay_diskstream ();
 435 }
 436
 437 void
 438 StreamView::redisplay_diskstream ()
 439 {
 440         list<AudioRegionView *>::iterator i, tmp;
 441         list<CrossfadeView*>::iterator xi, tmpx;
 442
 443
 444         for (i = region_views.begin(); i != region_views.end(); ++i) {
 445                 (*i)->set_valid (false);
 446         }
 447
 448         for (xi = crossfade_views.begin(); xi != crossfade_views.end(); ++xi) {
 449                 (*xi)->set_valid (false);
 450                 if ((*xi)->visible()) {
 451                         (*xi)->show ();
 452                 }
 453         }
 454
 455         if (_trackview.is_audio_track()) {
 456                 _trackview.get_diskstream()->playlist()->foreach_region (this, &StreamView::add_region_view);
 457                 _trackview.get_diskstream()->playlist()->foreach_crossfade (this, &StreamView::add_crossfade);
 458         }
 459
 460         for (i = region_views.begin(); i != region_views.end(); ) {
 461                 tmp = i;
 462                 tmp++;
 463
 464                 if (!(*i)->is_valid()) {
 465                         delete *i;
 466                         region_views.erase (i);
 467                 }
 468
 469                 i = tmp;
 470         }
 471
 472         for (xi = crossfade_views.begin(); xi != crossfade_views.end();) {
 473                 tmpx = xi;
 474                 tmpx++;
 475
 476                 if (!(*xi)->valid()) {
 477                         delete *xi;
 478                         crossfade_views.erase (xi);
 479                 }
 480
 481                 xi = tmpx;
 482         }
 483
 484         /* now fix layering */
 485
 486         playlist_modified ();
 487 }
 488
 489 void
 490 StreamView::diskstream_changed (void *src_ignored)
 491 {
 492         AudioTrack *at;
 493
 494         if ((at = _trackview.audio_track()) != 0) {
 495                 AudioDiskstream& ds = at->disk_stream();
 496                 /* XXX grrr: when will SigC++ allow me to bind references? */
 497                 Gtkmm2ext::UI::instance()->call_slot (bind (mem_fun (*this, &StreamView::display_diskstream), &ds));
 498         } else {
 499                 Gtkmm2ext::UI::instance()->call_slot (mem_fun (*this, &StreamView::undisplay_diskstream));
 500         }
 501 }
 502
 503 void
 504 StreamView::apply_color (Gdk::Color& color, ColorTarget target)
 505
 506 {
 507         list<AudioRegionView *>::iterator i;
 508
 509         switch (target) {
 510         case RegionColor:
 511                 region_color = color;
 512                 for (i = region_views.begin(); i != region_views.end(); ++i) {
 513                         (*i)->set_color (region_color);
 514                 }
 515                 // stream_base_color = RGBA_TO_UINT (color.red/256, color.green/256, color.blue/256, 255);
 516                 // gnome_canvas_item_set (canvas_rect, "fill_color_rgba", stream_base_color, NULL);
 517                 break;
 518
 519         case StreamBaseColor:
 520                 // stream_base_color = RGBA_TO_UINT (color.red/256, color.green/256, color.blue/256, 255);
 521                 // gnome_canvas_item_set (canvas_rect, "fill_color_rgba", stream_base_color, NULL);
 522                 break;
 523         }
 524 }
 525
 526 void
 527 StreamView::set_show_waveforms (bool yn)
 528 {
 529         for (list<AudioRegionView *>::iterator i = region_views.begin(); i != region_views.end(); ++i) {
 530                         (*i)->set_waveform_visible (yn);
 531         }
 532 }
 533
 534 void
 535 StreamView::set_selected_regionviews (AudioRegionSelection& regions)
 536 {
 537         bool selected;
 538
 539         // cerr << _trackview.name() << " (selected = " << regions.size() << ")" << endl;
 540         for (list<AudioRegionView*>::iterator i = region_views.begin(); i != region_views.end(); ++i) {
 541
 542                 selected = false;
 543
 544                 for (AudioRegionSelection::iterator ii = regions.begin(); ii != regions.end(); ++ii) {
 545                         if (*i == *ii) {
 546                                 selected = true;
 547                         }
 548                 }
 549
 550                 // cerr << "\tregion " << (*i)->region.name() << " selected = " << selected << endl;
 551                 (*i)->set_selected (selected, this);
 552         }
 553 }
 554
 555 void
 556 StreamView::get_selectables (jack_nframes_t start, jack_nframes_t end, list<Selectable*>& results)
 557 {
 558         for (list<AudioRegionView*>::iterator i = region_views.begin(); i != region_views.end(); ++i) {
 559                 if ((*i)->region.coverage(start, end) != OverlapNone) {
 560                         results.push_back (*i);
 561                 }
 562         }
 563 }
 564
 565 void
 566 StreamView::get_inverted_selectables (Selection& sel, list<Selectable*>& results)
 567 {
 568         for (list<AudioRegionView*>::iterator i = region_views.begin(); i != region_views.end(); ++i) {
 569                 if (!sel.audio_regions.contains (*i)) {
 570                         results.push_back (*i);
 571                 }
 572         }
 573 }
 574
 575 void
 576 StreamView::set_waveform_shape (WaveformShape shape)
 577 {
 578         for (AudioRegionViewList::iterator i = region_views.begin(); i != region_views.end(); ++i) {
 579                 (*i)->set_waveform_shape (shape);
 580         }
 581 }
 582
 583 void
 584 StreamView::region_layered (AudioRegionView* rv)
 585 {
 586         rv->get_canvas_group()->lower_to_bottom();
 587
 588         /* don't ever leave it at the bottom, since then it doesn't
 589            get events - the  parent group does instead ...
 590         */
 591
 592         rv->get_canvas_group()->raise (rv->region.layer() + 1);
 593 }
 594
 595 void
 596 StreamView::rec_enable_changed (void *src)
 597 {
 598         Gtkmm2ext::UI::instance()->call_slot (mem_fun (*this, &StreamView::setup_rec_box));
 599 }
 600
 601 void
 602 StreamView::sess_rec_enable_changed ()
 603 {
 604         Gtkmm2ext::UI::instance()->call_slot (mem_fun (*this, &StreamView::setup_rec_box));
 605 }
 606
 607 void
 608 StreamView::transport_changed()
 609 {
 610         Gtkmm2ext::UI::instance()->call_slot (mem_fun (*this, &StreamView::setup_rec_box));
 611 }
 612
 613 void
 614 StreamView::setup_rec_box ()
 615 {
 616         // cerr << _trackview.name() << " streamview SRB\n";
 617
 618         if (_trackview.session().transport_rolling()) {
 619
 620                 // cerr << "\trolling\n";
 621
 622                 if (!rec_active &&
 623                     _trackview.session().record_status() == Session::Recording &&
 624                     _trackview.get_diskstream()->record_enabled()) {
 625
 626                         if (_trackview.audio_track()->mode() == Normal && use_rec_regions && rec_regions.size() == rec_rects.size()) {
 627
 628                                 /* add a new region, but don't bother if they set use_rec_regions mid-record */
 629
 630                                 AudioRegion::SourceList sources;
 631
 632                                 for (list<sigc::connection>::iterator prc = peak_ready_connections.begin(); prc != peak_ready_connections.end(); ++prc) {
 633                                         (*prc).disconnect();
 634                                 }
 635                                 peak_ready_connections.clear();
 636
 637                                 for (uint32_t n=0; n < _trackview.get_diskstream()->n_channels(); ++n) {
 638                                         AudioSource *src = (AudioSource *) _trackview.get_diskstream()->write_source (n);
 639                                         if (src) {
 640                                                 sources.push_back (src);
 641                                                 peak_ready_connections.push_back (src->PeakRangeReady.connect (bind (mem_fun (*this, &StreamView::rec_peak_range_ready), src)));
 642                                         }
 643                                 }
 644
 645                                 // handle multi
 646
 647                                 jack_nframes_t start = 0;
 648                                 if (rec_regions.size() > 0) {
 649                                         start = rec_regions.back()->start() + _trackview.get_diskstream()->get_captured_frames(rec_regions.size()-1);
 650                                 }
 651
 652                                 AudioRegion * region = new AudioRegion(sources, start, 1 , "", 0, (Region::Flag)(Region::DefaultFlags | Region::DoNotSaveState), false);
 653                                 region->set_position (_trackview.session().transport_frame(), this);
 654                                 rec_regions.push_back (region);
 655                                 /* catch it if it goes away */
 656                                 region->GoingAway.connect (mem_fun (*this, &StreamView::remove_rec_region));
 657
 658                                 /* we add the region later */
 659                         }
 660
 661                         /* start a new rec box */
 662
 663                         AudioTrack* at;
 664
 665                         at = _trackview.audio_track(); /* we know what it is already */
 666                         AudioDiskstream& ds = at->disk_stream();
 667                         jack_nframes_t frame_pos = ds.current_capture_start ();
 668                         gdouble xstart = _trackview.editor.frame_to_pixel (frame_pos);
 669                         gdouble xend;
 670                         uint32_t fill_color;
 671
 672                         switch (_trackview.audio_track()->mode()) {
 673                         case Normal:
 674                                 xend = xstart;
 675                                 fill_color = color_map[cRecordingRectFill];
 676                                 break;
 677
 678                         case Destructive:
 679                                 xend = xstart + 2;
 680                                 fill_color = color_map[cRecordingRectFill];
 681                                 /* make the recording rect translucent to allow
 682                                    the user to see the peak data coming in, etc.
 683                                 */
 684                                 fill_color = UINT_RGBA_CHANGE_A (fill_color, 120);
 685                                 break;
 686                         }
 687
 688                         ArdourCanvas::SimpleRect * rec_rect = new Gnome::Canvas::SimpleRect (*canvas_group);
 689                         rec_rect->property_x1() = xstart;
 690                         rec_rect->property_y1() = 1.0;
 691                         rec_rect->property_x2() = xend;
 692                         rec_rect->property_y2() = (double) _trackview.height - 1;
 693                         rec_rect->property_outline_color_rgba() = color_map[cRecordingRectOutline];
 694                         rec_rect->property_fill_color_rgba() = fill_color;
 695
 696                         RecBoxInfo recbox;
 697                         recbox.rectangle = rec_rect;
 698                         recbox.start = _trackview.session().transport_frame();
 699                         recbox.length = 0;
 700
 701                         rec_rects.push_back (recbox);
 702
 703                         screen_update_connection.disconnect();
 704                         screen_update_connection = ARDOUR_UI::instance()->SuperRapidScreenUpdate.connect (mem_fun (*this, &StreamView::update_rec_box));
 705                         rec_updating = true;
 706                         rec_active = true;
 707
 708                 } else if (rec_active &&
 709                            (_trackview.session().record_status() != Session::Recording ||
 710                             !_trackview.get_diskstream()->record_enabled())) {
 711
 712                         screen_update_connection.disconnect();
 713                         rec_active = false;
 714                         rec_updating = false;
 715
 716                 }
 717
 718         } else {
 719
 720                 // cerr << "\tNOT rolling, rec_rects = " << rec_rects.size() << " rec_regions = " << rec_regions.size() << endl;
 721
 722                 if (!rec_rects.empty() || !rec_regions.empty()) {
 723
 724                         /* disconnect rapid update */
 725                         screen_update_connection.disconnect();
 726
 727                         for (list<sigc::connection>::iterator prc = peak_ready_connections.begin(); prc != peak_ready_connections.end(); ++prc) {
 728                                 (*prc).disconnect();
 729                         }
 730                         peak_ready_connections.clear();
 731
 732                         rec_updating = false;
 733                         rec_active = false;
 734                         last_rec_peak_frame = 0;
 735
 736                         /* remove temp regions */
 737                         for (list<AudioRegion*>::iterator iter=rec_regions.begin(); iter != rec_regions.end(); )
 738                         {
 739                                 list<AudioRegion*>::iterator tmp;
 740
 741                                 tmp = iter;
 742                                 ++tmp;
 743
 744                                 /* this will trigger the remove_region_view */
 745                                 delete *iter;
 746
 747                                 iter = tmp;
 748                         }
 749
 750                         rec_regions.clear();
 751
 752                         // cerr << "\tclear " << rec_rects.size() << " rec rects\n";
 753
 754
 755                         /* transport stopped, clear boxes */
 756                         for (vector<RecBoxInfo>::iterator iter=rec_rects.begin(); iter != rec_rects.end(); ++iter) {
 757                                 RecBoxInfo &rect = (*iter);
 758                                 delete rect.rectangle;
 759                         }
 760
 761                         rec_rects.clear();
 762
 763                 }
 764         }
 765 }
 766
 767
 768 void
 769 StreamView::update_rec_box ()
 770 {
 771         if (rec_active && rec_rects.size() > 0) {
 772                 /* only update the last box */
 773                 RecBoxInfo & rect = rec_rects.back();
 774                 jack_nframes_t at = _trackview.get_diskstream()->current_capture_end();
 775                 double xstart;
 776                 double xend;
 777
 778                 switch (_trackview.audio_track()->mode()) {
 779                 case Normal:
 780                         rect.length = at - rect.start;
 781                         xstart = _trackview.editor.frame_to_pixel (rect.start);
 782                         xend = _trackview.editor.frame_to_pixel (at);
 783                         break;
 784
 785                 case Destructive:
 786                         rect.length = 2;
 787                         xstart = _trackview.editor.frame_to_pixel (_trackview.get_diskstream()->current_capture_start());
 788                         xend = _trackview.editor.frame_to_pixel (at);
 789                         break;
 790                 }
 791
 792                 rect.rectangle->property_x1() = xstart;
 793                 rect.rectangle->property_x2() = xend;
 794         }
 795 }
 796
 797 AudioRegionView*
 798 StreamView::find_view (const AudioRegion& region)
 799 {
 800         for (list<AudioRegionView*>::iterator i = region_views.begin(); i != region_views.end(); ++i) {
 801
 802                 if (&(*i)->region == &region) {
 803                         return *i;
 804                 }
 805         }
 806         return 0;
 807 }
 808
 809 void
 810 StreamView::foreach_regionview (sigc::slot<void,AudioRegionView*> slot)
 811 {
 812         for (list<AudioRegionView*>::iterator i = region_views.begin(); i != region_views.end(); ++i) {
 813                 slot (*i);
 814         }
 815 }
 816
 817 void
 818 StreamView::foreach_crossfadeview (void (CrossfadeView::*pmf)(void))
 819 {
 820         for (list<CrossfadeView*>::iterator i = crossfade_views.begin(); i != crossfade_views.end(); ++i) {
 821                 ((*i)->*pmf) ();
 822         }
 823 }
 824
 825 void
 826 StreamView::rec_peak_range_ready (jack_nframes_t start, jack_nframes_t cnt, Source * src)
 827 {
 828         // this is called from the peak building thread
 829
 830         ENSURE_GUI_THREAD(bind (mem_fun (*this, &StreamView::rec_peak_range_ready), start, cnt, src));
 831
 832         if (rec_peak_ready_map.size() == 0 || start+cnt > last_rec_peak_frame) {
 833                 last_rec_peak_frame = start + cnt;
 834         }
 835
 836         rec_peak_ready_map[src] = true;
 837
 838         if (rec_peak_ready_map.size() == _trackview.get_diskstream()->n_channels()) {
 839                 this->update_rec_regions ();
 840                 rec_peak_ready_map.clear();
 841         }
 842 }
 843
 844 void
 845 StreamView::update_rec_regions ()
 846 {
 847         if (use_rec_regions) {
 848
 849                 uint32_t n = 0;
 850
 851                 for (list<AudioRegion*>::iterator iter = rec_regions.begin(); iter != rec_regions.end(); n++) {
 852
 853                         list<AudioRegion*>::iterator tmp;
 854
 855                         tmp = iter;
 856                         ++tmp;
 857
 858                         if (!canvas_item_visible (rec_rects[n].rectangle)) {
 859                                 /* rect already hidden, this region is done */
 860                                 iter = tmp;
 861                                 continue;
 862                         }
 863
 864                         AudioRegion * region = (*iter);
 865                         jack_nframes_t origlen = region->length();
 866
 867                         if (region == rec_regions.back() && rec_active) {
 868
 869                                 if (last_rec_peak_frame > region->start()) {
 870
 871                                         jack_nframes_t nlen = last_rec_peak_frame - region->start();
 872
 873                                         if (nlen != region->length()) {
 874
 875                                                 region->freeze ();
 876                                                 region->set_position (_trackview.get_diskstream()->get_capture_start_frame(n), this);
 877                                                 region->set_length (nlen, this);
 878                                                 region->thaw ("updated");
 879
 880                                                 if (origlen == 1) {
 881                                                         /* our special initial length */
 882                                                         add_region_view_internal (region, false);
 883                                                 }
 884
 885                                                 /* also update rect */
 886                                                 ArdourCanvas::SimpleRect * rect = rec_rects[n].rectangle;
 887                                                 gdouble xend = _trackview.editor.frame_to_pixel (region->position() + region->length());
 888                                                 rect->property_x2() = xend;
 889                                         }
 890                                 }
 891
 892                         } else {
 893
 894                                 jack_nframes_t nlen = _trackview.get_diskstream()->get_captured_frames(n);
 895
 896                                 if (nlen != region->length()) {
 897
 898                                         if (region->source(0).length() >= region->start() + nlen) {
 899
 900                                                 region->freeze ();
 901                                                 region->set_position (_trackview.get_diskstream()->get_capture_start_frame(n), this);
 902                                                 region->set_length (nlen, this);
 903                                                 region->thaw ("updated");
 904
 905                                                 if (origlen == 1) {
 906                                                         /* our special initial length */
 907                                                         add_region_view_internal (region, false);
 908                                                 }
 909
 910                                                 /* also hide rect */
 911                                                 ArdourCanvas::Item * rect = rec_rects[n].rectangle;
 912                                                 rect->hide();
 913
 914                                         }
 915                                 }
 916                         }
 917
 918                         iter = tmp;
 919                 }
 920         }
 921 }
 922
 923 void
 924 StreamView::show_all_xfades ()
 925 {
 926         foreach_crossfadeview (&CrossfadeView::show);
 927         crossfades_visible = true;
 928 }
 929
 930 void
 931 StreamView::hide_all_xfades ()
 932 {
 933         foreach_crossfadeview (&CrossfadeView::hide);
 934         crossfades_visible = false;
 935 }
 936
 937 void
 938 StreamView::hide_xfades_involving (AudioRegionView& rv)
 939 {
 940         for (list<CrossfadeView *>::iterator i = crossfade_views.begin(); i != crossfade_views.end(); ++i) {
 941                 if ((*i)->crossfade.involves (rv.region)) {
 942                         (*i)->fake_hide ();
 943                 }
 944         }
 945 }
 946
 947 void
 948 StreamView::reveal_xfades_involving (AudioRegionView& rv)
 949 {
 950         for (list<CrossfadeView *>::iterator i = crossfade_views.begin(); i != crossfade_views.end(); ++i) {
 951                 if ((*i)->crossfade.involves (rv.region) && (*i)->visible()) {
 952                         (*i)->show ();
 953                 }
 954         }
 955 }
 956
 957 void
 958 StreamView::color_handler (ColorID id, uint32_t val)
 959 {
 960         switch (id) {
 961         case cAudioTrackBase:
 962                 if (_trackview.is_audio_track()) {
 963                         canvas_rect->property_fill_color_rgba() = val;
 964                 }
 965                 break;
 966         case cAudioBusBase:
 967                 if (!_trackview.is_audio_track()) {
 968                         canvas_rect->property_fill_color_rgba() = val;
 969                 }
 970                 break;
 971         case cAudioTrackOutline:
 972                 canvas_rect->property_outline_color_rgba() = val;
 973                 break;
 974
 975         default:
 976                 break;
 977         }
 978 }