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 window_id,
  55         int x,
  56         int y,
  57         int editing_mode,
  58         int use_editing_mode,
  59         int use_keyframe,
  60         int use_splice,   // Extra buttons
  61         int use_overwrite,
  62         int use_copy,
  63         int use_paste,
  64         int use_undo,
  65         int use_fit,
  66         int use_locklabels,
  67         int use_labels,
  68         int use_toclip,
  69         int use_meters,
  70         int use_cut,
  71         int use_commercial,
  72         int use_goto,
  73         int use_clk2play)
  74 {
  75         this->window_id = window_id;
  76         this->editing_mode = editing_mode;
  77         this->use_editing_mode = use_editing_mode;
  78         this->use_keyframe = use_keyframe;
  79         this->use_splice = use_splice;
  80         this->use_overwrite = use_overwrite;
  81         this->use_copy = use_copy;
  82         this->use_paste = use_paste;
  83         this->use_undo = use_undo;
  84         this->mwindow = mwindow;
  85         this->subwindow = subwindow;
  86         this->use_fit = use_fit;
  87         this->use_labels = use_labels;
  88         this->use_locklabels = use_locklabels;
  89         this->use_toclip = use_toclip;
  90         this->use_meters = use_meters;
  91         this->use_cut = use_cut;
  92         this->use_commercial = use_commercial;
  93         this->use_goto = use_goto;
  94         this->use_clk2play = use_clk2play;
  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->clip = 0;
 105         this->cut = 0;
 106         this->commercial = 0;
 107         this->copy = 0;
 108         this->paste = 0;
 109         this->labelbutton = 0;
 110         this->prevlabel = 0;
 111         this->nextlabel = 0;
 112         this->prevedit = 0;
 113         this->nextedit = 0;
 114         this->undo = 0;
 115         this->redo = 0;
 116         this->meter_panel = 0;
 117         this->meters = 0;
 118         this->arrow = 0;
 119         this->ibeam = 0;
 120         this->keyframe = 0;
 121         this->mangoto = 0;
 122         this->click2play = 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( click2play ) {
 144                 int value = !is_vwindow() ?
 145                         mwindow->edl->session->cwindow_click2play :
 146                         mwindow->edl->session->vwindow_click2play ;
 147                 click2play->set_value(value);
 148         }
 149         if( meters ) {
 150                 if( is_cwindow() ) {
 151                         meters->update(mwindow->edl->session->cwindow_meter);
 152                         mwindow->cwindow->gui->update_meters();
 153                 }
 154                 else {
 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                 result += button_w + mwindow->theme->toggle_margin;
 167         }
 168
 169         result += button_w * total_buttons;
 170         return result;
 171 }
 172
 173 int EditPanel::calculate_h(MWindow *mwindow)
 174 {
 175         return mwindow->theme->get_image_set("ibeam")[0]->get_h();
 176 }
 177
 178 void EditPanel::create_buttons()
 179 {
 180         x1 = x, y1 = y;
 181
 182         if( use_editing_mode ) {
 183                 arrow = new ArrowButton(mwindow, this, x1, y1);
 184                 subwindow->add_subwindow(arrow);
 185                 x1 += arrow->get_w();
 186                 ibeam = new IBeamButton(mwindow, this, x1, y1);
 187                 subwindow->add_subwindow(ibeam);
 188                 x1 += ibeam->get_w();
 189                 x1 += mwindow->theme->toggle_margin;
 190         }
 191
 192         if( use_keyframe ) {
 193                 keyframe = new KeyFrameButton(mwindow, this, x1, y1);
 194                 subwindow->add_subwindow(keyframe);
 195                 x1 += keyframe->get_w();
 196         }
 197
 198         if( use_locklabels ) {
 199                 locklabels = new LockLabelsButton(mwindow, this, x1, y1);
 200                 subwindow->add_subwindow(locklabels);
 201                 x1 += locklabels->get_w();
 202         }
 203
 204         if( use_keyframe || use_locklabels )
 205                 x1 += mwindow->theme->toggle_margin;
 206
 207 // Mandatory
 208         inpoint = new EditInPoint(mwindow, this, x1, y1);
 209         subwindow->add_subwindow(inpoint);
 210         x1 += inpoint->get_w();
 211         outpoint = new EditOutPoint(mwindow, this, x1, y1);
 212         subwindow->add_subwindow(outpoint);
 213         x1 += outpoint->get_w();
 214
 215         if( use_splice ) {
 216                 splice = new EditSplice(mwindow, this, x1, y1);
 217                 subwindow->add_subwindow(splice);
 218                 x1 += splice->get_w();
 219         }
 220
 221         if( use_overwrite ) {
 222                 overwrite = new EditOverwrite(mwindow, this, x1, y1);
 223                 subwindow->add_subwindow(overwrite);
 224                 x1 += overwrite->get_w();
 225         }
 226
 227         if( use_toclip ) {
 228                 clip = new EditToClip(mwindow, this, x1, y1);
 229                 subwindow->add_subwindow(clip);
 230                 x1 += clip->get_w();
 231         }
 232
 233         if( use_cut ) {
 234                 cut = new EditCut(mwindow, this, x1, y1);
 235                 subwindow->add_subwindow(cut);
 236                 x1 += cut->get_w();
 237         }
 238
 239         if( use_copy ) {
 240                 copy = new EditCopy(mwindow, this, x1, y1);
 241                 subwindow->add_subwindow(copy);
 242                 x1 += copy->get_w();
 243         }
 244
 245         if( use_paste ) {
 246                 paste = new EditPaste(mwindow, this, x1, y1);
 247                 subwindow->add_subwindow(paste);
 248                 x1 += paste->get_w();
 249         }
 250
 251         if( use_meters ) {
 252                 if( meter_panel ) {
 253                         meters = new MeterShow(mwindow, meter_panel, x1, y1);
 254                         subwindow->add_subwindow(meters);
 255                         x1 += meters->get_w();
 256                 }
 257                 else
 258                         printf("EditPanel::create_objects: meter_panel == 0\n");
 259         }
 260
 261         if( use_labels ) {
 262                 labelbutton = new EditLabelbutton(mwindow, this, x1, y1);
 263                 subwindow->add_subwindow(labelbutton);
 264                 x1 += labelbutton->get_w();
 265                 prevlabel = new EditPrevLabel(mwindow, this, x1, y1);
 266                 subwindow->add_subwindow(prevlabel);
 267                 x1 += prevlabel->get_w();
 268                 nextlabel = new EditNextLabel(mwindow, this, x1, y1);
 269                 subwindow->add_subwindow(nextlabel);
 270                 x1 += nextlabel->get_w();
 271         }
 272
 273 // all windows except VWindow since it's only implemented in MWindow.
 274         if( use_cut ) {
 275                 prevedit = new EditPrevEdit(mwindow, this, x1, y1);
 276                 subwindow->add_subwindow(prevedit);
 277                 x1 += prevedit->get_w();
 278                 nextedit = new EditNextEdit(mwindow, this, x1, y1);
 279                 subwindow->add_subwindow(nextedit);
 280                 x1 += nextedit->get_w();
 281         }
 282
 283         if( use_fit ) {
 284                 fit = new EditFit(mwindow, this, x1, y1);
 285                 subwindow->add_subwindow(fit);
 286                 x1 += fit->get_w();
 287                 fit_autos = new EditFitAutos(mwindow, this, x1, y1);
 288                 subwindow->add_subwindow(fit_autos);
 289                 x1 += fit_autos->get_w();
 290         }
 291
 292         if( use_undo ) {
 293                 undo = new EditUndo(mwindow, this, x1, y1);
 294                 subwindow->add_subwindow(undo);
 295                 x1 += undo->get_w();
 296                 redo = new EditRedo(mwindow, this, x1, y1);
 297                 subwindow->add_subwindow(redo);
 298                 x1 += redo->get_w();
 299         }
 300
 301         if( use_goto ) {
 302                 mangoto = new EditManualGoto(mwindow, this, x1, y1);
 303                 subwindow->add_subwindow(mangoto);
 304                 x1 += mangoto->get_w();
 305         }
 306
 307         if( use_clk2play ) {
 308                 click2play = new EditClick2Play(mwindow, this, x1, y1+5);
 309                 subwindow->add_subwindow(click2play);
 310                 x1 += click2play->get_w();
 311         }
 312
 313         if( use_commercial ) {
 314                 commercial = new EditCommercial(mwindow, this, x1, y1);
 315                 subwindow->add_subwindow(commercial);
 316                 x1 += commercial->get_w();
 317         }
 318 }
 319
 320 void EditPanel::reposition_buttons(int x, int y)
 321 {
 322         this->x = x;
 323         this->y = y;
 324         x1 = x, y1 = y;
 325
 326         if( use_editing_mode ) {
 327                 arrow->reposition_window(x1, y1);
 328                 x1 += arrow->get_w();
 329                 ibeam->reposition_window(x1, y1);
 330                 x1 += ibeam->get_w();
 331                 x1 += mwindow->theme->toggle_margin;
 332         }
 333
 334         if( use_keyframe ) {
 335                 keyframe->reposition_window(x1, y1);
 336                 x1 += keyframe->get_w();
 337         }
 338
 339         if( use_locklabels ) {
 340                 locklabels->reposition_window(x1,y1);
 341                 x1 += locklabels->get_w();
 342         }
 343
 344         if( use_keyframe || use_locklabels )
 345                 x1 += mwindow->theme->toggle_margin;
 346
 347         inpoint->reposition_window(x1, y1);
 348         x1 += inpoint->get_w();
 349         outpoint->reposition_window(x1, y1);
 350         x1 += outpoint->get_w();
 351         if( use_splice ) {
 352                 splice->reposition_window(x1, y1);
 353                 x1 += splice->get_w();
 354         }
 355         if( use_overwrite ) {
 356                 overwrite->reposition_window(x1, y1);
 357                 x1 += overwrite->get_w();
 358         }
 359         if( use_toclip ) {
 360                 clip->reposition_window(x1, y1);
 361                 x1 += clip->get_w();
 362         }
 363         if( use_cut ) {
 364                 cut->reposition_window(x1, y1);
 365                 x1 += cut->get_w();
 366         }
 367         if( use_copy ) {
 368                 copy->reposition_window(x1, y1);
 369                 x1 += copy->get_w();
 370         }
 371         if( use_paste ) {
 372                 paste->reposition_window(x1, y1);
 373                 x1 += paste->get_w();
 374         }
 375
 376         if( use_meters ) {
 377                 meters->reposition_window(x1, y1);
 378                 x1 += meters->get_w();
 379         }
 380
 381         if( use_labels ) {
 382                 labelbutton->reposition_window(x1, y1);
 383                 x1 += labelbutton->get_w();
 384                 prevlabel->reposition_window(x1, y1);
 385                 x1 += prevlabel->get_w();
 386                 nextlabel->reposition_window(x1, y1);
 387                 x1 += nextlabel->get_w();
 388         }
 389
 390         if( prevedit ) {
 391                 prevedit->reposition_window(x1, y1);
 392                 x1 += prevedit->get_w();
 393         }
 394
 395         if( nextedit ) {
 396                 nextedit->reposition_window(x1, y1);
 397                 x1 += nextedit->get_w();
 398         }
 399
 400         if( use_fit ) {
 401                 fit->reposition_window(x1, y1);
 402                 x1 += fit->get_w();
 403                 fit_autos->reposition_window(x1, y1);
 404                 x1 += fit_autos->get_w();
 405         }
 406
 407         if( use_undo ) {
 408                 undo->reposition_window(x1, y1);
 409                 x1 += undo->get_w();
 410                 redo->reposition_window(x1, y1);
 411                 x1 += redo->get_w();
 412         }
 413
 414         if( use_goto ) {
 415                 mangoto->reposition_window(x1, y1);
 416                 x1 += mangoto->get_w();
 417         }
 418         if( use_clk2play ) {
 419                 click2play->reposition_window(x1, y1+5);
 420                 x1 += click2play->get_w();
 421         }
 422 }
 423
 424 void EditPanel::create_objects()
 425 {
 426         create_buttons();
 427 }
 428
 429 int EditPanel::get_w()
 430 {
 431         return x1 - x;
 432 }
 433
 434 // toggle_label
 435 EditLabelbutton::EditLabelbutton(MWindow *mwindow, EditPanel *panel, int x, int y)
 436  : BC_Button(x, y, mwindow->theme->get_image_set("labelbutton"))
 437 {
 438         this->mwindow = mwindow;
 439         this->panel = panel;
 440         set_tooltip(_("Toggle label at current position ( l )"));
 441 }
 442
 443 EditLabelbutton::~EditLabelbutton()
 444 {
 445 }
 446 int EditLabelbutton::keypress_event()
 447 {
 448         if( get_keypress() == 'l' && !alt_down() )
 449                 return handle_event();
 450         return 0;
 451 }
 452 int EditLabelbutton::handle_event()
 453 {
 454         panel->panel_toggle_label();
 455         return 1;
 456 }
 457
 458 //next_label
 459 EditNextLabel::EditNextLabel(MWindow *mwindow,
 460         EditPanel *panel, int x, int y)
 461  : BC_Button(x, y, mwindow->theme->get_image_set("nextlabel"))
 462 {
 463         this->mwindow = mwindow;
 464         this->panel = panel;
 465         set_tooltip(_("Next label ( ctrl -> )"));
 466 }
 467 EditNextLabel::~EditNextLabel()
 468 {
 469 }
 470 int EditNextLabel::keypress_event()
 471 {
 472         if( ctrl_down() ) {
 473                 int key = get_keypress();
 474                 if( (key == RIGHT || key == '.') && !alt_down() ) {
 475                         panel->panel_next_label(0);
 476                         return 1;
 477                 }
 478                 if( key == '>' && alt_down() ) {
 479                         panel->panel_next_label(1);
 480                         return 1;
 481                 }
 482         }
 483         return 0;
 484 }
 485 int EditNextLabel::handle_event()
 486 {
 487         int cut = ctrl_down() && alt_down();
 488         panel->panel_next_label(cut);
 489         return 1;
 490 }
 491
 492 //prev_label
 493 EditPrevLabel::EditPrevLabel(MWindow *mwindow,
 494         EditPanel *panel, int x, int y)
 495  : BC_Button(x, y, mwindow->theme->get_image_set("prevlabel"))
 496 {
 497         this->mwindow = mwindow;
 498         this->panel = panel;
 499         set_tooltip(_("Previous label ( ctrl <- )"));
 500 }
 501 EditPrevLabel::~EditPrevLabel()
 502 {
 503 }
 504 int EditPrevLabel::keypress_event()
 505 {
 506         if( ctrl_down() ) {
 507                 int key = get_keypress();
 508                 if( (key == LEFT || key == ',') && !alt_down() ) {
 509                         panel->panel_prev_label(0);
 510                         return 1;
 511                 }
 512                 if( key == '<' && alt_down() ) {
 513                         panel->panel_prev_label(1);
 514                         return 1;
 515                 }
 516         }
 517         return 0;
 518 }
 519 int EditPrevLabel::handle_event()
 520 {
 521         int cut = ctrl_down() && alt_down();
 522         panel->panel_prev_label(cut);
 523         return 1;
 524 }
 525
 526 //prev_edit
 527 EditPrevEdit::EditPrevEdit(MWindow *mwindow,
 528         EditPanel *panel, int x, int y)
 529  : BC_Button(x, y, mwindow->theme->get_image_set("prevedit"))
 530 {
 531         this->mwindow = mwindow;
 532         this->panel = panel;
 533         set_tooltip(_("Previous edit (alt <- )"));
 534 }
 535 EditPrevEdit::~EditPrevEdit()
 536 {
 537 }
 538 int EditPrevEdit::keypress_event()
 539 {
 540         if( alt_down() ) {
 541                 int key = get_keypress();
 542                 if( (key == LEFT || key == ',') && !ctrl_down() ) {
 543                         panel->panel_prev_edit(0);
 544                         return 1;
 545                 }
 546                 if( key == ',' && ctrl_down() ) {
 547                         panel->panel_prev_edit(1);
 548                         return 1;
 549                 }
 550         }
 551         return 0;
 552 }
 553 int EditPrevEdit::handle_event()
 554 {
 555         int cut = ctrl_down() && alt_down();
 556         panel->panel_prev_edit(cut);
 557         return 1;
 558 }
 559
 560 //next_edit
 561 EditNextEdit::EditNextEdit(MWindow *mwindow,
 562         EditPanel *panel, int x, int y)
 563  : BC_Button(x, y, mwindow->theme->get_image_set("nextedit"))
 564 {
 565         this->mwindow = mwindow;
 566         this->panel = panel;
 567         set_tooltip(_("Next edit ( alt -> )"));
 568 }
 569 EditNextEdit::~EditNextEdit()
 570 {
 571 }
 572 int EditNextEdit::keypress_event()
 573 {
 574         if( alt_down() ) {
 575                 int key = get_keypress();
 576                 if( (key == RIGHT || key == '.') && !ctrl_down() ) {
 577                         panel->panel_next_edit(0);
 578                         return 1;
 579                 }
 580                 if( key == '.' && ctrl_down() ) {
 581                         panel->panel_next_edit(1);
 582                         return 1;
 583                 }
 584         }
 585         return 0;
 586 }
 587 int EditNextEdit::handle_event()
 588 {
 589         int cut = ctrl_down() && alt_down();
 590         panel->panel_next_edit(cut);
 591         return 1;
 592 }
 593
 594 //copy_selection
 595 EditCopy::EditCopy(MWindow *mwindow, EditPanel *panel, int x, int y)
 596  : BC_Button(x, y, mwindow->theme->get_image_set("copy"))
 597 {
 598         this->mwindow = mwindow;
 599         this->panel = panel;
 600         set_tooltip(_("Copy ( c )"));
 601 }
 602 EditCopy::~EditCopy()
 603 {
 604 }
 605
 606 int EditCopy::keypress_event()
 607 {
 608         if( alt_down() ) return 0;
 609         if( (get_keypress() == 'c' && !ctrl_down()) ||
 610             (panel->is_vwindow() && get_keypress() == 'C') ) {
 611                 return handle_event();
 612         }
 613         return 0;
 614 }
 615 int EditCopy::handle_event()
 616 {
 617         panel->panel_copy_selection();
 618         return 1;
 619 }
 620
 621 //overwrite_selection
 622 EditOverwrite::EditOverwrite(MWindow *mwindow, EditPanel *panel, int x, int y)
 623  : BC_Button(x, y, mwindow->theme->overwrite_data)
 624 {
 625         this->mwindow = mwindow;
 626         this->panel = panel;
 627         set_tooltip(_("Overwrite ( b )"));
 628 }
 629 EditOverwrite::~EditOverwrite()
 630 {
 631 }
 632 int EditOverwrite::handle_event()
 633 {
 634         panel->panel_overwrite_selection();
 635         return 1;
 636 }
 637 int EditOverwrite::keypress_event()
 638 {
 639         if( alt_down() ) return 0;
 640         if( get_keypress() == 'b' ||
 641             (panel->is_vwindow() && get_keypress() == 'B') ) {
 642                 handle_event();
 643                 return 1;
 644         }
 645         return 0;
 646 }
 647
 648 //set_inpoint
 649 //unset_inoutpoint
 650 EditInPoint::EditInPoint(MWindow *mwindow, EditPanel *panel, int x, int y)
 651  : BC_Button(x, y, mwindow->theme->get_image_set("inbutton"))
 652 {
 653         this->mwindow = mwindow;
 654         this->panel = panel;
 655         set_tooltip(_("In point ( [ or < )"));
 656 }
 657 EditInPoint::~EditInPoint()
 658 {
 659 }
 660 int EditInPoint::handle_event()
 661 {
 662         panel->panel_set_inpoint();
 663         return 1;
 664 }
 665 int EditInPoint::keypress_event()
 666 {
 667         int key = get_keypress();
 668         if( ctrl_down() ) {
 669                 if( key == 't' ) {
 670                         panel->panel_unset_inoutpoint();
 671                         return 1;
 672                 }
 673         }
 674         else if( !alt_down() ) {
 675                 if( key == '[' || key == '<' ) {
 676                         panel->panel_set_inpoint();
 677                         return 1;
 678                 }
 679         }
 680         return 0;
 681 }
 682
 683 //set_outpoint
 684 //unset_inoutpoint
 685 EditOutPoint::EditOutPoint(MWindow *mwindow, EditPanel *panel, int x, int y)
 686  : BC_Button(x, y, mwindow->theme->get_image_set("outbutton"))
 687 {
 688         this->mwindow = mwindow;
 689         this->panel = panel;
 690         set_tooltip(_("Out point ( ] or > )"));
 691 }
 692 EditOutPoint::~EditOutPoint()
 693 {
 694 }
 695 int EditOutPoint::handle_event()
 696 {
 697         panel->panel_set_outpoint();
 698         return 1;
 699 }
 700 int EditOutPoint::keypress_event()
 701 {
 702         int key = get_keypress();
 703         if( ctrl_down() ) {
 704                 if(  key == 't' ) {
 705                         panel->panel_unset_inoutpoint();
 706                         return 1;
 707                 }
 708         }
 709         else if( !alt_down() ) {
 710                 if( key == ']' || key == '>' ) {
 711                         panel->panel_set_outpoint();
 712                         return 1;
 713                 }
 714         }
 715         return 0;
 716 }
 717
 718 //splice_selection
 719 EditSplice::EditSplice(MWindow *mwindow, EditPanel *panel, int x, int y)
 720  : BC_Button(x, y, mwindow->theme->splice_data)
 721 {
 722         this->mwindow = mwindow;
 723         this->panel = panel;
 724         set_tooltip(_("Splice ( v )"));
 725 }
 726 EditSplice::~EditSplice()
 727 {
 728 }
 729 int EditSplice::handle_event()
 730 {
 731         panel->panel_splice_selection();
 732         return 1;
 733 }
 734 int EditSplice::keypress_event()
 735 {
 736         if( alt_down() ) return 0;
 737         if( (get_keypress() == 'v' && !ctrl_down()) ||
 738             (panel->is_vwindow() && get_keypress() == 'V') ) {
 739                 handle_event();
 740                 return 1;
 741         }
 742         return 0;
 743 }
 744
 745 //to_clip
 746 EditToClip::EditToClip(MWindow *mwindow, EditPanel *panel, int x, int y)
 747  : BC_Button(x, y, mwindow->theme->get_image_set("toclip"))
 748 {
 749         this->mwindow = mwindow;
 750         this->panel = panel;
 751         set_tooltip(_("To clip ( i )"));
 752 }
 753 EditToClip::~EditToClip()
 754 {
 755 }
 756 int EditToClip::handle_event()
 757 {
 758         panel->panel_to_clip();
 759         return 1;
 760 }
 761
 762 int EditToClip::keypress_event()
 763 {
 764         if( alt_down() ) return 0;
 765         if( get_keypress() == 'i' ||
 766             (panel->is_vwindow() && get_keypress() == 'I') ) {
 767                 handle_event();
 768                 return 1;
 769         }
 770         return 0;
 771 }
 772
 773 //cut
 774 EditCut::EditCut(MWindow *mwindow, EditPanel *panel, int x, int y)
 775  : BC_Button(x, y, mwindow->theme->get_image_set("cut"))
 776 {
 777         this->mwindow = mwindow;
 778         this->panel = panel;
 779         set_tooltip(_("Split | Cut ( x )"));
 780 }
 781 EditCut::~EditCut()
 782 {
 783 }
 784 int EditCut::keypress_event()
 785 {
 786         if( ctrl_down() || shift_down() || alt_down() )
 787                 return 0;
 788         if( get_keypress() == 'x' )
 789                 return handle_event();
 790         return 0;
 791 }
 792
 793 int EditCut::handle_event()
 794 {
 795         panel->panel_cut();
 796         return 1;
 797 }
 798
 799 //paste
 800 EditPaste::EditPaste(MWindow *mwindow, EditPanel *panel, int x, int y)
 801  : BC_Button(x, y, mwindow->theme->get_image_set("paste"))
 802 {
 803         this->mwindow = mwindow;
 804         this->panel = panel;
 805         set_tooltip(_("Paste ( v )"));
 806 }
 807 EditPaste::~EditPaste()
 808 {
 809 }
 810
 811 int EditPaste::keypress_event()
 812 {
 813         if( get_keypress() == 'v' && !ctrl_down() )
 814                 return handle_event();
 815         return 0;
 816 }
 817 int EditPaste::handle_event()
 818 {
 819         panel->panel_paste();
 820         return 1;
 821 }
 822
 823 //fit_selection
 824 EditFit::EditFit(MWindow *mwindow, EditPanel *panel, int x, int y)
 825  : BC_Button(x, y, mwindow->theme->get_image_set("fit"))
 826 {
 827         this->mwindow = mwindow;
 828         this->panel = panel;
 829         set_tooltip(_("Fit selection to display ( f )"));
 830 }
 831 EditFit::~EditFit()
 832 {
 833 }
 834 int EditFit::keypress_event()
 835 {
 836         if( !alt_down() && get_keypress() == 'f' ) {
 837                 handle_event();
 838                 return 1;
 839         }
 840         return 0;
 841 }
 842 int EditFit::handle_event()
 843 {
 844         panel->panel_fit_selection();
 845         return 1;
 846 }
 847
 848 //fit_autos
 849 EditFitAutos::EditFitAutos(MWindow *mwindow, EditPanel *panel, int x, int y)
 850  : BC_Button(x, y, mwindow->theme->get_image_set("fitautos"))
 851 {
 852         this->mwindow = mwindow;
 853         this->panel = panel;
 854         set_tooltip(_("Fit all autos to display ( Alt + f )"));
 855 }
 856 EditFitAutos::~EditFitAutos()
 857 {
 858 }
 859 int EditFitAutos::keypress_event()
 860 {
 861         if( get_keypress() == 'f' && alt_down() ) {
 862                 panel->panel_fit_autos(!ctrl_down() ? 1 : 0);
 863                 return 1;
 864         }
 865         return 0;
 866 }
 867 int EditFitAutos::handle_event()
 868 {
 869         panel->panel_fit_autos(1);
 870         return 1;
 871 }
 872
 873 //set_editing_mode
 874 ArrowButton::ArrowButton(MWindow *mwindow, EditPanel *panel, int x, int y)
 875  : BC_Toggle(x, y,
 876         mwindow->theme->get_image_set("arrow"),
 877         mwindow->edl->session->editing_mode == EDITING_ARROW,
 878         "", 0, 0, 0)
 879 {
 880         this->mwindow = mwindow;
 881         this->panel = panel;
 882         set_tooltip(_("Drag and drop editing mode"));
 883 }
 884
 885 int ArrowButton::handle_event()
 886 {
 887         update(1);
 888         panel->ibeam->update(0);
 889         panel->panel_set_editing_mode(EDITING_ARROW);
 890 // Nothing after this
 891         return 1;
 892 }
 893
 894 IBeamButton::IBeamButton(MWindow *mwindow, EditPanel *panel, int x, int y)
 895  : BC_Toggle(x, y,
 896         mwindow->theme->get_image_set("ibeam"),
 897         mwindow->edl->session->editing_mode == EDITING_IBEAM,
 898         "", 0, 0, 0)
 899 {
 900         this->mwindow = mwindow;
 901         this->panel = panel;
 902         set_tooltip(_("Cut and paste editing mode"));
 903 }
 904
 905 int IBeamButton::handle_event()
 906 {
 907         update(1);
 908         panel->arrow->update(0);
 909         panel->panel_set_editing_mode(EDITING_IBEAM);
 910 // Nothing after this
 911         return 1;
 912 }
 913
 914 //set_auto_keyframes
 915 KeyFrameButton::KeyFrameButton(MWindow *mwindow, EditPanel *panel, int x, int y)
 916  : BC_Toggle(x, y,
 917         mwindow->theme->get_image_set("autokeyframe"),
 918         mwindow->edl->session->auto_keyframes,
 919         "", 0, 0, 0)
 920 {
 921         this->mwindow = mwindow;
 922         this->panel = panel;
 923         set_tooltip(_("Generate keyframes while tweeking (j)"));
 924 }
 925
 926 int KeyFrameButton::handle_event()
 927 {
 928         panel->panel_set_auto_keyframes(get_value());
 929         return 1;
 930 }
 931
 932 int KeyFrameButton::keypress_event()
 933 {
 934         int key = get_keypress();
 935         if( key == 'j' && !ctrl_down() && !shift_down() && !alt_down() ) {
 936                 int value = get_value() ? 0 : 1;
 937                 update(value);
 938                 panel->panel_set_auto_keyframes(value);
 939                 return 1;
 940         }
 941         return 0;
 942 }
 943
 944 //set_labels_follow_edits
 945 LockLabelsButton::LockLabelsButton(MWindow *mwindow, EditPanel *panel, int x, int y)
 946  : BC_Toggle(x, y,
 947         mwindow->theme->get_image_set("locklabels"),
 948         mwindow->edl->session->labels_follow_edits,
 949         "", 0, 0, 0)
 950 {
 951         this->mwindow = mwindow;
 952         this->panel = panel;
 953         set_tooltip(_("Lock labels from moving with edits"));
 954 }
 955
 956 int LockLabelsButton::handle_event()
 957 {
 958         panel->panel_set_labels_follow_edits(get_value());
 959         return 1;
 960 }
 961
 962
 963
 964 EditManualGoto::EditManualGoto(MWindow *mwindow, EditPanel *panel, int x, int y)
 965  : BC_Button(x, y, mwindow->theme->get_image_set("goto"))
 966 {
 967         this->mwindow = mwindow;
 968         this->panel = panel;
 969         mangoto = new ManualGoto(mwindow, panel);
 970         set_tooltip(_("Manual goto ( g )"));
 971 }
 972 EditManualGoto::~EditManualGoto()
 973 {
 974         delete mangoto;
 975 }
 976 int EditManualGoto::handle_event()
 977 {
 978         mangoto->start();
 979         return 1;
 980 }
 981
 982 int EditManualGoto::keypress_event()
 983 {
 984         if( get_keypress() == 'g' ) {
 985                 handle_event();
 986                 return 1;
 987         }
 988         return 0;
 989 }
 990
 991
 992 EditClick2Play::EditClick2Play(MWindow *mwindow, EditPanel *panel, int x, int y)
 993  : BC_Toggle(x, y, mwindow->theme->get_image_set("playpatch_data"),
 994     !panel->is_vwindow() ?
 995         mwindow->edl->session->cwindow_click2play :
 996         mwindow->edl->session->vwindow_click2play)
 997 {
 998         this->mwindow = mwindow;
 999         this->panel = panel;
1000         set_tooltip(_("Click to play (p)"));
1001 }
1002 int EditClick2Play::handle_event()
1003 {
1004         int value = get_value();
1005         panel->set_click_to_play(value);
1006         return 1;
1007 }
1008 int EditClick2Play::keypress_event()
1009 {
1010         int key = get_keypress();
1011         if( key == 'p' && !ctrl_down() && !shift_down() && !alt_down() ) {
1012                 int value = get_value() ? 0 : 1;
1013                 update(value);
1014                 panel->set_click_to_play(value);
1015                 return 1;
1016         }
1017         return 0;
1018 }
1019
1020
1021 EditCommercial::EditCommercial(MWindow *mwindow, EditPanel *panel, int x, int y)
1022  : BC_Button(x, y, mwindow->theme->get_image_set("commercial"))
1023 {
1024         this->mwindow = mwindow;
1025         this->panel = panel;
1026         set_tooltip(_("Commercial ( shift A )"));
1027 }
1028 EditCommercial::~EditCommercial()
1029 {
1030 }
1031 int EditCommercial::keypress_event()
1032 {
1033         if( ctrl_down() || !shift_down() || alt_down() )
1034                 return 0;
1035         if( get_keypress() == 'A' )
1036                 return handle_event();
1037         return 0;
1038 }
1039
1040 int EditCommercial::handle_event()
1041 {
1042         int have_mwindow_lock = mwindow->gui->get_window_lock();
1043         if( have_mwindow_lock )
1044                 mwindow->gui->unlock_window();
1045         mwindow->commit_commercial();
1046         if( !mwindow->put_commercial() ) {
1047                 mwindow->gui->lock_window("EditCommercial::handle_event 1");
1048                 mwindow->cut();
1049                 if( !have_mwindow_lock )
1050                         mwindow->gui->unlock_window();
1051                 mwindow->activate_commercial();
1052                 return 1;
1053         }
1054         mwindow->undo_commercial();
1055         if( have_mwindow_lock )
1056                 mwindow->gui->lock_window("EditCommercial::handle_event 2");
1057         return 1;
1058 }
1059
1060
1061 EditUndo::EditUndo(MWindow *mwindow, EditPanel *panel, int x, int y)
1062  : BC_Button(x, y, mwindow->theme->get_image_set("undo"))
1063 {
1064         this->mwindow = mwindow;
1065         this->panel = panel;
1066         set_tooltip(_("Undo ( z )"));
1067 }
1068 EditUndo::~EditUndo()
1069 {
1070 }
1071 int EditUndo::keypress_event()
1072 {
1073         if( ctrl_down() || shift_down() || alt_down() )
1074                 return 0;
1075         if( get_keypress() == 'z' )
1076                 return handle_event();
1077         return 0;
1078 }
1079 int EditUndo::handle_event()
1080 {
1081         mwindow->undo_entry(panel->subwindow);
1082         return 1;
1083 }
1084
1085 EditRedo::EditRedo(MWindow *mwindow, EditPanel *panel, int x, int y)
1086  : BC_Button(x, y, mwindow->theme->get_image_set("redo"))
1087 {
1088         this->mwindow = mwindow;
1089         this->panel = panel;
1090         set_tooltip(_("Redo ( shift Z )"));
1091 }
1092 EditRedo::~EditRedo()
1093 {
1094 }
1095 int EditRedo::keypress_event()
1096 {
1097         if( ctrl_down() || !shift_down() || alt_down() )
1098                 return 0;
1099         if( get_keypress() == 'Z' )
1100                 return handle_event();
1101         return 0;
1102 }
1103 int EditRedo::handle_event()
1104 {
1105         mwindow->redo_entry(panel->subwindow);
1106         return 1;
1107 }
1108