FreeCAD

1
/***************************************************************************
2
 *   Copyright (c) 2010 Jürgen Riegel <juergen.riegel@web.de>              *
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
#ifndef _PreComp_
25
#include <cstdlib>
26
#include <memory>
27

28
#include <QApplication>
29
#include <QString>
30
#endif
31

32
#include <App/OriginFeature.h>
33
#include <Gui/Action.h>
34
#include <Gui/Application.h>
35
#include <Gui/BitmapFactory.h>
36
#include <Gui/CommandT.h>
37
#include <Gui/Document.h>
38
#include <Gui/MainWindow.h>
39
#include <Gui/SelectionFilter.h>
40
#include <Gui/View3DInventor.h>
41
#include <Gui/View3DInventorViewer.h>
42
#include <Mod/Part/App/DatumFeature.h>
43
#include <Mod/Part/App/Geometry2d.h>
44
#include <Mod/Sketcher/App/Constraint.h>
45
#include <Mod/Sketcher/App/SketchObject.h>
46

47
#include "CircleEllipseConstructionMethod.h"
48
#include "GeometryCreationMode.h"
49
#include "Utils.h"
50
#include "ViewProviderSketch.h"
51

52
// DrawSketchHandler* must be last includes
53
#include "DrawSketchHandler.h"
54
#include "DrawSketchHandlerArc.h"
55
#include "DrawSketchHandlerArcOfEllipse.h"
56
#include "DrawSketchHandlerArcOfHyperbola.h"
57
#include "DrawSketchHandlerArcOfParabola.h"
58
#include "DrawSketchHandlerArcSlot.h"
59
#include "DrawSketchHandlerBSpline.h"
60
#include "DrawSketchHandlerCarbonCopy.h"
61
#include "DrawSketchHandlerCircle.h"
62
#include "DrawSketchHandlerEllipse.h"
63
#include "DrawSketchHandlerExtend.h"
64
#include "DrawSketchHandlerExternal.h"
65
#include "DrawSketchHandlerFillet.h"
66
#include "DrawSketchHandlerLine.h"
67
#include "DrawSketchHandlerLineSet.h"
68
#include "DrawSketchHandlerPoint.h"
69
#include "DrawSketchHandlerPolygon.h"
70
#include "DrawSketchHandlerRectangle.h"
71
#include "DrawSketchHandlerSlot.h"
72
#include "DrawSketchHandlerSplitting.h"
73
#include "DrawSketchHandlerTrimming.h"
74

75

76
using namespace std;
77
using namespace SketcherGui;
78

79
#define CONSTRUCTION_UPDATE_ACTION(CLASS, ICON)                                                    \
80
    /* This macro creates an updateAction() function that will toggle between normal &             \
81
     * construction icon */                                                                        \
82
    void CLASS::updateAction(int mode)                                                             \
83
    {                                                                                              \
84
        auto act = getAction();                                                                    \
85
        if (act) {                                                                                 \
86
            switch (static_cast<GeometryCreationMode>(mode)) {                                     \
87
                case GeometryCreationMode::Normal:                                                 \
88
                    act->setIcon(Gui::BitmapFactory().iconFromTheme(ICON));                        \
89
                    break;                                                                         \
90
                case GeometryCreationMode::Construction:                                           \
91
                    act->setIcon(Gui::BitmapFactory().iconFromTheme(ICON "_Constr"));              \
92
                    break;                                                                         \
93
            }                                                                                      \
94
        }                                                                                          \
95
    }
96

97
namespace SketcherGui
98
{
99
GeometryCreationMode geometryCreationMode = GeometryCreationMode::Normal;
100
}
101

102
/* Sketch commands =======================================================*/
103

104
// Comp for line tools =============================================
105

106
class CmdSketcherCompLine: public Gui::GroupCommand
107
{
108
public:
109
    CmdSketcherCompLine()
110
        : GroupCommand("Sketcher_CompLine")
111
    {
112
        sAppModule = "Sketcher";
113
        sGroup = "Sketcher";
114
        sMenuText = QT_TR_NOOP("Create polyline");
115
        sToolTipText = QT_TR_NOOP("Create a polyline in the sketch. 'M' Key cycles behaviour");
116
        sWhatsThis = "Sketcher_CompLine";
117
        sStatusTip = sToolTipText;
118
        eType = ForEdit;
119

120
        setCheckable(false);
121

122
        addCommand("Sketcher_CreatePolyline");
123
        addCommand("Sketcher_CreateLine");
124
    }
125

126
    void updateAction(int mode) override
127
    {
128
        Gui::ActionGroup* pcAction = qobject_cast<Gui::ActionGroup*>(getAction());
129
        if (!pcAction) {
130
            return;
131
        }
132

133
        QList<QAction*> al = pcAction->actions();
134
        int index = pcAction->property("defaultAction").toInt();
135
        switch (static_cast<GeometryCreationMode>(mode)) {
136
            case GeometryCreationMode::Normal:
137
                al[0]->setIcon(Gui::BitmapFactory().iconFromTheme("Sketcher_CreatePolyline"));
138
                al[1]->setIcon(Gui::BitmapFactory().iconFromTheme("Sketcher_CreateLine"));
139
                getAction()->setIcon(al[index]->icon());
140
                break;
141
            case GeometryCreationMode::Construction:
142
                al[0]->setIcon(
143
                    Gui::BitmapFactory().iconFromTheme("Sketcher_CreatePolyline_Constr"));
144
                al[1]->setIcon(Gui::BitmapFactory().iconFromTheme("Sketcher_CreateLine_Constr"));
145
                getAction()->setIcon(al[index]->icon());
146
                break;
147
        }
148
    }
149

150
    const char* className() const override
151
    {
152
        return "CmdSketcherCompLine";
153
    }
154

155
    bool isActive() override
156
    {
157
        return isCommandActive(getActiveGuiDocument());
158
    }
159
};
160

161
// Line ================================================================
162

163
DEF_STD_CMD_AU(CmdSketcherCreateLine)
164

165
CmdSketcherCreateLine::CmdSketcherCreateLine()
166
    : Command("Sketcher_CreateLine")
167
{
168
    sAppModule = "Sketcher";
169
    sGroup = "Sketcher";
170
    sMenuText = QT_TR_NOOP("Create line");
171
    sToolTipText = QT_TR_NOOP("Create a line in the sketch");
172
    sWhatsThis = "Sketcher_CreateLine";
173
    sStatusTip = sToolTipText;
174
    sPixmap = "Sketcher_CreateLine";
175
    sAccel = "G, L";
176
    eType = ForEdit;
177
}
178

179
CONSTRUCTION_UPDATE_ACTION(CmdSketcherCreateLine, "Sketcher_CreateLine")
180

181
void CmdSketcherCreateLine::activated(int iMsg)
182
{
183
    Q_UNUSED(iMsg);
184
    ActivateHandler(getActiveGuiDocument(), std::make_unique<DrawSketchHandlerLine>());
185
}
186

187
bool CmdSketcherCreateLine::isActive()
188
{
189
    return isCommandActive(getActiveGuiDocument());
190
}
191

192
// Polyline ================================================================
193

194
DEF_STD_CMD_AU(CmdSketcherCreatePolyline)
195

196
CmdSketcherCreatePolyline::CmdSketcherCreatePolyline()
197
    : Command("Sketcher_CreatePolyline")
198
{
199
    sAppModule = "Sketcher";
200
    sGroup = "Sketcher";
201
    sMenuText = QT_TR_NOOP("Create polyline");
202
    sToolTipText = QT_TR_NOOP("Create a polyline in the sketch. 'M' Key cycles behaviour");
203
    sWhatsThis = "Sketcher_CreatePolyline";
204
    sStatusTip = sToolTipText;
205
    sPixmap = "Sketcher_CreatePolyline";
206
    sAccel = "G, M";
207
    eType = ForEdit;
208
}
209

210
CONSTRUCTION_UPDATE_ACTION(CmdSketcherCreatePolyline, "Sketcher_CreatePolyline")
211

212
void CmdSketcherCreatePolyline::activated(int iMsg)
213
{
214
    Q_UNUSED(iMsg);
215
    ActivateHandler(getActiveGuiDocument(), std::make_unique<DrawSketchHandlerLineSet>());
216
}
217

218
bool CmdSketcherCreatePolyline::isActive()
219
{
220
    return isCommandActive(getActiveGuiDocument());
221
}
222

223

224
/* Create Box =======================================================*/
225

226
DEF_STD_CMD_AU(CmdSketcherCreateRectangle)
227

228
CmdSketcherCreateRectangle::CmdSketcherCreateRectangle()
229
    : Command("Sketcher_CreateRectangle")
230
{
231
    sAppModule = "Sketcher";
232
    sGroup = "Sketcher";
233
    sMenuText = QT_TR_NOOP("Create rectangle");
234
    sToolTipText = QT_TR_NOOP("Create a rectangle in the sketch");
235
    sWhatsThis = "Sketcher_CreateRectangle";
236
    sStatusTip = sToolTipText;
237
    sPixmap = "Sketcher_CreateRectangle";
238
    sAccel = "G, R";
239
    eType = ForEdit;
240
}
241

242
CONSTRUCTION_UPDATE_ACTION(CmdSketcherCreateRectangle, "Sketcher_CreateRectangle")
243

244
void CmdSketcherCreateRectangle::activated(int iMsg)
245
{
246
    Q_UNUSED(iMsg);
247
    ActivateHandler(getActiveGuiDocument(),
248
                    std::make_unique<DrawSketchHandlerRectangle>(
249
                        ConstructionMethods::RectangleConstructionMethod::Diagonal));
250
}
251

252
bool CmdSketcherCreateRectangle::isActive()
253
{
254
    return isCommandActive(getActiveGuiDocument());
255
}
256

257
DEF_STD_CMD_AU(CmdSketcherCreateRectangleCenter)
258

259
CmdSketcherCreateRectangleCenter::CmdSketcherCreateRectangleCenter()
260
    : Command("Sketcher_CreateRectangle_Center")
261
{
262
    sAppModule = "Sketcher";
263
    sGroup = "Sketcher";
264
    sMenuText = QT_TR_NOOP("Create centered rectangle");
265
    sToolTipText = QT_TR_NOOP("Create a centered rectangle in the sketch");
266
    sWhatsThis = "Sketcher_CreateRectangle_Center";
267
    sStatusTip = sToolTipText;
268
    sPixmap = "Sketcher_CreateRectangle_Center";
269
    sAccel = "G, V";
270
    eType = ForEdit;
271
}
272

273
CONSTRUCTION_UPDATE_ACTION(CmdSketcherCreateRectangleCenter, "Sketcher_CreateRectangle_Center")
274

275
void CmdSketcherCreateRectangleCenter::activated(int iMsg)
276
{
277
    Q_UNUSED(iMsg);
278
    ActivateHandler(getActiveGuiDocument(),
279
                    std::make_unique<DrawSketchHandlerRectangle>(
280
                        ConstructionMethods::RectangleConstructionMethod::CenterAndCorner));
281
}
282

283
bool CmdSketcherCreateRectangleCenter::isActive()
284
{
285
    return isCommandActive(getActiveGuiDocument());
286
}
287

288

289
/* Create rounded oblong =======================================================*/
290

291
DEF_STD_CMD_AU(CmdSketcherCreateOblong)
292

293
CmdSketcherCreateOblong::CmdSketcherCreateOblong()
294
    : Command("Sketcher_CreateOblong")
295
{
296
    sAppModule = "Sketcher";
297
    sGroup = "Sketcher";
298
    sMenuText = QT_TR_NOOP("Create rounded rectangle");
299
    sToolTipText = QT_TR_NOOP("Create a rounded rectangle in the sketch");
300
    sWhatsThis = "Sketcher_CreateOblong";
301
    sStatusTip = sToolTipText;
302
    sPixmap = "Sketcher_CreateOblong";
303
    sAccel = "G, O";
304
    eType = ForEdit;
305
}
306

307
CONSTRUCTION_UPDATE_ACTION(CmdSketcherCreateOblong, "Sketcher_CreateOblong")
308

309
void CmdSketcherCreateOblong::activated(int iMsg)
310
{
311
    Q_UNUSED(iMsg);
312
    ActivateHandler(getActiveGuiDocument(),
313
                    std::make_unique<DrawSketchHandlerRectangle>(
314
                        ConstructionMethods::RectangleConstructionMethod::Diagonal,
315
                        true));
316
}
317

318
bool CmdSketcherCreateOblong::isActive()
319
{
320
    return isCommandActive(getActiveGuiDocument());
321
}
322

323
/* Rectangles Comp command =========================================*/
324

325
DEF_STD_CMD_ACLU(CmdSketcherCompCreateRectangles)
326

327
CmdSketcherCompCreateRectangles::CmdSketcherCompCreateRectangles()
328
    : Command("Sketcher_CompCreateRectangles")
329
{
330
    sAppModule = "Sketcher";
331
    sGroup = "Sketcher";
332
    sMenuText = QT_TR_NOOP("Create rectangle");
333
    sToolTipText = QT_TR_NOOP("Creates a rectangle in the sketch");
334
    sWhatsThis = "Sketcher_CompCreateRectangles";
335
    sStatusTip = sToolTipText;
336
    eType = ForEdit;
337
}
338

339
void CmdSketcherCompCreateRectangles::activated(int iMsg)
340
{
341
    if (iMsg == 0) {
342
        ActivateHandler(getActiveGuiDocument(),
343
                        std::make_unique<DrawSketchHandlerRectangle>(
344
                            ConstructionMethods::RectangleConstructionMethod::Diagonal));
345
    }
346
    else if (iMsg == 1) {
347
        ActivateHandler(getActiveGuiDocument(),
348
                        std::make_unique<DrawSketchHandlerRectangle>(
349
                            ConstructionMethods::RectangleConstructionMethod::CenterAndCorner));
350
    }
351
    else if (iMsg == 2) {
352
        ActivateHandler(getActiveGuiDocument(),
353
                        std::make_unique<DrawSketchHandlerRectangle>(
354
                            ConstructionMethods::RectangleConstructionMethod::Diagonal,
355
                            true));
356
    }
357
    else {
358
        return;
359
    }
360

361
    // Since the default icon is reset when enabling/disabling the command we have
362
    // to explicitly set the icon of the used command.
363
    Gui::ActionGroup* pcAction = qobject_cast<Gui::ActionGroup*>(_pcAction);
364
    QList<QAction*> a = pcAction->actions();
365

366
    assert(iMsg < a.size());
367
    pcAction->setIcon(a[iMsg]->icon());
368
}
369

370
Gui::Action* CmdSketcherCompCreateRectangles::createAction()
371
{
372
    Gui::ActionGroup* pcAction = new Gui::ActionGroup(this, Gui::getMainWindow());
373
    pcAction->setDropDownMenu(true);
374
    applyCommandData(this->className(), pcAction);
375

376
    QAction* arc1 = pcAction->addAction(QString());
377
    arc1->setIcon(Gui::BitmapFactory().iconFromTheme("Sketcher_CreateRectangle"));
378
    QAction* arc2 = pcAction->addAction(QString());
379
    arc2->setIcon(Gui::BitmapFactory().iconFromTheme("Sketcher_CreateRectangle_Center"));
380
    QAction* arc3 = pcAction->addAction(QString());
381
    arc3->setIcon(Gui::BitmapFactory().iconFromTheme("Sketcher_CreateOblong"));
382

383
    _pcAction = pcAction;
384
    languageChange();
385

386
    pcAction->setIcon(arc1->icon());
387
    int defaultId = 0;
388
    pcAction->setProperty("defaultAction", QVariant(defaultId));
389

390
    return pcAction;
391
}
392

393
void CmdSketcherCompCreateRectangles::updateAction(int mode)
394
{
395
    Gui::ActionGroup* pcAction = qobject_cast<Gui::ActionGroup*>(getAction());
396
    if (!pcAction) {
397
        return;
398
    }
399

400
    QList<QAction*> a = pcAction->actions();
401
    int index = pcAction->property("defaultAction").toInt();
402
    switch (static_cast<GeometryCreationMode>(mode)) {
403
        case GeometryCreationMode::Normal:
404
            a[0]->setIcon(Gui::BitmapFactory().iconFromTheme("Sketcher_CreateRectangle"));
405
            a[1]->setIcon(Gui::BitmapFactory().iconFromTheme("Sketcher_CreateRectangle_Center"));
406
            a[2]->setIcon(Gui::BitmapFactory().iconFromTheme("Sketcher_CreateOblong"));
407
            getAction()->setIcon(a[index]->icon());
408
            break;
409
        case GeometryCreationMode::Construction:
410
            a[0]->setIcon(Gui::BitmapFactory().iconFromTheme("Sketcher_CreateRectangle_Constr"));
411
            a[1]->setIcon(
412
                Gui::BitmapFactory().iconFromTheme("Sketcher_CreateRectangle_Center_Constr"));
413
            a[2]->setIcon(Gui::BitmapFactory().iconFromTheme("Sketcher_CreateOblong_Constr"));
414
            getAction()->setIcon(a[index]->icon());
415
            break;
416
    }
417
}
418

419
void CmdSketcherCompCreateRectangles::languageChange()
420
{
421
    Command::languageChange();
422

423
    if (!_pcAction) {
424
        return;
425
    }
426
    Gui::ActionGroup* pcAction = qobject_cast<Gui::ActionGroup*>(_pcAction);
427
    QList<QAction*> a = pcAction->actions();
428

429
    QAction* rectangle1 = a[0];
430
    rectangle1->setText(QApplication::translate("CmdSketcherCompCreateRectangles", "Rectangle"));
431
    rectangle1->setToolTip(
432
        QApplication::translate("Sketcher_CreateRectangle", "Create a rectangle"));
433
    rectangle1->setStatusTip(rectangle1->toolTip());
434
    QAction* rectangle2 = a[1];
435
    rectangle2->setText(
436
        QApplication::translate("CmdSketcherCompCreateRectangles", "Centered rectangle"));
437
    rectangle2->setToolTip(
438
        QApplication::translate("Sketcher_CreateRectangle_Center", "Create a centered rectangle"));
439
    rectangle2->setStatusTip(rectangle2->toolTip());
440
    QAction* rectangle3 = a[2];
441
    rectangle3->setText(
442
        QApplication::translate("CmdSketcherCompCreateRectangles", "Rounded rectangle"));
443
    rectangle3->setToolTip(
444
        QApplication::translate("Sketcher_CreateOblong", "Create a rounded rectangle"));
445
    rectangle3->setStatusTip(rectangle3->toolTip());
446
}
447

448
bool CmdSketcherCompCreateRectangles::isActive()
449
{
450
    return isCommandActive(getActiveGuiDocument());
451
}
452

453
// ======================================================================================
454

455
DEF_STD_CMD_AU(CmdSketcherCreateArc)
456

457
CmdSketcherCreateArc::CmdSketcherCreateArc()
458
    : Command("Sketcher_CreateArc")
459
{
460
    sAppModule = "Sketcher";
461
    sGroup = "Sketcher";
462
    sMenuText = QT_TR_NOOP("Create arc by center");
463
    sToolTipText = QT_TR_NOOP("Create an arc by its center and by its end points");
464
    sWhatsThis = "Sketcher_CreateArc";
465
    sStatusTip = sToolTipText;
466
    sPixmap = "Sketcher_CreateArc";
467
    sAccel = "G, A";
468
    eType = ForEdit;
469
}
470

471
CONSTRUCTION_UPDATE_ACTION(CmdSketcherCreateArc, "Sketcher_CreateArc")
472

473
void CmdSketcherCreateArc::activated(int iMsg)
474
{
475
    Q_UNUSED(iMsg);
476
    ActivateHandler(getActiveGuiDocument(), std::make_unique<DrawSketchHandlerArc>());
477
}
478

479
bool CmdSketcherCreateArc::isActive()
480
{
481
    return isCommandActive(getActiveGuiDocument());
482
}
483

484

485
// ======================================================================================
486

487
DEF_STD_CMD_AU(CmdSketcherCreate3PointArc)
488

489
CmdSketcherCreate3PointArc::CmdSketcherCreate3PointArc()
490
    : Command("Sketcher_Create3PointArc")
491
{
492
    sAppModule = "Sketcher";
493
    sGroup = "Sketcher";
494
    sMenuText = QT_TR_NOOP("Create arc by 3 points");
495
    sToolTipText = QT_TR_NOOP("Create an arc by its end points and a point along the arc");
496
    sWhatsThis = "Sketcher_Create3PointArc";
497
    sStatusTip = sToolTipText;
498
    sPixmap = "Sketcher_Create3PointArc";
499
    sAccel = "G, 3, A";
500
    eType = ForEdit;
501
}
502

503
CONSTRUCTION_UPDATE_ACTION(CmdSketcherCreate3PointArc, "Sketcher_Create3PointArc")
504

505
void CmdSketcherCreate3PointArc::activated(int iMsg)
506
{
507
    Q_UNUSED(iMsg);
508
    ActivateHandler(getActiveGuiDocument(),
509
                    std::make_unique<DrawSketchHandlerArc>(
510
                        ConstructionMethods::CircleEllipseConstructionMethod::ThreeRim));
511
}
512

513
bool CmdSketcherCreate3PointArc::isActive()
514
{
515
    return isCommandActive(getActiveGuiDocument());
516
}
517

518

519
// Comp create arc tools =============================================
520

521
class CmdSketcherCompCreateArc: public Gui::GroupCommand
522
{
523
public:
524
    CmdSketcherCompCreateArc()
525
        : GroupCommand("Sketcher_CompCreateArc")
526
    {
527
        sAppModule = "Sketcher";
528
        sGroup = "Sketcher";
529
        sMenuText = QT_TR_NOOP("Create arc");
530
        sToolTipText = QT_TR_NOOP("Create an arc in the sketch");
531
        sWhatsThis = "Sketcher_CompCreateArc";
532
        sStatusTip = sToolTipText;
533
        eType = ForEdit;
534

535
        setCheckable(false);
536
        // setRememberLast(true);
537

538
        addCommand("Sketcher_CreateArc");
539
        addCommand("Sketcher_Create3PointArc");
540
        addCommand("Sketcher_CreateArcOfEllipse");
541
        addCommand("Sketcher_CreateArcOfHyperbola");
542
        addCommand("Sketcher_CreateArcOfParabola");
543
    }
544

545
    void updateAction(int mode) override
546
    {
547
        Gui::ActionGroup* pcAction = qobject_cast<Gui::ActionGroup*>(getAction());
548
        if (!pcAction) {
549
            return;
550
        }
551

552
        QList<QAction*> al = pcAction->actions();
553
        int index = pcAction->property("defaultAction").toInt();
554
        switch (static_cast<GeometryCreationMode>(mode)) {
555
            case GeometryCreationMode::Normal:
556
                al[0]->setIcon(Gui::BitmapFactory().iconFromTheme("Sketcher_CreateArc"));
557
                al[1]->setIcon(Gui::BitmapFactory().iconFromTheme("Sketcher_Create3PointArc"));
558
                al[2]->setIcon(Gui::BitmapFactory().iconFromTheme("Sketcher_CreateElliptical_Arc"));
559
                al[3]->setIcon(Gui::BitmapFactory().iconFromTheme("Sketcher_CreateHyperbolic_Arc"));
560
                al[4]->setIcon(Gui::BitmapFactory().iconFromTheme("Sketcher_CreateParabolic_Arc"));
561
                getAction()->setIcon(al[index]->icon());
562
                break;
563
            case GeometryCreationMode::Construction:
564
                al[0]->setIcon(Gui::BitmapFactory().iconFromTheme("Sketcher_CreateArc_Constr"));
565
                al[1]->setIcon(
566
                    Gui::BitmapFactory().iconFromTheme("Sketcher_Create3PointArc_Constr"));
567
                al[2]->setIcon(
568
                    Gui::BitmapFactory().iconFromTheme("Sketcher_CreateElliptical_Arc_Constr"));
569
                al[3]->setIcon(
570
                    Gui::BitmapFactory().iconFromTheme("Sketcher_CreateHyperbolic_Arc_Constr"));
571
                al[4]->setIcon(
572
                    Gui::BitmapFactory().iconFromTheme("Sketcher_CreateParabolic_Arc_Constr"));
573
                getAction()->setIcon(al[index]->icon());
574
                break;
575
        }
576
    }
577
    const char* className() const override
578
    {
579
        return "CmdSketcherCompCreateArc";
580
    }
581
    bool isActive() override
582
    {
583
        return isCommandActive(getActiveGuiDocument());
584
    }
585
};
586

587
// ======================================================================================
588

589

590
DEF_STD_CMD_AU(CmdSketcherCreateCircle)
591

592
CmdSketcherCreateCircle::CmdSketcherCreateCircle()
593
    : Command("Sketcher_CreateCircle")
594
{
595
    sAppModule = "Sketcher";
596
    sGroup = "Sketcher";
597
    sMenuText = QT_TR_NOOP("Create circle by center");
598
    sToolTipText = QT_TR_NOOP("Create a circle in the sketch");
599
    sWhatsThis = "Sketcher_CreateCircle";
600
    sStatusTip = sToolTipText;
601
    sPixmap = "Sketcher_CreateCircle";
602
    sAccel = "G, C";
603
    eType = ForEdit;
604
}
605

606
CONSTRUCTION_UPDATE_ACTION(CmdSketcherCreateCircle, "Sketcher_CreateCircle")
607

608
void CmdSketcherCreateCircle::activated(int iMsg)
609
{
610
    Q_UNUSED(iMsg);
611
    ActivateHandler(getActiveGuiDocument(), std::make_unique<DrawSketchHandlerCircle>());
612
}
613

614
bool CmdSketcherCreateCircle::isActive()
615
{
616
    return isCommandActive(getActiveGuiDocument());
617
}
618
// ======================================================================================
619

620
/// @brief Macro that declares a new sketcher command class 'CmdSketcherCreateEllipseByCenter'
621
DEF_STD_CMD_AU(CmdSketcherCreateEllipseByCenter)
622

623
/**
624
 * @brief ctor
625
 */
626
CmdSketcherCreateEllipseByCenter::CmdSketcherCreateEllipseByCenter()
627
    : Command("Sketcher_CreateEllipseByCenter")
628
{
629
    sAppModule = "Sketcher";
630
    sGroup = "Sketcher";
631
    sMenuText = QT_TR_NOOP("Create ellipse by center");
632
    sToolTipText = QT_TR_NOOP("Create an ellipse by center in the sketch");
633
    sWhatsThis = "Sketcher_CreateEllipseByCenter";
634
    sStatusTip = sToolTipText;
635
    sPixmap = "Sketcher_CreateEllipseByCenter";
636
    sAccel = "G, E, E";
637
    eType = ForEdit;
638
}
639

640
CONSTRUCTION_UPDATE_ACTION(CmdSketcherCreateEllipseByCenter, "Sketcher_CreateEllipseByCenter")
641

642
void CmdSketcherCreateEllipseByCenter::activated(int iMsg)
643
{
644
    Q_UNUSED(iMsg);
645
    ActivateHandler(getActiveGuiDocument(), std::make_unique<DrawSketchHandlerEllipse>());
646
}
647

648
bool CmdSketcherCreateEllipseByCenter::isActive()
649
{
650
    return isCommandActive(getActiveGuiDocument());
651
}
652

653
/// @brief Macro that declares a new sketcher command class 'CmdSketcherCreateEllipseBy3Points'
654
DEF_STD_CMD_AU(CmdSketcherCreateEllipseBy3Points)
655

656
/**
657
 * @brief ctor
658
 */
659
CmdSketcherCreateEllipseBy3Points::CmdSketcherCreateEllipseBy3Points()
660
    : Command("Sketcher_CreateEllipseBy3Points")
661
{
662
    sAppModule = "Sketcher";
663
    sGroup = "Sketcher";
664
    sMenuText = QT_TR_NOOP("Create ellipse by 3 points");
665
    sToolTipText = QT_TR_NOOP("Create an ellipse by 3 points in the sketch");
666
    sWhatsThis = "Sketcher_CreateEllipseBy3Points";
667
    sStatusTip = sToolTipText;
668
    sPixmap = "Sketcher_CreateEllipse_3points";
669
    sAccel = "G, 3, E";
670
    eType = ForEdit;
671
}
672

673
CONSTRUCTION_UPDATE_ACTION(CmdSketcherCreateEllipseBy3Points, "Sketcher_CreateEllipse_3points")
674

675
void CmdSketcherCreateEllipseBy3Points::activated(int iMsg)
676
{
677
    Q_UNUSED(iMsg);
678
    ActivateHandler(getActiveGuiDocument(),
679
                    std::make_unique<DrawSketchHandlerEllipse>(
680
                        ConstructionMethods::CircleEllipseConstructionMethod::ThreeRim));
681
}
682

683
bool CmdSketcherCreateEllipseBy3Points::isActive()
684
{
685
    return isCommandActive(getActiveGuiDocument());
686
}
687

688
DEF_STD_CMD_AU(CmdSketcherCreateArcOfEllipse)
689

690
CmdSketcherCreateArcOfEllipse::CmdSketcherCreateArcOfEllipse()
691
    : Command("Sketcher_CreateArcOfEllipse")
692
{
693
    sAppModule = "Sketcher";
694
    sGroup = "Sketcher";
695
    sMenuText = QT_TR_NOOP("Create arc of ellipse");
696
    sToolTipText = QT_TR_NOOP("Create an arc of ellipse in the sketch");
697
    sWhatsThis = "Sketcher_CreateArcOfEllipse";
698
    sStatusTip = sToolTipText;
699
    sPixmap = "Sketcher_CreateElliptical_Arc";
700
    sAccel = "G, E, A";
701
    eType = ForEdit;
702
}
703

704
CONSTRUCTION_UPDATE_ACTION(CmdSketcherCreateArcOfEllipse, "Sketcher_CreateElliptical_Arc")
705

706
void CmdSketcherCreateArcOfEllipse::activated(int iMsg)
707
{
708
    Q_UNUSED(iMsg);
709
    ActivateHandler(getActiveGuiDocument(), std::make_unique<DrawSketchHandlerArcOfEllipse>());
710
}
711

712
bool CmdSketcherCreateArcOfEllipse::isActive()
713
{
714
    return isCommandActive(getActiveGuiDocument());
715
}
716

717
DEF_STD_CMD_AU(CmdSketcherCreateArcOfHyperbola)
718

719
CmdSketcherCreateArcOfHyperbola::CmdSketcherCreateArcOfHyperbola()
720
    : Command("Sketcher_CreateArcOfHyperbola")
721
{
722
    sAppModule = "Sketcher";
723
    sGroup = "Sketcher";
724
    sMenuText = QT_TR_NOOP("Create arc of hyperbola");
725
    sToolTipText = QT_TR_NOOP("Create an arc of hyperbola in the sketch");
726
    sWhatsThis = "Sketcher_CreateArcOfHyperbola";
727
    sStatusTip = sToolTipText;
728
    sPixmap = "Sketcher_CreateHyperbolic_Arc";
729
    sAccel = "G, H";
730
    eType = ForEdit;
731
}
732

733
CONSTRUCTION_UPDATE_ACTION(CmdSketcherCreateArcOfHyperbola, "Sketcher_CreateHyperbolic_Arc")
734

735
void CmdSketcherCreateArcOfHyperbola::activated(int /*iMsg*/)
736
{
737
    ActivateHandler(getActiveGuiDocument(), std::make_unique<DrawSketchHandlerArcOfHyperbola>());
738
}
739

740
bool CmdSketcherCreateArcOfHyperbola::isActive()
741
{
742
    return isCommandActive(getActiveGuiDocument());
743
}
744

745
DEF_STD_CMD_AU(CmdSketcherCreateArcOfParabola)
746

747
CmdSketcherCreateArcOfParabola::CmdSketcherCreateArcOfParabola()
748
    : Command("Sketcher_CreateArcOfParabola")
749
{
750
    sAppModule = "Sketcher";
751
    sGroup = "Sketcher";
752
    sMenuText = QT_TR_NOOP("Create arc of parabola");
753
    sToolTipText = QT_TR_NOOP("Create an arc of parabola in the sketch");
754
    sWhatsThis = "Sketcher_CreateArcOfParabola";
755
    sStatusTip = sToolTipText;
756
    sPixmap = "Sketcher_CreateParabolic_Arc";
757
    sAccel = "G, J";
758
    eType = ForEdit;
759
}
760

761
CONSTRUCTION_UPDATE_ACTION(CmdSketcherCreateArcOfParabola, "Sketcher_CreateParabolic_Arc")
762

763
void CmdSketcherCreateArcOfParabola::activated(int /*iMsg*/)
764
{
765
    ActivateHandler(getActiveGuiDocument(), std::make_unique<DrawSketchHandlerArcOfParabola>());
766
}
767

768
bool CmdSketcherCreateArcOfParabola::isActive()
769
{
770
    return isCommandActive(getActiveGuiDocument());
771
}
772

773

774
// Comp create conic tools =============================================
775
class CmdSketcherCompCreateConic: public Gui::GroupCommand
776
{
777
public:
778
    CmdSketcherCompCreateConic()
779
        : GroupCommand("Sketcher_CompCreateConic")
780
    {
781
        sAppModule = "Sketcher";
782
        sGroup = "Sketcher";
783
        sMenuText = QT_TR_NOOP("Create conic");
784
        sToolTipText = QT_TR_NOOP("Create a conic in the sketch");
785
        sWhatsThis = "Sketcher_CompCreateConic";
786
        sStatusTip = sToolTipText;
787
        eType = ForEdit;
788

789
        setCheckable(false);
790
        setRememberLast(true);
791

792
        addCommand("Sketcher_CreateCircle");
793
        addCommand("Sketcher_Create3PointCircle");
794
        addCommand("Sketcher_CreateEllipseByCenter");
795
        addCommand("Sketcher_CreateEllipseBy3Points");
796
    }
797

798
    void updateAction(int mode) override
799
    {
800
        Gui::ActionGroup* pcAction = qobject_cast<Gui::ActionGroup*>(getAction());
801
        if (!pcAction) {
802
            return;
803
        }
804

805
        QList<QAction*> al = pcAction->actions();
806
        int index = pcAction->property("defaultAction").toInt();
807
        switch (static_cast<GeometryCreationMode>(mode)) {
808
            case GeometryCreationMode::Normal:
809
                al[0]->setIcon(Gui::BitmapFactory().iconFromTheme("Sketcher_CreateCircle"));
810
                al[1]->setIcon(Gui::BitmapFactory().iconFromTheme("Sketcher_Create3PointCircle"));
811
                al[2]->setIcon(
812
                    Gui::BitmapFactory().iconFromTheme("Sketcher_CreateEllipseByCenter"));
813
                al[3]->setIcon(
814
                    Gui::BitmapFactory().iconFromTheme("Sketcher_CreateEllipse_3points"));
815
                getAction()->setIcon(al[index]->icon());
816
                break;
817
            case GeometryCreationMode::Construction:
818
                al[0]->setIcon(Gui::BitmapFactory().iconFromTheme("Sketcher_CreateCircle_Constr"));
819
                al[1]->setIcon(
820
                    Gui::BitmapFactory().iconFromTheme("Sketcher_Create3PointCircle_Constr"));
821
                al[2]->setIcon(
822
                    Gui::BitmapFactory().iconFromTheme("Sketcher_CreateEllipseByCenter_Constr"));
823
                al[3]->setIcon(
824
                    Gui::BitmapFactory().iconFromTheme("Sketcher_CreateEllipse_3points_Constr"));
825
                getAction()->setIcon(al[index]->icon());
826
                break;
827
        }
828
    }
829
    const char* className() const override
830
    {
831
        return "CmdSketcherCompCreateConic";
832
    }
833
    bool isActive() override
834
    {
835
        return isCommandActive(getActiveGuiDocument());
836
    }
837
};
838

839
// ======================================================================================
840

841
DEF_STD_CMD_AU(CmdSketcherCreateBSpline)
842

843
CmdSketcherCreateBSpline::CmdSketcherCreateBSpline()
844
    : Command("Sketcher_CreateBSpline")
845
{
846
    sAppModule = "Sketcher";
847
    sGroup = "Sketcher";
848
    sMenuText = QT_TR_NOOP("Create B-spline");
849
    sToolTipText = QT_TR_NOOP("Create a B-spline by control points in the sketch.");
850
    sWhatsThis = "Sketcher_CreateBSpline";
851
    sStatusTip = sToolTipText;
852
    sPixmap = "Sketcher_CreateBSpline";
853
    sAccel = "G, B, B";
854
    eType = ForEdit;
855
}
856

857
CONSTRUCTION_UPDATE_ACTION(CmdSketcherCreateBSpline, "Sketcher_CreateBSpline")
858

859
void CmdSketcherCreateBSpline::activated(int iMsg)
860
{
861
    Q_UNUSED(iMsg);
862
    ActivateHandler(getActiveGuiDocument(),
863
                    std::make_unique<DrawSketchHandlerBSpline>(
864
                        ConstructionMethods::BSplineConstructionMethod::ControlPoints));
865
}
866

867
bool CmdSketcherCreateBSpline::isActive()
868
{
869
    return isCommandActive(getActiveGuiDocument());
870
}
871

872
/// @brief Macro that declares a new sketcher command class 'CmdSketcherCreateBSpline'
873
DEF_STD_CMD_AU(CmdSketcherCreatePeriodicBSpline)
874

875
/**
876
 * @brief ctor
877
 */
878
CmdSketcherCreatePeriodicBSpline::CmdSketcherCreatePeriodicBSpline()
879
    : Command("Sketcher_CreatePeriodicBSpline")
880
{
881
    sAppModule = "Sketcher";
882
    sGroup = "Sketcher";
883
    sMenuText = QT_TR_NOOP("Create periodic B-spline");
884
    sToolTipText = QT_TR_NOOP("Create a periodic B-spline by control points in the sketch.");
885
    sWhatsThis = "Sketcher_CreatePeriodicBSpline";
886
    sStatusTip = sToolTipText;
887
    sPixmap = "Sketcher_Create_Periodic_BSpline";
888
    sAccel = "G, B, P";
889
    eType = ForEdit;
890
}
891

892
CONSTRUCTION_UPDATE_ACTION(CmdSketcherCreatePeriodicBSpline, "Sketcher_Create_Periodic_BSpline")
893

894
void CmdSketcherCreatePeriodicBSpline::activated(int iMsg)
895
{
896
    Q_UNUSED(iMsg);
897
    ActivateHandler(getActiveGuiDocument(),
898
                    std::make_unique<DrawSketchHandlerBSpline>(
899
                        ConstructionMethods::BSplineConstructionMethod::ControlPoints,
900
                        true));
901
}
902

903
bool CmdSketcherCreatePeriodicBSpline::isActive()
904
{
905
    return isCommandActive(getActiveGuiDocument());
906
}
907

908
/// @brief Macro that declares a new sketcher command class
909
/// 'CmdSketcherCreateBSplineByInterpolation'
910
DEF_STD_CMD_AU(CmdSketcherCreateBSplineByInterpolation)
911

912
CmdSketcherCreateBSplineByInterpolation::CmdSketcherCreateBSplineByInterpolation()
913
    : Command("Sketcher_CreateBSplineByInterpolation")
914
{
915
    sAppModule = "Sketcher";
916
    sGroup = "Sketcher";
917
    sMenuText = QT_TR_NOOP("Create B-spline by knots");
918
    sToolTipText = QT_TR_NOOP("Create a B-spline by knots, i.e. by interpolation, in the sketch.");
919
    sWhatsThis = "Sketcher_CreateBSplineByInterpolation";
920
    sStatusTip = sToolTipText;
921
    sPixmap = "Sketcher_CreateBSplineByInterpolation";
922
    sAccel = "G, B, I";
923
    eType = ForEdit;
924
}
925

926
CONSTRUCTION_UPDATE_ACTION(CmdSketcherCreateBSplineByInterpolation,
927
                           "Sketcher_CreateBSplineByInterpolation")
928

929
void CmdSketcherCreateBSplineByInterpolation::activated(int iMsg)
930
{
931
    Q_UNUSED(iMsg);
932
    ActivateHandler(getActiveGuiDocument(),
933
                    std::make_unique<DrawSketchHandlerBSpline>(
934
                        ConstructionMethods::BSplineConstructionMethod::Knots));
935
}
936

937
bool CmdSketcherCreateBSplineByInterpolation::isActive()
938
{
939
    return isCommandActive(getActiveGuiDocument());
940
}
941

942
/// @brief Macro that declares a new sketcher command class
943
/// 'CmdSketcherCreatePeriodicBSplineByInterpolation'
944
DEF_STD_CMD_AU(CmdSketcherCreatePeriodicBSplineByInterpolation)
945

946
CmdSketcherCreatePeriodicBSplineByInterpolation::CmdSketcherCreatePeriodicBSplineByInterpolation()
947
    : Command("Sketcher_CreatePeriodicBSplineByInterpolation")
948
{
949
    sAppModule = "Sketcher";
950
    sGroup = "Sketcher";
951
    sMenuText = QT_TR_NOOP("Create periodic B-spline by knots");
952
    sToolTipText =
953
        QT_TR_NOOP("Create a periodic B-spline by knots, i.e. by interpolation, in the sketch.");
954
    sWhatsThis = "Sketcher_CreatePeriodicBSplineByInterpolation";
955
    sStatusTip = sToolTipText;
956
    sPixmap = "Sketcher_CreatePeriodicBSplineByInterpolation";
957
    sAccel = "G, B, O";
958
    eType = ForEdit;
959
}
960

961
CONSTRUCTION_UPDATE_ACTION(CmdSketcherCreatePeriodicBSplineByInterpolation,
962
                           "Sketcher_CreatePeriodicBSplineByInterpolation")
963

964
void CmdSketcherCreatePeriodicBSplineByInterpolation::activated(int iMsg)
965
{
966
    Q_UNUSED(iMsg);
967

968
    ActivateHandler(getActiveGuiDocument(),
969
                    std::make_unique<DrawSketchHandlerBSpline>(
970
                        ConstructionMethods::BSplineConstructionMethod::Knots,
971
                        true));
972
}
973

974
bool CmdSketcherCreatePeriodicBSplineByInterpolation::isActive()
975
{
976
    return isCommandActive(getActiveGuiDocument());
977
}
978

979

980
/// @brief Macro that declares a new sketcher command class 'CmdSketcherCompCreateBSpline'
981
DEF_STD_CMD_ACLU(CmdSketcherCompCreateBSpline)
982

983
/**
984
 * @brief ctor
985
 */
986
CmdSketcherCompCreateBSpline::CmdSketcherCompCreateBSpline()
987
    : Command("Sketcher_CompCreateBSpline")
988
{
989
    sAppModule = "Sketcher";
990
    sGroup = "Sketcher";
991
    sMenuText = QT_TR_NOOP("Create B-spline");
992
    sToolTipText = QT_TR_NOOP("Create a B-spline in the sketch");
993
    sWhatsThis = "Sketcher_CompCreateBSpline";
994
    sStatusTip = sToolTipText;
995
    eType = ForEdit;
996
}
997

998
/**
999
 * @brief Instantiates the B-spline handler when the B-spline command activated
1000
 * @param int iMsg
1001
 */
1002
void CmdSketcherCompCreateBSpline::activated(int iMsg)
1003
{
1004
    if (iMsg == 0) {
1005
        ActivateHandler(getActiveGuiDocument(),
1006
                        std::make_unique<DrawSketchHandlerBSpline>(
1007
                            ConstructionMethods::BSplineConstructionMethod::ControlPoints));
1008
    }
1009
    else if (iMsg == 1) {
1010
        ActivateHandler(getActiveGuiDocument(),
1011
                        std::make_unique<DrawSketchHandlerBSpline>(
1012
                            ConstructionMethods::BSplineConstructionMethod::ControlPoints,
1013
                            true));
1014
    }
1015
    else if (iMsg == 2) {
1016
        ActivateHandler(getActiveGuiDocument(),
1017
                        std::make_unique<DrawSketchHandlerBSpline>(
1018
                            ConstructionMethods::BSplineConstructionMethod::Knots));
1019
    }
1020
    else if (iMsg == 3) {
1021
        ActivateHandler(getActiveGuiDocument(),
1022
                        std::make_unique<DrawSketchHandlerBSpline>(
1023
                            ConstructionMethods::BSplineConstructionMethod::Knots,
1024
                            true));
1025
    }
1026
    else {
1027
        return;
1028
    }
1029

1030
    // Since the default icon is reset when enabling/disabling the command we have
1031
    // to explicitly set the icon of the used command.
1032
    Gui::ActionGroup* pcAction = qobject_cast<Gui::ActionGroup*>(_pcAction);
1033
    QList<QAction*> a = pcAction->actions();
1034

1035
    assert(iMsg < a.size());
1036
    pcAction->setIcon(a[iMsg]->icon());
1037
}
1038

1039
Gui::Action* CmdSketcherCompCreateBSpline::createAction()
1040
{
1041
    Gui::ActionGroup* pcAction = new Gui::ActionGroup(this, Gui::getMainWindow());
1042
    pcAction->setDropDownMenu(true);
1043
    applyCommandData(this->className(), pcAction);
1044

1045
    QAction* bspline = pcAction->addAction(QString());
1046
    bspline->setIcon(Gui::BitmapFactory().iconFromTheme("Sketcher_CreateBSpline"));
1047

1048
    QAction* periodicbspline = pcAction->addAction(QString());
1049
    periodicbspline->setIcon(
1050
        Gui::BitmapFactory().iconFromTheme("Sketcher_Create_Periodic_BSpline"));
1051

1052
    QAction* bsplinebyknot = pcAction->addAction(QString());
1053
    bsplinebyknot->setIcon(
1054
        Gui::BitmapFactory().iconFromTheme("Sketcher_CreateBSplineByInterpolation"));
1055

1056
    QAction* periodicbsplinebyknot = pcAction->addAction(QString());
1057
    periodicbsplinebyknot->setIcon(
1058
        Gui::BitmapFactory().iconFromTheme("Sketcher_CreatePeriodicBSplineByInterpolation"));
1059

1060
    _pcAction = pcAction;
1061
    languageChange();
1062

1063
    // default
1064
    pcAction->setIcon(Gui::BitmapFactory().iconFromTheme("Sketcher_CreateBSpline"));
1065
    int defaultId = 0;
1066
    pcAction->setProperty("defaultAction", QVariant(defaultId));
1067

1068
    return pcAction;
1069
}
1070

1071
void CmdSketcherCompCreateBSpline::updateAction(int mode)
1072
{
1073
    Gui::ActionGroup* pcAction = qobject_cast<Gui::ActionGroup*>(getAction());
1074
    if (!pcAction) {
1075
        return;
1076
    }
1077

1078
    QList<QAction*> a = pcAction->actions();
1079
    int index = pcAction->property("defaultAction").toInt();
1080
    switch (static_cast<GeometryCreationMode>(mode)) {
1081
        case GeometryCreationMode::Normal:
1082
            a[0]->setIcon(Gui::BitmapFactory().iconFromTheme("Sketcher_CreateBSpline"));
1083
            a[1]->setIcon(Gui::BitmapFactory().iconFromTheme("Sketcher_Create_Periodic_BSpline"));
1084
            a[2]->setIcon(
1085
                Gui::BitmapFactory().iconFromTheme("Sketcher_CreateBSplineByInterpolation"));
1086
            a[3]->setIcon(Gui::BitmapFactory().iconFromTheme(
1087
                "Sketcher_CreatePeriodicBSplineByInterpolation"));
1088
            getAction()->setIcon(a[index]->icon());
1089
            break;
1090
        case GeometryCreationMode::Construction:
1091
            a[0]->setIcon(Gui::BitmapFactory().iconFromTheme("Sketcher_CreateBSpline_Constr"));
1092
            a[1]->setIcon(
1093
                Gui::BitmapFactory().iconFromTheme("Sketcher_Create_Periodic_BSpline_Constr"));
1094
            a[2]->setIcon(
1095
                Gui::BitmapFactory().iconFromTheme("Sketcher_CreateBSplineByInterpolation_Constr"));
1096
            a[3]->setIcon(Gui::BitmapFactory().iconFromTheme(
1097
                "Sketcher_CreatePeriodicBSplineByInterpolation_Constr"));
1098
            getAction()->setIcon(a[index]->icon());
1099
            break;
1100
    }
1101
}
1102

1103
void CmdSketcherCompCreateBSpline::languageChange()
1104
{
1105
    Command::languageChange();
1106

1107
    if (!_pcAction) {
1108
        return;
1109
    }
1110
    Gui::ActionGroup* pcAction = qobject_cast<Gui::ActionGroup*>(_pcAction);
1111
    QList<QAction*> a = pcAction->actions();
1112

1113
    QAction* bspline = a[0];
1114
    bspline->setText(
1115
        QApplication::translate("Sketcher_CreateBSpline", "B-spline by control points"));
1116
    bspline->setToolTip(
1117
        QApplication::translate("Sketcher_CreateBSpline", "Create a B-spline by control points"));
1118
    bspline->setStatusTip(
1119
        QApplication::translate("Sketcher_CreateBSpline", "Create a B-spline by control points"));
1120
    QAction* periodicbspline = a[1];
1121
    periodicbspline->setText(QApplication::translate("Sketcher_Create_Periodic_BSpline",
1122
                                                     "Periodic B-spline by control points"));
1123
    periodicbspline->setToolTip(
1124
        QApplication::translate("Sketcher_Create_Periodic_BSpline",
1125
                                "Create a periodic B-spline by control points"));
1126
    periodicbspline->setStatusTip(
1127
        QApplication::translate("Sketcher_Create_Periodic_BSpline",
1128
                                "Create a periodic B-spline by control points"));
1129
    QAction* bsplinebyknot = a[2];
1130
    bsplinebyknot->setText(
1131
        QApplication::translate("Sketcher_CreateBSplineByInterpolation", "B-spline by knots"));
1132
    bsplinebyknot->setToolTip(QApplication::translate("Sketcher_CreateBSplineByInterpolation",
1133
                                                      "Create a B-spline by knots"));
1134
    bsplinebyknot->setStatusTip(QApplication::translate("Sketcher_CreateBSplineByInterpolation",
1135
                                                        "Create a B-spline by knots"));
1136
    QAction* periodicbsplinebyknot = a[3];
1137
    periodicbsplinebyknot->setText(
1138
        QApplication::translate("Sketcher_CreatePeriodicBSplineByInterpolation",
1139
                                "Periodic B-spline by knots"));
1140
    periodicbsplinebyknot->setToolTip(
1141
        QApplication::translate("Sketcher_CreatePeriodicBSplineByInterpolation",
1142
                                "Create a periodic B-spline by knots"));
1143
    periodicbsplinebyknot->setStatusTip(
1144
        QApplication::translate("Sketcher_CreatePeriodicBSplineByInterpolation",
1145
                                "Create a periodic B-spline by knots"));
1146
}
1147

1148
bool CmdSketcherCompCreateBSpline::isActive()
1149
{
1150
    return isCommandActive(getActiveGuiDocument());
1151
}
1152

1153

1154
// ======================================================================================
1155

1156
DEF_STD_CMD_AU(CmdSketcherCreate3PointCircle)
1157

1158
CmdSketcherCreate3PointCircle::CmdSketcherCreate3PointCircle()
1159
    : Command("Sketcher_Create3PointCircle")
1160
{
1161
    sAppModule = "Sketcher";
1162
    sGroup = "Sketcher";
1163
    sMenuText = QT_TR_NOOP("Create circle by 3 points");
1164
    sToolTipText = QT_TR_NOOP("Create a circle by 3 perimeter points");
1165
    sWhatsThis = "Sketcher_Create3PointCircle";
1166
    sStatusTip = sToolTipText;
1167
    sPixmap = "Sketcher_Create3PointCircle";
1168
    sAccel = "G, 3, C";
1169
    eType = ForEdit;
1170
}
1171

1172
CONSTRUCTION_UPDATE_ACTION(CmdSketcherCreate3PointCircle, "Sketcher_Create3PointCircle")
1173

1174
void CmdSketcherCreate3PointCircle::activated(int iMsg)
1175
{
1176
    Q_UNUSED(iMsg);
1177
    ActivateHandler(getActiveGuiDocument(),
1178
                    std::make_unique<DrawSketchHandlerCircle>(
1179
                        ConstructionMethods::CircleEllipseConstructionMethod::ThreeRim));
1180
}
1181

1182
bool CmdSketcherCreate3PointCircle::isActive()
1183
{
1184
    return isCommandActive(getActiveGuiDocument());
1185
}
1186

1187
// ======================================================================================
1188

1189

1190
DEF_STD_CMD_A(CmdSketcherCreatePoint)
1191

1192
CmdSketcherCreatePoint::CmdSketcherCreatePoint()
1193
    : Command("Sketcher_CreatePoint")
1194
{
1195
    sAppModule = "Sketcher";
1196
    sGroup = "Sketcher";
1197
    sMenuText = QT_TR_NOOP("Create point");
1198
    sToolTipText = QT_TR_NOOP("Create a point in the sketch");
1199
    sWhatsThis = "Sketcher_CreatePoint";
1200
    sStatusTip = sToolTipText;
1201
    sPixmap = "Sketcher_CreatePoint";
1202
    sAccel = "G, Y";
1203
    eType = ForEdit;
1204
}
1205

1206
void CmdSketcherCreatePoint::activated(int iMsg)
1207
{
1208
    Q_UNUSED(iMsg);
1209
    ActivateHandler(getActiveGuiDocument(), std::make_unique<DrawSketchHandlerPoint>());
1210
}
1211

1212
bool CmdSketcherCreatePoint::isActive()
1213
{
1214
    return isCommandActive(getActiveGuiDocument());
1215
}
1216

1217
// ======================================================================================
1218

1219
DEF_STD_CMD_A(CmdSketcherCreateFillet)
1220

1221
CmdSketcherCreateFillet::CmdSketcherCreateFillet()
1222
    : Command("Sketcher_CreateFillet")
1223
{
1224
    sAppModule = "Sketcher";
1225
    sGroup = "Sketcher";
1226
    sMenuText = QT_TR_NOOP("Create fillet");
1227
    sToolTipText = QT_TR_NOOP("Create a fillet between two lines or at a coincident point");
1228
    sWhatsThis = "Sketcher_CreateFillet";
1229
    sStatusTip = sToolTipText;
1230
    sPixmap = "Sketcher_CreateFillet";
1231
    sAccel = "G, F, F";
1232
    eType = ForEdit;
1233
}
1234

1235
void CmdSketcherCreateFillet::activated(int iMsg)
1236
{
1237
    Q_UNUSED(iMsg);
1238
    ActivateHandler(getActiveGuiDocument(),
1239
                    std::make_unique<DrawSketchHandlerFillet>(
1240
                        ConstructionMethods::FilletConstructionMethod::Fillet));
1241
}
1242

1243
bool CmdSketcherCreateFillet::isActive()
1244
{
1245
    return isCommandActive(getActiveGuiDocument());
1246
}
1247

1248
// ======================================================================================
1249

1250
DEF_STD_CMD_A(CmdSketcherCreateChamfer)
1251

1252
CmdSketcherCreateChamfer::CmdSketcherCreateChamfer()
1253
    : Command("Sketcher_CreateChamfer")
1254
{
1255
    sAppModule = "Sketcher";
1256
    sGroup = "Sketcher";
1257
    sMenuText = QT_TR_NOOP("Create chamfer");
1258
    sToolTipText = QT_TR_NOOP("Create a chamfer between two lines or at a coincident point");
1259
    sWhatsThis = "Sketcher_CreateChamfer";
1260
    sStatusTip = sToolTipText;
1261
    sPixmap = "Sketcher_CreateChamfer";
1262
    sAccel = "G, F, C";
1263
    eType = ForEdit;
1264
}
1265

1266
void CmdSketcherCreateChamfer::activated(int iMsg)
1267
{
1268
    Q_UNUSED(iMsg);
1269
    ActivateHandler(getActiveGuiDocument(),
1270
                    std::make_unique<DrawSketchHandlerFillet>(
1271
                        ConstructionMethods::FilletConstructionMethod::Chamfer));
1272
}
1273

1274
bool CmdSketcherCreateChamfer::isActive()
1275
{
1276
    return isCommandActive(getActiveGuiDocument());
1277
}
1278

1279

1280
class CmdSketcherCompCreateFillets: public Gui::GroupCommand
1281
{
1282
public:
1283
    CmdSketcherCompCreateFillets()
1284
        : GroupCommand("Sketcher_CompCreateFillets")
1285
    {
1286
        sAppModule = "Sketcher";
1287
        sGroup = "Sketcher";
1288
        sMenuText = QT_TR_NOOP("Create fillet or chamfer");
1289
        sToolTipText = QT_TR_NOOP("Create a fillet or chamfer between two lines");
1290
        sWhatsThis = "Sketcher_CompCreateFillets";
1291
        sStatusTip = sToolTipText;
1292
        eType = ForEdit;
1293

1294
        setCheckable(false);
1295

1296
        addCommand("Sketcher_CreateFillet");
1297
        addCommand("Sketcher_CreateChamfer");
1298
    }
1299

1300
    const char* className() const override
1301
    {
1302
        return "CmdSketcherCompCreateFillets";
1303
    }
1304

1305
    bool isActive() override
1306
    {
1307
        return isCommandActive(getActiveGuiDocument());
1308
    }
1309
};
1310

1311

1312
// ======================================================================================
1313

1314
DEF_STD_CMD_A(CmdSketcherTrimming)
1315

1316
CmdSketcherTrimming::CmdSketcherTrimming()
1317
    : Command("Sketcher_Trimming")
1318
{
1319
    sAppModule = "Sketcher";
1320
    sGroup = "Sketcher";
1321
    sMenuText = QT_TR_NOOP("Trim edge");
1322
    sToolTipText = QT_TR_NOOP("Trim an edge with respect to the picked position");
1323
    sWhatsThis = "Sketcher_Trimming";
1324
    sStatusTip = sToolTipText;
1325
    sPixmap = "Sketcher_Trimming";
1326
    sAccel = "G, T";
1327
    eType = ForEdit;
1328
}
1329

1330
void CmdSketcherTrimming::activated(int iMsg)
1331
{
1332
    Q_UNUSED(iMsg);
1333
    ActivateHandler(getActiveGuiDocument(), std::make_unique<DrawSketchHandlerTrimming>());
1334
}
1335

1336
bool CmdSketcherTrimming::isActive()
1337
{
1338
    return isCommandActive(getActiveGuiDocument());
1339
}
1340

1341

1342
// ======================================================================================
1343

1344
DEF_STD_CMD_A(CmdSketcherExtend)
1345

1346
// TODO: fix the translations for this
1347
CmdSketcherExtend::CmdSketcherExtend()
1348
    : Command("Sketcher_Extend")
1349
{
1350
    sAppModule = "Sketcher";
1351
    sGroup = "Sketcher";
1352
    sMenuText = QT_TR_NOOP("Extend edge");
1353
    sToolTipText = QT_TR_NOOP("Extend an edge with respect to the picked position");
1354
    sWhatsThis = "Sketcher_Extend";
1355
    sStatusTip = sToolTipText;
1356
    sPixmap = "Sketcher_Extend";
1357
    sAccel = "G, Q";
1358
    eType = ForEdit;
1359
}
1360

1361
void CmdSketcherExtend::activated(int iMsg)
1362
{
1363
    Q_UNUSED(iMsg);
1364
    ActivateHandler(getActiveGuiDocument(), std::make_unique<DrawSketchHandlerExtend>());
1365
}
1366

1367
bool CmdSketcherExtend::isActive()
1368
{
1369
    return isCommandActive(getActiveGuiDocument());
1370
}
1371

1372

1373
// ======================================================================================
1374

1375
DEF_STD_CMD_A(CmdSketcherSplit)
1376

1377
// TODO: fix the translations for this
1378
CmdSketcherSplit::CmdSketcherSplit()
1379
    : Command("Sketcher_Split")
1380
{
1381
    sAppModule = "Sketcher";
1382
    sGroup = "Sketcher";
1383
    sMenuText = QT_TR_NOOP("Split edge");
1384
    sToolTipText = QT_TR_NOOP("Splits an edge into two while preserving constraints");
1385
    sWhatsThis = "Sketcher_Split";
1386
    sStatusTip = sToolTipText;
1387
    sPixmap = "Sketcher_Split";
1388
    sAccel = "G, Z";
1389
    eType = ForEdit;
1390
}
1391

1392
void CmdSketcherSplit::activated(int iMsg)
1393
{
1394
    Q_UNUSED(iMsg);
1395
    ActivateHandler(getActiveGuiDocument(), std::make_unique<DrawSketchHandlerSplitting>());
1396
}
1397

1398
bool CmdSketcherSplit::isActive()
1399
{
1400
    return isCommandActive(getActiveGuiDocument());
1401
}
1402

1403
// Comp for curve edition tools =======================================================
1404

1405
class CmdSketcherCompCurveEdition: public Gui::GroupCommand
1406
{
1407
public:
1408
    CmdSketcherCompCurveEdition()
1409
        : GroupCommand("Sketcher_CompCurveEdition")
1410
    {
1411
        sAppModule = "Sketcher";
1412
        sGroup = "Sketcher";
1413
        sMenuText = QT_TR_NOOP("Curve Edition");
1414
        sToolTipText = QT_TR_NOOP("Curve Edition tools.");
1415
        sWhatsThis = "Sketcher_CompCurveEdition";
1416
        sStatusTip = sToolTipText;
1417
        eType = ForEdit;
1418

1419
        setCheckable(false);
1420

1421
        addCommand("Sketcher_Trimming");
1422
        addCommand("Sketcher_Split");
1423
        addCommand("Sketcher_Extend");
1424
    }
1425

1426
    const char* className() const override
1427
    {
1428
        return "CmdSketcherCompCurveEdition";
1429
    }
1430

1431
    bool isActive() override
1432
    {
1433
        return isCommandActive(getActiveGuiDocument());
1434
    }
1435
};
1436

1437
// ======================================================================================
1438

1439
DEF_STD_CMD_A(CmdSketcherExternal)
1440

1441
CmdSketcherExternal::CmdSketcherExternal()
1442
    : Command("Sketcher_External")
1443
{
1444
    sAppModule = "Sketcher";
1445
    sGroup = "Sketcher";
1446
    sMenuText = QT_TR_NOOP("Create external geometry");
1447
    sToolTipText = QT_TR_NOOP("Create an edge linked to an external geometry");
1448
    sWhatsThis = "Sketcher_External";
1449
    sStatusTip = sToolTipText;
1450
    sPixmap = "Sketcher_External";
1451
    sAccel = "G, X";
1452
    eType = ForEdit;
1453
}
1454

1455
void CmdSketcherExternal::activated(int iMsg)
1456
{
1457
    Q_UNUSED(iMsg);
1458
    ActivateHandler(getActiveGuiDocument(), std::make_unique<DrawSketchHandlerExternal>());
1459
}
1460

1461
bool CmdSketcherExternal::isActive()
1462
{
1463
    return isCommandActive(getActiveGuiDocument());
1464
}
1465

1466
// ======================================================================================
1467

1468
DEF_STD_CMD_AU(CmdSketcherCarbonCopy)
1469

1470
CmdSketcherCarbonCopy::CmdSketcherCarbonCopy()
1471
    : Command("Sketcher_CarbonCopy")
1472
{
1473
    sAppModule = "Sketcher";
1474
    sGroup = "Sketcher";
1475
    sMenuText = QT_TR_NOOP("Create carbon copy");
1476
    sToolTipText = QT_TR_NOOP("Copy the geometry of another sketch");
1477
    sWhatsThis = "Sketcher_CarbonCopy";
1478
    sStatusTip = sToolTipText;
1479
    sPixmap = "Sketcher_CarbonCopy";
1480
    sAccel = "G, W";
1481
    eType = ForEdit;
1482
}
1483

1484
CONSTRUCTION_UPDATE_ACTION(CmdSketcherCarbonCopy, "Sketcher_CarbonCopy")
1485

1486
void CmdSketcherCarbonCopy::activated(int iMsg)
1487
{
1488
    Q_UNUSED(iMsg);
1489
    ActivateHandler(getActiveGuiDocument(), std::make_unique<DrawSketchHandlerCarbonCopy>());
1490
}
1491

1492
bool CmdSketcherCarbonCopy::isActive()
1493
{
1494
    return isCommandActive(getActiveGuiDocument());
1495
}
1496

1497
// Comp for slot tools =============================================
1498

1499
class CmdSketcherCompSlot: public Gui::GroupCommand
1500
{
1501
public:
1502
    CmdSketcherCompSlot()
1503
        : GroupCommand("Sketcher_CompSlot")
1504
    {
1505
        sAppModule = "Sketcher";
1506
        sGroup = "Sketcher";
1507
        sMenuText = QT_TR_NOOP("Slots");
1508
        sToolTipText = QT_TR_NOOP("Slot tools.");
1509
        sWhatsThis = "Sketcher_CompSlot";
1510
        sStatusTip = sToolTipText;
1511
        eType = ForEdit;
1512

1513
        setCheckable(false);
1514

1515
        addCommand("Sketcher_CreateSlot");
1516
        addCommand("Sketcher_CreateArcSlot");
1517
    }
1518

1519
    void updateAction(int mode) override
1520
    {
1521
        Gui::ActionGroup* pcAction = qobject_cast<Gui::ActionGroup*>(getAction());
1522
        if (!pcAction) {
1523
            return;
1524
        }
1525

1526
        QList<QAction*> al = pcAction->actions();
1527
        int index = pcAction->property("defaultAction").toInt();
1528
        switch (static_cast<GeometryCreationMode>(mode)) {
1529
            case GeometryCreationMode::Normal:
1530
                al[0]->setIcon(Gui::BitmapFactory().iconFromTheme("Sketcher_CreateSlot"));
1531
                al[1]->setIcon(Gui::BitmapFactory().iconFromTheme("Sketcher_CreateArcSlot"));
1532
                getAction()->setIcon(al[index]->icon());
1533
                break;
1534
            case GeometryCreationMode::Construction:
1535
                al[0]->setIcon(Gui::BitmapFactory().iconFromTheme("Sketcher_CreateSlot_Constr"));
1536
                al[1]->setIcon(Gui::BitmapFactory().iconFromTheme("Sketcher_CreateArcSlot_Constr"));
1537
                getAction()->setIcon(al[index]->icon());
1538
                break;
1539
        }
1540
    }
1541

1542
    const char* className() const override
1543
    {
1544
        return "CmdSketcherCompSlot";
1545
    }
1546

1547
    bool isActive() override
1548
    {
1549
        return isCommandActive(getActiveGuiDocument());
1550
    }
1551
};
1552

1553
/* Create Slot =============================================================*/
1554

1555
DEF_STD_CMD_AU(CmdSketcherCreateSlot)
1556

1557
CmdSketcherCreateSlot::CmdSketcherCreateSlot()
1558
    : Command("Sketcher_CreateSlot")
1559
{
1560
    sAppModule = "Sketcher";
1561
    sGroup = "Sketcher";
1562
    sMenuText = QT_TR_NOOP("Create slot");
1563
    sToolTipText = QT_TR_NOOP("Create a slot in the sketch");
1564
    sWhatsThis = "Sketcher_CreateSlot";
1565
    sStatusTip = sToolTipText;
1566
    sPixmap = "Sketcher_CreateSlot";
1567
    sAccel = "G, S";
1568
    eType = ForEdit;
1569
}
1570

1571
CONSTRUCTION_UPDATE_ACTION(CmdSketcherCreateSlot, "Sketcher_CreateSlot")
1572

1573
void CmdSketcherCreateSlot::activated(int iMsg)
1574
{
1575
    Q_UNUSED(iMsg);
1576
    ActivateHandler(getActiveGuiDocument(), std::make_unique<DrawSketchHandlerSlot>());
1577
}
1578

1579
bool CmdSketcherCreateSlot::isActive()
1580
{
1581
    return isCommandActive(getActiveGuiDocument());
1582
}
1583

1584
/* Create Arc Slot =========================================================*/
1585

1586
DEF_STD_CMD_AU(CmdSketcherCreateArcSlot)
1587

1588
CmdSketcherCreateArcSlot::CmdSketcherCreateArcSlot()
1589
    : Command("Sketcher_CreateArcSlot")
1590
{
1591
    sAppModule = "Sketcher";
1592
    sGroup = "Sketcher";
1593
    sMenuText = QT_TR_NOOP("Create arc slot");
1594
    sToolTipText = QT_TR_NOOP("Create an arc slot in the sketch");
1595
    sWhatsThis = "Sketcher_CreateArcSlot";
1596
    sStatusTip = sToolTipText;
1597
    sPixmap = "Sketcher_CreateArcSlot";
1598
    sAccel = "G, S, 2";
1599
    eType = ForEdit;
1600
}
1601

1602
CONSTRUCTION_UPDATE_ACTION(CmdSketcherCreateArcSlot, "Sketcher_CreateArcSlot")
1603

1604
void CmdSketcherCreateArcSlot::activated(int iMsg)
1605
{
1606
    Q_UNUSED(iMsg);
1607
    ActivateHandler(getActiveGuiDocument(), std::make_unique<DrawSketchHandlerArcSlot>());
1608
}
1609

1610
bool CmdSketcherCreateArcSlot::isActive(void)
1611
{
1612
    return isCommandActive(getActiveGuiDocument());
1613
}
1614

1615
/* Create Regular Polygon ==============================================*/
1616

1617
DEF_STD_CMD_AU(CmdSketcherCreateTriangle)
1618

1619
CmdSketcherCreateTriangle::CmdSketcherCreateTriangle()
1620
    : Command("Sketcher_CreateTriangle")
1621
{
1622
    sAppModule = "Sketcher";
1623
    sGroup = "Sketcher";
1624
    sMenuText = QT_TR_NOOP("Create equilateral triangle");
1625
    sToolTipText = QT_TR_NOOP("Create an equilateral triangle in the sketch");
1626
    sWhatsThis = "Sketcher_CreateTriangle";
1627
    sStatusTip = sToolTipText;
1628
    sPixmap = "Sketcher_CreateTriangle";
1629
    sAccel = "G, P, 3";
1630
    eType = ForEdit;
1631
}
1632

1633
CONSTRUCTION_UPDATE_ACTION(CmdSketcherCreateTriangle, "Sketcher_CreateTriangle")
1634

1635
void CmdSketcherCreateTriangle::activated(int iMsg)
1636
{
1637
    Q_UNUSED(iMsg);
1638
    ActivateHandler(getActiveGuiDocument(), std::make_unique<DrawSketchHandlerPolygon>(3));
1639
}
1640

1641
bool CmdSketcherCreateTriangle::isActive()
1642
{
1643
    return isCommandActive(getActiveGuiDocument());
1644
}
1645

1646
DEF_STD_CMD_AU(CmdSketcherCreateSquare)
1647

1648
CmdSketcherCreateSquare::CmdSketcherCreateSquare()
1649
    : Command("Sketcher_CreateSquare")
1650
{
1651
    sAppModule = "Sketcher";
1652
    sGroup = "Sketcher";
1653
    sMenuText = QT_TR_NOOP("Create square");
1654
    sToolTipText = QT_TR_NOOP("Create a square in the sketch");
1655
    sWhatsThis = "Sketcher_CreateSquare";
1656
    sStatusTip = sToolTipText;
1657
    sPixmap = "Sketcher_CreateSquare";
1658
    sAccel = "G, P, 4";
1659
    eType = ForEdit;
1660
}
1661

1662
CONSTRUCTION_UPDATE_ACTION(CmdSketcherCreateSquare, "Sketcher_CreateSquare")
1663

1664
void CmdSketcherCreateSquare::activated(int iMsg)
1665
{
1666
    Q_UNUSED(iMsg);
1667
    ActivateHandler(getActiveGuiDocument(), std::make_unique<DrawSketchHandlerPolygon>(4));
1668
}
1669

1670
bool CmdSketcherCreateSquare::isActive()
1671
{
1672
    return isCommandActive(getActiveGuiDocument());
1673
}
1674

1675
DEF_STD_CMD_AU(CmdSketcherCreatePentagon)
1676

1677
CmdSketcherCreatePentagon::CmdSketcherCreatePentagon()
1678
    : Command("Sketcher_CreatePentagon")
1679
{
1680
    sAppModule = "Sketcher";
1681
    sGroup = "Sketcher";
1682
    sMenuText = QT_TR_NOOP("Create pentagon");
1683
    sToolTipText = QT_TR_NOOP("Create a pentagon in the sketch");
1684
    sWhatsThis = "Sketcher_CreatePentagon";
1685
    sStatusTip = sToolTipText;
1686
    sPixmap = "Sketcher_CreatePentagon";
1687
    sAccel = "G, P, 5";
1688
    eType = ForEdit;
1689
}
1690

1691
CONSTRUCTION_UPDATE_ACTION(CmdSketcherCreatePentagon, "Sketcher_CreatePentagon")
1692

1693
void CmdSketcherCreatePentagon::activated(int iMsg)
1694
{
1695
    Q_UNUSED(iMsg);
1696
    ActivateHandler(getActiveGuiDocument(), std::make_unique<DrawSketchHandlerPolygon>(5));
1697
}
1698

1699
bool CmdSketcherCreatePentagon::isActive()
1700
{
1701
    return isCommandActive(getActiveGuiDocument());
1702
}
1703

1704

1705
DEF_STD_CMD_AU(CmdSketcherCreateHexagon)
1706

1707
CmdSketcherCreateHexagon::CmdSketcherCreateHexagon()
1708
    : Command("Sketcher_CreateHexagon")
1709
{
1710
    sAppModule = "Sketcher";
1711
    sGroup = "Sketcher";
1712
    sMenuText = QT_TR_NOOP("Create hexagon");
1713
    sToolTipText = QT_TR_NOOP("Create a hexagon in the sketch");
1714
    sWhatsThis = "Sketcher_CreateHexagon";
1715
    sStatusTip = sToolTipText;
1716
    sPixmap = "Sketcher_CreateHexagon";
1717
    sAccel = "G, P, 6";
1718
    eType = ForEdit;
1719
}
1720

1721
CONSTRUCTION_UPDATE_ACTION(CmdSketcherCreateHexagon, "Sketcher_CreateHexagon")
1722

1723
void CmdSketcherCreateHexagon::activated(int iMsg)
1724
{
1725
    Q_UNUSED(iMsg);
1726
    ActivateHandler(getActiveGuiDocument(), std::make_unique<DrawSketchHandlerPolygon>(6));
1727
}
1728

1729
bool CmdSketcherCreateHexagon::isActive()
1730
{
1731
    return isCommandActive(getActiveGuiDocument());
1732
}
1733

1734
DEF_STD_CMD_AU(CmdSketcherCreateHeptagon)
1735

1736
CmdSketcherCreateHeptagon::CmdSketcherCreateHeptagon()
1737
    : Command("Sketcher_CreateHeptagon")
1738
{
1739
    sAppModule = "Sketcher";
1740
    sGroup = "Sketcher";
1741
    sMenuText = QT_TR_NOOP("Create heptagon");
1742
    sToolTipText = QT_TR_NOOP("Create a heptagon in the sketch");
1743
    sWhatsThis = "Sketcher_CreateHeptagon";
1744
    sStatusTip = sToolTipText;
1745
    sPixmap = "Sketcher_CreateHeptagon";
1746
    sAccel = "G, P, 7";
1747
    eType = ForEdit;
1748
}
1749

1750
CONSTRUCTION_UPDATE_ACTION(CmdSketcherCreateHeptagon, "Sketcher_CreateHeptagon")
1751

1752
void CmdSketcherCreateHeptagon::activated(int iMsg)
1753
{
1754
    Q_UNUSED(iMsg);
1755
    ActivateHandler(getActiveGuiDocument(), std::make_unique<DrawSketchHandlerPolygon>(7));
1756
}
1757

1758
bool CmdSketcherCreateHeptagon::isActive()
1759
{
1760
    return isCommandActive(getActiveGuiDocument());
1761
}
1762

1763
DEF_STD_CMD_AU(CmdSketcherCreateOctagon)
1764

1765
CmdSketcherCreateOctagon::CmdSketcherCreateOctagon()
1766
    : Command("Sketcher_CreateOctagon")
1767
{
1768
    sAppModule = "Sketcher";
1769
    sGroup = "Sketcher";
1770
    sMenuText = QT_TR_NOOP("Create octagon");
1771
    sToolTipText = QT_TR_NOOP("Create an octagon in the sketch");
1772
    sWhatsThis = "Sketcher_CreateOctagon";
1773
    sStatusTip = sToolTipText;
1774
    sPixmap = "Sketcher_CreateOctagon";
1775
    sAccel = "G, P, 8";
1776
    eType = ForEdit;
1777
}
1778

1779
CONSTRUCTION_UPDATE_ACTION(CmdSketcherCreateOctagon, "Sketcher_CreateOctagon")
1780

1781
void CmdSketcherCreateOctagon::activated(int iMsg)
1782
{
1783
    Q_UNUSED(iMsg);
1784
    ActivateHandler(getActiveGuiDocument(), std::make_unique<DrawSketchHandlerPolygon>(8));
1785
}
1786

1787
bool CmdSketcherCreateOctagon::isActive()
1788
{
1789
    return isCommandActive(getActiveGuiDocument());
1790
}
1791

1792
DEF_STD_CMD_AU(CmdSketcherCreateRegularPolygon)
1793

1794
CmdSketcherCreateRegularPolygon::CmdSketcherCreateRegularPolygon()
1795
    : Command("Sketcher_CreateRegularPolygon")
1796
{
1797
    sAppModule = "Sketcher";
1798
    sGroup = "Sketcher";
1799
    sMenuText = QT_TR_NOOP("Create regular polygon");
1800
    sToolTipText = QT_TR_NOOP("Create a regular polygon in the sketch");
1801
    sWhatsThis = "Sketcher_CreateRegularPolygon";
1802
    sStatusTip = sToolTipText;
1803
    sPixmap = "Sketcher_CreateRegularPolygon";
1804
    sAccel = "G, P, R";
1805
    eType = ForEdit;
1806
}
1807

1808
CONSTRUCTION_UPDATE_ACTION(CmdSketcherCreateRegularPolygon, "Sketcher_CreateRegularPolygon")
1809

1810
void CmdSketcherCreateRegularPolygon::activated(int iMsg)
1811
{
1812
    Q_UNUSED(iMsg);
1813

1814
    // Pop-up asking for values
1815
    SketcherRegularPolygonDialog srpd;
1816
    if (srpd.exec() == QDialog::Accepted) {
1817
        ActivateHandler(getActiveGuiDocument(),
1818
                        std::make_unique<DrawSketchHandlerPolygon>(srpd.sides));
1819
    }
1820
}
1821

1822
bool CmdSketcherCreateRegularPolygon::isActive()
1823
{
1824
    return isCommandActive(getActiveGuiDocument());
1825
}
1826

1827
DEF_STD_CMD_ACLU(CmdSketcherCompCreateRegularPolygon)
1828

1829
CmdSketcherCompCreateRegularPolygon::CmdSketcherCompCreateRegularPolygon()
1830
    : Command("Sketcher_CompCreateRegularPolygon")
1831
{
1832
    sAppModule = "Sketcher";
1833
    sGroup = "Sketcher";
1834
    sMenuText = QT_TR_NOOP("Create regular polygon");
1835
    sToolTipText = QT_TR_NOOP("Create a regular polygon in the sketcher");
1836
    sWhatsThis = "Sketcher_CompCreateRegularPolygon";
1837
    sStatusTip = sToolTipText;
1838
    sAccel = "G, P, P";
1839
    eType = ForEdit;
1840
}
1841

1842
void CmdSketcherCompCreateRegularPolygon::activated(int iMsg)
1843
{
1844
    switch (iMsg) {
1845
        case 0:
1846
            ActivateHandler(getActiveGuiDocument(), std::make_unique<DrawSketchHandlerPolygon>(3));
1847
            break;
1848
        case 1:
1849
            ActivateHandler(getActiveGuiDocument(), std::make_unique<DrawSketchHandlerPolygon>(4));
1850
            break;
1851
        case 2:
1852
            ActivateHandler(getActiveGuiDocument(), std::make_unique<DrawSketchHandlerPolygon>(5));
1853
            break;
1854
        case 3:
1855
            ActivateHandler(getActiveGuiDocument(), std::make_unique<DrawSketchHandlerPolygon>(6));
1856
            break;
1857
        case 4:
1858
            ActivateHandler(getActiveGuiDocument(), std::make_unique<DrawSketchHandlerPolygon>(7));
1859
            break;
1860
        case 5:
1861
            ActivateHandler(getActiveGuiDocument(), std::make_unique<DrawSketchHandlerPolygon>(8));
1862
            break;
1863
        case 6: {
1864
            // Pop-up asking for values
1865
            SketcherRegularPolygonDialog srpd;
1866
            if (srpd.exec() == QDialog::Accepted) {
1867
                ActivateHandler(getActiveGuiDocument(),
1868
                                std::make_unique<DrawSketchHandlerPolygon>(srpd.sides));
1869
            }
1870
        } break;
1871
        default:
1872
            return;
1873
    }
1874

1875
    // Since the default icon is reset when enabling/disabling the command we have
1876
    // to explicitly set the icon of the used command.
1877
    Gui::ActionGroup* pcAction = qobject_cast<Gui::ActionGroup*>(_pcAction);
1878
    QList<QAction*> a = pcAction->actions();
1879

1880
    assert(iMsg < a.size());
1881
    pcAction->setIcon(a[iMsg]->icon());
1882
}
1883

1884
Gui::Action* CmdSketcherCompCreateRegularPolygon::createAction()
1885
{
1886
    Gui::ActionGroup* pcAction = new Gui::ActionGroup(this, Gui::getMainWindow());
1887
    pcAction->setDropDownMenu(true);
1888
    applyCommandData(this->className(), pcAction);
1889

1890
    QAction* triangle = pcAction->addAction(QString());
1891
    triangle->setIcon(Gui::BitmapFactory().iconFromTheme("Sketcher_CreateTriangle"));
1892
    QAction* square = pcAction->addAction(QString());
1893
    square->setIcon(Gui::BitmapFactory().iconFromTheme("Sketcher_CreateSquare"));
1894
    QAction* pentagon = pcAction->addAction(QString());
1895
    pentagon->setIcon(Gui::BitmapFactory().iconFromTheme("Sketcher_CreatePentagon"));
1896
    QAction* hexagon = pcAction->addAction(QString());
1897
    hexagon->setIcon(Gui::BitmapFactory().iconFromTheme("Sketcher_CreateHexagon"));
1898
    QAction* heptagon = pcAction->addAction(QString());
1899
    heptagon->setIcon(Gui::BitmapFactory().iconFromTheme("Sketcher_CreateHeptagon"));
1900
    QAction* octagon = pcAction->addAction(QString());
1901
    octagon->setIcon(Gui::BitmapFactory().iconFromTheme("Sketcher_CreateOctagon"));
1902
    QAction* regular = pcAction->addAction(QString());
1903
    regular->setIcon(Gui::BitmapFactory().iconFromTheme("Sketcher_CreateRegularPolygon"));
1904

1905
    _pcAction = pcAction;
1906
    languageChange();
1907

1908
    pcAction->setIcon(hexagon->icon());
1909
    int defaultId = 3;
1910
    pcAction->setProperty("defaultAction", QVariant(defaultId));
1911

1912
    return pcAction;
1913
}
1914

1915
void CmdSketcherCompCreateRegularPolygon::updateAction(int mode)
1916
{
1917
    Gui::ActionGroup* pcAction = qobject_cast<Gui::ActionGroup*>(getAction());
1918
    if (!pcAction) {
1919
        return;
1920
    }
1921

1922
    QList<QAction*> a = pcAction->actions();
1923
    int index = pcAction->property("defaultAction").toInt();
1924
    switch (static_cast<GeometryCreationMode>(mode)) {
1925
        case GeometryCreationMode::Normal:
1926
            a[0]->setIcon(Gui::BitmapFactory().iconFromTheme("Sketcher_CreateTriangle"));
1927
            a[1]->setIcon(Gui::BitmapFactory().iconFromTheme("Sketcher_CreateSquare"));
1928
            a[2]->setIcon(Gui::BitmapFactory().iconFromTheme("Sketcher_CreatePentagon"));
1929
            a[3]->setIcon(Gui::BitmapFactory().iconFromTheme("Sketcher_CreateHexagon"));
1930
            a[4]->setIcon(Gui::BitmapFactory().iconFromTheme("Sketcher_CreateHeptagon"));
1931
            a[5]->setIcon(Gui::BitmapFactory().iconFromTheme("Sketcher_CreateOctagon"));
1932
            a[6]->setIcon(Gui::BitmapFactory().iconFromTheme("Sketcher_CreateRegularPolygon"));
1933
            getAction()->setIcon(a[index]->icon());
1934
            break;
1935
        case GeometryCreationMode::Construction:
1936
            a[0]->setIcon(Gui::BitmapFactory().iconFromTheme("Sketcher_CreateTriangle_Constr"));
1937
            a[1]->setIcon(Gui::BitmapFactory().iconFromTheme("Sketcher_CreateSquare_Constr"));
1938
            a[2]->setIcon(Gui::BitmapFactory().iconFromTheme("Sketcher_CreatePentagon_Constr"));
1939
            a[3]->setIcon(Gui::BitmapFactory().iconFromTheme("Sketcher_CreateHexagon_Constr"));
1940
            a[4]->setIcon(Gui::BitmapFactory().iconFromTheme("Sketcher_CreateHeptagon_Constr"));
1941
            a[5]->setIcon(Gui::BitmapFactory().iconFromTheme("Sketcher_CreateOctagon_Constr"));
1942
            a[6]->setIcon(
1943
                Gui::BitmapFactory().iconFromTheme("Sketcher_CreateRegularPolygon_Constr"));
1944
            getAction()->setIcon(a[index]->icon());
1945
            break;
1946
    }
1947
}
1948

1949
void CmdSketcherCompCreateRegularPolygon::languageChange()
1950
{
1951
    Command::languageChange();
1952

1953
    if (!_pcAction) {
1954
        return;
1955
    }
1956
    Gui::ActionGroup* pcAction = qobject_cast<Gui::ActionGroup*>(_pcAction);
1957
    QList<QAction*> a = pcAction->actions();
1958

1959
    QAction* triangle = a[0];
1960
    triangle->setText(QApplication::translate("CmdSketcherCompCreateRegularPolygon", "Triangle"));
1961
    triangle->setToolTip(
1962
        QApplication::translate("Sketcher_CreateTriangle",
1963
                                "Create an equilateral triangle by its center and by one corner"));
1964
    triangle->setStatusTip(
1965
        QApplication::translate("Sketcher_CreateTriangle",
1966
                                "Create an equilateral triangle by its center and by one corner"));
1967
    QAction* square = a[1];
1968
    square->setText(QApplication::translate("CmdSketcherCompCreateRegularPolygon", "Square"));
1969
    square->setToolTip(QApplication::translate("Sketcher_CreateSquare",
1970
                                               "Create a square by its center and by one corner"));
1971
    square->setStatusTip(
1972
        QApplication::translate("Sketcher_CreateSquare",
1973
                                "Create a square by its center and by one corner"));
1974
    QAction* pentagon = a[2];
1975
    pentagon->setText(QApplication::translate("CmdSketcherCompCreateRegularPolygon", "Pentagon"));
1976
    pentagon->setToolTip(
1977
        QApplication::translate("Sketcher_CreatePentagon",
1978
                                "Create a pentagon by its center and by one corner"));
1979
    pentagon->setStatusTip(
1980
        QApplication::translate("Sketcher_CreatePentagon",
1981
                                "Create a pentagon by its center and by one corner"));
1982
    QAction* hexagon = a[3];
1983
    hexagon->setText(QApplication::translate("CmdSketcherCompCreateRegularPolygon", "Hexagon"));
1984
    hexagon->setToolTip(
1985
        QApplication::translate("Sketcher_CreateHexagon",
1986
                                "Create a hexagon by its center and by one corner"));
1987
    hexagon->setStatusTip(
1988
        QApplication::translate("Sketcher_CreateHexagon",
1989
                                "Create a hexagon by its center and by one corner"));
1990
    QAction* heptagon = a[4];
1991
    heptagon->setText(QApplication::translate("CmdSketcherCompCreateRegularPolygon", "Heptagon"));
1992
    heptagon->setToolTip(
1993
        QApplication::translate("Sketcher_CreateHeptagon",
1994
                                "Create a heptagon by its center and by one corner"));
1995
    heptagon->setStatusTip(
1996
        QApplication::translate("Sketcher_CreateHeptagon",
1997
                                "Create a heptagon by its center and by one corner"));
1998
    QAction* octagon = a[5];
1999
    octagon->setText(QApplication::translate("CmdSketcherCompCreateRegularPolygon", "Octagon"));
2000
    octagon->setToolTip(
2001
        QApplication::translate("Sketcher_CreateOctagon",
2002
                                "Create an octagon by its center and by one corner"));
2003
    octagon->setStatusTip(
2004
        QApplication::translate("Sketcher_CreateOctagon",
2005
                                "Create an octagon by its center and by one corner"));
2006
    QAction* regular = a[6];
2007
    regular->setText(
2008
        QApplication::translate("CmdSketcherCompCreateRegularPolygon", "Regular polygon"));
2009
    regular->setToolTip(
2010
        QApplication::translate("Sketcher_CreateOctagon",
2011
                                "Create a regular polygon by its center and by one corner"));
2012
    regular->setStatusTip(
2013
        QApplication::translate("Sketcher_CreateOctagon",
2014
                                "Create a regular polygon by its center and by one corner"));
2015
}
2016

2017
bool CmdSketcherCompCreateRegularPolygon::isActive()
2018
{
2019
    return isCommandActive(getActiveGuiDocument());
2020
}
2021

2022
void CreateSketcherCommandsCreateGeo()
2023
{
2024
    Gui::CommandManager& rcCmdMgr = Gui::Application::Instance->commandManager();
2025

2026
    rcCmdMgr.addCommand(new CmdSketcherCreatePoint());
2027
    rcCmdMgr.addCommand(new CmdSketcherCreateArc());
2028
    rcCmdMgr.addCommand(new CmdSketcherCreate3PointArc());
2029
    rcCmdMgr.addCommand(new CmdSketcherCreateCircle());
2030
    rcCmdMgr.addCommand(new CmdSketcherCreate3PointCircle());
2031
    rcCmdMgr.addCommand(new CmdSketcherCreateEllipseByCenter());
2032
    rcCmdMgr.addCommand(new CmdSketcherCreateEllipseBy3Points());
2033
    rcCmdMgr.addCommand(new CmdSketcherCompCreateConic());
2034
    rcCmdMgr.addCommand(new CmdSketcherCreateArcOfEllipse());
2035
    rcCmdMgr.addCommand(new CmdSketcherCreateArcOfHyperbola());
2036
    rcCmdMgr.addCommand(new CmdSketcherCreateArcOfParabola());
2037
    rcCmdMgr.addCommand(new CmdSketcherCompCreateArc());
2038
    rcCmdMgr.addCommand(new CmdSketcherCreateBSpline());
2039
    rcCmdMgr.addCommand(new CmdSketcherCreatePeriodicBSpline());
2040
    rcCmdMgr.addCommand(new CmdSketcherCreateBSplineByInterpolation());
2041
    rcCmdMgr.addCommand(new CmdSketcherCreatePeriodicBSplineByInterpolation());
2042
    rcCmdMgr.addCommand(new CmdSketcherCompCreateBSpline());
2043
    rcCmdMgr.addCommand(new CmdSketcherCreateLine());
2044
    rcCmdMgr.addCommand(new CmdSketcherCreatePolyline());
2045
    rcCmdMgr.addCommand(new CmdSketcherCreateRectangle());
2046
    rcCmdMgr.addCommand(new CmdSketcherCreateRectangleCenter());
2047
    rcCmdMgr.addCommand(new CmdSketcherCreateOblong());
2048
    rcCmdMgr.addCommand(new CmdSketcherCompCreateRegularPolygon());
2049
    rcCmdMgr.addCommand(new CmdSketcherCreateTriangle());
2050
    rcCmdMgr.addCommand(new CmdSketcherCreateSquare());
2051
    rcCmdMgr.addCommand(new CmdSketcherCreatePentagon());
2052
    rcCmdMgr.addCommand(new CmdSketcherCreateHexagon());
2053
    rcCmdMgr.addCommand(new CmdSketcherCreateHeptagon());
2054
    rcCmdMgr.addCommand(new CmdSketcherCreateOctagon());
2055
    rcCmdMgr.addCommand(new CmdSketcherCreateRegularPolygon());
2056
    rcCmdMgr.addCommand(new CmdSketcherCompCreateRectangles());
2057
    rcCmdMgr.addCommand(new CmdSketcherCreateSlot());
2058
    rcCmdMgr.addCommand(new CmdSketcherCreateArcSlot());
2059
    rcCmdMgr.addCommand(new CmdSketcherCompSlot());
2060
    rcCmdMgr.addCommand(new CmdSketcherCreateFillet());
2061
    rcCmdMgr.addCommand(new CmdSketcherCreateChamfer());
2062
    rcCmdMgr.addCommand(new CmdSketcherCompCreateFillets());
2063
    // rcCmdMgr.addCommand(new CmdSketcherCreateText());
2064
    // rcCmdMgr.addCommand(new CmdSketcherCreateDraftLine());
2065
    rcCmdMgr.addCommand(new CmdSketcherTrimming());
2066
    rcCmdMgr.addCommand(new CmdSketcherExtend());
2067
    rcCmdMgr.addCommand(new CmdSketcherSplit());
2068
    rcCmdMgr.addCommand(new CmdSketcherCompCurveEdition());
2069
    rcCmdMgr.addCommand(new CmdSketcherExternal());
2070
    rcCmdMgr.addCommand(new CmdSketcherCarbonCopy());
2071
    rcCmdMgr.addCommand(new CmdSketcherCompLine());
2072
}
2073