Audacity 3.2.0
Public Member Functions | Static Public Member Functions | Public Attributes | Private Member Functions | Private Attributes | List of all members
MenuManager Class Referencefinal

MenuManager handles updates to menu state. More...

#include <Menus.h>

Inheritance diagram for MenuManager:
[legend]
Collaboration diagram for MenuManager:
[legend]

Public Member Functions

 MenuManager (AudacityProject &project)
 
 MenuManager (const MenuManager &) PROHIBITED
 
MenuManageroperator= (const MenuManager &) PROHIBITED
 
 ~MenuManager ()
 
void UpdateMenus (bool checkActive=true)
 
CommandFlag GetUpdateFlags (bool checkActive=false) const
 
void UpdatePrefs () override
 
bool ReportIfActionNotAllowed (const TranslatableString &Name, CommandFlag &flags, CommandFlag flagsRqd)
 
bool TryToMakeActionAllowed (CommandFlag &flags, CommandFlag flagsRqd)
 
- Public Member Functions inherited from MenuCreator
 MenuCreator ()
 
 ~MenuCreator ()
 
void CreateMenusAndCommands (AudacityProject &project)
 
void RebuildMenuBar (AudacityProject &project)
 
- Public Member Functions inherited from ClientData::Base
virtual ~Base ()
 

Static Public Member Functions

static MenuManagerGet (AudacityProject &project)
 
static const MenuManagerGet (const AudacityProject &project)
 
static void Visit (ToolbarMenuVisitor &visitor)
 
static void ModifyUndoMenuItems (AudacityProject &project)
 
static void ModifyToolbarMenus (AudacityProject &project)
 
static void ModifyAllProjectToolbarMenus ()
 
- Static Public Member Functions inherited from MenuCreator
static void RebuildAllMenuBars ()
 

Public Attributes

int mWhatIfNoSelection
 
bool mStopIfWasPaused
 
- Public Attributes inherited from MenuCreator
CommandFlag mLastFlags
 
PluginID mLastGenerator {}
 
PluginID mLastEffect {}
 
PluginID mLastAnalyzer {}
 
int mLastAnalyzerRegistration
 
int mLastAnalyzerRegisteredId
 
PluginID mLastTool {}
 
int mLastToolRegistration
 
int mLastToolRegisteredId
 
unsigned mRepeatGeneratorFlags
 
unsigned mRepeatEffectFlags
 
unsigned mRepeatAnalyzerFlags
 
unsigned mRepeatToolFlags
 

Private Member Functions

void TellUserWhyDisallowed (const TranslatableString &Name, CommandFlag flagsGot, CommandFlag flagsRequired)
 
void OnUndoRedo (struct UndoRedoMessage)
 
- Private Member Functions inherited from PrefsListener
 PrefsListener ()
 
virtual ~PrefsListener ()
 
virtual void UpdatePrefs ()=0
 
virtual void UpdateSelectedPrefs (int id)
 

Private Attributes

Observer::Subscription mUndoSubscription
 
AudacityProjectmProject
 

Additional Inherited Members

- Public Types inherited from MenuCreator
enum  { repeattypenone = 0 , repeattypeplugin = 1 , repeattypeunique = 2 , repeattypeapplymacro = 3 }
 
- Static Private Member Functions inherited from PrefsListener
static void Broadcast (int id=0)
 Call this static function to notify all PrefsListener objects. More...
 

Detailed Description

MenuManager handles updates to menu state.

Definition at line 74 of file Menus.h.

Constructor & Destructor Documentation

◆ MenuManager() [1/2]

MenuManager::MenuManager ( AudacityProject project)
explicit

Definition at line 81 of file Menus.cpp.

82 : mProject{ project }
83{
87}
void OnUndoRedo(struct UndoRedoMessage)
Definition: Menus.cpp:513
void UpdatePrefs() override
Definition: Menus.cpp:93
Observer::Subscription mUndoSubscription
Definition: Menus.h:119
AudacityProject & mProject
Definition: Menus.h:120
Subscription Subscribe(Callback callback)
Connect a callback to the Publisher; later-connected are called earlier.
Definition: Observer.h:199
static UndoManager & Get(AudacityProject &project)
Definition: UndoManager.cpp:67

References UndoManager::Get(), mUndoSubscription, OnUndoRedo(), Observer::Publisher< Message, NotifyAll >::Subscribe(), and UpdatePrefs().

Here is the call graph for this function:

◆ MenuManager() [2/2]

MenuManager::MenuManager ( const MenuManager )

◆ ~MenuManager()

MenuManager::~MenuManager ( )

Definition at line 89 of file Menus.cpp.

90{
91}

Member Function Documentation

◆ Get() [1/2]

MenuManager & MenuManager::Get ( AudacityProject project)
static

Definition at line 71 of file Menus.cpp.

72{
73 return project.AttachedObjects::Get< MenuManager >( key );
74}
static const AudacityProject::AttachedObjects::RegisteredFactory key
Definition: Menus.cpp:66
MenuManager handles updates to menu state.
Definition: Menus.h:78

References key.

Referenced by anonymous_namespace{PluginMenus.cpp}::AnalyzeMenu(), MacroCommands::ApplyCommandInBatchMode(), CommonTrackPanelCell::DoContextMenu(), EffectUI::DoEffect(), anonymous_namespace{WindowMenus.cpp}::DoMacMinimize(), ProjectAudioManager::DoRecord(), DoReloadPreferences(), anonymous_namespace{PluginMenus.cpp}::EffectMenu(), CommandManager::FilterKeyEvent(), ProjectWindow::FixScrollbars(), anonymous_namespace{PluginMenus.cpp}::GenerateMenu(), Get(), CommandManager::HandleCommandEntry(), anonymous_namespace{PluginMenus.cpp}::HasLastAnalyzerFlag(), anonymous_namespace{PluginMenus.cpp}::HasLastEffectFlag(), anonymous_namespace{PluginMenus.cpp}::HasLastGeneratorFlag(), anonymous_namespace{PluginMenus.cpp}::HasLastToolFlag(), ModifyAllProjectToolbarMenus(), ProjectManager::New(), EffectUIHost::OnApply(), PluginActions::Handler::OnApplyMacroDirectlyByName(), EditToolBar::OnButton(), ExtraActions::Handler::OnFullScreen(), ProjectWindow::OnMenu(), EditActions::Handler::OnPreferences(), PluginActions::Handler::OnRepeatLastAnalyzer(), PluginActions::Handler::OnRepeatLastEffect(), PluginActions::Handler::OnRepeatLastGenerator(), PluginActions::Handler::OnRepeatLastTool(), PluginActions::Handler::OnResetConfig(), ToolManager::OnResetToolBars(), AttachedToolBarMenuItem::OnShowToolBar(), ProjectWindow::OnUpdateUI(), MenuCreator::RebuildAllMenuBars(), CommandManager::RegisterLastAnalyzer(), CommandManager::RegisterLastTool(), SelectUtilities::SelectAllIfNone(), SelectUtilities::SelectAllIfNoneAndAllowed(), anonymous_namespace{PluginMenus.cpp}::ToolsMenu(), and MacrosWindow::UpdateMenus().

Here is the caller graph for this function:

◆ Get() [2/2]

const MenuManager & MenuManager::Get ( const AudacityProject project)
static

Definition at line 76 of file Menus.cpp.

77{
78 return Get( const_cast< AudacityProject & >( project ) );
79}
The top-level handle to an Audacity project. It serves as a source of events that other objects can b...
Definition: Project.h:89
static MenuManager & Get(AudacityProject &project)
Definition: Menus.cpp:71

References Get().

Here is the call graph for this function:

◆ GetUpdateFlags()

CommandFlag MenuManager::GetUpdateFlags ( bool  checkActive = false) const

Definition at line 553 of file Menus.cpp.

554{
555 // This method determines all of the flags that determine whether
556 // certain menu items and commands should be enabled or disabled,
557 // and returns them in a bitfield. Note that if none of the flags
558 // have changed, it's not necessary to even check for updates.
559
560 // static variable, used to remember flags for next time.
561 static CommandFlag lastFlags;
562
563 CommandFlag flags, quickFlags;
564
565 const auto &options = Options();
566 size_t ii = 0;
567 for ( const auto &predicate : RegisteredPredicates() ) {
568 if ( options[ii].quickTest ) {
569 quickFlags[ii] = true;
570 if( predicate( mProject ) )
571 flags[ii] = true;
572 }
573 ++ii;
574 }
575
576 if ( checkActive && !GetProjectFrame( mProject ).IsActive() )
577 // quick 'short-circuit' return.
578 flags = (lastFlags & ~quickFlags) | flags;
579 else {
580 ii = 0;
581 for ( const auto &predicate : RegisteredPredicates() ) {
582 if ( !options[ii].quickTest && predicate( mProject ) )
583 flags[ii] = true;
584 ++ii;
585 }
586 }
587
588 lastFlags = flags;
589 return flags;
590}
std::bitset< NCommandFlags > CommandFlag
Definition: CommandFlag.h:31
AUDACITY_DLL_API wxFrame & GetProjectFrame(AudacityProject &project)
Get the top-level window associated with the project (as a wxFrame only, when you do not need to use ...
Predicates & RegisteredPredicates()
Definition: Menus.cpp:530
std::vector< CommandFlagOptions > & Options()
Definition: Menus.cpp:535

References GetProjectFrame(), anonymous_namespace{Menus.cpp}::Options(), and anonymous_namespace{Menus.cpp}::RegisteredPredicates().

Referenced by CommonTrackPanelCell::DoContextMenu(), CommandManager::FilterKeyEvent(), EditToolBar::OnButton(), ProjectWindow::OnMenu(), SelectUtilities::SelectAllIfNone(), and SelectUtilities::SelectAllIfNoneAndAllowed().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ ModifyAllProjectToolbarMenus()

void MenuManager::ModifyAllProjectToolbarMenus ( )
static

Definition at line 592 of file Menus.cpp.

593{
594 for (auto pProject : AllProjects{}) {
595 auto &project = *pProject;
596 MenuManager::Get(project).ModifyToolbarMenus(project);
597 }
598}
static void ModifyToolbarMenus(AudacityProject &project)
Definition: Menus.cpp:600

References Get(), and ModifyToolbarMenus().

Referenced by TrackActions::Handler::OnSyncLock(), TransportActions::Handler::OnTogglePlayRecording(), TransportActions::Handler::OnToggleSoundActivated(), TransportActions::Handler::OnToggleSWPlaythrough(), LabelEditActions::Handler::OnToggleTypeToCreateLabel(), and AdornedRulerPanel::TogglePinnedHead().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ ModifyToolbarMenus()

void MenuManager::ModifyToolbarMenus ( AudacityProject project)
static

Definition at line 600 of file Menus.cpp.

601{
602 // Refreshes can occur during shutdown and the toolmanager may already
603 // be deleted, so protect against it.
604 auto &toolManager = ToolManager::Get( project );
605
606 auto &settings = ProjectSettings::Get( project );
607
608 // Now, go through each toolbar, and call EnableDisableButtons()
609 for (int i = 0; i < ToolBarCount; i++) {
610 auto bar = toolManager.GetToolBar(i);
611 if (bar)
612 bar->EnableDisableButtons();
613 }
614
615 // These don't really belong here, but it's easier and especially so for
616 // the Edit toolbar and the sync-lock menu item.
617 bool active;
618
619 gPrefs->Read(wxT("/GUI/SyncLockTracks"), &active, false);
620 settings.SetSyncLock(active);
621
622 CommandManager::Get( project ).UpdateCheckmarks( project );
623}
wxT("CloseDown"))
FileConfig * gPrefs
Definition: Prefs.cpp:71
@ ToolBarCount
Definition: ToolBar.h:90
static Settings & settings()
Definition: TrackInfo.cpp:87
void UpdateCheckmarks(AudacityProject &project)
static CommandManager & Get(AudacityProject &project)
static ProjectSettings & Get(AudacityProject &project)
static ToolManager & Get(AudacityProject &project)

References CommandManager::Get(), ProjectSettings::Get(), ToolManager::Get(), gPrefs, settings(), ToolBarCount, CommandManager::UpdateCheckmarks(), and wxT().

Referenced by ModifyAllProjectToolbarMenus(), ExtraActions::Handler::OnFullScreen(), ToolManager::OnResetToolBars(), AttachedToolBarMenuItem::OnShowToolBar(), and UpdateMenus().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ ModifyUndoMenuItems()

void MenuManager::ModifyUndoMenuItems ( AudacityProject project)
static

Definition at line 444 of file Menus.cpp.

445{
447 auto &undoManager = UndoManager::Get( project );
448 auto &commandManager = CommandManager::Get( project );
449 int cur = undoManager.GetCurrentState();
450
451 if (undoManager.UndoAvailable()) {
452 undoManager.GetShortDescription(cur, &desc);
453 commandManager.Modify(wxT("Undo"),
454 XXO("&Undo %s")
455 .Format( desc ));
456 commandManager.Enable(wxT("Undo"),
457 ProjectHistory::Get( project ).UndoAvailable());
458 }
459 else {
460 commandManager.Modify(wxT("Undo"),
461 XXO("&Undo"));
462 }
463
464 if (undoManager.RedoAvailable()) {
465 undoManager.GetShortDescription(cur+1, &desc);
466 commandManager.Modify(wxT("Redo"),
467 XXO("&Redo %s")
468 .Format( desc ));
469 commandManager.Enable(wxT("Redo"),
470 ProjectHistory::Get( project ).RedoAvailable());
471 }
472 else {
473 commandManager.Modify(wxT("Redo"),
474 XXO("&Redo"));
475 commandManager.Enable(wxT("Redo"), false);
476 }
477}
const TranslatableString desc
Definition: ExportPCM.cpp:58
#define XXO(s)
Definition: Internat.h:44
Abstract base class used in importing a file.
static ProjectHistory & Get(AudacityProject &project)
Holds a msgid for the translation catalog; may also bind format arguments.

References desc, ProjectHistory::Get(), UndoManager::Get(), CommandManager::Get(), wxT(), and XXO.

Referenced by anonymous_namespace{EditMenus.cpp}::EditMenu(), and PluginActions::Handler::OnApplyMacroDirectlyByName().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ OnUndoRedo()

void MenuManager::OnUndoRedo ( struct UndoRedoMessage  message)
private

Definition at line 513 of file Menus.cpp.

514{
515 switch (message.type) {
520 break;
521 default:
522 return;
523 }
525 UpdateMenus();
526}
static void ModifyUndoMenuItems(AudacityProject &project)
Definition: Menus.cpp:444
void UpdateMenus(bool checkActive=true)
Definition: Menus.cpp:643
enum UndoRedoMessage::Type type

References UndoRedoMessage::Pushed, UndoRedoMessage::Renamed, UndoRedoMessage::Reset, UndoRedoMessage::type, and UndoRedoMessage::UndoOrRedo.

Referenced by MenuManager().

Here is the caller graph for this function:

◆ operator=()

MenuManager & MenuManager::operator= ( const MenuManager )

◆ ReportIfActionNotAllowed()

bool MenuManager::ReportIfActionNotAllowed ( const TranslatableString Name,
CommandFlag flags,
CommandFlag  flagsRqd 
)

Definition at line 705 of file Menus.cpp.

707{
708 auto &project = mProject;
709 bool bAllowed = TryToMakeActionAllowed( flags, flagsRqd );
710 if( bAllowed )
711 return true;
712 auto &cm = CommandManager::Get( project );
713 TellUserWhyDisallowed( Name, flags & flagsRqd, flagsRqd);
714 return false;
715}
bool TryToMakeActionAllowed(CommandFlag &flags, CommandFlag flagsRqd)
Definition: Menus.cpp:720
void TellUserWhyDisallowed(const TranslatableString &Name, CommandFlag flagsGot, CommandFlag flagsRequired)
Definition: Menus.cpp:751

References CommandManager::Get().

Referenced by CommandManager::HandleCommandEntry(), and EffectUIHost::OnApply().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ TellUserWhyDisallowed()

void MenuManager::TellUserWhyDisallowed ( const TranslatableString Name,
CommandFlag  flagsGot,
CommandFlag  flagsRequired 
)
private

Definition at line 751 of file Menus.cpp.

753{
754 // The default string for 'reason' is a catch all. I hope it won't ever be seen
755 // and that we will get something more specific.
756 auto reason = XO("There was a problem with your last action. If you think\nthis is a bug, please tell us exactly where it occurred.");
757 // The default title string is 'Disallowed'.
758 auto untranslatedTitle = XO("Disallowed");
759 wxString helpPage;
760
761 bool enableDefaultMessage = true;
762 bool defaultMessage = true;
763
764 auto doOption = [&](const CommandFlagOptions &options) {
765 if ( options.message ) {
766 reason = options.message( Name );
767 defaultMessage = false;
768 if ( !options.title.empty() )
769 untranslatedTitle = options.title;
770 helpPage = options.helpPage;
771 return true;
772 }
773 else {
774 enableDefaultMessage =
775 enableDefaultMessage && options.enableDefaultMessage;
776 return false;
777 }
778 };
779
780 const auto &alloptions = Options();
781 auto missingFlags = flagsRequired & ~flagsGot;
782
783 // Find greatest priority
784 unsigned priority = 0;
785 for ( const auto &options : alloptions )
786 priority = std::max( priority, options.priority );
787
788 // Visit all unsatisfied conditions' options, by descending priority,
789 // stopping when we find a message
790 ++priority;
791 while( priority-- ) {
792 size_t ii = 0;
793 for ( const auto &options : alloptions ) {
794 if (
795 priority == options.priority
796 &&
797 missingFlags[ii]
798 &&
799 doOption( options ) )
800 goto done;
801
802 ++ii;
803 }
804 }
805 done:
806
807 if (
808 // didn't find a message
809 defaultMessage
810 &&
811 // did find a condition that suppresses the default message
812 !enableDefaultMessage
813 )
814 return;
815
816 // Does not have the warning icon...
818 untranslatedTitle,
819 reason,
820 helpPage);
821}
#define XO(s)
Definition: Internat.h:31
void ShowErrorDialog(const WindowPlacement &placement, const TranslatableString &dlogTitle, const TranslatableString &message, const ManualPageID &helpPage, const ErrorDialogOptions &options={})
Show an error dialog with a link to the manual for further help.
Definition: BasicUI.h:254

References anonymous_namespace{Menus.cpp}::Options(), BasicUI::ShowErrorDialog(), and XO.

Here is the call graph for this function:

◆ TryToMakeActionAllowed()

bool MenuManager::TryToMakeActionAllowed ( CommandFlag flags,
CommandFlag  flagsRqd 
)

Determines if flags for command are compatible with current state. If not, then try some recovery action to make it so.

Returns
whether compatible or not after any actions taken.

Definition at line 720 of file Menus.cpp.

722{
723 auto &project = mProject;
724
725 if( flags.none() )
726 flags = GetUpdateFlags();
727
728 // Visit the table of recovery actions
729 auto &enablers = Enablers();
730 auto iter = enablers.begin(), end = enablers.end();
731 while ((flags & flagsRqd) != flagsRqd && iter != end) {
732 const auto &enabler = *iter;
733 auto actual = enabler.actualFlags();
734 auto MissingFlags = (~flags & flagsRqd);
735 if (
736 // Do we have the right precondition?
737 (flags & actual) == actual
738 &&
739 // Can we get the condition we need?
740 (MissingFlags & enabler.possibleFlags()).any()
741 ) {
742 // Then try the function
743 enabler.tryEnable( project, flagsRqd );
744 flags = GetUpdateFlags();
745 }
746 ++iter;
747 }
748 return (flags & flagsRqd) == flagsRqd;
749}
CommandFlag GetUpdateFlags(bool checkActive=false) const
Definition: Menus.cpp:553
auto end(const Ptr< Type, BaseDeleter > &p)
Enables range-for.
Definition: PackedArray.h:159
MenuItemEnablers & Enablers()
Definition: Menus.cpp:628

References anonymous_namespace{Menus.cpp}::Enablers(), and PackedArray::end().

Referenced by ProjectAudioManager::DoRecord().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ UpdateMenus()

void MenuManager::UpdateMenus ( bool  checkActive = true)

Definition at line 643 of file Menus.cpp.

644{
645 auto &project = mProject;
646
647 auto flags = GetUpdateFlags(checkActive);
648 // Return from this function if nothing's changed since
649 // the last time we were here.
650 if (flags == mLastFlags)
651 return;
652 mLastFlags = flags;
653
654 auto flags2 = flags;
655
656 // We can enable some extra items if we have select-all-on-none.
657 //EXPLAIN-ME: Why is this here rather than in GetUpdateFlags()?
658 //ANSWER: Because flags2 is used in the menu enable/disable.
659 //The effect still needs flags to determine whether it will need
660 //to actually do the 'select all' to make the command valid.
661
662 for ( const auto &enabler : Enablers() ) {
663 auto actual = enabler.actualFlags();
664 if (
665 enabler.applicable( project ) && (flags & actual) == actual
666 )
667 flags2 |= enabler.possibleFlags();
668 }
669
670 auto &commandManager = CommandManager::Get( project );
671
672 // With select-all-on-none, some items that we don't want enabled may have
673 // been enabled, since we changed the flags. Here we manually disable them.
674 // 0 is grey out, 1 is Autoselect, 2 is Give warnings.
675 commandManager.EnableUsingFlags(
676 flags2, // the "lax" flags
677 (mWhatIfNoSelection == 0 ? flags2 : flags) // the "strict" flags
678 );
679
681}
CommandFlag mLastFlags
Definition: Menus.h:49
int mWhatIfNoSelection
Definition: Menus.h:124

References anonymous_namespace{Menus.cpp}::Enablers(), CommandManager::Get(), and ModifyToolbarMenus().

Referenced by MacroCommands::ApplyCommandInBatchMode(), EffectUI::DoEffect(), anonymous_namespace{WindowMenus.cpp}::DoMacMinimize(), ProjectWindow::FixScrollbars(), and ProjectWindow::OnUpdateUI().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ UpdatePrefs()

void MenuManager::UpdatePrefs ( )
overridevirtual

Implements PrefsListener.

Definition at line 93 of file Menus.cpp.

94{
95 bool bSelectAllIfNone;
96 gPrefs->Read(wxT("/GUI/SelectAllOnNone"), &bSelectAllIfNone, false);
97 // 0 is grey out, 1 is Autoselect, 2 is Give warnings.
98#ifdef EXPERIMENTAL_DA
99 // DA warns or greys out.
100 mWhatIfNoSelection = bSelectAllIfNone ? 2 : 0;
101#else
102 // Audacity autoselects or warns.
103 mWhatIfNoSelection = bSelectAllIfNone ? 1 : 2;
104#endif
105 mStopIfWasPaused = true; // not configurable for now, but could be later.
106}
bool mStopIfWasPaused
Definition: Menus.h:125

References gPrefs, mStopIfWasPaused, mWhatIfNoSelection, and wxT().

Referenced by MenuManager().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ Visit()

void MenuManager::Visit ( ToolbarMenuVisitor visitor)
static

Definition at line 435 of file Menus.cpp.

436{
437 static const auto menuTree = MenuTable::Items( MenuPathStart );
438
439 wxLogNull nolog;
440 Registry::Visit( visitor, menuTree.get(), &sRegistry() );
441}
static const auto MenuPathStart
std::unique_ptr< MenuItems > Items(const Identifier &internalName, Args &&... args)
void Visit(Visitor &visitor, BaseItem *pTopItem, const GroupItem *pRegistry)
Definition: Registry.cpp:713
static Registry::GroupItem & sRegistry()
Definition: Menus.cpp:254

References MenuTable::Items(), MenuPathStart, anonymous_namespace{Menus.cpp}::sRegistry(), and Registry::Visit().

Referenced by MenuCreator::CreateMenusAndCommands(), and HelpActions::Handler::OnMenuTree().

Here is the call graph for this function:
Here is the caller graph for this function:

Member Data Documentation

◆ mProject

AudacityProject& MenuManager::mProject
private

Definition at line 120 of file Menus.h.

◆ mStopIfWasPaused

bool MenuManager::mStopIfWasPaused

Definition at line 125 of file Menus.h.

Referenced by UpdatePrefs().

◆ mUndoSubscription

Observer::Subscription MenuManager::mUndoSubscription
private

Definition at line 119 of file Menus.h.

Referenced by MenuManager().

◆ mWhatIfNoSelection

int MenuManager::mWhatIfNoSelection

Definition at line 124 of file Menus.h.

Referenced by UpdatePrefs().


The documentation for this class was generated from the following files: