Index: /trunk/src/VBox/Frontends/VirtualBox/Makefile.kmk =================================================================== --- /trunk/src/VBox/Frontends/VirtualBox/Makefile.kmk (revision 94435) +++ /trunk/src/VBox/Frontends/VirtualBox/Makefile.kmk (revision 94436) @@ -912,4 +912,5 @@ 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,4 +1472,5 @@ 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 \ Index: /trunk/src/VBox/Frontends/VirtualBox/src/settings/UISettingsDefs.h =================================================================== --- /trunk/src/VBox/Frontends/VirtualBox/src/settings/UISettingsDefs.h (revision 94435) +++ /trunk/src/VBox/Frontends/VirtualBox/src/settings/UISettingsDefs.h (revision 94436) @@ -65,4 +65,6 @@ } +Q_DECLARE_METATYPE(UISettingsDefs::RecordingMode); + /** Template organizing settings object cache: */ Index: /trunk/src/VBox/Frontends/VirtualBox/src/settings/editors/UIRecordingSettingsEditor.cpp =================================================================== --- /trunk/src/VBox/Frontends/VirtualBox/src/settings/editors/UIRecordingSettingsEditor.cpp (revision 94436) +++ /trunk/src/VBox/Frontends/VirtualBox/src/settings/editors/UIRecordingSettingsEditor.cpp (revision 94436) @@ -0,0 +1,905 @@ +/* $Id$ */ +/** @file + * VBox Qt GUI - UIRecordingSettingsEditor class implementation. + */ + +/* + * Copyright (C) 2006-2022 Oracle Corporation + * + * This file is part of VirtualBox Open Source Edition (OSE), as + * available from http://www.virtualbox.org. This file is free software; + * you can redistribute it and/or modify it under the terms of the GNU + * General Public License (GPL) as published by the Free Software + * Foundation, in version 2 as it comes in the "COPYING" file of the + * VirtualBox OSE distribution. VirtualBox OSE is distributed in the + * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. + */ + +/* Qt includes: */ +#include +#include +#include +#include +#include +#include + +/* GUI includes: */ +#include "QIAdvancedSlider.h" +#include "UICommon.h" +#include "UIConverter.h" +#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(pParent) + , m_fFeatureEnabled(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_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 UIRecordingSettingsEditor::setFeatureEnabled(bool fEnabled) +{ + /* Update cached value and + * check-box if value has changed: */ + if (m_fFeatureEnabled != fEnabled) + { + m_fFeatureEnabled = fEnabled; + if (m_pCheckboxFeature) + { + m_pCheckboxFeature->setChecked(m_fFeatureEnabled); + sltHandleFeatureToggled(); + } + } +} + +bool UIRecordingSettingsEditor::isFeatureEnabled() const +{ + return m_pCheckboxFeature ? m_pCheckboxFeature->isChecked() : m_fFeatureEnabled; +} + +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_enmMode != enmMode) + { + m_enmMode = enmMode; + if (m_pComboMode) + { + const int iIndex = m_pComboMode->findData(QVariant::fromValue(enmMode)); + if (iIndex != -1) + m_pComboMode->setCurrentIndex(iIndex); + } + } +} + +UISettingsDefs::RecordingMode UIRecordingSettingsEditor::mode() const +{ + return m_pComboMode ? m_pComboMode->currentData().value() : 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 &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 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(); + 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: */ + 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: */ + prepareWidgets(); + prepareConnections(); + + /* Apply language settings: */ + retranslateUi(); +} + +void UIRecordingSettingsEditor::prepareWidgets() +{ + /* Prepare main layout: */ + QGridLayout *pLayout = new QGridLayout(this); + if (pLayout) + { + pLayout->setContentsMargins(0, 0, 0, 0); + pLayout->setColumnStretch(1, 1); + + /* Prepare 'feature' check-box: */ + m_pCheckboxFeature = new QCheckBox(this); + if (m_pCheckboxFeature) + pLayout->addWidget(m_pCheckboxFeature, 0, 0, 1, 2); + + /* Prepare 20-px shifting spacer: */ + QSpacerItem *pSpacerItem = new QSpacerItem(20, 0, QSizePolicy::Fixed, QSizePolicy::Minimum); + if (pSpacerItem) + pLayout->addItem(pSpacerItem, 1, 0); + + /* Prepare 'settings' widget: */ + QWidget *pWidgetSettings = new QWidget(this); + if (pWidgetSettings) + { + /* Prepare recording settings widget layout: */ + QGridLayout *pLayoutSettings = new QGridLayout(pWidgetSettings); + if (pLayoutSettings) + { + 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(pWidgetSettings, 1, 1, 1, 2); + } + } + + /* Update widget availability: */ + updateWidgetAvailability(); +} + +void UIRecordingSettingsEditor::prepareConnections() +{ + connect(m_pCheckboxFeature, &QCheckBox::toggled, + this, &UIRecordingSettingsEditor::sltHandleFeatureToggled); + connect(m_pComboMode, static_cast(&QComboBox::currentIndexChanged), + this, &UIRecordingSettingsEditor::sltHandleModeComboChange); + connect(m_pComboFrameSize, static_cast(&QComboBox:: currentIndexChanged), + this, &UIRecordingSettingsEditor::sltHandleVideoFrameSizeComboChange); + connect(m_pSpinboxFrameWidth, static_cast(&QSpinBox::valueChanged), + this, &UIRecordingSettingsEditor::sltHandleVideoFrameWidthChange); + connect(m_pSpinboxFrameHeight, static_cast(&QSpinBox::valueChanged), + this, &UIRecordingSettingsEditor::sltHandleVideoFrameHeightChange); + connect(m_pSliderFrameRate, &QIAdvancedSlider::valueChanged, + this, &UIRecordingSettingsEditor::sltHandleVideoFrameRateSliderChange); + connect(m_pSpinboxFrameRate, static_cast(&QSpinBox::valueChanged), + this, &UIRecordingSettingsEditor::sltHandleVideoFrameRateSpinboxChange); + connect(m_pSliderVideoQuality, &QIAdvancedSlider::valueChanged, + this, &UIRecordingSettingsEditor::sltHandleVideoBitRateSliderChange); + connect(m_pSpinboxVideoQuality, static_cast(&QSpinBox::valueChanged), + this, &UIRecordingSettingsEditor::sltHandleVideoBitRateSpinboxChange); +} + +void UIRecordingSettingsEditor::updateWidgetAvailability() +{ + const bool fFeatureEnabled = m_pCheckboxFeature->isChecked(); + const UISettingsDefs::RecordingMode enmRecordingMode = + m_pComboMode->currentData().value(); + 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("About %1MB per 5 minute video") + .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; +} Index: /trunk/src/VBox/Frontends/VirtualBox/src/settings/editors/UIRecordingSettingsEditor.h =================================================================== --- /trunk/src/VBox/Frontends/VirtualBox/src/settings/editors/UIRecordingSettingsEditor.h (revision 94436) +++ /trunk/src/VBox/Frontends/VirtualBox/src/settings/editors/UIRecordingSettingsEditor.h (revision 94436) @@ -0,0 +1,254 @@ +/* $Id$ */ +/** @file + * VBox Qt GUI - UIRecordingSettingsEditor class declaration. + */ + +/* + * Copyright (C) 2006-2022 Oracle Corporation + * + * This file is part of VirtualBox Open Source Edition (OSE), as + * available from http://www.virtualbox.org. This file is free software; + * you can redistribute it and/or modify it under the terms of the GNU + * General Public License (GPL) as published by the Free Software + * Foundation, in version 2 as it comes in the "COPYING" file of the + * VirtualBox OSE distribution. VirtualBox OSE is distributed in the + * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. + */ + +#ifndef FEQT_INCLUDED_SRC_settings_editors_UIRecordingSettingsEditor_h +#define FEQT_INCLUDED_SRC_settings_editors_UIRecordingSettingsEditor_h +#ifndef RT_WITHOUT_PRAGMA_ONCE +# pragma once +#endif + +/* GUI includes: */ +#include "QIWithRetranslateUI.h" +#include "UISettingsDefs.h" + +/* COM includes: */ +#include "COMEnums.h" + +/* Other VBox includes: */ +#include + +/* Forward declarations: */ +class QCheckBox; +class QComboBox; +class QLabel; +class QSpinBox; +class QWidget; +class QIAdvancedSlider; +class UIFilePathSelector; +class UIFilmContainer; + +/** QWidget subclass used as a recording settings editor. */ +class SHARED_LIBRARY_STUFF UIRecordingSettingsEditor : public QIWithRetranslateUI +{ + Q_OBJECT; + +public: + + /** Constructs editor passing @a pParent to the base-class. */ + UIRecordingSettingsEditor(QWidget *pParent = 0); + + /** Defines whether feature is @a fEnabled. */ + void setFeatureEnabled(bool fEnabled); + /** Returns whether feature is enabled. */ + bool isFeatureEnabled() 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 &screens); + /** Returns enabled screens. */ + QVector screens() const; + +protected: + + /** Handles translation event. */ + virtual void retranslateUi() RT_OVERRIDE; + +private slots: + + /** 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: + + /** Prepares all. */ + void prepare(); + /** Prepares widgets. */ + void prepareWidgets(); + /** Prepares connections. */ + void prepareConnections(); + + /** Repopulates auth type combo-box. */ + 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 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 m_screens; + /** @} */ + + /** @name Widgets + * @{ */ + /** Holds the feature check-box instance. */ + 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_UIRecordingSettingsEditor_h */ Index: /trunk/src/VBox/Frontends/VirtualBox/src/settings/machine/UIMachineSettingsDisplay.cpp =================================================================== --- /trunk/src/VBox/Frontends/VirtualBox/src/settings/machine/UIMachineSettingsDisplay.cpp (revision 94435) +++ /trunk/src/VBox/Frontends/VirtualBox/src/settings/machine/UIMachineSettingsDisplay.cpp (revision 94436) @@ -17,24 +17,13 @@ /* Qt includes: */ -#include -#include #include -#include -#include -#include -#include -#include -#include +#include /* 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,4 +32,5 @@ #include "UIMachineSettingsDisplay.h" #include "UIMonitorCountEditor.h" +#include "UIRecordingSettingsEditor.h" #include "UIScaleFactorEditor.h" #include "UITranslator.h" @@ -49,14 +39,9 @@ /* 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,36 +302,4 @@ , 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,5 +326,5 @@ 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,23 +402,23 @@ /* 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,26 +464,31 @@ /* 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,41 +525,35 @@ /* 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(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 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 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,8 +651,8 @@ { message.second << tr("Remote Display is currently enabled for this virtual machine. " - "However, this requires the %1 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 %1 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,66 +697,13 @@ /* 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 horizontal resolution (frame width) of the recorded video.")); - m_pSpinboxRecordingFrameHeight->setToolTip(tr("Holds the vertical resolution (frame height) of the recorded video.")); - m_pLabelRecordingFrameRate->setText(tr("Frame R&ate:")); - m_pSliderRecordingFrameRate->setToolTip(tr("Controls 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_pSpinboxRecordingFrameRate->setToolTip(tr("Controls 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_pLabelRecordingVideoQuality->setText(tr("&Video Quality:")); - m_pSliderRecordingVideoQuality->setToolTip(tr("Controls the quality. 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 kilobits per second. 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 quality. 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,6 +723,4 @@ m_pEditorDisplayScreenFeatures->setMinimumLayoutIndent(iMinimumLayoutHint); #endif - - updateRecordingFileSizeHint(); } @@ -849,5 +746,16 @@ /* 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,101 +788,4 @@ } #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,6 +806,6 @@ { /* Prepare main layout: */ - QVBoxLayout *pLayoutMain = new QVBoxLayout(this); - if (pLayoutMain) + QVBoxLayout *pLayout = new QVBoxLayout(this); + if (pLayout) { /* Prepare tab-widget: */ @@ -1007,5 +818,5 @@ prepareTabRecording(); - pLayoutMain->addWidget(m_pTabWidget); + pLayout->addWidget(m_pTabWidget); } } @@ -1085,357 +896,13 @@ { /* 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,24 +928,4 @@ connect(m_pEditorVRDESettings, &UIVRDESettingsEditor::sigChanged, this, &UIMachineSettingsDisplay::revalidate); - - /* Configure 'Recording' connections: */ - connect(m_pCheckboxRecording, &QCheckBox::toggled, - this, &UIMachineSettingsDisplay::sltHandleRecordingCheckboxToggle); - connect(m_pComboRecordingMode, static_cast(&QComboBox::currentIndexChanged), - this, &UIMachineSettingsDisplay::sltHandleRecordingComboBoxChange); - connect(m_pComboRecordingFrameSize, static_cast(&QComboBox:: currentIndexChanged), - this, &UIMachineSettingsDisplay::sltHandleRecordingVideoFrameSizeComboboxChange); - connect(m_pSpinboxRecordingFrameWidth, static_cast(&QSpinBox::valueChanged), - this, &UIMachineSettingsDisplay::sltHandleRecordingVideoFrameWidthEditorChange); - connect(m_pSpinboxRecordingFrameHeight, static_cast(&QSpinBox::valueChanged), - this, &UIMachineSettingsDisplay::sltHandleRecordingVideoFrameHeightEditorChange); - connect(m_pSliderRecordingFrameRate, &QIAdvancedSlider::valueChanged, - this, &UIMachineSettingsDisplay::sltHandleRecordingVideoFrameRateSliderChange); - connect(m_pSpinboxRecordingFrameRate, static_cast(&QSpinBox::valueChanged), - this, &UIMachineSettingsDisplay::sltHandleRecordingVideoFrameRateEditorChange); - connect(m_pSliderRecordingVideoQuality, &QIAdvancedSlider::valueChanged, - this, &UIMachineSettingsDisplay::sltHandleRecordingVideoQualitySliderChange); - connect(m_pSpinboxRecordingVideoQuality, static_cast(&QSpinBox::valueChanged), - this, &UIMachineSettingsDisplay::sltHandleRecordingVideoBitRateEditorChange); } @@ -1502,12 +949,4 @@ } -void UIMachineSettingsDisplay::lookForCorrespondingFrameSizePreset() -{ - /* Look for video-capture size preset: */ - lookForCorrespondingPreset(m_pComboRecordingFrameSize, - QSize(m_pSpinboxRecordingFrameWidth->value(), - m_pSpinboxRecordingFrameHeight->value())); -} - void UIMachineSettingsDisplay::updateGuestScreenCount() { @@ -1515,46 +954,6 @@ QVector 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("About %1MB per 5 minute video").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,13 +1145,13 @@ 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,8 +1160,8 @@ 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,42 +1170,42 @@ 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,7 +1213,7 @@ 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,50 +1232,50 @@ 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,7 +1283,7 @@ 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,41 +1306,2 @@ 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(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); -} Index: /trunk/src/VBox/Frontends/VirtualBox/src/settings/machine/UIMachineSettingsDisplay.h =================================================================== --- /trunk/src/VBox/Frontends/VirtualBox/src/settings/machine/UIMachineSettingsDisplay.h (revision 94435) +++ /trunk/src/VBox/Frontends/VirtualBox/src/settings/machine/UIMachineSettingsDisplay.h (revision 94436) @@ -29,12 +29,5 @@ /* 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,4 +35,5 @@ #endif class UIMonitorCountEditor; +class UIRecordingSettingsEditor; class UIScaleFactorEditor; class UIVideoMemoryEditor; @@ -115,22 +109,4 @@ #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,16 +129,6 @@ 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,6 +139,4 @@ /** 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,69 +178,7 @@ /** 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; /** @} */ }; Index: /trunk/src/VBox/Frontends/VirtualBox/src/widgets/UIFilePathSelector.h =================================================================== --- /trunk/src/VBox/Frontends/VirtualBox/src/widgets/UIFilePathSelector.h (revision 94435) +++ /trunk/src/VBox/Frontends/VirtualBox/src/widgets/UIFilePathSelector.h (revision 94436) @@ -111,4 +111,6 @@ /** 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. */