cinelerra-5.1/cinelerra/editpanel.C

   1
   2 /*
   3  * CINELERRA
   4  * Copyright (C) 2008 Adam Williams <broadcast at earthling dot net>
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program; if not, write to the Free Software
  18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  *
  20  */
  21
  22 #include "awindow.h"
  23 #include "awindowgui.h"
  24 #include "bcsignals.h"
  25 #include "clipedit.h"
  26 #include "cplayback.h"
  27 #include "cwindow.h"
  28 #include "cwindowgui.h"
  29 #include "editpanel.h"
  30 #include "edl.h"
  31 #include "edlsession.h"
  32 #include "filexml.h"
  33 #include "keys.h"
  34 #include "language.h"
  35 #include "localsession.h"
  36 #include "mainclock.h"
  37 #include "mainundo.h"
  38 #include "mbuttons.h"
  39 #include "meterpanel.h"
  40 #include "mwindow.h"
  41 #include "mwindowgui.h"
  42 #include "playbackengine.h"
  43 #include "theme.h"
  44 #include "timebar.h"
  45 #include "trackcanvas.h"
  46 #include "transportque.h"
  47 #include "zoombar.h"
  48 #include "manualgoto.h"
  49
  50
  51
  52 EditPanel::EditPanel(MWindow *mwindow,
  53         BC_WindowBase *subwindow,
  54         int window_id,
  55         int x,
  56         int y,
  57         int editing_mode,
  58         int use_editing_mode,
  59         int use_keyframe,
  60         int use_splice,   // Extra buttons
  61         int use_overwrite,
  62         int use_lift,
  63         int use_extract,
  64         int use_copy,
  65         int use_paste,
  66         int use_undo,
  67         int use_fit,
  68         int use_locklabels,
  69         int use_labels,
  70         int use_toclip,
  71         int use_meters,
  72         int use_cut,
  73         int use_commercial,
  74         int use_goto,
  75         int use_clk2play)
  76 {
  77         this->window_id = window_id;
  78         this->editing_mode = editing_mode;
  79         this->use_editing_mode = use_editing_mode;
  80         this->use_keyframe = use_keyframe;
  81         this->use_splice = use_splice;
  82         this->use_overwrite = use_overwrite;
  83         this->use_lift = 0;
  84         this->use_extract = 0;
  85         this->use_copy = use_copy;
  86         this->use_paste = use_paste;
  87         this->use_undo = use_undo;
  88         this->mwindow = mwindow;
  89         this->subwindow = subwindow;
  90         this->use_fit = use_fit;
  91         this->use_labels = use_labels;
  92         this->use_locklabels = use_locklabels;
  93         this->use_toclip = use_toclip;
  94         this->use_meters = use_meters;
  95         this->use_cut = use_cut;
  96         this->use_commercial = use_commercial;
  97         this->use_goto = use_goto;
  98         this->use_clk2play = use_clk2play;
  99
 100         this->x = x;
 101         this->y = y;
 102         this->fit = 0;
 103         this->fit_autos = 0;
 104         this->inpoint = 0;
 105         this->outpoint = 0;
 106         this->splice = 0;
 107         this->overwrite = 0;
 108         this->lift = 0;
 109         this->extract = 0;
 110         this->clip = 0;
 111         this->cut = 0;
 112         this->commercial = 0;
 113         this->copy = 0;
 114         this->paste = 0;
 115         this->labelbutton = 0;
 116         this->prevlabel = 0;
 117         this->nextlabel = 0;
 118         this->prevedit = 0;
 119         this->nextedit = 0;
 120         this->undo = 0;
 121         this->redo = 0;
 122         this->meter_panel = 0;
 123         this->meters = 0;
 124         this->arrow = 0;
 125         this->ibeam = 0;
 126         this->keyframe = 0;
 127         this->mangoto = 0;
 128         this->click2play = 0;
 129         locklabels = 0;
 130 }
 131
 132 EditPanel::~EditPanel()
 133 {
 134 }
 135
 136 void EditPanel::set_meters(MeterPanel *meter_panel)
 137 {
 138         this->meter_panel = meter_panel;
 139 }
 140
 141
 142 void EditPanel::update()
 143 {
 144         int new_editing_mode = mwindow->edl->session->editing_mode;
 145         if( arrow ) arrow->update(new_editing_mode == EDITING_ARROW);
 146         if( ibeam ) ibeam->update(new_editing_mode == EDITING_IBEAM);
 147         if( keyframe ) keyframe->update(mwindow->edl->session->auto_keyframes);
 148         if( locklabels ) locklabels->set_value(mwindow->edl->session->labels_follow_edits);
 149         if( click2play ) {
 150                 int value = !is_vwindow() ?
 151                         mwindow->edl->session->cwindow_click2play :
 152                         mwindow->edl->session->vwindow_click2play ;
 153                 click2play->set_value(value);
 154         }
 155         if( meters ) {
 156                 if( is_cwindow() ) {
 157                         meters->update(mwindow->edl->session->cwindow_meter);
 158                         mwindow->cwindow->gui->update_meters();
 159                 }
 160                 else {
 161                         meters->update(mwindow->edl->session->vwindow_meter);
 162                 }
 163         }
 164         subwindow->flush();
 165 }
 166
 167 int EditPanel::calculate_w(MWindow *mwindow, int use_keyframe, int total_buttons)
 168 {
 169         int result = 0;
 170         int button_w = mwindow->theme->get_image_set("ibeam")[0]->get_w();
 171         if( use_keyframe ) {
 172                 result += button_w + mwindow->theme->toggle_margin;
 173         }
 174
 175         result += button_w * total_buttons;
 176         return result;
 177 }
 178
 179 int EditPanel::calculate_h(MWindow *mwindow)
 180 {
 181         return mwindow->theme->get_image_set("ibeam")[0]->get_h();
 182 }
 183
 184 void EditPanel::create_buttons()
 185 {
 186         x1 = x, y1 = y;
 187
 188         if( use_editing_mode ) {
 189                 arrow = new ArrowButton(mwindow, this, x1, y1);
 190                 subwindow->add_subwindow(arrow);
 191                 x1 += arrow->get_w();
 192                 ibeam = new IBeamButton(mwindow, this, x1, y1);
 193                 subwindow->add_subwindow(ibeam);
 194                 x1 += ibeam->get_w();
 195                 x1 += mwindow->theme->toggle_margin;
 196         }
 197
 198         if( use_keyframe ) {
 199                 keyframe = new KeyFrameButton(mwindow, this, x1, y1);
 200                 subwindow->add_subwindow(keyframe);
 201                 x1 += keyframe->get_w();
 202         }
 203
 204         if( use_locklabels ) {
 205                 locklabels = new LockLabelsButton(mwindow, x1, y1);
 206                 subwindow->add_subwindow(locklabels);
 207                 x1 += locklabels->get_w();
 208         }
 209
 210         if( use_keyframe || use_locklabels )
 211                 x1 += mwindow->theme->toggle_margin;
 212
 213 // Mandatory
 214         inpoint = new EditInPoint(mwindow, this, x1, y1);
 215         subwindow->add_subwindow(inpoint);
 216         x1 += inpoint->get_w();
 217         outpoint = new EditOutPoint(mwindow, this, x1, y1);
 218         subwindow->add_subwindow(outpoint);
 219         x1 += outpoint->get_w();
 220
 221         if( use_splice ) {
 222                 splice = new EditSplice(mwindow, this, x1, y1);
 223                 subwindow->add_subwindow(splice);
 224                 x1 += splice->get_w();
 225         }
 226
 227         if( use_overwrite ) {
 228                 overwrite = new EditOverwrite(mwindow, this, x1, y1);
 229                 subwindow->add_subwindow(overwrite);
 230                 x1 += overwrite->get_w();
 231         }
 232
 233         if( use_lift ) {
 234                 lift = new EditLift(mwindow, this, x1, y1);
 235                 subwindow->add_subwindow(lift);
 236                 x1 += lift->get_w();
 237         }
 238
 239         if( use_extract ) {
 240                 extract = new EditExtract(mwindow, this, x1, y1);
 241                 subwindow->add_subwindow(extract);
 242                 x1 += extract->get_w();
 243         }
 244
 245         if( use_toclip ) {
 246                 clip = new EditToClip(mwindow, this, x1, y1);
 247                 subwindow->add_subwindow(clip);
 248                 x1 += clip->get_w();
 249         }
 250
 251         if( use_cut ) {
 252                 cut = new EditCut(mwindow, this, x1, y1);
 253                 subwindow->add_subwindow(cut);
 254                 x1 += cut->get_w();
 255         }
 256
 257         if( use_copy ) {
 258                 copy = new EditCopy(mwindow, this, x1, y1);
 259                 subwindow->add_subwindow(copy);
 260                 x1 += copy->get_w();
 261         }
 262
 263         if( use_paste ) {
 264                 paste = new EditPaste(mwindow, this, x1, y1);
 265                 subwindow->add_subwindow(paste);
 266                 x1 += paste->get_w();
 267         }
 268
 269         if( use_meters ) {
 270                 if( meter_panel ) {
 271                         meters = new MeterShow(mwindow, meter_panel, x1, y1);
 272                         subwindow->add_subwindow(meters);
 273                         x1 += meters->get_w();
 274                 }
 275                 else
 276                         printf("EditPanel::create_objects: meter_panel == 0\n");
 277         }
 278
 279         if( use_labels ) {
 280                 labelbutton = new EditLabelbutton(mwindow, this, x1, y1);
 281                 subwindow->add_subwindow(labelbutton);
 282                 x1 += labelbutton->get_w();
 283                 prevlabel = new EditPrevLabel(mwindow, this, x1, y1);
 284                 subwindow->add_subwindow(prevlabel);
 285                 x1 += prevlabel->get_w();
 286                 nextlabel = new EditNextLabel(mwindow, this, x1, y1);
 287                 subwindow->add_subwindow(nextlabel);
 288                 x1 += nextlabel->get_w();
 289         }
 290
 291 // all windows except VWindow since it's only implemented in MWindow.
 292         if( use_cut ) {
 293                 prevedit = new EditPrevEdit(mwindow, this, x1, y1);
 294                 subwindow->add_subwindow(prevedit);
 295                 x1 += prevedit->get_w();
 296                 nextedit = new EditNextEdit(mwindow, this, x1, y1);
 297                 subwindow->add_subwindow(nextedit);
 298                 x1 += nextedit->get_w();
 299         }
 300
 301         if( use_fit ) {
 302                 fit = new EditFit(mwindow, this, x1, y1);
 303                 subwindow->add_subwindow(fit);
 304                 x1 += fit->get_w();
 305                 fit_autos = new EditFitAutos(mwindow, this, x1, y1);
 306                 subwindow->add_subwindow(fit_autos);
 307                 x1 += fit_autos->get_w();
 308         }
 309
 310         if( use_undo ) {
 311                 undo = new EditUndo(mwindow, this, x1, y1);
 312                 subwindow->add_subwindow(undo);
 313                 x1 += undo->get_w();
 314                 redo = new EditRedo(mwindow, this, x1, y1);
 315                 subwindow->add_subwindow(redo);
 316                 x1 += redo->get_w();
 317         }
 318
 319         if( use_goto ) {
 320                 mangoto = new EditManualGoto(mwindow, this, x1, y1);
 321                 subwindow->add_subwindow(mangoto);
 322                 x1 += mangoto->get_w();
 323         }
 324
 325         if( use_clk2play ) {
 326                 click2play = new EditClick2Play(mwindow, this, x1, y1+5);
 327                 subwindow->add_subwindow(click2play);
 328                 x1 += click2play->get_w();
 329         }
 330
 331         if( use_commercial ) {
 332                 commercial = new EditCommercial(mwindow, this, x1, y1);
 333                 subwindow->add_subwindow(commercial);
 334                 x1 += commercial->get_w();
 335         }
 336 }
 337
 338 void EditPanel::stop_transport(const char *lock_msg)
 339 {
 340         int have_subwindow_lock = subwindow->get_window_lock();
 341         if( have_subwindow_lock ) subwindow->unlock_window();
 342         mwindow->stop_transport();
 343         if( have_subwindow_lock ) subwindow->lock_window(lock_msg);
 344 }
 345
 346
 347 void EditPanel::toggle_label()
 348 {
 349         mwindow->toggle_label(is_mwindow());
 350 }
 351
 352 void EditPanel::prev_label(int cut)
 353 {
 354         int shift_down = subwindow->shift_down();
 355         int have_mwindow_lock = mwindow->gui->get_window_lock();
 356         if( have_mwindow_lock ) mwindow->gui->unlock_window();
 357
 358         stop_transport("EditPanel::prev_label 1");
 359
 360         mwindow->gui->lock_window("EditPanel::prev_label 2");
 361         if( cut )
 362                 mwindow->cut_left_label();
 363         else
 364                 mwindow->prev_label(shift_down);
 365         if( !have_mwindow_lock )
 366                 mwindow->gui->unlock_window();
 367 }
 368
 369 void EditPanel::next_label(int cut)
 370 {
 371         int shift_down = subwindow->shift_down();
 372         int have_mwindow_lock = mwindow->gui->get_window_lock();
 373         if( have_mwindow_lock ) mwindow->gui->unlock_window();
 374
 375         stop_transport("EditPanel::next_label 1");
 376
 377         mwindow->gui->lock_window("EditPanel::next_label 2");
 378         if( cut )
 379                 mwindow->cut_right_label();
 380         else
 381                 mwindow->next_label(shift_down);
 382         if( !have_mwindow_lock )
 383                 mwindow->gui->unlock_window();
 384 }
 385
 386
 387
 388 void EditPanel::prev_edit(int cut)
 389 {
 390         int shift_down = subwindow->shift_down();
 391         int have_mwindow_lock = mwindow->gui->get_window_lock();
 392         if( have_mwindow_lock ) mwindow->gui->unlock_window();
 393
 394         stop_transport("EditPanel::prev_edit 1");
 395
 396         mwindow->gui->lock_window("EditPanel::prev_edit 2");
 397
 398         if( cut )
 399                 mwindow->cut_left_edit();
 400         else
 401                 mwindow->prev_edit_handle(shift_down);
 402
 403         if( !have_mwindow_lock )
 404                 mwindow->gui->unlock_window();
 405 }
 406
 407 void EditPanel::next_edit(int cut)
 408 {
 409         int shift_down = subwindow->shift_down();
 410         int have_mwindow_lock = mwindow->gui->get_window_lock();
 411         if( have_mwindow_lock ) mwindow->gui->unlock_window();
 412
 413         stop_transport("EditPanel::next_edit 1");
 414
 415         mwindow->gui->lock_window("EditPanel::next_edit 2");
 416
 417         if( cut )
 418                 mwindow->cut_right_edit();
 419         else
 420                 mwindow->next_edit_handle(shift_down);
 421
 422         if( !have_mwindow_lock )
 423                 mwindow->gui->unlock_window();
 424 }
 425
 426
 427 double EditPanel::get_position()
 428 {
 429         EDL *edl = mwindow->edl;
 430         return !edl ? 0 : edl->local_session->get_selectionstart(1);
 431 }
 432
 433 void EditPanel::set_position(double position)
 434 {
 435         EDL *edl = mwindow->edl;
 436         if( !edl ) return;
 437         if( position != get_position() ) {
 438                 if( position < 0 ) position = 0;
 439                 edl->local_session->set_selectionstart(position);
 440                 edl->local_session->set_selectionend(position);
 441                 mwindow->gui->lock_window();
 442                 mwindow->find_cursor();
 443                 mwindow->gui->update(1, NORMAL_DRAW, 1, 1, 1, 1, 0);
 444                 mwindow->gui->unlock_window();
 445                 mwindow->cwindow->update(1, 0, 0, 0, 0);
 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                 arrow->reposition_window(x1, y1);
 457                 x1 += arrow->get_w();
 458                 ibeam->reposition_window(x1, y1);
 459                 x1 += ibeam->get_w();
 460                 x1 += mwindow->theme->toggle_margin;
 461         }
 462
 463         if( use_keyframe ) {
 464                 keyframe->reposition_window(x1, y1);
 465                 x1 += keyframe->get_w();
 466         }
 467
 468         if( use_locklabels ) {
 469                 locklabels->reposition_window(x1,y1);
 470                 x1 += locklabels->get_w();
 471         }
 472
 473         if( use_keyframe || use_locklabels )
 474                 x1 += mwindow->theme->toggle_margin;
 475
 476         inpoint->reposition_window(x1, y1);
 477         x1 += inpoint->get_w();
 478         outpoint->reposition_window(x1, y1);
 479         x1 += outpoint->get_w();
 480         if( use_splice ) {
 481                 splice->reposition_window(x1, y1);
 482                 x1 += splice->get_w();
 483         }
 484         if( use_overwrite ) {
 485                 overwrite->reposition_window(x1, y1);
 486                 x1 += overwrite->get_w();
 487         }
 488         if( use_lift ) {
 489                 lift->reposition_window(x1, y1);
 490                 x1 += lift->get_w();
 491         }
 492         if( use_extract ) {
 493                 extract->reposition_window(x1, y1);
 494                 x1 += extract->get_w();
 495         }
 496         if( use_toclip ) {
 497                 clip->reposition_window(x1, y1);
 498                 x1 += clip->get_w();
 499         }
 500         if( use_cut ) {
 501                 cut->reposition_window(x1, y1);
 502                 x1 += cut->get_w();
 503         }
 504         if( use_copy ) {
 505                 copy->reposition_window(x1, y1);
 506                 x1 += copy->get_w();
 507         }
 508         if( use_paste ) {
 509                 paste->reposition_window(x1, y1);
 510                 x1 += paste->get_w();
 511         }
 512
 513         if( use_meters ) {
 514                 meters->reposition_window(x1, y1);
 515                 x1 += meters->get_w();
 516         }
 517
 518         if( use_labels ) {
 519                 labelbutton->reposition_window(x1, y1);
 520                 x1 += labelbutton->get_w();
 521                 prevlabel->reposition_window(x1, y1);
 522                 x1 += prevlabel->get_w();
 523                 nextlabel->reposition_window(x1, y1);
 524                 x1 += nextlabel->get_w();
 525         }
 526
 527         if( prevedit ) {
 528                 prevedit->reposition_window(x1, y1);
 529                 x1 += prevedit->get_w();
 530         }
 531
 532         if( nextedit ) {
 533                 nextedit->reposition_window(x1, y1);
 534                 x1 += nextedit->get_w();
 535         }
 536
 537         if( use_fit ) {
 538                 fit->reposition_window(x1, y1);
 539                 x1 += fit->get_w();
 540                 fit_autos->reposition_window(x1, y1);
 541                 x1 += fit_autos->get_w();
 542         }
 543
 544         if( use_undo ) {
 545                 undo->reposition_window(x1, y1);
 546                 x1 += undo->get_w();
 547                 redo->reposition_window(x1, y1);
 548                 x1 += redo->get_w();
 549         }
 550
 551         if( use_goto ) {
 552                 mangoto->reposition_window(x1, y1);
 553                 x1 += mangoto->get_w();
 554         }
 555         if( use_clk2play ) {
 556                 click2play->reposition_window(x1, y1+5);
 557                 x1 += click2play->get_w();
 558         }
 559 }
 560
 561
 562
 563 void EditPanel::create_objects()
 564 {
 565         create_buttons();
 566 }
 567
 568 int EditPanel::get_w()
 569 {
 570         return x1 - x;
 571 }
 572
 573
 574 void EditPanel::copy_selection()
 575 {
 576         mwindow->copy();
 577 }
 578
 579 void EditPanel::splice_selection()
 580 {
 581 }
 582
 583 void EditPanel::overwrite_selection()
 584 {
 585 }
 586
 587 void EditPanel::set_inpoint()
 588 {
 589         mwindow->set_inpoint(1);
 590 }
 591
 592 void EditPanel::set_outpoint()
 593 {
 594         mwindow->set_outpoint(1);
 595 }
 596
 597 void EditPanel::unset_inoutpoint()
 598 {
 599         mwindow->unset_inoutpoint(1);
 600 }
 601
 602
 603 EditInPoint::EditInPoint(MWindow *mwindow, EditPanel *panel, int x, int y)
 604  : BC_Button(x, y, mwindow->theme->get_image_set("inbutton"))
 605 {
 606         this->mwindow = mwindow;
 607         this->panel = panel;
 608         set_tooltip(_("In point ( [ or < )"));
 609 }
 610 EditInPoint::~EditInPoint()
 611 {
 612 }
 613 int EditInPoint::handle_event()
 614 {
 615         panel->set_inpoint();
 616         return 1;
 617 }
 618 int EditInPoint::keypress_event()
 619 {
 620         int key = get_keypress();
 621         if( ctrl_down() ) {
 622                 if( key == 't' ) {
 623                         panel->unset_inoutpoint();
 624                         return 1;
 625                 }
 626         }
 627         else if( !alt_down() ) {
 628                 if( key == '[' || key == '<' ) {
 629                         panel->set_inpoint();
 630                         return 1;
 631                 }
 632         }
 633         return 0;
 634 }
 635
 636 EditOutPoint::EditOutPoint(MWindow *mwindow, EditPanel *panel, int x, int y)
 637  : BC_Button(x, y, mwindow->theme->get_image_set("outbutton"))
 638 {
 639         this->mwindow = mwindow;
 640         this->panel = panel;
 641         set_tooltip(_("Out point ( ] or > )"));
 642 }
 643 EditOutPoint::~EditOutPoint()
 644 {
 645 }
 646 int EditOutPoint::handle_event()
 647 {
 648         panel->set_outpoint();
 649         return 1;
 650 }
 651 int EditOutPoint::keypress_event()
 652 {
 653         int key = get_keypress();
 654         if( ctrl_down() ) {
 655                 if(  key == 't' ) {
 656                         panel->unset_inoutpoint();
 657                         return 1;
 658                 }
 659         }
 660         else if( !alt_down() ) {
 661                 if( key == ']' || key == '>' ) {
 662                         panel->set_outpoint();
 663                         return 1;
 664                 }
 665         }
 666         return 0;
 667 }
 668
 669
 670 EditNextLabel::EditNextLabel(MWindow *mwindow,
 671         EditPanel *panel, int x, int y)
 672  : BC_Button(x, y, mwindow->theme->get_image_set("nextlabel"))
 673 {
 674         this->mwindow = mwindow;
 675         this->panel = panel;
 676         set_tooltip(_("Next label ( ctrl -> )"));
 677 }
 678 EditNextLabel::~EditNextLabel()
 679 {
 680 }
 681 int EditNextLabel::keypress_event()
 682 {
 683         if( ctrl_down() ) {
 684                 int key = get_keypress();
 685                 if( (key == RIGHT || key == '.') && !alt_down() ) {
 686                         panel->next_label(0);
 687                         return 1;
 688                 }
 689                 if( key == '>' && alt_down() ) {
 690                         panel->next_label(1);
 691                         return 1;
 692                 }
 693         }
 694         return 0;
 695 }
 696 int EditNextLabel::handle_event()
 697 {
 698         int cut = ctrl_down() && alt_down();
 699         panel->next_label(cut);
 700         return 1;
 701 }
 702
 703 EditPrevLabel::EditPrevLabel(MWindow *mwindow,
 704         EditPanel *panel, int x, int y)
 705  : BC_Button(x, y, mwindow->theme->get_image_set("prevlabel"))
 706 {
 707         this->mwindow = mwindow;
 708         this->panel = panel;
 709         set_tooltip(_("Previous label ( ctrl <- )"));
 710 }
 711 EditPrevLabel::~EditPrevLabel()
 712 {
 713 }
 714 int EditPrevLabel::keypress_event()
 715 {
 716         if( ctrl_down() ) {
 717                 int key = get_keypress();
 718                 if( (key == LEFT || key == ',') && !alt_down() ) {
 719                         panel->prev_label(0);
 720                         return 1;
 721                 }
 722                 if( key == '<' && alt_down() ) {
 723                         panel->prev_label(1);
 724                         return 1;
 725                 }
 726         }
 727         return 0;
 728 }
 729 int EditPrevLabel::handle_event()
 730 {
 731         int cut = ctrl_down() && alt_down();
 732         panel->prev_label(cut);
 733         return 1;
 734 }
 735
 736
 737
 738 EditNextEdit::EditNextEdit(MWindow *mwindow,
 739         EditPanel *panel, int x, int y)
 740  : BC_Button(x, y, mwindow->theme->get_image_set("nextedit"))
 741 {
 742         this->mwindow = mwindow;
 743         this->panel = panel;
 744         set_tooltip(_("Next edit ( alt -> )"));
 745 }
 746 EditNextEdit::~EditNextEdit()
 747 {
 748 }
 749 int EditNextEdit::keypress_event()
 750 {
 751         if( alt_down() ) {
 752                 int key = get_keypress();
 753                 if( (key == RIGHT || key == '.') && !ctrl_down() ) {
 754                         panel->next_edit(0);
 755                         return 1;
 756                 }
 757                 if( key == '.' && ctrl_down() ) {
 758                         panel->next_edit(1);
 759                         return 1;
 760                 }
 761         }
 762         return 0;
 763 }
 764 int EditNextEdit::handle_event()
 765 {
 766         int cut = ctrl_down() && alt_down();
 767         panel->next_edit(cut);
 768         return 1;
 769 }
 770
 771 EditPrevEdit::EditPrevEdit(MWindow *mwindow,
 772         EditPanel *panel, int x, int y)
 773  : BC_Button(x, y, mwindow->theme->get_image_set("prevedit"))
 774 {
 775         this->mwindow = mwindow;
 776         this->panel = panel;
 777         set_tooltip(_("Previous edit (alt <- )"));
 778 }
 779 EditPrevEdit::~EditPrevEdit()
 780 {
 781 }
 782 int EditPrevEdit::keypress_event()
 783 {
 784         if( alt_down() ) {
 785                 int key = get_keypress();
 786                 if( (key == LEFT || key == ',') && !ctrl_down() ) {
 787                         panel->prev_edit(0);
 788                         return 1;
 789                 }
 790                 if( key == ',' && ctrl_down() ) {
 791                         panel->prev_edit(1);
 792                         return 1;
 793                 }
 794         }
 795         return 0;
 796 }
 797 int EditPrevEdit::handle_event()
 798 {
 799         int cut = ctrl_down() && alt_down();
 800         panel->prev_edit(cut);
 801         return 1;
 802 }
 803
 804
 805
 806 EditLift::EditLift(MWindow *mwindow, EditPanel *panel, int x, int y)
 807  : BC_Button(x, y, mwindow->theme->lift_data)
 808 {
 809         this->mwindow = mwindow;
 810         this->panel = panel;
 811         set_tooltip(_("Lift"));
 812 }
 813 EditLift::~EditLift()
 814 {
 815 }
 816 int EditLift::handle_event()
 817 {
 818         return 1;
 819 }
 820
 821 EditOverwrite::EditOverwrite(MWindow *mwindow, EditPanel *panel, int x, int y)
 822  : BC_Button(x, y, mwindow->theme->overwrite_data)
 823 {
 824         this->mwindow = mwindow;
 825         this->panel = panel;
 826         set_tooltip(_("Overwrite ( b )"));
 827 }
 828 EditOverwrite::~EditOverwrite()
 829 {
 830 }
 831 int EditOverwrite::handle_event()
 832 {
 833         panel->overwrite_selection();
 834         return 1;
 835 }
 836 int EditOverwrite::keypress_event()
 837 {
 838         if( alt_down() ) return 0;
 839         if( get_keypress() == 'b' ||
 840             (panel->is_vwindow() && get_keypress() == 'B') ) {
 841                 handle_event();
 842                 return 1;
 843         }
 844         return 0;
 845 }
 846
 847 EditExtract::EditExtract(MWindow *mwindow, EditPanel *panel, int x, int y)
 848  : BC_Button(x, y, mwindow->theme->extract_data)
 849 {
 850         this->mwindow = mwindow;
 851         this->panel = panel;
 852         set_tooltip(_("Extract"));
 853 }
 854 EditExtract::~EditExtract()
 855 {
 856 }
 857 int EditExtract::handle_event()
 858 {
 859 //      mwindow->extract_selection();
 860         return 1;
 861 }
 862
 863 EditToClip::EditToClip(MWindow *mwindow, EditPanel *panel, int x, int y)
 864  : BC_Button(x, y, mwindow->theme->get_image_set("toclip"))
 865 {
 866         this->mwindow = mwindow;
 867         this->panel = panel;
 868         set_tooltip(_("To clip ( i )"));
 869 }
 870 EditToClip::~EditToClip()
 871 {
 872 }
 873 int EditToClip::handle_event()
 874 {
 875         panel->to_clip();
 876         return 1;
 877 }
 878
 879 int EditToClip::keypress_event()
 880 {
 881         if( alt_down() ) return 0;
 882         if( get_keypress() == 'i' ||
 883             (panel->is_vwindow() && get_keypress() == 'I') ) {
 884                 handle_event();
 885                 return 1;
 886         }
 887         return 0;
 888 }
 889
 890 EditManualGoto::EditManualGoto(MWindow *mwindow, EditPanel *panel, int x, int y)
 891  : BC_Button(x, y, mwindow->theme->get_image_set("goto"))
 892 {
 893         this->mwindow = mwindow;
 894         this->panel = panel;
 895         mangoto = new ManualGoto(mwindow, panel);
 896         set_tooltip(_("Manual goto ( g )"));
 897 }
 898 EditManualGoto::~EditManualGoto()
 899 {
 900         delete mangoto;
 901 }
 902 int EditManualGoto::handle_event()
 903 {
 904         mangoto->start();
 905         return 1;
 906 }
 907
 908 int EditManualGoto::keypress_event()
 909 {
 910         if( get_keypress() == 'g' ) {
 911                 handle_event();
 912                 return 1;
 913         }
 914         return 0;
 915 }
 916
 917
 918 EditSplice::EditSplice(MWindow *mwindow, EditPanel *panel, int x, int y)
 919  : BC_Button(x, y, mwindow->theme->splice_data)
 920 {
 921         this->mwindow = mwindow;
 922         this->panel = panel;
 923         set_tooltip(_("Splice ( v )"));
 924 }
 925 EditSplice::~EditSplice()
 926 {
 927 }
 928 int EditSplice::handle_event()
 929 {
 930         panel->splice_selection();
 931         return 1;
 932 }
 933 int EditSplice::keypress_event()
 934 {
 935         if( alt_down() ) return 0;
 936         if( get_keypress() == 'v' ||
 937             (panel->is_vwindow() && get_keypress() == 'V') ) {
 938                 handle_event();
 939                 return 1;
 940         }
 941         return 0;
 942 }
 943
 944 EditCut::EditCut(MWindow *mwindow, EditPanel *panel, int x, int y)
 945  : BC_Button(x, y, mwindow->theme->get_image_set("cut"))
 946 {
 947         this->mwindow = mwindow;
 948         this->panel = panel;
 949         set_tooltip(_("Split | Cut ( x )"));
 950 }
 951 EditCut::~EditCut()
 952 {
 953 }
 954 int EditCut::keypress_event()
 955 {
 956         if( ctrl_down() || shift_down() || alt_down() )
 957                 return 0;
 958         if( get_keypress() == 'x' )
 959                 return handle_event();
 960         return 0;
 961 }
 962
 963 int EditCut::handle_event()
 964 {
 965         int have_mwindow_lock = mwindow->gui->get_window_lock();
 966         if( !have_mwindow_lock )
 967                 mwindow->gui->lock_window("EditCut::handle_event");
 968
 969         mwindow->cut();
 970
 971         if( !have_mwindow_lock )
 972                 mwindow->gui->unlock_window();
 973         return 1;
 974 }
 975
 976 EditClick2Play::EditClick2Play(MWindow *mwindow, EditPanel *panel, int x, int y)
 977  : BC_Toggle(x, y, mwindow->theme->get_image_set("playpatch_data"),
 978     !panel->is_vwindow() ?
 979         mwindow->edl->session->cwindow_click2play :
 980         mwindow->edl->session->vwindow_click2play)
 981 {
 982         this->mwindow = mwindow;
 983         this->panel = panel;
 984         set_tooltip(_("Click to play (p)"));
 985 }
 986 int EditClick2Play::handle_event()
 987 {
 988         int value = get_value();
 989         if( panel->is_vwindow() ) {
 990                 mwindow->edl->session->vwindow_click2play = value;
 991                 mwindow->update_vwindow();
 992         }
 993         else
 994                 mwindow->edl->session->cwindow_click2play = value;
 995         return 1;
 996 }
 997 int EditClick2Play::keypress_event()
 998 {
 999         int key = get_keypress();
1000         if( key == 'p' && !ctrl_down() && !shift_down() && !alt_down() ) {
1001                 int value = get_value() ? 0 : 1;
1002                 update(value);
1003                 if( panel->is_vwindow() ) {
1004                         mwindow->edl->session->vwindow_click2play = value;
1005                         mwindow->update_vwindow();
1006                 }
1007                 else
1008                         mwindow->edl->session->cwindow_click2play = value;
1009                 return 1;
1010         }
1011         return 0;
1012 }
1013
1014
1015 EditCommercial::EditCommercial(MWindow *mwindow, EditPanel *panel, int x, int y)
1016  : BC_Button(x, y, mwindow->theme->get_image_set("commercial"))
1017 {
1018         this->mwindow = mwindow;
1019         this->panel = panel;
1020         set_tooltip(_("Commercial ( shift A )"));
1021 }
1022 EditCommercial::~EditCommercial()
1023 {
1024 }
1025 int EditCommercial::keypress_event()
1026 {
1027         if( ctrl_down() || !shift_down() || alt_down() )
1028                 return 0;
1029         if( get_keypress() == 'A' )
1030                 return handle_event();
1031         return 0;
1032 }
1033
1034 int EditCommercial::handle_event()
1035 {
1036         int have_mwindow_lock = mwindow->gui->get_window_lock();
1037         if( have_mwindow_lock )
1038                 mwindow->gui->unlock_window();
1039         mwindow->commit_commercial();
1040         if( !mwindow->put_commercial() ) {
1041                 mwindow->gui->lock_window("EditCommercial::handle_event 1");
1042                 mwindow->cut();
1043                 if( !have_mwindow_lock )
1044                         mwindow->gui->unlock_window();
1045                 mwindow->activate_commercial();
1046                 return 1;
1047         }
1048         mwindow->undo_commercial();
1049         if( have_mwindow_lock )
1050                 mwindow->gui->lock_window("EditCommercial::handle_event 2");
1051         return 1;
1052 }
1053
1054 EditCopy::EditCopy(MWindow *mwindow, EditPanel *panel, int x, int y)
1055  : BC_Button(x, y, mwindow->theme->get_image_set("copy"))
1056 {
1057         this->mwindow = mwindow;
1058         this->panel = panel;
1059         set_tooltip(_("Copy ( c )"));
1060 }
1061 EditCopy::~EditCopy()
1062 {
1063 }
1064
1065 int EditCopy::keypress_event()
1066 {
1067         if( alt_down() ) return 0;
1068         if( get_keypress() == 'c' ||
1069             (panel->is_vwindow() && get_keypress() == 'C') ) {
1070                 return handle_event();
1071         }
1072         return 0;
1073 }
1074 int EditCopy::handle_event()
1075 {
1076         panel->copy_selection();
1077         return 1;
1078 }
1079
1080 EditAppend::EditAppend(MWindow *mwindow, EditPanel *panel, int x, int y)
1081  : BC_Button(x, y, mwindow->theme->append_data)
1082 {
1083         this->mwindow = mwindow;
1084         this->panel = panel;
1085         set_tooltip(_("Append to end of track"));
1086 }
1087 EditAppend::~EditAppend()
1088 {
1089 }
1090
1091
1092 int EditAppend::handle_event()
1093 {
1094         return 1;
1095 }
1096
1097
1098 EditInsert::EditInsert(MWindow *mwindow, EditPanel *panel, int x, int y)
1099  : BC_Button(x, y, mwindow->theme->insert_data)
1100 {
1101         this->mwindow = mwindow;
1102         this->panel = panel;
1103         set_tooltip(_("Insert before beginning of track"));
1104 }
1105 EditInsert::~EditInsert()
1106 {
1107 }
1108
1109
1110 int EditInsert::handle_event()
1111 {
1112
1113         return 1;
1114 }
1115
1116
1117 EditPaste::EditPaste(MWindow *mwindow, EditPanel *panel, int x, int y)
1118  : BC_Button(x, y, mwindow->theme->get_image_set("paste"))
1119 {
1120         this->mwindow = mwindow;
1121         this->panel = panel;
1122         set_tooltip(_("Paste ( v )"));
1123 }
1124 EditPaste::~EditPaste()
1125 {
1126 }
1127
1128 int EditPaste::keypress_event()
1129 {
1130         if( get_keypress() == 'v' )
1131                 return handle_event();
1132         return 0;
1133 }
1134 int EditPaste::handle_event()
1135 {
1136         int have_mwindow_lock = mwindow->gui->get_window_lock();
1137         if( !have_mwindow_lock )
1138                 mwindow->gui->lock_window("EditPaste::handle_event");
1139
1140         mwindow->paste();
1141
1142         if( !have_mwindow_lock )
1143                 mwindow->gui->unlock_window();
1144         return 1;
1145 }
1146
1147
1148
1149 EditTransition::EditTransition(MWindow *mwindow, EditPanel *panel, int x, int y)
1150  : BC_Button(x, y, mwindow->theme->transition_data)
1151 {
1152         this->mwindow = mwindow;
1153         this->panel = panel;
1154         set_tooltip(_("Set transition"));
1155 }
1156 EditTransition::~EditTransition()
1157 {
1158 }
1159 int EditTransition::handle_event()
1160 {
1161         return 1;
1162 }
1163
1164 EditPresentation::EditPresentation(MWindow *mwindow, EditPanel *panel, int x, int y)
1165  : BC_Button(x, y, mwindow->theme->presentation_data)
1166 {
1167         this->mwindow = mwindow;
1168         this->panel = panel;
1169         set_tooltip(_("Set presentation up to current position"));
1170 }
1171 EditPresentation::~EditPresentation()
1172 {
1173 }
1174 int EditPresentation::handle_event()
1175 {
1176         return 1;
1177 }
1178
1179 EditUndo::EditUndo(MWindow *mwindow, EditPanel *panel, int x, int y)
1180  : BC_Button(x, y, mwindow->theme->get_image_set("undo"))
1181 {
1182         this->mwindow = mwindow;
1183         this->panel = panel;
1184         set_tooltip(_("Undo ( z )"));
1185 }
1186 EditUndo::~EditUndo()
1187 {
1188 }
1189 int EditUndo::keypress_event()
1190 {
1191         if( ctrl_down() || shift_down() || alt_down() )
1192                 return 0;
1193         if( get_keypress() == 'z' )
1194                 return handle_event();
1195         return 0;
1196 }
1197 int EditUndo::handle_event()
1198 {
1199         mwindow->undo_entry(panel->subwindow);
1200         return 1;
1201 }
1202
1203 EditRedo::EditRedo(MWindow *mwindow, EditPanel *panel, int x, int y)
1204  : BC_Button(x, y, mwindow->theme->get_image_set("redo"))
1205 {
1206         this->mwindow = mwindow;
1207         this->panel = panel;
1208         set_tooltip(_("Redo ( shift Z )"));
1209 }
1210 EditRedo::~EditRedo()
1211 {
1212 }
1213 int EditRedo::keypress_event()
1214 {
1215         if( ctrl_down() || !shift_down() || alt_down() )
1216                 return 0;
1217         if( get_keypress() == 'Z' )
1218                 return handle_event();
1219         return 0;
1220 }
1221 int EditRedo::handle_event()
1222 {
1223         mwindow->redo_entry(panel->subwindow);
1224         return 1;
1225 };
1226
1227
1228
1229
1230
1231 EditLabelbutton::EditLabelbutton(MWindow *mwindow, EditPanel *panel, int x, int y)
1232  : BC_Button(x, y, mwindow->theme->get_image_set("labelbutton"))
1233 {
1234         this->mwindow = mwindow;
1235         this->panel = panel;
1236         set_tooltip(_("Toggle label at current position ( l )"));
1237 }
1238
1239 EditLabelbutton::~EditLabelbutton()
1240 {
1241 }
1242 int EditLabelbutton::keypress_event()
1243 {
1244         if( get_keypress() == 'l' && !alt_down() )
1245                 return handle_event();
1246         return 0;
1247 }
1248 int EditLabelbutton::handle_event()
1249 {
1250         panel->toggle_label();
1251         return 1;
1252 }
1253
1254
1255
1256
1257
1258
1259
1260 EditFit::EditFit(MWindow *mwindow, EditPanel *panel, int x, int y)
1261  : BC_Button(x, y, mwindow->theme->get_image_set("fit"))
1262 {
1263         this->mwindow = mwindow;
1264         this->panel = panel;
1265         set_tooltip(_("Fit selection to display ( f )"));
1266 }
1267 EditFit::~EditFit()
1268 {
1269 }
1270 int EditFit::keypress_event()
1271 {
1272         if( !alt_down() && get_keypress() == 'f' ) {
1273                 handle_event();
1274                 return 1;
1275         }
1276         return 0;
1277 }
1278 int EditFit::handle_event()
1279 {
1280         mwindow->fit_selection();
1281         return 1;
1282 }
1283
1284
1285
1286
1287
1288
1289
1290
1291
1292 EditFitAutos::EditFitAutos(MWindow *mwindow, EditPanel *panel, int x, int y)
1293  : BC_Button(x, y, mwindow->theme->get_image_set("fitautos"))
1294 {
1295         this->mwindow = mwindow;
1296         this->panel = panel;
1297         set_tooltip(_("Fit all autos to display ( Alt + f )"));
1298 }
1299 EditFitAutos::~EditFitAutos()
1300 {
1301 }
1302 int EditFitAutos::keypress_event()
1303 {
1304         if( !ctrl_down() && alt_down() && get_keypress() == 'f' ) {
1305                 mwindow->fit_autos(1);
1306                 return 1;
1307         }
1308         if( ctrl_down() && alt_down() && get_keypress() == 'f' ) {
1309                 mwindow->fit_autos(0);
1310                 return 1;
1311         }
1312         return 0;
1313 }
1314 int EditFitAutos::handle_event()
1315 {
1316         mwindow->fit_autos(1);
1317         return 1;
1318 }
1319
1320
1321
1322
1323
1324
1325
1326
1327
1328
1329
1330
1331
1332 ArrowButton::ArrowButton(MWindow *mwindow, EditPanel *panel, int x, int y)
1333  : BC_Toggle(x, y,
1334         mwindow->theme->get_image_set("arrow"),
1335         mwindow->edl->session->editing_mode == EDITING_ARROW,
1336         "", 0, 0, 0)
1337 {
1338         this->mwindow = mwindow;
1339         this->panel = panel;
1340         set_tooltip(_("Drag and drop editing mode"));
1341 }
1342
1343 int ArrowButton::handle_event()
1344 {
1345         update(1);
1346         panel->ibeam->update(0);
1347         mwindow->set_editing_mode(EDITING_ARROW,
1348                 !panel->is_mwindow(), panel->is_mwindow());
1349 // Nothing after this
1350         return 1;
1351 }
1352
1353
1354 IBeamButton::IBeamButton(MWindow *mwindow, EditPanel *panel, int x, int y)
1355  : BC_Toggle(x, y,
1356         mwindow->theme->get_image_set("ibeam"),
1357         mwindow->edl->session->editing_mode == EDITING_IBEAM,
1358         "", 0, 0, 0)
1359 {
1360         this->mwindow = mwindow;
1361         this->panel = panel;
1362         set_tooltip(_("Cut and paste editing mode"));
1363 }
1364
1365 int IBeamButton::handle_event()
1366 {
1367         update(1);
1368         panel->arrow->update(0);
1369         mwindow->set_editing_mode(EDITING_IBEAM,
1370                 !panel->is_mwindow(), panel->is_mwindow());
1371 // Nothing after this
1372         return 1;
1373 }
1374
1375 KeyFrameButton::KeyFrameButton(MWindow *mwindow, EditPanel *panel, int x, int y)
1376  : BC_Toggle(x, y,
1377         mwindow->theme->get_image_set("autokeyframe"),
1378         mwindow->edl->session->auto_keyframes,
1379         "", 0, 0, 0)
1380 {
1381         this->mwindow = mwindow;
1382         this->panel = panel;
1383         set_tooltip(_("Generate keyframes while tweeking (j)"));
1384 }
1385
1386 int KeyFrameButton::handle_event()
1387 {
1388         mwindow->set_auto_keyframes(get_value(),
1389                 !panel->is_mwindow(), panel->is_mwindow());
1390         return 1;
1391 }
1392
1393 int KeyFrameButton::keypress_event()
1394 {
1395         int key = get_keypress();
1396         if( key == 'j' && !ctrl_down() && !shift_down() && !alt_down() ) {
1397                 int value = get_value() ? 0 : 1;
1398                 update(value);
1399                 mwindow->set_auto_keyframes(value,
1400                         !panel->is_mwindow(), panel->is_mwindow());
1401                 return 1;
1402         }
1403         return 0;
1404 }
1405
1406 LockLabelsButton::LockLabelsButton(MWindow *mwindow, int x, int y)
1407  : BC_Toggle(x, y,
1408         mwindow->theme->get_image_set("locklabels"),
1409         mwindow->edl->session->labels_follow_edits,
1410         "", 0, 0, 0)
1411 {
1412         this->mwindow = mwindow;
1413         set_tooltip(_("Lock labels from moving with edits"));
1414 }
1415
1416 int LockLabelsButton::handle_event()
1417 {
1418         mwindow->set_labels_follow_edits(get_value());
1419         return 1;
1420 }
1421