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 "Tree.h"
25

26
/*[[[cog
27
import TreeParams
28
TreeParams.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 "TreeParams.h"
36
using namespace Gui;
37

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

45
    bool SyncSelection;
46
    bool CheckBoxesSelection;
47
    bool SyncView;
48
    bool PreSelection;
49
    bool SyncPlacement;
50
    bool RecordSelection;
51
    long DocumentMode;
52
    long StatusTimeout;
53
    long SelectionTimeout;
54
    long PreSelectionTimeout;
55
    long PreSelectionDelay;
56
    long PreSelectionMinDelay;
57
    bool RecomputeOnDrop;
58
    bool KeepRootOrder;
59
    bool TreeActiveAutoExpand;
60
    unsigned long TreeActiveColor;
61
    unsigned long TreeEditColor;
62
    unsigned long SelectingGroupColor;
63
    bool TreeActiveBold;
64
    bool TreeActiveItalic;
65
    bool TreeActiveUnderlined;
66
    bool TreeActiveOverlined;
67
    long Indentation;
68
    bool LabelExpression;
69
    long IconSize;
70
    long FontSize;
71
    long ItemSpacing;
72
    unsigned long ItemBackground;
73
    long ItemBackgroundPadding;
74
    bool HideColumn;
75
    bool HideScrollBar;
76
    bool HideHeaderView;
77
    bool ResizableColumn;
78
    long ColumnSize1;
79
    long ColumnSize2;
80
    bool TreeToolTipIcon;
81
    bool VisibilityIcon;
82

83
    // Auto generated code (Tools/params_utils.py:245)
84
    TreeParamsP() {
85
        handle = App::GetApplication().GetParameterGroupByPath("User parameter:BaseApp/Preferences/TreeView");
86
        handle->Attach(this);
87

88
        SyncSelection = handle->GetBool("SyncSelection", true);
89
        funcs["SyncSelection"] = &TreeParamsP::updateSyncSelection;
90
        CheckBoxesSelection = handle->GetBool("CheckBoxesSelection", false);
91
        funcs["CheckBoxesSelection"] = &TreeParamsP::updateCheckBoxesSelection;
92
        SyncView = handle->GetBool("SyncView", true);
93
        funcs["SyncView"] = &TreeParamsP::updateSyncView;
94
        PreSelection = handle->GetBool("PreSelection", true);
95
        funcs["PreSelection"] = &TreeParamsP::updatePreSelection;
96
        SyncPlacement = handle->GetBool("SyncPlacement", false);
97
        funcs["SyncPlacement"] = &TreeParamsP::updateSyncPlacement;
98
        RecordSelection = handle->GetBool("RecordSelection", true);
99
        funcs["RecordSelection"] = &TreeParamsP::updateRecordSelection;
100
        DocumentMode = handle->GetInt("DocumentMode", 2);
101
        funcs["DocumentMode"] = &TreeParamsP::updateDocumentMode;
102
        StatusTimeout = handle->GetInt("StatusTimeout", 100);
103
        funcs["StatusTimeout"] = &TreeParamsP::updateStatusTimeout;
104
        SelectionTimeout = handle->GetInt("SelectionTimeout", 100);
105
        funcs["SelectionTimeout"] = &TreeParamsP::updateSelectionTimeout;
106
        PreSelectionTimeout = handle->GetInt("PreSelectionTimeout", 500);
107
        funcs["PreSelectionTimeout"] = &TreeParamsP::updatePreSelectionTimeout;
108
        PreSelectionDelay = handle->GetInt("PreSelectionDelay", 700);
109
        funcs["PreSelectionDelay"] = &TreeParamsP::updatePreSelectionDelay;
110
        PreSelectionMinDelay = handle->GetInt("PreSelectionMinDelay", 200);
111
        funcs["PreSelectionMinDelay"] = &TreeParamsP::updatePreSelectionMinDelay;
112
        RecomputeOnDrop = handle->GetBool("RecomputeOnDrop", true);
113
        funcs["RecomputeOnDrop"] = &TreeParamsP::updateRecomputeOnDrop;
114
        KeepRootOrder = handle->GetBool("KeepRootOrder", true);
115
        funcs["KeepRootOrder"] = &TreeParamsP::updateKeepRootOrder;
116
        TreeActiveAutoExpand = handle->GetBool("TreeActiveAutoExpand", true);
117
        funcs["TreeActiveAutoExpand"] = &TreeParamsP::updateTreeActiveAutoExpand;
118
        TreeActiveColor = handle->GetUnsigned("TreeActiveColor", 3873898495);
119
        funcs["TreeActiveColor"] = &TreeParamsP::updateTreeActiveColor;
120
        TreeEditColor = handle->GetUnsigned("TreeEditColor", 2459042047);
121
        funcs["TreeEditColor"] = &TreeParamsP::updateTreeEditColor;
122
        SelectingGroupColor = handle->GetUnsigned("SelectingGroupColor", 1082163711);
123
        funcs["SelectingGroupColor"] = &TreeParamsP::updateSelectingGroupColor;
124
        TreeActiveBold = handle->GetBool("TreeActiveBold", true);
125
        funcs["TreeActiveBold"] = &TreeParamsP::updateTreeActiveBold;
126
        TreeActiveItalic = handle->GetBool("TreeActiveItalic", false);
127
        funcs["TreeActiveItalic"] = &TreeParamsP::updateTreeActiveItalic;
128
        TreeActiveUnderlined = handle->GetBool("TreeActiveUnderlined", false);
129
        funcs["TreeActiveUnderlined"] = &TreeParamsP::updateTreeActiveUnderlined;
130
        TreeActiveOverlined = handle->GetBool("TreeActiveOverlined", false);
131
        funcs["TreeActiveOverlined"] = &TreeParamsP::updateTreeActiveOverlined;
132
        Indentation = handle->GetInt("Indentation", 0);
133
        funcs["Indentation"] = &TreeParamsP::updateIndentation;
134
        LabelExpression = handle->GetBool("LabelExpression", false);
135
        funcs["LabelExpression"] = &TreeParamsP::updateLabelExpression;
136
        IconSize = handle->GetInt("IconSize", 0);
137
        funcs["IconSize"] = &TreeParamsP::updateIconSize;
138
        FontSize = handle->GetInt("FontSize", 0);
139
        funcs["FontSize"] = &TreeParamsP::updateFontSize;
140
        ItemSpacing = handle->GetInt("ItemSpacing", 0);
141
        funcs["ItemSpacing"] = &TreeParamsP::updateItemSpacing;
142
        ItemBackground = handle->GetUnsigned("ItemBackground", 0x00000000);
143
        funcs["ItemBackground"] = &TreeParamsP::updateItemBackground;
144
        ItemBackgroundPadding = handle->GetInt("ItemBackgroundPadding", 0);
145
        funcs["ItemBackgroundPadding"] = &TreeParamsP::updateItemBackgroundPadding;
146
        HideColumn = handle->GetBool("HideColumn", true);
147
        funcs["HideColumn"] = &TreeParamsP::updateHideColumn;
148
        HideScrollBar = handle->GetBool("HideScrollBar", true);
149
        funcs["HideScrollBar"] = &TreeParamsP::updateHideScrollBar;
150
        HideHeaderView = handle->GetBool("HideHeaderView", true);
151
        funcs["HideHeaderView"] = &TreeParamsP::updateHideHeaderView;
152
        ResizableColumn = handle->GetBool("ResizableColumn", false);
153
        funcs["ResizableColumn"] = &TreeParamsP::updateResizableColumn;
154
        ColumnSize1 = handle->GetInt("ColumnSize1", 0);
155
        funcs["ColumnSize1"] = &TreeParamsP::updateColumnSize1;
156
        ColumnSize2 = handle->GetInt("ColumnSize2", 0);
157
        funcs["ColumnSize2"] = &TreeParamsP::updateColumnSize2;
158
        TreeToolTipIcon = handle->GetBool("TreeToolTipIcon", false);
159
        funcs["TreeToolTipIcon"] = &TreeParamsP::updateTreeToolTipIcon;
160
        VisibilityIcon = handle->GetBool("VisibilityIcon", false);
161
        funcs["VisibilityIcon"] = &TreeParamsP::updateVisibilityIcon;
162
    }
163

164
    // Auto generated code (Tools/params_utils.py:263)
165
    ~TreeParamsP() {
166
    }
167

168
    // Auto generated code (Tools/params_utils.py:270)
169
    void OnChange(Base::Subject<const char*> &, const char* sReason) {
170
        if(!sReason)
171
            return;
172
        auto it = funcs.find(sReason);
173
        if(it == funcs.end())
174
            return;
175
        it->second(this);
176
        
177
    }
178

179

180
    // Auto generated code (Tools/params_utils.py:296)
181
    static void updateSyncSelection(TreeParamsP *self) {
182
        auto v = self->handle->GetBool("SyncSelection", true);
183
        if (self->SyncSelection != v) {
184
            self->SyncSelection = v;
185
            TreeParams::onSyncSelectionChanged();
186
        }
187
    }
188
    // Auto generated code (Tools/params_utils.py:296)
189
    static void updateCheckBoxesSelection(TreeParamsP *self) {
190
        auto v = self->handle->GetBool("CheckBoxesSelection", false);
191
        if (self->CheckBoxesSelection != v) {
192
            self->CheckBoxesSelection = v;
193
            TreeParams::onCheckBoxesSelectionChanged();
194
        }
195
    }
196
    // Auto generated code (Tools/params_utils.py:288)
197
    static void updateSyncView(TreeParamsP *self) {
198
        self->SyncView = self->handle->GetBool("SyncView", true);
199
    }
200
    // Auto generated code (Tools/params_utils.py:288)
201
    static void updatePreSelection(TreeParamsP *self) {
202
        self->PreSelection = self->handle->GetBool("PreSelection", true);
203
    }
204
    // Auto generated code (Tools/params_utils.py:288)
205
    static void updateSyncPlacement(TreeParamsP *self) {
206
        self->SyncPlacement = self->handle->GetBool("SyncPlacement", false);
207
    }
208
    // Auto generated code (Tools/params_utils.py:288)
209
    static void updateRecordSelection(TreeParamsP *self) {
210
        self->RecordSelection = self->handle->GetBool("RecordSelection", true);
211
    }
212
    // Auto generated code (Tools/params_utils.py:296)
213
    static void updateDocumentMode(TreeParamsP *self) {
214
        auto v = self->handle->GetInt("DocumentMode", 2);
215
        if (self->DocumentMode != v) {
216
            self->DocumentMode = v;
217
            TreeParams::onDocumentModeChanged();
218
        }
219
    }
220
    // Auto generated code (Tools/params_utils.py:288)
221
    static void updateStatusTimeout(TreeParamsP *self) {
222
        self->StatusTimeout = self->handle->GetInt("StatusTimeout", 100);
223
    }
224
    // Auto generated code (Tools/params_utils.py:288)
225
    static void updateSelectionTimeout(TreeParamsP *self) {
226
        self->SelectionTimeout = self->handle->GetInt("SelectionTimeout", 100);
227
    }
228
    // Auto generated code (Tools/params_utils.py:288)
229
    static void updatePreSelectionTimeout(TreeParamsP *self) {
230
        self->PreSelectionTimeout = self->handle->GetInt("PreSelectionTimeout", 500);
231
    }
232
    // Auto generated code (Tools/params_utils.py:288)
233
    static void updatePreSelectionDelay(TreeParamsP *self) {
234
        self->PreSelectionDelay = self->handle->GetInt("PreSelectionDelay", 700);
235
    }
236
    // Auto generated code (Tools/params_utils.py:288)
237
    static void updatePreSelectionMinDelay(TreeParamsP *self) {
238
        self->PreSelectionMinDelay = self->handle->GetInt("PreSelectionMinDelay", 200);
239
    }
240
    // Auto generated code (Tools/params_utils.py:288)
241
    static void updateRecomputeOnDrop(TreeParamsP *self) {
242
        self->RecomputeOnDrop = self->handle->GetBool("RecomputeOnDrop", true);
243
    }
244
    // Auto generated code (Tools/params_utils.py:288)
245
    static void updateKeepRootOrder(TreeParamsP *self) {
246
        self->KeepRootOrder = self->handle->GetBool("KeepRootOrder", true);
247
    }
248
    // Auto generated code (Tools/params_utils.py:288)
249
    static void updateTreeActiveAutoExpand(TreeParamsP *self) {
250
        self->TreeActiveAutoExpand = self->handle->GetBool("TreeActiveAutoExpand", true);
251
    }
252
    // Auto generated code (Tools/params_utils.py:296)
253
    static void updateTreeActiveColor(TreeParamsP *self) {
254
        auto v = self->handle->GetUnsigned("TreeActiveColor", 3873898495);
255
        if (self->TreeActiveColor != v) {
256
            self->TreeActiveColor = v;
257
            TreeParams::onTreeActiveColorChanged();
258
        }
259
    }
260
    // Auto generated code (Tools/params_utils.py:296)
261
    static void updateTreeEditColor(TreeParamsP *self) {
262
        auto v = self->handle->GetUnsigned("TreeEditColor", 2459042047);
263
        if (self->TreeEditColor != v) {
264
            self->TreeEditColor = v;
265
            TreeParams::onTreeEditColorChanged();
266
        }
267
    }
268
    // Auto generated code (Tools/params_utils.py:296)
269
    static void updateSelectingGroupColor(TreeParamsP *self) {
270
        auto v = self->handle->GetUnsigned("SelectingGroupColor", 1082163711);
271
        if (self->SelectingGroupColor != v) {
272
            self->SelectingGroupColor = v;
273
            TreeParams::onSelectingGroupColorChanged();
274
        }
275
    }
276
    // Auto generated code (Tools/params_utils.py:296)
277
    static void updateTreeActiveBold(TreeParamsP *self) {
278
        auto v = self->handle->GetBool("TreeActiveBold", true);
279
        if (self->TreeActiveBold != v) {
280
            self->TreeActiveBold = v;
281
            TreeParams::onTreeActiveBoldChanged();
282
        }
283
    }
284
    // Auto generated code (Tools/params_utils.py:296)
285
    static void updateTreeActiveItalic(TreeParamsP *self) {
286
        auto v = self->handle->GetBool("TreeActiveItalic", false);
287
        if (self->TreeActiveItalic != v) {
288
            self->TreeActiveItalic = v;
289
            TreeParams::onTreeActiveItalicChanged();
290
        }
291
    }
292
    // Auto generated code (Tools/params_utils.py:296)
293
    static void updateTreeActiveUnderlined(TreeParamsP *self) {
294
        auto v = self->handle->GetBool("TreeActiveUnderlined", false);
295
        if (self->TreeActiveUnderlined != v) {
296
            self->TreeActiveUnderlined = v;
297
            TreeParams::onTreeActiveUnderlinedChanged();
298
        }
299
    }
300
    // Auto generated code (Tools/params_utils.py:296)
301
    static void updateTreeActiveOverlined(TreeParamsP *self) {
302
        auto v = self->handle->GetBool("TreeActiveOverlined", false);
303
        if (self->TreeActiveOverlined != v) {
304
            self->TreeActiveOverlined = v;
305
            TreeParams::onTreeActiveOverlinedChanged();
306
        }
307
    }
308
    // Auto generated code (Tools/params_utils.py:296)
309
    static void updateIndentation(TreeParamsP *self) {
310
        auto v = self->handle->GetInt("Indentation", 0);
311
        if (self->Indentation != v) {
312
            self->Indentation = v;
313
            TreeParams::onIndentationChanged();
314
        }
315
    }
316
    // Auto generated code (Tools/params_utils.py:288)
317
    static void updateLabelExpression(TreeParamsP *self) {
318
        self->LabelExpression = self->handle->GetBool("LabelExpression", false);
319
    }
320
    // Auto generated code (Tools/params_utils.py:296)
321
    static void updateIconSize(TreeParamsP *self) {
322
        auto v = self->handle->GetInt("IconSize", 0);
323
        if (self->IconSize != v) {
324
            self->IconSize = v;
325
            TreeParams::onIconSizeChanged();
326
        }
327
    }
328
    // Auto generated code (Tools/params_utils.py:296)
329
    static void updateFontSize(TreeParamsP *self) {
330
        auto v = self->handle->GetInt("FontSize", 0);
331
        if (self->FontSize != v) {
332
            self->FontSize = v;
333
            TreeParams::onFontSizeChanged();
334
        }
335
    }
336
    // Auto generated code (Tools/params_utils.py:296)
337
    static void updateItemSpacing(TreeParamsP *self) {
338
        auto v = self->handle->GetInt("ItemSpacing", 0);
339
        if (self->ItemSpacing != v) {
340
            self->ItemSpacing = v;
341
            TreeParams::onItemSpacingChanged();
342
        }
343
    }
344
    // Auto generated code (Tools/params_utils.py:296)
345
    static void updateItemBackground(TreeParamsP *self) {
346
        auto v = self->handle->GetUnsigned("ItemBackground", 0x00000000);
347
        if (self->ItemBackground != v) {
348
            self->ItemBackground = v;
349
            TreeParams::onItemBackgroundChanged();
350
        }
351
    }
352
    // Auto generated code (Tools/params_utils.py:296)
353
    static void updateItemBackgroundPadding(TreeParamsP *self) {
354
        auto v = self->handle->GetInt("ItemBackgroundPadding", 0);
355
        if (self->ItemBackgroundPadding != v) {
356
            self->ItemBackgroundPadding = v;
357
            TreeParams::onItemBackgroundPaddingChanged();
358
        }
359
    }
360
    // Auto generated code (Tools/params_utils.py:296)
361
    static void updateHideColumn(TreeParamsP *self) {
362
        auto v = self->handle->GetBool("HideColumn", true);
363
        if (self->HideColumn != v) {
364
            self->HideColumn = v;
365
            TreeParams::onHideColumnChanged();
366
        }
367
    }
368
    // Auto generated code (Tools/params_utils.py:288)
369
    static void updateHideScrollBar(TreeParamsP *self) {
370
        self->HideScrollBar = self->handle->GetBool("HideScrollBar", true);
371
    }
372
    // Auto generated code (Tools/params_utils.py:288)
373
    static void updateHideHeaderView(TreeParamsP *self) {
374
        self->HideHeaderView = self->handle->GetBool("HideHeaderView", true);
375
    }
376
    // Auto generated code (Tools/params_utils.py:296)
377
    static void updateResizableColumn(TreeParamsP *self) {
378
        auto v = self->handle->GetBool("ResizableColumn", false);
379
        if (self->ResizableColumn != v) {
380
            self->ResizableColumn = v;
381
            TreeParams::onResizableColumnChanged();
382
        }
383
    }
384
    // Auto generated code (Tools/params_utils.py:288)
385
    static void updateColumnSize1(TreeParamsP *self) {
386
        self->ColumnSize1 = self->handle->GetInt("ColumnSize1", 0);
387
    }
388
    // Auto generated code (Tools/params_utils.py:288)
389
    static void updateColumnSize2(TreeParamsP *self) {
390
        self->ColumnSize2 = self->handle->GetInt("ColumnSize2", 0);
391
    }
392
    // Auto generated code (Tools/params_utils.py:288)
393
    static void updateTreeToolTipIcon(TreeParamsP *self) {
394
        self->TreeToolTipIcon = self->handle->GetBool("TreeToolTipIcon", false);
395
    }
396
    // Auto generated code (Tools/params_utils.py:296)
397
    static void updateVisibilityIcon(TreeParamsP *self) {
398
        auto v = self->handle->GetBool("VisibilityIcon", false);
399
        if (self->VisibilityIcon != v) {
400
            self->VisibilityIcon = v;
401
            TreeParams::onVisibilityIconChanged();
402
        }
403
    }
404
};
405

406
// Auto generated code (Tools/params_utils.py:310)
407
TreeParamsP *instance() {
408
    static TreeParamsP *inst = new TreeParamsP;
409
    return inst;
410
}
411

412
} // Anonymous namespace
413

414
// Auto generated code (Tools/params_utils.py:321)
415
ParameterGrp::handle TreeParams::getHandle() {
416
    return instance()->handle;
417
}
418

419
// Auto generated code (Tools/params_utils.py:350)
420
const char *TreeParams::docSyncSelection() {
421
    return "";
422
}
423

424
// Auto generated code (Tools/params_utils.py:358)
425
const bool & TreeParams::getSyncSelection() {
426
    return instance()->SyncSelection;
427
}
428

429
// Auto generated code (Tools/params_utils.py:366)
430
const bool & TreeParams::defaultSyncSelection() {
431
    const static bool def = true;
432
    return def;
433
}
434

435
// Auto generated code (Tools/params_utils.py:375)
436
void TreeParams::setSyncSelection(const bool &v) {
437
    instance()->handle->SetBool("SyncSelection",v);
438
    instance()->SyncSelection = v;
439
}
440

441
// Auto generated code (Tools/params_utils.py:384)
442
void TreeParams::removeSyncSelection() {
443
    instance()->handle->RemoveBool("SyncSelection");
444
}
445

446
// Auto generated code (Tools/params_utils.py:350)
447
const char *TreeParams::docCheckBoxesSelection() {
448
    return "";
449
}
450

451
// Auto generated code (Tools/params_utils.py:358)
452
const bool & TreeParams::getCheckBoxesSelection() {
453
    return instance()->CheckBoxesSelection;
454
}
455

456
// Auto generated code (Tools/params_utils.py:366)
457
const bool & TreeParams::defaultCheckBoxesSelection() {
458
    const static bool def = false;
459
    return def;
460
}
461

462
// Auto generated code (Tools/params_utils.py:375)
463
void TreeParams::setCheckBoxesSelection(const bool &v) {
464
    instance()->handle->SetBool("CheckBoxesSelection",v);
465
    instance()->CheckBoxesSelection = v;
466
}
467

468
// Auto generated code (Tools/params_utils.py:384)
469
void TreeParams::removeCheckBoxesSelection() {
470
    instance()->handle->RemoveBool("CheckBoxesSelection");
471
}
472

473
// Auto generated code (Tools/params_utils.py:350)
474
const char *TreeParams::docSyncView() {
475
    return "";
476
}
477

478
// Auto generated code (Tools/params_utils.py:358)
479
const bool & TreeParams::getSyncView() {
480
    return instance()->SyncView;
481
}
482

483
// Auto generated code (Tools/params_utils.py:366)
484
const bool & TreeParams::defaultSyncView() {
485
    const static bool def = true;
486
    return def;
487
}
488

489
// Auto generated code (Tools/params_utils.py:375)
490
void TreeParams::setSyncView(const bool &v) {
491
    instance()->handle->SetBool("SyncView",v);
492
    instance()->SyncView = v;
493
}
494

495
// Auto generated code (Tools/params_utils.py:384)
496
void TreeParams::removeSyncView() {
497
    instance()->handle->RemoveBool("SyncView");
498
}
499

500
// Auto generated code (Tools/params_utils.py:350)
501
const char *TreeParams::docPreSelection() {
502
    return "";
503
}
504

505
// Auto generated code (Tools/params_utils.py:358)
506
const bool & TreeParams::getPreSelection() {
507
    return instance()->PreSelection;
508
}
509

510
// Auto generated code (Tools/params_utils.py:366)
511
const bool & TreeParams::defaultPreSelection() {
512
    const static bool def = true;
513
    return def;
514
}
515

516
// Auto generated code (Tools/params_utils.py:375)
517
void TreeParams::setPreSelection(const bool &v) {
518
    instance()->handle->SetBool("PreSelection",v);
519
    instance()->PreSelection = v;
520
}
521

522
// Auto generated code (Tools/params_utils.py:384)
523
void TreeParams::removePreSelection() {
524
    instance()->handle->RemoveBool("PreSelection");
525
}
526

527
// Auto generated code (Tools/params_utils.py:350)
528
const char *TreeParams::docSyncPlacement() {
529
    return "";
530
}
531

532
// Auto generated code (Tools/params_utils.py:358)
533
const bool & TreeParams::getSyncPlacement() {
534
    return instance()->SyncPlacement;
535
}
536

537
// Auto generated code (Tools/params_utils.py:366)
538
const bool & TreeParams::defaultSyncPlacement() {
539
    const static bool def = false;
540
    return def;
541
}
542

543
// Auto generated code (Tools/params_utils.py:375)
544
void TreeParams::setSyncPlacement(const bool &v) {
545
    instance()->handle->SetBool("SyncPlacement",v);
546
    instance()->SyncPlacement = v;
547
}
548

549
// Auto generated code (Tools/params_utils.py:384)
550
void TreeParams::removeSyncPlacement() {
551
    instance()->handle->RemoveBool("SyncPlacement");
552
}
553

554
// Auto generated code (Tools/params_utils.py:350)
555
const char *TreeParams::docRecordSelection() {
556
    return "";
557
}
558

559
// Auto generated code (Tools/params_utils.py:358)
560
const bool & TreeParams::getRecordSelection() {
561
    return instance()->RecordSelection;
562
}
563

564
// Auto generated code (Tools/params_utils.py:366)
565
const bool & TreeParams::defaultRecordSelection() {
566
    const static bool def = true;
567
    return def;
568
}
569

570
// Auto generated code (Tools/params_utils.py:375)
571
void TreeParams::setRecordSelection(const bool &v) {
572
    instance()->handle->SetBool("RecordSelection",v);
573
    instance()->RecordSelection = v;
574
}
575

576
// Auto generated code (Tools/params_utils.py:384)
577
void TreeParams::removeRecordSelection() {
578
    instance()->handle->RemoveBool("RecordSelection");
579
}
580

581
// Auto generated code (Tools/params_utils.py:350)
582
const char *TreeParams::docDocumentMode() {
583
    return "";
584
}
585

586
// Auto generated code (Tools/params_utils.py:358)
587
const long & TreeParams::getDocumentMode() {
588
    return instance()->DocumentMode;
589
}
590

591
// Auto generated code (Tools/params_utils.py:366)
592
const long & TreeParams::defaultDocumentMode() {
593
    const static long def = 2;
594
    return def;
595
}
596

597
// Auto generated code (Tools/params_utils.py:375)
598
void TreeParams::setDocumentMode(const long &v) {
599
    instance()->handle->SetInt("DocumentMode",v);
600
    instance()->DocumentMode = v;
601
}
602

603
// Auto generated code (Tools/params_utils.py:384)
604
void TreeParams::removeDocumentMode() {
605
    instance()->handle->RemoveInt("DocumentMode");
606
}
607

608
// Auto generated code (Tools/params_utils.py:350)
609
const char *TreeParams::docStatusTimeout() {
610
    return "";
611
}
612

613
// Auto generated code (Tools/params_utils.py:358)
614
const long & TreeParams::getStatusTimeout() {
615
    return instance()->StatusTimeout;
616
}
617

618
// Auto generated code (Tools/params_utils.py:366)
619
const long & TreeParams::defaultStatusTimeout() {
620
    const static long def = 100;
621
    return def;
622
}
623

624
// Auto generated code (Tools/params_utils.py:375)
625
void TreeParams::setStatusTimeout(const long &v) {
626
    instance()->handle->SetInt("StatusTimeout",v);
627
    instance()->StatusTimeout = v;
628
}
629

630
// Auto generated code (Tools/params_utils.py:384)
631
void TreeParams::removeStatusTimeout() {
632
    instance()->handle->RemoveInt("StatusTimeout");
633
}
634

635
// Auto generated code (Tools/params_utils.py:350)
636
const char *TreeParams::docSelectionTimeout() {
637
    return "";
638
}
639

640
// Auto generated code (Tools/params_utils.py:358)
641
const long & TreeParams::getSelectionTimeout() {
642
    return instance()->SelectionTimeout;
643
}
644

645
// Auto generated code (Tools/params_utils.py:366)
646
const long & TreeParams::defaultSelectionTimeout() {
647
    const static long def = 100;
648
    return def;
649
}
650

651
// Auto generated code (Tools/params_utils.py:375)
652
void TreeParams::setSelectionTimeout(const long &v) {
653
    instance()->handle->SetInt("SelectionTimeout",v);
654
    instance()->SelectionTimeout = v;
655
}
656

657
// Auto generated code (Tools/params_utils.py:384)
658
void TreeParams::removeSelectionTimeout() {
659
    instance()->handle->RemoveInt("SelectionTimeout");
660
}
661

662
// Auto generated code (Tools/params_utils.py:350)
663
const char *TreeParams::docPreSelectionTimeout() {
664
    return "";
665
}
666

667
// Auto generated code (Tools/params_utils.py:358)
668
const long & TreeParams::getPreSelectionTimeout() {
669
    return instance()->PreSelectionTimeout;
670
}
671

672
// Auto generated code (Tools/params_utils.py:366)
673
const long & TreeParams::defaultPreSelectionTimeout() {
674
    const static long def = 500;
675
    return def;
676
}
677

678
// Auto generated code (Tools/params_utils.py:375)
679
void TreeParams::setPreSelectionTimeout(const long &v) {
680
    instance()->handle->SetInt("PreSelectionTimeout",v);
681
    instance()->PreSelectionTimeout = v;
682
}
683

684
// Auto generated code (Tools/params_utils.py:384)
685
void TreeParams::removePreSelectionTimeout() {
686
    instance()->handle->RemoveInt("PreSelectionTimeout");
687
}
688

689
// Auto generated code (Tools/params_utils.py:350)
690
const char *TreeParams::docPreSelectionDelay() {
691
    return "";
692
}
693

694
// Auto generated code (Tools/params_utils.py:358)
695
const long & TreeParams::getPreSelectionDelay() {
696
    return instance()->PreSelectionDelay;
697
}
698

699
// Auto generated code (Tools/params_utils.py:366)
700
const long & TreeParams::defaultPreSelectionDelay() {
701
    const static long def = 700;
702
    return def;
703
}
704

705
// Auto generated code (Tools/params_utils.py:375)
706
void TreeParams::setPreSelectionDelay(const long &v) {
707
    instance()->handle->SetInt("PreSelectionDelay",v);
708
    instance()->PreSelectionDelay = v;
709
}
710

711
// Auto generated code (Tools/params_utils.py:384)
712
void TreeParams::removePreSelectionDelay() {
713
    instance()->handle->RemoveInt("PreSelectionDelay");
714
}
715

716
// Auto generated code (Tools/params_utils.py:350)
717
const char *TreeParams::docPreSelectionMinDelay() {
718
    return "";
719
}
720

721
// Auto generated code (Tools/params_utils.py:358)
722
const long & TreeParams::getPreSelectionMinDelay() {
723
    return instance()->PreSelectionMinDelay;
724
}
725

726
// Auto generated code (Tools/params_utils.py:366)
727
const long & TreeParams::defaultPreSelectionMinDelay() {
728
    const static long def = 200;
729
    return def;
730
}
731

732
// Auto generated code (Tools/params_utils.py:375)
733
void TreeParams::setPreSelectionMinDelay(const long &v) {
734
    instance()->handle->SetInt("PreSelectionMinDelay",v);
735
    instance()->PreSelectionMinDelay = v;
736
}
737

738
// Auto generated code (Tools/params_utils.py:384)
739
void TreeParams::removePreSelectionMinDelay() {
740
    instance()->handle->RemoveInt("PreSelectionMinDelay");
741
}
742

743
// Auto generated code (Tools/params_utils.py:350)
744
const char *TreeParams::docRecomputeOnDrop() {
745
    return "";
746
}
747

748
// Auto generated code (Tools/params_utils.py:358)
749
const bool & TreeParams::getRecomputeOnDrop() {
750
    return instance()->RecomputeOnDrop;
751
}
752

753
// Auto generated code (Tools/params_utils.py:366)
754
const bool & TreeParams::defaultRecomputeOnDrop() {
755
    const static bool def = true;
756
    return def;
757
}
758

759
// Auto generated code (Tools/params_utils.py:375)
760
void TreeParams::setRecomputeOnDrop(const bool &v) {
761
    instance()->handle->SetBool("RecomputeOnDrop",v);
762
    instance()->RecomputeOnDrop = v;
763
}
764

765
// Auto generated code (Tools/params_utils.py:384)
766
void TreeParams::removeRecomputeOnDrop() {
767
    instance()->handle->RemoveBool("RecomputeOnDrop");
768
}
769

770
// Auto generated code (Tools/params_utils.py:350)
771
const char *TreeParams::docKeepRootOrder() {
772
    return "";
773
}
774

775
// Auto generated code (Tools/params_utils.py:358)
776
const bool & TreeParams::getKeepRootOrder() {
777
    return instance()->KeepRootOrder;
778
}
779

780
// Auto generated code (Tools/params_utils.py:366)
781
const bool & TreeParams::defaultKeepRootOrder() {
782
    const static bool def = true;
783
    return def;
784
}
785

786
// Auto generated code (Tools/params_utils.py:375)
787
void TreeParams::setKeepRootOrder(const bool &v) {
788
    instance()->handle->SetBool("KeepRootOrder",v);
789
    instance()->KeepRootOrder = v;
790
}
791

792
// Auto generated code (Tools/params_utils.py:384)
793
void TreeParams::removeKeepRootOrder() {
794
    instance()->handle->RemoveBool("KeepRootOrder");
795
}
796

797
// Auto generated code (Tools/params_utils.py:350)
798
const char *TreeParams::docTreeActiveAutoExpand() {
799
    return "";
800
}
801

802
// Auto generated code (Tools/params_utils.py:358)
803
const bool & TreeParams::getTreeActiveAutoExpand() {
804
    return instance()->TreeActiveAutoExpand;
805
}
806

807
// Auto generated code (Tools/params_utils.py:366)
808
const bool & TreeParams::defaultTreeActiveAutoExpand() {
809
    const static bool def = true;
810
    return def;
811
}
812

813
// Auto generated code (Tools/params_utils.py:375)
814
void TreeParams::setTreeActiveAutoExpand(const bool &v) {
815
    instance()->handle->SetBool("TreeActiveAutoExpand",v);
816
    instance()->TreeActiveAutoExpand = v;
817
}
818

819
// Auto generated code (Tools/params_utils.py:384)
820
void TreeParams::removeTreeActiveAutoExpand() {
821
    instance()->handle->RemoveBool("TreeActiveAutoExpand");
822
}
823

824
// Auto generated code (Tools/params_utils.py:350)
825
const char *TreeParams::docTreeActiveColor() {
826
    return "";
827
}
828

829
// Auto generated code (Tools/params_utils.py:358)
830
const unsigned long & TreeParams::getTreeActiveColor() {
831
    return instance()->TreeActiveColor;
832
}
833

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

840
// Auto generated code (Tools/params_utils.py:375)
841
void TreeParams::setTreeActiveColor(const unsigned long &v) {
842
    instance()->handle->SetUnsigned("TreeActiveColor",v);
843
    instance()->TreeActiveColor = v;
844
}
845

846
// Auto generated code (Tools/params_utils.py:384)
847
void TreeParams::removeTreeActiveColor() {
848
    instance()->handle->RemoveUnsigned("TreeActiveColor");
849
}
850

851
// Auto generated code (Tools/params_utils.py:350)
852
const char *TreeParams::docTreeEditColor() {
853
    return "";
854
}
855

856
// Auto generated code (Tools/params_utils.py:358)
857
const unsigned long & TreeParams::getTreeEditColor() {
858
    return instance()->TreeEditColor;
859
}
860

861
// Auto generated code (Tools/params_utils.py:366)
862
const unsigned long & TreeParams::defaultTreeEditColor() {
863
    const static unsigned long def = 2459042047;
864
    return def;
865
}
866

867
// Auto generated code (Tools/params_utils.py:375)
868
void TreeParams::setTreeEditColor(const unsigned long &v) {
869
    instance()->handle->SetUnsigned("TreeEditColor",v);
870
    instance()->TreeEditColor = v;
871
}
872

873
// Auto generated code (Tools/params_utils.py:384)
874
void TreeParams::removeTreeEditColor() {
875
    instance()->handle->RemoveUnsigned("TreeEditColor");
876
}
877

878
// Auto generated code (Tools/params_utils.py:350)
879
const char *TreeParams::docSelectingGroupColor() {
880
    return "";
881
}
882

883
// Auto generated code (Tools/params_utils.py:358)
884
const unsigned long & TreeParams::getSelectingGroupColor() {
885
    return instance()->SelectingGroupColor;
886
}
887

888
// Auto generated code (Tools/params_utils.py:366)
889
const unsigned long & TreeParams::defaultSelectingGroupColor() {
890
    const static unsigned long def = 1082163711;
891
    return def;
892
}
893

894
// Auto generated code (Tools/params_utils.py:375)
895
void TreeParams::setSelectingGroupColor(const unsigned long &v) {
896
    instance()->handle->SetUnsigned("SelectingGroupColor",v);
897
    instance()->SelectingGroupColor = v;
898
}
899

900
// Auto generated code (Tools/params_utils.py:384)
901
void TreeParams::removeSelectingGroupColor() {
902
    instance()->handle->RemoveUnsigned("SelectingGroupColor");
903
}
904

905
// Auto generated code (Tools/params_utils.py:350)
906
const char *TreeParams::docTreeActiveBold() {
907
    return "";
908
}
909

910
// Auto generated code (Tools/params_utils.py:358)
911
const bool & TreeParams::getTreeActiveBold() {
912
    return instance()->TreeActiveBold;
913
}
914

915
// Auto generated code (Tools/params_utils.py:366)
916
const bool & TreeParams::defaultTreeActiveBold() {
917
    const static bool def = true;
918
    return def;
919
}
920

921
// Auto generated code (Tools/params_utils.py:375)
922
void TreeParams::setTreeActiveBold(const bool &v) {
923
    instance()->handle->SetBool("TreeActiveBold",v);
924
    instance()->TreeActiveBold = v;
925
}
926

927
// Auto generated code (Tools/params_utils.py:384)
928
void TreeParams::removeTreeActiveBold() {
929
    instance()->handle->RemoveBool("TreeActiveBold");
930
}
931

932
// Auto generated code (Tools/params_utils.py:350)
933
const char *TreeParams::docTreeActiveItalic() {
934
    return "";
935
}
936

937
// Auto generated code (Tools/params_utils.py:358)
938
const bool & TreeParams::getTreeActiveItalic() {
939
    return instance()->TreeActiveItalic;
940
}
941

942
// Auto generated code (Tools/params_utils.py:366)
943
const bool & TreeParams::defaultTreeActiveItalic() {
944
    const static bool def = false;
945
    return def;
946
}
947

948
// Auto generated code (Tools/params_utils.py:375)
949
void TreeParams::setTreeActiveItalic(const bool &v) {
950
    instance()->handle->SetBool("TreeActiveItalic",v);
951
    instance()->TreeActiveItalic = v;
952
}
953

954
// Auto generated code (Tools/params_utils.py:384)
955
void TreeParams::removeTreeActiveItalic() {
956
    instance()->handle->RemoveBool("TreeActiveItalic");
957
}
958

959
// Auto generated code (Tools/params_utils.py:350)
960
const char *TreeParams::docTreeActiveUnderlined() {
961
    return "";
962
}
963

964
// Auto generated code (Tools/params_utils.py:358)
965
const bool & TreeParams::getTreeActiveUnderlined() {
966
    return instance()->TreeActiveUnderlined;
967
}
968

969
// Auto generated code (Tools/params_utils.py:366)
970
const bool & TreeParams::defaultTreeActiveUnderlined() {
971
    const static bool def = false;
972
    return def;
973
}
974

975
// Auto generated code (Tools/params_utils.py:375)
976
void TreeParams::setTreeActiveUnderlined(const bool &v) {
977
    instance()->handle->SetBool("TreeActiveUnderlined",v);
978
    instance()->TreeActiveUnderlined = v;
979
}
980

981
// Auto generated code (Tools/params_utils.py:384)
982
void TreeParams::removeTreeActiveUnderlined() {
983
    instance()->handle->RemoveBool("TreeActiveUnderlined");
984
}
985

986
// Auto generated code (Tools/params_utils.py:350)
987
const char *TreeParams::docTreeActiveOverlined() {
988
    return "";
989
}
990

991
// Auto generated code (Tools/params_utils.py:358)
992
const bool & TreeParams::getTreeActiveOverlined() {
993
    return instance()->TreeActiveOverlined;
994
}
995

996
// Auto generated code (Tools/params_utils.py:366)
997
const bool & TreeParams::defaultTreeActiveOverlined() {
998
    const static bool def = false;
999
    return def;
1000
}
1001

1002
// Auto generated code (Tools/params_utils.py:375)
1003
void TreeParams::setTreeActiveOverlined(const bool &v) {
1004
    instance()->handle->SetBool("TreeActiveOverlined",v);
1005
    instance()->TreeActiveOverlined = v;
1006
}
1007

1008
// Auto generated code (Tools/params_utils.py:384)
1009
void TreeParams::removeTreeActiveOverlined() {
1010
    instance()->handle->RemoveBool("TreeActiveOverlined");
1011
}
1012

1013
// Auto generated code (Tools/params_utils.py:350)
1014
const char *TreeParams::docIndentation() {
1015
    return "";
1016
}
1017

1018
// Auto generated code (Tools/params_utils.py:358)
1019
const long & TreeParams::getIndentation() {
1020
    return instance()->Indentation;
1021
}
1022

1023
// Auto generated code (Tools/params_utils.py:366)
1024
const long & TreeParams::defaultIndentation() {
1025
    const static long def = 0;
1026
    return def;
1027
}
1028

1029
// Auto generated code (Tools/params_utils.py:375)
1030
void TreeParams::setIndentation(const long &v) {
1031
    instance()->handle->SetInt("Indentation",v);
1032
    instance()->Indentation = v;
1033
}
1034

1035
// Auto generated code (Tools/params_utils.py:384)
1036
void TreeParams::removeIndentation() {
1037
    instance()->handle->RemoveInt("Indentation");
1038
}
1039

1040
// Auto generated code (Tools/params_utils.py:350)
1041
const char *TreeParams::docLabelExpression() {
1042
    return "";
1043
}
1044

1045
// Auto generated code (Tools/params_utils.py:358)
1046
const bool & TreeParams::getLabelExpression() {
1047
    return instance()->LabelExpression;
1048
}
1049

1050
// Auto generated code (Tools/params_utils.py:366)
1051
const bool & TreeParams::defaultLabelExpression() {
1052
    const static bool def = false;
1053
    return def;
1054
}
1055

1056
// Auto generated code (Tools/params_utils.py:375)
1057
void TreeParams::setLabelExpression(const bool &v) {
1058
    instance()->handle->SetBool("LabelExpression",v);
1059
    instance()->LabelExpression = v;
1060
}
1061

1062
// Auto generated code (Tools/params_utils.py:384)
1063
void TreeParams::removeLabelExpression() {
1064
    instance()->handle->RemoveBool("LabelExpression");
1065
}
1066

1067
// Auto generated code (Tools/params_utils.py:350)
1068
const char *TreeParams::docIconSize() {
1069
    return "";
1070
}
1071

1072
// Auto generated code (Tools/params_utils.py:358)
1073
const long & TreeParams::getIconSize() {
1074
    return instance()->IconSize;
1075
}
1076

1077
// Auto generated code (Tools/params_utils.py:366)
1078
const long & TreeParams::defaultIconSize() {
1079
    const static long def = 0;
1080
    return def;
1081
}
1082

1083
// Auto generated code (Tools/params_utils.py:375)
1084
void TreeParams::setIconSize(const long &v) {
1085
    instance()->handle->SetInt("IconSize",v);
1086
    instance()->IconSize = v;
1087
}
1088

1089
// Auto generated code (Tools/params_utils.py:384)
1090
void TreeParams::removeIconSize() {
1091
    instance()->handle->RemoveInt("IconSize");
1092
}
1093

1094
// Auto generated code (Tools/params_utils.py:350)
1095
const char *TreeParams::docFontSize() {
1096
    return "";
1097
}
1098

1099
// Auto generated code (Tools/params_utils.py:358)
1100
const long & TreeParams::getFontSize() {
1101
    return instance()->FontSize;
1102
}
1103

1104
// Auto generated code (Tools/params_utils.py:366)
1105
const long & TreeParams::defaultFontSize() {
1106
    const static long def = 0;
1107
    return def;
1108
}
1109

1110
// Auto generated code (Tools/params_utils.py:375)
1111
void TreeParams::setFontSize(const long &v) {
1112
    instance()->handle->SetInt("FontSize",v);
1113
    instance()->FontSize = v;
1114
}
1115

1116
// Auto generated code (Tools/params_utils.py:384)
1117
void TreeParams::removeFontSize() {
1118
    instance()->handle->RemoveInt("FontSize");
1119
}
1120

1121
// Auto generated code (Tools/params_utils.py:350)
1122
const char *TreeParams::docItemSpacing() {
1123
    return "";
1124
}
1125

1126
// Auto generated code (Tools/params_utils.py:358)
1127
const long & TreeParams::getItemSpacing() {
1128
    return instance()->ItemSpacing;
1129
}
1130

1131
// Auto generated code (Tools/params_utils.py:366)
1132
const long & TreeParams::defaultItemSpacing() {
1133
    const static long def = 0;
1134
    return def;
1135
}
1136

1137
// Auto generated code (Tools/params_utils.py:375)
1138
void TreeParams::setItemSpacing(const long &v) {
1139
    instance()->handle->SetInt("ItemSpacing",v);
1140
    instance()->ItemSpacing = v;
1141
}
1142

1143
// Auto generated code (Tools/params_utils.py:384)
1144
void TreeParams::removeItemSpacing() {
1145
    instance()->handle->RemoveInt("ItemSpacing");
1146
}
1147

1148
// Auto generated code (Tools/params_utils.py:350)
1149
const char *TreeParams::docItemBackground() {
1150
    return QT_TRANSLATE_NOOP("TreeParams",
1151
"Tree view item background. Only effective in overlay.");
1152
}
1153

1154
// Auto generated code (Tools/params_utils.py:358)
1155
const unsigned long & TreeParams::getItemBackground() {
1156
    return instance()->ItemBackground;
1157
}
1158

1159
// Auto generated code (Tools/params_utils.py:366)
1160
const unsigned long & TreeParams::defaultItemBackground() {
1161
    const static unsigned long def = 0x00000000;
1162
    return def;
1163
}
1164

1165
// Auto generated code (Tools/params_utils.py:375)
1166
void TreeParams::setItemBackground(const unsigned long &v) {
1167
    instance()->handle->SetUnsigned("ItemBackground",v);
1168
    instance()->ItemBackground = v;
1169
}
1170

1171
// Auto generated code (Tools/params_utils.py:384)
1172
void TreeParams::removeItemBackground() {
1173
    instance()->handle->RemoveUnsigned("ItemBackground");
1174
}
1175

1176
// Auto generated code (Tools/params_utils.py:350)
1177
const char *TreeParams::docItemBackgroundPadding() {
1178
    return QT_TRANSLATE_NOOP("TreeParams",
1179
"Tree view item background padding.");
1180
}
1181

1182
// Auto generated code (Tools/params_utils.py:358)
1183
const long & TreeParams::getItemBackgroundPadding() {
1184
    return instance()->ItemBackgroundPadding;
1185
}
1186

1187
// Auto generated code (Tools/params_utils.py:366)
1188
const long & TreeParams::defaultItemBackgroundPadding() {
1189
    const static long def = 0;
1190
    return def;
1191
}
1192

1193
// Auto generated code (Tools/params_utils.py:375)
1194
void TreeParams::setItemBackgroundPadding(const long &v) {
1195
    instance()->handle->SetInt("ItemBackgroundPadding",v);
1196
    instance()->ItemBackgroundPadding = v;
1197
}
1198

1199
// Auto generated code (Tools/params_utils.py:384)
1200
void TreeParams::removeItemBackgroundPadding() {
1201
    instance()->handle->RemoveInt("ItemBackgroundPadding");
1202
}
1203

1204
// Auto generated code (Tools/params_utils.py:350)
1205
const char *TreeParams::docHideColumn() {
1206
    return QT_TRANSLATE_NOOP("TreeParams",
1207
"Hide extra tree view column for item description.");
1208
}
1209

1210
// Auto generated code (Tools/params_utils.py:358)
1211
const bool & TreeParams::getHideColumn() {
1212
    return instance()->HideColumn;
1213
}
1214

1215
// Auto generated code (Tools/params_utils.py:366)
1216
const bool & TreeParams::defaultHideColumn() {
1217
    const static bool def = true;
1218
    return def;
1219
}
1220

1221
// Auto generated code (Tools/params_utils.py:375)
1222
void TreeParams::setHideColumn(const bool &v) {
1223
    instance()->handle->SetBool("HideColumn",v);
1224
    instance()->HideColumn = v;
1225
}
1226

1227
// Auto generated code (Tools/params_utils.py:384)
1228
void TreeParams::removeHideColumn() {
1229
    instance()->handle->RemoveBool("HideColumn");
1230
}
1231

1232
// Auto generated code (Tools/params_utils.py:350)
1233
const char *TreeParams::docHideScrollBar() {
1234
    return QT_TRANSLATE_NOOP("TreeParams",
1235
"Hide tree view scroll bar in dock overlay.");
1236
}
1237

1238
// Auto generated code (Tools/params_utils.py:358)
1239
const bool & TreeParams::getHideScrollBar() {
1240
    return instance()->HideScrollBar;
1241
}
1242

1243
// Auto generated code (Tools/params_utils.py:366)
1244
const bool & TreeParams::defaultHideScrollBar() {
1245
    const static bool def = true;
1246
    return def;
1247
}
1248

1249
// Auto generated code (Tools/params_utils.py:375)
1250
void TreeParams::setHideScrollBar(const bool &v) {
1251
    instance()->handle->SetBool("HideScrollBar",v);
1252
    instance()->HideScrollBar = v;
1253
}
1254

1255
// Auto generated code (Tools/params_utils.py:384)
1256
void TreeParams::removeHideScrollBar() {
1257
    instance()->handle->RemoveBool("HideScrollBar");
1258
}
1259

1260
// Auto generated code (Tools/params_utils.py:350)
1261
const char *TreeParams::docHideHeaderView() {
1262
    return QT_TRANSLATE_NOOP("TreeParams",
1263
"Hide tree view header view in dock overlay.");
1264
}
1265

1266
// Auto generated code (Tools/params_utils.py:358)
1267
const bool & TreeParams::getHideHeaderView() {
1268
    return instance()->HideHeaderView;
1269
}
1270

1271
// Auto generated code (Tools/params_utils.py:366)
1272
const bool & TreeParams::defaultHideHeaderView() {
1273
    const static bool def = true;
1274
    return def;
1275
}
1276

1277
// Auto generated code (Tools/params_utils.py:375)
1278
void TreeParams::setHideHeaderView(const bool &v) {
1279
    instance()->handle->SetBool("HideHeaderView",v);
1280
    instance()->HideHeaderView = v;
1281
}
1282

1283
// Auto generated code (Tools/params_utils.py:384)
1284
void TreeParams::removeHideHeaderView() {
1285
    instance()->handle->RemoveBool("HideHeaderView");
1286
}
1287

1288
// Auto generated code (Tools/params_utils.py:350)
1289
const char *TreeParams::docResizableColumn() {
1290
    return QT_TRANSLATE_NOOP("TreeParams",
1291
"Allow tree view columns to be manually resized.");
1292
}
1293

1294
// Auto generated code (Tools/params_utils.py:358)
1295
const bool & TreeParams::getResizableColumn() {
1296
    return instance()->ResizableColumn;
1297
}
1298

1299
// Auto generated code (Tools/params_utils.py:366)
1300
const bool & TreeParams::defaultResizableColumn() {
1301
    const static bool def = false;
1302
    return def;
1303
}
1304

1305
// Auto generated code (Tools/params_utils.py:375)
1306
void TreeParams::setResizableColumn(const bool &v) {
1307
    instance()->handle->SetBool("ResizableColumn",v);
1308
    instance()->ResizableColumn = v;
1309
}
1310

1311
// Auto generated code (Tools/params_utils.py:384)
1312
void TreeParams::removeResizableColumn() {
1313
    instance()->handle->RemoveBool("ResizableColumn");
1314
}
1315

1316
// Auto generated code (Tools/params_utils.py:350)
1317
const char *TreeParams::docColumnSize1() {
1318
    return "";
1319
}
1320

1321
// Auto generated code (Tools/params_utils.py:358)
1322
const long & TreeParams::getColumnSize1() {
1323
    return instance()->ColumnSize1;
1324
}
1325

1326
// Auto generated code (Tools/params_utils.py:366)
1327
const long & TreeParams::defaultColumnSize1() {
1328
    const static long def = 0;
1329
    return def;
1330
}
1331

1332
// Auto generated code (Tools/params_utils.py:375)
1333
void TreeParams::setColumnSize1(const long &v) {
1334
    instance()->handle->SetInt("ColumnSize1",v);
1335
    instance()->ColumnSize1 = v;
1336
}
1337

1338
// Auto generated code (Tools/params_utils.py:384)
1339
void TreeParams::removeColumnSize1() {
1340
    instance()->handle->RemoveInt("ColumnSize1");
1341
}
1342

1343
// Auto generated code (Tools/params_utils.py:350)
1344
const char *TreeParams::docColumnSize2() {
1345
    return "";
1346
}
1347

1348
// Auto generated code (Tools/params_utils.py:358)
1349
const long & TreeParams::getColumnSize2() {
1350
    return instance()->ColumnSize2;
1351
}
1352

1353
// Auto generated code (Tools/params_utils.py:366)
1354
const long & TreeParams::defaultColumnSize2() {
1355
    const static long def = 0;
1356
    return def;
1357
}
1358

1359
// Auto generated code (Tools/params_utils.py:375)
1360
void TreeParams::setColumnSize2(const long &v) {
1361
    instance()->handle->SetInt("ColumnSize2",v);
1362
    instance()->ColumnSize2 = v;
1363
}
1364

1365
// Auto generated code (Tools/params_utils.py:384)
1366
void TreeParams::removeColumnSize2() {
1367
    instance()->handle->RemoveInt("ColumnSize2");
1368
}
1369

1370
// Auto generated code (Tools/params_utils.py:350)
1371
const char *TreeParams::docTreeToolTipIcon() {
1372
    return "";
1373
}
1374

1375
// Auto generated code (Tools/params_utils.py:358)
1376
const bool & TreeParams::getTreeToolTipIcon() {
1377
    return instance()->TreeToolTipIcon;
1378
}
1379

1380
// Auto generated code (Tools/params_utils.py:366)
1381
const bool & TreeParams::defaultTreeToolTipIcon() {
1382
    const static bool def = false;
1383
    return def;
1384
}
1385

1386
// Auto generated code (Tools/params_utils.py:375)
1387
void TreeParams::setTreeToolTipIcon(const bool &v) {
1388
    instance()->handle->SetBool("TreeToolTipIcon",v);
1389
    instance()->TreeToolTipIcon = v;
1390
}
1391

1392
// Auto generated code (Tools/params_utils.py:384)
1393
void TreeParams::removeTreeToolTipIcon() {
1394
    instance()->handle->RemoveBool("TreeToolTipIcon");
1395
}
1396

1397
// Auto generated code (Tools/params_utils.py:350)
1398
const char *TreeParams::docVisibilityIcon() {
1399
    return QT_TRANSLATE_NOOP("TreeParams",
1400
"If enabled, show an eye icon before the tree view items, showing the items visibility status. When clicked the visibility is toggled");
1401
}
1402

1403
// Auto generated code (Tools/params_utils.py:358)
1404
const bool & TreeParams::getVisibilityIcon() {
1405
    return instance()->VisibilityIcon;
1406
}
1407

1408
// Auto generated code (Tools/params_utils.py:366)
1409
const bool & TreeParams::defaultVisibilityIcon() {
1410
    const static bool def = false;
1411
    return def;
1412
}
1413

1414
// Auto generated code (Tools/params_utils.py:375)
1415
void TreeParams::setVisibilityIcon(const bool &v) {
1416
    instance()->handle->SetBool("VisibilityIcon",v);
1417
    instance()->VisibilityIcon = v;
1418
}
1419

1420
// Auto generated code (Tools/params_utils.py:384)
1421
void TreeParams::removeVisibilityIcon() {
1422
    instance()->handle->RemoveBool("VisibilityIcon");
1423
}
1424
//[[[end]]]
1425

1426
void TreeParams::onSyncSelectionChanged() {
1427
    if(!TreeParams::getSyncSelection() || !Gui::Selection().hasSelection())
1428
        return;
1429
    TreeWidget::scrollItemToTop();
1430
}
1431

1432
void TreeParams::onCheckBoxesSelectionChanged()
1433
{
1434
    TreeWidget::synchronizeSelectionCheckBoxes();
1435
}
1436

1437
void TreeParams::onDocumentModeChanged() {
1438
    App::GetApplication().setActiveDocument(App::GetApplication().getActiveDocument());
1439
}
1440

1441
void TreeParams::onResizableColumnChanged() {
1442
    TreeWidget::setupResizableColumn();
1443
}
1444

1445
void TreeParams::onIconSizeChanged() {
1446
    auto tree = TreeWidget::instance();
1447
    if (tree)
1448
        tree->setIconHeight(TreeParams::getIconSize());
1449
}
1450

1451
void TreeParams::onFontSizeChanged() {
1452
    int fontSize = TreeParams::getFontSize();
1453
    if (fontSize <= 0)
1454
        return;
1455
    for(auto tree : TreeWidget::Instances) {
1456
        QFont font = tree->font();
1457
        font.setPointSize(std::max(8,fontSize));
1458
        tree->setFont(font);
1459
    }
1460
}
1461

1462
void TreeParams::onItemSpacingChanged()
1463
{
1464
    refreshTreeViews();
1465
}
1466

1467
void TreeParams::refreshTreeViews()
1468
{
1469
    for(auto tree : TreeWidget::Instances) {
1470
        tree->scheduleDelayedItemsLayout();
1471
    }
1472
}
1473

1474
void TreeParams::onTreeActiveColorChanged()
1475
{
1476
    refreshTreeViews();
1477
}
1478

1479
void TreeParams::onTreeEditColorChanged()
1480
{
1481
    refreshTreeViews();
1482
}
1483

1484
void TreeParams::onSelectingGroupColorChanged()
1485
{
1486
    refreshTreeViews();
1487
}
1488

1489
void TreeParams::onTreeActiveBoldChanged()
1490
{
1491
    refreshTreeViews();
1492
}
1493

1494
void TreeParams::onTreeActiveItalicChanged()
1495
{
1496
    refreshTreeViews();
1497
}
1498

1499
void TreeParams::onTreeActiveUnderlinedChanged()
1500
{
1501
    refreshTreeViews();
1502
}
1503

1504
void TreeParams::onTreeActiveOverlinedChanged()
1505
{
1506
    refreshTreeViews();
1507
}
1508

1509
void TreeParams::onIndentationChanged()
1510
{
1511
    refreshTreeViews();
1512
}
1513

1514
void TreeParams::onItemBackgroundPaddingChanged()
1515
{
1516
    if (getItemBackground())
1517
        refreshTreeViews();
1518
}
1519

1520
void TreeParams::onHideColumnChanged()
1521
{
1522
    for(auto tree : TreeWidget::Instances)
1523
        tree->setColumnHidden(1, TreeParams::getHideColumn());
1524
}
1525

1526
void TreeParams::onVisibilityIconChanged()
1527
{
1528
    TreeWidget::updateVisibilityIcons();
1529
}
1530