1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
|
#!/usr/bin/env python
# A demonstration custom widget.
#
# Copyright (c) 2007 Phil Thompson
from PyQt4 import QtCore, QtGui
# The purpose of this class is to show that Designer's property editor shows
# all Python classes in the hierarchy that define properties.
class PyTextViewer(QtGui.QTextEdit):
# Initialise the instance.
def __init__(self, parent=None):
super(PyTextViewer, self).__init__(parent)
self.setReadOnly(True)
# Initialise the author property by calling it's reset function.
self.resetAuthor()
# The getter for the author property. Note that we cannot follow the Qt
# naming convention (ie. by using the naming the getter "author") because
# it would conflict with the property name.
def getAuthor(self):
return self._author
# The setter for the author property.
def setAuthor(self, name):
self._author = name
# The resetter for the author property. Only Qt Designer uses this. Qt
# Designer does not use the deleter function of the property.
def resetAuthor(self):
self._author = "David Boddie"
# Define the author property. This will look like a C++ property to Qt
# Designer and a Python property to Python.
author = QtCore.pyqtProperty(str, getAuthor, setAuthor, resetAuthor)
# This is the class that implements the custom widget.
class PyDemo(PyTextViewer):
# Define the Qt signals as a sequence of C++ function signatures excluding
# the return type. These may be connected to other signals or slots in Qt
# Designer.
zoomChanged = QtCore.pyqtSignal(int)
# Initialise the instance.
def __init__(self, parent=None):
super(PyDemo, self).__init__(parent)
self.setWindowTitle("PyQt Demonstration Widget")
self.setText(_demo_text)
# Initialise the zoom property. We don't just call the resetter
# because it assumes that this has already been initialised.
self._zoom = 0
# The getter for the zoom property.
def getZoom(self):
return self._zoom
# The setter for the zoom property. We also make define this as a Qt slot
# which can be connected to Qt signals in Qt Designer.
@QtCore.pyqtSlot(int)
def setZoom(self, zoom):
# Don't do anything if nothing has changed.
if self._zoom == zoom:
return
# Zoom in or out according to the relative zoom levels.
if self._zoom < zoom:
self.zoomIn(zoom - self._zoom)
elif self._zoom > zoom:
self.zoomOut(self._zoom - zoom)
# Remember the new zoom level.
self._zoom = zoom
# Emit the Qt signal to say that the zoom level has changed.
self.zoomChanged.emit(zoom)
# The resetter for the zoom property.
def resetZoom(self):
self.setZoom(0)
# Define the zoom property. Changing the value of this in Qt Designer's
# property editor causes the zoom level to change dynamically.
zoom = QtCore.pyqtProperty(int, getZoom, setZoom, resetZoom)
# The text displayed in the custom widget.
_demo_text = """<h3>PyQt Demonstration Widget</h3>
<p>This simple example demonstrates the following features.</p>
<ul>
<li>The definition of properties that behave as C++ properties to Qt and
Python properties to Python.</li>
<li>The definition of new Qt signals that can be connected to other signals
and Qt slots in Designer.</li>
<li>The definition of new Qt slots that can be connected to signals in
Designer.</li>
</ul>
"""
# Display the custom widget if the script is being run directly from the
# command line.
if __name__ == "__main__":
import sys
app = QtGui.QApplication(sys.argv)
demo = PyDemo()
demo.show()
sys.exit(app.exec_())
|
