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