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

Timestamp:

Jun 4, 2014 1:08:25 PM (11 years ago)

Author:

vboxsync

Message:

FE/Qt: 6660: Advanced extra-data management framework: Integrate GUI_PreviewUpdate.

Location:

trunk/src/VBox/Frontends/VirtualBox/src

Files:

• converter/UIConverter.h (modified) (1 diff)
• converter/UIConverterBackend.h (modified) (3 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)
• selector/graphics/details/UIGMachinePreview.cpp (modified) (7 diffs)
• selector/graphics/details/UIGMachinePreview.h (modified) (5 diffs)

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

@@ -88 +88 @@
     }
 
+    /* int <= template class: */
+    template<class T> int toInternalInteger(const T &data) const
+    {
+        if (canConvert<T>())
+            return ::toInternalInteger(data);
+        Assert(0); return 0;
+    }
+    /* Template class <= int: */
+    template<class T> T fromInternalInteger(const int &iData) const
+    {
+        if (canConvert<T>())
+            return ::fromInternalInteger<T>(iData);
+        Assert(0); return T();
+    }
+
 private:
 

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

@@ -58 +58 @@
 template<class X> X fromInternalString(const QString & /* strData */) { Assert(0); return X(); }
 
+/* Converts passed 'Object of type X' to abstract integer.
+ * This function returns 0 for any object type until re-determined for specific one. */
+template<class X> int toInternalInteger(const X & /* xobject */) { Assert(0); return 0; }
+/* Converts passed abstract integer to 'Object of type X'.
+ * This function returns default constructed object for any object type until re-determined for specific one. */
+template<class X> X fromInternalInteger(const int & /* iData */) { Assert(0); return X(); }
+
 /* Declare global canConvert specializations: */
 template<> bool canConvert<SizeSuffix>();
@@ -74 +81 @@
 template<> bool canConvert<UIVisualStateType>();
 template<> bool canConvert<DetailsElementType>();
+template<> bool canConvert<PreviewUpdateIntervalType>();
 template<> bool canConvert<GlobalSettingsPageType>();
 template<> bool canConvert<MachineSettingsPageType>();
@@ -134 +142 @@
 template<> QString toInternalString(const DetailsElementType &detailsElementType);
 template<> DetailsElementType fromInternalString<DetailsElementType>(const QString &strDetailsElementType);
+template<> QString toInternalString(const PreviewUpdateIntervalType &previewUpdateIntervalType);
+template<> PreviewUpdateIntervalType fromInternalString<PreviewUpdateIntervalType>(const QString &strPreviewUpdateIntervalType);
+template<> int toInternalInteger(const PreviewUpdateIntervalType &previewUpdateIntervalType);
+template<> PreviewUpdateIntervalType fromInternalInteger<PreviewUpdateIntervalType>(const int &iPreviewUpdateIntervalType);
 template<> QString toInternalString(const GlobalSettingsPageType &globalSettingsPageType);
 template<> GlobalSettingsPageType fromInternalString<GlobalSettingsPageType>(const QString &strGlobalSettingsPageType);

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

@@ -47 +47 @@
 template<> bool canConvert<UIVisualStateType>() { return true; }
 template<> bool canConvert<DetailsElementType>() { return true; }
+template<> bool canConvert<PreviewUpdateIntervalType>() { return true; }
 template<> bool canConvert<GlobalSettingsPageType>() { return true; }
 template<> bool canConvert<MachineSettingsPageType>() { return true; }
@@ -822 +823 @@
 }
 
+/* QString <= PreviewUpdateIntervalType: */
+template<> QString toInternalString(const PreviewUpdateIntervalType &previewUpdateIntervalType)
+{
+    /* Return corresponding QString representation for passed enum value: */
+    switch (previewUpdateIntervalType)
+    {
+        case PreviewUpdateIntervalType_Disabled: return "disabled";
+        case PreviewUpdateIntervalType_500ms:    return "500";
+        case PreviewUpdateIntervalType_1000ms:   return "1000";
+        case PreviewUpdateIntervalType_2000ms:   return "2000";
+        case PreviewUpdateIntervalType_5000ms:   return "5000";
+        case PreviewUpdateIntervalType_10000ms:  return "10000";
+        default: AssertMsgFailed(("No text for '%d'", previewUpdateIntervalType)); break;
+    }
+    /* Return QString() by default: */
+    return QString();
+}
+
+/* PreviewUpdateIntervalType <= QString: */
+template<> PreviewUpdateIntervalType fromInternalString<PreviewUpdateIntervalType>(const QString &strPreviewUpdateIntervalType)
+{
+    /* Here we have some fancy stuff allowing us
+     * to search through the keys using 'case-insensitive' rule: */
+    QStringList keys;   QList<PreviewUpdateIntervalType> values;
+    keys << "disabled"; values << PreviewUpdateIntervalType_Disabled;
+    keys << "500";      values << PreviewUpdateIntervalType_500ms;
+    keys << "1000";     values << PreviewUpdateIntervalType_1000ms;
+    keys << "2000";     values << PreviewUpdateIntervalType_2000ms;
+    keys << "5000";     values << PreviewUpdateIntervalType_5000ms;
+    keys << "10000";    values << PreviewUpdateIntervalType_10000ms;
+    /* 1000ms type for unknown words: */
+    if (!keys.contains(strPreviewUpdateIntervalType, Qt::CaseInsensitive))
+        return PreviewUpdateIntervalType_1000ms;
+    /* Corresponding type for known words: */
+    return values.at(keys.indexOf(QRegExp(strPreviewUpdateIntervalType, Qt::CaseInsensitive)));
+}
+
+/* int <= PreviewUpdateIntervalType: */
+template<> int toInternalInteger(const PreviewUpdateIntervalType &previewUpdateIntervalType)
+{
+    /* Return corresponding integer representation for passed enum value: */
+    switch (previewUpdateIntervalType)
+    {
+        case PreviewUpdateIntervalType_Disabled: return 0;
+        case PreviewUpdateIntervalType_500ms:    return 500;
+        case PreviewUpdateIntervalType_1000ms:   return 1000;
+        case PreviewUpdateIntervalType_2000ms:   return 2000;
+        case PreviewUpdateIntervalType_5000ms:   return 5000;
+        case PreviewUpdateIntervalType_10000ms:  return 10000;
+        default: AssertMsgFailed(("No value for '%d'", previewUpdateIntervalType)); break;
+    }
+    /* Return 0 by default: */
+    return 0;
+}
+
+/* PreviewUpdateIntervalType <= int: */
+template<> PreviewUpdateIntervalType fromInternalInteger<PreviewUpdateIntervalType>(const int &iPreviewUpdateIntervalType)
+{
+    /* Add all the enum values into the hash: */
+    QHash<int, PreviewUpdateIntervalType> hash;
+    hash.insert(0,     PreviewUpdateIntervalType_Disabled);
+    hash.insert(500,   PreviewUpdateIntervalType_500ms);
+    hash.insert(1000,  PreviewUpdateIntervalType_1000ms);
+    hash.insert(2000,  PreviewUpdateIntervalType_2000ms);
+    hash.insert(5000,  PreviewUpdateIntervalType_5000ms);
+    hash.insert(10000, PreviewUpdateIntervalType_10000ms);
+    /* Make sure hash contains incoming integer representation: */
+    if (!hash.contains(iPreviewUpdateIntervalType))
+        AssertMsgFailed(("No value for '%d'", iPreviewUpdateIntervalType));
+    /* Return corresponding enum value for passed integer representation: */
+    return hash.value(iPreviewUpdateIntervalType);
+}
+
 /* QString <= GlobalSettingsPageType: */
 template<> QString toInternalString(const GlobalSettingsPageType &globalSettingsPageType)

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

@@ -227 +227 @@
 Q_DECLARE_METATYPE(DetailsElementType);
 
+/** Selector UI: Preview update interval types. */
+enum PreviewUpdateIntervalType
+{
+    PreviewUpdateIntervalType_Disabled,
+    PreviewUpdateIntervalType_500ms,
+    PreviewUpdateIntervalType_1000ms,
+    PreviewUpdateIntervalType_2000ms,
+    PreviewUpdateIntervalType_5000ms,
+    PreviewUpdateIntervalType_10000ms,
+    PreviewUpdateIntervalType_Max
+};
+
 
 /** Runtime UI: Menu types. */

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

@@ -427 +427 @@
 }
 
+PreviewUpdateIntervalType UIExtraDataManager::selectorWindowPreviewUpdateInterval() const
+{
+    return gpConverter->fromInternalString<PreviewUpdateIntervalType>(extraDataString(GUI_PreviewUpdate));
+}
+
+void UIExtraDataManager::setSelectorWindowPreviewUpdateInterval(PreviewUpdateIntervalType interval)
+{
+    setExtraDataString(GUI_PreviewUpdate, gpConverter->toInternalString(interval));
+}
+
 bool UIExtraDataManager::isFirstRun(const QString &strId) const
 {

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

@@ -151 +151 @@
     /** Defines whether selector-window status-bar @a fVisible. */
     void setSelectorWindowStatusBarVisible(bool fVisible);
+
+    /** Returns selector-window preview update interval. */
+    PreviewUpdateIntervalType selectorWindowPreviewUpdateInterval() const;
+    /** Defines selector-window preview update @a interval. */
+    void setSelectorWindowPreviewUpdateInterval(PreviewUpdateIntervalType interval);
 
     /** Returns whether this machine started for the first time. */

trunk/src/VBox/Frontends/VirtualBox/src/selector/graphics/details/UIGMachinePreview.cpp

@@ -27 +27 @@
 #include "UIGMachinePreview.h"
 #include "UIVirtualBoxEventHandler.h"
-#include "UIExtraDataDefs.h"
+#include "UIExtraDataManager.h"
 #include "UIImageTools.h"
+#include "UIConverter.h"
 #include "UIIconPool.h"
 #include "VBoxGlobal.h"
@@ -35 +36 @@
 #include "CConsole.h"
 #include "CDisplay.h"
-
-UpdateIntervalMap CreateUpdateIntervalMap()
-{
-    UpdateIntervalMap map;
-    map[UpdateInterval_Disabled] = "disabled";
-    map[UpdateInterval_500ms]    = "500";
-    map[UpdateInterval_1000ms]   = "1000";
-    map[UpdateInterval_2000ms]   = "2000";
-    map[UpdateInterval_5000ms]   = "5000";
-    map[UpdateInterval_10000ms]  = "10000";
-    return map;
-}
-UpdateIntervalMap UIGMachinePreview::m_intervals = CreateUpdateIntervalMap();
 
 UIGMachinePreview::UIGMachinePreview(QIGraphicsWidget *pParent)
@@ -72 +60 @@
     QActionGroup *pUpdateTimeG = new QActionGroup(this);
     pUpdateTimeG->setExclusive(true);
-    for(int i = 0; i < UpdateInterval_Max; ++i)
+    for(int i = 0; i < PreviewUpdateIntervalType_Max; ++i)
     {
         QAction *pUpdateTime = new QAction(pUpdateTimeG);
@@ -79 +67 @@
         pUpdateTimeG->addAction(pUpdateTime);
         m_pUpdateTimerMenu->addAction(pUpdateTime);
-        m_actions[static_cast<UpdateInterval>(i)] = pUpdateTime;
-    }
-    m_pUpdateTimerMenu->insertSeparator(m_actions[static_cast<UpdateInterval>(UpdateInterval_500ms)]);
-
-    /* Load preview update interval: */
-    QString strInterval = vboxGlobal().virtualBox().GetExtraData(GUI_PreviewUpdate);
-    /* Parse loaded value: */
-    UpdateInterval interval = m_intervals.key(strInterval, UpdateInterval_1000ms);
+        m_actions[static_cast<PreviewUpdateIntervalType>(i)] = pUpdateTime;
+    }
+    m_pUpdateTimerMenu->insertSeparator(m_actions[static_cast<PreviewUpdateIntervalType>(PreviewUpdateIntervalType_500ms)]);
+
     /* Initialize with the new update interval: */
-    setUpdateInterval(interval, false);
+    setUpdateInterval(gEDataManager->selectorWindowPreviewUpdateInterval(), false);
 
     /* Setup connections: */
@@ -267 +251 @@
     if (pReturn)
     {
-        UpdateInterval interval = static_cast<UpdateInterval>(pReturn->data().toInt());
+        PreviewUpdateIntervalType interval = static_cast<PreviewUpdateIntervalType>(pReturn->data().toInt());
         setUpdateInterval(interval, true);
         restart();
@@ -275 +259 @@
 void UIGMachinePreview::retranslateUi()
 {
-    m_actions.value(UpdateInterval_Disabled)->setText(tr("Update disabled"));
-    m_actions.value(UpdateInterval_500ms)->setText(tr("Every 0.5 s"));
-    m_actions.value(UpdateInterval_1000ms)->setText(tr("Every 1 s"));
-    m_actions.value(UpdateInterval_2000ms)->setText(tr("Every 2 s"));
-    m_actions.value(UpdateInterval_5000ms)->setText(tr("Every 5 s"));
-    m_actions.value(UpdateInterval_10000ms)->setText(tr("Every 10 s"));
+    m_actions.value(PreviewUpdateIntervalType_Disabled)->setText(tr("Update disabled"));
+    m_actions.value(PreviewUpdateIntervalType_500ms)->setText(tr("Every 0.5 s"));
+    m_actions.value(PreviewUpdateIntervalType_1000ms)->setText(tr("Every 1 s"));
+    m_actions.value(PreviewUpdateIntervalType_2000ms)->setText(tr("Every 2 s"));
+    m_actions.value(PreviewUpdateIntervalType_5000ms)->setText(tr("Every 5 s"));
+    m_actions.value(PreviewUpdateIntervalType_10000ms)->setText(tr("Every 10 s"));
 }
 
@@ -334 +318 @@
 }
 
-void UIGMachinePreview::setUpdateInterval(UpdateInterval interval, bool fSave)
+void UIGMachinePreview::setUpdateInterval(PreviewUpdateIntervalType interval, bool fSave)
 {
     switch (interval)
     {
-        case UpdateInterval_Disabled:
+        case PreviewUpdateIntervalType_Disabled:
         {
-            m_pUpdateTimer->setInterval(0);
+            /* Stop the timer: */
             m_pUpdateTimer->stop();
+            /* And continue with other cases: */
+        }
+        case PreviewUpdateIntervalType_500ms:
+        case PreviewUpdateIntervalType_1000ms:
+        case PreviewUpdateIntervalType_2000ms:
+        case PreviewUpdateIntervalType_5000ms:
+        case PreviewUpdateIntervalType_10000ms:
+        {
+            /* Set the timer interval: */
+            m_pUpdateTimer->setInterval(gpConverter->toInternalInteger(interval));
+            /* Check corresponding action: */
             m_actions[interval]->setChecked(true);
             break;
         }
-        case UpdateInterval_500ms:
-        {
-            m_pUpdateTimer->setInterval(500);
-            m_actions[interval]->setChecked(true);
+        case PreviewUpdateIntervalType_Max:
             break;
-        }
-        case UpdateInterval_1000ms:
-        {
-            m_pUpdateTimer->setInterval(1000);
-            m_actions[interval]->setChecked(true);
-            break;
-        }
-        case UpdateInterval_2000ms:
-        {
-            m_pUpdateTimer->setInterval(2000);
-            m_actions[interval]->setChecked(true);
-            break;
-        }
-        case UpdateInterval_5000ms:
-        {
-            m_pUpdateTimer->setInterval(5000);
-            m_actions[interval]->setChecked(true);
-            break;
-        }
-        case UpdateInterval_10000ms:
-        {
-            m_pUpdateTimer->setInterval(10000);
-            m_actions[interval]->setChecked(true);
-            break;
-        }
-        case UpdateInterval_Max: break;
-    }
-    if (fSave && m_intervals.contains(interval))
-        vboxGlobal().virtualBox().SetExtraData(GUI_PreviewUpdate, m_intervals[interval]);
+    }
+    if (fSave)
+        gEDataManager->setSelectorWindowPreviewUpdateInterval(interval);
 }
 

trunk/src/VBox/Frontends/VirtualBox/src/selector/graphics/details/UIGMachinePreview.h

@@ -24 +24 @@
 
 /* GUI includes: */
+#include "QIWithRetranslateUI.h"
 #include "UIGDetailsItem.h"
-#include "QIWithRetranslateUI.h"
+#include "UIExtraDataDefs.h"
 
 /* COM includes: */
@@ -38 +39 @@
 class QMenu;
 class QTimer;
-
-/* Update interval type: */
-enum UpdateInterval
-{
-    UpdateInterval_Disabled,
-    UpdateInterval_500ms,
-    UpdateInterval_1000ms,
-    UpdateInterval_2000ms,
-    UpdateInterval_5000ms,
-    UpdateInterval_10000ms,
-    UpdateInterval_Max
-};
-typedef QMap<UpdateInterval, QString> UpdateIntervalMap;
 
 /* Preview window class: */
@@ -97 +85 @@
 
     /* Helpers: Update stuff: */
-    void setUpdateInterval(UpdateInterval interval, bool fSave);
+    void setUpdateInterval(PreviewUpdateIntervalType interval, bool fSave);
     void recalculatePreviewRectangle();
     void restart();
@@ -107 +95 @@
     QTimer *m_pUpdateTimer;
     QMenu *m_pUpdateTimerMenu;
-    QHash<UpdateInterval, QAction*> m_actions;
+    QHash<PreviewUpdateIntervalType, QAction*> m_actions;
     const int m_iMargin;
     QRect m_vRect;
@@ -114 +102 @@
     QImage *m_pPreviewImg;
     QString m_strPreviewName;
-    static UpdateIntervalMap m_intervals;
 };