Changeset 52459 in vbox for trunk/src/VBox/Frontends/VirtualBox

Timestamp:

Aug 22, 2014 11:03:40 AM (11 years ago)

Author:

vboxsync

svn:sync-xref-src-repo-rev:

95673

Message:

FE/Qt: 7462: Runtime UI: Move action-pool related enums to Q_OBJECT zone to be possible to register them for meta-data access.

Location:

trunk/src/VBox/Frontends/VirtualBox

Files:

• Makefile.kmk (modified) (1 diff)
• src/converter/UIConverterBackend.h (modified) (2 diffs)
• src/converter/UIConverterBackendGlobal.cpp (modified) (12 diffs)
• src/extradata/UIExtraDataDefs.h (modified) (2 diffs)
• src/extradata/UIExtraDataManager.cpp (modified) (7 diffs)
• src/extradata/UIExtraDataManager.h (modified) (1 diff)
• src/globals/UIActionPool.cpp (modified) (12 diffs)
• src/globals/UIActionPool.h (modified) (2 diffs)
• src/runtime/UIActionPoolRuntime.cpp (modified) (69 diffs)
• src/runtime/UIActionPoolRuntime.h (modified) (2 diffs)
• src/runtime/UISession.cpp (modified) (5 diffs)
• src/runtime/fullscreen/UIMachineLogicFullscreen.cpp (modified) (2 diffs)
• src/runtime/scale/UIMachineLogicScale.cpp (modified) (2 diffs)
• src/runtime/seamless/UIMachineLogicSeamless.cpp (modified) (2 diffs)
• src/selector/UIActionPoolSelector.h (modified) (1 diff)

trunk/src/VBox/Frontends/VirtualBox/Makefile.kmk

@@ -279 +279 @@
         src/extensions/QIAdvancedToolBar.h \
         src/extensions/graphics/QIGraphicsWidget.h \
+        src/extradata/UIExtraDataDefs.h \
         src/extradata/UIExtraDataManager.h \
         src/globals/UIActionPool.h \

trunk/src/VBox/Frontends/VirtualBox/src/converter/UIConverterBackend.h

@@ -70 +70 @@
 template<> bool canConvert<SizeSuffix>();
 template<> bool canConvert<StorageSlot>();
-template<> bool canConvert<MenuHelpActionType>();
+template<> bool canConvert<UIExtraDataMetaDefs::MenuHelpActionType>();
 #ifdef Q_WS_MAC
-template<> bool canConvert<MenuApplicationActionType>();
+template<> bool canConvert<UIExtraDataMetaDefs::MenuApplicationActionType>();
 #endif /* Q_WS_MAC */
-template<> bool canConvert<RuntimeMenuType>();
-template<> bool canConvert<RuntimeMenuMachineActionType>();
-template<> bool canConvert<RuntimeMenuViewActionType>();
-template<> bool canConvert<RuntimeMenuDevicesActionType>();
+template<> bool canConvert<UIExtraDataMetaDefs::RuntimeMenuType>();
+template<> bool canConvert<UIExtraDataMetaDefs::RuntimeMenuMachineActionType>();
+template<> bool canConvert<UIExtraDataMetaDefs::RuntimeMenuViewActionType>();
+template<> bool canConvert<UIExtraDataMetaDefs::RuntimeMenuDevicesActionType>();
 #ifdef VBOX_WITH_DEBUGGER_GUI
-template<> bool canConvert<RuntimeMenuDebuggerActionType>();
+template<> bool canConvert<UIExtraDataMetaDefs::RuntimeMenuDebuggerActionType>();
 #endif /* VBOX_WITH_DEBUGGER_GUI */
 template<> bool canConvert<UIVisualStateType>();
@@ -123 +123 @@
 template<> QString toString(const StorageSlot &storageSlot);
 template<> StorageSlot fromString<StorageSlot>(const QString &strStorageSlot);
-template<> QString toInternalString(const MenuHelpActionType &menuHelpActionType);
-template<> MenuHelpActionType fromInternalString<MenuHelpActionType>(const QString &strMenuHelpActionType);
+template<> QString toInternalString(const UIExtraDataMetaDefs::MenuHelpActionType &menuHelpActionType);
+template<> UIExtraDataMetaDefs::MenuHelpActionType fromInternalString<UIExtraDataMetaDefs::MenuHelpActionType>(const QString &strMenuHelpActionType);
 #ifdef Q_WS_MAC
-template<> QString toInternalString(const MenuApplicationActionType &runtimeMenuApplicationActionType);
-template<> MenuApplicationActionType fromInternalString<MenuApplicationActionType>(const QString &strRuntimeMenuApplicationActionType);
+template<> QString toInternalString(const UIExtraDataMetaDefs::MenuApplicationActionType &runtimeMenuApplicationActionType);
+template<> UIExtraDataMetaDefs::MenuApplicationActionType fromInternalString<UIExtraDataMetaDefs::MenuApplicationActionType>(const QString &strRuntimeMenuApplicationActionType);
 #endif /* Q_WS_MAC */
-template<> QString toInternalString(const RuntimeMenuType &runtimeMenuType);
-template<> RuntimeMenuType fromInternalString<RuntimeMenuType>(const QString &strRuntimeMenuType);
-template<> QString toInternalString(const RuntimeMenuMachineActionType &runtimeMenuMachineActionType);
-template<> RuntimeMenuMachineActionType fromInternalString<RuntimeMenuMachineActionType>(const QString &strRuntimeMenuMachineActionType);
-template<> QString toInternalString(const RuntimeMenuViewActionType &runtimeMenuViewActionType);
-template<> RuntimeMenuViewActionType fromInternalString<RuntimeMenuViewActionType>(const QString &strRuntimeMenuViewActionType);
-template<> QString toInternalString(const RuntimeMenuDevicesActionType &runtimeMenuDevicesActionType);
-template<> RuntimeMenuDevicesActionType fromInternalString<RuntimeMenuDevicesActionType>(const QString &strRuntimeMenuDevicesActionType);
+template<> QString toInternalString(const UIExtraDataMetaDefs::RuntimeMenuType &runtimeMenuType);
+template<> UIExtraDataMetaDefs::RuntimeMenuType fromInternalString<UIExtraDataMetaDefs::RuntimeMenuType>(const QString &strRuntimeMenuType);
+template<> QString toInternalString(const UIExtraDataMetaDefs::RuntimeMenuMachineActionType &runtimeMenuMachineActionType);
+template<> UIExtraDataMetaDefs::RuntimeMenuMachineActionType fromInternalString<UIExtraDataMetaDefs::RuntimeMenuMachineActionType>(const QString &strRuntimeMenuMachineActionType);
+template<> QString toInternalString(const UIExtraDataMetaDefs::RuntimeMenuViewActionType &runtimeMenuViewActionType);
+template<> UIExtraDataMetaDefs::RuntimeMenuViewActionType fromInternalString<UIExtraDataMetaDefs::RuntimeMenuViewActionType>(const QString &strRuntimeMenuViewActionType);
+template<> QString toInternalString(const UIExtraDataMetaDefs::RuntimeMenuDevicesActionType &runtimeMenuDevicesActionType);
+template<> UIExtraDataMetaDefs::RuntimeMenuDevicesActionType fromInternalString<UIExtraDataMetaDefs::RuntimeMenuDevicesActionType>(const QString &strRuntimeMenuDevicesActionType);
 #ifdef VBOX_WITH_DEBUGGER_GUI
-template<> QString toInternalString(const RuntimeMenuDebuggerActionType &runtimeMenuDebuggerActionType);
-template<> RuntimeMenuDebuggerActionType fromInternalString<RuntimeMenuDebuggerActionType>(const QString &strRuntimeMenuDebuggerActionType);
+template<> QString toInternalString(const UIExtraDataMetaDefs::RuntimeMenuDebuggerActionType &runtimeMenuDebuggerActionType);
+template<> UIExtraDataMetaDefs::RuntimeMenuDebuggerActionType fromInternalString<UIExtraDataMetaDefs::RuntimeMenuDebuggerActionType>(const QString &strRuntimeMenuDebuggerActionType);
 #endif /* VBOX_WITH_DEBUGGER_GUI */
 template<> QString toInternalString(const UIVisualStateType &visualStateType);

trunk/src/VBox/Frontends/VirtualBox/src/converter/UIConverterBackendGlobal.cpp

@@ -34 +34 @@
 template<> bool canConvert<SizeSuffix>() { return true; }
 template<> bool canConvert<StorageSlot>() { return true; }
-template<> bool canConvert<MenuHelpActionType>() { return true; }
+template<> bool canConvert<UIExtraDataMetaDefs::MenuHelpActionType>() { return true; }
 #ifdef Q_WS_MAC
-template<> bool canConvert<MenuApplicationActionType>() { return true; }
+template<> bool canConvert<UIExtraDataMetaDefs::MenuApplicationActionType>() { return true; }
 #endif /* Q_WS_MAC */
-template<> bool canConvert<RuntimeMenuType>() { return true; }
-template<> bool canConvert<RuntimeMenuMachineActionType>() { return true; }
-template<> bool canConvert<RuntimeMenuViewActionType>() { return true; }
-template<> bool canConvert<RuntimeMenuDevicesActionType>() { return true; }
+template<> bool canConvert<UIExtraDataMetaDefs::RuntimeMenuType>() { return true; }
+template<> bool canConvert<UIExtraDataMetaDefs::RuntimeMenuMachineActionType>() { return true; }
+template<> bool canConvert<UIExtraDataMetaDefs::RuntimeMenuViewActionType>() { return true; }
+template<> bool canConvert<UIExtraDataMetaDefs::RuntimeMenuDevicesActionType>() { return true; }
 #ifdef VBOX_WITH_DEBUGGER_GUI
-template<> bool canConvert<RuntimeMenuDebuggerActionType>() { return true; }
+template<> bool canConvert<UIExtraDataMetaDefs::RuntimeMenuDebuggerActionType>() { return true; }
 #endif /* VBOX_WITH_DEBUGGER_GUI */
 template<> bool canConvert<UIVisualStateType>() { return true; }
@@ -357 +357 @@
 }
 
-/* QString <= MenuHelpActionType: */
-template<> QString toInternalString(const MenuHelpActionType &menuHelpActionType)
+/* QString <= UIExtraDataMetaDefs::MenuHelpActionType: */
+template<> QString toInternalString(const UIExtraDataMetaDefs::MenuHelpActionType &menuHelpActionType)
 {
     QString strResult;
     switch (menuHelpActionType)
     {
-        case MenuHelpActionType_Contents:             strResult = "Contents"; break;
-        case MenuHelpActionType_WebSite:              strResult = "WebSite"; break;
-        case MenuHelpActionType_ResetWarnings:        strResult = "ResetWarnings"; break;
+        case UIExtraDataMetaDefs::MenuHelpActionType_Contents:             strResult = "Contents"; break;
+        case UIExtraDataMetaDefs::MenuHelpActionType_WebSite:              strResult = "WebSite"; break;
+        case UIExtraDataMetaDefs::MenuHelpActionType_ResetWarnings:        strResult = "ResetWarnings"; break;
 #ifdef VBOX_GUI_WITH_NETWORK_MANAGER
-        case MenuHelpActionType_NetworkAccessManager: strResult = "NetworkAccessManager"; break;
-        case MenuHelpActionType_CheckForUpdates:      strResult = "CheckForUpdates"; break;
+        case UIExtraDataMetaDefs::MenuHelpActionType_NetworkAccessManager: strResult = "NetworkAccessManager"; break;
+        case UIExtraDataMetaDefs::MenuHelpActionType_CheckForUpdates:      strResult = "CheckForUpdates"; break;
 #endif /* VBOX_GUI_WITH_NETWORK_MANAGER */
 #ifndef Q_WS_MAC
-        case MenuHelpActionType_About:                strResult = "About"; break;
-        case MenuHelpActionType_Preferences:          strResult = "Preferences"; break;
+        case UIExtraDataMetaDefs::MenuHelpActionType_About:                strResult = "About"; break;
+        case UIExtraDataMetaDefs::MenuHelpActionType_Preferences:          strResult = "Preferences"; break;
 #endif /* !Q_WS_MAC */
-        case MenuHelpActionType_All:                  strResult = "All"; break;
+        case UIExtraDataMetaDefs::MenuHelpActionType_All:                  strResult = "All"; break;
         default:
         {
@@ -384 +384 @@
 }
 
-/* MenuHelpActionType <= QString: */
-template<> MenuHelpActionType fromInternalString<MenuHelpActionType>(const QString &strMenuHelpActionType)
-{
-    /* Here we have some fancy stuff allowing us
-     * to search through the keys using 'case-insensitive' rule: */
-    QStringList keys;               QList<MenuHelpActionType> values;
-    keys << "Contents";             values << MenuHelpActionType_Contents;
-    keys << "WebSite";              values << MenuHelpActionType_WebSite;
-    keys << "ResetWarnings";        values << MenuHelpActionType_ResetWarnings;
+/* UIExtraDataMetaDefs::MenuHelpActionType <= QString: */
+template<> UIExtraDataMetaDefs::MenuHelpActionType fromInternalString<UIExtraDataMetaDefs::MenuHelpActionType>(const QString &strMenuHelpActionType)
+{
+    /* Here we have some fancy stuff allowing us
+     * to search through the keys using 'case-insensitive' rule: */
+    QStringList keys;               QList<UIExtraDataMetaDefs::MenuHelpActionType> values;
+    keys << "Contents";             values << UIExtraDataMetaDefs::MenuHelpActionType_Contents;
+    keys << "WebSite";              values << UIExtraDataMetaDefs::MenuHelpActionType_WebSite;
+    keys << "ResetWarnings";        values << UIExtraDataMetaDefs::MenuHelpActionType_ResetWarnings;
 #ifdef VBOX_GUI_WITH_NETWORK_MANAGER
-    keys << "NetworkAccessManager"; values << MenuHelpActionType_NetworkAccessManager;
-    keys << "CheckForUpdates";      values << MenuHelpActionType_CheckForUpdates;
+    keys << "NetworkAccessManager"; values << UIExtraDataMetaDefs::MenuHelpActionType_NetworkAccessManager;
+    keys << "CheckForUpdates";      values << UIExtraDataMetaDefs::MenuHelpActionType_CheckForUpdates;
 #endif /* VBOX_GUI_WITH_NETWORK_MANAGER */
 #ifndef Q_WS_MAC
-    keys << "About";                values << MenuHelpActionType_About;
-    keys << "Preferences";          values << MenuHelpActionType_Preferences;
+    keys << "About";                values << UIExtraDataMetaDefs::MenuHelpActionType_About;
+    keys << "Preferences";          values << UIExtraDataMetaDefs::MenuHelpActionType_Preferences;
 #endif /* !Q_WS_MAC */
-    keys << "All";                  values << MenuHelpActionType_All;
+    keys << "All";                  values << UIExtraDataMetaDefs::MenuHelpActionType_All;
     /* Invalid type for unknown words: */
     if (!keys.contains(strMenuHelpActionType, Qt::CaseInsensitive))
-        return MenuHelpActionType_Invalid;
+        return UIExtraDataMetaDefs::MenuHelpActionType_Invalid;
     /* Corresponding type for known words: */
     return values.at(keys.indexOf(QRegExp(strMenuHelpActionType, Qt::CaseInsensitive)));
@@ -410 +410 @@
 
 #ifdef Q_WS_MAC
-/* QString <= MenuApplicationActionType: */
-template<> QString toInternalString(const MenuApplicationActionType &runtimeMenuApplicationActionType)
+/* QString <= UIExtraDataMetaDefs::MenuApplicationActionType: */
+template<> QString toInternalString(const UIExtraDataMetaDefs::MenuApplicationActionType &runtimeMenuApplicationActionType)
 {
     QString strResult;
     switch (runtimeMenuApplicationActionType)
     {
-        case MenuApplicationActionType_About:       strResult = "About"; break;
-        case MenuApplicationActionType_Preferences: strResult = "Preferences"; break;
-        case MenuApplicationActionType_Close:       strResult = "Close"; break;
-        case MenuApplicationActionType_All:         strResult = "All"; break;
+        case UIExtraDataMetaDefs::MenuApplicationActionType_About:       strResult = "About"; break;
+        case UIExtraDataMetaDefs::MenuApplicationActionType_Preferences: strResult = "Preferences"; break;
+        case UIExtraDataMetaDefs::MenuApplicationActionType_Close:       strResult = "Close"; break;
+        case UIExtraDataMetaDefs::MenuApplicationActionType_All:         strResult = "All"; break;
         default:
         {
@@ -429 +429 @@
 }
 
-/* MenuApplicationActionType <= QString: */
-template<> MenuApplicationActionType fromInternalString<MenuApplicationActionType>(const QString &strRuntimeMenuApplicationActionType)
-{
-    /* Here we have some fancy stuff allowing us
-     * to search through the keys using 'case-insensitive' rule: */
-    QStringList keys;      QList<MenuApplicationActionType> values;
-    keys << "About";       values << MenuApplicationActionType_About;
-    keys << "Preferences"; values << MenuApplicationActionType_Preferences;
-    keys << "Close";       values << MenuApplicationActionType_Close;
-    keys << "All";         values << MenuApplicationActionType_All;
+/* UIExtraDataMetaDefs::MenuApplicationActionType <= QString: */
+template<> UIExtraDataMetaDefs::MenuApplicationActionType fromInternalString<UIExtraDataMetaDefs::MenuApplicationActionType>(const QString &strRuntimeMenuApplicationActionType)
+{
+    /* Here we have some fancy stuff allowing us
+     * to search through the keys using 'case-insensitive' rule: */
+    QStringList keys;      QList<UIExtraDataMetaDefs::MenuApplicationActionType> values;
+    keys << "About";       values << UIExtraDataMetaDefs::MenuApplicationActionType_About;
+    keys << "Preferences"; values << UIExtraDataMetaDefs::MenuApplicationActionType_Preferences;
+    keys << "Close";       values << UIExtraDataMetaDefs::MenuApplicationActionType_Close;
+    keys << "All";         values << UIExtraDataMetaDefs::MenuApplicationActionType_All;
     /* Invalid type for unknown words: */
     if (!keys.contains(strRuntimeMenuApplicationActionType, Qt::CaseInsensitive))
-        return MenuApplicationActionType_Invalid;
+        return UIExtraDataMetaDefs::MenuApplicationActionType_Invalid;
     /* Corresponding type for known words: */
     return values.at(keys.indexOf(QRegExp(strRuntimeMenuApplicationActionType, Qt::CaseInsensitive)));
@@ -447 +447 @@
 #endif /* Q_WS_MAC */
 
-/* QString <= RuntimeMenuType: */
-template<> QString toInternalString(const RuntimeMenuType &runtimeMenuType)
+/* QString <= UIExtraDataMetaDefs::RuntimeMenuType: */
+template<> QString toInternalString(const UIExtraDataMetaDefs::RuntimeMenuType &runtimeMenuType)
 {
     QString strResult;
     switch (runtimeMenuType)
     {
-        case RuntimeMenuType_Machine: strResult = "Machine"; break;
-        case RuntimeMenuType_View:    strResult = "View"; break;
-        case RuntimeMenuType_Devices: strResult = "Devices"; break;
+        case UIExtraDataMetaDefs::RuntimeMenuType_Machine: strResult = "Machine"; break;
+        case UIExtraDataMetaDefs::RuntimeMenuType_View:    strResult = "View"; break;
+        case UIExtraDataMetaDefs::RuntimeMenuType_Devices: strResult = "Devices"; break;
 #ifdef VBOX_WITH_DEBUGGER_GUI
-        case RuntimeMenuType_Debug:   strResult = "Debug"; break;
+        case UIExtraDataMetaDefs::RuntimeMenuType_Debug:   strResult = "Debug"; break;
 #endif /* VBOX_WITH_DEBUGGER_GUI */
-        case RuntimeMenuType_Help:    strResult = "Help"; break;
-        case RuntimeMenuType_All:     strResult = "All"; break;
+        case UIExtraDataMetaDefs::RuntimeMenuType_Help:    strResult = "Help"; break;
+        case UIExtraDataMetaDefs::RuntimeMenuType_All:     strResult = "All"; break;
         default:
         {
@@ -470 +470 @@
 }
 
-/* RuntimeMenuType <= QString: */
-template<> RuntimeMenuType fromInternalString<RuntimeMenuType>(const QString &strRuntimeMenuType)
-{
-    /* Here we have some fancy stuff allowing us
-     * to search through the keys using 'case-insensitive' rule: */
-    QStringList keys;  QList<RuntimeMenuType> values;
-    keys << "Machine"; values << RuntimeMenuType_Machine;
-    keys << "View";    values << RuntimeMenuType_View;
-    keys << "Devices"; values << RuntimeMenuType_Devices;
+/* UIExtraDataMetaDefs::RuntimeMenuType <= QString: */
+template<> UIExtraDataMetaDefs::RuntimeMenuType fromInternalString<UIExtraDataMetaDefs::RuntimeMenuType>(const QString &strRuntimeMenuType)
+{
+    /* Here we have some fancy stuff allowing us
+     * to search through the keys using 'case-insensitive' rule: */
+    QStringList keys;  QList<UIExtraDataMetaDefs::RuntimeMenuType> values;
+    keys << "Machine"; values << UIExtraDataMetaDefs::RuntimeMenuType_Machine;
+    keys << "View";    values << UIExtraDataMetaDefs::RuntimeMenuType_View;
+    keys << "Devices"; values << UIExtraDataMetaDefs::RuntimeMenuType_Devices;
 #ifdef VBOX_WITH_DEBUGGER_GUI
-    keys << "Debug";   values << RuntimeMenuType_Debug;
+    keys << "Debug";   values << UIExtraDataMetaDefs::RuntimeMenuType_Debug;
 #endif /* VBOX_WITH_DEBUGGER_GUI */
-    keys << "Help";    values << RuntimeMenuType_Help;
-    keys << "All";     values << RuntimeMenuType_All;
+    keys << "Help";    values << UIExtraDataMetaDefs::RuntimeMenuType_Help;
+    keys << "All";     values << UIExtraDataMetaDefs::RuntimeMenuType_All;
     /* Invalid type for unknown words: */
     if (!keys.contains(strRuntimeMenuType, Qt::CaseInsensitive))
-        return RuntimeMenuType_Invalid;
+        return UIExtraDataMetaDefs::RuntimeMenuType_Invalid;
     /* Corresponding type for known words: */
     return values.at(keys.indexOf(QRegExp(strRuntimeMenuType, Qt::CaseInsensitive)));
 }
 
-/* QString <= RuntimeMenuMachineActionType: */
-template<> QString toInternalString(const RuntimeMenuMachineActionType &runtimeMenuMachineActionType)
+/* QString <= UIExtraDataMetaDefs::RuntimeMenuMachineActionType: */
+template<> QString toInternalString(const UIExtraDataMetaDefs::RuntimeMenuMachineActionType &runtimeMenuMachineActionType)
 {
     QString strResult;
     switch (runtimeMenuMachineActionType)
     {
-        case RuntimeMenuMachineActionType_SettingsDialog:    strResult = "SettingsDialog"; break;
-        case RuntimeMenuMachineActionType_TakeSnapshot:      strResult = "TakeSnapshot"; break;
-        case RuntimeMenuMachineActionType_TakeScreenshot:    strResult = "TakeScreenshot"; break;
-        case RuntimeMenuMachineActionType_InformationDialog: strResult = "InformationDialog"; break;
-        case RuntimeMenuMachineActionType_Keyboard:          strResult = "Keyboard"; break;
-        case RuntimeMenuMachineActionType_KeyboardSettings:  strResult = "KeyboardSettings"; break;
-        case RuntimeMenuMachineActionType_Mouse:             strResult = "Mouse"; break;
-        case RuntimeMenuMachineActionType_MouseIntegration:  strResult = "MouseIntegration"; break;
-        case RuntimeMenuMachineActionType_TypeCAD:           strResult = "TypeCAD"; break;
+        case UIExtraDataMetaDefs::RuntimeMenuMachineActionType_SettingsDialog:    strResult = "SettingsDialog"; break;
+        case UIExtraDataMetaDefs::RuntimeMenuMachineActionType_TakeSnapshot:      strResult = "TakeSnapshot"; break;
+        case UIExtraDataMetaDefs::RuntimeMenuMachineActionType_TakeScreenshot:    strResult = "TakeScreenshot"; break;
+        case UIExtraDataMetaDefs::RuntimeMenuMachineActionType_InformationDialog: strResult = "InformationDialog"; break;
+        case UIExtraDataMetaDefs::RuntimeMenuMachineActionType_Keyboard:          strResult = "Keyboard"; break;
+        case UIExtraDataMetaDefs::RuntimeMenuMachineActionType_KeyboardSettings:  strResult = "KeyboardSettings"; break;
+        case UIExtraDataMetaDefs::RuntimeMenuMachineActionType_Mouse:             strResult = "Mouse"; break;
+        case UIExtraDataMetaDefs::RuntimeMenuMachineActionType_MouseIntegration:  strResult = "MouseIntegration"; break;
+        case UIExtraDataMetaDefs::RuntimeMenuMachineActionType_TypeCAD:           strResult = "TypeCAD"; break;
 #ifdef Q_WS_X11
-        case RuntimeMenuMachineActionType_TypeCABS:          strResult = "TypeCABS"; break;
+        case UIExtraDataMetaDefs::RuntimeMenuMachineActionType_TypeCABS:          strResult = "TypeCABS"; break;
 #endif /* Q_WS_X11 */
-        case RuntimeMenuMachineActionType_Pause:             strResult = "Pause"; break;
-        case RuntimeMenuMachineActionType_Reset:             strResult = "Reset"; break;
-        case RuntimeMenuMachineActionType_SaveState:         strResult = "SaveState"; break;
-        case RuntimeMenuMachineActionType_Shutdown:          strResult = "Shutdown"; break;
-        case RuntimeMenuMachineActionType_PowerOff:          strResult = "PowerOff"; break;
+        case UIExtraDataMetaDefs::RuntimeMenuMachineActionType_Pause:             strResult = "Pause"; break;
+        case UIExtraDataMetaDefs::RuntimeMenuMachineActionType_Reset:             strResult = "Reset"; break;
+        case UIExtraDataMetaDefs::RuntimeMenuMachineActionType_SaveState:         strResult = "SaveState"; break;
+        case UIExtraDataMetaDefs::RuntimeMenuMachineActionType_Shutdown:          strResult = "Shutdown"; break;
+        case UIExtraDataMetaDefs::RuntimeMenuMachineActionType_PowerOff:          strResult = "PowerOff"; break;
 #ifndef Q_WS_MAC
-        case RuntimeMenuMachineActionType_Close:             strResult = "Close"; break;
+        case UIExtraDataMetaDefs::RuntimeMenuMachineActionType_Close:             strResult = "Close"; break;
 #endif /* !Q_WS_MAC */
-        case RuntimeMenuMachineActionType_All:               strResult = "All"; break;
+        case UIExtraDataMetaDefs::RuntimeMenuMachineActionType_All:               strResult = "All"; break;
         default:
         {
@@ -527 +527 @@
 }
 
-/* RuntimeMenuMachineActionType <= QString: */
-template<> RuntimeMenuMachineActionType fromInternalString<RuntimeMenuMachineActionType>(const QString &strRuntimeMenuMachineActionType)
-{
-    /* Here we have some fancy stuff allowing us
-     * to search through the keys using 'case-insensitive' rule: */
-    QStringList keys;            QList<RuntimeMenuMachineActionType> values;
-    keys << "SettingsDialog";    values << RuntimeMenuMachineActionType_SettingsDialog;
-    keys << "TakeSnapshot";      values << RuntimeMenuMachineActionType_TakeSnapshot;
-    keys << "TakeScreenshot";    values << RuntimeMenuMachineActionType_TakeScreenshot;
-    keys << "InformationDialog"; values << RuntimeMenuMachineActionType_InformationDialog;
-    keys << "Keyboard";          values << RuntimeMenuMachineActionType_Keyboard;
-    keys << "KeyboardSettings";  values << RuntimeMenuMachineActionType_KeyboardSettings;
-    keys << "Mouse";             values << RuntimeMenuMachineActionType_Mouse;
-    keys << "MouseIntegration";  values << RuntimeMenuMachineActionType_MouseIntegration;
-    keys << "TypeCAD";           values << RuntimeMenuMachineActionType_TypeCAD;
+/* UIExtraDataMetaDefs::RuntimeMenuMachineActionType <= QString: */
+template<> UIExtraDataMetaDefs::RuntimeMenuMachineActionType fromInternalString<UIExtraDataMetaDefs::RuntimeMenuMachineActionType>(const QString &strRuntimeMenuMachineActionType)
+{
+    /* Here we have some fancy stuff allowing us
+     * to search through the keys using 'case-insensitive' rule: */
+    QStringList keys;            QList<UIExtraDataMetaDefs::RuntimeMenuMachineActionType> values;
+    keys << "SettingsDialog";    values << UIExtraDataMetaDefs::RuntimeMenuMachineActionType_SettingsDialog;
+    keys << "TakeSnapshot";      values << UIExtraDataMetaDefs::RuntimeMenuMachineActionType_TakeSnapshot;
+    keys << "TakeScreenshot";    values << UIExtraDataMetaDefs::RuntimeMenuMachineActionType_TakeScreenshot;
+    keys << "InformationDialog"; values << UIExtraDataMetaDefs::RuntimeMenuMachineActionType_InformationDialog;
+    keys << "Keyboard";          values << UIExtraDataMetaDefs::RuntimeMenuMachineActionType_Keyboard;
+    keys << "KeyboardSettings";  values << UIExtraDataMetaDefs::RuntimeMenuMachineActionType_KeyboardSettings;
+    keys << "Mouse";             values << UIExtraDataMetaDefs::RuntimeMenuMachineActionType_Mouse;
+    keys << "MouseIntegration";  values << UIExtraDataMetaDefs::RuntimeMenuMachineActionType_MouseIntegration;
+    keys << "TypeCAD";           values << UIExtraDataMetaDefs::RuntimeMenuMachineActionType_TypeCAD;
 #ifdef Q_WS_X11
-    keys << "TypeCABS";          values << RuntimeMenuMachineActionType_TypeCABS;
+    keys << "TypeCABS";          values << UIExtraDataMetaDefs::RuntimeMenuMachineActionType_TypeCABS;
 #endif /* Q_WS_X11 */
-    keys << "Pause";             values << RuntimeMenuMachineActionType_Pause;
-    keys << "Reset";             values << RuntimeMenuMachineActionType_Reset;
-    keys << "SaveState";         values << RuntimeMenuMachineActionType_SaveState;
-    keys << "Shutdown";          values << RuntimeMenuMachineActionType_Shutdown;
-    keys << "PowerOff";          values << RuntimeMenuMachineActionType_PowerOff;
+    keys << "Pause";             values << UIExtraDataMetaDefs::RuntimeMenuMachineActionType_Pause;
+    keys << "Reset";             values << UIExtraDataMetaDefs::RuntimeMenuMachineActionType_Reset;
+    keys << "SaveState";         values << UIExtraDataMetaDefs::RuntimeMenuMachineActionType_SaveState;
+    keys << "Shutdown";          values << UIExtraDataMetaDefs::RuntimeMenuMachineActionType_Shutdown;
+    keys << "PowerOff";          values << UIExtraDataMetaDefs::RuntimeMenuMachineActionType_PowerOff;
 #ifndef Q_WS_MAC
-    keys << "Close";             values << RuntimeMenuMachineActionType_Close;
+    keys << "Close";             values << UIExtraDataMetaDefs::RuntimeMenuMachineActionType_Close;
 #endif /* !Q_WS_MAC */
-    keys << "All";               values << RuntimeMenuMachineActionType_All;
+    keys << "All";               values << UIExtraDataMetaDefs::RuntimeMenuMachineActionType_All;
     /* Invalid type for unknown words: */
     if (!keys.contains(strRuntimeMenuMachineActionType, Qt::CaseInsensitive))
-        return RuntimeMenuMachineActionType_Invalid;
+        return UIExtraDataMetaDefs::RuntimeMenuMachineActionType_Invalid;
     /* Corresponding type for known words: */
     return values.at(keys.indexOf(QRegExp(strRuntimeMenuMachineActionType, Qt::CaseInsensitive)));
 }
 
-/* QString <= RuntimeMenuViewActionType: */
-template<> QString toInternalString(const RuntimeMenuViewActionType &runtimeMenuViewActionType)
+/* QString <= UIExtraDataMetaDefs::RuntimeMenuViewActionType: */
+template<> QString toInternalString(const UIExtraDataMetaDefs::RuntimeMenuViewActionType &runtimeMenuViewActionType)
 {
     QString strResult;
     switch (runtimeMenuViewActionType)
     {
-        case RuntimeMenuViewActionType_Fullscreen:        strResult = "Fullscreen"; break;
-        case RuntimeMenuViewActionType_Seamless:          strResult = "Seamless"; break;
-        case RuntimeMenuViewActionType_Scale:             strResult = "Scale"; break;
-        case RuntimeMenuViewActionType_GuestAutoresize:   strResult = "GuestAutoresize"; break;
-        case RuntimeMenuViewActionType_AdjustWindow:      strResult = "AdjustWindow"; break;
-        case RuntimeMenuViewActionType_StatusBar:         strResult = "StatusBar"; break;
-        case RuntimeMenuViewActionType_StatusBarSettings: strResult = "StatusBarSettings"; break;
-        case RuntimeMenuViewActionType_ToggleStatusBar:   strResult = "ToggleStatusBar"; break;
-        case RuntimeMenuViewActionType_Resize:            strResult = "Resize"; break;
-        case RuntimeMenuViewActionType_Multiscreen:       strResult = "Multiscreen"; break;
-        case RuntimeMenuViewActionType_All:               strResult = "All"; break;
+        case UIExtraDataMetaDefs::RuntimeMenuViewActionType_Fullscreen:        strResult = "Fullscreen"; break;
+        case UIExtraDataMetaDefs::RuntimeMenuViewActionType_Seamless:          strResult = "Seamless"; break;
+        case UIExtraDataMetaDefs::RuntimeMenuViewActionType_Scale:             strResult = "Scale"; break;
+        case UIExtraDataMetaDefs::RuntimeMenuViewActionType_GuestAutoresize:   strResult = "GuestAutoresize"; break;
+        case UIExtraDataMetaDefs::RuntimeMenuViewActionType_AdjustWindow:      strResult = "AdjustWindow"; break;
+        case UIExtraDataMetaDefs::RuntimeMenuViewActionType_StatusBar:         strResult = "StatusBar"; break;
+        case UIExtraDataMetaDefs::RuntimeMenuViewActionType_StatusBarSettings: strResult = "StatusBarSettings"; break;
+        case UIExtraDataMetaDefs::RuntimeMenuViewActionType_ToggleStatusBar:   strResult = "ToggleStatusBar"; break;
+        case UIExtraDataMetaDefs::RuntimeMenuViewActionType_Resize:            strResult = "Resize"; break;
+        case UIExtraDataMetaDefs::RuntimeMenuViewActionType_Multiscreen:       strResult = "Multiscreen"; break;
+        case UIExtraDataMetaDefs::RuntimeMenuViewActionType_All:               strResult = "All"; break;
         default:
         {
@@ -587 +587 @@
 }
 
-/* RuntimeMenuViewActionType <= QString: */
-template<> RuntimeMenuViewActionType fromInternalString<RuntimeMenuViewActionType>(const QString &strRuntimeMenuViewActionType)
-{
-    /* Here we have some fancy stuff allowing us
-     * to search through the keys using 'case-insensitive' rule: */
-    QStringList keys;            QList<RuntimeMenuViewActionType> values;
-    keys << "Fullscreen";        values << RuntimeMenuViewActionType_Fullscreen;
-    keys << "Seamless";          values << RuntimeMenuViewActionType_Seamless;
-    keys << "Scale";             values << RuntimeMenuViewActionType_Scale;
-    keys << "GuestAutoresize";   values << RuntimeMenuViewActionType_GuestAutoresize;
-    keys << "AdjustWindow";      values << RuntimeMenuViewActionType_AdjustWindow;
-    keys << "StatusBar";         values << RuntimeMenuViewActionType_StatusBar;
-    keys << "StatusBarSettings"; values << RuntimeMenuViewActionType_StatusBarSettings;
-    keys << "ToggleStatusBar";   values << RuntimeMenuViewActionType_ToggleStatusBar;
-    keys << "Resize";            values << RuntimeMenuViewActionType_Resize;
-    keys << "Multiscreen";       values << RuntimeMenuViewActionType_Multiscreen;
-    keys << "All";               values << RuntimeMenuViewActionType_All;
+/* UIExtraDataMetaDefs::RuntimeMenuViewActionType <= QString: */
+template<> UIExtraDataMetaDefs::RuntimeMenuViewActionType fromInternalString<UIExtraDataMetaDefs::RuntimeMenuViewActionType>(const QString &strRuntimeMenuViewActionType)
+{
+    /* Here we have some fancy stuff allowing us
+     * to search through the keys using 'case-insensitive' rule: */
+    QStringList keys;            QList<UIExtraDataMetaDefs::RuntimeMenuViewActionType> values;
+    keys << "Fullscreen";        values << UIExtraDataMetaDefs::RuntimeMenuViewActionType_Fullscreen;
+    keys << "Seamless";          values << UIExtraDataMetaDefs::RuntimeMenuViewActionType_Seamless;
+    keys << "Scale";             values << UIExtraDataMetaDefs::RuntimeMenuViewActionType_Scale;
+    keys << "GuestAutoresize";   values << UIExtraDataMetaDefs::RuntimeMenuViewActionType_GuestAutoresize;
+    keys << "AdjustWindow";      values << UIExtraDataMetaDefs::RuntimeMenuViewActionType_AdjustWindow;
+    keys << "StatusBar";         values << UIExtraDataMetaDefs::RuntimeMenuViewActionType_StatusBar;
+    keys << "StatusBarSettings"; values << UIExtraDataMetaDefs::RuntimeMenuViewActionType_StatusBarSettings;
+    keys << "ToggleStatusBar";   values << UIExtraDataMetaDefs::RuntimeMenuViewActionType_ToggleStatusBar;
+    keys << "Resize";            values << UIExtraDataMetaDefs::RuntimeMenuViewActionType_Resize;
+    keys << "Multiscreen";       values << UIExtraDataMetaDefs::RuntimeMenuViewActionType_Multiscreen;
+    keys << "All";               values << UIExtraDataMetaDefs::RuntimeMenuViewActionType_All;
     /* Invalid type for unknown words: */
     if (!keys.contains(strRuntimeMenuViewActionType, Qt::CaseInsensitive))
-        return RuntimeMenuViewActionType_Invalid;
+        return UIExtraDataMetaDefs::RuntimeMenuViewActionType_Invalid;
     /* Corresponding type for known words: */
     return values.at(keys.indexOf(QRegExp(strRuntimeMenuViewActionType, Qt::CaseInsensitive)));
 }
 
-/* QString <= RuntimeMenuDevicesActionType: */
-template<> QString toInternalString(const RuntimeMenuDevicesActionType &runtimeMenuDevicesActionType)
+/* QString <= UIExtraDataMetaDefs::RuntimeMenuDevicesActionType: */
+template<> QString toInternalString(const UIExtraDataMetaDefs::RuntimeMenuDevicesActionType &runtimeMenuDevicesActionType)
 {
     QString strResult;
     switch (runtimeMenuDevicesActionType)
     {
-        case RuntimeMenuDevicesActionType_HardDrives:            strResult = "HardDrives"; break;
-        case RuntimeMenuDevicesActionType_HardDrivesSettings:    strResult = "HardDrivesSettings"; break;
-        case RuntimeMenuDevicesActionType_OpticalDevices:        strResult = "OpticalDevices"; break;
-        case RuntimeMenuDevicesActionType_FloppyDevices:         strResult = "FloppyDevices"; break;
-        case RuntimeMenuDevicesActionType_Network:               strResult = "Network"; break;
-        case RuntimeMenuDevicesActionType_NetworkSettings:       strResult = "NetworkSettings"; break;
-        case RuntimeMenuDevicesActionType_USBDevices:            strResult = "USBDevices"; break;
-        case RuntimeMenuDevicesActionType_USBDevicesSettings:    strResult = "USBDevicesSettings"; break;
-        case RuntimeMenuDevicesActionType_WebCams:               strResult = "WebCams"; break;
-        case RuntimeMenuDevicesActionType_SharedClipboard:       strResult = "SharedClipboard"; break;
-        case RuntimeMenuDevicesActionType_DragAndDrop:           strResult = "DragAndDrop"; break;
-        case RuntimeMenuDevicesActionType_SharedFolders:         strResult = "SharedFolders"; break;
-        case RuntimeMenuDevicesActionType_SharedFoldersSettings: strResult = "SharedFoldersSettings"; break;
-        case RuntimeMenuDevicesActionType_VRDEServer:            strResult = "VRDEServer"; break;
-        case RuntimeMenuDevicesActionType_VideoCapture:          strResult = "VideoCapture"; break;
-        case RuntimeMenuDevicesActionType_VideoCaptureSettings:  strResult = "VideoCaptureSettings"; break;
-        case RuntimeMenuDevicesActionType_StartVideoCapture:     strResult = "StartVideoCapture"; break;
-        case RuntimeMenuDevicesActionType_InstallGuestTools:     strResult = "InstallGuestTools"; break;
-        case RuntimeMenuDevicesActionType_All:                   strResult = "All"; break;
+        case UIExtraDataMetaDefs::RuntimeMenuDevicesActionType_HardDrives:            strResult = "HardDrives"; break;
+        case UIExtraDataMetaDefs::RuntimeMenuDevicesActionType_HardDrivesSettings:    strResult = "HardDrivesSettings"; break;
+        case UIExtraDataMetaDefs::RuntimeMenuDevicesActionType_OpticalDevices:        strResult = "OpticalDevices"; break;
+        case UIExtraDataMetaDefs::RuntimeMenuDevicesActionType_FloppyDevices:         strResult = "FloppyDevices"; break;
+        case UIExtraDataMetaDefs::RuntimeMenuDevicesActionType_Network:               strResult = "Network"; break;
+        case UIExtraDataMetaDefs::RuntimeMenuDevicesActionType_NetworkSettings:       strResult = "NetworkSettings"; break;
+        case UIExtraDataMetaDefs::RuntimeMenuDevicesActionType_USBDevices:            strResult = "USBDevices"; break;
+        case UIExtraDataMetaDefs::RuntimeMenuDevicesActionType_USBDevicesSettings:    strResult = "USBDevicesSettings"; break;
+        case UIExtraDataMetaDefs::RuntimeMenuDevicesActionType_WebCams:               strResult = "WebCams"; break;
+        case UIExtraDataMetaDefs::RuntimeMenuDevicesActionType_SharedClipboard:       strResult = "SharedClipboard"; break;
+        case UIExtraDataMetaDefs::RuntimeMenuDevicesActionType_DragAndDrop:           strResult = "DragAndDrop"; break;
+        case UIExtraDataMetaDefs::RuntimeMenuDevicesActionType_SharedFolders:         strResult = "SharedFolders"; break;
+        case UIExtraDataMetaDefs::RuntimeMenuDevicesActionType_SharedFoldersSettings: strResult = "SharedFoldersSettings"; break;
+        case UIExtraDataMetaDefs::RuntimeMenuDevicesActionType_VRDEServer:            strResult = "VRDEServer"; break;
+        case UIExtraDataMetaDefs::RuntimeMenuDevicesActionType_VideoCapture:          strResult = "VideoCapture"; break;
+        case UIExtraDataMetaDefs::RuntimeMenuDevicesActionType_VideoCaptureSettings:  strResult = "VideoCaptureSettings"; break;
+        case UIExtraDataMetaDefs::RuntimeMenuDevicesActionType_StartVideoCapture:     strResult = "StartVideoCapture"; break;
+        case UIExtraDataMetaDefs::RuntimeMenuDevicesActionType_InstallGuestTools:     strResult = "InstallGuestTools"; break;
+        case UIExtraDataMetaDefs::RuntimeMenuDevicesActionType_All:                   strResult = "All"; break;
         default:
         {
@@ -645 +645 @@
 }
 
-/* RuntimeMenuDevicesActionType <= QString: */
-template<> RuntimeMenuDevicesActionType fromInternalString<RuntimeMenuDevicesActionType>(const QString &strRuntimeMenuDevicesActionType)
-{
-    /* Here we have some fancy stuff allowing us
-     * to search through the keys using 'case-insensitive' rule: */
-    QStringList keys;                QList<RuntimeMenuDevicesActionType> values;
-    keys << "HardDrives";            values << RuntimeMenuDevicesActionType_HardDrives;
-    keys << "HardDrivesSettings";    values << RuntimeMenuDevicesActionType_HardDrivesSettings;
-    keys << "OpticalDevices";        values << RuntimeMenuDevicesActionType_OpticalDevices;
-    keys << "FloppyDevices";         values << RuntimeMenuDevicesActionType_FloppyDevices;
-    keys << "Network";               values << RuntimeMenuDevicesActionType_Network;
-    keys << "NetworkSettings";       values << RuntimeMenuDevicesActionType_NetworkSettings;
-    keys << "USBDevices";            values << RuntimeMenuDevicesActionType_USBDevices;
-    keys << "USBDevicesSettings";    values << RuntimeMenuDevicesActionType_USBDevicesSettings;
-    keys << "WebCams";               values << RuntimeMenuDevicesActionType_WebCams;
-    keys << "SharedClipboard";       values << RuntimeMenuDevicesActionType_SharedClipboard;
-    keys << "DragAndDrop";           values << RuntimeMenuDevicesActionType_DragAndDrop;
-    keys << "SharedFolders";         values << RuntimeMenuDevicesActionType_SharedFolders;
-    keys << "SharedFoldersSettings"; values << RuntimeMenuDevicesActionType_SharedFoldersSettings;
-    keys << "VRDEServer";            values << RuntimeMenuDevicesActionType_VRDEServer;
-    keys << "VideoCapture";          values << RuntimeMenuDevicesActionType_VideoCapture;
-    keys << "VideoCaptureSettings";  values << RuntimeMenuDevicesActionType_VideoCaptureSettings;
-    keys << "StartVideoCapture";     values << RuntimeMenuDevicesActionType_StartVideoCapture;
-    keys << "InstallGuestTools";     values << RuntimeMenuDevicesActionType_InstallGuestTools;
-    keys << "All";                   values << RuntimeMenuDevicesActionType_All;
+/* UIExtraDataMetaDefs::RuntimeMenuDevicesActionType <= QString: */
+template<> UIExtraDataMetaDefs::RuntimeMenuDevicesActionType fromInternalString<UIExtraDataMetaDefs::RuntimeMenuDevicesActionType>(const QString &strRuntimeMenuDevicesActionType)
+{
+    /* Here we have some fancy stuff allowing us
+     * to search through the keys using 'case-insensitive' rule: */
+    QStringList keys;                QList<UIExtraDataMetaDefs::RuntimeMenuDevicesActionType> values;
+    keys << "HardDrives";            values << UIExtraDataMetaDefs::RuntimeMenuDevicesActionType_HardDrives;
+    keys << "HardDrivesSettings";    values << UIExtraDataMetaDefs::RuntimeMenuDevicesActionType_HardDrivesSettings;
+    keys << "OpticalDevices";        values << UIExtraDataMetaDefs::RuntimeMenuDevicesActionType_OpticalDevices;
+    keys << "FloppyDevices";         values << UIExtraDataMetaDefs::RuntimeMenuDevicesActionType_FloppyDevices;
+    keys << "Network";               values << UIExtraDataMetaDefs::RuntimeMenuDevicesActionType_Network;
+    keys << "NetworkSettings";       values << UIExtraDataMetaDefs::RuntimeMenuDevicesActionType_NetworkSettings;
+    keys << "USBDevices";            values << UIExtraDataMetaDefs::RuntimeMenuDevicesActionType_USBDevices;
+    keys << "USBDevicesSettings";    values << UIExtraDataMetaDefs::RuntimeMenuDevicesActionType_USBDevicesSettings;
+    keys << "WebCams";               values << UIExtraDataMetaDefs::RuntimeMenuDevicesActionType_WebCams;
+    keys << "SharedClipboard";       values << UIExtraDataMetaDefs::RuntimeMenuDevicesActionType_SharedClipboard;
+    keys << "DragAndDrop";           values << UIExtraDataMetaDefs::RuntimeMenuDevicesActionType_DragAndDrop;
+    keys << "SharedFolders";         values << UIExtraDataMetaDefs::RuntimeMenuDevicesActionType_SharedFolders;
+    keys << "SharedFoldersSettings"; values << UIExtraDataMetaDefs::RuntimeMenuDevicesActionType_SharedFoldersSettings;
+    keys << "VRDEServer";            values << UIExtraDataMetaDefs::RuntimeMenuDevicesActionType_VRDEServer;
+    keys << "VideoCapture";          values << UIExtraDataMetaDefs::RuntimeMenuDevicesActionType_VideoCapture;
+    keys << "VideoCaptureSettings";  values << UIExtraDataMetaDefs::RuntimeMenuDevicesActionType_VideoCaptureSettings;
+    keys << "StartVideoCapture";     values << UIExtraDataMetaDefs::RuntimeMenuDevicesActionType_StartVideoCapture;
+    keys << "InstallGuestTools";     values << UIExtraDataMetaDefs::RuntimeMenuDevicesActionType_InstallGuestTools;
+    keys << "All";                   values << UIExtraDataMetaDefs::RuntimeMenuDevicesActionType_All;
     /* Invalid type for unknown words: */
     if (!keys.contains(strRuntimeMenuDevicesActionType, Qt::CaseInsensitive))
-        return RuntimeMenuDevicesActionType_Invalid;
+        return UIExtraDataMetaDefs::RuntimeMenuDevicesActionType_Invalid;
     /* Corresponding type for known words: */
     return values.at(keys.indexOf(QRegExp(strRuntimeMenuDevicesActionType, Qt::CaseInsensitive)));
@@ -678 +678 @@
 
 #ifdef VBOX_WITH_DEBUGGER_GUI
-/* QString <= RuntimeMenuDebuggerActionType: */
-template<> QString toInternalString(const RuntimeMenuDebuggerActionType &runtimeMenuDebuggerActionType)
+/* QString <= UIExtraDataMetaDefs::RuntimeMenuDebuggerActionType: */
+template<> QString toInternalString(const UIExtraDataMetaDefs::RuntimeMenuDebuggerActionType &runtimeMenuDebuggerActionType)
 {
     QString strResult;
     switch (runtimeMenuDebuggerActionType)
     {
-        case RuntimeMenuDebuggerActionType_Statistics:  strResult = "Statistics"; break;
-        case RuntimeMenuDebuggerActionType_CommandLine: strResult = "CommandLine"; break;
-        case RuntimeMenuDebuggerActionType_Logging:     strResult = "Logging"; break;
-        case RuntimeMenuDebuggerActionType_LogDialog:   strResult = "LogDialog"; break;
-        case RuntimeMenuDebuggerActionType_All:         strResult = "All"; break;
+        case UIExtraDataMetaDefs::RuntimeMenuDebuggerActionType_Statistics:  strResult = "Statistics"; break;
+        case UIExtraDataMetaDefs::RuntimeMenuDebuggerActionType_CommandLine: strResult = "CommandLine"; break;
+        case UIExtraDataMetaDefs::RuntimeMenuDebuggerActionType_Logging:     strResult = "Logging"; break;
+        case UIExtraDataMetaDefs::RuntimeMenuDebuggerActionType_LogDialog:   strResult = "LogDialog"; break;
+        case UIExtraDataMetaDefs::RuntimeMenuDebuggerActionType_All:         strResult = "All"; break;
         default:
         {
@@ -698 +698 @@
 }
 
-/* RuntimeMenuDebuggerActionType <= QString: */
-template<> RuntimeMenuDebuggerActionType fromInternalString<RuntimeMenuDebuggerActionType>(const QString &strRuntimeMenuDebuggerActionType)
-{
-    /* Here we have some fancy stuff allowing us
-     * to search through the keys using 'case-insensitive' rule: */
-    QStringList keys;      QList<RuntimeMenuDebuggerActionType> values;
-    keys << "Statistics";  values << RuntimeMenuDebuggerActionType_Statistics;
-    keys << "CommandLine"; values << RuntimeMenuDebuggerActionType_CommandLine;
-    keys << "Logging";     values << RuntimeMenuDebuggerActionType_Logging;
-    keys << "LogDialog";   values << RuntimeMenuDebuggerActionType_LogDialog;
-    keys << "All";         values << RuntimeMenuDebuggerActionType_All;
+/* UIExtraDataMetaDefs::RuntimeMenuDebuggerActionType <= QString: */
+template<> UIExtraDataMetaDefs::RuntimeMenuDebuggerActionType fromInternalString<UIExtraDataMetaDefs::RuntimeMenuDebuggerActionType>(const QString &strRuntimeMenuDebuggerActionType)
+{
+    /* Here we have some fancy stuff allowing us
+     * to search through the keys using 'case-insensitive' rule: */
+    QStringList keys;      QList<UIExtraDataMetaDefs::RuntimeMenuDebuggerActionType> values;
+    keys << "Statistics";  values << UIExtraDataMetaDefs::RuntimeMenuDebuggerActionType_Statistics;
+    keys << "CommandLine"; values << UIExtraDataMetaDefs::RuntimeMenuDebuggerActionType_CommandLine;
+    keys << "Logging";     values << UIExtraDataMetaDefs::RuntimeMenuDebuggerActionType_Logging;
+    keys << "LogDialog";   values << UIExtraDataMetaDefs::RuntimeMenuDebuggerActionType_LogDialog;
+    keys << "All";         values << UIExtraDataMetaDefs::RuntimeMenuDebuggerActionType_All;
     /* Invalid type for unknown words: */
     if (!keys.contains(strRuntimeMenuDebuggerActionType, Qt::CaseInsensitive))
-        return RuntimeMenuDebuggerActionType_Invalid;
+        return UIExtraDataMetaDefs::RuntimeMenuDebuggerActionType_Invalid;
     /* Corresponding type for known words: */
     return values.at(keys.indexOf(QRegExp(strRuntimeMenuDebuggerActionType, Qt::CaseInsensitive)));

trunk/src/VBox/Frontends/VirtualBox/src/extradata/UIExtraDataDefs.h

@@ -264 +264 @@
 }
 
+/** Extra-data meta definitions. */
+class UIExtraDataMetaDefs : public QObject
+{
+    Q_OBJECT;
+    Q_ENUMS(MenuHelpActionType);
+#ifdef Q_WS_MAC
+    Q_ENUMS(MenuApplicationActionType);
+#endif /* Q_WS_MAC */
+    Q_ENUMS(RuntimeMenuType);
+    Q_ENUMS(RuntimeMenuMachineActionType);
+    Q_ENUMS(RuntimeMenuViewActionType);
+    Q_ENUMS(RuntimeMenuDevicesActionType);
+#ifdef VBOX_WITH_DEBUGGER_GUI
+    Q_ENUMS(RuntimeMenuDebuggerActionType);
+#endif /* VBOX_WITH_DEBUGGER_GUI */
+
+public:
+
+    /** Menu "Help": Action types. */
+    enum MenuHelpActionType
+    {
+        MenuHelpActionType_Invalid              = 0,
+        MenuHelpActionType_Contents             = RT_BIT(0),
+        MenuHelpActionType_WebSite              = RT_BIT(1),
+        MenuHelpActionType_ResetWarnings        = RT_BIT(2),
+#ifdef VBOX_GUI_WITH_NETWORK_MANAGER
+        MenuHelpActionType_NetworkAccessManager = RT_BIT(3),
+        MenuHelpActionType_CheckForUpdates      = RT_BIT(4),
+#endif /* VBOX_GUI_WITH_NETWORK_MANAGER */
+#ifndef Q_WS_MAC
+        MenuHelpActionType_About                = RT_BIT(5),
+        MenuHelpActionType_Preferences          = RT_BIT(6),
+#endif /* !Q_WS_MAC */
+        MenuHelpActionType_All                  = 0xFFFF
+    };
+
+#ifdef Q_WS_MAC
+    /** Menu "Application": Action types. */
+    enum MenuApplicationActionType
+    {
+        MenuApplicationActionType_Invalid     = 0,
+        MenuApplicationActionType_About       = RT_BIT(0),
+        MenuApplicationActionType_Preferences = RT_BIT(1),
+        MenuApplicationActionType_Close       = RT_BIT(2),
+        MenuApplicationActionType_All         = 0xFFFF
+    };
+#endif /* Q_WS_MAC */
+
+    /** Runtime UI: Menu types. */
+    enum RuntimeMenuType
+    {
+        RuntimeMenuType_Invalid = 0,
+        RuntimeMenuType_Machine = RT_BIT(0),
+        RuntimeMenuType_View    = RT_BIT(1),
+        RuntimeMenuType_Devices = RT_BIT(2),
+#ifdef VBOX_WITH_DEBUGGER_GUI
+        RuntimeMenuType_Debug   = RT_BIT(3),
+#endif /* VBOX_WITH_DEBUGGER_GUI */
+        RuntimeMenuType_Help    = RT_BIT(4),
+        RuntimeMenuType_All     = 0xFF
+    };
+
+    /** Runtime UI: Menu "Machine": Action types. */
+    enum RuntimeMenuMachineActionType
+    {
+        RuntimeMenuMachineActionType_Invalid           = 0,
+        RuntimeMenuMachineActionType_SettingsDialog    = RT_BIT(0),
+        RuntimeMenuMachineActionType_TakeSnapshot      = RT_BIT(1),
+        RuntimeMenuMachineActionType_TakeScreenshot    = RT_BIT(2),
+        RuntimeMenuMachineActionType_InformationDialog = RT_BIT(3),
+        RuntimeMenuMachineActionType_Keyboard          = RT_BIT(4),
+        RuntimeMenuMachineActionType_KeyboardSettings  = RT_BIT(5),
+        RuntimeMenuMachineActionType_Mouse             = RT_BIT(6),
+        RuntimeMenuMachineActionType_MouseIntegration  = RT_BIT(7),
+        RuntimeMenuMachineActionType_TypeCAD           = RT_BIT(8),
+#ifdef Q_WS_X11
+        RuntimeMenuMachineActionType_TypeCABS          = RT_BIT(9),
+#endif /* Q_WS_X11 */
+        RuntimeMenuMachineActionType_Pause             = RT_BIT(10),
+        RuntimeMenuMachineActionType_Reset             = RT_BIT(11),
+        RuntimeMenuMachineActionType_SaveState         = RT_BIT(12),
+        RuntimeMenuMachineActionType_Shutdown          = RT_BIT(13),
+        RuntimeMenuMachineActionType_PowerOff          = RT_BIT(14),
+#ifndef Q_WS_MAC
+        RuntimeMenuMachineActionType_Close             = RT_BIT(15),
+#endif /* !Q_WS_MAC */
+        RuntimeMenuMachineActionType_All               = 0xFFFF
+    };
+
+    /** Runtime UI: Menu "View": Action types. */
+    enum RuntimeMenuViewActionType
+    {
+        RuntimeMenuViewActionType_Invalid           = 0,
+        RuntimeMenuViewActionType_Fullscreen        = RT_BIT(0),
+        RuntimeMenuViewActionType_Seamless          = RT_BIT(1),
+        RuntimeMenuViewActionType_Scale             = RT_BIT(2),
+        RuntimeMenuViewActionType_GuestAutoresize   = RT_BIT(3),
+        RuntimeMenuViewActionType_AdjustWindow      = RT_BIT(4),
+        RuntimeMenuViewActionType_StatusBar         = RT_BIT(5),
+        RuntimeMenuViewActionType_StatusBarSettings = RT_BIT(6),
+        RuntimeMenuViewActionType_ToggleStatusBar   = RT_BIT(7),
+        RuntimeMenuViewActionType_Resize            = RT_BIT(8),
+        RuntimeMenuViewActionType_Multiscreen       = RT_BIT(9),
+        RuntimeMenuViewActionType_All               = 0xFFFF
+    };
+
+    /** Runtime UI: Menu "Devices": Action types. */
+    enum RuntimeMenuDevicesActionType
+    {
+        RuntimeMenuDevicesActionType_Invalid               = 0,
+        RuntimeMenuDevicesActionType_HardDrives            = RT_BIT(0),
+        RuntimeMenuDevicesActionType_HardDrivesSettings    = RT_BIT(1),
+        RuntimeMenuDevicesActionType_OpticalDevices        = RT_BIT(2),
+        RuntimeMenuDevicesActionType_FloppyDevices         = RT_BIT(3),
+        RuntimeMenuDevicesActionType_Network               = RT_BIT(4),
+        RuntimeMenuDevicesActionType_NetworkSettings       = RT_BIT(5),
+        RuntimeMenuDevicesActionType_USBDevices            = RT_BIT(6),
+        RuntimeMenuDevicesActionType_USBDevicesSettings    = RT_BIT(7),
+        RuntimeMenuDevicesActionType_WebCams               = RT_BIT(8),
+        RuntimeMenuDevicesActionType_SharedClipboard       = RT_BIT(9),
+        RuntimeMenuDevicesActionType_DragAndDrop           = RT_BIT(10),
+        RuntimeMenuDevicesActionType_SharedFolders         = RT_BIT(11),
+        RuntimeMenuDevicesActionType_SharedFoldersSettings = RT_BIT(12),
+        RuntimeMenuDevicesActionType_VRDEServer            = RT_BIT(13),
+        RuntimeMenuDevicesActionType_VideoCapture          = RT_BIT(14),
+        RuntimeMenuDevicesActionType_VideoCaptureSettings  = RT_BIT(15),
+        RuntimeMenuDevicesActionType_StartVideoCapture     = RT_BIT(16),
+        RuntimeMenuDevicesActionType_InstallGuestTools     = RT_BIT(17),
+        RuntimeMenuDevicesActionType_All                   = 0xFFFF
+    };
+
+#ifdef VBOX_WITH_DEBUGGER_GUI
+    /** Runtime UI: Menu "Debugger": Action types. */
+    enum RuntimeMenuDebuggerActionType
+    {
+        RuntimeMenuDebuggerActionType_Invalid     = 0,
+        RuntimeMenuDebuggerActionType_Statistics  = RT_BIT(0),
+        RuntimeMenuDebuggerActionType_CommandLine = RT_BIT(1),
+        RuntimeMenuDebuggerActionType_Logging     = RT_BIT(2),
+        RuntimeMenuDebuggerActionType_LogDialog   = RT_BIT(3),
+        RuntimeMenuDebuggerActionType_All         = 0xFFFF
+    };
+#endif /* VBOX_WITH_DEBUGGER_GUI */
+};
 
 /** Common UI: Global settings page types. */
@@ -360 +504 @@
 
 
-/** Menu "Help": Action types. */
-enum MenuHelpActionType
-{
-    MenuHelpActionType_Invalid              = 0,
-    MenuHelpActionType_Contents             = RT_BIT(0),
-    MenuHelpActionType_WebSite              = RT_BIT(1),
-    MenuHelpActionType_ResetWarnings        = RT_BIT(2),
-#ifdef VBOX_GUI_WITH_NETWORK_MANAGER
-    MenuHelpActionType_NetworkAccessManager = RT_BIT(3),
-    MenuHelpActionType_CheckForUpdates      = RT_BIT(4),
-#endif /* VBOX_GUI_WITH_NETWORK_MANAGER */
-#ifndef Q_WS_MAC
-    MenuHelpActionType_About                = RT_BIT(5),
-    MenuHelpActionType_Preferences          = RT_BIT(6),
-#endif /* !Q_WS_MAC */
-    MenuHelpActionType_All                  = 0xFFFF
-};
-
-#ifdef Q_WS_MAC
-/** Menu "Application": Action types. */
-enum MenuApplicationActionType
-{
-    MenuApplicationActionType_Invalid     = 0,
-    MenuApplicationActionType_About       = RT_BIT(0),
-    MenuApplicationActionType_Preferences = RT_BIT(1),
-    MenuApplicationActionType_Close       = RT_BIT(2),
-    MenuApplicationActionType_All         = 0xFFFF
-};
-#endif /* Q_WS_MAC */
-
-/** Runtime UI: Menu types. */
-enum RuntimeMenuType
-{
-    RuntimeMenuType_Invalid = 0,
-    RuntimeMenuType_Machine = RT_BIT(0),
-    RuntimeMenuType_View    = RT_BIT(1),
-    RuntimeMenuType_Devices = RT_BIT(2),
-#ifdef VBOX_WITH_DEBUGGER_GUI
-    RuntimeMenuType_Debug   = RT_BIT(3),
-#endif /* VBOX_WITH_DEBUGGER_GUI */
-    RuntimeMenuType_Help    = RT_BIT(4),
-    RuntimeMenuType_All     = 0xFF
-};
-
-/** Runtime UI: Menu "Machine": Action types. */
-enum RuntimeMenuMachineActionType
-{
-    RuntimeMenuMachineActionType_Invalid           = 0,
-    RuntimeMenuMachineActionType_SettingsDialog    = RT_BIT(0),
-    RuntimeMenuMachineActionType_TakeSnapshot      = RT_BIT(1),
-    RuntimeMenuMachineActionType_TakeScreenshot    = RT_BIT(2),
-    RuntimeMenuMachineActionType_InformationDialog = RT_BIT(3),
-    RuntimeMenuMachineActionType_Keyboard          = RT_BIT(4),
-    RuntimeMenuMachineActionType_KeyboardSettings  = RT_BIT(5),
-    RuntimeMenuMachineActionType_Mouse             = RT_BIT(6),
-    RuntimeMenuMachineActionType_MouseIntegration  = RT_BIT(7),
-    RuntimeMenuMachineActionType_TypeCAD           = RT_BIT(8),
-#ifdef Q_WS_X11
-    RuntimeMenuMachineActionType_TypeCABS          = RT_BIT(9),
-#endif /* Q_WS_X11 */
-    RuntimeMenuMachineActionType_Pause             = RT_BIT(10),
-    RuntimeMenuMachineActionType_Reset             = RT_BIT(11),
-    RuntimeMenuMachineActionType_SaveState         = RT_BIT(12),
-    RuntimeMenuMachineActionType_Shutdown          = RT_BIT(13),
-    RuntimeMenuMachineActionType_PowerOff          = RT_BIT(14),
-#ifndef Q_WS_MAC
-    RuntimeMenuMachineActionType_Close             = RT_BIT(15),
-#endif /* !Q_WS_MAC */
-    RuntimeMenuMachineActionType_All               = 0xFFFF
-};
-
-/** Runtime UI: Menu "View": Action types. */
-enum RuntimeMenuViewActionType
-{
-    RuntimeMenuViewActionType_Invalid           = 0,
-    RuntimeMenuViewActionType_Fullscreen        = RT_BIT(0),
-    RuntimeMenuViewActionType_Seamless          = RT_BIT(1),
-    RuntimeMenuViewActionType_Scale             = RT_BIT(2),
-    RuntimeMenuViewActionType_GuestAutoresize   = RT_BIT(3),
-    RuntimeMenuViewActionType_AdjustWindow      = RT_BIT(4),
-    RuntimeMenuViewActionType_StatusBar         = RT_BIT(5),
-    RuntimeMenuViewActionType_StatusBarSettings = RT_BIT(6),
-    RuntimeMenuViewActionType_ToggleStatusBar   = RT_BIT(7),
-    RuntimeMenuViewActionType_Resize            = RT_BIT(8),
-    RuntimeMenuViewActionType_Multiscreen       = RT_BIT(9),
-    RuntimeMenuViewActionType_All               = 0xFFFF
-};
-
-/** Runtime UI: Menu "Devices": Action types. */
-enum RuntimeMenuDevicesActionType
-{
-    RuntimeMenuDevicesActionType_Invalid               = 0,
-    RuntimeMenuDevicesActionType_HardDrives            = RT_BIT(0),
-    RuntimeMenuDevicesActionType_HardDrivesSettings    = RT_BIT(1),
-    RuntimeMenuDevicesActionType_OpticalDevices        = RT_BIT(2),
-    RuntimeMenuDevicesActionType_FloppyDevices         = RT_BIT(3),
-    RuntimeMenuDevicesActionType_Network               = RT_BIT(4),
-    RuntimeMenuDevicesActionType_NetworkSettings       = RT_BIT(5),
-    RuntimeMenuDevicesActionType_USBDevices            = RT_BIT(6),
-    RuntimeMenuDevicesActionType_USBDevicesSettings    = RT_BIT(7),
-    RuntimeMenuDevicesActionType_WebCams               = RT_BIT(8),
-    RuntimeMenuDevicesActionType_SharedClipboard       = RT_BIT(9),
-    RuntimeMenuDevicesActionType_DragAndDrop           = RT_BIT(10),
-    RuntimeMenuDevicesActionType_SharedFolders         = RT_BIT(11),
-    RuntimeMenuDevicesActionType_SharedFoldersSettings = RT_BIT(12),
-    RuntimeMenuDevicesActionType_VRDEServer            = RT_BIT(13),
-    RuntimeMenuDevicesActionType_VideoCapture          = RT_BIT(14),
-    RuntimeMenuDevicesActionType_VideoCaptureSettings  = RT_BIT(15),
-    RuntimeMenuDevicesActionType_StartVideoCapture     = RT_BIT(16),
-    RuntimeMenuDevicesActionType_InstallGuestTools     = RT_BIT(17),
-    RuntimeMenuDevicesActionType_All                   = 0xFFFF
-};
-
-#ifdef VBOX_WITH_DEBUGGER_GUI
-/** Runtime UI: Menu "Debugger": Action types. */
-enum RuntimeMenuDebuggerActionType
-{
-    RuntimeMenuDebuggerActionType_Invalid     = 0,
-    RuntimeMenuDebuggerActionType_Statistics  = RT_BIT(0),
-    RuntimeMenuDebuggerActionType_CommandLine = RT_BIT(1),
-    RuntimeMenuDebuggerActionType_Logging     = RT_BIT(2),
-    RuntimeMenuDebuggerActionType_LogDialog   = RT_BIT(3),
-    RuntimeMenuDebuggerActionType_All         = 0xFFFF
-};
-#endif /* VBOX_WITH_DEBUGGER_GUI */
-
 /** Runtime UI: Visual-state types. */
 enum UIVisualStateType

trunk/src/VBox/Frontends/VirtualBox/src/extradata/UIExtraDataManager.cpp

@@ -2488 +2488 @@
 }
 
-RuntimeMenuType UIExtraDataManager::restrictedRuntimeMenuTypes(const QString &strID)
+UIExtraDataMetaDefs::RuntimeMenuType UIExtraDataManager::restrictedRuntimeMenuTypes(const QString &strID)
 {
     /* Prepare result: */
-    RuntimeMenuType result = RuntimeMenuType_Invalid;
+    UIExtraDataMetaDefs::RuntimeMenuType result = UIExtraDataMetaDefs::RuntimeMenuType_Invalid;
     /* Get restricted runtime-menu-types: */
     foreach (const QString &strValue, extraDataStringList(GUI_RestrictedRuntimeMenus, strID))
     {
-        RuntimeMenuType value = gpConverter->fromInternalString<RuntimeMenuType>(strValue);
-        if (value != RuntimeMenuType_Invalid)
-            result = static_cast<RuntimeMenuType>(result | value);
+        UIExtraDataMetaDefs::RuntimeMenuType value = gpConverter->fromInternalString<UIExtraDataMetaDefs::RuntimeMenuType>(strValue);
+        if (value != UIExtraDataMetaDefs::RuntimeMenuType_Invalid)
+            result = static_cast<UIExtraDataMetaDefs::RuntimeMenuType>(result | value);
     }
     /* Return result: */
@@ -2504 +2504 @@
 
 #ifdef Q_WS_MAC
-MenuApplicationActionType UIExtraDataManager::restrictedRuntimeMenuApplicationActionTypes(const QString &strID)
+UIExtraDataMetaDefs::MenuApplicationActionType UIExtraDataManager::restrictedRuntimeMenuApplicationActionTypes(const QString &strID)
 {
     /* Prepare result: */
-    MenuApplicationActionType result = MenuApplicationActionType_Invalid;
+    UIExtraDataMetaDefs::MenuApplicationActionType result = UIExtraDataMetaDefs::MenuApplicationActionType_Invalid;
     /* Get restricted runtime-application-menu action-types: */
     foreach (const QString &strValue, extraDataStringList(GUI_RestrictedRuntimeApplicationMenuActions, strID))
     {
-        MenuApplicationActionType value = gpConverter->fromInternalString<MenuApplicationActionType>(strValue);
-        if (value != MenuApplicationActionType_Invalid)
-            result = static_cast<MenuApplicationActionType>(result | value);
+        UIExtraDataMetaDefs::MenuApplicationActionType value = gpConverter->fromInternalString<UIExtraDataMetaDefs::MenuApplicationActionType>(strValue);
+        if (value != UIExtraDataMetaDefs::MenuApplicationActionType_Invalid)
+            result = static_cast<UIExtraDataMetaDefs::MenuApplicationActionType>(result | value);
     }
     /* Return result: */
@@ -2520 +2520 @@
 #endif /* Q_WS_MAC */
 
-RuntimeMenuMachineActionType UIExtraDataManager::restrictedRuntimeMenuMachineActionTypes(const QString &strID)
+UIExtraDataMetaDefs::RuntimeMenuMachineActionType UIExtraDataManager::restrictedRuntimeMenuMachineActionTypes(const QString &strID)
 {
     /* Prepare result: */
-    RuntimeMenuMachineActionType result = RuntimeMenuMachineActionType_Invalid;
+    UIExtraDataMetaDefs::RuntimeMenuMachineActionType result = UIExtraDataMetaDefs::RuntimeMenuMachineActionType_Invalid;
     /* Get restricted runtime-machine-menu action-types: */
     foreach (const QString &strValue, extraDataStringList(GUI_RestrictedRuntimeMachineMenuActions, strID))
     {
-        RuntimeMenuMachineActionType value = gpConverter->fromInternalString<RuntimeMenuMachineActionType>(strValue);
-        if (value != RuntimeMenuMachineActionType_Invalid)
-            result = static_cast<RuntimeMenuMachineActionType>(result | value);
+        UIExtraDataMetaDefs::RuntimeMenuMachineActionType value = gpConverter->fromInternalString<UIExtraDataMetaDefs::RuntimeMenuMachineActionType>(strValue);
+        if (value != UIExtraDataMetaDefs::RuntimeMenuMachineActionType_Invalid)
+            result = static_cast<UIExtraDataMetaDefs::RuntimeMenuMachineActionType>(result | value);
     }
     /* Return result: */
@@ -2535 +2535 @@
 }
 
-RuntimeMenuViewActionType UIExtraDataManager::restrictedRuntimeMenuViewActionTypes(const QString &strID)
+UIExtraDataMetaDefs::RuntimeMenuViewActionType UIExtraDataManager::restrictedRuntimeMenuViewActionTypes(const QString &strID)
 {
     /* Prepare result: */
-    RuntimeMenuViewActionType result = RuntimeMenuViewActionType_Invalid;
+    UIExtraDataMetaDefs::RuntimeMenuViewActionType result = UIExtraDataMetaDefs::RuntimeMenuViewActionType_Invalid;
     /* Get restricted runtime-view-menu action-types: */
     foreach (const QString &strValue, extraDataStringList(GUI_RestrictedRuntimeViewMenuActions, strID))
     {
-        RuntimeMenuViewActionType value = gpConverter->fromInternalString<RuntimeMenuViewActionType>(strValue);
-        if (value != RuntimeMenuViewActionType_Invalid)
-            result = static_cast<RuntimeMenuViewActionType>(result | value);
+        UIExtraDataMetaDefs::RuntimeMenuViewActionType value = gpConverter->fromInternalString<UIExtraDataMetaDefs::RuntimeMenuViewActionType>(strValue);
+        if (value != UIExtraDataMetaDefs::RuntimeMenuViewActionType_Invalid)
+            result = static_cast<UIExtraDataMetaDefs::RuntimeMenuViewActionType>(result | value);
     }
     /* Return result: */
@@ -2550 +2550 @@
 }
 
-RuntimeMenuDevicesActionType UIExtraDataManager::restrictedRuntimeMenuDevicesActionTypes(const QString &strID)
+UIExtraDataMetaDefs::RuntimeMenuDevicesActionType UIExtraDataManager::restrictedRuntimeMenuDevicesActionTypes(const QString &strID)
 {
     /* Prepare result: */
-    RuntimeMenuDevicesActionType result = RuntimeMenuDevicesActionType_Invalid;
+    UIExtraDataMetaDefs::RuntimeMenuDevicesActionType result = UIExtraDataMetaDefs::RuntimeMenuDevicesActionType_Invalid;
     /* Get restricted runtime-devices-menu action-types: */
     foreach (const QString &strValue, extraDataStringList(GUI_RestrictedRuntimeDevicesMenuActions, strID))
     {
-        RuntimeMenuDevicesActionType value = gpConverter->fromInternalString<RuntimeMenuDevicesActionType>(strValue);
-        if (value != RuntimeMenuDevicesActionType_Invalid)
-            result = static_cast<RuntimeMenuDevicesActionType>(result | value);
+        UIExtraDataMetaDefs::RuntimeMenuDevicesActionType value = gpConverter->fromInternalString<UIExtraDataMetaDefs::RuntimeMenuDevicesActionType>(strValue);
+        if (value != UIExtraDataMetaDefs::RuntimeMenuDevicesActionType_Invalid)
+            result = static_cast<UIExtraDataMetaDefs::RuntimeMenuDevicesActionType>(result | value);
     }
     /* Return result: */
@@ -2566 +2566 @@
 
 #ifdef VBOX_WITH_DEBUGGER_GUI
-RuntimeMenuDebuggerActionType UIExtraDataManager::restrictedRuntimeMenuDebuggerActionTypes(const QString &strID)
+UIExtraDataMetaDefs::RuntimeMenuDebuggerActionType UIExtraDataManager::restrictedRuntimeMenuDebuggerActionTypes(const QString &strID)
 {
     /* Prepare result: */
-    RuntimeMenuDebuggerActionType result = RuntimeMenuDebuggerActionType_Invalid;
+    UIExtraDataMetaDefs::RuntimeMenuDebuggerActionType result = UIExtraDataMetaDefs::RuntimeMenuDebuggerActionType_Invalid;
     /* Get restricted runtime-debugger-menu action-types: */
     foreach (const QString &strValue, extraDataStringList(GUI_RestrictedRuntimeDebuggerMenuActions, strID))
     {
-        RuntimeMenuDebuggerActionType value = gpConverter->fromInternalString<RuntimeMenuDebuggerActionType>(strValue);
-        if (value != RuntimeMenuDebuggerActionType_Invalid)
-            result = static_cast<RuntimeMenuDebuggerActionType>(result | value);
+        UIExtraDataMetaDefs::RuntimeMenuDebuggerActionType value = gpConverter->fromInternalString<UIExtraDataMetaDefs::RuntimeMenuDebuggerActionType>(strValue);
+        if (value != UIExtraDataMetaDefs::RuntimeMenuDebuggerActionType_Invalid)
+            result = static_cast<UIExtraDataMetaDefs::RuntimeMenuDebuggerActionType>(result | value);
     }
     /* Return result: */
@@ -2582 +2582 @@
 #endif /* VBOX_WITH_DEBUGGER_GUI */
 
-MenuHelpActionType UIExtraDataManager::restrictedRuntimeMenuHelpActionTypes(const QString &strID)
+UIExtraDataMetaDefs::MenuHelpActionType UIExtraDataManager::restrictedRuntimeMenuHelpActionTypes(const QString &strID)
 {
     /* Prepare result: */
-    MenuHelpActionType result = MenuHelpActionType_Invalid;
+    UIExtraDataMetaDefs::MenuHelpActionType result = UIExtraDataMetaDefs::MenuHelpActionType_Invalid;
     /* Get restricted runtime-help-menu action-types: */
     foreach (const QString &strValue, extraDataStringList(GUI_RestrictedRuntimeHelpMenuActions, strID))
     {
-        MenuHelpActionType value = gpConverter->fromInternalString<MenuHelpActionType>(strValue);
-        if (value != MenuHelpActionType_Invalid)
-            result = static_cast<MenuHelpActionType>(result | value);
+        UIExtraDataMetaDefs::MenuHelpActionType value = gpConverter->fromInternalString<UIExtraDataMetaDefs::MenuHelpActionType>(strValue);
+        if (value != UIExtraDataMetaDefs::MenuHelpActionType_Invalid)
+            result = static_cast<UIExtraDataMetaDefs::MenuHelpActionType>(result | value);
     }
     /* Return result: */

trunk/src/VBox/Frontends/VirtualBox/src/extradata/UIExtraDataManager.h

@@ -285 +285 @@
 
         /** Returns restricted Runtime UI menu types. */
-        RuntimeMenuType restrictedRuntimeMenuTypes(const QString &strID);
-    #ifdef Q_WS_MAC
+        UIExtraDataMetaDefs::RuntimeMenuType restrictedRuntimeMenuTypes(const QString &strID);
+#ifdef Q_WS_MAC
         /** Mac OS X: Returns restricted Runtime UI action types for Application menu. */
-        MenuApplicationActionType restrictedRuntimeMenuApplicationActionTypes(const QString &strID);
-    #endif /* Q_WS_MAC */
+        UIExtraDataMetaDefs::MenuApplicationActionType restrictedRuntimeMenuApplicationActionTypes(const QString &strID);
+#endif /* Q_WS_MAC */
         /** Returns restricted Runtime UI action types for Machine menu. */
-        RuntimeMenuMachineActionType restrictedRuntimeMenuMachineActionTypes(const QString &strID);
+        UIExtraDataMetaDefs::RuntimeMenuMachineActionType restrictedRuntimeMenuMachineActionTypes(const QString &strID);
         /** Returns restricted Runtime UI action types for View menu. */
-        RuntimeMenuViewActionType restrictedRuntimeMenuViewActionTypes(const QString &strID);
+        UIExtraDataMetaDefs::RuntimeMenuViewActionType restrictedRuntimeMenuViewActionTypes(const QString &strID);
         /** Returns restricted Runtime UI action types for Devices menu. */
-        RuntimeMenuDevicesActionType restrictedRuntimeMenuDevicesActionTypes(const QString &strID);
-    #ifdef VBOX_WITH_DEBUGGER_GUI
+        UIExtraDataMetaDefs::RuntimeMenuDevicesActionType restrictedRuntimeMenuDevicesActionTypes(const QString &strID);
+#ifdef VBOX_WITH_DEBUGGER_GUI
         /** Returns restricted Runtime UI action types for Debugger menu. */
-        RuntimeMenuDebuggerActionType restrictedRuntimeMenuDebuggerActionTypes(const QString &strID);
-    #endif /* VBOX_WITH_DEBUGGER_GUI */
+        UIExtraDataMetaDefs::RuntimeMenuDebuggerActionType restrictedRuntimeMenuDebuggerActionTypes(const QString &strID);
+#endif /* VBOX_WITH_DEBUGGER_GUI */
         /** Returns restricted Runtime UI action types for Help menu. */
-        MenuHelpActionType restrictedRuntimeMenuHelpActionTypes(const QString &strID);
+        UIExtraDataMetaDefs::MenuHelpActionType restrictedRuntimeMenuHelpActionTypes(const QString &strID);
 
         /** Returns restricted Runtime UI visual-states. */

trunk/src/VBox/Frontends/VirtualBox/src/globals/UIActionPool.cpp

@@ -620 +620 @@
 }
 
-bool UIActionPool::isAllowedInMenuHelp(MenuHelpActionType type) const
-{
-    foreach (const MenuHelpActionType &restriction, m_restrictedActionsMenuHelp.values())
+bool UIActionPool::isAllowedInMenuHelp(UIExtraDataMetaDefs::MenuHelpActionType type) const
+{
+    foreach (const UIExtraDataMetaDefs::MenuHelpActionType &restriction, m_restrictedActionsMenuHelp.values())
         if (restriction & type)
             return false;
@@ -628 +628 @@
 }
 
-void UIActionPool::setRestrictionForMenuHelp(UIActionRestrictionLevel level, MenuHelpActionType restriction)
+void UIActionPool::setRestrictionForMenuHelp(UIActionRestrictionLevel level, UIExtraDataMetaDefs::MenuHelpActionType restriction)
 {
     m_restrictedActionsMenuHelp[level] = restriction;
@@ -635 +635 @@
 
 #ifdef Q_WS_MAC
-bool UIActionPool::isAllowedInMenuApplication(MenuApplicationActionType type) const
-{
-    foreach (const MenuApplicationActionType &restriction, m_restrictedActionsMenuApplication.values())
+bool UIActionPool::isAllowedInMenuApplication(UIExtraDataMetaDefs::MenuApplicationActionType type) const
+{
+    foreach (const UIExtraDataMetaDefs::MenuApplicationActionType &restriction, m_restrictedActionsMenuApplication.values())
         if (restriction & type)
             return false;
@@ -643 +643 @@
 }
 
-void UIActionPool::setRestrictionForMenuApplication(UIActionRestrictionLevel level, MenuApplicationActionType restriction)
+void UIActionPool::setRestrictionForMenuApplication(UIActionRestrictionLevel level, UIExtraDataMetaDefs::MenuApplicationActionType restriction)
 {
     m_restrictedActionsMenuApplication[level] = restriction;
@@ -766 +766 @@
     if (!fUpdateAllowed)
     {
-        m_restrictedActionsMenuHelp[UIActionRestrictionLevel_Base] = (MenuHelpActionType)
-            (m_restrictedActionsMenuHelp[UIActionRestrictionLevel_Base] | MenuHelpActionType_CheckForUpdates);
+        m_restrictedActionsMenuHelp[UIActionRestrictionLevel_Base] = (UIExtraDataMetaDefs::MenuHelpActionType)
+            (m_restrictedActionsMenuHelp[UIActionRestrictionLevel_Base] | UIExtraDataMetaDefs::MenuHelpActionType_CheckForUpdates);
     }
 #endif /* VBOX_GUI_WITH_NETWORK_MANAGER */
@@ -795 +795 @@
 
     /* 'Contents' action: */
-    const bool fAllowToShowActionContents = isAllowedInMenuHelp(MenuHelpActionType_Contents);
+    const bool fAllowToShowActionContents = isAllowedInMenuHelp(UIExtraDataMetaDefs::MenuHelpActionType_Contents);
     action(UIActionIndex_Simple_Contents)->setEnabled(fAllowToShowActionContents);
     if (fAllowToShowActionContents)
@@ -806 +806 @@
 
     /* 'Web Site' action: */
-    const bool fAllowToShowActionWebSite = isAllowedInMenuHelp(MenuHelpActionType_WebSite);
-    action(MenuHelpActionType_WebSite)->setEnabled(fAllowToShowActionWebSite);
+    const bool fAllowToShowActionWebSite = isAllowedInMenuHelp(UIExtraDataMetaDefs::MenuHelpActionType_WebSite);
+    action(UIActionIndex_Simple_WebSite)->setEnabled(fAllowToShowActionWebSite);
     if (fAllowToShowActionWebSite)
     {
@@ -825 +825 @@
 
     /* 'Reset Warnings' action: */
-    const bool fAllowToShowActionResetWarnings = isAllowedInMenuHelp(MenuHelpActionType_ResetWarnings);
+    const bool fAllowToShowActionResetWarnings = isAllowedInMenuHelp(UIExtraDataMetaDefs::MenuHelpActionType_ResetWarnings);
     action(UIActionIndex_Simple_ResetWarnings)->setEnabled(fAllowToShowActionResetWarnings);
     if (fAllowToShowActionResetWarnings)
@@ -847 +847 @@
 
     /* 'Network Manager' action: */
-    const bool fAllowToShowActionNetworkManager = isAllowedInMenuHelp(MenuHelpActionType_NetworkAccessManager);
+    const bool fAllowToShowActionNetworkManager = isAllowedInMenuHelp(UIExtraDataMetaDefs::MenuHelpActionType_NetworkAccessManager);
     action(UIActionIndex_Simple_NetworkAccessManager)->setEnabled(fAllowToShowActionNetworkManager);
     if (fAllowToShowActionNetworkManager)
@@ -863 +863 @@
     {
         /* 'Check for Updates' action: */
-        const bool fAllowToShowActionCheckForUpdates = isAllowedInMenuHelp(MenuHelpActionType_CheckForUpdates);
+        const bool fAllowToShowActionCheckForUpdates = isAllowedInMenuHelp(UIExtraDataMetaDefs::MenuHelpActionType_CheckForUpdates);
         action(UIActionIndex_Simple_NetworkAccessManager)->setEnabled(fAllowToShowActionCheckForUpdates);
         if (fAllowToShowActionCheckForUpdates)
@@ -887 +887 @@
     const bool fAllowToShowActionAbout =
 #ifdef Q_WS_MAC
-        isAllowedInMenuApplication(MenuApplicationActionType_About);
+        isAllowedInMenuApplication(UIExtraDataMetaDefs::MenuApplicationActionType_About);
 #else /* !Q_WS_MAC */
-        isAllowedInMenuHelp(MenuHelpActionType_About);
+        isAllowedInMenuHelp(UIExtraDataMetaDefs::MenuHelpActionType_About);
 #endif /* Q_WS_MAC */
     action(UIActionIndex_Simple_About)->setEnabled(fAllowToShowActionAbout);
@@ -905 +905 @@
         const bool fAllowToShowActionPreferences =
 #ifdef Q_WS_MAC
-            isAllowedInMenuApplication(MenuApplicationActionType_Preferences);
+            isAllowedInMenuApplication(UIExtraDataMetaDefs::MenuApplicationActionType_Preferences);
 #else /* !Q_WS_MAC */
-            isAllowedInMenuHelp(MenuHelpActionType_Preferences);
+            isAllowedInMenuHelp(UIExtraDataMetaDefs::MenuHelpActionType_Preferences);
 #endif /* Q_WS_MAC */
         action(UIActionIndex_Simple_Preferences)->setEnabled(fAllowToShowActionPreferences);

trunk/src/VBox/Frontends/VirtualBox/src/globals/UIActionPool.h

@@ -323 +323 @@
 
     /** Returns whether the action with passed @a type is allowed in the 'Help' menu. */
-    bool isAllowedInMenuHelp(MenuHelpActionType type) const;
+    bool isAllowedInMenuHelp(UIExtraDataMetaDefs::MenuHelpActionType type) const;
     /** Defines 'Help' menu @a restriction for passed @a level. */
-    void setRestrictionForMenuHelp(UIActionRestrictionLevel level, MenuHelpActionType restriction);
+    void setRestrictionForMenuHelp(UIActionRestrictionLevel level, UIExtraDataMetaDefs::MenuHelpActionType restriction);
 
 #ifdef Q_WS_MAC
     /** Returns whether the action with passed @a type is allowed in the 'Application' menu. */
-    bool isAllowedInMenuApplication(MenuApplicationActionType type) const;
+    bool isAllowedInMenuApplication(UIExtraDataMetaDefs::MenuApplicationActionType type) const;
     /** Defines 'Application' menu @a restriction for passed @a level. */
-    void setRestrictionForMenuApplication(UIActionRestrictionLevel level, MenuApplicationActionType restriction);
+    void setRestrictionForMenuApplication(UIActionRestrictionLevel level, UIExtraDataMetaDefs::MenuApplicationActionType restriction);
 #endif /* Q_WS_MAC */
 
@@ -401 +401 @@
 
     /** Holds restricted action types of the Help menu. */
-    QMap<UIActionRestrictionLevel, MenuHelpActionType> m_restrictedActionsMenuHelp;
+    QMap<UIActionRestrictionLevel, UIExtraDataMetaDefs::MenuHelpActionType> m_restrictedActionsMenuHelp;
 #ifdef Q_WS_MAC
     /** Holds restricted action types of the Application menu. */
-    QMap<UIActionRestrictionLevel, MenuApplicationActionType> m_restrictedActionsMenuApplication;
+    QMap<UIActionRestrictionLevel, UIExtraDataMetaDefs::MenuApplicationActionType> m_restrictedActionsMenuApplication;
 #endif /* Q_WS_MAC */
 };

trunk/src/VBox/Frontends/VirtualBox/src/runtime/UIActionPoolRuntime.cpp

@@ -1300 +1300 @@
 }
 
-bool UIActionPoolRuntime::isAllowedInMenuBar(RuntimeMenuType type) const
-{
-    foreach (const RuntimeMenuType &restriction, m_restrictedMenus.values())
+bool UIActionPoolRuntime::isAllowedInMenuBar(UIExtraDataMetaDefs::RuntimeMenuType type) const
+{
+    foreach (const UIExtraDataMetaDefs::RuntimeMenuType &restriction, m_restrictedMenus.values())
         if (restriction & type)
             return false;
@@ -1308 +1308 @@
 }
 
-void UIActionPoolRuntime::setRestrictionForMenuBar(UIActionRestrictionLevel level, RuntimeMenuType restriction)
+void UIActionPoolRuntime::setRestrictionForMenuBar(UIActionRestrictionLevel level, UIExtraDataMetaDefs::RuntimeMenuType restriction)
 {
     m_restrictedMenus[level] = restriction;
@@ -1314 +1314 @@
 }
 
-bool UIActionPoolRuntime::isAllowedInMenuMachine(RuntimeMenuMachineActionType type) const
-{
-    foreach (const RuntimeMenuMachineActionType &restriction, m_restrictedActionsMenuMachine.values())
+bool UIActionPoolRuntime::isAllowedInMenuMachine(UIExtraDataMetaDefs::RuntimeMenuMachineActionType type) const
+{
+    foreach (const UIExtraDataMetaDefs::RuntimeMenuMachineActionType &restriction, m_restrictedActionsMenuMachine.values())
         if (restriction & type)
             return false;
@@ -1322 +1322 @@
 }
 
-void UIActionPoolRuntime::setRestrictionForMenuMachine(UIActionRestrictionLevel level, RuntimeMenuMachineActionType restriction)
+void UIActionPoolRuntime::setRestrictionForMenuMachine(UIActionRestrictionLevel level, UIExtraDataMetaDefs::RuntimeMenuMachineActionType restriction)
 {
     m_restrictedActionsMenuMachine[level] = restriction;
@@ -1328 +1328 @@
 }
 
-bool UIActionPoolRuntime::isAllowedInMenuView(RuntimeMenuViewActionType type) const
-{
-    foreach (const RuntimeMenuViewActionType &restriction, m_restrictedActionsMenuView.values())
+bool UIActionPoolRuntime::isAllowedInMenuView(UIExtraDataMetaDefs::RuntimeMenuViewActionType type) const
+{
+    foreach (const UIExtraDataMetaDefs::RuntimeMenuViewActionType &restriction, m_restrictedActionsMenuView.values())
         if (restriction & type)
             return false;
@@ -1336 +1336 @@
 }
 
-void UIActionPoolRuntime::setRestrictionForMenuView(UIActionRestrictionLevel level, RuntimeMenuViewActionType restriction)
+void UIActionPoolRuntime::setRestrictionForMenuView(UIActionRestrictionLevel level, UIExtraDataMetaDefs::RuntimeMenuViewActionType restriction)
 {
     m_restrictedActionsMenuView[level] = restriction;
@@ -1342 +1342 @@
 }
 
-bool UIActionPoolRuntime::isAllowedInMenuDevices(RuntimeMenuDevicesActionType type) const
-{
-    foreach (const RuntimeMenuDevicesActionType &restriction, m_restrictedActionsMenuDevices.values())
+bool UIActionPoolRuntime::isAllowedInMenuDevices(UIExtraDataMetaDefs::RuntimeMenuDevicesActionType type) const
+{
+    foreach (const UIExtraDataMetaDefs::RuntimeMenuDevicesActionType &restriction, m_restrictedActionsMenuDevices.values())
         if (restriction & type)
             return false;
@@ -1350 +1350 @@
 }
 
-void UIActionPoolRuntime::setRestrictionForMenuDevices(UIActionRestrictionLevel level, RuntimeMenuDevicesActionType restriction)
+void UIActionPoolRuntime::setRestrictionForMenuDevices(UIActionRestrictionLevel level, UIExtraDataMetaDefs::RuntimeMenuDevicesActionType restriction)
 {
     m_restrictedActionsMenuDevices[level] = restriction;
@@ -1357 +1357 @@
 
 #ifdef VBOX_WITH_DEBUGGER_GUI
-bool UIActionPoolRuntime::isAllowedInMenuDebug(RuntimeMenuDebuggerActionType type) const
-{
-    foreach (const RuntimeMenuDebuggerActionType &restriction, m_restrictedActionsMenuDebug.values())
+bool UIActionPoolRuntime::isAllowedInMenuDebug(UIExtraDataMetaDefs::RuntimeMenuDebuggerActionType type) const
+{
+    foreach (const UIExtraDataMetaDefs::RuntimeMenuDebuggerActionType &restriction, m_restrictedActionsMenuDebug.values())
         if (restriction & type)
             return false;
@@ -1365 +1365 @@
 }
 
-void UIActionPoolRuntime::setRestrictionForMenuDebugger(UIActionRestrictionLevel level, RuntimeMenuDebuggerActionType restriction)
+void UIActionPoolRuntime::setRestrictionForMenuDebugger(UIActionRestrictionLevel level, UIExtraDataMetaDefs::RuntimeMenuDebuggerActionType restriction)
 {
     m_restrictedActionsMenuDebug[level] = restriction;
@@ -1555 +1555 @@
     {
         if (restrictedVisualStates & UIVisualStateType_Fullscreen)
-            m_restrictedActionsMenuView[UIActionRestrictionLevel_Base] = (RuntimeMenuViewActionType)
-                (m_restrictedActionsMenuView[UIActionRestrictionLevel_Base] | RuntimeMenuViewActionType_Fullscreen);
+            m_restrictedActionsMenuView[UIActionRestrictionLevel_Base] = (UIExtraDataMetaDefs::RuntimeMenuViewActionType)
+                (m_restrictedActionsMenuView[UIActionRestrictionLevel_Base] | UIExtraDataMetaDefs::RuntimeMenuViewActionType_Fullscreen);
         if (restrictedVisualStates & UIVisualStateType_Seamless)
-            m_restrictedActionsMenuView[UIActionRestrictionLevel_Base] = (RuntimeMenuViewActionType)
-                (m_restrictedActionsMenuView[UIActionRestrictionLevel_Base] | RuntimeMenuViewActionType_Seamless);
+            m_restrictedActionsMenuView[UIActionRestrictionLevel_Base] = (UIExtraDataMetaDefs::RuntimeMenuViewActionType)
+                (m_restrictedActionsMenuView[UIActionRestrictionLevel_Base] | UIExtraDataMetaDefs::RuntimeMenuViewActionType_Seamless);
         if (restrictedVisualStates & UIVisualStateType_Scale)
-            m_restrictedActionsMenuView[UIActionRestrictionLevel_Base] = (RuntimeMenuViewActionType)
-                (m_restrictedActionsMenuView[UIActionRestrictionLevel_Base] | RuntimeMenuViewActionType_Scale);
+            m_restrictedActionsMenuView[UIActionRestrictionLevel_Base] = (UIExtraDataMetaDefs::RuntimeMenuViewActionType)
+                (m_restrictedActionsMenuView[UIActionRestrictionLevel_Base] | UIExtraDataMetaDefs::RuntimeMenuViewActionType_Scale);
     }
 
@@ -1569 +1569 @@
     if (!fReconfigurationAllowed)
     {
-        m_restrictedActionsMenuMachine[UIActionRestrictionLevel_Base] = (RuntimeMenuMachineActionType)
-            (m_restrictedActionsMenuMachine[UIActionRestrictionLevel_Base] | RuntimeMenuMachineActionType_SettingsDialog);
-        m_restrictedActionsMenuMachine[UIActionRestrictionLevel_Base] = (RuntimeMenuMachineActionType)
-            (m_restrictedActionsMenuMachine[UIActionRestrictionLevel_Base] | RuntimeMenuMachineActionType_KeyboardSettings);
-        m_restrictedActionsMenuDevices[UIActionRestrictionLevel_Base] = (RuntimeMenuDevicesActionType)
-            (m_restrictedActionsMenuDevices[UIActionRestrictionLevel_Base] | RuntimeMenuDevicesActionType_HardDrivesSettings);
-        m_restrictedActionsMenuDevices[UIActionRestrictionLevel_Base] = (RuntimeMenuDevicesActionType)
-            (m_restrictedActionsMenuDevices[UIActionRestrictionLevel_Base] | RuntimeMenuDevicesActionType_NetworkSettings);
-        m_restrictedActionsMenuDevices[UIActionRestrictionLevel_Base] = (RuntimeMenuDevicesActionType)
-            (m_restrictedActionsMenuDevices[UIActionRestrictionLevel_Base] | RuntimeMenuDevicesActionType_USBDevicesSettings);
-        m_restrictedActionsMenuDevices[UIActionRestrictionLevel_Base] = (RuntimeMenuDevicesActionType)
-            (m_restrictedActionsMenuDevices[UIActionRestrictionLevel_Base] | RuntimeMenuDevicesActionType_SharedFoldersSettings);
-        m_restrictedActionsMenuDevices[UIActionRestrictionLevel_Base] = (RuntimeMenuDevicesActionType)
-            (m_restrictedActionsMenuDevices[UIActionRestrictionLevel_Base] | RuntimeMenuDevicesActionType_VideoCaptureSettings);
+        m_restrictedActionsMenuMachine[UIActionRestrictionLevel_Base] = (UIExtraDataMetaDefs::RuntimeMenuMachineActionType)
+            (m_restrictedActionsMenuMachine[UIActionRestrictionLevel_Base] | UIExtraDataMetaDefs::RuntimeMenuMachineActionType_SettingsDialog);
+        m_restrictedActionsMenuMachine[UIActionRestrictionLevel_Base] = (UIExtraDataMetaDefs::RuntimeMenuMachineActionType)
+            (m_restrictedActionsMenuMachine[UIActionRestrictionLevel_Base] | UIExtraDataMetaDefs::RuntimeMenuMachineActionType_KeyboardSettings);
+        m_restrictedActionsMenuDevices[UIActionRestrictionLevel_Base] = (UIExtraDataMetaDefs::RuntimeMenuDevicesActionType)
+            (m_restrictedActionsMenuDevices[UIActionRestrictionLevel_Base] | UIExtraDataMetaDefs::RuntimeMenuDevicesActionType_HardDrivesSettings);
+        m_restrictedActionsMenuDevices[UIActionRestrictionLevel_Base] = (UIExtraDataMetaDefs::RuntimeMenuDevicesActionType)
+            (m_restrictedActionsMenuDevices[UIActionRestrictionLevel_Base] | UIExtraDataMetaDefs::RuntimeMenuDevicesActionType_NetworkSettings);
+        m_restrictedActionsMenuDevices[UIActionRestrictionLevel_Base] = (UIExtraDataMetaDefs::RuntimeMenuDevicesActionType)
+            (m_restrictedActionsMenuDevices[UIActionRestrictionLevel_Base] | UIExtraDataMetaDefs::RuntimeMenuDevicesActionType_USBDevicesSettings);
+        m_restrictedActionsMenuDevices[UIActionRestrictionLevel_Base] = (UIExtraDataMetaDefs::RuntimeMenuDevicesActionType)
+            (m_restrictedActionsMenuDevices[UIActionRestrictionLevel_Base] | UIExtraDataMetaDefs::RuntimeMenuDevicesActionType_SharedFoldersSettings);
+        m_restrictedActionsMenuDevices[UIActionRestrictionLevel_Base] = (UIExtraDataMetaDefs::RuntimeMenuDevicesActionType)
+            (m_restrictedActionsMenuDevices[UIActionRestrictionLevel_Base] | UIExtraDataMetaDefs::RuntimeMenuDevicesActionType_VideoCaptureSettings);
     }
 
@@ -1589 +1589 @@
     if (!fSnapshotOperationsAllowed)
     {
-        m_restrictedActionsMenuMachine[UIActionRestrictionLevel_Base] = (RuntimeMenuMachineActionType)
-            (m_restrictedActionsMenuMachine[UIActionRestrictionLevel_Base] | RuntimeMenuMachineActionType_TakeSnapshot);
+        m_restrictedActionsMenuMachine[UIActionRestrictionLevel_Base] = (UIExtraDataMetaDefs::RuntimeMenuMachineActionType)
+            (m_restrictedActionsMenuMachine[UIActionRestrictionLevel_Base] | UIExtraDataMetaDefs::RuntimeMenuMachineActionType_TakeSnapshot);
     }
 
@@ -1598 +1598 @@
     if (!fExtensionPackOperationsAllowed)
     {
-        m_restrictedActionsMenuDevices[UIActionRestrictionLevel_Base] = (RuntimeMenuDevicesActionType)
-            (m_restrictedActionsMenuDevices[UIActionRestrictionLevel_Base] | RuntimeMenuDevicesActionType_VRDEServer);
+        m_restrictedActionsMenuDevices[UIActionRestrictionLevel_Base] = (UIExtraDataMetaDefs::RuntimeMenuDevicesActionType)
+            (m_restrictedActionsMenuDevices[UIActionRestrictionLevel_Base] | UIExtraDataMetaDefs::RuntimeMenuDevicesActionType_VRDEServer);
     }
 
@@ -1612 +1612 @@
     {
 #ifdef Q_WS_MAC
-        m_restrictedActionsMenuApplication[UIActionRestrictionLevel_Base] = (MenuApplicationActionType)
-            (m_restrictedActionsMenuApplication[UIActionRestrictionLevel_Base] | MenuApplicationActionType_Close);
+        m_restrictedActionsMenuApplication[UIActionRestrictionLevel_Base] = (UIExtraDataMetaDefs::MenuApplicationActionType)
+            (m_restrictedActionsMenuApplication[UIActionRestrictionLevel_Base] | UIExtraDataMetaDefs::MenuApplicationActionType_Close);
 #else /* !Q_WS_MAC */
-        m_restrictedActionsMenuMachine[UIActionRestrictionLevel_Base] = (RuntimeMenuMachineActionType)
-            (m_restrictedActionsMenuMachine[UIActionRestrictionLevel_Base] | RuntimeMenuMachineActionType_Close);
+        m_restrictedActionsMenuMachine[UIActionRestrictionLevel_Base] = (UIExtraDataMetaDefs::RuntimeMenuMachineActionType)
+            (m_restrictedActionsMenuMachine[UIActionRestrictionLevel_Base] | UIExtraDataMetaDefs::RuntimeMenuMachineActionType_Close);
 #endif /* !Q_WS_MAC */
     }
@@ -1641 +1641 @@
 
     /* 'Machine' menu: */
-    const bool fAllowToShowMenuMachine = isAllowedInMenuBar(RuntimeMenuType_Machine);
+    const bool fAllowToShowMenuMachine = isAllowedInMenuBar(UIExtraDataMetaDefs::RuntimeMenuType_Machine);
     action(UIActionIndexRT_M_Machine)->setVisible(fAllowToShowMenuMachine);
     if (fAllowToShowMenuMachine)
@@ -1648 +1648 @@
 
     /* 'View' menu: */
-    const bool fAllowToShowMenuView = isAllowedInMenuBar(RuntimeMenuType_View);
+    const bool fAllowToShowMenuView = isAllowedInMenuBar(UIExtraDataMetaDefs::RuntimeMenuType_View);
     action(UIActionIndexRT_M_View)->setVisible(fAllowToShowMenuView);
     action(UIActionIndexRT_M_ViewPopup)->setVisible(fAllowToShowMenuView);
@@ -1657 +1657 @@
 
     /* 'Devices' menu: */
-    const bool fAllowToShowMenuDevices = isAllowedInMenuBar(RuntimeMenuType_Devices);
+    const bool fAllowToShowMenuDevices = isAllowedInMenuBar(UIExtraDataMetaDefs::RuntimeMenuType_Devices);
     action(UIActionIndexRT_M_Devices)->setVisible(fAllowToShowMenuDevices);
     if (fAllowToShowMenuDevices)
@@ -1665 +1665 @@
 #ifdef VBOX_WITH_DEBUGGER_GUI
     /* 'Debug' menu: */
-    const bool fAllowToShowMenuDebug = isAllowedInMenuBar(RuntimeMenuType_Debug);
+    const bool fAllowToShowMenuDebug = isAllowedInMenuBar(UIExtraDataMetaDefs::RuntimeMenuType_Debug);
     action(UIActionIndexRT_M_Debug)->setVisible(fAllowToShowMenuDebug);
     if (fAllowToShowMenuDebug)
@@ -1673 +1673 @@
 
     /* 'Help' menu: */
-    const bool fAllowToShowMenuHelp = isAllowedInMenuBar(RuntimeMenuType_Help);
+    const bool fAllowToShowMenuHelp = isAllowedInMenuBar(UIExtraDataMetaDefs::RuntimeMenuType_Help);
     action(UIActionIndex_Menu_Help)->setVisible(fAllowToShowMenuHelp);
     if (fAllowToShowMenuHelp)
@@ -1693 +1693 @@
 
     /* 'Settings Dialog' action: */
-    const bool fAllowToShowActionSettingsDialog = isAllowedInMenuMachine(RuntimeMenuMachineActionType_SettingsDialog);
+    const bool fAllowToShowActionSettingsDialog = isAllowedInMenuMachine(UIExtraDataMetaDefs::RuntimeMenuMachineActionType_SettingsDialog);
     action(UIActionIndexRT_M_Machine_S_Settings)->setEnabled(fAllowToShowActionSettingsDialog);
     if (fAllowToShowActionSettingsDialog)
@@ -1702 +1702 @@
 
     /* 'Take Snapshot' action: */
-    const bool fAllowToShowActionTakeSnapshot = isAllowedInMenuMachine(RuntimeMenuMachineActionType_TakeSnapshot);
+    const bool fAllowToShowActionTakeSnapshot = isAllowedInMenuMachine(UIExtraDataMetaDefs::RuntimeMenuMachineActionType_TakeSnapshot);
     action(UIActionIndexRT_M_Machine_S_TakeSnapshot)->setEnabled(fAllowToShowActionTakeSnapshot);
     if (fAllowToShowActionTakeSnapshot)
@@ -1711 +1711 @@
 
     /* 'Take Screenshot' action: */
-    const bool fAllowToShowActionTakeScreenshot = isAllowedInMenuMachine(RuntimeMenuMachineActionType_TakeScreenshot);
+    const bool fAllowToShowActionTakeScreenshot = isAllowedInMenuMachine(UIExtraDataMetaDefs::RuntimeMenuMachineActionType_TakeScreenshot);
     action(UIActionIndexRT_M_Machine_S_TakeScreenshot)->setEnabled(fAllowToShowActionTakeScreenshot);
     if (fAllowToShowActionTakeScreenshot)
@@ -1720 +1720 @@
 
     /* 'Information Dialog' action: */
-    const bool fAllowToShowActionInformationDialog = isAllowedInMenuMachine(RuntimeMenuMachineActionType_InformationDialog);
+    const bool fAllowToShowActionInformationDialog = isAllowedInMenuMachine(UIExtraDataMetaDefs::RuntimeMenuMachineActionType_InformationDialog);
     action(UIActionIndexRT_M_Machine_S_ShowInformation)->setEnabled(fAllowToShowActionInformationDialog);
     if (fAllowToShowActionInformationDialog)
@@ -1737 +1737 @@
 
     /* 'Keyboard' submenu: */
-    const bool fAllowToShowActionKeyboard = isAllowedInMenuMachine(RuntimeMenuMachineActionType_Keyboard);
+    const bool fAllowToShowActionKeyboard = isAllowedInMenuMachine(UIExtraDataMetaDefs::RuntimeMenuMachineActionType_Keyboard);
     action(UIActionIndexRT_M_Machine_M_Keyboard)->setEnabled(fAllowToShowActionKeyboard);
     if (fAllowToShowActionKeyboard)
@@ -1747 +1747 @@
 
     /* 'Mouse' submenu: */
-    const bool fAllowToShowActionMouse = isAllowedInMenuMachine(RuntimeMenuMachineActionType_Mouse);
+    const bool fAllowToShowActionMouse = isAllowedInMenuMachine(UIExtraDataMetaDefs::RuntimeMenuMachineActionType_Mouse);
     action(UIActionIndexRT_M_Machine_M_Mouse)->setEnabled(fAllowToShowActionMouse);
     if (fAllowToShowActionMouse)
@@ -1757 +1757 @@
 
     /* 'Mouse Integration' action: */
-    const bool fAllowToShowActionMouseIntegration = isAllowedInMenuMachine(RuntimeMenuMachineActionType_MouseIntegration);
+    const bool fAllowToShowActionMouseIntegration = isAllowedInMenuMachine(UIExtraDataMetaDefs::RuntimeMenuMachineActionType_MouseIntegration);
     action(UIActionIndexRT_M_Machine_M_Mouse_T_Integration)->setEnabled(fAllowToShowActionMouseIntegration);
     if (fAllowToShowActionMouseIntegration)
@@ -1774 +1774 @@
 
     /* 'Type CAD' action: */
-    const bool fAllowToShowActionTypeCAD = isAllowedInMenuMachine(RuntimeMenuMachineActionType_TypeCAD);
+    const bool fAllowToShowActionTypeCAD = isAllowedInMenuMachine(UIExtraDataMetaDefs::RuntimeMenuMachineActionType_TypeCAD);
     action(UIActionIndexRT_M_Machine_S_TypeCAD)->setEnabled(fAllowToShowActionTypeCAD);
     if (fAllowToShowActionTypeCAD)
@@ -1784 +1784 @@
 #ifdef Q_WS_X11
     /* 'Type CABS' action: */
-    const bool fAllowToShowActionTypeCABS = isAllowedInMenuMachine(RuntimeMenuMachineActionType_TypeCABS);
+    const bool fAllowToShowActionTypeCABS = isAllowedInMenuMachine(UIExtraDataMetaDefs::RuntimeMenuMachineActionType_TypeCABS);
     action(UIActionIndexRT_M_Machine_S_TypeCABS)->setEnabled(fAllowToShowActionTypeCABS);
     if (fAllowToShowActionTypeCABS)
@@ -1802 +1802 @@
 
     /* 'Pause' action: */
-    const bool fAllowToShowActionPause = isAllowedInMenuMachine(RuntimeMenuMachineActionType_Pause);
+    const bool fAllowToShowActionPause = isAllowedInMenuMachine(UIExtraDataMetaDefs::RuntimeMenuMachineActionType_Pause);
     action(UIActionIndexRT_M_Machine_T_Pause)->setEnabled(fAllowToShowActionPause);
     if (fAllowToShowActionPause)
@@ -1811 +1811 @@
 
     /* 'Reset' action: */
-    const bool fAllowToShowActionReset = isAllowedInMenuMachine(RuntimeMenuMachineActionType_Reset);
+    const bool fAllowToShowActionReset = isAllowedInMenuMachine(UIExtraDataMetaDefs::RuntimeMenuMachineActionType_Reset);
     action(UIActionIndexRT_M_Machine_S_Reset)->setEnabled(fAllowToShowActionReset);
     if (fAllowToShowActionReset)
@@ -1820 +1820 @@
 
     /* 'Save' action: */
-    const bool fAllowToShowActionSaveState = isAllowedInMenuMachine(RuntimeMenuMachineActionType_SaveState);
+    const bool fAllowToShowActionSaveState = isAllowedInMenuMachine(UIExtraDataMetaDefs::RuntimeMenuMachineActionType_SaveState);
     action(UIActionIndexRT_M_Machine_S_Save)->setEnabled(fAllowToShowActionSaveState);
     if (fAllowToShowActionSaveState)
@@ -1829 +1829 @@
 
     /* 'Shutdown' action: */
-    const bool fAllowToShowActionShutdown = isAllowedInMenuMachine(RuntimeMenuMachineActionType_Shutdown);
+    const bool fAllowToShowActionShutdown = isAllowedInMenuMachine(UIExtraDataMetaDefs::RuntimeMenuMachineActionType_Shutdown);
     action(UIActionIndexRT_M_Machine_S_Shutdown)->setEnabled(fAllowToShowActionShutdown);
     if (fAllowToShowActionShutdown)
@@ -1838 +1838 @@
 
     /* 'PowerOff' action: */
-    const bool fAllowToShowActionPowerOff = isAllowedInMenuMachine(RuntimeMenuMachineActionType_PowerOff);
+    const bool fAllowToShowActionPowerOff = isAllowedInMenuMachine(UIExtraDataMetaDefs::RuntimeMenuMachineActionType_PowerOff);
     action(UIActionIndexRT_M_Machine_S_PowerOff)->setEnabled(fAllowToShowActionPowerOff);
     if (fAllowToShowActionPowerOff)
@@ -1856 +1856 @@
     const bool fAllowToShowActionClose =
 #ifdef Q_WS_MAC
-        isAllowedInMenuApplication(MenuApplicationActionType_Close);
+        isAllowedInMenuApplication(UIExtraDataMetaDefs::MenuApplicationActionType_Close);
 #else /* !Q_WS_MAC */
-        isAllowedInMenuMachine(RuntimeMenuMachineActionType_Close);
+        isAllowedInMenuMachine(UIExtraDataMetaDefs::RuntimeMenuMachineActionType_Close);
 #endif /* !Q_WS_MAC */
     pMenu->addAction(action(UIActionIndexRT_M_Machine_S_Close));
@@ -1877 +1877 @@
 
     /* 'Keyboard Settings' action: */
-    const bool fAllowToShowActionKeyboardSettings = isAllowedInMenuMachine(RuntimeMenuMachineActionType_KeyboardSettings);
+    const bool fAllowToShowActionKeyboardSettings = isAllowedInMenuMachine(UIExtraDataMetaDefs::RuntimeMenuMachineActionType_KeyboardSettings);
     action(UIActionIndexRT_M_Machine_M_Keyboard_S_Settings)->setEnabled(fAllowToShowActionKeyboardSettings);
     if (fAllowToShowActionKeyboardSettings)
@@ -1895 +1895 @@
 
     /* 'Machine Integration' action: */
-    const bool fAllowToShowActionMouseIntegration = isAllowedInMenuMachine(RuntimeMenuMachineActionType_MouseIntegration);
+    const bool fAllowToShowActionMouseIntegration = isAllowedInMenuMachine(UIExtraDataMetaDefs::RuntimeMenuMachineActionType_MouseIntegration);
     action(UIActionIndexRT_M_Machine_M_Mouse_T_Integration)->setEnabled(fAllowToShowActionMouseIntegration);
     if (fAllowToShowActionMouseIntegration)
@@ -1914 +1914 @@
 
     /* Visual representation mode flags: */
-    const bool fIsAllowToShowActionFullscreen = isAllowedInMenuView(RuntimeMenuViewActionType_Fullscreen);
-    const bool fIsAllowToShowActionSeamless   = isAllowedInMenuView(RuntimeMenuViewActionType_Seamless);
-    const bool fIsAllowToShowActionScale      = isAllowedInMenuView(RuntimeMenuViewActionType_Scale);
+    const bool fIsAllowToShowActionFullscreen = isAllowedInMenuView(UIExtraDataMetaDefs::RuntimeMenuViewActionType_Fullscreen);
+    const bool fIsAllowToShowActionSeamless   = isAllowedInMenuView(UIExtraDataMetaDefs::RuntimeMenuViewActionType_Seamless);
+    const bool fIsAllowToShowActionScale      = isAllowedInMenuView(UIExtraDataMetaDefs::RuntimeMenuViewActionType_Scale);
 
     /* 'Fullscreen' action: */
@@ -1942 +1942 @@
 
     /* 'Adjust Window' action: */
-    const bool fAllowToShowActionAdjustWindow = isAllowedInMenuView(RuntimeMenuViewActionType_AdjustWindow);
+    const bool fAllowToShowActionAdjustWindow = isAllowedInMenuView(UIExtraDataMetaDefs::RuntimeMenuViewActionType_AdjustWindow);
     action(UIActionIndexRT_M_View_S_AdjustWindow)->setEnabled(fAllowToShowActionAdjustWindow);
     if (fAllowToShowActionAdjustWindow)
@@ -1951 +1951 @@
 
     /* 'Guest Autoresize' action: */
-    const bool fAllowToShowActionGuestAutoresize = isAllowedInMenuView(RuntimeMenuViewActionType_GuestAutoresize);
+    const bool fAllowToShowActionGuestAutoresize = isAllowedInMenuView(UIExtraDataMetaDefs::RuntimeMenuViewActionType_GuestAutoresize);
     action(UIActionIndexRT_M_View_T_GuestAutoresize)->setEnabled(fAllowToShowActionGuestAutoresize);
     if (fAllowToShowActionGuestAutoresize)
@@ -1968 +1968 @@
 
     /* 'Status Bar' submenu: */
-    const bool fAllowToShowActionStatusBar = isAllowedInMenuView(RuntimeMenuViewActionType_StatusBar);
+    const bool fAllowToShowActionStatusBar = isAllowedInMenuView(UIExtraDataMetaDefs::RuntimeMenuViewActionType_StatusBar);
     action(UIActionIndexRT_M_View_M_StatusBar)->setEnabled(fAllowToShowActionStatusBar);
     if (fAllowToShowActionStatusBar)
@@ -1983 +1983 @@
 
     /* Do we have to show resize or multiscreen menu? */
-    const bool fAllowToShowActionResize = isAllowedInMenuView(RuntimeMenuViewActionType_Resize);
-    const bool fAllowToShowActionMultiscreen = isAllowedInMenuView(RuntimeMenuViewActionType_Multiscreen);
+    const bool fAllowToShowActionResize = isAllowedInMenuView(UIExtraDataMetaDefs::RuntimeMenuViewActionType_Resize);
+    const bool fAllowToShowActionMultiscreen = isAllowedInMenuView(UIExtraDataMetaDefs::RuntimeMenuViewActionType_Multiscreen);
     if (fAllowToShowActionResize && session())
     {
@@ -2030 +2030 @@
 
     /* 'Adjust Window' action: */
-    const bool fAllowToShowActionAdjustWindow = isAllowedInMenuView(RuntimeMenuViewActionType_AdjustWindow);
+    const bool fAllowToShowActionAdjustWindow = isAllowedInMenuView(UIExtraDataMetaDefs::RuntimeMenuViewActionType_AdjustWindow);
     action(UIActionIndexRT_M_View_S_AdjustWindow)->setEnabled(fAllowToShowActionAdjustWindow);
     if (fAllowToShowActionAdjustWindow)
@@ -2039 +2039 @@
 
     /* 'Guest Autoresize' action: */
-    const bool fAllowToShowActionGuestAutoresize = isAllowedInMenuView(RuntimeMenuViewActionType_GuestAutoresize);
+    const bool fAllowToShowActionGuestAutoresize = isAllowedInMenuView(UIExtraDataMetaDefs::RuntimeMenuViewActionType_GuestAutoresize);
     action(UIActionIndexRT_M_View_T_GuestAutoresize)->setEnabled(fAllowToShowActionGuestAutoresize);
     if (fAllowToShowActionGuestAutoresize)
@@ -2053 +2053 @@
 
     /* Do we have to show resize menu? */
-    const bool fAllowToShowActionResize = isAllowedInMenuView(RuntimeMenuViewActionType_Resize);
+    const bool fAllowToShowActionResize = isAllowedInMenuView(UIExtraDataMetaDefs::RuntimeMenuViewActionType_Resize);
     if (fAllowToShowActionResize && session())
     {
@@ -2080 +2080 @@
 
     /* 'Status Bar Settings' action: */
-    const bool fAllowToShowActionStatusBarSettings = isAllowedInMenuView(RuntimeMenuViewActionType_StatusBarSettings);
+    const bool fAllowToShowActionStatusBarSettings = isAllowedInMenuView(UIExtraDataMetaDefs::RuntimeMenuViewActionType_StatusBarSettings);
     action(UIActionIndexRT_M_View_M_StatusBar_S_Settings)->setEnabled(fAllowToShowActionStatusBarSettings);
     if (fAllowToShowActionStatusBarSettings)
@@ -2086 +2086 @@
 
     /* 'Toggle Status Bar' action: */
-    const bool fAllowToShowActionToggleStatusBar = isAllowedInMenuView(RuntimeMenuViewActionType_ToggleStatusBar);
+    const bool fAllowToShowActionToggleStatusBar = isAllowedInMenuView(UIExtraDataMetaDefs::RuntimeMenuViewActionType_ToggleStatusBar);
     action(UIActionIndexRT_M_View_M_StatusBar_T_Visibility)->setEnabled(fAllowToShowActionToggleStatusBar);
     if (fAllowToShowActionToggleStatusBar)
@@ -2227 +2227 @@
 
     /* 'Hard Drives' submenu: */
-    const bool fAllowToShowActionHardDrives = isAllowedInMenuDevices(RuntimeMenuDevicesActionType_HardDrives);
+    const bool fAllowToShowActionHardDrives = isAllowedInMenuDevices(UIExtraDataMetaDefs::RuntimeMenuDevicesActionType_HardDrives);
     action(UIActionIndexRT_M_Devices_M_HardDrives)->setEnabled(fAllowToShowActionHardDrives);
     if (fAllowToShowActionHardDrives)
@@ -2237 +2237 @@
 
     /* 'Optical Devices' submenu: */
-    const bool fAllowToShowActionOpticalDevices = isAllowedInMenuDevices(RuntimeMenuDevicesActionType_OpticalDevices);
+    const bool fAllowToShowActionOpticalDevices = isAllowedInMenuDevices(UIExtraDataMetaDefs::RuntimeMenuDevicesActionType_OpticalDevices);
     action(UIActionIndexRT_M_Devices_M_OpticalDevices)->setEnabled(fAllowToShowActionOpticalDevices);
     if (fAllowToShowActionOpticalDevices)
@@ -2246 +2246 @@
 
     /* 'Floppy Devices' submenu: */
-    const bool fAllowToShowActionFloppyDevices = isAllowedInMenuDevices(RuntimeMenuDevicesActionType_FloppyDevices);
+    const bool fAllowToShowActionFloppyDevices = isAllowedInMenuDevices(UIExtraDataMetaDefs::RuntimeMenuDevicesActionType_FloppyDevices);
     action(UIActionIndexRT_M_Devices_M_FloppyDevices)->setEnabled(fAllowToShowActionFloppyDevices);
     if (fAllowToShowActionFloppyDevices)
@@ -2255 +2255 @@
 
     /* 'Network' submenu: */
-    const bool fAllowToShowActionNetwork = isAllowedInMenuDevices(RuntimeMenuDevicesActionType_Network);
+    const bool fAllowToShowActionNetwork = isAllowedInMenuDevices(UIExtraDataMetaDefs::RuntimeMenuDevicesActionType_Network);
     action(UIActionIndexRT_M_Devices_M_Network)->setEnabled(fAllowToShowActionNetwork);
     if (fAllowToShowActionNetwork)
@@ -2265 +2265 @@
 
     /* 'USB Devices' submenu: */
-    const bool fAllowToShowActionUSBDevices = isAllowedInMenuDevices(RuntimeMenuDevicesActionType_USBDevices);
+    const bool fAllowToShowActionUSBDevices = isAllowedInMenuDevices(UIExtraDataMetaDefs::RuntimeMenuDevicesActionType_USBDevices);
     action(UIActionIndexRT_M_Devices_M_USBDevices)->setEnabled(fAllowToShowActionUSBDevices);
     if (fAllowToShowActionUSBDevices)
@@ -2275 +2275 @@
 
     /* 'Web Cams' submenu: */
-    const bool fAllowToShowActionWebCams = isAllowedInMenuDevices(RuntimeMenuDevicesActionType_WebCams);
+    const bool fAllowToShowActionWebCams = isAllowedInMenuDevices(UIExtraDataMetaDefs::RuntimeMenuDevicesActionType_WebCams);
     action(UIActionIndexRT_M_Devices_M_WebCams)->setEnabled(fAllowToShowActionWebCams);
     if (fAllowToShowActionWebCams)
@@ -2284 +2284 @@
 
     /* 'Shared Clipboard' submenu: */
-    const bool fAllowToShowActionSharedClipboard = isAllowedInMenuDevices(RuntimeMenuDevicesActionType_SharedClipboard);
+    const bool fAllowToShowActionSharedClipboard = isAllowedInMenuDevices(UIExtraDataMetaDefs::RuntimeMenuDevicesActionType_SharedClipboard);
     action(UIActionIndexRT_M_Devices_M_SharedClipboard)->setEnabled(fAllowToShowActionSharedClipboard);
     if (fAllowToShowActionSharedClipboard)
@@ -2293 +2293 @@
 
     /* 'Drag&Drop' submenu: */
-    const bool fAllowToShowActionDragAndDrop = isAllowedInMenuDevices(RuntimeMenuDevicesActionType_DragAndDrop);
+    const bool fAllowToShowActionDragAndDrop = isAllowedInMenuDevices(UIExtraDataMetaDefs::RuntimeMenuDevicesActionType_DragAndDrop);
     action(UIActionIndexRT_M_Devices_M_DragAndDrop)->setEnabled(fAllowToShowActionDragAndDrop);
     if (fAllowToShowActionDragAndDrop)
@@ -2302 +2302 @@
 
     /* 'Shared Folders' submenu: */
-    const bool fAllowToShowActionSharedFolders = isAllowedInMenuDevices(RuntimeMenuDevicesActionType_SharedFolders);
+    const bool fAllowToShowActionSharedFolders = isAllowedInMenuDevices(UIExtraDataMetaDefs::RuntimeMenuDevicesActionType_SharedFolders);
     action(UIActionIndexRT_M_Devices_M_SharedFolders)->setEnabled(fAllowToShowActionSharedFolders);
     if (fAllowToShowActionSharedFolders)
@@ -2320 +2320 @@
 
     /* 'VRDE Server' action: */
-    const bool fAllowToShowActionVRDEServer = isAllowedInMenuDevices(RuntimeMenuDevicesActionType_VRDEServer);
+    const bool fAllowToShowActionVRDEServer = isAllowedInMenuDevices(UIExtraDataMetaDefs::RuntimeMenuDevicesActionType_VRDEServer);
     action(UIActionIndexRT_M_Devices_T_VRDEServer)->setEnabled(fAllowToShowActionVRDEServer);
     if (fAllowToShowActionVRDEServer)
@@ -2329 +2329 @@
 
     /* 'Video Capture' action: */
-    const bool fAllowToShowActionVideoCapture = isAllowedInMenuDevices(RuntimeMenuDevicesActionType_VideoCapture);
+    const bool fAllowToShowActionVideoCapture = isAllowedInMenuDevices(UIExtraDataMetaDefs::RuntimeMenuDevicesActionType_StartVideoCapture);
     action(UIActionIndexRT_M_Devices_M_VideoCapture_T_Start)->setEnabled(fAllowToShowActionVideoCapture);
     if (fAllowToShowActionVideoCapture)
@@ -2344 +2344 @@
 
     /* Install Guest Tools action: */
-    const bool fAllowToShowActionInstallGuestTools = isAllowedInMenuDevices(RuntimeMenuDevicesActionType_InstallGuestTools);
+    const bool fAllowToShowActionInstallGuestTools = isAllowedInMenuDevices(UIExtraDataMetaDefs::RuntimeMenuDevicesActionType_InstallGuestTools);
     action(UIActionIndexRT_M_Devices_S_InstallGuestTools)->setEnabled(fAllowToShowActionInstallGuestTools);
     if (fAllowToShowActionInstallGuestTools)
@@ -2363 +2363 @@
 
     /* 'Hard Drives Settings' action: */
-    const bool fAllowToShowActionHardDrivesSettings = isAllowedInMenuDevices(RuntimeMenuDevicesActionType_HardDrivesSettings);
+    const bool fAllowToShowActionHardDrivesSettings = isAllowedInMenuDevices(UIExtraDataMetaDefs::RuntimeMenuDevicesActionType_HardDrivesSettings);
     action(UIActionIndexRT_M_Devices_M_HardDrives_S_Settings)->setEnabled(fAllowToShowActionHardDrivesSettings);
     if (fAllowToShowActionHardDrivesSettings)
@@ -2381 +2381 @@
 
     /* 'Network Settings' action: */
-    const bool fAllowToShowActionNetworkSettings = isAllowedInMenuDevices(RuntimeMenuDevicesActionType_NetworkSettings);
+    const bool fAllowToShowActionNetworkSettings = isAllowedInMenuDevices(UIExtraDataMetaDefs::RuntimeMenuDevicesActionType_NetworkSettings);
     action(UIActionIndexRT_M_Devices_M_Network_S_Settings)->setEnabled(fAllowToShowActionNetworkSettings);
     if (fAllowToShowActionNetworkSettings)
@@ -2396 +2396 @@
 
     /* 'USB Devices Settings' action: */
-    const bool fAllowToShowActionUSBDevicesSettings = isAllowedInMenuDevices(RuntimeMenuDevicesActionType_USBDevicesSettings);
+    const bool fAllowToShowActionUSBDevicesSettings = isAllowedInMenuDevices(UIExtraDataMetaDefs::RuntimeMenuDevicesActionType_USBDevicesSettings);
     action(UIActionIndexRT_M_Devices_M_USBDevices_S_Settings)->setEnabled(fAllowToShowActionUSBDevicesSettings);
     if (fAllowToShowActionUSBDevicesSettings)
@@ -2411 +2411 @@
 
     /* 'Shared Folders Settings' action: */
-    const bool fAllowToShowActionSharedFoldersSettings = isAllowedInMenuDevices(RuntimeMenuDevicesActionType_SharedFoldersSettings);
+    const bool fAllowToShowActionSharedFoldersSettings = isAllowedInMenuDevices(UIExtraDataMetaDefs::RuntimeMenuDevicesActionType_SharedFoldersSettings);
     action(UIActionIndexRT_M_Devices_M_SharedFolders_S_Settings)->setEnabled(fAllowToShowActionSharedFoldersSettings);
     if (fAllowToShowActionSharedFoldersSettings)
@@ -2429 +2429 @@
 
     /* 'Video Capture Settings' action: */
-    const bool fAllowToShowActionVideoCaptureSettings = isAllowedInMenuDevices(RuntimeMenuDevicesActionType_VideoCaptureSettings);
+    const bool fAllowToShowActionVideoCaptureSettings = isAllowedInMenuDevices(UIExtraDataMetaDefs::RuntimeMenuDevicesActionType_VideoCaptureSettings);
     action(UIActionIndexRT_M_Devices_M_VideoCapture_S_Settings)->setEnabled(fAllowToShowActionVideoCaptureSettings);
     if (fAllowToShowActionVideoCaptureSettings)
@@ -2435 +2435 @@
 
     /* 'Start Video Capture' action: */
-    const bool fAllowToShowActionStartVideoCapture = isAllowedInMenuDevices(RuntimeMenuDevicesActionType_StartVideoCapture);
+    const bool fAllowToShowActionStartVideoCapture = isAllowedInMenuDevices(UIExtraDataMetaDefs::RuntimeMenuDevicesActionType_StartVideoCapture);
     action(UIActionIndexRT_M_Devices_M_VideoCapture_S_Settings)->setEnabled(fAllowToShowActionStartVideoCapture);
     if (fAllowToShowActionStartVideoCapture)
@@ -2454 +2454 @@
 
     /* 'Statistics' action: */
-    const bool fAllowToShowActionStatistics = isAllowedInMenuDebug(RuntimeMenuDebuggerActionType_Statistics);
+    const bool fAllowToShowActionStatistics = isAllowedInMenuDebug(UIExtraDataMetaDefs::RuntimeMenuDebuggerActionType_Statistics);
     action(UIActionIndexRT_M_Debug_S_ShowStatistics)->setEnabled(fAllowToShowActionStatistics);
     if (fAllowToShowActionStatistics)
@@ -2460 +2460 @@
 
     /* 'Command Line' action: */
-    const bool fAllowToShowActionCommandLine = isAllowedInMenuDebug(RuntimeMenuDebuggerActionType_CommandLine);
+    const bool fAllowToShowActionCommandLine = isAllowedInMenuDebug(UIExtraDataMetaDefs::RuntimeMenuDebuggerActionType_CommandLine);
     action(UIActionIndexRT_M_Debug_S_ShowCommandLine)->setEnabled(fAllowToShowActionCommandLine);
     if (fAllowToShowActionCommandLine)
@@ -2466 +2466 @@
 
     /* 'Logging' action: */
-    const bool fAllowToShowActionLogging = isAllowedInMenuDebug(RuntimeMenuDebuggerActionType_Logging);
+    const bool fAllowToShowActionLogging = isAllowedInMenuDebug(UIExtraDataMetaDefs::RuntimeMenuDebuggerActionType_Logging);
     action(UIActionIndexRT_M_Debug_T_Logging)->setEnabled(fAllowToShowActionLogging);
     if (fAllowToShowActionLogging)
@@ -2472 +2472 @@
 
     /* 'Log Dialog' action: */
-    const bool fAllowToShowActionLogDialog = isAllowedInMenuDebug(RuntimeMenuDebuggerActionType_LogDialog);
+    const bool fAllowToShowActionLogDialog = isAllowedInMenuDebug(UIExtraDataMetaDefs::RuntimeMenuDebuggerActionType_LogDialog);
     action(UIActionIndex_Simple_LogDialog)->setEnabled(fAllowToShowActionLogDialog);
     if (fAllowToShowActionLogDialog)

trunk/src/VBox/Frontends/VirtualBox/src/runtime/UIActionPoolRuntime.h

@@ -143 +143 @@
 
     /** Returns whether the menu with passed @a type is allowed in menu-bar. */
-    bool isAllowedInMenuBar(RuntimeMenuType type) const;
+    bool isAllowedInMenuBar(UIExtraDataMetaDefs::RuntimeMenuType type) const;
     /** Defines menu-bar @a restriction for passed @a level. */
-    void setRestrictionForMenuBar(UIActionRestrictionLevel level, RuntimeMenuType restriction);
+    void setRestrictionForMenuBar(UIActionRestrictionLevel level, UIExtraDataMetaDefs::RuntimeMenuType restriction);
 
     /** Returns whether the action with passed @a type is allowed in the 'Machine' menu. */
-    bool isAllowedInMenuMachine(RuntimeMenuMachineActionType type) const;
+    bool isAllowedInMenuMachine(UIExtraDataMetaDefs::RuntimeMenuMachineActionType type) const;
     /** Defines 'Machine' menu @a restriction for passed @a level. */
-    void setRestrictionForMenuMachine(UIActionRestrictionLevel level, RuntimeMenuMachineActionType restriction);
+    void setRestrictionForMenuMachine(UIActionRestrictionLevel level, UIExtraDataMetaDefs::RuntimeMenuMachineActionType restriction);
 
     /** Returns whether the action with passed @a type is allowed in the 'View' menu. */
-    bool isAllowedInMenuView(RuntimeMenuViewActionType type) const;
+    bool isAllowedInMenuView(UIExtraDataMetaDefs::RuntimeMenuViewActionType type) const;
     /** Defines 'View' menu @a restriction for passed @a level. */
-    void setRestrictionForMenuView(UIActionRestrictionLevel level, RuntimeMenuViewActionType restriction);
+    void setRestrictionForMenuView(UIActionRestrictionLevel level, UIExtraDataMetaDefs::RuntimeMenuViewActionType restriction);
 
     /** Returns whether the action with passed @a type is allowed in the 'Devices' menu. */
-    bool isAllowedInMenuDevices(RuntimeMenuDevicesActionType type) const;
+    bool isAllowedInMenuDevices(UIExtraDataMetaDefs::RuntimeMenuDevicesActionType type) const;
     /** Defines 'Devices' menu @a restriction for passed @a level. */
-    void setRestrictionForMenuDevices(UIActionRestrictionLevel level, RuntimeMenuDevicesActionType restriction);
+    void setRestrictionForMenuDevices(UIActionRestrictionLevel level, UIExtraDataMetaDefs::RuntimeMenuDevicesActionType restriction);
 
 #ifdef VBOX_WITH_DEBUGGER_GUI
     /** Returns whether the action with passed @a type is allowed in the 'Debug' menu. */
-    bool isAllowedInMenuDebug(RuntimeMenuDebuggerActionType type) const;
+    bool isAllowedInMenuDebug(UIExtraDataMetaDefs::RuntimeMenuDebuggerActionType type) const;
     /** Defines 'Debug' menu @a restriction for passed @a level. */
-    void setRestrictionForMenuDebugger(UIActionRestrictionLevel level, RuntimeMenuDebuggerActionType restriction);
+    void setRestrictionForMenuDebugger(UIActionRestrictionLevel level, UIExtraDataMetaDefs::RuntimeMenuDebuggerActionType restriction);
 #endif /* VBOX_WITH_DEBUGGER_GUI */
 
@@ -254 +254 @@
     UIMultiScreenLayout *m_pMultiScreenLayout;
 
-    /** Holds the list of main-menus. */
+    /** Holds the list of Runtime UI main menus. */
     QList<QMenu*> m_mainMenus;
 
     /** Holds restricted menu types. */
-    QMap<UIActionRestrictionLevel, RuntimeMenuType> m_restrictedMenus;
+    QMap<UIActionRestrictionLevel, UIExtraDataMetaDefs::RuntimeMenuType> m_restrictedMenus;
     /** Holds restricted action types of the Machine menu. */
-    QMap<UIActionRestrictionLevel, RuntimeMenuMachineActionType> m_restrictedActionsMenuMachine;
+    QMap<UIActionRestrictionLevel, UIExtraDataMetaDefs::RuntimeMenuMachineActionType> m_restrictedActionsMenuMachine;
     /** Holds restricted action types of the View menu. */
-    QMap<UIActionRestrictionLevel, RuntimeMenuViewActionType> m_restrictedActionsMenuView;
+    QMap<UIActionRestrictionLevel, UIExtraDataMetaDefs::RuntimeMenuViewActionType> m_restrictedActionsMenuView;
     /** Holds restricted action types of the Devices menu. */
-    QMap<UIActionRestrictionLevel, RuntimeMenuDevicesActionType> m_restrictedActionsMenuDevices;
+    QMap<UIActionRestrictionLevel, UIExtraDataMetaDefs::RuntimeMenuDevicesActionType> m_restrictedActionsMenuDevices;
 #ifdef VBOX_WITH_DEBUGGER_GUI
     /** Holds restricted action types of the Debugger menu. */
-    QMap<UIActionRestrictionLevel, RuntimeMenuDebuggerActionType> m_restrictedActionsMenuDebug;
+    QMap<UIActionRestrictionLevel, UIExtraDataMetaDefs::RuntimeMenuDebuggerActionType> m_restrictedActionsMenuDebug;
 #endif /* VBOX_WITH_DEBUGGER_GUI */
 

trunk/src/VBox/Frontends/VirtualBox/src/runtime/UISession.cpp

@@ -1000 +1000 @@
     const CHost host = vboxGlobal().host();
     const CMachine machine = session().GetConsole().GetMachine();
-    RuntimeMenuDevicesActionType restriction = RuntimeMenuDevicesActionType_Invalid;
+    UIExtraDataMetaDefs::RuntimeMenuDevicesActionType restriction = UIExtraDataMetaDefs::RuntimeMenuDevicesActionType_Invalid;
 
     /* Storage stuff: */
@@ -1019 +1019 @@
         pFloppyDevicesMenu->setData(iDevicesCountFD);
         if (!iDevicesCountCD)
-            restriction = (RuntimeMenuDevicesActionType)(restriction | RuntimeMenuDevicesActionType_OpticalDevices);
+            restriction = (UIExtraDataMetaDefs::RuntimeMenuDevicesActionType)(restriction | UIExtraDataMetaDefs::RuntimeMenuDevicesActionType_OpticalDevices);
         if (!iDevicesCountFD)
-            restriction = (RuntimeMenuDevicesActionType)(restriction | RuntimeMenuDevicesActionType_FloppyDevices);
+            restriction = (UIExtraDataMetaDefs::RuntimeMenuDevicesActionType)(restriction | UIExtraDataMetaDefs::RuntimeMenuDevicesActionType_FloppyDevices);
     }
 
@@ -1040 +1040 @@
         }
         if (!fAtLeastOneAdapterActive)
-            restriction = (RuntimeMenuDevicesActionType)(restriction | RuntimeMenuDevicesActionType_Network);
+            restriction = (UIExtraDataMetaDefs::RuntimeMenuDevicesActionType)(restriction | UIExtraDataMetaDefs::RuntimeMenuDevicesActionType_Network);
     }
 
@@ -1050 +1050 @@
                                  && machine.GetUSBProxyAvailable();
         if (!fUSBEnabled)
-            restriction = (RuntimeMenuDevicesActionType)(restriction | RuntimeMenuDevicesActionType_USBDevices);
+            restriction = (UIExtraDataMetaDefs::RuntimeMenuDevicesActionType)(restriction | UIExtraDataMetaDefs::RuntimeMenuDevicesActionType_USBDevices);
     }
 
@@ -1059 +1059 @@
         const bool fWebCamsEnabled = host.isOk() && !machine.GetUSBControllers().isEmpty();
         if (!fWebCamsEnabled)
-            restriction = (RuntimeMenuDevicesActionType)(restriction | RuntimeMenuDevicesActionType_WebCams);
+            restriction = (UIExtraDataMetaDefs::RuntimeMenuDevicesActionType)(restriction | UIExtraDataMetaDefs::RuntimeMenuDevicesActionType_WebCams);
     }
 

trunk/src/VBox/Frontends/VirtualBox/src/runtime/fullscreen/UIMachineLogicFullscreen.cpp

@@ -463 +463 @@
     /* Restrict 'Adjust Window', 'Status Bar' and 'Resize' actions for 'View' menu: */
     actionPool()->toRuntime()->setRestrictionForMenuView(UIActionRestrictionLevel_Logic,
-                                                         (RuntimeMenuViewActionType)
-                                                         (RuntimeMenuViewActionType_AdjustWindow |
-                                                          RuntimeMenuViewActionType_StatusBar |
-                                                          RuntimeMenuViewActionType_Resize));
+                                                         (UIExtraDataMetaDefs::RuntimeMenuViewActionType)
+                                                         (UIExtraDataMetaDefs::RuntimeMenuViewActionType_AdjustWindow |
+                                                          UIExtraDataMetaDefs::RuntimeMenuViewActionType_StatusBar |
+                                                          UIExtraDataMetaDefs::RuntimeMenuViewActionType_Resize));
 
     /* Take care of view-action toggle state: */
@@ -638 +638 @@
     /* Allow 'Adjust Window', 'Status Bar' and 'Resize' actions for 'View' menu: */
     actionPool()->toRuntime()->setRestrictionForMenuView(UIActionRestrictionLevel_Logic,
-                                                         RuntimeMenuViewActionType_Invalid);
+                                                         UIExtraDataMetaDefs::RuntimeMenuViewActionType_Invalid);
 
     /* Call to base-class: */

trunk/src/VBox/Frontends/VirtualBox/src/runtime/scale/UIMachineLogicScale.cpp

@@ -75 +75 @@
     /* Restrict 'Adjust Window', 'Guest Autoresize', 'Status Bar' and 'Resize' actions for 'View' menu: */
     actionPool()->toRuntime()->setRestrictionForMenuView(UIActionRestrictionLevel_Logic,
-                                                         (RuntimeMenuViewActionType)
-                                                         (RuntimeMenuViewActionType_AdjustWindow |
-                                                          RuntimeMenuViewActionType_GuestAutoresize |
-                                                          RuntimeMenuViewActionType_StatusBar |
-                                                          RuntimeMenuViewActionType_Resize));
+                                                         (UIExtraDataMetaDefs::RuntimeMenuViewActionType)
+                                                         (UIExtraDataMetaDefs::RuntimeMenuViewActionType_AdjustWindow |
+                                                          UIExtraDataMetaDefs::RuntimeMenuViewActionType_GuestAutoresize |
+                                                          UIExtraDataMetaDefs::RuntimeMenuViewActionType_StatusBar |
+                                                          UIExtraDataMetaDefs::RuntimeMenuViewActionType_Resize));
 
     /* Take care of view-action toggle state: */
@@ -201 +201 @@
     /* Allow 'Adjust Window', 'Guest Autoresize', 'Status Bar' and 'Resize' actions for 'View' menu: */
     actionPool()->toRuntime()->setRestrictionForMenuView(UIActionRestrictionLevel_Logic,
-                                                         RuntimeMenuViewActionType_Invalid);
+                                                         UIExtraDataMetaDefs::RuntimeMenuViewActionType_Invalid);
 
     /* Call to base-class: */

trunk/src/VBox/Frontends/VirtualBox/src/runtime/seamless/UIMachineLogicSeamless.cpp

@@ -205 +205 @@
     /* Restrict 'Disable Mouse Integration' action for 'Machine' menu: */
     actionPool()->toRuntime()->setRestrictionForMenuMachine(UIActionRestrictionLevel_Logic,
-                                                            RuntimeMenuMachineActionType_MouseIntegration);
+                                                            UIExtraDataMetaDefs::RuntimeMenuMachineActionType_MouseIntegration);
     /* Restrict 'Adjust Window', 'Guest Autoresize', 'Status Bar' and 'Resize' actions for 'View' menu: */
     actionPool()->toRuntime()->setRestrictionForMenuView(UIActionRestrictionLevel_Logic,
-                                                         (RuntimeMenuViewActionType)
-                                                         (RuntimeMenuViewActionType_AdjustWindow |
-                                                          RuntimeMenuViewActionType_GuestAutoresize |
-                                                          RuntimeMenuViewActionType_StatusBar |
-                                                          RuntimeMenuViewActionType_Resize));
+                                                         (UIExtraDataMetaDefs::RuntimeMenuViewActionType)
+                                                         (UIExtraDataMetaDefs::RuntimeMenuViewActionType_AdjustWindow |
+                                                          UIExtraDataMetaDefs::RuntimeMenuViewActionType_GuestAutoresize |
+                                                          UIExtraDataMetaDefs::RuntimeMenuViewActionType_StatusBar |
+                                                          UIExtraDataMetaDefs::RuntimeMenuViewActionType_Resize));
 
     /* Take care of view-action toggle state: */
@@ -335 +335 @@
     /* Allow 'Disable Mouse Integration' action for 'Machine' menu: */
     actionPool()->toRuntime()->setRestrictionForMenuMachine(UIActionRestrictionLevel_Logic,
-                                                            RuntimeMenuMachineActionType_Invalid);
+                                                            UIExtraDataMetaDefs::RuntimeMenuMachineActionType_Invalid);
     /* Allow 'Adjust Window', 'Guest Autoresize', 'Status Bar' and 'Resize' actions for 'View' menu: */
     actionPool()->toRuntime()->setRestrictionForMenuView(UIActionRestrictionLevel_Logic,
-                                                         RuntimeMenuViewActionType_Invalid);
+                                                         UIExtraDataMetaDefs::RuntimeMenuViewActionType_Invalid);
 
     /* Call to base-class: */

trunk/src/VBox/Frontends/VirtualBox/src/selector/UIActionPoolSelector.h

@@ -111 +111 @@
     virtual QString shortcutsExtraDataID() const;
 
-    /** Returns the list of Runtime UI main menus. */
+    /** Returns the list of Selector UI main menus. */
     virtual QList<QMenu*> menus() const { return QList<QMenu*>(); }