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

Timestamp:

Apr 1, 2022 12:07:11 PM (3 years ago)

Author:

vboxsync

Message:

FE/Qt/Ds: bugref:6899: Machine settings: Display page accessibility improvements for Recording tab; Moving recording stuff to separate editor.

Location:

trunk/src/VBox/Frontends/VirtualBox

Files:

• Makefile.kmk (modified) (2 diffs)
• src/settings/UISettingsDefs.h (modified) (1 diff)
• src/settings/editors/UIRecordingSettingsEditor.cpp (copied) (copied from trunk/src/VBox/Frontends/VirtualBox/src/settings/editors/UIVRDESettingsEditor.cpp ) (5 diffs)
• src/settings/editors/UIRecordingSettingsEditor.h (copied) (copied from trunk/src/VBox/Frontends/VirtualBox/src/settings/editors/UIVRDESettingsEditor.h ) (8 diffs)
• src/settings/machine/UIMachineSettingsDisplay.cpp (modified) (26 diffs)
• src/settings/machine/UIMachineSettingsDisplay.h (modified) (6 diffs)
• src/widgets/UIFilePathSelector.h (modified) (1 diff)

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

@@ -912 +912 @@
         src/settings/editors/UINameAndSystemEditor.h \
         src/settings/editors/UINetworkAttachmentEditor.h \
+        src/settings/editors/UIRecordingSettingsEditor.h \
         src/settings/editors/UIScaleFactorEditor.h \
         src/settings/editors/UIShortcutConfigurationEditor.h \
@@ -1471 +1472 @@
         src/settings/editors/UINameAndSystemEditor.cpp \
         src/settings/editors/UINetworkAttachmentEditor.cpp \
+        src/settings/editors/UIRecordingSettingsEditor.cpp \
         src/settings/editors/UIScaleFactorEditor.cpp \
         src/settings/editors/UIShortcutConfigurationEditor.cpp \

trunk/src/VBox/Frontends/VirtualBox/src/settings/UISettingsDefs.h

@@ -65 +65 @@
 }
 
+Q_DECLARE_METATYPE(UISettingsDefs::RecordingMode);
+
 
 /** Template organizing settings object cache: */

trunk/src/VBox/Frontends/VirtualBox/src/settings/editors/UIRecordingSettingsEditor.cpp

@@ -1 +1 @@
 /* $Id$ */
 /** @file
- * VBox Qt GUI - UIVRDESettingsEditor class implementation.
+ * VBox Qt GUI - UIRecordingSettingsEditor class implementation.
  */
 
@@ -18 +18 @@
 /* Qt includes: */
 #include <QCheckBox>
-#include <QComboBox>
+#include <QHBoxLayout>
 #include <QGridLayout>
 #include <QLabel>
-#include <QLineEdit>
+#include <QSpinBox>
+#include <QVBoxLayout>
 
 /* GUI includes: */
+#include "QIAdvancedSlider.h"
+#include "UICommon.h"
 #include "UIConverter.h"
-#include "UIVRDESettingsEditor.h"
-
-
-UIVRDESettingsEditor::UIVRDESettingsEditor(QWidget *pParent /* = 0 */)
+#include "UIFilePathSelector.h"
+#include "UIFilmContainer.h"
+#include "UIRecordingSettingsEditor.h"
+
+/* Defines: */
+#define VIDEO_CAPTURE_BIT_RATE_MIN 32
+#define VIDEO_CAPTURE_BIT_RATE_MAX 2048
+
+
+UIRecordingSettingsEditor::UIRecordingSettingsEditor(QWidget *pParent /* = 0 */)
     : QIWithRetranslateUI<QWidget>(pParent)
     , m_fFeatureEnabled(false)
-    , m_enmAuthType(KAuthType_Max)
-    , m_fMultipleConnectionsAllowed(false)
+    , m_fOptionsAvailable(false)
+    , m_fScreenOptionsAvailable(false)
+    , m_enmMode(UISettingsDefs::RecordingMode_VideoAudio)
+    , m_iFrameWidth(0)
+    , m_iFrameHeight(0)
+    , m_iFrameRate(0)
+    , m_iBitRate(0)
+    , m_iAudioQualityRate(0)
     , m_pCheckboxFeature(0)
-    , m_pWidgetSettings(0)
-    , m_pLabelPort(0)
-    , m_pEditorPort(0)
-    , m_pLabelAuthMethod(0)
-    , m_pComboAuthType(0)
-    , m_pLabelTimeout(0)
-    , m_pEditorTimeout(0)
-    , m_pLabelOptions(0)
-    , m_pCheckboxMultipleConnections(0)
+    , m_pLabelMode(0)
+    , m_pComboMode(0)
+    , m_pLabelFilePath(0)
+    , m_pEditorFilePath(0)
+    , m_pLabelFrameSize(0)
+    , m_pComboFrameSize(0)
+    , m_pSpinboxFrameWidth(0)
+    , m_pSpinboxFrameHeight(0)
+    , m_pLabelFrameRate(0)
+    , m_pWidgetFrameRateSettings(0)
+    , m_pSliderFrameRate(0)
+    , m_pSpinboxFrameRate(0)
+    , m_pLabelFrameRateMin(0)
+    , m_pLabelFrameRateMax(0)
+    , m_pLabelVideoQuality(0)
+    , m_pWidgetVideoQualitySettings(0)
+    , m_pSliderVideoQuality(0)
+    , m_pSpinboxVideoQuality(0)
+    , m_pLabelVideoQualityMin(0)
+    , m_pLabelVideoQualityMed(0)
+    , m_pLabelVideoQualityMax(0)
+    , m_pLabelAudioQuality(0)
+    , m_pWidgetAudioQualitySettings(0)
+    , m_pSliderAudioQuality(0)
+    , m_pLabelAudioQualityMin(0)
+    , m_pLabelAudioQualityMed(0)
+    , m_pLabelAudioQualityMax(0)
+    , m_pLabelSizeHint(0)
+    , m_pLabelScreens(0)
+    , m_pScrollerScreens(0)
 {
     prepare();
 }
 
-void UIVRDESettingsEditor::setFeatureEnabled(bool fEnabled)
+void UIRecordingSettingsEditor::setFeatureEnabled(bool fEnabled)
 {
     /* Update cached value and
@@ -57 +93 @@
         {
             m_pCheckboxFeature->setChecked(m_fFeatureEnabled);
-            sltHandleFeatureToggled(m_pCheckboxFeature->isChecked());
+            sltHandleFeatureToggled();
         }
     }
 }
 
-bool UIVRDESettingsEditor::isFeatureEnabled() const
+bool UIRecordingSettingsEditor::isFeatureEnabled() const
 {
     return m_pCheckboxFeature ? m_pCheckboxFeature->isChecked() : m_fFeatureEnabled;
 }
 
-void UIVRDESettingsEditor::setVRDEOptionsAvailable(bool fAvailable)
-{
-    if (m_pLabelOptions)
-        m_pLabelOptions->setEnabled(fAvailable);
-    if (m_pCheckboxMultipleConnections)
-        m_pCheckboxMultipleConnections->setEnabled(fAvailable);
-}
-
-void UIVRDESettingsEditor::setPort(const QString &strPort)
-{
-    /* Update cached value and
-     * line-edit if value has changed: */
-    if (m_strPort != strPort)
-    {
-        m_strPort = strPort;
-        if (m_pEditorPort)
-            m_pEditorPort->setText(m_strPort);
-    }
-}
-
-QString UIVRDESettingsEditor::port() const
-{
-    return m_pEditorPort ? m_pEditorPort->text() : m_strPort;
-}
-
-void UIVRDESettingsEditor::setAuthType(const KAuthType &enmType)
+void UIRecordingSettingsEditor::setOptionsAvailable(bool fAvailable)
+{
+    /* Update cached value and
+     * widget availability if value has changed: */
+    if (m_fOptionsAvailable != fAvailable)
+    {
+        m_fOptionsAvailable = fAvailable;
+        updateWidgetAvailability();
+    }
+}
+
+void UIRecordingSettingsEditor::setScreenOptionsAvailable(bool fAvailable)
+{
+    /* Update cached value and
+     * widget availability if value has changed: */
+    if (m_fScreenOptionsAvailable != fAvailable)
+    {
+        m_fScreenOptionsAvailable = fAvailable;
+        updateWidgetAvailability();
+    }
+}
+
+void UIRecordingSettingsEditor::setMode(UISettingsDefs::RecordingMode enmMode)
 {
     /* Update cached value and
      * combo if value has changed: */
-    if (m_enmAuthType != enmType)
-    {
-        m_enmAuthType = enmType;
-        repopulateComboAuthType();
-    }
-}
-
-KAuthType UIVRDESettingsEditor::authType() const
-{
-    return m_pComboAuthType ? m_pComboAuthType->currentData().value<KAuthType>() : m_enmAuthType;
-}
-
-void UIVRDESettingsEditor::setTimeout(const QString &strTimeout)
-{
-    /* Update cached value and
-     * line-edit if value has changed: */
-    if (m_strTimeout != strTimeout)
-    {
-        m_strTimeout = strTimeout;
-        if (m_pEditorTimeout)
-            m_pEditorTimeout->setText(m_strTimeout);
-    }
-}
-
-QString UIVRDESettingsEditor::timeout() const
-{
-    return m_pEditorTimeout ? m_pEditorTimeout->text() : m_strTimeout;
-}
-
-void UIVRDESettingsEditor::setMultipleConnectionsAllowed(bool fAllowed)
-{
-    /* Update cached value and
-     * check-box if value has changed: */
-    if (m_fMultipleConnectionsAllowed != fAllowed)
-    {
-        m_fMultipleConnectionsAllowed = fAllowed;
-        if (m_pCheckboxMultipleConnections)
-            m_pCheckboxMultipleConnections->setChecked(m_fMultipleConnectionsAllowed);
-    }
-}
-
-bool UIVRDESettingsEditor::isMultipleConnectionsAllowed() const
-{
-    return m_pCheckboxMultipleConnections ? m_pCheckboxMultipleConnections->isChecked() : m_fMultipleConnectionsAllowed;
-}
-
-void UIVRDESettingsEditor::retranslateUi()
-{
-    if (m_pCheckboxFeature)
-    {
-        m_pCheckboxFeature->setText(tr("&Enable Server"));
-        m_pCheckboxFeature->setToolTip(tr("When checked, the VM will act as a Remote Desktop Protocol (RDP) server, allowing "
-                                          "remote clients to connect and operate the VM (when it is running) using a standard "
-                                          "RDP client."));
-    }
-
-    if (m_pLabelPort)
-        m_pLabelPort->setText(tr("Server &Port:"));
-    if (m_pEditorPort)
-        m_pEditorPort->setToolTip(tr("Holds the VRDP Server port number. You may specify 0 (zero), to select port 3389, the "
-                                     "standard port for RDP."));
-
-    if (m_pLabelAuthMethod)
-        m_pLabelAuthMethod->setText(tr("Authentication &Method:"));
-    if (m_pComboAuthType)
-    {
-        for (int iIndex = 0; iIndex < m_pComboAuthType->count(); ++iIndex)
+    if (m_enmMode != enmMode)
+    {
+        m_enmMode = enmMode;
+        if (m_pComboMode)
         {
-            const KAuthType enmType = m_pComboAuthType->itemData(iIndex).value<KAuthType>();
-            m_pComboAuthType->setItemText(iIndex, gpConverter->toString(enmType));
+            const int iIndex = m_pComboMode->findData(QVariant::fromValue(enmMode));
+            if (iIndex != -1)
+                m_pComboMode->setCurrentIndex(iIndex);
         }
-        m_pComboAuthType->setToolTip(tr("Selects the VRDP authentication method."));
-    }
-
-    if (m_pLabelTimeout)
-        m_pLabelTimeout->setText(tr("Authentication &Timeout:"));
-    if (m_pEditorTimeout)
-        m_pEditorTimeout->setToolTip(tr("Holds the timeout for guest authentication, in milliseconds."));
-
-    if (m_pLabelOptions)
-        m_pLabelOptions->setText(tr("Extended Features:"));
-    if (m_pCheckboxMultipleConnections)
-    {
-        m_pCheckboxMultipleConnections->setText(tr("&Allow Multiple Connections"));
-        m_pCheckboxMultipleConnections->setToolTip(tr("When checked, multiple simultaneous connections to the VM are "
-                                                      "permitted."));
-    }
-}
-
-void UIVRDESettingsEditor::sltHandleFeatureToggled(bool fEnabled)
+    }
+}
+
+UISettingsDefs::RecordingMode UIRecordingSettingsEditor::mode() const
+{
+    return m_pComboMode ? m_pComboMode->currentData().value<UISettingsDefs::RecordingMode>() : m_enmMode;
+}
+
+void UIRecordingSettingsEditor::setFolder(const QString &strFolder)
+{
+    /* Update cached value and
+     * file editor if value has changed: */
+    if (m_strFolder != strFolder)
+    {
+        m_strFolder = strFolder;
+        if (m_pEditorFilePath)
+            m_pEditorFilePath->setInitialPath(m_strFolder);
+    }
+}
+
+QString UIRecordingSettingsEditor::folder() const
+{
+    return m_pEditorFilePath ? m_pEditorFilePath->initialPath() : m_strFolder;
+}
+
+void UIRecordingSettingsEditor::setFilePath(const QString &strFilePath)
+{
+    /* Update cached value and
+     * file editor if value has changed: */
+    if (m_strFilePath != strFilePath)
+    {
+        m_strFilePath = strFilePath;
+        if (m_pEditorFilePath)
+            m_pEditorFilePath->setPath(m_strFilePath);
+    }
+}
+
+QString UIRecordingSettingsEditor::filePath() const
+{
+    return m_pEditorFilePath ? m_pEditorFilePath->path() : m_strFilePath;
+}
+
+void UIRecordingSettingsEditor::setFrameWidth(int iWidth)
+{
+    /* Update cached value and
+     * spin-box if value has changed: */
+    if (m_iFrameWidth != iWidth)
+    {
+        m_iFrameWidth = iWidth;
+        if (m_pSpinboxFrameWidth)
+            m_pSpinboxFrameWidth->setValue(m_iFrameWidth);
+    }
+}
+
+int UIRecordingSettingsEditor::frameWidth() const
+{
+    return m_pSpinboxFrameWidth ? m_pSpinboxFrameWidth->value() : m_iFrameWidth;
+}
+
+void UIRecordingSettingsEditor::setFrameHeight(int iHeight)
+{
+    /* Update cached value and
+     * spin-box if value has changed: */
+    if (m_iFrameHeight != iHeight)
+    {
+        m_iFrameHeight = iHeight;
+        if (m_pSpinboxFrameHeight)
+            m_pSpinboxFrameHeight->setValue(m_iFrameHeight);
+    }
+}
+
+int UIRecordingSettingsEditor::frameHeight() const
+{
+    return m_pSpinboxFrameHeight ? m_pSpinboxFrameHeight->value() : m_iFrameHeight;
+}
+
+void UIRecordingSettingsEditor::setFrameRate(int iRate)
+{
+    /* Update cached value and
+     * spin-box if value has changed: */
+    if (m_iFrameRate != iRate)
+    {
+        m_iFrameRate = iRate;
+        if (m_pSpinboxFrameRate)
+            m_pSpinboxFrameRate->setValue(m_iFrameRate);
+    }
+}
+
+int UIRecordingSettingsEditor::frameRate() const
+{
+    return m_pSpinboxFrameRate ? m_pSpinboxFrameRate->value() : m_iFrameRate;
+}
+
+void UIRecordingSettingsEditor::setBitRate(int iRate)
+{
+    /* Update cached value and
+     * spin-box if value has changed: */
+    if (m_iBitRate != iRate)
+    {
+        m_iBitRate = iRate;
+        if (m_pSpinboxVideoQuality)
+            m_pSpinboxVideoQuality->setValue(m_iBitRate);
+    }
+}
+
+int UIRecordingSettingsEditor::bitRate() const
+{
+    return m_pSpinboxVideoQuality ? m_pSpinboxVideoQuality->value() : m_iBitRate;
+}
+
+void UIRecordingSettingsEditor::setAudioQualityRate(int iRate)
+{
+    /* Update cached value and
+     * slider if value has changed: */
+    if (m_iAudioQualityRate != iRate)
+    {
+        m_iAudioQualityRate = iRate;
+        if (m_pSliderAudioQuality)
+            m_pSliderAudioQuality->setValue(m_iAudioQualityRate);
+    }
+}
+
+int UIRecordingSettingsEditor::audioQualityRate() const
+{
+    return m_pSliderAudioQuality ? m_pSliderAudioQuality->value() : m_iAudioQualityRate;
+}
+
+void UIRecordingSettingsEditor::setScreens(const QVector<BOOL> &screens)
+{
+    /* Update cached value and
+     * editor if value has changed: */
+    if (m_screens != screens)
+    {
+        m_screens = screens;
+        if (m_pScrollerScreens)
+            m_pScrollerScreens->setValue(m_screens);
+    }
+}
+
+QVector<BOOL> UIRecordingSettingsEditor::screens() const
+{
+    return m_pScrollerScreens ? m_pScrollerScreens->value() : m_screens;
+}
+
+void UIRecordingSettingsEditor::retranslateUi()
+{
+    m_pCheckboxFeature->setText(tr("&Enable Recording"));
+    m_pCheckboxFeature->setToolTip(tr("When checked, VirtualBox will record the virtual machine session as a video file."));
+
+    m_pLabelMode->setText(tr("Recording &Mode:"));
+    for (int iIndex = 0; iIndex < m_pComboMode->count(); ++iIndex)
+    {
+        const UISettingsDefs::RecordingMode enmType =
+            m_pComboMode->itemData(iIndex).value<UISettingsDefs::RecordingMode>();
+        m_pComboMode->setItemText(iIndex, gpConverter->toString(enmType));
+    }
+    m_pComboMode->setToolTip(tr("Holds the recording mode."));
+
+    m_pLabelFilePath->setText(tr("File &Path:"));
+    m_pEditorFilePath->setToolTip(tr("Holds the filename VirtualBox uses to save the recorded content."));
+
+    m_pLabelFrameSize->setText(tr("Frame Si&ze:"));
+    m_pComboFrameSize->setItemText(0, tr("User Defined"));
+    m_pComboFrameSize->setToolTip(tr("Holds the resolution (frame size) of the recorded video."));
+    m_pSpinboxFrameWidth->setToolTip(tr("Holds the horizontal resolution (frame width) of the recorded video."));
+    m_pSpinboxFrameHeight->setToolTip(tr("Holds the vertical resolution (frame height) of the recorded video."));
+
+    m_pLabelFrameRate->setText(tr("Frame R&ate:"));
+    m_pSliderFrameRate->setToolTip(tr("Holds the maximum number of frames per second. Additional frames "
+                                      "will be skipped. Reducing this value will increase the number of skipped "
+                                      "frames and reduce the file size."));
+    m_pSpinboxFrameRate->setSuffix(QString(" %1").arg(tr("fps")));
+    m_pSpinboxFrameRate->setToolTip(tr("Holds the maximum number of frames per second. Additional frames "
+                                       "will be skipped. Reducing this value will increase the number of skipped "
+                                       "frames and reduce the file size."));
+    m_pLabelFrameRateMin->setText(tr("%1 fps").arg(m_pSliderFrameRate->minimum()));
+    m_pLabelFrameRateMax->setText(tr("%1 fps").arg(m_pSliderFrameRate->maximum()));
+
+    m_pLabelVideoQuality->setText(tr("&Video Quality:"));
+    m_pSliderVideoQuality->setToolTip(tr("Holds the quality. Increasing this value will make the video "
+                                         "look better at the cost of an increased file size."));
+    m_pSpinboxVideoQuality->setSuffix(QString(" %1").arg(tr("kbps")));
+    m_pSpinboxVideoQuality->setToolTip(tr("Holds the bitrate in kilobits per second. Increasing this value "
+                                          "will make the video look better at the cost of an increased file size."));
+    m_pLabelVideoQualityMin->setText(tr("low", "quality"));
+    m_pLabelVideoQualityMed->setText(tr("medium", "quality"));
+    m_pLabelVideoQualityMax->setText(tr("high", "quality"));
+
+    m_pLabelAudioQuality->setText(tr("&Audio Quality:"));
+    m_pSliderAudioQuality->setToolTip(tr("Holds the quality. Increasing this value will make the audio "
+                                         "sound better at the cost of an increased file size."));
+    m_pLabelAudioQualityMin->setText(tr("low", "quality"));
+    m_pLabelAudioQualityMed->setText(tr("medium", "quality"));
+    m_pLabelAudioQualityMax->setText(tr("high", "quality"));
+
+    m_pLabelScreens->setText(tr("Scree&ns:"));
+
+    updateRecordingFileSizeHint();
+}
+
+void UIRecordingSettingsEditor::sltHandleFeatureToggled()
 {
     /* Update widget availability: */
-    if (m_pWidgetSettings)
-        m_pWidgetSettings->setEnabled(fEnabled);
-
-    /* Notify listeners: */
-    emit sigChanged();
-}
-
-void UIVRDESettingsEditor::prepare()
+    updateWidgetAvailability();
+}
+
+void UIRecordingSettingsEditor::sltHandleModeComboChange()
+{
+    /* Update widget availability: */
+    updateWidgetAvailability();
+}
+
+void UIRecordingSettingsEditor::sltHandleVideoFrameSizeComboChange()
+{
+    /* Get the proposed size: */
+    const int iCurrentIndex = m_pComboFrameSize->currentIndex();
+    const QSize videoCaptureSize = m_pComboFrameSize->itemData(iCurrentIndex).toSize();
+
+    /* Make sure its valid: */
+    if (!videoCaptureSize.isValid())
+        return;
+
+    /* Apply proposed size: */
+    m_pSpinboxFrameWidth->setValue(videoCaptureSize.width());
+    m_pSpinboxFrameHeight->setValue(videoCaptureSize.height());
+}
+
+void UIRecordingSettingsEditor::sltHandleVideoFrameWidthChange()
+{
+    /* Look for preset: */
+    lookForCorrespondingFrameSizePreset();
+    /* Update quality and bit-rate: */
+    sltHandleVideoBitRateSliderChange();
+}
+
+void UIRecordingSettingsEditor::sltHandleVideoFrameHeightChange()
+{
+    /* Look for preset: */
+    lookForCorrespondingFrameSizePreset();
+    /* Update quality and bit-rate: */
+    sltHandleVideoBitRateSliderChange();
+}
+
+void UIRecordingSettingsEditor::sltHandleVideoFrameRateSliderChange()
+{
+    /* Apply proposed frame-rate: */
+    m_pSpinboxFrameRate->blockSignals(true);
+    m_pSpinboxFrameRate->setValue(m_pSliderFrameRate->value());
+    m_pSpinboxFrameRate->blockSignals(false);
+    /* Update quality and bit-rate: */
+    sltHandleVideoBitRateSliderChange();
+}
+
+void UIRecordingSettingsEditor::sltHandleVideoFrameRateSpinboxChange()
+{
+    /* Apply proposed frame-rate: */
+    m_pSliderFrameRate->blockSignals(true);
+    m_pSliderFrameRate->setValue(m_pSpinboxFrameRate->value());
+    m_pSliderFrameRate->blockSignals(false);
+    /* Update quality and bit-rate: */
+    sltHandleVideoBitRateSliderChange();
+}
+
+void UIRecordingSettingsEditor::sltHandleVideoBitRateSliderChange()
+{
+    /* Calculate/apply proposed bit-rate: */
+    m_pSpinboxVideoQuality->blockSignals(true);
+    m_pSpinboxVideoQuality->setValue(calculateBitRate(m_pSpinboxFrameWidth->value(),
+                                                               m_pSpinboxFrameHeight->value(),
+                                                               m_pSpinboxFrameRate->value(),
+                                                               m_pSliderVideoQuality->value()));
+    m_pSpinboxVideoQuality->blockSignals(false);
+    updateRecordingFileSizeHint();
+}
+
+void UIRecordingSettingsEditor::sltHandleVideoBitRateSpinboxChange()
+{
+    /* Calculate/apply proposed quality: */
+    m_pSliderVideoQuality->blockSignals(true);
+    m_pSliderVideoQuality->setValue(calculateQuality(m_pSpinboxFrameWidth->value(),
+                                                              m_pSpinboxFrameHeight->value(),
+                                                              m_pSpinboxFrameRate->value(),
+                                                              m_pSpinboxVideoQuality->value()));
+    m_pSliderVideoQuality->blockSignals(false);
+    updateRecordingFileSizeHint();
+}
+
+void UIRecordingSettingsEditor::prepare()
 {
     /* Prepare everything: */
@@ -205 +435 @@
 }
 
-void UIVRDESettingsEditor::prepareWidgets()
+void UIRecordingSettingsEditor::prepareWidgets()
 {
     /* Prepare main layout: */
@@ -225 +455 @@
 
         /* Prepare 'settings' widget: */
-        m_pWidgetSettings = new QWidget(this);
-        if (m_pWidgetSettings)
+        QWidget *pWidgetSettings = new QWidget(this);
+        if (pWidgetSettings)
         {
-            /* Prepare 'settings' layout: */
-            QGridLayout *pLayoutRemoteDisplaySettings = new QGridLayout(m_pWidgetSettings);
-            if (pLayoutRemoteDisplaySettings)
+            /* Prepare recording settings widget layout: */
+            QGridLayout *pLayoutSettings = new QGridLayout(pWidgetSettings);
+            if (pLayoutSettings)
             {
-                pLayoutRemoteDisplaySettings->setContentsMargins(0, 0, 0, 0);
-                pLayoutRemoteDisplaySettings->setColumnStretch(1, 1);
-
-                /* Prepare 'port' label: */
-                m_pLabelPort = new QLabel(m_pWidgetSettings);
-                if (m_pLabelPort)
-                {
-                    m_pLabelPort->setAlignment(Qt::AlignRight | Qt::AlignVCenter);
-                    pLayoutRemoteDisplaySettings->addWidget(m_pLabelPort, 0, 0);
-                }
-                /* Prepare 'port' editor: */
-                m_pEditorPort = new QLineEdit(m_pWidgetSettings);
-                if (m_pEditorPort)
-                {
-                    if (m_pLabelPort)
-                        m_pLabelPort->setBuddy(m_pEditorPort);
-                    m_pEditorPort->setValidator(new QRegularExpressionValidator(
-                        QRegularExpression("(([0-9]{1,5}(\\-[0-9]{1,5}){0,1}),)*([0-9]{1,5}(\\-[0-9]{1,5}){0,1})"), this));
-
-                    pLayoutRemoteDisplaySettings->addWidget(m_pEditorPort, 0, 1, 1, 2);
-                }
-
-                /* Prepare 'auth type' label: */
-                m_pLabelAuthMethod = new QLabel(m_pWidgetSettings);
-                if (m_pLabelAuthMethod)
-                {
-                    m_pLabelAuthMethod->setAlignment(Qt::AlignRight | Qt::AlignVCenter);
-                    pLayoutRemoteDisplaySettings->addWidget(m_pLabelAuthMethod, 1, 0);
-                }
-                /* Prepare 'auth type' combo: */
-                m_pComboAuthType = new QComboBox(m_pWidgetSettings);
-                if (m_pComboAuthType)
-                {
-                    if (m_pLabelAuthMethod)
-                        m_pLabelAuthMethod->setBuddy(m_pComboAuthType);
-                    m_pComboAuthType->setSizeAdjustPolicy(QComboBox::AdjustToContents);
-
-                    pLayoutRemoteDisplaySettings->addWidget(m_pComboAuthType, 1, 1, 1, 2);
-                }
-
-                /* Prepare 'timeout' label: */
-                m_pLabelTimeout = new QLabel(m_pWidgetSettings);
-                if (m_pLabelTimeout)
-                {
-                    m_pLabelTimeout->setAlignment(Qt::AlignRight | Qt::AlignVCenter);
-                    pLayoutRemoteDisplaySettings->addWidget(m_pLabelTimeout, 2, 0);
-                }
-                /* Prepare 'timeout' editor: */
-                m_pEditorTimeout = new QLineEdit(m_pWidgetSettings);
-                if (m_pEditorTimeout)
-                {
-                    if (m_pLabelTimeout)
-                        m_pLabelTimeout->setBuddy(m_pEditorTimeout);
-                    m_pEditorTimeout->setValidator(new QIntValidator(this));
-
-                    pLayoutRemoteDisplaySettings->addWidget(m_pEditorTimeout, 2, 1, 1, 2);
-                }
-
-                /* Prepare 'options' label: */
-                m_pLabelOptions = new QLabel(m_pWidgetSettings);
-                if (m_pLabelOptions)
-                {
-                    m_pLabelOptions->setAlignment(Qt::AlignRight | Qt::AlignVCenter);
-                    pLayoutRemoteDisplaySettings->addWidget(m_pLabelOptions, 3, 0);
-                }
-                /* Prepare 'multiple connections' check-box: */
-                m_pCheckboxMultipleConnections = new QCheckBox(m_pWidgetSettings);
-                if (m_pCheckboxMultipleConnections)
-                    pLayoutRemoteDisplaySettings->addWidget(m_pCheckboxMultipleConnections, 3, 1);
+                pLayoutSettings->setContentsMargins(0, 0, 0, 0);
+
+                /* Prepare recording mode label: */
+                m_pLabelMode = new QLabel(pWidgetSettings);
+                if (m_pLabelMode)
+                {
+                    m_pLabelMode->setAlignment(Qt::AlignRight | Qt::AlignVCenter);
+                    pLayoutSettings->addWidget(m_pLabelMode, 0, 0);
+                }
+                /* Prepare recording mode combo: */
+                m_pComboMode = new QComboBox(pWidgetSettings);
+                if (m_pComboMode)
+                {
+                    if (m_pLabelMode)
+                        m_pLabelMode->setBuddy(m_pComboMode);
+                    m_pComboMode->addItem(QString(), QVariant::fromValue(UISettingsDefs::RecordingMode_VideoAudio));
+                    m_pComboMode->addItem(QString(), QVariant::fromValue(UISettingsDefs::RecordingMode_VideoOnly));
+                    m_pComboMode->addItem(QString(), QVariant::fromValue(UISettingsDefs::RecordingMode_AudioOnly));
+
+                    pLayoutSettings->addWidget(m_pComboMode, 0, 1, 1, 3);
+                }
+
+                /* Prepare recording file path label: */
+                m_pLabelFilePath = new QLabel(pWidgetSettings);
+                if (m_pLabelFilePath)
+                {
+                    m_pLabelFilePath->setAlignment(Qt::AlignRight | Qt::AlignVCenter);
+                    pLayoutSettings->addWidget(m_pLabelFilePath, 1, 0);
+                }
+                /* Prepare recording file path editor: */
+                m_pEditorFilePath = new UIFilePathSelector(pWidgetSettings);
+                if (m_pEditorFilePath)
+                {
+                    if (m_pLabelFilePath)
+                        m_pLabelFilePath->setBuddy(m_pEditorFilePath->focusProxy());
+                    m_pEditorFilePath->setEditable(false);
+                    m_pEditorFilePath->setMode(UIFilePathSelector::Mode_File_Save);
+
+                    pLayoutSettings->addWidget(m_pEditorFilePath, 1, 1, 1, 3);
+                }
+
+                /* Prepare recording frame size label: */
+                m_pLabelFrameSize = new QLabel(pWidgetSettings);
+                if (m_pLabelFrameSize)
+                {
+                    m_pLabelFrameSize->setAlignment(Qt::AlignRight | Qt::AlignVCenter);
+                    pLayoutSettings->addWidget(m_pLabelFrameSize, 2, 0);
+                }
+                /* Prepare recording frame size combo: */
+                m_pComboFrameSize = new QComboBox(pWidgetSettings);
+                if (m_pComboFrameSize)
+                {
+                    if (m_pLabelFrameSize)
+                        m_pLabelFrameSize->setBuddy(m_pComboFrameSize);
+                    m_pComboFrameSize->setSizePolicy(QSizePolicy(QSizePolicy::MinimumExpanding, QSizePolicy::Fixed));
+                    m_pComboFrameSize->addItem(""); /* User Defined */
+                    m_pComboFrameSize->addItem("320 x 200 (16:10)",   QSize(320, 200));
+                    m_pComboFrameSize->addItem("640 x 480 (4:3)",     QSize(640, 480));
+                    m_pComboFrameSize->addItem("720 x 400 (9:5)",     QSize(720, 400));
+                    m_pComboFrameSize->addItem("720 x 480 (3:2)",     QSize(720, 480));
+                    m_pComboFrameSize->addItem("800 x 600 (4:3)",     QSize(800, 600));
+                    m_pComboFrameSize->addItem("1024 x 768 (4:3)",    QSize(1024, 768));
+                    m_pComboFrameSize->addItem("1152 x 864 (4:3)",    QSize(1152, 864));
+                    m_pComboFrameSize->addItem("1280 x 720 (16:9)",   QSize(1280, 720));
+                    m_pComboFrameSize->addItem("1280 x 800 (16:10)",  QSize(1280, 800));
+                    m_pComboFrameSize->addItem("1280 x 960 (4:3)",    QSize(1280, 960));
+                    m_pComboFrameSize->addItem("1280 x 1024 (5:4)",   QSize(1280, 1024));
+                    m_pComboFrameSize->addItem("1366 x 768 (16:9)",   QSize(1366, 768));
+                    m_pComboFrameSize->addItem("1440 x 900 (16:10)",  QSize(1440, 900));
+                    m_pComboFrameSize->addItem("1440 x 1080 (4:3)",   QSize(1440, 1080));
+                    m_pComboFrameSize->addItem("1600 x 900 (16:9)",   QSize(1600, 900));
+                    m_pComboFrameSize->addItem("1680 x 1050 (16:10)", QSize(1680, 1050));
+                    m_pComboFrameSize->addItem("1600 x 1200 (4:3)",   QSize(1600, 1200));
+                    m_pComboFrameSize->addItem("1920 x 1080 (16:9)",  QSize(1920, 1080));
+                    m_pComboFrameSize->addItem("1920 x 1200 (16:10)", QSize(1920, 1200));
+                    m_pComboFrameSize->addItem("1920 x 1440 (4:3)",   QSize(1920, 1440));
+                    m_pComboFrameSize->addItem("2880 x 1800 (16:10)", QSize(2880, 1800));
+
+                    pLayoutSettings->addWidget(m_pComboFrameSize, 2, 1);
+                }
+                /* Prepare recording frame width spinbox: */
+                m_pSpinboxFrameWidth = new QSpinBox(pWidgetSettings);
+                if (m_pSpinboxFrameWidth)
+                {
+                    uiCommon().setMinimumWidthAccordingSymbolCount(m_pSpinboxFrameWidth, 5);
+                    m_pSpinboxFrameWidth->setMinimum(16);
+                    m_pSpinboxFrameWidth->setMaximum(2880);
+
+                    pLayoutSettings->addWidget(m_pSpinboxFrameWidth, 2, 2);
+                }
+                /* Prepare recording frame height spinbox: */
+                m_pSpinboxFrameHeight = new QSpinBox(pWidgetSettings);
+                if (m_pSpinboxFrameHeight)
+                {
+                    uiCommon().setMinimumWidthAccordingSymbolCount(m_pSpinboxFrameHeight, 5);
+                    m_pSpinboxFrameHeight->setMinimum(16);
+                    m_pSpinboxFrameHeight->setMaximum(1800);
+
+                    pLayoutSettings->addWidget(m_pSpinboxFrameHeight, 2, 3);
+                }
+
+                /* Prepare recording frame rate label: */
+                m_pLabelFrameRate = new QLabel(pWidgetSettings);
+                if (m_pLabelFrameRate)
+                {
+                    m_pLabelFrameRate->setAlignment(Qt::AlignRight | Qt::AlignVCenter);
+                    pLayoutSettings->addWidget(m_pLabelFrameRate, 3, 0);
+                }
+                /* Prepare recording frame rate widget: */
+                m_pWidgetFrameRateSettings = new QWidget(pWidgetSettings);
+                if (m_pWidgetFrameRateSettings)
+                {
+                    /* Prepare recording frame rate layout: */
+                    QVBoxLayout *pLayoutRecordingFrameRate = new QVBoxLayout(m_pWidgetFrameRateSettings);
+                    if (pLayoutRecordingFrameRate)
+                    {
+                        pLayoutRecordingFrameRate->setContentsMargins(0, 0, 0, 0);
+
+                        /* Prepare recording frame rate slider: */
+                        m_pSliderFrameRate = new QIAdvancedSlider(m_pWidgetFrameRateSettings);
+                        if (m_pSliderFrameRate)
+                        {
+                            m_pSliderFrameRate->setOrientation(Qt::Horizontal);
+                            m_pSliderFrameRate->setMinimum(1);
+                            m_pSliderFrameRate->setMaximum(30);
+                            m_pSliderFrameRate->setPageStep(1);
+                            m_pSliderFrameRate->setSingleStep(1);
+                            m_pSliderFrameRate->setTickInterval(1);
+                            m_pSliderFrameRate->setSnappingEnabled(true);
+                            m_pSliderFrameRate->setOptimalHint(1, 25);
+                            m_pSliderFrameRate->setWarningHint(25, 30);
+
+                            pLayoutRecordingFrameRate->addWidget(m_pSliderFrameRate);
+                        }
+                        /* Prepare recording frame rate scale layout: */
+                        QHBoxLayout *pLayoutRecordingFrameRateScale = new QHBoxLayout;
+                        if (pLayoutRecordingFrameRateScale)
+                        {
+                            pLayoutRecordingFrameRateScale->setContentsMargins(0, 0, 0, 0);
+
+                            /* Prepare recording frame rate min label: */
+                            m_pLabelFrameRateMin = new QLabel(m_pWidgetFrameRateSettings);
+                            if (m_pLabelFrameRateMin)
+                                pLayoutRecordingFrameRateScale->addWidget(m_pLabelFrameRateMin);
+                            pLayoutRecordingFrameRateScale->addStretch();
+                            /* Prepare recording frame rate max label: */
+                            m_pLabelFrameRateMax = new QLabel(m_pWidgetFrameRateSettings);
+                            if (m_pLabelFrameRateMax)
+                                pLayoutRecordingFrameRateScale->addWidget(m_pLabelFrameRateMax);
+
+                            pLayoutRecordingFrameRate->addLayout(pLayoutRecordingFrameRateScale);
+                        }
+                    }
+
+                    pLayoutSettings->addWidget(m_pWidgetFrameRateSettings, 3, 1, 2, 1);
+                }
+                /* Prepare recording frame rate spinbox: */
+                m_pSpinboxFrameRate = new QSpinBox(pWidgetSettings);
+                if (m_pSpinboxFrameRate)
+                {
+                    if (m_pLabelFrameRate)
+                        m_pLabelFrameRate->setBuddy(m_pSpinboxFrameRate);
+                    uiCommon().setMinimumWidthAccordingSymbolCount(m_pSpinboxFrameRate, 3);
+                    m_pSpinboxFrameRate->setMinimum(1);
+                    m_pSpinboxFrameRate->setMaximum(30);
+
+                    pLayoutSettings->addWidget(m_pSpinboxFrameRate, 3, 2, 1, 2);
+                }
+
+                /* Prepare recording video quality label: */
+                m_pLabelVideoQuality = new QLabel(pWidgetSettings);
+                if (m_pLabelVideoQuality)
+                {
+                    m_pLabelVideoQuality->setAlignment(Qt::AlignRight | Qt::AlignVCenter);
+                    pLayoutSettings->addWidget(m_pLabelVideoQuality, 5, 0);
+                }
+                /* Prepare recording video quality widget: */
+                m_pWidgetVideoQualitySettings = new QWidget(pWidgetSettings);
+                if (m_pWidgetVideoQualitySettings)
+                {
+                    /* Prepare recording video quality layout: */
+                    QVBoxLayout *pLayoutRecordingVideoQuality = new QVBoxLayout(m_pWidgetVideoQualitySettings);
+                    if (pLayoutRecordingVideoQuality)
+                    {
+                        pLayoutRecordingVideoQuality->setContentsMargins(0, 0, 0, 0);
+
+                        /* Prepare recording video quality slider: */
+                        m_pSliderVideoQuality = new QIAdvancedSlider(m_pWidgetVideoQualitySettings);
+                        if (m_pSliderVideoQuality)
+                        {
+                            m_pSliderVideoQuality->setOrientation(Qt::Horizontal);
+                            m_pSliderVideoQuality->setMinimum(1);
+                            m_pSliderVideoQuality->setMaximum(10);
+                            m_pSliderVideoQuality->setPageStep(1);
+                            m_pSliderVideoQuality->setSingleStep(1);
+                            m_pSliderVideoQuality->setTickInterval(1);
+                            m_pSliderVideoQuality->setSnappingEnabled(true);
+                            m_pSliderVideoQuality->setOptimalHint(1, 5);
+                            m_pSliderVideoQuality->setWarningHint(5, 9);
+                            m_pSliderVideoQuality->setErrorHint(9, 10);
+
+                            pLayoutRecordingVideoQuality->addWidget(m_pSliderVideoQuality);
+                        }
+                        /* Prepare recording video quality scale layout: */
+                        QHBoxLayout *pLayoutRecordingVideoQialityScale = new QHBoxLayout;
+                        if (pLayoutRecordingVideoQialityScale)
+                        {
+                            pLayoutRecordingVideoQialityScale->setContentsMargins(0, 0, 0, 0);
+
+                            /* Prepare recording video quality min label: */
+                            m_pLabelVideoQualityMin = new QLabel(m_pWidgetVideoQualitySettings);
+                            if (m_pLabelVideoQualityMin)
+                                pLayoutRecordingVideoQialityScale->addWidget(m_pLabelVideoQualityMin);
+                            pLayoutRecordingVideoQialityScale->addStretch();
+                            /* Prepare recording video quality med label: */
+                            m_pLabelVideoQualityMed = new QLabel(m_pWidgetVideoQualitySettings);
+                            if (m_pLabelVideoQualityMed)
+                                pLayoutRecordingVideoQialityScale->addWidget(m_pLabelVideoQualityMed);
+                            pLayoutRecordingVideoQialityScale->addStretch();
+                            /* Prepare recording video quality max label: */
+                            m_pLabelVideoQualityMax = new QLabel(m_pWidgetVideoQualitySettings);
+                            if (m_pLabelVideoQualityMax)
+                                pLayoutRecordingVideoQialityScale->addWidget(m_pLabelVideoQualityMax);
+
+                            pLayoutRecordingVideoQuality->addLayout(pLayoutRecordingVideoQialityScale);
+                        }
+                    }
+
+                    pLayoutSettings->addWidget(m_pWidgetVideoQualitySettings, 5, 1, 2, 1);
+                }
+                /* Prepare recording video quality spinbox: */
+                m_pSpinboxVideoQuality = new QSpinBox(pWidgetSettings);
+                if (m_pSpinboxVideoQuality)
+                {
+                    if (m_pLabelVideoQuality)
+                        m_pLabelVideoQuality->setBuddy(m_pSpinboxVideoQuality);
+                    uiCommon().setMinimumWidthAccordingSymbolCount(m_pSpinboxVideoQuality, 5);
+                    m_pSpinboxVideoQuality->setMinimum(VIDEO_CAPTURE_BIT_RATE_MIN);
+                    m_pSpinboxVideoQuality->setMaximum(VIDEO_CAPTURE_BIT_RATE_MAX);
+
+                    pLayoutSettings->addWidget(m_pSpinboxVideoQuality, 5, 2, 1, 2);
+                }
+
+                /* Prepare recording audio quality label: */
+                m_pLabelAudioQuality = new QLabel(pWidgetSettings);
+                if (m_pLabelAudioQuality)
+                {
+                    m_pLabelAudioQuality->setAlignment(Qt::AlignRight | Qt::AlignVCenter);
+                    pLayoutSettings->addWidget(m_pLabelAudioQuality, 7, 0);
+                }
+                /* Prepare recording audio quality widget: */
+                m_pWidgetAudioQualitySettings = new QWidget(pWidgetSettings);
+                if (m_pWidgetAudioQualitySettings)
+                {
+                    /* Prepare recording audio quality layout: */
+                    QVBoxLayout *pLayoutRecordingAudioQuality = new QVBoxLayout(m_pWidgetAudioQualitySettings);
+                    if (pLayoutRecordingAudioQuality)
+                    {
+                        pLayoutRecordingAudioQuality->setContentsMargins(0, 0, 0, 0);
+
+                        /* Prepare recording audio quality slider: */
+                        m_pSliderAudioQuality = new QIAdvancedSlider(m_pWidgetAudioQualitySettings);
+                        if (m_pSliderAudioQuality)
+                        {
+                            if (m_pLabelAudioQuality)
+                                m_pLabelAudioQuality->setBuddy(m_pSliderAudioQuality);
+                            m_pSliderAudioQuality->setOrientation(Qt::Horizontal);
+                            m_pSliderAudioQuality->setMinimum(1);
+                            m_pSliderAudioQuality->setMaximum(3);
+                            m_pSliderAudioQuality->setPageStep(1);
+                            m_pSliderAudioQuality->setSingleStep(1);
+                            m_pSliderAudioQuality->setTickInterval(1);
+                            m_pSliderAudioQuality->setSnappingEnabled(true);
+                            m_pSliderAudioQuality->setOptimalHint(1, 2);
+                            m_pSliderAudioQuality->setWarningHint(2, 3);
+
+                            pLayoutRecordingAudioQuality->addWidget(m_pSliderAudioQuality);
+                        }
+                        /* Prepare recording audio quality scale layout: */
+                        QHBoxLayout *pLayoutRecordingAudioQialityScale = new QHBoxLayout;
+                        if (pLayoutRecordingAudioQialityScale)
+                        {
+                            pLayoutRecordingAudioQialityScale->setContentsMargins(0, 0, 0, 0);
+
+                            /* Prepare recording audio quality min label: */
+                            m_pLabelAudioQualityMin = new QLabel(m_pWidgetAudioQualitySettings);
+                            if (m_pLabelAudioQualityMin)
+                                pLayoutRecordingAudioQialityScale->addWidget(m_pLabelAudioQualityMin);
+                            pLayoutRecordingAudioQialityScale->addStretch();
+                            /* Prepare recording audio quality med label: */
+                            m_pLabelAudioQualityMed = new QLabel(m_pWidgetAudioQualitySettings);
+                            if (m_pLabelAudioQualityMed)
+                                pLayoutRecordingAudioQialityScale->addWidget(m_pLabelAudioQualityMed);
+                            pLayoutRecordingAudioQialityScale->addStretch();
+                            /* Prepare recording audio quality max label: */
+                            m_pLabelAudioQualityMax = new QLabel(m_pWidgetAudioQualitySettings);
+                            if (m_pLabelAudioQualityMax)
+                                pLayoutRecordingAudioQialityScale->addWidget(m_pLabelAudioQualityMax);
+
+                            pLayoutRecordingAudioQuality->addLayout(pLayoutRecordingAudioQialityScale);
+                        }
+                    }
+
+                    pLayoutSettings->addWidget(m_pWidgetAudioQualitySettings, 7, 1, 2, 1);
+                }
+
+                /* Prepare recording size hint label: */
+                m_pLabelSizeHint = new QLabel(pWidgetSettings);
+                if (m_pLabelSizeHint)
+                    pLayoutSettings->addWidget(m_pLabelSizeHint, 9, 1);
+
+                /* Prepare recording screens label: */
+                m_pLabelScreens = new QLabel(pWidgetSettings);
+                if (m_pLabelScreens)
+                {
+                    m_pLabelScreens->setAlignment(Qt::AlignRight | Qt::AlignTop);
+                    pLayoutSettings->addWidget(m_pLabelScreens, 10, 0);
+                }
+                /* Prepare recording screens scroller: */
+                m_pScrollerScreens = new UIFilmContainer(pWidgetSettings);
+                if (m_pScrollerScreens)
+                {
+                    if (m_pLabelScreens)
+                        m_pLabelScreens->setBuddy(m_pScrollerScreens);
+                    pLayoutSettings->addWidget(m_pScrollerScreens, 10, 1, 1, 3);
+                }
             }
 
-            pLayout->addWidget(m_pWidgetSettings, 1, 1, 1, 2);
+            pLayout->addWidget(pWidgetSettings, 1, 1, 1, 2);
         }
     }
 
     /* Update widget availability: */
-    if (m_pCheckboxFeature)
-        sltHandleFeatureToggled(m_pCheckboxFeature->isChecked());
-}
-
-void UIVRDESettingsEditor::prepareConnections()
-{
-    if (m_pCheckboxFeature)
-        connect(m_pCheckboxFeature, &QCheckBox::toggled, this, &UIVRDESettingsEditor::sltHandleFeatureToggled);
-    if (m_pEditorPort)
-        connect(m_pEditorPort, &QLineEdit::textChanged, this, &UIVRDESettingsEditor::sigChanged);
-    if (m_pEditorTimeout)
-        connect(m_pEditorTimeout, &QLineEdit::textChanged, this, &UIVRDESettingsEditor::sigChanged);
-}
-
-void UIVRDESettingsEditor::repopulateComboAuthType()
-{
-    if (m_pComboAuthType)
-    {
-        /* Clear combo first of all: */
-        m_pComboAuthType->clear();
-
-        /// @todo get supported auth types (API not implemented), not hardcoded!
-        QVector<KAuthType> authTypes = QVector<KAuthType>() << KAuthType_Null
-                                                            << KAuthType_External
-                                                            << KAuthType_Guest;
-
-        /* Take into account currently cached value: */
-        if (!authTypes.contains(m_enmAuthType))
-            authTypes.prepend(m_enmAuthType);
-
-        /* Populate combo finally: */
-        foreach (const KAuthType &enmType, authTypes)
-            m_pComboAuthType->addItem(gpConverter->toString(enmType), QVariant::fromValue(enmType));
-
-        /* Look for proper index to choose: */
-        const int iIndex = m_pComboAuthType->findData(QVariant::fromValue(m_enmAuthType));
-        if (iIndex != -1)
-            m_pComboAuthType->setCurrentIndex(iIndex);
-    }
-}
+    updateWidgetAvailability();
+}
+
+void UIRecordingSettingsEditor::prepareConnections()
+{
+    connect(m_pCheckboxFeature, &QCheckBox::toggled,
+            this, &UIRecordingSettingsEditor::sltHandleFeatureToggled);
+    connect(m_pComboMode, static_cast<void(QComboBox::*)(int)>(&QComboBox::currentIndexChanged),
+            this, &UIRecordingSettingsEditor::sltHandleModeComboChange);
+    connect(m_pComboFrameSize, static_cast<void(QComboBox::*)(int)>(&QComboBox:: currentIndexChanged),
+            this, &UIRecordingSettingsEditor::sltHandleVideoFrameSizeComboChange);
+    connect(m_pSpinboxFrameWidth, static_cast<void(QSpinBox::*)(int)>(&QSpinBox::valueChanged),
+            this, &UIRecordingSettingsEditor::sltHandleVideoFrameWidthChange);
+    connect(m_pSpinboxFrameHeight, static_cast<void(QSpinBox::*)(int)>(&QSpinBox::valueChanged),
+            this, &UIRecordingSettingsEditor::sltHandleVideoFrameHeightChange);
+    connect(m_pSliderFrameRate, &QIAdvancedSlider::valueChanged,
+            this, &UIRecordingSettingsEditor::sltHandleVideoFrameRateSliderChange);
+    connect(m_pSpinboxFrameRate, static_cast<void(QSpinBox::*)(int)>(&QSpinBox::valueChanged),
+            this, &UIRecordingSettingsEditor::sltHandleVideoFrameRateSpinboxChange);
+    connect(m_pSliderVideoQuality, &QIAdvancedSlider::valueChanged,
+            this, &UIRecordingSettingsEditor::sltHandleVideoBitRateSliderChange);
+    connect(m_pSpinboxVideoQuality, static_cast<void(QSpinBox::*)(int)>(&QSpinBox::valueChanged),
+            this, &UIRecordingSettingsEditor::sltHandleVideoBitRateSpinboxChange);
+}
+
+void UIRecordingSettingsEditor::updateWidgetAvailability()
+{
+    const bool fFeatureEnabled = m_pCheckboxFeature->isChecked();
+    const UISettingsDefs::RecordingMode enmRecordingMode =
+        m_pComboMode->currentData().value<UISettingsDefs::RecordingMode>();
+    const bool fRecordVideo =    enmRecordingMode == UISettingsDefs::RecordingMode_VideoOnly
+                              || enmRecordingMode == UISettingsDefs::RecordingMode_VideoAudio;
+    const bool fRecordAudio =    enmRecordingMode == UISettingsDefs::RecordingMode_AudioOnly
+                              || enmRecordingMode == UISettingsDefs::RecordingMode_VideoAudio;
+
+    m_pLabelMode->setEnabled(fFeatureEnabled && m_fOptionsAvailable);
+    m_pComboMode->setEnabled(fFeatureEnabled && m_fOptionsAvailable);
+    m_pLabelFilePath->setEnabled(fFeatureEnabled && m_fOptionsAvailable);
+    m_pEditorFilePath->setEnabled(fFeatureEnabled && m_fOptionsAvailable);
+
+    m_pLabelFrameSize->setEnabled(fFeatureEnabled && m_fOptionsAvailable && fRecordVideo);
+    m_pComboFrameSize->setEnabled(fFeatureEnabled && m_fOptionsAvailable && fRecordVideo);
+    m_pSpinboxFrameWidth->setEnabled(fFeatureEnabled && m_fOptionsAvailable && fRecordVideo);
+    m_pSpinboxFrameHeight->setEnabled(fFeatureEnabled && m_fOptionsAvailable && fRecordVideo);
+
+    m_pLabelFrameRate->setEnabled(fFeatureEnabled && m_fOptionsAvailable && fRecordVideo);
+    m_pWidgetFrameRateSettings->setEnabled(fFeatureEnabled && m_fOptionsAvailable && fRecordVideo);
+    m_pSpinboxFrameRate->setEnabled(fFeatureEnabled && m_fOptionsAvailable && fRecordVideo);
+
+    m_pLabelVideoQuality->setEnabled(fFeatureEnabled && m_fOptionsAvailable && fRecordVideo);
+    m_pWidgetVideoQualitySettings->setEnabled(fFeatureEnabled && m_fOptionsAvailable && fRecordVideo);
+    m_pSpinboxVideoQuality->setEnabled(fFeatureEnabled && m_fOptionsAvailable && fRecordVideo);
+
+    m_pLabelAudioQuality->setEnabled(fFeatureEnabled && m_fOptionsAvailable && fRecordAudio);
+    m_pWidgetAudioQualitySettings->setEnabled(fFeatureEnabled && m_fOptionsAvailable && fRecordAudio);
+
+    m_pLabelSizeHint->setEnabled(fFeatureEnabled && m_fOptionsAvailable && fRecordVideo);
+
+    m_pLabelScreens->setEnabled(fFeatureEnabled && m_fScreenOptionsAvailable && fRecordVideo);
+    m_pScrollerScreens->setEnabled(fFeatureEnabled && m_fScreenOptionsAvailable && fRecordVideo);
+}
+
+void UIRecordingSettingsEditor::updateRecordingFileSizeHint()
+{
+    m_pLabelSizeHint->setText(tr("<i>About %1MB per 5 minute video</i>")
+                                 .arg(m_pSpinboxVideoQuality->value() * 300 / 8 / 1024));
+}
+
+void UIRecordingSettingsEditor::lookForCorrespondingFrameSizePreset()
+{
+    lookForCorrespondingPreset(m_pComboFrameSize,
+                               QSize(m_pSpinboxFrameWidth->value(),
+                                     m_pSpinboxFrameHeight->value()));
+}
+
+/* static */
+void UIRecordingSettingsEditor::lookForCorrespondingPreset(QComboBox *pComboBox, const QVariant &data)
+{
+    /* Use passed iterator to look for corresponding preset of passed combo-box: */
+    const int iLookupResult = pComboBox->findData(data);
+    if (iLookupResult != -1 && pComboBox->currentIndex() != iLookupResult)
+        pComboBox->setCurrentIndex(iLookupResult);
+    else if (iLookupResult == -1 && pComboBox->currentIndex() != 0)
+        pComboBox->setCurrentIndex(0);
+}
+
+/* static */
+int UIRecordingSettingsEditor::calculateBitRate(int iFrameWidth, int iFrameHeight, int iFrameRate, int iQuality)
+{
+    /* Linear quality<=>bit-rate scale-factor: */
+    const double dResult = (double)iQuality
+                         * (double)iFrameWidth * (double)iFrameHeight * (double)iFrameRate
+                         / (double)10 /* translate quality to [%] */
+                         / (double)1024 /* translate bit-rate to [kbps] */
+                         / (double)18.75 /* linear scale factor */;
+    return (int)dResult;
+}
+
+/* static */
+int UIRecordingSettingsEditor::calculateQuality(int iFrameWidth, int iFrameHeight, int iFrameRate, int iBitRate)
+{
+    /* Linear bit-rate<=>quality scale-factor: */
+    const double dResult = (double)iBitRate
+                         / (double)iFrameWidth / (double)iFrameHeight / (double)iFrameRate
+                         * (double)10 /* translate quality to [%] */
+                         * (double)1024 /* translate bit-rate to [kbps] */
+                         * (double)18.75 /* linear scale factor */;
+    return (int)dResult;
+}

trunk/src/VBox/Frontends/VirtualBox/src/settings/editors/UIRecordingSettingsEditor.h

@@ -1 +1 @@
 /* $Id$ */
 /** @file
- * VBox Qt GUI - UIVRDESettingsEditor class declaration.
+ * VBox Qt GUI - UIRecordingSettingsEditor class declaration.
  */
 
@@ -16 +16 @@
  */
 
-#ifndef FEQT_INCLUDED_SRC_settings_editors_UIVRDESettingsEditor_h
-#define FEQT_INCLUDED_SRC_settings_editors_UIVRDESettingsEditor_h
+#ifndef FEQT_INCLUDED_SRC_settings_editors_UIRecordingSettingsEditor_h
+#define FEQT_INCLUDED_SRC_settings_editors_UIRecordingSettingsEditor_h
 #ifndef RT_WITHOUT_PRAGMA_ONCE
 # pragma once
@@ -24 +24 @@
 /* GUI includes: */
 #include "QIWithRetranslateUI.h"
+#include "UISettingsDefs.h"
 
 /* COM includes: */
 #include "COMEnums.h"
+
+/* Other VBox includes: */
+#include <VBox/com/com.h>
 
 /* Forward declarations: */
@@ -32 +36 @@
 class QComboBox;
 class QLabel;
-class QLineEdit;
+class QSpinBox;
 class QWidget;
-
-/** QWidget subclass used as a VRDE settings editor. */
-class SHARED_LIBRARY_STUFF UIVRDESettingsEditor : public QIWithRetranslateUI<QWidget>
+class QIAdvancedSlider;
+class UIFilePathSelector;
+class UIFilmContainer;
+
+/** QWidget subclass used as a recording settings editor. */
+class SHARED_LIBRARY_STUFF UIRecordingSettingsEditor : public QIWithRetranslateUI<QWidget>
 {
     Q_OBJECT;
 
-signals:
-
-    /** Notify listeners about some status changed. */
-    void sigChanged();
-
 public:
 
     /** Constructs editor passing @a pParent to the base-class. */
-    UIVRDESettingsEditor(QWidget *pParent = 0);
+    UIRecordingSettingsEditor(QWidget *pParent = 0);
 
     /** Defines whether feature is @a fEnabled. */
@@ -55 +57 @@
     bool isFeatureEnabled() const;
 
-    /** Defines whether VRDE options are @a fAvailable. */
-    void setVRDEOptionsAvailable(bool fAvailable);
-
-    /** Defines @a strPort. */
-    void setPort(const QString &strPort);
-    /** Returns port. */
-    QString port() const;
-
-    /** Defines auth @a enmType. */
-    void setAuthType(const KAuthType &enmType);
-    /** Returns auth type. */
-    KAuthType authType() const;
-
-    /** Defines @a strTimeout. */
-    void setTimeout(const QString &strTimeout);
-    /** Returns timeout. */
-    QString timeout() const;
-
-    /** Defines whether multiple connections @a fAllowed. */
-    void setMultipleConnectionsAllowed(bool fAllowed);
-    /** Returns whether multiple connections allowed. */
-    bool isMultipleConnectionsAllowed() const;
+    /** Defines whether options are @a fAvailable. */
+    void setOptionsAvailable(bool fAvailable);
+    /** Defines whether screen options are @a fAvailable. */
+    void setScreenOptionsAvailable(bool fAvailable);
+
+    /** Defines @a enmMode. */
+    void setMode(UISettingsDefs::RecordingMode enmMode);
+    /** Return mode. */
+    UISettingsDefs::RecordingMode mode() const;
+
+    /** Defines @a strFolder. */
+    void setFolder(const QString &strFolder);
+    /** Returns folder. */
+    QString folder() const;
+    /** Defines @a strFilePath. */
+    void setFilePath(const QString &strFilePath);
+    /** Returns file path. */
+    QString filePath() const;
+
+    /** Defines frame @a iWidth. */
+    void setFrameWidth(int iWidth);
+    /** Returns frame width. */
+    int frameWidth() const;
+    /** Defines frame @a iHeight. */
+    void setFrameHeight(int iHeight);
+    /** Returns frame height. */
+    int frameHeight() const;
+
+    /** Defines frame @a iRate. */
+    void setFrameRate(int iRate);
+    /** Returns frame rate. */
+    int frameRate() const;
+
+    /** Defines bit @a iRate. */
+    void setBitRate(int iRate);
+    /** Returns bit rate. */
+    int bitRate() const;
+
+    /** Defines audio quality @a iRate. */
+    void setAudioQualityRate(int iRate);
+    /** Returns audio quality rate. */
+    int audioQualityRate() const;
+
+    /** Defines enabled @a screens. */
+    void setScreens(const QVector<BOOL> &screens);
+    /** Returns enabled screens. */
+    QVector<BOOL> screens() const;
 
 protected:
@@ -85 +112 @@
 private slots:
 
-    /** Handles whether VRDE is @a fEnabled. */
-    void sltHandleFeatureToggled(bool fEnabled);
+    /** Handles feature toggling. */
+    void sltHandleFeatureToggled();
+    /** Handles mode change. */
+    void sltHandleModeComboChange();
+    /** Handles frame size change. */
+    void sltHandleVideoFrameSizeComboChange();
+    /** Handles frame width change. */
+    void sltHandleVideoFrameWidthChange();
+    /** Handles frame height change. */
+    void sltHandleVideoFrameHeightChange();
+    /** Handles frame rate slider change. */
+    void sltHandleVideoFrameRateSliderChange();
+    /** Handles frame rate spinbox change. */
+    void sltHandleVideoFrameRateSpinboxChange();
+    /** Handles bit-rate slider change. */
+    void sltHandleVideoBitRateSliderChange();
+    /** Handles bit-rate spinbox change. */
+    void sltHandleVideoBitRateSpinboxChange();
 
 private:
@@ -100 +143 @@
     void repopulateComboAuthType();
 
+    /** Updates widget availability. */
+    void updateWidgetAvailability();
+    /** Updates recording file size hint. */
+    void updateRecordingFileSizeHint();
+    /** Searches for corresponding frame size preset. */
+    void lookForCorrespondingFrameSizePreset();
+
+    /** Searches for the @a data field in corresponding @a pComboBox. */
+    static void lookForCorrespondingPreset(QComboBox *pComboBox, const QVariant &data);
+    /** Calculates recording video bit-rate for passed @a iFrameWidth, @a iFrameHeight, @a iFrameRate and @a iQuality. */
+    static int calculateBitRate(int iFrameWidth, int iFrameHeight, int iFrameRate, int iQuality);
+    /** Calculates recording video quality for passed @a iFrameWidth, @a iFrameHeight, @a iFrameRate and @a iBitRate. */
+    static int calculateQuality(int iFrameWidth, int iFrameHeight, int iFrameRate, int iBitRate);
+
     /** @name Values
      * @{ */
         /** Holds whether feature is enabled. */
-        bool       m_fFeatureEnabled;
-        /** Holds the port. */
-        QString    m_strPort;
-        /** Holds the auth type. */
-        KAuthType  m_enmAuthType;
-        /** Holds the timeout. */
-        QString    m_strTimeout;
-        /** Returns whether multiple connections allowed. */
-        bool       m_fMultipleConnectionsAllowed;
+        bool                           m_fFeatureEnabled;
+        /** Holds whether options are available. */
+        bool                           m_fOptionsAvailable;
+        /** Holds whether screen options are available. */
+        bool                           m_fScreenOptionsAvailable;
+        /** Holds the mode. */
+        UISettingsDefs::RecordingMode  m_enmMode;
+        /** Holds the folder. */
+        QString                        m_strFolder;
+        /** Holds the file path. */
+        QString                        m_strFilePath;
+        /** Holds the frame width. */
+        int                            m_iFrameWidth;
+        /** Holds the frame height. */
+        int                            m_iFrameHeight;
+        /** Holds the frame rate. */
+        int                            m_iFrameRate;
+        /** Holds the bit rate. */
+        int                            m_iBitRate;
+        /** Holds the audio quality rate. */
+        int                            m_iAudioQualityRate;
+        /** Holds the screens. */
+        QVector<BOOL>                  m_screens;
     /** @} */
 
@@ -117 +188 @@
      * @{ */
         /** Holds the feature check-box instance. */
-        QCheckBox *m_pCheckboxFeature;
-        /** Holds the settings widget instance. */
-        QWidget   *m_pWidgetSettings;
-        /** Holds the port label instance. */
-        QLabel    *m_pLabelPort;
-        /** Holds the port editor instance. */
-        QLineEdit *m_pEditorPort;
-        /** Holds the port auth method label instance. */
-        QLabel    *m_pLabelAuthMethod;
-        /** Holds the port auth method combo instance. */
-        QComboBox *m_pComboAuthType;
-        /** Holds the timeout label instance. */
-        QLabel    *m_pLabelTimeout;
-        /** Holds the timeout editor instance. */
-        QLineEdit *m_pEditorTimeout;
-        /** Holds the options label instance. */
-        QLabel    *m_pLabelOptions;
-        /** Holds the multiple connection check-box instance. */
-        QCheckBox *m_pCheckboxMultipleConnections;
+        QCheckBox          *m_pCheckboxFeature;
+        /** Holds the mode label instance. */
+        QLabel             *m_pLabelMode;
+        /** Holds the mode combo instance. */
+        QComboBox          *m_pComboMode;
+        /** Holds the file path label instance. */
+        QLabel             *m_pLabelFilePath;
+        /** Holds the file path editor instance. */
+        UIFilePathSelector *m_pEditorFilePath;
+        /** Holds the frame size label instance. */
+        QLabel             *m_pLabelFrameSize;
+        /** Holds the frame size combo instance. */
+        QComboBox          *m_pComboFrameSize;
+        /** Holds the frame width spinbox instance. */
+        QSpinBox           *m_pSpinboxFrameWidth;
+        /** Holds the frame height spinbox instance. */
+        QSpinBox           *m_pSpinboxFrameHeight;
+        /** Holds the frame rate label instance. */
+        QLabel             *m_pLabelFrameRate;
+        /** Holds the frame rate settings widget instance. */
+        QWidget            *m_pWidgetFrameRateSettings;
+        /** Holds the frame rate slider instance. */
+        QIAdvancedSlider   *m_pSliderFrameRate;
+        /** Holds the frame rate spinbox instance. */
+        QSpinBox           *m_pSpinboxFrameRate;
+        /** Holds the frame rate min label instance. */
+        QLabel             *m_pLabelFrameRateMin;
+        /** Holds the frame rate max label instance. */
+        QLabel             *m_pLabelFrameRateMax;
+        /** Holds the video quality label instance. */
+        QLabel             *m_pLabelVideoQuality;
+        /** Holds the video quality settings widget instance. */
+        QWidget            *m_pWidgetVideoQualitySettings;
+        /** Holds the video quality slider instance. */
+        QIAdvancedSlider   *m_pSliderVideoQuality;
+        /** Holds the video quality spinbox instance. */
+        QSpinBox           *m_pSpinboxVideoQuality;
+        /** Holds the video quality min label instance. */
+        QLabel             *m_pLabelVideoQualityMin;
+        /** Holds the video quality med label instance. */
+        QLabel             *m_pLabelVideoQualityMed;
+        /** Holds the video quality max label instance. */
+        QLabel             *m_pLabelVideoQualityMax;
+        /** Holds the audio quality label instance. */
+        QLabel             *m_pLabelAudioQuality;
+        /** Holds the audio quality settings widget instance. */
+        QWidget            *m_pWidgetAudioQualitySettings;
+        /** Holds the audio quality slider instance. */
+        QIAdvancedSlider   *m_pSliderAudioQuality;
+        /** Holds the audio quality min label instance. */
+        QLabel             *m_pLabelAudioQualityMin;
+        /** Holds the audio quality med label instance. */
+        QLabel             *m_pLabelAudioQualityMed;
+        /** Holds the audio quality max label instance. */
+        QLabel             *m_pLabelAudioQualityMax;
+        /** Holds the size hint label instance. */
+        QLabel             *m_pLabelSizeHint;
+        /** Holds the screens label instance. */
+        QLabel             *m_pLabelScreens;
+        /** Holds the screens scroller instance. */
+        UIFilmContainer    *m_pScrollerScreens;
     /** @} */
 };
 
-#endif /* !FEQT_INCLUDED_SRC_settings_editors_UIVRDESettingsEditor_h */
+#endif /* !FEQT_INCLUDED_SRC_settings_editors_UIRecordingSettingsEditor_h */

trunk/src/VBox/Frontends/VirtualBox/src/settings/machine/UIMachineSettingsDisplay.cpp

@@ -17 +17 @@
 
 /* Qt includes: */
-#include <QCheckBox>
-#include <QComboBox>
 #include <QFileInfo>
-#include <QGridLayout>
-#include <QLabel>
-#include <QLineEdit>
-#include <QRegularExpressionValidator>
-#include <QSpinBox>
-#include <QStackedLayout>
+#include <QVBoxLayout>
 
 /* GUI includes: */
-#include "QIAdvancedSlider.h"
 #include "QITabWidget.h"
-#include "QIWidgetValidator.h"
 #include "UICommon.h"
 #include "UIConverter.h"
 #include "UIErrorString.h"
 #include "UIExtraDataManager.h"
-#include "UIFilePathSelector.h"
-#include "UIFilmContainer.h"
 #include "UIGraphicsControllerEditor.h"
 #ifdef VBOX_WITH_3D_ACCELERATION
@@ -43 +32 @@
 #include "UIMachineSettingsDisplay.h"
 #include "UIMonitorCountEditor.h"
+#include "UIRecordingSettingsEditor.h"
 #include "UIScaleFactorEditor.h"
 #include "UITranslator.h"
@@ -49 +39 @@
 
 /* COM includes: */
+#include "CExtPackManager.h"
 #include "CGraphicsAdapter.h"
+#include "CRecordingScreenSettings.h"
 #include "CRecordingSettings.h"
-#include "CRecordingScreenSettings.h"
-#include "CExtPack.h"
-#include "CExtPackManager.h"
 #include "CVRDEServer.h"
-
-
-#define VIDEO_CAPTURE_BIT_RATE_MIN 32
-#define VIDEO_CAPTURE_BIT_RATE_MAX 2048
 
 
@@ -317 +302 @@
     , m_pEditorVRDESettings(0)
     , m_pTabRecording(0)
-    , m_pCheckboxRecording(0)
-    , m_pWidgetRecordingSettings(0)
-    , m_pLabelRecordingMode(0)
-    , m_pComboRecordingMode(0)
-    , m_pLabelRecordingFilePath(0)
-    , m_pEditorRecordingFilePath(0)
-    , m_pLabelRecordingFrameSize(0)
-    , m_pComboRecordingFrameSize(0)
-    , m_pSpinboxRecordingFrameWidth(0)
-    , m_pSpinboxRecordingFrameHeight(0)
-    , m_pLabelRecordingFrameRate(0)
-    , m_pWidgetRecordingFrameRateSettings(0)
-    , m_pSliderRecordingFrameRate(0)
-    , m_pSpinboxRecordingFrameRate(0)
-    , m_pLabelRecordingFrameRateMin(0)
-    , m_pLabelRecordingFrameRateMax(0)
-    , m_pLabelRecordingVideoQuality(0)
-    , m_pWidgetRecordingVideoQualitySettings(0)
-    , m_pSliderRecordingVideoQuality(0)
-    , m_pSpinboxRecordingVideoQuality(0)
-    , m_pLabelRecordingVideoQualityMin(0)
-    , m_pLabelRecordingVideoQualityMed(0)
-    , m_pLabelRecordingVideoQualityMax(0)
-    , m_pLabelRecordingAudioQuality(0)
-    , m_pWidgetRecordingAudioQualitySettings(0)
-    , m_pSliderRecordingAudioQuality(0)
-    , m_pLabelRecordingAudioQualityMin(0)
-    , m_pLabelRecordingAudioQualityMed(0)
-    , m_pLabelRecordingAudioQualityMax(0)
-    , m_pLabelRecordingSizeHint(0)
-    , m_pLabelRecordingScreens(0)
-    , m_pScrollerRecordingScreens(0)
 {
     prepare();
@@ -373 +326 @@
     m_fWddmModeSupported = UICommon::isWddmCompatibleOsType(strGuestOSTypeId);
     m_pEditorVideoMemorySize->set3DAccelerationSupported(m_fWddmModeSupported);
-#endif
+#endif /* VBOX_WITH_3D_ACCELERATION */
     /* Acquire recommended graphics controller type: */
     m_enmGraphicsControllerTypeRecommended = m_comGuestOSType.GetRecommendedGraphicsController();
@@ -449 +402 @@
 
     /* For now we're using the same settings for all screens; so get settings from screen 0 and work with that. */
-    CRecordingScreenSettings recordingScreen0Settings = recordingSettings.GetScreenSettings(0);
-    if (!recordingScreen0Settings.isNull())
+    CRecordingScreenSettings comRecordingScreen0Settings = recordingSettings.GetScreenSettings(0);
+    if (!comRecordingScreen0Settings.isNull())
     {
         oldDisplayData.m_strRecordingFolder = QFileInfo(m_machine.GetSettingsFilePath()).absolutePath();
-        oldDisplayData.m_strRecordingFilePath = recordingScreen0Settings.GetFilename();
-        oldDisplayData.m_iRecordingVideoFrameWidth = recordingScreen0Settings.GetVideoWidth();
-        oldDisplayData.m_iRecordingVideoFrameHeight = recordingScreen0Settings.GetVideoHeight();
-        oldDisplayData.m_iRecordingVideoFrameRate = recordingScreen0Settings.GetVideoFPS();
-        oldDisplayData.m_iRecordingVideoBitRate = recordingScreen0Settings.GetVideoRate();
-        oldDisplayData.m_strRecordingVideoOptions = recordingScreen0Settings.GetOptions();
-    }
-
-    CRecordingScreenSettingsVector recordingScreenSettingsVector = recordingSettings.GetScreens();
-    oldDisplayData.m_vecRecordingScreens.resize(recordingScreenSettingsVector.size());
-    for (int iScreenIndex = 0; iScreenIndex < recordingScreenSettingsVector.size(); ++iScreenIndex)
-    {
-        CRecordingScreenSettings recordingScreenSettings = recordingScreenSettingsVector.at(iScreenIndex);
-        if (!recordingScreenSettings.isNull())
-            oldDisplayData.m_vecRecordingScreens[iScreenIndex] = recordingScreenSettings.GetEnabled();
+        oldDisplayData.m_strRecordingFilePath = comRecordingScreen0Settings.GetFilename();
+        oldDisplayData.m_iRecordingVideoFrameWidth = comRecordingScreen0Settings.GetVideoWidth();
+        oldDisplayData.m_iRecordingVideoFrameHeight = comRecordingScreen0Settings.GetVideoHeight();
+        oldDisplayData.m_iRecordingVideoFrameRate = comRecordingScreen0Settings.GetVideoFPS();
+        oldDisplayData.m_iRecordingVideoBitRate = comRecordingScreen0Settings.GetVideoRate();
+        oldDisplayData.m_strRecordingVideoOptions = comRecordingScreen0Settings.GetOptions();
+    }
+
+    CRecordingScreenSettingsVector comRecordingScreenSettingsVector = recordingSettings.GetScreens();
+    oldDisplayData.m_vecRecordingScreens.resize(comRecordingScreenSettingsVector.size());
+    for (int iScreenIndex = 0; iScreenIndex < comRecordingScreenSettingsVector.size(); ++iScreenIndex)
+    {
+        CRecordingScreenSettings comRecordingScreenSettings = comRecordingScreenSettingsVector.at(iScreenIndex);
+        if (!comRecordingScreenSettings.isNull())
+            oldDisplayData.m_vecRecordingScreens[iScreenIndex] = comRecordingScreenSettings.GetEnabled();
     }
 
@@ -511 +464 @@
 
     /* Load old 'Recording' data from cache: */
-    m_pCheckboxRecording->setChecked(oldDisplayData.m_fRecordingEnabled);
-    m_pEditorRecordingFilePath->setInitialPath(oldDisplayData.m_strRecordingFolder);
-    m_pEditorRecordingFilePath->setPath(oldDisplayData.m_strRecordingFilePath);
-    m_pSpinboxRecordingFrameWidth->setValue(oldDisplayData.m_iRecordingVideoFrameWidth);
-    m_pSpinboxRecordingFrameHeight->setValue(oldDisplayData.m_iRecordingVideoFrameHeight);
-    m_pSpinboxRecordingFrameRate->setValue(oldDisplayData.m_iRecordingVideoFrameRate);
-    m_pSpinboxRecordingVideoQuality->setValue(oldDisplayData.m_iRecordingVideoBitRate);
-    m_pScrollerRecordingScreens->setValue(oldDisplayData.m_vecRecordingScreens);
-
-    /* Load data from old 'Recording option': */
-    bool fRecordAudio = UIDataSettingsMachineDisplay::isRecordingOptionEnabled(oldDisplayData.m_strRecordingVideoOptions,
-                                                                                UIDataSettingsMachineDisplay::RecordingOption_AC);
-    bool fRecordVideo = UIDataSettingsMachineDisplay::isRecordingOptionEnabled(oldDisplayData.m_strRecordingVideoOptions,
-                                                                                UIDataSettingsMachineDisplay::RecordingOption_VC);
+    m_pEditorRecordingSettings->setFeatureEnabled(oldDisplayData.m_fRecordingEnabled);
+    m_pEditorRecordingSettings->setFolder(oldDisplayData.m_strRecordingFolder);
+    m_pEditorRecordingSettings->setFilePath(oldDisplayData.m_strRecordingFilePath);
+    m_pEditorRecordingSettings->setFrameWidth(oldDisplayData.m_iRecordingVideoFrameWidth);
+    m_pEditorRecordingSettings->setFrameHeight(oldDisplayData.m_iRecordingVideoFrameHeight);
+    m_pEditorRecordingSettings->setFrameRate(oldDisplayData.m_iRecordingVideoFrameRate);
+    m_pEditorRecordingSettings->setBitRate(oldDisplayData.m_iRecordingVideoBitRate);
+    m_pEditorRecordingSettings->setScreens(oldDisplayData.m_vecRecordingScreens);
+
+    /* Load old 'Recording' options: */
+    const bool fRecordVideo =
+        UIDataSettingsMachineDisplay::isRecordingOptionEnabled(oldDisplayData.m_strRecordingVideoOptions,
+                                                               UIDataSettingsMachineDisplay::RecordingOption_VC);
+    const bool fRecordAudio =
+        UIDataSettingsMachineDisplay::isRecordingOptionEnabled(oldDisplayData.m_strRecordingVideoOptions,
+                                                               UIDataSettingsMachineDisplay::RecordingOption_AC);
+    UISettingsDefs::RecordingMode enmMode;
     if (fRecordAudio && fRecordVideo)
-        m_pComboRecordingMode->setCurrentIndex(m_pComboRecordingMode->findText(gpConverter->toString(UISettingsDefs::RecordingMode_VideoAudio)));
+        enmMode = UISettingsDefs::RecordingMode_VideoAudio;
     else if (fRecordAudio && !fRecordVideo)
-        m_pComboRecordingMode->setCurrentIndex(m_pComboRecordingMode->findText(gpConverter->toString(UISettingsDefs::RecordingMode_AudioOnly)));
+        enmMode = UISettingsDefs::RecordingMode_AudioOnly;
     else
-        m_pComboRecordingMode->setCurrentIndex(m_pComboRecordingMode->findText(gpConverter->toString(UISettingsDefs::RecordingMode_VideoOnly)));
-
-    m_pSliderRecordingAudioQuality->setValue(UIDataSettingsMachineDisplay::getAudioQualityFromOptions(oldDisplayData.m_strRecordingVideoOptions));
+        enmMode = UISettingsDefs::RecordingMode_VideoOnly;
+    m_pEditorRecordingSettings->setMode(enmMode);
+    const int iAudioQualityRate =
+        UIDataSettingsMachineDisplay::getAudioQualityFromOptions(oldDisplayData.m_strRecordingVideoOptions);
+    m_pEditorRecordingSettings->setAudioQualityRate(iAudioQualityRate);
 
     /* Polish page finally: */
@@ -567 +525 @@
 
     /* Gather new 'Recording' data: */
-    newDisplayData.m_fRecordingEnabled = m_pCheckboxRecording->isChecked();
-    newDisplayData.m_strRecordingFolder = m_pCache->base().m_strRecordingFolder;
-    newDisplayData.m_strRecordingFilePath = m_pEditorRecordingFilePath->path();
-    newDisplayData.m_iRecordingVideoFrameWidth = m_pSpinboxRecordingFrameWidth->value();
-    newDisplayData.m_iRecordingVideoFrameHeight = m_pSpinboxRecordingFrameHeight->value();
-    newDisplayData.m_iRecordingVideoFrameRate = m_pSpinboxRecordingFrameRate->value();
-    newDisplayData.m_iRecordingVideoBitRate = m_pSpinboxRecordingVideoQuality->value();
-    newDisplayData.m_vecRecordingScreens = m_pScrollerRecordingScreens->value();
-
-    /* Update recording options */
-    const UISettingsDefs::RecordingMode enmRecordingMode =
-        gpConverter->fromString<UISettingsDefs::RecordingMode>(m_pComboRecordingMode->currentText());
+    newDisplayData.m_fRecordingEnabled = m_pEditorRecordingSettings->isFeatureEnabled();
+    newDisplayData.m_strRecordingFolder = m_pEditorRecordingSettings->folder();
+    newDisplayData.m_strRecordingFilePath = m_pEditorRecordingSettings->filePath();
+    newDisplayData.m_iRecordingVideoFrameWidth = m_pEditorRecordingSettings->frameWidth();
+    newDisplayData.m_iRecordingVideoFrameHeight = m_pEditorRecordingSettings->frameHeight();
+    newDisplayData.m_iRecordingVideoFrameRate = m_pEditorRecordingSettings->frameRate();
+    newDisplayData.m_iRecordingVideoBitRate = m_pEditorRecordingSettings->bitRate();
+    newDisplayData.m_vecRecordingScreens = m_pEditorRecordingSettings->screens();
+
+    /* Gather new 'Recording' options: */
+    const UISettingsDefs::RecordingMode enmRecordingMode = m_pEditorRecordingSettings->mode();
     QStringList optionValues;
-    /* Option value for video recording: */
-    optionValues.push_back(     (enmRecordingMode == UISettingsDefs::RecordingMode_VideoAudio)
-                             || (enmRecordingMode == UISettingsDefs::RecordingMode_VideoOnly)
-                           ? "true" : "false");
-    /* Option value for audio recording: */
-    optionValues.push_back(     (enmRecordingMode == UISettingsDefs::RecordingMode_VideoAudio)
-                             || (enmRecordingMode == UISettingsDefs::RecordingMode_AudioOnly)
-                           ? "true" : "false");
-
-    if (m_pSliderRecordingAudioQuality->value() == 1)
-        optionValues.push_back("low");
-    else if (m_pSliderRecordingAudioQuality->value() == 2)
-        optionValues.push_back("med");
-    else
-        optionValues.push_back("high");
-
-    QVector<UIDataSettingsMachineDisplay::RecordingOption> recordingOptionsVector;
-    recordingOptionsVector.push_back(UIDataSettingsMachineDisplay::RecordingOption_VC);
-    recordingOptionsVector.push_back(UIDataSettingsMachineDisplay::RecordingOption_AC);
-    recordingOptionsVector.push_back(UIDataSettingsMachineDisplay::RecordingOption_AC_Profile);
-
-    newDisplayData.m_strRecordingVideoOptions = UIDataSettingsMachineDisplay::setRecordingOptions(m_pCache->base().m_strRecordingVideoOptions,
-                                                                                                   recordingOptionsVector,
-                                                                                                   optionValues);
+    optionValues.append(     (enmRecordingMode == UISettingsDefs::RecordingMode_VideoAudio)
+                          || (enmRecordingMode == UISettingsDefs::RecordingMode_VideoOnly)
+                        ? "true" : "false");
+    optionValues.append(     (enmRecordingMode == UISettingsDefs::RecordingMode_VideoAudio)
+                          || (enmRecordingMode == UISettingsDefs::RecordingMode_AudioOnly)
+                        ? "true" : "false");
+    switch (m_pEditorRecordingSettings->audioQualityRate())
+    {
+        case 1: optionValues.append("low"); break;
+        case 2: optionValues.append("med"); break;
+        default: optionValues.append("high"); break;
+    }
+    QVector<UIDataSettingsMachineDisplay::RecordingOption> optionKeys;
+    optionKeys.append(UIDataSettingsMachineDisplay::RecordingOption_VC);
+    optionKeys.append(UIDataSettingsMachineDisplay::RecordingOption_AC);
+    optionKeys.append(UIDataSettingsMachineDisplay::RecordingOption_AC_Profile);
+    newDisplayData.m_strRecordingVideoOptions =
+        UIDataSettingsMachineDisplay::setRecordingOptions(m_pCache->base().m_strRecordingVideoOptions,
+                                                          optionKeys, optionValues);
 
     /* Cache new display data: */
@@ -699 +651 @@
             {
                 message.second << tr("Remote Display is currently enabled for this virtual machine. "
-                                    "However, this requires the <i>%1</i> to be installed. "
-                                    "Please install the Extension Pack from the VirtualBox download site as "
-                                    "otherwise your VM will be started with Remote Display disabled.")
-                                    .arg(GUI_ExtPackName);
+                                     "However, this requires the <i>%1</i> to be installed. "
+                                     "Please install the Extension Pack from the VirtualBox download site as "
+                                     "otherwise your VM will be started with Remote Display disabled.")
+                                     .arg(GUI_ExtPackName);
             }
         }
@@ -745 +697 @@
 
     /* Remote Display tab-order: */
-    setTabOrder(m_pEditorVRDESettings, m_pCheckboxRecording);
-
-    /* Recording tab-order: */
-    setTabOrder(m_pCheckboxRecording, m_pEditorRecordingFilePath);
-    setTabOrder(m_pEditorRecordingFilePath, m_pComboRecordingFrameSize);
-    setTabOrder(m_pComboRecordingFrameSize, m_pSpinboxRecordingFrameWidth);
-    setTabOrder(m_pSpinboxRecordingFrameWidth, m_pSpinboxRecordingFrameHeight);
-    setTabOrder(m_pSpinboxRecordingFrameHeight, m_pSliderRecordingFrameRate);
-    setTabOrder(m_pSliderRecordingFrameRate, m_pSpinboxRecordingFrameRate);
-    setTabOrder(m_pSpinboxRecordingFrameRate, m_pSliderRecordingVideoQuality);
-    setTabOrder(m_pSliderRecordingVideoQuality, m_pSpinboxRecordingVideoQuality);
+    setTabOrder(m_pEditorVRDESettings, m_pEditorRecordingSettings);
 }
 
 void UIMachineSettingsDisplay::retranslateUi()
 {
+    /* Translate tab-widget: */
     m_pTabWidget->setTabText(m_pTabWidget->indexOf(m_pTabScreen), tr("&Screen"));
     m_pTabWidget->setTabText(m_pTabWidget->indexOf(m_pTabRemoteDisplay), tr("&Remote Display"));
-    m_pCheckboxRecording->setToolTip(tr("When checked, VirtualBox will record the virtual machine session as a video file."));
-    m_pCheckboxRecording->setText(tr("&Enable Recording"));
-    m_pLabelRecordingMode->setText(tr("Recording &Mode:"));
-    m_pComboRecordingMode->setToolTip(tr("Selects the recording mode."));
-    m_pLabelRecordingFilePath->setText(tr("File &Path:"));
-    m_pEditorRecordingFilePath->setToolTip(tr("Holds the filename VirtualBox uses to save the recorded content."));
-    m_pLabelRecordingFrameSize->setText(tr("Frame Si&ze:"));
-    m_pComboRecordingFrameSize->setToolTip(tr("Selects the resolution (frame size) of the recorded video."));
-    m_pSpinboxRecordingFrameWidth->setToolTip(tr("Holds the <b>horizontal</b> resolution (frame width) of the recorded video."));
-    m_pSpinboxRecordingFrameHeight->setToolTip(tr("Holds the <b>vertical</b> resolution (frame height) of the recorded video."));
-    m_pLabelRecordingFrameRate->setText(tr("Frame R&ate:"));
-    m_pSliderRecordingFrameRate->setToolTip(tr("Controls the maximum number of <b>frames per second</b>. Additional frames will "
-                                               "be skipped. Reducing this value will increase the number of skipped frames and "
-                                               "reduce the file size."));
-    m_pSpinboxRecordingFrameRate->setToolTip(tr("Controls the maximum number of <b>frames per second</b>. Additional frames will "
-                                                "be skipped. Reducing this value will increase the number of skipped frames and "
-                                                "reduce the file size."));
-    m_pLabelRecordingVideoQuality->setText(tr("&Video Quality:"));
-    m_pSliderRecordingVideoQuality->setToolTip(tr("Controls the <b>quality</b>. Increasing this value will make the video look "
-                                                  "better at the cost of an increased file size."));
-    m_pSpinboxRecordingVideoQuality->setToolTip(tr("Holds the bitrate in <b>kilobits per second</b>. Increasing this value will "
-                                                   "make the video look better at the cost of an increased file size."));
-    m_pLabelRecordingAudioQuality->setText(tr("&Audio Quality:"));
-    m_pSliderRecordingAudioQuality->setToolTip(tr("Controls the <b>quality</b>. Increasing this value will make the audio sound "
-                                                  "better at the cost of an increased file size."));
-    m_pLabelRecordingScreens->setText(tr("Scree&ns:"));
-    m_pScrollerRecordingScreens->setToolTip(QString());
     m_pTabWidget->setTabText(m_pTabWidget->indexOf(m_pTabRecording), tr("Re&cording"));
-
-    /* Recording stuff: */
-    m_pSpinboxRecordingFrameRate->setSuffix(QString(" %1").arg(tr("fps")));
-    m_pSpinboxRecordingVideoQuality->setSuffix(QString(" %1").arg(tr("kbps")));
-    m_pComboRecordingFrameSize->setItemText(0, tr("User Defined"));
-    m_pLabelRecordingFrameRateMin->setText(tr("%1 fps").arg(m_pSliderRecordingFrameRate->minimum()));
-    m_pLabelRecordingFrameRateMax->setText(tr("%1 fps").arg(m_pSliderRecordingFrameRate->maximum()));
-    m_pLabelRecordingVideoQualityMin->setText(tr("low", "quality"));
-    m_pLabelRecordingVideoQualityMed->setText(tr("medium", "quality"));
-    m_pLabelRecordingVideoQualityMax->setText(tr("high", "quality"));
-    m_pLabelRecordingAudioQualityMin->setText(tr("low", "quality"));
-    m_pLabelRecordingAudioQualityMed->setText(tr("medium", "quality"));
-    m_pLabelRecordingAudioQualityMax->setText(tr("high", "quality"));
-
-    m_pComboRecordingMode->setItemText(0, gpConverter->toString(UISettingsDefs::RecordingMode_VideoAudio));
-    m_pComboRecordingMode->setItemText(1, gpConverter->toString(UISettingsDefs::RecordingMode_VideoOnly));
-    m_pComboRecordingMode->setItemText(2, gpConverter->toString(UISettingsDefs::RecordingMode_AudioOnly));
 
     /* These editors have own labels, but we want them to be properly layouted according to each other: */
@@ -824 +723 @@
     m_pEditorDisplayScreenFeatures->setMinimumLayoutIndent(iMinimumLayoutHint);
 #endif
-
-    updateRecordingFileSizeHint();
 }
 
@@ -849 +746 @@
     /* Polish 'Recording' availability: */
     m_pTabRecording->setEnabled(isMachineInValidMode());
-    sltHandleRecordingCheckboxToggle();
+    // Recording options should be enabled only if:
+    // 1. Machine is in 'offline' or 'saved' state,
+    // 2. Machine is in 'online' state and video recording is *disabled* currently.
+    const bool fIsRecordingOptionsEnabled =
+           ((isMachineOffline() || isMachineSaved()))
+        || (isMachineOnline() && !m_pCache->base().m_fRecordingEnabled);
+    m_pEditorRecordingSettings->setOptionsAvailable(fIsRecordingOptionsEnabled);
+    // Recording screens option should be enabled only if:
+    // 1. Machine is in *any* valid state.
+    const bool fIsRecordingScreenOptionsEnabled =
+        isMachineInValidMode();
+    m_pEditorRecordingSettings->setScreenOptionsAvailable(fIsRecordingScreenOptionsEnabled);
 }
 
@@ -880 +788 @@
 }
 #endif /* VBOX_WITH_3D_ACCELERATION */
-
-void UIMachineSettingsDisplay::sltHandleRecordingCheckboxToggle()
-{
-    /* Recording options should be enabled only if:
-     * 1. Machine is in 'offline' or 'saved' state and check-box is checked,
-     * 2. Machine is in 'online' state, check-box is checked, and video recording is *disabled* currently. */
-    const bool fIsRecordingOptionsEnabled = ((isMachineOffline() || isMachineSaved()) && m_pCheckboxRecording->isChecked()) ||
-                                               (isMachineOnline() && !m_pCache->base().m_fRecordingEnabled && m_pCheckboxRecording->isChecked());
-
-    m_pLabelRecordingMode->setEnabled(fIsRecordingOptionsEnabled);
-    m_pComboRecordingMode->setEnabled(fIsRecordingOptionsEnabled);
-
-    m_pLabelRecordingFilePath->setEnabled(fIsRecordingOptionsEnabled);
-    m_pEditorRecordingFilePath->setEnabled(fIsRecordingOptionsEnabled);
-
-    enableDisableRecordingWidgets();
-}
-
-void UIMachineSettingsDisplay::sltHandleRecordingVideoFrameSizeComboboxChange()
-{
-    /* Get the proposed size: */
-    const int iCurrentIndex = m_pComboRecordingFrameSize->currentIndex();
-    const QSize videoCaptureSize = m_pComboRecordingFrameSize->itemData(iCurrentIndex).toSize();
-
-    /* Make sure its valid: */
-    if (!videoCaptureSize.isValid())
-        return;
-
-    /* Apply proposed size: */
-    m_pSpinboxRecordingFrameWidth->setValue(videoCaptureSize.width());
-    m_pSpinboxRecordingFrameHeight->setValue(videoCaptureSize.height());
-}
-
-void UIMachineSettingsDisplay::sltHandleRecordingVideoFrameWidthEditorChange()
-{
-    /* Look for preset: */
-    lookForCorrespondingFrameSizePreset();
-    /* Update quality and bit-rate: */
-    sltHandleRecordingVideoQualitySliderChange();
-}
-
-void UIMachineSettingsDisplay::sltHandleRecordingVideoFrameHeightEditorChange()
-{
-    /* Look for preset: */
-    lookForCorrespondingFrameSizePreset();
-    /* Update quality and bit-rate: */
-    sltHandleRecordingVideoQualitySliderChange();
-}
-
-void UIMachineSettingsDisplay::sltHandleRecordingVideoFrameRateSliderChange()
-{
-    /* Apply proposed frame-rate: */
-    m_pSpinboxRecordingFrameRate->blockSignals(true);
-    m_pSpinboxRecordingFrameRate->setValue(m_pSliderRecordingFrameRate->value());
-    m_pSpinboxRecordingFrameRate->blockSignals(false);
-    /* Update quality and bit-rate: */
-    sltHandleRecordingVideoQualitySliderChange();
-}
-
-void UIMachineSettingsDisplay::sltHandleRecordingVideoFrameRateEditorChange()
-{
-    /* Apply proposed frame-rate: */
-    m_pSliderRecordingFrameRate->blockSignals(true);
-    m_pSliderRecordingFrameRate->setValue(m_pSpinboxRecordingFrameRate->value());
-    m_pSliderRecordingFrameRate->blockSignals(false);
-    /* Update quality and bit-rate: */
-    sltHandleRecordingVideoQualitySliderChange();
-}
-
-void UIMachineSettingsDisplay::sltHandleRecordingVideoQualitySliderChange()
-{
-    /* Calculate/apply proposed bit-rate: */
-    m_pSpinboxRecordingVideoQuality->blockSignals(true);
-    m_pSpinboxRecordingVideoQuality->setValue(calculateBitRate(m_pSpinboxRecordingFrameWidth->value(),
-                                                            m_pSpinboxRecordingFrameHeight->value(),
-                                                            m_pSpinboxRecordingFrameRate->value(),
-                                                            m_pSliderRecordingVideoQuality->value()));
-    m_pSpinboxRecordingVideoQuality->blockSignals(false);
-    updateRecordingFileSizeHint();
-}
-
-void UIMachineSettingsDisplay::sltHandleRecordingVideoBitRateEditorChange()
-{
-    /* Calculate/apply proposed quality: */
-    m_pSliderRecordingVideoQuality->blockSignals(true);
-    m_pSliderRecordingVideoQuality->setValue(calculateQuality(m_pSpinboxRecordingFrameWidth->value(),
-                                                            m_pSpinboxRecordingFrameHeight->value(),
-                                                            m_pSpinboxRecordingFrameRate->value(),
-                                                            m_pSpinboxRecordingVideoQuality->value()));
-    m_pSliderRecordingVideoQuality->blockSignals(false);
-    updateRecordingFileSizeHint();
-}
-
-void UIMachineSettingsDisplay::sltHandleRecordingComboBoxChange()
-{
-    enableDisableRecordingWidgets();
-}
 
 void UIMachineSettingsDisplay::prepare()
@@ -995 +806 @@
 {
     /* Prepare main layout: */
-    QVBoxLayout *pLayoutMain = new QVBoxLayout(this);
-    if (pLayoutMain)
+    QVBoxLayout *pLayout = new QVBoxLayout(this);
+    if (pLayout)
     {
         /* Prepare tab-widget: */
@@ -1007 +818 @@
             prepareTabRecording();
 
-            pLayoutMain->addWidget(m_pTabWidget);
+            pLayout->addWidget(m_pTabWidget);
         }
     }
@@ -1085 +896 @@
     {
         /* Prepare 'Recording' tab layout: */
-        QGridLayout *pLayoutRecording = new QGridLayout(m_pTabRecording);
+        QVBoxLayout *pLayoutRecording = new QVBoxLayout(m_pTabRecording);
         if (pLayoutRecording)
         {
-            pLayoutRecording->setRowStretch(2, 1);
-
-            /* Prepare recording check-box: */
-            m_pCheckboxRecording = new QCheckBox(m_pWidgetRecordingSettings);
-            if (m_pCheckboxRecording)
-                pLayoutRecording->addWidget(m_pCheckboxRecording, 0, 0, 1, 2);
-
-            /* Prepare 20-px shifting spacer: */
-            QSpacerItem *pSpacerItem = new QSpacerItem(20, 0, QSizePolicy::Fixed, QSizePolicy::Minimum);
-            if (pSpacerItem)
-                pLayoutRecording->addItem(pSpacerItem, 1, 0);
-
-            /* Prepare recording settings widget: */
-            m_pWidgetRecordingSettings = new QWidget(m_pTabRecording);
-            if (m_pWidgetRecordingSettings)
-            {
-                /* Prepare recording settings widget layout: */
-                QGridLayout *pLayoutRecordingSettings = new QGridLayout(m_pWidgetRecordingSettings);
-                if (pLayoutRecordingSettings)
-                {
-                    pLayoutRecordingSettings->setContentsMargins(0, 0, 0, 0);
-
-                    /* Prepare recording mode label: */
-                    m_pLabelRecordingMode = new QLabel(m_pWidgetRecordingSettings);
-                    if (m_pLabelRecordingMode)
-                    {
-                        m_pLabelRecordingMode->setAlignment(Qt::AlignRight | Qt::AlignVCenter);
-                        pLayoutRecordingSettings->addWidget(m_pLabelRecordingMode, 0, 0);
-                    }
-                    /* Prepare recording mode combo: */
-                    m_pComboRecordingMode = new QComboBox(m_pWidgetRecordingSettings);
-                    if (m_pComboRecordingMode)
-                    {
-                        if (m_pLabelRecordingMode)
-                            m_pLabelRecordingMode->setBuddy(m_pComboRecordingMode);
-                        m_pComboRecordingMode->insertItem(0, ""); /* UISettingsDefs::RecordingMode_VideoAudio */
-                        m_pComboRecordingMode->insertItem(1, ""); /* UISettingsDefs::RecordingMode_VideoOnly */
-                        m_pComboRecordingMode->insertItem(2, ""); /* UISettingsDefs::RecordingMode_AudioOnly */
-
-                        pLayoutRecordingSettings->addWidget(m_pComboRecordingMode, 0, 1, 1, 3);
-                    }
-
-                    /* Prepare recording file path label: */
-                    m_pLabelRecordingFilePath = new QLabel(m_pWidgetRecordingSettings);
-                    if (m_pLabelRecordingFilePath)
-                    {
-                        m_pLabelRecordingFilePath->setAlignment(Qt::AlignRight | Qt::AlignVCenter);
-                        pLayoutRecordingSettings->addWidget(m_pLabelRecordingFilePath, 1, 0);
-                    }
-                    /* Prepare recording file path editor: */
-                    m_pEditorRecordingFilePath = new UIFilePathSelector(m_pWidgetRecordingSettings);
-                    if (m_pEditorRecordingFilePath)
-                    {
-                        if (m_pLabelRecordingFilePath)
-                            m_pLabelRecordingFilePath->setBuddy(m_pEditorRecordingFilePath->focusProxy());
-                        m_pEditorRecordingFilePath->setEditable(false);
-                        m_pEditorRecordingFilePath->setMode(UIFilePathSelector::Mode_File_Save);
-
-                        pLayoutRecordingSettings->addWidget(m_pEditorRecordingFilePath, 1, 1, 1, 3);
-                    }
-
-                    /* Prepare recording frame size label: */
-                    m_pLabelRecordingFrameSize = new QLabel(m_pWidgetRecordingSettings);
-                    if (m_pLabelRecordingFrameSize)
-                    {
-                        m_pLabelRecordingFrameSize->setAlignment(Qt::AlignRight | Qt::AlignVCenter);
-                        pLayoutRecordingSettings->addWidget(m_pLabelRecordingFrameSize, 2, 0);
-                    }
-                    /* Prepare recording frame size combo: */
-                    m_pComboRecordingFrameSize = new QComboBox(m_pWidgetRecordingSettings);
-                    if (m_pComboRecordingFrameSize)
-                    {
-                        if (m_pLabelRecordingFrameSize)
-                            m_pLabelRecordingFrameSize->setBuddy(m_pComboRecordingFrameSize);
-                        m_pComboRecordingFrameSize->setSizePolicy(QSizePolicy(QSizePolicy::MinimumExpanding, QSizePolicy::Fixed));
-                        m_pComboRecordingFrameSize->addItem(""); /* User Defined */
-                        m_pComboRecordingFrameSize->addItem("320 x 200 (16:10)",   QSize(320, 200));
-                        m_pComboRecordingFrameSize->addItem("640 x 480 (4:3)",     QSize(640, 480));
-                        m_pComboRecordingFrameSize->addItem("720 x 400 (9:5)",     QSize(720, 400));
-                        m_pComboRecordingFrameSize->addItem("720 x 480 (3:2)",     QSize(720, 480));
-                        m_pComboRecordingFrameSize->addItem("800 x 600 (4:3)",     QSize(800, 600));
-                        m_pComboRecordingFrameSize->addItem("1024 x 768 (4:3)",    QSize(1024, 768));
-                        m_pComboRecordingFrameSize->addItem("1152 x 864 (4:3)",    QSize(1152, 864));
-                        m_pComboRecordingFrameSize->addItem("1280 x 720 (16:9)",   QSize(1280, 720));
-                        m_pComboRecordingFrameSize->addItem("1280 x 800 (16:10)",  QSize(1280, 800));
-                        m_pComboRecordingFrameSize->addItem("1280 x 960 (4:3)",    QSize(1280, 960));
-                        m_pComboRecordingFrameSize->addItem("1280 x 1024 (5:4)",   QSize(1280, 1024));
-                        m_pComboRecordingFrameSize->addItem("1366 x 768 (16:9)",   QSize(1366, 768));
-                        m_pComboRecordingFrameSize->addItem("1440 x 900 (16:10)",  QSize(1440, 900));
-                        m_pComboRecordingFrameSize->addItem("1440 x 1080 (4:3)",   QSize(1440, 1080));
-                        m_pComboRecordingFrameSize->addItem("1600 x 900 (16:9)",   QSize(1600, 900));
-                        m_pComboRecordingFrameSize->addItem("1680 x 1050 (16:10)", QSize(1680, 1050));
-                        m_pComboRecordingFrameSize->addItem("1600 x 1200 (4:3)",   QSize(1600, 1200));
-                        m_pComboRecordingFrameSize->addItem("1920 x 1080 (16:9)",  QSize(1920, 1080));
-                        m_pComboRecordingFrameSize->addItem("1920 x 1200 (16:10)", QSize(1920, 1200));
-                        m_pComboRecordingFrameSize->addItem("1920 x 1440 (4:3)",   QSize(1920, 1440));
-                        m_pComboRecordingFrameSize->addItem("2880 x 1800 (16:10)", QSize(2880, 1800));
-
-                        pLayoutRecordingSettings->addWidget(m_pComboRecordingFrameSize, 2, 1);
-                    }
-                    /* Prepare recording frame width spinbox: */
-                    m_pSpinboxRecordingFrameWidth = new QSpinBox(m_pWidgetRecordingSettings);
-                    if (m_pSpinboxRecordingFrameWidth)
-                    {
-                        uiCommon().setMinimumWidthAccordingSymbolCount(m_pSpinboxRecordingFrameWidth, 5);
-                        m_pSpinboxRecordingFrameWidth->setMinimum(16);
-                        m_pSpinboxRecordingFrameWidth->setMaximum(2880);
-
-                        pLayoutRecordingSettings->addWidget(m_pSpinboxRecordingFrameWidth, 2, 2);
-                    }
-                    /* Prepare recording frame height spinbox: */
-                    m_pSpinboxRecordingFrameHeight = new QSpinBox(m_pWidgetRecordingSettings);
-                    if (m_pSpinboxRecordingFrameHeight)
-                    {
-                        uiCommon().setMinimumWidthAccordingSymbolCount(m_pSpinboxRecordingFrameHeight, 5);
-                        m_pSpinboxRecordingFrameHeight->setMinimum(16);
-                        m_pSpinboxRecordingFrameHeight->setMaximum(1800);
-
-                        pLayoutRecordingSettings->addWidget(m_pSpinboxRecordingFrameHeight, 2, 3);
-                    }
-
-                    /* Prepare recording frame rate label: */
-                    m_pLabelRecordingFrameRate = new QLabel(m_pWidgetRecordingSettings);
-                    if (m_pLabelRecordingFrameRate)
-                    {
-                        m_pLabelRecordingFrameRate->setAlignment(Qt::AlignRight | Qt::AlignVCenter);
-                        pLayoutRecordingSettings->addWidget(m_pLabelRecordingFrameRate, 3, 0);
-                    }
-                    /* Prepare recording frame rate widget: */
-                    m_pWidgetRecordingFrameRateSettings = new QWidget(m_pWidgetRecordingSettings);
-                    if (m_pWidgetRecordingFrameRateSettings)
-                    {
-                        /* Prepare recording frame rate layout: */
-                        QVBoxLayout *pLayoutRecordingFrameRate = new QVBoxLayout(m_pWidgetRecordingFrameRateSettings);
-                        if (pLayoutRecordingFrameRate)
-                        {
-                            pLayoutRecordingFrameRate->setContentsMargins(0, 0, 0, 0);
-
-                            /* Prepare recording frame rate slider: */
-                            m_pSliderRecordingFrameRate = new QIAdvancedSlider(m_pWidgetRecordingFrameRateSettings);
-                            if (m_pSliderRecordingFrameRate)
-                            {
-                                m_pSliderRecordingFrameRate->setOrientation(Qt::Horizontal);
-                                m_pSliderRecordingFrameRate->setMinimum(1);
-                                m_pSliderRecordingFrameRate->setMaximum(30);
-                                m_pSliderRecordingFrameRate->setPageStep(1);
-                                m_pSliderRecordingFrameRate->setSingleStep(1);
-                                m_pSliderRecordingFrameRate->setTickInterval(1);
-                                m_pSliderRecordingFrameRate->setSnappingEnabled(true);
-                                m_pSliderRecordingFrameRate->setOptimalHint(1, 25);
-                                m_pSliderRecordingFrameRate->setWarningHint(25, 30);
-
-                                pLayoutRecordingFrameRate->addWidget(m_pSliderRecordingFrameRate);
-                            }
-                            /* Prepare recording frame rate scale layout: */
-                            QHBoxLayout *pLayoutRecordingFrameRateScale = new QHBoxLayout;
-                            if (pLayoutRecordingFrameRateScale)
-                            {
-                                pLayoutRecordingFrameRateScale->setContentsMargins(0, 0, 0, 0);
-
-                                /* Prepare recording frame rate min label: */
-                                m_pLabelRecordingFrameRateMin = new QLabel(m_pWidgetRecordingFrameRateSettings);
-                                if (m_pLabelRecordingFrameRateMin)
-                                    pLayoutRecordingFrameRateScale->addWidget(m_pLabelRecordingFrameRateMin);
-                                pLayoutRecordingFrameRateScale->addStretch();
-                                /* Prepare recording frame rate max label: */
-                                m_pLabelRecordingFrameRateMax = new QLabel(m_pWidgetRecordingFrameRateSettings);
-                                if (m_pLabelRecordingFrameRateMax)
-                                    pLayoutRecordingFrameRateScale->addWidget(m_pLabelRecordingFrameRateMax);
-
-                                pLayoutRecordingFrameRate->addLayout(pLayoutRecordingFrameRateScale);
-                            }
-                        }
-
-                        pLayoutRecordingSettings->addWidget(m_pWidgetRecordingFrameRateSettings, 3, 1, 2, 1);
-                    }
-                    /* Prepare recording frame rate spinbox: */
-                    m_pSpinboxRecordingFrameRate = new QSpinBox(m_pWidgetRecordingSettings);
-                    if (m_pSpinboxRecordingFrameRate)
-                    {
-                        if (m_pLabelRecordingFrameRate)
-                            m_pLabelRecordingFrameRate->setBuddy(m_pSpinboxRecordingFrameRate);
-                        uiCommon().setMinimumWidthAccordingSymbolCount(m_pSpinboxRecordingFrameRate, 3);
-                        m_pSpinboxRecordingFrameRate->setMinimum(1);
-                        m_pSpinboxRecordingFrameRate->setMaximum(30);
-
-                        pLayoutRecordingSettings->addWidget(m_pSpinboxRecordingFrameRate, 3, 2, 1, 2);
-                    }
-
-                    /* Prepare recording video quality label: */
-                    m_pLabelRecordingVideoQuality = new QLabel(m_pWidgetRecordingSettings);
-                    if (m_pLabelRecordingVideoQuality)
-                    {
-                        m_pLabelRecordingVideoQuality->setAlignment(Qt::AlignRight | Qt::AlignVCenter);
-                        pLayoutRecordingSettings->addWidget(m_pLabelRecordingVideoQuality, 5, 0);
-                    }
-                    /* Prepare recording video quality widget: */
-                    m_pWidgetRecordingVideoQualitySettings = new QWidget(m_pWidgetRecordingSettings);
-                    if (m_pWidgetRecordingVideoQualitySettings)
-                    {
-                        /* Prepare recording video quality layout: */
-                        QVBoxLayout *pLayoutRecordingVideoQuality = new QVBoxLayout(m_pWidgetRecordingVideoQualitySettings);
-                        if (pLayoutRecordingVideoQuality)
-                        {
-                            pLayoutRecordingVideoQuality->setContentsMargins(0, 0, 0, 0);
-
-                            /* Prepare recording video quality slider: */
-                            m_pSliderRecordingVideoQuality = new QIAdvancedSlider(m_pWidgetRecordingVideoQualitySettings);
-                            if (m_pSliderRecordingVideoQuality)
-                            {
-                                m_pSliderRecordingVideoQuality->setOrientation(Qt::Horizontal);
-                                m_pSliderRecordingVideoQuality->setMinimum(1);
-                                m_pSliderRecordingVideoQuality->setMaximum(10);
-                                m_pSliderRecordingVideoQuality->setPageStep(1);
-                                m_pSliderRecordingVideoQuality->setSingleStep(1);
-                                m_pSliderRecordingVideoQuality->setTickInterval(1);
-                                m_pSliderRecordingVideoQuality->setSnappingEnabled(true);
-                                m_pSliderRecordingVideoQuality->setOptimalHint(1, 5);
-                                m_pSliderRecordingVideoQuality->setWarningHint(5, 9);
-                                m_pSliderRecordingVideoQuality->setErrorHint(9, 10);
-
-                                pLayoutRecordingVideoQuality->addWidget(m_pSliderRecordingVideoQuality);
-                            }
-                            /* Prepare recording video quality scale layout: */
-                            QHBoxLayout *pLayoutRecordingVideoQialityScale = new QHBoxLayout;
-                            if (pLayoutRecordingVideoQialityScale)
-                            {
-                                pLayoutRecordingVideoQialityScale->setContentsMargins(0, 0, 0, 0);
-
-                                /* Prepare recording video quality min label: */
-                                m_pLabelRecordingVideoQualityMin = new QLabel(m_pWidgetRecordingVideoQualitySettings);
-                                if (m_pLabelRecordingVideoQualityMin)
-                                    pLayoutRecordingVideoQialityScale->addWidget(m_pLabelRecordingVideoQualityMin);
-                                pLayoutRecordingVideoQialityScale->addStretch();
-                                /* Prepare recording video quality med label: */
-                                m_pLabelRecordingVideoQualityMed = new QLabel(m_pWidgetRecordingVideoQualitySettings);
-                                if (m_pLabelRecordingVideoQualityMed)
-                                    pLayoutRecordingVideoQialityScale->addWidget(m_pLabelRecordingVideoQualityMed);
-                                pLayoutRecordingVideoQialityScale->addStretch();
-                                /* Prepare recording video quality max label: */
-                                m_pLabelRecordingVideoQualityMax = new QLabel(m_pWidgetRecordingVideoQualitySettings);
-                                if (m_pLabelRecordingVideoQualityMax)
-                                    pLayoutRecordingVideoQialityScale->addWidget(m_pLabelRecordingVideoQualityMax);
-
-                                pLayoutRecordingVideoQuality->addLayout(pLayoutRecordingVideoQialityScale);
-                            }
-                        }
-
-                        pLayoutRecordingSettings->addWidget(m_pWidgetRecordingVideoQualitySettings, 5, 1, 2, 1);
-                    }
-                    /* Prepare recording video quality spinbox: */
-                    m_pSpinboxRecordingVideoQuality = new QSpinBox(m_pWidgetRecordingSettings);
-                    if (m_pSpinboxRecordingVideoQuality)
-                    {
-                        if (m_pLabelRecordingVideoQuality)
-                            m_pLabelRecordingVideoQuality->setBuddy(m_pSpinboxRecordingVideoQuality);
-                        uiCommon().setMinimumWidthAccordingSymbolCount(m_pSpinboxRecordingVideoQuality, 5);
-                        m_pSpinboxRecordingVideoQuality->setMinimum(VIDEO_CAPTURE_BIT_RATE_MIN);
-                        m_pSpinboxRecordingVideoQuality->setMaximum(VIDEO_CAPTURE_BIT_RATE_MAX);
-
-                        pLayoutRecordingSettings->addWidget(m_pSpinboxRecordingVideoQuality, 5, 2, 1, 2);
-                    }
-
-                    /* Prepare recording audio quality label: */
-                    m_pLabelRecordingAudioQuality = new QLabel(m_pWidgetRecordingSettings);
-                    if (m_pLabelRecordingAudioQuality)
-                    {
-                        m_pLabelRecordingAudioQuality->setAlignment(Qt::AlignRight | Qt::AlignVCenter);
-                        pLayoutRecordingSettings->addWidget(m_pLabelRecordingAudioQuality, 7, 0);
-                    }
-                    /* Prepare recording audio quality widget: */
-                    m_pWidgetRecordingAudioQualitySettings = new QWidget(m_pWidgetRecordingSettings);
-                    if (m_pWidgetRecordingAudioQualitySettings)
-                    {
-                        /* Prepare recording audio quality layout: */
-                        QVBoxLayout *pLayoutRecordingAudioQuality = new QVBoxLayout(m_pWidgetRecordingAudioQualitySettings);
-                        if (pLayoutRecordingAudioQuality)
-                        {
-                            pLayoutRecordingAudioQuality->setContentsMargins(0, 0, 0, 0);
-
-                            /* Prepare recording audio quality slider: */
-                            m_pSliderRecordingAudioQuality = new QIAdvancedSlider(m_pWidgetRecordingAudioQualitySettings);
-                            if (m_pSliderRecordingAudioQuality)
-                            {
-                                if (m_pLabelRecordingAudioQuality)
-                                    m_pLabelRecordingAudioQuality->setBuddy(m_pSliderRecordingAudioQuality);
-                                m_pSliderRecordingAudioQuality->setOrientation(Qt::Horizontal);
-                                m_pSliderRecordingAudioQuality->setMinimum(1);
-                                m_pSliderRecordingAudioQuality->setMaximum(3);
-                                m_pSliderRecordingAudioQuality->setPageStep(1);
-                                m_pSliderRecordingAudioQuality->setSingleStep(1);
-                                m_pSliderRecordingAudioQuality->setTickInterval(1);
-                                m_pSliderRecordingAudioQuality->setSnappingEnabled(true);
-                                m_pSliderRecordingAudioQuality->setOptimalHint(1, 2);
-                                m_pSliderRecordingAudioQuality->setWarningHint(2, 3);
-
-                                pLayoutRecordingAudioQuality->addWidget(m_pSliderRecordingAudioQuality);
-                            }
-                            /* Prepare recording audio quality scale layout: */
-                            QHBoxLayout *pLayoutRecordingAudioQialityScale = new QHBoxLayout;
-                            if (pLayoutRecordingAudioQialityScale)
-                            {
-                                pLayoutRecordingAudioQialityScale->setContentsMargins(0, 0, 0, 0);
-
-                                /* Prepare recording audio quality min label: */
-                                m_pLabelRecordingAudioQualityMin = new QLabel(m_pWidgetRecordingAudioQualitySettings);
-                                if (m_pLabelRecordingAudioQualityMin)
-                                    pLayoutRecordingAudioQialityScale->addWidget(m_pLabelRecordingAudioQualityMin);
-                                pLayoutRecordingAudioQialityScale->addStretch();
-                                /* Prepare recording audio quality med label: */
-                                m_pLabelRecordingAudioQualityMed = new QLabel(m_pWidgetRecordingAudioQualitySettings);
-                                if (m_pLabelRecordingAudioQualityMed)
-                                    pLayoutRecordingAudioQialityScale->addWidget(m_pLabelRecordingAudioQualityMed);
-                                pLayoutRecordingAudioQialityScale->addStretch();
-                                /* Prepare recording audio quality max label: */
-                                m_pLabelRecordingAudioQualityMax = new QLabel(m_pWidgetRecordingAudioQualitySettings);
-                                if (m_pLabelRecordingAudioQualityMax)
-                                    pLayoutRecordingAudioQialityScale->addWidget(m_pLabelRecordingAudioQualityMax);
-
-                                pLayoutRecordingAudioQuality->addLayout(pLayoutRecordingAudioQialityScale);
-                            }
-                        }
-
-                        pLayoutRecordingSettings->addWidget(m_pWidgetRecordingAudioQualitySettings, 7, 1, 2, 1);
-                    }
-
-                    /* Prepare recording size hint label: */
-                    m_pLabelRecordingSizeHint = new QLabel(m_pWidgetRecordingSettings);
-                    if (m_pLabelRecordingSizeHint)
-                        pLayoutRecordingSettings->addWidget(m_pLabelRecordingSizeHint, 9, 1);
-
-                    /* Prepare recording screens label: */
-                    m_pLabelRecordingScreens = new QLabel(m_pWidgetRecordingSettings);
-                    if (m_pLabelRecordingScreens)
-                    {
-                        m_pLabelRecordingScreens->setAlignment(Qt::AlignRight | Qt::AlignTop);
-                        pLayoutRecordingSettings->addWidget(m_pLabelRecordingScreens, 10, 0);
-                    }
-                    /* Prepare recording screens scroller: */
-                    m_pScrollerRecordingScreens = new UIFilmContainer(m_pWidgetRecordingSettings);
-                    if (m_pScrollerRecordingScreens)
-                    {
-                        if (m_pLabelRecordingScreens)
-                            m_pLabelRecordingScreens->setBuddy(m_pScrollerRecordingScreens);
-                        pLayoutRecordingSettings->addWidget(m_pScrollerRecordingScreens, 10, 1, 1, 3);
-                    }
-                }
-
-                pLayoutRecording->addWidget(m_pWidgetRecordingSettings, 1, 1);
-            }
+            /* Prepare recording editor: */
+            m_pEditorRecordingSettings = new UIRecordingSettingsEditor(m_pTabRecording);
+            if (m_pEditorRecordingSettings)
+                pLayoutRecording->addWidget(m_pEditorRecordingSettings);
+
+            pLayoutRecording->addStretch();
         }
 
@@ -1461 +928 @@
     connect(m_pEditorVRDESettings, &UIVRDESettingsEditor::sigChanged,
             this, &UIMachineSettingsDisplay::revalidate);
-
-    /* Configure 'Recording' connections: */
-    connect(m_pCheckboxRecording, &QCheckBox::toggled,
-            this, &UIMachineSettingsDisplay::sltHandleRecordingCheckboxToggle);
-    connect(m_pComboRecordingMode, static_cast<void(QComboBox::*)(int)>(&QComboBox::currentIndexChanged),
-            this, &UIMachineSettingsDisplay::sltHandleRecordingComboBoxChange);
-    connect(m_pComboRecordingFrameSize, static_cast<void(QComboBox::*)(int)>(&QComboBox:: currentIndexChanged),
-            this, &UIMachineSettingsDisplay::sltHandleRecordingVideoFrameSizeComboboxChange);
-    connect(m_pSpinboxRecordingFrameWidth, static_cast<void(QSpinBox::*)(int)>(&QSpinBox::valueChanged),
-            this, &UIMachineSettingsDisplay::sltHandleRecordingVideoFrameWidthEditorChange);
-    connect(m_pSpinboxRecordingFrameHeight, static_cast<void(QSpinBox::*)(int)>(&QSpinBox::valueChanged),
-            this, &UIMachineSettingsDisplay::sltHandleRecordingVideoFrameHeightEditorChange);
-    connect(m_pSliderRecordingFrameRate, &QIAdvancedSlider::valueChanged,
-            this, &UIMachineSettingsDisplay::sltHandleRecordingVideoFrameRateSliderChange);
-    connect(m_pSpinboxRecordingFrameRate, static_cast<void(QSpinBox::*)(int)>(&QSpinBox::valueChanged),
-            this, &UIMachineSettingsDisplay::sltHandleRecordingVideoFrameRateEditorChange);
-    connect(m_pSliderRecordingVideoQuality, &QIAdvancedSlider::valueChanged,
-            this, &UIMachineSettingsDisplay::sltHandleRecordingVideoQualitySliderChange);
-    connect(m_pSpinboxRecordingVideoQuality, static_cast<void(QSpinBox::*)(int)>(&QSpinBox::valueChanged),
-            this, &UIMachineSettingsDisplay::sltHandleRecordingVideoBitRateEditorChange);
 }
 
@@ -1502 +949 @@
 }
 
-void UIMachineSettingsDisplay::lookForCorrespondingFrameSizePreset()
-{
-    /* Look for video-capture size preset: */
-    lookForCorrespondingPreset(m_pComboRecordingFrameSize,
-                               QSize(m_pSpinboxRecordingFrameWidth->value(),
-                                     m_pSpinboxRecordingFrameHeight->value()));
-}
-
 void UIMachineSettingsDisplay::updateGuestScreenCount()
 {
@@ -1515 +954 @@
     QVector<BOOL> screens = m_pCache->base().m_vecRecordingScreens;
     screens.resize(m_pEditorMonitorCount->value());
-    m_pScrollerRecordingScreens->setValue(screens);
+    m_pEditorRecordingSettings->setScreens(screens);
     m_pEditorScaleFactor->setMonitorCount(m_pEditorMonitorCount->value());
-}
-
-void UIMachineSettingsDisplay::updateRecordingFileSizeHint()
-{
-    m_pLabelRecordingSizeHint->setText(tr("<i>About %1MB per 5 minute video</i>").arg(m_pSpinboxRecordingVideoQuality->value() * 300 / 8 / 1024));
-}
-
-/* static */
-void UIMachineSettingsDisplay::lookForCorrespondingPreset(QComboBox *pComboBox, const QVariant &data)
-{
-    /* Use passed iterator to look for corresponding preset of passed combo-box: */
-    const int iLookupResult = pComboBox->findData(data);
-    if (iLookupResult != -1 && pComboBox->currentIndex() != iLookupResult)
-        pComboBox->setCurrentIndex(iLookupResult);
-    else if (iLookupResult == -1 && pComboBox->currentIndex() != 0)
-        pComboBox->setCurrentIndex(0);
-}
-
-/* static */
-int UIMachineSettingsDisplay::calculateBitRate(int iFrameWidth, int iFrameHeight, int iFrameRate, int iQuality)
-{
-    /* Linear quality<=>bit-rate scale-factor: */
-    const double dResult = (double)iQuality
-                         * (double)iFrameWidth * (double)iFrameHeight * (double)iFrameRate
-                         / (double)10 /* translate quality to [%] */
-                         / (double)1024 /* translate bit-rate to [kbps] */
-                         / (double)18.75 /* linear scale factor */;
-    return (int)dResult;
-}
-
-/* static */
-int UIMachineSettingsDisplay::calculateQuality(int iFrameWidth, int iFrameHeight, int iFrameRate, int iBitRate)
-{
-    /* Linear bit-rate<=>quality scale-factor: */
-    const double dResult = (double)iBitRate
-                         / (double)iFrameWidth / (double)iFrameHeight / (double)iFrameRate
-                         * (double)10 /* translate quality to [%] */
-                         * (double)1024 /* translate bit-rate to [kbps] */
-                         * (double)18.75 /* linear scale factor */;
-    return (int)dResult;
 }
 
@@ -1746 +1145 @@
                 if (fSuccess)
                 {
-                    CRecordingScreenSettingsVector RecordScreenSettingsVector = recordingSettings.GetScreens();
-                    for (int iScreenIndex = 0; fSuccess && iScreenIndex < RecordScreenSettingsVector.size(); ++iScreenIndex)
+                    CRecordingScreenSettingsVector comRecordingScreenSettingsVector = recordingSettings.GetScreens();
+                    for (int iScreenIndex = 0; fSuccess && iScreenIndex < comRecordingScreenSettingsVector.size(); ++iScreenIndex)
                     {
                         if (newDisplayData.m_vecRecordingScreens[iScreenIndex] == oldDisplayData.m_vecRecordingScreens[iScreenIndex])
                             continue;
 
-                        CRecordingScreenSettings recordingScreenSettings = RecordScreenSettingsVector.at(iScreenIndex);
-                        recordingScreenSettings.SetEnabled(newDisplayData.m_vecRecordingScreens[iScreenIndex]);
-                        fSuccess = recordingScreenSettings.isOk();
+                        CRecordingScreenSettings comRecordingScreenSettings = comRecordingScreenSettingsVector.at(iScreenIndex);
+                        comRecordingScreenSettings.SetEnabled(newDisplayData.m_vecRecordingScreens[iScreenIndex]);
+                        fSuccess = comRecordingScreenSettings.isOk();
                     }
                 }
@@ -1761 +1160 @@
             else
             {
-                CRecordingScreenSettingsVector recordingScreenSettingsVector = recordingSettings.GetScreens();
-                for (int iScreenIndex = 0; fSuccess && iScreenIndex < recordingScreenSettingsVector.size(); ++iScreenIndex)
+                CRecordingScreenSettingsVector comRecordingScreenSettingsVector = recordingSettings.GetScreens();
+                for (int iScreenIndex = 0; fSuccess && iScreenIndex < comRecordingScreenSettingsVector.size(); ++iScreenIndex)
                 {
-                    CRecordingScreenSettings recordingScreenSettings = recordingScreenSettingsVector.at(iScreenIndex);
+                    CRecordingScreenSettings comRecordingScreenSettings = comRecordingScreenSettingsVector.at(iScreenIndex);
 
                     // We should save all the options *before* 'Recording' activation.
@@ -1771 +1170 @@
                     if (fSuccess && newDisplayData.m_strRecordingFilePath != oldDisplayData.m_strRecordingFilePath)
                     {
-                        recordingScreenSettings.SetFilename(newDisplayData.m_strRecordingFilePath);
-                        Assert(recordingScreenSettings.isOk());
-                        fSuccess = recordingScreenSettings.isOk();
+                        comRecordingScreenSettings.SetFilename(newDisplayData.m_strRecordingFilePath);
+                        Assert(comRecordingScreenSettings.isOk());
+                        fSuccess = comRecordingScreenSettings.isOk();
                     }
                     /* Save recording frame width: */
                     if (fSuccess && newDisplayData.m_iRecordingVideoFrameWidth != oldDisplayData.m_iRecordingVideoFrameWidth)
                     {
-                        recordingScreenSettings.SetVideoWidth(newDisplayData.m_iRecordingVideoFrameWidth);
-                        Assert(recordingScreenSettings.isOk());
-                        fSuccess = recordingScreenSettings.isOk();
+                        comRecordingScreenSettings.SetVideoWidth(newDisplayData.m_iRecordingVideoFrameWidth);
+                        Assert(comRecordingScreenSettings.isOk());
+                        fSuccess = comRecordingScreenSettings.isOk();
                     }
                     /* Save recording frame height: */
                     if (fSuccess && newDisplayData.m_iRecordingVideoFrameHeight != oldDisplayData.m_iRecordingVideoFrameHeight)
                     {
-                        recordingScreenSettings.SetVideoHeight(newDisplayData.m_iRecordingVideoFrameHeight);
-                        Assert(recordingScreenSettings.isOk());
-                        fSuccess = recordingScreenSettings.isOk();
+                        comRecordingScreenSettings.SetVideoHeight(newDisplayData.m_iRecordingVideoFrameHeight);
+                        Assert(comRecordingScreenSettings.isOk());
+                        fSuccess = comRecordingScreenSettings.isOk();
                     }
                     /* Save recording frame rate: */
                     if (fSuccess && newDisplayData.m_iRecordingVideoFrameRate != oldDisplayData.m_iRecordingVideoFrameRate)
                     {
-                        recordingScreenSettings.SetVideoFPS(newDisplayData.m_iRecordingVideoFrameRate);
-                        Assert(recordingScreenSettings.isOk());
-                        fSuccess = recordingScreenSettings.isOk();
+                        comRecordingScreenSettings.SetVideoFPS(newDisplayData.m_iRecordingVideoFrameRate);
+                        Assert(comRecordingScreenSettings.isOk());
+                        fSuccess = comRecordingScreenSettings.isOk();
                     }
                     /* Save recording frame bit rate: */
                     if (fSuccess && newDisplayData.m_iRecordingVideoBitRate != oldDisplayData.m_iRecordingVideoBitRate)
                     {
-                        recordingScreenSettings.SetVideoRate(newDisplayData.m_iRecordingVideoBitRate);
-                        Assert(recordingScreenSettings.isOk());
-                        fSuccess = recordingScreenSettings.isOk();
+                        comRecordingScreenSettings.SetVideoRate(newDisplayData.m_iRecordingVideoBitRate);
+                        Assert(comRecordingScreenSettings.isOk());
+                        fSuccess = comRecordingScreenSettings.isOk();
                     }
                     /* Save recording options: */
                     if (fSuccess && newDisplayData.m_strRecordingVideoOptions != oldDisplayData.m_strRecordingVideoOptions)
                     {
-                        recordingScreenSettings.SetOptions(newDisplayData.m_strRecordingVideoOptions);
-                        Assert(recordingScreenSettings.isOk());
-                        fSuccess = recordingScreenSettings.isOk();
+                        comRecordingScreenSettings.SetOptions(newDisplayData.m_strRecordingVideoOptions);
+                        Assert(comRecordingScreenSettings.isOk());
+                        fSuccess = comRecordingScreenSettings.isOk();
                     }
                     /* Finally, save the screen's recording state: */
@@ -1814 +1213 @@
                     if (fSuccess && newDisplayData.m_vecRecordingScreens != oldDisplayData.m_vecRecordingScreens)
                     {
-                        recordingScreenSettings.SetEnabled(newDisplayData.m_vecRecordingScreens[iScreenIndex]);
-                        Assert(recordingScreenSettings.isOk());
-                        fSuccess = recordingScreenSettings.isOk();
+                        comRecordingScreenSettings.SetEnabled(newDisplayData.m_vecRecordingScreens[iScreenIndex]);
+                        Assert(comRecordingScreenSettings.isOk());
+                        fSuccess = comRecordingScreenSettings.isOk();
                     }
                 }
@@ -1833 +1232 @@
         else
         {
-            CRecordingScreenSettingsVector recordingScreenSettingsVector = recordingSettings.GetScreens();
-            for (int iScreenIndex = 0; fSuccess && iScreenIndex < recordingScreenSettingsVector.size(); ++iScreenIndex)
-            {
-                CRecordingScreenSettings recordingScreenSettings = recordingScreenSettingsVector.at(iScreenIndex);
+            CRecordingScreenSettingsVector comRecordingScreenSettingsVector = recordingSettings.GetScreens();
+            for (int iScreenIndex = 0; fSuccess && iScreenIndex < comRecordingScreenSettingsVector.size(); ++iScreenIndex)
+            {
+                CRecordingScreenSettings comRecordingScreenSettings = comRecordingScreenSettingsVector.at(iScreenIndex);
 
                 /* Save recording file path: */
                 if (fSuccess && newDisplayData.m_strRecordingFilePath != oldDisplayData.m_strRecordingFilePath)
                 {
-                    recordingScreenSettings.SetFilename(newDisplayData.m_strRecordingFilePath);
-                    Assert(recordingScreenSettings.isOk());
-                    fSuccess = recordingScreenSettings.isOk();
+                    comRecordingScreenSettings.SetFilename(newDisplayData.m_strRecordingFilePath);
+                    Assert(comRecordingScreenSettings.isOk());
+                    fSuccess = comRecordingScreenSettings.isOk();
                 }
                 /* Save recording frame width: */
                 if (fSuccess && newDisplayData.m_iRecordingVideoFrameWidth != oldDisplayData.m_iRecordingVideoFrameWidth)
                 {
-                    recordingScreenSettings.SetVideoWidth(newDisplayData.m_iRecordingVideoFrameWidth);
-                    Assert(recordingScreenSettings.isOk());
-                    fSuccess = recordingScreenSettings.isOk();
+                    comRecordingScreenSettings.SetVideoWidth(newDisplayData.m_iRecordingVideoFrameWidth);
+                    Assert(comRecordingScreenSettings.isOk());
+                    fSuccess = comRecordingScreenSettings.isOk();
                 }
                 /* Save recording frame height: */
                 if (fSuccess && newDisplayData.m_iRecordingVideoFrameHeight != oldDisplayData.m_iRecordingVideoFrameHeight)
                 {
-                    recordingScreenSettings.SetVideoHeight(newDisplayData.m_iRecordingVideoFrameHeight);
-                    Assert(recordingScreenSettings.isOk());
-                    fSuccess = recordingScreenSettings.isOk();
+                    comRecordingScreenSettings.SetVideoHeight(newDisplayData.m_iRecordingVideoFrameHeight);
+                    Assert(comRecordingScreenSettings.isOk());
+                    fSuccess = comRecordingScreenSettings.isOk();
                 }
                 /* Save recording frame rate: */
                 if (fSuccess && newDisplayData.m_iRecordingVideoFrameRate != oldDisplayData.m_iRecordingVideoFrameRate)
                 {
-                    recordingScreenSettings.SetVideoFPS(newDisplayData.m_iRecordingVideoFrameRate);
-                    Assert(recordingScreenSettings.isOk());
-                    fSuccess = recordingScreenSettings.isOk();
+                    comRecordingScreenSettings.SetVideoFPS(newDisplayData.m_iRecordingVideoFrameRate);
+                    Assert(comRecordingScreenSettings.isOk());
+                    fSuccess = comRecordingScreenSettings.isOk();
                 }
                 /* Save recording frame bit rate: */
                 if (fSuccess && newDisplayData.m_iRecordingVideoBitRate != oldDisplayData.m_iRecordingVideoBitRate)
                 {
-                    recordingScreenSettings.SetVideoRate(newDisplayData.m_iRecordingVideoBitRate);
-                    Assert(recordingScreenSettings.isOk());
-                    fSuccess = recordingScreenSettings.isOk();
+                    comRecordingScreenSettings.SetVideoRate(newDisplayData.m_iRecordingVideoBitRate);
+                    Assert(comRecordingScreenSettings.isOk());
+                    fSuccess = comRecordingScreenSettings.isOk();
                 }
                 /* Save capture options: */
                 if (fSuccess && newDisplayData.m_strRecordingVideoOptions != oldDisplayData.m_strRecordingVideoOptions)
                 {
-                    recordingScreenSettings.SetOptions(newDisplayData.m_strRecordingVideoOptions);
-                    Assert(recordingScreenSettings.isOk());
-                    fSuccess = recordingScreenSettings.isOk();
+                    comRecordingScreenSettings.SetOptions(newDisplayData.m_strRecordingVideoOptions);
+                    Assert(comRecordingScreenSettings.isOk());
+                    fSuccess = comRecordingScreenSettings.isOk();
                 }
                 /* Finally, save the screen's recording state: */
@@ -1884 +1283 @@
                 if (fSuccess && newDisplayData.m_vecRecordingScreens != oldDisplayData.m_vecRecordingScreens)
                 {
-                    recordingScreenSettings.SetEnabled(newDisplayData.m_vecRecordingScreens[iScreenIndex]);
-                    Assert(recordingScreenSettings.isOk());
-                    fSuccess = recordingScreenSettings.isOk();
+                    comRecordingScreenSettings.SetEnabled(newDisplayData.m_vecRecordingScreens[iScreenIndex]);
+                    Assert(comRecordingScreenSettings.isOk());
+                    fSuccess = comRecordingScreenSettings.isOk();
                 }
             }
@@ -1907 +1306 @@
     return fSuccess;
 }
-
-void UIMachineSettingsDisplay::enableDisableRecordingWidgets()
-{
-    /* Recording options should be enabled only if:
-     * 1. Machine is in 'offline' or 'saved' state and check-box is checked,
-     * 2. Machine is in 'online' state, check-box is checked, and video recording is *disabled* currently. */
-    const bool fIsRecordingOptionsEnabled = ((isMachineOffline() || isMachineSaved()) && m_pCheckboxRecording->isChecked()) ||
-                                             (isMachineOnline() && !m_pCache->base().m_fRecordingEnabled && m_pCheckboxRecording->isChecked());
-
-    /* Video Capture Screens option should be enabled only if:
-     * Machine is in *any* valid state and check-box is checked. */
-    const bool fIsVideoCaptureScreenOptionEnabled = isMachineInValidMode() && m_pCheckboxRecording->isChecked();
-    const UISettingsDefs::RecordingMode enmRecordingMode =
-        gpConverter->fromString<UISettingsDefs::RecordingMode>(m_pComboRecordingMode->currentText());
-    const bool fRecordVideo =    enmRecordingMode == UISettingsDefs::RecordingMode_VideoOnly
-                              || enmRecordingMode == UISettingsDefs::RecordingMode_VideoAudio;
-    const bool fRecordAudio =    enmRecordingMode == UISettingsDefs::RecordingMode_AudioOnly
-                              || enmRecordingMode == UISettingsDefs::RecordingMode_VideoAudio;
-
-    m_pLabelRecordingFrameSize->setEnabled(fIsRecordingOptionsEnabled && fRecordVideo);
-    m_pComboRecordingFrameSize->setEnabled(fIsRecordingOptionsEnabled && fRecordVideo);
-    m_pSpinboxRecordingFrameWidth->setEnabled(fIsRecordingOptionsEnabled && fRecordVideo);
-    m_pSpinboxRecordingFrameHeight->setEnabled(fIsRecordingOptionsEnabled && fRecordVideo);
-
-    m_pLabelRecordingFrameRate->setEnabled(fIsRecordingOptionsEnabled && fRecordVideo);
-    m_pWidgetRecordingFrameRateSettings->setEnabled(fIsRecordingOptionsEnabled && fRecordVideo);
-    m_pSpinboxRecordingFrameRate->setEnabled(fIsRecordingOptionsEnabled && fRecordVideo);
-
-    m_pLabelRecordingVideoQuality->setEnabled(fIsRecordingOptionsEnabled && fRecordVideo);
-    m_pWidgetRecordingVideoQualitySettings->setEnabled(fIsRecordingOptionsEnabled && fRecordVideo);
-    m_pSpinboxRecordingVideoQuality->setEnabled(fIsRecordingOptionsEnabled && fRecordVideo);
-    m_pScrollerRecordingScreens->setEnabled(fIsVideoCaptureScreenOptionEnabled && fRecordVideo);
-
-    m_pLabelRecordingAudioQuality->setEnabled(fIsRecordingOptionsEnabled && fRecordAudio);
-    m_pWidgetRecordingAudioQualitySettings->setEnabled(fIsRecordingOptionsEnabled && fRecordAudio);
-
-    m_pLabelRecordingScreens->setEnabled(fIsVideoCaptureScreenOptionEnabled && fRecordVideo);
-    m_pLabelRecordingSizeHint->setEnabled(fIsVideoCaptureScreenOptionEnabled && fRecordVideo);
-}

trunk/src/VBox/Frontends/VirtualBox/src/settings/machine/UIMachineSettingsDisplay.h

@@ -29 +29 @@
 
 /* Forward declarations: */
-class QCheckBox;
-class QComboBox;
-class QLabel;
-class QSpinBox;
-class QIAdvancedSlider;
 class QITabWidget;
-class UIFilePathSelector;
-class UIFilmContainer;
 class UIGraphicsControllerEditor;
 #ifdef VBOX_WITH_3D_ACCELERATION
@@ -42 +35 @@
 #endif
 class UIMonitorCountEditor;
+class UIRecordingSettingsEditor;
 class UIScaleFactorEditor;
 class UIVideoMemoryEditor;
@@ -115 +109 @@
 #endif
 
-    /** Handles recording toggle. */
-    void sltHandleRecordingCheckboxToggle();
-    /** Handles recording frame size change. */
-    void sltHandleRecordingVideoFrameSizeComboboxChange();
-    /** Handles recording frame width change. */
-    void sltHandleRecordingVideoFrameWidthEditorChange();
-    /** Handles recording frame height change. */
-    void sltHandleRecordingVideoFrameHeightEditorChange();
-    /** Handles recording frame rate slider change. */
-    void sltHandleRecordingVideoFrameRateSliderChange();
-    /** Handles recording frame rate editor change. */
-    void sltHandleRecordingVideoFrameRateEditorChange();
-    /** Handles recording quality slider change. */
-    void sltHandleRecordingVideoQualitySliderChange();
-    /** Handles recording bit-rate editor change. */
-    void sltHandleRecordingVideoBitRateEditorChange();
-    void sltHandleRecordingComboBoxChange();
-
 private:
 
@@ -153 +129 @@
     bool shouldWeWarnAboutLowVRAM();
 
-    /** Searches for corresponding frame size preset. */
-    void lookForCorrespondingFrameSizePreset();
     /** Updates guest-screen count. */
     void updateGuestScreenCount();
-    /** Updates recording file size hint. */
-    void updateRecordingFileSizeHint();
-    /** Searches for the @a data field in corresponding @a pComboBox. */
-    static void lookForCorrespondingPreset(QComboBox *pComboBox, const QVariant &data);
-    /** Calculates recording video bit-rate for passed @a iFrameWidth, @a iFrameHeight, @a iFrameRate and @a iQuality. */
-    static int calculateBitRate(int iFrameWidth, int iFrameHeight, int iFrameRate, int iQuality);
-    /** Calculates recording video quality for passed @a iFrameWidth, @a iFrameHeight, @a iFrameRate and @a iBitRate. */
-    static int calculateQuality(int iFrameWidth, int iFrameHeight, int iFrameRate, int iBitRate);
     /** Saves existing data from cache. */
     bool saveData();
@@ -173 +139 @@
     /** Saves existing 'Recording' data from cache. */
     bool saveRecordingData();
-    /** Decide which of the recording related widgets are to be disabled/enabled. */
-    void enableDisableRecordingWidgets();
 
     /** Holds the guest OS type ID. */
@@ -214 +178 @@
 
         /** Holds the 'Recording' tab instance. */
-        QWidget            *m_pTabRecording;
-        /** Holds the recording check-box instance. */
-        QCheckBox          *m_pCheckboxRecording;
-        /** Holds the recording settings widget instance. */
-        QWidget            *m_pWidgetRecordingSettings;
-        /** Holds the recording mode label instance. */
-        QLabel             *m_pLabelRecordingMode;
-        /** Holds the recording mode combo instance. */
-        QComboBox          *m_pComboRecordingMode;
-        /** Holds the recording file path label instance. */
-        QLabel             *m_pLabelRecordingFilePath;
-        /** Holds the recording file path editor instance. */
-        UIFilePathSelector *m_pEditorRecordingFilePath;
-        /** Holds the recording frame size label instance. */
-        QLabel             *m_pLabelRecordingFrameSize;
-        /** Holds the recording frame size combo instance. */
-        QComboBox          *m_pComboRecordingFrameSize;
-        /** Holds the recording frame width spinbox instance. */
-        QSpinBox           *m_pSpinboxRecordingFrameWidth;
-        /** Holds the recording frame height spinbox instance. */
-        QSpinBox           *m_pSpinboxRecordingFrameHeight;
-        /** Holds the recording frame rate label instance. */
-        QLabel             *m_pLabelRecordingFrameRate;
-        /** Holds the recording frame rate settings widget instance. */
-        QWidget            *m_pWidgetRecordingFrameRateSettings;
-        /** Holds the recording frame rate slider instance. */
-        QIAdvancedSlider   *m_pSliderRecordingFrameRate;
-        /** Holds the recording frame rate spinbox instance. */
-        QSpinBox           *m_pSpinboxRecordingFrameRate;
-        /** Holds the recording frame rate min label instance. */
-        QLabel             *m_pLabelRecordingFrameRateMin;
-        /** Holds the recording frame rate max label instance. */
-        QLabel             *m_pLabelRecordingFrameRateMax;
-        /** Holds the recording video quality label instance. */
-        QLabel             *m_pLabelRecordingVideoQuality;
-        /** Holds the recording video quality settings widget instance. */
-        QWidget            *m_pWidgetRecordingVideoQualitySettings;
-        /** Holds the recording video quality slider instance. */
-        QIAdvancedSlider   *m_pSliderRecordingVideoQuality;
-        /** Holds the recording video quality spinbox instance. */
-        QSpinBox           *m_pSpinboxRecordingVideoQuality;
-        /** Holds the recording video quality min label instance. */
-        QLabel             *m_pLabelRecordingVideoQualityMin;
-        /** Holds the recording video quality med label instance. */
-        QLabel             *m_pLabelRecordingVideoQualityMed;
-        /** Holds the recording video quality max label instance. */
-        QLabel             *m_pLabelRecordingVideoQualityMax;
-        /** Holds the recording audio quality label instance. */
-        QLabel             *m_pLabelRecordingAudioQuality;
-        /** Holds the recording audio quality settings widget instance. */
-        QWidget            *m_pWidgetRecordingAudioQualitySettings;
-        /** Holds the recording audio quality slider instance. */
-        QIAdvancedSlider   *m_pSliderRecordingAudioQuality;
-        /** Holds the recording audio quality min label instance. */
-        QLabel             *m_pLabelRecordingAudioQualityMin;
-        /** Holds the recording audio quality med label instance. */
-        QLabel             *m_pLabelRecordingAudioQualityMed;
-        /** Holds the recording audio quality max label instance. */
-        QLabel             *m_pLabelRecordingAudioQualityMax;
-        /** Holds the recording size hint label instance. */
-        QLabel             *m_pLabelRecordingSizeHint;
-        /** Holds the recording screens label instance. */
-        QLabel             *m_pLabelRecordingScreens;
-        /** Holds the recording screens scroller instance. */
-        UIFilmContainer    *m_pScrollerRecordingScreens;
+        QWidget                   *m_pTabRecording;
+        /** Holds the Recording settings editor instance. */
+        UIRecordingSettingsEditor *m_pEditorRecordingSettings;
    /** @} */
 };

trunk/src/VBox/Frontends/VirtualBox/src/widgets/UIFilePathSelector.h

@@ -111 +111 @@
     /** Returns the path. */
     QString path() const { return m_strPath; }
+    /** Returns the path which we pass to QFileDialog as initial path. */
+    QString initialPath() const { return m_strInitialPath; }
 
     /** Returns true if the selected path points to an existing/readable file. */