Question

I’ll start with the question and then try to explain:
Is there a way for an imported module to call a function in the module that imports it?

I am just learning to use Qt and am starting with Qt Designer to get some fundamentals worked out.

I have figured out how to create more than one “.ui” file in order to get the code for multiple windows and have managed to work out how to call the multiple windows from a main application by importing the code for the two windows.

For example, starting with win1.ui and win2.ui I create win1.py and win2.py – from my main application I import win1 and win2…

Note – I got this far by following this simple tutorial : http://www.youtube.com/watch?v=bHsC6WJsK-U&list=PLF4575388795F2531&index=10&feature=plpp_video

OK – now the question. If I have a button in win2, I know how to link that button to a function in the win2.py code. What I don’t know how to do is link the button in win2 to a function in my main application.

My only thought would be to add a function as an argument to the class that sets up the second window but if I do that then any changes to win2.ui will wreck the code that I have changed.

Thus, Is there a way for an imported module to call a function in the module that imports it?

I hope this is clear without adding a bunch of code that isn’t really relevant…

Answer 1

Qt is based on event-driven programming. Generally when you start building up your widgets, what you are going to be wanting to do is providing information to receiver widgets via signals that are then processed. You don’t want to explicitly have a child widget know or require to call methods on a parent widget (this is not always the case, but it is good to avoid when possible).

I’m gonna post some examples that don’t have UI files for ease here, but just assume you can build the same widget with designer and have it work the same way…

testwidget.py

from PyQt4 import QtGui, QtCore

class TestWidget(QtGui.QWidget):
    textSaved = QtCore.pyqtSignal(str)

    def __init__( self, parent = None ):
        super(TestWidget, self).__init__(parent)

        # create the ui (or load it)
        self.__edit   = QtGui.QTextEdit(self)
        self.__button = QtGui.QPushButton(self)
        self.__button.setText('Save')

        layout = QtGui.QVBoxLayout()
        layout.addWidget(self.__edit)
        layout.addWidget(self.__button)
        self.setLayout(layout)

        # create connections
        self.__button.clicked.connect(self.emitTextSaved)

    def emitTextSaved( self ):
        # allow Qt's blocking of signals paradigm to control flow
        if ( not self.signalsBlocked() ):
            self.textSaved.emit(self.__edit.toPlainText())

testwindow.py

from PyQt4 import QtGui, QtCore
import testwidget

class TestWindow(QtGui.QMainWindow):
    def __init__( self, parent == None ):
        super(TestWindow, self).__init__(parent)

        # create the ui (or load it)
        self.__editor = testwidget.TestWidget(self)
        self.setCentralWidget(self.__editor)

        # create connections
        self.__editor.textSaved.connect(self.showMessage)

    def showMessage( self, message ):
        QtGui.QMessageBox.information(self, 'Message', message)

So, here you can see that instead of thinking about it like – “when I click the button in TestWidget, I want to show a message in TestWindow” and explicitly link the two methods, you expose a signal that the TestWidget will emit out when the user performs an action, then connect that signal to the showMessage slot of the TestWindow. This way, your smaller widgets become more independent, and its more a matter of how you connect to each event that drives your application.

I could have done something like self.parent().showMessage(self.__edit.toPlainText()) within the TestWidget’s emitTextSaved method to call the method directly – but this is not a good design.