Sérgio Neves Sérgio Neves - 1 year ago 96
Python Question

How does the MainDialog() cycle work

I'm trying to understand how the cycle of my "main.py" works. It's based on examples found on the net, about the PySide and Qt Designer, to implement a Python GUI.

The code is:

# Python Libraries #
from PySide.QtCore import *
from PySide.QtGui import *
import sys
import time
# Python files #
import Gui
from server import *

class MainDialog(QDialog, Gui.Ui_TCPServer):

def __init__(self, parent=None):

super(MainDialog, self).__init__(parent)

self.connect(self.ConnectBt, SIGNAL("clicked()"), self.ConnectBt_clicked)
self.connect(self.QuitBt, SIGNAL("clicked()"), self.QuitBt_clicked)
self.connect(self.DisconnectBt, SIGNAL("clicked()"), self.DisconnectBt_clicked)

print "NOW HERE\r\n"

def ConnectBt_clicked(self):
print "THEN HERE\r\n"

def QuitBt_clicked(self):

def DisconnectBt_clicked(self):
self.server_off = ChronoRequestHandler()

def server_connect(self):
self.server_on = ServerStart()

if __name__ == '__main__':
app = QApplication(sys.argv)
form = MainDialog()
print "HERE\r\n"
print "END\r\n"

When I call the "main.py" I get a print of "NOW HERE" and "THEN HERE". When I press the 'ConnectBt', I get the print of "THEN HERE".

But and after this, where the cycle remains? Does it returns to init, if so, shouldn't I get again the print of "NOW HERE"? Does it returns to main, if so, shouldn't I get the print of "HERE"? Please explain me...

When I press the 'QuitBt' I get the print of "END"... I'm confused!


Answer Source

I think you should get more clear on how object programming and events work.

In the last if-statement (the code on the bottom that runs when you call your script from e.g. terminal) you create an app object instance of QApplication.

After that you create form, instance of MainDialog which is the class you define above (inheriting methods, properties, etc from two classes, QDialog, Gui.Ui_TCPServer).

By doing

form = MainDialog()

you run __init__, print "NOW HERE" and go out of that method. Please check what __init__ does in Python. why-do-we-use-init-in-python-classes

Before the end you call the exec() method of the app instance. This contains a loop so that your interface gathers and processes events. See the documentation on QApplication.exec() below.

When you press the 'ConnectBt' button you call the ConnectBt_clicked() method, which does stuff (connects with the server) and prints "THEN HERE".

In the same way, when you press QuitBt you call QuitBt_clicked(), which closes the connection and lets the code print "END".

I also suggest you read more documentation about the classes you are using. They will explain how come that the different buttons are "linked"/have as callbacks the methods ConnectBt_clicked(), def QuitBt_clicked(), and DisconnectBt_clicked(). The mechanisms by which the buttons trigger these callbacks is kind of implicit in the code implemented in those classes.

QApplication Class Reference: exec_

int QApplication.exec_ ()

Enters the main event loop and waits until exit() is called, then returns the value that was set to exit() (which is 0 if exit() is called via quit()).

It is necessary to call this function to start event handling. The main event loop receives events from the window system and dispatches these to the application widgets.

Generally, no user interaction can take place before calling exec(). As a special case, modal widgets like QMessageBox can be used before calling exec(), because modal widgets call exec() to start a local event loop.

To make your application perform idle processing, i.e., executing a special function whenever there are no pending events, use a QTimer with 0 timeout. More advanced idle processing schemes can be achieved using processEvents().

We recommend that you connect clean-up code to the aboutToQuit() signal, instead of putting it in your application's main() function. This is because, on some platforms the QApplication.exec() call may not return. For example, on the Windows platform, when the user logs off, the system terminates the process after Qt closes all top-level windows. Hence, there is no guarantee that the application will have time to exit its event loop and execute code at the end of the main() function, after the QApplication.exec() call.

See also quitOnLastWindowClosed, quit(), exit(), processEvents(), and QCoreApplication.exec().

Recommended from our users: Dynamic Network Monitoring from WhatsUp Gold from IPSwitch. Free Download