gtk2_ardour/crossfade_edit.cc

   1 /*
   2     Copyright (C) 2004 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     $Id$
  19 */
  20
  21 #include <cmath>
  22
  23 #include <sigc++/bind.h>
  24
  25 #include <gtkmm/frame.h>
  26 #include <gtkmm/image.h>
  27 #include <gtkmm/scrolledwindow.h>
  28
  29 #include <libgnomecanvasmm/line.h>
  30
  31 #include <ardour/automation_event.h>
  32 #include <ardour/curve.h>
  33 #include <ardour/crossfade.h>
  34 #include <ardour/session.h>
  35 #include <ardour/auditioner.h>
  36 #include <ardour/audioplaylist.h>
  37 #include <ardour/playlist_templates.h>
  38
  39 #include <gtkmm2ext/gtk_ui.h>
  40
  41 #include "ardour_ui.h"
  42 #include "crossfade_edit.h"
  43 #include "rgb_macros.h"
  44 #include "keyboard.h"
  45 #include "utils.h"
  46 #include "gui_thread.h"
  47 #include "canvas_impl.h"
  48 #include "simplerect.h"
  49 #include "waveview.h"
  50
  51 using namespace std;
  52 using namespace ARDOUR;
  53 using namespace Gtk;
  54 using namespace sigc;
  55 using namespace Editing;
  56
  57 #include "i18n.h"
  58
  59 const int32_t CrossfadeEditor::Point::size = 7;
  60 const double CrossfadeEditor::canvas_border = 10;
  61 CrossfadeEditor::Presets* CrossfadeEditor::fade_in_presets = 0;
  62 CrossfadeEditor::Presets* CrossfadeEditor::fade_out_presets = 0;
  63
  64 #include "crossfade_xpms.h"
  65
  66 CrossfadeEditor::Half::Half ()
  67         : line (0),
  68           normative_curve (0.0, 1.0, 1.0, true),
  69           gain_curve (0.0, 2.0, 1.0, true)
  70 {
  71 }
  72
  73 CrossfadeEditor::CrossfadeEditor (Session& s, Crossfade& xf, double my, double mxy)
  74         : ArdourDialog (_("ardour: x-fade edit")),
  75           xfade (xf),
  76           session (s),
  77           clear_button (_("Clear")),
  78           revert_button (_("Reset")),
  79           audition_both_button (_("Fade")),
  80           audition_left_dry_button (_("Out (dry)")),
  81           audition_left_button (_("Out")),
  82           audition_right_dry_button (_("In (dry)")),
  83           audition_right_button (_("In")),
  84
  85           preroll_button (_("With Pre-roll")),
  86           postroll_button (_("With Post-roll")),
  87
  88           miny (my),
  89           maxy (mxy),
  90
  91           fade_in_table (3, 3),
  92           fade_out_table (3, 3),
  93
  94           select_in_button (_("Fade In")),
  95           select_out_button (_("Fade Out"))
  96 {
  97         set_wmclass ("ardour_automationedit", "Ardour");
  98         set_name ("CrossfadeEditWindow");
  99         set_position (Gtk::WIN_POS_MOUSE);
 100
 101         add_events (Gdk::KEY_PRESS_MASK|Gdk::KEY_RELEASE_MASK|Gdk::POINTER_MOTION_MASK);
 102
 103         RadioButtonGroup sel_but_group = select_in_button.get_group();
 104         select_out_button.set_group (sel_but_group);
 105         select_out_button.set_mode (false);
 106         select_in_button.set_mode (false);
 107
 108         get_action_area()->set_layout(BUTTONBOX_SPREAD);
 109         get_action_area()->pack_start(clear_button);
 110         get_action_area()->pack_start(revert_button);
 111         cancel_button = add_button ("Cancel", RESPONSE_CANCEL);
 112         ok_button = add_button ("OK", RESPONSE_ACCEPT);
 113
 114         if (fade_in_presets == 0) {
 115                 build_presets ();
 116         }
 117
 118         point_grabbed = false;
 119         toplevel = 0;
 120
 121         canvas = new ArdourCanvas::CanvasAA ();
 122         canvas->signal_size_allocate().connect (mem_fun(*this, &CrossfadeEditor::canvas_allocation));
 123         canvas->set_size_request (425, 200);
 124
 125         toplevel = new ArdourCanvas::SimpleRect (*(canvas->root()));
 126         toplevel->property_x1() =  0.0;
 127         toplevel->property_y1() =  0.0;
 128         toplevel->property_x2() =  10.0;
 129         toplevel->property_y2() =  10.0;
 130         toplevel->property_fill() =  true;
 131         toplevel->property_fill_color_rgba() =  (guint32) color_map[cCrossfadeEditorBase];
 132         toplevel->property_outline_pixels() =  0;
 133         toplevel->signal_event().connect (mem_fun (*this, &CrossfadeEditor::canvas_event));
 134
 135         fade[Out].line = new ArdourCanvas::Line (*(canvas->root()));
 136         fade[Out].line->property_width_pixels() = 1;
 137         fade[Out].line->property_fill_color_rgba() = color_map[cCrossfadeEditorLine];
 138
 139         fade[Out].shading = new ArdourCanvas::Polygon (*(canvas->root()));
 140         fade[Out].shading->property_fill_color_rgba() = color_map[cCrossfadeEditorLineShading];
 141
 142         fade[In].line = new ArdourCanvas::Line (*(canvas->root()));
 143         fade[In].line->property_width_pixels() = 1;
 144         fade[In].line->property_fill_color_rgba() = color_map[cCrossfadeEditorLine];
 145
 146         fade[In].shading = new ArdourCanvas::Polygon (*(canvas->root()));
 147         fade[In].shading->property_fill_color_rgba() = color_map[cCrossfadeEditorLineShading];
 148
 149         fade[In].shading->signal_event().connect (mem_fun (*this, &CrossfadeEditor::canvas_event));
 150         fade[In].line->signal_event().connect (mem_fun (*this, &CrossfadeEditor::curve_event));
 151         fade[Out].shading->signal_event().connect (mem_fun (*this, &CrossfadeEditor::canvas_event));
 152         fade[Out].line->signal_event().connect (mem_fun (*this, &CrossfadeEditor::curve_event));
 153
 154         select_in_button.set_name (X_("CrossfadeEditCurveButton"));
 155         select_out_button.set_name (X_("CrossfadeEditCurveButton"));
 156
 157         select_in_button.signal_clicked().connect (bind (mem_fun (*this, &CrossfadeEditor::curve_select_clicked), In));
 158         select_out_button.signal_clicked().connect (bind (mem_fun (*this, &CrossfadeEditor::curve_select_clicked), Out));
 159
 160         HBox* acbox = manage (new HBox);
 161
 162         audition_box.set_border_width (7);
 163         audition_box.set_spacing (5);
 164         audition_box.set_homogeneous (false);
 165         audition_box.pack_start (audition_left_dry_button, false, false);
 166         audition_box.pack_start (audition_left_button, false, false);
 167         audition_box.pack_start (audition_both_button, false, false);
 168         audition_box.pack_start (audition_right_button, false, false);
 169         audition_box.pack_start (audition_right_dry_button, false, false);
 170
 171         Frame* audition_frame = manage (new Frame (_("Audition")));
 172
 173         audition_frame->set_name (X_("CrossfadeEditFrame"));
 174         audition_frame->add (audition_box);
 175
 176         acbox->pack_start (*audition_frame, true, false);
 177
 178         Frame* canvas_frame = manage (new Frame);
 179         canvas_frame->add (*canvas);
 180         canvas_frame->set_shadow_type (Gtk::SHADOW_IN);
 181
 182         fade_in_table.attach (select_in_button, 0, 2, 0, 1, Gtk::FILL|Gtk::EXPAND);
 183         fade_out_table.attach (select_out_button, 0, 2, 0, 1, Gtk::FILL|Gtk::EXPAND);
 184
 185         Image *pxmap;
 186         Button* pbutton;
 187         int row;
 188         int col;
 189
 190         row = 1;
 191         col = 0;
 192
 193         for (list<Preset*>::iterator i = fade_in_presets->begin(); i != fade_in_presets->end(); ++i) {
 194
 195                 pxmap = manage (new Image (Gdk::Pixbuf::create_from_xpm_data((*i)->xpm)));
 196                 pbutton = manage (new Button);
 197                 pbutton->add (*pxmap);
 198                 pbutton->set_name ("CrossfadeEditButton");
 199                 pbutton->signal_clicked().connect (bind (mem_fun(*this, &CrossfadeEditor::apply_preset), *i));
 200                 fade_in_table.attach (*pbutton, col, col+1, row, row+1);
 201                 fade_in_buttons.push_back (pbutton);
 202
 203                 col++;
 204
 205                 if (col == 2) {
 206                         col = 0;
 207                         row++;
 208                 }
 209         }
 210
 211         row = 1;
 212         col = 0;
 213
 214         for (list<Preset*>::iterator i = fade_out_presets->begin(); i != fade_out_presets->end(); ++i) {
 215
 216                 pxmap = manage (new Image (Gdk::Pixbuf::create_from_xpm_data((*i)->xpm)));
 217                 pbutton = manage (new Button);
 218                 pbutton->add (*pxmap);
 219                 pbutton->set_name ("CrossfadeEditButton");
 220                 pbutton->signal_clicked().connect (bind (mem_fun(*this, &CrossfadeEditor::apply_preset), *i));
 221                 fade_out_table.attach (*pbutton, col, col+1, row, row+1);
 222                 fade_out_buttons.push_back (pbutton);
 223
 224                 col++;
 225
 226                 if (col == 2) {
 227                         col = 0;
 228                         row++;
 229                 }
 230         }
 231
 232         clear_button.set_name ("CrossfadeEditButton");
 233         revert_button.set_name ("CrossfadeEditButton");
 234         ok_button->set_name ("CrossfadeEditButton");
 235         cancel_button->set_name ("CrossfadeEditButton");
 236         preroll_button.set_name ("CrossfadeEditButton");
 237         postroll_button.set_name ("CrossfadeEditButton");
 238         audition_both_button.set_name ("CrossfadeEditAuditionButton");
 239         audition_left_dry_button.set_name ("CrossfadeEditAuditionButton");
 240         audition_left_button.set_name ("CrossfadeEditAuditionButton");
 241         audition_right_dry_button.set_name ("CrossfadeEditAuditionButton");
 242         audition_right_button.set_name ("CrossfadeEditAuditionButton");
 243
 244         clear_button.signal_clicked().connect (mem_fun(*this, &CrossfadeEditor::clear));
 245         revert_button.signal_clicked().connect (mem_fun(*this, &CrossfadeEditor::reset));
 246         audition_both_button.signal_toggled().connect (mem_fun(*this, &CrossfadeEditor::audition_toggled));
 247         audition_right_button.signal_toggled().connect (mem_fun(*this, &CrossfadeEditor::audition_right_toggled));
 248         audition_right_dry_button.signal_toggled().connect (mem_fun(*this, &CrossfadeEditor::audition_right_dry_toggled));
 249         audition_left_button.signal_toggled().connect (mem_fun(*this, &CrossfadeEditor::audition_left_toggled));
 250         audition_left_dry_button.signal_toggled().connect (mem_fun(*this, &CrossfadeEditor::audition_left_dry_toggled));
 251
 252         roll_box.pack_start (preroll_button, false, false);
 253         roll_box.pack_start (postroll_button, false, false);
 254
 255         Gtk::HBox* rcenter_box = manage (new HBox);
 256         rcenter_box->pack_start (roll_box, true, false);
 257
 258         VBox* vpacker2 = manage (new (VBox));
 259
 260         vpacker2->set_border_width (12);
 261         vpacker2->set_spacing (7);
 262         vpacker2->pack_start (*acbox, false, false);
 263         vpacker2->pack_start (*rcenter_box, false, false);
 264
 265         curve_button_box.set_spacing (7);
 266         curve_button_box.pack_start (fade_out_table, false, false, 12);
 267         curve_button_box.pack_start (*vpacker2, false, false, 12);
 268         curve_button_box.pack_start (fade_in_table, false, false, 12);
 269
 270         get_vbox()->pack_start (*canvas_frame, true, true);
 271         get_vbox()->pack_start (curve_button_box, false, false);
 272
 273         /* button to allow hackers to check the actual curve values */
 274
 275 //      Button* foobut = manage (new Button ("dump"));
 276 //      foobut-.signal_clicked().connect (mem_fun(*this, &CrossfadeEditor::dump));
 277 //      vpacker.pack_start (*foobut, false, false);
 278
 279         current = In;
 280         set (xfade.fade_in(), In);
 281
 282         current = Out;
 283         set (xfade.fade_out(), Out);
 284
 285         curve_select_clicked (In);
 286
 287         xfade.StateChanged.connect (mem_fun(*this, &CrossfadeEditor::xfade_changed));
 288
 289         session.AuditionActive.connect (mem_fun(*this, &CrossfadeEditor::audition_state_changed));
 290         show_all_children();
 291 }
 292
 293 CrossfadeEditor::~CrossfadeEditor()
 294 {
 295         /* most objects will be destroyed when the toplevel window is. */
 296
 297         for (list<Point*>::iterator i = fade[In].points.begin(); i != fade[In].points.end(); ++i) {
 298                 delete *i;
 299         }
 300
 301         for (list<Point*>::iterator i = fade[Out].points.begin(); i != fade[Out].points.end(); ++i) {
 302                 delete *i;
 303         }
 304 }
 305
 306 void
 307 CrossfadeEditor::dump ()
 308 {
 309         for (AutomationList::iterator i = fade[Out].normative_curve.begin(); i != fade[Out].normative_curve.end(); ++i) {
 310                 cerr << (*i)->when << ' ' << (*i)->value << endl;
 311         }
 312 }
 313
 314 void
 315 CrossfadeEditor::audition_state_changed (bool yn)
 316 {
 317         ENSURE_GUI_THREAD (bind (mem_fun(*this, &CrossfadeEditor::audition_state_changed), yn));
 318
 319         if (!yn) {
 320                 audition_both_button.set_active (false);
 321                 audition_left_button.set_active (false);
 322                 audition_right_button.set_active (false);
 323                 audition_left_dry_button.set_active (false);
 324                 audition_right_dry_button.set_active (false);
 325         }
 326 }
 327
 328 void
 329 CrossfadeEditor::set (const ARDOUR::Curve& curve, WhichFade which)
 330 {
 331         double firstx, endx;
 332         ARDOUR::Curve::const_iterator the_end;
 333
 334         for (list<Point*>::iterator i = fade[which].points.begin(); i != fade[which].points.end(); ++i) {
 335                         delete *i;
 336         }
 337
 338         fade[which].points.clear ();
 339         fade[which].gain_curve.clear ();
 340         fade[which].normative_curve.clear ();
 341
 342         if (curve.empty()) {
 343                 goto out;
 344         }
 345
 346         the_end = curve.const_end();
 347         --the_end;
 348
 349         firstx = (*curve.const_begin())->when;
 350         endx = (*the_end)->when;
 351
 352         for (ARDOUR::Curve::const_iterator i = curve.const_begin(); i != curve.const_end(); ++i) {
 353
 354                 double xfract = ((*i)->when - firstx) / (endx - firstx);
 355                 double yfract = ((*i)->value - miny) / (maxy - miny);
 356
 357                 Point* p = make_point ();
 358
 359                 p->move_to (x_coordinate (xfract), y_coordinate (yfract),
 360                             xfract, yfract);
 361
 362                 fade[which].points.push_back (p);
 363         }
 364
 365         /* no need to sort because curve is already time-ordered */
 366
 367   out:
 368
 369         swap (which, current);
 370         redraw ();
 371         swap (which, current);
 372 }
 373
 374 bool
 375 CrossfadeEditor::curve_event (GdkEvent* event)
 376 {
 377         /* treat it like a toplevel event */
 378
 379         return canvas_event (event);
 380 }
 381
 382 bool
 383 CrossfadeEditor::point_event (GdkEvent* event, Point* point)
 384 {
 385
 386         if (point->curve != fade[current].line) {
 387                 return FALSE;
 388         }
 389
 390         switch (event->type) {
 391         case GDK_BUTTON_PRESS:
 392                 point_grabbed = true;
 393                 break;
 394         case GDK_BUTTON_RELEASE:
 395                 point_grabbed = false;
 396
 397                 if (Keyboard::is_delete_event (&event->button)) {
 398                         fade[current].points.remove (point);
 399                         delete point;
 400                 }
 401
 402                 redraw ();
 403                 break;
 404
 405         case GDK_MOTION_NOTIFY:
 406                 if (point_grabbed) {
 407                         double new_x, new_y;
 408
 409                         /* can't drag first or last points horizontally */
 410
 411                         if (point == fade[current].points.front() || point == fade[current].points.back()) {
 412                                 new_x = point->x;
 413                         } else {
 414                                 new_x = (event->motion.x - canvas_border)/effective_width();
 415                         }
 416
 417                         new_y = 1.0 - ((event->motion.y - canvas_border)/effective_height());
 418                         point->move_to (x_coordinate (new_x), y_coordinate (new_y),
 419                                         new_x, new_y);
 420                         redraw ();
 421                 }
 422                 break;
 423         default:
 424                 break;
 425         }
 426         return TRUE;
 427 }
 428
 429 bool
 430 CrossfadeEditor::canvas_event (GdkEvent* event)
 431 {
 432         switch (event->type) {
 433         case GDK_BUTTON_PRESS:
 434                 add_control_point ((event->button.x - canvas_border)/effective_width(),
 435                                    1.0 - ((event->button.y - canvas_border)/effective_height()));
 436                 return TRUE;
 437                 break;
 438         default:
 439                 break;
 440         }
 441         return FALSE;
 442 }
 443
 444 CrossfadeEditor::Point::~Point()
 445 {
 446         delete box;
 447 }
 448
 449 CrossfadeEditor::Point*
 450 CrossfadeEditor::make_point ()
 451 {
 452         Point* p = new Point;
 453
 454         p->box = new ArdourCanvas::SimpleRect (*(canvas->root()));
 455         p->box->property_fill() = true;
 456         p->box->property_fill_color_rgba() = color_map[cCrossfadeEditorPointFill];
 457         p->box->property_outline_color_rgba() = color_map[cCrossfadeEditorPointOutline];
 458         p->box->property_outline_pixels() = 1;
 459
 460         p->curve = fade[current].line;
 461
 462         p->box->signal_event().connect (bind (mem_fun (*this, &CrossfadeEditor::point_event), p));
 463
 464         return p;
 465 }
 466
 467 void
 468 CrossfadeEditor::add_control_point (double x, double y)
 469 {
 470         PointSorter cmp;
 471
 472         /* enforce end point x location */
 473
 474         if (fade[current].points.empty()) {
 475                 x = 0.0;
 476         } else if (fade[current].points.size() == 1) {
 477                 x = 1.0;
 478         }
 479
 480         Point* p = make_point ();
 481
 482         p->move_to (x_coordinate (x), y_coordinate (y), x, y);
 483
 484         fade[current].points.push_back (p);
 485         fade[current].points.sort (cmp);
 486
 487         redraw ();
 488 }
 489
 490 void
 491 CrossfadeEditor::Point::move_to (double nx, double ny, double xfract, double yfract)
 492 {
 493         const double half_size = rint(size/2.0);
 494         double x1 = nx - half_size;
 495         double x2 = nx + half_size;
 496
 497         box->property_x1() = x1;
 498         box->property_x2() = x2;
 499
 500         box->property_y1() = ny - half_size;
 501         box->property_y2() = ny + half_size;
 502
 503         x = xfract;
 504         y = yfract;
 505 }
 506
 507 void
 508 CrossfadeEditor::canvas_allocation (Gtk::Allocation& alloc)
 509 {
 510         if (toplevel) {
 511                 toplevel->property_x1() = 0.0;
 512                 toplevel->property_y1() = 0.0;
 513                 toplevel->property_x2() = (double) canvas->get_allocation().get_width() + canvas_border;
 514                 toplevel->property_y2() = (double) canvas->get_allocation().get_height() + canvas_border;
 515         }
 516
 517         canvas->set_scroll_region (0.0, 0.0,
 518                                    canvas->get_allocation().get_width(),
 519                                    canvas->get_allocation().get_height());
 520
 521         Point* end = make_point ();
 522         PointSorter cmp;
 523
 524         if (fade[In].points.size() > 1) {
 525                 Point* old_end = fade[In].points.back();
 526                 fade[In].points.pop_back ();
 527                 end->move_to (x_coordinate (old_end->x),
 528                               y_coordinate (old_end->y),
 529                               old_end->x, old_end->y);
 530                 delete old_end;
 531         } else {
 532                 double x = 1.0;
 533                 double y = 0.5;
 534                 end->move_to (x_coordinate (x), y_coordinate (y), x, y);
 535
 536         }
 537
 538         fade[In].points.push_back (end);
 539         fade[In].points.sort (cmp);
 540
 541         for (list<Point*>::iterator i = fade[In].points.begin(); i != fade[In].points.end(); ++i) {
 542                 (*i)->move_to (x_coordinate((*i)->x), y_coordinate((*i)->y),
 543                                (*i)->x, (*i)->y);
 544         }
 545
 546         end = make_point ();
 547
 548         if (fade[Out].points.size() > 1) {
 549                 Point* old_end = fade[Out].points.back();
 550                 fade[Out].points.pop_back ();
 551                 end->move_to (x_coordinate (old_end->x),
 552                               y_coordinate (old_end->y),
 553                               old_end->x, old_end->y);
 554                 delete old_end;
 555         } else {
 556                 double x = 1.0;
 557                 double y = 0.5;
 558                 end->move_to (x_coordinate (x), y_coordinate (y), x, y);
 559
 560         }
 561
 562         fade[Out].points.push_back (end);
 563         fade[Out].points.sort (cmp);
 564
 565         for (list<Point*>::iterator i = fade[Out].points.begin(); i != fade[Out].points.end(); ++i) {
 566                 (*i)->move_to (x_coordinate ((*i)->x),
 567                                y_coordinate ((*i)->y),
 568                                (*i)->x, (*i)->y);
 569         }
 570
 571         WhichFade old_current = current;
 572         current = In;
 573         redraw ();
 574         current = Out;
 575         redraw ();
 576         current = old_current;
 577
 578         double spu = xfade.length() / (double) effective_width();
 579
 580         if (fade[In].waves.empty()) {
 581                 make_waves (xfade.in(), In);
 582         }
 583
 584         if (fade[Out].waves.empty()) {
 585                 make_waves (xfade.out(), Out);
 586         }
 587
 588         double ht;
 589         vector<ArdourCanvas::WaveView*>::iterator i;
 590         uint32_t n;
 591
 592         ht = canvas->get_allocation().get_height() / xfade.in().n_channels();
 593
 594         for (n = 0, i = fade[In].waves.begin(); i != fade[In].waves.end(); ++i, ++n) {
 595                 double yoff;
 596
 597                 yoff = n * ht;
 598
 599                 (*i)->property_y() = yoff;
 600                 (*i)->property_height() = ht;
 601                 (*i)->property_samples_per_unit() = spu;
 602         }
 603
 604         ht = canvas->get_allocation().get_height() / xfade.out().n_channels();
 605
 606         for (n = 0, i = fade[Out].waves.begin(); i != fade[Out].waves.end(); ++i, ++n) {
 607                 double yoff;
 608
 609                 yoff = n * ht;
 610
 611                 (*i)->property_y() = yoff;
 612                 (*i)->property_height() = ht;
 613                 (*i)->property_samples_per_unit() = spu;
 614         }
 615
 616 }
 617
 618
 619 void
 620 CrossfadeEditor::xfade_changed (Change ignored)
 621 {
 622         set (xfade.fade_in(), In);
 623         set (xfade.fade_out(), Out);
 624 }
 625
 626 void
 627 CrossfadeEditor::redraw ()
 628 {
 629         if (canvas->get_allocation().get_width() < 2) {
 630                 return;
 631         }
 632
 633         jack_nframes_t len = xfade.length ();
 634
 635         fade[current].normative_curve.clear ();
 636         fade[current].gain_curve.clear ();
 637
 638         for (list<Point*>::iterator i = fade[current].points.begin(); i != fade[current].points.end(); ++i) {
 639                 fade[current].normative_curve.add ((*i)->x, (*i)->y);
 640                 fade[current].gain_curve.add (((*i)->x * len), (*i)->y);
 641         }
 642
 643         size_t npoints = (size_t) effective_width();
 644         float vec[npoints];
 645
 646         fade[current].normative_curve.get_vector (0, 1.0, vec, npoints);
 647
 648         ArdourCanvas::Points pts;
 649         ArdourCanvas::Points spts;
 650
 651         while (pts.size() < npoints) {
 652                 pts.push_back (Gnome::Art::Point (0,0));
 653         }
 654
 655         while (spts.size() < npoints + 3) {
 656                 spts.push_back (Gnome::Art::Point (0,0));
 657         }
 658
 659         /* the shade coordinates *MUST* be in anti-clockwise order.
 660          */
 661
 662         if (current == In) {
 663
 664                 /* lower left */
 665
 666                 spts[0].set_x (canvas_border);
 667                 spts[0].set_y (effective_height() + canvas_border);
 668
 669                 /* lower right */
 670
 671                 spts[1].set_x (effective_width() + canvas_border);
 672                 spts[1].set_y (effective_height() + canvas_border);
 673
 674                 /* upper right */
 675
 676                 spts[2].set_x (effective_width() + canvas_border);
 677                 spts[2].set_y (canvas_border);
 678
 679
 680         } else {
 681
 682                 /*  upper left */
 683
 684                 spts[0].set_x (canvas_border);
 685                 spts[0].set_y (canvas_border);
 686
 687                 /* lower left */
 688
 689                 spts[1].set_x (canvas_border);
 690                 spts[1].set_y (effective_height() + canvas_border);
 691
 692                 /* lower right */
 693
 694                 spts[2].set_x (effective_width() + canvas_border);
 695                 spts[2].set_y (effective_height() + canvas_border);
 696
 697         }
 698
 699         // GTK2FIX some odd math to fix up here
 700
 701         size_t last_spt = (npoints + 3) - 1;
 702
 703         for (size_t i = 0; i < npoints; ++i) {
 704
 705                 double y = vec[i];
 706
 707                 pts[i].set_x (canvas_border + i);
 708                 pts[i].set_y  (y_coordinate (y));
 709
 710                 spts[last_spt - i].set_x (canvas_border + i);
 711                 spts[last_spt - i].set_y (pts[i].get_y());
 712         }
 713
 714         fade[current].line->property_points() = pts;
 715         fade[current].shading->property_points() = spts;
 716
 717         for (vector<ArdourCanvas::WaveView*>::iterator i = fade[current].waves.begin(); i != fade[current].waves.end(); ++i) {
 718                 (*i)->property_gain_src() = &fade[current].gain_curve;
 719         }
 720 }
 721
 722 void
 723 CrossfadeEditor::apply_preset (Preset *preset)
 724 {
 725         for (list<Point*>::iterator i = fade[current].points.begin(); i != fade[current].points.end(); ++i) {
 726                 delete *i;
 727         }
 728
 729         fade[current].points.clear ();
 730
 731         for (Preset::iterator i = preset->begin(); i != preset->end(); ++i) {
 732                 Point* p = make_point ();
 733                 p->move_to (x_coordinate ((*i).x), y_coordinate ((*i).y),
 734                             (*i).x, (*i).y);
 735                 fade[current].points.push_back (p);
 736         }
 737
 738         redraw ();
 739 }
 740
 741 void
 742 CrossfadeEditor::apply ()
 743 {
 744         _apply_to (&xfade);
 745 }
 746
 747 void
 748 CrossfadeEditor::_apply_to (Crossfade* xf)
 749 {
 750         ARDOUR::Curve& in (xf->fade_in());
 751         ARDOUR::Curve& out (xf->fade_out());
 752
 753         /* IN */
 754
 755
 756         ARDOUR::Curve::const_iterator the_end = in.const_end();
 757         --the_end;
 758
 759         double firstx = (*in.begin())->when;
 760         double endx = (*the_end)->when;
 761         double miny = in.get_min_y ();
 762         double maxy = in.get_max_y ();
 763
 764         in.freeze ();
 765         in.clear ();
 766
 767         for (list<Point*>::iterator i = fade[In].points.begin(); i != fade[In].points.end(); ++i) {
 768
 769                 double when = firstx + ((*i)->x * (endx - firstx));
 770                 double value = (*i)->y; // miny + ((*i)->y * (maxy - miny));
 771                 in.add (when, value);
 772         }
 773
 774         /* OUT */
 775
 776         the_end = out.const_end();
 777         --the_end;
 778
 779         firstx = (*out.begin())->when;
 780         endx = (*the_end)->when;
 781         miny = out.get_min_y ();
 782         maxy = out.get_max_y ();
 783
 784         out.freeze ();
 785         out.clear ();
 786
 787         for (list<Point*>::iterator i = fade[Out].points.begin(); i != fade[Out].points.end(); ++i) {
 788
 789                 double when = firstx + ((*i)->x * (endx - firstx));
 790                 double value = (*i)->y; // miny + ((*i)->y * (maxy - miny));
 791                 out.add (when, value);
 792         }
 793
 794         in.thaw ();
 795         out.thaw ();
 796 }
 797
 798 void
 799 CrossfadeEditor::setup (Crossfade* xfade)
 800 {
 801         _apply_to (xfade);
 802         xfade->set_active (true);
 803         xfade->fade_in().solve ();
 804         xfade->fade_out().solve ();
 805 }
 806
 807 void
 808 CrossfadeEditor::clear ()
 809 {
 810         for (list<Point*>::iterator i = fade[current].points.begin(); i != fade[current].points.end(); ++i) {
 811                 delete *i;
 812         }
 813
 814         fade[current].points.clear ();
 815
 816         redraw ();
 817 }
 818
 819 void
 820 CrossfadeEditor::reset ()
 821 {
 822         set (xfade.fade_in(),  In);
 823         set (xfade.fade_out(), Out);
 824 }
 825
 826 void
 827 CrossfadeEditor::build_presets ()
 828 {
 829         Preset* p;
 830
 831         fade_in_presets = new Presets;
 832         fade_out_presets = new Presets;
 833
 834         /* FADE OUT */
 835
 836         p = new Preset (hiin_xpm);
 837         p->push_back (PresetPoint (0, 0));
 838         p->push_back (PresetPoint (0.0207373, 0.197222));
 839         p->push_back (PresetPoint (0.0645161, 0.525));
 840         p->push_back (PresetPoint (0.152074, 0.802778));
 841         p->push_back (PresetPoint (0.276498, 0.919444));
 842         p->push_back (PresetPoint (0.481567, 0.980556));
 843         p->push_back (PresetPoint (0.767281, 1));
 844         p->push_back (PresetPoint (1, 1));
 845         fade_in_presets->push_back (p);
 846
 847         p = new Preset (loin_xpm);
 848         p->push_back (PresetPoint (0, 0));
 849         p->push_back (PresetPoint (0.389401, 0.0333333));
 850         p->push_back (PresetPoint (0.629032, 0.0861111));
 851         p->push_back (PresetPoint (0.829493, 0.233333));
 852         p->push_back (PresetPoint (0.9447, 0.483333));
 853         p->push_back (PresetPoint (0.976959, 0.697222));
 854         p->push_back (PresetPoint (1, 1));
 855         fade_in_presets->push_back (p);
 856
 857         p = new Preset (regin_xpm);
 858         p->push_back (PresetPoint (0, 0));
 859         p->push_back (PresetPoint (0.0737327, 0.308333));
 860         p->push_back (PresetPoint (0.246544, 0.658333));
 861         p->push_back (PresetPoint (0.470046, 0.886111));
 862         p->push_back (PresetPoint (0.652074, 0.972222));
 863         p->push_back (PresetPoint (0.771889, 0.988889));
 864         p->push_back (PresetPoint (1, 1));
 865         fade_in_presets->push_back (p);
 866
 867         p = new Preset (regin2_xpm);
 868         p->push_back (PresetPoint (0, 0));
 869         p->push_back (PresetPoint (0.304147, 0.0694444));
 870         p->push_back (PresetPoint (0.529954, 0.152778));
 871         p->push_back (PresetPoint (0.725806, 0.333333));
 872         p->push_back (PresetPoint (0.847926, 0.558333));
 873         p->push_back (PresetPoint (0.919355, 0.730556));
 874         p->push_back (PresetPoint (1, 1));
 875         fade_in_presets->push_back (p);
 876
 877         p = new Preset (linin_xpm);
 878         p->push_back (PresetPoint (0, 0));
 879         p->push_back (PresetPoint (1, 1));
 880         fade_in_presets->push_back (p);
 881
 882         /* FADE OUT */
 883
 884         p = new Preset (hiout_xpm);
 885         p->push_back (PresetPoint (0, 1));
 886         p->push_back (PresetPoint (0.305556, 1));
 887         p->push_back (PresetPoint (0.548611, 0.991736));
 888         p->push_back (PresetPoint (0.759259, 0.931129));
 889         p->push_back (PresetPoint (0.918981, 0.68595));
 890         p->push_back (PresetPoint (0.976852, 0.22865));
 891         p->push_back (PresetPoint (1, 0));
 892         fade_out_presets->push_back (p);
 893
 894         p = new Preset (regout_xpm);
 895         p->push_back (PresetPoint (0, 1));
 896         p->push_back (PresetPoint (0.228111, 0.988889));
 897         p->push_back (PresetPoint (0.347926, 0.972222));
 898         p->push_back (PresetPoint (0.529954, 0.886111));
 899         p->push_back (PresetPoint (0.753456, 0.658333));
 900         p->push_back (PresetPoint (0.9262673, 0.308333));
 901         p->push_back (PresetPoint (1, 0));
 902         fade_out_presets->push_back (p);
 903
 904         p = new Preset (loout_xpm);
 905         p->push_back (PresetPoint (0, 1));
 906         p->push_back (PresetPoint (0.023041, 0.697222));
 907         p->push_back (PresetPoint (0.0553,   0.483333));
 908         p->push_back (PresetPoint (0.170507, 0.233333));
 909         p->push_back (PresetPoint (0.370968, 0.0861111));
 910         p->push_back (PresetPoint (0.610599, 0.0333333));
 911         p->push_back (PresetPoint (1, 0));
 912         fade_out_presets->push_back (p);
 913
 914         p = new Preset (regout2_xpm);
 915         p->push_back (PresetPoint (0, 1));
 916         p->push_back (PresetPoint (0.080645, 0.730556));
 917         p->push_back (PresetPoint (0.277778, 0.289256));
 918         p->push_back (PresetPoint (0.470046, 0.152778));
 919         p->push_back (PresetPoint (0.695853, 0.0694444));
 920         p->push_back (PresetPoint (1, 0));
 921         fade_out_presets->push_back (p);
 922
 923         p = new Preset (linout_xpm);
 924         p->push_back (PresetPoint (0, 1));
 925         p->push_back (PresetPoint (1, 0));
 926         fade_out_presets->push_back (p);
 927 }
 928
 929 void
 930 CrossfadeEditor::curve_select_clicked (WhichFade wf)
 931 {
 932         current = wf;
 933
 934         if (wf == In) {
 935
 936                 for (vector<ArdourCanvas::WaveView*>::iterator i = fade[In].waves.begin(); i != fade[In].waves.end(); ++i) {
 937                         (*i)->property_wave_color() = color_map[cSelectedCrossfadeEditorWave];
 938                 }
 939
 940                 for (vector<ArdourCanvas::WaveView*>::iterator i = fade[Out].waves.begin(); i != fade[Out].waves.end(); ++i) {
 941                         (*i)->property_wave_color() = color_map[cCrossfadeEditorWave];
 942                 }
 943
 944                 fade[In].line->property_fill_color_rgba() = color_map[cSelectedCrossfadeEditorLine];
 945                 fade[Out].line->property_fill_color_rgba() = color_map[cCrossfadeEditorLine];
 946                 fade[Out].shading->hide();
 947                 fade[In].shading->show();
 948
 949                 for (list<Point*>::iterator i = fade[Out].points.begin(); i != fade[Out].points.end(); ++i) {
 950                         (*i)->box->hide();
 951                 }
 952
 953                 for (list<Point*>::iterator i = fade[In].points.begin(); i != fade[In].points.end(); ++i) {
 954                         (*i)->box->show ();
 955                 }
 956
 957                 for (vector<Button*>::iterator i = fade_out_buttons.begin(); i != fade_out_buttons.end(); ++i) {
 958                         (*i)->set_sensitive (false);
 959                 }
 960
 961                 for (vector<Button*>::iterator i = fade_in_buttons.begin(); i != fade_in_buttons.end(); ++i) {
 962                         (*i)->set_sensitive (true);
 963                 }
 964
 965         } else {
 966
 967                 for (vector<ArdourCanvas::WaveView*>::iterator i = fade[In].waves.begin(); i != fade[In].waves.end(); ++i) {
 968                         (*i)->property_wave_color() = color_map[cCrossfadeEditorWave];
 969                 }
 970
 971                 for (vector<ArdourCanvas::WaveView*>::iterator i = fade[Out].waves.begin(); i != fade[Out].waves.end(); ++i) {
 972                         (*i)->property_wave_color() = color_map[cSelectedCrossfadeEditorWave];
 973                 }
 974
 975                 fade[Out].line->property_fill_color_rgba() = color_map[cSelectedCrossfadeEditorLine];
 976                 fade[In].line->property_fill_color_rgba() = color_map[cCrossfadeEditorLine];
 977                 fade[In].shading->hide();
 978                 fade[Out].shading->show();
 979
 980                 for (list<Point*>::iterator i = fade[In].points.begin(); i != fade[In].points.end(); ++i) {
 981                         (*i)->box->hide();
 982                 }
 983
 984                 for (list<Point*>::iterator i = fade[Out].points.begin(); i != fade[Out].points.end(); ++i) {
 985                         (*i)->box->hide();
 986                 }
 987
 988                 for (vector<Button*>::iterator i = fade_out_buttons.begin(); i != fade_out_buttons.end(); ++i) {
 989                         (*i)->set_sensitive (true);
 990                 }
 991
 992                 for (vector<Button*>::iterator i = fade_in_buttons.begin(); i != fade_in_buttons.end(); ++i) {
 993                         (*i)->set_sensitive (false);
 994                 }
 995
 996         }
 997 }
 998
 999 double
1000 CrossfadeEditor::x_coordinate (double& xfract) const
1001 {
1002         xfract = min (1.0, xfract);
1003         xfract = max (0.0, xfract);
1004
1005         return canvas_border + (xfract * effective_width());
1006 }
1007
1008 double
1009 CrossfadeEditor::y_coordinate (double& yfract) const
1010 {
1011         yfract = min (1.0, yfract);
1012         yfract = max (0.0, yfract);
1013
1014         return (canvas->get_allocation().get_height() - (canvas_border)) - (yfract * effective_height());
1015 }
1016
1017 void
1018 CrossfadeEditor::make_waves (AudioRegion& region, WhichFade which)
1019 {
1020         gdouble ht;
1021         uint32_t nchans = region.n_channels();
1022         guint32 color;
1023         double spu;
1024
1025         if (which == In) {
1026                 color = color_map[cSelectedCrossfadeEditorWave];
1027         } else {
1028                 color = color_map[cCrossfadeEditorWave];
1029         }
1030
1031         ht = canvas->get_allocation().get_height() / (double) nchans;
1032         spu = xfade.length() / (double) effective_width();
1033
1034         for (uint32_t n = 0; n < nchans; ++n) {
1035
1036                 gdouble yoff = n * ht;
1037
1038                 if (region.source(n).peaks_ready (bind (mem_fun(*this, &CrossfadeEditor::peaks_ready), &region, which))) {
1039
1040                         WaveView* waveview = new WaveView (*(canvas->root()));
1041
1042                         waveview->property_data_src() = &region;
1043                         waveview->property_cache_updater() =  true;
1044                         waveview->property_cache() = WaveView::create_cache();
1045                         waveview->property_channel() = n;
1046                         waveview->property_length_function() = (void*) region_length_from_c;
1047                         waveview->property_sourcefile_length_function() = (void*) sourcefile_length_from_c;
1048                         waveview->property_peak_function() = (void*) region_read_peaks_from_c;
1049                         waveview->property_gain_function() = (void*) curve_get_vector_from_c;
1050                         waveview->property_gain_src() = &fade[which].gain_curve;
1051                         waveview->property_x() = canvas_border;
1052                         waveview->property_y() = yoff;
1053                         waveview->property_height() = ht;
1054                         waveview->property_samples_per_unit() = spu;
1055                         waveview->property_amplitude_above_axis() = 2.0;
1056                         waveview->property_wave_color() = color;
1057
1058                         waveview->lower_to_bottom();
1059                         fade[which].waves.push_back (waveview);
1060                 }
1061         }
1062
1063         toplevel->lower_to_bottom();
1064 }
1065
1066 void
1067 CrossfadeEditor::peaks_ready (AudioRegion* r, WhichFade which)
1068 {
1069         /* this should never be called, because the peak files for an xfade
1070            will be ready by the time we want them. but our API forces us
1071            to provide this, so ..
1072         */
1073
1074         make_waves (*r, which);
1075 }
1076
1077 void
1078 CrossfadeEditor::audition_both ()
1079 {
1080         AudioPlaylist& pl (session.the_auditioner().prepare_playlist());
1081         jack_nframes_t preroll;
1082         jack_nframes_t postroll;
1083         jack_nframes_t length;
1084         jack_nframes_t left_start_offset;
1085         jack_nframes_t right_length;
1086         jack_nframes_t left_length;
1087
1088         if (preroll_button.get_active()) {
1089                 preroll = ARDOUR_UI::instance()->preroll_clock.current_duration ();
1090         } else {
1091                 preroll = 0;
1092         }
1093
1094         if (postroll_button.get_active()) {
1095                 postroll = ARDOUR_UI::instance()->postroll_clock.current_duration ();
1096         } else {
1097                 postroll = 0;
1098         }
1099
1100         if ((left_start_offset = xfade.out().length() - xfade.length()) >= preroll) {
1101                 left_start_offset -= preroll;
1102         }
1103
1104         length = 0;
1105
1106         if ((left_length = xfade.length()) < xfade.out().length() - left_start_offset) {
1107                 length += postroll;
1108         }
1109
1110         right_length = xfade.length();
1111
1112         if (xfade.in().length() - right_length < postroll) {
1113                 right_length += postroll;
1114         }
1115
1116         AudioRegion* left = new AudioRegion (xfade.out(), left_start_offset, left_length, "xfade out",
1117                                              0, Region::DefaultFlags, false);
1118         AudioRegion* right = new AudioRegion (xfade.in(), 0, right_length, "xfade in",
1119                                               0, Region::DefaultFlags, false);
1120
1121         pl.add_region (*left, 0);
1122         pl.add_region (*right, 1+preroll);
1123
1124         /* there is only one ... */
1125
1126         pl.foreach_crossfade (this, &CrossfadeEditor::setup);
1127
1128         session.audition_playlist ();
1129 }
1130
1131 void
1132 CrossfadeEditor::audition_left_dry ()
1133 {
1134         AudioRegion* left = new AudioRegion (xfade.out(), xfade.out().length() - xfade.length(), xfade.length(), "xfade left",
1135                                              0, Region::DefaultFlags, false);
1136
1137         session.audition_region (*left);
1138 }
1139
1140 void
1141 CrossfadeEditor::audition_left ()
1142 {
1143         AudioPlaylist& pl (session.the_auditioner().prepare_playlist());
1144
1145         AudioRegion* left = new AudioRegion (xfade.out(), xfade.out().length() - xfade.length(), xfade.length(), "xfade left",
1146                                              0, Region::DefaultFlags, false);
1147         AudioRegion* right = new AudioRegion (xfade.in(), 0, xfade.length(), "xfade in",
1148                                               0, Region::DefaultFlags, false);
1149
1150         pl.add_region (*left, 0);
1151         pl.add_region (*right, 1);
1152
1153         right->set_muted (true);
1154
1155         /* there is only one ... */
1156
1157         pl.foreach_crossfade (this, &CrossfadeEditor::setup);
1158
1159         session.audition_playlist ();
1160
1161         /* memory leak for regions */
1162 }
1163
1164 void
1165 CrossfadeEditor::audition_right_dry ()
1166 {
1167         AudioRegion* right = new AudioRegion (xfade.in(), 0, xfade.length(), "xfade in",
1168                                               0, Region::DefaultFlags, false);
1169         session.audition_region (*right);
1170 }
1171
1172 void
1173 CrossfadeEditor::audition_right ()
1174 {
1175         AudioPlaylist& pl (session.the_auditioner().prepare_playlist());
1176
1177         AudioRegion* left = new AudioRegion (xfade.out(), xfade.out().length() - xfade.length(), xfade.length(), "xfade out",
1178                                              0, Region::DefaultFlags, false);
1179         AudioRegion* right = new AudioRegion (xfade.out(), 0, xfade.length(), "xfade out",
1180                                               0, Region::DefaultFlags, false);
1181
1182         pl.add_region (*left, 0);
1183         pl.add_region (*right, 1);
1184
1185         left->set_muted (true);
1186
1187         /* there is only one ... */
1188
1189         pl.foreach_crossfade (this, &CrossfadeEditor::setup);
1190
1191         session.audition_playlist ();
1192 }
1193
1194 void
1195 CrossfadeEditor::cancel_audition ()
1196 {
1197         session.cancel_audition ();
1198 }
1199
1200 void
1201 CrossfadeEditor::audition_toggled ()
1202 {
1203         bool x;
1204
1205         if ((x = audition_both_button.get_active ()) != session.is_auditioning()) {
1206
1207                 if (x) {
1208                         audition_both ();
1209                 } else {
1210                         cancel_audition ();
1211                 }
1212         }
1213 }
1214
1215 void
1216 CrossfadeEditor::audition_right_toggled ()
1217 {
1218         bool x;
1219
1220         if ((x = audition_right_button.get_active ()) != session.is_auditioning()) {
1221
1222                 if (x) {
1223                         audition_right ();
1224                 } else {
1225                         cancel_audition ();
1226                 }
1227         }
1228 }
1229
1230 void
1231 CrossfadeEditor::audition_right_dry_toggled ()
1232 {
1233         bool x;
1234
1235         if ((x = audition_right_dry_button.get_active ()) != session.is_auditioning()) {
1236
1237                 if (x) {
1238                         audition_right_dry ();
1239                 } else {
1240                         cancel_audition ();
1241                 }
1242         }
1243 }
1244
1245 void
1246 CrossfadeEditor::audition_left_toggled ()
1247 {
1248         bool x;
1249
1250         if ((x = audition_left_button.get_active ()) != session.is_auditioning()) {
1251
1252                 if (x) {
1253                         audition_left ();
1254                 } else {
1255                         cancel_audition ();
1256                 }
1257         }
1258 }
1259
1260 void
1261 CrossfadeEditor::audition_left_dry_toggled ()
1262 {
1263         bool x;
1264
1265         if ((x = audition_left_dry_button.get_active ()) != session.is_auditioning()) {
1266
1267                 if (x) {
1268                         audition_left_dry ();
1269                 } else {
1270                         cancel_audition ();
1271                 }
1272         }
1273 }