cinelerra-5.0/cinelerra/mwindowedit.C

   1 /*
   2  * CINELERRA
   3  * Copyright (C) 1997-2012 Adam Williams <broadcast at earthling dot net>
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation; either version 2 of the License, or
   8  * (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program; if not, write to the Free Software
  17  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  18  *
  19  */
  20
  21 #include "asset.h"
  22 #include "assets.h"
  23 #include "awindowgui.h"
  24 #include "awindow.h"
  25 #include "bcsignals.h"
  26 #include "cache.h"
  27 #include "clip.h"
  28 #include "clipedit.h"
  29 #include "commercials.h"
  30 #include "cplayback.h"
  31 #include "ctimebar.h"
  32 #include "cwindow.h"
  33 #include "cwindowgui.h"
  34 #include "bchash.h"
  35 #include "edl.h"
  36 #include "edlsession.h"
  37 #include "filexml.h"
  38 #include "floatauto.h"
  39 #include "gwindow.h"
  40 #include "gwindowgui.h"
  41 #include "keyframe.h"
  42 #include "language.h"
  43 #include "labels.h"
  44 #include "levelwindow.h"
  45 #include "localsession.h"
  46 #include "mainclock.h"
  47 #include "maincursor.h"
  48 #include "mainerror.h"
  49 #include "mainindexes.h"
  50 #include "mainmenu.h"
  51 #include "mainsession.h"
  52 #include "mainundo.h"
  53 #include "maskautos.h"
  54 #include "mtimebar.h"
  55 #include "mwindowgui.h"
  56 #include "mwindow.h"
  57 #include "panauto.h"
  58 #include "patchbay.h"
  59 #include "playbackengine.h"
  60 #include "pluginset.h"
  61 #include "recordlabel.h"
  62 #include "samplescroll.h"
  63 #include "trackcanvas.h"
  64 #include "track.h"
  65 #include "trackscroll.h"
  66 #include "tracks.h"
  67 #include "transition.h"
  68 #include "transportque.h"
  69 #include "units.h"
  70 #include "vplayback.h"
  71 #include "vwindow.h"
  72 #include "vwindowgui.h"
  73 #include "zoombar.h"
  74
  75
  76
  77 #include <string.h>
  78
  79
  80
  81
  82
  83
  84 void MWindow::add_audio_track_entry(int above, Track *dst)
  85 {
  86         undo->update_undo_before();
  87         add_audio_track(above, dst);
  88         save_backup();
  89         undo->update_undo_after(_("add track"), LOAD_ALL);
  90
  91         restart_brender();
  92         gui->update(1,
  93                 1,
  94                 0,
  95                 0,
  96                 1,
  97                 0,
  98                 0);
  99         gui->activate_timeline();
 100
 101 //      gui->get_scrollbars(0);
 102 //      gui->canvas->draw();
 103 //      gui->patchbay->update();
 104 //      gui->cursor->draw(1);
 105 //      gui->canvas->flash();
 106 //      gui->canvas->activate();
 107         cwindow->playback_engine->que->send_command(CURRENT_FRAME,
 108                 CHANGE_EDL,
 109                 edl,
 110                 1);
 111 }
 112
 113 void MWindow::add_video_track_entry(Track *dst)
 114 {
 115         undo->update_undo_before();
 116         add_video_track(1, dst);
 117         undo->update_undo_after(_("add track"), LOAD_ALL);
 118
 119         restart_brender();
 120
 121         gui->update(1,
 122                 1,
 123                 0,
 124                 0,
 125                 1,
 126                 0,
 127                 0);
 128         gui->activate_timeline();
 129 //      gui->get_scrollbars(0);
 130 //      gui->canvas->draw();
 131 //      gui->patchbay->update();
 132 //      gui->cursor->draw(1);
 133 //      gui->canvas->flash();
 134 //      gui->canvas->activate();
 135         cwindow->playback_engine->que->send_command(CURRENT_FRAME,
 136                                                         CHANGE_EDL,
 137                                                         edl,
 138                                                         1);
 139         save_backup();
 140 }
 141
 142 void MWindow::add_subttl_track_entry(Track *dst)
 143 {
 144         undo->update_undo_before();
 145         add_subttl_track(1, dst);
 146         undo->update_undo_after(_("add track"), LOAD_ALL);
 147
 148         restart_brender();
 149 //      gui->get_scrollbars(0);
 150 //      gui->canvas->draw();
 151 //      gui->patchbay->update();
 152 //      gui->cursor->draw(1);
 153 //      gui->canvas->flash();
 154 //      gui->canvas->activate();
 155         cwindow->playback_engine->que->send_command(CURRENT_FRAME,
 156                                                         CHANGE_EDL,
 157                                                         edl,
 158                                                         1);
 159         save_backup();
 160 }
 161
 162
 163 int MWindow::add_audio_track(int above, Track *dst)
 164 {
 165         edl->tracks->add_audio_track(above, dst);
 166         edl->tracks->update_y_pixels(theme);
 167         save_backup();
 168         return 0;
 169 }
 170
 171 int MWindow::add_video_track(int above, Track *dst)
 172 {
 173         edl->tracks->add_video_track(above, dst);
 174         edl->tracks->update_y_pixels(theme);
 175         save_backup();
 176         return 0;
 177 }
 178
 179 int MWindow::add_subttl_track(int above, Track *dst)
 180 {
 181         edl->tracks->add_subttl_track(above, dst);
 182         edl->tracks->update_y_pixels(theme);
 183         save_backup();
 184         return 0;
 185 }
 186
 187
 188
 189
 190 void MWindow::asset_to_all()
 191 {
 192         if(!session->drag_assets->size()) return;
 193         Indexable *indexable = session->drag_assets->get(0);
 194
 195 //      if(indexable->have_video())
 196         {
 197                 int w, h;
 198
 199                 undo->update_undo_before();
 200
 201 // Get w and h
 202                 w = indexable->get_w();
 203                 h = indexable->get_h();
 204                 double new_framerate = session->drag_assets->get(0)->get_frame_rate();
 205                 double old_framerate = edl->session->frame_rate;
 206                 int old_samplerate = edl->session->sample_rate;
 207                 int new_samplerate = session->drag_assets->get(0)->get_sample_rate();
 208
 209
 210                 if(indexable->have_video())
 211                 {
 212                         edl->session->output_w = w;
 213                         edl->session->output_h = h;
 214                         edl->session->frame_rate = new_framerate;
 215                         create_aspect_ratio(edl->session->aspect_w,
 216                                 edl->session->aspect_h,
 217                                 w,
 218                                 h);
 219
 220                         for(Track *current = edl->tracks->first;
 221                                 current;
 222                                 current = NEXT)
 223                         {
 224                                 if(current->data_type == TRACK_VIDEO &&
 225                                         current->record)
 226                                 {
 227                                         current->track_w = w;
 228                                         current->track_h = h;
 229                                 }
 230                         }
 231
 232
 233                         if(((edl->session->output_w % 4) ||
 234                                 (edl->session->output_h % 4)) &&
 235                                 edl->session->playback_config->vconfig->driver == PLAYBACK_X11_GL)
 236                         {
 237                                 MainError::show_error(
 238                                         _("This project's dimensions are not multiples of 4 so\n"
 239                                         "it can't be rendered by OpenGL."));
 240                         }
 241
 242
 243 // Get aspect ratio
 244                         if(defaults->get("AUTOASPECT", 0))
 245                         {
 246                                 create_aspect_ratio(edl->session->aspect_w,
 247                                         edl->session->aspect_h,
 248                                         w,
 249                                         h);
 250                         }
 251                 }
 252
 253                 if(indexable->have_audio())
 254                 {
 255                         edl->session->sample_rate = new_samplerate;
 256                         edl->resample(old_framerate, new_framerate, TRACK_VIDEO);
 257                         edl->resample(old_samplerate, new_samplerate, TRACK_AUDIO);
 258                 }
 259
 260
 261                 save_backup();
 262
 263                 undo->update_undo_after(_("asset to all"), LOAD_ALL);
 264                 restart_brender();
 265                 gui->update(1,
 266                         2,
 267                         1,
 268                         1,
 269                         1,
 270                         1,
 271                         0);
 272                 sync_parameters(CHANGE_ALL);
 273         }
 274 }
 275
 276
 277
 278
 279
 280
 281 void MWindow::asset_to_size()
 282 {
 283         if(!session->drag_assets->size()) return;
 284         Indexable *indexable = session->drag_assets->get(0);
 285
 286         if(indexable->have_video())
 287         {
 288                 int w, h;
 289                 undo->update_undo_before();
 290
 291 // Get w and h
 292                 w = indexable->get_w();
 293                 h = indexable->get_h();
 294
 295
 296                 edl->session->output_w = w;
 297                 edl->session->output_h = h;
 298
 299                 if(((edl->session->output_w % 4) ||
 300                         (edl->session->output_h % 4)) &&
 301                         edl->session->playback_config->vconfig->driver == PLAYBACK_X11_GL)
 302                 {
 303                         MainError::show_error(
 304                                 _("This project's dimensions are not multiples of 4 so\n"
 305                                 "it can't be rendered by OpenGL."));
 306                 }
 307
 308
 309 // Get aspect ratio
 310                 if(defaults->get("AUTOASPECT", 0))
 311                 {
 312                         create_aspect_ratio(edl->session->aspect_w,
 313                                 edl->session->aspect_h,
 314                                 w,
 315                                 h);
 316                 }
 317
 318                 save_backup();
 319
 320                 undo->update_undo_after(_("asset to size"), LOAD_ALL);
 321                 restart_brender();
 322                 sync_parameters(CHANGE_ALL);
 323         }
 324 }
 325
 326
 327 void MWindow::asset_to_rate()
 328 {
 329         if(session->drag_assets->size() &&
 330                 session->drag_assets->get(0)->have_video())
 331         {
 332                 double new_framerate = session->drag_assets->get(0)->get_frame_rate();
 333                 double old_framerate = edl->session->frame_rate;
 334                 undo->update_undo_before();
 335
 336                 edl->session->frame_rate = new_framerate;
 337                 edl->resample(old_framerate, new_framerate, TRACK_VIDEO);
 338
 339                 save_backup();
 340
 341                 undo->update_undo_after(_("asset to rate"), LOAD_ALL);
 342                 restart_brender();
 343                 gui->update(1,
 344                         2,
 345                         1,
 346                         1,
 347                         1,
 348                         1,
 349                         0);
 350                 sync_parameters(CHANGE_ALL);
 351         }
 352 }
 353
 354
 355
 356 void MWindow::clear_entry()
 357 {
 358         undo->update_undo_before();
 359         clear(1);
 360
 361         edl->optimize();
 362         save_backup();
 363         undo->update_undo_after(_("clear"), LOAD_EDITS | LOAD_TIMEBAR);
 364
 365         restart_brender();
 366         update_plugin_guis();
 367         gui->update(1, 2, 1, 1, 1, 1, 0);
 368         cwindow->update(1, 0, 0, 0, 1);
 369         cwindow->playback_engine->que->send_command(CURRENT_FRAME,
 370                            CHANGE_EDL,
 371                            edl,
 372                            1);
 373 }
 374
 375 void MWindow::clear(int clear_handle)
 376 {
 377         double start = edl->local_session->get_selectionstart();
 378         double end = edl->local_session->get_selectionend();
 379         if(clear_handle || !EQUIV(start, end))
 380         {
 381                 edl->clear(start,
 382                         end,
 383                         edl->session->labels_follow_edits,
 384                         edl->session->plugins_follow_edits,
 385                         edl->session->autos_follow_edits);
 386         }
 387 }
 388
 389 void MWindow::set_automation_mode(int mode)
 390 {
 391         undo->update_undo_before();
 392         edl->tracks->set_automation_mode(
 393                 edl->local_session->get_selectionstart(),
 394                 edl->local_session->get_selectionend(),
 395                 mode);
 396         save_backup();
 397
 398         if(mode == Auto::LINEAR)
 399                 undo->update_undo_after(_("set linear"), LOAD_AUTOMATION);
 400         else
 401                 undo->update_undo_after(_("set bezier"), LOAD_AUTOMATION);
 402
 403         restart_brender();
 404         update_plugin_guis();
 405         gui->draw_overlays(1);
 406         sync_parameters(CHANGE_PARAMS);
 407         gui->update_patchbay();
 408         cwindow->update(1, 0, 0);
 409 }
 410
 411 void MWindow::clear_automation()
 412 {
 413         undo->update_undo_before();
 414         edl->tracks->clear_automation(edl->local_session->get_selectionstart(),
 415                 edl->local_session->get_selectionend());
 416         save_backup();
 417         undo->update_undo_after(_("clear keyframes"), LOAD_AUTOMATION);
 418
 419         restart_brender();
 420         update_plugin_guis();
 421         gui->draw_overlays(1);
 422         sync_parameters(CHANGE_PARAMS);
 423         gui->update_patchbay();
 424         cwindow->update(1, 0, 0);
 425 }
 426
 427 int MWindow::clear_default_keyframe()
 428 {
 429         undo->update_undo_before();
 430         edl->tracks->clear_default_keyframe();
 431         save_backup();
 432         undo->update_undo_after(_("clear default keyframe"), LOAD_AUTOMATION);
 433
 434         restart_brender();
 435         gui->draw_overlays(1);
 436         sync_parameters(CHANGE_PARAMS);
 437         gui->update_patchbay();
 438         cwindow->update(1, 0, 0);
 439
 440         return 0;
 441 }
 442
 443 void MWindow::clear_labels()
 444 {
 445         undo->update_undo_before();
 446         clear_labels(edl->local_session->get_selectionstart(),
 447                 edl->local_session->get_selectionend());
 448         undo->update_undo_after(_("clear labels"), LOAD_TIMEBAR);
 449
 450         gui->update_timebar(1);
 451         cwindow->update(0, 0, 0, 0, 1);
 452         save_backup();
 453 }
 454
 455 int MWindow::clear_labels(double start, double end)
 456 {
 457         edl->labels->clear(start, end, 0);
 458         return 0;
 459 }
 460
 461 void MWindow::concatenate_tracks()
 462 {
 463         undo->update_undo_before();
 464         edl->tracks->concatenate_tracks(edl->session->plugins_follow_edits,
 465                 edl->session->autos_follow_edits);
 466         save_backup();
 467         undo->update_undo_after(_("concatenate tracks"), LOAD_EDITS);
 468
 469         restart_brender();
 470         gui->update(1, 1, 0, 0, 1, 0, 0);
 471         cwindow->playback_engine->que->send_command(CURRENT_FRAME,
 472                 CHANGE_EDL,
 473                 edl,
 474                 1);
 475 }
 476
 477
 478 void MWindow::copy()
 479 {
 480         copy(edl->local_session->get_selectionstart(),
 481                 edl->local_session->get_selectionend());
 482 }
 483
 484 int MWindow::copy(double start, double end)
 485 {
 486         if(start == end) return 1;
 487
 488 //printf("MWindow::copy 1\n");
 489         FileXML file;
 490 //printf("MWindow::copy 1\n");
 491         edl->copy(start,
 492                 end,
 493                 0,
 494                 0,
 495                 0,
 496                 &file,
 497                 "",
 498                 1);
 499 //printf("MWindow::copy 1\n");
 500
 501 // File is now terminated and rewound
 502
 503 //printf("MWindow::copy 1\n");
 504         const char *file_string = file.string();
 505         long file_length = strlen(file_string);
 506         gui->get_clipboard()->to_clipboard(file_string, file_length,
 507                 SECONDARY_SELECTION);
 508         gui->get_clipboard()->to_clipboard(file_string, file_length,
 509                 BC_PRIMARY_SELECTION);
 510 //printf("MWindow::copy\n%s\n", file.string);
 511 //printf("MWindow::copy 2\n");
 512         save_backup();
 513         return 0;
 514 }
 515
 516 int MWindow::copy_automation()
 517 {
 518         FileXML file;
 519         edl->tracks->copy_automation(edl->local_session->get_selectionstart(),
 520                 edl->local_session->get_selectionend(),
 521                 &file,
 522                 0,
 523                 1);
 524         const char *file_string = file.string();
 525         long file_length = strlen(file_string);
 526         gui->get_clipboard()->to_clipboard(file_string, file_length,
 527                 BC_PRIMARY_SELECTION);
 528         gui->get_clipboard()->to_clipboard(file_string, file_length,
 529                 SECONDARY_SELECTION);
 530         return 0;
 531 }
 532
 533 int MWindow::copy_default_keyframe()
 534 {
 535         FileXML file;
 536         edl->tracks->copy_automation(edl->local_session->get_selectionstart(),
 537                 edl->local_session->get_selectionend(),
 538                 &file,
 539                 1,
 540                 0);
 541         const char *file_string = file.string();
 542         long file_length = strlen(file_string);
 543         gui->get_clipboard()->to_clipboard(file_string, file_length,
 544                 BC_PRIMARY_SELECTION);
 545         gui->get_clipboard()->to_clipboard(file_string, file_length,
 546                 SECONDARY_SELECTION);
 547         return 0;
 548 }
 549
 550
 551 // Uses cropping coordinates in edl session to crop and translate video.
 552 // We modify the projector since camera automation depends on the track size.
 553 void MWindow::crop_video()
 554 {
 555
 556         undo->update_undo_before();
 557 // Clamp EDL crop region
 558         if(edl->session->crop_x1 > edl->session->crop_x2)
 559         {
 560                 edl->session->crop_x1 ^= edl->session->crop_x2;
 561                 edl->session->crop_x2 ^= edl->session->crop_x1;
 562                 edl->session->crop_x1 ^= edl->session->crop_x2;
 563         }
 564         if(edl->session->crop_y1 > edl->session->crop_y2)
 565         {
 566                 edl->session->crop_y1 ^= edl->session->crop_y2;
 567                 edl->session->crop_y2 ^= edl->session->crop_y1;
 568                 edl->session->crop_y1 ^= edl->session->crop_y2;
 569         }
 570
 571         float old_projector_x = (float)edl->session->output_w / 2;
 572         float old_projector_y = (float)edl->session->output_h / 2;
 573         float new_projector_x = (float)(edl->session->crop_x1 + edl->session->crop_x2) / 2;
 574         float new_projector_y = (float)(edl->session->crop_y1 + edl->session->crop_y2) / 2;
 575         float projector_offset_x = -(new_projector_x - old_projector_x);
 576         float projector_offset_y = -(new_projector_y - old_projector_y);
 577
 578         edl->tracks->translate_projector(projector_offset_x, projector_offset_y);
 579
 580         edl->session->output_w = edl->session->crop_x2 - edl->session->crop_x1;
 581         edl->session->output_h = edl->session->crop_y2 - edl->session->crop_y1;
 582         edl->session->crop_x1 = 0;
 583         edl->session->crop_y1 = 0;
 584         edl->session->crop_x2 = edl->session->output_w;
 585         edl->session->crop_y2 = edl->session->output_h;
 586
 587 // Recalculate aspect ratio
 588         if(defaults->get("AUTOASPECT", 0))
 589         {
 590                 create_aspect_ratio(edl->session->aspect_w,
 591                         edl->session->aspect_h,
 592                         edl->session->output_w,
 593                         edl->session->output_h);
 594         }
 595
 596         undo->update_undo_after(_("crop"), LOAD_ALL);
 597
 598         restart_brender();
 599         cwindow->playback_engine->que->send_command(CURRENT_FRAME,
 600                 CHANGE_ALL,
 601                 edl,
 602                 1);
 603         save_backup();
 604 }
 605
 606 void MWindow::cut()
 607 {
 608         undo->update_undo_before();
 609
 610         double start = edl->local_session->get_selectionstart();
 611         double end = edl->local_session->get_selectionend();
 612
 613         copy(start, end);
 614         edl->clear(start,
 615                 end,
 616                 edl->session->labels_follow_edits,
 617                 edl->session->plugins_follow_edits,
 618                 edl->session->autos_follow_edits);
 619
 620
 621         edl->optimize();
 622         save_backup();
 623         undo->update_undo_after(_("cut"), LOAD_EDITS | LOAD_TIMEBAR);
 624
 625         restart_brender();
 626         update_plugin_guis();
 627         gui->update(1, 2, 1, 1, 1, 1, 0);
 628         cwindow->update(1, 0, 0, 0, 1);
 629         cwindow->playback_engine->que->send_command(CURRENT_FRAME,
 630                                                         CHANGE_EDL,
 631                                                         edl,
 632                                                         1);
 633 }
 634
 635 int MWindow::cut_automation()
 636 {
 637         undo->update_undo_before();
 638
 639         copy_automation();
 640
 641         edl->tracks->clear_automation(edl->local_session->get_selectionstart(),
 642                 edl->local_session->get_selectionend());
 643         save_backup();
 644         undo->update_undo_after(_("cut keyframes"), LOAD_AUTOMATION);
 645
 646
 647         restart_brender();
 648         update_plugin_guis();
 649         gui->draw_overlays(1);
 650         sync_parameters(CHANGE_PARAMS);
 651         gui->update_patchbay();
 652         cwindow->update(1, 0, 0);
 653         return 0;
 654 }
 655
 656 int MWindow::cut_default_keyframe()
 657 {
 658
 659         undo->update_undo_before();
 660         copy_default_keyframe();
 661         edl->tracks->clear_default_keyframe();
 662         undo->update_undo_after(_("cut default keyframe"), LOAD_AUTOMATION);
 663
 664         restart_brender();
 665         gui->draw_overlays(1);
 666         sync_parameters(CHANGE_PARAMS);
 667         gui->update_patchbay();
 668         cwindow->update(1, 0, 0);
 669         save_backup();
 670
 671
 672         return 0;
 673 }
 674
 675 void MWindow::delete_inpoint()
 676 {
 677         edl->local_session->unset_inpoint();
 678         save_backup();
 679 }
 680
 681 void MWindow::delete_outpoint()
 682 {
 683         edl->local_session->unset_outpoint();
 684         save_backup();
 685 }
 686
 687 void MWindow::delete_track()
 688 {
 689         if (edl->tracks->last)
 690                 delete_track(edl->tracks->last);
 691 }
 692
 693 void MWindow::delete_tracks()
 694 {
 695         undo->update_undo_before();
 696         edl->tracks->delete_tracks();
 697         undo->update_undo_after(_("delete tracks"), LOAD_ALL);
 698         save_backup();
 699
 700         restart_brender();
 701         update_plugin_states();
 702         gui->update(1, 1, 1, 0, 1, 0, 0);
 703         cwindow->playback_engine->que->send_command(CURRENT_FRAME,
 704                            CHANGE_EDL,
 705                            edl,
 706                            1);
 707 }
 708
 709 void MWindow::delete_track(Track *track)
 710 {
 711         undo->update_undo_before();
 712         edl->tracks->delete_track(track);
 713         undo->update_undo_after(_("delete track"), LOAD_ALL);
 714
 715         restart_brender();
 716         update_plugin_states();
 717         gui->update(1, 1, 1, 0, 1, 0, 0);
 718         cwindow->playback_engine->que->send_command(CURRENT_FRAME,
 719                            CHANGE_EDL,
 720                            edl,
 721                            1);
 722         save_backup();
 723 }
 724
 725
 726
 727
 728
 729 // Insert data from clipboard
 730 void MWindow::insert(double position,
 731         FileXML *file,
 732         int edit_labels,
 733         int edit_plugins,
 734         int edit_autos,
 735         EDL *parent_edl)
 736 {
 737 // For clipboard pasting make the new edl use a separate session
 738 // from the master EDL.  Then it can be resampled to the master rates.
 739 // For splice, overwrite, and dragging need same session to get the assets.
 740         EDL *edl = new EDL(parent_edl);
 741         ArrayList<EDL*> new_edls;
 742         uint32_t load_flags = LOAD_ALL;
 743
 744
 745         new_edls.append(edl);
 746         edl->create_objects();
 747
 748
 749
 750
 751         if(parent_edl) load_flags &= ~LOAD_SESSION;
 752         if(!edl->session->autos_follow_edits) load_flags &= ~LOAD_AUTOMATION;
 753         if(!edl->session->labels_follow_edits) load_flags &= ~LOAD_TIMEBAR;
 754
 755         edl->load_xml(file, load_flags);
 756
 757
 758 //printf("MWindow::insert %f\n", edl->local_session->clipboard_length);
 759
 760
 761
 762         paste_edls(&new_edls,
 763                 LOADMODE_PASTE,
 764                 0,
 765                 position,
 766                 edit_labels,
 767                 edit_plugins,
 768                 edit_autos);
 769 // if(vwindow->edl)
 770 // printf("MWindow::insert 5 %f %f\n",
 771 // vwindow->edl->local_session->in_point,
 772 // vwindow->edl->local_session->out_point);
 773         new_edls.remove_all();
 774         edl->Garbage::remove_user();
 775 //printf("MWindow::insert 6 %p\n", vwindow->get_edl());
 776 }
 777
 778 void MWindow::insert_effects_canvas(double start,
 779         double length)
 780 {
 781         Track *dest_track = session->track_highlighted;
 782         if(!dest_track) return;
 783
 784         undo->update_undo_before();
 785
 786         for(int i = 0; i < session->drag_pluginservers->total; i++)
 787         {
 788                 PluginServer *plugin = session->drag_pluginservers->values[i];
 789
 790                 insert_effect(plugin->title,
 791                         0,
 792                         dest_track,
 793                         i == 0 ? session->pluginset_highlighted : 0,
 794                         start,
 795                         length,
 796                         PLUGIN_STANDALONE);
 797         }
 798
 799         save_backup();
 800         undo->update_undo_after(_("insert effect"), LOAD_EDITS | LOAD_PATCHES);
 801         restart_brender();
 802         sync_parameters(CHANGE_EDL);
 803 // GUI updated in TrackCanvas, after current_operations are reset
 804 }
 805
 806 void MWindow::insert_effects_cwindow(Track *dest_track)
 807 {
 808         if(!dest_track) return;
 809
 810         undo->update_undo_before();
 811
 812         double start = 0;
 813         double length = dest_track->get_length();
 814
 815         if(edl->local_session->get_selectionend() >
 816                 edl->local_session->get_selectionstart())
 817         {
 818                 start = edl->local_session->get_selectionstart();
 819                 length = edl->local_session->get_selectionend() -
 820                         edl->local_session->get_selectionstart();
 821         }
 822
 823         for(int i = 0; i < session->drag_pluginservers->total; i++)
 824         {
 825                 PluginServer *plugin = session->drag_pluginservers->values[i];
 826
 827
 828                 insert_effect(plugin->title,
 829                         0,
 830                         dest_track,
 831                         0,
 832                         start,
 833                         length,
 834                         PLUGIN_STANDALONE);
 835         }
 836
 837         save_backup();
 838         undo->update_undo_after(_("insert effect"), LOAD_EDITS | LOAD_PATCHES);
 839         restart_brender();
 840         sync_parameters(CHANGE_EDL);
 841         gui->update(1,
 842                 1,
 843                 0,
 844                 0,
 845                 1,
 846                 0,
 847                 0);
 848 }
 849
 850 void MWindow::insert_effect(char *title,
 851         SharedLocation *shared_location,
 852         int data_type,
 853         int plugin_type,
 854         int single_standalone)
 855 {
 856         Track *current = edl->tracks->first;
 857         SharedLocation shared_location_local;
 858         shared_location_local.copy_from(shared_location);
 859         int first_track = 1;
 860         for( ; current; current = NEXT)
 861         {
 862                 if(current->data_type == data_type &&
 863                         current->record)
 864                 {
 865                         insert_effect(title,
 866                                 &shared_location_local,
 867                                 current,
 868                                 0,
 869                                 0,
 870                                 0,
 871                                 plugin_type);
 872
 873                         if(first_track)
 874                         {
 875                                 if(plugin_type == PLUGIN_STANDALONE && single_standalone)
 876                                 {
 877                                         plugin_type = PLUGIN_SHAREDPLUGIN;
 878                                         shared_location_local.module = edl->tracks->number_of(current);
 879                                         shared_location_local.plugin = current->plugin_set.total - 1;
 880                                 }
 881                                 first_track = 0;
 882                         }
 883                 }
 884         }
 885 }
 886
 887
 888 void MWindow::insert_effect(char *title,
 889         SharedLocation *shared_location,
 890         Track *track,
 891         PluginSet *plugin_set,
 892         double start,
 893         double length,
 894         int plugin_type)
 895 {
 896         KeyFrame *default_keyframe = 0;
 897         PluginServer *server = 0;
 898
 899
 900
 901
 902
 903
 904 // Get default keyframe
 905         if(plugin_type == PLUGIN_STANDALONE)
 906         {
 907                 default_keyframe = new KeyFrame;
 908                 server = new PluginServer(*scan_plugindb(title, track->data_type));
 909
 910                 server->open_plugin(0, preferences, edl, 0);
 911                 server->save_data(default_keyframe);
 912         }
 913
 914
 915
 916 // Insert plugin object
 917         track->insert_effect(title,
 918                 shared_location,
 919                 default_keyframe,
 920                 plugin_set,
 921                 start,
 922                 length,
 923                 plugin_type);
 924
 925         track->optimize();
 926
 927
 928         if(plugin_type == PLUGIN_STANDALONE)
 929         {
 930                 server->close_plugin();
 931                 delete server;
 932                 delete default_keyframe;
 933         }
 934 }
 935
 936 int MWindow::modify_edithandles()
 937 {
 938         undo->update_undo_before();
 939         edl->modify_edithandles(session->drag_start,
 940                 session->drag_position,
 941                 session->drag_handle,
 942                 edl->session->edit_handle_mode[session->drag_button],
 943                 edl->session->labels_follow_edits,
 944                 edl->session->plugins_follow_edits,
 945                 edl->session->autos_follow_edits);
 946
 947         finish_modify_handles();
 948
 949
 950 //printf("MWindow::modify_handles 1\n");
 951         return 0;
 952 }
 953
 954 int MWindow::modify_pluginhandles()
 955 {
 956         undo->update_undo_before();
 957
 958         edl->modify_pluginhandles(session->drag_start,
 959                 session->drag_position,
 960                 session->drag_handle,
 961                 edl->session->edit_handle_mode[session->drag_button],
 962                 edl->session->labels_follow_edits,
 963                 edl->session->autos_follow_edits,
 964                 session->trim_edits);
 965
 966         finish_modify_handles();
 967
 968         return 0;
 969 }
 970
 971
 972 // Common to edithandles and plugin handles
 973 void MWindow::finish_modify_handles()
 974 {
 975         int edit_mode = edl->session->edit_handle_mode[session->drag_button];
 976
 977         if((session->drag_handle == 1 && edit_mode != MOVE_NO_EDITS) ||
 978                 (session->drag_handle == 0 && edit_mode == MOVE_ONE_EDIT))
 979         {
 980                 edl->local_session->set_selectionstart(session->drag_position);
 981                 edl->local_session->set_selectionend(session->drag_position);
 982         }
 983         else
 984         if(edit_mode != MOVE_NO_EDITS)
 985         {
 986                 edl->local_session->set_selectionstart(session->drag_start);
 987                 edl->local_session->set_selectionend(session->drag_start);
 988         }
 989
 990         if(edl->local_session->get_selectionstart(1) < 0)
 991         {
 992                 edl->local_session->set_selectionstart(0);
 993                 edl->local_session->set_selectionend(0);
 994         }
 995         undo->update_undo_after(_("drag handle"), LOAD_EDITS | LOAD_TIMEBAR);
 996
 997         save_backup();
 998         restart_brender();
 999         sync_parameters(CHANGE_EDL);
1000         update_plugin_guis();
1001         gui->update(1, 2, 1, 1, 1, 1, 0);
1002         cwindow->update(1, 0, 0, 0, 1);
1003 }
1004
1005 void MWindow::match_output_size(Track *track)
1006 {
1007         undo->update_undo_before();
1008         track->track_w = edl->session->output_w;
1009         track->track_h = edl->session->output_h;
1010         save_backup();
1011         undo->update_undo_after(_("match output size"), LOAD_ALL);
1012
1013         restart_brender();
1014         sync_parameters(CHANGE_EDL);
1015 }
1016
1017
1018 void MWindow::move_edits(ArrayList<Edit*> *edits,
1019                 Track *track,
1020                 double position)
1021 {
1022         undo->update_undo_before();
1023
1024         edl->tracks->move_edits(edits,
1025                 track,
1026                 position,
1027                 edl->session->labels_follow_edits,
1028                 edl->session->plugins_follow_edits,
1029                 edl->session->autos_follow_edits);
1030
1031         save_backup();
1032         undo->update_undo_after(_("move edit"), LOAD_ALL);
1033
1034         restart_brender();
1035         cwindow->playback_engine->que->send_command(CURRENT_FRAME,
1036                 CHANGE_EDL,
1037                 edl,
1038                 1);
1039
1040         update_plugin_guis();
1041         gui->update(1,
1042                 1,      // 1 for incremental drawing.  2 for full refresh
1043                 1,
1044                 0,
1045                 0,
1046                 0,
1047                 0);
1048 }
1049
1050 void MWindow::move_effect(Plugin *plugin,
1051         PluginSet *dest_plugin_set,
1052         Track *dest_track,
1053         int64_t dest_position)
1054 {
1055         undo->update_undo_before();
1056
1057         edl->tracks->move_effect(plugin,
1058                 dest_plugin_set,
1059                 dest_track,
1060                 dest_position);
1061
1062         save_backup();
1063         undo->update_undo_after(_("move effect"), LOAD_ALL);
1064
1065         restart_brender();
1066         cwindow->playback_engine->que->send_command(CURRENT_FRAME,
1067                 CHANGE_EDL,
1068                 edl,
1069                 1);
1070
1071         update_plugin_guis();
1072         gui->update(1,
1073                 1,      // 1 for incremental drawing.  2 for full refresh
1074                 0,
1075                 0,
1076                 0,
1077                 0,
1078                 0);
1079 }
1080
1081 void MWindow::move_plugins_up(PluginSet *plugin_set)
1082 {
1083
1084         undo->update_undo_before();
1085         plugin_set->track->move_plugins_up(plugin_set);
1086
1087         save_backup();
1088         undo->update_undo_after(_("move effect up"), LOAD_ALL);
1089         restart_brender();
1090         gui->update(1,
1091                 1,      // 1 for incremental drawing.  2 for full refresh
1092                 0,
1093                 0,
1094                 0,
1095                 0,
1096                 0);
1097         sync_parameters(CHANGE_EDL);
1098 }
1099
1100 void MWindow::move_plugins_down(PluginSet *plugin_set)
1101 {
1102         undo->update_undo_before();
1103
1104         plugin_set->track->move_plugins_down(plugin_set);
1105
1106         save_backup();
1107         undo->update_undo_after(_("move effect down"), LOAD_ALL);
1108         restart_brender();
1109         gui->update(1,
1110                 1,      // 1 for incremental drawing.  2 for full refresh
1111                 0,
1112                 0,
1113                 0,
1114                 0,
1115                 0);
1116         sync_parameters(CHANGE_EDL);
1117 }
1118
1119 void MWindow::move_track_down(Track *track)
1120 {
1121         undo->update_undo_before();
1122         edl->tracks->move_track_down(track);
1123         save_backup();
1124         undo->update_undo_after(_("move track down"), LOAD_ALL);
1125
1126         restart_brender();
1127         gui->update(1, 1, 0, 0, 1, 0, 0);
1128         sync_parameters(CHANGE_EDL);
1129         save_backup();
1130 }
1131
1132 void MWindow::move_tracks_down()
1133 {
1134         undo->update_undo_before();
1135         edl->tracks->move_tracks_down();
1136         save_backup();
1137         undo->update_undo_after(_("move tracks down"), LOAD_ALL);
1138
1139         restart_brender();
1140         gui->update(1, 1, 0, 0, 1, 0, 0);
1141         sync_parameters(CHANGE_EDL);
1142         save_backup();
1143 }
1144
1145 void MWindow::move_track_up(Track *track)
1146 {
1147         undo->update_undo_before();
1148         edl->tracks->move_track_up(track);
1149         save_backup();
1150         undo->update_undo_after(_("move track up"), LOAD_ALL);
1151         restart_brender();
1152         gui->update(1, 1, 0, 0, 1, 0, 0);
1153         sync_parameters(CHANGE_EDL);
1154         save_backup();
1155 }
1156
1157 void MWindow::move_tracks_up()
1158 {
1159         undo->update_undo_before();
1160         edl->tracks->move_tracks_up();
1161         save_backup();
1162         undo->update_undo_after(_("move tracks up"), LOAD_ALL);
1163         restart_brender();
1164         gui->update(1, 1, 0, 0, 1, 0, 0);
1165         sync_parameters(CHANGE_EDL);
1166 }
1167
1168
1169 void MWindow::mute_selection()
1170 {
1171         double start = edl->local_session->get_selectionstart();
1172         double end = edl->local_session->get_selectionend();
1173         if(start != end)
1174         {
1175                 undo->update_undo_before();
1176                 edl->clear(start,
1177                         end,
1178                         0,
1179                         edl->session->plugins_follow_edits,
1180                         edl->session->autos_follow_edits);
1181                 edl->local_session->set_selectionend(end);
1182                 edl->local_session->set_selectionstart(start);
1183                 edl->paste_silence(start,
1184                         end,
1185                         0,
1186                         edl->session->plugins_follow_edits,
1187                         edl->session->autos_follow_edits);
1188                 save_backup();
1189                 undo->update_undo_after(_("mute"), LOAD_EDITS);
1190
1191                 restart_brender();
1192                 update_plugin_guis();
1193                 gui->update(1, 2, 1, 1, 1, 1, 0);
1194                 cwindow->playback_engine->que->send_command(CURRENT_FRAME,
1195                                                                 CHANGE_EDL,
1196                                                                 edl,
1197                                                                 1);
1198         }
1199 }
1200
1201
1202
1203 void MWindow::overwrite(EDL *source)
1204 {
1205         FileXML file;
1206
1207         double src_start = source->local_session->get_selectionstart();
1208         double overwrite_len = source->local_session->get_selectionend() - src_start;
1209         double dst_start = edl->local_session->get_selectionstart();
1210         double dst_len = edl->local_session->get_selectionend() - dst_start;
1211
1212         undo->update_undo_before();
1213         if (!EQUIV(dst_len, 0) && (dst_len < overwrite_len))
1214         {
1215 // in/out points or selection present and shorter than overwrite range
1216 // shorten the copy range
1217                 overwrite_len = dst_len;
1218         }
1219
1220         source->copy(src_start,
1221                 src_start + overwrite_len,
1222                 1,
1223                 0,
1224                 0,
1225                 &file,
1226                 "",
1227                 1);
1228
1229 // HACK around paste_edl get_start/endselection on its own
1230 // so we need to clear only when not using both io points
1231 // FIXME: need to write simple overwrite_edl to be used for overwrite function
1232         if (edl->local_session->get_inpoint() < 0 ||
1233                 edl->local_session->get_outpoint() < 0)
1234                 edl->clear(dst_start,
1235                         dst_start + overwrite_len,
1236                         0,
1237                         0,
1238                         0);
1239
1240         paste(dst_start,
1241                 dst_start + overwrite_len,
1242                 &file,
1243                 0,
1244                 0,
1245                 0);
1246
1247         edl->local_session->set_selectionstart(dst_start + overwrite_len);
1248         edl->local_session->set_selectionend(dst_start + overwrite_len);
1249
1250         save_backup();
1251         undo->update_undo_after(_("overwrite"), LOAD_EDITS);
1252
1253         restart_brender();
1254         update_plugin_guis();
1255         gui->update(1, 1, 1, 1, 0, 1, 0);
1256         sync_parameters(CHANGE_EDL);
1257 }
1258
1259 // For splice and overwrite
1260 int MWindow::paste(double start,
1261         double end,
1262         FileXML *file,
1263         int edit_labels,
1264         int edit_plugins,
1265         int edit_autos)
1266 {
1267         clear(0);
1268
1269 // Want to insert with assets shared with the master EDL.
1270         insert(start,
1271                         file,
1272                         edit_labels,
1273                         edit_plugins,
1274                         edit_autos,
1275                         edl);
1276
1277         return 0;
1278 }
1279
1280 // For editing using insertion point
1281 void MWindow::paste()
1282 {
1283         double start = edl->local_session->get_selectionstart();
1284         //double end = edl->local_session->get_selectionend();
1285         int64_t len = gui->get_clipboard()->clipboard_len(SECONDARY_SELECTION);
1286
1287         if(len)
1288         {
1289                 char *string = new char[len + 1];
1290
1291                 undo->update_undo_before();
1292
1293
1294                 gui->get_clipboard()->from_clipboard(string,
1295                         len,
1296                         BC_PRIMARY_SELECTION);
1297                 FileXML file;
1298                 file.read_from_string(string);
1299
1300
1301
1302
1303                 clear(0);
1304
1305                 insert(start,
1306                         &file,
1307                         edl->session->labels_follow_edits,
1308                         edl->session->plugins_follow_edits,
1309                         edl->session->autos_follow_edits,
1310                         0);
1311
1312                 edl->optimize();
1313
1314
1315                 delete [] string;
1316
1317
1318
1319                 save_backup();
1320
1321
1322                 undo->update_undo_after(_("paste"), LOAD_EDITS | LOAD_TIMEBAR);
1323                 restart_brender();
1324                 update_plugin_guis();
1325                 gui->update(1, 2, 1, 1, 0, 1, 0);
1326                 gui->unlock_window();
1327
1328                 awindow->gui->lock_window("MWindow::paste");
1329                 awindow->gui->update_assets();
1330                 awindow->gui->unlock_window();
1331
1332                 gui->lock_window("MWindow::paste");
1333                 sync_parameters(CHANGE_EDL);
1334         }
1335
1336 }
1337
1338 int MWindow::paste_assets(double position, Track *dest_track)
1339 {
1340         int result = 0;
1341
1342         undo->update_undo_before();
1343
1344
1345
1346         if(session->drag_assets->total)
1347         {
1348                 load_assets(session->drag_assets,
1349                         position,
1350                         LOADMODE_PASTE,
1351                         dest_track,
1352                         0,
1353                         edl->session->labels_follow_edits,
1354                         edl->session->plugins_follow_edits,
1355                         edl->session->autos_follow_edits);
1356                 result = 1;
1357         }
1358
1359
1360         if(session->drag_clips->total)
1361         {
1362                 paste_edls(session->drag_clips,
1363                         LOADMODE_PASTE,
1364                         dest_track,
1365                         position,
1366                         edl->session->labels_follow_edits,
1367                         edl->session->plugins_follow_edits,
1368                         edl->session->autos_follow_edits);
1369                 result = 1;
1370         }
1371
1372
1373         save_backup();
1374
1375         undo->update_undo_after(_("paste assets"), LOAD_EDITS);
1376         restart_brender();
1377         gui->update(1,
1378                 2,
1379                 1,
1380                 0,
1381                 0,
1382                 1,
1383                 0);
1384         sync_parameters(CHANGE_EDL);
1385         return result;
1386 }
1387
1388 void MWindow::load_assets(ArrayList<Indexable*> *new_assets,
1389         double position,
1390         int load_mode,
1391         Track *first_track,
1392         RecordLabels *labels,
1393         int edit_labels,
1394         int edit_plugins,
1395         int edit_autos)
1396 {
1397 const int debug = 0;
1398 if(debug) printf("MWindow::load_assets %d\n", __LINE__);
1399         if(position < 0) position = edl->local_session->get_selectionstart();
1400
1401         ArrayList<EDL*> new_edls;
1402         for(int i = 0; i < new_assets->total; i++)
1403         {
1404                 Indexable *indexable = new_assets->get(i);
1405                 if(indexable->is_asset)
1406                 {
1407                         remove_asset_from_caches((Asset*)indexable);
1408                 }
1409                 EDL *new_edl = new EDL;
1410                 new_edl->create_objects();
1411                 new_edl->copy_session(edl);
1412                 new_edls.append(new_edl);
1413
1414
1415                 if(indexable->is_asset)
1416                 {
1417 if(debug) printf("MWindow::load_assets %d\n", __LINE__);
1418 if(debug) ((Asset*)indexable)->dump();
1419                         asset_to_edl(new_edl, (Asset*)indexable);
1420                 }
1421                 else
1422                         edl_to_nested(new_edl, (EDL*)indexable);
1423 if(debug) printf("MWindow::load_assets %d\n", __LINE__);
1424
1425
1426                 if(labels)
1427                 {
1428                         for(RecordLabel *label = labels->first; label; label = label->next)
1429                         {
1430                                 new_edl->labels->toggle_label(label->position, label->position);
1431                         }
1432                 }
1433         }
1434 if(debug) printf("MWindow::load_assets %d\n", __LINE__);
1435
1436         paste_edls(&new_edls,
1437                 load_mode,
1438                 first_track,
1439                 position,
1440                 edit_labels,
1441                 edit_plugins,
1442                 edit_autos);
1443 if(debug) printf("MWindow::load_assets %d\n", __LINE__);
1444
1445
1446         save_backup();
1447         for(int i = 0; i < new_edls.size(); i++)
1448                 new_edls.get(i)->Garbage::remove_user();
1449
1450 if(debug) printf("MWindow::load_assets %d\n", __LINE__);
1451 }
1452
1453 int MWindow::paste_automation()
1454 {
1455         int64_t len = gui->get_clipboard()->clipboard_len(SECONDARY_SELECTION);
1456
1457         if(len)
1458         {
1459                 undo->update_undo_before();
1460                 char *string = new char[len + 1];
1461                 gui->get_clipboard()->from_clipboard(string,
1462                         len,
1463                         BC_PRIMARY_SELECTION);
1464                 FileXML file;
1465                 file.read_from_string(string);
1466
1467                 edl->tracks->clear_automation(edl->local_session->get_selectionstart(),
1468                         edl->local_session->get_selectionend());
1469                 edl->tracks->paste_automation(edl->local_session->get_selectionstart(),
1470                         &file,
1471                         0,
1472                         1,
1473                         edl->session->typeless_keyframes);
1474                 save_backup();
1475                 undo->update_undo_after(_("paste keyframes"), LOAD_AUTOMATION);
1476                 delete [] string;
1477
1478
1479                 restart_brender();
1480                 update_plugin_guis();
1481                 gui->draw_overlays(1);
1482                 sync_parameters(CHANGE_PARAMS);
1483                 gui->update_patchbay();
1484                 cwindow->update(1, 0, 0);
1485         }
1486
1487         return 0;
1488 }
1489
1490 int MWindow::paste_default_keyframe()
1491 {
1492         int64_t len = gui->get_clipboard()->clipboard_len(SECONDARY_SELECTION);
1493
1494         if(len)
1495         {
1496                 undo->update_undo_before();
1497                 char *string = new char[len + 1];
1498                 gui->get_clipboard()->from_clipboard(string,
1499                         len,
1500                         BC_PRIMARY_SELECTION);
1501                 FileXML file;
1502                 file.read_from_string(string);
1503                 edl->tracks->paste_automation(edl->local_session->get_selectionstart(),
1504                         &file,
1505                         1,
1506                         0,
1507                         edl->session->typeless_keyframes);
1508 //              edl->tracks->paste_default_keyframe(&file);
1509                 undo->update_undo_after(_("paste default keyframe"), LOAD_AUTOMATION);
1510
1511
1512                 restart_brender();
1513                 update_plugin_guis();
1514                 gui->draw_overlays(1);
1515                 sync_parameters(CHANGE_PARAMS);
1516                 gui->update_patchbay();
1517                 cwindow->update(1, 0, 0);
1518                 delete [] string;
1519                 save_backup();
1520         }
1521
1522         return 0;
1523 }
1524
1525
1526 // Insert edls with project deletion and index file generation.
1527 int MWindow::paste_edls(ArrayList<EDL*> *new_edls,
1528         int load_mode,
1529         Track *first_track,
1530         double current_position,
1531         int edit_labels,
1532         int edit_plugins,
1533         int edit_autos)
1534 {
1535
1536         ArrayList<Track*> destination_tracks;
1537         int need_new_tracks = 0;
1538
1539 //PRINT_TRACE
1540         if(!new_edls->total) return 0;
1541
1542 //PRINT_TRACE
1543 //      double original_length = edl->tracks->total_playable_length();
1544 //      double original_preview_end = edl->local_session->preview_end;
1545 //PRINT_TRACE
1546
1547 // Delete current project
1548         if(load_mode == LOADMODE_REPLACE ||
1549                 load_mode == LOADMODE_REPLACE_CONCATENATE)
1550         {
1551                 reset_caches();
1552
1553                 edl->save_defaults(defaults);
1554
1555                 hide_plugins();
1556
1557                 edl->Garbage::remove_user();
1558
1559                 edl = new EDL;
1560
1561                 edl->create_objects();
1562
1563                 edl->copy_session(new_edls->values[0]);
1564
1565                 gui->mainmenu->update_toggles(0);
1566
1567
1568                 gui->unlock_window();
1569
1570                 gwindow->gui->update_toggles(1);
1571
1572                 gui->lock_window("MWindow::paste_edls");
1573
1574
1575 // Insert labels for certain modes constitutively
1576                 edit_labels = 1;
1577                 edit_plugins = 1;
1578                 edit_autos = 1;
1579 // Force reset of preview
1580 //              original_length = 0;
1581 //              original_preview_end = -1;
1582         }
1583
1584
1585 //PRINT_TRACE
1586
1587 // Create new tracks in master EDL
1588         if(load_mode == LOADMODE_REPLACE ||
1589                 load_mode == LOADMODE_REPLACE_CONCATENATE ||
1590                 load_mode == LOADMODE_NEW_TRACKS)
1591         {
1592
1593                 need_new_tracks = 1;
1594                 for(int i = 0; i < new_edls->total; i++)
1595                 {
1596                         EDL *new_edl = new_edls->values[i];
1597                         for(Track *current = new_edl->tracks->first;
1598                                 current;
1599                                 current = NEXT)
1600                         {
1601                                 if(current->data_type == TRACK_VIDEO)
1602                                 {
1603                                         edl->tracks->add_video_track(0, 0);
1604                                         if(current->draw) edl->tracks->last->draw = 1;
1605                                         destination_tracks.append(edl->tracks->last);
1606                                 }
1607                                 else
1608                                 if(current->data_type == TRACK_AUDIO)
1609                                 {
1610                                         edl->tracks->add_audio_track(0, 0);
1611                                         destination_tracks.append(edl->tracks->last);
1612                                 }
1613                                 else
1614                                 if(current->data_type == TRACK_SUBTITLE)
1615                                 {
1616                                         edl->tracks->add_subttl_track(0, 0);
1617                                         destination_tracks.append(edl->tracks->last);
1618                                 }
1619                                 edl->session->highlighted_track = edl->tracks->total() - 1;
1620                         }
1621
1622 // Base track count on first EDL only for concatenation
1623                         if(load_mode == LOADMODE_REPLACE_CONCATENATE) break;
1624                 }
1625
1626         }
1627         else
1628 // Recycle existing tracks of master EDL
1629         if(load_mode == LOADMODE_CONCATENATE ||
1630                 load_mode == LOADMODE_PASTE ||
1631                 load_mode == LOADMODE_NESTED)
1632         {
1633 //PRINT_TRACE
1634
1635 // The point of this is to shift forward labels after the selection so they can
1636 // then be shifted back to their original locations without recursively
1637 // shifting back every paste.
1638                 if((load_mode == LOADMODE_PASTE ||
1639                         load_mode == LOADMODE_NESTED) &&
1640                         edl->session->labels_follow_edits)
1641                         edl->labels->clear(edl->local_session->get_selectionstart(),
1642                                                 edl->local_session->get_selectionend(),
1643                                                 1);
1644
1645                 Track *current = first_track ? first_track : edl->tracks->first;
1646                 for( ; current; current = NEXT)
1647                 {
1648                         if(current->record)
1649                         {
1650                                 destination_tracks.append(current);
1651                         }
1652                 }
1653 //PRINT_TRACE
1654
1655         }
1656 //PRINT_TRACE
1657
1658
1659
1660
1661         int destination_track = 0;
1662         double *paste_position = new double[destination_tracks.total];
1663
1664
1665
1666
1667
1668 // Iterate through the edls
1669         for(int i = 0; i < new_edls->total; i++)
1670         {
1671
1672                 EDL *new_edl = new_edls->values[i];
1673                 double edl_length = new_edl->local_session->clipboard_length ?
1674                         new_edl->local_session->clipboard_length :
1675                         new_edl->tracks->total_length();
1676 // printf("MWindow::paste_edls 2 %f %f\n",
1677 // new_edl->local_session->clipboard_length,
1678 // new_edl->tracks->total_length());
1679 // new_edl->dump();
1680
1681
1682
1683 //PRINT_TRACE
1684
1685 // Convert EDL to master rates
1686                 new_edl->resample(new_edl->session->sample_rate,
1687                         edl->session->sample_rate,
1688                         TRACK_AUDIO);
1689                 new_edl->resample(new_edl->session->frame_rate,
1690                         edl->session->frame_rate,
1691                         TRACK_VIDEO);
1692 //PRINT_TRACE
1693
1694
1695
1696
1697 // Add assets and prepare index files
1698                 for(Asset *new_asset = new_edl->assets->first;
1699                         new_asset;
1700                         new_asset = new_asset->next)
1701                 {
1702                         mainindexes->add_next_asset(0, new_asset);
1703                 }
1704 // Capture index file status from mainindex test
1705                 edl->update_assets(new_edl);
1706 //PRINT_TRACE
1707
1708
1709
1710 // Get starting point of insertion.  Need this to paste labels.
1711                 switch(load_mode)
1712                 {
1713                         case LOADMODE_REPLACE:
1714                         case LOADMODE_NEW_TRACKS:
1715                                 current_position = 0;
1716                                 break;
1717
1718                         case LOADMODE_CONCATENATE:
1719                         case LOADMODE_REPLACE_CONCATENATE:
1720                                 destination_track = 0;
1721                                 if(destination_tracks.total)
1722                                         current_position = destination_tracks.values[0]->get_length();
1723                                 else
1724                                         current_position = 0;
1725                                 break;
1726
1727                         case LOADMODE_PASTE:
1728                         case LOADMODE_NESTED:
1729                                 destination_track = 0;
1730                                 if(i == 0)
1731                                 {
1732                                         for(int j = 0; j < destination_tracks.total; j++)
1733                                         {
1734                                                 paste_position[j] = (current_position >= 0) ?
1735                                                         current_position :
1736                                                         edl->local_session->get_selectionstart();
1737                                         }
1738                                 }
1739                                 break;
1740
1741                         case LOADMODE_RESOURCESONLY:
1742                                 edl->add_clip(new_edl);
1743                                 break;
1744                 }
1745
1746
1747
1748 //PRINT_TRACE
1749
1750
1751 // Insert edl
1752                 if(load_mode != LOADMODE_RESOURCESONLY)
1753                 {
1754 // Insert labels
1755 //printf("MWindow::paste_edls %f %f\n", current_position, edl_length);
1756                         if(load_mode == LOADMODE_PASTE ||
1757                                 load_mode == LOADMODE_NESTED)
1758                                 edl->labels->insert_labels(new_edl->labels,
1759                                         destination_tracks.total ? paste_position[0] : 0.0,
1760                                         edl_length,
1761                                         edit_labels);
1762                         else
1763                                 edl->labels->insert_labels(new_edl->labels,
1764                                         current_position,
1765                                         edl_length,
1766                                         edit_labels);
1767 //PRINT_TRACE
1768
1769                         for(Track *new_track = new_edl->tracks->first;
1770                                 new_track;
1771                                 new_track = new_track->next)
1772                         {
1773 // Get destination track of same type as new_track
1774                                 for(int k = 0;
1775                                         k < destination_tracks.total &&
1776                                         destination_tracks.values[destination_track]->data_type != new_track->data_type;
1777                                         k++, destination_track++)
1778                                 {
1779                                         if(destination_track >= destination_tracks.total - 1)
1780                                                 destination_track = 0;
1781                                 }
1782
1783 // Insert data into destination track
1784                                 if(destination_track < destination_tracks.total &&
1785                                         destination_tracks.values[destination_track]->data_type == new_track->data_type)
1786                                 {
1787                                         Track *track = destination_tracks.values[destination_track];
1788
1789 // Replace default keyframes if first EDL and new tracks were created.
1790 // This means data copied from one track and pasted to another won't retain
1791 // the camera position unless it's a keyframe.  If it did, previous data in the
1792 // track might get unknowingly corrupted.  Ideally we would detect when differing
1793 // default keyframes existed and create discrete keyframes for both.
1794                                         int replace_default = (i == 0) && need_new_tracks;
1795
1796 //printf("MWindow::paste_edls 1 %d\n", replace_default);
1797 // Insert new track at current position
1798                                         switch(load_mode)
1799                                         {
1800                                                 case LOADMODE_REPLACE_CONCATENATE:
1801                                                 case LOADMODE_CONCATENATE:
1802                                                         current_position = track->get_length();
1803                                                         break;
1804
1805                                                 case LOADMODE_PASTE:
1806                                                 case LOADMODE_NESTED:
1807                                                         current_position = paste_position[destination_track];
1808                                                         paste_position[destination_track] += new_track->get_length();
1809                                                         break;
1810                                         }
1811
1812 //PRINT_TRACE
1813                                         track->insert_track(new_track,
1814                                                 current_position,
1815                                                 replace_default,
1816                                                 edit_plugins,
1817                                                 edit_autos,
1818                                                 edl_length);
1819 //PRINT_TRACE
1820                                 }
1821
1822 // Get next destination track
1823                                 destination_track++;
1824                                 if(destination_track >= destination_tracks.total)
1825                                         destination_track = 0;
1826                         }
1827                 }
1828
1829                 if(load_mode == LOADMODE_PASTE ||
1830                         load_mode == LOADMODE_NESTED)
1831                         current_position += edl_length;
1832         }
1833
1834
1835 // Move loading of clips and vwindow to the end - this fixes some
1836 // strange issue, for index not being shown
1837 // Assume any paste operation from the same EDL won't contain any clips.
1838 // If it did it would duplicate every clip here.
1839         for(int i = 0; i < new_edls->total; i++)
1840         {
1841                 EDL *new_edl = new_edls->values[i];
1842
1843                 for(int j = 0; j < new_edl->clips.total; j++)
1844                 {
1845                         edl->add_clip(new_edl->clips.values[j]);
1846                 }
1847
1848                 if(new_edl->total_vwindow_edls())
1849                 {
1850 //                      if(edl->vwindow_edl)
1851 //                              edl->vwindow_edl->Garbage::remove_user();
1852 //                      edl->vwindow_edl = new EDL(edl);
1853 //                      edl->vwindow_edl->create_objects();
1854 //                      edl->vwindow_edl->copy_all(new_edl->vwindow_edl);
1855
1856                         for(int j = 0; j < new_edl->total_vwindow_edls(); j++)
1857                         {
1858                                 EDL *vwindow_edl = new EDL(edl);
1859                                 vwindow_edl->create_objects();
1860                                 vwindow_edl->copy_all(new_edl->get_vwindow_edl(j));
1861                                 edl->append_vwindow_edl(vwindow_edl, 0);
1862                         }
1863                 }
1864         }
1865
1866
1867         if(paste_position) delete [] paste_position;
1868
1869
1870 // This is already done in load_filenames and everything else that uses paste_edls
1871 //      update_project(load_mode);
1872
1873 // Fix preview range
1874 //      if(EQUIV(original_length, original_preview_end))
1875 //      {
1876 //              edl->local_session->preview_end = edl->tracks->total_playable_length();
1877 //      }
1878
1879
1880 // Start examining next batch of index files
1881         mainindexes->start_build();
1882
1883
1884 // Don't save a backup after loading since the loaded file is on disk already.
1885
1886
1887 //PRINT_TRACE
1888         return 0;
1889 }
1890
1891 void MWindow::paste_silence()
1892 {
1893         double start = edl->local_session->get_selectionstart();
1894         double end = edl->local_session->get_selectionend();
1895         undo->update_undo_before();
1896         edl->paste_silence(start,
1897                 end,
1898                 edl->session->labels_follow_edits,
1899                 edl->session->plugins_follow_edits,
1900                 edl->session->autos_follow_edits);
1901         edl->optimize();
1902         save_backup();
1903         undo->update_undo_after(_("silence"), LOAD_EDITS | LOAD_TIMEBAR);
1904
1905         update_plugin_guis();
1906         restart_brender();
1907         gui->update(1, 2, 1, 1, 1, 1, 0);
1908         cwindow->update(1, 0, 0, 0, 1);
1909         cwindow->playback_engine->que->send_command(CURRENT_FRAME,
1910                                                         CHANGE_EDL,
1911                                                         edl,
1912                                                         1);
1913 }
1914
1915 void MWindow::detach_transition(Transition *transition)
1916 {
1917         undo->update_undo_before();
1918         hide_plugin(transition, 1);
1919         int is_video = (transition->edit->track->data_type == TRACK_VIDEO);
1920         transition->edit->detach_transition();
1921         save_backup();
1922         undo->update_undo_after(_("detach transition"), LOAD_ALL);
1923
1924         if(is_video) restart_brender();
1925         gui->update(0,
1926                 1,
1927                 0,
1928                 0,
1929                 0,
1930                 0,
1931                 0);
1932         sync_parameters(CHANGE_EDL);
1933 }
1934
1935 void MWindow::detach_transitions()
1936 {
1937         gui->lock_window("MWindow::detach_transitions 1");
1938
1939         undo->update_undo_before();
1940         double start = edl->local_session->get_selectionstart();
1941         double end = edl->local_session->get_selectionend();
1942         edl->tracks->clear_transitions(start, end);
1943
1944         save_backup();
1945         undo->update_undo_after(_("detach transitions"), LOAD_EDITS);
1946
1947         sync_parameters(CHANGE_EDL);
1948         gui->update(0, 1, 0, 0, 0, 0, 0);
1949         gui->unlock_window();
1950 }
1951
1952 void MWindow::paste_transition()
1953 {
1954 // Only the first transition gets dropped.
1955         PluginServer *server = session->drag_pluginservers->values[0];
1956
1957         undo->update_undo_before();
1958         if(server->audio)
1959                 strcpy(edl->session->default_atransition, server->title);
1960         else
1961                 strcpy(edl->session->default_vtransition, server->title);
1962
1963         edl->tracks->paste_transition(server, session->edit_highlighted);
1964         save_backup();
1965         undo->update_undo_after(_("transition"), LOAD_EDITS);
1966
1967         if(server->video) restart_brender();
1968         sync_parameters(CHANGE_ALL);
1969 }
1970
1971 void MWindow::paste_transitions(int track_type, char *title)
1972 {
1973         gui->lock_window("MWindow::detach_transitions 1");
1974
1975         undo->update_undo_before();
1976         double start = edl->local_session->get_selectionstart();
1977         double end = edl->local_session->get_selectionend();
1978         edl->tracks->paste_transitions(start, end, track_type, title);
1979
1980         save_backup();
1981         undo->update_undo_after(_("attach transitions"), LOAD_EDITS);
1982
1983         sync_parameters(CHANGE_EDL);
1984         gui->update(0, 1, 0, 0, 0, 0, 0);
1985         gui->unlock_window();
1986 }
1987
1988 void MWindow::paste_transition_cwindow(Track *dest_track)
1989 {
1990         PluginServer *server = session->drag_pluginservers->values[0];
1991         undo->update_undo_before();
1992         edl->tracks->paste_video_transition(server, 1);
1993         save_backup();
1994         undo->update_undo_after(_("transition"), LOAD_EDITS);
1995         restart_brender();
1996         gui->update(0, 1, 0, 0, 0, 0, 0);
1997         sync_parameters(CHANGE_ALL);
1998 }
1999
2000 void MWindow::paste_audio_transition()
2001 {
2002         PluginServer *server = scan_plugindb(edl->session->default_atransition,
2003                 TRACK_AUDIO);
2004         if(!server)
2005         {
2006                 char string[BCTEXTLEN];
2007                 sprintf(string, _("No default transition %s found."), edl->session->default_atransition);
2008                 gui->show_message(string);
2009                 return;
2010         }
2011
2012         undo->update_undo_before();
2013         edl->tracks->paste_audio_transition(server);
2014         save_backup();
2015         undo->update_undo_after(_("transition"), LOAD_EDITS);
2016
2017         sync_parameters(CHANGE_EDL);
2018         gui->update(0, 1, 0, 0, 0, 0, 0);
2019 }
2020
2021 void MWindow::paste_video_transition()
2022 {
2023         PluginServer *server = scan_plugindb(edl->session->default_vtransition,
2024                 TRACK_VIDEO);
2025         if(!server)
2026         {
2027                 char string[BCTEXTLEN];
2028                 sprintf(string, _("No default transition %s found."), edl->session->default_vtransition);
2029                 gui->show_message(string);
2030                 return;
2031         }
2032
2033         undo->update_undo_before();
2034
2035         edl->tracks->paste_video_transition(server);
2036         save_backup();
2037         undo->update_undo_after(_("transition"), LOAD_EDITS);
2038
2039         sync_parameters(CHANGE_EDL);
2040         restart_brender();
2041         gui->update(0, 1, 0, 0, 0, 0, 0);
2042 }
2043
2044 void MWindow::shuffle_edits()
2045 {
2046         gui->lock_window("MWindow::shuffle_edits 1");
2047
2048         undo->update_undo_before();
2049         double start = edl->local_session->get_selectionstart();
2050         double end = edl->local_session->get_selectionend();
2051
2052         edl->tracks->shuffle_edits(start, end);
2053
2054         save_backup();
2055         undo->update_undo_after(_("shuffle edits"), LOAD_EDITS | LOAD_TIMEBAR);
2056
2057         sync_parameters(CHANGE_EDL);
2058         restart_brender();
2059         gui->update(0, 1, 1, 0, 0, 0, 0);
2060         gui->unlock_window();
2061 }
2062
2063 void MWindow::align_edits()
2064 {
2065         gui->lock_window("MWindow::align_edits 1");
2066
2067         undo->update_undo_before();
2068         double start = edl->local_session->get_selectionstart();
2069         double end = edl->local_session->get_selectionend();
2070
2071         edl->tracks->align_edits(start, end);
2072
2073         save_backup();
2074         undo->update_undo_after(_("align edits"), LOAD_EDITS | LOAD_TIMEBAR);
2075
2076         sync_parameters(CHANGE_EDL);
2077         restart_brender();
2078         gui->update(0, 1, 1, 0, 0, 0, 0);
2079         gui->unlock_window();
2080 }
2081
2082 void MWindow::set_edit_length(double length)
2083 {
2084         gui->lock_window("MWindow::detach_transitions 1");
2085
2086         undo->update_undo_before();
2087         double start = edl->local_session->get_selectionstart();
2088         double end = edl->local_session->get_selectionend();
2089
2090         edl->tracks->set_edit_length(start, end, length);
2091
2092         save_backup();
2093         undo->update_undo_after(_("edit length"), LOAD_EDITS | LOAD_TIMEBAR);
2094
2095         sync_parameters(CHANGE_EDL);
2096         restart_brender();
2097         gui->update(0, 1, 1, 0, 0, 0, 0);
2098         gui->unlock_window();
2099 }
2100
2101
2102 void MWindow::set_transition_length(Transition *transition, double length)
2103 {
2104         gui->lock_window("MWindow::detach_transitions 1");
2105
2106         undo->update_undo_before();
2107         //double start = edl->local_session->get_selectionstart();
2108         //double end = edl->local_session->get_selectionend();
2109
2110         edl->tracks->set_transition_length(transition, length);
2111
2112         save_backup();
2113         undo->update_undo_after(_("transition length"), LOAD_EDITS);
2114
2115         edl->session->default_transition_length = length;
2116         sync_parameters(CHANGE_PARAMS);
2117         gui->update(0, 1, 0, 0, 0, 0, 0);
2118         gui->unlock_window();
2119 }
2120
2121 void MWindow::set_transition_length(double length)
2122 {
2123         gui->lock_window("MWindow::detach_transitions 1");
2124
2125         undo->update_undo_before();
2126         double start = edl->local_session->get_selectionstart();
2127         double end = edl->local_session->get_selectionend();
2128
2129         edl->tracks->set_transition_length(start, end, length);
2130
2131         save_backup();
2132         undo->update_undo_after(_("transition length"), LOAD_EDITS);
2133
2134         edl->session->default_transition_length = length;
2135         sync_parameters(CHANGE_PARAMS);
2136         restart_brender();
2137         gui->update(0, 1, 0, 0, 0, 0, 0);
2138         gui->unlock_window();
2139 }
2140
2141
2142 void MWindow::redo_entry(BC_WindowBase *calling_window_gui)
2143 {
2144
2145         calling_window_gui->unlock_window();
2146
2147         cwindow->playback_engine->que->send_command(STOP,
2148                 CHANGE_NONE,
2149                 0,
2150                 0);
2151         cwindow->playback_engine->interrupt_playback(0);
2152
2153         for(int i = 0; i < vwindows.size(); i++)
2154         {
2155                 vwindows.get(i)->playback_engine->que->send_command(STOP,
2156                         CHANGE_NONE,
2157                         0,
2158                         0);
2159                 vwindows.get(i)->playback_engine->interrupt_playback(0);
2160         }
2161
2162         cwindow->gui->lock_window("MWindow::redo_entry");
2163         for(int i = 0; i < vwindows.size(); i++)
2164         {
2165                 vwindows.get(i)->gui->lock_window("MWindow::redo_entry 2");
2166         }
2167         gui->lock_window();
2168
2169         undo->redo();
2170
2171         save_backup();
2172         update_plugin_states();
2173         update_plugin_guis();
2174         restart_brender();
2175         gui->update(1, 2, 1, 1, 1, 1, 1);
2176         cwindow->update(1, 1, 1, 1, 1);
2177
2178         if (calling_window_gui != cwindow->gui)
2179                 cwindow->gui->unlock_window();
2180         if (calling_window_gui != gui)
2181                 gui->unlock_window();
2182
2183
2184         for(int i = 0; i < vwindows.size(); i++)
2185         {
2186                 if (calling_window_gui != vwindows.get(i)->gui)
2187                         vwindows.get(i)->gui->unlock_window();
2188         }
2189
2190         cwindow->playback_engine->que->send_command(CURRENT_FRAME,
2191                            CHANGE_ALL,
2192                            edl,
2193                            1);
2194
2195 }
2196
2197
2198 void MWindow::resize_track(Track *track, int w, int h)
2199 {
2200         undo->update_undo_before();
2201 // We have to move all maskpoints so they do not move in relation to image areas
2202         ((MaskAutos*)track->automation->autos[AUTOMATION_MASK])->translate_masks(
2203                 (w - track->track_w) / 2,
2204                 (h - track->track_h) / 2);
2205         track->track_w = w;
2206         track->track_h = h;
2207         undo->update_undo_after(_("resize track"), LOAD_ALL);
2208         save_backup();
2209
2210         restart_brender();
2211         sync_parameters(CHANGE_EDL);
2212 }
2213
2214
2215 void MWindow::set_inpoint(int is_mwindow)
2216 {
2217         undo->update_undo_before();
2218         edl->set_inpoint(edl->local_session->get_selectionstart(1));
2219         save_backup();
2220         undo->update_undo_after(_("in point"), LOAD_TIMEBAR);
2221
2222
2223         if(!is_mwindow)
2224         {
2225                 gui->lock_window("MWindow::set_inpoint 1");
2226         }
2227         gui->update_timebar(1);
2228         if(!is_mwindow)
2229         {
2230                 gui->unlock_window();
2231         }
2232
2233         if(is_mwindow)
2234         {
2235                 cwindow->gui->lock_window("MWindow::set_inpoint 2");
2236         }
2237         cwindow->gui->timebar->update(1);
2238         if(is_mwindow)
2239         {
2240                 cwindow->gui->unlock_window();
2241         }
2242 }
2243
2244 void MWindow::set_outpoint(int is_mwindow)
2245 {
2246         undo->update_undo_before();
2247         edl->set_outpoint(edl->local_session->get_selectionend(1));
2248         save_backup();
2249         undo->update_undo_after(_("out point"), LOAD_TIMEBAR);
2250
2251
2252         if(!is_mwindow)
2253         {
2254                 gui->lock_window("MWindow::set_outpoint 1");
2255         }
2256         gui->update_timebar(1);
2257         if(!is_mwindow)
2258         {
2259                 gui->unlock_window();
2260         }
2261
2262         if(is_mwindow)
2263         {
2264                 cwindow->gui->lock_window("MWindow::set_outpoint 2");
2265         }
2266         cwindow->gui->timebar->update(1);
2267         if(is_mwindow)
2268         {
2269                 cwindow->gui->unlock_window();
2270         }
2271 }
2272
2273 void MWindow::splice(EDL *source)
2274 {
2275         FileXML file;
2276
2277         undo->update_undo_before();
2278         source->copy(source->local_session->get_selectionstart(),
2279                 source->local_session->get_selectionend(),
2280                 1,
2281                 0,
2282                 0,
2283                 &file,
2284                 "",
2285                 1);
2286
2287
2288
2289 //file.dump();
2290         double start = edl->local_session->get_selectionstart();
2291         //double end = edl->local_session->get_selectionend();
2292         double source_start = source->local_session->get_selectionstart();
2293         double source_end = source->local_session->get_selectionend();
2294
2295         paste(start,
2296                 start,
2297                 &file,
2298                 edl->session->labels_follow_edits,
2299                 edl->session->plugins_follow_edits,
2300                 edl->session->autos_follow_edits);
2301
2302 // Position at end of clip
2303         edl->local_session->set_selectionstart(start +
2304                 source_end -
2305                 source_start);
2306         edl->local_session->set_selectionend(start +
2307                 source_end -
2308                 source_start);
2309
2310         save_backup();
2311         undo->update_undo_after(_("splice"), LOAD_EDITS | LOAD_TIMEBAR);
2312         update_plugin_guis();
2313         restart_brender();
2314         gui->update(1, 1, 1, 1, 0, 1, 0);
2315         sync_parameters(CHANGE_EDL);
2316 }
2317
2318 void MWindow::to_clip()
2319 {
2320         FileXML file;
2321         double start, end;
2322
2323         gui->lock_window("MWindow::to_clip 1");
2324         start = edl->local_session->get_selectionstart();
2325         end = edl->local_session->get_selectionend();
2326
2327         if(EQUIV(end, start))
2328         {
2329                 start = 0;
2330                 end = edl->tracks->total_length();
2331         }
2332
2333 // Don't copy all since we don't want the clips twice.
2334         edl->copy(start,
2335                 end,
2336                 0,
2337                 0,
2338                 0,
2339                 &file,
2340                 "",
2341                 1);
2342
2343
2344         EDL *new_edl = new EDL(edl);
2345         new_edl->create_objects();
2346         new_edl->load_xml(&file, LOAD_ALL);
2347         sprintf(new_edl->local_session->clip_title, _("Clip %d"), session->clip_number++);
2348         new_edl->local_session->set_selectionstart(0);
2349         new_edl->local_session->set_selectionend(0);
2350
2351         gui->unlock_window();
2352
2353         awindow->clip_edit->create_clip(new_edl);
2354
2355         gui->lock_window("MWindow::to_clip 2");
2356         save_backup();
2357         gui->unlock_window();
2358 }
2359
2360
2361
2362
2363 int MWindow::toggle_label(int is_mwindow)
2364 {
2365         double position1, position2;
2366         undo->update_undo_before();
2367
2368         if(cwindow->playback_engine->is_playing_back)
2369         {
2370                 position1 = position2 =
2371                         cwindow->playback_engine->get_tracking_position();
2372         }
2373         else
2374         {
2375                 position1 = edl->local_session->get_selectionstart(1);
2376                 position2 = edl->local_session->get_selectionend(1);
2377         }
2378
2379         position1 = edl->align_to_frame(position1, 0);
2380         position2 = edl->align_to_frame(position2, 0);
2381
2382         edl->labels->toggle_label(position1, position2);
2383         save_backup();
2384
2385         if(!is_mwindow)
2386         {
2387                 gui->lock_window("MWindow::toggle_label 1");
2388         }
2389         gui->update_timebar(0);
2390         gui->activate_timeline();
2391         gui->flush();
2392         if(!is_mwindow)
2393         {
2394                 gui->unlock_window();
2395         }
2396
2397         if(is_mwindow)
2398         {
2399                 cwindow->gui->lock_window("MWindow::toggle_label 2");
2400         }
2401         cwindow->gui->timebar->update(1);
2402         if(is_mwindow)
2403         {
2404                 cwindow->gui->unlock_window();
2405         }
2406
2407         undo->update_undo_after(_("label"), LOAD_TIMEBAR);
2408         return 0;
2409 }
2410
2411 void MWindow::trim_selection()
2412 {
2413         undo->update_undo_before();
2414
2415
2416         edl->trim_selection(edl->local_session->get_selectionstart(),
2417                 edl->local_session->get_selectionend(),
2418                 edl->session->labels_follow_edits,
2419                 edl->session->plugins_follow_edits,
2420                 edl->session->autos_follow_edits);
2421
2422         save_backup();
2423         undo->update_undo_after(_("trim selection"), LOAD_EDITS | LOAD_TIMEBAR);
2424         update_plugin_guis();
2425         gui->update(1, 2, 1, 1, 1, 1, 0);
2426         cwindow->update(1, 0, 0, 0, 1);
2427         restart_brender();
2428         cwindow->playback_engine->que->send_command(CURRENT_FRAME,
2429                                                         CHANGE_EDL,
2430                                                         edl,
2431                                                         1);
2432 }
2433
2434
2435
2436 void MWindow::undo_entry(BC_WindowBase *calling_window_gui)
2437 {
2438         calling_window_gui->unlock_window();
2439
2440         cwindow->playback_engine->que->send_command(STOP,
2441                 CHANGE_NONE,
2442                 0,
2443                 0);
2444         cwindow->playback_engine->interrupt_playback(0);
2445
2446
2447         for(int i = 0; i < vwindows.size(); i++)
2448         {
2449                 vwindows.get(i)->playback_engine->que->send_command(STOP,
2450                         CHANGE_NONE,
2451                         0,
2452                         0);
2453                 vwindows.get(i)->playback_engine->interrupt_playback(0);
2454         }
2455
2456         cwindow->gui->lock_window("MWindow::undo_entry 1");
2457         for(int i = 0; i < vwindows.size(); i++)
2458         {
2459                 vwindows.get(i)->gui->lock_window("MWindow::undo_entry 4");
2460         }
2461         gui->lock_window("MWindow::undo_entry 2");
2462
2463         undo->undo();
2464
2465         save_backup();
2466         restart_brender();
2467         update_plugin_states();
2468         update_plugin_guis();
2469
2470
2471
2472         gui->update(1, 2, 1, 1, 1, 1, 1);
2473
2474         gui->unlock_window();
2475
2476         cwindow->update(1, 1, 1, 1, 1);
2477
2478         cwindow->gui->unlock_window();
2479
2480         for(int i = 0; i < vwindows.size(); i++)
2481         {
2482                 if (calling_window_gui != vwindows.get(i)->gui)
2483                         vwindows.get(i)->gui->unlock_window();
2484         }
2485
2486         if (calling_window_gui != gui)
2487                 gui->unlock_window();
2488
2489
2490         awindow->gui->lock_window("MWindow::undo_entry 3");
2491         awindow->gui->update_assets();
2492         awindow->gui->flush();
2493         awindow->gui->unlock_window();
2494
2495         cwindow->playback_engine->que->send_command(CURRENT_FRAME,
2496                            CHANGE_ALL,
2497                            edl,
2498                            1);
2499         calling_window_gui->lock_window("MWindow::undo_entry 4");
2500 }
2501
2502
2503
2504 void MWindow::new_folder(const char *new_folder)
2505 {
2506         undo->update_undo_before();
2507         edl->new_folder(new_folder);
2508         undo->update_undo_after(_("new folder"), LOAD_ALL);
2509         awindow->gui->lock_window("MWindow::new_folder");
2510         awindow->gui->update_assets();
2511         awindow->gui->unlock_window();
2512 }
2513
2514 void MWindow::delete_folder(char *folder)
2515 {
2516 //      undo->update_undo_after(_("delete folder"), LOAD_ALL);
2517 }
2518
2519 void MWindow::select_point(double position)
2520 {
2521         edl->local_session->set_selectionstart(position);
2522         edl->local_session->set_selectionend(position);
2523
2524 // Que the CWindow
2525         cwindow->update(1, 0, 0, 0, 1);
2526
2527
2528         update_plugin_guis();
2529         gui->update_patchbay();
2530         gui->hide_cursor(0);
2531         gui->draw_cursor(0);
2532         gui->mainclock->update(edl->local_session->get_selectionstart(1));
2533         gui->zoombar->update();
2534         gui->update_timebar(0);
2535         gui->flash_canvas(0);
2536         gui->flush();
2537 }
2538
2539
2540
2541
2542 void MWindow::map_audio(int pattern)
2543 {
2544         undo->update_undo_before();
2545         remap_audio(pattern);
2546         undo->update_undo_after(_("map 1:1"), LOAD_AUTOMATION);
2547         sync_parameters(CHANGE_PARAMS);
2548         gui->update(0,
2549                 1,
2550                 0,
2551                 0,
2552                 1,
2553                 0,
2554                 0);
2555 }
2556
2557 void MWindow::remap_audio(int pattern)
2558 {
2559         int current_channel = 0;
2560         int current_track = 0;
2561         for(Track *current = edl->tracks->first; current; current = NEXT)
2562         {
2563                 if(current->data_type == TRACK_AUDIO &&
2564                         current->record)
2565                 {
2566                         Autos *pan_autos = current->automation->autos[AUTOMATION_PAN];
2567                         PanAuto *pan_auto = (PanAuto*)pan_autos->get_auto_for_editing(-1);
2568
2569                         for(int i = 0; i < MAXCHANNELS; i++)
2570                         {
2571                                 pan_auto->values[i] = 0.0;
2572                         }
2573
2574                         if(pattern == MWindow::AUDIO_1_TO_1)
2575                         {
2576                                 pan_auto->values[current_channel] = 1.0;
2577                         }
2578                         else
2579                         if(pattern == MWindow::AUDIO_5_1_TO_2)
2580                         {
2581                                 switch(current_track)
2582                                 {
2583                                         case 0:
2584                                                 pan_auto->values[0] = 0.5;
2585                                                 pan_auto->values[1] = 0.5;
2586                                                 break;
2587                                         case 1:
2588                                                 pan_auto->values[0] = 1;
2589                                                 break;
2590                                         case 2:
2591                                                 pan_auto->values[1] = 1;
2592                                                 break;
2593                                         case 3:
2594                                                 pan_auto->values[0] = 1;
2595                                                 break;
2596                                         case 4:
2597                                                 pan_auto->values[1] = 1;
2598                                                 break;
2599                                         case 5:
2600                                                 pan_auto->values[0] = 0.5;
2601                                                 pan_auto->values[1] = 0.5;
2602                                                 break;
2603                                 }
2604                         }
2605
2606                         BC_Pan::calculate_stick_position(edl->session->audio_channels,
2607                                 edl->session->achannel_positions,
2608                                 pan_auto->values,
2609                                 MAX_PAN,
2610                                 PAN_RADIUS,
2611                                 pan_auto->handle_x,
2612                                 pan_auto->handle_y);
2613
2614                         current_channel++;
2615                         current_track++;
2616                         if(current_channel >= edl->session->audio_channels)
2617                                 current_channel = 0;
2618                 }
2619         }
2620 }
2621
2622 void MWindow::cut_commercials()
2623 {
2624         undo->update_undo_before();
2625         commercials->scan_media();
2626         edl->optimize();
2627         save_backup();
2628         undo->update_undo_after(_("cut ads"), LOAD_EDITS | LOAD_TIMEBAR);
2629
2630         restart_brender();
2631         update_plugin_guis();
2632         gui->update(1, 2, 1, 1, 1, 1, 0);
2633         cwindow->update(1, 0, 0, 0, 1);
2634         cwindow->playback_engine->que->
2635                 send_command(CURRENT_FRAME, CHANGE_EDL, edl, 1);
2636 }
2637