← Back to branch summary

~ubuntu-branches/ubuntu/gutsy/audacity/gutsy

« back to all changes in this revision

Viewing changes to src/Menus.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Free Ekanayaka
  • Date: 2007-05-18 12:11:05 UTC
  • mfrom: (1.2.5 upstream)
  • Revision ID: james.westby@ubuntu.com-20070518121105-onhr7ojai3n5khzt
Tags: 1.3.3-1
* New upstream release
* Added watch file
* debian/patches:
   - updated libmp3lame patch
* debian/control:
   - as suggested upstream, depend on libgtk2.0-dev, otherwise 
     the code fails to build

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/Menus.cpp
54
54
#include "import/ImportMIDI.h"
55
55
#include "import/ImportRaw.h"
56
56
#include "export/Export.h"
57
 
#include "export/ExportMP3.h"
58
57
#include "export/ExportMultiple.h"
59
58
#include "prefs/PrefsDialog.h"
60
59
#include "widgets/TimeTextCtrl.h"
70
69
#include "Tags.h"
71
70
#include "Mix.h"
72
71
#include "AboutDialog.h"
73
 
#include "Help.h"
74
72
#include "Benchmark.h"
 
73
#include "Screenshot.h"
75
74
 
76
75
#include "Resample.h"
77
76
#include "BatchProcessDialog.h"
89
88
#include "SmartRecordDialog.h"
90
89
#include "LabelDialog.h"
91
90
 
 
91
#include "FileDialog.h"
 
92
 
92
93
enum {
93
94
   kAlignZero=0,
94
95
   kAlignCursor,
160
161
   LabelsSelectedFlag     = 0x00020000,
161
162
   AudioIOBusyFlag        = 0x00040000,  //lll
162
163
   PlayRegionLockedFlag   = 0x00080000,  //msmeyer
163
 
   PlayRegionNotLockedFlag= 0x00100000   //msmeyer
 
164
   PlayRegionNotLockedFlag= 0x00100000,  //msmeyer
 
165
   CutCopyAvailableFlag   = 0x00200000   //lll
164
166
};
165
167
 
 
168
wxString SHOW(const wxString &toolbarName)
 
169
{
 
170
   /* i18n-hint: here, %s is the name of a toolbar, e.g. "Control Toolbar" */
 
171
   return wxString::Format(_("Show %s"), toolbarName.c_str());
 
172
}
 
173
 
 
174
wxString HIDE(const wxString &toolbarName)
 
175
{
 
176
   /* i18n-hint: here, %s is the name of a toolbar, e.g. "Control Toolbar" */
 
177
   return wxString::Format(_("Hide %s"), toolbarName.c_str());
 
178
}
 
179
 
166
180
#define FN(X) new AudacityProjectCommandFunctor(this, &AudacityProject:: X )
167
181
 
168
182
/// CreateMenusAndCommands builds the menus, and also rebuilds them after
229
243
      
230
244
      c->AddSeparator();
231
245
      
232
 
      c->BeginSubMenu(_("&Export As..."));
233
 
      c->AddItem(wxT("Export"),         _("&WAV..."),                   FN(OnExportMix));
234
 
      c->AddItem(wxT("ExportMP3"),      _("&MP3..."),               FN(OnExportMP3Mix));
235
 
#ifdef USE_LIBVORBIS
236
 
      c->AddItem(wxT("ExportOgg"),      _("Ogg &Vorbis..."),        FN(OnExportOggMix));
237
 
      // Enable Export commands only when there are tracks
238
 
      c->SetCommandFlags(AudioIONotBusyFlag | TracksExistFlag,
239
 
                         AudioIONotBusyFlag | TracksExistFlag,
240
 
                         wxT("ExportOgg"), NULL);
241
 
#endif
242
 
#ifdef USE_LIBFLAC
243
 
      c->AddItem(wxT("ExportFLAC"),      _("&FLAC..."),        FN(OnExportFLACMix));
244
 
      c->SetCommandFlags(AudioIONotBusyFlag | TracksExistFlag,
245
 
                         AudioIONotBusyFlag | TracksExistFlag,
246
 
                         wxT("ExportFLAC"), NULL);
247
 
#endif
248
 
#ifdef USE_LIBTWOLAME
249
 
      c->AddItem(wxT("ExportMP2"), _("MP&2..."), FN(OnExportMP2Mix));
250
 
      c->SetCommandFlags(AudioIONotBusyFlag | TracksExistFlag,
251
 
                         AudioIONotBusyFlag | TracksExistFlag,
252
 
                         wxT("ExportMP2"), NULL);
253
 
#endif
254
 
      c->EndSubMenu();
255
 
      
256
 
      c->BeginSubMenu(_("Expo&rt Selection As..."));
257
 
      c->AddItem(wxT("ExportSel"),      _("&WAV..."),         FN(OnExportSelection));
258
 
      c->AddItem(wxT("ExportMP3Sel"),   _("&MP3..."),     FN(OnExportMP3Selection));
259
 
#ifdef USE_LIBVORBIS
260
 
      c->AddItem(wxT("ExportOggSel"),   _("Ogg &Vorbis..."), FN(OnExportOggSelection));
261
 
      // Enable Export Selection commands only when there's a selection
262
 
      c->SetCommandFlags(AudioIONotBusyFlag | TimeSelectedFlag | TracksSelectedFlag,
263
 
                         AudioIONotBusyFlag | TimeSelectedFlag | TracksSelectedFlag,
264
 
                         wxT("ExportOggSel"), NULL);
265
 
#endif
266
 
#ifdef USE_LIBFLAC
267
 
      c->AddItem(wxT("ExportFLACSel"),   _("&FLAC..."), FN(OnExportFLACSelection));
268
 
      c->SetCommandFlags(AudioIONotBusyFlag | TracksExistFlag | TracksSelectedFlag,
269
 
                         AudioIONotBusyFlag | TracksExistFlag | TracksSelectedFlag,
270
 
                         wxT("ExportFLACSel"), NULL);
271
 
#endif
272
 
#ifdef USE_LIBTWOLAME
273
 
      c->AddItem(wxT("ExportMP2Sel"),    _("&MP&2..."), FN(OnExportMP2Selection));
274
 
      c->SetCommandFlags(AudioIONotBusyFlag | TracksExistFlag | TracksSelectedFlag,
275
 
                         AudioIONotBusyFlag | TracksExistFlag | TracksSelectedFlag,
276
 
                         wxT("ExportMP2Sel"), NULL);
277
 
#endif
278
 
      c->EndSubMenu();
279
 
      
280
 
      // Enable Export commands only when there are tracks
281
 
      c->SetCommandFlags(AudioIONotBusyFlag | TracksExistFlag,
282
 
                         AudioIONotBusyFlag | TracksExistFlag,
283
 
                         wxT("Export"), wxT("ExportMP3"), NULL);
284
 
      // Enable Export Selection commands only when there's a selection
285
 
      c->SetCommandFlags(AudioIONotBusyFlag | TimeSelectedFlag | TracksSelectedFlag,
286
 
                         AudioIONotBusyFlag | TimeSelectedFlag | TracksSelectedFlag,
287
 
                         wxT("ExportSel"), wxT("ExportMP3Sel"), NULL);
 
246
      c->AddItem(wxT("Export"),         _("&Export..."),           FN(OnExport));
 
247
      // Enable Export commands only when there are tracks
 
248
      c->SetCommandFlags(wxT("Export"),
 
249
                         AudioIONotBusyFlag | TracksExistFlag,
 
250
                         AudioIONotBusyFlag | TracksExistFlag);
 
251
 
 
252
      c->AddItem(wxT("ExportSel"),      _("Expo&rt Selection..."), FN(OnExportSelection));
 
253
      // Enable Export Selection commands only when there's a selection
 
254
      c->SetCommandFlags(wxT("ExportSel"),
 
255
                         AudioIONotBusyFlag | TimeSelectedFlag | TracksSelectedFlag,
 
256
                         AudioIONotBusyFlag | TimeSelectedFlag | TracksSelectedFlag);
288
257
      
289
258
      c->AddSeparator();
290
259
      c->AddItem(wxT("ExportLabels"),   _("Export &Labels..."),              FN(OnExportLabels));
303
272
        if( mCleanSpeechMode )
304
273
        {
305
274
      
306
 
      c->BeginSubMenu(_("&Export As..."));
307
 
      c->AddItem(wxT("Export"),         _("&WAV..."),                   FN(OnExportMix));
308
 
      c->AddItem(wxT("ExportMP3"),      _("&MP3..."),               FN(OnExportMP3Mix));
309
 
      c->EndSubMenu();
310
 
      
311
 
      c->BeginSubMenu(_("Expo&rt Selection As..."));
312
 
      c->AddItem(wxT("ExportSel"),      _("&WAV..."),         FN(OnExportSelection));
313
 
      c->AddItem(wxT("ExportMP3Sel"),   _("&MP3..."),     FN(OnExportMP3Selection));
314
 
      c->EndSubMenu();
315
 
      
 
275
      c->AddItem(wxT("Export"),         _("&Export..."),           FN(OnExport));
316
276
      // Enable Export commands only when there are tracks
317
 
      c->SetCommandFlags(AudioIONotBusyFlag | TracksExistFlag,
 
277
      c->SetCommandFlags(wxT("Export"),
318
278
                         AudioIONotBusyFlag | TracksExistFlag,
319
 
                         wxT("Export"), wxT("ExportMP3"), NULL);
 
279
                         AudioIONotBusyFlag | TracksExistFlag);
 
280
 
 
281
      c->AddItem(wxT("ExportSel"),      _("Expo&rt Selection..."), FN(OnExportSelection));
320
282
      // Enable Export Selection commands only when there's a selection
321
 
      c->SetCommandFlags(AudioIONotBusyFlag | TimeSelectedFlag | TracksSelectedFlag,
 
283
      c->SetCommandFlags(wxT("ExportSel"),
322
284
                         AudioIONotBusyFlag | TimeSelectedFlag | TracksSelectedFlag,
323
 
                         wxT("ExportSel"), wxT("ExportMP3Sel"), NULL);
 
285
                         AudioIONotBusyFlag | TimeSelectedFlag | TracksSelectedFlag);
324
286
      
325
287
      c->AddSeparator();
326
288
 
327
 
      c->AddItem(wxT("ApplyChain"), _("CleanSpeech C&hain..."),   FN(OnApplyChain));
 
289
      c->AddItem(wxT("ApplyChain"), wxT("CleanSpeech C&hain..."),   FN(OnApplyChain));
328
290
      c->AddItem(wxT("EditChains"), _("Edit C&hains..."), FN(OnEditChains));
329
 
      c->AddItem(wxT("ExportCcSettings"), _("Export CleanSpeech &Presets..."),   FN(OnExportCleanSpeechPresets));
330
 
      c->AddItem(wxT("ImportCcSettings"), _("I&mport CleanSpeech Presets..."),   FN(OnImportCleanSpeechPresets));
 
291
      c->AddItem(wxT("ExportCcSettings"), wxT("Export CleanSpeech &Presets..."),   FN(OnExportCleanSpeechPresets));
 
292
      c->AddItem(wxT("ImportCcSettings"), wxT("I&mport CleanSpeech Presets..."),   FN(OnImportCleanSpeechPresets));
331
293
      c->SetCommandFlags(wxT("BatchProcess"), AudioIONotBusyFlag, AudioIONotBusyFlag);
332
294
#ifdef __WXDEBUG__
333
295
           gPrefs->Write(wxT("/Validate/DebugBuild"), "Y");
405
367
 
406
368
   c->AddSeparator();
407
369
   c->AddItem(wxT("Cut"),            _("Cu&t\tCtrl+X"),                   FN(OnCut));
 
370
   c->SetCommandFlags(wxT("Cut"),
 
371
                      AudioIONotBusyFlag | CutCopyAvailableFlag,
 
372
                      AudioIONotBusyFlag | CutCopyAvailableFlag);
408
373
   c->AddItem(wxT("SplitCut"),       _("Spl&it Cut\tCtrl+Alt+X"),          FN(OnSplitCut));
409
374
   c->AddItem(wxT("Copy"),           _("&Copy\tCtrl+C"),                  FN(OnCopy)); 
 
375
   c->SetCommandFlags(wxT("Copy"),
 
376
                      AudioIONotBusyFlag | CutCopyAvailableFlag,
 
377
                      AudioIONotBusyFlag | CutCopyAvailableFlag);
410
378
   c->AddItem(wxT("Paste"),          _("&Paste\tCtrl+V"),                 FN(OnPaste));
411
379
   c->SetCommandFlags(wxT("Paste"),
412
380
                      AudioIONotBusyFlag | ClipboardFlag,
422
390
      AudioIONotBusyFlag | WaveTracksSelectedFlag,
423
391
      AudioIONotBusyFlag | WaveTracksSelectedFlag);
424
392
 
 
393
   c->AddItem(wxT("SplitNew"),      _("Split Ne&w\tCtrl+Alt+I"),       FN(OnSplitNew));
 
394
   c->SetCommandFlags(wxT("SplitNew"),
 
395
      AudioIONotBusyFlag | WaveTracksSelectedFlag,
 
396
      AudioIONotBusyFlag | WaveTracksSelectedFlag);
 
397
 
425
398
   c->AddItem(wxT("Join"),           _("&Join\tCtrl+J"),                  FN(OnJoin));
426
399
   c->AddItem(wxT("Disjoin"),        _("Disj&oin\tCtrl+Alt+J"),                       FN(OnDisjoin));
427
400
   
431
404
   // which doesn't have a Project menu, but they are under Project for normal Audacity.
432
405
   if( mCleanSpeechMode )
433
406
        {
434
 
      c->AddItem(wxT("Stereo To Mono"),      _("Stereo To Mono"),            FN(OnStereoToMono));
 
407
      c->AddItem(wxT("Stereo To Mono"),      _("&Stereo To Mono"),            FN(OnStereoToMono));
435
408
      c->SetCommandFlags(wxT("Stereo To Mono"),
436
409
         AudioIONotBusyFlag | StereoRequiredFlag | WaveTracksSelectedFlag,
437
410
         AudioIONotBusyFlag | StereoRequiredFlag | WaveTracksSelectedFlag);
439
412
   c->AddSeparator();
440
413
 
441
414
   c->BeginSubMenu( _( "Labeled Re&gions..." ) );
 
415
   /* i18n-hint: Labeled Regions submenu */
442
416
   c->AddItem( wxT( "CutLabels" ), _( "&Cut\tAlt+X" ), 
443
417
         FN( OnCutLabels ) );
444
418
   c->SetCommandFlags( wxT( "CutLabels" ), LabelsSelectedFlag, 
445
419
         LabelsSelectedFlag );
 
420
   /* i18n-hint: Labeled Regions submenu */
446
421
   c->AddItem( wxT( "SplitCutLabels" ), _( "&Split Cut\tShift+Alt+X" ), 
447
422
         FN( OnSplitCutLabels ) );
448
423
   c->SetCommandFlags( wxT( "SplitCutLabels" ), LabelsSelectedFlag, 
449
424
         LabelsSelectedFlag );
 
425
   /* i18n-hint: Labeled Regions submenu */
450
426
   c->AddItem( wxT( "CopyLabels" ), _( "Co&py\tShift+Alt+C" ), 
451
427
         FN( OnCopyLabels ) );
452
428
   c->SetCommandFlags( wxT( "CopyLabels" ), LabelsSelectedFlag, 
453
429
         LabelsSelectedFlag );
454
430
   c->AddSeparator();
 
431
   /* i18n-hint: Labeled Regions submenu */
455
432
   c->AddItem( wxT( "DeleteLabels" ), _( "&Delete\tAlt+K" ), 
456
433
         FN( OnDeleteLabels ) );
457
434
   c->SetCommandFlags( wxT( "DeleteLabels" ), LabelsSelectedFlag, 
458
435
         LabelsSelectedFlag );
 
436
   /* i18n-hint: Labeled Regions submenu */
459
437
   c->AddItem( wxT( "SplitDeleteLabels" ), _( "Sp&lit Delete\tShift+Alt+K" ), 
460
438
         FN( OnSplitDeleteLabels ) );
461
439
   c->SetCommandFlags( wxT( "SplitDeleteLabels" ), LabelsSelectedFlag, 
462
440
         LabelsSelectedFlag );
 
441
   /* i18n-hint: Labeled Regions submenu */
463
442
   c->AddItem( wxT( "SilenceLabels" ), _( "Sile&nce\tAlt+L" ), 
464
443
         FN( OnSilenceLabels ) );
465
444
   c->SetCommandFlags( wxT( "SilenceLabels" ), LabelsSelectedFlag, 
466
445
         LabelsSelectedFlag );
467
446
   c->AddSeparator();
 
447
   /* i18n-hint: Labeled Regions submenu */
468
448
   c->AddItem( wxT( "SplitLabels" ), _( "Spli&t\tAlt+I" ), 
469
449
         FN( OnSplitLabels ) );
470
450
   c->SetCommandFlags( wxT( "SplitLabels" ), LabelsSelectedFlag, 
471
451
         LabelsSelectedFlag );
 
452
   /* i18n-hint: Labeled Regions submenu */
472
453
   c->AddItem( wxT( "JoinLabels" ), _( "&Join\tAlt+J" ), 
473
454
         FN( OnJoinLabels ) );
474
455
   c->SetCommandFlags( wxT( "JoinLabels" ), LabelsSelectedFlag, 
475
456
         LabelsSelectedFlag );
 
457
   /* i18n-hint: Labeled Regions submenu */
476
458
   c->AddItem( wxT( "DisjoinLabels" ), _( "Disj&oin\tShift+Alt+J" ), 
477
459
         FN( OnDisjoinLabels ) );
478
460
   c->SetCommandFlags( wxT( "DisjoinLabels" ), LabelsSelectedFlag, 
479
461
         LabelsSelectedFlag );
480
462
   c->EndSubMenu();
481
463
   
482
 
   c->BeginSubMenu(_("Select..."));
 
464
   c->BeginSubMenu(_("&Select..."));
483
465
   c->AddItem(wxT("SelectAll"),      _("&All\tCtrl+A"),                   FN(OnSelectAll));
484
 
   c->SetCommandFlags(wxT("SelectAll"),
485
 
                      TracksExistFlag, TracksExistFlag);
 
466
   c->AddItem(wxT("SelectNone"),     _("&None\tCtrl+Shift+A"),            FN(OnSelectNone));
 
467
   c->SetCommandFlags(TracksExistFlag, TracksExistFlag,
 
468
                      wxT("SelectAll"), wxT("SelectNone"), NULL);
486
469
 
487
470
   c->AddItem(wxT("SetLeftSelection"),_("Left at Playback Position\t["), FN(OnSetLeftSelection));
488
471
   c->AddItem(wxT("SetRightSelection"),_("Right at Playback Position\t]"), FN(OnSetRightSelection));
589
572
#endif
590
573
   c->AddSeparator();
591
574
   c->BeginSubMenu(_("&Toolbars..."));
592
 
   c->AddItem(wxT("ShowControlTB"),       _("Show Control Toolbar"),       FN(OnShowControlToolBar));
593
 
   c->AddItem(wxT("ShowDeviceTB"),        _("Show Device Toolbar"),        FN(OnShowDeviceToolBar));
594
 
   c->AddItem(wxT("ShowEditTB"),          _("Show Edit Toolbar"),          FN(OnShowEditToolBar));
595
 
   c->AddItem(wxT("ShowMeterTB"),         _("Show Meter Toolbar"),         FN(OnShowMeterToolBar));
596
 
   c->AddItem(wxT("ShowMixerTB"),         _("Show Mixer Toolbar"),         FN(OnShowMixerToolBar));
597
 
   c->AddItem(wxT("ShowSelectionTB"),     _("Show Selection Toolbar"),     FN(OnShowSelectionToolBar));
598
 
   c->AddItem(wxT("ShowToolsTB"),         _("Show Tools Toolbar"),         FN(OnShowToolsToolBar));
599
 
   c->AddItem(wxT("ShowTranscriptionTB"), _("Show Transcription Toolbar"), FN(OnShowTranscriptionToolBar));
 
575
   c->AddItem(wxT("ShowControlTB"),       SHOW(_("Control Toolbar")),       FN(OnShowControlToolBar));
 
576
   c->AddItem(wxT("ShowDeviceTB"),        SHOW(_("Device Toolbar")),        FN(OnShowDeviceToolBar));
 
577
   c->AddItem(wxT("ShowEditTB"),          SHOW(_("Edit Toolbar")),          FN(OnShowEditToolBar));
 
578
   c->AddItem(wxT("ShowMeterTB"),         SHOW(_("Meter Toolbar")),         FN(OnShowMeterToolBar));
 
579
   c->AddItem(wxT("ShowMixerTB"),         SHOW(_("Mixer Toolbar")),         FN(OnShowMixerToolBar));
 
580
   c->AddItem(wxT("ShowSelectionTB"),     SHOW(_("Selection Toolbar")),     FN(OnShowSelectionToolBar));
 
581
   c->AddItem(wxT("ShowToolsTB"),         SHOW(_("Tools Toolbar")),         FN(OnShowToolsToolBar));
 
582
   c->AddItem(wxT("ShowTranscriptionTB"), SHOW(_("Transcription Toolbar")), FN(OnShowTranscriptionToolBar));
 
583
   c->AddSeparator();
 
584
   c->AddItem(wxT("ResetToolbars"),       _("Reset Toolbars"),              FN(OnResetToolBars));
600
585
   c->EndSubMenu();
601
586
 
602
587
   c->EndMenu();
795
780
 
796
781
   c->BeginMenu(_("&Help"));
797
782
   c->SetDefaultFlags(0, 0);
798
 
   c->AddItem(wxT("Help"),           _("&Contents..."),             FN(OnHelp));
799
 
   c->AddSeparator();   
800
 
        if( mCleanSpeechMode )
 
783
   if( mCleanSpeechMode )
801
784
        c->AddItem(wxT("About"),          _("&About Audacity CleanSpeech..."), FN(OnAbout));
802
 
        else
803
 
   c->AddItem(wxT("About"),          _("&About Audacity..."),          FN(OnAbout));
 
785
   else
 
786
      c->AddItem(wxT("About"),          _("&About Audacity..."),          FN(OnAbout));
804
787
 
805
 
#if 1 // Benchmark is enabled in unstable builds
806
 
        if( !mCleanSpeechMode )
807
 
        {
808
 
   c->AddSeparator();   
809
 
   c->AddItem(wxT("Benchmark"),      _("&Run Benchmark..."),           FN(OnBenchmark));
810
 
        }
 
788
#if 1 // Debugging tools are enabled in unstable builds
 
789
   if( !mCleanSpeechMode )
 
790
   {
 
791
      c->AddSeparator();   
 
792
      c->AddItem(wxT("Screenshot"),     _("&Screenshot Tools..."),        FN(OnScreenshot));
 
793
      c->AddSeparator();   
 
794
      c->AddItem(wxT("Benchmark"),      _("&Run Benchmark..."),           FN(OnBenchmark));
 
795
   }
811
796
#endif 
812
797
 
813
798
   c->EndMenu();
814
799
 
815
 
   ModifyExportMenus();
816
 
 
817
800
   SetMenuBar(menubar);
818
801
 
819
802
   c->SetDefaultFlags(0, 0);
868
851
   
869
852
   c->SetDefaultFlags(TracksExistFlag | TrackPanelHasFocus,
870
853
                      TracksExistFlag | TrackPanelHasFocus);
871
 
   c->AddCommand(wxT("PrevTrack"),     _("Move to Previous Track\tUp"),                      FN(OnCursorUp));
872
 
   c->AddCommand(wxT("ShiftUp"),       _("Move to Previous and Change Selection\tShift+Up"), FN(OnShiftUp));
873
 
   c->AddCommand(wxT("NextTrack"),     _("Move to Next Track\tDown"),                        FN(OnCursorDown));
874
 
   c->AddCommand(wxT("ShiftDown"),     _("Move to Next and Change Selection\tShift+Down"),   FN(OnShiftDown));
 
854
   c->AddCommand(wxT("PrevTrack"),     _("Move Focus to Previous Track\tUp"),                      FN(OnCursorUp));
 
855
   c->AddCommand(wxT("ShiftUp"),       _("Move Focus to Previous and Change Selection\tShift+Up"), FN(OnShiftUp));
 
856
   c->AddCommand(wxT("NextTrack"),     _("Move Focus to Next Track\tDown"),                        FN(OnCursorDown));
 
857
   c->AddCommand(wxT("ShiftDown"),     _("Move Focus to Next and Change Selection\tShift+Down"),   FN(OnShiftDown));
875
858
   c->AddCommand(wxT("Toggle"),        _("Toggle Focused Track\tReturn"),                    FN(OnToggle));
876
859
   c->AddCommand(wxT("Toggle1"),       _("Toggle Focused Track\tNUMPAD_ENTER"),              FN(OnToggle));
877
860
   c->AddCommand(wxT("Toggle2"),       _("Toggle Focused Track\tCtrl+Spacebar"),             FN(OnToggle));
935
918
// when calling an effect.
936
919
void AudacityProject::ResolveEffectIndices(EffectArray *effects)
937
920
{
 
921
   mNormalizeIndex = -1;
 
922
   mStereoToMonoIndex = -1;
 
923
 
938
924
   for (unsigned int i = 0; i < effects->GetCount(); i++) {
939
 
      wxString effectName = (*effects)[i]->GetEffectName();
940
 
      if (effectName == wxT("Normalize...")) {
 
925
      wxString effectIdentifier = (*effects)[i]->GetEffectIdentifier();
 
926
      if (effectIdentifier == wxT("Normalize")) {
941
927
         mNormalizeIndex = i;
942
928
      }
943
 
      else if (effectName == wxT("Stereo To Mono")) {
 
929
      else if (effectIdentifier == wxT("StereoToMono")) {
944
930
         mStereoToMonoIndex = i;
945
931
      }
946
932
   }
947
933
}
948
934
 
949
 
void AudacityProject::ModifyExportMenus()
950
 
{
951
 
   int format = ReadExportFormatPref();
952
 
   wxString pcmFormat = sf_header_shortname(format & SF_FORMAT_TYPEMASK);
953
 
 
954
 
   mCommandManager.Modify(wxT("Export"),
955
 
                          wxString::Format(_("&%s..."),
956
 
                                           pcmFormat.c_str()));
957
 
   mCommandManager.Modify(wxT("ExportSel"),
958
 
                          wxString::Format(_("&%s..."),
959
 
                                           pcmFormat.c_str()));
960
 
}
961
 
 
962
935
void AudacityProject::ModifyUndoMenus()
963
936
{
964
937
   wxString desc;
1049
1022
{
1050
1023
   wxWindow *w = FindFocus();
1051
1024
 
1052
 
   while (w) {
 
1025
   while (w && mToolManager && mTrackPanel) {
1053
1026
      if (w == mToolManager->GetTopDock()) {
1054
1027
         return TopDockHasFocus;
1055
1028
      }
1089
1062
   Track *t = iter.First();
1090
1063
   while (t) {
1091
1064
      flags |= TracksExistFlag;
1092
 
      if (t->GetKind() == Track::Label)
1093
 
      {
 
1065
      if (t->GetKind() == Track::Label) {
 
1066
         LabelTrack *lt = (LabelTrack *) t;
 
1067
 
1094
1068
         flags |= LabelTracksExistFlag;
1095
 
         if( t->GetSelected() )
1096
 
         {
 
1069
 
 
1070
         if (lt->GetSelected()) {
1097
1071
            flags |= TracksSelectedFlag;
1098
 
 
1099
 
            LabelTrack *lt = ( LabelTrack* )t; 
1100
 
            for( int i = 0; i < lt->GetNumLabels(); i++ ) 
1101
 
            {
1102
 
               const LabelStruct *ls = lt->GetLabel( i );
1103
 
               if( ls->t >= mViewInfo.sel0 && ls->t1 <= mViewInfo.sel1 )
1104
 
               {
 
1072
            for (int i = 0; i < lt->GetNumLabels(); i++) {
 
1073
               const LabelStruct *ls = lt->GetLabel(i);
 
1074
               if (ls->t >= mViewInfo.sel0 && ls->t1 <= mViewInfo.sel1) {
1105
1075
                  flags |= LabelsSelectedFlag;
1106
1076
                  break;
1107
1077
               }
1108
1078
            }
1109
 
 
1110
 
            if (((LabelTrack *)t)->IsTextClipSupported())
1111
 
               flags |= TextClipFlag;
 
1079
         }
 
1080
 
 
1081
         if (lt->IsTextSelected()) {
 
1082
            flags |= CutCopyAvailableFlag;
 
1083
         }
 
1084
 
 
1085
         if (lt->IsTextClipSupported()) {
 
1086
            flags |= TextClipFlag;
1112
1087
         }
1113
1088
      }
1114
1089
      else if (t->GetKind() == Track::Wave) {
1153
1128
   else
1154
1129
      flags |= PlayRegionNotLockedFlag;
1155
1130
 
 
1131
   if (flags & AudioIONotBusyFlag) {
 
1132
      if (flags & TimeSelectedFlag) {
 
1133
         if (flags & TracksSelectedFlag) {
 
1134
            flags |= CutCopyAvailableFlag;
 
1135
         }
 
1136
      }
 
1137
   }
 
1138
 
1156
1139
   return flags;
1157
1140
}
1158
1141
 
1168
1151
{
1169
1152
   mCommandManager.Modify(wxT("ShowControlTB"),
1170
1153
                          mToolManager->IsVisible(ControlBarID ) ?
1171
 
                          _("Hide Control Toolbar") :
1172
 
                          _("Show Control Toolbar"));
 
1154
                          HIDE(_("Control Toolbar")) :
 
1155
                          SHOW(_("Control Toolbar")));
1173
1156
   mCommandManager.Modify(wxT("ShowDeviceTB"),
1174
1157
                          mToolManager->IsVisible(DeviceBarID) ?
1175
 
                          _("Hide Device Toolbar") :
1176
 
                          _("Show Device Toolbar"));
 
1158
                          HIDE(_("Device Toolbar")) :
 
1159
                          SHOW(_("Device Toolbar")));
1177
1160
   mCommandManager.Modify(wxT("ShowEditTB"),
1178
1161
                          mToolManager->IsVisible(EditBarID) ?
1179
 
                          _("Hide Edit Toolbar") :
1180
 
                          _("Show Edit Toolbar"));
 
1162
                          HIDE(_("Edit Toolbar")) :
 
1163
                          SHOW(_("Edit Toolbar")));
1181
1164
   mCommandManager.Modify(wxT("ShowMeterTB"),
1182
1165
                          mToolManager->IsVisible(MeterBarID) ?
1183
 
                          _("Hide Meter Toolbar") :
1184
 
                          _("Show Meter Toolbar"));
 
1166
                          HIDE(_("Meter Toolbar")) :
 
1167
                          SHOW(_("Meter Toolbar")));
1185
1168
   mCommandManager.Modify(wxT("ShowMixerTB"),
1186
1169
                          mToolManager->IsVisible(MixerBarID) ?
1187
 
                          _("Hide Mixer Toolbar") :
1188
 
                          _("Show Mixer Toolbar"));
 
1170
                          HIDE(_("Mixer Toolbar")) :
 
1171
                          SHOW(_("Mixer Toolbar")));
1189
1172
   mCommandManager.Modify(wxT("ShowSelectionTB"),
1190
1173
                          mToolManager->IsVisible(SelectionBarID) ?
1191
 
                          _("Hide Selection Toolbar") :
1192
 
                          _("Show Selection Toolbar"));
 
1174
                          HIDE(_("Selection Toolbar")) :
 
1175
                          SHOW(_("Selection Toolbar")));
1193
1176
   mCommandManager.Modify(wxT("ShowToolsTB"),
1194
1177
                          mToolManager->IsVisible(ToolsBarID) ?
1195
 
                          _("Hide Tools Toolbar") :
1196
 
                          _("Show Tools Toolbar"));
 
1178
                          HIDE(_("Tools Toolbar")) :
 
1179
                          SHOW(_("Tools Toolbar")));
1197
1180
   mCommandManager.Modify(wxT("ShowTranscriptionTB"),
1198
1181
                          mToolManager->IsVisible(TranscriptionBarID) ?
1199
 
                          _("Hide Transcription Toolbar") :
1200
 
                          _("Show Transcription Toolbar"));
 
1182
                          HIDE(_("Transcription Toolbar")) :
 
1183
                          SHOW(_("Transcription Toolbar")));
1201
1184
 }
1202
1185
 
1203
1186
void AudacityProject::UpdateMenus()
1220
1203
   mLastFlags = flags;
1221
1204
   mCommandManager.EnableUsingFlags(flags, 0xFFFFFFFF);
1222
1205
 
 
1206
   if (flags & CutCopyAvailableFlag) {
 
1207
      mCommandManager.Enable(wxT("Copy"), true);
 
1208
      mCommandManager.Enable(wxT("Cut"), true);
 
1209
   }
 
1210
 
1223
1211
   ModifyToolbarMenus();
1224
1212
 
1225
1213
   // Now, go through each toolbar, and call EnableDisableButtons()
1793
1781
 
1794
1782
void AudacityProject::OnTrackMenu()
1795
1783
{
1796
 
   mTrackPanel->OnTrackMenu();
 
1784
   // LLL:  There's a slight problem on Windows that I was not able to track
 
1785
   //       down to the actual cause.  I "think" it might be a problem in wxWidgets
 
1786
   //       on Windows, but I'm not sure.
 
1787
   //
 
1788
   //       Let's say the user has SHIFT+M assigned as the keyboard shortcut for
 
1789
   //       bringing up the track menu.  If there is only 1 wave track and the user
 
1790
   //       uses the shortcut, the menu is display and immediately disappears.  But,
 
1791
   //       if there are 2 or more wave tracks, then the menu is displayed.
 
1792
   //
 
1793
   //       However, what is actually happening is that the popup menu is processing
 
1794
   //       the "M" as the menu item to select after the menu is displayed.  With only
 
1795
   //       1 track, the only (enabled) menu item that begins with "M" is Mono and
 
1796
   //       that's what gets selected.
 
1797
   //
 
1798
   //       With 2+ wave tracks, there's 2 menu items that begin with "M" and Mono
 
1799
   //       is only highlighted by not selected, so the menu doesn't get dismissed.
 
1800
   //
 
1801
   //       While the 1 or 2 track example above is a way to recreate the issue, the
 
1802
   //       real problem is when there's only one enabled menu item that begins with
 
1803
   //       the selected shortcut key.
 
1804
   //
 
1805
   //       The workaround is to queue a context menu event, allowing the key press
 
1806
   //       event to complete.
 
1807
   wxContextMenuEvent e(wxEVT_CONTEXT_MENU, GetId());
 
1808
   mTrackPanel->AddPendingEvent(e);
1797
1809
}
1798
1810
 
1799
1811
void AudacityProject::OnTrackMute()
1898
1910
   Effect *f = NULL;
1899
1911
 
1900
1912
   effects = Effect::GetEffects(type);
 
1913
 
1901
1914
   f = (*effects)[index];
1902
1915
   delete effects;
1903
1916
 
2024
2037
 
2025
2038
void AudacityProject::OnStereoToMono(int index)
2026
2039
{
2027
 
   OnEffect(ALL_EFFECTS, mStereoToMonoIndex);
 
2040
   if (mStereoToMonoIndex >= 0)
 
2041
      OnEffect(ALL_EFFECTS, mStereoToMonoIndex);
2028
2042
}
2029
2043
 
2030
2044
void AudacityProject::OnProcessPlugin(int index)
2083
2097
 
2084
2098
void AudacityProject::OnUpload()
2085
2099
{
2086
 
   //if (mTags->ShowEditDialog(this, _("Edit ID3 Tags (for MP3 exporting)")))
2087
 
   //   PushState(_("Edit ID3 tags"), _("Edit ID3 Tags"));
 
2100
   //if (mTags->ShowEditDialog(this, wxT("Edit ID3 Tags (for MP3 exporting)")))
 
2101
   //   PushState(wxT("Edit ID3 Tags"), wxT("Edit ID3 Tags"));
2088
2102
 
2089
2103
   UploadDialog dlog(this);
2090
2104
   dlog.ShowModal();
2111
2125
 
2112
2126
   wxString fName = _("labels.txt");
2113
2127
 
2114
 
   fName = wxFileSelector(_("Export Labels As:"),
2115
 
                          NULL,
2116
 
                          fName,
2117
 
                          wxT("txt"),
2118
 
                          wxT("*.txt"), wxSAVE | wxOVERWRITE_PROMPT, this);
 
2128
   fName = FileSelector(_("Export Labels As:"),
 
2129
                        NULL,
 
2130
                        fName,
 
2131
                        wxT("txt"),
 
2132
                        wxT("*.txt"), wxSAVE | wxOVERWRITE_PROMPT, this);
2119
2133
 
2120
2134
   if (fName == wxT(""))
2121
2135
      return;
2166
2180
   f.Close();
2167
2181
}
2168
2182
 
2169
 
void AudacityProject::OnExportMix()
 
2183
void AudacityProject::OnExport()
2170
2184
{
2171
 
   ::ExportPCM(this, false, 0.0, mTracks->GetEndTime());
 
2185
   Exporter e;
 
2186
 
 
2187
   e.Process(this, false, 0.0, mTracks->GetEndTime());
2172
2188
}
2173
2189
 
2174
2190
void AudacityProject::OnExportSelection()
2175
2191
{
2176
 
   ::ExportPCM(this, true, mViewInfo.sel0, mViewInfo.sel1);
2177
 
}
2178
 
 
2179
 
void AudacityProject::OnExportMP3Mix()
2180
 
{
2181
 
   ::ExportCompressed(this, wxT("MP3"), false, 0.0, mTracks->GetEndTime());
2182
 
}
2183
 
 
2184
 
void AudacityProject::OnExportMP3Selection()
2185
 
{
2186
 
   ::ExportCompressed(this, wxT("MP3"), true, mViewInfo.sel0, mViewInfo.sel1);
2187
 
}
2188
 
 
2189
 
void AudacityProject::OnExportMP2Mix()
2190
 
{
2191
 
   ::ExportCompressed(this, wxT("MP2"), false, 0.0, mTracks->GetEndTime());
2192
 
}
2193
 
 
2194
 
void AudacityProject::OnExportMP2Selection()
2195
 
{
2196
 
   ::ExportCompressed(this, wxT("MP2"), true, mViewInfo.sel0, mViewInfo.sel1);
2197
 
}
2198
 
 
2199
 
void AudacityProject::OnExportOggMix()
2200
 
{
2201
 
   ::ExportCompressed(this, wxT("OGG"), false, 0.0, mTracks->GetEndTime());
2202
 
}
2203
 
 
2204
 
void AudacityProject::OnExportFLACMix()
2205
 
{
2206
 
   ::ExportCompressed(this, wxT("FLAC"), false, 0.0, mTracks->GetEndTime());
2207
 
}
2208
 
 
2209
 
void AudacityProject::OnExportOggSelection()
2210
 
{
2211
 
   ::ExportCompressed(this, wxT("OGG"), true, mViewInfo.sel0, mViewInfo.sel1);
2212
 
}
2213
 
 
2214
 
void AudacityProject::OnExportFLACSelection()
2215
 
{
2216
 
   ::ExportCompressed(this, wxT("FLAC"), true, mViewInfo.sel0, mViewInfo.sel1);
 
2192
   Exporter e;
 
2193
 
 
2194
   e.Process(this, true, mViewInfo.sel0, mViewInfo.sel1);
2217
2195
}
2218
2196
 
2219
2197
void AudacityProject::OnExportMultiple()
2220
2198
{
2221
 
   ::ExportMultiple(this);
 
2199
   ExportMultiple em(this);
 
2200
   
 
2201
   em.ShowModal();
2222
2202
}
2223
2203
 
2224
2204
void AudacityProject::OnPreferences()
2463
2443
   while (countTrack) {
2464
2444
      if (countTrack->GetSelected()) {
2465
2445
         if (countTrack->GetKind() == Track::Label) {
2466
 
            if (((LabelTrack *)countTrack)->PasteSelectedText(mViewInfo.sel0, mViewInfo.sel1)) {
 
2446
            LabelTrack *lt = (LabelTrack *) countTrack;
 
2447
            if (lt->PasteSelectedText(mViewInfo.sel0, mViewInfo.sel1)) {
2467
2448
               PushState(_("Pasted text from the clipboard"), _("Paste"));
 
2449
 
 
2450
               // Make sure caret is in view
 
2451
               int x;
 
2452
               if (lt->CalcCursorX(this, &x)) {
 
2453
                  mTrackPanel->ScrollIntoView(x);
 
2454
               }
 
2455
 
2468
2456
               RedrawProject();
2469
2457
               return;
2470
2458
            }
2985
2973
#endif
2986
2974
}
2987
2975
 
 
2976
void AudacityProject::OnSplitNew()
 
2977
{
 
2978
   TrackListIterator iter(mTracks);
 
2979
   Track *n = iter.First();
 
2980
   Track *dest;
 
2981
 
 
2982
   TrackList newTracks;
 
2983
 
 
2984
   n = iter.First();
 
2985
   while (n) {
 
2986
      if (n->GetSelected()) {
 
2987
         dest = NULL;
 
2988
         if (n->GetKind() == Track::Wave)
 
2989
         {
 
2990
            ((WaveTrack*)n)->SplitCut(mViewInfo.sel0, mViewInfo.sel1, &dest);
 
2991
         } else
 
2992
         {
 
2993
            n->Cut(mViewInfo.sel0, mViewInfo.sel1, &dest);
 
2994
         }
 
2995
         if (dest) {
 
2996
            dest->SetChannel(n->GetChannel());
 
2997
            dest->SetTeamed(n->GetTeamed()); // do first
 
2998
            dest->SetLinked(n->GetLinked());
 
2999
            dest->SetName(n->GetName());
 
3000
            dest->SetOffset(wxMax(mViewInfo.sel0, n->GetOffset()));
 
3001
            newTracks.Add(dest);
 
3002
         }
 
3003
      }
 
3004
      n = iter.Next();
 
3005
   }
 
3006
 
 
3007
   TrackListIterator nIter(&newTracks);
 
3008
   n = nIter.First();
 
3009
   while (n) {
 
3010
      mTracks->Add(n);
 
3011
      n = nIter.Next();
 
3012
   }
 
3013
 
 
3014
   PushState(_("Split to new track"), _("Split New"));
 
3015
 
 
3016
   RedrawProject();
 
3017
}
 
3018
 
 
3019
 
2988
3020
void AudacityProject::OnSplitLabelsToTracks()
2989
3021
{
2990
3022
   TrackListIterator iter(mTracks);
3084
3116
   mTrackPanel->Refresh(false);
3085
3117
}
3086
3118
 
 
3119
void AudacityProject::OnSelectNone()
 
3120
{
 
3121
   TrackListIterator iter(mTracks);
 
3122
 
 
3123
   Track *t = iter.First();
 
3124
   while (t) {
 
3125
      t->SetSelected(false);
 
3126
      t = iter.Next();
 
3127
   }
 
3128
   mViewInfo.sel1 = mViewInfo.sel0;
 
3129
 
 
3130
   ModifyState();
 
3131
   
 
3132
   mTrackPanel->Refresh(false);
 
3133
}
 
3134
 
3087
3135
void AudacityProject::OnSelectCursorEnd()
3088
3136
{
3089
3137
   double maxEndOffset = -1000000.0;
3430
3478
   ModifyToolbarMenus();
3431
3479
}
3432
3480
 
 
3481
void AudacityProject::OnResetToolBars()
 
3482
{
 
3483
   mToolManager->Reset();
 
3484
   ModifyToolbarMenus();
 
3485
}
 
3486
 
3433
3487
 
3434
3488
//
3435
3489
// Project Menu
3440
3494
   wxString path = gPrefs->Read(wxT("/DefaultOpenPath"),::wxGetCwd());
3441
3495
 
3442
3496
   // TODO: Build the list of file types dynamically
3443
 
   
3444
 
   wxFileDialog dlog(this, _("Select one or more audio files..."),
3445
 
                     path, wxT(""),
3446
 
                     GetImportFilesFilter(),
3447
 
                     wxOPEN | wxMULTIPLE);
 
3497
 
 
3498
   FileDialog dlog(this, _("Select one or more audio files..."),
 
3499
                   path, wxT(""),
 
3500
                   GetImportFilesFilter(),
 
3501
                   wxOPEN | wxMULTIPLE);
3448
3502
 
3449
3503
   int result = dlog.ShowModal();
3450
3504
 
3466
3520
      
3467
3521
      Import(fileName);
3468
3522
   }
 
3523
   HandleResize(); // Adjust scrollers for new track sizes.
3469
3524
}
3470
3525
 
3471
3526
void AudacityProject::OnImportLabels()
3473
3528
   wxString path = gPrefs->Read(wxT("/DefaultOpenPath"),::wxGetCwd());
3474
3529
 
3475
3530
   wxString fileName =
3476
 
       wxFileSelector(_("Select a text file containing labels..."),
3477
 
                      path,     // Path
3478
 
                      wxT(""),       // Name
3479
 
                      wxT(".txt"),   // Extension
3480
 
                      _("Text files (*.txt)|*.txt|All files (*.*)|*.*"),
3481
 
                      0,        // Flags
3482
 
                      this);    // Parent
 
3531
       FileSelector(_("Select a text file containing labels..."),
 
3532
                    path,     // Path
 
3533
                    wxT(""),       // Name
 
3534
                    wxT(".txt"),   // Extension
 
3535
                    _("Text files (*.txt)|*.txt|All files (*.*)|*.*"),
 
3536
                    0,        // Flags
 
3537
                    this);    // Parent
3483
3538
 
3484
3539
   if (fileName != wxT("")) {
3485
3540
      path =::wxPathOnly(fileName);
3513
3568
{
3514
3569
   wxString path = gPrefs->Read(wxT("/DefaultOpenPath"),::wxGetCwd());
3515
3570
 
3516
 
   wxString fileName = wxFileSelector(_("Select a MIDI file..."),
3517
 
                                      path,     // Path
3518
 
                                      wxT(""),       // Name
3519
 
                                      wxT(""),       // Extension
3520
 
                                      _("All files (*.*)|*.*|MIDI files (*.mid)|*.mid|Allegro files (*.gro)|*.gro"),
3521
 
                                      0,        // Flags
3522
 
                                      this);    // Parent
 
3571
   wxString fileName = FileSelector(_("Select a MIDI file..."),
 
3572
                                    path,     // Path
 
3573
                                    wxT(""),       // Name
 
3574
                                    wxT(""),       // Extension
 
3575
                                    _("All files (*.*)|*.*|MIDI files (*.mid)|*.mid|Allegro files (*.gro)|*.gro"),
 
3576
                                    0,        // Flags
 
3577
                                    this);    // Parent
3523
3578
 
3524
3579
   if (fileName != wxT("")) {
3525
3580
      path =::wxPathOnly(fileName);
3548
3603
   wxString path = gPrefs->Read(wxT("/DefaultOpenPath"),::wxGetCwd());
3549
3604
 
3550
3605
   wxString fileName =
3551
 
       wxFileSelector(_("Select any uncompressed audio file..."),
3552
 
                      path,     // Path
3553
 
                      wxT(""),       // Name
3554
 
                      wxT(""),       // Extension
3555
 
                      _("All files (*)|*"),
3556
 
                      0,        // Flags
3557
 
                      this);    // Parent
 
3606
       FileSelector(_("Select any uncompressed audio file..."),
 
3607
                    path,     // Path
 
3608
                    wxT(""),       // Name
 
3609
                    wxT(""),       // Extension
 
3610
                    _("All files (*)|*"),
 
3611
                    0,        // Flags
 
3612
                    this);    // Parent
3558
3613
 
3559
3614
   if (fileName == wxT(""))
3560
3615
      return;
3581
3636
      return;
3582
3637
 
3583
3638
   AddImportedTracks(fileName, newTracks, numTracks);
 
3639
   HandleResize(); // Adjust scrollers for new track sizes.
3584
3640
}
3585
3641
 
3586
3642
void AudacityProject::OnEditID3()
3648
3704
         else
3649
3705
            msg.Printf(_("Mixed and rendered %d tracks into one new mono track"),
3650
3706
                       selectedCount);
3651
 
         PushState(msg, _("Mix and Render"));
 
3707
         PushState(msg, _NoAcc("&Mix and Render"));
3652
3708
      }
3653
3709
 
3654
3710
      mTrackPanel->SetFocusedTrack(newLeft);
3895
3951
 
3896
3952
void AudacityProject::OnNewTimeTrack()
3897
3953
{
3898
 
   TrackListIterator iter(mTracks);
3899
 
   Track *t = iter.First();
3900
 
   bool alreadyHaveTimeTrack = false;
3901
 
   
3902
 
   while (t)
3903
 
      {
3904
 
         if (t->GetKind() == Track::Time)
3905
 
            {
3906
 
               alreadyHaveTimeTrack = true;
3907
 
               break;
3908
 
            }
3909
 
         t = iter.Next();
3910
 
      }
3911
 
   
3912
 
   if( alreadyHaveTimeTrack )
3913
 
      {
3914
 
         wxString msg;
3915
 
         msg.Printf(_("The version of Audacity you are using does not support multiple time tracks."));
3916
 
         wxMessageBox(msg);
3917
 
      }
3918
 
   else
3919
 
      {
3920
 
         TimeTrack *t = new TimeTrack(mDirManager);
3921
 
 
3922
 
         SelectNone();
3923
 
         mTracks->AddToHead(t);
3924
 
         t->SetSelected(true);
3925
 
         
3926
 
         PushState(_("Created new time track"), _("New Track"));
3927
 
 
3928
 
         /*
3929
 
         TrackListIterator iter(mTracks);
3930
 
         for( Track *tr = iter.First(); (tr); tr = iter.Next() )
3931
 
            tr->SetTimeTrack( t );
3932
 
         */
3933
 
         
3934
 
         RedrawProject();
3935
 
         mTrackPanel->EnsureVisible(t);
3936
 
      }
 
3954
   if (mTracks->GetTimeTrack()) {
 
3955
      wxMessageBox(_("The version of Audacity you are using does not support multiple time tracks."));
 
3956
      return;
 
3957
   }
 
3958
 
 
3959
   TimeTrack *t = new TimeTrack(mDirManager);
 
3960
 
 
3961
   SelectNone();
 
3962
 
 
3963
   mTracks->AddToHead(t);
 
3964
   t->SetSelected(true);
 
3965
   
 
3966
   PushState(_("Created new time track"), _("New Track"));
 
3967
 
 
3968
   RedrawProject();
 
3969
   mTrackPanel->EnsureVisible(t);
3937
3970
}
3938
3971
 
3939
3972
void AudacityProject::OnSmartRecord()
4034
4067
   do {
4035
4068
      fileOkay = true;
4036
4069
 
4037
 
      fName = wxFileSelector(_("Save CleanSpeech Preset File As:"),
4038
 
                        path,
4039
 
                        wxT("*.csp"),       // default file extension
4040
 
                        extension,
4041
 
                        _("CleanSpeech Presets (*.csp)|*.csp"),
4042
 
                        wxSAVE | wxOVERWRITE_PROMPT);
 
4070
      fName = FileSelector(_("Save CleanSpeech Preset File As:"),
 
4071
                           path,
 
4072
                           wxT("*.csp"),       // default file extension
 
4073
                           extension,
 
4074
                           _("CleanSpeech Presets (*.csp)|*.csp"),
 
4075
                           wxSAVE | wxOVERWRITE_PROMPT);
4043
4076
 
4044
4077
      if (fName.empty()) { // if cancel selected
4045
4078
         return;
4117
4150
   do {
4118
4151
      fileOkay = true;
4119
4152
 
4120
 
      fName = wxFileSelector(_("Open CleanSpeech Preset File:"),
4121
 
                             path,
4122
 
                             _("*.csp"),       // default file name
4123
 
                             extension,
4124
 
                             _("CleanSpeech Presets (*.csp)|*.csp"),
4125
 
                             wxOPEN);
 
4153
      fName = FileSelector(wxT("Open CleanSpeech Preset File:"),
 
4154
                           path,
 
4155
                           wxT("*.csp"),       // default file name
 
4156
                           extension,
 
4157
                           wxT("CleanSpeech Presets (*.csp)|*.csp"),
 
4158
                           wxOPEN);
4126
4159
 
4127
4160
      if (fName.empty()) { // if cancel selected
4128
4161
         return;
4134
4167
         int lenPreset = sizeof(preset);
4135
4168
         int count = presetsFile.Read(preset, lenPreset);
4136
4169
         if (preset[0] != PRESET_FORMAT) {
4137
 
            wxMessageBox(wxString::Format(_("Preset may be invalid or corrupted.\nExpected format %d ... found %d"), PRESET_FORMAT, preset[0]),
4138
 
                         _("Error opening preset"),
 
4170
            wxMessageBox(wxString::Format(wxT("Preset may be invalid or corrupted.\nExpected format %d ... found %d"), PRESET_FORMAT, preset[0]),
 
4171
                         wxT("Error opening preset"),
4139
4172
                         wxOK | wxCENTRE | wxICON_WARNING, this);
4140
4173
            return;
4141
4174
         }
4167
4200
         presetsFile.Close();
4168
4201
      }
4169
4202
      else {
4170
 
         wxMessageBox(_("Problem encountered importing presets."),
4171
 
                     _("Unable to import"),
 
4203
         wxMessageBox(wxT("Problem encountered importing presets."),
 
4204
                     wxT("Unable to import"),
4172
4205
                     wxOK | wxICON_WARNING);
4173
4206
         fileOkay = false;
4174
4207
         continue;
4217
4250
//      double startTime = 0.0;
4218
4251
      OnSelectAll();
4219
4252
      pathName = gPrefs->Read(wxT("/DefaultOpenPath"), ::wxGetCwd());
4220
 
      ::wxMessageBox(wxString::Format(_("Export recording to %s\n/cleaned/%s.mp3"), 
 
4253
      ::wxMessageBox(wxString::Format(wxT("Export recording to %s\n/cleaned/%s.mp3"), 
4221
4254
         pathName.c_str(), justName.c_str()),
4222
 
         _("Export recording"),
 
4255
         wxT("Export recording"),
4223
4256
                  wxOK | wxCENTRE);
4224
4257
      pathName += wxT("/");
4225
4258
   }
4227
4260
   cleanedName += wxT("cleaned");
4228
4261
   bool flag  = ::wxFileName::FileExists(cleanedName);
4229
4262
   if (flag == true) {
4230
 
      ::wxMessageBox(_("Cannot create directory 'cleaned'. \nFile already exists that is not a directory"));
 
4263
      ::wxMessageBox(wxT("Cannot create directory 'cleaned'. \nFile already exists that is not a directory"));
4231
4264
      return wxT("");
4232
4265
   }
4233
4266
   ::wxFileName::Mkdir(cleanedName, 0777, wxPATH_MKDIR_FULL); // make sure it exists
4291
4324
   dlog.ShowModal();
4292
4325
}
4293
4326
 
4294
 
void AudacityProject::OnHelp()
4295
 
{
4296
 
   ::ShowHelp(this);
4297
 
}
4298
 
 
4299
 
void AudacityProject::OnHelpIndex()
4300
 
{
4301
 
   ::ShowHelpIndex(this);
4302
 
}
4303
 
 
4304
 
void AudacityProject::OnHelpSearch()
4305
 
{
4306
 
   ::SearchHelp(this);
4307
 
}
4308
 
 
4309
4327
void AudacityProject::OnBenchmark()
4310
4328
{
4311
4329
   ::RunBenchmark(this);
4312
4330
}
4313
4331
 
 
4332
void AudacityProject::OnScreenshot()
 
4333
{
 
4334
   ::OpenScreenshotTools();
 
4335
}
 
4336
 
4314
4337
//
4315
4338
 
4316
4339
void AudacityProject::OnSeparator()