FreeCAD

1
/****************************************************************************
2
 *   Copyright (c) 2022 Zheng Lei (realthunder) <realthunder.dev@gmail.com> *
3
 *                                                                          *
4
 *   This file is part of the FreeCAD CAx development system.               *
5
 *                                                                          *
6
 *   This library is free software; you can redistribute it and/or          *
7
 *   modify it under the terms of the GNU Library General Public            *
8
 *   License as published by the Free Software Foundation; either           *
9
 *   version 2 of the License, or (at your option) any later version.       *
10
 *                                                                          *
11
 *   This library  is distributed in the hope that it will be useful,       *
12
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of         *
13
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the          *
14
 *   GNU Library General Public License for more details.                   *
15
 *                                                                          *
16
 *   You should have received a copy of the GNU Library General Public      *
17
 *   License along with this library; see the file COPYING.LIB. If not,     *
18
 *   write to the Free Software Foundation, Inc., 59 Temple Place,          *
19
 *   Suite 330, Boston, MA  02111-1307, USA                                 *
20
 *                                                                          *
21
 ****************************************************************************/
22

23
#include "PreCompiled.h"
24
#include "OverlayManager.h"
25

26
/*[[[cog
27
import OverlayParams
28
OverlayParams.define()
29
]]]*/
30

31
// Auto generated code (Tools/params_utils.py:196)
32
#include <unordered_map>
33
#include <App/Application.h>
34
#include <App/DynamicProperty.h>
35
#include "OverlayParams.h"
36
using namespace Gui;
37

38
// Auto generated code (Tools/params_utils.py:207)
39
namespace {
40
class OverlayParamsP: public ParameterGrp::ObserverType {
41
public:
42
    ParameterGrp::handle handle;
43
    std::unordered_map<const char *,void(*)(OverlayParamsP*),App::CStringHasher,App::CStringHasher> funcs;
44

45
    bool DockOverlayAutoView;
46
    long DockOverlayDelay;
47
    long DockOverlayRevealDelay;
48
    long DockOverlaySplitterHandleTimeout;
49
    bool DockOverlayActivateOnHover;
50
    bool DockOverlayAutoMouseThrough;
51
    bool DockOverlayWheelPassThrough;
52
    long DockOverlayWheelDelay;
53
    long DockOverlayAlphaRadius;
54
    bool DockOverlayCheckNaviCube;
55
    long DockOverlayHintTriggerSize;
56
    long DockOverlayHintSize;
57
    long DockOverlayHintLeftLength;
58
    long DockOverlayHintRightLength;
59
    long DockOverlayHintTopLength;
60
    long DockOverlayHintBottomLength;
61
    long DockOverlayHintLeftOffset;
62
    long DockOverlayHintRightOffset;
63
    long DockOverlayHintTopOffset;
64
    long DockOverlayHintBottomOffset;
65
    bool DockOverlayHintTabBar;
66
    bool DockOverlayHideTabBar;
67
    long DockOverlayHintDelay;
68
    long DockOverlayAnimationDuration;
69
    long DockOverlayAnimationCurve;
70
    bool DockOverlayHidePropertyViewScrollBar;
71
    long DockOverlayMinimumSize;
72

73
    // Auto generated code (Tools/params_utils.py:245)
74
    OverlayParamsP() {
75
        handle = App::GetApplication().GetParameterGroupByPath("User parameter:BaseApp/Preferences/View");
76
        handle->Attach(this);
77

78
        DockOverlayAutoView = handle->GetBool("DockOverlayAutoView", true);
79
        funcs["DockOverlayAutoView"] = &OverlayParamsP::updateDockOverlayAutoView;
80
        DockOverlayDelay = handle->GetInt("DockOverlayDelay", 200);
81
        funcs["DockOverlayDelay"] = &OverlayParamsP::updateDockOverlayDelay;
82
        DockOverlayRevealDelay = handle->GetInt("DockOverlayRevealDelay", 2000);
83
        funcs["DockOverlayRevealDelay"] = &OverlayParamsP::updateDockOverlayRevealDelay;
84
        DockOverlaySplitterHandleTimeout = handle->GetInt("DockOverlaySplitterHandleTimeout", 0);
85
        funcs["DockOverlaySplitterHandleTimeout"] = &OverlayParamsP::updateDockOverlaySplitterHandleTimeout;
86
        DockOverlayActivateOnHover = handle->GetBool("DockOverlayActivateOnHover", true);
87
        funcs["DockOverlayActivateOnHover"] = &OverlayParamsP::updateDockOverlayActivateOnHover;
88
        DockOverlayAutoMouseThrough = handle->GetBool("DockOverlayAutoMouseThrough", true);
89
        funcs["DockOverlayAutoMouseThrough"] = &OverlayParamsP::updateDockOverlayAutoMouseThrough;
90
        DockOverlayWheelPassThrough = handle->GetBool("DockOverlayWheelPassThrough", true);
91
        funcs["DockOverlayWheelPassThrough"] = &OverlayParamsP::updateDockOverlayWheelPassThrough;
92
        DockOverlayWheelDelay = handle->GetInt("DockOverlayWheelDelay", 1000);
93
        funcs["DockOverlayWheelDelay"] = &OverlayParamsP::updateDockOverlayWheelDelay;
94
        DockOverlayAlphaRadius = handle->GetInt("DockOverlayAlphaRadius", 2);
95
        funcs["DockOverlayAlphaRadius"] = &OverlayParamsP::updateDockOverlayAlphaRadius;
96
        DockOverlayCheckNaviCube = handle->GetBool("DockOverlayCheckNaviCube", true);
97
        funcs["DockOverlayCheckNaviCube"] = &OverlayParamsP::updateDockOverlayCheckNaviCube;
98
        DockOverlayHintTriggerSize = handle->GetInt("DockOverlayHintTriggerSize", 16);
99
        funcs["DockOverlayHintTriggerSize"] = &OverlayParamsP::updateDockOverlayHintTriggerSize;
100
        DockOverlayHintSize = handle->GetInt("DockOverlayHintSize", 8);
101
        funcs["DockOverlayHintSize"] = &OverlayParamsP::updateDockOverlayHintSize;
102
        DockOverlayHintLeftLength = handle->GetInt("DockOverlayHintLeftLength", 100);
103
        funcs["DockOverlayHintLeftLength"] = &OverlayParamsP::updateDockOverlayHintLeftLength;
104
        DockOverlayHintRightLength = handle->GetInt("DockOverlayHintRightLength", 100);
105
        funcs["DockOverlayHintRightLength"] = &OverlayParamsP::updateDockOverlayHintRightLength;
106
        DockOverlayHintTopLength = handle->GetInt("DockOverlayHintTopLength", 100);
107
        funcs["DockOverlayHintTopLength"] = &OverlayParamsP::updateDockOverlayHintTopLength;
108
        DockOverlayHintBottomLength = handle->GetInt("DockOverlayHintBottomLength", 100);
109
        funcs["DockOverlayHintBottomLength"] = &OverlayParamsP::updateDockOverlayHintBottomLength;
110
        DockOverlayHintLeftOffset = handle->GetInt("DockOverlayHintLeftOffset", 0);
111
        funcs["DockOverlayHintLeftOffset"] = &OverlayParamsP::updateDockOverlayHintLeftOffset;
112
        DockOverlayHintRightOffset = handle->GetInt("DockOverlayHintRightOffset", 0);
113
        funcs["DockOverlayHintRightOffset"] = &OverlayParamsP::updateDockOverlayHintRightOffset;
114
        DockOverlayHintTopOffset = handle->GetInt("DockOverlayHintTopOffset", 0);
115
        funcs["DockOverlayHintTopOffset"] = &OverlayParamsP::updateDockOverlayHintTopOffset;
116
        DockOverlayHintBottomOffset = handle->GetInt("DockOverlayHintBottomOffset", 0);
117
        funcs["DockOverlayHintBottomOffset"] = &OverlayParamsP::updateDockOverlayHintBottomOffset;
118
        DockOverlayHintTabBar = handle->GetBool("DockOverlayHintTabBar", false);
119
        funcs["DockOverlayHintTabBar"] = &OverlayParamsP::updateDockOverlayHintTabBar;
120
        DockOverlayHideTabBar = handle->GetBool("DockOverlayHideTabBar", true);
121
        funcs["DockOverlayHideTabBar"] = &OverlayParamsP::updateDockOverlayHideTabBar;
122
        DockOverlayHintDelay = handle->GetInt("DockOverlayHintDelay", 200);
123
        funcs["DockOverlayHintDelay"] = &OverlayParamsP::updateDockOverlayHintDelay;
124
        DockOverlayAnimationDuration = handle->GetInt("DockOverlayAnimationDuration", 200);
125
        funcs["DockOverlayAnimationDuration"] = &OverlayParamsP::updateDockOverlayAnimationDuration;
126
        DockOverlayAnimationCurve = handle->GetInt("DockOverlayAnimationCurve", 7);
127
        funcs["DockOverlayAnimationCurve"] = &OverlayParamsP::updateDockOverlayAnimationCurve;
128
        DockOverlayHidePropertyViewScrollBar = handle->GetBool("DockOverlayHidePropertyViewScrollBar", false);
129
        funcs["DockOverlayHidePropertyViewScrollBar"] = &OverlayParamsP::updateDockOverlayHidePropertyViewScrollBar;
130
        DockOverlayMinimumSize = handle->GetInt("DockOverlayMinimumSize", 30);
131
        funcs["DockOverlayMinimumSize"] = &OverlayParamsP::updateDockOverlayMinimumSize;
132
    }
133

134
    // Auto generated code (Tools/params_utils.py:263)
135
    ~OverlayParamsP() {
136
    }
137

138
    // Auto generated code (Tools/params_utils.py:270)
139
    void OnChange(Base::Subject<const char*> &, const char* sReason) {
140
        if(!sReason)
141
            return;
142
        auto it = funcs.find(sReason);
143
        if(it == funcs.end())
144
            return;
145
        it->second(this);
146
    }
147

148

149
    // Auto generated code (Tools/params_utils.py:296)
150
    static void updateDockOverlayAutoView(OverlayParamsP *self) {
151
        auto v = self->handle->GetBool("DockOverlayAutoView", true);
152
        if (self->DockOverlayAutoView != v) {
153
            self->DockOverlayAutoView = v;
154
            OverlayParams::onDockOverlayAutoViewChanged();
155
        }
156
    }
157
    // Auto generated code (Tools/params_utils.py:288)
158
    static void updateDockOverlayDelay(OverlayParamsP *self) {
159
        self->DockOverlayDelay = self->handle->GetInt("DockOverlayDelay", 200);
160
    }
161
    // Auto generated code (Tools/params_utils.py:288)
162
    static void updateDockOverlayRevealDelay(OverlayParamsP *self) {
163
        self->DockOverlayRevealDelay = self->handle->GetInt("DockOverlayRevealDelay", 2000);
164
    }
165
    // Auto generated code (Tools/params_utils.py:288)
166
    static void updateDockOverlaySplitterHandleTimeout(OverlayParamsP *self) {
167
        self->DockOverlaySplitterHandleTimeout = self->handle->GetInt("DockOverlaySplitterHandleTimeout", 0);
168
    }
169
    // Auto generated code (Tools/params_utils.py:288)
170
    static void updateDockOverlayActivateOnHover(OverlayParamsP *self) {
171
        self->DockOverlayActivateOnHover = self->handle->GetBool("DockOverlayActivateOnHover", true);
172
    }
173
    // Auto generated code (Tools/params_utils.py:288)
174
    static void updateDockOverlayAutoMouseThrough(OverlayParamsP *self) {
175
        self->DockOverlayAutoMouseThrough = self->handle->GetBool("DockOverlayAutoMouseThrough", true);
176
    }
177
    // Auto generated code (Tools/params_utils.py:288)
178
    static void updateDockOverlayWheelPassThrough(OverlayParamsP *self) {
179
        self->DockOverlayWheelPassThrough = self->handle->GetBool("DockOverlayWheelPassThrough", true);
180
    }
181
    // Auto generated code (Tools/params_utils.py:288)
182
    static void updateDockOverlayWheelDelay(OverlayParamsP *self) {
183
        self->DockOverlayWheelDelay = self->handle->GetInt("DockOverlayWheelDelay", 1000);
184
    }
185
    // Auto generated code (Tools/params_utils.py:288)
186
    static void updateDockOverlayAlphaRadius(OverlayParamsP *self) {
187
        self->DockOverlayAlphaRadius = self->handle->GetInt("DockOverlayAlphaRadius", 2);
188
    }
189
    // Auto generated code (Tools/params_utils.py:296)
190
    static void updateDockOverlayCheckNaviCube(OverlayParamsP *self) {
191
        auto v = self->handle->GetBool("DockOverlayCheckNaviCube", true);
192
        if (self->DockOverlayCheckNaviCube != v) {
193
            self->DockOverlayCheckNaviCube = v;
194
            OverlayParams::onDockOverlayCheckNaviCubeChanged();
195
        }
196
    }
197
    // Auto generated code (Tools/params_utils.py:288)
198
    static void updateDockOverlayHintTriggerSize(OverlayParamsP *self) {
199
        self->DockOverlayHintTriggerSize = self->handle->GetInt("DockOverlayHintTriggerSize", 16);
200
    }
201
    // Auto generated code (Tools/params_utils.py:288)
202
    static void updateDockOverlayHintSize(OverlayParamsP *self) {
203
        self->DockOverlayHintSize = self->handle->GetInt("DockOverlayHintSize", 8);
204
    }
205
    // Auto generated code (Tools/params_utils.py:288)
206
    static void updateDockOverlayHintLeftLength(OverlayParamsP *self) {
207
        self->DockOverlayHintLeftLength = self->handle->GetInt("DockOverlayHintLeftLength", 100);
208
    }
209
    // Auto generated code (Tools/params_utils.py:288)
210
    static void updateDockOverlayHintRightLength(OverlayParamsP *self) {
211
        self->DockOverlayHintRightLength = self->handle->GetInt("DockOverlayHintRightLength", 100);
212
    }
213
    // Auto generated code (Tools/params_utils.py:288)
214
    static void updateDockOverlayHintTopLength(OverlayParamsP *self) {
215
        self->DockOverlayHintTopLength = self->handle->GetInt("DockOverlayHintTopLength", 100);
216
    }
217
    // Auto generated code (Tools/params_utils.py:288)
218
    static void updateDockOverlayHintBottomLength(OverlayParamsP *self) {
219
        self->DockOverlayHintBottomLength = self->handle->GetInt("DockOverlayHintBottomLength", 100);
220
    }
221
    // Auto generated code (Tools/params_utils.py:288)
222
    static void updateDockOverlayHintLeftOffset(OverlayParamsP *self) {
223
        self->DockOverlayHintLeftOffset = self->handle->GetInt("DockOverlayHintLeftOffset", 0);
224
    }
225
    // Auto generated code (Tools/params_utils.py:288)
226
    static void updateDockOverlayHintRightOffset(OverlayParamsP *self) {
227
        self->DockOverlayHintRightOffset = self->handle->GetInt("DockOverlayHintRightOffset", 0);
228
    }
229
    // Auto generated code (Tools/params_utils.py:288)
230
    static void updateDockOverlayHintTopOffset(OverlayParamsP *self) {
231
        self->DockOverlayHintTopOffset = self->handle->GetInt("DockOverlayHintTopOffset", 0);
232
    }
233
    // Auto generated code (Tools/params_utils.py:288)
234
    static void updateDockOverlayHintBottomOffset(OverlayParamsP *self) {
235
        self->DockOverlayHintBottomOffset = self->handle->GetInt("DockOverlayHintBottomOffset", 0);
236
    }
237
    // Auto generated code (Tools/params_utils.py:288)
238
    static void updateDockOverlayHintTabBar(OverlayParamsP *self) {
239
        self->DockOverlayHintTabBar = self->handle->GetBool("DockOverlayHintTabBar", false);
240
    }
241
    // Auto generated code (Tools/params_utils.py:296)
242
    static void updateDockOverlayHideTabBar(OverlayParamsP *self) {
243
        auto v = self->handle->GetBool("DockOverlayHideTabBar", true);
244
        if (self->DockOverlayHideTabBar != v) {
245
            self->DockOverlayHideTabBar = v;
246
            OverlayParams::onDockOverlayHideTabBarChanged();
247
        }
248
    }
249
    // Auto generated code (Tools/params_utils.py:288)
250
    static void updateDockOverlayHintDelay(OverlayParamsP *self) {
251
        self->DockOverlayHintDelay = self->handle->GetInt("DockOverlayHintDelay", 200);
252
    }
253
    // Auto generated code (Tools/params_utils.py:288)
254
    static void updateDockOverlayAnimationDuration(OverlayParamsP *self) {
255
        self->DockOverlayAnimationDuration = self->handle->GetInt("DockOverlayAnimationDuration", 200);
256
    }
257
    // Auto generated code (Tools/params_utils.py:288)
258
    static void updateDockOverlayAnimationCurve(OverlayParamsP *self) {
259
        self->DockOverlayAnimationCurve = self->handle->GetInt("DockOverlayAnimationCurve", 7);
260
    }
261
    // Auto generated code (Tools/params_utils.py:288)
262
    static void updateDockOverlayHidePropertyViewScrollBar(OverlayParamsP *self) {
263
        self->DockOverlayHidePropertyViewScrollBar = self->handle->GetBool("DockOverlayHidePropertyViewScrollBar", false);
264
    }
265
    // Auto generated code (Tools/params_utils.py:296)
266
    static void updateDockOverlayMinimumSize(OverlayParamsP *self) {
267
        auto v = self->handle->GetInt("DockOverlayMinimumSize", 30);
268
        if (self->DockOverlayMinimumSize != v) {
269
            self->DockOverlayMinimumSize = v;
270
            OverlayParams::onDockOverlayMinimumSizeChanged();
271
        }
272
    }
273
};
274

275
// Auto generated code (Tools/params_utils.py:310)
276
OverlayParamsP *instance() {
277
    static OverlayParamsP *inst = new OverlayParamsP;
278
    return inst;
279
}
280

281
} // Anonymous namespace
282

283
// Auto generated code (Tools/params_utils.py:321)
284
ParameterGrp::handle OverlayParams::getHandle() {
285
    return instance()->handle;
286
}
287

288
// Auto generated code (Tools/params_utils.py:350)
289
const char *OverlayParams::docDockOverlayAutoView() {
290
    return "";
291
}
292

293
// Auto generated code (Tools/params_utils.py:358)
294
const bool & OverlayParams::getDockOverlayAutoView() {
295
    return instance()->DockOverlayAutoView;
296
}
297

298
// Auto generated code (Tools/params_utils.py:366)
299
const bool & OverlayParams::defaultDockOverlayAutoView() {
300
    const static bool def = true;
301
    return def;
302
}
303

304
// Auto generated code (Tools/params_utils.py:375)
305
void OverlayParams::setDockOverlayAutoView(const bool &v) {
306
    instance()->handle->SetBool("DockOverlayAutoView",v);
307
    instance()->DockOverlayAutoView = v;
308
}
309

310
// Auto generated code (Tools/params_utils.py:384)
311
void OverlayParams::removeDockOverlayAutoView() {
312
    instance()->handle->RemoveBool("DockOverlayAutoView");
313
}
314

315
// Auto generated code (Tools/params_utils.py:350)
316
const char *OverlayParams::docDockOverlayDelay() {
317
    return QT_TRANSLATE_NOOP("OverlayParams",
318
"Overlay dock (re),layout delay.");
319
}
320

321
// Auto generated code (Tools/params_utils.py:358)
322
const long & OverlayParams::getDockOverlayDelay() {
323
    return instance()->DockOverlayDelay;
324
}
325

326
// Auto generated code (Tools/params_utils.py:366)
327
const long & OverlayParams::defaultDockOverlayDelay() {
328
    const static long def = 200;
329
    return def;
330
}
331

332
// Auto generated code (Tools/params_utils.py:375)
333
void OverlayParams::setDockOverlayDelay(const long &v) {
334
    instance()->handle->SetInt("DockOverlayDelay",v);
335
    instance()->DockOverlayDelay = v;
336
}
337

338
// Auto generated code (Tools/params_utils.py:384)
339
void OverlayParams::removeDockOverlayDelay() {
340
    instance()->handle->RemoveInt("DockOverlayDelay");
341
}
342

343
// Auto generated code (Tools/params_utils.py:350)
344
const char *OverlayParams::docDockOverlayRevealDelay() {
345
    return "";
346
}
347

348
// Auto generated code (Tools/params_utils.py:358)
349
const long & OverlayParams::getDockOverlayRevealDelay() {
350
    return instance()->DockOverlayRevealDelay;
351
}
352

353
// Auto generated code (Tools/params_utils.py:366)
354
const long & OverlayParams::defaultDockOverlayRevealDelay() {
355
    const static long def = 2000;
356
    return def;
357
}
358

359
// Auto generated code (Tools/params_utils.py:375)
360
void OverlayParams::setDockOverlayRevealDelay(const long &v) {
361
    instance()->handle->SetInt("DockOverlayRevealDelay",v);
362
    instance()->DockOverlayRevealDelay = v;
363
}
364

365
// Auto generated code (Tools/params_utils.py:384)
366
void OverlayParams::removeDockOverlayRevealDelay() {
367
    instance()->handle->RemoveInt("DockOverlayRevealDelay");
368
}
369

370
// Auto generated code (Tools/params_utils.py:350)
371
const char *OverlayParams::docDockOverlaySplitterHandleTimeout() {
372
    return QT_TRANSLATE_NOOP("OverlayParams",
373
"Overlay splitter handle auto hide delay. Set zero to disable auto hiding.");
374
}
375

376
// Auto generated code (Tools/params_utils.py:358)
377
const long & OverlayParams::getDockOverlaySplitterHandleTimeout() {
378
    return instance()->DockOverlaySplitterHandleTimeout;
379
}
380

381
// Auto generated code (Tools/params_utils.py:366)
382
const long & OverlayParams::defaultDockOverlaySplitterHandleTimeout() {
383
    const static long def = 0;
384
    return def;
385
}
386

387
// Auto generated code (Tools/params_utils.py:375)
388
void OverlayParams::setDockOverlaySplitterHandleTimeout(const long &v) {
389
    instance()->handle->SetInt("DockOverlaySplitterHandleTimeout",v);
390
    instance()->DockOverlaySplitterHandleTimeout = v;
391
}
392

393
// Auto generated code (Tools/params_utils.py:384)
394
void OverlayParams::removeDockOverlaySplitterHandleTimeout() {
395
    instance()->handle->RemoveInt("DockOverlaySplitterHandleTimeout");
396
}
397

398
// Auto generated code (Tools/params_utils.py:350)
399
const char *OverlayParams::docDockOverlayActivateOnHover() {
400
    return QT_TRANSLATE_NOOP("OverlayParams",
401
"Show auto hidden dock overlay on mouse over.\n"
402
"If disabled, then show on mouse click.");
403
}
404

405
// Auto generated code (Tools/params_utils.py:358)
406
const bool & OverlayParams::getDockOverlayActivateOnHover() {
407
    return instance()->DockOverlayActivateOnHover;
408
}
409

410
// Auto generated code (Tools/params_utils.py:366)
411
const bool & OverlayParams::defaultDockOverlayActivateOnHover() {
412
    const static bool def = true;
413
    return def;
414
}
415

416
// Auto generated code (Tools/params_utils.py:375)
417
void OverlayParams::setDockOverlayActivateOnHover(const bool &v) {
418
    instance()->handle->SetBool("DockOverlayActivateOnHover",v);
419
    instance()->DockOverlayActivateOnHover = v;
420
}
421

422
// Auto generated code (Tools/params_utils.py:384)
423
void OverlayParams::removeDockOverlayActivateOnHover() {
424
    instance()->handle->RemoveBool("DockOverlayActivateOnHover");
425
}
426

427
// Auto generated code (Tools/params_utils.py:350)
428
const char *OverlayParams::docDockOverlayAutoMouseThrough() {
429
    return QT_TRANSLATE_NOOP("OverlayParams",
430
"Auto mouse click through transparent part of dock overlay.");
431
}
432

433
// Auto generated code (Tools/params_utils.py:358)
434
const bool & OverlayParams::getDockOverlayAutoMouseThrough() {
435
    return instance()->DockOverlayAutoMouseThrough;
436
}
437

438
// Auto generated code (Tools/params_utils.py:366)
439
const bool & OverlayParams::defaultDockOverlayAutoMouseThrough() {
440
    const static bool def = true;
441
    return def;
442
}
443

444
// Auto generated code (Tools/params_utils.py:375)
445
void OverlayParams::setDockOverlayAutoMouseThrough(const bool &v) {
446
    instance()->handle->SetBool("DockOverlayAutoMouseThrough",v);
447
    instance()->DockOverlayAutoMouseThrough = v;
448
}
449

450
// Auto generated code (Tools/params_utils.py:384)
451
void OverlayParams::removeDockOverlayAutoMouseThrough() {
452
    instance()->handle->RemoveBool("DockOverlayAutoMouseThrough");
453
}
454

455
// Auto generated code (Tools/params_utils.py:350)
456
const char *OverlayParams::docDockOverlayWheelPassThrough() {
457
    return QT_TRANSLATE_NOOP("OverlayParams",
458
"Auto pass through mouse wheel event on transparent dock overlay.");
459
}
460

461
// Auto generated code (Tools/params_utils.py:358)
462
const bool & OverlayParams::getDockOverlayWheelPassThrough() {
463
    return instance()->DockOverlayWheelPassThrough;
464
}
465

466
// Auto generated code (Tools/params_utils.py:366)
467
const bool & OverlayParams::defaultDockOverlayWheelPassThrough() {
468
    const static bool def = true;
469
    return def;
470
}
471

472
// Auto generated code (Tools/params_utils.py:375)
473
void OverlayParams::setDockOverlayWheelPassThrough(const bool &v) {
474
    instance()->handle->SetBool("DockOverlayWheelPassThrough",v);
475
    instance()->DockOverlayWheelPassThrough = v;
476
}
477

478
// Auto generated code (Tools/params_utils.py:384)
479
void OverlayParams::removeDockOverlayWheelPassThrough() {
480
    instance()->handle->RemoveBool("DockOverlayWheelPassThrough");
481
}
482

483
// Auto generated code (Tools/params_utils.py:350)
484
const char *OverlayParams::docDockOverlayWheelDelay() {
485
    return QT_TRANSLATE_NOOP("OverlayParams",
486
"Delay capturing mouse wheel event for passing through if it is\n"
487
"previously handled by other widget.");
488
}
489

490
// Auto generated code (Tools/params_utils.py:358)
491
const long & OverlayParams::getDockOverlayWheelDelay() {
492
    return instance()->DockOverlayWheelDelay;
493
}
494

495
// Auto generated code (Tools/params_utils.py:366)
496
const long & OverlayParams::defaultDockOverlayWheelDelay() {
497
    const static long def = 1000;
498
    return def;
499
}
500

501
// Auto generated code (Tools/params_utils.py:375)
502
void OverlayParams::setDockOverlayWheelDelay(const long &v) {
503
    instance()->handle->SetInt("DockOverlayWheelDelay",v);
504
    instance()->DockOverlayWheelDelay = v;
505
}
506

507
// Auto generated code (Tools/params_utils.py:384)
508
void OverlayParams::removeDockOverlayWheelDelay() {
509
    instance()->handle->RemoveInt("DockOverlayWheelDelay");
510
}
511

512
// Auto generated code (Tools/params_utils.py:350)
513
const char *OverlayParams::docDockOverlayAlphaRadius() {
514
    return QT_TRANSLATE_NOOP("OverlayParams",
515
"If auto mouse click through is enabled, then this radius\n"
516
"defines a region of alpha test under the mouse cursor.\n"
517
"Auto click through is only activated if all pixels within\n"
518
"the region are non-opaque.");
519
}
520

521
// Auto generated code (Tools/params_utils.py:358)
522
const long & OverlayParams::getDockOverlayAlphaRadius() {
523
    return instance()->DockOverlayAlphaRadius;
524
}
525

526
// Auto generated code (Tools/params_utils.py:366)
527
const long & OverlayParams::defaultDockOverlayAlphaRadius() {
528
    const static long def = 2;
529
    return def;
530
}
531

532
// Auto generated code (Tools/params_utils.py:375)
533
void OverlayParams::setDockOverlayAlphaRadius(const long &v) {
534
    instance()->handle->SetInt("DockOverlayAlphaRadius",v);
535
    instance()->DockOverlayAlphaRadius = v;
536
}
537

538
// Auto generated code (Tools/params_utils.py:384)
539
void OverlayParams::removeDockOverlayAlphaRadius() {
540
    instance()->handle->RemoveInt("DockOverlayAlphaRadius");
541
}
542

543
// Auto generated code (Tools/params_utils.py:350)
544
const char *OverlayParams::docDockOverlayCheckNaviCube() {
545
    return QT_TRANSLATE_NOOP("OverlayParams",
546
"Leave space for Navigation Cube in dock overlay");
547
}
548

549
// Auto generated code (Tools/params_utils.py:358)
550
const bool & OverlayParams::getDockOverlayCheckNaviCube() {
551
    return instance()->DockOverlayCheckNaviCube;
552
}
553

554
// Auto generated code (Tools/params_utils.py:366)
555
const bool & OverlayParams::defaultDockOverlayCheckNaviCube() {
556
    const static bool def = true;
557
    return def;
558
}
559

560
// Auto generated code (Tools/params_utils.py:375)
561
void OverlayParams::setDockOverlayCheckNaviCube(const bool &v) {
562
    instance()->handle->SetBool("DockOverlayCheckNaviCube",v);
563
    instance()->DockOverlayCheckNaviCube = v;
564
}
565

566
// Auto generated code (Tools/params_utils.py:384)
567
void OverlayParams::removeDockOverlayCheckNaviCube() {
568
    instance()->handle->RemoveBool("DockOverlayCheckNaviCube");
569
}
570

571
// Auto generated code (Tools/params_utils.py:350)
572
const char *OverlayParams::docDockOverlayHintTriggerSize() {
573
    return QT_TRANSLATE_NOOP("OverlayParams",
574
"Auto hide hint visual display triggering width");
575
}
576

577
// Auto generated code (Tools/params_utils.py:358)
578
const long & OverlayParams::getDockOverlayHintTriggerSize() {
579
    return instance()->DockOverlayHintTriggerSize;
580
}
581

582
// Auto generated code (Tools/params_utils.py:366)
583
const long & OverlayParams::defaultDockOverlayHintTriggerSize() {
584
    const static long def = 16;
585
    return def;
586
}
587

588
// Auto generated code (Tools/params_utils.py:375)
589
void OverlayParams::setDockOverlayHintTriggerSize(const long &v) {
590
    instance()->handle->SetInt("DockOverlayHintTriggerSize",v);
591
    instance()->DockOverlayHintTriggerSize = v;
592
}
593

594
// Auto generated code (Tools/params_utils.py:384)
595
void OverlayParams::removeDockOverlayHintTriggerSize() {
596
    instance()->handle->RemoveInt("DockOverlayHintTriggerSize");
597
}
598

599
// Auto generated code (Tools/params_utils.py:350)
600
const char *OverlayParams::docDockOverlayHintSize() {
601
    return QT_TRANSLATE_NOOP("OverlayParams",
602
"Auto hide hint visual display width");
603
}
604

605
// Auto generated code (Tools/params_utils.py:358)
606
const long & OverlayParams::getDockOverlayHintSize() {
607
    return instance()->DockOverlayHintSize;
608
}
609

610
// Auto generated code (Tools/params_utils.py:366)
611
const long & OverlayParams::defaultDockOverlayHintSize() {
612
    const static long def = 8;
613
    return def;
614
}
615

616
// Auto generated code (Tools/params_utils.py:375)
617
void OverlayParams::setDockOverlayHintSize(const long &v) {
618
    instance()->handle->SetInt("DockOverlayHintSize",v);
619
    instance()->DockOverlayHintSize = v;
620
}
621

622
// Auto generated code (Tools/params_utils.py:384)
623
void OverlayParams::removeDockOverlayHintSize() {
624
    instance()->handle->RemoveInt("DockOverlayHintSize");
625
}
626

627
// Auto generated code (Tools/params_utils.py:350)
628
const char *OverlayParams::docDockOverlayHintLeftLength() {
629
    return QT_TRANSLATE_NOOP("OverlayParams",
630
"Auto hide hint visual display length for left panel. Set to zero to fill the space.");
631
}
632

633
// Auto generated code (Tools/params_utils.py:358)
634
const long & OverlayParams::getDockOverlayHintLeftLength() {
635
    return instance()->DockOverlayHintLeftLength;
636
}
637

638
// Auto generated code (Tools/params_utils.py:366)
639
const long & OverlayParams::defaultDockOverlayHintLeftLength() {
640
    const static long def = 100;
641
    return def;
642
}
643

644
// Auto generated code (Tools/params_utils.py:375)
645
void OverlayParams::setDockOverlayHintLeftLength(const long &v) {
646
    instance()->handle->SetInt("DockOverlayHintLeftLength",v);
647
    instance()->DockOverlayHintLeftLength = v;
648
}
649

650
// Auto generated code (Tools/params_utils.py:384)
651
void OverlayParams::removeDockOverlayHintLeftLength() {
652
    instance()->handle->RemoveInt("DockOverlayHintLeftLength");
653
}
654

655
// Auto generated code (Tools/params_utils.py:350)
656
const char *OverlayParams::docDockOverlayHintRightLength() {
657
    return QT_TRANSLATE_NOOP("OverlayParams",
658
"Auto hide hint visual display length for right panel. Set to zero to fill the space.");
659
}
660

661
// Auto generated code (Tools/params_utils.py:358)
662
const long & OverlayParams::getDockOverlayHintRightLength() {
663
    return instance()->DockOverlayHintRightLength;
664
}
665

666
// Auto generated code (Tools/params_utils.py:366)
667
const long & OverlayParams::defaultDockOverlayHintRightLength() {
668
    const static long def = 100;
669
    return def;
670
}
671

672
// Auto generated code (Tools/params_utils.py:375)
673
void OverlayParams::setDockOverlayHintRightLength(const long &v) {
674
    instance()->handle->SetInt("DockOverlayHintRightLength",v);
675
    instance()->DockOverlayHintRightLength = v;
676
}
677

678
// Auto generated code (Tools/params_utils.py:384)
679
void OverlayParams::removeDockOverlayHintRightLength() {
680
    instance()->handle->RemoveInt("DockOverlayHintRightLength");
681
}
682

683
// Auto generated code (Tools/params_utils.py:350)
684
const char *OverlayParams::docDockOverlayHintTopLength() {
685
    return QT_TRANSLATE_NOOP("OverlayParams",
686
"Auto hide hint visual display length for top panel. Set to zero to fill the space.");
687
}
688

689
// Auto generated code (Tools/params_utils.py:358)
690
const long & OverlayParams::getDockOverlayHintTopLength() {
691
    return instance()->DockOverlayHintTopLength;
692
}
693

694
// Auto generated code (Tools/params_utils.py:366)
695
const long & OverlayParams::defaultDockOverlayHintTopLength() {
696
    const static long def = 100;
697
    return def;
698
}
699

700
// Auto generated code (Tools/params_utils.py:375)
701
void OverlayParams::setDockOverlayHintTopLength(const long &v) {
702
    instance()->handle->SetInt("DockOverlayHintTopLength",v);
703
    instance()->DockOverlayHintTopLength = v;
704
}
705

706
// Auto generated code (Tools/params_utils.py:384)
707
void OverlayParams::removeDockOverlayHintTopLength() {
708
    instance()->handle->RemoveInt("DockOverlayHintTopLength");
709
}
710

711
// Auto generated code (Tools/params_utils.py:350)
712
const char *OverlayParams::docDockOverlayHintBottomLength() {
713
    return QT_TRANSLATE_NOOP("OverlayParams",
714
"Auto hide hint visual display length for bottom panel. Set to zero to fill the space.");
715
}
716

717
// Auto generated code (Tools/params_utils.py:358)
718
const long & OverlayParams::getDockOverlayHintBottomLength() {
719
    return instance()->DockOverlayHintBottomLength;
720
}
721

722
// Auto generated code (Tools/params_utils.py:366)
723
const long & OverlayParams::defaultDockOverlayHintBottomLength() {
724
    const static long def = 100;
725
    return def;
726
}
727

728
// Auto generated code (Tools/params_utils.py:375)
729
void OverlayParams::setDockOverlayHintBottomLength(const long &v) {
730
    instance()->handle->SetInt("DockOverlayHintBottomLength",v);
731
    instance()->DockOverlayHintBottomLength = v;
732
}
733

734
// Auto generated code (Tools/params_utils.py:384)
735
void OverlayParams::removeDockOverlayHintBottomLength() {
736
    instance()->handle->RemoveInt("DockOverlayHintBottomLength");
737
}
738

739
// Auto generated code (Tools/params_utils.py:350)
740
const char *OverlayParams::docDockOverlayHintLeftOffset() {
741
    return QT_TRANSLATE_NOOP("OverlayParams",
742
"Auto hide hint visual display offset for left panel");
743
}
744

745
// Auto generated code (Tools/params_utils.py:358)
746
const long & OverlayParams::getDockOverlayHintLeftOffset() {
747
    return instance()->DockOverlayHintLeftOffset;
748
}
749

750
// Auto generated code (Tools/params_utils.py:366)
751
const long & OverlayParams::defaultDockOverlayHintLeftOffset() {
752
    const static long def = 0;
753
    return def;
754
}
755

756
// Auto generated code (Tools/params_utils.py:375)
757
void OverlayParams::setDockOverlayHintLeftOffset(const long &v) {
758
    instance()->handle->SetInt("DockOverlayHintLeftOffset",v);
759
    instance()->DockOverlayHintLeftOffset = v;
760
}
761

762
// Auto generated code (Tools/params_utils.py:384)
763
void OverlayParams::removeDockOverlayHintLeftOffset() {
764
    instance()->handle->RemoveInt("DockOverlayHintLeftOffset");
765
}
766

767
// Auto generated code (Tools/params_utils.py:350)
768
const char *OverlayParams::docDockOverlayHintRightOffset() {
769
    return QT_TRANSLATE_NOOP("OverlayParams",
770
"Auto hide hint visual display offset for right panel");
771
}
772

773
// Auto generated code (Tools/params_utils.py:358)
774
const long & OverlayParams::getDockOverlayHintRightOffset() {
775
    return instance()->DockOverlayHintRightOffset;
776
}
777

778
// Auto generated code (Tools/params_utils.py:366)
779
const long & OverlayParams::defaultDockOverlayHintRightOffset() {
780
    const static long def = 0;
781
    return def;
782
}
783

784
// Auto generated code (Tools/params_utils.py:375)
785
void OverlayParams::setDockOverlayHintRightOffset(const long &v) {
786
    instance()->handle->SetInt("DockOverlayHintRightOffset",v);
787
    instance()->DockOverlayHintRightOffset = v;
788
}
789

790
// Auto generated code (Tools/params_utils.py:384)
791
void OverlayParams::removeDockOverlayHintRightOffset() {
792
    instance()->handle->RemoveInt("DockOverlayHintRightOffset");
793
}
794

795
// Auto generated code (Tools/params_utils.py:350)
796
const char *OverlayParams::docDockOverlayHintTopOffset() {
797
    return QT_TRANSLATE_NOOP("OverlayParams",
798
"Auto hide hint visual display offset for top panel");
799
}
800

801
// Auto generated code (Tools/params_utils.py:358)
802
const long & OverlayParams::getDockOverlayHintTopOffset() {
803
    return instance()->DockOverlayHintTopOffset;
804
}
805

806
// Auto generated code (Tools/params_utils.py:366)
807
const long & OverlayParams::defaultDockOverlayHintTopOffset() {
808
    const static long def = 0;
809
    return def;
810
}
811

812
// Auto generated code (Tools/params_utils.py:375)
813
void OverlayParams::setDockOverlayHintTopOffset(const long &v) {
814
    instance()->handle->SetInt("DockOverlayHintTopOffset",v);
815
    instance()->DockOverlayHintTopOffset = v;
816
}
817

818
// Auto generated code (Tools/params_utils.py:384)
819
void OverlayParams::removeDockOverlayHintTopOffset() {
820
    instance()->handle->RemoveInt("DockOverlayHintTopOffset");
821
}
822

823
// Auto generated code (Tools/params_utils.py:350)
824
const char *OverlayParams::docDockOverlayHintBottomOffset() {
825
    return QT_TRANSLATE_NOOP("OverlayParams",
826
"Auto hide hint visual display offset for bottom panel");
827
}
828

829
// Auto generated code (Tools/params_utils.py:358)
830
const long & OverlayParams::getDockOverlayHintBottomOffset() {
831
    return instance()->DockOverlayHintBottomOffset;
832
}
833

834
// Auto generated code (Tools/params_utils.py:366)
835
const long & OverlayParams::defaultDockOverlayHintBottomOffset() {
836
    const static long def = 0;
837
    return def;
838
}
839

840
// Auto generated code (Tools/params_utils.py:375)
841
void OverlayParams::setDockOverlayHintBottomOffset(const long &v) {
842
    instance()->handle->SetInt("DockOverlayHintBottomOffset",v);
843
    instance()->DockOverlayHintBottomOffset = v;
844
}
845

846
// Auto generated code (Tools/params_utils.py:384)
847
void OverlayParams::removeDockOverlayHintBottomOffset() {
848
    instance()->handle->RemoveInt("DockOverlayHintBottomOffset");
849
}
850

851
// Auto generated code (Tools/params_utils.py:350)
852
const char *OverlayParams::docDockOverlayHintTabBar() {
853
    return QT_TRANSLATE_NOOP("OverlayParams",
854
"Show tab bar on mouse over when auto hide");
855
}
856

857
// Auto generated code (Tools/params_utils.py:358)
858
const bool & OverlayParams::getDockOverlayHintTabBar() {
859
    return instance()->DockOverlayHintTabBar;
860
}
861

862
// Auto generated code (Tools/params_utils.py:366)
863
const bool & OverlayParams::defaultDockOverlayHintTabBar() {
864
    const static bool def = false;
865
    return def;
866
}
867

868
// Auto generated code (Tools/params_utils.py:375)
869
void OverlayParams::setDockOverlayHintTabBar(const bool &v) {
870
    instance()->handle->SetBool("DockOverlayHintTabBar",v);
871
    instance()->DockOverlayHintTabBar = v;
872
}
873

874
// Auto generated code (Tools/params_utils.py:384)
875
void OverlayParams::removeDockOverlayHintTabBar() {
876
    instance()->handle->RemoveBool("DockOverlayHintTabBar");
877
}
878

879
// Auto generated code (Tools/params_utils.py:350)
880
const char *OverlayParams::docDockOverlayHideTabBar() {
881
    return QT_TRANSLATE_NOOP("OverlayParams",
882
"Hide tab bar in dock overlay");
883
}
884

885
// Auto generated code (Tools/params_utils.py:358)
886
const bool & OverlayParams::getDockOverlayHideTabBar() {
887
    return instance()->DockOverlayHideTabBar;
888
}
889

890
// Auto generated code (Tools/params_utils.py:366)
891
const bool & OverlayParams::defaultDockOverlayHideTabBar() {
892
    const static bool def = true;
893
    return def;
894
}
895

896
// Auto generated code (Tools/params_utils.py:375)
897
void OverlayParams::setDockOverlayHideTabBar(const bool &v) {
898
    instance()->handle->SetBool("DockOverlayHideTabBar",v);
899
    instance()->DockOverlayHideTabBar = v;
900
}
901

902
// Auto generated code (Tools/params_utils.py:384)
903
void OverlayParams::removeDockOverlayHideTabBar() {
904
    instance()->handle->RemoveBool("DockOverlayHideTabBar");
905
}
906

907
// Auto generated code (Tools/params_utils.py:350)
908
const char *OverlayParams::docDockOverlayHintDelay() {
909
    return QT_TRANSLATE_NOOP("OverlayParams",
910
"Delay before show hint visual");
911
}
912

913
// Auto generated code (Tools/params_utils.py:358)
914
const long & OverlayParams::getDockOverlayHintDelay() {
915
    return instance()->DockOverlayHintDelay;
916
}
917

918
// Auto generated code (Tools/params_utils.py:366)
919
const long & OverlayParams::defaultDockOverlayHintDelay() {
920
    const static long def = 200;
921
    return def;
922
}
923

924
// Auto generated code (Tools/params_utils.py:375)
925
void OverlayParams::setDockOverlayHintDelay(const long &v) {
926
    instance()->handle->SetInt("DockOverlayHintDelay",v);
927
    instance()->DockOverlayHintDelay = v;
928
}
929

930
// Auto generated code (Tools/params_utils.py:384)
931
void OverlayParams::removeDockOverlayHintDelay() {
932
    instance()->handle->RemoveInt("DockOverlayHintDelay");
933
}
934

935
// Auto generated code (Tools/params_utils.py:350)
936
const char *OverlayParams::docDockOverlayAnimationDuration() {
937
    return QT_TRANSLATE_NOOP("OverlayParams",
938
"Auto hide animation duration, 0 to disable");
939
}
940

941
// Auto generated code (Tools/params_utils.py:358)
942
const long & OverlayParams::getDockOverlayAnimationDuration() {
943
    return instance()->DockOverlayAnimationDuration;
944
}
945

946
// Auto generated code (Tools/params_utils.py:366)
947
const long & OverlayParams::defaultDockOverlayAnimationDuration() {
948
    const static long def = 200;
949
    return def;
950
}
951

952
// Auto generated code (Tools/params_utils.py:375)
953
void OverlayParams::setDockOverlayAnimationDuration(const long &v) {
954
    instance()->handle->SetInt("DockOverlayAnimationDuration",v);
955
    instance()->DockOverlayAnimationDuration = v;
956
}
957

958
// Auto generated code (Tools/params_utils.py:384)
959
void OverlayParams::removeDockOverlayAnimationDuration() {
960
    instance()->handle->RemoveInt("DockOverlayAnimationDuration");
961
}
962

963
// Auto generated code (Tools/params_utils.py:350)
964
const char *OverlayParams::docDockOverlayAnimationCurve() {
965
    return QT_TRANSLATE_NOOP("OverlayParams",
966
"Auto hide animation curve type");
967
}
968

969
// Auto generated code (Tools/params_utils.py:358)
970
const long & OverlayParams::getDockOverlayAnimationCurve() {
971
    return instance()->DockOverlayAnimationCurve;
972
}
973

974
// Auto generated code (Tools/params_utils.py:366)
975
const long & OverlayParams::defaultDockOverlayAnimationCurve() {
976
    const static long def = 7;
977
    return def;
978
}
979

980
// Auto generated code (Tools/params_utils.py:375)
981
void OverlayParams::setDockOverlayAnimationCurve(const long &v) {
982
    instance()->handle->SetInt("DockOverlayAnimationCurve",v);
983
    instance()->DockOverlayAnimationCurve = v;
984
}
985

986
// Auto generated code (Tools/params_utils.py:384)
987
void OverlayParams::removeDockOverlayAnimationCurve() {
988
    instance()->handle->RemoveInt("DockOverlayAnimationCurve");
989
}
990

991
// Auto generated code (Tools/params_utils.py:350)
992
const char *OverlayParams::docDockOverlayHidePropertyViewScrollBar() {
993
    return QT_TRANSLATE_NOOP("OverlayParams",
994
"Hide property view scroll bar in dock overlay");
995
}
996

997
// Auto generated code (Tools/params_utils.py:358)
998
const bool & OverlayParams::getDockOverlayHidePropertyViewScrollBar() {
999
    return instance()->DockOverlayHidePropertyViewScrollBar;
1000
}
1001

1002
// Auto generated code (Tools/params_utils.py:366)
1003
const bool & OverlayParams::defaultDockOverlayHidePropertyViewScrollBar() {
1004
    const static bool def = false;
1005
    return def;
1006
}
1007

1008
// Auto generated code (Tools/params_utils.py:375)
1009
void OverlayParams::setDockOverlayHidePropertyViewScrollBar(const bool &v) {
1010
    instance()->handle->SetBool("DockOverlayHidePropertyViewScrollBar",v);
1011
    instance()->DockOverlayHidePropertyViewScrollBar = v;
1012
}
1013

1014
// Auto generated code (Tools/params_utils.py:384)
1015
void OverlayParams::removeDockOverlayHidePropertyViewScrollBar() {
1016
    instance()->handle->RemoveBool("DockOverlayHidePropertyViewScrollBar");
1017
}
1018

1019
// Auto generated code (Tools/params_utils.py:350)
1020
const char *OverlayParams::docDockOverlayMinimumSize() {
1021
    return QT_TRANSLATE_NOOP("OverlayParams",
1022
"Minimum overlay dock widget width/height");
1023
}
1024

1025
// Auto generated code (Tools/params_utils.py:358)
1026
const long & OverlayParams::getDockOverlayMinimumSize() {
1027
    return instance()->DockOverlayMinimumSize;
1028
}
1029

1030
// Auto generated code (Tools/params_utils.py:366)
1031
const long & OverlayParams::defaultDockOverlayMinimumSize() {
1032
    const static long def = 30;
1033
    return def;
1034
}
1035

1036
// Auto generated code (Tools/params_utils.py:375)
1037
void OverlayParams::setDockOverlayMinimumSize(const long &v) {
1038
    instance()->handle->SetInt("DockOverlayMinimumSize",v);
1039
    instance()->DockOverlayMinimumSize = v;
1040
}
1041

1042
// Auto generated code (Tools/params_utils.py:384)
1043
void OverlayParams::removeDockOverlayMinimumSize() {
1044
    instance()->handle->RemoveInt("DockOverlayMinimumSize");
1045
}
1046

1047
// Auto generated code (Gui/OverlayParams.py:171)
1048
const std::vector<QString> OverlayParams::AnimationCurveTypes = {
1049
    QStringLiteral("Linear"),
1050
    QStringLiteral("InQuad"),
1051
    QStringLiteral("OutQuad"),
1052
    QStringLiteral("InOutQuad"),
1053
    QStringLiteral("OutInQuad"),
1054
    QStringLiteral("InCubic"),
1055
    QStringLiteral("OutCubic"),
1056
    QStringLiteral("InOutCubic"),
1057
    QStringLiteral("OutInCubic"),
1058
    QStringLiteral("InQuart"),
1059
    QStringLiteral("OutQuart"),
1060
    QStringLiteral("InOutQuart"),
1061
    QStringLiteral("OutInQuart"),
1062
    QStringLiteral("InQuint"),
1063
    QStringLiteral("OutQuint"),
1064
    QStringLiteral("InOutQuint"),
1065
    QStringLiteral("OutInQuint"),
1066
    QStringLiteral("InSine"),
1067
    QStringLiteral("OutSine"),
1068
    QStringLiteral("InOutSine"),
1069
    QStringLiteral("OutInSine"),
1070
    QStringLiteral("InExpo"),
1071
    QStringLiteral("OutExpo"),
1072
    QStringLiteral("InOutExpo"),
1073
    QStringLiteral("OutInExpo"),
1074
    QStringLiteral("InCirc"),
1075
    QStringLiteral("OutCirc"),
1076
    QStringLiteral("InOutCirc"),
1077
    QStringLiteral("OutInCirc"),
1078
    QStringLiteral("InElastic"),
1079
    QStringLiteral("OutElastic"),
1080
    QStringLiteral("InOutElastic"),
1081
    QStringLiteral("OutInElastic"),
1082
    QStringLiteral("InBack"),
1083
    QStringLiteral("OutBack"),
1084
    QStringLiteral("InOutBack"),
1085
    QStringLiteral("OutInBack"),
1086
    QStringLiteral("InBounce"),
1087
    QStringLiteral("OutBounce"),
1088
    QStringLiteral("InOutBounce"),
1089
    QStringLiteral("OutInBounce"),
1090
};
1091
//[[[end]]]
1092

1093
void OverlayParams::onDockOverlayAutoViewChanged() {
1094
    OverlayManager::instance()->refresh();
1095
}
1096

1097
void OverlayParams::onDockOverlayCheckNaviCubeChanged() {
1098
    OverlayManager::instance()->refresh();
1099
}
1100

1101
void OverlayParams::onDockOverlayHideTabBarChanged() {
1102
    OverlayManager::instance()->refresh(nullptr, true);
1103
}
1104

1105
void OverlayParams::onDockOverlayMinimumSizeChanged() {
1106
    OverlayManager::instance()->refresh();
1107
}
1108

1109