734 lines
24 KiB
C++
734 lines
24 KiB
C++
// SPDX-License-Identifier: LGPL-2.1-or-later
|
|
|
|
/****************************************************************************
|
|
* Copyright (c) 2020 Chris Hennes (chennes@pioneerlibrarysystem.org) *
|
|
* Copyright (c) 2023 FreeCAD Project Association *
|
|
* *
|
|
* This file is part of FreeCAD. *
|
|
* *
|
|
* FreeCAD is free software: you can redistribute it and/or modify it *
|
|
* under the terms of the GNU Lesser General Public License as *
|
|
* published by the Free Software Foundation, either version 2.1 of the *
|
|
* License, or (at your option) any later version. *
|
|
* *
|
|
* FreeCAD 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 *
|
|
* Lesser General Public License for more details. *
|
|
* *
|
|
* You should have received a copy of the GNU Lesser General Public *
|
|
* License along with FreeCAD. If not, see *
|
|
* <https://www.gnu.org/licenses/>. *
|
|
* *
|
|
***************************************************************************/
|
|
|
|
#include <QAction>
|
|
#include <QCheckBox>
|
|
#include <QLabel>
|
|
#include <QMenu>
|
|
#include <QPushButton>
|
|
#include <sstream>
|
|
|
|
#include <Gui/Application.h>
|
|
#include <Gui/Workbench.h>
|
|
#include <Gui/WorkbenchManager.h>
|
|
|
|
#include "DlgSettingsWorkbenchesImp.h"
|
|
#include "ui_DlgSettingsWorkbenches.h"
|
|
|
|
|
|
using namespace Gui::Dialog;
|
|
|
|
namespace Gui::Dialog
|
|
{
|
|
class wbListItem: public QWidget
|
|
{
|
|
Q_OBJECT
|
|
|
|
public:
|
|
explicit wbListItem(
|
|
const QString& wbName,
|
|
bool enabled,
|
|
bool startupWb,
|
|
bool autoLoad,
|
|
int index,
|
|
QWidget* parent = nullptr
|
|
);
|
|
~wbListItem() override;
|
|
|
|
bool isEnabled();
|
|
bool isAutoLoading();
|
|
void setStartupWb(bool val);
|
|
|
|
void setShortcutLabel(int index);
|
|
|
|
protected Q_SLOTS:
|
|
void onLoadClicked();
|
|
void onWbToggled(bool checked);
|
|
|
|
Q_SIGNALS:
|
|
void wbToggled(const QString& wbName, bool enabled);
|
|
|
|
private:
|
|
QCheckBox* enableCheckBox;
|
|
QCheckBox* autoloadCheckBox;
|
|
QLabel* iconLabel;
|
|
QLabel* textLabel;
|
|
QLabel* shortcutLabel;
|
|
QLabel* loadLabel;
|
|
QPushButton* loadButton;
|
|
};
|
|
} // namespace Gui::Dialog
|
|
|
|
wbListItem::wbListItem(
|
|
const QString& wbName,
|
|
bool enabled,
|
|
bool startupWb,
|
|
bool autoLoad,
|
|
int index,
|
|
QWidget* parent
|
|
)
|
|
: QWidget(parent)
|
|
{
|
|
this->setObjectName(wbName);
|
|
|
|
auto wbTooltip = Application::Instance->workbenchToolTip(wbName);
|
|
auto wbDisplayName = Application::Instance->workbenchMenuText(wbName);
|
|
|
|
// 1: Enable checkbox
|
|
enableCheckBox = new QCheckBox(this);
|
|
enableCheckBox->setToolTip(
|
|
tr("Toggles the visibility of %1 in the available workbenches").arg(wbDisplayName)
|
|
);
|
|
enableCheckBox->setChecked(enabled);
|
|
if (startupWb) {
|
|
enableCheckBox->setChecked(true);
|
|
enableCheckBox->setEnabled(false);
|
|
enableCheckBox->setToolTip(tr("This is the current startup module, and must be enabled"));
|
|
}
|
|
connect(enableCheckBox, &QCheckBox::toggled, this, [this](bool checked) { onWbToggled(checked); });
|
|
|
|
QWidget* subWidget = new QWidget(this);
|
|
// 2: Workbench Icon
|
|
auto wbIcon = Application::Instance->workbenchIcon(wbName);
|
|
iconLabel = new QLabel(wbDisplayName, this);
|
|
iconLabel->setPixmap(wbIcon.scaled(
|
|
QSize(20, 20),
|
|
Qt::AspectRatioMode::KeepAspectRatio,
|
|
Qt::TransformationMode::SmoothTransformation
|
|
));
|
|
iconLabel->setToolTip(wbTooltip);
|
|
iconLabel->setContentsMargins(5, 0, 0, 5); // Left, top, right, bottom
|
|
iconLabel->setEnabled(enableCheckBox->isChecked());
|
|
|
|
// 3: Workbench Display Name
|
|
textLabel = new QLabel(wbDisplayName, this);
|
|
textLabel->setToolTip(wbTooltip);
|
|
QFont font = textLabel->font();
|
|
font.setBold(true);
|
|
textLabel->setFont(font);
|
|
textLabel->setEnabled(enableCheckBox->isChecked());
|
|
|
|
// 4: shortcut
|
|
shortcutLabel = new QLabel(QStringLiteral("(W, %1)").arg(index + 1), this);
|
|
shortcutLabel->setToolTip(tr("Shortcut to activate this workbench"));
|
|
shortcutLabel->setEnabled(enableCheckBox->isChecked());
|
|
shortcutLabel->setVisible(index < 9);
|
|
|
|
auto subLayout = new QHBoxLayout(subWidget);
|
|
subLayout->addWidget(iconLabel);
|
|
subLayout->addWidget(textLabel);
|
|
subLayout->addWidget(shortcutLabel);
|
|
subLayout->setAlignment(Qt::AlignLeft);
|
|
subLayout->setContentsMargins(5, 0, 0, 5);
|
|
subWidget->setMinimumSize(250, 0);
|
|
subWidget->setAttribute(Qt::WA_TranslucentBackground);
|
|
|
|
// 5: Autoloaded checkBox.
|
|
autoloadCheckBox = new QCheckBox(this);
|
|
autoloadCheckBox->setText(tr("Auto-load"));
|
|
autoloadCheckBox->setToolTip(tr("Loads %1 automatically when FreeCAD starts").arg(wbDisplayName));
|
|
autoloadCheckBox->setEnabled(enableCheckBox->isChecked());
|
|
|
|
if (startupWb) { // Figure out whether to check and/or disable this checkBox:
|
|
autoloadCheckBox->setChecked(true);
|
|
autoloadCheckBox->setEnabled(false);
|
|
autoloadCheckBox->setToolTip(tr("This is the current startup module, and must be autoloaded."));
|
|
}
|
|
else if (autoLoad) {
|
|
autoloadCheckBox->setChecked(true);
|
|
}
|
|
|
|
// 6: Load button/loaded indicator
|
|
loadLabel = new QLabel(tr("Loaded"), this);
|
|
loadLabel->setAlignment(Qt::AlignCenter);
|
|
loadLabel->setEnabled(enableCheckBox->isChecked());
|
|
loadButton = new QPushButton(tr("Load"), this);
|
|
loadButton->setToolTip(
|
|
tr("To preserve resources, FreeCAD does not load workbenches until they are used. Loading "
|
|
"them may provide access to additional preferences related to their functionality.")
|
|
);
|
|
loadButton->setEnabled(enableCheckBox->isChecked());
|
|
connect(loadButton, &QPushButton::clicked, this, [this]() { onLoadClicked(); });
|
|
if (WorkbenchManager::instance()->getWorkbench(wbName.toStdString())) {
|
|
loadButton->setVisible(false);
|
|
}
|
|
else {
|
|
loadLabel->setVisible(false);
|
|
}
|
|
|
|
auto layout = new QHBoxLayout(this);
|
|
layout->addWidget(enableCheckBox);
|
|
layout->addWidget(subWidget);
|
|
layout->addWidget(autoloadCheckBox);
|
|
layout->addWidget(loadButton);
|
|
layout->addWidget(loadLabel);
|
|
layout->setAlignment(Qt::AlignLeft);
|
|
layout->setContentsMargins(10, 0, 0, 0);
|
|
}
|
|
|
|
wbListItem::~wbListItem() = default;
|
|
|
|
bool wbListItem::isEnabled()
|
|
{
|
|
return enableCheckBox->isChecked();
|
|
}
|
|
|
|
bool wbListItem::isAutoLoading()
|
|
{
|
|
return autoloadCheckBox->isChecked();
|
|
}
|
|
|
|
void wbListItem::setStartupWb(bool val)
|
|
{
|
|
if (val) {
|
|
autoloadCheckBox->setChecked(true);
|
|
}
|
|
|
|
enableCheckBox->setEnabled(!val);
|
|
autoloadCheckBox->setEnabled(!val && textLabel->isEnabled());
|
|
}
|
|
|
|
void wbListItem::setShortcutLabel(int index)
|
|
{
|
|
shortcutLabel->setText(QStringLiteral("(W, %1)").arg(index + 1));
|
|
shortcutLabel->setVisible(index < 9);
|
|
}
|
|
|
|
void wbListItem::onLoadClicked()
|
|
{
|
|
// activate selected workbench
|
|
Workbench* originalActiveWB = WorkbenchManager::instance()->active();
|
|
Application::Instance->activateWorkbench(objectName().toStdString().c_str());
|
|
Application::Instance->activateWorkbench(originalActiveWB->name().c_str());
|
|
|
|
// replace load button with loaded indicator
|
|
loadButton->setVisible(false);
|
|
loadLabel->setVisible(true);
|
|
}
|
|
|
|
void wbListItem::onWbToggled(bool checked)
|
|
{
|
|
// activate/deactivate the widgets
|
|
iconLabel->setEnabled(checked);
|
|
textLabel->setEnabled(checked);
|
|
shortcutLabel->setEnabled(checked);
|
|
loadLabel->setEnabled(checked);
|
|
loadButton->setEnabled(checked);
|
|
autoloadCheckBox->setEnabled(checked);
|
|
|
|
// Reset the start combo items.
|
|
Q_EMIT wbToggled(objectName(), checked);
|
|
}
|
|
|
|
/* TRANSLATOR Gui::Dialog::DlgSettingsWorkbenchesImp */
|
|
|
|
/**
|
|
* Constructs a DlgSettingsWorkbenchesImp
|
|
*/
|
|
DlgSettingsWorkbenchesImp::DlgSettingsWorkbenchesImp(QWidget* parent)
|
|
: PreferencePage(parent)
|
|
, ui(new Ui_DlgSettingsWorkbenches)
|
|
{
|
|
ui->setupUi(this);
|
|
|
|
ui->wbList->setDragDropMode(QAbstractItemView::InternalMove);
|
|
ui->wbList->setSelectionMode(QAbstractItemView::SingleSelection);
|
|
ui->wbList->viewport()->setAcceptDrops(true);
|
|
ui->wbList->setDropIndicatorShown(true);
|
|
ui->wbList->setDragEnabled(true);
|
|
ui->wbList->setDefaultDropAction(Qt::MoveAction);
|
|
|
|
QAction* sortAction = new QAction(tr("Sort Alphabetically"), this);
|
|
connect(sortAction, &QAction::triggered, this, &DlgSettingsWorkbenchesImp::sortEnabledWorkbenches);
|
|
|
|
QMenu* contextMenu = new QMenu(ui->wbList);
|
|
contextMenu->addAction(sortAction);
|
|
ui->wbList->setContextMenuPolicy(Qt::CustomContextMenu);
|
|
connect(
|
|
ui->wbList,
|
|
&QListWidget::customContextMenuRequested,
|
|
this,
|
|
[this, contextMenu](const QPoint& pos) { contextMenu->exec(ui->wbList->mapToGlobal(pos)); }
|
|
);
|
|
|
|
connect(
|
|
ui->wbList->model(),
|
|
&QAbstractItemModel::rowsMoved,
|
|
this,
|
|
&DlgSettingsWorkbenchesImp::wbItemMoved
|
|
);
|
|
connect(
|
|
ui->AutoloadModuleCombo,
|
|
qOverload<int>(&QComboBox::activated),
|
|
this,
|
|
&DlgSettingsWorkbenchesImp::onStartWbChanged
|
|
);
|
|
connect(ui->CheckBox_WbByTab, &QCheckBox::toggled, this, &DlgSettingsWorkbenchesImp::onWbByTabToggled);
|
|
}
|
|
|
|
/**
|
|
* Destroys the object and frees any allocated resources
|
|
*/
|
|
DlgSettingsWorkbenchesImp::~DlgSettingsWorkbenchesImp() = default;
|
|
|
|
void DlgSettingsWorkbenchesImp::saveSettings()
|
|
{
|
|
std::ostringstream orderedStr, disabledStr, autoloadStr;
|
|
|
|
auto addStrToOss = [](std::string wbName, std::ostringstream& oss) {
|
|
if (oss.str().find(wbName) == std::string::npos) {
|
|
if (!oss.str().empty()) {
|
|
oss << ",";
|
|
}
|
|
oss << wbName;
|
|
}
|
|
};
|
|
|
|
for (int i = 0; i < ui->wbList->count(); i++) {
|
|
wbListItem* wbItem = qobject_cast<wbListItem*>(ui->wbList->itemWidget(ui->wbList->item(i)));
|
|
if (!wbItem) {
|
|
continue;
|
|
}
|
|
std::string wbName = wbItem->objectName().toStdString();
|
|
|
|
if (wbItem->isEnabled()) {
|
|
addStrToOss(wbName, orderedStr);
|
|
}
|
|
else {
|
|
addStrToOss(wbName, disabledStr);
|
|
}
|
|
|
|
if (wbItem->isAutoLoading()) {
|
|
addStrToOss(wbName, autoloadStr);
|
|
}
|
|
}
|
|
|
|
if (orderedStr.str().empty()) { // make sure that we have at least one enabled workbench. This
|
|
// should not be necessary because startup wb cannot be disabled.
|
|
orderedStr << "NoneWorkbench";
|
|
}
|
|
else {
|
|
if (!disabledStr.str().empty()) {
|
|
disabledStr << ",";
|
|
}
|
|
disabledStr << "NoneWorkbench";
|
|
}
|
|
|
|
|
|
ParameterGrp::handle hGrp = App::GetApplication().GetParameterGroupByPath(
|
|
"User parameter:BaseApp/Preferences/Workbenches"
|
|
);
|
|
hGrp->SetASCII("Ordered", orderedStr.str().c_str());
|
|
hGrp->SetASCII("Disabled", disabledStr.str().c_str());
|
|
|
|
// Update the list of workbenches in the WorkbenchGroup and in the WorkbenchComboBox & workbench
|
|
// QMenu
|
|
Application::Instance->signalRefreshWorkbenches();
|
|
|
|
App::GetApplication()
|
|
.GetParameterGroupByPath("User parameter:BaseApp/Preferences/General")
|
|
->SetASCII("BackgroundAutoloadModules", autoloadStr.str().c_str());
|
|
|
|
saveWorkbenchSelector();
|
|
|
|
int index = ui->AutoloadModuleCombo->currentIndex();
|
|
QVariant data = ui->AutoloadModuleCombo->itemData(index);
|
|
QString startWbName = data.toString();
|
|
App::GetApplication()
|
|
.GetParameterGroupByPath("User parameter:BaseApp/Preferences/General")
|
|
->SetASCII("AutoloadModule", startWbName.toLatin1());
|
|
|
|
ui->CheckBox_WbByTab->onSave();
|
|
}
|
|
|
|
void DlgSettingsWorkbenchesImp::loadSettings()
|
|
{
|
|
loadWorkbenchSelector();
|
|
|
|
// There are two different "autoload" settings: the first, in FreeCAD since 2004,
|
|
// controls the module the user sees first when starting FreeCAD, and defaults to the Start workbench
|
|
std::string start = App::Application::Config()["StartWorkbench"];
|
|
_startupModule = App::GetApplication()
|
|
.GetParameterGroupByPath("User parameter:BaseApp/Preferences/General")
|
|
->GetASCII("AutoloadModule", start.c_str());
|
|
|
|
// The second autoload setting does a background autoload of any number of other modules
|
|
std::string autoloadCSV = App::GetApplication()
|
|
.GetParameterGroupByPath("User parameter:BaseApp/Preferences/General")
|
|
->GetASCII("BackgroundAutoloadModules", "");
|
|
|
|
// Tokenize the comma-separated list
|
|
_backgroundAutoloadedModules.clear();
|
|
std::stringstream stream(autoloadCSV);
|
|
std::string workbench;
|
|
while (std::getline(stream, workbench, ',')) {
|
|
_backgroundAutoloadedModules.push_back(workbench);
|
|
}
|
|
|
|
buildWorkbenchList();
|
|
|
|
// We set the startup setting after building the list so that we can put only the enabled wb.
|
|
setStartWorkbenchComboItems();
|
|
|
|
{
|
|
QSignalBlocker sigblk(ui->CheckBox_WbByTab);
|
|
ui->CheckBox_WbByTab->onRestore();
|
|
}
|
|
}
|
|
|
|
void DlgSettingsWorkbenchesImp::resetSettingsToDefaults()
|
|
{
|
|
ParameterGrp::handle hGrp;
|
|
hGrp = App::GetApplication().GetParameterGroupByPath(
|
|
"User parameter:BaseApp/Preferences/Workbenches"
|
|
);
|
|
hGrp->RemoveASCII("Ordered");
|
|
hGrp->RemoveASCII("Disabled");
|
|
hGrp->RemoveASCII("WorkbenchSelectorType");
|
|
hGrp->RemoveASCII("WorkbenchSelectorItem");
|
|
|
|
hGrp = App::GetApplication().GetParameterGroupByPath("User parameter:BaseApp/Preferences/General");
|
|
hGrp->RemoveASCII("BackgroundAutoloadModules");
|
|
hGrp->RemoveASCII("AutoloadModule");
|
|
|
|
hGrp = App::GetApplication().GetParameterGroupByPath(
|
|
"User parameter:BaseApp/Preferences/MainWindow"
|
|
);
|
|
hGrp->RemoveASCII("WSPosition");
|
|
|
|
// finally reset all the parameters associated to Gui::Pref* widgets
|
|
PreferencePage::resetSettingsToDefaults();
|
|
|
|
hGrp = App::GetApplication().GetParameterGroupByPath("User parameter:BaseApp/Preferences/View");
|
|
if (ui->CheckBox_WbByTab->isChecked() != hGrp->GetBool("SaveWBbyTab", 0)) {
|
|
requireRestart();
|
|
}
|
|
}
|
|
|
|
/**
|
|
Build the list of unloaded workbenches.
|
|
*/
|
|
void DlgSettingsWorkbenchesImp::buildWorkbenchList()
|
|
{
|
|
QSignalBlocker sigblk(ui->wbList);
|
|
|
|
ui->wbList->clear();
|
|
|
|
QStringList enabledWbs = getEnabledWorkbenches();
|
|
QStringList disabledWbs = getDisabledWorkbenches();
|
|
|
|
// First we add the enabled wbs in their saved order.
|
|
for (const auto& wbName : enabledWbs) {
|
|
addWorkbench(wbName, true);
|
|
}
|
|
// Second we add workbenches that are disabled in alphabetical order.
|
|
for (const auto& wbName : disabledWbs) {
|
|
if (wbName.toStdString() != "NoneWorkbench") {
|
|
addWorkbench(wbName, false);
|
|
}
|
|
}
|
|
}
|
|
|
|
void DlgSettingsWorkbenchesImp::addWorkbench(const QString& wbName, bool enabled)
|
|
{
|
|
const bool isStartupWb = wbName.toStdString() == _startupModule;
|
|
const bool autoLoad = std::ranges::find(_backgroundAutoloadedModules, wbName.toStdString())
|
|
!= _backgroundAutoloadedModules.end();
|
|
const auto widget
|
|
= new wbListItem(wbName, enabled, isStartupWb, autoLoad, ui->wbList->count(), this);
|
|
connect(widget, &wbListItem::wbToggled, this, &DlgSettingsWorkbenchesImp::wbToggled);
|
|
const auto wItem = new QListWidgetItem();
|
|
wItem->setSizeHint(widget->sizeHint());
|
|
ui->wbList->addItem(wItem);
|
|
ui->wbList->setItemWidget(wItem, widget);
|
|
}
|
|
|
|
QStringList DlgSettingsWorkbenchesImp::getEnabledWorkbenches()
|
|
{
|
|
QStringList disabled_wbs_list = getDisabledWorkbenches();
|
|
QStringList enabled_wbs_list;
|
|
QStringList wbs_ordered_list;
|
|
QString wbs_ordered;
|
|
ParameterGrp::handle hGrp;
|
|
|
|
hGrp = App::GetApplication().GetParameterGroupByPath(
|
|
"User parameter:BaseApp/Preferences/Workbenches"
|
|
);
|
|
wbs_ordered = QString::fromStdString(hGrp->GetASCII("Ordered", ""));
|
|
|
|
wbs_ordered_list = wbs_ordered.split(QLatin1String(","), Qt::SkipEmptyParts);
|
|
|
|
QStringList workbenches = Application::Instance->workbenches();
|
|
workbenches.sort();
|
|
|
|
// First we add the wb that are ordered.
|
|
for (auto& wbName : wbs_ordered_list) {
|
|
if (workbenches.contains(wbName)
|
|
&& !disabled_wbs_list.contains(wbName)) { // Some wb may have been removed
|
|
enabled_wbs_list.append(wbName);
|
|
}
|
|
else {
|
|
Base::Console().log(
|
|
"Ignoring unknown %s workbench found in user preferences.\n",
|
|
wbName.toStdString().c_str()
|
|
);
|
|
}
|
|
}
|
|
|
|
// Then we add the wbs that are not ordered and not disabled in alphabetical order
|
|
for (auto& wbName : workbenches) {
|
|
if (!enabled_wbs_list.contains(wbName) && !disabled_wbs_list.contains(wbName)) {
|
|
enabled_wbs_list.append(wbName);
|
|
}
|
|
}
|
|
|
|
return enabled_wbs_list;
|
|
}
|
|
|
|
QStringList DlgSettingsWorkbenchesImp::getDisabledWorkbenches()
|
|
{
|
|
QString disabled_wbs;
|
|
QStringList unfiltered_disabled_wbs_list;
|
|
QStringList disabled_wbs_list;
|
|
ParameterGrp::handle hGrp;
|
|
|
|
hGrp = App::GetApplication().GetParameterGroupByPath(
|
|
"User parameter:BaseApp/Preferences/Workbenches"
|
|
);
|
|
disabled_wbs = QString::fromStdString(hGrp->GetASCII(
|
|
"Disabled",
|
|
"NoneWorkbench,TestWorkbench,InspectionWorkbench,RobotWorkbench,OpenSCADWorkbench"
|
|
));
|
|
|
|
unfiltered_disabled_wbs_list = disabled_wbs.split(QLatin1String(","), Qt::SkipEmptyParts);
|
|
|
|
QStringList workbenches = Application::Instance->workbenches();
|
|
|
|
for (auto& wbName : unfiltered_disabled_wbs_list) {
|
|
if (workbenches.contains(wbName)) { // Some wb may have been removed
|
|
disabled_wbs_list.append(wbName);
|
|
}
|
|
else {
|
|
Base::Console().log(
|
|
"Ignoring unknown %s workbench found in user preferences.\n",
|
|
wbName.toStdString().c_str()
|
|
);
|
|
}
|
|
}
|
|
|
|
disabled_wbs_list.sort();
|
|
|
|
return disabled_wbs_list;
|
|
}
|
|
|
|
/**
|
|
* Sets the strings of the subwidgets using the current language.
|
|
*/
|
|
void DlgSettingsWorkbenchesImp::changeEvent(QEvent* e)
|
|
{
|
|
if (e->type() == QEvent::LanguageChange) {
|
|
ui->retranslateUi(this);
|
|
translateWorkbenchSelector();
|
|
}
|
|
else {
|
|
QWidget::changeEvent(e);
|
|
}
|
|
}
|
|
|
|
void DlgSettingsWorkbenchesImp::saveWorkbenchSelector()
|
|
{
|
|
// save workbench selector type
|
|
ParameterGrp::handle hGrp;
|
|
hGrp = App::GetApplication().GetParameterGroupByPath(
|
|
"User parameter:BaseApp/Preferences/Workbenches"
|
|
);
|
|
int prevIndex = hGrp->GetInt("WorkbenchSelectorType", 0);
|
|
int index = ui->WorkbenchSelectorType->currentIndex();
|
|
if (prevIndex != index) {
|
|
hGrp->SetInt("WorkbenchSelectorType", index);
|
|
requireRestart();
|
|
}
|
|
|
|
// save workbench selector items style
|
|
prevIndex = hGrp->GetInt("WorkbenchSelectorItem", 0);
|
|
index = ui->WorkbenchSelectorItem->currentIndex();
|
|
if (prevIndex != index) {
|
|
hGrp->SetInt("WorkbenchSelectorItem", index);
|
|
requireRestart();
|
|
}
|
|
}
|
|
|
|
void DlgSettingsWorkbenchesImp::loadWorkbenchSelector()
|
|
{
|
|
// workbench selector type setup
|
|
ParameterGrp::handle hGrp;
|
|
hGrp = App::GetApplication().GetParameterGroupByPath(
|
|
"User parameter:BaseApp/Preferences/Workbenches"
|
|
);
|
|
int widgetTypeIndex = hGrp->GetInt("WorkbenchSelectorType", 0);
|
|
ui->WorkbenchSelectorType->clear();
|
|
ui->WorkbenchSelectorType->addItem(tr("ComboBox"));
|
|
ui->WorkbenchSelectorType->addItem(tr("TabBar"));
|
|
ui->WorkbenchSelectorType->setCurrentIndex(widgetTypeIndex);
|
|
|
|
// workbench selector items style
|
|
int itemStyleIndex = hGrp->GetInt("WorkbenchSelectorItem", 0);
|
|
ui->WorkbenchSelectorItem->clear();
|
|
ui->WorkbenchSelectorItem->addItem(tr("Icon and text"));
|
|
ui->WorkbenchSelectorItem->addItem(tr("Icon"));
|
|
ui->WorkbenchSelectorItem->addItem(tr("Text"));
|
|
ui->WorkbenchSelectorItem->setCurrentIndex(itemStyleIndex);
|
|
}
|
|
|
|
void DlgSettingsWorkbenchesImp::translateWorkbenchSelector()
|
|
{
|
|
ui->WorkbenchSelectorType->setItemText(0, tr("ComboBox"));
|
|
ui->WorkbenchSelectorType->setItemText(1, tr("TabBar"));
|
|
|
|
ui->WorkbenchSelectorItem->setItemText(0, tr("Icon and text"));
|
|
ui->WorkbenchSelectorItem->setItemText(1, tr("Icon"));
|
|
ui->WorkbenchSelectorItem->setItemText(2, tr("Text"));
|
|
}
|
|
|
|
void DlgSettingsWorkbenchesImp::wbToggled(const QString& wbName, bool enabled)
|
|
{
|
|
setStartWorkbenchComboItems();
|
|
|
|
// reorder the list of items.
|
|
int wbIndex = 0;
|
|
for (int i = 0; i < ui->wbList->count(); i++) {
|
|
wbListItem* wbItem = qobject_cast<wbListItem*>(ui->wbList->itemWidget(ui->wbList->item(i)));
|
|
if (wbItem && wbItem->objectName() == wbName) {
|
|
wbIndex = i;
|
|
}
|
|
}
|
|
|
|
int destinationIndex = ui->wbList->count();
|
|
|
|
for (int i = 0; i < ui->wbList->count(); i++) {
|
|
wbListItem* wbItem = qobject_cast<wbListItem*>(ui->wbList->itemWidget(ui->wbList->item(i)));
|
|
if (wbItem && !wbItem->isEnabled()
|
|
&& (enabled || ((wbItem->objectName()).toStdString() > wbName.toStdString()))) {
|
|
// If the wb was enabled, then it was in the disabled wbs. So it moves to the row of the
|
|
// currently first disabled wb If the wb was disabled. Then it goes to the disabled wb
|
|
// where it belongs alphabetically.
|
|
destinationIndex = i;
|
|
break;
|
|
}
|
|
}
|
|
ui->wbList->model()->moveRow(QModelIndex(), wbIndex, QModelIndex(), destinationIndex);
|
|
}
|
|
|
|
void DlgSettingsWorkbenchesImp::setStartWorkbenchComboItems()
|
|
{
|
|
ui->AutoloadModuleCombo->clear();
|
|
|
|
// fills the combo box with activated workbenches.
|
|
QStringList enabledWbs;
|
|
for (int i = 0; i < ui->wbList->count(); i++) {
|
|
wbListItem* wbItem = qobject_cast<wbListItem*>(ui->wbList->itemWidget(ui->wbList->item(i)));
|
|
if (wbItem && wbItem->isEnabled()) {
|
|
enabledWbs << wbItem->objectName();
|
|
}
|
|
}
|
|
|
|
QMap<QString, QString> menuText;
|
|
for (const auto& it : enabledWbs) {
|
|
QString text = Application::Instance->workbenchMenuText(it);
|
|
menuText[text] = it;
|
|
}
|
|
|
|
{ // add special workbench to selection
|
|
QPixmap px = Application::Instance->workbenchIcon(QStringLiteral("NoneWorkbench"));
|
|
QString key = QStringLiteral("<last>");
|
|
QString value = QStringLiteral("$LastModule");
|
|
if (px.isNull()) {
|
|
ui->AutoloadModuleCombo->addItem(key, QVariant(value));
|
|
}
|
|
else {
|
|
ui->AutoloadModuleCombo->addItem(px, key, QVariant(value));
|
|
}
|
|
}
|
|
|
|
for (QMap<QString, QString>::Iterator it = menuText.begin(); it != menuText.end(); ++it) {
|
|
QPixmap px = Application::Instance->workbenchIcon(it.value());
|
|
if (px.isNull()) {
|
|
ui->AutoloadModuleCombo->addItem(it.key(), QVariant(it.value()));
|
|
}
|
|
else {
|
|
ui->AutoloadModuleCombo->addItem(px, it.key(), QVariant(it.value()));
|
|
}
|
|
}
|
|
|
|
ui->AutoloadModuleCombo->setCurrentIndex(
|
|
ui->AutoloadModuleCombo->findData(QString::fromStdString(_startupModule))
|
|
);
|
|
}
|
|
|
|
void DlgSettingsWorkbenchesImp::wbItemMoved()
|
|
{
|
|
for (int i = 0; i < ui->wbList->count(); i++) {
|
|
wbListItem* wbItem = qobject_cast<wbListItem*>(ui->wbList->itemWidget(ui->wbList->item(i)));
|
|
if (wbItem) {
|
|
wbItem->setShortcutLabel(i);
|
|
}
|
|
}
|
|
}
|
|
|
|
void DlgSettingsWorkbenchesImp::onStartWbChanged(int index)
|
|
{
|
|
// Update _startupModule
|
|
QVariant data = ui->AutoloadModuleCombo->itemData(index);
|
|
QString wbName = data.toString();
|
|
_startupModule = wbName.toStdString();
|
|
|
|
// Change wb that user can't deactivate.
|
|
for (int i = 0; i < ui->wbList->count(); i++) {
|
|
wbListItem* wbItem = qobject_cast<wbListItem*>(ui->wbList->itemWidget(ui->wbList->item(i)));
|
|
if (wbItem) {
|
|
wbItem->setStartupWb(wbItem->objectName() == wbName);
|
|
}
|
|
}
|
|
}
|
|
|
|
void DlgSettingsWorkbenchesImp::onWbByTabToggled(bool val)
|
|
{
|
|
Q_UNUSED(val);
|
|
requireRestart();
|
|
}
|
|
|
|
void DlgSettingsWorkbenchesImp::sortEnabledWorkbenches()
|
|
{
|
|
ParameterGrp::handle hGrp;
|
|
|
|
hGrp = App::GetApplication().GetParameterGroupByPath(
|
|
"User parameter:BaseApp/Preferences/Workbenches"
|
|
);
|
|
hGrp->SetASCII("Ordered", "");
|
|
|
|
buildWorkbenchList();
|
|
}
|
|
#include "moc_DlgSettingsWorkbenchesImp.cpp"
|
|
#include "DlgSettingsWorkbenchesImp.moc"
|