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 snap = subwindow->ctrl_down() && subwindow->ctrl_down();
 343
 344         int have_mwindow_lock = mwindow->gui->get_window_lock();
 345         int have_subwindow_lock =
 346                  subwindow->get_top_level() == mwindow->gui->get_top_level() ?
 347                          0 : subwindow->get_window_lock();
 348         if(have_mwindow_lock)
 349                 mwindow->gui->unlock_window();
 350         if(have_subwindow_lock)
 351                 subwindow->unlock_window();
 352
 353         mwindow->gui->mbuttons->transport->handle_transport(STOP, 1, 0, 0);
 354
 355         if(have_subwindow_lock)
 356                 subwindow->lock_window("EditPanel::prev_label 1");
 357
 358         mwindow->gui->lock_window("EditPanel::prev_label 2");
 359
 360         if( snap )
 361                 mwindow->snap_left_label();
 362         else
 363                 mwindow->prev_label(shift_down);
 364
 365         if(!have_mwindow_lock)
 366                 mwindow->gui->unlock_window();
 367 }
 368
 369 void EditPanel::next_label()
 370 {
 371         int shift_down = subwindow->shift_down();
 372         int snap = subwindow->ctrl_down() && subwindow->ctrl_down();
 373
 374         int have_mwindow_lock = mwindow->gui->get_window_lock();
 375         int have_subwindow_lock =
 376                  subwindow->get_top_level() == mwindow->gui->get_top_level() ?
 377                          0 : subwindow->get_window_lock();
 378         if(have_mwindow_lock)
 379                 mwindow->gui->unlock_window();
 380         if(have_subwindow_lock)
 381                 subwindow->unlock_window();
 382
 383         mwindow->gui->mbuttons->transport->handle_transport(STOP, 1, 0, 0);
 384
 385         if(have_subwindow_lock)
 386                 subwindow->lock_window("EditPanel::next_label 1");
 387
 388         mwindow->gui->lock_window("EditPanel::next_label 2");
 389
 390         if( snap )
 391                 mwindow->snap_right_label();
 392         else
 393                 mwindow->next_label(shift_down);
 394
 395         if(!have_mwindow_lock)
 396                 mwindow->gui->unlock_window();
 397 }
 398
 399
 400
 401 void EditPanel::prev_edit()
 402 {
 403         int shift_down = subwindow->shift_down();
 404         int snap = subwindow->ctrl_down() && subwindow->ctrl_down();
 405
 406         int have_mwindow_lock = mwindow->gui->get_window_lock();
 407         int have_subwindow_lock =
 408                  subwindow->get_top_level() == mwindow->gui->get_top_level() ?
 409                          0 : subwindow->get_window_lock();
 410         if(have_mwindow_lock)
 411                 mwindow->gui->unlock_window();
 412         if(have_subwindow_lock)
 413                 subwindow->unlock_window();
 414
 415         mwindow->gui->mbuttons->transport->handle_transport(STOP, 1, 0, 0);
 416
 417         if(have_subwindow_lock)
 418                 subwindow->lock_window("EditPanel::prev_edit 1");
 419
 420         mwindow->gui->lock_window("EditPanel::prev_edit 2");
 421
 422         if( snap )
 423                 mwindow->snap_left_edit();
 424         else
 425                 mwindow->prev_edit_handle(shift_down);
 426
 427         if(!have_mwindow_lock)
 428                 mwindow->gui->unlock_window();
 429 }
 430
 431 void EditPanel::next_edit()
 432 {
 433         int shift_down = subwindow->shift_down();
 434         int snap = subwindow->ctrl_down() && subwindow->ctrl_down();
 435
 436         int have_mwindow_lock = mwindow->gui->get_window_lock();
 437         int have_subwindow_lock =
 438                  subwindow->get_top_level() == mwindow->gui->get_top_level() ?
 439                          0 : subwindow->get_window_lock();
 440         if(have_mwindow_lock)
 441                 mwindow->gui->unlock_window();
 442         if(have_subwindow_lock)
 443                 subwindow->unlock_window();
 444
 445         mwindow->gui->mbuttons->transport->handle_transport(STOP, 1, 0, 0);
 446
 447         if(have_subwindow_lock)
 448                 subwindow->lock_window("EditPanel::next_edit 1");
 449
 450         mwindow->gui->lock_window("EditPanel::next_edit 2");
 451
 452         if( snap )
 453                 mwindow->snap_right_edit();
 454         else
 455                 mwindow->next_edit_handle(shift_down);
 456
 457         if(!have_mwindow_lock)
 458                 mwindow->gui->unlock_window();
 459 }
 460
 461
 462 double EditPanel::get_position()
 463 {
 464         EDL *edl = mwindow->edl;
 465         return !edl ? 0 : edl->local_session->get_selectionstart(1);
 466 }
 467
 468 void EditPanel::set_position(double position)
 469 {
 470         EDL *edl = mwindow->edl;
 471         if( !edl ) return;
 472         if( position != get_position() ) {
 473                 if( position < 0 ) position = 0;
 474                 edl->local_session->set_selectionstart(position);
 475                 edl->local_session->set_selectionend(position);
 476                 mwindow->gui->lock_window();
 477                 mwindow->find_cursor();
 478                 mwindow->gui->update(1, 1, 1, 1, 1, 1, 0);
 479                 mwindow->gui->unlock_window();
 480                 mwindow->cwindow->update(1, 0, 0, 0, 0);
 481         }
 482 }
 483
 484
 485
 486
 487
 488
 489
 490 void EditPanel::reposition_buttons(int x, int y)
 491 {
 492         this->x = x;
 493         this->y = y;
 494         x1 = x, y1 = y;
 495
 496         if(use_editing_mode)
 497         {
 498                 arrow->reposition_window(x1, y1);
 499                 x1 += arrow->get_w();
 500                 ibeam->reposition_window(x1, y1);
 501                 x1 += ibeam->get_w();
 502                 x1 += mwindow->theme->toggle_margin;
 503         }
 504
 505         if(use_keyframe)
 506         {
 507                 keyframe->reposition_window(x1, y1);
 508                 x1 += keyframe->get_w();
 509         }
 510
 511         if(use_locklabels)
 512         {
 513                 locklabels->reposition_window(x1,y1);
 514                 x1 += locklabels->get_w();
 515         }
 516
 517         if(use_keyframe || use_locklabels)
 518                 x1 += mwindow->theme->toggle_margin;
 519
 520         inpoint->reposition_window(x1, y1);
 521         x1 += inpoint->get_w();
 522         outpoint->reposition_window(x1, y1);
 523         x1 += outpoint->get_w();
 524         if(use_splice)
 525         {
 526                 splice->reposition_window(x1, y1);
 527                 x1 += splice->get_w();
 528         }
 529         if(use_overwrite)
 530         {
 531                 overwrite->reposition_window(x1, y1);
 532                 x1 += overwrite->get_w();
 533         }
 534         if(use_lift)
 535         {
 536                 lift->reposition_window(x1, y1);
 537                 x1 += lift->get_w();
 538         }
 539         if(use_extract)
 540         {
 541                 extract->reposition_window(x1, y1);
 542                 x1 += extract->get_w();
 543         }
 544         if(use_toclip)
 545         {
 546                 clip->reposition_window(x1, y1);
 547                 x1 += clip->get_w();
 548         }
 549         if(use_cut)
 550         {
 551                 cut->reposition_window(x1, y1);
 552                 x1 += cut->get_w();
 553         }
 554         if(use_copy)
 555         {
 556                 copy->reposition_window(x1, y1);
 557                 x1 += copy->get_w();
 558         }
 559         if(use_paste)
 560         {
 561                 paste->reposition_window(x1, y1);
 562                 x1 += paste->get_w();
 563         }
 564
 565         if(use_meters)
 566         {
 567                 meters->reposition_window(x1, y1);
 568                 x1 += meters->get_w();
 569         }
 570
 571         if(use_labels)
 572         {
 573                 labelbutton->reposition_window(x1, y1);
 574                 x1 += labelbutton->get_w();
 575                 prevlabel->reposition_window(x1, y1);
 576                 x1 += prevlabel->get_w();
 577                 nextlabel->reposition_window(x1, y1);
 578                 x1 += nextlabel->get_w();
 579         }
 580
 581         if(prevedit)
 582         {
 583                 prevedit->reposition_window(x1, y1);
 584                 x1 += prevedit->get_w();
 585         }
 586
 587         if(nextedit)
 588         {
 589                 nextedit->reposition_window(x1, y1);
 590                 x1 += nextedit->get_w();
 591         }
 592
 593         if(use_fit)
 594         {
 595                 fit->reposition_window(x1, y1);
 596                 x1 += fit->get_w();
 597                 fit_autos->reposition_window(x1, y1);
 598                 x1 += fit_autos->get_w();
 599         }
 600
 601         if(use_undo)
 602         {
 603                 undo->reposition_window(x1, y1);
 604                 x1 += undo->get_w();
 605                 redo->reposition_window(x1, y1);
 606                 x1 += redo->get_w();
 607         }
 608
 609         mangoto->reposition_window(x1, y1);
 610         x1 += mangoto->get_w();
 611 }
 612
 613
 614
 615 void EditPanel::create_objects()
 616 {
 617         create_buttons();
 618 }
 619
 620 int EditPanel::get_w()
 621 {
 622         return x1 - x;
 623 }
 624
 625
 626 void EditPanel::copy_selection()
 627 {
 628         mwindow->copy();
 629 }
 630
 631 void EditPanel::splice_selection()
 632 {
 633 }
 634
 635 void EditPanel::overwrite_selection()
 636 {
 637 }
 638
 639 void EditPanel::set_inpoint()
 640 {
 641         mwindow->set_inpoint(1);
 642 }
 643
 644 void EditPanel::set_outpoint()
 645 {
 646         mwindow->set_outpoint(1);
 647 }
 648
 649 void EditPanel::clear_inpoint()
 650 {
 651         mwindow->delete_inpoint();
 652 }
 653
 654 void EditPanel::clear_outpoint()
 655 {
 656         mwindow->delete_outpoint();
 657 }
 658
 659
 660 EditInPoint::EditInPoint(MWindow *mwindow, EditPanel *panel, int x, int y)
 661  : BC_Button(x, y, mwindow->theme->get_image_set("inbutton"))
 662 {
 663         this->mwindow = mwindow;
 664         this->panel = panel;
 665         set_tooltip(_("In point ( [ )"));
 666 }
 667 EditInPoint::~EditInPoint()
 668 {
 669 }
 670 int EditInPoint::handle_event()
 671 {
 672         panel->set_inpoint();
 673         return 1;
 674 }
 675 int EditInPoint::keypress_event()
 676 {
 677         if(get_keypress() == '[')
 678         {
 679                 panel->set_inpoint();
 680                 return 1;
 681         }
 682         return 0;
 683 }
 684
 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 ( ] )"));
 691 }
 692 EditOutPoint::~EditOutPoint()
 693 {
 694 }
 695 int EditOutPoint::handle_event()
 696 {
 697         panel->set_outpoint();
 698         return 1;
 699 }
 700 int EditOutPoint::keypress_event()
 701 {
 702         if(get_keypress() == ']')
 703         {
 704                 panel->set_outpoint();
 705                 return 1;
 706         }
 707         return 0;
 708 }
 709
 710
 711 EditNextLabel::EditNextLabel(MWindow *mwindow,
 712         EditPanel *panel,
 713         int x,
 714         int y,
 715         int is_mwindow)
 716  : BC_Button(x, y, mwindow->theme->get_image_set("nextlabel"))
 717 {
 718         this->mwindow = mwindow;
 719         this->panel = panel;
 720         this->is_mwindow = is_mwindow;
 721         set_tooltip(_("Next label ( ctrl -> )"));
 722 }
 723 EditNextLabel::~EditNextLabel()
 724 {
 725 }
 726 int EditNextLabel::keypress_event()
 727 {
 728         if( ctrl_down() && get_keypress() == (!alt_down() ? RIGHT : '>') )
 729                 return handle_event();
 730         return 0;
 731 }
 732 int EditNextLabel::handle_event()
 733 {
 734         panel->next_label();
 735         return 1;
 736 }
 737
 738 EditPrevLabel::EditPrevLabel(MWindow *mwindow,
 739         EditPanel *panel,
 740         int x,
 741         int y,
 742         int is_mwindow)
 743  : BC_Button(x, y, mwindow->theme->get_image_set("prevlabel"))
 744 {
 745         this->mwindow = mwindow;
 746         this->panel = panel;
 747         this->is_mwindow = is_mwindow;
 748         set_tooltip(_("Previous label ( ctrl <- )"));
 749 }
 750 EditPrevLabel::~EditPrevLabel()
 751 {
 752 }
 753 int EditPrevLabel::keypress_event()
 754 {
 755         if( ctrl_down() && get_keypress() == (!alt_down() ? LEFT : '<') )
 756                 return handle_event();
 757         return 0;
 758 }
 759 int EditPrevLabel::handle_event()
 760 {
 761         panel->prev_label();
 762         return 1;
 763 }
 764
 765
 766
 767 EditNextEdit::EditNextEdit(MWindow *mwindow,
 768         EditPanel *panel,
 769         int x,
 770         int y,
 771         int is_mwindow)
 772  : BC_Button(x, y, mwindow->theme->get_image_set("nextedit"))
 773 {
 774         this->mwindow = mwindow;
 775         this->panel = panel;
 776         this->is_mwindow = is_mwindow;
 777         set_tooltip(_("Next edit ( alt -> )"));
 778 }
 779 EditNextEdit::~EditNextEdit()
 780 {
 781 }
 782 int EditNextEdit::keypress_event()
 783 {
 784         if( alt_down() && get_keypress() == (!ctrl_down() ? RIGHT : '.') )
 785                 return handle_event();
 786         return 0;
 787 }
 788 int EditNextEdit::handle_event()
 789 {
 790         panel->next_edit();
 791         return 1;
 792 }
 793
 794 EditPrevEdit::EditPrevEdit(MWindow *mwindow,
 795         EditPanel *panel,
 796         int x,
 797         int y,
 798         int is_mwindow)
 799  : BC_Button(x, y, mwindow->theme->get_image_set("prevedit"))
 800 {
 801         this->mwindow = mwindow;
 802         this->panel = panel;
 803         this->is_mwindow = is_mwindow;
 804         set_tooltip(_("Previous edit (alt <- )"));
 805 }
 806 EditPrevEdit::~EditPrevEdit()
 807 {
 808 }
 809 int EditPrevEdit::keypress_event()
 810 {
 811         if( alt_down() && get_keypress() == (!ctrl_down() ? LEFT : ',') )
 812                 return handle_event();
 813         return 0;
 814 }
 815 int EditPrevEdit::handle_event()
 816 {
 817         panel->prev_edit();
 818         return 1;
 819 }
 820
 821
 822
 823 EditLift::EditLift(MWindow *mwindow, EditPanel *panel, int x, int y)
 824  : BC_Button(x, y, mwindow->theme->lift_data)
 825 {
 826         this->mwindow = mwindow;
 827         this->panel = panel;
 828         set_tooltip(_("Lift"));
 829 }
 830 EditLift::~EditLift()
 831 {
 832 }
 833 int EditLift::handle_event()
 834 {
 835         return 1;
 836 }
 837
 838 EditOverwrite::EditOverwrite(MWindow *mwindow, EditPanel *panel, int x, int y)
 839  : BC_Button(x, y, mwindow->theme->overwrite_data)
 840 {
 841         this->mwindow = mwindow;
 842         this->panel = panel;
 843         set_tooltip(_("Overwrite ( b )"));
 844 }
 845 EditOverwrite::~EditOverwrite()
 846 {
 847 }
 848 int EditOverwrite::handle_event()
 849 {
 850         panel->overwrite_selection();
 851         return 1;
 852 }
 853 int EditOverwrite::keypress_event()
 854 {
 855         if(get_keypress() == 'b')
 856         {
 857                 handle_event();
 858                 return 1;
 859         }
 860         return 0;
 861 }
 862
 863 EditExtract::EditExtract(MWindow *mwindow, EditPanel *panel, int x, int y)
 864  : BC_Button(x, y, mwindow->theme->extract_data)
 865 {
 866         this->mwindow = mwindow;
 867         this->panel = panel;
 868         set_tooltip(_("Extract"));
 869 }
 870 EditExtract::~EditExtract()
 871 {
 872 }
 873 int EditExtract::handle_event()
 874 {
 875 //      mwindow->extract_selection();
 876         return 1;
 877 }
 878
 879 EditToClip::EditToClip(MWindow *mwindow, EditPanel *panel, int x, int y)
 880  : BC_Button(x, y, mwindow->theme->get_image_set("toclip"))
 881 {
 882         this->mwindow = mwindow;
 883         this->panel = panel;
 884         set_tooltip(_("To clip ( i )"));
 885 }
 886 EditToClip::~EditToClip()
 887 {
 888 }
 889 int EditToClip::handle_event()
 890 {
 891         panel->to_clip();
 892         return 1;
 893 }
 894
 895 int EditToClip::keypress_event()
 896 {
 897         if(get_keypress() == 'i' && !alt_down())
 898         {
 899                 handle_event();
 900                 return 1;
 901         }
 902         return 0;
 903 }
 904
 905 EditManualGoto::EditManualGoto(MWindow *mwindow, EditPanel *panel, int x, int y)
 906  : BC_Button(x, y, mwindow->theme->get_image_set("goto"))
 907 {
 908         this->mwindow = mwindow;
 909         this->panel = panel;
 910         mangoto = new ManualGoto(mwindow, panel);
 911         set_tooltip(_("Manual goto ( g )"));
 912 }
 913 EditManualGoto::~EditManualGoto()
 914 {
 915         delete mangoto;
 916 }
 917 int EditManualGoto::handle_event()
 918 {
 919         mangoto->start();
 920         return 1;
 921 }
 922
 923 int EditManualGoto::keypress_event()
 924 {
 925         if(get_keypress() == 'g')
 926         {
 927                 handle_event();
 928                 return 1;
 929         }
 930         return 0;
 931 }
 932
 933
 934 EditSplice::EditSplice(MWindow *mwindow, EditPanel *panel, int x, int y)
 935  : BC_Button(x, y, mwindow->theme->splice_data)
 936 {
 937         this->mwindow = mwindow;
 938         this->panel = panel;
 939         set_tooltip(_("Splice ( v )"));
 940 }
 941 EditSplice::~EditSplice()
 942 {
 943 }
 944 int EditSplice::handle_event()
 945 {
 946         panel->splice_selection();
 947         return 1;
 948 }
 949 int EditSplice::keypress_event()
 950 {
 951         if(get_keypress() == 'v')
 952         {
 953                 handle_event();
 954                 return 1;
 955         }
 956         return 0;
 957 }
 958
 959 EditCut::EditCut(MWindow *mwindow, EditPanel *panel, int x, int y)
 960  : BC_Button(x, y, mwindow->theme->get_image_set("cut"))
 961 {
 962         this->mwindow = mwindow;
 963         this->panel = panel;
 964         set_tooltip(_("Cut ( x )"));
 965 }
 966 EditCut::~EditCut()
 967 {
 968 }
 969 int EditCut::keypress_event()
 970 {
 971         if(get_keypress() == 'x')
 972                 return handle_event();
 973         return 0;
 974 }
 975
 976 int EditCut::handle_event()
 977 {
 978         int have_mwindow_lock = mwindow->gui->get_window_lock();
 979         if(!have_mwindow_lock)
 980                 mwindow->gui->lock_window("EditCut::handle_event");
 981
 982         mwindow->cut();
 983
 984         if(!have_mwindow_lock)
 985                 mwindow->gui->unlock_window();
 986         return 1;
 987 }
 988
 989 EditCommercial::EditCommercial(MWindow *mwindow, EditPanel *panel, int x, int y)
 990  : BC_Button(x, y, mwindow->theme->get_image_set("commercial"))
 991 {
 992         this->mwindow = mwindow;
 993         this->panel = panel;
 994         set_tooltip(_("Commercial ( shift X )"));
 995 }
 996 EditCommercial::~EditCommercial()
 997 {
 998 }
 999 int EditCommercial::keypress_event()
1000 {
1001         if(get_keypress() == 'X')
1002                 return handle_event();
1003         return 0;
1004 }
1005
1006 int EditCommercial::handle_event()
1007 {
1008         int have_mwindow_lock = mwindow->gui->get_window_lock();
1009         if(have_mwindow_lock)
1010                 mwindow->gui->unlock_window();
1011         mwindow->commit_commercial();
1012         if( !mwindow->put_commercial() ) {
1013                 mwindow->gui->lock_window("EditCommercial::handle_event 1");
1014                 mwindow->cut();
1015                 if(!have_mwindow_lock)
1016                         mwindow->gui->unlock_window();
1017                 mwindow->activate_commercial();
1018                 return 1;
1019         }
1020         mwindow->undo_commercial();
1021         if(have_mwindow_lock)
1022                 mwindow->gui->lock_window("EditCommercial::handle_event 2");
1023         return 1;
1024 }
1025
1026 EditCopy::EditCopy(MWindow *mwindow, EditPanel *panel, int x, int y)
1027  : BC_Button(x, y, mwindow->theme->get_image_set("copy"))
1028 {
1029         this->mwindow = mwindow;
1030         this->panel = panel;
1031         set_tooltip(_("Copy ( c )"));
1032 }
1033 EditCopy::~EditCopy()
1034 {
1035 }
1036
1037 int EditCopy::keypress_event()
1038 {
1039         if(get_keypress() == 'c')
1040                 return handle_event();
1041         return 0;
1042 }
1043 int EditCopy::handle_event()
1044 {
1045         panel->copy_selection();
1046         return 1;
1047 }
1048
1049 EditAppend::EditAppend(MWindow *mwindow, EditPanel *panel, int x, int y)
1050  : BC_Button(x, y, mwindow->theme->append_data)
1051 {
1052         this->mwindow = mwindow;
1053         this->panel = panel;
1054         set_tooltip(_("Append to end of track"));
1055 }
1056 EditAppend::~EditAppend()
1057 {
1058 }
1059
1060
1061 int EditAppend::handle_event()
1062 {
1063         return 1;
1064 }
1065
1066
1067 EditInsert::EditInsert(MWindow *mwindow, EditPanel *panel, int x, int y)
1068  : BC_Button(x, y, mwindow->theme->insert_data)
1069 {
1070         this->mwindow = mwindow;
1071         this->panel = panel;
1072         set_tooltip(_("Insert before beginning of track"));
1073 }
1074 EditInsert::~EditInsert()
1075 {
1076 }
1077
1078
1079 int EditInsert::handle_event()
1080 {
1081
1082         return 1;
1083 }
1084
1085
1086 EditPaste::EditPaste(MWindow *mwindow, EditPanel *panel, int x, int y)
1087  : BC_Button(x, y, mwindow->theme->get_image_set("paste"))
1088 {
1089         this->mwindow = mwindow;
1090         this->panel = panel;
1091         set_tooltip(_("Paste ( v )"));
1092 }
1093 EditPaste::~EditPaste()
1094 {
1095 }
1096
1097 int EditPaste::keypress_event()
1098 {
1099         if(get_keypress() == 'v')
1100                 return handle_event();
1101         return 0;
1102 }
1103 int EditPaste::handle_event()
1104 {
1105         int have_mwindow_lock = mwindow->gui->get_window_lock();
1106         if(!have_mwindow_lock)
1107                 mwindow->gui->lock_window("EditPaste::handle_event");
1108
1109         mwindow->paste();
1110
1111         if(!have_mwindow_lock)
1112                 mwindow->gui->unlock_window();
1113         return 1;
1114 }
1115
1116
1117
1118 EditTransition::EditTransition(MWindow *mwindow, EditPanel *panel, int x, int y)
1119  : BC_Button(x, y, mwindow->theme->transition_data)
1120 {
1121         this->mwindow = mwindow;
1122         this->panel = panel;
1123         set_tooltip(_("Set transition"));
1124 }
1125 EditTransition::~EditTransition()
1126 {
1127 }
1128 int EditTransition::handle_event()
1129 {
1130         return 1;
1131 }
1132
1133 EditPresentation::EditPresentation(MWindow *mwindow, EditPanel *panel, int x, int y)
1134  : BC_Button(x, y, mwindow->theme->presentation_data)
1135 {
1136         this->mwindow = mwindow;
1137         this->panel = panel;
1138         set_tooltip(_("Set presentation up to current position"));
1139 }
1140 EditPresentation::~EditPresentation()
1141 {
1142 }
1143 int EditPresentation::handle_event()
1144 {
1145         return 1;
1146 }
1147
1148 EditUndo::EditUndo(MWindow *mwindow, EditPanel *panel, int x, int y)
1149  : BC_Button(x, y, mwindow->theme->get_image_set("undo"))
1150 {
1151         this->mwindow = mwindow;
1152         this->panel = panel;
1153         set_tooltip(_("Undo ( z )"));
1154 }
1155 EditUndo::~EditUndo()
1156 {
1157 }
1158 int EditUndo::keypress_event()
1159 {
1160         if(get_keypress() == 'z')
1161                 return handle_event();
1162         return 0;
1163 }
1164 int EditUndo::handle_event()
1165 {
1166         mwindow->undo_entry(panel->subwindow);
1167         return 1;
1168 }
1169
1170 EditRedo::EditRedo(MWindow *mwindow, EditPanel *panel, int x, int y)
1171  : BC_Button(x, y, mwindow->theme->get_image_set("redo"))
1172 {
1173         this->mwindow = mwindow;
1174         this->panel = panel;
1175         set_tooltip(_("Redo ( shift Z )"));
1176 }
1177 EditRedo::~EditRedo()
1178 {
1179 }
1180 int EditRedo::keypress_event()
1181 {
1182         if(get_keypress() == 'Z')
1183                 return handle_event();
1184         return 0;
1185 }
1186 int EditRedo::handle_event()
1187 {
1188         mwindow->redo_entry(panel->subwindow);
1189         return 1;
1190 };
1191
1192
1193
1194
1195
1196 EditLabelbutton::EditLabelbutton(MWindow *mwindow, EditPanel *panel, int x, int y)
1197  : BC_Button(x, y, mwindow->theme->get_image_set("labelbutton"))
1198 {
1199         this->mwindow = mwindow;
1200         this->panel = panel;
1201         set_tooltip(_("Toggle label at current position ( l )"));
1202 }
1203
1204 EditLabelbutton::~EditLabelbutton()
1205 {
1206 }
1207 int EditLabelbutton::keypress_event()
1208 {
1209         if(get_keypress() == 'l' && !alt_down())
1210                 return handle_event();
1211         return 0;
1212 }
1213 int EditLabelbutton::handle_event()
1214 {
1215         panel->toggle_label();
1216         return 1;
1217 }
1218
1219
1220
1221
1222
1223
1224
1225 EditFit::EditFit(MWindow *mwindow, EditPanel *panel, int x, int y)
1226  : BC_Button(x, y, mwindow->theme->get_image_set("fit"))
1227 {
1228         this->mwindow = mwindow;
1229         this->panel = panel;
1230         set_tooltip(_("Fit selection to display ( f )"));
1231 }
1232 EditFit::~EditFit()
1233 {
1234 }
1235 int EditFit::keypress_event()
1236 {
1237         if(!alt_down() && get_keypress() == 'f')
1238         {
1239                 handle_event();
1240                 return 1;
1241         }
1242         return 0;
1243 }
1244 int EditFit::handle_event()
1245 {
1246         mwindow->fit_selection();
1247         return 1;
1248 }
1249
1250
1251
1252
1253
1254
1255
1256
1257
1258 EditFitAutos::EditFitAutos(MWindow *mwindow, EditPanel *panel, int x, int y)
1259  : BC_Button(x, y, mwindow->theme->get_image_set("fitautos"))
1260 {
1261         this->mwindow = mwindow;
1262         this->panel = panel;
1263         set_tooltip(_("Fit all autos to display ( Alt + f )"));
1264 }
1265 EditFitAutos::~EditFitAutos()
1266 {
1267 }
1268 int EditFitAutos::keypress_event()
1269 {
1270         if(!ctrl_down() && alt_down() && get_keypress() == 'f')
1271         {
1272                 mwindow->fit_autos(1);
1273                 return 1;
1274         }
1275         if(ctrl_down() && alt_down() && get_keypress() == 'f')
1276         {
1277                 mwindow->fit_autos(0);
1278                 return 1;
1279         }
1280         return 0;
1281 }
1282 int EditFitAutos::handle_event()
1283 {
1284         mwindow->fit_autos(1);
1285         return 1;
1286 }
1287
1288
1289
1290
1291
1292
1293
1294
1295
1296
1297
1298
1299
1300 ArrowButton::ArrowButton(MWindow *mwindow, EditPanel *panel, int x, int y)
1301  : BC_Toggle(x,
1302         y,
1303         mwindow->theme->get_image_set("arrow"),
1304         mwindow->edl->session->editing_mode == EDITING_ARROW,
1305         "",
1306         0,
1307         0,
1308         0)
1309 {
1310         this->mwindow = mwindow;
1311         this->panel = panel;
1312         set_tooltip(_("Drag and drop editing mode"));
1313 }
1314
1315 int ArrowButton::handle_event()
1316 {
1317         update(1);
1318         panel->ibeam->update(0);
1319         mwindow->set_editing_mode(EDITING_ARROW,
1320                 !panel->is_mwindow,
1321                 panel->is_mwindow);
1322 // Nothing after this
1323         return 1;
1324 }
1325
1326
1327 IBeamButton::IBeamButton(MWindow *mwindow, EditPanel *panel, int x, int y)
1328  : BC_Toggle(x,
1329         y,
1330         mwindow->theme->get_image_set("ibeam"),
1331         mwindow->edl->session->editing_mode == EDITING_IBEAM,
1332         "",
1333         0,
1334         0,
1335         0)
1336 {
1337         this->mwindow = mwindow;
1338         this->panel = panel;
1339         set_tooltip(_("Cut and paste editing mode"));
1340 }
1341
1342 int IBeamButton::handle_event()
1343 {
1344         update(1);
1345         panel->arrow->update(0);
1346         mwindow->set_editing_mode(EDITING_IBEAM,
1347                 !panel->is_mwindow,
1348                 panel->is_mwindow);
1349 // Nothing after this
1350         return 1;
1351 }
1352
1353 KeyFrameButton::KeyFrameButton(MWindow *mwindow, EditPanel *panel, int x, int y)
1354  : BC_Toggle(x,
1355         y,
1356         mwindow->theme->get_image_set("autokeyframe"),
1357         mwindow->edl->session->auto_keyframes,
1358         "",
1359         0,
1360         0,
1361         0)
1362 {
1363         this->mwindow = mwindow;
1364         this->panel = panel;
1365         set_tooltip(_("Generate keyframes while tweeking"));
1366 }
1367
1368 int KeyFrameButton::handle_event()
1369 {
1370         mwindow->set_auto_keyframes(get_value(),
1371                 !panel->is_mwindow,
1372                 panel->is_mwindow);
1373         return 1;
1374 }
1375
1376
1377 LockLabelsButton::LockLabelsButton(MWindow *mwindow, int x, int y)
1378  : BC_Toggle(x,
1379         y,
1380         mwindow->theme->get_image_set("locklabels"),
1381         mwindow->edl->session->labels_follow_edits,
1382         "",
1383         0,
1384         0,
1385         0)
1386 {
1387         this->mwindow = mwindow;
1388         set_tooltip(_("Lock labels from moving"));
1389 }
1390
1391 int LockLabelsButton::handle_event()
1392 {
1393         mwindow->set_labels_follow_edits(get_value());
1394         return 1;
1395 }
1396