Index: trunk/src/VBox/Frontends/VirtualBox/src/converter/UIConverterBackend.h
===================================================================
--- trunk/src/VBox/Frontends/VirtualBox/src/converter/UIConverterBackend.h	(revision 86976)
+++ trunk/src/VBox/Frontends/VirtualBox/src/converter/UIConverterBackend.h	(revision 86977)
@@ -122,5 +122,5 @@
 #endif
 template<> SHARED_LIBRARY_STUFF bool canConvert<InformationElementType>();
-template<> SHARED_LIBRARY_STUFF bool canConvert<MaxGuestResolutionPolicy>();
+template<> SHARED_LIBRARY_STUFF bool canConvert<MaximumGuestScreenSizePolicy>();
 template<> SHARED_LIBRARY_STUFF bool canConvert<UIMediumFormat>();
 template<> SHARED_LIBRARY_STUFF bool canConvert<UISettingsDefs::RecordingMode>();
@@ -262,6 +262,6 @@
 template<> SHARED_LIBRARY_STUFF InformationElementType fromInternalString<InformationElementType>(const QString &strInformationElementType);
 template<> SHARED_LIBRARY_STUFF QIcon toIcon(const InformationElementType &informationElementType);
-template<> SHARED_LIBRARY_STUFF QString toInternalString(const MaxGuestResolutionPolicy &enmMaxGuestResolutionPolicy);
-template<> SHARED_LIBRARY_STUFF MaxGuestResolutionPolicy fromInternalString<MaxGuestResolutionPolicy>(const QString &strMaxGuestResolutionPolicy);
+template<> SHARED_LIBRARY_STUFF QString toInternalString(const MaximumGuestScreenSizePolicy &enmMaximumGuestScreenSizePolicy);
+template<> SHARED_LIBRARY_STUFF MaximumGuestScreenSizePolicy fromInternalString<MaximumGuestScreenSizePolicy>(const QString &strMaximumGuestScreenSizePolicy);
 template<> SHARED_LIBRARY_STUFF QString toString(const UIMediumFormat &enmUIMediumFormat);
 template<> SHARED_LIBRARY_STUFF QString toInternalString(const UIMediumFormat &enmUIMediumFormat);
Index: trunk/src/VBox/Frontends/VirtualBox/src/converter/UIConverterBackendGlobal.cpp
===================================================================
--- trunk/src/VBox/Frontends/VirtualBox/src/converter/UIConverterBackendGlobal.cpp	(revision 86976)
+++ trunk/src/VBox/Frontends/VirtualBox/src/converter/UIConverterBackendGlobal.cpp	(revision 86977)
@@ -76,5 +76,5 @@
 #endif
 template<> bool canConvert<InformationElementType>() { return true; }
-template<> bool canConvert<MaxGuestResolutionPolicy>() { return true; }
+template<> bool canConvert<MaximumGuestScreenSizePolicy>() { return true; }
 template<> bool canConvert<UIMediumFormat>() { return true; }
 template<> bool canConvert<UISettingsDefs::RecordingMode>() { return true; }
@@ -2457,39 +2457,39 @@
 }
 
-/* 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;
+/* QString <= MaximumGuestScreenSizePolicy: */
+template<> QString toInternalString(const MaximumGuestScreenSizePolicy &enmMaximumGuestScreenSizePolicy)
+{
+    QString strResult;
+    switch (enmMaximumGuestScreenSizePolicy)
+    {
+        case MaximumGuestScreenSizePolicy_Automatic: strResult = ""; break;
+        case MaximumGuestScreenSizePolicy_Any:       strResult = "any"; break;
+        default:
+        {
+            AssertMsgFailed(("No text for max guest resolution policy=%d", enmMaximumGuestScreenSizePolicy));
+            break;
+        }
+    }
+    return strResult;
+}
+
+/* MaximumGuestScreenSizePolicy <= QString: */
+template<> MaximumGuestScreenSizePolicy fromInternalString<MaximumGuestScreenSizePolicy>(const QString &strMaximumGuestScreenSizePolicy)
+{
+    /* Here we have some fancy stuff allowing us
+     * to search through the keys using 'case-insensitive' rule: */
+    QStringList keys; QList<MaximumGuestScreenSizePolicy> values;
+    keys << "auto";   values << MaximumGuestScreenSizePolicy_Automatic;
     /* Auto type for empty value: */
-    if (strMaxGuestResolutionPolicy.isEmpty())
-        return MaxGuestResolutionPolicy_Automatic;
+    if (strMaximumGuestScreenSizePolicy.isEmpty())
+        return MaximumGuestScreenSizePolicy_Automatic;
     /* Fixed type for value which can be parsed: */
-    if (QRegularExpression("[1-9]\\d*,[1-9]\\d*").match(strMaxGuestResolutionPolicy).hasMatch())
-        return MaxGuestResolutionPolicy_Fixed;
+    if (QRegularExpression("[1-9]\\d*,[1-9]\\d*").match(strMaximumGuestScreenSizePolicy).hasMatch())
+        return MaximumGuestScreenSizePolicy_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)));
+    if (!keys.contains(strMaximumGuestScreenSizePolicy, Qt::CaseInsensitive))
+        return MaximumGuestScreenSizePolicy_Any;
+    /* Corresponding type for known words: */
+    return values.at(keys.indexOf(QRegExp(strMaximumGuestScreenSizePolicy, Qt::CaseInsensitive)));
 }
 
Index: trunk/src/VBox/Frontends/VirtualBox/src/extradata/UIExtraDataDefs.h
===================================================================
--- trunk/src/VBox/Frontends/VirtualBox/src/extradata/UIExtraDataDefs.h	(revision 86976)
+++ trunk/src/VBox/Frontends/VirtualBox/src/extradata/UIExtraDataDefs.h	(revision 86977)
@@ -1059,16 +1059,17 @@
 
 
-/** 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
+/** Runtime UI: Maximum guest-screen size policy types.
+  * @note This policy determines which guest-screen sizes we wish to
+  *       handle. We also accept anything smaller than the current size. */
+enum MaximumGuestScreenSizePolicy
 {
     /** Anything at all. */
-    MaxGuestResolutionPolicy_Any,
+    MaximumGuestScreenSizePolicy_Any,
     /** Anything up to a fixed size. */
-    MaxGuestResolutionPolicy_Fixed,
+    MaximumGuestScreenSizePolicy_Fixed,
     /** Anything up to host-screen available space. */
-    MaxGuestResolutionPolicy_Automatic
-};
+    MaximumGuestScreenSizePolicy_Automatic
+};
+
 
 /** Manager UI: VM resource Monitor Column types.
Index: trunk/src/VBox/Frontends/VirtualBox/src/extradata/UIExtraDataManager.cpp
===================================================================
--- trunk/src/VBox/Frontends/VirtualBox/src/extradata/UIExtraDataManager.cpp	(revision 86976)
+++ trunk/src/VBox/Frontends/VirtualBox/src/extradata/UIExtraDataManager.cpp	(revision 86977)
@@ -2431,14 +2431,14 @@
 }
 
-MaxGuestResolutionPolicy UIExtraDataManager::maxGuestResolutionPolicy()
+MaximumGuestScreenSizePolicy UIExtraDataManager::maxGuestResolutionPolicy()
 {
     /* Return maximum guest-screen resolution policy: */
-    return gpConverter->fromInternalString<MaxGuestResolutionPolicy>(extraDataString(GUI_MaxGuestResolution));
-}
-
-void UIExtraDataManager::setMaxGuestScreenResolution(MaxGuestResolutionPolicy enmPolicy, const QSize resolution /* = QSize() */)
+    return gpConverter->fromInternalString<MaximumGuestScreenSizePolicy>(extraDataString(GUI_MaxGuestResolution));
+}
+
+void UIExtraDataManager::setMaxGuestScreenResolution(MaximumGuestScreenSizePolicy enmPolicy, const QSize resolution /* = QSize() */)
 {
     /* If policy is 'Fixed' => call the wrapper: */
-    if (enmPolicy == MaxGuestResolutionPolicy_Fixed)
+    if (enmPolicy == MaximumGuestScreenSizePolicy_Fixed)
         setMaxGuestResolutionForPolicyFixed(resolution);
     /* Otherwise => just store the value: */
@@ -2451,8 +2451,8 @@
     /* Acquire maximum guest-screen resolution policy: */
     const QString strPolicy = extraDataString(GUI_MaxGuestResolution);
-    const MaxGuestResolutionPolicy enmPolicy = gpConverter->fromInternalString<MaxGuestResolutionPolicy>(strPolicy);
+    const MaximumGuestScreenSizePolicy enmPolicy = gpConverter->fromInternalString<MaximumGuestScreenSizePolicy>(strPolicy);
 
     /* Make sure maximum guest-screen resolution policy is really Fixed: */
-    if (enmPolicy != MaxGuestResolutionPolicy_Fixed)
+    if (enmPolicy != MaximumGuestScreenSizePolicy_Fixed)
         return QSize();
 
@@ -2474,5 +2474,5 @@
     /* If resolution is 'empty' => call the wrapper: */
     if (resolution.isEmpty())
-        setMaxGuestScreenResolution(MaxGuestResolutionPolicy_Automatic);
+        setMaxGuestScreenResolution(MaximumGuestScreenSizePolicy_Automatic);
     /* Otherwise => just store the value: */
     else
Index: trunk/src/VBox/Frontends/VirtualBox/src/extradata/UIExtraDataManager.h
===================================================================
--- trunk/src/VBox/Frontends/VirtualBox/src/extradata/UIExtraDataManager.h	(revision 86976)
+++ trunk/src/VBox/Frontends/VirtualBox/src/extradata/UIExtraDataManager.h	(revision 86977)
@@ -226,7 +226,7 @@
       * @{ */
         /** Returns maximum guest-screen resolution policy. */
-        MaxGuestResolutionPolicy maxGuestResolutionPolicy();
+        MaximumGuestScreenSizePolicy maxGuestResolutionPolicy();
         /** Defines maximum guest-screen resolution @a enmPolicy or @a resolution itself for Fixed policy. */
-        void setMaxGuestScreenResolution(MaxGuestResolutionPolicy enmPolicy, const QSize resolution = QSize());
+        void setMaxGuestScreenResolution(MaximumGuestScreenSizePolicy enmPolicy, const QSize resolution = QSize());
         /** Returns maximum guest-screen resolution for fixed policy. */
         QSize maxGuestResolutionForPolicyFixed();
Index: trunk/src/VBox/Frontends/VirtualBox/src/runtime/UIMachineView.cpp
===================================================================
--- trunk/src/VBox/Frontends/VirtualBox/src/runtime/UIMachineView.cpp	(revision 86976)
+++ trunk/src/VBox/Frontends/VirtualBox/src/runtime/UIMachineView.cpp	(revision 86977)
@@ -639,5 +639,5 @@
     , m_previousState(KMachineState_Null)
     , m_iHostScreenNumber(0)
-    , m_maxGuestSizePolicy(MaxGuestResolutionPolicy_Automatic)
+    , m_enmMaximumGuestScreenSizePolicy(MaximumGuestScreenSizePolicy_Automatic)
     , m_u64MaxGuestSize(0)
 #ifdef VBOX_WITH_DRAG_AND_DROP_GH
@@ -654,6 +654,6 @@
         /* 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_enmMaximumGuestScreenSizePolicy = gEDataManager->maxGuestResolutionPolicy();
+        if (m_enmMaximumGuestScreenSizePolicy == MaximumGuestScreenSizePolicy_Fixed)
             m_fixedMaxGuestSize = gEDataManager->maxGuestResolutionForPolicyFixed();
     }
@@ -980,13 +980,13 @@
 {
     QSize maxSize;
-    switch (m_maxGuestSizePolicy)
-    {
-        case MaxGuestResolutionPolicy_Fixed:
+    switch (m_enmMaximumGuestScreenSizePolicy)
+    {
+        case MaximumGuestScreenSizePolicy_Fixed:
             maxSize = m_fixedMaxGuestSize;
             break;
-        case MaxGuestResolutionPolicy_Automatic:
+        case MaximumGuestScreenSizePolicy_Automatic:
             maxSize = calculateMaxGuestSize().expandedTo(minimumSizeHint);
             break;
-        case MaxGuestResolutionPolicy_Any:
+        case MaximumGuestScreenSizePolicy_Any:
             /* (0, 0) means any of course. */
             maxSize = QSize(0, 0);
Index: trunk/src/VBox/Frontends/VirtualBox/src/runtime/UIMachineView.h
===================================================================
--- trunk/src/VBox/Frontends/VirtualBox/src/runtime/UIMachineView.h	(revision 86976)
+++ trunk/src/VBox/Frontends/VirtualBox/src/runtime/UIMachineView.h	(revision 86977)
@@ -350,7 +350,6 @@
     int m_iHostScreenNumber;
 
-    /** The policy for calculating the maximum guest resolution which we wish
-     * to handle. */
-    MaxGuestResolutionPolicy m_maxGuestSizePolicy;
+    /** Holds the maximum guest screen size policy. */
+    MaximumGuestScreenSizePolicy m_enmMaximumGuestScreenSizePolicy;
     /** The maximum guest size for fixed size policy. */
     QSize m_fixedMaxGuestSize;
Index: trunk/src/VBox/Frontends/VirtualBox/src/settings/global/UIGlobalSettingsDisplay.cpp
===================================================================
--- trunk/src/VBox/Frontends/VirtualBox/src/settings/global/UIGlobalSettingsDisplay.cpp	(revision 86976)
+++ trunk/src/VBox/Frontends/VirtualBox/src/settings/global/UIGlobalSettingsDisplay.cpp	(revision 86977)
@@ -36,6 +36,6 @@
     /** Constructs data. */
     UIDataSettingsGlobalDisplay()
-        : m_enmMaxGuestResolution(MaxGuestResolutionPolicy_Automatic)
-        , m_maxGuestResolution(QSize())
+        : m_enmMaximumGuestScreenSizePolicy(MaximumGuestScreenSizePolicy_Automatic)
+        , m_maximumGuestScreenSize(QSize())
         , m_fActivateHoveredMachineWindow(false)
     {}
@@ -45,6 +45,6 @@
     {
         return true
-               && (m_enmMaxGuestResolution == other.m_enmMaxGuestResolution)
-               && (m_maxGuestResolution == other.m_maxGuestResolution)
+               && (m_enmMaximumGuestScreenSizePolicy == other.m_enmMaximumGuestScreenSizePolicy)
+               && (m_maximumGuestScreenSize == other.m_maximumGuestScreenSize)
                && (m_fActivateHoveredMachineWindow == other.m_fActivateHoveredMachineWindow)
                && (m_scaleFactors == other.m_scaleFactors)
@@ -57,8 +57,8 @@
     bool operator!=(const UIDataSettingsGlobalDisplay &other) const { return !equal(other); }
 
-    /** Holds the maximum guest-screen resolution policy. */
-    MaxGuestResolutionPolicy m_enmMaxGuestResolution;
-    /** Holds the maximum guest-screen resolution. */
-    QSize m_maxGuestResolution;
+    /** Holds the maximum guest-screen size policy. */
+    MaximumGuestScreenSizePolicy m_enmMaximumGuestScreenSizePolicy;
+    /** Holds the maximum guest-screen size. */
+    QSize m_maximumGuestScreenSize;
     /** Holds whether we should automatically activate machine window under the mouse cursor. */
     bool m_fActivateHoveredMachineWindow;
@@ -103,7 +103,7 @@
 
     /* Gather old display data: */
-    oldDisplayData.m_enmMaxGuestResolution = gEDataManager->maxGuestResolutionPolicy();
-    if (oldDisplayData.m_enmMaxGuestResolution == MaxGuestResolutionPolicy_Fixed)
-        oldDisplayData.m_maxGuestResolution = gEDataManager->maxGuestResolutionForPolicyFixed();
+    oldDisplayData.m_enmMaximumGuestScreenSizePolicy = gEDataManager->maxGuestResolutionPolicy();
+    if (oldDisplayData.m_enmMaximumGuestScreenSizePolicy == MaximumGuestScreenSizePolicy_Fixed)
+        oldDisplayData.m_maximumGuestScreenSize = gEDataManager->maxGuestResolutionForPolicyFixed();
     oldDisplayData.m_fActivateHoveredMachineWindow = gEDataManager->activateHoveredMachineWindow();
     oldDisplayData.m_scaleFactors = gEDataManager->scaleFactors(UIExtraDataManager::GlobalID);
@@ -122,9 +122,9 @@
 
     /* Load old display data from the cache: */
-    m_pComboMaxGuestScreenSize->setCurrentIndex(m_pComboMaxGuestScreenSize->findData((int)oldDisplayData.m_enmMaxGuestResolution));
-    if (oldDisplayData.m_enmMaxGuestResolution == MaxGuestResolutionPolicy_Fixed)
+    m_pComboMaxGuestScreenSize->setCurrentIndex(m_pComboMaxGuestScreenSize->findData((int)oldDisplayData.m_enmMaximumGuestScreenSizePolicy));
+    if (oldDisplayData.m_enmMaximumGuestScreenSizePolicy == MaximumGuestScreenSizePolicy_Fixed)
     {
-        m_pSpinboxMaxGuestScreenWidth->setValue(oldDisplayData.m_maxGuestResolution.width());
-        m_pSpinboxMaxGuestScreenHeight->setValue(oldDisplayData.m_maxGuestResolution.height());
+        m_pSpinboxMaxGuestScreenWidth->setValue(oldDisplayData.m_maximumGuestScreenSize.width());
+        m_pSpinboxMaxGuestScreenHeight->setValue(oldDisplayData.m_maximumGuestScreenSize.height());
     }
     m_pCheckBoxActivateOnMouseHover->setChecked(oldDisplayData.m_fActivateHoveredMachineWindow);
@@ -139,7 +139,7 @@
 
     /* Gather new display data: */
-    newDisplayData.m_enmMaxGuestResolution = (MaxGuestResolutionPolicy)m_pComboMaxGuestScreenSize->itemData(m_pComboMaxGuestScreenSize->currentIndex()).toInt();
-    if (newDisplayData.m_enmMaxGuestResolution == MaxGuestResolutionPolicy_Fixed)
-        newDisplayData.m_maxGuestResolution = QSize(m_pSpinboxMaxGuestScreenWidth->value(), m_pSpinboxMaxGuestScreenHeight->value());
+    newDisplayData.m_enmMaximumGuestScreenSizePolicy = (MaximumGuestScreenSizePolicy)m_pComboMaxGuestScreenSize->itemData(m_pComboMaxGuestScreenSize->currentIndex()).toInt();
+    if (newDisplayData.m_enmMaximumGuestScreenSizePolicy == MaximumGuestScreenSizePolicy_Fixed)
+        newDisplayData.m_maximumGuestScreenSize = QSize(m_pSpinboxMaxGuestScreenWidth->value(), m_pSpinboxMaxGuestScreenHeight->value());
     newDisplayData.m_fActivateHoveredMachineWindow = m_pCheckBoxActivateOnMouseHover->isChecked();
     newDisplayData.m_scaleFactors = m_pEditorScaleFactor->scaleFactors();
@@ -180,12 +180,12 @@
 void UIGlobalSettingsDisplay::sltHandleMaximumGuestScreenSizePolicyChange()
 {
-    /* Get current resolution-combo tool-tip data: */
+    /* Get current size-combo tool-tip data: */
     const QString strCurrentComboItemTip = m_pComboMaxGuestScreenSize->itemData(m_pComboMaxGuestScreenSize->currentIndex(), Qt::ToolTipRole).toString();
     m_pComboMaxGuestScreenSize->setWhatsThis(strCurrentComboItemTip);
 
-    /* Get current resolution-combo item data: */
-    const MaxGuestResolutionPolicy enmPolicy = (MaxGuestResolutionPolicy)m_pComboMaxGuestScreenSize->itemData(m_pComboMaxGuestScreenSize->currentIndex()).toInt();
+    /* Get current size-combo item data: */
+    const MaximumGuestScreenSizePolicy enmPolicy = (MaximumGuestScreenSizePolicy)m_pComboMaxGuestScreenSize->itemData(m_pComboMaxGuestScreenSize->currentIndex()).toInt();
     /* Should be combo-level widgets enabled? */
-    const bool fComboLevelWidgetsEnabled = enmPolicy == MaxGuestResolutionPolicy_Fixed;
+    const bool fComboLevelWidgetsEnabled = enmPolicy == MaximumGuestScreenSizePolicy_Fixed;
     /* Enable/disable combo-level widgets: */
     m_pLabelMaxGuestScreenWidth->setEnabled(fComboLevelWidgetsEnabled);
@@ -327,5 +327,5 @@
     /* Create corresponding items: */
     m_pComboMaxGuestScreenSize->addItem(tr("Automatic", "Maximum Guest Screen Size"),
-                                   QVariant((int)MaxGuestResolutionPolicy_Automatic));
+                                   QVariant((int)MaximumGuestScreenSizePolicy_Automatic));
     m_pComboMaxGuestScreenSize->setItemData(m_pComboMaxGuestScreenSize->count() - 1,
                                        tr("Suggest a reasonable maximum screen size to the guest. "
@@ -333,10 +333,10 @@
                                        Qt::ToolTipRole);
     m_pComboMaxGuestScreenSize->addItem(tr("None", "Maximum Guest Screen Size"),
-                                   QVariant((int)MaxGuestResolutionPolicy_Any));
+                                   QVariant((int)MaximumGuestScreenSizePolicy_Any));
     m_pComboMaxGuestScreenSize->setItemData(m_pComboMaxGuestScreenSize->count() - 1,
                                        tr("Do not attempt to limit the size of the guest screen."),
                                        Qt::ToolTipRole);
     m_pComboMaxGuestScreenSize->addItem(tr("Hint", "Maximum Guest Screen Size"),
-                                   QVariant((int)MaxGuestResolutionPolicy_Fixed));
+                                   QVariant((int)MaximumGuestScreenSizePolicy_Fixed));
     m_pComboMaxGuestScreenSize->setItemData(m_pComboMaxGuestScreenSize->count() - 1,
                                        tr("Suggest a maximum screen size to the guest. "
@@ -363,7 +363,7 @@
         /* Save maximum guest resolution policy and/or value: */
         if (   fSuccess
-            && (   newDisplayData.m_enmMaxGuestResolution != oldDisplayData.m_enmMaxGuestResolution
-                || newDisplayData.m_maxGuestResolution != oldDisplayData.m_maxGuestResolution))
-            gEDataManager->setMaxGuestScreenResolution(newDisplayData.m_enmMaxGuestResolution, newDisplayData.m_maxGuestResolution);
+            && (   newDisplayData.m_enmMaximumGuestScreenSizePolicy != oldDisplayData.m_enmMaximumGuestScreenSizePolicy
+                || newDisplayData.m_maximumGuestScreenSize != oldDisplayData.m_maximumGuestScreenSize))
+            gEDataManager->setMaxGuestScreenResolution(newDisplayData.m_enmMaximumGuestScreenSizePolicy, newDisplayData.m_maximumGuestScreenSize);
         /* Save whether hovered machine-window should be activated automatically: */
         if (fSuccess && newDisplayData.m_fActivateHoveredMachineWindow != oldDisplayData.m_fActivateHoveredMachineWindow)
