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 "mainsession.h"
  38 #include "mainundo.h"
  39 #include "manualgoto.h"
  40 #include "mbuttons.h"
  41 #include "meterpanel.h"
  42 #include "mwindow.h"
  43 #include "mwindowgui.h"
  44 #include "playbackengine.h"
  45 #include "preferences.h"
  46 #include "scopewindow.h"
  47 #include "theme.h"
  48 #include "timebar.h"
  49 #include "trackcanvas.h"
  50 #include "transportque.h"
  51 #include "vwindowgui.h"
  52 #include "zoombar.h"
  53
  54
  55
  56 EditPanel::EditPanel(MWindow *mwindow,
  57         BC_WindowBase *subwindow,
  58         int window_id,
  59         int x,
  60         int y,
  61         int editing_mode,
  62         int use_editing_mode,
  63         int use_keyframe,
  64         int use_splice,   // Extra buttons
  65         int use_overwrite,
  66         int use_copy,
  67         int use_paste,
  68         int use_undo,
  69         int use_fit,
  70         int use_locklabels,
  71         int use_labels,
  72         int use_toclip,
  73         int use_meters,
  74         int use_cut,
  75         int use_commercial,
  76         int use_goto,
  77         int use_clk2play,
  78         int use_scope)
  79 {
  80         this->window_id = window_id;
  81         this->editing_mode = editing_mode;
  82         this->use_editing_mode = use_editing_mode;
  83         this->use_keyframe = use_keyframe;
  84         this->use_splice = use_splice;
  85         this->use_overwrite = use_overwrite;
  86         this->use_copy = use_copy;
  87         this->use_paste = use_paste;
  88         this->use_undo = use_undo;
  89         this->mwindow = mwindow;
  90         this->subwindow = subwindow;
  91         this->use_fit = use_fit;
  92         this->use_labels = use_labels;
  93         this->use_locklabels = use_locklabels;
  94         this->use_toclip = use_toclip;
  95         this->use_meters = use_meters;
  96         this->use_cut = use_cut;
  97         this->use_commercial = use_commercial;
  98         this->use_goto = use_goto;
  99         this->use_clk2play = use_clk2play;
 100         this->use_scope = use_scope;
 101
 102         this->x = x;
 103         this->y = y;
 104         this->fit = 0;
 105         this->fit_autos = 0;
 106         this->inpoint = 0;
 107         this->outpoint = 0;
 108         this->splice = 0;
 109         this->overwrite = 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->span_keyframe = 0;
 128         this->mangoto = 0;
 129         this->click2play = 0;
 130         this->scope = 0;
 131         this->scope_dialog = 0;
 132         locklabels = 0;
 133 }
 134
 135 EditPanel::~EditPanel()
 136 {
 137         delete scope_dialog;
 138 }
 139
 140 void EditPanel::set_meters(MeterPanel *meter_panel)
 141 {
 142         this->meter_panel = meter_panel;
 143 }
 144
 145
 146 void EditPanel::update()
 147 {
 148         int new_editing_mode = mwindow->edl->session->editing_mode;
 149         if( arrow ) arrow->update(new_editing_mode == EDITING_ARROW);
 150         if( ibeam ) ibeam->update(new_editing_mode == EDITING_IBEAM);
 151         if( keyframe ) keyframe->update(mwindow->edl->session->auto_keyframes);
 152         if( span_keyframe ) span_keyframe->update(mwindow->edl->session->span_keyframes);
 153         if( locklabels ) locklabels->set_value(mwindow->edl->session->labels_follow_edits);
 154         if( click2play ) {
 155                 int value = !is_vwindow() ?
 156                         mwindow->edl->session->cwindow_click2play :
 157                         mwindow->edl->session->vwindow_click2play ;
 158                 click2play->set_value(value);
 159         }
 160         if( meters ) {
 161                 if( is_cwindow() ) {
 162                         meters->update(mwindow->edl->session->cwindow_meter);
 163                         mwindow->cwindow->gui->update_meters();
 164                 }
 165                 else {
 166                         meters->update(mwindow->edl->session->vwindow_meter);
 167                 }
 168         }
 169         subwindow->flush();
 170 }
 171
 172 int EditPanel::calculate_w(MWindow *mwindow, int use_keyframe, int total_buttons)
 173 {
 174         int result = 0;
 175         int button_w = mwindow->theme->get_image_set("ibeam")[0]->get_w();
 176         if( use_keyframe ) {
 177                 result += 2*(button_w + mwindow->theme->toggle_margin);
 178         }
 179
 180         result += button_w * total_buttons;
 181         return result;
 182 }
 183
 184 int EditPanel::calculate_h(MWindow *mwindow)
 185 {
 186         return mwindow->theme->get_image_set("ibeam")[0]->get_h();
 187 }
 188
 189 void EditPanel::create_buttons()
 190 {
 191         x1 = x, y1 = y;
 192
 193         if( use_editing_mode ) {
 194                 arrow = new ArrowButton(mwindow, this, x1, y1);
 195                 subwindow->add_subwindow(arrow);
 196                 x1 += arrow->get_w();
 197                 ibeam = new IBeamButton(mwindow, this, x1, y1);
 198                 subwindow->add_subwindow(ibeam);
 199                 x1 += ibeam->get_w();
 200                 x1 += mwindow->theme->toggle_margin;
 201         }
 202
 203         if( use_keyframe ) {
 204                 keyframe = new KeyFrameButton(mwindow, this, x1, y1);
 205                 subwindow->add_subwindow(keyframe);
 206                 x1 += keyframe->get_w();
 207                 span_keyframe = new SpanKeyFrameButton(mwindow, this, x1, y1);
 208                 subwindow->add_subwindow(span_keyframe);
 209                 x1 += span_keyframe->get_w();
 210         }
 211
 212         if( use_locklabels ) {
 213                 locklabels = new LockLabelsButton(mwindow, this, x1, y1);
 214                 subwindow->add_subwindow(locklabels);
 215                 x1 += locklabels->get_w();
 216         }
 217
 218         if( use_keyframe || use_locklabels )
 219                 x1 += mwindow->theme->toggle_margin;
 220
 221 // Mandatory
 222         inpoint = new EditInPoint(mwindow, this, x1, y1);
 223         subwindow->add_subwindow(inpoint);
 224         x1 += inpoint->get_w();
 225         outpoint = new EditOutPoint(mwindow, this, x1, y1);
 226         subwindow->add_subwindow(outpoint);
 227         x1 += outpoint->get_w();
 228
 229         if( use_splice ) {
 230                 splice = new EditSplice(mwindow, this, x1, y1);
 231                 subwindow->add_subwindow(splice);
 232                 x1 += splice->get_w();
 233         }
 234
 235         if( use_overwrite ) {
 236                 overwrite = new EditOverwrite(mwindow, this, x1, y1);
 237                 subwindow->add_subwindow(overwrite);
 238                 x1 += overwrite->get_w();
 239         }
 240
 241         if( use_toclip ) {
 242                 clip = new EditToClip(mwindow, this, x1, y1);
 243                 subwindow->add_subwindow(clip);
 244                 x1 += clip->get_w();
 245         }
 246
 247         if( use_cut ) {
 248                 cut = new EditCut(mwindow, this, x1, y1);
 249                 subwindow->add_subwindow(cut);
 250                 x1 += cut->get_w();
 251         }
 252
 253         if( use_copy ) {
 254                 copy = new EditCopy(mwindow, this, x1, y1);
 255                 subwindow->add_subwindow(copy);
 256                 x1 += copy->get_w();
 257         }
 258
 259         if( use_paste ) {
 260                 paste = new EditPaste(mwindow, this, x1, y1);
 261                 subwindow->add_subwindow(paste);
 262                 x1 += paste->get_w();
 263         }
 264
 265         if( use_meters ) {
 266                 if( meter_panel ) {
 267                         meters = new MeterShow(mwindow, meter_panel, x1, y1);
 268                         subwindow->add_subwindow(meters);
 269                         x1 += meters->get_w();
 270                 }
 271                 else
 272                         printf("EditPanel::create_objects: meter_panel == 0\n");
 273         }
 274
 275         if( use_labels ) {
 276                 labelbutton = new EditLabelbutton(mwindow, this, x1, y1);
 277                 subwindow->add_subwindow(labelbutton);
 278                 x1 += labelbutton->get_w();
 279                 prevlabel = new EditPrevLabel(mwindow, this, x1, y1);
 280                 subwindow->add_subwindow(prevlabel);
 281                 x1 += prevlabel->get_w();
 282                 nextlabel = new EditNextLabel(mwindow, this, x1, y1);
 283                 subwindow->add_subwindow(nextlabel);
 284                 x1 += nextlabel->get_w();
 285         }
 286
 287 // all windows except VWindow since it's only implemented in MWindow.
 288         if( use_cut ) {
 289                 prevedit = new EditPrevEdit(mwindow, this, x1, y1);
 290                 subwindow->add_subwindow(prevedit);
 291                 x1 += prevedit->get_w();
 292                 nextedit = new EditNextEdit(mwindow, this, x1, y1);
 293                 subwindow->add_subwindow(nextedit);
 294                 x1 += nextedit->get_w();
 295         }
 296
 297         if( use_fit ) {
 298                 fit = new EditFit(mwindow, this, x1, y1);
 299                 subwindow->add_subwindow(fit);
 300                 x1 += fit->get_w();
 301                 fit_autos = new EditFitAutos(mwindow, this, x1, y1);
 302                 subwindow->add_subwindow(fit_autos);
 303                 x1 += fit_autos->get_w();
 304         }
 305
 306         if( use_undo ) {
 307                 undo = new EditUndo(mwindow, this, x1, y1);
 308                 subwindow->add_subwindow(undo);
 309                 x1 += undo->get_w();
 310                 redo = new EditRedo(mwindow, this, x1, y1);
 311                 subwindow->add_subwindow(redo);
 312                 x1 += redo->get_w();
 313         }
 314
 315         if( use_goto ) {
 316                 mangoto = new EditManualGoto(mwindow, this, x1, y1);
 317                 subwindow->add_subwindow(mangoto);
 318                 x1 += mangoto->get_w();
 319         }
 320
 321         if( use_clk2play ) {
 322                 click2play = new EditClick2Play(mwindow, this, x1, y1+yS(3));
 323                 subwindow->add_subwindow(click2play);
 324                 x1 += click2play->get_w();
 325         }
 326
 327         if( use_scope ) {
 328                 scope = new EditPanelScope(mwindow, this, x1, y1-yS(1));
 329                 subwindow->add_subwindow(scope);
 330                 x1 += scope->get_w();
 331                 scope_dialog = new EditPanelScopeDialog(mwindow, this);
 332         }
 333
 334         if( use_commercial ) {
 335                 commercial = new EditCommercial(mwindow, this, x1, y1);
 336                 subwindow->add_subwindow(commercial);
 337                 x1 += commercial->get_w();
 338         }
 339 }
 340
 341 void EditPanel::reposition_buttons(int x, int y)
 342 {
 343         this->x = x;
 344         this->y = y;
 345         x1 = x, y1 = y;
 346
 347         if( use_editing_mode ) {
 348                 arrow->reposition_window(x1, y1);
 349                 x1 += arrow->get_w();
 350                 ibeam->reposition_window(x1, y1);
 351                 x1 += ibeam->get_w();
 352                 x1 += mwindow->theme->toggle_margin;
 353         }
 354
 355         if( use_keyframe ) {
 356                 keyframe->reposition_window(x1, y1);
 357                 x1 += keyframe->get_w();
 358                 span_keyframe->reposition_window(x1, y1);
 359                 x1 += span_keyframe->get_w();
 360         }
 361
 362         if( use_locklabels ) {
 363                 locklabels->reposition_window(x1,y1);
 364                 x1 += locklabels->get_w();
 365         }
 366
 367         if( use_keyframe || use_locklabels )
 368                 x1 += mwindow->theme->toggle_margin;
 369
 370         inpoint->reposition_window(x1, y1);
 371         x1 += inpoint->get_w();
 372         outpoint->reposition_window(x1, y1);
 373         x1 += outpoint->get_w();
 374         if( use_splice ) {
 375                 splice->reposition_window(x1, y1);
 376                 x1 += splice->get_w();
 377         }
 378         if( use_overwrite ) {
 379                 overwrite->reposition_window(x1, y1);
 380                 x1 += overwrite->get_w();
 381         }
 382         if( use_toclip ) {
 383                 clip->reposition_window(x1, y1);
 384                 x1 += clip->get_w();
 385         }
 386         if( use_cut ) {
 387                 cut->reposition_window(x1, y1);
 388                 x1 += cut->get_w();
 389         }
 390         if( use_copy ) {
 391                 copy->reposition_window(x1, y1);
 392                 x1 += copy->get_w();
 393         }
 394         if( use_paste ) {
 395                 paste->reposition_window(x1, y1);
 396                 x1 += paste->get_w();
 397         }
 398
 399         if( use_meters ) {
 400                 meters->reposition_window(x1, y1);
 401                 x1 += meters->get_w();
 402         }
 403
 404         if( use_labels ) {
 405                 labelbutton->reposition_window(x1, y1);
 406                 x1 += labelbutton->get_w();
 407                 prevlabel->reposition_window(x1, y1);
 408                 x1 += prevlabel->get_w();
 409                 nextlabel->reposition_window(x1, y1);
 410                 x1 += nextlabel->get_w();
 411         }
 412
 413         if( prevedit ) {
 414                 prevedit->reposition_window(x1, y1);
 415                 x1 += prevedit->get_w();
 416         }
 417
 418         if( nextedit ) {
 419                 nextedit->reposition_window(x1, y1);
 420                 x1 += nextedit->get_w();
 421         }
 422
 423         if( use_fit ) {
 424                 fit->reposition_window(x1, y1);
 425                 x1 += fit->get_w();
 426                 fit_autos->reposition_window(x1, y1);
 427                 x1 += fit_autos->get_w();
 428         }
 429
 430         if( use_undo ) {
 431                 undo->reposition_window(x1, y1);
 432                 x1 += undo->get_w();
 433                 redo->reposition_window(x1, y1);
 434                 x1 += redo->get_w();
 435         }
 436
 437         if( use_goto ) {
 438                 mangoto->reposition_window(x1, y1);
 439                 x1 += mangoto->get_w();
 440         }
 441         if( use_clk2play ) {
 442                 click2play->reposition_window(x1, y1+yS(3));
 443                 x1 += click2play->get_w();
 444         }
 445         if( use_scope ) {
 446                 scope->reposition_window(x1, y1-yS(1));
 447                 x1 += scope->get_w();
 448         }
 449 }
 450
 451 void EditPanel::create_objects()
 452 {
 453         create_buttons();
 454 }
 455
 456 int EditPanel::get_w()
 457 {
 458         return x1 - x;
 459 }
 460
 461 // toggle_label
 462 EditLabelbutton::EditLabelbutton(MWindow *mwindow, EditPanel *panel, int x, int y)
 463  : BC_Button(x, y, mwindow->theme->get_image_set("labelbutton"))
 464 {
 465         this->mwindow = mwindow;
 466         this->panel = panel;
 467         set_tooltip(_("Toggle label at current position ( l )"));
 468 }
 469
 470 EditLabelbutton::~EditLabelbutton()
 471 {
 472 }
 473 int EditLabelbutton::keypress_event()
 474 {
 475         if( get_keypress() == 'l' && !alt_down() )
 476                 return handle_event();
 477         return 0;
 478 }
 479 int EditLabelbutton::handle_event()
 480 {
 481         panel->panel_toggle_label();
 482         return 1;
 483 }
 484
 485 //next_label
 486 EditNextLabel::EditNextLabel(MWindow *mwindow,
 487         EditPanel *panel, int x, int y)
 488  : BC_Button(x, y, mwindow->theme->get_image_set("nextlabel"))
 489 {
 490         this->mwindow = mwindow;
 491         this->panel = panel;
 492         set_tooltip(_("Next label ( ctrl -> )"));
 493 }
 494 EditNextLabel::~EditNextLabel()
 495 {
 496 }
 497 int EditNextLabel::keypress_event()
 498 {
 499         if( ctrl_down() ) {
 500                 int key = get_keypress();
 501                 if( (key == RIGHT || key == '.') && !alt_down() ) {
 502                         panel->panel_next_label(0);
 503                         return 1;
 504                 }
 505                 if( key == '>' && alt_down() ) {
 506                         panel->panel_next_label(1);
 507                         return 1;
 508                 }
 509         }
 510         return 0;
 511 }
 512 int EditNextLabel::handle_event()
 513 {
 514         int cut = ctrl_down() && alt_down();
 515         panel->panel_next_label(cut);
 516         return 1;
 517 }
 518
 519 //prev_label
 520 EditPrevLabel::EditPrevLabel(MWindow *mwindow,
 521         EditPanel *panel, int x, int y)
 522  : BC_Button(x, y, mwindow->theme->get_image_set("prevlabel"))
 523 {
 524         this->mwindow = mwindow;
 525         this->panel = panel;
 526         set_tooltip(_("Previous label ( ctrl <- )"));
 527 }
 528 EditPrevLabel::~EditPrevLabel()
 529 {
 530 }
 531 int EditPrevLabel::keypress_event()
 532 {
 533         if( ctrl_down() ) {
 534                 int key = get_keypress();
 535                 if( (key == LEFT || key == ',') && !alt_down() ) {
 536                         panel->panel_prev_label(0);
 537                         return 1;
 538                 }
 539                 if( key == '<' && alt_down() ) {
 540                         panel->panel_prev_label(1);
 541                         return 1;
 542                 }
 543         }
 544         return 0;
 545 }
 546 int EditPrevLabel::handle_event()
 547 {
 548         int cut = ctrl_down() && alt_down();
 549         panel->panel_prev_label(cut);
 550         return 1;
 551 }
 552
 553 //prev_edit
 554 EditPrevEdit::EditPrevEdit(MWindow *mwindow,
 555         EditPanel *panel, int x, int y)
 556  : BC_Button(x, y, mwindow->theme->get_image_set("prevedit"))
 557 {
 558         this->mwindow = mwindow;
 559         this->panel = panel;
 560         set_tooltip(_("Previous edit (alt <- )"));
 561 }
 562 EditPrevEdit::~EditPrevEdit()
 563 {
 564 }
 565 int EditPrevEdit::keypress_event()
 566 {
 567         if( alt_down() ) {
 568                 int key = get_keypress();
 569                 if( (key == LEFT || key == ',') && !ctrl_down() ) {
 570                         panel->panel_prev_edit(0);
 571                         return 1;
 572                 }
 573                 if( key == ',' && ctrl_down() ) {
 574                         panel->panel_prev_edit(1);
 575                         return 1;
 576                 }
 577         }
 578         return 0;
 579 }
 580 int EditPrevEdit::handle_event()
 581 {
 582         int cut = ctrl_down() && alt_down();
 583         panel->panel_prev_edit(cut);
 584         return 1;
 585 }
 586
 587 //next_edit
 588 EditNextEdit::EditNextEdit(MWindow *mwindow,
 589         EditPanel *panel, int x, int y)
 590  : BC_Button(x, y, mwindow->theme->get_image_set("nextedit"))
 591 {
 592         this->mwindow = mwindow;
 593         this->panel = panel;
 594         set_tooltip(_("Next edit ( alt -> )"));
 595 }
 596 EditNextEdit::~EditNextEdit()
 597 {
 598 }
 599 int EditNextEdit::keypress_event()
 600 {
 601         if( alt_down() ) {
 602                 int key = get_keypress();
 603                 if( (key == RIGHT || key == '.') && !ctrl_down() ) {
 604                         panel->panel_next_edit(0);
 605                         return 1;
 606                 }
 607                 if( key == '.' && ctrl_down() ) {
 608                         panel->panel_next_edit(1);
 609                         return 1;
 610                 }
 611         }
 612         return 0;
 613 }
 614 int EditNextEdit::handle_event()
 615 {
 616         int cut = ctrl_down() && alt_down();
 617         panel->panel_next_edit(cut);
 618         return 1;
 619 }
 620
 621 //copy_selection
 622 EditCopy::EditCopy(MWindow *mwindow, EditPanel *panel, int x, int y)
 623  : BC_Button(x, y, mwindow->theme->get_image_set("copy"))
 624 {
 625         this->mwindow = mwindow;
 626         this->panel = panel;
 627         set_tooltip(_("Copy ( c )"));
 628 }
 629 EditCopy::~EditCopy()
 630 {
 631 }
 632
 633 int EditCopy::keypress_event()
 634 {
 635         if( alt_down() ) return 0;
 636         if( (get_keypress() == 'c' && !ctrl_down()) ||
 637             (panel->is_vwindow() && get_keypress() == 'C') ) {
 638                 return handle_event();
 639         }
 640         return 0;
 641 }
 642 int EditCopy::handle_event()
 643 {
 644         panel->panel_copy_selection();
 645         return 1;
 646 }
 647
 648 //overwrite_selection
 649 EditOverwrite::EditOverwrite(MWindow *mwindow, EditPanel *panel, int x, int y)
 650  : BC_Button(x, y, mwindow->theme->overwrite_data)
 651 {
 652         this->mwindow = mwindow;
 653         this->panel = panel;
 654         set_tooltip(_("Overwrite ( b )"));
 655 }
 656 EditOverwrite::~EditOverwrite()
 657 {
 658 }
 659 int EditOverwrite::handle_event()
 660 {
 661         panel->panel_overwrite_selection();
 662         return 1;
 663 }
 664 int EditOverwrite::keypress_event()
 665 {
 666         if( alt_down() ) return 0;
 667         if( get_keypress() == 'b' ||
 668             (panel->is_vwindow() && get_keypress() == 'B') ) {
 669                 handle_event();
 670                 return 1;
 671         }
 672         return 0;
 673 }
 674
 675 //set_inpoint
 676 //unset_inoutpoint
 677 EditInPoint::EditInPoint(MWindow *mwindow, EditPanel *panel, int x, int y)
 678  : BC_Button(x, y, mwindow->theme->get_image_set("inbutton"))
 679 {
 680         this->mwindow = mwindow;
 681         this->panel = panel;
 682         set_tooltip(_("In point ( [ or < )"));
 683 }
 684 EditInPoint::~EditInPoint()
 685 {
 686 }
 687 int EditInPoint::handle_event()
 688 {
 689         panel->panel_set_inpoint();
 690         return 1;
 691 }
 692 int EditInPoint::keypress_event()
 693 {
 694         int key = get_keypress();
 695         if( ctrl_down() ) {
 696                 if( key == 't' ) {
 697                         panel->panel_unset_inoutpoint();
 698                         return 1;
 699                 }
 700         }
 701         else if( !alt_down() ) {
 702                 if( key == '[' || key == '<' ) {
 703                         panel->panel_set_inpoint();
 704                         return 1;
 705                 }
 706         }
 707         return 0;
 708 }
 709
 710 //set_outpoint
 711 //unset_inoutpoint
 712 EditOutPoint::EditOutPoint(MWindow *mwindow, EditPanel *panel, int x, int y)
 713  : BC_Button(x, y, mwindow->theme->get_image_set("outbutton"))
 714 {
 715         this->mwindow = mwindow;
 716         this->panel = panel;
 717         set_tooltip(_("Out point ( ] or > )"));
 718 }
 719 EditOutPoint::~EditOutPoint()
 720 {
 721 }
 722 int EditOutPoint::handle_event()
 723 {
 724         panel->panel_set_outpoint();
 725         return 1;
 726 }
 727 int EditOutPoint::keypress_event()
 728 {
 729         int key = get_keypress();
 730         if( ctrl_down() ) {
 731                 if(  key == 't' ) {
 732                         panel->panel_unset_inoutpoint();
 733                         return 1;
 734                 }
 735         }
 736         else if( !alt_down() ) {
 737                 if( key == ']' || key == '>' ) {
 738                         panel->panel_set_outpoint();
 739                         return 1;
 740                 }
 741         }
 742         return 0;
 743 }
 744
 745 //splice_selection
 746 EditSplice::EditSplice(MWindow *mwindow, EditPanel *panel, int x, int y)
 747  : BC_Button(x, y, mwindow->theme->splice_data)
 748 {
 749         this->mwindow = mwindow;
 750         this->panel = panel;
 751         set_tooltip(_("Splice ( v )"));
 752 }
 753 EditSplice::~EditSplice()
 754 {
 755 }
 756 int EditSplice::handle_event()
 757 {
 758         panel->panel_splice_selection();
 759         return 1;
 760 }
 761 int EditSplice::keypress_event()
 762 {
 763         if( alt_down() ) return 0;
 764         if( (get_keypress() == 'v' && !ctrl_down()) ||
 765             (panel->is_vwindow() && get_keypress() == 'V') ) {
 766                 handle_event();
 767                 return 1;
 768         }
 769         return 0;
 770 }
 771
 772 //to_clip
 773 EditToClip::EditToClip(MWindow *mwindow, EditPanel *panel, int x, int y)
 774  : BC_Button(x, y, mwindow->theme->get_image_set("toclip"))
 775 {
 776         this->mwindow = mwindow;
 777         this->panel = panel;
 778         set_tooltip(_("To clip ( i )"));
 779 }
 780 EditToClip::~EditToClip()
 781 {
 782 }
 783 int EditToClip::handle_event()
 784 {
 785         panel->panel_to_clip();
 786         return 1;
 787 }
 788
 789 int EditToClip::keypress_event()
 790 {
 791         if( alt_down() ) return 0;
 792         if( get_keypress() == 'i' ||
 793             (panel->is_vwindow() && get_keypress() == 'I') ) {
 794                 handle_event();
 795                 return 1;
 796         }
 797         return 0;
 798 }
 799
 800 //cut
 801 EditCut::EditCut(MWindow *mwindow, EditPanel *panel, int x, int y)
 802  : BC_Button(x, y, mwindow->theme->get_image_set("cut"))
 803 {
 804         this->mwindow = mwindow;
 805         this->panel = panel;
 806         set_tooltip(_("Split | Cut ( x )"));
 807 }
 808 EditCut::~EditCut()
 809 {
 810 }
 811 int EditCut::keypress_event()
 812 {
 813         if( ctrl_down() || shift_down() || alt_down() )
 814                 return 0;
 815         if( get_keypress() == 'x' )
 816                 return handle_event();
 817         return 0;
 818 }
 819
 820 int EditCut::handle_event()
 821 {
 822         panel->panel_cut();
 823         return 1;
 824 }
 825
 826 //paste
 827 EditPaste::EditPaste(MWindow *mwindow, EditPanel *panel, int x, int y)
 828  : BC_Button(x, y, mwindow->theme->get_image_set("paste"))
 829 {
 830         this->mwindow = mwindow;
 831         this->panel = panel;
 832         set_tooltip(_("Paste ( v )"));
 833 }
 834 EditPaste::~EditPaste()
 835 {
 836 }
 837
 838 int EditPaste::keypress_event()
 839 {
 840         if( get_keypress() == 'v' && !ctrl_down() )
 841                 return handle_event();
 842         return 0;
 843 }
 844 int EditPaste::handle_event()
 845 {
 846         panel->panel_paste();
 847         return 1;
 848 }
 849
 850 //fit_selection
 851 EditFit::EditFit(MWindow *mwindow, EditPanel *panel, int x, int y)
 852  : BC_Button(x, y, mwindow->theme->get_image_set("fit"))
 853 {
 854         this->mwindow = mwindow;
 855         this->panel = panel;
 856         set_tooltip(_("Fit selection to display ( f )"));
 857 }
 858 EditFit::~EditFit()
 859 {
 860 }
 861 int EditFit::keypress_event()
 862 {
 863         if( !alt_down() && get_keypress() == 'f' ) {
 864                 handle_event();
 865                 return 1;
 866         }
 867         return 0;
 868 }
 869 int EditFit::handle_event()
 870 {
 871         panel->panel_fit_selection();
 872         return 1;
 873 }
 874
 875 //fit_autos
 876 EditFitAutos::EditFitAutos(MWindow *mwindow, EditPanel *panel, int x, int y)
 877  : BC_Button(x, y, mwindow->theme->get_image_set("fitautos"))
 878 {
 879         this->mwindow = mwindow;
 880         this->panel = panel;
 881         set_tooltip(_("Fit all autos to display ( Alt + f )"));
 882 }
 883 EditFitAutos::~EditFitAutos()
 884 {
 885 }
 886 int EditFitAutos::keypress_event()
 887 {
 888         if( get_keypress() == 'f' && alt_down() ) {
 889                 panel->panel_fit_autos(!ctrl_down() ? 1 : 0);
 890                 return 1;
 891         }
 892         return 0;
 893 }
 894 int EditFitAutos::handle_event()
 895 {
 896         panel->panel_fit_autos(1);
 897         return 1;
 898 }
 899
 900 //set_editing_mode
 901 ArrowButton::ArrowButton(MWindow *mwindow, EditPanel *panel, int x, int y)
 902  : BC_Toggle(x, y,
 903         mwindow->theme->get_image_set("arrow"),
 904         mwindow->edl->session->editing_mode == EDITING_ARROW,
 905         "", 0, 0, 0)
 906 {
 907         this->mwindow = mwindow;
 908         this->panel = panel;
 909         set_tooltip(_("Drag and drop editing mode"));
 910 }
 911
 912 int ArrowButton::handle_event()
 913 {
 914         update(1);
 915         panel->ibeam->update(0);
 916         panel->panel_set_editing_mode(EDITING_ARROW);
 917 // Nothing after this
 918         return 1;
 919 }
 920
 921 IBeamButton::IBeamButton(MWindow *mwindow, EditPanel *panel, int x, int y)
 922  : BC_Toggle(x, y,
 923         mwindow->theme->get_image_set("ibeam"),
 924         mwindow->edl->session->editing_mode == EDITING_IBEAM,
 925         "", 0, 0, 0)
 926 {
 927         this->mwindow = mwindow;
 928         this->panel = panel;
 929         set_tooltip(_("Cut and paste editing mode"));
 930 }
 931
 932 int IBeamButton::handle_event()
 933 {
 934         update(1);
 935         panel->arrow->update(0);
 936         panel->panel_set_editing_mode(EDITING_IBEAM);
 937 // Nothing after this
 938         return 1;
 939 }
 940
 941 //set_auto_keyframes
 942 KeyFrameButton::KeyFrameButton(MWindow *mwindow, EditPanel *panel, int x, int y)
 943  : BC_Toggle(x, y,
 944         mwindow->theme->get_image_set("autokeyframe"),
 945         mwindow->edl->session->auto_keyframes,
 946         "", 0, 0, 0)
 947 {
 948         this->mwindow = mwindow;
 949         this->panel = panel;
 950         set_tooltip(_("Generate keyframes while tweeking (j)"));
 951 }
 952
 953 int KeyFrameButton::handle_event()
 954 {
 955         panel->panel_set_auto_keyframes(get_value());
 956         return 1;
 957 }
 958
 959 int KeyFrameButton::keypress_event()
 960 {
 961         int key = get_keypress();
 962         if( key == 'j' && !ctrl_down() && !shift_down() && !alt_down() ) {
 963                 int value = get_value() ? 0 : 1;
 964                 update(value);
 965                 panel->panel_set_auto_keyframes(value);
 966                 return 1;
 967         }
 968         return 0;
 969 }
 970
 971 //set_span_keyframes
 972 SpanKeyFrameButton::SpanKeyFrameButton(MWindow *mwindow, EditPanel *panel, int x, int y)
 973  : BC_Toggle(x, y,
 974         mwindow->theme->get_image_set("spankeyframe"),
 975         mwindow->edl->session->span_keyframes,
 976         "", 0, 0, 0)
 977 {
 978         this->mwindow = mwindow;
 979         this->panel = panel;
 980         set_tooltip(_("Allow keyframe spanning"));
 981 }
 982
 983 int SpanKeyFrameButton::handle_event()
 984 {
 985         panel->panel_set_span_keyframes(get_value());
 986         return 1;
 987 }
 988
 989 //set_labels_follow_edits
 990 LockLabelsButton::LockLabelsButton(MWindow *mwindow, EditPanel *panel, int x, int y)
 991  : BC_Toggle(x, y,
 992         mwindow->theme->get_image_set("locklabels"),
 993         mwindow->edl->session->labels_follow_edits,
 994         "", 0, 0, 0)
 995 {
 996         this->mwindow = mwindow;
 997         this->panel = panel;
 998         set_tooltip(_("Lock labels from moving with edits"));
 999 }
1000
1001 int LockLabelsButton::handle_event()
1002 {
1003         panel->panel_set_labels_follow_edits(get_value());
1004         return 1;
1005 }
1006
1007
1008
1009 EditManualGoto::EditManualGoto(MWindow *mwindow, EditPanel *panel, int x, int y)
1010  : BC_Button(x, y, mwindow->theme->get_image_set("goto"))
1011 {
1012         this->mwindow = mwindow;
1013         this->panel = panel;
1014         mangoto = new ManualGoto(mwindow, panel);
1015         set_tooltip(_("Manual goto ( g )"));
1016 }
1017 EditManualGoto::~EditManualGoto()
1018 {
1019         delete mangoto;
1020 }
1021 int EditManualGoto::handle_event()
1022 {
1023         mangoto->start();
1024         return 1;
1025 }
1026
1027 int EditManualGoto::keypress_event()
1028 {
1029         if( get_keypress() == 'g' ) {
1030                 handle_event();
1031                 return 1;
1032         }
1033         return 0;
1034 }
1035
1036
1037 EditClick2Play::EditClick2Play(MWindow *mwindow, EditPanel *panel, int x, int y)
1038  : BC_Toggle(x, y, mwindow->theme->get_image_set("playpatch_data"),
1039     !panel->is_vwindow() ?
1040         mwindow->edl->session->cwindow_click2play :
1041         mwindow->edl->session->vwindow_click2play)
1042 {
1043         this->mwindow = mwindow;
1044         this->panel = panel;
1045         set_tooltip(_("Click to play (p)"));
1046 }
1047 int EditClick2Play::handle_event()
1048 {
1049         int value = get_value();
1050         panel->set_click_to_play(value);
1051         return 1;
1052 }
1053 int EditClick2Play::keypress_event()
1054 {
1055         int key = get_keypress();
1056         if( key == 'p' && !ctrl_down() && !shift_down() && !alt_down() ) {
1057                 int value = get_value() ? 0 : 1;
1058                 update(value);
1059                 panel->set_click_to_play(value);
1060                 return 1;
1061         }
1062         return 0;
1063 }
1064
1065
1066 EditCommercial::EditCommercial(MWindow *mwindow, EditPanel *panel, int x, int y)
1067  : BC_Button(x, y, mwindow->theme->get_image_set("commercial"))
1068 {
1069         this->mwindow = mwindow;
1070         this->panel = panel;
1071         set_tooltip(_("Commercial ( shift A )"));
1072 }
1073 EditCommercial::~EditCommercial()
1074 {
1075 }
1076 int EditCommercial::keypress_event()
1077 {
1078         if( ctrl_down() || !shift_down() || alt_down() )
1079                 return 0;
1080         if( get_keypress() == 'A' )
1081                 return handle_event();
1082         return 0;
1083 }
1084
1085 int EditCommercial::handle_event()
1086 {
1087         int have_mwindow_lock = mwindow->gui->get_window_lock();
1088         if( have_mwindow_lock )
1089                 mwindow->gui->unlock_window();
1090         mwindow->commit_commercial();
1091         if( !mwindow->put_commercial() ) {
1092                 mwindow->gui->lock_window("EditCommercial::handle_event 1");
1093                 mwindow->cut();
1094                 if( !have_mwindow_lock )
1095                         mwindow->gui->unlock_window();
1096                 mwindow->activate_commercial();
1097                 return 1;
1098         }
1099         mwindow->undo_commercial();
1100         if( have_mwindow_lock )
1101                 mwindow->gui->lock_window("EditCommercial::handle_event 2");
1102         return 1;
1103 }
1104
1105
1106 EditUndo::EditUndo(MWindow *mwindow, EditPanel *panel, int x, int y)
1107  : BC_Button(x, y, mwindow->theme->get_image_set("undo"))
1108 {
1109         this->mwindow = mwindow;
1110         this->panel = panel;
1111         set_tooltip(_("Undo ( z )"));
1112 }
1113 EditUndo::~EditUndo()
1114 {
1115 }
1116 int EditUndo::keypress_event()
1117 {
1118         if( ctrl_down() || shift_down() || alt_down() )
1119                 return 0;
1120         if( get_keypress() == 'z' )
1121                 return handle_event();
1122         return 0;
1123 }
1124 int EditUndo::handle_event()
1125 {
1126         mwindow->undo_entry(panel->subwindow);
1127         return 1;
1128 }
1129
1130 EditRedo::EditRedo(MWindow *mwindow, EditPanel *panel, int x, int y)
1131  : BC_Button(x, y, mwindow->theme->get_image_set("redo"))
1132 {
1133         this->mwindow = mwindow;
1134         this->panel = panel;
1135         set_tooltip(_("Redo ( shift Z )"));
1136 }
1137 EditRedo::~EditRedo()
1138 {
1139 }
1140 int EditRedo::keypress_event()
1141 {
1142         if( ctrl_down() || !shift_down() || alt_down() )
1143                 return 0;
1144         if( get_keypress() == 'Z' )
1145                 return handle_event();
1146         return 0;
1147 }
1148 int EditRedo::handle_event()
1149 {
1150         mwindow->redo_entry(panel->subwindow);
1151         return 1;
1152 }
1153
1154
1155 EditPanelScopeDialog::EditPanelScopeDialog(MWindow *mwindow, EditPanel *panel)
1156  : BC_DialogThread()
1157 {
1158         this->mwindow = mwindow;
1159         this->panel = panel;
1160         scope_gui = 0;
1161         gui_lock = new Mutex("EditPanelScopeDialog::gui_lock");
1162 }
1163
1164 EditPanelScopeDialog::~EditPanelScopeDialog()
1165 {
1166         close_window();
1167         delete gui_lock;
1168 }
1169
1170 void EditPanelScopeDialog::handle_done_event(int result)
1171 {
1172         gui_lock->lock("EditPanelScopeDialog::handle_done_event");
1173         scope_gui = 0;
1174         gui_lock->unlock();
1175
1176         panel->subwindow->lock_window("EditPanelScopeDialog::handle_done_event");
1177         panel->scope->update(0);
1178         panel->subwindow->unlock_window();
1179 }
1180
1181 BC_Window* EditPanelScopeDialog::new_gui()
1182 {
1183         EditPanelScopeGUI *gui = new EditPanelScopeGUI(mwindow, this);
1184         gui->create_objects();
1185         scope_gui = gui;
1186         return gui;
1187 }
1188
1189 void EditPanelScopeDialog::process(VFrame *output_frame)
1190 {
1191         if( panel->scope_dialog ) {
1192                 panel->scope_dialog->gui_lock->lock("EditPanelScopeDialog::process");
1193                 if( panel->scope_dialog->scope_gui ) {
1194                         EditPanelScopeGUI *gui = panel->scope_dialog->scope_gui;
1195                         gui->process(output_frame);
1196                 }
1197                 panel->scope_dialog->gui_lock->unlock();
1198         }
1199 }
1200
1201 EditPanelScopeGUI::EditPanelScopeGUI(MWindow *mwindow, EditPanelScopeDialog *dialog)
1202  : ScopeGUI(mwindow->theme,
1203         mwindow->session->scope_x, mwindow->session->scope_y,
1204         mwindow->session->scope_w, mwindow->session->scope_h,
1205         mwindow->preferences->processors)
1206 {
1207         this->mwindow = mwindow;
1208         this->dialog = dialog;
1209 }
1210
1211 EditPanelScopeGUI::~EditPanelScopeGUI()
1212 {
1213 }
1214
1215 void EditPanelScopeGUI::create_objects()
1216 {
1217         MainSession *session = mwindow->session;
1218         use_hist = session->use_hist;
1219         use_wave = session->use_wave;
1220         use_vector = session->use_vector;
1221         use_hist_parade = session->use_hist_parade;
1222         use_wave_parade = session->use_wave_parade;
1223         ScopeGUI::create_objects();
1224 }
1225
1226 void EditPanelScopeGUI::toggle_event()
1227 {
1228         MainSession *session = mwindow->session;
1229         session->use_hist = use_hist;
1230         session->use_wave = use_wave;
1231         session->use_vector = use_vector;
1232         session->use_hist_parade = use_hist_parade;
1233         session->use_wave_parade = use_wave_parade;
1234 }
1235
1236 int EditPanelScopeGUI::translation_event()
1237 {
1238         ScopeGUI::translation_event();
1239         MainSession *session = mwindow->session;
1240         session->scope_x = get_x();
1241         session->scope_y = get_y();
1242         return 0;
1243 }
1244
1245 int EditPanelScopeGUI::resize_event(int w, int h)
1246 {
1247         ScopeGUI::resize_event(w, h);
1248         MainSession *session = mwindow->session;
1249         session->scope_w = w;
1250         session->scope_h = h;
1251         return 0;
1252 }
1253
1254 EditPanelScope::EditPanelScope(MWindow *mwindow, EditPanel *panel, int x, int y)
1255  : BC_Toggle(x, y, mwindow->theme ?
1256                 mwindow->theme->get_image_set("scope_toggle") : 0, 0)
1257 {
1258         this->mwindow = mwindow;
1259         this->panel = panel;
1260         set_tooltip(_("View scope"));
1261 }
1262
1263 EditPanelScope::~EditPanelScope()
1264 {
1265 }
1266
1267 void EditPanelScopeGUI::update_scope()
1268 {
1269         Canvas *canvas = 0;
1270         if( dialog->panel->is_cwindow() ) {
1271                 CWindowGUI *cgui = (CWindowGUI *)dialog->panel->subwindow;
1272                 canvas = cgui->canvas;
1273         }
1274         else if( dialog->panel->is_vwindow() ) {
1275                 VWindowGUI *vgui = (VWindowGUI *)dialog->panel->subwindow;
1276                 canvas = vgui->canvas;
1277         }
1278         if( canvas && canvas->refresh_frame )
1279                 process(canvas->refresh_frame);
1280 }
1281
1282 int EditPanelScope::handle_event()
1283 {
1284         unlock_window();
1285         int v = get_value();
1286         if( v )
1287                 panel->scope_dialog->start();
1288         else
1289                 panel->scope_dialog->close_window();
1290         lock_window("EditPanelScope::handle_event");
1291         return 1;
1292 }
1293