cinelerra-5.1/cinelerra/mainmenu.C

   1
   2 /*
   3  * CINELERRA
   4  * Copyright (C) 1997-2014 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 "assets.h"
  23 #include "auto.h"
  24 #include "batchrender.h"
  25 #include "bcdisplayinfo.h"
  26 #include "bchash.h"
  27 #include "bcsignals.h"
  28 #include "bdcreate.h"
  29 #include "cache.h"
  30 #include "channelinfo.h"
  31 #include "cplayback.h"
  32 #include "cropvideo.h"
  33 #include "cwindow.h"
  34 #include "cwindowgui.h"
  35 #include "dbwindow.h"
  36 #include "dvdcreate.h"
  37 #include "edl.h"
  38 #include "edlsession.h"
  39 #include "file.h"
  40 #include "filesystem.h"
  41 #include "filexml.h"
  42 #include "floatauto.h"
  43 #include "keys.h"
  44 #include "language.h"
  45 #include "levelwindow.h"
  46 #include "loadfile.h"
  47 #include "localsession.h"
  48 #include "mainclock.h"
  49 #include "mainmenu.h"
  50 #include "mainsession.h"
  51 #include "mainundo.h"
  52 #include "menuattacheffect.h"
  53 #include "menuattachtransition.h"
  54 #include "menuaeffects.h"
  55 #include "menueditlength.h"
  56 #include "menutransitionlength.h"
  57 #include "menuveffects.h"
  58 #include "mixersalign.h"
  59 #include "mwindowgui.h"
  60 #include "mwindow.h"
  61 #include "new.h"
  62 #include "patchbay.h"
  63 #include "playbackengine.h"
  64 #include "preferences.h"
  65 #include "proxy.h"
  66 #include "preferencesthread.h"
  67 #include "quit.h"
  68 #include "record.h"
  69 #include "render.h"
  70 #include "savefile.h"
  71 #include "setformat.h"
  72 #include "swindow.h"
  73 #include "timebar.h"
  74 #include "trackcanvas.h"
  75 #include "tracks.h"
  76 #include "transition.h"
  77 #include "transportque.h"
  78 #include "viewmenu.h"
  79 #include "zoombar.h"
  80 #include "exportedl.h"
  81
  82 #include <string.h>
  83
  84
  85 MainMenu::MainMenu(MWindow *mwindow, MWindowGUI *gui, int w)
  86  : BC_MenuBar(0, 0, w)
  87 {
  88         this->gui = gui;
  89         this->mwindow = mwindow;
  90 }
  91
  92 MainMenu::~MainMenu()
  93 {
  94 }
  95
  96 void MainMenu::create_objects()
  97 {
  98         BC_Menu *viewmenu, *windowmenu, *settingsmenu, *trackmenu;
  99         PreferencesMenuitem *preferences;
 100         total_loads = 0;
 101
 102         add_menu(filemenu = new BC_Menu(_("File")));
 103         filemenu->add_item(new_project = new NewProject(mwindow));
 104         new_project->create_objects();
 105
 106 // file loaders
 107         filemenu->add_item(load_file = new Load(mwindow, this));
 108         load_file->create_objects();
 109
 110 // new and load can be undone so no need to prompt save
 111         Save *save;                   //  affected by saveas
 112         filemenu->add_item(save = new Save(mwindow));
 113         SaveAs *saveas;
 114         filemenu->add_item(saveas = new SaveAs(mwindow));
 115         save->create_objects(saveas);
 116         saveas->set_mainmenu(this);
 117         SaveProject *save_project;
 118         filemenu->add_item(save_project = new SaveProject(mwindow));
 119
 120         filemenu->add_item(record_menu_item = new RecordMenuItem(mwindow));
 121 #ifdef HAVE_DVB
 122         filemenu->add_item(new ChannelScan(mwindow));
 123 #endif
 124 #ifdef HAVE_COMMERCIAL
 125         if( mwindow->has_commercials() )
 126                 filemenu->add_item(new DbWindowScan(mwindow));
 127 #endif
 128         filemenu->add_item(new SubttlSWin(mwindow));
 129
 130         filemenu->add_item(render = new RenderItem(mwindow));
 131         filemenu->add_item(new ExportEDLItem(mwindow));
 132         filemenu->add_item(new BatchRenderMenuItem(mwindow));
 133         filemenu->add_item(new CreateBD_MenuItem(mwindow));
 134         filemenu->add_item(new CreateDVD_MenuItem(mwindow));
 135         filemenu->add_item(new BC_MenuItem("-"));
 136         filemenu->add_item(quit_program = new Quit(mwindow));
 137         quit_program->create_objects(save);
 138         filemenu->add_item(dump_menu = new MainDumpsMenu(mwindow));
 139         dump_menu->create_objects();
 140         filemenu->add_item(new LoadBackup(mwindow));
 141         filemenu->add_item(new SaveBackup(mwindow));
 142
 143         BC_Menu *editmenu;
 144         add_menu(editmenu = new BC_Menu(_("Edit")));
 145         editmenu->add_item(undo = new Undo(mwindow));
 146         editmenu->add_item(redo = new Redo(mwindow));
 147         editmenu->add_item(new BC_MenuItem("-"));
 148         editmenu->add_item(new Cut(mwindow));
 149         editmenu->add_item(new Copy(mwindow));
 150         editmenu->add_item(new Paste(mwindow));
 151         editmenu->add_item(new Clear(mwindow));
 152         editmenu->add_item(new PasteSilence(mwindow));
 153         editmenu->add_item(new MuteSelection(mwindow));
 154         editmenu->add_item(new TrimSelection(mwindow));
 155         editmenu->add_item(new SelectAll(mwindow));
 156         editmenu->add_item(new BC_MenuItem("-"));
 157         editmenu->add_item(new MenuEditShuffle(mwindow));
 158         editmenu->add_item(new MenuEditReverse(mwindow));
 159         editmenu->add_item(new MenuEditLength(mwindow));
 160         editmenu->add_item(new MenuEditAlign(mwindow));
 161         editmenu->add_item(new MenuTransitionLength(mwindow));
 162         editmenu->add_item(new DetachTransitions(mwindow));
 163         editmenu->add_item(new BC_MenuItem("-"));
 164         editmenu->add_item(new ClearLabels(mwindow));
 165         editmenu->add_item(new CutCommercials(mwindow));
 166         editmenu->add_item(new PasteSubttl(mwindow));
 167
 168         BC_Menu *keyframemenu;
 169         add_menu(keyframemenu = new BC_Menu(_("Keyframes")));
 170         keyframemenu->add_item(new CutKeyframes(mwindow));
 171         keyframemenu->add_item(new CopyKeyframes(mwindow));
 172         keyframemenu->add_item(new PasteKeyframes(mwindow));
 173         keyframemenu->add_item(new ClearKeyframes(mwindow));
 174         keyframemenu->add_item(new StraightenKeyframes(mwindow));
 175         keyframemenu->add_item(new BendKeyframes(mwindow));
 176         keyframemenu->add_item(keyframe_curve_type = new KeyframeCurveType(mwindow));
 177         keyframe_curve_type->create_objects();
 178         keyframe_curve_type->update(mwindow->edl->local_session->floatauto_type);
 179         keyframemenu->add_item(new BC_MenuItem("-"));
 180         keyframemenu->add_item(new CopyDefaultKeyframe(mwindow));
 181         keyframemenu->add_item(new PasteDefaultKeyframe(mwindow));
 182
 183
 184
 185
 186         add_menu(audiomenu = new BC_Menu(_("Audio")));
 187         audiomenu->add_item(new AddAudioTrack(mwindow));
 188         audiomenu->add_item(new DefaultATransition(mwindow));
 189         audiomenu->add_item(new MapAudio1(mwindow));
 190         audiomenu->add_item(new MapAudio2(mwindow));
 191         audiomenu->add_item(new MenuAttachTransition(mwindow, TRACK_AUDIO));
 192         audiomenu->add_item(new MenuAttachEffect(mwindow, TRACK_AUDIO));
 193         audiomenu->add_item(aeffects = new MenuAEffects(mwindow));
 194
 195         add_menu(videomenu = new BC_Menu(_("Video")));
 196         videomenu->add_item(new AddVideoTrack(mwindow));
 197         videomenu->add_item(new DefaultVTransition(mwindow));
 198         videomenu->add_item(new MenuAttachTransition(mwindow, TRACK_VIDEO));
 199         videomenu->add_item(new MenuAttachEffect(mwindow, TRACK_VIDEO));
 200         videomenu->add_item(veffects = new MenuVEffects(mwindow));
 201
 202         add_menu(trackmenu = new BC_Menu(_("Tracks")));
 203         trackmenu->add_item(new MoveTracksUp(mwindow));
 204         trackmenu->add_item(new MoveTracksDown(mwindow));
 205         trackmenu->add_item(new DeleteTracks(mwindow));
 206         trackmenu->add_item(new DeleteFirstTrack(mwindow));
 207         trackmenu->add_item(new DeleteLastTrack(mwindow));
 208         trackmenu->add_item(new ConcatenateTracks(mwindow));
 209         AppendTracks *append_tracks;
 210         trackmenu->add_item(append_tracks = new AppendTracks(mwindow));
 211         append_tracks->create_objects();
 212         trackmenu->add_item(new AddSubttlTrack(mwindow));
 213
 214         add_menu(settingsmenu = new BC_Menu(_("Settings")));
 215
 216         settingsmenu->add_item(new SetFormat(mwindow));
 217         settingsmenu->add_item(preferences = new PreferencesMenuitem(mwindow));
 218         ProxyMenuItem *proxy;
 219         settingsmenu->add_item(proxy = new ProxyMenuItem(mwindow));
 220         proxy->create_objects();
 221         mwindow->preferences_thread = preferences->thread;
 222         settingsmenu->add_item(cursor_on_frames = new CursorOnFrames(mwindow));
 223         settingsmenu->add_item(labels_follow_edits = new LabelsFollowEdits(mwindow));
 224         settingsmenu->add_item(plugins_follow_edits = new PluginsFollowEdits(mwindow));
 225         settingsmenu->add_item(keyframes_follow_edits = new KeyframesFollowEdits(mwindow));
 226         settingsmenu->add_item(typeless_keyframes = new TypelessKeyframes(mwindow));
 227         settingsmenu->add_item(new BC_MenuItem("-"));
 228         settingsmenu->add_item(new SaveSettingsNow(mwindow));
 229         settingsmenu->add_item(loop_playback = new LoopPlayback(mwindow));
 230         settingsmenu->add_item(brender_active = new SetBRenderActive(mwindow));
 231 // set scrubbing speed
 232 //      ScrubSpeed *scrub_speed;
 233 //      settingsmenu->add_item(scrub_speed = new ScrubSpeed(mwindow));
 234 //      if(mwindow->edl->session->scrub_speed == .5)
 235 //              scrub_speed->set_text(_("Fast Shuttle"));
 236
 237
 238
 239
 240
 241
 242         add_menu(viewmenu = new BC_Menu(_("View")));
 243         viewmenu->add_item(show_assets = new ShowAssets(mwindow, "0"));
 244         viewmenu->add_item(show_titles = new ShowTitles(mwindow, "1"));
 245         viewmenu->add_item(show_transitions = new ShowTransitions(mwindow, "2"));
 246         viewmenu->add_item(fade_automation = new ShowAutomation(mwindow, _("Fade"), "3", AUTOMATION_FADE));
 247         viewmenu->add_item(mute_automation = new ShowAutomation(mwindow, _("Mute"), "4", AUTOMATION_MUTE));
 248         viewmenu->add_item(mode_automation = new ShowAutomation(mwindow, _("Overlay mode"), "5", AUTOMATION_MODE));
 249         viewmenu->add_item(pan_automation = new ShowAutomation(mwindow, _("Pan"), "6", AUTOMATION_PAN));
 250         viewmenu->add_item(plugin_automation = new PluginAutomation(mwindow, "7"));
 251         viewmenu->add_item(mask_automation = new ShowAutomation(mwindow, _("Mask"), "8", AUTOMATION_MASK));
 252         viewmenu->add_item(speed_automation = new ShowAutomation(mwindow, _("Speed"), "9", AUTOMATION_SPEED));
 253
 254         camera_x = new ShowAutomation(mwindow, _("Camera X"), "Ctrl-Shift-X", AUTOMATION_CAMERA_X);
 255         camera_x->set_ctrl();  camera_x->set_shift();   viewmenu->add_item(camera_x);
 256         camera_y = new ShowAutomation(mwindow, _("Camera Y"), "Ctrl-Shift-Y", AUTOMATION_CAMERA_Y);
 257         camera_y->set_ctrl();  camera_y->set_shift();   viewmenu->add_item(camera_y);
 258         camera_z = new ShowAutomation(mwindow, _("Camera Z"), "Ctrl-Shift-Z", AUTOMATION_CAMERA_Z);
 259         camera_z->set_ctrl();  camera_z->set_shift();  viewmenu->add_item(camera_z);
 260         project_x = new ShowAutomation(mwindow, _("Projector X"), "Alt-Shift-X", AUTOMATION_PROJECTOR_X);
 261         project_x->set_alt();  project_x->set_shift();  viewmenu->add_item(project_x);
 262         project_y = new ShowAutomation(mwindow, _("Projector Y"), "Alt-Shift-Y", AUTOMATION_PROJECTOR_Y);
 263         project_y->set_alt();  project_y->set_shift();  viewmenu->add_item(project_y);
 264         project_z = new ShowAutomation(mwindow, _("Projector Z"), "Alt-Shift-Z", AUTOMATION_PROJECTOR_Z);
 265         project_z->set_alt();  project_z->set_shift();  viewmenu->add_item(project_z);
 266
 267         add_menu(windowmenu = new BC_Menu(_("Window")));
 268         windowmenu->add_item(show_vwindow = new ShowVWindow(mwindow));
 269         windowmenu->add_item(show_awindow = new ShowAWindow(mwindow));
 270         windowmenu->add_item(show_cwindow = new ShowCWindow(mwindow));
 271         windowmenu->add_item(show_gwindow = new ShowGWindow(mwindow));
 272         windowmenu->add_item(show_lwindow = new ShowLWindow(mwindow));
 273         windowmenu->add_item(new BC_MenuItem("-"));
 274         windowmenu->add_item(split_x = new SplitX(mwindow));
 275         windowmenu->add_item(split_y = new SplitY(mwindow));
 276         windowmenu->add_item(mixer_items = new MixerItems(mwindow));
 277         mixer_items->create_objects();
 278         windowmenu->add_item(new TileWindows(mwindow,_("Tile left"),0));
 279         windowmenu->add_item(new TileWindows(mwindow,_("Tile right"),1));
 280         windowmenu->add_item(new BC_MenuItem("-"));
 281
 282         windowmenu->add_item(new TileWindows(mwindow,_("Default positions"),-1,_("Ctrl-P"),'p'));
 283         windowmenu->add_item(load_layout = new LoadLayout(mwindow, _("Load layout..."),LAYOUT_LOAD));
 284         load_layout->create_objects();
 285         windowmenu->add_item(save_layout = new LoadLayout(mwindow, _("Save layout..."),LAYOUT_SAVE));
 286         save_layout->create_objects();
 287 }
 288
 289 int MainMenu::load_defaults(BC_Hash *defaults)
 290 {
 291         init_loads(defaults);
 292         init_aeffects(defaults);
 293         init_veffects(defaults);
 294         return 0;
 295 }
 296
 297 void MainMenu::update_toggles(int use_lock)
 298 {
 299         if(use_lock) lock_window("MainMenu::update_toggles");
 300         labels_follow_edits->set_checked(mwindow->edl->session->labels_follow_edits);
 301         plugins_follow_edits->set_checked(mwindow->edl->session->plugins_follow_edits);
 302         keyframes_follow_edits->set_checked(mwindow->edl->session->autos_follow_edits);
 303         typeless_keyframes->set_checked(mwindow->edl->session->typeless_keyframes);
 304         cursor_on_frames->set_checked(mwindow->edl->session->cursor_on_frames);
 305         loop_playback->set_checked(mwindow->edl->local_session->loop_playback);
 306
 307         show_assets->set_checked(mwindow->edl->session->show_assets);
 308         show_titles->set_checked(mwindow->edl->session->show_titles);
 309         show_transitions->set_checked(mwindow->edl->session->auto_conf->transitions);
 310         fade_automation->update_toggle();
 311         mute_automation->update_toggle();
 312         pan_automation->update_toggle();
 313         camera_x->update_toggle();
 314         camera_y->update_toggle();
 315         camera_z->update_toggle();
 316         project_x->update_toggle();
 317         project_y->update_toggle();
 318         project_z->update_toggle();
 319         plugin_automation->set_checked(mwindow->edl->session->auto_conf->plugins);
 320         mode_automation->update_toggle();
 321         mask_automation->update_toggle();
 322         speed_automation->update_toggle();
 323         split_x->set_checked(mwindow->gui->pane[TOP_RIGHT_PANE] != 0);
 324         split_y->set_checked(mwindow->gui->pane[BOTTOM_LEFT_PANE] != 0);
 325
 326         if(use_lock) mwindow->gui->unlock_window();
 327 }
 328
 329 int MainMenu::save_defaults(BC_Hash *defaults)
 330 {
 331         save_loads(defaults);
 332         save_aeffects(defaults);
 333         save_veffects(defaults);
 334         return 0;
 335 }
 336
 337
 338
 339
 340
 341 int MainMenu::quit()
 342 {
 343         quit_program->handle_event();
 344         return 0;
 345 }
 346
 347
 348
 349
 350
 351 // ================================== load most recent
 352
 353 int MainMenu::init_aeffects(BC_Hash *defaults)
 354 {
 355         total_aeffects = defaults->get((char*)"TOTAL_AEFFECTS", 0);
 356
 357         char string[BCTEXTLEN], title[BCTEXTLEN];
 358         if(total_aeffects) audiomenu->add_item(new BC_MenuItem("-"));
 359
 360         for(int i = 0; i < total_aeffects; i++)
 361         {
 362                 sprintf(string, "AEFFECTRECENT%d", i);
 363                 defaults->get(string, title);
 364                 audiomenu->add_item(aeffect[i] = new MenuAEffectItem(aeffects, title));
 365         }
 366         return 0;
 367 }
 368
 369 int MainMenu::init_veffects(BC_Hash *defaults)
 370 {
 371         total_veffects = defaults->get((char*)"TOTAL_VEFFECTS", 0);
 372
 373         char string[BCTEXTLEN], title[BCTEXTLEN];
 374         if(total_veffects) videomenu->add_item(new BC_MenuItem("-"));
 375
 376         for(int i = 0; i < total_veffects; i++)
 377         {
 378                 sprintf(string, "VEFFECTRECENT%d", i);
 379                 defaults->get(string, title);
 380                 videomenu->add_item(veffect[i] = new MenuVEffectItem(veffects, title));
 381         }
 382         return 0;
 383 }
 384
 385 void MainMenu::init_loads(BC_Hash *defaults)
 386 {
 387         total_loads = defaults->get((char*)"TOTAL_LOADS", 0);
 388         if( !total_loads ) return;
 389         filemenu->add_item(new BC_MenuItem("-"));
 390
 391         char string[BCTEXTLEN], path[BCTEXTLEN], filename[BCTEXTLEN];
 392         FileSystem dir;
 393 //printf("MainMenu::init_loads 2\n");
 394
 395         for(int i = 0; i < total_loads; i++) {
 396                 sprintf(string, "LOADPREVIOUS%d", i);
 397 //printf("MainMenu::init_loads 3\n");
 398                 defaults->get(string, path);
 399                 filemenu->add_item(load[i] = new LoadPrevious(mwindow, load_file));
 400                 dir.extract_name(filename, path, 0);
 401                 load[i]->set_text(filename);
 402                 load[i]->set_path(path);
 403         }
 404 }
 405
 406 // ============================ save most recent
 407
 408 int MainMenu::save_aeffects(BC_Hash *defaults)
 409 {
 410         defaults->update((char*)"TOTAL_AEFFECTS", total_aeffects);
 411         char string[BCTEXTLEN];
 412         for(int i = 0; i < total_aeffects; i++)
 413         {
 414                 sprintf(string, "AEFFECTRECENT%d", i);
 415                 defaults->update(string, aeffect[i]->get_text());
 416         }
 417         return 0;
 418 }
 419
 420 int MainMenu::save_veffects(BC_Hash *defaults)
 421 {
 422         defaults->update((char*)"TOTAL_VEFFECTS", total_veffects);
 423         char string[BCTEXTLEN];
 424         for(int i = 0; i < total_veffects; i++)
 425         {
 426                 sprintf(string, "VEFFECTRECENT%d", i);
 427                 defaults->update(string, veffect[i]->get_text());
 428         }
 429         return 0;
 430 }
 431
 432 int MainMenu::save_loads(BC_Hash *defaults)
 433 {
 434         defaults->update((char*)"TOTAL_LOADS", total_loads);
 435         char string[BCTEXTLEN];
 436         for(int i = 0; i < total_loads; i++)
 437         {
 438                 sprintf(string, "LOADPREVIOUS%d", i);
 439                 defaults->update(string, load[i]->path);
 440         }
 441         return 0;
 442 }
 443
 444 // =================================== add most recent
 445
 446 int MainMenu::add_aeffect(char *title)
 447 {
 448 // add bar for first effect
 449         if(total_aeffects == 0)
 450         {
 451                 audiomenu->add_item(new BC_MenuItem("-"));
 452         }
 453
 454 // test for existing copy of effect
 455         for(int i = 0; i < total_aeffects; i++)
 456         {
 457                 if(!strcmp(aeffect[i]->get_text(), title))     // already exists
 458                 {                                // swap for top effect
 459                         for(int j = i; j > 0; j--)   // move preceeding effects down
 460                         {
 461                                 aeffect[j]->set_text(aeffect[j - 1]->get_text());
 462                         }
 463                         aeffect[0]->set_text(title);
 464                         return 1;
 465                 }
 466         }
 467
 468 // add another blank effect
 469         if(total_aeffects < TOTAL_EFFECTS)
 470         {
 471                 audiomenu->add_item(
 472                         aeffect[total_aeffects] = new MenuAEffectItem(aeffects, (char*)""));
 473                 total_aeffects++;
 474         }
 475
 476 // cycle effect down
 477         for(int i = total_aeffects - 1; i > 0; i--)
 478         {
 479         // set menu item text
 480                 aeffect[i]->set_text(aeffect[i - 1]->get_text());
 481         }
 482
 483 // set up the new effect
 484         aeffect[0]->set_text(title);
 485         return 0;
 486 }
 487
 488 int MainMenu::add_veffect(char *title)
 489 {
 490 // add bar for first effect
 491         if(total_veffects == 0)
 492         {
 493                 videomenu->add_item(new BC_MenuItem("-"));
 494         }
 495
 496 // test for existing copy of effect
 497         for(int i = 0; i < total_veffects; i++)
 498         {
 499                 if(!strcmp(veffect[i]->get_text(), title))     // already exists
 500                 {                                // swap for top effect
 501                         for(int j = i; j > 0; j--)   // move preceeding effects down
 502                         {
 503                                 veffect[j]->set_text(veffect[j - 1]->get_text());
 504                         }
 505                         veffect[0]->set_text(title);
 506                         return 1;
 507                 }
 508         }
 509
 510 // add another blank effect
 511         if(total_veffects < TOTAL_EFFECTS)
 512         {
 513                 videomenu->add_item(veffect[total_veffects] =
 514                         new MenuVEffectItem(veffects, (char*)""));
 515                 total_veffects++;
 516         }
 517
 518 // cycle effect down
 519         for(int i = total_veffects - 1; i > 0; i--)
 520         {
 521 // set menu item text
 522                 veffect[i]->set_text(veffect[i - 1]->get_text());
 523         }
 524
 525 // set up the new effect
 526         veffect[0]->set_text(title);
 527         return 0;
 528 }
 529
 530 int MainMenu::add_load(char *path)
 531 {
 532         if(total_loads == 0)
 533 {
 534                 filemenu->add_item(new BC_MenuItem("-"));
 535         }
 536
 537 // test for existing copy
 538         FileSystem fs;
 539         char text[BCTEXTLEN], new_path[BCTEXTLEN];      // get text and path
 540         fs.extract_name(text, path);
 541         strcpy(new_path, path);
 542
 543         for(int i = 0; i < total_loads; i++)
 544         {
 545                 if(!strcmp(load[i]->get_text(), text))     // already exists
 546                 {                                // swap for top load
 547                         for(int j = i; j > 0; j--)   // move preceeding loads down
 548                         {
 549                                 load[j]->set_text(load[j - 1]->get_text());
 550                                 load[j]->set_path(load[j - 1]->path);
 551         }
 552                         load[0]->set_text(text);
 553                         load[0]->set_path(new_path);
 554
 555                         return 1;
 556                 }
 557         }
 558
 559 // add another load
 560         if(total_loads < TOTAL_LOADS)
 561         {
 562                 filemenu->add_item(load[total_loads] = new LoadPrevious(mwindow, load_file));
 563                 total_loads++;
 564         }
 565
 566 // cycle loads down
 567         for(int i = total_loads - 1; i > 0; i--)
 568         {
 569         // set menu item text
 570                 load[i]->set_text(load[i - 1]->get_text());
 571         // set filename
 572                 load[i]->set_path(load[i - 1]->path);
 573         }
 574
 575 // set up the new load
 576         load[0]->set_text(text);
 577         load[0]->set_path(new_path);
 578         return 0;
 579 }
 580
 581
 582
 583
 584
 585
 586
 587
 588 // ================================== menu items
 589
 590 MainDumpsSubMenu::MainDumpsSubMenu(BC_MenuItem *menu_item)
 591  : BC_SubMenu()
 592 {
 593         this->menu_item = menu_item;
 594 }
 595 MainDumpsSubMenu::~MainDumpsSubMenu()
 596 {
 597 }
 598
 599
 600 MainDumpsMenu::MainDumpsMenu(MWindow *mwindow)
 601  : BC_MenuItem(_("Dumps..."))
 602 {
 603         this->mwindow = mwindow;
 604         this->dumps_menu = 0;
 605 }
 606 MainDumpsMenu::~MainDumpsMenu()
 607 {
 608 }
 609
 610 void MainDumpsMenu::create_objects()
 611 {
 612         add_submenu(dumps_menu = new MainDumpsSubMenu(this));
 613 //      dumps_menu->add_item(new DumpCICache(mwindow));
 614         dumps_menu->add_item(new DumpEDL(mwindow));
 615         dumps_menu->add_item(new DumpPlugins(mwindow));
 616         dumps_menu->add_item(new DumpAssets(mwindow));
 617         dumps_menu->add_item(new DumpUndo(mwindow));
 618 };
 619
 620
 621 DumpCICache::DumpCICache(MWindow *mwindow)
 622  : BC_MenuItem(_("Dump CICache"))
 623 { this->mwindow = mwindow; }
 624
 625 int DumpCICache::handle_event()
 626 {
 627 //      mwindow->cache->dump();
 628         return 1;
 629 }
 630
 631 DumpEDL::DumpEDL(MWindow *mwindow)
 632  : BC_MenuItem(_("Dump EDL"))
 633 {
 634         this->mwindow = mwindow;
 635 }
 636
 637 int DumpEDL::handle_event()
 638 {
 639         mwindow->dump_edl();
 640         return 1;
 641 }
 642
 643 DumpPlugins::DumpPlugins(MWindow *mwindow)
 644  : BC_MenuItem(_("Dump Plugins"))
 645 {
 646         this->mwindow = mwindow;
 647 }
 648
 649 int DumpPlugins::handle_event()
 650 {
 651         mwindow->dump_plugins();
 652         return 1;
 653 }
 654
 655 DumpAssets::DumpAssets(MWindow *mwindow)
 656  : BC_MenuItem(_("Dump Assets"))
 657 { this->mwindow = mwindow; }
 658
 659 int DumpAssets::handle_event()
 660 {
 661         mwindow->edl->assets->dump();
 662         return 1;
 663 }
 664
 665 DumpUndo::DumpUndo(MWindow *mwindow)
 666  : BC_MenuItem(_("Dump Undo"))
 667 {
 668         this->mwindow = mwindow;
 669 }
 670
 671 int DumpUndo::handle_event()
 672 {
 673         mwindow->dump_undo();
 674         return 1;
 675 }
 676
 677 // ================================================= edit
 678
 679 Undo::Undo(MWindow *mwindow) : BC_MenuItem(_("Undo"), "z", 'z')
 680 {
 681         this->mwindow = mwindow;
 682 }
 683 int Undo::handle_event()
 684 {
 685         if( mwindow->session->current_operation == NO_OPERATION )
 686                 mwindow->undo_entry(mwindow->gui);
 687         return 1;
 688 }
 689 int Undo::update_caption(const char *new_caption)
 690 {
 691         char string[BCTEXTLEN];
 692         sprintf(string, _("Undo %s"), new_caption);
 693         set_text(string);
 694         return 0;
 695 }
 696
 697
 698 Redo::Redo(MWindow *mwindow) : BC_MenuItem(_("Redo"), _("Shift-Z"), 'Z')
 699 {
 700         set_shift(1);
 701         this->mwindow = mwindow;
 702 }
 703
 704 int Redo::handle_event()
 705 {
 706         if( mwindow->session->current_operation == NO_OPERATION )
 707                 mwindow->redo_entry(mwindow->gui);
 708         return 1;
 709 }
 710 int Redo::update_caption(const char *new_caption)
 711 {
 712         char string[BCTEXTLEN];
 713         sprintf(string, _("Redo %s"), new_caption);
 714         set_text(string);
 715         return 0;
 716 }
 717
 718 CutKeyframes::CutKeyframes(MWindow *mwindow)
 719  : BC_MenuItem(_("Cut keyframes"), _("Shift-X"), 'X')
 720 {
 721         set_shift();
 722         this->mwindow = mwindow;
 723 }
 724
 725 int CutKeyframes::handle_event()
 726 {
 727         if( mwindow->session->current_operation == NO_OPERATION )
 728                 mwindow->cut_automation();
 729         return 1;
 730 }
 731
 732 CopyKeyframes::CopyKeyframes(MWindow *mwindow)
 733  : BC_MenuItem(_("Copy keyframes"), _("Shift-C"), 'C')
 734 {
 735         set_shift();
 736         this->mwindow = mwindow;
 737 }
 738
 739 int CopyKeyframes::handle_event()
 740 {
 741         if( mwindow->session->current_operation == NO_OPERATION )
 742                 mwindow->copy_automation();
 743         return 1;
 744 }
 745
 746 PasteKeyframes::PasteKeyframes(MWindow *mwindow)
 747  : BC_MenuItem(_("Paste keyframes"), _("Shift-V"), 'V')
 748 {
 749         set_shift();
 750         this->mwindow = mwindow;
 751 }
 752
 753 int PasteKeyframes::handle_event()
 754 {
 755         if( mwindow->session->current_operation == NO_OPERATION )
 756                 mwindow->paste_automation();
 757         return 1;
 758 }
 759
 760 ClearKeyframes::ClearKeyframes(MWindow *mwindow)
 761  : BC_MenuItem(_("Clear keyframes"), _("Shift-Del"), DELETE)
 762 {
 763         set_shift();
 764         this->mwindow = mwindow;
 765 }
 766
 767 int ClearKeyframes::handle_event()
 768 {
 769         if( mwindow->session->current_operation == NO_OPERATION )
 770                 mwindow->clear_automation();
 771         return 1;
 772 }
 773
 774
 775
 776 StraightenKeyframes::StraightenKeyframes(MWindow *mwindow)
 777  : BC_MenuItem(_("Change to linear"))
 778 {
 779         this->mwindow = mwindow;
 780 }
 781
 782 int StraightenKeyframes::handle_event()
 783 {
 784         mwindow->set_automation_mode(FloatAuto::LINEAR);
 785         return 1;
 786 }
 787
 788
 789
 790
 791 BendKeyframes::BendKeyframes(MWindow *mwindow)
 792  : BC_MenuItem(_("Change to smooth"))
 793 {
 794         this->mwindow = mwindow;
 795 }
 796
 797 int BendKeyframes::handle_event()
 798 {
 799         mwindow->set_automation_mode(FloatAuto::SMOOTH);
 800         return 1;
 801 }
 802
 803
 804
 805 KeyframeCurveType::KeyframeCurveType(MWindow *mwindow)
 806  : BC_MenuItem(_("Create curve type..."))
 807 {
 808         this->mwindow = mwindow;
 809         this->curve_menu = 0;
 810 }
 811 KeyframeCurveType::~KeyframeCurveType()
 812 {
 813 }
 814
 815 void KeyframeCurveType::create_objects()
 816 {
 817         add_submenu(curve_menu = new KeyframeCurveTypeMenu(this));
 818         for( int i=FloatAuto::SMOOTH; i<=FloatAuto::FREE; ++i ) {
 819                 KeyframeCurveTypeItem *curve_type_item = new KeyframeCurveTypeItem(i, this);
 820                 curve_menu->add_submenuitem(curve_type_item);
 821         }
 822 }
 823
 824 void KeyframeCurveType::update(int curve_type)
 825 {
 826         for( int i=0; i<curve_menu->total_items(); ++i ) {
 827                 KeyframeCurveTypeItem *curve_type_item = (KeyframeCurveTypeItem *)curve_menu->get_item(i);
 828                 curve_type_item->set_checked(curve_type_item->type == curve_type);
 829         }
 830 }
 831
 832 int KeyframeCurveType::handle_event()
 833 {
 834         return 1;
 835 }
 836
 837 KeyframeCurveTypeMenu::KeyframeCurveTypeMenu(KeyframeCurveType *menu_item)
 838  : BC_SubMenu()
 839 {
 840         this->menu_item = menu_item;
 841 }
 842 KeyframeCurveTypeMenu::~KeyframeCurveTypeMenu()
 843 {
 844 }
 845
 846 KeyframeCurveTypeItem::KeyframeCurveTypeItem(int type, KeyframeCurveType *main_item)
 847  : BC_MenuItem(FloatAuto::curve_name(type))
 848 {
 849         this->type = type;
 850         this->main_item = main_item;
 851 }
 852 KeyframeCurveTypeItem::~KeyframeCurveTypeItem()
 853 {
 854 }
 855
 856 int KeyframeCurveTypeItem::handle_event()
 857 {
 858         main_item->update(type);
 859         main_item->mwindow->set_keyframe_type(type);
 860         return 1;
 861 }
 862
 863
 864 CutDefaultKeyframe::CutDefaultKeyframe(MWindow *mwindow)
 865  : BC_MenuItem(_("Cut default keyframe"), _("Alt-x"), 'x')
 866 {
 867         set_alt();
 868         this->mwindow = mwindow;
 869 }
 870
 871 int CutDefaultKeyframe::handle_event()
 872 {
 873         if( mwindow->session->current_operation == NO_OPERATION )
 874                 mwindow->cut_default_keyframe();
 875         return 1;
 876 }
 877
 878 CopyDefaultKeyframe::CopyDefaultKeyframe(MWindow *mwindow)
 879  : BC_MenuItem(_("Copy default keyframe"), _("Alt-c"), 'c')
 880 {
 881         set_alt();
 882         this->mwindow = mwindow;
 883 }
 884
 885 int CopyDefaultKeyframe::handle_event()
 886 {
 887         if( mwindow->session->current_operation == NO_OPERATION )
 888                 mwindow->copy_default_keyframe();
 889         return 1;
 890 }
 891
 892 PasteDefaultKeyframe::PasteDefaultKeyframe(MWindow *mwindow)
 893  : BC_MenuItem(_("Paste default keyframe"), _("Alt-v"), 'v')
 894 {
 895         set_alt();
 896         this->mwindow = mwindow;
 897 }
 898
 899 int PasteDefaultKeyframe::handle_event()
 900 {
 901         if( mwindow->session->current_operation == NO_OPERATION )
 902                 mwindow->paste_default_keyframe();
 903         return 1;
 904 }
 905
 906 ClearDefaultKeyframe::ClearDefaultKeyframe(MWindow *mwindow)
 907  : BC_MenuItem(_("Clear default keyframe"), _("Alt-Del"), DELETE)
 908 {
 909         set_alt();
 910         this->mwindow = mwindow;
 911 }
 912
 913 int ClearDefaultKeyframe::handle_event()
 914 {
 915         if( mwindow->session->current_operation == NO_OPERATION )
 916                 mwindow->clear_default_keyframe();
 917         return 1;
 918 }
 919
 920 Cut::Cut(MWindow *mwindow)
 921  : BC_MenuItem(_("Split | Cut"), "x", 'x')
 922 {
 923         this->mwindow = mwindow;
 924 }
 925
 926 int Cut::handle_event()
 927 {
 928         if( mwindow->session->current_operation == NO_OPERATION )
 929                 mwindow->cut();
 930         return 1;
 931 }
 932
 933 Copy::Copy(MWindow *mwindow)
 934  : BC_MenuItem(_("Copy"), "c", 'c')
 935 {
 936         this->mwindow = mwindow;
 937 }
 938
 939 int Copy::handle_event()
 940 {
 941         if( mwindow->session->current_operation == NO_OPERATION )
 942                 mwindow->copy();
 943         return 1;
 944 }
 945
 946 Paste::Paste(MWindow *mwindow)
 947  : BC_MenuItem(_("Paste"), "v", 'v')
 948 {
 949         this->mwindow = mwindow;
 950 }
 951
 952 int Paste::handle_event()
 953 {
 954         if( mwindow->session->current_operation == NO_OPERATION )
 955                 mwindow->paste();
 956         return 1;
 957 }
 958
 959 Clear::Clear(MWindow *mwindow)
 960  : BC_MenuItem(_("Clear"), _("Del"), DELETE)
 961 {
 962         this->mwindow = mwindow;
 963 }
 964
 965 int Clear::handle_event()
 966 {
 967         if( mwindow->session->current_operation == NO_OPERATION ) {
 968                 mwindow->cwindow->gui->lock_window("Clear::handle_event");
 969                 mwindow->clear_entry();
 970                 mwindow->cwindow->gui->unlock_window();
 971         }
 972         return 1;
 973 }
 974
 975 PasteSilence::PasteSilence(MWindow *mwindow)
 976  : BC_MenuItem(_("Paste silence"), _("Shift-Space"), ' ')
 977 {
 978         this->mwindow = mwindow;
 979         set_shift();
 980 }
 981
 982 int PasteSilence::handle_event()
 983 {
 984         if( mwindow->session->current_operation == NO_OPERATION )
 985                 mwindow->paste_silence();
 986         return 1;
 987 }
 988
 989 SelectAll::SelectAll(MWindow *mwindow)
 990  : BC_MenuItem(_("Select All"), "a", 'a')
 991 {
 992         this->mwindow = mwindow;
 993 }
 994
 995 int SelectAll::handle_event()
 996 {
 997         if( mwindow->session->current_operation == NO_OPERATION )
 998                 mwindow->select_all();
 999         return 1;
1000 }
1001
1002 ClearLabels::ClearLabels(MWindow *mwindow) : BC_MenuItem(_("Clear labels"))
1003 {
1004         this->mwindow = mwindow;
1005 }
1006
1007 int ClearLabels::handle_event()
1008 {
1009         mwindow->clear_labels();
1010         return 1;
1011 }
1012
1013 CutCommercials::CutCommercials(MWindow *mwindow) : BC_MenuItem(_("Cut ads"))
1014 {
1015         this->mwindow = mwindow;
1016 }
1017
1018 int CutCommercials::handle_event()
1019 {
1020         mwindow->cut_commercials();
1021         return 1;
1022 }
1023
1024 DetachTransitions::DetachTransitions(MWindow *mwindow)
1025  : BC_MenuItem(_("Detach transitions"))
1026 {
1027         this->mwindow = mwindow;
1028 }
1029
1030 int DetachTransitions::handle_event()
1031 {
1032         mwindow->detach_transitions();
1033         return 1;
1034 }
1035
1036 MuteSelection::MuteSelection(MWindow *mwindow)
1037  : BC_MenuItem(_("Mute Region"), "m", 'm')
1038 {
1039         this->mwindow = mwindow;
1040 }
1041
1042 int MuteSelection::handle_event()
1043 {
1044         if( mwindow->session->current_operation == NO_OPERATION )
1045                 mwindow->mute_selection();
1046         return 1;
1047 }
1048
1049
1050 TrimSelection::TrimSelection(MWindow *mwindow)
1051  : BC_MenuItem(_("Trim Selection"))
1052 {
1053         this->mwindow = mwindow;
1054 }
1055
1056 int TrimSelection::handle_event()
1057 {
1058         mwindow->trim_selection();
1059         return 1;
1060 }
1061
1062
1063
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073 // ============================================= audio
1074
1075 AddAudioTrack::AddAudioTrack(MWindow *mwindow)
1076  : BC_MenuItem(_("Add track"), "t", 't')
1077 {
1078         this->mwindow = mwindow;
1079 }
1080
1081 int AddAudioTrack::handle_event()
1082 {
1083         if( mwindow->session->current_operation == NO_OPERATION )
1084                 mwindow->add_audio_track_entry(0, 0);
1085         return 1;
1086 }
1087
1088 DeleteAudioTrack::DeleteAudioTrack(MWindow *mwindow)
1089  : BC_MenuItem(_("Delete track"))
1090 {
1091         this->mwindow = mwindow;
1092 }
1093
1094 int DeleteAudioTrack::handle_event()
1095 {
1096         return 1;
1097 }
1098
1099 DefaultATransition::DefaultATransition(MWindow *mwindow)
1100  : BC_MenuItem(_("Default Transition"), "u", 'u')
1101 {
1102         this->mwindow = mwindow;
1103 }
1104
1105 int DefaultATransition::handle_event()
1106 {
1107         if( mwindow->session->current_operation == NO_OPERATION )
1108                 mwindow->paste_audio_transition();
1109         return 1;
1110 }
1111
1112
1113 MapAudio1::MapAudio1(MWindow *mwindow)
1114  : BC_MenuItem(_("Map 1:1"))
1115 {
1116         this->mwindow = mwindow;
1117 }
1118
1119 int MapAudio1::handle_event()
1120 {
1121         mwindow->map_audio(MWindow::AUDIO_1_TO_1);
1122         return 1;
1123 }
1124
1125 MapAudio2::MapAudio2(MWindow *mwindow)
1126  : BC_MenuItem(_("Map 5.1:2"))
1127 {
1128         this->mwindow = mwindow;
1129 }
1130
1131 int MapAudio2::handle_event()
1132 {
1133         mwindow->map_audio(MWindow::AUDIO_5_1_TO_2);
1134         return 1;
1135 }
1136
1137
1138
1139
1140 // ============================================= video
1141
1142
1143 AddVideoTrack::AddVideoTrack(MWindow *mwindow)
1144  : BC_MenuItem(_("Add track"), _("Shift-T"), 'T')
1145 {
1146         set_shift();
1147         this->mwindow = mwindow;
1148 }
1149
1150 int AddVideoTrack::handle_event()
1151 {
1152         if( mwindow->session->current_operation == NO_OPERATION )
1153                 mwindow->add_video_track_entry();
1154         return 1;
1155 }
1156
1157
1158 DeleteVideoTrack::DeleteVideoTrack(MWindow *mwindow)
1159  : BC_MenuItem(_("Delete track"))
1160 {
1161         this->mwindow = mwindow;
1162 }
1163
1164 int DeleteVideoTrack::handle_event()
1165 {
1166         return 1;
1167 }
1168
1169
1170
1171 ResetTranslation::ResetTranslation(MWindow *mwindow)
1172  : BC_MenuItem(_("Reset Translation"))
1173 {
1174         this->mwindow = mwindow;
1175 }
1176
1177 int ResetTranslation::handle_event()
1178 {
1179         return 1;
1180 }
1181
1182
1183
1184 DefaultVTransition::DefaultVTransition(MWindow *mwindow)
1185  : BC_MenuItem(_("Default Transition"), _("Shift-U"), 'U')
1186 {
1187         set_shift();
1188         this->mwindow = mwindow;
1189 }
1190
1191 int DefaultVTransition::handle_event()
1192 {
1193         if( mwindow->session->current_operation == NO_OPERATION )
1194                 mwindow->paste_video_transition();
1195         return 1;
1196 }
1197
1198
1199
1200
1201
1202
1203
1204
1205
1206
1207
1208
1209
1210
1211 // ============================================ settings
1212
1213 DeleteTracks::DeleteTracks(MWindow *mwindow)
1214  : BC_MenuItem(_("Delete tracks"))
1215 {
1216         this->mwindow = mwindow;
1217 }
1218
1219 int DeleteTracks::handle_event()
1220 {
1221         mwindow->delete_tracks();
1222         return 1;
1223 }
1224
1225 DeleteFirstTrack::DeleteFirstTrack(MWindow *mwindow)
1226  : BC_MenuItem(_("Delete first track"), "Shift-D", 'D')
1227 {
1228         set_shift(1);
1229         this->mwindow = mwindow;
1230 }
1231
1232 int DeleteFirstTrack::handle_event()
1233 {
1234         if( mwindow->session->current_operation == NO_OPERATION ) {
1235                 Track *track = mwindow->edl->tracks->first;
1236                 if( track ) mwindow->delete_track(track);
1237         }
1238         return 1;
1239 }
1240
1241 DeleteLastTrack::DeleteLastTrack(MWindow *mwindow)
1242  : BC_MenuItem(_("Delete last track"), "d", 'd')
1243 {
1244         this->mwindow = mwindow;
1245 }
1246
1247 int DeleteLastTrack::handle_event()
1248 {
1249         if( mwindow->session->current_operation == NO_OPERATION ) {
1250                 Track *track = mwindow->edl->tracks->last;
1251                 if( track ) mwindow->delete_track(track);
1252         }
1253         return 1;
1254 }
1255
1256 MoveTracksUp::MoveTracksUp(MWindow *mwindow)
1257  : BC_MenuItem(_("Move tracks up"), _("Shift-Up"), UP)
1258 {
1259         this->mwindow = mwindow;
1260         set_shift();
1261 }
1262
1263 int MoveTracksUp::handle_event()
1264 {
1265         if( mwindow->session->current_operation == NO_OPERATION )
1266                 mwindow->move_tracks_up();
1267         return 1;
1268 }
1269
1270 MoveTracksDown::MoveTracksDown(MWindow *mwindow)
1271  : BC_MenuItem(_("Move tracks down"), _("Shift-Down"), DOWN)
1272 {
1273         set_shift(); this->mwindow = mwindow;
1274 }
1275
1276 int MoveTracksDown::handle_event()
1277 {
1278         if( mwindow->session->current_operation == NO_OPERATION )
1279                 mwindow->move_tracks_down();
1280         return 1;
1281 }
1282
1283
1284
1285
1286 ConcatenateTracks::ConcatenateTracks(MWindow *mwindow)
1287  : BC_MenuItem(_("Concatenate tracks"))
1288 {
1289         set_shift();
1290         this->mwindow = mwindow;
1291 }
1292
1293 int ConcatenateTracks::handle_event()
1294 {
1295         mwindow->concatenate_tracks();
1296         return 1;
1297 }
1298
1299
1300
1301
1302
1303 LoopPlayback::LoopPlayback(MWindow *mwindow)
1304  : BC_MenuItem(_("Loop Playback"), _("Shift-L"), 'L')
1305 {
1306         this->mwindow = mwindow;
1307         set_checked(mwindow->edl->local_session->loop_playback);
1308         set_shift();
1309 }
1310
1311 int LoopPlayback::handle_event()
1312 {
1313         if( mwindow->session->current_operation == NO_OPERATION ) {
1314                 mwindow->toggle_loop_playback();
1315                 set_checked(mwindow->edl->local_session->loop_playback);
1316         }
1317         return 1;
1318 }
1319
1320
1321
1322 // ============================================= subtitle
1323
1324
1325 AddSubttlTrack::AddSubttlTrack(MWindow *mwindow)
1326  : BC_MenuItem(_("Add subttl"), _("Shift-Y"), 'Y')
1327 {
1328         set_shift();
1329         this->mwindow = mwindow;
1330 }
1331
1332 int AddSubttlTrack::handle_event()
1333 {
1334         if( mwindow->session->current_operation == NO_OPERATION )
1335                 mwindow->add_subttl_track_entry();
1336         return 1;
1337 }
1338
1339 PasteSubttl::PasteSubttl(MWindow *mwindow)
1340  : BC_MenuItem(_("paste subttl"), "y", 'y')
1341 {
1342         this->mwindow = mwindow;
1343 }
1344
1345 int PasteSubttl::handle_event()
1346 {
1347         if( mwindow->session->current_operation == NO_OPERATION )
1348                 mwindow->gui->swindow->paste_subttl();
1349         return 1;
1350 }
1351
1352
1353 SetBRenderActive::SetBRenderActive(MWindow *mwindow)
1354  : BC_MenuItem(_("Toggle background rendering"),_("Shift-G"),'G')
1355 {
1356         this->mwindow = mwindow;
1357         set_shift(1);
1358 }
1359
1360 int SetBRenderActive::handle_event()
1361 {
1362         if( mwindow->session->current_operation == NO_OPERATION ) {
1363                 int v = mwindow->brender_active ? 0 : 1;
1364                 set_checked(v);
1365                 mwindow->set_brender_active(v);
1366         }
1367         return 1;
1368 }
1369
1370
1371 LabelsFollowEdits::LabelsFollowEdits(MWindow *mwindow)
1372  : BC_MenuItem(_("Edit labels"))
1373 {
1374         this->mwindow = mwindow;
1375         set_checked(mwindow->edl->session->labels_follow_edits);
1376 }
1377
1378 int LabelsFollowEdits::handle_event()
1379 {
1380         set_checked(get_checked() ^ 1);
1381         mwindow->set_labels_follow_edits(get_checked());
1382         return 1;
1383 }
1384
1385
1386
1387
1388 PluginsFollowEdits::PluginsFollowEdits(MWindow *mwindow)
1389  : BC_MenuItem(_("Edit effects"))
1390 {
1391         this->mwindow = mwindow;
1392         set_checked(mwindow->edl->session->plugins_follow_edits);
1393 }
1394
1395 int PluginsFollowEdits::handle_event()
1396 {
1397         set_checked(get_checked() ^ 1);
1398         mwindow->edl->session->plugins_follow_edits = get_checked();
1399         return 1;
1400 }
1401
1402
1403
1404
1405 KeyframesFollowEdits::KeyframesFollowEdits(MWindow *mwindow)
1406  : BC_MenuItem(_("Keyframes follow edits"))
1407 {
1408         this->mwindow = mwindow;
1409         set_checked(mwindow->edl->session->autos_follow_edits);
1410 }
1411
1412 int KeyframesFollowEdits::handle_event()
1413 {
1414         mwindow->edl->session->autos_follow_edits ^= 1;
1415         set_checked(!get_checked());
1416         return 1;
1417 }
1418
1419
1420 CursorOnFrames::CursorOnFrames(MWindow *mwindow)
1421  : BC_MenuItem(_("Align cursor on frames"),_("Ctrl-a"),'a')
1422 {
1423         this->mwindow = mwindow;
1424         set_checked(mwindow->edl->session->cursor_on_frames);
1425         set_ctrl(1);
1426 }
1427
1428 int CursorOnFrames::handle_event()
1429 {
1430         mwindow->edl->session->cursor_on_frames = !mwindow->edl->session->cursor_on_frames;
1431         set_checked(mwindow->edl->session->cursor_on_frames);
1432         return 1;
1433 }
1434
1435
1436 TypelessKeyframes::TypelessKeyframes(MWindow *mwindow)
1437  : BC_MenuItem(_("Typeless keyframes"))
1438 {
1439         this->mwindow = mwindow;
1440         set_checked(mwindow->edl->session->typeless_keyframes);
1441 }
1442
1443 int TypelessKeyframes::handle_event()
1444 {
1445         mwindow->edl->session->typeless_keyframes = !mwindow->edl->session->typeless_keyframes;
1446         set_checked(mwindow->edl->session->typeless_keyframes);
1447         return 1;
1448 }
1449
1450
1451 ScrubSpeed::ScrubSpeed(MWindow *mwindow)
1452  : BC_MenuItem(_("Slow Shuttle"))
1453 {
1454         this->mwindow = mwindow;
1455 }
1456
1457 int ScrubSpeed::handle_event()
1458 {
1459         if(mwindow->edl->session->scrub_speed == .5)
1460         {
1461                 mwindow->edl->session->scrub_speed = 2;
1462                 set_text(_("Slow Shuttle"));
1463         }
1464         else
1465         {
1466                 mwindow->edl->session->scrub_speed = .5;
1467                 set_text(_("Fast Shuttle"));
1468         }
1469         return 1;
1470 }
1471
1472 SaveSettingsNow::SaveSettingsNow(MWindow *mwindow)
1473  : BC_MenuItem(_("Save settings now"),_("Ctrl-s"),'s')
1474 {
1475         this->mwindow = mwindow;
1476         set_ctrl(1);
1477 }
1478
1479 int SaveSettingsNow::handle_event()
1480 {
1481         mwindow->save_defaults();
1482         mwindow->save_backup();
1483         mwindow->gui->show_message(_("Saved settings."));
1484         return 1;
1485 }
1486
1487
1488
1489 // ============================================ window
1490
1491
1492
1493
1494
1495 ShowVWindow::ShowVWindow(MWindow *mwindow)
1496  : BC_MenuItem(_("Show Viewer"))
1497 {
1498         this->mwindow = mwindow;
1499         set_checked(mwindow->session->show_vwindow);
1500 }
1501 int ShowVWindow::handle_event()
1502 {
1503         mwindow->show_vwindow();
1504         return 1;
1505 }
1506
1507 ShowAWindow::ShowAWindow(MWindow *mwindow)
1508  : BC_MenuItem(_("Show Resources"))
1509 {
1510         this->mwindow = mwindow;
1511         set_checked(mwindow->session->show_awindow);
1512 }
1513 int ShowAWindow::handle_event()
1514 {
1515         mwindow->show_awindow();
1516         return 1;
1517 }
1518
1519 ShowCWindow::ShowCWindow(MWindow *mwindow)
1520  : BC_MenuItem(_("Show Compositor"))
1521 {
1522         this->mwindow = mwindow;
1523         set_checked(mwindow->session->show_cwindow);
1524 }
1525 int ShowCWindow::handle_event()
1526 {
1527         mwindow->show_cwindow();
1528         return 1;
1529 }
1530
1531
1532 ShowGWindow::ShowGWindow(MWindow *mwindow)
1533  : BC_MenuItem(_("Show Overlays"), _("Ctrl-0"), '0')
1534 {
1535         this->mwindow = mwindow;
1536         set_ctrl(1);
1537         set_checked(mwindow->session->show_gwindow);
1538 }
1539 int ShowGWindow::handle_event()
1540 {
1541         if( mwindow->session->current_operation == NO_OPERATION ) {
1542                 if( !mwindow->session->show_gwindow )
1543                         mwindow->show_gwindow();
1544                 else
1545                         mwindow->hide_gwindow();
1546                 set_checked(mwindow->session->show_gwindow);
1547         }
1548         return 1;
1549 }
1550
1551
1552 ShowLWindow::ShowLWindow(MWindow *mwindow)
1553  : BC_MenuItem(_("Show Levels"))
1554 {
1555         this->mwindow = mwindow;
1556         set_checked(mwindow->session->show_lwindow);
1557 }
1558 int ShowLWindow::handle_event()
1559 {
1560         mwindow->show_lwindow();
1561         return 1;
1562 }
1563
1564 TileWindows::TileWindows(MWindow *mwindow, const char *item_title, int config,
1565                 const char *hot_keytext, int hot_key)
1566  : BC_MenuItem(item_title, hot_keytext, hot_key)
1567 {
1568         this->mwindow = mwindow;
1569         this->config = config;
1570         if( hot_key ) set_ctrl(1);
1571 }
1572 int TileWindows::handle_event()
1573 {
1574         if( mwindow->session->current_operation == NO_OPERATION ) {
1575                 int window_config = config >= 0 ? config :
1576                         mwindow->session->window_config;
1577                 if( mwindow->tile_windows(window_config) ) {
1578                         mwindow->restart_status = 1;
1579                         mwindow->gui->set_done(0);
1580                 }
1581         }
1582         return 1;
1583 }
1584
1585 SplitX::SplitX(MWindow *mwindow)
1586  : BC_MenuItem(_("Split X pane"), _("Ctrl-1"), '1')
1587 {
1588         this->mwindow = mwindow;
1589         set_ctrl(1);
1590         set_checked(mwindow->gui->pane[TOP_RIGHT_PANE] != 0);
1591 }
1592 int SplitX::handle_event()
1593 {
1594         if( mwindow->session->current_operation == NO_OPERATION )
1595                 mwindow->split_x();
1596         return 1;
1597 }
1598
1599 SplitY::SplitY(MWindow *mwindow)
1600  : BC_MenuItem(_("Split Y pane"), _("Ctrl-2"), '2')
1601 {
1602         this->mwindow = mwindow;
1603         set_ctrl(1);
1604         set_checked(mwindow->gui->pane[BOTTOM_LEFT_PANE] != 0);
1605 }
1606 int SplitY::handle_event()
1607 {
1608         if( mwindow->session->current_operation == NO_OPERATION )
1609                 mwindow->split_y();
1610         return 1;
1611 }
1612
1613
1614 MixerItems::MixerItems(MWindow *mwindow)
1615  : BC_MenuItem(_("Mixers..."))
1616 {
1617         this->mwindow = mwindow;
1618 }
1619
1620 void MixerItems::create_objects()
1621 {
1622         BC_SubMenu *mixer_submenu = new BC_SubMenu();
1623         add_submenu(mixer_submenu);
1624         mixer_submenu->add_submenuitem(new MixerViewer(mwindow));
1625         mixer_submenu->add_submenuitem(new TileMixers(mwindow));
1626         mixer_submenu->add_submenuitem(new AlignMixers(mwindow));
1627 }
1628
1629 MixerViewer::MixerViewer(MWindow *mwindow)
1630  : BC_MenuItem(_("Mixer Viewer"), _("Shift-M"), 'M')
1631 {
1632         this->mwindow = mwindow;
1633         set_shift(1);
1634 }
1635
1636 int MixerViewer::handle_event()
1637 {
1638         mwindow->start_mixer();
1639         return 1;
1640 }
1641
1642 TileMixers::TileMixers(MWindow *mwindow)
1643  : BC_MenuItem(_("Tile mixers"), "Alt-t", 't')
1644 {
1645         this->mwindow = mwindow;
1646         set_alt();
1647 }
1648
1649 int TileMixers::handle_event()
1650 {
1651         mwindow->tile_mixers();
1652         return 1;
1653 }
1654
1655 AlignMixers::AlignMixers(MWindow *mwindow)
1656  : BC_MenuItem(_("Align mixers"))
1657 {
1658         this->mwindow = mwindow;
1659 }
1660
1661 int AlignMixers::handle_event()
1662 {
1663         int wx, wy;
1664         mwindow->gui->get_abs_cursor(wx, wy);
1665         mwindow->mixers_align->start_dialog(wx, wy);
1666         return 1;
1667 }
1668
1669
1670 LoadLayoutItem::LoadLayoutItem(LoadLayout *load_layout, const char *text, int idx, int hotkey)
1671  : BC_MenuItem(text, "", hotkey)
1672 {
1673         this->idx = idx;
1674         this->load_layout = load_layout;
1675         if( hotkey ) {
1676                 char hot_txt[BCSTRLEN];
1677                 sprintf(hot_txt, _("Ctrl-Shift+F%d"), hotkey-KEY_F1+1);
1678                 set_ctrl();  set_shift();
1679                 set_hotkey_text(hot_txt);
1680         }
1681 }
1682
1683
1684 int LoadLayoutItem::handle_event()
1685 {
1686 // key_press hotkey skips over activate_submenu
1687         load_layout->update();
1688         MWindow *mwindow = load_layout->mwindow;
1689         switch( load_layout->action ) {
1690         case LAYOUT_LOAD:
1691                 mwindow->load_layout(layout_file);
1692                 break;
1693         case LAYOUT_SAVE: {
1694                 int wx = 0, wy = 0;
1695                 mwindow->gui->get_abs_cursor(wx, wy);
1696                 load_layout->layout_dialog->start_confirm_dialog(wx, wy, idx);
1697                 break; }
1698         }
1699         return 1;
1700 }
1701
1702 LoadLayout::LoadLayout(MWindow *mwindow, const char *text, int action)
1703  : BC_MenuItem(text)
1704 {
1705         this->mwindow = mwindow;
1706         this->action = action;
1707         this->layout_dialog = new LoadLayoutDialog(this);
1708 }
1709
1710 LoadLayout::~LoadLayout()
1711 {
1712         delete layout_dialog;
1713 }
1714
1715 void LoadLayout::create_objects()
1716 {
1717         BC_SubMenu *layout_submenu = new BC_SubMenu();
1718         add_submenu(layout_submenu);
1719
1720         for( int i=0; i<LAYOUTS_MAX; ++i ) {
1721                 char text[BCSTRLEN];
1722                 sprintf(text, _("Layout %d"), i+1);
1723                 LoadLayoutItem *item = new LoadLayoutItem(this, text, i,
1724                                 action==LAYOUT_LOAD ? KEY_F1+i : 0);
1725                 layout_submenu->add_submenuitem(item);
1726         }
1727 }
1728
1729 int LoadLayout::activate_submenu()
1730 {
1731         update();
1732         return BC_MenuItem::activate_submenu();
1733 }
1734
1735 void LoadLayout::update()
1736 {
1737         FileSystem fs;
1738         fs.set_filter("layout*_rc");
1739         int ret = fs.update(File::get_config_path());
1740         int sz = !ret ? fs.dir_list.size() : 0;
1741         BC_SubMenu *layout_submenu = get_submenu();
1742
1743         for( int i=0; i<LAYOUTS_MAX; ++i ) {
1744                 LoadLayoutItem* item = (LoadLayoutItem *)
1745                         layout_submenu->get_item(i);
1746                 char layout_text[BCSTRLEN];  layout_text[0] = 0;
1747                 int n = sz, id = i+1;
1748                 while( --n >= 0 ) {
1749                         char *np = fs.dir_list[n]->name;
1750                         char *cp = strrchr(np, '_'), *bp = 0;
1751                         int no = strtol(np+6, &bp, 10);
1752                         if( no != id || !bp ) continue;
1753                         if( bp == cp ) {  n = -1;  break; }
1754                         if( *bp++ == '_' && bp < cp && !strcmp(cp, "_rc") ) {
1755                                 int k = cp - bp;  char *tp = layout_text;
1756                                 if( k > LAYOUT_NAME_LEN ) k = LAYOUT_NAME_LEN;
1757                                 while( --k >= 0 ) *tp++ = *bp++;
1758                                 *tp = 0;
1759                                 break;
1760                         }
1761                 }
1762                 strcpy(item->layout_text, layout_text);
1763                 char *lp = item->layout_file;
1764                 int k = sprintf(lp, LAYOUT_FILE, id);
1765                 if( n >= 0 && layout_text[0] )
1766                         sprintf(lp + k-2, "%s_rc", layout_text);
1767                 else
1768                         sprintf(layout_text, _("Layout %d"), id);
1769                 item->set_text(layout_text);
1770         }
1771 }
1772
1773 LoadLayoutDialog::LoadLayoutDialog(LoadLayout *load_layout)
1774 {
1775         this->load_layout = load_layout;
1776         wx = 0;  wy = 0;
1777         idx = -1;
1778         lgui = 0;
1779 }
1780
1781 LoadLayoutDialog::~LoadLayoutDialog()
1782 {
1783         close_window();
1784 }
1785
1786 void LoadLayoutDialog::handle_done_event(int result)
1787 {
1788         if( result ) return;
1789         char layout_file[BCSTRLEN];
1790         BC_SubMenu *layout_submenu = load_layout->get_submenu();
1791         LoadLayoutItem* item =
1792                 (LoadLayoutItem *) layout_submenu->get_item(idx);
1793         snprintf(layout_file, sizeof(layout_file), "%s", item->layout_file);
1794         load_layout->mwindow->delete_layout(layout_file);
1795         int k = sprintf(layout_file, LAYOUT_FILE, idx+1);
1796         const char *text = lgui->name_text->get_text();
1797         if( text[0] )
1798                 snprintf(layout_file + k-2, sizeof(layout_file)-k+2, "%s_rc", text);
1799         load_layout->mwindow->save_layout(layout_file);
1800 }
1801
1802 void LoadLayoutDialog::handle_close_event(int result)
1803 {
1804         lgui = 0;
1805 }
1806
1807 BC_Window *LoadLayoutDialog::new_gui()
1808 {
1809         lgui = new LoadLayoutConfirm(this, wx, wy);
1810         lgui->create_objects();
1811         return lgui;
1812 }
1813
1814 void LoadLayoutDialog::start_confirm_dialog(int wx, int wy, int idx)
1815 {
1816         close_window();
1817         this->wx = wx;  this->wy = wy;
1818         this->idx = idx;
1819         start();
1820 }
1821
1822 LoadLayoutNameText::LoadLayoutNameText(LoadLayoutConfirm *confirm,
1823                 int x, int y, int w, const char *text)
1824  : BC_TextBox(x, y, w, 1, text)
1825 {
1826         this->confirm = confirm;
1827 }
1828
1829 LoadLayoutNameText::~LoadLayoutNameText()
1830 {
1831 }
1832
1833 int LoadLayoutNameText::handle_event()
1834 {
1835         const char *text = get_text();
1836         int len = strlen(text), k = 0;
1837         char new_text[BCTEXTLEN];
1838         for( int i=0; i<len; ++i ) {
1839                 int ch = text[i];
1840                 if( (ch>='A' && ch<='Z') || (ch>='a' && ch<='z') ||
1841                     (ch>='0' && ch<='9') || ch=='_' )
1842                         new_text[k++] = ch;
1843         }
1844         new_text[k] = 0;  len = k;
1845         int i = len - LAYOUT_NAME_LEN;
1846         if( i >= 0 ) {
1847                 k = 0;
1848                 while( i < len ) new_text[k++] = new_text[i++];
1849                 new_text[k] = 0;
1850         }
1851         update(new_text);
1852         return 1;
1853 }
1854
1855 LoadLayoutConfirm::LoadLayoutConfirm(LoadLayoutDialog *layout_dialog, int x, int y)
1856  : BC_Window(_(PROGRAM_NAME ": Layout"), x, y, 300,140, 300,140, 0)
1857 {
1858         this->layout_dialog = layout_dialog;
1859 }
1860
1861 LoadLayoutConfirm::~LoadLayoutConfirm()
1862 {
1863 }
1864
1865 void LoadLayoutConfirm::create_objects()
1866 {
1867         lock_window("LoadLayoutConfirm::create_objects");
1868         int x = 10, y = 10, pad = 10;
1869         BC_SubMenu *layout_submenu = layout_dialog->load_layout->get_submenu();
1870         LoadLayoutItem *item = (LoadLayoutItem *)
1871                 layout_submenu->get_item(layout_dialog->idx);
1872         BC_Title *title;
1873         add_subwindow(title = new BC_Title(x, y, _("Layout Name:")));
1874         int x1 = x + title->get_w() + 10;
1875         add_subwindow(title = new BC_Title(x1, y, item->get_text()));
1876         y += title->get_h() + pad;
1877         add_subwindow(name_text = new LoadLayoutNameText(this,
1878                 x, y, get_w()-x-20, item->layout_text));
1879         y += name_text->get_h();
1880         x1 = x + 80;
1881         char legend[BCTEXTLEN];
1882         sprintf(legend, _("a-z,A-Z,0-9_ only, %dch max"), LAYOUT_NAME_LEN);
1883         add_subwindow(title = new BC_Title(x1, y, legend));
1884         add_subwindow(new BC_OKButton(this));
1885         add_subwindow(new BC_CancelButton(this));
1886         unlock_window();
1887 }
1888