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