Changeset 75016 in vbox for trunk/src/VBox

Timestamp:

Oct 23, 2018 7:42:38 PM (6 years ago)

Author:

vboxsync

Message:

FE/Qt: bugref:9241: Merge UIToolsType, ToolTypeGlobal and ToolTypeMachine into one enum UIToolType; Rename UIToolsClass to UIToolClass.

Location:

trunk/src/VBox/Frontends/VirtualBox/src

Files:

• converter/UIConverterBackend.h (modified) (2 diffs)
• converter/UIConverterBackendGlobal.cpp (modified) (2 diffs)
• extradata/UIExtraDataDefs.h (modified) (1 diff)
• extradata/UIExtraDataManager.cpp (modified) (1 diff)
• extradata/UIExtraDataManager.h (modified) (1 diff)
• manager/UIToolPaneGlobal.cpp (modified) (12 diffs)
• manager/UIToolPaneGlobal.h (modified) (1 diff)
• manager/UIToolPaneMachine.cpp (modified) (15 diffs)
• manager/UIToolPaneMachine.h (modified) (1 diff)
• manager/UIVirtualBoxManager.cpp (modified) (7 diffs)
• manager/UIVirtualBoxManagerWidget.cpp (modified) (20 diffs)
• manager/UIVirtualBoxManagerWidget.h (modified) (2 diffs)
• manager/chooser/UIChooser.cpp (modified) (1 diff)
• manager/chooser/UIChooser.h (modified) (2 diffs)
• manager/chooser/UIChooserModel.cpp (modified) (1 diff)
• manager/chooser/UIChooserModel.h (modified) (1 diff)
• manager/tools/UITools.cpp (modified) (1 diff)
• manager/tools/UITools.h (modified) (1 diff)
• manager/tools/UIToolsItem.cpp (modified) (3 diffs)
• manager/tools/UIToolsItem.h (modified) (3 diffs)
• manager/tools/UIToolsModel.cpp (modified) (13 diffs)
• manager/tools/UIToolsModel.h (modified) (3 diffs)

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

@@ -89 +89 @@
 template<> SHARED_LIBRARY_STUFF bool canConvert<UIExtraDataMetaDefs::MenuWindowActionType>();
 #endif /* VBOX_WS_MAC */
-template<> SHARED_LIBRARY_STUFF bool canConvert<ToolTypeMachine>();
-template<> SHARED_LIBRARY_STUFF bool canConvert<ToolTypeGlobal>();
+template<> SHARED_LIBRARY_STUFF bool canConvert<UIToolType>();
 template<> SHARED_LIBRARY_STUFF bool canConvert<UIVisualStateType>();
 template<> SHARED_LIBRARY_STUFF bool canConvert<DetailsElementType>();
@@ -165 +164 @@
 template<> SHARED_LIBRARY_STUFF UIExtraDataMetaDefs::MenuWindowActionType fromInternalString<UIExtraDataMetaDefs::MenuWindowActionType>(const QString &strMenuWindowActionType);
 #endif /* VBOX_WS_MAC */
-template<> SHARED_LIBRARY_STUFF QString toInternalString(const ToolTypeMachine &enmToolTypeMachine);
-template<> SHARED_LIBRARY_STUFF ToolTypeMachine fromInternalString<ToolTypeMachine>(const QString &strToolTypeMachine);
-template<> SHARED_LIBRARY_STUFF QString toInternalString(const ToolTypeGlobal &enmToolTypeGlobal);
-template<> SHARED_LIBRARY_STUFF ToolTypeGlobal fromInternalString<ToolTypeGlobal>(const QString &strToolTypeGlobal);
+template<> SHARED_LIBRARY_STUFF QString toInternalString(const UIToolType &enmToolType);
+template<> SHARED_LIBRARY_STUFF UIToolType fromInternalString<UIToolType>(const QString &strToolType);
 template<> SHARED_LIBRARY_STUFF QString toInternalString(const UIVisualStateType &visualStateType);
 template<> SHARED_LIBRARY_STUFF UIVisualStateType fromInternalString<UIVisualStateType>(const QString &strVisualStateType);

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

@@ -53 +53 @@
 template<> bool canConvert<UIExtraDataMetaDefs::MenuWindowActionType>() { return true; }
 #endif /* VBOX_WS_MAC */
-template<> bool canConvert<ToolTypeMachine>() { return true; }
-template<> bool canConvert<ToolTypeGlobal>() { return true; }
+template<> bool canConvert<UIToolType>() { return true; }
 template<> bool canConvert<UIVisualStateType>() { return true; }
 template<> bool canConvert<DetailsElementType>() { return true; }
@@ -867 +866 @@
 #endif /* VBOX_WS_MAC */
 
-/* QString <= ToolTypeMachine: */
-template<> QString toInternalString(const ToolTypeMachine &enmToolTypeMachine)
-{
-    QString strResult;
-    switch (enmToolTypeMachine)
-    {
-        case ToolTypeMachine_Details:   strResult = "Details"; break;
-        case ToolTypeMachine_Snapshots: strResult = "Snapshots"; break;
-        case ToolTypeMachine_Logs:      strResult = "Logs"; break;
-        default:
-        {
-            AssertMsgFailed(("No text for machine tool type=%d", enmToolTypeMachine));
-            break;
-        }
-    }
-    return strResult;
-}
-
-/* ToolTypeMachine <= QString: */
-template<> ToolTypeMachine fromInternalString<ToolTypeMachine>(const QString &strToolTypeMachine)
-{
-    /* Here we have some fancy stuff allowing us
-     * to search through the keys using 'case-insensitive' rule: */
-    QStringList keys;    QList<ToolTypeMachine> values;
-    keys << "Details";   values << ToolTypeMachine_Details;
-    keys << "Snapshots"; values << ToolTypeMachine_Snapshots;
-    keys << "Logs";      values << ToolTypeMachine_Logs;
-    /* Invalid type for unknown words: */
-    if (!keys.contains(strToolTypeMachine, Qt::CaseInsensitive))
-        return ToolTypeMachine_Invalid;
-    /* Corresponding type for known words: */
-    return values.at(keys.indexOf(QRegExp(strToolTypeMachine, Qt::CaseInsensitive)));
-}
-
-/* QString <= ToolTypeGlobal: */
-template<> QString toInternalString(const ToolTypeGlobal &enmToolTypeGlobal)
-{
-    QString strResult;
-    switch (enmToolTypeGlobal)
-    {
-        case ToolTypeGlobal_Welcome: strResult = "Welcome"; break;
-        case ToolTypeGlobal_Media:   strResult = "Media"; break;
-        case ToolTypeGlobal_Network: strResult = "Network"; break;
-        case ToolTypeGlobal_Cloud:   strResult = "Cloud"; break;
-        default:
-        {
-            AssertMsgFailed(("No text for global tool type=%d", enmToolTypeGlobal));
-            break;
-        }
-    }
-    return strResult;
-}
-
-/* ToolTypeGlobal <= QString: */
-template<> ToolTypeGlobal fromInternalString<ToolTypeGlobal>(const QString &strToolTypeGlobal)
-{
-    /* Here we have some fancy stuff allowing us
-     * to search through the keys using 'case-insensitive' rule: */
-    QStringList keys;       QList<ToolTypeGlobal> values;
-    keys << "Welcome"; values << ToolTypeGlobal_Welcome;
-    keys << "Media";   values << ToolTypeGlobal_Media;
-    keys << "Network"; values << ToolTypeGlobal_Network;
-    keys << "Cloud";   values << ToolTypeGlobal_Cloud;
-    /* Invalid type for unknown words: */
-    if (!keys.contains(strToolTypeGlobal, Qt::CaseInsensitive))
-        return ToolTypeGlobal_Invalid;
-    /* Corresponding type for known words: */
-    return values.at(keys.indexOf(QRegExp(strToolTypeGlobal, Qt::CaseInsensitive)));
+/* QString <= UIToolType: */
+template<> QString toInternalString(const UIToolType &enmToolType)
+{
+    QString strResult;
+    switch (enmToolType)
+    {
+        case UIToolType_Welcome:   strResult = "Welcome"; break;
+        case UIToolType_Media:     strResult = "Media"; break;
+        case UIToolType_Network:   strResult = "Network"; break;
+        case UIToolType_Cloud:     strResult = "Cloud"; break;
+        case UIToolType_Details:   strResult = "Details"; break;
+        case UIToolType_Snapshots: strResult = "Snapshots"; break;
+        case UIToolType_Logs:      strResult = "Logs"; break;
+        default:
+        {
+            AssertMsgFailed(("No text for tool type=%d", enmToolType));
+            break;
+        }
+    }
+    return strResult;
+}
+
+/* UIToolType <= QString: */
+template<> UIToolType fromInternalString<UIToolType>(const QString &strToolType)
+{
+    /* Here we have some fancy stuff allowing us
+     * to search through the keys using 'case-insensitive' rule: */
+    QStringList keys;    QList<UIToolType> values;
+    keys << "Welcome";   values << UIToolType_Welcome;
+    keys << "Media";     values << UIToolType_Media;
+    keys << "Network";   values << UIToolType_Network;
+    keys << "Cloud";     values << UIToolType_Cloud;
+    keys << "Details";   values << UIToolType_Details;
+    keys << "Snapshots"; values << UIToolType_Snapshots;
+    keys << "Logs";      values << UIToolType_Logs;
+    /* Invalid type for unknown words: */
+    if (!keys.contains(strToolType, Qt::CaseInsensitive))
+        return UIToolType_Invalid;
+    /* Corresponding type for known words: */
+    return values.at(keys.indexOf(QRegExp(strToolType, Qt::CaseInsensitive)));
 }
 

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

@@ -660 +660 @@
 
 /** Tool item classes. */
-enum UIToolsClass
-{
-    UIToolsClass_Invalid,
-    UIToolsClass_Global,
-    UIToolsClass_Machine
+enum UIToolClass
+{
+    UIToolClass_Invalid,
+    UIToolClass_Global,
+    UIToolClass_Machine
 };
 
 
 /** Tool item types. */
-enum UIToolsType
-{
-    UIToolsType_Invalid,
+enum UIToolType
+{
+    UIToolType_Invalid,
     /* Global types: */
-    UIToolsType_Welcome,
-    UIToolsType_Media,
-    UIToolsType_Network,
-    UIToolsType_Cloud,
+    UIToolType_Welcome,
+    UIToolType_Media,
+    UIToolType_Network,
+    UIToolType_Cloud,
     /* Machine types: */
-    UIToolsType_Details,
-    UIToolsType_Snapshots,
-    UIToolsType_Logs,
-};
-
-
-/** Selector UI: Global tool types. */
-enum ToolTypeGlobal
-{
-    ToolTypeGlobal_Invalid,
-    ToolTypeGlobal_Welcome,
-    ToolTypeGlobal_Media,
-    ToolTypeGlobal_Network,
-    ToolTypeGlobal_Cloud,
-};
-Q_DECLARE_METATYPE(ToolTypeGlobal);
-
-
-/** Selector UI: Machine tool types. */
-enum ToolTypeMachine
-{
-    ToolTypeMachine_Invalid,
-    ToolTypeMachine_Error,
-    ToolTypeMachine_Details,
-    ToolTypeMachine_Snapshots,
-    ToolTypeMachine_Logs
-};
-Q_DECLARE_METATYPE(ToolTypeMachine);
+    UIToolType_Error,
+    UIToolType_Details,
+    UIToolType_Snapshots,
+    UIToolType_Logs,
+};
+Q_DECLARE_METATYPE(UIToolType);
 
 

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

@@ -2737 +2737 @@
 }
 
-QList<ToolTypeMachine> UIExtraDataManager::selectorWindowToolsOrderMachine()
-{
-    /* Prepare result: */
-    QList<ToolTypeMachine> aLoadedOrder;
-    /* Get machine tools order: */
-    foreach (const QString &strValue, extraDataStringList(GUI_Toolbar_MachineTools_Order))
-    {
-        const ToolTypeMachine enmValue = gpConverter->fromInternalString<ToolTypeMachine>(strValue);
-        if (!aLoadedOrder.contains(enmValue))
-            aLoadedOrder << enmValue;
-    }
-
-    /* If the list is empty => add 'Details' at least: */
-    if (aLoadedOrder.isEmpty())
-        aLoadedOrder << ToolTypeMachine_Details;
-
-    /* Return result: */
-    return aLoadedOrder;
-}
-
-void UIExtraDataManager::setSelectorWindowToolsOrderMachine(const QList<ToolTypeMachine> &aOrder)
-{
-    /* Parse passed list: */
-    QStringList aSavedOrder;
-    foreach (const ToolTypeMachine &enmToolType, aOrder)
-        aSavedOrder << gpConverter->toInternalString(enmToolType);
-
-    /* If the list is empty => add 'None' at least: */
-    if (aSavedOrder.isEmpty())
-        aSavedOrder << gpConverter->toInternalString(ToolTypeMachine_Invalid);
-
-    /* Re-cache corresponding extra-data: */
-    setExtraDataStringList(GUI_Toolbar_MachineTools_Order, aSavedOrder);
-}
-
-QList<ToolTypeGlobal> UIExtraDataManager::selectorWindowToolsOrderGlobal()
-{
-    /* Prepare result: */
-    QList<ToolTypeGlobal> aLoadedOrder;
-    /* Get global tools order: */
-    foreach (const QString &strValue, extraDataStringList(GUI_Toolbar_GlobalTools_Order))
-    {
-        const ToolTypeGlobal enmValue = gpConverter->fromInternalString<ToolTypeGlobal>(strValue);
-        if (enmValue != ToolTypeGlobal_Invalid && !aLoadedOrder.contains(enmValue))
-            aLoadedOrder << enmValue;
-    }
-
-    /* Return result: */
-    return aLoadedOrder;
-}
-
-void UIExtraDataManager::setSelectorWindowToolsOrderGlobal(const QList<ToolTypeGlobal> &aOrder)
-{
-    /* Parse passed list: */
-    QStringList aSavedOrder;
-    foreach (const ToolTypeGlobal &enmToolType, aOrder)
-        aSavedOrder << gpConverter->toInternalString(enmToolType);
-
-    /* Re-cache corresponding extra-data: */
-    setExtraDataStringList(GUI_Toolbar_GlobalTools_Order, aSavedOrder);
-}
-
 QString UIExtraDataManager::toolsPaneLastItemsChosen()
 {

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

@@ -309 +309 @@
         /** Defines whether selector-window tool-bar text @a fVisible. */
         void setSelectorWindowToolBarTextVisible(bool fVisible);
-
-        /** Returns selector-window machine tools order. */
-        QList<ToolTypeMachine> selectorWindowToolsOrderMachine();
-        /** Defines selector-window machine tools @a aOrder. */
-        void setSelectorWindowToolsOrderMachine(const QList<ToolTypeMachine> &aOrder);
-
-        /** Returns selector-window global tools order. */
-        QList<ToolTypeGlobal> selectorWindowToolsOrderGlobal();
-        /** Defines selector-window global tools @a aOrder. */
-        void setSelectorWindowToolsOrderGlobal(const QList<ToolTypeGlobal> &aOrder);
 
         /** Returns last selected tool set of VirtualBox Manager. */

trunk/src/VBox/Frontends/VirtualBox/src/manager/UIToolPaneGlobal.cpp

@@ -60 +60 @@
 }
 
-ToolTypeGlobal UIToolPaneGlobal::currentTool() const
-{
-    return m_pLayout->currentWidget()->property("ToolType").value<ToolTypeGlobal>();
-}
-
-bool UIToolPaneGlobal::isToolOpened(ToolTypeGlobal enmType) const
+UIToolType UIToolPaneGlobal::currentTool() const
+{
+    return m_pLayout->currentWidget()->property("ToolType").value<UIToolType>();
+}
+
+bool UIToolPaneGlobal::isToolOpened(UIToolType enmType) const
 {
     /* Search through the stacked widgets: */
     for (int iIndex = 0; iIndex < m_pLayout->count(); ++iIndex)
-        if (m_pLayout->widget(iIndex)->property("ToolType").value<ToolTypeGlobal>() == enmType)
+        if (m_pLayout->widget(iIndex)->property("ToolType").value<UIToolType>() == enmType)
             return true;
     return false;
 }
 
-void UIToolPaneGlobal::openTool(ToolTypeGlobal enmType)
+void UIToolPaneGlobal::openTool(UIToolType enmType)
 {
     /* Search through the stacked widgets: */
     int iActualIndex = -1;
     for (int iIndex = 0; iIndex < m_pLayout->count(); ++iIndex)
-        if (m_pLayout->widget(iIndex)->property("ToolType").value<ToolTypeGlobal>() == enmType)
+        if (m_pLayout->widget(iIndex)->property("ToolType").value<UIToolType>() == enmType)
             iActualIndex = iIndex;
 
@@ -94 +94 @@
         switch (enmType)
         {
-            case ToolTypeGlobal_Welcome:
+            case UIToolType_Welcome:
             {
                 /* Create Desktop pane: */
@@ -101 +101 @@
                 {
                     /* Configure pane: */
-                    m_pPaneWelcome->setProperty("ToolType", QVariant::fromValue(ToolTypeGlobal_Welcome));
+                    m_pPaneWelcome->setProperty("ToolType", QVariant::fromValue(UIToolType_Welcome));
 
                     /* Add into layout: */
@@ -109 +109 @@
                 break;
             }
-            case ToolTypeGlobal_Media:
+            case UIToolType_Media:
             {
                 /* Create Virtual Media Manager: */
@@ -121 +121 @@
 
                     /* Configure pane: */
-                    m_pPaneMedia->setProperty("ToolType", QVariant::fromValue(ToolTypeGlobal_Media));
+                    m_pPaneMedia->setProperty("ToolType", QVariant::fromValue(UIToolType_Media));
 
                     /* Add into layout: */
@@ -129 +129 @@
                 break;
             }
-            case ToolTypeGlobal_Network:
+            case UIToolType_Network:
             {
                 /* Create Host Network Manager: */
@@ -141 +141 @@
 
                     /* Configure pane: */
-                    m_pPaneNetwork->setProperty("ToolType", QVariant::fromValue(ToolTypeGlobal_Network));
+                    m_pPaneNetwork->setProperty("ToolType", QVariant::fromValue(UIToolType_Network));
 
                     /* Add into layout: */
@@ -149 +149 @@
                 break;
             }
-            case ToolTypeGlobal_Cloud:
+            case UIToolType_Cloud:
             {
                 /* Create Cloud Profile Manager: */
@@ -161 +161 @@
 
                     /* Configure pane: */
-                    m_pPaneCloud->setProperty("ToolType", QVariant::fromValue(ToolTypeGlobal_Cloud));
+                    m_pPaneCloud->setProperty("ToolType", QVariant::fromValue(UIToolType_Cloud));
 
                     /* Add into layout: */
@@ -175 +175 @@
 }
 
-void UIToolPaneGlobal::closeTool(ToolTypeGlobal enmType)
+void UIToolPaneGlobal::closeTool(UIToolType enmType)
 {
     /* Search through the stacked widgets: */
     int iActualIndex = -1;
     for (int iIndex = 0; iIndex < m_pLayout->count(); ++iIndex)
-        if (m_pLayout->widget(iIndex)->property("ToolType").value<ToolTypeGlobal>() == enmType)
+        if (m_pLayout->widget(iIndex)->property("ToolType").value<UIToolType>() == enmType)
             iActualIndex = iIndex;
 
@@ -189 +189 @@
         switch (enmType)
         {
-            case ToolTypeGlobal_Welcome: m_pPaneWelcome = 0; break;
-            case ToolTypeGlobal_Media:   m_pPaneMedia = 0; break;
-            case ToolTypeGlobal_Network: m_pPaneNetwork = 0; break;
-            case ToolTypeGlobal_Cloud:   m_pPaneCloud = 0; break;
+            case UIToolType_Welcome: m_pPaneWelcome = 0; break;
+            case UIToolType_Media:   m_pPaneMedia = 0; break;
+            case UIToolType_Network: m_pPaneNetwork = 0; break;
+            case UIToolType_Cloud:   m_pPaneCloud = 0; break;
             default: break;
         }
@@ -208 +208 @@
 
     /* Create desktop pane: */
-    openTool(ToolTypeGlobal_Welcome);
+    openTool(UIToolType_Welcome);
 }
 

trunk/src/VBox/Frontends/VirtualBox/src/manager/UIToolPaneGlobal.h

@@ -51 +51 @@
 
     /** Returns type of tool currently opened. */
-    ToolTypeGlobal currentTool() const;
+    UIToolType currentTool() const;
     /** Returns whether tool of particular @a enmType is opened. */
-    bool isToolOpened(ToolTypeGlobal enmType) const;
+    bool isToolOpened(UIToolType enmType) const;
     /** Activates tool of passed @a enmType, creates new one if necessary. */
-    void openTool(ToolTypeGlobal enmType);
+    void openTool(UIToolType enmType);
     /** Closes tool of passed @a enmType, deletes one if exists. */
-    void closeTool(ToolTypeGlobal enmType);
+    void closeTool(UIToolType enmType);
 
 private:

trunk/src/VBox/Frontends/VirtualBox/src/manager/UIToolPaneMachine.cpp

@@ -63 +63 @@
 }
 
-ToolTypeMachine UIToolPaneMachine::currentTool() const
-{
-    return m_pLayout->currentWidget()->property("ToolType").value<ToolTypeMachine>();
-}
-
-bool UIToolPaneMachine::isToolOpened(ToolTypeMachine enmType) const
+UIToolType UIToolPaneMachine::currentTool() const
+{
+    return m_pLayout->currentWidget()->property("ToolType").value<UIToolType>();
+}
+
+bool UIToolPaneMachine::isToolOpened(UIToolType enmType) const
 {
     /* Search through the stacked widgets: */
     for (int iIndex = 0; iIndex < m_pLayout->count(); ++iIndex)
-        if (m_pLayout->widget(iIndex)->property("ToolType").value<ToolTypeMachine>() == enmType)
+        if (m_pLayout->widget(iIndex)->property("ToolType").value<UIToolType>() == enmType)
             return true;
     return false;
 }
 
-void UIToolPaneMachine::openTool(ToolTypeMachine enmType)
+void UIToolPaneMachine::openTool(UIToolType enmType)
 {
     /* Search through the stacked widgets: */
     int iActualIndex = -1;
     for (int iIndex = 0; iIndex < m_pLayout->count(); ++iIndex)
-        if (m_pLayout->widget(iIndex)->property("ToolType").value<ToolTypeMachine>() == enmType)
+        if (m_pLayout->widget(iIndex)->property("ToolType").value<UIToolType>() == enmType)
             iActualIndex = iIndex;
 
@@ -97 +97 @@
         switch (enmType)
         {
-            case ToolTypeMachine_Error:
+            case UIToolType_Error:
             {
                 /* Create Desktop pane: */
@@ -104 +104 @@
                 {
                     /* Configure pane: */
-                    m_pPaneError->setProperty("ToolType", QVariant::fromValue(ToolTypeMachine_Error));
+                    m_pPaneError->setProperty("ToolType", QVariant::fromValue(UIToolType_Error));
 
                     /* Add into layout: */
@@ -112 +112 @@
                 break;
             }
-            case ToolTypeMachine_Details:
+            case UIToolType_Details:
             {
                 /* Create Details pane: */
@@ -119 +119 @@
                 {
                     /* Configure pane: */
-                    m_pPaneDetails->setProperty("ToolType", QVariant::fromValue(ToolTypeMachine_Details));
+                    m_pPaneDetails->setProperty("ToolType", QVariant::fromValue(UIToolType_Details));
                     connect(this, &UIToolPaneMachine::sigSlidingStarted, m_pPaneDetails, &UIDetails::sigSlidingStarted);
                     connect(this, &UIToolPaneMachine::sigToggleStarted,  m_pPaneDetails, &UIDetails::sigToggleStarted);
@@ -131 +131 @@
                 break;
             }
-            case ToolTypeMachine_Snapshots:
+            case UIToolType_Snapshots:
             {
                 /* Create Snapshots pane: */
@@ -143 +143 @@
 
                     /* Configure pane: */
-                    m_pPaneSnapshots->setProperty("ToolType", QVariant::fromValue(ToolTypeMachine_Snapshots));
+                    m_pPaneSnapshots->setProperty("ToolType", QVariant::fromValue(UIToolType_Snapshots));
 
                     /* Add into layout: */
@@ -151 +151 @@
                 break;
             }
-            case ToolTypeMachine_Logs:
+            case UIToolType_Logs:
             {
                 /* Create the Logviewer pane: */
@@ -163 +163 @@
 
                     /* Configure pane: */
-                    m_pPaneLogViewer->setProperty("ToolType", QVariant::fromValue(ToolTypeMachine_Logs));
+                    m_pPaneLogViewer->setProperty("ToolType", QVariant::fromValue(UIToolType_Logs));
 
                     /* Add into layout: */
@@ -177 +177 @@
 }
 
-void UIToolPaneMachine::closeTool(ToolTypeMachine enmType)
+void UIToolPaneMachine::closeTool(UIToolType enmType)
 {
     /* Search through the stacked widgets: */
     int iActualIndex = -1;
     for (int iIndex = 0; iIndex < m_pLayout->count(); ++iIndex)
-        if (m_pLayout->widget(iIndex)->property("ToolType").value<ToolTypeMachine>() == enmType)
+        if (m_pLayout->widget(iIndex)->property("ToolType").value<UIToolType>() == enmType)
             iActualIndex = iIndex;
 
@@ -191 +191 @@
         switch (enmType)
         {
-            case ToolTypeMachine_Error:     m_pPaneError = 0; break;
-            case ToolTypeMachine_Details:   m_pPaneDetails = 0; break;
-            case ToolTypeMachine_Snapshots: m_pPaneSnapshots = 0; break;
-            case ToolTypeMachine_Logs:      m_pPaneLogViewer = 0; break;
+            case UIToolType_Error:     m_pPaneError = 0; break;
+            case UIToolType_Details:   m_pPaneDetails = 0; break;
+            case UIToolType_Snapshots: m_pPaneSnapshots = 0; break;
+            case UIToolType_Logs:      m_pPaneLogViewer = 0; break;
             default: break;
         }
@@ -222 +222 @@
 void UIToolPaneMachine::setItems(const QList<UIVirtualMachineItem*> &items)
 {
-    /* Update details pane: */
-    AssertPtrReturnVoid(m_pPaneDetails);
-    m_pPaneDetails->setItems(items);
+    /* Update details pane is it is open: */
+    if (isToolOpened(UIToolType_Details))
+    {
+        AssertPtrReturnVoid(m_pPaneDetails);
+        m_pPaneDetails->setItems(items);
+    }
 }
 
@@ -230 +233 @@
 {
     /* Update snapshots pane is it is open: */
-    if (isToolOpened(ToolTypeMachine_Snapshots))
+    if (isToolOpened(UIToolType_Snapshots))
     {
         AssertPtrReturnVoid(m_pPaneSnapshots);
@@ -236 +239 @@
     }
     /* Update logviewer pane is it is open: */
-    if (isToolOpened(ToolTypeMachine_Logs))
+    if (isToolOpened(UIToolType_Logs))
     {
         AssertPtrReturnVoid(m_pPaneLogViewer);
@@ -249 +252 @@
 
     /* Create Details pane: */
-    openTool(ToolTypeMachine_Details);
+    openTool(UIToolType_Details);
 }
 

trunk/src/VBox/Frontends/VirtualBox/src/manager/UIToolPaneMachine.h

@@ -62 +62 @@
 
     /** Returns type of tool currently opened. */
-    ToolTypeMachine currentTool() const;
+    UIToolType currentTool() const;
     /** Returns whether tool of particular @a enmType is opened. */
-    bool isToolOpened(ToolTypeMachine enmType) const;
+    bool isToolOpened(UIToolType enmType) const;
     /** Activates tool of passed @a enmType, creates new one if necessary. */
-    void openTool(ToolTypeMachine enmType);
+    void openTool(UIToolType enmType);
     /** Closes tool of passed @a enmType, deletes one if exists. */
-    void closeTool(ToolTypeMachine enmType);
+    void closeTool(UIToolType enmType);
 
     /** Defines error @a strDetails and switches to Error pane. */

trunk/src/VBox/Frontends/VirtualBox/src/manager/UIVirtualBoxManager.cpp

@@ -291 +291 @@
      * otherwise user sees everything himself: */
     if (   m_pManagerVirtualMedia
-        || m_pWidget->isToolOpened(ToolTypeGlobal_Media))
+        || m_pWidget->isGlobalToolOpened(UIToolType_Media))
         return;
 
@@ -386 +386 @@
     switch (m_pWidget->toolsType())
     {
-        case UIToolsType_Media:   sltCloseVirtualMediumManagerWindow(); break;
-        case UIToolsType_Network: sltCloseHostNetworkManagerWindow(); break;
-        case UIToolsType_Cloud:   sltCloseCloudProfileManagerWindow(); break;
-        case UIToolsType_Logs:    sltCloseLogViewerWindow(); break;
+        case UIToolType_Media:   sltCloseVirtualMediumManagerWindow(); break;
+        case UIToolType_Network: sltCloseHostNetworkManagerWindow(); break;
+        case UIToolType_Cloud:   sltCloseCloudProfileManagerWindow(); break;
+        case UIToolType_Logs:    sltCloseLogViewerWindow(); break;
         default: break;
     }
@@ -402 +402 @@
 {
     /* First check if instance of widget opened the embedded way: */
-    if (m_pWidget->isToolOpened(ToolTypeGlobal_Media))
-    {
-        m_pWidget->setToolsType(UIToolsType_Welcome);
-        m_pWidget->closeTool(ToolTypeGlobal_Media);
+    if (m_pWidget->isGlobalToolOpened(UIToolType_Media))
+    {
+        m_pWidget->setToolsType(UIToolType_Welcome);
+        m_pWidget->closeGlobalTool(UIToolType_Media);
     }
 
@@ -432 +432 @@
 {
     /* First check if instance of widget opened the embedded way: */
-    if (m_pWidget->isToolOpened(ToolTypeGlobal_Network))
-    {
-        m_pWidget->setToolsType(UIToolsType_Welcome);
-        m_pWidget->closeTool(ToolTypeGlobal_Network);
+    if (m_pWidget->isGlobalToolOpened(UIToolType_Network))
+    {
+        m_pWidget->setToolsType(UIToolType_Welcome);
+        m_pWidget->closeGlobalTool(UIToolType_Network);
     }
 
@@ -462 +462 @@
 {
     /* First check if instance of widget opened the embedded way: */
-    if (m_pWidget->isToolOpened(ToolTypeGlobal_Cloud))
-    {
-        m_pWidget->setToolsType(UIToolsType_Welcome);
-        m_pWidget->closeTool(ToolTypeGlobal_Cloud);
+    if (m_pWidget->isGlobalToolOpened(UIToolType_Cloud))
+    {
+        m_pWidget->setToolsType(UIToolType_Welcome);
+        m_pWidget->closeGlobalTool(UIToolType_Cloud);
     }
 
@@ -1062 +1062 @@
 
     /* First check if instance of widget opened the embedded way: */
-    if (m_pWidget->isToolOpened(ToolTypeMachine_Logs))
-    {
-        m_pWidget->setToolsType(UIToolsType_Details);
-        m_pWidget->closeTool(ToolTypeMachine_Logs);
+    if (m_pWidget->isMachineToolOpened(UIToolType_Logs))
+    {
+        m_pWidget->setToolsType(UIToolType_Details);
+        m_pWidget->closeMachineTool(UIToolType_Logs);
     }
 
@@ -2127 +2127 @@
 
     /* Determine whether Media menu should be visible: */
-    const bool fMediumMenuShown = fGlobalMenuShown && m_pWidget->currentGlobalTool() == ToolTypeGlobal_Media;
+    const bool fMediumMenuShown = fGlobalMenuShown && m_pWidget->currentGlobalTool() == UIToolType_Media;
     m_pVirtualMediaManagerMenuAction->setVisible(fMediumMenuShown);
 
     /* Determine whether Network menu should be visible: */
-    const bool fNetworkMenuShown = fGlobalMenuShown && m_pWidget->currentGlobalTool() == ToolTypeGlobal_Network;
+    const bool fNetworkMenuShown = fGlobalMenuShown && m_pWidget->currentGlobalTool() == UIToolType_Network;
     m_pHostNetworkManagerMenuAction->setVisible(fNetworkMenuShown);
 
     /* Determine whether Cloud menu should be visible: */
-    const bool fCloudMenuShown = fGlobalMenuShown && m_pWidget->currentGlobalTool() == ToolTypeGlobal_Cloud;
+    const bool fCloudMenuShown = fGlobalMenuShown && m_pWidget->currentGlobalTool() == UIToolType_Cloud;
     m_pCloudProfileManagerMenuAction->setVisible(fCloudMenuShown);
 
     /* Determine whether Snapshots menu should be visible: */
     const bool fSnapshotMenuShown = (fMachineMenuShown || fGroupMenuShown) &&
-                                    m_pWidget->currentMachineTool() == ToolTypeMachine_Snapshots;
+                                    m_pWidget->currentMachineTool() == UIToolType_Snapshots;
     m_pSnapshotMenuAction->setVisible(fSnapshotMenuShown);
 
     /* Determine whether Logs menu should be visible: */
     const bool fLogViewerMenuShown = (fMachineMenuShown || fGroupMenuShown) &&
-                                     m_pWidget->currentMachineTool() == ToolTypeMachine_Logs;
+                                     m_pWidget->currentMachineTool() == UIToolType_Logs;
     m_pLogViewerMenuAction->setVisible(fLogViewerMenuShown);
 

trunk/src/VBox/Frontends/VirtualBox/src/manager/UIVirtualBoxManagerWidget.cpp

@@ -104 +104 @@
 }
 
-void UIVirtualBoxManagerWidget::setToolsType(UIToolsType enmType)
+void UIVirtualBoxManagerWidget::setToolsType(UIToolType enmType)
 {
     m_pPaneTools->setToolsType(enmType);
 }
 
-UIToolsType UIVirtualBoxManagerWidget::toolsType() const
+UIToolType UIVirtualBoxManagerWidget::toolsType() const
 {
     return m_pPaneTools->toolsType();
 }
 
-ToolTypeMachine UIVirtualBoxManagerWidget::currentMachineTool() const
+UIToolType UIVirtualBoxManagerWidget::currentMachineTool() const
 {
     return m_pPaneToolsMachine->currentTool();
 }
 
-ToolTypeGlobal UIVirtualBoxManagerWidget::currentGlobalTool() const
+UIToolType UIVirtualBoxManagerWidget::currentGlobalTool() const
 {
     return m_pPaneToolsGlobal->currentTool();
 }
 
-bool UIVirtualBoxManagerWidget::isToolOpened(ToolTypeMachine enmType) const
+bool UIVirtualBoxManagerWidget::isMachineToolOpened(UIToolType enmType) const
 {
     return m_pPaneToolsMachine ? m_pPaneToolsMachine->isToolOpened(enmType) : false;
 }
 
-bool UIVirtualBoxManagerWidget::isToolOpened(ToolTypeGlobal enmType) const
+bool UIVirtualBoxManagerWidget::isGlobalToolOpened(UIToolType enmType) const
 {
     return m_pPaneToolsGlobal ? m_pPaneToolsGlobal->isToolOpened(enmType) : false;
 }
 
-void UIVirtualBoxManagerWidget::switchToTool(ToolTypeMachine enmType)
+void UIVirtualBoxManagerWidget::switchToMachineTool(UIToolType enmType)
 {
     /* Open corresponding tool: */
@@ -140 +140 @@
 
     /* If that was 'Details' => pass there current items: */
-    if (   enmType == ToolTypeMachine_Details
-        && m_pPaneToolsMachine->isToolOpened(ToolTypeMachine_Details))
+    if (enmType == UIToolType_Details)
         m_pPaneToolsMachine->setItems(currentItems());
     /* If that was 'Snapshot' or 'LogViewer' => pass there current or null machine: */
-    if (enmType == ToolTypeMachine_Snapshots || enmType == ToolTypeMachine_Logs)
+    if (enmType == UIToolType_Snapshots || enmType == UIToolType_Logs)
     {
         UIVirtualMachineItem *pItem = currentItem();
@@ -157 +156 @@
 }
 
-void UIVirtualBoxManagerWidget::switchToTool(ToolTypeGlobal enmType)
+void UIVirtualBoxManagerWidget::switchToGlobalTool(UIToolType enmType)
 {
     /* Open corresponding tool: */
@@ -169 +168 @@
 }
 
-void UIVirtualBoxManagerWidget::closeTool(ToolTypeMachine enmType)
+void UIVirtualBoxManagerWidget::closeMachineTool(UIToolType enmType)
 {
     m_pPaneToolsMachine->closeTool(enmType);
 }
 
-void UIVirtualBoxManagerWidget::closeTool(ToolTypeGlobal enmType)
+void UIVirtualBoxManagerWidget::closeGlobalTool(UIToolType enmType)
 {
     m_pPaneToolsGlobal->closeTool(enmType);
@@ -269 +268 @@
 
         /* Update Machine Tools availability: */
-        m_pPaneTools->setToolsEnabled(UIToolsClass_Machine, pItem && pItem->accessible());
+        m_pPaneTools->setToolsEnabled(UIToolClass_Machine, pItem && pItem->accessible());
 
         /* If current item exists & accessible: */
@@ -275 +274 @@
         {
             /* If Error pane is chosen currently => open tool currently chosen in Tools-pane: */
-            if (m_pPaneToolsMachine->currentTool() == ToolTypeMachine_Error)
+            if (m_pPaneToolsMachine->currentTool() == UIToolType_Error)
                 sltHandleToolsPaneIndexChange();
 
             /* Update Details-pane (if requested): */
-            if (   fUpdateDetails
-                && m_pPaneToolsMachine->isToolOpened(ToolTypeMachine_Details))
+            if (fUpdateDetails)
                 m_pPaneToolsMachine->setItems(currentItems());
             /* Update the Snapshots-pane or/and Logviewer-pane (if requested): */
@@ -289 +287 @@
         {
             /* Make sure Error pane raised: */
-            m_pPaneToolsMachine->openTool(ToolTypeMachine_Error);
+            m_pPaneToolsMachine->openTool(UIToolType_Error);
 
             /* Note that the machine becomes inaccessible (or if the last VM gets
@@ -300 +298 @@
 
             /* Update Details-pane (in any case): */
-            if (m_pPaneToolsMachine->isToolOpened(ToolTypeMachine_Details))
-                m_pPaneToolsMachine->setItems(currentItems());
+            m_pPaneToolsMachine->setItems(currentItems());
             /* Update Snapshots-pane and Logviewer-pane (in any case): */
             m_pPaneToolsMachine->setMachine(CMachine());
@@ -315 +312 @@
         case SlidingDirection_Forward:
         {
-            m_pPaneTools->setToolsClass(UIToolsClass_Machine);
+            m_pPaneTools->setToolsClass(UIToolClass_Machine);
             m_pStackedWidget->setCurrentWidget(m_pPaneToolsMachine);
             break;
@@ -321 +318 @@
         case SlidingDirection_Reverse:
         {
-            m_pPaneTools->setToolsClass(UIToolsClass_Global);
+            m_pPaneTools->setToolsClass(UIToolClass_Global);
             m_pStackedWidget->setCurrentWidget(m_pPaneToolsGlobal);
             break;
@@ -330 +327 @@
 }
 
-void UIVirtualBoxManagerWidget::sltHandleToolMenuRequested(UIToolsClass enmClass, const QPoint &position)
+void UIVirtualBoxManagerWidget::sltHandleToolMenuRequested(UIToolClass enmClass, const QPoint &position)
 {
     /* Define current tools class: */
@@ -348 +345 @@
     switch (m_pPaneTools->toolsClass())
     {
-        case UIToolsClass_Global:
-        {
-            ToolTypeGlobal enmType = ToolTypeGlobal_Invalid;
-            if (!m_pPaneTools->areToolsEnabled(UIToolsClass_Global))
-                enmType = ToolTypeGlobal_Welcome;
-            else
-            {
-                switch (m_pPaneTools->toolsType())
-                {
-                    case UIToolsType_Welcome: enmType = ToolTypeGlobal_Welcome; break;
-                    case UIToolsType_Media:   enmType = ToolTypeGlobal_Media; break;
-                    case UIToolsType_Network: enmType = ToolTypeGlobal_Network; break;
-                    case UIToolsType_Cloud:   enmType = ToolTypeGlobal_Cloud; break;
-                    default: break;
-                }
-            }
-            if (enmType != ToolTypeGlobal_Invalid)
-                switchToTool(enmType);
+        case UIToolClass_Global:
+        {
+            const UIToolType enmType = m_pPaneTools->areToolsEnabled(UIToolClass_Global)
+                                     ? m_pPaneTools->toolsType()
+                                     : UIToolType_Welcome;
+            switchToGlobalTool(enmType);
             break;
         }
-        case UIToolsClass_Machine:
-        {
-            ToolTypeMachine enmType = ToolTypeMachine_Invalid;
-            if (!m_pPaneTools->areToolsEnabled(UIToolsClass_Machine))
-                enmType = ToolTypeMachine_Details;
-            else
-            {
-                switch (m_pPaneTools->toolsType())
-                {
-                    case UIToolsType_Details:   enmType = ToolTypeMachine_Details; break;
-                    case UIToolsType_Snapshots: enmType = ToolTypeMachine_Snapshots; break;
-                    case UIToolsType_Logs:      enmType = ToolTypeMachine_Logs; break;
-                    default: break;
-                }
-            }
-            if (enmType != ToolTypeMachine_Invalid)
-                switchToTool(enmType);
+        case UIToolClass_Machine:
+        {
+            const UIToolType enmType = m_pPaneTools->areToolsEnabled(UIToolClass_Machine)
+                                     ? m_pPaneTools->toolsType()
+                                     : UIToolType_Details;
+            switchToMachineTool(enmType);
             break;
         }
@@ -540 +514 @@
             /* Choose which pane should be active initially: */
             if (m_pPaneChooser->isGlobalItemSelected())
-                m_pPaneTools->setToolsClass(UIToolsClass_Global);
+                m_pPaneTools->setToolsClass(UIToolClass_Global);
             else
-                m_pPaneTools->setToolsClass(UIToolsClass_Machine);
+                m_pPaneTools->setToolsClass(UIToolClass_Machine);
         }
     }
@@ -624 +598 @@
     {
         /* Global toolbar: */
-        case UIToolsClass_Global:
+        case UIToolClass_Global:
         {
             switch (currentGlobalTool())
             {
-                case ToolTypeGlobal_Welcome:
+                case UIToolType_Welcome:
                 {
                     m_pToolBar->addAction(actionPool()->action(UIActionIndex_M_Application_S_Preferences));
@@ -639 +613 @@
                     break;
                 }
-                case ToolTypeGlobal_Media:
+                case UIToolType_Media:
                 {
                     m_pToolBar->addAction(actionPool()->action(UIActionIndexST_M_Medium_S_Add));
@@ -652 +626 @@
                     break;
                 }
-                case ToolTypeGlobal_Network:
+                case UIToolType_Network:
                 {
                     m_pToolBar->addAction(actionPool()->action(UIActionIndexST_M_Network_S_Create));
@@ -661 +635 @@
                     break;
                 }
-                case ToolTypeGlobal_Cloud:
+                case UIToolType_Cloud:
                 {
                     m_pToolBar->addAction(actionPool()->action(UIActionIndexST_M_Cloud_S_Add));
@@ -678 +652 @@
         }
         /* Machine toolbar: */
-        case UIToolsClass_Machine:
+        case UIToolClass_Machine:
         {
             switch (currentMachineTool())
             {
-                case ToolTypeMachine_Details:
+                case UIToolType_Details:
                 {
                     m_pToolBar->addAction(actionPool()->action(UIActionIndexST_M_Machine_S_New));
@@ -690 +664 @@
                     break;
                 }
-                case ToolTypeMachine_Snapshots:
+                case UIToolType_Snapshots:
                 {
                     m_pToolBar->addAction(actionPool()->action(UIActionIndexST_M_Machine_S_New));
@@ -704 +678 @@
                     break;
                 }
-                case ToolTypeMachine_Logs:
+                case UIToolType_Logs:
                 {
                     m_pToolBar->addAction(actionPool()->action(UIActionIndexST_M_Machine_S_New));

trunk/src/VBox/Frontends/VirtualBox/src/manager/UIVirtualBoxManagerWidget.h

@@ -88 +88 @@
 
         /** Defines tools @a enmType. */
-        void setToolsType(UIToolsType enmType);
+        void setToolsType(UIToolType enmType);
         /** Returns tools type. */
-        UIToolsType toolsType() const;
+        UIToolType toolsType() const;
 
         /** Returns a type of curent Machine tool. */
-        ToolTypeMachine currentMachineTool() const;
+        UIToolType currentMachineTool() const;
         /** Returns a type of curent Global tool. */
-        ToolTypeGlobal currentGlobalTool() const;
+        UIToolType currentGlobalTool() const;
         /** Returns whether Machine tool of passed @a enmType is opened. */
-        bool isToolOpened(ToolTypeMachine enmType) const;
+        bool isMachineToolOpened(UIToolType enmType) const;
         /** Returns whether Global tool of passed @a enmType is opened. */
-        bool isToolOpened(ToolTypeGlobal enmType) const;
+        bool isGlobalToolOpened(UIToolType enmType) const;
         /** Switches to Machine tool of passed @a enmType. */
-        void switchToTool(ToolTypeMachine enmType);
+        void switchToMachineTool(UIToolType enmType);
         /** Switches to Global tool of passed @a enmType. */
-        void switchToTool(ToolTypeGlobal enmType);
+        void switchToGlobalTool(UIToolType enmType);
         /** Closes Machine tool of passed @a enmType. */
-        void closeTool(ToolTypeMachine enmType);
+        void closeMachineTool(UIToolType enmType);
         /** Closes Global tool of passed @a enmType. */
-        void closeTool(ToolTypeGlobal enmType);
+        void closeGlobalTool(UIToolType enmType);
     /** @} */
 
@@ -148 +148 @@
       * @{ */
         /** Handles tool menu request. */
-        void sltHandleToolMenuRequested(UIToolsClass enmClass, const QPoint &position);
+        void sltHandleToolMenuRequested(UIToolClass enmClass, const QPoint &position);
 
         /** Handles signal abour Tools-pane index change. */

trunk/src/VBox/Frontends/VirtualBox/src/manager/chooser/UIChooser.cpp

@@ -101 +101 @@
 }
 
-void UIChooser::sltToolMenuRequested(UIToolsClass enmClass, const QPoint &position)
+void UIChooser::sltToolMenuRequested(UIToolClass enmClass, const QPoint &position)
 {
     /* Translate scene coordinates to global one: */

trunk/src/VBox/Frontends/VirtualBox/src/manager/chooser/UIChooser.h

@@ -54 +54 @@
 
         /** Notifies listeners about tool popup-menu request for certain tool @a enmClass and in specified @a position. */
-        void sigToolMenuRequested(UIToolsClass enmClass, const QPoint &position);
+        void sigToolMenuRequested(UIToolClass enmClass, const QPoint &position);
     /** @} */
 
@@ -123 +123 @@
       * @{ */
         /** Handles signal about tool popup-menu request for certain tool @a enmClass and in specified @a position. */
-        void sltToolMenuRequested(UIToolsClass enmClass, const QPoint &position);
+        void sltToolMenuRequested(UIToolClass enmClass, const QPoint &position);
     /** @} */
 

trunk/src/VBox/Frontends/VirtualBox/src/manager/chooser/UIChooserModel.cpp

@@ -158 +158 @@
     {
         case UIChooserItemType_Global:
-            emit sigToolMenuRequested(UIToolsClass_Global, pItem->geometry().topRight().toPoint());
+            emit sigToolMenuRequested(UIToolClass_Global, pItem->geometry().topRight().toPoint());
             break;
         case UIChooserItemType_Group:
         case UIChooserItemType_Machine:
-            emit sigToolMenuRequested(UIToolsClass_Machine, pItem->geometry().topRight().toPoint());
+            emit sigToolMenuRequested(UIToolClass_Machine, pItem->geometry().topRight().toPoint());
             break;
         default:

trunk/src/VBox/Frontends/VirtualBox/src/manager/chooser/UIChooserModel.h

@@ -69 +69 @@
       * @{ */
         /** Notify listeners about tool menu popup request for certain @a enmClass and @a position. */
-        void sigToolMenuRequested(UIToolsClass enmClass, const QPoint &position);
+        void sigToolMenuRequested(UIToolClass enmClass, const QPoint &position);
     /** @} */
 

trunk/src/VBox/Frontends/VirtualBox/src/manager/tools/UITools.cpp

@@ -55 +55 @@
 }
 
-void UITools::setToolsClass(UIToolsClass enmClass)
+void UITools::setToolsClass(UIToolClass enmClass)
 {
     m_pToolsModel->setToolsClass(enmClass);
 }
 
-UIToolsClass UITools::toolsClass() const
+UIToolClass UITools::toolsClass() const
 {
     return m_pToolsModel->toolsClass();
 }
 
-void UITools::setToolsType(UIToolsType enmType)
+void UITools::setToolsType(UIToolType enmType)
 {
     m_pToolsModel->setToolsType(enmType);
 }
 
-UIToolsType UITools::toolsType() const
+UIToolType UITools::toolsType() const
 {
     return m_pToolsModel->toolsType();
 }
 
-void UITools::setToolsEnabled(UIToolsClass enmClass, bool fEnabled)
+void UITools::setToolsEnabled(UIToolClass enmClass, bool fEnabled)
 {
     m_pToolsModel->setToolsEnabled(enmClass, fEnabled);
 }
 
-bool UITools::areToolsEnabled(UIToolsClass enmClass) const
+bool UITools::areToolsEnabled(UIToolClass enmClass) const
 {
     return m_pToolsModel->areToolsEnabled(enmClass);

trunk/src/VBox/Frontends/VirtualBox/src/manager/tools/UITools.h

@@ -72 +72 @@
 
         /** Defines current tools @a enmClass. */
-        void setToolsClass(UIToolsClass enmClass);
+        void setToolsClass(UIToolClass enmClass);
         /** Returns current tools class. */
-        UIToolsClass toolsClass() const;
+        UIToolClass toolsClass() const;
 
         /** Defines current tools @a enmType. */
-        void setToolsType(UIToolsType enmType);
+        void setToolsType(UIToolType enmType);
         /** Returns current tools type. */
-        UIToolsType toolsType() const;
+        UIToolType toolsType() const;
 
         /** Defines whether certain @a enmClass of tools is @a fEnabled.*/
-        void setToolsEnabled(UIToolsClass enmClass, bool fEnabled);
+        void setToolsEnabled(UIToolClass enmClass, bool fEnabled);
         /** Returns whether certain class of tools is enabled.*/
-        bool areToolsEnabled(UIToolsClass enmClass) const;
+        bool areToolsEnabled(UIToolClass enmClass) const;
     /** @} */
 

trunk/src/VBox/Frontends/VirtualBox/src/manager/tools/UIToolsItem.cpp

@@ -180 +180 @@
 
 UIToolsItem::UIToolsItem(QGraphicsScene *pScene,
-                         UIToolsClass enmClass, UIToolsType enmType,
+                         UIToolClass enmClass, UIToolType enmType,
                          const QIcon &icon, const QString &strName)
     : m_pScene(pScene)
@@ -222 +222 @@
 }
 
-void UIToolsItem::reconfigure(UIToolsClass enmClass, UIToolsType enmType,
+void UIToolsItem::reconfigure(UIToolClass enmClass, UIToolType enmType,
                               const QIcon &icon, const QString &strName)
 {
@@ -253 +253 @@
 }
 
-UIToolsClass UIToolsItem::itemClass() const
+UIToolClass UIToolsItem::itemClass() const
 {
     return m_enmClass;
 }
 
-UIToolsType UIToolsItem::itemType() const
+UIToolType UIToolsItem::itemType() const
 {
     return m_enmType;

trunk/src/VBox/Frontends/VirtualBox/src/manager/tools/UIToolsItem.h

@@ -78 +78 @@
       * @param  strName  Brings the item name. */
     UIToolsItem(QGraphicsScene *pScene,
-                UIToolsClass enmClass, UIToolsType enmType,
+                UIToolClass enmClass, UIToolType enmType,
                 const QIcon &icon, const QString &strName);
     /** Destructs item. */
@@ -89 +89 @@
 
         /** Reconfigures icon with new @a enmClass, @a enmType, @a icon and @a strName. */
-        void reconfigure(UIToolsClass enmClass, UIToolsType enmType,
+        void reconfigure(UIToolClass enmClass, UIToolType enmType,
                          const QIcon &icon, const QString &strName);
 
         /** Returns item class. */
-        UIToolsClass itemClass() const;
+        UIToolClass itemClass() const;
         /** Returns item type. */
-        UIToolsType itemType() const;
+        UIToolType itemType() const;
         /** Returns item icon. */
         const QIcon &icon() const;
@@ -246 +246 @@
         QGraphicsScene *m_pScene;
         /** Holds the item class. */
-        UIToolsClass    m_enmClass;
+        UIToolClass     m_enmClass;
         /** Holds the item type. */
-        UIToolsType     m_enmType;
+        UIToolType      m_enmType;
         /** Holds the item icon. */
         QIcon           m_icon;

trunk/src/VBox/Frontends/VirtualBox/src/manager/tools/UIToolsModel.cpp

@@ -62 +62 @@
     , m_pMouseHandler(0)
     , m_pKeyboardHandler(0)
-    , m_enmCurrentClass(UIToolsClass_Global)
+    , m_enmCurrentClass(UIToolClass_Global)
 {
     /* Prepare: */
@@ -119 +119 @@
 }
 
-void UIToolsModel::setToolsClass(UIToolsClass enmClass)
+void UIToolsModel::setToolsClass(UIToolClass enmClass)
 {
     /* Update linked values: */
@@ -131 +131 @@
 }
 
-UIToolsClass UIToolsModel::toolsClass() const
+UIToolClass UIToolsModel::toolsClass() const
 {
     return m_enmCurrentClass;
 }
 
-void UIToolsModel::setToolsType(UIToolsType enmType)
+void UIToolsModel::setToolsType(UIToolType enmType)
 {
     /* Update linked values: */
@@ -150 +150 @@
 }
 
-UIToolsType UIToolsModel::toolsType() const
+UIToolType UIToolsModel::toolsType() const
 {
     return currentItem()->itemType();
 }
 
-void UIToolsModel::setToolsEnabled(UIToolsClass enmClass, bool fEnabled)
+void UIToolsModel::setToolsEnabled(UIToolClass enmClass, bool fEnabled)
 {
     /* Update linked values: */
@@ -164 +164 @@
 }
 
-bool UIToolsModel::areToolsEnabled(UIToolsClass enmClass) const
+bool UIToolsModel::areToolsEnabled(UIToolClass enmClass) const
 {
     return m_statesToolsEnabled.value(enmClass);
@@ -192 +192 @@
             switch (m_pCurrentItem->itemClass())
             {
-                case UIToolsClass_Global:  m_pLastItemGlobal  = m_pCurrentItem; break;
-                case UIToolsClass_Machine: m_pLastItemMachine = m_pCurrentItem; break;
+                case UIToolClass_Global:  m_pLastItemGlobal  = m_pCurrentItem; break;
+                case UIToolClass_Machine: m_pLastItemMachine = m_pCurrentItem; break;
                 default: break;
             }
@@ -296 +296 @@
 
     /* Choose last selected item of current class: */
-    UIToolsItem *pLastSelectedItem = m_enmCurrentClass == UIToolsClass_Global
+    UIToolsItem *pLastSelectedItem = m_enmCurrentClass == UIToolClass_Global
                                    ? m_pLastItemGlobal : m_pLastItemMachine;
     if (navigationList().contains(pLastSelectedItem))
@@ -438 +438 @@
 {
     /* Enable all classes of tools initially: */
-    m_statesToolsEnabled[UIToolsClass_Global] = true;
-    m_statesToolsEnabled[UIToolsClass_Machine] = true;
+    m_statesToolsEnabled[UIToolClass_Global] = true;
+    m_statesToolsEnabled[UIToolClass_Machine] = true;
 
     /* Prepare classes: */
-    QList<UIToolsClass> classes;
-    classes << UIToolsClass_Global;
-    classes << UIToolsClass_Global;
-    classes << UIToolsClass_Global;
-    classes << UIToolsClass_Global;
-    classes << UIToolsClass_Machine;
-    classes << UIToolsClass_Machine;
-    classes << UIToolsClass_Machine;
+    QList<UIToolClass> classes;
+    classes << UIToolClass_Global;
+    classes << UIToolClass_Global;
+    classes << UIToolClass_Global;
+    classes << UIToolClass_Global;
+    classes << UIToolClass_Machine;
+    classes << UIToolClass_Machine;
+    classes << UIToolClass_Machine;
 
     /* Prepare types: */
-    QList<UIToolsType> types;
-    types << UIToolsType_Welcome;
-    types << UIToolsType_Media;
-    types << UIToolsType_Network;
-    types << UIToolsType_Cloud;
-    types << UIToolsType_Details;
-    types << UIToolsType_Snapshots;
-    types << UIToolsType_Logs;
+    QList<UIToolType> types;
+    types << UIToolType_Welcome;
+    types << UIToolType_Media;
+    types << UIToolType_Network;
+    types << UIToolType_Cloud;
+    types << UIToolType_Details;
+    types << UIToolType_Snapshots;
+    types << UIToolType_Logs;
 
     /* Prepare icons: */
@@ -516 +516 @@
 
     /* First of them is current global class item definition: */
-    UIToolsType enmTypeGlobal = typeFromString(values.value(0));
-    if (!isTypeOfClass(enmTypeGlobal, UIToolsClass_Global))
-        enmTypeGlobal = UIToolsType_Welcome;
+    UIToolType enmTypeGlobal = typeFromString(values.value(0));
+    if (!isTypeOfClass(enmTypeGlobal, UIToolClass_Global))
+        enmTypeGlobal = UIToolType_Welcome;
     foreach (UIToolsItem *pItem, items())
         if (pItem->itemType() == enmTypeGlobal)
@@ -525 +525 @@
 
     /* Second of them is current machine class item definition: */
-    UIToolsType enmTypeMachine = typeFromString(values.value(1));
-    if (!isTypeOfClass(enmTypeMachine, UIToolsClass_Machine))
-        enmTypeMachine = UIToolsType_Details;
+    UIToolType enmTypeMachine = typeFromString(values.value(1));
+    if (!isTypeOfClass(enmTypeMachine, UIToolClass_Machine))
+        enmTypeMachine = UIToolType_Details;
     foreach (UIToolsItem *pItem, items())
         if (pItem->itemType() == enmTypeMachine)
@@ -592 +592 @@
 
 /* static */
-QString UIToolsModel::typeToString(UIToolsType enmType)
-{
-    QMap<UIToolsType, QString> values;
+QString UIToolsModel::typeToString(UIToolType enmType)
+{
+    QMap<UIToolType, QString> values;
     /* Global classes: */
-    values[UIToolsType_Welcome]   = "Welcome";
-    values[UIToolsType_Media]     = "Media";
-    values[UIToolsType_Network]   = "Network";
-    values[UIToolsType_Cloud]     = "Cloud";
+    values[UIToolType_Welcome]   = "Welcome";
+    values[UIToolType_Media]     = "Media";
+    values[UIToolType_Network]   = "Network";
+    values[UIToolType_Cloud]     = "Cloud";
     /* Machine classes: */
-    values[UIToolsType_Details]   = "Details";
-    values[UIToolsType_Snapshots] = "Snapshots";
-    values[UIToolsType_Logs]      = "Logs";
+    values[UIToolType_Details]   = "Details";
+    values[UIToolType_Snapshots] = "Snapshots";
+    values[UIToolType_Logs]      = "Logs";
     /* Return value, null-string by default: */
     return values.value(enmType, QString());
@@ -609 +609 @@
 
 /* static */
-UIToolsType UIToolsModel::typeFromString(const QString &strType)
-{
-    QMap<QString, UIToolsType> values;
+UIToolType UIToolsModel::typeFromString(const QString &strType)
+{
+    QMap<QString, UIToolType> values;
     /* Global classes: */
-    values["Welcome"]   = UIToolsType_Welcome;
-    values["Media"]     = UIToolsType_Media;
-    values["Network"]   = UIToolsType_Network;
-    values["Cloud"]     = UIToolsType_Cloud;
+    values["Welcome"]   = UIToolType_Welcome;
+    values["Media"]     = UIToolType_Media;
+    values["Network"]   = UIToolType_Network;
+    values["Cloud"]     = UIToolType_Cloud;
     /* Machine classes: */
-    values["Details"]   = UIToolsType_Details;
-    values["Snapshots"] = UIToolsType_Snapshots;
-    values["Logs"]      = UIToolsType_Logs;
-    /* Return value, UIToolsType_Invalid by default: */
-    return values.value(strType, UIToolsType_Invalid);
+    values["Details"]   = UIToolType_Details;
+    values["Snapshots"] = UIToolType_Snapshots;
+    values["Logs"]      = UIToolType_Logs;
+    /* Return value, UIToolType_Invalid by default: */
+    return values.value(strType, UIToolType_Invalid);
 }
 
 /* static */
-bool UIToolsModel::isTypeOfClass(UIToolsType enmType, UIToolsClass enmClass)
+bool UIToolsModel::isTypeOfClass(UIToolType enmType, UIToolClass enmClass)
 {
     switch (enmClass)
     {
-        case UIToolsClass_Global:
+        case UIToolClass_Global:
         {
             switch (enmType)
             {
-                case UIToolsType_Welcome:
-                case UIToolsType_Media:
-                case UIToolsType_Network:
-                case UIToolsType_Cloud:
+                case UIToolType_Welcome:
+                case UIToolType_Media:
+                case UIToolType_Network:
+                case UIToolType_Cloud:
                     return true;
                 default:
@@ -644 +644 @@
             break;
         }
-        case UIToolsClass_Machine:
+        case UIToolClass_Machine:
         {
             switch (enmType)
             {
-                case UIToolsType_Details:
-                case UIToolsType_Snapshots:
-                case UIToolsType_Logs:
+                case UIToolType_Details:
+                case UIToolType_Snapshots:
+                case UIToolType_Logs:
                     return true;
                 default:

trunk/src/VBox/Frontends/VirtualBox/src/manager/tools/UIToolsModel.h

@@ -98 +98 @@
 
         /** Defines current tools @a enmClass. */
-        void setToolsClass(UIToolsClass enmClass);
+        void setToolsClass(UIToolClass enmClass);
         /** Returns current tools class. */
-        UIToolsClass toolsClass() const;
+        UIToolClass toolsClass() const;
 
         /** Defines current tools @a enmType. */
-        void setToolsType(UIToolsType enmType);
+        void setToolsType(UIToolType enmType);
         /** Returns current tools type. */
-        UIToolsType toolsType() const;
+        UIToolType toolsType() const;
 
         /** Defines whether certain @a enmClass of tools is @a fEnabled.*/
-        void setToolsEnabled(UIToolsClass enmClass, bool fEnabled);
+        void setToolsEnabled(UIToolClass enmClass, bool fEnabled);
         /** Returns whether certain class of tools is enabled.*/
-        bool areToolsEnabled(UIToolsClass enmClass) const;
+        bool areToolsEnabled(UIToolClass enmClass) const;
 
         /** Closes parent. */
@@ -230 +230 @@
         /** Returns @a enmType string representation.
           * @todo move to UIConverter one day .. */
-        static QString typeToString(UIToolsType enmType);
-        /** Returns @a strType converted to corresponding UIToolsType.
+        static QString typeToString(UIToolType enmType);
+        /** Returns @a strType converted to corresponding UIToolType.
           * @todo move to UIConverter one day .. */
-        static UIToolsType typeFromString(const QString &strType);
+        static UIToolType typeFromString(const QString &strType);
 
         /** Returns whether passed @a enmType is of passed @a enmClass. */
-        static bool isTypeOfClass(UIToolsType enmType, UIToolsClass enmClass);
+        static bool isTypeOfClass(UIToolType enmType, UIToolClass enmClass);
     /** @} */
 
@@ -253 +253 @@
 
         /** Holds current tools class. */
-        UIToolsClass  m_enmCurrentClass;
+        UIToolClass  m_enmCurrentClass;
 
         /** Holds whether tools of particular class are enabled. */
-        QMap<UIToolsClass, bool>  m_statesToolsEnabled;
+        QMap<UIToolClass, bool>  m_statesToolsEnabled;
     /** @} */