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