Important: Please read the Qt Code of Conduct - https://forum.qt.io/topic/113070/qt-code-of-conduct

Send action Codes to PushButton



  • Hello,
    I have a class with scene name
    and this class have codes that draw lines in a GraphicView
    this class is wrote for mainwindow that Use toolBar for
    Drawing
    but i want to
    So change the code that draw lines when i click pushButton
    not toolBar.
    Can any body change codes for me?
    MainWindow.h:

    #ifndef MAINWINDOW_H
    #define MAINWINDOW_H
    
    #include <QMainWindow>
    #include <QGraphicsView>
    #include <QToolBar>
    #include "scene.h"
    #include <QAction>
    
    
    namespace Ui {
    class MainWindow;
    }
    
    class MainWindow : public QMainWindow
    {
        Q_OBJECT
    
    public:
        explicit MainWindow(QWidget *parent = 0);
        ~MainWindow();
    public slots:
        void actionGroupClicked(QAction*);
    private:
        Ui::MainWindow *ui;
        QGraphicsView* view;
        Scene* scene;
    
        void createActions();
        void createConnections();
        void createToolBar();
    
        QAction* lineAction;
        QAction* selectAction;
        QActionGroup *actionGroup;
        QToolBar* drawingToolBar;
    };
    
    #endif // MAINWINDOW_H
    

    mainWindow.cpp:

    #include "mainwindow.h"
    #include "ui_mainwindow.h"
    
    
    MainWindow::MainWindow(QWidget *parent) :
        QMainWindow(parent),
        ui(new Ui::MainWindow)
    {
        ui->setupUi(this);
        scene = new Scene(this);
        scene->setSceneRect(0,0,200,200);
        ui->graphicsView->setScene(scene);
        ui->graphicsView->setRenderHints(QPainter::Antialiasing);
        //setCentralWidget(ui->graphicsView);
    
        createActions();
        createConnections();
        createToolBar();
    
    }
    
    MainWindow::~MainWindow()
    {
        delete ui;
    }
    void MainWindow::createActions(){
        lineAction = new QAction("Draw line", this);
        lineAction->setData(int(Scene::DrawLine));
        lineAction->setIcon(QIcon(":/icons/line.png"));
        lineAction->setCheckable(true);
    
        selectAction = new QAction("Select object", this);
        selectAction->setData(int(Scene::SelectObject));
        selectAction->setIcon(QIcon(":/icons/select.png"));
        selectAction->setCheckable(true);
    
        actionGroup = new QActionGroup(this);
        actionGroup->setExclusive(true);
        actionGroup->addAction(lineAction);
        actionGroup->addAction(selectAction);
    }
    
    void MainWindow::createConnections(){
        connect(actionGroup, SIGNAL(triggered(QAction*)),
                this, SLOT(actionGroupClicked(QAction*)));
    }
    
    void MainWindow::actionGroupClicked(QAction *action){
        scene->setMode(Scene::Mode(action->data().toInt()));
    }
    
    void MainWindow::createToolBar(){
        drawingToolBar = new QToolBar;
        addToolBar(Qt::TopToolBarArea, drawingToolBar);
        drawingToolBar->addAction(selectAction);
        drawingToolBar->addAction(lineAction);
    }
    

    scene.h:

    #ifndef SCENE_H
    #define SCENE_H
    
    #include <QGraphicsScene>
    #include <QGraphicsSceneMouseEvent>
    #include <QGraphicsLineItem>
    #include <QAction>
    #include <QGraphicsView>
    #include <QKeyEvent>
    
    class Scene : public QGraphicsScene
    {
    public:
        scene();
        enum Mode {NoMode, SelectObject, DrawLine};
        Scene(QObject* parent = 0);
        void setMode(Mode mode);
    protected:
        void mousePressEvent(QGraphicsSceneMouseEvent *event);
        void mouseMoveEvent(QGraphicsSceneMouseEvent *event);
        void mouseReleaseEvent(QGraphicsSceneMouseEvent *event);
        void keyPressEvent(QKeyEvent *event);
    private:
        Mode sceneMode;
        QPointF origPoint;
        QGraphicsLineItem* itemToDraw;
        void makeItemsControllable(bool areControllable);
    };
    
    #endif // SCENE_H
    
    

    scene.cpp:

    #include "scene.h"
    
    Scene::Scene(QObject* parent): QGraphicsScene(parent)
    {
        sceneMode = NoMode;
        itemToDraw = 0;
    }
    
    void Scene::setMode(Mode mode){
        sceneMode = mode;
        QGraphicsView::DragMode vMode =
                QGraphicsView::NoDrag;
        if(mode == DrawLine){
            makeItemsControllable(false);
            vMode = QGraphicsView::NoDrag;
        }
        else if(mode == SelectObject){
            makeItemsControllable(true);
            vMode = QGraphicsView::RubberBandDrag;
        }
        QGraphicsView* mView = views().at(0);
        if(mView)
            mView->setDragMode(vMode);
    }
    
    void Scene::makeItemsControllable(bool areControllable){
        foreach(QGraphicsItem* item, items()){
            item->setFlag(QGraphicsItem::ItemIsSelectable,
                          areControllable);
            item->setFlag(QGraphicsItem::ItemIsMovable,
                          areControllable);
        }
    }
    
    void Scene::mousePressEvent(QGraphicsSceneMouseEvent *event){
        if(sceneMode == DrawLine)
            origPoint = event->scenePos();
        QGraphicsScene::mousePressEvent(event);
    }
    
    void Scene::mouseMoveEvent(QGraphicsSceneMouseEvent *event){
        if(sceneMode == DrawLine){
            if(!itemToDraw){
                itemToDraw = new QGraphicsLineItem;
                this->addItem(itemToDraw);
                itemToDraw->setPen(QPen(Qt::black, 3, Qt::SolidLine));
                itemToDraw->setPos(origPoint);
            }
            itemToDraw->setLine(0,0,
                                event->scenePos().x() - origPoint.x(),
                                event->scenePos().y() - origPoint.y());
        }
        else
            QGraphicsScene::mouseMoveEvent(event);
    }
    
    void Scene::mouseReleaseEvent(QGraphicsSceneMouseEvent *event){
        itemToDraw = 0;
        QGraphicsScene::mouseReleaseEvent(event);
    }
    
    void Scene::keyPressEvent(QKeyEvent *event){
        if(event->key() == Qt::Key_Delete)
            foreach(QGraphicsItem* item, selectedItems()){
                removeItem(item);
                delete item;
            }
        else
            QGraphicsScene::keyPressEvent(event);
    }
    
    


  • You could subclass the Button and then add an enum to define what to draw an make a variable of it, in the drawing function, do a switch case statement for every draw type on that one variable.



  • @Maxim-DC
    i dont know what are you saying
    Exactly
    can you edit code please?



  • This post is deleted!


  • @Maxim-DC
    i have a graphicView and i want to draw line on it and erase lines
    what i must do?
    can you write a example for me?
    thanks:)



  • @M4RZB4Ni

    I think this will work, but i haven't tested it yet

    // view.h
    ...
    class View: public QGraphicsView
    {
    public:
        View();
        enum DrawType { Draw, Erase };
        void paintEvent(QPaintEvent *) override;
        
        View::DrawType type;
    
    public slots:
        void toggleType();
    private:
        QPushButton button;
        QPainter painter;
    };
    
    // view.cpp
    #include <view.h>
    
    View::View()
    {
        type = View::Draw;
    
        QObject::connect(&button, SIGNAL(clicked(bool)), this, SLOT(toggleType()));
    }
    
    void View::paintEvent(QPaintEvent *) 
    {
        painter.restore()
        switch (type)
        {
            case: View::Draw: painter.drawPoint(10, 10);
            case: View::Erase: painter.eraseRect(10, 10, 100, 100)
        }
        painter.save();
    }
    
    void View::toggleType()
    {
        switch (type)
        {
            case: View::Draw: type = View::Erase
            case: View::Erase: type = View::Draw
        }
    }
    


  • @Maxim-DC
    code showed a error !
    error: 'void Scene::paintEvent(QPaintEvent*)' marked override, but does not override
    void paintEvent(QPaintEvent *) override;
    ^


  • Lifetime Qt Champion

    Hi,

    Why not use QGraphicsLineItem ?



  • @SGaist
    Hi,
    Because id dont know how i must use it!
    for my graphicView!
    i want to draw line with mouse!


  • Lifetime Qt Champion

    You could use a QRubberBand to setup the line and once you release it add the QGraphicsLineItem to your scene.