##// END OF EJS Templates
HG_REPOSITORIES » LPP » INSTRUMENTATION » SocExplorer
RSS
Made possible to subclass from python plugin class....
Jeandet Alexis -
r64:fb730b849667 default
parent child
Show More
Show file before | Show file after | Hide comments
@@ -0,0 +1,3
1 SocExplorer Icon:
2 By Lolo00 (Own work) [GFDL (http://www.gnu.org/copyleft/fdl.html) or CC-BY-SA-3.0 (http://creativecommons.org/licenses/by-sa/3.0/)], via Wikimedia Commons
3
Show file before | Show file after | Hide comments
@@ -0,0 +1,6
1 #!/usr/bin/lppmon -e
2
3 class test(PySocExplorerEngine.socexplorerplugin):
4 def hello(self):
5 print "hello"
6
Show file before | Show file after | Hide comments
1 NO CONTENT: new file 100644, binary diff hidden
NO CONTENT: new file 100644, binary diff hidden
Show file before | Show file after | Hide comments
@@ -0,0 +1,4
1 #include <QtCore/QObject>
2 #include <QtWidgets/QtWidgets>
3 #include "plugins/socexplorerplugin.h"
4
Show file before | Show file after | Hide comments
@@ -0,0 +1,6
1 HEADERS += \
2 $$PWD/PySocExplorerEngine0.h \
3
4 SOURCES += \
5 $$PWD/PySocExplorerEngine0.cpp \
6 $$PWD/PySocExplorerEngine_init.cpp
Show file before | Show file after | Hide comments
This diff has been collapsed as it changes many lines, (1328 lines changed) Show them Hide them
@@ -0,0 +1,1328
1 #include "PySocExplorerEngine0.h"
2 #include <PythonQtConversion.h>
3 #include <PythonQtMethodInfo.h>
4 #include <PythonQtSignalReceiver.h>
5 #include <QIconEngine>
6 #include <QVariant>
7 #include <qaction.h>
8 #include <qbitmap.h>
9 #include <qbytearray.h>
10 #include <qcoreevent.h>
11 #include <qcursor.h>
12 #include <qdockwidget.h>
13 #include <qevent.h>
14 #include <qfont.h>
15 #include <qgraphicseffect.h>
16 #include <qgraphicsproxywidget.h>
17 #include <qkeysequence.h>
18 #include <qlayout.h>
19 #include <qlist.h>
20 #include <qlocale.h>
21 #include <qmargins.h>
22 #include <qmenu.h>
23 #include <qobject.h>
24 #include <qpaintdevice.h>
25 #include <qpaintengine.h>
26 #include <qpainter.h>
27 #include <qpalette.h>
28 #include <qpixmap.h>
29 #include <qpoint.h>
30 #include <qrect.h>
31 #include <qregion.h>
32 #include <qsize.h>
33 #include <qsizepolicy.h>
34 #include <qstyle.h>
35 #include <qstyleoption.h>
36 #include <qwidget.h>
37 #include <socexplorerplugin.h>
38
39 PythonQtShell_socexplorerplugin::~PythonQtShell_socexplorerplugin() {
40 PythonQtPrivate* priv = PythonQt::priv();
41 if (priv) { priv->shellClassDeleted(this); }
42 }
43 int PythonQtShell_socexplorerplugin::PID()
44 {
45 if (_wrapper) {
46 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "PID");
47 PyErr_Clear();
48 if (obj && !PythonQtSlotFunction_Check(obj)) {
49 static const char* argumentList[] ={"int"};
50 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
51 int returnValue;
52 void* args[1] = {NULL};
53 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
54 if (result) {
55 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
56 if (args[0]!=&returnValue) {
57 if (args[0]==NULL) {
58 PythonQt::priv()->handleVirtualOverloadReturnError("PID", methodInfo, result);
59 } else {
60 returnValue = *((int*)args[0]);
61 }
62 }
63 }
64 if (result) { Py_DECREF(result); }
65 Py_DECREF(obj);
66 return returnValue;
67 }
68 }
69 return socexplorerplugin::PID();
70 }
71 unsigned int PythonQtShell_socexplorerplugin::Read(unsigned int* Value, unsigned int count, unsigned int address)
72 {
73 if (_wrapper) {
74 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "Read");
75 PyErr_Clear();
76 if (obj && !PythonQtSlotFunction_Check(obj)) {
77 static const char* argumentList[] ={"unsigned int" , "unsigned int*" , "unsigned int" , "unsigned int"};
78 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
79 unsigned int returnValue;
80 void* args[4] = {NULL, (void*)&Value, (void*)&count, (void*)&address};
81 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
82 if (result) {
83 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
84 if (args[0]!=&returnValue) {
85 if (args[0]==NULL) {
86 PythonQt::priv()->handleVirtualOverloadReturnError("Read", methodInfo, result);
87 } else {
88 returnValue = *((unsigned int*)args[0]);
89 }
90 }
91 }
92 if (result) { Py_DECREF(result); }
93 Py_DECREF(obj);
94 return returnValue;
95 }
96 }
97 return socexplorerplugin::Read(Value, count, address);
98 }
99 int PythonQtShell_socexplorerplugin::VID()
100 {
101 if (_wrapper) {
102 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "VID");
103 PyErr_Clear();
104 if (obj && !PythonQtSlotFunction_Check(obj)) {
105 static const char* argumentList[] ={"int"};
106 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
107 int returnValue;
108 void* args[1] = {NULL};
109 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
110 if (result) {
111 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
112 if (args[0]!=&returnValue) {
113 if (args[0]==NULL) {
114 PythonQt::priv()->handleVirtualOverloadReturnError("VID", methodInfo, result);
115 } else {
116 returnValue = *((int*)args[0]);
117 }
118 }
119 }
120 if (result) { Py_DECREF(result); }
121 Py_DECREF(obj);
122 return returnValue;
123 }
124 }
125 return socexplorerplugin::VID();
126 }
127 unsigned int PythonQtShell_socexplorerplugin::Write(unsigned int* Value, unsigned int count, unsigned int address)
128 {
129 if (_wrapper) {
130 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "Write");
131 PyErr_Clear();
132 if (obj && !PythonQtSlotFunction_Check(obj)) {
133 static const char* argumentList[] ={"unsigned int" , "unsigned int*" , "unsigned int" , "unsigned int"};
134 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
135 unsigned int returnValue;
136 void* args[4] = {NULL, (void*)&Value, (void*)&count, (void*)&address};
137 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
138 if (result) {
139 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
140 if (args[0]!=&returnValue) {
141 if (args[0]==NULL) {
142 PythonQt::priv()->handleVirtualOverloadReturnError("Write", methodInfo, result);
143 } else {
144 returnValue = *((unsigned int*)args[0]);
145 }
146 }
147 }
148 if (result) { Py_DECREF(result); }
149 Py_DECREF(obj);
150 return returnValue;
151 }
152 }
153 return socexplorerplugin::Write(Value, count, address);
154 }
155 void PythonQtShell_socexplorerplugin::actionEvent(QActionEvent* arg__1)
156 {
157 if (_wrapper) {
158 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "actionEvent");
159 PyErr_Clear();
160 if (obj && !PythonQtSlotFunction_Check(obj)) {
161 static const char* argumentList[] ={"" , "QActionEvent*"};
162 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
163 void* args[2] = {NULL, (void*)&arg__1};
164 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
165 if (result) { Py_DECREF(result); }
166 Py_DECREF(obj);
167 return;
168 }
169 }
170 socexplorerplugin::actionEvent(arg__1);
171 }
172 void PythonQtShell_socexplorerplugin::activate(bool flag)
173 {
174 if (_wrapper) {
175 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "activate");
176 PyErr_Clear();
177 if (obj && !PythonQtSlotFunction_Check(obj)) {
178 static const char* argumentList[] ={"" , "bool"};
179 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
180 void* args[2] = {NULL, (void*)&flag};
181 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
182 if (result) { Py_DECREF(result); }
183 Py_DECREF(obj);
184 return;
185 }
186 }
187 socexplorerplugin::activate(flag);
188 }
189 int PythonQtShell_socexplorerplugin::baseAddress()
190 {
191 if (_wrapper) {
192 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "baseAddress");
193 PyErr_Clear();
194 if (obj && !PythonQtSlotFunction_Check(obj)) {
195 static const char* argumentList[] ={"int"};
196 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
197 int returnValue;
198 void* args[1] = {NULL};
199 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
200 if (result) {
201 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
202 if (args[0]!=&returnValue) {
203 if (args[0]==NULL) {
204 PythonQt::priv()->handleVirtualOverloadReturnError("baseAddress", methodInfo, result);
205 } else {
206 returnValue = *((int*)args[0]);
207 }
208 }
209 }
210 if (result) { Py_DECREF(result); }
211 Py_DECREF(obj);
212 return returnValue;
213 }
214 }
215 return socexplorerplugin::baseAddress();
216 }
217 QString PythonQtShell_socexplorerplugin::baseName()
218 {
219 if (_wrapper) {
220 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "baseName");
221 PyErr_Clear();
222 if (obj && !PythonQtSlotFunction_Check(obj)) {
223 static const char* argumentList[] ={"QString"};
224 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
225 QString returnValue;
226 void* args[1] = {NULL};
227 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
228 if (result) {
229 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
230 if (args[0]!=&returnValue) {
231 if (args[0]==NULL) {
232 PythonQt::priv()->handleVirtualOverloadReturnError("baseName", methodInfo, result);
233 } else {
234 returnValue = *((QString*)args[0]);
235 }
236 }
237 }
238 if (result) { Py_DECREF(result); }
239 Py_DECREF(obj);
240 return returnValue;
241 }
242 }
243 return socexplorerplugin::baseName();
244 }
245 void PythonQtShell_socexplorerplugin::changeEvent(QEvent* event)
246 {
247 if (_wrapper) {
248 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "changeEvent");
249 PyErr_Clear();
250 if (obj && !PythonQtSlotFunction_Check(obj)) {
251 static const char* argumentList[] ={"" , "QEvent*"};
252 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
253 void* args[2] = {NULL, (void*)&event};
254 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
255 if (result) { Py_DECREF(result); }
256 Py_DECREF(obj);
257 return;
258 }
259 }
260 socexplorerplugin::changeEvent(event);
261 }
262 void PythonQtShell_socexplorerplugin::childEvent(QChildEvent* arg__1)
263 {
264 if (_wrapper) {
265 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "childEvent");
266 PyErr_Clear();
267 if (obj && !PythonQtSlotFunction_Check(obj)) {
268 static const char* argumentList[] ={"" , "QChildEvent*"};
269 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
270 void* args[2] = {NULL, (void*)&arg__1};
271 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
272 if (result) { Py_DECREF(result); }
273 Py_DECREF(obj);
274 return;
275 }
276 }
277 socexplorerplugin::childEvent(arg__1);
278 }
279 void PythonQtShell_socexplorerplugin::closeEvent(QCloseEvent* event)
280 {
281 if (_wrapper) {
282 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "closeEvent");
283 PyErr_Clear();
284 if (obj && !PythonQtSlotFunction_Check(obj)) {
285 static const char* argumentList[] ={"" , "QCloseEvent*"};
286 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
287 void* args[2] = {NULL, (void*)&event};
288 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
289 if (result) { Py_DECREF(result); }
290 Py_DECREF(obj);
291 return;
292 }
293 }
294 socexplorerplugin::closeEvent(event);
295 }
296 void PythonQtShell_socexplorerplugin::closeMe()
297 {
298 if (_wrapper) {
299 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "closeMe");
300 PyErr_Clear();
301 if (obj && !PythonQtSlotFunction_Check(obj)) {
302 static const char* argumentList[] ={""};
303 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
304 void* args[1] = {NULL};
305 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
306 if (result) { Py_DECREF(result); }
307 Py_DECREF(obj);
308 return;
309 }
310 }
311 socexplorerplugin::closeMe();
312 }
313 void PythonQtShell_socexplorerplugin::contextMenuEvent(QContextMenuEvent* arg__1)
314 {
315 if (_wrapper) {
316 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "contextMenuEvent");
317 PyErr_Clear();
318 if (obj && !PythonQtSlotFunction_Check(obj)) {
319 static const char* argumentList[] ={"" , "QContextMenuEvent*"};
320 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
321 void* args[2] = {NULL, (void*)&arg__1};
322 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
323 if (result) { Py_DECREF(result); }
324 Py_DECREF(obj);
325 return;
326 }
327 }
328 socexplorerplugin::contextMenuEvent(arg__1);
329 }
330 void PythonQtShell_socexplorerplugin::customEvent(QEvent* arg__1)
331 {
332 if (_wrapper) {
333 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "customEvent");
334 PyErr_Clear();
335 if (obj && !PythonQtSlotFunction_Check(obj)) {
336 static const char* argumentList[] ={"" , "QEvent*"};
337 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
338 void* args[2] = {NULL, (void*)&arg__1};
339 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
340 if (result) { Py_DECREF(result); }
341 Py_DECREF(obj);
342 return;
343 }
344 }
345 socexplorerplugin::customEvent(arg__1);
346 }
347 int PythonQtShell_socexplorerplugin::devType() const
348 {
349 if (_wrapper) {
350 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "devType");
351 PyErr_Clear();
352 if (obj && !PythonQtSlotFunction_Check(obj)) {
353 static const char* argumentList[] ={"int"};
354 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
355 int returnValue;
356 void* args[1] = {NULL};
357 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
358 if (result) {
359 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
360 if (args[0]!=&returnValue) {
361 if (args[0]==NULL) {
362 PythonQt::priv()->handleVirtualOverloadReturnError("devType", methodInfo, result);
363 } else {
364 returnValue = *((int*)args[0]);
365 }
366 }
367 }
368 if (result) { Py_DECREF(result); }
369 Py_DECREF(obj);
370 return returnValue;
371 }
372 }
373 return socexplorerplugin::devType();
374 }
375 void PythonQtShell_socexplorerplugin::dragEnterEvent(QDragEnterEvent* arg__1)
376 {
377 if (_wrapper) {
378 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragEnterEvent");
379 PyErr_Clear();
380 if (obj && !PythonQtSlotFunction_Check(obj)) {
381 static const char* argumentList[] ={"" , "QDragEnterEvent*"};
382 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
383 void* args[2] = {NULL, (void*)&arg__1};
384 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
385 if (result) { Py_DECREF(result); }
386 Py_DECREF(obj);
387 return;
388 }
389 }
390 socexplorerplugin::dragEnterEvent(arg__1);
391 }
392 void PythonQtShell_socexplorerplugin::dragLeaveEvent(QDragLeaveEvent* arg__1)
393 {
394 if (_wrapper) {
395 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragLeaveEvent");
396 PyErr_Clear();
397 if (obj && !PythonQtSlotFunction_Check(obj)) {
398 static const char* argumentList[] ={"" , "QDragLeaveEvent*"};
399 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
400 void* args[2] = {NULL, (void*)&arg__1};
401 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
402 if (result) { Py_DECREF(result); }
403 Py_DECREF(obj);
404 return;
405 }
406 }
407 socexplorerplugin::dragLeaveEvent(arg__1);
408 }
409 void PythonQtShell_socexplorerplugin::dragMoveEvent(QDragMoveEvent* arg__1)
410 {
411 if (_wrapper) {
412 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragMoveEvent");
413 PyErr_Clear();
414 if (obj && !PythonQtSlotFunction_Check(obj)) {
415 static const char* argumentList[] ={"" , "QDragMoveEvent*"};
416 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
417 void* args[2] = {NULL, (void*)&arg__1};
418 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
419 if (result) { Py_DECREF(result); }
420 Py_DECREF(obj);
421 return;
422 }
423 }
424 socexplorerplugin::dragMoveEvent(arg__1);
425 }
426 void PythonQtShell_socexplorerplugin::dropEvent(QDropEvent* arg__1)
427 {
428 if (_wrapper) {
429 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dropEvent");
430 PyErr_Clear();
431 if (obj && !PythonQtSlotFunction_Check(obj)) {
432 static const char* argumentList[] ={"" , "QDropEvent*"};
433 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
434 void* args[2] = {NULL, (void*)&arg__1};
435 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
436 if (result) { Py_DECREF(result); }
437 Py_DECREF(obj);
438 return;
439 }
440 }
441 socexplorerplugin::dropEvent(arg__1);
442 }
443 void PythonQtShell_socexplorerplugin::enterEvent(QEvent* arg__1)
444 {
445 if (_wrapper) {
446 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "enterEvent");
447 PyErr_Clear();
448 if (obj && !PythonQtSlotFunction_Check(obj)) {
449 static const char* argumentList[] ={"" , "QEvent*"};
450 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
451 void* args[2] = {NULL, (void*)&arg__1};
452 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
453 if (result) { Py_DECREF(result); }
454 Py_DECREF(obj);
455 return;
456 }
457 }
458 socexplorerplugin::enterEvent(arg__1);
459 }
460 bool PythonQtShell_socexplorerplugin::event(QEvent* event)
461 {
462 if (_wrapper) {
463 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "event");
464 PyErr_Clear();
465 if (obj && !PythonQtSlotFunction_Check(obj)) {
466 static const char* argumentList[] ={"bool" , "QEvent*"};
467 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
468 bool returnValue;
469 void* args[2] = {NULL, (void*)&event};
470 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
471 if (result) {
472 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
473 if (args[0]!=&returnValue) {
474 if (args[0]==NULL) {
475 PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
476 } else {
477 returnValue = *((bool*)args[0]);
478 }
479 }
480 }
481 if (result) { Py_DECREF(result); }
482 Py_DECREF(obj);
483 return returnValue;
484 }
485 }
486 return socexplorerplugin::event(event);
487 }
488 bool PythonQtShell_socexplorerplugin::eventFilter(QObject* arg__1, QEvent* arg__2)
489 {
490 if (_wrapper) {
491 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "eventFilter");
492 PyErr_Clear();
493 if (obj && !PythonQtSlotFunction_Check(obj)) {
494 static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
495 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
496 bool returnValue;
497 void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2};
498 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
499 if (result) {
500 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
501 if (args[0]!=&returnValue) {
502 if (args[0]==NULL) {
503 PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
504 } else {
505 returnValue = *((bool*)args[0]);
506 }
507 }
508 }
509 if (result) { Py_DECREF(result); }
510 Py_DECREF(obj);
511 return returnValue;
512 }
513 }
514 return socexplorerplugin::eventFilter(arg__1, arg__2);
515 }
516 void PythonQtShell_socexplorerplugin::focusInEvent(QFocusEvent* arg__1)
517 {
518 if (_wrapper) {
519 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusInEvent");
520 PyErr_Clear();
521 if (obj && !PythonQtSlotFunction_Check(obj)) {
522 static const char* argumentList[] ={"" , "QFocusEvent*"};
523 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
524 void* args[2] = {NULL, (void*)&arg__1};
525 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
526 if (result) { Py_DECREF(result); }
527 Py_DECREF(obj);
528 return;
529 }
530 }
531 socexplorerplugin::focusInEvent(arg__1);
532 }
533 bool PythonQtShell_socexplorerplugin::focusNextPrevChild(bool next)
534 {
535 if (_wrapper) {
536 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusNextPrevChild");
537 PyErr_Clear();
538 if (obj && !PythonQtSlotFunction_Check(obj)) {
539 static const char* argumentList[] ={"bool" , "bool"};
540 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
541 bool returnValue;
542 void* args[2] = {NULL, (void*)&next};
543 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
544 if (result) {
545 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
546 if (args[0]!=&returnValue) {
547 if (args[0]==NULL) {
548 PythonQt::priv()->handleVirtualOverloadReturnError("focusNextPrevChild", methodInfo, result);
549 } else {
550 returnValue = *((bool*)args[0]);
551 }
552 }
553 }
554 if (result) { Py_DECREF(result); }
555 Py_DECREF(obj);
556 return returnValue;
557 }
558 }
559 return socexplorerplugin::focusNextPrevChild(next);
560 }
561 void PythonQtShell_socexplorerplugin::focusOutEvent(QFocusEvent* arg__1)
562 {
563 if (_wrapper) {
564 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusOutEvent");
565 PyErr_Clear();
566 if (obj && !PythonQtSlotFunction_Check(obj)) {
567 static const char* argumentList[] ={"" , "QFocusEvent*"};
568 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
569 void* args[2] = {NULL, (void*)&arg__1};
570 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
571 if (result) { Py_DECREF(result); }
572 Py_DECREF(obj);
573 return;
574 }
575 }
576 socexplorerplugin::focusOutEvent(arg__1);
577 }
578 bool PythonQtShell_socexplorerplugin::hasHeightForWidth() const
579 {
580 if (_wrapper) {
581 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hasHeightForWidth");
582 PyErr_Clear();
583 if (obj && !PythonQtSlotFunction_Check(obj)) {
584 static const char* argumentList[] ={"bool"};
585 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
586 bool returnValue;
587 void* args[1] = {NULL};
588 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
589 if (result) {
590 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
591 if (args[0]!=&returnValue) {
592 if (args[0]==NULL) {
593 PythonQt::priv()->handleVirtualOverloadReturnError("hasHeightForWidth", methodInfo, result);
594 } else {
595 returnValue = *((bool*)args[0]);
596 }
597 }
598 }
599 if (result) { Py_DECREF(result); }
600 Py_DECREF(obj);
601 return returnValue;
602 }
603 }
604 return socexplorerplugin::hasHeightForWidth();
605 }
606 int PythonQtShell_socexplorerplugin::heightForWidth(int arg__1) const
607 {
608 if (_wrapper) {
609 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "heightForWidth");
610 PyErr_Clear();
611 if (obj && !PythonQtSlotFunction_Check(obj)) {
612 static const char* argumentList[] ={"int" , "int"};
613 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
614 int returnValue;
615 void* args[2] = {NULL, (void*)&arg__1};
616 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
617 if (result) {
618 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
619 if (args[0]!=&returnValue) {
620 if (args[0]==NULL) {
621 PythonQt::priv()->handleVirtualOverloadReturnError("heightForWidth", methodInfo, result);
622 } else {
623 returnValue = *((int*)args[0]);
624 }
625 }
626 }
627 if (result) { Py_DECREF(result); }
628 Py_DECREF(obj);
629 return returnValue;
630 }
631 }
632 return socexplorerplugin::heightForWidth(arg__1);
633 }
634 void PythonQtShell_socexplorerplugin::hideEvent(QHideEvent* arg__1)
635 {
636 if (_wrapper) {
637 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hideEvent");
638 PyErr_Clear();
639 if (obj && !PythonQtSlotFunction_Check(obj)) {
640 static const char* argumentList[] ={"" , "QHideEvent*"};
641 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
642 void* args[2] = {NULL, (void*)&arg__1};
643 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
644 if (result) { Py_DECREF(result); }
645 Py_DECREF(obj);
646 return;
647 }
648 }
649 socexplorerplugin::hideEvent(arg__1);
650 }
651 void PythonQtShell_socexplorerplugin::initPainter(QPainter* painter) const
652 {
653 if (_wrapper) {
654 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "initPainter");
655 PyErr_Clear();
656 if (obj && !PythonQtSlotFunction_Check(obj)) {
657 static const char* argumentList[] ={"" , "QPainter*"};
658 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
659 void* args[2] = {NULL, (void*)&painter};
660 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
661 if (result) { Py_DECREF(result); }
662 Py_DECREF(obj);
663 return;
664 }
665 }
666 socexplorerplugin::initPainter(painter);
667 }
668 void PythonQtShell_socexplorerplugin::inputMethodEvent(QInputMethodEvent* arg__1)
669 {
670 if (_wrapper) {
671 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodEvent");
672 PyErr_Clear();
673 if (obj && !PythonQtSlotFunction_Check(obj)) {
674 static const char* argumentList[] ={"" , "QInputMethodEvent*"};
675 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
676 void* args[2] = {NULL, (void*)&arg__1};
677 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
678 if (result) { Py_DECREF(result); }
679 Py_DECREF(obj);
680 return;
681 }
682 }
683 socexplorerplugin::inputMethodEvent(arg__1);
684 }
685 QVariant PythonQtShell_socexplorerplugin::inputMethodQuery(Qt::InputMethodQuery arg__1) const
686 {
687 if (_wrapper) {
688 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodQuery");
689 PyErr_Clear();
690 if (obj && !PythonQtSlotFunction_Check(obj)) {
691 static const char* argumentList[] ={"QVariant" , "Qt::InputMethodQuery"};
692 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
693 QVariant returnValue;
694 void* args[2] = {NULL, (void*)&arg__1};
695 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
696 if (result) {
697 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
698 if (args[0]!=&returnValue) {
699 if (args[0]==NULL) {
700 PythonQt::priv()->handleVirtualOverloadReturnError("inputMethodQuery", methodInfo, result);
701 } else {
702 returnValue = *((QVariant*)args[0]);
703 }
704 }
705 }
706 if (result) { Py_DECREF(result); }
707 Py_DECREF(obj);
708 return returnValue;
709 }
710 }
711 return socexplorerplugin::inputMethodQuery(arg__1);
712 }
713 int PythonQtShell_socexplorerplugin::isConnected()
714 {
715 if (_wrapper) {
716 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "isConnected");
717 PyErr_Clear();
718 if (obj && !PythonQtSlotFunction_Check(obj)) {
719 static const char* argumentList[] ={"int"};
720 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
721 int returnValue;
722 void* args[1] = {NULL};
723 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
724 if (result) {
725 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
726 if (args[0]!=&returnValue) {
727 if (args[0]==NULL) {
728 PythonQt::priv()->handleVirtualOverloadReturnError("isConnected", methodInfo, result);
729 } else {
730 returnValue = *((int*)args[0]);
731 }
732 }
733 }
734 if (result) { Py_DECREF(result); }
735 Py_DECREF(obj);
736 return returnValue;
737 }
738 }
739 return socexplorerplugin::isConnected();
740 }
741 void PythonQtShell_socexplorerplugin::keyPressEvent(QKeyEvent* arg__1)
742 {
743 if (_wrapper) {
744 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyPressEvent");
745 PyErr_Clear();
746 if (obj && !PythonQtSlotFunction_Check(obj)) {
747 static const char* argumentList[] ={"" , "QKeyEvent*"};
748 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
749 void* args[2] = {NULL, (void*)&arg__1};
750 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
751 if (result) { Py_DECREF(result); }
752 Py_DECREF(obj);
753 return;
754 }
755 }
756 socexplorerplugin::keyPressEvent(arg__1);
757 }
758 void PythonQtShell_socexplorerplugin::keyReleaseEvent(QKeyEvent* arg__1)
759 {
760 if (_wrapper) {
761 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyReleaseEvent");
762 PyErr_Clear();
763 if (obj && !PythonQtSlotFunction_Check(obj)) {
764 static const char* argumentList[] ={"" , "QKeyEvent*"};
765 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
766 void* args[2] = {NULL, (void*)&arg__1};
767 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
768 if (result) { Py_DECREF(result); }
769 Py_DECREF(obj);
770 return;
771 }
772 }
773 socexplorerplugin::keyReleaseEvent(arg__1);
774 }
775 void PythonQtShell_socexplorerplugin::leaveEvent(QEvent* arg__1)
776 {
777 if (_wrapper) {
778 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "leaveEvent");
779 PyErr_Clear();
780 if (obj && !PythonQtSlotFunction_Check(obj)) {
781 static const char* argumentList[] ={"" , "QEvent*"};
782 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
783 void* args[2] = {NULL, (void*)&arg__1};
784 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
785 if (result) { Py_DECREF(result); }
786 Py_DECREF(obj);
787 return;
788 }
789 }
790 socexplorerplugin::leaveEvent(arg__1);
791 }
792 int PythonQtShell_socexplorerplugin::metric(QPaintDevice::PaintDeviceMetric arg__1) const
793 {
794 if (_wrapper) {
795 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "metric");
796 PyErr_Clear();
797 if (obj && !PythonQtSlotFunction_Check(obj)) {
798 static const char* argumentList[] ={"int" , "QPaintDevice::PaintDeviceMetric"};
799 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
800 int returnValue;
801 void* args[2] = {NULL, (void*)&arg__1};
802 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
803 if (result) {
804 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
805 if (args[0]!=&returnValue) {
806 if (args[0]==NULL) {
807 PythonQt::priv()->handleVirtualOverloadReturnError("metric", methodInfo, result);
808 } else {
809 returnValue = *((int*)args[0]);
810 }
811 }
812 }
813 if (result) { Py_DECREF(result); }
814 Py_DECREF(obj);
815 return returnValue;
816 }
817 }
818 return socexplorerplugin::metric(arg__1);
819 }
820 QSize PythonQtShell_socexplorerplugin::minimumSizeHint() const
821 {
822 if (_wrapper) {
823 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getMinimumSizeHint");
824 PyErr_Clear();
825 if (obj && !PythonQtSlotFunction_Check(obj)) {
826 static const char* argumentList[] ={"QSize"};
827 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
828 QSize returnValue;
829 void* args[1] = {NULL};
830 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
831 if (result) {
832 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
833 if (args[0]!=&returnValue) {
834 if (args[0]==NULL) {
835 PythonQt::priv()->handleVirtualOverloadReturnError("getMinimumSizeHint", methodInfo, result);
836 } else {
837 returnValue = *((QSize*)args[0]);
838 }
839 }
840 }
841 if (result) { Py_DECREF(result); }
842 Py_DECREF(obj);
843 return returnValue;
844 }
845 }
846 return socexplorerplugin::minimumSizeHint();
847 }
848 void PythonQtShell_socexplorerplugin::mouseDoubleClickEvent(QMouseEvent* arg__1)
849 {
850 if (_wrapper) {
851 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseDoubleClickEvent");
852 PyErr_Clear();
853 if (obj && !PythonQtSlotFunction_Check(obj)) {
854 static const char* argumentList[] ={"" , "QMouseEvent*"};
855 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
856 void* args[2] = {NULL, (void*)&arg__1};
857 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
858 if (result) { Py_DECREF(result); }
859 Py_DECREF(obj);
860 return;
861 }
862 }
863 socexplorerplugin::mouseDoubleClickEvent(arg__1);
864 }
865 void PythonQtShell_socexplorerplugin::mouseMoveEvent(QMouseEvent* arg__1)
866 {
867 if (_wrapper) {
868 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseMoveEvent");
869 PyErr_Clear();
870 if (obj && !PythonQtSlotFunction_Check(obj)) {
871 static const char* argumentList[] ={"" , "QMouseEvent*"};
872 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
873 void* args[2] = {NULL, (void*)&arg__1};
874 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
875 if (result) { Py_DECREF(result); }
876 Py_DECREF(obj);
877 return;
878 }
879 }
880 socexplorerplugin::mouseMoveEvent(arg__1);
881 }
882 void PythonQtShell_socexplorerplugin::mousePressEvent(QMouseEvent* arg__1)
883 {
884 if (_wrapper) {
885 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mousePressEvent");
886 PyErr_Clear();
887 if (obj && !PythonQtSlotFunction_Check(obj)) {
888 static const char* argumentList[] ={"" , "QMouseEvent*"};
889 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
890 void* args[2] = {NULL, (void*)&arg__1};
891 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
892 if (result) { Py_DECREF(result); }
893 Py_DECREF(obj);
894 return;
895 }
896 }
897 socexplorerplugin::mousePressEvent(arg__1);
898 }
899 void PythonQtShell_socexplorerplugin::mouseReleaseEvent(QMouseEvent* arg__1)
900 {
901 if (_wrapper) {
902 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseReleaseEvent");
903 PyErr_Clear();
904 if (obj && !PythonQtSlotFunction_Check(obj)) {
905 static const char* argumentList[] ={"" , "QMouseEvent*"};
906 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
907 void* args[2] = {NULL, (void*)&arg__1};
908 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
909 if (result) { Py_DECREF(result); }
910 Py_DECREF(obj);
911 return;
912 }
913 }
914 socexplorerplugin::mouseReleaseEvent(arg__1);
915 }
916 void PythonQtShell_socexplorerplugin::moveEvent(QMoveEvent* arg__1)
917 {
918 if (_wrapper) {
919 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "moveEvent");
920 PyErr_Clear();
921 if (obj && !PythonQtSlotFunction_Check(obj)) {
922 static const char* argumentList[] ={"" , "QMoveEvent*"};
923 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
924 void* args[2] = {NULL, (void*)&arg__1};
925 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
926 if (result) { Py_DECREF(result); }
927 Py_DECREF(obj);
928 return;
929 }
930 }
931 socexplorerplugin::moveEvent(arg__1);
932 }
933 bool PythonQtShell_socexplorerplugin::nativeEvent(const QByteArray& eventType, void* message, long* result)
934 {
935 if (_wrapper) {
936 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "nativeEvent");
937 PyErr_Clear();
938 if (obj && !PythonQtSlotFunction_Check(obj)) {
939 static const char* argumentList[] ={"bool" , "const QByteArray&" , "void*" , "long*"};
940 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
941 bool returnValue;
942 void* args[4] = {NULL, (void*)&eventType, (void*)&message, (void*)&result};
943 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
944 if (result) {
945 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
946 if (args[0]!=&returnValue) {
947 if (args[0]==NULL) {
948 PythonQt::priv()->handleVirtualOverloadReturnError("nativeEvent", methodInfo, result);
949 } else {
950 returnValue = *((bool*)args[0]);
951 }
952 }
953 }
954 if (result) { Py_DECREF(result); }
955 Py_DECREF(obj);
956 return returnValue;
957 }
958 }
959 return socexplorerplugin::nativeEvent(eventType, message, result);
960 }
961 QPaintEngine* PythonQtShell_socexplorerplugin::paintEngine() const
962 {
963 if (_wrapper) {
964 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEngine");
965 PyErr_Clear();
966 if (obj && !PythonQtSlotFunction_Check(obj)) {
967 static const char* argumentList[] ={"QPaintEngine*"};
968 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
969 QPaintEngine* returnValue;
970 void* args[1] = {NULL};
971 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
972 if (result) {
973 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
974 if (args[0]!=&returnValue) {
975 if (args[0]==NULL) {
976 PythonQt::priv()->handleVirtualOverloadReturnError("paintEngine", methodInfo, result);
977 } else {
978 returnValue = *((QPaintEngine**)args[0]);
979 }
980 }
981 }
982 if (result) { Py_DECREF(result); }
983 Py_DECREF(obj);
984 return returnValue;
985 }
986 }
987 return socexplorerplugin::paintEngine();
988 }
989 void PythonQtShell_socexplorerplugin::paintEvent(QPaintEvent* event)
990 {
991 if (_wrapper) {
992 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEvent");
993 PyErr_Clear();
994 if (obj && !PythonQtSlotFunction_Check(obj)) {
995 static const char* argumentList[] ={"" , "QPaintEvent*"};
996 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
997 void* args[2] = {NULL, (void*)&event};
998 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
999 if (result) { Py_DECREF(result); }
1000 Py_DECREF(obj);
1001 return;
1002 }
1003 }
1004 socexplorerplugin::paintEvent(event);
1005 }
1006 void PythonQtShell_socexplorerplugin::postInstantiationTrigger()
1007 {
1008 if (_wrapper) {
1009 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "postInstantiationTrigger");
1010 PyErr_Clear();
1011 if (obj && !PythonQtSlotFunction_Check(obj)) {
1012 static const char* argumentList[] ={""};
1013 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
1014 void* args[1] = {NULL};
1015 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1016 if (result) { Py_DECREF(result); }
1017 Py_DECREF(obj);
1018 return;
1019 }
1020 }
1021 socexplorerplugin::postInstantiationTrigger();
1022 }
1023 QPaintDevice* PythonQtShell_socexplorerplugin::redirected(QPoint* offset) const
1024 {
1025 if (_wrapper) {
1026 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "redirected");
1027 PyErr_Clear();
1028 if (obj && !PythonQtSlotFunction_Check(obj)) {
1029 static const char* argumentList[] ={"QPaintDevice*" , "QPoint*"};
1030 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1031 QPaintDevice* returnValue;
1032 void* args[2] = {NULL, (void*)&offset};
1033 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1034 if (result) {
1035 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1036 if (args[0]!=&returnValue) {
1037 if (args[0]==NULL) {
1038 PythonQt::priv()->handleVirtualOverloadReturnError("redirected", methodInfo, result);
1039 } else {
1040 returnValue = *((QPaintDevice**)args[0]);
1041 }
1042 }
1043 }
1044 if (result) { Py_DECREF(result); }
1045 Py_DECREF(obj);
1046 return returnValue;
1047 }
1048 }
1049 return socexplorerplugin::redirected(offset);
1050 }
1051 int PythonQtShell_socexplorerplugin::registermenu(QMenu* menu)
1052 {
1053 if (_wrapper) {
1054 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "registermenu");
1055 PyErr_Clear();
1056 if (obj && !PythonQtSlotFunction_Check(obj)) {
1057 static const char* argumentList[] ={"int" , "QMenu*"};
1058 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1059 int returnValue;
1060 void* args[2] = {NULL, (void*)&menu};
1061 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1062 if (result) {
1063 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1064 if (args[0]!=&returnValue) {
1065 if (args[0]==NULL) {
1066 PythonQt::priv()->handleVirtualOverloadReturnError("registermenu", methodInfo, result);
1067 } else {
1068 returnValue = *((int*)args[0]);
1069 }
1070 }
1071 }
1072 if (result) { Py_DECREF(result); }
1073 Py_DECREF(obj);
1074 return returnValue;
1075 }
1076 }
1077 return socexplorerplugin::registermenu(menu);
1078 }
1079 void PythonQtShell_socexplorerplugin::resizeEvent(QResizeEvent* arg__1)
1080 {
1081 if (_wrapper) {
1082 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "resizeEvent");
1083 PyErr_Clear();
1084 if (obj && !PythonQtSlotFunction_Check(obj)) {
1085 static const char* argumentList[] ={"" , "QResizeEvent*"};
1086 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1087 void* args[2] = {NULL, (void*)&arg__1};
1088 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1089 if (result) { Py_DECREF(result); }
1090 Py_DECREF(obj);
1091 return;
1092 }
1093 }
1094 socexplorerplugin::resizeEvent(arg__1);
1095 }
1096 void PythonQtShell_socexplorerplugin::setBaseAddress(unsigned int baseAddress)
1097 {
1098 if (_wrapper) {
1099 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "setBaseAddress");
1100 PyErr_Clear();
1101 if (obj && !PythonQtSlotFunction_Check(obj)) {
1102 static const char* argumentList[] ={"" , "unsigned int"};
1103 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1104 void* args[2] = {NULL, (void*)&baseAddress};
1105 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1106 if (result) { Py_DECREF(result); }
1107 Py_DECREF(obj);
1108 return;
1109 }
1110 }
1111 socexplorerplugin::setBaseAddress(baseAddress);
1112 }
1113 void PythonQtShell_socexplorerplugin::setInstanceName(const QString& newName)
1114 {
1115 if (_wrapper) {
1116 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "setInstanceName");
1117 PyErr_Clear();
1118 if (obj && !PythonQtSlotFunction_Check(obj)) {
1119 static const char* argumentList[] ={"" , "const QString&"};
1120 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1121 void* args[2] = {NULL, (void*)&newName};
1122 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1123 if (result) { Py_DECREF(result); }
1124 Py_DECREF(obj);
1125 return;
1126 }
1127 }
1128 socexplorerplugin::setInstanceName(newName);
1129 }
1130 QPainter* PythonQtShell_socexplorerplugin::sharedPainter() const
1131 {
1132 if (_wrapper) {
1133 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "sharedPainter");
1134 PyErr_Clear();
1135 if (obj && !PythonQtSlotFunction_Check(obj)) {
1136 static const char* argumentList[] ={"QPainter*"};
1137 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
1138 QPainter* returnValue;
1139 void* args[1] = {NULL};
1140 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1141 if (result) {
1142 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1143 if (args[0]!=&returnValue) {
1144 if (args[0]==NULL) {
1145 PythonQt::priv()->handleVirtualOverloadReturnError("sharedPainter", methodInfo, result);
1146 } else {
1147 returnValue = *((QPainter**)args[0]);
1148 }
1149 }
1150 }
1151 if (result) { Py_DECREF(result); }
1152 Py_DECREF(obj);
1153 return returnValue;
1154 }
1155 }
1156 return socexplorerplugin::sharedPainter();
1157 }
1158 void PythonQtShell_socexplorerplugin::showEvent(QShowEvent* arg__1)
1159 {
1160 if (_wrapper) {
1161 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "showEvent");
1162 PyErr_Clear();
1163 if (obj && !PythonQtSlotFunction_Check(obj)) {
1164 static const char* argumentList[] ={"" , "QShowEvent*"};
1165 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1166 void* args[2] = {NULL, (void*)&arg__1};
1167 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1168 if (result) { Py_DECREF(result); }
1169 Py_DECREF(obj);
1170 return;
1171 }
1172 }
1173 socexplorerplugin::showEvent(arg__1);
1174 }
1175 QSize PythonQtShell_socexplorerplugin::sizeHint() const
1176 {
1177 if (_wrapper) {
1178 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getSizeHint");
1179 PyErr_Clear();
1180 if (obj && !PythonQtSlotFunction_Check(obj)) {
1181 static const char* argumentList[] ={"QSize"};
1182 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
1183 QSize returnValue;
1184 void* args[1] = {NULL};
1185 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1186 if (result) {
1187 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1188 if (args[0]!=&returnValue) {
1189 if (args[0]==NULL) {
1190 PythonQt::priv()->handleVirtualOverloadReturnError("getSizeHint", methodInfo, result);
1191 } else {
1192 returnValue = *((QSize*)args[0]);
1193 }
1194 }
1195 }
1196 if (result) { Py_DECREF(result); }
1197 Py_DECREF(obj);
1198 return returnValue;
1199 }
1200 }
1201 return socexplorerplugin::sizeHint();
1202 }
1203 void PythonQtShell_socexplorerplugin::tabletEvent(QTabletEvent* arg__1)
1204 {
1205 if (_wrapper) {
1206 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "tabletEvent");
1207 PyErr_Clear();
1208 if (obj && !PythonQtSlotFunction_Check(obj)) {
1209 static const char* argumentList[] ={"" , "QTabletEvent*"};
1210 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1211 void* args[2] = {NULL, (void*)&arg__1};
1212 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1213 if (result) { Py_DECREF(result); }
1214 Py_DECREF(obj);
1215 return;
1216 }
1217 }
1218 socexplorerplugin::tabletEvent(arg__1);
1219 }
1220 void PythonQtShell_socexplorerplugin::timerEvent(QTimerEvent* arg__1)
1221 {
1222 if (_wrapper) {
1223 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "timerEvent");
1224 PyErr_Clear();
1225 if (obj && !PythonQtSlotFunction_Check(obj)) {
1226 static const char* argumentList[] ={"" , "QTimerEvent*"};
1227 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1228 void* args[2] = {NULL, (void*)&arg__1};
1229 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1230 if (result) { Py_DECREF(result); }
1231 Py_DECREF(obj);
1232 return;
1233 }
1234 }
1235 socexplorerplugin::timerEvent(arg__1);
1236 }
1237 void PythonQtShell_socexplorerplugin::wheelEvent(QWheelEvent* arg__1)
1238 {
1239 if (_wrapper) {
1240 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "wheelEvent");
1241 PyErr_Clear();
1242 if (obj && !PythonQtSlotFunction_Check(obj)) {
1243 static const char* argumentList[] ={"" , "QWheelEvent*"};
1244 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1245 void* args[2] = {NULL, (void*)&arg__1};
1246 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1247 if (result) { Py_DECREF(result); }
1248 Py_DECREF(obj);
1249 return;
1250 }
1251 }
1252 socexplorerplugin::wheelEvent(arg__1);
1253 }
1254 socexplorerplugin* PythonQtWrapper_socexplorerplugin::new_socexplorerplugin(QWidget* parent, bool createPyObject)
1255 {
1256 return new PythonQtShell_socexplorerplugin(parent, createPyObject); }
1257
1258 int PythonQtWrapper_socexplorerplugin::PID(socexplorerplugin* theWrappedObject)
1259 {
1260 return ( ((PythonQtPublicPromoter_socexplorerplugin*)theWrappedObject)->promoted_PID());
1261 }
1262
1263 unsigned int PythonQtWrapper_socexplorerplugin::Read(socexplorerplugin* theWrappedObject, unsigned int* Value, unsigned int count, unsigned int address)
1264 {
1265 return ( ((PythonQtPublicPromoter_socexplorerplugin*)theWrappedObject)->promoted_Read(Value, count, address));
1266 }
1267
1268 int PythonQtWrapper_socexplorerplugin::VID(socexplorerplugin* theWrappedObject)
1269 {
1270 return ( ((PythonQtPublicPromoter_socexplorerplugin*)theWrappedObject)->promoted_VID());
1271 }
1272
1273 unsigned int PythonQtWrapper_socexplorerplugin::Write(socexplorerplugin* theWrappedObject, unsigned int* Value, unsigned int count, unsigned int address)
1274 {
1275 return ( ((PythonQtPublicPromoter_socexplorerplugin*)theWrappedObject)->promoted_Write(Value, count, address));
1276 }
1277
1278 void PythonQtWrapper_socexplorerplugin::activate(socexplorerplugin* theWrappedObject, bool flag)
1279 {
1280 ( ((PythonQtPublicPromoter_socexplorerplugin*)theWrappedObject)->promoted_activate(flag));
1281 }
1282
1283 int PythonQtWrapper_socexplorerplugin::baseAddress(socexplorerplugin* theWrappedObject)
1284 {
1285 return ( ((PythonQtPublicPromoter_socexplorerplugin*)theWrappedObject)->promoted_baseAddress());
1286 }
1287
1288 QString PythonQtWrapper_socexplorerplugin::baseName(socexplorerplugin* theWrappedObject)
1289 {
1290 return ( ((PythonQtPublicPromoter_socexplorerplugin*)theWrappedObject)->promoted_baseName());
1291 }
1292
1293 void PythonQtWrapper_socexplorerplugin::closeMe(socexplorerplugin* theWrappedObject)
1294 {
1295 ( ((PythonQtPublicPromoter_socexplorerplugin*)theWrappedObject)->promoted_closeMe());
1296 }
1297
1298 QString PythonQtWrapper_socexplorerplugin::instanceName(socexplorerplugin* theWrappedObject)
1299 {
1300 return ( theWrappedObject->instanceName());
1301 }
1302
1303 int PythonQtWrapper_socexplorerplugin::isConnected(socexplorerplugin* theWrappedObject)
1304 {
1305 return ( ((PythonQtPublicPromoter_socexplorerplugin*)theWrappedObject)->promoted_isConnected());
1306 }
1307
1308 void PythonQtWrapper_socexplorerplugin::postInstantiationTrigger(socexplorerplugin* theWrappedObject)
1309 {
1310 ( ((PythonQtPublicPromoter_socexplorerplugin*)theWrappedObject)->promoted_postInstantiationTrigger());
1311 }
1312
1313 int PythonQtWrapper_socexplorerplugin::registermenu(socexplorerplugin* theWrappedObject, QMenu* menu)
1314 {
1315 return ( ((PythonQtPublicPromoter_socexplorerplugin*)theWrappedObject)->promoted_registermenu(menu));
1316 }
1317
1318 void PythonQtWrapper_socexplorerplugin::setBaseAddress(socexplorerplugin* theWrappedObject, unsigned int baseAddress)
1319 {
1320 ( ((PythonQtPublicPromoter_socexplorerplugin*)theWrappedObject)->promoted_setBaseAddress(baseAddress));
1321 }
1322
1323 void PythonQtWrapper_socexplorerplugin::setInstanceName(socexplorerplugin* theWrappedObject, const QString& newName)
1324 {
1325 ( ((PythonQtPublicPromoter_socexplorerplugin*)theWrappedObject)->promoted_setInstanceName(newName));
1326 }
1327
1328
Show file before | Show file after | Hide comments
@@ -0,0 +1,156
1 #include <PythonQt.h>
2 #include <QIconEngine>
3 #include <QObject>
4 #include <QVariant>
5 #include <qaction.h>
6 #include <qbitmap.h>
7 #include <qbytearray.h>
8 #include <qcoreevent.h>
9 #include <qcursor.h>
10 #include <qdockwidget.h>
11 #include <qevent.h>
12 #include <qfont.h>
13 #include <qgraphicseffect.h>
14 #include <qgraphicsproxywidget.h>
15 #include <qkeysequence.h>
16 #include <qlayout.h>
17 #include <qlist.h>
18 #include <qlocale.h>
19 #include <qmargins.h>
20 #include <qmenu.h>
21 #include <qobject.h>
22 #include <qpaintdevice.h>
23 #include <qpaintengine.h>
24 #include <qpainter.h>
25 #include <qpalette.h>
26 #include <qpixmap.h>
27 #include <qpoint.h>
28 #include <qrect.h>
29 #include <qregion.h>
30 #include <qsize.h>
31 #include <qsizepolicy.h>
32 #include <qstyle.h>
33 #include <qstyleoption.h>
34 #include <qwidget.h>
35 #include <socexplorerplugin.h>
36
37
38
39 class PythonQtShell_socexplorerplugin : public socexplorerplugin
40 {
41 public:
42 PythonQtShell_socexplorerplugin(QWidget* parent = 0, bool createPyObject = true):socexplorerplugin(parent, createPyObject),_wrapper(NULL) {};
43
44 ~PythonQtShell_socexplorerplugin();
45
46 virtual int PID();
47 virtual unsigned int Read(unsigned int* Value, unsigned int count, unsigned int address);
48 virtual int VID();
49 virtual unsigned int Write(unsigned int* Value, unsigned int count, unsigned int address);
50 virtual void actionEvent(QActionEvent* arg__1);
51 virtual void activate(bool flag);
52 virtual int baseAddress();
53 virtual QString baseName();
54 virtual void changeEvent(QEvent* event);
55 virtual void childEvent(QChildEvent* arg__1);
56 virtual void closeEvent(QCloseEvent* event);
57 virtual void closeMe();
58 virtual void contextMenuEvent(QContextMenuEvent* arg__1);
59 virtual void customEvent(QEvent* arg__1);
60 virtual int devType() const;
61 virtual void dragEnterEvent(QDragEnterEvent* arg__1);
62 virtual void dragLeaveEvent(QDragLeaveEvent* arg__1);
63 virtual void dragMoveEvent(QDragMoveEvent* arg__1);
64 virtual void dropEvent(QDropEvent* arg__1);
65 virtual void enterEvent(QEvent* arg__1);
66 virtual bool event(QEvent* event);
67 virtual bool eventFilter(QObject* arg__1, QEvent* arg__2);
68 virtual void focusInEvent(QFocusEvent* arg__1);
69 virtual bool focusNextPrevChild(bool next);
70 virtual void focusOutEvent(QFocusEvent* arg__1);
71 virtual bool hasHeightForWidth() const;
72 virtual int heightForWidth(int arg__1) const;
73 virtual void hideEvent(QHideEvent* arg__1);
74 virtual void initPainter(QPainter* painter) const;
75 virtual void inputMethodEvent(QInputMethodEvent* arg__1);
76 virtual QVariant inputMethodQuery(Qt::InputMethodQuery arg__1) const;
77 virtual int isConnected();
78 virtual void keyPressEvent(QKeyEvent* arg__1);
79 virtual void keyReleaseEvent(QKeyEvent* arg__1);
80 virtual void leaveEvent(QEvent* arg__1);
81 virtual int metric(QPaintDevice::PaintDeviceMetric arg__1) const;
82 virtual QSize minimumSizeHint() const;
83 virtual void mouseDoubleClickEvent(QMouseEvent* arg__1);
84 virtual void mouseMoveEvent(QMouseEvent* arg__1);
85 virtual void mousePressEvent(QMouseEvent* arg__1);
86 virtual void mouseReleaseEvent(QMouseEvent* arg__1);
87 virtual void moveEvent(QMoveEvent* arg__1);
88 virtual bool nativeEvent(const QByteArray& eventType, void* message, long* result);
89 virtual QPaintEngine* paintEngine() const;
90 virtual void paintEvent(QPaintEvent* event);
91 virtual void postInstantiationTrigger();
92 virtual QPaintDevice* redirected(QPoint* offset) const;
93 virtual int registermenu(QMenu* menu);
94 virtual void resizeEvent(QResizeEvent* arg__1);
95 virtual void setBaseAddress(unsigned int baseAddress);
96 virtual void setInstanceName(const QString& newName);
97 virtual QPainter* sharedPainter() const;
98 virtual void showEvent(QShowEvent* arg__1);
99 virtual QSize sizeHint() const;
100 virtual void tabletEvent(QTabletEvent* arg__1);
101 virtual void timerEvent(QTimerEvent* arg__1);
102 virtual void wheelEvent(QWheelEvent* arg__1);
103
104 PythonQtInstanceWrapper* _wrapper;
105 };
106
107 class PythonQtPublicPromoter_socexplorerplugin : public socexplorerplugin
108 { public:
109 inline int promoted_PID() { return socexplorerplugin::PID(); }
110 inline unsigned int promoted_Read(unsigned int* Value, unsigned int count, unsigned int address) { return socexplorerplugin::Read(Value, count, address); }
111 inline int promoted_VID() { return socexplorerplugin::VID(); }
112 inline unsigned int promoted_Write(unsigned int* Value, unsigned int count, unsigned int address) { return socexplorerplugin::Write(Value, count, address); }
113 inline void promoted_activate(bool flag) { socexplorerplugin::activate(flag); }
114 inline int promoted_baseAddress() { return socexplorerplugin::baseAddress(); }
115 inline QString promoted_baseName() { return socexplorerplugin::baseName(); }
116 inline void promoted_closeMe() { socexplorerplugin::closeMe(); }
117 inline int promoted_isConnected() { return socexplorerplugin::isConnected(); }
118 inline void promoted_postInstantiationTrigger() { socexplorerplugin::postInstantiationTrigger(); }
119 inline int promoted_registermenu(QMenu* menu) { return socexplorerplugin::registermenu(menu); }
120 inline void promoted_setBaseAddress(unsigned int baseAddress) { socexplorerplugin::setBaseAddress(baseAddress); }
121 inline void promoted_setInstanceName(const QString& newName) { socexplorerplugin::setInstanceName(newName); }
122 };
123
124 class PythonQtWrapper_socexplorerplugin : public QObject
125 { Q_OBJECT
126 public:
127 public slots:
128 socexplorerplugin* new_socexplorerplugin(QWidget* parent = 0, bool createPyObject = true);
129 void delete_socexplorerplugin(socexplorerplugin* obj) { delete obj; }
130 int PID(socexplorerplugin* theWrappedObject);
131 unsigned int Read(socexplorerplugin* theWrappedObject, unsigned int* Value, unsigned int count, unsigned int address);
132 int VID(socexplorerplugin* theWrappedObject);
133 unsigned int Write(socexplorerplugin* theWrappedObject, unsigned int* Value, unsigned int count, unsigned int address);
134 void activate(socexplorerplugin* theWrappedObject, bool flag);
135 int baseAddress(socexplorerplugin* theWrappedObject);
136 QString baseName(socexplorerplugin* theWrappedObject);
137 void closeMe(socexplorerplugin* theWrappedObject);
138 QString instanceName(socexplorerplugin* theWrappedObject);
139 int isConnected(socexplorerplugin* theWrappedObject);
140 void postInstantiationTrigger(socexplorerplugin* theWrappedObject);
141 int registermenu(socexplorerplugin* theWrappedObject, QMenu* menu);
142 void setBaseAddress(socexplorerplugin* theWrappedObject, unsigned int baseAddress);
143 void setInstanceName(socexplorerplugin* theWrappedObject, const QString& newName);
144 void py_set_parent(socexplorerplugin* theWrappedObject, socexplorerplugin* parent){ theWrappedObject->parent = parent; }
145 socexplorerplugin* py_get_parent(socexplorerplugin* theWrappedObject){ return theWrappedObject->parent; }
146 void py_set_menu(socexplorerplugin* theWrappedObject, QMenu* menu){ theWrappedObject->menu = menu; }
147 QMenu* py_get_menu(socexplorerplugin* theWrappedObject){ return theWrappedObject->menu; }
148 void py_set_ChildsMenu(socexplorerplugin* theWrappedObject, QMenu* ChildsMenu){ theWrappedObject->ChildsMenu = ChildsMenu; }
149 QMenu* py_get_ChildsMenu(socexplorerplugin* theWrappedObject){ return theWrappedObject->ChildsMenu; }
150 void py_set_closeAction(socexplorerplugin* theWrappedObject, QAction* closeAction){ theWrappedObject->closeAction = closeAction; }
151 QAction* py_get_closeAction(socexplorerplugin* theWrappedObject){ return theWrappedObject->closeAction; }
152 void py_set_childs(socexplorerplugin* theWrappedObject, QList<socexplorerplugin* > childs){ theWrappedObject->childs = childs; }
153 QList<socexplorerplugin* > py_get_childs(socexplorerplugin* theWrappedObject){ return theWrappedObject->childs; }
154 };
155
156
Show file before | Show file after | Hide comments
@@ -0,0 +1,8
1 #include <PythonQt.h>
2 #include "PySocExplorerEngine0.h"
3
4
5 void PythonQt_init_PySocExplorerEngine(PyObject* module) {
6 PythonQt::priv()->registerClass(&socexplorerplugin::staticMetaObject, "PySocExplorerEngine", PythonQtCreateObject<PythonQtWrapper_socexplorerplugin>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_socexplorerplugin>, module, 0);
7
8 }
Show file before | Show file after | Hide comments
@@ -0,0 +1,16
1 <typesystem package="PySocExplorerEngine" default-superclass="com.trolltech.qt.QtJambiObject">
2 <load-typesystem name=":/trolltech/generator/typesystem_core.txt" generate="no" />
3 <load-typesystem name=":/trolltech/generator/typesystem_gui.txt" generate="no" />
4 <load-typesystem name=":/trolltech/generator/typesystem_network.txt" generate="no" />
5
6 <interface-type name="socexplorerplugin"/>
7
8 </typesystem>
9
10
11
12
13
14
15
16
Show file before | Show file after | Hide comments
@@ -0,0 +1,6
1 #!/bin/bash
2
3 #export QTDIR=/usr/include
4 #export QTDIR=/usr/include/qt5
5
6 pythonqt_generator --include-paths=./plugins:/usr/include/qt5:/usr/include/qt5/QtCore:/usr/include/qt5/QtWidgets --output-directory=pythonQtOut PySocExplorerEngine.h pythonQtgeneratorCfg.txt
Show file before | Show file after | Hide comments
@@ -1,4 +1,4
1 2c82d72694590cbc2aebb946667f11f60ea89afe src/SocExplorerEngine/PeripheralWidget
1 2c82d72694590cbc2aebb946667f11f60ea89afe src/SocExplorerEngine/PeripheralWidget
2 e0f25227d6283e833fbb70c5fc1bdc6c3ca8060e src/common/genericBinaryFiles
2 e0f25227d6283e833fbb70c5fc1bdc6c3ca8060e src/common/genericBinaryFiles
3 2dce25b198558be573f56c1cf337aa95ddd666d6 src/common/lppserial
3 2dce25b198558be573f56c1cf337aa95ddd666d6 src/common/lppserial
4 a4274329c9f05c742b3eb9753e77c47d27e838e9 src/common/qhexedit
4 923afde9cc96bb419cf898560d080ec96991aeca src/common/qhexedit
Show file before | Show file after | Hide comments
@@ -1,86 +1,86
1 #-------------------------------------------------
1 #-------------------------------------------------
2 #
2 #
3 # Project created by QtCreator 2011-09-19T22:52:10
3 # Project created by QtCreator 2011-09-19T22:52:10
4 #
4 #
5 #-------------------------------------------------
5 #-------------------------------------------------
6
6
7 TEMPLATE = subdirs
7 TEMPLATE = subdirs
8 CONFIG += ordered release
8 CONFIG += ordered release
9
9
10 SUBDIRS = \
10 SUBDIRS = \
11 src/common \
11 src/common \
12 src/SocExplorerEngine \
12 src/SocExplorerEngine \
13 src \
13 src \
14 src/SocExplorer_TCP_Terminal
14 src/SocExplorer_TCP_Terminal
15
15
16
16
17 socexplorercfg.path = $$[QT_INSTALL_PREFIX]/mkspecs/features
17 socexplorercfg.path = $$[QT_INSTALL_PREFIX]/mkspecs/features
18 socexplorercfg.files = \
18 socexplorercfg.files = \
19 src/SocExplorerEngine/plugins/socexplorerplugin.prf
19 src/SocExplorerEngine/plugins/socexplorerplugin.prf
20
20
21
21
22 unix{
22 unix{
23 SocExplorer.path = /usr/share/applications/
23 SocExplorer.path = /usr/share/applications/
24 SocExplorer.files = unixcfg/SocExplorer.desktop
24 SocExplorer.files = unixcfg/SocExplorer.desktop
25 icon.path = /etc/SocExplorer
25 icon.path = /usr/share/SocExplorer
26 icon.files = ressources/images/logo-lpp-cutted.png
26 icon.files = ressources/images/Indiana_Jones_cappello.png
27 Wizard.path = /usr/share/qtcreator/templates/wizards/SocExplorerPlugin
27 Wizard.path = /usr/share/qtcreator/templates/wizards/SocExplorerPlugin
28 Wizard.files = Qt_Creator_Wizard/SocExplorerPlugin/logo-lpp-cutted.png \
28 Wizard.files = Qt_Creator_Wizard/SocExplorerPlugin/logo-lpp-cutted.png \
29 Qt_Creator_Wizard/SocExplorerPlugin/plugin.cpp \
29 Qt_Creator_Wizard/SocExplorerPlugin/plugin.cpp \
30 Qt_Creator_Wizard/SocExplorerPlugin/plugin.h \
30 Qt_Creator_Wizard/SocExplorerPlugin/plugin.h \
31 Qt_Creator_Wizard/SocExplorerPlugin/project.pro \
31 Qt_Creator_Wizard/SocExplorerPlugin/project.pro \
32 Qt_Creator_Wizard/SocExplorerPlugin/wizard.xml
32 Qt_Creator_Wizard/SocExplorerPlugin/wizard.xml
33 INSTALLS+=Wizard SocExplorer icon
33 INSTALLS+=Wizard SocExplorer icon
34 }
34 }
35 INSTALLS+=socexplorercfg
35 INSTALLS+=socexplorercfg
36
36
37
37
38
38
39
39
40
40
41
41
42
42
43
43
44
44
45
45
46
46
47
47
48
48
49
49
50
50
51
51
52
52
53
53
54
54
55
55
56
56
57
57
58
58
59
59
60
60
61
61
62
62
63
63
64
64
65
65
66
66
67
67
68
68
69
69
70
70
71
71
72
72
73
73
74
74
75
75
76
76
77
77
78
78
79
79
80
80
81
81
82
82
83
83
84
84
85
85
86
86
Show file before | Show file after | Hide comments
@@ -1,22 +1,23
1 <RCC>
1 <RCC>
2 <qresource prefix="/images">
2 <qresource prefix="/images">
3 <file alias="logolpp.png">images/logo-lpp.png</file>
3 <file alias="logolpp.png">images/logo-lpp.png</file>
4 <file alias="logocnrs.png">images/LOGO CNRS.png</file>
4 <file alias="logocnrs.png">images/LOGO CNRS.png</file>
5 <file alias="logoso.png">images/LOGO SO.png</file>
5 <file alias="logoso.png">images/LOGO SO.png</file>
6 <file alias="logolppcutted.png">images/logo-lpp-cutted.png</file>
6 <file alias="logolppcutted.png">images/logo-lpp-cutted.png</file>
7 <file alias="trash.svg">images/Gnome-user-trash.svg</file>
7 <file alias="trash.svg">images/Gnome-user-trash.svg</file>
8 <file alias="refresh.svg">images/Gnome-view-refresh.svg</file>
8 <file alias="refresh.svg">images/Gnome-view-refresh.svg</file>
9 <file alias="open.svg">images/Gnome-document-open.svg</file>
9 <file alias="open.svg">images/Gnome-document-open.svg</file>
10 <file alias="add.svg">images/Gnome-list-add.svg</file>
10 <file alias="add.svg">images/Gnome-list-add.svg</file>
11 <file alias="server.svg">images/Gnome-network-server.svg</file>
11 <file alias="server.svg">images/Gnome-network-server.svg</file>
12 <file alias="config.svg">images/Gnome-preferences-system.svg</file>
12 <file alias="config.svg">images/Gnome-preferences-system.svg</file>
13 <file alias="up.svg">images/Gnome-go-up.svg</file>
13 <file alias="up.svg">images/Gnome-go-up.svg</file>
14 <file alias="down.svg">images/Gnome-go-down.svg</file>
14 <file alias="down.svg">images/Gnome-go-down.svg</file>
15 <file alias="icon.png">images/Indiana_Jones_cappello.png</file>
15 </qresource>
16 </qresource>
16 <qresource prefix="/about">
17 <qresource prefix="/about">
17 <file alias="about.html">txt/about.html</file>
18 <file alias="about.html">txt/about.html</file>
18 </qresource>
19 </qresource>
19 <qresource prefix="/styles">
20 <qresource prefix="/styles">
20 <file alias="SocExplorer.css">Styles/SocExplorer.css</file>
21 <file alias="SocExplorer.css">Styles/SocExplorer.css</file>
21 </qresource>
22 </qresource>
22 </RCC>
23 </RCC>
Show file before | Show file after | Hide comments
@@ -1,37 +1,40
1 <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
1 <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
2 <html>
2 <html>
3 <head>
3 <head>
4 </head>
4 </head>
5 <body style="background-color : #dbdbdb;">
5 <body style="background-color : #dbdbdb;">
6
6 <div align="center">
7 <IMG src=":/images/icon.png" alt="SocExplorer" width="80" height="54" align="center" border="0" >
8 </div>
7 <div align="center">
9 <div align="center">
8 <a href="http://www.cnrs.fr/"> <IMG src=":/images/logocnrs.png" alt="CNRS" width="47" height="47" align="top" border="0" ></a>
10 <a href="http://www.cnrs.fr/"> <IMG src=":/images/logocnrs.png" alt="CNRS" width="47" height="47" align="top" border="0" ></a>
9 <a href="http://www.lpp.fr/"> <IMG src=":/images/logolpp.png" width="158" height="47" align="top" border="0" ></a>
11 <a href="http://www.lpp.fr/"> <IMG src=":/images/logolpp.png" width="158" height="47" align="top" border="0" ></a>
10 <a href="http://www.solarorbiter.org/"> <IMG src=":/images/logoso.png" width="64" height="47" align="top" border="0" ></a>
12 <a href="http://www.solarorbiter.org/"> <IMG src=":/images/logoso.png" width="64" height="47" align="top" border="0" ></a>
11 </div>
13 </div>
12 <hr>
14 <hr>
13 <div align="center">
15 <div align="center">
14 <B style="font-size : 150%;">About SocExplorer</B>
16 <B style="font-size : 150%;">About SocExplorer</B>
15 </div>
17 </div>
16 <hr>
18 <hr>
17 <div align="center">
19 <div align="center">
18 <B>SocExplorer Version $VERSION$.</B><BR><BR>
20 <B>SocExplorer Version $VERSION$.</B><BR><BR>
19 <B> Build from Changeset $Changeset$.</B><BR><BR>
21 <B> Build from Changeset $Changeset$.</B><BR><BR>
20 <B> Branch $Branch$.</B><BR><BR>
22 <B> Branch $Branch$.</B><BR><BR>
21 Copyright (C) 2011-2014 Plasmas Physic Laboratory.<BR>
23 Copyright (C) 2011-2014 Plasmas Physic Laboratory.<BR>
22 This is free software; licenced under the terms of the GPLV2 license.<BR><BR>
24 This is free software; licenced under the terms of the GPLV2 license.<BR><BR>
23 This program uses:
25 This program uses:
24 <div align="left" style="margin-left : 50%;">
26 <div align="left" style="margin-left : 50%;">
25 <ul>
27 <ul>
26 <LI><a href="http://qt.digia.com/" title="Qt">Qt</a> (Copyright 2008-2014 Digia Plc).</LI>
28 <LI><a href="http://qt.digia.com/" title="Qt">Qt</a> (Copyright 2008-2014 Digia Plc).</LI>
27 <LI><a href="http://pythonqt.sourceforge.net" title="PythonQt">PythonQt</a> </LI>
29 <LI><a href="http://pythonqt.sourceforge.net" title="PythonQt">PythonQt</a> </LI>
28 <LI><a href="http://commons.wikimedia.org/wiki/GNOME_Desktop_icons" title="Gnome Icons">Gnome Icons</a> </LI>
30 <LI><a href="http://commons.wikimedia.org/wiki/GNOME_Desktop_icons" title="Gnome Icons">Gnome Icons</a> </LI>
29 <LI><a href="http://nsis.sourceforge.net/Main_Page" title="NSIS">NSIS</a> (Nullsoft Scriptable Install System) </LI>
31 <LI><a href="http://nsis.sourceforge.net/Main_Page" title="NSIS">NSIS</a> (Nullsoft Scriptable Install System) </LI>
30 <LI><a href="https://hephaistos.lpp.polytechnique.fr/rhodecode/HG_REPOSITORIES/LPP/INSTRUMENTATION/lppserial" title="LppSerial">LppSerial</a></LI>
32 <LI><a href="https://hephaistos.lpp.polytechnique.fr/rhodecode/HG_REPOSITORIES/LPP/INSTRUMENTATION/lppserial" title="LppSerial">LppSerial</a></LI>
31 <LI><a href="http://www.qcustomplot.com/index.php/introduction" title="qhexedit">QCustomPlot</a></LI>
33 <LI><a href="http://www.qcustomplot.com/index.php/introduction" title="qhexedit">QCustomPlot</a></LI>
32 <LI><a href="http://code.google.com/p/qhexedit2/" title="qhexedit">QHexEdit</a></LI>
34 <LI><a href="http://code.google.com/p/qhexedit2/" title="qhexedit">QHexEdit</a></LI>
35 <LI><a href="http://commons.wikimedia.org/wiki/File:Indiana_Jones_cappello.png" title="Indiana Jones cappello icon">Indiana Jones cappello icon</a></LI>
33 </ul>
36 </ul>
34 </div>
37 </div>
35 </div>
38 </div>
36 </body>
39 </body>
37 </html>
40 </html>
Show file before | Show file after | Hide comments
@@ -1,111 +1,112
1 #include "pythonconsole.h"
1 #include "pythonconsole.h"
2 #include <QPushButton>
2 #include <QPushButton>
3 #include <QFile>
3 #include <QFile>
4 #include <QTextStream>
4 #include <QTextStream>
5 #include <QCustomPlot/qcustomplot.h>
5 #include <QCustomPlot/qcustomplot.h>
6 #include "../common/pythonQtOut/generated_cpp/PySocExplorer/PySocExplorer0.h"
6 #include "../common/pythonQtOut/generated_cpp/PySocExplorer/PySocExplorer0.h"
7
7
8 #include <PythonQt.h>
8 #include <PythonQt.h>
9 #include "pluginloader.h"
9 #include "pluginloader.h"
10 #include <socexplorer.h>
10 #include <socexplorer.h>
11
11
12 void PythonQt_init_PySocExplorer(PyObject* module);
12 void PythonQt_init_PySocExplorer(PyObject* module);
13
13 void PythonQt_init_PySocExplorerEngine(PyObject* module) ;
14
14
15 PythonConsole::PythonConsole(socexplorerproxy *proxy, QWidget *parent) :
15 PythonConsole::PythonConsole(socexplorerproxy *proxy, QWidget *parent) :
16 QWidget(parent)
16 QWidget(parent)
17 {
17 {
18 //PythonQt::init();
18 //PythonQt::init();
19 PythonQt::init(PythonQt::RedirectStdOut);
19 PythonQt::init(PythonQt::RedirectStdOut);
20 PythonQt_QtAll::init();
20 PythonQt_QtAll::init();
21 this->proxy = proxy;
21 this->proxy = proxy;
22 this->mainlayout = new QHBoxLayout;
22 this->mainlayout = new QHBoxLayout;
23 this->mainContext = new PythonQtObjectPtr(PythonQt::self()->getMainModule());
23 this->mainContext = new PythonQtObjectPtr(PythonQt::self()->getMainModule());
24 this->mainContext->addVariable(QString("PYMODULES"),QVariant(QString(PYMODULES)));
24 this->mainContext->addVariable(QString("PYMODULES"),QVariant(QString(PYMODULES)));
25 this->console = new PythonQtScriptingConsoleDandD(NULL, PythonQt::self()->getMainModule());
25 this->console = new PythonQtScriptingConsoleDandD(NULL, PythonQt::self()->getMainModule());
26 this->mainlayout->addWidget(this->console);
26 this->mainlayout->addWidget(this->console);
27 this->setWindowTitle(tr("Python Scripting Console"));
27 this->setWindowTitle(tr("Python Scripting Console"));
28 this->bussdriver = 0;
28 this->bussdriver = 0;
29 this->setAcceptDrops(true);
29 this->setAcceptDrops(true);
30 this->setLayout(this->mainlayout);
30 this->setLayout(this->mainlayout);
31 connect(this->console,SIGNAL(pyConsoleRunFiles(QStringList)),this,SLOT(pyConsoleRunFiles(QStringList)));
31 connect(this->console,SIGNAL(pyConsoleRunFiles(QStringList)),this,SLOT(pyConsoleRunFiles(QStringList)));
32 this->mainContext->addObject("proxy", proxy);
32 this->mainContext->addObject("proxy", proxy);
33 PythonQt_init_PySocExplorer(0);
33 PythonQt_init_PySocExplorer(0);
34 PythonQt_init_PySocExplorerEngine(0);
34 this->mainContext->evalScript(QString("from PythonQt import *"));
35 this->mainContext->evalScript(QString("from PythonQt import *"));
35 }
36 }
36
37
37 void PythonConsole::addObject(const QString& name, QObject* object)
38 void PythonConsole::addObject(const QString& name, QObject* object)
38 {
39 {
39 this->mainContext->addObject(name, object);
40 this->mainContext->addObject(name, object);
40 }
41 }
41
42
42 void PythonConsole::setBussDriver(socexplorerplugin *driver)
43 void PythonConsole::setBussDriver(socexplorerplugin *driver)
43 {
44 {
44 this->bussdriver = driver;
45 this->bussdriver = driver;
45 this->mainContext->addObject("buss", this->bussdriver);
46 this->mainContext->addObject("buss", this->bussdriver);
46 }
47 }
47
48
48 void PythonConsole::registerObject(QObject* object,const QString& instanceName)
49 void PythonConsole::registerObject(QObject* object,const QString& instanceName)
49 {
50 {
50 this->mainContext->addObject(instanceName,object);
51 this->mainContext->addObject(instanceName,object);
51 }
52 }
52
53
53 void PythonConsole::changeSysDriverInstName(const QString newinstanceName,const QString previnstanceName)
54 void PythonConsole::changeSysDriverInstName(const QString newinstanceName,const QString previnstanceName)
54 {
55 {
55 socexplorerplugin* obj= this->proxy->getSysDriver(previnstanceName);
56 socexplorerplugin* obj= this->proxy->getSysDriver(previnstanceName);
56 if(obj==NULL)obj= this->proxy->getSysDriver(newinstanceName);
57 if(obj==NULL)obj= this->proxy->getSysDriver(newinstanceName);
57 if(obj==NULL)return;
58 if(obj==NULL)return;
58 this->mainContext->addObject(newinstanceName,obj->getPyObjectWrapper());
59 this->mainContext->addObject(newinstanceName,obj->getPyObjectWrapper());
59 this->mainContext->removeVariable(previnstanceName);
60 this->mainContext->removeVariable(previnstanceName);
60 }
61 }
61
62
62 void PythonConsole::removeDriver(const QString& instanceName)
63 void PythonConsole::removeDriver(const QString& instanceName)
63 {
64 {
64 this->mainContext->removeVariable(instanceName);
65 this->mainContext->removeVariable(instanceName);
65 }
66 }
66
67
67 void PythonConsole::removeBussDriver()
68 void PythonConsole::removeBussDriver()
68 {
69 {
69 this->bussdriver = 0;
70 this->bussdriver = 0;
70 this->mainContext->removeVariable("buss");
71 this->mainContext->removeVariable("buss");
71 emit this->rootDriverDelete();
72 emit this->rootDriverDelete();
72 }
73 }
73
74
74
75
75 void PythonConsole::pyConsoleRunFiles(const QStringList & pathList)
76 void PythonConsole::pyConsoleRunFiles(const QStringList & pathList)
76 {
77 {
77 for (int i = 0; i < pathList.size() && i < 32; ++i)
78 for (int i = 0; i < pathList.size() && i < 32; ++i)
78 {
79 {
79 this->pyConsoleRunFile(pathList.at(i));
80 this->pyConsoleRunFile(pathList.at(i));
80 }
81 }
81 }
82 }
82
83
83 void PythonConsole::pyConsoleRunFile(const QString& fileName)
84 void PythonConsole::pyConsoleRunFile(const QString& fileName)
84 {
85 {
85 QString code;
86 QString code;
86 QFile file;
87 QFile file;
87 QFileInfo fileinfo;
88 QFileInfo fileinfo;
88
89
89 code.clear();
90 code.clear();
90 file.setFileName(fileName);
91 file.setFileName(fileName);
91 fileinfo.setFile(fileName);
92 fileinfo.setFile(fileName);
92 if(!fileinfo.suffix().compare("py"))
93 if(!fileinfo.suffix().compare("py"))
93 {
94 {
94 QString CMD="execfile(\'"+fileName+"\')";
95 QString CMD="execfile(\'"+fileName+"\')";
95 this->console->executePythonCommand(CMD);
96 this->console->executePythonCommand(CMD);
96 }
97 }
97 }
98 }
98
99
99
100
100 QSize PythonConsole::sizeHint()
101 QSize PythonConsole::sizeHint()
101 {
102 {
102 return QSize(800,80);
103 return QSize(800,80);
103 }
104 }
104
105
105
106
106
107
107
108
108
109
109
110
110
111
111
112
Show file before | Show file after | Hide comments
@@ -1,152 +1,155
1 SOCEXPLORER_ROOT = \"$${PWD}/../..\"
1 SOCEXPLORER_ROOT = \"$${PWD}/../..\"
2
2
3 include($${PWD}/../../build_cfg/socexplorer.pri)
3 include($${PWD}/../../build_cfg/socexplorer.pri)
4
4
5 TARGET = socexplorerengine$${DEBUG_EXT}
5 TARGET = socexplorerengine$${DEBUG_EXT}
6 TEMPLATE = lib
6 TEMPLATE = lib
7
7
8 #more verbose plugin loader to debug plugin loading issues such as dependencies issues
8 #more verbose plugin loader to debug plugin loading issues such as dependencies issues
9 SOCEXPLORER_PLUGIN_LOADER="custom"
9 SOCEXPLORER_PLUGIN_LOADER="custom"
10
10
11 SOCEXPLORER_CHAGESETNUM=$$system(hg id)
11 SOCEXPLORER_CHAGESETNUM=$$system(hg id)
12 SOCEXPLORER_CHAGESETNUMSTR = '\\"$${SOCEXPLORER_CHAGESETNUM}\\"'
12 SOCEXPLORER_CHAGESETNUMSTR = '\\"$${SOCEXPLORER_CHAGESETNUM}\\"'
13 SOCEXPLORER_BRANCH=$$system(hg branch)
13 SOCEXPLORER_BRANCH=$$system(hg branch)
14 SOCEXPLORER_BRANCHSTR = '\\"$${SOCEXPLORER_BRANCH}\\"'
14 SOCEXPLORER_BRANCHSTR = '\\"$${SOCEXPLORER_BRANCH}\\"'
15
15
16 DEFINES += SOCEXPLORER_VERSION="\"\\\"0.2.2"\\\"\"
16 DEFINES += SOCEXPLORER_VERSION="\"\\\"0.2.2"\\\"\"
17 DEFINES += SOCEXPLORER_CHAGESET=\"$${SOCEXPLORER_CHAGESETNUMSTR}\"
17 DEFINES += SOCEXPLORER_CHAGESET=\"$${SOCEXPLORER_CHAGESETNUMSTR}\"
18 DEFINES += SOCEXPLORER_BRANCH=\"$${SOCEXPLORER_BRANCHSTR}\"
18 DEFINES += SOCEXPLORER_BRANCH=\"$${SOCEXPLORER_BRANCHSTR}\"
19
19
20
20
21 message("Building SOCEXPLORER changeset $${SOCEXPLORER_CHAGESETNUM}")
21 message("Building SOCEXPLORER changeset $${SOCEXPLORER_CHAGESETNUM}")
22
22
23 DEFINES += SOCEXPLORER_EXPORTS
23 DEFINES += SOCEXPLORER_EXPORTS
24
24
25 include ( plugins/socexplorerplugin.prf )
25 include ( plugins/socexplorerplugin.prf )
26 include ( PeripheralWidget/PeripheralWidget.pri)
26 include ( PeripheralWidget/PeripheralWidget.pri)
27
27
28 win32:CONFIG += dll
28 win32:CONFIG += dll
29 win32:CONFIG -= static
29 win32:CONFIG -= static
30 win32:LIBS+=-L$${SOCEXPLORER_ROOT}/bin/win32 -lsocexplorercommon$${DEBUG_EXT}
30 win32:LIBS+=-L$${SOCEXPLORER_ROOT}/bin/win32 -lsocexplorercommon$${DEBUG_EXT}
31
31
32 contains(SOCEXPLORER_PLUGIN_LOADER,"custom")
32 contains(SOCEXPLORER_PLUGIN_LOADER,"custom")
33 {
33 {
34 unix:LIBS+= -ldl
34 unix:LIBS+= -ldl
35 unix:DEFINES += SOCEXPLORER_CUSTOM_PLUGIN_LOADER
35 unix:DEFINES += SOCEXPLORER_CUSTOM_PLUGIN_LOADER
36 unix:HEADERS += \
36 unix:HEADERS += \
37 pluginloader/unix/unixpluginloader.h
37 pluginloader/unix/unixpluginloader.h
38 unix:SOURCES += \
38 unix:SOURCES += \
39 pluginloader/unix/unixpluginloader.cpp
39 pluginloader/unix/unixpluginloader.cpp
40 }
40 }
41
41
42 target.path = $$[QT_INSTALL_LIBS]
42 target.path = $$[QT_INSTALL_LIBS]
43 isEmpty(target.path) {
43 isEmpty(target.path) {
44 error(can\'t get QT_INSTALL_LIBS)
44 error(can\'t get QT_INSTALL_LIBS)
45 }
45 }
46
46
47 header.path = $$[QT_INSTALL_HEADERS]/SocExplorer
47 header.path = $$[QT_INSTALL_HEADERS]/SocExplorer
48 header.files = engine/socexplorerengine.h \
48 header.files = engine/socexplorerengine.h \
49 pluginloader/pluginscache.h \
49 pluginloader/pluginscache.h \
50 plugins/socexplorerplugin.h \
50 plugins/socexplorerplugin.h \
51 proxy/socexplorerproxy.h \
51 proxy/socexplorerproxy.h \
52 engine/socexplorerxmlfile.h \
52 engine/socexplorerxmlfile.h \
53 SOC/socexplorerenumdevice.h \
53 SOC/socexplorerenumdevice.h \
54 plugins/genericPySysdriver.h \
54 plugins/genericPySysdriver.h \
55 XmlEngine/XMLmodel.h \
55 XmlEngine/XMLmodel.h \
56 XmlEngine/XMLdata.h \
56 XmlEngine/XMLdata.h \
57 XmlEngine/xmldriver.h \
57 XmlEngine/xmldriver.h \
58 SOC/socmodel.h \
58 SOC/socmodel.h \
59 SOC/registerdata.h \
59 SOC/registerdata.h \
60 SOC/socclk.h \
60 SOC/socclk.h \
61 PeripheralWidget/src/peripheralwidget.h \
61 PeripheralWidget/src/peripheralwidget.h \
62 PeripheralWidget/src/registerwidget.h \
62 PeripheralWidget/src/registerwidget.h \
63 PeripheralWidget/src/socregsviewer.h
63 PeripheralWidget/src/socregsviewer.h
64
64
65
65
66
66
67 isEmpty(header.path) {
67 isEmpty(header.path) {
68 error(can\'t get QT_INSTALL_HEADERS)
68 error(can\'t get QT_INSTALL_HEADERS)
69 }
69 }
70
70
71 pluginif.files = pluginsInterface/*.h \
71 pluginif.files = pluginsInterface/*.h \
72 pluginsInterface/*.cpp
72 pluginsInterface/*.cpp
73
73
74 pluginif.path = $$[QT_INSTALL_HEADERS]/SocExplorer/pluginsInterface
74 pluginif.path = $$[QT_INSTALL_HEADERS]/SocExplorer/pluginsInterface
75
75
76
76
77 INSTALLS += target header pluginif
77 INSTALLS += target header pluginif
78
78
79 INCLUDEPATH += engine \
79 INCLUDEPATH += engine \
80 pluginloader \
80 pluginloader \
81 pluginsInterface \
81 pluginsInterface \
82 proxy \
82 proxy \
83 plugins \
83 plugins \
84 pluginManagerWdgt \
84 pluginManagerWdgt \
85 ../common \
85 ../common \
86 ../ \
86 ../ \
87 RegisterMVS \
87 RegisterMVS \
88 XmlEngine \
88 XmlEngine \
89 SOC \
89 SOC \
90 PeripheralWidget/src
90 PeripheralWidget/src
91
91
92
92
93 HEADERS += \
93 HEADERS += \
94 pluginloader/pluginscache.h \
94 pluginloader/pluginscache.h \
95 pluginloader/pluginloader.h \
95 pluginloader/pluginloader.h \
96 plugins/genericPySysdriver.h \
96 plugins/genericPySysdriver.h \
97 pluginManagerWdgt/plugintree.h \
97 pluginManagerWdgt/plugintree.h \
98 pluginManagerWdgt/pluginmanagerWDGT.h \
98 pluginManagerWdgt/pluginmanagerWDGT.h \
99 pluginManagerWdgt/pluginlist.h \
99 pluginManagerWdgt/pluginlist.h \
100 pluginManagerWdgt/plugininfoswdgt.h \
100 pluginManagerWdgt/plugininfoswdgt.h \
101 XmlEngine/XMLmodel.h \
101 XmlEngine/XMLmodel.h \
102 XmlEngine/XMLdata.h \
102 XmlEngine/XMLdata.h \
103 SOC/socmodel.h \
103 SOC/socmodel.h \
104 SOC/registerdata.h \
104 SOC/registerdata.h \
105 XmlEngine/xmldriver.h \
105 XmlEngine/xmldriver.h \
106 PeripheralWidget/src/peripheralwidget.h \
106 PeripheralWidget/src/peripheralwidget.h \
107 PeripheralWidget/src/registerwidget.h \
107 PeripheralWidget/src/registerwidget.h \
108 PeripheralWidget/src/socregsviewer.h \
108 PeripheralWidget/src/socregsviewer.h \
109 SOC/socclk.h \
109 SOC/socclk.h \
110 engine/socexplorerengine.h \
110 engine/socexplorerengine.h \
111 engine/socexplorerxmlfile.h \
111 engine/socexplorerxmlfile.h \
112 plugins/socexplorerplugin.h \
112 plugins/socexplorerplugin.h \
113 pluginsInterface/socexplorerplugininterface.h \
113 pluginsInterface/socexplorerplugininterface.h \
114 pluginsInterface/socexplorerplugininterface_global.h \
114 pluginsInterface/socexplorerplugininterface_global.h \
115 proxy/socexplorerproxy.h \
115 proxy/socexplorerproxy.h \
116 SOC/socexplorerenumdevice.h
116 SOC/socexplorerenumdevice.h \
117 PySocExplorerEngine.h
117
118
118
119
119
120
120
121
121
122
122
123
123 SOURCES += \
124 SOURCES += \
124 pluginloader/pluginscache.cpp \
125 pluginloader/pluginscache.cpp \
125 pluginloader/pluginloader.cpp \
126 pluginloader/pluginloader.cpp \
126 pluginManagerWdgt/plugintree.cpp \
127 pluginManagerWdgt/plugintree.cpp \
127 pluginManagerWdgt/pluginmanagerWDGT.cpp \
128 pluginManagerWdgt/pluginmanagerWDGT.cpp \
128 pluginManagerWdgt/pluginlist.cpp \
129 pluginManagerWdgt/pluginlist.cpp \
129 pluginManagerWdgt/plugininfoswdgt.cpp \
130 pluginManagerWdgt/plugininfoswdgt.cpp \
130 XmlEngine/XMLmodel.cpp \
131 XmlEngine/XMLmodel.cpp \
131 XmlEngine/XMLdata.cpp \
132 XmlEngine/XMLdata.cpp \
132 SOC/socmodel.cpp \
133 SOC/socmodel.cpp \
133 SOC/registerdata.cpp \
134 SOC/registerdata.cpp \
134 XmlEngine/xmldriver.cpp \
135 XmlEngine/xmldriver.cpp \
135 PeripheralWidget/src/peripheralwidget.cpp \
136 PeripheralWidget/src/peripheralwidget.cpp \
136 PeripheralWidget/src/registerwidget.cpp \
137 PeripheralWidget/src/registerwidget.cpp \
137 PeripheralWidget/src/socregsviewer.cpp \
138 PeripheralWidget/src/socregsviewer.cpp \
138 SOC/socclk.cpp \
139 SOC/socclk.cpp \
139 plugins/genericPySysdriver.cpp \
140 plugins/genericPySysdriver.cpp \
140 engine/socexplorerengine.cpp \
141 engine/socexplorerengine.cpp \
141 engine/socexplorerxmlfile.cpp \
142 engine/socexplorerxmlfile.cpp \
142 proxy/socexplorerproxy.cpp \
143 proxy/socexplorerproxy.cpp \
143 SOC/socexplorerenumdevice.cpp \
144 SOC/socexplorerenumdevice.cpp \
144 plugins/socexplorerplugin.cpp
145 plugins/socexplorerplugin.cpp
145
146
146
147
147 OTHER_FILES += \
148 OTHER_FILES += \
148 plugins/socexplorerplugin.cpp \
149 plugins/socexplorerplugin.cpp \
149 pluginsInterface/socexplorerplugininterface.cpp \
150 pluginsInterface/socexplorerplugininterface.cpp \
150 plugins/socexplorerplugin.prf
151 plugins/socexplorerplugin.prf \
152 pythongenerator.sh \
153 pythonQtgeneratorCfg.txt
151
154
152
155
Show file before | Show file after | Hide comments
@@ -1,17 +1,18
1 #include <QtCore/QObject>
1 #include <QtCore/QObject>
2 #include <QtWidgets/QtWidgets>
2 #include <QtWidgets/QtWidgets>
3 #include "qhexspinbox.h"
3 #include "qhexspinbox.h"
4 #include "memsizewdgt.h"
4 #include "memsizewdgt.h"
5 #include "qhexedit/qhexedit.h"
5 #include "qhexedit/qhexedit.h"
6 #include "SocExplorerPlot.h"
6 #include "SocExplorerPlot.h"
7 #include "tcp_terminal_client.h"
7 #include "tcp_terminal_client.h"
8 #include "QCustomPlot/qcustomplot.h"
8 #include "QCustomPlot/qcustomplot.h"
9 #include "genericBinaryFiles/abstractbinfile.h"
9 #include "genericBinaryFiles/abstractbinfile.h"
10 #include "genericBinaryFiles/elf/elfparser.h"
10 #include "genericBinaryFiles/elf/elfparser.h"
11 #include "genericBinaryFiles/elf/elffile.h"
11 #include "genericBinaryFiles/elf/elffile.h"
12 #include "genericBinaryFiles/elf/elffilewidget.h"
12 #include "genericBinaryFiles/elf/elffilewidget.h"
13 #include "genericBinaryFiles/elf/elfinfowdgt.h"
13 #include "genericBinaryFiles/elf/elfinfowdgt.h"
14 #include "genericBinaryFiles/srec/srecfile.h"
14 #include "genericBinaryFiles/srec/srecfile.h"
15 #include "genericBinaryFiles/srec/srecfilewidget.h"
15 #include "genericBinaryFiles/srec/srecfilewidget.h"
16 #include "genericBinaryFiles/BinFile/binaryfile.h"
16 #include "genericBinaryFiles/BinFile/binaryfile.h"
17 #include "genericBinaryFiles/BinFile/binaryfilewidget.h"
17 #include "genericBinaryFiles/BinFile/binaryfilewidget.h"
18 #include "genericBinaryFiles/genericbinaryfilewidget.h"
Show file before | Show file after | Hide comments
@@ -1,147 +1,150
1 SOCEXPLORER_ROOT = \"$${PWD}/../..\"
1 SOCEXPLORER_ROOT = \"$${PWD}/../..\"
2 include($${PWD}/../../build_cfg/socexplorer.pri)
2 include($${PWD}/../../build_cfg/socexplorer.pri)
3 include($${PWD}/lppserial/lppserial.pri)
3 include($${PWD}/lppserial/lppserial.pri)
4
4
5 TEMPLATE = lib
5 TEMPLATE = lib
6 TARGET = socexplorercommon$${DEBUG_EXT}
6 TARGET = socexplorercommon$${DEBUG_EXT}
7
7
8 win32:CONFIG += dll
8 win32:CONFIG += dll
9 win32:CONFIG -= static
9 win32:CONFIG -= static
10
10
11 win32:INCLUDEPATH += $${PWD}/genericBinaryFiles/elf/libelfWin32/include
11 win32:INCLUDEPATH += $${PWD}/genericBinaryFiles/elf/libelfWin32/include
12 win32:INCLUDEPATH += $${PWD}/genericBinaryFiles/elf/libelfWin32/include/libelf
12 win32:INCLUDEPATH += $${PWD}/genericBinaryFiles/elf/libelfWin32/include/libelf
13 win32:DEFINES+=_ELF_WINDOWS_
13 win32:DEFINES+=_ELF_WINDOWS_
14 DEFINES+=RS232_debug
14 DEFINES+=RS232_debug
15
15
16 win32:LIBS += $${PWD}/genericBinaryFiles/elf/libelfWin32/bin/libelf.a
16 win32:LIBS += $${PWD}/genericBinaryFiles/elf/libelfWin32/bin/libelf.a
17 unix:LIBS += -lelf
17 unix:LIBS += -lelf
18
18
19 QMAKE_LFLAGS_RELEASE += --enable-auto-import
19 QMAKE_LFLAGS_RELEASE += --enable-auto-import
20 QMAKE_LFLAGS_DEBUG += --enable-auto-import
20 QMAKE_LFLAGS_DEBUG += --enable-auto-import
21
21
22 target.path = $$[QT_INSTALL_LIBS]
22 target.path = $$[QT_INSTALL_LIBS]
23 isEmpty(target.path) {
23 isEmpty(target.path) {
24 error(can\'t get QT_INSTALL_LIBS)
24 error(can\'t get QT_INSTALL_LIBS)
25 }
25 }
26
26
27 header.path = $$[QT_INSTALL_HEADERS]/SocExplorer/common
27 header.path = $$[QT_INSTALL_HEADERS]/SocExplorer/common
28 header.files = \
28 header.files = \
29 memsizewdgt.h \
29 memsizewdgt.h \
30 qhexspinbox.h \
30 qhexspinbox.h \
31 qsvgicon.h \
31 qsvgicon.h \
32 qhexedit/qhexedit_p.h \
32 qhexedit/qhexedit_p.h \
33 qhexedit/qhexedit.h \
33 qhexedit/qhexedit.h \
34 qhexedit/xbytearray.h \
34 qhexedit/xbytearray.h \
35 QCustomPlot/qcustomplot.h \
35 QCustomPlot/qcustomplot.h \
36 SocExplorerPlot.h \
36 SocExplorerPlot.h \
37 tcp_terminal_client.h \
37 tcp_terminal_client.h \
38 genericBinaryFiles/elf/elfinfowdgt.h \
38 genericBinaryFiles/elf/elfinfowdgt.h \
39 genericBinaryFiles/elf/elfparser.h \
39 genericBinaryFiles/elf/elfparser.h \
40 genericBinaryFiles/elf/elffile.h \
40 genericBinaryFiles/elf/elffile.h \
41 genericBinaryFiles/elf/elffilewidget.h \
41 genericBinaryFiles/elf/elffilewidget.h \
42 qipdialogbox.h \
42 qipdialogbox.h \
43 lppserial/src/RS232.h \
43 lppserial/src/RS232.h \
44 qtablewidgetintitem.h \
44 qtablewidgetintitem.h \
45 genericBinaryFiles/srec/srecfile.h \
45 genericBinaryFiles/srec/srecfile.h \
46 genericBinaryFiles/srec/srecfilewidget.h \
46 genericBinaryFiles/srec/srecfilewidget.h \
47 genericBinaryFiles/BinFile/binaryfile.h \
47 genericBinaryFiles/BinFile/binaryfile.h \
48 genericBinaryFiles/BinFile/binaryfilewidget.h \
48 genericBinaryFiles/BinFile/binaryfilewidget.h \
49 genericBinaryFiles/abstractbinfile.h \
49 genericBinaryFiles/abstractbinfile.h \
50 genericBinaryFiles/qvpushbutton.h \
50 genericBinaryFiles/qvpushbutton.h \
51 genericBinaryFiles/qtablewidgetintitem.h \
51 genericBinaryFiles/qtablewidgetintitem.h \
52 genericBinaryFiles/filelist.h
52 genericBinaryFiles/filelist.h
53
53
54 win32{
54 win32{
55 elfheader.path = $$[QT_INSTALL_HEADERS]/SocExplorer/common/genericBinaryFiles/libelf
55 elfheader.path = $$[QT_INSTALL_HEADERS]/SocExplorer/common/genericBinaryFiles/libelf
56 elfheader.files += \
56 elfheader.files += \
57 genericBinaryFiles/elf/libelfWin32/include/libelf/byteswap.h \
57 genericBinaryFiles/elf/libelfWin32/include/libelf/byteswap.h \
58 genericBinaryFiles/elf/libelfWin32/include/libelf/errors.h \
58 genericBinaryFiles/elf/libelfWin32/include/libelf/errors.h \
59 genericBinaryFiles/elf/libelfWin32/include/libelf/gelf.h \
59 genericBinaryFiles/elf/libelfWin32/include/libelf/gelf.h \
60 genericBinaryFiles/elf/libelfWin32/include/libelf/nlist.h \
60 genericBinaryFiles/elf/libelfWin32/include/libelf/nlist.h \
61 genericBinaryFiles/elf/libelfWin32/include/libelf/sys_elf.h \
61 genericBinaryFiles/elf/libelfWin32/include/libelf/sys_elf.h \
62 genericBinaryFiles/elf/libelfWin32/include/libelf/verneed.h \
62 genericBinaryFiles/elf/libelfWin32/include/libelf/verneed.h \
63 genericBinaryFiles/elf/libelfWin32/include/libelf/elf_repl.h \
63 genericBinaryFiles/elf/libelfWin32/include/libelf/elf_repl.h \
64 genericBinaryFiles/elf/libelfWin32/include/libelf/ext_types.h \
64 genericBinaryFiles/elf/libelfWin32/include/libelf/ext_types.h \
65 genericBinaryFiles/elf/libelfWin32/include/libelf/libelf.h \
65 genericBinaryFiles/elf/libelfWin32/include/libelf/libelf.h \
66 genericBinaryFiles/elf/libelfWin32/include/libelf/private.h \
66 genericBinaryFiles/elf/libelfWin32/include/libelf/private.h \
67 genericBinaryFiles/elf/libelfWin32/include/libelf/verdef.h
67 genericBinaryFiles/elf/libelfWin32/include/libelf/verdef.h
68 INSTALLS += elfheader
68 INSTALLS += elfheader
69 }
69 }
70
70
71
71
72 isEmpty(header.path) {
72 isEmpty(header.path) {
73 error(can\'t get QT_INSTALL_HEADERS)
73 error(can\'t get QT_INSTALL_HEADERS)
74 }
74 }
75
75
76 INSTALLS += target header
76 INSTALLS += target header
77
77
78 INCLUDEPATH += QCustomPlot qhexedit genericBinaryFiles genericBinaryFiles/srec genericBinaryFiles/BinFile
78 INCLUDEPATH += QCustomPlot qhexedit genericBinaryFiles genericBinaryFiles/srec genericBinaryFiles/BinFile
79
79
80 HEADERS += \
80 HEADERS += \
81 memsizewdgt.h \
81 memsizewdgt.h \
82 qhexspinbox.h \
82 qhexspinbox.h \
83 qsvgicon.h \
83 qsvgicon.h \
84 qhexedit/qhexedit_p.h \
84 qhexedit/qhexedit_p.h \
85 qhexedit/qhexedit.h \
85 qhexedit/qhexedit.h \
86 qhexedit/xbytearray.h \
86 qhexedit/xbytearray.h \
87 qhexedit/commands.h \
87 qhexedit/commands.h \
88 QCustomPlot/qcustomplot.h \
88 QCustomPlot/qcustomplot.h \
89 tcp_terminal_client.h \
89 tcp_terminal_client.h \
90 genericBinaryFiles/elf/elfinfowdgt.h \
90 genericBinaryFiles/elf/elfinfowdgt.h \
91 genericBinaryFiles/elf/elfparser.h \
91 genericBinaryFiles/elf/elfparser.h \
92 genericBinaryFiles/elf/elffile.h \
92 genericBinaryFiles/elf/elffile.h \
93 qipdialogbox.h \
93 qipdialogbox.h \
94 PySocExplorer.h \
94 PySocExplorer.h \
95 SocExplorerPlot.h \
95 SocExplorerPlot.h \
96 genericBinaryFiles/elf/elffilewidget.h \
96 genericBinaryFiles/elf/elffilewidget.h \
97 genericBinaryFiles/srec/srecfile.h \
97 genericBinaryFiles/srec/srecfile.h \
98 genericBinaryFiles/srec/srecfilewidget.h \
98 genericBinaryFiles/srec/srecfilewidget.h \
99 genericBinaryFiles/abstractbinfile.h \
99 genericBinaryFiles/abstractbinfile.h \
100 genericBinaryFiles/BinFile/binaryfile.h \
100 genericBinaryFiles/BinFile/binaryfile.h \
101 genericBinaryFiles/BinFile/binaryfilewidget.h \
101 genericBinaryFiles/BinFile/binaryfilewidget.h \
102 genericBinaryFiles/genericbinaryfilewidget.h \
102 genericBinaryFiles/genericbinaryfilewidget.h \
103 genericBinaryFiles/qvpushbutton.h \
103 genericBinaryFiles/qvpushbutton.h \
104 genericBinaryFiles/qtablewidgetintitem.h \
104 genericBinaryFiles/qtablewidgetintitem.h \
105 genericBinaryFiles/filelist.h
105 genericBinaryFiles/filelist.h
106
106
107
107
108 SOURCES += \
108 SOURCES += \
109 memsizewdgt.cpp \
109 memsizewdgt.cpp \
110 qhexspinbox.cpp \
110 qhexspinbox.cpp \
111 qsvgicon.cpp \
111 qsvgicon.cpp \
112 qhexedit/qhexedit_p.cpp \
112 qhexedit/qhexedit_p.cpp \
113 qhexedit/qhexedit.cpp \
113 qhexedit/qhexedit.cpp \
114 qhexedit/xbytearray.cpp \
114 qhexedit/xbytearray.cpp \
115 qhexedit/commands.cpp \
115 qhexedit/commands.cpp \
116 QCustomPlot/qcustomplot.cpp \
116 QCustomPlot/qcustomplot.cpp \
117 tcp_terminal_client.cpp \
117 tcp_terminal_client.cpp \
118 genericBinaryFiles/elf/elfinfowdgt.cpp \
118 genericBinaryFiles/elf/elfinfowdgt.cpp \
119 genericBinaryFiles/elf/elfparser.cpp \
119 genericBinaryFiles/elf/elfparser.cpp \
120 genericBinaryFiles/elf/elffile.cpp \
120 genericBinaryFiles/elf/elffile.cpp \
121 qipdialogbox.cpp \
121 qipdialogbox.cpp \
122 SocExplorerPlot.cpp \
122 SocExplorerPlot.cpp \
123 genericBinaryFiles/elf/elffilewidget.cpp \
123 genericBinaryFiles/elf/elffilewidget.cpp \
124 genericBinaryFiles/srec/srecfile.cpp \
124 genericBinaryFiles/srec/srecfile.cpp \
125 genericBinaryFiles/srec/srecfilewidget.cpp \
125 genericBinaryFiles/srec/srecfilewidget.cpp \
126 genericBinaryFiles/abstractbinfile.cpp \
126 genericBinaryFiles/abstractbinfile.cpp \
127 genericBinaryFiles/BinFile/binaryfile.cpp \
127 genericBinaryFiles/BinFile/binaryfile.cpp \
128 genericBinaryFiles/BinFile/binaryfilewidget.cpp \
128 genericBinaryFiles/BinFile/binaryfilewidget.cpp \
129 genericBinaryFiles/genericbinaryfilewidget.cpp \
129 genericBinaryFiles/genericbinaryfilewidget.cpp \
130 genericBinaryFiles/qvpushbutton.cpp \
130 genericBinaryFiles/qvpushbutton.cpp \
131 genericBinaryFiles/qtablewidgetintitem.cpp \
131 genericBinaryFiles/qtablewidgetintitem.cpp \
132 genericBinaryFiles/filelist.cpp
132 genericBinaryFiles/filelist.cpp
133
133
134 FORMS += \
134 FORMS += \
135 genericBinaryFiles/elf/elffilewidget.ui \
135 genericBinaryFiles/elf/elffilewidget.ui \
136 genericBinaryFiles/srec/srecfilewidget.ui \
136 genericBinaryFiles/srec/srecfilewidget.ui \
137 genericBinaryFiles/BinFile/binaryfilewidget.ui \
137 genericBinaryFiles/BinFile/binaryfilewidget.ui \
138 genericBinaryFiles/genericbinaryfilewidget.ui
138 genericBinaryFiles/genericbinaryfilewidget.ui
139
139
140 OTHER_FILES += \
140 OTHER_FILES += \
141 ./pythongenerator.sh \
141 ./pythongenerator.sh \
142 ./pythonQtgeneratorCfg.txt
142 ./pythonQtgeneratorCfg.txt
143
143
144 RESOURCES += \
145 genericBinaryFiles/genericBinaryFiles.qrc
144
146
145
147
146
148
147
149
150
Show file before | Show file after | Hide comments
This diff has been collapsed as it changes many lines, (928 lines changed) Show them Hide them
@@ -1,7793 +1,8711
1 #include "PySocExplorer0.h"
1 #include "PySocExplorer0.h"
2 #include <PythonQtConversion.h>
2 #include <PythonQtConversion.h>
3 #include <PythonQtMethodInfo.h>
3 #include <PythonQtMethodInfo.h>
4 #include <PythonQtSignalReceiver.h>
4 #include <PythonQtSignalReceiver.h>
5 #include <QIconEngine>
5 #include <QIconEngine>
6 #include <QObject>
7 #include <QSpinBox>
8 #include <QVariant>
6 #include <QVariant>
9 #include <QWidget>
10 #include <abstractbinfile.h>
7 #include <abstractbinfile.h>
11 #include <elffile.h>
12 #include <elfparser.h>
8 #include <elfparser.h>
13 #include <qaction.h>
9 #include <qaction.h>
14 #include <qbitmap.h>
10 #include <qbitmap.h>
15 #include <qbytearray.h>
11 #include <qbytearray.h>
16 #include <qcolor.h>
12 #include <qcolor.h>
17 #include <qcoreevent.h>
13 #include <qcoreevent.h>
18 #include <qcursor.h>
14 #include <qcursor.h>
19 #include <qevent.h>
15 #include <qevent.h>
20 #include <qfile.h>
16 #include <qfile.h>
21 #include <qfont.h>
17 #include <qfont.h>
22 #include <qgraphicseffect.h>
18 #include <qgraphicseffect.h>
23 #include <qgraphicsproxywidget.h>
19 #include <qgraphicsproxywidget.h>
24 #include <qkeysequence.h>
20 #include <qkeysequence.h>
25 #include <qlayout.h>
21 #include <qlayout.h>
26 #include <qlineedit.h>
22 #include <qlineedit.h>
27 #include <qlist.h>
23 #include <qlist.h>
28 #include <qlocale.h>
24 #include <qlocale.h>
29 #include <qmargins.h>
25 #include <qmargins.h>
30 #include <qobject.h>
26 #include <qobject.h>
31 #include <qpaintdevice.h>
27 #include <qpaintdevice.h>
32 #include <qpaintengine.h>
28 #include <qpaintengine.h>
33 #include <qpainter.h>
29 #include <qpainter.h>
34 #include <qpalette.h>
30 #include <qpalette.h>
35 #include <qpen.h>
31 #include <qpen.h>
36 #include <qpixmap.h>
32 #include <qpixmap.h>
37 #include <qpoint.h>
33 #include <qpoint.h>
38 #include <qrect.h>
34 #include <qrect.h>
39 #include <qregion.h>
35 #include <qregion.h>
40 #include <qscrollarea.h>
36 #include <qscrollarea.h>
41 #include <qscrollbar.h>
37 #include <qscrollbar.h>
42 #include <qsize.h>
38 #include <qsize.h>
43 #include <qsizepolicy.h>
39 #include <qsizepolicy.h>
44 #include <qspinbox.h>
40 #include <qspinbox.h>
45 #include <qstringlist.h>
41 #include <qstringlist.h>
46 #include <qstyle.h>
42 #include <qstyle.h>
47 #include <qstyleoption.h>
43 #include <qstyleoption.h>
48 #include <qwidget.h>
44 #include <qwidget.h>
49
45
50 PythonQtShell_ElfFile::~PythonQtShell_ElfFile() {
46 PythonQtShell_ElfFile::~PythonQtShell_ElfFile() {
51 PythonQtPrivate* priv = PythonQt::priv();
47 PythonQtPrivate* priv = PythonQt::priv();
52 if (priv) { priv->shellClassDeleted(this); }
48 if (priv) { priv->shellClassDeleted(this); }
53 }
49 }
54 int PythonQtShell_ElfFile::closeFile()
50 int PythonQtShell_ElfFile::closeFile()
55 {
51 {
56 if (_wrapper) {
52 if (_wrapper) {
57 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "closeFile");
53 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "closeFile");
58 PyErr_Clear();
54 PyErr_Clear();
59 if (obj && !PythonQtSlotFunction_Check(obj)) {
55 if (obj && !PythonQtSlotFunction_Check(obj)) {
60 static const char* argumentList[] ={"int"};
56 static const char* argumentList[] ={"int"};
61 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
57 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
62 int returnValue;
58 int returnValue;
63 void* args[1] = {NULL};
59 void* args[1] = {NULL};
64 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
60 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
65 if (result) {
61 if (result) {
66 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
62 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
67 if (args[0]!=&returnValue) {
63 if (args[0]!=&returnValue) {
68 if (args[0]==NULL) {
64 if (args[0]==NULL) {
69 PythonQt::priv()->handleVirtualOverloadReturnError("closeFile", methodInfo, result);
65 PythonQt::priv()->handleVirtualOverloadReturnError("closeFile", methodInfo, result);
70 } else {
66 } else {
71 returnValue = *((int*)args[0]);
67 returnValue = *((int*)args[0]);
72 }
68 }
73 }
69 }
74 }
70 }
75 if (result) { Py_DECREF(result); }
71 if (result) { Py_DECREF(result); }
76 Py_DECREF(obj);
72 Py_DECREF(obj);
77 return returnValue;
73 return returnValue;
78 }
74 }
79 }
75 }
80 return ElfFile::closeFile();
76 return ElfFile::closeFile();
81 }
77 }
82 QList<codeFragment* > PythonQtShell_ElfFile::getFragments()
78 QList<codeFragment* > PythonQtShell_ElfFile::getFragments()
83 {
79 {
84 if (_wrapper) {
80 if (_wrapper) {
85 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getFragments");
81 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getFragments");
86 PyErr_Clear();
82 PyErr_Clear();
87 if (obj && !PythonQtSlotFunction_Check(obj)) {
83 if (obj && !PythonQtSlotFunction_Check(obj)) {
88 static const char* argumentList[] ={"QList<codeFragment* >"};
84 static const char* argumentList[] ={"QList<codeFragment* >"};
89 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
85 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
90 QList<codeFragment* > returnValue;
86 QList<codeFragment* > returnValue;
91 void* args[1] = {NULL};
87 void* args[1] = {NULL};
92 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
88 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
93 if (result) {
89 if (result) {
94 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
90 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
95 if (args[0]!=&returnValue) {
91 if (args[0]!=&returnValue) {
96 if (args[0]==NULL) {
92 if (args[0]==NULL) {
97 PythonQt::priv()->handleVirtualOverloadReturnError("getFragments", methodInfo, result);
93 PythonQt::priv()->handleVirtualOverloadReturnError("getFragments", methodInfo, result);
98 } else {
94 } else {
99 returnValue = *((QList<codeFragment* >*)args[0]);
95 returnValue = *((QList<codeFragment* >*)args[0]);
100 }
96 }
101 }
97 }
102 }
98 }
103 if (result) { Py_DECREF(result); }
99 if (result) { Py_DECREF(result); }
104 Py_DECREF(obj);
100 Py_DECREF(obj);
105 return returnValue;
101 return returnValue;
106 }
102 }
107 }
103 }
108 return ElfFile::getFragments();
104 return ElfFile::getFragments();
109 }
105 }
110 bool PythonQtShell_ElfFile::isopened()
106 bool PythonQtShell_ElfFile::isopened()
111 {
107 {
112 if (_wrapper) {
108 if (_wrapper) {
113 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "isopened");
109 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "isopened");
114 PyErr_Clear();
110 PyErr_Clear();
115 if (obj && !PythonQtSlotFunction_Check(obj)) {
111 if (obj && !PythonQtSlotFunction_Check(obj)) {
116 static const char* argumentList[] ={"bool"};
112 static const char* argumentList[] ={"bool"};
117 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
113 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
118 bool returnValue;
114 bool returnValue;
119 void* args[1] = {NULL};
115 void* args[1] = {NULL};
120 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
116 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
121 if (result) {
117 if (result) {
122 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
118 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
123 if (args[0]!=&returnValue) {
119 if (args[0]!=&returnValue) {
124 if (args[0]==NULL) {
120 if (args[0]==NULL) {
125 PythonQt::priv()->handleVirtualOverloadReturnError("isopened", methodInfo, result);
121 PythonQt::priv()->handleVirtualOverloadReturnError("isopened", methodInfo, result);
126 } else {
122 } else {
127 returnValue = *((bool*)args[0]);
123 returnValue = *((bool*)args[0]);
128 }
124 }
129 }
125 }
130 }
126 }
131 if (result) { Py_DECREF(result); }
127 if (result) { Py_DECREF(result); }
132 Py_DECREF(obj);
128 Py_DECREF(obj);
133 return returnValue;
129 return returnValue;
134 }
130 }
135 }
131 }
136 return ElfFile::isopened();
132 return ElfFile::isopened();
137 }
133 }
138 bool PythonQtShell_ElfFile::openFile(const QString& File)
134 bool PythonQtShell_ElfFile::openFile(const QString& File)
139 {
135 {
140 if (_wrapper) {
136 if (_wrapper) {
141 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "openFile");
137 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "openFile");
142 PyErr_Clear();
138 PyErr_Clear();
143 if (obj && !PythonQtSlotFunction_Check(obj)) {
139 if (obj && !PythonQtSlotFunction_Check(obj)) {
144 static const char* argumentList[] ={"bool" , "const QString&"};
140 static const char* argumentList[] ={"bool" , "const QString&"};
145 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
141 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
146 bool returnValue;
142 bool returnValue;
147 void* args[2] = {NULL, (void*)&File};
143 void* args[2] = {NULL, (void*)&File};
148 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
144 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
149 if (result) {
145 if (result) {
150 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
146 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
151 if (args[0]!=&returnValue) {
147 if (args[0]!=&returnValue) {
152 if (args[0]==NULL) {
148 if (args[0]==NULL) {
153 PythonQt::priv()->handleVirtualOverloadReturnError("openFile", methodInfo, result);
149 PythonQt::priv()->handleVirtualOverloadReturnError("openFile", methodInfo, result);
154 } else {
150 } else {
155 returnValue = *((bool*)args[0]);
151 returnValue = *((bool*)args[0]);
156 }
152 }
157 }
153 }
158 }
154 }
159 if (result) { Py_DECREF(result); }
155 if (result) { Py_DECREF(result); }
160 Py_DECREF(obj);
156 Py_DECREF(obj);
161 return returnValue;
157 return returnValue;
162 }
158 }
163 }
159 }
164 return ElfFile::openFile(File);
160 return ElfFile::openFile(File);
165 }
161 }
166 bool PythonQtShell_ElfFile::toBinary(const QString& File)
162 bool PythonQtShell_ElfFile::toBinary(const QString& File)
167 {
163 {
168 if (_wrapper) {
164 if (_wrapper) {
169 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "toBinary");
165 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "toBinary");
170 PyErr_Clear();
166 PyErr_Clear();
171 if (obj && !PythonQtSlotFunction_Check(obj)) {
167 if (obj && !PythonQtSlotFunction_Check(obj)) {
172 static const char* argumentList[] ={"bool" , "const QString&"};
168 static const char* argumentList[] ={"bool" , "const QString&"};
173 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
169 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
174 bool returnValue;
170 bool returnValue;
175 void* args[2] = {NULL, (void*)&File};
171 void* args[2] = {NULL, (void*)&File};
176 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
172 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
177 if (result) {
173 if (result) {
178 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
174 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
179 if (args[0]!=&returnValue) {
175 if (args[0]!=&returnValue) {
180 if (args[0]==NULL) {
176 if (args[0]==NULL) {
181 PythonQt::priv()->handleVirtualOverloadReturnError("toBinary", methodInfo, result);
177 PythonQt::priv()->handleVirtualOverloadReturnError("toBinary", methodInfo, result);
182 } else {
178 } else {
183 returnValue = *((bool*)args[0]);
179 returnValue = *((bool*)args[0]);
184 }
180 }
185 }
181 }
186 }
182 }
187 if (result) { Py_DECREF(result); }
183 if (result) { Py_DECREF(result); }
188 Py_DECREF(obj);
184 Py_DECREF(obj);
189 return returnValue;
185 return returnValue;
190 }
186 }
191 }
187 }
192 return ElfFile::toBinary(File);
188 return ElfFile::toBinary(File);
193 }
189 }
194 bool PythonQtShell_ElfFile::toSrec(const QString& File)
190 bool PythonQtShell_ElfFile::toSrec(const QString& File)
195 {
191 {
196 if (_wrapper) {
192 if (_wrapper) {
197 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "toSrec");
193 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "toSrec");
198 PyErr_Clear();
194 PyErr_Clear();
199 if (obj && !PythonQtSlotFunction_Check(obj)) {
195 if (obj && !PythonQtSlotFunction_Check(obj)) {
200 static const char* argumentList[] ={"bool" , "const QString&"};
196 static const char* argumentList[] ={"bool" , "const QString&"};
201 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
197 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
202 bool returnValue;
198 bool returnValue;
203 void* args[2] = {NULL, (void*)&File};
199 void* args[2] = {NULL, (void*)&File};
204 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
200 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
205 if (result) {
201 if (result) {
206 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
202 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
207 if (args[0]!=&returnValue) {
203 if (args[0]!=&returnValue) {
208 if (args[0]==NULL) {
204 if (args[0]==NULL) {
209 PythonQt::priv()->handleVirtualOverloadReturnError("toSrec", methodInfo, result);
205 PythonQt::priv()->handleVirtualOverloadReturnError("toSrec", methodInfo, result);
210 } else {
206 } else {
211 returnValue = *((bool*)args[0]);
207 returnValue = *((bool*)args[0]);
212 }
208 }
213 }
209 }
214 }
210 }
215 if (result) { Py_DECREF(result); }
211 if (result) { Py_DECREF(result); }
216 Py_DECREF(obj);
212 Py_DECREF(obj);
217 return returnValue;
213 return returnValue;
218 }
214 }
219 }
215 }
220 return ElfFile::toSrec(File);
216 return ElfFile::toSrec(File);
221 }
217 }
222 ElfFile* PythonQtWrapper_ElfFile::new_ElfFile()
218 ElfFile* PythonQtWrapper_ElfFile::new_ElfFile()
223 {
219 {
224 return new PythonQtShell_ElfFile(); }
220 return new PythonQtShell_ElfFile(); }
225
221
226 ElfFile* PythonQtWrapper_ElfFile::new_ElfFile(const QString& File)
222 ElfFile* PythonQtWrapper_ElfFile::new_ElfFile(const QString& File)
227 {
223 {
228 return new PythonQtShell_ElfFile(File); }
224 return new PythonQtShell_ElfFile(File); }
229
225
230 int PythonQtWrapper_ElfFile::closeFile(ElfFile* theWrappedObject)
226 int PythonQtWrapper_ElfFile::closeFile(ElfFile* theWrappedObject)
231 {
227 {
232 return ( ((PythonQtPublicPromoter_ElfFile*)theWrappedObject)->promoted_closeFile());
228 return ( ((PythonQtPublicPromoter_ElfFile*)theWrappedObject)->promoted_closeFile());
233 }
229 }
234
230
235 QString PythonQtWrapper_ElfFile::getABI(ElfFile* theWrappedObject)
231 QString PythonQtWrapper_ElfFile::getABI(ElfFile* theWrappedObject)
236 {
232 {
237 return ( theWrappedObject->getABI());
233 return ( theWrappedObject->getABI());
238 }
234 }
239
235
240 QString PythonQtWrapper_ElfFile::getArchitecture(ElfFile* theWrappedObject)
236 QString PythonQtWrapper_ElfFile::getArchitecture(ElfFile* theWrappedObject)
241 {
237 {
242 return ( theWrappedObject->getArchitecture());
238 return ( theWrappedObject->getArchitecture());
243 }
239 }
244
240
245 QString PythonQtWrapper_ElfFile::getClass(ElfFile* theWrappedObject)
241 QString PythonQtWrapper_ElfFile::getClass(ElfFile* theWrappedObject)
246 {
242 {
247 return ( theWrappedObject->getClass());
243 return ( theWrappedObject->getClass());
248 }
244 }
249
245
250 QString PythonQtWrapper_ElfFile::getEndianness(ElfFile* theWrappedObject)
246 QString PythonQtWrapper_ElfFile::getEndianness(ElfFile* theWrappedObject)
251 {
247 {
252 return ( theWrappedObject->getEndianness());
248 return ( theWrappedObject->getEndianness());
253 }
249 }
254
250
255 qint64 PythonQtWrapper_ElfFile::getEntryPointAddress(ElfFile* theWrappedObject)
251 qint64 PythonQtWrapper_ElfFile::getEntryPointAddress(ElfFile* theWrappedObject)
256 {
252 {
257 return ( theWrappedObject->getEntryPointAddress());
253 return ( theWrappedObject->getEntryPointAddress());
258 }
254 }
259
255
260 QList<codeFragment* > PythonQtWrapper_ElfFile::getFragments(ElfFile* theWrappedObject)
256 QList<codeFragment* > PythonQtWrapper_ElfFile::getFragments(ElfFile* theWrappedObject)
261 {
257 {
262 return ( ((PythonQtPublicPromoter_ElfFile*)theWrappedObject)->promoted_getFragments());
258 return ( ((PythonQtPublicPromoter_ElfFile*)theWrappedObject)->promoted_getFragments());
263 }
259 }
264
260
265 QList<codeFragment* > PythonQtWrapper_ElfFile::getFragments(ElfFile* theWrappedObject, QStringList fragmentList)
261 QList<codeFragment* > PythonQtWrapper_ElfFile::getFragments(ElfFile* theWrappedObject, QStringList fragmentList)
266 {
262 {
267 return ( theWrappedObject->getFragments(fragmentList));
263 return ( theWrappedObject->getFragments(fragmentList));
268 }
264 }
269
265
270 int PythonQtWrapper_ElfFile::getSectionCount(ElfFile* theWrappedObject)
266 int PythonQtWrapper_ElfFile::getSectionCount(ElfFile* theWrappedObject)
271 {
267 {
272 return ( theWrappedObject->getSectionCount());
268 return ( theWrappedObject->getSectionCount());
273 }
269 }
274
270
275 bool PythonQtWrapper_ElfFile::getSectionData(ElfFile* theWrappedObject, int index, char** buffer)
271 bool PythonQtWrapper_ElfFile::getSectionData(ElfFile* theWrappedObject, int index, char** buffer)
276 {
272 {
277 return ( theWrappedObject->getSectionData(index, buffer));
273 return ( theWrappedObject->getSectionData(index, buffer));
278 }
274 }
279
275
280 qint64 PythonQtWrapper_ElfFile::getSectionDatasz(ElfFile* theWrappedObject, int index)
276 qint64 PythonQtWrapper_ElfFile::getSectionDatasz(ElfFile* theWrappedObject, int index)
281 {
277 {
282 return ( theWrappedObject->getSectionDatasz(index));
278 return ( theWrappedObject->getSectionDatasz(index));
283 }
279 }
284
280
285 int PythonQtWrapper_ElfFile::getSectionIndex(ElfFile* theWrappedObject, QString name)
281 int PythonQtWrapper_ElfFile::getSectionIndex(ElfFile* theWrappedObject, QString name)
286 {
282 {
287 return ( theWrappedObject->getSectionIndex(name));
283 return ( theWrappedObject->getSectionIndex(name));
288 }
284 }
289
285
290 qint64 PythonQtWrapper_ElfFile::getSectionMemsz(ElfFile* theWrappedObject, int index)
286 qint64 PythonQtWrapper_ElfFile::getSectionMemsz(ElfFile* theWrappedObject, int index)
291 {
287 {
292 return ( theWrappedObject->getSectionMemsz(index));
288 return ( theWrappedObject->getSectionMemsz(index));
293 }
289 }
294
290
295 QString PythonQtWrapper_ElfFile::getSectionName(ElfFile* theWrappedObject, int index)
291 QString PythonQtWrapper_ElfFile::getSectionName(ElfFile* theWrappedObject, int index)
296 {
292 {
297 return ( theWrappedObject->getSectionName(index));
293 return ( theWrappedObject->getSectionName(index));
298 }
294 }
299
295
300 qint64 PythonQtWrapper_ElfFile::getSectionPaddr(ElfFile* theWrappedObject, int index)
296 qint64 PythonQtWrapper_ElfFile::getSectionPaddr(ElfFile* theWrappedObject, int index)
301 {
297 {
302 return ( theWrappedObject->getSectionPaddr(index));
298 return ( theWrappedObject->getSectionPaddr(index));
303 }
299 }
304
300
305 QString PythonQtWrapper_ElfFile::getSectionType(ElfFile* theWrappedObject, int index)
301 QString PythonQtWrapper_ElfFile::getSectionType(ElfFile* theWrappedObject, int index)
306 {
302 {
307 return ( theWrappedObject->getSectionType(index));
303 return ( theWrappedObject->getSectionType(index));
308 }
304 }
309
305
310 int PythonQtWrapper_ElfFile::getSegmentCount(ElfFile* theWrappedObject)
306 int PythonQtWrapper_ElfFile::getSegmentCount(ElfFile* theWrappedObject)
311 {
307 {
312 return ( theWrappedObject->getSegmentCount());
308 return ( theWrappedObject->getSegmentCount());
313 }
309 }
314
310
315 qint64 PythonQtWrapper_ElfFile::getSegmentFilesz(ElfFile* theWrappedObject, int index)
311 qint64 PythonQtWrapper_ElfFile::getSegmentFilesz(ElfFile* theWrappedObject, int index)
316 {
312 {
317 return ( theWrappedObject->getSegmentFilesz(index));
313 return ( theWrappedObject->getSegmentFilesz(index));
318 }
314 }
319
315
320 QString PythonQtWrapper_ElfFile::getSegmentFlags(ElfFile* theWrappedObject, int index)
316 QString PythonQtWrapper_ElfFile::getSegmentFlags(ElfFile* theWrappedObject, int index)
321 {
317 {
322 return ( theWrappedObject->getSegmentFlags(index));
318 return ( theWrappedObject->getSegmentFlags(index));
323 }
319 }
324
320
325 qint64 PythonQtWrapper_ElfFile::getSegmentMemsz(ElfFile* theWrappedObject, int index)
321 qint64 PythonQtWrapper_ElfFile::getSegmentMemsz(ElfFile* theWrappedObject, int index)
326 {
322 {
327 return ( theWrappedObject->getSegmentMemsz(index));
323 return ( theWrappedObject->getSegmentMemsz(index));
328 }
324 }
329
325
330 qint64 PythonQtWrapper_ElfFile::getSegmentOffset(ElfFile* theWrappedObject, int index)
326 qint64 PythonQtWrapper_ElfFile::getSegmentOffset(ElfFile* theWrappedObject, int index)
331 {
327 {
332 return ( theWrappedObject->getSegmentOffset(index));
328 return ( theWrappedObject->getSegmentOffset(index));
333 }
329 }
334
330
335 qint64 PythonQtWrapper_ElfFile::getSegmentPaddr(ElfFile* theWrappedObject, int index)
331 qint64 PythonQtWrapper_ElfFile::getSegmentPaddr(ElfFile* theWrappedObject, int index)
336 {
332 {
337 return ( theWrappedObject->getSegmentPaddr(index));
333 return ( theWrappedObject->getSegmentPaddr(index));
338 }
334 }
339
335
340 QString PythonQtWrapper_ElfFile::getSegmentType(ElfFile* theWrappedObject, int index)
336 QString PythonQtWrapper_ElfFile::getSegmentType(ElfFile* theWrappedObject, int index)
341 {
337 {
342 return ( theWrappedObject->getSegmentType(index));
338 return ( theWrappedObject->getSegmentType(index));
343 }
339 }
344
340
345 qint64 PythonQtWrapper_ElfFile::getSegmentVaddr(ElfFile* theWrappedObject, int index)
341 qint64 PythonQtWrapper_ElfFile::getSegmentVaddr(ElfFile* theWrappedObject, int index)
346 {
342 {
347 return ( theWrappedObject->getSegmentVaddr(index));
343 return ( theWrappedObject->getSegmentVaddr(index));
348 }
344 }
349
345
350 quint64 PythonQtWrapper_ElfFile::getSymbolAddress(ElfFile* theWrappedObject, int index)
346 quint64 PythonQtWrapper_ElfFile::getSymbolAddress(ElfFile* theWrappedObject, int index)
351 {
347 {
352 return ( theWrappedObject->getSymbolAddress(index));
348 return ( theWrappedObject->getSymbolAddress(index));
353 }
349 }
354
350
355 int PythonQtWrapper_ElfFile::getSymbolCount(ElfFile* theWrappedObject)
351 int PythonQtWrapper_ElfFile::getSymbolCount(ElfFile* theWrappedObject)
356 {
352 {
357 return ( theWrappedObject->getSymbolCount());
353 return ( theWrappedObject->getSymbolCount());
358 }
354 }
359
355
360 QString PythonQtWrapper_ElfFile::getSymbolLinkType(ElfFile* theWrappedObject, int index)
356 QString PythonQtWrapper_ElfFile::getSymbolLinkType(ElfFile* theWrappedObject, int index)
361 {
357 {
362 return ( theWrappedObject->getSymbolLinkType(index));
358 return ( theWrappedObject->getSymbolLinkType(index));
363 }
359 }
364
360
365 QString PythonQtWrapper_ElfFile::getSymbolName(ElfFile* theWrappedObject, int index)
361 QString PythonQtWrapper_ElfFile::getSymbolName(ElfFile* theWrappedObject, int index)
366 {
362 {
367 return ( theWrappedObject->getSymbolName(index));
363 return ( theWrappedObject->getSymbolName(index));
368 }
364 }
369
365
370 int PythonQtWrapper_ElfFile::getSymbolSectionIndex(ElfFile* theWrappedObject, int index)
366 int PythonQtWrapper_ElfFile::getSymbolSectionIndex(ElfFile* theWrappedObject, int index)
371 {
367 {
372 return ( theWrappedObject->getSymbolSectionIndex(index));
368 return ( theWrappedObject->getSymbolSectionIndex(index));
373 }
369 }
374
370
375 QString PythonQtWrapper_ElfFile::getSymbolSectionName(ElfFile* theWrappedObject, int index)
371 QString PythonQtWrapper_ElfFile::getSymbolSectionName(ElfFile* theWrappedObject, int index)
376 {
372 {
377 return ( theWrappedObject->getSymbolSectionName(index));
373 return ( theWrappedObject->getSymbolSectionName(index));
378 }
374 }
379
375
380 quint64 PythonQtWrapper_ElfFile::getSymbolSize(ElfFile* theWrappedObject, int index)
376 quint64 PythonQtWrapper_ElfFile::getSymbolSize(ElfFile* theWrappedObject, int index)
381 {
377 {
382 return ( theWrappedObject->getSymbolSize(index));
378 return ( theWrappedObject->getSymbolSize(index));
383 }
379 }
384
380
385 QString PythonQtWrapper_ElfFile::getSymbolType(ElfFile* theWrappedObject, int index)
381 QString PythonQtWrapper_ElfFile::getSymbolType(ElfFile* theWrappedObject, int index)
386 {
382 {
387 return ( theWrappedObject->getSymbolType(index));
383 return ( theWrappedObject->getSymbolType(index));
388 }
384 }
389
385
390 QString PythonQtWrapper_ElfFile::getType(ElfFile* theWrappedObject)
386 QString PythonQtWrapper_ElfFile::getType(ElfFile* theWrappedObject)
391 {
387 {
392 return ( theWrappedObject->getType());
388 return ( theWrappedObject->getType());
393 }
389 }
394
390
395 qint64 PythonQtWrapper_ElfFile::getVersion(ElfFile* theWrappedObject)
391 qint64 PythonQtWrapper_ElfFile::getVersion(ElfFile* theWrappedObject)
396 {
392 {
397 return ( theWrappedObject->getVersion());
393 return ( theWrappedObject->getVersion());
398 }
394 }
399
395
400 bool PythonQtWrapper_ElfFile::static_ElfFile_isElf(const QString& File)
396 bool PythonQtWrapper_ElfFile::static_ElfFile_isElf(const QString& File)
401 {
397 {
402 return (ElfFile::isElf(File));
398 return (ElfFile::isElf(File));
403 }
399 }
404
400
405 bool PythonQtWrapper_ElfFile::iself(ElfFile* theWrappedObject)
401 bool PythonQtWrapper_ElfFile::iself(ElfFile* theWrappedObject)
406 {
402 {
407 return ( theWrappedObject->iself());
403 return ( theWrappedObject->iself());
408 }
404 }
409
405
410 bool PythonQtWrapper_ElfFile::isopened(ElfFile* theWrappedObject)
406 bool PythonQtWrapper_ElfFile::isopened(ElfFile* theWrappedObject)
411 {
407 {
412 return ( ((PythonQtPublicPromoter_ElfFile*)theWrappedObject)->promoted_isopened());
408 return ( ((PythonQtPublicPromoter_ElfFile*)theWrappedObject)->promoted_isopened());
413 }
409 }
414
410
415 bool PythonQtWrapper_ElfFile::openFile(ElfFile* theWrappedObject, const QString& File)
411 bool PythonQtWrapper_ElfFile::openFile(ElfFile* theWrappedObject, const QString& File)
416 {
412 {
417 return ( ((PythonQtPublicPromoter_ElfFile*)theWrappedObject)->promoted_openFile(File));
413 return ( ((PythonQtPublicPromoter_ElfFile*)theWrappedObject)->promoted_openFile(File));
418 }
414 }
419
415
420 bool PythonQtWrapper_ElfFile::sectionIsNobits(ElfFile* theWrappedObject, int index)
416 bool PythonQtWrapper_ElfFile::sectionIsNobits(ElfFile* theWrappedObject, int index)
421 {
417 {
422 return ( theWrappedObject->sectionIsNobits(index));
418 return ( theWrappedObject->sectionIsNobits(index));
423 }
419 }
424
420
425 bool PythonQtWrapper_ElfFile::toBinary(ElfFile* theWrappedObject, const QString& File)
421 bool PythonQtWrapper_ElfFile::toBinary(ElfFile* theWrappedObject, const QString& File)
426 {
422 {
427 return ( ((PythonQtPublicPromoter_ElfFile*)theWrappedObject)->promoted_toBinary(File));
423 return ( ((PythonQtPublicPromoter_ElfFile*)theWrappedObject)->promoted_toBinary(File));
428 }
424 }
429
425
430 bool PythonQtWrapper_ElfFile::toSrec(ElfFile* theWrappedObject, const QString& File)
426 bool PythonQtWrapper_ElfFile::toSrec(ElfFile* theWrappedObject, const QString& File)
431 {
427 {
432 return ( ((PythonQtPublicPromoter_ElfFile*)theWrappedObject)->promoted_toSrec(File));
428 return ( ((PythonQtPublicPromoter_ElfFile*)theWrappedObject)->promoted_toSrec(File));
433 }
429 }
434
430
435
431
436
432
437 PythonQtShell_MemSizeWdgt::~PythonQtShell_MemSizeWdgt() {
433 PythonQtShell_MemSizeWdgt::~PythonQtShell_MemSizeWdgt() {
438 PythonQtPrivate* priv = PythonQt::priv();
434 PythonQtPrivate* priv = PythonQt::priv();
439 if (priv) { priv->shellClassDeleted(this); }
435 if (priv) { priv->shellClassDeleted(this); }
440 }
436 }
441 void PythonQtShell_MemSizeWdgt::actionEvent(QActionEvent* arg__1)
437 void PythonQtShell_MemSizeWdgt::actionEvent(QActionEvent* arg__1)
442 {
438 {
443 if (_wrapper) {
439 if (_wrapper) {
444 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "actionEvent");
440 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "actionEvent");
445 PyErr_Clear();
441 PyErr_Clear();
446 if (obj && !PythonQtSlotFunction_Check(obj)) {
442 if (obj && !PythonQtSlotFunction_Check(obj)) {
447 static const char* argumentList[] ={"" , "QActionEvent*"};
443 static const char* argumentList[] ={"" , "QActionEvent*"};
448 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
444 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
449 void* args[2] = {NULL, (void*)&arg__1};
445 void* args[2] = {NULL, (void*)&arg__1};
450 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
446 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
451 if (result) { Py_DECREF(result); }
447 if (result) { Py_DECREF(result); }
452 Py_DECREF(obj);
448 Py_DECREF(obj);
453 return;
449 return;
454 }
450 }
455 }
451 }
456 MemSizeWdgt::actionEvent(arg__1);
452 MemSizeWdgt::actionEvent(arg__1);
457 }
453 }
458 void PythonQtShell_MemSizeWdgt::changeEvent(QEvent* arg__1)
454 void PythonQtShell_MemSizeWdgt::changeEvent(QEvent* arg__1)
459 {
455 {
460 if (_wrapper) {
456 if (_wrapper) {
461 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "changeEvent");
457 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "changeEvent");
462 PyErr_Clear();
458 PyErr_Clear();
463 if (obj && !PythonQtSlotFunction_Check(obj)) {
459 if (obj && !PythonQtSlotFunction_Check(obj)) {
464 static const char* argumentList[] ={"" , "QEvent*"};
460 static const char* argumentList[] ={"" , "QEvent*"};
465 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
461 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
466 void* args[2] = {NULL, (void*)&arg__1};
462 void* args[2] = {NULL, (void*)&arg__1};
467 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
463 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
468 if (result) { Py_DECREF(result); }
464 if (result) { Py_DECREF(result); }
469 Py_DECREF(obj);
465 Py_DECREF(obj);
470 return;
466 return;
471 }
467 }
472 }
468 }
473 MemSizeWdgt::changeEvent(arg__1);
469 MemSizeWdgt::changeEvent(arg__1);
474 }
470 }
475 void PythonQtShell_MemSizeWdgt::childEvent(QChildEvent* arg__1)
471 void PythonQtShell_MemSizeWdgt::childEvent(QChildEvent* arg__1)
476 {
472 {
477 if (_wrapper) {
473 if (_wrapper) {
478 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "childEvent");
474 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "childEvent");
479 PyErr_Clear();
475 PyErr_Clear();
480 if (obj && !PythonQtSlotFunction_Check(obj)) {
476 if (obj && !PythonQtSlotFunction_Check(obj)) {
481 static const char* argumentList[] ={"" , "QChildEvent*"};
477 static const char* argumentList[] ={"" , "QChildEvent*"};
482 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
478 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
483 void* args[2] = {NULL, (void*)&arg__1};
479 void* args[2] = {NULL, (void*)&arg__1};
484 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
480 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
485 if (result) { Py_DECREF(result); }
481 if (result) { Py_DECREF(result); }
486 Py_DECREF(obj);
482 Py_DECREF(obj);
487 return;
483 return;
488 }
484 }
489 }
485 }
490 MemSizeWdgt::childEvent(arg__1);
486 MemSizeWdgt::childEvent(arg__1);
491 }
487 }
492 void PythonQtShell_MemSizeWdgt::closeEvent(QCloseEvent* arg__1)
488 void PythonQtShell_MemSizeWdgt::closeEvent(QCloseEvent* arg__1)
493 {
489 {
494 if (_wrapper) {
490 if (_wrapper) {
495 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "closeEvent");
491 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "closeEvent");
496 PyErr_Clear();
492 PyErr_Clear();
497 if (obj && !PythonQtSlotFunction_Check(obj)) {
493 if (obj && !PythonQtSlotFunction_Check(obj)) {
498 static const char* argumentList[] ={"" , "QCloseEvent*"};
494 static const char* argumentList[] ={"" , "QCloseEvent*"};
499 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
495 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
500 void* args[2] = {NULL, (void*)&arg__1};
496 void* args[2] = {NULL, (void*)&arg__1};
501 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
497 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
502 if (result) { Py_DECREF(result); }
498 if (result) { Py_DECREF(result); }
503 Py_DECREF(obj);
499 Py_DECREF(obj);
504 return;
500 return;
505 }
501 }
506 }
502 }
507 MemSizeWdgt::closeEvent(arg__1);
503 MemSizeWdgt::closeEvent(arg__1);
508 }
504 }
509 void PythonQtShell_MemSizeWdgt::contextMenuEvent(QContextMenuEvent* arg__1)
505 void PythonQtShell_MemSizeWdgt::contextMenuEvent(QContextMenuEvent* arg__1)
510 {
506 {
511 if (_wrapper) {
507 if (_wrapper) {
512 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "contextMenuEvent");
508 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "contextMenuEvent");
513 PyErr_Clear();
509 PyErr_Clear();
514 if (obj && !PythonQtSlotFunction_Check(obj)) {
510 if (obj && !PythonQtSlotFunction_Check(obj)) {
515 static const char* argumentList[] ={"" , "QContextMenuEvent*"};
511 static const char* argumentList[] ={"" , "QContextMenuEvent*"};
516 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
512 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
517 void* args[2] = {NULL, (void*)&arg__1};
513 void* args[2] = {NULL, (void*)&arg__1};
518 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
514 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
519 if (result) { Py_DECREF(result); }
515 if (result) { Py_DECREF(result); }
520 Py_DECREF(obj);
516 Py_DECREF(obj);
521 return;
517 return;
522 }
518 }
523 }
519 }
524 MemSizeWdgt::contextMenuEvent(arg__1);
520 MemSizeWdgt::contextMenuEvent(arg__1);
525 }
521 }
526 void PythonQtShell_MemSizeWdgt::customEvent(QEvent* arg__1)
522 void PythonQtShell_MemSizeWdgt::customEvent(QEvent* arg__1)
527 {
523 {
528 if (_wrapper) {
524 if (_wrapper) {
529 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "customEvent");
525 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "customEvent");
530 PyErr_Clear();
526 PyErr_Clear();
531 if (obj && !PythonQtSlotFunction_Check(obj)) {
527 if (obj && !PythonQtSlotFunction_Check(obj)) {
532 static const char* argumentList[] ={"" , "QEvent*"};
528 static const char* argumentList[] ={"" , "QEvent*"};
533 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
529 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
534 void* args[2] = {NULL, (void*)&arg__1};
530 void* args[2] = {NULL, (void*)&arg__1};
535 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
531 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
536 if (result) { Py_DECREF(result); }
532 if (result) { Py_DECREF(result); }
537 Py_DECREF(obj);
533 Py_DECREF(obj);
538 return;
534 return;
539 }
535 }
540 }
536 }
541 MemSizeWdgt::customEvent(arg__1);
537 MemSizeWdgt::customEvent(arg__1);
542 }
538 }
543 int PythonQtShell_MemSizeWdgt::devType() const
539 int PythonQtShell_MemSizeWdgt::devType() const
544 {
540 {
545 if (_wrapper) {
541 if (_wrapper) {
546 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "devType");
542 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "devType");
547 PyErr_Clear();
543 PyErr_Clear();
548 if (obj && !PythonQtSlotFunction_Check(obj)) {
544 if (obj && !PythonQtSlotFunction_Check(obj)) {
549 static const char* argumentList[] ={"int"};
545 static const char* argumentList[] ={"int"};
550 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
546 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
551 int returnValue;
547 int returnValue;
552 void* args[1] = {NULL};
548 void* args[1] = {NULL};
553 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
549 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
554 if (result) {
550 if (result) {
555 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
551 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
556 if (args[0]!=&returnValue) {
552 if (args[0]!=&returnValue) {
557 if (args[0]==NULL) {
553 if (args[0]==NULL) {
558 PythonQt::priv()->handleVirtualOverloadReturnError("devType", methodInfo, result);
554 PythonQt::priv()->handleVirtualOverloadReturnError("devType", methodInfo, result);
559 } else {
555 } else {
560 returnValue = *((int*)args[0]);
556 returnValue = *((int*)args[0]);
561 }
557 }
562 }
558 }
563 }
559 }
564 if (result) { Py_DECREF(result); }
560 if (result) { Py_DECREF(result); }
565 Py_DECREF(obj);
561 Py_DECREF(obj);
566 return returnValue;
562 return returnValue;
567 }
563 }
568 }
564 }
569 return MemSizeWdgt::devType();
565 return MemSizeWdgt::devType();
570 }
566 }
571 void PythonQtShell_MemSizeWdgt::dragEnterEvent(QDragEnterEvent* arg__1)
567 void PythonQtShell_MemSizeWdgt::dragEnterEvent(QDragEnterEvent* arg__1)
572 {
568 {
573 if (_wrapper) {
569 if (_wrapper) {
574 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragEnterEvent");
570 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragEnterEvent");
575 PyErr_Clear();
571 PyErr_Clear();
576 if (obj && !PythonQtSlotFunction_Check(obj)) {
572 if (obj && !PythonQtSlotFunction_Check(obj)) {
577 static const char* argumentList[] ={"" , "QDragEnterEvent*"};
573 static const char* argumentList[] ={"" , "QDragEnterEvent*"};
578 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
574 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
579 void* args[2] = {NULL, (void*)&arg__1};
575 void* args[2] = {NULL, (void*)&arg__1};
580 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
576 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
581 if (result) { Py_DECREF(result); }
577 if (result) { Py_DECREF(result); }
582 Py_DECREF(obj);
578 Py_DECREF(obj);
583 return;
579 return;
584 }
580 }
585 }
581 }
586 MemSizeWdgt::dragEnterEvent(arg__1);
582 MemSizeWdgt::dragEnterEvent(arg__1);
587 }
583 }
588 void PythonQtShell_MemSizeWdgt::dragLeaveEvent(QDragLeaveEvent* arg__1)
584 void PythonQtShell_MemSizeWdgt::dragLeaveEvent(QDragLeaveEvent* arg__1)
589 {
585 {
590 if (_wrapper) {
586 if (_wrapper) {
591 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragLeaveEvent");
587 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragLeaveEvent");
592 PyErr_Clear();
588 PyErr_Clear();
593 if (obj && !PythonQtSlotFunction_Check(obj)) {
589 if (obj && !PythonQtSlotFunction_Check(obj)) {
594 static const char* argumentList[] ={"" , "QDragLeaveEvent*"};
590 static const char* argumentList[] ={"" , "QDragLeaveEvent*"};
595 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
591 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
596 void* args[2] = {NULL, (void*)&arg__1};
592 void* args[2] = {NULL, (void*)&arg__1};
597 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
593 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
598 if (result) { Py_DECREF(result); }
594 if (result) { Py_DECREF(result); }
599 Py_DECREF(obj);
595 Py_DECREF(obj);
600 return;
596 return;
601 }
597 }
602 }
598 }
603 MemSizeWdgt::dragLeaveEvent(arg__1);
599 MemSizeWdgt::dragLeaveEvent(arg__1);
604 }
600 }
605 void PythonQtShell_MemSizeWdgt::dragMoveEvent(QDragMoveEvent* arg__1)
601 void PythonQtShell_MemSizeWdgt::dragMoveEvent(QDragMoveEvent* arg__1)
606 {
602 {
607 if (_wrapper) {
603 if (_wrapper) {
608 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragMoveEvent");
604 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragMoveEvent");
609 PyErr_Clear();
605 PyErr_Clear();
610 if (obj && !PythonQtSlotFunction_Check(obj)) {
606 if (obj && !PythonQtSlotFunction_Check(obj)) {
611 static const char* argumentList[] ={"" , "QDragMoveEvent*"};
607 static const char* argumentList[] ={"" , "QDragMoveEvent*"};
612 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
608 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
613 void* args[2] = {NULL, (void*)&arg__1};
609 void* args[2] = {NULL, (void*)&arg__1};
614 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
610 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
615 if (result) { Py_DECREF(result); }
611 if (result) { Py_DECREF(result); }
616 Py_DECREF(obj);
612 Py_DECREF(obj);
617 return;
613 return;
618 }
614 }
619 }
615 }
620 MemSizeWdgt::dragMoveEvent(arg__1);
616 MemSizeWdgt::dragMoveEvent(arg__1);
621 }
617 }
622 void PythonQtShell_MemSizeWdgt::dropEvent(QDropEvent* arg__1)
618 void PythonQtShell_MemSizeWdgt::dropEvent(QDropEvent* arg__1)
623 {
619 {
624 if (_wrapper) {
620 if (_wrapper) {
625 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dropEvent");
621 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dropEvent");
626 PyErr_Clear();
622 PyErr_Clear();
627 if (obj && !PythonQtSlotFunction_Check(obj)) {
623 if (obj && !PythonQtSlotFunction_Check(obj)) {
628 static const char* argumentList[] ={"" , "QDropEvent*"};
624 static const char* argumentList[] ={"" , "QDropEvent*"};
629 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
625 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
630 void* args[2] = {NULL, (void*)&arg__1};
626 void* args[2] = {NULL, (void*)&arg__1};
631 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
627 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
632 if (result) { Py_DECREF(result); }
628 if (result) { Py_DECREF(result); }
633 Py_DECREF(obj);
629 Py_DECREF(obj);
634 return;
630 return;
635 }
631 }
636 }
632 }
637 MemSizeWdgt::dropEvent(arg__1);
633 MemSizeWdgt::dropEvent(arg__1);
638 }
634 }
639 void PythonQtShell_MemSizeWdgt::enterEvent(QEvent* arg__1)
635 void PythonQtShell_MemSizeWdgt::enterEvent(QEvent* arg__1)
640 {
636 {
641 if (_wrapper) {
637 if (_wrapper) {
642 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "enterEvent");
638 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "enterEvent");
643 PyErr_Clear();
639 PyErr_Clear();
644 if (obj && !PythonQtSlotFunction_Check(obj)) {
640 if (obj && !PythonQtSlotFunction_Check(obj)) {
645 static const char* argumentList[] ={"" , "QEvent*"};
641 static const char* argumentList[] ={"" , "QEvent*"};
646 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
642 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
647 void* args[2] = {NULL, (void*)&arg__1};
643 void* args[2] = {NULL, (void*)&arg__1};
648 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
644 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
649 if (result) { Py_DECREF(result); }
645 if (result) { Py_DECREF(result); }
650 Py_DECREF(obj);
646 Py_DECREF(obj);
651 return;
647 return;
652 }
648 }
653 }
649 }
654 MemSizeWdgt::enterEvent(arg__1);
650 MemSizeWdgt::enterEvent(arg__1);
655 }
651 }
656 bool PythonQtShell_MemSizeWdgt::event(QEvent* arg__1)
652 bool PythonQtShell_MemSizeWdgt::event(QEvent* arg__1)
657 {
653 {
658 if (_wrapper) {
654 if (_wrapper) {
659 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "event");
655 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "event");
660 PyErr_Clear();
656 PyErr_Clear();
661 if (obj && !PythonQtSlotFunction_Check(obj)) {
657 if (obj && !PythonQtSlotFunction_Check(obj)) {
662 static const char* argumentList[] ={"bool" , "QEvent*"};
658 static const char* argumentList[] ={"bool" , "QEvent*"};
663 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
659 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
664 bool returnValue;
660 bool returnValue;
665 void* args[2] = {NULL, (void*)&arg__1};
661 void* args[2] = {NULL, (void*)&arg__1};
666 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
662 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
667 if (result) {
663 if (result) {
668 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
664 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
669 if (args[0]!=&returnValue) {
665 if (args[0]!=&returnValue) {
670 if (args[0]==NULL) {
666 if (args[0]==NULL) {
671 PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
667 PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
672 } else {
668 } else {
673 returnValue = *((bool*)args[0]);
669 returnValue = *((bool*)args[0]);
674 }
670 }
675 }
671 }
676 }
672 }
677 if (result) { Py_DECREF(result); }
673 if (result) { Py_DECREF(result); }
678 Py_DECREF(obj);
674 Py_DECREF(obj);
679 return returnValue;
675 return returnValue;
680 }
676 }
681 }
677 }
682 return MemSizeWdgt::event(arg__1);
678 return MemSizeWdgt::event(arg__1);
683 }
679 }
684 bool PythonQtShell_MemSizeWdgt::eventFilter(QObject* arg__1, QEvent* arg__2)
680 bool PythonQtShell_MemSizeWdgt::eventFilter(QObject* arg__1, QEvent* arg__2)
685 {
681 {
686 if (_wrapper) {
682 if (_wrapper) {
687 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "eventFilter");
683 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "eventFilter");
688 PyErr_Clear();
684 PyErr_Clear();
689 if (obj && !PythonQtSlotFunction_Check(obj)) {
685 if (obj && !PythonQtSlotFunction_Check(obj)) {
690 static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
686 static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
691 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
687 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
692 bool returnValue;
688 bool returnValue;
693 void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2};
689 void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2};
694 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
690 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
695 if (result) {
691 if (result) {
696 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
692 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
697 if (args[0]!=&returnValue) {
693 if (args[0]!=&returnValue) {
698 if (args[0]==NULL) {
694 if (args[0]==NULL) {
699 PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
695 PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
700 } else {
696 } else {
701 returnValue = *((bool*)args[0]);
697 returnValue = *((bool*)args[0]);
702 }
698 }
703 }
699 }
704 }
700 }
705 if (result) { Py_DECREF(result); }
701 if (result) { Py_DECREF(result); }
706 Py_DECREF(obj);
702 Py_DECREF(obj);
707 return returnValue;
703 return returnValue;
708 }
704 }
709 }
705 }
710 return MemSizeWdgt::eventFilter(arg__1, arg__2);
706 return MemSizeWdgt::eventFilter(arg__1, arg__2);
711 }
707 }
712 void PythonQtShell_MemSizeWdgt::focusInEvent(QFocusEvent* arg__1)
708 void PythonQtShell_MemSizeWdgt::focusInEvent(QFocusEvent* arg__1)
713 {
709 {
714 if (_wrapper) {
710 if (_wrapper) {
715 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusInEvent");
711 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusInEvent");
716 PyErr_Clear();
712 PyErr_Clear();
717 if (obj && !PythonQtSlotFunction_Check(obj)) {
713 if (obj && !PythonQtSlotFunction_Check(obj)) {
718 static const char* argumentList[] ={"" , "QFocusEvent*"};
714 static const char* argumentList[] ={"" , "QFocusEvent*"};
719 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
715 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
720 void* args[2] = {NULL, (void*)&arg__1};
716 void* args[2] = {NULL, (void*)&arg__1};
721 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
717 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
722 if (result) { Py_DECREF(result); }
718 if (result) { Py_DECREF(result); }
723 Py_DECREF(obj);
719 Py_DECREF(obj);
724 return;
720 return;
725 }
721 }
726 }
722 }
727 MemSizeWdgt::focusInEvent(arg__1);
723 MemSizeWdgt::focusInEvent(arg__1);
728 }
724 }
729 bool PythonQtShell_MemSizeWdgt::focusNextPrevChild(bool next)
725 bool PythonQtShell_MemSizeWdgt::focusNextPrevChild(bool next)
730 {
726 {
731 if (_wrapper) {
727 if (_wrapper) {
732 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusNextPrevChild");
728 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusNextPrevChild");
733 PyErr_Clear();
729 PyErr_Clear();
734 if (obj && !PythonQtSlotFunction_Check(obj)) {
730 if (obj && !PythonQtSlotFunction_Check(obj)) {
735 static const char* argumentList[] ={"bool" , "bool"};
731 static const char* argumentList[] ={"bool" , "bool"};
736 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
732 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
737 bool returnValue;
733 bool returnValue;
738 void* args[2] = {NULL, (void*)&next};
734 void* args[2] = {NULL, (void*)&next};
739 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
735 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
740 if (result) {
736 if (result) {
741 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
737 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
742 if (args[0]!=&returnValue) {
738 if (args[0]!=&returnValue) {
743 if (args[0]==NULL) {
739 if (args[0]==NULL) {
744 PythonQt::priv()->handleVirtualOverloadReturnError("focusNextPrevChild", methodInfo, result);
740 PythonQt::priv()->handleVirtualOverloadReturnError("focusNextPrevChild", methodInfo, result);
745 } else {
741 } else {
746 returnValue = *((bool*)args[0]);
742 returnValue = *((bool*)args[0]);
747 }
743 }
748 }
744 }
749 }
745 }
750 if (result) { Py_DECREF(result); }
746 if (result) { Py_DECREF(result); }
751 Py_DECREF(obj);
747 Py_DECREF(obj);
752 return returnValue;
748 return returnValue;
753 }
749 }
754 }
750 }
755 return MemSizeWdgt::focusNextPrevChild(next);
751 return MemSizeWdgt::focusNextPrevChild(next);
756 }
752 }
757 void PythonQtShell_MemSizeWdgt::focusOutEvent(QFocusEvent* arg__1)
753 void PythonQtShell_MemSizeWdgt::focusOutEvent(QFocusEvent* arg__1)
758 {
754 {
759 if (_wrapper) {
755 if (_wrapper) {
760 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusOutEvent");
756 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusOutEvent");
761 PyErr_Clear();
757 PyErr_Clear();
762 if (obj && !PythonQtSlotFunction_Check(obj)) {
758 if (obj && !PythonQtSlotFunction_Check(obj)) {
763 static const char* argumentList[] ={"" , "QFocusEvent*"};
759 static const char* argumentList[] ={"" , "QFocusEvent*"};
764 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
760 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
765 void* args[2] = {NULL, (void*)&arg__1};
761 void* args[2] = {NULL, (void*)&arg__1};
766 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
762 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
767 if (result) { Py_DECREF(result); }
763 if (result) { Py_DECREF(result); }
768 Py_DECREF(obj);
764 Py_DECREF(obj);
769 return;
765 return;
770 }
766 }
771 }
767 }
772 MemSizeWdgt::focusOutEvent(arg__1);
768 MemSizeWdgt::focusOutEvent(arg__1);
773 }
769 }
774 bool PythonQtShell_MemSizeWdgt::hasHeightForWidth() const
770 bool PythonQtShell_MemSizeWdgt::hasHeightForWidth() const
775 {
771 {
776 if (_wrapper) {
772 if (_wrapper) {
777 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hasHeightForWidth");
773 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hasHeightForWidth");
778 PyErr_Clear();
774 PyErr_Clear();
779 if (obj && !PythonQtSlotFunction_Check(obj)) {
775 if (obj && !PythonQtSlotFunction_Check(obj)) {
780 static const char* argumentList[] ={"bool"};
776 static const char* argumentList[] ={"bool"};
781 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
777 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
782 bool returnValue;
778 bool returnValue;
783 void* args[1] = {NULL};
779 void* args[1] = {NULL};
784 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
780 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
785 if (result) {
781 if (result) {
786 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
782 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
787 if (args[0]!=&returnValue) {
783 if (args[0]!=&returnValue) {
788 if (args[0]==NULL) {
784 if (args[0]==NULL) {
789 PythonQt::priv()->handleVirtualOverloadReturnError("hasHeightForWidth", methodInfo, result);
785 PythonQt::priv()->handleVirtualOverloadReturnError("hasHeightForWidth", methodInfo, result);
790 } else {
786 } else {
791 returnValue = *((bool*)args[0]);
787 returnValue = *((bool*)args[0]);
792 }
788 }
793 }
789 }
794 }
790 }
795 if (result) { Py_DECREF(result); }
791 if (result) { Py_DECREF(result); }
796 Py_DECREF(obj);
792 Py_DECREF(obj);
797 return returnValue;
793 return returnValue;
798 }
794 }
799 }
795 }
800 return MemSizeWdgt::hasHeightForWidth();
796 return MemSizeWdgt::hasHeightForWidth();
801 }
797 }
802 int PythonQtShell_MemSizeWdgt::heightForWidth(int arg__1) const
798 int PythonQtShell_MemSizeWdgt::heightForWidth(int arg__1) const
803 {
799 {
804 if (_wrapper) {
800 if (_wrapper) {
805 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "heightForWidth");
801 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "heightForWidth");
806 PyErr_Clear();
802 PyErr_Clear();
807 if (obj && !PythonQtSlotFunction_Check(obj)) {
803 if (obj && !PythonQtSlotFunction_Check(obj)) {
808 static const char* argumentList[] ={"int" , "int"};
804 static const char* argumentList[] ={"int" , "int"};
809 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
805 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
810 int returnValue;
806 int returnValue;
811 void* args[2] = {NULL, (void*)&arg__1};
807 void* args[2] = {NULL, (void*)&arg__1};
812 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
808 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
813 if (result) {
809 if (result) {
814 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
810 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
815 if (args[0]!=&returnValue) {
811 if (args[0]!=&returnValue) {
816 if (args[0]==NULL) {
812 if (args[0]==NULL) {
817 PythonQt::priv()->handleVirtualOverloadReturnError("heightForWidth", methodInfo, result);
813 PythonQt::priv()->handleVirtualOverloadReturnError("heightForWidth", methodInfo, result);
818 } else {
814 } else {
819 returnValue = *((int*)args[0]);
815 returnValue = *((int*)args[0]);
820 }
816 }
821 }
817 }
822 }
818 }
823 if (result) { Py_DECREF(result); }
819 if (result) { Py_DECREF(result); }
824 Py_DECREF(obj);
820 Py_DECREF(obj);
825 return returnValue;
821 return returnValue;
826 }
822 }
827 }
823 }
828 return MemSizeWdgt::heightForWidth(arg__1);
824 return MemSizeWdgt::heightForWidth(arg__1);
829 }
825 }
830 void PythonQtShell_MemSizeWdgt::hideEvent(QHideEvent* arg__1)
826 void PythonQtShell_MemSizeWdgt::hideEvent(QHideEvent* arg__1)
831 {
827 {
832 if (_wrapper) {
828 if (_wrapper) {
833 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hideEvent");
829 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hideEvent");
834 PyErr_Clear();
830 PyErr_Clear();
835 if (obj && !PythonQtSlotFunction_Check(obj)) {
831 if (obj && !PythonQtSlotFunction_Check(obj)) {
836 static const char* argumentList[] ={"" , "QHideEvent*"};
832 static const char* argumentList[] ={"" , "QHideEvent*"};
837 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
833 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
838 void* args[2] = {NULL, (void*)&arg__1};
834 void* args[2] = {NULL, (void*)&arg__1};
839 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
835 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
840 if (result) { Py_DECREF(result); }
836 if (result) { Py_DECREF(result); }
841 Py_DECREF(obj);
837 Py_DECREF(obj);
842 return;
838 return;
843 }
839 }
844 }
840 }
845 MemSizeWdgt::hideEvent(arg__1);
841 MemSizeWdgt::hideEvent(arg__1);
846 }
842 }
847 void PythonQtShell_MemSizeWdgt::initPainter(QPainter* painter) const
843 void PythonQtShell_MemSizeWdgt::initPainter(QPainter* painter) const
848 {
844 {
849 if (_wrapper) {
845 if (_wrapper) {
850 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "initPainter");
846 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "initPainter");
851 PyErr_Clear();
847 PyErr_Clear();
852 if (obj && !PythonQtSlotFunction_Check(obj)) {
848 if (obj && !PythonQtSlotFunction_Check(obj)) {
853 static const char* argumentList[] ={"" , "QPainter*"};
849 static const char* argumentList[] ={"" , "QPainter*"};
854 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
850 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
855 void* args[2] = {NULL, (void*)&painter};
851 void* args[2] = {NULL, (void*)&painter};
856 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
852 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
857 if (result) { Py_DECREF(result); }
853 if (result) { Py_DECREF(result); }
858 Py_DECREF(obj);
854 Py_DECREF(obj);
859 return;
855 return;
860 }
856 }
861 }
857 }
862 MemSizeWdgt::initPainter(painter);
858 MemSizeWdgt::initPainter(painter);
863 }
859 }
864 void PythonQtShell_MemSizeWdgt::inputMethodEvent(QInputMethodEvent* arg__1)
860 void PythonQtShell_MemSizeWdgt::inputMethodEvent(QInputMethodEvent* arg__1)
865 {
861 {
866 if (_wrapper) {
862 if (_wrapper) {
867 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodEvent");
863 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodEvent");
868 PyErr_Clear();
864 PyErr_Clear();
869 if (obj && !PythonQtSlotFunction_Check(obj)) {
865 if (obj && !PythonQtSlotFunction_Check(obj)) {
870 static const char* argumentList[] ={"" , "QInputMethodEvent*"};
866 static const char* argumentList[] ={"" , "QInputMethodEvent*"};
871 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
867 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
872 void* args[2] = {NULL, (void*)&arg__1};
868 void* args[2] = {NULL, (void*)&arg__1};
873 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
869 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
874 if (result) { Py_DECREF(result); }
870 if (result) { Py_DECREF(result); }
875 Py_DECREF(obj);
871 Py_DECREF(obj);
876 return;
872 return;
877 }
873 }
878 }
874 }
879 MemSizeWdgt::inputMethodEvent(arg__1);
875 MemSizeWdgt::inputMethodEvent(arg__1);
880 }
876 }
881 QVariant PythonQtShell_MemSizeWdgt::inputMethodQuery(Qt::InputMethodQuery arg__1) const
877 QVariant PythonQtShell_MemSizeWdgt::inputMethodQuery(Qt::InputMethodQuery arg__1) const
882 {
878 {
883 if (_wrapper) {
879 if (_wrapper) {
884 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodQuery");
880 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodQuery");
885 PyErr_Clear();
881 PyErr_Clear();
886 if (obj && !PythonQtSlotFunction_Check(obj)) {
882 if (obj && !PythonQtSlotFunction_Check(obj)) {
887 static const char* argumentList[] ={"QVariant" , "Qt::InputMethodQuery"};
883 static const char* argumentList[] ={"QVariant" , "Qt::InputMethodQuery"};
888 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
884 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
889 QVariant returnValue;
885 QVariant returnValue;
890 void* args[2] = {NULL, (void*)&arg__1};
886 void* args[2] = {NULL, (void*)&arg__1};
891 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
887 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
892 if (result) {
888 if (result) {
893 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
889 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
894 if (args[0]!=&returnValue) {
890 if (args[0]!=&returnValue) {
895 if (args[0]==NULL) {
891 if (args[0]==NULL) {
896 PythonQt::priv()->handleVirtualOverloadReturnError("inputMethodQuery", methodInfo, result);
892 PythonQt::priv()->handleVirtualOverloadReturnError("inputMethodQuery", methodInfo, result);
897 } else {
893 } else {
898 returnValue = *((QVariant*)args[0]);
894 returnValue = *((QVariant*)args[0]);
899 }
895 }
900 }
896 }
901 }
897 }
902 if (result) { Py_DECREF(result); }
898 if (result) { Py_DECREF(result); }
903 Py_DECREF(obj);
899 Py_DECREF(obj);
904 return returnValue;
900 return returnValue;
905 }
901 }
906 }
902 }
907 return MemSizeWdgt::inputMethodQuery(arg__1);
903 return MemSizeWdgt::inputMethodQuery(arg__1);
908 }
904 }
909 void PythonQtShell_MemSizeWdgt::keyPressEvent(QKeyEvent* arg__1)
905 void PythonQtShell_MemSizeWdgt::keyPressEvent(QKeyEvent* arg__1)
910 {
906 {
911 if (_wrapper) {
907 if (_wrapper) {
912 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyPressEvent");
908 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyPressEvent");
913 PyErr_Clear();
909 PyErr_Clear();
914 if (obj && !PythonQtSlotFunction_Check(obj)) {
910 if (obj && !PythonQtSlotFunction_Check(obj)) {
915 static const char* argumentList[] ={"" , "QKeyEvent*"};
911 static const char* argumentList[] ={"" , "QKeyEvent*"};
916 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
912 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
917 void* args[2] = {NULL, (void*)&arg__1};
913 void* args[2] = {NULL, (void*)&arg__1};
918 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
914 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
919 if (result) { Py_DECREF(result); }
915 if (result) { Py_DECREF(result); }
920 Py_DECREF(obj);
916 Py_DECREF(obj);
921 return;
917 return;
922 }
918 }
923 }
919 }
924 MemSizeWdgt::keyPressEvent(arg__1);
920 MemSizeWdgt::keyPressEvent(arg__1);
925 }
921 }
926 void PythonQtShell_MemSizeWdgt::keyReleaseEvent(QKeyEvent* arg__1)
922 void PythonQtShell_MemSizeWdgt::keyReleaseEvent(QKeyEvent* arg__1)
927 {
923 {
928 if (_wrapper) {
924 if (_wrapper) {
929 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyReleaseEvent");
925 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyReleaseEvent");
930 PyErr_Clear();
926 PyErr_Clear();
931 if (obj && !PythonQtSlotFunction_Check(obj)) {
927 if (obj && !PythonQtSlotFunction_Check(obj)) {
932 static const char* argumentList[] ={"" , "QKeyEvent*"};
928 static const char* argumentList[] ={"" , "QKeyEvent*"};
933 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
929 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
934 void* args[2] = {NULL, (void*)&arg__1};
930 void* args[2] = {NULL, (void*)&arg__1};
935 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
931 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
936 if (result) { Py_DECREF(result); }
932 if (result) { Py_DECREF(result); }
937 Py_DECREF(obj);
933 Py_DECREF(obj);
938 return;
934 return;
939 }
935 }
940 }
936 }
941 MemSizeWdgt::keyReleaseEvent(arg__1);
937 MemSizeWdgt::keyReleaseEvent(arg__1);
942 }
938 }
943 void PythonQtShell_MemSizeWdgt::leaveEvent(QEvent* arg__1)
939 void PythonQtShell_MemSizeWdgt::leaveEvent(QEvent* arg__1)
944 {
940 {
945 if (_wrapper) {
941 if (_wrapper) {
946 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "leaveEvent");
942 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "leaveEvent");
947 PyErr_Clear();
943 PyErr_Clear();
948 if (obj && !PythonQtSlotFunction_Check(obj)) {
944 if (obj && !PythonQtSlotFunction_Check(obj)) {
949 static const char* argumentList[] ={"" , "QEvent*"};
945 static const char* argumentList[] ={"" , "QEvent*"};
950 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
946 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
951 void* args[2] = {NULL, (void*)&arg__1};
947 void* args[2] = {NULL, (void*)&arg__1};
952 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
948 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
953 if (result) { Py_DECREF(result); }
949 if (result) { Py_DECREF(result); }
954 Py_DECREF(obj);
950 Py_DECREF(obj);
955 return;
951 return;
956 }
952 }
957 }
953 }
958 MemSizeWdgt::leaveEvent(arg__1);
954 MemSizeWdgt::leaveEvent(arg__1);
959 }
955 }
960 int PythonQtShell_MemSizeWdgt::metric(QPaintDevice::PaintDeviceMetric arg__1) const
956 int PythonQtShell_MemSizeWdgt::metric(QPaintDevice::PaintDeviceMetric arg__1) const
961 {
957 {
962 if (_wrapper) {
958 if (_wrapper) {
963 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "metric");
959 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "metric");
964 PyErr_Clear();
960 PyErr_Clear();
965 if (obj && !PythonQtSlotFunction_Check(obj)) {
961 if (obj && !PythonQtSlotFunction_Check(obj)) {
966 static const char* argumentList[] ={"int" , "QPaintDevice::PaintDeviceMetric"};
962 static const char* argumentList[] ={"int" , "QPaintDevice::PaintDeviceMetric"};
967 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
963 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
968 int returnValue;
964 int returnValue;
969 void* args[2] = {NULL, (void*)&arg__1};
965 void* args[2] = {NULL, (void*)&arg__1};
970 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
966 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
971 if (result) {
967 if (result) {
972 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
968 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
973 if (args[0]!=&returnValue) {
969 if (args[0]!=&returnValue) {
974 if (args[0]==NULL) {
970 if (args[0]==NULL) {
975 PythonQt::priv()->handleVirtualOverloadReturnError("metric", methodInfo, result);
971 PythonQt::priv()->handleVirtualOverloadReturnError("metric", methodInfo, result);
976 } else {
972 } else {
977 returnValue = *((int*)args[0]);
973 returnValue = *((int*)args[0]);
978 }
974 }
979 }
975 }
980 }
976 }
981 if (result) { Py_DECREF(result); }
977 if (result) { Py_DECREF(result); }
982 Py_DECREF(obj);
978 Py_DECREF(obj);
983 return returnValue;
979 return returnValue;
984 }
980 }
985 }
981 }
986 return MemSizeWdgt::metric(arg__1);
982 return MemSizeWdgt::metric(arg__1);
987 }
983 }
988 QSize PythonQtShell_MemSizeWdgt::minimumSizeHint() const
984 QSize PythonQtShell_MemSizeWdgt::minimumSizeHint() const
989 {
985 {
990 if (_wrapper) {
986 if (_wrapper) {
991 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getMinimumSizeHint");
987 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getMinimumSizeHint");
992 PyErr_Clear();
988 PyErr_Clear();
993 if (obj && !PythonQtSlotFunction_Check(obj)) {
989 if (obj && !PythonQtSlotFunction_Check(obj)) {
994 static const char* argumentList[] ={"QSize"};
990 static const char* argumentList[] ={"QSize"};
995 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
991 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
996 QSize returnValue;
992 QSize returnValue;
997 void* args[1] = {NULL};
993 void* args[1] = {NULL};
998 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
994 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
999 if (result) {
995 if (result) {
1000 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
996 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1001 if (args[0]!=&returnValue) {
997 if (args[0]!=&returnValue) {
1002 if (args[0]==NULL) {
998 if (args[0]==NULL) {
1003 PythonQt::priv()->handleVirtualOverloadReturnError("getMinimumSizeHint", methodInfo, result);
999 PythonQt::priv()->handleVirtualOverloadReturnError("getMinimumSizeHint", methodInfo, result);
1004 } else {
1000 } else {
1005 returnValue = *((QSize*)args[0]);
1001 returnValue = *((QSize*)args[0]);
1006 }
1002 }
1007 }
1003 }
1008 }
1004 }
1009 if (result) { Py_DECREF(result); }
1005 if (result) { Py_DECREF(result); }
1010 Py_DECREF(obj);
1006 Py_DECREF(obj);
1011 return returnValue;
1007 return returnValue;
1012 }
1008 }
1013 }
1009 }
1014 return MemSizeWdgt::minimumSizeHint();
1010 return MemSizeWdgt::minimumSizeHint();
1015 }
1011 }
1016 void PythonQtShell_MemSizeWdgt::mouseDoubleClickEvent(QMouseEvent* arg__1)
1012 void PythonQtShell_MemSizeWdgt::mouseDoubleClickEvent(QMouseEvent* arg__1)
1017 {
1013 {
1018 if (_wrapper) {
1014 if (_wrapper) {
1019 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseDoubleClickEvent");
1015 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseDoubleClickEvent");
1020 PyErr_Clear();
1016 PyErr_Clear();
1021 if (obj && !PythonQtSlotFunction_Check(obj)) {
1017 if (obj && !PythonQtSlotFunction_Check(obj)) {
1022 static const char* argumentList[] ={"" , "QMouseEvent*"};
1018 static const char* argumentList[] ={"" , "QMouseEvent*"};
1023 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1019 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1024 void* args[2] = {NULL, (void*)&arg__1};
1020 void* args[2] = {NULL, (void*)&arg__1};
1025 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1021 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1026 if (result) { Py_DECREF(result); }
1022 if (result) { Py_DECREF(result); }
1027 Py_DECREF(obj);
1023 Py_DECREF(obj);
1028 return;
1024 return;
1029 }
1025 }
1030 }
1026 }
1031 MemSizeWdgt::mouseDoubleClickEvent(arg__1);
1027 MemSizeWdgt::mouseDoubleClickEvent(arg__1);
1032 }
1028 }
1033 void PythonQtShell_MemSizeWdgt::mouseMoveEvent(QMouseEvent* arg__1)
1029 void PythonQtShell_MemSizeWdgt::mouseMoveEvent(QMouseEvent* arg__1)
1034 {
1030 {
1035 if (_wrapper) {
1031 if (_wrapper) {
1036 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseMoveEvent");
1032 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseMoveEvent");
1037 PyErr_Clear();
1033 PyErr_Clear();
1038 if (obj && !PythonQtSlotFunction_Check(obj)) {
1034 if (obj && !PythonQtSlotFunction_Check(obj)) {
1039 static const char* argumentList[] ={"" , "QMouseEvent*"};
1035 static const char* argumentList[] ={"" , "QMouseEvent*"};
1040 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1036 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1041 void* args[2] = {NULL, (void*)&arg__1};
1037 void* args[2] = {NULL, (void*)&arg__1};
1042 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1038 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1043 if (result) { Py_DECREF(result); }
1039 if (result) { Py_DECREF(result); }
1044 Py_DECREF(obj);
1040 Py_DECREF(obj);
1045 return;
1041 return;
1046 }
1042 }
1047 }
1043 }
1048 MemSizeWdgt::mouseMoveEvent(arg__1);
1044 MemSizeWdgt::mouseMoveEvent(arg__1);
1049 }
1045 }
1050 void PythonQtShell_MemSizeWdgt::mousePressEvent(QMouseEvent* arg__1)
1046 void PythonQtShell_MemSizeWdgt::mousePressEvent(QMouseEvent* arg__1)
1051 {
1047 {
1052 if (_wrapper) {
1048 if (_wrapper) {
1053 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mousePressEvent");
1049 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mousePressEvent");
1054 PyErr_Clear();
1050 PyErr_Clear();
1055 if (obj && !PythonQtSlotFunction_Check(obj)) {
1051 if (obj && !PythonQtSlotFunction_Check(obj)) {
1056 static const char* argumentList[] ={"" , "QMouseEvent*"};
1052 static const char* argumentList[] ={"" , "QMouseEvent*"};
1057 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1053 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1058 void* args[2] = {NULL, (void*)&arg__1};
1054 void* args[2] = {NULL, (void*)&arg__1};
1059 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1055 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1060 if (result) { Py_DECREF(result); }
1056 if (result) { Py_DECREF(result); }
1061 Py_DECREF(obj);
1057 Py_DECREF(obj);
1062 return;
1058 return;
1063 }
1059 }
1064 }
1060 }
1065 MemSizeWdgt::mousePressEvent(arg__1);
1061 MemSizeWdgt::mousePressEvent(arg__1);
1066 }
1062 }
1067 void PythonQtShell_MemSizeWdgt::mouseReleaseEvent(QMouseEvent* arg__1)
1063 void PythonQtShell_MemSizeWdgt::mouseReleaseEvent(QMouseEvent* arg__1)
1068 {
1064 {
1069 if (_wrapper) {
1065 if (_wrapper) {
1070 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseReleaseEvent");
1066 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseReleaseEvent");
1071 PyErr_Clear();
1067 PyErr_Clear();
1072 if (obj && !PythonQtSlotFunction_Check(obj)) {
1068 if (obj && !PythonQtSlotFunction_Check(obj)) {
1073 static const char* argumentList[] ={"" , "QMouseEvent*"};
1069 static const char* argumentList[] ={"" , "QMouseEvent*"};
1074 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1070 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1075 void* args[2] = {NULL, (void*)&arg__1};
1071 void* args[2] = {NULL, (void*)&arg__1};
1076 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1072 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1077 if (result) { Py_DECREF(result); }
1073 if (result) { Py_DECREF(result); }
1078 Py_DECREF(obj);
1074 Py_DECREF(obj);
1079 return;
1075 return;
1080 }
1076 }
1081 }
1077 }
1082 MemSizeWdgt::mouseReleaseEvent(arg__1);
1078 MemSizeWdgt::mouseReleaseEvent(arg__1);
1083 }
1079 }
1084 void PythonQtShell_MemSizeWdgt::moveEvent(QMoveEvent* arg__1)
1080 void PythonQtShell_MemSizeWdgt::moveEvent(QMoveEvent* arg__1)
1085 {
1081 {
1086 if (_wrapper) {
1082 if (_wrapper) {
1087 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "moveEvent");
1083 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "moveEvent");
1088 PyErr_Clear();
1084 PyErr_Clear();
1089 if (obj && !PythonQtSlotFunction_Check(obj)) {
1085 if (obj && !PythonQtSlotFunction_Check(obj)) {
1090 static const char* argumentList[] ={"" , "QMoveEvent*"};
1086 static const char* argumentList[] ={"" , "QMoveEvent*"};
1091 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1087 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1092 void* args[2] = {NULL, (void*)&arg__1};
1088 void* args[2] = {NULL, (void*)&arg__1};
1093 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1089 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1094 if (result) { Py_DECREF(result); }
1090 if (result) { Py_DECREF(result); }
1095 Py_DECREF(obj);
1091 Py_DECREF(obj);
1096 return;
1092 return;
1097 }
1093 }
1098 }
1094 }
1099 MemSizeWdgt::moveEvent(arg__1);
1095 MemSizeWdgt::moveEvent(arg__1);
1100 }
1096 }
1101 bool PythonQtShell_MemSizeWdgt::nativeEvent(const QByteArray& eventType, void* message, long* result)
1097 bool PythonQtShell_MemSizeWdgt::nativeEvent(const QByteArray& eventType, void* message, long* result)
1102 {
1098 {
1103 if (_wrapper) {
1099 if (_wrapper) {
1104 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "nativeEvent");
1100 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "nativeEvent");
1105 PyErr_Clear();
1101 PyErr_Clear();
1106 if (obj && !PythonQtSlotFunction_Check(obj)) {
1102 if (obj && !PythonQtSlotFunction_Check(obj)) {
1107 static const char* argumentList[] ={"bool" , "const QByteArray&" , "void*" , "long*"};
1103 static const char* argumentList[] ={"bool" , "const QByteArray&" , "void*" , "long*"};
1108 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
1104 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
1109 bool returnValue;
1105 bool returnValue;
1110 void* args[4] = {NULL, (void*)&eventType, (void*)&message, (void*)&result};
1106 void* args[4] = {NULL, (void*)&eventType, (void*)&message, (void*)&result};
1111 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1107 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1112 if (result) {
1108 if (result) {
1113 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1109 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1114 if (args[0]!=&returnValue) {
1110 if (args[0]!=&returnValue) {
1115 if (args[0]==NULL) {
1111 if (args[0]==NULL) {
1116 PythonQt::priv()->handleVirtualOverloadReturnError("nativeEvent", methodInfo, result);
1112 PythonQt::priv()->handleVirtualOverloadReturnError("nativeEvent", methodInfo, result);
1117 } else {
1113 } else {
1118 returnValue = *((bool*)args[0]);
1114 returnValue = *((bool*)args[0]);
1119 }
1115 }
1120 }
1116 }
1121 }
1117 }
1122 if (result) { Py_DECREF(result); }
1118 if (result) { Py_DECREF(result); }
1123 Py_DECREF(obj);
1119 Py_DECREF(obj);
1124 return returnValue;
1120 return returnValue;
1125 }
1121 }
1126 }
1122 }
1127 return MemSizeWdgt::nativeEvent(eventType, message, result);
1123 return MemSizeWdgt::nativeEvent(eventType, message, result);
1128 }
1124 }
1129 QPaintEngine* PythonQtShell_MemSizeWdgt::paintEngine() const
1125 QPaintEngine* PythonQtShell_MemSizeWdgt::paintEngine() const
1130 {
1126 {
1131 if (_wrapper) {
1127 if (_wrapper) {
1132 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEngine");
1128 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEngine");
1133 PyErr_Clear();
1129 PyErr_Clear();
1134 if (obj && !PythonQtSlotFunction_Check(obj)) {
1130 if (obj && !PythonQtSlotFunction_Check(obj)) {
1135 static const char* argumentList[] ={"QPaintEngine*"};
1131 static const char* argumentList[] ={"QPaintEngine*"};
1136 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
1132 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
1137 QPaintEngine* returnValue;
1133 QPaintEngine* returnValue;
1138 void* args[1] = {NULL};
1134 void* args[1] = {NULL};
1139 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1135 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1140 if (result) {
1136 if (result) {
1141 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1137 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1142 if (args[0]!=&returnValue) {
1138 if (args[0]!=&returnValue) {
1143 if (args[0]==NULL) {
1139 if (args[0]==NULL) {
1144 PythonQt::priv()->handleVirtualOverloadReturnError("paintEngine", methodInfo, result);
1140 PythonQt::priv()->handleVirtualOverloadReturnError("paintEngine", methodInfo, result);
1145 } else {
1141 } else {
1146 returnValue = *((QPaintEngine**)args[0]);
1142 returnValue = *((QPaintEngine**)args[0]);
1147 }
1143 }
1148 }
1144 }
1149 }
1145 }
1150 if (result) { Py_DECREF(result); }
1146 if (result) { Py_DECREF(result); }
1151 Py_DECREF(obj);
1147 Py_DECREF(obj);
1152 return returnValue;
1148 return returnValue;
1153 }
1149 }
1154 }
1150 }
1155 return MemSizeWdgt::paintEngine();
1151 return MemSizeWdgt::paintEngine();
1156 }
1152 }
1157 void PythonQtShell_MemSizeWdgt::paintEvent(QPaintEvent* arg__1)
1153 void PythonQtShell_MemSizeWdgt::paintEvent(QPaintEvent* arg__1)
1158 {
1154 {
1159 if (_wrapper) {
1155 if (_wrapper) {
1160 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEvent");
1156 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEvent");
1161 PyErr_Clear();
1157 PyErr_Clear();
1162 if (obj && !PythonQtSlotFunction_Check(obj)) {
1158 if (obj && !PythonQtSlotFunction_Check(obj)) {
1163 static const char* argumentList[] ={"" , "QPaintEvent*"};
1159 static const char* argumentList[] ={"" , "QPaintEvent*"};
1164 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1160 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1165 void* args[2] = {NULL, (void*)&arg__1};
1161 void* args[2] = {NULL, (void*)&arg__1};
1166 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1162 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1167 if (result) { Py_DECREF(result); }
1163 if (result) { Py_DECREF(result); }
1168 Py_DECREF(obj);
1164 Py_DECREF(obj);
1169 return;
1165 return;
1170 }
1166 }
1171 }
1167 }
1172 MemSizeWdgt::paintEvent(arg__1);
1168 MemSizeWdgt::paintEvent(arg__1);
1173 }
1169 }
1174 QPaintDevice* PythonQtShell_MemSizeWdgt::redirected(QPoint* offset) const
1170 QPaintDevice* PythonQtShell_MemSizeWdgt::redirected(QPoint* offset) const
1175 {
1171 {
1176 if (_wrapper) {
1172 if (_wrapper) {
1177 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "redirected");
1173 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "redirected");
1178 PyErr_Clear();
1174 PyErr_Clear();
1179 if (obj && !PythonQtSlotFunction_Check(obj)) {
1175 if (obj && !PythonQtSlotFunction_Check(obj)) {
1180 static const char* argumentList[] ={"QPaintDevice*" , "QPoint*"};
1176 static const char* argumentList[] ={"QPaintDevice*" , "QPoint*"};
1181 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1177 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1182 QPaintDevice* returnValue;
1178 QPaintDevice* returnValue;
1183 void* args[2] = {NULL, (void*)&offset};
1179 void* args[2] = {NULL, (void*)&offset};
1184 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1180 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1185 if (result) {
1181 if (result) {
1186 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1182 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1187 if (args[0]!=&returnValue) {
1183 if (args[0]!=&returnValue) {
1188 if (args[0]==NULL) {
1184 if (args[0]==NULL) {
1189 PythonQt::priv()->handleVirtualOverloadReturnError("redirected", methodInfo, result);
1185 PythonQt::priv()->handleVirtualOverloadReturnError("redirected", methodInfo, result);
1190 } else {
1186 } else {
1191 returnValue = *((QPaintDevice**)args[0]);
1187 returnValue = *((QPaintDevice**)args[0]);
1192 }
1188 }
1193 }
1189 }
1194 }
1190 }
1195 if (result) { Py_DECREF(result); }
1191 if (result) { Py_DECREF(result); }
1196 Py_DECREF(obj);
1192 Py_DECREF(obj);
1197 return returnValue;
1193 return returnValue;
1198 }
1194 }
1199 }
1195 }
1200 return MemSizeWdgt::redirected(offset);
1196 return MemSizeWdgt::redirected(offset);
1201 }
1197 }
1202 void PythonQtShell_MemSizeWdgt::resizeEvent(QResizeEvent* arg__1)
1198 void PythonQtShell_MemSizeWdgt::resizeEvent(QResizeEvent* arg__1)
1203 {
1199 {
1204 if (_wrapper) {
1200 if (_wrapper) {
1205 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "resizeEvent");
1201 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "resizeEvent");
1206 PyErr_Clear();
1202 PyErr_Clear();
1207 if (obj && !PythonQtSlotFunction_Check(obj)) {
1203 if (obj && !PythonQtSlotFunction_Check(obj)) {
1208 static const char* argumentList[] ={"" , "QResizeEvent*"};
1204 static const char* argumentList[] ={"" , "QResizeEvent*"};
1209 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1205 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1210 void* args[2] = {NULL, (void*)&arg__1};
1206 void* args[2] = {NULL, (void*)&arg__1};
1211 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1207 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1212 if (result) { Py_DECREF(result); }
1208 if (result) { Py_DECREF(result); }
1213 Py_DECREF(obj);
1209 Py_DECREF(obj);
1214 return;
1210 return;
1215 }
1211 }
1216 }
1212 }
1217 MemSizeWdgt::resizeEvent(arg__1);
1213 MemSizeWdgt::resizeEvent(arg__1);
1218 }
1214 }
1219 QPainter* PythonQtShell_MemSizeWdgt::sharedPainter() const
1215 QPainter* PythonQtShell_MemSizeWdgt::sharedPainter() const
1220 {
1216 {
1221 if (_wrapper) {
1217 if (_wrapper) {
1222 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "sharedPainter");
1218 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "sharedPainter");
1223 PyErr_Clear();
1219 PyErr_Clear();
1224 if (obj && !PythonQtSlotFunction_Check(obj)) {
1220 if (obj && !PythonQtSlotFunction_Check(obj)) {
1225 static const char* argumentList[] ={"QPainter*"};
1221 static const char* argumentList[] ={"QPainter*"};
1226 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
1222 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
1227 QPainter* returnValue;
1223 QPainter* returnValue;
1228 void* args[1] = {NULL};
1224 void* args[1] = {NULL};
1229 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1225 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1230 if (result) {
1226 if (result) {
1231 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1227 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1232 if (args[0]!=&returnValue) {
1228 if (args[0]!=&returnValue) {
1233 if (args[0]==NULL) {
1229 if (args[0]==NULL) {
1234 PythonQt::priv()->handleVirtualOverloadReturnError("sharedPainter", methodInfo, result);
1230 PythonQt::priv()->handleVirtualOverloadReturnError("sharedPainter", methodInfo, result);
1235 } else {
1231 } else {
1236 returnValue = *((QPainter**)args[0]);
1232 returnValue = *((QPainter**)args[0]);
1237 }
1233 }
1238 }
1234 }
1239 }
1235 }
1240 if (result) { Py_DECREF(result); }
1236 if (result) { Py_DECREF(result); }
1241 Py_DECREF(obj);
1237 Py_DECREF(obj);
1242 return returnValue;
1238 return returnValue;
1243 }
1239 }
1244 }
1240 }
1245 return MemSizeWdgt::sharedPainter();
1241 return MemSizeWdgt::sharedPainter();
1246 }
1242 }
1247 void PythonQtShell_MemSizeWdgt::showEvent(QShowEvent* arg__1)
1243 void PythonQtShell_MemSizeWdgt::showEvent(QShowEvent* arg__1)
1248 {
1244 {
1249 if (_wrapper) {
1245 if (_wrapper) {
1250 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "showEvent");
1246 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "showEvent");
1251 PyErr_Clear();
1247 PyErr_Clear();
1252 if (obj && !PythonQtSlotFunction_Check(obj)) {
1248 if (obj && !PythonQtSlotFunction_Check(obj)) {
1253 static const char* argumentList[] ={"" , "QShowEvent*"};
1249 static const char* argumentList[] ={"" , "QShowEvent*"};
1254 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1250 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1255 void* args[2] = {NULL, (void*)&arg__1};
1251 void* args[2] = {NULL, (void*)&arg__1};
1256 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1252 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1257 if (result) { Py_DECREF(result); }
1253 if (result) { Py_DECREF(result); }
1258 Py_DECREF(obj);
1254 Py_DECREF(obj);
1259 return;
1255 return;
1260 }
1256 }
1261 }
1257 }
1262 MemSizeWdgt::showEvent(arg__1);
1258 MemSizeWdgt::showEvent(arg__1);
1263 }
1259 }
1264 QSize PythonQtShell_MemSizeWdgt::sizeHint() const
1260 QSize PythonQtShell_MemSizeWdgt::sizeHint() const
1265 {
1261 {
1266 if (_wrapper) {
1262 if (_wrapper) {
1267 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getSizeHint");
1263 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getSizeHint");
1268 PyErr_Clear();
1264 PyErr_Clear();
1269 if (obj && !PythonQtSlotFunction_Check(obj)) {
1265 if (obj && !PythonQtSlotFunction_Check(obj)) {
1270 static const char* argumentList[] ={"QSize"};
1266 static const char* argumentList[] ={"QSize"};
1271 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
1267 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
1272 QSize returnValue;
1268 QSize returnValue;
1273 void* args[1] = {NULL};
1269 void* args[1] = {NULL};
1274 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1270 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1275 if (result) {
1271 if (result) {
1276 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1272 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1277 if (args[0]!=&returnValue) {
1273 if (args[0]!=&returnValue) {
1278 if (args[0]==NULL) {
1274 if (args[0]==NULL) {
1279 PythonQt::priv()->handleVirtualOverloadReturnError("getSizeHint", methodInfo, result);
1275 PythonQt::priv()->handleVirtualOverloadReturnError("getSizeHint", methodInfo, result);
1280 } else {
1276 } else {
1281 returnValue = *((QSize*)args[0]);
1277 returnValue = *((QSize*)args[0]);
1282 }
1278 }
1283 }
1279 }
1284 }
1280 }
1285 if (result) { Py_DECREF(result); }
1281 if (result) { Py_DECREF(result); }
1286 Py_DECREF(obj);
1282 Py_DECREF(obj);
1287 return returnValue;
1283 return returnValue;
1288 }
1284 }
1289 }
1285 }
1290 return MemSizeWdgt::sizeHint();
1286 return MemSizeWdgt::sizeHint();
1291 }
1287 }
1292 void PythonQtShell_MemSizeWdgt::tabletEvent(QTabletEvent* arg__1)
1288 void PythonQtShell_MemSizeWdgt::tabletEvent(QTabletEvent* arg__1)
1293 {
1289 {
1294 if (_wrapper) {
1290 if (_wrapper) {
1295 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "tabletEvent");
1291 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "tabletEvent");
1296 PyErr_Clear();
1292 PyErr_Clear();
1297 if (obj && !PythonQtSlotFunction_Check(obj)) {
1293 if (obj && !PythonQtSlotFunction_Check(obj)) {
1298 static const char* argumentList[] ={"" , "QTabletEvent*"};
1294 static const char* argumentList[] ={"" , "QTabletEvent*"};
1299 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1295 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1300 void* args[2] = {NULL, (void*)&arg__1};
1296 void* args[2] = {NULL, (void*)&arg__1};
1301 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1297 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1302 if (result) { Py_DECREF(result); }
1298 if (result) { Py_DECREF(result); }
1303 Py_DECREF(obj);
1299 Py_DECREF(obj);
1304 return;
1300 return;
1305 }
1301 }
1306 }
1302 }
1307 MemSizeWdgt::tabletEvent(arg__1);
1303 MemSizeWdgt::tabletEvent(arg__1);
1308 }
1304 }
1309 void PythonQtShell_MemSizeWdgt::timerEvent(QTimerEvent* arg__1)
1305 void PythonQtShell_MemSizeWdgt::timerEvent(QTimerEvent* arg__1)
1310 {
1306 {
1311 if (_wrapper) {
1307 if (_wrapper) {
1312 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "timerEvent");
1308 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "timerEvent");
1313 PyErr_Clear();
1309 PyErr_Clear();
1314 if (obj && !PythonQtSlotFunction_Check(obj)) {
1310 if (obj && !PythonQtSlotFunction_Check(obj)) {
1315 static const char* argumentList[] ={"" , "QTimerEvent*"};
1311 static const char* argumentList[] ={"" , "QTimerEvent*"};
1316 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1312 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1317 void* args[2] = {NULL, (void*)&arg__1};
1313 void* args[2] = {NULL, (void*)&arg__1};
1318 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1314 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1319 if (result) { Py_DECREF(result); }
1315 if (result) { Py_DECREF(result); }
1320 Py_DECREF(obj);
1316 Py_DECREF(obj);
1321 return;
1317 return;
1322 }
1318 }
1323 }
1319 }
1324 MemSizeWdgt::timerEvent(arg__1);
1320 MemSizeWdgt::timerEvent(arg__1);
1325 }
1321 }
1326 void PythonQtShell_MemSizeWdgt::wheelEvent(QWheelEvent* arg__1)
1322 void PythonQtShell_MemSizeWdgt::wheelEvent(QWheelEvent* arg__1)
1327 {
1323 {
1328 if (_wrapper) {
1324 if (_wrapper) {
1329 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "wheelEvent");
1325 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "wheelEvent");
1330 PyErr_Clear();
1326 PyErr_Clear();
1331 if (obj && !PythonQtSlotFunction_Check(obj)) {
1327 if (obj && !PythonQtSlotFunction_Check(obj)) {
1332 static const char* argumentList[] ={"" , "QWheelEvent*"};
1328 static const char* argumentList[] ={"" , "QWheelEvent*"};
1333 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1329 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1334 void* args[2] = {NULL, (void*)&arg__1};
1330 void* args[2] = {NULL, (void*)&arg__1};
1335 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1331 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1336 if (result) { Py_DECREF(result); }
1332 if (result) { Py_DECREF(result); }
1337 Py_DECREF(obj);
1333 Py_DECREF(obj);
1338 return;
1334 return;
1339 }
1335 }
1340 }
1336 }
1341 MemSizeWdgt::wheelEvent(arg__1);
1337 MemSizeWdgt::wheelEvent(arg__1);
1342 }
1338 }
1343 MemSizeWdgt* PythonQtWrapper_MemSizeWdgt::new_MemSizeWdgt(QWidget* parent)
1339 MemSizeWdgt* PythonQtWrapper_MemSizeWdgt::new_MemSizeWdgt(QWidget* parent)
1344 {
1340 {
1345 return new PythonQtShell_MemSizeWdgt(parent); }
1341 return new PythonQtShell_MemSizeWdgt(parent); }
1346
1342
1347 MemSizeWdgt* PythonQtWrapper_MemSizeWdgt::new_MemSizeWdgt(int defaultSize, QWidget* parent)
1343 MemSizeWdgt* PythonQtWrapper_MemSizeWdgt::new_MemSizeWdgt(int defaultSize, QWidget* parent)
1348 {
1344 {
1349 return new PythonQtShell_MemSizeWdgt(defaultSize, parent); }
1345 return new PythonQtShell_MemSizeWdgt(defaultSize, parent); }
1350
1346
1351 int PythonQtWrapper_MemSizeWdgt::getsize(MemSizeWdgt* theWrappedObject)
1347 int PythonQtWrapper_MemSizeWdgt::getsize(MemSizeWdgt* theWrappedObject)
1352 {
1348 {
1353 return ( theWrappedObject->getsize());
1349 return ( theWrappedObject->getsize());
1354 }
1350 }
1355
1351
1356 void PythonQtWrapper_MemSizeWdgt::setMaximum(MemSizeWdgt* theWrappedObject, unsigned int max)
1352 void PythonQtWrapper_MemSizeWdgt::setMaximum(MemSizeWdgt* theWrappedObject, unsigned int max)
1357 {
1353 {
1358 ( theWrappedObject->setMaximum(max));
1354 ( theWrappedObject->setMaximum(max));
1359 }
1355 }
1360
1356
1361 void PythonQtWrapper_MemSizeWdgt::show(MemSizeWdgt* theWrappedObject)
1357 void PythonQtWrapper_MemSizeWdgt::show(MemSizeWdgt* theWrappedObject)
1362 {
1358 {
1363 ( theWrappedObject->show());
1359 ( theWrappedObject->show());
1364 }
1360 }
1365
1361
1366 void PythonQtWrapper_MemSizeWdgt::updateSizeValue(MemSizeWdgt* theWrappedObject)
1362 void PythonQtWrapper_MemSizeWdgt::updateSizeValue(MemSizeWdgt* theWrappedObject)
1367 {
1363 {
1368 ( theWrappedObject->updateSizeValue());
1364 ( theWrappedObject->updateSizeValue());
1369 }
1365 }
1370
1366
1371
1367
1372
1368
1373 PythonQtShell_QHexEdit::~PythonQtShell_QHexEdit() {
1369 PythonQtShell_QHexEdit::~PythonQtShell_QHexEdit() {
1374 PythonQtPrivate* priv = PythonQt::priv();
1370 PythonQtPrivate* priv = PythonQt::priv();
1375 if (priv) { priv->shellClassDeleted(this); }
1371 if (priv) { priv->shellClassDeleted(this); }
1376 }
1372 }
1377 void PythonQtShell_QHexEdit::actionEvent(QActionEvent* arg__1)
1373 void PythonQtShell_QHexEdit::actionEvent(QActionEvent* arg__1)
1378 {
1374 {
1379 if (_wrapper) {
1375 if (_wrapper) {
1380 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "actionEvent");
1376 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "actionEvent");
1381 PyErr_Clear();
1377 PyErr_Clear();
1382 if (obj && !PythonQtSlotFunction_Check(obj)) {
1378 if (obj && !PythonQtSlotFunction_Check(obj)) {
1383 static const char* argumentList[] ={"" , "QActionEvent*"};
1379 static const char* argumentList[] ={"" , "QActionEvent*"};
1384 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1380 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1385 void* args[2] = {NULL, (void*)&arg__1};
1381 void* args[2] = {NULL, (void*)&arg__1};
1386 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1382 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1387 if (result) { Py_DECREF(result); }
1383 if (result) { Py_DECREF(result); }
1388 Py_DECREF(obj);
1384 Py_DECREF(obj);
1389 return;
1385 return;
1390 }
1386 }
1391 }
1387 }
1392 QHexEdit::actionEvent(arg__1);
1388 QHexEdit::actionEvent(arg__1);
1393 }
1389 }
1394 void PythonQtShell_QHexEdit::changeEvent(QEvent* arg__1)
1390 void PythonQtShell_QHexEdit::changeEvent(QEvent* arg__1)
1395 {
1391 {
1396 if (_wrapper) {
1392 if (_wrapper) {
1397 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "changeEvent");
1393 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "changeEvent");
1398 PyErr_Clear();
1394 PyErr_Clear();
1399 if (obj && !PythonQtSlotFunction_Check(obj)) {
1395 if (obj && !PythonQtSlotFunction_Check(obj)) {
1400 static const char* argumentList[] ={"" , "QEvent*"};
1396 static const char* argumentList[] ={"" , "QEvent*"};
1401 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1397 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1402 void* args[2] = {NULL, (void*)&arg__1};
1398 void* args[2] = {NULL, (void*)&arg__1};
1403 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1399 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1404 if (result) { Py_DECREF(result); }
1400 if (result) { Py_DECREF(result); }
1405 Py_DECREF(obj);
1401 Py_DECREF(obj);
1406 return;
1402 return;
1407 }
1403 }
1408 }
1404 }
1409 QHexEdit::changeEvent(arg__1);
1405 QHexEdit::changeEvent(arg__1);
1410 }
1406 }
1411 void PythonQtShell_QHexEdit::childEvent(QChildEvent* arg__1)
1407 void PythonQtShell_QHexEdit::childEvent(QChildEvent* arg__1)
1412 {
1408 {
1413 if (_wrapper) {
1409 if (_wrapper) {
1414 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "childEvent");
1410 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "childEvent");
1415 PyErr_Clear();
1411 PyErr_Clear();
1416 if (obj && !PythonQtSlotFunction_Check(obj)) {
1412 if (obj && !PythonQtSlotFunction_Check(obj)) {
1417 static const char* argumentList[] ={"" , "QChildEvent*"};
1413 static const char* argumentList[] ={"" , "QChildEvent*"};
1418 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1414 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1419 void* args[2] = {NULL, (void*)&arg__1};
1415 void* args[2] = {NULL, (void*)&arg__1};
1420 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1416 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1421 if (result) { Py_DECREF(result); }
1417 if (result) { Py_DECREF(result); }
1422 Py_DECREF(obj);
1418 Py_DECREF(obj);
1423 return;
1419 return;
1424 }
1420 }
1425 }
1421 }
1426 QHexEdit::childEvent(arg__1);
1422 QHexEdit::childEvent(arg__1);
1427 }
1423 }
1428 void PythonQtShell_QHexEdit::closeEvent(QCloseEvent* arg__1)
1424 void PythonQtShell_QHexEdit::closeEvent(QCloseEvent* arg__1)
1429 {
1425 {
1430 if (_wrapper) {
1426 if (_wrapper) {
1431 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "closeEvent");
1427 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "closeEvent");
1432 PyErr_Clear();
1428 PyErr_Clear();
1433 if (obj && !PythonQtSlotFunction_Check(obj)) {
1429 if (obj && !PythonQtSlotFunction_Check(obj)) {
1434 static const char* argumentList[] ={"" , "QCloseEvent*"};
1430 static const char* argumentList[] ={"" , "QCloseEvent*"};
1435 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1431 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1436 void* args[2] = {NULL, (void*)&arg__1};
1432 void* args[2] = {NULL, (void*)&arg__1};
1437 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1433 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1438 if (result) { Py_DECREF(result); }
1434 if (result) { Py_DECREF(result); }
1439 Py_DECREF(obj);
1435 Py_DECREF(obj);
1440 return;
1436 return;
1441 }
1437 }
1442 }
1438 }
1443 QHexEdit::closeEvent(arg__1);
1439 QHexEdit::closeEvent(arg__1);
1444 }
1440 }
1445 void PythonQtShell_QHexEdit::contextMenuEvent(QContextMenuEvent* arg__1)
1441 void PythonQtShell_QHexEdit::contextMenuEvent(QContextMenuEvent* arg__1)
1446 {
1442 {
1447 if (_wrapper) {
1443 if (_wrapper) {
1448 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "contextMenuEvent");
1444 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "contextMenuEvent");
1449 PyErr_Clear();
1445 PyErr_Clear();
1450 if (obj && !PythonQtSlotFunction_Check(obj)) {
1446 if (obj && !PythonQtSlotFunction_Check(obj)) {
1451 static const char* argumentList[] ={"" , "QContextMenuEvent*"};
1447 static const char* argumentList[] ={"" , "QContextMenuEvent*"};
1452 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1448 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1453 void* args[2] = {NULL, (void*)&arg__1};
1449 void* args[2] = {NULL, (void*)&arg__1};
1454 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1450 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1455 if (result) { Py_DECREF(result); }
1451 if (result) { Py_DECREF(result); }
1456 Py_DECREF(obj);
1452 Py_DECREF(obj);
1457 return;
1453 return;
1458 }
1454 }
1459 }
1455 }
1460 QHexEdit::contextMenuEvent(arg__1);
1456 QHexEdit::contextMenuEvent(arg__1);
1461 }
1457 }
1462 void PythonQtShell_QHexEdit::customEvent(QEvent* arg__1)
1458 void PythonQtShell_QHexEdit::customEvent(QEvent* arg__1)
1463 {
1459 {
1464 if (_wrapper) {
1460 if (_wrapper) {
1465 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "customEvent");
1461 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "customEvent");
1466 PyErr_Clear();
1462 PyErr_Clear();
1467 if (obj && !PythonQtSlotFunction_Check(obj)) {
1463 if (obj && !PythonQtSlotFunction_Check(obj)) {
1468 static const char* argumentList[] ={"" , "QEvent*"};
1464 static const char* argumentList[] ={"" , "QEvent*"};
1469 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1465 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1470 void* args[2] = {NULL, (void*)&arg__1};
1466 void* args[2] = {NULL, (void*)&arg__1};
1471 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1467 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1472 if (result) { Py_DECREF(result); }
1468 if (result) { Py_DECREF(result); }
1473 Py_DECREF(obj);
1469 Py_DECREF(obj);
1474 return;
1470 return;
1475 }
1471 }
1476 }
1472 }
1477 QHexEdit::customEvent(arg__1);
1473 QHexEdit::customEvent(arg__1);
1478 }
1474 }
1479 int PythonQtShell_QHexEdit::devType() const
1475 int PythonQtShell_QHexEdit::devType() const
1480 {
1476 {
1481 if (_wrapper) {
1477 if (_wrapper) {
1482 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "devType");
1478 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "devType");
1483 PyErr_Clear();
1479 PyErr_Clear();
1484 if (obj && !PythonQtSlotFunction_Check(obj)) {
1480 if (obj && !PythonQtSlotFunction_Check(obj)) {
1485 static const char* argumentList[] ={"int"};
1481 static const char* argumentList[] ={"int"};
1486 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
1482 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
1487 int returnValue;
1483 int returnValue;
1488 void* args[1] = {NULL};
1484 void* args[1] = {NULL};
1489 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1485 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1490 if (result) {
1486 if (result) {
1491 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1487 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1492 if (args[0]!=&returnValue) {
1488 if (args[0]!=&returnValue) {
1493 if (args[0]==NULL) {
1489 if (args[0]==NULL) {
1494 PythonQt::priv()->handleVirtualOverloadReturnError("devType", methodInfo, result);
1490 PythonQt::priv()->handleVirtualOverloadReturnError("devType", methodInfo, result);
1495 } else {
1491 } else {
1496 returnValue = *((int*)args[0]);
1492 returnValue = *((int*)args[0]);
1497 }
1493 }
1498 }
1494 }
1499 }
1495 }
1500 if (result) { Py_DECREF(result); }
1496 if (result) { Py_DECREF(result); }
1501 Py_DECREF(obj);
1497 Py_DECREF(obj);
1502 return returnValue;
1498 return returnValue;
1503 }
1499 }
1504 }
1500 }
1505 return QHexEdit::devType();
1501 return QHexEdit::devType();
1506 }
1502 }
1507 void PythonQtShell_QHexEdit::dragEnterEvent(QDragEnterEvent* arg__1)
1503 void PythonQtShell_QHexEdit::dragEnterEvent(QDragEnterEvent* arg__1)
1508 {
1504 {
1509 if (_wrapper) {
1505 if (_wrapper) {
1510 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragEnterEvent");
1506 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragEnterEvent");
1511 PyErr_Clear();
1507 PyErr_Clear();
1512 if (obj && !PythonQtSlotFunction_Check(obj)) {
1508 if (obj && !PythonQtSlotFunction_Check(obj)) {
1513 static const char* argumentList[] ={"" , "QDragEnterEvent*"};
1509 static const char* argumentList[] ={"" , "QDragEnterEvent*"};
1514 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1510 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1515 void* args[2] = {NULL, (void*)&arg__1};
1511 void* args[2] = {NULL, (void*)&arg__1};
1516 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1512 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1517 if (result) { Py_DECREF(result); }
1513 if (result) { Py_DECREF(result); }
1518 Py_DECREF(obj);
1514 Py_DECREF(obj);
1519 return;
1515 return;
1520 }
1516 }
1521 }
1517 }
1522 QHexEdit::dragEnterEvent(arg__1);
1518 QHexEdit::dragEnterEvent(arg__1);
1523 }
1519 }
1524 void PythonQtShell_QHexEdit::dragLeaveEvent(QDragLeaveEvent* arg__1)
1520 void PythonQtShell_QHexEdit::dragLeaveEvent(QDragLeaveEvent* arg__1)
1525 {
1521 {
1526 if (_wrapper) {
1522 if (_wrapper) {
1527 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragLeaveEvent");
1523 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragLeaveEvent");
1528 PyErr_Clear();
1524 PyErr_Clear();
1529 if (obj && !PythonQtSlotFunction_Check(obj)) {
1525 if (obj && !PythonQtSlotFunction_Check(obj)) {
1530 static const char* argumentList[] ={"" , "QDragLeaveEvent*"};
1526 static const char* argumentList[] ={"" , "QDragLeaveEvent*"};
1531 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1527 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1532 void* args[2] = {NULL, (void*)&arg__1};
1528 void* args[2] = {NULL, (void*)&arg__1};
1533 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1529 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1534 if (result) { Py_DECREF(result); }
1530 if (result) { Py_DECREF(result); }
1535 Py_DECREF(obj);
1531 Py_DECREF(obj);
1536 return;
1532 return;
1537 }
1533 }
1538 }
1534 }
1539 QHexEdit::dragLeaveEvent(arg__1);
1535 QHexEdit::dragLeaveEvent(arg__1);
1540 }
1536 }
1541 void PythonQtShell_QHexEdit::dragMoveEvent(QDragMoveEvent* arg__1)
1537 void PythonQtShell_QHexEdit::dragMoveEvent(QDragMoveEvent* arg__1)
1542 {
1538 {
1543 if (_wrapper) {
1539 if (_wrapper) {
1544 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragMoveEvent");
1540 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragMoveEvent");
1545 PyErr_Clear();
1541 PyErr_Clear();
1546 if (obj && !PythonQtSlotFunction_Check(obj)) {
1542 if (obj && !PythonQtSlotFunction_Check(obj)) {
1547 static const char* argumentList[] ={"" , "QDragMoveEvent*"};
1543 static const char* argumentList[] ={"" , "QDragMoveEvent*"};
1548 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1544 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1549 void* args[2] = {NULL, (void*)&arg__1};
1545 void* args[2] = {NULL, (void*)&arg__1};
1550 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1546 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1551 if (result) { Py_DECREF(result); }
1547 if (result) { Py_DECREF(result); }
1552 Py_DECREF(obj);
1548 Py_DECREF(obj);
1553 return;
1549 return;
1554 }
1550 }
1555 }
1551 }
1556 QHexEdit::dragMoveEvent(arg__1);
1552 QHexEdit::dragMoveEvent(arg__1);
1557 }
1553 }
1558 void PythonQtShell_QHexEdit::dropEvent(QDropEvent* arg__1)
1554 void PythonQtShell_QHexEdit::dropEvent(QDropEvent* arg__1)
1559 {
1555 {
1560 if (_wrapper) {
1556 if (_wrapper) {
1561 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dropEvent");
1557 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dropEvent");
1562 PyErr_Clear();
1558 PyErr_Clear();
1563 if (obj && !PythonQtSlotFunction_Check(obj)) {
1559 if (obj && !PythonQtSlotFunction_Check(obj)) {
1564 static const char* argumentList[] ={"" , "QDropEvent*"};
1560 static const char* argumentList[] ={"" , "QDropEvent*"};
1565 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1561 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1566 void* args[2] = {NULL, (void*)&arg__1};
1562 void* args[2] = {NULL, (void*)&arg__1};
1567 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1563 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1568 if (result) { Py_DECREF(result); }
1564 if (result) { Py_DECREF(result); }
1569 Py_DECREF(obj);
1565 Py_DECREF(obj);
1570 return;
1566 return;
1571 }
1567 }
1572 }
1568 }
1573 QHexEdit::dropEvent(arg__1);
1569 QHexEdit::dropEvent(arg__1);
1574 }
1570 }
1575 void PythonQtShell_QHexEdit::enterEvent(QEvent* arg__1)
1571 void PythonQtShell_QHexEdit::enterEvent(QEvent* arg__1)
1576 {
1572 {
1577 if (_wrapper) {
1573 if (_wrapper) {
1578 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "enterEvent");
1574 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "enterEvent");
1579 PyErr_Clear();
1575 PyErr_Clear();
1580 if (obj && !PythonQtSlotFunction_Check(obj)) {
1576 if (obj && !PythonQtSlotFunction_Check(obj)) {
1581 static const char* argumentList[] ={"" , "QEvent*"};
1577 static const char* argumentList[] ={"" , "QEvent*"};
1582 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1578 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1583 void* args[2] = {NULL, (void*)&arg__1};
1579 void* args[2] = {NULL, (void*)&arg__1};
1584 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1580 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1585 if (result) { Py_DECREF(result); }
1581 if (result) { Py_DECREF(result); }
1586 Py_DECREF(obj);
1582 Py_DECREF(obj);
1587 return;
1583 return;
1588 }
1584 }
1589 }
1585 }
1590 QHexEdit::enterEvent(arg__1);
1586 QHexEdit::enterEvent(arg__1);
1591 }
1587 }
1592 bool PythonQtShell_QHexEdit::event(QEvent* arg__1)
1588 bool PythonQtShell_QHexEdit::event(QEvent* arg__1)
1593 {
1589 {
1594 if (_wrapper) {
1590 if (_wrapper) {
1595 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "event");
1591 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "event");
1596 PyErr_Clear();
1592 PyErr_Clear();
1597 if (obj && !PythonQtSlotFunction_Check(obj)) {
1593 if (obj && !PythonQtSlotFunction_Check(obj)) {
1598 static const char* argumentList[] ={"bool" , "QEvent*"};
1594 static const char* argumentList[] ={"bool" , "QEvent*"};
1599 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1595 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1600 bool returnValue;
1596 bool returnValue;
1601 void* args[2] = {NULL, (void*)&arg__1};
1597 void* args[2] = {NULL, (void*)&arg__1};
1602 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1598 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1603 if (result) {
1599 if (result) {
1604 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1600 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1605 if (args[0]!=&returnValue) {
1601 if (args[0]!=&returnValue) {
1606 if (args[0]==NULL) {
1602 if (args[0]==NULL) {
1607 PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
1603 PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
1608 } else {
1604 } else {
1609 returnValue = *((bool*)args[0]);
1605 returnValue = *((bool*)args[0]);
1610 }
1606 }
1611 }
1607 }
1612 }
1608 }
1613 if (result) { Py_DECREF(result); }
1609 if (result) { Py_DECREF(result); }
1614 Py_DECREF(obj);
1610 Py_DECREF(obj);
1615 return returnValue;
1611 return returnValue;
1616 }
1612 }
1617 }
1613 }
1618 return QHexEdit::event(arg__1);
1614 return QHexEdit::event(arg__1);
1619 }
1615 }
1620 bool PythonQtShell_QHexEdit::eventFilter(QObject* arg__1, QEvent* arg__2)
1616 bool PythonQtShell_QHexEdit::eventFilter(QObject* arg__1, QEvent* arg__2)
1621 {
1617 {
1622 if (_wrapper) {
1618 if (_wrapper) {
1623 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "eventFilter");
1619 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "eventFilter");
1624 PyErr_Clear();
1620 PyErr_Clear();
1625 if (obj && !PythonQtSlotFunction_Check(obj)) {
1621 if (obj && !PythonQtSlotFunction_Check(obj)) {
1626 static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
1622 static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
1627 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
1623 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
1628 bool returnValue;
1624 bool returnValue;
1629 void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2};
1625 void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2};
1630 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1626 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1631 if (result) {
1627 if (result) {
1632 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1628 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1633 if (args[0]!=&returnValue) {
1629 if (args[0]!=&returnValue) {
1634 if (args[0]==NULL) {
1630 if (args[0]==NULL) {
1635 PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
1631 PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
1636 } else {
1632 } else {
1637 returnValue = *((bool*)args[0]);
1633 returnValue = *((bool*)args[0]);
1638 }
1634 }
1639 }
1635 }
1640 }
1636 }
1641 if (result) { Py_DECREF(result); }
1637 if (result) { Py_DECREF(result); }
1642 Py_DECREF(obj);
1638 Py_DECREF(obj);
1643 return returnValue;
1639 return returnValue;
1644 }
1640 }
1645 }
1641 }
1646 return QHexEdit::eventFilter(arg__1, arg__2);
1642 return QHexEdit::eventFilter(arg__1, arg__2);
1647 }
1643 }
1648 void PythonQtShell_QHexEdit::focusInEvent(QFocusEvent* arg__1)
1644 void PythonQtShell_QHexEdit::focusInEvent(QFocusEvent* arg__1)
1649 {
1645 {
1650 if (_wrapper) {
1646 if (_wrapper) {
1651 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusInEvent");
1647 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusInEvent");
1652 PyErr_Clear();
1648 PyErr_Clear();
1653 if (obj && !PythonQtSlotFunction_Check(obj)) {
1649 if (obj && !PythonQtSlotFunction_Check(obj)) {
1654 static const char* argumentList[] ={"" , "QFocusEvent*"};
1650 static const char* argumentList[] ={"" , "QFocusEvent*"};
1655 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1651 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1656 void* args[2] = {NULL, (void*)&arg__1};
1652 void* args[2] = {NULL, (void*)&arg__1};
1657 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1653 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1658 if (result) { Py_DECREF(result); }
1654 if (result) { Py_DECREF(result); }
1659 Py_DECREF(obj);
1655 Py_DECREF(obj);
1660 return;
1656 return;
1661 }
1657 }
1662 }
1658 }
1663 QHexEdit::focusInEvent(arg__1);
1659 QHexEdit::focusInEvent(arg__1);
1664 }
1660 }
1665 bool PythonQtShell_QHexEdit::focusNextPrevChild(bool next)
1661 bool PythonQtShell_QHexEdit::focusNextPrevChild(bool next)
1666 {
1662 {
1667 if (_wrapper) {
1663 if (_wrapper) {
1668 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusNextPrevChild");
1664 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusNextPrevChild");
1669 PyErr_Clear();
1665 PyErr_Clear();
1670 if (obj && !PythonQtSlotFunction_Check(obj)) {
1666 if (obj && !PythonQtSlotFunction_Check(obj)) {
1671 static const char* argumentList[] ={"bool" , "bool"};
1667 static const char* argumentList[] ={"bool" , "bool"};
1672 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1668 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1673 bool returnValue;
1669 bool returnValue;
1674 void* args[2] = {NULL, (void*)&next};
1670 void* args[2] = {NULL, (void*)&next};
1675 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1671 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1676 if (result) {
1672 if (result) {
1677 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1673 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1678 if (args[0]!=&returnValue) {
1674 if (args[0]!=&returnValue) {
1679 if (args[0]==NULL) {
1675 if (args[0]==NULL) {
1680 PythonQt::priv()->handleVirtualOverloadReturnError("focusNextPrevChild", methodInfo, result);
1676 PythonQt::priv()->handleVirtualOverloadReturnError("focusNextPrevChild", methodInfo, result);
1681 } else {
1677 } else {
1682 returnValue = *((bool*)args[0]);
1678 returnValue = *((bool*)args[0]);
1683 }
1679 }
1684 }
1680 }
1685 }
1681 }
1686 if (result) { Py_DECREF(result); }
1682 if (result) { Py_DECREF(result); }
1687 Py_DECREF(obj);
1683 Py_DECREF(obj);
1688 return returnValue;
1684 return returnValue;
1689 }
1685 }
1690 }
1686 }
1691 return QHexEdit::focusNextPrevChild(next);
1687 return QHexEdit::focusNextPrevChild(next);
1692 }
1688 }
1693 void PythonQtShell_QHexEdit::focusOutEvent(QFocusEvent* arg__1)
1689 void PythonQtShell_QHexEdit::focusOutEvent(QFocusEvent* arg__1)
1694 {
1690 {
1695 if (_wrapper) {
1691 if (_wrapper) {
1696 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusOutEvent");
1692 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusOutEvent");
1697 PyErr_Clear();
1693 PyErr_Clear();
1698 if (obj && !PythonQtSlotFunction_Check(obj)) {
1694 if (obj && !PythonQtSlotFunction_Check(obj)) {
1699 static const char* argumentList[] ={"" , "QFocusEvent*"};
1695 static const char* argumentList[] ={"" , "QFocusEvent*"};
1700 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1696 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1701 void* args[2] = {NULL, (void*)&arg__1};
1697 void* args[2] = {NULL, (void*)&arg__1};
1702 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1698 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1703 if (result) { Py_DECREF(result); }
1699 if (result) { Py_DECREF(result); }
1704 Py_DECREF(obj);
1700 Py_DECREF(obj);
1705 return;
1701 return;
1706 }
1702 }
1707 }
1703 }
1708 QHexEdit::focusOutEvent(arg__1);
1704 QHexEdit::focusOutEvent(arg__1);
1709 }
1705 }
1710 bool PythonQtShell_QHexEdit::hasHeightForWidth() const
1706 bool PythonQtShell_QHexEdit::hasHeightForWidth() const
1711 {
1707 {
1712 if (_wrapper) {
1708 if (_wrapper) {
1713 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hasHeightForWidth");
1709 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hasHeightForWidth");
1714 PyErr_Clear();
1710 PyErr_Clear();
1715 if (obj && !PythonQtSlotFunction_Check(obj)) {
1711 if (obj && !PythonQtSlotFunction_Check(obj)) {
1716 static const char* argumentList[] ={"bool"};
1712 static const char* argumentList[] ={"bool"};
1717 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
1713 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
1718 bool returnValue;
1714 bool returnValue;
1719 void* args[1] = {NULL};
1715 void* args[1] = {NULL};
1720 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1716 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1721 if (result) {
1717 if (result) {
1722 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1718 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1723 if (args[0]!=&returnValue) {
1719 if (args[0]!=&returnValue) {
1724 if (args[0]==NULL) {
1720 if (args[0]==NULL) {
1725 PythonQt::priv()->handleVirtualOverloadReturnError("hasHeightForWidth", methodInfo, result);
1721 PythonQt::priv()->handleVirtualOverloadReturnError("hasHeightForWidth", methodInfo, result);
1726 } else {
1722 } else {
1727 returnValue = *((bool*)args[0]);
1723 returnValue = *((bool*)args[0]);
1728 }
1724 }
1729 }
1725 }
1730 }
1726 }
1731 if (result) { Py_DECREF(result); }
1727 if (result) { Py_DECREF(result); }
1732 Py_DECREF(obj);
1728 Py_DECREF(obj);
1733 return returnValue;
1729 return returnValue;
1734 }
1730 }
1735 }
1731 }
1736 return QHexEdit::hasHeightForWidth();
1732 return QHexEdit::hasHeightForWidth();
1737 }
1733 }
1738 int PythonQtShell_QHexEdit::heightForWidth(int arg__1) const
1734 int PythonQtShell_QHexEdit::heightForWidth(int arg__1) const
1739 {
1735 {
1740 if (_wrapper) {
1736 if (_wrapper) {
1741 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "heightForWidth");
1737 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "heightForWidth");
1742 PyErr_Clear();
1738 PyErr_Clear();
1743 if (obj && !PythonQtSlotFunction_Check(obj)) {
1739 if (obj && !PythonQtSlotFunction_Check(obj)) {
1744 static const char* argumentList[] ={"int" , "int"};
1740 static const char* argumentList[] ={"int" , "int"};
1745 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1741 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1746 int returnValue;
1742 int returnValue;
1747 void* args[2] = {NULL, (void*)&arg__1};
1743 void* args[2] = {NULL, (void*)&arg__1};
1748 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1744 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1749 if (result) {
1745 if (result) {
1750 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1746 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1751 if (args[0]!=&returnValue) {
1747 if (args[0]!=&returnValue) {
1752 if (args[0]==NULL) {
1748 if (args[0]==NULL) {
1753 PythonQt::priv()->handleVirtualOverloadReturnError("heightForWidth", methodInfo, result);
1749 PythonQt::priv()->handleVirtualOverloadReturnError("heightForWidth", methodInfo, result);
1754 } else {
1750 } else {
1755 returnValue = *((int*)args[0]);
1751 returnValue = *((int*)args[0]);
1756 }
1752 }
1757 }
1753 }
1758 }
1754 }
1759 if (result) { Py_DECREF(result); }
1755 if (result) { Py_DECREF(result); }
1760 Py_DECREF(obj);
1756 Py_DECREF(obj);
1761 return returnValue;
1757 return returnValue;
1762 }
1758 }
1763 }
1759 }
1764 return QHexEdit::heightForWidth(arg__1);
1760 return QHexEdit::heightForWidth(arg__1);
1765 }
1761 }
1766 void PythonQtShell_QHexEdit::hideEvent(QHideEvent* arg__1)
1762 void PythonQtShell_QHexEdit::hideEvent(QHideEvent* arg__1)
1767 {
1763 {
1768 if (_wrapper) {
1764 if (_wrapper) {
1769 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hideEvent");
1765 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hideEvent");
1770 PyErr_Clear();
1766 PyErr_Clear();
1771 if (obj && !PythonQtSlotFunction_Check(obj)) {
1767 if (obj && !PythonQtSlotFunction_Check(obj)) {
1772 static const char* argumentList[] ={"" , "QHideEvent*"};
1768 static const char* argumentList[] ={"" , "QHideEvent*"};
1773 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1769 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1774 void* args[2] = {NULL, (void*)&arg__1};
1770 void* args[2] = {NULL, (void*)&arg__1};
1775 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1771 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1776 if (result) { Py_DECREF(result); }
1772 if (result) { Py_DECREF(result); }
1777 Py_DECREF(obj);
1773 Py_DECREF(obj);
1778 return;
1774 return;
1779 }
1775 }
1780 }
1776 }
1781 QHexEdit::hideEvent(arg__1);
1777 QHexEdit::hideEvent(arg__1);
1782 }
1778 }
1783 void PythonQtShell_QHexEdit::initPainter(QPainter* painter) const
1779 void PythonQtShell_QHexEdit::initPainter(QPainter* painter) const
1784 {
1780 {
1785 if (_wrapper) {
1781 if (_wrapper) {
1786 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "initPainter");
1782 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "initPainter");
1787 PyErr_Clear();
1783 PyErr_Clear();
1788 if (obj && !PythonQtSlotFunction_Check(obj)) {
1784 if (obj && !PythonQtSlotFunction_Check(obj)) {
1789 static const char* argumentList[] ={"" , "QPainter*"};
1785 static const char* argumentList[] ={"" , "QPainter*"};
1790 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1786 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1791 void* args[2] = {NULL, (void*)&painter};
1787 void* args[2] = {NULL, (void*)&painter};
1792 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1788 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1793 if (result) { Py_DECREF(result); }
1789 if (result) { Py_DECREF(result); }
1794 Py_DECREF(obj);
1790 Py_DECREF(obj);
1795 return;
1791 return;
1796 }
1792 }
1797 }
1793 }
1798 QHexEdit::initPainter(painter);
1794 QHexEdit::initPainter(painter);
1799 }
1795 }
1800 void PythonQtShell_QHexEdit::inputMethodEvent(QInputMethodEvent* arg__1)
1796 void PythonQtShell_QHexEdit::inputMethodEvent(QInputMethodEvent* arg__1)
1801 {
1797 {
1802 if (_wrapper) {
1798 if (_wrapper) {
1803 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodEvent");
1799 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodEvent");
1804 PyErr_Clear();
1800 PyErr_Clear();
1805 if (obj && !PythonQtSlotFunction_Check(obj)) {
1801 if (obj && !PythonQtSlotFunction_Check(obj)) {
1806 static const char* argumentList[] ={"" , "QInputMethodEvent*"};
1802 static const char* argumentList[] ={"" , "QInputMethodEvent*"};
1807 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1803 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1808 void* args[2] = {NULL, (void*)&arg__1};
1804 void* args[2] = {NULL, (void*)&arg__1};
1809 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1805 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1810 if (result) { Py_DECREF(result); }
1806 if (result) { Py_DECREF(result); }
1811 Py_DECREF(obj);
1807 Py_DECREF(obj);
1812 return;
1808 return;
1813 }
1809 }
1814 }
1810 }
1815 QHexEdit::inputMethodEvent(arg__1);
1811 QHexEdit::inputMethodEvent(arg__1);
1816 }
1812 }
1817 QVariant PythonQtShell_QHexEdit::inputMethodQuery(Qt::InputMethodQuery arg__1) const
1813 QVariant PythonQtShell_QHexEdit::inputMethodQuery(Qt::InputMethodQuery arg__1) const
1818 {
1814 {
1819 if (_wrapper) {
1815 if (_wrapper) {
1820 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodQuery");
1816 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodQuery");
1821 PyErr_Clear();
1817 PyErr_Clear();
1822 if (obj && !PythonQtSlotFunction_Check(obj)) {
1818 if (obj && !PythonQtSlotFunction_Check(obj)) {
1823 static const char* argumentList[] ={"QVariant" , "Qt::InputMethodQuery"};
1819 static const char* argumentList[] ={"QVariant" , "Qt::InputMethodQuery"};
1824 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1820 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1825 QVariant returnValue;
1821 QVariant returnValue;
1826 void* args[2] = {NULL, (void*)&arg__1};
1822 void* args[2] = {NULL, (void*)&arg__1};
1827 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1823 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1828 if (result) {
1824 if (result) {
1829 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1825 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1830 if (args[0]!=&returnValue) {
1826 if (args[0]!=&returnValue) {
1831 if (args[0]==NULL) {
1827 if (args[0]==NULL) {
1832 PythonQt::priv()->handleVirtualOverloadReturnError("inputMethodQuery", methodInfo, result);
1828 PythonQt::priv()->handleVirtualOverloadReturnError("inputMethodQuery", methodInfo, result);
1833 } else {
1829 } else {
1834 returnValue = *((QVariant*)args[0]);
1830 returnValue = *((QVariant*)args[0]);
1835 }
1831 }
1836 }
1832 }
1837 }
1833 }
1838 if (result) { Py_DECREF(result); }
1834 if (result) { Py_DECREF(result); }
1839 Py_DECREF(obj);
1835 Py_DECREF(obj);
1840 return returnValue;
1836 return returnValue;
1841 }
1837 }
1842 }
1838 }
1843 return QHexEdit::inputMethodQuery(arg__1);
1839 return QHexEdit::inputMethodQuery(arg__1);
1844 }
1840 }
1845 void PythonQtShell_QHexEdit::keyPressEvent(QKeyEvent* arg__1)
1841 void PythonQtShell_QHexEdit::keyPressEvent(QKeyEvent* arg__1)
1846 {
1842 {
1847 if (_wrapper) {
1843 if (_wrapper) {
1848 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyPressEvent");
1844 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyPressEvent");
1849 PyErr_Clear();
1845 PyErr_Clear();
1850 if (obj && !PythonQtSlotFunction_Check(obj)) {
1846 if (obj && !PythonQtSlotFunction_Check(obj)) {
1851 static const char* argumentList[] ={"" , "QKeyEvent*"};
1847 static const char* argumentList[] ={"" , "QKeyEvent*"};
1852 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1848 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1853 void* args[2] = {NULL, (void*)&arg__1};
1849 void* args[2] = {NULL, (void*)&arg__1};
1854 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1850 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1855 if (result) { Py_DECREF(result); }
1851 if (result) { Py_DECREF(result); }
1856 Py_DECREF(obj);
1852 Py_DECREF(obj);
1857 return;
1853 return;
1858 }
1854 }
1859 }
1855 }
1860 QHexEdit::keyPressEvent(arg__1);
1856 QHexEdit::keyPressEvent(arg__1);
1861 }
1857 }
1862 void PythonQtShell_QHexEdit::keyReleaseEvent(QKeyEvent* arg__1)
1858 void PythonQtShell_QHexEdit::keyReleaseEvent(QKeyEvent* arg__1)
1863 {
1859 {
1864 if (_wrapper) {
1860 if (_wrapper) {
1865 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyReleaseEvent");
1861 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyReleaseEvent");
1866 PyErr_Clear();
1862 PyErr_Clear();
1867 if (obj && !PythonQtSlotFunction_Check(obj)) {
1863 if (obj && !PythonQtSlotFunction_Check(obj)) {
1868 static const char* argumentList[] ={"" , "QKeyEvent*"};
1864 static const char* argumentList[] ={"" , "QKeyEvent*"};
1869 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1865 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1870 void* args[2] = {NULL, (void*)&arg__1};
1866 void* args[2] = {NULL, (void*)&arg__1};
1871 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1867 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1872 if (result) { Py_DECREF(result); }
1868 if (result) { Py_DECREF(result); }
1873 Py_DECREF(obj);
1869 Py_DECREF(obj);
1874 return;
1870 return;
1875 }
1871 }
1876 }
1872 }
1877 QHexEdit::keyReleaseEvent(arg__1);
1873 QHexEdit::keyReleaseEvent(arg__1);
1878 }
1874 }
1879 void PythonQtShell_QHexEdit::leaveEvent(QEvent* arg__1)
1875 void PythonQtShell_QHexEdit::leaveEvent(QEvent* arg__1)
1880 {
1876 {
1881 if (_wrapper) {
1877 if (_wrapper) {
1882 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "leaveEvent");
1878 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "leaveEvent");
1883 PyErr_Clear();
1879 PyErr_Clear();
1884 if (obj && !PythonQtSlotFunction_Check(obj)) {
1880 if (obj && !PythonQtSlotFunction_Check(obj)) {
1885 static const char* argumentList[] ={"" , "QEvent*"};
1881 static const char* argumentList[] ={"" , "QEvent*"};
1886 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1882 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1887 void* args[2] = {NULL, (void*)&arg__1};
1883 void* args[2] = {NULL, (void*)&arg__1};
1888 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1884 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1889 if (result) { Py_DECREF(result); }
1885 if (result) { Py_DECREF(result); }
1890 Py_DECREF(obj);
1886 Py_DECREF(obj);
1891 return;
1887 return;
1892 }
1888 }
1893 }
1889 }
1894 QHexEdit::leaveEvent(arg__1);
1890 QHexEdit::leaveEvent(arg__1);
1895 }
1891 }
1896 int PythonQtShell_QHexEdit::metric(QPaintDevice::PaintDeviceMetric arg__1) const
1892 int PythonQtShell_QHexEdit::metric(QPaintDevice::PaintDeviceMetric arg__1) const
1897 {
1893 {
1898 if (_wrapper) {
1894 if (_wrapper) {
1899 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "metric");
1895 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "metric");
1900 PyErr_Clear();
1896 PyErr_Clear();
1901 if (obj && !PythonQtSlotFunction_Check(obj)) {
1897 if (obj && !PythonQtSlotFunction_Check(obj)) {
1902 static const char* argumentList[] ={"int" , "QPaintDevice::PaintDeviceMetric"};
1898 static const char* argumentList[] ={"int" , "QPaintDevice::PaintDeviceMetric"};
1903 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1899 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1904 int returnValue;
1900 int returnValue;
1905 void* args[2] = {NULL, (void*)&arg__1};
1901 void* args[2] = {NULL, (void*)&arg__1};
1906 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1902 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1907 if (result) {
1903 if (result) {
1908 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1904 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
1909 if (args[0]!=&returnValue) {
1905 if (args[0]!=&returnValue) {
1910 if (args[0]==NULL) {
1906 if (args[0]==NULL) {
1911 PythonQt::priv()->handleVirtualOverloadReturnError("metric", methodInfo, result);
1907 PythonQt::priv()->handleVirtualOverloadReturnError("metric", methodInfo, result);
1912 } else {
1908 } else {
1913 returnValue = *((int*)args[0]);
1909 returnValue = *((int*)args[0]);
1914 }
1910 }
1915 }
1911 }
1916 }
1912 }
1917 if (result) { Py_DECREF(result); }
1913 if (result) { Py_DECREF(result); }
1918 Py_DECREF(obj);
1914 Py_DECREF(obj);
1919 return returnValue;
1915 return returnValue;
1920 }
1916 }
1921 }
1917 }
1922 return QHexEdit::metric(arg__1);
1918 return QHexEdit::metric(arg__1);
1923 }
1919 }
1924 void PythonQtShell_QHexEdit::mouseDoubleClickEvent(QMouseEvent* arg__1)
1920 void PythonQtShell_QHexEdit::mouseDoubleClickEvent(QMouseEvent* arg__1)
1925 {
1921 {
1926 if (_wrapper) {
1922 if (_wrapper) {
1927 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseDoubleClickEvent");
1923 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseDoubleClickEvent");
1928 PyErr_Clear();
1924 PyErr_Clear();
1929 if (obj && !PythonQtSlotFunction_Check(obj)) {
1925 if (obj && !PythonQtSlotFunction_Check(obj)) {
1930 static const char* argumentList[] ={"" , "QMouseEvent*"};
1926 static const char* argumentList[] ={"" , "QMouseEvent*"};
1931 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1927 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1932 void* args[2] = {NULL, (void*)&arg__1};
1928 void* args[2] = {NULL, (void*)&arg__1};
1933 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1929 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1934 if (result) { Py_DECREF(result); }
1930 if (result) { Py_DECREF(result); }
1935 Py_DECREF(obj);
1931 Py_DECREF(obj);
1936 return;
1932 return;
1937 }
1933 }
1938 }
1934 }
1939 QHexEdit::mouseDoubleClickEvent(arg__1);
1935 QHexEdit::mouseDoubleClickEvent(arg__1);
1940 }
1936 }
1941 void PythonQtShell_QHexEdit::mouseMoveEvent(QMouseEvent* arg__1)
1937 void PythonQtShell_QHexEdit::mouseMoveEvent(QMouseEvent* arg__1)
1942 {
1938 {
1943 if (_wrapper) {
1939 if (_wrapper) {
1944 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseMoveEvent");
1940 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseMoveEvent");
1945 PyErr_Clear();
1941 PyErr_Clear();
1946 if (obj && !PythonQtSlotFunction_Check(obj)) {
1942 if (obj && !PythonQtSlotFunction_Check(obj)) {
1947 static const char* argumentList[] ={"" , "QMouseEvent*"};
1943 static const char* argumentList[] ={"" , "QMouseEvent*"};
1948 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1944 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1949 void* args[2] = {NULL, (void*)&arg__1};
1945 void* args[2] = {NULL, (void*)&arg__1};
1950 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1946 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1951 if (result) { Py_DECREF(result); }
1947 if (result) { Py_DECREF(result); }
1952 Py_DECREF(obj);
1948 Py_DECREF(obj);
1953 return;
1949 return;
1954 }
1950 }
1955 }
1951 }
1956 QHexEdit::mouseMoveEvent(arg__1);
1952 QHexEdit::mouseMoveEvent(arg__1);
1957 }
1953 }
1958 void PythonQtShell_QHexEdit::mousePressEvent(QMouseEvent* arg__1)
1954 void PythonQtShell_QHexEdit::mousePressEvent(QMouseEvent* arg__1)
1959 {
1955 {
1960 if (_wrapper) {
1956 if (_wrapper) {
1961 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mousePressEvent");
1957 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mousePressEvent");
1962 PyErr_Clear();
1958 PyErr_Clear();
1963 if (obj && !PythonQtSlotFunction_Check(obj)) {
1959 if (obj && !PythonQtSlotFunction_Check(obj)) {
1964 static const char* argumentList[] ={"" , "QMouseEvent*"};
1960 static const char* argumentList[] ={"" , "QMouseEvent*"};
1965 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1961 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1966 void* args[2] = {NULL, (void*)&arg__1};
1962 void* args[2] = {NULL, (void*)&arg__1};
1967 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1963 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1968 if (result) { Py_DECREF(result); }
1964 if (result) { Py_DECREF(result); }
1969 Py_DECREF(obj);
1965 Py_DECREF(obj);
1970 return;
1966 return;
1971 }
1967 }
1972 }
1968 }
1973 QHexEdit::mousePressEvent(arg__1);
1969 QHexEdit::mousePressEvent(arg__1);
1974 }
1970 }
1975 void PythonQtShell_QHexEdit::mouseReleaseEvent(QMouseEvent* arg__1)
1971 void PythonQtShell_QHexEdit::mouseReleaseEvent(QMouseEvent* arg__1)
1976 {
1972 {
1977 if (_wrapper) {
1973 if (_wrapper) {
1978 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseReleaseEvent");
1974 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseReleaseEvent");
1979 PyErr_Clear();
1975 PyErr_Clear();
1980 if (obj && !PythonQtSlotFunction_Check(obj)) {
1976 if (obj && !PythonQtSlotFunction_Check(obj)) {
1981 static const char* argumentList[] ={"" , "QMouseEvent*"};
1977 static const char* argumentList[] ={"" , "QMouseEvent*"};
1982 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1978 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1983 void* args[2] = {NULL, (void*)&arg__1};
1979 void* args[2] = {NULL, (void*)&arg__1};
1984 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1980 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1985 if (result) { Py_DECREF(result); }
1981 if (result) { Py_DECREF(result); }
1986 Py_DECREF(obj);
1982 Py_DECREF(obj);
1987 return;
1983 return;
1988 }
1984 }
1989 }
1985 }
1990 QHexEdit::mouseReleaseEvent(arg__1);
1986 QHexEdit::mouseReleaseEvent(arg__1);
1991 }
1987 }
1992 void PythonQtShell_QHexEdit::moveEvent(QMoveEvent* arg__1)
1988 void PythonQtShell_QHexEdit::moveEvent(QMoveEvent* arg__1)
1993 {
1989 {
1994 if (_wrapper) {
1990 if (_wrapper) {
1995 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "moveEvent");
1991 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "moveEvent");
1996 PyErr_Clear();
1992 PyErr_Clear();
1997 if (obj && !PythonQtSlotFunction_Check(obj)) {
1993 if (obj && !PythonQtSlotFunction_Check(obj)) {
1998 static const char* argumentList[] ={"" , "QMoveEvent*"};
1994 static const char* argumentList[] ={"" , "QMoveEvent*"};
1999 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
1995 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2000 void* args[2] = {NULL, (void*)&arg__1};
1996 void* args[2] = {NULL, (void*)&arg__1};
2001 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
1997 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2002 if (result) { Py_DECREF(result); }
1998 if (result) { Py_DECREF(result); }
2003 Py_DECREF(obj);
1999 Py_DECREF(obj);
2004 return;
2000 return;
2005 }
2001 }
2006 }
2002 }
2007 QHexEdit::moveEvent(arg__1);
2003 QHexEdit::moveEvent(arg__1);
2008 }
2004 }
2009 bool PythonQtShell_QHexEdit::nativeEvent(const QByteArray& eventType, void* message, long* result)
2005 bool PythonQtShell_QHexEdit::nativeEvent(const QByteArray& eventType, void* message, long* result)
2010 {
2006 {
2011 if (_wrapper) {
2007 if (_wrapper) {
2012 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "nativeEvent");
2008 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "nativeEvent");
2013 PyErr_Clear();
2009 PyErr_Clear();
2014 if (obj && !PythonQtSlotFunction_Check(obj)) {
2010 if (obj && !PythonQtSlotFunction_Check(obj)) {
2015 static const char* argumentList[] ={"bool" , "const QByteArray&" , "void*" , "long*"};
2011 static const char* argumentList[] ={"bool" , "const QByteArray&" , "void*" , "long*"};
2016 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
2012 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
2017 bool returnValue;
2013 bool returnValue;
2018 void* args[4] = {NULL, (void*)&eventType, (void*)&message, (void*)&result};
2014 void* args[4] = {NULL, (void*)&eventType, (void*)&message, (void*)&result};
2019 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2015 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2020 if (result) {
2016 if (result) {
2021 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
2017 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
2022 if (args[0]!=&returnValue) {
2018 if (args[0]!=&returnValue) {
2023 if (args[0]==NULL) {
2019 if (args[0]==NULL) {
2024 PythonQt::priv()->handleVirtualOverloadReturnError("nativeEvent", methodInfo, result);
2020 PythonQt::priv()->handleVirtualOverloadReturnError("nativeEvent", methodInfo, result);
2025 } else {
2021 } else {
2026 returnValue = *((bool*)args[0]);
2022 returnValue = *((bool*)args[0]);
2027 }
2023 }
2028 }
2024 }
2029 }
2025 }
2030 if (result) { Py_DECREF(result); }
2026 if (result) { Py_DECREF(result); }
2031 Py_DECREF(obj);
2027 Py_DECREF(obj);
2032 return returnValue;
2028 return returnValue;
2033 }
2029 }
2034 }
2030 }
2035 return QHexEdit::nativeEvent(eventType, message, result);
2031 return QHexEdit::nativeEvent(eventType, message, result);
2036 }
2032 }
2037 QPaintEngine* PythonQtShell_QHexEdit::paintEngine() const
2033 QPaintEngine* PythonQtShell_QHexEdit::paintEngine() const
2038 {
2034 {
2039 if (_wrapper) {
2035 if (_wrapper) {
2040 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEngine");
2036 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEngine");
2041 PyErr_Clear();
2037 PyErr_Clear();
2042 if (obj && !PythonQtSlotFunction_Check(obj)) {
2038 if (obj && !PythonQtSlotFunction_Check(obj)) {
2043 static const char* argumentList[] ={"QPaintEngine*"};
2039 static const char* argumentList[] ={"QPaintEngine*"};
2044 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
2040 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
2045 QPaintEngine* returnValue;
2041 QPaintEngine* returnValue;
2046 void* args[1] = {NULL};
2042 void* args[1] = {NULL};
2047 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2043 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2048 if (result) {
2044 if (result) {
2049 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
2045 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
2050 if (args[0]!=&returnValue) {
2046 if (args[0]!=&returnValue) {
2051 if (args[0]==NULL) {
2047 if (args[0]==NULL) {
2052 PythonQt::priv()->handleVirtualOverloadReturnError("paintEngine", methodInfo, result);
2048 PythonQt::priv()->handleVirtualOverloadReturnError("paintEngine", methodInfo, result);
2053 } else {
2049 } else {
2054 returnValue = *((QPaintEngine**)args[0]);
2050 returnValue = *((QPaintEngine**)args[0]);
2055 }
2051 }
2056 }
2052 }
2057 }
2053 }
2058 if (result) { Py_DECREF(result); }
2054 if (result) { Py_DECREF(result); }
2059 Py_DECREF(obj);
2055 Py_DECREF(obj);
2060 return returnValue;
2056 return returnValue;
2061 }
2057 }
2062 }
2058 }
2063 return QHexEdit::paintEngine();
2059 return QHexEdit::paintEngine();
2064 }
2060 }
2065 void PythonQtShell_QHexEdit::paintEvent(QPaintEvent* arg__1)
2061 void PythonQtShell_QHexEdit::paintEvent(QPaintEvent* arg__1)
2066 {
2062 {
2067 if (_wrapper) {
2063 if (_wrapper) {
2068 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEvent");
2064 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEvent");
2069 PyErr_Clear();
2065 PyErr_Clear();
2070 if (obj && !PythonQtSlotFunction_Check(obj)) {
2066 if (obj && !PythonQtSlotFunction_Check(obj)) {
2071 static const char* argumentList[] ={"" , "QPaintEvent*"};
2067 static const char* argumentList[] ={"" , "QPaintEvent*"};
2072 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2068 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2073 void* args[2] = {NULL, (void*)&arg__1};
2069 void* args[2] = {NULL, (void*)&arg__1};
2074 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2070 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2075 if (result) { Py_DECREF(result); }
2071 if (result) { Py_DECREF(result); }
2076 Py_DECREF(obj);
2072 Py_DECREF(obj);
2077 return;
2073 return;
2078 }
2074 }
2079 }
2075 }
2080 QHexEdit::paintEvent(arg__1);
2076 QHexEdit::paintEvent(arg__1);
2081 }
2077 }
2082 QPaintDevice* PythonQtShell_QHexEdit::redirected(QPoint* offset) const
2078 QPaintDevice* PythonQtShell_QHexEdit::redirected(QPoint* offset) const
2083 {
2079 {
2084 if (_wrapper) {
2080 if (_wrapper) {
2085 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "redirected");
2081 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "redirected");
2086 PyErr_Clear();
2082 PyErr_Clear();
2087 if (obj && !PythonQtSlotFunction_Check(obj)) {
2083 if (obj && !PythonQtSlotFunction_Check(obj)) {
2088 static const char* argumentList[] ={"QPaintDevice*" , "QPoint*"};
2084 static const char* argumentList[] ={"QPaintDevice*" , "QPoint*"};
2089 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2085 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2090 QPaintDevice* returnValue;
2086 QPaintDevice* returnValue;
2091 void* args[2] = {NULL, (void*)&offset};
2087 void* args[2] = {NULL, (void*)&offset};
2092 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2088 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2093 if (result) {
2089 if (result) {
2094 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
2090 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
2095 if (args[0]!=&returnValue) {
2091 if (args[0]!=&returnValue) {
2096 if (args[0]==NULL) {
2092 if (args[0]==NULL) {
2097 PythonQt::priv()->handleVirtualOverloadReturnError("redirected", methodInfo, result);
2093 PythonQt::priv()->handleVirtualOverloadReturnError("redirected", methodInfo, result);
2098 } else {
2094 } else {
2099 returnValue = *((QPaintDevice**)args[0]);
2095 returnValue = *((QPaintDevice**)args[0]);
2100 }
2096 }
2101 }
2097 }
2102 }
2098 }
2103 if (result) { Py_DECREF(result); }
2099 if (result) { Py_DECREF(result); }
2104 Py_DECREF(obj);
2100 Py_DECREF(obj);
2105 return returnValue;
2101 return returnValue;
2106 }
2102 }
2107 }
2103 }
2108 return QHexEdit::redirected(offset);
2104 return QHexEdit::redirected(offset);
2109 }
2105 }
2110 void PythonQtShell_QHexEdit::resizeEvent(QResizeEvent* arg__1)
2106 void PythonQtShell_QHexEdit::resizeEvent(QResizeEvent* arg__1)
2111 {
2107 {
2112 if (_wrapper) {
2108 if (_wrapper) {
2113 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "resizeEvent");
2109 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "resizeEvent");
2114 PyErr_Clear();
2110 PyErr_Clear();
2115 if (obj && !PythonQtSlotFunction_Check(obj)) {
2111 if (obj && !PythonQtSlotFunction_Check(obj)) {
2116 static const char* argumentList[] ={"" , "QResizeEvent*"};
2112 static const char* argumentList[] ={"" , "QResizeEvent*"};
2117 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2113 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2118 void* args[2] = {NULL, (void*)&arg__1};
2114 void* args[2] = {NULL, (void*)&arg__1};
2119 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2115 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2120 if (result) { Py_DECREF(result); }
2116 if (result) { Py_DECREF(result); }
2121 Py_DECREF(obj);
2117 Py_DECREF(obj);
2122 return;
2118 return;
2123 }
2119 }
2124 }
2120 }
2125 QHexEdit::resizeEvent(arg__1);
2121 QHexEdit::resizeEvent(arg__1);
2126 }
2122 }
2127 void PythonQtShell_QHexEdit::scrollContentsBy(int dx, int dy)
2123 void PythonQtShell_QHexEdit::scrollContentsBy(int dx, int dy)
2128 {
2124 {
2129 if (_wrapper) {
2125 if (_wrapper) {
2130 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "scrollContentsBy");
2126 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "scrollContentsBy");
2131 PyErr_Clear();
2127 PyErr_Clear();
2132 if (obj && !PythonQtSlotFunction_Check(obj)) {
2128 if (obj && !PythonQtSlotFunction_Check(obj)) {
2133 static const char* argumentList[] ={"" , "int" , "int"};
2129 static const char* argumentList[] ={"" , "int" , "int"};
2134 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
2130 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
2135 void* args[3] = {NULL, (void*)&dx, (void*)&dy};
2131 void* args[3] = {NULL, (void*)&dx, (void*)&dy};
2136 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2132 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2137 if (result) { Py_DECREF(result); }
2133 if (result) { Py_DECREF(result); }
2138 Py_DECREF(obj);
2134 Py_DECREF(obj);
2139 return;
2135 return;
2140 }
2136 }
2141 }
2137 }
2142 QHexEdit::scrollContentsBy(dx, dy);
2138 QHexEdit::scrollContentsBy(dx, dy);
2143 }
2139 }
2144 void PythonQtShell_QHexEdit::setupViewport(QWidget* viewport)
2140 void PythonQtShell_QHexEdit::setupViewport(QWidget* viewport)
2145 {
2141 {
2146 if (_wrapper) {
2142 if (_wrapper) {
2147 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "setupViewport");
2143 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "setupViewport");
2148 PyErr_Clear();
2144 PyErr_Clear();
2149 if (obj && !PythonQtSlotFunction_Check(obj)) {
2145 if (obj && !PythonQtSlotFunction_Check(obj)) {
2150 static const char* argumentList[] ={"" , "QWidget*"};
2146 static const char* argumentList[] ={"" , "QWidget*"};
2151 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2147 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2152 void* args[2] = {NULL, (void*)&viewport};
2148 void* args[2] = {NULL, (void*)&viewport};
2153 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2149 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2154 if (result) { Py_DECREF(result); }
2150 if (result) { Py_DECREF(result); }
2155 Py_DECREF(obj);
2151 Py_DECREF(obj);
2156 return;
2152 return;
2157 }
2153 }
2158 }
2154 }
2159 QHexEdit::setupViewport(viewport);
2155 QHexEdit::setupViewport(viewport);
2160 }
2156 }
2161 QPainter* PythonQtShell_QHexEdit::sharedPainter() const
2157 QPainter* PythonQtShell_QHexEdit::sharedPainter() const
2162 {
2158 {
2163 if (_wrapper) {
2159 if (_wrapper) {
2164 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "sharedPainter");
2160 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "sharedPainter");
2165 PyErr_Clear();
2161 PyErr_Clear();
2166 if (obj && !PythonQtSlotFunction_Check(obj)) {
2162 if (obj && !PythonQtSlotFunction_Check(obj)) {
2167 static const char* argumentList[] ={"QPainter*"};
2163 static const char* argumentList[] ={"QPainter*"};
2168 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
2164 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
2169 QPainter* returnValue;
2165 QPainter* returnValue;
2170 void* args[1] = {NULL};
2166 void* args[1] = {NULL};
2171 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2167 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2172 if (result) {
2168 if (result) {
2173 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
2169 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
2174 if (args[0]!=&returnValue) {
2170 if (args[0]!=&returnValue) {
2175 if (args[0]==NULL) {
2171 if (args[0]==NULL) {
2176 PythonQt::priv()->handleVirtualOverloadReturnError("sharedPainter", methodInfo, result);
2172 PythonQt::priv()->handleVirtualOverloadReturnError("sharedPainter", methodInfo, result);
2177 } else {
2173 } else {
2178 returnValue = *((QPainter**)args[0]);
2174 returnValue = *((QPainter**)args[0]);
2179 }
2175 }
2180 }
2176 }
2181 }
2177 }
2182 if (result) { Py_DECREF(result); }
2178 if (result) { Py_DECREF(result); }
2183 Py_DECREF(obj);
2179 Py_DECREF(obj);
2184 return returnValue;
2180 return returnValue;
2185 }
2181 }
2186 }
2182 }
2187 return QHexEdit::sharedPainter();
2183 return QHexEdit::sharedPainter();
2188 }
2184 }
2189 void PythonQtShell_QHexEdit::showEvent(QShowEvent* arg__1)
2185 void PythonQtShell_QHexEdit::showEvent(QShowEvent* arg__1)
2190 {
2186 {
2191 if (_wrapper) {
2187 if (_wrapper) {
2192 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "showEvent");
2188 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "showEvent");
2193 PyErr_Clear();
2189 PyErr_Clear();
2194 if (obj && !PythonQtSlotFunction_Check(obj)) {
2190 if (obj && !PythonQtSlotFunction_Check(obj)) {
2195 static const char* argumentList[] ={"" , "QShowEvent*"};
2191 static const char* argumentList[] ={"" , "QShowEvent*"};
2196 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2192 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2197 void* args[2] = {NULL, (void*)&arg__1};
2193 void* args[2] = {NULL, (void*)&arg__1};
2198 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2194 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2199 if (result) { Py_DECREF(result); }
2195 if (result) { Py_DECREF(result); }
2200 Py_DECREF(obj);
2196 Py_DECREF(obj);
2201 return;
2197 return;
2202 }
2198 }
2203 }
2199 }
2204 QHexEdit::showEvent(arg__1);
2200 QHexEdit::showEvent(arg__1);
2205 }
2201 }
2206 void PythonQtShell_QHexEdit::tabletEvent(QTabletEvent* arg__1)
2202 void PythonQtShell_QHexEdit::tabletEvent(QTabletEvent* arg__1)
2207 {
2203 {
2208 if (_wrapper) {
2204 if (_wrapper) {
2209 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "tabletEvent");
2205 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "tabletEvent");
2210 PyErr_Clear();
2206 PyErr_Clear();
2211 if (obj && !PythonQtSlotFunction_Check(obj)) {
2207 if (obj && !PythonQtSlotFunction_Check(obj)) {
2212 static const char* argumentList[] ={"" , "QTabletEvent*"};
2208 static const char* argumentList[] ={"" , "QTabletEvent*"};
2213 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2209 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2214 void* args[2] = {NULL, (void*)&arg__1};
2210 void* args[2] = {NULL, (void*)&arg__1};
2215 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2211 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2216 if (result) { Py_DECREF(result); }
2212 if (result) { Py_DECREF(result); }
2217 Py_DECREF(obj);
2213 Py_DECREF(obj);
2218 return;
2214 return;
2219 }
2215 }
2220 }
2216 }
2221 QHexEdit::tabletEvent(arg__1);
2217 QHexEdit::tabletEvent(arg__1);
2222 }
2218 }
2223 void PythonQtShell_QHexEdit::timerEvent(QTimerEvent* arg__1)
2219 void PythonQtShell_QHexEdit::timerEvent(QTimerEvent* arg__1)
2224 {
2220 {
2225 if (_wrapper) {
2221 if (_wrapper) {
2226 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "timerEvent");
2222 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "timerEvent");
2227 PyErr_Clear();
2223 PyErr_Clear();
2228 if (obj && !PythonQtSlotFunction_Check(obj)) {
2224 if (obj && !PythonQtSlotFunction_Check(obj)) {
2229 static const char* argumentList[] ={"" , "QTimerEvent*"};
2225 static const char* argumentList[] ={"" , "QTimerEvent*"};
2230 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2226 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2231 void* args[2] = {NULL, (void*)&arg__1};
2227 void* args[2] = {NULL, (void*)&arg__1};
2232 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2228 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2233 if (result) { Py_DECREF(result); }
2229 if (result) { Py_DECREF(result); }
2234 Py_DECREF(obj);
2230 Py_DECREF(obj);
2235 return;
2231 return;
2236 }
2232 }
2237 }
2233 }
2238 QHexEdit::timerEvent(arg__1);
2234 QHexEdit::timerEvent(arg__1);
2239 }
2235 }
2240 bool PythonQtShell_QHexEdit::viewportEvent(QEvent* arg__1)
2236 bool PythonQtShell_QHexEdit::viewportEvent(QEvent* arg__1)
2241 {
2237 {
2242 if (_wrapper) {
2238 if (_wrapper) {
2243 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "viewportEvent");
2239 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "viewportEvent");
2244 PyErr_Clear();
2240 PyErr_Clear();
2245 if (obj && !PythonQtSlotFunction_Check(obj)) {
2241 if (obj && !PythonQtSlotFunction_Check(obj)) {
2246 static const char* argumentList[] ={"bool" , "QEvent*"};
2242 static const char* argumentList[] ={"bool" , "QEvent*"};
2247 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2243 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2248 bool returnValue;
2244 bool returnValue;
2249 void* args[2] = {NULL, (void*)&arg__1};
2245 void* args[2] = {NULL, (void*)&arg__1};
2250 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2246 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2251 if (result) {
2247 if (result) {
2252 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
2248 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
2253 if (args[0]!=&returnValue) {
2249 if (args[0]!=&returnValue) {
2254 if (args[0]==NULL) {
2250 if (args[0]==NULL) {
2255 PythonQt::priv()->handleVirtualOverloadReturnError("viewportEvent", methodInfo, result);
2251 PythonQt::priv()->handleVirtualOverloadReturnError("viewportEvent", methodInfo, result);
2256 } else {
2252 } else {
2257 returnValue = *((bool*)args[0]);
2253 returnValue = *((bool*)args[0]);
2258 }
2254 }
2259 }
2255 }
2260 }
2256 }
2261 if (result) { Py_DECREF(result); }
2257 if (result) { Py_DECREF(result); }
2262 Py_DECREF(obj);
2258 Py_DECREF(obj);
2263 return returnValue;
2259 return returnValue;
2264 }
2260 }
2265 }
2261 }
2266 return QHexEdit::viewportEvent(arg__1);
2262 return QHexEdit::viewportEvent(arg__1);
2267 }
2263 }
2268 QSize PythonQtShell_QHexEdit::viewportSizeHint() const
2264 QSize PythonQtShell_QHexEdit::viewportSizeHint() const
2269 {
2265 {
2270 if (_wrapper) {
2266 if (_wrapper) {
2271 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "viewportSizeHint");
2267 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "viewportSizeHint");
2272 PyErr_Clear();
2268 PyErr_Clear();
2273 if (obj && !PythonQtSlotFunction_Check(obj)) {
2269 if (obj && !PythonQtSlotFunction_Check(obj)) {
2274 static const char* argumentList[] ={"QSize"};
2270 static const char* argumentList[] ={"QSize"};
2275 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
2271 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
2276 QSize returnValue;
2272 QSize returnValue;
2277 void* args[1] = {NULL};
2273 void* args[1] = {NULL};
2278 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2274 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2279 if (result) {
2275 if (result) {
2280 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
2276 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
2281 if (args[0]!=&returnValue) {
2277 if (args[0]!=&returnValue) {
2282 if (args[0]==NULL) {
2278 if (args[0]==NULL) {
2283 PythonQt::priv()->handleVirtualOverloadReturnError("viewportSizeHint", methodInfo, result);
2279 PythonQt::priv()->handleVirtualOverloadReturnError("viewportSizeHint", methodInfo, result);
2284 } else {
2280 } else {
2285 returnValue = *((QSize*)args[0]);
2281 returnValue = *((QSize*)args[0]);
2286 }
2282 }
2287 }
2283 }
2288 }
2284 }
2289 if (result) { Py_DECREF(result); }
2285 if (result) { Py_DECREF(result); }
2290 Py_DECREF(obj);
2286 Py_DECREF(obj);
2291 return returnValue;
2287 return returnValue;
2292 }
2288 }
2293 }
2289 }
2294 return QHexEdit::viewportSizeHint();
2290 return QHexEdit::viewportSizeHint();
2295 }
2291 }
2296 void PythonQtShell_QHexEdit::wheelEvent(QWheelEvent* arg__1)
2292 void PythonQtShell_QHexEdit::wheelEvent(QWheelEvent* arg__1)
2297 {
2293 {
2298 if (_wrapper) {
2294 if (_wrapper) {
2299 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "wheelEvent");
2295 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "wheelEvent");
2300 PyErr_Clear();
2296 PyErr_Clear();
2301 if (obj && !PythonQtSlotFunction_Check(obj)) {
2297 if (obj && !PythonQtSlotFunction_Check(obj)) {
2302 static const char* argumentList[] ={"" , "QWheelEvent*"};
2298 static const char* argumentList[] ={"" , "QWheelEvent*"};
2303 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2299 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2304 void* args[2] = {NULL, (void*)&arg__1};
2300 void* args[2] = {NULL, (void*)&arg__1};
2305 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2301 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2306 if (result) { Py_DECREF(result); }
2302 if (result) { Py_DECREF(result); }
2307 Py_DECREF(obj);
2303 Py_DECREF(obj);
2308 return;
2304 return;
2309 }
2305 }
2310 }
2306 }
2311 QHexEdit::wheelEvent(arg__1);
2307 QHexEdit::wheelEvent(arg__1);
2312 }
2308 }
2313 QHexEdit* PythonQtWrapper_QHexEdit::new_QHexEdit(QWidget* parent)
2309 QHexEdit* PythonQtWrapper_QHexEdit::new_QHexEdit(QWidget* parent)
2314 {
2310 {
2315 return new PythonQtShell_QHexEdit(parent); }
2311 return new PythonQtShell_QHexEdit(parent); }
2316
2312
2317 QColor PythonQtWrapper_QHexEdit::addressAreaColor(QHexEdit* theWrappedObject)
2313 QColor PythonQtWrapper_QHexEdit::addressAreaColor(QHexEdit* theWrappedObject)
2318 {
2314 {
2319 return ( theWrappedObject->addressAreaColor());
2315 return ( theWrappedObject->addressAreaColor());
2320 }
2316 }
2321
2317
2322 int PythonQtWrapper_QHexEdit::addressOffset(QHexEdit* theWrappedObject)
2318 int PythonQtWrapper_QHexEdit::addressOffset(QHexEdit* theWrappedObject)
2323 {
2319 {
2324 return ( theWrappedObject->addressOffset());
2320 return ( theWrappedObject->addressOffset());
2325 }
2321 }
2326
2322
2327 int PythonQtWrapper_QHexEdit::cursorPosition(QHexEdit* theWrappedObject)
2323 int PythonQtWrapper_QHexEdit::cursorPosition(QHexEdit* theWrappedObject)
2328 {
2324 {
2329 return ( theWrappedObject->cursorPosition());
2325 return ( theWrappedObject->cursorPosition());
2330 }
2326 }
2331
2327
2332 QByteArray PythonQtWrapper_QHexEdit::data(QHexEdit* theWrappedObject)
2328 QByteArray PythonQtWrapper_QHexEdit::data(QHexEdit* theWrappedObject)
2333 {
2329 {
2334 return ( theWrappedObject->data());
2330 return ( theWrappedObject->data());
2335 }
2331 }
2336
2332
2337 const QFont* PythonQtWrapper_QHexEdit::font(QHexEdit* theWrappedObject) const
2333 const QFont* PythonQtWrapper_QHexEdit::font(QHexEdit* theWrappedObject) const
2338 {
2334 {
2339 return &( theWrappedObject->font());
2335 return &( theWrappedObject->font());
2340 }
2336 }
2341
2337
2342 int PythonQtWrapper_QHexEdit::getSelectionBegin(QHexEdit* theWrappedObject)
2338 int PythonQtWrapper_QHexEdit::getSelectionBegin(QHexEdit* theWrappedObject)
2343 {
2339 {
2344 return ( theWrappedObject->getSelectionBegin());
2340 return ( theWrappedObject->getSelectionBegin());
2345 }
2341 }
2346
2342
2347 int PythonQtWrapper_QHexEdit::getSelectionEnd(QHexEdit* theWrappedObject)
2343 int PythonQtWrapper_QHexEdit::getSelectionEnd(QHexEdit* theWrappedObject)
2348 {
2344 {
2349 return ( theWrappedObject->getSelectionEnd());
2345 return ( theWrappedObject->getSelectionEnd());
2350 }
2346 }
2351
2347
2352 QColor PythonQtWrapper_QHexEdit::highlightingColor(QHexEdit* theWrappedObject)
2348 QColor PythonQtWrapper_QHexEdit::highlightingColor(QHexEdit* theWrappedObject)
2353 {
2349 {
2354 return ( theWrappedObject->highlightingColor());
2350 return ( theWrappedObject->highlightingColor());
2355 }
2351 }
2356
2352
2357 int PythonQtWrapper_QHexEdit::indexOf(QHexEdit* theWrappedObject, const QByteArray& ba, int from) const
2353 int PythonQtWrapper_QHexEdit::indexOf(QHexEdit* theWrappedObject, const QByteArray& ba, int from) const
2358 {
2354 {
2359 return ( theWrappedObject->indexOf(ba, from));
2355 return ( theWrappedObject->indexOf(ba, from));
2360 }
2356 }
2361
2357
2362 void PythonQtWrapper_QHexEdit::insert(QHexEdit* theWrappedObject, int i, char ch)
2358 void PythonQtWrapper_QHexEdit::insert(QHexEdit* theWrappedObject, int i, char ch)
2363 {
2359 {
2364 ( theWrappedObject->insert(i, ch));
2360 ( theWrappedObject->insert(i, ch));
2365 }
2361 }
2366
2362
2367 void PythonQtWrapper_QHexEdit::insert(QHexEdit* theWrappedObject, int i, const QByteArray& ba)
2363 void PythonQtWrapper_QHexEdit::insert(QHexEdit* theWrappedObject, int i, const QByteArray& ba)
2368 {
2364 {
2369 ( theWrappedObject->insert(i, ba));
2365 ( theWrappedObject->insert(i, ba));
2370 }
2366 }
2371
2367
2372 bool PythonQtWrapper_QHexEdit::isReadOnly(QHexEdit* theWrappedObject)
2368 bool PythonQtWrapper_QHexEdit::isReadOnly(QHexEdit* theWrappedObject)
2373 {
2369 {
2374 return ( theWrappedObject->isReadOnly());
2370 return ( theWrappedObject->isReadOnly());
2375 }
2371 }
2376
2372
2377 int PythonQtWrapper_QHexEdit::lastIndexOf(QHexEdit* theWrappedObject, const QByteArray& ba, int from) const
2373 int PythonQtWrapper_QHexEdit::lastIndexOf(QHexEdit* theWrappedObject, const QByteArray& ba, int from) const
2378 {
2374 {
2379 return ( theWrappedObject->lastIndexOf(ba, from));
2375 return ( theWrappedObject->lastIndexOf(ba, from));
2380 }
2376 }
2381
2377
2382 bool PythonQtWrapper_QHexEdit::overwriteMode(QHexEdit* theWrappedObject)
2378 bool PythonQtWrapper_QHexEdit::overwriteMode(QHexEdit* theWrappedObject)
2383 {
2379 {
2384 return ( theWrappedObject->overwriteMode());
2380 return ( theWrappedObject->overwriteMode());
2385 }
2381 }
2386
2382
2387 void PythonQtWrapper_QHexEdit::remove(QHexEdit* theWrappedObject, int pos, int len)
2383 void PythonQtWrapper_QHexEdit::remove(QHexEdit* theWrappedObject, int pos, int len)
2388 {
2384 {
2389 ( theWrappedObject->remove(pos, len));
2385 ( theWrappedObject->remove(pos, len));
2390 }
2386 }
2391
2387
2392 void PythonQtWrapper_QHexEdit::replace(QHexEdit* theWrappedObject, int pos, int len, const QByteArray& after)
2388 void PythonQtWrapper_QHexEdit::replace(QHexEdit* theWrappedObject, int pos, int len, const QByteArray& after)
2393 {
2389 {
2394 ( theWrappedObject->replace(pos, len, after));
2390 ( theWrappedObject->replace(pos, len, after));
2395 }
2391 }
2396
2392
2397 void PythonQtWrapper_QHexEdit::resetSelection(QHexEdit* theWrappedObject)
2393 void PythonQtWrapper_QHexEdit::resetSelection(QHexEdit* theWrappedObject)
2398 {
2394 {
2399 ( theWrappedObject->resetSelection());
2395 ( theWrappedObject->resetSelection());
2400 }
2396 }
2401
2397
2402 void PythonQtWrapper_QHexEdit::resetSelection(QHexEdit* theWrappedObject, int pos)
2398 void PythonQtWrapper_QHexEdit::resetSelection(QHexEdit* theWrappedObject, int pos)
2403 {
2399 {
2404 ( theWrappedObject->resetSelection(pos));
2400 ( theWrappedObject->resetSelection(pos));
2405 }
2401 }
2406
2402
2407 QColor PythonQtWrapper_QHexEdit::selectionColor(QHexEdit* theWrappedObject)
2403 QColor PythonQtWrapper_QHexEdit::selectionColor(QHexEdit* theWrappedObject)
2408 {
2404 {
2409 return ( theWrappedObject->selectionColor());
2405 return ( theWrappedObject->selectionColor());
2410 }
2406 }
2411
2407
2412 QString PythonQtWrapper_QHexEdit::selectionToReadableString(QHexEdit* theWrappedObject)
2408 QString PythonQtWrapper_QHexEdit::selectionToReadableString(QHexEdit* theWrappedObject)
2413 {
2409 {
2414 return ( theWrappedObject->selectionToReadableString());
2410 return ( theWrappedObject->selectionToReadableString());
2415 }
2411 }
2416
2412
2417 void PythonQtWrapper_QHexEdit::setAddressAreaColor(QHexEdit* theWrappedObject, const QColor& color)
2413 void PythonQtWrapper_QHexEdit::setAddressAreaColor(QHexEdit* theWrappedObject, const QColor& color)
2418 {
2414 {
2419 ( theWrappedObject->setAddressAreaColor(color));
2415 ( theWrappedObject->setAddressAreaColor(color));
2420 }
2416 }
2421
2417
2422 void PythonQtWrapper_QHexEdit::setAddressOffset(QHexEdit* theWrappedObject, int offset)
2418 void PythonQtWrapper_QHexEdit::setAddressOffset(QHexEdit* theWrappedObject, int offset)
2423 {
2419 {
2424 ( theWrappedObject->setAddressOffset(offset));
2420 ( theWrappedObject->setAddressOffset(offset));
2425 }
2421 }
2426
2422
2427 void PythonQtWrapper_QHexEdit::setCursorPosition(QHexEdit* theWrappedObject, int cusorPos)
2423 void PythonQtWrapper_QHexEdit::setCursorPosition(QHexEdit* theWrappedObject, int cusorPos)
2428 {
2424 {
2429 ( theWrappedObject->setCursorPosition(cusorPos));
2425 ( theWrappedObject->setCursorPosition(cusorPos));
2430 }
2426 }
2431
2427
2432 void PythonQtWrapper_QHexEdit::setData(QHexEdit* theWrappedObject, const QByteArray& data)
2428 void PythonQtWrapper_QHexEdit::setData(QHexEdit* theWrappedObject, const QByteArray& data)
2433 {
2429 {
2434 ( theWrappedObject->setData(data));
2430 ( theWrappedObject->setData(data));
2435 }
2431 }
2436
2432
2437 void PythonQtWrapper_QHexEdit::setFont(QHexEdit* theWrappedObject, const QFont& arg__1)
2433 void PythonQtWrapper_QHexEdit::setFont(QHexEdit* theWrappedObject, const QFont& arg__1)
2438 {
2434 {
2439 ( theWrappedObject->setFont(arg__1));
2435 ( theWrappedObject->setFont(arg__1));
2440 }
2436 }
2441
2437
2442 void PythonQtWrapper_QHexEdit::setHighlightingColor(QHexEdit* theWrappedObject, const QColor& color)
2438 void PythonQtWrapper_QHexEdit::setHighlightingColor(QHexEdit* theWrappedObject, const QColor& color)
2443 {
2439 {
2444 ( theWrappedObject->setHighlightingColor(color));
2440 ( theWrappedObject->setHighlightingColor(color));
2445 }
2441 }
2446
2442
2447 void PythonQtWrapper_QHexEdit::setOverwriteMode(QHexEdit* theWrappedObject, bool arg__1)
2443 void PythonQtWrapper_QHexEdit::setOverwriteMode(QHexEdit* theWrappedObject, bool arg__1)
2448 {
2444 {
2449 ( theWrappedObject->setOverwriteMode(arg__1));
2445 ( theWrappedObject->setOverwriteMode(arg__1));
2450 }
2446 }
2451
2447
2452 void PythonQtWrapper_QHexEdit::setReadOnly(QHexEdit* theWrappedObject, bool arg__1)
2448 void PythonQtWrapper_QHexEdit::setReadOnly(QHexEdit* theWrappedObject, bool arg__1)
2453 {
2449 {
2454 ( theWrappedObject->setReadOnly(arg__1));
2450 ( theWrappedObject->setReadOnly(arg__1));
2455 }
2451 }
2456
2452
2457 void PythonQtWrapper_QHexEdit::setSelection(QHexEdit* theWrappedObject, int pos)
2453 void PythonQtWrapper_QHexEdit::setSelection(QHexEdit* theWrappedObject, int pos)
2458 {
2454 {
2459 ( theWrappedObject->setSelection(pos));
2455 ( theWrappedObject->setSelection(pos));
2460 }
2456 }
2461
2457
2462 void PythonQtWrapper_QHexEdit::setSelectionColor(QHexEdit* theWrappedObject, const QColor& color)
2458 void PythonQtWrapper_QHexEdit::setSelectionColor(QHexEdit* theWrappedObject, const QColor& color)
2463 {
2459 {
2464 ( theWrappedObject->setSelectionColor(color));
2460 ( theWrappedObject->setSelectionColor(color));
2465 }
2461 }
2466
2462
2467 QString PythonQtWrapper_QHexEdit::toReadableString(QHexEdit* theWrappedObject)
2463 QString PythonQtWrapper_QHexEdit::toReadableString(QHexEdit* theWrappedObject)
2468 {
2464 {
2469 return ( theWrappedObject->toReadableString());
2465 return ( theWrappedObject->toReadableString());
2470 }
2466 }
2471
2467
2472
2468
2473
2469
2474 PythonQtShell_QHexSpinBox::~PythonQtShell_QHexSpinBox() {
2470 PythonQtShell_QHexSpinBox::~PythonQtShell_QHexSpinBox() {
2475 PythonQtPrivate* priv = PythonQt::priv();
2471 PythonQtPrivate* priv = PythonQt::priv();
2476 if (priv) { priv->shellClassDeleted(this); }
2472 if (priv) { priv->shellClassDeleted(this); }
2477 }
2473 }
2478 void PythonQtShell_QHexSpinBox::actionEvent(QActionEvent* arg__1)
2474 void PythonQtShell_QHexSpinBox::actionEvent(QActionEvent* arg__1)
2479 {
2475 {
2480 if (_wrapper) {
2476 if (_wrapper) {
2481 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "actionEvent");
2477 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "actionEvent");
2482 PyErr_Clear();
2478 PyErr_Clear();
2483 if (obj && !PythonQtSlotFunction_Check(obj)) {
2479 if (obj && !PythonQtSlotFunction_Check(obj)) {
2484 static const char* argumentList[] ={"" , "QActionEvent*"};
2480 static const char* argumentList[] ={"" , "QActionEvent*"};
2485 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2481 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2486 void* args[2] = {NULL, (void*)&arg__1};
2482 void* args[2] = {NULL, (void*)&arg__1};
2487 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2483 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2488 if (result) { Py_DECREF(result); }
2484 if (result) { Py_DECREF(result); }
2489 Py_DECREF(obj);
2485 Py_DECREF(obj);
2490 return;
2486 return;
2491 }
2487 }
2492 }
2488 }
2493 QHexSpinBox::actionEvent(arg__1);
2489 QHexSpinBox::actionEvent(arg__1);
2494 }
2490 }
2495 void PythonQtShell_QHexSpinBox::changeEvent(QEvent* event)
2491 void PythonQtShell_QHexSpinBox::changeEvent(QEvent* event)
2496 {
2492 {
2497 if (_wrapper) {
2493 if (_wrapper) {
2498 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "changeEvent");
2494 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "changeEvent");
2499 PyErr_Clear();
2495 PyErr_Clear();
2500 if (obj && !PythonQtSlotFunction_Check(obj)) {
2496 if (obj && !PythonQtSlotFunction_Check(obj)) {
2501 static const char* argumentList[] ={"" , "QEvent*"};
2497 static const char* argumentList[] ={"" , "QEvent*"};
2502 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2498 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2503 void* args[2] = {NULL, (void*)&event};
2499 void* args[2] = {NULL, (void*)&event};
2504 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2500 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2505 if (result) { Py_DECREF(result); }
2501 if (result) { Py_DECREF(result); }
2506 Py_DECREF(obj);
2502 Py_DECREF(obj);
2507 return;
2503 return;
2508 }
2504 }
2509 }
2505 }
2510 QHexSpinBox::changeEvent(event);
2506 QHexSpinBox::changeEvent(event);
2511 }
2507 }
2512 void PythonQtShell_QHexSpinBox::childEvent(QChildEvent* arg__1)
2508 void PythonQtShell_QHexSpinBox::childEvent(QChildEvent* arg__1)
2513 {
2509 {
2514 if (_wrapper) {
2510 if (_wrapper) {
2515 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "childEvent");
2511 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "childEvent");
2516 PyErr_Clear();
2512 PyErr_Clear();
2517 if (obj && !PythonQtSlotFunction_Check(obj)) {
2513 if (obj && !PythonQtSlotFunction_Check(obj)) {
2518 static const char* argumentList[] ={"" , "QChildEvent*"};
2514 static const char* argumentList[] ={"" , "QChildEvent*"};
2519 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2515 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2520 void* args[2] = {NULL, (void*)&arg__1};
2516 void* args[2] = {NULL, (void*)&arg__1};
2521 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2517 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2522 if (result) { Py_DECREF(result); }
2518 if (result) { Py_DECREF(result); }
2523 Py_DECREF(obj);
2519 Py_DECREF(obj);
2524 return;
2520 return;
2525 }
2521 }
2526 }
2522 }
2527 QHexSpinBox::childEvent(arg__1);
2523 QHexSpinBox::childEvent(arg__1);
2528 }
2524 }
2529 void PythonQtShell_QHexSpinBox::clear()
2525 void PythonQtShell_QHexSpinBox::clear()
2530 {
2526 {
2531 if (_wrapper) {
2527 if (_wrapper) {
2532 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "clear");
2528 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "clear");
2533 PyErr_Clear();
2529 PyErr_Clear();
2534 if (obj && !PythonQtSlotFunction_Check(obj)) {
2530 if (obj && !PythonQtSlotFunction_Check(obj)) {
2535 static const char* argumentList[] ={""};
2531 static const char* argumentList[] ={""};
2536 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
2532 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
2537 void* args[1] = {NULL};
2533 void* args[1] = {NULL};
2538 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2534 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2539 if (result) { Py_DECREF(result); }
2535 if (result) { Py_DECREF(result); }
2540 Py_DECREF(obj);
2536 Py_DECREF(obj);
2541 return;
2537 return;
2542 }
2538 }
2543 }
2539 }
2544 QHexSpinBox::clear();
2540 QHexSpinBox::clear();
2545 }
2541 }
2546 void PythonQtShell_QHexSpinBox::closeEvent(QCloseEvent* event)
2542 void PythonQtShell_QHexSpinBox::closeEvent(QCloseEvent* event)
2547 {
2543 {
2548 if (_wrapper) {
2544 if (_wrapper) {
2549 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "closeEvent");
2545 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "closeEvent");
2550 PyErr_Clear();
2546 PyErr_Clear();
2551 if (obj && !PythonQtSlotFunction_Check(obj)) {
2547 if (obj && !PythonQtSlotFunction_Check(obj)) {
2552 static const char* argumentList[] ={"" , "QCloseEvent*"};
2548 static const char* argumentList[] ={"" , "QCloseEvent*"};
2553 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2549 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2554 void* args[2] = {NULL, (void*)&event};
2550 void* args[2] = {NULL, (void*)&event};
2555 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2551 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2556 if (result) { Py_DECREF(result); }
2552 if (result) { Py_DECREF(result); }
2557 Py_DECREF(obj);
2553 Py_DECREF(obj);
2558 return;
2554 return;
2559 }
2555 }
2560 }
2556 }
2561 QHexSpinBox::closeEvent(event);
2557 QHexSpinBox::closeEvent(event);
2562 }
2558 }
2563 void PythonQtShell_QHexSpinBox::contextMenuEvent(QContextMenuEvent* event)
2559 void PythonQtShell_QHexSpinBox::contextMenuEvent(QContextMenuEvent* event)
2564 {
2560 {
2565 if (_wrapper) {
2561 if (_wrapper) {
2566 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "contextMenuEvent");
2562 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "contextMenuEvent");
2567 PyErr_Clear();
2563 PyErr_Clear();
2568 if (obj && !PythonQtSlotFunction_Check(obj)) {
2564 if (obj && !PythonQtSlotFunction_Check(obj)) {
2569 static const char* argumentList[] ={"" , "QContextMenuEvent*"};
2565 static const char* argumentList[] ={"" , "QContextMenuEvent*"};
2570 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2566 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2571 void* args[2] = {NULL, (void*)&event};
2567 void* args[2] = {NULL, (void*)&event};
2572 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2568 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2573 if (result) { Py_DECREF(result); }
2569 if (result) { Py_DECREF(result); }
2574 Py_DECREF(obj);
2570 Py_DECREF(obj);
2575 return;
2571 return;
2576 }
2572 }
2577 }
2573 }
2578 QHexSpinBox::contextMenuEvent(event);
2574 QHexSpinBox::contextMenuEvent(event);
2579 }
2575 }
2580 void PythonQtShell_QHexSpinBox::customEvent(QEvent* arg__1)
2576 void PythonQtShell_QHexSpinBox::customEvent(QEvent* arg__1)
2581 {
2577 {
2582 if (_wrapper) {
2578 if (_wrapper) {
2583 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "customEvent");
2579 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "customEvent");
2584 PyErr_Clear();
2580 PyErr_Clear();
2585 if (obj && !PythonQtSlotFunction_Check(obj)) {
2581 if (obj && !PythonQtSlotFunction_Check(obj)) {
2586 static const char* argumentList[] ={"" , "QEvent*"};
2582 static const char* argumentList[] ={"" , "QEvent*"};
2587 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2583 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2588 void* args[2] = {NULL, (void*)&arg__1};
2584 void* args[2] = {NULL, (void*)&arg__1};
2589 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2585 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2590 if (result) { Py_DECREF(result); }
2586 if (result) { Py_DECREF(result); }
2591 Py_DECREF(obj);
2587 Py_DECREF(obj);
2592 return;
2588 return;
2593 }
2589 }
2594 }
2590 }
2595 QHexSpinBox::customEvent(arg__1);
2591 QHexSpinBox::customEvent(arg__1);
2596 }
2592 }
2597 int PythonQtShell_QHexSpinBox::devType() const
2593 int PythonQtShell_QHexSpinBox::devType() const
2598 {
2594 {
2599 if (_wrapper) {
2595 if (_wrapper) {
2600 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "devType");
2596 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "devType");
2601 PyErr_Clear();
2597 PyErr_Clear();
2602 if (obj && !PythonQtSlotFunction_Check(obj)) {
2598 if (obj && !PythonQtSlotFunction_Check(obj)) {
2603 static const char* argumentList[] ={"int"};
2599 static const char* argumentList[] ={"int"};
2604 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
2600 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
2605 int returnValue;
2601 int returnValue;
2606 void* args[1] = {NULL};
2602 void* args[1] = {NULL};
2607 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2603 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2608 if (result) {
2604 if (result) {
2609 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
2605 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
2610 if (args[0]!=&returnValue) {
2606 if (args[0]!=&returnValue) {
2611 if (args[0]==NULL) {
2607 if (args[0]==NULL) {
2612 PythonQt::priv()->handleVirtualOverloadReturnError("devType", methodInfo, result);
2608 PythonQt::priv()->handleVirtualOverloadReturnError("devType", methodInfo, result);
2613 } else {
2609 } else {
2614 returnValue = *((int*)args[0]);
2610 returnValue = *((int*)args[0]);
2615 }
2611 }
2616 }
2612 }
2617 }
2613 }
2618 if (result) { Py_DECREF(result); }
2614 if (result) { Py_DECREF(result); }
2619 Py_DECREF(obj);
2615 Py_DECREF(obj);
2620 return returnValue;
2616 return returnValue;
2621 }
2617 }
2622 }
2618 }
2623 return QHexSpinBox::devType();
2619 return QHexSpinBox::devType();
2624 }
2620 }
2625 void PythonQtShell_QHexSpinBox::dragEnterEvent(QDragEnterEvent* arg__1)
2621 void PythonQtShell_QHexSpinBox::dragEnterEvent(QDragEnterEvent* arg__1)
2626 {
2622 {
2627 if (_wrapper) {
2623 if (_wrapper) {
2628 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragEnterEvent");
2624 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragEnterEvent");
2629 PyErr_Clear();
2625 PyErr_Clear();
2630 if (obj && !PythonQtSlotFunction_Check(obj)) {
2626 if (obj && !PythonQtSlotFunction_Check(obj)) {
2631 static const char* argumentList[] ={"" , "QDragEnterEvent*"};
2627 static const char* argumentList[] ={"" , "QDragEnterEvent*"};
2632 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2628 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2633 void* args[2] = {NULL, (void*)&arg__1};
2629 void* args[2] = {NULL, (void*)&arg__1};
2634 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2630 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2635 if (result) { Py_DECREF(result); }
2631 if (result) { Py_DECREF(result); }
2636 Py_DECREF(obj);
2632 Py_DECREF(obj);
2637 return;
2633 return;
2638 }
2634 }
2639 }
2635 }
2640 QHexSpinBox::dragEnterEvent(arg__1);
2636 QHexSpinBox::dragEnterEvent(arg__1);
2641 }
2637 }
2642 void PythonQtShell_QHexSpinBox::dragLeaveEvent(QDragLeaveEvent* arg__1)
2638 void PythonQtShell_QHexSpinBox::dragLeaveEvent(QDragLeaveEvent* arg__1)
2643 {
2639 {
2644 if (_wrapper) {
2640 if (_wrapper) {
2645 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragLeaveEvent");
2641 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragLeaveEvent");
2646 PyErr_Clear();
2642 PyErr_Clear();
2647 if (obj && !PythonQtSlotFunction_Check(obj)) {
2643 if (obj && !PythonQtSlotFunction_Check(obj)) {
2648 static const char* argumentList[] ={"" , "QDragLeaveEvent*"};
2644 static const char* argumentList[] ={"" , "QDragLeaveEvent*"};
2649 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2645 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2650 void* args[2] = {NULL, (void*)&arg__1};
2646 void* args[2] = {NULL, (void*)&arg__1};
2651 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2647 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2652 if (result) { Py_DECREF(result); }
2648 if (result) { Py_DECREF(result); }
2653 Py_DECREF(obj);
2649 Py_DECREF(obj);
2654 return;
2650 return;
2655 }
2651 }
2656 }
2652 }
2657 QHexSpinBox::dragLeaveEvent(arg__1);
2653 QHexSpinBox::dragLeaveEvent(arg__1);
2658 }
2654 }
2659 void PythonQtShell_QHexSpinBox::dragMoveEvent(QDragMoveEvent* arg__1)
2655 void PythonQtShell_QHexSpinBox::dragMoveEvent(QDragMoveEvent* arg__1)
2660 {
2656 {
2661 if (_wrapper) {
2657 if (_wrapper) {
2662 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragMoveEvent");
2658 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragMoveEvent");
2663 PyErr_Clear();
2659 PyErr_Clear();
2664 if (obj && !PythonQtSlotFunction_Check(obj)) {
2660 if (obj && !PythonQtSlotFunction_Check(obj)) {
2665 static const char* argumentList[] ={"" , "QDragMoveEvent*"};
2661 static const char* argumentList[] ={"" , "QDragMoveEvent*"};
2666 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2662 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2667 void* args[2] = {NULL, (void*)&arg__1};
2663 void* args[2] = {NULL, (void*)&arg__1};
2668 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2664 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2669 if (result) { Py_DECREF(result); }
2665 if (result) { Py_DECREF(result); }
2670 Py_DECREF(obj);
2666 Py_DECREF(obj);
2671 return;
2667 return;
2672 }
2668 }
2673 }
2669 }
2674 QHexSpinBox::dragMoveEvent(arg__1);
2670 QHexSpinBox::dragMoveEvent(arg__1);
2675 }
2671 }
2676 void PythonQtShell_QHexSpinBox::dropEvent(QDropEvent* arg__1)
2672 void PythonQtShell_QHexSpinBox::dropEvent(QDropEvent* arg__1)
2677 {
2673 {
2678 if (_wrapper) {
2674 if (_wrapper) {
2679 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dropEvent");
2675 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dropEvent");
2680 PyErr_Clear();
2676 PyErr_Clear();
2681 if (obj && !PythonQtSlotFunction_Check(obj)) {
2677 if (obj && !PythonQtSlotFunction_Check(obj)) {
2682 static const char* argumentList[] ={"" , "QDropEvent*"};
2678 static const char* argumentList[] ={"" , "QDropEvent*"};
2683 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2679 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2684 void* args[2] = {NULL, (void*)&arg__1};
2680 void* args[2] = {NULL, (void*)&arg__1};
2685 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2681 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2686 if (result) { Py_DECREF(result); }
2682 if (result) { Py_DECREF(result); }
2687 Py_DECREF(obj);
2683 Py_DECREF(obj);
2688 return;
2684 return;
2689 }
2685 }
2690 }
2686 }
2691 QHexSpinBox::dropEvent(arg__1);
2687 QHexSpinBox::dropEvent(arg__1);
2692 }
2688 }
2693 void PythonQtShell_QHexSpinBox::enterEvent(QEvent* arg__1)
2689 void PythonQtShell_QHexSpinBox::enterEvent(QEvent* arg__1)
2694 {
2690 {
2695 if (_wrapper) {
2691 if (_wrapper) {
2696 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "enterEvent");
2692 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "enterEvent");
2697 PyErr_Clear();
2693 PyErr_Clear();
2698 if (obj && !PythonQtSlotFunction_Check(obj)) {
2694 if (obj && !PythonQtSlotFunction_Check(obj)) {
2699 static const char* argumentList[] ={"" , "QEvent*"};
2695 static const char* argumentList[] ={"" , "QEvent*"};
2700 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2696 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2701 void* args[2] = {NULL, (void*)&arg__1};
2697 void* args[2] = {NULL, (void*)&arg__1};
2702 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2698 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2703 if (result) { Py_DECREF(result); }
2699 if (result) { Py_DECREF(result); }
2704 Py_DECREF(obj);
2700 Py_DECREF(obj);
2705 return;
2701 return;
2706 }
2702 }
2707 }
2703 }
2708 QHexSpinBox::enterEvent(arg__1);
2704 QHexSpinBox::enterEvent(arg__1);
2709 }
2705 }
2710 bool PythonQtShell_QHexSpinBox::event(QEvent* event)
2706 bool PythonQtShell_QHexSpinBox::event(QEvent* event)
2711 {
2707 {
2712 if (_wrapper) {
2708 if (_wrapper) {
2713 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "event");
2709 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "event");
2714 PyErr_Clear();
2710 PyErr_Clear();
2715 if (obj && !PythonQtSlotFunction_Check(obj)) {
2711 if (obj && !PythonQtSlotFunction_Check(obj)) {
2716 static const char* argumentList[] ={"bool" , "QEvent*"};
2712 static const char* argumentList[] ={"bool" , "QEvent*"};
2717 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2713 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2718 bool returnValue;
2714 bool returnValue;
2719 void* args[2] = {NULL, (void*)&event};
2715 void* args[2] = {NULL, (void*)&event};
2720 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2716 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2721 if (result) {
2717 if (result) {
2722 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
2718 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
2723 if (args[0]!=&returnValue) {
2719 if (args[0]!=&returnValue) {
2724 if (args[0]==NULL) {
2720 if (args[0]==NULL) {
2725 PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
2721 PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
2726 } else {
2722 } else {
2727 returnValue = *((bool*)args[0]);
2723 returnValue = *((bool*)args[0]);
2728 }
2724 }
2729 }
2725 }
2730 }
2726 }
2731 if (result) { Py_DECREF(result); }
2727 if (result) { Py_DECREF(result); }
2732 Py_DECREF(obj);
2728 Py_DECREF(obj);
2733 return returnValue;
2729 return returnValue;
2734 }
2730 }
2735 }
2731 }
2736 return QHexSpinBox::event(event);
2732 return QHexSpinBox::event(event);
2737 }
2733 }
2738 bool PythonQtShell_QHexSpinBox::eventFilter(QObject* arg__1, QEvent* arg__2)
2734 bool PythonQtShell_QHexSpinBox::eventFilter(QObject* arg__1, QEvent* arg__2)
2739 {
2735 {
2740 if (_wrapper) {
2736 if (_wrapper) {
2741 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "eventFilter");
2737 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "eventFilter");
2742 PyErr_Clear();
2738 PyErr_Clear();
2743 if (obj && !PythonQtSlotFunction_Check(obj)) {
2739 if (obj && !PythonQtSlotFunction_Check(obj)) {
2744 static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
2740 static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
2745 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
2741 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
2746 bool returnValue;
2742 bool returnValue;
2747 void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2};
2743 void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2};
2748 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2744 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2749 if (result) {
2745 if (result) {
2750 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
2746 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
2751 if (args[0]!=&returnValue) {
2747 if (args[0]!=&returnValue) {
2752 if (args[0]==NULL) {
2748 if (args[0]==NULL) {
2753 PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
2749 PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
2754 } else {
2750 } else {
2755 returnValue = *((bool*)args[0]);
2751 returnValue = *((bool*)args[0]);
2756 }
2752 }
2757 }
2753 }
2758 }
2754 }
2759 if (result) { Py_DECREF(result); }
2755 if (result) { Py_DECREF(result); }
2760 Py_DECREF(obj);
2756 Py_DECREF(obj);
2761 return returnValue;
2757 return returnValue;
2762 }
2758 }
2763 }
2759 }
2764 return QHexSpinBox::eventFilter(arg__1, arg__2);
2760 return QHexSpinBox::eventFilter(arg__1, arg__2);
2765 }
2761 }
2766 void PythonQtShell_QHexSpinBox::fixup(QString& str) const
2762 void PythonQtShell_QHexSpinBox::fixup(QString& str) const
2767 {
2763 {
2768 if (_wrapper) {
2764 if (_wrapper) {
2769 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "fixup");
2765 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "fixup");
2770 PyErr_Clear();
2766 PyErr_Clear();
2771 if (obj && !PythonQtSlotFunction_Check(obj)) {
2767 if (obj && !PythonQtSlotFunction_Check(obj)) {
2772 static const char* argumentList[] ={"" , "QString&"};
2768 static const char* argumentList[] ={"" , "QString&"};
2773 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2769 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2774 void* args[2] = {NULL, (void*)&str};
2770 void* args[2] = {NULL, (void*)&str};
2775 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2771 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2776 if (result) { Py_DECREF(result); }
2772 if (result) { Py_DECREF(result); }
2777 Py_DECREF(obj);
2773 Py_DECREF(obj);
2778 return;
2774 return;
2779 }
2775 }
2780 }
2776 }
2781 QHexSpinBox::fixup(str);
2777 QHexSpinBox::fixup(str);
2782 }
2778 }
2783 void PythonQtShell_QHexSpinBox::focusInEvent(QFocusEvent* event)
2779 void PythonQtShell_QHexSpinBox::focusInEvent(QFocusEvent* event)
2784 {
2780 {
2785 if (_wrapper) {
2781 if (_wrapper) {
2786 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusInEvent");
2782 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusInEvent");
2787 PyErr_Clear();
2783 PyErr_Clear();
2788 if (obj && !PythonQtSlotFunction_Check(obj)) {
2784 if (obj && !PythonQtSlotFunction_Check(obj)) {
2789 static const char* argumentList[] ={"" , "QFocusEvent*"};
2785 static const char* argumentList[] ={"" , "QFocusEvent*"};
2790 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2786 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2791 void* args[2] = {NULL, (void*)&event};
2787 void* args[2] = {NULL, (void*)&event};
2792 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2788 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2793 if (result) { Py_DECREF(result); }
2789 if (result) { Py_DECREF(result); }
2794 Py_DECREF(obj);
2790 Py_DECREF(obj);
2795 return;
2791 return;
2796 }
2792 }
2797 }
2793 }
2798 QHexSpinBox::focusInEvent(event);
2794 QHexSpinBox::focusInEvent(event);
2799 }
2795 }
2800 bool PythonQtShell_QHexSpinBox::focusNextPrevChild(bool next)
2796 bool PythonQtShell_QHexSpinBox::focusNextPrevChild(bool next)
2801 {
2797 {
2802 if (_wrapper) {
2798 if (_wrapper) {
2803 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusNextPrevChild");
2799 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusNextPrevChild");
2804 PyErr_Clear();
2800 PyErr_Clear();
2805 if (obj && !PythonQtSlotFunction_Check(obj)) {
2801 if (obj && !PythonQtSlotFunction_Check(obj)) {
2806 static const char* argumentList[] ={"bool" , "bool"};
2802 static const char* argumentList[] ={"bool" , "bool"};
2807 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2803 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2808 bool returnValue;
2804 bool returnValue;
2809 void* args[2] = {NULL, (void*)&next};
2805 void* args[2] = {NULL, (void*)&next};
2810 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2806 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2811 if (result) {
2807 if (result) {
2812 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
2808 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
2813 if (args[0]!=&returnValue) {
2809 if (args[0]!=&returnValue) {
2814 if (args[0]==NULL) {
2810 if (args[0]==NULL) {
2815 PythonQt::priv()->handleVirtualOverloadReturnError("focusNextPrevChild", methodInfo, result);
2811 PythonQt::priv()->handleVirtualOverloadReturnError("focusNextPrevChild", methodInfo, result);
2816 } else {
2812 } else {
2817 returnValue = *((bool*)args[0]);
2813 returnValue = *((bool*)args[0]);
2818 }
2814 }
2819 }
2815 }
2820 }
2816 }
2821 if (result) { Py_DECREF(result); }
2817 if (result) { Py_DECREF(result); }
2822 Py_DECREF(obj);
2818 Py_DECREF(obj);
2823 return returnValue;
2819 return returnValue;
2824 }
2820 }
2825 }
2821 }
2826 return QHexSpinBox::focusNextPrevChild(next);
2822 return QHexSpinBox::focusNextPrevChild(next);
2827 }
2823 }
2828 void PythonQtShell_QHexSpinBox::focusOutEvent(QFocusEvent* event)
2824 void PythonQtShell_QHexSpinBox::focusOutEvent(QFocusEvent* event)
2829 {
2825 {
2830 if (_wrapper) {
2826 if (_wrapper) {
2831 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusOutEvent");
2827 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusOutEvent");
2832 PyErr_Clear();
2828 PyErr_Clear();
2833 if (obj && !PythonQtSlotFunction_Check(obj)) {
2829 if (obj && !PythonQtSlotFunction_Check(obj)) {
2834 static const char* argumentList[] ={"" , "QFocusEvent*"};
2830 static const char* argumentList[] ={"" , "QFocusEvent*"};
2835 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2831 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2836 void* args[2] = {NULL, (void*)&event};
2832 void* args[2] = {NULL, (void*)&event};
2837 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2833 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2838 if (result) { Py_DECREF(result); }
2834 if (result) { Py_DECREF(result); }
2839 Py_DECREF(obj);
2835 Py_DECREF(obj);
2840 return;
2836 return;
2841 }
2837 }
2842 }
2838 }
2843 QHexSpinBox::focusOutEvent(event);
2839 QHexSpinBox::focusOutEvent(event);
2844 }
2840 }
2845 bool PythonQtShell_QHexSpinBox::hasHeightForWidth() const
2841 bool PythonQtShell_QHexSpinBox::hasHeightForWidth() const
2846 {
2842 {
2847 if (_wrapper) {
2843 if (_wrapper) {
2848 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hasHeightForWidth");
2844 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hasHeightForWidth");
2849 PyErr_Clear();
2845 PyErr_Clear();
2850 if (obj && !PythonQtSlotFunction_Check(obj)) {
2846 if (obj && !PythonQtSlotFunction_Check(obj)) {
2851 static const char* argumentList[] ={"bool"};
2847 static const char* argumentList[] ={"bool"};
2852 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
2848 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
2853 bool returnValue;
2849 bool returnValue;
2854 void* args[1] = {NULL};
2850 void* args[1] = {NULL};
2855 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2851 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2856 if (result) {
2852 if (result) {
2857 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
2853 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
2858 if (args[0]!=&returnValue) {
2854 if (args[0]!=&returnValue) {
2859 if (args[0]==NULL) {
2855 if (args[0]==NULL) {
2860 PythonQt::priv()->handleVirtualOverloadReturnError("hasHeightForWidth", methodInfo, result);
2856 PythonQt::priv()->handleVirtualOverloadReturnError("hasHeightForWidth", methodInfo, result);
2861 } else {
2857 } else {
2862 returnValue = *((bool*)args[0]);
2858 returnValue = *((bool*)args[0]);
2863 }
2859 }
2864 }
2860 }
2865 }
2861 }
2866 if (result) { Py_DECREF(result); }
2862 if (result) { Py_DECREF(result); }
2867 Py_DECREF(obj);
2863 Py_DECREF(obj);
2868 return returnValue;
2864 return returnValue;
2869 }
2865 }
2870 }
2866 }
2871 return QHexSpinBox::hasHeightForWidth();
2867 return QHexSpinBox::hasHeightForWidth();
2872 }
2868 }
2873 int PythonQtShell_QHexSpinBox::heightForWidth(int arg__1) const
2869 int PythonQtShell_QHexSpinBox::heightForWidth(int arg__1) const
2874 {
2870 {
2875 if (_wrapper) {
2871 if (_wrapper) {
2876 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "heightForWidth");
2872 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "heightForWidth");
2877 PyErr_Clear();
2873 PyErr_Clear();
2878 if (obj && !PythonQtSlotFunction_Check(obj)) {
2874 if (obj && !PythonQtSlotFunction_Check(obj)) {
2879 static const char* argumentList[] ={"int" , "int"};
2875 static const char* argumentList[] ={"int" , "int"};
2880 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2876 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2881 int returnValue;
2877 int returnValue;
2882 void* args[2] = {NULL, (void*)&arg__1};
2878 void* args[2] = {NULL, (void*)&arg__1};
2883 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2879 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2884 if (result) {
2880 if (result) {
2885 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
2881 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
2886 if (args[0]!=&returnValue) {
2882 if (args[0]!=&returnValue) {
2887 if (args[0]==NULL) {
2883 if (args[0]==NULL) {
2888 PythonQt::priv()->handleVirtualOverloadReturnError("heightForWidth", methodInfo, result);
2884 PythonQt::priv()->handleVirtualOverloadReturnError("heightForWidth", methodInfo, result);
2889 } else {
2885 } else {
2890 returnValue = *((int*)args[0]);
2886 returnValue = *((int*)args[0]);
2891 }
2887 }
2892 }
2888 }
2893 }
2889 }
2894 if (result) { Py_DECREF(result); }
2890 if (result) { Py_DECREF(result); }
2895 Py_DECREF(obj);
2891 Py_DECREF(obj);
2896 return returnValue;
2892 return returnValue;
2897 }
2893 }
2898 }
2894 }
2899 return QHexSpinBox::heightForWidth(arg__1);
2895 return QHexSpinBox::heightForWidth(arg__1);
2900 }
2896 }
2901 void PythonQtShell_QHexSpinBox::hideEvent(QHideEvent* event)
2897 void PythonQtShell_QHexSpinBox::hideEvent(QHideEvent* event)
2902 {
2898 {
2903 if (_wrapper) {
2899 if (_wrapper) {
2904 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hideEvent");
2900 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hideEvent");
2905 PyErr_Clear();
2901 PyErr_Clear();
2906 if (obj && !PythonQtSlotFunction_Check(obj)) {
2902 if (obj && !PythonQtSlotFunction_Check(obj)) {
2907 static const char* argumentList[] ={"" , "QHideEvent*"};
2903 static const char* argumentList[] ={"" , "QHideEvent*"};
2908 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2904 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2909 void* args[2] = {NULL, (void*)&event};
2905 void* args[2] = {NULL, (void*)&event};
2910 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2906 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2911 if (result) { Py_DECREF(result); }
2907 if (result) { Py_DECREF(result); }
2912 Py_DECREF(obj);
2908 Py_DECREF(obj);
2913 return;
2909 return;
2914 }
2910 }
2915 }
2911 }
2916 QHexSpinBox::hideEvent(event);
2912 QHexSpinBox::hideEvent(event);
2917 }
2913 }
2918 void PythonQtShell_QHexSpinBox::initPainter(QPainter* painter) const
2914 void PythonQtShell_QHexSpinBox::initPainter(QPainter* painter) const
2919 {
2915 {
2920 if (_wrapper) {
2916 if (_wrapper) {
2921 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "initPainter");
2917 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "initPainter");
2922 PyErr_Clear();
2918 PyErr_Clear();
2923 if (obj && !PythonQtSlotFunction_Check(obj)) {
2919 if (obj && !PythonQtSlotFunction_Check(obj)) {
2924 static const char* argumentList[] ={"" , "QPainter*"};
2920 static const char* argumentList[] ={"" , "QPainter*"};
2925 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2921 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2926 void* args[2] = {NULL, (void*)&painter};
2922 void* args[2] = {NULL, (void*)&painter};
2927 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2923 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2928 if (result) { Py_DECREF(result); }
2924 if (result) { Py_DECREF(result); }
2929 Py_DECREF(obj);
2925 Py_DECREF(obj);
2930 return;
2926 return;
2931 }
2927 }
2932 }
2928 }
2933 QHexSpinBox::initPainter(painter);
2929 QHexSpinBox::initPainter(painter);
2934 }
2930 }
2935 void PythonQtShell_QHexSpinBox::inputMethodEvent(QInputMethodEvent* arg__1)
2931 void PythonQtShell_QHexSpinBox::inputMethodEvent(QInputMethodEvent* arg__1)
2936 {
2932 {
2937 if (_wrapper) {
2933 if (_wrapper) {
2938 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodEvent");
2934 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodEvent");
2939 PyErr_Clear();
2935 PyErr_Clear();
2940 if (obj && !PythonQtSlotFunction_Check(obj)) {
2936 if (obj && !PythonQtSlotFunction_Check(obj)) {
2941 static const char* argumentList[] ={"" , "QInputMethodEvent*"};
2937 static const char* argumentList[] ={"" , "QInputMethodEvent*"};
2942 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2938 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2943 void* args[2] = {NULL, (void*)&arg__1};
2939 void* args[2] = {NULL, (void*)&arg__1};
2944 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2940 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2945 if (result) { Py_DECREF(result); }
2941 if (result) { Py_DECREF(result); }
2946 Py_DECREF(obj);
2942 Py_DECREF(obj);
2947 return;
2943 return;
2948 }
2944 }
2949 }
2945 }
2950 QHexSpinBox::inputMethodEvent(arg__1);
2946 QHexSpinBox::inputMethodEvent(arg__1);
2951 }
2947 }
2952 QVariant PythonQtShell_QHexSpinBox::inputMethodQuery(Qt::InputMethodQuery arg__1) const
2948 QVariant PythonQtShell_QHexSpinBox::inputMethodQuery(Qt::InputMethodQuery arg__1) const
2953 {
2949 {
2954 if (_wrapper) {
2950 if (_wrapper) {
2955 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodQuery");
2951 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodQuery");
2956 PyErr_Clear();
2952 PyErr_Clear();
2957 if (obj && !PythonQtSlotFunction_Check(obj)) {
2953 if (obj && !PythonQtSlotFunction_Check(obj)) {
2958 static const char* argumentList[] ={"QVariant" , "Qt::InputMethodQuery"};
2954 static const char* argumentList[] ={"QVariant" , "Qt::InputMethodQuery"};
2959 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2955 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2960 QVariant returnValue;
2956 QVariant returnValue;
2961 void* args[2] = {NULL, (void*)&arg__1};
2957 void* args[2] = {NULL, (void*)&arg__1};
2962 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2958 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2963 if (result) {
2959 if (result) {
2964 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
2960 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
2965 if (args[0]!=&returnValue) {
2961 if (args[0]!=&returnValue) {
2966 if (args[0]==NULL) {
2962 if (args[0]==NULL) {
2967 PythonQt::priv()->handleVirtualOverloadReturnError("inputMethodQuery", methodInfo, result);
2963 PythonQt::priv()->handleVirtualOverloadReturnError("inputMethodQuery", methodInfo, result);
2968 } else {
2964 } else {
2969 returnValue = *((QVariant*)args[0]);
2965 returnValue = *((QVariant*)args[0]);
2970 }
2966 }
2971 }
2967 }
2972 }
2968 }
2973 if (result) { Py_DECREF(result); }
2969 if (result) { Py_DECREF(result); }
2974 Py_DECREF(obj);
2970 Py_DECREF(obj);
2975 return returnValue;
2971 return returnValue;
2976 }
2972 }
2977 }
2973 }
2978 return QHexSpinBox::inputMethodQuery(arg__1);
2974 return QHexSpinBox::inputMethodQuery(arg__1);
2979 }
2975 }
2980 void PythonQtShell_QHexSpinBox::keyPressEvent(QKeyEvent* event)
2976 void PythonQtShell_QHexSpinBox::keyPressEvent(QKeyEvent* event)
2981 {
2977 {
2982 if (_wrapper) {
2978 if (_wrapper) {
2983 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyPressEvent");
2979 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyPressEvent");
2984 PyErr_Clear();
2980 PyErr_Clear();
2985 if (obj && !PythonQtSlotFunction_Check(obj)) {
2981 if (obj && !PythonQtSlotFunction_Check(obj)) {
2986 static const char* argumentList[] ={"" , "QKeyEvent*"};
2982 static const char* argumentList[] ={"" , "QKeyEvent*"};
2987 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2983 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
2988 void* args[2] = {NULL, (void*)&event};
2984 void* args[2] = {NULL, (void*)&event};
2989 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2985 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
2990 if (result) { Py_DECREF(result); }
2986 if (result) { Py_DECREF(result); }
2991 Py_DECREF(obj);
2987 Py_DECREF(obj);
2992 return;
2988 return;
2993 }
2989 }
2994 }
2990 }
2995 QHexSpinBox::keyPressEvent(event);
2991 QHexSpinBox::keyPressEvent(event);
2996 }
2992 }
2997 void PythonQtShell_QHexSpinBox::keyReleaseEvent(QKeyEvent* event)
2993 void PythonQtShell_QHexSpinBox::keyReleaseEvent(QKeyEvent* event)
2998 {
2994 {
2999 if (_wrapper) {
2995 if (_wrapper) {
3000 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyReleaseEvent");
2996 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyReleaseEvent");
3001 PyErr_Clear();
2997 PyErr_Clear();
3002 if (obj && !PythonQtSlotFunction_Check(obj)) {
2998 if (obj && !PythonQtSlotFunction_Check(obj)) {
3003 static const char* argumentList[] ={"" , "QKeyEvent*"};
2999 static const char* argumentList[] ={"" , "QKeyEvent*"};
3004 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3000 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3005 void* args[2] = {NULL, (void*)&event};
3001 void* args[2] = {NULL, (void*)&event};
3006 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3002 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3007 if (result) { Py_DECREF(result); }
3003 if (result) { Py_DECREF(result); }
3008 Py_DECREF(obj);
3004 Py_DECREF(obj);
3009 return;
3005 return;
3010 }
3006 }
3011 }
3007 }
3012 QHexSpinBox::keyReleaseEvent(event);
3008 QHexSpinBox::keyReleaseEvent(event);
3013 }
3009 }
3014 void PythonQtShell_QHexSpinBox::leaveEvent(QEvent* arg__1)
3010 void PythonQtShell_QHexSpinBox::leaveEvent(QEvent* arg__1)
3015 {
3011 {
3016 if (_wrapper) {
3012 if (_wrapper) {
3017 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "leaveEvent");
3013 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "leaveEvent");
3018 PyErr_Clear();
3014 PyErr_Clear();
3019 if (obj && !PythonQtSlotFunction_Check(obj)) {
3015 if (obj && !PythonQtSlotFunction_Check(obj)) {
3020 static const char* argumentList[] ={"" , "QEvent*"};
3016 static const char* argumentList[] ={"" , "QEvent*"};
3021 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3017 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3022 void* args[2] = {NULL, (void*)&arg__1};
3018 void* args[2] = {NULL, (void*)&arg__1};
3023 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3019 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3024 if (result) { Py_DECREF(result); }
3020 if (result) { Py_DECREF(result); }
3025 Py_DECREF(obj);
3021 Py_DECREF(obj);
3026 return;
3022 return;
3027 }
3023 }
3028 }
3024 }
3029 QHexSpinBox::leaveEvent(arg__1);
3025 QHexSpinBox::leaveEvent(arg__1);
3030 }
3026 }
3031 int PythonQtShell_QHexSpinBox::metric(QPaintDevice::PaintDeviceMetric arg__1) const
3027 int PythonQtShell_QHexSpinBox::metric(QPaintDevice::PaintDeviceMetric arg__1) const
3032 {
3028 {
3033 if (_wrapper) {
3029 if (_wrapper) {
3034 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "metric");
3030 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "metric");
3035 PyErr_Clear();
3031 PyErr_Clear();
3036 if (obj && !PythonQtSlotFunction_Check(obj)) {
3032 if (obj && !PythonQtSlotFunction_Check(obj)) {
3037 static const char* argumentList[] ={"int" , "QPaintDevice::PaintDeviceMetric"};
3033 static const char* argumentList[] ={"int" , "QPaintDevice::PaintDeviceMetric"};
3038 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3034 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3039 int returnValue;
3035 int returnValue;
3040 void* args[2] = {NULL, (void*)&arg__1};
3036 void* args[2] = {NULL, (void*)&arg__1};
3041 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3037 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3042 if (result) {
3038 if (result) {
3043 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3039 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3044 if (args[0]!=&returnValue) {
3040 if (args[0]!=&returnValue) {
3045 if (args[0]==NULL) {
3041 if (args[0]==NULL) {
3046 PythonQt::priv()->handleVirtualOverloadReturnError("metric", methodInfo, result);
3042 PythonQt::priv()->handleVirtualOverloadReturnError("metric", methodInfo, result);
3047 } else {
3043 } else {
3048 returnValue = *((int*)args[0]);
3044 returnValue = *((int*)args[0]);
3049 }
3045 }
3050 }
3046 }
3051 }
3047 }
3052 if (result) { Py_DECREF(result); }
3048 if (result) { Py_DECREF(result); }
3053 Py_DECREF(obj);
3049 Py_DECREF(obj);
3054 return returnValue;
3050 return returnValue;
3055 }
3051 }
3056 }
3052 }
3057 return QHexSpinBox::metric(arg__1);
3053 return QHexSpinBox::metric(arg__1);
3058 }
3054 }
3059 void PythonQtShell_QHexSpinBox::mouseDoubleClickEvent(QMouseEvent* arg__1)
3055 void PythonQtShell_QHexSpinBox::mouseDoubleClickEvent(QMouseEvent* arg__1)
3060 {
3056 {
3061 if (_wrapper) {
3057 if (_wrapper) {
3062 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseDoubleClickEvent");
3058 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseDoubleClickEvent");
3063 PyErr_Clear();
3059 PyErr_Clear();
3064 if (obj && !PythonQtSlotFunction_Check(obj)) {
3060 if (obj && !PythonQtSlotFunction_Check(obj)) {
3065 static const char* argumentList[] ={"" , "QMouseEvent*"};
3061 static const char* argumentList[] ={"" , "QMouseEvent*"};
3066 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3062 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3067 void* args[2] = {NULL, (void*)&arg__1};
3063 void* args[2] = {NULL, (void*)&arg__1};
3068 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3064 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3069 if (result) { Py_DECREF(result); }
3065 if (result) { Py_DECREF(result); }
3070 Py_DECREF(obj);
3066 Py_DECREF(obj);
3071 return;
3067 return;
3072 }
3068 }
3073 }
3069 }
3074 QHexSpinBox::mouseDoubleClickEvent(arg__1);
3070 QHexSpinBox::mouseDoubleClickEvent(arg__1);
3075 }
3071 }
3076 void PythonQtShell_QHexSpinBox::mouseMoveEvent(QMouseEvent* event)
3072 void PythonQtShell_QHexSpinBox::mouseMoveEvent(QMouseEvent* event)
3077 {
3073 {
3078 if (_wrapper) {
3074 if (_wrapper) {
3079 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseMoveEvent");
3075 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseMoveEvent");
3080 PyErr_Clear();
3076 PyErr_Clear();
3081 if (obj && !PythonQtSlotFunction_Check(obj)) {
3077 if (obj && !PythonQtSlotFunction_Check(obj)) {
3082 static const char* argumentList[] ={"" , "QMouseEvent*"};
3078 static const char* argumentList[] ={"" , "QMouseEvent*"};
3083 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3079 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3084 void* args[2] = {NULL, (void*)&event};
3080 void* args[2] = {NULL, (void*)&event};
3085 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3081 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3086 if (result) { Py_DECREF(result); }
3082 if (result) { Py_DECREF(result); }
3087 Py_DECREF(obj);
3083 Py_DECREF(obj);
3088 return;
3084 return;
3089 }
3085 }
3090 }
3086 }
3091 QHexSpinBox::mouseMoveEvent(event);
3087 QHexSpinBox::mouseMoveEvent(event);
3092 }
3088 }
3093 void PythonQtShell_QHexSpinBox::mousePressEvent(QMouseEvent* event)
3089 void PythonQtShell_QHexSpinBox::mousePressEvent(QMouseEvent* event)
3094 {
3090 {
3095 if (_wrapper) {
3091 if (_wrapper) {
3096 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mousePressEvent");
3092 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mousePressEvent");
3097 PyErr_Clear();
3093 PyErr_Clear();
3098 if (obj && !PythonQtSlotFunction_Check(obj)) {
3094 if (obj && !PythonQtSlotFunction_Check(obj)) {
3099 static const char* argumentList[] ={"" , "QMouseEvent*"};
3095 static const char* argumentList[] ={"" , "QMouseEvent*"};
3100 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3096 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3101 void* args[2] = {NULL, (void*)&event};
3097 void* args[2] = {NULL, (void*)&event};
3102 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3098 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3103 if (result) { Py_DECREF(result); }
3099 if (result) { Py_DECREF(result); }
3104 Py_DECREF(obj);
3100 Py_DECREF(obj);
3105 return;
3101 return;
3106 }
3102 }
3107 }
3103 }
3108 QHexSpinBox::mousePressEvent(event);
3104 QHexSpinBox::mousePressEvent(event);
3109 }
3105 }
3110 void PythonQtShell_QHexSpinBox::mouseReleaseEvent(QMouseEvent* event)
3106 void PythonQtShell_QHexSpinBox::mouseReleaseEvent(QMouseEvent* event)
3111 {
3107 {
3112 if (_wrapper) {
3108 if (_wrapper) {
3113 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseReleaseEvent");
3109 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseReleaseEvent");
3114 PyErr_Clear();
3110 PyErr_Clear();
3115 if (obj && !PythonQtSlotFunction_Check(obj)) {
3111 if (obj && !PythonQtSlotFunction_Check(obj)) {
3116 static const char* argumentList[] ={"" , "QMouseEvent*"};
3112 static const char* argumentList[] ={"" , "QMouseEvent*"};
3117 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3113 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3118 void* args[2] = {NULL, (void*)&event};
3114 void* args[2] = {NULL, (void*)&event};
3119 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3115 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3120 if (result) { Py_DECREF(result); }
3116 if (result) { Py_DECREF(result); }
3121 Py_DECREF(obj);
3117 Py_DECREF(obj);
3122 return;
3118 return;
3123 }
3119 }
3124 }
3120 }
3125 QHexSpinBox::mouseReleaseEvent(event);
3121 QHexSpinBox::mouseReleaseEvent(event);
3126 }
3122 }
3127 void PythonQtShell_QHexSpinBox::moveEvent(QMoveEvent* arg__1)
3123 void PythonQtShell_QHexSpinBox::moveEvent(QMoveEvent* arg__1)
3128 {
3124 {
3129 if (_wrapper) {
3125 if (_wrapper) {
3130 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "moveEvent");
3126 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "moveEvent");
3131 PyErr_Clear();
3127 PyErr_Clear();
3132 if (obj && !PythonQtSlotFunction_Check(obj)) {
3128 if (obj && !PythonQtSlotFunction_Check(obj)) {
3133 static const char* argumentList[] ={"" , "QMoveEvent*"};
3129 static const char* argumentList[] ={"" , "QMoveEvent*"};
3134 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3130 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3135 void* args[2] = {NULL, (void*)&arg__1};
3131 void* args[2] = {NULL, (void*)&arg__1};
3136 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3132 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3137 if (result) { Py_DECREF(result); }
3133 if (result) { Py_DECREF(result); }
3138 Py_DECREF(obj);
3134 Py_DECREF(obj);
3139 return;
3135 return;
3140 }
3136 }
3141 }
3137 }
3142 QHexSpinBox::moveEvent(arg__1);
3138 QHexSpinBox::moveEvent(arg__1);
3143 }
3139 }
3144 bool PythonQtShell_QHexSpinBox::nativeEvent(const QByteArray& eventType, void* message, long* result)
3140 bool PythonQtShell_QHexSpinBox::nativeEvent(const QByteArray& eventType, void* message, long* result)
3145 {
3141 {
3146 if (_wrapper) {
3142 if (_wrapper) {
3147 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "nativeEvent");
3143 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "nativeEvent");
3148 PyErr_Clear();
3144 PyErr_Clear();
3149 if (obj && !PythonQtSlotFunction_Check(obj)) {
3145 if (obj && !PythonQtSlotFunction_Check(obj)) {
3150 static const char* argumentList[] ={"bool" , "const QByteArray&" , "void*" , "long*"};
3146 static const char* argumentList[] ={"bool" , "const QByteArray&" , "void*" , "long*"};
3151 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
3147 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
3152 bool returnValue;
3148 bool returnValue;
3153 void* args[4] = {NULL, (void*)&eventType, (void*)&message, (void*)&result};
3149 void* args[4] = {NULL, (void*)&eventType, (void*)&message, (void*)&result};
3154 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3150 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3155 if (result) {
3151 if (result) {
3156 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3152 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3157 if (args[0]!=&returnValue) {
3153 if (args[0]!=&returnValue) {
3158 if (args[0]==NULL) {
3154 if (args[0]==NULL) {
3159 PythonQt::priv()->handleVirtualOverloadReturnError("nativeEvent", methodInfo, result);
3155 PythonQt::priv()->handleVirtualOverloadReturnError("nativeEvent", methodInfo, result);
3160 } else {
3156 } else {
3161 returnValue = *((bool*)args[0]);
3157 returnValue = *((bool*)args[0]);
3162 }
3158 }
3163 }
3159 }
3164 }
3160 }
3165 if (result) { Py_DECREF(result); }
3161 if (result) { Py_DECREF(result); }
3166 Py_DECREF(obj);
3162 Py_DECREF(obj);
3167 return returnValue;
3163 return returnValue;
3168 }
3164 }
3169 }
3165 }
3170 return QHexSpinBox::nativeEvent(eventType, message, result);
3166 return QHexSpinBox::nativeEvent(eventType, message, result);
3171 }
3167 }
3172 QPaintEngine* PythonQtShell_QHexSpinBox::paintEngine() const
3168 QPaintEngine* PythonQtShell_QHexSpinBox::paintEngine() const
3173 {
3169 {
3174 if (_wrapper) {
3170 if (_wrapper) {
3175 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEngine");
3171 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEngine");
3176 PyErr_Clear();
3172 PyErr_Clear();
3177 if (obj && !PythonQtSlotFunction_Check(obj)) {
3173 if (obj && !PythonQtSlotFunction_Check(obj)) {
3178 static const char* argumentList[] ={"QPaintEngine*"};
3174 static const char* argumentList[] ={"QPaintEngine*"};
3179 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
3175 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
3180 QPaintEngine* returnValue;
3176 QPaintEngine* returnValue;
3181 void* args[1] = {NULL};
3177 void* args[1] = {NULL};
3182 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3178 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3183 if (result) {
3179 if (result) {
3184 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3180 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3185 if (args[0]!=&returnValue) {
3181 if (args[0]!=&returnValue) {
3186 if (args[0]==NULL) {
3182 if (args[0]==NULL) {
3187 PythonQt::priv()->handleVirtualOverloadReturnError("paintEngine", methodInfo, result);
3183 PythonQt::priv()->handleVirtualOverloadReturnError("paintEngine", methodInfo, result);
3188 } else {
3184 } else {
3189 returnValue = *((QPaintEngine**)args[0]);
3185 returnValue = *((QPaintEngine**)args[0]);
3190 }
3186 }
3191 }
3187 }
3192 }
3188 }
3193 if (result) { Py_DECREF(result); }
3189 if (result) { Py_DECREF(result); }
3194 Py_DECREF(obj);
3190 Py_DECREF(obj);
3195 return returnValue;
3191 return returnValue;
3196 }
3192 }
3197 }
3193 }
3198 return QHexSpinBox::paintEngine();
3194 return QHexSpinBox::paintEngine();
3199 }
3195 }
3200 void PythonQtShell_QHexSpinBox::paintEvent(QPaintEvent* event)
3196 void PythonQtShell_QHexSpinBox::paintEvent(QPaintEvent* event)
3201 {
3197 {
3202 if (_wrapper) {
3198 if (_wrapper) {
3203 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEvent");
3199 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEvent");
3204 PyErr_Clear();
3200 PyErr_Clear();
3205 if (obj && !PythonQtSlotFunction_Check(obj)) {
3201 if (obj && !PythonQtSlotFunction_Check(obj)) {
3206 static const char* argumentList[] ={"" , "QPaintEvent*"};
3202 static const char* argumentList[] ={"" , "QPaintEvent*"};
3207 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3203 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3208 void* args[2] = {NULL, (void*)&event};
3204 void* args[2] = {NULL, (void*)&event};
3209 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3205 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3210 if (result) { Py_DECREF(result); }
3206 if (result) { Py_DECREF(result); }
3211 Py_DECREF(obj);
3207 Py_DECREF(obj);
3212 return;
3208 return;
3213 }
3209 }
3214 }
3210 }
3215 QHexSpinBox::paintEvent(event);
3211 QHexSpinBox::paintEvent(event);
3216 }
3212 }
3217 QPaintDevice* PythonQtShell_QHexSpinBox::redirected(QPoint* offset) const
3213 QPaintDevice* PythonQtShell_QHexSpinBox::redirected(QPoint* offset) const
3218 {
3214 {
3219 if (_wrapper) {
3215 if (_wrapper) {
3220 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "redirected");
3216 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "redirected");
3221 PyErr_Clear();
3217 PyErr_Clear();
3222 if (obj && !PythonQtSlotFunction_Check(obj)) {
3218 if (obj && !PythonQtSlotFunction_Check(obj)) {
3223 static const char* argumentList[] ={"QPaintDevice*" , "QPoint*"};
3219 static const char* argumentList[] ={"QPaintDevice*" , "QPoint*"};
3224 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3220 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3225 QPaintDevice* returnValue;
3221 QPaintDevice* returnValue;
3226 void* args[2] = {NULL, (void*)&offset};
3222 void* args[2] = {NULL, (void*)&offset};
3227 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3223 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3228 if (result) {
3224 if (result) {
3229 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3225 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3230 if (args[0]!=&returnValue) {
3226 if (args[0]!=&returnValue) {
3231 if (args[0]==NULL) {
3227 if (args[0]==NULL) {
3232 PythonQt::priv()->handleVirtualOverloadReturnError("redirected", methodInfo, result);
3228 PythonQt::priv()->handleVirtualOverloadReturnError("redirected", methodInfo, result);
3233 } else {
3229 } else {
3234 returnValue = *((QPaintDevice**)args[0]);
3230 returnValue = *((QPaintDevice**)args[0]);
3235 }
3231 }
3236 }
3232 }
3237 }
3233 }
3238 if (result) { Py_DECREF(result); }
3234 if (result) { Py_DECREF(result); }
3239 Py_DECREF(obj);
3235 Py_DECREF(obj);
3240 return returnValue;
3236 return returnValue;
3241 }
3237 }
3242 }
3238 }
3243 return QHexSpinBox::redirected(offset);
3239 return QHexSpinBox::redirected(offset);
3244 }
3240 }
3245 void PythonQtShell_QHexSpinBox::resizeEvent(QResizeEvent* event)
3241 void PythonQtShell_QHexSpinBox::resizeEvent(QResizeEvent* event)
3246 {
3242 {
3247 if (_wrapper) {
3243 if (_wrapper) {
3248 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "resizeEvent");
3244 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "resizeEvent");
3249 PyErr_Clear();
3245 PyErr_Clear();
3250 if (obj && !PythonQtSlotFunction_Check(obj)) {
3246 if (obj && !PythonQtSlotFunction_Check(obj)) {
3251 static const char* argumentList[] ={"" , "QResizeEvent*"};
3247 static const char* argumentList[] ={"" , "QResizeEvent*"};
3252 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3248 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3253 void* args[2] = {NULL, (void*)&event};
3249 void* args[2] = {NULL, (void*)&event};
3254 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3250 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3255 if (result) { Py_DECREF(result); }
3251 if (result) { Py_DECREF(result); }
3256 Py_DECREF(obj);
3252 Py_DECREF(obj);
3257 return;
3253 return;
3258 }
3254 }
3259 }
3255 }
3260 QHexSpinBox::resizeEvent(event);
3256 QHexSpinBox::resizeEvent(event);
3261 }
3257 }
3262 QPainter* PythonQtShell_QHexSpinBox::sharedPainter() const
3258 QPainter* PythonQtShell_QHexSpinBox::sharedPainter() const
3263 {
3259 {
3264 if (_wrapper) {
3260 if (_wrapper) {
3265 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "sharedPainter");
3261 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "sharedPainter");
3266 PyErr_Clear();
3262 PyErr_Clear();
3267 if (obj && !PythonQtSlotFunction_Check(obj)) {
3263 if (obj && !PythonQtSlotFunction_Check(obj)) {
3268 static const char* argumentList[] ={"QPainter*"};
3264 static const char* argumentList[] ={"QPainter*"};
3269 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
3265 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
3270 QPainter* returnValue;
3266 QPainter* returnValue;
3271 void* args[1] = {NULL};
3267 void* args[1] = {NULL};
3272 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3268 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3273 if (result) {
3269 if (result) {
3274 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3270 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3275 if (args[0]!=&returnValue) {
3271 if (args[0]!=&returnValue) {
3276 if (args[0]==NULL) {
3272 if (args[0]==NULL) {
3277 PythonQt::priv()->handleVirtualOverloadReturnError("sharedPainter", methodInfo, result);
3273 PythonQt::priv()->handleVirtualOverloadReturnError("sharedPainter", methodInfo, result);
3278 } else {
3274 } else {
3279 returnValue = *((QPainter**)args[0]);
3275 returnValue = *((QPainter**)args[0]);
3280 }
3276 }
3281 }
3277 }
3282 }
3278 }
3283 if (result) { Py_DECREF(result); }
3279 if (result) { Py_DECREF(result); }
3284 Py_DECREF(obj);
3280 Py_DECREF(obj);
3285 return returnValue;
3281 return returnValue;
3286 }
3282 }
3287 }
3283 }
3288 return QHexSpinBox::sharedPainter();
3284 return QHexSpinBox::sharedPainter();
3289 }
3285 }
3290 void PythonQtShell_QHexSpinBox::showEvent(QShowEvent* event)
3286 void PythonQtShell_QHexSpinBox::showEvent(QShowEvent* event)
3291 {
3287 {
3292 if (_wrapper) {
3288 if (_wrapper) {
3293 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "showEvent");
3289 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "showEvent");
3294 PyErr_Clear();
3290 PyErr_Clear();
3295 if (obj && !PythonQtSlotFunction_Check(obj)) {
3291 if (obj && !PythonQtSlotFunction_Check(obj)) {
3296 static const char* argumentList[] ={"" , "QShowEvent*"};
3292 static const char* argumentList[] ={"" , "QShowEvent*"};
3297 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3293 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3298 void* args[2] = {NULL, (void*)&event};
3294 void* args[2] = {NULL, (void*)&event};
3299 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3295 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3300 if (result) { Py_DECREF(result); }
3296 if (result) { Py_DECREF(result); }
3301 Py_DECREF(obj);
3297 Py_DECREF(obj);
3302 return;
3298 return;
3303 }
3299 }
3304 }
3300 }
3305 QHexSpinBox::showEvent(event);
3301 QHexSpinBox::showEvent(event);
3306 }
3302 }
3307 void PythonQtShell_QHexSpinBox::stepBy(int steps)
3303 void PythonQtShell_QHexSpinBox::stepBy(int steps)
3308 {
3304 {
3309 if (_wrapper) {
3305 if (_wrapper) {
3310 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "stepBy");
3306 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "stepBy");
3311 PyErr_Clear();
3307 PyErr_Clear();
3312 if (obj && !PythonQtSlotFunction_Check(obj)) {
3308 if (obj && !PythonQtSlotFunction_Check(obj)) {
3313 static const char* argumentList[] ={"" , "int"};
3309 static const char* argumentList[] ={"" , "int"};
3314 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3310 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3315 void* args[2] = {NULL, (void*)&steps};
3311 void* args[2] = {NULL, (void*)&steps};
3316 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3312 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3317 if (result) { Py_DECREF(result); }
3313 if (result) { Py_DECREF(result); }
3318 Py_DECREF(obj);
3314 Py_DECREF(obj);
3319 return;
3315 return;
3320 }
3316 }
3321 }
3317 }
3322 QHexSpinBox::stepBy(steps);
3318 QHexSpinBox::stepBy(steps);
3323 }
3319 }
3324 QAbstractSpinBox::StepEnabled PythonQtShell_QHexSpinBox::stepEnabled() const
3320 QAbstractSpinBox::StepEnabled PythonQtShell_QHexSpinBox::stepEnabled() const
3325 {
3321 {
3326 if (_wrapper) {
3322 if (_wrapper) {
3327 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "stepEnabled");
3323 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "stepEnabled");
3328 PyErr_Clear();
3324 PyErr_Clear();
3329 if (obj && !PythonQtSlotFunction_Check(obj)) {
3325 if (obj && !PythonQtSlotFunction_Check(obj)) {
3330 static const char* argumentList[] ={"QAbstractSpinBox::StepEnabled"};
3326 static const char* argumentList[] ={"QAbstractSpinBox::StepEnabled"};
3331 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
3327 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
3332 QAbstractSpinBox::StepEnabled returnValue;
3328 QAbstractSpinBox::StepEnabled returnValue;
3333 void* args[1] = {NULL};
3329 void* args[1] = {NULL};
3334 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3330 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3335 if (result) {
3331 if (result) {
3336 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3332 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3337 if (args[0]!=&returnValue) {
3333 if (args[0]!=&returnValue) {
3338 if (args[0]==NULL) {
3334 if (args[0]==NULL) {
3339 PythonQt::priv()->handleVirtualOverloadReturnError("stepEnabled", methodInfo, result);
3335 PythonQt::priv()->handleVirtualOverloadReturnError("stepEnabled", methodInfo, result);
3340 } else {
3336 } else {
3341 returnValue = *((QAbstractSpinBox::StepEnabled*)args[0]);
3337 returnValue = *((QAbstractSpinBox::StepEnabled*)args[0]);
3342 }
3338 }
3343 }
3339 }
3344 }
3340 }
3345 if (result) { Py_DECREF(result); }
3341 if (result) { Py_DECREF(result); }
3346 Py_DECREF(obj);
3342 Py_DECREF(obj);
3347 return returnValue;
3343 return returnValue;
3348 }
3344 }
3349 }
3345 }
3350 return QHexSpinBox::stepEnabled();
3346 return QHexSpinBox::stepEnabled();
3351 }
3347 }
3352 void PythonQtShell_QHexSpinBox::tabletEvent(QTabletEvent* arg__1)
3348 void PythonQtShell_QHexSpinBox::tabletEvent(QTabletEvent* arg__1)
3353 {
3349 {
3354 if (_wrapper) {
3350 if (_wrapper) {
3355 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "tabletEvent");
3351 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "tabletEvent");
3356 PyErr_Clear();
3352 PyErr_Clear();
3357 if (obj && !PythonQtSlotFunction_Check(obj)) {
3353 if (obj && !PythonQtSlotFunction_Check(obj)) {
3358 static const char* argumentList[] ={"" , "QTabletEvent*"};
3354 static const char* argumentList[] ={"" , "QTabletEvent*"};
3359 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3355 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3360 void* args[2] = {NULL, (void*)&arg__1};
3356 void* args[2] = {NULL, (void*)&arg__1};
3361 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3357 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3362 if (result) { Py_DECREF(result); }
3358 if (result) { Py_DECREF(result); }
3363 Py_DECREF(obj);
3359 Py_DECREF(obj);
3364 return;
3360 return;
3365 }
3361 }
3366 }
3362 }
3367 QHexSpinBox::tabletEvent(arg__1);
3363 QHexSpinBox::tabletEvent(arg__1);
3368 }
3364 }
3369 QString PythonQtShell_QHexSpinBox::textFromValue(int value) const
3365 QString PythonQtShell_QHexSpinBox::textFromValue(int value) const
3370 {
3366 {
3371 if (_wrapper) {
3367 if (_wrapper) {
3372 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "textFromValue");
3368 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "textFromValue");
3373 PyErr_Clear();
3369 PyErr_Clear();
3374 if (obj && !PythonQtSlotFunction_Check(obj)) {
3370 if (obj && !PythonQtSlotFunction_Check(obj)) {
3375 static const char* argumentList[] ={"QString" , "int"};
3371 static const char* argumentList[] ={"QString" , "int"};
3376 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3372 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3377 QString returnValue;
3373 QString returnValue;
3378 void* args[2] = {NULL, (void*)&value};
3374 void* args[2] = {NULL, (void*)&value};
3379 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3375 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3380 if (result) {
3376 if (result) {
3381 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3377 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3382 if (args[0]!=&returnValue) {
3378 if (args[0]!=&returnValue) {
3383 if (args[0]==NULL) {
3379 if (args[0]==NULL) {
3384 PythonQt::priv()->handleVirtualOverloadReturnError("textFromValue", methodInfo, result);
3380 PythonQt::priv()->handleVirtualOverloadReturnError("textFromValue", methodInfo, result);
3385 } else {
3381 } else {
3386 returnValue = *((QString*)args[0]);
3382 returnValue = *((QString*)args[0]);
3387 }
3383 }
3388 }
3384 }
3389 }
3385 }
3390 if (result) { Py_DECREF(result); }
3386 if (result) { Py_DECREF(result); }
3391 Py_DECREF(obj);
3387 Py_DECREF(obj);
3392 return returnValue;
3388 return returnValue;
3393 }
3389 }
3394 }
3390 }
3395 return QHexSpinBox::textFromValue(value);
3391 return QHexSpinBox::textFromValue(value);
3396 }
3392 }
3397 void PythonQtShell_QHexSpinBox::timerEvent(QTimerEvent* event)
3393 void PythonQtShell_QHexSpinBox::timerEvent(QTimerEvent* event)
3398 {
3394 {
3399 if (_wrapper) {
3395 if (_wrapper) {
3400 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "timerEvent");
3396 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "timerEvent");
3401 PyErr_Clear();
3397 PyErr_Clear();
3402 if (obj && !PythonQtSlotFunction_Check(obj)) {
3398 if (obj && !PythonQtSlotFunction_Check(obj)) {
3403 static const char* argumentList[] ={"" , "QTimerEvent*"};
3399 static const char* argumentList[] ={"" , "QTimerEvent*"};
3404 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3400 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3405 void* args[2] = {NULL, (void*)&event};
3401 void* args[2] = {NULL, (void*)&event};
3406 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3402 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3407 if (result) { Py_DECREF(result); }
3403 if (result) { Py_DECREF(result); }
3408 Py_DECREF(obj);
3404 Py_DECREF(obj);
3409 return;
3405 return;
3410 }
3406 }
3411 }
3407 }
3412 QHexSpinBox::timerEvent(event);
3408 QHexSpinBox::timerEvent(event);
3413 }
3409 }
3414 QValidator::State PythonQtShell_QHexSpinBox::validate(QString& input, int& pos) const
3410 QValidator::State PythonQtShell_QHexSpinBox::validate(QString& input, int& pos) const
3415 {
3411 {
3416 if (_wrapper) {
3412 if (_wrapper) {
3417 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "validate");
3413 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "validate");
3418 PyErr_Clear();
3414 PyErr_Clear();
3419 if (obj && !PythonQtSlotFunction_Check(obj)) {
3415 if (obj && !PythonQtSlotFunction_Check(obj)) {
3420 static const char* argumentList[] ={"QValidator::State" , "QString&" , "int&"};
3416 static const char* argumentList[] ={"QValidator::State" , "QString&" , "int&"};
3421 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
3417 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
3422 QValidator::State returnValue;
3418 QValidator::State returnValue;
3423 void* args[3] = {NULL, (void*)&input, (void*)&pos};
3419 void* args[3] = {NULL, (void*)&input, (void*)&pos};
3424 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3420 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3425 if (result) {
3421 if (result) {
3426 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3422 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3427 if (args[0]!=&returnValue) {
3423 if (args[0]!=&returnValue) {
3428 if (args[0]==NULL) {
3424 if (args[0]==NULL) {
3429 PythonQt::priv()->handleVirtualOverloadReturnError("validate", methodInfo, result);
3425 PythonQt::priv()->handleVirtualOverloadReturnError("validate", methodInfo, result);
3430 } else {
3426 } else {
3431 returnValue = *((QValidator::State*)args[0]);
3427 returnValue = *((QValidator::State*)args[0]);
3432 }
3428 }
3433 }
3429 }
3434 }
3430 }
3435 if (result) { Py_DECREF(result); }
3431 if (result) { Py_DECREF(result); }
3436 Py_DECREF(obj);
3432 Py_DECREF(obj);
3437 return returnValue;
3433 return returnValue;
3438 }
3434 }
3439 }
3435 }
3440 return QHexSpinBox::validate(input, pos);
3436 return QHexSpinBox::validate(input, pos);
3441 }
3437 }
3442 int PythonQtShell_QHexSpinBox::valueFromText(const QString& text) const
3438 int PythonQtShell_QHexSpinBox::valueFromText(const QString& text) const
3443 {
3439 {
3444 if (_wrapper) {
3440 if (_wrapper) {
3445 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "valueFromText");
3441 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "valueFromText");
3446 PyErr_Clear();
3442 PyErr_Clear();
3447 if (obj && !PythonQtSlotFunction_Check(obj)) {
3443 if (obj && !PythonQtSlotFunction_Check(obj)) {
3448 static const char* argumentList[] ={"int" , "const QString&"};
3444 static const char* argumentList[] ={"int" , "const QString&"};
3449 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3445 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3450 int returnValue;
3446 int returnValue;
3451 void* args[2] = {NULL, (void*)&text};
3447 void* args[2] = {NULL, (void*)&text};
3452 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3448 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3453 if (result) {
3449 if (result) {
3454 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3450 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3455 if (args[0]!=&returnValue) {
3451 if (args[0]!=&returnValue) {
3456 if (args[0]==NULL) {
3452 if (args[0]==NULL) {
3457 PythonQt::priv()->handleVirtualOverloadReturnError("valueFromText", methodInfo, result);
3453 PythonQt::priv()->handleVirtualOverloadReturnError("valueFromText", methodInfo, result);
3458 } else {
3454 } else {
3459 returnValue = *((int*)args[0]);
3455 returnValue = *((int*)args[0]);
3460 }
3456 }
3461 }
3457 }
3462 }
3458 }
3463 if (result) { Py_DECREF(result); }
3459 if (result) { Py_DECREF(result); }
3464 Py_DECREF(obj);
3460 Py_DECREF(obj);
3465 return returnValue;
3461 return returnValue;
3466 }
3462 }
3467 }
3463 }
3468 return QHexSpinBox::valueFromText(text);
3464 return QHexSpinBox::valueFromText(text);
3469 }
3465 }
3470 void PythonQtShell_QHexSpinBox::wheelEvent(QWheelEvent* event)
3466 void PythonQtShell_QHexSpinBox::wheelEvent(QWheelEvent* event)
3471 {
3467 {
3472 if (_wrapper) {
3468 if (_wrapper) {
3473 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "wheelEvent");
3469 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "wheelEvent");
3474 PyErr_Clear();
3470 PyErr_Clear();
3475 if (obj && !PythonQtSlotFunction_Check(obj)) {
3471 if (obj && !PythonQtSlotFunction_Check(obj)) {
3476 static const char* argumentList[] ={"" , "QWheelEvent*"};
3472 static const char* argumentList[] ={"" , "QWheelEvent*"};
3477 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3473 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3478 void* args[2] = {NULL, (void*)&event};
3474 void* args[2] = {NULL, (void*)&event};
3479 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3475 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3480 if (result) { Py_DECREF(result); }
3476 if (result) { Py_DECREF(result); }
3481 Py_DECREF(obj);
3477 Py_DECREF(obj);
3482 return;
3478 return;
3483 }
3479 }
3484 }
3480 }
3485 QHexSpinBox::wheelEvent(event);
3481 QHexSpinBox::wheelEvent(event);
3486 }
3482 }
3487 QHexSpinBox* PythonQtWrapper_QHexSpinBox::new_QHexSpinBox(QWidget* parent)
3483 QHexSpinBox* PythonQtWrapper_QHexSpinBox::new_QHexSpinBox(QWidget* parent)
3488 {
3484 {
3489 return new PythonQtShell_QHexSpinBox(parent); }
3485 return new PythonQtShell_QHexSpinBox(parent); }
3490
3486
3491 void PythonQtWrapper_QHexSpinBox::show(QHexSpinBox* theWrappedObject)
3487 void PythonQtWrapper_QHexSpinBox::show(QHexSpinBox* theWrappedObject)
3492 {
3488 {
3493 ( theWrappedObject->show());
3489 ( theWrappedObject->show());
3494 }
3490 }
3495
3491
3496 QString PythonQtWrapper_QHexSpinBox::textFromValue(QHexSpinBox* theWrappedObject, int value) const
3492 QString PythonQtWrapper_QHexSpinBox::textFromValue(QHexSpinBox* theWrappedObject, int value) const
3497 {
3493 {
3498 return ( ((PythonQtPublicPromoter_QHexSpinBox*)theWrappedObject)->promoted_textFromValue(value));
3494 return ( ((PythonQtPublicPromoter_QHexSpinBox*)theWrappedObject)->promoted_textFromValue(value));
3499 }
3495 }
3500
3496
3501 QValidator::State PythonQtWrapper_QHexSpinBox::validate(QHexSpinBox* theWrappedObject, QString& input, int& pos) const
3497 QValidator::State PythonQtWrapper_QHexSpinBox::validate(QHexSpinBox* theWrappedObject, QString& input, int& pos) const
3502 {
3498 {
3503 return ( ((PythonQtPublicPromoter_QHexSpinBox*)theWrappedObject)->promoted_validate(input, pos));
3499 return ( ((PythonQtPublicPromoter_QHexSpinBox*)theWrappedObject)->promoted_validate(input, pos));
3504 }
3500 }
3505
3501
3506 int PythonQtWrapper_QHexSpinBox::valueFromText(QHexSpinBox* theWrappedObject, const QString& text) const
3502 int PythonQtWrapper_QHexSpinBox::valueFromText(QHexSpinBox* theWrappedObject, const QString& text) const
3507 {
3503 {
3508 return ( ((PythonQtPublicPromoter_QHexSpinBox*)theWrappedObject)->promoted_valueFromText(text));
3504 return ( ((PythonQtPublicPromoter_QHexSpinBox*)theWrappedObject)->promoted_valueFromText(text));
3509 }
3505 }
3510
3506
3511
3507
3512
3508
3513 PythonQtShell_SocExplorerPlot::~PythonQtShell_SocExplorerPlot() {
3509 PythonQtShell_SocExplorerPlot::~PythonQtShell_SocExplorerPlot() {
3514 PythonQtPrivate* priv = PythonQt::priv();
3510 PythonQtPrivate* priv = PythonQt::priv();
3515 if (priv) { priv->shellClassDeleted(this); }
3511 if (priv) { priv->shellClassDeleted(this); }
3516 }
3512 }
3517 void PythonQtShell_SocExplorerPlot::actionEvent(QActionEvent* arg__1)
3513 void PythonQtShell_SocExplorerPlot::actionEvent(QActionEvent* arg__1)
3518 {
3514 {
3519 if (_wrapper) {
3515 if (_wrapper) {
3520 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "actionEvent");
3516 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "actionEvent");
3521 PyErr_Clear();
3517 PyErr_Clear();
3522 if (obj && !PythonQtSlotFunction_Check(obj)) {
3518 if (obj && !PythonQtSlotFunction_Check(obj)) {
3523 static const char* argumentList[] ={"" , "QActionEvent*"};
3519 static const char* argumentList[] ={"" , "QActionEvent*"};
3524 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3520 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3525 void* args[2] = {NULL, (void*)&arg__1};
3521 void* args[2] = {NULL, (void*)&arg__1};
3526 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3522 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3527 if (result) { Py_DECREF(result); }
3523 if (result) { Py_DECREF(result); }
3528 Py_DECREF(obj);
3524 Py_DECREF(obj);
3529 return;
3525 return;
3530 }
3526 }
3531 }
3527 }
3532 SocExplorerPlot::actionEvent(arg__1);
3528 SocExplorerPlot::actionEvent(arg__1);
3533 }
3529 }
3534 void PythonQtShell_SocExplorerPlot::changeEvent(QEvent* arg__1)
3530 void PythonQtShell_SocExplorerPlot::changeEvent(QEvent* arg__1)
3535 {
3531 {
3536 if (_wrapper) {
3532 if (_wrapper) {
3537 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "changeEvent");
3533 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "changeEvent");
3538 PyErr_Clear();
3534 PyErr_Clear();
3539 if (obj && !PythonQtSlotFunction_Check(obj)) {
3535 if (obj && !PythonQtSlotFunction_Check(obj)) {
3540 static const char* argumentList[] ={"" , "QEvent*"};
3536 static const char* argumentList[] ={"" , "QEvent*"};
3541 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3537 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3542 void* args[2] = {NULL, (void*)&arg__1};
3538 void* args[2] = {NULL, (void*)&arg__1};
3543 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3539 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3544 if (result) { Py_DECREF(result); }
3540 if (result) { Py_DECREF(result); }
3545 Py_DECREF(obj);
3541 Py_DECREF(obj);
3546 return;
3542 return;
3547 }
3543 }
3548 }
3544 }
3549 SocExplorerPlot::changeEvent(arg__1);
3545 SocExplorerPlot::changeEvent(arg__1);
3550 }
3546 }
3551 void PythonQtShell_SocExplorerPlot::childEvent(QChildEvent* arg__1)
3547 void PythonQtShell_SocExplorerPlot::childEvent(QChildEvent* arg__1)
3552 {
3548 {
3553 if (_wrapper) {
3549 if (_wrapper) {
3554 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "childEvent");
3550 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "childEvent");
3555 PyErr_Clear();
3551 PyErr_Clear();
3556 if (obj && !PythonQtSlotFunction_Check(obj)) {
3552 if (obj && !PythonQtSlotFunction_Check(obj)) {
3557 static const char* argumentList[] ={"" , "QChildEvent*"};
3553 static const char* argumentList[] ={"" , "QChildEvent*"};
3558 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3554 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3559 void* args[2] = {NULL, (void*)&arg__1};
3555 void* args[2] = {NULL, (void*)&arg__1};
3560 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3556 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3561 if (result) { Py_DECREF(result); }
3557 if (result) { Py_DECREF(result); }
3562 Py_DECREF(obj);
3558 Py_DECREF(obj);
3563 return;
3559 return;
3564 }
3560 }
3565 }
3561 }
3566 SocExplorerPlot::childEvent(arg__1);
3562 SocExplorerPlot::childEvent(arg__1);
3567 }
3563 }
3568 void PythonQtShell_SocExplorerPlot::closeEvent(QCloseEvent* arg__1)
3564 void PythonQtShell_SocExplorerPlot::closeEvent(QCloseEvent* arg__1)
3569 {
3565 {
3570 if (_wrapper) {
3566 if (_wrapper) {
3571 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "closeEvent");
3567 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "closeEvent");
3572 PyErr_Clear();
3568 PyErr_Clear();
3573 if (obj && !PythonQtSlotFunction_Check(obj)) {
3569 if (obj && !PythonQtSlotFunction_Check(obj)) {
3574 static const char* argumentList[] ={"" , "QCloseEvent*"};
3570 static const char* argumentList[] ={"" , "QCloseEvent*"};
3575 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3571 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3576 void* args[2] = {NULL, (void*)&arg__1};
3572 void* args[2] = {NULL, (void*)&arg__1};
3577 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3573 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3578 if (result) { Py_DECREF(result); }
3574 if (result) { Py_DECREF(result); }
3579 Py_DECREF(obj);
3575 Py_DECREF(obj);
3580 return;
3576 return;
3581 }
3577 }
3582 }
3578 }
3583 SocExplorerPlot::closeEvent(arg__1);
3579 SocExplorerPlot::closeEvent(arg__1);
3584 }
3580 }
3585 void PythonQtShell_SocExplorerPlot::contextMenuEvent(QContextMenuEvent* arg__1)
3581 void PythonQtShell_SocExplorerPlot::contextMenuEvent(QContextMenuEvent* arg__1)
3586 {
3582 {
3587 if (_wrapper) {
3583 if (_wrapper) {
3588 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "contextMenuEvent");
3584 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "contextMenuEvent");
3589 PyErr_Clear();
3585 PyErr_Clear();
3590 if (obj && !PythonQtSlotFunction_Check(obj)) {
3586 if (obj && !PythonQtSlotFunction_Check(obj)) {
3591 static const char* argumentList[] ={"" , "QContextMenuEvent*"};
3587 static const char* argumentList[] ={"" , "QContextMenuEvent*"};
3592 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3588 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3593 void* args[2] = {NULL, (void*)&arg__1};
3589 void* args[2] = {NULL, (void*)&arg__1};
3594 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3590 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3595 if (result) { Py_DECREF(result); }
3591 if (result) { Py_DECREF(result); }
3596 Py_DECREF(obj);
3592 Py_DECREF(obj);
3597 return;
3593 return;
3598 }
3594 }
3599 }
3595 }
3600 SocExplorerPlot::contextMenuEvent(arg__1);
3596 SocExplorerPlot::contextMenuEvent(arg__1);
3601 }
3597 }
3602 void PythonQtShell_SocExplorerPlot::customEvent(QEvent* arg__1)
3598 void PythonQtShell_SocExplorerPlot::customEvent(QEvent* arg__1)
3603 {
3599 {
3604 if (_wrapper) {
3600 if (_wrapper) {
3605 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "customEvent");
3601 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "customEvent");
3606 PyErr_Clear();
3602 PyErr_Clear();
3607 if (obj && !PythonQtSlotFunction_Check(obj)) {
3603 if (obj && !PythonQtSlotFunction_Check(obj)) {
3608 static const char* argumentList[] ={"" , "QEvent*"};
3604 static const char* argumentList[] ={"" , "QEvent*"};
3609 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3605 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3610 void* args[2] = {NULL, (void*)&arg__1};
3606 void* args[2] = {NULL, (void*)&arg__1};
3611 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3607 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3612 if (result) { Py_DECREF(result); }
3608 if (result) { Py_DECREF(result); }
3613 Py_DECREF(obj);
3609 Py_DECREF(obj);
3614 return;
3610 return;
3615 }
3611 }
3616 }
3612 }
3617 SocExplorerPlot::customEvent(arg__1);
3613 SocExplorerPlot::customEvent(arg__1);
3618 }
3614 }
3619 int PythonQtShell_SocExplorerPlot::devType() const
3615 int PythonQtShell_SocExplorerPlot::devType() const
3620 {
3616 {
3621 if (_wrapper) {
3617 if (_wrapper) {
3622 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "devType");
3618 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "devType");
3623 PyErr_Clear();
3619 PyErr_Clear();
3624 if (obj && !PythonQtSlotFunction_Check(obj)) {
3620 if (obj && !PythonQtSlotFunction_Check(obj)) {
3625 static const char* argumentList[] ={"int"};
3621 static const char* argumentList[] ={"int"};
3626 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
3622 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
3627 int returnValue;
3623 int returnValue;
3628 void* args[1] = {NULL};
3624 void* args[1] = {NULL};
3629 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3625 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3630 if (result) {
3626 if (result) {
3631 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3627 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3632 if (args[0]!=&returnValue) {
3628 if (args[0]!=&returnValue) {
3633 if (args[0]==NULL) {
3629 if (args[0]==NULL) {
3634 PythonQt::priv()->handleVirtualOverloadReturnError("devType", methodInfo, result);
3630 PythonQt::priv()->handleVirtualOverloadReturnError("devType", methodInfo, result);
3635 } else {
3631 } else {
3636 returnValue = *((int*)args[0]);
3632 returnValue = *((int*)args[0]);
3637 }
3633 }
3638 }
3634 }
3639 }
3635 }
3640 if (result) { Py_DECREF(result); }
3636 if (result) { Py_DECREF(result); }
3641 Py_DECREF(obj);
3637 Py_DECREF(obj);
3642 return returnValue;
3638 return returnValue;
3643 }
3639 }
3644 }
3640 }
3645 return SocExplorerPlot::devType();
3641 return SocExplorerPlot::devType();
3646 }
3642 }
3647 void PythonQtShell_SocExplorerPlot::dragEnterEvent(QDragEnterEvent* arg__1)
3643 void PythonQtShell_SocExplorerPlot::dragEnterEvent(QDragEnterEvent* arg__1)
3648 {
3644 {
3649 if (_wrapper) {
3645 if (_wrapper) {
3650 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragEnterEvent");
3646 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragEnterEvent");
3651 PyErr_Clear();
3647 PyErr_Clear();
3652 if (obj && !PythonQtSlotFunction_Check(obj)) {
3648 if (obj && !PythonQtSlotFunction_Check(obj)) {
3653 static const char* argumentList[] ={"" , "QDragEnterEvent*"};
3649 static const char* argumentList[] ={"" , "QDragEnterEvent*"};
3654 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3650 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3655 void* args[2] = {NULL, (void*)&arg__1};
3651 void* args[2] = {NULL, (void*)&arg__1};
3656 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3652 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3657 if (result) { Py_DECREF(result); }
3653 if (result) { Py_DECREF(result); }
3658 Py_DECREF(obj);
3654 Py_DECREF(obj);
3659 return;
3655 return;
3660 }
3656 }
3661 }
3657 }
3662 SocExplorerPlot::dragEnterEvent(arg__1);
3658 SocExplorerPlot::dragEnterEvent(arg__1);
3663 }
3659 }
3664 void PythonQtShell_SocExplorerPlot::dragLeaveEvent(QDragLeaveEvent* arg__1)
3660 void PythonQtShell_SocExplorerPlot::dragLeaveEvent(QDragLeaveEvent* arg__1)
3665 {
3661 {
3666 if (_wrapper) {
3662 if (_wrapper) {
3667 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragLeaveEvent");
3663 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragLeaveEvent");
3668 PyErr_Clear();
3664 PyErr_Clear();
3669 if (obj && !PythonQtSlotFunction_Check(obj)) {
3665 if (obj && !PythonQtSlotFunction_Check(obj)) {
3670 static const char* argumentList[] ={"" , "QDragLeaveEvent*"};
3666 static const char* argumentList[] ={"" , "QDragLeaveEvent*"};
3671 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3667 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3672 void* args[2] = {NULL, (void*)&arg__1};
3668 void* args[2] = {NULL, (void*)&arg__1};
3673 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3669 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3674 if (result) { Py_DECREF(result); }
3670 if (result) { Py_DECREF(result); }
3675 Py_DECREF(obj);
3671 Py_DECREF(obj);
3676 return;
3672 return;
3677 }
3673 }
3678 }
3674 }
3679 SocExplorerPlot::dragLeaveEvent(arg__1);
3675 SocExplorerPlot::dragLeaveEvent(arg__1);
3680 }
3676 }
3681 void PythonQtShell_SocExplorerPlot::dragMoveEvent(QDragMoveEvent* arg__1)
3677 void PythonQtShell_SocExplorerPlot::dragMoveEvent(QDragMoveEvent* arg__1)
3682 {
3678 {
3683 if (_wrapper) {
3679 if (_wrapper) {
3684 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragMoveEvent");
3680 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragMoveEvent");
3685 PyErr_Clear();
3681 PyErr_Clear();
3686 if (obj && !PythonQtSlotFunction_Check(obj)) {
3682 if (obj && !PythonQtSlotFunction_Check(obj)) {
3687 static const char* argumentList[] ={"" , "QDragMoveEvent*"};
3683 static const char* argumentList[] ={"" , "QDragMoveEvent*"};
3688 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3684 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3689 void* args[2] = {NULL, (void*)&arg__1};
3685 void* args[2] = {NULL, (void*)&arg__1};
3690 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3686 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3691 if (result) { Py_DECREF(result); }
3687 if (result) { Py_DECREF(result); }
3692 Py_DECREF(obj);
3688 Py_DECREF(obj);
3693 return;
3689 return;
3694 }
3690 }
3695 }
3691 }
3696 SocExplorerPlot::dragMoveEvent(arg__1);
3692 SocExplorerPlot::dragMoveEvent(arg__1);
3697 }
3693 }
3698 void PythonQtShell_SocExplorerPlot::dropEvent(QDropEvent* arg__1)
3694 void PythonQtShell_SocExplorerPlot::dropEvent(QDropEvent* arg__1)
3699 {
3695 {
3700 if (_wrapper) {
3696 if (_wrapper) {
3701 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dropEvent");
3697 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dropEvent");
3702 PyErr_Clear();
3698 PyErr_Clear();
3703 if (obj && !PythonQtSlotFunction_Check(obj)) {
3699 if (obj && !PythonQtSlotFunction_Check(obj)) {
3704 static const char* argumentList[] ={"" , "QDropEvent*"};
3700 static const char* argumentList[] ={"" , "QDropEvent*"};
3705 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3701 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3706 void* args[2] = {NULL, (void*)&arg__1};
3702 void* args[2] = {NULL, (void*)&arg__1};
3707 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3703 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3708 if (result) { Py_DECREF(result); }
3704 if (result) { Py_DECREF(result); }
3709 Py_DECREF(obj);
3705 Py_DECREF(obj);
3710 return;
3706 return;
3711 }
3707 }
3712 }
3708 }
3713 SocExplorerPlot::dropEvent(arg__1);
3709 SocExplorerPlot::dropEvent(arg__1);
3714 }
3710 }
3715 void PythonQtShell_SocExplorerPlot::enterEvent(QEvent* arg__1)
3711 void PythonQtShell_SocExplorerPlot::enterEvent(QEvent* arg__1)
3716 {
3712 {
3717 if (_wrapper) {
3713 if (_wrapper) {
3718 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "enterEvent");
3714 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "enterEvent");
3719 PyErr_Clear();
3715 PyErr_Clear();
3720 if (obj && !PythonQtSlotFunction_Check(obj)) {
3716 if (obj && !PythonQtSlotFunction_Check(obj)) {
3721 static const char* argumentList[] ={"" , "QEvent*"};
3717 static const char* argumentList[] ={"" , "QEvent*"};
3722 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3718 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3723 void* args[2] = {NULL, (void*)&arg__1};
3719 void* args[2] = {NULL, (void*)&arg__1};
3724 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3720 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3725 if (result) { Py_DECREF(result); }
3721 if (result) { Py_DECREF(result); }
3726 Py_DECREF(obj);
3722 Py_DECREF(obj);
3727 return;
3723 return;
3728 }
3724 }
3729 }
3725 }
3730 SocExplorerPlot::enterEvent(arg__1);
3726 SocExplorerPlot::enterEvent(arg__1);
3731 }
3727 }
3732 bool PythonQtShell_SocExplorerPlot::event(QEvent* arg__1)
3728 bool PythonQtShell_SocExplorerPlot::event(QEvent* arg__1)
3733 {
3729 {
3734 if (_wrapper) {
3730 if (_wrapper) {
3735 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "event");
3731 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "event");
3736 PyErr_Clear();
3732 PyErr_Clear();
3737 if (obj && !PythonQtSlotFunction_Check(obj)) {
3733 if (obj && !PythonQtSlotFunction_Check(obj)) {
3738 static const char* argumentList[] ={"bool" , "QEvent*"};
3734 static const char* argumentList[] ={"bool" , "QEvent*"};
3739 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3735 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3740 bool returnValue;
3736 bool returnValue;
3741 void* args[2] = {NULL, (void*)&arg__1};
3737 void* args[2] = {NULL, (void*)&arg__1};
3742 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3738 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3743 if (result) {
3739 if (result) {
3744 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3740 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3745 if (args[0]!=&returnValue) {
3741 if (args[0]!=&returnValue) {
3746 if (args[0]==NULL) {
3742 if (args[0]==NULL) {
3747 PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
3743 PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
3748 } else {
3744 } else {
3749 returnValue = *((bool*)args[0]);
3745 returnValue = *((bool*)args[0]);
3750 }
3746 }
3751 }
3747 }
3752 }
3748 }
3753 if (result) { Py_DECREF(result); }
3749 if (result) { Py_DECREF(result); }
3754 Py_DECREF(obj);
3750 Py_DECREF(obj);
3755 return returnValue;
3751 return returnValue;
3756 }
3752 }
3757 }
3753 }
3758 return SocExplorerPlot::event(arg__1);
3754 return SocExplorerPlot::event(arg__1);
3759 }
3755 }
3760 bool PythonQtShell_SocExplorerPlot::eventFilter(QObject* arg__1, QEvent* arg__2)
3756 bool PythonQtShell_SocExplorerPlot::eventFilter(QObject* arg__1, QEvent* arg__2)
3761 {
3757 {
3762 if (_wrapper) {
3758 if (_wrapper) {
3763 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "eventFilter");
3759 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "eventFilter");
3764 PyErr_Clear();
3760 PyErr_Clear();
3765 if (obj && !PythonQtSlotFunction_Check(obj)) {
3761 if (obj && !PythonQtSlotFunction_Check(obj)) {
3766 static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
3762 static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
3767 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
3763 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
3768 bool returnValue;
3764 bool returnValue;
3769 void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2};
3765 void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2};
3770 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3766 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3771 if (result) {
3767 if (result) {
3772 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3768 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3773 if (args[0]!=&returnValue) {
3769 if (args[0]!=&returnValue) {
3774 if (args[0]==NULL) {
3770 if (args[0]==NULL) {
3775 PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
3771 PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
3776 } else {
3772 } else {
3777 returnValue = *((bool*)args[0]);
3773 returnValue = *((bool*)args[0]);
3778 }
3774 }
3779 }
3775 }
3780 }
3776 }
3781 if (result) { Py_DECREF(result); }
3777 if (result) { Py_DECREF(result); }
3782 Py_DECREF(obj);
3778 Py_DECREF(obj);
3783 return returnValue;
3779 return returnValue;
3784 }
3780 }
3785 }
3781 }
3786 return SocExplorerPlot::eventFilter(arg__1, arg__2);
3782 return SocExplorerPlot::eventFilter(arg__1, arg__2);
3787 }
3783 }
3788 void PythonQtShell_SocExplorerPlot::focusInEvent(QFocusEvent* arg__1)
3784 void PythonQtShell_SocExplorerPlot::focusInEvent(QFocusEvent* arg__1)
3789 {
3785 {
3790 if (_wrapper) {
3786 if (_wrapper) {
3791 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusInEvent");
3787 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusInEvent");
3792 PyErr_Clear();
3788 PyErr_Clear();
3793 if (obj && !PythonQtSlotFunction_Check(obj)) {
3789 if (obj && !PythonQtSlotFunction_Check(obj)) {
3794 static const char* argumentList[] ={"" , "QFocusEvent*"};
3790 static const char* argumentList[] ={"" , "QFocusEvent*"};
3795 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3791 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3796 void* args[2] = {NULL, (void*)&arg__1};
3792 void* args[2] = {NULL, (void*)&arg__1};
3797 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3793 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3798 if (result) { Py_DECREF(result); }
3794 if (result) { Py_DECREF(result); }
3799 Py_DECREF(obj);
3795 Py_DECREF(obj);
3800 return;
3796 return;
3801 }
3797 }
3802 }
3798 }
3803 SocExplorerPlot::focusInEvent(arg__1);
3799 SocExplorerPlot::focusInEvent(arg__1);
3804 }
3800 }
3805 bool PythonQtShell_SocExplorerPlot::focusNextPrevChild(bool next)
3801 bool PythonQtShell_SocExplorerPlot::focusNextPrevChild(bool next)
3806 {
3802 {
3807 if (_wrapper) {
3803 if (_wrapper) {
3808 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusNextPrevChild");
3804 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusNextPrevChild");
3809 PyErr_Clear();
3805 PyErr_Clear();
3810 if (obj && !PythonQtSlotFunction_Check(obj)) {
3806 if (obj && !PythonQtSlotFunction_Check(obj)) {
3811 static const char* argumentList[] ={"bool" , "bool"};
3807 static const char* argumentList[] ={"bool" , "bool"};
3812 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3808 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3813 bool returnValue;
3809 bool returnValue;
3814 void* args[2] = {NULL, (void*)&next};
3810 void* args[2] = {NULL, (void*)&next};
3815 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3811 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3816 if (result) {
3812 if (result) {
3817 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3813 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3818 if (args[0]!=&returnValue) {
3814 if (args[0]!=&returnValue) {
3819 if (args[0]==NULL) {
3815 if (args[0]==NULL) {
3820 PythonQt::priv()->handleVirtualOverloadReturnError("focusNextPrevChild", methodInfo, result);
3816 PythonQt::priv()->handleVirtualOverloadReturnError("focusNextPrevChild", methodInfo, result);
3821 } else {
3817 } else {
3822 returnValue = *((bool*)args[0]);
3818 returnValue = *((bool*)args[0]);
3823 }
3819 }
3824 }
3820 }
3825 }
3821 }
3826 if (result) { Py_DECREF(result); }
3822 if (result) { Py_DECREF(result); }
3827 Py_DECREF(obj);
3823 Py_DECREF(obj);
3828 return returnValue;
3824 return returnValue;
3829 }
3825 }
3830 }
3826 }
3831 return SocExplorerPlot::focusNextPrevChild(next);
3827 return SocExplorerPlot::focusNextPrevChild(next);
3832 }
3828 }
3833 void PythonQtShell_SocExplorerPlot::focusOutEvent(QFocusEvent* arg__1)
3829 void PythonQtShell_SocExplorerPlot::focusOutEvent(QFocusEvent* arg__1)
3834 {
3830 {
3835 if (_wrapper) {
3831 if (_wrapper) {
3836 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusOutEvent");
3832 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusOutEvent");
3837 PyErr_Clear();
3833 PyErr_Clear();
3838 if (obj && !PythonQtSlotFunction_Check(obj)) {
3834 if (obj && !PythonQtSlotFunction_Check(obj)) {
3839 static const char* argumentList[] ={"" , "QFocusEvent*"};
3835 static const char* argumentList[] ={"" , "QFocusEvent*"};
3840 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3836 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3841 void* args[2] = {NULL, (void*)&arg__1};
3837 void* args[2] = {NULL, (void*)&arg__1};
3842 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3838 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3843 if (result) { Py_DECREF(result); }
3839 if (result) { Py_DECREF(result); }
3844 Py_DECREF(obj);
3840 Py_DECREF(obj);
3845 return;
3841 return;
3846 }
3842 }
3847 }
3843 }
3848 SocExplorerPlot::focusOutEvent(arg__1);
3844 SocExplorerPlot::focusOutEvent(arg__1);
3849 }
3845 }
3850 bool PythonQtShell_SocExplorerPlot::hasHeightForWidth() const
3846 bool PythonQtShell_SocExplorerPlot::hasHeightForWidth() const
3851 {
3847 {
3852 if (_wrapper) {
3848 if (_wrapper) {
3853 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hasHeightForWidth");
3849 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hasHeightForWidth");
3854 PyErr_Clear();
3850 PyErr_Clear();
3855 if (obj && !PythonQtSlotFunction_Check(obj)) {
3851 if (obj && !PythonQtSlotFunction_Check(obj)) {
3856 static const char* argumentList[] ={"bool"};
3852 static const char* argumentList[] ={"bool"};
3857 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
3853 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
3858 bool returnValue;
3854 bool returnValue;
3859 void* args[1] = {NULL};
3855 void* args[1] = {NULL};
3860 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3856 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3861 if (result) {
3857 if (result) {
3862 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3858 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3863 if (args[0]!=&returnValue) {
3859 if (args[0]!=&returnValue) {
3864 if (args[0]==NULL) {
3860 if (args[0]==NULL) {
3865 PythonQt::priv()->handleVirtualOverloadReturnError("hasHeightForWidth", methodInfo, result);
3861 PythonQt::priv()->handleVirtualOverloadReturnError("hasHeightForWidth", methodInfo, result);
3866 } else {
3862 } else {
3867 returnValue = *((bool*)args[0]);
3863 returnValue = *((bool*)args[0]);
3868 }
3864 }
3869 }
3865 }
3870 }
3866 }
3871 if (result) { Py_DECREF(result); }
3867 if (result) { Py_DECREF(result); }
3872 Py_DECREF(obj);
3868 Py_DECREF(obj);
3873 return returnValue;
3869 return returnValue;
3874 }
3870 }
3875 }
3871 }
3876 return SocExplorerPlot::hasHeightForWidth();
3872 return SocExplorerPlot::hasHeightForWidth();
3877 }
3873 }
3878 int PythonQtShell_SocExplorerPlot::heightForWidth(int arg__1) const
3874 int PythonQtShell_SocExplorerPlot::heightForWidth(int arg__1) const
3879 {
3875 {
3880 if (_wrapper) {
3876 if (_wrapper) {
3881 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "heightForWidth");
3877 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "heightForWidth");
3882 PyErr_Clear();
3878 PyErr_Clear();
3883 if (obj && !PythonQtSlotFunction_Check(obj)) {
3879 if (obj && !PythonQtSlotFunction_Check(obj)) {
3884 static const char* argumentList[] ={"int" , "int"};
3880 static const char* argumentList[] ={"int" , "int"};
3885 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3881 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3886 int returnValue;
3882 int returnValue;
3887 void* args[2] = {NULL, (void*)&arg__1};
3883 void* args[2] = {NULL, (void*)&arg__1};
3888 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3884 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3889 if (result) {
3885 if (result) {
3890 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3886 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3891 if (args[0]!=&returnValue) {
3887 if (args[0]!=&returnValue) {
3892 if (args[0]==NULL) {
3888 if (args[0]==NULL) {
3893 PythonQt::priv()->handleVirtualOverloadReturnError("heightForWidth", methodInfo, result);
3889 PythonQt::priv()->handleVirtualOverloadReturnError("heightForWidth", methodInfo, result);
3894 } else {
3890 } else {
3895 returnValue = *((int*)args[0]);
3891 returnValue = *((int*)args[0]);
3896 }
3892 }
3897 }
3893 }
3898 }
3894 }
3899 if (result) { Py_DECREF(result); }
3895 if (result) { Py_DECREF(result); }
3900 Py_DECREF(obj);
3896 Py_DECREF(obj);
3901 return returnValue;
3897 return returnValue;
3902 }
3898 }
3903 }
3899 }
3904 return SocExplorerPlot::heightForWidth(arg__1);
3900 return SocExplorerPlot::heightForWidth(arg__1);
3905 }
3901 }
3906 void PythonQtShell_SocExplorerPlot::hideEvent(QHideEvent* arg__1)
3902 void PythonQtShell_SocExplorerPlot::hideEvent(QHideEvent* arg__1)
3907 {
3903 {
3908 if (_wrapper) {
3904 if (_wrapper) {
3909 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hideEvent");
3905 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hideEvent");
3910 PyErr_Clear();
3906 PyErr_Clear();
3911 if (obj && !PythonQtSlotFunction_Check(obj)) {
3907 if (obj && !PythonQtSlotFunction_Check(obj)) {
3912 static const char* argumentList[] ={"" , "QHideEvent*"};
3908 static const char* argumentList[] ={"" , "QHideEvent*"};
3913 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3909 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3914 void* args[2] = {NULL, (void*)&arg__1};
3910 void* args[2] = {NULL, (void*)&arg__1};
3915 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3911 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3916 if (result) { Py_DECREF(result); }
3912 if (result) { Py_DECREF(result); }
3917 Py_DECREF(obj);
3913 Py_DECREF(obj);
3918 return;
3914 return;
3919 }
3915 }
3920 }
3916 }
3921 SocExplorerPlot::hideEvent(arg__1);
3917 SocExplorerPlot::hideEvent(arg__1);
3922 }
3918 }
3923 void PythonQtShell_SocExplorerPlot::initPainter(QPainter* painter) const
3919 void PythonQtShell_SocExplorerPlot::initPainter(QPainter* painter) const
3924 {
3920 {
3925 if (_wrapper) {
3921 if (_wrapper) {
3926 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "initPainter");
3922 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "initPainter");
3927 PyErr_Clear();
3923 PyErr_Clear();
3928 if (obj && !PythonQtSlotFunction_Check(obj)) {
3924 if (obj && !PythonQtSlotFunction_Check(obj)) {
3929 static const char* argumentList[] ={"" , "QPainter*"};
3925 static const char* argumentList[] ={"" , "QPainter*"};
3930 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3926 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3931 void* args[2] = {NULL, (void*)&painter};
3927 void* args[2] = {NULL, (void*)&painter};
3932 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3928 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3933 if (result) { Py_DECREF(result); }
3929 if (result) { Py_DECREF(result); }
3934 Py_DECREF(obj);
3930 Py_DECREF(obj);
3935 return;
3931 return;
3936 }
3932 }
3937 }
3933 }
3938 SocExplorerPlot::initPainter(painter);
3934 SocExplorerPlot::initPainter(painter);
3939 }
3935 }
3940 void PythonQtShell_SocExplorerPlot::inputMethodEvent(QInputMethodEvent* arg__1)
3936 void PythonQtShell_SocExplorerPlot::inputMethodEvent(QInputMethodEvent* arg__1)
3941 {
3937 {
3942 if (_wrapper) {
3938 if (_wrapper) {
3943 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodEvent");
3939 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodEvent");
3944 PyErr_Clear();
3940 PyErr_Clear();
3945 if (obj && !PythonQtSlotFunction_Check(obj)) {
3941 if (obj && !PythonQtSlotFunction_Check(obj)) {
3946 static const char* argumentList[] ={"" , "QInputMethodEvent*"};
3942 static const char* argumentList[] ={"" , "QInputMethodEvent*"};
3947 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3943 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3948 void* args[2] = {NULL, (void*)&arg__1};
3944 void* args[2] = {NULL, (void*)&arg__1};
3949 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3945 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3950 if (result) { Py_DECREF(result); }
3946 if (result) { Py_DECREF(result); }
3951 Py_DECREF(obj);
3947 Py_DECREF(obj);
3952 return;
3948 return;
3953 }
3949 }
3954 }
3950 }
3955 SocExplorerPlot::inputMethodEvent(arg__1);
3951 SocExplorerPlot::inputMethodEvent(arg__1);
3956 }
3952 }
3957 QVariant PythonQtShell_SocExplorerPlot::inputMethodQuery(Qt::InputMethodQuery arg__1) const
3953 QVariant PythonQtShell_SocExplorerPlot::inputMethodQuery(Qt::InputMethodQuery arg__1) const
3958 {
3954 {
3959 if (_wrapper) {
3955 if (_wrapper) {
3960 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodQuery");
3956 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodQuery");
3961 PyErr_Clear();
3957 PyErr_Clear();
3962 if (obj && !PythonQtSlotFunction_Check(obj)) {
3958 if (obj && !PythonQtSlotFunction_Check(obj)) {
3963 static const char* argumentList[] ={"QVariant" , "Qt::InputMethodQuery"};
3959 static const char* argumentList[] ={"QVariant" , "Qt::InputMethodQuery"};
3964 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3960 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3965 QVariant returnValue;
3961 QVariant returnValue;
3966 void* args[2] = {NULL, (void*)&arg__1};
3962 void* args[2] = {NULL, (void*)&arg__1};
3967 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3963 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3968 if (result) {
3964 if (result) {
3969 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3965 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
3970 if (args[0]!=&returnValue) {
3966 if (args[0]!=&returnValue) {
3971 if (args[0]==NULL) {
3967 if (args[0]==NULL) {
3972 PythonQt::priv()->handleVirtualOverloadReturnError("inputMethodQuery", methodInfo, result);
3968 PythonQt::priv()->handleVirtualOverloadReturnError("inputMethodQuery", methodInfo, result);
3973 } else {
3969 } else {
3974 returnValue = *((QVariant*)args[0]);
3970 returnValue = *((QVariant*)args[0]);
3975 }
3971 }
3976 }
3972 }
3977 }
3973 }
3978 if (result) { Py_DECREF(result); }
3974 if (result) { Py_DECREF(result); }
3979 Py_DECREF(obj);
3975 Py_DECREF(obj);
3980 return returnValue;
3976 return returnValue;
3981 }
3977 }
3982 }
3978 }
3983 return SocExplorerPlot::inputMethodQuery(arg__1);
3979 return SocExplorerPlot::inputMethodQuery(arg__1);
3984 }
3980 }
3985 void PythonQtShell_SocExplorerPlot::keyPressEvent(QKeyEvent* arg__1)
3981 void PythonQtShell_SocExplorerPlot::keyPressEvent(QKeyEvent* arg__1)
3986 {
3982 {
3987 if (_wrapper) {
3983 if (_wrapper) {
3988 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyPressEvent");
3984 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyPressEvent");
3989 PyErr_Clear();
3985 PyErr_Clear();
3990 if (obj && !PythonQtSlotFunction_Check(obj)) {
3986 if (obj && !PythonQtSlotFunction_Check(obj)) {
3991 static const char* argumentList[] ={"" , "QKeyEvent*"};
3987 static const char* argumentList[] ={"" , "QKeyEvent*"};
3992 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3988 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
3993 void* args[2] = {NULL, (void*)&arg__1};
3989 void* args[2] = {NULL, (void*)&arg__1};
3994 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3990 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
3995 if (result) { Py_DECREF(result); }
3991 if (result) { Py_DECREF(result); }
3996 Py_DECREF(obj);
3992 Py_DECREF(obj);
3997 return;
3993 return;
3998 }
3994 }
3999 }
3995 }
4000 SocExplorerPlot::keyPressEvent(arg__1);
3996 SocExplorerPlot::keyPressEvent(arg__1);
4001 }
3997 }
4002 void PythonQtShell_SocExplorerPlot::keyReleaseEvent(QKeyEvent* arg__1)
3998 void PythonQtShell_SocExplorerPlot::keyReleaseEvent(QKeyEvent* arg__1)
4003 {
3999 {
4004 if (_wrapper) {
4000 if (_wrapper) {
4005 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyReleaseEvent");
4001 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyReleaseEvent");
4006 PyErr_Clear();
4002 PyErr_Clear();
4007 if (obj && !PythonQtSlotFunction_Check(obj)) {
4003 if (obj && !PythonQtSlotFunction_Check(obj)) {
4008 static const char* argumentList[] ={"" , "QKeyEvent*"};
4004 static const char* argumentList[] ={"" , "QKeyEvent*"};
4009 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4005 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4010 void* args[2] = {NULL, (void*)&arg__1};
4006 void* args[2] = {NULL, (void*)&arg__1};
4011 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4007 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4012 if (result) { Py_DECREF(result); }
4008 if (result) { Py_DECREF(result); }
4013 Py_DECREF(obj);
4009 Py_DECREF(obj);
4014 return;
4010 return;
4015 }
4011 }
4016 }
4012 }
4017 SocExplorerPlot::keyReleaseEvent(arg__1);
4013 SocExplorerPlot::keyReleaseEvent(arg__1);
4018 }
4014 }
4019 void PythonQtShell_SocExplorerPlot::leaveEvent(QEvent* arg__1)
4015 void PythonQtShell_SocExplorerPlot::leaveEvent(QEvent* arg__1)
4020 {
4016 {
4021 if (_wrapper) {
4017 if (_wrapper) {
4022 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "leaveEvent");
4018 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "leaveEvent");
4023 PyErr_Clear();
4019 PyErr_Clear();
4024 if (obj && !PythonQtSlotFunction_Check(obj)) {
4020 if (obj && !PythonQtSlotFunction_Check(obj)) {
4025 static const char* argumentList[] ={"" , "QEvent*"};
4021 static const char* argumentList[] ={"" , "QEvent*"};
4026 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4022 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4027 void* args[2] = {NULL, (void*)&arg__1};
4023 void* args[2] = {NULL, (void*)&arg__1};
4028 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4024 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4029 if (result) { Py_DECREF(result); }
4025 if (result) { Py_DECREF(result); }
4030 Py_DECREF(obj);
4026 Py_DECREF(obj);
4031 return;
4027 return;
4032 }
4028 }
4033 }
4029 }
4034 SocExplorerPlot::leaveEvent(arg__1);
4030 SocExplorerPlot::leaveEvent(arg__1);
4035 }
4031 }
4036 int PythonQtShell_SocExplorerPlot::metric(QPaintDevice::PaintDeviceMetric arg__1) const
4032 int PythonQtShell_SocExplorerPlot::metric(QPaintDevice::PaintDeviceMetric arg__1) const
4037 {
4033 {
4038 if (_wrapper) {
4034 if (_wrapper) {
4039 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "metric");
4035 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "metric");
4040 PyErr_Clear();
4036 PyErr_Clear();
4041 if (obj && !PythonQtSlotFunction_Check(obj)) {
4037 if (obj && !PythonQtSlotFunction_Check(obj)) {
4042 static const char* argumentList[] ={"int" , "QPaintDevice::PaintDeviceMetric"};
4038 static const char* argumentList[] ={"int" , "QPaintDevice::PaintDeviceMetric"};
4043 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4039 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4044 int returnValue;
4040 int returnValue;
4045 void* args[2] = {NULL, (void*)&arg__1};
4041 void* args[2] = {NULL, (void*)&arg__1};
4046 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4042 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4047 if (result) {
4043 if (result) {
4048 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
4044 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
4049 if (args[0]!=&returnValue) {
4045 if (args[0]!=&returnValue) {
4050 if (args[0]==NULL) {
4046 if (args[0]==NULL) {
4051 PythonQt::priv()->handleVirtualOverloadReturnError("metric", methodInfo, result);
4047 PythonQt::priv()->handleVirtualOverloadReturnError("metric", methodInfo, result);
4052 } else {
4048 } else {
4053 returnValue = *((int*)args[0]);
4049 returnValue = *((int*)args[0]);
4054 }
4050 }
4055 }
4051 }
4056 }
4052 }
4057 if (result) { Py_DECREF(result); }
4053 if (result) { Py_DECREF(result); }
4058 Py_DECREF(obj);
4054 Py_DECREF(obj);
4059 return returnValue;
4055 return returnValue;
4060 }
4056 }
4061 }
4057 }
4062 return SocExplorerPlot::metric(arg__1);
4058 return SocExplorerPlot::metric(arg__1);
4063 }
4059 }
4064 QSize PythonQtShell_SocExplorerPlot::minimumSizeHint() const
4060 QSize PythonQtShell_SocExplorerPlot::minimumSizeHint() const
4065 {
4061 {
4066 if (_wrapper) {
4062 if (_wrapper) {
4067 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getMinimumSizeHint");
4063 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getMinimumSizeHint");
4068 PyErr_Clear();
4064 PyErr_Clear();
4069 if (obj && !PythonQtSlotFunction_Check(obj)) {
4065 if (obj && !PythonQtSlotFunction_Check(obj)) {
4070 static const char* argumentList[] ={"QSize"};
4066 static const char* argumentList[] ={"QSize"};
4071 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
4067 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
4072 QSize returnValue;
4068 QSize returnValue;
4073 void* args[1] = {NULL};
4069 void* args[1] = {NULL};
4074 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4070 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4075 if (result) {
4071 if (result) {
4076 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
4072 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
4077 if (args[0]!=&returnValue) {
4073 if (args[0]!=&returnValue) {
4078 if (args[0]==NULL) {
4074 if (args[0]==NULL) {
4079 PythonQt::priv()->handleVirtualOverloadReturnError("getMinimumSizeHint", methodInfo, result);
4075 PythonQt::priv()->handleVirtualOverloadReturnError("getMinimumSizeHint", methodInfo, result);
4080 } else {
4076 } else {
4081 returnValue = *((QSize*)args[0]);
4077 returnValue = *((QSize*)args[0]);
4082 }
4078 }
4083 }
4079 }
4084 }
4080 }
4085 if (result) { Py_DECREF(result); }
4081 if (result) { Py_DECREF(result); }
4086 Py_DECREF(obj);
4082 Py_DECREF(obj);
4087 return returnValue;
4083 return returnValue;
4088 }
4084 }
4089 }
4085 }
4090 return SocExplorerPlot::minimumSizeHint();
4086 return SocExplorerPlot::minimumSizeHint();
4091 }
4087 }
4092 void PythonQtShell_SocExplorerPlot::mouseDoubleClickEvent(QMouseEvent* arg__1)
4088 void PythonQtShell_SocExplorerPlot::mouseDoubleClickEvent(QMouseEvent* arg__1)
4093 {
4089 {
4094 if (_wrapper) {
4090 if (_wrapper) {
4095 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseDoubleClickEvent");
4091 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseDoubleClickEvent");
4096 PyErr_Clear();
4092 PyErr_Clear();
4097 if (obj && !PythonQtSlotFunction_Check(obj)) {
4093 if (obj && !PythonQtSlotFunction_Check(obj)) {
4098 static const char* argumentList[] ={"" , "QMouseEvent*"};
4094 static const char* argumentList[] ={"" , "QMouseEvent*"};
4099 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4095 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4100 void* args[2] = {NULL, (void*)&arg__1};
4096 void* args[2] = {NULL, (void*)&arg__1};
4101 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4097 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4102 if (result) { Py_DECREF(result); }
4098 if (result) { Py_DECREF(result); }
4103 Py_DECREF(obj);
4099 Py_DECREF(obj);
4104 return;
4100 return;
4105 }
4101 }
4106 }
4102 }
4107 SocExplorerPlot::mouseDoubleClickEvent(arg__1);
4103 SocExplorerPlot::mouseDoubleClickEvent(arg__1);
4108 }
4104 }
4109 void PythonQtShell_SocExplorerPlot::mouseMoveEvent(QMouseEvent* arg__1)
4105 void PythonQtShell_SocExplorerPlot::mouseMoveEvent(QMouseEvent* arg__1)
4110 {
4106 {
4111 if (_wrapper) {
4107 if (_wrapper) {
4112 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseMoveEvent");
4108 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseMoveEvent");
4113 PyErr_Clear();
4109 PyErr_Clear();
4114 if (obj && !PythonQtSlotFunction_Check(obj)) {
4110 if (obj && !PythonQtSlotFunction_Check(obj)) {
4115 static const char* argumentList[] ={"" , "QMouseEvent*"};
4111 static const char* argumentList[] ={"" , "QMouseEvent*"};
4116 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4112 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4117 void* args[2] = {NULL, (void*)&arg__1};
4113 void* args[2] = {NULL, (void*)&arg__1};
4118 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4114 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4119 if (result) { Py_DECREF(result); }
4115 if (result) { Py_DECREF(result); }
4120 Py_DECREF(obj);
4116 Py_DECREF(obj);
4121 return;
4117 return;
4122 }
4118 }
4123 }
4119 }
4124 SocExplorerPlot::mouseMoveEvent(arg__1);
4120 SocExplorerPlot::mouseMoveEvent(arg__1);
4125 }
4121 }
4126 void PythonQtShell_SocExplorerPlot::mousePressEvent(QMouseEvent* arg__1)
4122 void PythonQtShell_SocExplorerPlot::mousePressEvent(QMouseEvent* arg__1)
4127 {
4123 {
4128 if (_wrapper) {
4124 if (_wrapper) {
4129 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mousePressEvent");
4125 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mousePressEvent");
4130 PyErr_Clear();
4126 PyErr_Clear();
4131 if (obj && !PythonQtSlotFunction_Check(obj)) {
4127 if (obj && !PythonQtSlotFunction_Check(obj)) {
4132 static const char* argumentList[] ={"" , "QMouseEvent*"};
4128 static const char* argumentList[] ={"" , "QMouseEvent*"};
4133 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4129 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4134 void* args[2] = {NULL, (void*)&arg__1};
4130 void* args[2] = {NULL, (void*)&arg__1};
4135 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4131 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4136 if (result) { Py_DECREF(result); }
4132 if (result) { Py_DECREF(result); }
4137 Py_DECREF(obj);
4133 Py_DECREF(obj);
4138 return;
4134 return;
4139 }
4135 }
4140 }
4136 }
4141 SocExplorerPlot::mousePressEvent(arg__1);
4137 SocExplorerPlot::mousePressEvent(arg__1);
4142 }
4138 }
4143 void PythonQtShell_SocExplorerPlot::mouseReleaseEvent(QMouseEvent* arg__1)
4139 void PythonQtShell_SocExplorerPlot::mouseReleaseEvent(QMouseEvent* arg__1)
4144 {
4140 {
4145 if (_wrapper) {
4141 if (_wrapper) {
4146 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseReleaseEvent");
4142 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseReleaseEvent");
4147 PyErr_Clear();
4143 PyErr_Clear();
4148 if (obj && !PythonQtSlotFunction_Check(obj)) {
4144 if (obj && !PythonQtSlotFunction_Check(obj)) {
4149 static const char* argumentList[] ={"" , "QMouseEvent*"};
4145 static const char* argumentList[] ={"" , "QMouseEvent*"};
4150 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4146 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4151 void* args[2] = {NULL, (void*)&arg__1};
4147 void* args[2] = {NULL, (void*)&arg__1};
4152 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4148 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4153 if (result) { Py_DECREF(result); }
4149 if (result) { Py_DECREF(result); }
4154 Py_DECREF(obj);
4150 Py_DECREF(obj);
4155 return;
4151 return;
4156 }
4152 }
4157 }
4153 }
4158 SocExplorerPlot::mouseReleaseEvent(arg__1);
4154 SocExplorerPlot::mouseReleaseEvent(arg__1);
4159 }
4155 }
4160 void PythonQtShell_SocExplorerPlot::moveEvent(QMoveEvent* arg__1)
4156 void PythonQtShell_SocExplorerPlot::moveEvent(QMoveEvent* arg__1)
4161 {
4157 {
4162 if (_wrapper) {
4158 if (_wrapper) {
4163 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "moveEvent");
4159 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "moveEvent");
4164 PyErr_Clear();
4160 PyErr_Clear();
4165 if (obj && !PythonQtSlotFunction_Check(obj)) {
4161 if (obj && !PythonQtSlotFunction_Check(obj)) {
4166 static const char* argumentList[] ={"" , "QMoveEvent*"};
4162 static const char* argumentList[] ={"" , "QMoveEvent*"};
4167 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4163 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4168 void* args[2] = {NULL, (void*)&arg__1};
4164 void* args[2] = {NULL, (void*)&arg__1};
4169 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4165 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4170 if (result) { Py_DECREF(result); }
4166 if (result) { Py_DECREF(result); }
4171 Py_DECREF(obj);
4167 Py_DECREF(obj);
4172 return;
4168 return;
4173 }
4169 }
4174 }
4170 }
4175 SocExplorerPlot::moveEvent(arg__1);
4171 SocExplorerPlot::moveEvent(arg__1);
4176 }
4172 }
4177 bool PythonQtShell_SocExplorerPlot::nativeEvent(const QByteArray& eventType, void* message, long* result)
4173 bool PythonQtShell_SocExplorerPlot::nativeEvent(const QByteArray& eventType, void* message, long* result)
4178 {
4174 {
4179 if (_wrapper) {
4175 if (_wrapper) {
4180 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "nativeEvent");
4176 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "nativeEvent");
4181 PyErr_Clear();
4177 PyErr_Clear();
4182 if (obj && !PythonQtSlotFunction_Check(obj)) {
4178 if (obj && !PythonQtSlotFunction_Check(obj)) {
4183 static const char* argumentList[] ={"bool" , "const QByteArray&" , "void*" , "long*"};
4179 static const char* argumentList[] ={"bool" , "const QByteArray&" , "void*" , "long*"};
4184 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
4180 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
4185 bool returnValue;
4181 bool returnValue;
4186 void* args[4] = {NULL, (void*)&eventType, (void*)&message, (void*)&result};
4182 void* args[4] = {NULL, (void*)&eventType, (void*)&message, (void*)&result};
4187 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4183 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4188 if (result) {
4184 if (result) {
4189 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
4185 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
4190 if (args[0]!=&returnValue) {
4186 if (args[0]!=&returnValue) {
4191 if (args[0]==NULL) {
4187 if (args[0]==NULL) {
4192 PythonQt::priv()->handleVirtualOverloadReturnError("nativeEvent", methodInfo, result);
4188 PythonQt::priv()->handleVirtualOverloadReturnError("nativeEvent", methodInfo, result);
4193 } else {
4189 } else {
4194 returnValue = *((bool*)args[0]);
4190 returnValue = *((bool*)args[0]);
4195 }
4191 }
4196 }
4192 }
4197 }
4193 }
4198 if (result) { Py_DECREF(result); }
4194 if (result) { Py_DECREF(result); }
4199 Py_DECREF(obj);
4195 Py_DECREF(obj);
4200 return returnValue;
4196 return returnValue;
4201 }
4197 }
4202 }
4198 }
4203 return SocExplorerPlot::nativeEvent(eventType, message, result);
4199 return SocExplorerPlot::nativeEvent(eventType, message, result);
4204 }
4200 }
4205 QPaintEngine* PythonQtShell_SocExplorerPlot::paintEngine() const
4201 QPaintEngine* PythonQtShell_SocExplorerPlot::paintEngine() const
4206 {
4202 {
4207 if (_wrapper) {
4203 if (_wrapper) {
4208 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEngine");
4204 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEngine");
4209 PyErr_Clear();
4205 PyErr_Clear();
4210 if (obj && !PythonQtSlotFunction_Check(obj)) {
4206 if (obj && !PythonQtSlotFunction_Check(obj)) {
4211 static const char* argumentList[] ={"QPaintEngine*"};
4207 static const char* argumentList[] ={"QPaintEngine*"};
4212 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
4208 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
4213 QPaintEngine* returnValue;
4209 QPaintEngine* returnValue;
4214 void* args[1] = {NULL};
4210 void* args[1] = {NULL};
4215 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4211 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4216 if (result) {
4212 if (result) {
4217 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
4213 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
4218 if (args[0]!=&returnValue) {
4214 if (args[0]!=&returnValue) {
4219 if (args[0]==NULL) {
4215 if (args[0]==NULL) {
4220 PythonQt::priv()->handleVirtualOverloadReturnError("paintEngine", methodInfo, result);
4216 PythonQt::priv()->handleVirtualOverloadReturnError("paintEngine", methodInfo, result);
4221 } else {
4217 } else {
4222 returnValue = *((QPaintEngine**)args[0]);
4218 returnValue = *((QPaintEngine**)args[0]);
4223 }
4219 }
4224 }
4220 }
4225 }
4221 }
4226 if (result) { Py_DECREF(result); }
4222 if (result) { Py_DECREF(result); }
4227 Py_DECREF(obj);
4223 Py_DECREF(obj);
4228 return returnValue;
4224 return returnValue;
4229 }
4225 }
4230 }
4226 }
4231 return SocExplorerPlot::paintEngine();
4227 return SocExplorerPlot::paintEngine();
4232 }
4228 }
4233 void PythonQtShell_SocExplorerPlot::paintEvent(QPaintEvent* arg__1)
4229 void PythonQtShell_SocExplorerPlot::paintEvent(QPaintEvent* arg__1)
4234 {
4230 {
4235 if (_wrapper) {
4231 if (_wrapper) {
4236 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEvent");
4232 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEvent");
4237 PyErr_Clear();
4233 PyErr_Clear();
4238 if (obj && !PythonQtSlotFunction_Check(obj)) {
4234 if (obj && !PythonQtSlotFunction_Check(obj)) {
4239 static const char* argumentList[] ={"" , "QPaintEvent*"};
4235 static const char* argumentList[] ={"" , "QPaintEvent*"};
4240 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4236 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4241 void* args[2] = {NULL, (void*)&arg__1};
4237 void* args[2] = {NULL, (void*)&arg__1};
4242 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4238 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4243 if (result) { Py_DECREF(result); }
4239 if (result) { Py_DECREF(result); }
4244 Py_DECREF(obj);
4240 Py_DECREF(obj);
4245 return;
4241 return;
4246 }
4242 }
4247 }
4243 }
4248 SocExplorerPlot::paintEvent(arg__1);
4244 SocExplorerPlot::paintEvent(arg__1);
4249 }
4245 }
4250 QPaintDevice* PythonQtShell_SocExplorerPlot::redirected(QPoint* offset) const
4246 QPaintDevice* PythonQtShell_SocExplorerPlot::redirected(QPoint* offset) const
4251 {
4247 {
4252 if (_wrapper) {
4248 if (_wrapper) {
4253 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "redirected");
4249 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "redirected");
4254 PyErr_Clear();
4250 PyErr_Clear();
4255 if (obj && !PythonQtSlotFunction_Check(obj)) {
4251 if (obj && !PythonQtSlotFunction_Check(obj)) {
4256 static const char* argumentList[] ={"QPaintDevice*" , "QPoint*"};
4252 static const char* argumentList[] ={"QPaintDevice*" , "QPoint*"};
4257 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4253 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4258 QPaintDevice* returnValue;
4254 QPaintDevice* returnValue;
4259 void* args[2] = {NULL, (void*)&offset};
4255 void* args[2] = {NULL, (void*)&offset};
4260 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4256 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4261 if (result) {
4257 if (result) {
4262 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
4258 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
4263 if (args[0]!=&returnValue) {
4259 if (args[0]!=&returnValue) {
4264 if (args[0]==NULL) {
4260 if (args[0]==NULL) {
4265 PythonQt::priv()->handleVirtualOverloadReturnError("redirected", methodInfo, result);
4261 PythonQt::priv()->handleVirtualOverloadReturnError("redirected", methodInfo, result);
4266 } else {
4262 } else {
4267 returnValue = *((QPaintDevice**)args[0]);
4263 returnValue = *((QPaintDevice**)args[0]);
4268 }
4264 }
4269 }
4265 }
4270 }
4266 }
4271 if (result) { Py_DECREF(result); }
4267 if (result) { Py_DECREF(result); }
4272 Py_DECREF(obj);
4268 Py_DECREF(obj);
4273 return returnValue;
4269 return returnValue;
4274 }
4270 }
4275 }
4271 }
4276 return SocExplorerPlot::redirected(offset);
4272 return SocExplorerPlot::redirected(offset);
4277 }
4273 }
4278 void PythonQtShell_SocExplorerPlot::resizeEvent(QResizeEvent* arg__1)
4274 void PythonQtShell_SocExplorerPlot::resizeEvent(QResizeEvent* arg__1)
4279 {
4275 {
4280 if (_wrapper) {
4276 if (_wrapper) {
4281 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "resizeEvent");
4277 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "resizeEvent");
4282 PyErr_Clear();
4278 PyErr_Clear();
4283 if (obj && !PythonQtSlotFunction_Check(obj)) {
4279 if (obj && !PythonQtSlotFunction_Check(obj)) {
4284 static const char* argumentList[] ={"" , "QResizeEvent*"};
4280 static const char* argumentList[] ={"" , "QResizeEvent*"};
4285 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4281 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4286 void* args[2] = {NULL, (void*)&arg__1};
4282 void* args[2] = {NULL, (void*)&arg__1};
4287 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4283 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4288 if (result) { Py_DECREF(result); }
4284 if (result) { Py_DECREF(result); }
4289 Py_DECREF(obj);
4285 Py_DECREF(obj);
4290 return;
4286 return;
4291 }
4287 }
4292 }
4288 }
4293 SocExplorerPlot::resizeEvent(arg__1);
4289 SocExplorerPlot::resizeEvent(arg__1);
4294 }
4290 }
4295 QPainter* PythonQtShell_SocExplorerPlot::sharedPainter() const
4291 QPainter* PythonQtShell_SocExplorerPlot::sharedPainter() const
4296 {
4292 {
4297 if (_wrapper) {
4293 if (_wrapper) {
4298 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "sharedPainter");
4294 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "sharedPainter");
4299 PyErr_Clear();
4295 PyErr_Clear();
4300 if (obj && !PythonQtSlotFunction_Check(obj)) {
4296 if (obj && !PythonQtSlotFunction_Check(obj)) {
4301 static const char* argumentList[] ={"QPainter*"};
4297 static const char* argumentList[] ={"QPainter*"};
4302 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
4298 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
4303 QPainter* returnValue;
4299 QPainter* returnValue;
4304 void* args[1] = {NULL};
4300 void* args[1] = {NULL};
4305 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4301 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4306 if (result) {
4302 if (result) {
4307 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
4303 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
4308 if (args[0]!=&returnValue) {
4304 if (args[0]!=&returnValue) {
4309 if (args[0]==NULL) {
4305 if (args[0]==NULL) {
4310 PythonQt::priv()->handleVirtualOverloadReturnError("sharedPainter", methodInfo, result);
4306 PythonQt::priv()->handleVirtualOverloadReturnError("sharedPainter", methodInfo, result);
4311 } else {
4307 } else {
4312 returnValue = *((QPainter**)args[0]);
4308 returnValue = *((QPainter**)args[0]);
4313 }
4309 }
4314 }
4310 }
4315 }
4311 }
4316 if (result) { Py_DECREF(result); }
4312 if (result) { Py_DECREF(result); }
4317 Py_DECREF(obj);
4313 Py_DECREF(obj);
4318 return returnValue;
4314 return returnValue;
4319 }
4315 }
4320 }
4316 }
4321 return SocExplorerPlot::sharedPainter();
4317 return SocExplorerPlot::sharedPainter();
4322 }
4318 }
4323 void PythonQtShell_SocExplorerPlot::showEvent(QShowEvent* arg__1)
4319 void PythonQtShell_SocExplorerPlot::showEvent(QShowEvent* arg__1)
4324 {
4320 {
4325 if (_wrapper) {
4321 if (_wrapper) {
4326 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "showEvent");
4322 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "showEvent");
4327 PyErr_Clear();
4323 PyErr_Clear();
4328 if (obj && !PythonQtSlotFunction_Check(obj)) {
4324 if (obj && !PythonQtSlotFunction_Check(obj)) {
4329 static const char* argumentList[] ={"" , "QShowEvent*"};
4325 static const char* argumentList[] ={"" , "QShowEvent*"};
4330 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4326 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4331 void* args[2] = {NULL, (void*)&arg__1};
4327 void* args[2] = {NULL, (void*)&arg__1};
4332 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4328 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4333 if (result) { Py_DECREF(result); }
4329 if (result) { Py_DECREF(result); }
4334 Py_DECREF(obj);
4330 Py_DECREF(obj);
4335 return;
4331 return;
4336 }
4332 }
4337 }
4333 }
4338 SocExplorerPlot::showEvent(arg__1);
4334 SocExplorerPlot::showEvent(arg__1);
4339 }
4335 }
4340 QSize PythonQtShell_SocExplorerPlot::sizeHint() const
4336 QSize PythonQtShell_SocExplorerPlot::sizeHint() const
4341 {
4337 {
4342 if (_wrapper) {
4338 if (_wrapper) {
4343 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getSizeHint");
4339 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getSizeHint");
4344 PyErr_Clear();
4340 PyErr_Clear();
4345 if (obj && !PythonQtSlotFunction_Check(obj)) {
4341 if (obj && !PythonQtSlotFunction_Check(obj)) {
4346 static const char* argumentList[] ={"QSize"};
4342 static const char* argumentList[] ={"QSize"};
4347 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
4343 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
4348 QSize returnValue;
4344 QSize returnValue;
4349 void* args[1] = {NULL};
4345 void* args[1] = {NULL};
4350 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4346 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4351 if (result) {
4347 if (result) {
4352 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
4348 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
4353 if (args[0]!=&returnValue) {
4349 if (args[0]!=&returnValue) {
4354 if (args[0]==NULL) {
4350 if (args[0]==NULL) {
4355 PythonQt::priv()->handleVirtualOverloadReturnError("getSizeHint", methodInfo, result);
4351 PythonQt::priv()->handleVirtualOverloadReturnError("getSizeHint", methodInfo, result);
4356 } else {
4352 } else {
4357 returnValue = *((QSize*)args[0]);
4353 returnValue = *((QSize*)args[0]);
4358 }
4354 }
4359 }
4355 }
4360 }
4356 }
4361 if (result) { Py_DECREF(result); }
4357 if (result) { Py_DECREF(result); }
4362 Py_DECREF(obj);
4358 Py_DECREF(obj);
4363 return returnValue;
4359 return returnValue;
4364 }
4360 }
4365 }
4361 }
4366 return SocExplorerPlot::sizeHint();
4362 return SocExplorerPlot::sizeHint();
4367 }
4363 }
4368 void PythonQtShell_SocExplorerPlot::tabletEvent(QTabletEvent* arg__1)
4364 void PythonQtShell_SocExplorerPlot::tabletEvent(QTabletEvent* arg__1)
4369 {
4365 {
4370 if (_wrapper) {
4366 if (_wrapper) {
4371 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "tabletEvent");
4367 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "tabletEvent");
4372 PyErr_Clear();
4368 PyErr_Clear();
4373 if (obj && !PythonQtSlotFunction_Check(obj)) {
4369 if (obj && !PythonQtSlotFunction_Check(obj)) {
4374 static const char* argumentList[] ={"" , "QTabletEvent*"};
4370 static const char* argumentList[] ={"" , "QTabletEvent*"};
4375 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4371 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4376 void* args[2] = {NULL, (void*)&arg__1};
4372 void* args[2] = {NULL, (void*)&arg__1};
4377 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4373 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4378 if (result) { Py_DECREF(result); }
4374 if (result) { Py_DECREF(result); }
4379 Py_DECREF(obj);
4375 Py_DECREF(obj);
4380 return;
4376 return;
4381 }
4377 }
4382 }
4378 }
4383 SocExplorerPlot::tabletEvent(arg__1);
4379 SocExplorerPlot::tabletEvent(arg__1);
4384 }
4380 }
4385 void PythonQtShell_SocExplorerPlot::timerEvent(QTimerEvent* arg__1)
4381 void PythonQtShell_SocExplorerPlot::timerEvent(QTimerEvent* arg__1)
4386 {
4382 {
4387 if (_wrapper) {
4383 if (_wrapper) {
4388 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "timerEvent");
4384 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "timerEvent");
4389 PyErr_Clear();
4385 PyErr_Clear();
4390 if (obj && !PythonQtSlotFunction_Check(obj)) {
4386 if (obj && !PythonQtSlotFunction_Check(obj)) {
4391 static const char* argumentList[] ={"" , "QTimerEvent*"};
4387 static const char* argumentList[] ={"" , "QTimerEvent*"};
4392 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4388 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4393 void* args[2] = {NULL, (void*)&arg__1};
4389 void* args[2] = {NULL, (void*)&arg__1};
4394 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4390 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4395 if (result) { Py_DECREF(result); }
4391 if (result) { Py_DECREF(result); }
4396 Py_DECREF(obj);
4392 Py_DECREF(obj);
4397 return;
4393 return;
4398 }
4394 }
4399 }
4395 }
4400 SocExplorerPlot::timerEvent(arg__1);
4396 SocExplorerPlot::timerEvent(arg__1);
4401 }
4397 }
4402 void PythonQtShell_SocExplorerPlot::wheelEvent(QWheelEvent* arg__1)
4398 void PythonQtShell_SocExplorerPlot::wheelEvent(QWheelEvent* arg__1)
4403 {
4399 {
4404 if (_wrapper) {
4400 if (_wrapper) {
4405 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "wheelEvent");
4401 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "wheelEvent");
4406 PyErr_Clear();
4402 PyErr_Clear();
4407 if (obj && !PythonQtSlotFunction_Check(obj)) {
4403 if (obj && !PythonQtSlotFunction_Check(obj)) {
4408 static const char* argumentList[] ={"" , "QWheelEvent*"};
4404 static const char* argumentList[] ={"" , "QWheelEvent*"};
4409 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4405 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4410 void* args[2] = {NULL, (void*)&arg__1};
4406 void* args[2] = {NULL, (void*)&arg__1};
4411 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4407 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4412 if (result) { Py_DECREF(result); }
4408 if (result) { Py_DECREF(result); }
4413 Py_DECREF(obj);
4409 Py_DECREF(obj);
4414 return;
4410 return;
4415 }
4411 }
4416 }
4412 }
4417 SocExplorerPlot::wheelEvent(arg__1);
4413 SocExplorerPlot::wheelEvent(arg__1);
4418 }
4414 }
4419 SocExplorerPlot* PythonQtWrapper_SocExplorerPlot::new_SocExplorerPlot(QWidget* parent)
4415 SocExplorerPlot* PythonQtWrapper_SocExplorerPlot::new_SocExplorerPlot(QWidget* parent)
4420 {
4416 {
4421 return new PythonQtShell_SocExplorerPlot(parent); }
4417 return new PythonQtShell_SocExplorerPlot(parent); }
4422
4418
4423 int PythonQtWrapper_SocExplorerPlot::addGraph(SocExplorerPlot* theWrappedObject)
4419 int PythonQtWrapper_SocExplorerPlot::addGraph(SocExplorerPlot* theWrappedObject)
4424 {
4420 {
4425 return ( theWrappedObject->addGraph());
4421 return ( theWrappedObject->addGraph());
4426 }
4422 }
4427
4423
4428 void PythonQtWrapper_SocExplorerPlot::addGraphData(SocExplorerPlot* theWrappedObject, int graphIndex, QList<QVariant > x, QList<QVariant > y)
4424 void PythonQtWrapper_SocExplorerPlot::addGraphData(SocExplorerPlot* theWrappedObject, int graphIndex, QList<QVariant > x, QList<QVariant > y)
4429 {
4425 {
4430 ( theWrappedObject->addGraphData(graphIndex, x, y));
4426 ( theWrappedObject->addGraphData(graphIndex, x, y));
4431 }
4427 }
4432
4428
4433 void PythonQtWrapper_SocExplorerPlot::addGraphData(SocExplorerPlot* theWrappedObject, int graphIndex, QVariant x, QVariant y)
4429 void PythonQtWrapper_SocExplorerPlot::addGraphData(SocExplorerPlot* theWrappedObject, int graphIndex, QVariant x, QVariant y)
4434 {
4430 {
4435 ( theWrappedObject->addGraphData(graphIndex, x, y));
4431 ( theWrappedObject->addGraphData(graphIndex, x, y));
4436 }
4432 }
4437
4433
4438 QPen PythonQtWrapper_SocExplorerPlot::getGraphPen(SocExplorerPlot* theWrappedObject, int graphIndex)
4434 QPen PythonQtWrapper_SocExplorerPlot::getGraphPen(SocExplorerPlot* theWrappedObject, int graphIndex)
4439 {
4435 {
4440 return ( theWrappedObject->getGraphPen(graphIndex));
4436 return ( theWrappedObject->getGraphPen(graphIndex));
4441 }
4437 }
4442
4438
4443 void PythonQtWrapper_SocExplorerPlot::keyPressEvent(SocExplorerPlot* theWrappedObject, QKeyEvent* arg__1)
4439 void PythonQtWrapper_SocExplorerPlot::keyPressEvent(SocExplorerPlot* theWrappedObject, QKeyEvent* arg__1)
4444 {
4440 {
4445 ( ((PythonQtPublicPromoter_SocExplorerPlot*)theWrappedObject)->promoted_keyPressEvent(arg__1));
4441 ( ((PythonQtPublicPromoter_SocExplorerPlot*)theWrappedObject)->promoted_keyPressEvent(arg__1));
4446 }
4442 }
4447
4443
4448 void PythonQtWrapper_SocExplorerPlot::keyReleaseEvent(SocExplorerPlot* theWrappedObject, QKeyEvent* arg__1)
4444 void PythonQtWrapper_SocExplorerPlot::keyReleaseEvent(SocExplorerPlot* theWrappedObject, QKeyEvent* arg__1)
4449 {
4445 {
4450 ( ((PythonQtPublicPromoter_SocExplorerPlot*)theWrappedObject)->promoted_keyReleaseEvent(arg__1));
4446 ( ((PythonQtPublicPromoter_SocExplorerPlot*)theWrappedObject)->promoted_keyReleaseEvent(arg__1));
4451 }
4447 }
4452
4448
4453 void PythonQtWrapper_SocExplorerPlot::mouseMoveEvent(SocExplorerPlot* theWrappedObject, QMouseEvent* arg__1)
4449 void PythonQtWrapper_SocExplorerPlot::mouseMoveEvent(SocExplorerPlot* theWrappedObject, QMouseEvent* arg__1)
4454 {
4450 {
4455 ( ((PythonQtPublicPromoter_SocExplorerPlot*)theWrappedObject)->promoted_mouseMoveEvent(arg__1));
4451 ( ((PythonQtPublicPromoter_SocExplorerPlot*)theWrappedObject)->promoted_mouseMoveEvent(arg__1));
4456 }
4452 }
4457
4453
4458 void PythonQtWrapper_SocExplorerPlot::mousePressEvent(SocExplorerPlot* theWrappedObject, QMouseEvent* arg__1)
4454 void PythonQtWrapper_SocExplorerPlot::mousePressEvent(SocExplorerPlot* theWrappedObject, QMouseEvent* arg__1)
4459 {
4455 {
4460 ( ((PythonQtPublicPromoter_SocExplorerPlot*)theWrappedObject)->promoted_mousePressEvent(arg__1));
4456 ( ((PythonQtPublicPromoter_SocExplorerPlot*)theWrappedObject)->promoted_mousePressEvent(arg__1));
4461 }
4457 }
4462
4458
4463 void PythonQtWrapper_SocExplorerPlot::mouseReleaseEvent(SocExplorerPlot* theWrappedObject, QMouseEvent* arg__1)
4459 void PythonQtWrapper_SocExplorerPlot::mouseReleaseEvent(SocExplorerPlot* theWrappedObject, QMouseEvent* arg__1)
4464 {
4460 {
4465 ( ((PythonQtPublicPromoter_SocExplorerPlot*)theWrappedObject)->promoted_mouseReleaseEvent(arg__1));
4461 ( ((PythonQtPublicPromoter_SocExplorerPlot*)theWrappedObject)->promoted_mouseReleaseEvent(arg__1));
4466 }
4462 }
4467
4463
4468 void PythonQtWrapper_SocExplorerPlot::rescaleAxis(SocExplorerPlot* theWrappedObject)
4464 void PythonQtWrapper_SocExplorerPlot::rescaleAxis(SocExplorerPlot* theWrappedObject)
4469 {
4465 {
4470 ( theWrappedObject->rescaleAxis());
4466 ( theWrappedObject->rescaleAxis());
4471 }
4467 }
4472
4468
4473 void PythonQtWrapper_SocExplorerPlot::setAdaptativeSampling(SocExplorerPlot* theWrappedObject, int graphIndex, bool enable)
4469 void PythonQtWrapper_SocExplorerPlot::setAdaptativeSampling(SocExplorerPlot* theWrappedObject, int graphIndex, bool enable)
4474 {
4470 {
4475 ( theWrappedObject->setAdaptativeSampling(graphIndex, enable));
4471 ( theWrappedObject->setAdaptativeSampling(graphIndex, enable));
4476 }
4472 }
4477
4473
4478 void PythonQtWrapper_SocExplorerPlot::setGraphData(SocExplorerPlot* theWrappedObject, int graphIndex, QList<QVariant > x, QList<QVariant > y)
4474 void PythonQtWrapper_SocExplorerPlot::setGraphData(SocExplorerPlot* theWrappedObject, int graphIndex, QList<QVariant > x, QList<QVariant > y)
4479 {
4475 {
4480 ( theWrappedObject->setGraphData(graphIndex, x, y));
4476 ( theWrappedObject->setGraphData(graphIndex, x, y));
4481 }
4477 }
4482
4478
4483 void PythonQtWrapper_SocExplorerPlot::setGraphLineStyle(SocExplorerPlot* theWrappedObject, int graphIndex, QString lineStyle)
4479 void PythonQtWrapper_SocExplorerPlot::setGraphLineStyle(SocExplorerPlot* theWrappedObject, int graphIndex, QString lineStyle)
4484 {
4480 {
4485 ( theWrappedObject->setGraphLineStyle(graphIndex, lineStyle));
4481 ( theWrappedObject->setGraphLineStyle(graphIndex, lineStyle));
4486 }
4482 }
4487
4483
4488 void PythonQtWrapper_SocExplorerPlot::setGraphName(SocExplorerPlot* theWrappedObject, int graphIndex, QString name)
4484 void PythonQtWrapper_SocExplorerPlot::setGraphName(SocExplorerPlot* theWrappedObject, int graphIndex, QString name)
4489 {
4485 {
4490 ( theWrappedObject->setGraphName(graphIndex, name));
4486 ( theWrappedObject->setGraphName(graphIndex, name));
4491 }
4487 }
4492
4488
4493 void PythonQtWrapper_SocExplorerPlot::setGraphPen(SocExplorerPlot* theWrappedObject, int graphIndex, QPen pen)
4489 void PythonQtWrapper_SocExplorerPlot::setGraphPen(SocExplorerPlot* theWrappedObject, int graphIndex, QPen pen)
4494 {
4490 {
4495 ( theWrappedObject->setGraphPen(graphIndex, pen));
4491 ( theWrappedObject->setGraphPen(graphIndex, pen));
4496 }
4492 }
4497
4493
4498 void PythonQtWrapper_SocExplorerPlot::setGraphScatterStyle(SocExplorerPlot* theWrappedObject, int graphIndex, QString scatterStyle)
4494 void PythonQtWrapper_SocExplorerPlot::setGraphScatterStyle(SocExplorerPlot* theWrappedObject, int graphIndex, QString scatterStyle)
4499 {
4495 {
4500 ( theWrappedObject->setGraphScatterStyle(graphIndex, scatterStyle));
4496 ( theWrappedObject->setGraphScatterStyle(graphIndex, scatterStyle));
4501 }
4497 }
4502
4498
4503 void PythonQtWrapper_SocExplorerPlot::setLegendFont(SocExplorerPlot* theWrappedObject, QFont font)
4499 void PythonQtWrapper_SocExplorerPlot::setLegendFont(SocExplorerPlot* theWrappedObject, QFont font)
4504 {
4500 {
4505 ( theWrappedObject->setLegendFont(font));
4501 ( theWrappedObject->setLegendFont(font));
4506 }
4502 }
4507
4503
4508 void PythonQtWrapper_SocExplorerPlot::setLegendSelectedFont(SocExplorerPlot* theWrappedObject, QFont font)
4504 void PythonQtWrapper_SocExplorerPlot::setLegendSelectedFont(SocExplorerPlot* theWrappedObject, QFont font)
4509 {
4505 {
4510 ( theWrappedObject->setLegendSelectedFont(font));
4506 ( theWrappedObject->setLegendSelectedFont(font));
4511 }
4507 }
4512
4508
4513 void PythonQtWrapper_SocExplorerPlot::setTitle(SocExplorerPlot* theWrappedObject, QString title)
4509 void PythonQtWrapper_SocExplorerPlot::setTitle(SocExplorerPlot* theWrappedObject, QString title)
4514 {
4510 {
4515 ( theWrappedObject->setTitle(title));
4511 ( theWrappedObject->setTitle(title));
4516 }
4512 }
4517
4513
4518 void PythonQtWrapper_SocExplorerPlot::setXaxisLabel(SocExplorerPlot* theWrappedObject, QString label)
4514 void PythonQtWrapper_SocExplorerPlot::setXaxisLabel(SocExplorerPlot* theWrappedObject, QString label)
4519 {
4515 {
4520 ( theWrappedObject->setXaxisLabel(label));
4516 ( theWrappedObject->setXaxisLabel(label));
4521 }
4517 }
4522
4518
4523 void PythonQtWrapper_SocExplorerPlot::setXaxisRange(SocExplorerPlot* theWrappedObject, double lower, double upper)
4519 void PythonQtWrapper_SocExplorerPlot::setXaxisRange(SocExplorerPlot* theWrappedObject, double lower, double upper)
4524 {
4520 {
4525 ( theWrappedObject->setXaxisRange(lower, upper));
4521 ( theWrappedObject->setXaxisRange(lower, upper));
4526 }
4522 }
4527
4523
4528 void PythonQtWrapper_SocExplorerPlot::setYaxisLabel(SocExplorerPlot* theWrappedObject, QString label)
4524 void PythonQtWrapper_SocExplorerPlot::setYaxisLabel(SocExplorerPlot* theWrappedObject, QString label)
4529 {
4525 {
4530 ( theWrappedObject->setYaxisLabel(label));
4526 ( theWrappedObject->setYaxisLabel(label));
4531 }
4527 }
4532
4528
4533 void PythonQtWrapper_SocExplorerPlot::setYaxisRange(SocExplorerPlot* theWrappedObject, double lower, double upper)
4529 void PythonQtWrapper_SocExplorerPlot::setYaxisRange(SocExplorerPlot* theWrappedObject, double lower, double upper)
4534 {
4530 {
4535 ( theWrappedObject->setYaxisRange(lower, upper));
4531 ( theWrappedObject->setYaxisRange(lower, upper));
4536 }
4532 }
4537
4533
4538 void PythonQtWrapper_SocExplorerPlot::show(SocExplorerPlot* theWrappedObject)
4534 void PythonQtWrapper_SocExplorerPlot::show(SocExplorerPlot* theWrappedObject)
4539 {
4535 {
4540 ( theWrappedObject->show());
4536 ( theWrappedObject->show());
4541 }
4537 }
4542
4538
4543 void PythonQtWrapper_SocExplorerPlot::wheelEvent(SocExplorerPlot* theWrappedObject, QWheelEvent* arg__1)
4539 void PythonQtWrapper_SocExplorerPlot::wheelEvent(SocExplorerPlot* theWrappedObject, QWheelEvent* arg__1)
4544 {
4540 {
4545 ( ((PythonQtPublicPromoter_SocExplorerPlot*)theWrappedObject)->promoted_wheelEvent(arg__1));
4541 ( ((PythonQtPublicPromoter_SocExplorerPlot*)theWrappedObject)->promoted_wheelEvent(arg__1));
4546 }
4542 }
4547
4543
4548
4544
4549
4545
4550 PythonQtShell_TCP_Terminal_Client::~PythonQtShell_TCP_Terminal_Client() {
4546 PythonQtShell_TCP_Terminal_Client::~PythonQtShell_TCP_Terminal_Client() {
4551 PythonQtPrivate* priv = PythonQt::priv();
4547 PythonQtPrivate* priv = PythonQt::priv();
4552 if (priv) { priv->shellClassDeleted(this); }
4548 if (priv) { priv->shellClassDeleted(this); }
4553 }
4549 }
4554 void PythonQtShell_TCP_Terminal_Client::childEvent(QChildEvent* arg__1)
4550 void PythonQtShell_TCP_Terminal_Client::childEvent(QChildEvent* arg__1)
4555 {
4551 {
4556 if (_wrapper) {
4552 if (_wrapper) {
4557 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "childEvent");
4553 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "childEvent");
4558 PyErr_Clear();
4554 PyErr_Clear();
4559 if (obj && !PythonQtSlotFunction_Check(obj)) {
4555 if (obj && !PythonQtSlotFunction_Check(obj)) {
4560 static const char* argumentList[] ={"" , "QChildEvent*"};
4556 static const char* argumentList[] ={"" , "QChildEvent*"};
4561 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4557 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4562 void* args[2] = {NULL, (void*)&arg__1};
4558 void* args[2] = {NULL, (void*)&arg__1};
4563 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4559 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4564 if (result) { Py_DECREF(result); }
4560 if (result) { Py_DECREF(result); }
4565 Py_DECREF(obj);
4561 Py_DECREF(obj);
4566 return;
4562 return;
4567 }
4563 }
4568 }
4564 }
4569 TCP_Terminal_Client::childEvent(arg__1);
4565 TCP_Terminal_Client::childEvent(arg__1);
4570 }
4566 }
4571 void PythonQtShell_TCP_Terminal_Client::customEvent(QEvent* arg__1)
4567 void PythonQtShell_TCP_Terminal_Client::customEvent(QEvent* arg__1)
4572 {
4568 {
4573 if (_wrapper) {
4569 if (_wrapper) {
4574 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "customEvent");
4570 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "customEvent");
4575 PyErr_Clear();
4571 PyErr_Clear();
4576 if (obj && !PythonQtSlotFunction_Check(obj)) {
4572 if (obj && !PythonQtSlotFunction_Check(obj)) {
4577 static const char* argumentList[] ={"" , "QEvent*"};
4573 static const char* argumentList[] ={"" , "QEvent*"};
4578 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4574 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4579 void* args[2] = {NULL, (void*)&arg__1};
4575 void* args[2] = {NULL, (void*)&arg__1};
4580 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4576 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4581 if (result) { Py_DECREF(result); }
4577 if (result) { Py_DECREF(result); }
4582 Py_DECREF(obj);
4578 Py_DECREF(obj);
4583 return;
4579 return;
4584 }
4580 }
4585 }
4581 }
4586 TCP_Terminal_Client::customEvent(arg__1);
4582 TCP_Terminal_Client::customEvent(arg__1);
4587 }
4583 }
4588 bool PythonQtShell_TCP_Terminal_Client::event(QEvent* arg__1)
4584 bool PythonQtShell_TCP_Terminal_Client::event(QEvent* arg__1)
4589 {
4585 {
4590 if (_wrapper) {
4586 if (_wrapper) {
4591 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "event");
4587 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "event");
4592 PyErr_Clear();
4588 PyErr_Clear();
4593 if (obj && !PythonQtSlotFunction_Check(obj)) {
4589 if (obj && !PythonQtSlotFunction_Check(obj)) {
4594 static const char* argumentList[] ={"bool" , "QEvent*"};
4590 static const char* argumentList[] ={"bool" , "QEvent*"};
4595 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4591 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4596 bool returnValue;
4592 bool returnValue;
4597 void* args[2] = {NULL, (void*)&arg__1};
4593 void* args[2] = {NULL, (void*)&arg__1};
4598 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4594 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4599 if (result) {
4595 if (result) {
4600 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
4596 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
4601 if (args[0]!=&returnValue) {
4597 if (args[0]!=&returnValue) {
4602 if (args[0]==NULL) {
4598 if (args[0]==NULL) {
4603 PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
4599 PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
4604 } else {
4600 } else {
4605 returnValue = *((bool*)args[0]);
4601 returnValue = *((bool*)args[0]);
4606 }
4602 }
4607 }
4603 }
4608 }
4604 }
4609 if (result) { Py_DECREF(result); }
4605 if (result) { Py_DECREF(result); }
4610 Py_DECREF(obj);
4606 Py_DECREF(obj);
4611 return returnValue;
4607 return returnValue;
4612 }
4608 }
4613 }
4609 }
4614 return TCP_Terminal_Client::event(arg__1);
4610 return TCP_Terminal_Client::event(arg__1);
4615 }
4611 }
4616 bool PythonQtShell_TCP_Terminal_Client::eventFilter(QObject* arg__1, QEvent* arg__2)
4612 bool PythonQtShell_TCP_Terminal_Client::eventFilter(QObject* arg__1, QEvent* arg__2)
4617 {
4613 {
4618 if (_wrapper) {
4614 if (_wrapper) {
4619 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "eventFilter");
4615 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "eventFilter");
4620 PyErr_Clear();
4616 PyErr_Clear();
4621 if (obj && !PythonQtSlotFunction_Check(obj)) {
4617 if (obj && !PythonQtSlotFunction_Check(obj)) {
4622 static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
4618 static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
4623 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
4619 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
4624 bool returnValue;
4620 bool returnValue;
4625 void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2};
4621 void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2};
4626 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4622 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4627 if (result) {
4623 if (result) {
4628 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
4624 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
4629 if (args[0]!=&returnValue) {
4625 if (args[0]!=&returnValue) {
4630 if (args[0]==NULL) {
4626 if (args[0]==NULL) {
4631 PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
4627 PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
4632 } else {
4628 } else {
4633 returnValue = *((bool*)args[0]);
4629 returnValue = *((bool*)args[0]);
4634 }
4630 }
4635 }
4631 }
4636 }
4632 }
4637 if (result) { Py_DECREF(result); }
4633 if (result) { Py_DECREF(result); }
4638 Py_DECREF(obj);
4634 Py_DECREF(obj);
4639 return returnValue;
4635 return returnValue;
4640 }
4636 }
4641 }
4637 }
4642 return TCP_Terminal_Client::eventFilter(arg__1, arg__2);
4638 return TCP_Terminal_Client::eventFilter(arg__1, arg__2);
4643 }
4639 }
4644 void PythonQtShell_TCP_Terminal_Client::timerEvent(QTimerEvent* arg__1)
4640 void PythonQtShell_TCP_Terminal_Client::timerEvent(QTimerEvent* arg__1)
4645 {
4641 {
4646 if (_wrapper) {
4642 if (_wrapper) {
4647 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "timerEvent");
4643 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "timerEvent");
4648 PyErr_Clear();
4644 PyErr_Clear();
4649 if (obj && !PythonQtSlotFunction_Check(obj)) {
4645 if (obj && !PythonQtSlotFunction_Check(obj)) {
4650 static const char* argumentList[] ={"" , "QTimerEvent*"};
4646 static const char* argumentList[] ={"" , "QTimerEvent*"};
4651 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4647 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4652 void* args[2] = {NULL, (void*)&arg__1};
4648 void* args[2] = {NULL, (void*)&arg__1};
4653 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4649 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4654 if (result) { Py_DECREF(result); }
4650 if (result) { Py_DECREF(result); }
4655 Py_DECREF(obj);
4651 Py_DECREF(obj);
4656 return;
4652 return;
4657 }
4653 }
4658 }
4654 }
4659 TCP_Terminal_Client::timerEvent(arg__1);
4655 TCP_Terminal_Client::timerEvent(arg__1);
4660 }
4656 }
4661 TCP_Terminal_Client* PythonQtWrapper_TCP_Terminal_Client::new_TCP_Terminal_Client(QObject* parent)
4657 TCP_Terminal_Client* PythonQtWrapper_TCP_Terminal_Client::new_TCP_Terminal_Client(QObject* parent)
4662 {
4658 {
4663 return new PythonQtShell_TCP_Terminal_Client(parent); }
4659 return new PythonQtShell_TCP_Terminal_Client(parent); }
4664
4660
4665 void PythonQtWrapper_TCP_Terminal_Client::connectToServer(TCP_Terminal_Client* theWrappedObject)
4661 void PythonQtWrapper_TCP_Terminal_Client::connectToServer(TCP_Terminal_Client* theWrappedObject)
4666 {
4662 {
4667 ( theWrappedObject->connectToServer());
4663 ( theWrappedObject->connectToServer());
4668 }
4664 }
4669
4665
4670 void PythonQtWrapper_TCP_Terminal_Client::connectToServer(TCP_Terminal_Client* theWrappedObject, const QString& IP, int port)
4666 void PythonQtWrapper_TCP_Terminal_Client::connectToServer(TCP_Terminal_Client* theWrappedObject, const QString& IP, int port)
4671 {
4667 {
4672 ( theWrappedObject->connectToServer(IP, port));
4668 ( theWrappedObject->connectToServer(IP, port));
4673 }
4669 }
4674
4670
4675 bool PythonQtWrapper_TCP_Terminal_Client::isConnected(TCP_Terminal_Client* theWrappedObject)
4671 bool PythonQtWrapper_TCP_Terminal_Client::isConnected(TCP_Terminal_Client* theWrappedObject)
4676 {
4672 {
4677 return ( theWrappedObject->isConnected());
4673 return ( theWrappedObject->isConnected());
4678 }
4674 }
4679
4675
4680 void PythonQtWrapper_TCP_Terminal_Client::sendText(TCP_Terminal_Client* theWrappedObject, const QString& text)
4676 void PythonQtWrapper_TCP_Terminal_Client::sendText(TCP_Terminal_Client* theWrappedObject, const QString& text)
4681 {
4677 {
4682 ( theWrappedObject->sendText(text));
4678 ( theWrappedObject->sendText(text));
4683 }
4679 }
4684
4680
4685 void PythonQtWrapper_TCP_Terminal_Client::startServer(TCP_Terminal_Client* theWrappedObject)
4681 void PythonQtWrapper_TCP_Terminal_Client::startServer(TCP_Terminal_Client* theWrappedObject)
4686 {
4682 {
4687 ( theWrappedObject->startServer());
4683 ( theWrappedObject->startServer());
4688 }
4684 }
4689
4685
4690 void PythonQtWrapper_TCP_Terminal_Client::startServer(TCP_Terminal_Client* theWrappedObject, int port)
4686 void PythonQtWrapper_TCP_Terminal_Client::startServer(TCP_Terminal_Client* theWrappedObject, int port)
4691 {
4687 {
4692 ( theWrappedObject->startServer(port));
4688 ( theWrappedObject->startServer(port));
4693 }
4689 }
4694
4690
4695
4691
4696
4692
4697 XByteArray* PythonQtWrapper_XByteArray::new_XByteArray()
4693 XByteArray* PythonQtWrapper_XByteArray::new_XByteArray()
4698 {
4694 {
4699 return new XByteArray(); }
4695 return new XByteArray(); }
4700
4696
4701 int PythonQtWrapper_XByteArray::addressOffset(XByteArray* theWrappedObject)
4697 int PythonQtWrapper_XByteArray::addressOffset(XByteArray* theWrappedObject)
4702 {
4698 {
4703 return ( theWrappedObject->addressOffset());
4699 return ( theWrappedObject->addressOffset());
4704 }
4700 }
4705
4701
4706 int PythonQtWrapper_XByteArray::addressWidth(XByteArray* theWrappedObject)
4702 int PythonQtWrapper_XByteArray::addressWidth(XByteArray* theWrappedObject)
4707 {
4703 {
4708 return ( theWrappedObject->addressWidth());
4704 return ( theWrappedObject->addressWidth());
4709 }
4705 }
4710
4706
4711 QChar PythonQtWrapper_XByteArray::asciiChar(XByteArray* theWrappedObject, int index)
4707 QChar PythonQtWrapper_XByteArray::asciiChar(XByteArray* theWrappedObject, int index)
4712 {
4708 {
4713 return ( theWrappedObject->asciiChar(index));
4709 return ( theWrappedObject->asciiChar(index));
4714 }
4710 }
4715
4711
4716 QByteArray* PythonQtWrapper_XByteArray::data(XByteArray* theWrappedObject)
4712 QByteArray* PythonQtWrapper_XByteArray::data(XByteArray* theWrappedObject)
4717 {
4713 {
4718 return &( theWrappedObject->data());
4714 return &( theWrappedObject->data());
4719 }
4715 }
4720
4716
4721 bool PythonQtWrapper_XByteArray::dataChanged(XByteArray* theWrappedObject, int i)
4717 bool PythonQtWrapper_XByteArray::dataChanged(XByteArray* theWrappedObject, int i)
4722 {
4718 {
4723 return ( theWrappedObject->dataChanged(i));
4719 return ( theWrappedObject->dataChanged(i));
4724 }
4720 }
4725
4721
4726 QByteArray PythonQtWrapper_XByteArray::dataChanged(XByteArray* theWrappedObject, int i, int len)
4722 QByteArray PythonQtWrapper_XByteArray::dataChanged(XByteArray* theWrappedObject, int i, int len)
4727 {
4723 {
4728 return ( theWrappedObject->dataChanged(i, len));
4724 return ( theWrappedObject->dataChanged(i, len));
4729 }
4725 }
4730
4726
4731 QByteArray* PythonQtWrapper_XByteArray::insert(XByteArray* theWrappedObject, int i, char ch)
4727 QByteArray* PythonQtWrapper_XByteArray::insert(XByteArray* theWrappedObject, int i, char ch)
4732 {
4728 {
4733 return &( theWrappedObject->insert(i, ch));
4729 return &( theWrappedObject->insert(i, ch));
4734 }
4730 }
4735
4731
4736 QByteArray* PythonQtWrapper_XByteArray::insert(XByteArray* theWrappedObject, int i, const QByteArray& ba)
4732 QByteArray* PythonQtWrapper_XByteArray::insert(XByteArray* theWrappedObject, int i, const QByteArray& ba)
4737 {
4733 {
4738 return &( theWrappedObject->insert(i, ba));
4734 return &( theWrappedObject->insert(i, ba));
4739 }
4735 }
4740
4736
4741 int PythonQtWrapper_XByteArray::realAddressNumbers(XByteArray* theWrappedObject)
4737 int PythonQtWrapper_XByteArray::realAddressNumbers(XByteArray* theWrappedObject)
4742 {
4738 {
4743 return ( theWrappedObject->realAddressNumbers());
4739 return ( theWrappedObject->realAddressNumbers());
4744 }
4740 }
4745
4741
4746 QByteArray* PythonQtWrapper_XByteArray::remove(XByteArray* theWrappedObject, int pos, int len)
4742 QByteArray* PythonQtWrapper_XByteArray::remove(XByteArray* theWrappedObject, int pos, int len)
4747 {
4743 {
4748 return &( theWrappedObject->remove(pos, len));
4744 return &( theWrappedObject->remove(pos, len));
4749 }
4745 }
4750
4746
4751 QByteArray* PythonQtWrapper_XByteArray::replace(XByteArray* theWrappedObject, int index, char ch)
4747 QByteArray* PythonQtWrapper_XByteArray::replace(XByteArray* theWrappedObject, int index, char ch)
4752 {
4748 {
4753 return &( theWrappedObject->replace(index, ch));
4749 return &( theWrappedObject->replace(index, ch));
4754 }
4750 }
4755
4751
4756 QByteArray* PythonQtWrapper_XByteArray::replace(XByteArray* theWrappedObject, int index, const QByteArray& ba)
4752 QByteArray* PythonQtWrapper_XByteArray::replace(XByteArray* theWrappedObject, int index, const QByteArray& ba)
4757 {
4753 {
4758 return &( theWrappedObject->replace(index, ba));
4754 return &( theWrappedObject->replace(index, ba));
4759 }
4755 }
4760
4756
4761 QByteArray* PythonQtWrapper_XByteArray::replace(XByteArray* theWrappedObject, int index, int length, const QByteArray& ba)
4757 QByteArray* PythonQtWrapper_XByteArray::replace(XByteArray* theWrappedObject, int index, int length, const QByteArray& ba)
4762 {
4758 {
4763 return &( theWrappedObject->replace(index, length, ba));
4759 return &( theWrappedObject->replace(index, length, ba));
4764 }
4760 }
4765
4761
4766 void PythonQtWrapper_XByteArray::setAddressOffset(XByteArray* theWrappedObject, int offset)
4762 void PythonQtWrapper_XByteArray::setAddressOffset(XByteArray* theWrappedObject, int offset)
4767 {
4763 {
4768 ( theWrappedObject->setAddressOffset(offset));
4764 ( theWrappedObject->setAddressOffset(offset));
4769 }
4765 }
4770
4766
4771 void PythonQtWrapper_XByteArray::setAddressWidth(XByteArray* theWrappedObject, int width)
4767 void PythonQtWrapper_XByteArray::setAddressWidth(XByteArray* theWrappedObject, int width)
4772 {
4768 {
4773 ( theWrappedObject->setAddressWidth(width));
4769 ( theWrappedObject->setAddressWidth(width));
4774 }
4770 }
4775
4771
4776 void PythonQtWrapper_XByteArray::setData(XByteArray* theWrappedObject, QByteArray data)
4772 void PythonQtWrapper_XByteArray::setData(XByteArray* theWrappedObject, QByteArray data)
4777 {
4773 {
4778 ( theWrappedObject->setData(data));
4774 ( theWrappedObject->setData(data));
4779 }
4775 }
4780
4776
4781 void PythonQtWrapper_XByteArray::setDataChanged(XByteArray* theWrappedObject, int i, bool state)
4777 void PythonQtWrapper_XByteArray::setDataChanged(XByteArray* theWrappedObject, int i, bool state)
4782 {
4778 {
4783 ( theWrappedObject->setDataChanged(i, state));
4779 ( theWrappedObject->setDataChanged(i, state));
4784 }
4780 }
4785
4781
4786 void PythonQtWrapper_XByteArray::setDataChanged(XByteArray* theWrappedObject, int i, const QByteArray& state)
4782 void PythonQtWrapper_XByteArray::setDataChanged(XByteArray* theWrappedObject, int i, const QByteArray& state)
4787 {
4783 {
4788 ( theWrappedObject->setDataChanged(i, state));
4784 ( theWrappedObject->setDataChanged(i, state));
4789 }
4785 }
4790
4786
4791 int PythonQtWrapper_XByteArray::size(XByteArray* theWrappedObject)
4787 int PythonQtWrapper_XByteArray::size(XByteArray* theWrappedObject)
4792 {
4788 {
4793 return ( theWrappedObject->size());
4789 return ( theWrappedObject->size());
4794 }
4790 }
4795
4791
4796 QString PythonQtWrapper_XByteArray::toRedableString(XByteArray* theWrappedObject, int start, int end)
4792 QString PythonQtWrapper_XByteArray::toRedableString(XByteArray* theWrappedObject, int start, int end)
4797 {
4793 {
4798 return ( theWrappedObject->toRedableString(start, end));
4794 return ( theWrappedObject->toRedableString(start, end));
4799 }
4795 }
4800
4796
4801
4797
4802
4798
4803 PythonQtShell_abstractBinFile::~PythonQtShell_abstractBinFile() {
4799 PythonQtShell_abstractBinFile::~PythonQtShell_abstractBinFile() {
4804 PythonQtPrivate* priv = PythonQt::priv();
4800 PythonQtPrivate* priv = PythonQt::priv();
4805 if (priv) { priv->shellClassDeleted(this); }
4801 if (priv) { priv->shellClassDeleted(this); }
4806 }
4802 }
4807 void PythonQtShell_abstractBinFile::childEvent(QChildEvent* arg__1)
4803 void PythonQtShell_abstractBinFile::childEvent(QChildEvent* arg__1)
4808 {
4804 {
4809 if (_wrapper) {
4805 if (_wrapper) {
4810 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "childEvent");
4806 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "childEvent");
4811 PyErr_Clear();
4807 PyErr_Clear();
4812 if (obj && !PythonQtSlotFunction_Check(obj)) {
4808 if (obj && !PythonQtSlotFunction_Check(obj)) {
4813 static const char* argumentList[] ={"" , "QChildEvent*"};
4809 static const char* argumentList[] ={"" , "QChildEvent*"};
4814 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4810 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4815 void* args[2] = {NULL, (void*)&arg__1};
4811 void* args[2] = {NULL, (void*)&arg__1};
4816 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4812 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4817 if (result) { Py_DECREF(result); }
4813 if (result) { Py_DECREF(result); }
4818 Py_DECREF(obj);
4814 Py_DECREF(obj);
4819 return;
4815 return;
4820 }
4816 }
4821 }
4817 }
4822 abstractBinFile::childEvent(arg__1);
4818 abstractBinFile::childEvent(arg__1);
4823 }
4819 }
4824 int PythonQtShell_abstractBinFile::closeFile()
4820 int PythonQtShell_abstractBinFile::closeFile()
4825 {
4821 {
4826 if (_wrapper) {
4822 if (_wrapper) {
4827 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "closeFile");
4823 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "closeFile");
4828 PyErr_Clear();
4824 PyErr_Clear();
4829 if (obj && !PythonQtSlotFunction_Check(obj)) {
4825 if (obj && !PythonQtSlotFunction_Check(obj)) {
4830 static const char* argumentList[] ={"int"};
4826 static const char* argumentList[] ={"int"};
4831 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
4827 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
4832 int returnValue;
4828 int returnValue;
4833 void* args[1] = {NULL};
4829 void* args[1] = {NULL};
4834 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4830 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4835 if (result) {
4831 if (result) {
4836 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
4832 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
4837 if (args[0]!=&returnValue) {
4833 if (args[0]!=&returnValue) {
4838 if (args[0]==NULL) {
4834 if (args[0]==NULL) {
4839 PythonQt::priv()->handleVirtualOverloadReturnError("closeFile", methodInfo, result);
4835 PythonQt::priv()->handleVirtualOverloadReturnError("closeFile", methodInfo, result);
4840 } else {
4836 } else {
4841 returnValue = *((int*)args[0]);
4837 returnValue = *((int*)args[0]);
4842 }
4838 }
4843 }
4839 }
4844 }
4840 }
4845 if (result) { Py_DECREF(result); }
4841 if (result) { Py_DECREF(result); }
4846 Py_DECREF(obj);
4842 Py_DECREF(obj);
4847 return returnValue;
4843 return returnValue;
4848 }
4844 }
4849 }
4845 }
4850 return int();
4846 return int();
4851 }
4847 }
4852 void PythonQtShell_abstractBinFile::customEvent(QEvent* arg__1)
4848 void PythonQtShell_abstractBinFile::customEvent(QEvent* arg__1)
4853 {
4849 {
4854 if (_wrapper) {
4850 if (_wrapper) {
4855 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "customEvent");
4851 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "customEvent");
4856 PyErr_Clear();
4852 PyErr_Clear();
4857 if (obj && !PythonQtSlotFunction_Check(obj)) {
4853 if (obj && !PythonQtSlotFunction_Check(obj)) {
4858 static const char* argumentList[] ={"" , "QEvent*"};
4854 static const char* argumentList[] ={"" , "QEvent*"};
4859 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4855 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4860 void* args[2] = {NULL, (void*)&arg__1};
4856 void* args[2] = {NULL, (void*)&arg__1};
4861 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4857 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4862 if (result) { Py_DECREF(result); }
4858 if (result) { Py_DECREF(result); }
4863 Py_DECREF(obj);
4859 Py_DECREF(obj);
4864 return;
4860 return;
4865 }
4861 }
4866 }
4862 }
4867 abstractBinFile::customEvent(arg__1);
4863 abstractBinFile::customEvent(arg__1);
4868 }
4864 }
4869 bool PythonQtShell_abstractBinFile::event(QEvent* arg__1)
4865 bool PythonQtShell_abstractBinFile::event(QEvent* arg__1)
4870 {
4866 {
4871 if (_wrapper) {
4867 if (_wrapper) {
4872 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "event");
4868 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "event");
4873 PyErr_Clear();
4869 PyErr_Clear();
4874 if (obj && !PythonQtSlotFunction_Check(obj)) {
4870 if (obj && !PythonQtSlotFunction_Check(obj)) {
4875 static const char* argumentList[] ={"bool" , "QEvent*"};
4871 static const char* argumentList[] ={"bool" , "QEvent*"};
4876 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4872 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4877 bool returnValue;
4873 bool returnValue;
4878 void* args[2] = {NULL, (void*)&arg__1};
4874 void* args[2] = {NULL, (void*)&arg__1};
4879 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4875 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4880 if (result) {
4876 if (result) {
4881 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
4877 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
4882 if (args[0]!=&returnValue) {
4878 if (args[0]!=&returnValue) {
4883 if (args[0]==NULL) {
4879 if (args[0]==NULL) {
4884 PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
4880 PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
4885 } else {
4881 } else {
4886 returnValue = *((bool*)args[0]);
4882 returnValue = *((bool*)args[0]);
4887 }
4883 }
4888 }
4884 }
4889 }
4885 }
4890 if (result) { Py_DECREF(result); }
4886 if (result) { Py_DECREF(result); }
4891 Py_DECREF(obj);
4887 Py_DECREF(obj);
4892 return returnValue;
4888 return returnValue;
4893 }
4889 }
4894 }
4890 }
4895 return abstractBinFile::event(arg__1);
4891 return abstractBinFile::event(arg__1);
4896 }
4892 }
4897 bool PythonQtShell_abstractBinFile::eventFilter(QObject* arg__1, QEvent* arg__2)
4893 bool PythonQtShell_abstractBinFile::eventFilter(QObject* arg__1, QEvent* arg__2)
4898 {
4894 {
4899 if (_wrapper) {
4895 if (_wrapper) {
4900 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "eventFilter");
4896 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "eventFilter");
4901 PyErr_Clear();
4897 PyErr_Clear();
4902 if (obj && !PythonQtSlotFunction_Check(obj)) {
4898 if (obj && !PythonQtSlotFunction_Check(obj)) {
4903 static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
4899 static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
4904 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
4900 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
4905 bool returnValue;
4901 bool returnValue;
4906 void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2};
4902 void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2};
4907 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4903 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4908 if (result) {
4904 if (result) {
4909 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
4905 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
4910 if (args[0]!=&returnValue) {
4906 if (args[0]!=&returnValue) {
4911 if (args[0]==NULL) {
4907 if (args[0]==NULL) {
4912 PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
4908 PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
4913 } else {
4909 } else {
4914 returnValue = *((bool*)args[0]);
4910 returnValue = *((bool*)args[0]);
4915 }
4911 }
4916 }
4912 }
4917 }
4913 }
4918 if (result) { Py_DECREF(result); }
4914 if (result) { Py_DECREF(result); }
4919 Py_DECREF(obj);
4915 Py_DECREF(obj);
4920 return returnValue;
4916 return returnValue;
4921 }
4917 }
4922 }
4918 }
4923 return abstractBinFile::eventFilter(arg__1, arg__2);
4919 return abstractBinFile::eventFilter(arg__1, arg__2);
4924 }
4920 }
4925 QList<codeFragment* > PythonQtShell_abstractBinFile::getFragments()
4921 QList<codeFragment* > PythonQtShell_abstractBinFile::getFragments()
4926 {
4922 {
4927 if (_wrapper) {
4923 if (_wrapper) {
4928 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getFragments");
4924 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getFragments");
4929 PyErr_Clear();
4925 PyErr_Clear();
4930 if (obj && !PythonQtSlotFunction_Check(obj)) {
4926 if (obj && !PythonQtSlotFunction_Check(obj)) {
4931 static const char* argumentList[] ={"QList<codeFragment* >"};
4927 static const char* argumentList[] ={"QList<codeFragment* >"};
4932 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
4928 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
4933 QList<codeFragment* > returnValue;
4929 QList<codeFragment* > returnValue;
4934 void* args[1] = {NULL};
4930 void* args[1] = {NULL};
4935 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4931 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4936 if (result) {
4932 if (result) {
4937 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
4933 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
4938 if (args[0]!=&returnValue) {
4934 if (args[0]!=&returnValue) {
4939 if (args[0]==NULL) {
4935 if (args[0]==NULL) {
4940 PythonQt::priv()->handleVirtualOverloadReturnError("getFragments", methodInfo, result);
4936 PythonQt::priv()->handleVirtualOverloadReturnError("getFragments", methodInfo, result);
4941 } else {
4937 } else {
4942 returnValue = *((QList<codeFragment* >*)args[0]);
4938 returnValue = *((QList<codeFragment* >*)args[0]);
4943 }
4939 }
4944 }
4940 }
4945 }
4941 }
4946 if (result) { Py_DECREF(result); }
4942 if (result) { Py_DECREF(result); }
4947 Py_DECREF(obj);
4943 Py_DECREF(obj);
4948 return returnValue;
4944 return returnValue;
4949 }
4945 }
4950 }
4946 }
4951 return QList<codeFragment* >();
4947 return QList<codeFragment* >();
4952 }
4948 }
4953 bool PythonQtShell_abstractBinFile::isopened()
4949 bool PythonQtShell_abstractBinFile::isopened()
4954 {
4950 {
4955 if (_wrapper) {
4951 if (_wrapper) {
4956 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "isopened");
4952 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "isopened");
4957 PyErr_Clear();
4953 PyErr_Clear();
4958 if (obj && !PythonQtSlotFunction_Check(obj)) {
4954 if (obj && !PythonQtSlotFunction_Check(obj)) {
4959 static const char* argumentList[] ={"bool"};
4955 static const char* argumentList[] ={"bool"};
4960 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
4956 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
4961 bool returnValue;
4957 bool returnValue;
4962 void* args[1] = {NULL};
4958 void* args[1] = {NULL};
4963 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4959 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4964 if (result) {
4960 if (result) {
4965 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
4961 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
4966 if (args[0]!=&returnValue) {
4962 if (args[0]!=&returnValue) {
4967 if (args[0]==NULL) {
4963 if (args[0]==NULL) {
4968 PythonQt::priv()->handleVirtualOverloadReturnError("isopened", methodInfo, result);
4964 PythonQt::priv()->handleVirtualOverloadReturnError("isopened", methodInfo, result);
4969 } else {
4965 } else {
4970 returnValue = *((bool*)args[0]);
4966 returnValue = *((bool*)args[0]);
4971 }
4967 }
4972 }
4968 }
4973 }
4969 }
4974 if (result) { Py_DECREF(result); }
4970 if (result) { Py_DECREF(result); }
4975 Py_DECREF(obj);
4971 Py_DECREF(obj);
4976 return returnValue;
4972 return returnValue;
4977 }
4973 }
4978 }
4974 }
4979 return bool();
4975 return bool();
4980 }
4976 }
4981 bool PythonQtShell_abstractBinFile::openFile(const QString& File)
4977 bool PythonQtShell_abstractBinFile::openFile(const QString& File)
4982 {
4978 {
4983 if (_wrapper) {
4979 if (_wrapper) {
4984 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "openFile");
4980 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "openFile");
4985 PyErr_Clear();
4981 PyErr_Clear();
4986 if (obj && !PythonQtSlotFunction_Check(obj)) {
4982 if (obj && !PythonQtSlotFunction_Check(obj)) {
4987 static const char* argumentList[] ={"bool" , "const QString&"};
4983 static const char* argumentList[] ={"bool" , "const QString&"};
4988 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4984 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
4989 bool returnValue;
4985 bool returnValue;
4990 void* args[2] = {NULL, (void*)&File};
4986 void* args[2] = {NULL, (void*)&File};
4991 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4987 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
4992 if (result) {
4988 if (result) {
4993 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
4989 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
4994 if (args[0]!=&returnValue) {
4990 if (args[0]!=&returnValue) {
4995 if (args[0]==NULL) {
4991 if (args[0]==NULL) {
4996 PythonQt::priv()->handleVirtualOverloadReturnError("openFile", methodInfo, result);
4992 PythonQt::priv()->handleVirtualOverloadReturnError("openFile", methodInfo, result);
4997 } else {
4993 } else {
4998 returnValue = *((bool*)args[0]);
4994 returnValue = *((bool*)args[0]);
4999 }
4995 }
5000 }
4996 }
5001 }
4997 }
5002 if (result) { Py_DECREF(result); }
4998 if (result) { Py_DECREF(result); }
5003 Py_DECREF(obj);
4999 Py_DECREF(obj);
5004 return returnValue;
5000 return returnValue;
5005 }
5001 }
5006 }
5002 }
5007 return bool();
5003 return bool();
5008 }
5004 }
5009 void PythonQtShell_abstractBinFile::timerEvent(QTimerEvent* arg__1)
5005 void PythonQtShell_abstractBinFile::timerEvent(QTimerEvent* arg__1)
5010 {
5006 {
5011 if (_wrapper) {
5007 if (_wrapper) {
5012 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "timerEvent");
5008 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "timerEvent");
5013 PyErr_Clear();
5009 PyErr_Clear();
5014 if (obj && !PythonQtSlotFunction_Check(obj)) {
5010 if (obj && !PythonQtSlotFunction_Check(obj)) {
5015 static const char* argumentList[] ={"" , "QTimerEvent*"};
5011 static const char* argumentList[] ={"" , "QTimerEvent*"};
5016 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5012 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5017 void* args[2] = {NULL, (void*)&arg__1};
5013 void* args[2] = {NULL, (void*)&arg__1};
5018 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5014 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5019 if (result) { Py_DECREF(result); }
5015 if (result) { Py_DECREF(result); }
5020 Py_DECREF(obj);
5016 Py_DECREF(obj);
5021 return;
5017 return;
5022 }
5018 }
5023 }
5019 }
5024 abstractBinFile::timerEvent(arg__1);
5020 abstractBinFile::timerEvent(arg__1);
5025 }
5021 }
5026 bool PythonQtShell_abstractBinFile::toBinary(const QString& File)
5022 bool PythonQtShell_abstractBinFile::toBinary(const QString& File)
5027 {
5023 {
5028 if (_wrapper) {
5024 if (_wrapper) {
5029 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "toBinary");
5025 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "toBinary");
5030 PyErr_Clear();
5026 PyErr_Clear();
5031 if (obj && !PythonQtSlotFunction_Check(obj)) {
5027 if (obj && !PythonQtSlotFunction_Check(obj)) {
5032 static const char* argumentList[] ={"bool" , "const QString&"};
5028 static const char* argumentList[] ={"bool" , "const QString&"};
5033 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5029 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5034 bool returnValue;
5030 bool returnValue;
5035 void* args[2] = {NULL, (void*)&File};
5031 void* args[2] = {NULL, (void*)&File};
5036 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5032 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5037 if (result) {
5033 if (result) {
5038 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5034 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5039 if (args[0]!=&returnValue) {
5035 if (args[0]!=&returnValue) {
5040 if (args[0]==NULL) {
5036 if (args[0]==NULL) {
5041 PythonQt::priv()->handleVirtualOverloadReturnError("toBinary", methodInfo, result);
5037 PythonQt::priv()->handleVirtualOverloadReturnError("toBinary", methodInfo, result);
5042 } else {
5038 } else {
5043 returnValue = *((bool*)args[0]);
5039 returnValue = *((bool*)args[0]);
5044 }
5040 }
5045 }
5041 }
5046 }
5042 }
5047 if (result) { Py_DECREF(result); }
5043 if (result) { Py_DECREF(result); }
5048 Py_DECREF(obj);
5044 Py_DECREF(obj);
5049 return returnValue;
5045 return returnValue;
5050 }
5046 }
5051 }
5047 }
5052 return bool();
5048 return bool();
5053 }
5049 }
5054 bool PythonQtShell_abstractBinFile::toSrec(const QString& File)
5050 bool PythonQtShell_abstractBinFile::toSrec(const QString& File)
5055 {
5051 {
5056 if (_wrapper) {
5052 if (_wrapper) {
5057 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "toSrec");
5053 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "toSrec");
5058 PyErr_Clear();
5054 PyErr_Clear();
5059 if (obj && !PythonQtSlotFunction_Check(obj)) {
5055 if (obj && !PythonQtSlotFunction_Check(obj)) {
5060 static const char* argumentList[] ={"bool" , "const QString&"};
5056 static const char* argumentList[] ={"bool" , "const QString&"};
5061 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5057 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5062 bool returnValue;
5058 bool returnValue;
5063 void* args[2] = {NULL, (void*)&File};
5059 void* args[2] = {NULL, (void*)&File};
5064 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5060 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5065 if (result) {
5061 if (result) {
5066 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5062 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5067 if (args[0]!=&returnValue) {
5063 if (args[0]!=&returnValue) {
5068 if (args[0]==NULL) {
5064 if (args[0]==NULL) {
5069 PythonQt::priv()->handleVirtualOverloadReturnError("toSrec", methodInfo, result);
5065 PythonQt::priv()->handleVirtualOverloadReturnError("toSrec", methodInfo, result);
5070 } else {
5066 } else {
5071 returnValue = *((bool*)args[0]);
5067 returnValue = *((bool*)args[0]);
5072 }
5068 }
5073 }
5069 }
5074 }
5070 }
5075 if (result) { Py_DECREF(result); }
5071 if (result) { Py_DECREF(result); }
5076 Py_DECREF(obj);
5072 Py_DECREF(obj);
5077 return returnValue;
5073 return returnValue;
5078 }
5074 }
5079 }
5075 }
5080 return bool();
5076 return bool();
5081 }
5077 }
5082 abstractBinFile* PythonQtWrapper_abstractBinFile::new_abstractBinFile()
5078 abstractBinFile* PythonQtWrapper_abstractBinFile::new_abstractBinFile()
5083 {
5079 {
5084 return new PythonQtShell_abstractBinFile(); }
5080 return new PythonQtShell_abstractBinFile(); }
5085
5081
5086
5082
5087
5083
5088 PythonQtShell_abstractBinFileWidget::~PythonQtShell_abstractBinFileWidget() {
5084 PythonQtShell_abstractBinFileWidget::~PythonQtShell_abstractBinFileWidget() {
5089 PythonQtPrivate* priv = PythonQt::priv();
5085 PythonQtPrivate* priv = PythonQt::priv();
5090 if (priv) { priv->shellClassDeleted(this); }
5086 if (priv) { priv->shellClassDeleted(this); }
5091 }
5087 }
5092 void PythonQtShell_abstractBinFileWidget::actionEvent(QActionEvent* arg__1)
5088 void PythonQtShell_abstractBinFileWidget::actionEvent(QActionEvent* arg__1)
5093 {
5089 {
5094 if (_wrapper) {
5090 if (_wrapper) {
5095 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "actionEvent");
5091 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "actionEvent");
5096 PyErr_Clear();
5092 PyErr_Clear();
5097 if (obj && !PythonQtSlotFunction_Check(obj)) {
5093 if (obj && !PythonQtSlotFunction_Check(obj)) {
5098 static const char* argumentList[] ={"" , "QActionEvent*"};
5094 static const char* argumentList[] ={"" , "QActionEvent*"};
5099 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5095 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5100 void* args[2] = {NULL, (void*)&arg__1};
5096 void* args[2] = {NULL, (void*)&arg__1};
5101 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5097 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5102 if (result) { Py_DECREF(result); }
5098 if (result) { Py_DECREF(result); }
5103 Py_DECREF(obj);
5099 Py_DECREF(obj);
5104 return;
5100 return;
5105 }
5101 }
5106 }
5102 }
5107 abstractBinFileWidget::actionEvent(arg__1);
5103 abstractBinFileWidget::actionEvent(arg__1);
5108 }
5104 }
5109 void PythonQtShell_abstractBinFileWidget::changeEvent(QEvent* arg__1)
5105 void PythonQtShell_abstractBinFileWidget::changeEvent(QEvent* arg__1)
5110 {
5106 {
5111 if (_wrapper) {
5107 if (_wrapper) {
5112 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "changeEvent");
5108 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "changeEvent");
5113 PyErr_Clear();
5109 PyErr_Clear();
5114 if (obj && !PythonQtSlotFunction_Check(obj)) {
5110 if (obj && !PythonQtSlotFunction_Check(obj)) {
5115 static const char* argumentList[] ={"" , "QEvent*"};
5111 static const char* argumentList[] ={"" , "QEvent*"};
5116 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5112 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5117 void* args[2] = {NULL, (void*)&arg__1};
5113 void* args[2] = {NULL, (void*)&arg__1};
5118 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5114 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5119 if (result) { Py_DECREF(result); }
5115 if (result) { Py_DECREF(result); }
5120 Py_DECREF(obj);
5116 Py_DECREF(obj);
5121 return;
5117 return;
5122 }
5118 }
5123 }
5119 }
5124 abstractBinFileWidget::changeEvent(arg__1);
5120 abstractBinFileWidget::changeEvent(arg__1);
5125 }
5121 }
5126 void PythonQtShell_abstractBinFileWidget::childEvent(QChildEvent* arg__1)
5122 void PythonQtShell_abstractBinFileWidget::childEvent(QChildEvent* arg__1)
5127 {
5123 {
5128 if (_wrapper) {
5124 if (_wrapper) {
5129 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "childEvent");
5125 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "childEvent");
5130 PyErr_Clear();
5126 PyErr_Clear();
5131 if (obj && !PythonQtSlotFunction_Check(obj)) {
5127 if (obj && !PythonQtSlotFunction_Check(obj)) {
5132 static const char* argumentList[] ={"" , "QChildEvent*"};
5128 static const char* argumentList[] ={"" , "QChildEvent*"};
5133 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5129 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5134 void* args[2] = {NULL, (void*)&arg__1};
5130 void* args[2] = {NULL, (void*)&arg__1};
5135 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5131 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5136 if (result) { Py_DECREF(result); }
5132 if (result) { Py_DECREF(result); }
5137 Py_DECREF(obj);
5133 Py_DECREF(obj);
5138 return;
5134 return;
5139 }
5135 }
5140 }
5136 }
5141 abstractBinFileWidget::childEvent(arg__1);
5137 abstractBinFileWidget::childEvent(arg__1);
5142 }
5138 }
5143 void PythonQtShell_abstractBinFileWidget::closeEvent(QCloseEvent* arg__1)
5139 void PythonQtShell_abstractBinFileWidget::closeEvent(QCloseEvent* arg__1)
5144 {
5140 {
5145 if (_wrapper) {
5141 if (_wrapper) {
5146 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "closeEvent");
5142 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "closeEvent");
5147 PyErr_Clear();
5143 PyErr_Clear();
5148 if (obj && !PythonQtSlotFunction_Check(obj)) {
5144 if (obj && !PythonQtSlotFunction_Check(obj)) {
5149 static const char* argumentList[] ={"" , "QCloseEvent*"};
5145 static const char* argumentList[] ={"" , "QCloseEvent*"};
5150 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5146 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5151 void* args[2] = {NULL, (void*)&arg__1};
5147 void* args[2] = {NULL, (void*)&arg__1};
5152 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5148 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5153 if (result) { Py_DECREF(result); }
5149 if (result) { Py_DECREF(result); }
5154 Py_DECREF(obj);
5150 Py_DECREF(obj);
5155 return;
5151 return;
5156 }
5152 }
5157 }
5153 }
5158 abstractBinFileWidget::closeEvent(arg__1);
5154 abstractBinFileWidget::closeEvent(arg__1);
5159 }
5155 }
5160 void PythonQtShell_abstractBinFileWidget::contextMenuEvent(QContextMenuEvent* arg__1)
5156 void PythonQtShell_abstractBinFileWidget::contextMenuEvent(QContextMenuEvent* arg__1)
5161 {
5157 {
5162 if (_wrapper) {
5158 if (_wrapper) {
5163 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "contextMenuEvent");
5159 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "contextMenuEvent");
5164 PyErr_Clear();
5160 PyErr_Clear();
5165 if (obj && !PythonQtSlotFunction_Check(obj)) {
5161 if (obj && !PythonQtSlotFunction_Check(obj)) {
5166 static const char* argumentList[] ={"" , "QContextMenuEvent*"};
5162 static const char* argumentList[] ={"" , "QContextMenuEvent*"};
5167 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5163 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5168 void* args[2] = {NULL, (void*)&arg__1};
5164 void* args[2] = {NULL, (void*)&arg__1};
5169 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5165 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5170 if (result) { Py_DECREF(result); }
5166 if (result) { Py_DECREF(result); }
5171 Py_DECREF(obj);
5167 Py_DECREF(obj);
5172 return;
5168 return;
5173 }
5169 }
5174 }
5170 }
5175 abstractBinFileWidget::contextMenuEvent(arg__1);
5171 abstractBinFileWidget::contextMenuEvent(arg__1);
5176 }
5172 }
5177 void PythonQtShell_abstractBinFileWidget::customEvent(QEvent* arg__1)
5173 void PythonQtShell_abstractBinFileWidget::customEvent(QEvent* arg__1)
5178 {
5174 {
5179 if (_wrapper) {
5175 if (_wrapper) {
5180 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "customEvent");
5176 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "customEvent");
5181 PyErr_Clear();
5177 PyErr_Clear();
5182 if (obj && !PythonQtSlotFunction_Check(obj)) {
5178 if (obj && !PythonQtSlotFunction_Check(obj)) {
5183 static const char* argumentList[] ={"" , "QEvent*"};
5179 static const char* argumentList[] ={"" , "QEvent*"};
5184 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5180 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5185 void* args[2] = {NULL, (void*)&arg__1};
5181 void* args[2] = {NULL, (void*)&arg__1};
5186 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5182 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5187 if (result) { Py_DECREF(result); }
5183 if (result) { Py_DECREF(result); }
5188 Py_DECREF(obj);
5184 Py_DECREF(obj);
5189 return;
5185 return;
5190 }
5186 }
5191 }
5187 }
5192 abstractBinFileWidget::customEvent(arg__1);
5188 abstractBinFileWidget::customEvent(arg__1);
5193 }
5189 }
5194 int PythonQtShell_abstractBinFileWidget::devType() const
5190 int PythonQtShell_abstractBinFileWidget::devType() const
5195 {
5191 {
5196 if (_wrapper) {
5192 if (_wrapper) {
5197 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "devType");
5193 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "devType");
5198 PyErr_Clear();
5194 PyErr_Clear();
5199 if (obj && !PythonQtSlotFunction_Check(obj)) {
5195 if (obj && !PythonQtSlotFunction_Check(obj)) {
5200 static const char* argumentList[] ={"int"};
5196 static const char* argumentList[] ={"int"};
5201 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
5197 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
5202 int returnValue;
5198 int returnValue;
5203 void* args[1] = {NULL};
5199 void* args[1] = {NULL};
5204 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5200 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5205 if (result) {
5201 if (result) {
5206 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5202 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5207 if (args[0]!=&returnValue) {
5203 if (args[0]!=&returnValue) {
5208 if (args[0]==NULL) {
5204 if (args[0]==NULL) {
5209 PythonQt::priv()->handleVirtualOverloadReturnError("devType", methodInfo, result);
5205 PythonQt::priv()->handleVirtualOverloadReturnError("devType", methodInfo, result);
5210 } else {
5206 } else {
5211 returnValue = *((int*)args[0]);
5207 returnValue = *((int*)args[0]);
5212 }
5208 }
5213 }
5209 }
5214 }
5210 }
5215 if (result) { Py_DECREF(result); }
5211 if (result) { Py_DECREF(result); }
5216 Py_DECREF(obj);
5212 Py_DECREF(obj);
5217 return returnValue;
5213 return returnValue;
5218 }
5214 }
5219 }
5215 }
5220 return abstractBinFileWidget::devType();
5216 return abstractBinFileWidget::devType();
5221 }
5217 }
5222 void PythonQtShell_abstractBinFileWidget::dragEnterEvent(QDragEnterEvent* arg__1)
5218 void PythonQtShell_abstractBinFileWidget::dragEnterEvent(QDragEnterEvent* arg__1)
5223 {
5219 {
5224 if (_wrapper) {
5220 if (_wrapper) {
5225 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragEnterEvent");
5221 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragEnterEvent");
5226 PyErr_Clear();
5222 PyErr_Clear();
5227 if (obj && !PythonQtSlotFunction_Check(obj)) {
5223 if (obj && !PythonQtSlotFunction_Check(obj)) {
5228 static const char* argumentList[] ={"" , "QDragEnterEvent*"};
5224 static const char* argumentList[] ={"" , "QDragEnterEvent*"};
5229 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5225 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5230 void* args[2] = {NULL, (void*)&arg__1};
5226 void* args[2] = {NULL, (void*)&arg__1};
5231 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5227 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5232 if (result) { Py_DECREF(result); }
5228 if (result) { Py_DECREF(result); }
5233 Py_DECREF(obj);
5229 Py_DECREF(obj);
5234 return;
5230 return;
5235 }
5231 }
5236 }
5232 }
5237 abstractBinFileWidget::dragEnterEvent(arg__1);
5233 abstractBinFileWidget::dragEnterEvent(arg__1);
5238 }
5234 }
5239 void PythonQtShell_abstractBinFileWidget::dragLeaveEvent(QDragLeaveEvent* arg__1)
5235 void PythonQtShell_abstractBinFileWidget::dragLeaveEvent(QDragLeaveEvent* arg__1)
5240 {
5236 {
5241 if (_wrapper) {
5237 if (_wrapper) {
5242 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragLeaveEvent");
5238 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragLeaveEvent");
5243 PyErr_Clear();
5239 PyErr_Clear();
5244 if (obj && !PythonQtSlotFunction_Check(obj)) {
5240 if (obj && !PythonQtSlotFunction_Check(obj)) {
5245 static const char* argumentList[] ={"" , "QDragLeaveEvent*"};
5241 static const char* argumentList[] ={"" , "QDragLeaveEvent*"};
5246 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5242 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5247 void* args[2] = {NULL, (void*)&arg__1};
5243 void* args[2] = {NULL, (void*)&arg__1};
5248 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5244 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5249 if (result) { Py_DECREF(result); }
5245 if (result) { Py_DECREF(result); }
5250 Py_DECREF(obj);
5246 Py_DECREF(obj);
5251 return;
5247 return;
5252 }
5248 }
5253 }
5249 }
5254 abstractBinFileWidget::dragLeaveEvent(arg__1);
5250 abstractBinFileWidget::dragLeaveEvent(arg__1);
5255 }
5251 }
5256 void PythonQtShell_abstractBinFileWidget::dragMoveEvent(QDragMoveEvent* arg__1)
5252 void PythonQtShell_abstractBinFileWidget::dragMoveEvent(QDragMoveEvent* arg__1)
5257 {
5253 {
5258 if (_wrapper) {
5254 if (_wrapper) {
5259 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragMoveEvent");
5255 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragMoveEvent");
5260 PyErr_Clear();
5256 PyErr_Clear();
5261 if (obj && !PythonQtSlotFunction_Check(obj)) {
5257 if (obj && !PythonQtSlotFunction_Check(obj)) {
5262 static const char* argumentList[] ={"" , "QDragMoveEvent*"};
5258 static const char* argumentList[] ={"" , "QDragMoveEvent*"};
5263 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5259 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5264 void* args[2] = {NULL, (void*)&arg__1};
5260 void* args[2] = {NULL, (void*)&arg__1};
5265 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5261 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5266 if (result) { Py_DECREF(result); }
5262 if (result) { Py_DECREF(result); }
5267 Py_DECREF(obj);
5263 Py_DECREF(obj);
5268 return;
5264 return;
5269 }
5265 }
5270 }
5266 }
5271 abstractBinFileWidget::dragMoveEvent(arg__1);
5267 abstractBinFileWidget::dragMoveEvent(arg__1);
5272 }
5268 }
5273 void PythonQtShell_abstractBinFileWidget::dropEvent(QDropEvent* arg__1)
5269 void PythonQtShell_abstractBinFileWidget::dropEvent(QDropEvent* arg__1)
5274 {
5270 {
5275 if (_wrapper) {
5271 if (_wrapper) {
5276 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dropEvent");
5272 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dropEvent");
5277 PyErr_Clear();
5273 PyErr_Clear();
5278 if (obj && !PythonQtSlotFunction_Check(obj)) {
5274 if (obj && !PythonQtSlotFunction_Check(obj)) {
5279 static const char* argumentList[] ={"" , "QDropEvent*"};
5275 static const char* argumentList[] ={"" , "QDropEvent*"};
5280 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5276 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5281 void* args[2] = {NULL, (void*)&arg__1};
5277 void* args[2] = {NULL, (void*)&arg__1};
5282 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5278 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5283 if (result) { Py_DECREF(result); }
5279 if (result) { Py_DECREF(result); }
5284 Py_DECREF(obj);
5280 Py_DECREF(obj);
5285 return;
5281 return;
5286 }
5282 }
5287 }
5283 }
5288 abstractBinFileWidget::dropEvent(arg__1);
5284 abstractBinFileWidget::dropEvent(arg__1);
5289 }
5285 }
5290 void PythonQtShell_abstractBinFileWidget::enterEvent(QEvent* arg__1)
5286 void PythonQtShell_abstractBinFileWidget::enterEvent(QEvent* arg__1)
5291 {
5287 {
5292 if (_wrapper) {
5288 if (_wrapper) {
5293 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "enterEvent");
5289 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "enterEvent");
5294 PyErr_Clear();
5290 PyErr_Clear();
5295 if (obj && !PythonQtSlotFunction_Check(obj)) {
5291 if (obj && !PythonQtSlotFunction_Check(obj)) {
5296 static const char* argumentList[] ={"" , "QEvent*"};
5292 static const char* argumentList[] ={"" , "QEvent*"};
5297 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5293 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5298 void* args[2] = {NULL, (void*)&arg__1};
5294 void* args[2] = {NULL, (void*)&arg__1};
5299 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5295 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5300 if (result) { Py_DECREF(result); }
5296 if (result) { Py_DECREF(result); }
5301 Py_DECREF(obj);
5297 Py_DECREF(obj);
5302 return;
5298 return;
5303 }
5299 }
5304 }
5300 }
5305 abstractBinFileWidget::enterEvent(arg__1);
5301 abstractBinFileWidget::enterEvent(arg__1);
5306 }
5302 }
5307 bool PythonQtShell_abstractBinFileWidget::event(QEvent* arg__1)
5303 bool PythonQtShell_abstractBinFileWidget::event(QEvent* arg__1)
5308 {
5304 {
5309 if (_wrapper) {
5305 if (_wrapper) {
5310 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "event");
5306 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "event");
5311 PyErr_Clear();
5307 PyErr_Clear();
5312 if (obj && !PythonQtSlotFunction_Check(obj)) {
5308 if (obj && !PythonQtSlotFunction_Check(obj)) {
5313 static const char* argumentList[] ={"bool" , "QEvent*"};
5309 static const char* argumentList[] ={"bool" , "QEvent*"};
5314 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5310 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5315 bool returnValue;
5311 bool returnValue;
5316 void* args[2] = {NULL, (void*)&arg__1};
5312 void* args[2] = {NULL, (void*)&arg__1};
5317 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5313 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5318 if (result) {
5314 if (result) {
5319 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5315 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5320 if (args[0]!=&returnValue) {
5316 if (args[0]!=&returnValue) {
5321 if (args[0]==NULL) {
5317 if (args[0]==NULL) {
5322 PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
5318 PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
5323 } else {
5319 } else {
5324 returnValue = *((bool*)args[0]);
5320 returnValue = *((bool*)args[0]);
5325 }
5321 }
5326 }
5322 }
5327 }
5323 }
5328 if (result) { Py_DECREF(result); }
5324 if (result) { Py_DECREF(result); }
5329 Py_DECREF(obj);
5325 Py_DECREF(obj);
5330 return returnValue;
5326 return returnValue;
5331 }
5327 }
5332 }
5328 }
5333 return abstractBinFileWidget::event(arg__1);
5329 return abstractBinFileWidget::event(arg__1);
5334 }
5330 }
5335 bool PythonQtShell_abstractBinFileWidget::eventFilter(QObject* arg__1, QEvent* arg__2)
5331 bool PythonQtShell_abstractBinFileWidget::eventFilter(QObject* arg__1, QEvent* arg__2)
5336 {
5332 {
5337 if (_wrapper) {
5333 if (_wrapper) {
5338 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "eventFilter");
5334 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "eventFilter");
5339 PyErr_Clear();
5335 PyErr_Clear();
5340 if (obj && !PythonQtSlotFunction_Check(obj)) {
5336 if (obj && !PythonQtSlotFunction_Check(obj)) {
5341 static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
5337 static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
5342 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
5338 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
5343 bool returnValue;
5339 bool returnValue;
5344 void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2};
5340 void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2};
5345 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5341 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5346 if (result) {
5342 if (result) {
5347 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5343 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5348 if (args[0]!=&returnValue) {
5344 if (args[0]!=&returnValue) {
5349 if (args[0]==NULL) {
5345 if (args[0]==NULL) {
5350 PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
5346 PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
5351 } else {
5347 } else {
5352 returnValue = *((bool*)args[0]);
5348 returnValue = *((bool*)args[0]);
5353 }
5349 }
5354 }
5350 }
5355 }
5351 }
5356 if (result) { Py_DECREF(result); }
5352 if (result) { Py_DECREF(result); }
5357 Py_DECREF(obj);
5353 Py_DECREF(obj);
5358 return returnValue;
5354 return returnValue;
5359 }
5355 }
5360 }
5356 }
5361 return abstractBinFileWidget::eventFilter(arg__1, arg__2);
5357 return abstractBinFileWidget::eventFilter(arg__1, arg__2);
5362 }
5358 }
5363 void PythonQtShell_abstractBinFileWidget::focusInEvent(QFocusEvent* arg__1)
5359 void PythonQtShell_abstractBinFileWidget::focusInEvent(QFocusEvent* arg__1)
5364 {
5360 {
5365 if (_wrapper) {
5361 if (_wrapper) {
5366 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusInEvent");
5362 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusInEvent");
5367 PyErr_Clear();
5363 PyErr_Clear();
5368 if (obj && !PythonQtSlotFunction_Check(obj)) {
5364 if (obj && !PythonQtSlotFunction_Check(obj)) {
5369 static const char* argumentList[] ={"" , "QFocusEvent*"};
5365 static const char* argumentList[] ={"" , "QFocusEvent*"};
5370 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5366 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5371 void* args[2] = {NULL, (void*)&arg__1};
5367 void* args[2] = {NULL, (void*)&arg__1};
5372 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5368 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5373 if (result) { Py_DECREF(result); }
5369 if (result) { Py_DECREF(result); }
5374 Py_DECREF(obj);
5370 Py_DECREF(obj);
5375 return;
5371 return;
5376 }
5372 }
5377 }
5373 }
5378 abstractBinFileWidget::focusInEvent(arg__1);
5374 abstractBinFileWidget::focusInEvent(arg__1);
5379 }
5375 }
5380 bool PythonQtShell_abstractBinFileWidget::focusNextPrevChild(bool next)
5376 bool PythonQtShell_abstractBinFileWidget::focusNextPrevChild(bool next)
5381 {
5377 {
5382 if (_wrapper) {
5378 if (_wrapper) {
5383 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusNextPrevChild");
5379 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusNextPrevChild");
5384 PyErr_Clear();
5380 PyErr_Clear();
5385 if (obj && !PythonQtSlotFunction_Check(obj)) {
5381 if (obj && !PythonQtSlotFunction_Check(obj)) {
5386 static const char* argumentList[] ={"bool" , "bool"};
5382 static const char* argumentList[] ={"bool" , "bool"};
5387 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5383 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5388 bool returnValue;
5384 bool returnValue;
5389 void* args[2] = {NULL, (void*)&next};
5385 void* args[2] = {NULL, (void*)&next};
5390 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5386 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5391 if (result) {
5387 if (result) {
5392 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5388 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5393 if (args[0]!=&returnValue) {
5389 if (args[0]!=&returnValue) {
5394 if (args[0]==NULL) {
5390 if (args[0]==NULL) {
5395 PythonQt::priv()->handleVirtualOverloadReturnError("focusNextPrevChild", methodInfo, result);
5391 PythonQt::priv()->handleVirtualOverloadReturnError("focusNextPrevChild", methodInfo, result);
5396 } else {
5392 } else {
5397 returnValue = *((bool*)args[0]);
5393 returnValue = *((bool*)args[0]);
5398 }
5394 }
5399 }
5395 }
5400 }
5396 }
5401 if (result) { Py_DECREF(result); }
5397 if (result) { Py_DECREF(result); }
5402 Py_DECREF(obj);
5398 Py_DECREF(obj);
5403 return returnValue;
5399 return returnValue;
5404 }
5400 }
5405 }
5401 }
5406 return abstractBinFileWidget::focusNextPrevChild(next);
5402 return abstractBinFileWidget::focusNextPrevChild(next);
5407 }
5403 }
5408 void PythonQtShell_abstractBinFileWidget::focusOutEvent(QFocusEvent* arg__1)
5404 void PythonQtShell_abstractBinFileWidget::focusOutEvent(QFocusEvent* arg__1)
5409 {
5405 {
5410 if (_wrapper) {
5406 if (_wrapper) {
5411 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusOutEvent");
5407 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusOutEvent");
5412 PyErr_Clear();
5408 PyErr_Clear();
5413 if (obj && !PythonQtSlotFunction_Check(obj)) {
5409 if (obj && !PythonQtSlotFunction_Check(obj)) {
5414 static const char* argumentList[] ={"" , "QFocusEvent*"};
5410 static const char* argumentList[] ={"" , "QFocusEvent*"};
5415 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5411 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5416 void* args[2] = {NULL, (void*)&arg__1};
5412 void* args[2] = {NULL, (void*)&arg__1};
5417 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5413 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5418 if (result) { Py_DECREF(result); }
5414 if (result) { Py_DECREF(result); }
5419 Py_DECREF(obj);
5415 Py_DECREF(obj);
5420 return;
5416 return;
5421 }
5417 }
5422 }
5418 }
5423 abstractBinFileWidget::focusOutEvent(arg__1);
5419 abstractBinFileWidget::focusOutEvent(arg__1);
5424 }
5420 }
5425 bool PythonQtShell_abstractBinFileWidget::hasHeightForWidth() const
5421 bool PythonQtShell_abstractBinFileWidget::hasHeightForWidth() const
5426 {
5422 {
5427 if (_wrapper) {
5423 if (_wrapper) {
5428 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hasHeightForWidth");
5424 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hasHeightForWidth");
5429 PyErr_Clear();
5425 PyErr_Clear();
5430 if (obj && !PythonQtSlotFunction_Check(obj)) {
5426 if (obj && !PythonQtSlotFunction_Check(obj)) {
5431 static const char* argumentList[] ={"bool"};
5427 static const char* argumentList[] ={"bool"};
5432 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
5428 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
5433 bool returnValue;
5429 bool returnValue;
5434 void* args[1] = {NULL};
5430 void* args[1] = {NULL};
5435 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5431 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5436 if (result) {
5432 if (result) {
5437 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5433 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5438 if (args[0]!=&returnValue) {
5434 if (args[0]!=&returnValue) {
5439 if (args[0]==NULL) {
5435 if (args[0]==NULL) {
5440 PythonQt::priv()->handleVirtualOverloadReturnError("hasHeightForWidth", methodInfo, result);
5436 PythonQt::priv()->handleVirtualOverloadReturnError("hasHeightForWidth", methodInfo, result);
5441 } else {
5437 } else {
5442 returnValue = *((bool*)args[0]);
5438 returnValue = *((bool*)args[0]);
5443 }
5439 }
5444 }
5440 }
5445 }
5441 }
5446 if (result) { Py_DECREF(result); }
5442 if (result) { Py_DECREF(result); }
5447 Py_DECREF(obj);
5443 Py_DECREF(obj);
5448 return returnValue;
5444 return returnValue;
5449 }
5445 }
5450 }
5446 }
5451 return abstractBinFileWidget::hasHeightForWidth();
5447 return abstractBinFileWidget::hasHeightForWidth();
5452 }
5448 }
5453 int PythonQtShell_abstractBinFileWidget::heightForWidth(int arg__1) const
5449 int PythonQtShell_abstractBinFileWidget::heightForWidth(int arg__1) const
5454 {
5450 {
5455 if (_wrapper) {
5451 if (_wrapper) {
5456 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "heightForWidth");
5452 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "heightForWidth");
5457 PyErr_Clear();
5453 PyErr_Clear();
5458 if (obj && !PythonQtSlotFunction_Check(obj)) {
5454 if (obj && !PythonQtSlotFunction_Check(obj)) {
5459 static const char* argumentList[] ={"int" , "int"};
5455 static const char* argumentList[] ={"int" , "int"};
5460 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5456 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5461 int returnValue;
5457 int returnValue;
5462 void* args[2] = {NULL, (void*)&arg__1};
5458 void* args[2] = {NULL, (void*)&arg__1};
5463 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5459 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5464 if (result) {
5460 if (result) {
5465 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5461 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5466 if (args[0]!=&returnValue) {
5462 if (args[0]!=&returnValue) {
5467 if (args[0]==NULL) {
5463 if (args[0]==NULL) {
5468 PythonQt::priv()->handleVirtualOverloadReturnError("heightForWidth", methodInfo, result);
5464 PythonQt::priv()->handleVirtualOverloadReturnError("heightForWidth", methodInfo, result);
5469 } else {
5465 } else {
5470 returnValue = *((int*)args[0]);
5466 returnValue = *((int*)args[0]);
5471 }
5467 }
5472 }
5468 }
5473 }
5469 }
5474 if (result) { Py_DECREF(result); }
5470 if (result) { Py_DECREF(result); }
5475 Py_DECREF(obj);
5471 Py_DECREF(obj);
5476 return returnValue;
5472 return returnValue;
5477 }
5473 }
5478 }
5474 }
5479 return abstractBinFileWidget::heightForWidth(arg__1);
5475 return abstractBinFileWidget::heightForWidth(arg__1);
5480 }
5476 }
5481 void PythonQtShell_abstractBinFileWidget::hideEvent(QHideEvent* arg__1)
5477 void PythonQtShell_abstractBinFileWidget::hideEvent(QHideEvent* arg__1)
5482 {
5478 {
5483 if (_wrapper) {
5479 if (_wrapper) {
5484 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hideEvent");
5480 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hideEvent");
5485 PyErr_Clear();
5481 PyErr_Clear();
5486 if (obj && !PythonQtSlotFunction_Check(obj)) {
5482 if (obj && !PythonQtSlotFunction_Check(obj)) {
5487 static const char* argumentList[] ={"" , "QHideEvent*"};
5483 static const char* argumentList[] ={"" , "QHideEvent*"};
5488 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5484 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5489 void* args[2] = {NULL, (void*)&arg__1};
5485 void* args[2] = {NULL, (void*)&arg__1};
5490 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5486 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5491 if (result) { Py_DECREF(result); }
5487 if (result) { Py_DECREF(result); }
5492 Py_DECREF(obj);
5488 Py_DECREF(obj);
5493 return;
5489 return;
5494 }
5490 }
5495 }
5491 }
5496 abstractBinFileWidget::hideEvent(arg__1);
5492 abstractBinFileWidget::hideEvent(arg__1);
5497 }
5493 }
5498 void PythonQtShell_abstractBinFileWidget::initPainter(QPainter* painter) const
5494 void PythonQtShell_abstractBinFileWidget::initPainter(QPainter* painter) const
5499 {
5495 {
5500 if (_wrapper) {
5496 if (_wrapper) {
5501 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "initPainter");
5497 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "initPainter");
5502 PyErr_Clear();
5498 PyErr_Clear();
5503 if (obj && !PythonQtSlotFunction_Check(obj)) {
5499 if (obj && !PythonQtSlotFunction_Check(obj)) {
5504 static const char* argumentList[] ={"" , "QPainter*"};
5500 static const char* argumentList[] ={"" , "QPainter*"};
5505 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5501 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5506 void* args[2] = {NULL, (void*)&painter};
5502 void* args[2] = {NULL, (void*)&painter};
5507 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5503 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5508 if (result) { Py_DECREF(result); }
5504 if (result) { Py_DECREF(result); }
5509 Py_DECREF(obj);
5505 Py_DECREF(obj);
5510 return;
5506 return;
5511 }
5507 }
5512 }
5508 }
5513 abstractBinFileWidget::initPainter(painter);
5509 abstractBinFileWidget::initPainter(painter);
5514 }
5510 }
5515 void PythonQtShell_abstractBinFileWidget::inputMethodEvent(QInputMethodEvent* arg__1)
5511 void PythonQtShell_abstractBinFileWidget::inputMethodEvent(QInputMethodEvent* arg__1)
5516 {
5512 {
5517 if (_wrapper) {
5513 if (_wrapper) {
5518 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodEvent");
5514 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodEvent");
5519 PyErr_Clear();
5515 PyErr_Clear();
5520 if (obj && !PythonQtSlotFunction_Check(obj)) {
5516 if (obj && !PythonQtSlotFunction_Check(obj)) {
5521 static const char* argumentList[] ={"" , "QInputMethodEvent*"};
5517 static const char* argumentList[] ={"" , "QInputMethodEvent*"};
5522 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5518 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5523 void* args[2] = {NULL, (void*)&arg__1};
5519 void* args[2] = {NULL, (void*)&arg__1};
5524 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5520 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5525 if (result) { Py_DECREF(result); }
5521 if (result) { Py_DECREF(result); }
5526 Py_DECREF(obj);
5522 Py_DECREF(obj);
5527 return;
5523 return;
5528 }
5524 }
5529 }
5525 }
5530 abstractBinFileWidget::inputMethodEvent(arg__1);
5526 abstractBinFileWidget::inputMethodEvent(arg__1);
5531 }
5527 }
5532 QVariant PythonQtShell_abstractBinFileWidget::inputMethodQuery(Qt::InputMethodQuery arg__1) const
5528 QVariant PythonQtShell_abstractBinFileWidget::inputMethodQuery(Qt::InputMethodQuery arg__1) const
5533 {
5529 {
5534 if (_wrapper) {
5530 if (_wrapper) {
5535 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodQuery");
5531 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodQuery");
5536 PyErr_Clear();
5532 PyErr_Clear();
5537 if (obj && !PythonQtSlotFunction_Check(obj)) {
5533 if (obj && !PythonQtSlotFunction_Check(obj)) {
5538 static const char* argumentList[] ={"QVariant" , "Qt::InputMethodQuery"};
5534 static const char* argumentList[] ={"QVariant" , "Qt::InputMethodQuery"};
5539 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5535 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5540 QVariant returnValue;
5536 QVariant returnValue;
5541 void* args[2] = {NULL, (void*)&arg__1};
5537 void* args[2] = {NULL, (void*)&arg__1};
5542 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5538 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5543 if (result) {
5539 if (result) {
5544 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5540 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5545 if (args[0]!=&returnValue) {
5541 if (args[0]!=&returnValue) {
5546 if (args[0]==NULL) {
5542 if (args[0]==NULL) {
5547 PythonQt::priv()->handleVirtualOverloadReturnError("inputMethodQuery", methodInfo, result);
5543 PythonQt::priv()->handleVirtualOverloadReturnError("inputMethodQuery", methodInfo, result);
5548 } else {
5544 } else {
5549 returnValue = *((QVariant*)args[0]);
5545 returnValue = *((QVariant*)args[0]);
5550 }
5546 }
5551 }
5547 }
5552 }
5548 }
5553 if (result) { Py_DECREF(result); }
5549 if (result) { Py_DECREF(result); }
5554 Py_DECREF(obj);
5550 Py_DECREF(obj);
5555 return returnValue;
5551 return returnValue;
5556 }
5552 }
5557 }
5553 }
5558 return abstractBinFileWidget::inputMethodQuery(arg__1);
5554 return abstractBinFileWidget::inputMethodQuery(arg__1);
5559 }
5555 }
5560 void PythonQtShell_abstractBinFileWidget::keyPressEvent(QKeyEvent* arg__1)
5556 void PythonQtShell_abstractBinFileWidget::keyPressEvent(QKeyEvent* arg__1)
5561 {
5557 {
5562 if (_wrapper) {
5558 if (_wrapper) {
5563 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyPressEvent");
5559 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyPressEvent");
5564 PyErr_Clear();
5560 PyErr_Clear();
5565 if (obj && !PythonQtSlotFunction_Check(obj)) {
5561 if (obj && !PythonQtSlotFunction_Check(obj)) {
5566 static const char* argumentList[] ={"" , "QKeyEvent*"};
5562 static const char* argumentList[] ={"" , "QKeyEvent*"};
5567 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5563 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5568 void* args[2] = {NULL, (void*)&arg__1};
5564 void* args[2] = {NULL, (void*)&arg__1};
5569 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5565 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5570 if (result) { Py_DECREF(result); }
5566 if (result) { Py_DECREF(result); }
5571 Py_DECREF(obj);
5567 Py_DECREF(obj);
5572 return;
5568 return;
5573 }
5569 }
5574 }
5570 }
5575 abstractBinFileWidget::keyPressEvent(arg__1);
5571 abstractBinFileWidget::keyPressEvent(arg__1);
5576 }
5572 }
5577 void PythonQtShell_abstractBinFileWidget::keyReleaseEvent(QKeyEvent* arg__1)
5573 void PythonQtShell_abstractBinFileWidget::keyReleaseEvent(QKeyEvent* arg__1)
5578 {
5574 {
5579 if (_wrapper) {
5575 if (_wrapper) {
5580 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyReleaseEvent");
5576 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyReleaseEvent");
5581 PyErr_Clear();
5577 PyErr_Clear();
5582 if (obj && !PythonQtSlotFunction_Check(obj)) {
5578 if (obj && !PythonQtSlotFunction_Check(obj)) {
5583 static const char* argumentList[] ={"" , "QKeyEvent*"};
5579 static const char* argumentList[] ={"" , "QKeyEvent*"};
5584 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5580 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5585 void* args[2] = {NULL, (void*)&arg__1};
5581 void* args[2] = {NULL, (void*)&arg__1};
5586 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5582 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5587 if (result) { Py_DECREF(result); }
5583 if (result) { Py_DECREF(result); }
5588 Py_DECREF(obj);
5584 Py_DECREF(obj);
5589 return;
5585 return;
5590 }
5586 }
5591 }
5587 }
5592 abstractBinFileWidget::keyReleaseEvent(arg__1);
5588 abstractBinFileWidget::keyReleaseEvent(arg__1);
5593 }
5589 }
5594 void PythonQtShell_abstractBinFileWidget::leaveEvent(QEvent* arg__1)
5590 void PythonQtShell_abstractBinFileWidget::leaveEvent(QEvent* arg__1)
5595 {
5591 {
5596 if (_wrapper) {
5592 if (_wrapper) {
5597 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "leaveEvent");
5593 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "leaveEvent");
5598 PyErr_Clear();
5594 PyErr_Clear();
5599 if (obj && !PythonQtSlotFunction_Check(obj)) {
5595 if (obj && !PythonQtSlotFunction_Check(obj)) {
5600 static const char* argumentList[] ={"" , "QEvent*"};
5596 static const char* argumentList[] ={"" , "QEvent*"};
5601 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5597 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5602 void* args[2] = {NULL, (void*)&arg__1};
5598 void* args[2] = {NULL, (void*)&arg__1};
5603 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5599 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5604 if (result) { Py_DECREF(result); }
5600 if (result) { Py_DECREF(result); }
5605 Py_DECREF(obj);
5601 Py_DECREF(obj);
5606 return;
5602 return;
5607 }
5603 }
5608 }
5604 }
5609 abstractBinFileWidget::leaveEvent(arg__1);
5605 abstractBinFileWidget::leaveEvent(arg__1);
5610 }
5606 }
5611 int PythonQtShell_abstractBinFileWidget::metric(QPaintDevice::PaintDeviceMetric arg__1) const
5607 int PythonQtShell_abstractBinFileWidget::metric(QPaintDevice::PaintDeviceMetric arg__1) const
5612 {
5608 {
5613 if (_wrapper) {
5609 if (_wrapper) {
5614 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "metric");
5610 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "metric");
5615 PyErr_Clear();
5611 PyErr_Clear();
5616 if (obj && !PythonQtSlotFunction_Check(obj)) {
5612 if (obj && !PythonQtSlotFunction_Check(obj)) {
5617 static const char* argumentList[] ={"int" , "QPaintDevice::PaintDeviceMetric"};
5613 static const char* argumentList[] ={"int" , "QPaintDevice::PaintDeviceMetric"};
5618 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5614 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5619 int returnValue;
5615 int returnValue;
5620 void* args[2] = {NULL, (void*)&arg__1};
5616 void* args[2] = {NULL, (void*)&arg__1};
5621 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5617 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5622 if (result) {
5618 if (result) {
5623 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5619 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5624 if (args[0]!=&returnValue) {
5620 if (args[0]!=&returnValue) {
5625 if (args[0]==NULL) {
5621 if (args[0]==NULL) {
5626 PythonQt::priv()->handleVirtualOverloadReturnError("metric", methodInfo, result);
5622 PythonQt::priv()->handleVirtualOverloadReturnError("metric", methodInfo, result);
5627 } else {
5623 } else {
5628 returnValue = *((int*)args[0]);
5624 returnValue = *((int*)args[0]);
5629 }
5625 }
5630 }
5626 }
5631 }
5627 }
5632 if (result) { Py_DECREF(result); }
5628 if (result) { Py_DECREF(result); }
5633 Py_DECREF(obj);
5629 Py_DECREF(obj);
5634 return returnValue;
5630 return returnValue;
5635 }
5631 }
5636 }
5632 }
5637 return abstractBinFileWidget::metric(arg__1);
5633 return abstractBinFileWidget::metric(arg__1);
5638 }
5634 }
5639 QSize PythonQtShell_abstractBinFileWidget::minimumSizeHint() const
5635 QSize PythonQtShell_abstractBinFileWidget::minimumSizeHint() const
5640 {
5636 {
5641 if (_wrapper) {
5637 if (_wrapper) {
5642 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getMinimumSizeHint");
5638 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getMinimumSizeHint");
5643 PyErr_Clear();
5639 PyErr_Clear();
5644 if (obj && !PythonQtSlotFunction_Check(obj)) {
5640 if (obj && !PythonQtSlotFunction_Check(obj)) {
5645 static const char* argumentList[] ={"QSize"};
5641 static const char* argumentList[] ={"QSize"};
5646 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
5642 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
5647 QSize returnValue;
5643 QSize returnValue;
5648 void* args[1] = {NULL};
5644 void* args[1] = {NULL};
5649 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5645 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5650 if (result) {
5646 if (result) {
5651 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5647 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5652 if (args[0]!=&returnValue) {
5648 if (args[0]!=&returnValue) {
5653 if (args[0]==NULL) {
5649 if (args[0]==NULL) {
5654 PythonQt::priv()->handleVirtualOverloadReturnError("getMinimumSizeHint", methodInfo, result);
5650 PythonQt::priv()->handleVirtualOverloadReturnError("getMinimumSizeHint", methodInfo, result);
5655 } else {
5651 } else {
5656 returnValue = *((QSize*)args[0]);
5652 returnValue = *((QSize*)args[0]);
5657 }
5653 }
5658 }
5654 }
5659 }
5655 }
5660 if (result) { Py_DECREF(result); }
5656 if (result) { Py_DECREF(result); }
5661 Py_DECREF(obj);
5657 Py_DECREF(obj);
5662 return returnValue;
5658 return returnValue;
5663 }
5659 }
5664 }
5660 }
5665 return abstractBinFileWidget::minimumSizeHint();
5661 return abstractBinFileWidget::minimumSizeHint();
5666 }
5662 }
5667 void PythonQtShell_abstractBinFileWidget::mouseDoubleClickEvent(QMouseEvent* arg__1)
5663 void PythonQtShell_abstractBinFileWidget::mouseDoubleClickEvent(QMouseEvent* arg__1)
5668 {
5664 {
5669 if (_wrapper) {
5665 if (_wrapper) {
5670 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseDoubleClickEvent");
5666 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseDoubleClickEvent");
5671 PyErr_Clear();
5667 PyErr_Clear();
5672 if (obj && !PythonQtSlotFunction_Check(obj)) {
5668 if (obj && !PythonQtSlotFunction_Check(obj)) {
5673 static const char* argumentList[] ={"" , "QMouseEvent*"};
5669 static const char* argumentList[] ={"" , "QMouseEvent*"};
5674 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5670 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5675 void* args[2] = {NULL, (void*)&arg__1};
5671 void* args[2] = {NULL, (void*)&arg__1};
5676 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5672 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5677 if (result) { Py_DECREF(result); }
5673 if (result) { Py_DECREF(result); }
5678 Py_DECREF(obj);
5674 Py_DECREF(obj);
5679 return;
5675 return;
5680 }
5676 }
5681 }
5677 }
5682 abstractBinFileWidget::mouseDoubleClickEvent(arg__1);
5678 abstractBinFileWidget::mouseDoubleClickEvent(arg__1);
5683 }
5679 }
5684 void PythonQtShell_abstractBinFileWidget::mouseMoveEvent(QMouseEvent* arg__1)
5680 void PythonQtShell_abstractBinFileWidget::mouseMoveEvent(QMouseEvent* arg__1)
5685 {
5681 {
5686 if (_wrapper) {
5682 if (_wrapper) {
5687 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseMoveEvent");
5683 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseMoveEvent");
5688 PyErr_Clear();
5684 PyErr_Clear();
5689 if (obj && !PythonQtSlotFunction_Check(obj)) {
5685 if (obj && !PythonQtSlotFunction_Check(obj)) {
5690 static const char* argumentList[] ={"" , "QMouseEvent*"};
5686 static const char* argumentList[] ={"" , "QMouseEvent*"};
5691 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5687 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5692 void* args[2] = {NULL, (void*)&arg__1};
5688 void* args[2] = {NULL, (void*)&arg__1};
5693 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5689 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5694 if (result) { Py_DECREF(result); }
5690 if (result) { Py_DECREF(result); }
5695 Py_DECREF(obj);
5691 Py_DECREF(obj);
5696 return;
5692 return;
5697 }
5693 }
5698 }
5694 }
5699 abstractBinFileWidget::mouseMoveEvent(arg__1);
5695 abstractBinFileWidget::mouseMoveEvent(arg__1);
5700 }
5696 }
5701 void PythonQtShell_abstractBinFileWidget::mousePressEvent(QMouseEvent* arg__1)
5697 void PythonQtShell_abstractBinFileWidget::mousePressEvent(QMouseEvent* arg__1)
5702 {
5698 {
5703 if (_wrapper) {
5699 if (_wrapper) {
5704 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mousePressEvent");
5700 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mousePressEvent");
5705 PyErr_Clear();
5701 PyErr_Clear();
5706 if (obj && !PythonQtSlotFunction_Check(obj)) {
5702 if (obj && !PythonQtSlotFunction_Check(obj)) {
5707 static const char* argumentList[] ={"" , "QMouseEvent*"};
5703 static const char* argumentList[] ={"" , "QMouseEvent*"};
5708 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5704 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5709 void* args[2] = {NULL, (void*)&arg__1};
5705 void* args[2] = {NULL, (void*)&arg__1};
5710 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5706 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5711 if (result) { Py_DECREF(result); }
5707 if (result) { Py_DECREF(result); }
5712 Py_DECREF(obj);
5708 Py_DECREF(obj);
5713 return;
5709 return;
5714 }
5710 }
5715 }
5711 }
5716 abstractBinFileWidget::mousePressEvent(arg__1);
5712 abstractBinFileWidget::mousePressEvent(arg__1);
5717 }
5713 }
5718 void PythonQtShell_abstractBinFileWidget::mouseReleaseEvent(QMouseEvent* arg__1)
5714 void PythonQtShell_abstractBinFileWidget::mouseReleaseEvent(QMouseEvent* arg__1)
5719 {
5715 {
5720 if (_wrapper) {
5716 if (_wrapper) {
5721 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseReleaseEvent");
5717 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseReleaseEvent");
5722 PyErr_Clear();
5718 PyErr_Clear();
5723 if (obj && !PythonQtSlotFunction_Check(obj)) {
5719 if (obj && !PythonQtSlotFunction_Check(obj)) {
5724 static const char* argumentList[] ={"" , "QMouseEvent*"};
5720 static const char* argumentList[] ={"" , "QMouseEvent*"};
5725 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5721 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5726 void* args[2] = {NULL, (void*)&arg__1};
5722 void* args[2] = {NULL, (void*)&arg__1};
5727 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5723 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5728 if (result) { Py_DECREF(result); }
5724 if (result) { Py_DECREF(result); }
5729 Py_DECREF(obj);
5725 Py_DECREF(obj);
5730 return;
5726 return;
5731 }
5727 }
5732 }
5728 }
5733 abstractBinFileWidget::mouseReleaseEvent(arg__1);
5729 abstractBinFileWidget::mouseReleaseEvent(arg__1);
5734 }
5730 }
5735 void PythonQtShell_abstractBinFileWidget::moveEvent(QMoveEvent* arg__1)
5731 void PythonQtShell_abstractBinFileWidget::moveEvent(QMoveEvent* arg__1)
5736 {
5732 {
5737 if (_wrapper) {
5733 if (_wrapper) {
5738 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "moveEvent");
5734 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "moveEvent");
5739 PyErr_Clear();
5735 PyErr_Clear();
5740 if (obj && !PythonQtSlotFunction_Check(obj)) {
5736 if (obj && !PythonQtSlotFunction_Check(obj)) {
5741 static const char* argumentList[] ={"" , "QMoveEvent*"};
5737 static const char* argumentList[] ={"" , "QMoveEvent*"};
5742 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5738 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5743 void* args[2] = {NULL, (void*)&arg__1};
5739 void* args[2] = {NULL, (void*)&arg__1};
5744 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5740 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5745 if (result) { Py_DECREF(result); }
5741 if (result) { Py_DECREF(result); }
5746 Py_DECREF(obj);
5742 Py_DECREF(obj);
5747 return;
5743 return;
5748 }
5744 }
5749 }
5745 }
5750 abstractBinFileWidget::moveEvent(arg__1);
5746 abstractBinFileWidget::moveEvent(arg__1);
5751 }
5747 }
5752 bool PythonQtShell_abstractBinFileWidget::nativeEvent(const QByteArray& eventType, void* message, long* result)
5748 bool PythonQtShell_abstractBinFileWidget::nativeEvent(const QByteArray& eventType, void* message, long* result)
5753 {
5749 {
5754 if (_wrapper) {
5750 if (_wrapper) {
5755 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "nativeEvent");
5751 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "nativeEvent");
5756 PyErr_Clear();
5752 PyErr_Clear();
5757 if (obj && !PythonQtSlotFunction_Check(obj)) {
5753 if (obj && !PythonQtSlotFunction_Check(obj)) {
5758 static const char* argumentList[] ={"bool" , "const QByteArray&" , "void*" , "long*"};
5754 static const char* argumentList[] ={"bool" , "const QByteArray&" , "void*" , "long*"};
5759 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
5755 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
5760 bool returnValue;
5756 bool returnValue;
5761 void* args[4] = {NULL, (void*)&eventType, (void*)&message, (void*)&result};
5757 void* args[4] = {NULL, (void*)&eventType, (void*)&message, (void*)&result};
5762 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5758 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5763 if (result) {
5759 if (result) {
5764 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5760 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5765 if (args[0]!=&returnValue) {
5761 if (args[0]!=&returnValue) {
5766 if (args[0]==NULL) {
5762 if (args[0]==NULL) {
5767 PythonQt::priv()->handleVirtualOverloadReturnError("nativeEvent", methodInfo, result);
5763 PythonQt::priv()->handleVirtualOverloadReturnError("nativeEvent", methodInfo, result);
5768 } else {
5764 } else {
5769 returnValue = *((bool*)args[0]);
5765 returnValue = *((bool*)args[0]);
5770 }
5766 }
5771 }
5767 }
5772 }
5768 }
5773 if (result) { Py_DECREF(result); }
5769 if (result) { Py_DECREF(result); }
5774 Py_DECREF(obj);
5770 Py_DECREF(obj);
5775 return returnValue;
5771 return returnValue;
5776 }
5772 }
5777 }
5773 }
5778 return abstractBinFileWidget::nativeEvent(eventType, message, result);
5774 return abstractBinFileWidget::nativeEvent(eventType, message, result);
5779 }
5775 }
5780 QPaintEngine* PythonQtShell_abstractBinFileWidget::paintEngine() const
5776 QPaintEngine* PythonQtShell_abstractBinFileWidget::paintEngine() const
5781 {
5777 {
5782 if (_wrapper) {
5778 if (_wrapper) {
5783 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEngine");
5779 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEngine");
5784 PyErr_Clear();
5780 PyErr_Clear();
5785 if (obj && !PythonQtSlotFunction_Check(obj)) {
5781 if (obj && !PythonQtSlotFunction_Check(obj)) {
5786 static const char* argumentList[] ={"QPaintEngine*"};
5782 static const char* argumentList[] ={"QPaintEngine*"};
5787 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
5783 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
5788 QPaintEngine* returnValue;
5784 QPaintEngine* returnValue;
5789 void* args[1] = {NULL};
5785 void* args[1] = {NULL};
5790 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5786 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5791 if (result) {
5787 if (result) {
5792 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5788 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5793 if (args[0]!=&returnValue) {
5789 if (args[0]!=&returnValue) {
5794 if (args[0]==NULL) {
5790 if (args[0]==NULL) {
5795 PythonQt::priv()->handleVirtualOverloadReturnError("paintEngine", methodInfo, result);
5791 PythonQt::priv()->handleVirtualOverloadReturnError("paintEngine", methodInfo, result);
5796 } else {
5792 } else {
5797 returnValue = *((QPaintEngine**)args[0]);
5793 returnValue = *((QPaintEngine**)args[0]);
5798 }
5794 }
5799 }
5795 }
5800 }
5796 }
5801 if (result) { Py_DECREF(result); }
5797 if (result) { Py_DECREF(result); }
5802 Py_DECREF(obj);
5798 Py_DECREF(obj);
5803 return returnValue;
5799 return returnValue;
5804 }
5800 }
5805 }
5801 }
5806 return abstractBinFileWidget::paintEngine();
5802 return abstractBinFileWidget::paintEngine();
5807 }
5803 }
5808 void PythonQtShell_abstractBinFileWidget::paintEvent(QPaintEvent* arg__1)
5804 void PythonQtShell_abstractBinFileWidget::paintEvent(QPaintEvent* arg__1)
5809 {
5805 {
5810 if (_wrapper) {
5806 if (_wrapper) {
5811 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEvent");
5807 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEvent");
5812 PyErr_Clear();
5808 PyErr_Clear();
5813 if (obj && !PythonQtSlotFunction_Check(obj)) {
5809 if (obj && !PythonQtSlotFunction_Check(obj)) {
5814 static const char* argumentList[] ={"" , "QPaintEvent*"};
5810 static const char* argumentList[] ={"" , "QPaintEvent*"};
5815 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5811 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5816 void* args[2] = {NULL, (void*)&arg__1};
5812 void* args[2] = {NULL, (void*)&arg__1};
5817 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5813 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5818 if (result) { Py_DECREF(result); }
5814 if (result) { Py_DECREF(result); }
5819 Py_DECREF(obj);
5815 Py_DECREF(obj);
5820 return;
5816 return;
5821 }
5817 }
5822 }
5818 }
5823 abstractBinFileWidget::paintEvent(arg__1);
5819 abstractBinFileWidget::paintEvent(arg__1);
5824 }
5820 }
5825 QPaintDevice* PythonQtShell_abstractBinFileWidget::redirected(QPoint* offset) const
5821 QPaintDevice* PythonQtShell_abstractBinFileWidget::redirected(QPoint* offset) const
5826 {
5822 {
5827 if (_wrapper) {
5823 if (_wrapper) {
5828 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "redirected");
5824 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "redirected");
5829 PyErr_Clear();
5825 PyErr_Clear();
5830 if (obj && !PythonQtSlotFunction_Check(obj)) {
5826 if (obj && !PythonQtSlotFunction_Check(obj)) {
5831 static const char* argumentList[] ={"QPaintDevice*" , "QPoint*"};
5827 static const char* argumentList[] ={"QPaintDevice*" , "QPoint*"};
5832 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5828 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5833 QPaintDevice* returnValue;
5829 QPaintDevice* returnValue;
5834 void* args[2] = {NULL, (void*)&offset};
5830 void* args[2] = {NULL, (void*)&offset};
5835 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5831 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5836 if (result) {
5832 if (result) {
5837 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5833 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5838 if (args[0]!=&returnValue) {
5834 if (args[0]!=&returnValue) {
5839 if (args[0]==NULL) {
5835 if (args[0]==NULL) {
5840 PythonQt::priv()->handleVirtualOverloadReturnError("redirected", methodInfo, result);
5836 PythonQt::priv()->handleVirtualOverloadReturnError("redirected", methodInfo, result);
5841 } else {
5837 } else {
5842 returnValue = *((QPaintDevice**)args[0]);
5838 returnValue = *((QPaintDevice**)args[0]);
5843 }
5839 }
5844 }
5840 }
5845 }
5841 }
5846 if (result) { Py_DECREF(result); }
5842 if (result) { Py_DECREF(result); }
5847 Py_DECREF(obj);
5843 Py_DECREF(obj);
5848 return returnValue;
5844 return returnValue;
5849 }
5845 }
5850 }
5846 }
5851 return abstractBinFileWidget::redirected(offset);
5847 return abstractBinFileWidget::redirected(offset);
5852 }
5848 }
5853 void PythonQtShell_abstractBinFileWidget::reloadFile()
5849 void PythonQtShell_abstractBinFileWidget::reloadFile()
5854 {
5850 {
5855 if (_wrapper) {
5851 if (_wrapper) {
5856 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "reloadFile");
5852 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "reloadFile");
5857 PyErr_Clear();
5853 PyErr_Clear();
5858 if (obj && !PythonQtSlotFunction_Check(obj)) {
5854 if (obj && !PythonQtSlotFunction_Check(obj)) {
5859 static const char* argumentList[] ={""};
5855 static const char* argumentList[] ={""};
5860 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
5856 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
5861 void* args[1] = {NULL};
5857 void* args[1] = {NULL};
5862 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5858 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5863 if (result) { Py_DECREF(result); }
5859 if (result) { Py_DECREF(result); }
5864 Py_DECREF(obj);
5860 Py_DECREF(obj);
5865 return;
5861 return;
5866 }
5862 }
5867 }
5863 }
5868
5864
5869 }
5865 }
5870 void PythonQtShell_abstractBinFileWidget::resizeEvent(QResizeEvent* arg__1)
5866 void PythonQtShell_abstractBinFileWidget::resizeEvent(QResizeEvent* arg__1)
5871 {
5867 {
5872 if (_wrapper) {
5868 if (_wrapper) {
5873 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "resizeEvent");
5869 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "resizeEvent");
5874 PyErr_Clear();
5870 PyErr_Clear();
5875 if (obj && !PythonQtSlotFunction_Check(obj)) {
5871 if (obj && !PythonQtSlotFunction_Check(obj)) {
5876 static const char* argumentList[] ={"" , "QResizeEvent*"};
5872 static const char* argumentList[] ={"" , "QResizeEvent*"};
5877 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5873 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5878 void* args[2] = {NULL, (void*)&arg__1};
5874 void* args[2] = {NULL, (void*)&arg__1};
5879 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5875 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5880 if (result) { Py_DECREF(result); }
5876 if (result) { Py_DECREF(result); }
5881 Py_DECREF(obj);
5877 Py_DECREF(obj);
5882 return;
5878 return;
5883 }
5879 }
5884 }
5880 }
5885 abstractBinFileWidget::resizeEvent(arg__1);
5881 abstractBinFileWidget::resizeEvent(arg__1);
5886 }
5882 }
5887 void PythonQtShell_abstractBinFileWidget::setFile(abstractBinFile* file)
5883 void PythonQtShell_abstractBinFileWidget::setFile(abstractBinFile* file)
5888 {
5884 {
5889 if (_wrapper) {
5885 if (_wrapper) {
5890 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "setFile");
5886 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "setFile");
5891 PyErr_Clear();
5887 PyErr_Clear();
5892 if (obj && !PythonQtSlotFunction_Check(obj)) {
5888 if (obj && !PythonQtSlotFunction_Check(obj)) {
5893 static const char* argumentList[] ={"" , "abstractBinFile*"};
5889 static const char* argumentList[] ={"" , "abstractBinFile*"};
5894 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5890 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5895 void* args[2] = {NULL, (void*)&file};
5891 void* args[2] = {NULL, (void*)&file};
5896 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5892 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5897 if (result) { Py_DECREF(result); }
5893 if (result) { Py_DECREF(result); }
5898 Py_DECREF(obj);
5894 Py_DECREF(obj);
5899 return;
5895 return;
5900 }
5896 }
5901 }
5897 }
5902
5898
5903 }
5899 }
5904 QPainter* PythonQtShell_abstractBinFileWidget::sharedPainter() const
5900 QPainter* PythonQtShell_abstractBinFileWidget::sharedPainter() const
5905 {
5901 {
5906 if (_wrapper) {
5902 if (_wrapper) {
5907 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "sharedPainter");
5903 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "sharedPainter");
5908 PyErr_Clear();
5904 PyErr_Clear();
5909 if (obj && !PythonQtSlotFunction_Check(obj)) {
5905 if (obj && !PythonQtSlotFunction_Check(obj)) {
5910 static const char* argumentList[] ={"QPainter*"};
5906 static const char* argumentList[] ={"QPainter*"};
5911 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
5907 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
5912 QPainter* returnValue;
5908 QPainter* returnValue;
5913 void* args[1] = {NULL};
5909 void* args[1] = {NULL};
5914 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5910 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5915 if (result) {
5911 if (result) {
5916 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5912 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5917 if (args[0]!=&returnValue) {
5913 if (args[0]!=&returnValue) {
5918 if (args[0]==NULL) {
5914 if (args[0]==NULL) {
5919 PythonQt::priv()->handleVirtualOverloadReturnError("sharedPainter", methodInfo, result);
5915 PythonQt::priv()->handleVirtualOverloadReturnError("sharedPainter", methodInfo, result);
5920 } else {
5916 } else {
5921 returnValue = *((QPainter**)args[0]);
5917 returnValue = *((QPainter**)args[0]);
5922 }
5918 }
5923 }
5919 }
5924 }
5920 }
5925 if (result) { Py_DECREF(result); }
5921 if (result) { Py_DECREF(result); }
5926 Py_DECREF(obj);
5922 Py_DECREF(obj);
5927 return returnValue;
5923 return returnValue;
5928 }
5924 }
5929 }
5925 }
5930 return abstractBinFileWidget::sharedPainter();
5926 return abstractBinFileWidget::sharedPainter();
5931 }
5927 }
5932 void PythonQtShell_abstractBinFileWidget::showEvent(QShowEvent* arg__1)
5928 void PythonQtShell_abstractBinFileWidget::showEvent(QShowEvent* arg__1)
5933 {
5929 {
5934 if (_wrapper) {
5930 if (_wrapper) {
5935 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "showEvent");
5931 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "showEvent");
5936 PyErr_Clear();
5932 PyErr_Clear();
5937 if (obj && !PythonQtSlotFunction_Check(obj)) {
5933 if (obj && !PythonQtSlotFunction_Check(obj)) {
5938 static const char* argumentList[] ={"" , "QShowEvent*"};
5934 static const char* argumentList[] ={"" , "QShowEvent*"};
5939 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5935 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5940 void* args[2] = {NULL, (void*)&arg__1};
5936 void* args[2] = {NULL, (void*)&arg__1};
5941 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5937 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5942 if (result) { Py_DECREF(result); }
5938 if (result) { Py_DECREF(result); }
5943 Py_DECREF(obj);
5939 Py_DECREF(obj);
5944 return;
5940 return;
5945 }
5941 }
5946 }
5942 }
5947 abstractBinFileWidget::showEvent(arg__1);
5943 abstractBinFileWidget::showEvent(arg__1);
5948 }
5944 }
5949 QSize PythonQtShell_abstractBinFileWidget::sizeHint() const
5945 QSize PythonQtShell_abstractBinFileWidget::sizeHint() const
5950 {
5946 {
5951 if (_wrapper) {
5947 if (_wrapper) {
5952 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getSizeHint");
5948 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getSizeHint");
5953 PyErr_Clear();
5949 PyErr_Clear();
5954 if (obj && !PythonQtSlotFunction_Check(obj)) {
5950 if (obj && !PythonQtSlotFunction_Check(obj)) {
5955 static const char* argumentList[] ={"QSize"};
5951 static const char* argumentList[] ={"QSize"};
5956 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
5952 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
5957 QSize returnValue;
5953 QSize returnValue;
5958 void* args[1] = {NULL};
5954 void* args[1] = {NULL};
5959 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5955 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5960 if (result) {
5956 if (result) {
5961 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5957 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
5962 if (args[0]!=&returnValue) {
5958 if (args[0]!=&returnValue) {
5963 if (args[0]==NULL) {
5959 if (args[0]==NULL) {
5964 PythonQt::priv()->handleVirtualOverloadReturnError("getSizeHint", methodInfo, result);
5960 PythonQt::priv()->handleVirtualOverloadReturnError("getSizeHint", methodInfo, result);
5965 } else {
5961 } else {
5966 returnValue = *((QSize*)args[0]);
5962 returnValue = *((QSize*)args[0]);
5967 }
5963 }
5968 }
5964 }
5969 }
5965 }
5970 if (result) { Py_DECREF(result); }
5966 if (result) { Py_DECREF(result); }
5971 Py_DECREF(obj);
5967 Py_DECREF(obj);
5972 return returnValue;
5968 return returnValue;
5973 }
5969 }
5974 }
5970 }
5975 return abstractBinFileWidget::sizeHint();
5971 return abstractBinFileWidget::sizeHint();
5976 }
5972 }
5977 void PythonQtShell_abstractBinFileWidget::tabletEvent(QTabletEvent* arg__1)
5973 void PythonQtShell_abstractBinFileWidget::tabletEvent(QTabletEvent* arg__1)
5978 {
5974 {
5979 if (_wrapper) {
5975 if (_wrapper) {
5980 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "tabletEvent");
5976 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "tabletEvent");
5981 PyErr_Clear();
5977 PyErr_Clear();
5982 if (obj && !PythonQtSlotFunction_Check(obj)) {
5978 if (obj && !PythonQtSlotFunction_Check(obj)) {
5983 static const char* argumentList[] ={"" , "QTabletEvent*"};
5979 static const char* argumentList[] ={"" , "QTabletEvent*"};
5984 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5980 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5985 void* args[2] = {NULL, (void*)&arg__1};
5981 void* args[2] = {NULL, (void*)&arg__1};
5986 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5982 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5987 if (result) { Py_DECREF(result); }
5983 if (result) { Py_DECREF(result); }
5988 Py_DECREF(obj);
5984 Py_DECREF(obj);
5989 return;
5985 return;
5990 }
5986 }
5991 }
5987 }
5992 abstractBinFileWidget::tabletEvent(arg__1);
5988 abstractBinFileWidget::tabletEvent(arg__1);
5993 }
5989 }
5994 void PythonQtShell_abstractBinFileWidget::timerEvent(QTimerEvent* arg__1)
5990 void PythonQtShell_abstractBinFileWidget::timerEvent(QTimerEvent* arg__1)
5995 {
5991 {
5996 if (_wrapper) {
5992 if (_wrapper) {
5997 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "timerEvent");
5993 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "timerEvent");
5998 PyErr_Clear();
5994 PyErr_Clear();
5999 if (obj && !PythonQtSlotFunction_Check(obj)) {
5995 if (obj && !PythonQtSlotFunction_Check(obj)) {
6000 static const char* argumentList[] ={"" , "QTimerEvent*"};
5996 static const char* argumentList[] ={"" , "QTimerEvent*"};
6001 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
5997 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6002 void* args[2] = {NULL, (void*)&arg__1};
5998 void* args[2] = {NULL, (void*)&arg__1};
6003 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
5999 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6004 if (result) { Py_DECREF(result); }
6000 if (result) { Py_DECREF(result); }
6005 Py_DECREF(obj);
6001 Py_DECREF(obj);
6006 return;
6002 return;
6007 }
6003 }
6008 }
6004 }
6009 abstractBinFileWidget::timerEvent(arg__1);
6005 abstractBinFileWidget::timerEvent(arg__1);
6010 }
6006 }
6011 void PythonQtShell_abstractBinFileWidget::wheelEvent(QWheelEvent* arg__1)
6007 void PythonQtShell_abstractBinFileWidget::wheelEvent(QWheelEvent* arg__1)
6012 {
6008 {
6013 if (_wrapper) {
6009 if (_wrapper) {
6014 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "wheelEvent");
6010 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "wheelEvent");
6015 PyErr_Clear();
6011 PyErr_Clear();
6016 if (obj && !PythonQtSlotFunction_Check(obj)) {
6012 if (obj && !PythonQtSlotFunction_Check(obj)) {
6017 static const char* argumentList[] ={"" , "QWheelEvent*"};
6013 static const char* argumentList[] ={"" , "QWheelEvent*"};
6018 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6014 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6019 void* args[2] = {NULL, (void*)&arg__1};
6015 void* args[2] = {NULL, (void*)&arg__1};
6020 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6016 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6021 if (result) { Py_DECREF(result); }
6017 if (result) { Py_DECREF(result); }
6022 Py_DECREF(obj);
6018 Py_DECREF(obj);
6023 return;
6019 return;
6024 }
6020 }
6025 }
6021 }
6026 abstractBinFileWidget::wheelEvent(arg__1);
6022 abstractBinFileWidget::wheelEvent(arg__1);
6027 }
6023 }
6028 abstractBinFileWidget* PythonQtWrapper_abstractBinFileWidget::new_abstractBinFileWidget(QWidget* parent)
6024 abstractBinFileWidget* PythonQtWrapper_abstractBinFileWidget::new_abstractBinFileWidget(QWidget* parent)
6029 {
6025 {
6030 return new PythonQtShell_abstractBinFileWidget(parent); }
6026 return new PythonQtShell_abstractBinFileWidget(parent); }
6031
6027
6032
6028
6033
6029
6034 PythonQtShell_binaryFile::~PythonQtShell_binaryFile() {
6030 PythonQtShell_binaryFile::~PythonQtShell_binaryFile() {
6035 PythonQtPrivate* priv = PythonQt::priv();
6031 PythonQtPrivate* priv = PythonQt::priv();
6036 if (priv) { priv->shellClassDeleted(this); }
6032 if (priv) { priv->shellClassDeleted(this); }
6037 }
6033 }
6038 int PythonQtShell_binaryFile::closeFile()
6034 int PythonQtShell_binaryFile::closeFile()
6039 {
6035 {
6040 if (_wrapper) {
6036 if (_wrapper) {
6041 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "closeFile");
6037 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "closeFile");
6042 PyErr_Clear();
6038 PyErr_Clear();
6043 if (obj && !PythonQtSlotFunction_Check(obj)) {
6039 if (obj && !PythonQtSlotFunction_Check(obj)) {
6044 static const char* argumentList[] ={"int"};
6040 static const char* argumentList[] ={"int"};
6045 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
6041 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
6046 int returnValue;
6042 int returnValue;
6047 void* args[1] = {NULL};
6043 void* args[1] = {NULL};
6048 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6044 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6049 if (result) {
6045 if (result) {
6050 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6046 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6051 if (args[0]!=&returnValue) {
6047 if (args[0]!=&returnValue) {
6052 if (args[0]==NULL) {
6048 if (args[0]==NULL) {
6053 PythonQt::priv()->handleVirtualOverloadReturnError("closeFile", methodInfo, result);
6049 PythonQt::priv()->handleVirtualOverloadReturnError("closeFile", methodInfo, result);
6054 } else {
6050 } else {
6055 returnValue = *((int*)args[0]);
6051 returnValue = *((int*)args[0]);
6056 }
6052 }
6057 }
6053 }
6058 }
6054 }
6059 if (result) { Py_DECREF(result); }
6055 if (result) { Py_DECREF(result); }
6060 Py_DECREF(obj);
6056 Py_DECREF(obj);
6061 return returnValue;
6057 return returnValue;
6062 }
6058 }
6063 }
6059 }
6064 return binaryFile::closeFile();
6060 return binaryFile::closeFile();
6065 }
6061 }
6066 QList<codeFragment* > PythonQtShell_binaryFile::getFragments()
6062 QList<codeFragment* > PythonQtShell_binaryFile::getFragments()
6067 {
6063 {
6068 if (_wrapper) {
6064 if (_wrapper) {
6069 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getFragments");
6065 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getFragments");
6070 PyErr_Clear();
6066 PyErr_Clear();
6071 if (obj && !PythonQtSlotFunction_Check(obj)) {
6067 if (obj && !PythonQtSlotFunction_Check(obj)) {
6072 static const char* argumentList[] ={"QList<codeFragment* >"};
6068 static const char* argumentList[] ={"QList<codeFragment* >"};
6073 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
6069 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
6074 QList<codeFragment* > returnValue;
6070 QList<codeFragment* > returnValue;
6075 void* args[1] = {NULL};
6071 void* args[1] = {NULL};
6076 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6072 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6077 if (result) {
6073 if (result) {
6078 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6074 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6079 if (args[0]!=&returnValue) {
6075 if (args[0]!=&returnValue) {
6080 if (args[0]==NULL) {
6076 if (args[0]==NULL) {
6081 PythonQt::priv()->handleVirtualOverloadReturnError("getFragments", methodInfo, result);
6077 PythonQt::priv()->handleVirtualOverloadReturnError("getFragments", methodInfo, result);
6082 } else {
6078 } else {
6083 returnValue = *((QList<codeFragment* >*)args[0]);
6079 returnValue = *((QList<codeFragment* >*)args[0]);
6084 }
6080 }
6085 }
6081 }
6086 }
6082 }
6087 if (result) { Py_DECREF(result); }
6083 if (result) { Py_DECREF(result); }
6088 Py_DECREF(obj);
6084 Py_DECREF(obj);
6089 return returnValue;
6085 return returnValue;
6090 }
6086 }
6091 }
6087 }
6092 return binaryFile::getFragments();
6088 return binaryFile::getFragments();
6093 }
6089 }
6094 bool PythonQtShell_binaryFile::isopened()
6090 bool PythonQtShell_binaryFile::isopened()
6095 {
6091 {
6096 if (_wrapper) {
6092 if (_wrapper) {
6097 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "isopened");
6093 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "isopened");
6098 PyErr_Clear();
6094 PyErr_Clear();
6099 if (obj && !PythonQtSlotFunction_Check(obj)) {
6095 if (obj && !PythonQtSlotFunction_Check(obj)) {
6100 static const char* argumentList[] ={"bool"};
6096 static const char* argumentList[] ={"bool"};
6101 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
6097 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
6102 bool returnValue;
6098 bool returnValue;
6103 void* args[1] = {NULL};
6099 void* args[1] = {NULL};
6104 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6100 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6105 if (result) {
6101 if (result) {
6106 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6102 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6107 if (args[0]!=&returnValue) {
6103 if (args[0]!=&returnValue) {
6108 if (args[0]==NULL) {
6104 if (args[0]==NULL) {
6109 PythonQt::priv()->handleVirtualOverloadReturnError("isopened", methodInfo, result);
6105 PythonQt::priv()->handleVirtualOverloadReturnError("isopened", methodInfo, result);
6110 } else {
6106 } else {
6111 returnValue = *((bool*)args[0]);
6107 returnValue = *((bool*)args[0]);
6112 }
6108 }
6113 }
6109 }
6114 }
6110 }
6115 if (result) { Py_DECREF(result); }
6111 if (result) { Py_DECREF(result); }
6116 Py_DECREF(obj);
6112 Py_DECREF(obj);
6117 return returnValue;
6113 return returnValue;
6118 }
6114 }
6119 }
6115 }
6120 return binaryFile::isopened();
6116 return binaryFile::isopened();
6121 }
6117 }
6122 bool PythonQtShell_binaryFile::openFile(const QString& File)
6118 bool PythonQtShell_binaryFile::openFile(const QString& File)
6123 {
6119 {
6124 if (_wrapper) {
6120 if (_wrapper) {
6125 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "openFile");
6121 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "openFile");
6126 PyErr_Clear();
6122 PyErr_Clear();
6127 if (obj && !PythonQtSlotFunction_Check(obj)) {
6123 if (obj && !PythonQtSlotFunction_Check(obj)) {
6128 static const char* argumentList[] ={"bool" , "const QString&"};
6124 static const char* argumentList[] ={"bool" , "const QString&"};
6129 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6125 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6130 bool returnValue;
6126 bool returnValue;
6131 void* args[2] = {NULL, (void*)&File};
6127 void* args[2] = {NULL, (void*)&File};
6132 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6128 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6133 if (result) {
6129 if (result) {
6134 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6130 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6135 if (args[0]!=&returnValue) {
6131 if (args[0]!=&returnValue) {
6136 if (args[0]==NULL) {
6132 if (args[0]==NULL) {
6137 PythonQt::priv()->handleVirtualOverloadReturnError("openFile", methodInfo, result);
6133 PythonQt::priv()->handleVirtualOverloadReturnError("openFile", methodInfo, result);
6138 } else {
6134 } else {
6139 returnValue = *((bool*)args[0]);
6135 returnValue = *((bool*)args[0]);
6140 }
6136 }
6141 }
6137 }
6142 }
6138 }
6143 if (result) { Py_DECREF(result); }
6139 if (result) { Py_DECREF(result); }
6144 Py_DECREF(obj);
6140 Py_DECREF(obj);
6145 return returnValue;
6141 return returnValue;
6146 }
6142 }
6147 }
6143 }
6148 return binaryFile::openFile(File);
6144 return binaryFile::openFile(File);
6149 }
6145 }
6150 bool PythonQtShell_binaryFile::toBinary(const QString& fileName)
6146 bool PythonQtShell_binaryFile::toBinary(const QString& fileName)
6151 {
6147 {
6152 if (_wrapper) {
6148 if (_wrapper) {
6153 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "toBinary");
6149 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "toBinary");
6154 PyErr_Clear();
6150 PyErr_Clear();
6155 if (obj && !PythonQtSlotFunction_Check(obj)) {
6151 if (obj && !PythonQtSlotFunction_Check(obj)) {
6156 static const char* argumentList[] ={"bool" , "const QString&"};
6152 static const char* argumentList[] ={"bool" , "const QString&"};
6157 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6153 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6158 bool returnValue;
6154 bool returnValue;
6159 void* args[2] = {NULL, (void*)&fileName};
6155 void* args[2] = {NULL, (void*)&fileName};
6160 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6156 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6161 if (result) {
6157 if (result) {
6162 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6158 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6163 if (args[0]!=&returnValue) {
6159 if (args[0]!=&returnValue) {
6164 if (args[0]==NULL) {
6160 if (args[0]==NULL) {
6165 PythonQt::priv()->handleVirtualOverloadReturnError("toBinary", methodInfo, result);
6161 PythonQt::priv()->handleVirtualOverloadReturnError("toBinary", methodInfo, result);
6166 } else {
6162 } else {
6167 returnValue = *((bool*)args[0]);
6163 returnValue = *((bool*)args[0]);
6168 }
6164 }
6169 }
6165 }
6170 }
6166 }
6171 if (result) { Py_DECREF(result); }
6167 if (result) { Py_DECREF(result); }
6172 Py_DECREF(obj);
6168 Py_DECREF(obj);
6173 return returnValue;
6169 return returnValue;
6174 }
6170 }
6175 }
6171 }
6176 return binaryFile::toBinary(fileName);
6172 return binaryFile::toBinary(fileName);
6177 }
6173 }
6178 bool PythonQtShell_binaryFile::toSrec(const QString& fileName)
6174 bool PythonQtShell_binaryFile::toSrec(const QString& fileName)
6179 {
6175 {
6180 if (_wrapper) {
6176 if (_wrapper) {
6181 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "toSrec");
6177 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "toSrec");
6182 PyErr_Clear();
6178 PyErr_Clear();
6183 if (obj && !PythonQtSlotFunction_Check(obj)) {
6179 if (obj && !PythonQtSlotFunction_Check(obj)) {
6184 static const char* argumentList[] ={"bool" , "const QString&"};
6180 static const char* argumentList[] ={"bool" , "const QString&"};
6185 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6181 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6186 bool returnValue;
6182 bool returnValue;
6187 void* args[2] = {NULL, (void*)&fileName};
6183 void* args[2] = {NULL, (void*)&fileName};
6188 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6184 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6189 if (result) {
6185 if (result) {
6190 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6186 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6191 if (args[0]!=&returnValue) {
6187 if (args[0]!=&returnValue) {
6192 if (args[0]==NULL) {
6188 if (args[0]==NULL) {
6193 PythonQt::priv()->handleVirtualOverloadReturnError("toSrec", methodInfo, result);
6189 PythonQt::priv()->handleVirtualOverloadReturnError("toSrec", methodInfo, result);
6194 } else {
6190 } else {
6195 returnValue = *((bool*)args[0]);
6191 returnValue = *((bool*)args[0]);
6196 }
6192 }
6197 }
6193 }
6198 }
6194 }
6199 if (result) { Py_DECREF(result); }
6195 if (result) { Py_DECREF(result); }
6200 Py_DECREF(obj);
6196 Py_DECREF(obj);
6201 return returnValue;
6197 return returnValue;
6202 }
6198 }
6203 }
6199 }
6204 return binaryFile::toSrec(fileName);
6200 return binaryFile::toSrec(fileName);
6205 }
6201 }
6206 binaryFile* PythonQtWrapper_binaryFile::new_binaryFile()
6202 binaryFile* PythonQtWrapper_binaryFile::new_binaryFile()
6207 {
6203 {
6208 return new PythonQtShell_binaryFile(); }
6204 return new PythonQtShell_binaryFile(); }
6209
6205
6210 binaryFile* PythonQtWrapper_binaryFile::new_binaryFile(const QString& File)
6206 binaryFile* PythonQtWrapper_binaryFile::new_binaryFile(const QString& File)
6211 {
6207 {
6212 return new PythonQtShell_binaryFile(File); }
6208 return new PythonQtShell_binaryFile(File); }
6213
6209
6214 binaryFile* PythonQtWrapper_binaryFile::new_binaryFile(const QStringList& Files)
6210 binaryFile* PythonQtWrapper_binaryFile::new_binaryFile(const QStringList& Files)
6215 {
6211 {
6216 return new PythonQtShell_binaryFile(Files); }
6212 return new PythonQtShell_binaryFile(Files); }
6217
6213
6218 int PythonQtWrapper_binaryFile::closeFile(binaryFile* theWrappedObject)
6214 int PythonQtWrapper_binaryFile::closeFile(binaryFile* theWrappedObject)
6219 {
6215 {
6220 return ( ((PythonQtPublicPromoter_binaryFile*)theWrappedObject)->promoted_closeFile());
6216 return ( ((PythonQtPublicPromoter_binaryFile*)theWrappedObject)->promoted_closeFile());
6221 }
6217 }
6222
6218
6223 codeFragment* PythonQtWrapper_binaryFile::getFragment(binaryFile* theWrappedObject, int index)
6219 codeFragment* PythonQtWrapper_binaryFile::getFragment(binaryFile* theWrappedObject, int index)
6224 {
6220 {
6225 return ( theWrappedObject->getFragment(index));
6221 return ( theWrappedObject->getFragment(index));
6226 }
6222 }
6227
6223
6228 int PythonQtWrapper_binaryFile::getFragmentAddress(binaryFile* theWrappedObject, int index)
6224 int PythonQtWrapper_binaryFile::getFragmentAddress(binaryFile* theWrappedObject, int index)
6229 {
6225 {
6230 return ( theWrappedObject->getFragmentAddress(index));
6226 return ( theWrappedObject->getFragmentAddress(index));
6231 }
6227 }
6232
6228
6233 bool PythonQtWrapper_binaryFile::getFragmentData(binaryFile* theWrappedObject, int index, char** buffer)
6229 bool PythonQtWrapper_binaryFile::getFragmentData(binaryFile* theWrappedObject, int index, char** buffer)
6234 {
6230 {
6235 return ( theWrappedObject->getFragmentData(index, buffer));
6231 return ( theWrappedObject->getFragmentData(index, buffer));
6236 }
6232 }
6237
6233
6238 QString PythonQtWrapper_binaryFile::getFragmentHeader(binaryFile* theWrappedObject, int index)
6234 QString PythonQtWrapper_binaryFile::getFragmentHeader(binaryFile* theWrappedObject, int index)
6239 {
6235 {
6240 return ( theWrappedObject->getFragmentHeader(index));
6236 return ( theWrappedObject->getFragmentHeader(index));
6241 }
6237 }
6242
6238
6243 int PythonQtWrapper_binaryFile::getFragmentSize(binaryFile* theWrappedObject, int index)
6239 int PythonQtWrapper_binaryFile::getFragmentSize(binaryFile* theWrappedObject, int index)
6244 {
6240 {
6245 return ( theWrappedObject->getFragmentSize(index));
6241 return ( theWrappedObject->getFragmentSize(index));
6246 }
6242 }
6247
6243
6248 QList<codeFragment* > PythonQtWrapper_binaryFile::getFragments(binaryFile* theWrappedObject)
6244 QList<codeFragment* > PythonQtWrapper_binaryFile::getFragments(binaryFile* theWrappedObject)
6249 {
6245 {
6250 return ( ((PythonQtPublicPromoter_binaryFile*)theWrappedObject)->promoted_getFragments());
6246 return ( ((PythonQtPublicPromoter_binaryFile*)theWrappedObject)->promoted_getFragments());
6251 }
6247 }
6252
6248
6253 int PythonQtWrapper_binaryFile::getFragmentsCount(binaryFile* theWrappedObject)
6249 int PythonQtWrapper_binaryFile::getFragmentsCount(binaryFile* theWrappedObject)
6254 {
6250 {
6255 return ( theWrappedObject->getFragmentsCount());
6251 return ( theWrappedObject->getFragmentsCount());
6256 }
6252 }
6257
6253
6258 bool PythonQtWrapper_binaryFile::isopened(binaryFile* theWrappedObject)
6254 bool PythonQtWrapper_binaryFile::isopened(binaryFile* theWrappedObject)
6259 {
6255 {
6260 return ( ((PythonQtPublicPromoter_binaryFile*)theWrappedObject)->promoted_isopened());
6256 return ( ((PythonQtPublicPromoter_binaryFile*)theWrappedObject)->promoted_isopened());
6261 }
6257 }
6262
6258
6263 bool PythonQtWrapper_binaryFile::openFile(binaryFile* theWrappedObject, const QString& File)
6259 bool PythonQtWrapper_binaryFile::openFile(binaryFile* theWrappedObject, const QString& File)
6264 {
6260 {
6265 return ( ((PythonQtPublicPromoter_binaryFile*)theWrappedObject)->promoted_openFile(File));
6261 return ( ((PythonQtPublicPromoter_binaryFile*)theWrappedObject)->promoted_openFile(File));
6266 }
6262 }
6267
6263
6268 bool PythonQtWrapper_binaryFile::openFiles(binaryFile* theWrappedObject, const QStringList& Files)
6264 bool PythonQtWrapper_binaryFile::openFiles(binaryFile* theWrappedObject, const QStringList& Files)
6269 {
6265 {
6270 return ( theWrappedObject->openFiles(Files));
6266 return ( theWrappedObject->openFiles(Files));
6271 }
6267 }
6272
6268
6273 bool PythonQtWrapper_binaryFile::static_binaryFile_toBinary(QList<codeFragment* > fragments, const QString& File)
6269 bool PythonQtWrapper_binaryFile::static_binaryFile_toBinary(QList<codeFragment* > fragments, const QString& File)
6274 {
6270 {
6275 return (binaryFile::toBinary(fragments, File));
6271 return (binaryFile::toBinary(fragments, File));
6276 }
6272 }
6277
6273
6278 bool PythonQtWrapper_binaryFile::toBinary(binaryFile* theWrappedObject, const QString& fileName)
6274 bool PythonQtWrapper_binaryFile::toBinary(binaryFile* theWrappedObject, const QString& fileName)
6279 {
6275 {
6280 return ( ((PythonQtPublicPromoter_binaryFile*)theWrappedObject)->promoted_toBinary(fileName));
6276 return ( ((PythonQtPublicPromoter_binaryFile*)theWrappedObject)->promoted_toBinary(fileName));
6281 }
6277 }
6282
6278
6283 bool PythonQtWrapper_binaryFile::toSrec(binaryFile* theWrappedObject, const QString& fileName)
6279 bool PythonQtWrapper_binaryFile::toSrec(binaryFile* theWrappedObject, const QString& fileName)
6284 {
6280 {
6285 return ( ((PythonQtPublicPromoter_binaryFile*)theWrappedObject)->promoted_toSrec(fileName));
6281 return ( ((PythonQtPublicPromoter_binaryFile*)theWrappedObject)->promoted_toSrec(fileName));
6286 }
6282 }
6287
6283
6288
6284
6289
6285
6290 PythonQtShell_binaryFileWidget::~PythonQtShell_binaryFileWidget() {
6286 PythonQtShell_binaryFileWidget::~PythonQtShell_binaryFileWidget() {
6291 PythonQtPrivate* priv = PythonQt::priv();
6287 PythonQtPrivate* priv = PythonQt::priv();
6292 if (priv) { priv->shellClassDeleted(this); }
6288 if (priv) { priv->shellClassDeleted(this); }
6293 }
6289 }
6294 void PythonQtShell_binaryFileWidget::reloadFile()
6290 void PythonQtShell_binaryFileWidget::reloadFile()
6295 {
6291 {
6296 if (_wrapper) {
6292 if (_wrapper) {
6297 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "reloadFile");
6293 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "reloadFile");
6298 PyErr_Clear();
6294 PyErr_Clear();
6299 if (obj && !PythonQtSlotFunction_Check(obj)) {
6295 if (obj && !PythonQtSlotFunction_Check(obj)) {
6300 static const char* argumentList[] ={""};
6296 static const char* argumentList[] ={""};
6301 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
6297 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
6302 void* args[1] = {NULL};
6298 void* args[1] = {NULL};
6303 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6299 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6304 if (result) { Py_DECREF(result); }
6300 if (result) { Py_DECREF(result); }
6305 Py_DECREF(obj);
6301 Py_DECREF(obj);
6306 return;
6302 return;
6307 }
6303 }
6308 }
6304 }
6309 binaryFileWidget::reloadFile();
6305 binaryFileWidget::reloadFile();
6310 }
6306 }
6311 void PythonQtShell_binaryFileWidget::setFile(abstractBinFile* file)
6307 void PythonQtShell_binaryFileWidget::setFile(abstractBinFile* file)
6312 {
6308 {
6313 if (_wrapper) {
6309 if (_wrapper) {
6314 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "setFile");
6310 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "setFile");
6315 PyErr_Clear();
6311 PyErr_Clear();
6316 if (obj && !PythonQtSlotFunction_Check(obj)) {
6312 if (obj && !PythonQtSlotFunction_Check(obj)) {
6317 static const char* argumentList[] ={"" , "abstractBinFile*"};
6313 static const char* argumentList[] ={"" , "abstractBinFile*"};
6318 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6314 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6319 void* args[2] = {NULL, (void*)&file};
6315 void* args[2] = {NULL, (void*)&file};
6320 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6316 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6321 if (result) { Py_DECREF(result); }
6317 if (result) { Py_DECREF(result); }
6322 Py_DECREF(obj);
6318 Py_DECREF(obj);
6323 return;
6319 return;
6324 }
6320 }
6325 }
6321 }
6326 binaryFileWidget::setFile(file);
6322 binaryFileWidget::setFile(file);
6327 }
6323 }
6328 binaryFileWidget* PythonQtWrapper_binaryFileWidget::new_binaryFileWidget(QWidget* parent)
6324 binaryFileWidget* PythonQtWrapper_binaryFileWidget::new_binaryFileWidget(QWidget* parent)
6329 {
6325 {
6330 return new PythonQtShell_binaryFileWidget(parent); }
6326 return new PythonQtShell_binaryFileWidget(parent); }
6331
6327
6332 void PythonQtWrapper_binaryFileWidget::reloadFile(binaryFileWidget* theWrappedObject)
6328 void PythonQtWrapper_binaryFileWidget::reloadFile(binaryFileWidget* theWrappedObject)
6333 {
6329 {
6334 ( ((PythonQtPublicPromoter_binaryFileWidget*)theWrappedObject)->promoted_reloadFile());
6330 ( ((PythonQtPublicPromoter_binaryFileWidget*)theWrappedObject)->promoted_reloadFile());
6335 }
6331 }
6336
6332
6337 void PythonQtWrapper_binaryFileWidget::setFile(binaryFileWidget* theWrappedObject, abstractBinFile* file)
6333 void PythonQtWrapper_binaryFileWidget::setFile(binaryFileWidget* theWrappedObject, abstractBinFile* file)
6338 {
6334 {
6339 ( ((PythonQtPublicPromoter_binaryFileWidget*)theWrappedObject)->promoted_setFile(file));
6335 ( ((PythonQtPublicPromoter_binaryFileWidget*)theWrappedObject)->promoted_setFile(file));
6340 }
6336 }
6341
6337
6342
6338
6343
6339
6344 PythonQtShell_codeFragment::~PythonQtShell_codeFragment() {
6340 PythonQtShell_codeFragment::~PythonQtShell_codeFragment() {
6345 PythonQtPrivate* priv = PythonQt::priv();
6341 PythonQtPrivate* priv = PythonQt::priv();
6346 if (priv) { priv->shellClassDeleted(this); }
6342 if (priv) { priv->shellClassDeleted(this); }
6347 }
6343 }
6348 codeFragment* PythonQtWrapper_codeFragment::new_codeFragment()
6344 codeFragment* PythonQtWrapper_codeFragment::new_codeFragment()
6349 {
6345 {
6350 return new PythonQtShell_codeFragment(); }
6346 return new PythonQtShell_codeFragment(); }
6351
6347
6352 codeFragment* PythonQtWrapper_codeFragment::new_codeFragment(char* data, quint64 size, quint64 address)
6348 codeFragment* PythonQtWrapper_codeFragment::new_codeFragment(char* data, quint64 size, quint64 address)
6353 {
6349 {
6354 return new PythonQtShell_codeFragment(data, size, address); }
6350 return new PythonQtShell_codeFragment(data, size, address); }
6355
6351
6356
6352
6357
6353
6358 PythonQtShell_elfFileWidget::~PythonQtShell_elfFileWidget() {
6354 PythonQtShell_elfFileWidget::~PythonQtShell_elfFileWidget() {
6359 PythonQtPrivate* priv = PythonQt::priv();
6355 PythonQtPrivate* priv = PythonQt::priv();
6360 if (priv) { priv->shellClassDeleted(this); }
6356 if (priv) { priv->shellClassDeleted(this); }
6361 }
6357 }
6362 void PythonQtShell_elfFileWidget::reloadFile()
6358 void PythonQtShell_elfFileWidget::reloadFile()
6363 {
6359 {
6364 if (_wrapper) {
6360 if (_wrapper) {
6365 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "reloadFile");
6361 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "reloadFile");
6366 PyErr_Clear();
6362 PyErr_Clear();
6367 if (obj && !PythonQtSlotFunction_Check(obj)) {
6363 if (obj && !PythonQtSlotFunction_Check(obj)) {
6368 static const char* argumentList[] ={""};
6364 static const char* argumentList[] ={""};
6369 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
6365 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
6370 void* args[1] = {NULL};
6366 void* args[1] = {NULL};
6371 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6367 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6372 if (result) { Py_DECREF(result); }
6368 if (result) { Py_DECREF(result); }
6373 Py_DECREF(obj);
6369 Py_DECREF(obj);
6374 return;
6370 return;
6375 }
6371 }
6376 }
6372 }
6377 elfFileWidget::reloadFile();
6373 elfFileWidget::reloadFile();
6378 }
6374 }
6379 void PythonQtShell_elfFileWidget::setFile(abstractBinFile* file)
6375 void PythonQtShell_elfFileWidget::setFile(abstractBinFile* file)
6380 {
6376 {
6381 if (_wrapper) {
6377 if (_wrapper) {
6382 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "setFile");
6378 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "setFile");
6383 PyErr_Clear();
6379 PyErr_Clear();
6384 if (obj && !PythonQtSlotFunction_Check(obj)) {
6380 if (obj && !PythonQtSlotFunction_Check(obj)) {
6385 static const char* argumentList[] ={"" , "abstractBinFile*"};
6381 static const char* argumentList[] ={"" , "abstractBinFile*"};
6386 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6382 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6387 void* args[2] = {NULL, (void*)&file};
6383 void* args[2] = {NULL, (void*)&file};
6388 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6384 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6389 if (result) { Py_DECREF(result); }
6385 if (result) { Py_DECREF(result); }
6390 Py_DECREF(obj);
6386 Py_DECREF(obj);
6391 return;
6387 return;
6392 }
6388 }
6393 }
6389 }
6394
6390 elfFileWidget::setFile(file);
6395 }
6391 }
6396 elfFileWidget* PythonQtWrapper_elfFileWidget::new_elfFileWidget(QWidget* parent)
6392 elfFileWidget* PythonQtWrapper_elfFileWidget::new_elfFileWidget(QWidget* parent)
6397 {
6393 {
6398 return new PythonQtShell_elfFileWidget(parent); }
6394 return new PythonQtShell_elfFileWidget(parent); }
6399
6395
6400 void PythonQtWrapper_elfFileWidget::reloadFile(elfFileWidget* theWrappedObject)
6396 void PythonQtWrapper_elfFileWidget::reloadFile(elfFileWidget* theWrappedObject)
6401 {
6397 {
6402 ( ((PythonQtPublicPromoter_elfFileWidget*)theWrappedObject)->promoted_reloadFile());
6398 ( ((PythonQtPublicPromoter_elfFileWidget*)theWrappedObject)->promoted_reloadFile());
6403 }
6399 }
6404
6400
6401 void PythonQtWrapper_elfFileWidget::setFile(elfFileWidget* theWrappedObject, abstractBinFile* file)
6402 {
6403 ( ((PythonQtPublicPromoter_elfFileWidget*)theWrappedObject)->promoted_setFile(file));
6404 }
6405
6405
6406
6406
6407
6407 PythonQtShell_elfInfoWdgt::~PythonQtShell_elfInfoWdgt() {
6408 PythonQtShell_elfInfoWdgt::~PythonQtShell_elfInfoWdgt() {
6408 PythonQtPrivate* priv = PythonQt::priv();
6409 PythonQtPrivate* priv = PythonQt::priv();
6409 if (priv) { priv->shellClassDeleted(this); }
6410 if (priv) { priv->shellClassDeleted(this); }
6410 }
6411 }
6411 void PythonQtShell_elfInfoWdgt::actionEvent(QActionEvent* arg__1)
6412 void PythonQtShell_elfInfoWdgt::actionEvent(QActionEvent* arg__1)
6412 {
6413 {
6413 if (_wrapper) {
6414 if (_wrapper) {
6414 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "actionEvent");
6415 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "actionEvent");
6415 PyErr_Clear();
6416 PyErr_Clear();
6416 if (obj && !PythonQtSlotFunction_Check(obj)) {
6417 if (obj && !PythonQtSlotFunction_Check(obj)) {
6417 static const char* argumentList[] ={"" , "QActionEvent*"};
6418 static const char* argumentList[] ={"" , "QActionEvent*"};
6418 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6419 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6419 void* args[2] = {NULL, (void*)&arg__1};
6420 void* args[2] = {NULL, (void*)&arg__1};
6420 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6421 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6421 if (result) { Py_DECREF(result); }
6422 if (result) { Py_DECREF(result); }
6422 Py_DECREF(obj);
6423 Py_DECREF(obj);
6423 return;
6424 return;
6424 }
6425 }
6425 }
6426 }
6426 elfInfoWdgt::actionEvent(arg__1);
6427 elfInfoWdgt::actionEvent(arg__1);
6427 }
6428 }
6428 void PythonQtShell_elfInfoWdgt::changeEvent(QEvent* arg__1)
6429 void PythonQtShell_elfInfoWdgt::changeEvent(QEvent* arg__1)
6429 {
6430 {
6430 if (_wrapper) {
6431 if (_wrapper) {
6431 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "changeEvent");
6432 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "changeEvent");
6432 PyErr_Clear();
6433 PyErr_Clear();
6433 if (obj && !PythonQtSlotFunction_Check(obj)) {
6434 if (obj && !PythonQtSlotFunction_Check(obj)) {
6434 static const char* argumentList[] ={"" , "QEvent*"};
6435 static const char* argumentList[] ={"" , "QEvent*"};
6435 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6436 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6436 void* args[2] = {NULL, (void*)&arg__1};
6437 void* args[2] = {NULL, (void*)&arg__1};
6437 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6438 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6438 if (result) { Py_DECREF(result); }
6439 if (result) { Py_DECREF(result); }
6439 Py_DECREF(obj);
6440 Py_DECREF(obj);
6440 return;
6441 return;
6441 }
6442 }
6442 }
6443 }
6443 elfInfoWdgt::changeEvent(arg__1);
6444 elfInfoWdgt::changeEvent(arg__1);
6444 }
6445 }
6445 void PythonQtShell_elfInfoWdgt::childEvent(QChildEvent* arg__1)
6446 void PythonQtShell_elfInfoWdgt::childEvent(QChildEvent* arg__1)
6446 {
6447 {
6447 if (_wrapper) {
6448 if (_wrapper) {
6448 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "childEvent");
6449 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "childEvent");
6449 PyErr_Clear();
6450 PyErr_Clear();
6450 if (obj && !PythonQtSlotFunction_Check(obj)) {
6451 if (obj && !PythonQtSlotFunction_Check(obj)) {
6451 static const char* argumentList[] ={"" , "QChildEvent*"};
6452 static const char* argumentList[] ={"" , "QChildEvent*"};
6452 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6453 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6453 void* args[2] = {NULL, (void*)&arg__1};
6454 void* args[2] = {NULL, (void*)&arg__1};
6454 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6455 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6455 if (result) { Py_DECREF(result); }
6456 if (result) { Py_DECREF(result); }
6456 Py_DECREF(obj);
6457 Py_DECREF(obj);
6457 return;
6458 return;
6458 }
6459 }
6459 }
6460 }
6460 elfInfoWdgt::childEvent(arg__1);
6461 elfInfoWdgt::childEvent(arg__1);
6461 }
6462 }
6462 void PythonQtShell_elfInfoWdgt::closeEvent(QCloseEvent* arg__1)
6463 void PythonQtShell_elfInfoWdgt::closeEvent(QCloseEvent* arg__1)
6463 {
6464 {
6464 if (_wrapper) {
6465 if (_wrapper) {
6465 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "closeEvent");
6466 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "closeEvent");
6466 PyErr_Clear();
6467 PyErr_Clear();
6467 if (obj && !PythonQtSlotFunction_Check(obj)) {
6468 if (obj && !PythonQtSlotFunction_Check(obj)) {
6468 static const char* argumentList[] ={"" , "QCloseEvent*"};
6469 static const char* argumentList[] ={"" , "QCloseEvent*"};
6469 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6470 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6470 void* args[2] = {NULL, (void*)&arg__1};
6471 void* args[2] = {NULL, (void*)&arg__1};
6471 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6472 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6472 if (result) { Py_DECREF(result); }
6473 if (result) { Py_DECREF(result); }
6473 Py_DECREF(obj);
6474 Py_DECREF(obj);
6474 return;
6475 return;
6475 }
6476 }
6476 }
6477 }
6477 elfInfoWdgt::closeEvent(arg__1);
6478 elfInfoWdgt::closeEvent(arg__1);
6478 }
6479 }
6479 void PythonQtShell_elfInfoWdgt::contextMenuEvent(QContextMenuEvent* arg__1)
6480 void PythonQtShell_elfInfoWdgt::contextMenuEvent(QContextMenuEvent* arg__1)
6480 {
6481 {
6481 if (_wrapper) {
6482 if (_wrapper) {
6482 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "contextMenuEvent");
6483 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "contextMenuEvent");
6483 PyErr_Clear();
6484 PyErr_Clear();
6484 if (obj && !PythonQtSlotFunction_Check(obj)) {
6485 if (obj && !PythonQtSlotFunction_Check(obj)) {
6485 static const char* argumentList[] ={"" , "QContextMenuEvent*"};
6486 static const char* argumentList[] ={"" , "QContextMenuEvent*"};
6486 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6487 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6487 void* args[2] = {NULL, (void*)&arg__1};
6488 void* args[2] = {NULL, (void*)&arg__1};
6488 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6489 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6489 if (result) { Py_DECREF(result); }
6490 if (result) { Py_DECREF(result); }
6490 Py_DECREF(obj);
6491 Py_DECREF(obj);
6491 return;
6492 return;
6492 }
6493 }
6493 }
6494 }
6494 elfInfoWdgt::contextMenuEvent(arg__1);
6495 elfInfoWdgt::contextMenuEvent(arg__1);
6495 }
6496 }
6496 void PythonQtShell_elfInfoWdgt::customEvent(QEvent* arg__1)
6497 void PythonQtShell_elfInfoWdgt::customEvent(QEvent* arg__1)
6497 {
6498 {
6498 if (_wrapper) {
6499 if (_wrapper) {
6499 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "customEvent");
6500 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "customEvent");
6500 PyErr_Clear();
6501 PyErr_Clear();
6501 if (obj && !PythonQtSlotFunction_Check(obj)) {
6502 if (obj && !PythonQtSlotFunction_Check(obj)) {
6502 static const char* argumentList[] ={"" , "QEvent*"};
6503 static const char* argumentList[] ={"" , "QEvent*"};
6503 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6504 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6504 void* args[2] = {NULL, (void*)&arg__1};
6505 void* args[2] = {NULL, (void*)&arg__1};
6505 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6506 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6506 if (result) { Py_DECREF(result); }
6507 if (result) { Py_DECREF(result); }
6507 Py_DECREF(obj);
6508 Py_DECREF(obj);
6508 return;
6509 return;
6509 }
6510 }
6510 }
6511 }
6511 elfInfoWdgt::customEvent(arg__1);
6512 elfInfoWdgt::customEvent(arg__1);
6512 }
6513 }
6513 int PythonQtShell_elfInfoWdgt::devType() const
6514 int PythonQtShell_elfInfoWdgt::devType() const
6514 {
6515 {
6515 if (_wrapper) {
6516 if (_wrapper) {
6516 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "devType");
6517 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "devType");
6517 PyErr_Clear();
6518 PyErr_Clear();
6518 if (obj && !PythonQtSlotFunction_Check(obj)) {
6519 if (obj && !PythonQtSlotFunction_Check(obj)) {
6519 static const char* argumentList[] ={"int"};
6520 static const char* argumentList[] ={"int"};
6520 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
6521 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
6521 int returnValue;
6522 int returnValue;
6522 void* args[1] = {NULL};
6523 void* args[1] = {NULL};
6523 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6524 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6524 if (result) {
6525 if (result) {
6525 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6526 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6526 if (args[0]!=&returnValue) {
6527 if (args[0]!=&returnValue) {
6527 if (args[0]==NULL) {
6528 if (args[0]==NULL) {
6528 PythonQt::priv()->handleVirtualOverloadReturnError("devType", methodInfo, result);
6529 PythonQt::priv()->handleVirtualOverloadReturnError("devType", methodInfo, result);
6529 } else {
6530 } else {
6530 returnValue = *((int*)args[0]);
6531 returnValue = *((int*)args[0]);
6531 }
6532 }
6532 }
6533 }
6533 }
6534 }
6534 if (result) { Py_DECREF(result); }
6535 if (result) { Py_DECREF(result); }
6535 Py_DECREF(obj);
6536 Py_DECREF(obj);
6536 return returnValue;
6537 return returnValue;
6537 }
6538 }
6538 }
6539 }
6539 return elfInfoWdgt::devType();
6540 return elfInfoWdgt::devType();
6540 }
6541 }
6541 void PythonQtShell_elfInfoWdgt::dragEnterEvent(QDragEnterEvent* arg__1)
6542 void PythonQtShell_elfInfoWdgt::dragEnterEvent(QDragEnterEvent* arg__1)
6542 {
6543 {
6543 if (_wrapper) {
6544 if (_wrapper) {
6544 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragEnterEvent");
6545 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragEnterEvent");
6545 PyErr_Clear();
6546 PyErr_Clear();
6546 if (obj && !PythonQtSlotFunction_Check(obj)) {
6547 if (obj && !PythonQtSlotFunction_Check(obj)) {
6547 static const char* argumentList[] ={"" , "QDragEnterEvent*"};
6548 static const char* argumentList[] ={"" , "QDragEnterEvent*"};
6548 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6549 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6549 void* args[2] = {NULL, (void*)&arg__1};
6550 void* args[2] = {NULL, (void*)&arg__1};
6550 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6551 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6551 if (result) { Py_DECREF(result); }
6552 if (result) { Py_DECREF(result); }
6552 Py_DECREF(obj);
6553 Py_DECREF(obj);
6553 return;
6554 return;
6554 }
6555 }
6555 }
6556 }
6556 elfInfoWdgt::dragEnterEvent(arg__1);
6557 elfInfoWdgt::dragEnterEvent(arg__1);
6557 }
6558 }
6558 void PythonQtShell_elfInfoWdgt::dragLeaveEvent(QDragLeaveEvent* arg__1)
6559 void PythonQtShell_elfInfoWdgt::dragLeaveEvent(QDragLeaveEvent* arg__1)
6559 {
6560 {
6560 if (_wrapper) {
6561 if (_wrapper) {
6561 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragLeaveEvent");
6562 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragLeaveEvent");
6562 PyErr_Clear();
6563 PyErr_Clear();
6563 if (obj && !PythonQtSlotFunction_Check(obj)) {
6564 if (obj && !PythonQtSlotFunction_Check(obj)) {
6564 static const char* argumentList[] ={"" , "QDragLeaveEvent*"};
6565 static const char* argumentList[] ={"" , "QDragLeaveEvent*"};
6565 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6566 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6566 void* args[2] = {NULL, (void*)&arg__1};
6567 void* args[2] = {NULL, (void*)&arg__1};
6567 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6568 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6568 if (result) { Py_DECREF(result); }
6569 if (result) { Py_DECREF(result); }
6569 Py_DECREF(obj);
6570 Py_DECREF(obj);
6570 return;
6571 return;
6571 }
6572 }
6572 }
6573 }
6573 elfInfoWdgt::dragLeaveEvent(arg__1);
6574 elfInfoWdgt::dragLeaveEvent(arg__1);
6574 }
6575 }
6575 void PythonQtShell_elfInfoWdgt::dragMoveEvent(QDragMoveEvent* arg__1)
6576 void PythonQtShell_elfInfoWdgt::dragMoveEvent(QDragMoveEvent* arg__1)
6576 {
6577 {
6577 if (_wrapper) {
6578 if (_wrapper) {
6578 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragMoveEvent");
6579 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragMoveEvent");
6579 PyErr_Clear();
6580 PyErr_Clear();
6580 if (obj && !PythonQtSlotFunction_Check(obj)) {
6581 if (obj && !PythonQtSlotFunction_Check(obj)) {
6581 static const char* argumentList[] ={"" , "QDragMoveEvent*"};
6582 static const char* argumentList[] ={"" , "QDragMoveEvent*"};
6582 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6583 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6583 void* args[2] = {NULL, (void*)&arg__1};
6584 void* args[2] = {NULL, (void*)&arg__1};
6584 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6585 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6585 if (result) { Py_DECREF(result); }
6586 if (result) { Py_DECREF(result); }
6586 Py_DECREF(obj);
6587 Py_DECREF(obj);
6587 return;
6588 return;
6588 }
6589 }
6589 }
6590 }
6590 elfInfoWdgt::dragMoveEvent(arg__1);
6591 elfInfoWdgt::dragMoveEvent(arg__1);
6591 }
6592 }
6592 void PythonQtShell_elfInfoWdgt::dropEvent(QDropEvent* arg__1)
6593 void PythonQtShell_elfInfoWdgt::dropEvent(QDropEvent* arg__1)
6593 {
6594 {
6594 if (_wrapper) {
6595 if (_wrapper) {
6595 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dropEvent");
6596 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dropEvent");
6596 PyErr_Clear();
6597 PyErr_Clear();
6597 if (obj && !PythonQtSlotFunction_Check(obj)) {
6598 if (obj && !PythonQtSlotFunction_Check(obj)) {
6598 static const char* argumentList[] ={"" , "QDropEvent*"};
6599 static const char* argumentList[] ={"" , "QDropEvent*"};
6599 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6600 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6600 void* args[2] = {NULL, (void*)&arg__1};
6601 void* args[2] = {NULL, (void*)&arg__1};
6601 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6602 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6602 if (result) { Py_DECREF(result); }
6603 if (result) { Py_DECREF(result); }
6603 Py_DECREF(obj);
6604 Py_DECREF(obj);
6604 return;
6605 return;
6605 }
6606 }
6606 }
6607 }
6607 elfInfoWdgt::dropEvent(arg__1);
6608 elfInfoWdgt::dropEvent(arg__1);
6608 }
6609 }
6609 void PythonQtShell_elfInfoWdgt::enterEvent(QEvent* arg__1)
6610 void PythonQtShell_elfInfoWdgt::enterEvent(QEvent* arg__1)
6610 {
6611 {
6611 if (_wrapper) {
6612 if (_wrapper) {
6612 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "enterEvent");
6613 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "enterEvent");
6613 PyErr_Clear();
6614 PyErr_Clear();
6614 if (obj && !PythonQtSlotFunction_Check(obj)) {
6615 if (obj && !PythonQtSlotFunction_Check(obj)) {
6615 static const char* argumentList[] ={"" , "QEvent*"};
6616 static const char* argumentList[] ={"" , "QEvent*"};
6616 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6617 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6617 void* args[2] = {NULL, (void*)&arg__1};
6618 void* args[2] = {NULL, (void*)&arg__1};
6618 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6619 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6619 if (result) { Py_DECREF(result); }
6620 if (result) { Py_DECREF(result); }
6620 Py_DECREF(obj);
6621 Py_DECREF(obj);
6621 return;
6622 return;
6622 }
6623 }
6623 }
6624 }
6624 elfInfoWdgt::enterEvent(arg__1);
6625 elfInfoWdgt::enterEvent(arg__1);
6625 }
6626 }
6626 bool PythonQtShell_elfInfoWdgt::event(QEvent* arg__1)
6627 bool PythonQtShell_elfInfoWdgt::event(QEvent* arg__1)
6627 {
6628 {
6628 if (_wrapper) {
6629 if (_wrapper) {
6629 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "event");
6630 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "event");
6630 PyErr_Clear();
6631 PyErr_Clear();
6631 if (obj && !PythonQtSlotFunction_Check(obj)) {
6632 if (obj && !PythonQtSlotFunction_Check(obj)) {
6632 static const char* argumentList[] ={"bool" , "QEvent*"};
6633 static const char* argumentList[] ={"bool" , "QEvent*"};
6633 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6634 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6634 bool returnValue;
6635 bool returnValue;
6635 void* args[2] = {NULL, (void*)&arg__1};
6636 void* args[2] = {NULL, (void*)&arg__1};
6636 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6637 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6637 if (result) {
6638 if (result) {
6638 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6639 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6639 if (args[0]!=&returnValue) {
6640 if (args[0]!=&returnValue) {
6640 if (args[0]==NULL) {
6641 if (args[0]==NULL) {
6641 PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
6642 PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
6642 } else {
6643 } else {
6643 returnValue = *((bool*)args[0]);
6644 returnValue = *((bool*)args[0]);
6644 }
6645 }
6645 }
6646 }
6646 }
6647 }
6647 if (result) { Py_DECREF(result); }
6648 if (result) { Py_DECREF(result); }
6648 Py_DECREF(obj);
6649 Py_DECREF(obj);
6649 return returnValue;
6650 return returnValue;
6650 }
6651 }
6651 }
6652 }
6652 return elfInfoWdgt::event(arg__1);
6653 return elfInfoWdgt::event(arg__1);
6653 }
6654 }
6654 bool PythonQtShell_elfInfoWdgt::eventFilter(QObject* arg__1, QEvent* arg__2)
6655 bool PythonQtShell_elfInfoWdgt::eventFilter(QObject* arg__1, QEvent* arg__2)
6655 {
6656 {
6656 if (_wrapper) {
6657 if (_wrapper) {
6657 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "eventFilter");
6658 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "eventFilter");
6658 PyErr_Clear();
6659 PyErr_Clear();
6659 if (obj && !PythonQtSlotFunction_Check(obj)) {
6660 if (obj && !PythonQtSlotFunction_Check(obj)) {
6660 static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
6661 static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
6661 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
6662 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
6662 bool returnValue;
6663 bool returnValue;
6663 void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2};
6664 void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2};
6664 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6665 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6665 if (result) {
6666 if (result) {
6666 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6667 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6667 if (args[0]!=&returnValue) {
6668 if (args[0]!=&returnValue) {
6668 if (args[0]==NULL) {
6669 if (args[0]==NULL) {
6669 PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
6670 PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
6670 } else {
6671 } else {
6671 returnValue = *((bool*)args[0]);
6672 returnValue = *((bool*)args[0]);
6672 }
6673 }
6673 }
6674 }
6674 }
6675 }
6675 if (result) { Py_DECREF(result); }
6676 if (result) { Py_DECREF(result); }
6676 Py_DECREF(obj);
6677 Py_DECREF(obj);
6677 return returnValue;
6678 return returnValue;
6678 }
6679 }
6679 }
6680 }
6680 return elfInfoWdgt::eventFilter(arg__1, arg__2);
6681 return elfInfoWdgt::eventFilter(arg__1, arg__2);
6681 }
6682 }
6682 void PythonQtShell_elfInfoWdgt::focusInEvent(QFocusEvent* arg__1)
6683 void PythonQtShell_elfInfoWdgt::focusInEvent(QFocusEvent* arg__1)
6683 {
6684 {
6684 if (_wrapper) {
6685 if (_wrapper) {
6685 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusInEvent");
6686 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusInEvent");
6686 PyErr_Clear();
6687 PyErr_Clear();
6687 if (obj && !PythonQtSlotFunction_Check(obj)) {
6688 if (obj && !PythonQtSlotFunction_Check(obj)) {
6688 static const char* argumentList[] ={"" , "QFocusEvent*"};
6689 static const char* argumentList[] ={"" , "QFocusEvent*"};
6689 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6690 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6690 void* args[2] = {NULL, (void*)&arg__1};
6691 void* args[2] = {NULL, (void*)&arg__1};
6691 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6692 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6692 if (result) { Py_DECREF(result); }
6693 if (result) { Py_DECREF(result); }
6693 Py_DECREF(obj);
6694 Py_DECREF(obj);
6694 return;
6695 return;
6695 }
6696 }
6696 }
6697 }
6697 elfInfoWdgt::focusInEvent(arg__1);
6698 elfInfoWdgt::focusInEvent(arg__1);
6698 }
6699 }
6699 bool PythonQtShell_elfInfoWdgt::focusNextPrevChild(bool next)
6700 bool PythonQtShell_elfInfoWdgt::focusNextPrevChild(bool next)
6700 {
6701 {
6701 if (_wrapper) {
6702 if (_wrapper) {
6702 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusNextPrevChild");
6703 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusNextPrevChild");
6703 PyErr_Clear();
6704 PyErr_Clear();
6704 if (obj && !PythonQtSlotFunction_Check(obj)) {
6705 if (obj && !PythonQtSlotFunction_Check(obj)) {
6705 static const char* argumentList[] ={"bool" , "bool"};
6706 static const char* argumentList[] ={"bool" , "bool"};
6706 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6707 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6707 bool returnValue;
6708 bool returnValue;
6708 void* args[2] = {NULL, (void*)&next};
6709 void* args[2] = {NULL, (void*)&next};
6709 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6710 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6710 if (result) {
6711 if (result) {
6711 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6712 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6712 if (args[0]!=&returnValue) {
6713 if (args[0]!=&returnValue) {
6713 if (args[0]==NULL) {
6714 if (args[0]==NULL) {
6714 PythonQt::priv()->handleVirtualOverloadReturnError("focusNextPrevChild", methodInfo, result);
6715 PythonQt::priv()->handleVirtualOverloadReturnError("focusNextPrevChild", methodInfo, result);
6715 } else {
6716 } else {
6716 returnValue = *((bool*)args[0]);
6717 returnValue = *((bool*)args[0]);
6717 }
6718 }
6718 }
6719 }
6719 }
6720 }
6720 if (result) { Py_DECREF(result); }
6721 if (result) { Py_DECREF(result); }
6721 Py_DECREF(obj);
6722 Py_DECREF(obj);
6722 return returnValue;
6723 return returnValue;
6723 }
6724 }
6724 }
6725 }
6725 return elfInfoWdgt::focusNextPrevChild(next);
6726 return elfInfoWdgt::focusNextPrevChild(next);
6726 }
6727 }
6727 void PythonQtShell_elfInfoWdgt::focusOutEvent(QFocusEvent* arg__1)
6728 void PythonQtShell_elfInfoWdgt::focusOutEvent(QFocusEvent* arg__1)
6728 {
6729 {
6729 if (_wrapper) {
6730 if (_wrapper) {
6730 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusOutEvent");
6731 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusOutEvent");
6731 PyErr_Clear();
6732 PyErr_Clear();
6732 if (obj && !PythonQtSlotFunction_Check(obj)) {
6733 if (obj && !PythonQtSlotFunction_Check(obj)) {
6733 static const char* argumentList[] ={"" , "QFocusEvent*"};
6734 static const char* argumentList[] ={"" , "QFocusEvent*"};
6734 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6735 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6735 void* args[2] = {NULL, (void*)&arg__1};
6736 void* args[2] = {NULL, (void*)&arg__1};
6736 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6737 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6737 if (result) { Py_DECREF(result); }
6738 if (result) { Py_DECREF(result); }
6738 Py_DECREF(obj);
6739 Py_DECREF(obj);
6739 return;
6740 return;
6740 }
6741 }
6741 }
6742 }
6742 elfInfoWdgt::focusOutEvent(arg__1);
6743 elfInfoWdgt::focusOutEvent(arg__1);
6743 }
6744 }
6744 bool PythonQtShell_elfInfoWdgt::hasHeightForWidth() const
6745 bool PythonQtShell_elfInfoWdgt::hasHeightForWidth() const
6745 {
6746 {
6746 if (_wrapper) {
6747 if (_wrapper) {
6747 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hasHeightForWidth");
6748 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hasHeightForWidth");
6748 PyErr_Clear();
6749 PyErr_Clear();
6749 if (obj && !PythonQtSlotFunction_Check(obj)) {
6750 if (obj && !PythonQtSlotFunction_Check(obj)) {
6750 static const char* argumentList[] ={"bool"};
6751 static const char* argumentList[] ={"bool"};
6751 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
6752 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
6752 bool returnValue;
6753 bool returnValue;
6753 void* args[1] = {NULL};
6754 void* args[1] = {NULL};
6754 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6755 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6755 if (result) {
6756 if (result) {
6756 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6757 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6757 if (args[0]!=&returnValue) {
6758 if (args[0]!=&returnValue) {
6758 if (args[0]==NULL) {
6759 if (args[0]==NULL) {
6759 PythonQt::priv()->handleVirtualOverloadReturnError("hasHeightForWidth", methodInfo, result);
6760 PythonQt::priv()->handleVirtualOverloadReturnError("hasHeightForWidth", methodInfo, result);
6760 } else {
6761 } else {
6761 returnValue = *((bool*)args[0]);
6762 returnValue = *((bool*)args[0]);
6762 }
6763 }
6763 }
6764 }
6764 }
6765 }
6765 if (result) { Py_DECREF(result); }
6766 if (result) { Py_DECREF(result); }
6766 Py_DECREF(obj);
6767 Py_DECREF(obj);
6767 return returnValue;
6768 return returnValue;
6768 }
6769 }
6769 }
6770 }
6770 return elfInfoWdgt::hasHeightForWidth();
6771 return elfInfoWdgt::hasHeightForWidth();
6771 }
6772 }
6772 int PythonQtShell_elfInfoWdgt::heightForWidth(int arg__1) const
6773 int PythonQtShell_elfInfoWdgt::heightForWidth(int arg__1) const
6773 {
6774 {
6774 if (_wrapper) {
6775 if (_wrapper) {
6775 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "heightForWidth");
6776 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "heightForWidth");
6776 PyErr_Clear();
6777 PyErr_Clear();
6777 if (obj && !PythonQtSlotFunction_Check(obj)) {
6778 if (obj && !PythonQtSlotFunction_Check(obj)) {
6778 static const char* argumentList[] ={"int" , "int"};
6779 static const char* argumentList[] ={"int" , "int"};
6779 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6780 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6780 int returnValue;
6781 int returnValue;
6781 void* args[2] = {NULL, (void*)&arg__1};
6782 void* args[2] = {NULL, (void*)&arg__1};
6782 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6783 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6783 if (result) {
6784 if (result) {
6784 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6785 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6785 if (args[0]!=&returnValue) {
6786 if (args[0]!=&returnValue) {
6786 if (args[0]==NULL) {
6787 if (args[0]==NULL) {
6787 PythonQt::priv()->handleVirtualOverloadReturnError("heightForWidth", methodInfo, result);
6788 PythonQt::priv()->handleVirtualOverloadReturnError("heightForWidth", methodInfo, result);
6788 } else {
6789 } else {
6789 returnValue = *((int*)args[0]);
6790 returnValue = *((int*)args[0]);
6790 }
6791 }
6791 }
6792 }
6792 }
6793 }
6793 if (result) { Py_DECREF(result); }
6794 if (result) { Py_DECREF(result); }
6794 Py_DECREF(obj);
6795 Py_DECREF(obj);
6795 return returnValue;
6796 return returnValue;
6796 }
6797 }
6797 }
6798 }
6798 return elfInfoWdgt::heightForWidth(arg__1);
6799 return elfInfoWdgt::heightForWidth(arg__1);
6799 }
6800 }
6800 void PythonQtShell_elfInfoWdgt::hideEvent(QHideEvent* arg__1)
6801 void PythonQtShell_elfInfoWdgt::hideEvent(QHideEvent* arg__1)
6801 {
6802 {
6802 if (_wrapper) {
6803 if (_wrapper) {
6803 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hideEvent");
6804 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hideEvent");
6804 PyErr_Clear();
6805 PyErr_Clear();
6805 if (obj && !PythonQtSlotFunction_Check(obj)) {
6806 if (obj && !PythonQtSlotFunction_Check(obj)) {
6806 static const char* argumentList[] ={"" , "QHideEvent*"};
6807 static const char* argumentList[] ={"" , "QHideEvent*"};
6807 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6808 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6808 void* args[2] = {NULL, (void*)&arg__1};
6809 void* args[2] = {NULL, (void*)&arg__1};
6809 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6810 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6810 if (result) { Py_DECREF(result); }
6811 if (result) { Py_DECREF(result); }
6811 Py_DECREF(obj);
6812 Py_DECREF(obj);
6812 return;
6813 return;
6813 }
6814 }
6814 }
6815 }
6815 elfInfoWdgt::hideEvent(arg__1);
6816 elfInfoWdgt::hideEvent(arg__1);
6816 }
6817 }
6817 void PythonQtShell_elfInfoWdgt::initPainter(QPainter* painter) const
6818 void PythonQtShell_elfInfoWdgt::initPainter(QPainter* painter) const
6818 {
6819 {
6819 if (_wrapper) {
6820 if (_wrapper) {
6820 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "initPainter");
6821 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "initPainter");
6821 PyErr_Clear();
6822 PyErr_Clear();
6822 if (obj && !PythonQtSlotFunction_Check(obj)) {
6823 if (obj && !PythonQtSlotFunction_Check(obj)) {
6823 static const char* argumentList[] ={"" , "QPainter*"};
6824 static const char* argumentList[] ={"" , "QPainter*"};
6824 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6825 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6825 void* args[2] = {NULL, (void*)&painter};
6826 void* args[2] = {NULL, (void*)&painter};
6826 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6827 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6827 if (result) { Py_DECREF(result); }
6828 if (result) { Py_DECREF(result); }
6828 Py_DECREF(obj);
6829 Py_DECREF(obj);
6829 return;
6830 return;
6830 }
6831 }
6831 }
6832 }
6832 elfInfoWdgt::initPainter(painter);
6833 elfInfoWdgt::initPainter(painter);
6833 }
6834 }
6834 void PythonQtShell_elfInfoWdgt::inputMethodEvent(QInputMethodEvent* arg__1)
6835 void PythonQtShell_elfInfoWdgt::inputMethodEvent(QInputMethodEvent* arg__1)
6835 {
6836 {
6836 if (_wrapper) {
6837 if (_wrapper) {
6837 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodEvent");
6838 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodEvent");
6838 PyErr_Clear();
6839 PyErr_Clear();
6839 if (obj && !PythonQtSlotFunction_Check(obj)) {
6840 if (obj && !PythonQtSlotFunction_Check(obj)) {
6840 static const char* argumentList[] ={"" , "QInputMethodEvent*"};
6841 static const char* argumentList[] ={"" , "QInputMethodEvent*"};
6841 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6842 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6842 void* args[2] = {NULL, (void*)&arg__1};
6843 void* args[2] = {NULL, (void*)&arg__1};
6843 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6844 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6844 if (result) { Py_DECREF(result); }
6845 if (result) { Py_DECREF(result); }
6845 Py_DECREF(obj);
6846 Py_DECREF(obj);
6846 return;
6847 return;
6847 }
6848 }
6848 }
6849 }
6849 elfInfoWdgt::inputMethodEvent(arg__1);
6850 elfInfoWdgt::inputMethodEvent(arg__1);
6850 }
6851 }
6851 QVariant PythonQtShell_elfInfoWdgt::inputMethodQuery(Qt::InputMethodQuery arg__1) const
6852 QVariant PythonQtShell_elfInfoWdgt::inputMethodQuery(Qt::InputMethodQuery arg__1) const
6852 {
6853 {
6853 if (_wrapper) {
6854 if (_wrapper) {
6854 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodQuery");
6855 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodQuery");
6855 PyErr_Clear();
6856 PyErr_Clear();
6856 if (obj && !PythonQtSlotFunction_Check(obj)) {
6857 if (obj && !PythonQtSlotFunction_Check(obj)) {
6857 static const char* argumentList[] ={"QVariant" , "Qt::InputMethodQuery"};
6858 static const char* argumentList[] ={"QVariant" , "Qt::InputMethodQuery"};
6858 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6859 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6859 QVariant returnValue;
6860 QVariant returnValue;
6860 void* args[2] = {NULL, (void*)&arg__1};
6861 void* args[2] = {NULL, (void*)&arg__1};
6861 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6862 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6862 if (result) {
6863 if (result) {
6863 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6864 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6864 if (args[0]!=&returnValue) {
6865 if (args[0]!=&returnValue) {
6865 if (args[0]==NULL) {
6866 if (args[0]==NULL) {
6866 PythonQt::priv()->handleVirtualOverloadReturnError("inputMethodQuery", methodInfo, result);
6867 PythonQt::priv()->handleVirtualOverloadReturnError("inputMethodQuery", methodInfo, result);
6867 } else {
6868 } else {
6868 returnValue = *((QVariant*)args[0]);
6869 returnValue = *((QVariant*)args[0]);
6869 }
6870 }
6870 }
6871 }
6871 }
6872 }
6872 if (result) { Py_DECREF(result); }
6873 if (result) { Py_DECREF(result); }
6873 Py_DECREF(obj);
6874 Py_DECREF(obj);
6874 return returnValue;
6875 return returnValue;
6875 }
6876 }
6876 }
6877 }
6877 return elfInfoWdgt::inputMethodQuery(arg__1);
6878 return elfInfoWdgt::inputMethodQuery(arg__1);
6878 }
6879 }
6879 void PythonQtShell_elfInfoWdgt::keyPressEvent(QKeyEvent* arg__1)
6880 void PythonQtShell_elfInfoWdgt::keyPressEvent(QKeyEvent* arg__1)
6880 {
6881 {
6881 if (_wrapper) {
6882 if (_wrapper) {
6882 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyPressEvent");
6883 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyPressEvent");
6883 PyErr_Clear();
6884 PyErr_Clear();
6884 if (obj && !PythonQtSlotFunction_Check(obj)) {
6885 if (obj && !PythonQtSlotFunction_Check(obj)) {
6885 static const char* argumentList[] ={"" , "QKeyEvent*"};
6886 static const char* argumentList[] ={"" , "QKeyEvent*"};
6886 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6887 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6887 void* args[2] = {NULL, (void*)&arg__1};
6888 void* args[2] = {NULL, (void*)&arg__1};
6888 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6889 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6889 if (result) { Py_DECREF(result); }
6890 if (result) { Py_DECREF(result); }
6890 Py_DECREF(obj);
6891 Py_DECREF(obj);
6891 return;
6892 return;
6892 }
6893 }
6893 }
6894 }
6894 elfInfoWdgt::keyPressEvent(arg__1);
6895 elfInfoWdgt::keyPressEvent(arg__1);
6895 }
6896 }
6896 void PythonQtShell_elfInfoWdgt::keyReleaseEvent(QKeyEvent* arg__1)
6897 void PythonQtShell_elfInfoWdgt::keyReleaseEvent(QKeyEvent* arg__1)
6897 {
6898 {
6898 if (_wrapper) {
6899 if (_wrapper) {
6899 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyReleaseEvent");
6900 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyReleaseEvent");
6900 PyErr_Clear();
6901 PyErr_Clear();
6901 if (obj && !PythonQtSlotFunction_Check(obj)) {
6902 if (obj && !PythonQtSlotFunction_Check(obj)) {
6902 static const char* argumentList[] ={"" , "QKeyEvent*"};
6903 static const char* argumentList[] ={"" , "QKeyEvent*"};
6903 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6904 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6904 void* args[2] = {NULL, (void*)&arg__1};
6905 void* args[2] = {NULL, (void*)&arg__1};
6905 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6906 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6906 if (result) { Py_DECREF(result); }
6907 if (result) { Py_DECREF(result); }
6907 Py_DECREF(obj);
6908 Py_DECREF(obj);
6908 return;
6909 return;
6909 }
6910 }
6910 }
6911 }
6911 elfInfoWdgt::keyReleaseEvent(arg__1);
6912 elfInfoWdgt::keyReleaseEvent(arg__1);
6912 }
6913 }
6913 void PythonQtShell_elfInfoWdgt::leaveEvent(QEvent* arg__1)
6914 void PythonQtShell_elfInfoWdgt::leaveEvent(QEvent* arg__1)
6914 {
6915 {
6915 if (_wrapper) {
6916 if (_wrapper) {
6916 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "leaveEvent");
6917 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "leaveEvent");
6917 PyErr_Clear();
6918 PyErr_Clear();
6918 if (obj && !PythonQtSlotFunction_Check(obj)) {
6919 if (obj && !PythonQtSlotFunction_Check(obj)) {
6919 static const char* argumentList[] ={"" , "QEvent*"};
6920 static const char* argumentList[] ={"" , "QEvent*"};
6920 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6921 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6921 void* args[2] = {NULL, (void*)&arg__1};
6922 void* args[2] = {NULL, (void*)&arg__1};
6922 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6923 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6923 if (result) { Py_DECREF(result); }
6924 if (result) { Py_DECREF(result); }
6924 Py_DECREF(obj);
6925 Py_DECREF(obj);
6925 return;
6926 return;
6926 }
6927 }
6927 }
6928 }
6928 elfInfoWdgt::leaveEvent(arg__1);
6929 elfInfoWdgt::leaveEvent(arg__1);
6929 }
6930 }
6930 int PythonQtShell_elfInfoWdgt::metric(QPaintDevice::PaintDeviceMetric arg__1) const
6931 int PythonQtShell_elfInfoWdgt::metric(QPaintDevice::PaintDeviceMetric arg__1) const
6931 {
6932 {
6932 if (_wrapper) {
6933 if (_wrapper) {
6933 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "metric");
6934 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "metric");
6934 PyErr_Clear();
6935 PyErr_Clear();
6935 if (obj && !PythonQtSlotFunction_Check(obj)) {
6936 if (obj && !PythonQtSlotFunction_Check(obj)) {
6936 static const char* argumentList[] ={"int" , "QPaintDevice::PaintDeviceMetric"};
6937 static const char* argumentList[] ={"int" , "QPaintDevice::PaintDeviceMetric"};
6937 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6938 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6938 int returnValue;
6939 int returnValue;
6939 void* args[2] = {NULL, (void*)&arg__1};
6940 void* args[2] = {NULL, (void*)&arg__1};
6940 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6941 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6941 if (result) {
6942 if (result) {
6942 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6943 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6943 if (args[0]!=&returnValue) {
6944 if (args[0]!=&returnValue) {
6944 if (args[0]==NULL) {
6945 if (args[0]==NULL) {
6945 PythonQt::priv()->handleVirtualOverloadReturnError("metric", methodInfo, result);
6946 PythonQt::priv()->handleVirtualOverloadReturnError("metric", methodInfo, result);
6946 } else {
6947 } else {
6947 returnValue = *((int*)args[0]);
6948 returnValue = *((int*)args[0]);
6948 }
6949 }
6949 }
6950 }
6950 }
6951 }
6951 if (result) { Py_DECREF(result); }
6952 if (result) { Py_DECREF(result); }
6952 Py_DECREF(obj);
6953 Py_DECREF(obj);
6953 return returnValue;
6954 return returnValue;
6954 }
6955 }
6955 }
6956 }
6956 return elfInfoWdgt::metric(arg__1);
6957 return elfInfoWdgt::metric(arg__1);
6957 }
6958 }
6958 QSize PythonQtShell_elfInfoWdgt::minimumSizeHint() const
6959 QSize PythonQtShell_elfInfoWdgt::minimumSizeHint() const
6959 {
6960 {
6960 if (_wrapper) {
6961 if (_wrapper) {
6961 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getMinimumSizeHint");
6962 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getMinimumSizeHint");
6962 PyErr_Clear();
6963 PyErr_Clear();
6963 if (obj && !PythonQtSlotFunction_Check(obj)) {
6964 if (obj && !PythonQtSlotFunction_Check(obj)) {
6964 static const char* argumentList[] ={"QSize"};
6965 static const char* argumentList[] ={"QSize"};
6965 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
6966 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
6966 QSize returnValue;
6967 QSize returnValue;
6967 void* args[1] = {NULL};
6968 void* args[1] = {NULL};
6968 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6969 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6969 if (result) {
6970 if (result) {
6970 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6971 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
6971 if (args[0]!=&returnValue) {
6972 if (args[0]!=&returnValue) {
6972 if (args[0]==NULL) {
6973 if (args[0]==NULL) {
6973 PythonQt::priv()->handleVirtualOverloadReturnError("getMinimumSizeHint", methodInfo, result);
6974 PythonQt::priv()->handleVirtualOverloadReturnError("getMinimumSizeHint", methodInfo, result);
6974 } else {
6975 } else {
6975 returnValue = *((QSize*)args[0]);
6976 returnValue = *((QSize*)args[0]);
6976 }
6977 }
6977 }
6978 }
6978 }
6979 }
6979 if (result) { Py_DECREF(result); }
6980 if (result) { Py_DECREF(result); }
6980 Py_DECREF(obj);
6981 Py_DECREF(obj);
6981 return returnValue;
6982 return returnValue;
6982 }
6983 }
6983 }
6984 }
6984 return elfInfoWdgt::minimumSizeHint();
6985 return elfInfoWdgt::minimumSizeHint();
6985 }
6986 }
6986 void PythonQtShell_elfInfoWdgt::mouseDoubleClickEvent(QMouseEvent* arg__1)
6987 void PythonQtShell_elfInfoWdgt::mouseDoubleClickEvent(QMouseEvent* arg__1)
6987 {
6988 {
6988 if (_wrapper) {
6989 if (_wrapper) {
6989 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseDoubleClickEvent");
6990 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseDoubleClickEvent");
6990 PyErr_Clear();
6991 PyErr_Clear();
6991 if (obj && !PythonQtSlotFunction_Check(obj)) {
6992 if (obj && !PythonQtSlotFunction_Check(obj)) {
6992 static const char* argumentList[] ={"" , "QMouseEvent*"};
6993 static const char* argumentList[] ={"" , "QMouseEvent*"};
6993 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6994 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
6994 void* args[2] = {NULL, (void*)&arg__1};
6995 void* args[2] = {NULL, (void*)&arg__1};
6995 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6996 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
6996 if (result) { Py_DECREF(result); }
6997 if (result) { Py_DECREF(result); }
6997 Py_DECREF(obj);
6998 Py_DECREF(obj);
6998 return;
6999 return;
6999 }
7000 }
7000 }
7001 }
7001 elfInfoWdgt::mouseDoubleClickEvent(arg__1);
7002 elfInfoWdgt::mouseDoubleClickEvent(arg__1);
7002 }
7003 }
7003 void PythonQtShell_elfInfoWdgt::mouseMoveEvent(QMouseEvent* arg__1)
7004 void PythonQtShell_elfInfoWdgt::mouseMoveEvent(QMouseEvent* arg__1)
7004 {
7005 {
7005 if (_wrapper) {
7006 if (_wrapper) {
7006 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseMoveEvent");
7007 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseMoveEvent");
7007 PyErr_Clear();
7008 PyErr_Clear();
7008 if (obj && !PythonQtSlotFunction_Check(obj)) {
7009 if (obj && !PythonQtSlotFunction_Check(obj)) {
7009 static const char* argumentList[] ={"" , "QMouseEvent*"};
7010 static const char* argumentList[] ={"" , "QMouseEvent*"};
7010 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7011 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7011 void* args[2] = {NULL, (void*)&arg__1};
7012 void* args[2] = {NULL, (void*)&arg__1};
7012 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7013 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7013 if (result) { Py_DECREF(result); }
7014 if (result) { Py_DECREF(result); }
7014 Py_DECREF(obj);
7015 Py_DECREF(obj);
7015 return;
7016 return;
7016 }
7017 }
7017 }
7018 }
7018 elfInfoWdgt::mouseMoveEvent(arg__1);
7019 elfInfoWdgt::mouseMoveEvent(arg__1);
7019 }
7020 }
7020 void PythonQtShell_elfInfoWdgt::mousePressEvent(QMouseEvent* arg__1)
7021 void PythonQtShell_elfInfoWdgt::mousePressEvent(QMouseEvent* arg__1)
7021 {
7022 {
7022 if (_wrapper) {
7023 if (_wrapper) {
7023 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mousePressEvent");
7024 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mousePressEvent");
7024 PyErr_Clear();
7025 PyErr_Clear();
7025 if (obj && !PythonQtSlotFunction_Check(obj)) {
7026 if (obj && !PythonQtSlotFunction_Check(obj)) {
7026 static const char* argumentList[] ={"" , "QMouseEvent*"};
7027 static const char* argumentList[] ={"" , "QMouseEvent*"};
7027 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7028 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7028 void* args[2] = {NULL, (void*)&arg__1};
7029 void* args[2] = {NULL, (void*)&arg__1};
7029 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7030 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7030 if (result) { Py_DECREF(result); }
7031 if (result) { Py_DECREF(result); }
7031 Py_DECREF(obj);
7032 Py_DECREF(obj);
7032 return;
7033 return;
7033 }
7034 }
7034 }
7035 }
7035 elfInfoWdgt::mousePressEvent(arg__1);
7036 elfInfoWdgt::mousePressEvent(arg__1);
7036 }
7037 }
7037 void PythonQtShell_elfInfoWdgt::mouseReleaseEvent(QMouseEvent* arg__1)
7038 void PythonQtShell_elfInfoWdgt::mouseReleaseEvent(QMouseEvent* arg__1)
7038 {
7039 {
7039 if (_wrapper) {
7040 if (_wrapper) {
7040 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseReleaseEvent");
7041 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseReleaseEvent");
7041 PyErr_Clear();
7042 PyErr_Clear();
7042 if (obj && !PythonQtSlotFunction_Check(obj)) {
7043 if (obj && !PythonQtSlotFunction_Check(obj)) {
7043 static const char* argumentList[] ={"" , "QMouseEvent*"};
7044 static const char* argumentList[] ={"" , "QMouseEvent*"};
7044 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7045 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7045 void* args[2] = {NULL, (void*)&arg__1};
7046 void* args[2] = {NULL, (void*)&arg__1};
7046 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7047 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7047 if (result) { Py_DECREF(result); }
7048 if (result) { Py_DECREF(result); }
7048 Py_DECREF(obj);
7049 Py_DECREF(obj);
7049 return;
7050 return;
7050 }
7051 }
7051 }
7052 }
7052 elfInfoWdgt::mouseReleaseEvent(arg__1);
7053 elfInfoWdgt::mouseReleaseEvent(arg__1);
7053 }
7054 }
7054 void PythonQtShell_elfInfoWdgt::moveEvent(QMoveEvent* arg__1)
7055 void PythonQtShell_elfInfoWdgt::moveEvent(QMoveEvent* arg__1)
7055 {
7056 {
7056 if (_wrapper) {
7057 if (_wrapper) {
7057 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "moveEvent");
7058 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "moveEvent");
7058 PyErr_Clear();
7059 PyErr_Clear();
7059 if (obj && !PythonQtSlotFunction_Check(obj)) {
7060 if (obj && !PythonQtSlotFunction_Check(obj)) {
7060 static const char* argumentList[] ={"" , "QMoveEvent*"};
7061 static const char* argumentList[] ={"" , "QMoveEvent*"};
7061 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7062 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7062 void* args[2] = {NULL, (void*)&arg__1};
7063 void* args[2] = {NULL, (void*)&arg__1};
7063 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7064 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7064 if (result) { Py_DECREF(result); }
7065 if (result) { Py_DECREF(result); }
7065 Py_DECREF(obj);
7066 Py_DECREF(obj);
7066 return;
7067 return;
7067 }
7068 }
7068 }
7069 }
7069 elfInfoWdgt::moveEvent(arg__1);
7070 elfInfoWdgt::moveEvent(arg__1);
7070 }
7071 }
7071 bool PythonQtShell_elfInfoWdgt::nativeEvent(const QByteArray& eventType, void* message, long* result)
7072 bool PythonQtShell_elfInfoWdgt::nativeEvent(const QByteArray& eventType, void* message, long* result)
7072 {
7073 {
7073 if (_wrapper) {
7074 if (_wrapper) {
7074 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "nativeEvent");
7075 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "nativeEvent");
7075 PyErr_Clear();
7076 PyErr_Clear();
7076 if (obj && !PythonQtSlotFunction_Check(obj)) {
7077 if (obj && !PythonQtSlotFunction_Check(obj)) {
7077 static const char* argumentList[] ={"bool" , "const QByteArray&" , "void*" , "long*"};
7078 static const char* argumentList[] ={"bool" , "const QByteArray&" , "void*" , "long*"};
7078 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
7079 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
7079 bool returnValue;
7080 bool returnValue;
7080 void* args[4] = {NULL, (void*)&eventType, (void*)&message, (void*)&result};
7081 void* args[4] = {NULL, (void*)&eventType, (void*)&message, (void*)&result};
7081 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7082 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7082 if (result) {
7083 if (result) {
7083 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
7084 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
7084 if (args[0]!=&returnValue) {
7085 if (args[0]!=&returnValue) {
7085 if (args[0]==NULL) {
7086 if (args[0]==NULL) {
7086 PythonQt::priv()->handleVirtualOverloadReturnError("nativeEvent", methodInfo, result);
7087 PythonQt::priv()->handleVirtualOverloadReturnError("nativeEvent", methodInfo, result);
7087 } else {
7088 } else {
7088 returnValue = *((bool*)args[0]);
7089 returnValue = *((bool*)args[0]);
7089 }
7090 }
7090 }
7091 }
7091 }
7092 }
7092 if (result) { Py_DECREF(result); }
7093 if (result) { Py_DECREF(result); }
7093 Py_DECREF(obj);
7094 Py_DECREF(obj);
7094 return returnValue;
7095 return returnValue;
7095 }
7096 }
7096 }
7097 }
7097 return elfInfoWdgt::nativeEvent(eventType, message, result);
7098 return elfInfoWdgt::nativeEvent(eventType, message, result);
7098 }
7099 }
7099 QPaintEngine* PythonQtShell_elfInfoWdgt::paintEngine() const
7100 QPaintEngine* PythonQtShell_elfInfoWdgt::paintEngine() const
7100 {
7101 {
7101 if (_wrapper) {
7102 if (_wrapper) {
7102 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEngine");
7103 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEngine");
7103 PyErr_Clear();
7104 PyErr_Clear();
7104 if (obj && !PythonQtSlotFunction_Check(obj)) {
7105 if (obj && !PythonQtSlotFunction_Check(obj)) {
7105 static const char* argumentList[] ={"QPaintEngine*"};
7106 static const char* argumentList[] ={"QPaintEngine*"};
7106 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
7107 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
7107 QPaintEngine* returnValue;
7108 QPaintEngine* returnValue;
7108 void* args[1] = {NULL};
7109 void* args[1] = {NULL};
7109 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7110 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7110 if (result) {
7111 if (result) {
7111 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
7112 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
7112 if (args[0]!=&returnValue) {
7113 if (args[0]!=&returnValue) {
7113 if (args[0]==NULL) {
7114 if (args[0]==NULL) {
7114 PythonQt::priv()->handleVirtualOverloadReturnError("paintEngine", methodInfo, result);
7115 PythonQt::priv()->handleVirtualOverloadReturnError("paintEngine", methodInfo, result);
7115 } else {
7116 } else {
7116 returnValue = *((QPaintEngine**)args[0]);
7117 returnValue = *((QPaintEngine**)args[0]);
7117 }
7118 }
7118 }
7119 }
7119 }
7120 }
7120 if (result) { Py_DECREF(result); }
7121 if (result) { Py_DECREF(result); }
7121 Py_DECREF(obj);
7122 Py_DECREF(obj);
7122 return returnValue;
7123 return returnValue;
7123 }
7124 }
7124 }
7125 }
7125 return elfInfoWdgt::paintEngine();
7126 return elfInfoWdgt::paintEngine();
7126 }
7127 }
7127 void PythonQtShell_elfInfoWdgt::paintEvent(QPaintEvent* arg__1)
7128 void PythonQtShell_elfInfoWdgt::paintEvent(QPaintEvent* arg__1)
7128 {
7129 {
7129 if (_wrapper) {
7130 if (_wrapper) {
7130 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEvent");
7131 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEvent");
7131 PyErr_Clear();
7132 PyErr_Clear();
7132 if (obj && !PythonQtSlotFunction_Check(obj)) {
7133 if (obj && !PythonQtSlotFunction_Check(obj)) {
7133 static const char* argumentList[] ={"" , "QPaintEvent*"};
7134 static const char* argumentList[] ={"" , "QPaintEvent*"};
7134 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7135 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7135 void* args[2] = {NULL, (void*)&arg__1};
7136 void* args[2] = {NULL, (void*)&arg__1};
7136 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7137 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7137 if (result) { Py_DECREF(result); }
7138 if (result) { Py_DECREF(result); }
7138 Py_DECREF(obj);
7139 Py_DECREF(obj);
7139 return;
7140 return;
7140 }
7141 }
7141 }
7142 }
7142 elfInfoWdgt::paintEvent(arg__1);
7143 elfInfoWdgt::paintEvent(arg__1);
7143 }
7144 }
7144 QPaintDevice* PythonQtShell_elfInfoWdgt::redirected(QPoint* offset) const
7145 QPaintDevice* PythonQtShell_elfInfoWdgt::redirected(QPoint* offset) const
7145 {
7146 {
7146 if (_wrapper) {
7147 if (_wrapper) {
7147 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "redirected");
7148 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "redirected");
7148 PyErr_Clear();
7149 PyErr_Clear();
7149 if (obj && !PythonQtSlotFunction_Check(obj)) {
7150 if (obj && !PythonQtSlotFunction_Check(obj)) {
7150 static const char* argumentList[] ={"QPaintDevice*" , "QPoint*"};
7151 static const char* argumentList[] ={"QPaintDevice*" , "QPoint*"};
7151 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7152 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7152 QPaintDevice* returnValue;
7153 QPaintDevice* returnValue;
7153 void* args[2] = {NULL, (void*)&offset};
7154 void* args[2] = {NULL, (void*)&offset};
7154 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7155 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7155 if (result) {
7156 if (result) {
7156 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
7157 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
7157 if (args[0]!=&returnValue) {
7158 if (args[0]!=&returnValue) {
7158 if (args[0]==NULL) {
7159 if (args[0]==NULL) {
7159 PythonQt::priv()->handleVirtualOverloadReturnError("redirected", methodInfo, result);
7160 PythonQt::priv()->handleVirtualOverloadReturnError("redirected", methodInfo, result);
7160 } else {
7161 } else {
7161 returnValue = *((QPaintDevice**)args[0]);
7162 returnValue = *((QPaintDevice**)args[0]);
7162 }
7163 }
7163 }
7164 }
7164 }
7165 }
7165 if (result) { Py_DECREF(result); }
7166 if (result) { Py_DECREF(result); }
7166 Py_DECREF(obj);
7167 Py_DECREF(obj);
7167 return returnValue;
7168 return returnValue;
7168 }
7169 }
7169 }
7170 }
7170 return elfInfoWdgt::redirected(offset);
7171 return elfInfoWdgt::redirected(offset);
7171 }
7172 }
7172 void PythonQtShell_elfInfoWdgt::resizeEvent(QResizeEvent* arg__1)
7173 void PythonQtShell_elfInfoWdgt::resizeEvent(QResizeEvent* arg__1)
7173 {
7174 {
7174 if (_wrapper) {
7175 if (_wrapper) {
7175 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "resizeEvent");
7176 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "resizeEvent");
7176 PyErr_Clear();
7177 PyErr_Clear();
7177 if (obj && !PythonQtSlotFunction_Check(obj)) {
7178 if (obj && !PythonQtSlotFunction_Check(obj)) {
7178 static const char* argumentList[] ={"" , "QResizeEvent*"};
7179 static const char* argumentList[] ={"" , "QResizeEvent*"};
7179 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7180 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7180 void* args[2] = {NULL, (void*)&arg__1};
7181 void* args[2] = {NULL, (void*)&arg__1};
7181 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7182 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7182 if (result) { Py_DECREF(result); }
7183 if (result) { Py_DECREF(result); }
7183 Py_DECREF(obj);
7184 Py_DECREF(obj);
7184 return;
7185 return;
7185 }
7186 }
7186 }
7187 }
7187 elfInfoWdgt::resizeEvent(arg__1);
7188 elfInfoWdgt::resizeEvent(arg__1);
7188 }
7189 }
7189 QPainter* PythonQtShell_elfInfoWdgt::sharedPainter() const
7190 QPainter* PythonQtShell_elfInfoWdgt::sharedPainter() const
7190 {
7191 {
7191 if (_wrapper) {
7192 if (_wrapper) {
7192 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "sharedPainter");
7193 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "sharedPainter");
7193 PyErr_Clear();
7194 PyErr_Clear();
7194 if (obj && !PythonQtSlotFunction_Check(obj)) {
7195 if (obj && !PythonQtSlotFunction_Check(obj)) {
7195 static const char* argumentList[] ={"QPainter*"};
7196 static const char* argumentList[] ={"QPainter*"};
7196 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
7197 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
7197 QPainter* returnValue;
7198 QPainter* returnValue;
7198 void* args[1] = {NULL};
7199 void* args[1] = {NULL};
7199 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7200 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7200 if (result) {
7201 if (result) {
7201 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
7202 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
7202 if (args[0]!=&returnValue) {
7203 if (args[0]!=&returnValue) {
7203 if (args[0]==NULL) {
7204 if (args[0]==NULL) {
7204 PythonQt::priv()->handleVirtualOverloadReturnError("sharedPainter", methodInfo, result);
7205 PythonQt::priv()->handleVirtualOverloadReturnError("sharedPainter", methodInfo, result);
7205 } else {
7206 } else {
7206 returnValue = *((QPainter**)args[0]);
7207 returnValue = *((QPainter**)args[0]);
7207 }
7208 }
7208 }
7209 }
7209 }
7210 }
7210 if (result) { Py_DECREF(result); }
7211 if (result) { Py_DECREF(result); }
7211 Py_DECREF(obj);
7212 Py_DECREF(obj);
7212 return returnValue;
7213 return returnValue;
7213 }
7214 }
7214 }
7215 }
7215 return elfInfoWdgt::sharedPainter();
7216 return elfInfoWdgt::sharedPainter();
7216 }
7217 }
7217 void PythonQtShell_elfInfoWdgt::showEvent(QShowEvent* arg__1)
7218 void PythonQtShell_elfInfoWdgt::showEvent(QShowEvent* arg__1)
7218 {
7219 {
7219 if (_wrapper) {
7220 if (_wrapper) {
7220 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "showEvent");
7221 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "showEvent");
7221 PyErr_Clear();
7222 PyErr_Clear();
7222 if (obj && !PythonQtSlotFunction_Check(obj)) {
7223 if (obj && !PythonQtSlotFunction_Check(obj)) {
7223 static const char* argumentList[] ={"" , "QShowEvent*"};
7224 static const char* argumentList[] ={"" , "QShowEvent*"};
7224 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7225 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7225 void* args[2] = {NULL, (void*)&arg__1};
7226 void* args[2] = {NULL, (void*)&arg__1};
7226 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7227 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7227 if (result) { Py_DECREF(result); }
7228 if (result) { Py_DECREF(result); }
7228 Py_DECREF(obj);
7229 Py_DECREF(obj);
7229 return;
7230 return;
7230 }
7231 }
7231 }
7232 }
7232 elfInfoWdgt::showEvent(arg__1);
7233 elfInfoWdgt::showEvent(arg__1);
7233 }
7234 }
7234 QSize PythonQtShell_elfInfoWdgt::sizeHint() const
7235 QSize PythonQtShell_elfInfoWdgt::sizeHint() const
7235 {
7236 {
7236 if (_wrapper) {
7237 if (_wrapper) {
7237 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getSizeHint");
7238 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getSizeHint");
7238 PyErr_Clear();
7239 PyErr_Clear();
7239 if (obj && !PythonQtSlotFunction_Check(obj)) {
7240 if (obj && !PythonQtSlotFunction_Check(obj)) {
7240 static const char* argumentList[] ={"QSize"};
7241 static const char* argumentList[] ={"QSize"};
7241 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
7242 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
7242 QSize returnValue;
7243 QSize returnValue;
7243 void* args[1] = {NULL};
7244 void* args[1] = {NULL};
7244 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7245 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7245 if (result) {
7246 if (result) {
7246 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
7247 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
7247 if (args[0]!=&returnValue) {
7248 if (args[0]!=&returnValue) {
7248 if (args[0]==NULL) {
7249 if (args[0]==NULL) {
7249 PythonQt::priv()->handleVirtualOverloadReturnError("getSizeHint", methodInfo, result);
7250 PythonQt::priv()->handleVirtualOverloadReturnError("getSizeHint", methodInfo, result);
7250 } else {
7251 } else {
7251 returnValue = *((QSize*)args[0]);
7252 returnValue = *((QSize*)args[0]);
7252 }
7253 }
7253 }
7254 }
7254 }
7255 }
7255 if (result) { Py_DECREF(result); }
7256 if (result) { Py_DECREF(result); }
7256 Py_DECREF(obj);
7257 Py_DECREF(obj);
7257 return returnValue;
7258 return returnValue;
7258 }
7259 }
7259 }
7260 }
7260 return elfInfoWdgt::sizeHint();
7261 return elfInfoWdgt::sizeHint();
7261 }
7262 }
7262 void PythonQtShell_elfInfoWdgt::tabletEvent(QTabletEvent* arg__1)
7263 void PythonQtShell_elfInfoWdgt::tabletEvent(QTabletEvent* arg__1)
7263 {
7264 {
7264 if (_wrapper) {
7265 if (_wrapper) {
7265 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "tabletEvent");
7266 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "tabletEvent");
7266 PyErr_Clear();
7267 PyErr_Clear();
7267 if (obj && !PythonQtSlotFunction_Check(obj)) {
7268 if (obj && !PythonQtSlotFunction_Check(obj)) {
7268 static const char* argumentList[] ={"" , "QTabletEvent*"};
7269 static const char* argumentList[] ={"" , "QTabletEvent*"};
7269 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7270 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7270 void* args[2] = {NULL, (void*)&arg__1};
7271 void* args[2] = {NULL, (void*)&arg__1};
7271 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7272 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7272 if (result) { Py_DECREF(result); }
7273 if (result) { Py_DECREF(result); }
7273 Py_DECREF(obj);
7274 Py_DECREF(obj);
7274 return;
7275 return;
7275 }
7276 }
7276 }
7277 }
7277 elfInfoWdgt::tabletEvent(arg__1);
7278 elfInfoWdgt::tabletEvent(arg__1);
7278 }
7279 }
7279 void PythonQtShell_elfInfoWdgt::timerEvent(QTimerEvent* arg__1)
7280 void PythonQtShell_elfInfoWdgt::timerEvent(QTimerEvent* arg__1)
7280 {
7281 {
7281 if (_wrapper) {
7282 if (_wrapper) {
7282 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "timerEvent");
7283 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "timerEvent");
7283 PyErr_Clear();
7284 PyErr_Clear();
7284 if (obj && !PythonQtSlotFunction_Check(obj)) {
7285 if (obj && !PythonQtSlotFunction_Check(obj)) {
7285 static const char* argumentList[] ={"" , "QTimerEvent*"};
7286 static const char* argumentList[] ={"" , "QTimerEvent*"};
7286 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7287 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7287 void* args[2] = {NULL, (void*)&arg__1};
7288 void* args[2] = {NULL, (void*)&arg__1};
7288 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7289 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7289 if (result) { Py_DECREF(result); }
7290 if (result) { Py_DECREF(result); }
7290 Py_DECREF(obj);
7291 Py_DECREF(obj);
7291 return;
7292 return;
7292 }
7293 }
7293 }
7294 }
7294 elfInfoWdgt::timerEvent(arg__1);
7295 elfInfoWdgt::timerEvent(arg__1);
7295 }
7296 }
7296 void PythonQtShell_elfInfoWdgt::wheelEvent(QWheelEvent* arg__1)
7297 void PythonQtShell_elfInfoWdgt::wheelEvent(QWheelEvent* arg__1)
7297 {
7298 {
7298 if (_wrapper) {
7299 if (_wrapper) {
7299 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "wheelEvent");
7300 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "wheelEvent");
7300 PyErr_Clear();
7301 PyErr_Clear();
7301 if (obj && !PythonQtSlotFunction_Check(obj)) {
7302 if (obj && !PythonQtSlotFunction_Check(obj)) {
7302 static const char* argumentList[] ={"" , "QWheelEvent*"};
7303 static const char* argumentList[] ={"" , "QWheelEvent*"};
7303 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7304 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7304 void* args[2] = {NULL, (void*)&arg__1};
7305 void* args[2] = {NULL, (void*)&arg__1};
7305 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7306 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7306 if (result) { Py_DECREF(result); }
7307 if (result) { Py_DECREF(result); }
7307 Py_DECREF(obj);
7308 Py_DECREF(obj);
7308 return;
7309 return;
7309 }
7310 }
7310 }
7311 }
7311 elfInfoWdgt::wheelEvent(arg__1);
7312 elfInfoWdgt::wheelEvent(arg__1);
7312 }
7313 }
7313 elfInfoWdgt* PythonQtWrapper_elfInfoWdgt::new_elfInfoWdgt(QWidget* parent)
7314 elfInfoWdgt* PythonQtWrapper_elfInfoWdgt::new_elfInfoWdgt(QWidget* parent)
7314 {
7315 {
7315 return new PythonQtShell_elfInfoWdgt(parent); }
7316 return new PythonQtShell_elfInfoWdgt(parent); }
7316
7317
7317
7318
7318
7319
7319 elfparser* PythonQtWrapper_elfparser::new_elfparser()
7320 elfparser* PythonQtWrapper_elfparser::new_elfparser()
7320 {
7321 {
7321 return new elfparser(); }
7322 return new elfparser(); }
7322
7323
7323 int PythonQtWrapper_elfparser::closeFile(elfparser* theWrappedObject)
7324 int PythonQtWrapper_elfparser::closeFile(elfparser* theWrappedObject)
7324 {
7325 {
7325 return ( theWrappedObject->closeFile());
7326 return ( theWrappedObject->closeFile());
7326 }
7327 }
7327
7328
7328 QString PythonQtWrapper_elfparser::getABI(elfparser* theWrappedObject)
7329 QString PythonQtWrapper_elfparser::getABI(elfparser* theWrappedObject)
7329 {
7330 {
7330 return ( theWrappedObject->getABI());
7331 return ( theWrappedObject->getABI());
7331 }
7332 }
7332
7333
7333 QString PythonQtWrapper_elfparser::getArchitecture(elfparser* theWrappedObject)
7334 QString PythonQtWrapper_elfparser::getArchitecture(elfparser* theWrappedObject)
7334 {
7335 {
7335 return ( theWrappedObject->getArchitecture());
7336 return ( theWrappedObject->getArchitecture());
7336 }
7337 }
7337
7338
7338 QString PythonQtWrapper_elfparser::getClass(elfparser* theWrappedObject)
7339 QString PythonQtWrapper_elfparser::getClass(elfparser* theWrappedObject)
7339 {
7340 {
7340 return ( theWrappedObject->getClass());
7341 return ( theWrappedObject->getClass());
7341 }
7342 }
7342
7343
7343 QString PythonQtWrapper_elfparser::getEndianness(elfparser* theWrappedObject)
7344 QString PythonQtWrapper_elfparser::getEndianness(elfparser* theWrappedObject)
7344 {
7345 {
7345 return ( theWrappedObject->getEndianness());
7346 return ( theWrappedObject->getEndianness());
7346 }
7347 }
7347
7348
7348 qint64 PythonQtWrapper_elfparser::getEntryPointAddress(elfparser* theWrappedObject)
7349 qint64 PythonQtWrapper_elfparser::getEntryPointAddress(elfparser* theWrappedObject)
7349 {
7350 {
7350 return ( theWrappedObject->getEntryPointAddress());
7351 return ( theWrappedObject->getEntryPointAddress());
7351 }
7352 }
7352
7353
7353 bool PythonQtWrapper_elfparser::getSectionData(elfparser* theWrappedObject, int index, char** buffer)
7354 bool PythonQtWrapper_elfparser::getSectionData(elfparser* theWrappedObject, int index, char** buffer)
7354 {
7355 {
7355 return ( theWrappedObject->getSectionData(index, buffer));
7356 return ( theWrappedObject->getSectionData(index, buffer));
7356 }
7357 }
7357
7358
7358 qint64 PythonQtWrapper_elfparser::getSectionDatasz(elfparser* theWrappedObject, int index)
7359 qint64 PythonQtWrapper_elfparser::getSectionDatasz(elfparser* theWrappedObject, int index)
7359 {
7360 {
7360 return ( theWrappedObject->getSectionDatasz(index));
7361 return ( theWrappedObject->getSectionDatasz(index));
7361 }
7362 }
7362
7363
7363 qint64 PythonQtWrapper_elfparser::getSectionMemsz(elfparser* theWrappedObject, int index)
7364 qint64 PythonQtWrapper_elfparser::getSectionMemsz(elfparser* theWrappedObject, int index)
7364 {
7365 {
7365 return ( theWrappedObject->getSectionMemsz(index));
7366 return ( theWrappedObject->getSectionMemsz(index));
7366 }
7367 }
7367
7368
7368 QString PythonQtWrapper_elfparser::getSectionName(elfparser* theWrappedObject, int index)
7369 QString PythonQtWrapper_elfparser::getSectionName(elfparser* theWrappedObject, int index)
7369 {
7370 {
7370 return ( theWrappedObject->getSectionName(index));
7371 return ( theWrappedObject->getSectionName(index));
7371 }
7372 }
7372
7373
7373 qint64 PythonQtWrapper_elfparser::getSectionPaddr(elfparser* theWrappedObject, int index)
7374 qint64 PythonQtWrapper_elfparser::getSectionPaddr(elfparser* theWrappedObject, int index)
7374 {
7375 {
7375 return ( theWrappedObject->getSectionPaddr(index));
7376 return ( theWrappedObject->getSectionPaddr(index));
7376 }
7377 }
7377
7378
7378 QString PythonQtWrapper_elfparser::getSectionType(elfparser* theWrappedObject, int index)
7379 QString PythonQtWrapper_elfparser::getSectionType(elfparser* theWrappedObject, int index)
7379 {
7380 {
7380 return ( theWrappedObject->getSectionType(index));
7381 return ( theWrappedObject->getSectionType(index));
7381 }
7382 }
7382
7383
7383 int PythonQtWrapper_elfparser::getSectioncount(elfparser* theWrappedObject)
7384 int PythonQtWrapper_elfparser::getSectioncount(elfparser* theWrappedObject)
7384 {
7385 {
7385 return ( theWrappedObject->getSectioncount());
7386 return ( theWrappedObject->getSectioncount());
7386 }
7387 }
7387
7388
7388 qint64 PythonQtWrapper_elfparser::getSegmentFilesz(elfparser* theWrappedObject, int index)
7389 qint64 PythonQtWrapper_elfparser::getSegmentFilesz(elfparser* theWrappedObject, int index)
7389 {
7390 {
7390 return ( theWrappedObject->getSegmentFilesz(index));
7391 return ( theWrappedObject->getSegmentFilesz(index));
7391 }
7392 }
7392
7393
7393 QString PythonQtWrapper_elfparser::getSegmentFlags(elfparser* theWrappedObject, int index)
7394 QString PythonQtWrapper_elfparser::getSegmentFlags(elfparser* theWrappedObject, int index)
7394 {
7395 {
7395 return ( theWrappedObject->getSegmentFlags(index));
7396 return ( theWrappedObject->getSegmentFlags(index));
7396 }
7397 }
7397
7398
7398 qint64 PythonQtWrapper_elfparser::getSegmentMemsz(elfparser* theWrappedObject, int index)
7399 qint64 PythonQtWrapper_elfparser::getSegmentMemsz(elfparser* theWrappedObject, int index)
7399 {
7400 {
7400 return ( theWrappedObject->getSegmentMemsz(index));
7401 return ( theWrappedObject->getSegmentMemsz(index));
7401 }
7402 }
7402
7403
7403 qint64 PythonQtWrapper_elfparser::getSegmentOffset(elfparser* theWrappedObject, int index)
7404 qint64 PythonQtWrapper_elfparser::getSegmentOffset(elfparser* theWrappedObject, int index)
7404 {
7405 {
7405 return ( theWrappedObject->getSegmentOffset(index));
7406 return ( theWrappedObject->getSegmentOffset(index));
7406 }
7407 }
7407
7408
7408 qint64 PythonQtWrapper_elfparser::getSegmentPaddr(elfparser* theWrappedObject, int index)
7409 qint64 PythonQtWrapper_elfparser::getSegmentPaddr(elfparser* theWrappedObject, int index)
7409 {
7410 {
7410 return ( theWrappedObject->getSegmentPaddr(index));
7411 return ( theWrappedObject->getSegmentPaddr(index));
7411 }
7412 }
7412
7413
7413 QString PythonQtWrapper_elfparser::getSegmentType(elfparser* theWrappedObject, int index)
7414 QString PythonQtWrapper_elfparser::getSegmentType(elfparser* theWrappedObject, int index)
7414 {
7415 {
7415 return ( theWrappedObject->getSegmentType(index));
7416 return ( theWrappedObject->getSegmentType(index));
7416 }
7417 }
7417
7418
7418 qint64 PythonQtWrapper_elfparser::getSegmentVaddr(elfparser* theWrappedObject, int index)
7419 qint64 PythonQtWrapper_elfparser::getSegmentVaddr(elfparser* theWrappedObject, int index)
7419 {
7420 {
7420 return ( theWrappedObject->getSegmentVaddr(index));
7421 return ( theWrappedObject->getSegmentVaddr(index));
7421 }
7422 }
7422
7423
7423 int PythonQtWrapper_elfparser::getSegmentcount(elfparser* theWrappedObject)
7424 int PythonQtWrapper_elfparser::getSegmentcount(elfparser* theWrappedObject)
7424 {
7425 {
7425 return ( theWrappedObject->getSegmentcount());
7426 return ( theWrappedObject->getSegmentcount());
7426 }
7427 }
7427
7428
7428 QString PythonQtWrapper_elfparser::getType(elfparser* theWrappedObject)
7429 QString PythonQtWrapper_elfparser::getType(elfparser* theWrappedObject)
7429 {
7430 {
7430 return ( theWrappedObject->getType());
7431 return ( theWrappedObject->getType());
7431 }
7432 }
7432
7433
7433 qint64 PythonQtWrapper_elfparser::getVersion(elfparser* theWrappedObject)
7434 qint64 PythonQtWrapper_elfparser::getVersion(elfparser* theWrappedObject)
7434 {
7435 {
7435 return ( theWrappedObject->getVersion());
7436 return ( theWrappedObject->getVersion());
7436 }
7437 }
7437
7438
7438 bool PythonQtWrapper_elfparser::static_elfparser_isElf(const QString& File)
7439 bool PythonQtWrapper_elfparser::static_elfparser_isElf(const QString& File)
7439 {
7440 {
7440 return (elfparser::isElf(File));
7441 return (elfparser::isElf(File));
7441 }
7442 }
7442
7443
7443 bool PythonQtWrapper_elfparser::iself(elfparser* theWrappedObject)
7444 bool PythonQtWrapper_elfparser::iself(elfparser* theWrappedObject)
7444 {
7445 {
7445 return ( theWrappedObject->iself());
7446 return ( theWrappedObject->iself());
7446 }
7447 }
7447
7448
7448 bool PythonQtWrapper_elfparser::isopened(elfparser* theWrappedObject)
7449 bool PythonQtWrapper_elfparser::isopened(elfparser* theWrappedObject)
7449 {
7450 {
7450 return ( theWrappedObject->isopened());
7451 return ( theWrappedObject->isopened());
7451 }
7452 }
7452
7453
7453 int PythonQtWrapper_elfparser::setFilename(elfparser* theWrappedObject, const QString& name)
7454 int PythonQtWrapper_elfparser::setFilename(elfparser* theWrappedObject, const QString& name)
7454 {
7455 {
7455 return ( theWrappedObject->setFilename(name));
7456 return ( theWrappedObject->setFilename(name));
7456 }
7457 }
7457
7458
7458
7459
7459
7460
7461 PythonQtShell_genericBinaryFileWidget::~PythonQtShell_genericBinaryFileWidget() {
7462 PythonQtPrivate* priv = PythonQt::priv();
7463 if (priv) { priv->shellClassDeleted(this); }
7464 }
7465 void PythonQtShell_genericBinaryFileWidget::actionEvent(QActionEvent* arg__1)
7466 {
7467 if (_wrapper) {
7468 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "actionEvent");
7469 PyErr_Clear();
7470 if (obj && !PythonQtSlotFunction_Check(obj)) {
7471 static const char* argumentList[] ={"" , "QActionEvent*"};
7472 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7473 void* args[2] = {NULL, (void*)&arg__1};
7474 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7475 if (result) { Py_DECREF(result); }
7476 Py_DECREF(obj);
7477 return;
7478 }
7479 }
7480 genericBinaryFileWidget::actionEvent(arg__1);
7481 }
7482 void PythonQtShell_genericBinaryFileWidget::changeEvent(QEvent* arg__1)
7483 {
7484 if (_wrapper) {
7485 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "changeEvent");
7486 PyErr_Clear();
7487 if (obj && !PythonQtSlotFunction_Check(obj)) {
7488 static const char* argumentList[] ={"" , "QEvent*"};
7489 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7490 void* args[2] = {NULL, (void*)&arg__1};
7491 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7492 if (result) { Py_DECREF(result); }
7493 Py_DECREF(obj);
7494 return;
7495 }
7496 }
7497 genericBinaryFileWidget::changeEvent(arg__1);
7498 }
7499 void PythonQtShell_genericBinaryFileWidget::childEvent(QChildEvent* arg__1)
7500 {
7501 if (_wrapper) {
7502 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "childEvent");
7503 PyErr_Clear();
7504 if (obj && !PythonQtSlotFunction_Check(obj)) {
7505 static const char* argumentList[] ={"" , "QChildEvent*"};
7506 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7507 void* args[2] = {NULL, (void*)&arg__1};
7508 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7509 if (result) { Py_DECREF(result); }
7510 Py_DECREF(obj);
7511 return;
7512 }
7513 }
7514 genericBinaryFileWidget::childEvent(arg__1);
7515 }
7516 void PythonQtShell_genericBinaryFileWidget::closeEvent(QCloseEvent* arg__1)
7517 {
7518 if (_wrapper) {
7519 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "closeEvent");
7520 PyErr_Clear();
7521 if (obj && !PythonQtSlotFunction_Check(obj)) {
7522 static const char* argumentList[] ={"" , "QCloseEvent*"};
7523 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7524 void* args[2] = {NULL, (void*)&arg__1};
7525 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7526 if (result) { Py_DECREF(result); }
7527 Py_DECREF(obj);
7528 return;
7529 }
7530 }
7531 genericBinaryFileWidget::closeEvent(arg__1);
7532 }
7533 void PythonQtShell_genericBinaryFileWidget::contextMenuEvent(QContextMenuEvent* arg__1)
7534 {
7535 if (_wrapper) {
7536 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "contextMenuEvent");
7537 PyErr_Clear();
7538 if (obj && !PythonQtSlotFunction_Check(obj)) {
7539 static const char* argumentList[] ={"" , "QContextMenuEvent*"};
7540 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7541 void* args[2] = {NULL, (void*)&arg__1};
7542 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7543 if (result) { Py_DECREF(result); }
7544 Py_DECREF(obj);
7545 return;
7546 }
7547 }
7548 genericBinaryFileWidget::contextMenuEvent(arg__1);
7549 }
7550 void PythonQtShell_genericBinaryFileWidget::customEvent(QEvent* arg__1)
7551 {
7552 if (_wrapper) {
7553 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "customEvent");
7554 PyErr_Clear();
7555 if (obj && !PythonQtSlotFunction_Check(obj)) {
7556 static const char* argumentList[] ={"" , "QEvent*"};
7557 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7558 void* args[2] = {NULL, (void*)&arg__1};
7559 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7560 if (result) { Py_DECREF(result); }
7561 Py_DECREF(obj);
7562 return;
7563 }
7564 }
7565 genericBinaryFileWidget::customEvent(arg__1);
7566 }
7567 int PythonQtShell_genericBinaryFileWidget::devType() const
7568 {
7569 if (_wrapper) {
7570 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "devType");
7571 PyErr_Clear();
7572 if (obj && !PythonQtSlotFunction_Check(obj)) {
7573 static const char* argumentList[] ={"int"};
7574 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
7575 int returnValue;
7576 void* args[1] = {NULL};
7577 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7578 if (result) {
7579 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
7580 if (args[0]!=&returnValue) {
7581 if (args[0]==NULL) {
7582 PythonQt::priv()->handleVirtualOverloadReturnError("devType", methodInfo, result);
7583 } else {
7584 returnValue = *((int*)args[0]);
7585 }
7586 }
7587 }
7588 if (result) { Py_DECREF(result); }
7589 Py_DECREF(obj);
7590 return returnValue;
7591 }
7592 }
7593 return genericBinaryFileWidget::devType();
7594 }
7595 void PythonQtShell_genericBinaryFileWidget::dragEnterEvent(QDragEnterEvent* arg__1)
7596 {
7597 if (_wrapper) {
7598 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragEnterEvent");
7599 PyErr_Clear();
7600 if (obj && !PythonQtSlotFunction_Check(obj)) {
7601 static const char* argumentList[] ={"" , "QDragEnterEvent*"};
7602 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7603 void* args[2] = {NULL, (void*)&arg__1};
7604 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7605 if (result) { Py_DECREF(result); }
7606 Py_DECREF(obj);
7607 return;
7608 }
7609 }
7610 genericBinaryFileWidget::dragEnterEvent(arg__1);
7611 }
7612 void PythonQtShell_genericBinaryFileWidget::dragLeaveEvent(QDragLeaveEvent* arg__1)
7613 {
7614 if (_wrapper) {
7615 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragLeaveEvent");
7616 PyErr_Clear();
7617 if (obj && !PythonQtSlotFunction_Check(obj)) {
7618 static const char* argumentList[] ={"" , "QDragLeaveEvent*"};
7619 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7620 void* args[2] = {NULL, (void*)&arg__1};
7621 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7622 if (result) { Py_DECREF(result); }
7623 Py_DECREF(obj);
7624 return;
7625 }
7626 }
7627 genericBinaryFileWidget::dragLeaveEvent(arg__1);
7628 }
7629 void PythonQtShell_genericBinaryFileWidget::dragMoveEvent(QDragMoveEvent* arg__1)
7630 {
7631 if (_wrapper) {
7632 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragMoveEvent");
7633 PyErr_Clear();
7634 if (obj && !PythonQtSlotFunction_Check(obj)) {
7635 static const char* argumentList[] ={"" , "QDragMoveEvent*"};
7636 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7637 void* args[2] = {NULL, (void*)&arg__1};
7638 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7639 if (result) { Py_DECREF(result); }
7640 Py_DECREF(obj);
7641 return;
7642 }
7643 }
7644 genericBinaryFileWidget::dragMoveEvent(arg__1);
7645 }
7646 void PythonQtShell_genericBinaryFileWidget::dropEvent(QDropEvent* arg__1)
7647 {
7648 if (_wrapper) {
7649 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dropEvent");
7650 PyErr_Clear();
7651 if (obj && !PythonQtSlotFunction_Check(obj)) {
7652 static const char* argumentList[] ={"" , "QDropEvent*"};
7653 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7654 void* args[2] = {NULL, (void*)&arg__1};
7655 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7656 if (result) { Py_DECREF(result); }
7657 Py_DECREF(obj);
7658 return;
7659 }
7660 }
7661 genericBinaryFileWidget::dropEvent(arg__1);
7662 }
7663 void PythonQtShell_genericBinaryFileWidget::enterEvent(QEvent* arg__1)
7664 {
7665 if (_wrapper) {
7666 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "enterEvent");
7667 PyErr_Clear();
7668 if (obj && !PythonQtSlotFunction_Check(obj)) {
7669 static const char* argumentList[] ={"" , "QEvent*"};
7670 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7671 void* args[2] = {NULL, (void*)&arg__1};
7672 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7673 if (result) { Py_DECREF(result); }
7674 Py_DECREF(obj);
7675 return;
7676 }
7677 }
7678 genericBinaryFileWidget::enterEvent(arg__1);
7679 }
7680 bool PythonQtShell_genericBinaryFileWidget::event(QEvent* arg__1)
7681 {
7682 if (_wrapper) {
7683 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "event");
7684 PyErr_Clear();
7685 if (obj && !PythonQtSlotFunction_Check(obj)) {
7686 static const char* argumentList[] ={"bool" , "QEvent*"};
7687 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7688 bool returnValue;
7689 void* args[2] = {NULL, (void*)&arg__1};
7690 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7691 if (result) {
7692 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
7693 if (args[0]!=&returnValue) {
7694 if (args[0]==NULL) {
7695 PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
7696 } else {
7697 returnValue = *((bool*)args[0]);
7698 }
7699 }
7700 }
7701 if (result) { Py_DECREF(result); }
7702 Py_DECREF(obj);
7703 return returnValue;
7704 }
7705 }
7706 return genericBinaryFileWidget::event(arg__1);
7707 }
7708 bool PythonQtShell_genericBinaryFileWidget::eventFilter(QObject* arg__1, QEvent* arg__2)
7709 {
7710 if (_wrapper) {
7711 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "eventFilter");
7712 PyErr_Clear();
7713 if (obj && !PythonQtSlotFunction_Check(obj)) {
7714 static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
7715 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
7716 bool returnValue;
7717 void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2};
7718 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7719 if (result) {
7720 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
7721 if (args[0]!=&returnValue) {
7722 if (args[0]==NULL) {
7723 PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
7724 } else {
7725 returnValue = *((bool*)args[0]);
7726 }
7727 }
7728 }
7729 if (result) { Py_DECREF(result); }
7730 Py_DECREF(obj);
7731 return returnValue;
7732 }
7733 }
7734 return genericBinaryFileWidget::eventFilter(arg__1, arg__2);
7735 }
7736 void PythonQtShell_genericBinaryFileWidget::focusInEvent(QFocusEvent* arg__1)
7737 {
7738 if (_wrapper) {
7739 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusInEvent");
7740 PyErr_Clear();
7741 if (obj && !PythonQtSlotFunction_Check(obj)) {
7742 static const char* argumentList[] ={"" , "QFocusEvent*"};
7743 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7744 void* args[2] = {NULL, (void*)&arg__1};
7745 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7746 if (result) { Py_DECREF(result); }
7747 Py_DECREF(obj);
7748 return;
7749 }
7750 }
7751 genericBinaryFileWidget::focusInEvent(arg__1);
7752 }
7753 bool PythonQtShell_genericBinaryFileWidget::focusNextPrevChild(bool next)
7754 {
7755 if (_wrapper) {
7756 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusNextPrevChild");
7757 PyErr_Clear();
7758 if (obj && !PythonQtSlotFunction_Check(obj)) {
7759 static const char* argumentList[] ={"bool" , "bool"};
7760 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7761 bool returnValue;
7762 void* args[2] = {NULL, (void*)&next};
7763 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7764 if (result) {
7765 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
7766 if (args[0]!=&returnValue) {
7767 if (args[0]==NULL) {
7768 PythonQt::priv()->handleVirtualOverloadReturnError("focusNextPrevChild", methodInfo, result);
7769 } else {
7770 returnValue = *((bool*)args[0]);
7771 }
7772 }
7773 }
7774 if (result) { Py_DECREF(result); }
7775 Py_DECREF(obj);
7776 return returnValue;
7777 }
7778 }
7779 return genericBinaryFileWidget::focusNextPrevChild(next);
7780 }
7781 void PythonQtShell_genericBinaryFileWidget::focusOutEvent(QFocusEvent* arg__1)
7782 {
7783 if (_wrapper) {
7784 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusOutEvent");
7785 PyErr_Clear();
7786 if (obj && !PythonQtSlotFunction_Check(obj)) {
7787 static const char* argumentList[] ={"" , "QFocusEvent*"};
7788 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7789 void* args[2] = {NULL, (void*)&arg__1};
7790 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7791 if (result) { Py_DECREF(result); }
7792 Py_DECREF(obj);
7793 return;
7794 }
7795 }
7796 genericBinaryFileWidget::focusOutEvent(arg__1);
7797 }
7798 bool PythonQtShell_genericBinaryFileWidget::hasHeightForWidth() const
7799 {
7800 if (_wrapper) {
7801 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hasHeightForWidth");
7802 PyErr_Clear();
7803 if (obj && !PythonQtSlotFunction_Check(obj)) {
7804 static const char* argumentList[] ={"bool"};
7805 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
7806 bool returnValue;
7807 void* args[1] = {NULL};
7808 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7809 if (result) {
7810 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
7811 if (args[0]!=&returnValue) {
7812 if (args[0]==NULL) {
7813 PythonQt::priv()->handleVirtualOverloadReturnError("hasHeightForWidth", methodInfo, result);
7814 } else {
7815 returnValue = *((bool*)args[0]);
7816 }
7817 }
7818 }
7819 if (result) { Py_DECREF(result); }
7820 Py_DECREF(obj);
7821 return returnValue;
7822 }
7823 }
7824 return genericBinaryFileWidget::hasHeightForWidth();
7825 }
7826 int PythonQtShell_genericBinaryFileWidget::heightForWidth(int arg__1) const
7827 {
7828 if (_wrapper) {
7829 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "heightForWidth");
7830 PyErr_Clear();
7831 if (obj && !PythonQtSlotFunction_Check(obj)) {
7832 static const char* argumentList[] ={"int" , "int"};
7833 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7834 int returnValue;
7835 void* args[2] = {NULL, (void*)&arg__1};
7836 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7837 if (result) {
7838 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
7839 if (args[0]!=&returnValue) {
7840 if (args[0]==NULL) {
7841 PythonQt::priv()->handleVirtualOverloadReturnError("heightForWidth", methodInfo, result);
7842 } else {
7843 returnValue = *((int*)args[0]);
7844 }
7845 }
7846 }
7847 if (result) { Py_DECREF(result); }
7848 Py_DECREF(obj);
7849 return returnValue;
7850 }
7851 }
7852 return genericBinaryFileWidget::heightForWidth(arg__1);
7853 }
7854 void PythonQtShell_genericBinaryFileWidget::hideEvent(QHideEvent* arg__1)
7855 {
7856 if (_wrapper) {
7857 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hideEvent");
7858 PyErr_Clear();
7859 if (obj && !PythonQtSlotFunction_Check(obj)) {
7860 static const char* argumentList[] ={"" , "QHideEvent*"};
7861 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7862 void* args[2] = {NULL, (void*)&arg__1};
7863 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7864 if (result) { Py_DECREF(result); }
7865 Py_DECREF(obj);
7866 return;
7867 }
7868 }
7869 genericBinaryFileWidget::hideEvent(arg__1);
7870 }
7871 void PythonQtShell_genericBinaryFileWidget::initPainter(QPainter* painter) const
7872 {
7873 if (_wrapper) {
7874 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "initPainter");
7875 PyErr_Clear();
7876 if (obj && !PythonQtSlotFunction_Check(obj)) {
7877 static const char* argumentList[] ={"" , "QPainter*"};
7878 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7879 void* args[2] = {NULL, (void*)&painter};
7880 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7881 if (result) { Py_DECREF(result); }
7882 Py_DECREF(obj);
7883 return;
7884 }
7885 }
7886 genericBinaryFileWidget::initPainter(painter);
7887 }
7888 void PythonQtShell_genericBinaryFileWidget::inputMethodEvent(QInputMethodEvent* arg__1)
7889 {
7890 if (_wrapper) {
7891 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodEvent");
7892 PyErr_Clear();
7893 if (obj && !PythonQtSlotFunction_Check(obj)) {
7894 static const char* argumentList[] ={"" , "QInputMethodEvent*"};
7895 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7896 void* args[2] = {NULL, (void*)&arg__1};
7897 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7898 if (result) { Py_DECREF(result); }
7899 Py_DECREF(obj);
7900 return;
7901 }
7902 }
7903 genericBinaryFileWidget::inputMethodEvent(arg__1);
7904 }
7905 QVariant PythonQtShell_genericBinaryFileWidget::inputMethodQuery(Qt::InputMethodQuery arg__1) const
7906 {
7907 if (_wrapper) {
7908 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodQuery");
7909 PyErr_Clear();
7910 if (obj && !PythonQtSlotFunction_Check(obj)) {
7911 static const char* argumentList[] ={"QVariant" , "Qt::InputMethodQuery"};
7912 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7913 QVariant returnValue;
7914 void* args[2] = {NULL, (void*)&arg__1};
7915 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7916 if (result) {
7917 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
7918 if (args[0]!=&returnValue) {
7919 if (args[0]==NULL) {
7920 PythonQt::priv()->handleVirtualOverloadReturnError("inputMethodQuery", methodInfo, result);
7921 } else {
7922 returnValue = *((QVariant*)args[0]);
7923 }
7924 }
7925 }
7926 if (result) { Py_DECREF(result); }
7927 Py_DECREF(obj);
7928 return returnValue;
7929 }
7930 }
7931 return genericBinaryFileWidget::inputMethodQuery(arg__1);
7932 }
7933 void PythonQtShell_genericBinaryFileWidget::keyPressEvent(QKeyEvent* arg__1)
7934 {
7935 if (_wrapper) {
7936 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyPressEvent");
7937 PyErr_Clear();
7938 if (obj && !PythonQtSlotFunction_Check(obj)) {
7939 static const char* argumentList[] ={"" , "QKeyEvent*"};
7940 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7941 void* args[2] = {NULL, (void*)&arg__1};
7942 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7943 if (result) { Py_DECREF(result); }
7944 Py_DECREF(obj);
7945 return;
7946 }
7947 }
7948 genericBinaryFileWidget::keyPressEvent(arg__1);
7949 }
7950 void PythonQtShell_genericBinaryFileWidget::keyReleaseEvent(QKeyEvent* arg__1)
7951 {
7952 if (_wrapper) {
7953 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyReleaseEvent");
7954 PyErr_Clear();
7955 if (obj && !PythonQtSlotFunction_Check(obj)) {
7956 static const char* argumentList[] ={"" , "QKeyEvent*"};
7957 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7958 void* args[2] = {NULL, (void*)&arg__1};
7959 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7960 if (result) { Py_DECREF(result); }
7961 Py_DECREF(obj);
7962 return;
7963 }
7964 }
7965 genericBinaryFileWidget::keyReleaseEvent(arg__1);
7966 }
7967 void PythonQtShell_genericBinaryFileWidget::leaveEvent(QEvent* arg__1)
7968 {
7969 if (_wrapper) {
7970 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "leaveEvent");
7971 PyErr_Clear();
7972 if (obj && !PythonQtSlotFunction_Check(obj)) {
7973 static const char* argumentList[] ={"" , "QEvent*"};
7974 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7975 void* args[2] = {NULL, (void*)&arg__1};
7976 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7977 if (result) { Py_DECREF(result); }
7978 Py_DECREF(obj);
7979 return;
7980 }
7981 }
7982 genericBinaryFileWidget::leaveEvent(arg__1);
7983 }
7984 int PythonQtShell_genericBinaryFileWidget::metric(QPaintDevice::PaintDeviceMetric arg__1) const
7985 {
7986 if (_wrapper) {
7987 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "metric");
7988 PyErr_Clear();
7989 if (obj && !PythonQtSlotFunction_Check(obj)) {
7990 static const char* argumentList[] ={"int" , "QPaintDevice::PaintDeviceMetric"};
7991 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7992 int returnValue;
7993 void* args[2] = {NULL, (void*)&arg__1};
7994 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7995 if (result) {
7996 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
7997 if (args[0]!=&returnValue) {
7998 if (args[0]==NULL) {
7999 PythonQt::priv()->handleVirtualOverloadReturnError("metric", methodInfo, result);
8000 } else {
8001 returnValue = *((int*)args[0]);
8002 }
8003 }
8004 }
8005 if (result) { Py_DECREF(result); }
8006 Py_DECREF(obj);
8007 return returnValue;
8008 }
8009 }
8010 return genericBinaryFileWidget::metric(arg__1);
8011 }
8012 QSize PythonQtShell_genericBinaryFileWidget::minimumSizeHint() const
8013 {
8014 if (_wrapper) {
8015 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getMinimumSizeHint");
8016 PyErr_Clear();
8017 if (obj && !PythonQtSlotFunction_Check(obj)) {
8018 static const char* argumentList[] ={"QSize"};
8019 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
8020 QSize returnValue;
8021 void* args[1] = {NULL};
8022 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8023 if (result) {
8024 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
8025 if (args[0]!=&returnValue) {
8026 if (args[0]==NULL) {
8027 PythonQt::priv()->handleVirtualOverloadReturnError("getMinimumSizeHint", methodInfo, result);
8028 } else {
8029 returnValue = *((QSize*)args[0]);
8030 }
8031 }
8032 }
8033 if (result) { Py_DECREF(result); }
8034 Py_DECREF(obj);
8035 return returnValue;
8036 }
8037 }
8038 return genericBinaryFileWidget::minimumSizeHint();
8039 }
8040 void PythonQtShell_genericBinaryFileWidget::mouseDoubleClickEvent(QMouseEvent* arg__1)
8041 {
8042 if (_wrapper) {
8043 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseDoubleClickEvent");
8044 PyErr_Clear();
8045 if (obj && !PythonQtSlotFunction_Check(obj)) {
8046 static const char* argumentList[] ={"" , "QMouseEvent*"};
8047 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8048 void* args[2] = {NULL, (void*)&arg__1};
8049 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8050 if (result) { Py_DECREF(result); }
8051 Py_DECREF(obj);
8052 return;
8053 }
8054 }
8055 genericBinaryFileWidget::mouseDoubleClickEvent(arg__1);
8056 }
8057 void PythonQtShell_genericBinaryFileWidget::mouseMoveEvent(QMouseEvent* arg__1)
8058 {
8059 if (_wrapper) {
8060 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseMoveEvent");
8061 PyErr_Clear();
8062 if (obj && !PythonQtSlotFunction_Check(obj)) {
8063 static const char* argumentList[] ={"" , "QMouseEvent*"};
8064 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8065 void* args[2] = {NULL, (void*)&arg__1};
8066 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8067 if (result) { Py_DECREF(result); }
8068 Py_DECREF(obj);
8069 return;
8070 }
8071 }
8072 genericBinaryFileWidget::mouseMoveEvent(arg__1);
8073 }
8074 void PythonQtShell_genericBinaryFileWidget::mousePressEvent(QMouseEvent* arg__1)
8075 {
8076 if (_wrapper) {
8077 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mousePressEvent");
8078 PyErr_Clear();
8079 if (obj && !PythonQtSlotFunction_Check(obj)) {
8080 static const char* argumentList[] ={"" , "QMouseEvent*"};
8081 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8082 void* args[2] = {NULL, (void*)&arg__1};
8083 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8084 if (result) { Py_DECREF(result); }
8085 Py_DECREF(obj);
8086 return;
8087 }
8088 }
8089 genericBinaryFileWidget::mousePressEvent(arg__1);
8090 }
8091 void PythonQtShell_genericBinaryFileWidget::mouseReleaseEvent(QMouseEvent* arg__1)
8092 {
8093 if (_wrapper) {
8094 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseReleaseEvent");
8095 PyErr_Clear();
8096 if (obj && !PythonQtSlotFunction_Check(obj)) {
8097 static const char* argumentList[] ={"" , "QMouseEvent*"};
8098 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8099 void* args[2] = {NULL, (void*)&arg__1};
8100 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8101 if (result) { Py_DECREF(result); }
8102 Py_DECREF(obj);
8103 return;
8104 }
8105 }
8106 genericBinaryFileWidget::mouseReleaseEvent(arg__1);
8107 }
8108 void PythonQtShell_genericBinaryFileWidget::moveEvent(QMoveEvent* arg__1)
8109 {
8110 if (_wrapper) {
8111 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "moveEvent");
8112 PyErr_Clear();
8113 if (obj && !PythonQtSlotFunction_Check(obj)) {
8114 static const char* argumentList[] ={"" , "QMoveEvent*"};
8115 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8116 void* args[2] = {NULL, (void*)&arg__1};
8117 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8118 if (result) { Py_DECREF(result); }
8119 Py_DECREF(obj);
8120 return;
8121 }
8122 }
8123 genericBinaryFileWidget::moveEvent(arg__1);
8124 }
8125 bool PythonQtShell_genericBinaryFileWidget::nativeEvent(const QByteArray& eventType, void* message, long* result)
8126 {
8127 if (_wrapper) {
8128 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "nativeEvent");
8129 PyErr_Clear();
8130 if (obj && !PythonQtSlotFunction_Check(obj)) {
8131 static const char* argumentList[] ={"bool" , "const QByteArray&" , "void*" , "long*"};
8132 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
8133 bool returnValue;
8134 void* args[4] = {NULL, (void*)&eventType, (void*)&message, (void*)&result};
8135 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8136 if (result) {
8137 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
8138 if (args[0]!=&returnValue) {
8139 if (args[0]==NULL) {
8140 PythonQt::priv()->handleVirtualOverloadReturnError("nativeEvent", methodInfo, result);
8141 } else {
8142 returnValue = *((bool*)args[0]);
8143 }
8144 }
8145 }
8146 if (result) { Py_DECREF(result); }
8147 Py_DECREF(obj);
8148 return returnValue;
8149 }
8150 }
8151 return genericBinaryFileWidget::nativeEvent(eventType, message, result);
8152 }
8153 QPaintEngine* PythonQtShell_genericBinaryFileWidget::paintEngine() const
8154 {
8155 if (_wrapper) {
8156 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEngine");
8157 PyErr_Clear();
8158 if (obj && !PythonQtSlotFunction_Check(obj)) {
8159 static const char* argumentList[] ={"QPaintEngine*"};
8160 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
8161 QPaintEngine* returnValue;
8162 void* args[1] = {NULL};
8163 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8164 if (result) {
8165 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
8166 if (args[0]!=&returnValue) {
8167 if (args[0]==NULL) {
8168 PythonQt::priv()->handleVirtualOverloadReturnError("paintEngine", methodInfo, result);
8169 } else {
8170 returnValue = *((QPaintEngine**)args[0]);
8171 }
8172 }
8173 }
8174 if (result) { Py_DECREF(result); }
8175 Py_DECREF(obj);
8176 return returnValue;
8177 }
8178 }
8179 return genericBinaryFileWidget::paintEngine();
8180 }
8181 void PythonQtShell_genericBinaryFileWidget::paintEvent(QPaintEvent* arg__1)
8182 {
8183 if (_wrapper) {
8184 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEvent");
8185 PyErr_Clear();
8186 if (obj && !PythonQtSlotFunction_Check(obj)) {
8187 static const char* argumentList[] ={"" , "QPaintEvent*"};
8188 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8189 void* args[2] = {NULL, (void*)&arg__1};
8190 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8191 if (result) { Py_DECREF(result); }
8192 Py_DECREF(obj);
8193 return;
8194 }
8195 }
8196 genericBinaryFileWidget::paintEvent(arg__1);
8197 }
8198 QPaintDevice* PythonQtShell_genericBinaryFileWidget::redirected(QPoint* offset) const
8199 {
8200 if (_wrapper) {
8201 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "redirected");
8202 PyErr_Clear();
8203 if (obj && !PythonQtSlotFunction_Check(obj)) {
8204 static const char* argumentList[] ={"QPaintDevice*" , "QPoint*"};
8205 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8206 QPaintDevice* returnValue;
8207 void* args[2] = {NULL, (void*)&offset};
8208 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8209 if (result) {
8210 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
8211 if (args[0]!=&returnValue) {
8212 if (args[0]==NULL) {
8213 PythonQt::priv()->handleVirtualOverloadReturnError("redirected", methodInfo, result);
8214 } else {
8215 returnValue = *((QPaintDevice**)args[0]);
8216 }
8217 }
8218 }
8219 if (result) { Py_DECREF(result); }
8220 Py_DECREF(obj);
8221 return returnValue;
8222 }
8223 }
8224 return genericBinaryFileWidget::redirected(offset);
8225 }
8226 void PythonQtShell_genericBinaryFileWidget::resizeEvent(QResizeEvent* arg__1)
8227 {
8228 if (_wrapper) {
8229 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "resizeEvent");
8230 PyErr_Clear();
8231 if (obj && !PythonQtSlotFunction_Check(obj)) {
8232 static const char* argumentList[] ={"" , "QResizeEvent*"};
8233 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8234 void* args[2] = {NULL, (void*)&arg__1};
8235 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8236 if (result) { Py_DECREF(result); }
8237 Py_DECREF(obj);
8238 return;
8239 }
8240 }
8241 genericBinaryFileWidget::resizeEvent(arg__1);
8242 }
8243 QPainter* PythonQtShell_genericBinaryFileWidget::sharedPainter() const
8244 {
8245 if (_wrapper) {
8246 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "sharedPainter");
8247 PyErr_Clear();
8248 if (obj && !PythonQtSlotFunction_Check(obj)) {
8249 static const char* argumentList[] ={"QPainter*"};
8250 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
8251 QPainter* returnValue;
8252 void* args[1] = {NULL};
8253 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8254 if (result) {
8255 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
8256 if (args[0]!=&returnValue) {
8257 if (args[0]==NULL) {
8258 PythonQt::priv()->handleVirtualOverloadReturnError("sharedPainter", methodInfo, result);
8259 } else {
8260 returnValue = *((QPainter**)args[0]);
8261 }
8262 }
8263 }
8264 if (result) { Py_DECREF(result); }
8265 Py_DECREF(obj);
8266 return returnValue;
8267 }
8268 }
8269 return genericBinaryFileWidget::sharedPainter();
8270 }
8271 void PythonQtShell_genericBinaryFileWidget::showEvent(QShowEvent* arg__1)
8272 {
8273 if (_wrapper) {
8274 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "showEvent");
8275 PyErr_Clear();
8276 if (obj && !PythonQtSlotFunction_Check(obj)) {
8277 static const char* argumentList[] ={"" , "QShowEvent*"};
8278 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8279 void* args[2] = {NULL, (void*)&arg__1};
8280 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8281 if (result) { Py_DECREF(result); }
8282 Py_DECREF(obj);
8283 return;
8284 }
8285 }
8286 genericBinaryFileWidget::showEvent(arg__1);
8287 }
8288 QSize PythonQtShell_genericBinaryFileWidget::sizeHint() const
8289 {
8290 if (_wrapper) {
8291 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getSizeHint");
8292 PyErr_Clear();
8293 if (obj && !PythonQtSlotFunction_Check(obj)) {
8294 static const char* argumentList[] ={"QSize"};
8295 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
8296 QSize returnValue;
8297 void* args[1] = {NULL};
8298 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8299 if (result) {
8300 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
8301 if (args[0]!=&returnValue) {
8302 if (args[0]==NULL) {
8303 PythonQt::priv()->handleVirtualOverloadReturnError("getSizeHint", methodInfo, result);
8304 } else {
8305 returnValue = *((QSize*)args[0]);
8306 }
8307 }
8308 }
8309 if (result) { Py_DECREF(result); }
8310 Py_DECREF(obj);
8311 return returnValue;
8312 }
8313 }
8314 return genericBinaryFileWidget::sizeHint();
8315 }
8316 void PythonQtShell_genericBinaryFileWidget::tabletEvent(QTabletEvent* arg__1)
8317 {
8318 if (_wrapper) {
8319 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "tabletEvent");
8320 PyErr_Clear();
8321 if (obj && !PythonQtSlotFunction_Check(obj)) {
8322 static const char* argumentList[] ={"" , "QTabletEvent*"};
8323 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8324 void* args[2] = {NULL, (void*)&arg__1};
8325 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8326 if (result) { Py_DECREF(result); }
8327 Py_DECREF(obj);
8328 return;
8329 }
8330 }
8331 genericBinaryFileWidget::tabletEvent(arg__1);
8332 }
8333 void PythonQtShell_genericBinaryFileWidget::timerEvent(QTimerEvent* arg__1)
8334 {
8335 if (_wrapper) {
8336 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "timerEvent");
8337 PyErr_Clear();
8338 if (obj && !PythonQtSlotFunction_Check(obj)) {
8339 static const char* argumentList[] ={"" , "QTimerEvent*"};
8340 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8341 void* args[2] = {NULL, (void*)&arg__1};
8342 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8343 if (result) { Py_DECREF(result); }
8344 Py_DECREF(obj);
8345 return;
8346 }
8347 }
8348 genericBinaryFileWidget::timerEvent(arg__1);
8349 }
8350 void PythonQtShell_genericBinaryFileWidget::wheelEvent(QWheelEvent* arg__1)
8351 {
8352 if (_wrapper) {
8353 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "wheelEvent");
8354 PyErr_Clear();
8355 if (obj && !PythonQtSlotFunction_Check(obj)) {
8356 static const char* argumentList[] ={"" , "QWheelEvent*"};
8357 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8358 void* args[2] = {NULL, (void*)&arg__1};
8359 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8360 if (result) { Py_DECREF(result); }
8361 Py_DECREF(obj);
8362 return;
8363 }
8364 }
8365 genericBinaryFileWidget::wheelEvent(arg__1);
8366 }
8367 genericBinaryFileWidget* PythonQtWrapper_genericBinaryFileWidget::new_genericBinaryFileWidget(QWidget* parent)
8368 {
8369 return new PythonQtShell_genericBinaryFileWidget(parent); }
8370
8371
8372
7460 PythonQtShell_srecFile::~PythonQtShell_srecFile() {
8373 PythonQtShell_srecFile::~PythonQtShell_srecFile() {
7461 PythonQtPrivate* priv = PythonQt::priv();
8374 PythonQtPrivate* priv = PythonQt::priv();
7462 if (priv) { priv->shellClassDeleted(this); }
8375 if (priv) { priv->shellClassDeleted(this); }
7463 }
8376 }
7464 int PythonQtShell_srecFile::closeFile()
8377 int PythonQtShell_srecFile::closeFile()
7465 {
8378 {
7466 if (_wrapper) {
8379 if (_wrapper) {
7467 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "closeFile");
8380 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "closeFile");
7468 PyErr_Clear();
8381 PyErr_Clear();
7469 if (obj && !PythonQtSlotFunction_Check(obj)) {
8382 if (obj && !PythonQtSlotFunction_Check(obj)) {
7470 static const char* argumentList[] ={"int"};
8383 static const char* argumentList[] ={"int"};
7471 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
8384 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
7472 int returnValue;
8385 int returnValue;
7473 void* args[1] = {NULL};
8386 void* args[1] = {NULL};
7474 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8387 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7475 if (result) {
8388 if (result) {
7476 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
8389 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
7477 if (args[0]!=&returnValue) {
8390 if (args[0]!=&returnValue) {
7478 if (args[0]==NULL) {
8391 if (args[0]==NULL) {
7479 PythonQt::priv()->handleVirtualOverloadReturnError("closeFile", methodInfo, result);
8392 PythonQt::priv()->handleVirtualOverloadReturnError("closeFile", methodInfo, result);
7480 } else {
8393 } else {
7481 returnValue = *((int*)args[0]);
8394 returnValue = *((int*)args[0]);
7482 }
8395 }
7483 }
8396 }
7484 }
8397 }
7485 if (result) { Py_DECREF(result); }
8398 if (result) { Py_DECREF(result); }
7486 Py_DECREF(obj);
8399 Py_DECREF(obj);
7487 return returnValue;
8400 return returnValue;
7488 }
8401 }
7489 }
8402 }
7490 return srecFile::closeFile();
8403 return srecFile::closeFile();
7491 }
8404 }
7492 QList<codeFragment* > PythonQtShell_srecFile::getFragments()
8405 QList<codeFragment* > PythonQtShell_srecFile::getFragments()
7493 {
8406 {
7494 if (_wrapper) {
8407 if (_wrapper) {
7495 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getFragments");
8408 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getFragments");
7496 PyErr_Clear();
8409 PyErr_Clear();
7497 if (obj && !PythonQtSlotFunction_Check(obj)) {
8410 if (obj && !PythonQtSlotFunction_Check(obj)) {
7498 static const char* argumentList[] ={"QList<codeFragment* >"};
8411 static const char* argumentList[] ={"QList<codeFragment* >"};
7499 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
8412 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
7500 QList<codeFragment* > returnValue;
8413 QList<codeFragment* > returnValue;
7501 void* args[1] = {NULL};
8414 void* args[1] = {NULL};
7502 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8415 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7503 if (result) {
8416 if (result) {
7504 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
8417 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
7505 if (args[0]!=&returnValue) {
8418 if (args[0]!=&returnValue) {
7506 if (args[0]==NULL) {
8419 if (args[0]==NULL) {
7507 PythonQt::priv()->handleVirtualOverloadReturnError("getFragments", methodInfo, result);
8420 PythonQt::priv()->handleVirtualOverloadReturnError("getFragments", methodInfo, result);
7508 } else {
8421 } else {
7509 returnValue = *((QList<codeFragment* >*)args[0]);
8422 returnValue = *((QList<codeFragment* >*)args[0]);
7510 }
8423 }
7511 }
8424 }
7512 }
8425 }
7513 if (result) { Py_DECREF(result); }
8426 if (result) { Py_DECREF(result); }
7514 Py_DECREF(obj);
8427 Py_DECREF(obj);
7515 return returnValue;
8428 return returnValue;
7516 }
8429 }
7517 }
8430 }
7518 return srecFile::getFragments();
8431 return srecFile::getFragments();
7519 }
8432 }
7520 bool PythonQtShell_srecFile::isopened()
8433 bool PythonQtShell_srecFile::isopened()
7521 {
8434 {
7522 if (_wrapper) {
8435 if (_wrapper) {
7523 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "isopened");
8436 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "isopened");
7524 PyErr_Clear();
8437 PyErr_Clear();
7525 if (obj && !PythonQtSlotFunction_Check(obj)) {
8438 if (obj && !PythonQtSlotFunction_Check(obj)) {
7526 static const char* argumentList[] ={"bool"};
8439 static const char* argumentList[] ={"bool"};
7527 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
8440 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
7528 bool returnValue;
8441 bool returnValue;
7529 void* args[1] = {NULL};
8442 void* args[1] = {NULL};
7530 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8443 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7531 if (result) {
8444 if (result) {
7532 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
8445 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
7533 if (args[0]!=&returnValue) {
8446 if (args[0]!=&returnValue) {
7534 if (args[0]==NULL) {
8447 if (args[0]==NULL) {
7535 PythonQt::priv()->handleVirtualOverloadReturnError("isopened", methodInfo, result);
8448 PythonQt::priv()->handleVirtualOverloadReturnError("isopened", methodInfo, result);
7536 } else {
8449 } else {
7537 returnValue = *((bool*)args[0]);
8450 returnValue = *((bool*)args[0]);
7538 }
8451 }
7539 }
8452 }
7540 }
8453 }
7541 if (result) { Py_DECREF(result); }
8454 if (result) { Py_DECREF(result); }
7542 Py_DECREF(obj);
8455 Py_DECREF(obj);
7543 return returnValue;
8456 return returnValue;
7544 }
8457 }
7545 }
8458 }
7546 return srecFile::isopened();
8459 return srecFile::isopened();
7547 }
8460 }
7548 bool PythonQtShell_srecFile::openFile(const QString& File)
8461 bool PythonQtShell_srecFile::openFile(const QString& File)
7549 {
8462 {
7550 if (_wrapper) {
8463 if (_wrapper) {
7551 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "openFile");
8464 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "openFile");
7552 PyErr_Clear();
8465 PyErr_Clear();
7553 if (obj && !PythonQtSlotFunction_Check(obj)) {
8466 if (obj && !PythonQtSlotFunction_Check(obj)) {
7554 static const char* argumentList[] ={"bool" , "const QString&"};
8467 static const char* argumentList[] ={"bool" , "const QString&"};
7555 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8468 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7556 bool returnValue;
8469 bool returnValue;
7557 void* args[2] = {NULL, (void*)&File};
8470 void* args[2] = {NULL, (void*)&File};
7558 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8471 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7559 if (result) {
8472 if (result) {
7560 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
8473 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
7561 if (args[0]!=&returnValue) {
8474 if (args[0]!=&returnValue) {
7562 if (args[0]==NULL) {
8475 if (args[0]==NULL) {
7563 PythonQt::priv()->handleVirtualOverloadReturnError("openFile", methodInfo, result);
8476 PythonQt::priv()->handleVirtualOverloadReturnError("openFile", methodInfo, result);
7564 } else {
8477 } else {
7565 returnValue = *((bool*)args[0]);
8478 returnValue = *((bool*)args[0]);
7566 }
8479 }
7567 }
8480 }
7568 }
8481 }
7569 if (result) { Py_DECREF(result); }
8482 if (result) { Py_DECREF(result); }
7570 Py_DECREF(obj);
8483 Py_DECREF(obj);
7571 return returnValue;
8484 return returnValue;
7572 }
8485 }
7573 }
8486 }
7574 return srecFile::openFile(File);
8487 return srecFile::openFile(File);
7575 }
8488 }
7576 bool PythonQtShell_srecFile::toBinary(const QString& File)
8489 bool PythonQtShell_srecFile::toBinary(const QString& File)
7577 {
8490 {
7578 if (_wrapper) {
8491 if (_wrapper) {
7579 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "toBinary");
8492 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "toBinary");
7580 PyErr_Clear();
8493 PyErr_Clear();
7581 if (obj && !PythonQtSlotFunction_Check(obj)) {
8494 if (obj && !PythonQtSlotFunction_Check(obj)) {
7582 static const char* argumentList[] ={"bool" , "const QString&"};
8495 static const char* argumentList[] ={"bool" , "const QString&"};
7583 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8496 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7584 bool returnValue;
8497 bool returnValue;
7585 void* args[2] = {NULL, (void*)&File};
8498 void* args[2] = {NULL, (void*)&File};
7586 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8499 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7587 if (result) {
8500 if (result) {
7588 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
8501 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
7589 if (args[0]!=&returnValue) {
8502 if (args[0]!=&returnValue) {
7590 if (args[0]==NULL) {
8503 if (args[0]==NULL) {
7591 PythonQt::priv()->handleVirtualOverloadReturnError("toBinary", methodInfo, result);
8504 PythonQt::priv()->handleVirtualOverloadReturnError("toBinary", methodInfo, result);
7592 } else {
8505 } else {
7593 returnValue = *((bool*)args[0]);
8506 returnValue = *((bool*)args[0]);
7594 }
8507 }
7595 }
8508 }
7596 }
8509 }
7597 if (result) { Py_DECREF(result); }
8510 if (result) { Py_DECREF(result); }
7598 Py_DECREF(obj);
8511 Py_DECREF(obj);
7599 return returnValue;
8512 return returnValue;
7600 }
8513 }
7601 }
8514 }
7602 return srecFile::toBinary(File);
8515 return srecFile::toBinary(File);
7603 }
8516 }
7604 bool PythonQtShell_srecFile::toSrec(const QString& File)
8517 bool PythonQtShell_srecFile::toSrec(const QString& File)
7605 {
8518 {
7606 if (_wrapper) {
8519 if (_wrapper) {
7607 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "toSrec");
8520 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "toSrec");
7608 PyErr_Clear();
8521 PyErr_Clear();
7609 if (obj && !PythonQtSlotFunction_Check(obj)) {
8522 if (obj && !PythonQtSlotFunction_Check(obj)) {
7610 static const char* argumentList[] ={"bool" , "const QString&"};
8523 static const char* argumentList[] ={"bool" , "const QString&"};
7611 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8524 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7612 bool returnValue;
8525 bool returnValue;
7613 void* args[2] = {NULL, (void*)&File};
8526 void* args[2] = {NULL, (void*)&File};
7614 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8527 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7615 if (result) {
8528 if (result) {
7616 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
8529 args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
7617 if (args[0]!=&returnValue) {
8530 if (args[0]!=&returnValue) {
7618 if (args[0]==NULL) {
8531 if (args[0]==NULL) {
7619 PythonQt::priv()->handleVirtualOverloadReturnError("toSrec", methodInfo, result);
8532 PythonQt::priv()->handleVirtualOverloadReturnError("toSrec", methodInfo, result);
7620 } else {
8533 } else {
7621 returnValue = *((bool*)args[0]);
8534 returnValue = *((bool*)args[0]);
7622 }
8535 }
7623 }
8536 }
7624 }
8537 }
7625 if (result) { Py_DECREF(result); }
8538 if (result) { Py_DECREF(result); }
7626 Py_DECREF(obj);
8539 Py_DECREF(obj);
7627 return returnValue;
8540 return returnValue;
7628 }
8541 }
7629 }
8542 }
7630 return srecFile::toSrec(File);
8543 return srecFile::toSrec(File);
7631 }
8544 }
7632 srecFile* PythonQtWrapper_srecFile::new_srecFile()
8545 srecFile* PythonQtWrapper_srecFile::new_srecFile()
7633 {
8546 {
7634 return new PythonQtShell_srecFile(); }
8547 return new PythonQtShell_srecFile(); }
7635
8548
7636 srecFile* PythonQtWrapper_srecFile::new_srecFile(const QString& File)
8549 srecFile* PythonQtWrapper_srecFile::new_srecFile(const QString& File)
7637 {
8550 {
7638 return new PythonQtShell_srecFile(File); }
8551 return new PythonQtShell_srecFile(File); }
7639
8552
7640 srecFile* PythonQtWrapper_srecFile::new_srecFile(const QStringList& Files)
8553 srecFile* PythonQtWrapper_srecFile::new_srecFile(const QStringList& Files)
7641 {
8554 {
7642 return new PythonQtShell_srecFile(Files); }
8555 return new PythonQtShell_srecFile(Files); }
7643
8556
8557 bool PythonQtWrapper_srecFile::static_srecFile_checkSum(const QString& line)
8558 {
8559 return (srecFile::checkSum(line));
8560 }
8561
7644 int PythonQtWrapper_srecFile::closeFile(srecFile* theWrappedObject)
8562 int PythonQtWrapper_srecFile::closeFile(srecFile* theWrappedObject)
7645 {
8563 {
7646 return ( ((PythonQtPublicPromoter_srecFile*)theWrappedObject)->promoted_closeFile());
8564 return ( ((PythonQtPublicPromoter_srecFile*)theWrappedObject)->promoted_closeFile());
7647 }
8565 }
7648
8566
7649 codeFragment* PythonQtWrapper_srecFile::getFragment(srecFile* theWrappedObject, int index)
8567 codeFragment* PythonQtWrapper_srecFile::getFragment(srecFile* theWrappedObject, int index)
7650 {
8568 {
7651 return ( theWrappedObject->getFragment(index));
8569 return ( theWrappedObject->getFragment(index));
7652 }
8570 }
7653
8571
7654 int PythonQtWrapper_srecFile::getFragmentAddress(srecFile* theWrappedObject, int index)
8572 int PythonQtWrapper_srecFile::getFragmentAddress(srecFile* theWrappedObject, int index)
7655 {
8573 {
7656 return ( theWrappedObject->getFragmentAddress(index));
8574 return ( theWrappedObject->getFragmentAddress(index));
7657 }
8575 }
7658
8576
7659 bool PythonQtWrapper_srecFile::getFragmentData(srecFile* theWrappedObject, int index, char** buffer)
8577 bool PythonQtWrapper_srecFile::getFragmentData(srecFile* theWrappedObject, int index, char** buffer)
7660 {
8578 {
7661 return ( theWrappedObject->getFragmentData(index, buffer));
8579 return ( theWrappedObject->getFragmentData(index, buffer));
7662 }
8580 }
7663
8581
7664 QString PythonQtWrapper_srecFile::getFragmentHeader(srecFile* theWrappedObject, int index)
8582 QString PythonQtWrapper_srecFile::getFragmentHeader(srecFile* theWrappedObject, int index)
7665 {
8583 {
7666 return ( theWrappedObject->getFragmentHeader(index));
8584 return ( theWrappedObject->getFragmentHeader(index));
7667 }
8585 }
7668
8586
7669 int PythonQtWrapper_srecFile::getFragmentSize(srecFile* theWrappedObject, int index)
8587 int PythonQtWrapper_srecFile::getFragmentSize(srecFile* theWrappedObject, int index)
7670 {
8588 {
7671 return ( theWrappedObject->getFragmentSize(index));
8589 return ( theWrappedObject->getFragmentSize(index));
7672 }
8590 }
7673
8591
7674 QList<codeFragment* > PythonQtWrapper_srecFile::getFragments(srecFile* theWrappedObject)
8592 QList<codeFragment* > PythonQtWrapper_srecFile::getFragments(srecFile* theWrappedObject)
7675 {
8593 {
7676 return ( ((PythonQtPublicPromoter_srecFile*)theWrappedObject)->promoted_getFragments());
8594 return ( ((PythonQtPublicPromoter_srecFile*)theWrappedObject)->promoted_getFragments());
7677 }
8595 }
7678
8596
7679 int PythonQtWrapper_srecFile::getFragmentsCount(srecFile* theWrappedObject)
8597 int PythonQtWrapper_srecFile::getFragmentsCount(srecFile* theWrappedObject)
7680 {
8598 {
7681 return ( theWrappedObject->getFragmentsCount());
8599 return ( theWrappedObject->getFragmentsCount());
7682 }
8600 }
7683
8601
7684 bool PythonQtWrapper_srecFile::isSREC(srecFile* theWrappedObject)
8602 bool PythonQtWrapper_srecFile::isSREC(srecFile* theWrappedObject)
7685 {
8603 {
7686 return ( theWrappedObject->isSREC());
8604 return ( theWrappedObject->isSREC());
7687 }
8605 }
7688
8606
7689 bool PythonQtWrapper_srecFile::static_srecFile_isSREC(const QString& File)
8607 bool PythonQtWrapper_srecFile::static_srecFile_isSREC(const QString& File)
7690 {
8608 {
7691 return (srecFile::isSREC(File));
8609 return (srecFile::isSREC(File));
7692 }
8610 }
7693
8611
7694 bool PythonQtWrapper_srecFile::isopened(srecFile* theWrappedObject)
8612 bool PythonQtWrapper_srecFile::isopened(srecFile* theWrappedObject)
7695 {
8613 {
7696 return ( ((PythonQtPublicPromoter_srecFile*)theWrappedObject)->promoted_isopened());
8614 return ( ((PythonQtPublicPromoter_srecFile*)theWrappedObject)->promoted_isopened());
7697 }
8615 }
7698
8616
7699 int PythonQtWrapper_srecFile::lineCount(srecFile* theWrappedObject)
8617 int PythonQtWrapper_srecFile::lineCount(srecFile* theWrappedObject)
7700 {
8618 {
7701 return ( theWrappedObject->lineCount());
8619 return ( theWrappedObject->lineCount());
7702 }
8620 }
7703
8621
7704 bool PythonQtWrapper_srecFile::mergingRecords(srecFile* theWrappedObject)
8622 bool PythonQtWrapper_srecFile::mergingRecords(srecFile* theWrappedObject)
7705 {
8623 {
7706 return ( theWrappedObject->mergingRecords());
8624 return ( theWrappedObject->mergingRecords());
7707 }
8625 }
7708
8626
7709 bool PythonQtWrapper_srecFile::openFile(srecFile* theWrappedObject, const QString& File)
8627 bool PythonQtWrapper_srecFile::openFile(srecFile* theWrappedObject, const QString& File)
7710 {
8628 {
7711 return ( ((PythonQtPublicPromoter_srecFile*)theWrappedObject)->promoted_openFile(File));
8629 return ( ((PythonQtPublicPromoter_srecFile*)theWrappedObject)->promoted_openFile(File));
7712 }
8630 }
7713
8631
7714 bool PythonQtWrapper_srecFile::openFiles(srecFile* theWrappedObject, const QStringList& Files)
8632 bool PythonQtWrapper_srecFile::openFiles(srecFile* theWrappedObject, const QStringList& Files)
7715 {
8633 {
7716 return ( theWrappedObject->openFiles(Files));
8634 return ( theWrappedObject->openFiles(Files));
7717 }
8635 }
7718
8636
7719 void PythonQtWrapper_srecFile::setMergingRecords(srecFile* theWrappedObject, bool enabled)
8637 void PythonQtWrapper_srecFile::setMergingRecords(srecFile* theWrappedObject, bool enabled)
7720 {
8638 {
7721 ( theWrappedObject->setMergingRecords(enabled));
8639 ( theWrappedObject->setMergingRecords(enabled));
7722 }
8640 }
7723
8641
7724 bool PythonQtWrapper_srecFile::toBinary(srecFile* theWrappedObject, const QString& File)
8642 bool PythonQtWrapper_srecFile::toBinary(srecFile* theWrappedObject, const QString& File)
7725 {
8643 {
7726 return ( ((PythonQtPublicPromoter_srecFile*)theWrappedObject)->promoted_toBinary(File));
8644 return ( ((PythonQtPublicPromoter_srecFile*)theWrappedObject)->promoted_toBinary(File));
7727 }
8645 }
7728
8646
7729 bool PythonQtWrapper_srecFile::static_srecFile_toSrec(QList<codeFragment* > fragments, const QString& File)
8647 bool PythonQtWrapper_srecFile::static_srecFile_toSrec(QList<codeFragment* > fragments, const QString& File)
7730 {
8648 {
7731 return (srecFile::toSrec(fragments, File));
8649 return (srecFile::toSrec(fragments, File));
7732 }
8650 }
7733
8651
7734 bool PythonQtWrapper_srecFile::toSrec(srecFile* theWrappedObject, const QString& File)
8652 bool PythonQtWrapper_srecFile::toSrec(srecFile* theWrappedObject, const QString& File)
7735 {
8653 {
7736 return ( ((PythonQtPublicPromoter_srecFile*)theWrappedObject)->promoted_toSrec(File));
8654 return ( ((PythonQtPublicPromoter_srecFile*)theWrappedObject)->promoted_toSrec(File));
7737 }
8655 }
7738
8656
7739
8657
7740
8658
7741 PythonQtShell_srecFileWidget::~PythonQtShell_srecFileWidget() {
8659 PythonQtShell_srecFileWidget::~PythonQtShell_srecFileWidget() {
7742 PythonQtPrivate* priv = PythonQt::priv();
8660 PythonQtPrivate* priv = PythonQt::priv();
7743 if (priv) { priv->shellClassDeleted(this); }
8661 if (priv) { priv->shellClassDeleted(this); }
7744 }
8662 }
7745 void PythonQtShell_srecFileWidget::reloadFile()
8663 void PythonQtShell_srecFileWidget::reloadFile()
7746 {
8664 {
7747 if (_wrapper) {
8665 if (_wrapper) {
7748 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "reloadFile");
8666 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "reloadFile");
7749 PyErr_Clear();
8667 PyErr_Clear();
7750 if (obj && !PythonQtSlotFunction_Check(obj)) {
8668 if (obj && !PythonQtSlotFunction_Check(obj)) {
7751 static const char* argumentList[] ={""};
8669 static const char* argumentList[] ={""};
7752 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
8670 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
7753 void* args[1] = {NULL};
8671 void* args[1] = {NULL};
7754 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8672 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7755 if (result) { Py_DECREF(result); }
8673 if (result) { Py_DECREF(result); }
7756 Py_DECREF(obj);
8674 Py_DECREF(obj);
7757 return;
8675 return;
7758 }
8676 }
7759 }
8677 }
7760 srecFileWidget::reloadFile();
8678 srecFileWidget::reloadFile();
7761 }
8679 }
7762 void PythonQtShell_srecFileWidget::setFile(abstractBinFile* file)
8680 void PythonQtShell_srecFileWidget::setFile(abstractBinFile* file)
7763 {
8681 {
7764 if (_wrapper) {
8682 if (_wrapper) {
7765 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "setFile");
8683 PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "setFile");
7766 PyErr_Clear();
8684 PyErr_Clear();
7767 if (obj && !PythonQtSlotFunction_Check(obj)) {
8685 if (obj && !PythonQtSlotFunction_Check(obj)) {
7768 static const char* argumentList[] ={"" , "abstractBinFile*"};
8686 static const char* argumentList[] ={"" , "abstractBinFile*"};
7769 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
8687 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
7770 void* args[2] = {NULL, (void*)&file};
8688 void* args[2] = {NULL, (void*)&file};
7771 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
8689 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
7772 if (result) { Py_DECREF(result); }
8690 if (result) { Py_DECREF(result); }
7773 Py_DECREF(obj);
8691 Py_DECREF(obj);
7774 return;
8692 return;
7775 }
8693 }
7776 }
8694 }
7777 srecFileWidget::setFile(file);
8695 srecFileWidget::setFile(file);
7778 }
8696 }
7779 srecFileWidget* PythonQtWrapper_srecFileWidget::new_srecFileWidget(QWidget* parent)
8697 srecFileWidget* PythonQtWrapper_srecFileWidget::new_srecFileWidget(QWidget* parent)
7780 {
8698 {
7781 return new PythonQtShell_srecFileWidget(parent); }
8699 return new PythonQtShell_srecFileWidget(parent); }
7782
8700
7783 void PythonQtWrapper_srecFileWidget::reloadFile(srecFileWidget* theWrappedObject)
8701 void PythonQtWrapper_srecFileWidget::reloadFile(srecFileWidget* theWrappedObject)
7784 {
8702 {
7785 ( ((PythonQtPublicPromoter_srecFileWidget*)theWrappedObject)->promoted_reloadFile());
8703 ( ((PythonQtPublicPromoter_srecFileWidget*)theWrappedObject)->promoted_reloadFile());
7786 }
8704 }
7787
8705
7788 void PythonQtWrapper_srecFileWidget::setFile(srecFileWidget* theWrappedObject, abstractBinFile* file)
8706 void PythonQtWrapper_srecFileWidget::setFile(srecFileWidget* theWrappedObject, abstractBinFile* file)
7789 {
8707 {
7790 ( ((PythonQtPublicPromoter_srecFileWidget*)theWrappedObject)->promoted_setFile(file));
8708 ( ((PythonQtPublicPromoter_srecFileWidget*)theWrappedObject)->promoted_setFile(file));
7791 }
8709 }
7792
8710
7793
8711
Show file before | Show file after | Hide comments
@@ -1,1021 +1,1090
1 #include <PythonQt.h>
1 #include <PythonQt.h>
2 #include <QIconEngine>
2 #include <QIconEngine>
3 #include <QObject>
3 #include <QObject>
4 #include <QSpinBox>
5 #include <QVariant>
4 #include <QVariant>
6 #include <QWidget>
7 #include <SocExplorerPlot.h>
5 #include <SocExplorerPlot.h>
8 #include <abstractbinfile.h>
6 #include <abstractbinfile.h>
9 #include <binaryfile.h>
7 #include <binaryfile.h>
10 #include <binaryfilewidget.h>
8 #include <binaryfilewidget.h>
11 #include <elffile.h>
9 #include <elffile.h>
12 #include <elffilewidget.h>
10 #include <elffilewidget.h>
13 #include <elfinfowdgt.h>
11 #include <elfinfowdgt.h>
14 #include <elfparser.h>
12 #include <elfparser.h>
13 #include <genericbinaryfilewidget.h>
15 #include <memsizewdgt.h>
14 #include <memsizewdgt.h>
16 #include <qaction.h>
15 #include <qaction.h>
17 #include <qbitmap.h>
16 #include <qbitmap.h>
18 #include <qbytearray.h>
17 #include <qbytearray.h>
19 #include <qcolor.h>
18 #include <qcolor.h>
20 #include <qcoreevent.h>
19 #include <qcoreevent.h>
21 #include <qcursor.h>
20 #include <qcursor.h>
22 #include <qevent.h>
21 #include <qevent.h>
23 #include <qfile.h>
22 #include <qfile.h>
24 #include <qfont.h>
23 #include <qfont.h>
25 #include <qgraphicseffect.h>
24 #include <qgraphicseffect.h>
26 #include <qgraphicsproxywidget.h>
25 #include <qgraphicsproxywidget.h>
27 #include <qhexedit.h>
26 #include <qhexedit.h>
28 #include <qhexspinbox.h>
27 #include <qhexspinbox.h>
29 #include <qkeysequence.h>
28 #include <qkeysequence.h>
30 #include <qlayout.h>
29 #include <qlayout.h>
31 #include <qlineedit.h>
30 #include <qlineedit.h>
32 #include <qlist.h>
31 #include <qlist.h>
33 #include <qlocale.h>
32 #include <qlocale.h>
34 #include <qmargins.h>
33 #include <qmargins.h>
35 #include <qobject.h>
34 #include <qobject.h>
36 #include <qpaintdevice.h>
35 #include <qpaintdevice.h>
37 #include <qpaintengine.h>
36 #include <qpaintengine.h>
38 #include <qpainter.h>
37 #include <qpainter.h>
39 #include <qpalette.h>
38 #include <qpalette.h>
40 #include <qpen.h>
39 #include <qpen.h>
41 #include <qpixmap.h>
40 #include <qpixmap.h>
42 #include <qpoint.h>
41 #include <qpoint.h>
43 #include <qrect.h>
42 #include <qrect.h>
44 #include <qregion.h>
43 #include <qregion.h>
45 #include <qscrollarea.h>
44 #include <qscrollarea.h>
46 #include <qscrollbar.h>
45 #include <qscrollbar.h>
47 #include <qsize.h>
46 #include <qsize.h>
48 #include <qsizepolicy.h>
47 #include <qsizepolicy.h>
49 #include <qspinbox.h>
48 #include <qspinbox.h>
50 #include <qstringlist.h>
49 #include <qstringlist.h>
51 #include <qstyle.h>
50 #include <qstyle.h>
52 #include <qstyleoption.h>
51 #include <qstyleoption.h>
53 #include <qwidget.h>
52 #include <qwidget.h>
54 #include <srecfile.h>
53 #include <srecfile.h>
55 #include <srecfilewidget.h>
54 #include <srecfilewidget.h>
56 #include <tcp_terminal_client.h>
55 #include <tcp_terminal_client.h>
57 #include <xbytearray.h>
56 #include <xbytearray.h>
58
57
59
58
60
59
61 class PythonQtShell_ElfFile : public ElfFile
60 class PythonQtShell_ElfFile : public ElfFile
62 {
61 {
63 public:
62 public:
64 PythonQtShell_ElfFile():ElfFile(),_wrapper(NULL) {};
63 PythonQtShell_ElfFile():ElfFile(),_wrapper(NULL) {};
65 PythonQtShell_ElfFile(const QString& File):ElfFile(File),_wrapper(NULL) {};
64 PythonQtShell_ElfFile(const QString& File):ElfFile(File),_wrapper(NULL) {};
66
65
67 ~PythonQtShell_ElfFile();
66 ~PythonQtShell_ElfFile();
68
67
69 virtual int closeFile();
68 virtual int closeFile();
70 virtual QList<codeFragment* > getFragments();
69 virtual QList<codeFragment* > getFragments();
71 virtual bool isopened();
70 virtual bool isopened();
72 virtual bool openFile(const QString& File);
71 virtual bool openFile(const QString& File);
73 virtual bool toBinary(const QString& File);
72 virtual bool toBinary(const QString& File);
74 virtual bool toSrec(const QString& File);
73 virtual bool toSrec(const QString& File);
75
74
76 PythonQtInstanceWrapper* _wrapper;
75 PythonQtInstanceWrapper* _wrapper;
77 };
76 };
78
77
79 class PythonQtPublicPromoter_ElfFile : public ElfFile
78 class PythonQtPublicPromoter_ElfFile : public ElfFile
80 { public:
79 { public:
81 inline int promoted_closeFile() { return ElfFile::closeFile(); }
80 inline int promoted_closeFile() { return ElfFile::closeFile(); }
82 inline QList<codeFragment* > promoted_getFragments() { return ElfFile::getFragments(); }
81 inline QList<codeFragment* > promoted_getFragments() { return ElfFile::getFragments(); }
83 inline bool promoted_isopened() { return ElfFile::isopened(); }
82 inline bool promoted_isopened() { return ElfFile::isopened(); }
84 inline bool promoted_openFile(const QString& File) { return ElfFile::openFile(File); }
83 inline bool promoted_openFile(const QString& File) { return ElfFile::openFile(File); }
85 inline bool promoted_toBinary(const QString& File) { return ElfFile::toBinary(File); }
84 inline bool promoted_toBinary(const QString& File) { return ElfFile::toBinary(File); }
86 inline bool promoted_toSrec(const QString& File) { return ElfFile::toSrec(File); }
85 inline bool promoted_toSrec(const QString& File) { return ElfFile::toSrec(File); }
87 };
86 };
88
87
89 class PythonQtWrapper_ElfFile : public QObject
88 class PythonQtWrapper_ElfFile : public QObject
90 { Q_OBJECT
89 { Q_OBJECT
91 public:
90 public:
92 public slots:
91 public slots:
93 ElfFile* new_ElfFile();
92 ElfFile* new_ElfFile();
94 ElfFile* new_ElfFile(const QString& File);
93 ElfFile* new_ElfFile(const QString& File);
95 void delete_ElfFile(ElfFile* obj) { delete obj; }
94 void delete_ElfFile(ElfFile* obj) { delete obj; }
96 int closeFile(ElfFile* theWrappedObject);
95 int closeFile(ElfFile* theWrappedObject);
97 QString getABI(ElfFile* theWrappedObject);
96 QString getABI(ElfFile* theWrappedObject);
98 QString getArchitecture(ElfFile* theWrappedObject);
97 QString getArchitecture(ElfFile* theWrappedObject);
99 QString getClass(ElfFile* theWrappedObject);
98 QString getClass(ElfFile* theWrappedObject);
100 QString getEndianness(ElfFile* theWrappedObject);
99 QString getEndianness(ElfFile* theWrappedObject);
101 qint64 getEntryPointAddress(ElfFile* theWrappedObject);
100 qint64 getEntryPointAddress(ElfFile* theWrappedObject);
102 QList<codeFragment* > getFragments(ElfFile* theWrappedObject);
101 QList<codeFragment* > getFragments(ElfFile* theWrappedObject);
103 QList<codeFragment* > getFragments(ElfFile* theWrappedObject, QStringList fragmentList);
102 QList<codeFragment* > getFragments(ElfFile* theWrappedObject, QStringList fragmentList);
104 int getSectionCount(ElfFile* theWrappedObject);
103 int getSectionCount(ElfFile* theWrappedObject);
105 bool getSectionData(ElfFile* theWrappedObject, int index, char** buffer);
104 bool getSectionData(ElfFile* theWrappedObject, int index, char** buffer);
106 qint64 getSectionDatasz(ElfFile* theWrappedObject, int index);
105 qint64 getSectionDatasz(ElfFile* theWrappedObject, int index);
107 int getSectionIndex(ElfFile* theWrappedObject, QString name);
106 int getSectionIndex(ElfFile* theWrappedObject, QString name);
108 qint64 getSectionMemsz(ElfFile* theWrappedObject, int index);
107 qint64 getSectionMemsz(ElfFile* theWrappedObject, int index);
109 QString getSectionName(ElfFile* theWrappedObject, int index);
108 QString getSectionName(ElfFile* theWrappedObject, int index);
110 qint64 getSectionPaddr(ElfFile* theWrappedObject, int index);
109 qint64 getSectionPaddr(ElfFile* theWrappedObject, int index);
111 QString getSectionType(ElfFile* theWrappedObject, int index);
110 QString getSectionType(ElfFile* theWrappedObject, int index);
112 int getSegmentCount(ElfFile* theWrappedObject);
111 int getSegmentCount(ElfFile* theWrappedObject);
113 qint64 getSegmentFilesz(ElfFile* theWrappedObject, int index);
112 qint64 getSegmentFilesz(ElfFile* theWrappedObject, int index);
114 QString getSegmentFlags(ElfFile* theWrappedObject, int index);
113 QString getSegmentFlags(ElfFile* theWrappedObject, int index);
115 qint64 getSegmentMemsz(ElfFile* theWrappedObject, int index);
114 qint64 getSegmentMemsz(ElfFile* theWrappedObject, int index);
116 qint64 getSegmentOffset(ElfFile* theWrappedObject, int index);
115 qint64 getSegmentOffset(ElfFile* theWrappedObject, int index);
117 qint64 getSegmentPaddr(ElfFile* theWrappedObject, int index);
116 qint64 getSegmentPaddr(ElfFile* theWrappedObject, int index);
118 QString getSegmentType(ElfFile* theWrappedObject, int index);
117 QString getSegmentType(ElfFile* theWrappedObject, int index);
119 qint64 getSegmentVaddr(ElfFile* theWrappedObject, int index);
118 qint64 getSegmentVaddr(ElfFile* theWrappedObject, int index);
120 quint64 getSymbolAddress(ElfFile* theWrappedObject, int index);
119 quint64 getSymbolAddress(ElfFile* theWrappedObject, int index);
121 int getSymbolCount(ElfFile* theWrappedObject);
120 int getSymbolCount(ElfFile* theWrappedObject);
122 QString getSymbolLinkType(ElfFile* theWrappedObject, int index);
121 QString getSymbolLinkType(ElfFile* theWrappedObject, int index);
123 QString getSymbolName(ElfFile* theWrappedObject, int index);
122 QString getSymbolName(ElfFile* theWrappedObject, int index);
124 int getSymbolSectionIndex(ElfFile* theWrappedObject, int index);
123 int getSymbolSectionIndex(ElfFile* theWrappedObject, int index);
125 QString getSymbolSectionName(ElfFile* theWrappedObject, int index);
124 QString getSymbolSectionName(ElfFile* theWrappedObject, int index);
126 quint64 getSymbolSize(ElfFile* theWrappedObject, int index);
125 quint64 getSymbolSize(ElfFile* theWrappedObject, int index);
127 QString getSymbolType(ElfFile* theWrappedObject, int index);
126 QString getSymbolType(ElfFile* theWrappedObject, int index);
128 QString getType(ElfFile* theWrappedObject);
127 QString getType(ElfFile* theWrappedObject);
129 qint64 getVersion(ElfFile* theWrappedObject);
128 qint64 getVersion(ElfFile* theWrappedObject);
130 bool static_ElfFile_isElf(const QString& File);
129 bool static_ElfFile_isElf(const QString& File);
131 bool iself(ElfFile* theWrappedObject);
130 bool iself(ElfFile* theWrappedObject);
132 bool isopened(ElfFile* theWrappedObject);
131 bool isopened(ElfFile* theWrappedObject);
133 bool openFile(ElfFile* theWrappedObject, const QString& File);
132 bool openFile(ElfFile* theWrappedObject, const QString& File);
134 bool sectionIsNobits(ElfFile* theWrappedObject, int index);
133 bool sectionIsNobits(ElfFile* theWrappedObject, int index);
135 bool toBinary(ElfFile* theWrappedObject, const QString& File);
134 bool toBinary(ElfFile* theWrappedObject, const QString& File);
136 bool toSrec(ElfFile* theWrappedObject, const QString& File);
135 bool toSrec(ElfFile* theWrappedObject, const QString& File);
137 };
136 };
138
137
139
138
140
139
141
140
142
141
143 class PythonQtShell_MemSizeWdgt : public MemSizeWdgt
142 class PythonQtShell_MemSizeWdgt : public MemSizeWdgt
144 {
143 {
145 public:
144 public:
146 PythonQtShell_MemSizeWdgt(QWidget* parent = 0):MemSizeWdgt(parent),_wrapper(NULL) {};
145 PythonQtShell_MemSizeWdgt(QWidget* parent = 0):MemSizeWdgt(parent),_wrapper(NULL) {};
147 PythonQtShell_MemSizeWdgt(int defaultSize, QWidget* parent = 0):MemSizeWdgt(defaultSize, parent),_wrapper(NULL) {};
146 PythonQtShell_MemSizeWdgt(int defaultSize, QWidget* parent = 0):MemSizeWdgt(defaultSize, parent),_wrapper(NULL) {};
148
147
149 ~PythonQtShell_MemSizeWdgt();
148 ~PythonQtShell_MemSizeWdgt();
150
149
151 virtual void actionEvent(QActionEvent* arg__1);
150 virtual void actionEvent(QActionEvent* arg__1);
152 virtual void changeEvent(QEvent* arg__1);
151 virtual void changeEvent(QEvent* arg__1);
153 virtual void childEvent(QChildEvent* arg__1);
152 virtual void childEvent(QChildEvent* arg__1);
154 virtual void closeEvent(QCloseEvent* arg__1);
153 virtual void closeEvent(QCloseEvent* arg__1);
155 virtual void contextMenuEvent(QContextMenuEvent* arg__1);
154 virtual void contextMenuEvent(QContextMenuEvent* arg__1);
156 virtual void customEvent(QEvent* arg__1);
155 virtual void customEvent(QEvent* arg__1);
157 virtual int devType() const;
156 virtual int devType() const;
158 virtual void dragEnterEvent(QDragEnterEvent* arg__1);
157 virtual void dragEnterEvent(QDragEnterEvent* arg__1);
159 virtual void dragLeaveEvent(QDragLeaveEvent* arg__1);
158 virtual void dragLeaveEvent(QDragLeaveEvent* arg__1);
160 virtual void dragMoveEvent(QDragMoveEvent* arg__1);
159 virtual void dragMoveEvent(QDragMoveEvent* arg__1);
161 virtual void dropEvent(QDropEvent* arg__1);
160 virtual void dropEvent(QDropEvent* arg__1);
162 virtual void enterEvent(QEvent* arg__1);
161 virtual void enterEvent(QEvent* arg__1);
163 virtual bool event(QEvent* arg__1);
162 virtual bool event(QEvent* arg__1);
164 virtual bool eventFilter(QObject* arg__1, QEvent* arg__2);
163 virtual bool eventFilter(QObject* arg__1, QEvent* arg__2);
165 virtual void focusInEvent(QFocusEvent* arg__1);
164 virtual void focusInEvent(QFocusEvent* arg__1);
166 virtual bool focusNextPrevChild(bool next);
165 virtual bool focusNextPrevChild(bool next);
167 virtual void focusOutEvent(QFocusEvent* arg__1);
166 virtual void focusOutEvent(QFocusEvent* arg__1);
168 virtual bool hasHeightForWidth() const;
167 virtual bool hasHeightForWidth() const;
169 virtual int heightForWidth(int arg__1) const;
168 virtual int heightForWidth(int arg__1) const;
170 virtual void hideEvent(QHideEvent* arg__1);
169 virtual void hideEvent(QHideEvent* arg__1);
171 virtual void initPainter(QPainter* painter) const;
170 virtual void initPainter(QPainter* painter) const;
172 virtual void inputMethodEvent(QInputMethodEvent* arg__1);
171 virtual void inputMethodEvent(QInputMethodEvent* arg__1);
173 virtual QVariant inputMethodQuery(Qt::InputMethodQuery arg__1) const;
172 virtual QVariant inputMethodQuery(Qt::InputMethodQuery arg__1) const;
174 virtual void keyPressEvent(QKeyEvent* arg__1);
173 virtual void keyPressEvent(QKeyEvent* arg__1);
175 virtual void keyReleaseEvent(QKeyEvent* arg__1);
174 virtual void keyReleaseEvent(QKeyEvent* arg__1);
176 virtual void leaveEvent(QEvent* arg__1);
175 virtual void leaveEvent(QEvent* arg__1);
177 virtual int metric(QPaintDevice::PaintDeviceMetric arg__1) const;
176 virtual int metric(QPaintDevice::PaintDeviceMetric arg__1) const;
178 virtual QSize minimumSizeHint() const;
177 virtual QSize minimumSizeHint() const;
179 virtual void mouseDoubleClickEvent(QMouseEvent* arg__1);
178 virtual void mouseDoubleClickEvent(QMouseEvent* arg__1);
180 virtual void mouseMoveEvent(QMouseEvent* arg__1);
179 virtual void mouseMoveEvent(QMouseEvent* arg__1);
181 virtual void mousePressEvent(QMouseEvent* arg__1);
180 virtual void mousePressEvent(QMouseEvent* arg__1);
182 virtual void mouseReleaseEvent(QMouseEvent* arg__1);
181 virtual void mouseReleaseEvent(QMouseEvent* arg__1);
183 virtual void moveEvent(QMoveEvent* arg__1);
182 virtual void moveEvent(QMoveEvent* arg__1);
184 virtual bool nativeEvent(const QByteArray& eventType, void* message, long* result);
183 virtual bool nativeEvent(const QByteArray& eventType, void* message, long* result);
185 virtual QPaintEngine* paintEngine() const;
184 virtual QPaintEngine* paintEngine() const;
186 virtual void paintEvent(QPaintEvent* arg__1);
185 virtual void paintEvent(QPaintEvent* arg__1);
187 virtual QPaintDevice* redirected(QPoint* offset) const;
186 virtual QPaintDevice* redirected(QPoint* offset) const;
188 virtual void resizeEvent(QResizeEvent* arg__1);
187 virtual void resizeEvent(QResizeEvent* arg__1);
189 virtual QPainter* sharedPainter() const;
188 virtual QPainter* sharedPainter() const;
190 virtual void showEvent(QShowEvent* arg__1);
189 virtual void showEvent(QShowEvent* arg__1);
191 virtual QSize sizeHint() const;
190 virtual QSize sizeHint() const;
192 virtual void tabletEvent(QTabletEvent* arg__1);
191 virtual void tabletEvent(QTabletEvent* arg__1);
193 virtual void timerEvent(QTimerEvent* arg__1);
192 virtual void timerEvent(QTimerEvent* arg__1);
194 virtual void wheelEvent(QWheelEvent* arg__1);
193 virtual void wheelEvent(QWheelEvent* arg__1);
195
194
196 PythonQtInstanceWrapper* _wrapper;
195 PythonQtInstanceWrapper* _wrapper;
197 };
196 };
198
197
199 class PythonQtWrapper_MemSizeWdgt : public QObject
198 class PythonQtWrapper_MemSizeWdgt : public QObject
200 { Q_OBJECT
199 { Q_OBJECT
201 public:
200 public:
202 public slots:
201 public slots:
203 MemSizeWdgt* new_MemSizeWdgt(QWidget* parent = 0);
202 MemSizeWdgt* new_MemSizeWdgt(QWidget* parent = 0);
204 MemSizeWdgt* new_MemSizeWdgt(int defaultSize, QWidget* parent = 0);
203 MemSizeWdgt* new_MemSizeWdgt(int defaultSize, QWidget* parent = 0);
205 void delete_MemSizeWdgt(MemSizeWdgt* obj) { delete obj; }
204 void delete_MemSizeWdgt(MemSizeWdgt* obj) { delete obj; }
206 int getsize(MemSizeWdgt* theWrappedObject);
205 int getsize(MemSizeWdgt* theWrappedObject);
207 void setMaximum(MemSizeWdgt* theWrappedObject, unsigned int max);
206 void setMaximum(MemSizeWdgt* theWrappedObject, unsigned int max);
208 void show(MemSizeWdgt* theWrappedObject);
207 void show(MemSizeWdgt* theWrappedObject);
209 void updateSizeValue(MemSizeWdgt* theWrappedObject);
208 void updateSizeValue(MemSizeWdgt* theWrappedObject);
210 };
209 };
211
210
212
211
213
212
214
213
215
214
216 class PythonQtShell_QHexEdit : public QHexEdit
215 class PythonQtShell_QHexEdit : public QHexEdit
217 {
216 {
218 public:
217 public:
219 PythonQtShell_QHexEdit(QWidget* parent = 0):QHexEdit(parent),_wrapper(NULL) {};
218 PythonQtShell_QHexEdit(QWidget* parent = 0):QHexEdit(parent),_wrapper(NULL) {};
220
219
221 ~PythonQtShell_QHexEdit();
220 ~PythonQtShell_QHexEdit();
222
221
223 virtual void actionEvent(QActionEvent* arg__1);
222 virtual void actionEvent(QActionEvent* arg__1);
224 virtual void changeEvent(QEvent* arg__1);
223 virtual void changeEvent(QEvent* arg__1);
225 virtual void childEvent(QChildEvent* arg__1);
224 virtual void childEvent(QChildEvent* arg__1);
226 virtual void closeEvent(QCloseEvent* arg__1);
225 virtual void closeEvent(QCloseEvent* arg__1);
227 virtual void contextMenuEvent(QContextMenuEvent* arg__1);
226 virtual void contextMenuEvent(QContextMenuEvent* arg__1);
228 virtual void customEvent(QEvent* arg__1);
227 virtual void customEvent(QEvent* arg__1);
229 virtual int devType() const;
228 virtual int devType() const;
230 virtual void dragEnterEvent(QDragEnterEvent* arg__1);
229 virtual void dragEnterEvent(QDragEnterEvent* arg__1);
231 virtual void dragLeaveEvent(QDragLeaveEvent* arg__1);
230 virtual void dragLeaveEvent(QDragLeaveEvent* arg__1);
232 virtual void dragMoveEvent(QDragMoveEvent* arg__1);
231 virtual void dragMoveEvent(QDragMoveEvent* arg__1);
233 virtual void dropEvent(QDropEvent* arg__1);
232 virtual void dropEvent(QDropEvent* arg__1);
234 virtual void enterEvent(QEvent* arg__1);
233 virtual void enterEvent(QEvent* arg__1);
235 virtual bool event(QEvent* arg__1);
234 virtual bool event(QEvent* arg__1);
236 virtual bool eventFilter(QObject* arg__1, QEvent* arg__2);
235 virtual bool eventFilter(QObject* arg__1, QEvent* arg__2);
237 virtual void focusInEvent(QFocusEvent* arg__1);
236 virtual void focusInEvent(QFocusEvent* arg__1);
238 virtual bool focusNextPrevChild(bool next);
237 virtual bool focusNextPrevChild(bool next);
239 virtual void focusOutEvent(QFocusEvent* arg__1);
238 virtual void focusOutEvent(QFocusEvent* arg__1);
240 virtual bool hasHeightForWidth() const;
239 virtual bool hasHeightForWidth() const;
241 virtual int heightForWidth(int arg__1) const;
240 virtual int heightForWidth(int arg__1) const;
242 virtual void hideEvent(QHideEvent* arg__1);
241 virtual void hideEvent(QHideEvent* arg__1);
243 virtual void initPainter(QPainter* painter) const;
242 virtual void initPainter(QPainter* painter) const;
244 virtual void inputMethodEvent(QInputMethodEvent* arg__1);
243 virtual void inputMethodEvent(QInputMethodEvent* arg__1);
245 virtual QVariant inputMethodQuery(Qt::InputMethodQuery arg__1) const;
244 virtual QVariant inputMethodQuery(Qt::InputMethodQuery arg__1) const;
246 virtual void keyPressEvent(QKeyEvent* arg__1);
245 virtual void keyPressEvent(QKeyEvent* arg__1);
247 virtual void keyReleaseEvent(QKeyEvent* arg__1);
246 virtual void keyReleaseEvent(QKeyEvent* arg__1);
248 virtual void leaveEvent(QEvent* arg__1);
247 virtual void leaveEvent(QEvent* arg__1);
249 virtual int metric(QPaintDevice::PaintDeviceMetric arg__1) const;
248 virtual int metric(QPaintDevice::PaintDeviceMetric arg__1) const;
250 virtual void mouseDoubleClickEvent(QMouseEvent* arg__1);
249 virtual void mouseDoubleClickEvent(QMouseEvent* arg__1);
251 virtual void mouseMoveEvent(QMouseEvent* arg__1);
250 virtual void mouseMoveEvent(QMouseEvent* arg__1);
252 virtual void mousePressEvent(QMouseEvent* arg__1);
251 virtual void mousePressEvent(QMouseEvent* arg__1);
253 virtual void mouseReleaseEvent(QMouseEvent* arg__1);
252 virtual void mouseReleaseEvent(QMouseEvent* arg__1);
254 virtual void moveEvent(QMoveEvent* arg__1);
253 virtual void moveEvent(QMoveEvent* arg__1);
255 virtual bool nativeEvent(const QByteArray& eventType, void* message, long* result);
254 virtual bool nativeEvent(const QByteArray& eventType, void* message, long* result);
256 virtual QPaintEngine* paintEngine() const;
255 virtual QPaintEngine* paintEngine() const;
257 virtual void paintEvent(QPaintEvent* arg__1);
256 virtual void paintEvent(QPaintEvent* arg__1);
258 virtual QPaintDevice* redirected(QPoint* offset) const;
257 virtual QPaintDevice* redirected(QPoint* offset) const;
259 virtual void resizeEvent(QResizeEvent* arg__1);
258 virtual void resizeEvent(QResizeEvent* arg__1);
260 virtual void scrollContentsBy(int dx, int dy);
259 virtual void scrollContentsBy(int dx, int dy);
261 virtual void setupViewport(QWidget* viewport);
260 virtual void setupViewport(QWidget* viewport);
262 virtual QPainter* sharedPainter() const;
261 virtual QPainter* sharedPainter() const;
263 virtual void showEvent(QShowEvent* arg__1);
262 virtual void showEvent(QShowEvent* arg__1);
264 virtual void tabletEvent(QTabletEvent* arg__1);
263 virtual void tabletEvent(QTabletEvent* arg__1);
265 virtual void timerEvent(QTimerEvent* arg__1);
264 virtual void timerEvent(QTimerEvent* arg__1);
266 virtual bool viewportEvent(QEvent* arg__1);
265 virtual bool viewportEvent(QEvent* arg__1);
267 virtual QSize viewportSizeHint() const;
266 virtual QSize viewportSizeHint() const;
268 virtual void wheelEvent(QWheelEvent* arg__1);
267 virtual void wheelEvent(QWheelEvent* arg__1);
269
268
270 PythonQtInstanceWrapper* _wrapper;
269 PythonQtInstanceWrapper* _wrapper;
271 };
270 };
272
271
273 class PythonQtWrapper_QHexEdit : public QObject
272 class PythonQtWrapper_QHexEdit : public QObject
274 { Q_OBJECT
273 { Q_OBJECT
275 public:
274 public:
276 public slots:
275 public slots:
277 QHexEdit* new_QHexEdit(QWidget* parent = 0);
276 QHexEdit* new_QHexEdit(QWidget* parent = 0);
278 void delete_QHexEdit(QHexEdit* obj) { delete obj; }
277 void delete_QHexEdit(QHexEdit* obj) { delete obj; }
279 QColor addressAreaColor(QHexEdit* theWrappedObject);
278 QColor addressAreaColor(QHexEdit* theWrappedObject);
280 int addressOffset(QHexEdit* theWrappedObject);
279 int addressOffset(QHexEdit* theWrappedObject);
281 int cursorPosition(QHexEdit* theWrappedObject);
280 int cursorPosition(QHexEdit* theWrappedObject);
282 QByteArray data(QHexEdit* theWrappedObject);
281 QByteArray data(QHexEdit* theWrappedObject);
283 const QFont* font(QHexEdit* theWrappedObject) const;
282 const QFont* font(QHexEdit* theWrappedObject) const;
284 int getSelectionBegin(QHexEdit* theWrappedObject);
283 int getSelectionBegin(QHexEdit* theWrappedObject);
285 int getSelectionEnd(QHexEdit* theWrappedObject);
284 int getSelectionEnd(QHexEdit* theWrappedObject);
286 QColor highlightingColor(QHexEdit* theWrappedObject);
285 QColor highlightingColor(QHexEdit* theWrappedObject);
287 int indexOf(QHexEdit* theWrappedObject, const QByteArray& ba, int from = 0) const;
286 int indexOf(QHexEdit* theWrappedObject, const QByteArray& ba, int from = 0) const;
288 void insert(QHexEdit* theWrappedObject, int i, char ch);
287 void insert(QHexEdit* theWrappedObject, int i, char ch);
289 void insert(QHexEdit* theWrappedObject, int i, const QByteArray& ba);
288 void insert(QHexEdit* theWrappedObject, int i, const QByteArray& ba);
290 bool isReadOnly(QHexEdit* theWrappedObject);
289 bool isReadOnly(QHexEdit* theWrappedObject);
291 int lastIndexOf(QHexEdit* theWrappedObject, const QByteArray& ba, int from = 0) const;
290 int lastIndexOf(QHexEdit* theWrappedObject, const QByteArray& ba, int from = 0) const;
292 bool overwriteMode(QHexEdit* theWrappedObject);
291 bool overwriteMode(QHexEdit* theWrappedObject);
293 void remove(QHexEdit* theWrappedObject, int pos, int len = 1);
292 void remove(QHexEdit* theWrappedObject, int pos, int len = 1);
294 void replace(QHexEdit* theWrappedObject, int pos, int len, const QByteArray& after);
293 void replace(QHexEdit* theWrappedObject, int pos, int len, const QByteArray& after);
295 void resetSelection(QHexEdit* theWrappedObject);
294 void resetSelection(QHexEdit* theWrappedObject);
296 void resetSelection(QHexEdit* theWrappedObject, int pos);
295 void resetSelection(QHexEdit* theWrappedObject, int pos);
297 QColor selectionColor(QHexEdit* theWrappedObject);
296 QColor selectionColor(QHexEdit* theWrappedObject);
298 QString selectionToReadableString(QHexEdit* theWrappedObject);
297 QString selectionToReadableString(QHexEdit* theWrappedObject);
299 void setAddressAreaColor(QHexEdit* theWrappedObject, const QColor& color);
298 void setAddressAreaColor(QHexEdit* theWrappedObject, const QColor& color);
300 void setAddressOffset(QHexEdit* theWrappedObject, int offset);
299 void setAddressOffset(QHexEdit* theWrappedObject, int offset);
301 void setCursorPosition(QHexEdit* theWrappedObject, int cusorPos);
300 void setCursorPosition(QHexEdit* theWrappedObject, int cusorPos);
302 void setData(QHexEdit* theWrappedObject, const QByteArray& data);
301 void setData(QHexEdit* theWrappedObject, const QByteArray& data);
303 void setFont(QHexEdit* theWrappedObject, const QFont& arg__1);
302 void setFont(QHexEdit* theWrappedObject, const QFont& arg__1);
304 void setHighlightingColor(QHexEdit* theWrappedObject, const QColor& color);
303 void setHighlightingColor(QHexEdit* theWrappedObject, const QColor& color);
305 void setOverwriteMode(QHexEdit* theWrappedObject, bool arg__1);
304 void setOverwriteMode(QHexEdit* theWrappedObject, bool arg__1);
306 void setReadOnly(QHexEdit* theWrappedObject, bool arg__1);
305 void setReadOnly(QHexEdit* theWrappedObject, bool arg__1);
307 void setSelection(QHexEdit* theWrappedObject, int pos);
306 void setSelection(QHexEdit* theWrappedObject, int pos);
308 void setSelectionColor(QHexEdit* theWrappedObject, const QColor& color);
307 void setSelectionColor(QHexEdit* theWrappedObject, const QColor& color);
309 QString toReadableString(QHexEdit* theWrappedObject);
308 QString toReadableString(QHexEdit* theWrappedObject);
310 };
309 };
311
310
312
311
313
312
314
313
315
314
316 class PythonQtShell_QHexSpinBox : public QHexSpinBox
315 class PythonQtShell_QHexSpinBox : public QHexSpinBox
317 {
316 {
318 public:
317 public:
319 PythonQtShell_QHexSpinBox(QWidget* parent = 0):QHexSpinBox(parent),_wrapper(NULL) {};
318 PythonQtShell_QHexSpinBox(QWidget* parent = 0):QHexSpinBox(parent),_wrapper(NULL) {};
320
319
321 ~PythonQtShell_QHexSpinBox();
320 ~PythonQtShell_QHexSpinBox();
322
321
323 virtual void actionEvent(QActionEvent* arg__1);
322 virtual void actionEvent(QActionEvent* arg__1);
324 virtual void changeEvent(QEvent* event);
323 virtual void changeEvent(QEvent* event);
325 virtual void childEvent(QChildEvent* arg__1);
324 virtual void childEvent(QChildEvent* arg__1);
326 virtual void clear();
325 virtual void clear();
327 virtual void closeEvent(QCloseEvent* event);
326 virtual void closeEvent(QCloseEvent* event);
328 virtual void contextMenuEvent(QContextMenuEvent* event);
327 virtual void contextMenuEvent(QContextMenuEvent* event);
329 virtual void customEvent(QEvent* arg__1);
328 virtual void customEvent(QEvent* arg__1);
330 virtual int devType() const;
329 virtual int devType() const;
331 virtual void dragEnterEvent(QDragEnterEvent* arg__1);
330 virtual void dragEnterEvent(QDragEnterEvent* arg__1);
332 virtual void dragLeaveEvent(QDragLeaveEvent* arg__1);
331 virtual void dragLeaveEvent(QDragLeaveEvent* arg__1);
333 virtual void dragMoveEvent(QDragMoveEvent* arg__1);
332 virtual void dragMoveEvent(QDragMoveEvent* arg__1);
334 virtual void dropEvent(QDropEvent* arg__1);
333 virtual void dropEvent(QDropEvent* arg__1);
335 virtual void enterEvent(QEvent* arg__1);
334 virtual void enterEvent(QEvent* arg__1);
336 virtual bool event(QEvent* event);
335 virtual bool event(QEvent* event);
337 virtual bool eventFilter(QObject* arg__1, QEvent* arg__2);
336 virtual bool eventFilter(QObject* arg__1, QEvent* arg__2);
338 virtual void fixup(QString& str) const;
337 virtual void fixup(QString& str) const;
339 virtual void focusInEvent(QFocusEvent* event);
338 virtual void focusInEvent(QFocusEvent* event);
340 virtual bool focusNextPrevChild(bool next);
339 virtual bool focusNextPrevChild(bool next);
341 virtual void focusOutEvent(QFocusEvent* event);
340 virtual void focusOutEvent(QFocusEvent* event);
342 virtual bool hasHeightForWidth() const;
341 virtual bool hasHeightForWidth() const;
343 virtual int heightForWidth(int arg__1) const;
342 virtual int heightForWidth(int arg__1) const;
344 virtual void hideEvent(QHideEvent* event);
343 virtual void hideEvent(QHideEvent* event);
345 virtual void initPainter(QPainter* painter) const;
344 virtual void initPainter(QPainter* painter) const;
346 virtual void inputMethodEvent(QInputMethodEvent* arg__1);
345 virtual void inputMethodEvent(QInputMethodEvent* arg__1);
347 virtual QVariant inputMethodQuery(Qt::InputMethodQuery arg__1) const;
346 virtual QVariant inputMethodQuery(Qt::InputMethodQuery arg__1) const;
348 virtual void keyPressEvent(QKeyEvent* event);
347 virtual void keyPressEvent(QKeyEvent* event);
349 virtual void keyReleaseEvent(QKeyEvent* event);
348 virtual void keyReleaseEvent(QKeyEvent* event);
350 virtual void leaveEvent(QEvent* arg__1);
349 virtual void leaveEvent(QEvent* arg__1);
351 virtual int metric(QPaintDevice::PaintDeviceMetric arg__1) const;
350 virtual int metric(QPaintDevice::PaintDeviceMetric arg__1) const;
352 virtual void mouseDoubleClickEvent(QMouseEvent* arg__1);
351 virtual void mouseDoubleClickEvent(QMouseEvent* arg__1);
353 virtual void mouseMoveEvent(QMouseEvent* event);
352 virtual void mouseMoveEvent(QMouseEvent* event);
354 virtual void mousePressEvent(QMouseEvent* event);
353 virtual void mousePressEvent(QMouseEvent* event);
355 virtual void mouseReleaseEvent(QMouseEvent* event);
354 virtual void mouseReleaseEvent(QMouseEvent* event);
356 virtual void moveEvent(QMoveEvent* arg__1);
355 virtual void moveEvent(QMoveEvent* arg__1);
357 virtual bool nativeEvent(const QByteArray& eventType, void* message, long* result);
356 virtual bool nativeEvent(const QByteArray& eventType, void* message, long* result);
358 virtual QPaintEngine* paintEngine() const;
357 virtual QPaintEngine* paintEngine() const;
359 virtual void paintEvent(QPaintEvent* event);
358 virtual void paintEvent(QPaintEvent* event);
360 virtual QPaintDevice* redirected(QPoint* offset) const;
359 virtual QPaintDevice* redirected(QPoint* offset) const;
361 virtual void resizeEvent(QResizeEvent* event);
360 virtual void resizeEvent(QResizeEvent* event);
362 virtual QPainter* sharedPainter() const;
361 virtual QPainter* sharedPainter() const;
363 virtual void showEvent(QShowEvent* event);
362 virtual void showEvent(QShowEvent* event);
364 virtual void stepBy(int steps);
363 virtual void stepBy(int steps);
365 virtual QAbstractSpinBox::StepEnabled stepEnabled() const;
364 virtual QAbstractSpinBox::StepEnabled stepEnabled() const;
366 virtual void tabletEvent(QTabletEvent* arg__1);
365 virtual void tabletEvent(QTabletEvent* arg__1);
367 virtual QString textFromValue(int value) const;
366 virtual QString textFromValue(int value) const;
368 virtual void timerEvent(QTimerEvent* event);
367 virtual void timerEvent(QTimerEvent* event);
369 virtual QValidator::State validate(QString& input, int& pos) const;
368 virtual QValidator::State validate(QString& input, int& pos) const;
370 virtual int valueFromText(const QString& text) const;
369 virtual int valueFromText(const QString& text) const;
371 virtual void wheelEvent(QWheelEvent* event);
370 virtual void wheelEvent(QWheelEvent* event);
372
371
373 PythonQtInstanceWrapper* _wrapper;
372 PythonQtInstanceWrapper* _wrapper;
374 };
373 };
375
374
376 class PythonQtPublicPromoter_QHexSpinBox : public QHexSpinBox
375 class PythonQtPublicPromoter_QHexSpinBox : public QHexSpinBox
377 { public:
376 { public:
378 inline QString promoted_textFromValue(int value) const { return QHexSpinBox::textFromValue(value); }
377 inline QString promoted_textFromValue(int value) const { return QHexSpinBox::textFromValue(value); }
379 inline QValidator::State promoted_validate(QString& input, int& pos) const { return QHexSpinBox::validate(input, pos); }
378 inline QValidator::State promoted_validate(QString& input, int& pos) const { return QHexSpinBox::validate(input, pos); }
380 inline int promoted_valueFromText(const QString& text) const { return QHexSpinBox::valueFromText(text); }
379 inline int promoted_valueFromText(const QString& text) const { return QHexSpinBox::valueFromText(text); }
381 };
380 };
382
381
383 class PythonQtWrapper_QHexSpinBox : public QObject
382 class PythonQtWrapper_QHexSpinBox : public QObject
384 { Q_OBJECT
383 { Q_OBJECT
385 public:
384 public:
386 public slots:
385 public slots:
387 QHexSpinBox* new_QHexSpinBox(QWidget* parent = 0);
386 QHexSpinBox* new_QHexSpinBox(QWidget* parent = 0);
388 void delete_QHexSpinBox(QHexSpinBox* obj) { delete obj; }
387 void delete_QHexSpinBox(QHexSpinBox* obj) { delete obj; }
389 void show(QHexSpinBox* theWrappedObject);
388 void show(QHexSpinBox* theWrappedObject);
390 QString textFromValue(QHexSpinBox* theWrappedObject, int value) const;
389 QString textFromValue(QHexSpinBox* theWrappedObject, int value) const;
391 QValidator::State validate(QHexSpinBox* theWrappedObject, QString& input, int& pos) const;
390 QValidator::State validate(QHexSpinBox* theWrappedObject, QString& input, int& pos) const;
392 int valueFromText(QHexSpinBox* theWrappedObject, const QString& text) const;
391 int valueFromText(QHexSpinBox* theWrappedObject, const QString& text) const;
393 };
392 };
394
393
395
394
396
395
397
396
398
397
399 class PythonQtShell_SocExplorerPlot : public SocExplorerPlot
398 class PythonQtShell_SocExplorerPlot : public SocExplorerPlot
400 {
399 {
401 public:
400 public:
402 PythonQtShell_SocExplorerPlot(QWidget* parent = 0):SocExplorerPlot(parent),_wrapper(NULL) {};
401 PythonQtShell_SocExplorerPlot(QWidget* parent = 0):SocExplorerPlot(parent),_wrapper(NULL) {};
403
402
404 ~PythonQtShell_SocExplorerPlot();
403 ~PythonQtShell_SocExplorerPlot();
405
404
406 virtual void actionEvent(QActionEvent* arg__1);
405 virtual void actionEvent(QActionEvent* arg__1);
407 virtual void changeEvent(QEvent* arg__1);
406 virtual void changeEvent(QEvent* arg__1);
408 virtual void childEvent(QChildEvent* arg__1);
407 virtual void childEvent(QChildEvent* arg__1);
409 virtual void closeEvent(QCloseEvent* arg__1);
408 virtual void closeEvent(QCloseEvent* arg__1);
410 virtual void contextMenuEvent(QContextMenuEvent* arg__1);
409 virtual void contextMenuEvent(QContextMenuEvent* arg__1);
411 virtual void customEvent(QEvent* arg__1);
410 virtual void customEvent(QEvent* arg__1);
412 virtual int devType() const;
411 virtual int devType() const;
413 virtual void dragEnterEvent(QDragEnterEvent* arg__1);
412 virtual void dragEnterEvent(QDragEnterEvent* arg__1);
414 virtual void dragLeaveEvent(QDragLeaveEvent* arg__1);
413 virtual void dragLeaveEvent(QDragLeaveEvent* arg__1);
415 virtual void dragMoveEvent(QDragMoveEvent* arg__1);
414 virtual void dragMoveEvent(QDragMoveEvent* arg__1);
416 virtual void dropEvent(QDropEvent* arg__1);
415 virtual void dropEvent(QDropEvent* arg__1);
417 virtual void enterEvent(QEvent* arg__1);
416 virtual void enterEvent(QEvent* arg__1);
418 virtual bool event(QEvent* arg__1);
417 virtual bool event(QEvent* arg__1);
419 virtual bool eventFilter(QObject* arg__1, QEvent* arg__2);
418 virtual bool eventFilter(QObject* arg__1, QEvent* arg__2);
420 virtual void focusInEvent(QFocusEvent* arg__1);
419 virtual void focusInEvent(QFocusEvent* arg__1);
421 virtual bool focusNextPrevChild(bool next);
420 virtual bool focusNextPrevChild(bool next);
422 virtual void focusOutEvent(QFocusEvent* arg__1);
421 virtual void focusOutEvent(QFocusEvent* arg__1);
423 virtual bool hasHeightForWidth() const;
422 virtual bool hasHeightForWidth() const;
424 virtual int heightForWidth(int arg__1) const;
423 virtual int heightForWidth(int arg__1) const;
425 virtual void hideEvent(QHideEvent* arg__1);
424 virtual void hideEvent(QHideEvent* arg__1);
426 virtual void initPainter(QPainter* painter) const;
425 virtual void initPainter(QPainter* painter) const;
427 virtual void inputMethodEvent(QInputMethodEvent* arg__1);
426 virtual void inputMethodEvent(QInputMethodEvent* arg__1);
428 virtual QVariant inputMethodQuery(Qt::InputMethodQuery arg__1) const;
427 virtual QVariant inputMethodQuery(Qt::InputMethodQuery arg__1) const;
429 virtual void keyPressEvent(QKeyEvent* arg__1);
428 virtual void keyPressEvent(QKeyEvent* arg__1);
430 virtual void keyReleaseEvent(QKeyEvent* arg__1);
429 virtual void keyReleaseEvent(QKeyEvent* arg__1);
431 virtual void leaveEvent(QEvent* arg__1);
430 virtual void leaveEvent(QEvent* arg__1);
432 virtual int metric(QPaintDevice::PaintDeviceMetric arg__1) const;
431 virtual int metric(QPaintDevice::PaintDeviceMetric arg__1) const;
433 virtual QSize minimumSizeHint() const;
432 virtual QSize minimumSizeHint() const;
434 virtual void mouseDoubleClickEvent(QMouseEvent* arg__1);
433 virtual void mouseDoubleClickEvent(QMouseEvent* arg__1);
435 virtual void mouseMoveEvent(QMouseEvent* arg__1);
434 virtual void mouseMoveEvent(QMouseEvent* arg__1);
436 virtual void mousePressEvent(QMouseEvent* arg__1);
435 virtual void mousePressEvent(QMouseEvent* arg__1);
437 virtual void mouseReleaseEvent(QMouseEvent* arg__1);
436 virtual void mouseReleaseEvent(QMouseEvent* arg__1);
438 virtual void moveEvent(QMoveEvent* arg__1);
437 virtual void moveEvent(QMoveEvent* arg__1);
439 virtual bool nativeEvent(const QByteArray& eventType, void* message, long* result);
438 virtual bool nativeEvent(const QByteArray& eventType, void* message, long* result);
440 virtual QPaintEngine* paintEngine() const;
439 virtual QPaintEngine* paintEngine() const;
441 virtual void paintEvent(QPaintEvent* arg__1);
440 virtual void paintEvent(QPaintEvent* arg__1);
442 virtual QPaintDevice* redirected(QPoint* offset) const;
441 virtual QPaintDevice* redirected(QPoint* offset) const;
443 virtual void resizeEvent(QResizeEvent* arg__1);
442 virtual void resizeEvent(QResizeEvent* arg__1);
444 virtual QPainter* sharedPainter() const;
443 virtual QPainter* sharedPainter() const;
445 virtual void showEvent(QShowEvent* arg__1);
444 virtual void showEvent(QShowEvent* arg__1);
446 virtual QSize sizeHint() const;
445 virtual QSize sizeHint() const;
447 virtual void tabletEvent(QTabletEvent* arg__1);
446 virtual void tabletEvent(QTabletEvent* arg__1);
448 virtual void timerEvent(QTimerEvent* arg__1);
447 virtual void timerEvent(QTimerEvent* arg__1);
449 virtual void wheelEvent(QWheelEvent* arg__1);
448 virtual void wheelEvent(QWheelEvent* arg__1);
450
449
451 PythonQtInstanceWrapper* _wrapper;
450 PythonQtInstanceWrapper* _wrapper;
452 };
451 };
453
452
454 class PythonQtPublicPromoter_SocExplorerPlot : public SocExplorerPlot
453 class PythonQtPublicPromoter_SocExplorerPlot : public SocExplorerPlot
455 { public:
454 { public:
456 inline void promoted_keyPressEvent(QKeyEvent* arg__1) { SocExplorerPlot::keyPressEvent(arg__1); }
455 inline void promoted_keyPressEvent(QKeyEvent* arg__1) { SocExplorerPlot::keyPressEvent(arg__1); }
457 inline void promoted_keyReleaseEvent(QKeyEvent* arg__1) { SocExplorerPlot::keyReleaseEvent(arg__1); }
456 inline void promoted_keyReleaseEvent(QKeyEvent* arg__1) { SocExplorerPlot::keyReleaseEvent(arg__1); }
458 inline void promoted_mouseMoveEvent(QMouseEvent* arg__1) { SocExplorerPlot::mouseMoveEvent(arg__1); }
457 inline void promoted_mouseMoveEvent(QMouseEvent* arg__1) { SocExplorerPlot::mouseMoveEvent(arg__1); }
459 inline void promoted_mousePressEvent(QMouseEvent* arg__1) { SocExplorerPlot::mousePressEvent(arg__1); }
458 inline void promoted_mousePressEvent(QMouseEvent* arg__1) { SocExplorerPlot::mousePressEvent(arg__1); }
460 inline void promoted_mouseReleaseEvent(QMouseEvent* arg__1) { SocExplorerPlot::mouseReleaseEvent(arg__1); }
459 inline void promoted_mouseReleaseEvent(QMouseEvent* arg__1) { SocExplorerPlot::mouseReleaseEvent(arg__1); }
461 inline void promoted_wheelEvent(QWheelEvent* arg__1) { SocExplorerPlot::wheelEvent(arg__1); }
460 inline void promoted_wheelEvent(QWheelEvent* arg__1) { SocExplorerPlot::wheelEvent(arg__1); }
462 };
461 };
463
462
464 class PythonQtWrapper_SocExplorerPlot : public QObject
463 class PythonQtWrapper_SocExplorerPlot : public QObject
465 { Q_OBJECT
464 { Q_OBJECT
466 public:
465 public:
467 public slots:
466 public slots:
468 SocExplorerPlot* new_SocExplorerPlot(QWidget* parent = 0);
467 SocExplorerPlot* new_SocExplorerPlot(QWidget* parent = 0);
469 void delete_SocExplorerPlot(SocExplorerPlot* obj) { delete obj; }
468 void delete_SocExplorerPlot(SocExplorerPlot* obj) { delete obj; }
470 int addGraph(SocExplorerPlot* theWrappedObject);
469 int addGraph(SocExplorerPlot* theWrappedObject);
471 void addGraphData(SocExplorerPlot* theWrappedObject, int graphIndex, QList<QVariant > x, QList<QVariant > y);
470 void addGraphData(SocExplorerPlot* theWrappedObject, int graphIndex, QList<QVariant > x, QList<QVariant > y);
472 void addGraphData(SocExplorerPlot* theWrappedObject, int graphIndex, QVariant x, QVariant y);
471 void addGraphData(SocExplorerPlot* theWrappedObject, int graphIndex, QVariant x, QVariant y);
473 QPen getGraphPen(SocExplorerPlot* theWrappedObject, int graphIndex);
472 QPen getGraphPen(SocExplorerPlot* theWrappedObject, int graphIndex);
474 void keyPressEvent(SocExplorerPlot* theWrappedObject, QKeyEvent* arg__1);
473 void keyPressEvent(SocExplorerPlot* theWrappedObject, QKeyEvent* arg__1);
475 void keyReleaseEvent(SocExplorerPlot* theWrappedObject, QKeyEvent* arg__1);
474 void keyReleaseEvent(SocExplorerPlot* theWrappedObject, QKeyEvent* arg__1);
476 void mouseMoveEvent(SocExplorerPlot* theWrappedObject, QMouseEvent* arg__1);
475 void mouseMoveEvent(SocExplorerPlot* theWrappedObject, QMouseEvent* arg__1);
477 void mousePressEvent(SocExplorerPlot* theWrappedObject, QMouseEvent* arg__1);
476 void mousePressEvent(SocExplorerPlot* theWrappedObject, QMouseEvent* arg__1);
478 void mouseReleaseEvent(SocExplorerPlot* theWrappedObject, QMouseEvent* arg__1);
477 void mouseReleaseEvent(SocExplorerPlot* theWrappedObject, QMouseEvent* arg__1);
479 void rescaleAxis(SocExplorerPlot* theWrappedObject);
478 void rescaleAxis(SocExplorerPlot* theWrappedObject);
480 void setAdaptativeSampling(SocExplorerPlot* theWrappedObject, int graphIndex, bool enable);
479 void setAdaptativeSampling(SocExplorerPlot* theWrappedObject, int graphIndex, bool enable);
481 void setGraphData(SocExplorerPlot* theWrappedObject, int graphIndex, QList<QVariant > x, QList<QVariant > y);
480 void setGraphData(SocExplorerPlot* theWrappedObject, int graphIndex, QList<QVariant > x, QList<QVariant > y);
482 void setGraphLineStyle(SocExplorerPlot* theWrappedObject, int graphIndex, QString lineStyle);
481 void setGraphLineStyle(SocExplorerPlot* theWrappedObject, int graphIndex, QString lineStyle);
483 void setGraphName(SocExplorerPlot* theWrappedObject, int graphIndex, QString name);
482 void setGraphName(SocExplorerPlot* theWrappedObject, int graphIndex, QString name);
484 void setGraphPen(SocExplorerPlot* theWrappedObject, int graphIndex, QPen pen);
483 void setGraphPen(SocExplorerPlot* theWrappedObject, int graphIndex, QPen pen);
485 void setGraphScatterStyle(SocExplorerPlot* theWrappedObject, int graphIndex, QString scatterStyle);
484 void setGraphScatterStyle(SocExplorerPlot* theWrappedObject, int graphIndex, QString scatterStyle);
486 void setLegendFont(SocExplorerPlot* theWrappedObject, QFont font);
485 void setLegendFont(SocExplorerPlot* theWrappedObject, QFont font);
487 void setLegendSelectedFont(SocExplorerPlot* theWrappedObject, QFont font);
486 void setLegendSelectedFont(SocExplorerPlot* theWrappedObject, QFont font);
488 void setTitle(SocExplorerPlot* theWrappedObject, QString title);
487 void setTitle(SocExplorerPlot* theWrappedObject, QString title);
489 void setXaxisLabel(SocExplorerPlot* theWrappedObject, QString label);
488 void setXaxisLabel(SocExplorerPlot* theWrappedObject, QString label);
490 void setXaxisRange(SocExplorerPlot* theWrappedObject, double lower, double upper);
489 void setXaxisRange(SocExplorerPlot* theWrappedObject, double lower, double upper);
491 void setYaxisLabel(SocExplorerPlot* theWrappedObject, QString label);
490 void setYaxisLabel(SocExplorerPlot* theWrappedObject, QString label);
492 void setYaxisRange(SocExplorerPlot* theWrappedObject, double lower, double upper);
491 void setYaxisRange(SocExplorerPlot* theWrappedObject, double lower, double upper);
493 void show(SocExplorerPlot* theWrappedObject);
492 void show(SocExplorerPlot* theWrappedObject);
494 void wheelEvent(SocExplorerPlot* theWrappedObject, QWheelEvent* arg__1);
493 void wheelEvent(SocExplorerPlot* theWrappedObject, QWheelEvent* arg__1);
495 };
494 };
496
495
497
496
498
497
499
498
500
499
501 class PythonQtShell_TCP_Terminal_Client : public TCP_Terminal_Client
500 class PythonQtShell_TCP_Terminal_Client : public TCP_Terminal_Client
502 {
501 {
503 public:
502 public:
504 PythonQtShell_TCP_Terminal_Client(QObject* parent = 0):TCP_Terminal_Client(parent),_wrapper(NULL) {};
503 PythonQtShell_TCP_Terminal_Client(QObject* parent = 0):TCP_Terminal_Client(parent),_wrapper(NULL) {};
505
504
506 ~PythonQtShell_TCP_Terminal_Client();
505 ~PythonQtShell_TCP_Terminal_Client();
507
506
508 virtual void childEvent(QChildEvent* arg__1);
507 virtual void childEvent(QChildEvent* arg__1);
509 virtual void customEvent(QEvent* arg__1);
508 virtual void customEvent(QEvent* arg__1);
510 virtual bool event(QEvent* arg__1);
509 virtual bool event(QEvent* arg__1);
511 virtual bool eventFilter(QObject* arg__1, QEvent* arg__2);
510 virtual bool eventFilter(QObject* arg__1, QEvent* arg__2);
512 virtual void timerEvent(QTimerEvent* arg__1);
511 virtual void timerEvent(QTimerEvent* arg__1);
513
512
514 PythonQtInstanceWrapper* _wrapper;
513 PythonQtInstanceWrapper* _wrapper;
515 };
514 };
516
515
517 class PythonQtWrapper_TCP_Terminal_Client : public QObject
516 class PythonQtWrapper_TCP_Terminal_Client : public QObject
518 { Q_OBJECT
517 { Q_OBJECT
519 public:
518 public:
520 public slots:
519 public slots:
521 TCP_Terminal_Client* new_TCP_Terminal_Client(QObject* parent = 0);
520 TCP_Terminal_Client* new_TCP_Terminal_Client(QObject* parent = 0);
522 void delete_TCP_Terminal_Client(TCP_Terminal_Client* obj) { delete obj; }
521 void delete_TCP_Terminal_Client(TCP_Terminal_Client* obj) { delete obj; }
523 void connectToServer(TCP_Terminal_Client* theWrappedObject);
522 void connectToServer(TCP_Terminal_Client* theWrappedObject);
524 void connectToServer(TCP_Terminal_Client* theWrappedObject, const QString& IP, int port);
523 void connectToServer(TCP_Terminal_Client* theWrappedObject, const QString& IP, int port);
525 bool isConnected(TCP_Terminal_Client* theWrappedObject);
524 bool isConnected(TCP_Terminal_Client* theWrappedObject);
526 void sendText(TCP_Terminal_Client* theWrappedObject, const QString& text);
525 void sendText(TCP_Terminal_Client* theWrappedObject, const QString& text);
527 void startServer(TCP_Terminal_Client* theWrappedObject);
526 void startServer(TCP_Terminal_Client* theWrappedObject);
528 void startServer(TCP_Terminal_Client* theWrappedObject, int port);
527 void startServer(TCP_Terminal_Client* theWrappedObject, int port);
529 };
528 };
530
529
531
530
532
531
533
532
534
533
535 class PythonQtWrapper_XByteArray : public QObject
534 class PythonQtWrapper_XByteArray : public QObject
536 { Q_OBJECT
535 { Q_OBJECT
537 public:
536 public:
538 public slots:
537 public slots:
539 XByteArray* new_XByteArray();
538 XByteArray* new_XByteArray();
540 void delete_XByteArray(XByteArray* obj) { delete obj; }
539 void delete_XByteArray(XByteArray* obj) { delete obj; }
541 int addressOffset(XByteArray* theWrappedObject);
540 int addressOffset(XByteArray* theWrappedObject);
542 int addressWidth(XByteArray* theWrappedObject);
541 int addressWidth(XByteArray* theWrappedObject);
543 QChar asciiChar(XByteArray* theWrappedObject, int index);
542 QChar asciiChar(XByteArray* theWrappedObject, int index);
544 QByteArray* data(XByteArray* theWrappedObject);
543 QByteArray* data(XByteArray* theWrappedObject);
545 bool dataChanged(XByteArray* theWrappedObject, int i);
544 bool dataChanged(XByteArray* theWrappedObject, int i);
546 QByteArray dataChanged(XByteArray* theWrappedObject, int i, int len);
545 QByteArray dataChanged(XByteArray* theWrappedObject, int i, int len);
547 QByteArray* insert(XByteArray* theWrappedObject, int i, char ch);
546 QByteArray* insert(XByteArray* theWrappedObject, int i, char ch);
548 QByteArray* insert(XByteArray* theWrappedObject, int i, const QByteArray& ba);
547 QByteArray* insert(XByteArray* theWrappedObject, int i, const QByteArray& ba);
549 int realAddressNumbers(XByteArray* theWrappedObject);
548 int realAddressNumbers(XByteArray* theWrappedObject);
550 QByteArray* remove(XByteArray* theWrappedObject, int pos, int len);
549 QByteArray* remove(XByteArray* theWrappedObject, int pos, int len);
551 QByteArray* replace(XByteArray* theWrappedObject, int index, char ch);
550 QByteArray* replace(XByteArray* theWrappedObject, int index, char ch);
552 QByteArray* replace(XByteArray* theWrappedObject, int index, const QByteArray& ba);
551 QByteArray* replace(XByteArray* theWrappedObject, int index, const QByteArray& ba);
553 QByteArray* replace(XByteArray* theWrappedObject, int index, int length, const QByteArray& ba);
552 QByteArray* replace(XByteArray* theWrappedObject, int index, int length, const QByteArray& ba);
554 void setAddressOffset(XByteArray* theWrappedObject, int offset);
553 void setAddressOffset(XByteArray* theWrappedObject, int offset);
555 void setAddressWidth(XByteArray* theWrappedObject, int width);
554 void setAddressWidth(XByteArray* theWrappedObject, int width);
556 void setData(XByteArray* theWrappedObject, QByteArray data);
555 void setData(XByteArray* theWrappedObject, QByteArray data);
557 void setDataChanged(XByteArray* theWrappedObject, int i, bool state);
556 void setDataChanged(XByteArray* theWrappedObject, int i, bool state);
558 void setDataChanged(XByteArray* theWrappedObject, int i, const QByteArray& state);
557 void setDataChanged(XByteArray* theWrappedObject, int i, const QByteArray& state);
559 int size(XByteArray* theWrappedObject);
558 int size(XByteArray* theWrappedObject);
560 QString toRedableString(XByteArray* theWrappedObject, int start = 0, int end = -1);
559 QString toRedableString(XByteArray* theWrappedObject, int start = 0, int end = -1);
561 };
560 };
562
561
563
562
564
563
565
564
566
565
567 class PythonQtShell_abstractBinFile : public abstractBinFile
566 class PythonQtShell_abstractBinFile : public abstractBinFile
568 {
567 {
569 public:
568 public:
570 PythonQtShell_abstractBinFile():abstractBinFile(),_wrapper(NULL) {};
569 PythonQtShell_abstractBinFile():abstractBinFile(),_wrapper(NULL) {};
571
570
572 ~PythonQtShell_abstractBinFile();
571 ~PythonQtShell_abstractBinFile();
573
572
574 virtual void childEvent(QChildEvent* arg__1);
573 virtual void childEvent(QChildEvent* arg__1);
575 virtual int closeFile();
574 virtual int closeFile();
576 virtual void customEvent(QEvent* arg__1);
575 virtual void customEvent(QEvent* arg__1);
577 virtual bool event(QEvent* arg__1);
576 virtual bool event(QEvent* arg__1);
578 virtual bool eventFilter(QObject* arg__1, QEvent* arg__2);
577 virtual bool eventFilter(QObject* arg__1, QEvent* arg__2);
579 virtual QList<codeFragment* > getFragments();
578 virtual QList<codeFragment* > getFragments();
580 virtual bool isopened();
579 virtual bool isopened();
581 virtual bool openFile(const QString& File);
580 virtual bool openFile(const QString& File);
582 virtual void timerEvent(QTimerEvent* arg__1);
581 virtual void timerEvent(QTimerEvent* arg__1);
583 virtual bool toBinary(const QString& File);
582 virtual bool toBinary(const QString& File);
584 virtual bool toSrec(const QString& File);
583 virtual bool toSrec(const QString& File);
585
584
586 PythonQtInstanceWrapper* _wrapper;
585 PythonQtInstanceWrapper* _wrapper;
587 };
586 };
588
587
589 class PythonQtWrapper_abstractBinFile : public QObject
588 class PythonQtWrapper_abstractBinFile : public QObject
590 { Q_OBJECT
589 { Q_OBJECT
591 public:
590 public:
592 public slots:
591 public slots:
593 abstractBinFile* new_abstractBinFile();
592 abstractBinFile* new_abstractBinFile();
594 void delete_abstractBinFile(abstractBinFile* obj) { delete obj; }
593 void delete_abstractBinFile(abstractBinFile* obj) { delete obj; }
595 };
594 };
596
595
597
596
598
597
599
598
600
599
601 class PythonQtShell_abstractBinFileWidget : public abstractBinFileWidget
600 class PythonQtShell_abstractBinFileWidget : public abstractBinFileWidget
602 {
601 {
603 public:
602 public:
604 PythonQtShell_abstractBinFileWidget(QWidget* parent = 0):abstractBinFileWidget(parent),_wrapper(NULL) {};
603 PythonQtShell_abstractBinFileWidget(QWidget* parent = 0):abstractBinFileWidget(parent),_wrapper(NULL) {};
605
604
606 ~PythonQtShell_abstractBinFileWidget();
605 ~PythonQtShell_abstractBinFileWidget();
607
606
608 virtual void actionEvent(QActionEvent* arg__1);
607 virtual void actionEvent(QActionEvent* arg__1);
609 virtual void changeEvent(QEvent* arg__1);
608 virtual void changeEvent(QEvent* arg__1);
610 virtual void childEvent(QChildEvent* arg__1);
609 virtual void childEvent(QChildEvent* arg__1);
611 virtual void closeEvent(QCloseEvent* arg__1);
610 virtual void closeEvent(QCloseEvent* arg__1);
612 virtual void contextMenuEvent(QContextMenuEvent* arg__1);
611 virtual void contextMenuEvent(QContextMenuEvent* arg__1);
613 virtual void customEvent(QEvent* arg__1);
612 virtual void customEvent(QEvent* arg__1);
614 virtual int devType() const;
613 virtual int devType() const;
615 virtual void dragEnterEvent(QDragEnterEvent* arg__1);
614 virtual void dragEnterEvent(QDragEnterEvent* arg__1);
616 virtual void dragLeaveEvent(QDragLeaveEvent* arg__1);
615 virtual void dragLeaveEvent(QDragLeaveEvent* arg__1);
617 virtual void dragMoveEvent(QDragMoveEvent* arg__1);
616 virtual void dragMoveEvent(QDragMoveEvent* arg__1);
618 virtual void dropEvent(QDropEvent* arg__1);
617 virtual void dropEvent(QDropEvent* arg__1);
619 virtual void enterEvent(QEvent* arg__1);
618 virtual void enterEvent(QEvent* arg__1);
620 virtual bool event(QEvent* arg__1);
619 virtual bool event(QEvent* arg__1);
621 virtual bool eventFilter(QObject* arg__1, QEvent* arg__2);
620 virtual bool eventFilter(QObject* arg__1, QEvent* arg__2);
622 virtual void focusInEvent(QFocusEvent* arg__1);
621 virtual void focusInEvent(QFocusEvent* arg__1);
623 virtual bool focusNextPrevChild(bool next);
622 virtual bool focusNextPrevChild(bool next);
624 virtual void focusOutEvent(QFocusEvent* arg__1);
623 virtual void focusOutEvent(QFocusEvent* arg__1);
625 virtual bool hasHeightForWidth() const;
624 virtual bool hasHeightForWidth() const;
626 virtual int heightForWidth(int arg__1) const;
625 virtual int heightForWidth(int arg__1) const;
627 virtual void hideEvent(QHideEvent* arg__1);
626 virtual void hideEvent(QHideEvent* arg__1);
628 virtual void initPainter(QPainter* painter) const;
627 virtual void initPainter(QPainter* painter) const;
629 virtual void inputMethodEvent(QInputMethodEvent* arg__1);
628 virtual void inputMethodEvent(QInputMethodEvent* arg__1);
630 virtual QVariant inputMethodQuery(Qt::InputMethodQuery arg__1) const;
629 virtual QVariant inputMethodQuery(Qt::InputMethodQuery arg__1) const;
631 virtual void keyPressEvent(QKeyEvent* arg__1);
630 virtual void keyPressEvent(QKeyEvent* arg__1);
632 virtual void keyReleaseEvent(QKeyEvent* arg__1);
631 virtual void keyReleaseEvent(QKeyEvent* arg__1);
633 virtual void leaveEvent(QEvent* arg__1);
632 virtual void leaveEvent(QEvent* arg__1);
634 virtual int metric(QPaintDevice::PaintDeviceMetric arg__1) const;
633 virtual int metric(QPaintDevice::PaintDeviceMetric arg__1) const;
635 virtual QSize minimumSizeHint() const;
634 virtual QSize minimumSizeHint() const;
636 virtual void mouseDoubleClickEvent(QMouseEvent* arg__1);
635 virtual void mouseDoubleClickEvent(QMouseEvent* arg__1);
637 virtual void mouseMoveEvent(QMouseEvent* arg__1);
636 virtual void mouseMoveEvent(QMouseEvent* arg__1);
638 virtual void mousePressEvent(QMouseEvent* arg__1);
637 virtual void mousePressEvent(QMouseEvent* arg__1);
639 virtual void mouseReleaseEvent(QMouseEvent* arg__1);
638 virtual void mouseReleaseEvent(QMouseEvent* arg__1);
640 virtual void moveEvent(QMoveEvent* arg__1);
639 virtual void moveEvent(QMoveEvent* arg__1);
641 virtual bool nativeEvent(const QByteArray& eventType, void* message, long* result);
640 virtual bool nativeEvent(const QByteArray& eventType, void* message, long* result);
642 virtual QPaintEngine* paintEngine() const;
641 virtual QPaintEngine* paintEngine() const;
643 virtual void paintEvent(QPaintEvent* arg__1);
642 virtual void paintEvent(QPaintEvent* arg__1);
644 virtual QPaintDevice* redirected(QPoint* offset) const;
643 virtual QPaintDevice* redirected(QPoint* offset) const;
645 virtual void reloadFile();
644 virtual void reloadFile();
646 virtual void resizeEvent(QResizeEvent* arg__1);
645 virtual void resizeEvent(QResizeEvent* arg__1);
647 virtual void setFile(abstractBinFile* file);
646 virtual void setFile(abstractBinFile* file);
648 virtual QPainter* sharedPainter() const;
647 virtual QPainter* sharedPainter() const;
649 virtual void showEvent(QShowEvent* arg__1);
648 virtual void showEvent(QShowEvent* arg__1);
650 virtual QSize sizeHint() const;
649 virtual QSize sizeHint() const;
651 virtual void tabletEvent(QTabletEvent* arg__1);
650 virtual void tabletEvent(QTabletEvent* arg__1);
652 virtual void timerEvent(QTimerEvent* arg__1);
651 virtual void timerEvent(QTimerEvent* arg__1);
653 virtual void wheelEvent(QWheelEvent* arg__1);
652 virtual void wheelEvent(QWheelEvent* arg__1);
654
653
655 PythonQtInstanceWrapper* _wrapper;
654 PythonQtInstanceWrapper* _wrapper;
656 };
655 };
657
656
658 class PythonQtWrapper_abstractBinFileWidget : public QObject
657 class PythonQtWrapper_abstractBinFileWidget : public QObject
659 { Q_OBJECT
658 { Q_OBJECT
660 public:
659 public:
661 public slots:
660 public slots:
662 abstractBinFileWidget* new_abstractBinFileWidget(QWidget* parent = 0);
661 abstractBinFileWidget* new_abstractBinFileWidget(QWidget* parent = 0);
663 void delete_abstractBinFileWidget(abstractBinFileWidget* obj) { delete obj; }
662 void delete_abstractBinFileWidget(abstractBinFileWidget* obj) { delete obj; }
664 };
663 };
665
664
666
665
667
666
668
667
669
668
670 class PythonQtShell_binaryFile : public binaryFile
669 class PythonQtShell_binaryFile : public binaryFile
671 {
670 {
672 public:
671 public:
673 PythonQtShell_binaryFile():binaryFile(),_wrapper(NULL) {};
672 PythonQtShell_binaryFile():binaryFile(),_wrapper(NULL) {};
674 PythonQtShell_binaryFile(const QString& File):binaryFile(File),_wrapper(NULL) {};
673 PythonQtShell_binaryFile(const QString& File):binaryFile(File),_wrapper(NULL) {};
675 PythonQtShell_binaryFile(const QStringList& Files):binaryFile(Files),_wrapper(NULL) {};
674 PythonQtShell_binaryFile(const QStringList& Files):binaryFile(Files),_wrapper(NULL) {};
676
675
677 ~PythonQtShell_binaryFile();
676 ~PythonQtShell_binaryFile();
678
677
679 virtual int closeFile();
678 virtual int closeFile();
680 virtual QList<codeFragment* > getFragments();
679 virtual QList<codeFragment* > getFragments();
681 virtual bool isopened();
680 virtual bool isopened();
682 virtual bool openFile(const QString& File);
681 virtual bool openFile(const QString& File);
683 virtual bool toBinary(const QString& fileName);
682 virtual bool toBinary(const QString& fileName);
684 virtual bool toSrec(const QString& fileName);
683 virtual bool toSrec(const QString& fileName);
685
684
686 PythonQtInstanceWrapper* _wrapper;
685 PythonQtInstanceWrapper* _wrapper;
687 };
686 };
688
687
689 class PythonQtPublicPromoter_binaryFile : public binaryFile
688 class PythonQtPublicPromoter_binaryFile : public binaryFile
690 { public:
689 { public:
691 inline int promoted_closeFile() { return binaryFile::closeFile(); }
690 inline int promoted_closeFile() { return binaryFile::closeFile(); }
692 inline QList<codeFragment* > promoted_getFragments() { return binaryFile::getFragments(); }
691 inline QList<codeFragment* > promoted_getFragments() { return binaryFile::getFragments(); }
693 inline bool promoted_isopened() { return binaryFile::isopened(); }
692 inline bool promoted_isopened() { return binaryFile::isopened(); }
694 inline bool promoted_openFile(const QString& File) { return binaryFile::openFile(File); }
693 inline bool promoted_openFile(const QString& File) { return binaryFile::openFile(File); }
695 inline bool promoted_toBinary(const QString& fileName) { return binaryFile::toBinary(fileName); }
694 inline bool promoted_toBinary(const QString& fileName) { return binaryFile::toBinary(fileName); }
696 inline bool promoted_toSrec(const QString& fileName) { return binaryFile::toSrec(fileName); }
695 inline bool promoted_toSrec(const QString& fileName) { return binaryFile::toSrec(fileName); }
697 };
696 };
698
697
699 class PythonQtWrapper_binaryFile : public QObject
698 class PythonQtWrapper_binaryFile : public QObject
700 { Q_OBJECT
699 { Q_OBJECT
701 public:
700 public:
702 public slots:
701 public slots:
703 binaryFile* new_binaryFile();
702 binaryFile* new_binaryFile();
704 binaryFile* new_binaryFile(const QString& File);
703 binaryFile* new_binaryFile(const QString& File);
705 binaryFile* new_binaryFile(const QStringList& Files);
704 binaryFile* new_binaryFile(const QStringList& Files);
706 void delete_binaryFile(binaryFile* obj) { delete obj; }
705 void delete_binaryFile(binaryFile* obj) { delete obj; }
707 int closeFile(binaryFile* theWrappedObject);
706 int closeFile(binaryFile* theWrappedObject);
708 codeFragment* getFragment(binaryFile* theWrappedObject, int index);
707 codeFragment* getFragment(binaryFile* theWrappedObject, int index);
709 int getFragmentAddress(binaryFile* theWrappedObject, int index);
708 int getFragmentAddress(binaryFile* theWrappedObject, int index);
710 bool getFragmentData(binaryFile* theWrappedObject, int index, char** buffer);
709 bool getFragmentData(binaryFile* theWrappedObject, int index, char** buffer);
711 QString getFragmentHeader(binaryFile* theWrappedObject, int index);
710 QString getFragmentHeader(binaryFile* theWrappedObject, int index);
712 int getFragmentSize(binaryFile* theWrappedObject, int index);
711 int getFragmentSize(binaryFile* theWrappedObject, int index);
713 QList<codeFragment* > getFragments(binaryFile* theWrappedObject);
712 QList<codeFragment* > getFragments(binaryFile* theWrappedObject);
714 int getFragmentsCount(binaryFile* theWrappedObject);
713 int getFragmentsCount(binaryFile* theWrappedObject);
715 bool isopened(binaryFile* theWrappedObject);
714 bool isopened(binaryFile* theWrappedObject);
716 bool openFile(binaryFile* theWrappedObject, const QString& File);
715 bool openFile(binaryFile* theWrappedObject, const QString& File);
717 bool openFiles(binaryFile* theWrappedObject, const QStringList& Files);
716 bool openFiles(binaryFile* theWrappedObject, const QStringList& Files);
718 bool static_binaryFile_toBinary(QList<codeFragment* > fragments, const QString& File);
717 bool static_binaryFile_toBinary(QList<codeFragment* > fragments, const QString& File);
719 bool toBinary(binaryFile* theWrappedObject, const QString& fileName);
718 bool toBinary(binaryFile* theWrappedObject, const QString& fileName);
720 bool toSrec(binaryFile* theWrappedObject, const QString& fileName);
719 bool toSrec(binaryFile* theWrappedObject, const QString& fileName);
721 };
720 };
722
721
723
722
724
723
725
724
726
725
727 class PythonQtShell_binaryFileWidget : public binaryFileWidget
726 class PythonQtShell_binaryFileWidget : public binaryFileWidget
728 {
727 {
729 public:
728 public:
730 PythonQtShell_binaryFileWidget(QWidget* parent = 0):binaryFileWidget(parent),_wrapper(NULL) {};
729 PythonQtShell_binaryFileWidget(QWidget* parent = 0):binaryFileWidget(parent),_wrapper(NULL) {};
731
730
732 ~PythonQtShell_binaryFileWidget();
731 ~PythonQtShell_binaryFileWidget();
733
732
734 virtual void reloadFile();
733 virtual void reloadFile();
735 virtual void setFile(abstractBinFile* file);
734 virtual void setFile(abstractBinFile* file);
736
735
737 PythonQtInstanceWrapper* _wrapper;
736 PythonQtInstanceWrapper* _wrapper;
738 };
737 };
739
738
740 class PythonQtPublicPromoter_binaryFileWidget : public binaryFileWidget
739 class PythonQtPublicPromoter_binaryFileWidget : public binaryFileWidget
741 { public:
740 { public:
742 inline void promoted_reloadFile() { binaryFileWidget::reloadFile(); }
741 inline void promoted_reloadFile() { binaryFileWidget::reloadFile(); }
743 inline void promoted_setFile(abstractBinFile* file) { binaryFileWidget::setFile(file); }
742 inline void promoted_setFile(abstractBinFile* file) { binaryFileWidget::setFile(file); }
744 };
743 };
745
744
746 class PythonQtWrapper_binaryFileWidget : public QObject
745 class PythonQtWrapper_binaryFileWidget : public QObject
747 { Q_OBJECT
746 { Q_OBJECT
748 public:
747 public:
749 public slots:
748 public slots:
750 binaryFileWidget* new_binaryFileWidget(QWidget* parent = 0);
749 binaryFileWidget* new_binaryFileWidget(QWidget* parent = 0);
751 void delete_binaryFileWidget(binaryFileWidget* obj) { delete obj; }
750 void delete_binaryFileWidget(binaryFileWidget* obj) { delete obj; }
752 void reloadFile(binaryFileWidget* theWrappedObject);
751 void reloadFile(binaryFileWidget* theWrappedObject);
753 void setFile(binaryFileWidget* theWrappedObject, abstractBinFile* file);
752 void setFile(binaryFileWidget* theWrappedObject, abstractBinFile* file);
754 };
753 };
755
754
756
755
757
756
758
757
759
758
760 class PythonQtShell_codeFragment : public codeFragment
759 class PythonQtShell_codeFragment : public codeFragment
761 {
760 {
762 public:
761 public:
763 PythonQtShell_codeFragment():codeFragment(),_wrapper(NULL) {};
762 PythonQtShell_codeFragment():codeFragment(),_wrapper(NULL) {};
764 PythonQtShell_codeFragment(char* data, quint64 size, quint64 address):codeFragment(data, size, address),_wrapper(NULL) {};
763 PythonQtShell_codeFragment(char* data, quint64 size, quint64 address):codeFragment(data, size, address),_wrapper(NULL) {};
765
764
766 ~PythonQtShell_codeFragment();
765 ~PythonQtShell_codeFragment();
767
766
768
767
769 PythonQtInstanceWrapper* _wrapper;
768 PythonQtInstanceWrapper* _wrapper;
770 };
769 };
771
770
772 class PythonQtWrapper_codeFragment : public QObject
771 class PythonQtWrapper_codeFragment : public QObject
773 { Q_OBJECT
772 { Q_OBJECT
774 public:
773 public:
775 public slots:
774 public slots:
776 codeFragment* new_codeFragment();
775 codeFragment* new_codeFragment();
777 codeFragment* new_codeFragment(char* data, quint64 size, quint64 address);
776 codeFragment* new_codeFragment(char* data, quint64 size, quint64 address);
778 void delete_codeFragment(codeFragment* obj) { delete obj; }
777 void delete_codeFragment(codeFragment* obj) { delete obj; }
779 void py_set_size(codeFragment* theWrappedObject, quint64 size){ theWrappedObject->size = size; }
778 void py_set_size(codeFragment* theWrappedObject, quint64 size){ theWrappedObject->size = size; }
780 quint64 py_get_size(codeFragment* theWrappedObject){ return theWrappedObject->size; }
779 quint64 py_get_size(codeFragment* theWrappedObject){ return theWrappedObject->size; }
780 void py_set_data(codeFragment* theWrappedObject, char* data){ theWrappedObject->data = data; }
781 char* py_get_data(codeFragment* theWrappedObject){ return theWrappedObject->data; }
781 void py_set_address(codeFragment* theWrappedObject, quint64 address){ theWrappedObject->address = address; }
782 void py_set_address(codeFragment* theWrappedObject, quint64 address){ theWrappedObject->address = address; }
782 quint64 py_get_address(codeFragment* theWrappedObject){ return theWrappedObject->address; }
783 quint64 py_get_address(codeFragment* theWrappedObject){ return theWrappedObject->address; }
783 void py_set_data(codeFragment* theWrappedObject, char* data){ theWrappedObject->data = data; }
784 char* py_get_data(codeFragment* theWrappedObject){ return theWrappedObject->data; }
785 void py_set_header(codeFragment* theWrappedObject, QString header){ theWrappedObject->header = header; }
784 void py_set_header(codeFragment* theWrappedObject, QString header){ theWrappedObject->header = header; }
786 QString py_get_header(codeFragment* theWrappedObject){ return theWrappedObject->header; }
785 QString py_get_header(codeFragment* theWrappedObject){ return theWrappedObject->header; }
787 };
786 };
788
787
789
788
790
789
791
790
792
791
793 class PythonQtShell_elfFileWidget : public elfFileWidget
792 class PythonQtShell_elfFileWidget : public elfFileWidget
794 {
793 {
795 public:
794 public:
796 PythonQtShell_elfFileWidget(QWidget* parent = 0):elfFileWidget(parent),_wrapper(NULL) {};
795 PythonQtShell_elfFileWidget(QWidget* parent = 0):elfFileWidget(parent),_wrapper(NULL) {};
797
796
798 ~PythonQtShell_elfFileWidget();
797 ~PythonQtShell_elfFileWidget();
799
798
800 virtual void reloadFile();
799 virtual void reloadFile();
801 virtual void setFile(abstractBinFile* file);
800 virtual void setFile(abstractBinFile* file);
802
801
803 PythonQtInstanceWrapper* _wrapper;
802 PythonQtInstanceWrapper* _wrapper;
804 };
803 };
805
804
806 class PythonQtPublicPromoter_elfFileWidget : public elfFileWidget
805 class PythonQtPublicPromoter_elfFileWidget : public elfFileWidget
807 { public:
806 { public:
808 inline void promoted_reloadFile() { elfFileWidget::reloadFile(); }
807 inline void promoted_reloadFile() { elfFileWidget::reloadFile(); }
808 inline void promoted_setFile(abstractBinFile* file) { elfFileWidget::setFile(file); }
809 };
809 };
810
810
811 class PythonQtWrapper_elfFileWidget : public QObject
811 class PythonQtWrapper_elfFileWidget : public QObject
812 { Q_OBJECT
812 { Q_OBJECT
813 public:
813 public:
814 public slots:
814 public slots:
815 elfFileWidget* new_elfFileWidget(QWidget* parent = 0);
815 elfFileWidget* new_elfFileWidget(QWidget* parent = 0);
816 void delete_elfFileWidget(elfFileWidget* obj) { delete obj; }
816 void delete_elfFileWidget(elfFileWidget* obj) { delete obj; }
817 void reloadFile(elfFileWidget* theWrappedObject);
817 void reloadFile(elfFileWidget* theWrappedObject);
818 void setFile(elfFileWidget* theWrappedObject, abstractBinFile* file);
818 };
819 };
819
820
820
821
821
822
822
823
823
824
824 class PythonQtShell_elfInfoWdgt : public elfInfoWdgt
825 class PythonQtShell_elfInfoWdgt : public elfInfoWdgt
825 {
826 {
826 public:
827 public:
827 PythonQtShell_elfInfoWdgt(QWidget* parent = 0):elfInfoWdgt(parent),_wrapper(NULL) {};
828 PythonQtShell_elfInfoWdgt(QWidget* parent = 0):elfInfoWdgt(parent),_wrapper(NULL) {};
828
829
829 ~PythonQtShell_elfInfoWdgt();
830 ~PythonQtShell_elfInfoWdgt();
830
831
831 virtual void actionEvent(QActionEvent* arg__1);
832 virtual void actionEvent(QActionEvent* arg__1);
832 virtual void changeEvent(QEvent* arg__1);
833 virtual void changeEvent(QEvent* arg__1);
833 virtual void childEvent(QChildEvent* arg__1);
834 virtual void childEvent(QChildEvent* arg__1);
834 virtual void closeEvent(QCloseEvent* arg__1);
835 virtual void closeEvent(QCloseEvent* arg__1);
835 virtual void contextMenuEvent(QContextMenuEvent* arg__1);
836 virtual void contextMenuEvent(QContextMenuEvent* arg__1);
836 virtual void customEvent(QEvent* arg__1);
837 virtual void customEvent(QEvent* arg__1);
837 virtual int devType() const;
838 virtual int devType() const;
838 virtual void dragEnterEvent(QDragEnterEvent* arg__1);
839 virtual void dragEnterEvent(QDragEnterEvent* arg__1);
839 virtual void dragLeaveEvent(QDragLeaveEvent* arg__1);
840 virtual void dragLeaveEvent(QDragLeaveEvent* arg__1);
840 virtual void dragMoveEvent(QDragMoveEvent* arg__1);
841 virtual void dragMoveEvent(QDragMoveEvent* arg__1);
841 virtual void dropEvent(QDropEvent* arg__1);
842 virtual void dropEvent(QDropEvent* arg__1);
842 virtual void enterEvent(QEvent* arg__1);
843 virtual void enterEvent(QEvent* arg__1);
843 virtual bool event(QEvent* arg__1);
844 virtual bool event(QEvent* arg__1);
844 virtual bool eventFilter(QObject* arg__1, QEvent* arg__2);
845 virtual bool eventFilter(QObject* arg__1, QEvent* arg__2);
845 virtual void focusInEvent(QFocusEvent* arg__1);
846 virtual void focusInEvent(QFocusEvent* arg__1);
846 virtual bool focusNextPrevChild(bool next);
847 virtual bool focusNextPrevChild(bool next);
847 virtual void focusOutEvent(QFocusEvent* arg__1);
848 virtual void focusOutEvent(QFocusEvent* arg__1);
848 virtual bool hasHeightForWidth() const;
849 virtual bool hasHeightForWidth() const;
849 virtual int heightForWidth(int arg__1) const;
850 virtual int heightForWidth(int arg__1) const;
850 virtual void hideEvent(QHideEvent* arg__1);
851 virtual void hideEvent(QHideEvent* arg__1);
851 virtual void initPainter(QPainter* painter) const;
852 virtual void initPainter(QPainter* painter) const;
852 virtual void inputMethodEvent(QInputMethodEvent* arg__1);
853 virtual void inputMethodEvent(QInputMethodEvent* arg__1);
853 virtual QVariant inputMethodQuery(Qt::InputMethodQuery arg__1) const;
854 virtual QVariant inputMethodQuery(Qt::InputMethodQuery arg__1) const;
854 virtual void keyPressEvent(QKeyEvent* arg__1);
855 virtual void keyPressEvent(QKeyEvent* arg__1);
855 virtual void keyReleaseEvent(QKeyEvent* arg__1);
856 virtual void keyReleaseEvent(QKeyEvent* arg__1);
856 virtual void leaveEvent(QEvent* arg__1);
857 virtual void leaveEvent(QEvent* arg__1);
857 virtual int metric(QPaintDevice::PaintDeviceMetric arg__1) const;
858 virtual int metric(QPaintDevice::PaintDeviceMetric arg__1) const;
858 virtual QSize minimumSizeHint() const;
859 virtual QSize minimumSizeHint() const;
859 virtual void mouseDoubleClickEvent(QMouseEvent* arg__1);
860 virtual void mouseDoubleClickEvent(QMouseEvent* arg__1);
860 virtual void mouseMoveEvent(QMouseEvent* arg__1);
861 virtual void mouseMoveEvent(QMouseEvent* arg__1);
861 virtual void mousePressEvent(QMouseEvent* arg__1);
862 virtual void mousePressEvent(QMouseEvent* arg__1);
862 virtual void mouseReleaseEvent(QMouseEvent* arg__1);
863 virtual void mouseReleaseEvent(QMouseEvent* arg__1);
863 virtual void moveEvent(QMoveEvent* arg__1);
864 virtual void moveEvent(QMoveEvent* arg__1);
864 virtual bool nativeEvent(const QByteArray& eventType, void* message, long* result);
865 virtual bool nativeEvent(const QByteArray& eventType, void* message, long* result);
865 virtual QPaintEngine* paintEngine() const;
866 virtual QPaintEngine* paintEngine() const;
866 virtual void paintEvent(QPaintEvent* arg__1);
867 virtual void paintEvent(QPaintEvent* arg__1);
867 virtual QPaintDevice* redirected(QPoint* offset) const;
868 virtual QPaintDevice* redirected(QPoint* offset) const;
868 virtual void resizeEvent(QResizeEvent* arg__1);
869 virtual void resizeEvent(QResizeEvent* arg__1);
869 virtual QPainter* sharedPainter() const;
870 virtual QPainter* sharedPainter() const;
870 virtual void showEvent(QShowEvent* arg__1);
871 virtual void showEvent(QShowEvent* arg__1);
871 virtual QSize sizeHint() const;
872 virtual QSize sizeHint() const;
872 virtual void tabletEvent(QTabletEvent* arg__1);
873 virtual void tabletEvent(QTabletEvent* arg__1);
873 virtual void timerEvent(QTimerEvent* arg__1);
874 virtual void timerEvent(QTimerEvent* arg__1);
874 virtual void wheelEvent(QWheelEvent* arg__1);
875 virtual void wheelEvent(QWheelEvent* arg__1);
875
876
876 PythonQtInstanceWrapper* _wrapper;
877 PythonQtInstanceWrapper* _wrapper;
877 };
878 };
878
879
879 class PythonQtWrapper_elfInfoWdgt : public QObject
880 class PythonQtWrapper_elfInfoWdgt : public QObject
880 { Q_OBJECT
881 { Q_OBJECT
881 public:
882 public:
882 public slots:
883 public slots:
883 elfInfoWdgt* new_elfInfoWdgt(QWidget* parent = 0);
884 elfInfoWdgt* new_elfInfoWdgt(QWidget* parent = 0);
884 void delete_elfInfoWdgt(elfInfoWdgt* obj) { delete obj; }
885 void delete_elfInfoWdgt(elfInfoWdgt* obj) { delete obj; }
885 };
886 };
886
887
887
888
888
889
889
890
890
891
891 class PythonQtWrapper_elfparser : public QObject
892 class PythonQtWrapper_elfparser : public QObject
892 { Q_OBJECT
893 { Q_OBJECT
893 public:
894 public:
894 public slots:
895 public slots:
895 elfparser* new_elfparser();
896 elfparser* new_elfparser();
896 void delete_elfparser(elfparser* obj) { delete obj; }
897 void delete_elfparser(elfparser* obj) { delete obj; }
897 int closeFile(elfparser* theWrappedObject);
898 int closeFile(elfparser* theWrappedObject);
898 QString getABI(elfparser* theWrappedObject);
899 QString getABI(elfparser* theWrappedObject);
899 QString getArchitecture(elfparser* theWrappedObject);
900 QString getArchitecture(elfparser* theWrappedObject);
900 QString getClass(elfparser* theWrappedObject);
901 QString getClass(elfparser* theWrappedObject);
901 QString getEndianness(elfparser* theWrappedObject);
902 QString getEndianness(elfparser* theWrappedObject);
902 qint64 getEntryPointAddress(elfparser* theWrappedObject);
903 qint64 getEntryPointAddress(elfparser* theWrappedObject);
903 bool getSectionData(elfparser* theWrappedObject, int index, char** buffer);
904 bool getSectionData(elfparser* theWrappedObject, int index, char** buffer);
904 qint64 getSectionDatasz(elfparser* theWrappedObject, int index);
905 qint64 getSectionDatasz(elfparser* theWrappedObject, int index);
905 qint64 getSectionMemsz(elfparser* theWrappedObject, int index);
906 qint64 getSectionMemsz(elfparser* theWrappedObject, int index);
906 QString getSectionName(elfparser* theWrappedObject, int index);
907 QString getSectionName(elfparser* theWrappedObject, int index);
907 qint64 getSectionPaddr(elfparser* theWrappedObject, int index);
908 qint64 getSectionPaddr(elfparser* theWrappedObject, int index);
908 QString getSectionType(elfparser* theWrappedObject, int index);
909 QString getSectionType(elfparser* theWrappedObject, int index);
909 int getSectioncount(elfparser* theWrappedObject);
910 int getSectioncount(elfparser* theWrappedObject);
910 qint64 getSegmentFilesz(elfparser* theWrappedObject, int index);
911 qint64 getSegmentFilesz(elfparser* theWrappedObject, int index);
911 QString getSegmentFlags(elfparser* theWrappedObject, int index);
912 QString getSegmentFlags(elfparser* theWrappedObject, int index);
912 qint64 getSegmentMemsz(elfparser* theWrappedObject, int index);
913 qint64 getSegmentMemsz(elfparser* theWrappedObject, int index);
913 qint64 getSegmentOffset(elfparser* theWrappedObject, int index);
914 qint64 getSegmentOffset(elfparser* theWrappedObject, int index);
914 qint64 getSegmentPaddr(elfparser* theWrappedObject, int index);
915 qint64 getSegmentPaddr(elfparser* theWrappedObject, int index);
915 QString getSegmentType(elfparser* theWrappedObject, int index);
916 QString getSegmentType(elfparser* theWrappedObject, int index);
916 qint64 getSegmentVaddr(elfparser* theWrappedObject, int index);
917 qint64 getSegmentVaddr(elfparser* theWrappedObject, int index);
917 int getSegmentcount(elfparser* theWrappedObject);
918 int getSegmentcount(elfparser* theWrappedObject);
918 QString getType(elfparser* theWrappedObject);
919 QString getType(elfparser* theWrappedObject);
919 qint64 getVersion(elfparser* theWrappedObject);
920 qint64 getVersion(elfparser* theWrappedObject);
920 bool static_elfparser_isElf(const QString& File);
921 bool static_elfparser_isElf(const QString& File);
921 bool iself(elfparser* theWrappedObject);
922 bool iself(elfparser* theWrappedObject);
922 bool isopened(elfparser* theWrappedObject);
923 bool isopened(elfparser* theWrappedObject);
923 int setFilename(elfparser* theWrappedObject, const QString& name);
924 int setFilename(elfparser* theWrappedObject, const QString& name);
924 };
925 };
925
926
926
927
927
928
928
929
929
930
931 class PythonQtShell_genericBinaryFileWidget : public genericBinaryFileWidget
932 {
933 public:
934 PythonQtShell_genericBinaryFileWidget(QWidget* parent = 0):genericBinaryFileWidget(parent),_wrapper(NULL) {};
935
936 ~PythonQtShell_genericBinaryFileWidget();
937
938 virtual void actionEvent(QActionEvent* arg__1);
939 virtual void changeEvent(QEvent* arg__1);
940 virtual void childEvent(QChildEvent* arg__1);
941 virtual void closeEvent(QCloseEvent* arg__1);
942 virtual void contextMenuEvent(QContextMenuEvent* arg__1);
943 virtual void customEvent(QEvent* arg__1);
944 virtual int devType() const;
945 virtual void dragEnterEvent(QDragEnterEvent* arg__1);
946 virtual void dragLeaveEvent(QDragLeaveEvent* arg__1);
947 virtual void dragMoveEvent(QDragMoveEvent* arg__1);
948 virtual void dropEvent(QDropEvent* arg__1);
949 virtual void enterEvent(QEvent* arg__1);
950 virtual bool event(QEvent* arg__1);
951 virtual bool eventFilter(QObject* arg__1, QEvent* arg__2);
952 virtual void focusInEvent(QFocusEvent* arg__1);
953 virtual bool focusNextPrevChild(bool next);
954 virtual void focusOutEvent(QFocusEvent* arg__1);
955 virtual bool hasHeightForWidth() const;
956 virtual int heightForWidth(int arg__1) const;
957 virtual void hideEvent(QHideEvent* arg__1);
958 virtual void initPainter(QPainter* painter) const;
959 virtual void inputMethodEvent(QInputMethodEvent* arg__1);
960 virtual QVariant inputMethodQuery(Qt::InputMethodQuery arg__1) const;
961 virtual void keyPressEvent(QKeyEvent* arg__1);
962 virtual void keyReleaseEvent(QKeyEvent* arg__1);
963 virtual void leaveEvent(QEvent* arg__1);
964 virtual int metric(QPaintDevice::PaintDeviceMetric arg__1) const;
965 virtual QSize minimumSizeHint() const;
966 virtual void mouseDoubleClickEvent(QMouseEvent* arg__1);
967 virtual void mouseMoveEvent(QMouseEvent* arg__1);
968 virtual void mousePressEvent(QMouseEvent* arg__1);
969 virtual void mouseReleaseEvent(QMouseEvent* arg__1);
970 virtual void moveEvent(QMoveEvent* arg__1);
971 virtual bool nativeEvent(const QByteArray& eventType, void* message, long* result);
972 virtual QPaintEngine* paintEngine() const;
973 virtual void paintEvent(QPaintEvent* arg__1);
974 virtual QPaintDevice* redirected(QPoint* offset) const;
975 virtual void resizeEvent(QResizeEvent* arg__1);
976 virtual QPainter* sharedPainter() const;
977 virtual void showEvent(QShowEvent* arg__1);
978 virtual QSize sizeHint() const;
979 virtual void tabletEvent(QTabletEvent* arg__1);
980 virtual void timerEvent(QTimerEvent* arg__1);
981 virtual void wheelEvent(QWheelEvent* arg__1);
982
983 PythonQtInstanceWrapper* _wrapper;
984 };
985
986 class PythonQtWrapper_genericBinaryFileWidget : public QObject
987 { Q_OBJECT
988 public:
989 public slots:
990 genericBinaryFileWidget* new_genericBinaryFileWidget(QWidget* parent = 0);
991 void delete_genericBinaryFileWidget(genericBinaryFileWidget* obj) { delete obj; }
992 };
993
994
995
996
997
930 class PythonQtShell_srecFile : public srecFile
998 class PythonQtShell_srecFile : public srecFile
931 {
999 {
932 public:
1000 public:
933 PythonQtShell_srecFile():srecFile(),_wrapper(NULL) {};
1001 PythonQtShell_srecFile():srecFile(),_wrapper(NULL) {};
934 PythonQtShell_srecFile(const QString& File):srecFile(File),_wrapper(NULL) {};
1002 PythonQtShell_srecFile(const QString& File):srecFile(File),_wrapper(NULL) {};
935 PythonQtShell_srecFile(const QStringList& Files):srecFile(Files),_wrapper(NULL) {};
1003 PythonQtShell_srecFile(const QStringList& Files):srecFile(Files),_wrapper(NULL) {};
936
1004
937 ~PythonQtShell_srecFile();
1005 ~PythonQtShell_srecFile();
938
1006
939 virtual int closeFile();
1007 virtual int closeFile();
940 virtual QList<codeFragment* > getFragments();
1008 virtual QList<codeFragment* > getFragments();
941 virtual bool isopened();
1009 virtual bool isopened();
942 virtual bool openFile(const QString& File);
1010 virtual bool openFile(const QString& File);
943 virtual bool toBinary(const QString& File);
1011 virtual bool toBinary(const QString& File);
944 virtual bool toSrec(const QString& File);
1012 virtual bool toSrec(const QString& File);
945
1013
946 PythonQtInstanceWrapper* _wrapper;
1014 PythonQtInstanceWrapper* _wrapper;
947 };
1015 };
948
1016
949 class PythonQtPublicPromoter_srecFile : public srecFile
1017 class PythonQtPublicPromoter_srecFile : public srecFile
950 { public:
1018 { public:
951 inline int promoted_closeFile() { return srecFile::closeFile(); }
1019 inline int promoted_closeFile() { return srecFile::closeFile(); }
952 inline QList<codeFragment* > promoted_getFragments() { return srecFile::getFragments(); }
1020 inline QList<codeFragment* > promoted_getFragments() { return srecFile::getFragments(); }
953 inline bool promoted_isopened() { return srecFile::isopened(); }
1021 inline bool promoted_isopened() { return srecFile::isopened(); }
954 inline bool promoted_openFile(const QString& File) { return srecFile::openFile(File); }
1022 inline bool promoted_openFile(const QString& File) { return srecFile::openFile(File); }
955 inline bool promoted_toBinary(const QString& File) { return srecFile::toBinary(File); }
1023 inline bool promoted_toBinary(const QString& File) { return srecFile::toBinary(File); }
956 inline bool promoted_toSrec(const QString& File) { return srecFile::toSrec(File); }
1024 inline bool promoted_toSrec(const QString& File) { return srecFile::toSrec(File); }
957 };
1025 };
958
1026
959 class PythonQtWrapper_srecFile : public QObject
1027 class PythonQtWrapper_srecFile : public QObject
960 { Q_OBJECT
1028 { Q_OBJECT
961 public:
1029 public:
962 public slots:
1030 public slots:
963 srecFile* new_srecFile();
1031 srecFile* new_srecFile();
964 srecFile* new_srecFile(const QString& File);
1032 srecFile* new_srecFile(const QString& File);
965 srecFile* new_srecFile(const QStringList& Files);
1033 srecFile* new_srecFile(const QStringList& Files);
966 void delete_srecFile(srecFile* obj) { delete obj; }
1034 void delete_srecFile(srecFile* obj) { delete obj; }
1035 bool static_srecFile_checkSum(const QString& line);
967 int closeFile(srecFile* theWrappedObject);
1036 int closeFile(srecFile* theWrappedObject);
968 codeFragment* getFragment(srecFile* theWrappedObject, int index);
1037 codeFragment* getFragment(srecFile* theWrappedObject, int index);
969 int getFragmentAddress(srecFile* theWrappedObject, int index);
1038 int getFragmentAddress(srecFile* theWrappedObject, int index);
970 bool getFragmentData(srecFile* theWrappedObject, int index, char** buffer);
1039 bool getFragmentData(srecFile* theWrappedObject, int index, char** buffer);
971 QString getFragmentHeader(srecFile* theWrappedObject, int index);
1040 QString getFragmentHeader(srecFile* theWrappedObject, int index);
972 int getFragmentSize(srecFile* theWrappedObject, int index);
1041 int getFragmentSize(srecFile* theWrappedObject, int index);
973 QList<codeFragment* > getFragments(srecFile* theWrappedObject);
1042 QList<codeFragment* > getFragments(srecFile* theWrappedObject);
974 int getFragmentsCount(srecFile* theWrappedObject);
1043 int getFragmentsCount(srecFile* theWrappedObject);
975 bool isSREC(srecFile* theWrappedObject);
1044 bool isSREC(srecFile* theWrappedObject);
976 bool static_srecFile_isSREC(const QString& File);
1045 bool static_srecFile_isSREC(const QString& File);
977 bool isopened(srecFile* theWrappedObject);
1046 bool isopened(srecFile* theWrappedObject);
978 int lineCount(srecFile* theWrappedObject);
1047 int lineCount(srecFile* theWrappedObject);
979 bool mergingRecords(srecFile* theWrappedObject);
1048 bool mergingRecords(srecFile* theWrappedObject);
980 bool openFile(srecFile* theWrappedObject, const QString& File);
1049 bool openFile(srecFile* theWrappedObject, const QString& File);
981 bool openFiles(srecFile* theWrappedObject, const QStringList& Files);
1050 bool openFiles(srecFile* theWrappedObject, const QStringList& Files);
982 void setMergingRecords(srecFile* theWrappedObject, bool enabled);
1051 void setMergingRecords(srecFile* theWrappedObject, bool enabled);
983 bool toBinary(srecFile* theWrappedObject, const QString& File);
1052 bool toBinary(srecFile* theWrappedObject, const QString& File);
984 bool static_srecFile_toSrec(QList<codeFragment* > fragments, const QString& File);
1053 bool static_srecFile_toSrec(QList<codeFragment* > fragments, const QString& File);
985 bool toSrec(srecFile* theWrappedObject, const QString& File);
1054 bool toSrec(srecFile* theWrappedObject, const QString& File);
986 };
1055 };
987
1056
988
1057
989
1058
990
1059
991
1060
992 class PythonQtShell_srecFileWidget : public srecFileWidget
1061 class PythonQtShell_srecFileWidget : public srecFileWidget
993 {
1062 {
994 public:
1063 public:
995 PythonQtShell_srecFileWidget(QWidget* parent = 0):srecFileWidget(parent),_wrapper(NULL) {};
1064 PythonQtShell_srecFileWidget(QWidget* parent = 0):srecFileWidget(parent),_wrapper(NULL) {};
996
1065
997 ~PythonQtShell_srecFileWidget();
1066 ~PythonQtShell_srecFileWidget();
998
1067
999 virtual void reloadFile();
1068 virtual void reloadFile();
1000 virtual void setFile(abstractBinFile* file);
1069 virtual void setFile(abstractBinFile* file);
1001
1070
1002 PythonQtInstanceWrapper* _wrapper;
1071 PythonQtInstanceWrapper* _wrapper;
1003 };
1072 };
1004
1073
1005 class PythonQtPublicPromoter_srecFileWidget : public srecFileWidget
1074 class PythonQtPublicPromoter_srecFileWidget : public srecFileWidget
1006 { public:
1075 { public:
1007 inline void promoted_reloadFile() { srecFileWidget::reloadFile(); }
1076 inline void promoted_reloadFile() { srecFileWidget::reloadFile(); }
1008 inline void promoted_setFile(abstractBinFile* file) { srecFileWidget::setFile(file); }
1077 inline void promoted_setFile(abstractBinFile* file) { srecFileWidget::setFile(file); }
1009 };
1078 };
1010
1079
1011 class PythonQtWrapper_srecFileWidget : public QObject
1080 class PythonQtWrapper_srecFileWidget : public QObject
1012 { Q_OBJECT
1081 { Q_OBJECT
1013 public:
1082 public:
1014 public slots:
1083 public slots:
1015 srecFileWidget* new_srecFileWidget(QWidget* parent = 0);
1084 srecFileWidget* new_srecFileWidget(QWidget* parent = 0);
1016 void delete_srecFileWidget(srecFileWidget* obj) { delete obj; }
1085 void delete_srecFileWidget(srecFileWidget* obj) { delete obj; }
1017 void reloadFile(srecFileWidget* theWrappedObject);
1086 void reloadFile(srecFileWidget* theWrappedObject);
1018 void setFile(srecFileWidget* theWrappedObject, abstractBinFile* file);
1087 void setFile(srecFileWidget* theWrappedObject, abstractBinFile* file);
1019 };
1088 };
1020
1089
1021
1090
Show file before | Show file after | Hide comments
@@ -1,30 +1,31
1 #include <PythonQt.h>
1 #include <PythonQt.h>
2 #include "PySocExplorer0.h"
2 #include "PySocExplorer0.h"
3
3
4
4
5 void PythonQt_init_PySocExplorer(PyObject* module) {
5 void PythonQt_init_PySocExplorer(PyObject* module) {
6 PythonQt::priv()->registerClass(&ElfFile::staticMetaObject, "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_ElfFile>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_ElfFile>, module, 0);
6 PythonQt::priv()->registerClass(&ElfFile::staticMetaObject, "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_ElfFile>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_ElfFile>, module, 0);
7 PythonQt::self()->addParentClass("ElfFile", "abstractBinFile",PythonQtUpcastingOffset<ElfFile,abstractBinFile>());
7 PythonQt::self()->addParentClass("ElfFile", "abstractBinFile",PythonQtUpcastingOffset<ElfFile,abstractBinFile>());
8 PythonQt::priv()->registerClass(&MemSizeWdgt::staticMetaObject, "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_MemSizeWdgt>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_MemSizeWdgt>, module, 0);
8 PythonQt::priv()->registerClass(&MemSizeWdgt::staticMetaObject, "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_MemSizeWdgt>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_MemSizeWdgt>, module, 0);
9 PythonQt::priv()->registerClass(&QHexEdit::staticMetaObject, "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_QHexEdit>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_QHexEdit>, module, 0);
9 PythonQt::priv()->registerClass(&QHexEdit::staticMetaObject, "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_QHexEdit>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_QHexEdit>, module, 0);
10 PythonQt::priv()->registerClass(&QHexSpinBox::staticMetaObject, "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_QHexSpinBox>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_QHexSpinBox>, module, 0);
10 PythonQt::priv()->registerClass(&QHexSpinBox::staticMetaObject, "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_QHexSpinBox>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_QHexSpinBox>, module, 0);
11 PythonQt::priv()->registerClass(&SocExplorerPlot::staticMetaObject, "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_SocExplorerPlot>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_SocExplorerPlot>, module, 0);
11 PythonQt::priv()->registerClass(&SocExplorerPlot::staticMetaObject, "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_SocExplorerPlot>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_SocExplorerPlot>, module, 0);
12 PythonQt::priv()->registerClass(&TCP_Terminal_Client::staticMetaObject, "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_TCP_Terminal_Client>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_TCP_Terminal_Client>, module, 0);
12 PythonQt::priv()->registerClass(&TCP_Terminal_Client::staticMetaObject, "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_TCP_Terminal_Client>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_TCP_Terminal_Client>, module, 0);
13 PythonQt::priv()->registerCPPClass("XByteArray", "", "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_XByteArray>, NULL, module, 0);
13 PythonQt::priv()->registerCPPClass("XByteArray", "", "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_XByteArray>, NULL, module, 0);
14 PythonQt::priv()->registerClass(&abstractBinFile::staticMetaObject, "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_abstractBinFile>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_abstractBinFile>, module, 0);
14 PythonQt::priv()->registerClass(&abstractBinFile::staticMetaObject, "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_abstractBinFile>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_abstractBinFile>, module, 0);
15 PythonQt::priv()->registerClass(&abstractBinFileWidget::staticMetaObject, "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_abstractBinFileWidget>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_abstractBinFileWidget>, module, 0);
15 PythonQt::priv()->registerClass(&abstractBinFileWidget::staticMetaObject, "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_abstractBinFileWidget>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_abstractBinFileWidget>, module, 0);
16 PythonQt::priv()->registerClass(&binaryFile::staticMetaObject, "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_binaryFile>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_binaryFile>, module, 0);
16 PythonQt::priv()->registerClass(&binaryFile::staticMetaObject, "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_binaryFile>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_binaryFile>, module, 0);
17 PythonQt::self()->addParentClass("binaryFile", "abstractBinFile",PythonQtUpcastingOffset<binaryFile,abstractBinFile>());
17 PythonQt::self()->addParentClass("binaryFile", "abstractBinFile",PythonQtUpcastingOffset<binaryFile,abstractBinFile>());
18 PythonQt::priv()->registerClass(&binaryFileWidget::staticMetaObject, "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_binaryFileWidget>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_binaryFileWidget>, module, 0);
18 PythonQt::priv()->registerClass(&binaryFileWidget::staticMetaObject, "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_binaryFileWidget>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_binaryFileWidget>, module, 0);
19 PythonQt::self()->addParentClass("binaryFileWidget", "abstractBinFileWidget",PythonQtUpcastingOffset<binaryFileWidget,abstractBinFileWidget>());
19 PythonQt::self()->addParentClass("binaryFileWidget", "abstractBinFileWidget",PythonQtUpcastingOffset<binaryFileWidget,abstractBinFileWidget>());
20 PythonQt::priv()->registerCPPClass("codeFragment", "", "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_codeFragment>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_codeFragment>, module, 0);
20 PythonQt::priv()->registerCPPClass("codeFragment", "", "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_codeFragment>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_codeFragment>, module, 0);
21 PythonQt::priv()->registerClass(&elfFileWidget::staticMetaObject, "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_elfFileWidget>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_elfFileWidget>, module, 0);
21 PythonQt::priv()->registerClass(&elfFileWidget::staticMetaObject, "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_elfFileWidget>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_elfFileWidget>, module, 0);
22 PythonQt::self()->addParentClass("elfFileWidget", "abstractBinFileWidget",PythonQtUpcastingOffset<elfFileWidget,abstractBinFileWidget>());
22 PythonQt::self()->addParentClass("elfFileWidget", "abstractBinFileWidget",PythonQtUpcastingOffset<elfFileWidget,abstractBinFileWidget>());
23 PythonQt::priv()->registerClass(&elfInfoWdgt::staticMetaObject, "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_elfInfoWdgt>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_elfInfoWdgt>, module, 0);
23 PythonQt::priv()->registerClass(&elfInfoWdgt::staticMetaObject, "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_elfInfoWdgt>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_elfInfoWdgt>, module, 0);
24 PythonQt::priv()->registerCPPClass("elfparser", "", "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_elfparser>, NULL, module, 0);
24 PythonQt::priv()->registerCPPClass("elfparser", "", "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_elfparser>, NULL, module, 0);
25 PythonQt::priv()->registerClass(&genericBinaryFileWidget::staticMetaObject, "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_genericBinaryFileWidget>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_genericBinaryFileWidget>, module, 0);
25 PythonQt::priv()->registerClass(&srecFile::staticMetaObject, "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_srecFile>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_srecFile>, module, 0);
26 PythonQt::priv()->registerClass(&srecFile::staticMetaObject, "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_srecFile>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_srecFile>, module, 0);
26 PythonQt::self()->addParentClass("srecFile", "abstractBinFile",PythonQtUpcastingOffset<srecFile,abstractBinFile>());
27 PythonQt::self()->addParentClass("srecFile", "abstractBinFile",PythonQtUpcastingOffset<srecFile,abstractBinFile>());
27 PythonQt::priv()->registerClass(&srecFileWidget::staticMetaObject, "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_srecFileWidget>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_srecFileWidget>, module, 0);
28 PythonQt::priv()->registerClass(&srecFileWidget::staticMetaObject, "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_srecFileWidget>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_srecFileWidget>, module, 0);
28 PythonQt::self()->addParentClass("srecFileWidget", "abstractBinFileWidget",PythonQtUpcastingOffset<srecFileWidget,abstractBinFileWidget>());
29 PythonQt::self()->addParentClass("srecFileWidget", "abstractBinFileWidget",PythonQtUpcastingOffset<srecFileWidget,abstractBinFileWidget>());
29
30
30 }
31 }
Show file before | Show file after | Hide comments
@@ -1,75 +1,34
1 <typesystem package="PySocExplorer" default-superclass="com.trolltech.qt.QtJambiObject">
1 <typesystem package="PySocExplorer" default-superclass="com.trolltech.qt.QtJambiObject">
2 <load-typesystem name=":/trolltech/generator/typesystem_core.txt" generate="no" />
2 <load-typesystem name=":/trolltech/generator/typesystem_core.txt" generate="no" />
3 <load-typesystem name=":/trolltech/generator/typesystem_gui.txt" generate="no" />
3 <load-typesystem name=":/trolltech/generator/typesystem_gui.txt" generate="no" />
4 <load-typesystem name=":/trolltech/generator/typesystem_network.txt" generate="no" />
4 <load-typesystem name=":/trolltech/generator/typesystem_network.txt" generate="no" />
5
5
6
6 <object-type name="QHexSpinBox"/>
7 <object-type name="QHexSpinBox">
8 <extra-includes>
9 <include file-name="QWidget" location="global"/>
10 <include file-name="QObject" location="global"/>
11 <include file-name="QSpinBox" location="global"/>
12 </extra-includes>
13 </object-type>
14 <object-type name="MemSizeWdgt" />
7 <object-type name="MemSizeWdgt" />
15 <object-type name="QHexEdit" />
8 <object-type name="QHexEdit" />
16 <object-type name="XByteArray" />
9 <object-type name="XByteArray" />
17 <object-type name="SocExplorerPlot" />
10 <object-type name="SocExplorerPlot" />
18 <object-type name="TCP_Terminal_Client" />
11 <object-type name="TCP_Terminal_Client" />
19 <object-type name="codeFragment" />
12 <object-type name="codeFragment" />
20 <object-type name="srecFile" />
13 <object-type name="srecFile" />
21 <object-type name="binaryFile" />
14 <object-type name="binaryFile" />
22 <rejection class="Elf_Section"/>
15 <rejection class="Elf_Section"/>
23 <object-type name="elfparser" />
16 <object-type name="elfparser" />
24 <interface-type name="abstractBinFile">
17 <interface-type name="abstractBinFile"/>
25 <extra-includes>
18 <object-type name="ElfFile"/>
26 <include file-name="QWidget" location="global"/>
19 <interface-type name="abstractBinFileWidget"/>
27 <include file-name="QObject" location="global"/>
20 <object-type name="elfFileWidget"/>
28 </extra-includes>
21 <object-type name="srecFileWidget"/>
29 </interface-type>
22 <object-type name="binaryFileWidget"/>
30 <object-type name="ElfFile">
23 <object-type name="elfInfoWdgt"/>
31 <extra-includes>
24 <object-type name="genericBinaryFileWidget"/>
32 <include file-name="QWidget" location="global"/>
33 <include file-name="QObject" location="global"/>
34 </extra-includes>
35 </object-type>
36 <interface-type name="abstractBinFileWidget">
37 <extra-includes>
38 <include file-name="QWidget" location="global"/>
39 <include file-name="QObject" location="global"/>
40 </extra-includes>
41 </interface-type>
42 <object-type name="elfFileWidget">
43 <extra-includes>
44 <include file-name="QWidget" location="global"/>
45 <include file-name="QObject" location="global"/>
46 </extra-includes>
47 </object-type>
48 <object-type name="srecFileWidget">
49 <extra-includes>
50 <include file-name="QWidget" location="global"/>
51 <include file-name="QObject" location="global"/>
52 </extra-includes>
53 </object-type>
54 <object-type name="binaryFileWidget">
55 <extra-includes>
56 <include file-name="QWidget" location="global"/>
57 <include file-name="QObject" location="global"/>
58 </extra-includes>
59 </object-type>
60 <object-type name="elfInfoWdgt">
61 <extra-includes>
62 <include file-name="QWidget" location="global"/>
63 <include file-name="QObject" location="global"/>
64 </extra-includes>
65 </object-type>
66
25
67 </typesystem>
26 </typesystem>
68
27
69
28
70
29
71
30
72
31
73
32
74
33
75
34
Show file before | Show file after | Hide comments
@@ -1,242 +1,242
1 /*------------------------------------------------------------------------------
1 /*------------------------------------------------------------------------------
2 -- This file is a part of the SocExplorer Software
2 -- This file is a part of the SocExplorer Software
3 -- Copyright (C) 2011, Plasma Physics Laboratory - CNRS
3 -- Copyright (C) 2011, Plasma Physics Laboratory - CNRS
4 --
4 --
5 -- This program is free software; you can redistribute it and/or modify
5 -- This program is free software; you can redistribute it and/or modify
6 -- it under the terms of the GNU General Public License as published by
6 -- it under the terms of the GNU General Public License as published by
7 -- the Free Software Foundation; either version 2 of the License, or
7 -- the Free Software Foundation; either version 2 of the License, or
8 -- (at your option) any later version.
8 -- (at your option) any later version.
9 --
9 --
10 -- This program is distributed in the hope that it will be useful,
10 -- This program is distributed in the hope that it will be useful,
11 -- but WITHOUT ANY WARRANTY; without even the implied warranty of
11 -- but WITHOUT ANY WARRANTY; without even the implied warranty of
12 -- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 -- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 -- GNU General Public License for more details.
13 -- GNU General Public License for more details.
14 --
14 --
15 -- You should have received a copy of the GNU General Public License
15 -- You should have received a copy of the GNU General Public License
16 -- along with this program; if not, write to the Free Software
16 -- along with this program; if not, write to the Free Software
17 -- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17 -- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
18 -------------------------------------------------------------------------------*/
18 -------------------------------------------------------------------------------*/
19 /*-- Author : Alexis Jeandet
19 /*-- Author : Alexis Jeandet
20 -- Mail : alexis.jeandet@lpp.polytechnique.fr
20 -- Mail : alexis.jeandet@lpp.polytechnique.fr
21 ----------------------------------------------------------------------------*/
21 ----------------------------------------------------------------------------*/
22 #include "mainwindow.h"
22 #include "mainwindow.h"
23 #include <QDockWidget>
23 #include <QDockWidget>
24
24
25 SocExplorerMainWindow::SocExplorerMainWindow(QString ScriptToEval, QWidget *parent)
25 SocExplorerMainWindow::SocExplorerMainWindow(QString ScriptToEval, QWidget *parent)
26 : QMainWindow(parent)
26 : QMainWindow(parent)
27 {
27 {
28 QCoreApplication::setApplicationName("SocExplorer");
28 QCoreApplication::setApplicationName("SocExplorer");
29 QCoreApplication::setOrganizationName("LPP");
29 QCoreApplication::setOrganizationName("LPP");
30 QCoreApplication::setOrganizationDomain("lpp.fr");
30 QCoreApplication::setOrganizationDomain("lpp.fr");
31 this->makeObjects(ScriptToEval);
31 this->makeObjects(ScriptToEval);
32 this->makeLayout();
32 this->makeLayout();
33 this->makeMenu();
33 this->makeMenu();
34 this->makeConnections();
34 this->makeConnections();
35 this->setWindowIcon(QIcon(tr(":/images/logolppcutted.png")));
35 this->setWindowIcon(QIcon(tr(":/images/icon.png")));
36 this->setAcceptDrops(true);
36 this->setAcceptDrops(true);
37 this->pluginManager->setRootLoadable(true);
37 this->pluginManager->setRootLoadable(true);
38 this->PythonConsoleInst->pyConsoleRunFile(ScriptToEval);
38 this->PythonConsoleInst->pyConsoleRunFile(ScriptToEval);
39 QFile file(":/styles/SocExplorer.css");
39 QFile file(":/styles/SocExplorer.css");
40 if(file.open(QIODevice::ReadOnly | QIODevice::Text))
40 if(file.open(QIODevice::ReadOnly | QIODevice::Text))
41 {
41 {
42 qApp->setStyleSheet(file.readAll());
42 qApp->setStyleSheet(file.readAll());
43 file.close();
43 file.close();
44 }
44 }
45 }
45 }
46
46
47
47
48 void SocExplorerMainWindow::makeObjects(QString ScriptToEval)
48 void SocExplorerMainWindow::makeObjects(QString ScriptToEval)
49 {
49 {
50 Q_UNUSED(ScriptToEval)
50 Q_UNUSED(ScriptToEval)
51 this->p_pluginGUIlist = new QList<QDockWidget*>();
51 this->p_pluginGUIlist = new QList<QDockWidget*>();
52 pluginsDockContainer = new QMainWindow;
52 pluginsDockContainer = new QMainWindow;
53 pluginsDockContainer->setWindowFlags(Qt::Widget);
53 pluginsDockContainer->setWindowFlags(Qt::Widget);
54 pluginsDockContainer->setDockNestingEnabled(true);
54 pluginsDockContainer->setDockNestingEnabled(true);
55 this->mainWidget = new QSplitter(Qt::Vertical);
55 this->mainWidget = new QSplitter(Qt::Vertical);
56 this->appTranslator = new QTranslator;
56 this->appTranslator = new QTranslator;
57 this->Quit = new QAction(tr("&Quit"),this);
57 this->Quit = new QAction(tr("&Quit"),this);
58 this->Quit->setShortcut(tr("CTRL+Q"));
58 this->Quit->setShortcut(tr("CTRL+Q"));
59 this->ManagePlugins = new QAction(tr("&Manage Plugins"),this);
59 this->ManagePlugins = new QAction(tr("&Manage Plugins"),this);
60 this->ManagePlugins->setShortcut(tr("CTRL+P"));
60 this->ManagePlugins->setShortcut(tr("CTRL+P"));
61 this->regsManager = new QAction(tr("&Manage registers"),this);
61 this->regsManager = new QAction(tr("&Manage registers"),this);
62 this->exploreRegs = new QAction(tr("&Explore registers"),this);
62 this->exploreRegs = new QAction(tr("&Explore registers"),this);
63 this->help = new QAction(tr("&Help"),this);
63 this->help = new QAction(tr("&Help"),this);
64 this->help->setShortcut(tr("CTRL+H"));
64 this->help->setShortcut(tr("CTRL+H"));
65 this->about = new QAction(tr("&About"),this);
65 this->about = new QAction(tr("&About"),this);
66 socexplorerproxy::setMainWindow(this);
66 socexplorerproxy::setMainWindow(this);
67 SocExplorerEngine::setMainWindow(this);
67 SocExplorerEngine::setMainWindow(this);
68 SocExplorerEngine::xmlModel()->scanXmlFiles();
68 SocExplorerEngine::xmlModel()->scanXmlFiles();
69 this->regExplorer = new regsExplorer();
69 this->regExplorer = new regsExplorer();
70 this->regExplorer->setAllowedAreas(Qt::AllDockWidgetAreas);
70 this->regExplorer->setAllowedAreas(Qt::AllDockWidgetAreas);
71 this->addPluginInterface(this->regExplorer);
71 this->addPluginInterface(this->regExplorer);
72 this->PythonConsoleInst = new PythonConsole(socexplorerproxy::self());
72 this->PythonConsoleInst = new PythonConsole(socexplorerproxy::self());
73 this->PythonConsoleInst->addObject("SocExplorerEngine",SocExplorerEngine::self());
73 this->PythonConsoleInst->addObject("SocExplorerEngine",SocExplorerEngine::self());
74 this->pluginManager = new dockablePluginManager();
74 this->pluginManager = new dockablePluginManager();
75 this->toolpane = new toolBar;
75 this->toolpane = new toolBar;
76 this->p_about = new aboutsocexplorer();
76 this->p_about = new aboutsocexplorer();
77
77
78 }
78 }
79
79
80 void SocExplorerMainWindow::makeLayout()
80 void SocExplorerMainWindow::makeLayout()
81 {
81 {
82 this->mainWidget->addWidget(pluginsDockContainer);
82 this->mainWidget->addWidget(pluginsDockContainer);
83 this->mainWidget->addWidget(this->PythonConsoleInst);
83 this->mainWidget->addWidget(this->PythonConsoleInst);
84 this->toolpane->setAllowedAreas(Qt::RightDockWidgetArea|Qt::LeftDockWidgetArea);
84 this->toolpane->setAllowedAreas(Qt::RightDockWidgetArea|Qt::LeftDockWidgetArea);
85 this->addDockWidget(Qt::LeftDockWidgetArea,this->toolpane);
85 this->addDockWidget(Qt::LeftDockWidgetArea,this->toolpane);
86 this->toolpane->addTool(this->pluginManager);
86 this->toolpane->addTool(this->pluginManager);
87 this->setCentralWidget(this->mainWidget);
87 this->setCentralWidget(this->mainWidget);
88 }
88 }
89
89
90
90
91 void SocExplorerMainWindow::makeConnections()
91 void SocExplorerMainWindow::makeConnections()
92 {
92 {
93 connect(socexplorerproxy::self(),SIGNAL(clearMenu()),this,SLOT(clearMenu()));
93 connect(socexplorerproxy::self(),SIGNAL(clearMenu()),this,SLOT(clearMenu()));
94 connect(this,SIGNAL(translateSig()),socexplorerproxy::self(),SLOT(updateText()));
94 connect(this,SIGNAL(translateSig()),socexplorerproxy::self(),SLOT(updateText()));
95 connect(socexplorerproxy::self(),SIGNAL(addPluginGUI(QDockWidget*)),this,SLOT(addPluginInterface(QDockWidget*)));
95 connect(socexplorerproxy::self(),SIGNAL(addPluginGUI(QDockWidget*)),this,SLOT(addPluginInterface(QDockWidget*)));
96 connect(socexplorerproxy::self(),SIGNAL(removePluginGUI(QDockWidget*)),this,SLOT(removePluginInterface(QDockWidget*)));
96 connect(socexplorerproxy::self(),SIGNAL(removePluginGUI(QDockWidget*)),this,SLOT(removePluginInterface(QDockWidget*)));
97 connect(this->ManagePlugins,SIGNAL(triggered()),this,SLOT(launchPluginManager()));
97 connect(this->ManagePlugins,SIGNAL(triggered()),this,SLOT(launchPluginManager()));
98 connect(this->Quit,SIGNAL(triggered()),qApp,SLOT(quit()));
98 connect(this->Quit,SIGNAL(triggered()),qApp,SLOT(quit()));
99 connect(this,SIGNAL(registerObject(QObject*,QString)),this->PythonConsoleInst,SLOT(registerObject(QObject*,QString)));
99 connect(this,SIGNAL(registerObject(QObject*,QString)),this->PythonConsoleInst,SLOT(registerObject(QObject*,QString)));
100 connect(socexplorerproxy::self(),SIGNAL(registerObject(QObject*,QString)),this,SIGNAL(registerObject(QObject*,QString)));
100 connect(socexplorerproxy::self(),SIGNAL(registerObject(QObject*,QString)),this,SIGNAL(registerObject(QObject*,QString)));
101 connect(this->pluginManager,SIGNAL(geteplugintree()),socexplorerproxy::self(),SLOT(geteplugintree()));
101 connect(this->pluginManager,SIGNAL(geteplugintree()),socexplorerproxy::self(),SLOT(geteplugintree()));
102 connect(socexplorerproxy::self(),SIGNAL(treeChanged(QList<socexplorerplugin*>)),this->pluginManager,SIGNAL(treeChanged(QList<socexplorerplugin*>)));
102 connect(socexplorerproxy::self(),SIGNAL(treeChanged(QList<socexplorerplugin*>)),this->pluginManager,SIGNAL(treeChanged(QList<socexplorerplugin*>)));
103 connect(this->pluginManager,SIGNAL(changeSysDriverInstName(QString,QString)),socexplorerproxy::self(),SLOT(changeSysDriverInstName(QString,QString)));
103 connect(this->pluginManager,SIGNAL(changeSysDriverInstName(QString,QString)),socexplorerproxy::self(),SLOT(changeSysDriverInstName(QString,QString)));
104 connect(this->pluginManager,SIGNAL(changeSysDriverInstName(QString,QString)),this->PythonConsoleInst,SLOT(changeSysDriverInstName(QString,QString)));
104 connect(this->pluginManager,SIGNAL(changeSysDriverInstName(QString,QString)),this->PythonConsoleInst,SLOT(changeSysDriverInstName(QString,QString)));
105 connect(this->pluginManager,SIGNAL(closeSysDriver(QString)),socexplorerproxy::self(),SLOT(closeSysDriver(QString)));
105 connect(this->pluginManager,SIGNAL(closeSysDriver(QString)),socexplorerproxy::self(),SLOT(closeSysDriver(QString)));
106 connect(this->pluginManager,SIGNAL(closeSysDriver(QString)),this->PythonConsoleInst,SLOT(removeDriver(QString)));
106 connect(this->pluginManager,SIGNAL(closeSysDriver(QString)),this->PythonConsoleInst,SLOT(removeDriver(QString)));
107 connect(this->pluginManager,SIGNAL(pluginselected(QString)),this,SLOT(pluginselected(QString)));
107 connect(this->pluginManager,SIGNAL(pluginselected(QString)),this,SLOT(pluginselected(QString)));
108 connect(this->about,SIGNAL(triggered()),this,SLOT(showAboutBox()));
108 connect(this->about,SIGNAL(triggered()),this,SLOT(showAboutBox()));
109 connect(this->exploreRegs,SIGNAL(triggered()),this->regExplorer,SLOT(show()));
109 connect(this->exploreRegs,SIGNAL(triggered()),this->regExplorer,SLOT(show()));
110
110
111 this->pluginManager->connect(this->pluginManager,SIGNAL(loadSysDrviver(QString)),socexplorerproxy::self(),SLOT(loadSysDriver(QString)));
111 this->pluginManager->connect(this->pluginManager,SIGNAL(loadSysDrviver(QString)),socexplorerproxy::self(),SLOT(loadSysDriver(QString)));
112 this->pluginManager->connect(this->pluginManager,SIGNAL(loadSysDriverToParent(QString,QString)),socexplorerproxy::self(),SLOT(loadSysDriverToParent(QString,QString)));
112 this->pluginManager->connect(this->pluginManager,SIGNAL(loadSysDriverToParent(QString,QString)),socexplorerproxy::self(),SLOT(loadSysDriverToParent(QString,QString)));
113
113
114 }
114 }
115
115
116
116
117 void SocExplorerMainWindow::launchPluginManager()
117 void SocExplorerMainWindow::launchPluginManager()
118 {
118 {
119
119
120 if(this->pluginManager->isHidden())
120 if(this->pluginManager->isHidden())
121 {
121 {
122 this->pluginManager->setHidden(false);
122 this->pluginManager->setHidden(false);
123 }
123 }
124
124
125 }
125 }
126
126
127
127
128 void SocExplorerMainWindow::addPluginInterface(QDockWidget *plugin)
128 void SocExplorerMainWindow::addPluginInterface(QDockWidget *plugin)
129 {
129 {
130 plugin->setAllowedAreas(Qt::AllDockWidgetAreas);
130 plugin->setAllowedAreas(Qt::AllDockWidgetAreas);
131 this->pluginsDockContainer->addDockWidget(Qt::TopDockWidgetArea,plugin);
131 this->pluginsDockContainer->addDockWidget(Qt::TopDockWidgetArea,plugin);
132 if(p_pluginGUIlist->count()!=0)
132 if(p_pluginGUIlist->count()!=0)
133 this->pluginsDockContainer->tabifyDockWidget(p_pluginGUIlist->last(),plugin);
133 this->pluginsDockContainer->tabifyDockWidget(p_pluginGUIlist->last(),plugin);
134 p_pluginGUIlist->append(plugin);
134 p_pluginGUIlist->append(plugin);
135
135
136 }
136 }
137
137
138 void SocExplorerMainWindow::removePluginInterface(QDockWidget *plugin)
138 void SocExplorerMainWindow::removePluginInterface(QDockWidget *plugin)
139 {
139 {
140 p_pluginGUIlist->removeOne(plugin);
140 p_pluginGUIlist->removeOne(plugin);
141 this->pluginsDockContainer->removeDockWidget(plugin);
141 this->pluginsDockContainer->removeDockWidget(plugin);
142 }
142 }
143
143
144
144
145 void SocExplorerMainWindow::clearMenu()
145 void SocExplorerMainWindow::clearMenu()
146 {
146 {
147 this->menuBar()->clear();
147 this->menuBar()->clear();
148 this->makeMenu();
148 this->makeMenu();
149 }
149 }
150
150
151
151
152 void SocExplorerMainWindow::makeMenu()
152 void SocExplorerMainWindow::makeMenu()
153 {
153 {
154 this->FileMenu = menuBar()->addMenu(tr("&File"));
154 this->FileMenu = menuBar()->addMenu(tr("&File"));
155 this->PluginsMenu = menuBar()->addMenu(tr("&Plugins"));
155 this->PluginsMenu = menuBar()->addMenu(tr("&Plugins"));
156 this->ToolsMenu = menuBar()->addMenu(tr("&Tools"));
156 this->ToolsMenu = menuBar()->addMenu(tr("&Tools"));
157 this->ToolsMenu->addAction(this->exploreRegs);
157 this->ToolsMenu->addAction(this->exploreRegs);
158 this->FileMenu->addAction(this->Quit);
158 this->FileMenu->addAction(this->Quit);
159 socexplorerproxy::self()->makeMenu(this->PluginsMenu);
159 socexplorerproxy::self()->makeMenu(this->PluginsMenu);
160 this->PluginsMenu->addAction(this->ManagePlugins);
160 this->PluginsMenu->addAction(this->ManagePlugins);
161
161
162 this->helpMenu = menuBar()->addMenu(tr("Help"));
162 this->helpMenu = menuBar()->addMenu(tr("Help"));
163 this->helpMenu->addAction(this->help);
163 this->helpMenu->addAction(this->help);
164 this->helpMenu->addAction(this->about);
164 this->helpMenu->addAction(this->about);
165
165
166 }
166 }
167
167
168
168
169 SocExplorerMainWindow::~SocExplorerMainWindow()
169 SocExplorerMainWindow::~SocExplorerMainWindow()
170 {
170 {
171 }
171 }
172
172
173
173
174 void SocExplorerMainWindow::setLangage(QAction *action)
174 void SocExplorerMainWindow::setLangage(QAction *action)
175 {
175 {
176 QString local = action->data().toString();
176 QString local = action->data().toString();
177 QString qmPath = QDir(QString("translations")).absolutePath();
177 QString qmPath = QDir(QString("translations")).absolutePath();
178 appTranslator->load(qmPath+"/socexplorer_"+local+".qm");
178 appTranslator->load(qmPath+"/socexplorer_"+local+".qm");
179 qApp->installTranslator(appTranslator);
179 qApp->installTranslator(appTranslator);
180 emit this->translateSig();
180 emit this->translateSig();
181 }
181 }
182
182
183
183
184 void SocExplorerMainWindow::createLangMenu()
184 void SocExplorerMainWindow::createLangMenu()
185 {
185 {
186 this->langMenu = menuBar()->addMenu(tr("&Langue"));
186 this->langMenu = menuBar()->addMenu(tr("&Langue"));
187 this->langActionGrp = new QActionGroup(this);
187 this->langActionGrp = new QActionGroup(this);
188 connect(this->langActionGrp,SIGNAL(triggered(QAction*)),this,SLOT(setLangage(QAction*)));
188 connect(this->langActionGrp,SIGNAL(triggered(QAction*)),this,SLOT(setLangage(QAction*)));
189 QDir* qmDir = new QDir(QString("translations"));
189 QDir* qmDir = new QDir(QString("translations"));
190 QStringList LangFiles = qmDir->entryList(QStringList("socexplorer_*.qm"));
190 QStringList LangFiles = qmDir->entryList(QStringList("socexplorer_*.qm"));
191 for(int i=0;i<LangFiles.size();++i)
191 for(int i=0;i<LangFiles.size();++i)
192 {
192 {
193 QString Local = LangFiles[i];
193 QString Local = LangFiles[i];
194 Local.remove(0,Local.indexOf('_')+1);
194 Local.remove(0,Local.indexOf('_')+1);
195 Local.chop(3);
195 Local.chop(3);
196 QTranslator translator;
196 QTranslator translator;
197 translator.load(LangFiles[i],qmDir->absolutePath());
197 translator.load(LangFiles[i],qmDir->absolutePath());
198 QString langage = translator.translate("MainWindow","English");
198 QString langage = translator.translate("MainWindow","English");
199 QAction *action = new QAction(tr("&%1 %2").arg(i+1).arg(langage),this);
199 QAction *action = new QAction(tr("&%1 %2").arg(i+1).arg(langage),this);
200 action->setCheckable(true);
200 action->setCheckable(true);
201 action->setData(Local);
201 action->setData(Local);
202 langMenu->addAction(action);
202 langMenu->addAction(action);
203 langActionGrp->addAction(action);
203 langActionGrp->addAction(action);
204 if(langage==tr("English"))
204 if(langage==tr("English"))
205 action->setChecked(true);
205 action->setChecked(true);
206 }
206 }
207 }
207 }
208
208
209
209
210 void SocExplorerMainWindow::updateText()
210 void SocExplorerMainWindow::updateText()
211 {
211 {
212 emit this->translateSig();
212 emit this->translateSig();
213 }
213 }
214
214
215
215
216
216
217 void SocExplorerMainWindow::showAboutBox()
217 void SocExplorerMainWindow::showAboutBox()
218 {
218 {
219 p_about->show();
219 p_about->show();
220 }
220 }
221
221
222 void SocExplorerMainWindow::pluginselected(const QString &instanceName)
222 void SocExplorerMainWindow::pluginselected(const QString &instanceName)
223 {
223 {
224 socexplorerplugin* drv=socexplorerproxy::self()->getSysDriver(instanceName);
224 socexplorerplugin* drv=socexplorerproxy::self()->getSysDriver(instanceName);
225 if(drv)
225 if(drv)
226 drv->raise();
226 drv->raise();
227 }
227 }
228
228
229
229
230
230
231 void SocExplorerMainWindow::closeEvent(QCloseEvent *event)
231 void SocExplorerMainWindow::closeEvent(QCloseEvent *event)
232 {
232 {
233 socexplorerproxy::self()->close();
233 socexplorerproxy::self()->close();
234 qApp->closeAllWindows();
234 qApp->closeAllWindows();
235 event->accept();
235 event->accept();
236 }
236 }
237
237
238
238
239
239
240
240
241
241
242
242
Show file before | Show file after | Hide comments
@@ -1,136 +1,137
1 #-------------------------------------------------
1 #-------------------------------------------------
2 #
2 #
3 # Project created by QtCreator 2011-09-19T22:52:10
3 # Project created by QtCreator 2011-09-19T22:52:10
4 #
4 #
5 #-------------------------------------------------
5 #-------------------------------------------------
6 SOCEXPLORER_ROOT = $${PWD}/..
6 SOCEXPLORER_ROOT = $${PWD}/..
7 include(../build_cfg/socexplorer.pri)
7 include(../build_cfg/socexplorer.pri)
8
8
9 TARGET = socexplorer$${DEBUG_EXT}
9 TARGET = socexplorer$${DEBUG_EXT}
10 TEMPLATE = app
10 TEMPLATE = app
11 CONFIG += pythonqt
11 CONFIG += pythonqt
12
12
13
13
14 QMAKE_LFLAGS_RELEASE += --enable-auto-import -mstackrealign
14 QMAKE_LFLAGS_RELEASE += --enable-auto-import -mstackrealign
15 QMAKE_LFLAGS_DEBUG += --enable-auto-import -mstackrealign
15 QMAKE_LFLAGS_DEBUG += --enable-auto-import -mstackrealign
16
16
17 include ( common/pythonQtOut/generated_cpp/PySocExplorer/PySocExplorer.pri )
17 include ( common/pythonQtOut/generated_cpp/PySocExplorer/PySocExplorer.pri )
18 include ( SocExplorerEngine/pythonQtOut/generated_cpp/PySocExplorerEngine/PySocExplorerEngine.pri )
18 include ( SocExplorerEngine/plugins/socexplorerplugin.prf )
19 include ( SocExplorerEngine/plugins/socexplorerplugin.prf )
19
20
20 INCLUDEPATH+=$${PWD} \
21 INCLUDEPATH+=$${PWD} \
21 $${PWD}/common \
22 $${PWD}/common \
22 $${PWD}/common/qhexedit \
23 $${PWD}/common/qhexedit \
23 $${PWD}/common/QCustomPlot \
24 $${PWD}/common/QCustomPlot \
24 $${PWD}/common/genericBinaryFiles \
25 $${PWD}/common/genericBinaryFiles \
25 $${PWD}/common/genericBinaryFiles/elf \
26 $${PWD}/common/genericBinaryFiles/elf \
26 $${PWD}/common/genericBinaryFiles/srec \
27 $${PWD}/common/genericBinaryFiles/srec \
27 $${PWD}/common/genericBinaryFiles/BinFile \
28 $${PWD}/common/genericBinaryFiles/BinFile \
28 SocExplorerEngine/engine \
29 SocExplorerEngine/engine \
29 SocExplorerEngine/pluginloader \
30 SocExplorerEngine/pluginloader \
30 SocExplorerEngine/pluginsInterface \
31 SocExplorerEngine/pluginsInterface \
31 SocExplorerEngine/proxy \
32 SocExplorerEngine/proxy \
32 SocExplorerEngine/pluginManagerWdgt \
33 SocExplorerEngine/pluginManagerWdgt \
33 SocExplorerEngine/plugins \
34 SocExplorerEngine/plugins \
34 SocExplorerEngine/RegisterMVS \
35 SocExplorerEngine/RegisterMVS \
35 SocExplorerEngine/XmlEngine \
36 SocExplorerEngine/XmlEngine \
36 SocExplorerEngine/SOC \
37 SocExplorerEngine/SOC \
37 SocExplorerEngine/PeripheralWidget/src
38 SocExplorerEngine/PeripheralWidget/src
38
39
39 win32:INCLUDEPATH+= \
40 win32:INCLUDEPATH+= \
40 $${PWD}/common/genericBinaryFiles/elf/libelfWin32/include \
41 $${PWD}/common/genericBinaryFiles/elf/libelfWin32/include \
41 $${PWD}/common/genericBinaryFiles/elf/libelfWin32/include/libelf \
42 $${PWD}/common/genericBinaryFiles/elf/libelfWin32/include/libelf \
42
43
43
44
44 RC_FILE = ../win32cfg/socexplorer.rc
45 RC_FILE = ../win32cfg/socexplorer.rc
45
46
46
47
47 unix:LIBS+=-L$${SOCEXPLORER_ROOT}/bin/linux -lsocexplorercommon$${DEBUG_EXT} -L$${SOCEXPLORER_ROOT}/bin/linux -lsocexplorerengine$${DEBUG_EXT}
48 unix:LIBS+=-L$${SOCEXPLORER_ROOT}/bin/linux -lsocexplorercommon$${DEBUG_EXT} -L$${SOCEXPLORER_ROOT}/bin/linux -lsocexplorerengine$${DEBUG_EXT}
48
49
49 win32-g++:LIBS += $${SOCEXPLORER_ROOT}/bin/win32/socexplorercommon$${DEBUG_EXT}.dll $${SOCEXPLORER_ROOT}/bin/win32/socexplorerengine$${DEBUG_EXT}.dll
50 win32-g++:LIBS += $${SOCEXPLORER_ROOT}/bin/win32/socexplorercommon$${DEBUG_EXT}.dll $${SOCEXPLORER_ROOT}/bin/win32/socexplorerengine$${DEBUG_EXT}.dll
50
51
51
52
52 unix{
53 unix{
53 translation.files = $${SOCEXPLORER_ROOT}/translations/socexplorer_fr.qm \
54 translation.files = $${SOCEXPLORER_ROOT}/translations/socexplorer_fr.qm \
54 $${SOCEXPLORER_ROOT}/translations/socexplorer_en.qm
55 $${SOCEXPLORER_ROOT}/translations/socexplorer_en.qm
55 translation.path = $${SOCEXPLORER_TRANSLATION_INSTALL_PATH}
56 translation.path = $${SOCEXPLORER_TRANSLATION_INSTALL_PATH}
56 target.path = /usr/bin
57 target.path = /usr/bin
57 INSTALLS += translation target
58 INSTALLS += translation target
58 }
59 }
59
60
60 header.path = $$[QT_INSTALL_HEADERS]/SocExplorer/common
61 header.path = $$[QT_INSTALL_HEADERS]/SocExplorer/common
61 header.files = \
62 header.files = \
62 socexplorer.h
63 socexplorer.h
63 INSTALLS += header
64 INSTALLS += header
64
65
65
66
66 SOURCES += main.cpp\
67 SOURCES += main.cpp\
67 mainwindow.cpp \
68 mainwindow.cpp \
68 PyWdgt/pythonconsole.cpp \
69 PyWdgt/pythonconsole.cpp \
69 PyWdgt/pythonqtscriptingconsoledandd.cpp \
70 PyWdgt/pythonqtscriptingconsoledandd.cpp \
70 dockablepluginmanager.cpp \
71 dockablepluginmanager.cpp \
71 toolbar.cpp \
72 toolbar.cpp \
72 toolbarcontainer.cpp \
73 toolbarcontainer.cpp \
73 regsExplorer/regsexplorer.cpp \
74 regsExplorer/regsexplorer.cpp \
74 regsExplorer/regsviewer.cpp \
75 regsExplorer/regsviewer.cpp \
75 regsExplorer/regsexplorercfg.cpp \
76 regsExplorer/regsexplorercfg.cpp \
76 aboutsocexplorer.cpp
77 aboutsocexplorer.cpp
77
78
78 # regWidget/xmltagtextedit.cpp \
79 # regWidget/xmltagtextedit.cpp \
79 # regWidget/xmltaglabeledit.cpp \
80 # regWidget/xmltaglabeledit.cpp \
80 # regWidget/xmlelementslistwidget.cpp \
81 # regWidget/xmlelementslistwidget.cpp \
81 # regWidget/xmlelementslistview.cpp \
82 # regWidget/xmlelementslistview.cpp \
82 # regWidget/regpropeditor.cpp \
83 # regWidget/regpropeditor.cpp \
83 # regWidget/registerwdgt.cpp \
84 # regWidget/registerwdgt.cpp \
84 # regWidget/registereditor.cpp \
85 # regWidget/registereditor.cpp \
85 # regWidget/registercel.cpp \
86 # regWidget/registercel.cpp \
86 # regWidget/periphpropeditor.cpp \
87 # regWidget/periphpropeditor.cpp \
87 # regWidget/peripherialregs.cpp \
88 # regWidget/peripherialregs.cpp \
88 # regWidget/bitfieldpropeditor.cpp \
89 # regWidget/bitfieldpropeditor.cpp \
89 # regWidget/bitfield.cpp
90 # regWidget/bitfield.cpp
90
91
91
92
92 HEADERS += mainwindow.h \
93 HEADERS += mainwindow.h \
93 PyWdgt/pythonconsole.h \
94 PyWdgt/pythonconsole.h \
94 PyWdgt/pythonqtscriptingconsoledandd.h \
95 PyWdgt/pythonqtscriptingconsoledandd.h \
95 dockablepluginmanager.h \
96 dockablepluginmanager.h \
96 toolbar.h \
97 toolbar.h \
97 toolbarcontainer.h \
98 toolbarcontainer.h \
98 regsExplorer/regsexplorer.h \
99 regsExplorer/regsexplorer.h \
99 regsExplorer/regsviewer.h \
100 regsExplorer/regsviewer.h \
100 regsExplorer/regsexplorercfg.h \
101 regsExplorer/regsexplorercfg.h \
101 socexplorer.h \
102 socexplorer.h \
102 SocExplorerEngine/plugins/socexplorerplugin.h \
103 SocExplorerEngine/plugins/socexplorerplugin.h \
103 aboutsocexplorer.h
104 aboutsocexplorer.h
104 # regWidget/xmltagtextedit.h \
105 # regWidget/xmltagtextedit.h \
105 # regWidget/xmltaglabeledit.h \
106 # regWidget/xmltaglabeledit.h \
106 # regWidget/xmlelementslistwidget.h \
107 # regWidget/xmlelementslistwidget.h \
107 # regWidget/xmlelementslistview.h \
108 # regWidget/xmlelementslistview.h \
108 # regWidget/regpropeditor.h \
109 # regWidget/regpropeditor.h \
109 # regWidget/registerwdgt.h \
110 # regWidget/registerwdgt.h \
110 # regWidget/registereditor.h \
111 # regWidget/registereditor.h \
111 # regWidget/registercel.h \
112 # regWidget/registercel.h \
112 # regWidget/periphpropeditor.h \
113 # regWidget/periphpropeditor.h \
113 # regWidget/peripherialregs.h \
114 # regWidget/peripherialregs.h \
114 # regWidget/bitfieldpropeditor.h \
115 # regWidget/bitfieldpropeditor.h \
115 # regWidget/bitfield.h
116 # regWidget/bitfield.h
116
117
117
118
118 include ( NicePyConsole/NicePyConsole.pri)
119 include ( NicePyConsole/NicePyConsole.pri)
119
120
120 win32{
121 win32{
121 RESOURCES = ../ressources/SocExplorer.qrc
122 RESOURCES = ../ressources/SocExplorer.qrc
122 }
123 }
123
124
124 unix{
125 unix{
125 RESOURCES = ../ressources/SocExplorer.qrc
126 RESOURCES = ../ressources/SocExplorer.qrc
126 }
127 }
127
128
128 TRANSLATIONS = ../translations/socexplorer_fr.ts \
129 TRANSLATIONS = ../translations/socexplorer_fr.ts \
129 ../translations/socexplorer_en.ts
130 ../translations/socexplorer_en.ts
130
131
131
132
132
133
133
134
134
135
135
136
136
137
Show file before | Show file after | Hide comments
@@ -1,14 +1,14
1 [Desktop Entry]
1 [Desktop Entry]
2 Version=1.0
2 Version=1.0
3 Name=SocExplorer
3 Name=SocExplorer
4 Type=Application
4 Type=Application
5 GenericName=SocExplorer
5 GenericName=SocExplorer
6
6
7 Comment=Software to monitor and explore Soc devices.
7 Comment=Software to monitor and explore Soc devices.
8
8
9 Exec=socexplorer
9 Exec=socexplorer
10 Icon=/etc/SocExplorer/logo-lpp-cutted.png
10 Icon=/usr/share/SocExplorer/Indiana_Jones_cappello.png
11 Terminal=false
11 Terminal=false
12 Type=Application
12 Type=Application
13 Categories=Application;Programming;
13 Categories=Application;Programming;
14 Name[fr_FR]=SocExplorer
14 Name[fr_FR]=SocExplorer
General Comments 0
You need to be logged in to leave comments. Login now