929 lines
24 KiB
C++
929 lines
24 KiB
C++
/***************************************************************************
|
|
* Copyright (c) 2004 Werner Mayer <wmayer[at]users.sourceforge.net> *
|
|
* *
|
|
* This file is part of the FreeCAD CAx development system. *
|
|
* *
|
|
* This library is free software; you can redistribute it and/or *
|
|
* modify it under the terms of the GNU Library General Public *
|
|
* License as published by the Free Software Foundation; either *
|
|
* version 2 of the License, or (at your option) any later version. *
|
|
* *
|
|
* This library is distributed in the hope that it will be useful, *
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
|
|
* GNU Library General Public License for more details. *
|
|
* *
|
|
* You should have received a copy of the GNU Library General Public *
|
|
* License along with this library; see the file COPYING.LIB. If not, *
|
|
* write to the Free Software Foundation, Inc., 59 Temple Place, *
|
|
* Suite 330, Boston, MA 02111-1307, USA *
|
|
* *
|
|
***************************************************************************/
|
|
|
|
|
|
#include <QContextMenuEvent>
|
|
#include <QMenu>
|
|
|
|
|
|
#include <cstring>
|
|
|
|
#include <Base/Console.h>
|
|
#include <Base/Tools.h>
|
|
#include <Base/Color.h>
|
|
|
|
#include "PrefWidgets.h"
|
|
|
|
|
|
using Base::Console;
|
|
using namespace Gui;
|
|
|
|
/** Constructs a preference widget.
|
|
*/
|
|
PrefWidget::PrefWidget()
|
|
: WindowParameter("")
|
|
{}
|
|
|
|
/**
|
|
* Destroys the widget and detaches it from its parameter group.
|
|
*/
|
|
PrefWidget::~PrefWidget()
|
|
{
|
|
if (getWindowParameter().isValid()) {
|
|
getWindowParameter()->Detach(this);
|
|
}
|
|
}
|
|
|
|
/** Sets the preference name to \a name. */
|
|
void PrefWidget::setEntryName(const QByteArray& name)
|
|
{
|
|
m_sPrefName = name;
|
|
}
|
|
|
|
/** Sets the preference name to \a name. */
|
|
void PrefWidget::setPrefEntry(const QByteArray& name)
|
|
{
|
|
setEntryName(name);
|
|
}
|
|
|
|
/** Returns the widget's preference name. */
|
|
QByteArray PrefWidget::entryName() const
|
|
{
|
|
return m_sPrefName;
|
|
}
|
|
|
|
/** Sets the preference path to \a path. */
|
|
void PrefWidget::setParamGrpPath(const QByteArray& path)
|
|
{
|
|
#ifdef FC_DEBUG
|
|
if (getWindowParameter().isValid()) {
|
|
if (paramGrpPath() != path) {
|
|
Base::Console().warning("Widget already attached\n");
|
|
}
|
|
}
|
|
#endif
|
|
|
|
if (paramGrpPath() != path) {
|
|
if (setGroupName(path)) {
|
|
m_sPrefGrp = path;
|
|
assert(getWindowParameter().isValid());
|
|
getWindowParameter()->Attach(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
/** Sets the preference path to \a path. */
|
|
void PrefWidget::setPrefPath(const QByteArray& name)
|
|
{
|
|
setParamGrpPath(name);
|
|
}
|
|
|
|
/** Returns the widget's preferences path. */
|
|
QByteArray PrefWidget::paramGrpPath() const
|
|
{
|
|
return m_sPrefGrp;
|
|
}
|
|
|
|
/**
|
|
* This method is called if one or more values in the parameter settings are changed
|
|
* where getParamGrp() points to.
|
|
* Note: This method is called for each parameter inside the parameter group. So
|
|
* you have to filter out the appropriate parameter with the name \a sReason.
|
|
* \a rCaller calls this method.
|
|
*/
|
|
void PrefWidget::OnChange(Base::Subject<const char*>& rCaller, const char* sReason)
|
|
{
|
|
Q_UNUSED(rCaller);
|
|
if (std::strcmp(sReason, m_sPrefName) == 0) {
|
|
restorePreferences();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Saves the current preferences of the widget.
|
|
* All preference widget attached to the same parameter group are notified.
|
|
*/
|
|
void PrefWidget::onSave()
|
|
{
|
|
savePreferences();
|
|
if (getWindowParameter().isValid()) {
|
|
getWindowParameter()->Notify(entryName());
|
|
}
|
|
#ifdef FC_DEBUG
|
|
else {
|
|
qFatal("No parameter group specified!");
|
|
}
|
|
#endif
|
|
}
|
|
|
|
/**
|
|
* Restores the preferences of the widget.
|
|
*/
|
|
void PrefWidget::onRestore()
|
|
{
|
|
#ifdef FC_DEBUG
|
|
if (getWindowParameter().isNull()) {
|
|
qWarning("No parameter group specified!");
|
|
}
|
|
#endif
|
|
restorePreferences();
|
|
m_Restored = true;
|
|
}
|
|
|
|
void PrefWidget::failedToSave(const QString& name) const
|
|
{
|
|
QByteArray objname = name.toLatin1();
|
|
if (objname.isEmpty()) {
|
|
objname = "Undefined";
|
|
}
|
|
Console().warning("Cannot save %s (%s)\n", typeid(*this).name(), objname.constData());
|
|
}
|
|
|
|
void PrefWidget::failedToRestore(const QString& name) const
|
|
{
|
|
QByteArray objname = name.toLatin1();
|
|
if (objname.isEmpty()) {
|
|
objname = "Undefined";
|
|
}
|
|
Console().warning("Cannot restore %s (%s)\n", typeid(*this).name(), objname.constData());
|
|
}
|
|
|
|
// --------------------------------------------------------------------
|
|
|
|
PrefSpinBox::PrefSpinBox(QWidget* parent)
|
|
: QSpinBox(parent)
|
|
, PrefWidget()
|
|
{
|
|
setFocusPolicy(Qt::FocusPolicy::StrongFocus);
|
|
}
|
|
|
|
void PrefSpinBox::wheelEvent(QWheelEvent* event)
|
|
{
|
|
if (hasFocus()) {
|
|
QSpinBox::wheelEvent(event);
|
|
}
|
|
else {
|
|
event->ignore();
|
|
}
|
|
}
|
|
|
|
PrefSpinBox::~PrefSpinBox() = default;
|
|
|
|
void PrefSpinBox::restorePreferences()
|
|
{
|
|
if (getWindowParameter().isNull()) {
|
|
failedToRestore(objectName());
|
|
return;
|
|
}
|
|
|
|
int nVal = getWindowParameter()->GetInt(entryName(), QSpinBox::value());
|
|
setValue(nVal);
|
|
}
|
|
|
|
void PrefSpinBox::savePreferences()
|
|
{
|
|
if (getWindowParameter().isNull()) {
|
|
failedToSave(objectName());
|
|
return;
|
|
}
|
|
|
|
getWindowParameter()->SetInt(entryName(), (int)value());
|
|
}
|
|
|
|
// --------------------------------------------------------------------
|
|
|
|
PrefDoubleSpinBox::PrefDoubleSpinBox(QWidget* parent)
|
|
: QDoubleSpinBox(parent)
|
|
, PrefWidget()
|
|
{
|
|
setFocusPolicy(Qt::FocusPolicy::StrongFocus);
|
|
}
|
|
|
|
void PrefDoubleSpinBox::wheelEvent(QWheelEvent* event)
|
|
{
|
|
if (hasFocus()) {
|
|
QDoubleSpinBox::wheelEvent(event);
|
|
}
|
|
else {
|
|
event->ignore();
|
|
}
|
|
}
|
|
|
|
PrefDoubleSpinBox::~PrefDoubleSpinBox() = default;
|
|
|
|
void PrefDoubleSpinBox::restorePreferences()
|
|
{
|
|
if (getWindowParameter().isNull()) {
|
|
failedToRestore(objectName());
|
|
return;
|
|
}
|
|
|
|
double fVal = (double)getWindowParameter()->GetFloat(entryName(), value());
|
|
setValue(fVal);
|
|
}
|
|
|
|
void PrefDoubleSpinBox::savePreferences()
|
|
{
|
|
if (getWindowParameter().isNull()) {
|
|
failedToSave(objectName());
|
|
return;
|
|
}
|
|
|
|
getWindowParameter()->SetFloat(entryName(), value());
|
|
}
|
|
|
|
// --------------------------------------------------------------------
|
|
|
|
PrefLineEdit::PrefLineEdit(QWidget* parent)
|
|
: QLineEdit(parent)
|
|
, PrefWidget()
|
|
{}
|
|
|
|
PrefLineEdit::~PrefLineEdit() = default;
|
|
|
|
void PrefLineEdit::restorePreferences()
|
|
{
|
|
if (getWindowParameter().isNull()) {
|
|
failedToRestore(objectName());
|
|
return;
|
|
}
|
|
|
|
QString text = this->text();
|
|
text = QString::fromUtf8(getWindowParameter()->GetASCII(entryName(), text.toUtf8()).c_str());
|
|
setText(text);
|
|
}
|
|
|
|
void PrefLineEdit::savePreferences()
|
|
{
|
|
if (getWindowParameter().isNull()) {
|
|
failedToSave(objectName());
|
|
return;
|
|
}
|
|
|
|
getWindowParameter()->SetASCII(entryName(), text().toUtf8());
|
|
}
|
|
|
|
// --------------------------------------------------------------------
|
|
|
|
PrefTextEdit::PrefTextEdit(QWidget* parent)
|
|
: QTextEdit(parent)
|
|
, PrefWidget()
|
|
{}
|
|
|
|
PrefTextEdit::~PrefTextEdit() = default;
|
|
|
|
void PrefTextEdit::restorePreferences()
|
|
{
|
|
if (getWindowParameter().isNull()) {
|
|
failedToRestore(objectName());
|
|
return;
|
|
}
|
|
|
|
QString text = this->toPlainText();
|
|
text = QString::fromUtf8(getWindowParameter()->GetASCII(entryName(), text.toUtf8()).c_str());
|
|
setText(text);
|
|
}
|
|
|
|
void PrefTextEdit::savePreferences()
|
|
{
|
|
if (getWindowParameter().isNull()) {
|
|
failedToSave(objectName());
|
|
return;
|
|
}
|
|
|
|
QString text = this->toPlainText();
|
|
getWindowParameter()->SetASCII(entryName(), text.toUtf8());
|
|
}
|
|
|
|
// --------------------------------------------------------------------
|
|
|
|
PrefFileChooser::PrefFileChooser(QWidget* parent)
|
|
: FileChooser(parent)
|
|
, PrefWidget()
|
|
{}
|
|
|
|
PrefFileChooser::~PrefFileChooser() = default;
|
|
|
|
void PrefFileChooser::restorePreferences()
|
|
{
|
|
if (getWindowParameter().isNull()) {
|
|
failedToRestore(objectName());
|
|
return;
|
|
}
|
|
|
|
QString txt = QString::fromUtf8(
|
|
getWindowParameter()->GetASCII(entryName(), fileName().toUtf8()).c_str()
|
|
);
|
|
setFileName(txt);
|
|
}
|
|
|
|
void PrefFileChooser::savePreferences()
|
|
{
|
|
if (getWindowParameter().isNull()) {
|
|
failedToSave(objectName());
|
|
return;
|
|
}
|
|
|
|
getWindowParameter()->SetASCII(entryName(), fileName().toUtf8());
|
|
}
|
|
|
|
// --------------------------------------------------------------------
|
|
|
|
PrefComboBox::PrefComboBox(QWidget* parent)
|
|
: QComboBox(parent)
|
|
, PrefWidget()
|
|
{
|
|
setFocusPolicy(Qt::FocusPolicy::StrongFocus);
|
|
}
|
|
|
|
void PrefComboBox::wheelEvent(QWheelEvent* event)
|
|
{
|
|
if (hasFocus()) {
|
|
QComboBox::wheelEvent(event);
|
|
}
|
|
else {
|
|
event->ignore();
|
|
}
|
|
}
|
|
|
|
PrefComboBox::~PrefComboBox() = default;
|
|
|
|
QMetaType::Type PrefComboBox::getParamType() const
|
|
{
|
|
return static_cast<QMetaType::Type>(property("prefType").userType());
|
|
}
|
|
|
|
void PrefComboBox::restorePreferences()
|
|
{
|
|
if (getWindowParameter().isNull()) {
|
|
failedToRestore(objectName());
|
|
return;
|
|
}
|
|
if (!m_Restored) {
|
|
m_Default = currentData();
|
|
m_DefaultText = currentText();
|
|
m_DefaultIndex = currentIndex();
|
|
}
|
|
int index = -1;
|
|
switch (static_cast<int>(getParamType())) {
|
|
case QMetaType::Int:
|
|
case QMetaType::LongLong:
|
|
index = findData(
|
|
static_cast<int>(getWindowParameter()->GetInt(entryName(), m_Default.toInt()))
|
|
);
|
|
break;
|
|
case QMetaType::UInt:
|
|
case QMetaType::ULongLong:
|
|
index = findData(
|
|
static_cast<uint>(getWindowParameter()->GetUnsigned(entryName(), m_Default.toUInt()))
|
|
);
|
|
break;
|
|
case QMetaType::Bool:
|
|
index = findData(getWindowParameter()->GetBool(entryName(), m_Default.toBool()));
|
|
break;
|
|
case QMetaType::Double:
|
|
index = findData(getWindowParameter()->GetFloat(entryName(), m_Default.toDouble()));
|
|
break;
|
|
case QMetaType::QString:
|
|
index = findText(
|
|
QString::fromUtf8(
|
|
getWindowParameter()->GetASCII(entryName(), m_DefaultText.toUtf8().constData()).c_str()
|
|
)
|
|
);
|
|
break;
|
|
case QMetaType::QByteArray:
|
|
index = findData(QByteArray(
|
|
getWindowParameter()->GetASCII(entryName(), m_Default.toByteArray().constData()).c_str()
|
|
));
|
|
break;
|
|
default:
|
|
index = getWindowParameter()->GetInt(entryName(), m_DefaultIndex);
|
|
break;
|
|
}
|
|
if (index >= 0 && index < count()) {
|
|
setCurrentIndex(index);
|
|
}
|
|
}
|
|
|
|
void PrefComboBox::savePreferences()
|
|
{
|
|
if (getWindowParameter().isNull()) {
|
|
failedToSave(objectName());
|
|
return;
|
|
}
|
|
|
|
switch (static_cast<int>(getParamType())) {
|
|
case QMetaType::Int:
|
|
case QMetaType::LongLong:
|
|
getWindowParameter()->SetInt(entryName(), currentData().toInt());
|
|
break;
|
|
case QMetaType::UInt:
|
|
case QMetaType::ULongLong:
|
|
getWindowParameter()->SetUnsigned(entryName(), currentData().toUInt());
|
|
break;
|
|
case QMetaType::Bool:
|
|
getWindowParameter()->SetBool(entryName(), currentData().toBool());
|
|
break;
|
|
case QMetaType::Double:
|
|
getWindowParameter()->SetFloat(entryName(), currentData().toDouble());
|
|
break;
|
|
case QMetaType::QString:
|
|
getWindowParameter()->SetASCII(entryName(), currentText().toUtf8().constData());
|
|
break;
|
|
case QMetaType::QByteArray:
|
|
getWindowParameter()->SetASCII(entryName(), currentData().toByteArray().constData());
|
|
break;
|
|
default:
|
|
getWindowParameter()->SetInt(entryName(), currentIndex());
|
|
break;
|
|
}
|
|
}
|
|
|
|
// --------------------------------------------------------------------
|
|
|
|
PrefCheckBox::PrefCheckBox(QWidget* parent)
|
|
: QCheckBox(parent)
|
|
, PrefWidget()
|
|
{}
|
|
|
|
PrefCheckBox::~PrefCheckBox() = default;
|
|
|
|
void PrefCheckBox::restorePreferences()
|
|
{
|
|
if (getWindowParameter().isNull()) {
|
|
failedToRestore(objectName());
|
|
return;
|
|
}
|
|
|
|
bool enable = getWindowParameter()->GetBool(entryName(), isChecked());
|
|
setChecked(enable);
|
|
}
|
|
|
|
void PrefCheckBox::savePreferences()
|
|
{
|
|
if (getWindowParameter().isNull()) {
|
|
failedToSave(objectName());
|
|
return;
|
|
}
|
|
|
|
getWindowParameter()->SetBool(entryName(), isChecked());
|
|
}
|
|
|
|
// --------------------------------------------------------------------
|
|
|
|
PrefRadioButton::PrefRadioButton(QWidget* parent)
|
|
: QRadioButton(parent)
|
|
, PrefWidget()
|
|
{}
|
|
|
|
PrefRadioButton::~PrefRadioButton() = default;
|
|
|
|
void PrefRadioButton::restorePreferences()
|
|
{
|
|
if (getWindowParameter().isNull()) {
|
|
failedToRestore(objectName());
|
|
return;
|
|
}
|
|
|
|
bool enable = getWindowParameter()->GetBool(entryName(), isChecked());
|
|
setChecked(enable);
|
|
}
|
|
|
|
void PrefRadioButton::savePreferences()
|
|
{
|
|
if (getWindowParameter().isNull()) {
|
|
failedToSave(objectName());
|
|
return;
|
|
}
|
|
|
|
getWindowParameter()->SetBool(entryName(), isChecked());
|
|
}
|
|
|
|
// --------------------------------------------------------------------
|
|
|
|
PrefSlider::PrefSlider(QWidget* parent)
|
|
: QSlider(parent)
|
|
, PrefWidget()
|
|
{}
|
|
|
|
PrefSlider::~PrefSlider() = default;
|
|
|
|
void PrefSlider::restorePreferences()
|
|
{
|
|
if (getWindowParameter().isNull()) {
|
|
failedToRestore(objectName());
|
|
return;
|
|
}
|
|
|
|
int nVal = getWindowParameter()->GetInt(entryName(), QSlider::value());
|
|
setValue(nVal);
|
|
}
|
|
|
|
void PrefSlider::savePreferences()
|
|
{
|
|
if (getWindowParameter().isNull()) {
|
|
failedToSave(objectName());
|
|
return;
|
|
}
|
|
|
|
getWindowParameter()->SetInt(entryName(), (int)value());
|
|
}
|
|
|
|
// --------------------------------------------------------------------
|
|
|
|
PrefColorButton::PrefColorButton(QWidget* parent)
|
|
: ColorButton(parent)
|
|
, PrefWidget()
|
|
{}
|
|
|
|
PrefColorButton::~PrefColorButton() = default;
|
|
|
|
void PrefColorButton::restorePreferences()
|
|
{
|
|
if (getWindowParameter().isNull()) {
|
|
failedToRestore(objectName());
|
|
return;
|
|
}
|
|
|
|
if (!m_Restored) {
|
|
m_Default = color();
|
|
}
|
|
|
|
unsigned int icol = Base::Color::asPackedRGBA<QColor>(m_Default);
|
|
|
|
unsigned long lcol = static_cast<unsigned long>(icol);
|
|
lcol = getWindowParameter()->GetUnsigned(entryName(), lcol);
|
|
icol = static_cast<unsigned int>(lcol);
|
|
QColor value = Base::Color::fromPackedRGBA<QColor>(icol);
|
|
if (!this->allowTransparency()) {
|
|
value.setAlpha(0xff);
|
|
}
|
|
setColor(value);
|
|
}
|
|
|
|
void PrefColorButton::savePreferences()
|
|
{
|
|
if (getWindowParameter().isNull()) {
|
|
failedToSave(objectName());
|
|
return;
|
|
}
|
|
|
|
QColor col = color();
|
|
// (r,g,b,a) with a = 255 (opaque)
|
|
unsigned int icol = Base::Color::asPackedRGBA<QColor>(col);
|
|
unsigned long lcol = static_cast<unsigned long>(icol);
|
|
getWindowParameter()->SetUnsigned(entryName(), lcol);
|
|
}
|
|
|
|
// --------------------------------------------------------------------
|
|
|
|
PrefUnitSpinBox::PrefUnitSpinBox(QWidget* parent)
|
|
: QuantitySpinBox(parent)
|
|
, PrefWidget()
|
|
{
|
|
setFocusPolicy(Qt::FocusPolicy::StrongFocus);
|
|
}
|
|
|
|
void PrefUnitSpinBox::wheelEvent(QWheelEvent* event)
|
|
{
|
|
if (hasFocus()) {
|
|
QuantitySpinBox::wheelEvent(event);
|
|
}
|
|
else {
|
|
event->ignore();
|
|
}
|
|
}
|
|
|
|
PrefUnitSpinBox::~PrefUnitSpinBox() = default;
|
|
|
|
void PrefUnitSpinBox::restorePreferences()
|
|
{
|
|
if (getWindowParameter().isNull()) {
|
|
failedToRestore(objectName());
|
|
return;
|
|
}
|
|
|
|
double fVal = (double)getWindowParameter()->GetFloat(entryName(), rawValue());
|
|
setValue(fVal);
|
|
}
|
|
|
|
void PrefUnitSpinBox::savePreferences()
|
|
{
|
|
if (getWindowParameter().isNull()) {
|
|
failedToSave(objectName());
|
|
return;
|
|
}
|
|
|
|
double q = rawValue();
|
|
getWindowParameter()->SetFloat(entryName(), q);
|
|
}
|
|
|
|
// --------------------------------------------------------------------
|
|
|
|
namespace Gui
|
|
{
|
|
class HistoryList
|
|
{
|
|
QStringList list;
|
|
int max_size = 5;
|
|
|
|
public:
|
|
const QStringList& asStringList() const
|
|
{
|
|
return list;
|
|
}
|
|
int maximumSize() const
|
|
{
|
|
return max_size;
|
|
}
|
|
void setMaximumSize(int num)
|
|
{
|
|
max_size = num;
|
|
while (list.size() > num) {
|
|
list.pop_front();
|
|
}
|
|
}
|
|
void clear()
|
|
{
|
|
list.clear();
|
|
}
|
|
void append(const QString& value)
|
|
{
|
|
if (!list.isEmpty() && list.back() == value) {
|
|
return;
|
|
}
|
|
const auto it = std::ranges::find(list, value);
|
|
if (it != list.end()) {
|
|
list.erase(it);
|
|
}
|
|
else if (list.size() == max_size) {
|
|
list.pop_front();
|
|
}
|
|
list.push_back(value);
|
|
}
|
|
};
|
|
|
|
class PrefQuantitySpinBoxPrivate
|
|
{
|
|
public:
|
|
HistoryList history;
|
|
bool isSaving = false;
|
|
|
|
QByteArray getHistoryGroupName(QByteArray name) const
|
|
{
|
|
return name + "_History";
|
|
}
|
|
|
|
void restoreHistory(ParameterGrp::handle hGrp)
|
|
{
|
|
std::vector<std::string> hist = hGrp->GetASCIIs("Hist");
|
|
for (const auto& it : hist) {
|
|
history.append(QString::fromStdString(it));
|
|
}
|
|
}
|
|
void clearHistory(ParameterGrp::handle hGrp)
|
|
{
|
|
std::vector<std::string> hist = hGrp->GetASCIIs("Hist");
|
|
for (const auto& it : hist) {
|
|
hGrp->RemoveASCII(it.c_str());
|
|
}
|
|
}
|
|
void saveHistory(ParameterGrp::handle hGrp)
|
|
{
|
|
clearHistory(hGrp);
|
|
|
|
const QStringList& list = history.asStringList();
|
|
for (int i = 0; i < list.size(); i++) {
|
|
QByteArray key("Hist");
|
|
key.append(QByteArray::number(i));
|
|
hGrp->SetASCII(key, list[i].toUtf8());
|
|
}
|
|
}
|
|
};
|
|
} // namespace Gui
|
|
|
|
PrefQuantitySpinBox::PrefQuantitySpinBox(QWidget* parent)
|
|
: QuantitySpinBox(parent)
|
|
, d_ptr(new PrefQuantitySpinBoxPrivate())
|
|
{
|
|
setFocusPolicy(Qt::FocusPolicy::StrongFocus);
|
|
}
|
|
|
|
PrefQuantitySpinBox::~PrefQuantitySpinBox() = default;
|
|
|
|
void PrefQuantitySpinBox::contextMenuEvent(QContextMenuEvent* event)
|
|
{
|
|
Q_D(PrefQuantitySpinBox);
|
|
|
|
QMenu* editMenu = lineEdit()->createStandardContextMenu();
|
|
editMenu->setTitle(tr("Edit"));
|
|
std::unique_ptr<QMenu> menu(new QMenu(QStringLiteral("PrefQuantitySpinBox")));
|
|
|
|
menu->addMenu(editMenu);
|
|
menu->addSeparator();
|
|
|
|
// data structure to remember actions for values
|
|
QStringList history = d->history.asStringList();
|
|
for (const auto& it : history) {
|
|
QAction* action = menu->addAction(it);
|
|
action->setProperty("history_value", it);
|
|
}
|
|
|
|
// add the save value portion of the menu
|
|
menu->addSeparator();
|
|
QAction* saveValueAction = menu->addAction(tr("Save Value"));
|
|
QAction* clearListAction = menu->addAction(tr("Clear List"));
|
|
clearListAction->setDisabled(history.empty());
|
|
|
|
// call the menu
|
|
QAction* userAction = menu->exec(event->globalPos());
|
|
|
|
// look what the user has chosen
|
|
if (userAction == saveValueAction) {
|
|
pushToHistory(this->text());
|
|
}
|
|
else if (userAction == clearListAction) {
|
|
d->history.clear();
|
|
}
|
|
else if (userAction) {
|
|
QVariant prop = userAction->property("history_value");
|
|
if (prop.isValid()) {
|
|
lineEdit()->setText(prop.toString());
|
|
}
|
|
}
|
|
}
|
|
|
|
void PrefQuantitySpinBox::wheelEvent(QWheelEvent* event)
|
|
{
|
|
if (hasFocus()) {
|
|
QuantitySpinBox::wheelEvent(event);
|
|
}
|
|
else {
|
|
event->ignore();
|
|
}
|
|
}
|
|
|
|
void PrefQuantitySpinBox::restorePreferences()
|
|
{
|
|
Q_D(PrefQuantitySpinBox);
|
|
|
|
// Do not restore values while saving them
|
|
if (d->isSaving) {
|
|
return;
|
|
}
|
|
|
|
if (getWindowParameter().isNull() || entryName().isEmpty()) {
|
|
failedToRestore(objectName());
|
|
return;
|
|
}
|
|
|
|
QString text = this->text();
|
|
text = QString::fromUtf8(getWindowParameter()->GetASCII(entryName(), text.toUtf8()).c_str());
|
|
lineEdit()->setText(text);
|
|
|
|
// Restore history
|
|
auto hGrp = getWindowParameter()->GetGroup(d->getHistoryGroupName(entryName()));
|
|
d->restoreHistory(hGrp);
|
|
}
|
|
|
|
void PrefQuantitySpinBox::savePreferences()
|
|
{
|
|
Q_D(PrefQuantitySpinBox);
|
|
if (getWindowParameter().isNull() || entryName().isEmpty()) {
|
|
failedToSave(objectName());
|
|
return;
|
|
}
|
|
|
|
getWindowParameter()->SetASCII(entryName(), text().toUtf8());
|
|
|
|
// Save history
|
|
auto hGrp = getWindowParameter()->GetGroup(d->getHistoryGroupName(entryName()));
|
|
d->saveHistory(hGrp);
|
|
}
|
|
|
|
void PrefQuantitySpinBox::pushToHistory(const QString& value)
|
|
{
|
|
Q_D(PrefQuantitySpinBox);
|
|
d->history.append(value.isEmpty() ? this->text() : value);
|
|
|
|
Base::StateLocker lock(d->isSaving);
|
|
onSave();
|
|
}
|
|
|
|
QStringList PrefQuantitySpinBox::getHistory() const
|
|
{
|
|
Q_D(const PrefQuantitySpinBox);
|
|
return d->history.asStringList();
|
|
}
|
|
|
|
void PrefQuantitySpinBox::setToLastUsedValue()
|
|
{
|
|
QStringList hist = getHistory();
|
|
if (!hist.empty()) {
|
|
lineEdit()->setText(hist.front());
|
|
}
|
|
}
|
|
|
|
int PrefQuantitySpinBox::historySize() const
|
|
{
|
|
Q_D(const PrefQuantitySpinBox);
|
|
return d->history.maximumSize();
|
|
}
|
|
|
|
void PrefQuantitySpinBox::setHistorySize(int i)
|
|
{
|
|
Q_D(PrefQuantitySpinBox);
|
|
d->history.setMaximumSize(i);
|
|
}
|
|
|
|
// --------------------------------------------------------------------
|
|
|
|
PrefFontBox::PrefFontBox(QWidget* parent)
|
|
: QFontComboBox(parent)
|
|
, PrefWidget()
|
|
{}
|
|
|
|
PrefFontBox::~PrefFontBox() = default;
|
|
|
|
void PrefFontBox::restorePreferences()
|
|
{
|
|
if (getWindowParameter().isNull()) {
|
|
failedToRestore(objectName());
|
|
return;
|
|
}
|
|
|
|
QFont currFont = currentFont(); // QFont from selector widget
|
|
QString currName = currFont.family();
|
|
|
|
std::string prefName
|
|
= getWindowParameter()->GetASCII(entryName(), currName.toUtf8()); // font name from cfg file
|
|
|
|
currFont.setFamily(QString::fromStdString(prefName));
|
|
setCurrentFont(currFont); // set selector widget to name from cfg file
|
|
}
|
|
|
|
void PrefFontBox::savePreferences()
|
|
{
|
|
if (getWindowParameter().isNull()) {
|
|
failedToSave(objectName());
|
|
return;
|
|
}
|
|
|
|
QFont currFont = currentFont();
|
|
QString currName = currFont.family();
|
|
getWindowParameter()->SetASCII(entryName(), currName.toUtf8());
|
|
}
|
|
|
|
// --------------------------------------------------------------------
|
|
|
|
PrefCheckableGroupBox::PrefCheckableGroupBox(QWidget* parent)
|
|
: QGroupBox(parent)
|
|
, PrefWidget()
|
|
{}
|
|
|
|
PrefCheckableGroupBox::~PrefCheckableGroupBox() = default;
|
|
|
|
void PrefCheckableGroupBox::restorePreferences()
|
|
{
|
|
if (getWindowParameter().isNull() || entryName().isEmpty()) {
|
|
failedToRestore(objectName());
|
|
return;
|
|
}
|
|
|
|
// Default value is the current state of the checkbox (usually from .ui on first load)
|
|
bool defaultValueInUi = isChecked();
|
|
bool actualValue = getWindowParameter()->GetBool(entryName(), defaultValueInUi);
|
|
setChecked(actualValue);
|
|
}
|
|
|
|
void PrefCheckableGroupBox::savePreferences()
|
|
{
|
|
if (getWindowParameter().isNull() || entryName().isEmpty()) {
|
|
failedToSave(objectName());
|
|
return;
|
|
}
|
|
|
|
getWindowParameter()->SetBool(entryName(), isChecked());
|
|
}
|
|
|
|
#include "moc_PrefWidgets.cpp"
|