Qt No Such Slot In Derived Class

Posted : admin On 4/9/2022

steloditnu1983.netlify.com › ∎∎∎ Qt No Such Slot In Derived Class

Qt No Such Slot In Derived Class 5,9/10 798 votes

The main interface to PythonQt is the PythonQt singleton. PythonQt needs to be initialized via PythonQt::init() once. Afterwards you communicate with the singleton via PythonQt::self(). PythonQt offers a complete Qt binding, which needs to be enabled via PythonQt_QtAll::init().

QT no such slot. 0 Hi everyone, I'm trying to modify the sources codes of wireshark QT but apparently I can't add new slots. I mean i added in mainwindows.h my. QObject::connect: No such signal ButtonPanel::mostRecentPatientBtnClicked in.welcomebuttonpanel.cpp:6 So it seems QT is looking for the signal in ButtonPanel, the parent class, and not finding the signal in WelcomeButtonPanel, the derived class. The base class is ButtonPanel: Header. Qt Development General and Desktop. And a derived class. QObject::connect: No such slot QCcmStatusPanel::DistributorDepthSlot(int) Reply Quote 0. Signals and Events in Qt. But lets start with Qt. Qt offers two different systems for our needs, Qt signal/slot and QEvents. While Qt signal/slot is the moc driven signaling system of Qt (which you can connect to via QObject::connect), there is a second Event interface informing you about certain system-like events, such as QMouseEvent, QKeyEvent or QFocusEvent. In Qt Designer's signals and slots editing mode, you can connect objects in a form together using Qt's signals and slots mechanism.Both widgets and layouts can be connected via an intuitive connection interface, using the menu of compatible signals and slots provided by Qt Designer.

The following table shows the mapping between Python and Qt objects:

Qt/C++	Python
bool	bool
double	float
float	float
char/uchar,int/uint,short,ushort,QChar	integer
long	integer
ulong,longlong,ulonglong	long
QString	unicode string
QByteArray	QByteArray wrapper ⁽¹⁾
char*	str
QStringList	tuple of unicode strings
QVariantList	tuple of objects
QVariantMap	dict of objects
QVariant	depends on type ⁽²⁾
QSize, QRect and all other standard Qt QVariants	variant wrapper that supports complete API of the respective Qt classes
OwnRegisteredMetaType	C++ wrapper, optionally with additional information/wrapping provided by registerCPPClass()
QList<AnyObject*>	converts to a list of CPP wrappers
QVector<AnyObject*>	converts to a list of CPP wrappers
EnumType	Enum wrapper derived from python integer
QObject (and derived classes)	QObject wrapper
C++ object	CPP wrapper, either wrapped via PythonQtCppWrapperFactory or just decorated with decorators
PyObject	PyObject ⁽³⁾

The Python 'bytes' type will automatically be converted to QByteArray where required. For converting a QByteArray to 'bytes' use the .data() method.
QVariants are mapped recursively as given above, e.g. a dictionary can contain lists of dictionaries of doubles.
PyObject is passed as direct pointer, which allows to pass/return any Python object directly to/from a Qt slot that uses PyObject* as its argument/return value.

Qt No Such Slot In Derived Classroom

All Qt QVariant types are implemented, PythonQt supports the complete Qt API for these objects.

All classes derived from QObject are automatically wrapped with a python wrapper class when they become visible to the Python interpreter. This can happen via

the PythonQt::addObject() method
when a Qt slot returns a QObject derived object to python
when a Qt signal contains a QObject and is connected to a python function

It is important that you call PythonQt::registerClass() for any QObject derived class that may become visible to Python, except when you add it via PythonQt::addObject(). This will register the complete parent hierachy of the registered class, so that when you register e.g. a QPushButton, QWidget will be registered as well (and all intermediate parents).

From Python, you can talk to the returned QObjects in a natural way by calling their slots and receiving the return values. You can also read/write all properties of the objects as if they where normal python properties.

In addition to this, the wrapped objects support

className() - returns a string that reprents the classname of the QObject
help() - shows all properties, slots, enums, decorator slots and constructors of the object, in a printable form
delete() - deletes the object (use with care, especially if you passed the ownership to C++)
connect(signal, function) - connect the signal of the given object to a python function
connect(signal, qobject, slot) - connect the signal of the given object to a slot of another QObject
disconnect(signal, function) - disconnect the signal of the given object from a python function
disconnect(signal, qobject, slot) - disconnect the signal of the given object from a slot of another QObject
children() - returns the children of the object
setParent(QObject) - set the parent
QObject* parent() - get the parent

The below example shows how to connect signals in Python:

def someFunction(flag):

# button1 is a QPushButton that has been added to Python via addObject()

Qt No Such Slot In Derived Classes

# connect the clicked signal to a python function:

You can create dedicated wrapper QObjects for any C++ class. This is done by deriving from PythonQtCppWrapperFactory and adding your factory via addWrapperFactory(). Whenever PythonQt encounters a CPP pointer (e.g. on a slot or signal) and it does not known it as a QObject derived class, it will create a generic CPP wrapper. So even unknown C++ objects can be passed through Python. If the wrapper factory supports the CPP class, a QObject wrapper will be created for each instance that enters Python. An alternative to a complete wrapper via the wrapper factory are decorators, see Decorator slots

For each known C++ class, PythonQt provides a Python class. These classes are visible inside of the 'PythonQt' python module or in subpackages if a package is given when the class is registered.

A Meta class supports:

access to all declared enum values
constructors
static methods
unbound non-static methods
help() and className()

From within Python, you can import the module 'PythonQt' to access these classes and the Qt namespace.

print QtCore.Qt.AlignLeft

# constructors

b = QtCore.QFont()

# static method

QtCore.QFont.UltraCondensed

PythonQt introduces a new generic approach to extend any wrapped QObject or CPP object with

constructors
destructors (for CPP objects)
additional slots
static slots (callable on both the Meta object and the instances)

The idea behind decorators is that we wanted to make it as easy as possible to extend wrapped objects. Since we already have an implementation for invoking any Qt Slot from Python, it looked promising to use this approach for the extension of wrapped objects as well. This avoids that the PythonQt user needs to care about how Python arguments are mapped from/to Qt when he wants to create static methods, constructors and additional member functions.

The basic idea about decorators is to create a QObject derived class that implements slots which take one of the above roles (e.g. constructor, destructor etc.) via a naming convention. These slots are then assigned to other classes via the naming convention.

SomeClassName* new_SomeClassName(...) - defines a constructor for 'SomeClassName' that returns a new object of type SomeClassName (where SomeClassName can be any CPP class, not just QObject classes)
void delete_SomeClassName(SomeClassName* o) - defines a destructor, which should delete the passed in object o
anything static_SomeClassName_someMethodName(...) - defines a static method that is callable on instances and the meta class
anything someMethodName(SomeClassName* o, ...) - defines a slot that will be available on SomeClassName instances (and derived instances). When such a slot is called the first argument is the pointer to the instance and the rest of the arguments can be used to make a call on the instance.

The below example shows all kinds of decorators in action:

class YourCPPObject {

YourCPPObject(int arg1, float arg2) { a = arg1; b = arg2; }

float doSomething(int arg1) { return arg1*a*b; };

private:

int a;

};

// an example decorator

{

// add a constructor to QSize that takes a QPoint

QSize* new_QSize(const QPoint& p) { returnnew QSize(p.x(), p.y()); }

// add a constructor for QPushButton that takes a text and a parent widget

QPushButton* new_QPushButton(const QString& text, QWidget* parent=NULL) { returnnew QPushButton(text, parent); }

// add a constructor for a CPP object

YourCPPObject* new_YourCPPObject(int arg1, float arg2) { returnnew YourCPPObject(arg1, arg2); }

// add a destructor for a CPP object

void delete_YourCPPObject(YourCPPObject* obj) { delete obj; }

// add a static method to QWidget

QWidget* static_QWidget_mouseGrabber() { return QWidget::mouseGrabber(); }

// add an additional slot to QWidget (make move() callable, which is not declared as a slot in QWidget)

void move(QWidget* w, const QPoint& p) { w->move(p); }

// add an additional slot to QWidget, overloading the above move method

void move(QWidget* w, int x, int y) { w->move(x,y); }

// add a method to your own CPP object

int doSomething(YourCPPObject* obj, int arg1) { return obj->doSomething(arg1); }

PythonQt::self()->addDecorators(new ExampleDecorator());

PythonQt::self()->registerCPPClass('YourCPPObject');

After you have registered an instance of the above ExampleDecorator, you can do the following from Python (all these calls are mapped to the above decorator slots):

size = QtCore.QSize(QPoint(1,2));

# call our new QPushButton constructor

button.move(QPoint(0,0))

# call the move slot (overload2)

grabber = QtGui.QWidget.mouseWrapper();

# create a CPP object via constructor

print yourCpp.doSomething(1);

# destructor will be called:

In PythonQt, each wrapped C++ object is either owned by Python or C++. When an object is created via a Python constructor, it is owned by Python by default. When an object is returned from a C++ API (e.g. a slot), it is owned by C++ by default. Since the Qt API contains various APIs that pass the ownership from/to other C++ objects, PythonQt needs to keep track of such API calls. This is archieved by annotating arguments and return values in wrapper slots with magic templates:

These annotation templates work for since C++ pointer types. In addition to that, they work for QList<AnyObject*>, to pass the ownership for each object in the list.

Examples:

PythonQtPassOwnershipToPython<QGraphicsItem*> createNewItemOwnedByPython();

void addItemToCPP(PythonQtPassOwnershipToPython<QGraphicsItem*> item);

void addItemToCPP(PythonQtPassOwnershipToPython<QList<QGraphicsItem*> > items);

void addItemParent(QGraphicsItem* wrappedObject, PythonQtNewOwnerOfThis<QGraphicsItem*> parent);

Meeting C++

published at 20.08.2015 15:28 by Jens Weller

This is the 7th blog post in my series about writing applications with C++ using Qt and boost. This time it is about how to notify one part of our application that something has happened somewhere else. I will start with Qt, as it brings with signals and slots a mechanism to do exactly that. But, as I have the goal not to use Qt mainly in the UI Layer, I will also look on how to notify other parts of the application, when things are changing. The last episode was about QWidgets and data.

The video for this episode:

Signals and Events in Qt

But lets start with Qt. Qt offers two different systems for our needs, Qt signal/slot and QEvents. While Qt signal/slot is the moc driven signaling system of Qt (which you can connect to via QObject::connect), there is a second Event interface informing you about certain system-like events, such as QMouseEvent, QKeyEvent or QFocusEvent. Usually you have to overwrite a method to receive such events, or use an event filter, like I showed in my last post for QFocusEvents. Some classes translate QEvents to signals, such as the TreeView, which has a signal for displaying context menus. But as this blog post is more on signaling then system events...

Qt has had its own signaling mechanism for a long time now, so when you use Qt, you also will use QSignals. Qt also uses its own keywords for this: signals, slots and emit. There is an option to turn this of, and use the macros Q_SIGNAL/S,Q_SLOT/S and Q_EMIT instead: CONFIG += no_keywords. This allows to use 3rd party libraries which use these terms, e.g. boost::signal. Qt signal/slot implementation is thread safe, so that you can use it to send messages between different QThreads, this is especially important, as anything UI related should run in the main thread of Qt, anything that could block your UI should not run in this thread, so running jobs in a QThreadPool and emitting the finished result as a signal is a common pattern. Maybe I will touch this in a later post...

For now, lets see the basics of using signals and slots in Qt. This is the code from my MainWindow class constructor, connecting several signals to slots:

So, the traditional, moc driven connect method is QObject* derived sender, the SIGNAL macro defining the signal to connect to, followed by the QObject* derived receiver, then SLOT(...) is the last argument, naming the slot to connect to. There is a fifth defaultet parameter: the ConnectionType. The last line contains the new, lambda based connection option, where you again have the sender and its slot, this time as a method-pointer, and then followed by a lambda acting as the receiving slot.

This syntax can lead to a rare error, when ever a signal is overloaded, like QComboBox::currentIndexChanged, which is available with an int or QString parameter. Then you'll need an ugly static_cast to tell the compiler which version you'd like:

In this case I didn't even needed the argument from the slot. It is fairly easy to use your own signals and slots, all you need is a QObject derived class, which is processed by the moc. Mostly of course you already have classes derived from QObject indirectly, which then use signals and slots, like the page panel class:

So, slots and signals are normal member functions, declared after the qt-specific keyword signals/slots. When you want to emit a signal, its enough to just write 'emit my_signal();', and all observers on this signal will get notified. Slots are often used to react to certain events in the UI, like the currentIndexChanged signal in this case. In the widget editor of QtCreator you get an overview of available signals when right clicking and selecting 'go to slot...', this will create a slot for this signal in your QWidget derived class.

There is also the option to map certain widgets to certain values when a signal fires, this is done via QSignalMapper. I use this in a different program to have one widget for editing flag like settings, where each flag is a bit in a settings value:

The constructor only takes a QStringList for the option names, and an int for how many columns of check boxes the current use case should have. The QSignalMapper is a member variable, and each QCheckBox connects its clicked signal to the map() slot of QSignalMapper. With setMapping the connection between the sender and the value is set up. QSignalMapper offers int, QObject*, QWidget* and QString as mapping values. QVariant or a generic interface is not provided by Qt. In the clicked slot I simply toggle the bit for the corresponding flag.

When working in Qt, most of it types provide support for signals and slots through deriving from QObject, which offers connect/disconnect methods to manage your slot connections. This brings again the disadvantages of QObject and the moc, as templates can't be used in this context, all classes using signal/slot must be concrete classes. Deriving your classes from templates (CRTP e.g.) can help here to mix in a generic layer.

While Qt is fairly well prepared to manage its own messaging needs, what alternatives exist, that could be used in the non Qt related code? The C++ standard offers currently only std::function, which can be used to implement a callback mechanism. But this has its limitations, of a 1:1 or 1:many connection this is a viable option. I use it to notify my MainWindow class that a node in the tree has changed its name. Also its useful to implement classes which execute a callback in a certain context, like EventFilter in the last blog post in this series. But std::function is not an implementation of the observer pattern, and implementing your own with it would be reinventing the wheel. Boost has had for a long time a signal library, which now is available as version 2: boost::signals2.

Using boost::signals2

Honestly, if I could avoid using signals2, I would, as it has one certain disadvantage: build times increase. So far my project is kind of small, has only a few classes, which most of are less then 100 loc. Adding boost::signals2 to a class makes it hard to build a project quickly for debugging or just seeing if the work of the past hour still compiles.

The need for signals2 came in my application, when I began to understand, that there are some events, which go from the Qt layer into the boost/standard C++ layer, and then need to travel back into the Qt layer. Each Page has a shared_ptr to a layout object, which is part of a LayoutItem holding the list of layouts for a document. There is one LayoutPanel to edit, create and delete layouts in LayoutItem, and each PagePanel has a QComboBox, so that the user can select the layout for the page. Now, when a user creates/renames a layout, each PagePanel needs to be notified, but when it gets deleted, also page needs to change. This could be implemented in the Qt layer, each Qt class involved has access to the boost/C++ layer, and can make the necessary changes. But then, this important business logic of removing a layout will only work through the UI. When I use boost::signals2, it can be done in the boost/standard C++ layer.

Qt No Such Slot In Derived Class Example

boost::signals2 has a signal template, which has the signature as the argument, this signal type also then has the typedef for the slot type, signal::connect returns a connection object:

When ever an object subscribes to the layout signals, it must to so for all three, the vector should invoke RVO. Currently, PagePanel is the only subscriber, it simply connects to the signals using boost::bind:

One detail here is, that I do use scoped_connection, which will call disconnect() on its destruction, while the default boost::signals2::connection class does not. scoped_connection can be moved, but not copied. But once it is in the vector, it will stay there. Also, you should forward declare the connection classes, so that you don't have to include the boost/signals2.hpp headers, this prevents leaking into other sources.

But boost::signals2 can do far more. I have no use for code that depends on the order of slots called, but you can specify this with signal::contect(int group, slot):

In some context it is interesting to handle the return value of a signal, for this boost::signal2 offers a combiner, which is the second template parameter to signal: signal<float(float,float), aggregate_combiner<std::vector<float> > >. This combiner then also overwrites the return value of the signal, which is now std::vector instead of float. Another feature is that you can block a connection with shared_connection_block.

boost::signal2 is currently header only, thread safe and offers a few more customization points, for example you can change the mutex, but also the signature type, which currently is boost::function.

Qt No Such Slot In Derived Class C

Alternatives to boost::signals2

If you know very well what you are doing, you could use boost::signal instead of its new version, signals2. This might improve your compile times, but boost::signals is not any more maintained. Also, while signals2 is header-only, signals is not. The thread safety is a key feature of signals2, which at some time sooner or later will come into play in your code base. I don't want to introduce a 3rd party library into my project just to have signaling/observer pattern, but you should know, that there are a few alternatives (I googled that too):

libsigslot
- has open bugs from 2003 - 2011, memory leaks and other issues. But seems to do the job.
libsigc++
- a standard C++ implementation, inspired by Qt, you (might) have to derive your objects from a base class. Virtual function calls are the base of this library it seems, at least for method slots, which the call has to be derived from sigc::trackable.
- gtkmm and glibmm seem to use this for their signaling needs.
- the 5 open bugs seem to be feature requests mostly (and nil is a keyword in Object-C, well...)
- the library has been rewritten using modern C++ idioms (claims the site)
This codeproject article from 2005 gives some insights, but C++11 changes some of them I think.
slimsig
- seems to be a header only alternative to boost::signals2
- 2 open bugs, no change in one year
boost::synapse
- this library is proposed for boost, but has not yet been reviewed.
- I think it could be a more lightweight alternative to signals2
- Currently its not threadsafe.

The only disadvantage of boost::signal2 is really its impact on compile and link time, which can be reduced through pimple and other isolation techniques, so that a recompilation is only triggered when really needed. One idea which came in my mind during this blog post is a std_signal2 header, which replaces the boost types (function, mutex etc.) with the corresponding std types. I'm not sure how this would work out, but boost::signals2 seems to be pretty well build to do this, a lot of template parameters have default values which then configure the library, and are hidden from the day to day usage.

Join the Meeting C++ patreon community!
This and other posts on Meeting C++ are enabled by my supporters on patreon!