Passing an argument to a slot

Question

I want to override mouseReleaseEvent with a bunch of QActions and QMenus...

connect(action1, SIGNAL(triggered()), this, SLOT(onStepIncreased()));

connect(action5, SIGNAL(triggered()), this, SLOT(onStepIncreased()));

connect(action10, SIGNAL(triggered()), this, SLOT(onStepIncreased()));

connect(action25, SIGNAL(triggered()), this, SLOT(onStepIncreased()));

connect(action50, SIGNAL(triggered()), this, SLOT(onStepIncreased()));

So I want to pass an argument to the slot onStepIncreased (as you can imagine they are 1,5,10,25,50). Do you know how I can do it?

Solution 1

Use QSignalMapper. Like this:

QSignalMapper* signalMapper = new QSignalMapper (this) ;
connect (action1, SIGNAL(triggered()), signalMapper, SLOT(map())) ;
connect (action5, SIGNAL(triggered()), signalMapper, SLOT(map())) ;
connect (action10, SIGNAL(triggered()), signalMapper, SLOT(map())) ;
connect (action25, SIGNAL(triggered()), signalMapper, SLOT(map())) ;
connect (action50, SIGNAL(triggered()), signalMapper, SLOT(map())) ;

signalMapper -> setMapping (action1, 1) ;
signalMapper -> setMapping (action5, 5) ;
signalMapper -> setMapping (action10, 10) ;
signalMapper -> setMapping (action25, 25) ;
signalMapper -> setMapping (action50, 50) ;

connect (signalMapper, SIGNAL(mapped(int)), this, SLOT(onStepIncreased(int))) ;

Solution 2

With Qt 5 and a C++11 compiler, the idiomatic way to do such things is to give a functor to connect:

connect(action1,  &QAction::triggered, this, [this]{ onStepIncreased(1); });
connect(action5,  &QAction::triggered, this, [this]{ onStepIncreased(5); });
connect(action10, &QAction::triggered, this, [this]{ onStepIncreased(10); });
connect(action25, &QAction::triggered, this, [this]{ onStepIncreased(25); });
connect(action50, &QAction::triggered, this, [this]{ onStepIncreased(50); });

The third argument to connect is nominally optional. It is used to set up the thread context in which the functor will execute. It is always necessary when the functor uses a QObject instance. If the functor uses multiple QObject instances, they should have some common parent that manages their lifetime and the functor should refer to that parent, or it should be ensured that the objects will outlive the functor.

On Windows, this works in MSVC2012 & newer.

Solution 3

The QObject::sender() function returns a pointer to the object that has signaled to the slot. You could use this to find out which action was triggered

Solution 4

Maybe you can subclass QAction with an m_increase member variable.
Connect the triggered() signal to a slot on your new QAction subclass and emit a new signal (e.g. triggered(int number)) with the correct parameter.
e.g.

class MyAction:public QAction  
{  
public:  
    MyAction(int increase, ...)  
        :QAction(...), m_increase(increase)
    {  
        connect(this, SIGNAL(triggered()), this, SLOT(onTriggered()));  
    }  
protected Q_SLOTS:  
    void onTriggered()  
    {  
        emit triggered(m_increase);  
    }  

Q_SIGNALS:
    void triggered(int increase);   

private:  
    int m_increase;  
};

View more solutions

Comments

[Pavel Radzivilovsky]

Instead of passing parameters, consider analyzing sender() inside the signal.

[Septagram]

I beg your pardon? The slot is a member of a subclass of QObject, thus it has also a QObject::sender() member. Just call sender(), and you will be given a QObject* pointing to your action. After that you can use objectName() or property() of an acquired action to collect more information. You can also convert it to an action object if you really want to, but I wouldn't recommend that.

[Kamil Klimek]

I still remember times, when Qt didn't have QSignalMapper, and the only solution was setting property on objects connected to same slot and using sender()->property(...)

[Piotr Dobrogost]

@Kamil Klimek You didn't have to; you could have written your own mapper :)

[dhein]

How to use this if my context parameter targets a to a class which has no acess to the actions? so eitherway, the context signalmapper wouldn't have access to the actions, or if I'd have the signalmapper into the same class, would be the wrong context for the conecting slots.

[Carlton]

This combination of C++11 lambdas and Qt 5's ability to connect a functor to a signal is such a useful and yet underrated feature.

[Deniz]

I adapted this solution to my case. However, it throws an error if I use SIGNAL(triggered(bool)) instead of &QAction::triggered. Can somebody please explain to me why?

[Kuba hasn't forgotten Monica]

It doesn't "throw" an error. The compiler complains, and the error message should tell you why: there's no QObject::connect overload that takes a const char * as the 2nd argument and a functor as the third or fourth argument. The Qt4-style connect syntax doesn't mix with the new syntax. If you wish to use the old syntax, you forfeit the ease of connecting to functors (even though it could be approximated if you had a C++11 compiler but used Qt 4).

[Robin Macharg]

Worth noting (2018, Qt5, C++11) that QSignalMapper is deprecated. From the link: "This class is obsolete. It is provided to keep old source code working. We strongly advise against using it in new code." The answer by @kuba, below, is now a better one.