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
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
|
# This file is part of the PySide project.
#
# Copyright (C) 2009-2011 Nokia Corporation and/or its subsidiary(-ies).
# Copyright (C) 2010 Riverbank Computing Limited.
# Copyright (C) 2009 Torsten Marek
#
# Contact: PySide team <pyside@openbossa.org>
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# version 2 as published by the Free Software Foundation.
#
# This program is distributed in the hope that it will be useful, but
# WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
# General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
# 02110-1301 USA
import sys
import re
from pysideuic.Compiler.indenter import write_code
from pysideuic.Compiler.misc import Literal, moduleMember
if sys.hexversion >= 0x03000000:
from pysideuic.port_v3.proxy_base import ProxyBase
from pysideuic.port_v3.as_string import as_string
else:
from pysideuic.port_v2.proxy_base import ProxyBase
from pysideuic.port_v2.as_string import as_string
i18n_strings = []
i18n_context = ""
def i18n_print(string):
i18n_strings.append(string)
def i18n_void_func(name):
def _printer(self, *args):
i18n_print("%s.%s(%s)" % (self, name, ", ".join(map(as_string, args))))
return _printer
def i18n_func(name):
def _printer(self, rname, *args):
i18n_print("%s = %s.%s(%s)" % (rname, self, name, ", ".join(map(as_string, args))))
return Literal(rname)
return _printer
def strict_getattr(module, clsname):
cls = getattr(module, clsname)
if issubclass(cls, LiteralProxyClass):
raise AttributeError(cls)
else:
return cls
class i18n_string(object):
def __init__(self, string, disambig):
self.string = string
self.disambig = disambig
def __str__(self):
if self.disambig is None:
disambig = "None"
else:
disambig = as_string(self.disambig, encode=False)
return 'QtGui.QApplication.translate("%s", %s, %s, QtGui.QApplication.UnicodeUTF8)' % (i18n_context, as_string(self.string, encode=False), disambig)
# Classes with this flag will be handled as literal values. If functions are
# called on these classes, the literal value changes.
# Example:
# the code
# >>> QSize(9,10).expandedTo(...)
# will print just that code.
AS_ARGUMENT = 2
# ATTENTION: currently, classes can either be literal or normal. If a class
# should need both kinds of behaviour, the code has to be changed.
class ProxyClassMember(object):
def __init__(self, proxy, function_name, flags):
self.proxy = proxy
self.function_name = function_name
self.flags = flags
def __str__(self):
return "%s.%s" % (self.proxy, self.function_name)
def __call__(self, *args):
func_call = "%s.%s(%s)" % (self.proxy,
self.function_name,
", ".join(map(as_string, args)))
if self.flags & AS_ARGUMENT:
self.proxy._uic_name = func_call
return self.proxy
else:
needs_translation = False
for arg in args:
if isinstance(arg, i18n_string):
needs_translation = True
if needs_translation:
i18n_print(func_call)
else:
write_code(func_call)
class ProxyClass(ProxyBase):
flags = 0
def __init__(self, objectname, is_attribute, args=(), noInstantiation=False):
if objectname:
if is_attribute:
objectname = "self." + objectname
self._uic_name = objectname
else:
self._uic_name = "Unnamed"
if not noInstantiation:
funcall = "%s(%s)" % \
(moduleMember(self.module, self.__class__.__name__),
", ".join(map(str, args)))
if objectname:
funcall = "%s = %s" % (objectname, funcall)
write_code(funcall)
def __str__(self):
return self._uic_name
def __getattribute__(self, attribute):
try:
return object.__getattribute__(self, attribute)
except AttributeError:
return ProxyClassMember(self, attribute, self.flags)
class LiteralProxyClass(ProxyClass):
"""LiteralObject(*args) -> new literal class
a literal class can be used as argument in a function call
>>> class Foo(LiteralProxyClass): pass
>>> str(Foo(1,2,3)) == "Foo(1,2,3)"
"""
flags = AS_ARGUMENT
def __init__(self, *args):
self._uic_name = "%s(%s)" % \
(moduleMember(self.module, self.__class__.__name__),
", ".join(map(as_string, args)))
class ProxyNamespace(ProxyBase):
pass
# These are all the Qt classes used by pyuic4 in their namespaces. If a class
# is missing, the compiler will fail, normally with an AttributeError.
#
# For adding new classes:
# - utility classes used as literal values do not need to be listed
# because they are created on the fly as subclasses of LiteralProxyClass
# - classes which are *not* QWidgets inherit from ProxyClass and they
# have to be listed explicitly in the correct namespace. These classes
# are created via a ProxyQObjectCreator
# - new QWidget-derived classes have to inherit from qtproxies.QWidget
# If the widget does not need any special methods, it can be listed
# in _qwidgets
class QtCore(ProxyNamespace):
class Qt(ProxyNamespace):
pass
## connectSlotsByName and connect have to be handled as class methods,
## otherwise they would be created as LiteralProxyClasses and never be
## printed
class QMetaObject(ProxyClass):
def connectSlotsByName(cls, *args):
ProxyClassMember(cls, "connectSlotsByName", 0)(*args)
connectSlotsByName = classmethod(connectSlotsByName)
class QObject(ProxyClass):
def metaObject(self):
class _FakeMetaObject(object):
def className(*args):
return self.__class__.__name__
return _FakeMetaObject()
def objectName(self):
return self._uic_name.split(".")[-1]
def connect(cls, *args):
# Handle slots that have names corresponding to Python keywords.
slot_name = str(args[-1])
if slot_name.endswith('.raise'):
args = list(args[:-1])
args.append(Literal(slot_name + '_'))
ProxyClassMember(cls, "connect", 0)(*args)
connect = classmethod(connect)
# These sub-class QWidget but aren't themselves sub-classed.
_qwidgets = ("QCalendarWidget", "QDialogButtonBox", "QDockWidget", "QGroupBox",
"QLineEdit", "QMainWindow", "QMenuBar", "QProgressBar", "QStatusBar",
"QToolBar", "QWizardPage")
class QtGui(ProxyNamespace):
class QApplication(QtCore.QObject):
def translate(uiname, text, disambig, encoding):
return i18n_string(text or "", disambig)
translate = staticmethod(translate)
class QIcon(ProxyClass): pass
class QConicalGradient(ProxyClass): pass
class QLinearGradient(ProxyClass): pass
class QRadialGradient(ProxyClass): pass
class QBrush(ProxyClass): pass
class QPainter(ProxyClass): pass
class QPalette(ProxyClass): pass
class QFont(ProxyClass): pass
class QSpacerItem(ProxyClass): pass
class QSizePolicy(ProxyClass): pass
## QActions inherit from QObject for the metaobject stuff
## and the hierarchy has to be correct since we have a
## isinstance(x, QtGui.QLayout) call in the ui parser
class QAction(QtCore.QObject): pass
class QActionGroup(QtCore.QObject): pass
class QButtonGroup(QtCore.QObject): pass
class QLayout(QtCore.QObject):
def setMargin(self, v):
ProxyClassMember(self, "setContentsMargins", 0)(v, v, v, v);
class QGridLayout(QLayout): pass
class QBoxLayout(QLayout): pass
class QHBoxLayout(QBoxLayout): pass
class QVBoxLayout(QBoxLayout): pass
class QFormLayout(QLayout): pass
class QWidget(QtCore.QObject):
def font(self):
return Literal("%s.font()" % self)
def minimumSizeHint(self):
return Literal("%s.minimumSizeHint()" % self)
def sizePolicy(self):
sp = LiteralProxyClass()
sp._uic_name = "%s.sizePolicy()" % self
return sp
class QDialog(QWidget): pass
class QWizard(QDialog): pass
class QAbstractSlider(QWidget): pass
class QDial(QAbstractSlider): pass
class QScrollBar(QAbstractSlider): pass
class QSlider(QAbstractSlider): pass
class QMenu(QWidget):
def menuAction(self):
return Literal("%s.menuAction()" % self)
class QTabWidget(QWidget):
def addTab(self, *args):
text = args[-1]
if isinstance(text, i18n_string):
i18n_print("%s.setTabText(%s.indexOf(%s), %s)" % \
(self._uic_name, self._uic_name, args[0], text))
args = args[:-1] + ("", )
ProxyClassMember(self, "addTab", 0)(*args)
def indexOf(self, page):
return Literal("%s.indexOf(%s)" % (self, page))
class QComboBox(QWidget): pass
class QFontComboBox(QComboBox): pass
class QAbstractSpinBox(QWidget): pass
class QDoubleSpinBox(QAbstractSpinBox): pass
class QSpinBox(QAbstractSpinBox): pass
class QDateTimeEdit(QAbstractSpinBox): pass
class QDateEdit(QDateTimeEdit): pass
class QTimeEdit(QDateTimeEdit): pass
class QFrame(QWidget): pass
class QLabel(QFrame): pass
class QLCDNumber(QFrame): pass
class QSplitter(QFrame): pass
class QStackedWidget(QFrame): pass
class QToolBox(QFrame):
def addItem(self, *args):
text = args[-1]
if isinstance(text, i18n_string):
i18n_print("%s.setItemText(%s.indexOf(%s), %s)" % \
(self._uic_name, self._uic_name, args[0], text))
args = args[:-1] + ("", )
ProxyClassMember(self, "addItem", 0)(*args)
def indexOf(self, page):
return Literal("%s.indexOf(%s)" % (self, page))
def layout(self):
return QtGui.QLayout("%s.layout()" % self,
False, (), noInstantiation=True)
class QAbstractScrollArea(QFrame): pass
class QGraphicsView(QAbstractScrollArea): pass
class QMdiArea(QAbstractScrollArea): pass
class QPlainTextEdit(QAbstractScrollArea): pass
class QScrollArea(QAbstractScrollArea): pass
class QTextEdit(QAbstractScrollArea): pass
class QTextBrowser(QTextEdit): pass
class QAbstractItemView(QAbstractScrollArea): pass
class QColumnView(QAbstractItemView): pass
class QHeaderView(QAbstractItemView): pass
class QListView(QAbstractItemView): pass
class QTableView(QAbstractItemView):
def horizontalHeader(self):
return QtGui.QHeaderView("%s.horizontalHeader()" % self,
False, (), noInstantiation=True)
def verticalHeader(self):
return QtGui.QHeaderView("%s.verticalHeader()" % self,
False, (), noInstantiation=True)
class QTreeView(QAbstractItemView):
def header(self):
return QtGui.QHeaderView("%s.header()" % self,
False, (), noInstantiation=True)
class QListWidgetItem(ProxyClass): pass
class QListWidget(QListView):
isSortingEnabled = i18n_func("isSortingEnabled")
setSortingEnabled = i18n_void_func("setSortingEnabled")
def item(self, row):
return QtGui.QListWidgetItem("%s.item(%i)" % (self, row), False,
(), noInstantiation=True)
class QTableWidgetItem(ProxyClass): pass
class QTableWidget(QTableView):
isSortingEnabled = i18n_func("isSortingEnabled")
setSortingEnabled = i18n_void_func("setSortingEnabled")
def item(self, row, col):
return QtGui.QTableWidgetItem("%s.item(%i, %i)" % (self, row, col),
False, (), noInstantiation=True)
def horizontalHeaderItem(self, col):
return QtGui.QTableWidgetItem("%s.horizontalHeaderItem(%i)" % (self, col),
False, (), noInstantiation=True)
def verticalHeaderItem(self, row):
return QtGui.QTableWidgetItem("%s.verticalHeaderItem(%i)" % (self, row),
False, (), noInstantiation=True)
class QTreeWidgetItem(ProxyClass):
def child(self, index):
return QtGui.QTreeWidgetItem("%s.child(%i)" % (self, index),
False, (), noInstantiation=True)
class QTreeWidget(QTreeView):
isSortingEnabled = i18n_func("isSortingEnabled")
setSortingEnabled = i18n_void_func("setSortingEnabled")
def headerItem(self):
return QtGui.QWidget("%s.headerItem()" % self, False, (),
noInstantiation=True)
def topLevelItem(self, index):
return QtGui.QTreeWidgetItem("%s.topLevelItem(%i)" % (self, index),
False, (), noInstantiation=True)
class QAbstractButton(QWidget): pass
class QCheckBox(QAbstractButton): pass
class QRadioButton(QAbstractButton): pass
class QToolButton(QAbstractButton): pass
class QPushButton(QAbstractButton): pass
class QCommandLinkButton(QPushButton): pass
# Add all remaining classes.
for _class in _qwidgets:
if _class not in locals():
locals()[_class] = type(_class, (QWidget, ), {})
|