2249 lines
76 KiB
C++
2249 lines
76 KiB
C++
/****************************************************************************
|
|
* Copyright (c) 2022 Zheng Lei (realthunder) <realthunder.dev@gmail.com> *
|
|
* *
|
|
* 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 <limits>
|
|
#include <QAction>
|
|
#include <QApplication>
|
|
#include <QComboBox>
|
|
#include <QDockWidget>
|
|
#include <QFile>
|
|
#include <QGraphicsView>
|
|
#include <QHeaderView>
|
|
#include <QKeyEvent>
|
|
#include <QMdiArea>
|
|
#include <QMenu>
|
|
#include <QPainter>
|
|
#include <QPointer>
|
|
#include <QTextStream>
|
|
#include <QTimerEvent>
|
|
#include <QToolTip>
|
|
#include <QScrollBar>
|
|
|
|
#include <QPainterPath>
|
|
#include <QPropertyAnimation>
|
|
|
|
#include <array>
|
|
#include <unordered_map>
|
|
|
|
#include "OverlayManager.h"
|
|
|
|
#include <Base/Console.h>
|
|
#include <Base/Parameter.h>
|
|
#include <Base/Tools.h>
|
|
#include <App/Application.h>
|
|
#include "Application.h"
|
|
#include "BitmapFactory.h"
|
|
#include "Control.h"
|
|
#include "MainWindow.h"
|
|
#include "MDIView.h"
|
|
#include "NaviCube.h"
|
|
#include "OverlayParams.h"
|
|
#include "OverlayWidgets.h"
|
|
#include "TaskView/TaskView.h"
|
|
#include "Tree.h"
|
|
#include "TreeParams.h"
|
|
#include "View3DInventorViewer.h"
|
|
|
|
FC_LOG_LEVEL_INIT("Dock", true, true);
|
|
|
|
using namespace Gui;
|
|
|
|
static std::array<OverlayTabWidget*, 4> _Overlays;
|
|
|
|
static inline OverlayTabWidget* findTabWidget(QWidget* widget = nullptr, bool filterDialog = false)
|
|
{
|
|
if (!widget) {
|
|
widget = qApp->focusWidget();
|
|
}
|
|
for (auto w = widget; w; w = w->parentWidget()) {
|
|
auto tabWidget = qobject_cast<OverlayTabWidget*>(w);
|
|
if (tabWidget) {
|
|
return tabWidget;
|
|
}
|
|
auto proxy = qobject_cast<OverlayProxyWidget*>(w);
|
|
if (proxy) {
|
|
return proxy->getOwner();
|
|
}
|
|
if (filterDialog && w->windowType() != Qt::Widget) {
|
|
break;
|
|
}
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
class OverlayStyleSheet: public ParameterGrp::ObserverType
|
|
{
|
|
public:
|
|
OverlayStyleSheet()
|
|
{
|
|
handle = App::GetApplication().GetParameterGroupByPath(
|
|
"User parameter:BaseApp/Preferences/MainWindow"
|
|
);
|
|
|
|
update();
|
|
|
|
handle->Attach(this);
|
|
}
|
|
|
|
static OverlayStyleSheet* instance()
|
|
{
|
|
static OverlayStyleSheet* instance;
|
|
|
|
if (!instance) {
|
|
instance = new OverlayStyleSheet;
|
|
}
|
|
|
|
return instance;
|
|
}
|
|
|
|
void OnChange(Base::Subject<const char*>&, const char* sReason)
|
|
{
|
|
if (!sReason) {
|
|
return;
|
|
}
|
|
|
|
if (strcmp(sReason, "StyleSheet") == 0 || strcmp(sReason, "OverlayActiveStyleSheet") == 0) {
|
|
OverlayManager::instance()->refresh(nullptr, true);
|
|
}
|
|
}
|
|
|
|
void update()
|
|
{
|
|
activeStyleSheet.clear();
|
|
|
|
QString overlayStylesheetFileName = detectOverlayStyleSheetFileName();
|
|
loadFromFile(overlayStylesheetFileName);
|
|
|
|
// If after loading the result is still empty we need to apply some defaults
|
|
if (activeStyleSheet.isEmpty()) {
|
|
activeStyleSheet = _default;
|
|
}
|
|
|
|
activeStyleSheet = Application::Instance->replaceVariablesInQss(activeStyleSheet);
|
|
}
|
|
|
|
ParameterGrp::handle handle;
|
|
QString activeStyleSheet;
|
|
bool hideTab = false;
|
|
|
|
private:
|
|
QString detectOverlayStyleSheetFileName() const
|
|
{
|
|
QString mainStyleSheet = QString::fromUtf8(handle->GetASCII("StyleSheet").c_str());
|
|
QString overlayStyleSheet = QString::fromUtf8(
|
|
handle->GetASCII("OverlayActiveStyleSheet").c_str()
|
|
);
|
|
|
|
if (overlayStyleSheet.isEmpty()) {
|
|
// User did not choose any stylesheet, we need to choose one based on main stylesheet
|
|
if (mainStyleSheet.contains(QStringLiteral("light"), Qt::CaseInsensitive)) {
|
|
overlayStyleSheet = QStringLiteral("overlay:Light Theme + Dark Background.qss");
|
|
}
|
|
else {
|
|
// by default FreeCAD uses somewhat dark background for 3D View.
|
|
// if user has not explicitly selected light theme, the "Dark Outline" looks best
|
|
overlayStyleSheet = QStringLiteral("overlay:Dark Theme + Dark Background.qss");
|
|
}
|
|
}
|
|
else if (!overlayStyleSheet.isEmpty() && !QFile::exists(overlayStyleSheet)) {
|
|
// User did choose one of predefined stylesheets, we need to qualify it with namespace
|
|
overlayStyleSheet = QStringLiteral("overlay:%1").arg(overlayStyleSheet);
|
|
}
|
|
|
|
return overlayStyleSheet;
|
|
}
|
|
|
|
void loadFromFile(const QString& name)
|
|
{
|
|
if (!QFile::exists(name)) {
|
|
return;
|
|
}
|
|
|
|
QFile file(name);
|
|
|
|
if (file.open(QFile::ReadOnly)) {
|
|
activeStyleSheet = QTextStream(&file).readAll();
|
|
}
|
|
}
|
|
|
|
static const QString _default;
|
|
};
|
|
|
|
const QString OverlayStyleSheet::_default = QStringLiteral("overlay:Light Theme + Dark Background.qss");
|
|
|
|
// -----------------------------------------------------------
|
|
|
|
struct OverlayInfo
|
|
{
|
|
const char* name;
|
|
OverlayTabWidget* tabWidget;
|
|
Qt::DockWidgetArea dockArea;
|
|
std::unordered_map<QDockWidget*, OverlayInfo*>& overlayMap;
|
|
ParameterGrp::handle hGrp;
|
|
fastsignals::scoped_connection conn;
|
|
|
|
OverlayInfo(
|
|
QWidget* parent,
|
|
const char* name,
|
|
Qt::DockWidgetArea pos,
|
|
std::unordered_map<QDockWidget*, OverlayInfo*>& map
|
|
)
|
|
: name(name)
|
|
, dockArea(pos)
|
|
, overlayMap(map)
|
|
{
|
|
tabWidget = new OverlayTabWidget(parent, dockArea);
|
|
tabWidget->setObjectName(QString::fromUtf8(name));
|
|
tabWidget->getProxyWidget()->setObjectName(tabWidget->objectName() + QStringLiteral("Proxy"));
|
|
tabWidget->setMovable(true);
|
|
hGrp = App::GetApplication()
|
|
.GetUserParameter()
|
|
.GetGroup("BaseApp")
|
|
->GetGroup("MainWindow")
|
|
->GetGroup("DockWindows")
|
|
->GetGroup(name);
|
|
conn = App::GetApplication().GetUserParameter().signalParamChanged.connect(
|
|
[this](ParameterGrp* Param, ParameterGrp::ParamType, const char* Name, const char*) {
|
|
if (hGrp == Param && Name && !tabWidget->isSaving()) {
|
|
// This will prevent saving settings which will mess up the
|
|
// just restored ones
|
|
tabWidget->restore(nullptr);
|
|
OverlayManager::instance()->reload();
|
|
}
|
|
}
|
|
);
|
|
}
|
|
|
|
bool addWidget(QDockWidget* dock, bool forced = true)
|
|
{
|
|
if (!dock) {
|
|
return false;
|
|
}
|
|
if (tabWidget->dockWidgetIndex(dock) >= 0) {
|
|
return false;
|
|
}
|
|
overlayMap[dock] = this;
|
|
bool visible = dock->isVisible();
|
|
|
|
auto focus = qApp->focusWidget();
|
|
if (focus && findTabWidget(focus) != tabWidget) {
|
|
focus = nullptr;
|
|
}
|
|
|
|
tabWidget->addWidget(dock, dock->windowTitle());
|
|
|
|
if (focus) {
|
|
tabWidget->setCurrent(dock);
|
|
focus = qApp->focusWidget();
|
|
if (focus) {
|
|
focus->clearFocus();
|
|
}
|
|
}
|
|
|
|
if (forced) {
|
|
auto mw = getMainWindow();
|
|
for (auto d : mw->findChildren<QDockWidget*>()) {
|
|
if (mw->dockWidgetArea(d) == dockArea && d->toggleViewAction()->isChecked()) {
|
|
addWidget(d, false);
|
|
}
|
|
}
|
|
if (visible) {
|
|
dock->show();
|
|
tabWidget->setCurrent(dock);
|
|
}
|
|
}
|
|
else {
|
|
tabWidget->saveTabs();
|
|
}
|
|
return true;
|
|
}
|
|
|
|
void removeWidget()
|
|
{
|
|
if (!tabWidget->count()) {
|
|
return;
|
|
}
|
|
|
|
tabWidget->hide();
|
|
|
|
QPointer<QWidget> focus = qApp->focusWidget();
|
|
|
|
QDockWidget* lastDock = tabWidget->currentDockWidget();
|
|
if (lastDock) {
|
|
tabWidget->removeWidget(lastDock);
|
|
}
|
|
while (tabWidget->count()) {
|
|
QDockWidget* dock = tabWidget->dockWidget(0);
|
|
if (!dock) {
|
|
tabWidget->removeTab(0);
|
|
continue;
|
|
}
|
|
tabWidget->removeWidget(dock, lastDock);
|
|
lastDock = dock;
|
|
}
|
|
|
|
if (focus) {
|
|
focus->setFocus();
|
|
}
|
|
|
|
tabWidget->saveTabs();
|
|
}
|
|
|
|
void save()
|
|
{}
|
|
|
|
void restore()
|
|
{
|
|
tabWidget->restore(hGrp);
|
|
for (int i = 0, c = tabWidget->count(); i < c; ++i) {
|
|
auto dock = tabWidget->dockWidget(i);
|
|
if (dock) {
|
|
overlayMap[dock] = this;
|
|
}
|
|
}
|
|
}
|
|
};
|
|
|
|
enum class ToggleMode
|
|
{
|
|
Unset,
|
|
Set,
|
|
Toggle,
|
|
Transparent,
|
|
Check,
|
|
};
|
|
|
|
class OverlayManager::Private
|
|
{
|
|
public:
|
|
QPointer<QWidget> lastIntercept;
|
|
QTimer _timer;
|
|
QTimer _reloadTimer;
|
|
|
|
bool mouseTransparent = false;
|
|
bool intercepting = false;
|
|
|
|
std::unordered_map<QDockWidget*, OverlayInfo*> _overlayMap;
|
|
OverlayInfo _left;
|
|
OverlayInfo _right;
|
|
OverlayInfo _top;
|
|
OverlayInfo _bottom;
|
|
std::array<OverlayInfo*, 4> _overlayInfos;
|
|
QCursor _cursor;
|
|
|
|
QPoint _lastPos;
|
|
|
|
QAction _actClose;
|
|
QAction _actFloat;
|
|
QAction _actOverlay;
|
|
QList<QAction*> _actions;
|
|
|
|
QPointer<QWidget> _trackingWidget;
|
|
OverlayTabWidget* _trackingOverlay = nullptr;
|
|
|
|
bool updateStyle = false;
|
|
QTime wheelDelay;
|
|
QPoint wheelPos;
|
|
|
|
std::map<QString, OverlayTabWidget*> _dockWidgetNameMap;
|
|
|
|
bool raising = false;
|
|
|
|
OverlayManager::ReloadMode curReloadMode = OverlayManager::ReloadMode::ReloadPending;
|
|
|
|
Private(OverlayManager* host, QWidget* parent)
|
|
: _left(parent, "OverlayLeft", Qt::LeftDockWidgetArea, _overlayMap)
|
|
, _right(parent, "OverlayRight", Qt::RightDockWidgetArea, _overlayMap)
|
|
, _top(parent, "OverlayTop", Qt::TopDockWidgetArea, _overlayMap)
|
|
, _bottom(parent, "OverlayBottom", Qt::BottomDockWidgetArea, _overlayMap)
|
|
, _overlayInfos({&_left, &_right, &_top, &_bottom})
|
|
, _actions({&_actOverlay, &_actFloat, &_actClose})
|
|
{
|
|
_Overlays = {
|
|
OverlayTabWidget::_LeftOverlay,
|
|
OverlayTabWidget::_RightOverlay,
|
|
OverlayTabWidget::_TopOverlay,
|
|
OverlayTabWidget::_BottomOverlay
|
|
};
|
|
|
|
connect(&_timer, &QTimer::timeout, [this]() { onTimer(); });
|
|
_timer.setSingleShot(true);
|
|
|
|
_reloadTimer.setSingleShot(true);
|
|
connect(&_reloadTimer, &QTimer::timeout, [this]() {
|
|
for (auto& o : _overlayInfos) {
|
|
o->tabWidget->restore(nullptr); // prevent saving setting first
|
|
o->removeWidget();
|
|
}
|
|
for (auto& o : _overlayInfos) {
|
|
o->restore();
|
|
}
|
|
refresh();
|
|
});
|
|
|
|
connect(qApp, &QApplication::focusChanged, host, &OverlayManager::onFocusChanged);
|
|
|
|
Application::Instance->signalActivateView.connect([this](const MDIView*) { refresh(); });
|
|
Application::Instance->signalInEdit.connect([this](const ViewProviderDocumentObject&) {
|
|
refresh();
|
|
});
|
|
Application::Instance->signalResetEdit.connect([this](const ViewProviderDocumentObject&) {
|
|
refresh();
|
|
});
|
|
Application::Instance->signalActivateWorkbench.connect([this](const char*) { refresh(); });
|
|
|
|
_actOverlay.setData(QStringLiteral("OBTN Overlay"));
|
|
_actFloat.setData(QStringLiteral("OBTN Float"));
|
|
_actClose.setData(QStringLiteral("OBTN Close"));
|
|
|
|
retranslate();
|
|
refreshIcons();
|
|
|
|
for (auto action : _actions) {
|
|
QObject::connect(action, &QAction::triggered, host, &OverlayManager::onAction);
|
|
}
|
|
for (auto o : _overlayInfos) {
|
|
for (auto action : o->tabWidget->actions()) {
|
|
QObject::connect(action, &QAction::triggered, host, &OverlayManager::onAction);
|
|
}
|
|
o->tabWidget->setTitleBar(createTitleBar(o->tabWidget));
|
|
}
|
|
|
|
QIcon px = BitmapFactory().pixmap("cursor-through");
|
|
_cursor = QCursor(px.pixmap(32, 32), 10, 9);
|
|
}
|
|
|
|
void refreshIcons()
|
|
{
|
|
_actFloat.setIcon(BitmapFactory().pixmap("qss:overlay/icons/float.svg"));
|
|
_actOverlay.setIcon(BitmapFactory().pixmap("qss:overlay/icons/overlay.svg"));
|
|
_actClose.setIcon(BitmapFactory().pixmap("qss:overlay/icons/close.svg"));
|
|
for (OverlayTabWidget* tabWidget : _Overlays) {
|
|
tabWidget->refreshIcons();
|
|
for (auto handle : tabWidget->findChildren<OverlaySplitterHandle*>()) {
|
|
handle->refreshIcons();
|
|
}
|
|
}
|
|
}
|
|
|
|
void interceptEvent(QWidget*, QEvent*);
|
|
|
|
void setMouseTransparent(bool enabled)
|
|
{
|
|
if (mouseTransparent == enabled) {
|
|
return;
|
|
}
|
|
mouseTransparent = enabled;
|
|
for (OverlayTabWidget* tabWidget : _Overlays) {
|
|
tabWidget->setAttribute(Qt::WA_TransparentForMouseEvents, enabled);
|
|
tabWidget->touch();
|
|
}
|
|
refresh();
|
|
if (!enabled) {
|
|
qApp->restoreOverrideCursor();
|
|
}
|
|
else {
|
|
qApp->setOverrideCursor(_cursor);
|
|
}
|
|
}
|
|
|
|
bool toggleOverlay(QDockWidget* dock, ToggleMode toggle, int dockPos = Qt::NoDockWidgetArea)
|
|
{
|
|
if (!dock) {
|
|
return false;
|
|
}
|
|
|
|
auto it = _overlayMap.find(dock);
|
|
if (it != _overlayMap.end()) {
|
|
auto o = it->second;
|
|
switch (toggle) {
|
|
case ToggleMode::Transparent:
|
|
o->tabWidget->setTransparent(!o->tabWidget->isTransparent());
|
|
break;
|
|
case ToggleMode::Unset:
|
|
case ToggleMode::Toggle:
|
|
_overlayMap.erase(it);
|
|
o->tabWidget->removeWidget(dock);
|
|
return false;
|
|
default:
|
|
break;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
if (toggle == ToggleMode::Unset) {
|
|
return false;
|
|
}
|
|
|
|
if (dockPos == Qt::NoDockWidgetArea) {
|
|
dockPos = getMainWindow()->dockWidgetArea(dock);
|
|
}
|
|
OverlayInfo* o;
|
|
switch (dockPos) {
|
|
case Qt::LeftDockWidgetArea:
|
|
o = &_left;
|
|
break;
|
|
case Qt::RightDockWidgetArea:
|
|
o = &_right;
|
|
break;
|
|
case Qt::TopDockWidgetArea:
|
|
o = &_top;
|
|
break;
|
|
case Qt::BottomDockWidgetArea:
|
|
o = &_bottom;
|
|
break;
|
|
default:
|
|
return false;
|
|
}
|
|
if (toggle == ToggleMode::Check && !o->tabWidget->count()) {
|
|
return false;
|
|
}
|
|
if (o->addWidget(dock)) {
|
|
if (toggle == ToggleMode::Transparent) {
|
|
o->tabWidget->setTransparent(true);
|
|
}
|
|
}
|
|
refresh();
|
|
return true;
|
|
}
|
|
|
|
void refresh(QWidget* widget = nullptr, bool refreshStyle = false)
|
|
{
|
|
if (refreshStyle) {
|
|
OverlayStyleSheet::instance()->update();
|
|
updateStyle = true;
|
|
}
|
|
|
|
if (widget) {
|
|
auto tabWidget = findTabWidget(widget);
|
|
if (tabWidget && tabWidget->count()) {
|
|
for (auto o : _overlayInfos) {
|
|
if (tabWidget == o->tabWidget) {
|
|
tabWidget->touch();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
_timer.start(OverlayParams::getDockOverlayDelay());
|
|
}
|
|
|
|
void save()
|
|
{
|
|
_left.save();
|
|
_right.save();
|
|
_top.save();
|
|
_bottom.save();
|
|
}
|
|
|
|
void restore()
|
|
{
|
|
_left.restore();
|
|
_right.restore();
|
|
_top.restore();
|
|
_bottom.restore();
|
|
refresh();
|
|
}
|
|
|
|
void onTimer()
|
|
{
|
|
auto mdi = getMainWindow() ? getMainWindow()->getMdiArea() : nullptr;
|
|
if (!mdi) {
|
|
return;
|
|
}
|
|
|
|
auto focus = findTabWidget(qApp->focusWidget());
|
|
if (focus && !focus->getSplitter()->isVisible()) {
|
|
focus = nullptr;
|
|
}
|
|
auto active = findTabWidget(qApp->widgetAt(QCursor::pos()));
|
|
if (active && !active->getSplitter()->isVisible()) {
|
|
active = nullptr;
|
|
}
|
|
OverlayTabWidget* reveal = nullptr;
|
|
|
|
bool updateFocus = false;
|
|
bool updateActive = false;
|
|
|
|
for (auto o : _overlayInfos) {
|
|
if (o->tabWidget->isTouched() || updateStyle) {
|
|
if (o->tabWidget == focus) {
|
|
updateFocus = true;
|
|
}
|
|
else if (o->tabWidget == active) {
|
|
updateActive = true;
|
|
}
|
|
else {
|
|
o->tabWidget->setOverlayMode(true);
|
|
}
|
|
}
|
|
if (!o->tabWidget->getRevealTime().isNull()) {
|
|
if (o->tabWidget->getRevealTime() <= QTime::currentTime()) {
|
|
o->tabWidget->setRevealTime(QTime());
|
|
}
|
|
else {
|
|
reveal = o->tabWidget;
|
|
}
|
|
}
|
|
}
|
|
updateStyle = false;
|
|
|
|
if (focus) {
|
|
if (focus->isOverlaid(OverlayTabWidget::QueryOption::TransparencyChanged) || updateFocus) {
|
|
focus->setOverlayMode(false);
|
|
focus->raise();
|
|
if (reveal == focus) {
|
|
reveal = nullptr;
|
|
}
|
|
}
|
|
else {
|
|
focus->updateSplitterHandles();
|
|
}
|
|
}
|
|
|
|
if (active) {
|
|
if (active != focus
|
|
&& (active->isOverlaid(OverlayTabWidget::QueryOption::TransparencyChanged)
|
|
|| updateActive)) {
|
|
active->setOverlayMode(false);
|
|
}
|
|
active->raise();
|
|
if (reveal == active) {
|
|
reveal = nullptr;
|
|
}
|
|
}
|
|
|
|
if (reveal && !reveal->splitter->isVisible()) {
|
|
reveal->setOverlayMode(false);
|
|
reveal->raise();
|
|
}
|
|
|
|
for (auto o : _overlayInfos) {
|
|
if (o->tabWidget != focus && o->tabWidget != active && o->tabWidget != reveal
|
|
&& o->tabWidget->count()
|
|
&& !o->tabWidget->isOverlaid(OverlayTabWidget::QueryOption::TransparencyNotChanged)) {
|
|
o->tabWidget->setOverlayMode(true);
|
|
}
|
|
}
|
|
|
|
int w = mdi->geometry().width();
|
|
int h = mdi->geometry().height();
|
|
auto tabbar = mdi->findChild<QTabBar*>();
|
|
if (tabbar) {
|
|
h -= tabbar->height();
|
|
}
|
|
|
|
int naviCubeSize = NaviCube::getNaviCubeSize();
|
|
int naviCorner = OverlayParams::getDockOverlayCheckNaviCube()
|
|
? App::GetApplication()
|
|
.GetParameterGroupByPath("User parameter:BaseApp/Preferences/NaviCube")
|
|
->GetInt("CornerNaviCube", 1)
|
|
: -1;
|
|
|
|
QRect rect;
|
|
QRect rectBottom(0, 0, 0, 0);
|
|
|
|
rect = _bottom.tabWidget->getRect();
|
|
|
|
QSize ofs = _bottom.tabWidget->getOffset();
|
|
int delta = _bottom.tabWidget->getSizeDelta();
|
|
h -= ofs.height();
|
|
|
|
const int paddedCubeSize = naviCubeSize + 10;
|
|
if (naviCorner == 2) {
|
|
ofs.setWidth(ofs.width() + paddedCubeSize);
|
|
}
|
|
int bw = w - 10 - ofs.width() - delta;
|
|
if (naviCorner == 3) {
|
|
bw -= paddedCubeSize;
|
|
}
|
|
if (bw < 10) {
|
|
bw = 10;
|
|
}
|
|
|
|
// Bottom width is maintain the same to reduce QTextEdit re-layout
|
|
// which may be expensive if there are lots of text, e.g. for
|
|
// ReportView or PythonConsole.
|
|
_bottom.tabWidget->setRect(QRect(ofs.width(), h - rect.height(), bw, rect.height()));
|
|
|
|
if (_bottom.tabWidget->count() && _bottom.tabWidget->isVisible()
|
|
&& _bottom.tabWidget->getState() <= OverlayTabWidget::State::Normal) {
|
|
rectBottom = _bottom.tabWidget->getRect();
|
|
}
|
|
|
|
QRect rectLeft(0, 0, 0, 0);
|
|
rect = _left.tabWidget->getRect();
|
|
|
|
ofs = _left.tabWidget->getOffset();
|
|
if (naviCorner == 0) {
|
|
ofs.setWidth(ofs.width() + paddedCubeSize);
|
|
}
|
|
delta = _left.tabWidget->getSizeDelta() + rectBottom.height();
|
|
if (naviCorner == 2 && paddedCubeSize > rectBottom.height()) {
|
|
delta += paddedCubeSize - rectBottom.height();
|
|
}
|
|
int lh = std::max(h - ofs.width() - delta, 10);
|
|
|
|
_left.tabWidget->setRect(QRect(ofs.height(), ofs.width(), rect.width(), lh));
|
|
|
|
if (_left.tabWidget->count() && _left.tabWidget->isVisible()
|
|
&& _left.tabWidget->getState() <= OverlayTabWidget::State::Normal) {
|
|
rectLeft = _left.tabWidget->getRect();
|
|
}
|
|
|
|
QRect rectRight(0, 0, 0, 0);
|
|
rect = _right.tabWidget->getRect();
|
|
|
|
ofs = _right.tabWidget->getOffset();
|
|
if (naviCorner == 1) {
|
|
ofs.setWidth(ofs.width() + paddedCubeSize);
|
|
}
|
|
delta = _right.tabWidget->getSizeDelta() + rectBottom.height();
|
|
if (naviCorner == 3 && paddedCubeSize > rectBottom.height()) {
|
|
delta += paddedCubeSize - rectBottom.height();
|
|
}
|
|
int rh = std::max(h - ofs.width() - delta, 10);
|
|
w -= ofs.height();
|
|
|
|
_right.tabWidget->setRect(QRect(w - rect.width(), ofs.width(), rect.width(), rh));
|
|
|
|
if (_right.tabWidget->count() && _right.tabWidget->isVisible()
|
|
&& _right.tabWidget->getState() <= OverlayTabWidget::State::Normal) {
|
|
rectRight = _right.tabWidget->getRect();
|
|
}
|
|
|
|
rect = _top.tabWidget->getRect();
|
|
|
|
ofs = _top.tabWidget->getOffset();
|
|
delta = _top.tabWidget->getSizeDelta();
|
|
if (naviCorner == 0) {
|
|
rectLeft.setWidth(std::max(rectLeft.width(), paddedCubeSize));
|
|
}
|
|
else if (naviCorner == 1) {
|
|
rectRight.setWidth(std::max(rectRight.width(), paddedCubeSize));
|
|
}
|
|
int tw = w - rectLeft.width() - rectRight.width() - ofs.width() - delta;
|
|
|
|
_top.tabWidget->setRect(QRect(rectLeft.width() - ofs.width(), ofs.height(), tw, rect.height()));
|
|
}
|
|
|
|
void setOverlayMode(OverlayMode mode)
|
|
{
|
|
switch (mode) {
|
|
case OverlayManager::OverlayMode::DisableAll:
|
|
case OverlayManager::OverlayMode::EnableAll: {
|
|
auto docks = getMainWindow()->findChildren<QDockWidget*>();
|
|
// put visible dock widget first
|
|
std::sort(docks.begin(), docks.end(), [](const QDockWidget* a, const QDockWidget* b) {
|
|
return !a->visibleRegion().isEmpty() && b->visibleRegion().isEmpty();
|
|
});
|
|
for (auto dock : docks) {
|
|
if (mode == OverlayManager::OverlayMode::DisableAll) {
|
|
toggleOverlay(dock, ToggleMode::Unset);
|
|
}
|
|
else {
|
|
toggleOverlay(dock, ToggleMode::Set);
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
case OverlayManager::OverlayMode::ToggleAll:
|
|
for (auto o : _overlayInfos) {
|
|
if (o->tabWidget->count()) {
|
|
setOverlayMode(OverlayManager::OverlayMode::DisableAll);
|
|
return;
|
|
}
|
|
}
|
|
setOverlayMode(OverlayManager::OverlayMode::EnableAll);
|
|
return;
|
|
case OverlayManager::OverlayMode::TransparentAll: {
|
|
bool found = false;
|
|
for (auto o : _overlayInfos) {
|
|
if (o->tabWidget->count()) {
|
|
found = true;
|
|
}
|
|
}
|
|
if (!found) {
|
|
setOverlayMode(OverlayManager::OverlayMode::EnableAll);
|
|
}
|
|
}
|
|
// fall through
|
|
case OverlayManager::OverlayMode::TransparentNone:
|
|
for (auto o : _overlayInfos) {
|
|
o->tabWidget->setTransparent(mode == OverlayManager::OverlayMode::TransparentAll);
|
|
}
|
|
refresh();
|
|
return;
|
|
case OverlayManager::OverlayMode::ToggleTransparentAll:
|
|
for (auto o : _overlayInfos) {
|
|
if (o->tabWidget->count() && o->tabWidget->isTransparent()) {
|
|
setOverlayMode(OverlayManager::OverlayMode::TransparentNone);
|
|
return;
|
|
}
|
|
}
|
|
setOverlayMode(OverlayManager::OverlayMode::TransparentAll);
|
|
return;
|
|
case OverlayManager::OverlayMode::ToggleLeft:
|
|
if (OverlayTabWidget::_LeftOverlay->isVisible()) {
|
|
OverlayTabWidget::_LeftOverlay->setState(OverlayTabWidget::State::Hidden);
|
|
}
|
|
else {
|
|
OverlayTabWidget::_LeftOverlay->setState(OverlayTabWidget::State::Showing);
|
|
}
|
|
break;
|
|
case OverlayManager::OverlayMode::ToggleRight:
|
|
if (OverlayTabWidget::_RightOverlay->isVisible()) {
|
|
OverlayTabWidget::_RightOverlay->setState(OverlayTabWidget::State::Hidden);
|
|
}
|
|
else {
|
|
OverlayTabWidget::_RightOverlay->setState(OverlayTabWidget::State::Showing);
|
|
}
|
|
break;
|
|
case OverlayManager::OverlayMode::ToggleTop:
|
|
if (OverlayTabWidget::_TopOverlay->isVisible()) {
|
|
OverlayTabWidget::_TopOverlay->setState(OverlayTabWidget::State::Hidden);
|
|
}
|
|
else {
|
|
OverlayTabWidget::_TopOverlay->setState(OverlayTabWidget::State::Showing);
|
|
}
|
|
break;
|
|
case OverlayManager::OverlayMode::ToggleBottom:
|
|
if (OverlayTabWidget::_BottomOverlay->isVisible()) {
|
|
OverlayTabWidget::_BottomOverlay->setState(OverlayTabWidget::State::Hidden);
|
|
}
|
|
else {
|
|
OverlayTabWidget::_BottomOverlay->setState(OverlayTabWidget::State::Showing);
|
|
}
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
ToggleMode m;
|
|
QDockWidget* dock = nullptr;
|
|
for (auto w = qApp->widgetAt(QCursor::pos()); w; w = w->parentWidget()) {
|
|
dock = qobject_cast<QDockWidget*>(w);
|
|
if (dock) {
|
|
break;
|
|
}
|
|
auto tabWidget = qobject_cast<OverlayTabWidget*>(w);
|
|
if (tabWidget) {
|
|
dock = tabWidget->currentDockWidget();
|
|
if (dock) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if (!dock) {
|
|
for (auto w = qApp->focusWidget(); w; w = w->parentWidget()) {
|
|
dock = qobject_cast<QDockWidget*>(w);
|
|
if (dock) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
switch (mode) {
|
|
case OverlayManager::OverlayMode::ToggleActive:
|
|
m = ToggleMode::Toggle;
|
|
break;
|
|
case OverlayManager::OverlayMode::ToggleTransparent:
|
|
m = ToggleMode::Transparent;
|
|
break;
|
|
case OverlayManager::OverlayMode::EnableActive:
|
|
m = ToggleMode::Set;
|
|
break;
|
|
case OverlayManager::OverlayMode::DisableActive:
|
|
m = ToggleMode::Unset;
|
|
break;
|
|
default:
|
|
return;
|
|
}
|
|
toggleOverlay(dock, m);
|
|
}
|
|
|
|
void onToggleDockWidget(QDockWidget* dock, int checked)
|
|
{
|
|
if (!dock) {
|
|
return;
|
|
}
|
|
|
|
auto it = _overlayMap.find(dock);
|
|
if (it == _overlayMap.end()) {
|
|
return;
|
|
}
|
|
|
|
OverlayTabWidget* tabWidget = it->second->tabWidget;
|
|
int index = tabWidget->dockWidgetIndex(dock);
|
|
if (index < 0) {
|
|
return;
|
|
}
|
|
auto sizes = tabWidget->getSplitter()->sizes();
|
|
while (index >= sizes.size()) {
|
|
sizes.append(0);
|
|
}
|
|
|
|
if (checked < -1) {
|
|
checked = 0;
|
|
}
|
|
else if (checked == 3) {
|
|
checked = 1;
|
|
sizes[index] = 0; // force expand the tab in full
|
|
}
|
|
else if (checked <= 1) {
|
|
if (sizes[index] != 0 && tabWidget->isHidden()) {
|
|
checked = 1;
|
|
}
|
|
else {
|
|
// child widget inside splitter by right shouldn't been hidden, so
|
|
// we ignore the given toggle bit, but rely on its splitter size to
|
|
// decide.
|
|
checked = sizes[index] == 0 ? 1 : 0;
|
|
}
|
|
}
|
|
if (sizes[index] == 0) {
|
|
if (!checked) {
|
|
return;
|
|
}
|
|
tabWidget->setCurrent(dock);
|
|
tabWidget->onCurrentChanged(tabWidget->dockWidgetIndex(dock));
|
|
}
|
|
else if (!checked) {
|
|
if (sizes[index] > 0 && sizes.size() > 1) {
|
|
int newtotal = 0;
|
|
auto newsizes = sizes;
|
|
newsizes[index] = 0;
|
|
for (int i = 0; i < sizes.size(); ++i) {
|
|
if (i != index) {
|
|
auto d = tabWidget->dockWidget(i);
|
|
auto it = tabWidget->_sizemap.find(d);
|
|
if (it == tabWidget->_sizemap.end()) {
|
|
newsizes[i] = 0;
|
|
}
|
|
else {
|
|
if (newtotal == 0) {
|
|
tabWidget->setCurrent(d);
|
|
}
|
|
newsizes[i] = it->second;
|
|
newtotal += it->second;
|
|
}
|
|
}
|
|
}
|
|
if (!newtotal) {
|
|
int expand = 0;
|
|
for (int i = 0; i < sizes.size(); ++i) {
|
|
if (i != index && sizes[i] > 0) {
|
|
++expand;
|
|
break;
|
|
}
|
|
}
|
|
if (expand) {
|
|
int expansion = sizes[index];
|
|
int step = expansion / expand;
|
|
for (int i = 0; i < sizes.size(); ++i) {
|
|
if (i == index) {
|
|
newsizes[i] = 0;
|
|
}
|
|
else if (--expand) {
|
|
expansion -= step;
|
|
newsizes[i] += step;
|
|
}
|
|
else {
|
|
newsizes[i] += expansion;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
newsizes[index] = 0;
|
|
}
|
|
tabWidget->splitter->setSizes(newsizes);
|
|
tabWidget->saveTabs();
|
|
}
|
|
}
|
|
for (int i = 0; i < sizes.size(); ++i) {
|
|
if (sizes[i]) {
|
|
tabWidget->_sizemap[tabWidget->dockWidget(i)] = sizes[i];
|
|
}
|
|
}
|
|
if (checked) {
|
|
tabWidget->setRevealTime(
|
|
QTime::currentTime().addMSecs(OverlayParams::getDockOverlayRevealDelay())
|
|
);
|
|
}
|
|
refresh();
|
|
}
|
|
|
|
void onFocusChanged(QWidget*, QWidget*)
|
|
{
|
|
refresh();
|
|
}
|
|
|
|
void setupTitleBar(QDockWidget* dock)
|
|
{
|
|
if (!dock->titleBarWidget()) {
|
|
dock->setTitleBarWidget(createTitleBar(dock));
|
|
}
|
|
}
|
|
|
|
QWidget* createTitleBar(QWidget* parent)
|
|
{
|
|
OverlayTitleBar* widget = new OverlayTitleBar(parent);
|
|
widget->setObjectName(QStringLiteral("OverlayTitle"));
|
|
|
|
QList<QAction*> actions;
|
|
if (auto tabWidget = qobject_cast<OverlayTabWidget*>(parent)) {
|
|
actions = tabWidget->actions();
|
|
}
|
|
else if (auto dockWidget = qobject_cast<QDockWidget*>(parent)) {
|
|
const QDockWidget::DockWidgetFeatures features = dockWidget->features();
|
|
|
|
actions.append(&_actOverlay);
|
|
if (features.testFlag(QDockWidget::DockWidgetFloatable)) {
|
|
actions.append(&_actFloat);
|
|
}
|
|
if (features.testFlag(QDockWidget::DockWidgetClosable)) {
|
|
actions.append(&_actClose);
|
|
}
|
|
}
|
|
else {
|
|
actions = _actions;
|
|
}
|
|
|
|
widget->setTitleItem(OverlayTabWidget::prepareTitleWidget(widget, actions));
|
|
return widget;
|
|
}
|
|
|
|
void onAction(QAction* action)
|
|
{
|
|
if (action == &_actOverlay) {
|
|
OverlayManager::instance()->setOverlayMode(OverlayManager::OverlayMode::ToggleActive);
|
|
}
|
|
else if (action == &_actFloat || action == &_actClose) {
|
|
for (auto w = qApp->widgetAt(QCursor::pos()); w; w = w->parentWidget()) {
|
|
auto dock = qobject_cast<QDockWidget*>(w);
|
|
if (!dock) {
|
|
continue;
|
|
}
|
|
setFocusView();
|
|
if (action == &_actClose) {
|
|
dock->toggleViewAction()->activate(QAction::Trigger);
|
|
}
|
|
else {
|
|
auto it = _overlayMap.find(dock);
|
|
if (it != _overlayMap.end()) {
|
|
it->second->tabWidget->removeWidget(dock);
|
|
getMainWindow()->addDockWidget(it->second->dockArea, dock);
|
|
_overlayMap.erase(it);
|
|
dock->show();
|
|
dock->setFloating(true);
|
|
refresh();
|
|
}
|
|
else {
|
|
dock->setFloating(!dock->isFloating());
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
else {
|
|
auto tabWidget = qobject_cast<OverlayTabWidget*>(action->parent());
|
|
if (tabWidget) {
|
|
tabWidget->onAction(action);
|
|
}
|
|
}
|
|
}
|
|
|
|
void retranslate()
|
|
{
|
|
_actOverlay.setToolTip(QObject::tr("Toggle overlay"));
|
|
_actFloat.setToolTip(QObject::tr("Toggle floating window"));
|
|
_actClose.setToolTip(QObject::tr("Close dock window"));
|
|
}
|
|
|
|
void floatDockWidget(QDockWidget* dock)
|
|
{
|
|
setFocusView();
|
|
auto it = _overlayMap.find(dock);
|
|
if (it != _overlayMap.end()) {
|
|
it->second->tabWidget->removeWidget(dock);
|
|
_overlayMap.erase(it);
|
|
}
|
|
dock->setFloating(true);
|
|
dock->show();
|
|
}
|
|
|
|
// Warning, the caller may be deleted during the call. So do not pass
|
|
// parameter using reference, pass by value instead.
|
|
void dragDockWidget(QPoint pos, QWidget* srcWidget, QPoint dragOffset, QSize dragSize, bool drop)
|
|
{
|
|
if (!getMainWindow()) {
|
|
return;
|
|
}
|
|
auto mdi = getMainWindow()->getMdiArea();
|
|
if (!mdi) {
|
|
return;
|
|
}
|
|
|
|
auto dock = qobject_cast<QDockWidget*>(srcWidget);
|
|
if (dock && dock->isFloating()) {
|
|
dock->move(pos - dragOffset);
|
|
}
|
|
|
|
OverlayTabWidget* src = nullptr;
|
|
int srcIndex = -1;
|
|
if (dock) {
|
|
auto it = _overlayMap.find(dock);
|
|
if (it != _overlayMap.end()) {
|
|
src = it->second->tabWidget;
|
|
srcIndex = src->dockWidgetIndex(dock);
|
|
}
|
|
}
|
|
else {
|
|
src = qobject_cast<OverlayTabWidget*>(srcWidget);
|
|
if (!src) {
|
|
return;
|
|
}
|
|
for (int size : src->getSplitter()->sizes()) {
|
|
++srcIndex;
|
|
if (size) {
|
|
dock = src->dockWidget(srcIndex);
|
|
break;
|
|
}
|
|
}
|
|
if (!dock) {
|
|
return;
|
|
}
|
|
}
|
|
|
|
OverlayTabWidget* tabWidget = nullptr;
|
|
int resizeOffset = 0;
|
|
int index = -1;
|
|
QRect rect;
|
|
QRect rectMain(getMainWindow()->mapToGlobal(QPoint()), getMainWindow()->size());
|
|
QRect rectMdi(mdi->mapToGlobal(QPoint()), mdi->size());
|
|
|
|
for (OverlayTabWidget* overlay : _Overlays) {
|
|
rect = QRect(mdi->mapToGlobal(overlay->rectOverlay.topLeft()), overlay->rectOverlay.size());
|
|
|
|
QSize size(rect.width() * 3 / 4, rect.height() * 3 / 4);
|
|
QSize sideSize(rect.width() / 4, rect.height() / 4);
|
|
|
|
int dockArea = overlay->getDockArea();
|
|
|
|
if (dockArea == Qt::BottomDockWidgetArea) {
|
|
if (pos.y() < rect.bottom() && rect.bottom() - pos.y() < sideSize.height()) {
|
|
rect.setTop(rect.bottom() - OverlayParams::getDockOverlayMinimumSize());
|
|
rect.setBottom(rectMain.bottom());
|
|
rect.setLeft(rectMdi.left());
|
|
rect.setRight(rectMdi.right());
|
|
tabWidget = overlay;
|
|
index = -2;
|
|
break;
|
|
}
|
|
}
|
|
if (dockArea == Qt::LeftDockWidgetArea) {
|
|
if (pos.x() >= rect.left() && pos.x() - rect.left() < sideSize.width()) {
|
|
rect.setRight(rect.left() + OverlayParams::getDockOverlayMinimumSize());
|
|
rect.setLeft(rectMain.left());
|
|
rect.setTop(rectMdi.top());
|
|
rect.setBottom(rectMdi.bottom());
|
|
tabWidget = overlay;
|
|
index = -2;
|
|
break;
|
|
}
|
|
}
|
|
else if (dockArea == Qt::RightDockWidgetArea) {
|
|
if (pos.x() < rect.right() && rect.right() - pos.x() < sideSize.width()) {
|
|
rect.setLeft(rect.right() - OverlayParams::getDockOverlayMinimumSize());
|
|
rect.setRight(rectMain.right());
|
|
rect.setTop(rectMdi.top());
|
|
rect.setBottom(rectMdi.bottom());
|
|
tabWidget = overlay;
|
|
index = -2;
|
|
break;
|
|
}
|
|
}
|
|
else if (dockArea == Qt::TopDockWidgetArea) {
|
|
if (pos.y() >= rect.top() && pos.y() - rect.top() < sideSize.height()) {
|
|
rect.setBottom(rect.top() + OverlayParams::getDockOverlayMinimumSize());
|
|
rect.setTop(rectMain.top());
|
|
rect.setLeft(rectMdi.left());
|
|
rect.setRight(rectMdi.right());
|
|
tabWidget = overlay;
|
|
index = -2;
|
|
break;
|
|
}
|
|
}
|
|
|
|
switch (dockArea) {
|
|
case Qt::LeftDockWidgetArea:
|
|
rect.setWidth(size.width());
|
|
break;
|
|
case Qt::RightDockWidgetArea:
|
|
rect.setLeft(rect.right() - size.width());
|
|
break;
|
|
case Qt::TopDockWidgetArea:
|
|
rect.setHeight(size.height());
|
|
break;
|
|
default:
|
|
rect.setTop(rect.bottom() - size.height());
|
|
break;
|
|
}
|
|
|
|
if (!rect.contains(pos)) {
|
|
continue;
|
|
}
|
|
|
|
tabWidget = overlay;
|
|
index = -1;
|
|
int i = -1;
|
|
|
|
for (int size : overlay->getSplitter()->sizes()) {
|
|
++i;
|
|
auto handle = overlay->getSplitter()->handle(i);
|
|
QWidget* w = overlay->dockWidget(i);
|
|
if (!handle || !w) {
|
|
continue;
|
|
}
|
|
if (handle->rect().contains(handle->mapFromGlobal(pos))) {
|
|
QPoint pt = handle->mapToGlobal(QPoint());
|
|
QSize s = handle->size();
|
|
if (!size) {
|
|
size = OverlayParams::getDockOverlayMinimumSize();
|
|
}
|
|
if (tabWidget != src) {
|
|
size /= 2;
|
|
}
|
|
if (overlay->getSplitter()->orientation() == Qt::Vertical) {
|
|
s.setHeight(s.height() + size);
|
|
}
|
|
else {
|
|
s.setWidth(s.width() + size);
|
|
}
|
|
rect = QRect(pt, s);
|
|
index = i;
|
|
break;
|
|
}
|
|
if (!size) {
|
|
continue;
|
|
}
|
|
if (w->rect().contains(w->mapFromGlobal(pos))) {
|
|
QPoint pt = overlay->getSplitter()->mapToGlobal(w->pos());
|
|
rect = QRect(pt, w->size());
|
|
if (tabWidget != src) {
|
|
if (overlay->getSplitter()->orientation() == Qt::Vertical) {
|
|
if (pos.y() > pt.y() + size / 2) {
|
|
rect.setTop(rect.top() + size / 2);
|
|
resizeOffset = -1;
|
|
++i;
|
|
}
|
|
else {
|
|
rect.setHeight(size / 2);
|
|
}
|
|
}
|
|
else if (pos.x() > pt.x() + size / 2) {
|
|
rect.setLeft(rect.left() + size / 2);
|
|
resizeOffset = -1;
|
|
++i;
|
|
}
|
|
else {
|
|
rect.setWidth(size / 2);
|
|
}
|
|
}
|
|
index = i;
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
};
|
|
|
|
OverlayTabWidget* dst = nullptr;
|
|
int dstIndex = -1;
|
|
QDockWidget* dstDock = nullptr;
|
|
Qt::DockWidgetArea dstDockArea {};
|
|
|
|
if (!tabWidget) {
|
|
rect = QRect(pos - dragOffset, dragSize);
|
|
if (rect.width() < 50) {
|
|
rect.setWidth(50);
|
|
}
|
|
if (rect.height() < 50) {
|
|
rect.setHeight(50);
|
|
}
|
|
|
|
for (auto dockWidget : getMainWindow()->findChildren<QDockWidget*>()) {
|
|
if (dockWidget == dock || !dockWidget->isVisible() || dockWidget->isFloating()
|
|
|| _overlayMap.contains(dockWidget)) {
|
|
continue;
|
|
}
|
|
if (dockWidget->rect().contains(dockWidget->mapFromGlobal(pos))) {
|
|
dstDock = dockWidget;
|
|
dstDockArea = getMainWindow()->dockWidgetArea(dstDock);
|
|
rect = QRect(dockWidget->mapToGlobal(QPoint()), dockWidget->size());
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
dst = tabWidget;
|
|
dstIndex = index;
|
|
if (dstIndex == -1) {
|
|
rect = QRect(
|
|
mdi->mapToGlobal(tabWidget->rectOverlay.topLeft()),
|
|
tabWidget->rectOverlay.size()
|
|
);
|
|
}
|
|
}
|
|
|
|
bool outside = false;
|
|
if (!rectMain.contains(pos)) {
|
|
outside = true;
|
|
if (drop) {
|
|
if (!dock->isFloating()) {
|
|
if (src) {
|
|
_overlayMap.erase(dock);
|
|
src->removeWidget(dock);
|
|
}
|
|
setFocusView();
|
|
dock->setFloating(true);
|
|
dock->move(pos - dragOffset);
|
|
dock->show();
|
|
}
|
|
if (OverlayTabWidget::_DragFloating) {
|
|
OverlayTabWidget::_DragFloating->hide();
|
|
}
|
|
}
|
|
else if (!dock->isFloating()) {
|
|
if (!OverlayTabWidget::_DragFloating) {
|
|
OverlayTabWidget::_DragFloating = new QDockWidget(getMainWindow());
|
|
OverlayTabWidget::_DragFloating->setFloating(true);
|
|
}
|
|
OverlayTabWidget::_DragFloating->resize(dock->size());
|
|
OverlayTabWidget::_DragFloating->setWindowTitle(dock->windowTitle());
|
|
OverlayTabWidget::_DragFloating->show();
|
|
OverlayTabWidget::_DragFloating->move(pos - dragOffset);
|
|
}
|
|
if (OverlayTabWidget::_DragFrame) {
|
|
OverlayTabWidget::_DragFrame->hide();
|
|
}
|
|
return;
|
|
}
|
|
else if (!drop && OverlayTabWidget::_DragFrame && !OverlayTabWidget::_DragFrame->isVisible()) {
|
|
OverlayTabWidget::_DragFrame->raise();
|
|
OverlayTabWidget::_DragFrame->show();
|
|
if (OverlayTabWidget::_DragFloating) {
|
|
OverlayTabWidget::_DragFloating->hide();
|
|
}
|
|
}
|
|
|
|
int insertDock = 0; // 0: tabify, -1: insert before, 1: insert after
|
|
if (!dst && dstDock) {
|
|
switch (dstDockArea) {
|
|
case Qt::LeftDockWidgetArea:
|
|
case Qt::RightDockWidgetArea:
|
|
if (pos.y() < rect.top() + rect.height() / 4) {
|
|
insertDock = -1;
|
|
rect.setBottom(rect.top() + rect.height() / 2);
|
|
}
|
|
else if (pos.y() > rect.bottom() - rect.height() / 4) {
|
|
insertDock = 1;
|
|
int height = rect.height();
|
|
rect.setTop(rect.bottom() - height / 4);
|
|
rect.setHeight(height / 2);
|
|
}
|
|
break;
|
|
default:
|
|
if (pos.x() < rect.left() + rect.width() / 4) {
|
|
insertDock = -1;
|
|
rect.setRight(rect.left() + rect.width() / 2);
|
|
}
|
|
else if (pos.x() > rect.right() - rect.width() / 4) {
|
|
insertDock = 1;
|
|
int width = rect.width();
|
|
rect.setLeft(rect.right() - width / 4);
|
|
rect.setWidth(width / 2);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!drop) {
|
|
if (!OverlayTabWidget::_DragFrame) {
|
|
OverlayTabWidget::_DragFrame = new OverlayDragFrame(getMainWindow());
|
|
}
|
|
|
|
rect = QRect(getMainWindow()->mapFromGlobal(rect.topLeft()), rect.size());
|
|
OverlayTabWidget::_DragFrame->setGeometry(rect);
|
|
if (!outside && !OverlayTabWidget::_DragFrame->isVisible()) {
|
|
OverlayTabWidget::_DragFrame->raise();
|
|
OverlayTabWidget::_DragFrame->show();
|
|
}
|
|
return;
|
|
}
|
|
|
|
if (src && src == dst && dstIndex != -2) {
|
|
auto splitter = src->getSplitter();
|
|
if (dstIndex == -1) {
|
|
src->tabBar()->moveTab(srcIndex, 0);
|
|
src->setCurrentIndex(0);
|
|
src->onCurrentChanged(0);
|
|
}
|
|
else if (srcIndex != dstIndex) {
|
|
auto sizes = splitter->sizes();
|
|
src->tabBar()->moveTab(srcIndex, dstIndex);
|
|
splitter->setSizes(sizes);
|
|
src->onSplitterResize(dstIndex);
|
|
src->saveTabs();
|
|
}
|
|
return;
|
|
}
|
|
|
|
if (src) {
|
|
_overlayMap.erase(dock);
|
|
src->removeWidget(dock);
|
|
}
|
|
|
|
setFocusView();
|
|
if (!dst) {
|
|
if (dstDock) {
|
|
dock->setFloating(false);
|
|
if (insertDock == 0) {
|
|
getMainWindow()->tabifyDockWidget(dstDock, dock);
|
|
}
|
|
else {
|
|
std::map<int, QDockWidget*> docks;
|
|
for (auto dockWidget : getMainWindow()->findChildren<QDockWidget*>()) {
|
|
if (dockWidget == dock || !dockWidget->isVisible()
|
|
|| getMainWindow()->dockWidgetArea(dockWidget) != dstDockArea) {
|
|
continue;
|
|
}
|
|
auto pos = dockWidget->mapToGlobal(QPoint(0, 0));
|
|
if (dstDockArea == Qt::LeftDockWidgetArea
|
|
|| dstDockArea == Qt::RightDockWidgetArea) {
|
|
docks[pos.y()] = dockWidget;
|
|
}
|
|
else {
|
|
docks[pos.x()] = dockWidget;
|
|
}
|
|
}
|
|
auto it = docks.begin();
|
|
for (; it != docks.end(); ++it) {
|
|
if (it->second == dstDock) {
|
|
break;
|
|
}
|
|
}
|
|
if (insertDock > 0 && it != docks.end()) {
|
|
++it;
|
|
}
|
|
for (auto iter = it; iter != docks.end(); ++iter) {
|
|
getMainWindow()->removeDockWidget(iter->second);
|
|
}
|
|
getMainWindow()->addDockWidget(dstDockArea, dock);
|
|
dock->show();
|
|
for (auto iter = it; iter != docks.end(); ++iter) {
|
|
getMainWindow()->addDockWidget(dstDockArea, iter->second);
|
|
iter->second->show();
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
dock->setFloating(true);
|
|
if (OverlayTabWidget::_DragFrame) {
|
|
dock->setGeometry(QRect(
|
|
OverlayTabWidget::_DragFrame->mapToGlobal(QPoint()),
|
|
OverlayTabWidget::_DragFrame->size()
|
|
));
|
|
}
|
|
}
|
|
dock->show();
|
|
}
|
|
else if (dstIndex == -2) {
|
|
getMainWindow()->addDockWidget(dst->getDockArea(), dock);
|
|
dock->setFloating(false);
|
|
}
|
|
else {
|
|
auto sizes = dst->getSplitter()->sizes();
|
|
for (auto o : _overlayInfos) {
|
|
if (o->tabWidget == dst) {
|
|
o->addWidget(dock, false);
|
|
break;
|
|
}
|
|
}
|
|
index = dst->dockWidgetIndex(dock);
|
|
if (index >= 0) {
|
|
if (dstIndex < 0) {
|
|
dst->tabBar()->moveTab(index, 0);
|
|
dst->setCurrentIndex(0);
|
|
dst->onCurrentChanged(0);
|
|
}
|
|
else {
|
|
dst->tabBar()->moveTab(index, dstIndex);
|
|
int size = sizes[dstIndex + resizeOffset];
|
|
if (size) {
|
|
size /= 2;
|
|
sizes[dstIndex + resizeOffset] = size;
|
|
}
|
|
else {
|
|
size = 50;
|
|
}
|
|
sizes.insert(dstIndex, size);
|
|
dst->setCurrentIndex(dstIndex);
|
|
dst->getSplitter()->setSizes(sizes);
|
|
dst->onSplitterResize(dstIndex);
|
|
dst->saveTabs();
|
|
}
|
|
dst->setRevealTime(
|
|
QTime::currentTime().addMSecs(OverlayParams::getDockOverlayRevealDelay())
|
|
);
|
|
}
|
|
}
|
|
|
|
refresh();
|
|
}
|
|
|
|
void raiseAll()
|
|
{
|
|
if (raising) {
|
|
return;
|
|
}
|
|
Base::StateLocker guard(raising);
|
|
for (OverlayTabWidget* tabWidget : _Overlays) {
|
|
if (tabWidget->isVisible()) {
|
|
tabWidget->raise();
|
|
}
|
|
}
|
|
}
|
|
|
|
void registerDockWidget(const QString& name, OverlayTabWidget* widget)
|
|
{
|
|
if (name.size()) {
|
|
_dockWidgetNameMap[name] = widget;
|
|
}
|
|
}
|
|
|
|
void unregisterDockWidget(const QString& name, OverlayTabWidget* widget)
|
|
{
|
|
auto it = _dockWidgetNameMap.find(name);
|
|
if (it != _dockWidgetNameMap.end() && it->second == widget) {
|
|
_dockWidgetNameMap.erase(it);
|
|
}
|
|
}
|
|
|
|
void reload(OverlayManager::ReloadMode mode)
|
|
{
|
|
if (mode == OverlayManager::ReloadMode::ReloadResume) {
|
|
curReloadMode = mode = OverlayManager::ReloadMode::ReloadPending;
|
|
}
|
|
if (mode == OverlayManager::ReloadMode::ReloadPending) {
|
|
if (curReloadMode != OverlayManager::ReloadMode::ReloadPause) {
|
|
FC_LOG("reload pending");
|
|
_reloadTimer.start(100);
|
|
}
|
|
}
|
|
curReloadMode = mode;
|
|
if (mode == OverlayManager::ReloadMode::ReloadPause) {
|
|
FC_LOG("reload paused");
|
|
_reloadTimer.stop();
|
|
}
|
|
}
|
|
};
|
|
|
|
|
|
static OverlayManager* _instance;
|
|
|
|
OverlayManager* OverlayManager::instance()
|
|
{
|
|
if (_instance == 0) {
|
|
_instance = new OverlayManager;
|
|
}
|
|
return _instance;
|
|
}
|
|
|
|
void OverlayManager::destruct()
|
|
{
|
|
delete _instance;
|
|
_instance = 0;
|
|
}
|
|
|
|
OverlayManager::OverlayManager()
|
|
{
|
|
d = new Private(this, getMainWindow());
|
|
qApp->installEventFilter(this);
|
|
}
|
|
|
|
OverlayManager::~OverlayManager()
|
|
{
|
|
delete d;
|
|
}
|
|
|
|
void OverlayManager::setOverlayMode(OverlayMode mode)
|
|
{
|
|
d->setOverlayMode(mode);
|
|
}
|
|
|
|
|
|
void OverlayManager::initDockWidget(QDockWidget* dw)
|
|
{
|
|
QObject::connect(dw->toggleViewAction(), &QAction::triggered, this, &OverlayManager::onToggleDockWidget);
|
|
QObject::connect(dw, &QDockWidget::visibilityChanged, this, &OverlayManager::onDockVisibleChange);
|
|
QObject::connect(dw, &QDockWidget::featuresChanged, this, &OverlayManager::onDockFeaturesChange);
|
|
if (auto widget = dw->widget()) {
|
|
QObject::connect(
|
|
widget,
|
|
&QWidget::windowTitleChanged,
|
|
this,
|
|
&OverlayManager::onDockWidgetTitleChange
|
|
);
|
|
}
|
|
|
|
QString name = dw->objectName();
|
|
if (name.size()) {
|
|
auto it = d->_dockWidgetNameMap.find(dw->objectName());
|
|
if (it != d->_dockWidgetNameMap.end()) {
|
|
for (auto o : d->_overlayInfos) {
|
|
if (o->tabWidget == it->second) {
|
|
o->addWidget(dw, true);
|
|
d->onToggleDockWidget(dw, 3);
|
|
break;
|
|
}
|
|
}
|
|
d->refresh();
|
|
}
|
|
}
|
|
}
|
|
|
|
void OverlayManager::setupDockWidget(QDockWidget* dw, int dockArea)
|
|
{
|
|
(void)dockArea;
|
|
d->setupTitleBar(dw);
|
|
}
|
|
|
|
void OverlayManager::unsetupDockWidget(QDockWidget* dw)
|
|
{
|
|
d->toggleOverlay(dw, ToggleMode::Unset);
|
|
}
|
|
|
|
void OverlayManager::onToggleDockWidget(bool checked)
|
|
{
|
|
auto action = qobject_cast<QAction*>(sender());
|
|
if (!action) {
|
|
return;
|
|
}
|
|
d->onToggleDockWidget(qobject_cast<QDockWidget*>(action->parent()), checked);
|
|
}
|
|
|
|
void OverlayManager::onDockVisibleChange(bool visible)
|
|
{
|
|
auto dock = qobject_cast<QDockWidget*>(sender());
|
|
if (!dock) {
|
|
return;
|
|
}
|
|
FC_TRACE(
|
|
"dock " << dock->objectName().toUtf8().constData() << " visible change " << visible << ", "
|
|
<< dock->isVisible()
|
|
);
|
|
}
|
|
|
|
void OverlayManager::onDockFeaturesChange(QDockWidget::DockWidgetFeatures features)
|
|
{
|
|
Q_UNUSED(features);
|
|
|
|
auto dw = qobject_cast<QDockWidget*>(sender());
|
|
|
|
if (!dw) {
|
|
return;
|
|
}
|
|
|
|
// Rebuild the title widget as it may have a different set of buttons shown.
|
|
if (auto* titleBarWidget = qobject_cast<OverlayTitleBar*>(dw->titleBarWidget())) {
|
|
dw->setTitleBarWidget(nullptr);
|
|
delete titleBarWidget;
|
|
}
|
|
|
|
setupTitleBar(dw);
|
|
}
|
|
|
|
void OverlayManager::onTaskViewUpdate()
|
|
{
|
|
auto taskview = qobject_cast<TaskView::TaskView*>(sender());
|
|
if (!taskview) {
|
|
return;
|
|
}
|
|
QDockWidget* dock = nullptr;
|
|
for (QWidget* w = taskview; w; w = w->parentWidget()) {
|
|
if ((dock = qobject_cast<QDockWidget*>(w))) {
|
|
break;
|
|
}
|
|
}
|
|
if (dock) {
|
|
auto it = d->_overlayMap.find(dock);
|
|
if (it == d->_overlayMap.end() || it->second->tabWidget->count() < 2
|
|
|| it->second->tabWidget->getAutoMode() != OverlayTabWidget::AutoMode::TaskShow) {
|
|
return;
|
|
}
|
|
d->onToggleDockWidget(dock, taskview->isEmpty() ? -2 : 2);
|
|
}
|
|
}
|
|
|
|
void OverlayManager::onDockWidgetTitleChange(const QString& title)
|
|
{
|
|
if (title.isEmpty()) {
|
|
return;
|
|
}
|
|
auto widget = qobject_cast<QWidget*>(sender());
|
|
QDockWidget* dock = nullptr;
|
|
for (QWidget* w = widget; w; w = w->parentWidget()) {
|
|
if ((dock = qobject_cast<QDockWidget*>(w))) {
|
|
break;
|
|
}
|
|
}
|
|
if (!dock) {
|
|
return;
|
|
}
|
|
auto tabWidget = findTabWidget(dock);
|
|
if (!tabWidget) {
|
|
return;
|
|
}
|
|
int index = tabWidget->dockWidgetIndex(dock);
|
|
if (index >= 0) {
|
|
tabWidget->setTabText(index, title);
|
|
}
|
|
}
|
|
|
|
void OverlayManager::retranslate()
|
|
{
|
|
d->retranslate();
|
|
}
|
|
|
|
void OverlayManager::refreshIcons()
|
|
{
|
|
d->refreshIcons();
|
|
}
|
|
|
|
void OverlayManager::reload(ReloadMode mode)
|
|
{
|
|
d->reload(mode);
|
|
}
|
|
|
|
void OverlayManager::raiseAll()
|
|
{
|
|
d->raiseAll();
|
|
}
|
|
|
|
static inline bool isNear(const QPoint& a, const QPoint& b, int tol = 16)
|
|
{
|
|
QPoint d = a - b;
|
|
return d.x() * d.x() + d.y() * d.y() < tol;
|
|
}
|
|
|
|
bool OverlayManager::eventFilter(QObject* o, QEvent* ev)
|
|
{
|
|
if (d->intercepting || !getMainWindow() || !o->isWidgetType()) {
|
|
return false;
|
|
}
|
|
auto mdi = getMainWindow()->getMdiArea();
|
|
if (!mdi) {
|
|
return false;
|
|
}
|
|
|
|
switch (ev->type()) {
|
|
case QEvent::Enter:
|
|
if (Selection().hasPreselection() && !qobject_cast<View3DInventorViewer*>(o)
|
|
&& !isUnderOverlay()) {
|
|
Selection().rmvPreselect();
|
|
}
|
|
break;
|
|
case QEvent::ZOrderChange: {
|
|
if (!d->raising && getMainWindow() && o == mdi) {
|
|
// On Windows, for some reason, it will raise mdi window on tab
|
|
// change in any docked widget, which will then obscure any overlay
|
|
// docked widget here.
|
|
for (auto child : getMainWindow()->children()) {
|
|
if (child == mdi || qobject_cast<QDockWidget*>(child)) {
|
|
QMetaObject::invokeMethod(this, "raiseAll", Qt::QueuedConnection);
|
|
break;
|
|
}
|
|
if (qobject_cast<OverlayTabWidget*>(child)) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
case QEvent::Resize: {
|
|
if (getMainWindow() && o == mdi) {
|
|
refresh();
|
|
}
|
|
return false;
|
|
}
|
|
case QEvent::KeyPress: {
|
|
QKeyEvent* ke = static_cast<QKeyEvent*>(ev);
|
|
bool accepted = false;
|
|
if (ke->modifiers() == Qt::NoModifier && ke->key() == Qt::Key_Escape) {
|
|
if (d->mouseTransparent) {
|
|
d->setMouseTransparent(false);
|
|
accepted = true;
|
|
}
|
|
else if (OverlayTabWidget::_Dragging && OverlayTabWidget::_Dragging != o) {
|
|
if (auto titleBar = qobject_cast<OverlayTitleBar*>(OverlayTabWidget::_Dragging)) {
|
|
titleBar->endDrag();
|
|
}
|
|
else if (auto splitHandle
|
|
= qobject_cast<OverlaySplitterHandle*>(OverlayTabWidget::_Dragging)) {
|
|
splitHandle->endDrag();
|
|
}
|
|
}
|
|
else if (!OverlayTabWidget::_Dragging) {
|
|
for (OverlayTabWidget* tabWidget : _Overlays) {
|
|
if (tabWidget->onEscape()) {
|
|
accepted = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (accepted) {
|
|
ke->accept();
|
|
return true;
|
|
}
|
|
break;
|
|
}
|
|
case QEvent::Paint:
|
|
if (auto widget = qobject_cast<QWidget*>(o)) {
|
|
// QAbstractItemView optimize redraw using its item delegate's
|
|
// visualRect(). However, if we are using QGraphicsEffects, the
|
|
// effect may touch areas outside of visualRect(), so
|
|
// OverlayTabWidget offers a timer for a delayed redraw.
|
|
widget = qobject_cast<QAbstractItemView*>(widget->parentWidget());
|
|
if (widget) {
|
|
auto tabWidget = findTabWidget(widget, true);
|
|
if (tabWidget) {
|
|
tabWidget->scheduleRepaint();
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
// case QEvent::NativeGesture:
|
|
case QEvent::Wheel:
|
|
if (!OverlayParams::getDockOverlayWheelPassThrough()) {
|
|
return false;
|
|
}
|
|
// fall through
|
|
case QEvent::ContextMenu: {
|
|
auto cev = static_cast<QContextMenuEvent*>(ev);
|
|
if (cev->reason() != QContextMenuEvent::Mouse) {
|
|
return false;
|
|
}
|
|
} // fall through
|
|
case QEvent::MouseButtonDblClick:
|
|
case QEvent::MouseButtonRelease:
|
|
case QEvent::MouseButtonPress:
|
|
case QEvent::MouseMove: {
|
|
if (OverlayTabWidget::_Dragging && OverlayTabWidget::_Dragging != o) {
|
|
if (auto titleBar = qobject_cast<OverlayTitleBar*>(OverlayTabWidget::_Dragging)) {
|
|
titleBar->endDrag();
|
|
}
|
|
else if (auto splitHandle
|
|
= qobject_cast<OverlaySplitterHandle*>(OverlayTabWidget::_Dragging)) {
|
|
splitHandle->endDrag();
|
|
}
|
|
}
|
|
QWidget* grabber = QWidget::mouseGrabber();
|
|
d->lastIntercept = nullptr;
|
|
if (d->mouseTransparent || (grabber && grabber != d->_trackingOverlay)) {
|
|
return false;
|
|
}
|
|
if (qobject_cast<QAbstractButton*>(o)) {
|
|
return false;
|
|
}
|
|
if (ev->type() != QEvent::Wheel) {
|
|
if (qobject_cast<OverlayTitleBar*>(o)) {
|
|
return false;
|
|
}
|
|
}
|
|
else if (qobject_cast<QScrollBar*>(o)) {
|
|
return false;
|
|
}
|
|
|
|
if (d->_trackingWidget) {
|
|
if (!isTreeViewDragging()) {
|
|
d->interceptEvent(d->_trackingWidget, ev);
|
|
}
|
|
if (isTreeViewDragging()
|
|
|| (ev->type() == QEvent::MouseButtonRelease
|
|
&& QApplication::mouseButtons() == Qt::NoButton)) {
|
|
d->_trackingWidget = nullptr;
|
|
if (d->_trackingOverlay == grabber && ev->type() == QEvent::MouseButtonRelease) {
|
|
d->_trackingOverlay = nullptr;
|
|
// Must not release mouse here, because otherwise the event
|
|
// will find its way to the actual widget under cursor.
|
|
// Instead, return false here to let OverlayTabWidget::event()
|
|
// release the mouse.
|
|
return false;
|
|
}
|
|
if (d->_trackingOverlay && grabber == d->_trackingOverlay) {
|
|
d->_trackingOverlay->releaseMouse();
|
|
}
|
|
d->_trackingOverlay = nullptr;
|
|
}
|
|
// Must return true here to filter the event, otherwise ContextMenu
|
|
// event may be routed to the actual widget. Other types of event
|
|
// probably do not matter.
|
|
return true;
|
|
}
|
|
else if (ev->type() != QEvent::MouseButtonPress && ev->type() != QEvent::MouseButtonDblClick
|
|
&& QApplication::mouseButtons() != Qt::NoButton) {
|
|
return false;
|
|
}
|
|
|
|
if (isTreeViewDragging()) {
|
|
return false;
|
|
}
|
|
|
|
OverlayTabWidget* activeTabWidget = nullptr;
|
|
int hit = 0;
|
|
QPoint pos = QCursor::pos();
|
|
if (OverlayParams::getDockOverlayAutoMouseThrough() && ev->type() != QEvent::Wheel
|
|
&& pos == d->_lastPos) {
|
|
hit = 1;
|
|
}
|
|
else if (ev->type() == QEvent::Wheel && !d->wheelDelay.isNull()
|
|
&& (isNear(pos, d->wheelPos) || d->wheelDelay > QTime::currentTime())) {
|
|
d->wheelDelay = QTime::currentTime().addMSecs(
|
|
OverlayParams::getDockOverlayWheelDelay()
|
|
);
|
|
d->wheelPos = pos;
|
|
return false;
|
|
}
|
|
else {
|
|
for (auto widget = qApp->widgetAt(pos); widget; widget = widget->parentWidget()) {
|
|
int type = widget->windowType();
|
|
if (type != Qt::Widget && type != Qt::Window) {
|
|
if (type != Qt::SubWindow) {
|
|
hit = -1;
|
|
}
|
|
break;
|
|
}
|
|
if (ev->type() == QEvent::Wheel) {
|
|
if (qobject_cast<OverlayTitleBar*>(widget)) {
|
|
activeTabWidget = qobject_cast<OverlayTabWidget*>(widget->parentWidget());
|
|
}
|
|
else if (qobject_cast<OverlaySplitterHandle*>(widget)) {
|
|
auto parent = widget->parentWidget();
|
|
if (parent) {
|
|
activeTabWidget = qobject_cast<OverlayTabWidget*>(
|
|
parent->parentWidget()
|
|
);
|
|
}
|
|
}
|
|
if (activeTabWidget) {
|
|
break;
|
|
}
|
|
}
|
|
if (auto tabWidget = qobject_cast<OverlayTabWidget*>(widget)) {
|
|
if (tabWidget->testAlpha(pos, ev->type() == QEvent::Wheel ? 4 : 1) == 0) {
|
|
activeTabWidget = tabWidget;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
if (activeTabWidget) {
|
|
hit = OverlayParams::getDockOverlayAutoMouseThrough();
|
|
d->_lastPos = pos;
|
|
}
|
|
}
|
|
|
|
for (OverlayTabWidget* tabWidget : _Overlays) {
|
|
if (tabWidget->getProxyWidget()->hitTest(pos)
|
|
== OverlayProxyWidget::HitTest::HitInner) {
|
|
if ((ev->type() == QEvent::MouseButtonRelease
|
|
|| ev->type() == QEvent::MouseButtonPress)
|
|
&& static_cast<QMouseEvent*>(ev)->button() == Qt::LeftButton) {
|
|
if (ev->type() == QEvent::MouseButtonRelease) {
|
|
tabWidget->getProxyWidget()->onMousePress();
|
|
}
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (hit <= 0) {
|
|
d->_lastPos.setX(std::numeric_limits<int>::max());
|
|
if (ev->type() == QEvent::Wheel) {
|
|
d->wheelDelay = QTime::currentTime().addMSecs(
|
|
OverlayParams::getDockOverlayWheelDelay()
|
|
);
|
|
d->wheelPos = pos;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
auto hitWidget = mdi->childAt(mdi->mapFromGlobal(pos));
|
|
if (!hitWidget) {
|
|
return false;
|
|
}
|
|
|
|
if (!activeTabWidget) {
|
|
activeTabWidget = findTabWidget(qApp->widgetAt(QCursor::pos()));
|
|
}
|
|
if (!activeTabWidget || !activeTabWidget->isTransparent()) {
|
|
return false;
|
|
}
|
|
|
|
ev->accept();
|
|
d->interceptEvent(hitWidget, ev);
|
|
if (ev->isAccepted() && ev->type() == QEvent::MouseButtonPress) {
|
|
hitWidget->setFocus();
|
|
d->_trackingWidget = hitWidget;
|
|
d->_trackingOverlay = activeTabWidget;
|
|
d->_trackingOverlay->grabMouse();
|
|
}
|
|
return true;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
namespace
|
|
{
|
|
class MouseGrabberGuard
|
|
{
|
|
public:
|
|
explicit MouseGrabberGuard(QWidget* grabber)
|
|
{
|
|
if (grabber && grabber == QWidget::mouseGrabber()) {
|
|
_grabber = grabber;
|
|
_grabber->releaseMouse();
|
|
}
|
|
}
|
|
~MouseGrabberGuard()
|
|
{
|
|
if (_grabber) {
|
|
_grabber->grabMouse();
|
|
}
|
|
}
|
|
|
|
QPointer<QWidget> _grabber;
|
|
};
|
|
} // anonymous namespace
|
|
|
|
void OverlayManager::Private::interceptEvent(QWidget* widget, QEvent* ev)
|
|
{
|
|
Base::StateLocker guard(this->intercepting);
|
|
MouseGrabberGuard grabberGuard(_trackingOverlay);
|
|
|
|
lastIntercept = nullptr;
|
|
auto getChildAt = [](QWidget* w, const QPoint& pos) {
|
|
QWidget* res = w;
|
|
for (; w; w = w->childAt(w->mapFromGlobal(pos))) {
|
|
if (auto scrollArea = qobject_cast<QAbstractScrollArea*>(w)) {
|
|
return scrollArea->viewport();
|
|
}
|
|
res = w;
|
|
}
|
|
return res;
|
|
};
|
|
|
|
switch (ev->type()) {
|
|
case QEvent::MouseButtonRelease:
|
|
case QEvent::MouseButtonPress:
|
|
case QEvent::MouseMove:
|
|
case QEvent::MouseButtonDblClick: {
|
|
auto me = static_cast<QMouseEvent*>(ev);
|
|
#if QT_VERSION < QT_VERSION_CHECK(6, 0, 0)
|
|
QPointF screenPos = me->screenPos();
|
|
QPoint point = me->globalPos();
|
|
#else
|
|
QPointF screenPos = me->globalPosition();
|
|
QPoint point = screenPos.toPoint();
|
|
#endif
|
|
lastIntercept = getChildAt(widget, point);
|
|
QMouseEvent mouseEvent(
|
|
ev->type(),
|
|
lastIntercept->mapFromGlobal(point),
|
|
screenPos,
|
|
me->button(),
|
|
me->buttons(),
|
|
me->modifiers()
|
|
);
|
|
QApplication::sendEvent(lastIntercept, &mouseEvent);
|
|
break;
|
|
}
|
|
case QEvent::Wheel: {
|
|
auto we = static_cast<QWheelEvent*>(ev);
|
|
QPoint globalPos = we->globalPosition().toPoint();
|
|
lastIntercept = getChildAt(widget, globalPos);
|
|
|
|
// For some reason in case of 3D View we have to target it directly instead of targeting
|
|
// the viewport of QAbstractScrollArea like it works for all other widgets of that kind.
|
|
// That's why for this event we have to traverse up the widget tree to find if it is
|
|
// part of the 3D view.
|
|
for (auto parent = lastIntercept; parent; parent = parent->parentWidget()) {
|
|
if (qobject_cast<View3DInventorViewer*>(parent)) {
|
|
lastIntercept = parent;
|
|
break;
|
|
}
|
|
}
|
|
|
|
QWheelEvent wheelEvent(
|
|
lastIntercept->mapFromGlobal(globalPos),
|
|
globalPos,
|
|
we->pixelDelta(),
|
|
we->angleDelta(),
|
|
we->buttons(),
|
|
we->modifiers(),
|
|
we->phase(),
|
|
we->inverted(),
|
|
we->source()
|
|
);
|
|
QApplication::sendEvent(lastIntercept, &wheelEvent);
|
|
break;
|
|
}
|
|
case QEvent::ContextMenu: {
|
|
auto ce = static_cast<QContextMenuEvent*>(ev);
|
|
lastIntercept = getChildAt(widget, ce->globalPos());
|
|
QContextMenuEvent contextMenuEvent(
|
|
ce->reason(),
|
|
lastIntercept->mapFromGlobal(ce->globalPos()),
|
|
ce->globalPos()
|
|
);
|
|
QApplication::sendEvent(lastIntercept, &contextMenuEvent);
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
void OverlayManager::refresh(QWidget* widget, bool refreshStyle)
|
|
{
|
|
d->refresh(widget, refreshStyle);
|
|
}
|
|
|
|
void OverlayManager::setMouseTransparent(bool enabled)
|
|
{
|
|
d->setMouseTransparent(enabled);
|
|
}
|
|
|
|
bool OverlayManager::isMouseTransparent() const
|
|
{
|
|
return d->mouseTransparent;
|
|
}
|
|
|
|
bool OverlayManager::isUnderOverlay() const
|
|
{
|
|
return OverlayParams::getDockOverlayAutoMouseThrough()
|
|
&& findTabWidget(qApp->widgetAt(QCursor::pos()), true);
|
|
}
|
|
|
|
void OverlayManager::save()
|
|
{
|
|
d->save();
|
|
}
|
|
|
|
void OverlayManager::restore()
|
|
{
|
|
d->restore();
|
|
|
|
if (Control().taskPanel()) {
|
|
connect(
|
|
Control().taskPanel(),
|
|
&TaskView::TaskView::taskUpdate,
|
|
this,
|
|
&OverlayManager::onTaskViewUpdate
|
|
);
|
|
}
|
|
}
|
|
|
|
void OverlayManager::setupTitleBar(QDockWidget* dock)
|
|
{
|
|
d->setupTitleBar(dock);
|
|
}
|
|
|
|
void OverlayManager::onFocusChanged(QWidget* old, QWidget* now)
|
|
{
|
|
d->onFocusChanged(old, now);
|
|
}
|
|
|
|
void OverlayManager::onAction()
|
|
{
|
|
QAction* action = qobject_cast<QAction*>(sender());
|
|
if (action) {
|
|
d->onAction(action);
|
|
}
|
|
}
|
|
|
|
void OverlayManager::dragDockWidget(
|
|
const QPoint& pos,
|
|
QWidget* src,
|
|
const QPoint& offset,
|
|
const QSize& size,
|
|
bool drop
|
|
)
|
|
{
|
|
d->dragDockWidget(pos, src, offset, size, drop);
|
|
}
|
|
|
|
void OverlayManager::floatDockWidget(QDockWidget* dock)
|
|
{
|
|
d->floatDockWidget(dock);
|
|
}
|
|
|
|
void OverlayManager::registerDockWidget(const QString& name, OverlayTabWidget* widget)
|
|
{
|
|
d->registerDockWidget(name, widget);
|
|
}
|
|
|
|
void OverlayManager::unregisterDockWidget(const QString& name, OverlayTabWidget* widget)
|
|
{
|
|
d->unregisterDockWidget(name, widget);
|
|
}
|
|
|
|
QWidget* OverlayManager::getLastMouseInterceptWidget() const
|
|
{
|
|
return d->lastIntercept;
|
|
}
|
|
|
|
const QString& OverlayManager::getStyleSheet() const
|
|
{
|
|
return OverlayStyleSheet::instance()->activeStyleSheet;
|
|
}
|
|
|
|
bool OverlayManager::getHideTab() const
|
|
{
|
|
return OverlayStyleSheet::instance()->hideTab;
|
|
}
|
|
|
|
void OverlayManager::setFocusView()
|
|
{
|
|
auto view = getMainWindow()->activeWindow();
|
|
if (!view) {
|
|
view = Application::Instance->activeView();
|
|
}
|
|
if (view) {
|
|
view->setFocus();
|
|
}
|
|
}
|
|
|
|
#include "moc_OverlayManager.cpp"
|