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