mirror of
https://github.com/libretro/RetroArch.git
synced 2026-11-21 12:29:43 -10:00
Builds that trust the test signing key get a Test Signing Key toggle in Notification Visibility. Off hides the on-screen reminder; the log line saying the build trusts a test key stays on every launch. Release builds have no such setting.
9729 lines
307 KiB
C++
9729 lines
307 KiB
C++
#include <QAction>
|
|
#include <QApplication>
|
|
#include <QBitmap>
|
|
#include <QButtonGroup>
|
|
#include <QCloseEvent>
|
|
#include <QColor>
|
|
#include <QDialogButtonBox>
|
|
#include <QDoubleSpinBox>
|
|
#include <QDragEnterEvent>
|
|
#include <QDropEvent>
|
|
#include <QFileDialog>
|
|
#include <QFileInfo>
|
|
#include <QHeaderView>
|
|
#include <QLabel>
|
|
#include <QLineEdit>
|
|
#include <QTableWidget>
|
|
#include <QHash>
|
|
#include <QInputDialog>
|
|
#include <QKeyEvent>
|
|
#include <QLayout>
|
|
#include <QListWidgetItem>
|
|
#include <QMenu>
|
|
#include <QMessageBox>
|
|
#include <QMimeData>
|
|
#include <QPaintEvent>
|
|
#include <QProgressDialog>
|
|
#include <QResizeEvent>
|
|
#include <QScreen>
|
|
#include <QScrollBar>
|
|
#include <QSlider>
|
|
#include <QSpinBox>
|
|
#include <QStackedLayout>
|
|
#include <QStyle>
|
|
#include <QStyleOption>
|
|
#include <QTimer>
|
|
|
|
#include "ui_qt_widgets.h"
|
|
#include "ui_qt.h"
|
|
#include "ui_qt_float_sync.h"
|
|
|
|
/* RetroArch-internal headers are included here, OUTSIDE the extern "C"
|
|
* block below. They self-guard their C declarations with
|
|
* RETRO_BEGIN_DECLS / RETRO_END_DECLS, and several of them transitively
|
|
* include libretro-common/include/retro_atomic.h, which in C++ mode
|
|
* pulls in the C++ <atomic> header. Templates inside extern "C" are a
|
|
* hard error, so these must live outside the extern "C" block. */
|
|
#include "../../config.def.h"
|
|
#include "../../command.h"
|
|
#include "../../driver.h"
|
|
#include "../../core_info.h"
|
|
#include "../../core_option_manager.h"
|
|
#include "../../file_path_special.h"
|
|
#include "../../msg_hash.h"
|
|
#include "../../paths.h"
|
|
#include "../../tasks/tasks_internal.h"
|
|
#include "../../verbosity.h"
|
|
#include "../../version.h"
|
|
#include "../../gfx/video_display_server.h"
|
|
#include "../../input/input_driver.h"
|
|
#include "../../input/input_remapping.h"
|
|
#include "../../network/netplay/netplay.h"
|
|
#include "../../playlist.h"
|
|
|
|
#ifdef HAVE_MENU
|
|
#include "../../menu/menu_driver.h"
|
|
#include "../../menu/menu_entries.h"
|
|
#include "../../menu/menu_displaylist.h"
|
|
#if defined(HAVE_CG) || defined(HAVE_GLSL) || defined(HAVE_SLANG) || defined(HAVE_HLSL)
|
|
#include "../../menu/menu_shader.h"
|
|
#endif
|
|
#endif
|
|
|
|
#ifndef CXX_BUILD
|
|
extern "C" {
|
|
#endif
|
|
|
|
#include <math.h>
|
|
|
|
#include <retro_miscellaneous.h>
|
|
#include <string/stdstring.h>
|
|
#include <streams/file_stream.h>
|
|
#include <file/file_path.h>
|
|
#include <file/archive_file.h>
|
|
#include <lists/string_list.h>
|
|
#include <compat/strl.h>
|
|
|
|
#ifndef CXX_BUILD
|
|
}
|
|
#endif
|
|
|
|
/* Replace characters unsafe in URLs / file names with '_' */
|
|
|
|
/* The hidden-playlist list (desktop_menu_hidden_playlists in
|
|
* retroarch.cfg) is parsed and written by the shared core, in C: Qt's
|
|
* own split() takes its empty-parts flag from Qt::SkipEmptyParts on
|
|
* 5.14+ and QString::SkipEmptyParts before that, and string_split()
|
|
* drops empty parts on every Qt back to 4. The natives use the same
|
|
* two calls. */
|
|
static bool qt_playlist_hidden(const QString &path)
|
|
{
|
|
return companion_core_playlist_is_hidden(ui_companion_qt_core(),
|
|
path.toUtf8().constData());
|
|
}
|
|
|
|
static void qt_set_playlist_hidden(const QString &path, bool hidden)
|
|
{
|
|
companion_core_playlist_set_hidden(ui_companion_qt_core(),
|
|
path.toUtf8().constData(), hidden);
|
|
}
|
|
|
|
#ifdef HAVE_MENU
|
|
static const QRegularExpression decimalsRegex("%.(\\d)f");
|
|
|
|
/* Qt shows a plain-text tooltip on one line however long it is - a
|
|
* sublabel paragraph ran the width of a 2560 px desktop. It wraps
|
|
* rich text to a sane width, so tips go in as escaped rich text. */
|
|
static inline QString wrapped_tooltip(const char *text)
|
|
{
|
|
return QStringLiteral("<qt>") + QString::fromUtf8(text).toHtmlEscaped()
|
|
+ QStringLiteral("</qt>");
|
|
}
|
|
|
|
static inline void add_sublabel_and_whats_this(
|
|
QWidget *widget, rarch_setting_t *setting)
|
|
{
|
|
char tmp[512];
|
|
tmp[0] = '\0';
|
|
|
|
if (menu_cbs_sublabel_for_enum((enum msg_hash_enums)setting->enum_idx,
|
|
(unsigned)setting->type, setting->size, tmp, sizeof(tmp)))
|
|
widget->setToolTip(wrapped_tooltip(tmp));
|
|
|
|
msg_hash_get_help_enum((enum msg_hash_enums)setting->enum_idx,
|
|
tmp, sizeof(tmp));
|
|
|
|
if (!string_is_equal(tmp, msg_hash_to_str(MENU_ENUM_LABEL_VALUE_NO_INFORMATION_AVAILABLE)))
|
|
widget->setWhatsThis(tmp);
|
|
}
|
|
|
|
/* A setting's range is stored as float; converting a float outside
|
|
* int range to int is undefined, and on x86 it produces INT_MIN, which
|
|
* collapses a spin box's range to a single unreachable value. Bounds are
|
|
* therefore clamped in double, where every int is exact, and an
|
|
* unenforced or NaN bound takes the widget's own default. */
|
|
static int qt_setting_bound(const rarch_setting_t *setting,
|
|
unsigned flag, double value, int fallback)
|
|
{
|
|
if (!(setting->flags & flag) || value != value)
|
|
return fallback;
|
|
if (value >= (double)INT_MAX)
|
|
return INT_MAX;
|
|
if (value <= (double)INT_MIN)
|
|
return INT_MIN;
|
|
return (int)value;
|
|
}
|
|
|
|
/* The most choices a radio-button group lays out. */
|
|
#define QT_RADIO_BUTTONS_MAX 256
|
|
|
|
/* The value a spin box can show for a stored value: the stored value
|
|
* clamped to the box's range. The paint-time resync compares against
|
|
* this, so an out-of-range stored value is shown at the nearest bound
|
|
* once instead of being re-set (and repainted) on every paint. */
|
|
static int qt_spinbox_shown(const QSpinBox *box, double value)
|
|
{
|
|
if (value >= (double)box->maximum())
|
|
return box->maximum();
|
|
if (value <= (double)box->minimum())
|
|
return box->minimum();
|
|
return (int)value;
|
|
}
|
|
|
|
static inline QString sanitize_ampersand(QString input)
|
|
{
|
|
return input.replace("&", "&&");
|
|
}
|
|
|
|
static inline QString form_label(rarch_setting_t *setting)
|
|
{
|
|
return QString(sanitize_ampersand(setting->short_description)) + ":";
|
|
}
|
|
|
|
FormLayout::FormLayout(QWidget *parent) : QFormLayout(parent) { }
|
|
|
|
void FormLayout::addCheckBox(rarch_setting_t *setting)
|
|
{
|
|
if (setting && setting->short_description)
|
|
addRow(new CheckBox(setting));
|
|
}
|
|
|
|
void FormLayout::addUIntRadioButtons(rarch_setting_t *setting)
|
|
{
|
|
if (setting && setting->short_description)
|
|
addRow(new UIntRadioButtons(setting));
|
|
}
|
|
|
|
void FormLayout::addUIntComboBox(rarch_setting_t *setting)
|
|
{
|
|
if (setting && setting->short_description)
|
|
addRow(form_label(setting), new UIntComboBox(setting));
|
|
}
|
|
|
|
void FormLayout::addStringComboBox(rarch_setting_t *setting)
|
|
{
|
|
if (setting && setting->short_description)
|
|
addRow(form_label(setting), new StringComboBox(setting));
|
|
}
|
|
|
|
void FormLayout::addStringLineEdit(rarch_setting_t *setting)
|
|
{
|
|
if (setting && setting->short_description)
|
|
addRow(form_label(setting), new StringLineEdit(setting));
|
|
}
|
|
|
|
void FormLayout::addPasswordLineEdit(rarch_setting_t *setting)
|
|
{
|
|
if (setting && setting->short_description)
|
|
addRow(form_label(setting), new PasswordLineEdit(setting));
|
|
}
|
|
|
|
void FormLayout::addUIntSpinBox(rarch_setting_t *setting)
|
|
{
|
|
if (setting && setting->short_description)
|
|
{
|
|
/* Small, discrete integer settings with a representation callback
|
|
* are enumerations, not numeric quantities. Use the same labels as
|
|
* RetroArch's menu instead of exposing their internal integer values. */
|
|
if (setting->actions && setting->actions->repr
|
|
&& setting->step == 1.0f
|
|
&& (setting->flags & SD_FLAG_ENFORCE_MINRANGE)
|
|
&& (setting->flags & SD_FLAG_ENFORCE_MAXRANGE)
|
|
&& setting->max >= setting->min
|
|
&& (setting->max - setting->min) <= 32.0f)
|
|
addRow(form_label(setting), new UIntComboBox(setting,
|
|
setting->min, setting->max));
|
|
else
|
|
{
|
|
UIntSpinBox *spinBox = new UIntSpinBox(setting);
|
|
if (setting->enum_idx == MENU_ENUM_LABEL_MENU_SCROLL_DELAY)
|
|
spinBox->setMaximumWidth(150);
|
|
addRow(form_label(setting), spinBox);
|
|
}
|
|
}
|
|
}
|
|
|
|
void FormLayout::addSizeSpinBox(rarch_setting_t *setting, unsigned scale)
|
|
{
|
|
if (setting && setting->short_description)
|
|
addRow(form_label(setting), new SizeSpinBox(setting, scale));
|
|
}
|
|
|
|
void FormLayout::addFloatSpinBox(rarch_setting_t *setting)
|
|
{
|
|
if (setting && setting->short_description)
|
|
addRow(form_label(setting), new FloatSpinBox(setting));
|
|
}
|
|
|
|
void FormLayout::addRefreshRateControl(rarch_setting_t *setting)
|
|
{
|
|
if (setting && setting->short_description)
|
|
addRow(form_label(setting), new RefreshRateControl(setting));
|
|
}
|
|
|
|
void FormLayout::addDirectorySelector(rarch_setting_t *setting)
|
|
{
|
|
if (setting && setting->short_description)
|
|
addRow(form_label(setting), new DirectorySelector(setting));
|
|
}
|
|
|
|
void FormLayout::addFileSelector(rarch_setting_t *setting)
|
|
{
|
|
if (setting && setting->short_description)
|
|
addRow(form_label(setting), new FileSelector(setting));
|
|
}
|
|
|
|
void FormLayout::addFloatSliderAndSpinBox(rarch_setting_t *setting)
|
|
{
|
|
if (setting && setting->short_description)
|
|
addRow(form_label(setting), new FloatSliderAndSpinBox(setting));
|
|
}
|
|
|
|
void FormLayout::addUIntColorButton(const QString &title,
|
|
msg_hash_enums r, msg_hash_enums g, msg_hash_enums b)
|
|
{
|
|
rarch_setting_t *red = menu_setting_find_enum(r);
|
|
rarch_setting_t *green = menu_setting_find_enum(g);
|
|
rarch_setting_t *blue = menu_setting_find_enum(b);
|
|
|
|
if (red && green && blue)
|
|
addRow(title, new UIntColorButton(red, green, blue));
|
|
}
|
|
|
|
bool FormLayout::addBindButton(rarch_setting_t *setting)
|
|
{
|
|
if (!setting || !setting->short_description)
|
|
return false;
|
|
|
|
addRow(QString(setting->short_description), new BindButton(setting));
|
|
|
|
return true;
|
|
}
|
|
|
|
SettingsGroup::SettingsGroup(const QString &title, QWidget *parent) :
|
|
QGroupBox(title, parent)
|
|
,m_layout(new FormLayout(this)) { }
|
|
|
|
SettingsGroup::SettingsGroup(QWidget *parent) :
|
|
QGroupBox(parent)
|
|
,m_layout(new FormLayout(this)) { }
|
|
|
|
void SettingsGroup::addWidget(QWidget *widget) { m_layout->addWidget(widget); }
|
|
|
|
void SettingsGroup::addRow(QString label, QWidget *widget)
|
|
{
|
|
m_layout->addRow(label, widget);
|
|
}
|
|
|
|
void SettingsGroup::addRow(QWidget *widget) { m_layout->addRow(widget); }
|
|
void SettingsGroup::addRow(QLayout *layout) { m_layout->addRow(layout); }
|
|
|
|
void SettingsGroup::addRow(QString label, QLayout *layout)
|
|
{
|
|
m_layout->addRow(label, layout);
|
|
}
|
|
|
|
/* Add a path setting as a compact horizontal row. This avoids the wide label
|
|
* column reserved by QFormLayout and gives the editable path more room. */
|
|
static void qt_settings_group_add_compact_path(SettingsGroup *group,
|
|
enum msg_hash_enums enum_idx, bool isDirectory)
|
|
{
|
|
rarch_setting_t *setting = menu_setting_find_enum(enum_idx);
|
|
QHBoxLayout *row;
|
|
QLabel *textLabel;
|
|
|
|
if (!group || !setting || !setting->short_description)
|
|
return;
|
|
|
|
/* The setting's own (translated) label, as every other row uses. */
|
|
row = new QHBoxLayout;
|
|
textLabel = new QLabel(form_label(setting));
|
|
textLabel->setSizePolicy(QSizePolicy::Minimum, QSizePolicy::Preferred);
|
|
row->addWidget(textLabel);
|
|
if (isDirectory)
|
|
row->addLayout(new DirectorySelector(setting));
|
|
else
|
|
row->addWidget(new StringLineEdit(setting));
|
|
group->addRow(row);
|
|
}
|
|
|
|
void SettingsGroup::addCheckBox(rarch_setting_t *setting)
|
|
{
|
|
m_layout->addCheckBox(setting);
|
|
}
|
|
|
|
void SettingsGroup::addDirectorySelector(rarch_setting_t *setting)
|
|
{
|
|
m_layout->addDirectorySelector(setting);
|
|
}
|
|
|
|
void SettingsGroup::addFileSelector(rarch_setting_t *setting)
|
|
{
|
|
m_layout->addFileSelector(setting);
|
|
}
|
|
|
|
void SettingsGroup::addStringLineEdit(rarch_setting_t *setting)
|
|
{
|
|
m_layout->addStringLineEdit(setting);
|
|
}
|
|
|
|
void SettingsGroup::addPasswordLineEdit(rarch_setting_t *setting)
|
|
{
|
|
m_layout->addPasswordLineEdit(setting);
|
|
}
|
|
|
|
void SettingsGroup::addStringComboBox(rarch_setting_t *setting)
|
|
{
|
|
m_layout->addStringComboBox(setting);
|
|
}
|
|
|
|
void SettingsGroup::addUIntComboBox(rarch_setting_t *setting)
|
|
{
|
|
m_layout->addUIntComboBox(setting);
|
|
}
|
|
|
|
void SettingsGroup::addUIntRadioButtons(rarch_setting_t *setting)
|
|
{
|
|
m_layout->addUIntRadioButtons(setting);
|
|
}
|
|
|
|
void SettingsGroup::addUIntSpinBox(rarch_setting_t *setting)
|
|
{
|
|
m_layout->addUIntSpinBox(setting);
|
|
}
|
|
|
|
void SettingsGroup::addFloatSpinBox(rarch_setting_t *setting)
|
|
{
|
|
m_layout->addFloatSpinBox(setting);
|
|
}
|
|
|
|
void SettingsGroup::addRefreshRateControl(rarch_setting_t *setting)
|
|
{
|
|
m_layout->addRefreshRateControl(setting);
|
|
}
|
|
|
|
void SettingsGroup::addFloatSliderAndSpinBox(rarch_setting_t *setting)
|
|
{
|
|
m_layout->addFloatSliderAndSpinBox(setting);
|
|
}
|
|
|
|
void SettingsGroup::addUIntColorButton(const QString &title,
|
|
msg_hash_enums r, msg_hash_enums g, msg_hash_enums b)
|
|
{
|
|
m_layout->addUIntColorButton(title, r, g, b);
|
|
}
|
|
|
|
void SettingsGroup::addBindButton(rarch_setting_t *setting)
|
|
{
|
|
m_layout->addBindButton(setting);
|
|
}
|
|
|
|
CheckBox::CheckBox(rarch_setting_t *setting, QWidget *parent) :
|
|
QCheckBox(sanitize_ampersand(setting->short_description), parent)
|
|
,m_setting(setting)
|
|
,m_value(setting->value.target.boolean)
|
|
{
|
|
QAbstractButton::setChecked(*m_value);
|
|
|
|
/* TODO/FIXME only one of these should be necessary */
|
|
connect(this, SIGNAL(toggled(bool)), this, SLOT(onClicked(bool)));
|
|
connect(this, SIGNAL(clicked(bool)), this, SLOT(onClicked(bool)));
|
|
|
|
add_sublabel_and_whats_this(this, m_setting);
|
|
}
|
|
|
|
CheckBox::CheckBox(msg_hash_enums enum_idx, QWidget *parent) :
|
|
CheckBox(menu_setting_find_enum(enum_idx), parent)
|
|
{
|
|
}
|
|
|
|
void CheckBox::onClicked(bool checked)
|
|
{
|
|
*m_value = checked;
|
|
|
|
setting_generic_handle_change(m_setting);
|
|
}
|
|
|
|
void CheckBox::paintEvent(QPaintEvent *event)
|
|
{
|
|
if (*m_value != QAbstractButton::isChecked())
|
|
{
|
|
blockSignals(true);
|
|
|
|
QAbstractButton::setChecked(*m_value);
|
|
|
|
blockSignals(false);
|
|
}
|
|
|
|
QCheckBox::paintEvent(event);
|
|
}
|
|
|
|
CheckableSettingsGroup::CheckableSettingsGroup(rarch_setting_t *setting, QWidget *parent) :
|
|
SettingsGroup(parent)
|
|
{
|
|
if (setting && setting->short_description)
|
|
{
|
|
m_setting = setting;
|
|
m_value = setting->value.target.boolean;
|
|
|
|
setTitle(setting->short_description);
|
|
|
|
setCheckable(true);
|
|
setChecked(*m_value);
|
|
|
|
connect(this, SIGNAL(clicked(bool)), this, SLOT(onClicked(bool)));
|
|
|
|
add_sublabel_and_whats_this(this, m_setting);
|
|
}
|
|
}
|
|
|
|
CheckableSettingsGroup::CheckableSettingsGroup(msg_hash_enums enum_idx, QWidget *parent) :
|
|
CheckableSettingsGroup(menu_setting_find_enum(enum_idx), parent) { }
|
|
|
|
void CheckableSettingsGroup::onClicked(bool checked)
|
|
{
|
|
*m_value = checked;
|
|
|
|
setting_generic_handle_change(m_setting);
|
|
}
|
|
|
|
void CheckableSettingsGroup::paintEvent(QPaintEvent *event)
|
|
{
|
|
if (*m_value != isChecked())
|
|
{
|
|
blockSignals(true);
|
|
|
|
setChecked(*m_value);
|
|
|
|
blockSignals(false);
|
|
}
|
|
|
|
QGroupBox::paintEvent(event);
|
|
}
|
|
|
|
CheckableIcon::CheckableIcon(msg_hash_enums enum_idx, const QIcon &icon, QWidget *parent) :
|
|
CheckableIcon(menu_setting_find_enum(enum_idx), icon, parent) { }
|
|
|
|
CheckableIcon::CheckableIcon(rarch_setting_t *setting, const QIcon &icon, QWidget *parent) :
|
|
QToolButton(parent)
|
|
,m_setting(setting)
|
|
,m_value(setting->value.target.boolean)
|
|
{
|
|
setIcon(icon);
|
|
|
|
setCheckable(true);
|
|
|
|
QAbstractButton::setChecked(*m_value);
|
|
|
|
connect(this, SIGNAL(toggled(bool)), this, SLOT(onToggled(bool)));
|
|
|
|
add_sublabel_and_whats_this(this, m_setting);
|
|
}
|
|
|
|
void CheckableIcon::onToggled(bool checked)
|
|
{
|
|
*m_value = QAbstractButton::isChecked();
|
|
|
|
setting_generic_handle_change(m_setting);
|
|
|
|
QAbstractButton::setChecked(checked);
|
|
}
|
|
|
|
void CheckableIcon::paintEvent(QPaintEvent *event)
|
|
{
|
|
if (QAbstractButton::isChecked() != *m_value)
|
|
{
|
|
blockSignals(true);
|
|
|
|
QAbstractButton::setChecked(*m_value);
|
|
|
|
blockSignals(false);
|
|
}
|
|
QToolButton::paintEvent(event);
|
|
}
|
|
|
|
StringLineEdit::StringLineEdit(rarch_setting_t *setting, QWidget *parent) :
|
|
QLineEdit(setting->value.target.string)
|
|
,m_setting(setting)
|
|
,m_value(setting->value.target.string)
|
|
{
|
|
connect(this, SIGNAL(editingFinished()), this, SLOT(onEditingFinished()));
|
|
|
|
add_sublabel_and_whats_this(this, m_setting);
|
|
}
|
|
|
|
void StringLineEdit::onEditingFinished()
|
|
{
|
|
strlcpy(m_value, text().toUtf8().data(), m_setting->size);
|
|
|
|
setting_generic_handle_change(m_setting);
|
|
|
|
setModified(false);
|
|
}
|
|
|
|
void StringLineEdit::paintEvent(QPaintEvent *event)
|
|
{
|
|
if (!isModified() && m_value != text())
|
|
{
|
|
setText(m_value);
|
|
setModified(false);
|
|
}
|
|
|
|
QLineEdit::paintEvent(event);
|
|
}
|
|
|
|
PasswordLineEdit::PasswordLineEdit(rarch_setting_t *setting, QWidget *parent) :
|
|
StringLineEdit(setting)
|
|
{
|
|
setEchoMode(QLineEdit::Password);
|
|
}
|
|
|
|
StringComboBox::StringComboBox(rarch_setting_t *setting, QWidget *parent) :
|
|
QComboBox(parent)
|
|
,m_setting(setting)
|
|
,m_value(setting->value.target.string)
|
|
{
|
|
addItems(QString(setting->aux.values).split('|'));
|
|
|
|
connect(this, SIGNAL(currentTextChanged(const QString&)), this,
|
|
SLOT(onCurrentTextChanged(const QString&)));
|
|
|
|
add_sublabel_and_whats_this(this, m_setting);
|
|
}
|
|
|
|
void StringComboBox::onCurrentTextChanged(const QString &text)
|
|
{
|
|
strlcpy(m_value, text.toUtf8().data(), m_setting->size);
|
|
|
|
setting_generic_handle_change(m_setting);
|
|
}
|
|
|
|
void StringComboBox::paintEvent(QPaintEvent *event)
|
|
{
|
|
setCurrentText(m_value);
|
|
QComboBox::paintEvent(event);
|
|
}
|
|
|
|
UIntComboBox::UIntComboBox(rarch_setting_t *setting, QWidget *parent) :
|
|
QComboBox(parent)
|
|
,m_setting(setting)
|
|
{
|
|
float min = (setting->flags & SD_FLAG_ENFORCE_MINRANGE) ? setting->min : 0.00f;
|
|
float max = (setting->flags & SD_FLAG_ENFORCE_MAXRANGE) ? setting->max : 999.00f;
|
|
|
|
populate(min, max);
|
|
|
|
connect(this, SIGNAL(currentIndexChanged(int)), this, SLOT(onCurrentIndexChanged(int)));
|
|
|
|
add_sublabel_and_whats_this(this, m_setting);
|
|
}
|
|
|
|
UIntComboBox::UIntComboBox(rarch_setting_t *setting, double min, double max, QWidget *parent) :
|
|
QComboBox(parent)
|
|
,m_setting(setting)
|
|
{
|
|
populate(min, max);
|
|
|
|
connect(this, SIGNAL(currentIndexChanged(int)), this, SLOT(onCurrentIndexChanged(int)));
|
|
|
|
add_sublabel_and_whats_this(this, m_setting);
|
|
}
|
|
|
|
void UIntComboBox::populate(double min, double max)
|
|
{
|
|
float i;
|
|
unsigned orig_value = setting_uint_get(m_setting);
|
|
float step = m_setting->step;
|
|
bool checked_found = false;
|
|
unsigned count = 0;
|
|
|
|
if (m_setting->actions->repr)
|
|
{
|
|
for (i = min; i <= max; i += step)
|
|
{
|
|
char val_s[NAME_MAX_LENGTH];
|
|
unsigned val = (unsigned)i;
|
|
|
|
setting_uint_set(m_setting, val);
|
|
|
|
m_setting->actions->repr(m_setting, val_s, sizeof(val_s));
|
|
|
|
m_hash[i] = QString(val_s);
|
|
|
|
addItem(m_hash[i], i);
|
|
|
|
if (!checked_found && val == orig_value)
|
|
{
|
|
setCurrentIndex(count);
|
|
checked_found = true;
|
|
}
|
|
count++;
|
|
}
|
|
|
|
setting_uint_set(m_setting, orig_value);
|
|
}
|
|
}
|
|
|
|
UIntComboBox::UIntComboBox(msg_hash_enums enum_idx, QWidget *parent) :
|
|
UIntComboBox(menu_setting_find_enum(enum_idx), parent)
|
|
{
|
|
}
|
|
|
|
UIntComboBox::UIntComboBox(msg_hash_enums enum_idx, double min, double max, QWidget *parent) :
|
|
UIntComboBox(menu_setting_find_enum(enum_idx), min, max, parent) { }
|
|
|
|
void UIntComboBox::onCurrentIndexChanged(int index)
|
|
{
|
|
(void)(index);
|
|
|
|
setting_uint_set(m_setting, currentData().toUInt());
|
|
|
|
setting_generic_handle_change(m_setting);
|
|
}
|
|
|
|
void UIntComboBox::paintEvent(QPaintEvent *event)
|
|
{
|
|
setCurrentText(m_hash.value(setting_uint_get(m_setting)));
|
|
QComboBox::paintEvent(event);
|
|
}
|
|
|
|
UIntSpinBox::UIntSpinBox(rarch_setting_t *setting, QWidget *parent) :
|
|
QSpinBox(parent)
|
|
,m_setting(setting)
|
|
{
|
|
setRange(
|
|
qt_setting_bound(setting, SD_FLAG_ENFORCE_MINRANGE, setting->min, 0),
|
|
qt_setting_bound(setting, SD_FLAG_ENFORCE_MAXRANGE, setting->max, INT_MAX));
|
|
|
|
setSingleStep(setting->step);
|
|
|
|
connect(this, SIGNAL(valueChanged(int)), this, SLOT(onValueChanged(int)));
|
|
|
|
add_sublabel_and_whats_this(this, m_setting);
|
|
}
|
|
|
|
UIntSpinBox::UIntSpinBox(msg_hash_enums enum_idx, QWidget *parent) :
|
|
UIntSpinBox(menu_setting_find_enum(enum_idx), parent) { }
|
|
|
|
void UIntSpinBox::onValueChanged(int value)
|
|
{
|
|
setting_uint_set(m_setting, (unsigned)value);
|
|
setting_generic_handle_change(m_setting);
|
|
}
|
|
|
|
void UIntSpinBox::paintEvent(QPaintEvent *event)
|
|
{
|
|
int shown = qt_spinbox_shown(this, (double)setting_uint_get(m_setting));
|
|
|
|
if (value() != shown)
|
|
{
|
|
blockSignals(true);
|
|
|
|
setValue(shown);
|
|
|
|
blockSignals(false);
|
|
}
|
|
|
|
QSpinBox::paintEvent(event);
|
|
}
|
|
|
|
SizeSpinBox::SizeSpinBox(rarch_setting_t *setting, unsigned scale, QWidget *parent) :
|
|
QSpinBox(parent)
|
|
,m_setting(setting)
|
|
,m_value(setting->value.target.sizet)
|
|
,m_scale(scale)
|
|
{
|
|
setRange(
|
|
qt_setting_bound(setting, SD_FLAG_ENFORCE_MINRANGE,
|
|
(double)setting->min / m_scale, 0),
|
|
qt_setting_bound(setting, SD_FLAG_ENFORCE_MAXRANGE,
|
|
(double)setting->max / m_scale, INT_MAX));
|
|
|
|
setSingleStep(setting->step / m_scale);
|
|
|
|
setValue(*m_value / m_scale);
|
|
|
|
connect(this, SIGNAL(valueChanged(int)), this, SLOT(onValueChanged(int)));
|
|
|
|
add_sublabel_and_whats_this(this, m_setting);
|
|
}
|
|
|
|
SizeSpinBox::SizeSpinBox(msg_hash_enums enum_idx, unsigned scale, QWidget *parent) :
|
|
SizeSpinBox(menu_setting_find_enum(enum_idx), scale, parent) { }
|
|
|
|
void SizeSpinBox::onValueChanged(int value)
|
|
{
|
|
*m_value = value * m_scale;
|
|
setting_generic_handle_change(m_setting);
|
|
}
|
|
|
|
void SizeSpinBox::paintEvent(QPaintEvent *event)
|
|
{
|
|
int shown = qt_spinbox_shown(this, (double)(*m_value / m_scale));
|
|
|
|
if (value() != shown)
|
|
{
|
|
blockSignals(true);
|
|
|
|
setValue(shown);
|
|
|
|
blockSignals(false);
|
|
}
|
|
|
|
QSpinBox::paintEvent(event);
|
|
}
|
|
|
|
UIntRadioButton::UIntRadioButton(msg_hash_enums enum_idx, unsigned value, QWidget *parent) :
|
|
QRadioButton(parent)
|
|
,m_setting(menu_setting_find_enum(enum_idx))
|
|
,m_value(value)
|
|
{
|
|
char val_s[NAME_MAX_LENGTH];
|
|
unsigned orig_value = setting_uint_get(m_setting);
|
|
|
|
setting_uint_set(m_setting, value);
|
|
|
|
m_setting->actions->repr(m_setting, val_s, sizeof(val_s));
|
|
|
|
setting_uint_set(m_setting, orig_value);
|
|
|
|
setText(val_s);
|
|
|
|
if (m_value == orig_value)
|
|
setChecked(true);
|
|
|
|
connect(this, SIGNAL(clicked(bool)), this, SLOT(onClicked(bool)));
|
|
}
|
|
|
|
UIntRadioButton::UIntRadioButton(const QString &text,
|
|
rarch_setting_t *setting, unsigned value, QWidget *parent) :
|
|
QRadioButton(text, parent)
|
|
,m_setting(setting)
|
|
,m_value(value)
|
|
{
|
|
connect(this, SIGNAL(clicked(bool)), this, SLOT(onClicked(bool)));
|
|
}
|
|
|
|
void UIntRadioButton::onClicked(bool)
|
|
{
|
|
setting_uint_set(m_setting, m_value);
|
|
setting_generic_handle_change(m_setting);
|
|
}
|
|
|
|
void UIntRadioButton::paintEvent(QPaintEvent *event)
|
|
{
|
|
if (setting_uint_get(m_setting) == m_value)
|
|
setChecked(true);
|
|
else
|
|
setChecked(false);
|
|
|
|
QRadioButton::paintEvent(event);
|
|
}
|
|
|
|
UIntRadioButtons::UIntRadioButtons(rarch_setting_t *setting, QWidget *parent) :
|
|
QGroupBox(setting->short_description, parent)
|
|
,m_setting(setting)
|
|
,m_buttonGroup(new QButtonGroup(this))
|
|
{
|
|
QVBoxLayout *layout = new QVBoxLayout(this);
|
|
/* The choices are enumerated in unsigned integers: a float counter
|
|
* stops advancing past 2^24, and a missing or non-positive step
|
|
* would never reach the end. The button id is an int, so the range
|
|
* is bounded to [0, INT_MAX], and at most QT_RADIO_BUTTONS_MAX
|
|
* buttons are made, which also bounds a row with no enforced
|
|
* maximum. */
|
|
unsigned orig_value = setting_uint_get(setting);
|
|
unsigned min = (unsigned)qt_setting_bound(setting,
|
|
SD_FLAG_ENFORCE_MINRANGE, setting->min < 0.0f ? 0.0 : setting->min, 0);
|
|
unsigned max = (unsigned)qt_setting_bound(setting,
|
|
SD_FLAG_ENFORCE_MAXRANGE, setting->max < 0.0f ? 0.0 : setting->max,
|
|
INT_MAX);
|
|
unsigned step = 1;
|
|
bool checked_found = false;
|
|
|
|
if (setting->step >= (float)INT_MAX)
|
|
step = INT_MAX;
|
|
else if (setting->step >= 1.0f)
|
|
step = (unsigned)setting->step;
|
|
|
|
if (setting->actions->repr && min <= max)
|
|
{
|
|
unsigned i = min;
|
|
unsigned count = 0;
|
|
|
|
for (;;)
|
|
{
|
|
char val_s[NAME_MAX_LENGTH];
|
|
QRadioButton *button = NULL;
|
|
|
|
setting_uint_set(setting, i);
|
|
|
|
setting->actions->repr(setting, val_s, sizeof(val_s));
|
|
|
|
button = new QRadioButton(QString(val_s), this);
|
|
|
|
m_buttonGroup->addButton(button, (int)i);
|
|
|
|
layout->addWidget(button);
|
|
|
|
if (!checked_found && i == orig_value)
|
|
{
|
|
button->setChecked(true);
|
|
checked_found = true;
|
|
}
|
|
|
|
if (++count >= QT_RADIO_BUTTONS_MAX || max - i < step)
|
|
break;
|
|
i += step;
|
|
}
|
|
|
|
setting_uint_set(setting, orig_value);
|
|
}
|
|
add_sublabel_and_whats_this(this, m_setting);
|
|
#if (QT_VERSION >= QT_VERSION_CHECK(6, 0, 0))
|
|
connect(m_buttonGroup, &QButtonGroup::idClicked, this, &UIntRadioButtons::onButtonClicked);
|
|
#else
|
|
connect(m_buttonGroup, SIGNAL(buttonClicked(int)), this, SLOT(onButtonClicked(int)));
|
|
#endif
|
|
}
|
|
|
|
UIntRadioButtons::UIntRadioButtons(msg_hash_enums enum_idx, QWidget *parent) :
|
|
UIntRadioButtons(menu_setting_find_enum(enum_idx), parent) { }
|
|
|
|
void UIntRadioButtons::onButtonClicked(int id)
|
|
{
|
|
setting_uint_set(m_setting, (unsigned)id);
|
|
|
|
setting_generic_handle_change(m_setting);
|
|
}
|
|
|
|
IntSpinBox::IntSpinBox(rarch_setting_t *setting, QWidget *parent) :
|
|
QSpinBox(parent)
|
|
,m_setting(setting)
|
|
{
|
|
setRange(
|
|
qt_setting_bound(setting, SD_FLAG_ENFORCE_MINRANGE, setting->min, INT_MIN),
|
|
qt_setting_bound(setting, SD_FLAG_ENFORCE_MAXRANGE, setting->max, INT_MAX));
|
|
|
|
setSingleStep(setting->step);
|
|
|
|
connect(this, SIGNAL(valueChanged(int)), this, SLOT(onValueChanged(int)));
|
|
|
|
add_sublabel_and_whats_this(this, m_setting);
|
|
}
|
|
|
|
void IntSpinBox::onValueChanged(int value)
|
|
{
|
|
setting_int_set(m_setting, value);
|
|
setting_generic_handle_change(m_setting);
|
|
}
|
|
|
|
void IntSpinBox::paintEvent(QPaintEvent *event)
|
|
{
|
|
int shown = qt_spinbox_shown(this, (double)setting_int_get(m_setting));
|
|
|
|
if (value() != shown)
|
|
{
|
|
blockSignals(true);
|
|
setValue(shown);
|
|
blockSignals(false);
|
|
}
|
|
|
|
QSpinBox::paintEvent(event);
|
|
}
|
|
|
|
RefreshRateControl::RefreshRateControl(rarch_setting_t *setting, QWidget *parent) :
|
|
QWidget(parent)
|
|
,m_setting(setting)
|
|
,m_slider(new QSlider(Qt::Horizontal, this))
|
|
,m_spinBox(new QDoubleSpinBox(this))
|
|
,m_scale(1)
|
|
,m_synced(*setting->value.target.fraction)
|
|
,m_dirty(false)
|
|
{
|
|
int i;
|
|
QPushButton *setButton = new QPushButton(QObject::tr("Set"), this);
|
|
const char *fmt = setting->aux.rounding_fraction;
|
|
/* "%.Nf" - read N directly instead of compiling a regex per widget. */
|
|
int decimals = (fmt && fmt[0] == '%' && fmt[1] == '.'
|
|
&& fmt[2] >= '0' && fmt[2] <= '9' && fmt[3] == 'f')
|
|
? fmt[2] - '0' : 3;
|
|
|
|
for (i = 0; i < decimals; i++)
|
|
m_scale *= 10;
|
|
m_spinBox->setDecimals(decimals);
|
|
m_spinBox->setRange(
|
|
(setting->flags & SD_FLAG_ENFORCE_MINRANGE) ? setting->min : 0.0,
|
|
(setting->flags & SD_FLAG_ENFORCE_MAXRANGE) ? setting->max : 999.0);
|
|
m_spinBox->setSingleStep(setting->step > 0.0f ? setting->step : 0.001f);
|
|
m_spinBox->setValue(*setting->value.target.fraction);
|
|
|
|
m_slider->setRange(
|
|
(int)(m_spinBox->minimum() * m_scale),
|
|
(int)(m_spinBox->maximum() * m_scale));
|
|
m_slider->setSingleStep(qMax(1, (int)(m_spinBox->singleStep() * m_scale)));
|
|
m_slider->setPageStep(qMax(1, m_scale / 10));
|
|
m_slider->setValue((int)(m_spinBox->value() * m_scale));
|
|
|
|
setButton->setAutoDefault(false);
|
|
QHBoxLayout *layout = new QHBoxLayout(this);
|
|
layout->setContentsMargins(0, 0, 0, 0);
|
|
layout->addWidget(m_slider, 1);
|
|
layout->addWidget(m_spinBox);
|
|
layout->addWidget(setButton);
|
|
|
|
connect(m_slider, &QSlider::valueChanged, this, [this](int value)
|
|
{
|
|
m_dirty = true;
|
|
m_spinBox->setValue((double)value / m_scale);
|
|
});
|
|
connect(m_spinBox, QOverload<double>::of(&QDoubleSpinBox::valueChanged),
|
|
this, [this](double value)
|
|
{
|
|
m_dirty = true;
|
|
m_slider->setValue((int)(value * m_scale + 0.5));
|
|
});
|
|
connect(setButton, &QPushButton::clicked, this, [this]()
|
|
{
|
|
float refresh_rate = (float)m_spinBox->value();
|
|
|
|
/* Use the same driver path as the display-reported action. This also
|
|
* updates settings->floats.video_refresh_rate and emits RetroArch's
|
|
* standard refresh-rate OSD notification. */
|
|
driver_ctl(RARCH_DRIVER_CTL_SET_REFRESH_RATE, &refresh_rate);
|
|
command_event(CMD_EVENT_VIDEO_SET_BLOCKING_STATE, NULL);
|
|
m_dirty = false;
|
|
if (ui_qt_float_resync(&m_synced,
|
|
*m_setting->value.target.fraction))
|
|
syncValue();
|
|
});
|
|
|
|
add_sublabel_and_whats_this(m_spinBox, setting);
|
|
}
|
|
|
|
void RefreshRateControl::syncValue()
|
|
{
|
|
float value = *m_setting->value.target.fraction;
|
|
|
|
QSignalBlocker sliderBlock(m_slider);
|
|
QSignalBlocker spinBlock(m_spinBox);
|
|
m_spinBox->setValue(value);
|
|
m_slider->setValue((int)(value * m_scale + 0.5));
|
|
}
|
|
|
|
void RefreshRateControl::paintEvent(QPaintEvent *event)
|
|
{
|
|
QWidget::paintEvent(event);
|
|
|
|
/* The display-reported action updates the same RetroArch setting through
|
|
* the driver. Refresh this staged editor when that happens externally,
|
|
* but never overwrite an uncommitted value being edited here. */
|
|
if (!m_dirty && ui_qt_float_resync(&m_synced,
|
|
*m_setting->value.target.fraction))
|
|
syncValue();
|
|
}
|
|
|
|
FloatSpinBox::FloatSpinBox(msg_hash_enums enum_idx, QWidget *parent) :
|
|
FloatSpinBox(menu_setting_find_enum(enum_idx), parent)
|
|
{
|
|
}
|
|
|
|
const QRegularExpression FloatSpinBox::DECIMALS_REGEX = QRegularExpression("%.(\\d)f");
|
|
|
|
FloatSpinBox::FloatSpinBox(rarch_setting_t *setting, QWidget *parent) :
|
|
QDoubleSpinBox(parent)
|
|
,m_setting(setting)
|
|
,m_value(setting->value.target.fraction)
|
|
{
|
|
QRegularExpressionMatch match = DECIMALS_REGEX.match(setting->aux.rounding_fraction);
|
|
|
|
if (match.hasMatch())
|
|
setDecimals(match.captured(1).toInt());
|
|
|
|
setMinimum((setting->flags & SD_FLAG_ENFORCE_MINRANGE) ? setting->min : 0.00f);
|
|
setMaximum((setting->flags & SD_FLAG_ENFORCE_MAXRANGE) ? setting->max :
|
|
999.00f);
|
|
|
|
setValue(*m_value);
|
|
m_synced = *m_value;
|
|
setSingleStep(setting->step);
|
|
/* Commit typed values when the user presses Return or leaves the
|
|
* field: with keyboard tracking off, QAbstractSpinBox emits
|
|
* valueChanged() exactly once at that point (and only if the value
|
|
* changed), instead of once per keystroke. */
|
|
setKeyboardTracking(false);
|
|
|
|
connect(this, SIGNAL(valueChanged(double)), this, SLOT(onValueChanged(double)));
|
|
add_sublabel_and_whats_this(this, m_setting);
|
|
}
|
|
|
|
void FloatSpinBox::onValueChanged(double value)
|
|
{
|
|
*m_value = (float)value;
|
|
m_synced = *m_value;
|
|
|
|
/* Match the internal menu's ordinary float-setting path: update the
|
|
* setting value, then let its generic change handler mark the settings
|
|
* modified and run any descriptor-specific change callback. In
|
|
* particular, do not invoke the separate display-reported refresh-rate
|
|
* action when editing VIDEO_REFRESH_RATE. */
|
|
setting_generic_handle_change(m_setting);
|
|
}
|
|
|
|
void FloatSpinBox::paintEvent(QPaintEvent *event)
|
|
{
|
|
if (ui_qt_float_resync(&m_synced, *m_value))
|
|
{
|
|
blockSignals(true);
|
|
|
|
if (*m_value < minimum() || *m_value > maximum())
|
|
{
|
|
*m_value = m_setting->default_value.fraction;
|
|
m_synced = *m_value;
|
|
}
|
|
|
|
setValue(*m_value);
|
|
|
|
blockSignals(false);
|
|
}
|
|
|
|
QDoubleSpinBox::paintEvent(event);
|
|
}
|
|
|
|
PathButton::PathButton(rarch_setting_t *setting, QWidget *parent) :
|
|
QPushButton("Browse...", parent)
|
|
,m_setting(setting)
|
|
,m_value(setting->value.target.string)
|
|
,m_dir(setting->default_value.string)
|
|
{
|
|
connect(this, SIGNAL(clicked(bool)), this, SLOT(onClicked(bool)));
|
|
|
|
add_sublabel_and_whats_this(this, m_setting);
|
|
}
|
|
|
|
QString PathButton::currentPath()
|
|
{
|
|
QString current(m_setting->value.target.string);
|
|
if (current.isEmpty())
|
|
current = m_setting->default_value.string;
|
|
return current;
|
|
}
|
|
|
|
void DirectoryButton::onClicked(bool)
|
|
{
|
|
QString dir = QFileDialog::getExistingDirectory(
|
|
this,
|
|
"Choose " + QString(m_setting->short_description) + " Directory",
|
|
currentPath());
|
|
|
|
if (!dir.isNull())
|
|
{
|
|
strlcpy(m_setting->value.target.string, QDir::toNativeSeparators(dir).toUtf8().data(), m_setting->size);
|
|
|
|
setting_generic_handle_change(m_setting);
|
|
}
|
|
|
|
emit changed();
|
|
}
|
|
|
|
void FileButton::onClicked(bool)
|
|
{
|
|
QString file = QFileDialog::getOpenFileName(
|
|
this,
|
|
"Choose File",
|
|
currentPath(),
|
|
QString(m_setting->short_description) + " (*." + QString(m_setting->aux.values) + ")");
|
|
|
|
if (!file.isNull())
|
|
{
|
|
strlcpy(m_setting->value.target.string, QDir::toNativeSeparators(file).toUtf8().data(), m_setting->size);
|
|
|
|
setting_generic_handle_change(m_setting);
|
|
}
|
|
|
|
emit changed();
|
|
}
|
|
|
|
DirectorySelector::DirectorySelector(rarch_setting_t *setting, QWidget *parent) :
|
|
QHBoxLayout(parent)
|
|
,m_lineEdit(new StringLineEdit(setting))
|
|
,m_button(new DirectoryButton(setting))
|
|
{
|
|
addWidget(m_lineEdit);
|
|
addWidget(m_button);
|
|
|
|
connect(m_button, SIGNAL(changed()), m_lineEdit, SLOT(update()));
|
|
}
|
|
|
|
FileSelector::FileSelector(rarch_setting_t *setting, QWidget *parent) :
|
|
QHBoxLayout(parent)
|
|
,m_lineEdit(new StringLineEdit(setting))
|
|
,m_button(new FileButton(setting))
|
|
|
|
{
|
|
addWidget(m_lineEdit);
|
|
addWidget(m_button);
|
|
|
|
connect(m_button, SIGNAL(changed()), m_lineEdit, SLOT(update()));
|
|
}
|
|
|
|
FloatSlider::FloatSlider(rarch_setting_t *setting, QWidget *parent) :
|
|
QSlider(Qt::Horizontal, parent)
|
|
,m_setting(setting)
|
|
,m_value(setting->value.target.fraction)
|
|
,m_decimalsRegEx("%.(\\d)f")
|
|
{
|
|
QRegularExpressionMatch match = m_decimalsRegEx.match(setting->aux.rounding_fraction);
|
|
|
|
if (match.hasMatch())
|
|
m_precision = pow(10, match.captured(1).toInt());
|
|
else
|
|
m_precision = 10 * 10 * 10;
|
|
|
|
setMinimum((setting->flags & SD_FLAG_ENFORCE_MINRANGE) ? setting->min *
|
|
m_precision : 0.00f * m_precision);
|
|
setMaximum((setting->flags & SD_FLAG_ENFORCE_MAXRANGE) ? setting->max *
|
|
m_precision : 999.00f * m_precision);
|
|
|
|
setSingleStep(setting->step * m_precision);
|
|
|
|
setValue(*m_value * m_precision);
|
|
m_synced = *m_value;
|
|
|
|
connect(this, SIGNAL(valueChanged(int)), this, SLOT(onValueChanged(int)));
|
|
|
|
add_sublabel_and_whats_this(this, m_setting);
|
|
}
|
|
|
|
void FloatSlider::onValueChanged(int value)
|
|
{
|
|
*m_value = (float)value / m_precision;
|
|
m_synced = *m_value;
|
|
|
|
setting_generic_handle_change(m_setting);
|
|
}
|
|
|
|
void FloatSlider::paintEvent(QPaintEvent *event)
|
|
{
|
|
if (ui_qt_float_resync(&m_synced, *m_value))
|
|
{
|
|
blockSignals(true);
|
|
|
|
setValue(*m_value * m_precision);
|
|
|
|
blockSignals(false);
|
|
}
|
|
|
|
QSlider::paintEvent(event);
|
|
}
|
|
|
|
FloatSliderAndSpinBox::FloatSliderAndSpinBox(msg_hash_enums enum_idx, QWidget *parent) :
|
|
FloatSliderAndSpinBox(menu_setting_find_enum(enum_idx), parent)
|
|
{
|
|
}
|
|
|
|
FloatSliderAndSpinBox::FloatSliderAndSpinBox(rarch_setting_t *setting, QWidget *parent) :
|
|
QHBoxLayout(parent)
|
|
,m_slider(new FloatSlider(setting))
|
|
,m_spinBox(new FloatSpinBox(setting))
|
|
{
|
|
addWidget(m_slider);
|
|
addWidget(m_spinBox);
|
|
|
|
connect(m_slider, SIGNAL(valueChanged(int)), this, SLOT(onSliderValueChanged(int)));
|
|
connect(m_spinBox, SIGNAL(valueChanged(double)), this, SLOT(onSpinBoxValueChanged(double)));
|
|
}
|
|
|
|
void FloatSliderAndSpinBox::onSliderValueChanged(int value)
|
|
{
|
|
(void)(value);
|
|
|
|
m_spinBox->update();
|
|
}
|
|
|
|
void FloatSliderAndSpinBox::onSpinBoxValueChanged(double value)
|
|
{
|
|
(void)(value);
|
|
|
|
m_slider->update();
|
|
}
|
|
|
|
BindButton::BindButton(rarch_setting_t *setting, QWidget *parent) :
|
|
QPushButton(parent)
|
|
,m_setting(setting)
|
|
{
|
|
char val_s[NAME_MAX_LENGTH];
|
|
|
|
setting->actions->repr(setting, val_s, sizeof(val_s));
|
|
|
|
setText(val_s);
|
|
setAutoDefault(false);
|
|
|
|
connect(this, SIGNAL(clicked(bool)), this, SLOT(onClicked(bool)));
|
|
}
|
|
|
|
BindButton::BindButton(msg_hash_enums enum_idx, QWidget *parent) :
|
|
BindButton(menu_setting_find_enum(enum_idx), parent)
|
|
{
|
|
}
|
|
|
|
void BindButton::onClicked(bool checked)
|
|
{
|
|
(void)(checked);
|
|
|
|
m_setting->actions->ok(m_setting, 0, false);
|
|
}
|
|
|
|
ColorButton::ColorButton(rarch_setting_t *red, rarch_setting_t *green, rarch_setting_t *blue, QWidget *parent) :
|
|
QToolButton(parent)
|
|
,m_red(red)
|
|
,m_green(green)
|
|
,m_blue(blue)
|
|
,m_dialog(new QColorDialog(this))
|
|
{
|
|
setMinimumSize(64, 0);
|
|
|
|
m_dialog->setOptions(QColorDialog::NoButtons);
|
|
|
|
connect(this, SIGNAL(clicked()), m_dialog, SLOT(open()));
|
|
connect(m_dialog, SIGNAL(currentColorChanged(const QColor&)), this, SLOT(onColorChanged(const QColor&)));
|
|
}
|
|
|
|
ColorButton::ColorButton(msg_hash_enums red, msg_hash_enums green, msg_hash_enums blue, QWidget *parent) :
|
|
ColorButton(menu_setting_find_enum(red), menu_setting_find_enum(green), menu_setting_find_enum(blue), parent)
|
|
{
|
|
}
|
|
|
|
/* Stolen from Qt Creator's QtColorButton */
|
|
void ColorButton::paintEvent(QPaintEvent *event)
|
|
{
|
|
const int pixSize = 10;
|
|
const int corr = 5;
|
|
const QColor frameColor1(0, 0, 0, 26);
|
|
const QColor frameColor2(0, 0, 0, 51);
|
|
|
|
QToolButton::paintEvent(event);
|
|
if (!isEnabled())
|
|
return;
|
|
|
|
QBrush br(color());
|
|
|
|
QPainter p(this);
|
|
QRect r = rect().adjusted(corr, corr, -corr, -corr);
|
|
p.setBrushOrigin((r.width() % pixSize + pixSize) / 2 + corr, (r.height() % pixSize + pixSize) / 2 + corr);
|
|
p.fillRect(r, br);
|
|
|
|
p.setPen(frameColor1);
|
|
p.drawRect(r.adjusted(1, 1, -2, -2));
|
|
p.setPen(frameColor2);
|
|
p.drawRect(r.adjusted(0, 0, -1, -1));
|
|
}
|
|
|
|
UIntColorButton::UIntColorButton(msg_hash_enums red,
|
|
msg_hash_enums green, msg_hash_enums blue, QWidget *parent) :
|
|
ColorButton(red, green, blue, parent) { }
|
|
|
|
UIntColorButton::UIntColorButton(rarch_setting_t *red,
|
|
rarch_setting_t *green, rarch_setting_t *blue, QWidget *parent) :
|
|
ColorButton(red, green, blue, parent) { }
|
|
|
|
void UIntColorButton::onColorChanged(const QColor &color)
|
|
{
|
|
if (color.isValid())
|
|
{
|
|
*m_red->value.target.unsigned_integer = color.red();
|
|
*m_green->value.target.unsigned_integer = color.green();
|
|
*m_blue->value.target.unsigned_integer = color.blue();
|
|
}
|
|
}
|
|
|
|
QColor UIntColorButton::color()
|
|
{
|
|
return QColor(
|
|
*m_red->value.target.unsigned_integer,
|
|
*m_green->value.target.unsigned_integer,
|
|
*m_blue->value.target.unsigned_integer);
|
|
}
|
|
|
|
FloatColorButton::FloatColorButton(msg_hash_enums red,
|
|
msg_hash_enums green, msg_hash_enums blue, QWidget *parent) :
|
|
ColorButton(red, green, blue, parent) { }
|
|
|
|
void FloatColorButton::onColorChanged(const QColor &color)
|
|
{
|
|
if (color.isValid())
|
|
{
|
|
*m_red->value.target.fraction = color.red() / 255.0f;
|
|
*m_green->value.target.fraction = color.green() / 255.0f;
|
|
*m_blue->value.target.fraction = color.blue() / 255.0f;
|
|
}
|
|
}
|
|
|
|
QColor FloatColorButton::color()
|
|
{
|
|
return QColor(
|
|
*m_red->value.target.fraction * 255,
|
|
*m_green->value.target.fraction * 255,
|
|
*m_blue->value.target.fraction * 255);
|
|
}
|
|
#endif
|
|
|
|
FileDropWidget::FileDropWidget(QWidget *parent) :
|
|
QStackedWidget(parent)
|
|
{
|
|
setAcceptDrops(true);
|
|
}
|
|
|
|
void FileDropWidget::paintEvent(QPaintEvent *event)
|
|
{
|
|
QStyleOption o;
|
|
QPainter p;
|
|
o.initFrom(this);
|
|
p.begin(this);
|
|
style()->drawPrimitive(
|
|
QStyle::PE_Widget, &o, &p, this);
|
|
p.end();
|
|
|
|
QWidget::paintEvent(event);
|
|
}
|
|
|
|
void FileDropWidget::keyPressEvent(QKeyEvent *event)
|
|
{
|
|
int key = event->key();
|
|
if ( key == Qt::Key_Return
|
|
|| key == Qt::Key_Enter)
|
|
{
|
|
event->accept();
|
|
emit enterPressed();
|
|
}
|
|
else if (key == Qt::Key_Delete)
|
|
{
|
|
event->accept();
|
|
emit deletePressed();
|
|
}
|
|
else
|
|
QWidget::keyPressEvent(event);
|
|
}
|
|
|
|
void FileDropWidget::dragEnterEvent(QDragEnterEvent *event)
|
|
{
|
|
const QMimeData *data = event->mimeData();
|
|
|
|
if (data->hasUrls())
|
|
event->acceptProposedAction();
|
|
}
|
|
|
|
/* Workaround for QTBUG-72844. Without it, you can't drop on this if you
|
|
* first drag over another widget that doesn't accept drops. */
|
|
void FileDropWidget::dragMoveEvent(QDragMoveEvent *event)
|
|
{
|
|
event->acceptProposedAction();
|
|
}
|
|
|
|
void FileDropWidget::dropEvent(QDropEvent *event)
|
|
{
|
|
const QMimeData *data = event->mimeData();
|
|
|
|
if (data->hasUrls())
|
|
{
|
|
int i;
|
|
QStringList files;
|
|
QList<QUrl> urls = data->urls();
|
|
|
|
for (i = 0; i < urls.count(); i++)
|
|
{
|
|
QString path(urls.at(i).toLocalFile());
|
|
|
|
files.append(path);
|
|
}
|
|
|
|
emit filesDropped(files);
|
|
}
|
|
}
|
|
|
|
void MainWindow::onFileDropWidgetContextMenuRequested(const QPoint &pos)
|
|
{
|
|
QScopedPointer<QMenu> menu;
|
|
QScopedPointer<QAction> downloadThumbnailAction;
|
|
QScopedPointer<QAction> addEntryAction;
|
|
QScopedPointer<QAction> addFilesAction;
|
|
QScopedPointer<QAction> addFolderAction;
|
|
QScopedPointer<QAction> editAction;
|
|
QScopedPointer<QAction> deleteAction;
|
|
QPointer<QAction> selectedAction;
|
|
QPoint cursorPos = QCursor::pos();
|
|
PlaylistEntry currentEntry = getCurrentContentEntry();
|
|
bool specialPlaylist = currentPlaylistIsSpecial();
|
|
bool allPlaylist = currentPlaylistIsAll();
|
|
bool actionsAdded = false;
|
|
|
|
menu.reset(new QMenu(this));
|
|
|
|
if (!specialPlaylist)
|
|
{
|
|
downloadThumbnailAction.reset(new QAction(
|
|
QString(msg_hash_to_str(
|
|
MENU_ENUM_LABEL_VALUE_QT_DOWNLOAD_THUMBNAIL)), this));
|
|
menu->addAction(downloadThumbnailAction.data());
|
|
}
|
|
|
|
if (!allPlaylist)
|
|
{
|
|
addEntryAction.reset(new QAction(QString(msg_hash_to_str(MENU_ENUM_LABEL_VALUE_QT_ADD_ENTRY)), this));
|
|
menu->addAction(addEntryAction.data());
|
|
|
|
addFilesAction.reset(new QAction(QString(msg_hash_to_str(MENU_ENUM_LABEL_VALUE_QT_ADD_FILES)), this));
|
|
menu->addAction(addFilesAction.data());
|
|
|
|
addFolderAction.reset(new QAction(QString(msg_hash_to_str(MENU_ENUM_LABEL_VALUE_QT_ADD_FOLDER)), this));
|
|
menu->addAction(addFolderAction.data());
|
|
|
|
editAction.reset(new QAction(QString(msg_hash_to_str(MENU_ENUM_LABEL_VALUE_QT_EDIT)), this));
|
|
deleteAction.reset(new QAction(QString(msg_hash_to_str(MENU_ENUM_LABEL_VALUE_QT_DELETE)), this));
|
|
|
|
if (!currentEntry.path.isEmpty())
|
|
{
|
|
menu->addAction(editAction.data());
|
|
menu->addAction(deleteAction.data());
|
|
}
|
|
|
|
actionsAdded = true;
|
|
}
|
|
|
|
if (actionsAdded)
|
|
selectedAction = menu->exec(cursorPos);
|
|
|
|
if (!selectedAction)
|
|
return;
|
|
|
|
if (!specialPlaylist)
|
|
{
|
|
if (selectedAction == downloadThumbnailAction.data())
|
|
{
|
|
PlaylistEntry entry = getCurrentContentEntry();
|
|
QString system = QFileInfo(getCurrentPlaylistPath()).completeBaseName();
|
|
QString title = entry.label;
|
|
|
|
if (!title.isEmpty())
|
|
{
|
|
if (m_pendingThumbnailDownloadTypes.isEmpty())
|
|
{
|
|
m_pendingThumbnailDownloadTypes.append(THUMBNAIL_BOXART);
|
|
m_pendingThumbnailDownloadTypes.append(THUMBNAIL_SCREENSHOT);
|
|
m_pendingThumbnailDownloadTypes.append(THUMBNAIL_TITLE);
|
|
m_pendingThumbnailDownloadTypes.append(THUMBNAIL_LOGO);
|
|
downloadThumbnail(system, title);
|
|
}
|
|
else
|
|
{
|
|
showMessageBox(msg_hash_to_str(
|
|
MENU_ENUM_LABEL_VALUE_QT_DOWNLOAD_ALREADY_IN_PROGRESS),
|
|
MainWindow::MSGBOX_TYPE_ERROR,
|
|
Qt::ApplicationModal, false);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!allPlaylist)
|
|
{
|
|
if (selectedAction == addFilesAction.data())
|
|
{
|
|
QStringList filePaths = QFileDialog::getOpenFileNames(
|
|
this,
|
|
msg_hash_to_str(MENU_ENUM_LABEL_VALUE_QT_SELECT_FILES));
|
|
|
|
if (!filePaths.isEmpty())
|
|
addFilesToPlaylist(filePaths);
|
|
}
|
|
else if (selectedAction == addEntryAction.data())
|
|
addFilesToPlaylist(QStringList());
|
|
else if (selectedAction == addFolderAction.data())
|
|
{
|
|
QString dirPath = QFileDialog::getExistingDirectory(this,
|
|
msg_hash_to_str(MENU_ENUM_LABEL_VALUE_QT_SELECT_FOLDER),
|
|
QString(), QFileDialog::ShowDirsOnly);
|
|
|
|
if (!dirPath.isEmpty())
|
|
addFilesToPlaylist(QStringList() << dirPath);
|
|
}
|
|
else if (selectedAction == editAction.data())
|
|
{
|
|
QString selectedDatabase;
|
|
QString selectedName;
|
|
QString selectedPath;
|
|
QHash<QString, QString> selectedCore;
|
|
PlaylistEntryDialog *playlistDialog = playlistEntryDialog();
|
|
QString currentPlaylistPath = getCurrentPlaylistPath();
|
|
|
|
if (!playlistDialog->showDialog(currentEntry))
|
|
return;
|
|
|
|
selectedName = m_playlistEntryDialog->getSelectedName();
|
|
selectedPath = m_playlistEntryDialog->getSelectedPath();
|
|
selectedCore = m_playlistEntryDialog->getSelectedCore();
|
|
selectedDatabase = m_playlistEntryDialog->getSelectedDatabase();
|
|
|
|
if (selectedCore.isEmpty())
|
|
{
|
|
selectedCore["core_name"] = "DETECT";
|
|
selectedCore["core_path"] = "DETECT";
|
|
}
|
|
|
|
if (selectedDatabase.isEmpty())
|
|
selectedDatabase = QFileInfo(currentPlaylistPath).fileName().remove(".lpl");
|
|
|
|
currentEntry.label = selectedName;
|
|
currentEntry.path = selectedPath;
|
|
currentEntry.coreName = selectedCore.value("core_name");
|
|
currentEntry.corePath = selectedCore.value("core_path");
|
|
currentEntry.dbName = selectedDatabase;
|
|
|
|
if (!updateCurrentPlaylistEntry(currentEntry))
|
|
{
|
|
showMessageBox(msg_hash_to_str(
|
|
MENU_ENUM_LABEL_VALUE_QT_COULD_NOT_UPDATE_PLAYLIST_ENTRY),
|
|
MainWindow::MSGBOX_TYPE_ERROR, Qt::ApplicationModal, false);
|
|
return;
|
|
}
|
|
}
|
|
else if (selectedAction == deleteAction.data())
|
|
deleteCurrentPlaylistItem();
|
|
}
|
|
}
|
|
|
|
/* http://www.informit.com/articles/article.aspx?p=1613548 */
|
|
|
|
ThumbnailDelegate::ThumbnailDelegate(const GridItem &gridItem, QObject* parent) :
|
|
QStyledItemDelegate(parent), m_style(gridItem) { }
|
|
|
|
void ThumbnailDelegate::paint(QPainter* painter,
|
|
const QStyleOptionViewItem &option, const QModelIndex& index) const
|
|
{
|
|
QStyleOptionViewItem opt = option;
|
|
const QWidget *widget = opt.widget;
|
|
QStyle *style = widget->style();
|
|
int padding = m_style.padding;
|
|
int text_top_margin = 4; /* Qt seemingly reports -4 the actual line height. */
|
|
int text_height = painter->fontMetrics().height() + padding + padding;
|
|
QRect rect = opt.rect;
|
|
QRect adjusted = rect.adjusted(padding, padding, -padding,
|
|
-text_height + text_top_margin);
|
|
QPixmap pixmap = index.data(
|
|
PlaylistModel::THUMBNAIL).value<QPixmap>();
|
|
|
|
painter->save();
|
|
|
|
initStyleOption(&opt, index);
|
|
|
|
/* draw the background */
|
|
style->drawPrimitive(QStyle::PE_PanelItemViewItem, &opt, painter, widget);
|
|
|
|
/* draw the image */
|
|
if (!pixmap.isNull())
|
|
{
|
|
QPixmap pixmapScaled = pixmap.scaled(adjusted.size(),
|
|
Qt::KeepAspectRatio, Qt::SmoothTransformation);
|
|
style->drawItemPixmap(painter, adjusted,
|
|
Qt::AlignHCenter | m_style.thumbnailVerticalAlignmentFlag,
|
|
pixmapScaled);
|
|
}
|
|
|
|
/* draw the text */
|
|
if (!opt.text.isEmpty())
|
|
{
|
|
QPalette::ColorGroup cg = opt.state & QStyle::State_Enabled
|
|
? QPalette::Normal : QPalette::Disabled;
|
|
QRect textRect = QRect(rect.x() + padding,
|
|
rect.y() + adjusted.height() - text_top_margin + padding,
|
|
rect.width() - 2 * padding, text_height);
|
|
QString elidedText = painter->fontMetrics().elidedText(opt.text,
|
|
opt.textElideMode, textRect.width(), Qt::TextShowMnemonic);
|
|
|
|
if (cg == QPalette::Normal && !(opt.state & QStyle::State_Active))
|
|
cg = QPalette::Inactive;
|
|
|
|
if (opt.state & QStyle::State_Selected)
|
|
painter->setPen(opt.palette.color(cg, QPalette::HighlightedText));
|
|
else
|
|
painter->setPen(opt.palette.color(cg, QPalette::Text));
|
|
|
|
painter->setFont(opt.font);
|
|
painter->drawText(textRect, Qt::AlignCenter, elidedText);
|
|
}
|
|
|
|
painter->restore();
|
|
}
|
|
|
|
GridView::GridView(QWidget *parent) :
|
|
QAbstractItemView(parent), m_idealHeight(0), m_hashIsDirty(false)
|
|
{
|
|
setFocusPolicy(Qt::WheelFocus);
|
|
horizontalScrollBar()->setRange(0, 0);
|
|
verticalScrollBar()->setRange(0, 0);
|
|
}
|
|
|
|
void GridView::setModel(QAbstractItemModel *newModel)
|
|
{
|
|
if (model())
|
|
disconnect(model(), SIGNAL(rowsRemoved(QModelIndex, int, int)),
|
|
this, SLOT(rowsRemoved(QModelIndex, int, int)));
|
|
|
|
QAbstractItemView::setModel(newModel);
|
|
|
|
connect(newModel, SIGNAL(rowsRemoved(QModelIndex, int, int)),
|
|
this, SLOT(rowsRemoved(QModelIndex, int, int)));
|
|
|
|
m_hashIsDirty = true;
|
|
}
|
|
|
|
void GridView::setviewMode(ViewMode mode)
|
|
{
|
|
m_viewMode = mode;
|
|
}
|
|
|
|
void GridView::calculateRectsIfNecessary() const
|
|
{
|
|
int x, y;
|
|
int row, nextX;
|
|
if (!m_hashIsDirty)
|
|
return;
|
|
|
|
x = m_spacing;
|
|
y = m_spacing;
|
|
const int maxWidth = viewport()->width();
|
|
|
|
if (m_size + m_spacing * 2 > maxWidth)
|
|
{
|
|
m_rectForRow[0] = QRectF(x, y, m_size, m_size);
|
|
|
|
for (row = 1; row < model()->rowCount(); ++row)
|
|
{
|
|
y += m_size + m_spacing;
|
|
m_rectForRow[row] = QRectF(x, y, m_size, m_size);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
switch (m_viewMode)
|
|
{
|
|
case Anchored:
|
|
{
|
|
int columns = (maxWidth - m_spacing) / (m_size + m_spacing);
|
|
if (columns > 0)
|
|
{
|
|
const int actualSpacing = (maxWidth - m_spacing -
|
|
m_size - (columns - 1) * m_size) / columns;
|
|
for (row = 0; row < model()->rowCount(); ++row)
|
|
{
|
|
nextX = x + m_size + actualSpacing;
|
|
if (nextX > maxWidth)
|
|
{
|
|
x = m_spacing;
|
|
y += m_size + m_spacing;
|
|
nextX = x + m_size + actualSpacing;
|
|
}
|
|
m_rectForRow[row] = QRectF(x, y, m_size, m_size);
|
|
x = nextX;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
case Centered:
|
|
{
|
|
int columns = (maxWidth - m_spacing) / (m_size + m_spacing);
|
|
if (columns > 0)
|
|
{
|
|
const int actualSpacing = (maxWidth - columns * m_size)
|
|
/ (columns + 1);
|
|
x = actualSpacing;
|
|
|
|
for (row = 0; row < model()->rowCount(); ++row)
|
|
{
|
|
nextX = x + m_size + actualSpacing;
|
|
if (nextX > maxWidth)
|
|
{
|
|
x = actualSpacing;
|
|
y += m_size + m_spacing;
|
|
nextX = x + m_size + actualSpacing;
|
|
}
|
|
m_rectForRow[row] = QRectF(x, y, m_size, m_size);
|
|
x = nextX;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
case Simple:
|
|
for (row = 0; row < model()->rowCount(); ++row)
|
|
{
|
|
nextX = x + m_size + m_spacing;
|
|
if (nextX > maxWidth)
|
|
{
|
|
x = m_spacing;
|
|
y += m_size + m_spacing;
|
|
nextX = x + m_size + m_spacing;
|
|
}
|
|
m_rectForRow[row] = QRectF(x, y, m_size, m_size);
|
|
x = nextX;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
m_idealHeight = y + m_size + m_spacing;
|
|
m_hashIsDirty = false;
|
|
viewport()->update();
|
|
}
|
|
|
|
QRect GridView::visualRect(const QModelIndex &index) const
|
|
{
|
|
QRect rect;
|
|
if (index.isValid())
|
|
rect = viewportRectForRow(index.row()).toRect();
|
|
return rect;
|
|
}
|
|
|
|
QRectF GridView::viewportRectForRow(int row) const
|
|
{
|
|
QRectF rect;
|
|
calculateRectsIfNecessary();
|
|
rect = m_rectForRow.value(row).toRect();
|
|
if (!rect.isValid())
|
|
return rect;
|
|
return QRectF(
|
|
rect.x() - horizontalScrollBar()->value(),
|
|
rect.y() - verticalScrollBar()->value(),
|
|
rect.width(),
|
|
rect.height());
|
|
}
|
|
|
|
void GridView::scrollTo(const QModelIndex &index, QAbstractItemView::ScrollHint)
|
|
{
|
|
QRect viewRect = viewport()->rect();
|
|
QRect itemRect = visualRect(index);
|
|
|
|
if (itemRect.left() < viewRect.left())
|
|
horizontalScrollBar()->setValue(horizontalScrollBar()->value()
|
|
+ itemRect.left() - viewRect.left());
|
|
else if (itemRect.right() > viewRect.right())
|
|
horizontalScrollBar()->setValue(horizontalScrollBar()->value()
|
|
+ ((itemRect.right() - viewRect.right()) < (itemRect.left() - viewRect.left()) ? (itemRect.right() - viewRect.right()) : (itemRect.left() - viewRect.left())));
|
|
if (itemRect.top() < viewRect.top())
|
|
verticalScrollBar()->setValue(verticalScrollBar()->value()
|
|
+ itemRect.top() - viewRect.top());
|
|
else if (itemRect.bottom() > viewRect.bottom())
|
|
verticalScrollBar()->setValue(verticalScrollBar()->value()
|
|
+ ((itemRect.bottom() - viewRect.bottom()) < (itemRect.top() - viewRect.top()) ? (itemRect.bottom() - viewRect.bottom()) : (itemRect.top() - viewRect.top())));
|
|
viewport()->update();
|
|
}
|
|
|
|
/* TODO: Make this more efficient by changing m_rectForRow for
|
|
* another data structure. Look at how Qt's own views do it. */
|
|
QModelIndex GridView::indexAt(const QPoint &point_) const
|
|
{
|
|
QPoint point(point_);
|
|
QHash<int, QRectF>::const_iterator i;
|
|
point.rx() += horizontalScrollBar()->value();
|
|
point.ry() += verticalScrollBar()->value();
|
|
|
|
calculateRectsIfNecessary();
|
|
|
|
i = m_rectForRow.constBegin();
|
|
|
|
while (i != m_rectForRow.constEnd())
|
|
{
|
|
if (i.value().contains(point))
|
|
return model()->index(i.key(), 0, rootIndex());
|
|
i++;
|
|
}
|
|
return QModelIndex();
|
|
}
|
|
|
|
void GridView::dataChanged(const QModelIndex &topLeft,
|
|
const QModelIndex &bottomRight, const QVector<int> &roles)
|
|
{
|
|
m_hashIsDirty = true;
|
|
QAbstractItemView::dataChanged(topLeft, bottomRight);
|
|
}
|
|
|
|
void GridView::refresh()
|
|
{
|
|
m_hashIsDirty = true;
|
|
calculateRectsIfNecessary();
|
|
updateGeometries();
|
|
}
|
|
|
|
void GridView::rowsInserted(const QModelIndex &parent, int start, int end)
|
|
{
|
|
QAbstractItemView::rowsInserted(parent, start, end);
|
|
refresh();
|
|
}
|
|
|
|
void GridView::rowsRemoved(const QModelIndex &parent, int start, int end)
|
|
{
|
|
refresh();
|
|
}
|
|
|
|
void GridView::setGridSize(const int newSize)
|
|
{
|
|
if (newSize != m_size)
|
|
{
|
|
m_size = newSize;
|
|
refresh();
|
|
}
|
|
}
|
|
|
|
/* The item rectangles are cached and only recomputed when the hash is
|
|
* marked dirty. resizeEvent() does that, but a hidden widget receives
|
|
* no resize events: the desktop menu is hidden while content runs, and
|
|
* anything that changes the viewport width in the meantime - window
|
|
* geometry, dock layout, a scroll bar appearing - leaves the cached
|
|
* rectangles describing a width the viewport no longer has. They are
|
|
* then reused on the next paint, and the grid stays misaligned until
|
|
* something else happens to call refresh().
|
|
*
|
|
* Recompute whenever the view becomes visible again, so the layout is
|
|
* always derived from the viewport it is actually being drawn into. */
|
|
void GridView::showEvent(QShowEvent *event)
|
|
{
|
|
QAbstractItemView::showEvent(event);
|
|
refresh();
|
|
}
|
|
|
|
void GridView::resizeEvent(QResizeEvent*)
|
|
{
|
|
refresh();
|
|
}
|
|
|
|
void GridView::reset()
|
|
{
|
|
m_visibleIndexes.clear();
|
|
QAbstractItemView::reset();
|
|
refresh();
|
|
}
|
|
|
|
QModelIndex GridView::moveCursor(QAbstractItemView::CursorAction cursorAction,
|
|
Qt::KeyboardModifiers)
|
|
{
|
|
QModelIndex index = currentIndex();
|
|
if (index.isValid())
|
|
{
|
|
if ( (cursorAction == MoveLeft && index.row() > 0)
|
|
|| (cursorAction == MoveRight && index.row() + 1 < model()->rowCount()))
|
|
{
|
|
const int offset = (cursorAction == MoveLeft ? -1 : 1);
|
|
index = model()->index(index.row() + offset, index.column(), index.parent());
|
|
}
|
|
else if ((cursorAction == MoveUp && index.row() > 0)
|
|
|| (cursorAction == MoveDown && index.row() + 1 < model()->rowCount()))
|
|
{
|
|
const int offset = ((m_size + m_spacing) * (cursorAction == MoveUp ? -1 : 1));
|
|
QRect rect = viewportRectForRow(index.row()).toRect();
|
|
QPoint point(rect.center().x(), rect.center().y() + offset);
|
|
index = indexAt(point);
|
|
}
|
|
}
|
|
return index;
|
|
}
|
|
|
|
int GridView::horizontalOffset() const
|
|
{
|
|
return horizontalScrollBar()->value();
|
|
}
|
|
|
|
int GridView::verticalOffset() const
|
|
{
|
|
return verticalScrollBar()->value();
|
|
}
|
|
|
|
void GridView::scrollContentsBy(int dx, int dy)
|
|
{
|
|
scrollDirtyRegion(dx, dy);
|
|
viewport()->scroll(dx, dy);
|
|
emit(visibleItemsChangedMaybe());
|
|
}
|
|
|
|
/* TODO: Maybe add a way to get the previous/next visible indexes. */
|
|
QVector<QModelIndex> GridView::visibleIndexes() const {
|
|
return m_visibleIndexes;
|
|
}
|
|
|
|
void GridView::setSelection(const QRect &rect,
|
|
QFlags<QItemSelectionModel::SelectionFlag> flags)
|
|
{
|
|
QRect rectangle;
|
|
QHash<int, QRectF>::const_iterator i;
|
|
int firstRow = model()->rowCount();
|
|
int lastRow = -1;
|
|
|
|
calculateRectsIfNecessary();
|
|
|
|
rectangle = rect.translated(horizontalScrollBar()->value(),
|
|
verticalScrollBar()->value()).normalized();
|
|
|
|
i = m_rectForRow.constBegin();
|
|
|
|
while (i != m_rectForRow.constEnd())
|
|
{
|
|
if (i.value().intersects(rectangle))
|
|
{
|
|
firstRow = firstRow < i.key() ? firstRow : i.key();
|
|
lastRow = lastRow > i.key() ? lastRow : i.key();
|
|
}
|
|
i++;
|
|
}
|
|
if (firstRow != model()->rowCount() && lastRow != -1)
|
|
{
|
|
QItemSelection selection(model()->index(
|
|
firstRow, 0, rootIndex()),
|
|
model()->index(lastRow, 0, rootIndex()));
|
|
selectionModel()->select(selection, flags);
|
|
}
|
|
else
|
|
{
|
|
QModelIndex invalid;
|
|
QItemSelection selection(invalid, invalid);
|
|
selectionModel()->select(selection, flags);
|
|
}
|
|
}
|
|
|
|
QRegion GridView::visualRegionForSelection(const QItemSelection &selection) const
|
|
{
|
|
int i;
|
|
QRegion region;
|
|
QItemSelectionRange range;
|
|
|
|
for (i = 0; i < selection.size(); i++)
|
|
{
|
|
range = selection.at(i);
|
|
int row;
|
|
for (row = range.top(); row <= range.bottom(); row++)
|
|
{
|
|
int column;
|
|
for (column = range.left(); column < range.right(); column++)
|
|
{
|
|
QModelIndex index = model()->index(row, column, rootIndex());
|
|
region += visualRect(index);
|
|
}
|
|
}
|
|
}
|
|
|
|
return region;
|
|
}
|
|
|
|
void GridView::paintEvent(QPaintEvent*)
|
|
{
|
|
QPainter painter(viewport());
|
|
int row;
|
|
|
|
painter.setRenderHints(QPainter::Antialiasing | QPainter::TextAntialiasing);
|
|
m_visibleIndexes.clear();
|
|
|
|
for (row = 0; row < model()->rowCount(rootIndex()); ++row)
|
|
{
|
|
QModelIndex index = model()->index(row, 0, rootIndex());
|
|
QRectF rect = viewportRectForRow(row);
|
|
#if (QT_VERSION > QT_VERSION_CHECK(6, 0, 0))
|
|
QStyleOptionViewItem option;
|
|
initViewItemOption(&option);
|
|
#else
|
|
QStyleOptionViewItem option = viewOptions();
|
|
#endif
|
|
|
|
if ( !rect.isValid()
|
|
|| rect.bottom() < 0
|
|
|| rect.y() > viewport()->height())
|
|
continue;
|
|
|
|
m_visibleIndexes.append(index);
|
|
option.rect = rect.toRect();
|
|
|
|
if (selectionModel()->isSelected(index))
|
|
option.state |= QStyle::State_Selected;
|
|
|
|
if (currentIndex() == index)
|
|
option.state |= QStyle::State_HasFocus;
|
|
|
|
itemDelegate()->paint(&painter, option, index);
|
|
}
|
|
}
|
|
|
|
void GridView::updateGeometries()
|
|
{
|
|
const int RowHeight = m_size + m_spacing;
|
|
|
|
QAbstractItemView::updateGeometries();
|
|
|
|
verticalScrollBar()->setSingleStep(RowHeight);
|
|
verticalScrollBar()->setPageStep(viewport()->height());
|
|
verticalScrollBar()->setRange(0, ((0) > (m_idealHeight - viewport()->height()) ? (0) : (m_idealHeight - viewport()->height())));
|
|
|
|
horizontalScrollBar()->setPageStep(viewport()->width());
|
|
horizontalScrollBar()->setRange(0, ((0) > (RowHeight - viewport()->width()) ? (0) : (RowHeight - viewport()->width())));
|
|
|
|
emit(visibleItemsChangedMaybe());
|
|
}
|
|
|
|
QString GridView::getLayout() const
|
|
{
|
|
switch (m_viewMode)
|
|
{
|
|
case Simple:
|
|
return QString("simple");
|
|
case Anchored:
|
|
return QString("anchored");
|
|
case Centered:
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return QString("centered");
|
|
}
|
|
|
|
void GridView::setLayout(QString layout)
|
|
{
|
|
if (layout == QLatin1String("anchored"))
|
|
m_viewMode = Anchored;
|
|
else if (layout == QLatin1String("centered"))
|
|
m_viewMode = Centered;
|
|
else if (layout == QLatin1String("fixed"))
|
|
m_viewMode = Simple;
|
|
}
|
|
|
|
int GridView::getSpacing() const
|
|
{
|
|
return m_spacing;
|
|
}
|
|
|
|
void GridView::setSpacing(const int spacing) { m_spacing = spacing; }
|
|
|
|
GridItem::GridItem(QWidget* parent) : QWidget(parent)
|
|
, thumbnailVerticalAlignmentFlag(Qt::AlignBottom)
|
|
, padding(11) { }
|
|
|
|
int GridItem::getPadding() const { return padding; }
|
|
void GridItem::setPadding(const int value) { padding = value; }
|
|
|
|
QString GridItem::getThumbnailVerticalAlign() const
|
|
{
|
|
switch (thumbnailVerticalAlignmentFlag)
|
|
{
|
|
case Qt::AlignTop:
|
|
return QString("top");
|
|
case Qt::AlignVCenter:
|
|
return QString("center");
|
|
case Qt::AlignBottom:
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return QString("bottom");
|
|
}
|
|
|
|
void GridItem::setThumbnailVerticalAlign(const QString valign)
|
|
{
|
|
if (valign == QLatin1String("top"))
|
|
thumbnailVerticalAlignmentFlag = Qt::AlignTop;
|
|
else if (valign == QLatin1String("center"))
|
|
thumbnailVerticalAlignmentFlag = Qt::AlignVCenter;
|
|
else if (valign == QLatin1String("bottom"))
|
|
thumbnailVerticalAlignmentFlag = Qt::AlignBottom;
|
|
}
|
|
|
|
#if defined(_MSC_VER) && !defined(_XBOX) && (_MSC_VER >= 1500 && _MSC_VER < 1900)
|
|
/* https://support.microsoft.com/en-us/kb/980263 */
|
|
#pragma execution_character_set("utf-8")
|
|
#endif
|
|
|
|
static inline bool comp_string_lower(const QString &lhs, const QString &rhs)
|
|
{
|
|
return lhs.toLower() < rhs.toLower();
|
|
}
|
|
|
|
static inline bool comp_hash_ui_display_name_key_lower(const QHash<QString,
|
|
QString> &lhs, const QHash<QString, QString> &rhs)
|
|
{
|
|
return lhs.value("ui_display_name").toLower()
|
|
< rhs.value("ui_display_name").toLower();
|
|
}
|
|
|
|
PlaylistEntryDialog::PlaylistEntryDialog(MainWindow *mainwindow, QWidget *parent) :
|
|
QDialog(parent)
|
|
,m_mainwindow(mainwindow)
|
|
,m_nameLineEdit(new QLineEdit(this))
|
|
,m_pathLineEdit(new QLineEdit(this))
|
|
,m_extensionsLineEdit(new QLineEdit(this))
|
|
,m_coreComboBox(new QComboBox(this))
|
|
,m_databaseComboBox(new QComboBox(this))
|
|
,m_extensionArchiveCheckBox(new QCheckBox(
|
|
msg_hash_to_str(
|
|
MENU_ENUM_LABEL_VALUE_QT_PLAYLIST_ENTRY_FILTER_INSIDE_ARCHIVES),
|
|
this))
|
|
{
|
|
QFormLayout *form = new QFormLayout();
|
|
QDialogButtonBox *buttonBox = new QDialogButtonBox(
|
|
QDialogButtonBox::Ok | QDialogButtonBox::Cancel);
|
|
QVBoxLayout *databaseVBoxLayout = new QVBoxLayout();
|
|
QHBoxLayout *pathHBoxLayout = new QHBoxLayout();
|
|
QHBoxLayout *extensionHBoxLayout = new QHBoxLayout();
|
|
QLabel *databaseLabel = new QLabel(msg_hash_to_str(
|
|
MENU_ENUM_LABEL_VALUE_QT_FOR_THUMBNAILS), this);
|
|
QToolButton *pathPushButton = new QToolButton(this);
|
|
|
|
pathPushButton->setText(QString("..."));
|
|
|
|
pathHBoxLayout->addWidget(m_pathLineEdit);
|
|
pathHBoxLayout->addWidget(pathPushButton);
|
|
|
|
databaseVBoxLayout->addWidget(m_databaseComboBox);
|
|
databaseVBoxLayout->addWidget(databaseLabel);
|
|
|
|
extensionHBoxLayout->addWidget(m_extensionsLineEdit);
|
|
extensionHBoxLayout->addWidget(m_extensionArchiveCheckBox);
|
|
|
|
m_extensionsLineEdit->setPlaceholderText(msg_hash_to_str(
|
|
MENU_ENUM_LABEL_VALUE_QT_PLAYLIST_ENTRY_EXTENSIONS_PLACEHOLDER));
|
|
|
|
/* Ensure placeholder text is completely visible. */
|
|
m_extensionsLineEdit->setMinimumWidth(QFontMetrics(
|
|
m_extensionsLineEdit->font()).boundingRect(
|
|
m_extensionsLineEdit->placeholderText()).width()
|
|
+ m_extensionsLineEdit->frameSize().width());
|
|
|
|
setWindowTitle(msg_hash_to_str(MENU_ENUM_LABEL_VALUE_QT_PLAYLIST_ENTRY));
|
|
|
|
form->setFormAlignment(Qt::AlignCenter);
|
|
form->setLabelAlignment(Qt::AlignCenter);
|
|
|
|
setLayout(new QVBoxLayout(this));
|
|
|
|
connect(buttonBox, SIGNAL(accepted()), this, SLOT(accept()));
|
|
connect(buttonBox, SIGNAL(rejected()), this, SLOT(reject()));
|
|
|
|
connect(this, SIGNAL(accepted()), this, SLOT(onAccepted()));
|
|
connect(this, SIGNAL(rejected()), this, SLOT(onRejected()));
|
|
|
|
form->addRow(msg_hash_to_str(
|
|
MENU_ENUM_LABEL_VALUE_QT_PLAYLIST_ENTRY_NAME), m_nameLineEdit);
|
|
form->addRow(msg_hash_to_str(
|
|
MENU_ENUM_LABEL_VALUE_QT_PLAYLIST_ENTRY_PATH), pathHBoxLayout);
|
|
form->addRow(msg_hash_to_str(
|
|
MENU_ENUM_LABEL_VALUE_QT_PLAYLIST_ENTRY_CORE), m_coreComboBox);
|
|
form->addRow(msg_hash_to_str(
|
|
MENU_ENUM_LABEL_VALUE_QT_PLAYLIST_ENTRY_DATABASE), databaseVBoxLayout);
|
|
form->addRow(msg_hash_to_str(
|
|
MENU_ENUM_LABEL_VALUE_QT_PLAYLIST_ENTRY_EXTENSIONS), extensionHBoxLayout);
|
|
|
|
qobject_cast<QVBoxLayout*>(layout())->addLayout(form);
|
|
layout()->addItem(new QSpacerItem(20, 20, QSizePolicy::Minimum, QSizePolicy::Expanding));
|
|
layout()->addWidget(buttonBox);
|
|
|
|
connect(pathPushButton, SIGNAL(clicked()), this, SLOT(onPathClicked()));
|
|
}
|
|
|
|
bool PlaylistEntryDialog::filterInArchive()
|
|
{
|
|
return m_extensionArchiveCheckBox->isChecked();
|
|
}
|
|
|
|
void PlaylistEntryDialog::onPathClicked()
|
|
{
|
|
QString filePath = QFileDialog::getOpenFileName(this);
|
|
|
|
if (filePath.isEmpty())
|
|
return;
|
|
|
|
m_pathLineEdit->setText(filePath);
|
|
}
|
|
|
|
void PlaylistEntryDialog::loadPlaylistOptions()
|
|
{
|
|
unsigned i, j;
|
|
core_info_list_t *core_info_list = NULL;
|
|
|
|
m_nameLineEdit->clear();
|
|
m_pathLineEdit->clear();
|
|
m_coreComboBox->clear();
|
|
m_databaseComboBox->clear();
|
|
|
|
m_coreComboBox->addItem(
|
|
msg_hash_to_str(MENU_ENUM_LABEL_VALUE_QT_CORE_SELECTION_ASK));
|
|
m_databaseComboBox->addItem(
|
|
QString("<")
|
|
+ msg_hash_to_str(MENU_ENUM_LABEL_VALUE_NOT_AVAILABLE)
|
|
+ ">",
|
|
QFileInfo(m_mainwindow->getCurrentPlaylistPath()).fileName().remove(".lpl"));
|
|
|
|
core_info_get_list(&core_info_list);
|
|
|
|
if (core_info_list && core_info_list->count > 0)
|
|
{
|
|
QVector<QHash<QString, QString> > allCores;
|
|
QStringList allDatabases;
|
|
|
|
for (i = 0; i < core_info_list->count; i++)
|
|
{
|
|
QString ui_display_name;
|
|
QHash<QString, QString> hash;
|
|
const core_info_t *core = &core_info_list->list[i];
|
|
QStringList databases = QString(core->databases).split('|');
|
|
|
|
hash["core_name"] = core->core_name;
|
|
hash["core_display_name"] = core->display_name;
|
|
hash["core_path"] = core->path;
|
|
hash["core_databases"] = core->databases;
|
|
|
|
ui_display_name = hash.value("core_name");
|
|
|
|
if (ui_display_name.isEmpty())
|
|
ui_display_name = hash.value("core_display_name");
|
|
if (ui_display_name.isEmpty())
|
|
ui_display_name = QFileInfo(
|
|
hash.value("core_path")).fileName();
|
|
|
|
if (ui_display_name.isEmpty())
|
|
continue;
|
|
|
|
hash["ui_display_name"] = ui_display_name;
|
|
|
|
for (j = 0; static_cast<int>(j) < databases.count(); j++)
|
|
{
|
|
QString database = databases.at(static_cast<int>(j));
|
|
|
|
if (database.isEmpty())
|
|
continue;
|
|
|
|
if (!allDatabases.contains(database))
|
|
allDatabases.append(database);
|
|
}
|
|
|
|
if (!allCores.contains(hash))
|
|
allCores.append(hash);
|
|
}
|
|
|
|
std::sort(allCores.begin(), allCores.end(), comp_hash_ui_display_name_key_lower);
|
|
std::sort(allDatabases.begin(), allDatabases.end(), comp_string_lower);
|
|
|
|
for (j = 0; static_cast<int>(j) < allCores.count(); j++)
|
|
{
|
|
const QHash<QString, QString> &hash = allCores.at(static_cast<int>(j));
|
|
|
|
m_coreComboBox->addItem(hash.value("ui_display_name"), QVariant::fromValue(hash));
|
|
}
|
|
|
|
for (j = 0; static_cast<int>(j) < allDatabases.count(); j++)
|
|
{
|
|
QString database = allDatabases.at(static_cast<int>(j));
|
|
m_databaseComboBox->addItem(database, database);
|
|
}
|
|
}
|
|
}
|
|
|
|
bool PlaylistEntryDialog::nameFieldEnabled()
|
|
{
|
|
return m_nameLineEdit->isEnabled();
|
|
}
|
|
|
|
void PlaylistEntryDialog::setEntryValues(
|
|
const PlaylistEntry &entry)
|
|
{
|
|
QString db;
|
|
const QString &coreName = entry.coreName;
|
|
int foundDB = 0;
|
|
int i = 0;
|
|
|
|
loadPlaylistOptions();
|
|
|
|
if (entry.path.isEmpty())
|
|
{
|
|
m_nameLineEdit->setText(
|
|
msg_hash_to_str(MENU_ENUM_LABEL_VALUE_QT_FIELD_MULTIPLE));
|
|
m_pathLineEdit->setText(
|
|
msg_hash_to_str(MENU_ENUM_LABEL_VALUE_QT_FIELD_MULTIPLE));
|
|
m_nameLineEdit->setEnabled(false);
|
|
m_pathLineEdit->setEnabled(false);
|
|
}
|
|
else
|
|
{
|
|
m_nameLineEdit->setText(entry.label);
|
|
m_pathLineEdit->setText(entry.path);
|
|
m_nameLineEdit->setEnabled(true);
|
|
m_pathLineEdit->setEnabled(true);
|
|
}
|
|
|
|
for (i = 0; i < m_coreComboBox->count(); i++)
|
|
{
|
|
const QHash<QString, QString> hash =
|
|
m_coreComboBox->itemData(i,
|
|
Qt::UserRole).value<QHash<QString, QString> >();
|
|
|
|
if (hash.isEmpty() || coreName.isEmpty())
|
|
continue;
|
|
|
|
if (hash.value("core_name") == coreName)
|
|
{
|
|
m_coreComboBox->setCurrentIndex(i);
|
|
break;
|
|
}
|
|
}
|
|
|
|
db = entry.dbName;
|
|
|
|
if (!db.isEmpty())
|
|
{
|
|
foundDB = m_databaseComboBox->findText(db);
|
|
|
|
if (foundDB >= 0)
|
|
m_databaseComboBox->setCurrentIndex(foundDB);
|
|
}
|
|
}
|
|
|
|
const QHash<QString, QString> PlaylistEntryDialog::getSelectedCore()
|
|
{
|
|
return m_coreComboBox->currentData(
|
|
Qt::UserRole).value<QHash<QString, QString> >();
|
|
}
|
|
|
|
const QString PlaylistEntryDialog::getSelectedName()
|
|
{
|
|
return m_nameLineEdit->text();
|
|
}
|
|
|
|
const QString PlaylistEntryDialog::getSelectedPath()
|
|
{
|
|
return m_pathLineEdit->text();
|
|
}
|
|
|
|
const QString PlaylistEntryDialog::getSelectedDatabase()
|
|
{
|
|
return m_databaseComboBox->currentData(Qt::UserRole).toString();
|
|
}
|
|
|
|
const QStringList PlaylistEntryDialog::getSelectedExtensions()
|
|
{
|
|
QStringList list;
|
|
QString text = m_extensionsLineEdit->text();
|
|
|
|
/* Otherwise it would create a QStringList with a single blank entry... */
|
|
if (!text.isEmpty())
|
|
list = text.split(' ');
|
|
return list;
|
|
}
|
|
|
|
void PlaylistEntryDialog::onAccepted() { }
|
|
void PlaylistEntryDialog::onRejected() { }
|
|
void PlaylistEntryDialog::hideDialog() { reject(); }
|
|
|
|
bool PlaylistEntryDialog::showDialog(const PlaylistEntry &entry)
|
|
{
|
|
loadPlaylistOptions();
|
|
setEntryValues(entry);
|
|
return (exec() == QDialog::Accepted);
|
|
}
|
|
|
|
ShortcutsDialog::ShortcutsDialog(QWidget *parent) :
|
|
QDialog(parent)
|
|
,m_table(new QTableWidget(0, 2, this))
|
|
,m_help(new QLabel(this))
|
|
,m_edit(new QLineEdit(this))
|
|
{
|
|
QHBoxLayout *row = new QHBoxLayout();
|
|
QPushButton *apply = new QPushButton("Apply", this);
|
|
QPushButton *close = new QPushButton("Close", this);
|
|
QVBoxLayout *layout = new QVBoxLayout();
|
|
QStringList headers;
|
|
|
|
setWindowTitle(QString(msg_hash_to_str(
|
|
MENU_ENUM_LABEL_VALUE_QT_MENU_VIEW_CONTROLLER_SHORTCUTS)).remove('&'));
|
|
headers << "Shortcut" << "As written";
|
|
m_table->setHorizontalHeaderLabels(headers);
|
|
m_table->setSelectionBehavior(QAbstractItemView::SelectRows);
|
|
m_table->setSelectionMode(QAbstractItemView::SingleSelection);
|
|
m_table->setEditTriggers(QAbstractItemView::NoEditTriggers);
|
|
m_table->horizontalHeader()->setStretchLastSection(true);
|
|
m_table->verticalHeader()->hide();
|
|
m_help->setWordWrap(true);
|
|
apply->setDefault(true);
|
|
|
|
row->addWidget(m_edit, 1);
|
|
row->addWidget(apply);
|
|
row->addWidget(close);
|
|
layout->addWidget(m_table, 1);
|
|
layout->addWidget(m_help);
|
|
layout->addLayout(row);
|
|
setLayout(layout);
|
|
resize(640, 420);
|
|
|
|
connect(m_table, SIGNAL(itemSelectionChanged()), this, SLOT(onRowChanged()));
|
|
connect(m_edit, SIGNAL(returnPressed()), this, SLOT(onApply()));
|
|
connect(apply, SIGNAL(clicked()), this, SLOT(onApply()));
|
|
connect(close, SIGNAL(clicked()), this, SLOT(hide()));
|
|
}
|
|
|
|
void ShortcutsDialog::fill(int keep)
|
|
{
|
|
companion_core_t *core = ui_companion_qt_core();
|
|
size_t i, n = companion_core_shortcut_count(core);
|
|
char label[64], text[512];
|
|
|
|
m_table->blockSignals(true);
|
|
m_table->setRowCount((int)n);
|
|
for (i = 0; i < n; i++)
|
|
{
|
|
m_table->setItem((int)i, 0, new QTableWidgetItem(QString::fromUtf8(
|
|
companion_core_shortcut_label(core, i, label, sizeof(label)))));
|
|
m_table->setItem((int)i, 1, new QTableWidgetItem(QString::fromUtf8(
|
|
companion_core_shortcut_get(core, i, text, sizeof(text)))));
|
|
}
|
|
m_table->blockSignals(false);
|
|
if (keep >= 0 && keep < (int)n)
|
|
m_table->selectRow(keep);
|
|
onRowChanged();
|
|
}
|
|
|
|
void ShortcutsDialog::onRowChanged()
|
|
{
|
|
companion_core_t *core = ui_companion_qt_core();
|
|
int row = m_table->currentRow();
|
|
char text[512], help[2048];
|
|
if (row < 0)
|
|
return;
|
|
m_edit->setText(QString::fromUtf8(companion_core_shortcut_get(core,
|
|
(size_t)row, text, sizeof(text))));
|
|
m_help->setText(QString::fromUtf8(companion_core_shortcut_help(core,
|
|
companion_core_shortcut_is_macro(core, (size_t)row),
|
|
help, sizeof(help))));
|
|
}
|
|
|
|
void ShortcutsDialog::onApply()
|
|
{
|
|
int row = m_table->currentRow();
|
|
QByteArray in = m_edit->text().toUtf8();
|
|
if (row < 0 || !companion_core_shortcut_set(ui_companion_qt_core(),
|
|
(size_t)row, in.constData()))
|
|
{
|
|
QApplication::beep();
|
|
return;
|
|
}
|
|
fill(row);
|
|
}
|
|
|
|
void ShortcutsDialog::showDialog()
|
|
{
|
|
fill(0);
|
|
show();
|
|
raise();
|
|
activateWindow();
|
|
}
|
|
|
|
CoreInfoDialog::CoreInfoDialog(MainWindow *mainwindow, QWidget *parent) :
|
|
QDialog(parent)
|
|
,m_formLayout(new QFormLayout())
|
|
,m_mainwindow(mainwindow)
|
|
{
|
|
QDialogButtonBox *buttonBox = new QDialogButtonBox(QDialogButtonBox::Ok);
|
|
|
|
connect(buttonBox, SIGNAL(accepted()), this, SLOT(accept()));
|
|
connect(buttonBox, SIGNAL(rejected()), this, SLOT(reject()));
|
|
|
|
setWindowTitle(msg_hash_to_str(MENU_ENUM_LABEL_VALUE_CORE_INFORMATION));
|
|
|
|
m_formLayout->setFormAlignment(Qt::AlignCenter);
|
|
m_formLayout->setLabelAlignment(Qt::AlignCenter);
|
|
|
|
setLayout(new QVBoxLayout());
|
|
|
|
qobject_cast<QVBoxLayout*>(layout())->addLayout(m_formLayout);
|
|
layout()->addItem(new QSpacerItem(20, 20, QSizePolicy::Minimum, QSizePolicy::Expanding));
|
|
layout()->addWidget(buttonBox);
|
|
}
|
|
|
|
void CoreInfoDialog::showCoreInfo()
|
|
{
|
|
int i, row;
|
|
int row_count = m_formLayout->rowCount();
|
|
QVector<QHash<QString, QString> > info_list
|
|
= m_mainwindow->getCoreInfo();
|
|
|
|
if (row_count > 0)
|
|
{
|
|
for (row = 0; row < row_count; row++)
|
|
{
|
|
#if (QT_VERSION >= QT_VERSION_CHECK(5, 8, 0))
|
|
/* removeRow() and takeRow() was only added in 5.8! */
|
|
m_formLayout->removeRow(0);
|
|
#else
|
|
/* something is buggy here...
|
|
* sometimes items appear duplicated, and other times not */
|
|
QLayoutItem *item = m_formLayout->itemAt(0);
|
|
QWidget *w = NULL;
|
|
|
|
if (item)
|
|
{
|
|
w = item->widget();
|
|
|
|
if (w)
|
|
{
|
|
QWidget *label = m_formLayout->labelForField(w);
|
|
|
|
if (label)
|
|
delete label;
|
|
|
|
m_formLayout->removeWidget(w);
|
|
|
|
delete w;
|
|
}
|
|
}
|
|
#endif
|
|
}
|
|
}
|
|
|
|
if (info_list.count() == 0)
|
|
return;
|
|
|
|
for (i = 0; i < info_list.count(); i++)
|
|
{
|
|
const QHash<QString, QString> &line = info_list.at(i);
|
|
QLabel *label = new QLabel(line.value("key"));
|
|
CoreInfoLabel *value = new CoreInfoLabel(line.value("value"));
|
|
QString labelStyle = line.value("label_style");
|
|
QString valueStyle = line.value("value_style");
|
|
|
|
if (!labelStyle.isEmpty())
|
|
label->setStyleSheet(labelStyle);
|
|
|
|
if (!valueStyle.isEmpty())
|
|
value->setStyleSheet(valueStyle);
|
|
|
|
m_formLayout->addRow(label, value);
|
|
}
|
|
|
|
show();
|
|
}
|
|
|
|
#ifdef HAVE_MENU
|
|
QPixmap getColorizedPixmap(const QPixmap& oldPixmap, const QColor& color)
|
|
{
|
|
QPixmap pixmap = oldPixmap;
|
|
QBitmap mask = pixmap.createMaskFromColor(Qt::transparent,
|
|
Qt::MaskInColor);
|
|
pixmap.fill(color);
|
|
pixmap.setMask(mask);
|
|
return pixmap;
|
|
}
|
|
|
|
QColor getLabelColor(const QString& objectName)
|
|
{
|
|
QLabel dummyColor;
|
|
dummyColor.setObjectName(objectName);
|
|
dummyColor.ensurePolished();
|
|
return dummyColor.palette().color(QPalette::WindowText);
|
|
}
|
|
|
|
/* stolen from Qt Creator */
|
|
class SmartScrollArea : public QScrollArea
|
|
{
|
|
public:
|
|
explicit SmartScrollArea(QWidget *parent) :
|
|
QScrollArea(parent)
|
|
{
|
|
setFrameStyle(QFrame::NoFrame | QFrame::Plain);
|
|
viewport()->setAutoFillBackground(false);
|
|
setWidgetResizable(true);
|
|
}
|
|
private:
|
|
void resizeEvent(QResizeEvent *event) final
|
|
{
|
|
QWidget *inner = widget();
|
|
|
|
if (inner)
|
|
{
|
|
int fw = frameWidth() * 2;
|
|
QSize innerSize = event->size() - QSize(fw, fw);
|
|
QSize innerSizeHint = inner->minimumSizeHint();
|
|
|
|
/* Widget wants to be bigger than available space */
|
|
if (innerSizeHint.height() > innerSize.height())
|
|
{
|
|
innerSize.setWidth(innerSize.width() - scrollBarWidth());
|
|
innerSize.setHeight(innerSizeHint.height());
|
|
}
|
|
inner->resize(innerSize);
|
|
}
|
|
QScrollArea::resizeEvent(event);
|
|
}
|
|
|
|
QSize minimumSizeHint() const final
|
|
{
|
|
static const int max_min_width = 250;
|
|
static const int max_min_height = 250;
|
|
QWidget *inner = widget();
|
|
|
|
if (inner)
|
|
{
|
|
int fw = frameWidth() * 2;
|
|
QSize minSize = inner->minimumSizeHint();
|
|
|
|
minSize += QSize(fw, fw);
|
|
minSize += QSize(scrollBarWidth(), 0);
|
|
minSize.setWidth(((minSize.width()) < (max_min_width) ? (minSize.width()) : (max_min_width)));
|
|
minSize.setHeight(((minSize.height()) < (max_min_height) ? (minSize.height()) : (max_min_height)));
|
|
return minSize;
|
|
}
|
|
return QSize(0, 0);
|
|
}
|
|
|
|
bool event(QEvent *event) final
|
|
{
|
|
if (event->type() == QEvent::LayoutRequest)
|
|
updateGeometry();
|
|
return QScrollArea::event(event);
|
|
}
|
|
|
|
int scrollBarWidth() const
|
|
{
|
|
SmartScrollArea *that = const_cast<SmartScrollArea *>(this);
|
|
QWidgetList list = that->scrollBarWidgets(Qt::AlignRight);
|
|
if (list.isEmpty())
|
|
return 0;
|
|
return list.first()->sizeHint().width();
|
|
}
|
|
};
|
|
|
|
class QtDisplayListCategory : public OptionsCategory
|
|
{
|
|
public:
|
|
QtDisplayListCategory(msg_hash_enums title, const QString &icon,
|
|
enum menu_displaylist_ctl_state state, QObject *parent = nullptr)
|
|
: OptionsCategory(parent), m_state(state)
|
|
{
|
|
setDisplayName(title);
|
|
setCategoryIcon(icon);
|
|
}
|
|
|
|
QVector<OptionsPage*> pages()
|
|
{
|
|
QVector<OptionsPage*> result;
|
|
result << new SimplePage(m_state, this);
|
|
return result;
|
|
}
|
|
|
|
private:
|
|
enum menu_displaylist_ctl_state m_state;
|
|
};
|
|
|
|
ViewOptionsDialog::ViewOptionsDialog(MainWindow *mainwindow,
|
|
QWidget *parent) :
|
|
QDialog(mainwindow)
|
|
,m_optionsList(new QListWidget(this))
|
|
,m_optionsStack(new QStackedLayout)
|
|
{
|
|
int width;
|
|
QGridLayout *layout = new QGridLayout(this);
|
|
QLabel *m_headerLabel = new QLabel(this);
|
|
/* Header label with large font and a bit of spacing
|
|
* (align with group boxes) */
|
|
QFont headerLabelFont = m_headerLabel->font();
|
|
const int pointSize = headerLabelFont.pointSize();
|
|
QHBoxLayout *headerHLayout = new QHBoxLayout;
|
|
const int leftMargin = QApplication::style()->pixelMetric(
|
|
QStyle::PM_LayoutLeftMargin);
|
|
|
|
#if (QT_VERSION > QT_VERSION_CHECK(6, 0, 0))
|
|
m_optionsStack->setContentsMargins(0, 0, 0, 0);
|
|
#else
|
|
m_optionsStack->setMargin(0);
|
|
#endif
|
|
|
|
headerLabelFont.setBold(true);
|
|
|
|
/* Paranoia: Should a font be set in pixels... */
|
|
if (pointSize > 0)
|
|
headerLabelFont.setPointSize(pointSize + 2);
|
|
|
|
m_headerLabel->setFont(headerLabelFont);
|
|
|
|
headerHLayout->addSpacerItem(new QSpacerItem(leftMargin, 0,
|
|
QSizePolicy::Fixed, QSizePolicy::Ignored));
|
|
headerHLayout->addWidget(m_headerLabel);
|
|
|
|
addCategory(new DriversCategory(this));
|
|
addCategory(new VideoCategory(this));
|
|
addCategory(new AudioCategory(this));
|
|
addCategory(new InputCategory(this));
|
|
addCategory(new LatencyCategory(this));
|
|
addCategory(new QtDisplayListCategory(
|
|
MENU_ENUM_LABEL_VALUE_ACCESSIBILITY_SETTINGS, "menu_accessibility",
|
|
DISPLAYLIST_ACCESSIBILITY_SETTINGS_LIST, this));
|
|
addCategory(new QtDisplayListCategory(
|
|
MENU_ENUM_LABEL_VALUE_POWER_MANAGEMENT_SETTINGS, "menu_power",
|
|
DISPLAYLIST_POWER_MANAGEMENT_SETTINGS_LIST, this));
|
|
addCategory(new CoreCategory(this));
|
|
addCategory(new ConfigurationCategory(this));
|
|
addCategory(new SavingCategory(this));
|
|
addCategory(new LoggingCategory(this));
|
|
addCategory(new FrameThrottleCategory(this));
|
|
addCategory(new RecordingCategory(this));
|
|
addCategory(new OnscreenDisplayCategory(this));
|
|
addCategory(new UserInterfaceCategory(mainwindow, this));
|
|
addCategory(new AIServiceCategory(this));
|
|
#ifdef HAVE_CHEEVOS
|
|
addCategory(new AchievementsCategory(this));
|
|
#endif
|
|
#if defined(HAVE_NETWORKING) && defined(HAVE_WIFI)
|
|
addCategory(new QtDisplayListCategory(
|
|
MENU_ENUM_LABEL_VALUE_WIFI_SETTINGS, "menu_network",
|
|
DISPLAYLIST_WIFI_SETTINGS_LIST, this));
|
|
#endif
|
|
#ifdef HAVE_NETWORKING
|
|
/* Netplay and updater settings do not exist in a build without
|
|
* networking; NetplayPage constructs CheckBoxes straight from the
|
|
* setting lookups, which are NULL then (crashed the offscreen
|
|
* companion test's --disable-networking build at startup). */
|
|
addCategory(new NetworkCategory(this));
|
|
#endif
|
|
#ifdef HAVE_MIST
|
|
addCategory(new QtDisplayListCategory(
|
|
MENU_ENUM_LABEL_VALUE_STEAM_SETTINGS, "menu_steam",
|
|
DISPLAYLIST_STEAM_SETTINGS_LIST, this));
|
|
#endif
|
|
addCategory(new PlaylistsCategory(this));
|
|
addCategory(new UserCategory(this));
|
|
addCategory(new DirectoryCategory(this));
|
|
|
|
width =
|
|
m_optionsList->sizeHintForColumn(0)
|
|
+ m_optionsList->frameWidth() * 2
|
|
+ 5;
|
|
width += m_optionsList->verticalScrollBar()->sizeHint().width();
|
|
|
|
m_optionsList->setMaximumWidth(width);
|
|
m_optionsList->setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Minimum);
|
|
|
|
setWindowTitle(msg_hash_to_str(MENU_ENUM_LABEL_VALUE_QT_MENU_VIEW_OPTIONS_TITLE));
|
|
|
|
layout->addWidget(m_optionsList, 0, 0, 2, 1);
|
|
layout->addLayout(headerHLayout, 0, 1);
|
|
layout->addLayout(m_optionsStack, 1, 1);
|
|
|
|
connect(m_optionsList, SIGNAL(currentRowChanged(int)),
|
|
m_optionsStack, SLOT(setCurrentIndex(int)));
|
|
connect(m_optionsList, SIGNAL(currentTextChanged(const QString&)),
|
|
m_headerLabel, SLOT(setText(const QString&)));
|
|
|
|
connect(this, SIGNAL(rejected()), this, SLOT(onRejected()));
|
|
}
|
|
|
|
QIcon getIcon(OptionsCategory *category)
|
|
{
|
|
settings_t *settings = config_get_ptr();
|
|
const char *path_dir_assets = settings->paths.directory_assets;
|
|
QPixmap pixmap = QPixmap(QString(path_dir_assets)
|
|
+ "/xmb/monochrome/png/"
|
|
+ category->categoryIconName()
|
|
+ ".png");
|
|
return QIcon(getColorizedPixmap(pixmap, getLabelColor("iconColor")));
|
|
}
|
|
|
|
void ViewOptionsDialog::addCategory(OptionsCategory *category)
|
|
{
|
|
QTabWidget *tabWidget = new QTabWidget();
|
|
|
|
m_categoryList.append(category);
|
|
|
|
for (OptionsPage* page : category->pages())
|
|
{
|
|
SmartScrollArea *scrollArea = new SmartScrollArea(this);
|
|
QWidget *widget = page->widget();
|
|
|
|
scrollArea->setWidget(widget);
|
|
widget->setAutoFillBackground(false);
|
|
tabWidget->addTab(scrollArea, page->displayName());
|
|
}
|
|
|
|
#if (QT_VERSION >= QT_VERSION_CHECK(5, 4, 0))
|
|
tabWidget->setTabBarAutoHide(true);
|
|
#else
|
|
/* TODO remove the tabBar's space */
|
|
if (tabWidget->count() < 2)
|
|
tabWidget->tabBar()->hide();
|
|
#endif
|
|
m_optionsList->addItem(
|
|
new QListWidgetItem(getIcon(category),
|
|
category->displayName()));
|
|
m_optionsStack->addWidget(tabWidget);
|
|
}
|
|
|
|
void ViewOptionsDialog::repaintIcons()
|
|
{
|
|
unsigned i;
|
|
size_t list_size = (size_t)m_categoryList.size();
|
|
|
|
for (i = 0; i < list_size; i++)
|
|
m_optionsList->item(i)->setIcon(getIcon(m_categoryList.at(i)));
|
|
}
|
|
#else
|
|
ViewOptionsDialog::ViewOptionsDialog(MainWindow *mainwindow, QWidget *parent) :
|
|
QDialog(mainwindow)
|
|
, m_viewOptionsWidget(new ViewOptionsWidget(mainwindow))
|
|
{
|
|
QVBoxLayout *layout = new QVBoxLayout;
|
|
QDialogButtonBox *buttonBox = new QDialogButtonBox(
|
|
QDialogButtonBox::Ok | QDialogButtonBox::Cancel);
|
|
|
|
connect(buttonBox, SIGNAL(accepted()), this, SLOT(accept()));
|
|
connect(buttonBox, SIGNAL(rejected()), this, SLOT(reject()));
|
|
|
|
connect(this, SIGNAL(accepted()), m_viewOptionsWidget, SLOT(onAccepted()));
|
|
connect(this, SIGNAL(rejected()), m_viewOptionsWidget, SLOT(onRejected()));
|
|
|
|
setWindowTitle(msg_hash_to_str(MENU_ENUM_LABEL_VALUE_QT_MENU_VIEW_OPTIONS_TITLE));
|
|
|
|
layout->setContentsMargins(0, 0, 0, 0);
|
|
|
|
layout->addWidget(m_viewOptionsWidget);
|
|
layout->addWidget(buttonBox);
|
|
|
|
setLayout(layout);
|
|
}
|
|
#endif
|
|
|
|
void ViewOptionsDialog::showDialog()
|
|
{
|
|
#ifdef HAVE_MENU
|
|
unsigned i;
|
|
size_t list_size = (size_t)m_categoryList.size();
|
|
for (i = 0; i < list_size; i++)
|
|
m_categoryList.at(i)->load();
|
|
#else
|
|
m_viewOptionsWidget->loadViewOptions();
|
|
#endif
|
|
if (!isVisible())
|
|
restoreGeometry();
|
|
show();
|
|
activateWindow();
|
|
}
|
|
|
|
void ViewOptionsDialog::persistGeometry()
|
|
{
|
|
settings_t *settings = config_get_ptr();
|
|
QRect g;
|
|
if (!settings->bools.desktop_menu_save_geometry || !isVisible() || isMinimized())
|
|
return;
|
|
g = geometry();
|
|
if (g.width() <= 0 || g.height() <= 0)
|
|
return;
|
|
snprintf(settings->arrays.desktop_menu_options_window,
|
|
sizeof(settings->arrays.desktop_menu_options_window), "%d,%d,%d,%d",
|
|
g.x() < 0 ? 0 : g.x(), g.y() < 0 ? 0 : g.y(), g.width(), g.height());
|
|
}
|
|
|
|
void ViewOptionsDialog::restoreGeometry()
|
|
{
|
|
settings_t *settings = config_get_ptr();
|
|
int x = 0, y = 0, w = 0, h = 0;
|
|
if (!settings->bools.desktop_menu_save_geometry)
|
|
return;
|
|
if (sscanf(settings->arrays.desktop_menu_options_window, "%d,%d,%d,%d",
|
|
&x, &y, &w, &h) != 4)
|
|
return;
|
|
if (w <= 0 || h <= 0 || w > 32767 || h > 32767 || x < 0 || y < 0)
|
|
return;
|
|
setGeometry(x, y, w, h);
|
|
}
|
|
|
|
void ViewOptionsDialog::resizeEvent(QResizeEvent *event)
|
|
{
|
|
QDialog::resizeEvent(event);
|
|
persistGeometry();
|
|
}
|
|
|
|
void ViewOptionsDialog::moveEvent(QMoveEvent *event)
|
|
{
|
|
QDialog::moveEvent(event);
|
|
persistGeometry();
|
|
}
|
|
|
|
void ViewOptionsDialog::hideDialog() { reject(); }
|
|
|
|
void ViewOptionsDialog::onRejected()
|
|
{
|
|
#ifdef HAVE_MENU
|
|
unsigned i;
|
|
size_t list_size = (size_t)m_categoryList.size();
|
|
for (i = 0; i < list_size; i++)
|
|
m_categoryList.at(i)->apply();
|
|
#endif
|
|
}
|
|
|
|
ViewOptionsWidget::ViewOptionsWidget(MainWindow *mainwindow, QWidget *parent) :
|
|
QWidget(parent)
|
|
,m_mainwindow(mainwindow)
|
|
,m_saveGeometryCheckBox(new QCheckBox(this))
|
|
,m_saveLastTabCheckBox(new QCheckBox(this))
|
|
,m_saveDockPositionsCheckBox(new QCheckBox(this))
|
|
,m_showHiddenFilesCheckBox(new QCheckBox(this))
|
|
,m_themeComboBox(new QComboBox(this))
|
|
,m_thumbnailCacheSpinBox(new QSpinBox(this))
|
|
,m_thumbnailDropSizeSpinBox(new QSpinBox(this))
|
|
,m_startupPlaylistComboBox(new QComboBox(this))
|
|
,m_highlightColorPushButton(new QPushButton(
|
|
msg_hash_to_str(MENU_ENUM_LABEL_VALUE_QT_CHOOSE), this))
|
|
,m_highlightColor()
|
|
,m_highlightColorLabel(new QLabel(
|
|
msg_hash_to_str(
|
|
MENU_ENUM_LABEL_VALUE_QT_MENU_VIEW_OPTIONS_HIGHLIGHT_COLOR), this))
|
|
,m_customThemePath()
|
|
,m_suggestLoadedCoreFirstCheckBox(new QCheckBox(this))
|
|
/* ,m_allPlaylistsListMaxCountSpinBox(new QSpinBox(this)) */
|
|
/* ,m_allPlaylistsGridMaxCountSpinBox(new QSpinBox(this)) */
|
|
{
|
|
QVBoxLayout *layout = new QVBoxLayout;
|
|
QFormLayout *form = new QFormLayout;
|
|
|
|
m_themeComboBox->addItem(msg_hash_to_str(
|
|
MENU_ENUM_LABEL_VALUE_QT_MENU_VIEW_OPTIONS_THEME_SYSTEM_DEFAULT),
|
|
MainWindow::THEME_SYSTEM_DEFAULT);
|
|
m_themeComboBox->addItem(msg_hash_to_str(
|
|
MENU_ENUM_LABEL_VALUE_QT_MENU_VIEW_OPTIONS_THEME_DARK),
|
|
MainWindow::THEME_DARK);
|
|
m_themeComboBox->addItem(msg_hash_to_str(
|
|
MENU_ENUM_LABEL_VALUE_QT_MENU_VIEW_OPTIONS_THEME_CUSTOM),
|
|
MainWindow::THEME_CUSTOM);
|
|
|
|
m_thumbnailCacheSpinBox->setSuffix(" MB");
|
|
m_thumbnailCacheSpinBox->setRange(0, 99999);
|
|
|
|
m_thumbnailDropSizeSpinBox->setSuffix(" px");
|
|
m_thumbnailDropSizeSpinBox->setRange(0, 99999);
|
|
|
|
/* m_allPlaylistsListMaxCountSpinBox->setRange(0, 99999); */
|
|
/* m_allPlaylistsGridMaxCountSpinBox->setRange(0, 99999); */
|
|
|
|
form->setFormAlignment(Qt::AlignCenter);
|
|
form->setLabelAlignment(Qt::AlignCenter);
|
|
|
|
form->addRow(msg_hash_to_str(
|
|
MENU_ENUM_LABEL_VALUE_QT_MENU_VIEW_OPTIONS_SAVE_GEOMETRY),
|
|
m_saveGeometryCheckBox);
|
|
form->addRow(msg_hash_to_str(
|
|
MENU_ENUM_LABEL_VALUE_QT_MENU_VIEW_OPTIONS_SAVE_DOCK_POSITIONS),
|
|
m_saveDockPositionsCheckBox);
|
|
form->addRow(msg_hash_to_str(
|
|
MENU_ENUM_LABEL_VALUE_QT_MENU_VIEW_OPTIONS_SAVE_LAST_TAB), m_saveLastTabCheckBox);
|
|
form->addRow(msg_hash_to_str(MENU_ENUM_LABEL_VALUE_QT_MENU_VIEW_OPTIONS_SHOW_HIDDEN_FILES), m_showHiddenFilesCheckBox);
|
|
form->addRow(msg_hash_to_str(MENU_ENUM_LABEL_VALUE_QT_MENU_VIEW_OPTIONS_SUGGEST_LOADED_CORE_FIRST), m_suggestLoadedCoreFirstCheckBox);
|
|
form->addRow(msg_hash_to_str(MENU_ENUM_LABEL_VALUE_QT_MENU_VIEW_OPTIONS_STARTUP_PLAYLIST), m_startupPlaylistComboBox);
|
|
form->addRow(msg_hash_to_str(MENU_ENUM_LABEL_VALUE_QT_MENU_VIEW_OPTIONS_THUMBNAIL_CACHE_LIMIT), m_thumbnailCacheSpinBox);
|
|
form->addRow(msg_hash_to_str(MENU_ENUM_LABEL_VALUE_QT_MENU_VIEW_OPTIONS_THUMBNAIL_DROP_SIZE_LIMIT), m_thumbnailDropSizeSpinBox);
|
|
form->addRow(msg_hash_to_str(MENU_ENUM_LABEL_VALUE_QT_MENU_VIEW_OPTIONS_THEME), m_themeComboBox);
|
|
form->addRow(m_highlightColorLabel, m_highlightColorPushButton);
|
|
|
|
/* The same one-line help the Win32 and Cocoa companions show for
|
|
* these rows, on both the label and the control. The text is the
|
|
* menu's, and so is wrapped_tooltip() - a build without the menu
|
|
* has neither. */
|
|
#ifdef HAVE_MENU
|
|
{
|
|
struct { QWidget *w; enum msg_hash_enums help; } tips[] = {
|
|
{ m_saveGeometryCheckBox, MENU_ENUM_SUBLABEL_QT_MENU_VIEW_OPTIONS_SAVE_GEOMETRY },
|
|
{ m_saveLastTabCheckBox, MENU_ENUM_SUBLABEL_QT_MENU_VIEW_OPTIONS_SAVE_LAST_TAB },
|
|
{ m_showHiddenFilesCheckBox, MENU_ENUM_SUBLABEL_QT_MENU_VIEW_OPTIONS_SHOW_HIDDEN_FILES },
|
|
{ m_suggestLoadedCoreFirstCheckBox, MENU_ENUM_SUBLABEL_QT_MENU_VIEW_OPTIONS_SUGGEST_LOADED_CORE_FIRST },
|
|
{ m_startupPlaylistComboBox, MENU_ENUM_SUBLABEL_QT_MENU_VIEW_OPTIONS_STARTUP_PLAYLIST },
|
|
{ m_thumbnailCacheSpinBox, MENU_ENUM_SUBLABEL_QT_MENU_VIEW_OPTIONS_THUMBNAIL_CACHE_LIMIT },
|
|
{ m_thumbnailDropSizeSpinBox, MENU_ENUM_SUBLABEL_QT_MENU_VIEW_OPTIONS_THUMBNAIL_DROP_SIZE_LIMIT },
|
|
{ m_themeComboBox, MENU_ENUM_SUBLABEL_QT_MENU_VIEW_OPTIONS_THEME },
|
|
{ m_highlightColorPushButton, MENU_ENUM_SUBLABEL_QT_MENU_VIEW_OPTIONS_HIGHLIGHT_COLOR },
|
|
{ m_highlightColorLabel, MENU_ENUM_SUBLABEL_QT_MENU_VIEW_OPTIONS_HIGHLIGHT_COLOR },
|
|
};
|
|
for (size_t i = 0; i < sizeof(tips) / sizeof(tips[0]); i++)
|
|
{
|
|
QString tip = wrapped_tooltip(msg_hash_to_str(tips[i].help));
|
|
tips[i].w->setToolTip(tip);
|
|
if (QWidget *label = form->labelForField(tips[i].w))
|
|
label->setToolTip(tip);
|
|
}
|
|
}
|
|
#endif
|
|
|
|
layout->addLayout(form);
|
|
|
|
layout->addItem(new QSpacerItem(20, 20, QSizePolicy::Minimum, QSizePolicy::Expanding));
|
|
|
|
setLayout(layout);
|
|
|
|
loadViewOptions();
|
|
|
|
connect(m_themeComboBox, SIGNAL(currentIndexChanged(int)), this, SLOT(onThemeComboBoxIndexChanged(int)));
|
|
connect(m_highlightColorPushButton, SIGNAL(clicked()), this, SLOT(onHighlightColorChoose()));
|
|
}
|
|
|
|
void ViewOptionsWidget::onThemeComboBoxIndexChanged(int)
|
|
{
|
|
MainWindow::Theme theme = static_cast<MainWindow::Theme>(m_themeComboBox->currentData(Qt::UserRole).toInt());
|
|
|
|
if (theme == MainWindow::THEME_CUSTOM)
|
|
{
|
|
QString filePath = QFileDialog::getOpenFileName(this, msg_hash_to_str(MENU_ENUM_LABEL_VALUE_QT_SELECT_THEME));
|
|
|
|
if (filePath.isEmpty())
|
|
{
|
|
int oldThemeIndex = m_themeComboBox->findData((int)config_get_ptr()->uints.desktop_menu_theme);
|
|
|
|
if (m_themeComboBox->count() > oldThemeIndex)
|
|
{
|
|
disconnect(m_themeComboBox, SIGNAL(currentIndexChanged(int)), this, SLOT(onThemeComboBoxIndexChanged(int)));
|
|
m_themeComboBox->setCurrentIndex(oldThemeIndex);
|
|
connect(m_themeComboBox, SIGNAL(currentIndexChanged(int)), this, SLOT(onThemeComboBoxIndexChanged(int)));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
m_customThemePath = filePath;
|
|
|
|
if (m_mainwindow->setCustomThemeFile(filePath))
|
|
m_mainwindow->setTheme(theme);
|
|
}
|
|
}
|
|
else
|
|
m_mainwindow->setTheme(theme);
|
|
|
|
showOrHideHighlightColor();
|
|
}
|
|
|
|
void ViewOptionsWidget::onHighlightColorChoose()
|
|
{
|
|
QPixmap highlightPixmap(m_highlightColorPushButton->iconSize());
|
|
QColor currentHighlightColor =
|
|
string_is_empty(config_get_ptr()->arrays.desktop_menu_highlight_color)
|
|
? QApplication::palette().highlight().color()
|
|
: QColor(QString::fromUtf8(config_get_ptr()->arrays.desktop_menu_highlight_color));
|
|
QColor newHighlightColor = QColorDialog::getColor(
|
|
currentHighlightColor, this,
|
|
msg_hash_to_str(MENU_ENUM_LABEL_VALUE_QT_SELECT_COLOR));
|
|
|
|
if (newHighlightColor.isValid())
|
|
{
|
|
MainWindow::Theme theme = static_cast<MainWindow::Theme>(
|
|
m_themeComboBox->currentData(Qt::UserRole).toInt());
|
|
|
|
m_highlightColor = newHighlightColor;
|
|
strlcpy(config_get_ptr()->arrays.desktop_menu_highlight_color,
|
|
m_highlightColor.name().toUtf8().constData(),
|
|
sizeof(config_get_ptr()->arrays.desktop_menu_highlight_color));
|
|
highlightPixmap.fill(m_highlightColor);
|
|
m_highlightColorPushButton->setIcon(highlightPixmap);
|
|
m_mainwindow->setTheme(theme);
|
|
}
|
|
}
|
|
|
|
void ViewOptionsWidget::loadViewOptions()
|
|
{
|
|
int i;
|
|
int themeIndex = 0;
|
|
int playlistIndex = 0;
|
|
settings_t *settings = config_get_ptr();
|
|
QColor highlightColor =
|
|
string_is_empty(settings->arrays.desktop_menu_highlight_color)
|
|
? QApplication::palette().highlight().color()
|
|
: QColor(QString::fromUtf8(settings->arrays.desktop_menu_highlight_color));
|
|
QPixmap highlightPixmap(m_highlightColorPushButton->iconSize());
|
|
QVector<QPair<QString, QString> > playlists = m_mainwindow->getPlaylists();
|
|
QString initialPlaylist =
|
|
string_is_empty(settings->paths.desktop_menu_initial_playlist)
|
|
? QString(ALL_PLAYLISTS_TOKEN)
|
|
: QString::fromUtf8(settings->paths.desktop_menu_initial_playlist);
|
|
|
|
m_saveGeometryCheckBox->setChecked(settings->bools.desktop_menu_save_geometry);
|
|
m_saveLastTabCheckBox->setChecked(settings->bools.desktop_menu_save_last_tab);
|
|
m_saveDockPositionsCheckBox->setChecked(settings->bools.desktop_menu_save_dock_positions);
|
|
m_showHiddenFilesCheckBox->setChecked(settings->bools.show_hidden_files);
|
|
m_suggestLoadedCoreFirstCheckBox->setChecked(settings->bools.desktop_menu_suggest_loaded_core_first);
|
|
m_thumbnailCacheSpinBox->setValue((int)settings->uints.desktop_menu_thumbnail_cache_limit);
|
|
m_thumbnailDropSizeSpinBox->setValue((int)settings->uints.desktop_menu_thumbnail_max_size);
|
|
|
|
themeIndex = m_themeComboBox->findData((int)settings->uints.desktop_menu_theme);
|
|
|
|
if (m_themeComboBox->count() > themeIndex)
|
|
m_themeComboBox->setCurrentIndex(themeIndex);
|
|
|
|
if (highlightColor.isValid())
|
|
{
|
|
m_highlightColor = highlightColor;
|
|
highlightPixmap.fill(m_highlightColor);
|
|
m_highlightColorPushButton->setIcon(highlightPixmap);
|
|
}
|
|
|
|
showOrHideHighlightColor();
|
|
|
|
m_startupPlaylistComboBox->clear();
|
|
|
|
for (i = 0; i < playlists.count(); i++)
|
|
{
|
|
const QPair<QString, QString> &pair = playlists.at(i);
|
|
|
|
m_startupPlaylistComboBox->addItem(pair.first, pair.second);
|
|
}
|
|
|
|
playlistIndex = m_startupPlaylistComboBox->findData(
|
|
initialPlaylist, Qt::UserRole, Qt::MatchFixedString);
|
|
|
|
if (playlistIndex >= 0)
|
|
m_startupPlaylistComboBox->setCurrentIndex(playlistIndex);
|
|
}
|
|
|
|
void ViewOptionsWidget::showOrHideHighlightColor()
|
|
{
|
|
if (m_mainwindow->theme() == MainWindow::THEME_DARK)
|
|
{
|
|
m_highlightColorLabel->show();
|
|
m_highlightColorPushButton->show();
|
|
}
|
|
else
|
|
{
|
|
m_highlightColorLabel->hide();
|
|
m_highlightColorPushButton->hide();
|
|
}
|
|
}
|
|
|
|
void ViewOptionsWidget::saveViewOptions()
|
|
{
|
|
/* Into retroarch.cfg's settings_t, shared with the native companions;
|
|
* RetroArch writes the file on exit. */
|
|
settings_t *settings = config_get_ptr();
|
|
QByteArray initial = m_startupPlaylistComboBox->currentData(Qt::UserRole).toString().toUtf8();
|
|
QByteArray color = m_highlightColor.name().toUtf8();
|
|
QByteArray theme = m_customThemePath.toUtf8();
|
|
|
|
settings->bools.desktop_menu_save_geometry = m_saveGeometryCheckBox->isChecked();
|
|
settings->bools.desktop_menu_save_last_tab = m_saveLastTabCheckBox->isChecked();
|
|
settings->bools.desktop_menu_save_dock_positions = m_saveDockPositionsCheckBox->isChecked();
|
|
settings->uints.desktop_menu_theme =
|
|
(unsigned)m_themeComboBox->currentData(Qt::UserRole).toInt();
|
|
settings->bools.show_hidden_files = m_showHiddenFilesCheckBox->isChecked();
|
|
strlcpy(settings->arrays.desktop_menu_highlight_color, color.constData(),
|
|
sizeof(settings->arrays.desktop_menu_highlight_color));
|
|
settings->bools.desktop_menu_suggest_loaded_core_first = m_suggestLoadedCoreFirstCheckBox->isChecked();
|
|
strlcpy(settings->paths.desktop_menu_initial_playlist, initial.constData(),
|
|
sizeof(settings->paths.desktop_menu_initial_playlist));
|
|
settings->uints.desktop_menu_thumbnail_cache_limit = (unsigned)m_thumbnailCacheSpinBox->value();
|
|
settings->uints.desktop_menu_thumbnail_max_size = (unsigned)m_thumbnailDropSizeSpinBox->value();
|
|
|
|
if (!m_mainwindow->customThemeString().isEmpty())
|
|
strlcpy(settings->paths.desktop_menu_custom_theme, theme.constData(),
|
|
sizeof(settings->paths.desktop_menu_custom_theme));
|
|
|
|
m_mainwindow->setThumbnailCacheLimit(m_thumbnailCacheSpinBox->value());
|
|
}
|
|
|
|
void ViewOptionsWidget::onAccepted() { saveViewOptions(); }
|
|
void ViewOptionsWidget::onRejected() { loadViewOptions(); }
|
|
|
|
CoreOptionsDialog::CoreOptionsDialog(QWidget *parent) :
|
|
QDialog(parent)
|
|
,m_layout()
|
|
,m_scrollArea()
|
|
{
|
|
setWindowTitle(msg_hash_to_str(MENU_ENUM_LABEL_VALUE_QT_CORE_OPTIONS));
|
|
setObjectName("coreOptionsDialog");
|
|
|
|
resize(720, 480);
|
|
|
|
QTimer::singleShot(0, this, SLOT(clearLayout()));
|
|
}
|
|
|
|
CoreOptionsDialog::~CoreOptionsDialog() { }
|
|
|
|
void CoreOptionsDialog::resizeEvent(QResizeEvent *event)
|
|
{
|
|
QDialog::resizeEvent(event);
|
|
|
|
if (!m_scrollArea)
|
|
return;
|
|
|
|
m_scrollArea->resize(event->size());
|
|
|
|
emit resized(event->size());
|
|
}
|
|
|
|
void CoreOptionsDialog::closeEvent(QCloseEvent *event)
|
|
{
|
|
QDialog::closeEvent(event);
|
|
|
|
emit closed();
|
|
}
|
|
|
|
void CoreOptionsDialog::paintEvent(QPaintEvent *event)
|
|
{
|
|
QStyleOption o;
|
|
QPainter p;
|
|
o.initFrom(this);
|
|
p.begin(this);
|
|
style()->drawPrimitive(
|
|
QStyle::PE_Widget, &o, &p, this);
|
|
p.end();
|
|
|
|
QDialog::paintEvent(event);
|
|
}
|
|
|
|
void CoreOptionsDialog::clearLayout()
|
|
{
|
|
QWidget *widget = NULL;
|
|
|
|
if (m_scrollArea)
|
|
{
|
|
{
|
|
QList<QObject*> _children = children();
|
|
for (int _i = 0; _i < _children.size(); _i++)
|
|
_children[_i]->deleteLater();
|
|
}
|
|
}
|
|
|
|
m_layout = new QVBoxLayout();
|
|
|
|
widget = new QWidget();
|
|
widget->setLayout(m_layout);
|
|
widget->setObjectName("coreOptionsWidget");
|
|
|
|
m_scrollArea = new QScrollArea();
|
|
|
|
m_scrollArea->setParent(this);
|
|
m_scrollArea->setWidgetResizable(true);
|
|
m_scrollArea->setWidget(widget);
|
|
m_scrollArea->setObjectName("coreOptionsScrollArea");
|
|
m_scrollArea->show();
|
|
}
|
|
|
|
void CoreOptionsDialog::reload()
|
|
{
|
|
buildLayout();
|
|
}
|
|
|
|
void CoreOptionsDialog::onSaveGameSpecificOptions()
|
|
{
|
|
#ifdef HAVE_MENU
|
|
struct menu_state *menu_st = menu_state_get_ptr();
|
|
#endif
|
|
if (!core_options_create_override(true))
|
|
QMessageBox::critical(this, msg_hash_to_str(MSG_ERROR), msg_hash_to_str(MSG_ERROR_SAVING_CORE_OPTIONS_FILE));
|
|
#ifdef HAVE_MENU
|
|
menu_st->flags |= MENU_ST_FLAG_ENTRIES_NEED_REFRESH
|
|
| MENU_ST_FLAG_PREVENT_POPULATE;
|
|
#endif
|
|
}
|
|
|
|
void CoreOptionsDialog::onSaveFolderSpecificOptions()
|
|
{
|
|
#ifdef HAVE_MENU
|
|
struct menu_state *menu_st = menu_state_get_ptr();
|
|
#endif
|
|
if (!core_options_create_override(false))
|
|
QMessageBox::critical(this, msg_hash_to_str(MSG_ERROR), msg_hash_to_str(MSG_ERROR_SAVING_CORE_OPTIONS_FILE));
|
|
#ifdef HAVE_MENU
|
|
menu_st->flags |= MENU_ST_FLAG_ENTRIES_NEED_REFRESH
|
|
| MENU_ST_FLAG_PREVENT_POPULATE;
|
|
#endif
|
|
}
|
|
|
|
void CoreOptionsDialog::onCoreOptionComboBoxCurrentIndexChanged(int index)
|
|
{
|
|
unsigned i, k;
|
|
QString key, val;
|
|
runloop_state_t *runloop_st = runloop_state_get_ptr();
|
|
QComboBox *combo_box = qobject_cast<QComboBox*>(sender());
|
|
|
|
if (!combo_box)
|
|
return;
|
|
|
|
key = combo_box->itemData(index, Qt::UserRole).toString();
|
|
val = combo_box->itemText(index);
|
|
|
|
if (runloop_st->core_options)
|
|
{
|
|
core_option_manager_t *coreopts = NULL;
|
|
|
|
retroarch_ctl(RARCH_CTL_CORE_OPTIONS_LIST_GET, &coreopts);
|
|
|
|
if (coreopts)
|
|
{
|
|
size_t opts = runloop_st->core_options->size;
|
|
|
|
for (i = 0; i < opts; i++)
|
|
{
|
|
QString optKey;
|
|
struct core_option *option = static_cast<struct core_option*>(&coreopts->opts[i]);
|
|
|
|
if (!option)
|
|
continue;
|
|
|
|
optKey = option->key;
|
|
|
|
if (key == optKey)
|
|
{
|
|
for (k = 0; k < option->vals->size; k++)
|
|
{
|
|
QString str = option->vals->elems[k].data;
|
|
|
|
if (!str.isEmpty() && str == val)
|
|
core_option_manager_set_val(coreopts, i, k, true);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void CoreOptionsDialog::buildLayout()
|
|
{
|
|
unsigned j, k;
|
|
QFormLayout *form = NULL;
|
|
settings_t *settings = config_get_ptr();
|
|
runloop_state_t *runloop_st = runloop_state_get_ptr();
|
|
bool has_core_options = (runloop_st->core_options != NULL);
|
|
size_t opts = (runloop_st->core_options) ? runloop_st->core_options->size : 0;
|
|
|
|
clearLayout();
|
|
|
|
if (has_core_options)
|
|
{
|
|
core_option_manager_t *coreopts = NULL;
|
|
|
|
form = new QFormLayout();
|
|
|
|
if (settings->bools.game_specific_options)
|
|
{
|
|
QString contentLabel;
|
|
QString label;
|
|
rarch_system_info_t *sys_info = &runloop_st->system;
|
|
|
|
/* TODO/FIXME - why have this check here? sys_info is not used */
|
|
if (sys_info)
|
|
contentLabel = QFileInfo(path_get(RARCH_PATH_BASENAME)).completeBaseName();
|
|
|
|
if (!contentLabel.isEmpty())
|
|
{
|
|
if (!label.isEmpty())
|
|
{
|
|
QHBoxLayout *gameOptionsLayout = new QHBoxLayout();
|
|
QPushButton *button = new QPushButton(msg_hash_to_str(MENU_ENUM_LABEL_VALUE_QT_SAVE), this);
|
|
|
|
connect(button, SIGNAL(clicked()), this, SLOT(onSaveGameSpecificOptions()));
|
|
|
|
gameOptionsLayout->addWidget(new QLabel(contentLabel, this));
|
|
gameOptionsLayout->addSpacerItem(new QSpacerItem(0, 0, QSizePolicy::Expanding, QSizePolicy::Preferred));
|
|
gameOptionsLayout->addWidget(button);
|
|
|
|
form->addRow(label, gameOptionsLayout);
|
|
}
|
|
}
|
|
}
|
|
|
|
retroarch_ctl(RARCH_CTL_CORE_OPTIONS_LIST_GET, &coreopts);
|
|
|
|
if (coreopts)
|
|
{
|
|
QToolButton *resetAllButton = new QToolButton(this);
|
|
|
|
resetAllButton->setDefaultAction(new QAction(msg_hash_to_str(MENU_ENUM_LABEL_VALUE_QT_RESET_ALL), this));
|
|
connect(resetAllButton, SIGNAL(clicked()), this, SLOT(onCoreOptionResetAllClicked()));
|
|
|
|
for (j = 0; j < opts; j++)
|
|
{
|
|
QString desc =
|
|
core_option_manager_get_desc(coreopts, j, false);
|
|
QString val =
|
|
core_option_manager_get_val(coreopts, j);
|
|
QComboBox *combo_box = NULL;
|
|
QLabel *descLabel = NULL;
|
|
QHBoxLayout *comboLayout = NULL;
|
|
QToolButton *resetButton = NULL;
|
|
struct core_option *option = NULL;
|
|
|
|
if (desc.isEmpty() || !coreopts->opts)
|
|
continue;
|
|
|
|
option = static_cast<struct core_option*>(&coreopts->opts[j]);
|
|
|
|
if (!option->vals || option->vals->size == 0)
|
|
continue;
|
|
|
|
comboLayout = new QHBoxLayout();
|
|
descLabel = new QLabel(desc, this);
|
|
combo_box = new QComboBox(this);
|
|
combo_box->setObjectName("coreOptionComboBox");
|
|
resetButton = new QToolButton(this);
|
|
resetButton->setObjectName("resetButton");
|
|
resetButton->setDefaultAction(new QAction(msg_hash_to_str(MENU_ENUM_LABEL_VALUE_QT_RESET), this));
|
|
resetButton->setProperty("comboBox",
|
|
QVariant::fromValue(combo_box));
|
|
|
|
connect(resetButton, SIGNAL(clicked()),
|
|
this, SLOT(onCoreOptionResetClicked()));
|
|
|
|
if (option->info && *option->info)
|
|
{
|
|
char *new_info;
|
|
size_t option_info_len = strlen(option->info);
|
|
size_t new_info_len = option_info_len + 1;
|
|
|
|
if (!(new_info = (char *)malloc(new_info_len)))
|
|
return;
|
|
new_info[0] = '\0';
|
|
|
|
word_wrap(new_info, new_info_len, option->info,
|
|
option_info_len, 50, 100, 0);
|
|
/* already wrapped to 50 columns: keep the line breaks */
|
|
descLabel->setToolTip(QStringLiteral("<qt><pre>")
|
|
+ QString::fromUtf8(new_info).toHtmlEscaped()
|
|
+ QStringLiteral("</pre></qt>"));
|
|
combo_box->setToolTip(descLabel->toolTip());
|
|
free(new_info);
|
|
}
|
|
|
|
for (k = 0; k < option->vals->size; k++)
|
|
combo_box->addItem(option->vals->elems[k].data, QVariant::fromValue(QString(option->key)));
|
|
|
|
combo_box->setCurrentText(val);
|
|
combo_box->setProperty("default_index",
|
|
static_cast<unsigned>(option->default_index));
|
|
|
|
/* Only connect the signal after setting the default item */
|
|
connect(combo_box, SIGNAL(currentIndexChanged(int)),
|
|
this,
|
|
SLOT(onCoreOptionComboBoxCurrentIndexChanged(int)));
|
|
|
|
comboLayout->addWidget(combo_box);
|
|
comboLayout->addWidget(resetButton);
|
|
|
|
form->addRow(descLabel, comboLayout);
|
|
}
|
|
|
|
form->addRow(resetAllButton, new QWidget(this));
|
|
|
|
m_layout->addLayout(form);
|
|
}
|
|
}
|
|
|
|
if (!opts)
|
|
{
|
|
QLabel *noParamsLabel = new QLabel(msg_hash_to_str(
|
|
MENU_ENUM_LABEL_VALUE_NO_CORE_OPTIONS_AVAILABLE), this);
|
|
noParamsLabel->setAlignment(Qt::AlignCenter);
|
|
|
|
m_layout->addWidget(noParamsLabel);
|
|
}
|
|
|
|
m_layout->addItem(new QSpacerItem(20, 20,
|
|
QSizePolicy::Minimum, QSizePolicy::Expanding));
|
|
|
|
resize(width() + 1, height());
|
|
show();
|
|
resize(width() - 1, height());
|
|
}
|
|
|
|
void CoreOptionsDialog::onCoreOptionResetClicked()
|
|
{
|
|
bool ok = false;
|
|
QToolButton *button = qobject_cast<QToolButton*>(sender());
|
|
QComboBox *combo_box = NULL;
|
|
int default_index = 0;
|
|
|
|
if (!button)
|
|
return;
|
|
|
|
combo_box = qobject_cast<QComboBox*>(button->property("comboBox").value<QComboBox*>());
|
|
|
|
if (!combo_box)
|
|
return;
|
|
|
|
default_index = combo_box->property("default_index").toInt(&ok);
|
|
|
|
if (!ok)
|
|
return;
|
|
|
|
if (default_index >= 0 && default_index < combo_box->count())
|
|
combo_box->setCurrentIndex(default_index);
|
|
}
|
|
|
|
void CoreOptionsDialog::onCoreOptionResetAllClicked()
|
|
{
|
|
int i;
|
|
QList<QComboBox*> combo_boxes = findChildren<QComboBox*>("coreOptionComboBox");
|
|
|
|
for (i = 0; i < combo_boxes.count(); i++)
|
|
{
|
|
int default_index = 0;
|
|
bool ok = false;
|
|
QComboBox *combo_box = combo_boxes.at(i);
|
|
|
|
if (!combo_box)
|
|
continue;
|
|
|
|
default_index = combo_box->property("default_index").toInt(&ok);
|
|
|
|
if (!ok)
|
|
continue;
|
|
|
|
if (default_index >= 0 && default_index < combo_box->count())
|
|
combo_box->setCurrentIndex(default_index);
|
|
}
|
|
}
|
|
|
|
#if defined(HAVE_MENU)
|
|
#if defined(HAVE_CG) || defined(HAVE_GLSL) || defined(HAVE_SLANG) || defined(HAVE_HLSL)
|
|
enum
|
|
{
|
|
QT_SHADER_PRESET_GLOBAL = 0,
|
|
QT_SHADER_PRESET_CORE,
|
|
QT_SHADER_PRESET_PARENT,
|
|
QT_SHADER_PRESET_GAME,
|
|
QT_SHADER_PRESET_NORMAL
|
|
};
|
|
|
|
ShaderPass::ShaderPass(struct video_shader_pass *passToCopy) :
|
|
pass(NULL)
|
|
{
|
|
if (passToCopy)
|
|
{
|
|
pass = (struct video_shader_pass*)calloc(1, sizeof(*pass));
|
|
memcpy(pass, passToCopy, sizeof(*pass));
|
|
}
|
|
}
|
|
|
|
ShaderPass::ShaderPass(const ShaderPass &other) :
|
|
pass(NULL)
|
|
{
|
|
if (other.pass)
|
|
{
|
|
pass = (struct video_shader_pass*)calloc(1, sizeof(*pass));
|
|
memcpy(pass, other.pass, sizeof(*pass));
|
|
}
|
|
}
|
|
|
|
ShaderPass::~ShaderPass()
|
|
{
|
|
if (pass)
|
|
free(pass);
|
|
}
|
|
|
|
ShaderPass& ShaderPass::operator=(const ShaderPass &other)
|
|
{
|
|
if (this != &other)
|
|
{
|
|
/* Free any buffer we already own before taking a copy of
|
|
* other's, otherwise assigning into a non-empty ShaderPass
|
|
* leaks the previous allocation. */
|
|
if (pass)
|
|
{
|
|
free(pass);
|
|
pass = NULL;
|
|
}
|
|
|
|
if (other.pass)
|
|
{
|
|
pass = (struct video_shader_pass*)calloc(1, sizeof(*pass));
|
|
memcpy(pass, other.pass, sizeof(*pass));
|
|
}
|
|
}
|
|
|
|
return *this;
|
|
}
|
|
|
|
ShaderParamsDialog::ShaderParamsDialog(QWidget *parent) :
|
|
QDialog(parent)
|
|
,m_layout()
|
|
,m_scrollArea()
|
|
{
|
|
setWindowTitle(msg_hash_to_str(MENU_ENUM_LABEL_VALUE_SHADER_OPTIONS));
|
|
setObjectName("shaderParamsDialog");
|
|
|
|
resize(720, 480);
|
|
|
|
QTimer::singleShot(0, this, SLOT(clearLayout()));
|
|
}
|
|
|
|
ShaderParamsDialog::~ShaderParamsDialog()
|
|
{
|
|
}
|
|
|
|
void ShaderParamsDialog::resizeEvent(QResizeEvent *event)
|
|
{
|
|
QDialog::resizeEvent(event);
|
|
|
|
if (!m_scrollArea)
|
|
return;
|
|
|
|
m_scrollArea->resize(event->size());
|
|
|
|
emit resized(event->size());
|
|
}
|
|
|
|
void ShaderParamsDialog::closeEvent(QCloseEvent *event)
|
|
{
|
|
QDialog::closeEvent(event);
|
|
|
|
emit closed();
|
|
}
|
|
|
|
void ShaderParamsDialog::paintEvent(QPaintEvent *event)
|
|
{
|
|
QStyleOption o;
|
|
QPainter p;
|
|
o.initFrom(this);
|
|
p.begin(this);
|
|
style()->drawPrimitive(
|
|
QStyle::PE_Widget, &o, &p, this);
|
|
p.end();
|
|
|
|
QDialog::paintEvent(event);
|
|
}
|
|
|
|
QString ShaderParamsDialog::getFilterLabel(unsigned filter)
|
|
{
|
|
QString filterString;
|
|
|
|
switch (filter)
|
|
{
|
|
case 0:
|
|
filterString = msg_hash_to_str(MENU_ENUM_LABEL_VALUE_DONT_CARE);
|
|
break;
|
|
case 1:
|
|
filterString = msg_hash_to_str(MENU_ENUM_LABEL_VALUE_LINEAR);
|
|
break;
|
|
case 2:
|
|
filterString = msg_hash_to_str(MENU_ENUM_LABEL_VALUE_NEAREST);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return filterString;
|
|
}
|
|
|
|
void ShaderParamsDialog::clearLayout()
|
|
{
|
|
QWidget *widget = NULL;
|
|
|
|
if (m_scrollArea)
|
|
{
|
|
{
|
|
QList<QObject*> _children = children();
|
|
for (int _i = 0; _i < _children.size(); _i++)
|
|
delete _children[_i];
|
|
}
|
|
}
|
|
|
|
m_layout = new QVBoxLayout();
|
|
|
|
widget = new QWidget();
|
|
widget->setLayout(m_layout);
|
|
widget->setObjectName("shaderParamsWidget");
|
|
|
|
m_scrollArea = new QScrollArea();
|
|
|
|
m_scrollArea->setParent(this);
|
|
m_scrollArea->setWidgetResizable(true);
|
|
m_scrollArea->setWidget(widget);
|
|
m_scrollArea->setObjectName("shaderParamsScrollArea");
|
|
m_scrollArea->show();
|
|
}
|
|
|
|
void ShaderParamsDialog::getShaders(struct video_shader **menu_shader, struct video_shader **video_shader)
|
|
{
|
|
video_shader_ctx_t shader_info = {0};
|
|
struct video_shader *shader = menu_shader_get();
|
|
|
|
if (menu_shader)
|
|
{
|
|
if (shader)
|
|
*menu_shader = shader;
|
|
else
|
|
*menu_shader = NULL;
|
|
}
|
|
|
|
if (video_shader)
|
|
{
|
|
if (shader)
|
|
*video_shader = shader_info.data;
|
|
else
|
|
*video_shader = NULL;
|
|
}
|
|
|
|
if (video_shader)
|
|
{
|
|
if (!video_shader_driver_get_current_shader(&shader_info))
|
|
{
|
|
*video_shader = NULL;
|
|
return;
|
|
}
|
|
|
|
if (!shader_info.data || shader_info.data->num_parameters > GFX_MAX_PARAMETERS)
|
|
{
|
|
*video_shader = NULL;
|
|
return;
|
|
}
|
|
|
|
if (shader_info.data)
|
|
*video_shader = shader_info.data;
|
|
else
|
|
*video_shader = NULL;
|
|
}
|
|
}
|
|
|
|
void ShaderParamsDialog::onFilterComboBoxIndexChanged(int)
|
|
{
|
|
QVariant passVariant;
|
|
QComboBox *comboBox = qobject_cast<QComboBox*>(sender());
|
|
int pass = 0;
|
|
bool ok = false;
|
|
struct video_shader *menu_shader = NULL;
|
|
struct video_shader *video_shader = NULL;
|
|
|
|
getShaders(&menu_shader, &video_shader);
|
|
|
|
if (!comboBox)
|
|
return;
|
|
|
|
passVariant = comboBox->property("pass");
|
|
|
|
if (!passVariant.isValid())
|
|
return;
|
|
|
|
pass = passVariant.toInt(&ok);
|
|
|
|
if (!ok)
|
|
return;
|
|
|
|
if ( menu_shader
|
|
&& (pass >= 0)
|
|
&& (pass < static_cast<int>(menu_shader->passes)))
|
|
{
|
|
QVariant data = comboBox->currentData();
|
|
|
|
if (data.isValid())
|
|
{
|
|
unsigned filter = data.toUInt(&ok);
|
|
|
|
if (ok)
|
|
{
|
|
if (menu_shader)
|
|
menu_shader->pass[pass].filter = filter;
|
|
if (video_shader)
|
|
{
|
|
video_shader->pass[pass].filter = filter;
|
|
video_shader->flags |= SHDR_FLAG_MODIFIED;
|
|
}
|
|
|
|
command_event(CMD_EVENT_SHADERS_APPLY_CHANGES, NULL);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void ShaderParamsDialog::onScaleComboBoxIndexChanged(int)
|
|
{
|
|
QVariant passVariant;
|
|
QComboBox *comboBox = qobject_cast<QComboBox*>(sender());
|
|
int pass = 0;
|
|
bool ok = false;
|
|
struct video_shader *menu_shader = NULL;
|
|
struct video_shader *video_shader = NULL;
|
|
|
|
getShaders(&menu_shader, &video_shader);
|
|
|
|
if (!comboBox)
|
|
return;
|
|
|
|
passVariant = comboBox->property("pass");
|
|
|
|
if (!passVariant.isValid())
|
|
return;
|
|
|
|
pass = passVariant.toInt(&ok);
|
|
|
|
if (!ok)
|
|
return;
|
|
|
|
if (menu_shader && pass >= 0 && pass < static_cast<int>(menu_shader->passes))
|
|
{
|
|
QVariant data = comboBox->currentData();
|
|
|
|
if (data.isValid())
|
|
{
|
|
unsigned scale = data.toUInt(&ok);
|
|
|
|
if (ok)
|
|
{
|
|
if (menu_shader)
|
|
{
|
|
menu_shader->pass[pass].fbo.scale_x = scale;
|
|
menu_shader->pass[pass].fbo.scale_y = scale;
|
|
if (scale)
|
|
menu_shader->pass[pass].fbo.flags |= FBO_SCALE_FLAG_VALID;
|
|
else
|
|
menu_shader->pass[pass].fbo.flags &= ~FBO_SCALE_FLAG_VALID;
|
|
}
|
|
|
|
if (video_shader)
|
|
{
|
|
video_shader->pass[pass].fbo.scale_x = scale;
|
|
video_shader->pass[pass].fbo.scale_y = scale;
|
|
if (scale)
|
|
video_shader->pass[pass].fbo.flags |= FBO_SCALE_FLAG_VALID;
|
|
else
|
|
video_shader->pass[pass].fbo.flags &= ~FBO_SCALE_FLAG_VALID;
|
|
video_shader->flags |= SHDR_FLAG_MODIFIED;
|
|
}
|
|
|
|
command_event(CMD_EVENT_SHADERS_APPLY_CHANGES, NULL);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/* The pass a parameter belongs to follows from the order the sources
|
|
* sit in, so a swap is settled by resolving again rather than by
|
|
* moving indices by hand: a parameter both of the swapped passes
|
|
* declare belongs to whichever ends up first, which an index shift
|
|
* cannot work out. A resolve returns every parameter to its initial
|
|
* value, so the values in hand are carried across by id. */
|
|
static void shader_reresolve_keeping_values(struct video_shader *shader)
|
|
{
|
|
QHash<QString, float> values;
|
|
unsigned i;
|
|
|
|
if (!shader)
|
|
return;
|
|
|
|
for (i = 0; i < shader->num_parameters; i++)
|
|
values.insert(QString(shader->parameters[i].id),
|
|
video_shader_param_get(&shader->parameters[i]));
|
|
|
|
video_shader_resolve_parameters(shader);
|
|
|
|
for (i = 0; i < shader->num_parameters; i++)
|
|
{
|
|
QHash<QString, float>::const_iterator it =
|
|
values.constFind(QString(shader->parameters[i].id));
|
|
if (it != values.constEnd())
|
|
video_shader_param_set(&shader->parameters[i], it.value());
|
|
}
|
|
}
|
|
|
|
void ShaderParamsDialog::onShaderPassMoveDownClicked()
|
|
{
|
|
QVariant passVariant;
|
|
bool ok = false;
|
|
struct video_shader *menu_shader = NULL;
|
|
struct video_shader *video_shader = NULL;
|
|
QToolButton *button = qobject_cast<QToolButton*>(sender());
|
|
int pass = 0;
|
|
|
|
getShaders(&menu_shader, &video_shader);
|
|
|
|
if (!button)
|
|
return;
|
|
|
|
passVariant = button->property("pass");
|
|
|
|
if (!passVariant.isValid())
|
|
return;
|
|
|
|
pass = passVariant.toInt(&ok);
|
|
|
|
if (!ok || pass < 0)
|
|
return;
|
|
|
|
if (video_shader)
|
|
{
|
|
ShaderPass tempPass;
|
|
|
|
if (pass >= static_cast<int>(video_shader->passes) - 1)
|
|
return;
|
|
|
|
tempPass = ShaderPass(&video_shader->pass[pass]);
|
|
memcpy(&video_shader->pass[pass], &video_shader->pass[pass + 1], sizeof(struct video_shader_pass));
|
|
memcpy(&video_shader->pass[pass + 1], tempPass.pass, sizeof(struct video_shader_pass));
|
|
}
|
|
|
|
if (menu_shader)
|
|
{
|
|
ShaderPass tempPass;
|
|
|
|
if (pass >= static_cast<int>(menu_shader->passes) - 1)
|
|
return;
|
|
|
|
tempPass = ShaderPass(&menu_shader->pass[pass]);
|
|
memcpy(&menu_shader->pass[pass], &menu_shader->pass[pass + 1], sizeof(struct video_shader_pass));
|
|
memcpy(&menu_shader->pass[pass + 1], tempPass.pass, sizeof(struct video_shader_pass));
|
|
}
|
|
|
|
shader_reresolve_keeping_values(video_shader);
|
|
shader_reresolve_keeping_values(menu_shader);
|
|
|
|
if (menu_shader)
|
|
menu_shader->flags |= SHDR_FLAG_MODIFIED;
|
|
|
|
reload();
|
|
}
|
|
|
|
void ShaderParamsDialog::onShaderPassMoveUpClicked()
|
|
{
|
|
QVariant passVariant;
|
|
int pass = 0;
|
|
bool ok = false;
|
|
struct video_shader *menu_shader = NULL;
|
|
struct video_shader *video_shader = NULL;
|
|
QToolButton *button = qobject_cast<QToolButton*>(sender());
|
|
|
|
getShaders(&menu_shader, &video_shader);
|
|
|
|
if (!button)
|
|
return;
|
|
|
|
passVariant = button->property("pass");
|
|
|
|
if (!passVariant.isValid())
|
|
return;
|
|
|
|
pass = passVariant.toInt(&ok);
|
|
|
|
if (!ok || pass <= 0)
|
|
return;
|
|
|
|
if (video_shader)
|
|
{
|
|
ShaderPass tempPass;
|
|
|
|
if (pass > static_cast<int>(video_shader->passes) - 1)
|
|
return;
|
|
|
|
tempPass = ShaderPass(&video_shader->pass[pass - 1]);
|
|
memcpy(&video_shader->pass[pass - 1], &video_shader->pass[pass], sizeof(struct video_shader_pass));
|
|
memcpy(&video_shader->pass[pass], tempPass.pass, sizeof(struct video_shader_pass));
|
|
}
|
|
|
|
if (menu_shader)
|
|
{
|
|
ShaderPass tempPass;
|
|
|
|
if (pass > static_cast<int>(menu_shader->passes) - 1)
|
|
return;
|
|
|
|
tempPass = ShaderPass(&menu_shader->pass[pass - 1]);
|
|
memcpy(&menu_shader->pass[pass - 1], &menu_shader->pass[pass], sizeof(struct video_shader_pass));
|
|
memcpy(&menu_shader->pass[pass], tempPass.pass, sizeof(struct video_shader_pass));
|
|
}
|
|
|
|
shader_reresolve_keeping_values(video_shader);
|
|
shader_reresolve_keeping_values(menu_shader);
|
|
|
|
if (menu_shader)
|
|
menu_shader->flags |= SHDR_FLAG_MODIFIED;
|
|
|
|
reload();
|
|
}
|
|
|
|
void ShaderParamsDialog::onShaderLoadPresetClicked()
|
|
{
|
|
QString path, filter;
|
|
QByteArray pathArray;
|
|
gfx_ctx_flags_t flags;
|
|
struct video_shader *menu_shader = NULL;
|
|
struct video_shader *video_shader = NULL;
|
|
const char *pathData = NULL;
|
|
enum rarch_shader_type type = RARCH_SHADER_NONE;
|
|
#if !defined(HAVE_MENU)
|
|
settings_t *settings = config_get_ptr();
|
|
const char *shader_preset_dir = settings->paths.directory_video_shader;
|
|
#else
|
|
const char *shader_preset_dir = NULL;
|
|
menu_driver_get_last_shader_preset_path(&shader_preset_dir, NULL);
|
|
#endif
|
|
|
|
getShaders(&menu_shader, &video_shader);
|
|
|
|
if (!menu_shader)
|
|
return;
|
|
|
|
filter.append("Shader Preset (");
|
|
|
|
flags.flags = 0;
|
|
video_context_driver_get_flags(&flags);
|
|
|
|
/* NOTE: Maybe we should have a way to get a list
|
|
* of all shader types instead of hard-coding this? */
|
|
if (BIT32_GET(flags.flags, GFX_CTX_FLAGS_SHADERS_CG))
|
|
{
|
|
filter.append(QLatin1String(" *"));
|
|
filter.append(".cgp");
|
|
}
|
|
|
|
if (BIT32_GET(flags.flags, GFX_CTX_FLAGS_SHADERS_GLSL))
|
|
{
|
|
filter.append(QLatin1String(" *"));
|
|
filter.append(".glslp");
|
|
}
|
|
|
|
if (BIT32_GET(flags.flags, GFX_CTX_FLAGS_SHADERS_SLANG))
|
|
{
|
|
filter.append(QLatin1String(" *"));
|
|
filter.append(".slangp");
|
|
}
|
|
|
|
filter.append(")");
|
|
path = QFileDialog::getOpenFileName(
|
|
this,
|
|
msg_hash_to_str(MENU_ENUM_LABEL_VALUE_VIDEO_SHADER_PRESET),
|
|
shader_preset_dir, filter);
|
|
|
|
if (path.isEmpty())
|
|
return;
|
|
|
|
pathArray = path.toUtf8();
|
|
pathData = pathArray.constData();
|
|
type = video_shader_parse_type(pathData);
|
|
|
|
#if defined(HAVE_MENU)
|
|
/* Cache selected shader parent directory */
|
|
menu_driver_set_last_shader_preset_path(pathData);
|
|
#endif
|
|
|
|
menu_shader_manager_set_preset(menu_shader, type, pathData, true);
|
|
}
|
|
|
|
void ShaderParamsDialog::onShaderResetPass(int pass)
|
|
{
|
|
unsigned i;
|
|
struct video_shader *menu_shader = NULL;
|
|
struct video_shader *video_shader = NULL;
|
|
|
|
getShaders(&menu_shader, &video_shader);
|
|
|
|
if (menu_shader)
|
|
{
|
|
for (i = 0; i < menu_shader->num_parameters; i++)
|
|
{
|
|
struct video_shader_parameter *param = &menu_shader->parameters[i];
|
|
|
|
/* if pass < 0, reset all params,
|
|
* otherwise only reset the selected pass */
|
|
if (pass >= 0 && param->pass != pass)
|
|
continue;
|
|
|
|
video_shader_param_set(param, param->initial);
|
|
}
|
|
}
|
|
|
|
if (video_shader)
|
|
{
|
|
for (i = 0; i < video_shader->num_parameters; i++)
|
|
{
|
|
struct video_shader_parameter *param = &video_shader->parameters[i];
|
|
|
|
/* if pass < 0, reset all params,
|
|
* otherwise only reset the selected pass */
|
|
if (pass >= 0 && param->pass != pass)
|
|
continue;
|
|
|
|
video_shader_param_set(param, param->initial);
|
|
}
|
|
|
|
video_shader->flags |= SHDR_FLAG_MODIFIED;
|
|
}
|
|
|
|
reload();
|
|
}
|
|
|
|
void ShaderParamsDialog::onShaderResetParameter(QString parameter)
|
|
{
|
|
struct video_shader *menu_shader = NULL;
|
|
struct video_shader *video_shader = NULL;
|
|
|
|
getShaders(&menu_shader, &video_shader);
|
|
|
|
if (menu_shader)
|
|
{
|
|
int i;
|
|
struct video_shader_parameter *param = NULL;
|
|
|
|
for (i = 0; i < static_cast<int>(menu_shader->num_parameters); i++)
|
|
{
|
|
QString id = menu_shader->parameters[i].id;
|
|
|
|
if (id == parameter)
|
|
param = &menu_shader->parameters[i];
|
|
}
|
|
|
|
if (param)
|
|
video_shader_param_set(param, param->initial);
|
|
}
|
|
|
|
if (video_shader)
|
|
{
|
|
int i;
|
|
struct video_shader_parameter *param = NULL;
|
|
|
|
for (i = 0; i < static_cast<int>(video_shader->num_parameters); i++)
|
|
{
|
|
QString id = video_shader->parameters[i].id;
|
|
|
|
if (id == parameter)
|
|
param = &video_shader->parameters[i];
|
|
}
|
|
|
|
if (param)
|
|
video_shader_param_set(param, param->initial);
|
|
|
|
video_shader->flags |= SHDR_FLAG_MODIFIED;
|
|
}
|
|
|
|
reload();
|
|
}
|
|
|
|
void ShaderParamsDialog::onShaderResetAllPasses()
|
|
{
|
|
onShaderResetPass(-1);
|
|
}
|
|
|
|
void ShaderParamsDialog::onShaderAddPassClicked()
|
|
{
|
|
gfx_ctx_flags_t flags;
|
|
QString path, filter;
|
|
QByteArray pathArray;
|
|
struct video_shader *menu_shader = NULL;
|
|
struct video_shader *video_shader = NULL;
|
|
struct video_shader_pass *shader_pass = NULL;
|
|
const char *pathData = NULL;
|
|
#if !defined(HAVE_MENU)
|
|
settings_t *settings = config_get_ptr();
|
|
const char *shader_pass_dir = settings->paths.directory_video_shader;
|
|
#else
|
|
const char *shader_pass_dir = NULL;
|
|
|
|
menu_driver_get_last_shader_pass_path(&shader_pass_dir, NULL);
|
|
#endif
|
|
|
|
getShaders(&menu_shader, &video_shader);
|
|
|
|
if (!menu_shader)
|
|
return;
|
|
|
|
filter.append("Shader (");
|
|
|
|
flags.flags = 0;
|
|
video_context_driver_get_flags(&flags);
|
|
|
|
/* NOTE: Maybe we should have a way to get a list
|
|
* of all shader types instead of hard-coding this? */
|
|
if (BIT32_GET(flags.flags, GFX_CTX_FLAGS_SHADERS_CG))
|
|
filter.append(QLatin1String(" *.cg"));
|
|
if (BIT32_GET(flags.flags, GFX_CTX_FLAGS_SHADERS_GLSL))
|
|
filter.append(QLatin1String(" *.glsl"));
|
|
if (BIT32_GET(flags.flags, GFX_CTX_FLAGS_SHADERS_SLANG))
|
|
filter.append(QLatin1String(" *.slang"));
|
|
|
|
filter.append(")");
|
|
|
|
path = QFileDialog::getOpenFileName(
|
|
this,
|
|
msg_hash_to_str(MENU_ENUM_LABEL_VALUE_VIDEO_SHADER_PRESET),
|
|
shader_pass_dir, filter);
|
|
|
|
if (path.isEmpty())
|
|
return;
|
|
|
|
/* Qt uses '/' as a directory separator regardless
|
|
* of host platform. Have to convert to native separators,
|
|
* or video_shader_resolve_parameters() will fail on
|
|
* non-Linux platforms */
|
|
path = QDir::toNativeSeparators(path);
|
|
|
|
pathArray = path.toUtf8();
|
|
pathData = pathArray.constData();
|
|
|
|
if (menu_shader->passes < GFX_MAX_SHADERS)
|
|
menu_shader->passes++;
|
|
else
|
|
return;
|
|
|
|
menu_shader->flags |= SHDR_FLAG_MODIFIED;
|
|
shader_pass = &menu_shader->pass[menu_shader->passes - 1];
|
|
|
|
if (!shader_pass)
|
|
return;
|
|
|
|
strlcpy(shader_pass->source.path,
|
|
pathData,
|
|
sizeof(shader_pass->source.path));
|
|
|
|
#if defined(HAVE_MENU)
|
|
/* Cache selected shader parent directory */
|
|
menu_driver_set_last_shader_pass_path(pathData);
|
|
#endif
|
|
|
|
video_shader_resolve_parameters(menu_shader);
|
|
|
|
command_event(CMD_EVENT_SHADERS_APPLY_CHANGES, NULL);
|
|
}
|
|
|
|
void ShaderParamsDialog::onShaderSavePresetAsClicked()
|
|
{
|
|
QByteArray pathArray;
|
|
const char *pathData = NULL;
|
|
settings_t *settings = config_get_ptr();
|
|
const char *path_dir_video_shader = settings->paths.directory_video_shader;
|
|
QString path = QFileDialog::getSaveFileName(this, msg_hash_to_str(MENU_ENUM_LABEL_VALUE_VIDEO_SHADER_PRESET_SAVE_AS), path_dir_video_shader);
|
|
|
|
if (path.isEmpty())
|
|
return;
|
|
|
|
pathArray = path.toUtf8();
|
|
pathData = pathArray.constData();
|
|
|
|
operateShaderPreset(true, pathData, QT_SHADER_PRESET_NORMAL);
|
|
}
|
|
|
|
/** save or remove shader preset */
|
|
void ShaderParamsDialog::operateShaderPreset(bool save, const char *path, unsigned action_type)
|
|
{
|
|
bool ret;
|
|
enum auto_shader_type preset_type;
|
|
settings_t *settings = config_get_ptr();
|
|
const char *path_dir_video_shader = settings->paths.directory_video_shader;
|
|
const char *path_dir_menu_config = settings->paths.directory_menu_config;
|
|
|
|
switch (action_type)
|
|
{
|
|
case QT_SHADER_PRESET_GLOBAL:
|
|
preset_type = SHADER_PRESET_GLOBAL;
|
|
break;
|
|
case QT_SHADER_PRESET_CORE:
|
|
preset_type = SHADER_PRESET_CORE;
|
|
break;
|
|
case QT_SHADER_PRESET_PARENT:
|
|
preset_type = SHADER_PRESET_PARENT;
|
|
break;
|
|
case QT_SHADER_PRESET_GAME:
|
|
preset_type = SHADER_PRESET_GAME;
|
|
break;
|
|
case QT_SHADER_PRESET_NORMAL:
|
|
break;
|
|
default:
|
|
return;
|
|
}
|
|
|
|
if (save)
|
|
{
|
|
if (action_type == QT_SHADER_PRESET_NORMAL)
|
|
ret = menu_shader_manager_save_preset(
|
|
menu_shader_get(),
|
|
path,
|
|
path_dir_video_shader,
|
|
path_dir_menu_config,
|
|
true);
|
|
else
|
|
ret = menu_shader_manager_save_auto_preset(
|
|
menu_shader_get(),
|
|
preset_type,
|
|
path_dir_video_shader,
|
|
path_dir_menu_config,
|
|
true);
|
|
|
|
if (ret)
|
|
{
|
|
const char *_msg = msg_hash_to_str(MSG_SHADER_PRESET_SAVED_SUCCESSFULLY);
|
|
runloop_msg_queue_push(_msg, strlen(_msg), 1, 100, true, NULL,
|
|
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
|
|
}
|
|
else
|
|
{
|
|
const char *_msg = msg_hash_to_str(MSG_ERROR_SAVING_SHADER_PRESET);
|
|
runloop_msg_queue_push(_msg, strlen(_msg), 1, 100, true, NULL,
|
|
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_ERROR);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (action_type != QT_SHADER_PRESET_NORMAL &&
|
|
menu_shader_manager_remove_auto_preset(preset_type,
|
|
path_dir_video_shader,
|
|
path_dir_menu_config))
|
|
{
|
|
const char *_msg = msg_hash_to_str(MSG_SHADER_PRESET_REMOVED_SUCCESSFULLY);
|
|
runloop_msg_queue_push(_msg, strlen(_msg), 1, 100, true, NULL,
|
|
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
|
|
|
|
#ifdef HAVE_MENU
|
|
menu_state_get_ptr()->flags |= MENU_ST_FLAG_ENTRIES_NEED_REFRESH;
|
|
#endif
|
|
}
|
|
else
|
|
{
|
|
const char *_msg = msg_hash_to_str(MSG_ERROR_REMOVING_SHADER_PRESET);
|
|
runloop_msg_queue_push(_msg, strlen(_msg), 1, 100, true, NULL,
|
|
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_ERROR);
|
|
}
|
|
}
|
|
}
|
|
|
|
void ShaderParamsDialog::onShaderSaveGlobalPresetClicked()
|
|
{
|
|
operateShaderPreset(true, NULL, QT_SHADER_PRESET_GLOBAL);
|
|
}
|
|
|
|
void ShaderParamsDialog::onShaderSaveCorePresetClicked()
|
|
{
|
|
operateShaderPreset(true, NULL, QT_SHADER_PRESET_CORE);
|
|
}
|
|
|
|
void ShaderParamsDialog::onShaderSaveParentPresetClicked()
|
|
{
|
|
operateShaderPreset(true, NULL, QT_SHADER_PRESET_PARENT);
|
|
}
|
|
|
|
void ShaderParamsDialog::onShaderSaveGamePresetClicked()
|
|
{
|
|
operateShaderPreset(true, NULL, QT_SHADER_PRESET_GAME);
|
|
}
|
|
|
|
void ShaderParamsDialog::onShaderRemoveGlobalPresetClicked()
|
|
{
|
|
operateShaderPreset(false, NULL, QT_SHADER_PRESET_GLOBAL);
|
|
}
|
|
|
|
void ShaderParamsDialog::onShaderRemoveCorePresetClicked()
|
|
{
|
|
operateShaderPreset(false, NULL, QT_SHADER_PRESET_CORE);
|
|
}
|
|
|
|
void ShaderParamsDialog::onShaderRemoveParentPresetClicked()
|
|
{
|
|
operateShaderPreset(false, NULL, QT_SHADER_PRESET_PARENT);
|
|
}
|
|
|
|
void ShaderParamsDialog::onShaderRemoveGamePresetClicked()
|
|
{
|
|
operateShaderPreset(false, NULL, QT_SHADER_PRESET_GAME);
|
|
}
|
|
|
|
void ShaderParamsDialog::onShaderRemoveAllPassesClicked()
|
|
{
|
|
struct video_shader *menu_shader = NULL;
|
|
struct video_shader *video_shader = NULL;
|
|
|
|
getShaders(&menu_shader, &video_shader);
|
|
|
|
if (!menu_shader)
|
|
return;
|
|
|
|
menu_shader->passes = 0;
|
|
menu_shader->flags |= SHDR_FLAG_MODIFIED;
|
|
|
|
onShaderApplyClicked();
|
|
}
|
|
|
|
void ShaderParamsDialog::onShaderRemovePassClicked()
|
|
{
|
|
QVariant passVariant;
|
|
QAction *action = qobject_cast<QAction*>(sender());
|
|
int pass = 0;
|
|
bool ok = false;
|
|
|
|
if (!action)
|
|
return;
|
|
passVariant = action->data();
|
|
|
|
if (!passVariant.isValid())
|
|
return;
|
|
|
|
pass = passVariant.toInt(&ok);
|
|
|
|
if (!ok)
|
|
return;
|
|
|
|
onShaderRemovePass(pass);
|
|
}
|
|
|
|
void ShaderParamsDialog::onShaderRemovePass(int pass)
|
|
{
|
|
int i;
|
|
struct video_shader *menu_shader = NULL;
|
|
struct video_shader *video_shader = NULL;
|
|
|
|
getShaders(&menu_shader, &video_shader);
|
|
|
|
if (!menu_shader || menu_shader->passes == 0)
|
|
return;
|
|
|
|
if (pass < 0 || pass > static_cast<int>(menu_shader->passes))
|
|
return;
|
|
|
|
/* move selected pass to the bottom */
|
|
for (i = pass; i < static_cast<int>(menu_shader->passes) - 1; i++)
|
|
std::swap(menu_shader->pass[i], menu_shader->pass[i + 1]);
|
|
|
|
menu_shader->passes--;
|
|
|
|
menu_shader->flags |= SHDR_FLAG_MODIFIED;
|
|
|
|
onShaderApplyClicked();
|
|
}
|
|
|
|
void ShaderParamsDialog::onShaderApplyClicked()
|
|
{
|
|
command_event(CMD_EVENT_SHADERS_APPLY_CHANGES, NULL);
|
|
}
|
|
|
|
void ShaderParamsDialog::updateRemovePresetButtonsState()
|
|
{
|
|
settings_t *settings = config_get_ptr();
|
|
const char *path_dir_video_shader = settings->paths.directory_video_shader;
|
|
const char *path_dir_menu_config = settings->paths.directory_menu_config;
|
|
|
|
if (removeGlobalPresetAction)
|
|
removeGlobalPresetAction->setEnabled(
|
|
menu_shader_manager_auto_preset_exists(
|
|
SHADER_PRESET_GLOBAL,
|
|
path_dir_video_shader,
|
|
path_dir_menu_config
|
|
));
|
|
if (removeCorePresetAction)
|
|
removeCorePresetAction->setEnabled(
|
|
menu_shader_manager_auto_preset_exists(
|
|
SHADER_PRESET_CORE,
|
|
path_dir_video_shader,
|
|
path_dir_menu_config
|
|
));
|
|
if (removeParentPresetAction)
|
|
removeParentPresetAction->setEnabled(
|
|
menu_shader_manager_auto_preset_exists(
|
|
SHADER_PRESET_PARENT,
|
|
path_dir_video_shader,
|
|
path_dir_menu_config
|
|
));
|
|
if (removeGamePresetAction)
|
|
removeGamePresetAction->setEnabled(
|
|
menu_shader_manager_auto_preset_exists(
|
|
SHADER_PRESET_GAME,
|
|
path_dir_video_shader,
|
|
path_dir_menu_config
|
|
));
|
|
}
|
|
|
|
void ShaderParamsDialog::reload()
|
|
{
|
|
buildLayout();
|
|
}
|
|
|
|
void ShaderParamsDialog::buildLayout()
|
|
{
|
|
unsigned i;
|
|
bool hasPasses = false;
|
|
#if defined(HAVE_MENU)
|
|
CheckableSettingsGroup *topSettingsGroup = NULL;
|
|
#endif
|
|
QPushButton *loadButton = NULL;
|
|
QPushButton *saveButton = NULL;
|
|
QPushButton *removeButton = NULL;
|
|
QPushButton *removePassButton = NULL;
|
|
QPushButton *applyButton = NULL;
|
|
QHBoxLayout *topButtonLayout = NULL;
|
|
QMenu *loadMenu = NULL;
|
|
QMenu *saveMenu = NULL;
|
|
QMenu *removeMenu = NULL;
|
|
QMenu *removePassMenu = NULL;
|
|
struct video_shader *menu_shader = NULL;
|
|
struct video_shader *video_shader = NULL;
|
|
struct video_shader *avail_shader = NULL;
|
|
const char *shader_path = NULL;
|
|
|
|
getShaders(&menu_shader, &video_shader);
|
|
|
|
/* NOTE: For some reason, menu_shader_get() returns a COPY
|
|
* of what get_current_shader() gives us.
|
|
* And if you want to be able to change shader settings/parameters
|
|
* from both the raster menu and
|
|
* Qt at the same time... you must change BOTH or one will
|
|
* overwrite the other.
|
|
*
|
|
* AND, during a context reset, video_shader will be NULL
|
|
* but not menu_shader, so don't totally bail
|
|
* just because video_shader is NULL.
|
|
*
|
|
* Someone please fix this mess.
|
|
*/
|
|
|
|
if (video_shader)
|
|
{
|
|
avail_shader = video_shader;
|
|
|
|
if (video_shader->passes == 0)
|
|
setWindowTitle(msg_hash_to_str(MENU_ENUM_LABEL_VALUE_SHADER_OPTIONS));
|
|
}
|
|
/* Normally we'd only use video_shader,
|
|
* but the Vulkan driver returns a NULL shader when there
|
|
* are zero passes, so just fall back to menu_shader.
|
|
*/
|
|
else if (menu_shader)
|
|
{
|
|
avail_shader = menu_shader;
|
|
|
|
if (menu_shader->passes == 0)
|
|
setWindowTitle(msg_hash_to_str(MENU_ENUM_LABEL_VALUE_SHADER_OPTIONS));
|
|
}
|
|
else
|
|
{
|
|
setWindowTitle(msg_hash_to_str(MENU_ENUM_LABEL_VALUE_SHADER_OPTIONS));
|
|
|
|
/* no shader is available yet, just keep retrying until it is */
|
|
QTimer::singleShot(0, this, SLOT(buildLayout()));
|
|
return;
|
|
}
|
|
|
|
clearLayout();
|
|
|
|
/* Only check video_shader for the path, menu_shader seems stale...
|
|
* e.g. if you remove all the shader passes,
|
|
* it still has the old path in it, but video_shader does not
|
|
*/
|
|
if (video_shader)
|
|
{
|
|
if (*video_shader->path)
|
|
{
|
|
shader_path = video_shader->path;
|
|
setWindowTitle(QString(msg_hash_to_str(MENU_ENUM_LABEL_VALUE_QT_CURRENT_SHADER)) + ": " + QFileInfo(shader_path).fileName());
|
|
}
|
|
}
|
|
else if (menu_shader)
|
|
{
|
|
if (*menu_shader->path)
|
|
{
|
|
shader_path = menu_shader->path;
|
|
setWindowTitle(QString(msg_hash_to_str(MENU_ENUM_LABEL_VALUE_QT_CURRENT_SHADER)) + ": " + QFileInfo(shader_path).fileName());
|
|
}
|
|
}
|
|
else
|
|
setWindowTitle(msg_hash_to_str(MENU_ENUM_LABEL_VALUE_SHADER_OPTIONS));
|
|
|
|
loadButton = new QPushButton(msg_hash_to_str(MENU_ENUM_LABEL_VALUE_QT_LOAD), this);
|
|
saveButton = new QPushButton(msg_hash_to_str(MENU_ENUM_LABEL_VALUE_QT_SAVE), this);
|
|
removeButton = new QPushButton(msg_hash_to_str(MENU_ENUM_LABEL_VALUE_QT_REMOVE), this);
|
|
removePassButton = new QPushButton(msg_hash_to_str(MENU_ENUM_LABEL_VALUE_QT_REMOVE_PASSES), this);
|
|
applyButton = new QPushButton(msg_hash_to_str(MENU_ENUM_LABEL_VALUE_QT_APPLY), this);
|
|
|
|
loadMenu = new QMenu(loadButton);
|
|
|
|
loadMenu->addAction(msg_hash_to_str(MENU_ENUM_LABEL_VALUE_VIDEO_SHADER_PRESET), this, SLOT(onShaderLoadPresetClicked()));
|
|
loadMenu->addAction(msg_hash_to_str(MENU_ENUM_LABEL_VALUE_QT_SHADER_ADD_PASS), this, SLOT(onShaderAddPassClicked()));
|
|
|
|
loadButton->setMenu(loadMenu);
|
|
|
|
saveMenu = new QMenu(saveButton);
|
|
saveMenu->addAction(QString(msg_hash_to_str(MENU_ENUM_LABEL_VALUE_VIDEO_SHADER_PRESET_SAVE_AS)) + "...", this, SLOT(onShaderSavePresetAsClicked()));
|
|
saveMenu->addAction(msg_hash_to_str(MENU_ENUM_LABEL_VALUE_VIDEO_SHADER_PRESET_SAVE_GLOBAL), this, SLOT(onShaderSaveGlobalPresetClicked()));
|
|
saveMenu->addAction(msg_hash_to_str(MENU_ENUM_LABEL_VALUE_VIDEO_SHADER_PRESET_SAVE_CORE), this, SLOT(onShaderSaveCorePresetClicked()));
|
|
saveMenu->addAction(msg_hash_to_str(MENU_ENUM_LABEL_VALUE_VIDEO_SHADER_PRESET_SAVE_PARENT), this, SLOT(onShaderSaveParentPresetClicked()));
|
|
saveMenu->addAction(msg_hash_to_str(MENU_ENUM_LABEL_VALUE_VIDEO_SHADER_PRESET_SAVE_GAME), this, SLOT(onShaderSaveGamePresetClicked()));
|
|
|
|
saveButton->setMenu(saveMenu);
|
|
|
|
removeMenu = new QMenu(removeButton);
|
|
removeGlobalPresetAction = removeMenu->addAction(msg_hash_to_str(MENU_ENUM_LABEL_VALUE_VIDEO_SHADER_PRESET_REMOVE_GLOBAL), this, SLOT(onShaderRemoveGlobalPresetClicked()));
|
|
removeCorePresetAction = removeMenu->addAction(msg_hash_to_str(MENU_ENUM_LABEL_VALUE_VIDEO_SHADER_PRESET_REMOVE_CORE), this, SLOT(onShaderRemoveCorePresetClicked()));
|
|
removeParentPresetAction = removeMenu->addAction(msg_hash_to_str(MENU_ENUM_LABEL_VALUE_VIDEO_SHADER_PRESET_REMOVE_PARENT), this, SLOT(onShaderRemoveParentPresetClicked()));
|
|
removeGamePresetAction = removeMenu->addAction(msg_hash_to_str(MENU_ENUM_LABEL_VALUE_VIDEO_SHADER_PRESET_REMOVE_GAME), this, SLOT(onShaderRemoveGamePresetClicked()));
|
|
|
|
removeButton->setMenu(removeMenu);
|
|
|
|
connect(removeMenu, SIGNAL(aboutToShow()), this, SLOT(updateRemovePresetButtonsState()));
|
|
|
|
removePassMenu = new QMenu(removeButton);
|
|
|
|
/* When there are no passes, at least on first startup, it seems video_shader erroneously shows 1 pass, with an empty source file.
|
|
* So we use menu_shader instead for that.
|
|
*/
|
|
if (menu_shader)
|
|
{
|
|
for (i = 0; i < menu_shader->passes; i++)
|
|
{
|
|
QFileInfo fileInfo(menu_shader->pass[i].source.path);
|
|
QString shaderBasename = fileInfo.completeBaseName();
|
|
QAction *action = removePassMenu->addAction(shaderBasename, this, SLOT(onShaderRemovePassClicked()));
|
|
|
|
action->setData(i);
|
|
}
|
|
}
|
|
|
|
removePassMenu->addAction(msg_hash_to_str(MENU_ENUM_LABEL_VALUE_QT_SHADER_CLEAR_ALL_PASSES), this, SLOT(onShaderRemoveAllPassesClicked()));
|
|
|
|
removePassButton->setMenu(removePassMenu);
|
|
|
|
connect(applyButton, SIGNAL(clicked()), this, SLOT(onShaderApplyClicked()));
|
|
|
|
#if defined(HAVE_MENU)
|
|
topSettingsGroup = new CheckableSettingsGroup(MENU_ENUM_LABEL_VIDEO_SHADERS_ENABLE);
|
|
topSettingsGroup->add(MENU_ENUM_LABEL_VIDEO_SHADER_PRESET_SAVE_REFERENCE);
|
|
topSettingsGroup->add(MENU_ENUM_LABEL_SHADER_WATCH_FOR_CHANGES);
|
|
topSettingsGroup->add(MENU_ENUM_LABEL_VIDEO_SHADER_REMEMBER_LAST_DIR);
|
|
#endif
|
|
|
|
topButtonLayout = new QHBoxLayout();
|
|
topButtonLayout->addWidget(loadButton);
|
|
topButtonLayout->addWidget(saveButton);
|
|
topButtonLayout->addWidget(removeButton);
|
|
topButtonLayout->addWidget(removePassButton);
|
|
topButtonLayout->addWidget(applyButton);
|
|
|
|
#if defined(HAVE_MENU)
|
|
m_layout->addWidget(topSettingsGroup);
|
|
#endif
|
|
m_layout->addLayout(topButtonLayout);
|
|
|
|
/* NOTE: We assume that parameters are always grouped in order by the pass number, e.g., all parameters for pass 0 come first, then params for pass 1, etc. */
|
|
for (i = 0; avail_shader && i < avail_shader->passes; i++)
|
|
{
|
|
QFormLayout *form = NULL;
|
|
QGroupBox *groupBox = NULL;
|
|
QFileInfo fileInfo(avail_shader->pass[i].source.path);
|
|
QString shaderBasename = fileInfo.completeBaseName();
|
|
QHBoxLayout *filterScaleHBoxLayout = NULL;
|
|
QComboBox *filterComboBox = new QComboBox(this);
|
|
QComboBox *scaleComboBox = new QComboBox(this);
|
|
QToolButton *moveDownButton = NULL;
|
|
QToolButton *moveUpButton = NULL;
|
|
unsigned j = 0;
|
|
|
|
/* Sometimes video_shader shows 1 pass with no source file, when there are really 0 passes. */
|
|
if (shaderBasename.isEmpty())
|
|
continue;
|
|
|
|
hasPasses = true;
|
|
|
|
filterComboBox->setProperty("pass", i);
|
|
scaleComboBox->setProperty("pass", i);
|
|
|
|
moveDownButton = new QToolButton(this);
|
|
moveDownButton->setText("↓");
|
|
moveDownButton->setProperty("pass", i);
|
|
|
|
moveUpButton = new QToolButton(this);
|
|
moveUpButton->setText("↑");
|
|
moveUpButton->setProperty("pass", i);
|
|
|
|
/* Can't move down if we're already at the bottom. */
|
|
if (i < avail_shader->passes - 1)
|
|
connect(moveDownButton, SIGNAL(clicked()),
|
|
this, SLOT(onShaderPassMoveDownClicked()));
|
|
else
|
|
moveDownButton->setDisabled(true);
|
|
|
|
/* Can't move up if we're already at the top. */
|
|
if (i > 0)
|
|
connect(moveUpButton, SIGNAL(clicked()),
|
|
this, SLOT(onShaderPassMoveUpClicked()));
|
|
else
|
|
moveUpButton->setDisabled(true);
|
|
|
|
for (;;)
|
|
{
|
|
QString filterLabel = getFilterLabel(j);
|
|
|
|
if (filterLabel.isEmpty())
|
|
break;
|
|
|
|
if (j == 0)
|
|
filterLabel = msg_hash_to_str(MENU_ENUM_LABEL_VALUE_DONT_CARE);
|
|
|
|
filterComboBox->addItem(filterLabel, j);
|
|
|
|
j++;
|
|
}
|
|
|
|
for (j = 0; j < 7; j++)
|
|
{
|
|
QString label;
|
|
|
|
if (j == 0)
|
|
label = msg_hash_to_str(MENU_ENUM_LABEL_VALUE_DONT_CARE);
|
|
else
|
|
label = QString::number(j) + "x";
|
|
|
|
scaleComboBox->addItem(label, j);
|
|
}
|
|
|
|
filterComboBox->setCurrentIndex(static_cast<int>(avail_shader->pass[i].filter));
|
|
scaleComboBox->setCurrentIndex(static_cast<int>(avail_shader->pass[i].fbo.scale_x));
|
|
|
|
/* connect the signals only after the initial index is set */
|
|
connect(filterComboBox, SIGNAL(currentIndexChanged(int)), this, SLOT(onFilterComboBoxIndexChanged(int)));
|
|
connect(scaleComboBox, SIGNAL(currentIndexChanged(int)), this, SLOT(onScaleComboBoxIndexChanged(int)));
|
|
|
|
form = new QFormLayout();
|
|
groupBox = new QGroupBox(shaderBasename);
|
|
groupBox->setLayout(form);
|
|
groupBox->setProperty("pass", i);
|
|
groupBox->setContextMenuPolicy(Qt::CustomContextMenu);
|
|
|
|
connect(groupBox, SIGNAL(customContextMenuRequested(const QPoint&)), this, SLOT(onGroupBoxContextMenuRequested(const QPoint&)));
|
|
|
|
m_layout->addWidget(groupBox);
|
|
|
|
filterScaleHBoxLayout = new QHBoxLayout();
|
|
filterScaleHBoxLayout->addSpacerItem(new QSpacerItem(0, 0, QSizePolicy::Expanding, QSizePolicy::Preferred));
|
|
filterScaleHBoxLayout->addWidget(new QLabel(QString(msg_hash_to_str(MENU_ENUM_LABEL_VALUE_FILTER)) + ":", this));
|
|
filterScaleHBoxLayout->addWidget(filterComboBox);
|
|
filterScaleHBoxLayout->addWidget(new QLabel(QString(msg_hash_to_str(MENU_ENUM_LABEL_VALUE_SCALE)) + ":", this));
|
|
filterScaleHBoxLayout->addWidget(scaleComboBox);
|
|
filterScaleHBoxLayout->addSpacerItem(new QSpacerItem(20, 0, QSizePolicy::Preferred, QSizePolicy::Preferred));
|
|
|
|
if (moveUpButton)
|
|
filterScaleHBoxLayout->addWidget(moveUpButton);
|
|
|
|
if (moveDownButton)
|
|
filterScaleHBoxLayout->addWidget(moveDownButton);
|
|
|
|
form->addRow("", filterScaleHBoxLayout);
|
|
|
|
for (j = 0; j < avail_shader->num_parameters; j++)
|
|
{
|
|
struct video_shader_parameter *param = &avail_shader->parameters[j];
|
|
|
|
if (param->pass != static_cast<int>(i))
|
|
continue;
|
|
|
|
addShaderParam(param, form);
|
|
}
|
|
}
|
|
|
|
if (!hasPasses)
|
|
{
|
|
QLabel *noParamsLabel = new QLabel(msg_hash_to_str(MENU_ENUM_LABEL_VALUE_QT_SHADER_NO_PASSES), this);
|
|
noParamsLabel->setAlignment(Qt::AlignCenter);
|
|
|
|
m_layout->addWidget(noParamsLabel);
|
|
}
|
|
|
|
m_layout->addItem(new QSpacerItem(20, 20, QSizePolicy::Minimum, QSizePolicy::Expanding));
|
|
|
|
/* Why is this required?? The layout is corrupt without both resizes. */
|
|
resize(width() + 1, height());
|
|
show();
|
|
resize(width() - 1, height());
|
|
}
|
|
|
|
void ShaderParamsDialog::onParameterLabelContextMenuRequested(const QPoint&)
|
|
{
|
|
QVariant paramVariant;
|
|
QString parameter;
|
|
QPointer<QAction> action;
|
|
QList<QAction*> actions;
|
|
QScopedPointer<QAction> resetParamAction;
|
|
QLabel *label = qobject_cast<QLabel*>(sender());
|
|
|
|
if (!label)
|
|
return;
|
|
|
|
paramVariant = label->property("parameter");
|
|
|
|
if (!paramVariant.isValid())
|
|
return;
|
|
|
|
parameter = paramVariant.toString();
|
|
|
|
resetParamAction.reset(new QAction(msg_hash_to_str(MENU_ENUM_LABEL_VALUE_QT_RESET_PARAMETER), 0));
|
|
|
|
actions.append(resetParamAction.data());
|
|
|
|
action = QMenu::exec(actions, QCursor::pos(), NULL, label);
|
|
|
|
if (!action)
|
|
return;
|
|
|
|
if (action == resetParamAction.data())
|
|
onShaderResetParameter(parameter);
|
|
}
|
|
|
|
void ShaderParamsDialog::onGroupBoxContextMenuRequested(const QPoint&)
|
|
{
|
|
QPointer<QAction> action;
|
|
QList<QAction*> actions;
|
|
QScopedPointer<QAction> resetPassAction;
|
|
QScopedPointer<QAction> resetAllPassesAction;
|
|
QVariant passVariant;
|
|
int pass = 0;
|
|
bool ok = false;
|
|
QGroupBox *groupBox = qobject_cast<QGroupBox*>(sender());
|
|
|
|
if (!groupBox)
|
|
return;
|
|
|
|
passVariant = groupBox->property("pass");
|
|
|
|
if (!passVariant.isValid())
|
|
return;
|
|
|
|
pass = passVariant.toInt(&ok);
|
|
|
|
if (!ok)
|
|
return;
|
|
|
|
resetPassAction.reset(new QAction(msg_hash_to_str(MENU_ENUM_LABEL_VALUE_QT_RESET_PASS), 0));
|
|
resetAllPassesAction.reset(new QAction(msg_hash_to_str(MENU_ENUM_LABEL_VALUE_QT_RESET_ALL_PASSES), 0));
|
|
|
|
actions.append(resetPassAction.data());
|
|
actions.append(resetAllPassesAction.data());
|
|
|
|
action = QMenu::exec(actions, QCursor::pos(), NULL, groupBox);
|
|
|
|
if (!action)
|
|
return;
|
|
|
|
if (action == resetPassAction.data())
|
|
onShaderResetPass(pass);
|
|
else if (action == resetAllPassesAction.data())
|
|
onShaderResetAllPasses();
|
|
}
|
|
|
|
void ShaderParamsDialog::addShaderParam(struct video_shader_parameter *param, QFormLayout *form)
|
|
{
|
|
QString desc = param->desc;
|
|
QString parameter = param->id;
|
|
QLabel *label = new QLabel(desc);
|
|
|
|
label->setProperty("parameter", parameter);
|
|
label->setContextMenuPolicy(Qt::CustomContextMenu);
|
|
|
|
connect(label, SIGNAL(customContextMenuRequested(const QPoint&)), this, SLOT(onParameterLabelContextMenuRequested(const QPoint&)));
|
|
|
|
if ((param->minimum == 0.0)
|
|
&& (param->maximum
|
|
== (param->minimum
|
|
+ param->step)))
|
|
{
|
|
/* option is basically a bool, so use a checkbox */
|
|
QCheckBox *checkBox = new QCheckBox(this);
|
|
checkBox->setChecked(video_shader_param_get(param) == param->maximum ? true : false);
|
|
checkBox->setProperty("param", parameter);
|
|
|
|
connect(checkBox, SIGNAL(clicked()), this, SLOT(onShaderParamCheckBoxClicked()));
|
|
|
|
form->addRow(label, checkBox);
|
|
}
|
|
else
|
|
{
|
|
QDoubleSpinBox *doubleSpinBox = NULL;
|
|
QSpinBox *spinBox = NULL;
|
|
QHBoxLayout *box = new QHBoxLayout();
|
|
QSlider *slider = new QSlider(Qt::Horizontal, this);
|
|
double value = lerp(
|
|
param->minimum, param->maximum, 0, 100, video_shader_param_get(param));
|
|
double intpart = 0;
|
|
bool stepIsFractional = modf(param->step, &intpart);
|
|
|
|
slider->setRange(0, 100);
|
|
slider->setSingleStep(1);
|
|
slider->setValue(value);
|
|
slider->setProperty("param", parameter);
|
|
|
|
connect(slider, SIGNAL(valueChanged(int)),
|
|
this, SLOT(onShaderParamSliderValueChanged(int)));
|
|
|
|
box->addWidget(slider);
|
|
|
|
if (stepIsFractional)
|
|
{
|
|
doubleSpinBox = new QDoubleSpinBox(this);
|
|
doubleSpinBox->setRange(param->minimum, param->maximum);
|
|
doubleSpinBox->setSingleStep(param->step);
|
|
doubleSpinBox->setValue(video_shader_param_get(param));
|
|
doubleSpinBox->setProperty("slider", QVariant::fromValue(slider));
|
|
slider->setProperty("doubleSpinBox", QVariant::fromValue(doubleSpinBox));
|
|
|
|
connect(doubleSpinBox, SIGNAL(valueChanged(double)), this, SLOT(onShaderParamDoubleSpinBoxValueChanged(double)));
|
|
|
|
box->addWidget(doubleSpinBox);
|
|
}
|
|
else
|
|
{
|
|
spinBox = new QSpinBox(this);
|
|
spinBox->setRange(param->minimum, param->maximum);
|
|
spinBox->setSingleStep(param->step);
|
|
spinBox->setValue(video_shader_param_get(param));
|
|
spinBox->setProperty("slider", QVariant::fromValue(slider));
|
|
slider->setProperty("spinBox", QVariant::fromValue(spinBox));
|
|
|
|
connect(spinBox, SIGNAL(valueChanged(int)), this, SLOT(onShaderParamSpinBoxValueChanged(int)));
|
|
|
|
box->addWidget(spinBox);
|
|
}
|
|
|
|
form->addRow(label, box);
|
|
}
|
|
}
|
|
|
|
void ShaderParamsDialog::onShaderParamCheckBoxClicked()
|
|
{
|
|
QVariant paramVariant;
|
|
QCheckBox *checkBox = qobject_cast<QCheckBox*>(sender());
|
|
struct video_shader *menu_shader = NULL;
|
|
struct video_shader *video_shader = NULL;
|
|
|
|
getShaders(&menu_shader, &video_shader);
|
|
|
|
if (!checkBox)
|
|
return;
|
|
|
|
if (menu_shader && menu_shader->passes == 0)
|
|
return;
|
|
|
|
paramVariant = checkBox->property("param");
|
|
|
|
if (paramVariant.isValid())
|
|
{
|
|
QString parameter = paramVariant.toString();
|
|
|
|
if (menu_shader)
|
|
{
|
|
int i;
|
|
struct video_shader_parameter *param = NULL;
|
|
|
|
for (i = 0; i < static_cast<int>(menu_shader->num_parameters); i++)
|
|
{
|
|
QString id = menu_shader->parameters[i].id;
|
|
|
|
if (id == parameter)
|
|
param = &menu_shader->parameters[i];
|
|
}
|
|
|
|
if (param)
|
|
video_shader_param_set(param, (checkBox->isChecked() ? param->maximum : param->minimum));
|
|
}
|
|
|
|
if (video_shader)
|
|
{
|
|
int i;
|
|
struct video_shader_parameter *param = NULL;
|
|
|
|
for (i = 0; i < static_cast<int>(video_shader->num_parameters); i++)
|
|
{
|
|
QString id = video_shader->parameters[i].id;
|
|
|
|
if (id == parameter)
|
|
param = &video_shader->parameters[i];
|
|
}
|
|
|
|
if (param)
|
|
video_shader_param_set(param, (checkBox->isChecked() ? param->maximum : param->minimum));
|
|
|
|
video_shader->flags |= SHDR_FLAG_MODIFIED;
|
|
}
|
|
}
|
|
}
|
|
|
|
void ShaderParamsDialog::onShaderParamSliderValueChanged(int)
|
|
{
|
|
QVariant spinBoxVariant;
|
|
QVariant paramVariant;
|
|
QSlider *slider = qobject_cast<QSlider*>(sender());
|
|
struct video_shader *menu_shader = NULL;
|
|
struct video_shader *video_shader = NULL;
|
|
double newValue = 0.0;
|
|
|
|
getShaders(&menu_shader, &video_shader);
|
|
|
|
if (!slider)
|
|
return;
|
|
|
|
spinBoxVariant = slider->property("spinBox");
|
|
paramVariant = slider->property("param");
|
|
|
|
if (paramVariant.isValid())
|
|
{
|
|
QString parameter = paramVariant.toString();
|
|
|
|
if (menu_shader)
|
|
{
|
|
int i;
|
|
struct video_shader_parameter *param = NULL;
|
|
|
|
for (i = 0; i < static_cast<int>(menu_shader->num_parameters); i++)
|
|
{
|
|
QString id = menu_shader->parameters[i].id;
|
|
|
|
if (id == parameter)
|
|
param = &menu_shader->parameters[i];
|
|
}
|
|
|
|
if (param)
|
|
{
|
|
newValue = lerp(0, 100, param->minimum, param->maximum, slider->value());
|
|
newValue = round(newValue / param->step) * param->step;
|
|
video_shader_param_set(param, newValue);
|
|
}
|
|
}
|
|
|
|
if (video_shader)
|
|
{
|
|
int i;
|
|
struct video_shader_parameter *param = NULL;
|
|
|
|
for (i = 0; i < static_cast<int>(video_shader->num_parameters); i++)
|
|
{
|
|
QString id = video_shader->parameters[i].id;
|
|
|
|
if (id == parameter)
|
|
param = &video_shader->parameters[i];
|
|
}
|
|
|
|
if (param)
|
|
{
|
|
newValue = lerp(0, 100, param->minimum, param->maximum, slider->value());
|
|
newValue = round(newValue / param->step) * param->step;
|
|
video_shader_param_set(param, newValue);
|
|
}
|
|
|
|
video_shader->flags |= SHDR_FLAG_MODIFIED;
|
|
}
|
|
|
|
}
|
|
|
|
if (spinBoxVariant.isValid())
|
|
{
|
|
QSpinBox *spinBox = spinBoxVariant.value<QSpinBox*>();
|
|
|
|
if (!spinBox)
|
|
return;
|
|
|
|
spinBox->blockSignals(true);
|
|
spinBox->setValue(newValue);
|
|
spinBox->blockSignals(false);
|
|
}
|
|
else
|
|
{
|
|
QVariant doubleSpinBoxVariant = slider->property("doubleSpinBox");
|
|
QDoubleSpinBox *doubleSpinBox = doubleSpinBoxVariant.value<QDoubleSpinBox*>();
|
|
|
|
if (!doubleSpinBox)
|
|
return;
|
|
|
|
doubleSpinBox->blockSignals(true);
|
|
doubleSpinBox->setValue(newValue);
|
|
doubleSpinBox->blockSignals(false);
|
|
}
|
|
}
|
|
|
|
void ShaderParamsDialog::onShaderParamSpinBoxValueChanged(int value)
|
|
{
|
|
QVariant sliderVariant;
|
|
QVariant paramVariant;
|
|
QSpinBox *spinBox = qobject_cast<QSpinBox*>(sender());
|
|
QSlider *slider = NULL;
|
|
struct video_shader *menu_shader = NULL;
|
|
struct video_shader *video_shader = NULL;
|
|
|
|
getShaders(&menu_shader, &video_shader);
|
|
|
|
if (!spinBox)
|
|
return;
|
|
|
|
sliderVariant = spinBox->property("slider");
|
|
|
|
if (!sliderVariant.isValid())
|
|
return;
|
|
|
|
slider = sliderVariant.value<QSlider*>();
|
|
|
|
if (!slider)
|
|
return;
|
|
|
|
paramVariant = slider->property("param");
|
|
|
|
if (paramVariant.isValid())
|
|
{
|
|
QString parameter = paramVariant.toString();
|
|
double newValue = 0.0;
|
|
|
|
if (menu_shader)
|
|
{
|
|
int i;
|
|
struct video_shader_parameter *param = NULL;
|
|
|
|
for (i = 0; i < static_cast<int>(menu_shader->num_parameters); i++)
|
|
{
|
|
QString id = menu_shader->parameters[i].id;
|
|
|
|
if (id == parameter)
|
|
param = &menu_shader->parameters[i];
|
|
}
|
|
|
|
if (param)
|
|
{
|
|
video_shader_param_set(param, value);
|
|
newValue = lerp(
|
|
param->minimum, param->maximum, 0, 100, video_shader_param_get(param));
|
|
slider->blockSignals(true);
|
|
slider->setValue(newValue);
|
|
slider->blockSignals(false);
|
|
}
|
|
}
|
|
|
|
if (video_shader)
|
|
{
|
|
int i;
|
|
struct video_shader_parameter *param = NULL;
|
|
|
|
for (i = 0; i < static_cast<int>(video_shader->num_parameters); i++)
|
|
{
|
|
QString id = video_shader->parameters[i].id;
|
|
|
|
if (id == parameter)
|
|
param = &video_shader->parameters[i];
|
|
}
|
|
|
|
if (param)
|
|
{
|
|
video_shader_param_set(param, value);
|
|
newValue = lerp(
|
|
param->minimum, param->maximum, 0, 100, video_shader_param_get(param));
|
|
slider->blockSignals(true);
|
|
slider->setValue(newValue);
|
|
slider->blockSignals(false);
|
|
}
|
|
|
|
video_shader->flags |= SHDR_FLAG_MODIFIED;
|
|
}
|
|
}
|
|
}
|
|
|
|
void ShaderParamsDialog::onShaderParamDoubleSpinBoxValueChanged(double value)
|
|
{
|
|
QVariant sliderVariant;
|
|
QVariant paramVariant;
|
|
QSlider *slider = NULL;
|
|
QDoubleSpinBox *doubleSpinBox = qobject_cast<QDoubleSpinBox*>(sender());
|
|
struct video_shader *menu_shader = NULL;
|
|
struct video_shader *video_shader = NULL;
|
|
|
|
getShaders(&menu_shader, &video_shader);
|
|
|
|
if (!doubleSpinBox)
|
|
return;
|
|
|
|
sliderVariant = doubleSpinBox->property("slider");
|
|
|
|
if (!sliderVariant.isValid())
|
|
return;
|
|
|
|
slider = sliderVariant.value<QSlider*>();
|
|
|
|
if (!slider)
|
|
return;
|
|
|
|
paramVariant = slider->property("param");
|
|
|
|
if (paramVariant.isValid())
|
|
{
|
|
QString parameter = paramVariant.toString();
|
|
double newValue = 0.0;
|
|
|
|
if (menu_shader)
|
|
{
|
|
int i;
|
|
struct video_shader_parameter *param = NULL;
|
|
|
|
for (i = 0; i < static_cast<int>(menu_shader->num_parameters); i++)
|
|
{
|
|
QString id = menu_shader->parameters[i].id;
|
|
|
|
if (id == parameter)
|
|
param = &menu_shader->parameters[i];
|
|
}
|
|
|
|
if (param)
|
|
{
|
|
video_shader_param_set(param, value);
|
|
newValue = lerp(
|
|
param->minimum, param->maximum, 0, 100, video_shader_param_get(param));
|
|
slider->blockSignals(true);
|
|
slider->setValue(newValue);
|
|
slider->blockSignals(false);
|
|
}
|
|
}
|
|
|
|
if (video_shader)
|
|
{
|
|
int i;
|
|
struct video_shader_parameter *param = NULL;
|
|
|
|
for (i = 0; i < static_cast<int>(video_shader->num_parameters); i++)
|
|
{
|
|
QString id = video_shader->parameters[i].id;
|
|
|
|
if (id == parameter)
|
|
param = &video_shader->parameters[i];
|
|
}
|
|
|
|
if (param)
|
|
{
|
|
video_shader_param_set(param, value);
|
|
newValue = lerp(
|
|
param->minimum, param->maximum, 0, 100, video_shader_param_get(param));
|
|
slider->blockSignals(true);
|
|
slider->setValue(newValue);
|
|
slider->blockSignals(false);
|
|
}
|
|
|
|
video_shader->flags |= SHDR_FLAG_MODIFIED;
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
#endif
|
|
|
|
/* Thumbnail downloads. URLs, .partial handling, the pack extraction
|
|
* and the file replacement rules are the companion core's
|
|
* (companion_core_thumbnail_download / _pack_download); Qt keeps the
|
|
* queues, counters and progress dialogs. Results arrive through the
|
|
* driver's callback table as onCoreThumbnailDownloaded /
|
|
* onCoreThumbnailPackFinished. */
|
|
|
|
/* ---- Thumbnail Pack Download ---- */
|
|
|
|
void MainWindow::onThumbnailPackDownloadCanceled()
|
|
{
|
|
companion_core_download_cancel(ui_companion_qt_core());
|
|
}
|
|
|
|
void MainWindow::downloadAllThumbnails(QString system, QUrl url)
|
|
{
|
|
QByteArray systemArray = system.toUtf8();
|
|
|
|
(void)url; /* the server layout is the core's */
|
|
|
|
if (!companion_core_thumbnail_pack_download(ui_companion_qt_core(),
|
|
systemArray.constData()))
|
|
{
|
|
RARCH_ERR("[Qt] Failed to start thumbnail pack download.\n");
|
|
return;
|
|
}
|
|
|
|
m_thumbnailPackDownloadProgressDialog->setWindowModality(Qt::NonModal);
|
|
m_thumbnailPackDownloadProgressDialog->setMinimumDuration(0);
|
|
m_thumbnailPackDownloadProgressDialog->setRange(0, 0);
|
|
m_thumbnailPackDownloadProgressDialog->setAutoClose(true);
|
|
m_thumbnailPackDownloadProgressDialog->setAutoReset(true);
|
|
m_thumbnailPackDownloadProgressDialog->setValue(0);
|
|
m_thumbnailPackDownloadProgressDialog->setLabelText(
|
|
QString(msg_hash_to_str(MSG_DOWNLOADING)) + "...");
|
|
m_thumbnailPackDownloadProgressDialog->setCancelButtonText(tr("Cancel"));
|
|
m_thumbnailPackDownloadProgressDialog->show();
|
|
}
|
|
|
|
void MainWindow::onCoreThumbnailPackFinished(int result)
|
|
{
|
|
m_thumbnailPackDownloadProgressDialog->cancel();
|
|
|
|
switch ((enum companion_download_result)result)
|
|
{
|
|
case COMPANION_DL_OK:
|
|
RARCH_LOG("[Qt] Thumbnail pack extracted successfully.\n");
|
|
emit showInfoMessageDeferred(msg_hash_to_str(
|
|
MENU_ENUM_LABEL_VALUE_QT_THUMBNAIL_PACK_DOWNLOADED_SUCCESSFULLY));
|
|
updateVisibleItems();
|
|
emit itemChanged(); /* reload thumbnail image */
|
|
return;
|
|
case COMPANION_DL_ERR_NETWORK:
|
|
emit showErrorMessageDeferred(msg_hash_to_str(
|
|
MENU_ENUM_LABEL_VALUE_QT_NETWORK_ERROR));
|
|
return;
|
|
case COMPANION_DL_ERR_RENAME:
|
|
emit showErrorMessageDeferred(msg_hash_to_str(
|
|
MENU_ENUM_LABEL_VALUE_QT_COULD_NOT_RENAME_FILE));
|
|
return;
|
|
case COMPANION_DL_ERR_DELETE:
|
|
emit showErrorMessageDeferred(msg_hash_to_str(
|
|
MENU_ENUM_LABEL_VALUE_QT_COULD_NOT_DELETE_FILE));
|
|
return;
|
|
case COMPANION_DL_ERR_ARCHIVE_EMPTY:
|
|
emit showErrorMessageDeferred("Error: Archive is empty.");
|
|
return;
|
|
case COMPANION_DL_ERR_EXTRACT:
|
|
case COMPANION_DL_ERR_WRITE:
|
|
default:
|
|
emit showErrorMessageDeferred(msg_hash_to_str(MSG_DECOMPRESSION_FAILED));
|
|
return;
|
|
}
|
|
}
|
|
|
|
/* ---- Single Thumbnail Download ---- */
|
|
|
|
void MainWindow::onThumbnailDownloadCanceled()
|
|
{
|
|
companion_core_download_cancel(ui_companion_qt_core());
|
|
m_pendingThumbnailDownloadTypes.clear();
|
|
}
|
|
|
|
void MainWindow::onDownloadThumbnail(QString system, QString title)
|
|
{
|
|
downloadThumbnail(system, title);
|
|
}
|
|
|
|
/* companion core: a thumbnail transfer ended. */
|
|
void MainWindow::onCoreThumbnailDownloaded(QString system, QString title,
|
|
QString path, bool success)
|
|
{
|
|
if (m_downloadingPlaylistThumbnails)
|
|
onPlaylistThumbnailDownloadFinishedInternal(path, success);
|
|
else
|
|
onSingleThumbnailDownloadFinishedInternal(system, title, path, success);
|
|
}
|
|
|
|
void MainWindow::onSingleThumbnailDownloadFinishedInternal(
|
|
QString system, QString title, QString path, bool success)
|
|
{
|
|
if (success && !path.isEmpty())
|
|
{
|
|
/* Force reload of current item's thumbnail */
|
|
QModelIndex index = getCurrentContentIndex();
|
|
if (index.isValid())
|
|
{
|
|
m_playlistModel->reloadThumbnail(index);
|
|
onCurrentItemChanged(index);
|
|
}
|
|
|
|
updateVisibleItems();
|
|
}
|
|
|
|
if (!m_pendingThumbnailDownloadTypes.isEmpty())
|
|
{
|
|
/* Defer next download to let Qt event loop process */
|
|
QMetaObject::invokeMethod(this, "onDownloadThumbnail",
|
|
Qt::QueuedConnection,
|
|
Q_ARG(QString, system),
|
|
Q_ARG(QString, title));
|
|
}
|
|
else
|
|
m_thumbnailDownloadProgressDialog->cancel();
|
|
}
|
|
|
|
void MainWindow::downloadThumbnail(QString system, QString title, QUrl url)
|
|
{
|
|
QString downloadType;
|
|
QByteArray systemArray, titleArray, typeArray;
|
|
|
|
(void)url;
|
|
|
|
if (m_pendingThumbnailDownloadTypes.isEmpty())
|
|
return;
|
|
|
|
downloadType = m_pendingThumbnailDownloadTypes.takeFirst();
|
|
systemArray = system.toUtf8();
|
|
titleArray = title.toUtf8();
|
|
typeArray = downloadType.toUtf8();
|
|
|
|
m_downloadingPlaylistThumbnails = false;
|
|
|
|
if (!companion_core_thumbnail_download(ui_companion_qt_core(),
|
|
systemArray.constData(), titleArray.constData(),
|
|
typeArray.constData()))
|
|
{
|
|
RARCH_ERR("[Qt] Failed to start thumbnail download.\n");
|
|
m_pendingThumbnailDownloadTypes.clear();
|
|
m_thumbnailDownloadProgressDialog->cancel();
|
|
return;
|
|
}
|
|
|
|
m_thumbnailDownloadProgressDialog->setWindowModality(Qt::NonModal);
|
|
m_thumbnailDownloadProgressDialog->setMinimumDuration(0);
|
|
m_thumbnailDownloadProgressDialog->setRange(0, 100);
|
|
m_thumbnailDownloadProgressDialog->setAutoClose(true);
|
|
m_thumbnailDownloadProgressDialog->setAutoReset(true);
|
|
m_thumbnailDownloadProgressDialog->setValue(0);
|
|
m_thumbnailDownloadProgressDialog->setLabelText(
|
|
QString(msg_hash_to_str(MSG_DOWNLOADING)) + "...");
|
|
m_thumbnailDownloadProgressDialog->setCancelButtonText(tr("Cancel"));
|
|
m_thumbnailDownloadProgressDialog->show();
|
|
}
|
|
|
|
/* ---- Playlist Thumbnail Download ---- */
|
|
|
|
void MainWindow::onPlaylistThumbnailDownloadCanceled()
|
|
{
|
|
m_playlistThumbnailDownloadWasCanceled = true;
|
|
m_downloadingPlaylistThumbnails = false;
|
|
companion_core_download_cancel(ui_companion_qt_core());
|
|
m_pendingPlaylistThumbnails.clear();
|
|
}
|
|
|
|
void MainWindow::onPlaylistThumbnailDownloadFinishedInternal(
|
|
QString path, bool success)
|
|
{
|
|
if (success)
|
|
{
|
|
m_downloadedThumbnails++;
|
|
if (!path.isEmpty())
|
|
m_playlistModel->reloadThumbnailPath(path);
|
|
}
|
|
else
|
|
m_failedThumbnails++;
|
|
|
|
if (m_playlistThumbnailDownloadWasCanceled)
|
|
return;
|
|
|
|
if (m_pendingPlaylistThumbnails.count() > 0)
|
|
{
|
|
QHash<QString, QString> nextThumbnail = m_pendingPlaylistThumbnails.takeAt(0);
|
|
|
|
m_playlistThumbnailDownloadProgressDialog->setValue(
|
|
m_playlistThumbnailDownloadProgressDialog->maximum()
|
|
- m_pendingPlaylistThumbnails.count());
|
|
{
|
|
QString labelText = QString(msg_hash_to_str(MSG_DOWNLOADING))
|
|
+ "...\n"
|
|
+ QString(msg_hash_to_str(
|
|
MENU_ENUM_LABEL_VALUE_QT_DOWNLOAD_PLAYLIST_THUMBNAIL_PROGRESS)).arg(
|
|
m_downloadedThumbnails).arg(m_failedThumbnails);
|
|
m_playlistThumbnailDownloadProgressDialog->setLabelText(labelText);
|
|
}
|
|
|
|
downloadNextPlaylistThumbnail(
|
|
nextThumbnail.value("db_name"),
|
|
nextThumbnail.value("label_noext"),
|
|
nextThumbnail.value("type"));
|
|
}
|
|
else
|
|
{
|
|
m_downloadingPlaylistThumbnails = false;
|
|
m_playlistThumbnailDownloadProgressDialog->cancel();
|
|
/* Force reload of current item's thumbnail */
|
|
QModelIndex index = getCurrentContentIndex();
|
|
if (index.isValid())
|
|
{
|
|
m_playlistModel->reloadThumbnail(index);
|
|
onCurrentItemChanged(index);
|
|
}
|
|
updateVisibleItems();
|
|
}
|
|
}
|
|
|
|
void MainWindow::downloadNextPlaylistThumbnail(
|
|
QString system, QString title, QString type, QUrl url)
|
|
{
|
|
QByteArray systemArray = system.toUtf8();
|
|
QByteArray titleArray = title.toUtf8();
|
|
QByteArray typeArray = type.toUtf8();
|
|
|
|
(void)url;
|
|
|
|
/* Skip transfers that cannot start and move on down the queue; the
|
|
* core reports every one it does start. */
|
|
while (!companion_core_thumbnail_download(ui_companion_qt_core(),
|
|
systemArray.constData(), titleArray.constData(),
|
|
typeArray.constData()))
|
|
{
|
|
m_failedThumbnails++;
|
|
|
|
if (m_pendingPlaylistThumbnails.count() == 0)
|
|
{
|
|
m_downloadingPlaylistThumbnails = false;
|
|
m_playlistThumbnailDownloadProgressDialog->cancel();
|
|
return;
|
|
}
|
|
|
|
{
|
|
QHash<QString, QString> next = m_pendingPlaylistThumbnails.takeAt(0);
|
|
systemArray = next.value("db_name").toUtf8();
|
|
titleArray = next.value("label_noext").toUtf8();
|
|
typeArray = next.value("type").toUtf8();
|
|
}
|
|
}
|
|
}
|
|
|
|
void MainWindow::downloadPlaylistThumbnails(QString playlistPath)
|
|
{
|
|
int i, count;
|
|
QFile playlistFile(playlistPath);
|
|
|
|
if (!playlistFile.exists())
|
|
return;
|
|
|
|
m_pendingPlaylistThumbnails.clear();
|
|
m_downloadedThumbnails = 0;
|
|
m_failedThumbnails = 0;
|
|
m_playlistThumbnailDownloadWasCanceled = false;
|
|
|
|
count = m_playlistModel->rowCount();
|
|
|
|
if (count == 0)
|
|
return;
|
|
|
|
for (i = 0; i < count; i++)
|
|
{
|
|
QHash<QString, QString> hash;
|
|
QHash<QString, QString> hash2;
|
|
QHash<QString, QString> hash3;
|
|
QHash<QString, QString> hash4;
|
|
const PlaylistEntry itemEntry =
|
|
m_playlistModel->index(i, 0).data(
|
|
PlaylistModel::ENTRY).value<PlaylistEntry>();
|
|
|
|
hash["db_name"] = itemEntry.dbName;
|
|
hash["label_noext"] = itemEntry.labelNoExt;
|
|
hash["type"] = THUMBNAIL_BOXART;
|
|
|
|
hash2 = hash;
|
|
hash3 = hash;
|
|
hash4 = hash;
|
|
|
|
hash2["type"] = THUMBNAIL_SCREENSHOT;
|
|
hash3["type"] = THUMBNAIL_TITLE;
|
|
hash4["type"] = THUMBNAIL_LOGO;
|
|
|
|
m_pendingPlaylistThumbnails.append(hash);
|
|
m_pendingPlaylistThumbnails.append(hash2);
|
|
m_pendingPlaylistThumbnails.append(hash3);
|
|
m_pendingPlaylistThumbnails.append(hash4);
|
|
}
|
|
|
|
m_playlistThumbnailDownloadProgressDialog->setWindowModality(Qt::NonModal);
|
|
m_playlistThumbnailDownloadProgressDialog->setMinimumDuration(0);
|
|
m_playlistThumbnailDownloadProgressDialog->setRange(0,
|
|
m_pendingPlaylistThumbnails.count());
|
|
m_playlistThumbnailDownloadProgressDialog->setAutoClose(true);
|
|
m_playlistThumbnailDownloadProgressDialog->setAutoReset(true);
|
|
m_playlistThumbnailDownloadProgressDialog->setValue(0);
|
|
m_playlistThumbnailDownloadProgressDialog->setLabelText(
|
|
QString(msg_hash_to_str(MSG_DOWNLOADING)) + "...");
|
|
m_playlistThumbnailDownloadProgressDialog->setCancelButtonText(tr("Cancel"));
|
|
m_playlistThumbnailDownloadProgressDialog->show();
|
|
|
|
m_downloadingPlaylistThumbnails = true;
|
|
{
|
|
QHash<QString, QString> firstThumbnail =
|
|
m_pendingPlaylistThumbnails.takeAt(0);
|
|
downloadNextPlaylistThumbnail(
|
|
firstThumbnail.value("db_name"),
|
|
firstThumbnail.value("label_noext"),
|
|
firstThumbnail.value("type"));
|
|
}
|
|
}
|
|
|
|
/* All of the OptionsCategory/OptionsPage implementations below
|
|
* build trees of the menu settings widgets (FormLayout,
|
|
* SettingsGroup, CheckBox, etc.) and call into the menu code
|
|
* (menu_displaylist_build_list, menu_setting_find_enum). Their
|
|
* declarations are gated in ui_qt_widgets.h; the implementations
|
|
* are gated to match. */
|
|
#ifdef HAVE_MENU
|
|
|
|
AchievementsCategory::AchievementsCategory(QWidget *parent) :
|
|
OptionsCategory(parent)
|
|
{
|
|
setDisplayName(MENU_ENUM_LABEL_VALUE_RETRO_ACHIEVEMENTS_SETTINGS);
|
|
setCategoryIcon("menu_achievements");
|
|
}
|
|
|
|
QVector<OptionsPage*> AchievementsCategory::pages()
|
|
{
|
|
QVector<OptionsPage*> pages;
|
|
pages << new AchievementsPage(this);
|
|
return pages;
|
|
}
|
|
|
|
AchievementsPage::AchievementsPage(QObject *parent) :
|
|
OptionsPage(parent)
|
|
{
|
|
}
|
|
|
|
QWidget *AchievementsPage::widget()
|
|
{
|
|
unsigned i;
|
|
QWidget *widget = new QWidget;
|
|
QVBoxLayout *layout = new QVBoxLayout;
|
|
QHBoxLayout *columnsLayout = new QHBoxLayout;
|
|
QVBoxLayout *leftColumn = new QVBoxLayout;
|
|
QVBoxLayout *rightColumn = new QVBoxLayout;
|
|
settings_t* settings = config_get_ptr();
|
|
CheckBox *enabledCheckBox = new CheckBox(MENU_ENUM_LABEL_CHEEVOS_ENABLE);
|
|
file_list_t *generalList = (file_list_t*)calloc(1, sizeof(*generalList));
|
|
file_list_t *appearanceList = (file_list_t*)calloc(1, sizeof(*appearanceList));
|
|
file_list_t *visibilityList = (file_list_t*)calloc(1, sizeof(*visibilityList));
|
|
|
|
m_generalGroup = new SettingsGroup("General");
|
|
m_appearanceGroup = new SettingsGroup(msg_hash_to_str(
|
|
MENU_ENUM_LABEL_VALUE_CHEEVOS_APPEARANCE_SETTINGS));
|
|
m_visibilityGroup = new SettingsGroup(msg_hash_to_str(
|
|
MENU_ENUM_LABEL_VALUE_CHEEVOS_VISIBILITY_SETTINGS));
|
|
|
|
menu_displaylist_build_list(generalList, settings,
|
|
DISPLAYLIST_RETRO_ACHIEVEMENTS_SETTINGS_LIST, true);
|
|
|
|
for (i = 0; i < generalList->size; i++)
|
|
{
|
|
menu_file_list_cbs_t *cbs = (menu_file_list_cbs_t*)
|
|
file_list_get_actiondata_at_offset(generalList, i);
|
|
|
|
if (cbs->enum_idx == MENU_ENUM_LABEL_CHEEVOS_ENABLE)
|
|
continue;
|
|
|
|
m_generalGroup->add(cbs->enum_idx);
|
|
}
|
|
file_list_free(generalList);
|
|
|
|
menu_displaylist_build_list(appearanceList, settings,
|
|
DISPLAYLIST_CHEEVOS_APPEARANCE_SETTINGS_LIST, true);
|
|
|
|
for (i = 0; i < appearanceList->size; i++)
|
|
{
|
|
menu_file_list_cbs_t* cbs = (menu_file_list_cbs_t*)
|
|
file_list_get_actiondata_at_offset(appearanceList, i);
|
|
|
|
m_appearanceGroup->add(cbs->enum_idx);
|
|
}
|
|
file_list_free(appearanceList);
|
|
|
|
menu_displaylist_build_list(visibilityList, settings,
|
|
DISPLAYLIST_CHEEVOS_VISIBILITY_SETTINGS_LIST, true);
|
|
|
|
for (i = 0; i < visibilityList->size; i++)
|
|
{
|
|
menu_file_list_cbs_t* cbs = (menu_file_list_cbs_t*)
|
|
file_list_get_actiondata_at_offset(visibilityList, i);
|
|
|
|
m_visibilityGroup->add(cbs->enum_idx);
|
|
}
|
|
file_list_free(visibilityList);
|
|
|
|
connect(enabledCheckBox, SIGNAL(stateChanged(int)),
|
|
this, SLOT(onAchievementEnabledChanged(int)));
|
|
|
|
onAchievementEnabledChanged(enabledCheckBox->checkState());
|
|
|
|
layout->addWidget(enabledCheckBox);
|
|
leftColumn->addWidget(m_generalGroup);
|
|
leftColumn->addWidget(m_appearanceGroup);
|
|
rightColumn->addWidget(m_visibilityGroup);
|
|
leftColumn->addStretch();
|
|
rightColumn->addStretch();
|
|
columnsLayout->addLayout(leftColumn, 1);
|
|
columnsLayout->addLayout(rightColumn, 1);
|
|
layout->addLayout(columnsLayout);
|
|
layout->addStretch();
|
|
|
|
widget->setLayout(layout);
|
|
|
|
return widget;
|
|
}
|
|
|
|
void AchievementsPage::onAchievementEnabledChanged(int state)
|
|
{
|
|
m_generalGroup->setDisabled(state == Qt::Unchecked);
|
|
m_appearanceGroup->setDisabled(state == Qt::Unchecked);
|
|
m_visibilityGroup->setDisabled(state == Qt::Unchecked);
|
|
}
|
|
|
|
static file_list_t *qt_displaylist_build(
|
|
enum menu_displaylist_ctl_state state);
|
|
static bool qt_list_has_entry(const file_list_t *list,
|
|
enum msg_hash_enums entry);
|
|
static void qt_settings_group_add_list(SettingsGroup *group,
|
|
const file_list_t *list,
|
|
const enum msg_hash_enums *skip_entries, size_t skip_count,
|
|
const enum msg_hash_enums *only_entries, size_t only_count);
|
|
static void qt_settings_group_add_displaylist(SettingsGroup *group,
|
|
enum menu_displaylist_ctl_state state,
|
|
const enum msg_hash_enums *skip_entries, size_t skip_count,
|
|
const enum msg_hash_enums *only_entries, size_t only_count);
|
|
|
|
AudioCategory::AudioCategory(QWidget *parent) :
|
|
OptionsCategory(parent)
|
|
{
|
|
setDisplayName(MENU_ENUM_LABEL_VALUE_AUDIO_SETTINGS);
|
|
setCategoryIcon("menu_audio");
|
|
}
|
|
|
|
QVector<OptionsPage*> AudioCategory::pages()
|
|
{
|
|
QVector<OptionsPage*> pages;
|
|
|
|
pages << new AudioPage(this);
|
|
|
|
return pages;
|
|
}
|
|
|
|
AudioPage::AudioPage(QObject *parent) :
|
|
OptionsPage(parent)
|
|
{
|
|
}
|
|
|
|
QWidget *AudioPage::widget()
|
|
{
|
|
QWidget *widget = new QWidget;
|
|
QVBoxLayout *layout = new QVBoxLayout;
|
|
QHBoxLayout *columnsLayout = new QHBoxLayout;
|
|
QVBoxLayout *leftColumn = new QVBoxLayout;
|
|
QVBoxLayout *rightColumn = new QVBoxLayout;
|
|
SettingsGroup *generalGroup = new SettingsGroup("General");
|
|
SettingsGroup *outputGroup = new SettingsGroup("Output");
|
|
SettingsGroup *syncGroup = new SettingsGroup(msg_hash_to_str(
|
|
MENU_ENUM_LABEL_VALUE_AUDIO_SYNC));
|
|
SettingsGroup *resamplerGroup = new SettingsGroup("Resampler");
|
|
SettingsGroup *volumeGroup = new SettingsGroup("Volume");
|
|
SettingsGroup *menuSoundsGroup = new SettingsGroup(msg_hash_to_str(
|
|
MENU_ENUM_LABEL_VALUE_MENU_SOUNDS));
|
|
SettingsGroup *midiGroup = new SettingsGroup(
|
|
msg_hash_to_str(MENU_ENUM_LABEL_VALUE_MIDI_SETTINGS));
|
|
QGridLayout *volumeLayout = new QGridLayout;
|
|
static const enum msg_hash_enums generalSkip[] = {
|
|
MENU_ENUM_LABEL_AUDIO_VOLUME,
|
|
MENU_ENUM_LABEL_AUDIO_MIXER_VOLUME,
|
|
MENU_ENUM_LABEL_AUDIO_MUTE,
|
|
MENU_ENUM_LABEL_AUDIO_MIXER_MUTE
|
|
};
|
|
static const enum msg_hash_enums outputSkip[] = {
|
|
MENU_ENUM_LABEL_AUDIO_OUTPUT_RATE,
|
|
MENU_ENUM_LABEL_AUDIO_RESAMPLER_DRIVER,
|
|
MENU_ENUM_LABEL_AUDIO_RESAMPLER_QUALITY,
|
|
MENU_ENUM_LABEL_AUDIO_RESAMPLER_HQ_OVERSAMPLING,
|
|
MENU_ENUM_LABEL_AUDIO_FASTPATH_S16,
|
|
MENU_ENUM_LABEL_AUDIO_FORMAT_NEGOTIATION
|
|
};
|
|
static const enum msg_hash_enums midiVolumeSkip[] = {
|
|
MENU_ENUM_LABEL_MIDI_VOLUME
|
|
};
|
|
static const enum msg_hash_enums resamplerEntries[] = {
|
|
MENU_ENUM_LABEL_AUDIO_OUTPUT_RATE,
|
|
MENU_ENUM_LABEL_AUDIO_RESAMPLER_DRIVER,
|
|
MENU_ENUM_LABEL_AUDIO_RESAMPLER_QUALITY,
|
|
MENU_ENUM_LABEL_AUDIO_RESAMPLER_HQ_OVERSAMPLING,
|
|
MENU_ENUM_LABEL_AUDIO_FASTPATH_S16,
|
|
MENU_ENUM_LABEL_AUDIO_FORMAT_NEGOTIATION
|
|
};
|
|
|
|
/* Build the ordinary controls from the same lists used by the menu.
|
|
* Action entries are ignored by the SettingsGroup helper. */
|
|
qt_settings_group_add_displaylist(generalGroup,
|
|
DISPLAYLIST_AUDIO_SETTINGS_LIST,
|
|
generalSkip, ARRAY_SIZE(generalSkip), NULL, 0);
|
|
{
|
|
file_list_t *outputList = qt_displaylist_build(
|
|
DISPLAYLIST_AUDIO_OUTPUT_SETTINGS_LIST);
|
|
qt_settings_group_add_list(outputGroup, outputList,
|
|
outputSkip, ARRAY_SIZE(outputSkip), NULL, 0);
|
|
qt_settings_group_add_list(resamplerGroup, outputList, NULL, 0,
|
|
resamplerEntries, ARRAY_SIZE(resamplerEntries));
|
|
if (outputList)
|
|
file_list_free(outputList);
|
|
}
|
|
qt_settings_group_add_displaylist(syncGroup,
|
|
DISPLAYLIST_AUDIO_SYNCHRONIZATION_SETTINGS_LIST, NULL, 0, NULL, 0);
|
|
qt_settings_group_add_displaylist(menuSoundsGroup,
|
|
DISPLAYLIST_MENU_SOUNDS_LIST, NULL, 0, NULL, 0);
|
|
qt_settings_group_add_displaylist(midiGroup,
|
|
DISPLAYLIST_MIDI_SETTINGS_LIST,
|
|
midiVolumeSkip, ARRAY_SIZE(midiVolumeSkip), NULL, 0);
|
|
{
|
|
rarch_setting_t *midiVolume = menu_setting_find_enum(
|
|
MENU_ENUM_LABEL_MIDI_VOLUME);
|
|
if (midiVolume && midiVolume->value.target.unsigned_integer)
|
|
{
|
|
QHBoxLayout *midiVolumeLayout = new QHBoxLayout;
|
|
QSlider *slider = new QSlider(Qt::Horizontal);
|
|
QSpinBox *spinBox = new QSpinBox;
|
|
slider->setRange((int)midiVolume->min, (int)midiVolume->max);
|
|
spinBox->setRange((int)midiVolume->min, (int)midiVolume->max);
|
|
slider->setValue((int)*midiVolume->value.target.unsigned_integer);
|
|
spinBox->setValue((int)*midiVolume->value.target.unsigned_integer);
|
|
/* The spin box is the single writer: the slider only feeds
|
|
* it, so each edit runs the change handler once (it ran twice
|
|
* when both widgets wrote the setting and echoed each other). */
|
|
QObject::connect(slider, &QSlider::valueChanged,
|
|
spinBox, &QSpinBox::setValue);
|
|
QObject::connect(spinBox,
|
|
static_cast<void (QSpinBox::*)(int)>(&QSpinBox::valueChanged),
|
|
[midiVolume, slider](int value)
|
|
{
|
|
QSignalBlocker block(slider);
|
|
*midiVolume->value.target.unsigned_integer = (unsigned)value;
|
|
setting_generic_handle_change(midiVolume);
|
|
slider->setValue(value);
|
|
});
|
|
midiVolumeLayout->addWidget(slider, 1);
|
|
midiVolumeLayout->addWidget(spinBox);
|
|
midiGroup->addRow(msg_hash_to_str(MENU_ENUM_LABEL_VALUE_MIDI_VOLUME),
|
|
midiVolumeLayout);
|
|
}
|
|
}
|
|
#ifdef HAVE_MICROPHONE
|
|
{
|
|
SettingsGroup *microphoneGroup = new SettingsGroup(
|
|
msg_hash_to_str(MENU_ENUM_LABEL_VALUE_MICROPHONE_SETTINGS));
|
|
qt_settings_group_add_displaylist(microphoneGroup,
|
|
DISPLAYLIST_MICROPHONE_SETTINGS_LIST, NULL, 0, NULL, 0);
|
|
rightColumn->addWidget(microphoneGroup);
|
|
}
|
|
#endif
|
|
/* Keep the two volume sliders and their mute buttons together. */
|
|
volumeLayout->addWidget(new QLabel(
|
|
msg_hash_to_str(MENU_ENUM_LABEL_VALUE_AUDIO_VOLUME), widget),
|
|
0, 0);
|
|
volumeLayout->addWidget(new CheckableIcon(
|
|
MENU_ENUM_LABEL_AUDIO_MUTE,
|
|
qApp->style()->standardIcon(QStyle::SP_MediaVolumeMuted)), 0, 1);
|
|
volumeLayout->addLayout(new FloatSliderAndSpinBox(
|
|
MENU_ENUM_LABEL_AUDIO_VOLUME), 0, 2);
|
|
volumeLayout->addWidget(new QLabel(
|
|
msg_hash_to_str(MENU_ENUM_LABEL_VALUE_AUDIO_MIXER_VOLUME), widget),
|
|
1, 0);
|
|
volumeLayout->addWidget(new CheckableIcon(
|
|
MENU_ENUM_LABEL_AUDIO_MIXER_MUTE,
|
|
qApp->style()->standardIcon(QStyle::SP_MediaVolumeMuted)), 1, 1);
|
|
volumeLayout->addLayout(new FloatSliderAndSpinBox(
|
|
MENU_ENUM_LABEL_AUDIO_MIXER_VOLUME), 1, 2);
|
|
volumeGroup->addRow(volumeLayout);
|
|
|
|
leftColumn->addWidget(outputGroup);
|
|
leftColumn->addWidget(syncGroup);
|
|
leftColumn->addWidget(volumeGroup);
|
|
leftColumn->addWidget(generalGroup);
|
|
|
|
rightColumn->addWidget(resamplerGroup);
|
|
rightColumn->addWidget(menuSoundsGroup);
|
|
rightColumn->addWidget(midiGroup);
|
|
leftColumn->addStretch();
|
|
rightColumn->addStretch();
|
|
|
|
columnsLayout->addLayout(leftColumn, 1);
|
|
columnsLayout->addLayout(rightColumn, 1);
|
|
layout->addLayout(columnsLayout);
|
|
layout->addStretch();
|
|
widget->setLayout(layout);
|
|
return widget;
|
|
}
|
|
|
|
InputCategory::InputCategory(QWidget *parent) :
|
|
OptionsCategory(parent)
|
|
{
|
|
setDisplayName(MENU_ENUM_LABEL_VALUE_INPUT_SETTINGS);
|
|
setCategoryIcon("core-input-remapping-options");
|
|
}
|
|
|
|
QVector<OptionsPage*> InputCategory::pages()
|
|
{
|
|
QVector<OptionsPage*> pages;
|
|
|
|
pages << new InputPage(this);
|
|
pages << new HotkeyBindsPage(this);
|
|
|
|
return pages;
|
|
}
|
|
|
|
InputPage::InputPage(QObject *parent) :
|
|
OptionsPage(parent) { }
|
|
|
|
QWidget *InputPage::widget()
|
|
{
|
|
QWidget *widget = new QWidget;
|
|
QVBoxLayout *layout = new QVBoxLayout;
|
|
QHBoxLayout *columnsLayout = new QHBoxLayout;
|
|
QVBoxLayout *leftColumn = new QVBoxLayout;
|
|
QVBoxLayout *rightColumn = new QVBoxLayout;
|
|
SettingsGroup *generalGroup = new SettingsGroup("General");
|
|
SettingsGroup *menuGroup = new SettingsGroup(
|
|
msg_hash_to_str(MENU_ENUM_LABEL_VALUE_INPUT_MENU_SETTINGS));
|
|
SettingsGroup *turboGroup = new SettingsGroup(
|
|
msg_hash_to_str(MENU_ENUM_LABEL_VALUE_INPUT_TURBO_FIRE_SETTINGS));
|
|
SettingsGroup *sensorGroup = new SettingsGroup(
|
|
msg_hash_to_str(MENU_ENUM_LABEL_VALUE_INPUT_SENSOR_SETTINGS));
|
|
SettingsGroup *hapticGroup = new SettingsGroup(
|
|
msg_hash_to_str(MENU_ENUM_LABEL_VALUE_INPUT_HAPTIC_FEEDBACK_SETTINGS));
|
|
|
|
qt_settings_group_add_displaylist(generalGroup,
|
|
DISPLAYLIST_INPUT_SETTINGS_LIST, NULL, 0, NULL, 0);
|
|
qt_settings_group_add_displaylist(menuGroup,
|
|
DISPLAYLIST_INPUT_MENU_SETTINGS_LIST, NULL, 0, NULL, 0);
|
|
qt_settings_group_add_displaylist(turboGroup,
|
|
DISPLAYLIST_INPUT_TURBO_FIRE_SETTINGS_LIST, NULL, 0, NULL, 0);
|
|
qt_settings_group_add_displaylist(sensorGroup,
|
|
DISPLAYLIST_INPUT_SENSOR_SETTINGS_LIST, NULL, 0, NULL, 0);
|
|
qt_settings_group_add_displaylist(hapticGroup,
|
|
DISPLAYLIST_INPUT_HAPTIC_FEEDBACK_SETTINGS_LIST, NULL, 0, NULL, 0);
|
|
|
|
leftColumn->addWidget(generalGroup);
|
|
rightColumn->addWidget(menuGroup);
|
|
rightColumn->addWidget(turboGroup);
|
|
rightColumn->addWidget(sensorGroup);
|
|
rightColumn->addWidget(hapticGroup);
|
|
leftColumn->addStretch();
|
|
rightColumn->addStretch();
|
|
columnsLayout->addLayout(leftColumn, 1);
|
|
columnsLayout->addLayout(rightColumn, 1);
|
|
layout->addLayout(columnsLayout);
|
|
layout->addStretch();
|
|
widget->setLayout(layout);
|
|
return widget;
|
|
}
|
|
|
|
HotkeyBindsPage::HotkeyBindsPage(QObject *parent) :
|
|
OptionsPage(parent)
|
|
{
|
|
setDisplayName(MENU_ENUM_LABEL_VALUE_INPUT_HOTKEY_BINDS);
|
|
}
|
|
|
|
QWidget *HotkeyBindsPage::widget()
|
|
{
|
|
unsigned i;
|
|
QWidget *widget = new QWidget;
|
|
QHBoxLayout *layout = new QHBoxLayout;
|
|
FormLayout *mainLayout = new FormLayout;
|
|
settings_t *settings = config_get_ptr();
|
|
file_list_t *list = (file_list_t*)calloc(1, sizeof(*list));
|
|
|
|
menu_displaylist_build_list(list, settings,
|
|
DISPLAYLIST_INPUT_HOTKEY_BINDS_LIST, true);
|
|
|
|
for (i = 0; i < list->size; i++)
|
|
{
|
|
menu_file_list_cbs_t *cbs = (menu_file_list_cbs_t*)
|
|
file_list_get_actiondata_at_offset(list, i);
|
|
|
|
mainLayout->add(menu_setting_find_enum(cbs->enum_idx));
|
|
}
|
|
|
|
file_list_free(list);
|
|
|
|
layout->addLayout(mainLayout);
|
|
|
|
widget->setLayout(layout);
|
|
|
|
return widget;
|
|
}
|
|
|
|
UserBindsPage::UserBindsPage(QObject *parent) :
|
|
OptionsPage(parent) { setDisplayName("User Binds"); }
|
|
|
|
QWidget *UserBindsPage::widget()
|
|
{
|
|
unsigned p, retro_id;
|
|
settings_t *settings = config_get_ptr();
|
|
unsigned max_users = settings->uints.input_max_users;
|
|
QWidget *widget = new QWidget;
|
|
QGridLayout *layout = new QGridLayout;
|
|
QComboBox *userCombo = new QComboBox;
|
|
QStackedWidget *stack = new QStackedWidget;
|
|
|
|
for (p = 0; p < max_users; p++)
|
|
{
|
|
userCombo->addItem(QString::number(p));
|
|
|
|
QWidget *uWidget = new QWidget();
|
|
FormLayout *form = new FormLayout();
|
|
|
|
for (retro_id = 0; retro_id < RARCH_FIRST_CUSTOM_BIND + 20; retro_id++)
|
|
{
|
|
char descriptor[300];
|
|
const struct retro_keybind *keybind =
|
|
input_config_bind(p, retro_id);
|
|
const struct retro_keybind *auto_bind =
|
|
(const struct retro_keybind*)
|
|
input_config_get_bind_auto(p, retro_id);
|
|
|
|
input_config_get_bind_string(settings, descriptor,
|
|
keybind, auto_bind,
|
|
input_config_bind_names(p, retro_id),
|
|
input_autoconf_bind_names(p, retro_id),
|
|
sizeof(descriptor));
|
|
|
|
QString label = msg_hash_to_str(input_config_bind_label(retro_id));
|
|
|
|
form->addRow(QString(msg_hash_to_str(input_config_bind_label(retro_id))),
|
|
new QPushButton(QString(descriptor)));
|
|
}
|
|
|
|
uWidget->setLayout(form);
|
|
|
|
stack->addWidget(uWidget);
|
|
}
|
|
|
|
connect(userCombo, SIGNAL(activated(int)),
|
|
stack, SLOT(setCurrentIndex(int)));
|
|
|
|
layout->addWidget(userCombo, 0, 0);
|
|
layout->addWidget(stack, 1, 0);
|
|
|
|
widget->setLayout(layout);
|
|
|
|
return widget;
|
|
}
|
|
|
|
LatencyCategory::LatencyCategory(QWidget *parent) :
|
|
OptionsCategory(parent)
|
|
{
|
|
setDisplayName(MENU_ENUM_LABEL_VALUE_LATENCY_SETTINGS);
|
|
setCategoryIcon("menu_latency");
|
|
}
|
|
|
|
QVector<OptionsPage*> LatencyCategory::pages()
|
|
{
|
|
QVector<OptionsPage*> pages;
|
|
pages << new LatencyPage(this);
|
|
return pages;
|
|
}
|
|
|
|
LatencyPage::LatencyPage(QObject *parent) :
|
|
OptionsPage(parent) { }
|
|
|
|
QWidget *LatencyPage::widget()
|
|
{
|
|
QWidget *widget = new QWidget;
|
|
QVBoxLayout *layout = new QVBoxLayout;
|
|
QHBoxLayout *contentLayout = new QHBoxLayout;
|
|
QVBoxLayout *leftColumn = new QVBoxLayout;
|
|
SettingsGroup *latencyGroup = new SettingsGroup("Latency");
|
|
SettingsGroup *runAheadGroup = new SettingsGroup(
|
|
msg_hash_to_str(MENU_ENUM_LABEL_VALUE_RUNAHEAD_MODE));
|
|
rarch_setting_t *hardSyncSetting = menu_setting_find_enum(
|
|
MENU_ENUM_LABEL_VIDEO_HARD_SYNC);
|
|
static const enum msg_hash_enums latencySkip[] = {
|
|
MENU_ENUM_LABEL_RUNAHEAD_MODE,
|
|
MENU_ENUM_LABEL_RUN_AHEAD_FRAMES,
|
|
MENU_ENUM_LABEL_PREEMPT_FRAMES,
|
|
MENU_ENUM_LABEL_RUN_AHEAD_HIDE_WARNINGS,
|
|
MENU_ENUM_LABEL_VIDEO_HARD_SYNC,
|
|
MENU_ENUM_LABEL_VIDEO_HARD_SYNC_FRAMES
|
|
};
|
|
static const enum msg_hash_enums runAheadEntries[] = {
|
|
MENU_ENUM_LABEL_RUNAHEAD_MODE,
|
|
MENU_ENUM_LABEL_RUN_AHEAD_FRAMES,
|
|
MENU_ENUM_LABEL_PREEMPT_FRAMES,
|
|
MENU_ENUM_LABEL_RUN_AHEAD_HIDE_WARNINGS
|
|
};
|
|
|
|
{
|
|
file_list_t *latencyList = qt_displaylist_build(
|
|
DISPLAYLIST_LATENCY_SETTINGS_LIST);
|
|
qt_settings_group_add_list(latencyGroup, latencyList,
|
|
latencySkip, ARRAY_SIZE(latencySkip), NULL, 0);
|
|
latencyGroup->add(MENU_ENUM_LABEL_INPUT_POLL_TYPE_BEHAVIOR);
|
|
qt_settings_group_add_list(runAheadGroup, latencyList, NULL, 0,
|
|
runAheadEntries, ARRAY_SIZE(runAheadEntries));
|
|
if (latencyList)
|
|
file_list_free(latencyList);
|
|
}
|
|
|
|
leftColumn->addWidget(latencyGroup);
|
|
if (hardSyncSetting)
|
|
{
|
|
CheckableSettingsGroup *hardSyncGroup =
|
|
new CheckableSettingsGroup(hardSyncSetting);
|
|
hardSyncGroup->add(MENU_ENUM_LABEL_VIDEO_HARD_SYNC_FRAMES);
|
|
leftColumn->addWidget(hardSyncGroup);
|
|
}
|
|
leftColumn->addWidget(runAheadGroup);
|
|
leftColumn->addStretch();
|
|
contentLayout->addLayout(leftColumn, 1);
|
|
contentLayout->addStretch(1);
|
|
layout->addLayout(contentLayout);
|
|
layout->addStretch();
|
|
widget->setLayout(layout);
|
|
return widget;
|
|
}
|
|
|
|
NetworkCategory::NetworkCategory(QWidget *parent) :
|
|
OptionsCategory(parent)
|
|
{
|
|
setDisplayName(MENU_ENUM_LABEL_VALUE_NETWORK_SETTINGS);
|
|
setCategoryIcon("menu_network");
|
|
}
|
|
|
|
QVector<OptionsPage*> NetworkCategory::pages()
|
|
{
|
|
QVector<OptionsPage*> pages;
|
|
|
|
pages << new NetplayPage(this);
|
|
|
|
return pages;
|
|
}
|
|
|
|
NetplayPage::NetplayPage(QObject *parent) :
|
|
OptionsPage(parent)
|
|
{
|
|
setDisplayName("General");
|
|
}
|
|
|
|
QWidget *NetplayPage::widget()
|
|
{
|
|
QWidget *widget = new QWidget;
|
|
QVBoxLayout *mainLayout = new QVBoxLayout;
|
|
QHBoxLayout *columnsLayout = new QHBoxLayout;
|
|
QVBoxLayout *leftColumn = new QVBoxLayout;
|
|
QVBoxLayout *rightColumn = new QVBoxLayout;
|
|
SettingsGroup *netplayGroup = new SettingsGroup("Netplay");
|
|
SettingsGroup *updaterGroup = new SettingsGroup(
|
|
msg_hash_to_str(MENU_ENUM_LABEL_VALUE_UPDATER_SETTINGS));
|
|
QGridLayout *layout = new QGridLayout;
|
|
FormLayout *checksLayout = new FormLayout;
|
|
SettingsGroup *serverGroup = new SettingsGroup("Server");
|
|
SettingsGroup *syncGroup = new SettingsGroup("Synchronization");
|
|
SettingsGroup *slaveGroup = new SettingsGroup("Slave-Mode");
|
|
SettingsGroup *inputGroup = new SettingsGroup("Input Sharing");
|
|
SettingsGroup *deviceGroup = new SettingsGroup("Device Request");
|
|
SettingsGroup *networkGroup = new SettingsGroup("Network Services");
|
|
#ifdef HAVE_SMBCLIENT
|
|
SettingsGroup *smbGroup = new SettingsGroup(
|
|
msg_hash_to_str(MENU_ENUM_LABEL_VALUE_SMB_CLIENT_SETTINGS));
|
|
#endif
|
|
#ifdef HAVE_NFSCLIENT
|
|
SettingsGroup *nfsGroup = new SettingsGroup(
|
|
msg_hash_to_str(MENU_ENUM_LABEL_VALUE_NFS_CLIENT_SETTINGS));
|
|
#endif
|
|
FormLayout *serverForm = new FormLayout;
|
|
QGridLayout *requestGrid = new QGridLayout;
|
|
unsigned i = 0;
|
|
unsigned row = 0;
|
|
unsigned column = 0;
|
|
static const enum msg_hash_enums networkSkip[] = {
|
|
MENU_ENUM_LABEL_NETPLAY_PUBLIC_ANNOUNCE,
|
|
MENU_ENUM_LABEL_NETPLAY_USE_MITM_SERVER,
|
|
MENU_ENUM_LABEL_NETPLAY_MITM_SERVER,
|
|
MENU_ENUM_LABEL_NETPLAY_CUSTOM_MITM_SERVER,
|
|
MENU_ENUM_LABEL_NETPLAY_IP_ADDRESS,
|
|
MENU_ENUM_LABEL_NETPLAY_TCP_UDP_PORT,
|
|
MENU_ENUM_LABEL_NETPLAY_MAX_CONNECTIONS,
|
|
MENU_ENUM_LABEL_NETPLAY_MAX_PING,
|
|
MENU_ENUM_LABEL_NETPLAY_PASSWORD,
|
|
MENU_ENUM_LABEL_NETPLAY_SPECTATE_PASSWORD,
|
|
MENU_ENUM_LABEL_NETPLAY_START_AS_SPECTATOR,
|
|
MENU_ENUM_LABEL_NETPLAY_FADE_CHAT,
|
|
MENU_ENUM_LABEL_NETPLAY_CHAT_COLOR_NAME,
|
|
MENU_ENUM_LABEL_NETPLAY_CHAT_COLOR_MSG,
|
|
MENU_ENUM_LABEL_NETPLAY_ALLOW_PAUSING,
|
|
MENU_ENUM_LABEL_NETPLAY_ALLOW_SLAVES,
|
|
MENU_ENUM_LABEL_NETPLAY_REQUIRE_SLAVES,
|
|
MENU_ENUM_LABEL_NETPLAY_CHECK_FRAMES,
|
|
MENU_ENUM_LABEL_NETPLAY_INPUT_LATENCY_FRAMES_MIN,
|
|
MENU_ENUM_LABEL_NETPLAY_INPUT_LATENCY_FRAMES_RANGE,
|
|
MENU_ENUM_LABEL_NETPLAY_NAT_TRAVERSAL,
|
|
MENU_ENUM_LABEL_NETPLAY_SHARE_DIGITAL,
|
|
MENU_ENUM_LABEL_NETPLAY_SHARE_ANALOG,
|
|
MENU_ENUM_LABEL_NETWORK_ON_DEMAND_THUMBNAILS,
|
|
MENU_ENUM_LABEL_NETPLAY_ANALOG_JOYPADS,
|
|
MENU_ENUM_LABEL_NETPLAY_LOCKSTEP,
|
|
MENU_ENUM_LABEL_NETPLAY_REQUEST_DEVICES,
|
|
#ifdef HAVE_SMBCLIENT
|
|
MENU_ENUM_LABEL_SMB_CLIENT_SETTINGS,
|
|
#endif
|
|
#ifdef HAVE_NFSCLIENT
|
|
MENU_ENUM_LABEL_NFS_CLIENT_SETTINGS,
|
|
#endif
|
|
};
|
|
|
|
checksLayout->add(menu_setting_find_enum(MENU_ENUM_LABEL_NETPLAY_PUBLIC_ANNOUNCE));
|
|
checksLayout->add(menu_setting_find_enum(MENU_ENUM_LABEL_NETPLAY_START_AS_SPECTATOR));
|
|
checksLayout->add(menu_setting_find_enum(MENU_ENUM_LABEL_NETPLAY_FADE_CHAT));
|
|
checksLayout->add(menu_setting_find_enum(MENU_ENUM_LABEL_NETPLAY_ALLOW_PAUSING));
|
|
checksLayout->add(menu_setting_find_enum(MENU_ENUM_LABEL_NETPLAY_ANALOG_JOYPADS));
|
|
checksLayout->add(menu_setting_find_enum(MENU_ENUM_LABEL_NETPLAY_LOCKSTEP));
|
|
checksLayout->add(menu_setting_find_enum(MENU_ENUM_LABEL_NETWORK_ON_DEMAND_THUMBNAILS));
|
|
{
|
|
const enum msg_hash_enums colorSettings[] = {
|
|
MENU_ENUM_LABEL_NETPLAY_CHAT_COLOR_NAME,
|
|
MENU_ENUM_LABEL_NETPLAY_CHAT_COLOR_MSG
|
|
};
|
|
unsigned c;
|
|
for (c = 0; c < ARRAY_SIZE(colorSettings); c++)
|
|
{
|
|
rarch_setting_t *colorSetting = menu_setting_find_enum(colorSettings[c]);
|
|
if (colorSetting && colorSetting->value.target.unsigned_integer)
|
|
{
|
|
QPushButton *colorButton = new QPushButton;
|
|
const auto updateColorButton = [colorSetting, colorButton]()
|
|
{
|
|
const unsigned color = *colorSetting->value.target.unsigned_integer & 0xFFFFFF;
|
|
colorButton->setText(QString("#%1").arg(color, 6, 16, QChar('0')).toUpper());
|
|
colorButton->setStyleSheet(QString("background-color: #%1;").arg(color, 6, 16, QChar('0')));
|
|
};
|
|
updateColorButton();
|
|
QObject::connect(colorButton, &QPushButton::clicked,
|
|
[colorSetting, updateColorButton]()
|
|
{
|
|
const QColor initial((int)((*colorSetting->value.target.unsigned_integer >> 16) & 0xFF),
|
|
(int)((*colorSetting->value.target.unsigned_integer >> 8) & 0xFF),
|
|
(int)(*colorSetting->value.target.unsigned_integer & 0xFF));
|
|
const QColor chosen = QColorDialog::getColor(initial, nullptr);
|
|
if (chosen.isValid())
|
|
{
|
|
*colorSetting->value.target.unsigned_integer =
|
|
(unsigned)((chosen.red() << 16) | (chosen.green() << 8) | chosen.blue());
|
|
setting_generic_handle_change(colorSetting);
|
|
updateColorButton();
|
|
}
|
|
});
|
|
checksLayout->addRow(colorSetting->short_description
|
|
? colorSetting->short_description : "Chat Color", colorButton);
|
|
}
|
|
}
|
|
}
|
|
|
|
serverForm->add(menu_setting_find_enum(MENU_ENUM_LABEL_NETPLAY_IP_ADDRESS));
|
|
serverForm->add(menu_setting_find_enum(MENU_ENUM_LABEL_NETPLAY_TCP_UDP_PORT));
|
|
serverForm->add(menu_setting_find_enum(MENU_ENUM_LABEL_NETPLAY_MAX_CONNECTIONS));
|
|
serverForm->add(menu_setting_find_enum(MENU_ENUM_LABEL_NETPLAY_MAX_PING));
|
|
serverForm->add(menu_setting_find_enum(MENU_ENUM_LABEL_NETPLAY_PASSWORD));
|
|
serverForm->add(menu_setting_find_enum(MENU_ENUM_LABEL_NETPLAY_SPECTATE_PASSWORD));
|
|
serverForm->add(menu_setting_find_enum(MENU_ENUM_LABEL_NETPLAY_NAT_TRAVERSAL));
|
|
|
|
{
|
|
QGroupBox *mitmGroup = createMitmServerGroup();
|
|
if (mitmGroup)
|
|
serverGroup->addRow(mitmGroup);
|
|
}
|
|
/* Keep address/password fields at full width beneath the relay
|
|
* selection controls; placing the two forms side-by-side squeezed
|
|
* the editable fields into a narrow column. */
|
|
serverGroup->addRow(serverForm);
|
|
|
|
slaveGroup->add(MENU_ENUM_LABEL_NETPLAY_ALLOW_SLAVES);
|
|
slaveGroup->add(MENU_ENUM_LABEL_NETPLAY_REQUIRE_SLAVES);
|
|
|
|
syncGroup->add(MENU_ENUM_LABEL_NETPLAY_CHECK_FRAMES);
|
|
syncGroup->add(MENU_ENUM_LABEL_NETPLAY_INPUT_LATENCY_FRAMES_MIN);
|
|
syncGroup->add(MENU_ENUM_LABEL_NETPLAY_INPUT_LATENCY_FRAMES_RANGE);
|
|
|
|
inputGroup->add(MENU_ENUM_LABEL_NETPLAY_SHARE_DIGITAL);
|
|
inputGroup->add(MENU_ENUM_LABEL_NETPLAY_SHARE_ANALOG);
|
|
|
|
for (i = 0; i < MAX_USERS; i++)
|
|
{
|
|
if (column % 4 == 0)
|
|
{
|
|
column = 0;
|
|
row++;
|
|
}
|
|
requestGrid->addWidget(new CheckBox((enum msg_hash_enums)(
|
|
MENU_ENUM_LABEL_NETPLAY_REQUEST_DEVICE_1 + i)), row, column);
|
|
column++;
|
|
}
|
|
|
|
deviceGroup->addRow(requestGrid);
|
|
|
|
layout->addLayout(checksLayout, 0, 0, 1, 2);
|
|
layout->addWidget(serverGroup, 1, 0, 1, 2);
|
|
layout->addWidget(slaveGroup, 2, 0, 1, 1);
|
|
layout->addWidget(syncGroup, 2, 1, 2, 1);
|
|
layout->addWidget(inputGroup, 3, 0, 1, 1);
|
|
layout->addWidget(deviceGroup, 4, 0, 1, 2);
|
|
|
|
netplayGroup->addRow(layout);
|
|
|
|
/* Keep the Network category in sync with the internal menu list.
|
|
* The entries already represented by the custom Netplay controls above
|
|
* are excluded; all remaining ordinary settings are added here. */
|
|
qt_settings_group_add_displaylist(networkGroup,
|
|
DISPLAYLIST_NETWORK_SETTINGS_LIST, networkSkip,
|
|
ARRAY_SIZE(networkSkip), NULL, 0);
|
|
#ifdef HAVE_SMBCLIENT
|
|
qt_settings_group_add_displaylist(smbGroup,
|
|
DISPLAYLIST_SMB_CLIENT_SETTINGS_LIST, NULL, 0, NULL, 0);
|
|
networkGroup->addRow(smbGroup);
|
|
#endif
|
|
#ifdef HAVE_NFSCLIENT
|
|
qt_settings_group_add_displaylist(nfsGroup,
|
|
DISPLAYLIST_NFS_CLIENT_SETTINGS_LIST, NULL, 0, NULL, 0);
|
|
networkGroup->addRow(nfsGroup);
|
|
#endif
|
|
|
|
{
|
|
static const enum msg_hash_enums updaterPathSkip[] = {
|
|
MENU_ENUM_LABEL_CORE_UPDATER_BUILDBOT_URL,
|
|
MENU_ENUM_LABEL_BUILDBOT_ASSETS_URL
|
|
};
|
|
qt_settings_group_add_displaylist(updaterGroup,
|
|
DISPLAYLIST_UPDATER_SETTINGS_LIST, updaterPathSkip,
|
|
ARRAY_SIZE(updaterPathSkip), NULL, 0);
|
|
qt_settings_group_add_compact_path(updaterGroup,
|
|
MENU_ENUM_LABEL_CORE_UPDATER_BUILDBOT_URL, false);
|
|
qt_settings_group_add_compact_path(updaterGroup,
|
|
MENU_ENUM_LABEL_BUILDBOT_ASSETS_URL, false);
|
|
}
|
|
|
|
leftColumn->addWidget(netplayGroup);
|
|
rightColumn->addWidget(networkGroup);
|
|
rightColumn->addWidget(updaterGroup);
|
|
leftColumn->addStretch();
|
|
rightColumn->addStretch();
|
|
columnsLayout->addLayout(leftColumn, 1);
|
|
columnsLayout->addLayout(rightColumn, 1);
|
|
mainLayout->addLayout(columnsLayout);
|
|
widget->setLayout(mainLayout);
|
|
|
|
return widget;
|
|
}
|
|
|
|
QGroupBox *NetplayPage::createMitmServerGroup()
|
|
{
|
|
#ifdef HAVE_NETWORKING
|
|
size_t i;
|
|
const char *netplay_mitm_server;
|
|
CheckableSettingsGroup *groupBox = new CheckableSettingsGroup(
|
|
MENU_ENUM_LABEL_NETPLAY_USE_MITM_SERVER);
|
|
QButtonGroup *buttonGroup = new QButtonGroup(this);
|
|
rarch_setting_t *setting = menu_setting_find_enum(
|
|
MENU_ENUM_LABEL_NETPLAY_MITM_SERVER);
|
|
|
|
if (!setting)
|
|
return nullptr;
|
|
|
|
netplay_mitm_server = setting->value.target.string;
|
|
|
|
for (i = 0; i < ARRAY_SIZE(netplay_mitm_server_list); i++)
|
|
{
|
|
const mitm_server_t *server = &netplay_mitm_server_list[i];
|
|
QRadioButton *radioButton = new QRadioButton(
|
|
msg_hash_to_str(server->description));
|
|
|
|
if (string_is_equal(server->name, netplay_mitm_server))
|
|
radioButton->setChecked(true);
|
|
|
|
buttonGroup->addButton(radioButton, i);
|
|
groupBox->addRow(radioButton);
|
|
}
|
|
|
|
groupBox->add(MENU_ENUM_LABEL_NETPLAY_CUSTOM_MITM_SERVER);
|
|
|
|
#if (QT_VERSION >= QT_VERSION_CHECK(6, 0, 0))
|
|
connect(buttonGroup, &QButtonGroup::idClicked, this,
|
|
&NetplayPage::onRadioButtonClicked);
|
|
#else
|
|
connect(buttonGroup, SIGNAL(buttonClicked(int)), this,
|
|
SLOT(onRadioButtonClicked(int)));
|
|
#endif
|
|
|
|
return groupBox;
|
|
#else
|
|
return nullptr;
|
|
#endif
|
|
}
|
|
|
|
void NetplayPage::onRadioButtonClicked(int id)
|
|
{
|
|
#ifdef HAVE_NETWORKING
|
|
rarch_setting_t *setting =
|
|
menu_setting_find_enum(MENU_ENUM_LABEL_NETPLAY_MITM_SERVER);
|
|
|
|
if (!setting)
|
|
return;
|
|
|
|
strlcpy(setting->value.target.string,
|
|
netplay_mitm_server_list[id].name, setting->size);
|
|
#else
|
|
(void)id;
|
|
#endif
|
|
}
|
|
|
|
OnscreenDisplayCategory::OnscreenDisplayCategory(QWidget *parent) :
|
|
OptionsCategory(parent)
|
|
{
|
|
setDisplayName(MENU_ENUM_LABEL_VALUE_ONSCREEN_DISPLAY_SETTINGS);
|
|
setCategoryIcon("menu_osd");
|
|
}
|
|
|
|
QVector<OptionsPage*> OnscreenDisplayCategory::pages()
|
|
{
|
|
QVector<OptionsPage*> pages;
|
|
|
|
pages << new OverlayPage(this);
|
|
|
|
return pages;
|
|
}
|
|
|
|
NotificationsPage::NotificationsPage(QObject *parent) :
|
|
OptionsPage(parent)
|
|
{
|
|
setDisplayName(MENU_ENUM_LABEL_VALUE_ONSCREEN_NOTIFICATIONS_SETTINGS);
|
|
}
|
|
|
|
QWidget *NotificationsPage::widget()
|
|
{
|
|
QWidget *widget = new QWidget;
|
|
QVBoxLayout *layout = new QVBoxLayout;
|
|
CheckableSettingsGroup *notificationsGroup = new CheckableSettingsGroup(
|
|
MENU_ENUM_LABEL_VIDEO_FONT_ENABLE);
|
|
CheckableSettingsGroup *bgGroup = new CheckableSettingsGroup(
|
|
MENU_ENUM_LABEL_VIDEO_MESSAGE_BGCOLOR_ENABLE);
|
|
|
|
notificationsGroup->add(MENU_ENUM_LABEL_FPS_SHOW);
|
|
notificationsGroup->add(MENU_ENUM_LABEL_FPS_UPDATE_INTERVAL);
|
|
notificationsGroup->add(MENU_ENUM_LABEL_FRAMECOUNT_SHOW);
|
|
notificationsGroup->add(MENU_ENUM_LABEL_MEMORY_SHOW);
|
|
notificationsGroup->add(MENU_ENUM_LABEL_MEMORY_UPDATE_INTERVAL);
|
|
notificationsGroup->add(MENU_ENUM_LABEL_TIME_SHOW);
|
|
notificationsGroup->add(MENU_ENUM_LABEL_STATISTICS_SHOW);
|
|
notificationsGroup->add(MENU_ENUM_LABEL_NETPLAY_PING_SHOW);
|
|
notificationsGroup->add(MENU_ENUM_LABEL_VIDEO_FONT_PATH);
|
|
notificationsGroup->add(MENU_ENUM_LABEL_VIDEO_FONT_SIZE);
|
|
notificationsGroup->add(MENU_ENUM_LABEL_VIDEO_MESSAGE_POS_X);
|
|
notificationsGroup->add(MENU_ENUM_LABEL_VIDEO_MESSAGE_POS_Y);
|
|
/* TODO/FIXME - localize */
|
|
notificationsGroup->addRow("Notification Color: ", new FloatColorButton(
|
|
MENU_ENUM_LABEL_VIDEO_MESSAGE_COLOR_RED,
|
|
MENU_ENUM_LABEL_VIDEO_MESSAGE_COLOR_GREEN,
|
|
MENU_ENUM_LABEL_VIDEO_MESSAGE_COLOR_BLUE));
|
|
/* TODO/FIXME - localize */
|
|
bgGroup->addRow("Notification Background Color: ", new UIntColorButton(
|
|
MENU_ENUM_LABEL_VIDEO_MESSAGE_BGCOLOR_RED,
|
|
MENU_ENUM_LABEL_VIDEO_MESSAGE_BGCOLOR_GREEN,
|
|
MENU_ENUM_LABEL_VIDEO_MESSAGE_BGCOLOR_BLUE));
|
|
bgGroup->add(MENU_ENUM_LABEL_VIDEO_MESSAGE_BGCOLOR_OPACITY);
|
|
|
|
notificationsGroup->addRow(bgGroup);
|
|
|
|
notificationsGroup->add(MENU_ENUM_LABEL_MENU_WIDGETS_ENABLE);
|
|
notificationsGroup->add(MENU_ENUM_LABEL_MENU_WIDGET_SCALE_AUTO);
|
|
notificationsGroup->add(MENU_ENUM_LABEL_MENU_WIDGET_SCALE_FACTOR);
|
|
#if !(defined(RARCH_CONSOLE) || defined(RARCH_MOBILE))
|
|
notificationsGroup->add(MENU_ENUM_LABEL_MENU_WIDGET_SCALE_FACTOR_WINDOWED);
|
|
#endif
|
|
notificationsGroup->add(MENU_ENUM_LABEL_MENU_SHOW_LOAD_CONTENT_ANIMATION);
|
|
notificationsGroup->add(MENU_ENUM_LABEL_NOTIFICATION_SHOW_AUTOCONFIG);
|
|
notificationsGroup->add(MENU_ENUM_LABEL_NOTIFICATION_SHOW_AUTOCONFIG_FAILS);
|
|
notificationsGroup->add(MENU_ENUM_LABEL_NOTIFICATION_SHOW_REMAP_LOAD);
|
|
#ifdef HAVE_CORE_SIGNING_TEST_KEY
|
|
notificationsGroup->add(MENU_ENUM_LABEL_NOTIFICATION_SHOW_CORE_SIGNING_TEST_KEY);
|
|
#endif
|
|
notificationsGroup->add(MENU_ENUM_LABEL_NOTIFICATION_SHOW_CONFIG_OVERRIDE_LOAD);
|
|
notificationsGroup->add(MENU_ENUM_LABEL_NOTIFICATION_SHOW_SET_INITIAL_DISK);
|
|
notificationsGroup->add(MENU_ENUM_LABEL_NOTIFICATION_SHOW_SAVE_STATE);
|
|
notificationsGroup->add(MENU_ENUM_LABEL_NOTIFICATION_SHOW_FAST_FORWARD);
|
|
notificationsGroup->add(MENU_ENUM_LABEL_NOTIFICATION_SHOW_CHEATS_APPLIED);
|
|
notificationsGroup->add(MENU_ENUM_LABEL_NOTIFICATION_SHOW_SCREENSHOT);
|
|
notificationsGroup->add(MENU_ENUM_LABEL_NOTIFICATION_SHOW_SCREENSHOT_DURATION);
|
|
notificationsGroup->add(MENU_ENUM_LABEL_NOTIFICATION_SHOW_SCREENSHOT_FLASH);
|
|
notificationsGroup->add(MENU_ENUM_LABEL_NOTIFICATION_SHOW_REFRESH_RATE);
|
|
notificationsGroup->add(MENU_ENUM_LABEL_NOTIFICATION_SHOW_NETPLAY_EXTRA);
|
|
notificationsGroup->add(MENU_ENUM_LABEL_NOTIFICATION_SHOW_WHEN_MENU_IS_ALIVE);
|
|
{
|
|
SettingsGroup *notificationViewsGroup = new SettingsGroup("Additional Notification Options");
|
|
static const enum msg_hash_enums notificationViewsEntries[] = {
|
|
MENU_ENUM_LABEL_STATISTICS_HIDE_IN_MENU,
|
|
MENU_ENUM_LABEL_NOTIFICATION_SHOW_PATCH_APPLIED,
|
|
MENU_ENUM_LABEL_NOTIFICATION_SHOW_DISK_CONTROL
|
|
};
|
|
qt_settings_group_add_displaylist(notificationViewsGroup,
|
|
DISPLAYLIST_ONSCREEN_NOTIFICATIONS_VIEWS_SETTINGS_LIST,
|
|
NULL, 0, notificationViewsEntries,
|
|
ARRAY_SIZE(notificationViewsEntries));
|
|
notificationsGroup->addRow(notificationViewsGroup);
|
|
}
|
|
|
|
layout->addWidget(notificationsGroup);
|
|
|
|
layout->addStretch();
|
|
|
|
widget->setLayout(layout);
|
|
|
|
return widget;
|
|
}
|
|
|
|
OverlayPage::OverlayPage(QObject *parent) :
|
|
OptionsPage(parent)
|
|
{
|
|
setDisplayName("General");
|
|
}
|
|
|
|
QWidget *OverlayPage::widget()
|
|
{
|
|
QWidget *widget = new QWidget;
|
|
QVBoxLayout *layout = new QVBoxLayout;
|
|
QHBoxLayout *columnsLayout = new QHBoxLayout;
|
|
QVBoxLayout *leftColumn = new QVBoxLayout;
|
|
QVBoxLayout *rightColumn = new QVBoxLayout;
|
|
|
|
#if defined(HAVE_OVERLAY)
|
|
{
|
|
CheckableSettingsGroup *overlayGroup = new CheckableSettingsGroup(
|
|
MENU_ENUM_LABEL_INPUT_OVERLAY_ENABLE);
|
|
|
|
overlayGroup->add(MENU_ENUM_LABEL_OVERLAY_AUTOLOAD_PREFERRED);
|
|
overlayGroup->add(MENU_ENUM_LABEL_INPUT_OVERLAY_AUTO_ROTATE);
|
|
overlayGroup->add(MENU_ENUM_LABEL_INPUT_OVERLAY_HIDE_IN_MENU);
|
|
overlayGroup->add(MENU_ENUM_LABEL_INPUT_OVERLAY_HIDE_WHEN_GAMEPAD_CONNECTED);
|
|
overlayGroup->add(MENU_ENUM_LABEL_INPUT_OVERLAY_SHOW_MOUSE_CURSOR);
|
|
overlayGroup->add(MENU_ENUM_LABEL_INPUT_OVERLAY_SHOW_INPUTS);
|
|
overlayGroup->add(MENU_ENUM_LABEL_INPUT_OVERLAY_SHOW_INPUTS_PORT);
|
|
overlayGroup->add(MENU_ENUM_LABEL_OVERLAY_PRESET);
|
|
overlayGroup->add(MENU_ENUM_LABEL_OVERLAY_OPACITY);
|
|
overlayGroup->add(MENU_ENUM_LABEL_OVERLAY_SCALE_LANDSCAPE);
|
|
overlayGroup->add(MENU_ENUM_LABEL_OVERLAY_ASPECT_ADJUST_LANDSCAPE);
|
|
overlayGroup->add(MENU_ENUM_LABEL_OVERLAY_X_SEPARATION_LANDSCAPE);
|
|
overlayGroup->add(MENU_ENUM_LABEL_OVERLAY_Y_SEPARATION_LANDSCAPE);
|
|
overlayGroup->add(MENU_ENUM_LABEL_OVERLAY_X_OFFSET_LANDSCAPE);
|
|
overlayGroup->add(MENU_ENUM_LABEL_OVERLAY_Y_OFFSET_LANDSCAPE);
|
|
overlayGroup->add(MENU_ENUM_LABEL_OVERLAY_SCALE_PORTRAIT);
|
|
overlayGroup->add(MENU_ENUM_LABEL_OVERLAY_ASPECT_ADJUST_PORTRAIT);
|
|
overlayGroup->add(MENU_ENUM_LABEL_OVERLAY_X_SEPARATION_PORTRAIT);
|
|
overlayGroup->add(MENU_ENUM_LABEL_OVERLAY_X_OFFSET_PORTRAIT);
|
|
overlayGroup->add(MENU_ENUM_LABEL_OVERLAY_Y_OFFSET_PORTRAIT);
|
|
{
|
|
static const enum msg_hash_enums overlayExtraEntries[] = {
|
|
MENU_ENUM_LABEL_INPUT_OVERLAY_BEHIND_MENU,
|
|
MENU_ENUM_LABEL_INPUT_OVERLAY_DPAD_DIAGONAL_SENSITIVITY,
|
|
MENU_ENUM_LABEL_INPUT_OVERLAY_ABXY_DIAGONAL_SENSITIVITY,
|
|
MENU_ENUM_LABEL_INPUT_OVERLAY_DPAD_METHOD,
|
|
MENU_ENUM_LABEL_INPUT_OVERLAY_ABXY_METHOD,
|
|
MENU_ENUM_LABEL_INPUT_OVERLAY_CONTACT_SCALE,
|
|
MENU_ENUM_LABEL_INPUT_OVERLAY_ANALOG_RECENTER_ZONE,
|
|
MENU_ENUM_LABEL_INPUT_OVERLAY_AUTO_SCALE,
|
|
MENU_ENUM_LABEL_OVERLAY_Y_SEPARATION_PORTRAIT,
|
|
MENU_ENUM_LABEL_INPUT_OVERLAY_POINTER_ENABLE
|
|
};
|
|
qt_settings_group_add_displaylist(overlayGroup,
|
|
DISPLAYLIST_ONSCREEN_OVERLAY_SETTINGS_LIST,
|
|
NULL, 0, overlayExtraEntries,
|
|
ARRAY_SIZE(overlayExtraEntries));
|
|
}
|
|
{
|
|
SettingsGroup *lightgunGroup = new SettingsGroup(
|
|
msg_hash_to_str(MENU_ENUM_LABEL_VALUE_OVERLAY_LIGHTGUN_SETTINGS));
|
|
SettingsGroup *mouseGroup = new SettingsGroup(
|
|
msg_hash_to_str(MENU_ENUM_LABEL_VALUE_OVERLAY_MOUSE_SETTINGS));
|
|
SettingsGroup *oskGroup = new SettingsGroup(
|
|
msg_hash_to_str(MENU_ENUM_LABEL_VALUE_OSK_OVERLAY_SETTINGS));
|
|
qt_settings_group_add_displaylist(lightgunGroup,
|
|
DISPLAYLIST_OVERLAY_LIGHTGUN_SETTINGS_LIST, NULL, 0, NULL, 0);
|
|
qt_settings_group_add_displaylist(mouseGroup,
|
|
DISPLAYLIST_OVERLAY_MOUSE_SETTINGS_LIST, NULL, 0, NULL, 0);
|
|
qt_settings_group_add_displaylist(oskGroup,
|
|
DISPLAYLIST_OSK_OVERLAY_SETTINGS_LIST, NULL, 0, NULL, 0);
|
|
overlayGroup->addRow(lightgunGroup);
|
|
overlayGroup->addRow(mouseGroup);
|
|
overlayGroup->addRow(oskGroup);
|
|
}
|
|
|
|
rightColumn->addWidget(overlayGroup);
|
|
}
|
|
#endif
|
|
|
|
{
|
|
NotificationsPage *notificationsPage = new NotificationsPage(this);
|
|
leftColumn->addWidget(notificationsPage->widget());
|
|
}
|
|
|
|
leftColumn->addStretch();
|
|
rightColumn->addStretch();
|
|
columnsLayout->addLayout(leftColumn, 1);
|
|
columnsLayout->addLayout(rightColumn, 1);
|
|
layout->addLayout(columnsLayout);
|
|
widget->setLayout(layout);
|
|
return widget;
|
|
}
|
|
|
|
PlaylistsCategory::PlaylistsCategory(QWidget *parent) : OptionsCategory(parent)
|
|
{
|
|
setDisplayName(MENU_ENUM_LABEL_VALUE_PLAYLIST_SETTINGS);
|
|
setCategoryIcon("menu_playlist");
|
|
}
|
|
|
|
QVector<OptionsPage*> PlaylistsCategory::pages()
|
|
{
|
|
QVector<OptionsPage*> pages;
|
|
|
|
pages << new PlaylistsPage(this);
|
|
|
|
return pages;
|
|
}
|
|
|
|
PlaylistsPage::PlaylistsPage(QObject *parent) :
|
|
OptionsPage(parent)
|
|
{
|
|
}
|
|
|
|
QWidget *PlaylistsPage::widget()
|
|
{
|
|
QWidget *widget = new QWidget;
|
|
QVBoxLayout *layout = new QVBoxLayout;
|
|
QHBoxLayout *contentLayout = new QHBoxLayout;
|
|
QVBoxLayout *leftColumn = new QVBoxLayout;
|
|
CheckableSettingsGroup *historyGroup = new CheckableSettingsGroup(
|
|
MENU_ENUM_LABEL_HISTORY_LIST_ENABLE);
|
|
SettingsGroup *playlistGroup = new SettingsGroup("Playlist");
|
|
SettingsGroup *scanningGroup = new SettingsGroup("Scanning");
|
|
SettingsGroup *additionalGroup = new SettingsGroup("Additional Settings");
|
|
static const enum msg_hash_enums playlistSkip[] = {
|
|
MENU_ENUM_LABEL_HISTORY_LIST_ENABLE,
|
|
MENU_ENUM_LABEL_CONTENT_HISTORY_SIZE,
|
|
MENU_ENUM_LABEL_PLAYLIST_ENTRY_RENAME,
|
|
MENU_ENUM_LABEL_PLAYLIST_SORT_ALPHABETICAL,
|
|
MENU_ENUM_LABEL_PLAYLIST_USE_OLD_FORMAT,
|
|
MENU_ENUM_LABEL_PLAYLIST_COMPRESSION,
|
|
MENU_ENUM_LABEL_PLAYLIST_SHOW_SUBLABELS,
|
|
MENU_ENUM_LABEL_PLAYLIST_FUZZY_ARCHIVE_MATCH,
|
|
MENU_ENUM_LABEL_SCAN_WITHOUT_CORE_MATCH
|
|
};
|
|
|
|
historyGroup->add(MENU_ENUM_LABEL_CONTENT_HISTORY_SIZE);
|
|
|
|
playlistGroup->add(MENU_ENUM_LABEL_PLAYLIST_ENTRY_RENAME);
|
|
playlistGroup->add(MENU_ENUM_LABEL_PLAYLIST_SORT_ALPHABETICAL);
|
|
playlistGroup->add(MENU_ENUM_LABEL_PLAYLIST_USE_OLD_FORMAT);
|
|
playlistGroup->add(MENU_ENUM_LABEL_PLAYLIST_COMPRESSION);
|
|
playlistGroup->add(MENU_ENUM_LABEL_PLAYLIST_SHOW_SUBLABELS);
|
|
playlistGroup->add(MENU_ENUM_LABEL_PLAYLIST_FUZZY_ARCHIVE_MATCH);
|
|
scanningGroup->add(MENU_ENUM_LABEL_SCAN_WITHOUT_CORE_MATCH);
|
|
qt_settings_group_add_displaylist(additionalGroup,
|
|
DISPLAYLIST_PLAYLIST_SETTINGS_LIST,
|
|
playlistSkip, ARRAY_SIZE(playlistSkip), NULL, 0);
|
|
|
|
leftColumn->addWidget(historyGroup);
|
|
leftColumn->addWidget(playlistGroup);
|
|
leftColumn->addWidget(scanningGroup);
|
|
leftColumn->addWidget(additionalGroup);
|
|
leftColumn->addStretch();
|
|
contentLayout->addLayout(leftColumn, 1);
|
|
contentLayout->addStretch(1);
|
|
layout->addLayout(contentLayout);
|
|
layout->addStretch();
|
|
widget->setLayout(layout);
|
|
return widget;
|
|
}
|
|
|
|
RecordingCategory::RecordingCategory(QWidget *parent) :
|
|
OptionsCategory(parent)
|
|
{
|
|
setDisplayName(MENU_ENUM_LABEL_VALUE_RECORDING_SETTINGS);
|
|
setCategoryIcon("menu_record");
|
|
}
|
|
|
|
QVector<OptionsPage*> RecordingCategory::pages()
|
|
{
|
|
QVector<OptionsPage*> pages;
|
|
|
|
pages << new RecordingPage(this);
|
|
|
|
return pages;
|
|
}
|
|
|
|
RecordingPage::RecordingPage(QObject *parent) :
|
|
OptionsPage(parent)
|
|
{
|
|
}
|
|
|
|
QWidget *RecordingPage::widget()
|
|
{
|
|
QWidget *widget = new QWidget;
|
|
QVBoxLayout *layout = new QVBoxLayout;
|
|
QHBoxLayout *columnsLayout = new QHBoxLayout;
|
|
QVBoxLayout *leftColumn = new QVBoxLayout;
|
|
SettingsGroup *recordingGroup = new SettingsGroup("Recording");
|
|
SettingsGroup *streamingGroup = new SettingsGroup("Streaming");
|
|
QHBoxLayout *streamingModeLayout = new QHBoxLayout;
|
|
static const enum msg_hash_enums recordingSkip[] = {
|
|
MENU_ENUM_LABEL_STREAMING_MODE,
|
|
MENU_ENUM_LABEL_VIDEO_STREAM_QUALITY,
|
|
MENU_ENUM_LABEL_STREAM_CONFIG,
|
|
MENU_ENUM_LABEL_STREAMING_TITLE,
|
|
MENU_ENUM_LABEL_STREAMING_URL,
|
|
MENU_ENUM_LABEL_UDP_STREAM_PORT,
|
|
MENU_ENUM_LABEL_RECORDING_OUTPUT_DIRECTORY
|
|
};
|
|
static const enum msg_hash_enums streamingEntries[] = {
|
|
MENU_ENUM_LABEL_STREAM_CONFIG,
|
|
MENU_ENUM_LABEL_STREAMING_TITLE,
|
|
MENU_ENUM_LABEL_STREAMING_URL,
|
|
MENU_ENUM_LABEL_UDP_STREAM_PORT
|
|
};
|
|
|
|
file_list_t *recordingList = qt_displaylist_build(
|
|
DISPLAYLIST_RECORDING_SETTINGS_LIST);
|
|
|
|
qt_settings_group_add_list(recordingGroup, recordingList,
|
|
recordingSkip, ARRAY_SIZE(recordingSkip), NULL, 0);
|
|
qt_settings_group_add_compact_path(recordingGroup,
|
|
MENU_ENUM_LABEL_RECORDING_OUTPUT_DIRECTORY, true);
|
|
|
|
/* These compact radio controls are retained from the original page. */
|
|
streamingModeLayout->addWidget(
|
|
new UIntRadioButtons(MENU_ENUM_LABEL_STREAMING_MODE));
|
|
streamingModeLayout->addWidget(
|
|
new UIntRadioButtons(MENU_ENUM_LABEL_VIDEO_STREAM_QUALITY));
|
|
streamingGroup->addRow(streamingModeLayout);
|
|
qt_settings_group_add_list(streamingGroup, recordingList, NULL, 0,
|
|
streamingEntries, ARRAY_SIZE(streamingEntries));
|
|
if (recordingList)
|
|
file_list_free(recordingList);
|
|
|
|
leftColumn->addWidget(recordingGroup);
|
|
leftColumn->addWidget(streamingGroup);
|
|
leftColumn->addStretch();
|
|
columnsLayout->addLayout(leftColumn, 1);
|
|
columnsLayout->addStretch(1);
|
|
layout->addLayout(columnsLayout);
|
|
layout->addStretch();
|
|
widget->setLayout(layout);
|
|
return widget;
|
|
}
|
|
|
|
SavingCategory::SavingCategory(QWidget *parent) :
|
|
OptionsCategory(parent)
|
|
{
|
|
setDisplayName(MENU_ENUM_LABEL_VALUE_SAVING_SETTINGS);
|
|
setCategoryIcon("menu_saving");
|
|
}
|
|
|
|
QVector<OptionsPage*> SavingCategory::pages()
|
|
{
|
|
QVector<OptionsPage*> pages;
|
|
|
|
pages << new SavingPage(this);
|
|
|
|
return pages;
|
|
}
|
|
|
|
SavingPage::SavingPage(QObject *parent) :
|
|
OptionsPage(parent)
|
|
{
|
|
}
|
|
|
|
QWidget *SavingPage::widget()
|
|
{
|
|
QWidget *widget = new QWidget;
|
|
QVBoxLayout *layout = new QVBoxLayout;
|
|
QHBoxLayout *columnsLayout = new QHBoxLayout;
|
|
QVBoxLayout *leftColumn = new QVBoxLayout;
|
|
QVBoxLayout *rightColumn = new QVBoxLayout;
|
|
SettingsGroup *savesGroup = new SettingsGroup("Save Files");
|
|
SettingsGroup *saveRamGroup = new SettingsGroup("SaveRAM");
|
|
SettingsGroup *systemFilesDirGroup = new SettingsGroup("System Files");
|
|
SettingsGroup *screenshotsDirGroup = new SettingsGroup("Screenshots");
|
|
SettingsGroup *savestatesGroup = new SettingsGroup("Savestates");
|
|
SettingsGroup *replayGroup = new SettingsGroup("Replays");
|
|
SettingsGroup *runtimeLogGroup = new SettingsGroup("Runtime Log");
|
|
static const enum msg_hash_enums savesEntries[] = {
|
|
MENU_ENUM_LABEL_SORT_SAVEFILES_ENABLE,
|
|
MENU_ENUM_LABEL_SORT_SAVEFILES_BY_CONTENT_ENABLE,
|
|
MENU_ENUM_LABEL_SAVEFILES_IN_CONTENT_DIR_ENABLE,
|
|
MENU_ENUM_LABEL_SAVE_FILE_COMPRESSION,
|
|
MENU_ENUM_LABEL_SAVE_COMPRESSION_CODEC
|
|
};
|
|
static const enum msg_hash_enums saveRamEntries[] = {
|
|
MENU_ENUM_LABEL_BLOCK_SRAM_OVERWRITE,
|
|
MENU_ENUM_LABEL_AUTOSAVE_INTERVAL
|
|
};
|
|
static const enum msg_hash_enums screenshotEntries[] = {
|
|
MENU_ENUM_LABEL_VIDEO_GPU_SCREENSHOT,
|
|
MENU_ENUM_LABEL_SORT_SCREENSHOTS_BY_CONTENT_ENABLE,
|
|
MENU_ENUM_LABEL_SCREENSHOTS_IN_CONTENT_DIR_ENABLE
|
|
};
|
|
static const enum msg_hash_enums savestateEntries[] = {
|
|
MENU_ENUM_LABEL_SORT_SAVESTATES_ENABLE,
|
|
MENU_ENUM_LABEL_SORT_SAVESTATES_BY_CONTENT_ENABLE,
|
|
MENU_ENUM_LABEL_SAVESTATES_IN_CONTENT_DIR_ENABLE,
|
|
MENU_ENUM_LABEL_SAVESTATE_AUTO_SAVE,
|
|
MENU_ENUM_LABEL_SAVESTATE_AUTO_LOAD,
|
|
MENU_ENUM_LABEL_SAVESTATE_THUMBNAIL_ENABLE,
|
|
MENU_ENUM_LABEL_SAVESTATE_FILE_COMPRESSION,
|
|
MENU_ENUM_LABEL_SAVESTATE_AUTOMATIC_INTERVAL,
|
|
MENU_ENUM_LABEL_SAVESTATE_AUTO_INDEX,
|
|
MENU_ENUM_LABEL_SAVESTATE_MAX_KEEP
|
|
};
|
|
static const enum msg_hash_enums replayEntries[] = {
|
|
MENU_ENUM_LABEL_REPLAY_AUTO_INDEX,
|
|
MENU_ENUM_LABEL_REPLAY_MAX_KEEP,
|
|
MENU_ENUM_LABEL_REPLAY_CHECKPOINT_INTERVAL,
|
|
MENU_ENUM_LABEL_REPLAY_CHECKPOINT_DESERIALIZE
|
|
};
|
|
static const enum msg_hash_enums runtimeEntries[] = {
|
|
MENU_ENUM_LABEL_CONTENT_RUNTIME_LOG,
|
|
MENU_ENUM_LABEL_CONTENT_RUNTIME_LOG_AGGREGATE
|
|
};
|
|
|
|
file_list_t *savingList = qt_displaylist_build(
|
|
DISPLAYLIST_SAVING_SETTINGS_LIST);
|
|
|
|
qt_settings_group_add_list(savesGroup,
|
|
savingList, NULL, 0,
|
|
savesEntries, ARRAY_SIZE(savesEntries));
|
|
qt_settings_group_add_list(saveRamGroup,
|
|
savingList, NULL, 0,
|
|
saveRamEntries, ARRAY_SIZE(saveRamEntries));
|
|
systemFilesDirGroup->add(MENU_ENUM_LABEL_SYSTEMFILES_IN_CONTENT_DIR_ENABLE);
|
|
qt_settings_group_add_list(screenshotsDirGroup,
|
|
savingList, NULL, 0,
|
|
screenshotEntries, ARRAY_SIZE(screenshotEntries));
|
|
qt_settings_group_add_list(savestatesGroup,
|
|
savingList, NULL, 0,
|
|
savestateEntries, ARRAY_SIZE(savestateEntries));
|
|
qt_settings_group_add_list(replayGroup,
|
|
savingList, NULL, 0,
|
|
replayEntries, ARRAY_SIZE(replayEntries));
|
|
qt_settings_group_add_list(runtimeLogGroup,
|
|
savingList, NULL, 0,
|
|
runtimeEntries, ARRAY_SIZE(runtimeEntries));
|
|
if (savingList)
|
|
file_list_free(savingList);
|
|
|
|
leftColumn->addWidget(savesGroup);
|
|
leftColumn->addWidget(saveRamGroup);
|
|
leftColumn->addWidget(systemFilesDirGroup);
|
|
leftColumn->addWidget(screenshotsDirGroup);
|
|
leftColumn->addWidget(replayGroup);
|
|
|
|
rightColumn->addWidget(savestatesGroup);
|
|
rightColumn->addWidget(runtimeLogGroup);
|
|
#ifdef HAVE_CLOUDSYNC
|
|
{
|
|
SettingsGroup *cloudSyncGroup = new SettingsGroup(
|
|
msg_hash_to_str(MENU_ENUM_LABEL_VALUE_CLOUD_SYNC_SETTINGS));
|
|
qt_settings_group_add_displaylist(cloudSyncGroup,
|
|
DISPLAYLIST_CLOUD_SYNC_SETTINGS_LIST, NULL, 0, NULL, 0);
|
|
rightColumn->addWidget(cloudSyncGroup);
|
|
}
|
|
#endif
|
|
|
|
leftColumn->addStretch();
|
|
rightColumn->addStretch();
|
|
columnsLayout->addLayout(leftColumn, 1);
|
|
columnsLayout->addLayout(rightColumn, 1);
|
|
layout->addLayout(columnsLayout);
|
|
layout->addStretch();
|
|
widget->setLayout(layout);
|
|
return widget;
|
|
}
|
|
|
|
UserInterfaceCategory::UserInterfaceCategory(QWidget *parent) :
|
|
OptionsCategory(parent)
|
|
{
|
|
setDisplayName(MENU_ENUM_LABEL_VALUE_USER_INTERFACE_SETTINGS);
|
|
setCategoryIcon("menu_ui");
|
|
}
|
|
|
|
UserInterfaceCategory::UserInterfaceCategory(MainWindow *mainwindow, QWidget *parent) :
|
|
OptionsCategory(parent)
|
|
,m_mainwindow(mainwindow)
|
|
{
|
|
setDisplayName(MENU_ENUM_LABEL_VALUE_USER_INTERFACE_SETTINGS);
|
|
setCategoryIcon("menu_ui");
|
|
|
|
m_pages << new UserInterfacePage(this);
|
|
m_pages << new ViewsPage(this);
|
|
m_pages << new AppearancePage(this);
|
|
m_pages << new DesktopMenuPage(m_mainwindow, this);
|
|
}
|
|
|
|
QVector<OptionsPage*> UserInterfaceCategory::pages()
|
|
{
|
|
return m_pages;
|
|
}
|
|
|
|
UserInterfacePage::UserInterfacePage(QObject *parent) :
|
|
OptionsPage(parent)
|
|
{
|
|
}
|
|
|
|
QWidget *UserInterfacePage::widget()
|
|
{
|
|
QWidget *widget = new QWidget;
|
|
QVBoxLayout *layout = new QVBoxLayout;
|
|
QHBoxLayout *columnsLayout = new QHBoxLayout;
|
|
QVBoxLayout *leftColumn = new QVBoxLayout;
|
|
QVBoxLayout *rightColumn = new QVBoxLayout;
|
|
SettingsGroup *menuGroup = new SettingsGroup("Menu");
|
|
SettingsGroup *inputGroup = new SettingsGroup("Input");
|
|
SettingsGroup *miscGroup = new SettingsGroup("Miscellaneous");
|
|
SettingsGroup *behaviorGroup = new SettingsGroup("Behavior");
|
|
SettingsGroup *fileBrowserGroup = new SettingsGroup(
|
|
msg_hash_to_str(MENU_ENUM_LABEL_VALUE_MENU_FILE_BROWSER_SETTINGS));
|
|
SettingsGroup *mediaPlayerGroup = new SettingsGroup(
|
|
msg_hash_to_str(MENU_ENUM_LABEL_VALUE_MEDIA_PLAYER_SETTINGS));
|
|
CheckableSettingsGroup *desktopGroup = new CheckableSettingsGroup(
|
|
MENU_ENUM_LABEL_DESKTOP_MENU_ENABLE);
|
|
static const enum msg_hash_enums uiGeneralEntries[] = {
|
|
MENU_ENUM_LABEL_PAUSE_ON_DISCONNECT,
|
|
MENU_ENUM_LABEL_MENU_SAVESTATE_RESUME,
|
|
MENU_ENUM_LABEL_MENU_INSERT_DISK_RESUME,
|
|
MENU_ENUM_LABEL_QUIT_ON_CLOSE_CONTENT,
|
|
MENU_ENUM_LABEL_MENU_REMEMBER_SELECTION,
|
|
MENU_ENUM_LABEL_MENU_STARTUP_PAGE,
|
|
MENU_ENUM_LABEL_CONFIRM_QUIT,
|
|
MENU_ENUM_LABEL_CONFIRM_CLOSE,
|
|
MENU_ENUM_LABEL_CONFIRM_RESET,
|
|
MENU_ENUM_LABEL_THREAD_PREFER_FAST_CORES,
|
|
MENU_ENUM_LABEL_VIDEO_THREAD_PRIORITY,
|
|
MENU_ENUM_LABEL_MAIN_THREAD_PRIORITY,
|
|
MENU_ENUM_LABEL_MENU_SCREENSAVER_TIMEOUT,
|
|
MENU_ENUM_LABEL_MENU_SCREENSAVER_ANIMATION,
|
|
MENU_ENUM_LABEL_MENU_SCREENSAVER_ANIMATION_SPEED,
|
|
MENU_ENUM_LABEL_APPICON_SETTINGS
|
|
};
|
|
rarch_setting_t *kioskMode = menu_setting_find_enum(
|
|
MENU_ENUM_LABEL_MENU_ENABLE_KIOSK_MODE);
|
|
|
|
menuGroup->add(MENU_ENUM_LABEL_SHOW_ADVANCED_SETTINGS);
|
|
|
|
/* only on XMB and Ozone */
|
|
if (kioskMode)
|
|
{
|
|
CheckableSettingsGroup *kioskGroup = new CheckableSettingsGroup(kioskMode, widget);
|
|
kioskGroup->add(MENU_ENUM_LABEL_MENU_KIOSK_MODE_PASSWORD);
|
|
menuGroup->addRow(kioskGroup);
|
|
}
|
|
|
|
menuGroup->add(MENU_ENUM_LABEL_NAVIGATION_WRAPAROUND);
|
|
menuGroup->add(MENU_ENUM_LABEL_PAUSE_LIBRETRO);
|
|
menuGroup->add(MENU_ENUM_LABEL_THREADED_DATA_RUNLOOP_ENABLE);
|
|
menuGroup->add(MENU_ENUM_LABEL_UI_COMPANION_ENABLE);
|
|
menuGroup->add(MENU_ENUM_LABEL_UI_COMPANION_START_ON_BOOT);
|
|
menuGroup->add(MENU_ENUM_LABEL_UI_MENUBAR_ENABLE);
|
|
menuGroup->add(MENU_ENUM_LABEL_MENU_SCROLL_FAST);
|
|
|
|
inputGroup->add(MENU_ENUM_LABEL_MOUSE_ENABLE);
|
|
inputGroup->add(MENU_ENUM_LABEL_POINTER_ENABLE);
|
|
menuGroup->addRow(inputGroup);
|
|
|
|
miscGroup->add(MENU_ENUM_LABEL_PAUSE_NONACTIVE);
|
|
miscGroup->add(MENU_ENUM_LABEL_VIDEO_DISABLE_COMPOSITION);
|
|
desktopGroup->add(MENU_ENUM_LABEL_UI_COMPANION_TOGGLE);
|
|
|
|
qt_settings_group_add_displaylist(behaviorGroup,
|
|
DISPLAYLIST_USER_INTERFACE_SETTINGS_LIST,
|
|
NULL, 0, uiGeneralEntries, ARRAY_SIZE(uiGeneralEntries));
|
|
qt_settings_group_add_displaylist(fileBrowserGroup,
|
|
DISPLAYLIST_MENU_FILE_BROWSER_SETTINGS_LIST, NULL, 0, NULL, 0);
|
|
qt_settings_group_add_displaylist(mediaPlayerGroup,
|
|
DISPLAYLIST_MEDIA_PLAYER_SETTINGS_LIST, NULL, 0, NULL, 0);
|
|
|
|
leftColumn->addWidget(menuGroup);
|
|
leftColumn->addWidget(behaviorGroup);
|
|
|
|
rightColumn->addWidget(fileBrowserGroup);
|
|
rightColumn->addWidget(mediaPlayerGroup);
|
|
rightColumn->addWidget(miscGroup);
|
|
rightColumn->addWidget(desktopGroup);
|
|
|
|
leftColumn->addStretch();
|
|
rightColumn->addStretch();
|
|
columnsLayout->addLayout(leftColumn, 1);
|
|
columnsLayout->addLayout(rightColumn, 1);
|
|
layout->addLayout(columnsLayout);
|
|
widget->setLayout(layout);
|
|
return widget;
|
|
}
|
|
|
|
ViewsPage::ViewsPage(QObject *parent) :
|
|
OptionsPage(parent)
|
|
{
|
|
setDisplayName(MENU_ENUM_LABEL_VALUE_MENU_VIEWS_SETTINGS);
|
|
}
|
|
|
|
QWidget *ViewsPage::widget()
|
|
{
|
|
unsigned i;
|
|
QWidget * widget = new QWidget();
|
|
QHBoxLayout *mainLayout = new QHBoxLayout;
|
|
FormLayout *leftLayout = new FormLayout;
|
|
QVBoxLayout *rightLayout = new QVBoxLayout;
|
|
SettingsGroup *quickMenu = new SettingsGroup("Quick Menu");
|
|
OptionsPage *quickPage = new SimplePage(
|
|
DISPLAYLIST_QUICK_MENU_VIEWS_SETTINGS_LIST,
|
|
MENU_ENUM_LABEL_VALUE_QUICK_MENU_VIEWS_SETTINGS, this);
|
|
QWidget *quickPageWidget;
|
|
SettingsGroup *mainMenu = new SettingsGroup("Main Menu");
|
|
SettingsGroup *settings = new SettingsGroup("Settings");
|
|
SettingsGroup *tabs = new SettingsGroup("Tabs");
|
|
SettingsGroup *status = new SettingsGroup("Status");
|
|
SettingsGroup *startScreen = new SettingsGroup("StartScreen");
|
|
settings_t *_settings = config_get_ptr();
|
|
unsigned tabs_begin = 0;
|
|
unsigned status_begin = 0;
|
|
file_list_t *list = (file_list_t*)calloc(1, sizeof(*list));
|
|
|
|
{
|
|
rarch_setting_t *kiosk_mode = NULL;
|
|
menu_displaylist_build_list(list, _settings,
|
|
DISPLAYLIST_MENU_VIEWS_SETTINGS_LIST, true);
|
|
kiosk_mode = menu_setting_find_enum(
|
|
MENU_ENUM_LABEL_MENU_ENABLE_KIOSK_MODE);
|
|
|
|
for (i = 0; i < list->size; i++)
|
|
{
|
|
menu_file_list_cbs_t *cbs = (menu_file_list_cbs_t*)
|
|
file_list_get_actiondata_at_offset(list, i);
|
|
|
|
if (cbs->enum_idx == (kiosk_mode
|
|
? MENU_ENUM_LABEL_CONTENT_SHOW_SETTINGS
|
|
: MENU_ENUM_LABEL_CONTENT_SHOW_EXPLORE))
|
|
{
|
|
tabs_begin = i;
|
|
break;
|
|
}
|
|
|
|
mainMenu->add(cbs->enum_idx);
|
|
}
|
|
|
|
for (i = tabs_begin; i < list->size; i++)
|
|
{
|
|
menu_file_list_cbs_t *cbs = (menu_file_list_cbs_t*)
|
|
file_list_get_actiondata_at_offset(list, i);
|
|
|
|
if (cbs->enum_idx == MENU_ENUM_LABEL_TIMEDATE_ENABLE)
|
|
{
|
|
status_begin = i;
|
|
break;
|
|
}
|
|
|
|
tabs->add(cbs->enum_idx);
|
|
}
|
|
|
|
for (i = status_begin; i < list->size; i++)
|
|
{
|
|
menu_file_list_cbs_t *cbs = (menu_file_list_cbs_t*)
|
|
file_list_get_actiondata_at_offset(list, i);
|
|
|
|
if (cbs->enum_idx == MENU_ENUM_LABEL_MENU_SHOW_SUBLABELS)
|
|
break;
|
|
|
|
status->add(cbs->enum_idx);
|
|
}
|
|
|
|
file_list_free(list);
|
|
}
|
|
|
|
{
|
|
unsigned i;
|
|
file_list_t *list = (file_list_t*)calloc(1, sizeof(*list));
|
|
menu_displaylist_build_list(list, _settings,
|
|
DISPLAYLIST_SETTINGS_VIEWS_SETTINGS_LIST, true);
|
|
|
|
for (i = 0; i < list->size; i++)
|
|
{
|
|
menu_file_list_cbs_t *cbs = (menu_file_list_cbs_t*)
|
|
file_list_get_actiondata_at_offset(list, i);
|
|
|
|
settings->add(cbs->enum_idx);
|
|
}
|
|
|
|
file_list_free(list);
|
|
}
|
|
|
|
startScreen->add(MENU_ENUM_LABEL_RGUI_SHOW_START_SCREEN);
|
|
|
|
quickMenu->layout()->setContentsMargins(0, 0, 0, 0);
|
|
quickPageWidget = quickPage->widget();
|
|
quickPageWidget->setObjectName("quickMenuPage");
|
|
quickMenu->addRow(quickPageWidget);
|
|
|
|
leftLayout->addRow(mainMenu);
|
|
leftLayout->addRow(settings);
|
|
leftLayout->addRow(startScreen);
|
|
leftLayout->add(menu_setting_find_enum(MENU_ENUM_LABEL_MENU_SHOW_SUBLABELS));
|
|
|
|
rightLayout->addWidget(tabs);
|
|
rightLayout->addWidget(quickMenu);
|
|
rightLayout->addWidget(status);
|
|
rightLayout->addStretch();
|
|
|
|
mainLayout->addLayout(leftLayout, 1);
|
|
mainLayout->addLayout(rightLayout, 1);
|
|
|
|
widget->setLayout(mainLayout);
|
|
|
|
return widget;
|
|
}
|
|
|
|
AppearancePage::AppearancePage(QObject *parent) :
|
|
OptionsPage(parent)
|
|
{
|
|
setDisplayName(MENU_ENUM_LABEL_VALUE_MENU_SETTINGS);
|
|
}
|
|
|
|
static bool qt_setting_list_contains(enum msg_hash_enums setting,
|
|
const enum msg_hash_enums *entries, size_t count);
|
|
|
|
QWidget *AppearancePage::widget()
|
|
{
|
|
unsigned i;
|
|
QWidget *widget = new QWidget;
|
|
QVBoxLayout *layout = new QVBoxLayout;
|
|
QHBoxLayout *columnsLayout = new QHBoxLayout;
|
|
QVBoxLayout *leftColumn = new QVBoxLayout;
|
|
QVBoxLayout *rightColumn = new QVBoxLayout;
|
|
SettingsGroup *appearanceGroup = new SettingsGroup("Appearance");
|
|
SettingsGroup *tickerGroup = new SettingsGroup("Ticker");
|
|
SettingsGroup *thumbnailGroup = new SettingsGroup("Thumbnails");
|
|
file_list_t *list = (file_list_t*)calloc(1, sizeof(*list));
|
|
settings_t *settings = config_get_ptr();
|
|
static const enum msg_hash_enums tickerEntries[] = {
|
|
MENU_ENUM_LABEL_MENU_TICKER_TYPE,
|
|
MENU_ENUM_LABEL_MENU_TICKER_SPEED,
|
|
MENU_ENUM_LABEL_MENU_TICKER_SMOOTH
|
|
};
|
|
static const enum msg_hash_enums thumbnailEntries[] = {
|
|
MENU_ENUM_LABEL_MATERIALUI_MENU_THUMBNAIL_VIEW_PORTRAIT,
|
|
MENU_ENUM_LABEL_MATERIALUI_MENU_THUMBNAIL_VIEW_LANDSCAPE,
|
|
MENU_ENUM_LABEL_MATERIALUI_DUAL_THUMBNAIL_LIST_VIEW_ENABLE,
|
|
MENU_ENUM_LABEL_MATERIALUI_THUMBNAIL_BACKGROUND_ENABLE,
|
|
MENU_ENUM_LABEL_MENU_RGUI_INLINE_THUMBNAILS,
|
|
MENU_ENUM_LABEL_THUMBNAILS,
|
|
MENU_ENUM_LABEL_LEFT_THUMBNAILS,
|
|
MENU_ENUM_LABEL_ICON_THUMBNAILS,
|
|
MENU_ENUM_LABEL_XMB_VERTICAL_THUMBNAILS,
|
|
MENU_ENUM_LABEL_MENU_XMB_THUMBNAIL_SCALE_FACTOR,
|
|
MENU_ENUM_LABEL_OZONE_THUMBNAIL_SCALE_FACTOR,
|
|
MENU_ENUM_LABEL_MENU_THUMBNAIL_UPSCALE_THRESHOLD,
|
|
MENU_ENUM_LABEL_MENU_RGUI_SWAP_THUMBNAILS,
|
|
MENU_ENUM_LABEL_MENU_RGUI_THUMBNAIL_DOWNSCALER,
|
|
MENU_ENUM_LABEL_MENU_RGUI_THUMBNAIL_DITHER,
|
|
MENU_ENUM_LABEL_MENU_RGUI_THUMBNAIL_DELAY,
|
|
MENU_ENUM_LABEL_MENU_THUMBNAIL_BACKGROUND_ENABLE,
|
|
MENU_ENUM_LABEL_MENU_THUMBNAIL_PREVIEW_AUDIO,
|
|
MENU_ENUM_LABEL_MENU_THUMBNAIL_PREVIEW_THREADS
|
|
};
|
|
|
|
menu_displaylist_build_list(list, settings,
|
|
DISPLAYLIST_MENU_SETTINGS_LIST, true);
|
|
|
|
for (i = 0; i < list->size; i++)
|
|
{
|
|
menu_file_list_cbs_t *cbs = (menu_file_list_cbs_t*)
|
|
file_list_get_actiondata_at_offset(list, i);
|
|
enum msg_hash_enums entry = cbs->enum_idx;
|
|
|
|
if (qt_setting_list_contains(entry, tickerEntries,
|
|
ARRAY_SIZE(tickerEntries)))
|
|
tickerGroup->add(entry);
|
|
else if (qt_setting_list_contains(entry, thumbnailEntries,
|
|
ARRAY_SIZE(thumbnailEntries)))
|
|
thumbnailGroup->add(entry);
|
|
else
|
|
{
|
|
switch (entry)
|
|
{
|
|
case MENU_ENUM_LABEL_MENU_FONT_COLOR_RED:
|
|
appearanceGroup->addUIntColorButton("Menu Font Color: ",
|
|
MENU_ENUM_LABEL_MENU_FONT_COLOR_RED,
|
|
MENU_ENUM_LABEL_MENU_FONT_COLOR_GREEN,
|
|
MENU_ENUM_LABEL_MENU_FONT_COLOR_BLUE);
|
|
break;
|
|
case MENU_ENUM_LABEL_MENU_FONT_COLOR_GREEN:
|
|
case MENU_ENUM_LABEL_MENU_FONT_COLOR_BLUE:
|
|
break;
|
|
default:
|
|
appearanceGroup->add(entry);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
file_list_free(list);
|
|
|
|
leftColumn->addWidget(appearanceGroup);
|
|
leftColumn->addWidget(tickerGroup);
|
|
rightColumn->addWidget(thumbnailGroup);
|
|
leftColumn->addStretch();
|
|
rightColumn->addStretch();
|
|
columnsLayout->addLayout(leftColumn, 1);
|
|
columnsLayout->addLayout(rightColumn, 1);
|
|
layout->addLayout(columnsLayout);
|
|
widget->setLayout(layout);
|
|
return widget;
|
|
}
|
|
|
|
DesktopMenuPage::DesktopMenuPage(MainWindow *mainwindow, QObject *parent) :
|
|
OptionsPage(parent)
|
|
,m_widget(new ViewOptionsWidget(mainwindow))
|
|
{
|
|
setDisplayName("Desktop Menu");
|
|
}
|
|
|
|
void DesktopMenuPage::apply()
|
|
{
|
|
m_widget->saveViewOptions();
|
|
}
|
|
|
|
void DesktopMenuPage::load()
|
|
{
|
|
m_widget->loadViewOptions();
|
|
}
|
|
|
|
QWidget *DesktopMenuPage::widget()
|
|
{
|
|
QWidget *page = new QWidget;
|
|
QGridLayout *layout = new QGridLayout;
|
|
/* m_widget in the top-left cell; the stretch factors keep it at half
|
|
* width and top-aligned, without nested column layouts. */
|
|
layout->addWidget(m_widget, 0, 0);
|
|
layout->setColumnStretch(0, 1);
|
|
layout->setColumnStretch(1, 1);
|
|
layout->setRowStretch(1, 1);
|
|
page->setLayout(layout);
|
|
return page;
|
|
}
|
|
|
|
UserCategory::UserCategory(QWidget *parent) :
|
|
OptionsCategory(parent)
|
|
{
|
|
setDisplayName(MENU_ENUM_LABEL_VALUE_USER_SETTINGS);
|
|
setCategoryIcon("menu_user");
|
|
}
|
|
|
|
QVector<OptionsPage*> UserCategory::pages()
|
|
{
|
|
QVector<OptionsPage*> pages;
|
|
|
|
pages << new UserPage(this);
|
|
|
|
return pages;
|
|
}
|
|
|
|
UserPage::UserPage(QObject *parent) :
|
|
OptionsPage(parent)
|
|
{
|
|
}
|
|
|
|
QWidget *UserPage::widget()
|
|
{
|
|
QWidget *widget = new QWidget;
|
|
FormLayout *layout = new FormLayout;
|
|
|
|
layout->add(menu_setting_find_enum(MENU_ENUM_LABEL_NETPLAY_NICKNAME));
|
|
layout->add(menu_setting_find_enum(MENU_ENUM_LABEL_USER_LANGUAGE));
|
|
layout->add(menu_setting_find_enum(MENU_ENUM_LABEL_KEYCHAIN_PASSPHRASE));
|
|
{
|
|
SettingsGroup *privacyGroup = new SettingsGroup(
|
|
msg_hash_to_str(MENU_ENUM_LABEL_VALUE_PRIVACY_SETTINGS));
|
|
qt_settings_group_add_displaylist(privacyGroup,
|
|
DISPLAYLIST_PRIVACY_SETTINGS_LIST, NULL, 0, NULL, 0);
|
|
layout->addRow(privacyGroup);
|
|
}
|
|
{
|
|
SettingsGroup *accountsGroup = new SettingsGroup(
|
|
msg_hash_to_str(MENU_ENUM_LABEL_VALUE_ACCOUNTS_LIST));
|
|
AccountsPage *accountsPage = new AccountsPage(this);
|
|
accountsGroup->addRow(accountsPage->widget());
|
|
layout->addRow(accountsGroup);
|
|
}
|
|
|
|
widget->setLayout(layout);
|
|
|
|
return widget;
|
|
}
|
|
|
|
AccountsPage::AccountsPage(QObject *parent) :
|
|
OptionsPage(parent)
|
|
{
|
|
setDisplayName(MENU_ENUM_LABEL_VALUE_ACCOUNTS_LIST);
|
|
}
|
|
|
|
QWidget *AccountsPage::widget()
|
|
{
|
|
QWidget *widget = new QWidget;
|
|
QVBoxLayout *layout = new QVBoxLayout;
|
|
SettingsGroup *youtubeGroup = new SettingsGroup(msg_hash_to_str(MENU_ENUM_LABEL_VALUE_ACCOUNTS_YOUTUBE));
|
|
SettingsGroup *twitchGroup = new SettingsGroup(msg_hash_to_str(MENU_ENUM_LABEL_VALUE_ACCOUNTS_TWITCH));
|
|
SettingsGroup *facebookGroup = new SettingsGroup(msg_hash_to_str(MENU_ENUM_LABEL_VALUE_ACCOUNTS_FACEBOOK));
|
|
SettingsGroup *kickGroup = new SettingsGroup(msg_hash_to_str(MENU_ENUM_LABEL_VALUE_ACCOUNTS_KICK));
|
|
#ifdef HAVE_CHEEVOS
|
|
SettingsGroup *cheevosGroup = new SettingsGroup(msg_hash_to_str(MENU_ENUM_LABEL_VALUE_ACCOUNTS_RETRO_ACHIEVEMENTS));
|
|
|
|
cheevosGroup->add(MENU_ENUM_LABEL_CHEEVOS_USERNAME);
|
|
cheevosGroup->add(MENU_ENUM_LABEL_CHEEVOS_PASSWORD);
|
|
|
|
layout->addWidget(cheevosGroup);
|
|
#endif
|
|
|
|
youtubeGroup->add(MENU_ENUM_LABEL_YOUTUBE_STREAM_KEY);
|
|
|
|
layout->addWidget(youtubeGroup);
|
|
|
|
twitchGroup->add(MENU_ENUM_LABEL_TWITCH_STREAM_KEY);
|
|
|
|
layout->addWidget(twitchGroup);
|
|
|
|
facebookGroup->add(MENU_ENUM_LABEL_FACEBOOK_STREAM_KEY);
|
|
|
|
layout->addWidget(facebookGroup);
|
|
|
|
kickGroup->add(MENU_ENUM_LABEL_KICK_STREAM_KEY);
|
|
|
|
layout->addWidget(kickGroup);
|
|
|
|
layout->addStretch();
|
|
|
|
widget->setAttribute(Qt::WA_TranslucentBackground);
|
|
widget->setAutoFillBackground(false);
|
|
widget->setLayout(layout);
|
|
|
|
return widget;
|
|
}
|
|
|
|
/* Populate a Qt SettingsGroup from an existing RetroArch menu display list.
|
|
* This keeps the menu's conditional/platform-specific settings as the source
|
|
* of truth while allowing the desktop UI to arrange them into groups. */
|
|
static bool qt_setting_list_contains(enum msg_hash_enums setting,
|
|
const enum msg_hash_enums *entries, size_t count)
|
|
{
|
|
size_t i;
|
|
|
|
for (i = 0; i < count; i++)
|
|
if (entries[i] == setting)
|
|
return true;
|
|
|
|
return false;
|
|
}
|
|
|
|
/* Build a menu display list once; a page that splits one list into
|
|
* several groups walks the same build for each group instead of
|
|
* rebuilding (and re-copying every label of) the whole list per group. */
|
|
static file_list_t *qt_displaylist_build(
|
|
enum menu_displaylist_ctl_state state)
|
|
{
|
|
file_list_t *list = (file_list_t*)calloc(1, sizeof(*list));
|
|
if (list)
|
|
menu_displaylist_build_list(list, config_get_ptr(), state, true);
|
|
return list;
|
|
}
|
|
|
|
static bool qt_list_has_entry(const file_list_t *list,
|
|
enum msg_hash_enums entry)
|
|
{
|
|
size_t i;
|
|
|
|
if (!list)
|
|
return false;
|
|
|
|
for (i = 0; i < list->size; i++)
|
|
{
|
|
const menu_file_list_cbs_t *cbs = (const menu_file_list_cbs_t*)
|
|
list->list[i].actiondata;
|
|
if (cbs && cbs->enum_idx == entry)
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
static void qt_settings_group_add_list(SettingsGroup *group,
|
|
const file_list_t *list,
|
|
const enum msg_hash_enums *skip_entries, size_t skip_count,
|
|
const enum msg_hash_enums *only_entries, size_t only_count)
|
|
{
|
|
size_t i;
|
|
|
|
if (!list)
|
|
return;
|
|
|
|
for (i = 0; i < list->size; i++)
|
|
{
|
|
rarch_setting_t *setting;
|
|
const menu_file_list_cbs_t *cbs = (const menu_file_list_cbs_t*)
|
|
list->list[i].actiondata;
|
|
|
|
if (!cbs)
|
|
continue;
|
|
|
|
if (only_count && !qt_setting_list_contains(cbs->enum_idx,
|
|
only_entries, only_count))
|
|
continue;
|
|
|
|
if (qt_setting_list_contains(cbs->enum_idx,
|
|
skip_entries, skip_count))
|
|
continue;
|
|
|
|
if ((setting = menu_setting_find_enum(cbs->enum_idx)))
|
|
group->add(setting);
|
|
}
|
|
}
|
|
|
|
static void qt_settings_group_add_displaylist(SettingsGroup *group,
|
|
enum menu_displaylist_ctl_state state,
|
|
const enum msg_hash_enums *skip_entries, size_t skip_count,
|
|
const enum msg_hash_enums *only_entries, size_t only_count)
|
|
{
|
|
file_list_t *list = qt_displaylist_build(state);
|
|
|
|
if (!list)
|
|
return;
|
|
|
|
qt_settings_group_add_list(group, list,
|
|
skip_entries, skip_count, only_entries, only_count);
|
|
file_list_free(list);
|
|
}
|
|
|
|
VideoCategory::VideoCategory(QWidget *parent) :
|
|
OptionsCategory(parent)
|
|
{
|
|
setDisplayName(MENU_ENUM_LABEL_VALUE_VIDEO_SETTINGS);
|
|
setCategoryIcon("menu_video");
|
|
}
|
|
|
|
QVector<OptionsPage*> VideoCategory::pages()
|
|
{
|
|
QVector<OptionsPage*> pages;
|
|
|
|
pages << new VideoPage(this);
|
|
|
|
return pages;
|
|
}
|
|
|
|
VideoPage::VideoPage(QObject *parent) :
|
|
OptionsPage(parent)
|
|
,m_resolutionCombo(new QComboBox())
|
|
,m_crtSuperResolutionCombo(NULL)
|
|
{
|
|
}
|
|
|
|
QWidget *VideoPage::widget()
|
|
{
|
|
QWidget *widget = new QWidget;
|
|
QVBoxLayout *layout = new QVBoxLayout;
|
|
QHBoxLayout *columnsLayout = new QHBoxLayout;
|
|
QVBoxLayout *leftColumn = new QVBoxLayout;
|
|
QVBoxLayout *rightColumn = new QVBoxLayout;
|
|
|
|
SettingsGroup *outputGroup = new SettingsGroup("Output");
|
|
SettingsGroup *aspectGroup = new SettingsGroup("Scaling");
|
|
SettingsGroup *fullscreenGroup = new SettingsGroup("Fullscreen Mode");
|
|
SettingsGroup *windowedGroup = new SettingsGroup("Windowed Mode");
|
|
SettingsGroup *syncGroup = new SettingsGroup("Synchronization");
|
|
SettingsGroup *miscGroup = new SettingsGroup("Miscellaneous");
|
|
SettingsGroup *stereo3dGroup = new SettingsGroup("Stereo 3D and Screens");
|
|
CheckableSettingsGroup *vSyncGroup =
|
|
new CheckableSettingsGroup(MENU_ENUM_LABEL_VIDEO_VSYNC);
|
|
#if defined(_WIN32) && !defined(_XBOX) && !defined(__WINRT__)
|
|
CheckableSettingsGroup *windowCustomSizeGroup =
|
|
new CheckableSettingsGroup(MENU_ENUM_LABEL_VIDEO_WINDOW_SAVE_POSITION);
|
|
#else
|
|
CheckableSettingsGroup *windowCustomSizeGroup =
|
|
new CheckableSettingsGroup(MENU_ENUM_LABEL_VIDEO_WINDOW_CUSTOM_SIZE_ENABLE);
|
|
#endif
|
|
QHBoxLayout *fullscreenSizeLayout = new QHBoxLayout;
|
|
FormLayout *leftFullscreenSizeForm = new FormLayout;
|
|
FormLayout *rightFullscreenSizeForm = new FormLayout;
|
|
QHBoxLayout *windowedSizeLayout = new QHBoxLayout;
|
|
FormLayout *leftWindowedSizeForm = new FormLayout;
|
|
FormLayout *rightWindowedSizeForm = new FormLayout;
|
|
QHBoxLayout *windowedCustomSizeLayout = new QHBoxLayout;
|
|
FormLayout *leftWindowedCustomSizeForm = new FormLayout;
|
|
FormLayout *rightWindowedCustomSizeForm = new FormLayout;
|
|
unsigned i, size = 0;
|
|
bool hasCrtSwitchres;
|
|
/* One build of the top-level video list serves the CRT probe and the
|
|
* Miscellaneous / Video Filter split (it was built three times). */
|
|
file_list_t *videoList = qt_displaylist_build(
|
|
DISPLAYLIST_VIDEO_SETTINGS_LIST);
|
|
struct video_display_config *resolutionList =
|
|
(struct video_display_config*)video_display_server_get_resolution_list(&size);
|
|
|
|
static const enum msg_hash_enums outputSkip[] = {
|
|
MENU_ENUM_LABEL_SCREEN_RESOLUTION,
|
|
MENU_ENUM_LABEL_VIDEO_REFRESH_RATE_AUTO,
|
|
MENU_ENUM_LABEL_VIDEO_REFRESH_RATE_POLLED
|
|
};
|
|
static const enum msg_hash_enums scalingSkip[] = {
|
|
MENU_ENUM_LABEL_VIDEO_ASPECT_RATIO_INDEX,
|
|
MENU_ENUM_LABEL_VIDEO_ASPECT_RATIO,
|
|
MENU_ENUM_LABEL_VIDEO_VIEWPORT_CUSTOM_X,
|
|
MENU_ENUM_LABEL_VIDEO_VIEWPORT_CUSTOM_Y,
|
|
MENU_ENUM_LABEL_VIDEO_VIEWPORT_CUSTOM_WIDTH,
|
|
MENU_ENUM_LABEL_VIDEO_VIEWPORT_CUSTOM_HEIGHT
|
|
};
|
|
static const enum msg_hash_enums fullscreenSkip[] = {
|
|
MENU_ENUM_LABEL_VIDEO_FULLSCREEN_X,
|
|
MENU_ENUM_LABEL_VIDEO_FULLSCREEN_Y
|
|
};
|
|
static const enum msg_hash_enums windowedSkip[] = {
|
|
#if defined(_WIN32) && !defined(_XBOX) && !defined(__WINRT__)
|
|
MENU_ENUM_LABEL_VIDEO_WINDOW_SAVE_POSITION,
|
|
#else
|
|
MENU_ENUM_LABEL_VIDEO_WINDOW_CUSTOM_SIZE_ENABLE,
|
|
#endif
|
|
MENU_ENUM_LABEL_VIDEO_SCALE,
|
|
MENU_ENUM_LABEL_VIDEO_WINDOW_WIDTH,
|
|
MENU_ENUM_LABEL_VIDEO_WINDOW_HEIGHT,
|
|
MENU_ENUM_LABEL_VIDEO_WINDOW_AUTO_WIDTH_MAX,
|
|
MENU_ENUM_LABEL_VIDEO_WINDOW_AUTO_HEIGHT_MAX,
|
|
MENU_ENUM_LABEL_VIDEO_WINDOW_OPACITY
|
|
};
|
|
static const enum msg_hash_enums syncSkip[] = {
|
|
MENU_ENUM_LABEL_VIDEO_VSYNC,
|
|
MENU_ENUM_LABEL_VIDEO_SWAP_INTERVAL,
|
|
MENU_ENUM_LABEL_VIDEO_SHADER_SUBFRAMES,
|
|
MENU_ENUM_LABEL_VIDEO_SCAN_SUBFRAMES,
|
|
MENU_ENUM_LABEL_VIDEO_BLACK_FRAME_INSERTION,
|
|
MENU_ENUM_LABEL_VIDEO_BFI_DARK_FRAMES,
|
|
MENU_ENUM_LABEL_VIDEO_ADAPTIVE_VSYNC,
|
|
MENU_ENUM_LABEL_VIDEO_HARD_SYNC,
|
|
MENU_ENUM_LABEL_VIDEO_HARD_SYNC_FRAMES,
|
|
MENU_ENUM_LABEL_VIDEO_FRAME_DELAY_AUTO,
|
|
MENU_ENUM_LABEL_VIDEO_FRAME_DELAY
|
|
};
|
|
static const enum msg_hash_enums crtSwitchresSkip[] = {
|
|
MENU_ENUM_LABEL_CRT_SWITCH_RESOLUTION_SUPER
|
|
};
|
|
static const enum msg_hash_enums filterEntries[] = {
|
|
MENU_ENUM_LABEL_VIDEO_FILTER_ENABLE,
|
|
MENU_ENUM_LABEL_VIDEO_FILTER_THREADS,
|
|
MENU_ENUM_LABEL_VIDEO_FILTER,
|
|
#if defined(DINGUX)
|
|
MENU_ENUM_LABEL_VIDEO_DINGUX_IPU_FILTER_TYPE,
|
|
#if defined(RS90) || defined(MIYOO)
|
|
MENU_ENUM_LABEL_VIDEO_DINGUX_RS90_SOFTFILTER_TYPE,
|
|
#endif
|
|
#endif
|
|
};
|
|
|
|
hasCrtSwitchres = qt_list_has_entry(videoList,
|
|
MENU_ENUM_LABEL_CRT_SWITCHRES_SETTINGS);
|
|
#ifdef HAVE_TEMPORAL_UPSCALER
|
|
/* Only built where it can be shown: an unshown, unparented group
|
|
* would leak. */
|
|
SettingsGroup *dlssNrGroup = new SettingsGroup("DLSS Noise Reduction");
|
|
/* Do not gate this group on the runtime-dependent display list. The
|
|
* menu list is rebuilt only after a full restart when the DLSS runtime
|
|
* becomes available, while Qt can expose the settings immediately. */
|
|
dlssNrGroup->add(MENU_ENUM_LABEL_VIDEO_DLSS_NR_ENABLE);
|
|
dlssNrGroup->add(MENU_ENUM_LABEL_VIDEO_DLSS_NR_PRESET);
|
|
dlssNrGroup->add(MENU_ENUM_LABEL_VIDEO_DLSS_NR_STYLE);
|
|
dlssNrGroup->add(MENU_ENUM_LABEL_VIDEO_DLSS_NR_INTENSITY);
|
|
dlssNrGroup->add(MENU_ENUM_LABEL_VIDEO_DLSS_NR_LOCAL_STRUCTURE);
|
|
dlssNrGroup->add(MENU_ENUM_LABEL_VIDEO_DLSS_NR_LOCAL_TONE);
|
|
{
|
|
rarch_setting_t *skinStructure = menu_setting_find_enum(
|
|
MENU_ENUM_LABEL_VIDEO_DLSS_NR_SKIN_STRUCTURE);
|
|
if (skinStructure)
|
|
dlssNrGroup->addRow(form_label(skinStructure),
|
|
new IntSpinBox(skinStructure));
|
|
}
|
|
dlssNrGroup->add(MENU_ENUM_LABEL_VIDEO_DLSS_NR_AUTO_MASK);
|
|
#endif
|
|
|
|
qt_settings_group_add_displaylist(outputGroup,
|
|
DISPLAYLIST_VIDEO_OUTPUT_SETTINGS_LIST,
|
|
outputSkip, ARRAY_SIZE(outputSkip), NULL, 0);
|
|
|
|
if (resolutionList)
|
|
{
|
|
for (i = 0; i < size; i++)
|
|
{
|
|
/* Format straight into the QString the combo keeps, instead of
|
|
* a stack buffer that addItem() then copies and converts. */
|
|
m_resolutionCombo->addItem(QString::asprintf("%dx%d (%d Hz)",
|
|
VIDEO_SCALE_W(resolutionList[i].dims),
|
|
VIDEO_SCALE_H(resolutionList[i].dims),
|
|
resolutionList[i].refreshrate));
|
|
if (resolutionList[i].current)
|
|
m_resolutionCombo->setCurrentIndex((int)i);
|
|
}
|
|
free(resolutionList);
|
|
}
|
|
|
|
if (m_resolutionCombo->count() > 0)
|
|
outputGroup->addRow(msg_hash_to_str(MENU_ENUM_LABEL_VALUE_SCREEN_RESOLUTION),
|
|
m_resolutionCombo);
|
|
{
|
|
rarch_setting_t *refreshAction = menu_setting_find_enum(
|
|
MENU_ENUM_LABEL_VIDEO_REFRESH_RATE_POLLED);
|
|
if (refreshAction)
|
|
{
|
|
char refreshText[64] = {0};
|
|
QPushButton *refreshButton = new QPushButton;
|
|
if (refreshAction->actions && refreshAction->actions->repr)
|
|
refreshAction->actions->repr(refreshAction, refreshText,
|
|
sizeof(refreshText));
|
|
refreshButton->setText(QString::fromUtf8(refreshText));
|
|
QObject::connect(refreshButton, &QPushButton::clicked,
|
|
[refreshAction, refreshButton]()
|
|
{
|
|
if (refreshAction->actions && refreshAction->actions->ok)
|
|
refreshAction->actions->ok(refreshAction, 0, false);
|
|
char value[64] = {0};
|
|
if (refreshAction->actions && refreshAction->actions->repr)
|
|
refreshAction->actions->repr(refreshAction, value,
|
|
sizeof(value));
|
|
refreshButton->setText(QString::fromUtf8(value));
|
|
});
|
|
outputGroup->addRow(msg_hash_to_str(
|
|
MENU_ENUM_LABEL_VALUE_VIDEO_REFRESH_RATE_POLLED),
|
|
refreshButton);
|
|
}
|
|
}
|
|
|
|
qt_settings_group_add_displaylist(aspectGroup,
|
|
DISPLAYLIST_VIDEO_SCALING_SETTINGS_LIST,
|
|
scalingSkip, ARRAY_SIZE(scalingSkip), NULL, 0);
|
|
aspectGroup->addRow(new AspectRatioGroup("Aspect Ratio"));
|
|
|
|
qt_settings_group_add_displaylist(fullscreenGroup,
|
|
DISPLAYLIST_VIDEO_FULLSCREEN_MODE_SETTINGS_LIST,
|
|
fullscreenSkip, ARRAY_SIZE(fullscreenSkip), NULL, 0);
|
|
leftFullscreenSizeForm->addRow("Width:",
|
|
new UIntSpinBox(MENU_ENUM_LABEL_VIDEO_FULLSCREEN_X));
|
|
rightFullscreenSizeForm->addRow("Height:",
|
|
new UIntSpinBox(MENU_ENUM_LABEL_VIDEO_FULLSCREEN_Y));
|
|
fullscreenSizeLayout->addLayout(leftFullscreenSizeForm);
|
|
fullscreenSizeLayout->addLayout(rightFullscreenSizeForm);
|
|
fullscreenGroup->addRow(fullscreenSizeLayout);
|
|
|
|
qt_settings_group_add_displaylist(windowedGroup,
|
|
DISPLAYLIST_VIDEO_WINDOWED_MODE_SETTINGS_LIST,
|
|
windowedSkip, ARRAY_SIZE(windowedSkip), NULL, 0);
|
|
leftWindowedSizeForm->addRow("Scale:",
|
|
new UIntSpinBox(MENU_ENUM_LABEL_VIDEO_SCALE));
|
|
leftWindowedSizeForm->addRow("Max Width:",
|
|
new UIntSpinBox(MENU_ENUM_LABEL_VIDEO_WINDOW_AUTO_WIDTH_MAX));
|
|
rightWindowedSizeForm->addRow("Opacity:",
|
|
new UIntSpinBox(MENU_ENUM_LABEL_VIDEO_WINDOW_OPACITY));
|
|
rightWindowedSizeForm->addRow("Max Height:",
|
|
new UIntSpinBox(MENU_ENUM_LABEL_VIDEO_WINDOW_AUTO_HEIGHT_MAX));
|
|
windowedSizeLayout->addLayout(leftWindowedSizeForm);
|
|
windowedSizeLayout->addLayout(rightWindowedSizeForm);
|
|
windowedGroup->addRow(windowedSizeLayout);
|
|
leftWindowedCustomSizeForm->addRow("Width:",
|
|
new UIntSpinBox(MENU_ENUM_LABEL_VIDEO_WINDOW_WIDTH));
|
|
rightWindowedCustomSizeForm->addRow("Height:",
|
|
new UIntSpinBox(MENU_ENUM_LABEL_VIDEO_WINDOW_HEIGHT));
|
|
windowedCustomSizeLayout->addLayout(leftWindowedCustomSizeForm);
|
|
windowedCustomSizeLayout->addLayout(rightWindowedCustomSizeForm);
|
|
windowCustomSizeGroup->addRow(windowedCustomSizeLayout);
|
|
windowedGroup->addRow(windowCustomSizeGroup);
|
|
|
|
/* Keep the dependent VSync and hard-sync controls grouped with their
|
|
* master switches. The remaining synchronization settings come from the
|
|
* live menu display list. */
|
|
vSyncGroup->add(MENU_ENUM_LABEL_VIDEO_SWAP_INTERVAL);
|
|
vSyncGroup->add(MENU_ENUM_LABEL_VIDEO_SHADER_SUBFRAMES);
|
|
vSyncGroup->add(MENU_ENUM_LABEL_VIDEO_SCAN_SUBFRAMES);
|
|
vSyncGroup->add(MENU_ENUM_LABEL_VIDEO_BLACK_FRAME_INSERTION);
|
|
vSyncGroup->add(MENU_ENUM_LABEL_VIDEO_BFI_DARK_FRAMES);
|
|
vSyncGroup->add(MENU_ENUM_LABEL_VIDEO_ADAPTIVE_VSYNC);
|
|
vSyncGroup->add(MENU_ENUM_LABEL_VIDEO_FRAME_DELAY);
|
|
vSyncGroup->add(MENU_ENUM_LABEL_VIDEO_FRAME_DELAY_AUTO);
|
|
syncGroup->addRow(vSyncGroup);
|
|
{
|
|
rarch_setting_t *hardSyncSetting =
|
|
menu_setting_find_enum(MENU_ENUM_LABEL_VIDEO_HARD_SYNC);
|
|
if (hardSyncSetting)
|
|
{
|
|
CheckableSettingsGroup *hardSyncGroup =
|
|
new CheckableSettingsGroup(hardSyncSetting);
|
|
hardSyncGroup->add(MENU_ENUM_LABEL_VIDEO_HARD_SYNC_FRAMES);
|
|
syncGroup->addRow(hardSyncGroup);
|
|
}
|
|
}
|
|
qt_settings_group_add_displaylist(syncGroup,
|
|
DISPLAYLIST_VIDEO_SYNCHRONIZATION_SETTINGS_LIST,
|
|
syncSkip, ARRAY_SIZE(syncSkip), NULL, 0);
|
|
|
|
qt_settings_group_add_displaylist(stereo3dGroup,
|
|
DISPLAYLIST_VIDEO_STEREO_SETTINGS_LIST, NULL, 0, NULL, 0);
|
|
qt_settings_group_add_list(miscGroup, videoList,
|
|
filterEntries, ARRAY_SIZE(filterEntries), NULL, 0);
|
|
|
|
leftColumn->addWidget(outputGroup);
|
|
leftColumn->addWidget(windowedGroup);
|
|
leftColumn->addWidget(fullscreenGroup);
|
|
leftColumn->addWidget(syncGroup);
|
|
|
|
rightColumn->addWidget(aspectGroup);
|
|
#ifdef HAVE_TEMPORAL_UPSCALER
|
|
if (dlssNrGroup->layout()->count() > 0)
|
|
rightColumn->addWidget(dlssNrGroup);
|
|
else
|
|
delete dlssNrGroup;
|
|
#endif
|
|
if (video_driver_get_disp_flags() & VIDEO_FLAG_HDR_SUPPORT)
|
|
{
|
|
SettingsGroup *hdrGroup = new SettingsGroup("HDR");
|
|
qt_settings_group_add_displaylist(hdrGroup,
|
|
DISPLAYLIST_VIDEO_HDR_SETTINGS_LIST, NULL, 0, NULL, 0);
|
|
rightColumn->addWidget(hdrGroup);
|
|
}
|
|
if (hasCrtSwitchres)
|
|
{
|
|
SettingsGroup *crtSwitchresGroup = new SettingsGroup(
|
|
msg_hash_to_str(MENU_ENUM_LABEL_VALUE_CRT_SWITCHRES_SETTINGS));
|
|
m_crtSuperResolutionCombo = new QComboBox;
|
|
qt_settings_group_add_displaylist(crtSwitchresGroup,
|
|
DISPLAYLIST_CRT_SWITCHRES_SETTINGS_LIST,
|
|
crtSwitchresSkip, ARRAY_SIZE(crtSwitchresSkip), NULL, 0);
|
|
m_crtSuperResolutionCombo->addItem(msg_hash_to_str(MSG_NATIVE), 0);
|
|
m_crtSuperResolutionCombo->addItem("1920", 1920);
|
|
m_crtSuperResolutionCombo->addItem("2560", 2560);
|
|
m_crtSuperResolutionCombo->addItem("3840", 3840);
|
|
crtSwitchresGroup->addRow(
|
|
msg_hash_to_str(MENU_ENUM_LABEL_VALUE_CRT_SWITCH_RESOLUTION_SUPER),
|
|
m_crtSuperResolutionCombo);
|
|
#if (QT_VERSION > QT_VERSION_CHECK(6, 0, 0))
|
|
connect(m_crtSuperResolutionCombo, &QComboBox::currentIndexChanged,
|
|
this, &VideoPage::onCrtSuperResolutionComboIndexChanged);
|
|
#else
|
|
connect(m_crtSuperResolutionCombo, SIGNAL(currentIndexChanged(int)),
|
|
this, SLOT(onCrtSuperResolutionComboIndexChanged(int)));
|
|
#endif
|
|
rightColumn->addWidget(crtSwitchresGroup);
|
|
}
|
|
rightColumn->addWidget(miscGroup);
|
|
#if defined(HAVE_VIDEO_FILTER) || defined(DINGUX)
|
|
{
|
|
SettingsGroup *filterGroup = new SettingsGroup("Video Filter");
|
|
qt_settings_group_add_list(filterGroup, videoList, NULL, 0,
|
|
filterEntries, ARRAY_SIZE(filterEntries));
|
|
rightColumn->addWidget(filterGroup);
|
|
}
|
|
#endif
|
|
rightColumn->addWidget(stereo3dGroup);
|
|
if (videoList)
|
|
file_list_free(videoList);
|
|
|
|
leftColumn->addStretch();
|
|
rightColumn->addStretch();
|
|
columnsLayout->addLayout(leftColumn, 1);
|
|
columnsLayout->addLayout(rightColumn, 1);
|
|
layout->addLayout(columnsLayout);
|
|
layout->addStretch();
|
|
|
|
#if (QT_VERSION > QT_VERSION_CHECK(6, 0, 0))
|
|
void (VideoPage::*cb)(int) = &VideoPage::onResolutionComboIndexChanged;
|
|
connect(m_resolutionCombo, &QComboBox::currentIndexChanged, this, cb);
|
|
#else
|
|
connect(m_resolutionCombo, SIGNAL(currentIndexChanged(const QString&)), this,
|
|
SLOT(onResolutionComboIndexChanged(const QString&)));
|
|
#endif
|
|
|
|
widget->setLayout(layout);
|
|
return widget;
|
|
}
|
|
|
|
AspectRatioGroup::AspectRatioGroup(const QString &title, QWidget *parent) :
|
|
SettingsGroup(title, parent)
|
|
,m_radioButton(new AspectRatioRadioButton(ASPECT_RATIO_4_3, ASPECT_RATIO_32_9))
|
|
,m_comboBox(new UIntComboBox(MENU_ENUM_LABEL_VIDEO_ASPECT_RATIO_INDEX, ASPECT_RATIO_4_3, ASPECT_RATIO_32_9))
|
|
{
|
|
QHBoxLayout *aspectLayout = new QHBoxLayout;
|
|
QHBoxLayout *preset = new QHBoxLayout;
|
|
QHBoxLayout *custom = new QHBoxLayout;
|
|
QVBoxLayout *customRadio = new QVBoxLayout;
|
|
QHBoxLayout *config = new QHBoxLayout;
|
|
QHBoxLayout *full = new QHBoxLayout;
|
|
QHBoxLayout *aspectL = new QHBoxLayout;
|
|
FormLayout *leftAspectForm = new FormLayout;
|
|
FormLayout *rightAspectForm = new FormLayout;
|
|
FormLayout *leftAspect = new FormLayout;
|
|
FormLayout *rightAspect = new FormLayout;
|
|
|
|
leftAspectForm->addRow("X Pos.:", new UIntSpinBox(MENU_ENUM_LABEL_VIDEO_VIEWPORT_CUSTOM_X));
|
|
leftAspectForm->addRow("Width:", new UIntSpinBox(MENU_ENUM_LABEL_VIDEO_VIEWPORT_CUSTOM_WIDTH));
|
|
rightAspectForm->addRow("Y Pos.:", new UIntSpinBox(MENU_ENUM_LABEL_VIDEO_VIEWPORT_CUSTOM_Y));
|
|
rightAspectForm->addRow("Height:", new UIntSpinBox(MENU_ENUM_LABEL_VIDEO_VIEWPORT_CUSTOM_HEIGHT));
|
|
|
|
aspectLayout->addLayout(leftAspectForm);
|
|
aspectLayout->addLayout(rightAspectForm);
|
|
|
|
preset->addWidget(m_radioButton);
|
|
preset->addWidget(m_comboBox);
|
|
preset->setStretch(1, 1);
|
|
|
|
customRadio->addWidget(new UIntRadioButton(MENU_ENUM_LABEL_VIDEO_ASPECT_RATIO_INDEX, ASPECT_RATIO_CUSTOM), Qt::AlignTop);
|
|
customRadio->addStretch();
|
|
|
|
custom->addLayout(customRadio);
|
|
custom->addLayout(aspectLayout);
|
|
custom->addStretch();
|
|
|
|
config->addWidget(new UIntRadioButton(MENU_ENUM_LABEL_VIDEO_ASPECT_RATIO_INDEX, ASPECT_RATIO_CONFIG));
|
|
config->addWidget(new FloatSpinBox(MENU_ENUM_LABEL_VIDEO_ASPECT_RATIO));
|
|
config->setStretch(1, 1);
|
|
config->setSizeConstraint(QLayout::SetMinimumSize);
|
|
|
|
full->addWidget(new UIntRadioButton(MENU_ENUM_LABEL_VIDEO_ASPECT_RATIO_INDEX, ASPECT_RATIO_FULL));
|
|
|
|
leftAspect->addRow(new UIntRadioButton(MENU_ENUM_LABEL_VIDEO_ASPECT_RATIO_INDEX, ASPECT_RATIO_CORE));
|
|
leftAspect->addRow(preset);
|
|
|
|
rightAspect->addRow(config);
|
|
rightAspect->addRow(new UIntRadioButton(MENU_ENUM_LABEL_VIDEO_ASPECT_RATIO_INDEX, ASPECT_RATIO_SQUARE));
|
|
|
|
aspectL->addLayout(leftAspect);
|
|
aspectL->addStretch();
|
|
aspectL->addSpacing(30);
|
|
aspectL->addLayout(rightAspect);
|
|
|
|
addRow(aspectL);
|
|
addRow(full);
|
|
addRow(custom);
|
|
|
|
connect(m_radioButton, SIGNAL(clicked(bool)), this, SLOT(onAspectRadioClicked(bool)));
|
|
}
|
|
|
|
void AspectRatioGroup::paintEvent(QPaintEvent *event)
|
|
{
|
|
settings_t *settings = config_get_ptr();
|
|
unsigned value = settings->uints.video_aspect_ratio_idx;
|
|
|
|
if (ASPECT_RATIO_4_3 >= value || value <= ASPECT_RATIO_32_9)
|
|
{
|
|
m_comboBox->blockSignals(false);
|
|
m_radioButton->setChecked(true);
|
|
}
|
|
else
|
|
m_comboBox->blockSignals(true);
|
|
|
|
SettingsGroup::paintEvent(event);
|
|
}
|
|
|
|
void AspectRatioGroup::onAspectRadioToggled(bool checked)
|
|
{
|
|
if (checked)
|
|
m_comboBox->currentIndexChanged(m_comboBox->currentIndex());
|
|
else
|
|
m_comboBox->blockSignals(true);
|
|
}
|
|
|
|
void AspectRatioGroup::onAspectRadioClicked(bool checked)
|
|
{
|
|
m_comboBox->blockSignals(false);
|
|
m_comboBox->currentIndexChanged(m_comboBox->currentIndex());
|
|
setChecked(true);
|
|
}
|
|
|
|
|
|
void VideoPage::onCrtSuperResolutionComboIndexChanged(int index)
|
|
{
|
|
settings_t *settings = config_get_ptr();
|
|
(void)(index);
|
|
|
|
if (m_crtSuperResolutionCombo)
|
|
settings->uints.crt_switch_resolution_super =
|
|
m_crtSuperResolutionCombo->currentData().value<unsigned>();
|
|
}
|
|
|
|
void VideoPage::onResolutionComboIndexChanged(const QString &text)
|
|
{
|
|
const char *path = text.toUtf8().constData();
|
|
action_cb_push_dropdown_item_resolution(path,
|
|
NULL, 0, 0, 0);
|
|
}
|
|
|
|
void VideoPage::onResolutionComboIndexChanged(int index)
|
|
{
|
|
const QString& text = m_resolutionCombo->itemText(index);
|
|
const char *path = text.toUtf8().constData();
|
|
action_cb_push_dropdown_item_resolution(path,
|
|
NULL, 0, 0, 0);
|
|
}
|
|
|
|
AspectRatioRadioButton::AspectRatioRadioButton(unsigned min, unsigned max, QWidget *parent) :
|
|
QRadioButton(parent)
|
|
,m_min(min)
|
|
,m_max(max)
|
|
{
|
|
}
|
|
|
|
/* DRIVERS */
|
|
|
|
DriversPage::DriversPage(QObject *parent) :
|
|
OptionsPage(parent)
|
|
{
|
|
}
|
|
|
|
QWidget *DriversPage::widget()
|
|
{
|
|
QWidget *widget = new QWidget;
|
|
QVBoxLayout *layout = new QVBoxLayout;
|
|
QHBoxLayout *contentLayout = new QHBoxLayout;
|
|
QVBoxLayout *leftColumn = new QVBoxLayout;
|
|
SettingsGroup *graphicsGroup = new SettingsGroup("Graphics & Menu");
|
|
SettingsGroup *inputGroup = new SettingsGroup("Input");
|
|
SettingsGroup *audioGroup = new SettingsGroup("Audio");
|
|
SettingsGroup *otherGroup = new SettingsGroup("Other Devices");
|
|
static const enum msg_hash_enums graphicsEntries[] = {
|
|
MENU_ENUM_LABEL_MENU_DRIVER,
|
|
MENU_ENUM_LABEL_VIDEO_DRIVER,
|
|
#if defined(HAVE_RSLC) && defined(HAVE_GLSLANG)
|
|
MENU_ENUM_LABEL_VIDEO_SHADER_COMPILER
|
|
#endif
|
|
};
|
|
static const enum msg_hash_enums inputEntries[] = {
|
|
MENU_ENUM_LABEL_INPUT_DRIVER,
|
|
MENU_ENUM_LABEL_JOYPAD_DRIVER
|
|
};
|
|
static const enum msg_hash_enums audioEntries[] = {
|
|
MENU_ENUM_LABEL_AUDIO_DRIVER,
|
|
#ifdef HAVE_MICROPHONE
|
|
MENU_ENUM_LABEL_MICROPHONE_DRIVER,
|
|
#endif
|
|
MENU_ENUM_LABEL_MIDI_DRIVER
|
|
};
|
|
static const enum msg_hash_enums otherEntries[] = {
|
|
MENU_ENUM_LABEL_RECORD_DRIVER,
|
|
#ifdef HAVE_COMPANION_WIMP
|
|
MENU_ENUM_LABEL_UI_COMPANION_DRIVER,
|
|
#endif
|
|
#ifdef HAVE_BLUETOOTH
|
|
MENU_ENUM_LABEL_BLUETOOTH_DRIVER,
|
|
#endif
|
|
#if defined(HAVE_LAKKA) || defined(HAVE_WIFI)
|
|
MENU_ENUM_LABEL_WIFI_DRIVER,
|
|
#endif
|
|
MENU_ENUM_LABEL_CAMERA_DRIVER,
|
|
MENU_ENUM_LABEL_LOCATION_DRIVER
|
|
};
|
|
|
|
file_list_t *driverList = qt_displaylist_build(
|
|
DISPLAYLIST_DRIVER_SETTINGS_LIST);
|
|
|
|
qt_settings_group_add_list(graphicsGroup,
|
|
driverList, NULL, 0,
|
|
graphicsEntries, ARRAY_SIZE(graphicsEntries));
|
|
qt_settings_group_add_list(inputGroup,
|
|
driverList, NULL, 0,
|
|
inputEntries, ARRAY_SIZE(inputEntries));
|
|
qt_settings_group_add_list(audioGroup,
|
|
driverList, NULL, 0,
|
|
audioEntries, ARRAY_SIZE(audioEntries));
|
|
qt_settings_group_add_list(otherGroup,
|
|
driverList, NULL, 0,
|
|
otherEntries, ARRAY_SIZE(otherEntries));
|
|
if (driverList)
|
|
file_list_free(driverList);
|
|
|
|
leftColumn->addWidget(graphicsGroup);
|
|
leftColumn->addWidget(inputGroup);
|
|
leftColumn->addWidget(audioGroup);
|
|
leftColumn->addWidget(otherGroup);
|
|
leftColumn->addStretch();
|
|
contentLayout->addLayout(leftColumn, 1);
|
|
contentLayout->addStretch(1);
|
|
layout->addLayout(contentLayout);
|
|
layout->addStretch();
|
|
widget->setLayout(layout);
|
|
return widget;
|
|
}
|
|
|
|
DriversCategory::DriversCategory(QWidget *parent) :
|
|
OptionsCategory(parent)
|
|
{
|
|
setDisplayName(MENU_ENUM_LABEL_VALUE_DRIVER_SETTINGS);
|
|
setCategoryIcon("menu_drivers");
|
|
}
|
|
|
|
QVector<OptionsPage*> DriversCategory::pages()
|
|
{
|
|
QVector<OptionsPage*> pages;
|
|
pages << new DriversPage(this);
|
|
return pages;
|
|
}
|
|
|
|
/* DIRECTORY */
|
|
|
|
DirectoryCategory::DirectoryCategory(QWidget *parent) :
|
|
OptionsCategory(parent)
|
|
{
|
|
setDisplayName(MENU_ENUM_LABEL_VALUE_DIRECTORY_SETTINGS);
|
|
setCategoryIcon("folder");
|
|
}
|
|
|
|
QVector<OptionsPage*> DirectoryCategory::pages()
|
|
{
|
|
QVector<OptionsPage*> pages;
|
|
pages << new SimplePage(DISPLAYLIST_DIRECTORY_SETTINGS_LIST, this);
|
|
return pages;
|
|
}
|
|
|
|
/* CONFIGURATION */
|
|
|
|
ConfigurationCategory::ConfigurationCategory(QWidget *parent) :
|
|
OptionsCategory(parent)
|
|
{
|
|
setDisplayName(MENU_ENUM_LABEL_VALUE_CONFIGURATION_SETTINGS);
|
|
setCategoryIcon("setting");
|
|
}
|
|
|
|
QVector<OptionsPage*> ConfigurationCategory::pages()
|
|
{
|
|
QVector<OptionsPage*> pages;
|
|
pages << new SimplePage(DISPLAYLIST_CONFIGURATION_SETTINGS_LIST, this);
|
|
return pages;
|
|
}
|
|
|
|
/* CORE */
|
|
|
|
CoreCategory::CoreCategory(QWidget *parent) :
|
|
OptionsCategory(parent)
|
|
{
|
|
setDisplayName(MENU_ENUM_LABEL_VALUE_CORE_SETTINGS);
|
|
setCategoryIcon("core-options");
|
|
}
|
|
|
|
QVector<OptionsPage*> CoreCategory::pages()
|
|
{
|
|
QVector<OptionsPage*> pages;
|
|
pages << new SimplePage(DISPLAYLIST_CORE_SETTINGS_LIST, this);
|
|
return pages;
|
|
}
|
|
|
|
/* LOGGING */
|
|
|
|
class QtDisplayListGroupPage : public OptionsPage
|
|
{
|
|
public:
|
|
QtDisplayListGroupPage(enum menu_displaylist_ctl_state state,
|
|
const QString &title, QObject *parent = 0,
|
|
enum menu_displaylist_ctl_state secondState = DISPLAYLIST_NONE,
|
|
const QString &secondTitle = QString(),
|
|
enum menu_displaylist_ctl_state thirdState = DISPLAYLIST_NONE,
|
|
const QString &thirdTitle = QString())
|
|
: OptionsPage(parent), m_state(state), m_title(title),
|
|
m_secondState(secondState), m_secondTitle(secondTitle),
|
|
m_thirdState(thirdState), m_thirdTitle(thirdTitle)
|
|
{
|
|
setDisplayName(title);
|
|
}
|
|
|
|
QWidget *widget()
|
|
{
|
|
QWidget *page = new QWidget;
|
|
QHBoxLayout *columns = new QHBoxLayout;
|
|
QVBoxLayout *left = new QVBoxLayout;
|
|
SettingsGroup *first = new SettingsGroup(m_title);
|
|
qt_settings_group_add_displaylist(first, m_state, NULL, 0, NULL, 0);
|
|
left->addWidget(first);
|
|
if (m_secondState != DISPLAYLIST_NONE)
|
|
{
|
|
SettingsGroup *second = new SettingsGroup(m_secondTitle);
|
|
qt_settings_group_add_displaylist(second, m_secondState, NULL, 0, NULL, 0);
|
|
left->addWidget(second);
|
|
}
|
|
if (m_thirdState != DISPLAYLIST_NONE)
|
|
{
|
|
SettingsGroup *third = new SettingsGroup(m_thirdTitle);
|
|
qt_settings_group_add_displaylist(third, m_thirdState, NULL, 0, NULL, 0);
|
|
left->addWidget(third);
|
|
}
|
|
left->addStretch();
|
|
columns->addLayout(left, 1);
|
|
columns->addStretch(1);
|
|
page->setLayout(columns);
|
|
return page;
|
|
}
|
|
|
|
private:
|
|
enum menu_displaylist_ctl_state m_state;
|
|
QString m_title;
|
|
enum menu_displaylist_ctl_state m_secondState;
|
|
QString m_secondTitle;
|
|
enum menu_displaylist_ctl_state m_thirdState;
|
|
QString m_thirdTitle;
|
|
};
|
|
|
|
LoggingCategory::LoggingCategory(QWidget *parent) :
|
|
OptionsCategory(parent)
|
|
{
|
|
setDisplayName(MENU_ENUM_LABEL_VALUE_LOGGING_SETTINGS);
|
|
setCategoryIcon("menu_log");
|
|
}
|
|
|
|
QVector<OptionsPage*> LoggingCategory::pages()
|
|
{
|
|
QVector<OptionsPage*> pages;
|
|
pages << new QtDisplayListGroupPage(DISPLAYLIST_LOGGING_SETTINGS_LIST,
|
|
msg_hash_to_str(MENU_ENUM_LABEL_VALUE_LOGGING_SETTINGS), this);
|
|
return pages;
|
|
}
|
|
|
|
/* AI SERVICE */
|
|
|
|
AIServiceCategory::AIServiceCategory(QWidget *parent) :
|
|
OptionsCategory(parent)
|
|
{
|
|
setDisplayName(MENU_ENUM_LABEL_VALUE_AI_SERVICE_SETTINGS);
|
|
setCategoryIcon("menu_drivers");
|
|
}
|
|
|
|
QVector<OptionsPage*> AIServiceCategory::pages()
|
|
{
|
|
QVector<OptionsPage*> pages;
|
|
pages << new SimplePage(DISPLAYLIST_AI_SERVICE_SETTINGS_LIST,
|
|
MENU_ENUM_LABEL_VALUE_AI_SERVICE_SETTINGS, this);
|
|
return pages;
|
|
}
|
|
|
|
/* FRAME THROTTLE */
|
|
|
|
FrameThrottleCategory::FrameThrottleCategory(QWidget *parent) :
|
|
OptionsCategory(parent)
|
|
{
|
|
setDisplayName(MENU_ENUM_LABEL_VALUE_FRAME_THROTTLE_SETTINGS);
|
|
setCategoryIcon("menu_frameskip");
|
|
}
|
|
|
|
QVector<OptionsPage*> FrameThrottleCategory::pages()
|
|
{
|
|
QVector<OptionsPage*> pages;
|
|
pages << new QtDisplayListGroupPage(DISPLAYLIST_FRAME_THROTTLE_SETTINGS_LIST,
|
|
msg_hash_to_str(MENU_ENUM_LABEL_VALUE_FRAME_THROTTLE_SETTINGS), this,
|
|
DISPLAYLIST_REWIND_SETTINGS_LIST,
|
|
msg_hash_to_str(MENU_ENUM_LABEL_VALUE_REWIND_SETTINGS),
|
|
DISPLAYLIST_FRAME_TIME_COUNTER_SETTINGS_LIST,
|
|
msg_hash_to_str(MENU_ENUM_LABEL_VALUE_FRAME_TIME_COUNTER_SETTINGS));
|
|
return pages;
|
|
}
|
|
|
|
#endif /* HAVE_MENU - OptionsCategory/OptionsPage implementations */
|
|
|
|
PlaylistModel::PlaylistModel(QObject *parent)
|
|
: QAbstractListModel(parent)
|
|
{
|
|
/* The shared companion thumbnail engine: threads sized to the
|
|
* machine, cache budget from the view options. */
|
|
m_engine = companion_thumbs_new(0, 0);
|
|
setThumbnailCacheLimit(500);
|
|
/* Finished decodes are collected on the UI thread from a timer that
|
|
* only runs while something is pending. */
|
|
m_pollTimer.setInterval(16);
|
|
connect(&m_pollTimer, SIGNAL(timeout()), this, SLOT(pollThumbnails()));
|
|
}
|
|
|
|
PlaylistModel::~PlaylistModel()
|
|
{
|
|
if (m_engine)
|
|
companion_thumbs_free(m_engine); /* joins the decode threads */
|
|
}
|
|
|
|
int PlaylistModel::rowCount(const QModelIndex & /* parent */) const
|
|
{
|
|
return m_contents.count();
|
|
}
|
|
|
|
int PlaylistModel::columnCount(const QModelIndex & /* parent */) const
|
|
{
|
|
return 1;
|
|
}
|
|
|
|
QVariant PlaylistModel::data(const QModelIndex &index, int role) const
|
|
{
|
|
if (index.column() == 0)
|
|
{
|
|
if (!index.isValid() || index.row() >= m_contents.size() || index.row() < 0)
|
|
return QVariant();
|
|
|
|
switch (role)
|
|
{
|
|
case Qt::DisplayRole:
|
|
case Qt::EditRole:
|
|
case Qt::ToolTipRole:
|
|
return m_contents.at(index.row()).labelNoExt;
|
|
case ENTRY:
|
|
return QVariant::fromValue(m_contents.at(index.row()));
|
|
case THUMBNAIL:
|
|
{
|
|
/* The engine's pixels for this row at the grid's size,
|
|
* converted to a QPixmap once and kept in m_cache. */
|
|
QPixmap *pm = pixmapFor(getCurrentTypeThumbnailPath(index),
|
|
VIDEO_SCALE_PACK(m_thumbSize, m_thumbSize));
|
|
if (pm)
|
|
return *pm;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
return QVariant();
|
|
}
|
|
|
|
Qt::ItemFlags PlaylistModel::flags(const QModelIndex &index) const
|
|
{
|
|
if (!index.isValid())
|
|
return Qt::ItemIsEnabled;
|
|
|
|
return QAbstractListModel::flags(index) | Qt::ItemIsEditable;
|
|
}
|
|
|
|
bool PlaylistModel::setData(const QModelIndex &index, const QVariant &value, int role)
|
|
{
|
|
if (index.isValid() && role == Qt::EditRole)
|
|
{
|
|
PlaylistEntry rowEntry = m_contents.at(index.row());
|
|
|
|
rowEntry.label = value.toString();
|
|
rowEntry.labelNoExt = QFileInfo(value.toString()).completeBaseName();
|
|
|
|
m_contents.replace(index.row(), rowEntry);
|
|
emit dataChanged(index, index, { role });
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
QVariant PlaylistModel::headerData(int section,
|
|
Qt::Orientation orientation, int role) const
|
|
{
|
|
if (role != Qt::DisplayRole)
|
|
return QVariant();
|
|
|
|
if (orientation == Qt::Horizontal)
|
|
return msg_hash_to_str(MENU_ENUM_LABEL_VALUE_QT_NAME);
|
|
return section + 1;
|
|
}
|
|
|
|
void PlaylistModel::setThumbnailType(const ThumbnailType type)
|
|
{
|
|
m_thumbnailType = type;
|
|
}
|
|
|
|
void PlaylistModel::setThumbnailCacheLimit(int limit)
|
|
{
|
|
/* The setting is in MB: the engine holds the decoded pixels under
|
|
* that budget; the QPixmap conversion cache mirrors it in KB. */
|
|
if (m_engine)
|
|
companion_thumbs_set_budget(m_engine,
|
|
(size_t)(limit > 0 ? limit : 64) * 1024 * 1024);
|
|
m_cache.setMaxCost(limit * 1024);
|
|
}
|
|
|
|
void PlaylistModel::setThumbnailSize(int size)
|
|
{
|
|
if (size < 16)
|
|
size = 16;
|
|
if (size == m_thumbSize)
|
|
return;
|
|
m_thumbSize = size;
|
|
/* Pixmaps at the old size are keyed by it and simply age out; what
|
|
* was queued at the old size is dropped. */
|
|
if (m_engine)
|
|
companion_thumbs_cancel(m_engine);
|
|
m_pendingRows.clear();
|
|
}
|
|
|
|
QString PlaylistModel::getThumbnailPath(const QModelIndex &index,
|
|
QString type) const
|
|
{
|
|
return getThumbnailPath(m_contents.at(index.row()), type);
|
|
}
|
|
|
|
/* Thumbnail layout, name sanitising and extension probing live in the
|
|
* companion core; these are the Qt string wrappers. */
|
|
QString PlaylistModel::getPlaylistThumbnailsDir(
|
|
const QString playlistName, const QString type) const
|
|
{
|
|
char dir[PATH_MAX_LENGTH];
|
|
QByteArray dbArray = playlistName.toUtf8();
|
|
QByteArray typeArray = type.toUtf8();
|
|
|
|
companion_core_thumbnail_dir(ui_companion_qt_core(),
|
|
dbArray.constData(), typeArray.constData(), dir, sizeof(dir));
|
|
return QString::fromUtf8(dir);
|
|
}
|
|
|
|
bool PlaylistModel::isSupportedImage(const QString path) const
|
|
{
|
|
QByteArray pathArray = path.toUtf8();
|
|
return image_texture_get_type(pathArray.constData()) != IMAGE_TYPE_NONE;
|
|
}
|
|
|
|
QString PlaylistModel::getRepositoryThumbnailPath(const QString playlistName,
|
|
const QString labelNoExt, const QString type) const
|
|
{
|
|
char path[PATH_MAX_LENGTH];
|
|
QByteArray dbArray = playlistName.toUtf8();
|
|
QByteArray typeArray = type.toUtf8();
|
|
QByteArray labelArray = labelNoExt.toUtf8();
|
|
|
|
companion_core_thumbnail_path(ui_companion_qt_core(),
|
|
dbArray.constData(), typeArray.constData(), labelArray.constData(),
|
|
NULL, path, sizeof(path));
|
|
return QString::fromUtf8(path);
|
|
}
|
|
|
|
QString PlaylistModel::getThumbnailPath(const PlaylistEntry &entry, QString type) const
|
|
{
|
|
char path[PATH_MAX_LENGTH];
|
|
QByteArray dbArray = entry.dbName.toUtf8();
|
|
QByteArray typeArray = type.toUtf8();
|
|
QByteArray labelArray = entry.labelNoExt.toUtf8();
|
|
QByteArray pathArray = entry.path.toUtf8();
|
|
|
|
companion_core_thumbnail_path(ui_companion_qt_core(),
|
|
dbArray.constData(), typeArray.constData(), labelArray.constData(),
|
|
pathArray.constData(), path, sizeof(path));
|
|
return QString::fromUtf8(path);
|
|
}
|
|
|
|
QString PlaylistModel::getCurrentTypeThumbnailPath(const QModelIndex &index) const
|
|
{
|
|
switch (m_thumbnailType)
|
|
{
|
|
case THUMBNAIL_TYPE_BOXART:
|
|
return getThumbnailPath(index, THUMBNAIL_BOXART);
|
|
case THUMBNAIL_TYPE_SCREENSHOT:
|
|
return getThumbnailPath(index, THUMBNAIL_SCREENSHOT);
|
|
case THUMBNAIL_TYPE_TITLE_SCREEN:
|
|
return getThumbnailPath(index, THUMBNAIL_TITLE);
|
|
case THUMBNAIL_TYPE_LOGO:
|
|
return getThumbnailPath(index, THUMBNAIL_LOGO);
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return QString();
|
|
}
|
|
|
|
void PlaylistModel::reloadThumbnail(const QModelIndex &index)
|
|
{
|
|
if (index.isValid())
|
|
{
|
|
reloadThumbnailPath(getCurrentTypeThumbnailPath(index));
|
|
loadThumbnail(index);
|
|
}
|
|
}
|
|
|
|
void PlaylistModel::reloadSystemThumbnails(const QString system)
|
|
{
|
|
int i = 0;
|
|
settings_t *settings = config_get_ptr();
|
|
const char *path_dir_thumbnails = settings->paths.directory_thumbnails;
|
|
QString path = QDir::cleanPath(QString(path_dir_thumbnails))
|
|
+ QString("/") + system;
|
|
QList<QString> keys = m_cache.keys();
|
|
|
|
for (i = 0; i < keys.size(); i++)
|
|
{
|
|
QString key = keys.at(i);
|
|
if (key.startsWith(path))
|
|
{
|
|
m_cache.remove(key);
|
|
if (m_engine)
|
|
companion_thumbs_forget(m_engine,
|
|
key.left(key.lastIndexOf(QLatin1Char('@'))).toUtf8().constData());
|
|
}
|
|
}
|
|
}
|
|
|
|
void PlaylistModel::reloadThumbnailPath(const QString path)
|
|
{
|
|
QList<QString> keys = m_cache.keys();
|
|
int i;
|
|
for (i = 0; i < keys.size(); i++)
|
|
if (keys.at(i).startsWith(path + QLatin1Char('@')))
|
|
m_cache.remove(keys.at(i));
|
|
if (m_engine)
|
|
companion_thumbs_forget(m_engine, path.toUtf8().constData());
|
|
m_pendingRows.remove(path);
|
|
}
|
|
|
|
void PlaylistModel::loadThumbnail(const QModelIndex &index)
|
|
{
|
|
QString path = getCurrentTypeThumbnailPath(index);
|
|
if (!m_engine || path.isEmpty())
|
|
return;
|
|
if (companion_thumbs_get(m_engine, path.toUtf8().constData(),
|
|
VIDEO_SCALE_PACK(m_thumbSize, m_thumbSize)))
|
|
return; /* data() serves it from the cache */
|
|
if (m_pendingRows.contains(path))
|
|
return;
|
|
m_pendingRows.insert(path, QPersistentModelIndex(index));
|
|
companion_thumbs_request(m_engine, path.toUtf8().constData(),
|
|
VIDEO_SCALE_PACK(m_thumbSize, m_thumbSize), 0, true, 0x00000000u);
|
|
if (!m_pollTimer.isActive())
|
|
m_pollTimer.start();
|
|
}
|
|
|
|
#define QT_TAG_ANIM_FRAME ((uintptr_t)1 << (sizeof(uintptr_t) * 8 - 1))
|
|
|
|
void PlaylistModel::onEngineDone(void *ud, const char *path, unsigned dims,
|
|
uintptr_t tag, const uint32_t *bits)
|
|
{
|
|
PlaylistModel *self = static_cast<PlaylistModel*>(ud);
|
|
if (tag & QT_TAG_ANIM_FRAME)
|
|
{
|
|
/* An animation frame: not cached, shown at once. fromImage()
|
|
* copies into the pixmap, so wrap the engine's buffer directly
|
|
* rather than copying it once more first. */
|
|
if (bits)
|
|
{
|
|
int w = (int)VIDEO_SCALE_W(dims);
|
|
QImage img((const uchar*)bits, w, (int)VIDEO_SCALE_H(dims), w * 4,
|
|
QImage::Format_ARGB32);
|
|
emit self->frameReady(QString::fromUtf8(path), QPixmap::fromImage(img));
|
|
}
|
|
return;
|
|
}
|
|
self->thumbnailArrived(QString::fromUtf8(path));
|
|
}
|
|
|
|
void PlaylistModel::animateImage(const QString &path, unsigned dims)
|
|
{
|
|
if ( !m_engine || path.isEmpty()
|
|
|| !VIDEO_SCALE_W(dims) || !VIDEO_SCALE_H(dims))
|
|
return;
|
|
companion_thumbs_animate(m_engine, path.toUtf8().constData(), dims,
|
|
QT_TAG_ANIM_FRAME, 0x00000000u);
|
|
if (!m_pollTimer.isActive())
|
|
m_pollTimer.start();
|
|
}
|
|
|
|
void PlaylistModel::stopAnimation()
|
|
{
|
|
if (m_engine)
|
|
companion_thumbs_animate_stop(m_engine);
|
|
}
|
|
|
|
QPixmap *PlaylistModel::pixmapFor(const QString &path, unsigned dims) const
|
|
{
|
|
int w = (int)VIDEO_SCALE_W(dims);
|
|
int h = (int)VIDEO_SCALE_H(dims);
|
|
QString key = path + QLatin1Char('@') + QString::number(w)
|
|
+ QLatin1Char('x') + QString::number(h);
|
|
QPixmap *pm = m_cache.object(key);
|
|
const uint32_t *bits;
|
|
if (pm)
|
|
return pm;
|
|
if (!m_engine || path.isEmpty())
|
|
return NULL;
|
|
bits = companion_thumbs_get(m_engine, path.toUtf8().constData(), dims);
|
|
if (!bits)
|
|
return NULL;
|
|
{
|
|
/* copy(): the engine pointer is only valid until its next call */
|
|
QImage img((const uchar*)bits, w, h, w * 4, QImage::Format_ARGB32);
|
|
int cost;
|
|
pm = new QPixmap(QPixmap::fromImage(img.copy()));
|
|
cost = pm->width() * pm->height() * pm->depth() / (8 * 1024);
|
|
if (m_cache.maxCost() > 0 && cost > m_cache.maxCost())
|
|
cost = m_cache.maxCost();
|
|
m_cache.insert(key, pm, cost);
|
|
}
|
|
return pm;
|
|
}
|
|
|
|
bool PlaylistModel::imageAt(const QString &path, unsigned dims, QPixmap *out) const
|
|
{
|
|
QPixmap *pm = pixmapFor(path, dims);
|
|
if (!pm)
|
|
return false;
|
|
if (out)
|
|
*out = *pm;
|
|
return true;
|
|
}
|
|
|
|
void PlaylistModel::abandonPending()
|
|
{
|
|
if (m_engine)
|
|
companion_thumbs_cancel(m_engine);
|
|
m_pendingRows.clear();
|
|
}
|
|
|
|
void PlaylistModel::requestImage(const QString &path, unsigned dims)
|
|
{
|
|
if ( !m_engine || path.isEmpty()
|
|
|| !VIDEO_SCALE_W(dims) || !VIDEO_SCALE_H(dims))
|
|
return;
|
|
companion_thumbs_request(m_engine, path.toUtf8().constData(), dims, 0,
|
|
true, 0x00000000u);
|
|
if (!m_pollTimer.isActive())
|
|
m_pollTimer.start();
|
|
}
|
|
|
|
void PlaylistModel::thumbnailArrived(const QString &path)
|
|
{
|
|
QPersistentModelIndex index = m_pendingRows.take(path);
|
|
emit thumbnailReady(path);
|
|
/* index is persistent: it tracks the row across insertions / moves
|
|
* and is invalid if that row was removed or the model reset while
|
|
* the decode was in flight, so a stale row is never signalled. */
|
|
if (index.isValid())
|
|
{
|
|
const QModelIndex modelIndex(index);
|
|
emit dataChanged(modelIndex, modelIndex, { THUMBNAIL });
|
|
}
|
|
}
|
|
|
|
void PlaylistModel::pollThumbnails()
|
|
{
|
|
if (!m_engine)
|
|
return;
|
|
companion_thumbs_poll(m_engine, onEngineDone, this, 0, 4000);
|
|
if (!companion_thumbs_pending(m_engine) && !companion_thumbs_animating(m_engine))
|
|
m_pollTimer.stop();
|
|
}
|
|
|
|
|
|
static inline bool comp_hash_name_key_lower(const QHash<QString,
|
|
QString> &lhs, const QHash<QString, QString> &rhs)
|
|
{
|
|
return lhs.value("name").toLower() < rhs.value("name").toLower();
|
|
}
|
|
|
|
bool MainWindow::addDirectoryFilesToList(QProgressDialog *dialog,
|
|
QStringList &list, QDir &dir, QStringList &extensions)
|
|
{
|
|
int i;
|
|
PlaylistEntryDialog *playlistDialog = playlistEntryDialog();
|
|
QStringList dirList = dir.entryList(QStringList(),
|
|
QDir::Dirs | QDir::Files | QDir::NoDotAndDotDot
|
|
| QDir::Hidden | QDir::System,
|
|
QDir::Name);
|
|
|
|
for (i = 0; i < dirList.count(); i++)
|
|
{
|
|
QString path(dir.path() + QString("/") + dirList.at(i));
|
|
QByteArray pathArray = path.toUtf8();
|
|
QFileInfo fileInfo(path);
|
|
const char *pathData = pathArray.constData();
|
|
|
|
if (dialog->wasCanceled())
|
|
return false;
|
|
|
|
/* Needed to update progress dialog while doing
|
|
* a lot of stuff on the main thread. */
|
|
if (i % 25 == 0)
|
|
qApp->processEvents();
|
|
|
|
if (fileInfo.isDir())
|
|
{
|
|
QDir fileInfoDir(path);
|
|
if (!addDirectoryFilesToList(
|
|
dialog, list, fileInfoDir, extensions))
|
|
return false;
|
|
continue;
|
|
}
|
|
|
|
if (fileInfo.isFile())
|
|
{
|
|
bool add = false;
|
|
|
|
if (extensions.isEmpty())
|
|
add = true;
|
|
else
|
|
{
|
|
if (extensions.contains(fileInfo.suffix()))
|
|
add = true;
|
|
else
|
|
{
|
|
if (path_is_compressed_file(pathData))
|
|
{
|
|
struct string_list *archive_list =
|
|
file_archive_get_file_list(pathData, NULL);
|
|
|
|
if (archive_list)
|
|
{
|
|
if (archive_list->size == 1)
|
|
{
|
|
/* Assume archives with one file should have
|
|
* that file loaded directly.
|
|
* Don't just extend this to add all files
|
|
* in a ZIP, because we might hit something like
|
|
* MAME/FBA where only the archives themselves
|
|
* Only append inner file reference if filter
|
|
* inside archives is enabled */
|
|
if (playlistDialog->filterInArchive())
|
|
{
|
|
pathArray = (QString(pathData)
|
|
+ QString("#")
|
|
+ archive_list->elems[0].data).toUtf8();
|
|
pathData = pathArray.constData();
|
|
}
|
|
|
|
if (!extensions.isEmpty() && playlistDialog->filterInArchive())
|
|
{
|
|
/* If the user chose to filter extensions
|
|
* inside archives, and this particular file
|
|
* inside the archive
|
|
* doesn't have one of the chosen extensions,
|
|
* then we skip it. */
|
|
if (extensions.contains(
|
|
QString::fromUtf8(path_get_extension(pathData))))
|
|
add = true;
|
|
}
|
|
{
|
|
/* If the user chose to filter extensions
|
|
* inside archives, and this particular file
|
|
* inside the archive
|
|
* doesn't have one of the chosen extensions,
|
|
* then we skip it. */
|
|
if (extensions.contains(
|
|
QString::fromUtf8(path_get_extension(pathData))))
|
|
add = true;
|
|
}
|
|
}
|
|
|
|
string_list_free(archive_list);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (add)
|
|
list.append(fileInfo.absoluteFilePath());
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
void MainWindow::onPlaylistFilesDropped(QStringList files)
|
|
{
|
|
addFilesToPlaylist(files);
|
|
}
|
|
|
|
/* Takes a list of files and folders and adds them to the
|
|
* currently selected playlist. Folders will have their
|
|
* contents added recursively. */
|
|
void MainWindow::addFilesToPlaylist(QStringList files)
|
|
{
|
|
int i;
|
|
QStringList list;
|
|
QString currentPlaylistPath;
|
|
QByteArray currentPlaylistArray;
|
|
QScopedPointer<QProgressDialog> dialog(NULL);
|
|
QHash<QString, QString> selectedCore;
|
|
PlaylistEntry itemToAdd;
|
|
QString selectedDatabase;
|
|
QString selectedName;
|
|
QString selectedPath;
|
|
QStringList selectedExtensions;
|
|
QListWidgetItem *currentItem = m_listWidget->currentItem();
|
|
PlaylistEntryDialog *playlistDialog = playlistEntryDialog();
|
|
const char *currentPlaylistData = NULL;
|
|
playlist_t *playlist = NULL;
|
|
companion_core_t *core = ui_companion_qt_core();
|
|
|
|
/* Assume a blank list means we will manually enter in all fields. */
|
|
if (files.isEmpty())
|
|
{
|
|
/* Leave fields default-empty: the dialog will offer the
|
|
* "Multiple" placeholder when it sees an empty path. */
|
|
}
|
|
else if (files.count() == 1)
|
|
{
|
|
QString path = files.at(0);
|
|
QFileInfo info(path);
|
|
|
|
if (info.isFile())
|
|
{
|
|
itemToAdd.label = info.completeBaseName();
|
|
itemToAdd.path = path;
|
|
}
|
|
}
|
|
|
|
if (currentItem)
|
|
{
|
|
currentPlaylistPath = currentItem->data(Qt::UserRole).toString();
|
|
|
|
if (!currentPlaylistPath.isEmpty())
|
|
{
|
|
currentPlaylistArray = currentPlaylistPath.toUtf8();
|
|
currentPlaylistData = currentPlaylistArray.constData();
|
|
}
|
|
}
|
|
|
|
if (currentPlaylistPath == ALL_PLAYLISTS_TOKEN)
|
|
{
|
|
showMessageBox(msg_hash_to_str(
|
|
MENU_ENUM_LABEL_VALUE_QT_CANNOT_ADD_TO_ALL_PLAYLISTS),
|
|
MainWindow::MSGBOX_TYPE_ERROR,
|
|
Qt::ApplicationModal, false);
|
|
return;
|
|
}
|
|
|
|
/* a blank itemToAdd means there will be multiple */
|
|
if (!playlistDialog->showDialog(itemToAdd))
|
|
return;
|
|
|
|
selectedName = m_playlistEntryDialog->getSelectedName();
|
|
selectedPath = m_playlistEntryDialog->getSelectedPath();
|
|
selectedCore = m_playlistEntryDialog->getSelectedCore();
|
|
selectedDatabase = m_playlistEntryDialog->getSelectedDatabase();
|
|
selectedExtensions = m_playlistEntryDialog->getSelectedExtensions();
|
|
|
|
if (!selectedExtensions.isEmpty())
|
|
selectedExtensions.replaceInStrings(QRegularExpression("^\\."), "");
|
|
|
|
if (selectedDatabase.isEmpty())
|
|
selectedDatabase = QFileInfo(currentPlaylistPath).fileName();
|
|
else
|
|
selectedDatabase.append(".lpl");
|
|
|
|
dialog.reset(new QProgressDialog(msg_hash_to_str(
|
|
MENU_ENUM_LABEL_VALUE_QT_GATHERING_LIST_OF_FILES),
|
|
"Cancel", 0, 0, this));
|
|
dialog->setWindowModality(Qt::ApplicationModal);
|
|
dialog->show();
|
|
|
|
qApp->processEvents();
|
|
|
|
if ( selectedName.isEmpty()
|
|
|| selectedPath.isEmpty()
|
|
|| selectedDatabase.isEmpty())
|
|
{
|
|
showMessageBox(msg_hash_to_str(
|
|
MENU_ENUM_LABEL_VALUE_QT_PLEASE_FILL_OUT_REQUIRED_FIELDS),
|
|
MainWindow::MSGBOX_TYPE_ERROR, Qt::ApplicationModal, false);
|
|
return;
|
|
}
|
|
|
|
if (files.isEmpty())
|
|
files.append(selectedPath);
|
|
|
|
for (i = 0; i < files.count(); i++)
|
|
{
|
|
QString path(files.at(i));
|
|
QFileInfo fileInfo(path);
|
|
|
|
if (dialog->wasCanceled())
|
|
return;
|
|
|
|
/* Needed to update progress dialog while
|
|
* doing a lot of stuff on the main thread. */
|
|
if (i % 25 == 0)
|
|
qApp->processEvents();
|
|
|
|
if (fileInfo.isDir())
|
|
{
|
|
QDir dir(path);
|
|
if (!addDirectoryFilesToList(
|
|
dialog.data(), list, dir, selectedExtensions))
|
|
return;
|
|
continue;
|
|
}
|
|
|
|
if (fileInfo.isFile())
|
|
{
|
|
bool add = false;
|
|
|
|
if (selectedExtensions.isEmpty())
|
|
add = true;
|
|
else
|
|
{
|
|
QByteArray pathArray = path.toUtf8();
|
|
const char *pathData = pathArray.constData();
|
|
|
|
if (selectedExtensions.contains(fileInfo.suffix()))
|
|
add = true;
|
|
else if (playlistDialog->filterInArchive()
|
|
&& path_is_compressed_file(pathData))
|
|
{
|
|
/* We'll add it here, but really just delay
|
|
* the check until later when the archive
|
|
* contents are iterated. */
|
|
add = true;
|
|
}
|
|
}
|
|
|
|
if (add)
|
|
list.append(fileInfo.absoluteFilePath());
|
|
}
|
|
else if (files.count() == 1)
|
|
{
|
|
/* If adding a single file, tell user that it doesn't exist. */
|
|
showMessageBox(msg_hash_to_str(
|
|
MENU_ENUM_LABEL_VALUE_QT_FILE_DOES_NOT_EXIST),
|
|
MainWindow::MSGBOX_TYPE_ERROR, Qt::ApplicationModal,
|
|
false);
|
|
return;
|
|
}
|
|
}
|
|
|
|
dialog->setLabelText(msg_hash_to_str(
|
|
MENU_ENUM_LABEL_VALUE_QT_ADDING_FILES_TO_PLAYLIST));
|
|
dialog->setMaximum(list.count());
|
|
|
|
/* Deliberately a private instance (unlike the other playlist
|
|
* loads here): this is a bulk add whose cancel path discards
|
|
* the half-modified playlist by freeing it unwritten, which a
|
|
* borrowed cached instance cannot offer. The modal progress
|
|
* dialog pumps events, so this is not a UI-thread freeze. */
|
|
playlist = companion_core_playlist_open_private(core, currentPlaylistData);
|
|
if (!playlist)
|
|
return;
|
|
|
|
for (i = 0; i < list.count(); i++)
|
|
{
|
|
QFileInfo fileInfo;
|
|
QByteArray fileBaseNameArray;
|
|
QByteArray pathArray;
|
|
QByteArray corePathArray;
|
|
QByteArray coreNameArray;
|
|
QByteArray databaseArray;
|
|
char contentPath[PATH_MAX_LENGTH];
|
|
QString fileName = list.at(i);
|
|
const char *pathData = NULL;
|
|
const char *fileNameNoExten = NULL;
|
|
const char *corePathData = NULL;
|
|
const char *coreNameData = NULL;
|
|
const char *databaseData = NULL;
|
|
|
|
/* Cancel out of everything, the
|
|
* current progress will not be written
|
|
* to the playlist at all. */
|
|
if (dialog->wasCanceled())
|
|
{
|
|
companion_core_playlist_release(core, playlist, true, false);
|
|
return;
|
|
}
|
|
|
|
if (fileName.isEmpty())
|
|
continue;
|
|
|
|
/* a modal QProgressDialog calls processEvents()
|
|
* automatically in setValue() */
|
|
dialog->setValue(i + 1);
|
|
|
|
fileInfo = QFileInfo(fileName);
|
|
|
|
/* Make sure we're looking at a user-specified field
|
|
* and not just "<multiple>"
|
|
* in case it was a folder with one file in it */
|
|
if ( files.count() == 1
|
|
&& list.count() == 1
|
|
&& i == 0
|
|
&& playlistDialog->nameFieldEnabled())
|
|
{
|
|
fileBaseNameArray = selectedName.toUtf8();
|
|
pathArray = QDir::toNativeSeparators(selectedPath).toUtf8();
|
|
}
|
|
/* Otherwise just use the file name itself (minus extension)
|
|
* for the playlist entry title */
|
|
else
|
|
{
|
|
fileBaseNameArray = fileInfo.completeBaseName().toUtf8();
|
|
pathArray = QDir::toNativeSeparators(fileName).toUtf8();
|
|
}
|
|
|
|
fileNameNoExten = fileBaseNameArray.constData();
|
|
|
|
pathData = pathArray.constData();
|
|
|
|
if (!selectedCore.isEmpty())
|
|
{
|
|
corePathArray = QDir::toNativeSeparators(
|
|
selectedCore.value("core_path")).toUtf8();
|
|
coreNameArray = selectedCore.value("core_name").toUtf8();
|
|
corePathData = corePathArray.constData();
|
|
coreNameData = coreNameArray.constData();
|
|
}
|
|
/* else NULL: the core substitutes "DETECT" */
|
|
|
|
databaseArray = selectedDatabase.toUtf8();
|
|
databaseData = databaseArray.constData();
|
|
|
|
/* A single-file archive resolves to "archive#file". */
|
|
companion_core_resolve_content_path(core, pathData,
|
|
contentPath, sizeof(contentPath));
|
|
|
|
/* If the user chose to filter extensions inside archives, and
|
|
* the resolved file inside the archive doesn't have one of the
|
|
* chosen extensions, skip it. */
|
|
if ( strcmp(contentPath, pathData) != 0
|
|
&& !selectedExtensions.isEmpty()
|
|
&& playlistDialog->filterInArchive()
|
|
&& !selectedExtensions.contains(
|
|
QString::fromUtf8(path_get_extension(contentPath))))
|
|
continue;
|
|
|
|
companion_core_playlist_push(core, playlist, contentPath,
|
|
fileNameNoExten, corePathData, coreNameData, databaseData);
|
|
}
|
|
|
|
companion_core_playlist_release(core, playlist, true, true);
|
|
|
|
reloadPlaylists();
|
|
}
|
|
|
|
bool MainWindow::updateCurrentPlaylistEntry(
|
|
const PlaylistEntry &contentEntry)
|
|
{
|
|
QByteArray playlistPathArray;
|
|
QByteArray pathArray;
|
|
QByteArray labelArray;
|
|
QByteArray corePathArray;
|
|
QByteArray coreNameArray;
|
|
QByteArray dbNameArray;
|
|
QByteArray crc32Array;
|
|
char contentPath[PATH_MAX_LENGTH];
|
|
QString playlistPath = getCurrentPlaylistPath();
|
|
const char *playlistPathData = NULL;
|
|
const char *pathData = NULL;
|
|
const char *labelData = NULL;
|
|
const char *corePathData = NULL;
|
|
const char *coreNameData = NULL;
|
|
const char *dbNameData = NULL;
|
|
const char *crc32Data = NULL;
|
|
|
|
if ( playlistPath.isEmpty()
|
|
|| contentEntry.path.isEmpty()
|
|
|| contentEntry.label.isEmpty()
|
|
|| contentEntry.coreName.isEmpty()
|
|
|| contentEntry.corePath.isEmpty())
|
|
return false;
|
|
|
|
playlistPathArray = playlistPath.toUtf8();
|
|
pathArray = QDir::toNativeSeparators(contentEntry.path).toUtf8();
|
|
labelArray = contentEntry.label.toUtf8();
|
|
coreNameArray = contentEntry.coreName.toUtf8();
|
|
corePathArray = QDir::toNativeSeparators(contentEntry.corePath).toUtf8();
|
|
|
|
if (!contentEntry.dbName.isEmpty())
|
|
{
|
|
dbNameArray = (contentEntry.dbName + ".lpl").toUtf8();
|
|
dbNameData = dbNameArray.constData();
|
|
}
|
|
|
|
playlistPathData = playlistPathArray.constData();
|
|
pathData = pathArray.constData();
|
|
labelData = labelArray.constData();
|
|
coreNameData = coreNameArray.constData();
|
|
corePathData = corePathArray.constData();
|
|
|
|
if (!contentEntry.crc32.isEmpty())
|
|
{
|
|
crc32Array = contentEntry.crc32.toUtf8();
|
|
crc32Data = crc32Array.constData();
|
|
}
|
|
|
|
/* A single-file archive resolves to "archive#file". */
|
|
companion_core_resolve_content_path(ui_companion_qt_core(), pathData,
|
|
contentPath, sizeof(contentPath));
|
|
pathData = contentPath;
|
|
|
|
{
|
|
struct playlist_entry entry = {0};
|
|
|
|
/* The update function reads our entry as const,
|
|
* so these casts are safe */
|
|
entry.path = const_cast<char*>(pathData);
|
|
entry.label = const_cast<char*>(labelData);
|
|
entry.core_path = const_cast<char*>(corePathData);
|
|
entry.core_name = const_cast<char*>(coreNameData);
|
|
entry.crc32 = const_cast<char*>(crc32Data);
|
|
entry.db_name = const_cast<char*>(dbNameData);
|
|
|
|
if (!companion_core_playlist_update_entry(ui_companion_qt_core(),
|
|
playlistPathData, contentEntry.index, &entry))
|
|
return false;
|
|
}
|
|
|
|
reloadPlaylists();
|
|
|
|
return true;
|
|
}
|
|
|
|
void MainWindow::onPlaylistWidgetContextMenuRequested(const QPoint&)
|
|
{
|
|
QString currentPlaylistDirPath;
|
|
QString currentPlaylistPath;
|
|
QString currentPlaylistFileName;
|
|
QFile currentPlaylistFile;
|
|
QFileInfo currentPlaylistFileInfo;
|
|
QMap<QString, const core_info_t*> coreList;
|
|
QScopedPointer<QMenu> menu;
|
|
QScopedPointer<QMenu> associateMenu;
|
|
QScopedPointer<QMenu> hiddenPlaylistsMenu;
|
|
QScopedPointer<QMenu> downloadAllThumbnailsMenu;
|
|
QScopedPointer<QAction> hideAction;
|
|
QScopedPointer<QAction> newPlaylistAction;
|
|
QScopedPointer<QAction> deletePlaylistAction;
|
|
QScopedPointer<QAction> renamePlaylistAction;
|
|
QScopedPointer<QAction> downloadAllThumbnailsEntireSystemAction;
|
|
QScopedPointer<QAction> downloadAllThumbnailsThisPlaylistAction;
|
|
QPointer<QAction> selectedAction;
|
|
QPoint cursorPos = QCursor::pos();
|
|
settings_t *settings = config_get_ptr();
|
|
const char *path_dir_playlist = settings->paths.directory_playlist;
|
|
QDir playlistDir(path_dir_playlist);
|
|
QListWidgetItem *selectedItem = m_listWidget->itemAt(
|
|
m_listWidget->viewport()->mapFromGlobal(cursorPos));
|
|
QString playlistDirAbsPath = playlistDir.absolutePath();
|
|
core_info_list_t *core_info_list = NULL;
|
|
unsigned i = 0;
|
|
int j = 0;
|
|
bool specialPlaylist = false;
|
|
bool foundHiddenPlaylist = false;
|
|
|
|
if (selectedItem)
|
|
{
|
|
currentPlaylistPath = selectedItem->data(Qt::UserRole).toString();
|
|
currentPlaylistFile.setFileName(currentPlaylistPath);
|
|
|
|
currentPlaylistFileInfo = QFileInfo(currentPlaylistPath);
|
|
currentPlaylistFileName = currentPlaylistFileInfo.fileName();
|
|
currentPlaylistDirPath = currentPlaylistFileInfo.absoluteDir().absolutePath();
|
|
}
|
|
|
|
menu.reset(new QMenu(this));
|
|
menu->setObjectName("menu");
|
|
|
|
hiddenPlaylistsMenu.reset(new QMenu(msg_hash_to_str(MENU_ENUM_LABEL_VALUE_QT_HIDDEN_PLAYLISTS), this));
|
|
newPlaylistAction.reset(new QAction(QString(
|
|
msg_hash_to_str(MENU_ENUM_LABEL_VALUE_QT_NEW_PLAYLIST))
|
|
+ QString("..."), this));
|
|
|
|
hiddenPlaylistsMenu->setObjectName("hiddenPlaylistsMenu");
|
|
|
|
menu->addAction(newPlaylistAction.data());
|
|
|
|
if (currentPlaylistFile.exists())
|
|
{
|
|
deletePlaylistAction.reset(new QAction(
|
|
QString(msg_hash_to_str(
|
|
MENU_ENUM_LABEL_VALUE_QT_DELETE_PLAYLIST))
|
|
+ QString("..."), this));
|
|
menu->addAction(deletePlaylistAction.data());
|
|
|
|
renamePlaylistAction.reset(new QAction(QString(
|
|
msg_hash_to_str(MENU_ENUM_LABEL_VALUE_QT_RENAME_PLAYLIST))
|
|
+ QString("..."), this));
|
|
menu->addAction(renamePlaylistAction.data());
|
|
}
|
|
|
|
if (selectedItem)
|
|
{
|
|
hideAction.reset(new QAction(msg_hash_to_str(
|
|
MENU_ENUM_LABEL_VALUE_QT_HIDE), this));
|
|
menu->addAction(hideAction.data());
|
|
}
|
|
|
|
for (j = 0; j < m_listWidget->count(); j++)
|
|
{
|
|
QListWidgetItem *item = m_listWidget->item(j);
|
|
|
|
if (item->isHidden())
|
|
{
|
|
QAction *action = hiddenPlaylistsMenu->addAction(item->text());
|
|
action->setProperty("row", j);
|
|
action->setProperty("core_path", item->data(Qt::UserRole).toString());
|
|
foundHiddenPlaylist = true;
|
|
}
|
|
}
|
|
|
|
if (!foundHiddenPlaylist)
|
|
{
|
|
QAction *action = hiddenPlaylistsMenu->addAction(
|
|
msg_hash_to_str(MENU_ENUM_LABEL_VALUE_NONE));
|
|
action->setProperty("row", -1);
|
|
}
|
|
|
|
menu->addMenu(hiddenPlaylistsMenu.data());
|
|
|
|
/* Don't just compare strings in case there are
|
|
* case differences on Windows that should be ignored.
|
|
* Special playlists like history etc. can't have an association */
|
|
if (QDir(currentPlaylistDirPath) != QDir(playlistDirAbsPath))
|
|
specialPlaylist = true;
|
|
|
|
if (!specialPlaylist)
|
|
{
|
|
associateMenu.reset(new QMenu(msg_hash_to_str(
|
|
MENU_ENUM_LABEL_VALUE_QT_ASSOCIATE_CORE), this));
|
|
associateMenu->setObjectName("associateMenu");
|
|
|
|
core_info_get_list(&core_info_list);
|
|
|
|
for (i = 0; i < core_info_list->count && core_info_list->count > 0; i++)
|
|
{
|
|
const core_info_t *core = &core_info_list->list[i];
|
|
coreList[core->core_name] = core;
|
|
}
|
|
|
|
{
|
|
QMapIterator<QString, const core_info_t*> coreListIterator(coreList);
|
|
QVector<QHash<QString, QString> > cores;
|
|
|
|
while (coreListIterator.hasNext())
|
|
{
|
|
QString key, name;
|
|
const core_info_t *core = NULL;
|
|
QHash<QString, QString> hash;
|
|
|
|
coreListIterator.next();
|
|
|
|
key = coreListIterator.key();
|
|
core = coreList.value(key);
|
|
|
|
if (!core->core_name || !*core->core_name)
|
|
name = core->display_name;
|
|
else
|
|
name = core->core_name;
|
|
|
|
if (name.isEmpty())
|
|
continue;
|
|
|
|
hash["name"] = name;
|
|
hash["core_path"] = core->path;
|
|
|
|
cores.append(hash);
|
|
}
|
|
|
|
std::sort(cores.begin(), cores.end(), comp_hash_name_key_lower);
|
|
|
|
for (j = 0; j < cores.count(); j++)
|
|
{
|
|
const QHash<QString, QString> &hash = cores.at(j);
|
|
QAction *action = associateMenu->addAction(hash.value("name"));
|
|
|
|
action->setProperty("core_path", hash.value("core_path"));
|
|
}
|
|
}
|
|
|
|
menu->addMenu(associateMenu.data());
|
|
}
|
|
|
|
if (!specialPlaylist)
|
|
{
|
|
downloadAllThumbnailsMenu.reset(new QMenu(
|
|
msg_hash_to_str(MENU_ENUM_LABEL_VALUE_QT_DOWNLOAD_ALL_THUMBNAILS), this));
|
|
downloadAllThumbnailsMenu->setObjectName("downloadAllThumbnailsMenu");
|
|
|
|
downloadAllThumbnailsThisPlaylistAction.reset(
|
|
new QAction(msg_hash_to_str(
|
|
MENU_ENUM_LABEL_VALUE_QT_DOWNLOAD_ALL_THUMBNAILS_THIS_PLAYLIST),
|
|
downloadAllThumbnailsMenu.data()));
|
|
downloadAllThumbnailsEntireSystemAction.reset(
|
|
new QAction(msg_hash_to_str(
|
|
MENU_ENUM_LABEL_VALUE_QT_DOWNLOAD_ALL_THUMBNAILS_ENTIRE_SYSTEM),
|
|
downloadAllThumbnailsMenu.data()));
|
|
|
|
downloadAllThumbnailsMenu->addAction(
|
|
downloadAllThumbnailsThisPlaylistAction.data());
|
|
downloadAllThumbnailsMenu->addAction(
|
|
downloadAllThumbnailsEntireSystemAction.data());
|
|
|
|
menu->addMenu(downloadAllThumbnailsMenu.data());
|
|
}
|
|
|
|
selectedAction = menu->exec(cursorPos);
|
|
|
|
if (!selectedAction)
|
|
return;
|
|
|
|
if (!specialPlaylist && selectedAction->parent() == associateMenu.data())
|
|
{
|
|
QByteArray currentPlaylistPathByteArray = currentPlaylistPath.toUtf8();
|
|
QByteArray corePathByteArray = selectedAction->property("core_path").toString().toUtf8();
|
|
|
|
companion_core_playlist_set_default_core(ui_companion_qt_core(),
|
|
currentPlaylistPathByteArray.constData(),
|
|
corePathByteArray.constData());
|
|
}
|
|
else if (selectedItem && selectedAction == deletePlaylistAction.data())
|
|
{
|
|
if (currentPlaylistFile.exists())
|
|
{
|
|
if (showMessageBox(QString(msg_hash_to_str(MENU_ENUM_LABEL_VALUE_QT_CONFIRM_DELETE_PLAYLIST)).arg(selectedItem->text()), MainWindow::MSGBOX_TYPE_QUESTION_YESNO, Qt::ApplicationModal, false))
|
|
{
|
|
if (currentPlaylistFile.remove())
|
|
reloadPlaylists();
|
|
else
|
|
showMessageBox(msg_hash_to_str(MENU_ENUM_LABEL_VALUE_QT_COULD_NOT_DELETE_FILE), MainWindow::MSGBOX_TYPE_ERROR, Qt::ApplicationModal, false);
|
|
}
|
|
}
|
|
}
|
|
else if (selectedItem && selectedAction == renamePlaylistAction.data())
|
|
{
|
|
if (currentPlaylistFile.exists())
|
|
{
|
|
QString oldName = selectedItem->text();
|
|
QString name = QInputDialog::getText(this, msg_hash_to_str(MENU_ENUM_LABEL_VALUE_QT_RENAME_PLAYLIST), msg_hash_to_str(MENU_ENUM_LABEL_VALUE_QT_ENTER_NEW_PLAYLIST_NAME), QLineEdit::Normal, oldName);
|
|
|
|
if (!name.isEmpty())
|
|
{
|
|
renamePlaylistItem(selectedItem, name);
|
|
reloadPlaylists();
|
|
}
|
|
}
|
|
}
|
|
else if (selectedAction == newPlaylistAction.data())
|
|
{
|
|
QString name = QInputDialog::getText(this,
|
|
msg_hash_to_str(MENU_ENUM_LABEL_VALUE_QT_NEW_PLAYLIST),
|
|
msg_hash_to_str(MENU_ENUM_LABEL_VALUE_QT_ENTER_NEW_PLAYLIST_NAME));
|
|
QString newPlaylistPath = playlistDirAbsPath + "/" + name + ".lpl";
|
|
QFile file(newPlaylistPath);
|
|
|
|
if (!name.isEmpty())
|
|
{
|
|
if (file.open(QIODevice::WriteOnly))
|
|
file.close();
|
|
|
|
reloadPlaylists();
|
|
}
|
|
}
|
|
else if (selectedItem && selectedAction == hideAction.data())
|
|
{
|
|
int row = m_listWidget->row(selectedItem);
|
|
|
|
if (row >= 0)
|
|
{
|
|
qt_set_playlist_hidden(currentPlaylistFileName, true);
|
|
m_listWidget->setRowHidden(row, true);
|
|
}
|
|
}
|
|
else if (selectedAction->parent() == hiddenPlaylistsMenu.data())
|
|
{
|
|
QVariant rowVariant = selectedAction->property("row");
|
|
|
|
if (rowVariant.isValid())
|
|
{
|
|
int row = rowVariant.toInt();
|
|
|
|
if (row >= 0)
|
|
{
|
|
QString playlistPath = selectedAction->property("core_path").toString();
|
|
QFileInfo playlistFileInfo(playlistPath);
|
|
QString playlistFileName = playlistFileInfo.fileName();
|
|
|
|
qt_set_playlist_hidden(playlistFileName, false);
|
|
m_listWidget->setRowHidden(row, false);
|
|
}
|
|
}
|
|
}
|
|
else if (selectedItem && !specialPlaylist && selectedAction->parent() == downloadAllThumbnailsMenu.data())
|
|
{
|
|
if (selectedAction == downloadAllThumbnailsEntireSystemAction.data())
|
|
{
|
|
int row = m_listWidget->row(selectedItem);
|
|
|
|
if (row >= 0)
|
|
downloadAllThumbnails(currentPlaylistFileInfo.completeBaseName());
|
|
}
|
|
else if (selectedAction == downloadAllThumbnailsThisPlaylistAction.data())
|
|
downloadPlaylistThumbnails(currentPlaylistPath);
|
|
}
|
|
|
|
setCoreActions();
|
|
}
|
|
|
|
void MainWindow::deferReloadPlaylists() { emit gotReloadPlaylists(); }
|
|
void MainWindow::onGotReloadPlaylists() { reloadPlaylists(); }
|
|
|
|
void MainWindow::reloadPlaylists()
|
|
{
|
|
int i;
|
|
QString currentPlaylistPath;
|
|
QListWidgetItem *allPlaylistsItem = NULL;
|
|
QListWidgetItem *favoritesPlaylistsItem = NULL;
|
|
QListWidgetItem *imagePlaylistsItem = NULL;
|
|
QListWidgetItem *musicPlaylistsItem = NULL;
|
|
QListWidgetItem *videoPlaylistsItem = NULL;
|
|
QListWidgetItem *firstItem = NULL;
|
|
settings_t *settings = config_get_ptr();
|
|
const char *path_dir_playlist = settings->paths.directory_playlist;
|
|
QDir playlistDir(path_dir_playlist);
|
|
|
|
QListWidgetItem *currentItem = m_listWidget->currentItem();
|
|
|
|
if (currentItem)
|
|
currentPlaylistPath = currentItem->data(Qt::UserRole).toString();
|
|
|
|
getPlaylistFiles();
|
|
|
|
m_listWidget->clear();
|
|
m_listWidget->setSelectionBehavior(QAbstractItemView::SelectRows);
|
|
m_listWidget->setSelectionMode(QAbstractItemView::SingleSelection);
|
|
m_listWidget->setEditTriggers(QAbstractItemView::SelectedClicked | QAbstractItemView::EditKeyPressed);
|
|
|
|
allPlaylistsItem = new QListWidgetItem(m_folderIcon, msg_hash_to_str(MENU_ENUM_LABEL_VALUE_QT_ALL_PLAYLISTS));
|
|
allPlaylistsItem->setData(Qt::UserRole, ALL_PLAYLISTS_TOKEN);
|
|
|
|
favoritesPlaylistsItem = new QListWidgetItem(m_folderIcon, msg_hash_to_str(MENU_ENUM_LABEL_VALUE_FAVORITES_TAB));
|
|
favoritesPlaylistsItem->setData(Qt::UserRole, QString(settings->paths.path_content_favorites));
|
|
|
|
m_historyPlaylistsItem = new QListWidgetItem(m_folderIcon, msg_hash_to_str(MENU_ENUM_LABEL_VALUE_HISTORY_TAB));
|
|
m_historyPlaylistsItem->setData(Qt::UserRole, QString(settings->paths.path_content_history));
|
|
|
|
imagePlaylistsItem = new QListWidgetItem(m_folderIcon, msg_hash_to_str(MENU_ENUM_LABEL_VALUE_IMAGES_TAB));
|
|
imagePlaylistsItem->setData(Qt::UserRole, QString(settings->paths.path_content_image_history));
|
|
|
|
musicPlaylistsItem = new QListWidgetItem(m_folderIcon, msg_hash_to_str(MENU_ENUM_LABEL_VALUE_MUSIC_TAB));
|
|
musicPlaylistsItem->setData(Qt::UserRole, QString(settings->paths.path_content_music_history));
|
|
|
|
videoPlaylistsItem = new QListWidgetItem(m_folderIcon, msg_hash_to_str(MENU_ENUM_LABEL_VALUE_VIDEO_TAB));
|
|
videoPlaylistsItem->setData(Qt::UserRole, QString(settings->paths.path_content_video_history));
|
|
|
|
m_listWidget->addItem(allPlaylistsItem);
|
|
m_listWidget->addItem(favoritesPlaylistsItem);
|
|
m_listWidget->addItem(m_historyPlaylistsItem);
|
|
m_listWidget->addItem(imagePlaylistsItem);
|
|
m_listWidget->addItem(musicPlaylistsItem);
|
|
m_listWidget->addItem(videoPlaylistsItem);
|
|
|
|
if (qt_playlist_hidden(ALL_PLAYLISTS_TOKEN))
|
|
m_listWidget->setRowHidden(m_listWidget->row(allPlaylistsItem), true);
|
|
if (qt_playlist_hidden(QFileInfo(settings->paths.path_content_favorites).fileName()))
|
|
m_listWidget->setRowHidden(m_listWidget->row(favoritesPlaylistsItem), true);
|
|
if (qt_playlist_hidden(QFileInfo(settings->paths.path_content_history).fileName()))
|
|
m_listWidget->setRowHidden(m_listWidget->row(m_historyPlaylistsItem), true);
|
|
if (qt_playlist_hidden(QFileInfo(settings->paths.path_content_image_history).fileName()))
|
|
m_listWidget->setRowHidden(m_listWidget->row(imagePlaylistsItem), true);
|
|
if (qt_playlist_hidden(QFileInfo(settings->paths.path_content_music_history).fileName()))
|
|
m_listWidget->setRowHidden(m_listWidget->row(musicPlaylistsItem), true);
|
|
if (qt_playlist_hidden(QFileInfo(settings->paths.path_content_video_history).fileName()))
|
|
m_listWidget->setRowHidden(m_listWidget->row(videoPlaylistsItem), true);
|
|
|
|
for (i = 0; i < m_playlistFiles.count(); i++)
|
|
{
|
|
QIcon icon;
|
|
QString iconPath;
|
|
QListWidgetItem *item = NULL;
|
|
const QString &file = m_playlistFiles.at(i);
|
|
|
|
/* don't show view files */
|
|
if (file.endsWith(".lvw", Qt::CaseInsensitive))
|
|
continue;
|
|
|
|
QString fileDisplayName = file;
|
|
QString fileName = file;
|
|
bool hasIcon = false;
|
|
|
|
fileDisplayName.remove(".lpl");
|
|
|
|
iconPath = QString(
|
|
settings->paths.directory_assets)
|
|
+ ICON_PATH
|
|
+ fileDisplayName
|
|
+ ".png";
|
|
|
|
hasIcon = QFile::exists(iconPath);
|
|
|
|
if (hasIcon)
|
|
icon = QIcon(iconPath);
|
|
else
|
|
icon = m_folderIcon;
|
|
|
|
item = new QListWidgetItem(icon, fileDisplayName);
|
|
item->setFlags(item->flags() | Qt::ItemIsEditable);
|
|
item->setData(Qt::UserRole, playlistDir.absoluteFilePath(file));
|
|
|
|
m_listWidget->addItem(item);
|
|
|
|
if (qt_playlist_hidden(fileName))
|
|
{
|
|
int row = m_listWidget->row(item);
|
|
|
|
if (row >= 0)
|
|
m_listWidget->setRowHidden(row, true);
|
|
}
|
|
}
|
|
|
|
if (m_listWidget->count() > 0)
|
|
{
|
|
firstItem = m_listWidget->item(0);
|
|
|
|
if (firstItem)
|
|
{
|
|
bool foundCurrent = false;
|
|
bool foundInitial = false;
|
|
QString initialPlaylist =
|
|
string_is_empty(config_get_ptr()->paths.desktop_menu_initial_playlist)
|
|
? QString(ALL_PLAYLISTS_TOKEN)
|
|
: QString::fromUtf8(config_get_ptr()->paths.desktop_menu_initial_playlist);
|
|
QListWidgetItem *initialItem = NULL;
|
|
|
|
for (i = 0; i < m_listWidget->count(); i++)
|
|
{
|
|
QString path;
|
|
QListWidgetItem *item = m_listWidget->item(i);
|
|
|
|
if (item)
|
|
{
|
|
path = item->data(Qt::UserRole).toString();
|
|
|
|
if (!path.isEmpty())
|
|
{
|
|
/* don't break early here since we want
|
|
* to make sure we've found both initial
|
|
* and current items if they exist */
|
|
if (!foundInitial && path == initialPlaylist)
|
|
{
|
|
foundInitial = true;
|
|
initialItem = item;
|
|
}
|
|
if ( !foundCurrent
|
|
&& !currentPlaylistPath.isEmpty()
|
|
&& path == currentPlaylistPath)
|
|
{
|
|
foundCurrent = true;
|
|
m_listWidget->setCurrentItem(item);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!foundCurrent)
|
|
{
|
|
if (foundInitial && initialItem)
|
|
m_listWidget->setCurrentItem(initialItem);
|
|
else
|
|
{
|
|
/* the previous playlist must be gone now,
|
|
* just select the first one */
|
|
m_listWidget->setCurrentItem(firstItem);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
QString MainWindow::getCurrentPlaylistPath()
|
|
{
|
|
QString playlistPath;
|
|
QListWidgetItem *playlistItem = m_listWidget->currentItem();
|
|
|
|
if (!playlistItem)
|
|
return playlistPath;
|
|
|
|
playlistPath = playlistItem->data(Qt::UserRole).toString();
|
|
|
|
return playlistPath;
|
|
}
|
|
|
|
bool MainWindow::currentPlaylistIsSpecial()
|
|
{
|
|
QFileInfo currentPlaylistFileInfo;
|
|
QString currentPlaylistPath;
|
|
QString currentPlaylistDirPath;
|
|
settings_t *settings = config_get_ptr();
|
|
QDir playlistDir(settings->paths.directory_playlist);
|
|
QString playlistDirAbsPath = playlistDir.absolutePath();
|
|
QListWidgetItem *currentPlaylistItem = m_listWidget->currentItem();
|
|
|
|
if (!currentPlaylistItem)
|
|
return false;
|
|
|
|
currentPlaylistPath = currentPlaylistItem->data(Qt::UserRole).toString();
|
|
currentPlaylistFileInfo = QFileInfo(currentPlaylistPath);
|
|
currentPlaylistDirPath = currentPlaylistFileInfo.absoluteDir().absolutePath();
|
|
|
|
/* Don't just compare strings in case there are
|
|
* case differences on Windows that should be ignored. */
|
|
if (QDir(currentPlaylistDirPath) != QDir(playlistDirAbsPath))
|
|
return true;
|
|
return false;
|
|
}
|
|
|
|
bool MainWindow::currentPlaylistIsAll()
|
|
{
|
|
QListWidgetItem *currentPlaylistItem = m_listWidget->currentItem();
|
|
if (
|
|
currentPlaylistItem
|
|
&& currentPlaylistItem->data(Qt::UserRole).toString()
|
|
== ALL_PLAYLISTS_TOKEN)
|
|
return true;
|
|
return false;
|
|
}
|
|
|
|
void MainWindow::deleteCurrentPlaylistItem()
|
|
{
|
|
QByteArray playlistArray;
|
|
QString playlistPath = getCurrentPlaylistPath();
|
|
PlaylistEntry contentEntry = getCurrentContentEntry();
|
|
const char *playlistData = NULL;
|
|
bool isAllPlaylist = currentPlaylistIsAll();
|
|
|
|
if (isAllPlaylist)
|
|
return;
|
|
|
|
if (playlistPath.isEmpty())
|
|
return;
|
|
|
|
if (contentEntry.path.isEmpty())
|
|
return;
|
|
|
|
playlistArray = playlistPath.toUtf8();
|
|
playlistData = playlistArray.constData();
|
|
|
|
if (!showMessageBox(QString(msg_hash_to_str(MENU_ENUM_LABEL_VALUE_QT_CONFIRM_DELETE_PLAYLIST_ITEM)).arg(contentEntry.label), MainWindow::MSGBOX_TYPE_QUESTION_YESNO, Qt::ApplicationModal, false))
|
|
return;
|
|
|
|
companion_core_playlist_delete_entry(ui_companion_qt_core(),
|
|
playlistData, contentEntry.index);
|
|
|
|
reloadPlaylists();
|
|
}
|
|
|
|
QString MainWindow::getPlaylistDefaultCore(QString plName)
|
|
{
|
|
char core_path[PATH_MAX_LENGTH];
|
|
QByteArray plNameByteArray = plName.toUtf8();
|
|
|
|
if (companion_core_playlist_default_core(ui_companion_qt_core(),
|
|
plNameByteArray.constData(), core_path, sizeof(core_path)))
|
|
return QString::fromUtf8(core_path);
|
|
return QString();
|
|
}
|
|
|
|
void MainWindow::getPlaylistFiles()
|
|
{
|
|
settings_t *settings = config_get_ptr();
|
|
QDir playlistDir(settings->paths.directory_playlist);
|
|
|
|
m_playlistFiles = playlistDir.entryList(
|
|
QDir::NoDotAndDotDot | QDir::Readable | QDir::Files, QDir::Name);
|
|
}
|
|
|
|
/* Copy the companion core's currently loaded playlist into the pending
|
|
* contents. Everything is deep-copied into QStrings, so nothing here
|
|
* outlives the core's playlist object. */
|
|
void PlaylistModel::appendEntriesFromCore()
|
|
{
|
|
companion_core_t *core = ui_companion_qt_core();
|
|
const char *path = companion_core_selected_playlist_path(core);
|
|
const char *playlistName = NULL;
|
|
size_t playlistSize = companion_core_entry_count(core);
|
|
size_t i;
|
|
|
|
if (path && *path)
|
|
playlistName = path_basename(path);
|
|
|
|
for (i = 0; i < playlistSize; i++)
|
|
{
|
|
PlaylistEntry rowEntry;
|
|
const struct playlist_entry *pl_row = companion_core_entry(core, i);
|
|
|
|
if (!pl_row || !pl_row->path || !*pl_row->path)
|
|
continue;
|
|
|
|
rowEntry.path = pl_row->path;
|
|
rowEntry.index = (unsigned)i;
|
|
|
|
if (!pl_row->label || !*pl_row->label)
|
|
{
|
|
rowEntry.label = pl_row->path;
|
|
rowEntry.labelNoExt = pl_row->path;
|
|
}
|
|
else
|
|
{
|
|
rowEntry.label = pl_row->label;
|
|
rowEntry.labelNoExt = pl_row->label;
|
|
}
|
|
|
|
if (pl_row->core_path && *pl_row->core_path)
|
|
rowEntry.corePath = pl_row->core_path;
|
|
|
|
if (pl_row->core_name && *pl_row->core_name)
|
|
rowEntry.coreName = pl_row->core_name;
|
|
|
|
if (pl_row->crc32 && *pl_row->crc32)
|
|
rowEntry.crc32 = pl_row->crc32;
|
|
|
|
if (pl_row->db_name && *pl_row->db_name)
|
|
{
|
|
rowEntry.dbName = pl_row->db_name;
|
|
rowEntry.dbName.remove(".lpl");
|
|
}
|
|
|
|
if (playlistName && *playlistName)
|
|
{
|
|
rowEntry.plName = playlistName;
|
|
rowEntry.plName.remove(".lpl");
|
|
}
|
|
|
|
m_pendingContents.append(rowEntry);
|
|
}
|
|
}
|
|
|
|
void PlaylistModel::startNextPendingPlaylist()
|
|
{
|
|
while (!m_pendingPaths.isEmpty())
|
|
{
|
|
QByteArray pathArray = m_pendingPaths.takeFirst().toUtf8();
|
|
|
|
/* The parse is driven from the runloop by companion_core_iterate()
|
|
* under a time budget; onCorePlaylistChanged() fires when it is
|
|
* done. Nothing blocks here, however large the playlist. */
|
|
if (companion_core_select_playlist_path(ui_companion_qt_core(),
|
|
pathArray.constData()))
|
|
return;
|
|
/* Unreadable path: skip it and try the next one. */
|
|
}
|
|
|
|
/* All done: commit in a single model reset. */
|
|
beginResetModel();
|
|
m_contents = m_pendingContents;
|
|
m_pendingContents.clear();
|
|
m_loadingPlaylists = false;
|
|
endResetModel();
|
|
|
|
emit playlistsLoaded();
|
|
}
|
|
|
|
void PlaylistModel::onCorePlaylistChanged()
|
|
{
|
|
if (!m_loadingPlaylists)
|
|
return;
|
|
appendEntriesFromCore();
|
|
startNextPendingPlaylist();
|
|
}
|
|
|
|
bool PlaylistModel::isLoadingPlaylists() const
|
|
{
|
|
return m_loadingPlaylists;
|
|
}
|
|
|
|
void PlaylistModel::addPlaylistItems(const QStringList &paths, bool add)
|
|
{
|
|
if (paths.isEmpty())
|
|
return;
|
|
|
|
/* Restarting supersedes any load still in flight: the core aborts
|
|
* the pending parse when a new playlist is selected, and the
|
|
* partially collected entries are dropped. */
|
|
m_pendingPaths = paths;
|
|
m_pendingContents.clear();
|
|
m_loadingPlaylists = true;
|
|
|
|
startNextPendingPlaylist();
|
|
}
|
|
|
|
void PlaylistModel::addDir(QString path, QFlags<QDir::Filter> showHidden)
|
|
{
|
|
int i;
|
|
QDir dir = path;
|
|
QStringList dirList = dir.entryList(
|
|
QDir::NoDotAndDotDot
|
|
| QDir::Readable
|
|
| QDir::Files
|
|
| showHidden,
|
|
QDir::Name);
|
|
|
|
if (dirList.count() == 0)
|
|
return;
|
|
|
|
beginResetModel();
|
|
|
|
m_contents.clear();
|
|
|
|
for (i = 0; i < dirList.count(); i++)
|
|
{
|
|
PlaylistEntry rowEntry;
|
|
QString fileName = dirList.at(i);
|
|
QString filePath(
|
|
QDir::toNativeSeparators(dir.absoluteFilePath(fileName)));
|
|
QFileInfo fileInfo(filePath);
|
|
|
|
rowEntry.path = filePath;
|
|
rowEntry.label = filePath;
|
|
rowEntry.labelNoExt = fileInfo.completeBaseName();
|
|
rowEntry.dbName = fileInfo.dir().dirName();
|
|
|
|
m_contents.append(rowEntry);
|
|
}
|
|
|
|
endResetModel();
|
|
}
|
|
|
|
void MainWindow::setAllPlaylistsListMaxCount(int count)
|
|
{
|
|
if (count < 1)
|
|
count = 0;
|
|
m_allPlaylistsListMaxCount = count;
|
|
}
|
|
|
|
void MainWindow::setAllPlaylistsGridMaxCount(int count)
|
|
{
|
|
if (count < 1)
|
|
count = 0;
|
|
m_allPlaylistsGridMaxCount = count;
|
|
}
|