gtk2_ardour/audio_region_view.cc

   1 /*
   2     Copyright (C) 2001-2006 Paul Davis
   3
   4     This program is free software; you can r>edistribute 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 <algorithm>
  22
  23 #include <gtkmm.h>
  24
  25 #include <gtkmm2ext/gtk_ui.h>
  26
  27 #include "ardour/playlist.h"
  28 #include "ardour/audioregion.h"
  29 #include "ardour/audiosource.h"
  30 #include "ardour/audio_diskstream.h"
  31 #include "ardour/profile.h"
  32 #include "ardour/session.h"
  33
  34 #include "pbd/memento_command.h"
  35 #include "pbd/stacktrace.h"
  36
  37 #include "evoral/Curve.hpp"
  38
  39 #include "streamview.h"
  40 #include "audio_region_view.h"
  41 #include "audio_time_axis.h"
  42 #include "simplerect.h"
  43 #include "simpleline.h"
  44 #include "waveview.h"
  45 #include "public_editor.h"
  46 #include "audio_region_editor.h"
  47 #include "region_gain_line.h"
  48 #include "control_point.h"
  49 #include "ghostregion.h"
  50 #include "audio_time_axis.h"
  51 #include "utils.h"
  52 #include "rgb_macros.h"
  53 #include "gui_thread.h"
  54 #include "ardour_ui.h"
  55
  56 #include "i18n.h"
  57
  58 #define MUTED_ALPHA 10
  59
  60 using namespace std;
  61 using namespace ARDOUR;
  62 using namespace PBD;
  63 using namespace Editing;
  64 using namespace ArdourCanvas;
  65
  66 static const int32_t sync_mark_width = 9;
  67
  68 AudioRegionView::AudioRegionView (ArdourCanvas::Group *parent, RouteTimeAxisView &tv, boost::shared_ptr<AudioRegion> r, double spu,
  69                                   Gdk::Color const & basic_color)
  70         : RegionView (parent, tv, r, spu, basic_color)
  71         , sync_mark(0)
  72         , zero_line(0)
  73         , fade_in_shape(0)
  74         , fade_out_shape(0)
  75         , fade_in_handle(0)
  76         , fade_out_handle(0)
  77         , gain_line(0)
  78         , _amplitude_above_axis(1.0)
  79         , _flags(0)
  80         , fade_color(0)
  81 {
  82 }
  83
  84
  85 AudioRegionView::AudioRegionView (ArdourCanvas::Group *parent, RouteTimeAxisView &tv, boost::shared_ptr<AudioRegion> r, double spu,
  86                                   Gdk::Color const & basic_color, bool recording, TimeAxisViewItem::Visibility visibility)
  87         : RegionView (parent, tv, r, spu, basic_color, recording, visibility)
  88         , sync_mark(0)
  89         , zero_line(0)
  90         , fade_in_shape(0)
  91         , fade_out_shape(0)
  92         , fade_in_handle(0)
  93         , fade_out_handle(0)
  94         , gain_line(0)
  95         , _amplitude_above_axis(1.0)
  96         , _flags(0)
  97         , fade_color(0)
  98 {
  99 }
 100
 101
 102 AudioRegionView::AudioRegionView (const AudioRegionView& other)
 103         : sigc::trackable(other)
 104         , RegionView (other)
 105         , zero_line(0)
 106         , fade_in_shape(0)
 107         , fade_out_shape(0)
 108         , fade_in_handle(0)
 109         , fade_out_handle(0)
 110         , gain_line(0)
 111         , _amplitude_above_axis(1.0)
 112         , _flags(0)
 113         , fade_color(0)
 114
 115 {
 116         Gdk::Color c;
 117         int r,g,b,a;
 118
 119         UINT_TO_RGBA (other.fill_color, &r, &g, &b, &a);
 120         c.set_rgb_p (r/255.0, g/255.0, b/255.0);
 121
 122         init (c, false);
 123 }
 124
 125 AudioRegionView::AudioRegionView (const AudioRegionView& other, boost::shared_ptr<AudioRegion> other_region)
 126         : RegionView (other, boost::shared_ptr<Region> (other_region))
 127         , zero_line(0)
 128         , fade_in_shape(0)
 129         , fade_out_shape(0)
 130         , fade_in_handle(0)
 131         , fade_out_handle(0)
 132         , gain_line(0)
 133         , _amplitude_above_axis(1.0)
 134         , _flags(0)
 135         , fade_color(0)
 136
 137 {
 138         Gdk::Color c;
 139         int r,g,b,a;
 140
 141         UINT_TO_RGBA (other.fill_color, &r, &g, &b, &a);
 142         c.set_rgb_p (r/255.0, g/255.0, b/255.0);
 143
 144         init (c, true);
 145 }
 146
 147 void
 148 AudioRegionView::init (Gdk::Color const & basic_color, bool wfd)
 149 {
 150         // FIXME: Some redundancy here with RegionView::init.  Need to figure out
 151         // where order is important and where it isn't...
 152
 153         RegionView::init (basic_color, wfd);
 154
 155         XMLNode *node;
 156
 157         _amplitude_above_axis = 1.0;
 158         zero_line             = 0;
 159         _flags                = 0;
 160
 161         if ((node = _region->extra_xml ("GUI")) != 0) {
 162                 set_flags (node);
 163         } else {
 164                 _flags = WaveformVisible;
 165                 store_flags ();
 166         }
 167
 168         if (trackview.editor().new_regionviews_display_gain()) {
 169                 _flags |= EnvelopeVisible;
 170         }
 171
 172         compute_colors (basic_color);
 173
 174         create_waves ();
 175
 176         fade_in_shape = new ArdourCanvas::Polygon (*group);
 177         fade_in_shape->property_fill_color_rgba() = fade_color;
 178         fade_in_shape->set_data ("regionview", this);
 179
 180         fade_out_shape = new ArdourCanvas::Polygon (*group);
 181         fade_out_shape->property_fill_color_rgba() = fade_color;
 182         fade_out_shape->set_data ("regionview", this);
 183
 184         {
 185                 uint32_t r,g,b,a;
 186                 UINT_TO_RGBA(fill_color,&r,&g,&b,&a);
 187
 188                 fade_in_handle = new ArdourCanvas::SimpleRect (*group);
 189                 fade_in_handle->property_fill_color_rgba() = RGBA_TO_UINT(r,g,b,0);
 190                 fade_in_handle->property_outline_pixels() = 0;
 191
 192                 fade_in_handle->set_data ("regionview", this);
 193
 194                 fade_out_handle = new ArdourCanvas::SimpleRect (*group);
 195                 fade_out_handle->property_fill_color_rgba() = RGBA_TO_UINT(r,g,b,0);
 196                 fade_out_handle->property_outline_pixels() = 0;
 197
 198                 fade_out_handle->set_data ("regionview", this);
 199         }
 200
 201         setup_fade_handle_positions ();
 202
 203         if (!trackview.session()->config.get_show_region_fades()) {
 204                 set_fade_visibility (false);
 205         }
 206
 207         const string line_name = _region->name() + ":gain";
 208
 209         if (!Profile->get_sae()) {
 210                 gain_line = new AudioRegionGainLine (line_name, *this, *group, audio_region()->envelope());
 211         }
 212
 213         if (!(_flags & EnvelopeVisible)) {
 214                 gain_line->hide ();
 215         } else {
 216                 gain_line->show ();
 217         }
 218
 219         gain_line->reset ();
 220
 221         set_height (trackview.current_height());
 222
 223         region_muted ();
 224         region_sync_changed ();
 225
 226         region_resized (ARDOUR::bounds_change);
 227         set_waveview_data_src();
 228         region_locked ();
 229         envelope_active_changed ();
 230         fade_in_active_changed ();
 231         fade_out_active_changed ();
 232
 233         reset_width_dependent_items (_pixel_width);
 234
 235         fade_in_shape->signal_event().connect (sigc::bind (sigc::mem_fun (PublicEditor::instance(), &PublicEditor::canvas_fade_in_event), fade_in_shape, this));
 236         fade_in_handle->signal_event().connect (sigc::bind (sigc::mem_fun (PublicEditor::instance(), &PublicEditor::canvas_fade_in_handle_event), fade_in_handle, this));
 237         fade_out_shape->signal_event().connect (sigc::bind (sigc::mem_fun (PublicEditor::instance(), &PublicEditor::canvas_fade_out_event), fade_out_shape, this));
 238         fade_out_handle->signal_event().connect (sigc::bind (sigc::mem_fun (PublicEditor::instance(), &PublicEditor::canvas_fade_out_handle_event), fade_out_handle, this));
 239
 240         set_colors ();
 241
 242         /* XXX sync mark drag? */
 243 }
 244
 245 AudioRegionView::~AudioRegionView ()
 246 {
 247         in_destructor = true;
 248
 249         RegionViewGoingAway (this); /* EMIT_SIGNAL */
 250
 251         for (vector<GnomeCanvasWaveViewCache *>::iterator cache = wave_caches.begin(); cache != wave_caches.end() ; ++cache) {
 252                 gnome_canvas_waveview_cache_destroy (*cache);
 253         }
 254
 255         /* all waveviews etc will be destroyed when the group is destroyed */
 256
 257         delete gain_line;
 258 }
 259
 260 boost::shared_ptr<ARDOUR::AudioRegion>
 261 AudioRegionView::audio_region() const
 262 {
 263         // "Guaranteed" to succeed...
 264         return boost::dynamic_pointer_cast<AudioRegion>(_region);
 265 }
 266
 267 void
 268 AudioRegionView::region_changed (const PropertyChange& what_changed)
 269 {
 270         ENSURE_GUI_THREAD (*this, &AudioRegionView::region_changed, what_changed);
 271         // cerr << "AudioRegionView::region_changed() called" << endl;
 272
 273         RegionView::region_changed (what_changed);
 274
 275         if (what_changed.contains (ARDOUR::Properties::scale_amplitude)) {
 276                 region_scale_amplitude_changed ();
 277         }
 278         if (what_changed.contains (ARDOUR::Properties::fade_in)) {
 279                 fade_in_changed ();
 280         }
 281         if (what_changed.contains (ARDOUR::Properties::fade_out)) {
 282                 fade_out_changed ();
 283         }
 284         if (what_changed.contains (ARDOUR::Properties::fade_in_active)) {
 285                 fade_in_active_changed ();
 286         }
 287         if (what_changed.contains (ARDOUR::Properties::fade_out_active)) {
 288                 fade_out_active_changed ();
 289         }
 290         if (what_changed.contains (ARDOUR::Properties::envelope_active)) {
 291                 envelope_active_changed ();
 292         }
 293 }
 294
 295 void
 296 AudioRegionView::fade_in_changed ()
 297 {
 298         reset_fade_in_shape ();
 299 }
 300
 301 void
 302 AudioRegionView::fade_out_changed ()
 303 {
 304         reset_fade_out_shape ();
 305 }
 306 void
 307 AudioRegionView::fade_in_active_changed ()
 308 {
 309         uint32_t r,g,b,a;
 310         uint32_t col;
 311         UINT_TO_RGBA(fade_color,&r,&g,&b,&a);
 312
 313         if (audio_region()->fade_in_active()) {
 314                 col = RGBA_TO_UINT(r,g,b,120);
 315                 fade_in_shape->property_fill_color_rgba() = col;
 316                 fade_in_shape->property_width_pixels() = 0;
 317                 fade_in_shape->property_outline_color_rgba() = RGBA_TO_UINT(r,g,b,0);
 318         } else {
 319                 col = RGBA_TO_UINT(r,g,b,0);
 320                 fade_in_shape->property_fill_color_rgba() = col;
 321                 fade_in_shape->property_width_pixels() = 1;
 322                 fade_in_shape->property_outline_color_rgba() = RGBA_TO_UINT(r,g,b,255);
 323         }
 324 }
 325
 326 void
 327 AudioRegionView::fade_out_active_changed ()
 328 {
 329         uint32_t r,g,b,a;
 330         uint32_t col;
 331         UINT_TO_RGBA(fade_color,&r,&g,&b,&a);
 332
 333         if (audio_region()->fade_out_active()) {
 334                 col = RGBA_TO_UINT(r,g,b,120);
 335                 fade_out_shape->property_fill_color_rgba() = col;
 336                 fade_out_shape->property_width_pixels() = 0;
 337                 fade_out_shape->property_outline_color_rgba() = RGBA_TO_UINT(r,g,b,0);
 338         } else {
 339                 col = RGBA_TO_UINT(r,g,b,0);
 340                 fade_out_shape->property_fill_color_rgba() = col;
 341                 fade_out_shape->property_width_pixels() = 1;
 342                 fade_out_shape->property_outline_color_rgba() = RGBA_TO_UINT(r,g,b,255);
 343         }
 344 }
 345
 346
 347 void
 348 AudioRegionView::region_scale_amplitude_changed ()
 349 {
 350         ENSURE_GUI_THREAD (*this, &AudioRegionView::region_scale_amplitude_changed)
 351
 352         for (uint32_t n = 0; n < waves.size(); ++n) {
 353                 // force a reload of the cache
 354                 waves[n]->property_data_src() = _region.get();
 355         }
 356 }
 357
 358 void
 359 AudioRegionView::region_renamed ()
 360 {
 361         Glib::ustring str = RegionView::make_name ();
 362
 363         if (audio_region()->speed_mismatch (trackview.session()->frame_rate())) {
 364                 str = string ("*") + str;
 365         }
 366
 367         if (_region->muted()) {
 368                 str = string ("!") + str;
 369         }
 370
 371         set_item_name (str, this);
 372         set_name_text (str);
 373 }
 374
 375 void
 376 AudioRegionView::region_resized (const PropertyChange& what_changed)
 377 {
 378         AudioGhostRegion* agr;
 379
 380         RegionView::region_resized(what_changed);
 381         PropertyChange interesting_stuff;
 382
 383         interesting_stuff.add (ARDOUR::Properties::start);
 384         interesting_stuff.add (ARDOUR::Properties::length);
 385
 386         if (what_changed.contains (interesting_stuff)) {
 387
 388                 for (uint32_t n = 0; n < waves.size(); ++n) {
 389                         waves[n]->property_region_start() = _region->start();
 390                 }
 391
 392                 for (vector<GhostRegion*>::iterator i = ghosts.begin(); i != ghosts.end(); ++i) {
 393                         if((agr = dynamic_cast<AudioGhostRegion*>(*i)) != 0) {
 394
 395                                 for (vector<WaveView*>::iterator w = agr->waves.begin(); w != agr->waves.end(); ++w) {
 396                                         (*w)->property_region_start() = _region->start();
 397                                 }
 398                         }
 399                 }
 400         }
 401 }
 402
 403 void
 404 AudioRegionView::reset_width_dependent_items (double pixel_width)
 405 {
 406         RegionView::reset_width_dependent_items(pixel_width);
 407         assert(_pixel_width == pixel_width);
 408
 409         if (zero_line) {
 410                 zero_line->property_x2() = pixel_width - 1.0;
 411         }
 412
 413         if (fade_in_handle) {
 414                 if (pixel_width <= 6.0) {
 415                         fade_in_handle->hide();
 416                         fade_out_handle->hide();
 417                 } else {
 418                         if (_height < 5.0) {
 419                                 fade_in_handle->hide();
 420                                 fade_out_handle->hide();
 421                         } else {
 422                                 if (trackview.session()->config.get_show_region_fades()) {
 423                                         fade_in_handle->show();
 424                                         fade_out_handle->show();
 425                                 }
 426                         }
 427                 }
 428         }
 429
 430         reset_fade_shapes ();
 431 }
 432
 433 void
 434 AudioRegionView::region_muted ()
 435 {
 436         RegionView::region_muted();
 437
 438         for (uint32_t n=0; n < waves.size(); ++n) {
 439                 if (_region->muted()) {
 440                         waves[n]->property_wave_color() = UINT_RGBA_CHANGE_A(ARDOUR_UI::config()->canvasvar_WaveForm.get(), MUTED_ALPHA);
 441                 } else {
 442                         waves[n]->property_wave_color() = ARDOUR_UI::config()->canvasvar_WaveForm.get();
 443                 }
 444         }
 445 }
 446
 447 void
 448 AudioRegionView::setup_fade_handle_positions()
 449 {
 450         /* position of fade handle offset from the top of the region view */
 451         double const handle_pos = 2;
 452         /* height of fade handles */
 453         double const handle_height = 5;
 454
 455         if (fade_in_handle) {
 456                 fade_in_handle->property_y1() = handle_pos;
 457                 fade_in_handle->property_y2() = handle_pos + handle_height;
 458         }
 459
 460         if (fade_out_handle) {
 461                 fade_out_handle->property_y1() = handle_pos;
 462                 fade_out_handle->property_y2() = handle_pos + handle_height;
 463         }
 464 }
 465
 466 void
 467 AudioRegionView::set_height (gdouble height)
 468 {
 469         RegionView::set_height (height);
 470
 471         uint32_t wcnt = waves.size();
 472
 473         // FIXME: ick
 474         height -= 2;
 475
 476         _height = height;
 477
 478         for (uint32_t n=0; n < wcnt; ++n) {
 479                 gdouble ht;
 480
 481                 if ((height) < NAME_HIGHLIGHT_THRESH) {
 482                         ht = ((height-2*wcnt) / (double) wcnt);
 483                 } else {
 484                         ht = (((height-2*wcnt) - NAME_HIGHLIGHT_SIZE) / (double) wcnt);
 485                 }
 486
 487                 gdouble yoff = n * (ht+1);
 488
 489                 waves[n]->property_height() = ht;
 490                 waves[n]->property_y() = yoff + 2;
 491         }
 492
 493         if (gain_line) {
 494                 if ((height/wcnt) < NAME_HIGHLIGHT_THRESH) {
 495                         gain_line->hide ();
 496                 } else {
 497                         if (_flags & EnvelopeVisible) {
 498                                 gain_line->show ();
 499                         }
 500                 }
 501                 gain_line->set_height ((uint32_t) rint (height - NAME_HIGHLIGHT_SIZE - 2));
 502         }
 503
 504         manage_zero_line ();
 505         reset_fade_shapes ();
 506
 507         if (name_pixbuf) {
 508                 name_pixbuf->raise_to_top();
 509         }
 510
 511 }
 512
 513 void
 514 AudioRegionView::manage_zero_line ()
 515 {
 516         if (!zero_line) {
 517                 return;
 518         }
 519
 520         if (_height >= 100) {
 521                 double const wave_midpoint = (_height - NAME_HIGHLIGHT_SIZE) / 2.0;
 522                 zero_line->property_y1() = wave_midpoint;
 523                 zero_line->property_y2() = wave_midpoint;
 524                 zero_line->show();
 525         } else {
 526                 zero_line->hide();
 527         }
 528 }
 529
 530 void
 531 AudioRegionView::reset_fade_shapes ()
 532 {
 533         reset_fade_in_shape ();
 534         reset_fade_out_shape ();
 535 }
 536
 537 void
 538 AudioRegionView::reset_fade_in_shape ()
 539 {
 540         reset_fade_in_shape_width ((nframes_t) audio_region()->fade_in()->back()->when);
 541 }
 542
 543 void
 544 AudioRegionView::reset_fade_in_shape_width (nframes_t width)
 545 {
 546         if (fade_in_handle == 0) {
 547                 return;
 548         }
 549
 550         /* smallest size for a fade is 64 frames */
 551
 552         width = std::max ((nframes_t) 64, width);
 553
 554         Points* points;
 555         double pwidth = width / samples_per_unit;
 556         uint32_t npoints = std::min (gdk_screen_width(), (int) pwidth);
 557         double h;
 558
 559         if (_height < 5) {
 560                 fade_in_shape->hide();
 561                 fade_in_handle->hide();
 562                 return;
 563         }
 564
 565         double handle_center;
 566         handle_center = pwidth;
 567
 568         if (handle_center > 7.0) {
 569                 handle_center -= 3.0;
 570         } else {
 571                 handle_center = 3.0;
 572         }
 573
 574         fade_in_handle->property_x1() =  handle_center - 3.0;
 575         fade_in_handle->property_x2() =  handle_center + 3.0;
 576
 577         if (pwidth < 5) {
 578                 fade_in_shape->hide();
 579                 return;
 580         }
 581
 582         if (trackview.session()->config.get_show_region_fades()) {
 583                 fade_in_shape->show();
 584         }
 585
 586         float curve[npoints];
 587         audio_region()->fade_in()->curve().get_vector (0, audio_region()->fade_in()->back()->when, curve, npoints);
 588
 589         points = get_canvas_points ("fade in shape", npoints+3);
 590
 591         if (_height >= NAME_HIGHLIGHT_THRESH) {
 592                 h = _height - NAME_HIGHLIGHT_SIZE;
 593         } else {
 594                 h = _height;
 595         }
 596
 597         /* points *MUST* be in anti-clockwise order */
 598
 599         uint32_t pi, pc;
 600         double xdelta = pwidth/npoints;
 601
 602         for (pi = 0, pc = 0; pc < npoints; ++pc) {
 603                 (*points)[pi].set_x(1 + (pc * xdelta));
 604                 (*points)[pi++].set_y(2 + (h - (curve[pc] * h)));
 605         }
 606
 607         /* fold back */
 608
 609         (*points)[pi].set_x(pwidth);
 610         (*points)[pi++].set_y(2);
 611
 612         (*points)[pi].set_x(1);
 613         (*points)[pi++].set_y(2);
 614
 615         /* connect the dots ... */
 616
 617         (*points)[pi] = (*points)[0];
 618
 619         fade_in_shape->property_points() = *points;
 620         delete points;
 621
 622         /* ensure trim handle stays on top */
 623         frame_handle_start->raise_to_top();
 624 }
 625
 626 void
 627 AudioRegionView::reset_fade_out_shape ()
 628 {
 629         reset_fade_out_shape_width ((nframes_t) audio_region()->fade_out()->back()->when);
 630 }
 631
 632 void
 633 AudioRegionView::reset_fade_out_shape_width (nframes_t width)
 634 {
 635         if (fade_out_handle == 0) {
 636                 return;
 637         }
 638
 639         /* smallest size for a fade is 64 frames */
 640
 641         width = std::max ((nframes_t) 64, width);
 642
 643         Points* points;
 644         double pwidth = width / samples_per_unit;
 645         uint32_t npoints = std::min (gdk_screen_width(), (int) pwidth);
 646         double h;
 647
 648         if (_height < 5) {
 649                 fade_out_shape->hide();
 650                 fade_out_handle->hide();
 651                 return;
 652         }
 653
 654         double handle_center;
 655         handle_center = (_region->length() - width) / samples_per_unit;
 656
 657         if (handle_center > 7.0) {
 658                 handle_center -= 3.0;
 659         } else {
 660                 handle_center = 3.0;
 661         }
 662
 663         fade_out_handle->property_x1() =  handle_center - 3.0;
 664         fade_out_handle->property_x2() =  handle_center + 3.0;
 665
 666         /* don't show shape if its too small */
 667
 668         if (pwidth < 5) {
 669                 fade_out_shape->hide();
 670                 return;
 671         }
 672
 673         if (trackview.session()->config.get_show_region_fades()) {
 674                 fade_out_shape->show();
 675         }
 676
 677         float curve[npoints];
 678         audio_region()->fade_out()->curve().get_vector (0, audio_region()->fade_out()->back()->when, curve, npoints);
 679
 680         if (_height >= NAME_HIGHLIGHT_THRESH) {
 681                 h = _height - NAME_HIGHLIGHT_SIZE;
 682         } else {
 683                 h = _height;
 684         }
 685
 686         /* points *MUST* be in anti-clockwise order */
 687
 688         points = get_canvas_points ("fade out shape", npoints+3);
 689
 690         uint32_t pi, pc;
 691         double xdelta = pwidth/npoints;
 692
 693         for (pi = 0, pc = 0; pc < npoints; ++pc) {
 694                 (*points)[pi].set_x(_pixel_width - 1 - pwidth + (pc*xdelta));
 695                 (*points)[pi++].set_y(2 + (h - (curve[pc] * h)));
 696         }
 697
 698         /* fold back */
 699
 700         (*points)[pi].set_x(_pixel_width);
 701         (*points)[pi++].set_y(h);
 702
 703         (*points)[pi].set_x(_pixel_width);
 704         (*points)[pi++].set_y(2);
 705
 706         /* connect the dots ... */
 707
 708         (*points)[pi] = (*points)[0];
 709
 710         fade_out_shape->property_points() = *points;
 711         delete points;
 712
 713         /* ensure trim handle stays on top */
 714         frame_handle_end->raise_to_top();
 715 }
 716
 717 void
 718 AudioRegionView::set_samples_per_unit (gdouble spu)
 719 {
 720         RegionView::set_samples_per_unit (spu);
 721
 722         if (_flags & WaveformVisible) {
 723                 for (uint32_t n=0; n < waves.size(); ++n) {
 724                         waves[n]->property_samples_per_unit() = spu;
 725                 }
 726         }
 727
 728         if (gain_line) {
 729                 gain_line->reset ();
 730         }
 731
 732         reset_fade_shapes ();
 733 }
 734
 735 void
 736 AudioRegionView::set_amplitude_above_axis (gdouble spp)
 737 {
 738         for (uint32_t n=0; n < waves.size(); ++n) {
 739                 waves[n]->property_amplitude_above_axis() = spp;
 740         }
 741 }
 742
 743 void
 744 AudioRegionView::compute_colors (Gdk::Color const & basic_color)
 745 {
 746         RegionView::compute_colors (basic_color);
 747
 748         uint32_t r, g, b, a;
 749
 750         /* gain color computed in envelope_active_changed() */
 751
 752         UINT_TO_RGBA (fill_color, &r, &g, &b, &a);
 753         fade_color = RGBA_TO_UINT(r,g,b,120);
 754 }
 755
 756 void
 757 AudioRegionView::set_colors ()
 758 {
 759         RegionView::set_colors();
 760
 761         if (gain_line) {
 762                 gain_line->set_line_color (audio_region()->envelope_active() ? ARDOUR_UI::config()->canvasvar_GainLine.get() : ARDOUR_UI::config()->canvasvar_GainLineInactive.get());
 763         }
 764
 765         for (uint32_t n=0; n < waves.size(); ++n) {
 766                 if (_region->muted()) {
 767                         waves[n]->property_wave_color() = UINT_RGBA_CHANGE_A(ARDOUR_UI::config()->canvasvar_WaveForm.get(), MUTED_ALPHA);
 768                 } else {
 769                         waves[n]->property_wave_color() = ARDOUR_UI::config()->canvasvar_WaveForm.get();
 770                 }
 771
 772                 waves[n]->property_clip_color() = ARDOUR_UI::config()->canvasvar_WaveFormClip.get();
 773                 waves[n]->property_zero_color() = ARDOUR_UI::config()->canvasvar_ZeroLine.get();
 774         }
 775 }
 776
 777 void
 778 AudioRegionView::show_region_editor ()
 779 {
 780         if (editor == 0) {
 781                 editor = new AudioRegionEditor (trackview.session(), audio_region(), *this);
 782                 // GTK2FIX : how to ensure float without realizing
 783                 // editor->realize ();
 784                 // trackview.editor.ensure_float (*editor);
 785         }
 786
 787         editor->present ();
 788         editor->show_all();
 789 }
 790
 791 void
 792 AudioRegionView::set_waveform_visible (bool yn)
 793 {
 794         if (((_flags & WaveformVisible) != yn)) {
 795                 if (yn) {
 796                         for (uint32_t n=0; n < waves.size(); ++n) {
 797                                 /* make sure the zoom level is correct, since we don't update
 798                                    this when waveforms are hidden.
 799                                 */
 800                                 waves[n]->property_samples_per_unit() = samples_per_unit;
 801                                 waves[n]->show();
 802                         }
 803                         _flags |= WaveformVisible;
 804                 } else {
 805                         for (uint32_t n=0; n < waves.size(); ++n) {
 806                                 waves[n]->hide();
 807                         }
 808                         _flags &= ~WaveformVisible;
 809                 }
 810                 store_flags ();
 811         }
 812 }
 813
 814 void
 815 AudioRegionView::temporarily_hide_envelope ()
 816 {
 817         if (gain_line) {
 818                 gain_line->hide ();
 819         }
 820 }
 821
 822 void
 823 AudioRegionView::unhide_envelope ()
 824 {
 825         if (gain_line && (_flags & EnvelopeVisible)) {
 826                 gain_line->show ();
 827         }
 828 }
 829
 830 void
 831 AudioRegionView::set_envelope_visible (bool yn)
 832 {
 833         if (gain_line && ((_flags & EnvelopeVisible) != yn)) {
 834                 if (yn) {
 835                         gain_line->show ();
 836                         _flags |= EnvelopeVisible;
 837                 } else {
 838                         gain_line->hide ();
 839                         _flags &= ~EnvelopeVisible;
 840                 }
 841                 store_flags ();
 842         }
 843 }
 844
 845 void
 846 AudioRegionView::create_waves ()
 847 {
 848         // cerr << "AudioRegionView::create_waves() called on " << this << endl;//DEBUG
 849         RouteTimeAxisView& atv (*(dynamic_cast<RouteTimeAxisView*>(&trackview))); // ick
 850
 851         if (!atv.get_diskstream()) {
 852                 return;
 853         }
 854
 855         ChanCount nchans = atv.get_diskstream()->n_channels();
 856
 857         // cerr << "creating waves for " << _region->name() << " with wfd = " << wait_for_data
 858         //              << " and channels = " << nchans.n_audio() << endl;
 859
 860         /* in tmp_waves, set up null pointers for each channel so the vector is allocated */
 861         for (uint32_t n = 0; n < nchans.n_audio(); ++n) {
 862                 tmp_waves.push_back (0);
 863         }
 864
 865         for (uint32_t n = 0; n < nchans.n_audio(); ++n) {
 866
 867                 if (n >= audio_region()->n_channels()) {
 868                         break;
 869                 }
 870
 871                 wave_caches.push_back (WaveView::create_cache ());
 872
 873                 // cerr << "\tchannel " << n << endl;
 874
 875                 if (wait_for_data) {
 876                         if (audio_region()->audio_source(n)->peaks_ready (boost::bind (&AudioRegionView::peaks_ready_handler, this, n), data_ready_connection, gui_context())) {
 877                                 // cerr << "\tData is ready\n";
 878                                 create_one_wave (n, true);
 879                         } else {
 880                                 // cerr << "\tdata is not ready\n";
 881                                 // we'll get a PeaksReady signal from the source in the future
 882                                 // and will call create_one_wave(n) then.
 883                         }
 884
 885                 } else {
 886                         // cerr << "\tdon't delay, display today!\n";
 887                         create_one_wave (n, true);
 888                 }
 889
 890         }
 891 }
 892
 893 void
 894 AudioRegionView::create_one_wave (uint32_t which, bool /*direct*/)
 895 {
 896         //cerr << "AudioRegionView::create_one_wave() called which: " << which << " this: " << this << endl;//DEBUG
 897         RouteTimeAxisView& atv (*(dynamic_cast<RouteTimeAxisView*>(&trackview))); // ick
 898         uint32_t nchans = atv.get_diskstream()->n_channels().n_audio();
 899         uint32_t n;
 900         uint32_t nwaves = std::min (nchans, audio_region()->n_channels());
 901         gdouble ht;
 902
 903         if (trackview.current_height() < NAME_HIGHLIGHT_THRESH) {
 904                 ht = ((trackview.current_height()) / (double) nchans);
 905         } else {
 906                 ht = ((trackview.current_height() - NAME_HIGHLIGHT_SIZE) / (double) nchans);
 907         }
 908
 909         gdouble yoff = which * ht;
 910
 911         WaveView *wave = new WaveView(*group);
 912
 913         wave->property_data_src() = (gpointer) _region.get();
 914         wave->property_cache() =  wave_caches[which];
 915         wave->property_cache_updater() = true;
 916         wave->property_channel() =  which;
 917         wave->property_length_function() = (gpointer) region_length_from_c;
 918         wave->property_sourcefile_length_function() = (gpointer) sourcefile_length_from_c;
 919         wave->property_peak_function() =  (gpointer) region_read_peaks_from_c;
 920         wave->property_x() =  0.0;
 921         wave->property_y() =  yoff;
 922         wave->property_height() =  (double) ht;
 923         wave->property_samples_per_unit() =  samples_per_unit;
 924         wave->property_amplitude_above_axis() =  _amplitude_above_axis;
 925
 926         if (_recregion) {
 927                 wave->property_wave_color() = _region->muted() ? UINT_RGBA_CHANGE_A(ARDOUR_UI::config()->canvasvar_RecWaveForm.get(), MUTED_ALPHA) : ARDOUR_UI::config()->canvasvar_RecWaveForm.get();
 928                 wave->property_fill_color() = ARDOUR_UI::config()->canvasvar_RecWaveFormFill.get();
 929         } else {
 930                 wave->property_wave_color() = _region->muted() ? UINT_RGBA_CHANGE_A(ARDOUR_UI::config()->canvasvar_WaveForm.get(), MUTED_ALPHA) : ARDOUR_UI::config()->canvasvar_WaveForm.get();
 931                 wave->property_fill_color() = ARDOUR_UI::config()->canvasvar_WaveFormFill.get();
 932         }
 933
 934         wave->property_clip_color() = ARDOUR_UI::config()->canvasvar_WaveFormClip.get();
 935         wave->property_zero_color() = ARDOUR_UI::config()->canvasvar_ZeroLine.get();
 936         wave->property_region_start() = _region->start();
 937         wave->property_rectified() = (bool) (_flags & WaveformRectified);
 938         wave->property_logscaled() = (bool) (_flags & WaveformLogScaled);
 939
 940         if (!(_flags & WaveformVisible)) {
 941                 wave->hide();
 942         }
 943
 944         /* note: calling this function is serialized by the lock
 945            held in the peak building thread that signals that
 946            peaks are ready for use *or* by the fact that it is
 947            called one by one from the GUI thread.
 948         */
 949
 950         if (which < nchans) {
 951                 tmp_waves[which] = wave;
 952         } else {
 953                 /* n-channel track, >n-channel source */
 954         }
 955
 956         /* see if we're all ready */
 957
 958         for (n = 0; n < nchans; ++n) {
 959                 if (tmp_waves[n] == 0) {
 960                         break;
 961                 }
 962         }
 963
 964         if (n == nwaves && waves.empty()) {
 965                 /* all waves are ready */
 966                 tmp_waves.resize(nwaves);
 967
 968                 waves = tmp_waves;
 969                 tmp_waves.clear ();
 970
 971                 /* all waves created, don't hook into peaks ready anymore */
 972                 data_ready_connection.disconnect ();
 973
 974 #if 0
 975                 if (!zero_line) {
 976                         zero_line = new ArdourCanvas::SimpleLine (*group);
 977                         zero_line->property_x1() = (gdouble) 1.0;
 978                         zero_line->property_x2() = (gdouble) (_region->length() / samples_per_unit) - 1.0;
 979                         zero_line->property_color_rgba() = (guint) ARDOUR_UI::config()->canvasvar_ZeroLine.get();
 980                         manage_zero_line ();
 981                 }
 982 #endif
 983         }
 984 }
 985
 986 void
 987 AudioRegionView::peaks_ready_handler (uint32_t which)
 988 {
 989         Gtkmm2ext::UI::instance()->call_slot (boost::bind (&AudioRegionView::create_one_wave, this, which, false));
 990         // cerr << "AudioRegionView::peaks_ready_handler() called on " << which << " this: " << this << endl;
 991 }
 992
 993 void
 994 AudioRegionView::add_gain_point_event (ArdourCanvas::Item *item, GdkEvent *ev)
 995 {
 996         if (gain_line == 0) {
 997                 return;
 998         }
 999
1000         double x, y;
1001
1002         /* don't create points that can't be seen */
1003
1004         set_envelope_visible (true);
1005
1006         x = ev->button.x;
1007         y = ev->button.y;
1008
1009         item->w2i (x, y);
1010
1011         nframes_t fx = trackview.editor().pixel_to_frame (x);
1012
1013         if (fx > _region->length()) {
1014                 return;
1015         }
1016
1017         /* compute vertical fractional position */
1018
1019         y = 1.0 - (y / (_height - NAME_HIGHLIGHT_SIZE));
1020
1021         /* map using gain line */
1022
1023         gain_line->view_to_model_coord (x, y);
1024
1025         /* XXX STATEFUL: can't convert to stateful diff until we
1026            can represent automation data with it.
1027         */
1028
1029         trackview.session()->begin_reversible_command (_("add gain control point"));
1030         XMLNode &before = audio_region()->envelope()->get_state();
1031
1032         if (!audio_region()->envelope_active()) {
1033                 XMLNode &region_before = audio_region()->get_state();
1034                 audio_region()->set_envelope_active(true);
1035                 XMLNode &region_after = audio_region()->get_state();
1036                 trackview.session()->add_command (new MementoCommand<AudioRegion>(*(audio_region().get()), &region_before, &region_after));
1037         }
1038
1039         audio_region()->envelope()->add (fx, y);
1040
1041         XMLNode &after = audio_region()->envelope()->get_state();
1042         trackview.session()->add_command (new MementoCommand<AutomationList>(*audio_region()->envelope().get(), &before, &after));
1043         trackview.session()->commit_reversible_command ();
1044 }
1045
1046 void
1047 AudioRegionView::remove_gain_point_event (ArdourCanvas::Item *item, GdkEvent */*ev*/)
1048 {
1049         ControlPoint *cp = reinterpret_cast<ControlPoint *> (item->get_data ("control_point"));
1050         audio_region()->envelope()->erase (cp->model());
1051 }
1052
1053 void
1054 AudioRegionView::store_flags()
1055 {
1056         XMLNode *node = new XMLNode ("GUI");
1057
1058         node->add_property ("waveform-visible", (_flags & WaveformVisible) ? "yes" : "no");
1059         node->add_property ("envelope-visible", (_flags & EnvelopeVisible) ? "yes" : "no");
1060         node->add_property ("waveform-rectified", (_flags & WaveformRectified) ? "yes" : "no");
1061         node->add_property ("waveform-logscaled", (_flags & WaveformLogScaled) ? "yes" : "no");
1062
1063         _region->add_extra_xml (*node);
1064 }
1065
1066 void
1067 AudioRegionView::set_flags (XMLNode* node)
1068 {
1069         XMLProperty *prop;
1070
1071         if ((prop = node->property ("waveform-visible")) != 0) {
1072                 if (string_is_affirmative (prop->value())) {
1073                         _flags |= WaveformVisible;
1074                 }
1075         }
1076
1077         if ((prop = node->property ("envelope-visible")) != 0) {
1078                 if (string_is_affirmative (prop->value())) {
1079                         _flags |= EnvelopeVisible;
1080                 }
1081         }
1082
1083         if ((prop = node->property ("waveform-rectified")) != 0) {
1084                 if (string_is_affirmative (prop->value())) {
1085                         _flags |= WaveformRectified;
1086                 }
1087         }
1088
1089         if ((prop = node->property ("waveform-logscaled")) != 0) {
1090                 if (string_is_affirmative (prop->value())) {
1091                         _flags |= WaveformLogScaled;
1092                 }
1093         }
1094 }
1095
1096 void
1097 AudioRegionView::set_waveform_shape (WaveformShape shape)
1098 {
1099         bool yn;
1100
1101         /* this slightly odd approach is to leave the door open to
1102            other "shapes" such as spectral displays, etc.
1103         */
1104
1105         switch (shape) {
1106         case Rectified:
1107                 yn = true;
1108                 break;
1109
1110         default:
1111                 yn = false;
1112                 break;
1113         }
1114
1115         if (yn != (bool) (_flags & WaveformRectified)) {
1116                 for (vector<WaveView *>::iterator wave = waves.begin(); wave != waves.end() ; ++wave) {
1117                         (*wave)->property_rectified() = yn;
1118                 }
1119
1120                 if (zero_line) {
1121                         if (yn) {
1122                                 zero_line->hide();
1123                         } else {
1124                                 zero_line->show();
1125                         }
1126                 }
1127
1128                 if (yn) {
1129                         _flags |= WaveformRectified;
1130                 } else {
1131                         _flags &= ~WaveformRectified;
1132                 }
1133                 store_flags ();
1134         }
1135 }
1136
1137 void
1138 AudioRegionView::set_waveform_scale (WaveformScale scale)
1139 {
1140         bool yn = (scale == Logarithmic);
1141
1142         if (yn != (bool) (_flags & WaveformLogScaled)) {
1143                 for (vector<WaveView *>::iterator wave = waves.begin(); wave != waves.end() ; ++wave) {
1144                         (*wave)->property_logscaled() = yn;
1145                 }
1146
1147                 if (yn) {
1148                         _flags |= WaveformLogScaled;
1149                 } else {
1150                         _flags &= ~WaveformLogScaled;
1151                 }
1152                 store_flags ();
1153         }
1154 }
1155
1156
1157 GhostRegion*
1158 AudioRegionView::add_ghost (TimeAxisView& tv)
1159 {
1160         RouteTimeAxisView* rtv = dynamic_cast<RouteTimeAxisView*>(&trackview);
1161         assert(rtv);
1162
1163         double unit_position = _region->position () / samples_per_unit;
1164         AudioGhostRegion* ghost = new AudioGhostRegion (tv, trackview, unit_position);
1165         uint32_t nchans;
1166
1167         nchans = rtv->get_diskstream()->n_channels().n_audio();
1168
1169         for (uint32_t n = 0; n < nchans; ++n) {
1170
1171                 if (n >= audio_region()->n_channels()) {
1172                         break;
1173                 }
1174
1175                 WaveView *wave = new WaveView(*ghost->group);
1176
1177                 wave->property_data_src() = _region.get();
1178                 wave->property_cache() =  wave_caches[n];
1179                 wave->property_cache_updater() = false;
1180                 wave->property_channel() = n;
1181                 wave->property_length_function() = (gpointer)region_length_from_c;
1182                 wave->property_sourcefile_length_function() = (gpointer) sourcefile_length_from_c;
1183                 wave->property_peak_function() =  (gpointer) region_read_peaks_from_c;
1184                 wave->property_x() =  0.0;
1185                 wave->property_samples_per_unit() =  samples_per_unit;
1186                 wave->property_amplitude_above_axis() =  _amplitude_above_axis;
1187
1188                 wave->property_region_start() = _region->start();
1189
1190                 ghost->waves.push_back(wave);
1191         }
1192
1193         ghost->set_height ();
1194         ghost->set_duration (_region->length() / samples_per_unit);
1195         ghost->set_colors();
1196         ghosts.push_back (ghost);
1197
1198         return ghost;
1199 }
1200
1201 void
1202 AudioRegionView::entered ()
1203 {
1204         if (gain_line && _flags & EnvelopeVisible) {
1205                 gain_line->show_all_control_points ();
1206         }
1207
1208         uint32_t r,g,b,a;
1209         UINT_TO_RGBA(fade_color,&r,&g,&b,&a);
1210         a=255;
1211
1212         if (fade_in_handle) {
1213                 fade_in_handle->property_fill_color_rgba() = RGBA_TO_UINT(r,g,b,a);
1214                 fade_out_handle->property_fill_color_rgba() = RGBA_TO_UINT(r,g,b,a);
1215         }
1216 }
1217
1218 void
1219 AudioRegionView::exited ()
1220 {
1221         if (gain_line) {
1222                 gain_line->hide_all_but_selected_control_points ();
1223         }
1224
1225         uint32_t r,g,b,a;
1226         UINT_TO_RGBA(fade_color,&r,&g,&b,&a);
1227         a=0;
1228
1229         if (fade_in_handle) {
1230                 fade_in_handle->property_fill_color_rgba() = RGBA_TO_UINT(r,g,b,a);
1231                 fade_out_handle->property_fill_color_rgba() = RGBA_TO_UINT(r,g,b,a);
1232         }
1233 }
1234
1235 void
1236 AudioRegionView::envelope_active_changed ()
1237 {
1238         if (gain_line) {
1239                 gain_line->set_line_color (audio_region()->envelope_active() ? ARDOUR_UI::config()->canvasvar_GainLine.get() : ARDOUR_UI::config()->canvasvar_GainLineInactive.get());
1240         }
1241 }
1242
1243 void
1244 AudioRegionView::set_waveview_data_src()
1245 {
1246         AudioGhostRegion* agr;
1247         double unit_length= _region->length() / samples_per_unit;
1248
1249         for (uint32_t n = 0; n < waves.size(); ++n) {
1250                 // TODO: something else to let it know the channel
1251                 waves[n]->property_data_src() = _region.get();
1252         }
1253
1254         for (vector<GhostRegion*>::iterator i = ghosts.begin(); i != ghosts.end(); ++i) {
1255
1256                 (*i)->set_duration (unit_length);
1257
1258                 if((agr = dynamic_cast<AudioGhostRegion*>(*i)) != 0) {
1259                         for (vector<WaveView*>::iterator w = agr->waves.begin(); w != agr->waves.end(); ++w) {
1260                                 (*w)->property_data_src() = _region.get();
1261                         }
1262                 }
1263         }
1264
1265 }
1266
1267 void
1268 AudioRegionView::color_handler ()
1269 {
1270         //case cMutedWaveForm:
1271         //case cWaveForm:
1272         //case cWaveFormClip:
1273         //case cZeroLine:
1274         set_colors ();
1275
1276         //case cGainLineInactive:
1277         //case cGainLine:
1278         envelope_active_changed();
1279
1280 }
1281
1282 void
1283 AudioRegionView::set_frame_color ()
1284 {
1285         if (!frame) {
1286                 return;
1287         }
1288
1289         if (_region->opaque()) {
1290                 fill_opacity = 130;
1291         } else {
1292                 fill_opacity = 0;
1293         }
1294
1295         uint32_t r,g,b,a;
1296
1297         if (_selected && should_show_selection) {
1298                 UINT_TO_RGBA(ARDOUR_UI::config()->canvasvar_SelectedFrameBase.get(), &r, &g, &b, &a);
1299                 frame->property_fill_color_rgba() = RGBA_TO_UINT(r, g, b, fill_opacity ? fill_opacity : a);
1300
1301                 for (vector<ArdourCanvas::WaveView*>::iterator w = waves.begin(); w != waves.end(); ++w) {
1302                         if (_region->muted()) {
1303                                 (*w)->property_wave_color() = UINT_RGBA_CHANGE_A(ARDOUR_UI::config()->canvasvar_SelectedWaveForm.get(), MUTED_ALPHA);
1304                         } else {
1305                                 (*w)->property_wave_color() = ARDOUR_UI::config()->canvasvar_SelectedWaveForm.get();
1306                                 (*w)->property_fill_color() = ARDOUR_UI::config()->canvasvar_SelectedWaveFormFill.get();
1307                         }
1308                 }
1309         } else {
1310                 if (_recregion) {
1311                         UINT_TO_RGBA(ARDOUR_UI::config()->canvasvar_RecordingRect.get(), &r, &g, &b, &a);
1312                         frame->property_fill_color_rgba() = RGBA_TO_UINT(r, g, b, a);
1313
1314                         for (vector<ArdourCanvas::WaveView*>::iterator w = waves.begin(); w != waves.end(); ++w) {
1315                                 if (_region->muted()) {
1316                                         (*w)->property_wave_color() = UINT_RGBA_CHANGE_A(ARDOUR_UI::config()->canvasvar_RecWaveForm.get(), MUTED_ALPHA);
1317                                 } else {
1318                                         (*w)->property_wave_color() = ARDOUR_UI::config()->canvasvar_RecWaveForm.get();
1319                                         (*w)->property_fill_color() = ARDOUR_UI::config()->canvasvar_RecWaveFormFill.get();
1320                                 }
1321                         }
1322                 } else {
1323                         UINT_TO_RGBA(ARDOUR_UI::config()->canvasvar_FrameBase.get(), &r, &g, &b, &a);
1324                         frame->property_fill_color_rgba() = RGBA_TO_UINT(r, g, b, fill_opacity ? fill_opacity : a);
1325
1326                         for (vector<ArdourCanvas::WaveView*>::iterator w = waves.begin(); w != waves.end(); ++w) {
1327                                 if (_region->muted()) {
1328                                         (*w)->property_wave_color() = UINT_RGBA_CHANGE_A(ARDOUR_UI::config()->canvasvar_WaveForm.get(), MUTED_ALPHA);
1329                                 } else {
1330                                         (*w)->property_wave_color() = ARDOUR_UI::config()->canvasvar_WaveForm.get();
1331                                         (*w)->property_fill_color() = ARDOUR_UI::config()->canvasvar_WaveFormFill.get();
1332                                 }
1333                         }
1334                 }
1335         }
1336 }
1337
1338 void
1339 AudioRegionView::set_fade_visibility (bool yn)
1340 {
1341         if (yn) {
1342                 if (fade_in_shape) {
1343                         fade_in_shape->show();
1344                 }
1345                 if (fade_out_shape) {
1346                         fade_out_shape->show ();
1347                 }
1348                 if (fade_in_handle) {
1349                         fade_in_handle->show ();
1350                 }
1351                 if (fade_out_handle) {
1352                         fade_out_handle->show ();
1353                 }
1354         } else {
1355                 if (fade_in_shape) {
1356                         fade_in_shape->hide();
1357                 }
1358                 if (fade_out_shape) {
1359                         fade_out_shape->hide ();
1360                 }
1361                 if (fade_in_handle) {
1362                         fade_in_handle->hide ();
1363                 }
1364                 if (fade_out_handle) {
1365                         fade_out_handle->hide ();
1366                 }
1367         }
1368 }
1369
1370 void
1371 AudioRegionView::update_coverage_frames (LayerDisplay d)
1372 {
1373         RegionView::update_coverage_frames (d);
1374
1375         fade_in_handle->raise_to_top ();
1376         fade_out_handle->raise_to_top ();
1377 }