/****************************************************************************
 *   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();
}