SettingsUi Class Reference

#include <settings_ui.hpp>

Inheritance diagram for SettingsUi:

Collaboration diagram for SettingsUi:

Signals
void	changed ()

Public Member Functions
void	init (Settings *settings, AvailableSettings *availableSettings)
void	initMainWin (Ui::UltragridWindow *ui)
void	initSettingsWin (Ui::Settings *ui)
void	refreshAll ()

Private Slots
void	buildCodecOptControls (const Codec &codec)
void	buildSettingsCodecList ()
void	settingsCodecSelected (QListWidgetItem *curr, QListWidgetItem *prev)
void	settingsDeviceSelected (QListWidgetItem *curr, QListWidgetItem *prev)
void	test ()

Private Member Functions
void	addCallbacks ()
void	addControl (WidgetUi *widget)
void	addDeviceTabs ()
void	buildDeviceOptControls (const Device &dev, DeviceOptTab &tab)
void	buildSettingsDeviceList (QListWidget *list, SettingType type)
void	fillFormOptions (ControlForm &form, std::string_view keyPrefix, const std::vector< CapabOpt > &opts)

Static Private Member Functions
static void	refreshAllCallback (Option &, bool, void *)

Private Attributes
AvailableSettings *	availableSettings = nullptr
std::vector< std::unique_ptr< WidgetUi > >	codecControls
std::map< SettingType, DeviceOptTab >	deviceTabs
std::vector< std::unique_ptr< WidgetUi > >	displayControls
Ui::UltragridWindow *	mainWin = nullptr
Settings *	settings = nullptr
Ui::Settings *	settingsWin = nullptr
std::vector< std::unique_ptr< WidgetUi > >	uiControls

Detailed Description

Definition at line 44 of file settings_ui.hpp.

Member Function Documentation

addCallbacks()

void SettingsUi::addCallbacks ( )

private

Definition at line 134 of file settings_ui.cpp.

                             {
        settings->getOption("audio.compress").addOnChangeCallback(
                        Option::Callback(&audioCompressionCallback, mainWin));
 
        settings->getOption("advanced").addOnChangeCallback(
                        Option::Callback(&SettingsUi::refreshAllCallback, this));
 
        settings->getOption("vuMeter").addOnChangeCallback(
                        Option::Callback(&vuMeterCallback, mainWin));
}

References Option::addOnChangeCallback(), audioCompressionCallback(), Settings::getOption(), mainWin, refreshAllCallback(), settings, and vuMeterCallback().

Referenced by initMainWin().

Here is the call graph for this function:

addControl()

void SettingsUi::addControl ( WidgetUi * widget )

private

Definition at line 16 of file settings_ui.cpp.

                                           {
        uiControls.emplace_back(widget);
 
        connect(widget, &WidgetUi::changed, this, &SettingsUi::changed);
}

References changed(), WidgetUi::changed(), and uiControls.

Referenced by initMainWin(), and initSettingsWin().

Here is the call graph for this function:

addDeviceTabs()

void SettingsUi::addDeviceTabs ( )

private

Definition at line 184 of file settings_ui.cpp.

                              {
        struct{
                const char *label;
                SettingType type;
                const char *keyPrefix;
        } tabs[] = {
                {"Audio playback", AUDIO_PLAYBACK, "audio.playback"},
                {"Audio capture", AUDIO_SRC, "audio.source"},
                {"Display", VIDEO_DISPLAY, "video.display"},
                {"Capture", VIDEO_SRC, "video.source"},
        };
 
        deviceTabs.clear();
 
        for(const auto& i : tabs){
                DeviceOptTab tab;
                tab.keyPrefix = i.keyPrefix;
                tab.page = std::make_unique<QWidget>();
                auto layout = new QHBoxLayout();
                tab.page->setLayout(layout);
 
                tab.listWidget = new QListWidget();
                layout->addWidget(tab.listWidget, 1);
                tab.scrollArea = new QScrollArea();
                layout->addWidget(tab.scrollArea, 3);
 
                tab.listWidget->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
                tab.scrollArea->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
 
                buildSettingsDeviceList(tab.listWidget, i.type);
 
                if(tab.listWidget->count() == 0){
                        continue;
                }
 
                connect(tab.listWidget, &QListWidget::currentItemChanged,
                                this, &SettingsUi::settingsDeviceSelected);
 
                settingsWin->tabWidget->insertTab(0, tab.page.get(), i.label);
                deviceTabs.emplace(i.type, std::move(tab));
        }
}

References buildSettingsDeviceList(), deviceTabs, DeviceOptTab::keyPrefix, label, DeviceOptTab::listWidget, DeviceOptTab::page, DeviceOptTab::scrollArea, settingsDeviceSelected(), settingsWin, and type.

Referenced by initSettingsWin(), and refreshAll().

Here is the call graph for this function:

buildCodecOptControls

void SettingsUi::buildCodecOptControls ( const Codec & codec )

privateslot

Definition at line 287 of file settings_ui.cpp.

                                                        {
        ControlForm form;
 
        QComboBox *encoderCombo = new QComboBox();
        form.formLayout->addRow("Encoder", encoderCombo);
 
        WidgetUi *encoderComboUi = new ComboBoxUi(encoderCombo,
                        settings,
                        "video.compress." + codec.module_name + ".codec." + codec.name + ".encoder",
                        std::bind(getCodecEncoders, codec));
 
        form.uiControls.emplace_back(encoderComboUi);
        connect(encoderComboUi, &WidgetUi::changed, this, &SettingsUi::changed);
 
        for(const auto& compMod : availableSettings->getVideoCompressModules()){
                if(compMod.name == codec.module_name){
                        fillFormOptions(form, "video.compress." + compMod.name + ".", compMod.opts);
                }
        }
 
        codecControls = std::move(form.uiControls);
        settingsWin->codecOptScroll->setWidget(form.uiContainer.release());
}

References availableSettings, changed(), WidgetUi::changed(), codecControls, fillFormOptions(), ControlForm::formLayout, getCodecEncoders(), AvailableSettings::getVideoCompressModules(), codec::name, settings, settingsWin, ControlForm::uiContainer, and ControlForm::uiControls.

Referenced by settingsCodecSelected().

Here is the call graph for this function:

buildDeviceOptControls()

void SettingsUi::buildDeviceOptControls ( const Device & dev, DeviceOptTab & tab )

private

Definition at line 311 of file settings_ui.cpp.

                                                                           {
        ControlForm form;
 
        std::string optPrefix = tab.keyPrefix + "." + dev.type + ".device." + dev.deviceOpt + ".";
        fillFormOptions(form, optPrefix, dev.opts);
 
        tab.uiControls = std::move(form.uiControls);
        tab.scrollArea->setWidget(form.uiContainer.release());
}

References Device::deviceOpt, fillFormOptions(), DeviceOptTab::keyPrefix, Device::opts, DeviceOptTab::scrollArea, Device::type, ControlForm::uiContainer, ControlForm::uiControls, and DeviceOptTab::uiControls.

Referenced by settingsDeviceSelected().

Here is the call graph for this function:

buildSettingsCodecList

void SettingsUi::buildSettingsCodecList ( )

privateslot

Definition at line 229 of file settings_ui.cpp.

                                       {
        if(!settingsWin)
                return;
 
        QListWidget *list = settingsWin->codecList;
        list->clear();
 
        for(const auto& codec : availableSettings->getVideoCompressCodecs()){
                QListWidgetItem *item = new QListWidgetItem(list);
                item->setText(QString::fromStdString(codec.name));
                item->setData(Qt::UserRole, QVariant::fromValue(codec));
 
                list->addItem(item);
        }
}

References availableSettings, AvailableSettings::getVideoCompressCodecs(), codec::name, and settingsWin.

Referenced by initSettingsWin(), and refreshAll().

Here is the call graph for this function:

buildSettingsDeviceList()

void SettingsUi::buildSettingsDeviceList ( QListWidget * list, SettingType type )

private

Definition at line 247 of file settings_ui.cpp.

                                                                           {
        if(!settingsWin)
                return;
 
        list->clear();
 
        for(const auto& dev : availableSettings->getDevices(type)){
                if(dev.opts.empty())
                        continue;
 
                QListWidgetItem *item = new QListWidgetItem(list);
 
                item->setText(QString::fromStdString(dev.name));
                item->setData(Qt::UserRole, QVariant::fromValue(dev));
 
                list->addItem(item);
        }
}

References availableSettings, AvailableSettings::getDevices(), settingsWin, and type.

Referenced by addDeviceTabs().

Here is the call graph for this function:

changed

void SettingsUi::changed ( )

signal

Referenced by addControl(), buildCodecOptControls(), and fillFormOptions().

fillFormOptions()

void SettingsUi::fillFormOptions ( ControlForm & form, std::string_view keyPrefix, const std::vector< CapabOpt > & opts )

private

Definition at line 321 of file settings_ui.cpp.

{
        for(const auto& modOpt : opts){
                QLabel *label = new QLabel(QString::fromStdString(modOpt.displayName));
                QWidget *field = nullptr;
                WidgetUi *widgetUi = nullptr;
                std::string optKey = std::string(keyPrefix) + modOpt.key;
                if(modOpt.booleanOpt){
                        QCheckBox *checkBox = new QCheckBox();
                        field = checkBox;
 
                        widgetUi = new CheckboxUi(checkBox,
                                        settings,
                                        optKey);
                } else {
                        QLineEdit *lineEdit = new QLineEdit();
                        field = lineEdit;
 
                        widgetUi = new LineEditUi(lineEdit,
                                        settings,
                                        optKey);
                }
                label->setToolTip(QString::fromStdString(modOpt.displayDesc));
                field->setToolTip(QString::fromStdString(modOpt.displayDesc));
 
                form.formLayout->addRow(label, field);
 
                form.uiControls.emplace_back(widgetUi);
                connect(widgetUi, &WidgetUi::changed, this, &SettingsUi::changed);
        }
}

References changed(), WidgetUi::changed(), ControlForm::formLayout, label, settings, and ControlForm::uiControls.

Referenced by buildCodecOptControls(), and buildDeviceOptControls().

Here is the call graph for this function:

init()

void SettingsUi::init	(	Settings *	settings,
		AvailableSettings *	availableSettings )

Definition at line 11 of file settings_ui.cpp.

                                                                             {
        this->settings = settings;
        this->availableSettings = availableSettings;
}

References availableSettings, and settings.

Referenced by UltragridWindow::initializeUgOpts().

initMainWin()

void SettingsUi::initMainWin

(

Ui::UltragridWindow *

ui

)

Definition at line 22 of file settings_ui.cpp.

                                                 {
        mainWin = ui;
 
        addCallbacks();
#ifdef DEBUG
        connect(mainWin->actionTest, SIGNAL(triggered()), this, SLOT(test()));
#endif
 
        addControl(new CheckboxUi(ui->fECCheckBox, settings, "network.fec.enabled"));
        addControl(new CheckboxUi(ui->previewCheckBox, settings, "preview"));
        addControl(
                        new LineEditUi(ui->networkDestinationEdit, settings, "network.destination")
                        );
        addControl(new ActionCheckableUi(ui->actionVuMeter, settings, "vuMeter"));
        addControl(new ActionCheckableUi(ui->actionUse_hw_acceleration,
                                settings,
                                "decode.hwaccel"));
 
        addControl(
                        new ComboBoxUi(ui->videoSourceComboBox,
                                settings,
                                "video.source",
                                std::bind(getVideoSrc, availableSettings))
                        );
 
        LineEditUi *videoBitrate = new LineEditUi(ui->videoBitrateEdit,
                        settings,
                        "");
        addControl(videoBitrate);
 
        std::unique_ptr<VideoBitrateCallbackData> vidBitrateCallData(new VideoBitrateCallbackData());
 
        vidBitrateCallData->availSettings = availableSettings;
        vidBitrateCallData->lineEditUi = videoBitrate;
        vidBitrateCallData->label = mainWin->videoBitrateLabel;
 
        auto extraPtr = vidBitrateCallData.get();
        videoBitrate->registerCustomCallback("video.compress",
                        Option::Callback(videoCompressBitrateCallback, extraPtr),
                        std::move(vidBitrateCallData));
 
 
        addControl(
                        new ComboBoxUi(ui->videoCompressionComboBox,
                                settings,
                                "video.compress",
                                std::bind(getVideoCompress, availableSettings))
                        );
 
        addControl(
                        new ComboBoxUi(ui->videoDisplayComboBox,
                                settings,
                                "video.display",
                                std::bind(getVideoDisplay, availableSettings))
                        );
 
        ComboBoxUi *videoModeCombo = new ComboBoxUi(ui->videoModeComboBox,
                                settings,
                                "",
                                std::bind(getVideoModes, availableSettings));
        videoModeCombo->registerCallback("video.source");
        addControl(videoModeCombo);
 
        addControl(
                        new ComboBoxUi(ui->audioCompressionComboBox,
                                settings,
                                "audio.compress",
                                std::bind(getAudioCompress, availableSettings))
                        );
 
        ComboBoxUi *audioSrc = new ComboBoxUi(ui->audioSourceComboBox,
                        settings,
                        "audio.source",
                        std::bind(getAudioSrc, availableSettings));
        audioSrc->registerCallback("video.source");
        addControl(audioSrc);
 
        ComboBoxUi *audioPlayback = new ComboBoxUi(ui->audioPlaybackComboBox,
                        settings,
                        "audio.playback",
                        std::bind(getAudioPlayback, availableSettings));
        audioPlayback->registerCallback("video.display");
        addControl(audioPlayback);
 
        addControl(new LineEditUi(ui->audioBitrateEdit,
                                settings,
                                "audio.compress.bitrate"));
 
        addControl(new SpinBoxUi(ui->audioChannelsSpinBox,
                                settings,
                                "audio.source.channels"));
 
        addControl(new LineEditUi(ui->portLineEdit, settings, "network.port"));
}

References addCallbacks(), addControl(), availableSettings, getAudioCompress(), getAudioPlayback(), getAudioSrc(), getVideoCompress(), getVideoDisplay(), getVideoModes(), getVideoSrc(), mainWin, WidgetUi::registerCallback(), WidgetUi::registerCustomCallback(), settings, test(), and videoCompressBitrateCallback().

Referenced by UltragridWindow::initializeUgOpts().

Here is the call graph for this function:

initSettingsWin()

void SettingsUi::initSettingsWin

(

Ui::Settings *

ui

)

Definition at line 149 of file settings_ui.cpp.

                                              {
        settingsWin = ui;
 
        addControl(new LineEditUi(ui->basePort, settings, "network.port"));
        addControl(new LineEditUi(ui->controlPort, settings, "network.control_port"));
        addControl(new CheckboxUi(ui->controlPortRandom, settings, "network.control_port.random"));
        addControl(new CheckboxUi(ui->fecAutoCheck, settings, "network.fec.auto"));
        addControl(new GroupBoxUi(ui->fecGroupBox, settings, "network.fec.enabled"));
        addControl(new SpinBoxUi(ui->multSpin, settings, "network.fec.mult.factor"));
        addControl(new SpinBoxUi(ui->ldgmK, settings, "network.fec.ldgm.k"));
        addControl(new SpinBoxUi(ui->ldgmM, settings, "network.fec.ldgm.m"));
        addControl(new SpinBoxUi(ui->ldgmC, settings, "network.fec.ldgm.c"));
        addControl(new SpinBoxUi(ui->rsK, settings, "network.fec.rs.k"));
        addControl(new SpinBoxUi(ui->rsN, settings, "network.fec.rs.n"));
        addControl(new RadioButtonUi(ui->fecNoneRadio, "", settings, "network.fec.type"));
        addControl(new RadioButtonUi(ui->fecMultRadio, "mult", settings, "network.fec.type"));
        addControl(new RadioButtonUi(ui->fecLdgmRadio, "ldgm", settings, "network.fec.type"));
        addControl(new RadioButtonUi(ui->fecRsRadio, "rs", settings, "network.fec.type"));
        addControl(new RadioButtonUi(ui->ldgmSimpCpuRadio, "CPU", settings, "network.fec.ldgm.device"));
        addControl(new RadioButtonUi(ui->ldgmSimpGpuRadio, "GPU", settings, "network.fec.ldgm.device"));
        addControl(new RadioButtonUi(ui->ldgmCpuRadio, "CPU", settings, "network.fec.ldgm.device"));
        addControl(new RadioButtonUi(ui->ldgmGpuRadio, "GPU", settings, "network.fec.ldgm.device"));
        addControl(new CheckboxUi(ui->decodeAccelCheck, settings, "decode.hwaccel"));
        addControl(new CheckboxUi(ui->errorsFatalBox, settings, "errors_fatal"));
        addControl(new LineEditUi(ui->encryptionLineEdit, settings, "encryption"));
        addControl(new LineEditUi(ui->extraOptsLineEdit, settings, "extraOpts"));
        addControl(new CheckboxUi(ui->advModeCheck, settings, "advanced"));
 
        addDeviceTabs();
 
        buildSettingsCodecList();
        connect(settingsWin->codecList, &QListWidget::currentItemChanged,
                        this, &SettingsUi::settingsCodecSelected);
}

References addControl(), addDeviceTabs(), buildSettingsCodecList(), settings, settingsCodecSelected(), and settingsWin.

Referenced by SettingsWindow::init().

Here is the call graph for this function:

refreshAll()

void SettingsUi::refreshAll

(

)

Definition at line 117 of file settings_ui.cpp.

                           {
        for(auto &i : uiControls){
                i->refresh();
        }
        buildSettingsCodecList();
        addDeviceTabs();
}

References addDeviceTabs(), buildSettingsCodecList(), and uiControls.

Referenced by refreshAllCallback().

Here is the call graph for this function:

refreshAllCallback()

void SettingsUi::refreshAllCallback ( Option & , bool , void * opaque )

staticprivate

Definition at line 125 of file settings_ui.cpp.

                                                              {
        static_cast<SettingsUi *>(opaque)->refreshAll();
}

References refreshAll().

Referenced by addCallbacks().

Here is the call graph for this function:

settingsCodecSelected

void SettingsUi::settingsCodecSelected ( QListWidgetItem * curr, QListWidgetItem * prev )

privateslot

Definition at line 266 of file settings_ui.cpp.

                                                                              {
        if(!curr){
                codecControls.clear();
                return;
        }
 
        const auto &codec = curr->data(Qt::UserRole).value<Codec>();
 
        buildCodecOptControls(codec);
}

References buildCodecOptControls(), and codecControls.

Referenced by initSettingsWin().

Here is the call graph for this function:

settingsDeviceSelected

void SettingsUi::settingsDeviceSelected ( QListWidgetItem * curr, QListWidgetItem * prev )

privateslot

Definition at line 277 of file settings_ui.cpp.

                                                                               {
        if(!curr){
                return;
        }
 
        const auto &dev = curr->data(Qt::UserRole).value<Device>();
 
        buildDeviceOptControls(dev, deviceTabs.at(dev.settingType));
}

References buildDeviceOptControls(), and deviceTabs.

Referenced by addDeviceTabs().

Here is the call graph for this function:

test

void SettingsUi::test ( )

privateslot

Definition at line 145 of file settings_ui.cpp.

                     {
        printf("%s\n", settings->getLaunchParams().c_str());
}

References Settings::getLaunchParams(), and settings.

Referenced by initMainWin().

Here is the call graph for this function:

Member Data Documentation

availableSettings

AvailableSettings* SettingsUi::availableSettings = nullptr

private

Definition at line 58 of file settings_ui.hpp.

Referenced by buildCodecOptControls(), buildSettingsCodecList(), buildSettingsDeviceList(), init(), and initMainWin().

codecControls

std::vector<std::unique_ptr<WidgetUi> > SettingsUi::codecControls

private

Definition at line 61 of file settings_ui.hpp.

Referenced by buildCodecOptControls(), and settingsCodecSelected().

deviceTabs

std::map<SettingType, DeviceOptTab> SettingsUi::deviceTabs

private

Definition at line 64 of file settings_ui.hpp.

Referenced by addDeviceTabs(), and settingsDeviceSelected().

displayControls

std::vector<std::unique_ptr<WidgetUi> > SettingsUi::displayControls

private

Definition at line 62 of file settings_ui.hpp.

mainWin

Ui::UltragridWindow* SettingsUi::mainWin = nullptr

private

Definition at line 55 of file settings_ui.hpp.

Referenced by addCallbacks(), and initMainWin().

settings

Settings* SettingsUi::settings = nullptr

private

Definition at line 57 of file settings_ui.hpp.

Referenced by addCallbacks(), buildCodecOptControls(), fillFormOptions(), init(), initMainWin(), initSettingsWin(), and test().

settingsWin

Ui::Settings* SettingsUi::settingsWin = nullptr

private

Definition at line 56 of file settings_ui.hpp.

Referenced by addDeviceTabs(), buildCodecOptControls(), buildSettingsCodecList(), buildSettingsDeviceList(), and initSettingsWin().

uiControls

std::vector<std::unique_ptr<WidgetUi> > SettingsUi::uiControls

private

Definition at line 60 of file settings_ui.hpp.

Referenced by addControl(), and refreshAll().

---

The documentation for this class was generated from the following files:

• gui/QT/option/settings_ui.hpp
• gui/QT/option/settings_ui.cpp