electron-rare/FreeCAD
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
9fc77099697bcb7e4c62d4930581fc788afa4791
FreeCAD/src/Gui/TaskView/TaskView.cpp
T
theo-vt f4665aa7b5 Core: support multiple active transactions
2026-03-14 12:15:46 -04:00

1066 lines
35 KiB
C++
Raw Blame History

// SPDX-License-Identifier: LGPL-2.1-or-later
/***************************************************************************
* Copyright (c) 2009 Jürgen Riegel <juergen.riegel@web.de> *
* *
* 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 <QAbstractSpinBox>
#include <QActionEvent>
#include <QApplication>
#include <QCursor>
#include <QDockWidget>
#include <QLineEdit>
#include <QPointer>
#include <QPushButton>
#include <QTimer>
#include <QVBoxLayout>
#include <FCConfig.h>
#include <App/Document.h>
#include <Gui/ActionFunction.h>
#include <Gui/Application.h>
#include <Gui/Document.h>
#include <Gui/MainWindow.h>
#include <Gui/ViewProviderDocumentObject.h>
#include <Gui/OverlayManager.h>
#include "TaskView.h"
#include "TaskDialog.h"
#include "TaskEditControl.h"
#include <Gui/Control.h>
#include <Gui/QSint/actionpanel/taskgroup_p.h>
#include <Gui/QSint/actionpanel/taskheader_p.h>
#include <Gui/QSint/actionpanel/actionpanelscheme.h>
using namespace Gui::TaskView;
namespace sp = std::placeholders;
//**************************************************************************
//**************************************************************************
// TaskWidget
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
TaskWidget::TaskWidget(QWidget* parent)
: QWidget(parent)
{}
TaskWidget::~TaskWidget() = default;
//**************************************************************************
//**************************************************************************
// TaskGroup
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
TaskGroup::TaskGroup(QWidget* parent)
: QSint::ActionBox(parent)
{}
TaskGroup::TaskGroup(const QString& headerText, QWidget* parent)
: QSint::ActionBox(headerText, parent)
{}
TaskGroup::TaskGroup(const QPixmap& icon, const QString& headerText, QWidget* parent)
: QSint::ActionBox(icon, headerText, parent)
{}
TaskGroup::~TaskGroup() = default;
void TaskGroup::actionEvent(QActionEvent* e)
{
QAction* action = e->action();
switch (e->type()) {
case QEvent::ActionAdded: {
this->createItem(action);
break;
}
case QEvent::ActionChanged: {
break;
}
case QEvent::ActionRemoved: {
// cannot change anything
break;
}
default:
break;
}
}
//**************************************************************************
//**************************************************************************
// TaskBox
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
TaskBox::TaskBox(QWidget* parent)
: QSint::ActionGroup(parent)
, wasShown(false)
{
// override vertical size policy because otherwise task dialogs
// whose needsFullSpace() returns true won't take full space.
myGroup->setSizePolicy(QSizePolicy::Preferred, QSizePolicy::Preferred);
}
TaskBox::TaskBox(const QString& title, bool expandable, QWidget* parent)
: QSint::ActionGroup(title, expandable, parent)
, wasShown(false)
{
// override vertical size policy because otherwise task dialogs
// whose needsFullSpace() returns true won't take full space.
myGroup->setSizePolicy(QSizePolicy::Preferred, QSizePolicy::Preferred);
}
TaskBox::TaskBox(const QPixmap& icon, const QString& title, bool expandable, QWidget* parent)
: QSint::ActionGroup(icon, title, expandable, parent)
, wasShown(false)
{
// override vertical size policy because otherwise task dialogs
// whose needsFullSpace() returns true won't take full space.
myGroup->setSizePolicy(QSizePolicy::Preferred, QSizePolicy::Preferred);
}
QSize TaskBox::minimumSizeHint() const
{
// ActionGroup returns a size of 200x100 which leads to problems
// when there are several task groups in a panel and the first
// one is collapsed. In this case the task panel doesn't expand to
// the actually required size and all the remaining groups are
// squeezed into the available space and thus the widgets in there
// often can't be used any more.
// To fix this problem minimumSizeHint() is implemented to again
// respect the layout's minimum size.
QSize s1 = QSint::ActionGroup::minimumSizeHint();
QSize s2 = QWidget::minimumSizeHint();
return {qMax(s1.width(), s2.width()), qMax(s1.height(), s2.height())};
}
TaskBox::~TaskBox() = default;
void TaskBox::showEvent(QShowEvent*)
{
wasShown = true;
}
void TaskBox::hideGroupBox()
{
if (!wasShown) {
// get approximate height
int h = 0;
int ct = groupLayout()->count();
for (int i = 0; i < ct; i++) {
QLayoutItem* item = groupLayout()->itemAt(i);
if (item && item->widget()) {
QWidget* w = item->widget();
h += w->height();
}
}
m_tempHeight = m_fullHeight = h;
// For the very first time the group gets shown
// we cannot do the animation because the layouting
// is not yet fully done
m_foldDelta = 0;
}
else {
m_tempHeight = m_fullHeight = myGroup->height();
m_foldDelta = m_fullHeight / myScheme->groupFoldSteps;
}
m_foldStep = 0.0;
m_foldDirection = -1;
// make sure to have the correct icon
bool block = myHeader->blockSignals(true);
myHeader->fold();
myHeader->blockSignals(block);
myDummy->setFixedHeight(0);
myDummy->hide();
myGroup->hide();
m_foldPixmap = QPixmap();
setFixedHeight(myHeader->height());
setSizePolicy(QSizePolicy::Preferred, QSizePolicy::Preferred);
}
bool TaskBox::isGroupVisible() const
{
return myGroup->isVisible();
}
void TaskBox::actionEvent(QActionEvent* e)
{
QAction* action = e->action();
switch (e->type()) {
case QEvent::ActionAdded: {
auto label = new QSint::ActionLabel(action, this);
this->addActionLabel(label, true, false);
break;
}
case QEvent::ActionChanged: {
break;
}
case QEvent::ActionRemoved: {
// cannot change anything
break;
}
default:
break;
}
}
//**************************************************************************
//**************************************************************************
// TaskPanel
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
TaskPanel::TaskPanel(QWidget* parent)
: QWidget(parent)
{
mainLayout = new QVBoxLayout(this);
mainLayout->setContentsMargins(0, 0, 0, 0);
this->setLayout(mainLayout);
scrollArea = new QScrollArea(this);
contextualPanelsLayout = new QVBoxLayout();
contextualPanelsLayout->setContentsMargins(0, 0, 0, 0);
mainLayout->addLayout(contextualPanelsLayout);
dialogLayout = new QVBoxLayout();
dialogLayout->setContentsMargins(0, 0, 0, 0);
dialogLayout->setSpacing(0);
mainLayout->addLayout(dialogLayout, 1);
actionPanel = new QSint::ActionPanel(scrollArea);
QSizePolicy sizePolicy(QSizePolicy::Preferred, QSizePolicy::Preferred);
sizePolicy.setHorizontalStretch(0);
sizePolicy.setVerticalStretch(0);
sizePolicy.setHeightForWidth(actionPanel->sizePolicy().hasHeightForWidth());
actionPanel->setSizePolicy(sizePolicy);
actionPanel->setScheme(QSint::ActionPanelScheme::defaultScheme());
scrollArea->setWidget(actionPanel);
scrollArea->setWidgetResizable(true);
scrollArea->setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
scrollArea->setMinimumWidth(200);
dialogLayout->addWidget(scrollArea, 1);
}
TaskPanel::~TaskPanel()
{
for (QWidget* panel : contextualPanels) {
delete panel;
}
}
QSize TaskPanel::minimumSizeHint() const
{
// ActionPanel returns a size of 200x150 which leads to problems
// when there are several task groups in the panel and the first
// one is collapsed. In this case the task panel doesn't expand to
// the actually required size and all the remaining groups are
// squeezed into the available space and thus the widgets in there
// often can't be used any more.
// To fix this problem minimumSizeHint() is implemented to again
// respect the layout's minimum size.
QSize s1 = actionPanel->minimumSizeHint();
QSize s2 = QWidget::minimumSizeHint();
return {qMax(s1.width(), s2.width()), qMax(s1.height(), s2.height())};
}
//**************************************************************************
//**************************************************************************
// TaskView
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
TaskView::TaskView(QWidget* parent)
: QStackedWidget(parent)
, hGrp(Gui::WindowParameter::getDefaultParameter()->GetGroup("General"))
{
TaskWatcherPanel = new TaskPanel(this);
addWidget(TaskWatcherPanel);
Gui::Selection().Attach(this);
// NOLINTBEGIN
connectApplicationActiveDocument = App::GetApplication().signalActiveDocument.connect(
std::bind(&Gui::TaskView::TaskView::slotActiveDocument, this, sp::_1)
);
connectApplicationDeleteDocument = App::GetApplication().signalDeleteDocument.connect(
std::bind(&Gui::TaskView::TaskView::slotDeletedDocument, this, sp::_1)
);
connectApplicationClosedView = Gui::Application::Instance->signalCloseView.connect(
std::bind(&Gui::TaskView::TaskView::slotViewClosed, this, sp::_1)
);
connectApplicationUndoDocument = App::GetApplication().signalUndoDocument.connect(
std::bind(&Gui::TaskView::TaskView::slotUndoDocument, this, sp::_1)
);
connectApplicationRedoDocument = App::GetApplication().signalRedoDocument.connect(
std::bind(&Gui::TaskView::TaskView::slotRedoDocument, this, sp::_1)
);
connectApplicationInEdit = Gui::Application::Instance->signalInEdit.connect(
std::bind(&Gui::TaskView::TaskView::slotInEdit, this, sp::_1)
);
// NOLINTEND
setShowTaskWatcher(hGrp->GetBool("ShowTaskWatcher", true));
connectShowTaskWatcherSetting = hGrp->Manager()->signalParamChanged.connect(
[this](ParameterGrp* Param, ParameterGrp::ParamType Type, const char* name, const char* value) {
if (Param == hGrp && Type == ParameterGrp::ParamType::FCBool && name
&& strcmp(name, "ShowTaskWatcher") == 0) {
setShowTaskWatcher(value && *value == '1');
}
}
);
updateWatcher();
}
TaskView::~TaskView()
{
connectApplicationActiveDocument.disconnect();
connectApplicationDeleteDocument.disconnect();
connectApplicationClosedView.disconnect();
connectApplicationUndoDocument.disconnect();
connectApplicationRedoDocument.disconnect();
connectApplicationInEdit.disconnect();
connectShowTaskWatcherSetting.disconnect();
Gui::Selection().Detach(this);
// if well behaved, we should not have nay taskInfo at this point
for (auto& taskInfo : taskInfos) {
delete taskInfo.ActiveCtrl;
delete taskInfo.ActiveDialog;
delete taskInfo.taskPanel;
}
}
bool TaskView::isEmpty(bool includeWatcher) const
{
std::optional<TaskInfo> active = currentTaskInfo();
if (active) {
return false;
}
// There is no active task in the document
if (includeWatcher) {
for (auto* watcher : ActiveWatcher) {
if (watcher->shouldShow()) {
return false;
}
}
}
return true;
}
bool TaskView::event(QEvent* event)
{
// Workaround for a limitation in Qt (#0003794)
// Line edits and spin boxes don't handle the key combination
// Shift+Keypad button (if NumLock is activated)
if (event->type() == QEvent::ShortcutOverride) {
QWidget* focusWidget = qApp->focusWidget();
bool isLineEdit = qobject_cast<QLineEdit*>(focusWidget);
bool isSpinBox = qobject_cast<QAbstractSpinBox*>(focusWidget);
if (isLineEdit || isSpinBox) {
auto kevent = static_cast<QKeyEvent*>(event);
Qt::KeyboardModifiers ShiftKeypadModifier = Qt::ShiftModifier | Qt::KeypadModifier;
if (kevent->modifiers() == Qt::NoModifier || kevent->modifiers() == Qt::ShiftModifier
|| kevent->modifiers() == Qt::KeypadModifier
|| kevent->modifiers() == ShiftKeypadModifier) {
switch (kevent->key()) {
case Qt::Key_Delete:
case Qt::Key_Home:
case Qt::Key_End:
case Qt::Key_Backspace:
case Qt::Key_Left:
case Qt::Key_Right:
kevent->accept();
default:
break;
}
}
}
}
return QWidget::event(event);
}
void TaskView::keyPressEvent(QKeyEvent* ke)
{
std::optional<TaskInfo> active = currentTaskInfo();
if (active) {
if (ke->key() == Qt::Key_Return || ke->key() == Qt::Key_Enter) {
// get all buttons of the complete task dialog
QList<QPushButton*> list = this->findChildren<QPushButton*>();
for (auto pb : list) {
if (pb->isDefault() && pb->isVisible()) {
if (pb->isEnabled()) {
#if defined(FC_OS_MACOSX)
// #0001354: Crash on using Enter-Key for confirmation of chamfer or fillet
// entries
QPoint pos = QCursor::pos();
QCursor::setPos(pb->parentWidget()->mapToGlobal(pb->pos()));
#endif
pb->click();
#if defined(FC_OS_MACOSX)
QCursor::setPos(pos);
#endif
}
return;
}
}
}
else if (ke->key() == Qt::Key_Escape && active->ActiveDialog->isEscapeButtonEnabled()) {
// get only the buttons of the button box
QDialogButtonBox* box = active->ActiveCtrl->standardButtons();
QList<QAbstractButton*> list = box->buttons();
for (auto pb : list) {
if (box->buttonRole(pb) == QDialogButtonBox::RejectRole) {
if (pb->isEnabled()) {
#if defined(FC_OS_MACOSX)
// #0001354: Crash on using Enter-Key for confirmation of chamfer or fillet
// entries
QPoint pos = QCursor::pos();
QCursor::setPos(pb->parentWidget()->mapToGlobal(pb->pos()));
#endif
pb->click();
#if defined(FC_OS_MACOSX)
QCursor::setPos(pos);
#endif
}
return;
}
}
// In case a task panel has no Close or Cancel button
// then invoke resetEdit() directly
// See also ViewProvider::eventCallback
auto func = new Gui::TimerFunction();
func->setAutoDelete(true);
Gui::Document* doc = Gui::Application::Instance->getDocument(
active->ActiveDialog->getDocumentName().c_str()
);
if (doc) {
func->setFunction([doc]() { doc->resetEdit(); });
func->singleShot(0);
}
}
}
else {
QWidget::keyPressEvent(ke);
}
}
void TaskView::triggerMinimumSizeHint()
{
// NOLINTNEXTLINE
QTimer::singleShot(100, this, &TaskView::adjustMinimumSizeHint);
}
void TaskView::adjustMinimumSizeHint()
{
QSize ms = minimumSizeHint();
setMinimumWidth(ms.width());
}
QSize TaskView::minimumSizeHint() const
{
QSize ms = currentWidget()->minimumSizeHint();
int spacing = 0;
if (QLayout* layout = currentWidget()->layout()) {
spacing = 2 * layout->spacing();
}
ms.setWidth(ms.width() + spacing);
return ms;
}
void TaskView::slotActiveDocument(const App::Document& doc)
{
auto foundTaskInfo = std::ranges::find(taskInfos, &doc, &TaskInfo::Document);
if (foundTaskInfo != taskInfos.end()) {
setShownTaskInfo((foundTaskInfo - taskInfos.begin()));
}
else {
setShownTaskInfo(-1);
}
if (foundTaskInfo == taskInfos.end()) {
// at this point, active object of the active view returns None.
// which is a problem if shouldShow of a watcher rely on the presence
// of an active object (example Assembly).
QTimer::singleShot(100, this, &TaskView::updateWatcher);
}
}
void TaskView::slotInEdit(const Gui::ViewProviderDocumentObject& vp)
{
App::Document* doc = vp.getDocument()->getDocument();
if (std::ranges::find(taskInfos, doc, &TaskInfo::Document) == taskInfos.end()) {
updateWatcher();
}
}
void TaskView::slotDeletedDocument(const App::Document& doc)
{
auto foundTaskInfo = std::ranges::find(taskInfos, &doc, &TaskInfo::Document);
bool hasDialog = foundTaskInfo != taskInfos.end();
if (hasDialog && foundTaskInfo->ActiveDialog->isAutoCloseOnDeletedDocument()) {
foundTaskInfo->ActiveDialog->autoClosedOnDeletedDocument();
removeDialog(foundTaskInfo);
hasDialog = false;
}
if (!hasDialog) {
updateWatcher();
}
}
void TaskView::slotViewClosed(const Gui::MDIView* view)
{
auto foundTaskInfo = std::ranges::find_if(taskInfos, [view](const TaskInfo& info) {
return info.ActiveDialog->getAssociatedView() == view;
});
bool hasDialog = foundTaskInfo != taskInfos.end();
// It can happen that only a view is closed an not the document
if (hasDialog && foundTaskInfo->ActiveDialog->isAutoCloseOnClosedView()) {
foundTaskInfo->ActiveDialog->autoClosedOnClosedView();
removeDialog(foundTaskInfo);
hasDialog = false;
}
if (!hasDialog) {
updateWatcher();
}
}
void TaskView::transactionChangeOnDocument(const App::Document& doc, bool undo)
{
auto foundTaskInfo = std::ranges::find(taskInfos, &doc, &TaskInfo::Document);
bool hasDialog = foundTaskInfo != taskInfos.end();
if (hasDialog) {
if (undo) {
foundTaskInfo->ActiveDialog->onUndo();
}
else {
foundTaskInfo->ActiveDialog->onRedo();
}
if (foundTaskInfo->ActiveDialog->isAutoCloseOnTransactionChange()) {
foundTaskInfo->ActiveDialog->autoClosedOnTransactionChange();
removeDialog(foundTaskInfo);
hasDialog = false;
}
}
if (!hasDialog) {
updateWatcher();
}
}
void TaskView::slotUndoDocument(const App::Document& doc)
{
transactionChangeOnDocument(doc, true);
}
void TaskView::slotRedoDocument(const App::Document& doc)
{
transactionChangeOnDocument(doc, false);
}
/// @cond DOXERR
void TaskView::OnChange(
Gui::SelectionSingleton::SubjectType& rCaller,
Gui::SelectionSingleton::MessageType Reason
)
{
Q_UNUSED(rCaller);
std::string temp;
if (Reason.Type == SelectionChanges::AddSelection || Reason.Type == SelectionChanges::ClrSelection
|| Reason.Type == SelectionChanges::SetSelection
|| Reason.Type == SelectionChanges::RmvSelection) {
if (!currentTaskInfo()) {
updateWatcher();
}
}
}
/// @endcond
bool TaskView::showDialog(TaskDialog* dlg, App::Document* doc)
{
auto foundTaskInfo = std::ranges::find(taskInfos, doc, &TaskInfo::Document);
// if trying to open the same dialog twice nothing needs to be done
if (foundTaskInfo != taskInfos.end() && foundTaskInfo->ActiveDialog == dlg) {
return false;
}
assert(foundTaskInfo == taskInfos.end());
TaskInfo outInfo {.Document = doc};
// first create the control element, set it up and wire it:
outInfo.ActiveCtrl = new TaskEditControl(this);
outInfo.ActiveCtrl->buttonBox->setStandardButtons(dlg->getStandardButtons());
TaskDialogAttorney::setButtonBox(dlg, outInfo.ActiveCtrl->buttonBox);
const std::vector<QWidget*>& cont = dlg->getDialogContent();
// give to task dialog to customize the button box
dlg->modifyStandardButtons(outInfo.ActiveCtrl->buttonBox);
outInfo.taskPanel = new TaskPanel(this);
if (dlg->buttonPosition() == TaskDialog::North) {
// Add button box to the top of the main layout
outInfo.taskPanel->dialogLayout->insertWidget(0, outInfo.ActiveCtrl);
for (const auto& it : cont) {
outInfo.taskPanel->actionPanel->addWidget(it);
}
}
else {
for (const auto& it : cont) {
outInfo.taskPanel->actionPanel->addWidget(it);
}
// Add button box to the bottom of the main layout
outInfo.taskPanel->dialogLayout->addWidget(outInfo.ActiveCtrl);
}
outInfo.taskPanel->actionPanel->setScheme(QSint::ActionPanelScheme::defaultScheme());
if (!dlg->needsFullSpace()) {
outInfo.taskPanel->actionPanel->addStretch();
}
// set as active Dialog
outInfo.ActiveDialog = dlg;
outInfo.ActiveDialog->open();
// clang-format off
// make connection to the needed signals
connect(outInfo.ActiveCtrl->buttonBox, &QDialogButtonBox::accepted,
this, [doc, this]{ accept(doc); });
connect(outInfo.ActiveCtrl->buttonBox, &QDialogButtonBox::rejected,
this, [doc, this]{ reject(doc); });
connect(outInfo.ActiveCtrl->buttonBox, &QDialogButtonBox::helpRequested,
this, [doc, this]{ helpRequested(doc); });
connect(outInfo.ActiveCtrl->buttonBox, &QDialogButtonBox::clicked,
this, [doc, this](QAbstractButton *button) { clicked(button, doc); });
// clang-format on
// This will hide whatever was shown in the taskview
taskInfos.push_back(outInfo);
addWidget(outInfo.taskPanel);
setShownTaskInfo(taskInfos.size() - 1);
saveCurrentWidth();
getMainWindow()->updateActions();
triggerMinimumSizeHint();
Q_EMIT taskUpdate();
OverlayManager::instance()->refresh();
return true;
}
void TaskView::removeDialog(App::Document* doc)
{
auto foundTaskInfo = std::ranges::find(taskInfos, doc, &TaskInfo::Document);
if (foundTaskInfo != taskInfos.end()) {
removeDialog(foundTaskInfo);
}
}
void TaskView::removeDialog(std::vector<TaskInfo>::iterator infoIt)
{
if (infoIt == taskInfos.end()) {
return;
}
getMainWindow()->updateActions();
std::optional<TaskInfo> remove = std::nullopt;
if (infoIt->ActiveDialog) {
// See 'accept' and 'reject'
if (infoIt->ActiveDialog->property("taskview_accept_or_reject").isNull()) {
const std::vector<QWidget*>& cont = infoIt->ActiveDialog->getDialogContent();
for (const auto& it : cont) {
infoIt->taskPanel->actionPanel->removeWidget(it);
}
remove = *infoIt;
taskInfos.erase(infoIt);
removeWidget(remove->taskPanel);
}
else {
infoIt->ActiveDialog->setProperty("taskview_remove_dialog", true);
}
}
// put the watcher back in control
removeTaskWatcher();
addTaskWatcher();
if (remove) {
remove->ActiveDialog->closed();
remove->ActiveDialog->emitDestructionSignal();
delete remove->ActiveCtrl;
delete remove->ActiveDialog;
delete remove->taskPanel;
}
tryRestoreWidth();
triggerMinimumSizeHint();
OverlayManager::instance()->refresh();
}
void TaskView::setShowTaskWatcher(bool show)
{
if (showTaskWatcher == show) {
return;
}
showTaskWatcher = show;
if (show) {
addTaskWatcher();
}
else {
clearTaskWatcher();
}
}
void TaskView::updateWatcher()
{
if (!showTaskWatcher) {
return;
}
if (ActiveWatcher.empty()) {
auto panel = Gui::Control().taskPanel();
if (panel && !panel->ActiveWatcher.empty()) {
takeTaskWatcher(panel);
}
}
// In case a child of the TaskView has the focus and get hidden we have
// to make sure to set the focus on a widget that won't be hidden or
// deleted because otherwise Qt may forward the focus via focusNextPrevChild()
// to the mdi area which may switch to another mdi view which is not an
// acceptable behaviour.
QWidget* fw = QApplication::focusWidget();
if (!fw) {
this->setFocus();
}
QPointer<QWidget> fwp = fw;
while (fw && !fw->isWindow()) {
if (fw == this) {
this->setFocus();
break;
}
fw = fw->parentWidget();
}
// add all widgets for all watcher to the task view
for (const auto& it : ActiveWatcher) {
bool match = it->shouldShow();
std::vector<QWidget*>& cont = it->getWatcherContent();
for (auto& it2 : cont) {
if (match) {
it2->show();
}
else {
it2->hide();
}
}
}
// In case the previous widget that had the focus is still visible
// give it the focus back.
if (fwp && fwp->isVisible()) {
fwp->setFocus();
}
triggerMinimumSizeHint();
Q_EMIT taskUpdate();
}
void TaskView::addTaskWatcher(const std::vector<TaskWatcher*>& Watcher)
{
// remove and delete the old set of TaskWatcher
for (TaskWatcher* tw : ActiveWatcher) {
delete tw;
}
ActiveWatcher = Watcher;
addTaskWatcher();
}
void TaskView::takeTaskWatcher(TaskView* other)
{
clearTaskWatcher();
ActiveWatcher.swap(other->ActiveWatcher);
other->clearTaskWatcher();
if (isEmpty(false)) {
addTaskWatcher();
}
}
void TaskView::clearTaskWatcher()
{
std::vector<TaskWatcher*> watcher;
removeTaskWatcher();
// make sure to delete the old watchers
addTaskWatcher(watcher);
}
void TaskView::addTaskWatcher()
{
if (!showTaskWatcher) {
setShownTaskInfo(-1); // Switch to the empty taskwatcher panel
return;
}
// add all widgets for all watcher to the task view
for (TaskWatcher* tw : ActiveWatcher) {
std::vector<QWidget*>& cont = tw->getWatcherContent();
for (QWidget* w : cont) {
TaskWatcherPanel->actionPanel->addWidget(w);
}
}
if (!ActiveWatcher.empty()) {
TaskWatcherPanel->actionPanel->addStretch();
}
// Workaround to avoid a crash in Qt. See also
// https://forum.freecad.org/viewtopic.php?f=8&t=39187
//
// Notify the button box about a style change so that it can
// safely delete the style animation of its push buttons.
auto box = TaskWatcherPanel->mainLayout->findChild<QDialogButtonBox*>();
if (box) {
QEvent event(QEvent::StyleChange);
QApplication::sendEvent(box, &event);
}
TaskWatcherPanel->actionPanel->setScheme(QSint::ActionPanelScheme::defaultScheme());
setShownTaskInfo(-1);
}
void TaskView::saveCurrentWidth()
{
if (shouldRestoreWidth()) {
if (auto parent = qobject_cast<QDockWidget*>(parentWidget())) {
currentWidth = parent->width();
}
}
}
void TaskView::tryRestoreWidth()
{
if (shouldRestoreWidth()) {
if (auto parent = qobject_cast<QDockWidget*>(parentWidget())) {
Gui::getMainWindow()->resizeDocks({parent}, {currentWidth}, Qt::Horizontal);
}
}
}
void TaskView::setRestoreWidth(bool on)
{
restoreWidth = on;
}
bool TaskView::shouldRestoreWidth() const
{
return restoreWidth;
}
std::optional<TaskInfo> TaskView::currentTaskInfo() const
{
// Index 0 is taskWatcher's panel
if (currentIndex() <= 0) {
return std::nullopt;
}
return taskInfos[currentIndex() - 1];
}
TaskDialog* TaskView::dialog(App::Document* doc)
{
auto foundTaskInfo = std::ranges::find(taskInfos, doc, &TaskInfo::Document);
return foundTaskInfo == taskInfos.end() ? nullptr : foundTaskInfo->ActiveDialog;
}
void TaskView::setShownTaskInfo(int index)
{
int stackedIndex = 0;
int initIndex = currentIndex();
if (index < 0 || index >= taskInfos.size()) {
updateWatcher();
stackedIndex = 0; // Show task watcher
}
else {
stackedIndex = index + 1;
}
if (stackedIndex == initIndex) {
return; // Nothing to be done
}
if (initIndex > 0) {
Gui::Selection().rmvSelectionGate();
taskInfos[initIndex - 1].ActiveDialog->deactivate();
}
if (stackedIndex > 0) {
taskInfos[stackedIndex - 1].ActiveDialog->activate();
}
setCurrentIndex(stackedIndex);
}
void TaskView::removeTaskWatcher()
{
// In case a child of the TaskView has the focus and get hidden we have
// to make sure that set the focus on a widget that won't be hidden or
// deleted because otherwise Qt may forward the focus via focusNextPrevChild()
// to the mdi area which may switch to another mdi view which is not an
// acceptable behaviour.
QWidget* fw = QApplication::focusWidget();
if (!fw) {
this->setFocus();
}
while (fw && !fw->isWindow()) {
if (fw == this) {
this->setFocus();
break;
}
fw = fw->parentWidget();
}
// remove all widgets
for (TaskWatcher* tw : ActiveWatcher) {
std::vector<QWidget*>& cont = tw->getWatcherContent();
for (QWidget* w : cont) {
w->hide();
TaskWatcherPanel->actionPanel->removeWidget(w);
}
}
TaskWatcherPanel->actionPanel->removeStretch();
}
void TaskView::accept(App::Document* doc)
{
auto foundTaskInfo = std::ranges::find(taskInfos, doc, &TaskInfo::Document);
if (foundTaskInfo == taskInfos.end()) { // Protect against segfaults due to out-of-order deletions
Base::Console().warning("ActiveDialog was null in call to TaskView::accept()\n");
return;
}
// Make sure that if 'accept' calls 'closeDialog' the deletion is postponed until
// the dialog leaves the 'accept' method
foundTaskInfo->ActiveDialog->setProperty("taskview_accept_or_reject", true);
bool success = foundTaskInfo->ActiveDialog->accept();
foundTaskInfo->ActiveDialog->setProperty("taskview_accept_or_reject", QVariant());
if (success || foundTaskInfo->ActiveDialog->property("taskview_remove_dialog").isValid()) {
removeDialog(doc);
}
}
void TaskView::reject(App::Document* doc)
{
auto foundTaskInfo = std::ranges::find(taskInfos, doc, &TaskInfo::Document);
if (foundTaskInfo == taskInfos.end()) { // Protect against segfaults due to out-of-order deletions
Base::Console().warning("ActiveDialog was null in call to TaskView::reject()\n");
return;
}
// Make sure that if 'reject' calls 'closeDialog' the deletion is postponed until
// the dialog leaves the 'reject' method
foundTaskInfo->ActiveDialog->setProperty("taskview_accept_or_reject", true);
bool success = foundTaskInfo->ActiveDialog->reject();
foundTaskInfo->ActiveDialog->setProperty("taskview_accept_or_reject", QVariant());
if (success || foundTaskInfo->ActiveDialog->property("taskview_remove_dialog").isValid()) {
removeDialog(doc);
}
}
void TaskView::helpRequested(App::Document* doc)
{
auto foundTaskInfo = std::ranges::find(taskInfos, doc, &TaskInfo::Document);
if (foundTaskInfo != taskInfos.end()) {
foundTaskInfo->ActiveDialog->helpRequested();
}
}
void TaskView::clicked(QAbstractButton* button, App::Document* doc)
{
auto foundTaskInfo = std::ranges::find(taskInfos, doc, &TaskInfo::Document);
if (foundTaskInfo != taskInfos.end()) {
int id = foundTaskInfo->ActiveCtrl->buttonBox->standardButton(button);
foundTaskInfo->ActiveDialog->clicked(id);
}
}
void TaskView::clearActionStyle()
{
std::optional<TaskInfo> current = currentTaskInfo();
TaskPanel* panel = current ? current->taskPanel : TaskWatcherPanel;
static_cast<QSint::ActionPanelScheme*>(QSint::ActionPanelScheme::defaultScheme())->clearActionStyle();
panel->actionPanel->setScheme(QSint::ActionPanelScheme::defaultScheme());
}
void TaskView::restoreActionStyle()
{
std::optional<TaskInfo> current = currentTaskInfo();
TaskPanel* panel = current ? current->taskPanel : TaskWatcherPanel;
static_cast<QSint::ActionPanelScheme*>(QSint::ActionPanelScheme::defaultScheme())
->restoreActionStyle();
panel->actionPanel->setScheme(QSint::ActionPanelScheme::defaultScheme());
}
void TaskView::addContextualPanel(QWidget* panel, App::Document* doc)
{
auto foundTaskInfo = std::ranges::find(taskInfos, doc, &TaskInfo::Document);
if (!panel || foundTaskInfo == taskInfos.end()
|| foundTaskInfo->taskPanel->contextualPanels.contains(panel)) {
return;
}
foundTaskInfo->taskPanel->contextualPanelsLayout->addWidget(panel);
foundTaskInfo->taskPanel->contextualPanels.append(panel);
panel->show();
triggerMinimumSizeHint();
Q_EMIT taskUpdate();
}
void TaskView::removeContextualPanel(QWidget* panel, App::Document* doc)
{
auto foundTaskInfo = std::ranges::find(taskInfos, doc, &TaskInfo::Document);
if (!panel || foundTaskInfo == taskInfos.end()
|| !foundTaskInfo->taskPanel->contextualPanels.contains(panel)) {
return;
}
foundTaskInfo->taskPanel->contextualPanelsLayout->removeWidget(panel);
foundTaskInfo->taskPanel->contextualPanels.removeOne(panel);
panel->deleteLater();
triggerMinimumSizeHint();
Q_EMIT taskUpdate();
}
#include "moc_TaskView.cpp"
Reference in New Issue View Git Blame Copy Permalink