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
 101         add_menu(filemenu = new BC_Menu(_("File")));
 102         filemenu->add_item(new_project = new NewProject(mwindow));
 103         new_project->create_objects();
 104
 105 // file loaders
 106         filemenu->add_item(load_file = new Load(mwindow, this));
 107         load_file->create_objects();
 108         filemenu->add_item(load_recent = new LoadRecent(mwindow, this));
 109         load_recent->create_objects();
 110
 111 // new and load can be undone so no need to prompt save
 112         Save *save;                   //  affected by saveas
 113         filemenu->add_item(save = new Save(mwindow));
 114         SaveAs *saveas;
 115         filemenu->add_item(saveas = new SaveAs(mwindow));
 116         save->create_objects(saveas);
 117         saveas->set_mainmenu(this);
 118         SaveProject *save_project;
 119         filemenu->add_item(save_project = new SaveProject(mwindow));
 120
 121         filemenu->add_item(record_menu_item = new RecordMenuItem(mwindow));
 122 #ifdef HAVE_DVB
 123         filemenu->add_item(new ChannelScan(mwindow));
 124 #endif
 125 #ifdef HAVE_COMMERCIAL
 126         if( mwindow->has_commercials() )
 127                 filemenu->add_item(new DbWindowScan(mwindow));
 128 #endif
 129         filemenu->add_item(new SubttlSWin(mwindow));
 130
 131         filemenu->add_item(render = new RenderItem(mwindow));
 132         filemenu->add_item(new ExportEDLItem(mwindow));
 133         filemenu->add_item(new BatchRenderMenuItem(mwindow));
 134         filemenu->add_item(new CreateBD_MenuItem(mwindow));
 135         filemenu->add_item(new CreateDVD_MenuItem(mwindow));
 136         filemenu->add_item(new BC_MenuItem("-"));
 137         filemenu->add_item(quit_program = new Quit(mwindow));
 138         quit_program->create_objects(save);
 139         filemenu->add_item(dump_menu = new MainDumpsMenu(mwindow));
 140         dump_menu->create_objects();
 141         filemenu->add_item(new LoadBackup(mwindow));
 142         filemenu->add_item(new SaveBackup(mwindow));
 143
 144         BC_Menu *editmenu;
 145         add_menu(editmenu = new BC_Menu(_("Edit")));
 146         editmenu->add_item(undo = new Undo(mwindow));
 147         editmenu->add_item(redo = new Redo(mwindow));
 148         editmenu->add_item(new BC_MenuItem("-"));
 149         editmenu->add_item(new Cut(mwindow));
 150         editmenu->add_item(new Copy(mwindow));
 151         editmenu->add_item(new Paste(mwindow));
 152         editmenu->add_item(new PasteSilence(mwindow));
 153         editmenu->add_item(clear_menu = new EditClearMenu(mwindow));
 154         clear_menu->create_objects();
 155         editmenu->add_item(new TrimSelection(mwindow));
 156         editmenu->add_item(new SelectAll(mwindow));
 157         editmenu->add_item(new BC_MenuItem("-"));
 158         editmenu->add_item(new MenuEditShuffle(mwindow));
 159         editmenu->add_item(new MenuEditReverse(mwindow));
 160         editmenu->add_item(new MenuEditLength(mwindow));
 161         editmenu->add_item(new MenuEditAlign(mwindow));
 162         editmenu->add_item(new MenuTransitionLength(mwindow));
 163         editmenu->add_item(new DetachTransitions(mwindow));
 164         editmenu->add_item(new BC_MenuItem("-"));
 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 for legacy xml
 388         int total_loads = defaults->get((char*)"TOTAL_LOADS", 0);
 389         int loads_total = defaults->get((char*)"LOADS_TOTAL", 0);
 390         if( loads_total < total_loads ) loads_total = total_loads;
 391
 392         char string[BCTEXTLEN], path[BCTEXTLEN];
 393         FileSystem dir;
 394 //printf("MainMenu::init_loads 2\n");
 395
 396         for( int i=0; i<loads_total; ++i ) {
 397                 sprintf(string, "LOADPREVIOUS%d", i);
 398 //printf("MainMenu::init_loads 3\n");
 399                 defaults->get(string, path);
 400                 if( load.size() < TOTAL_LOADS )
 401                         load.append(new LoadRecentItem(path));
 402         }
 403 }
 404
 405 // ============================ save most recent
 406
 407 int MainMenu::save_aeffects(BC_Hash *defaults)
 408 {
 409         defaults->update((char*)"TOTAL_AEFFECTS", total_aeffects);
 410         char string[BCTEXTLEN];
 411         for(int i = 0; i < total_aeffects; i++)
 412         {
 413                 sprintf(string, "AEFFECTRECENT%d", i);
 414                 defaults->update(string, aeffect[i]->get_text());
 415         }
 416         return 0;
 417 }
 418
 419 int MainMenu::save_veffects(BC_Hash *defaults)
 420 {
 421         defaults->update((char*)"TOTAL_VEFFECTS", total_veffects);
 422         char string[BCTEXTLEN];
 423         for(int i = 0; i < total_veffects; i++)
 424         {
 425                 sprintf(string, "VEFFECTRECENT%d", i);
 426                 defaults->update(string, veffect[i]->get_text());
 427         }
 428         return 0;
 429 }
 430
 431 int MainMenu::save_loads(BC_Hash *defaults)
 432 {
 433 // legacy to prevent segv, older code cant tolerate total_loads>10
 434         int loads_total = load.size();
 435         int total_loads = MIN(10, loads_total);
 436         defaults->update((char*)"LOADS_TOTAL", loads_total);
 437         defaults->update((char*)"TOTAL_LOADS", total_loads);
 438         char string[BCTEXTLEN];
 439         for( int i=0; i<loads_total; ++i ) {
 440                 sprintf(string, "LOADPREVIOUS%d", i);
 441                 defaults->update(string, load[i]->path);
 442         }
 443         return 0;
 444 }
 445
 446 // =================================== add most recent
 447
 448 int MainMenu::add_aeffect(char *title)
 449 {
 450 // add bar for first effect
 451         if(total_aeffects == 0)
 452         {
 453                 audiomenu->add_item(new BC_MenuItem("-"));
 454         }
 455
 456 // test for existing copy of effect
 457         for(int i = 0; i < total_aeffects; i++)
 458         {
 459                 if(!strcmp(aeffect[i]->get_text(), title))     // already exists
 460                 {                                // swap for top effect
 461                         for(int j = i; j > 0; j--)   // move preceeding effects down
 462                         {
 463                                 aeffect[j]->set_text(aeffect[j - 1]->get_text());
 464                         }
 465                         aeffect[0]->set_text(title);
 466                         return 1;
 467                 }
 468         }
 469
 470 // add another blank effect
 471         if(total_aeffects < TOTAL_EFFECTS)
 472         {
 473                 audiomenu->add_item(
 474                         aeffect[total_aeffects] = new MenuAEffectItem(aeffects, (char*)""));
 475                 total_aeffects++;
 476         }
 477
 478 // cycle effect down
 479         for(int i = total_aeffects - 1; i > 0; i--)
 480         {
 481         // set menu item text
 482                 aeffect[i]->set_text(aeffect[i - 1]->get_text());
 483         }
 484
 485 // set up the new effect
 486         aeffect[0]->set_text(title);
 487         return 0;
 488 }
 489
 490 int MainMenu::add_veffect(char *title)
 491 {
 492 // add bar for first effect
 493         if(total_veffects == 0)
 494         {
 495                 videomenu->add_item(new BC_MenuItem("-"));
 496         }
 497
 498 // test for existing copy of effect
 499         for(int i = 0; i < total_veffects; i++)
 500         {
 501                 if(!strcmp(veffect[i]->get_text(), title))     // already exists
 502                 {                                // swap for top effect
 503                         for(int j = i; j > 0; j--)   // move preceeding effects down
 504                         {
 505                                 veffect[j]->set_text(veffect[j - 1]->get_text());
 506                         }
 507                         veffect[0]->set_text(title);
 508                         return 1;
 509                 }
 510         }
 511
 512 // add another blank effect
 513         if(total_veffects < TOTAL_EFFECTS)
 514         {
 515                 videomenu->add_item(veffect[total_veffects] =
 516                         new MenuVEffectItem(veffects, (char*)""));
 517                 total_veffects++;
 518         }
 519
 520 // cycle effect down
 521         for(int i = total_veffects - 1; i > 0; i--)
 522         {
 523 // set menu item text
 524                 veffect[i]->set_text(veffect[i - 1]->get_text());
 525         }
 526
 527 // set up the new effect
 528         veffect[0]->set_text(title);
 529         return 0;
 530 }
 531
 532 int MainMenu::add_load(char *path)
 533 {
 534         return load.add_load(path);
 535 }
 536
 537
 538
 539 // ================================== menu items
 540
 541 MainDumpsSubMenu::MainDumpsSubMenu(BC_MenuItem *menu_item)
 542  : BC_SubMenu()
 543 {
 544         this->menu_item = menu_item;
 545 }
 546 MainDumpsSubMenu::~MainDumpsSubMenu()
 547 {
 548 }
 549
 550
 551 MainDumpsMenu::MainDumpsMenu(MWindow *mwindow)
 552  : BC_MenuItem(_("Dumps..."))
 553 {
 554         this->mwindow = mwindow;
 555         this->dumps_menu = 0;
 556 }
 557 MainDumpsMenu::~MainDumpsMenu()
 558 {
 559 }
 560
 561 void MainDumpsMenu::create_objects()
 562 {
 563         add_submenu(dumps_menu = new MainDumpsSubMenu(this));
 564 //      dumps_menu->add_item(new DumpCICache(mwindow));
 565         dumps_menu->add_item(new DumpEDL(mwindow));
 566         dumps_menu->add_item(new DumpPlugins(mwindow));
 567         dumps_menu->add_item(new DumpAssets(mwindow));
 568         dumps_menu->add_item(new DumpUndo(mwindow));
 569 };
 570
 571
 572 DumpCICache::DumpCICache(MWindow *mwindow)
 573  : BC_MenuItem(_("Dump CICache"))
 574 { this->mwindow = mwindow; }
 575
 576 int DumpCICache::handle_event()
 577 {
 578 //      mwindow->cache->dump();
 579         return 1;
 580 }
 581
 582 DumpEDL::DumpEDL(MWindow *mwindow)
 583  : BC_MenuItem(_("Dump EDL"))
 584 {
 585         this->mwindow = mwindow;
 586 }
 587
 588 int DumpEDL::handle_event()
 589 {
 590         mwindow->dump_edl();
 591         return 1;
 592 }
 593
 594 DumpPlugins::DumpPlugins(MWindow *mwindow)
 595  : BC_MenuItem(_("Dump Plugins"))
 596 {
 597         this->mwindow = mwindow;
 598 }
 599
 600 int DumpPlugins::handle_event()
 601 {
 602         mwindow->dump_plugins();
 603         return 1;
 604 }
 605
 606 DumpAssets::DumpAssets(MWindow *mwindow)
 607  : BC_MenuItem(_("Dump Assets"))
 608 { this->mwindow = mwindow; }
 609
 610 int DumpAssets::handle_event()
 611 {
 612         mwindow->edl->assets->dump();
 613         return 1;
 614 }
 615
 616 DumpUndo::DumpUndo(MWindow *mwindow)
 617  : BC_MenuItem(_("Dump Undo"))
 618 {
 619         this->mwindow = mwindow;
 620 }
 621
 622 int DumpUndo::handle_event()
 623 {
 624         mwindow->dump_undo();
 625         return 1;
 626 }
 627
 628 // ================================================= edit
 629
 630 Undo::Undo(MWindow *mwindow) : BC_MenuItem(_("Undo"), "z", 'z')
 631 {
 632         this->mwindow = mwindow;
 633 }
 634 int Undo::handle_event()
 635 {
 636         if( mwindow->session->current_operation == NO_OPERATION )
 637                 mwindow->undo_entry(mwindow->gui);
 638         return 1;
 639 }
 640 int Undo::update_caption(const char *new_caption)
 641 {
 642         char string[BCTEXTLEN];
 643         sprintf(string, _("Undo %s"), new_caption);
 644         set_text(string);
 645         return 0;
 646 }
 647
 648
 649 Redo::Redo(MWindow *mwindow) : BC_MenuItem(_("Redo"), _("Shift-Z"), 'Z')
 650 {
 651         set_shift(1);
 652         this->mwindow = mwindow;
 653 }
 654
 655 int Redo::handle_event()
 656 {
 657         if( mwindow->session->current_operation == NO_OPERATION )
 658                 mwindow->redo_entry(mwindow->gui);
 659         return 1;
 660 }
 661 int Redo::update_caption(const char *new_caption)
 662 {
 663         char string[BCTEXTLEN];
 664         sprintf(string, _("Redo %s"), new_caption);
 665         set_text(string);
 666         return 0;
 667 }
 668
 669 CutKeyframes::CutKeyframes(MWindow *mwindow)
 670  : BC_MenuItem(_("Cut keyframes"), _("Shift-X"), 'X')
 671 {
 672         set_shift();
 673         this->mwindow = mwindow;
 674 }
 675
 676 int CutKeyframes::handle_event()
 677 {
 678         if( mwindow->session->current_operation == NO_OPERATION )
 679                 mwindow->cut_automation();
 680         return 1;
 681 }
 682
 683 CopyKeyframes::CopyKeyframes(MWindow *mwindow)
 684  : BC_MenuItem(_("Copy keyframes"), _("Shift-C"), 'C')
 685 {
 686         set_shift();
 687         this->mwindow = mwindow;
 688 }
 689
 690 int CopyKeyframes::handle_event()
 691 {
 692         if( mwindow->session->current_operation == NO_OPERATION )
 693                 mwindow->copy_automation();
 694         return 1;
 695 }
 696
 697 PasteKeyframes::PasteKeyframes(MWindow *mwindow)
 698  : BC_MenuItem(_("Paste keyframes"), _("Shift-V"), 'V')
 699 {
 700         set_shift();
 701         this->mwindow = mwindow;
 702 }
 703
 704 int PasteKeyframes::handle_event()
 705 {
 706         if( mwindow->session->current_operation == NO_OPERATION )
 707                 mwindow->paste_automation();
 708         return 1;
 709 }
 710
 711 ClearKeyframes::ClearKeyframes(MWindow *mwindow)
 712  : BC_MenuItem(_("Clear keyframes"), _("Shift-Del"), DELETE)
 713 {
 714         set_shift();
 715         this->mwindow = mwindow;
 716 }
 717
 718 int ClearKeyframes::handle_event()
 719 {
 720         if( mwindow->session->current_operation == NO_OPERATION )
 721                 mwindow->clear_automation();
 722         return 1;
 723 }
 724
 725
 726
 727 StraightenKeyframes::StraightenKeyframes(MWindow *mwindow)
 728  : BC_MenuItem(_("Change to linear"))
 729 {
 730         this->mwindow = mwindow;
 731 }
 732
 733 int StraightenKeyframes::handle_event()
 734 {
 735         mwindow->set_automation_mode(FloatAuto::LINEAR);
 736         return 1;
 737 }
 738
 739
 740
 741
 742 BendKeyframes::BendKeyframes(MWindow *mwindow)
 743  : BC_MenuItem(_("Change to smooth"))
 744 {
 745         this->mwindow = mwindow;
 746 }
 747
 748 int BendKeyframes::handle_event()
 749 {
 750         mwindow->set_automation_mode(FloatAuto::SMOOTH);
 751         return 1;
 752 }
 753
 754
 755
 756 KeyframeCurveType::KeyframeCurveType(MWindow *mwindow)
 757  : BC_MenuItem(_("Create curve type..."))
 758 {
 759         this->mwindow = mwindow;
 760         this->curve_menu = 0;
 761 }
 762 KeyframeCurveType::~KeyframeCurveType()
 763 {
 764 }
 765
 766 void KeyframeCurveType::create_objects()
 767 {
 768         add_submenu(curve_menu = new KeyframeCurveTypeMenu(this));
 769         for( int i=FloatAuto::SMOOTH; i<=FloatAuto::FREE; ++i ) {
 770                 KeyframeCurveTypeItem *curve_type_item = new KeyframeCurveTypeItem(i, this);
 771                 curve_menu->add_submenuitem(curve_type_item);
 772         }
 773 }
 774
 775 void KeyframeCurveType::update(int curve_type)
 776 {
 777         for( int i=0; i<curve_menu->total_items(); ++i ) {
 778                 KeyframeCurveTypeItem *curve_type_item = (KeyframeCurveTypeItem *)curve_menu->get_item(i);
 779                 curve_type_item->set_checked(curve_type_item->type == curve_type);
 780         }
 781 }
 782
 783 int KeyframeCurveType::handle_event()
 784 {
 785         return 1;
 786 }
 787
 788 KeyframeCurveTypeMenu::KeyframeCurveTypeMenu(KeyframeCurveType *menu_item)
 789  : BC_SubMenu()
 790 {
 791         this->menu_item = menu_item;
 792 }
 793 KeyframeCurveTypeMenu::~KeyframeCurveTypeMenu()
 794 {
 795 }
 796
 797 KeyframeCurveTypeItem::KeyframeCurveTypeItem(int type, KeyframeCurveType *main_item)
 798  : BC_MenuItem(FloatAuto::curve_name(type))
 799 {
 800         this->type = type;
 801         this->main_item = main_item;
 802 }
 803 KeyframeCurveTypeItem::~KeyframeCurveTypeItem()
 804 {
 805 }
 806
 807 int KeyframeCurveTypeItem::handle_event()
 808 {
 809         main_item->update(type);
 810         main_item->mwindow->set_keyframe_type(type);
 811         return 1;
 812 }
 813
 814
 815 CutDefaultKeyframe::CutDefaultKeyframe(MWindow *mwindow)
 816  : BC_MenuItem(_("Cut default keyframe"), _("Alt-x"), 'x')
 817 {
 818         set_alt();
 819         this->mwindow = mwindow;
 820 }
 821
 822 int CutDefaultKeyframe::handle_event()
 823 {
 824         if( mwindow->session->current_operation == NO_OPERATION )
 825                 mwindow->cut_default_keyframe();
 826         return 1;
 827 }
 828
 829 CopyDefaultKeyframe::CopyDefaultKeyframe(MWindow *mwindow)
 830  : BC_MenuItem(_("Copy default keyframe"), _("Alt-c"), 'c')
 831 {
 832         set_alt();
 833         this->mwindow = mwindow;
 834 }
 835
 836 int CopyDefaultKeyframe::handle_event()
 837 {
 838         if( mwindow->session->current_operation == NO_OPERATION )
 839                 mwindow->copy_default_keyframe();
 840         return 1;
 841 }
 842
 843 PasteDefaultKeyframe::PasteDefaultKeyframe(MWindow *mwindow)
 844  : BC_MenuItem(_("Paste default keyframe"), _("Alt-v"), 'v')
 845 {
 846         set_alt();
 847         this->mwindow = mwindow;
 848 }
 849
 850 int PasteDefaultKeyframe::handle_event()
 851 {
 852         if( mwindow->session->current_operation == NO_OPERATION )
 853                 mwindow->paste_default_keyframe();
 854         return 1;
 855 }
 856
 857 ClearDefaultKeyframe::ClearDefaultKeyframe(MWindow *mwindow)
 858  : BC_MenuItem(_("Clear default keyframe"), _("Alt-Del"), DELETE)
 859 {
 860         set_alt();
 861         this->mwindow = mwindow;
 862 }
 863
 864 int ClearDefaultKeyframe::handle_event()
 865 {
 866         if( mwindow->session->current_operation == NO_OPERATION )
 867                 mwindow->clear_default_keyframe();
 868         return 1;
 869 }
 870
 871 Cut::Cut(MWindow *mwindow)
 872  : BC_MenuItem(_("Split | Cut"), "x", 'x')
 873 {
 874         this->mwindow = mwindow;
 875 }
 876
 877 int Cut::handle_event()
 878 {
 879         if( mwindow->session->current_operation == NO_OPERATION )
 880                 mwindow->cut();
 881         return 1;
 882 }
 883
 884 Copy::Copy(MWindow *mwindow)
 885  : BC_MenuItem(_("Copy"), "c", 'c')
 886 {
 887         this->mwindow = mwindow;
 888 }
 889
 890 int Copy::handle_event()
 891 {
 892         if( mwindow->session->current_operation == NO_OPERATION )
 893                 mwindow->copy();
 894         return 1;
 895 }
 896
 897 Paste::Paste(MWindow *mwindow)
 898  : BC_MenuItem(_("Paste"), "v", 'v')
 899 {
 900         this->mwindow = mwindow;
 901 }
 902
 903 int Paste::handle_event()
 904 {
 905         if( mwindow->session->current_operation == NO_OPERATION )
 906                 mwindow->paste();
 907         return 1;
 908 }
 909
 910 EditClearSubMenu::EditClearSubMenu(BC_MenuItem *menu_item)
 911  : BC_SubMenu()
 912 {
 913         this->menu_item = menu_item;
 914 }
 915 EditClearSubMenu::~EditClearSubMenu()
 916 {
 917 }
 918
 919 EditClearMenu::EditClearMenu(MWindow *mwindow)
 920  : BC_MenuItem(_("Clear..."))
 921 {
 922         this->mwindow = mwindow;
 923         this->clear_sub_menu = 0;
 924 }
 925 EditClearMenu::~EditClearMenu()
 926 {
 927 }
 928
 929 void EditClearMenu::create_objects()
 930 {
 931         add_submenu(clear_sub_menu = new EditClearSubMenu(this));
 932         clear_sub_menu->add_item(new Clear(mwindow));
 933         clear_sub_menu->add_item(new MuteSelection(mwindow));
 934         clear_sub_menu->add_item(new ClearSelect(mwindow));
 935         clear_sub_menu->add_item(new ClearLabels(mwindow));
 936         clear_sub_menu->add_item(new ClearHardEdges(mwindow));
 937 };
 938
 939 Clear::Clear(MWindow *mwindow)
 940  : BC_MenuItem(_("Clear"), _("Del"), DELETE)
 941 {
 942         this->mwindow = mwindow;
 943 }
 944
 945 int Clear::handle_event()
 946 {
 947         if( mwindow->session->current_operation == NO_OPERATION ) {
 948                 mwindow->cwindow->gui->lock_window("Clear::handle_event");
 949                 mwindow->clear_entry();
 950                 mwindow->cwindow->gui->unlock_window();
 951         }
 952         return 1;
 953 }
 954
 955 PasteSilence::PasteSilence(MWindow *mwindow)
 956  : BC_MenuItem(_("Paste silence"), _("Shift-Space"), ' ')
 957 {
 958         this->mwindow = mwindow;
 959         set_shift();
 960 }
 961
 962 int PasteSilence::handle_event()
 963 {
 964         if( mwindow->session->current_operation == NO_OPERATION )
 965                 mwindow->paste_silence();
 966         return 1;
 967 }
 968
 969 SelectAll::SelectAll(MWindow *mwindow)
 970  : BC_MenuItem(_("Select All"), "a", 'a')
 971 {
 972         this->mwindow = mwindow;
 973 }
 974
 975 int SelectAll::handle_event()
 976 {
 977         if( mwindow->session->current_operation == NO_OPERATION )
 978                 mwindow->select_all();
 979         return 1;
 980 }
 981
 982 ClearHardEdges::ClearHardEdges(MWindow *mwindow) : BC_MenuItem(_("Clear Hard Edges"))
 983 {
 984         this->mwindow = mwindow;
 985 }
 986
 987 int ClearHardEdges::handle_event()
 988 {
 989         mwindow->clear_hard_edges();
 990         return 1;
 991 }
 992
 993 ClearLabels::ClearLabels(MWindow *mwindow) : BC_MenuItem(_("Clear labels"))
 994 {
 995         this->mwindow = mwindow;
 996 }
 997
 998 int ClearLabels::handle_event()
 999 {
1000         mwindow->clear_labels();
1001         return 1;
1002 }
1003
1004 ClearSelect::ClearSelect(MWindow *mwindow) : BC_MenuItem(_("Clear Select"),"Ctrl-Shift-A",'A')
1005 {
1006         set_ctrl(1);
1007         set_shift(1);
1008         this->mwindow = mwindow;
1009 }
1010
1011 int ClearSelect::handle_event()
1012 {
1013         mwindow->clear_select();
1014         return 1;
1015 }
1016
1017 CutCommercials::CutCommercials(MWindow *mwindow) : BC_MenuItem(_("Cut ads"))
1018 {
1019         this->mwindow = mwindow;
1020 }
1021
1022 int CutCommercials::handle_event()
1023 {
1024         mwindow->cut_commercials();
1025         return 1;
1026 }
1027
1028 DetachTransitions::DetachTransitions(MWindow *mwindow)
1029  : BC_MenuItem(_("Detach transitions"))
1030 {
1031         this->mwindow = mwindow;
1032 }
1033
1034 int DetachTransitions::handle_event()
1035 {
1036         mwindow->detach_transitions();
1037         return 1;
1038 }
1039
1040 MuteSelection::MuteSelection(MWindow *mwindow)
1041  : BC_MenuItem(_("Mute Region"), "m", 'm')
1042 {
1043         this->mwindow = mwindow;
1044 }
1045
1046 int MuteSelection::handle_event()
1047 {
1048         if( mwindow->session->current_operation == NO_OPERATION )
1049                 mwindow->mute_selection();
1050         return 1;
1051 }
1052
1053
1054 TrimSelection::TrimSelection(MWindow *mwindow)
1055  : BC_MenuItem(_("Trim Selection"))
1056 {
1057         this->mwindow = mwindow;
1058 }
1059
1060 int TrimSelection::handle_event()
1061 {
1062         mwindow->trim_selection();
1063         return 1;
1064 }
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077 // ============================================= audio
1078
1079 AddAudioTrack::AddAudioTrack(MWindow *mwindow)
1080  : BC_MenuItem(_("Add track"), "t", 't')
1081 {
1082         this->mwindow = mwindow;
1083 }
1084
1085 int AddAudioTrack::handle_event()
1086 {
1087         if( mwindow->session->current_operation == NO_OPERATION )
1088                 mwindow->add_audio_track_entry(0, 0);
1089         return 1;
1090 }
1091
1092 DeleteAudioTrack::DeleteAudioTrack(MWindow *mwindow)
1093  : BC_MenuItem(_("Delete track"))
1094 {
1095         this->mwindow = mwindow;
1096 }
1097
1098 int DeleteAudioTrack::handle_event()
1099 {
1100         return 1;
1101 }
1102
1103 DefaultATransition::DefaultATransition(MWindow *mwindow)
1104  : BC_MenuItem(_("Default Transition"), "u", 'u')
1105 {
1106         this->mwindow = mwindow;
1107 }
1108
1109 int DefaultATransition::handle_event()
1110 {
1111         if( mwindow->session->current_operation == NO_OPERATION )
1112                 mwindow->paste_audio_transition();
1113         return 1;
1114 }
1115
1116
1117 MapAudio1::MapAudio1(MWindow *mwindow)
1118  : BC_MenuItem(_("Map 1:1"))
1119 {
1120         this->mwindow = mwindow;
1121 }
1122
1123 int MapAudio1::handle_event()
1124 {
1125         mwindow->map_audio(MWindow::AUDIO_1_TO_1);
1126         return 1;
1127 }
1128
1129 MapAudio2::MapAudio2(MWindow *mwindow)
1130  : BC_MenuItem(_("Map 5.1:2"))
1131 {
1132         this->mwindow = mwindow;
1133 }
1134
1135 int MapAudio2::handle_event()
1136 {
1137         mwindow->map_audio(MWindow::AUDIO_5_1_TO_2);
1138         return 1;
1139 }
1140
1141
1142
1143
1144 // ============================================= video
1145
1146
1147 AddVideoTrack::AddVideoTrack(MWindow *mwindow)
1148  : BC_MenuItem(_("Add track"), _("Shift-T"), 'T')
1149 {
1150         set_shift();
1151         this->mwindow = mwindow;
1152 }
1153
1154 int AddVideoTrack::handle_event()
1155 {
1156         if( mwindow->session->current_operation == NO_OPERATION )
1157                 mwindow->add_video_track_entry();
1158         return 1;
1159 }
1160
1161
1162 DeleteVideoTrack::DeleteVideoTrack(MWindow *mwindow)
1163  : BC_MenuItem(_("Delete track"))
1164 {
1165         this->mwindow = mwindow;
1166 }
1167
1168 int DeleteVideoTrack::handle_event()
1169 {
1170         return 1;
1171 }
1172
1173
1174
1175 ResetTranslation::ResetTranslation(MWindow *mwindow)
1176  : BC_MenuItem(_("Reset Translation"))
1177 {
1178         this->mwindow = mwindow;
1179 }
1180
1181 int ResetTranslation::handle_event()
1182 {
1183         return 1;
1184 }
1185
1186
1187
1188 DefaultVTransition::DefaultVTransition(MWindow *mwindow)
1189  : BC_MenuItem(_("Default Transition"), _("Shift-U"), 'U')
1190 {
1191         set_shift();
1192         this->mwindow = mwindow;
1193 }
1194
1195 int DefaultVTransition::handle_event()
1196 {
1197         if( mwindow->session->current_operation == NO_OPERATION )
1198                 mwindow->paste_video_transition();
1199         return 1;
1200 }
1201
1202
1203
1204
1205
1206
1207
1208
1209
1210
1211
1212
1213
1214
1215 // ============================================ settings
1216
1217 DeleteTracks::DeleteTracks(MWindow *mwindow)
1218  : BC_MenuItem(_("Delete tracks"))
1219 {
1220         this->mwindow = mwindow;
1221 }
1222
1223 int DeleteTracks::handle_event()
1224 {
1225         mwindow->delete_tracks();
1226         return 1;
1227 }
1228
1229 DeleteFirstTrack::DeleteFirstTrack(MWindow *mwindow)
1230  : BC_MenuItem(_("Delete first track"), "Shift-D", 'D')
1231 {
1232         set_shift(1);
1233         this->mwindow = mwindow;
1234 }
1235
1236 int DeleteFirstTrack::handle_event()
1237 {
1238         if( mwindow->session->current_operation == NO_OPERATION ) {
1239                 Track *track = mwindow->edl->tracks->first;
1240                 if( track ) mwindow->delete_track(track);
1241         }
1242         return 1;
1243 }
1244
1245 DeleteLastTrack::DeleteLastTrack(MWindow *mwindow)
1246  : BC_MenuItem(_("Delete last track"), "d", 'd')
1247 {
1248         this->mwindow = mwindow;
1249 }
1250
1251 int DeleteLastTrack::handle_event()
1252 {
1253         if( mwindow->session->current_operation == NO_OPERATION ) {
1254                 Track *track = mwindow->edl->tracks->last;
1255                 if( track ) mwindow->delete_track(track);
1256         }
1257         return 1;
1258 }
1259
1260 MoveTracksUp::MoveTracksUp(MWindow *mwindow)
1261  : BC_MenuItem(_("Move tracks up"), _("Shift-Up"), UP)
1262 {
1263         this->mwindow = mwindow;
1264         set_shift();
1265 }
1266
1267 int MoveTracksUp::handle_event()
1268 {
1269         if( mwindow->session->current_operation == NO_OPERATION )
1270                 mwindow->move_tracks_up();
1271         return 1;
1272 }
1273
1274 MoveTracksDown::MoveTracksDown(MWindow *mwindow)
1275  : BC_MenuItem(_("Move tracks down"), _("Shift-Down"), DOWN)
1276 {
1277         set_shift(); this->mwindow = mwindow;
1278 }
1279
1280 int MoveTracksDown::handle_event()
1281 {
1282         if( mwindow->session->current_operation == NO_OPERATION )
1283                 mwindow->move_tracks_down();
1284         return 1;
1285 }
1286
1287
1288
1289
1290 ConcatenateTracks::ConcatenateTracks(MWindow *mwindow)
1291  : BC_MenuItem(_("Concatenate tracks"))
1292 {
1293         set_shift();
1294         this->mwindow = mwindow;
1295 }
1296
1297 int ConcatenateTracks::handle_event()
1298 {
1299         mwindow->concatenate_tracks();
1300         return 1;
1301 }
1302
1303
1304
1305
1306
1307 LoopPlayback::LoopPlayback(MWindow *mwindow)
1308  : BC_MenuItem(_("Loop Playback"), _("Shift-L"), 'L')
1309 {
1310         this->mwindow = mwindow;
1311         set_checked(mwindow->edl->local_session->loop_playback);
1312         set_shift();
1313 }
1314
1315 int LoopPlayback::handle_event()
1316 {
1317         if( mwindow->session->current_operation == NO_OPERATION ) {
1318                 mwindow->toggle_loop_playback();
1319                 set_checked(mwindow->edl->local_session->loop_playback);
1320         }
1321         return 1;
1322 }
1323
1324
1325
1326 // ============================================= subtitle
1327
1328
1329 AddSubttlTrack::AddSubttlTrack(MWindow *mwindow)
1330  : BC_MenuItem(_("Add subttl"), _("Shift-Y"), 'Y')
1331 {
1332         set_shift();
1333         this->mwindow = mwindow;
1334 }
1335
1336 int AddSubttlTrack::handle_event()
1337 {
1338         if( mwindow->session->current_operation == NO_OPERATION )
1339                 mwindow->add_subttl_track_entry();
1340         return 1;
1341 }
1342
1343 PasteSubttl::PasteSubttl(MWindow *mwindow)
1344  : BC_MenuItem(_("paste subttl"), "y", 'y')
1345 {
1346         this->mwindow = mwindow;
1347 }
1348
1349 int PasteSubttl::handle_event()
1350 {
1351         if( mwindow->session->current_operation == NO_OPERATION )
1352                 mwindow->gui->swindow->paste_subttl();
1353         return 1;
1354 }
1355
1356
1357 SetBRenderActive::SetBRenderActive(MWindow *mwindow)
1358  : BC_MenuItem(_("Toggle background rendering"),_("Shift-G"),'G')
1359 {
1360         this->mwindow = mwindow;
1361         set_shift(1);
1362 }
1363
1364 int SetBRenderActive::handle_event()
1365 {
1366         if( mwindow->session->current_operation == NO_OPERATION ) {
1367                 int v = mwindow->brender_active ? 0 : 1;
1368                 set_checked(v);
1369                 mwindow->set_brender_active(v);
1370         }
1371         return 1;
1372 }
1373
1374
1375 LabelsFollowEdits::LabelsFollowEdits(MWindow *mwindow)
1376  : BC_MenuItem(_("Edit labels"))
1377 {
1378         this->mwindow = mwindow;
1379         set_checked(mwindow->edl->session->labels_follow_edits);
1380 }
1381
1382 int LabelsFollowEdits::handle_event()
1383 {
1384         set_checked(get_checked() ^ 1);
1385         mwindow->set_labels_follow_edits(get_checked());
1386         return 1;
1387 }
1388
1389
1390
1391
1392 PluginsFollowEdits::PluginsFollowEdits(MWindow *mwindow)
1393  : BC_MenuItem(_("Edit effects"))
1394 {
1395         this->mwindow = mwindow;
1396         set_checked(mwindow->edl->session->plugins_follow_edits);
1397 }
1398
1399 int PluginsFollowEdits::handle_event()
1400 {
1401         set_checked(get_checked() ^ 1);
1402         mwindow->edl->session->plugins_follow_edits = get_checked();
1403         return 1;
1404 }
1405
1406
1407
1408
1409 KeyframesFollowEdits::KeyframesFollowEdits(MWindow *mwindow)
1410  : BC_MenuItem(_("Keyframes follow edits"))
1411 {
1412         this->mwindow = mwindow;
1413         set_checked(mwindow->edl->session->autos_follow_edits);
1414 }
1415
1416 int KeyframesFollowEdits::handle_event()
1417 {
1418         mwindow->edl->session->autos_follow_edits ^= 1;
1419         set_checked(!get_checked());
1420         return 1;
1421 }
1422
1423
1424 CursorOnFrames::CursorOnFrames(MWindow *mwindow)
1425  : BC_MenuItem(_("Align cursor on frames"),_("Ctrl-a"),'a')
1426 {
1427         this->mwindow = mwindow;
1428         set_checked(mwindow->edl->session->cursor_on_frames);
1429         set_ctrl(1);
1430 }
1431
1432 int CursorOnFrames::handle_event()
1433 {
1434         mwindow->edl->session->cursor_on_frames = !mwindow->edl->session->cursor_on_frames;
1435         set_checked(mwindow->edl->session->cursor_on_frames);
1436         return 1;
1437 }
1438
1439
1440 TypelessKeyframes::TypelessKeyframes(MWindow *mwindow)
1441  : BC_MenuItem(_("Typeless keyframes"))
1442 {
1443         this->mwindow = mwindow;
1444         set_checked(mwindow->edl->session->typeless_keyframes);
1445 }
1446
1447 int TypelessKeyframes::handle_event()
1448 {
1449         mwindow->edl->session->typeless_keyframes = !mwindow->edl->session->typeless_keyframes;
1450         set_checked(mwindow->edl->session->typeless_keyframes);
1451         return 1;
1452 }
1453
1454
1455 ScrubSpeed::ScrubSpeed(MWindow *mwindow)
1456  : BC_MenuItem(_("Slow Shuttle"))
1457 {
1458         this->mwindow = mwindow;
1459 }
1460
1461 int ScrubSpeed::handle_event()
1462 {
1463         if(mwindow->edl->session->scrub_speed == .5)
1464         {
1465                 mwindow->edl->session->scrub_speed = 2;
1466                 set_text(_("Slow Shuttle"));
1467         }
1468         else
1469         {
1470                 mwindow->edl->session->scrub_speed = .5;
1471                 set_text(_("Fast Shuttle"));
1472         }
1473         return 1;
1474 }
1475
1476 SaveSettingsNow::SaveSettingsNow(MWindow *mwindow)
1477  : BC_MenuItem(_("Save settings now"),_("Ctrl-s"),'s')
1478 {
1479         this->mwindow = mwindow;
1480         set_ctrl(1);
1481 }
1482
1483 int SaveSettingsNow::handle_event()
1484 {
1485         mwindow->save_defaults();
1486         mwindow->save_backup();
1487         mwindow->gui->show_message(_("Saved settings."));
1488         return 1;
1489 }
1490
1491
1492
1493 // ============================================ window
1494
1495
1496
1497
1498
1499 ShowVWindow::ShowVWindow(MWindow *mwindow)
1500  : BC_MenuItem(_("Show Viewer"))
1501 {
1502         this->mwindow = mwindow;
1503         set_checked(mwindow->session->show_vwindow);
1504 }
1505 int ShowVWindow::handle_event()
1506 {
1507         mwindow->show_vwindow();
1508         return 1;
1509 }
1510
1511 ShowAWindow::ShowAWindow(MWindow *mwindow)
1512  : BC_MenuItem(_("Show Resources"))
1513 {
1514         this->mwindow = mwindow;
1515         set_checked(mwindow->session->show_awindow);
1516 }
1517 int ShowAWindow::handle_event()
1518 {
1519         mwindow->show_awindow();
1520         return 1;
1521 }
1522
1523 ShowCWindow::ShowCWindow(MWindow *mwindow)
1524  : BC_MenuItem(_("Show Compositor"))
1525 {
1526         this->mwindow = mwindow;
1527         set_checked(mwindow->session->show_cwindow);
1528 }
1529 int ShowCWindow::handle_event()
1530 {
1531         mwindow->show_cwindow();
1532         return 1;
1533 }
1534
1535
1536 ShowGWindow::ShowGWindow(MWindow *mwindow)
1537  : BC_MenuItem(_("Show Overlays"), _("Ctrl-0"), '0')
1538 {
1539         this->mwindow = mwindow;
1540         set_ctrl(1);
1541         set_checked(mwindow->session->show_gwindow);
1542 }
1543 int ShowGWindow::handle_event()
1544 {
1545         if( mwindow->session->current_operation == NO_OPERATION ) {
1546                 if( !mwindow->session->show_gwindow )
1547                         mwindow->show_gwindow();
1548                 else
1549                         mwindow->hide_gwindow();
1550                 set_checked(mwindow->session->show_gwindow);
1551         }
1552         return 1;
1553 }
1554
1555
1556 ShowLWindow::ShowLWindow(MWindow *mwindow)
1557  : BC_MenuItem(_("Show Levels"))
1558 {
1559         this->mwindow = mwindow;
1560         set_checked(mwindow->session->show_lwindow);
1561 }
1562 int ShowLWindow::handle_event()
1563 {
1564         mwindow->show_lwindow();
1565         return 1;
1566 }
1567
1568 TileWindows::TileWindows(MWindow *mwindow, const char *item_title, int config,
1569                 const char *hot_keytext, int hot_key)
1570  : BC_MenuItem(item_title, hot_keytext, hot_key)
1571 {
1572         this->mwindow = mwindow;
1573         this->config = config;
1574         if( hot_key ) set_ctrl(1);
1575 }
1576 int TileWindows::handle_event()
1577 {
1578         if( mwindow->session->current_operation == NO_OPERATION ) {
1579                 int window_config = config >= 0 ? config :
1580                         mwindow->session->window_config;
1581                 if( mwindow->tile_windows(window_config) ) {
1582                         mwindow->restart_status = 1;
1583                         mwindow->gui->set_done(0);
1584                 }
1585         }
1586         return 1;
1587 }
1588
1589 SplitX::SplitX(MWindow *mwindow)
1590  : BC_MenuItem(_("Split X pane"), _("Ctrl-1"), '1')
1591 {
1592         this->mwindow = mwindow;
1593         set_ctrl(1);
1594         set_checked(mwindow->gui->pane[TOP_RIGHT_PANE] != 0);
1595 }
1596 int SplitX::handle_event()
1597 {
1598         if( mwindow->session->current_operation == NO_OPERATION )
1599                 mwindow->split_x();
1600         return 1;
1601 }
1602
1603 SplitY::SplitY(MWindow *mwindow)
1604  : BC_MenuItem(_("Split Y pane"), _("Ctrl-2"), '2')
1605 {
1606         this->mwindow = mwindow;
1607         set_ctrl(1);
1608         set_checked(mwindow->gui->pane[BOTTOM_LEFT_PANE] != 0);
1609 }
1610 int SplitY::handle_event()
1611 {
1612         if( mwindow->session->current_operation == NO_OPERATION )
1613                 mwindow->split_y();
1614         return 1;
1615 }
1616
1617
1618 MixerItems::MixerItems(MWindow *mwindow)
1619  : BC_MenuItem(_("Mixers..."))
1620 {
1621         this->mwindow = mwindow;
1622 }
1623
1624 void MixerItems::create_objects()
1625 {
1626         BC_SubMenu *mixer_submenu = new BC_SubMenu();
1627         add_submenu(mixer_submenu);
1628         mixer_submenu->add_submenuitem(new MixerViewer(mwindow));
1629         mixer_submenu->add_submenuitem(new TileMixers(mwindow));
1630         mixer_submenu->add_submenuitem(new AlignMixers(mwindow));
1631 }
1632
1633 MixerViewer::MixerViewer(MWindow *mwindow)
1634  : BC_MenuItem(_("Mixer Viewer"), _("Shift-M"), 'M')
1635 {
1636         this->mwindow = mwindow;
1637         set_shift(1);
1638 }
1639
1640 int MixerViewer::handle_event()
1641 {
1642         mwindow->start_mixer();
1643         return 1;
1644 }
1645
1646 TileMixers::TileMixers(MWindow *mwindow)
1647  : BC_MenuItem(_("Tile mixers"), "Alt-t", 't')
1648 {
1649         this->mwindow = mwindow;
1650         set_alt();
1651 }
1652
1653 int TileMixers::handle_event()
1654 {
1655         mwindow->tile_mixers();
1656         return 1;
1657 }
1658
1659 AlignMixers::AlignMixers(MWindow *mwindow)
1660  : BC_MenuItem(_("Align mixers"))
1661 {
1662         this->mwindow = mwindow;
1663 }
1664
1665 int AlignMixers::handle_event()
1666 {
1667         int wx, wy;
1668         mwindow->gui->get_abs_cursor(wx, wy);
1669         mwindow->mixers_align->start_dialog(wx, wy);
1670         return 1;
1671 }
1672
1673
1674 LoadLayoutItem::LoadLayoutItem(LoadLayout *load_layout, const char *text, int idx, int hotkey)
1675  : BC_MenuItem(text, "", hotkey)
1676 {
1677         this->idx = idx;
1678         this->load_layout = load_layout;
1679         if( hotkey ) {
1680                 char hot_txt[BCSTRLEN];
1681                 sprintf(hot_txt, _("Ctrl-Shift+F%d"), hotkey-KEY_F1+1);
1682                 set_ctrl();  set_shift();
1683                 set_hotkey_text(hot_txt);
1684         }
1685 }
1686
1687
1688 int LoadLayoutItem::handle_event()
1689 {
1690 // key_press hotkey skips over activate_submenu
1691         load_layout->update();
1692         MWindow *mwindow = load_layout->mwindow;
1693         switch( load_layout->action ) {
1694         case LAYOUT_LOAD:
1695                 mwindow->load_layout(layout_file);
1696                 break;
1697         case LAYOUT_SAVE: {
1698                 int wx = 0, wy = 0;
1699                 mwindow->gui->get_abs_cursor(wx, wy);
1700                 load_layout->layout_dialog->start_confirm_dialog(wx, wy, idx);
1701                 break; }
1702         }
1703         return 1;
1704 }
1705
1706 LoadLayout::LoadLayout(MWindow *mwindow, const char *text, int action)
1707  : BC_MenuItem(text)
1708 {
1709         this->mwindow = mwindow;
1710         this->action = action;
1711         this->layout_dialog = new LoadLayoutDialog(this);
1712 }
1713
1714 LoadLayout::~LoadLayout()
1715 {
1716         delete layout_dialog;
1717 }
1718
1719 void LoadLayout::create_objects()
1720 {
1721         BC_SubMenu *layout_submenu = new BC_SubMenu();
1722         add_submenu(layout_submenu);
1723
1724         for( int i=0; i<LAYOUTS_MAX; ++i ) {
1725                 char text[BCSTRLEN];
1726                 sprintf(text, _("Layout %d"), i+1);
1727                 LoadLayoutItem *item = new LoadLayoutItem(this, text, i,
1728                                 action==LAYOUT_LOAD ? KEY_F1+i : 0);
1729                 layout_submenu->add_submenuitem(item);
1730         }
1731 }
1732
1733 int LoadLayout::activate_submenu()
1734 {
1735         update();
1736         return BC_MenuItem::activate_submenu();
1737 }
1738
1739 void LoadLayout::update()
1740 {
1741         FileSystem fs;
1742         fs.set_filter("layout*_rc");
1743         int ret = fs.update(File::get_config_path());
1744         int sz = !ret ? fs.dir_list.size() : 0;
1745         BC_SubMenu *layout_submenu = get_submenu();
1746
1747         for( int i=0; i<LAYOUTS_MAX; ++i ) {
1748                 LoadLayoutItem* item = (LoadLayoutItem *)
1749                         layout_submenu->get_item(i);
1750                 char layout_text[BCSTRLEN];  layout_text[0] = 0;
1751                 int n = sz, id = i+1;
1752                 while( --n >= 0 ) {
1753                         char *np = fs.dir_list[n]->name;
1754                         char *cp = strrchr(np, '_'), *bp = 0;
1755                         int no = strtol(np+6, &bp, 10);
1756                         if( no != id || !bp ) continue;
1757                         if( bp == cp ) {  n = -1;  break; }
1758                         if( *bp++ == '_' && bp < cp && !strcmp(cp, "_rc") ) {
1759                                 int k = cp - bp;  char *tp = layout_text;
1760                                 if( k > LAYOUT_NAME_LEN ) k = LAYOUT_NAME_LEN;
1761                                 while( --k >= 0 ) *tp++ = *bp++;
1762                                 *tp = 0;
1763                                 break;
1764                         }
1765                 }
1766                 strcpy(item->layout_text, layout_text);
1767                 char *lp = item->layout_file;
1768                 int k = sprintf(lp, LAYOUT_FILE, id);
1769                 if( n >= 0 && layout_text[0] )
1770                         sprintf(lp + k-2, "%s_rc", layout_text);
1771                 else
1772                         sprintf(layout_text, _("Layout %d"), id);
1773                 item->set_text(layout_text);
1774         }
1775 }
1776
1777 LoadLayoutDialog::LoadLayoutDialog(LoadLayout *load_layout)
1778 {
1779         this->load_layout = load_layout;
1780         wx = 0;  wy = 0;
1781         idx = -1;
1782         lgui = 0;
1783 }
1784
1785 LoadLayoutDialog::~LoadLayoutDialog()
1786 {
1787         close_window();
1788 }
1789
1790 void LoadLayoutDialog::handle_done_event(int result)
1791 {
1792         if( result ) return;
1793         char layout_file[BCSTRLEN];
1794         BC_SubMenu *layout_submenu = load_layout->get_submenu();
1795         LoadLayoutItem* item =
1796                 (LoadLayoutItem *) layout_submenu->get_item(idx);
1797         snprintf(layout_file, sizeof(layout_file), "%s", item->layout_file);
1798         load_layout->mwindow->delete_layout(layout_file);
1799         int k = sprintf(layout_file, LAYOUT_FILE, idx+1);
1800         const char *text = lgui->name_text->get_text();
1801         if( text[0] )
1802                 snprintf(layout_file + k-2, sizeof(layout_file)-k+2, "%s_rc", text);
1803         load_layout->mwindow->save_layout(layout_file);
1804 }
1805
1806 void LoadLayoutDialog::handle_close_event(int result)
1807 {
1808         lgui = 0;
1809 }
1810
1811 BC_Window *LoadLayoutDialog::new_gui()
1812 {
1813         lgui = new LoadLayoutConfirm(this, wx, wy);
1814         lgui->create_objects();
1815         return lgui;
1816 }
1817
1818 void LoadLayoutDialog::start_confirm_dialog(int wx, int wy, int idx)
1819 {
1820         close_window();
1821         this->wx = wx;  this->wy = wy;
1822         this->idx = idx;
1823         start();
1824 }
1825
1826 LoadLayoutNameText::LoadLayoutNameText(LoadLayoutConfirm *confirm,
1827                 int x, int y, int w, const char *text)
1828  : BC_TextBox(x, y, w, 1, text)
1829 {
1830         this->confirm = confirm;
1831 }
1832
1833 LoadLayoutNameText::~LoadLayoutNameText()
1834 {
1835 }
1836
1837 int LoadLayoutNameText::handle_event()
1838 {
1839         const char *text = get_text();
1840         int len = strlen(text), k = 0;
1841         char new_text[BCTEXTLEN];
1842         for( int i=0; i<len; ++i ) {
1843                 int ch = text[i];
1844                 if( (ch>='A' && ch<='Z') || (ch>='a' && ch<='z') ||
1845                     (ch>='0' && ch<='9') || ch=='_' )
1846                         new_text[k++] = ch;
1847         }
1848         new_text[k] = 0;  len = k;
1849         int i = len - LAYOUT_NAME_LEN;
1850         if( i >= 0 ) {
1851                 k = 0;
1852                 while( i < len ) new_text[k++] = new_text[i++];
1853                 new_text[k] = 0;
1854         }
1855         update(new_text);
1856         return 1;
1857 }
1858
1859 LoadLayoutConfirm::LoadLayoutConfirm(LoadLayoutDialog *layout_dialog, int x, int y)
1860  : BC_Window(_(PROGRAM_NAME ": Layout"), x, y, xS(300),yS(140), xS(300),yS(140), 0)
1861 {
1862         this->layout_dialog = layout_dialog;
1863 }
1864
1865 LoadLayoutConfirm::~LoadLayoutConfirm()
1866 {
1867 }
1868
1869 void LoadLayoutConfirm::create_objects()
1870 {
1871         int xs10 = xS(10), xs20 = xS(20);
1872         int ys10 = yS(10);
1873         lock_window("LoadLayoutConfirm::create_objects");
1874         int x = xs10, y = ys10;
1875         BC_SubMenu *layout_submenu = layout_dialog->load_layout->get_submenu();
1876         LoadLayoutItem *item = (LoadLayoutItem *)
1877                 layout_submenu->get_item(layout_dialog->idx);
1878         BC_Title *title;
1879         add_subwindow(title = new BC_Title(x, y, _("Layout Name:")));
1880         int x1 = x + title->get_w() + xs10;
1881         add_subwindow(title = new BC_Title(x1, y, item->get_text()));
1882         y += title->get_h() + ys10;
1883         add_subwindow(name_text = new LoadLayoutNameText(this,
1884                 x, y, get_w()-x-xs20, item->layout_text));
1885         y += name_text->get_h();
1886         x1 = x + xS(80);
1887         char legend[BCTEXTLEN];
1888         sprintf(legend, _("a-z,A-Z,0-9_ only, %dch max"), LAYOUT_NAME_LEN);
1889         add_subwindow(title = new BC_Title(x1, y, legend));
1890         add_subwindow(new BC_OKButton(this));
1891         add_subwindow(new BC_CancelButton(this));
1892         unlock_window();
1893 }
1894
1895
1896 LoadRecentItem::LoadRecentItem(const char *path)
1897 {
1898         this->path = cstrdup(path);
1899 }
1900
1901 LoadRecentItem::~LoadRecentItem()
1902 {
1903         delete [] path;
1904 }
1905
1906 int LoadRecentItems::add_load(char *path)
1907 {
1908 // test for existing copy
1909         FileSystem fs;
1910         char name[BCTEXTLEN], text[BCTEXTLEN];
1911         fs.extract_name(name, path);
1912         int loads_total = size();
1913         int ret = 0, k = loads_total;
1914         LoadRecentItem *load_item = 0;
1915
1916         for( int i=0; !ret && i<loads_total; ++i ) {
1917                 load_item = get(i);
1918                 fs.extract_name(text, load_item->path);
1919                 if( strcmp(name, text) ) continue;
1920                 k = i;  ret = 1; // already exists, move to top
1921         }
1922         if( !ret ) { // adding a new one
1923                 while( loads_total >= TOTAL_LOADS )
1924                         remove_object_number(--loads_total);
1925                 insert(new LoadRecentItem(path), 0);
1926         }
1927         else if( k > 0 ) { // cycle loads
1928                 while( --k >= 0 ) set(k+1, get(k));
1929                 set(0, load_item);
1930         }
1931         return ret;
1932 }
1933
1934 LoadRecentItems::LoadRecentItems()
1935 {
1936 }
1937
1938 LoadRecentItems::~LoadRecentItems()
1939 {
1940         remove_all_objects();
1941 }
1942
1943 LoadRecent::LoadRecent(MWindow *mwindow, MainMenu *main_menu)
1944  : BC_MenuItem(_("Load Recent..."))
1945 {
1946         this->mwindow = mwindow;
1947         this->main_menu = main_menu;
1948         total_items = 0;
1949 }
1950 LoadRecent::~LoadRecent()
1951 {
1952 }
1953
1954 void LoadRecent::create_objects()
1955 {
1956         add_submenu(submenu = new LoadRecentSubMenu(this));
1957 }
1958
1959 LoadPrevious *LoadRecent::get_next_item()
1960 {
1961         int k = total_items++;
1962         if( k < submenu->total_items() )
1963                 return (LoadPrevious *)submenu->get_item(k);
1964         LoadPrevious *load_prev = new LoadPrevious(mwindow, main_menu->load_file);
1965         submenu->add_item(load_prev);
1966         return load_prev;
1967 }
1968
1969 int LoadRecent::activate_submenu()
1970 {
1971         total_items = 0;
1972         scan_items(1);
1973         if( total_items > 0 ) {
1974                 LoadPrevious *load_prev = get_next_item();
1975                 load_prev->set_text("-");
1976                 load_prev->set_path("");
1977         }
1978         scan_items(0);
1979         while( total_items < submenu->total_items() )
1980                 submenu->del_item(0);
1981         return BC_MenuItem::activate_submenu();
1982 }
1983
1984 void LoadRecent::scan_items(int use_xml)
1985 {
1986         FileSystem fs;
1987         int loads_total = main_menu->load.size();
1988         for( int i=0; i<loads_total; ++i ) {
1989                 LoadRecentItem *recent = main_menu->load[i];
1990                 char name[BCTEXTLEN];
1991                 fs.extract_name(name, recent->path);
1992                 const char *cp = strrchr(name, '.');
1993                 if( !cp || strcasecmp(cp+1,"xml") ? use_xml : !use_xml ) continue;
1994                 LoadPrevious *load_prev = get_next_item();
1995                 load_prev->set_text(name);
1996                 load_prev->set_path(recent->path);
1997         }
1998 }
1999
2000 LoadRecentSubMenu::LoadRecentSubMenu(LoadRecent *load_recent)
2001  : BC_SubMenu()
2002 {
2003         this->load_recent = load_recent;
2004 }
2005
2006 LoadRecentSubMenu::~LoadRecentSubMenu()
2007 {
2008 }
2009