cinelerra-5.1/cinelerra/editpanel.C

   1
   2 /*
   3  * CINELERRA
   4  * Copyright (C) 2008 Adam Williams <broadcast at earthling dot net>
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program; if not, write to the Free Software
  18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  *
  20  */
  21
  22 #include "awindow.h"
  23 #include "awindowgui.h"
  24 #include "bcsignals.h"
  25 #include "clipedit.h"
  26 #include "cplayback.h"
  27 #include "cwindow.h"
  28 #include "cwindowgui.h"
  29 #include "editpanel.h"
  30 #include "edl.h"
  31 #include "edlsession.h"
  32 #include "filexml.h"
  33 #include "keys.h"
  34 #include "language.h"
  35 #include "localsession.h"
  36 #include "mainclock.h"
  37 #include "mainundo.h"
  38 #include "mbuttons.h"
  39 #include "meterpanel.h"
  40 #include "mwindow.h"
  41 #include "mwindowgui.h"
  42 #include "playbackengine.h"
  43 #include "theme.h"
  44 #include "timebar.h"
  45 #include "trackcanvas.h"
  46 #include "transportque.h"
  47 #include "zoombar.h"
  48 #include "manualgoto.h"
  49
  50
  51
  52 EditPanel::EditPanel(MWindow *mwindow,
  53         BC_WindowBase *subwindow,
  54         int x,
  55         int y,
  56         int editing_mode,
  57         int use_editing_mode,
  58         int use_keyframe,
  59         int use_splice,   // Extra buttons
  60         int use_overwrite,
  61         int use_lift,
  62         int use_extract,
  63         int use_copy,
  64         int use_paste,
  65         int use_undo,
  66         int use_fit,
  67         int use_locklabels,
  68         int use_labels,
  69         int use_toclip,
  70         int use_meters,
  71         int is_mwindow,
  72         int use_cut,
  73         int use_commercial)
  74 {
  75         this->editing_mode = editing_mode;
  76         this->use_editing_mode = use_editing_mode;
  77         this->use_keyframe = use_keyframe;
  78         this->use_splice = use_splice;
  79         this->use_overwrite = use_overwrite;
  80         this->use_lift = 0;
  81         this->use_extract = 0;
  82         this->use_copy = use_copy;
  83         this->use_paste = use_paste;
  84         this->use_undo = use_undo;
  85         this->mwindow = mwindow;
  86         this->subwindow = subwindow;
  87         this->use_fit = use_fit;
  88         this->use_labels = use_labels;
  89         this->use_locklabels = use_locklabels;
  90         this->use_toclip = use_toclip;
  91         this->use_meters = use_meters;
  92         this->is_mwindow = is_mwindow;
  93         this->use_cut = use_cut;
  94         this->use_commercial = use_commercial;
  95
  96         this->x = x;
  97         this->y = y;
  98         this->fit = 0;
  99         this->fit_autos = 0;
 100         this->inpoint = 0;
 101         this->outpoint = 0;
 102         this->splice = 0;
 103         this->overwrite = 0;
 104         this->lift = 0;
 105         this->extract = 0;
 106         this->clip = 0;
 107         this->cut = 0;
 108         this->commercial = 0;
 109         this->copy = 0;
 110         this->paste = 0;
 111         this->labelbutton = 0;
 112         this->prevlabel = 0;
 113         this->nextlabel = 0;
 114         this->prevedit = 0;
 115         this->nextedit = 0;
 116         this->undo = 0;
 117         this->redo = 0;
 118         this->meter_panel = 0;
 119         this->meters = 0;
 120         this->arrow = 0;
 121         this->ibeam = 0;
 122         this->keyframe = 0;
 123         locklabels = 0;
 124 }
 125
 126 EditPanel::~EditPanel()
 127 {
 128 }
 129
 130 void EditPanel::set_meters(MeterPanel *meter_panel)
 131 {
 132         this->meter_panel = meter_panel;
 133 }
 134
 135
 136 void EditPanel::update()
 137 {
 138         int new_editing_mode = mwindow->edl->session->editing_mode;
 139         if(arrow) arrow->update(new_editing_mode == EDITING_ARROW);
 140         if(ibeam) ibeam->update(new_editing_mode == EDITING_IBEAM);
 141         if(keyframe) keyframe->update(mwindow->edl->session->auto_keyframes);
 142         if(locklabels) locklabels->set_value(mwindow->edl->session->labels_follow_edits);
 143         if(meters)
 144         {
 145 //printf("EditPanel::update %d %p %p\n", __LINE__, subwindow, (BC_WindowBase*)mwindow->cwindow->gui);
 146                 if(subwindow == (BC_WindowBase*)mwindow->cwindow->gui)
 147                 {
 148 //printf("EditPanel::update %d %d\n", __LINE__, mwindow->edl->session->cwindow_meter);
 149                         meters->update(mwindow->edl->session->cwindow_meter);
 150                         mwindow->cwindow->gui->update_meters();
 151                 }
 152                 else
 153                 {
 154 //printf("EditPanel::update %d %d\n", __LINE__, mwindow->edl->session->vwindow_meter);
 155                         meters->update(mwindow->edl->session->vwindow_meter);
 156                 }
 157         }
 158         subwindow->flush();
 159 }
 160
 161 int EditPanel::calculate_w(MWindow *mwindow, int use_keyframe, int total_buttons)
 162 {
 163         int result = 0;
 164         int button_w = mwindow->theme->get_image_set("ibeam")[0]->get_w();
 165         if(use_keyframe)
 166         {
 167                 result += button_w + mwindow->theme->toggle_margin;
 168         }
 169
 170         result += button_w * total_buttons;
 171         return result;
 172 }
 173
 174 int EditPanel::calculate_h(MWindow *mwindow)
 175 {
 176         return mwindow->theme->get_image_set("ibeam")[0]->get_h();
 177 }
 178
 179 void EditPanel::create_buttons()
 180 {
 181         x1 = x, y1 = y;
 182
 183
 184 SET_TRACE
 185         if(use_editing_mode)
 186         {
 187                 subwindow->add_subwindow(arrow = new ArrowButton(mwindow, this, x1, y1));
 188                 x1 += arrow->get_w();
 189                 subwindow->add_subwindow(ibeam = new IBeamButton(mwindow, this, x1, y1));
 190                 x1 += ibeam->get_w();
 191                 x1 += mwindow->theme->toggle_margin;
 192         }
 193
 194         if(use_keyframe)
 195         {
 196                 subwindow->add_subwindow(keyframe = new KeyFrameButton(mwindow, this, x1, y1));
 197                 x1 += keyframe->get_w();
 198         }
 199
 200         if(use_locklabels)
 201         {
 202                 subwindow->add_subwindow(locklabels = new LockLabelsButton(mwindow,
 203                         x1,
 204                         y1));
 205                 x1 += locklabels->get_w();
 206         }
 207         if(use_keyframe || use_locklabels)
 208                 x1 += mwindow->theme->toggle_margin;
 209
 210 // Mandatory
 211         subwindow->add_subwindow(inpoint = new EditInPoint(mwindow, this, x1, y1));
 212         x1 += inpoint->get_w();
 213         subwindow->add_subwindow(outpoint = new EditOutPoint(mwindow, this, x1, y1));
 214         x1 += outpoint->get_w();
 215         if(use_splice)
 216         {
 217                 subwindow->add_subwindow(splice = new EditSplice(mwindow, this, x1, y1));
 218                 x1 += splice->get_w();
 219         }
 220         if(use_overwrite)
 221         {
 222                 subwindow->add_subwindow(overwrite = new EditOverwrite(mwindow, this, x1, y1));
 223                 x1 += overwrite->get_w();
 224         }
 225         if(use_lift)
 226         {
 227                 subwindow->add_subwindow(lift = new EditLift(mwindow, this, x1, y1));
 228                 x1 += lift->get_w();
 229         }
 230         if(use_extract)
 231         {
 232                 subwindow->add_subwindow(extract = new EditExtract(mwindow, this, x1, y1));
 233                 x1 += extract->get_w();
 234         }
 235         if(use_toclip)
 236         {
 237                 subwindow->add_subwindow(clip = new EditToClip(mwindow, this, x1, y1));
 238                 x1 += clip->get_w();
 239         }
 240
 241         if(use_cut)
 242         {
 243                 subwindow->add_subwindow(cut = new EditCut(mwindow, this, x1, y1));
 244                 x1 += cut->get_w();
 245         }
 246         if(use_copy)
 247         {
 248                 subwindow->add_subwindow(copy = new EditCopy(mwindow, this, x1, y1));
 249                 x1 += copy->get_w();
 250         }
 251         if(use_paste)
 252         {
 253                 subwindow->add_subwindow(paste = new EditPaste(mwindow, this, x1, y1));
 254                 x1 += paste->get_w();
 255         }
 256
 257         if(use_meters)
 258         {
 259                 if(!meter_panel)
 260                 {
 261                         printf("EditPanel::create_objects: meter_panel == 0\n");
 262                 }
 263                 subwindow->add_subwindow(meters = new MeterShow(mwindow, meter_panel, x1, y1));
 264                 x1 += meters->get_w();
 265         }
 266
 267         if(use_labels)
 268         {
 269                 subwindow->add_subwindow(labelbutton = new EditLabelbutton(mwindow,
 270                         this,
 271                         x1,
 272                         y1));
 273                 x1 += labelbutton->get_w();
 274                 subwindow->add_subwindow(prevlabel = new EditPrevLabel(mwindow,
 275                         this,
 276                         x1,
 277                         y1,
 278                         is_mwindow));
 279                 x1 += prevlabel->get_w();
 280                 subwindow->add_subwindow(nextlabel = new EditNextLabel(mwindow,
 281                         this,
 282                         x1,
 283                         y1,
 284                         is_mwindow));
 285                 x1 += nextlabel->get_w();
 286         }
 287
 288 // all windows except VWindow since it's only implemented in MWindow.
 289         if(use_cut)
 290         {
 291                 subwindow->add_subwindow(prevedit = new EditPrevEdit(mwindow,
 292                         this,
 293                         x1,
 294                         y1,
 295                         is_mwindow));
 296                 x1 += prevedit->get_w();
 297                 subwindow->add_subwindow(nextedit = new EditNextEdit(mwindow,
 298                         this,
 299                         x1,
 300                         y1,
 301                         is_mwindow));
 302                 x1 += nextedit->get_w();
 303         }
 304
 305         if(use_fit)
 306         {
 307                 subwindow->add_subwindow(fit = new EditFit(mwindow, this, x1, y1));
 308                 x1 += fit->get_w();
 309                 subwindow->add_subwindow(fit_autos = new EditFitAutos(mwindow, this, x1, y1));
 310                 x1 += fit_autos->get_w();
 311         }
 312
 313         if(use_undo)
 314         {
 315                 subwindow->add_subwindow(undo = new EditUndo(mwindow, this, x1, y1));
 316                 x1 += undo->get_w();
 317                 subwindow->add_subwindow(redo = new EditRedo(mwindow, this, x1, y1));
 318                 x1 += redo->get_w();
 319         }
 320
 321         subwindow->add_subwindow(mangoto = new EditManualGoto(mwindow, this, x1, y1));
 322         x1 += mangoto->get_w();
 323
 324         if(use_commercial)
 325         {
 326                 subwindow->add_subwindow(commercial = new EditCommercial(mwindow, this, x1, y1));
 327                 x1 += commercial->get_w();
 328         }
 329 SET_TRACE
 330 }
 331
 332
 333
 334 void EditPanel::toggle_label()
 335 {
 336         mwindow->toggle_label(is_mwindow);
 337 }
 338
 339 void EditPanel::prev_label()
 340 {
 341         int shift_down = subwindow->shift_down();
 342         int have_mwindow_lock = mwindow->gui->get_window_lock();
 343         int have_subwindow_lock =
 344                  subwindow->get_top_level() == mwindow->gui->get_top_level() ?
 345                          0 : subwindow->get_window_lock();
 346         if(have_mwindow_lock)
 347                 mwindow->gui->unlock_window();
 348         if(have_subwindow_lock)
 349                 subwindow->unlock_window();
 350
 351         mwindow->gui->mbuttons->transport->handle_transport(STOP, 1, 0, 0);
 352
 353         if(have_subwindow_lock)
 354                 subwindow->lock_window("EditPanel::prev_label 1");
 355
 356         mwindow->gui->lock_window("EditPanel::prev_label 2");
 357
 358         mwindow->prev_label(shift_down);
 359
 360         if(!have_mwindow_lock)
 361                 mwindow->gui->unlock_window();
 362 }
 363
 364 void EditPanel::next_label()
 365 {
 366         int shift_down = subwindow->shift_down();
 367         int have_mwindow_lock = mwindow->gui->get_window_lock();
 368         int have_subwindow_lock =
 369                  subwindow->get_top_level() == mwindow->gui->get_top_level() ?
 370                          0 : subwindow->get_window_lock();
 371         if(have_mwindow_lock)
 372                 mwindow->gui->unlock_window();
 373         if(have_subwindow_lock)
 374                 subwindow->unlock_window();
 375
 376         mwindow->gui->mbuttons->transport->handle_transport(STOP, 1, 0, 0);
 377
 378         if(have_subwindow_lock)
 379                 subwindow->lock_window("EditPanel::next_label 1");
 380
 381         mwindow->gui->lock_window("EditPanel::next_label 2");
 382
 383         mwindow->next_label(shift_down);
 384
 385         if(!have_mwindow_lock)
 386                 mwindow->gui->unlock_window();
 387 }
 388
 389
 390
 391 void EditPanel::prev_edit()
 392 {
 393         int shift_down = subwindow->shift_down();
 394         int have_mwindow_lock = mwindow->gui->get_window_lock();
 395         int have_subwindow_lock =
 396                  subwindow->get_top_level() == mwindow->gui->get_top_level() ?
 397                          0 : subwindow->get_window_lock();
 398         if(have_mwindow_lock)
 399                 mwindow->gui->unlock_window();
 400         if(have_subwindow_lock)
 401                 subwindow->unlock_window();
 402
 403         mwindow->gui->mbuttons->transport->handle_transport(STOP, 1, 0, 0);
 404
 405         if(have_subwindow_lock)
 406                 subwindow->lock_window("EditPanel::prev_edit 1");
 407
 408         mwindow->gui->lock_window("EditPanel::prev_edit 2");
 409
 410         mwindow->prev_edit_handle(shift_down);
 411
 412         if(!have_mwindow_lock)
 413                 mwindow->gui->unlock_window();
 414 }
 415
 416 void EditPanel::next_edit()
 417 {
 418         int shift_down = subwindow->shift_down();
 419         int have_mwindow_lock = mwindow->gui->get_window_lock();
 420         int have_subwindow_lock =
 421                  subwindow->get_top_level() == mwindow->gui->get_top_level() ?
 422                          0 : subwindow->get_window_lock();
 423         if(have_mwindow_lock)
 424                 mwindow->gui->unlock_window();
 425         if(have_subwindow_lock)
 426                 subwindow->unlock_window();
 427
 428         mwindow->gui->mbuttons->transport->handle_transport(STOP, 1, 0, 0);
 429
 430         if(have_subwindow_lock)
 431                 subwindow->lock_window("EditPanel::next_edit 1");
 432
 433         mwindow->gui->lock_window("EditPanel::next_edit 2");
 434
 435         mwindow->next_edit_handle(shift_down);
 436
 437         if(!have_mwindow_lock)
 438                 mwindow->gui->unlock_window();
 439 }
 440
 441
 442 double EditPanel::get_position()
 443 {
 444         EDL *edl = mwindow->edl;
 445         return !edl ? 0 :
 446                 edl->local_session->get_selectionstart(1) +
 447                         edl->session->get_frame_offset() / edl->session->frame_rate;
 448 }
 449
 450 void EditPanel::set_position(double position)
 451 {
 452         EDL *edl = mwindow->edl;
 453         if( !edl ) return;
 454         if( position != get_position() ) {
 455                 position -= edl->session->get_frame_offset() / edl->session->frame_rate;
 456                 if( position < 0 ) position = 0;
 457                 edl->local_session->set_selectionstart(position);
 458                 edl->local_session->set_selectionend(position);
 459                 mwindow->gui->lock_window();
 460                 mwindow->find_cursor();
 461                 mwindow->gui->update(1, 1, 1, 1, 1, 1, 0);
 462                 mwindow->gui->unlock_window();
 463                 mwindow->cwindow->update(1, 0, 0, 0, 0);
 464         }
 465 }
 466
 467
 468
 469
 470
 471
 472
 473 void EditPanel::reposition_buttons(int x, int y)
 474 {
 475         this->x = x;
 476         this->y = y;
 477         x1 = x, y1 = y;
 478
 479         if(use_editing_mode)
 480         {
 481                 arrow->reposition_window(x1, y1);
 482                 x1 += arrow->get_w();
 483                 ibeam->reposition_window(x1, y1);
 484                 x1 += ibeam->get_w();
 485                 x1 += mwindow->theme->toggle_margin;
 486         }
 487
 488         if(use_keyframe)
 489         {
 490                 keyframe->reposition_window(x1, y1);
 491                 x1 += keyframe->get_w();
 492         }
 493
 494         if(use_locklabels)
 495         {
 496                 locklabels->reposition_window(x1,y1);
 497                 x1 += locklabels->get_w();
 498         }
 499
 500         if(use_keyframe || use_locklabels)
 501                 x1 += mwindow->theme->toggle_margin;
 502
 503         inpoint->reposition_window(x1, y1);
 504         x1 += inpoint->get_w();
 505         outpoint->reposition_window(x1, y1);
 506         x1 += outpoint->get_w();
 507         if(use_splice)
 508         {
 509                 splice->reposition_window(x1, y1);
 510                 x1 += splice->get_w();
 511         }
 512         if(use_overwrite)
 513         {
 514                 overwrite->reposition_window(x1, y1);
 515                 x1 += overwrite->get_w();
 516         }
 517         if(use_lift)
 518         {
 519                 lift->reposition_window(x1, y1);
 520                 x1 += lift->get_w();
 521         }
 522         if(use_extract)
 523         {
 524                 extract->reposition_window(x1, y1);
 525                 x1 += extract->get_w();
 526         }
 527         if(use_toclip)
 528         {
 529                 clip->reposition_window(x1, y1);
 530                 x1 += clip->get_w();
 531         }
 532         if(use_cut)
 533         {
 534                 cut->reposition_window(x1, y1);
 535                 x1 += cut->get_w();
 536         }
 537         if(use_copy)
 538         {
 539                 copy->reposition_window(x1, y1);
 540                 x1 += copy->get_w();
 541         }
 542         if(use_paste)
 543         {
 544                 paste->reposition_window(x1, y1);
 545                 x1 += paste->get_w();
 546         }
 547
 548         if(use_meters)
 549         {
 550                 meters->reposition_window(x1, y1);
 551                 x1 += meters->get_w();
 552         }
 553
 554         if(use_labels)
 555         {
 556                 labelbutton->reposition_window(x1, y1);
 557                 x1 += labelbutton->get_w();
 558                 prevlabel->reposition_window(x1, y1);
 559                 x1 += prevlabel->get_w();
 560                 nextlabel->reposition_window(x1, y1);
 561                 x1 += nextlabel->get_w();
 562         }
 563
 564         if(prevedit)
 565         {
 566                 prevedit->reposition_window(x1, y1);
 567                 x1 += prevedit->get_w();
 568         }
 569
 570         if(nextedit)
 571         {
 572                 nextedit->reposition_window(x1, y1);
 573                 x1 += nextedit->get_w();
 574         }
 575
 576         if(use_fit)
 577         {
 578                 fit->reposition_window(x1, y1);
 579                 x1 += fit->get_w();
 580                 fit_autos->reposition_window(x1, y1);
 581                 x1 += fit_autos->get_w();
 582         }
 583
 584         if(use_undo)
 585         {
 586                 undo->reposition_window(x1, y1);
 587                 x1 += undo->get_w();
 588                 redo->reposition_window(x1, y1);
 589                 x1 += redo->get_w();
 590         }
 591
 592         mangoto->reposition_window(x1, y1);
 593         x1 += mangoto->get_w();
 594 }
 595
 596
 597
 598 void EditPanel::create_objects()
 599 {
 600         create_buttons();
 601 }
 602
 603 int EditPanel::get_w()
 604 {
 605         return x1 - x;
 606 }
 607
 608
 609 void EditPanel::copy_selection()
 610 {
 611         mwindow->copy();
 612 }
 613
 614 void EditPanel::splice_selection()
 615 {
 616 }
 617
 618 void EditPanel::overwrite_selection()
 619 {
 620 }
 621
 622 void EditPanel::set_inpoint()
 623 {
 624         mwindow->set_inpoint(1);
 625 }
 626
 627 void EditPanel::set_outpoint()
 628 {
 629         mwindow->set_outpoint(1);
 630 }
 631
 632 void EditPanel::clear_inpoint()
 633 {
 634         mwindow->delete_inpoint();
 635 }
 636
 637 void EditPanel::clear_outpoint()
 638 {
 639         mwindow->delete_outpoint();
 640 }
 641
 642
 643 EditInPoint::EditInPoint(MWindow *mwindow, EditPanel *panel, int x, int y)
 644  : BC_Button(x, y, mwindow->theme->get_image_set("inbutton"))
 645 {
 646         this->mwindow = mwindow;
 647         this->panel = panel;
 648         set_tooltip(_("In point ( [ )"));
 649 }
 650 EditInPoint::~EditInPoint()
 651 {
 652 }
 653 int EditInPoint::handle_event()
 654 {
 655         panel->set_inpoint();
 656         return 1;
 657 }
 658 int EditInPoint::keypress_event()
 659 {
 660         if(get_keypress() == '[')
 661         {
 662                 panel->set_inpoint();
 663                 return 1;
 664         }
 665         return 0;
 666 }
 667
 668 EditOutPoint::EditOutPoint(MWindow *mwindow, EditPanel *panel, int x, int y)
 669  : BC_Button(x, y, mwindow->theme->get_image_set("outbutton"))
 670 {
 671         this->mwindow = mwindow;
 672         this->panel = panel;
 673         set_tooltip(_("Out point ( ] )"));
 674 }
 675 EditOutPoint::~EditOutPoint()
 676 {
 677 }
 678 int EditOutPoint::handle_event()
 679 {
 680         panel->set_outpoint();
 681         return 1;
 682 }
 683 int EditOutPoint::keypress_event()
 684 {
 685         if(get_keypress() == ']')
 686         {
 687                 panel->set_outpoint();
 688                 return 1;
 689         }
 690         return 0;
 691 }
 692
 693
 694 EditNextLabel::EditNextLabel(MWindow *mwindow,
 695         EditPanel *panel,
 696         int x,
 697         int y,
 698         int is_mwindow)
 699  : BC_Button(x, y, mwindow->theme->get_image_set("nextlabel"))
 700 {
 701         this->mwindow = mwindow;
 702         this->panel = panel;
 703         this->is_mwindow = is_mwindow;
 704         set_tooltip(_("Next label ( ctrl -> )"));
 705 }
 706 EditNextLabel::~EditNextLabel()
 707 {
 708 }
 709 int EditNextLabel::keypress_event()
 710 {
 711         if(get_keypress() == RIGHT && ctrl_down())
 712                 return handle_event();
 713         return 0;
 714 }
 715 int EditNextLabel::handle_event()
 716 {
 717         panel->next_label();
 718         return 1;
 719 }
 720
 721 EditPrevLabel::EditPrevLabel(MWindow *mwindow,
 722         EditPanel *panel,
 723         int x,
 724         int y,
 725         int is_mwindow)
 726  : BC_Button(x, y, mwindow->theme->get_image_set("prevlabel"))
 727 {
 728         this->mwindow = mwindow;
 729         this->panel = panel;
 730         this->is_mwindow = is_mwindow;
 731         set_tooltip(_("Previous label ( ctrl <- )"));
 732 }
 733 EditPrevLabel::~EditPrevLabel()
 734 {
 735 }
 736 int EditPrevLabel::keypress_event()
 737 {
 738         if(get_keypress() == LEFT && ctrl_down())
 739                 return handle_event();
 740         return 0;
 741 }
 742 int EditPrevLabel::handle_event()
 743 {
 744         panel->prev_label();
 745         return 1;
 746 }
 747
 748
 749
 750 EditNextEdit::EditNextEdit(MWindow *mwindow,
 751         EditPanel *panel,
 752         int x,
 753         int y,
 754         int is_mwindow)
 755  : BC_Button(x, y, mwindow->theme->get_image_set("nextedit"))
 756 {
 757         this->mwindow = mwindow;
 758         this->panel = panel;
 759         this->is_mwindow = is_mwindow;
 760         set_tooltip(_("Next edit ( alt -> )"));
 761 }
 762 EditNextEdit::~EditNextEdit()
 763 {
 764 }
 765 int EditNextEdit::keypress_event()
 766 {
 767         if(get_keypress() == RIGHT && alt_down())
 768                 return handle_event();
 769         return 0;
 770 }
 771 int EditNextEdit::handle_event()
 772 {
 773         panel->next_edit();
 774         return 1;
 775 }
 776
 777 EditPrevEdit::EditPrevEdit(MWindow *mwindow,
 778         EditPanel *panel,
 779         int x,
 780         int y,
 781         int is_mwindow)
 782  : BC_Button(x, y, mwindow->theme->get_image_set("prevedit"))
 783 {
 784         this->mwindow = mwindow;
 785         this->panel = panel;
 786         this->is_mwindow = is_mwindow;
 787         set_tooltip(_("Previous edit (alt <- )"));
 788 }
 789 EditPrevEdit::~EditPrevEdit()
 790 {
 791 }
 792 int EditPrevEdit::keypress_event()
 793 {
 794         if(get_keypress() == LEFT && alt_down())
 795                 return handle_event();
 796         return 0;
 797 }
 798 int EditPrevEdit::handle_event()
 799 {
 800         panel->prev_edit();
 801         return 1;
 802 }
 803
 804
 805
 806 EditLift::EditLift(MWindow *mwindow, EditPanel *panel, int x, int y)
 807  : BC_Button(x, y, mwindow->theme->lift_data)
 808 {
 809         this->mwindow = mwindow;
 810         this->panel = panel;
 811         set_tooltip(_("Lift"));
 812 }
 813 EditLift::~EditLift()
 814 {
 815 }
 816 int EditLift::handle_event()
 817 {
 818         return 1;
 819 }
 820
 821 EditOverwrite::EditOverwrite(MWindow *mwindow, EditPanel *panel, int x, int y)
 822  : BC_Button(x, y, mwindow->theme->overwrite_data)
 823 {
 824         this->mwindow = mwindow;
 825         this->panel = panel;
 826         set_tooltip(_("Overwrite ( b )"));
 827 }
 828 EditOverwrite::~EditOverwrite()
 829 {
 830 }
 831 int EditOverwrite::handle_event()
 832 {
 833         panel->overwrite_selection();
 834         return 1;
 835 }
 836 int EditOverwrite::keypress_event()
 837 {
 838         if(get_keypress() == 'b')
 839         {
 840                 handle_event();
 841                 return 1;
 842         }
 843         return 0;
 844 }
 845
 846 EditExtract::EditExtract(MWindow *mwindow, EditPanel *panel, int x, int y)
 847  : BC_Button(x, y, mwindow->theme->extract_data)
 848 {
 849         this->mwindow = mwindow;
 850         this->panel = panel;
 851         set_tooltip(_("Extract"));
 852 }
 853 EditExtract::~EditExtract()
 854 {
 855 }
 856 int EditExtract::handle_event()
 857 {
 858 //      mwindow->extract_selection();
 859         return 1;
 860 }
 861
 862 EditToClip::EditToClip(MWindow *mwindow, EditPanel *panel, int x, int y)
 863  : BC_Button(x, y, mwindow->theme->get_image_set("toclip"))
 864 {
 865         this->mwindow = mwindow;
 866         this->panel = panel;
 867         set_tooltip(_("To clip ( i )"));
 868 }
 869 EditToClip::~EditToClip()
 870 {
 871 }
 872 int EditToClip::handle_event()
 873 {
 874         panel->to_clip();
 875         return 1;
 876 }
 877
 878 int EditToClip::keypress_event()
 879 {
 880         if(get_keypress() == 'i')
 881         {
 882                 handle_event();
 883                 return 1;
 884         }
 885         return 0;
 886 }
 887
 888 EditManualGoto::EditManualGoto(MWindow *mwindow, EditPanel *panel, int x, int y)
 889  : BC_Button(x, y, mwindow->theme->get_image_set("goto"))
 890 {
 891         this->mwindow = mwindow;
 892         this->panel = panel;
 893         mangoto = new ManualGoto(mwindow, panel);
 894         set_tooltip(_("Manual goto ( g )"));
 895 }
 896 EditManualGoto::~EditManualGoto()
 897 {
 898         delete mangoto;
 899 }
 900 int EditManualGoto::handle_event()
 901 {
 902         mangoto->start();
 903         return 1;
 904 }
 905
 906 int EditManualGoto::keypress_event()
 907 {
 908         if(get_keypress() == 'g')
 909         {
 910                 handle_event();
 911                 return 1;
 912         }
 913         return 0;
 914 }
 915
 916
 917 EditSplice::EditSplice(MWindow *mwindow, EditPanel *panel, int x, int y)
 918  : BC_Button(x, y, mwindow->theme->splice_data)
 919 {
 920         this->mwindow = mwindow;
 921         this->panel = panel;
 922         set_tooltip(_("Splice ( v )"));
 923 }
 924 EditSplice::~EditSplice()
 925 {
 926 }
 927 int EditSplice::handle_event()
 928 {
 929         panel->splice_selection();
 930         return 1;
 931 }
 932 int EditSplice::keypress_event()
 933 {
 934         if(get_keypress() == 'v')
 935         {
 936                 handle_event();
 937                 return 1;
 938         }
 939         return 0;
 940 }
 941
 942 EditCut::EditCut(MWindow *mwindow, EditPanel *panel, int x, int y)
 943  : BC_Button(x, y, mwindow->theme->get_image_set("cut"))
 944 {
 945         this->mwindow = mwindow;
 946         this->panel = panel;
 947         set_tooltip(_("Cut ( x )"));
 948 }
 949 EditCut::~EditCut()
 950 {
 951 }
 952 int EditCut::keypress_event()
 953 {
 954         if(get_keypress() == 'x')
 955                 return handle_event();
 956         return 0;
 957 }
 958
 959 int EditCut::handle_event()
 960 {
 961         int have_mwindow_lock = mwindow->gui->get_window_lock();
 962         if(!have_mwindow_lock)
 963                 mwindow->gui->lock_window("EditCut::handle_event");
 964
 965         mwindow->cut();
 966
 967         if(!have_mwindow_lock)
 968                 mwindow->gui->unlock_window();
 969         return 1;
 970 }
 971
 972 EditCommercial::EditCommercial(MWindow *mwindow, EditPanel *panel, int x, int y)
 973  : BC_Button(x, y, mwindow->theme->get_image_set("commercial"))
 974 {
 975         this->mwindow = mwindow;
 976         this->panel = panel;
 977         set_tooltip(_("Commercial ( shift X )"));
 978 }
 979 EditCommercial::~EditCommercial()
 980 {
 981 }
 982 int EditCommercial::keypress_event()
 983 {
 984         if(get_keypress() == 'X')
 985                 return handle_event();
 986         return 0;
 987 }
 988
 989 int EditCommercial::handle_event()
 990 {
 991         int have_mwindow_lock = mwindow->gui->get_window_lock();
 992         if(have_mwindow_lock)
 993                 mwindow->gui->unlock_window();
 994         mwindow->commit_commercial();
 995         if( !mwindow->put_commercial() ) {
 996                 mwindow->gui->lock_window("EditCommercial::handle_event 1");
 997                 mwindow->cut();
 998                 if(!have_mwindow_lock)
 999                         mwindow->gui->unlock_window();
1000                 mwindow->activate_commercial();
1001                 return 1;
1002         }
1003         mwindow->undo_commercial();
1004         if(have_mwindow_lock)
1005                 mwindow->gui->lock_window("EditCommercial::handle_event 2");
1006         return 1;
1007 }
1008
1009 EditCopy::EditCopy(MWindow *mwindow, EditPanel *panel, int x, int y)
1010  : BC_Button(x, y, mwindow->theme->get_image_set("copy"))
1011 {
1012         this->mwindow = mwindow;
1013         this->panel = panel;
1014         set_tooltip(_("Copy ( c )"));
1015 }
1016 EditCopy::~EditCopy()
1017 {
1018 }
1019
1020 int EditCopy::keypress_event()
1021 {
1022         if(get_keypress() == 'c')
1023                 return handle_event();
1024         return 0;
1025 }
1026 int EditCopy::handle_event()
1027 {
1028         panel->copy_selection();
1029         return 1;
1030 }
1031
1032 EditAppend::EditAppend(MWindow *mwindow, EditPanel *panel, int x, int y)
1033  : BC_Button(x, y, mwindow->theme->append_data)
1034 {
1035         this->mwindow = mwindow;
1036         this->panel = panel;
1037         set_tooltip(_("Append to end of track"));
1038 }
1039 EditAppend::~EditAppend()
1040 {
1041 }
1042
1043
1044 int EditAppend::handle_event()
1045 {
1046         return 1;
1047 }
1048
1049
1050 EditInsert::EditInsert(MWindow *mwindow, EditPanel *panel, int x, int y)
1051  : BC_Button(x, y, mwindow->theme->insert_data)
1052 {
1053         this->mwindow = mwindow;
1054         this->panel = panel;
1055         set_tooltip(_("Insert before beginning of track"));
1056 }
1057 EditInsert::~EditInsert()
1058 {
1059 }
1060
1061
1062 int EditInsert::handle_event()
1063 {
1064
1065         return 1;
1066 }
1067
1068
1069 EditPaste::EditPaste(MWindow *mwindow, EditPanel *panel, int x, int y)
1070  : BC_Button(x, y, mwindow->theme->get_image_set("paste"))
1071 {
1072         this->mwindow = mwindow;
1073         this->panel = panel;
1074         set_tooltip(_("Paste ( v )"));
1075 }
1076 EditPaste::~EditPaste()
1077 {
1078 }
1079
1080 int EditPaste::keypress_event()
1081 {
1082         if(get_keypress() == 'v')
1083                 return handle_event();
1084         return 0;
1085 }
1086 int EditPaste::handle_event()
1087 {
1088         int have_mwindow_lock = mwindow->gui->get_window_lock();
1089         if(!have_mwindow_lock)
1090                 mwindow->gui->lock_window("EditPaste::handle_event");
1091
1092         mwindow->paste();
1093
1094         if(!have_mwindow_lock)
1095                 mwindow->gui->unlock_window();
1096         return 1;
1097 }
1098
1099
1100
1101 EditTransition::EditTransition(MWindow *mwindow, EditPanel *panel, int x, int y)
1102  : BC_Button(x, y, mwindow->theme->transition_data)
1103 {
1104         this->mwindow = mwindow;
1105         this->panel = panel;
1106         set_tooltip(_("Set transition"));
1107 }
1108 EditTransition::~EditTransition()
1109 {
1110 }
1111 int EditTransition::handle_event()
1112 {
1113         return 1;
1114 }
1115
1116 EditPresentation::EditPresentation(MWindow *mwindow, EditPanel *panel, int x, int y)
1117  : BC_Button(x, y, mwindow->theme->presentation_data)
1118 {
1119         this->mwindow = mwindow;
1120         this->panel = panel;
1121         set_tooltip(_("Set presentation up to current position"));
1122 }
1123 EditPresentation::~EditPresentation()
1124 {
1125 }
1126 int EditPresentation::handle_event()
1127 {
1128         return 1;
1129 }
1130
1131 EditUndo::EditUndo(MWindow *mwindow, EditPanel *panel, int x, int y)
1132  : BC_Button(x, y, mwindow->theme->get_image_set("undo"))
1133 {
1134         this->mwindow = mwindow;
1135         this->panel = panel;
1136         set_tooltip(_("Undo ( z )"));
1137 }
1138 EditUndo::~EditUndo()
1139 {
1140 }
1141 int EditUndo::keypress_event()
1142 {
1143         if(get_keypress() == 'z')
1144                 return handle_event();
1145         return 0;
1146 }
1147 int EditUndo::handle_event()
1148 {
1149         mwindow->undo_entry(panel->subwindow);
1150         return 1;
1151 }
1152
1153 EditRedo::EditRedo(MWindow *mwindow, EditPanel *panel, int x, int y)
1154  : BC_Button(x, y, mwindow->theme->get_image_set("redo"))
1155 {
1156         this->mwindow = mwindow;
1157         this->panel = panel;
1158         set_tooltip(_("Redo ( shift Z )"));
1159 }
1160 EditRedo::~EditRedo()
1161 {
1162 }
1163 int EditRedo::keypress_event()
1164 {
1165         if(get_keypress() == 'Z')
1166                 return handle_event();
1167         return 0;
1168 }
1169 int EditRedo::handle_event()
1170 {
1171         mwindow->redo_entry(panel->subwindow);
1172         return 1;
1173 };
1174
1175
1176
1177
1178
1179 EditLabelbutton::EditLabelbutton(MWindow *mwindow, EditPanel *panel, int x, int y)
1180  : BC_Button(x, y, mwindow->theme->get_image_set("labelbutton"))
1181 {
1182         this->mwindow = mwindow;
1183         this->panel = panel;
1184         set_tooltip(_("Toggle label at current position ( l )"));
1185 }
1186
1187 EditLabelbutton::~EditLabelbutton()
1188 {
1189 }
1190 int EditLabelbutton::keypress_event()
1191 {
1192         if(get_keypress() == 'l')
1193                 return handle_event();
1194         return 0;
1195 }
1196 int EditLabelbutton::handle_event()
1197 {
1198         panel->toggle_label();
1199         return 1;
1200 }
1201
1202
1203
1204
1205
1206
1207
1208 EditFit::EditFit(MWindow *mwindow, EditPanel *panel, int x, int y)
1209  : BC_Button(x, y, mwindow->theme->get_image_set("fit"))
1210 {
1211         this->mwindow = mwindow;
1212         this->panel = panel;
1213         set_tooltip(_("Fit selection to display ( f )"));
1214 }
1215 EditFit::~EditFit()
1216 {
1217 }
1218 int EditFit::keypress_event()
1219 {
1220         if(!alt_down() && get_keypress() == 'f')
1221         {
1222                 handle_event();
1223                 return 1;
1224         }
1225         return 0;
1226 }
1227 int EditFit::handle_event()
1228 {
1229         mwindow->fit_selection();
1230         return 1;
1231 }
1232
1233
1234
1235
1236
1237
1238
1239
1240
1241 EditFitAutos::EditFitAutos(MWindow *mwindow, EditPanel *panel, int x, int y)
1242  : BC_Button(x, y, mwindow->theme->get_image_set("fitautos"))
1243 {
1244         this->mwindow = mwindow;
1245         this->panel = panel;
1246         set_tooltip(_("Fit all autos to display ( Alt + f )"));
1247 }
1248 EditFitAutos::~EditFitAutos()
1249 {
1250 }
1251 int EditFitAutos::keypress_event()
1252 {
1253         if(!ctrl_down() && alt_down() && get_keypress() == 'f')
1254         {
1255                 mwindow->fit_autos(1);
1256                 return 1;
1257         }
1258         if(ctrl_down() && alt_down() && get_keypress() == 'f')
1259         {
1260                 mwindow->fit_autos(0);
1261                 return 1;
1262         }
1263         return 0;
1264 }
1265 int EditFitAutos::handle_event()
1266 {
1267         mwindow->fit_autos(1);
1268         return 1;
1269 }
1270
1271
1272
1273
1274
1275
1276
1277
1278
1279
1280
1281
1282
1283 ArrowButton::ArrowButton(MWindow *mwindow, EditPanel *panel, int x, int y)
1284  : BC_Toggle(x,
1285         y,
1286         mwindow->theme->get_image_set("arrow"),
1287         mwindow->edl->session->editing_mode == EDITING_ARROW,
1288         "",
1289         0,
1290         0,
1291         0)
1292 {
1293         this->mwindow = mwindow;
1294         this->panel = panel;
1295         set_tooltip(_("Drag and drop editing mode"));
1296 }
1297
1298 int ArrowButton::handle_event()
1299 {
1300         update(1);
1301         panel->ibeam->update(0);
1302         mwindow->set_editing_mode(EDITING_ARROW,
1303                 !panel->is_mwindow,
1304                 panel->is_mwindow);
1305 // Nothing after this
1306         return 1;
1307 }
1308
1309
1310 IBeamButton::IBeamButton(MWindow *mwindow, EditPanel *panel, int x, int y)
1311  : BC_Toggle(x,
1312         y,
1313         mwindow->theme->get_image_set("ibeam"),
1314         mwindow->edl->session->editing_mode == EDITING_IBEAM,
1315         "",
1316         0,
1317         0,
1318         0)
1319 {
1320         this->mwindow = mwindow;
1321         this->panel = panel;
1322         set_tooltip(_("Cut and paste editing mode"));
1323 }
1324
1325 int IBeamButton::handle_event()
1326 {
1327         update(1);
1328         panel->arrow->update(0);
1329         mwindow->set_editing_mode(EDITING_IBEAM,
1330                 !panel->is_mwindow,
1331                 panel->is_mwindow);
1332 // Nothing after this
1333         return 1;
1334 }
1335
1336 KeyFrameButton::KeyFrameButton(MWindow *mwindow, EditPanel *panel, int x, int y)
1337  : BC_Toggle(x,
1338         y,
1339         mwindow->theme->get_image_set("autokeyframe"),
1340         mwindow->edl->session->auto_keyframes,
1341         "",
1342         0,
1343         0,
1344         0)
1345 {
1346         this->mwindow = mwindow;
1347         this->panel = panel;
1348         set_tooltip(_("Generate keyframes while tweeking"));
1349 }
1350
1351 int KeyFrameButton::handle_event()
1352 {
1353         mwindow->set_auto_keyframes(get_value(),
1354                 !panel->is_mwindow,
1355                 panel->is_mwindow);
1356         return 1;
1357 }
1358
1359
1360 LockLabelsButton::LockLabelsButton(MWindow *mwindow, int x, int y)
1361  : BC_Toggle(x,
1362         y,
1363         mwindow->theme->get_image_set("locklabels"),
1364         mwindow->edl->session->labels_follow_edits,
1365         "",
1366         0,
1367         0,
1368         0)
1369 {
1370         this->mwindow = mwindow;
1371         set_tooltip(_("Lock labels from moving"));
1372 }
1373
1374 int LockLabelsButton::handle_event()
1375 {
1376         mwindow->set_labels_follow_edits(get_value());
1377         return 1;
1378 }
1379