1267 lines
43 KiB
C++
1267 lines
43 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 "OverlayManager.h"
|
|
|
|
/*[[[cog
|
|
import OverlayParams
|
|
OverlayParams.define()
|
|
]]]*/
|
|
|
|
// Auto generated code (Tools/params_utils.py:196)
|
|
#include <unordered_map>
|
|
#include <App/Application.h>
|
|
#include <App/DynamicProperty.h>
|
|
#include "OverlayParams.h"
|
|
using namespace Gui;
|
|
|
|
// Auto generated code (Tools/params_utils.py:207)
|
|
namespace
|
|
{
|
|
class OverlayParamsP: public ParameterGrp::ObserverType
|
|
{
|
|
public:
|
|
ParameterGrp::handle handle;
|
|
std::unordered_map<const char*, void (*)(OverlayParamsP*), App::CStringHasher, App::CStringHasher> funcs;
|
|
|
|
bool DockOverlayAutoView;
|
|
long DockOverlayDelay;
|
|
long DockOverlayRevealDelay;
|
|
long DockOverlaySplitterHandleTimeout;
|
|
bool DockOverlayActivateOnHover;
|
|
bool DockOverlayAutoMouseThrough;
|
|
bool DockOverlayWheelPassThrough;
|
|
long DockOverlayWheelDelay;
|
|
long DockOverlayAlphaRadius;
|
|
bool DockOverlayCheckNaviCube;
|
|
long DockOverlayHintTriggerSize;
|
|
long DockOverlayHintSize;
|
|
long DockOverlayHintLeftLength;
|
|
long DockOverlayHintRightLength;
|
|
long DockOverlayHintTopLength;
|
|
long DockOverlayHintBottomLength;
|
|
long DockOverlayHintLeftOffset;
|
|
long DockOverlayHintRightOffset;
|
|
long DockOverlayHintTopOffset;
|
|
long DockOverlayHintBottomOffset;
|
|
bool DockOverlayHintTabBar;
|
|
bool DockOverlayHideTabBar;
|
|
long DockOverlayHintDelay;
|
|
long DockOverlayAnimationDuration;
|
|
long DockOverlayAnimationCurve;
|
|
bool DockOverlayHidePropertyViewScrollBar;
|
|
long DockOverlayMinimumSize;
|
|
|
|
// Auto generated code (Tools/params_utils.py:245)
|
|
OverlayParamsP()
|
|
{
|
|
handle = App::GetApplication().GetParameterGroupByPath(
|
|
"User parameter:BaseApp/Preferences/View"
|
|
);
|
|
handle->Attach(this);
|
|
|
|
DockOverlayAutoView = handle->GetBool("DockOverlayAutoView", true);
|
|
funcs["DockOverlayAutoView"] = &OverlayParamsP::updateDockOverlayAutoView;
|
|
DockOverlayDelay = handle->GetInt("DockOverlayDelay", 200);
|
|
funcs["DockOverlayDelay"] = &OverlayParamsP::updateDockOverlayDelay;
|
|
DockOverlayRevealDelay = handle->GetInt("DockOverlayRevealDelay", 2000);
|
|
funcs["DockOverlayRevealDelay"] = &OverlayParamsP::updateDockOverlayRevealDelay;
|
|
DockOverlaySplitterHandleTimeout = handle->GetInt("DockOverlaySplitterHandleTimeout", 0);
|
|
funcs["DockOverlaySplitterHandleTimeout"]
|
|
= &OverlayParamsP::updateDockOverlaySplitterHandleTimeout;
|
|
DockOverlayActivateOnHover = handle->GetBool("DockOverlayActivateOnHover", true);
|
|
funcs["DockOverlayActivateOnHover"] = &OverlayParamsP::updateDockOverlayActivateOnHover;
|
|
DockOverlayAutoMouseThrough = handle->GetBool("DockOverlayAutoMouseThrough", true);
|
|
funcs["DockOverlayAutoMouseThrough"] = &OverlayParamsP::updateDockOverlayAutoMouseThrough;
|
|
DockOverlayWheelPassThrough = handle->GetBool("DockOverlayWheelPassThrough", true);
|
|
funcs["DockOverlayWheelPassThrough"] = &OverlayParamsP::updateDockOverlayWheelPassThrough;
|
|
DockOverlayWheelDelay = handle->GetInt("DockOverlayWheelDelay", 1000);
|
|
funcs["DockOverlayWheelDelay"] = &OverlayParamsP::updateDockOverlayWheelDelay;
|
|
DockOverlayAlphaRadius = handle->GetInt("DockOverlayAlphaRadius", 2);
|
|
funcs["DockOverlayAlphaRadius"] = &OverlayParamsP::updateDockOverlayAlphaRadius;
|
|
DockOverlayCheckNaviCube = handle->GetBool("DockOverlayCheckNaviCube", true);
|
|
funcs["DockOverlayCheckNaviCube"] = &OverlayParamsP::updateDockOverlayCheckNaviCube;
|
|
DockOverlayHintTriggerSize = handle->GetInt("DockOverlayHintTriggerSize", 16);
|
|
funcs["DockOverlayHintTriggerSize"] = &OverlayParamsP::updateDockOverlayHintTriggerSize;
|
|
DockOverlayHintSize = handle->GetInt("DockOverlayHintSize", 8);
|
|
funcs["DockOverlayHintSize"] = &OverlayParamsP::updateDockOverlayHintSize;
|
|
DockOverlayHintLeftLength = handle->GetInt("DockOverlayHintLeftLength", 100);
|
|
funcs["DockOverlayHintLeftLength"] = &OverlayParamsP::updateDockOverlayHintLeftLength;
|
|
DockOverlayHintRightLength = handle->GetInt("DockOverlayHintRightLength", 100);
|
|
funcs["DockOverlayHintRightLength"] = &OverlayParamsP::updateDockOverlayHintRightLength;
|
|
DockOverlayHintTopLength = handle->GetInt("DockOverlayHintTopLength", 100);
|
|
funcs["DockOverlayHintTopLength"] = &OverlayParamsP::updateDockOverlayHintTopLength;
|
|
DockOverlayHintBottomLength = handle->GetInt("DockOverlayHintBottomLength", 100);
|
|
funcs["DockOverlayHintBottomLength"] = &OverlayParamsP::updateDockOverlayHintBottomLength;
|
|
DockOverlayHintLeftOffset = handle->GetInt("DockOverlayHintLeftOffset", 0);
|
|
funcs["DockOverlayHintLeftOffset"] = &OverlayParamsP::updateDockOverlayHintLeftOffset;
|
|
DockOverlayHintRightOffset = handle->GetInt("DockOverlayHintRightOffset", 0);
|
|
funcs["DockOverlayHintRightOffset"] = &OverlayParamsP::updateDockOverlayHintRightOffset;
|
|
DockOverlayHintTopOffset = handle->GetInt("DockOverlayHintTopOffset", 0);
|
|
funcs["DockOverlayHintTopOffset"] = &OverlayParamsP::updateDockOverlayHintTopOffset;
|
|
DockOverlayHintBottomOffset = handle->GetInt("DockOverlayHintBottomOffset", 0);
|
|
funcs["DockOverlayHintBottomOffset"] = &OverlayParamsP::updateDockOverlayHintBottomOffset;
|
|
DockOverlayHintTabBar = handle->GetBool("DockOverlayHintTabBar", false);
|
|
funcs["DockOverlayHintTabBar"] = &OverlayParamsP::updateDockOverlayHintTabBar;
|
|
DockOverlayHideTabBar = handle->GetBool("DockOverlayHideTabBar", true);
|
|
funcs["DockOverlayHideTabBar"] = &OverlayParamsP::updateDockOverlayHideTabBar;
|
|
DockOverlayHintDelay = handle->GetInt("DockOverlayHintDelay", 200);
|
|
funcs["DockOverlayHintDelay"] = &OverlayParamsP::updateDockOverlayHintDelay;
|
|
DockOverlayAnimationDuration = handle->GetInt("DockOverlayAnimationDuration", 200);
|
|
funcs["DockOverlayAnimationDuration"] = &OverlayParamsP::updateDockOverlayAnimationDuration;
|
|
DockOverlayAnimationCurve = handle->GetInt("DockOverlayAnimationCurve", 7);
|
|
funcs["DockOverlayAnimationCurve"] = &OverlayParamsP::updateDockOverlayAnimationCurve;
|
|
DockOverlayHidePropertyViewScrollBar
|
|
= handle->GetBool("DockOverlayHidePropertyViewScrollBar", false);
|
|
funcs["DockOverlayHidePropertyViewScrollBar"]
|
|
= &OverlayParamsP::updateDockOverlayHidePropertyViewScrollBar;
|
|
DockOverlayMinimumSize = handle->GetInt("DockOverlayMinimumSize", 30);
|
|
funcs["DockOverlayMinimumSize"] = &OverlayParamsP::updateDockOverlayMinimumSize;
|
|
}
|
|
|
|
// Auto generated code (Tools/params_utils.py:263)
|
|
~OverlayParamsP()
|
|
{}
|
|
|
|
// Auto generated code (Tools/params_utils.py:270)
|
|
void OnChange(Base::Subject<const char*>&, const char* sReason)
|
|
{
|
|
if (!sReason) {
|
|
return;
|
|
}
|
|
auto it = funcs.find(sReason);
|
|
if (it == funcs.end()) {
|
|
return;
|
|
}
|
|
it->second(this);
|
|
}
|
|
|
|
|
|
// Auto generated code (Tools/params_utils.py:296)
|
|
static void updateDockOverlayAutoView(OverlayParamsP* self)
|
|
{
|
|
auto v = self->handle->GetBool("DockOverlayAutoView", true);
|
|
if (self->DockOverlayAutoView != v) {
|
|
self->DockOverlayAutoView = v;
|
|
OverlayParams::onDockOverlayAutoViewChanged();
|
|
}
|
|
}
|
|
// Auto generated code (Tools/params_utils.py:288)
|
|
static void updateDockOverlayDelay(OverlayParamsP* self)
|
|
{
|
|
self->DockOverlayDelay = self->handle->GetInt("DockOverlayDelay", 200);
|
|
}
|
|
// Auto generated code (Tools/params_utils.py:288)
|
|
static void updateDockOverlayRevealDelay(OverlayParamsP* self)
|
|
{
|
|
self->DockOverlayRevealDelay = self->handle->GetInt("DockOverlayRevealDelay", 2000);
|
|
}
|
|
// Auto generated code (Tools/params_utils.py:288)
|
|
static void updateDockOverlaySplitterHandleTimeout(OverlayParamsP* self)
|
|
{
|
|
self->DockOverlaySplitterHandleTimeout
|
|
= self->handle->GetInt("DockOverlaySplitterHandleTimeout", 0);
|
|
}
|
|
// Auto generated code (Tools/params_utils.py:288)
|
|
static void updateDockOverlayActivateOnHover(OverlayParamsP* self)
|
|
{
|
|
self->DockOverlayActivateOnHover = self->handle->GetBool("DockOverlayActivateOnHover", true);
|
|
}
|
|
// Auto generated code (Tools/params_utils.py:288)
|
|
static void updateDockOverlayAutoMouseThrough(OverlayParamsP* self)
|
|
{
|
|
self->DockOverlayAutoMouseThrough = self->handle->GetBool("DockOverlayAutoMouseThrough", true);
|
|
}
|
|
// Auto generated code (Tools/params_utils.py:288)
|
|
static void updateDockOverlayWheelPassThrough(OverlayParamsP* self)
|
|
{
|
|
self->DockOverlayWheelPassThrough = self->handle->GetBool("DockOverlayWheelPassThrough", true);
|
|
}
|
|
// Auto generated code (Tools/params_utils.py:288)
|
|
static void updateDockOverlayWheelDelay(OverlayParamsP* self)
|
|
{
|
|
self->DockOverlayWheelDelay = self->handle->GetInt("DockOverlayWheelDelay", 1000);
|
|
}
|
|
// Auto generated code (Tools/params_utils.py:288)
|
|
static void updateDockOverlayAlphaRadius(OverlayParamsP* self)
|
|
{
|
|
self->DockOverlayAlphaRadius = self->handle->GetInt("DockOverlayAlphaRadius", 2);
|
|
}
|
|
// Auto generated code (Tools/params_utils.py:296)
|
|
static void updateDockOverlayCheckNaviCube(OverlayParamsP* self)
|
|
{
|
|
auto v = self->handle->GetBool("DockOverlayCheckNaviCube", true);
|
|
if (self->DockOverlayCheckNaviCube != v) {
|
|
self->DockOverlayCheckNaviCube = v;
|
|
OverlayParams::onDockOverlayCheckNaviCubeChanged();
|
|
}
|
|
}
|
|
// Auto generated code (Tools/params_utils.py:288)
|
|
static void updateDockOverlayHintTriggerSize(OverlayParamsP* self)
|
|
{
|
|
self->DockOverlayHintTriggerSize = self->handle->GetInt("DockOverlayHintTriggerSize", 16);
|
|
}
|
|
// Auto generated code (Tools/params_utils.py:288)
|
|
static void updateDockOverlayHintSize(OverlayParamsP* self)
|
|
{
|
|
self->DockOverlayHintSize = self->handle->GetInt("DockOverlayHintSize", 8);
|
|
}
|
|
// Auto generated code (Tools/params_utils.py:288)
|
|
static void updateDockOverlayHintLeftLength(OverlayParamsP* self)
|
|
{
|
|
self->DockOverlayHintLeftLength = self->handle->GetInt("DockOverlayHintLeftLength", 100);
|
|
}
|
|
// Auto generated code (Tools/params_utils.py:288)
|
|
static void updateDockOverlayHintRightLength(OverlayParamsP* self)
|
|
{
|
|
self->DockOverlayHintRightLength = self->handle->GetInt("DockOverlayHintRightLength", 100);
|
|
}
|
|
// Auto generated code (Tools/params_utils.py:288)
|
|
static void updateDockOverlayHintTopLength(OverlayParamsP* self)
|
|
{
|
|
self->DockOverlayHintTopLength = self->handle->GetInt("DockOverlayHintTopLength", 100);
|
|
}
|
|
// Auto generated code (Tools/params_utils.py:288)
|
|
static void updateDockOverlayHintBottomLength(OverlayParamsP* self)
|
|
{
|
|
self->DockOverlayHintBottomLength = self->handle->GetInt("DockOverlayHintBottomLength", 100);
|
|
}
|
|
// Auto generated code (Tools/params_utils.py:288)
|
|
static void updateDockOverlayHintLeftOffset(OverlayParamsP* self)
|
|
{
|
|
self->DockOverlayHintLeftOffset = self->handle->GetInt("DockOverlayHintLeftOffset", 0);
|
|
}
|
|
// Auto generated code (Tools/params_utils.py:288)
|
|
static void updateDockOverlayHintRightOffset(OverlayParamsP* self)
|
|
{
|
|
self->DockOverlayHintRightOffset = self->handle->GetInt("DockOverlayHintRightOffset", 0);
|
|
}
|
|
// Auto generated code (Tools/params_utils.py:288)
|
|
static void updateDockOverlayHintTopOffset(OverlayParamsP* self)
|
|
{
|
|
self->DockOverlayHintTopOffset = self->handle->GetInt("DockOverlayHintTopOffset", 0);
|
|
}
|
|
// Auto generated code (Tools/params_utils.py:288)
|
|
static void updateDockOverlayHintBottomOffset(OverlayParamsP* self)
|
|
{
|
|
self->DockOverlayHintBottomOffset = self->handle->GetInt("DockOverlayHintBottomOffset", 0);
|
|
}
|
|
// Auto generated code (Tools/params_utils.py:288)
|
|
static void updateDockOverlayHintTabBar(OverlayParamsP* self)
|
|
{
|
|
self->DockOverlayHintTabBar = self->handle->GetBool("DockOverlayHintTabBar", false);
|
|
}
|
|
// Auto generated code (Tools/params_utils.py:296)
|
|
static void updateDockOverlayHideTabBar(OverlayParamsP* self)
|
|
{
|
|
auto v = self->handle->GetBool("DockOverlayHideTabBar", true);
|
|
if (self->DockOverlayHideTabBar != v) {
|
|
self->DockOverlayHideTabBar = v;
|
|
OverlayParams::onDockOverlayHideTabBarChanged();
|
|
}
|
|
}
|
|
// Auto generated code (Tools/params_utils.py:288)
|
|
static void updateDockOverlayHintDelay(OverlayParamsP* self)
|
|
{
|
|
self->DockOverlayHintDelay = self->handle->GetInt("DockOverlayHintDelay", 200);
|
|
}
|
|
// Auto generated code (Tools/params_utils.py:288)
|
|
static void updateDockOverlayAnimationDuration(OverlayParamsP* self)
|
|
{
|
|
self->DockOverlayAnimationDuration = self->handle->GetInt("DockOverlayAnimationDuration", 200);
|
|
}
|
|
// Auto generated code (Tools/params_utils.py:288)
|
|
static void updateDockOverlayAnimationCurve(OverlayParamsP* self)
|
|
{
|
|
self->DockOverlayAnimationCurve = self->handle->GetInt("DockOverlayAnimationCurve", 7);
|
|
}
|
|
// Auto generated code (Tools/params_utils.py:288)
|
|
static void updateDockOverlayHidePropertyViewScrollBar(OverlayParamsP* self)
|
|
{
|
|
self->DockOverlayHidePropertyViewScrollBar
|
|
= self->handle->GetBool("DockOverlayHidePropertyViewScrollBar", false);
|
|
}
|
|
// Auto generated code (Tools/params_utils.py:296)
|
|
static void updateDockOverlayMinimumSize(OverlayParamsP* self)
|
|
{
|
|
auto v = self->handle->GetInt("DockOverlayMinimumSize", 30);
|
|
if (self->DockOverlayMinimumSize != v) {
|
|
self->DockOverlayMinimumSize = v;
|
|
OverlayParams::onDockOverlayMinimumSizeChanged();
|
|
}
|
|
}
|
|
};
|
|
|
|
// Auto generated code (Tools/params_utils.py:310)
|
|
OverlayParamsP* instance()
|
|
{
|
|
static OverlayParamsP* inst = new OverlayParamsP;
|
|
return inst;
|
|
}
|
|
|
|
} // Anonymous namespace
|
|
|
|
// Auto generated code (Tools/params_utils.py:321)
|
|
ParameterGrp::handle OverlayParams::getHandle()
|
|
{
|
|
return instance()->handle;
|
|
}
|
|
|
|
// Auto generated code (Tools/params_utils.py:350)
|
|
const char* OverlayParams::docDockOverlayAutoView()
|
|
{
|
|
return "";
|
|
}
|
|
|
|
// Auto generated code (Tools/params_utils.py:358)
|
|
const bool& OverlayParams::getDockOverlayAutoView()
|
|
{
|
|
return instance()->DockOverlayAutoView;
|
|
}
|
|
|
|
// Auto generated code (Tools/params_utils.py:366)
|
|
const bool& OverlayParams::defaultDockOverlayAutoView()
|
|
{
|
|
const static bool def = true;
|
|
return def;
|
|
}
|
|
|
|
// Auto generated code (Tools/params_utils.py:375)
|
|
void OverlayParams::setDockOverlayAutoView(const bool& v)
|
|
{
|
|
instance()->handle->SetBool("DockOverlayAutoView", v);
|
|
instance()->DockOverlayAutoView = v;
|
|
}
|
|
|
|
// Auto generated code (Tools/params_utils.py:384)
|
|
void OverlayParams::removeDockOverlayAutoView()
|
|
{
|
|
instance()->handle->RemoveBool("DockOverlayAutoView");
|
|
}
|
|
|
|
// Auto generated code (Tools/params_utils.py:350)
|
|
const char* OverlayParams::docDockOverlayDelay()
|
|
{
|
|
return QT_TRANSLATE_NOOP("OverlayParams", "Overlay layout delay");
|
|
}
|
|
|
|
// Auto generated code (Tools/params_utils.py:358)
|
|
const long& OverlayParams::getDockOverlayDelay()
|
|
{
|
|
return instance()->DockOverlayDelay;
|
|
}
|
|
|
|
// Auto generated code (Tools/params_utils.py:366)
|
|
const long& OverlayParams::defaultDockOverlayDelay()
|
|
{
|
|
const static long def = 200;
|
|
return def;
|
|
}
|
|
|
|
// Auto generated code (Tools/params_utils.py:375)
|
|
void OverlayParams::setDockOverlayDelay(const long& v)
|
|
{
|
|
instance()->handle->SetInt("DockOverlayDelay", v);
|
|
instance()->DockOverlayDelay = v;
|
|
}
|
|
|
|
// Auto generated code (Tools/params_utils.py:384)
|
|
void OverlayParams::removeDockOverlayDelay()
|
|
{
|
|
instance()->handle->RemoveInt("DockOverlayDelay");
|
|
}
|
|
|
|
// Auto generated code (Tools/params_utils.py:350)
|
|
const char* OverlayParams::docDockOverlayRevealDelay()
|
|
{
|
|
return "";
|
|
}
|
|
|
|
// Auto generated code (Tools/params_utils.py:358)
|
|
const long& OverlayParams::getDockOverlayRevealDelay()
|
|
{
|
|
return instance()->DockOverlayRevealDelay;
|
|
}
|
|
|
|
// Auto generated code (Tools/params_utils.py:366)
|
|
const long& OverlayParams::defaultDockOverlayRevealDelay()
|
|
{
|
|
const static long def = 2000;
|
|
return def;
|
|
}
|
|
|
|
// Auto generated code (Tools/params_utils.py:375)
|
|
void OverlayParams::setDockOverlayRevealDelay(const long& v)
|
|
{
|
|
instance()->handle->SetInt("DockOverlayRevealDelay", v);
|
|
instance()->DockOverlayRevealDelay = v;
|
|
}
|
|
|
|
// Auto generated code (Tools/params_utils.py:384)
|
|
void OverlayParams::removeDockOverlayRevealDelay()
|
|
{
|
|
instance()->handle->RemoveInt("DockOverlayRevealDelay");
|
|
}
|
|
|
|
// Auto generated code (Tools/params_utils.py:350)
|
|
const char* OverlayParams::docDockOverlaySplitterHandleTimeout()
|
|
{
|
|
return QT_TRANSLATE_NOOP(
|
|
"OverlayParams",
|
|
"Overlay splitter handle auto hide delay. Set zero to disable auto hiding."
|
|
);
|
|
}
|
|
|
|
// Auto generated code (Tools/params_utils.py:358)
|
|
const long& OverlayParams::getDockOverlaySplitterHandleTimeout()
|
|
{
|
|
return instance()->DockOverlaySplitterHandleTimeout;
|
|
}
|
|
|
|
// Auto generated code (Tools/params_utils.py:366)
|
|
const long& OverlayParams::defaultDockOverlaySplitterHandleTimeout()
|
|
{
|
|
const static long def = 0;
|
|
return def;
|
|
}
|
|
|
|
// Auto generated code (Tools/params_utils.py:375)
|
|
void OverlayParams::setDockOverlaySplitterHandleTimeout(const long& v)
|
|
{
|
|
instance()->handle->SetInt("DockOverlaySplitterHandleTimeout", v);
|
|
instance()->DockOverlaySplitterHandleTimeout = v;
|
|
}
|
|
|
|
// Auto generated code (Tools/params_utils.py:384)
|
|
void OverlayParams::removeDockOverlaySplitterHandleTimeout()
|
|
{
|
|
instance()->handle->RemoveInt("DockOverlaySplitterHandleTimeout");
|
|
}
|
|
|
|
// Auto generated code (Tools/params_utils.py:350)
|
|
const char* OverlayParams::docDockOverlayActivateOnHover()
|
|
{
|
|
return QT_TRANSLATE_NOOP(
|
|
"OverlayParams",
|
|
"Show auto hidden dock overlay on mouse over.\n"
|
|
"If disabled, then show on mouse click."
|
|
);
|
|
}
|
|
|
|
// Auto generated code (Tools/params_utils.py:358)
|
|
const bool& OverlayParams::getDockOverlayActivateOnHover()
|
|
{
|
|
return instance()->DockOverlayActivateOnHover;
|
|
}
|
|
|
|
// Auto generated code (Tools/params_utils.py:366)
|
|
const bool& OverlayParams::defaultDockOverlayActivateOnHover()
|
|
{
|
|
const static bool def = true;
|
|
return def;
|
|
}
|
|
|
|
// Auto generated code (Tools/params_utils.py:375)
|
|
void OverlayParams::setDockOverlayActivateOnHover(const bool& v)
|
|
{
|
|
instance()->handle->SetBool("DockOverlayActivateOnHover", v);
|
|
instance()->DockOverlayActivateOnHover = v;
|
|
}
|
|
|
|
// Auto generated code (Tools/params_utils.py:384)
|
|
void OverlayParams::removeDockOverlayActivateOnHover()
|
|
{
|
|
instance()->handle->RemoveBool("DockOverlayActivateOnHover");
|
|
}
|
|
|
|
// Auto generated code (Tools/params_utils.py:350)
|
|
const char* OverlayParams::docDockOverlayAutoMouseThrough()
|
|
{
|
|
return QT_TRANSLATE_NOOP(
|
|
"OverlayParams",
|
|
"Auto mouse click through transparent part of dock overlay."
|
|
);
|
|
}
|
|
|
|
// Auto generated code (Tools/params_utils.py:358)
|
|
const bool& OverlayParams::getDockOverlayAutoMouseThrough()
|
|
{
|
|
return instance()->DockOverlayAutoMouseThrough;
|
|
}
|
|
|
|
// Auto generated code (Tools/params_utils.py:366)
|
|
const bool& OverlayParams::defaultDockOverlayAutoMouseThrough()
|
|
{
|
|
const static bool def = true;
|
|
return def;
|
|
}
|
|
|
|
// Auto generated code (Tools/params_utils.py:375)
|
|
void OverlayParams::setDockOverlayAutoMouseThrough(const bool& v)
|
|
{
|
|
instance()->handle->SetBool("DockOverlayAutoMouseThrough", v);
|
|
instance()->DockOverlayAutoMouseThrough = v;
|
|
}
|
|
|
|
// Auto generated code (Tools/params_utils.py:384)
|
|
void OverlayParams::removeDockOverlayAutoMouseThrough()
|
|
{
|
|
instance()->handle->RemoveBool("DockOverlayAutoMouseThrough");
|
|
}
|
|
|
|
// Auto generated code (Tools/params_utils.py:350)
|
|
const char* OverlayParams::docDockOverlayWheelPassThrough()
|
|
{
|
|
return QT_TRANSLATE_NOOP(
|
|
"OverlayParams",
|
|
"Automatically passes mouse wheel events through the transparent areas of an overlay panel"
|
|
);
|
|
}
|
|
|
|
// Auto generated code (Tools/params_utils.py:358)
|
|
const bool& OverlayParams::getDockOverlayWheelPassThrough()
|
|
{
|
|
return instance()->DockOverlayWheelPassThrough;
|
|
}
|
|
|
|
// Auto generated code (Tools/params_utils.py:366)
|
|
const bool& OverlayParams::defaultDockOverlayWheelPassThrough()
|
|
{
|
|
const static bool def = true;
|
|
return def;
|
|
}
|
|
|
|
// Auto generated code (Tools/params_utils.py:375)
|
|
void OverlayParams::setDockOverlayWheelPassThrough(const bool& v)
|
|
{
|
|
instance()->handle->SetBool("DockOverlayWheelPassThrough", v);
|
|
instance()->DockOverlayWheelPassThrough = v;
|
|
}
|
|
|
|
// Auto generated code (Tools/params_utils.py:384)
|
|
void OverlayParams::removeDockOverlayWheelPassThrough()
|
|
{
|
|
instance()->handle->RemoveBool("DockOverlayWheelPassThrough");
|
|
}
|
|
|
|
// Auto generated code (Tools/params_utils.py:350)
|
|
const char* OverlayParams::docDockOverlayWheelDelay()
|
|
{
|
|
return QT_TRANSLATE_NOOP(
|
|
"OverlayParams",
|
|
"Delay capturing mouse wheel event for passing through if it is\n"
|
|
"previously handled by other widget."
|
|
);
|
|
}
|
|
|
|
// Auto generated code (Tools/params_utils.py:358)
|
|
const long& OverlayParams::getDockOverlayWheelDelay()
|
|
{
|
|
return instance()->DockOverlayWheelDelay;
|
|
}
|
|
|
|
// Auto generated code (Tools/params_utils.py:366)
|
|
const long& OverlayParams::defaultDockOverlayWheelDelay()
|
|
{
|
|
const static long def = 1000;
|
|
return def;
|
|
}
|
|
|
|
// Auto generated code (Tools/params_utils.py:375)
|
|
void OverlayParams::setDockOverlayWheelDelay(const long& v)
|
|
{
|
|
instance()->handle->SetInt("DockOverlayWheelDelay", v);
|
|
instance()->DockOverlayWheelDelay = v;
|
|
}
|
|
|
|
// Auto generated code (Tools/params_utils.py:384)
|
|
void OverlayParams::removeDockOverlayWheelDelay()
|
|
{
|
|
instance()->handle->RemoveInt("DockOverlayWheelDelay");
|
|
}
|
|
|
|
// Auto generated code (Tools/params_utils.py:350)
|
|
const char* OverlayParams::docDockOverlayAlphaRadius()
|
|
{
|
|
return QT_TRANSLATE_NOOP(
|
|
"OverlayParams",
|
|
"If auto mouse click through is enabled, then this radius\n"
|
|
"defines a region of alpha test under the mouse cursor.\n"
|
|
"Auto click through is only activated if all pixels within\n"
|
|
"the region are non-opaque."
|
|
);
|
|
}
|
|
|
|
// Auto generated code (Tools/params_utils.py:358)
|
|
const long& OverlayParams::getDockOverlayAlphaRadius()
|
|
{
|
|
return instance()->DockOverlayAlphaRadius;
|
|
}
|
|
|
|
// Auto generated code (Tools/params_utils.py:366)
|
|
const long& OverlayParams::defaultDockOverlayAlphaRadius()
|
|
{
|
|
const static long def = 2;
|
|
return def;
|
|
}
|
|
|
|
// Auto generated code (Tools/params_utils.py:375)
|
|
void OverlayParams::setDockOverlayAlphaRadius(const long& v)
|
|
{
|
|
instance()->handle->SetInt("DockOverlayAlphaRadius", v);
|
|
instance()->DockOverlayAlphaRadius = v;
|
|
}
|
|
|
|
// Auto generated code (Tools/params_utils.py:384)
|
|
void OverlayParams::removeDockOverlayAlphaRadius()
|
|
{
|
|
instance()->handle->RemoveInt("DockOverlayAlphaRadius");
|
|
}
|
|
|
|
// Auto generated code (Tools/params_utils.py:350)
|
|
const char* OverlayParams::docDockOverlayCheckNaviCube()
|
|
{
|
|
return QT_TRANSLATE_NOOP("OverlayParams", "Leave space for Navigation Cube in dock overlay");
|
|
}
|
|
|
|
// Auto generated code (Tools/params_utils.py:358)
|
|
const bool& OverlayParams::getDockOverlayCheckNaviCube()
|
|
{
|
|
return instance()->DockOverlayCheckNaviCube;
|
|
}
|
|
|
|
// Auto generated code (Tools/params_utils.py:366)
|
|
const bool& OverlayParams::defaultDockOverlayCheckNaviCube()
|
|
{
|
|
const static bool def = true;
|
|
return def;
|
|
}
|
|
|
|
// Auto generated code (Tools/params_utils.py:375)
|
|
void OverlayParams::setDockOverlayCheckNaviCube(const bool& v)
|
|
{
|
|
instance()->handle->SetBool("DockOverlayCheckNaviCube", v);
|
|
instance()->DockOverlayCheckNaviCube = v;
|
|
}
|
|
|
|
// Auto generated code (Tools/params_utils.py:384)
|
|
void OverlayParams::removeDockOverlayCheckNaviCube()
|
|
{
|
|
instance()->handle->RemoveBool("DockOverlayCheckNaviCube");
|
|
}
|
|
|
|
// Auto generated code (Tools/params_utils.py:350)
|
|
const char* OverlayParams::docDockOverlayHintTriggerSize()
|
|
{
|
|
return QT_TRANSLATE_NOOP("OverlayParams", "Auto hide hint visual display triggering width");
|
|
}
|
|
|
|
// Auto generated code (Tools/params_utils.py:358)
|
|
const long& OverlayParams::getDockOverlayHintTriggerSize()
|
|
{
|
|
return instance()->DockOverlayHintTriggerSize;
|
|
}
|
|
|
|
// Auto generated code (Tools/params_utils.py:366)
|
|
const long& OverlayParams::defaultDockOverlayHintTriggerSize()
|
|
{
|
|
const static long def = 16;
|
|
return def;
|
|
}
|
|
|
|
// Auto generated code (Tools/params_utils.py:375)
|
|
void OverlayParams::setDockOverlayHintTriggerSize(const long& v)
|
|
{
|
|
instance()->handle->SetInt("DockOverlayHintTriggerSize", v);
|
|
instance()->DockOverlayHintTriggerSize = v;
|
|
}
|
|
|
|
// Auto generated code (Tools/params_utils.py:384)
|
|
void OverlayParams::removeDockOverlayHintTriggerSize()
|
|
{
|
|
instance()->handle->RemoveInt("DockOverlayHintTriggerSize");
|
|
}
|
|
|
|
// Auto generated code (Tools/params_utils.py:350)
|
|
const char* OverlayParams::docDockOverlayHintSize()
|
|
{
|
|
return QT_TRANSLATE_NOOP("OverlayParams", "Auto hide hint visual display width");
|
|
}
|
|
|
|
// Auto generated code (Tools/params_utils.py:358)
|
|
const long& OverlayParams::getDockOverlayHintSize()
|
|
{
|
|
return instance()->DockOverlayHintSize;
|
|
}
|
|
|
|
// Auto generated code (Tools/params_utils.py:366)
|
|
const long& OverlayParams::defaultDockOverlayHintSize()
|
|
{
|
|
const static long def = 8;
|
|
return def;
|
|
}
|
|
|
|
// Auto generated code (Tools/params_utils.py:375)
|
|
void OverlayParams::setDockOverlayHintSize(const long& v)
|
|
{
|
|
instance()->handle->SetInt("DockOverlayHintSize", v);
|
|
instance()->DockOverlayHintSize = v;
|
|
}
|
|
|
|
// Auto generated code (Tools/params_utils.py:384)
|
|
void OverlayParams::removeDockOverlayHintSize()
|
|
{
|
|
instance()->handle->RemoveInt("DockOverlayHintSize");
|
|
}
|
|
|
|
// Auto generated code (Tools/params_utils.py:350)
|
|
const char* OverlayParams::docDockOverlayHintLeftLength()
|
|
{
|
|
return QT_TRANSLATE_NOOP(
|
|
"OverlayParams",
|
|
"Auto hide hint visual display length for left panel. Set to zero to fill the space."
|
|
);
|
|
}
|
|
|
|
// Auto generated code (Tools/params_utils.py:358)
|
|
const long& OverlayParams::getDockOverlayHintLeftLength()
|
|
{
|
|
return instance()->DockOverlayHintLeftLength;
|
|
}
|
|
|
|
// Auto generated code (Tools/params_utils.py:366)
|
|
const long& OverlayParams::defaultDockOverlayHintLeftLength()
|
|
{
|
|
const static long def = 100;
|
|
return def;
|
|
}
|
|
|
|
// Auto generated code (Tools/params_utils.py:375)
|
|
void OverlayParams::setDockOverlayHintLeftLength(const long& v)
|
|
{
|
|
instance()->handle->SetInt("DockOverlayHintLeftLength", v);
|
|
instance()->DockOverlayHintLeftLength = v;
|
|
}
|
|
|
|
// Auto generated code (Tools/params_utils.py:384)
|
|
void OverlayParams::removeDockOverlayHintLeftLength()
|
|
{
|
|
instance()->handle->RemoveInt("DockOverlayHintLeftLength");
|
|
}
|
|
|
|
// Auto generated code (Tools/params_utils.py:350)
|
|
const char* OverlayParams::docDockOverlayHintRightLength()
|
|
{
|
|
return QT_TRANSLATE_NOOP(
|
|
"OverlayParams",
|
|
"Auto hide hint visual display length for right panel. Set to zero to fill the space."
|
|
);
|
|
}
|
|
|
|
// Auto generated code (Tools/params_utils.py:358)
|
|
const long& OverlayParams::getDockOverlayHintRightLength()
|
|
{
|
|
return instance()->DockOverlayHintRightLength;
|
|
}
|
|
|
|
// Auto generated code (Tools/params_utils.py:366)
|
|
const long& OverlayParams::defaultDockOverlayHintRightLength()
|
|
{
|
|
const static long def = 100;
|
|
return def;
|
|
}
|
|
|
|
// Auto generated code (Tools/params_utils.py:375)
|
|
void OverlayParams::setDockOverlayHintRightLength(const long& v)
|
|
{
|
|
instance()->handle->SetInt("DockOverlayHintRightLength", v);
|
|
instance()->DockOverlayHintRightLength = v;
|
|
}
|
|
|
|
// Auto generated code (Tools/params_utils.py:384)
|
|
void OverlayParams::removeDockOverlayHintRightLength()
|
|
{
|
|
instance()->handle->RemoveInt("DockOverlayHintRightLength");
|
|
}
|
|
|
|
// Auto generated code (Tools/params_utils.py:350)
|
|
const char* OverlayParams::docDockOverlayHintTopLength()
|
|
{
|
|
return QT_TRANSLATE_NOOP(
|
|
"OverlayParams",
|
|
"Auto hide hint visual display length for top panel. Set to zero to fill the space."
|
|
);
|
|
}
|
|
|
|
// Auto generated code (Tools/params_utils.py:358)
|
|
const long& OverlayParams::getDockOverlayHintTopLength()
|
|
{
|
|
return instance()->DockOverlayHintTopLength;
|
|
}
|
|
|
|
// Auto generated code (Tools/params_utils.py:366)
|
|
const long& OverlayParams::defaultDockOverlayHintTopLength()
|
|
{
|
|
const static long def = 100;
|
|
return def;
|
|
}
|
|
|
|
// Auto generated code (Tools/params_utils.py:375)
|
|
void OverlayParams::setDockOverlayHintTopLength(const long& v)
|
|
{
|
|
instance()->handle->SetInt("DockOverlayHintTopLength", v);
|
|
instance()->DockOverlayHintTopLength = v;
|
|
}
|
|
|
|
// Auto generated code (Tools/params_utils.py:384)
|
|
void OverlayParams::removeDockOverlayHintTopLength()
|
|
{
|
|
instance()->handle->RemoveInt("DockOverlayHintTopLength");
|
|
}
|
|
|
|
// Auto generated code (Tools/params_utils.py:350)
|
|
const char* OverlayParams::docDockOverlayHintBottomLength()
|
|
{
|
|
return QT_TRANSLATE_NOOP(
|
|
"OverlayParams",
|
|
"Auto hide hint visual display length for bottom panel. Set to zero to fill the space."
|
|
);
|
|
}
|
|
|
|
// Auto generated code (Tools/params_utils.py:358)
|
|
const long& OverlayParams::getDockOverlayHintBottomLength()
|
|
{
|
|
return instance()->DockOverlayHintBottomLength;
|
|
}
|
|
|
|
// Auto generated code (Tools/params_utils.py:366)
|
|
const long& OverlayParams::defaultDockOverlayHintBottomLength()
|
|
{
|
|
const static long def = 100;
|
|
return def;
|
|
}
|
|
|
|
// Auto generated code (Tools/params_utils.py:375)
|
|
void OverlayParams::setDockOverlayHintBottomLength(const long& v)
|
|
{
|
|
instance()->handle->SetInt("DockOverlayHintBottomLength", v);
|
|
instance()->DockOverlayHintBottomLength = v;
|
|
}
|
|
|
|
// Auto generated code (Tools/params_utils.py:384)
|
|
void OverlayParams::removeDockOverlayHintBottomLength()
|
|
{
|
|
instance()->handle->RemoveInt("DockOverlayHintBottomLength");
|
|
}
|
|
|
|
// Auto generated code (Tools/params_utils.py:350)
|
|
const char* OverlayParams::docDockOverlayHintLeftOffset()
|
|
{
|
|
return QT_TRANSLATE_NOOP("OverlayParams", "Auto hide hint visual display offset for left panel");
|
|
}
|
|
|
|
// Auto generated code (Tools/params_utils.py:358)
|
|
const long& OverlayParams::getDockOverlayHintLeftOffset()
|
|
{
|
|
return instance()->DockOverlayHintLeftOffset;
|
|
}
|
|
|
|
// Auto generated code (Tools/params_utils.py:366)
|
|
const long& OverlayParams::defaultDockOverlayHintLeftOffset()
|
|
{
|
|
const static long def = 0;
|
|
return def;
|
|
}
|
|
|
|
// Auto generated code (Tools/params_utils.py:375)
|
|
void OverlayParams::setDockOverlayHintLeftOffset(const long& v)
|
|
{
|
|
instance()->handle->SetInt("DockOverlayHintLeftOffset", v);
|
|
instance()->DockOverlayHintLeftOffset = v;
|
|
}
|
|
|
|
// Auto generated code (Tools/params_utils.py:384)
|
|
void OverlayParams::removeDockOverlayHintLeftOffset()
|
|
{
|
|
instance()->handle->RemoveInt("DockOverlayHintLeftOffset");
|
|
}
|
|
|
|
// Auto generated code (Tools/params_utils.py:350)
|
|
const char* OverlayParams::docDockOverlayHintRightOffset()
|
|
{
|
|
return QT_TRANSLATE_NOOP("OverlayParams", "Auto hide hint visual display offset for right panel");
|
|
}
|
|
|
|
// Auto generated code (Tools/params_utils.py:358)
|
|
const long& OverlayParams::getDockOverlayHintRightOffset()
|
|
{
|
|
return instance()->DockOverlayHintRightOffset;
|
|
}
|
|
|
|
// Auto generated code (Tools/params_utils.py:366)
|
|
const long& OverlayParams::defaultDockOverlayHintRightOffset()
|
|
{
|
|
const static long def = 0;
|
|
return def;
|
|
}
|
|
|
|
// Auto generated code (Tools/params_utils.py:375)
|
|
void OverlayParams::setDockOverlayHintRightOffset(const long& v)
|
|
{
|
|
instance()->handle->SetInt("DockOverlayHintRightOffset", v);
|
|
instance()->DockOverlayHintRightOffset = v;
|
|
}
|
|
|
|
// Auto generated code (Tools/params_utils.py:384)
|
|
void OverlayParams::removeDockOverlayHintRightOffset()
|
|
{
|
|
instance()->handle->RemoveInt("DockOverlayHintRightOffset");
|
|
}
|
|
|
|
// Auto generated code (Tools/params_utils.py:350)
|
|
const char* OverlayParams::docDockOverlayHintTopOffset()
|
|
{
|
|
return QT_TRANSLATE_NOOP("OverlayParams", "Auto hide hint visual display offset for top panel");
|
|
}
|
|
|
|
// Auto generated code (Tools/params_utils.py:358)
|
|
const long& OverlayParams::getDockOverlayHintTopOffset()
|
|
{
|
|
return instance()->DockOverlayHintTopOffset;
|
|
}
|
|
|
|
// Auto generated code (Tools/params_utils.py:366)
|
|
const long& OverlayParams::defaultDockOverlayHintTopOffset()
|
|
{
|
|
const static long def = 0;
|
|
return def;
|
|
}
|
|
|
|
// Auto generated code (Tools/params_utils.py:375)
|
|
void OverlayParams::setDockOverlayHintTopOffset(const long& v)
|
|
{
|
|
instance()->handle->SetInt("DockOverlayHintTopOffset", v);
|
|
instance()->DockOverlayHintTopOffset = v;
|
|
}
|
|
|
|
// Auto generated code (Tools/params_utils.py:384)
|
|
void OverlayParams::removeDockOverlayHintTopOffset()
|
|
{
|
|
instance()->handle->RemoveInt("DockOverlayHintTopOffset");
|
|
}
|
|
|
|
// Auto generated code (Tools/params_utils.py:350)
|
|
const char* OverlayParams::docDockOverlayHintBottomOffset()
|
|
{
|
|
return QT_TRANSLATE_NOOP("OverlayParams", "Auto hide hint visual display offset for bottom panel");
|
|
}
|
|
|
|
// Auto generated code (Tools/params_utils.py:358)
|
|
const long& OverlayParams::getDockOverlayHintBottomOffset()
|
|
{
|
|
return instance()->DockOverlayHintBottomOffset;
|
|
}
|
|
|
|
// Auto generated code (Tools/params_utils.py:366)
|
|
const long& OverlayParams::defaultDockOverlayHintBottomOffset()
|
|
{
|
|
const static long def = 0;
|
|
return def;
|
|
}
|
|
|
|
// Auto generated code (Tools/params_utils.py:375)
|
|
void OverlayParams::setDockOverlayHintBottomOffset(const long& v)
|
|
{
|
|
instance()->handle->SetInt("DockOverlayHintBottomOffset", v);
|
|
instance()->DockOverlayHintBottomOffset = v;
|
|
}
|
|
|
|
// Auto generated code (Tools/params_utils.py:384)
|
|
void OverlayParams::removeDockOverlayHintBottomOffset()
|
|
{
|
|
instance()->handle->RemoveInt("DockOverlayHintBottomOffset");
|
|
}
|
|
|
|
// Auto generated code (Tools/params_utils.py:350)
|
|
const char* OverlayParams::docDockOverlayHintTabBar()
|
|
{
|
|
return QT_TRANSLATE_NOOP("OverlayParams", "Show tab bar on mouse over when auto hide");
|
|
}
|
|
|
|
// Auto generated code (Tools/params_utils.py:358)
|
|
const bool& OverlayParams::getDockOverlayHintTabBar()
|
|
{
|
|
return instance()->DockOverlayHintTabBar;
|
|
}
|
|
|
|
// Auto generated code (Tools/params_utils.py:366)
|
|
const bool& OverlayParams::defaultDockOverlayHintTabBar()
|
|
{
|
|
const static bool def = false;
|
|
return def;
|
|
}
|
|
|
|
// Auto generated code (Tools/params_utils.py:375)
|
|
void OverlayParams::setDockOverlayHintTabBar(const bool& v)
|
|
{
|
|
instance()->handle->SetBool("DockOverlayHintTabBar", v);
|
|
instance()->DockOverlayHintTabBar = v;
|
|
}
|
|
|
|
// Auto generated code (Tools/params_utils.py:384)
|
|
void OverlayParams::removeDockOverlayHintTabBar()
|
|
{
|
|
instance()->handle->RemoveBool("DockOverlayHintTabBar");
|
|
}
|
|
|
|
// Auto generated code (Tools/params_utils.py:350)
|
|
const char* OverlayParams::docDockOverlayHideTabBar()
|
|
{
|
|
return QT_TRANSLATE_NOOP("OverlayParams", "Hide tab bar in dock overlay");
|
|
}
|
|
|
|
// Auto generated code (Tools/params_utils.py:358)
|
|
const bool& OverlayParams::getDockOverlayHideTabBar()
|
|
{
|
|
return instance()->DockOverlayHideTabBar;
|
|
}
|
|
|
|
// Auto generated code (Tools/params_utils.py:366)
|
|
const bool& OverlayParams::defaultDockOverlayHideTabBar()
|
|
{
|
|
const static bool def = true;
|
|
return def;
|
|
}
|
|
|
|
// Auto generated code (Tools/params_utils.py:375)
|
|
void OverlayParams::setDockOverlayHideTabBar(const bool& v)
|
|
{
|
|
instance()->handle->SetBool("DockOverlayHideTabBar", v);
|
|
instance()->DockOverlayHideTabBar = v;
|
|
}
|
|
|
|
// Auto generated code (Tools/params_utils.py:384)
|
|
void OverlayParams::removeDockOverlayHideTabBar()
|
|
{
|
|
instance()->handle->RemoveBool("DockOverlayHideTabBar");
|
|
}
|
|
|
|
// Auto generated code (Tools/params_utils.py:350)
|
|
const char* OverlayParams::docDockOverlayHintDelay()
|
|
{
|
|
return QT_TRANSLATE_NOOP("OverlayParams", "Delay before show hint visual");
|
|
}
|
|
|
|
// Auto generated code (Tools/params_utils.py:358)
|
|
const long& OverlayParams::getDockOverlayHintDelay()
|
|
{
|
|
return instance()->DockOverlayHintDelay;
|
|
}
|
|
|
|
// Auto generated code (Tools/params_utils.py:366)
|
|
const long& OverlayParams::defaultDockOverlayHintDelay()
|
|
{
|
|
const static long def = 200;
|
|
return def;
|
|
}
|
|
|
|
// Auto generated code (Tools/params_utils.py:375)
|
|
void OverlayParams::setDockOverlayHintDelay(const long& v)
|
|
{
|
|
instance()->handle->SetInt("DockOverlayHintDelay", v);
|
|
instance()->DockOverlayHintDelay = v;
|
|
}
|
|
|
|
// Auto generated code (Tools/params_utils.py:384)
|
|
void OverlayParams::removeDockOverlayHintDelay()
|
|
{
|
|
instance()->handle->RemoveInt("DockOverlayHintDelay");
|
|
}
|
|
|
|
// Auto generated code (Tools/params_utils.py:350)
|
|
const char* OverlayParams::docDockOverlayAnimationDuration()
|
|
{
|
|
return QT_TRANSLATE_NOOP("OverlayParams", "Auto hide animation duration, 0 to disable");
|
|
}
|
|
|
|
// Auto generated code (Tools/params_utils.py:358)
|
|
const long& OverlayParams::getDockOverlayAnimationDuration()
|
|
{
|
|
return instance()->DockOverlayAnimationDuration;
|
|
}
|
|
|
|
// Auto generated code (Tools/params_utils.py:366)
|
|
const long& OverlayParams::defaultDockOverlayAnimationDuration()
|
|
{
|
|
const static long def = 200;
|
|
return def;
|
|
}
|
|
|
|
// Auto generated code (Tools/params_utils.py:375)
|
|
void OverlayParams::setDockOverlayAnimationDuration(const long& v)
|
|
{
|
|
instance()->handle->SetInt("DockOverlayAnimationDuration", v);
|
|
instance()->DockOverlayAnimationDuration = v;
|
|
}
|
|
|
|
// Auto generated code (Tools/params_utils.py:384)
|
|
void OverlayParams::removeDockOverlayAnimationDuration()
|
|
{
|
|
instance()->handle->RemoveInt("DockOverlayAnimationDuration");
|
|
}
|
|
|
|
// Auto generated code (Tools/params_utils.py:350)
|
|
const char* OverlayParams::docDockOverlayAnimationCurve()
|
|
{
|
|
return QT_TRANSLATE_NOOP("OverlayParams", "Auto hide animation curve type");
|
|
}
|
|
|
|
// Auto generated code (Tools/params_utils.py:358)
|
|
const long& OverlayParams::getDockOverlayAnimationCurve()
|
|
{
|
|
return instance()->DockOverlayAnimationCurve;
|
|
}
|
|
|
|
// Auto generated code (Tools/params_utils.py:366)
|
|
const long& OverlayParams::defaultDockOverlayAnimationCurve()
|
|
{
|
|
const static long def = 7;
|
|
return def;
|
|
}
|
|
|
|
// Auto generated code (Tools/params_utils.py:375)
|
|
void OverlayParams::setDockOverlayAnimationCurve(const long& v)
|
|
{
|
|
instance()->handle->SetInt("DockOverlayAnimationCurve", v);
|
|
instance()->DockOverlayAnimationCurve = v;
|
|
}
|
|
|
|
// Auto generated code (Tools/params_utils.py:384)
|
|
void OverlayParams::removeDockOverlayAnimationCurve()
|
|
{
|
|
instance()->handle->RemoveInt("DockOverlayAnimationCurve");
|
|
}
|
|
|
|
// Auto generated code (Tools/params_utils.py:350)
|
|
const char* OverlayParams::docDockOverlayHidePropertyViewScrollBar()
|
|
{
|
|
return QT_TRANSLATE_NOOP("OverlayParams", "Hide property view scroll bar in dock overlay");
|
|
}
|
|
|
|
// Auto generated code (Tools/params_utils.py:358)
|
|
const bool& OverlayParams::getDockOverlayHidePropertyViewScrollBar()
|
|
{
|
|
return instance()->DockOverlayHidePropertyViewScrollBar;
|
|
}
|
|
|
|
// Auto generated code (Tools/params_utils.py:366)
|
|
const bool& OverlayParams::defaultDockOverlayHidePropertyViewScrollBar()
|
|
{
|
|
const static bool def = false;
|
|
return def;
|
|
}
|
|
|
|
// Auto generated code (Tools/params_utils.py:375)
|
|
void OverlayParams::setDockOverlayHidePropertyViewScrollBar(const bool& v)
|
|
{
|
|
instance()->handle->SetBool("DockOverlayHidePropertyViewScrollBar", v);
|
|
instance()->DockOverlayHidePropertyViewScrollBar = v;
|
|
}
|
|
|
|
// Auto generated code (Tools/params_utils.py:384)
|
|
void OverlayParams::removeDockOverlayHidePropertyViewScrollBar()
|
|
{
|
|
instance()->handle->RemoveBool("DockOverlayHidePropertyViewScrollBar");
|
|
}
|
|
|
|
// Auto generated code (Tools/params_utils.py:350)
|
|
const char* OverlayParams::docDockOverlayMinimumSize()
|
|
{
|
|
return QT_TRANSLATE_NOOP("OverlayParams", "Minimum overlay dock widget width/height");
|
|
}
|
|
|
|
// Auto generated code (Tools/params_utils.py:358)
|
|
const long& OverlayParams::getDockOverlayMinimumSize()
|
|
{
|
|
return instance()->DockOverlayMinimumSize;
|
|
}
|
|
|
|
// Auto generated code (Tools/params_utils.py:366)
|
|
const long& OverlayParams::defaultDockOverlayMinimumSize()
|
|
{
|
|
const static long def = 30;
|
|
return def;
|
|
}
|
|
|
|
// Auto generated code (Tools/params_utils.py:375)
|
|
void OverlayParams::setDockOverlayMinimumSize(const long& v)
|
|
{
|
|
instance()->handle->SetInt("DockOverlayMinimumSize", v);
|
|
instance()->DockOverlayMinimumSize = v;
|
|
}
|
|
|
|
// Auto generated code (Tools/params_utils.py:384)
|
|
void OverlayParams::removeDockOverlayMinimumSize()
|
|
{
|
|
instance()->handle->RemoveInt("DockOverlayMinimumSize");
|
|
}
|
|
|
|
// Auto generated code (Gui/OverlayParams.py:171)
|
|
const std::vector<QString> OverlayParams::AnimationCurveTypes = {
|
|
QStringLiteral("Linear"), QStringLiteral("InQuad"), QStringLiteral("OutQuad"),
|
|
QStringLiteral("InOutQuad"), QStringLiteral("OutInQuad"), QStringLiteral("InCubic"),
|
|
QStringLiteral("OutCubic"), QStringLiteral("InOutCubic"), QStringLiteral("OutInCubic"),
|
|
QStringLiteral("InQuart"), QStringLiteral("OutQuart"), QStringLiteral("InOutQuart"),
|
|
QStringLiteral("OutInQuart"), QStringLiteral("InQuint"), QStringLiteral("OutQuint"),
|
|
QStringLiteral("InOutQuint"), QStringLiteral("OutInQuint"), QStringLiteral("InSine"),
|
|
QStringLiteral("OutSine"), QStringLiteral("InOutSine"), QStringLiteral("OutInSine"),
|
|
QStringLiteral("InExpo"), QStringLiteral("OutExpo"), QStringLiteral("InOutExpo"),
|
|
QStringLiteral("OutInExpo"), QStringLiteral("InCirc"), QStringLiteral("OutCirc"),
|
|
QStringLiteral("InOutCirc"), QStringLiteral("OutInCirc"), QStringLiteral("InElastic"),
|
|
QStringLiteral("OutElastic"), QStringLiteral("InOutElastic"), QStringLiteral("OutInElastic"),
|
|
QStringLiteral("InBack"), QStringLiteral("OutBack"), QStringLiteral("InOutBack"),
|
|
QStringLiteral("OutInBack"), QStringLiteral("InBounce"), QStringLiteral("OutBounce"),
|
|
QStringLiteral("InOutBounce"), QStringLiteral("OutInBounce"),
|
|
};
|
|
//[[[end]]]
|
|
|
|
void OverlayParams::onDockOverlayAutoViewChanged()
|
|
{
|
|
OverlayManager::instance()->refresh();
|
|
}
|
|
|
|
void OverlayParams::onDockOverlayCheckNaviCubeChanged()
|
|
{
|
|
OverlayManager::instance()->refresh();
|
|
}
|
|
|
|
void OverlayParams::onDockOverlayHideTabBarChanged()
|
|
{
|
|
OverlayManager::instance()->refresh(nullptr, true);
|
|
}
|
|
|
|
void OverlayParams::onDockOverlayMinimumSizeChanged()
|
|
{
|
|
OverlayManager::instance()->refresh();
|
|
}
|