how to emit signal from a non PyQt class?

Question

i'm programming an application in python using twisted and PyQt . the problem that i'm facing is that when a function in my twisted code is executed i have to print a line in the GUI, i'm trying to achieve this by emiting a signal (Non PyQt class). This does not seem to work, i have a doubt that the twisted event loop is screwing things for PyQt. Because the closeEvent signal is not being trapped by the program. Here's the code snippet: ``` from PyQt4 import QtGui, QtCore import sys from twisted.internet.protocol import Factory, Protocol from twisted.protocols import amp import qt4reactor class register_procedure(amp.Command): arguments = [('MAC',amp.String()), ('IP',amp.String()), ('Computer_Name',amp.String()), ('OS',amp.String()) ] response = [('req_status', amp.String()), ('ALIGN_FUNCTION', amp.String()), ('ALIGN_Confirmation', amp.Integer()), ('Callback_offset',amp.Integer()) ] class Ui_MainWindow(QtGui.QMainWindow): def __init__(self,reactor, parent=None): super(Ui_MainWindow,se…

Accepted Answer

This is what I use in my one code for sending signals from QGraphicsItems (because they are not derived from QObject and cannot send/receive signals by default). It's basically a simplified version of Radio-'s answer.

```
from PyQt4 import QtGui as QG
from PyQt4 import QtCore as QC

class SenderObject(QC.QObject):
    something_happened = QC.pyqtSignal()
```

`SenderObject` is a tiny class derived from QObject where you can put all the signals you need to emit. In this case only one is defined.

```
class SnapROIItem(QG.QGraphicsRectItem):
    def __init__(self, parent = None):
        super(SnapROIItem, self).__init__(parent)
        self.sender = SenderObject()
    def do_something_and_emit(self):
        ...
        self.sender.something_happened.emit()
```

In the non-QObject class you add a `SenderObject` as a `sender` variable. Anywhere where the non-QObject class is used you can connect the signal from the `sender` to anything you need.

```
class ROIManager(QC.QObject):
    def add_snaproi(self, snaproi):
        snaproi.sender.something_happened.connect(...)
```

UPDATE

The full code is this and should print out "Something happened...":

```
from PyQt4 import QtGui as QG
from PyQt4 import QtCore as QC

class SenderObject(QC.QObject):
    something_happened = QC.pyqtSignal()

class SnapROIItem(QG.QGraphicsItem):
    def __init__(self, parent = None):
        super(SnapROIItem, self).__init__(parent)
        self.sender = SenderObject()
    def do_something_and_emit(self):
        self.sender.something_happened.emit()

class ROIManager(QC.QObject):
    def __init__(self, parent=None):
        super(ROIManager,self).__init__(parent)
    def add_snaproi(self, snaproi):
        snaproi.sender.something_happened.connect(self.new_roi)
    def new_roi(self):
        print 'Something happened in ROI!'

if __name__=="__main__":)
    roimanager = ROIManager()
    snaproi = SnapROIItem()
    roimanager.add_snaproi(snaproi)
    snaproi.do_something_and_emit()
```

UPDATE 2

Instead of

```
QtCore.QObject.connect(self,QtCore.SIGNAL('registered()'),self.registered) 
```

you should have:

```
protocol.sender.registered.connect(self.registered)
```

This means you also need to get hold of the `protocol` instance in `self.pf` (by the way, do you import `Protocol` and then define it yourself as well?)

In the Protocol class instead of

```
QtCore.QObject.emit( QtCore.SIGNAL('registered')
```

you need to, first, instantiate a SenderObject in the Protocol.

```
class Protocol(amp.AMP):
    def __init__( self, *args, **kw ):
       super(Protocol, self).__init__(*args, **kw)
       self.sender = SenderObject()
```

and then, in `register_procedure` emit the signal through `sender`: self.sender.registered.emit()

For all of this to work you'll have to have defined SenderObject as:

```
class SenderObject(QC.QObject):
    registered = QC.pyqtSignal()
```

how to emit signal from a non PyQt class?

Solution

Problem