Changeset 66588 in vbox for trunk/src/VBox/Frontends

Timestamp:

Apr 17, 2017 1:02:42 PM (8 years ago)

Author:

vboxsync

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

114615

Message:

FE/Qt: Get rid of VBoxGlobalSettings: Moving maximum guest-screen resolution policy/size handling into extra-data manager.

Location:

trunk/src/VBox/Frontends/VirtualBox/src

Files:

• VBoxGlobalSettings.cpp (modified) (4 diffs)
• VBoxGlobalSettings.h (modified) (3 diffs)
• converter/UIConverterBackend.h (modified) (3 diffs)
• converter/UIConverterBackendGlobal.cpp (modified) (4 diffs)
• extradata/UIExtraDataDefs.cpp (modified) (1 diff)
• extradata/UIExtraDataDefs.h (modified) (2 diffs)
• extradata/UIExtraDataManager.cpp (modified) (1 diff)
• extradata/UIExtraDataManager.h (modified) (2 diffs)
• runtime/UIMachineView.cpp (modified) (3 diffs)
• runtime/UIMachineView.h (modified) (2 diffs)
• settings/global/UIGlobalSettingsDisplay.cpp (modified) (9 diffs)

trunk/src/VBox/Frontends/VirtualBox/src/VBoxGlobalSettings.cpp

@@ -51 +51 @@
 {
     /* default settings */
-    maxGuestRes = QString::null;
     remapScancodes = QString::null;
     proxySettings = QString::null;
@@ -59 +58 @@
 VBoxGlobalSettingsData::VBoxGlobalSettingsData (const VBoxGlobalSettingsData &that)
 {
-    maxGuestRes = that.maxGuestRes;
     remapScancodes = that.remapScancodes;
     proxySettings = that.proxySettings;
@@ -72 +70 @@
 {
     return this == &that ||
-        (maxGuestRes == that.maxGuestRes &&
-         remapScancodes == that.remapScancodes &&
+        (remapScancodes == that.remapScancodes &&
          proxySettings == that.proxySettings &&
          hostScreenSaverDisabled == that.hostScreenSaverDisabled
@@ -94 +91 @@
 gPropertyMap[] =
 {
-    { "GUI/MaxGuestResolution",                    "maxGuestRes",             "\\d*[1-9]\\d*,\\d*[1-9]\\d*|any|auto", true },
     { "GUI/RemapScancodes",                        "remapScancodes",          "(\\d+=\\d+,)*\\d+=\\d+", true },
     { "GUI/ProxySettings",                         "proxySettings",           "[\\s\\S]*", true },

trunk/src/VBox/Frontends/VirtualBox/src/VBoxGlobalSettings.h

@@ -37 +37 @@
 private:
 
-    QString maxGuestRes;
     QString remapScancodes;
     QString proxySettings;
@@ -50 +49 @@
 {
     Q_OBJECT
-    Q_PROPERTY (QString maxGuestRes READ maxGuestRes WRITE setMaxGuestRes)
     Q_PROPERTY (QString remapScancodes READ remapScancodes WRITE setRemapScancodes)
     Q_PROPERTY (QString proxySettings READ proxySettings WRITE setProxySettings)
@@ -67 +65 @@
 
     // Properties
-
-    QString maxGuestRes() const { return data()->maxGuestRes; }
-    void setMaxGuestRes (const QString &aMaxGuestRes)
-    {
-        mData()->maxGuestRes = aMaxGuestRes;
-    }
 
     QString remapScancodes() const { return data()->remapScancodes; }

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

@@ -87 +87 @@
 template<> bool canConvert<UIVisualStateType>();
 template<> bool canConvert<DetailsElementType>();
-template<> bool canConvert<InformationElementType>();
 template<> bool canConvert<PreviewUpdateIntervalType>();
 template<> bool canConvert<EventHandlingType>();
@@ -103 +102 @@
 template<> bool canConvert<MiniToolbarAlignment>();
 #endif /* !VBOX_WS_MAC */
+template<> bool canConvert<InformationElementType>();
+template<> bool canConvert<MaxGuestResolutionPolicy>();
 
 /* Declare COM canConvert specializations: */
@@ -201 +202 @@
 template<> InformationElementType fromInternalString<InformationElementType>(const QString &strInformationElementType);
 template<> QIcon toIcon(const InformationElementType &informationElementType);
+template<> QString toInternalString(const MaxGuestResolutionPolicy &enmMaxGuestResolutionPolicy);
+template<> MaxGuestResolutionPolicy fromInternalString<MaxGuestResolutionPolicy>(const QString &strMaxGuestResolutionPolicy);
 
 /* Declare COM conversion specializations: */

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

@@ -23 +23 @@
 # include <QApplication>
 # include <QHash>
+# include <QRegularExpression>
 
 /* GUI includes: */
@@ -54 +55 @@
 template<> bool canConvert<UIVisualStateType>() { return true; }
 template<> bool canConvert<DetailsElementType>() { return true; }
-template<> bool canConvert<InformationElementType>() { return true; }
 template<> bool canConvert<PreviewUpdateIntervalType>() { return true; }
 template<> bool canConvert<EventHandlingType>() { return true; }
@@ -70 +70 @@
 template<> bool canConvert<MiniToolbarAlignment>() { return true; }
 #endif /* !VBOX_WS_MAC */
+template<> bool canConvert<InformationElementType>() { return true; }
+template<> bool canConvert<MaxGuestResolutionPolicy>() { return true; }
 
 /* QString <= SizeSuffix: */
@@ -1804 +1806 @@
 }
 
+/* QString <= MaxGuestResolutionPolicy: */
+template<> QString toInternalString(const MaxGuestResolutionPolicy &enmMaxGuestResolutionPolicy)
+{
+    QString strResult;
+    switch (enmMaxGuestResolutionPolicy)
+    {
+        case MaxGuestResolutionPolicy_Automatic: strResult = ""; break;
+        case MaxGuestResolutionPolicy_Any:       strResult = "any"; break;
+        default:
+        {
+            AssertMsgFailed(("No text for max guest resolution policy=%d", enmMaxGuestResolutionPolicy));
+            break;
+        }
+    }
+    return strResult;
+}
+
+/* MaxGuestResolutionPolicy <= QString: */
+template<> MaxGuestResolutionPolicy fromInternalString<MaxGuestResolutionPolicy>(const QString &strMaxGuestResolutionPolicy)
+{
+    /* Here we have some fancy stuff allowing us
+     * to search through the keys using 'case-insensitive' rule: */
+    QStringList keys; QList<MaxGuestResolutionPolicy> values;
+    keys << "auto";   values << MaxGuestResolutionPolicy_Automatic;
+    /* Auto type for empty value: */
+    if (strMaxGuestResolutionPolicy.isEmpty())
+        return MaxGuestResolutionPolicy_Automatic;
+    /* Fixed type for value which can be parsed: */
+    if (QRegularExpression("[1-9]\\d*,[1-9]\\d*").match(strMaxGuestResolutionPolicy).hasMatch())
+        return MaxGuestResolutionPolicy_Fixed;
+    /* Any type for unknown words: */
+    if (!keys.contains(strMaxGuestResolutionPolicy, Qt::CaseInsensitive))
+        return MaxGuestResolutionPolicy_Any;
+    /* Corresponding type for known words: */
+    return values.at(keys.indexOf(QRegExp(strMaxGuestResolutionPolicy, Qt::CaseInsensitive)));
+}
+

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

@@ -52 +52 @@
 
 /* Settings: Display: */
+const char* UIExtraDataDefs::GUI_MaxGuestResolution = "GUI/MaxGuestResolution";
 const char* UIExtraDataDefs::GUI_ActivateHoveredMachineWindow = "GUI/ActivateHoveredMachineWindow";
 

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

@@ -78 +78 @@
     /** @name Settings: Display
       * @{ */
+        /** Holds maximum guest-screen resolution policy/value. */
+        extern const char* GUI_MaxGuestResolution;
         /** Holds whether hovered machine-window should be activated. */
         extern const char* GUI_ActivateHoveredMachineWindow;
@@ -721 +723 @@
 Q_DECLARE_METATYPE(InformationElementType);
 
+/** Runtime UI: Maximum guest-screen resolution policy types.
+  * @note This policy determines which guest-screen resolutions we wish to
+  *       handle. We also accept anything smaller than the current resolution. */
+enum MaxGuestResolutionPolicy
+{
+    /** Anything at all. */
+    MaxGuestResolutionPolicy_Any,
+    /** Anything up to a fixed size. */
+    MaxGuestResolutionPolicy_Fixed,
+    /** Anything up to host-screen available space. */
+    MaxGuestResolutionPolicy_Automatic
+};
+
 #endif /* !___UIExtraDataDefs_h___ */
 

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

@@ -2349 +2349 @@
 }
 
+MaxGuestResolutionPolicy UIExtraDataManager::maxGuestResolutionPolicy()
+{
+    /* Return maximum guest-screen resolution policy: */
+    return gpConverter->fromInternalString<MaxGuestResolutionPolicy>(extraDataString(GUI_MaxGuestResolution));
+}
+
+void UIExtraDataManager::setMaxGuestScreenResolution(MaxGuestResolutionPolicy enmPolicy, const QSize resolution /* = QSize() */)
+{
+    /* If policy is 'Fixed' => call the wrapper: */
+    if (enmPolicy == MaxGuestResolutionPolicy_Fixed)
+        setMaxGuestResolutionForPolicyFixed(resolution);
+    /* Otherwise => just store the value: */
+    else
+        setExtraDataString(GUI_MaxGuestResolution, gpConverter->toInternalString(enmPolicy));
+}
+
+QSize UIExtraDataManager::maxGuestResolutionForPolicyFixed()
+{
+    /* Acquire maximum guest-screen resolution policy: */
+    const QString strPolicy = extraDataString(GUI_MaxGuestResolution);
+    const MaxGuestResolutionPolicy enmPolicy = gpConverter->fromInternalString<MaxGuestResolutionPolicy>(strPolicy);
+
+    /* Make sure maximum guest-screen resolution policy is really Fixed: */
+    if (enmPolicy != MaxGuestResolutionPolicy_Fixed)
+        return QSize();
+
+    /* Parse maximum guest-screen resolution: */
+    const QStringList values = strPolicy.split(',');
+    int iWidth = values.at(0).toInt();
+    int iHeight = values.at(1).toInt();
+    if (iWidth <= 0)
+        iWidth = 640;
+    if (iHeight <= 0)
+        iHeight = 480;
+
+    /* Return maximum guest-screen resolution: */
+    return QSize(iWidth, iHeight);
+}
+
+void UIExtraDataManager::setMaxGuestResolutionForPolicyFixed(const QSize &resolution)
+{
+    /* If resolution is 'empty' => call the wrapper: */
+    if (resolution.isEmpty())
+        setMaxGuestScreenResolution(MaxGuestResolutionPolicy_Automatic);
+    /* Otherwise => just store the value: */
+    else
+        setExtraDataString(GUI_MaxGuestResolution, QString("%1,%2").arg(resolution.width()).arg(resolution.height()));
+}
+
 bool UIExtraDataManager::activateHoveredMachineWindow()
 {

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

@@ -25 +25 @@
 # include <QPointer>
 #endif /* VBOX_GUI_WITH_EXTRADATA_MANAGER_UI */
+#include <QSize>
 
 /* GUI includes: */
@@ -198 +199 @@
     /** @name Settings: Display
       * @{ */
+        /** Returns maximum guest-screen resolution policy. */
+        MaxGuestResolutionPolicy maxGuestResolutionPolicy();
+        /** Defines maximum guest-screen resolution @a enmPolicy or @a resolution itself for Fixed policy. */
+        void setMaxGuestScreenResolution(MaxGuestResolutionPolicy enmPolicy, const QSize resolution = QSize());
+        /** Returns maximum guest-screen resolution for fixed policy. */
+        QSize maxGuestResolutionForPolicyFixed();
+        /** Defines maximum guest-screen @a resolution for fixed policy. */
+        void setMaxGuestResolutionForPolicyFixed(const QSize &resolution);
+
         /** Returns whether hovered machine-window should be activated. */
         bool activateHoveredMachineWindow();

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

@@ -649 +649 @@
     , m_iHostScreenNumber(0)
 #endif /* VBOX_WS_MAC */
-    , m_maxGuestSizePolicy(MaxGuestSizePolicy_Invalid)
+    , m_maxGuestSizePolicy(MaxGuestResolutionPolicy_Automatic)
     , m_u64MaxGuestSize(0)
 #ifdef VBOX_WITH_VIDEOHWACCEL
@@ -667 +667 @@
     /* Global settings: */
     {
-        /* Remember the maximum guest size policy for telling the guest about
-         * video modes we like: */
-        QString maxGuestSize = vboxGlobal().settings().publicProperty("GUI/MaxGuestResolution");
-        if ((maxGuestSize == QString::null) || (maxGuestSize == "auto"))
-            m_maxGuestSizePolicy = MaxGuestSizePolicy_Automatic;
-        else if (maxGuestSize == "any")
-            m_maxGuestSizePolicy = MaxGuestSizePolicy_Any;
-        else  /** @todo Mea culpa, but what about error checking? */
-        {
-            int width  = maxGuestSize.section(',', 0, 0).toInt();
-            int height = maxGuestSize.section(',', 1, 1).toInt();
-            m_maxGuestSizePolicy = MaxGuestSizePolicy_Fixed;
-            m_fixedMaxGuestSize = QSize(width, height);
-        }
+        /* Remember the maximum guest size policy for
+         * telling the guest about video modes we like: */
+        m_maxGuestSizePolicy = gEDataManager->maxGuestResolutionPolicy();
+        if (m_maxGuestSizePolicy == MaxGuestResolutionPolicy_Fixed)
+            m_fixedMaxGuestSize = gEDataManager->maxGuestResolutionForPolicyFixed();
     }
 }
@@ -1014 +1005 @@
     switch (m_maxGuestSizePolicy)
     {
-        case MaxGuestSizePolicy_Fixed:
+        case MaxGuestResolutionPolicy_Fixed:
             maxSize = m_fixedMaxGuestSize;
             break;
-        case MaxGuestSizePolicy_Automatic:
+        case MaxGuestResolutionPolicy_Automatic:
             maxSize = calculateMaxGuestSize().expandedTo(minimumSizeHint);
             break;
-        case MaxGuestSizePolicy_Any:
-        default:
-            AssertMsg(m_maxGuestSizePolicy == MaxGuestSizePolicy_Any,
-                      ("Invalid maximum guest size policy %d!\n",
-                       m_maxGuestSizePolicy));
+        case MaxGuestResolutionPolicy_Any:
             /* (0, 0) means any of course. */
             maxSize = QSize(0, 0);

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

@@ -80 +80 @@
 
 public:
-
-    /** Policy for determining which guest resolutions we wish to
-     * handle.  We also accept anything smaller than the current
-     * resolution. */
-    enum MaxGuestSizePolicy
-    {
-        /** Policy not set correctly. */
-        MaxGuestSizePolicy_Invalid = 0,
-        /** Anything up to a fixed size. */
-        MaxGuestSizePolicy_Fixed,
-        /** Anything up to available space on the host desktop. */
-        MaxGuestSizePolicy_Automatic,
-        /** We accept anything. */
-        MaxGuestSizePolicy_Any
-    };
 
     /* Factory function to create machine-view: */
@@ -406 +391 @@
     /** The policy for calculating the maximum guest resolution which we wish
      * to handle. */
-    MaxGuestSizePolicy m_maxGuestSizePolicy;
+    MaxGuestResolutionPolicy m_maxGuestSizePolicy;
     /** The maximum guest size for fixed size policy. */
     QSize m_fixedMaxGuestSize;

trunk/src/VBox/Frontends/VirtualBox/src/settings/global/UIGlobalSettingsDisplay.cpp

@@ -32 +32 @@
     /** Constructs data. */
     UIDataSettingsGlobalDisplay()
-        : m_strMaxGuestResolution(QString())
+        : m_enmMaxGuestResolution(MaxGuestResolutionPolicy_Automatic)
+        , m_maxGuestResolution(QSize())
         , m_fActivateHoveredMachineWindow(false)
     {}
@@ -40 +41 @@
     {
         return true
-               && (m_strMaxGuestResolution == other.m_strMaxGuestResolution)
+               && (m_enmMaxGuestResolution == other.m_enmMaxGuestResolution)
+               && (m_maxGuestResolution == other.m_maxGuestResolution)
                && (m_fActivateHoveredMachineWindow == other.m_fActivateHoveredMachineWindow)
                ;
@@ -50 +52 @@
     bool operator!=(const UIDataSettingsGlobalDisplay &other) const { return !equal(other); }
 
-    /** Holds the maximum guest resolution or preset name. */
-    QString m_strMaxGuestResolution;
+    /** Holds the maximum guest-screen resolution policy. */
+    MaxGuestResolutionPolicy m_enmMaxGuestResolution;
+    /** Holds the maximum guest-screen resolution. */
+    QSize m_maxGuestResolution;
     /** Holds whether we should automatically activate machine window under the mouse cursor. */
     bool m_fActivateHoveredMachineWindow;
@@ -82 +86 @@
 
     /* Gather old display data: */
-    oldDisplayData.m_strMaxGuestResolution = m_settings.maxGuestRes();
+    oldDisplayData.m_enmMaxGuestResolution = gEDataManager->maxGuestResolutionPolicy();
+    if (oldDisplayData.m_enmMaxGuestResolution == MaxGuestResolutionPolicy_Fixed)
+        oldDisplayData.m_maxGuestResolution = gEDataManager->maxGuestResolutionForPolicyFixed();
     oldDisplayData.m_fActivateHoveredMachineWindow = gEDataManager->activateHoveredMachineWindow();
 
@@ -98 +104 @@
 
     /* Load old display data from the cache: */
-    if (   (oldDisplayData.m_strMaxGuestResolution.isEmpty())
-        || (oldDisplayData.m_strMaxGuestResolution == "auto"))
-    {
-        /* Switch combo-box item: */
-        m_pMaxResolutionCombo->setCurrentIndex(m_pMaxResolutionCombo->findData("auto"));
-    }
-    else if (oldDisplayData.m_strMaxGuestResolution == "any")
-    {
-        /* Switch combo-box item: */
-        m_pMaxResolutionCombo->setCurrentIndex(m_pMaxResolutionCombo->findData("any"));
-    }
-    else
-    {
-        /* Switch combo-box item: */
-        m_pMaxResolutionCombo->setCurrentIndex(m_pMaxResolutionCombo->findData("fixed"));
-        /* Trying to parse text into 2 sections by ',' symbol: */
-        const int iWidth  = oldDisplayData.m_strMaxGuestResolution.section(',', 0, 0).toInt();
-        const int iHeight = oldDisplayData.m_strMaxGuestResolution.section(',', 1, 1).toInt();
-        /* And set values if they are present: */
-        m_pResolutionWidthSpin->setValue(iWidth);
-        m_pResolutionHeightSpin->setValue(iHeight);
+    m_pMaxResolutionCombo->setCurrentIndex(m_pMaxResolutionCombo->findData((int)oldDisplayData.m_enmMaxGuestResolution));
+    if (oldDisplayData.m_enmMaxGuestResolution == MaxGuestResolutionPolicy_Fixed)
+    {
+        m_pResolutionWidthSpin->setValue(oldDisplayData.m_maxGuestResolution.width());
+        m_pResolutionHeightSpin->setValue(oldDisplayData.m_maxGuestResolution.height());
     }
     m_pCheckBoxActivateOnMouseHover->setChecked(oldDisplayData.m_fActivateHoveredMachineWindow);
@@ -129 +119 @@
 
     /* Gather new display data: */
-    if (m_pMaxResolutionCombo->itemData(m_pMaxResolutionCombo->currentIndex()).toString() == "auto")
-    {
-        /* If resolution current combo item is "auto" => resolution set to "auto": */
-        newDisplayData.m_strMaxGuestResolution = QString();
-    }
-    else if (   m_pMaxResolutionCombo->itemData(m_pMaxResolutionCombo->currentIndex()).toString() == "any"
-             || m_pResolutionWidthSpin->value() == 0 || m_pResolutionHeightSpin->value() == 0)
-    {
-        /* Else if resolution current combo item is "any"
-         * or any of the resolution field attributes is zero => resolution set to "any": */
-        newDisplayData.m_strMaxGuestResolution = "any";
-    }
-    else if (m_pResolutionWidthSpin->value() != 0 && m_pResolutionHeightSpin->value() != 0)
-    {
-        /* Else if both field attributes are non-zeroes => resolution set to "fixed": */
-        newDisplayData.m_strMaxGuestResolution = QString("%1,%2").arg(m_pResolutionWidthSpin->value()).arg(m_pResolutionHeightSpin->value());
-    }
+    newDisplayData.m_enmMaxGuestResolution = (MaxGuestResolutionPolicy)m_pMaxResolutionCombo->itemData(m_pMaxResolutionCombo->currentIndex()).toInt();
+    if (newDisplayData.m_enmMaxGuestResolution == MaxGuestResolutionPolicy_Fixed)
+        newDisplayData.m_maxGuestResolution = QSize(m_pResolutionWidthSpin->value(), m_pResolutionHeightSpin->value());
     newDisplayData.m_fActivateHoveredMachineWindow = m_pCheckBoxActivateOnMouseHover->isChecked();
 
@@ -161 +137 @@
     {
         /* Save new display data from the cache: */
-        if (m_pCache->data().m_strMaxGuestResolution != m_pCache->base().m_strMaxGuestResolution)
-            m_settings.setMaxGuestRes(m_pCache->data().m_strMaxGuestResolution);
+        if (   m_pCache->data().m_enmMaxGuestResolution != m_pCache->base().m_enmMaxGuestResolution
+            || m_pCache->data().m_maxGuestResolution != m_pCache->base().m_maxGuestResolution)
+            gEDataManager->setMaxGuestScreenResolution(m_pCache->data().m_enmMaxGuestResolution, m_pCache->data().m_maxGuestResolution);
         if (m_pCache->data().m_fActivateHoveredMachineWindow != m_pCache->base().m_fActivateHoveredMachineWindow)
             gEDataManager->setActivateHoveredMachineWindow(m_pCache->data().m_fActivateHoveredMachineWindow);
@@ -187 +164 @@
 
     /* Get current resolution-combo item data: */
-    const QString strCurrentComboItemData = m_pMaxResolutionCombo->itemData(m_pMaxResolutionCombo->currentIndex()).toString();
-    /* Is our combo in state for 'fixed' resolution? */
-    const bool fCurrentResolutionStateFixed = strCurrentComboItemData == "fixed";
+    const MaxGuestResolutionPolicy enmPolicy = (MaxGuestResolutionPolicy)m_pMaxResolutionCombo->itemData(m_pMaxResolutionCombo->currentIndex()).toInt();
     /* Should be combo-level widgets enabled? */
-    const bool fComboLevelWidgetsEnabled = fCurrentResolutionStateFixed;
+    const bool fComboLevelWidgetsEnabled = enmPolicy == MaxGuestResolutionPolicy_Fixed;
     /* Enable/disable combo-level widgets: */
     m_pResolutionWidthLabel->setEnabled(fComboLevelWidgetsEnabled);
@@ -247 +222 @@
 
     /* Create corresponding items: */
-    m_pMaxResolutionCombo->addItem(tr("Automatic", "Maximum Guest Screen Size"), "auto");
+    m_pMaxResolutionCombo->addItem(tr("Automatic", "Maximum Guest Screen Size"),
+                                   QVariant((int)MaxGuestResolutionPolicy_Automatic));
     m_pMaxResolutionCombo->setItemData(m_pMaxResolutionCombo->count() - 1,
                                        tr("Suggest a reasonable maximum screen size to the guest. "
                                           "The guest will only see this suggestion when guest additions are installed."),
                                        Qt::ToolTipRole);
-    m_pMaxResolutionCombo->addItem(tr("None", "Maximum Guest Screen Size"), "any");
+    m_pMaxResolutionCombo->addItem(tr("None", "Maximum Guest Screen Size"),
+                                   QVariant((int)MaxGuestResolutionPolicy_Any));
     m_pMaxResolutionCombo->setItemData(m_pMaxResolutionCombo->count() - 1,
                                        tr("Do not attempt to limit the size of the guest screen."),
                                        Qt::ToolTipRole);
-    m_pMaxResolutionCombo->addItem(tr("Hint", "Maximum Guest Screen Size"), "fixed");
+    m_pMaxResolutionCombo->addItem(tr("Hint", "Maximum Guest Screen Size"),
+                                   QVariant((int)MaxGuestResolutionPolicy_Fixed));
     m_pMaxResolutionCombo->setItemData(m_pMaxResolutionCombo->count() - 1,
                                        tr("Suggest a maximum screen size to the guest. "