HG_REPOSITORIES/LPP/INSTRUMENTATION/SocExplorer Commit - r64:fb730b849667

Made possible to subclass from python plugin class....

Jeandet Alexis -

r64:fb730b849667 default

parent child

Context file:

r64:fb730b849667

Expand all files

CREDITS created 644 +3 0

			@@ -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

doc/PythonExamples/PythonPlugin.py created 644 +6 0

			@@ -0,0 +1,6
		1	#!/usr/bin/lppmon -e
		2
		3	class test(PySocExplorerEngine.socexplorerplugin):
		4	def hello(self):
		5	print "hello"
		6

ressources/images/Indiana_Jones_cappello.png created 644 binary 0 0

NO CONTENT: new file 100644, binary diff hidden

src/SocExplorerEngine/PySocExplorerEngine.h created 644 +4 0

			@@ -0,0 +1,4
		1	#include <QtCore/QObject>
		2	#include <QtWidgets/QtWidgets>
		3	#include "plugins/socexplorerplugin.h"
		4

src/SocExplorerEngine/pythonQtOut/generated_cpp/PySocExplorerEngine/PySocExplorerEngine.pri created 644 +6 0

			@@ -0,0 +1,6
		1	HEADERS += \
		2	$$PWD/PySocExplorerEngine0.h \
		3
		4	SOURCES += \
		5	$$PWD/PySocExplorerEngine0.cpp \
		6	$$PWD/PySocExplorerEngine_init.cpp

src/SocExplorerEngine/pythonQtOut/generated_cpp/PySocExplorerEngine/PySocExplorerEngine0.cpp created 644 +1328 0

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

src/SocExplorerEngine/pythonQtOut/generated_cpp/PySocExplorerEngine/PySocExplorerEngine0.h created 644 +156 0

			@@ -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

src/SocExplorerEngine/pythonQtOut/generated_cpp/PySocExplorerEngine/PySocExplorerEngine_init.cpp created 644 +8 0

			@@ -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	}

src/SocExplorerEngine/pythonQtgeneratorCfg.txt created 644 +16 0

			@@ -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

src/SocExplorerEngine/pythongenerator.sh created 644 +6 0

			@@ -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

.hgsubstate +1 -1

 c82d72694590cbc2aebb946667f11f60ea89afe src/SocExplorerEngine/PeripheralWidget
              e0f25227d6283e833fbb70c5fc1bdc6c3ca8060e src/common/genericBinaryFiles
 dce25b198558be573f56c1cf337aa95ddd666d6 src/common/lppserial
-             a4274329c9f05c742b3eb9753e77c47d27e838e9 src/common/qhexedit
+afde9cc96bb419cf898560d080ec96991aeca src/common/qhexedit

SocExplorer.pro +2 -2

              #-------------------------------------------------
              #
              # Project created by QtCreator 2011-09-19T22:52:10
              #
              #-------------------------------------------------
              TEMPLATE = subdirs
              CONFIG   += ordered release
              SUBDIRS = \
                  src/common \
                  src/SocExplorerEngine \
                  src \
                  src/SocExplorer_TCP_Terminal
              socexplorercfg.path = $$[QT_INSTALL_PREFIX]/mkspecs/features
              socexplorercfg.files = \
                  src/SocExplorerEngine/plugins/socexplorerplugin.prf
              unix{
                  SocExplorer.path = /usr/share/applications/
                  SocExplorer.files = unixcfg/SocExplorer.desktop
-                 icon.path = /etc/SocExplorer
-                 icon.files = ressources/images/logo-lpp-cutted.png
+                 icon.path = /usr/share/SocExplorer
+                 icon.files = ressources/images/Indiana_Jones_cappello.png
                  Wizard.path = /usr/share/qtcreator/templates/wizards/SocExplorerPlugin
                  Wizard.files = Qt_Creator_Wizard/SocExplorerPlugin/logo-lpp-cutted.png \
                                  Qt_Creator_Wizard/SocExplorerPlugin/plugin.cpp \
                                  Qt_Creator_Wizard/SocExplorerPlugin/plugin.h \
                                  Qt_Creator_Wizard/SocExplorerPlugin/project.pro \
                                  Qt_Creator_Wizard/SocExplorerPlugin/wizard.xml
                  INSTALLS+=Wizard SocExplorer icon
              }
                  INSTALLS+=socexplorercfg

ressources/SocExplorer.qrc +1 0

              <RCC>
                  <qresource prefix="/images">
                      <file alias="logolpp.png">images/logo-lpp.png</file>
                      <file alias="logocnrs.png">images/LOGO CNRS.png</file>
                      <file alias="logoso.png">images/LOGO SO.png</file>
                      <file alias="logolppcutted.png">images/logo-lpp-cutted.png</file>
                      <file alias="trash.svg">images/Gnome-user-trash.svg</file>
                      <file alias="refresh.svg">images/Gnome-view-refresh.svg</file>
                      <file alias="open.svg">images/Gnome-document-open.svg</file>
                      <file alias="add.svg">images/Gnome-list-add.svg</file>
                      <file alias="server.svg">images/Gnome-network-server.svg</file>
                      <file alias="config.svg">images/Gnome-preferences-system.svg</file>
                      <file alias="up.svg">images/Gnome-go-up.svg</file>
                      <file alias="down.svg">images/Gnome-go-down.svg</file>
+                     <file alias="icon.png">images/Indiana_Jones_cappello.png</file>
                  </qresource>
                  <qresource prefix="/about">
                      <file alias="about.html">txt/about.html</file>
                  </qresource>
                  <qresource prefix="/styles">
                      <file alias="SocExplorer.css">Styles/SocExplorer.css</file>
                  </qresource>
              </RCC>

ressources/txt/about.html +4 -1

              <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
              <html>
                  <head>
                  </head>
                  <body style="background-color : #dbdbdb;">
+                     <div align="center">
+                         <IMG src=":/images/icon.png" alt="SocExplorer" width="80" height="54" align="center" border="0" >
+                     </div>
              	<div align="center">
              		<a href="http://www.cnrs.fr/"> <IMG src=":/images/logocnrs.png" alt="CNRS" width="47" height="47" align="top" border="0" ></a>
              		<a href="http://www.lpp.fr/"> <IMG src=":/images/logolpp.png" width="158" height="47" align="top" border="0" ></a>
                              <a href="http://www.solarorbiter.org/"> <IMG src=":/images/logoso.png" width="64" height="47" align="top" border="0" ></a>
              	</div>
              	<hr>
                      <div align="center">
                          <B style="font-size : 150%;">About SocExplorer</B>
                      </div>
              	<hr>
              	<div align="center">
                              <B>SocExplorer Version $VERSION$.</B><BR><BR>
                              <B> Build from Changeset $Changeset$.</B><BR><BR>
                              <B> Branch $Branch$.</B><BR><BR>
                              Copyright (C) 2011-2014 Plasmas Physic Laboratory.<BR>
              		This is free software; licenced under the terms of the GPLV2 license.<BR><BR>
              		This program uses:
              		<div align="left"  style="margin-left : 50%;">
              			<ul>
                                              <LI><a href="http://qt.digia.com/" title="Qt">Qt</a> (Copyright 2008-2014 Digia Plc).</LI>
              				<LI><a href="http://pythonqt.sourceforge.net" title="PythonQt">PythonQt</a> </LI>
              				<LI><a href="http://commons.wikimedia.org/wiki/GNOME_Desktop_icons" title="Gnome Icons">Gnome Icons</a> </LI>
              				<LI><a href="http://nsis.sourceforge.net/Main_Page" title="NSIS">NSIS</a> (Nullsoft Scriptable Install System) </LI>
              				<LI><a href="https://hephaistos.lpp.polytechnique.fr/rhodecode/HG_REPOSITORIES/LPP/INSTRUMENTATION/lppserial" title="LppSerial">LppSerial</a></LI>
                                              <LI><a href="http://www.qcustomplot.com/index.php/introduction" title="qhexedit">QCustomPlot</a></LI>
              				<LI><a href="http://code.google.com/p/qhexedit2/" title="qhexedit">QHexEdit</a></LI>
+                                             <LI><a href="http://commons.wikimedia.org/wiki/File:Indiana_Jones_cappello.png" title="Indiana Jones cappello icon">Indiana Jones cappello icon</a></LI>
              			</ul>
              		</div>
              	</div>
                  </body>
              </html>

src/PyWdgt/pythonconsole.cpp +2 -1

              #include "pythonconsole.h"
              #include <QPushButton>
              #include <QFile>
              #include <QTextStream>
              #include <QCustomPlot/qcustomplot.h>
              #include "../common/pythonQtOut/generated_cpp/PySocExplorer/PySocExplorer0.h"
              #include <PythonQt.h>
              #include "pluginloader.h"
              #include <socexplorer.h>
              void PythonQt_init_PySocExplorer(PyObject* module);
+             void PythonQt_init_PySocExplorerEngine(PyObject* module) ;
              PythonConsole::PythonConsole(socexplorerproxy *proxy, QWidget *parent) :
                  QWidget(parent)
              {
                  //PythonQt::init();
                  PythonQt::init(PythonQt::RedirectStdOut);
                  PythonQt_QtAll::init();
                  this->proxy = proxy;
                  this->mainlayout = new QHBoxLayout;
                  this->mainContext = new PythonQtObjectPtr(PythonQt::self()->getMainModule());
                  this->mainContext->addVariable(QString("PYMODULES"),QVariant(QString(PYMODULES)));
                  this->console = new PythonQtScriptingConsoleDandD(NULL, PythonQt::self()->getMainModule());
                  this->mainlayout->addWidget(this->console);
                  this->setWindowTitle(tr("Python Scripting Console"));
                  this->bussdriver = 0;
                  this->setAcceptDrops(true);
                  this->setLayout(this->mainlayout);
                  connect(this->console,SIGNAL(pyConsoleRunFiles(QStringList)),this,SLOT(pyConsoleRunFiles(QStringList)));
                  this->mainContext->addObject("proxy", proxy);
                  PythonQt_init_PySocExplorer(0);
+                 PythonQt_init_PySocExplorerEngine(0);
                  this->mainContext->evalScript(QString("from PythonQt import *"));
              }
              void PythonConsole::addObject(const QString& name, QObject* object)
              {
                  this->mainContext->addObject(name, object);
              }
              void PythonConsole::setBussDriver(socexplorerplugin *driver)
              {
                  this->bussdriver = driver;
                  this->mainContext->addObject("buss", this->bussdriver);
              }
              void PythonConsole::registerObject(QObject* object,const QString& instanceName)
              {
                  this->mainContext->addObject(instanceName,object);
              }
              void PythonConsole::changeSysDriverInstName(const QString newinstanceName,const QString previnstanceName)
              {
                  socexplorerplugin* obj= this->proxy->getSysDriver(previnstanceName);
                  if(obj==NULL)obj= this->proxy->getSysDriver(newinstanceName);
                  if(obj==NULL)return;
                  this->mainContext->addObject(newinstanceName,obj->getPyObjectWrapper());
                  this->mainContext->removeVariable(previnstanceName);
              }
              void PythonConsole::removeDriver(const QString& instanceName)
              {
                  this->mainContext->removeVariable(instanceName);
              }
              void PythonConsole::removeBussDriver()
              {
                  this->bussdriver = 0;
                  this->mainContext->removeVariable("buss");
                  emit this->rootDriverDelete();
              }
              void PythonConsole::pyConsoleRunFiles(const QStringList & pathList)
              {
                  for (int i = 0; i < pathList.size() && i < 32; ++i)
                  {
                      this->pyConsoleRunFile(pathList.at(i));
                  }
              }
              void PythonConsole::pyConsoleRunFile(const QString& fileName)
              {
                  QString code;
                  QFile file;
                  QFileInfo fileinfo;
                  code.clear();
                  file.setFileName(fileName);
                  fileinfo.setFile(fileName);
                  if(!fileinfo.suffix().compare("py"))
                  {
                      QString CMD="execfile(\'"+fileName+"\')";
                      this->console->executePythonCommand(CMD);
                  }
              }
              QSize PythonConsole::sizeHint()
              {
                  return QSize(800,80);
              }

src/SocExplorerEngine/SocExplorerEngine.pro +5 -2

              SOCEXPLORER_ROOT = \"$${PWD}/../..\"
              include($${PWD}/../../build_cfg/socexplorer.pri)
              TARGET = socexplorerengine$${DEBUG_EXT}
              TEMPLATE = lib
              #more verbose plugin loader to debug plugin loading issues such as dependencies issues
              SOCEXPLORER_PLUGIN_LOADER="custom"
              SOCEXPLORER_CHAGESETNUM=$$system(hg id)
              SOCEXPLORER_CHAGESETNUMSTR = '\\"$${SOCEXPLORER_CHAGESETNUM}\\"'
              SOCEXPLORER_BRANCH=$$system(hg branch)
              SOCEXPLORER_BRANCHSTR = '\\"$${SOCEXPLORER_BRANCH}\\"'
              DEFINES += SOCEXPLORER_VERSION="\"\\\"0.2.2"\\\"\"
              DEFINES += SOCEXPLORER_CHAGESET=\"$${SOCEXPLORER_CHAGESETNUMSTR}\"
              DEFINES += SOCEXPLORER_BRANCH=\"$${SOCEXPLORER_BRANCHSTR}\"
              message("Building SOCEXPLORER changeset $${SOCEXPLORER_CHAGESETNUM}")
              DEFINES += SOCEXPLORER_EXPORTS
              include ( plugins/socexplorerplugin.prf )
              include ( PeripheralWidget/PeripheralWidget.pri)
              win32:CONFIG += dll
              win32:CONFIG -= static
              win32:LIBS+=-L$${SOCEXPLORER_ROOT}/bin/win32 -lsocexplorercommon$${DEBUG_EXT}
              contains(SOCEXPLORER_PLUGIN_LOADER,"custom")
              {
                  unix:LIBS+= -ldl
                  unix:DEFINES += SOCEXPLORER_CUSTOM_PLUGIN_LOADER
                  unix:HEADERS += \
                  pluginloader/unix/unixpluginloader.h
                  unix:SOURCES += \
                  pluginloader/unix/unixpluginloader.cpp
              }
              target.path = $$[QT_INSTALL_LIBS]
              isEmpty(target.path) {
                      error(can\'t get QT_INSTALL_LIBS)
              }
              header.path = $$[QT_INSTALL_HEADERS]/SocExplorer
              header.files = engine/socexplorerengine.h \
                              pluginloader/pluginscache.h \
                              plugins/socexplorerplugin.h \
                              proxy/socexplorerproxy.h \
                              engine/socexplorerxmlfile.h \
                              SOC/socexplorerenumdevice.h \
                              plugins/genericPySysdriver.h \
                              XmlEngine/XMLmodel.h \
                              XmlEngine/XMLdata.h \
                              XmlEngine/xmldriver.h \
                              SOC/socmodel.h \
                              SOC/registerdata.h \
                              SOC/socclk.h \
                              PeripheralWidget/src/peripheralwidget.h \
                              PeripheralWidget/src/registerwidget.h \
                              PeripheralWidget/src/socregsviewer.h
              isEmpty(header.path) {
                      error(can\'t get QT_INSTALL_HEADERS)
              }
              pluginif.files = pluginsInterface/*.h \
                              pluginsInterface/*.cpp
              pluginif.path = $$[QT_INSTALL_HEADERS]/SocExplorer/pluginsInterface
              INSTALLS += target header pluginif
              INCLUDEPATH += engine \
                  pluginloader \
                  pluginsInterface \
                  proxy \
                  plugins \
                  pluginManagerWdgt \
                  ../common \
                  ../ \
                  RegisterMVS \
                  XmlEngine \
                  SOC \
                  PeripheralWidget/src
              HEADERS += \
                  pluginloader/pluginscache.h \
                  pluginloader/pluginloader.h \
                  plugins/genericPySysdriver.h \
                  pluginManagerWdgt/plugintree.h \
                  pluginManagerWdgt/pluginmanagerWDGT.h \
                  pluginManagerWdgt/pluginlist.h \
                  pluginManagerWdgt/plugininfoswdgt.h \
                  XmlEngine/XMLmodel.h \
                  XmlEngine/XMLdata.h \
                  SOC/socmodel.h  \
                  SOC/registerdata.h \
                  XmlEngine/xmldriver.h \
                  PeripheralWidget/src/peripheralwidget.h \
                  PeripheralWidget/src/registerwidget.h \
                  PeripheralWidget/src/socregsviewer.h \
                  SOC/socclk.h \
                  engine/socexplorerengine.h \
                  engine/socexplorerxmlfile.h \
                  plugins/socexplorerplugin.h \
                  pluginsInterface/socexplorerplugininterface.h \
                  pluginsInterface/socexplorerplugininterface_global.h \
                  proxy/socexplorerproxy.h \
-                 SOC/socexplorerenumdevice.h
+                 SOC/socexplorerenumdevice.h \
+                 PySocExplorerEngine.h
              SOURCES += \
                  pluginloader/pluginscache.cpp \
                  pluginloader/pluginloader.cpp \
                  pluginManagerWdgt/plugintree.cpp \
                  pluginManagerWdgt/pluginmanagerWDGT.cpp \
                  pluginManagerWdgt/pluginlist.cpp \
                  pluginManagerWdgt/plugininfoswdgt.cpp \
                  XmlEngine/XMLmodel.cpp \
                  XmlEngine/XMLdata.cpp \
                  SOC/socmodel.cpp \
                  SOC/registerdata.cpp \
                  XmlEngine/xmldriver.cpp \
                  PeripheralWidget/src/peripheralwidget.cpp \
                  PeripheralWidget/src/registerwidget.cpp \
                  PeripheralWidget/src/socregsviewer.cpp \
                  SOC/socclk.cpp \
                  plugins/genericPySysdriver.cpp \
                  engine/socexplorerengine.cpp \
                  engine/socexplorerxmlfile.cpp \
                  proxy/socexplorerproxy.cpp \
                  SOC/socexplorerenumdevice.cpp \
                  plugins/socexplorerplugin.cpp
              OTHER_FILES += \
                  plugins/socexplorerplugin.cpp \
                  pluginsInterface/socexplorerplugininterface.cpp \
-                 plugins/socexplorerplugin.prf
+                 plugins/socexplorerplugin.prf \
+                 pythongenerator.sh \
+                 pythonQtgeneratorCfg.txt

src/common/PySocExplorer.h +1 0

              #include <QtCore/QObject>
              #include <QtWidgets/QtWidgets>
              #include "qhexspinbox.h"
              #include "memsizewdgt.h"
              #include "qhexedit/qhexedit.h"
              #include "SocExplorerPlot.h"
              #include "tcp_terminal_client.h"
              #include "QCustomPlot/qcustomplot.h"
              #include "genericBinaryFiles/abstractbinfile.h"
              #include "genericBinaryFiles/elf/elfparser.h"
              #include "genericBinaryFiles/elf/elffile.h"
              #include "genericBinaryFiles/elf/elffilewidget.h"
              #include "genericBinaryFiles/elf/elfinfowdgt.h"
              #include "genericBinaryFiles/srec/srecfile.h"
              #include "genericBinaryFiles/srec/srecfilewidget.h"
              #include "genericBinaryFiles/BinFile/binaryfile.h"
              #include "genericBinaryFiles/BinFile/binaryfilewidget.h"
+             #include "genericBinaryFiles/genericbinaryfilewidget.h"

src/common/common.pro +3 0

              SOCEXPLORER_ROOT = \"$${PWD}/../..\"
              include($${PWD}/../../build_cfg/socexplorer.pri)
              include($${PWD}/lppserial/lppserial.pri)
              TEMPLATE = lib
              TARGET = socexplorercommon$${DEBUG_EXT}
              win32:CONFIG += dll
              win32:CONFIG -= static
              win32:INCLUDEPATH += $${PWD}/genericBinaryFiles/elf/libelfWin32/include
              win32:INCLUDEPATH += $${PWD}/genericBinaryFiles/elf/libelfWin32/include/libelf
              win32:DEFINES+=_ELF_WINDOWS_
              DEFINES+=RS232_debug
              win32:LIBS += $${PWD}/genericBinaryFiles/elf/libelfWin32/bin/libelf.a
              unix:LIBS += -lelf
              QMAKE_LFLAGS_RELEASE += --enable-auto-import
              QMAKE_LFLAGS_DEBUG += --enable-auto-import
              target.path = $$[QT_INSTALL_LIBS]
              isEmpty(target.path) {
                 error(can\'t get QT_INSTALL_LIBS)
              }
              header.path = $$[QT_INSTALL_HEADERS]/SocExplorer/common
              header.files = \
                  memsizewdgt.h \
                  qhexspinbox.h \
                  qsvgicon.h \
                  qhexedit/qhexedit_p.h \
                  qhexedit/qhexedit.h \
                  qhexedit/xbytearray.h \
                  QCustomPlot/qcustomplot.h \
                  SocExplorerPlot.h \
                  tcp_terminal_client.h \
                  genericBinaryFiles/elf/elfinfowdgt.h \
                  genericBinaryFiles/elf/elfparser.h \
                  genericBinaryFiles/elf/elffile.h \
                  genericBinaryFiles/elf/elffilewidget.h \
                  qipdialogbox.h \
                  lppserial/src/RS232.h \
                  qtablewidgetintitem.h \
                  genericBinaryFiles/srec/srecfile.h \
                  genericBinaryFiles/srec/srecfilewidget.h \
                  genericBinaryFiles/BinFile/binaryfile.h \
                  genericBinaryFiles/BinFile/binaryfilewidget.h \
                  genericBinaryFiles/abstractbinfile.h \
                  genericBinaryFiles/qvpushbutton.h \
                  genericBinaryFiles/qtablewidgetintitem.h \
                  genericBinaryFiles/filelist.h
              win32{
                  elfheader.path = $$[QT_INSTALL_HEADERS]/SocExplorer/common/genericBinaryFiles/libelf
                  elfheader.files += \
                      genericBinaryFiles/elf/libelfWin32/include/libelf/byteswap.h  \
                      genericBinaryFiles/elf/libelfWin32/include/libelf/errors.h     \
                      genericBinaryFiles/elf/libelfWin32/include/libelf/gelf.h    \
                      genericBinaryFiles/elf/libelfWin32/include/libelf/nlist.h    \
                      genericBinaryFiles/elf/libelfWin32/include/libelf/sys_elf.h  \
                      genericBinaryFiles/elf/libelfWin32/include/libelf/verneed.h \
                      genericBinaryFiles/elf/libelfWin32/include/libelf/elf_repl.h \
                      genericBinaryFiles/elf/libelfWin32/include/libelf/ext_types.h \
                      genericBinaryFiles/elf/libelfWin32/include/libelf/libelf.h  \
                      genericBinaryFiles/elf/libelfWin32/include/libelf/private.h  \
                      genericBinaryFiles/elf/libelfWin32/include/libelf/verdef.h
                  INSTALLS += elfheader
              }
              isEmpty(header.path) {
                 error(can\'t get QT_INSTALL_HEADERS)
              }
              INSTALLS += target header
              INCLUDEPATH += QCustomPlot qhexedit   genericBinaryFiles genericBinaryFiles/srec  genericBinaryFiles/BinFile
              HEADERS += \
                  memsizewdgt.h \
                  qhexspinbox.h \
                  qsvgicon.h \
                  qhexedit/qhexedit_p.h \
                  qhexedit/qhexedit.h \
                  qhexedit/xbytearray.h \
                  qhexedit/commands.h \
                  QCustomPlot/qcustomplot.h \
                  tcp_terminal_client.h \
                  genericBinaryFiles/elf/elfinfowdgt.h \
                  genericBinaryFiles/elf/elfparser.h \
                  genericBinaryFiles/elf/elffile.h \
                  qipdialogbox.h \
                  PySocExplorer.h \
                  SocExplorerPlot.h \
                  genericBinaryFiles/elf/elffilewidget.h \
                  genericBinaryFiles/srec/srecfile.h \
                  genericBinaryFiles/srec/srecfilewidget.h \
                  genericBinaryFiles/abstractbinfile.h \
                  genericBinaryFiles/BinFile/binaryfile.h \
                  genericBinaryFiles/BinFile/binaryfilewidget.h \
                  genericBinaryFiles/genericbinaryfilewidget.h \
                  genericBinaryFiles/qvpushbutton.h \
                  genericBinaryFiles/qtablewidgetintitem.h \
                  genericBinaryFiles/filelist.h
              SOURCES += \
                  memsizewdgt.cpp \
                  qhexspinbox.cpp \
                  qsvgicon.cpp \
                  qhexedit/qhexedit_p.cpp \
                  qhexedit/qhexedit.cpp \
                  qhexedit/xbytearray.cpp \
                  qhexedit/commands.cpp \
                  QCustomPlot/qcustomplot.cpp \
                  tcp_terminal_client.cpp \
                  genericBinaryFiles/elf/elfinfowdgt.cpp \
                  genericBinaryFiles/elf/elfparser.cpp \
                  genericBinaryFiles/elf/elffile.cpp \
                  qipdialogbox.cpp \
                  SocExplorerPlot.cpp \
                  genericBinaryFiles/elf/elffilewidget.cpp \
                  genericBinaryFiles/srec/srecfile.cpp \
                  genericBinaryFiles/srec/srecfilewidget.cpp \
                  genericBinaryFiles/abstractbinfile.cpp \
                  genericBinaryFiles/BinFile/binaryfile.cpp \
                  genericBinaryFiles/BinFile/binaryfilewidget.cpp \
                  genericBinaryFiles/genericbinaryfilewidget.cpp \
                  genericBinaryFiles/qvpushbutton.cpp \
                  genericBinaryFiles/qtablewidgetintitem.cpp \
                  genericBinaryFiles/filelist.cpp
              FORMS += \
                  genericBinaryFiles/elf/elffilewidget.ui \
                  genericBinaryFiles/srec/srecfilewidget.ui \
                  genericBinaryFiles/BinFile/binaryfilewidget.ui \
                  genericBinaryFiles/genericbinaryfilewidget.ui
              OTHER_FILES += \
                  ./pythongenerator.sh \
                  ./pythonQtgeneratorCfg.txt
+             RESOURCES += \
+                 genericBinaryFiles/genericBinaryFiles.qrc

src/common/pythonQtOut/generated_cpp/PySocExplorer/PySocExplorer0.cpp +923 -5

              #include "PySocExplorer0.h"
              #include <PythonQtConversion.h>
              #include <PythonQtMethodInfo.h>
              #include <PythonQtSignalReceiver.h>
              #include <QIconEngine>
-             #include <QObject>
-             #include <QSpinBox>
              #include <QVariant>
-             #include <QWidget>
              #include <abstractbinfile.h>
-             #include <elffile.h>
              #include <elfparser.h>
              #include <qaction.h>
              #include <qbitmap.h>
              #include <qbytearray.h>
              #include <qcolor.h>
              #include <qcoreevent.h>
              #include <qcursor.h>
              #include <qevent.h>
              #include <qfile.h>
              #include <qfont.h>
              #include <qgraphicseffect.h>
              #include <qgraphicsproxywidget.h>
              #include <qkeysequence.h>
              #include <qlayout.h>
              #include <qlineedit.h>
              #include <qlist.h>
              #include <qlocale.h>
              #include <qmargins.h>
              #include <qobject.h>
              #include <qpaintdevice.h>
              #include <qpaintengine.h>
              #include <qpainter.h>
              #include <qpalette.h>
              #include <qpen.h>
              #include <qpixmap.h>
              #include <qpoint.h>
              #include <qrect.h>
              #include <qregion.h>
              #include <qscrollarea.h>
              #include <qscrollbar.h>
              #include <qsize.h>
              #include <qsizepolicy.h>
              #include <qspinbox.h>
              #include <qstringlist.h>
              #include <qstyle.h>
              #include <qstyleoption.h>
              #include <qwidget.h>
              PythonQtShell_ElfFile::~PythonQtShell_ElfFile() {
                PythonQtPrivate* priv = PythonQt::priv();
                if (priv) { priv->shellClassDeleted(this); }
              }
              int  PythonQtShell_ElfFile::closeFile()
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "closeFile");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"int"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
                    int returnValue;
                  void* args[1] = {NULL};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) {
                    args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
                    if (args[0]!=&returnValue) {
                      if (args[0]==NULL) {
                        PythonQt::priv()->handleVirtualOverloadReturnError("closeFile", methodInfo, result);
                      } else {
                        returnValue = *((int*)args[0]);
                      }
                    }
                  }
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return returnValue;
                }
              }
                return ElfFile::closeFile();
              }
              QList<codeFragment* >  PythonQtShell_ElfFile::getFragments()
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getFragments");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"QList<codeFragment* >"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
                    QList<codeFragment* > returnValue;
                  void* args[1] = {NULL};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) {
                    args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
                    if (args[0]!=&returnValue) {
                      if (args[0]==NULL) {
                        PythonQt::priv()->handleVirtualOverloadReturnError("getFragments", methodInfo, result);
                      } else {
                        returnValue = *((QList<codeFragment* >*)args[0]);
                      }
                    }
                  }
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return returnValue;
                }
              }
                return ElfFile::getFragments();
              }
              bool  PythonQtShell_ElfFile::isopened()
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "isopened");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"bool"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
                    bool returnValue;
                  void* args[1] = {NULL};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) {
                    args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
                    if (args[0]!=&returnValue) {
                      if (args[0]==NULL) {
                        PythonQt::priv()->handleVirtualOverloadReturnError("isopened", methodInfo, result);
                      } else {
                        returnValue = *((bool*)args[0]);
                      }
                    }
                  }
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return returnValue;
                }
              }
                return ElfFile::isopened();
              }
              bool  PythonQtShell_ElfFile::openFile(const QString&  File)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "openFile");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"bool" , "const QString&"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                    bool returnValue;
                  void* args[2] = {NULL, (void*)&File};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) {
                    args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
                    if (args[0]!=&returnValue) {
                      if (args[0]==NULL) {
                        PythonQt::priv()->handleVirtualOverloadReturnError("openFile", methodInfo, result);
                      } else {
                        returnValue = *((bool*)args[0]);
                      }
                    }
                  }
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return returnValue;
                }
              }
                return ElfFile::openFile(File);
              }
              bool  PythonQtShell_ElfFile::toBinary(const QString&  File)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "toBinary");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"bool" , "const QString&"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                    bool returnValue;
                  void* args[2] = {NULL, (void*)&File};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) {
                    args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
                    if (args[0]!=&returnValue) {
                      if (args[0]==NULL) {
                        PythonQt::priv()->handleVirtualOverloadReturnError("toBinary", methodInfo, result);
                      } else {
                        returnValue = *((bool*)args[0]);
                      }
                    }
                  }
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return returnValue;
                }
              }
                return ElfFile::toBinary(File);
              }
              bool  PythonQtShell_ElfFile::toSrec(const QString&  File)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "toSrec");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"bool" , "const QString&"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                    bool returnValue;
                  void* args[2] = {NULL, (void*)&File};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) {
                    args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
                    if (args[0]!=&returnValue) {
                      if (args[0]==NULL) {
                        PythonQt::priv()->handleVirtualOverloadReturnError("toSrec", methodInfo, result);
                      } else {
                        returnValue = *((bool*)args[0]);
                      }
                    }
                  }
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return returnValue;
                }
              }
                return ElfFile::toSrec(File);
              }
              ElfFile* PythonQtWrapper_ElfFile::new_ElfFile()
              {
              return new PythonQtShell_ElfFile(); }
              ElfFile* PythonQtWrapper_ElfFile::new_ElfFile(const QString&  File)
              {
              return new PythonQtShell_ElfFile(File); }
              int  PythonQtWrapper_ElfFile::closeFile(ElfFile* theWrappedObject)
              {
                return ( ((PythonQtPublicPromoter_ElfFile*)theWrappedObject)->promoted_closeFile());
              }
              QString  PythonQtWrapper_ElfFile::getABI(ElfFile* theWrappedObject)
              {
                return ( theWrappedObject->getABI());
              }
              QString  PythonQtWrapper_ElfFile::getArchitecture(ElfFile* theWrappedObject)
              {
                return ( theWrappedObject->getArchitecture());
              }
              QString  PythonQtWrapper_ElfFile::getClass(ElfFile* theWrappedObject)
              {
                return ( theWrappedObject->getClass());
              }
              QString  PythonQtWrapper_ElfFile::getEndianness(ElfFile* theWrappedObject)
              {
                return ( theWrappedObject->getEndianness());
              }
              qint64  PythonQtWrapper_ElfFile::getEntryPointAddress(ElfFile* theWrappedObject)
              {
                return ( theWrappedObject->getEntryPointAddress());
              }
              QList<codeFragment* >  PythonQtWrapper_ElfFile::getFragments(ElfFile* theWrappedObject)
              {
                return ( ((PythonQtPublicPromoter_ElfFile*)theWrappedObject)->promoted_getFragments());
              }
              QList<codeFragment* >  PythonQtWrapper_ElfFile::getFragments(ElfFile* theWrappedObject, QStringList  fragmentList)
              {
                return ( theWrappedObject->getFragments(fragmentList));
              }
              int  PythonQtWrapper_ElfFile::getSectionCount(ElfFile* theWrappedObject)
              {
                return ( theWrappedObject->getSectionCount());
              }
              bool  PythonQtWrapper_ElfFile::getSectionData(ElfFile* theWrappedObject, int  index, char**  buffer)
              {
                return ( theWrappedObject->getSectionData(index, buffer));
              }
              qint64  PythonQtWrapper_ElfFile::getSectionDatasz(ElfFile* theWrappedObject, int  index)
              {
                return ( theWrappedObject->getSectionDatasz(index));
              }
              int  PythonQtWrapper_ElfFile::getSectionIndex(ElfFile* theWrappedObject, QString  name)
              {
                return ( theWrappedObject->getSectionIndex(name));
              }
              qint64  PythonQtWrapper_ElfFile::getSectionMemsz(ElfFile* theWrappedObject, int  index)
              {
                return ( theWrappedObject->getSectionMemsz(index));
              }
              QString  PythonQtWrapper_ElfFile::getSectionName(ElfFile* theWrappedObject, int  index)
              {
                return ( theWrappedObject->getSectionName(index));
              }
              qint64  PythonQtWrapper_ElfFile::getSectionPaddr(ElfFile* theWrappedObject, int  index)
              {
                return ( theWrappedObject->getSectionPaddr(index));
              }
              QString  PythonQtWrapper_ElfFile::getSectionType(ElfFile* theWrappedObject, int  index)
              {
                return ( theWrappedObject->getSectionType(index));
              }
              int  PythonQtWrapper_ElfFile::getSegmentCount(ElfFile* theWrappedObject)
              {
                return ( theWrappedObject->getSegmentCount());
              }
              qint64  PythonQtWrapper_ElfFile::getSegmentFilesz(ElfFile* theWrappedObject, int  index)
              {
                return ( theWrappedObject->getSegmentFilesz(index));
              }
              QString  PythonQtWrapper_ElfFile::getSegmentFlags(ElfFile* theWrappedObject, int  index)
              {
                return ( theWrappedObject->getSegmentFlags(index));
              }
              qint64  PythonQtWrapper_ElfFile::getSegmentMemsz(ElfFile* theWrappedObject, int  index)
              {
                return ( theWrappedObject->getSegmentMemsz(index));
              }
              qint64  PythonQtWrapper_ElfFile::getSegmentOffset(ElfFile* theWrappedObject, int  index)
              {
                return ( theWrappedObject->getSegmentOffset(index));
              }
              qint64  PythonQtWrapper_ElfFile::getSegmentPaddr(ElfFile* theWrappedObject, int  index)
              {
                return ( theWrappedObject->getSegmentPaddr(index));
              }
              QString  PythonQtWrapper_ElfFile::getSegmentType(ElfFile* theWrappedObject, int  index)
              {
                return ( theWrappedObject->getSegmentType(index));
              }
              qint64  PythonQtWrapper_ElfFile::getSegmentVaddr(ElfFile* theWrappedObject, int  index)
              {
                return ( theWrappedObject->getSegmentVaddr(index));
              }
              quint64  PythonQtWrapper_ElfFile::getSymbolAddress(ElfFile* theWrappedObject, int  index)
              {
                return ( theWrappedObject->getSymbolAddress(index));
              }
              int  PythonQtWrapper_ElfFile::getSymbolCount(ElfFile* theWrappedObject)
              {
                return ( theWrappedObject->getSymbolCount());
              }
              QString  PythonQtWrapper_ElfFile::getSymbolLinkType(ElfFile* theWrappedObject, int  index)
              {
                return ( theWrappedObject->getSymbolLinkType(index));
              }
              QString  PythonQtWrapper_ElfFile::getSymbolName(ElfFile* theWrappedObject, int  index)
              {
                return ( theWrappedObject->getSymbolName(index));
              }
              int  PythonQtWrapper_ElfFile::getSymbolSectionIndex(ElfFile* theWrappedObject, int  index)
              {
                return ( theWrappedObject->getSymbolSectionIndex(index));
              }
              QString  PythonQtWrapper_ElfFile::getSymbolSectionName(ElfFile* theWrappedObject, int  index)
              {
                return ( theWrappedObject->getSymbolSectionName(index));
              }
              quint64  PythonQtWrapper_ElfFile::getSymbolSize(ElfFile* theWrappedObject, int  index)
              {
                return ( theWrappedObject->getSymbolSize(index));
              }
              QString  PythonQtWrapper_ElfFile::getSymbolType(ElfFile* theWrappedObject, int  index)
              {
                return ( theWrappedObject->getSymbolType(index));
              }
              QString  PythonQtWrapper_ElfFile::getType(ElfFile* theWrappedObject)
              {
                return ( theWrappedObject->getType());
              }
              qint64  PythonQtWrapper_ElfFile::getVersion(ElfFile* theWrappedObject)
              {
                return ( theWrappedObject->getVersion());
              }
              bool  PythonQtWrapper_ElfFile::static_ElfFile_isElf(const QString&  File)
              {
                return (ElfFile::isElf(File));
              }
              bool  PythonQtWrapper_ElfFile::iself(ElfFile* theWrappedObject)
              {
                return ( theWrappedObject->iself());
              }
              bool  PythonQtWrapper_ElfFile::isopened(ElfFile* theWrappedObject)
              {
                return ( ((PythonQtPublicPromoter_ElfFile*)theWrappedObject)->promoted_isopened());
              }
              bool  PythonQtWrapper_ElfFile::openFile(ElfFile* theWrappedObject, const QString&  File)
              {
                return ( ((PythonQtPublicPromoter_ElfFile*)theWrappedObject)->promoted_openFile(File));
              }
              bool  PythonQtWrapper_ElfFile::sectionIsNobits(ElfFile* theWrappedObject, int  index)
              {
                return ( theWrappedObject->sectionIsNobits(index));
              }
              bool  PythonQtWrapper_ElfFile::toBinary(ElfFile* theWrappedObject, const QString&  File)
              {
                return ( ((PythonQtPublicPromoter_ElfFile*)theWrappedObject)->promoted_toBinary(File));
              }
              bool  PythonQtWrapper_ElfFile::toSrec(ElfFile* theWrappedObject, const QString&  File)
              {
                return ( ((PythonQtPublicPromoter_ElfFile*)theWrappedObject)->promoted_toSrec(File));
              }
              PythonQtShell_MemSizeWdgt::~PythonQtShell_MemSizeWdgt() {
                PythonQtPrivate* priv = PythonQt::priv();
                if (priv) { priv->shellClassDeleted(this); }
              }
              void PythonQtShell_MemSizeWdgt::actionEvent(QActionEvent*  arg__1)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "actionEvent");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "QActionEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                MemSizeWdgt::actionEvent(arg__1);
              }
              void PythonQtShell_MemSizeWdgt::changeEvent(QEvent*  arg__1)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "changeEvent");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "QEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                MemSizeWdgt::changeEvent(arg__1);
              }
              void PythonQtShell_MemSizeWdgt::childEvent(QChildEvent*  arg__1)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "childEvent");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "QChildEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                MemSizeWdgt::childEvent(arg__1);
              }
              void PythonQtShell_MemSizeWdgt::closeEvent(QCloseEvent*  arg__1)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "closeEvent");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "QCloseEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                MemSizeWdgt::closeEvent(arg__1);
              }
              void PythonQtShell_MemSizeWdgt::contextMenuEvent(QContextMenuEvent*  arg__1)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "contextMenuEvent");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "QContextMenuEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                MemSizeWdgt::contextMenuEvent(arg__1);
              }
              void PythonQtShell_MemSizeWdgt::customEvent(QEvent*  arg__1)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "customEvent");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "QEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                MemSizeWdgt::customEvent(arg__1);
              }
              int  PythonQtShell_MemSizeWdgt::devType() const
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "devType");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"int"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
                    int returnValue;
                  void* args[1] = {NULL};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) {
                    args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
                    if (args[0]!=&returnValue) {
                      if (args[0]==NULL) {
                        PythonQt::priv()->handleVirtualOverloadReturnError("devType", methodInfo, result);
                      } else {
                        returnValue = *((int*)args[0]);
                      }
                    }
                  }
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return returnValue;
                }
              }
                return MemSizeWdgt::devType();
              }
              void PythonQtShell_MemSizeWdgt::dragEnterEvent(QDragEnterEvent*  arg__1)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragEnterEvent");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "QDragEnterEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                MemSizeWdgt::dragEnterEvent(arg__1);
              }
              void PythonQtShell_MemSizeWdgt::dragLeaveEvent(QDragLeaveEvent*  arg__1)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragLeaveEvent");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "QDragLeaveEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                MemSizeWdgt::dragLeaveEvent(arg__1);
              }
              void PythonQtShell_MemSizeWdgt::dragMoveEvent(QDragMoveEvent*  arg__1)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragMoveEvent");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "QDragMoveEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                MemSizeWdgt::dragMoveEvent(arg__1);
              }
              void PythonQtShell_MemSizeWdgt::dropEvent(QDropEvent*  arg__1)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dropEvent");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "QDropEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                MemSizeWdgt::dropEvent(arg__1);
              }
              void PythonQtShell_MemSizeWdgt::enterEvent(QEvent*  arg__1)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "enterEvent");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "QEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                MemSizeWdgt::enterEvent(arg__1);
              }
              bool  PythonQtShell_MemSizeWdgt::event(QEvent*  arg__1)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "event");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"bool" , "QEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                    bool returnValue;
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) {
                    args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
                    if (args[0]!=&returnValue) {
                      if (args[0]==NULL) {
                        PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
                      } else {
                        returnValue = *((bool*)args[0]);
                      }
                    }
                  }
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return returnValue;
                }
              }
                return MemSizeWdgt::event(arg__1);
              }
              bool  PythonQtShell_MemSizeWdgt::eventFilter(QObject*  arg__1, QEvent*  arg__2)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "eventFilter");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
                    bool returnValue;
                  void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) {
                    args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
                    if (args[0]!=&returnValue) {
                      if (args[0]==NULL) {
                        PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
                      } else {
                        returnValue = *((bool*)args[0]);
                      }
                    }
                  }
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return returnValue;
                }
              }
                return MemSizeWdgt::eventFilter(arg__1, arg__2);
              }
              void PythonQtShell_MemSizeWdgt::focusInEvent(QFocusEvent*  arg__1)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusInEvent");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "QFocusEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                MemSizeWdgt::focusInEvent(arg__1);
              }
              bool  PythonQtShell_MemSizeWdgt::focusNextPrevChild(bool  next)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusNextPrevChild");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"bool" , "bool"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                    bool returnValue;
                  void* args[2] = {NULL, (void*)&next};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) {
                    args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
                    if (args[0]!=&returnValue) {
                      if (args[0]==NULL) {
                        PythonQt::priv()->handleVirtualOverloadReturnError("focusNextPrevChild", methodInfo, result);
                      } else {
                        returnValue = *((bool*)args[0]);
                      }
                    }
                  }
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return returnValue;
                }
              }
                return MemSizeWdgt::focusNextPrevChild(next);
              }
              void PythonQtShell_MemSizeWdgt::focusOutEvent(QFocusEvent*  arg__1)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusOutEvent");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "QFocusEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                MemSizeWdgt::focusOutEvent(arg__1);
              }
              bool  PythonQtShell_MemSizeWdgt::hasHeightForWidth() const
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hasHeightForWidth");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"bool"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
                    bool returnValue;
                  void* args[1] = {NULL};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) {
                    args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
                    if (args[0]!=&returnValue) {
                      if (args[0]==NULL) {
                        PythonQt::priv()->handleVirtualOverloadReturnError("hasHeightForWidth", methodInfo, result);
                      } else {
                        returnValue = *((bool*)args[0]);
                      }
                    }
                  }
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return returnValue;
                }
              }
                return MemSizeWdgt::hasHeightForWidth();
              }
              int  PythonQtShell_MemSizeWdgt::heightForWidth(int  arg__1) const
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "heightForWidth");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"int" , "int"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                    int returnValue;
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) {
                    args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
                    if (args[0]!=&returnValue) {
                      if (args[0]==NULL) {
                        PythonQt::priv()->handleVirtualOverloadReturnError("heightForWidth", methodInfo, result);
                      } else {
                        returnValue = *((int*)args[0]);
                      }
                    }
                  }
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return returnValue;
                }
              }
                return MemSizeWdgt::heightForWidth(arg__1);
              }
              void PythonQtShell_MemSizeWdgt::hideEvent(QHideEvent*  arg__1)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hideEvent");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "QHideEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                MemSizeWdgt::hideEvent(arg__1);
              }
              void PythonQtShell_MemSizeWdgt::initPainter(QPainter*  painter) const
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "initPainter");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "QPainter*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&painter};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                MemSizeWdgt::initPainter(painter);
              }
              void PythonQtShell_MemSizeWdgt::inputMethodEvent(QInputMethodEvent*  arg__1)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodEvent");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "QInputMethodEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                MemSizeWdgt::inputMethodEvent(arg__1);
              }
              QVariant  PythonQtShell_MemSizeWdgt::inputMethodQuery(Qt::InputMethodQuery  arg__1) const
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodQuery");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"QVariant" , "Qt::InputMethodQuery"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                    QVariant returnValue;
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) {
                    args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
                    if (args[0]!=&returnValue) {
                      if (args[0]==NULL) {
                        PythonQt::priv()->handleVirtualOverloadReturnError("inputMethodQuery", methodInfo, result);
                      } else {
                        returnValue = *((QVariant*)args[0]);
                      }
                    }
                  }
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return returnValue;
                }
              }
                return MemSizeWdgt::inputMethodQuery(arg__1);
              }
              void PythonQtShell_MemSizeWdgt::keyPressEvent(QKeyEvent*  arg__1)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyPressEvent");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "QKeyEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                MemSizeWdgt::keyPressEvent(arg__1);
              }
              void PythonQtShell_MemSizeWdgt::keyReleaseEvent(QKeyEvent*  arg__1)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyReleaseEvent");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "QKeyEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                MemSizeWdgt::keyReleaseEvent(arg__1);
              }
              void PythonQtShell_MemSizeWdgt::leaveEvent(QEvent*  arg__1)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "leaveEvent");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "QEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                MemSizeWdgt::leaveEvent(arg__1);
              }
              int  PythonQtShell_MemSizeWdgt::metric(QPaintDevice::PaintDeviceMetric  arg__1) const
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "metric");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"int" , "QPaintDevice::PaintDeviceMetric"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                    int returnValue;
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) {
                    args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
                    if (args[0]!=&returnValue) {
                      if (args[0]==NULL) {
                        PythonQt::priv()->handleVirtualOverloadReturnError("metric", methodInfo, result);
                      } else {
                        returnValue = *((int*)args[0]);
                      }
                    }
                  }
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return returnValue;
                }
              }
                return MemSizeWdgt::metric(arg__1);
              }
              QSize  PythonQtShell_MemSizeWdgt::minimumSizeHint() const
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getMinimumSizeHint");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"QSize"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
                    QSize returnValue;
                  void* args[1] = {NULL};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) {
                    args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
                    if (args[0]!=&returnValue) {
                      if (args[0]==NULL) {
                        PythonQt::priv()->handleVirtualOverloadReturnError("getMinimumSizeHint", methodInfo, result);
                      } else {
                        returnValue = *((QSize*)args[0]);
                      }
                    }
                  }
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return returnValue;
                }
              }
                return MemSizeWdgt::minimumSizeHint();
              }
              void PythonQtShell_MemSizeWdgt::mouseDoubleClickEvent(QMouseEvent*  arg__1)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseDoubleClickEvent");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "QMouseEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                MemSizeWdgt::mouseDoubleClickEvent(arg__1);
              }
              void PythonQtShell_MemSizeWdgt::mouseMoveEvent(QMouseEvent*  arg__1)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseMoveEvent");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "QMouseEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                MemSizeWdgt::mouseMoveEvent(arg__1);
              }
              void PythonQtShell_MemSizeWdgt::mousePressEvent(QMouseEvent*  arg__1)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mousePressEvent");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "QMouseEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                MemSizeWdgt::mousePressEvent(arg__1);
              }
              void PythonQtShell_MemSizeWdgt::mouseReleaseEvent(QMouseEvent*  arg__1)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseReleaseEvent");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "QMouseEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                MemSizeWdgt::mouseReleaseEvent(arg__1);
              }
              void PythonQtShell_MemSizeWdgt::moveEvent(QMoveEvent*  arg__1)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "moveEvent");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "QMoveEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                MemSizeWdgt::moveEvent(arg__1);
              }
              bool  PythonQtShell_MemSizeWdgt::nativeEvent(const QByteArray&  eventType, void*  message, long*  result)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "nativeEvent");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"bool" , "const QByteArray&" , "void*" , "long*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
                    bool returnValue;
                  void* args[4] = {NULL, (void*)&eventType, (void*)&message, (void*)&result};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) {
                    args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
                    if (args[0]!=&returnValue) {
                      if (args[0]==NULL) {
                        PythonQt::priv()->handleVirtualOverloadReturnError("nativeEvent", methodInfo, result);
                      } else {
                        returnValue = *((bool*)args[0]);
                      }
                    }
                  }
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return returnValue;
                }
              }
                return MemSizeWdgt::nativeEvent(eventType, message, result);
              }
              QPaintEngine*  PythonQtShell_MemSizeWdgt::paintEngine() const
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEngine");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"QPaintEngine*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
                    QPaintEngine* returnValue;
                  void* args[1] = {NULL};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) {
                    args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
                    if (args[0]!=&returnValue) {
                      if (args[0]==NULL) {
                        PythonQt::priv()->handleVirtualOverloadReturnError("paintEngine", methodInfo, result);
                      } else {
                        returnValue = *((QPaintEngine**)args[0]);
                      }
                    }
                  }
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return returnValue;
                }
              }
                return MemSizeWdgt::paintEngine();
              }
              void PythonQtShell_MemSizeWdgt::paintEvent(QPaintEvent*  arg__1)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEvent");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "QPaintEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                MemSizeWdgt::paintEvent(arg__1);
              }
              QPaintDevice*  PythonQtShell_MemSizeWdgt::redirected(QPoint*  offset) const
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "redirected");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"QPaintDevice*" , "QPoint*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                    QPaintDevice* returnValue;
                  void* args[2] = {NULL, (void*)&offset};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) {
                    args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
                    if (args[0]!=&returnValue) {
                      if (args[0]==NULL) {
                        PythonQt::priv()->handleVirtualOverloadReturnError("redirected", methodInfo, result);
                      } else {
                        returnValue = *((QPaintDevice**)args[0]);
                      }
                    }
                  }
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return returnValue;
                }
              }
                return MemSizeWdgt::redirected(offset);
              }
              void PythonQtShell_MemSizeWdgt::resizeEvent(QResizeEvent*  arg__1)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "resizeEvent");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "QResizeEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                MemSizeWdgt::resizeEvent(arg__1);
              }
              QPainter*  PythonQtShell_MemSizeWdgt::sharedPainter() const
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "sharedPainter");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"QPainter*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
                    QPainter* returnValue;
                  void* args[1] = {NULL};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) {
                    args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
                    if (args[0]!=&returnValue) {
                      if (args[0]==NULL) {
                        PythonQt::priv()->handleVirtualOverloadReturnError("sharedPainter", methodInfo, result);
                      } else {
                        returnValue = *((QPainter**)args[0]);
                      }
                    }
                  }
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return returnValue;
                }
              }
                return MemSizeWdgt::sharedPainter();
              }
              void PythonQtShell_MemSizeWdgt::showEvent(QShowEvent*  arg__1)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "showEvent");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "QShowEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                MemSizeWdgt::showEvent(arg__1);
              }
              QSize  PythonQtShell_MemSizeWdgt::sizeHint() const
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getSizeHint");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"QSize"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
                    QSize returnValue;
                  void* args[1] = {NULL};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) {
                    args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
                    if (args[0]!=&returnValue) {
                      if (args[0]==NULL) {
                        PythonQt::priv()->handleVirtualOverloadReturnError("getSizeHint", methodInfo, result);
                      } else {
                        returnValue = *((QSize*)args[0]);
                      }
                    }
                  }
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return returnValue;
                }
              }
                return MemSizeWdgt::sizeHint();
              }
              void PythonQtShell_MemSizeWdgt::tabletEvent(QTabletEvent*  arg__1)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "tabletEvent");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "QTabletEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                MemSizeWdgt::tabletEvent(arg__1);
              }
              void PythonQtShell_MemSizeWdgt::timerEvent(QTimerEvent*  arg__1)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "timerEvent");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "QTimerEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                MemSizeWdgt::timerEvent(arg__1);
              }
              void PythonQtShell_MemSizeWdgt::wheelEvent(QWheelEvent*  arg__1)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "wheelEvent");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "QWheelEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                MemSizeWdgt::wheelEvent(arg__1);
              }
              MemSizeWdgt* PythonQtWrapper_MemSizeWdgt::new_MemSizeWdgt(QWidget*  parent)
              {
              return new PythonQtShell_MemSizeWdgt(parent); }
              MemSizeWdgt* PythonQtWrapper_MemSizeWdgt::new_MemSizeWdgt(int  defaultSize, QWidget*  parent)
              {
              return new PythonQtShell_MemSizeWdgt(defaultSize, parent); }
              int  PythonQtWrapper_MemSizeWdgt::getsize(MemSizeWdgt* theWrappedObject)
              {
                return ( theWrappedObject->getsize());
              }
              void PythonQtWrapper_MemSizeWdgt::setMaximum(MemSizeWdgt* theWrappedObject, unsigned int  max)
              {
                ( theWrappedObject->setMaximum(max));
              }
              void PythonQtWrapper_MemSizeWdgt::show(MemSizeWdgt* theWrappedObject)
              {
                ( theWrappedObject->show());
              }
              void PythonQtWrapper_MemSizeWdgt::updateSizeValue(MemSizeWdgt* theWrappedObject)
              {
                ( theWrappedObject->updateSizeValue());
              }
              PythonQtShell_QHexEdit::~PythonQtShell_QHexEdit() {
                PythonQtPrivate* priv = PythonQt::priv();
                if (priv) { priv->shellClassDeleted(this); }
              }
              void PythonQtShell_QHexEdit::actionEvent(QActionEvent*  arg__1)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "actionEvent");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "QActionEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                QHexEdit::actionEvent(arg__1);
              }
              void PythonQtShell_QHexEdit::changeEvent(QEvent*  arg__1)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "changeEvent");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "QEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                QHexEdit::changeEvent(arg__1);
              }
              void PythonQtShell_QHexEdit::childEvent(QChildEvent*  arg__1)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "childEvent");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "QChildEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                QHexEdit::childEvent(arg__1);
              }
              void PythonQtShell_QHexEdit::closeEvent(QCloseEvent*  arg__1)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "closeEvent");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "QCloseEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                QHexEdit::closeEvent(arg__1);
              }
              void PythonQtShell_QHexEdit::contextMenuEvent(QContextMenuEvent*  arg__1)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "contextMenuEvent");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "QContextMenuEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                QHexEdit::contextMenuEvent(arg__1);
              }
              void PythonQtShell_QHexEdit::customEvent(QEvent*  arg__1)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "customEvent");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "QEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                QHexEdit::customEvent(arg__1);
              }
              int  PythonQtShell_QHexEdit::devType() const
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "devType");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"int"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
                    int returnValue;
                  void* args[1] = {NULL};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) {
                    args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
                    if (args[0]!=&returnValue) {
                      if (args[0]==NULL) {
                        PythonQt::priv()->handleVirtualOverloadReturnError("devType", methodInfo, result);
                      } else {
                        returnValue = *((int*)args[0]);
                      }
                    }
                  }
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return returnValue;
                }
              }
                return QHexEdit::devType();
              }
              void PythonQtShell_QHexEdit::dragEnterEvent(QDragEnterEvent*  arg__1)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragEnterEvent");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "QDragEnterEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                QHexEdit::dragEnterEvent(arg__1);
              }
              void PythonQtShell_QHexEdit::dragLeaveEvent(QDragLeaveEvent*  arg__1)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragLeaveEvent");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "QDragLeaveEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                QHexEdit::dragLeaveEvent(arg__1);
              }
              void PythonQtShell_QHexEdit::dragMoveEvent(QDragMoveEvent*  arg__1)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragMoveEvent");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "QDragMoveEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                QHexEdit::dragMoveEvent(arg__1);
              }
              void PythonQtShell_QHexEdit::dropEvent(QDropEvent*  arg__1)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dropEvent");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "QDropEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                QHexEdit::dropEvent(arg__1);
              }
              void PythonQtShell_QHexEdit::enterEvent(QEvent*  arg__1)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "enterEvent");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "QEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                QHexEdit::enterEvent(arg__1);
              }
              bool  PythonQtShell_QHexEdit::event(QEvent*  arg__1)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "event");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"bool" , "QEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                    bool returnValue;
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) {
                    args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
                    if (args[0]!=&returnValue) {
                      if (args[0]==NULL) {
                        PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
                      } else {
                        returnValue = *((bool*)args[0]);
                      }
                    }
                  }
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return returnValue;
                }
              }
                return QHexEdit::event(arg__1);
              }
              bool  PythonQtShell_QHexEdit::eventFilter(QObject*  arg__1, QEvent*  arg__2)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "eventFilter");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
                    bool returnValue;
                  void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) {
                    args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
                    if (args[0]!=&returnValue) {
                      if (args[0]==NULL) {
                        PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
                      } else {
                        returnValue = *((bool*)args[0]);
                      }
                    }
                  }
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return returnValue;
                }
              }
                return QHexEdit::eventFilter(arg__1, arg__2);
              }
              void PythonQtShell_QHexEdit::focusInEvent(QFocusEvent*  arg__1)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusInEvent");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "QFocusEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                QHexEdit::focusInEvent(arg__1);
              }
              bool  PythonQtShell_QHexEdit::focusNextPrevChild(bool  next)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusNextPrevChild");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"bool" , "bool"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                    bool returnValue;
                  void* args[2] = {NULL, (void*)&next};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) {
                    args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
                    if (args[0]!=&returnValue) {
                      if (args[0]==NULL) {
                        PythonQt::priv()->handleVirtualOverloadReturnError("focusNextPrevChild", methodInfo, result);
                      } else {
                        returnValue = *((bool*)args[0]);
                      }
                    }
                  }
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return returnValue;
                }
              }
                return QHexEdit::focusNextPrevChild(next);
              }
              void PythonQtShell_QHexEdit::focusOutEvent(QFocusEvent*  arg__1)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusOutEvent");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "QFocusEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                QHexEdit::focusOutEvent(arg__1);
              }
              bool  PythonQtShell_QHexEdit::hasHeightForWidth() const
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hasHeightForWidth");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"bool"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
                    bool returnValue;
                  void* args[1] = {NULL};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) {
                    args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
                    if (args[0]!=&returnValue) {
                      if (args[0]==NULL) {
                        PythonQt::priv()->handleVirtualOverloadReturnError("hasHeightForWidth", methodInfo, result);
                      } else {
                        returnValue = *((bool*)args[0]);
                      }
                    }
                  }
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return returnValue;
                }
              }
                return QHexEdit::hasHeightForWidth();
              }
              int  PythonQtShell_QHexEdit::heightForWidth(int  arg__1) const
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "heightForWidth");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"int" , "int"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                    int returnValue;
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) {
                    args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
                    if (args[0]!=&returnValue) {
                      if (args[0]==NULL) {
                        PythonQt::priv()->handleVirtualOverloadReturnError("heightForWidth", methodInfo, result);
                      } else {
                        returnValue = *((int*)args[0]);
                      }
                    }
                  }
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return returnValue;
                }
              }
                return QHexEdit::heightForWidth(arg__1);
              }
              void PythonQtShell_QHexEdit::hideEvent(QHideEvent*  arg__1)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hideEvent");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "QHideEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                QHexEdit::hideEvent(arg__1);
              }
              void PythonQtShell_QHexEdit::initPainter(QPainter*  painter) const
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "initPainter");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "QPainter*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&painter};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                QHexEdit::initPainter(painter);
              }
              void PythonQtShell_QHexEdit::inputMethodEvent(QInputMethodEvent*  arg__1)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodEvent");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "QInputMethodEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                QHexEdit::inputMethodEvent(arg__1);
              }
              QVariant  PythonQtShell_QHexEdit::inputMethodQuery(Qt::InputMethodQuery  arg__1) const
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodQuery");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"QVariant" , "Qt::InputMethodQuery"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                    QVariant returnValue;
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) {
                    args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
                    if (args[0]!=&returnValue) {
                      if (args[0]==NULL) {
                        PythonQt::priv()->handleVirtualOverloadReturnError("inputMethodQuery", methodInfo, result);
                      } else {
                        returnValue = *((QVariant*)args[0]);
                      }
                    }
                  }
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return returnValue;
                }
              }
                return QHexEdit::inputMethodQuery(arg__1);
              }
              void PythonQtShell_QHexEdit::keyPressEvent(QKeyEvent*  arg__1)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyPressEvent");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "QKeyEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                QHexEdit::keyPressEvent(arg__1);
              }
              void PythonQtShell_QHexEdit::keyReleaseEvent(QKeyEvent*  arg__1)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyReleaseEvent");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "QKeyEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                QHexEdit::keyReleaseEvent(arg__1);
              }
              void PythonQtShell_QHexEdit::leaveEvent(QEvent*  arg__1)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "leaveEvent");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "QEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                QHexEdit::leaveEvent(arg__1);
              }
              int  PythonQtShell_QHexEdit::metric(QPaintDevice::PaintDeviceMetric  arg__1) const
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "metric");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"int" , "QPaintDevice::PaintDeviceMetric"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                    int returnValue;
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) {
                    args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
                    if (args[0]!=&returnValue) {
                      if (args[0]==NULL) {
                        PythonQt::priv()->handleVirtualOverloadReturnError("metric", methodInfo, result);
                      } else {
                        returnValue = *((int*)args[0]);
                      }
                    }
                  }
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return returnValue;
                }
              }
                return QHexEdit::metric(arg__1);
              }
              void PythonQtShell_QHexEdit::mouseDoubleClickEvent(QMouseEvent*  arg__1)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseDoubleClickEvent");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "QMouseEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                QHexEdit::mouseDoubleClickEvent(arg__1);
              }
              void PythonQtShell_QHexEdit::mouseMoveEvent(QMouseEvent*  arg__1)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseMoveEvent");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "QMouseEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                QHexEdit::mouseMoveEvent(arg__1);
              }
              void PythonQtShell_QHexEdit::mousePressEvent(QMouseEvent*  arg__1)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mousePressEvent");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "QMouseEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                QHexEdit::mousePressEvent(arg__1);
              }
              void PythonQtShell_QHexEdit::mouseReleaseEvent(QMouseEvent*  arg__1)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseReleaseEvent");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "QMouseEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                QHexEdit::mouseReleaseEvent(arg__1);
              }
              void PythonQtShell_QHexEdit::moveEvent(QMoveEvent*  arg__1)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "moveEvent");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "QMoveEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                QHexEdit::moveEvent(arg__1);
              }
              bool  PythonQtShell_QHexEdit::nativeEvent(const QByteArray&  eventType, void*  message, long*  result)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "nativeEvent");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"bool" , "const QByteArray&" , "void*" , "long*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
                    bool returnValue;
                  void* args[4] = {NULL, (void*)&eventType, (void*)&message, (void*)&result};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) {
                    args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
                    if (args[0]!=&returnValue) {
                      if (args[0]==NULL) {
                        PythonQt::priv()->handleVirtualOverloadReturnError("nativeEvent", methodInfo, result);
                      } else {
                        returnValue = *((bool*)args[0]);
                      }
                    }
                  }
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return returnValue;
                }
              }
                return QHexEdit::nativeEvent(eventType, message, result);
              }
              QPaintEngine*  PythonQtShell_QHexEdit::paintEngine() const
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEngine");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"QPaintEngine*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
                    QPaintEngine* returnValue;
                  void* args[1] = {NULL};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) {
                    args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
                    if (args[0]!=&returnValue) {
                      if (args[0]==NULL) {
                        PythonQt::priv()->handleVirtualOverloadReturnError("paintEngine", methodInfo, result);
                      } else {
                        returnValue = *((QPaintEngine**)args[0]);
                      }
                    }
                  }
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return returnValue;
                }
              }
                return QHexEdit::paintEngine();
              }
              void PythonQtShell_QHexEdit::paintEvent(QPaintEvent*  arg__1)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEvent");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "QPaintEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                QHexEdit::paintEvent(arg__1);
              }
              QPaintDevice*  PythonQtShell_QHexEdit::redirected(QPoint*  offset) const
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "redirected");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"QPaintDevice*" , "QPoint*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                    QPaintDevice* returnValue;
                  void* args[2] = {NULL, (void*)&offset};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) {
                    args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
                    if (args[0]!=&returnValue) {
                      if (args[0]==NULL) {
                        PythonQt::priv()->handleVirtualOverloadReturnError("redirected", methodInfo, result);
                      } else {
                        returnValue = *((QPaintDevice**)args[0]);
                      }
                    }
                  }
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return returnValue;
                }
              }
                return QHexEdit::redirected(offset);
              }
              void PythonQtShell_QHexEdit::resizeEvent(QResizeEvent*  arg__1)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "resizeEvent");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "QResizeEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                QHexEdit::resizeEvent(arg__1);
              }
              void PythonQtShell_QHexEdit::scrollContentsBy(int  dx, int  dy)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "scrollContentsBy");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "int" , "int"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
                  void* args[3] = {NULL, (void*)&dx, (void*)&dy};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                QHexEdit::scrollContentsBy(dx, dy);
              }
              void PythonQtShell_QHexEdit::setupViewport(QWidget*  viewport)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "setupViewport");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "QWidget*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&viewport};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                QHexEdit::setupViewport(viewport);
              }
              QPainter*  PythonQtShell_QHexEdit::sharedPainter() const
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "sharedPainter");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"QPainter*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
                    QPainter* returnValue;
                  void* args[1] = {NULL};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) {
                    args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
                    if (args[0]!=&returnValue) {
                      if (args[0]==NULL) {
                        PythonQt::priv()->handleVirtualOverloadReturnError("sharedPainter", methodInfo, result);
                      } else {
                        returnValue = *((QPainter**)args[0]);
                      }
                    }
                  }
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return returnValue;
                }
              }
                return QHexEdit::sharedPainter();
              }
              void PythonQtShell_QHexEdit::showEvent(QShowEvent*  arg__1)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "showEvent");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "QShowEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                QHexEdit::showEvent(arg__1);
              }
              void PythonQtShell_QHexEdit::tabletEvent(QTabletEvent*  arg__1)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "tabletEvent");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "QTabletEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                QHexEdit::tabletEvent(arg__1);
              }
              void PythonQtShell_QHexEdit::timerEvent(QTimerEvent*  arg__1)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "timerEvent");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "QTimerEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                QHexEdit::timerEvent(arg__1);
              }
              bool  PythonQtShell_QHexEdit::viewportEvent(QEvent*  arg__1)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "viewportEvent");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"bool" , "QEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                    bool returnValue;
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) {
                    args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
                    if (args[0]!=&returnValue) {
                      if (args[0]==NULL) {
                        PythonQt::priv()->handleVirtualOverloadReturnError("viewportEvent", methodInfo, result);
                      } else {
                        returnValue = *((bool*)args[0]);
                      }
                    }
                  }
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return returnValue;
                }
              }
                return QHexEdit::viewportEvent(arg__1);
              }
              QSize  PythonQtShell_QHexEdit::viewportSizeHint() const
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "viewportSizeHint");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"QSize"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
                    QSize returnValue;
                  void* args[1] = {NULL};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) {
                    args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
                    if (args[0]!=&returnValue) {
                      if (args[0]==NULL) {
                        PythonQt::priv()->handleVirtualOverloadReturnError("viewportSizeHint", methodInfo, result);
                      } else {
                        returnValue = *((QSize*)args[0]);
                      }
                    }
                  }
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return returnValue;
                }
              }
                return QHexEdit::viewportSizeHint();
              }
              void PythonQtShell_QHexEdit::wheelEvent(QWheelEvent*  arg__1)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "wheelEvent");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "QWheelEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                QHexEdit::wheelEvent(arg__1);
              }
              QHexEdit* PythonQtWrapper_QHexEdit::new_QHexEdit(QWidget*  parent)
              {
              return new PythonQtShell_QHexEdit(parent); }
              QColor  PythonQtWrapper_QHexEdit::addressAreaColor(QHexEdit* theWrappedObject)
              {
                return ( theWrappedObject->addressAreaColor());
              }
              int  PythonQtWrapper_QHexEdit::addressOffset(QHexEdit* theWrappedObject)
              {
                return ( theWrappedObject->addressOffset());
              }
              int  PythonQtWrapper_QHexEdit::cursorPosition(QHexEdit* theWrappedObject)
              {
                return ( theWrappedObject->cursorPosition());
              }
              QByteArray  PythonQtWrapper_QHexEdit::data(QHexEdit* theWrappedObject)
              {
                return ( theWrappedObject->data());
              }
              const QFont*  PythonQtWrapper_QHexEdit::font(QHexEdit* theWrappedObject) const
              {
                return &( theWrappedObject->font());
              }
              int  PythonQtWrapper_QHexEdit::getSelectionBegin(QHexEdit* theWrappedObject)
              {
                return ( theWrappedObject->getSelectionBegin());
              }
              int  PythonQtWrapper_QHexEdit::getSelectionEnd(QHexEdit* theWrappedObject)
              {
                return ( theWrappedObject->getSelectionEnd());
              }
              QColor  PythonQtWrapper_QHexEdit::highlightingColor(QHexEdit* theWrappedObject)
              {
                return ( theWrappedObject->highlightingColor());
              }
              int  PythonQtWrapper_QHexEdit::indexOf(QHexEdit* theWrappedObject, const QByteArray&  ba, int  from) const
              {
                return ( theWrappedObject->indexOf(ba, from));
              }
              void PythonQtWrapper_QHexEdit::insert(QHexEdit* theWrappedObject, int  i, char  ch)
              {
                ( theWrappedObject->insert(i, ch));
              }
              void PythonQtWrapper_QHexEdit::insert(QHexEdit* theWrappedObject, int  i, const QByteArray&  ba)
              {
                ( theWrappedObject->insert(i, ba));
              }
              bool  PythonQtWrapper_QHexEdit::isReadOnly(QHexEdit* theWrappedObject)
              {
                return ( theWrappedObject->isReadOnly());
              }
              int  PythonQtWrapper_QHexEdit::lastIndexOf(QHexEdit* theWrappedObject, const QByteArray&  ba, int  from) const
              {
                return ( theWrappedObject->lastIndexOf(ba, from));
              }
              bool  PythonQtWrapper_QHexEdit::overwriteMode(QHexEdit* theWrappedObject)
              {
                return ( theWrappedObject->overwriteMode());
              }
              void PythonQtWrapper_QHexEdit::remove(QHexEdit* theWrappedObject, int  pos, int  len)
              {
                ( theWrappedObject->remove(pos, len));
              }
              void PythonQtWrapper_QHexEdit::replace(QHexEdit* theWrappedObject, int  pos, int  len, const QByteArray&  after)
              {
                ( theWrappedObject->replace(pos, len, after));
              }
              void PythonQtWrapper_QHexEdit::resetSelection(QHexEdit* theWrappedObject)
              {
                ( theWrappedObject->resetSelection());
              }
              void PythonQtWrapper_QHexEdit::resetSelection(QHexEdit* theWrappedObject, int  pos)
              {
                ( theWrappedObject->resetSelection(pos));
              }
              QColor  PythonQtWrapper_QHexEdit::selectionColor(QHexEdit* theWrappedObject)
              {
                return ( theWrappedObject->selectionColor());
              }
              QString  PythonQtWrapper_QHexEdit::selectionToReadableString(QHexEdit* theWrappedObject)
              {
                return ( theWrappedObject->selectionToReadableString());
              }
              void PythonQtWrapper_QHexEdit::setAddressAreaColor(QHexEdit* theWrappedObject, const QColor&  color)
              {
                ( theWrappedObject->setAddressAreaColor(color));
              }
              void PythonQtWrapper_QHexEdit::setAddressOffset(QHexEdit* theWrappedObject, int  offset)
              {
                ( theWrappedObject->setAddressOffset(offset));
              }
              void PythonQtWrapper_QHexEdit::setCursorPosition(QHexEdit* theWrappedObject, int  cusorPos)
              {
                ( theWrappedObject->setCursorPosition(cusorPos));
              }
              void PythonQtWrapper_QHexEdit::setData(QHexEdit* theWrappedObject, const QByteArray&  data)
              {
                ( theWrappedObject->setData(data));
              }
              void PythonQtWrapper_QHexEdit::setFont(QHexEdit* theWrappedObject, const QFont&  arg__1)
              {
                ( theWrappedObject->setFont(arg__1));
              }
              void PythonQtWrapper_QHexEdit::setHighlightingColor(QHexEdit* theWrappedObject, const QColor&  color)
              {
                ( theWrappedObject->setHighlightingColor(color));
              }
              void PythonQtWrapper_QHexEdit::setOverwriteMode(QHexEdit* theWrappedObject, bool  arg__1)
              {
                ( theWrappedObject->setOverwriteMode(arg__1));
              }
              void PythonQtWrapper_QHexEdit::setReadOnly(QHexEdit* theWrappedObject, bool  arg__1)
              {
                ( theWrappedObject->setReadOnly(arg__1));
              }
              void PythonQtWrapper_QHexEdit::setSelection(QHexEdit* theWrappedObject, int  pos)
              {
                ( theWrappedObject->setSelection(pos));
              }
              void PythonQtWrapper_QHexEdit::setSelectionColor(QHexEdit* theWrappedObject, const QColor&  color)
              {
                ( theWrappedObject->setSelectionColor(color));
              }
              QString  PythonQtWrapper_QHexEdit::toReadableString(QHexEdit* theWrappedObject)
              {
                return ( theWrappedObject->toReadableString());
              }
              PythonQtShell_QHexSpinBox::~PythonQtShell_QHexSpinBox() {
                PythonQtPrivate* priv = PythonQt::priv();
                if (priv) { priv->shellClassDeleted(this); }
              }
              void PythonQtShell_QHexSpinBox::actionEvent(QActionEvent*  arg__1)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "actionEvent");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "QActionEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                QHexSpinBox::actionEvent(arg__1);
              }
              void PythonQtShell_QHexSpinBox::changeEvent(QEvent*  event)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "changeEvent");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "QEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&event};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                QHexSpinBox::changeEvent(event);
              }
              void PythonQtShell_QHexSpinBox::childEvent(QChildEvent*  arg__1)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "childEvent");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "QChildEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                QHexSpinBox::childEvent(arg__1);
              }
              void PythonQtShell_QHexSpinBox::clear()
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "clear");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={""};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
                  void* args[1] = {NULL};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                QHexSpinBox::clear();
              }
              void PythonQtShell_QHexSpinBox::closeEvent(QCloseEvent*  event)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "closeEvent");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "QCloseEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&event};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                QHexSpinBox::closeEvent(event);
              }
              void PythonQtShell_QHexSpinBox::contextMenuEvent(QContextMenuEvent*  event)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "contextMenuEvent");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "QContextMenuEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&event};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                QHexSpinBox::contextMenuEvent(event);
              }
              void PythonQtShell_QHexSpinBox::customEvent(QEvent*  arg__1)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "customEvent");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "QEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                QHexSpinBox::customEvent(arg__1);
              }
              int  PythonQtShell_QHexSpinBox::devType() const
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "devType");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"int"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
                    int returnValue;
                  void* args[1] = {NULL};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) {
                    args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
                    if (args[0]!=&returnValue) {
                      if (args[0]==NULL) {
                        PythonQt::priv()->handleVirtualOverloadReturnError("devType", methodInfo, result);
                      } else {
                        returnValue = *((int*)args[0]);
                      }
                    }
                  }
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return returnValue;
                }
              }
                return QHexSpinBox::devType();
              }
              void PythonQtShell_QHexSpinBox::dragEnterEvent(QDragEnterEvent*  arg__1)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragEnterEvent");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "QDragEnterEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                QHexSpinBox::dragEnterEvent(arg__1);
              }
              void PythonQtShell_QHexSpinBox::dragLeaveEvent(QDragLeaveEvent*  arg__1)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragLeaveEvent");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "QDragLeaveEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                QHexSpinBox::dragLeaveEvent(arg__1);
              }
              void PythonQtShell_QHexSpinBox::dragMoveEvent(QDragMoveEvent*  arg__1)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragMoveEvent");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "QDragMoveEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                QHexSpinBox::dragMoveEvent(arg__1);
              }
              void PythonQtShell_QHexSpinBox::dropEvent(QDropEvent*  arg__1)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dropEvent");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "QDropEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                QHexSpinBox::dropEvent(arg__1);
              }
              void PythonQtShell_QHexSpinBox::enterEvent(QEvent*  arg__1)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "enterEvent");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "QEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                QHexSpinBox::enterEvent(arg__1);
              }
              bool  PythonQtShell_QHexSpinBox::event(QEvent*  event)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "event");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"bool" , "QEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                    bool returnValue;
                  void* args[2] = {NULL, (void*)&event};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) {
                    args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
                    if (args[0]!=&returnValue) {
                      if (args[0]==NULL) {
                        PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
                      } else {
                        returnValue = *((bool*)args[0]);
                      }
                    }
                  }
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return returnValue;
                }
              }
                return QHexSpinBox::event(event);
              }
              bool  PythonQtShell_QHexSpinBox::eventFilter(QObject*  arg__1, QEvent*  arg__2)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "eventFilter");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
                    bool returnValue;
                  void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) {
                    args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
                    if (args[0]!=&returnValue) {
                      if (args[0]==NULL) {
                        PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
                      } else {
                        returnValue = *((bool*)args[0]);
                      }
                    }
                  }
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return returnValue;
                }
              }
                return QHexSpinBox::eventFilter(arg__1, arg__2);
              }
              void PythonQtShell_QHexSpinBox::fixup(QString&  str) const
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "fixup");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "QString&"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&str};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                QHexSpinBox::fixup(str);
              }
              void PythonQtShell_QHexSpinBox::focusInEvent(QFocusEvent*  event)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusInEvent");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "QFocusEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&event};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                QHexSpinBox::focusInEvent(event);
              }
              bool  PythonQtShell_QHexSpinBox::focusNextPrevChild(bool  next)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusNextPrevChild");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"bool" , "bool"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                    bool returnValue;
                  void* args[2] = {NULL, (void*)&next};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) {
                    args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
                    if (args[0]!=&returnValue) {
                      if (args[0]==NULL) {
                        PythonQt::priv()->handleVirtualOverloadReturnError("focusNextPrevChild", methodInfo, result);
                      } else {
                        returnValue = *((bool*)args[0]);
                      }
                    }
                  }
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return returnValue;
                }
              }
                return QHexSpinBox::focusNextPrevChild(next);
              }
              void PythonQtShell_QHexSpinBox::focusOutEvent(QFocusEvent*  event)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusOutEvent");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "QFocusEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&event};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                QHexSpinBox::focusOutEvent(event);
              }
              bool  PythonQtShell_QHexSpinBox::hasHeightForWidth() const
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hasHeightForWidth");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"bool"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
                    bool returnValue;
                  void* args[1] = {NULL};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) {
                    args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
                    if (args[0]!=&returnValue) {
                      if (args[0]==NULL) {
                        PythonQt::priv()->handleVirtualOverloadReturnError("hasHeightForWidth", methodInfo, result);
                      } else {
                        returnValue = *((bool*)args[0]);
                      }
                    }
                  }
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return returnValue;
                }
              }
                return QHexSpinBox::hasHeightForWidth();
              }
              int  PythonQtShell_QHexSpinBox::heightForWidth(int  arg__1) const
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "heightForWidth");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"int" , "int"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                    int returnValue;
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) {
                    args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
                    if (args[0]!=&returnValue) {
                      if (args[0]==NULL) {
                        PythonQt::priv()->handleVirtualOverloadReturnError("heightForWidth", methodInfo, result);
                      } else {
                        returnValue = *((int*)args[0]);
                      }
                    }
                  }
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return returnValue;
                }
              }
                return QHexSpinBox::heightForWidth(arg__1);
              }
              void PythonQtShell_QHexSpinBox::hideEvent(QHideEvent*  event)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hideEvent");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "QHideEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&event};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                QHexSpinBox::hideEvent(event);
              }
              void PythonQtShell_QHexSpinBox::initPainter(QPainter*  painter) const
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "initPainter");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "QPainter*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&painter};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                QHexSpinBox::initPainter(painter);
              }
              void PythonQtShell_QHexSpinBox::inputMethodEvent(QInputMethodEvent*  arg__1)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodEvent");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "QInputMethodEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                QHexSpinBox::inputMethodEvent(arg__1);
              }
              QVariant  PythonQtShell_QHexSpinBox::inputMethodQuery(Qt::InputMethodQuery  arg__1) const
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodQuery");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"QVariant" , "Qt::InputMethodQuery"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                    QVariant returnValue;
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) {
                    args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
                    if (args[0]!=&returnValue) {
                      if (args[0]==NULL) {
                        PythonQt::priv()->handleVirtualOverloadReturnError("inputMethodQuery", methodInfo, result);
                      } else {
                        returnValue = *((QVariant*)args[0]);
                      }
                    }
                  }
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return returnValue;
                }
              }
                return QHexSpinBox::inputMethodQuery(arg__1);
              }
              void PythonQtShell_QHexSpinBox::keyPressEvent(QKeyEvent*  event)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyPressEvent");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "QKeyEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&event};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                QHexSpinBox::keyPressEvent(event);
              }
              void PythonQtShell_QHexSpinBox::keyReleaseEvent(QKeyEvent*  event)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyReleaseEvent");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "QKeyEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&event};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                QHexSpinBox::keyReleaseEvent(event);
              }
              void PythonQtShell_QHexSpinBox::leaveEvent(QEvent*  arg__1)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "leaveEvent");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "QEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                QHexSpinBox::leaveEvent(arg__1);
              }
              int  PythonQtShell_QHexSpinBox::metric(QPaintDevice::PaintDeviceMetric  arg__1) const
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "metric");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"int" , "QPaintDevice::PaintDeviceMetric"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                    int returnValue;
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) {
                    args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
                    if (args[0]!=&returnValue) {
                      if (args[0]==NULL) {
                        PythonQt::priv()->handleVirtualOverloadReturnError("metric", methodInfo, result);
                      } else {
                        returnValue = *((int*)args[0]);
                      }
                    }
                  }
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return returnValue;
                }
              }
                return QHexSpinBox::metric(arg__1);
              }
              void PythonQtShell_QHexSpinBox::mouseDoubleClickEvent(QMouseEvent*  arg__1)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseDoubleClickEvent");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "QMouseEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                QHexSpinBox::mouseDoubleClickEvent(arg__1);
              }
              void PythonQtShell_QHexSpinBox::mouseMoveEvent(QMouseEvent*  event)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseMoveEvent");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "QMouseEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&event};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                QHexSpinBox::mouseMoveEvent(event);
              }
              void PythonQtShell_QHexSpinBox::mousePressEvent(QMouseEvent*  event)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mousePressEvent");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "QMouseEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&event};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                QHexSpinBox::mousePressEvent(event);
              }
              void PythonQtShell_QHexSpinBox::mouseReleaseEvent(QMouseEvent*  event)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseReleaseEvent");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "QMouseEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&event};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                QHexSpinBox::mouseReleaseEvent(event);
              }
              void PythonQtShell_QHexSpinBox::moveEvent(QMoveEvent*  arg__1)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "moveEvent");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "QMoveEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                QHexSpinBox::moveEvent(arg__1);
              }
              bool  PythonQtShell_QHexSpinBox::nativeEvent(const QByteArray&  eventType, void*  message, long*  result)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "nativeEvent");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"bool" , "const QByteArray&" , "void*" , "long*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
                    bool returnValue;
                  void* args[4] = {NULL, (void*)&eventType, (void*)&message, (void*)&result};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) {
                    args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
                    if (args[0]!=&returnValue) {
                      if (args[0]==NULL) {
                        PythonQt::priv()->handleVirtualOverloadReturnError("nativeEvent", methodInfo, result);
                      } else {
                        returnValue = *((bool*)args[0]);
                      }
                    }
                  }
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return returnValue;
                }
              }
                return QHexSpinBox::nativeEvent(eventType, message, result);
              }
              QPaintEngine*  PythonQtShell_QHexSpinBox::paintEngine() const
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEngine");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"QPaintEngine*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
                    QPaintEngine* returnValue;
                  void* args[1] = {NULL};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) {
                    args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
                    if (args[0]!=&returnValue) {
                      if (args[0]==NULL) {
                        PythonQt::priv()->handleVirtualOverloadReturnError("paintEngine", methodInfo, result);
                      } else {
                        returnValue = *((QPaintEngine**)args[0]);
                      }
                    }
                  }
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return returnValue;
                }
              }
                return QHexSpinBox::paintEngine();
              }
              void PythonQtShell_QHexSpinBox::paintEvent(QPaintEvent*  event)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEvent");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "QPaintEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&event};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                QHexSpinBox::paintEvent(event);
              }
              QPaintDevice*  PythonQtShell_QHexSpinBox::redirected(QPoint*  offset) const
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "redirected");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"QPaintDevice*" , "QPoint*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                    QPaintDevice* returnValue;
                  void* args[2] = {NULL, (void*)&offset};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) {
                    args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
                    if (args[0]!=&returnValue) {
                      if (args[0]==NULL) {
                        PythonQt::priv()->handleVirtualOverloadReturnError("redirected", methodInfo, result);
                      } else {
                        returnValue = *((QPaintDevice**)args[0]);
                      }
                    }
                  }
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return returnValue;
                }
              }
                return QHexSpinBox::redirected(offset);
              }
              void PythonQtShell_QHexSpinBox::resizeEvent(QResizeEvent*  event)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "resizeEvent");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "QResizeEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&event};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                QHexSpinBox::resizeEvent(event);
              }
              QPainter*  PythonQtShell_QHexSpinBox::sharedPainter() const
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "sharedPainter");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"QPainter*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
                    QPainter* returnValue;
                  void* args[1] = {NULL};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) {
                    args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
                    if (args[0]!=&returnValue) {
                      if (args[0]==NULL) {
                        PythonQt::priv()->handleVirtualOverloadReturnError("sharedPainter", methodInfo, result);
                      } else {
                        returnValue = *((QPainter**)args[0]);
                      }
                    }
                  }
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return returnValue;
                }
              }
                return QHexSpinBox::sharedPainter();
              }
              void PythonQtShell_QHexSpinBox::showEvent(QShowEvent*  event)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "showEvent");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "QShowEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&event};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                QHexSpinBox::showEvent(event);
              }
              void PythonQtShell_QHexSpinBox::stepBy(int  steps)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "stepBy");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "int"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&steps};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                QHexSpinBox::stepBy(steps);
              }
              QAbstractSpinBox::StepEnabled  PythonQtShell_QHexSpinBox::stepEnabled() const
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "stepEnabled");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"QAbstractSpinBox::StepEnabled"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
                    QAbstractSpinBox::StepEnabled returnValue;
                  void* args[1] = {NULL};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) {
                    args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
                    if (args[0]!=&returnValue) {
                      if (args[0]==NULL) {
                        PythonQt::priv()->handleVirtualOverloadReturnError("stepEnabled", methodInfo, result);
                      } else {
                        returnValue = *((QAbstractSpinBox::StepEnabled*)args[0]);
                      }
                    }
                  }
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return returnValue;
                }
              }
                return QHexSpinBox::stepEnabled();
              }
              void PythonQtShell_QHexSpinBox::tabletEvent(QTabletEvent*  arg__1)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "tabletEvent");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "QTabletEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                QHexSpinBox::tabletEvent(arg__1);
              }
              QString  PythonQtShell_QHexSpinBox::textFromValue(int  value) const
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "textFromValue");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"QString" , "int"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                    QString returnValue;
                  void* args[2] = {NULL, (void*)&value};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) {
                    args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
                    if (args[0]!=&returnValue) {
                      if (args[0]==NULL) {
                        PythonQt::priv()->handleVirtualOverloadReturnError("textFromValue", methodInfo, result);
                      } else {
                        returnValue = *((QString*)args[0]);
                      }
                    }
                  }
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return returnValue;
                }
              }
                return QHexSpinBox::textFromValue(value);
              }
              void PythonQtShell_QHexSpinBox::timerEvent(QTimerEvent*  event)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "timerEvent");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "QTimerEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&event};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                QHexSpinBox::timerEvent(event);
              }
              QValidator::State  PythonQtShell_QHexSpinBox::validate(QString&  input, int&  pos) const
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "validate");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"QValidator::State" , "QString&" , "int&"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
                    QValidator::State returnValue;
                  void* args[3] = {NULL, (void*)&input, (void*)&pos};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) {
                    args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
                    if (args[0]!=&returnValue) {
                      if (args[0]==NULL) {
                        PythonQt::priv()->handleVirtualOverloadReturnError("validate", methodInfo, result);
                      } else {
                        returnValue = *((QValidator::State*)args[0]);
                      }
                    }
                  }
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return returnValue;
                }
              }
                return QHexSpinBox::validate(input, pos);
              }
              int  PythonQtShell_QHexSpinBox::valueFromText(const QString&  text) const
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "valueFromText");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"int" , "const QString&"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                    int returnValue;
                  void* args[2] = {NULL, (void*)&text};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) {
                    args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
                    if (args[0]!=&returnValue) {
                      if (args[0]==NULL) {
                        PythonQt::priv()->handleVirtualOverloadReturnError("valueFromText", methodInfo, result);
                      } else {
                        returnValue = *((int*)args[0]);
                      }
                    }
                  }
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return returnValue;
                }
              }
                return QHexSpinBox::valueFromText(text);
              }
              void PythonQtShell_QHexSpinBox::wheelEvent(QWheelEvent*  event)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "wheelEvent");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "QWheelEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&event};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                QHexSpinBox::wheelEvent(event);
              }
              QHexSpinBox* PythonQtWrapper_QHexSpinBox::new_QHexSpinBox(QWidget*  parent)
              {
              return new PythonQtShell_QHexSpinBox(parent); }
              void PythonQtWrapper_QHexSpinBox::show(QHexSpinBox* theWrappedObject)
              {
                ( theWrappedObject->show());
              }
              QString  PythonQtWrapper_QHexSpinBox::textFromValue(QHexSpinBox* theWrappedObject, int  value) const
              {
                return ( ((PythonQtPublicPromoter_QHexSpinBox*)theWrappedObject)->promoted_textFromValue(value));
              }
              QValidator::State  PythonQtWrapper_QHexSpinBox::validate(QHexSpinBox* theWrappedObject, QString&  input, int&  pos) const
              {
                return ( ((PythonQtPublicPromoter_QHexSpinBox*)theWrappedObject)->promoted_validate(input, pos));
              }
              int  PythonQtWrapper_QHexSpinBox::valueFromText(QHexSpinBox* theWrappedObject, const QString&  text) const
              {
                return ( ((PythonQtPublicPromoter_QHexSpinBox*)theWrappedObject)->promoted_valueFromText(text));
              }
              PythonQtShell_SocExplorerPlot::~PythonQtShell_SocExplorerPlot() {
                PythonQtPrivate* priv = PythonQt::priv();
                if (priv) { priv->shellClassDeleted(this); }
              }
              void PythonQtShell_SocExplorerPlot::actionEvent(QActionEvent*  arg__1)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "actionEvent");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "QActionEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                SocExplorerPlot::actionEvent(arg__1);
              }
              void PythonQtShell_SocExplorerPlot::changeEvent(QEvent*  arg__1)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "changeEvent");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "QEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                SocExplorerPlot::changeEvent(arg__1);
              }
              void PythonQtShell_SocExplorerPlot::childEvent(QChildEvent*  arg__1)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "childEvent");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "QChildEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                SocExplorerPlot::childEvent(arg__1);
              }
              void PythonQtShell_SocExplorerPlot::closeEvent(QCloseEvent*  arg__1)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "closeEvent");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "QCloseEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                SocExplorerPlot::closeEvent(arg__1);
              }
              void PythonQtShell_SocExplorerPlot::contextMenuEvent(QContextMenuEvent*  arg__1)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "contextMenuEvent");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "QContextMenuEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                SocExplorerPlot::contextMenuEvent(arg__1);
              }
              void PythonQtShell_SocExplorerPlot::customEvent(QEvent*  arg__1)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "customEvent");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "QEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                SocExplorerPlot::customEvent(arg__1);
              }
              int  PythonQtShell_SocExplorerPlot::devType() const
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "devType");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"int"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
                    int returnValue;
                  void* args[1] = {NULL};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) {
                    args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
                    if (args[0]!=&returnValue) {
                      if (args[0]==NULL) {
                        PythonQt::priv()->handleVirtualOverloadReturnError("devType", methodInfo, result);
                      } else {
                        returnValue = *((int*)args[0]);
                      }
                    }
                  }
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return returnValue;
                }
              }
                return SocExplorerPlot::devType();
              }
              void PythonQtShell_SocExplorerPlot::dragEnterEvent(QDragEnterEvent*  arg__1)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragEnterEvent");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "QDragEnterEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                SocExplorerPlot::dragEnterEvent(arg__1);
              }
              void PythonQtShell_SocExplorerPlot::dragLeaveEvent(QDragLeaveEvent*  arg__1)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragLeaveEvent");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "QDragLeaveEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                SocExplorerPlot::dragLeaveEvent(arg__1);
              }
              void PythonQtShell_SocExplorerPlot::dragMoveEvent(QDragMoveEvent*  arg__1)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragMoveEvent");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "QDragMoveEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                SocExplorerPlot::dragMoveEvent(arg__1);
              }
              void PythonQtShell_SocExplorerPlot::dropEvent(QDropEvent*  arg__1)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dropEvent");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "QDropEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                SocExplorerPlot::dropEvent(arg__1);
              }
              void PythonQtShell_SocExplorerPlot::enterEvent(QEvent*  arg__1)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "enterEvent");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "QEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                SocExplorerPlot::enterEvent(arg__1);
              }
              bool  PythonQtShell_SocExplorerPlot::event(QEvent*  arg__1)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "event");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"bool" , "QEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                    bool returnValue;
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) {
                    args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
                    if (args[0]!=&returnValue) {
                      if (args[0]==NULL) {
                        PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
                      } else {
                        returnValue = *((bool*)args[0]);
                      }
                    }
                  }
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return returnValue;
                }
              }
                return SocExplorerPlot::event(arg__1);
              }
              bool  PythonQtShell_SocExplorerPlot::eventFilter(QObject*  arg__1, QEvent*  arg__2)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "eventFilter");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
                    bool returnValue;
                  void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) {
                    args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
                    if (args[0]!=&returnValue) {
                      if (args[0]==NULL) {
                        PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
                      } else {
                        returnValue = *((bool*)args[0]);
                      }
                    }
                  }
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return returnValue;
                }
              }
                return SocExplorerPlot::eventFilter(arg__1, arg__2);
              }
              void PythonQtShell_SocExplorerPlot::focusInEvent(QFocusEvent*  arg__1)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusInEvent");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "QFocusEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                SocExplorerPlot::focusInEvent(arg__1);
              }
              bool  PythonQtShell_SocExplorerPlot::focusNextPrevChild(bool  next)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusNextPrevChild");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"bool" , "bool"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                    bool returnValue;
                  void* args[2] = {NULL, (void*)&next};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) {
                    args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
                    if (args[0]!=&returnValue) {
                      if (args[0]==NULL) {
                        PythonQt::priv()->handleVirtualOverloadReturnError("focusNextPrevChild", methodInfo, result);
                      } else {
                        returnValue = *((bool*)args[0]);
                      }
                    }
                  }
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return returnValue;
                }
              }
                return SocExplorerPlot::focusNextPrevChild(next);
              }
              void PythonQtShell_SocExplorerPlot::focusOutEvent(QFocusEvent*  arg__1)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusOutEvent");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "QFocusEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                SocExplorerPlot::focusOutEvent(arg__1);
              }
              bool  PythonQtShell_SocExplorerPlot::hasHeightForWidth() const
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hasHeightForWidth");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"bool"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
                    bool returnValue;
                  void* args[1] = {NULL};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) {
                    args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
                    if (args[0]!=&returnValue) {
                      if (args[0]==NULL) {
                        PythonQt::priv()->handleVirtualOverloadReturnError("hasHeightForWidth", methodInfo, result);
                      } else {
                        returnValue = *((bool*)args[0]);
                      }
                    }
                  }
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return returnValue;
                }
              }
                return SocExplorerPlot::hasHeightForWidth();
              }
              int  PythonQtShell_SocExplorerPlot::heightForWidth(int  arg__1) const
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "heightForWidth");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"int" , "int"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                    int returnValue;
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) {
                    args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
                    if (args[0]!=&returnValue) {
                      if (args[0]==NULL) {
                        PythonQt::priv()->handleVirtualOverloadReturnError("heightForWidth", methodInfo, result);
                      } else {
                        returnValue = *((int*)args[0]);
                      }
                    }
                  }
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return returnValue;
                }
              }
                return SocExplorerPlot::heightForWidth(arg__1);
              }
              void PythonQtShell_SocExplorerPlot::hideEvent(QHideEvent*  arg__1)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hideEvent");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "QHideEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                SocExplorerPlot::hideEvent(arg__1);
              }
              void PythonQtShell_SocExplorerPlot::initPainter(QPainter*  painter) const
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "initPainter");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "QPainter*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&painter};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                SocExplorerPlot::initPainter(painter);
              }
              void PythonQtShell_SocExplorerPlot::inputMethodEvent(QInputMethodEvent*  arg__1)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodEvent");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "QInputMethodEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                SocExplorerPlot::inputMethodEvent(arg__1);
              }
              QVariant  PythonQtShell_SocExplorerPlot::inputMethodQuery(Qt::InputMethodQuery  arg__1) const
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodQuery");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"QVariant" , "Qt::InputMethodQuery"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                    QVariant returnValue;
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) {
                    args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
                    if (args[0]!=&returnValue) {
                      if (args[0]==NULL) {
                        PythonQt::priv()->handleVirtualOverloadReturnError("inputMethodQuery", methodInfo, result);
                      } else {
                        returnValue = *((QVariant*)args[0]);
                      }
                    }
                  }
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return returnValue;
                }
              }
                return SocExplorerPlot::inputMethodQuery(arg__1);
              }
              void PythonQtShell_SocExplorerPlot::keyPressEvent(QKeyEvent*  arg__1)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyPressEvent");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "QKeyEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                SocExplorerPlot::keyPressEvent(arg__1);
              }
              void PythonQtShell_SocExplorerPlot::keyReleaseEvent(QKeyEvent*  arg__1)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyReleaseEvent");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "QKeyEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                SocExplorerPlot::keyReleaseEvent(arg__1);
              }
              void PythonQtShell_SocExplorerPlot::leaveEvent(QEvent*  arg__1)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "leaveEvent");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "QEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                SocExplorerPlot::leaveEvent(arg__1);
              }
              int  PythonQtShell_SocExplorerPlot::metric(QPaintDevice::PaintDeviceMetric  arg__1) const
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "metric");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"int" , "QPaintDevice::PaintDeviceMetric"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                    int returnValue;
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) {
                    args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
                    if (args[0]!=&returnValue) {
                      if (args[0]==NULL) {
                        PythonQt::priv()->handleVirtualOverloadReturnError("metric", methodInfo, result);
                      } else {
                        returnValue = *((int*)args[0]);
                      }
                    }
                  }
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return returnValue;
                }
              }
                return SocExplorerPlot::metric(arg__1);
              }
              QSize  PythonQtShell_SocExplorerPlot::minimumSizeHint() const
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getMinimumSizeHint");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"QSize"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
                    QSize returnValue;
                  void* args[1] = {NULL};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) {
                    args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
                    if (args[0]!=&returnValue) {
                      if (args[0]==NULL) {
                        PythonQt::priv()->handleVirtualOverloadReturnError("getMinimumSizeHint", methodInfo, result);
                      } else {
                        returnValue = *((QSize*)args[0]);
                      }
                    }
                  }
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return returnValue;
                }
              }
                return SocExplorerPlot::minimumSizeHint();
              }
              void PythonQtShell_SocExplorerPlot::mouseDoubleClickEvent(QMouseEvent*  arg__1)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseDoubleClickEvent");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "QMouseEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                SocExplorerPlot::mouseDoubleClickEvent(arg__1);
              }
              void PythonQtShell_SocExplorerPlot::mouseMoveEvent(QMouseEvent*  arg__1)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseMoveEvent");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "QMouseEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                SocExplorerPlot::mouseMoveEvent(arg__1);
              }
              void PythonQtShell_SocExplorerPlot::mousePressEvent(QMouseEvent*  arg__1)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mousePressEvent");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "QMouseEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                SocExplorerPlot::mousePressEvent(arg__1);
              }
              void PythonQtShell_SocExplorerPlot::mouseReleaseEvent(QMouseEvent*  arg__1)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseReleaseEvent");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "QMouseEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                SocExplorerPlot::mouseReleaseEvent(arg__1);
              }
              void PythonQtShell_SocExplorerPlot::moveEvent(QMoveEvent*  arg__1)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "moveEvent");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "QMoveEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                SocExplorerPlot::moveEvent(arg__1);
              }
              bool  PythonQtShell_SocExplorerPlot::nativeEvent(const QByteArray&  eventType, void*  message, long*  result)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "nativeEvent");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"bool" , "const QByteArray&" , "void*" , "long*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
                    bool returnValue;
                  void* args[4] = {NULL, (void*)&eventType, (void*)&message, (void*)&result};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) {
                    args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
                    if (args[0]!=&returnValue) {
                      if (args[0]==NULL) {
                        PythonQt::priv()->handleVirtualOverloadReturnError("nativeEvent", methodInfo, result);
                      } else {
                        returnValue = *((bool*)args[0]);
                      }
                    }
                  }
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return returnValue;
                }
              }
                return SocExplorerPlot::nativeEvent(eventType, message, result);
              }
              QPaintEngine*  PythonQtShell_SocExplorerPlot::paintEngine() const
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEngine");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"QPaintEngine*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
                    QPaintEngine* returnValue;
                  void* args[1] = {NULL};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) {
                    args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
                    if (args[0]!=&returnValue) {
                      if (args[0]==NULL) {
                        PythonQt::priv()->handleVirtualOverloadReturnError("paintEngine", methodInfo, result);
                      } else {
                        returnValue = *((QPaintEngine**)args[0]);
                      }
                    }
                  }
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return returnValue;
                }
              }
                return SocExplorerPlot::paintEngine();
              }
              void PythonQtShell_SocExplorerPlot::paintEvent(QPaintEvent*  arg__1)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEvent");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "QPaintEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                SocExplorerPlot::paintEvent(arg__1);
              }
              QPaintDevice*  PythonQtShell_SocExplorerPlot::redirected(QPoint*  offset) const
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "redirected");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"QPaintDevice*" , "QPoint*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                    QPaintDevice* returnValue;
                  void* args[2] = {NULL, (void*)&offset};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) {
                    args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
                    if (args[0]!=&returnValue) {
                      if (args[0]==NULL) {
                        PythonQt::priv()->handleVirtualOverloadReturnError("redirected", methodInfo, result);
                      } else {
                        returnValue = *((QPaintDevice**)args[0]);
                      }
                    }
                  }
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return returnValue;
                }
              }
                return SocExplorerPlot::redirected(offset);
              }
              void PythonQtShell_SocExplorerPlot::resizeEvent(QResizeEvent*  arg__1)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "resizeEvent");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "QResizeEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                SocExplorerPlot::resizeEvent(arg__1);
              }
              QPainter*  PythonQtShell_SocExplorerPlot::sharedPainter() const
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "sharedPainter");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"QPainter*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
                    QPainter* returnValue;
                  void* args[1] = {NULL};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) {
                    args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
                    if (args[0]!=&returnValue) {
                      if (args[0]==NULL) {
                        PythonQt::priv()->handleVirtualOverloadReturnError("sharedPainter", methodInfo, result);
                      } else {
                        returnValue = *((QPainter**)args[0]);
                      }
                    }
                  }
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return returnValue;
                }
              }
                return SocExplorerPlot::sharedPainter();
              }
              void PythonQtShell_SocExplorerPlot::showEvent(QShowEvent*  arg__1)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "showEvent");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "QShowEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                SocExplorerPlot::showEvent(arg__1);
              }
              QSize  PythonQtShell_SocExplorerPlot::sizeHint() const
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getSizeHint");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"QSize"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
                    QSize returnValue;
                  void* args[1] = {NULL};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) {
                    args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
                    if (args[0]!=&returnValue) {
                      if (args[0]==NULL) {
                        PythonQt::priv()->handleVirtualOverloadReturnError("getSizeHint", methodInfo, result);
                      } else {
                        returnValue = *((QSize*)args[0]);
                      }
                    }
                  }
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return returnValue;
                }
              }
                return SocExplorerPlot::sizeHint();
              }
              void PythonQtShell_SocExplorerPlot::tabletEvent(QTabletEvent*  arg__1)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "tabletEvent");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "QTabletEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                SocExplorerPlot::tabletEvent(arg__1);
              }
              void PythonQtShell_SocExplorerPlot::timerEvent(QTimerEvent*  arg__1)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "timerEvent");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "QTimerEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                SocExplorerPlot::timerEvent(arg__1);
              }
              void PythonQtShell_SocExplorerPlot::wheelEvent(QWheelEvent*  arg__1)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "wheelEvent");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "QWheelEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                SocExplorerPlot::wheelEvent(arg__1);
              }
              SocExplorerPlot* PythonQtWrapper_SocExplorerPlot::new_SocExplorerPlot(QWidget*  parent)
              {
              return new PythonQtShell_SocExplorerPlot(parent); }
              int  PythonQtWrapper_SocExplorerPlot::addGraph(SocExplorerPlot* theWrappedObject)
              {
                return ( theWrappedObject->addGraph());
              }
              void PythonQtWrapper_SocExplorerPlot::addGraphData(SocExplorerPlot* theWrappedObject, int  graphIndex, QList<QVariant >  x, QList<QVariant >  y)
              {
                ( theWrappedObject->addGraphData(graphIndex, x, y));
              }
              void PythonQtWrapper_SocExplorerPlot::addGraphData(SocExplorerPlot* theWrappedObject, int  graphIndex, QVariant  x, QVariant  y)
              {
                ( theWrappedObject->addGraphData(graphIndex, x, y));
              }
              QPen  PythonQtWrapper_SocExplorerPlot::getGraphPen(SocExplorerPlot* theWrappedObject, int  graphIndex)
              {
                return ( theWrappedObject->getGraphPen(graphIndex));
              }
              void PythonQtWrapper_SocExplorerPlot::keyPressEvent(SocExplorerPlot* theWrappedObject, QKeyEvent*  arg__1)
              {
                ( ((PythonQtPublicPromoter_SocExplorerPlot*)theWrappedObject)->promoted_keyPressEvent(arg__1));
              }
              void PythonQtWrapper_SocExplorerPlot::keyReleaseEvent(SocExplorerPlot* theWrappedObject, QKeyEvent*  arg__1)
              {
                ( ((PythonQtPublicPromoter_SocExplorerPlot*)theWrappedObject)->promoted_keyReleaseEvent(arg__1));
              }
              void PythonQtWrapper_SocExplorerPlot::mouseMoveEvent(SocExplorerPlot* theWrappedObject, QMouseEvent*  arg__1)
              {
                ( ((PythonQtPublicPromoter_SocExplorerPlot*)theWrappedObject)->promoted_mouseMoveEvent(arg__1));
              }
              void PythonQtWrapper_SocExplorerPlot::mousePressEvent(SocExplorerPlot* theWrappedObject, QMouseEvent*  arg__1)
              {
                ( ((PythonQtPublicPromoter_SocExplorerPlot*)theWrappedObject)->promoted_mousePressEvent(arg__1));
              }
              void PythonQtWrapper_SocExplorerPlot::mouseReleaseEvent(SocExplorerPlot* theWrappedObject, QMouseEvent*  arg__1)
              {
                ( ((PythonQtPublicPromoter_SocExplorerPlot*)theWrappedObject)->promoted_mouseReleaseEvent(arg__1));
              }
              void PythonQtWrapper_SocExplorerPlot::rescaleAxis(SocExplorerPlot* theWrappedObject)
              {
                ( theWrappedObject->rescaleAxis());
              }
              void PythonQtWrapper_SocExplorerPlot::setAdaptativeSampling(SocExplorerPlot* theWrappedObject, int  graphIndex, bool  enable)
              {
                ( theWrappedObject->setAdaptativeSampling(graphIndex, enable));
              }
              void PythonQtWrapper_SocExplorerPlot::setGraphData(SocExplorerPlot* theWrappedObject, int  graphIndex, QList<QVariant >  x, QList<QVariant >  y)
              {
                ( theWrappedObject->setGraphData(graphIndex, x, y));
              }
              void PythonQtWrapper_SocExplorerPlot::setGraphLineStyle(SocExplorerPlot* theWrappedObject, int  graphIndex, QString  lineStyle)
              {
                ( theWrappedObject->setGraphLineStyle(graphIndex, lineStyle));
              }
              void PythonQtWrapper_SocExplorerPlot::setGraphName(SocExplorerPlot* theWrappedObject, int  graphIndex, QString  name)
              {
                ( theWrappedObject->setGraphName(graphIndex, name));
              }
              void PythonQtWrapper_SocExplorerPlot::setGraphPen(SocExplorerPlot* theWrappedObject, int  graphIndex, QPen  pen)
              {
                ( theWrappedObject->setGraphPen(graphIndex, pen));
              }
              void PythonQtWrapper_SocExplorerPlot::setGraphScatterStyle(SocExplorerPlot* theWrappedObject, int  graphIndex, QString  scatterStyle)
              {
                ( theWrappedObject->setGraphScatterStyle(graphIndex, scatterStyle));
              }
              void PythonQtWrapper_SocExplorerPlot::setLegendFont(SocExplorerPlot* theWrappedObject, QFont  font)
              {
                ( theWrappedObject->setLegendFont(font));
              }
              void PythonQtWrapper_SocExplorerPlot::setLegendSelectedFont(SocExplorerPlot* theWrappedObject, QFont  font)
              {
                ( theWrappedObject->setLegendSelectedFont(font));
              }
              void PythonQtWrapper_SocExplorerPlot::setTitle(SocExplorerPlot* theWrappedObject, QString  title)
              {
                ( theWrappedObject->setTitle(title));
              }
              void PythonQtWrapper_SocExplorerPlot::setXaxisLabel(SocExplorerPlot* theWrappedObject, QString  label)
              {
                ( theWrappedObject->setXaxisLabel(label));
              }
              void PythonQtWrapper_SocExplorerPlot::setXaxisRange(SocExplorerPlot* theWrappedObject, double  lower, double  upper)
              {
                ( theWrappedObject->setXaxisRange(lower, upper));
              }
              void PythonQtWrapper_SocExplorerPlot::setYaxisLabel(SocExplorerPlot* theWrappedObject, QString  label)
              {
                ( theWrappedObject->setYaxisLabel(label));
              }
              void PythonQtWrapper_SocExplorerPlot::setYaxisRange(SocExplorerPlot* theWrappedObject, double  lower, double  upper)
              {
                ( theWrappedObject->setYaxisRange(lower, upper));
              }
              void PythonQtWrapper_SocExplorerPlot::show(SocExplorerPlot* theWrappedObject)
              {
                ( theWrappedObject->show());
              }
              void PythonQtWrapper_SocExplorerPlot::wheelEvent(SocExplorerPlot* theWrappedObject, QWheelEvent*  arg__1)
              {
                ( ((PythonQtPublicPromoter_SocExplorerPlot*)theWrappedObject)->promoted_wheelEvent(arg__1));
              }
              PythonQtShell_TCP_Terminal_Client::~PythonQtShell_TCP_Terminal_Client() {
                PythonQtPrivate* priv = PythonQt::priv();
                if (priv) { priv->shellClassDeleted(this); }
              }
              void PythonQtShell_TCP_Terminal_Client::childEvent(QChildEvent*  arg__1)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "childEvent");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "QChildEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                TCP_Terminal_Client::childEvent(arg__1);
              }
              void PythonQtShell_TCP_Terminal_Client::customEvent(QEvent*  arg__1)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "customEvent");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "QEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                TCP_Terminal_Client::customEvent(arg__1);
              }
              bool  PythonQtShell_TCP_Terminal_Client::event(QEvent*  arg__1)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "event");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"bool" , "QEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                    bool returnValue;
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) {
                    args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
                    if (args[0]!=&returnValue) {
                      if (args[0]==NULL) {
                        PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
                      } else {
                        returnValue = *((bool*)args[0]);
                      }
                    }
                  }
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return returnValue;
                }
              }
                return TCP_Terminal_Client::event(arg__1);
              }
              bool  PythonQtShell_TCP_Terminal_Client::eventFilter(QObject*  arg__1, QEvent*  arg__2)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "eventFilter");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
                    bool returnValue;
                  void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) {
                    args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
                    if (args[0]!=&returnValue) {
                      if (args[0]==NULL) {
                        PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
                      } else {
                        returnValue = *((bool*)args[0]);
                      }
                    }
                  }
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return returnValue;
                }
              }
                return TCP_Terminal_Client::eventFilter(arg__1, arg__2);
              }
              void PythonQtShell_TCP_Terminal_Client::timerEvent(QTimerEvent*  arg__1)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "timerEvent");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "QTimerEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                TCP_Terminal_Client::timerEvent(arg__1);
              }
              TCP_Terminal_Client* PythonQtWrapper_TCP_Terminal_Client::new_TCP_Terminal_Client(QObject*  parent)
              {
              return new PythonQtShell_TCP_Terminal_Client(parent); }
              void PythonQtWrapper_TCP_Terminal_Client::connectToServer(TCP_Terminal_Client* theWrappedObject)
              {
                ( theWrappedObject->connectToServer());
              }
              void PythonQtWrapper_TCP_Terminal_Client::connectToServer(TCP_Terminal_Client* theWrappedObject, const QString&  IP, int  port)
              {
                ( theWrappedObject->connectToServer(IP, port));
              }
              bool  PythonQtWrapper_TCP_Terminal_Client::isConnected(TCP_Terminal_Client* theWrappedObject)
              {
                return ( theWrappedObject->isConnected());
              }
              void PythonQtWrapper_TCP_Terminal_Client::sendText(TCP_Terminal_Client* theWrappedObject, const QString&  text)
              {
                ( theWrappedObject->sendText(text));
              }
              void PythonQtWrapper_TCP_Terminal_Client::startServer(TCP_Terminal_Client* theWrappedObject)
              {
                ( theWrappedObject->startServer());
              }
              void PythonQtWrapper_TCP_Terminal_Client::startServer(TCP_Terminal_Client* theWrappedObject, int  port)
              {
                ( theWrappedObject->startServer(port));
              }
              XByteArray* PythonQtWrapper_XByteArray::new_XByteArray()
              {
              return new XByteArray(); }
              int  PythonQtWrapper_XByteArray::addressOffset(XByteArray* theWrappedObject)
              {
                return ( theWrappedObject->addressOffset());
              }
              int  PythonQtWrapper_XByteArray::addressWidth(XByteArray* theWrappedObject)
              {
                return ( theWrappedObject->addressWidth());
              }
              QChar  PythonQtWrapper_XByteArray::asciiChar(XByteArray* theWrappedObject, int  index)
              {
                return ( theWrappedObject->asciiChar(index));
              }
              QByteArray*  PythonQtWrapper_XByteArray::data(XByteArray* theWrappedObject)
              {
                return &( theWrappedObject->data());
              }
              bool  PythonQtWrapper_XByteArray::dataChanged(XByteArray* theWrappedObject, int  i)
              {
                return ( theWrappedObject->dataChanged(i));
              }
              QByteArray  PythonQtWrapper_XByteArray::dataChanged(XByteArray* theWrappedObject, int  i, int  len)
              {
                return ( theWrappedObject->dataChanged(i, len));
              }
              QByteArray*  PythonQtWrapper_XByteArray::insert(XByteArray* theWrappedObject, int  i, char  ch)
              {
                return &( theWrappedObject->insert(i, ch));
              }
              QByteArray*  PythonQtWrapper_XByteArray::insert(XByteArray* theWrappedObject, int  i, const QByteArray&  ba)
              {
                return &( theWrappedObject->insert(i, ba));
              }
              int  PythonQtWrapper_XByteArray::realAddressNumbers(XByteArray* theWrappedObject)
              {
                return ( theWrappedObject->realAddressNumbers());
              }
              QByteArray*  PythonQtWrapper_XByteArray::remove(XByteArray* theWrappedObject, int  pos, int  len)
              {
                return &( theWrappedObject->remove(pos, len));
              }
              QByteArray*  PythonQtWrapper_XByteArray::replace(XByteArray* theWrappedObject, int  index, char  ch)
              {
                return &( theWrappedObject->replace(index, ch));
              }
              QByteArray*  PythonQtWrapper_XByteArray::replace(XByteArray* theWrappedObject, int  index, const QByteArray&  ba)
              {
                return &( theWrappedObject->replace(index, ba));
              }
              QByteArray*  PythonQtWrapper_XByteArray::replace(XByteArray* theWrappedObject, int  index, int  length, const QByteArray&  ba)
              {
                return &( theWrappedObject->replace(index, length, ba));
              }
              void PythonQtWrapper_XByteArray::setAddressOffset(XByteArray* theWrappedObject, int  offset)
              {
                ( theWrappedObject->setAddressOffset(offset));
              }
              void PythonQtWrapper_XByteArray::setAddressWidth(XByteArray* theWrappedObject, int  width)
              {
                ( theWrappedObject->setAddressWidth(width));
              }
              void PythonQtWrapper_XByteArray::setData(XByteArray* theWrappedObject, QByteArray  data)
              {
                ( theWrappedObject->setData(data));
              }
              void PythonQtWrapper_XByteArray::setDataChanged(XByteArray* theWrappedObject, int  i, bool  state)
              {
                ( theWrappedObject->setDataChanged(i, state));
              }
              void PythonQtWrapper_XByteArray::setDataChanged(XByteArray* theWrappedObject, int  i, const QByteArray&  state)
              {
                ( theWrappedObject->setDataChanged(i, state));
              }
              int  PythonQtWrapper_XByteArray::size(XByteArray* theWrappedObject)
              {
                return ( theWrappedObject->size());
              }
              QString  PythonQtWrapper_XByteArray::toRedableString(XByteArray* theWrappedObject, int  start, int  end)
              {
                return ( theWrappedObject->toRedableString(start, end));
              }
              PythonQtShell_abstractBinFile::~PythonQtShell_abstractBinFile() {
                PythonQtPrivate* priv = PythonQt::priv();
                if (priv) { priv->shellClassDeleted(this); }
              }
              void PythonQtShell_abstractBinFile::childEvent(QChildEvent*  arg__1)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "childEvent");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "QChildEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                abstractBinFile::childEvent(arg__1);
              }
              int  PythonQtShell_abstractBinFile::closeFile()
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "closeFile");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"int"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
                    int returnValue;
                  void* args[1] = {NULL};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) {
                    args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
                    if (args[0]!=&returnValue) {
                      if (args[0]==NULL) {
                        PythonQt::priv()->handleVirtualOverloadReturnError("closeFile", methodInfo, result);
                      } else {
                        returnValue = *((int*)args[0]);
                      }
                    }
                  }
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return returnValue;
                }
              }
                return int();
              }
              void PythonQtShell_abstractBinFile::customEvent(QEvent*  arg__1)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "customEvent");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "QEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                abstractBinFile::customEvent(arg__1);
              }
              bool  PythonQtShell_abstractBinFile::event(QEvent*  arg__1)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "event");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"bool" , "QEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                    bool returnValue;
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) {
                    args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
                    if (args[0]!=&returnValue) {
                      if (args[0]==NULL) {
                        PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
                      } else {
                        returnValue = *((bool*)args[0]);
                      }
                    }
                  }
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return returnValue;
                }
              }
                return abstractBinFile::event(arg__1);
              }
              bool  PythonQtShell_abstractBinFile::eventFilter(QObject*  arg__1, QEvent*  arg__2)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "eventFilter");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
                    bool returnValue;
                  void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) {
                    args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
                    if (args[0]!=&returnValue) {
                      if (args[0]==NULL) {
                        PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
                      } else {
                        returnValue = *((bool*)args[0]);
                      }
                    }
                  }
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return returnValue;
                }
              }
                return abstractBinFile::eventFilter(arg__1, arg__2);
              }
              QList<codeFragment* >  PythonQtShell_abstractBinFile::getFragments()
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getFragments");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"QList<codeFragment* >"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
                    QList<codeFragment* > returnValue;
                  void* args[1] = {NULL};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) {
                    args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
                    if (args[0]!=&returnValue) {
                      if (args[0]==NULL) {
                        PythonQt::priv()->handleVirtualOverloadReturnError("getFragments", methodInfo, result);
                      } else {
                        returnValue = *((QList<codeFragment* >*)args[0]);
                      }
                    }
                  }
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return returnValue;
                }
              }
                return QList<codeFragment* >();
              }
              bool  PythonQtShell_abstractBinFile::isopened()
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "isopened");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"bool"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
                    bool returnValue;
                  void* args[1] = {NULL};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) {
                    args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
                    if (args[0]!=&returnValue) {
                      if (args[0]==NULL) {
                        PythonQt::priv()->handleVirtualOverloadReturnError("isopened", methodInfo, result);
                      } else {
                        returnValue = *((bool*)args[0]);
                      }
                    }
                  }
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return returnValue;
                }
              }
                return bool();
              }
              bool  PythonQtShell_abstractBinFile::openFile(const QString&  File)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "openFile");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"bool" , "const QString&"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                    bool returnValue;
                  void* args[2] = {NULL, (void*)&File};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) {
                    args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
                    if (args[0]!=&returnValue) {
                      if (args[0]==NULL) {
                        PythonQt::priv()->handleVirtualOverloadReturnError("openFile", methodInfo, result);
                      } else {
                        returnValue = *((bool*)args[0]);
                      }
                    }
                  }
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return returnValue;
                }
              }
                return bool();
              }
              void PythonQtShell_abstractBinFile::timerEvent(QTimerEvent*  arg__1)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "timerEvent");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "QTimerEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                abstractBinFile::timerEvent(arg__1);
              }
              bool  PythonQtShell_abstractBinFile::toBinary(const QString&  File)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "toBinary");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"bool" , "const QString&"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                    bool returnValue;
                  void* args[2] = {NULL, (void*)&File};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) {
                    args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
                    if (args[0]!=&returnValue) {
                      if (args[0]==NULL) {
                        PythonQt::priv()->handleVirtualOverloadReturnError("toBinary", methodInfo, result);
                      } else {
                        returnValue = *((bool*)args[0]);
                      }
                    }
                  }
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return returnValue;
                }
              }
                return bool();
              }
              bool  PythonQtShell_abstractBinFile::toSrec(const QString&  File)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "toSrec");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"bool" , "const QString&"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                    bool returnValue;
                  void* args[2] = {NULL, (void*)&File};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) {
                    args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
                    if (args[0]!=&returnValue) {
                      if (args[0]==NULL) {
                        PythonQt::priv()->handleVirtualOverloadReturnError("toSrec", methodInfo, result);
                      } else {
                        returnValue = *((bool*)args[0]);
                      }
                    }
                  }
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return returnValue;
                }
              }
                return bool();
              }
              abstractBinFile* PythonQtWrapper_abstractBinFile::new_abstractBinFile()
              {
              return new PythonQtShell_abstractBinFile(); }
              PythonQtShell_abstractBinFileWidget::~PythonQtShell_abstractBinFileWidget() {
                PythonQtPrivate* priv = PythonQt::priv();
                if (priv) { priv->shellClassDeleted(this); }
              }
              void PythonQtShell_abstractBinFileWidget::actionEvent(QActionEvent*  arg__1)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "actionEvent");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "QActionEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                abstractBinFileWidget::actionEvent(arg__1);
              }
              void PythonQtShell_abstractBinFileWidget::changeEvent(QEvent*  arg__1)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "changeEvent");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "QEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                abstractBinFileWidget::changeEvent(arg__1);
              }
              void PythonQtShell_abstractBinFileWidget::childEvent(QChildEvent*  arg__1)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "childEvent");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "QChildEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                abstractBinFileWidget::childEvent(arg__1);
              }
              void PythonQtShell_abstractBinFileWidget::closeEvent(QCloseEvent*  arg__1)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "closeEvent");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "QCloseEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                abstractBinFileWidget::closeEvent(arg__1);
              }
              void PythonQtShell_abstractBinFileWidget::contextMenuEvent(QContextMenuEvent*  arg__1)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "contextMenuEvent");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "QContextMenuEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                abstractBinFileWidget::contextMenuEvent(arg__1);
              }
              void PythonQtShell_abstractBinFileWidget::customEvent(QEvent*  arg__1)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "customEvent");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "QEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                abstractBinFileWidget::customEvent(arg__1);
              }
              int  PythonQtShell_abstractBinFileWidget::devType() const
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "devType");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"int"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
                    int returnValue;
                  void* args[1] = {NULL};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) {
                    args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
                    if (args[0]!=&returnValue) {
                      if (args[0]==NULL) {
                        PythonQt::priv()->handleVirtualOverloadReturnError("devType", methodInfo, result);
                      } else {
                        returnValue = *((int*)args[0]);
                      }
                    }
                  }
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return returnValue;
                }
              }
                return abstractBinFileWidget::devType();
              }
              void PythonQtShell_abstractBinFileWidget::dragEnterEvent(QDragEnterEvent*  arg__1)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragEnterEvent");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "QDragEnterEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                abstractBinFileWidget::dragEnterEvent(arg__1);
              }
              void PythonQtShell_abstractBinFileWidget::dragLeaveEvent(QDragLeaveEvent*  arg__1)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragLeaveEvent");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "QDragLeaveEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                abstractBinFileWidget::dragLeaveEvent(arg__1);
              }
              void PythonQtShell_abstractBinFileWidget::dragMoveEvent(QDragMoveEvent*  arg__1)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragMoveEvent");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "QDragMoveEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                abstractBinFileWidget::dragMoveEvent(arg__1);
              }
              void PythonQtShell_abstractBinFileWidget::dropEvent(QDropEvent*  arg__1)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dropEvent");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "QDropEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                abstractBinFileWidget::dropEvent(arg__1);
              }
              void PythonQtShell_abstractBinFileWidget::enterEvent(QEvent*  arg__1)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "enterEvent");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "QEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                abstractBinFileWidget::enterEvent(arg__1);
              }
              bool  PythonQtShell_abstractBinFileWidget::event(QEvent*  arg__1)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "event");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"bool" , "QEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                    bool returnValue;
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) {
                    args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
                    if (args[0]!=&returnValue) {
                      if (args[0]==NULL) {
                        PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
                      } else {
                        returnValue = *((bool*)args[0]);
                      }
                    }
                  }
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return returnValue;
                }
              }
                return abstractBinFileWidget::event(arg__1);
              }
              bool  PythonQtShell_abstractBinFileWidget::eventFilter(QObject*  arg__1, QEvent*  arg__2)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "eventFilter");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
                    bool returnValue;
                  void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) {
                    args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
                    if (args[0]!=&returnValue) {
                      if (args[0]==NULL) {
                        PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
                      } else {
                        returnValue = *((bool*)args[0]);
                      }
                    }
                  }
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return returnValue;
                }
              }
                return abstractBinFileWidget::eventFilter(arg__1, arg__2);
              }
              void PythonQtShell_abstractBinFileWidget::focusInEvent(QFocusEvent*  arg__1)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusInEvent");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "QFocusEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                abstractBinFileWidget::focusInEvent(arg__1);
              }
              bool  PythonQtShell_abstractBinFileWidget::focusNextPrevChild(bool  next)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusNextPrevChild");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"bool" , "bool"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                    bool returnValue;
                  void* args[2] = {NULL, (void*)&next};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) {
                    args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
                    if (args[0]!=&returnValue) {
                      if (args[0]==NULL) {
                        PythonQt::priv()->handleVirtualOverloadReturnError("focusNextPrevChild", methodInfo, result);
                      } else {
                        returnValue = *((bool*)args[0]);
                      }
                    }
                  }
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return returnValue;
                }
              }
                return abstractBinFileWidget::focusNextPrevChild(next);
              }
              void PythonQtShell_abstractBinFileWidget::focusOutEvent(QFocusEvent*  arg__1)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusOutEvent");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "QFocusEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                abstractBinFileWidget::focusOutEvent(arg__1);
              }
              bool  PythonQtShell_abstractBinFileWidget::hasHeightForWidth() const
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hasHeightForWidth");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"bool"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
                    bool returnValue;
                  void* args[1] = {NULL};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) {
                    args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
                    if (args[0]!=&returnValue) {
                      if (args[0]==NULL) {
                        PythonQt::priv()->handleVirtualOverloadReturnError("hasHeightForWidth", methodInfo, result);
                      } else {
                        returnValue = *((bool*)args[0]);
                      }
                    }
                  }
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return returnValue;
                }
              }
                return abstractBinFileWidget::hasHeightForWidth();
              }
              int  PythonQtShell_abstractBinFileWidget::heightForWidth(int  arg__1) const
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "heightForWidth");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"int" , "int"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                    int returnValue;
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) {
                    args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
                    if (args[0]!=&returnValue) {
                      if (args[0]==NULL) {
                        PythonQt::priv()->handleVirtualOverloadReturnError("heightForWidth", methodInfo, result);
                      } else {
                        returnValue = *((int*)args[0]);
                      }
                    }
                  }
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return returnValue;
                }
              }
                return abstractBinFileWidget::heightForWidth(arg__1);
              }
              void PythonQtShell_abstractBinFileWidget::hideEvent(QHideEvent*  arg__1)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hideEvent");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "QHideEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                abstractBinFileWidget::hideEvent(arg__1);
              }
              void PythonQtShell_abstractBinFileWidget::initPainter(QPainter*  painter) const
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "initPainter");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "QPainter*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&painter};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                abstractBinFileWidget::initPainter(painter);
              }
              void PythonQtShell_abstractBinFileWidget::inputMethodEvent(QInputMethodEvent*  arg__1)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodEvent");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "QInputMethodEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                abstractBinFileWidget::inputMethodEvent(arg__1);
              }
              QVariant  PythonQtShell_abstractBinFileWidget::inputMethodQuery(Qt::InputMethodQuery  arg__1) const
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodQuery");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"QVariant" , "Qt::InputMethodQuery"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                    QVariant returnValue;
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) {
                    args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
                    if (args[0]!=&returnValue) {
                      if (args[0]==NULL) {
                        PythonQt::priv()->handleVirtualOverloadReturnError("inputMethodQuery", methodInfo, result);
                      } else {
                        returnValue = *((QVariant*)args[0]);
                      }
                    }
                  }
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return returnValue;
                }
              }
                return abstractBinFileWidget::inputMethodQuery(arg__1);
              }
              void PythonQtShell_abstractBinFileWidget::keyPressEvent(QKeyEvent*  arg__1)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyPressEvent");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "QKeyEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                abstractBinFileWidget::keyPressEvent(arg__1);
              }
              void PythonQtShell_abstractBinFileWidget::keyReleaseEvent(QKeyEvent*  arg__1)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyReleaseEvent");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "QKeyEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                abstractBinFileWidget::keyReleaseEvent(arg__1);
              }
              void PythonQtShell_abstractBinFileWidget::leaveEvent(QEvent*  arg__1)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "leaveEvent");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "QEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                abstractBinFileWidget::leaveEvent(arg__1);
              }
              int  PythonQtShell_abstractBinFileWidget::metric(QPaintDevice::PaintDeviceMetric  arg__1) const
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "metric");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"int" , "QPaintDevice::PaintDeviceMetric"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                    int returnValue;
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) {
                    args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
                    if (args[0]!=&returnValue) {
                      if (args[0]==NULL) {
                        PythonQt::priv()->handleVirtualOverloadReturnError("metric", methodInfo, result);
                      } else {
                        returnValue = *((int*)args[0]);
                      }
                    }
                  }
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return returnValue;
                }
              }
                return abstractBinFileWidget::metric(arg__1);
              }
              QSize  PythonQtShell_abstractBinFileWidget::minimumSizeHint() const
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getMinimumSizeHint");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"QSize"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
                    QSize returnValue;
                  void* args[1] = {NULL};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) {
                    args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
                    if (args[0]!=&returnValue) {
                      if (args[0]==NULL) {
                        PythonQt::priv()->handleVirtualOverloadReturnError("getMinimumSizeHint", methodInfo, result);
                      } else {
                        returnValue = *((QSize*)args[0]);
                      }
                    }
                  }
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return returnValue;
                }
              }
                return abstractBinFileWidget::minimumSizeHint();
              }
              void PythonQtShell_abstractBinFileWidget::mouseDoubleClickEvent(QMouseEvent*  arg__1)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseDoubleClickEvent");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "QMouseEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                abstractBinFileWidget::mouseDoubleClickEvent(arg__1);
              }
              void PythonQtShell_abstractBinFileWidget::mouseMoveEvent(QMouseEvent*  arg__1)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseMoveEvent");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "QMouseEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                abstractBinFileWidget::mouseMoveEvent(arg__1);
              }
              void PythonQtShell_abstractBinFileWidget::mousePressEvent(QMouseEvent*  arg__1)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mousePressEvent");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "QMouseEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                abstractBinFileWidget::mousePressEvent(arg__1);
              }
              void PythonQtShell_abstractBinFileWidget::mouseReleaseEvent(QMouseEvent*  arg__1)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseReleaseEvent");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "QMouseEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                abstractBinFileWidget::mouseReleaseEvent(arg__1);
              }
              void PythonQtShell_abstractBinFileWidget::moveEvent(QMoveEvent*  arg__1)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "moveEvent");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "QMoveEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                abstractBinFileWidget::moveEvent(arg__1);
              }
              bool  PythonQtShell_abstractBinFileWidget::nativeEvent(const QByteArray&  eventType, void*  message, long*  result)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "nativeEvent");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"bool" , "const QByteArray&" , "void*" , "long*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
                    bool returnValue;
                  void* args[4] = {NULL, (void*)&eventType, (void*)&message, (void*)&result};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) {
                    args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
                    if (args[0]!=&returnValue) {
                      if (args[0]==NULL) {
                        PythonQt::priv()->handleVirtualOverloadReturnError("nativeEvent", methodInfo, result);
                      } else {
                        returnValue = *((bool*)args[0]);
                      }
                    }
                  }
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return returnValue;
                }
              }
                return abstractBinFileWidget::nativeEvent(eventType, message, result);
              }
              QPaintEngine*  PythonQtShell_abstractBinFileWidget::paintEngine() const
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEngine");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"QPaintEngine*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
                    QPaintEngine* returnValue;
                  void* args[1] = {NULL};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) {
                    args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
                    if (args[0]!=&returnValue) {
                      if (args[0]==NULL) {
                        PythonQt::priv()->handleVirtualOverloadReturnError("paintEngine", methodInfo, result);
                      } else {
                        returnValue = *((QPaintEngine**)args[0]);
                      }
                    }
                  }
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return returnValue;
                }
              }
                return abstractBinFileWidget::paintEngine();
              }
              void PythonQtShell_abstractBinFileWidget::paintEvent(QPaintEvent*  arg__1)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEvent");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "QPaintEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                abstractBinFileWidget::paintEvent(arg__1);
              }
              QPaintDevice*  PythonQtShell_abstractBinFileWidget::redirected(QPoint*  offset) const
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "redirected");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"QPaintDevice*" , "QPoint*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                    QPaintDevice* returnValue;
                  void* args[2] = {NULL, (void*)&offset};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) {
                    args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
                    if (args[0]!=&returnValue) {
                      if (args[0]==NULL) {
                        PythonQt::priv()->handleVirtualOverloadReturnError("redirected", methodInfo, result);
                      } else {
                        returnValue = *((QPaintDevice**)args[0]);
                      }
                    }
                  }
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return returnValue;
                }
              }
                return abstractBinFileWidget::redirected(offset);
              }
              void PythonQtShell_abstractBinFileWidget::reloadFile()
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "reloadFile");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={""};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
                  void* args[1] = {NULL};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
              }
              void PythonQtShell_abstractBinFileWidget::resizeEvent(QResizeEvent*  arg__1)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "resizeEvent");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "QResizeEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                abstractBinFileWidget::resizeEvent(arg__1);
              }
              void PythonQtShell_abstractBinFileWidget::setFile(abstractBinFile*  file)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "setFile");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "abstractBinFile*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&file};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
              }
              QPainter*  PythonQtShell_abstractBinFileWidget::sharedPainter() const
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "sharedPainter");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"QPainter*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
                    QPainter* returnValue;
                  void* args[1] = {NULL};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) {
                    args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
                    if (args[0]!=&returnValue) {
                      if (args[0]==NULL) {
                        PythonQt::priv()->handleVirtualOverloadReturnError("sharedPainter", methodInfo, result);
                      } else {
                        returnValue = *((QPainter**)args[0]);
                      }
                    }
                  }
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return returnValue;
                }
              }
                return abstractBinFileWidget::sharedPainter();
              }
              void PythonQtShell_abstractBinFileWidget::showEvent(QShowEvent*  arg__1)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "showEvent");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "QShowEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                abstractBinFileWidget::showEvent(arg__1);
              }
              QSize  PythonQtShell_abstractBinFileWidget::sizeHint() const
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getSizeHint");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"QSize"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
                    QSize returnValue;
                  void* args[1] = {NULL};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) {
                    args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
                    if (args[0]!=&returnValue) {
                      if (args[0]==NULL) {
                        PythonQt::priv()->handleVirtualOverloadReturnError("getSizeHint", methodInfo, result);
                      } else {
                        returnValue = *((QSize*)args[0]);
                      }
                    }
                  }
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return returnValue;
                }
              }
                return abstractBinFileWidget::sizeHint();
              }
              void PythonQtShell_abstractBinFileWidget::tabletEvent(QTabletEvent*  arg__1)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "tabletEvent");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "QTabletEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                abstractBinFileWidget::tabletEvent(arg__1);
              }
              void PythonQtShell_abstractBinFileWidget::timerEvent(QTimerEvent*  arg__1)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "timerEvent");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "QTimerEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                abstractBinFileWidget::timerEvent(arg__1);
              }
              void PythonQtShell_abstractBinFileWidget::wheelEvent(QWheelEvent*  arg__1)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "wheelEvent");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "QWheelEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                abstractBinFileWidget::wheelEvent(arg__1);
              }
              abstractBinFileWidget* PythonQtWrapper_abstractBinFileWidget::new_abstractBinFileWidget(QWidget*  parent)
              {
              return new PythonQtShell_abstractBinFileWidget(parent); }
              PythonQtShell_binaryFile::~PythonQtShell_binaryFile() {
                PythonQtPrivate* priv = PythonQt::priv();
                if (priv) { priv->shellClassDeleted(this); }
              }
              int  PythonQtShell_binaryFile::closeFile()
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "closeFile");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"int"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
                    int returnValue;
                  void* args[1] = {NULL};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) {
                    args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
                    if (args[0]!=&returnValue) {
                      if (args[0]==NULL) {
                        PythonQt::priv()->handleVirtualOverloadReturnError("closeFile", methodInfo, result);
                      } else {
                        returnValue = *((int*)args[0]);
                      }
                    }
                  }
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return returnValue;
                }
              }
                return binaryFile::closeFile();
              }
              QList<codeFragment* >  PythonQtShell_binaryFile::getFragments()
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getFragments");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"QList<codeFragment* >"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
                    QList<codeFragment* > returnValue;
                  void* args[1] = {NULL};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) {
                    args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
                    if (args[0]!=&returnValue) {
                      if (args[0]==NULL) {
                        PythonQt::priv()->handleVirtualOverloadReturnError("getFragments", methodInfo, result);
                      } else {
                        returnValue = *((QList<codeFragment* >*)args[0]);
                      }
                    }
                  }
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return returnValue;
                }
              }
                return binaryFile::getFragments();
              }
              bool  PythonQtShell_binaryFile::isopened()
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "isopened");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"bool"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
                    bool returnValue;
                  void* args[1] = {NULL};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) {
                    args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
                    if (args[0]!=&returnValue) {
                      if (args[0]==NULL) {
                        PythonQt::priv()->handleVirtualOverloadReturnError("isopened", methodInfo, result);
                      } else {
                        returnValue = *((bool*)args[0]);
                      }
                    }
                  }
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return returnValue;
                }
              }
                return binaryFile::isopened();
              }
              bool  PythonQtShell_binaryFile::openFile(const QString&  File)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "openFile");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"bool" , "const QString&"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                    bool returnValue;
                  void* args[2] = {NULL, (void*)&File};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) {
                    args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
                    if (args[0]!=&returnValue) {
                      if (args[0]==NULL) {
                        PythonQt::priv()->handleVirtualOverloadReturnError("openFile", methodInfo, result);
                      } else {
                        returnValue = *((bool*)args[0]);
                      }
                    }
                  }
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return returnValue;
                }
              }
                return binaryFile::openFile(File);
              }
              bool  PythonQtShell_binaryFile::toBinary(const QString&  fileName)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "toBinary");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"bool" , "const QString&"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                    bool returnValue;
                  void* args[2] = {NULL, (void*)&fileName};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) {
                    args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
                    if (args[0]!=&returnValue) {
                      if (args[0]==NULL) {
                        PythonQt::priv()->handleVirtualOverloadReturnError("toBinary", methodInfo, result);
                      } else {
                        returnValue = *((bool*)args[0]);
                      }
                    }
                  }
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return returnValue;
                }
              }
                return binaryFile::toBinary(fileName);
              }
              bool  PythonQtShell_binaryFile::toSrec(const QString&  fileName)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "toSrec");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"bool" , "const QString&"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                    bool returnValue;
                  void* args[2] = {NULL, (void*)&fileName};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) {
                    args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
                    if (args[0]!=&returnValue) {
                      if (args[0]==NULL) {
                        PythonQt::priv()->handleVirtualOverloadReturnError("toSrec", methodInfo, result);
                      } else {
                        returnValue = *((bool*)args[0]);
                      }
                    }
                  }
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return returnValue;
                }
              }
                return binaryFile::toSrec(fileName);
              }
              binaryFile* PythonQtWrapper_binaryFile::new_binaryFile()
              {
              return new PythonQtShell_binaryFile(); }
              binaryFile* PythonQtWrapper_binaryFile::new_binaryFile(const QString&  File)
              {
              return new PythonQtShell_binaryFile(File); }
              binaryFile* PythonQtWrapper_binaryFile::new_binaryFile(const QStringList&  Files)
              {
              return new PythonQtShell_binaryFile(Files); }
              int  PythonQtWrapper_binaryFile::closeFile(binaryFile* theWrappedObject)
              {
                return ( ((PythonQtPublicPromoter_binaryFile*)theWrappedObject)->promoted_closeFile());
              }
              codeFragment*  PythonQtWrapper_binaryFile::getFragment(binaryFile* theWrappedObject, int  index)
              {
                return ( theWrappedObject->getFragment(index));
              }
              int  PythonQtWrapper_binaryFile::getFragmentAddress(binaryFile* theWrappedObject, int  index)
              {
                return ( theWrappedObject->getFragmentAddress(index));
              }
              bool  PythonQtWrapper_binaryFile::getFragmentData(binaryFile* theWrappedObject, int  index, char**  buffer)
              {
                return ( theWrappedObject->getFragmentData(index, buffer));
              }
              QString  PythonQtWrapper_binaryFile::getFragmentHeader(binaryFile* theWrappedObject, int  index)
              {
                return ( theWrappedObject->getFragmentHeader(index));
              }
              int  PythonQtWrapper_binaryFile::getFragmentSize(binaryFile* theWrappedObject, int  index)
              {
                return ( theWrappedObject->getFragmentSize(index));
              }
              QList<codeFragment* >  PythonQtWrapper_binaryFile::getFragments(binaryFile* theWrappedObject)
              {
                return ( ((PythonQtPublicPromoter_binaryFile*)theWrappedObject)->promoted_getFragments());
              }
              int  PythonQtWrapper_binaryFile::getFragmentsCount(binaryFile* theWrappedObject)
              {
                return ( theWrappedObject->getFragmentsCount());
              }
              bool  PythonQtWrapper_binaryFile::isopened(binaryFile* theWrappedObject)
              {
                return ( ((PythonQtPublicPromoter_binaryFile*)theWrappedObject)->promoted_isopened());
              }
              bool  PythonQtWrapper_binaryFile::openFile(binaryFile* theWrappedObject, const QString&  File)
              {
                return ( ((PythonQtPublicPromoter_binaryFile*)theWrappedObject)->promoted_openFile(File));
              }
              bool  PythonQtWrapper_binaryFile::openFiles(binaryFile* theWrappedObject, const QStringList&  Files)
              {
                return ( theWrappedObject->openFiles(Files));
              }
              bool  PythonQtWrapper_binaryFile::static_binaryFile_toBinary(QList<codeFragment* >  fragments, const QString&  File)
              {
                return (binaryFile::toBinary(fragments, File));
              }
              bool  PythonQtWrapper_binaryFile::toBinary(binaryFile* theWrappedObject, const QString&  fileName)
              {
                return ( ((PythonQtPublicPromoter_binaryFile*)theWrappedObject)->promoted_toBinary(fileName));
              }
              bool  PythonQtWrapper_binaryFile::toSrec(binaryFile* theWrappedObject, const QString&  fileName)
              {
                return ( ((PythonQtPublicPromoter_binaryFile*)theWrappedObject)->promoted_toSrec(fileName));
              }
              PythonQtShell_binaryFileWidget::~PythonQtShell_binaryFileWidget() {
                PythonQtPrivate* priv = PythonQt::priv();
                if (priv) { priv->shellClassDeleted(this); }
              }
              void PythonQtShell_binaryFileWidget::reloadFile()
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "reloadFile");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={""};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
                  void* args[1] = {NULL};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                binaryFileWidget::reloadFile();
              }
              void PythonQtShell_binaryFileWidget::setFile(abstractBinFile*  file)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "setFile");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "abstractBinFile*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&file};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                binaryFileWidget::setFile(file);
              }
              binaryFileWidget* PythonQtWrapper_binaryFileWidget::new_binaryFileWidget(QWidget*  parent)
              {
              return new PythonQtShell_binaryFileWidget(parent); }
              void PythonQtWrapper_binaryFileWidget::reloadFile(binaryFileWidget* theWrappedObject)
              {
                ( ((PythonQtPublicPromoter_binaryFileWidget*)theWrappedObject)->promoted_reloadFile());
              }
              void PythonQtWrapper_binaryFileWidget::setFile(binaryFileWidget* theWrappedObject, abstractBinFile*  file)
              {
                ( ((PythonQtPublicPromoter_binaryFileWidget*)theWrappedObject)->promoted_setFile(file));
              }
              PythonQtShell_codeFragment::~PythonQtShell_codeFragment() {
                PythonQtPrivate* priv = PythonQt::priv();
                if (priv) { priv->shellClassDeleted(this); }
              }
              codeFragment* PythonQtWrapper_codeFragment::new_codeFragment()
              {
              return new PythonQtShell_codeFragment(); }
              codeFragment* PythonQtWrapper_codeFragment::new_codeFragment(char*  data, quint64  size, quint64  address)
              {
              return new PythonQtShell_codeFragment(data, size, address); }
              PythonQtShell_elfFileWidget::~PythonQtShell_elfFileWidget() {
                PythonQtPrivate* priv = PythonQt::priv();
                if (priv) { priv->shellClassDeleted(this); }
              }
              void PythonQtShell_elfFileWidget::reloadFile()
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "reloadFile");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={""};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
                  void* args[1] = {NULL};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                elfFileWidget::reloadFile();
              }
              void PythonQtShell_elfFileWidget::setFile(abstractBinFile*  file)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "setFile");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "abstractBinFile*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&file};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
+               elfFileWidget::setFile(file);
              }
              elfFileWidget* PythonQtWrapper_elfFileWidget::new_elfFileWidget(QWidget*  parent)
              {
              return new PythonQtShell_elfFileWidget(parent); }
              void PythonQtWrapper_elfFileWidget::reloadFile(elfFileWidget* theWrappedObject)
              {
                ( ((PythonQtPublicPromoter_elfFileWidget*)theWrappedObject)->promoted_reloadFile());
              }
+             void PythonQtWrapper_elfFileWidget::setFile(elfFileWidget* theWrappedObject, abstractBinFile*  file)
+             {
+               ( ((PythonQtPublicPromoter_elfFileWidget*)theWrappedObject)->promoted_setFile(file));
+             }
              PythonQtShell_elfInfoWdgt::~PythonQtShell_elfInfoWdgt() {
                PythonQtPrivate* priv = PythonQt::priv();
                if (priv) { priv->shellClassDeleted(this); }
              }
              void PythonQtShell_elfInfoWdgt::actionEvent(QActionEvent*  arg__1)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "actionEvent");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "QActionEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                elfInfoWdgt::actionEvent(arg__1);
              }
              void PythonQtShell_elfInfoWdgt::changeEvent(QEvent*  arg__1)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "changeEvent");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "QEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                elfInfoWdgt::changeEvent(arg__1);
              }
              void PythonQtShell_elfInfoWdgt::childEvent(QChildEvent*  arg__1)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "childEvent");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "QChildEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                elfInfoWdgt::childEvent(arg__1);
              }
              void PythonQtShell_elfInfoWdgt::closeEvent(QCloseEvent*  arg__1)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "closeEvent");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "QCloseEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                elfInfoWdgt::closeEvent(arg__1);
              }
              void PythonQtShell_elfInfoWdgt::contextMenuEvent(QContextMenuEvent*  arg__1)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "contextMenuEvent");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "QContextMenuEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                elfInfoWdgt::contextMenuEvent(arg__1);
              }
              void PythonQtShell_elfInfoWdgt::customEvent(QEvent*  arg__1)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "customEvent");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "QEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                elfInfoWdgt::customEvent(arg__1);
              }
              int  PythonQtShell_elfInfoWdgt::devType() const
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "devType");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"int"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
                    int returnValue;
                  void* args[1] = {NULL};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) {
                    args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
                    if (args[0]!=&returnValue) {
                      if (args[0]==NULL) {
                        PythonQt::priv()->handleVirtualOverloadReturnError("devType", methodInfo, result);
                      } else {
                        returnValue = *((int*)args[0]);
                      }
                    }
                  }
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return returnValue;
                }
              }
                return elfInfoWdgt::devType();
              }
              void PythonQtShell_elfInfoWdgt::dragEnterEvent(QDragEnterEvent*  arg__1)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragEnterEvent");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "QDragEnterEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                elfInfoWdgt::dragEnterEvent(arg__1);
              }
              void PythonQtShell_elfInfoWdgt::dragLeaveEvent(QDragLeaveEvent*  arg__1)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragLeaveEvent");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "QDragLeaveEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                elfInfoWdgt::dragLeaveEvent(arg__1);
              }
              void PythonQtShell_elfInfoWdgt::dragMoveEvent(QDragMoveEvent*  arg__1)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragMoveEvent");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "QDragMoveEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                elfInfoWdgt::dragMoveEvent(arg__1);
              }
              void PythonQtShell_elfInfoWdgt::dropEvent(QDropEvent*  arg__1)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dropEvent");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "QDropEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                elfInfoWdgt::dropEvent(arg__1);
              }
              void PythonQtShell_elfInfoWdgt::enterEvent(QEvent*  arg__1)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "enterEvent");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "QEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                elfInfoWdgt::enterEvent(arg__1);
              }
              bool  PythonQtShell_elfInfoWdgt::event(QEvent*  arg__1)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "event");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"bool" , "QEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                    bool returnValue;
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) {
                    args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
                    if (args[0]!=&returnValue) {
                      if (args[0]==NULL) {
                        PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
                      } else {
                        returnValue = *((bool*)args[0]);
                      }
                    }
                  }
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return returnValue;
                }
              }
                return elfInfoWdgt::event(arg__1);
              }
              bool  PythonQtShell_elfInfoWdgt::eventFilter(QObject*  arg__1, QEvent*  arg__2)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "eventFilter");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
                    bool returnValue;
                  void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) {
                    args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
                    if (args[0]!=&returnValue) {
                      if (args[0]==NULL) {
                        PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
                      } else {
                        returnValue = *((bool*)args[0]);
                      }
                    }
                  }
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return returnValue;
                }
              }
                return elfInfoWdgt::eventFilter(arg__1, arg__2);
              }
              void PythonQtShell_elfInfoWdgt::focusInEvent(QFocusEvent*  arg__1)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusInEvent");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "QFocusEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                elfInfoWdgt::focusInEvent(arg__1);
              }
              bool  PythonQtShell_elfInfoWdgt::focusNextPrevChild(bool  next)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusNextPrevChild");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"bool" , "bool"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                    bool returnValue;
                  void* args[2] = {NULL, (void*)&next};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) {
                    args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
                    if (args[0]!=&returnValue) {
                      if (args[0]==NULL) {
                        PythonQt::priv()->handleVirtualOverloadReturnError("focusNextPrevChild", methodInfo, result);
                      } else {
                        returnValue = *((bool*)args[0]);
                      }
                    }
                  }
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return returnValue;
                }
              }
                return elfInfoWdgt::focusNextPrevChild(next);
              }
              void PythonQtShell_elfInfoWdgt::focusOutEvent(QFocusEvent*  arg__1)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusOutEvent");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "QFocusEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                elfInfoWdgt::focusOutEvent(arg__1);
              }
              bool  PythonQtShell_elfInfoWdgt::hasHeightForWidth() const
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hasHeightForWidth");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"bool"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
                    bool returnValue;
                  void* args[1] = {NULL};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) {
                    args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
                    if (args[0]!=&returnValue) {
                      if (args[0]==NULL) {
                        PythonQt::priv()->handleVirtualOverloadReturnError("hasHeightForWidth", methodInfo, result);
                      } else {
                        returnValue = *((bool*)args[0]);
                      }
                    }
                  }
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return returnValue;
                }
              }
                return elfInfoWdgt::hasHeightForWidth();
              }
              int  PythonQtShell_elfInfoWdgt::heightForWidth(int  arg__1) const
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "heightForWidth");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"int" , "int"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                    int returnValue;
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) {
                    args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
                    if (args[0]!=&returnValue) {
                      if (args[0]==NULL) {
                        PythonQt::priv()->handleVirtualOverloadReturnError("heightForWidth", methodInfo, result);
                      } else {
                        returnValue = *((int*)args[0]);
                      }
                    }
                  }
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return returnValue;
                }
              }
                return elfInfoWdgt::heightForWidth(arg__1);
              }
              void PythonQtShell_elfInfoWdgt::hideEvent(QHideEvent*  arg__1)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hideEvent");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "QHideEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                elfInfoWdgt::hideEvent(arg__1);
              }
              void PythonQtShell_elfInfoWdgt::initPainter(QPainter*  painter) const
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "initPainter");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "QPainter*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&painter};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                elfInfoWdgt::initPainter(painter);
              }
              void PythonQtShell_elfInfoWdgt::inputMethodEvent(QInputMethodEvent*  arg__1)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodEvent");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "QInputMethodEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                elfInfoWdgt::inputMethodEvent(arg__1);
              }
              QVariant  PythonQtShell_elfInfoWdgt::inputMethodQuery(Qt::InputMethodQuery  arg__1) const
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodQuery");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"QVariant" , "Qt::InputMethodQuery"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                    QVariant returnValue;
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) {
                    args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
                    if (args[0]!=&returnValue) {
                      if (args[0]==NULL) {
                        PythonQt::priv()->handleVirtualOverloadReturnError("inputMethodQuery", methodInfo, result);
                      } else {
                        returnValue = *((QVariant*)args[0]);
                      }
                    }
                  }
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return returnValue;
                }
              }
                return elfInfoWdgt::inputMethodQuery(arg__1);
              }
              void PythonQtShell_elfInfoWdgt::keyPressEvent(QKeyEvent*  arg__1)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyPressEvent");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "QKeyEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                elfInfoWdgt::keyPressEvent(arg__1);
              }
              void PythonQtShell_elfInfoWdgt::keyReleaseEvent(QKeyEvent*  arg__1)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyReleaseEvent");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "QKeyEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                elfInfoWdgt::keyReleaseEvent(arg__1);
              }
              void PythonQtShell_elfInfoWdgt::leaveEvent(QEvent*  arg__1)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "leaveEvent");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "QEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                elfInfoWdgt::leaveEvent(arg__1);
              }
              int  PythonQtShell_elfInfoWdgt::metric(QPaintDevice::PaintDeviceMetric  arg__1) const
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "metric");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"int" , "QPaintDevice::PaintDeviceMetric"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                    int returnValue;
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) {
                    args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
                    if (args[0]!=&returnValue) {
                      if (args[0]==NULL) {
                        PythonQt::priv()->handleVirtualOverloadReturnError("metric", methodInfo, result);
                      } else {
                        returnValue = *((int*)args[0]);
                      }
                    }
                  }
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return returnValue;
                }
              }
                return elfInfoWdgt::metric(arg__1);
              }
              QSize  PythonQtShell_elfInfoWdgt::minimumSizeHint() const
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getMinimumSizeHint");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"QSize"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
                    QSize returnValue;
                  void* args[1] = {NULL};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) {
                    args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
                    if (args[0]!=&returnValue) {
                      if (args[0]==NULL) {
                        PythonQt::priv()->handleVirtualOverloadReturnError("getMinimumSizeHint", methodInfo, result);
                      } else {
                        returnValue = *((QSize*)args[0]);
                      }
                    }
                  }
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return returnValue;
                }
              }
                return elfInfoWdgt::minimumSizeHint();
              }
              void PythonQtShell_elfInfoWdgt::mouseDoubleClickEvent(QMouseEvent*  arg__1)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseDoubleClickEvent");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "QMouseEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                elfInfoWdgt::mouseDoubleClickEvent(arg__1);
              }
              void PythonQtShell_elfInfoWdgt::mouseMoveEvent(QMouseEvent*  arg__1)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseMoveEvent");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "QMouseEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                elfInfoWdgt::mouseMoveEvent(arg__1);
              }
              void PythonQtShell_elfInfoWdgt::mousePressEvent(QMouseEvent*  arg__1)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mousePressEvent");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "QMouseEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                elfInfoWdgt::mousePressEvent(arg__1);
              }
              void PythonQtShell_elfInfoWdgt::mouseReleaseEvent(QMouseEvent*  arg__1)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseReleaseEvent");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "QMouseEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                elfInfoWdgt::mouseReleaseEvent(arg__1);
              }
              void PythonQtShell_elfInfoWdgt::moveEvent(QMoveEvent*  arg__1)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "moveEvent");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "QMoveEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                elfInfoWdgt::moveEvent(arg__1);
              }
              bool  PythonQtShell_elfInfoWdgt::nativeEvent(const QByteArray&  eventType, void*  message, long*  result)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "nativeEvent");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"bool" , "const QByteArray&" , "void*" , "long*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
                    bool returnValue;
                  void* args[4] = {NULL, (void*)&eventType, (void*)&message, (void*)&result};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) {
                    args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
                    if (args[0]!=&returnValue) {
                      if (args[0]==NULL) {
                        PythonQt::priv()->handleVirtualOverloadReturnError("nativeEvent", methodInfo, result);
                      } else {
                        returnValue = *((bool*)args[0]);
                      }
                    }
                  }
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return returnValue;
                }
              }
                return elfInfoWdgt::nativeEvent(eventType, message, result);
              }
              QPaintEngine*  PythonQtShell_elfInfoWdgt::paintEngine() const
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEngine");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"QPaintEngine*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
                    QPaintEngine* returnValue;
                  void* args[1] = {NULL};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) {
                    args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
                    if (args[0]!=&returnValue) {
                      if (args[0]==NULL) {
                        PythonQt::priv()->handleVirtualOverloadReturnError("paintEngine", methodInfo, result);
                      } else {
                        returnValue = *((QPaintEngine**)args[0]);
                      }
                    }
                  }
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return returnValue;
                }
              }
                return elfInfoWdgt::paintEngine();
              }
              void PythonQtShell_elfInfoWdgt::paintEvent(QPaintEvent*  arg__1)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEvent");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "QPaintEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                elfInfoWdgt::paintEvent(arg__1);
              }
              QPaintDevice*  PythonQtShell_elfInfoWdgt::redirected(QPoint*  offset) const
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "redirected");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"QPaintDevice*" , "QPoint*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                    QPaintDevice* returnValue;
                  void* args[2] = {NULL, (void*)&offset};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) {
                    args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
                    if (args[0]!=&returnValue) {
                      if (args[0]==NULL) {
                        PythonQt::priv()->handleVirtualOverloadReturnError("redirected", methodInfo, result);
                      } else {
                        returnValue = *((QPaintDevice**)args[0]);
                      }
                    }
                  }
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return returnValue;
                }
              }
                return elfInfoWdgt::redirected(offset);
              }
              void PythonQtShell_elfInfoWdgt::resizeEvent(QResizeEvent*  arg__1)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "resizeEvent");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "QResizeEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                elfInfoWdgt::resizeEvent(arg__1);
              }
              QPainter*  PythonQtShell_elfInfoWdgt::sharedPainter() const
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "sharedPainter");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"QPainter*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
                    QPainter* returnValue;
                  void* args[1] = {NULL};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) {
                    args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
                    if (args[0]!=&returnValue) {
                      if (args[0]==NULL) {
                        PythonQt::priv()->handleVirtualOverloadReturnError("sharedPainter", methodInfo, result);
                      } else {
                        returnValue = *((QPainter**)args[0]);
                      }
                    }
                  }
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return returnValue;
                }
              }
                return elfInfoWdgt::sharedPainter();
              }
              void PythonQtShell_elfInfoWdgt::showEvent(QShowEvent*  arg__1)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "showEvent");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "QShowEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                elfInfoWdgt::showEvent(arg__1);
              }
              QSize  PythonQtShell_elfInfoWdgt::sizeHint() const
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getSizeHint");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"QSize"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
                    QSize returnValue;
                  void* args[1] = {NULL};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) {
                    args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
                    if (args[0]!=&returnValue) {
                      if (args[0]==NULL) {
                        PythonQt::priv()->handleVirtualOverloadReturnError("getSizeHint", methodInfo, result);
                      } else {
                        returnValue = *((QSize*)args[0]);
                      }
                    }
                  }
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return returnValue;
                }
              }
                return elfInfoWdgt::sizeHint();
              }
              void PythonQtShell_elfInfoWdgt::tabletEvent(QTabletEvent*  arg__1)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "tabletEvent");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "QTabletEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                elfInfoWdgt::tabletEvent(arg__1);
              }
              void PythonQtShell_elfInfoWdgt::timerEvent(QTimerEvent*  arg__1)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "timerEvent");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "QTimerEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                elfInfoWdgt::timerEvent(arg__1);
              }
              void PythonQtShell_elfInfoWdgt::wheelEvent(QWheelEvent*  arg__1)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "wheelEvent");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "QWheelEvent*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&arg__1};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                elfInfoWdgt::wheelEvent(arg__1);
              }
              elfInfoWdgt* PythonQtWrapper_elfInfoWdgt::new_elfInfoWdgt(QWidget*  parent)
              {
              return new PythonQtShell_elfInfoWdgt(parent); }
              elfparser* PythonQtWrapper_elfparser::new_elfparser()
              {
              return new elfparser(); }
              int  PythonQtWrapper_elfparser::closeFile(elfparser* theWrappedObject)
              {
                return ( theWrappedObject->closeFile());
              }
              QString  PythonQtWrapper_elfparser::getABI(elfparser* theWrappedObject)
              {
                return ( theWrappedObject->getABI());
              }
              QString  PythonQtWrapper_elfparser::getArchitecture(elfparser* theWrappedObject)
              {
                return ( theWrappedObject->getArchitecture());
              }
              QString  PythonQtWrapper_elfparser::getClass(elfparser* theWrappedObject)
              {
                return ( theWrappedObject->getClass());
              }
              QString  PythonQtWrapper_elfparser::getEndianness(elfparser* theWrappedObject)
              {
                return ( theWrappedObject->getEndianness());
              }
              qint64  PythonQtWrapper_elfparser::getEntryPointAddress(elfparser* theWrappedObject)
              {
                return ( theWrappedObject->getEntryPointAddress());
              }
              bool  PythonQtWrapper_elfparser::getSectionData(elfparser* theWrappedObject, int  index, char**  buffer)
              {
                return ( theWrappedObject->getSectionData(index, buffer));
              }
              qint64  PythonQtWrapper_elfparser::getSectionDatasz(elfparser* theWrappedObject, int  index)
              {
                return ( theWrappedObject->getSectionDatasz(index));
              }
              qint64  PythonQtWrapper_elfparser::getSectionMemsz(elfparser* theWrappedObject, int  index)
              {
                return ( theWrappedObject->getSectionMemsz(index));
              }
              QString  PythonQtWrapper_elfparser::getSectionName(elfparser* theWrappedObject, int  index)
              {
                return ( theWrappedObject->getSectionName(index));
              }
              qint64  PythonQtWrapper_elfparser::getSectionPaddr(elfparser* theWrappedObject, int  index)
              {
                return ( theWrappedObject->getSectionPaddr(index));
              }
              QString  PythonQtWrapper_elfparser::getSectionType(elfparser* theWrappedObject, int  index)
              {
                return ( theWrappedObject->getSectionType(index));
              }
              int  PythonQtWrapper_elfparser::getSectioncount(elfparser* theWrappedObject)
              {
                return ( theWrappedObject->getSectioncount());
              }
              qint64  PythonQtWrapper_elfparser::getSegmentFilesz(elfparser* theWrappedObject, int  index)
              {
                return ( theWrappedObject->getSegmentFilesz(index));
              }
              QString  PythonQtWrapper_elfparser::getSegmentFlags(elfparser* theWrappedObject, int  index)
              {
                return ( theWrappedObject->getSegmentFlags(index));
              }
              qint64  PythonQtWrapper_elfparser::getSegmentMemsz(elfparser* theWrappedObject, int  index)
              {
                return ( theWrappedObject->getSegmentMemsz(index));
              }
              qint64  PythonQtWrapper_elfparser::getSegmentOffset(elfparser* theWrappedObject, int  index)
              {
                return ( theWrappedObject->getSegmentOffset(index));
              }
              qint64  PythonQtWrapper_elfparser::getSegmentPaddr(elfparser* theWrappedObject, int  index)
              {
                return ( theWrappedObject->getSegmentPaddr(index));
              }
              QString  PythonQtWrapper_elfparser::getSegmentType(elfparser* theWrappedObject, int  index)
              {
                return ( theWrappedObject->getSegmentType(index));
              }
              qint64  PythonQtWrapper_elfparser::getSegmentVaddr(elfparser* theWrappedObject, int  index)
              {
                return ( theWrappedObject->getSegmentVaddr(index));
              }
              int  PythonQtWrapper_elfparser::getSegmentcount(elfparser* theWrappedObject)
              {
                return ( theWrappedObject->getSegmentcount());
              }
              QString  PythonQtWrapper_elfparser::getType(elfparser* theWrappedObject)
              {
                return ( theWrappedObject->getType());
              }
              qint64  PythonQtWrapper_elfparser::getVersion(elfparser* theWrappedObject)
              {
                return ( theWrappedObject->getVersion());
              }
              bool  PythonQtWrapper_elfparser::static_elfparser_isElf(const QString&  File)
              {
                return (elfparser::isElf(File));
              }
              bool  PythonQtWrapper_elfparser::iself(elfparser* theWrappedObject)
              {
                return ( theWrappedObject->iself());
              }
              bool  PythonQtWrapper_elfparser::isopened(elfparser* theWrappedObject)
              {
                return ( theWrappedObject->isopened());
              }
              int  PythonQtWrapper_elfparser::setFilename(elfparser* theWrappedObject, const QString&  name)
              {
                return ( theWrappedObject->setFilename(name));
              }
+             PythonQtShell_genericBinaryFileWidget::~PythonQtShell_genericBinaryFileWidget() {
+               PythonQtPrivate* priv = PythonQt::priv();
+               if (priv) { priv->shellClassDeleted(this); }
+             }
+             void PythonQtShell_genericBinaryFileWidget::actionEvent(QActionEvent*  arg__1)
+             {
+             if (_wrapper) {
+               PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "actionEvent");
+               PyErr_Clear();
+               if (obj && !PythonQtSlotFunction_Check(obj)) {
+                 static const char* argumentList[] ={"" , "QActionEvent*"};
+                 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
+                 void* args[2] = {NULL, (void*)&arg__1};
+                 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
+                 if (result) { Py_DECREF(result); }
+                 Py_DECREF(obj);
+                 return;
+               }
+             }
+               genericBinaryFileWidget::actionEvent(arg__1);
+             }
+             void PythonQtShell_genericBinaryFileWidget::changeEvent(QEvent*  arg__1)
+             {
+             if (_wrapper) {
+               PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "changeEvent");
+               PyErr_Clear();
+               if (obj && !PythonQtSlotFunction_Check(obj)) {
+                 static const char* argumentList[] ={"" , "QEvent*"};
+                 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
+                 void* args[2] = {NULL, (void*)&arg__1};
+                 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
+                 if (result) { Py_DECREF(result); }
+                 Py_DECREF(obj);
+                 return;
+               }
+             }
+               genericBinaryFileWidget::changeEvent(arg__1);
+             }
+             void PythonQtShell_genericBinaryFileWidget::childEvent(QChildEvent*  arg__1)
+             {
+             if (_wrapper) {
+               PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "childEvent");
+               PyErr_Clear();
+               if (obj && !PythonQtSlotFunction_Check(obj)) {
+                 static const char* argumentList[] ={"" , "QChildEvent*"};
+                 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
+                 void* args[2] = {NULL, (void*)&arg__1};
+                 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
+                 if (result) { Py_DECREF(result); }
+                 Py_DECREF(obj);
+                 return;
+               }
+             }
+               genericBinaryFileWidget::childEvent(arg__1);
+             }
+             void PythonQtShell_genericBinaryFileWidget::closeEvent(QCloseEvent*  arg__1)
+             {
+             if (_wrapper) {
+               PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "closeEvent");
+               PyErr_Clear();
+               if (obj && !PythonQtSlotFunction_Check(obj)) {
+                 static const char* argumentList[] ={"" , "QCloseEvent*"};
+                 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
+                 void* args[2] = {NULL, (void*)&arg__1};
+                 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
+                 if (result) { Py_DECREF(result); }
+                 Py_DECREF(obj);
+                 return;
+               }
+             }
+               genericBinaryFileWidget::closeEvent(arg__1);
+             }
+             void PythonQtShell_genericBinaryFileWidget::contextMenuEvent(QContextMenuEvent*  arg__1)
+             {
+             if (_wrapper) {
+               PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "contextMenuEvent");
+               PyErr_Clear();
+               if (obj && !PythonQtSlotFunction_Check(obj)) {
+                 static const char* argumentList[] ={"" , "QContextMenuEvent*"};
+                 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
+                 void* args[2] = {NULL, (void*)&arg__1};
+                 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
+                 if (result) { Py_DECREF(result); }
+                 Py_DECREF(obj);
+                 return;
+               }
+             }
+               genericBinaryFileWidget::contextMenuEvent(arg__1);
+             }
+             void PythonQtShell_genericBinaryFileWidget::customEvent(QEvent*  arg__1)
+             {
+             if (_wrapper) {
+               PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "customEvent");
+               PyErr_Clear();
+               if (obj && !PythonQtSlotFunction_Check(obj)) {
+                 static const char* argumentList[] ={"" , "QEvent*"};
+                 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
+                 void* args[2] = {NULL, (void*)&arg__1};
+                 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
+                 if (result) { Py_DECREF(result); }
+                 Py_DECREF(obj);
+                 return;
+               }
+             }
+               genericBinaryFileWidget::customEvent(arg__1);
+             }
+             int  PythonQtShell_genericBinaryFileWidget::devType() const
+             {
+             if (_wrapper) {
+               PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "devType");
+               PyErr_Clear();
+               if (obj && !PythonQtSlotFunction_Check(obj)) {
+                 static const char* argumentList[] ={"int"};
+                 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
+                   int returnValue;
+                 void* args[1] = {NULL};
+                 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
+                 if (result) {
+                   args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
+                   if (args[0]!=&returnValue) {
+                     if (args[0]==NULL) {
+                       PythonQt::priv()->handleVirtualOverloadReturnError("devType", methodInfo, result);
+                     } else {
+                       returnValue = *((int*)args[0]);
+                     }
+                   }
+                 }
+                 if (result) { Py_DECREF(result); }
+                 Py_DECREF(obj);
+                 return returnValue;
+               }
+             }
+               return genericBinaryFileWidget::devType();
+             }
+             void PythonQtShell_genericBinaryFileWidget::dragEnterEvent(QDragEnterEvent*  arg__1)
+             {
+             if (_wrapper) {
+               PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragEnterEvent");
+               PyErr_Clear();
+               if (obj && !PythonQtSlotFunction_Check(obj)) {
+                 static const char* argumentList[] ={"" , "QDragEnterEvent*"};
+                 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
+                 void* args[2] = {NULL, (void*)&arg__1};
+                 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
+                 if (result) { Py_DECREF(result); }
+                 Py_DECREF(obj);
+                 return;
+               }
+             }
+               genericBinaryFileWidget::dragEnterEvent(arg__1);
+             }
+             void PythonQtShell_genericBinaryFileWidget::dragLeaveEvent(QDragLeaveEvent*  arg__1)
+             {
+             if (_wrapper) {
+               PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragLeaveEvent");
+               PyErr_Clear();
+               if (obj && !PythonQtSlotFunction_Check(obj)) {
+                 static const char* argumentList[] ={"" , "QDragLeaveEvent*"};
+                 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
+                 void* args[2] = {NULL, (void*)&arg__1};
+                 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
+                 if (result) { Py_DECREF(result); }
+                 Py_DECREF(obj);
+                 return;
+               }
+             }
+               genericBinaryFileWidget::dragLeaveEvent(arg__1);
+             }
+             void PythonQtShell_genericBinaryFileWidget::dragMoveEvent(QDragMoveEvent*  arg__1)
+             {
+             if (_wrapper) {
+               PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragMoveEvent");
+               PyErr_Clear();
+               if (obj && !PythonQtSlotFunction_Check(obj)) {
+                 static const char* argumentList[] ={"" , "QDragMoveEvent*"};
+                 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
+                 void* args[2] = {NULL, (void*)&arg__1};
+                 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
+                 if (result) { Py_DECREF(result); }
+                 Py_DECREF(obj);
+                 return;
+               }
+             }
+               genericBinaryFileWidget::dragMoveEvent(arg__1);
+             }
+             void PythonQtShell_genericBinaryFileWidget::dropEvent(QDropEvent*  arg__1)
+             {
+             if (_wrapper) {
+               PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dropEvent");
+               PyErr_Clear();
+               if (obj && !PythonQtSlotFunction_Check(obj)) {
+                 static const char* argumentList[] ={"" , "QDropEvent*"};
+                 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
+                 void* args[2] = {NULL, (void*)&arg__1};
+                 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
+                 if (result) { Py_DECREF(result); }
+                 Py_DECREF(obj);
+                 return;
+               }
+             }
+               genericBinaryFileWidget::dropEvent(arg__1);
+             }
+             void PythonQtShell_genericBinaryFileWidget::enterEvent(QEvent*  arg__1)
+             {
+             if (_wrapper) {
+               PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "enterEvent");
+               PyErr_Clear();
+               if (obj && !PythonQtSlotFunction_Check(obj)) {
+                 static const char* argumentList[] ={"" , "QEvent*"};
+                 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
+                 void* args[2] = {NULL, (void*)&arg__1};
+                 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
+                 if (result) { Py_DECREF(result); }
+                 Py_DECREF(obj);
+                 return;
+               }
+             }
+               genericBinaryFileWidget::enterEvent(arg__1);
+             }
+             bool  PythonQtShell_genericBinaryFileWidget::event(QEvent*  arg__1)
+             {
+             if (_wrapper) {
+               PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "event");
+               PyErr_Clear();
+               if (obj && !PythonQtSlotFunction_Check(obj)) {
+                 static const char* argumentList[] ={"bool" , "QEvent*"};
+                 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
+                   bool returnValue;
+                 void* args[2] = {NULL, (void*)&arg__1};
+                 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
+                 if (result) {
+                   args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
+                   if (args[0]!=&returnValue) {
+                     if (args[0]==NULL) {
+                       PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
+                     } else {
+                       returnValue = *((bool*)args[0]);
+                     }
+                   }
+                 }
+                 if (result) { Py_DECREF(result); }
+                 Py_DECREF(obj);
+                 return returnValue;
+               }
+             }
+               return genericBinaryFileWidget::event(arg__1);
+             }
+             bool  PythonQtShell_genericBinaryFileWidget::eventFilter(QObject*  arg__1, QEvent*  arg__2)
+             {
+             if (_wrapper) {
+               PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "eventFilter");
+               PyErr_Clear();
+               if (obj && !PythonQtSlotFunction_Check(obj)) {
+                 static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
+                 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
+                   bool returnValue;
+                 void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2};
+                 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
+                 if (result) {
+                   args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
+                   if (args[0]!=&returnValue) {
+                     if (args[0]==NULL) {
+                       PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
+                     } else {
+                       returnValue = *((bool*)args[0]);
+                     }
+                   }
+                 }
+                 if (result) { Py_DECREF(result); }
+                 Py_DECREF(obj);
+                 return returnValue;
+               }
+             }
+               return genericBinaryFileWidget::eventFilter(arg__1, arg__2);
+             }
+             void PythonQtShell_genericBinaryFileWidget::focusInEvent(QFocusEvent*  arg__1)
+             {
+             if (_wrapper) {
+               PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusInEvent");
+               PyErr_Clear();
+               if (obj && !PythonQtSlotFunction_Check(obj)) {
+                 static const char* argumentList[] ={"" , "QFocusEvent*"};
+                 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
+                 void* args[2] = {NULL, (void*)&arg__1};
+                 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
+                 if (result) { Py_DECREF(result); }
+                 Py_DECREF(obj);
+                 return;
+               }
+             }
+               genericBinaryFileWidget::focusInEvent(arg__1);
+             }
+             bool  PythonQtShell_genericBinaryFileWidget::focusNextPrevChild(bool  next)
+             {
+             if (_wrapper) {
+               PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusNextPrevChild");
+               PyErr_Clear();
+               if (obj && !PythonQtSlotFunction_Check(obj)) {
+                 static const char* argumentList[] ={"bool" , "bool"};
+                 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
+                   bool returnValue;
+                 void* args[2] = {NULL, (void*)&next};
+                 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
+                 if (result) {
+                   args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
+                   if (args[0]!=&returnValue) {
+                     if (args[0]==NULL) {
+                       PythonQt::priv()->handleVirtualOverloadReturnError("focusNextPrevChild", methodInfo, result);
+                     } else {
+                       returnValue = *((bool*)args[0]);
+                     }
+                   }
+                 }
+                 if (result) { Py_DECREF(result); }
+                 Py_DECREF(obj);
+                 return returnValue;
+               }
+             }
+               return genericBinaryFileWidget::focusNextPrevChild(next);
+             }
+             void PythonQtShell_genericBinaryFileWidget::focusOutEvent(QFocusEvent*  arg__1)
+             {
+             if (_wrapper) {
+               PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusOutEvent");
+               PyErr_Clear();
+               if (obj && !PythonQtSlotFunction_Check(obj)) {
+                 static const char* argumentList[] ={"" , "QFocusEvent*"};
+                 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
+                 void* args[2] = {NULL, (void*)&arg__1};
+                 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
+                 if (result) { Py_DECREF(result); }
+                 Py_DECREF(obj);
+                 return;
+               }
+             }
+               genericBinaryFileWidget::focusOutEvent(arg__1);
+             }
+             bool  PythonQtShell_genericBinaryFileWidget::hasHeightForWidth() const
+             {
+             if (_wrapper) {
+               PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hasHeightForWidth");
+               PyErr_Clear();
+               if (obj && !PythonQtSlotFunction_Check(obj)) {
+                 static const char* argumentList[] ={"bool"};
+                 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
+                   bool returnValue;
+                 void* args[1] = {NULL};
+                 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
+                 if (result) {
+                   args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
+                   if (args[0]!=&returnValue) {
+                     if (args[0]==NULL) {
+                       PythonQt::priv()->handleVirtualOverloadReturnError("hasHeightForWidth", methodInfo, result);
+                     } else {
+                       returnValue = *((bool*)args[0]);
+                     }
+                   }
+                 }
+                 if (result) { Py_DECREF(result); }
+                 Py_DECREF(obj);
+                 return returnValue;
+               }
+             }
+               return genericBinaryFileWidget::hasHeightForWidth();
+             }
+             int  PythonQtShell_genericBinaryFileWidget::heightForWidth(int  arg__1) const
+             {
+             if (_wrapper) {
+               PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "heightForWidth");
+               PyErr_Clear();
+               if (obj && !PythonQtSlotFunction_Check(obj)) {
+                 static const char* argumentList[] ={"int" , "int"};
+                 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
+                   int returnValue;
+                 void* args[2] = {NULL, (void*)&arg__1};
+                 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
+                 if (result) {
+                   args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
+                   if (args[0]!=&returnValue) {
+                     if (args[0]==NULL) {
+                       PythonQt::priv()->handleVirtualOverloadReturnError("heightForWidth", methodInfo, result);
+                     } else {
+                       returnValue = *((int*)args[0]);
+                     }
+                   }
+                 }
+                 if (result) { Py_DECREF(result); }
+                 Py_DECREF(obj);
+                 return returnValue;
+               }
+             }
+               return genericBinaryFileWidget::heightForWidth(arg__1);
+             }
+             void PythonQtShell_genericBinaryFileWidget::hideEvent(QHideEvent*  arg__1)
+             {
+             if (_wrapper) {
+               PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hideEvent");
+               PyErr_Clear();
+               if (obj && !PythonQtSlotFunction_Check(obj)) {
+                 static const char* argumentList[] ={"" , "QHideEvent*"};
+                 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
+                 void* args[2] = {NULL, (void*)&arg__1};
+                 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
+                 if (result) { Py_DECREF(result); }
+                 Py_DECREF(obj);
+                 return;
+               }
+             }
+               genericBinaryFileWidget::hideEvent(arg__1);
+             }
+             void PythonQtShell_genericBinaryFileWidget::initPainter(QPainter*  painter) const
+             {
+             if (_wrapper) {
+               PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "initPainter");
+               PyErr_Clear();
+               if (obj && !PythonQtSlotFunction_Check(obj)) {
+                 static const char* argumentList[] ={"" , "QPainter*"};
+                 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
+                 void* args[2] = {NULL, (void*)&painter};
+                 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
+                 if (result) { Py_DECREF(result); }
+                 Py_DECREF(obj);
+                 return;
+               }
+             }
+               genericBinaryFileWidget::initPainter(painter);
+             }
+             void PythonQtShell_genericBinaryFileWidget::inputMethodEvent(QInputMethodEvent*  arg__1)
+             {
+             if (_wrapper) {
+               PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodEvent");
+               PyErr_Clear();
+               if (obj && !PythonQtSlotFunction_Check(obj)) {
+                 static const char* argumentList[] ={"" , "QInputMethodEvent*"};
+                 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
+                 void* args[2] = {NULL, (void*)&arg__1};
+                 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
+                 if (result) { Py_DECREF(result); }
+                 Py_DECREF(obj);
+                 return;
+               }
+             }
+               genericBinaryFileWidget::inputMethodEvent(arg__1);
+             }
+             QVariant  PythonQtShell_genericBinaryFileWidget::inputMethodQuery(Qt::InputMethodQuery  arg__1) const
+             {
+             if (_wrapper) {
+               PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodQuery");
+               PyErr_Clear();
+               if (obj && !PythonQtSlotFunction_Check(obj)) {
+                 static const char* argumentList[] ={"QVariant" , "Qt::InputMethodQuery"};
+                 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
+                   QVariant returnValue;
+                 void* args[2] = {NULL, (void*)&arg__1};
+                 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
+                 if (result) {
+                   args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
+                   if (args[0]!=&returnValue) {
+                     if (args[0]==NULL) {
+                       PythonQt::priv()->handleVirtualOverloadReturnError("inputMethodQuery", methodInfo, result);
+                     } else {
+                       returnValue = *((QVariant*)args[0]);
+                     }
+                   }
+                 }
+                 if (result) { Py_DECREF(result); }
+                 Py_DECREF(obj);
+                 return returnValue;
+               }
+             }
+               return genericBinaryFileWidget::inputMethodQuery(arg__1);
+             }
+             void PythonQtShell_genericBinaryFileWidget::keyPressEvent(QKeyEvent*  arg__1)
+             {
+             if (_wrapper) {
+               PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyPressEvent");
+               PyErr_Clear();
+               if (obj && !PythonQtSlotFunction_Check(obj)) {
+                 static const char* argumentList[] ={"" , "QKeyEvent*"};
+                 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
+                 void* args[2] = {NULL, (void*)&arg__1};
+                 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
+                 if (result) { Py_DECREF(result); }
+                 Py_DECREF(obj);
+                 return;
+               }
+             }
+               genericBinaryFileWidget::keyPressEvent(arg__1);
+             }
+             void PythonQtShell_genericBinaryFileWidget::keyReleaseEvent(QKeyEvent*  arg__1)
+             {
+             if (_wrapper) {
+               PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyReleaseEvent");
+               PyErr_Clear();
+               if (obj && !PythonQtSlotFunction_Check(obj)) {
+                 static const char* argumentList[] ={"" , "QKeyEvent*"};
+                 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
+                 void* args[2] = {NULL, (void*)&arg__1};
+                 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
+                 if (result) { Py_DECREF(result); }
+                 Py_DECREF(obj);
+                 return;
+               }
+             }
+               genericBinaryFileWidget::keyReleaseEvent(arg__1);
+             }
+             void PythonQtShell_genericBinaryFileWidget::leaveEvent(QEvent*  arg__1)
+             {
+             if (_wrapper) {
+               PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "leaveEvent");
+               PyErr_Clear();
+               if (obj && !PythonQtSlotFunction_Check(obj)) {
+                 static const char* argumentList[] ={"" , "QEvent*"};
+                 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
+                 void* args[2] = {NULL, (void*)&arg__1};
+                 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
+                 if (result) { Py_DECREF(result); }
+                 Py_DECREF(obj);
+                 return;
+               }
+             }
+               genericBinaryFileWidget::leaveEvent(arg__1);
+             }
+             int  PythonQtShell_genericBinaryFileWidget::metric(QPaintDevice::PaintDeviceMetric  arg__1) const
+             {
+             if (_wrapper) {
+               PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "metric");
+               PyErr_Clear();
+               if (obj && !PythonQtSlotFunction_Check(obj)) {
+                 static const char* argumentList[] ={"int" , "QPaintDevice::PaintDeviceMetric"};
+                 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
+                   int returnValue;
+                 void* args[2] = {NULL, (void*)&arg__1};
+                 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
+                 if (result) {
+                   args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
+                   if (args[0]!=&returnValue) {
+                     if (args[0]==NULL) {
+                       PythonQt::priv()->handleVirtualOverloadReturnError("metric", methodInfo, result);
+                     } else {
+                       returnValue = *((int*)args[0]);
+                     }
+                   }
+                 }
+                 if (result) { Py_DECREF(result); }
+                 Py_DECREF(obj);
+                 return returnValue;
+               }
+             }
+               return genericBinaryFileWidget::metric(arg__1);
+             }
+             QSize  PythonQtShell_genericBinaryFileWidget::minimumSizeHint() const
+             {
+             if (_wrapper) {
+               PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getMinimumSizeHint");
+               PyErr_Clear();
+               if (obj && !PythonQtSlotFunction_Check(obj)) {
+                 static const char* argumentList[] ={"QSize"};
+                 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
+                   QSize returnValue;
+                 void* args[1] = {NULL};
+                 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
+                 if (result) {
+                   args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
+                   if (args[0]!=&returnValue) {
+                     if (args[0]==NULL) {
+                       PythonQt::priv()->handleVirtualOverloadReturnError("getMinimumSizeHint", methodInfo, result);
+                     } else {
+                       returnValue = *((QSize*)args[0]);
+                     }
+                   }
+                 }
+                 if (result) { Py_DECREF(result); }
+                 Py_DECREF(obj);
+                 return returnValue;
+               }
+             }
+               return genericBinaryFileWidget::minimumSizeHint();
+             }
+             void PythonQtShell_genericBinaryFileWidget::mouseDoubleClickEvent(QMouseEvent*  arg__1)
+             {
+             if (_wrapper) {
+               PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseDoubleClickEvent");
+               PyErr_Clear();
+               if (obj && !PythonQtSlotFunction_Check(obj)) {
+                 static const char* argumentList[] ={"" , "QMouseEvent*"};
+                 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
+                 void* args[2] = {NULL, (void*)&arg__1};
+                 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
+                 if (result) { Py_DECREF(result); }
+                 Py_DECREF(obj);
+                 return;
+               }
+             }
+               genericBinaryFileWidget::mouseDoubleClickEvent(arg__1);
+             }
+             void PythonQtShell_genericBinaryFileWidget::mouseMoveEvent(QMouseEvent*  arg__1)
+             {
+             if (_wrapper) {
+               PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseMoveEvent");
+               PyErr_Clear();
+               if (obj && !PythonQtSlotFunction_Check(obj)) {
+                 static const char* argumentList[] ={"" , "QMouseEvent*"};
+                 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
+                 void* args[2] = {NULL, (void*)&arg__1};
+                 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
+                 if (result) { Py_DECREF(result); }
+                 Py_DECREF(obj);
+                 return;
+               }
+             }
+               genericBinaryFileWidget::mouseMoveEvent(arg__1);
+             }
+             void PythonQtShell_genericBinaryFileWidget::mousePressEvent(QMouseEvent*  arg__1)
+             {
+             if (_wrapper) {
+               PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mousePressEvent");
+               PyErr_Clear();
+               if (obj && !PythonQtSlotFunction_Check(obj)) {
+                 static const char* argumentList[] ={"" , "QMouseEvent*"};
+                 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
+                 void* args[2] = {NULL, (void*)&arg__1};
+                 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
+                 if (result) { Py_DECREF(result); }
+                 Py_DECREF(obj);
+                 return;
+               }
+             }
+               genericBinaryFileWidget::mousePressEvent(arg__1);
+             }
+             void PythonQtShell_genericBinaryFileWidget::mouseReleaseEvent(QMouseEvent*  arg__1)
+             {
+             if (_wrapper) {
+               PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseReleaseEvent");
+               PyErr_Clear();
+               if (obj && !PythonQtSlotFunction_Check(obj)) {
+                 static const char* argumentList[] ={"" , "QMouseEvent*"};
+                 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
+                 void* args[2] = {NULL, (void*)&arg__1};
+                 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
+                 if (result) { Py_DECREF(result); }
+                 Py_DECREF(obj);
+                 return;
+               }
+             }
+               genericBinaryFileWidget::mouseReleaseEvent(arg__1);
+             }
+             void PythonQtShell_genericBinaryFileWidget::moveEvent(QMoveEvent*  arg__1)
+             {
+             if (_wrapper) {
+               PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "moveEvent");
+               PyErr_Clear();
+               if (obj && !PythonQtSlotFunction_Check(obj)) {
+                 static const char* argumentList[] ={"" , "QMoveEvent*"};
+                 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
+                 void* args[2] = {NULL, (void*)&arg__1};
+                 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
+                 if (result) { Py_DECREF(result); }
+                 Py_DECREF(obj);
+                 return;
+               }
+             }
+               genericBinaryFileWidget::moveEvent(arg__1);
+             }
+             bool  PythonQtShell_genericBinaryFileWidget::nativeEvent(const QByteArray&  eventType, void*  message, long*  result)
+             {
+             if (_wrapper) {
+               PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "nativeEvent");
+               PyErr_Clear();
+               if (obj && !PythonQtSlotFunction_Check(obj)) {
+                 static const char* argumentList[] ={"bool" , "const QByteArray&" , "void*" , "long*"};
+                 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
+                   bool returnValue;
+                 void* args[4] = {NULL, (void*)&eventType, (void*)&message, (void*)&result};
+                 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
+                 if (result) {
+                   args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
+                   if (args[0]!=&returnValue) {
+                     if (args[0]==NULL) {
+                       PythonQt::priv()->handleVirtualOverloadReturnError("nativeEvent", methodInfo, result);
+                     } else {
+                       returnValue = *((bool*)args[0]);
+                     }
+                   }
+                 }
+                 if (result) { Py_DECREF(result); }
+                 Py_DECREF(obj);
+                 return returnValue;
+               }
+             }
+               return genericBinaryFileWidget::nativeEvent(eventType, message, result);
+             }
+             QPaintEngine*  PythonQtShell_genericBinaryFileWidget::paintEngine() const
+             {
+             if (_wrapper) {
+               PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEngine");
+               PyErr_Clear();
+               if (obj && !PythonQtSlotFunction_Check(obj)) {
+                 static const char* argumentList[] ={"QPaintEngine*"};
+                 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
+                   QPaintEngine* returnValue;
+                 void* args[1] = {NULL};
+                 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
+                 if (result) {
+                   args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
+                   if (args[0]!=&returnValue) {
+                     if (args[0]==NULL) {
+                       PythonQt::priv()->handleVirtualOverloadReturnError("paintEngine", methodInfo, result);
+                     } else {
+                       returnValue = *((QPaintEngine**)args[0]);
+                     }
+                   }
+                 }
+                 if (result) { Py_DECREF(result); }
+                 Py_DECREF(obj);
+                 return returnValue;
+               }
+             }
+               return genericBinaryFileWidget::paintEngine();
+             }
+             void PythonQtShell_genericBinaryFileWidget::paintEvent(QPaintEvent*  arg__1)
+             {
+             if (_wrapper) {
+               PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEvent");
+               PyErr_Clear();
+               if (obj && !PythonQtSlotFunction_Check(obj)) {
+                 static const char* argumentList[] ={"" , "QPaintEvent*"};
+                 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
+                 void* args[2] = {NULL, (void*)&arg__1};
+                 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
+                 if (result) { Py_DECREF(result); }
+                 Py_DECREF(obj);
+                 return;
+               }
+             }
+               genericBinaryFileWidget::paintEvent(arg__1);
+             }
+             QPaintDevice*  PythonQtShell_genericBinaryFileWidget::redirected(QPoint*  offset) const
+             {
+             if (_wrapper) {
+               PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "redirected");
+               PyErr_Clear();
+               if (obj && !PythonQtSlotFunction_Check(obj)) {
+                 static const char* argumentList[] ={"QPaintDevice*" , "QPoint*"};
+                 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
+                   QPaintDevice* returnValue;
+                 void* args[2] = {NULL, (void*)&offset};
+                 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
+                 if (result) {
+                   args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
+                   if (args[0]!=&returnValue) {
+                     if (args[0]==NULL) {
+                       PythonQt::priv()->handleVirtualOverloadReturnError("redirected", methodInfo, result);
+                     } else {
+                       returnValue = *((QPaintDevice**)args[0]);
+                     }
+                   }
+                 }
+                 if (result) { Py_DECREF(result); }
+                 Py_DECREF(obj);
+                 return returnValue;
+               }
+             }
+               return genericBinaryFileWidget::redirected(offset);
+             }
+             void PythonQtShell_genericBinaryFileWidget::resizeEvent(QResizeEvent*  arg__1)
+             {
+             if (_wrapper) {
+               PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "resizeEvent");
+               PyErr_Clear();
+               if (obj && !PythonQtSlotFunction_Check(obj)) {
+                 static const char* argumentList[] ={"" , "QResizeEvent*"};
+                 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
+                 void* args[2] = {NULL, (void*)&arg__1};
+                 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
+                 if (result) { Py_DECREF(result); }
+                 Py_DECREF(obj);
+                 return;
+               }
+             }
+               genericBinaryFileWidget::resizeEvent(arg__1);
+             }
+             QPainter*  PythonQtShell_genericBinaryFileWidget::sharedPainter() const
+             {
+             if (_wrapper) {
+               PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "sharedPainter");
+               PyErr_Clear();
+               if (obj && !PythonQtSlotFunction_Check(obj)) {
+                 static const char* argumentList[] ={"QPainter*"};
+                 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
+                   QPainter* returnValue;
+                 void* args[1] = {NULL};
+                 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
+                 if (result) {
+                   args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
+                   if (args[0]!=&returnValue) {
+                     if (args[0]==NULL) {
+                       PythonQt::priv()->handleVirtualOverloadReturnError("sharedPainter", methodInfo, result);
+                     } else {
+                       returnValue = *((QPainter**)args[0]);
+                     }
+                   }
+                 }
+                 if (result) { Py_DECREF(result); }
+                 Py_DECREF(obj);
+                 return returnValue;
+               }
+             }
+               return genericBinaryFileWidget::sharedPainter();
+             }
+             void PythonQtShell_genericBinaryFileWidget::showEvent(QShowEvent*  arg__1)
+             {
+             if (_wrapper) {
+               PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "showEvent");
+               PyErr_Clear();
+               if (obj && !PythonQtSlotFunction_Check(obj)) {
+                 static const char* argumentList[] ={"" , "QShowEvent*"};
+                 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
+                 void* args[2] = {NULL, (void*)&arg__1};
+                 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
+                 if (result) { Py_DECREF(result); }
+                 Py_DECREF(obj);
+                 return;
+               }
+             }
+               genericBinaryFileWidget::showEvent(arg__1);
+             }
+             QSize  PythonQtShell_genericBinaryFileWidget::sizeHint() const
+             {
+             if (_wrapper) {
+               PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getSizeHint");
+               PyErr_Clear();
+               if (obj && !PythonQtSlotFunction_Check(obj)) {
+                 static const char* argumentList[] ={"QSize"};
+                 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
+                   QSize returnValue;
+                 void* args[1] = {NULL};
+                 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
+                 if (result) {
+                   args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
+                   if (args[0]!=&returnValue) {
+                     if (args[0]==NULL) {
+                       PythonQt::priv()->handleVirtualOverloadReturnError("getSizeHint", methodInfo, result);
+                     } else {
+                       returnValue = *((QSize*)args[0]);
+                     }
+                   }
+                 }
+                 if (result) { Py_DECREF(result); }
+                 Py_DECREF(obj);
+                 return returnValue;
+               }
+             }
+               return genericBinaryFileWidget::sizeHint();
+             }
+             void PythonQtShell_genericBinaryFileWidget::tabletEvent(QTabletEvent*  arg__1)
+             {
+             if (_wrapper) {
+               PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "tabletEvent");
+               PyErr_Clear();
+               if (obj && !PythonQtSlotFunction_Check(obj)) {
+                 static const char* argumentList[] ={"" , "QTabletEvent*"};
+                 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
+                 void* args[2] = {NULL, (void*)&arg__1};
+                 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
+                 if (result) { Py_DECREF(result); }
+                 Py_DECREF(obj);
+                 return;
+               }
+             }
+               genericBinaryFileWidget::tabletEvent(arg__1);
+             }
+             void PythonQtShell_genericBinaryFileWidget::timerEvent(QTimerEvent*  arg__1)
+             {
+             if (_wrapper) {
+               PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "timerEvent");
+               PyErr_Clear();
+               if (obj && !PythonQtSlotFunction_Check(obj)) {
+                 static const char* argumentList[] ={"" , "QTimerEvent*"};
+                 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
+                 void* args[2] = {NULL, (void*)&arg__1};
+                 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
+                 if (result) { Py_DECREF(result); }
+                 Py_DECREF(obj);
+                 return;
+               }
+             }
+               genericBinaryFileWidget::timerEvent(arg__1);
+             }
+             void PythonQtShell_genericBinaryFileWidget::wheelEvent(QWheelEvent*  arg__1)
+             {
+             if (_wrapper) {
+               PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "wheelEvent");
+               PyErr_Clear();
+               if (obj && !PythonQtSlotFunction_Check(obj)) {
+                 static const char* argumentList[] ={"" , "QWheelEvent*"};
+                 static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
+                 void* args[2] = {NULL, (void*)&arg__1};
+                 PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
+                 if (result) { Py_DECREF(result); }
+                 Py_DECREF(obj);
+                 return;
+               }
+             }
+               genericBinaryFileWidget::wheelEvent(arg__1);
+             }
+             genericBinaryFileWidget* PythonQtWrapper_genericBinaryFileWidget::new_genericBinaryFileWidget(QWidget*  parent)
+             {
+             return new PythonQtShell_genericBinaryFileWidget(parent); }
              PythonQtShell_srecFile::~PythonQtShell_srecFile() {
                PythonQtPrivate* priv = PythonQt::priv();
                if (priv) { priv->shellClassDeleted(this); }
              }
              int  PythonQtShell_srecFile::closeFile()
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "closeFile");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"int"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
                    int returnValue;
                  void* args[1] = {NULL};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) {
                    args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
                    if (args[0]!=&returnValue) {
                      if (args[0]==NULL) {
                        PythonQt::priv()->handleVirtualOverloadReturnError("closeFile", methodInfo, result);
                      } else {
                        returnValue = *((int*)args[0]);
                      }
                    }
                  }
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return returnValue;
                }
              }
                return srecFile::closeFile();
              }
              QList<codeFragment* >  PythonQtShell_srecFile::getFragments()
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getFragments");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"QList<codeFragment* >"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
                    QList<codeFragment* > returnValue;
                  void* args[1] = {NULL};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) {
                    args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
                    if (args[0]!=&returnValue) {
                      if (args[0]==NULL) {
                        PythonQt::priv()->handleVirtualOverloadReturnError("getFragments", methodInfo, result);
                      } else {
                        returnValue = *((QList<codeFragment* >*)args[0]);
                      }
                    }
                  }
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return returnValue;
                }
              }
                return srecFile::getFragments();
              }
              bool  PythonQtShell_srecFile::isopened()
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "isopened");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"bool"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
                    bool returnValue;
                  void* args[1] = {NULL};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) {
                    args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
                    if (args[0]!=&returnValue) {
                      if (args[0]==NULL) {
                        PythonQt::priv()->handleVirtualOverloadReturnError("isopened", methodInfo, result);
                      } else {
                        returnValue = *((bool*)args[0]);
                      }
                    }
                  }
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return returnValue;
                }
              }
                return srecFile::isopened();
              }
              bool  PythonQtShell_srecFile::openFile(const QString&  File)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "openFile");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"bool" , "const QString&"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                    bool returnValue;
                  void* args[2] = {NULL, (void*)&File};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) {
                    args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
                    if (args[0]!=&returnValue) {
                      if (args[0]==NULL) {
                        PythonQt::priv()->handleVirtualOverloadReturnError("openFile", methodInfo, result);
                      } else {
                        returnValue = *((bool*)args[0]);
                      }
                    }
                  }
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return returnValue;
                }
              }
                return srecFile::openFile(File);
              }
              bool  PythonQtShell_srecFile::toBinary(const QString&  File)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "toBinary");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"bool" , "const QString&"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                    bool returnValue;
                  void* args[2] = {NULL, (void*)&File};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) {
                    args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
                    if (args[0]!=&returnValue) {
                      if (args[0]==NULL) {
                        PythonQt::priv()->handleVirtualOverloadReturnError("toBinary", methodInfo, result);
                      } else {
                        returnValue = *((bool*)args[0]);
                      }
                    }
                  }
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return returnValue;
                }
              }
                return srecFile::toBinary(File);
              }
              bool  PythonQtShell_srecFile::toSrec(const QString&  File)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "toSrec");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"bool" , "const QString&"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                    bool returnValue;
                  void* args[2] = {NULL, (void*)&File};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) {
                    args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
                    if (args[0]!=&returnValue) {
                      if (args[0]==NULL) {
                        PythonQt::priv()->handleVirtualOverloadReturnError("toSrec", methodInfo, result);
                      } else {
                        returnValue = *((bool*)args[0]);
                      }
                    }
                  }
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return returnValue;
                }
              }
                return srecFile::toSrec(File);
              }
              srecFile* PythonQtWrapper_srecFile::new_srecFile()
              {
              return new PythonQtShell_srecFile(); }
              srecFile* PythonQtWrapper_srecFile::new_srecFile(const QString&  File)
              {
              return new PythonQtShell_srecFile(File); }
              srecFile* PythonQtWrapper_srecFile::new_srecFile(const QStringList&  Files)
              {
              return new PythonQtShell_srecFile(Files); }
+             bool  PythonQtWrapper_srecFile::static_srecFile_checkSum(const QString&  line)
+             {
+               return (srecFile::checkSum(line));
+             }
              int  PythonQtWrapper_srecFile::closeFile(srecFile* theWrappedObject)
              {
                return ( ((PythonQtPublicPromoter_srecFile*)theWrappedObject)->promoted_closeFile());
              }
              codeFragment*  PythonQtWrapper_srecFile::getFragment(srecFile* theWrappedObject, int  index)
              {
                return ( theWrappedObject->getFragment(index));
              }
              int  PythonQtWrapper_srecFile::getFragmentAddress(srecFile* theWrappedObject, int  index)
              {
                return ( theWrappedObject->getFragmentAddress(index));
              }
              bool  PythonQtWrapper_srecFile::getFragmentData(srecFile* theWrappedObject, int  index, char**  buffer)
              {
                return ( theWrappedObject->getFragmentData(index, buffer));
              }
              QString  PythonQtWrapper_srecFile::getFragmentHeader(srecFile* theWrappedObject, int  index)
              {
                return ( theWrappedObject->getFragmentHeader(index));
              }
              int  PythonQtWrapper_srecFile::getFragmentSize(srecFile* theWrappedObject, int  index)
              {
                return ( theWrappedObject->getFragmentSize(index));
              }
              QList<codeFragment* >  PythonQtWrapper_srecFile::getFragments(srecFile* theWrappedObject)
              {
                return ( ((PythonQtPublicPromoter_srecFile*)theWrappedObject)->promoted_getFragments());
              }
              int  PythonQtWrapper_srecFile::getFragmentsCount(srecFile* theWrappedObject)
              {
                return ( theWrappedObject->getFragmentsCount());
              }
              bool  PythonQtWrapper_srecFile::isSREC(srecFile* theWrappedObject)
              {
                return ( theWrappedObject->isSREC());
              }
              bool  PythonQtWrapper_srecFile::static_srecFile_isSREC(const QString&  File)
              {
                return (srecFile::isSREC(File));
              }
              bool  PythonQtWrapper_srecFile::isopened(srecFile* theWrappedObject)
              {
                return ( ((PythonQtPublicPromoter_srecFile*)theWrappedObject)->promoted_isopened());
              }
              int  PythonQtWrapper_srecFile::lineCount(srecFile* theWrappedObject)
              {
                return ( theWrappedObject->lineCount());
              }
              bool  PythonQtWrapper_srecFile::mergingRecords(srecFile* theWrappedObject)
              {
                return ( theWrappedObject->mergingRecords());
              }
              bool  PythonQtWrapper_srecFile::openFile(srecFile* theWrappedObject, const QString&  File)
              {
                return ( ((PythonQtPublicPromoter_srecFile*)theWrappedObject)->promoted_openFile(File));
              }
              bool  PythonQtWrapper_srecFile::openFiles(srecFile* theWrappedObject, const QStringList&  Files)
              {
                return ( theWrappedObject->openFiles(Files));
              }
              void PythonQtWrapper_srecFile::setMergingRecords(srecFile* theWrappedObject, bool  enabled)
              {
                ( theWrappedObject->setMergingRecords(enabled));
              }
              bool  PythonQtWrapper_srecFile::toBinary(srecFile* theWrappedObject, const QString&  File)
              {
                return ( ((PythonQtPublicPromoter_srecFile*)theWrappedObject)->promoted_toBinary(File));
              }
              bool  PythonQtWrapper_srecFile::static_srecFile_toSrec(QList<codeFragment* >  fragments, const QString&  File)
              {
                return (srecFile::toSrec(fragments, File));
              }
              bool  PythonQtWrapper_srecFile::toSrec(srecFile* theWrappedObject, const QString&  File)
              {
                return ( ((PythonQtPublicPromoter_srecFile*)theWrappedObject)->promoted_toSrec(File));
              }
              PythonQtShell_srecFileWidget::~PythonQtShell_srecFileWidget() {
                PythonQtPrivate* priv = PythonQt::priv();
                if (priv) { priv->shellClassDeleted(this); }
              }
              void PythonQtShell_srecFileWidget::reloadFile()
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "reloadFile");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={""};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
                  void* args[1] = {NULL};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                srecFileWidget::reloadFile();
              }
              void PythonQtShell_srecFileWidget::setFile(abstractBinFile*  file)
              {
              if (_wrapper) {
                PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "setFile");
                PyErr_Clear();
                if (obj && !PythonQtSlotFunction_Check(obj)) {
                  static const char* argumentList[] ={"" , "abstractBinFile*"};
                  static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
                  void* args[2] = {NULL, (void*)&file};
                  PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
                  if (result) { Py_DECREF(result); }
                  Py_DECREF(obj);
                  return;
                }
              }
                srecFileWidget::setFile(file);
              }
              srecFileWidget* PythonQtWrapper_srecFileWidget::new_srecFileWidget(QWidget*  parent)
              {
              return new PythonQtShell_srecFileWidget(parent); }
              void PythonQtWrapper_srecFileWidget::reloadFile(srecFileWidget* theWrappedObject)
              {
                ( ((PythonQtPublicPromoter_srecFileWidget*)theWrappedObject)->promoted_reloadFile());
              }
              void PythonQtWrapper_srecFileWidget::setFile(srecFileWidget* theWrappedObject, abstractBinFile*  file)
              {
                ( ((PythonQtPublicPromoter_srecFileWidget*)theWrappedObject)->promoted_setFile(file));
              }

src/common/pythonQtOut/generated_cpp/PySocExplorer/PySocExplorer0.h +73 -4

              #include <PythonQt.h>
              #include <QIconEngine>
              #include <QObject>
-             #include <QSpinBox>
              #include <QVariant>
-             #include <QWidget>
              #include <SocExplorerPlot.h>
              #include <abstractbinfile.h>
              #include <binaryfile.h>
              #include <binaryfilewidget.h>
              #include <elffile.h>
              #include <elffilewidget.h>
              #include <elfinfowdgt.h>
              #include <elfparser.h>
+             #include <genericbinaryfilewidget.h>
              #include <memsizewdgt.h>
              #include <qaction.h>
              #include <qbitmap.h>
              #include <qbytearray.h>
              #include <qcolor.h>
              #include <qcoreevent.h>
              #include <qcursor.h>
              #include <qevent.h>
              #include <qfile.h>
              #include <qfont.h>
              #include <qgraphicseffect.h>
              #include <qgraphicsproxywidget.h>
              #include <qhexedit.h>
              #include <qhexspinbox.h>
              #include <qkeysequence.h>
              #include <qlayout.h>
              #include <qlineedit.h>
              #include <qlist.h>
              #include <qlocale.h>
              #include <qmargins.h>
              #include <qobject.h>
              #include <qpaintdevice.h>
              #include <qpaintengine.h>
              #include <qpainter.h>
              #include <qpalette.h>
              #include <qpen.h>
              #include <qpixmap.h>
              #include <qpoint.h>
              #include <qrect.h>
              #include <qregion.h>
              #include <qscrollarea.h>
              #include <qscrollbar.h>
              #include <qsize.h>
              #include <qsizepolicy.h>
              #include <qspinbox.h>
              #include <qstringlist.h>
              #include <qstyle.h>
              #include <qstyleoption.h>
              #include <qwidget.h>
              #include <srecfile.h>
              #include <srecfilewidget.h>
              #include <tcp_terminal_client.h>
              #include <xbytearray.h>
              class PythonQtShell_ElfFile : public ElfFile
              {
              public:
                  PythonQtShell_ElfFile():ElfFile(),_wrapper(NULL) {};
                  PythonQtShell_ElfFile(const QString&  File):ElfFile(File),_wrapper(NULL) {};
                 ~PythonQtShell_ElfFile();
              virtual int  closeFile();
              virtual QList<codeFragment* >  getFragments();
              virtual bool  isopened();
              virtual bool  openFile(const QString&  File);
              virtual bool  toBinary(const QString&  File);
              virtual bool  toSrec(const QString&  File);
                PythonQtInstanceWrapper* _wrapper;
              };
              class PythonQtPublicPromoter_ElfFile : public ElfFile
              { public:
              inline int  promoted_closeFile() { return ElfFile::closeFile(); }
              inline QList<codeFragment* >  promoted_getFragments() { return ElfFile::getFragments(); }
              inline bool  promoted_isopened() { return ElfFile::isopened(); }
              inline bool  promoted_openFile(const QString&  File) { return ElfFile::openFile(File); }
              inline bool  promoted_toBinary(const QString&  File) { return ElfFile::toBinary(File); }
              inline bool  promoted_toSrec(const QString&  File) { return ElfFile::toSrec(File); }
              };
              class PythonQtWrapper_ElfFile : public QObject
              { Q_OBJECT
              public:
              public slots:
              ElfFile* new_ElfFile();
              ElfFile* new_ElfFile(const QString&  File);
              void delete_ElfFile(ElfFile* obj) { delete obj; }
                 int  closeFile(ElfFile* theWrappedObject);
                 QString  getABI(ElfFile* theWrappedObject);
                 QString  getArchitecture(ElfFile* theWrappedObject);
                 QString  getClass(ElfFile* theWrappedObject);
                 QString  getEndianness(ElfFile* theWrappedObject);
                 qint64  getEntryPointAddress(ElfFile* theWrappedObject);
                 QList<codeFragment* >  getFragments(ElfFile* theWrappedObject);
                 QList<codeFragment* >  getFragments(ElfFile* theWrappedObject, QStringList  fragmentList);
                 int  getSectionCount(ElfFile* theWrappedObject);
                 bool  getSectionData(ElfFile* theWrappedObject, int  index, char**  buffer);
                 qint64  getSectionDatasz(ElfFile* theWrappedObject, int  index);
                 int  getSectionIndex(ElfFile* theWrappedObject, QString  name);
                 qint64  getSectionMemsz(ElfFile* theWrappedObject, int  index);
                 QString  getSectionName(ElfFile* theWrappedObject, int  index);
                 qint64  getSectionPaddr(ElfFile* theWrappedObject, int  index);
                 QString  getSectionType(ElfFile* theWrappedObject, int  index);
                 int  getSegmentCount(ElfFile* theWrappedObject);
                 qint64  getSegmentFilesz(ElfFile* theWrappedObject, int  index);
                 QString  getSegmentFlags(ElfFile* theWrappedObject, int  index);
                 qint64  getSegmentMemsz(ElfFile* theWrappedObject, int  index);
                 qint64  getSegmentOffset(ElfFile* theWrappedObject, int  index);
                 qint64  getSegmentPaddr(ElfFile* theWrappedObject, int  index);
                 QString  getSegmentType(ElfFile* theWrappedObject, int  index);
                 qint64  getSegmentVaddr(ElfFile* theWrappedObject, int  index);
                 quint64  getSymbolAddress(ElfFile* theWrappedObject, int  index);
                 int  getSymbolCount(ElfFile* theWrappedObject);
                 QString  getSymbolLinkType(ElfFile* theWrappedObject, int  index);
                 QString  getSymbolName(ElfFile* theWrappedObject, int  index);
                 int  getSymbolSectionIndex(ElfFile* theWrappedObject, int  index);
                 QString  getSymbolSectionName(ElfFile* theWrappedObject, int  index);
                 quint64  getSymbolSize(ElfFile* theWrappedObject, int  index);
                 QString  getSymbolType(ElfFile* theWrappedObject, int  index);
                 QString  getType(ElfFile* theWrappedObject);
                 qint64  getVersion(ElfFile* theWrappedObject);
                 bool  static_ElfFile_isElf(const QString&  File);
                 bool  iself(ElfFile* theWrappedObject);
                 bool  isopened(ElfFile* theWrappedObject);
                 bool  openFile(ElfFile* theWrappedObject, const QString&  File);
                 bool  sectionIsNobits(ElfFile* theWrappedObject, int  index);
                 bool  toBinary(ElfFile* theWrappedObject, const QString&  File);
                 bool  toSrec(ElfFile* theWrappedObject, const QString&  File);
              };
              class PythonQtShell_MemSizeWdgt : public MemSizeWdgt
              {
              public:
                  PythonQtShell_MemSizeWdgt(QWidget*  parent = 0):MemSizeWdgt(parent),_wrapper(NULL) {};
                  PythonQtShell_MemSizeWdgt(int  defaultSize, QWidget*  parent = 0):MemSizeWdgt(defaultSize, parent),_wrapper(NULL) {};
                 ~PythonQtShell_MemSizeWdgt();
              virtual void actionEvent(QActionEvent*  arg__1);
              virtual void changeEvent(QEvent*  arg__1);
              virtual void childEvent(QChildEvent*  arg__1);
              virtual void closeEvent(QCloseEvent*  arg__1);
              virtual void contextMenuEvent(QContextMenuEvent*  arg__1);
              virtual void customEvent(QEvent*  arg__1);
              virtual int  devType() const;
              virtual void dragEnterEvent(QDragEnterEvent*  arg__1);
              virtual void dragLeaveEvent(QDragLeaveEvent*  arg__1);
              virtual void dragMoveEvent(QDragMoveEvent*  arg__1);
              virtual void dropEvent(QDropEvent*  arg__1);
              virtual void enterEvent(QEvent*  arg__1);
              virtual bool  event(QEvent*  arg__1);
              virtual bool  eventFilter(QObject*  arg__1, QEvent*  arg__2);
              virtual void focusInEvent(QFocusEvent*  arg__1);
              virtual bool  focusNextPrevChild(bool  next);
              virtual void focusOutEvent(QFocusEvent*  arg__1);
              virtual bool  hasHeightForWidth() const;
              virtual int  heightForWidth(int  arg__1) const;
              virtual void hideEvent(QHideEvent*  arg__1);
              virtual void initPainter(QPainter*  painter) const;
              virtual void inputMethodEvent(QInputMethodEvent*  arg__1);
              virtual QVariant  inputMethodQuery(Qt::InputMethodQuery  arg__1) const;
              virtual void keyPressEvent(QKeyEvent*  arg__1);
              virtual void keyReleaseEvent(QKeyEvent*  arg__1);
              virtual void leaveEvent(QEvent*  arg__1);
              virtual int  metric(QPaintDevice::PaintDeviceMetric  arg__1) const;
              virtual QSize  minimumSizeHint() const;
              virtual void mouseDoubleClickEvent(QMouseEvent*  arg__1);
              virtual void mouseMoveEvent(QMouseEvent*  arg__1);
              virtual void mousePressEvent(QMouseEvent*  arg__1);
              virtual void mouseReleaseEvent(QMouseEvent*  arg__1);
              virtual void moveEvent(QMoveEvent*  arg__1);
              virtual bool  nativeEvent(const QByteArray&  eventType, void*  message, long*  result);
              virtual QPaintEngine*  paintEngine() const;
              virtual void paintEvent(QPaintEvent*  arg__1);
              virtual QPaintDevice*  redirected(QPoint*  offset) const;
              virtual void resizeEvent(QResizeEvent*  arg__1);
              virtual QPainter*  sharedPainter() const;
              virtual void showEvent(QShowEvent*  arg__1);
              virtual QSize  sizeHint() const;
              virtual void tabletEvent(QTabletEvent*  arg__1);
              virtual void timerEvent(QTimerEvent*  arg__1);
              virtual void wheelEvent(QWheelEvent*  arg__1);
                PythonQtInstanceWrapper* _wrapper;
              };
              class PythonQtWrapper_MemSizeWdgt : public QObject
              { Q_OBJECT
              public:
              public slots:
              MemSizeWdgt* new_MemSizeWdgt(QWidget*  parent = 0);
              MemSizeWdgt* new_MemSizeWdgt(int  defaultSize, QWidget*  parent = 0);
              void delete_MemSizeWdgt(MemSizeWdgt* obj) { delete obj; }
                 int  getsize(MemSizeWdgt* theWrappedObject);
                 void setMaximum(MemSizeWdgt* theWrappedObject, unsigned int  max);
                 void show(MemSizeWdgt* theWrappedObject);
                 void updateSizeValue(MemSizeWdgt* theWrappedObject);
              };
              class PythonQtShell_QHexEdit : public QHexEdit
              {
              public:
                  PythonQtShell_QHexEdit(QWidget*  parent = 0):QHexEdit(parent),_wrapper(NULL) {};
                 ~PythonQtShell_QHexEdit();
              virtual void actionEvent(QActionEvent*  arg__1);
              virtual void changeEvent(QEvent*  arg__1);
              virtual void childEvent(QChildEvent*  arg__1);
              virtual void closeEvent(QCloseEvent*  arg__1);
              virtual void contextMenuEvent(QContextMenuEvent*  arg__1);
              virtual void customEvent(QEvent*  arg__1);
              virtual int  devType() const;
              virtual void dragEnterEvent(QDragEnterEvent*  arg__1);
              virtual void dragLeaveEvent(QDragLeaveEvent*  arg__1);
              virtual void dragMoveEvent(QDragMoveEvent*  arg__1);
              virtual void dropEvent(QDropEvent*  arg__1);
              virtual void enterEvent(QEvent*  arg__1);
              virtual bool  event(QEvent*  arg__1);
              virtual bool  eventFilter(QObject*  arg__1, QEvent*  arg__2);
              virtual void focusInEvent(QFocusEvent*  arg__1);
              virtual bool  focusNextPrevChild(bool  next);
              virtual void focusOutEvent(QFocusEvent*  arg__1);
              virtual bool  hasHeightForWidth() const;
              virtual int  heightForWidth(int  arg__1) const;
              virtual void hideEvent(QHideEvent*  arg__1);
              virtual void initPainter(QPainter*  painter) const;
              virtual void inputMethodEvent(QInputMethodEvent*  arg__1);
              virtual QVariant  inputMethodQuery(Qt::InputMethodQuery  arg__1) const;
              virtual void keyPressEvent(QKeyEvent*  arg__1);
              virtual void keyReleaseEvent(QKeyEvent*  arg__1);
              virtual void leaveEvent(QEvent*  arg__1);
              virtual int  metric(QPaintDevice::PaintDeviceMetric  arg__1) const;
              virtual void mouseDoubleClickEvent(QMouseEvent*  arg__1);
              virtual void mouseMoveEvent(QMouseEvent*  arg__1);
              virtual void mousePressEvent(QMouseEvent*  arg__1);
              virtual void mouseReleaseEvent(QMouseEvent*  arg__1);
              virtual void moveEvent(QMoveEvent*  arg__1);
              virtual bool  nativeEvent(const QByteArray&  eventType, void*  message, long*  result);
              virtual QPaintEngine*  paintEngine() const;
              virtual void paintEvent(QPaintEvent*  arg__1);
              virtual QPaintDevice*  redirected(QPoint*  offset) const;
              virtual void resizeEvent(QResizeEvent*  arg__1);
              virtual void scrollContentsBy(int  dx, int  dy);
              virtual void setupViewport(QWidget*  viewport);
              virtual QPainter*  sharedPainter() const;
              virtual void showEvent(QShowEvent*  arg__1);
              virtual void tabletEvent(QTabletEvent*  arg__1);
              virtual void timerEvent(QTimerEvent*  arg__1);
              virtual bool  viewportEvent(QEvent*  arg__1);
              virtual QSize  viewportSizeHint() const;
              virtual void wheelEvent(QWheelEvent*  arg__1);
                PythonQtInstanceWrapper* _wrapper;
              };
              class PythonQtWrapper_QHexEdit : public QObject
              { Q_OBJECT
              public:
              public slots:
              QHexEdit* new_QHexEdit(QWidget*  parent = 0);
              void delete_QHexEdit(QHexEdit* obj) { delete obj; }
                 QColor  addressAreaColor(QHexEdit* theWrappedObject);
                 int  addressOffset(QHexEdit* theWrappedObject);
                 int  cursorPosition(QHexEdit* theWrappedObject);
                 QByteArray  data(QHexEdit* theWrappedObject);
                 const QFont*  font(QHexEdit* theWrappedObject) const;
                 int  getSelectionBegin(QHexEdit* theWrappedObject);
                 int  getSelectionEnd(QHexEdit* theWrappedObject);
                 QColor  highlightingColor(QHexEdit* theWrappedObject);
                 int  indexOf(QHexEdit* theWrappedObject, const QByteArray&  ba, int  from = 0) const;
                 void insert(QHexEdit* theWrappedObject, int  i, char  ch);
                 void insert(QHexEdit* theWrappedObject, int  i, const QByteArray&  ba);
                 bool  isReadOnly(QHexEdit* theWrappedObject);
                 int  lastIndexOf(QHexEdit* theWrappedObject, const QByteArray&  ba, int  from = 0) const;
                 bool  overwriteMode(QHexEdit* theWrappedObject);
                 void remove(QHexEdit* theWrappedObject, int  pos, int  len = 1);
                 void replace(QHexEdit* theWrappedObject, int  pos, int  len, const QByteArray&  after);
                 void resetSelection(QHexEdit* theWrappedObject);
                 void resetSelection(QHexEdit* theWrappedObject, int  pos);
                 QColor  selectionColor(QHexEdit* theWrappedObject);
                 QString  selectionToReadableString(QHexEdit* theWrappedObject);
                 void setAddressAreaColor(QHexEdit* theWrappedObject, const QColor&  color);
                 void setAddressOffset(QHexEdit* theWrappedObject, int  offset);
                 void setCursorPosition(QHexEdit* theWrappedObject, int  cusorPos);
                 void setData(QHexEdit* theWrappedObject, const QByteArray&  data);
                 void setFont(QHexEdit* theWrappedObject, const QFont&  arg__1);
                 void setHighlightingColor(QHexEdit* theWrappedObject, const QColor&  color);
                 void setOverwriteMode(QHexEdit* theWrappedObject, bool  arg__1);
                 void setReadOnly(QHexEdit* theWrappedObject, bool  arg__1);
                 void setSelection(QHexEdit* theWrappedObject, int  pos);
                 void setSelectionColor(QHexEdit* theWrappedObject, const QColor&  color);
                 QString  toReadableString(QHexEdit* theWrappedObject);
              };
              class PythonQtShell_QHexSpinBox : public QHexSpinBox
              {
              public:
                  PythonQtShell_QHexSpinBox(QWidget*  parent = 0):QHexSpinBox(parent),_wrapper(NULL) {};
                 ~PythonQtShell_QHexSpinBox();
              virtual void actionEvent(QActionEvent*  arg__1);
              virtual void changeEvent(QEvent*  event);
              virtual void childEvent(QChildEvent*  arg__1);
              virtual void clear();
              virtual void closeEvent(QCloseEvent*  event);
              virtual void contextMenuEvent(QContextMenuEvent*  event);
              virtual void customEvent(QEvent*  arg__1);
              virtual int  devType() const;
              virtual void dragEnterEvent(QDragEnterEvent*  arg__1);
              virtual void dragLeaveEvent(QDragLeaveEvent*  arg__1);
              virtual void dragMoveEvent(QDragMoveEvent*  arg__1);
              virtual void dropEvent(QDropEvent*  arg__1);
              virtual void enterEvent(QEvent*  arg__1);
              virtual bool  event(QEvent*  event);
              virtual bool  eventFilter(QObject*  arg__1, QEvent*  arg__2);
              virtual void fixup(QString&  str) const;
              virtual void focusInEvent(QFocusEvent*  event);
              virtual bool  focusNextPrevChild(bool  next);
              virtual void focusOutEvent(QFocusEvent*  event);
              virtual bool  hasHeightForWidth() const;
              virtual int  heightForWidth(int  arg__1) const;
              virtual void hideEvent(QHideEvent*  event);
              virtual void initPainter(QPainter*  painter) const;
              virtual void inputMethodEvent(QInputMethodEvent*  arg__1);
              virtual QVariant  inputMethodQuery(Qt::InputMethodQuery  arg__1) const;
              virtual void keyPressEvent(QKeyEvent*  event);
              virtual void keyReleaseEvent(QKeyEvent*  event);
              virtual void leaveEvent(QEvent*  arg__1);
              virtual int  metric(QPaintDevice::PaintDeviceMetric  arg__1) const;
              virtual void mouseDoubleClickEvent(QMouseEvent*  arg__1);
              virtual void mouseMoveEvent(QMouseEvent*  event);
              virtual void mousePressEvent(QMouseEvent*  event);
              virtual void mouseReleaseEvent(QMouseEvent*  event);
              virtual void moveEvent(QMoveEvent*  arg__1);
              virtual bool  nativeEvent(const QByteArray&  eventType, void*  message, long*  result);
              virtual QPaintEngine*  paintEngine() const;
              virtual void paintEvent(QPaintEvent*  event);
              virtual QPaintDevice*  redirected(QPoint*  offset) const;
              virtual void resizeEvent(QResizeEvent*  event);
              virtual QPainter*  sharedPainter() const;
              virtual void showEvent(QShowEvent*  event);
              virtual void stepBy(int  steps);
              virtual QAbstractSpinBox::StepEnabled  stepEnabled() const;
              virtual void tabletEvent(QTabletEvent*  arg__1);
              virtual QString  textFromValue(int  value) const;
              virtual void timerEvent(QTimerEvent*  event);
              virtual QValidator::State  validate(QString&  input, int&  pos) const;
              virtual int  valueFromText(const QString&  text) const;
              virtual void wheelEvent(QWheelEvent*  event);
                PythonQtInstanceWrapper* _wrapper;
              };
              class PythonQtPublicPromoter_QHexSpinBox : public QHexSpinBox
              { public:
              inline QString  promoted_textFromValue(int  value) const { return QHexSpinBox::textFromValue(value); }
              inline QValidator::State  promoted_validate(QString&  input, int&  pos) const { return QHexSpinBox::validate(input, pos); }
              inline int  promoted_valueFromText(const QString&  text) const { return QHexSpinBox::valueFromText(text); }
              };
              class PythonQtWrapper_QHexSpinBox : public QObject
              { Q_OBJECT
              public:
              public slots:
              QHexSpinBox* new_QHexSpinBox(QWidget*  parent = 0);
              void delete_QHexSpinBox(QHexSpinBox* obj) { delete obj; }
                 void show(QHexSpinBox* theWrappedObject);
                 QString  textFromValue(QHexSpinBox* theWrappedObject, int  value) const;
                 QValidator::State  validate(QHexSpinBox* theWrappedObject, QString&  input, int&  pos) const;
                 int  valueFromText(QHexSpinBox* theWrappedObject, const QString&  text) const;
              };
              class PythonQtShell_SocExplorerPlot : public SocExplorerPlot
              {
              public:
                  PythonQtShell_SocExplorerPlot(QWidget*  parent = 0):SocExplorerPlot(parent),_wrapper(NULL) {};
                 ~PythonQtShell_SocExplorerPlot();
              virtual void actionEvent(QActionEvent*  arg__1);
              virtual void changeEvent(QEvent*  arg__1);
              virtual void childEvent(QChildEvent*  arg__1);
              virtual void closeEvent(QCloseEvent*  arg__1);
              virtual void contextMenuEvent(QContextMenuEvent*  arg__1);
              virtual void customEvent(QEvent*  arg__1);
              virtual int  devType() const;
              virtual void dragEnterEvent(QDragEnterEvent*  arg__1);
              virtual void dragLeaveEvent(QDragLeaveEvent*  arg__1);
              virtual void dragMoveEvent(QDragMoveEvent*  arg__1);
              virtual void dropEvent(QDropEvent*  arg__1);
              virtual void enterEvent(QEvent*  arg__1);
              virtual bool  event(QEvent*  arg__1);
              virtual bool  eventFilter(QObject*  arg__1, QEvent*  arg__2);
              virtual void focusInEvent(QFocusEvent*  arg__1);
              virtual bool  focusNextPrevChild(bool  next);
              virtual void focusOutEvent(QFocusEvent*  arg__1);
              virtual bool  hasHeightForWidth() const;
              virtual int  heightForWidth(int  arg__1) const;
              virtual void hideEvent(QHideEvent*  arg__1);
              virtual void initPainter(QPainter*  painter) const;
              virtual void inputMethodEvent(QInputMethodEvent*  arg__1);
              virtual QVariant  inputMethodQuery(Qt::InputMethodQuery  arg__1) const;
              virtual void keyPressEvent(QKeyEvent*  arg__1);
              virtual void keyReleaseEvent(QKeyEvent*  arg__1);
              virtual void leaveEvent(QEvent*  arg__1);
              virtual int  metric(QPaintDevice::PaintDeviceMetric  arg__1) const;
              virtual QSize  minimumSizeHint() const;
              virtual void mouseDoubleClickEvent(QMouseEvent*  arg__1);
              virtual void mouseMoveEvent(QMouseEvent*  arg__1);
              virtual void mousePressEvent(QMouseEvent*  arg__1);
              virtual void mouseReleaseEvent(QMouseEvent*  arg__1);
              virtual void moveEvent(QMoveEvent*  arg__1);
              virtual bool  nativeEvent(const QByteArray&  eventType, void*  message, long*  result);
              virtual QPaintEngine*  paintEngine() const;
              virtual void paintEvent(QPaintEvent*  arg__1);
              virtual QPaintDevice*  redirected(QPoint*  offset) const;
              virtual void resizeEvent(QResizeEvent*  arg__1);
              virtual QPainter*  sharedPainter() const;
              virtual void showEvent(QShowEvent*  arg__1);
              virtual QSize  sizeHint() const;
              virtual void tabletEvent(QTabletEvent*  arg__1);
              virtual void timerEvent(QTimerEvent*  arg__1);
              virtual void wheelEvent(QWheelEvent*  arg__1);
                PythonQtInstanceWrapper* _wrapper;
              };
              class PythonQtPublicPromoter_SocExplorerPlot : public SocExplorerPlot
              { public:
              inline void promoted_keyPressEvent(QKeyEvent*  arg__1) { SocExplorerPlot::keyPressEvent(arg__1); }
              inline void promoted_keyReleaseEvent(QKeyEvent*  arg__1) { SocExplorerPlot::keyReleaseEvent(arg__1); }
              inline void promoted_mouseMoveEvent(QMouseEvent*  arg__1) { SocExplorerPlot::mouseMoveEvent(arg__1); }
              inline void promoted_mousePressEvent(QMouseEvent*  arg__1) { SocExplorerPlot::mousePressEvent(arg__1); }
              inline void promoted_mouseReleaseEvent(QMouseEvent*  arg__1) { SocExplorerPlot::mouseReleaseEvent(arg__1); }
              inline void promoted_wheelEvent(QWheelEvent*  arg__1) { SocExplorerPlot::wheelEvent(arg__1); }
              };
              class PythonQtWrapper_SocExplorerPlot : public QObject
              { Q_OBJECT
              public:
              public slots:
              SocExplorerPlot* new_SocExplorerPlot(QWidget*  parent = 0);
              void delete_SocExplorerPlot(SocExplorerPlot* obj) { delete obj; }
                 int  addGraph(SocExplorerPlot* theWrappedObject);
                 void addGraphData(SocExplorerPlot* theWrappedObject, int  graphIndex, QList<QVariant >  x, QList<QVariant >  y);
                 void addGraphData(SocExplorerPlot* theWrappedObject, int  graphIndex, QVariant  x, QVariant  y);
                 QPen  getGraphPen(SocExplorerPlot* theWrappedObject, int  graphIndex);
                 void keyPressEvent(SocExplorerPlot* theWrappedObject, QKeyEvent*  arg__1);
                 void keyReleaseEvent(SocExplorerPlot* theWrappedObject, QKeyEvent*  arg__1);
                 void mouseMoveEvent(SocExplorerPlot* theWrappedObject, QMouseEvent*  arg__1);
                 void mousePressEvent(SocExplorerPlot* theWrappedObject, QMouseEvent*  arg__1);
                 void mouseReleaseEvent(SocExplorerPlot* theWrappedObject, QMouseEvent*  arg__1);
                 void rescaleAxis(SocExplorerPlot* theWrappedObject);
                 void setAdaptativeSampling(SocExplorerPlot* theWrappedObject, int  graphIndex, bool  enable);
                 void setGraphData(SocExplorerPlot* theWrappedObject, int  graphIndex, QList<QVariant >  x, QList<QVariant >  y);
                 void setGraphLineStyle(SocExplorerPlot* theWrappedObject, int  graphIndex, QString  lineStyle);
                 void setGraphName(SocExplorerPlot* theWrappedObject, int  graphIndex, QString  name);
                 void setGraphPen(SocExplorerPlot* theWrappedObject, int  graphIndex, QPen  pen);
                 void setGraphScatterStyle(SocExplorerPlot* theWrappedObject, int  graphIndex, QString  scatterStyle);
                 void setLegendFont(SocExplorerPlot* theWrappedObject, QFont  font);
                 void setLegendSelectedFont(SocExplorerPlot* theWrappedObject, QFont  font);
                 void setTitle(SocExplorerPlot* theWrappedObject, QString  title);
                 void setXaxisLabel(SocExplorerPlot* theWrappedObject, QString  label);
                 void setXaxisRange(SocExplorerPlot* theWrappedObject, double  lower, double  upper);
                 void setYaxisLabel(SocExplorerPlot* theWrappedObject, QString  label);
                 void setYaxisRange(SocExplorerPlot* theWrappedObject, double  lower, double  upper);
                 void show(SocExplorerPlot* theWrappedObject);
                 void wheelEvent(SocExplorerPlot* theWrappedObject, QWheelEvent*  arg__1);
              };
              class PythonQtShell_TCP_Terminal_Client : public TCP_Terminal_Client
              {
              public:
                  PythonQtShell_TCP_Terminal_Client(QObject*  parent = 0):TCP_Terminal_Client(parent),_wrapper(NULL) {};
                 ~PythonQtShell_TCP_Terminal_Client();
              virtual void childEvent(QChildEvent*  arg__1);
              virtual void customEvent(QEvent*  arg__1);
              virtual bool  event(QEvent*  arg__1);
              virtual bool  eventFilter(QObject*  arg__1, QEvent*  arg__2);
              virtual void timerEvent(QTimerEvent*  arg__1);
                PythonQtInstanceWrapper* _wrapper;
              };
              class PythonQtWrapper_TCP_Terminal_Client : public QObject
              { Q_OBJECT
              public:
              public slots:
              TCP_Terminal_Client* new_TCP_Terminal_Client(QObject*  parent = 0);
              void delete_TCP_Terminal_Client(TCP_Terminal_Client* obj) { delete obj; }
                 void connectToServer(TCP_Terminal_Client* theWrappedObject);
                 void connectToServer(TCP_Terminal_Client* theWrappedObject, const QString&  IP, int  port);
                 bool  isConnected(TCP_Terminal_Client* theWrappedObject);
                 void sendText(TCP_Terminal_Client* theWrappedObject, const QString&  text);
                 void startServer(TCP_Terminal_Client* theWrappedObject);
                 void startServer(TCP_Terminal_Client* theWrappedObject, int  port);
              };
              class PythonQtWrapper_XByteArray : public QObject
              { Q_OBJECT
              public:
              public slots:
              XByteArray* new_XByteArray();
              void delete_XByteArray(XByteArray* obj) { delete obj; }
                 int  addressOffset(XByteArray* theWrappedObject);
                 int  addressWidth(XByteArray* theWrappedObject);
                 QChar  asciiChar(XByteArray* theWrappedObject, int  index);
                 QByteArray*  data(XByteArray* theWrappedObject);
                 bool  dataChanged(XByteArray* theWrappedObject, int  i);
                 QByteArray  dataChanged(XByteArray* theWrappedObject, int  i, int  len);
                 QByteArray*  insert(XByteArray* theWrappedObject, int  i, char  ch);
                 QByteArray*  insert(XByteArray* theWrappedObject, int  i, const QByteArray&  ba);
                 int  realAddressNumbers(XByteArray* theWrappedObject);
                 QByteArray*  remove(XByteArray* theWrappedObject, int  pos, int  len);
                 QByteArray*  replace(XByteArray* theWrappedObject, int  index, char  ch);
                 QByteArray*  replace(XByteArray* theWrappedObject, int  index, const QByteArray&  ba);
                 QByteArray*  replace(XByteArray* theWrappedObject, int  index, int  length, const QByteArray&  ba);
                 void setAddressOffset(XByteArray* theWrappedObject, int  offset);
                 void setAddressWidth(XByteArray* theWrappedObject, int  width);
                 void setData(XByteArray* theWrappedObject, QByteArray  data);
                 void setDataChanged(XByteArray* theWrappedObject, int  i, bool  state);
                 void setDataChanged(XByteArray* theWrappedObject, int  i, const QByteArray&  state);
                 int  size(XByteArray* theWrappedObject);
                 QString  toRedableString(XByteArray* theWrappedObject, int  start = 0, int  end = -1);
              };
              class PythonQtShell_abstractBinFile : public abstractBinFile
              {
              public:
                  PythonQtShell_abstractBinFile():abstractBinFile(),_wrapper(NULL) {};
                 ~PythonQtShell_abstractBinFile();
              virtual void childEvent(QChildEvent*  arg__1);
              virtual int  closeFile();
              virtual void customEvent(QEvent*  arg__1);
              virtual bool  event(QEvent*  arg__1);
              virtual bool  eventFilter(QObject*  arg__1, QEvent*  arg__2);
              virtual QList<codeFragment* >  getFragments();
              virtual bool  isopened();
              virtual bool  openFile(const QString&  File);
              virtual void timerEvent(QTimerEvent*  arg__1);
              virtual bool  toBinary(const QString&  File);
              virtual bool  toSrec(const QString&  File);
                PythonQtInstanceWrapper* _wrapper;
              };
              class PythonQtWrapper_abstractBinFile : public QObject
              { Q_OBJECT
              public:
              public slots:
              abstractBinFile* new_abstractBinFile();
              void delete_abstractBinFile(abstractBinFile* obj) { delete obj; }
              };
              class PythonQtShell_abstractBinFileWidget : public abstractBinFileWidget
              {
              public:
                  PythonQtShell_abstractBinFileWidget(QWidget*  parent = 0):abstractBinFileWidget(parent),_wrapper(NULL) {};
                 ~PythonQtShell_abstractBinFileWidget();
              virtual void actionEvent(QActionEvent*  arg__1);
              virtual void changeEvent(QEvent*  arg__1);
              virtual void childEvent(QChildEvent*  arg__1);
              virtual void closeEvent(QCloseEvent*  arg__1);
              virtual void contextMenuEvent(QContextMenuEvent*  arg__1);
              virtual void customEvent(QEvent*  arg__1);
              virtual int  devType() const;
              virtual void dragEnterEvent(QDragEnterEvent*  arg__1);
              virtual void dragLeaveEvent(QDragLeaveEvent*  arg__1);
              virtual void dragMoveEvent(QDragMoveEvent*  arg__1);
              virtual void dropEvent(QDropEvent*  arg__1);
              virtual void enterEvent(QEvent*  arg__1);
              virtual bool  event(QEvent*  arg__1);
              virtual bool  eventFilter(QObject*  arg__1, QEvent*  arg__2);
              virtual void focusInEvent(QFocusEvent*  arg__1);
              virtual bool  focusNextPrevChild(bool  next);
              virtual void focusOutEvent(QFocusEvent*  arg__1);
              virtual bool  hasHeightForWidth() const;
              virtual int  heightForWidth(int  arg__1) const;
              virtual void hideEvent(QHideEvent*  arg__1);
              virtual void initPainter(QPainter*  painter) const;
              virtual void inputMethodEvent(QInputMethodEvent*  arg__1);
              virtual QVariant  inputMethodQuery(Qt::InputMethodQuery  arg__1) const;
              virtual void keyPressEvent(QKeyEvent*  arg__1);
              virtual void keyReleaseEvent(QKeyEvent*  arg__1);
              virtual void leaveEvent(QEvent*  arg__1);
              virtual int  metric(QPaintDevice::PaintDeviceMetric  arg__1) const;
              virtual QSize  minimumSizeHint() const;
              virtual void mouseDoubleClickEvent(QMouseEvent*  arg__1);
              virtual void mouseMoveEvent(QMouseEvent*  arg__1);
              virtual void mousePressEvent(QMouseEvent*  arg__1);
              virtual void mouseReleaseEvent(QMouseEvent*  arg__1);
              virtual void moveEvent(QMoveEvent*  arg__1);
              virtual bool  nativeEvent(const QByteArray&  eventType, void*  message, long*  result);
              virtual QPaintEngine*  paintEngine() const;
              virtual void paintEvent(QPaintEvent*  arg__1);
              virtual QPaintDevice*  redirected(QPoint*  offset) const;
              virtual void reloadFile();
              virtual void resizeEvent(QResizeEvent*  arg__1);
              virtual void setFile(abstractBinFile*  file);
              virtual QPainter*  sharedPainter() const;
              virtual void showEvent(QShowEvent*  arg__1);
              virtual QSize  sizeHint() const;
              virtual void tabletEvent(QTabletEvent*  arg__1);
              virtual void timerEvent(QTimerEvent*  arg__1);
              virtual void wheelEvent(QWheelEvent*  arg__1);
                PythonQtInstanceWrapper* _wrapper;
              };
              class PythonQtWrapper_abstractBinFileWidget : public QObject
              { Q_OBJECT
              public:
              public slots:
              abstractBinFileWidget* new_abstractBinFileWidget(QWidget*  parent = 0);
              void delete_abstractBinFileWidget(abstractBinFileWidget* obj) { delete obj; }
              };
              class PythonQtShell_binaryFile : public binaryFile
              {
              public:
                  PythonQtShell_binaryFile():binaryFile(),_wrapper(NULL) {};
                  PythonQtShell_binaryFile(const QString&  File):binaryFile(File),_wrapper(NULL) {};
                  PythonQtShell_binaryFile(const QStringList&  Files):binaryFile(Files),_wrapper(NULL) {};
                 ~PythonQtShell_binaryFile();
              virtual int  closeFile();
              virtual QList<codeFragment* >  getFragments();
              virtual bool  isopened();
              virtual bool  openFile(const QString&  File);
              virtual bool  toBinary(const QString&  fileName);
              virtual bool  toSrec(const QString&  fileName);
                PythonQtInstanceWrapper* _wrapper;
              };
              class PythonQtPublicPromoter_binaryFile : public binaryFile
              { public:
              inline int  promoted_closeFile() { return binaryFile::closeFile(); }
              inline QList<codeFragment* >  promoted_getFragments() { return binaryFile::getFragments(); }
              inline bool  promoted_isopened() { return binaryFile::isopened(); }
              inline bool  promoted_openFile(const QString&  File) { return binaryFile::openFile(File); }
              inline bool  promoted_toBinary(const QString&  fileName) { return binaryFile::toBinary(fileName); }
              inline bool  promoted_toSrec(const QString&  fileName) { return binaryFile::toSrec(fileName); }
              };
              class PythonQtWrapper_binaryFile : public QObject
              { Q_OBJECT
              public:
              public slots:
              binaryFile* new_binaryFile();
              binaryFile* new_binaryFile(const QString&  File);
              binaryFile* new_binaryFile(const QStringList&  Files);
              void delete_binaryFile(binaryFile* obj) { delete obj; }
                 int  closeFile(binaryFile* theWrappedObject);
                 codeFragment*  getFragment(binaryFile* theWrappedObject, int  index);
                 int  getFragmentAddress(binaryFile* theWrappedObject, int  index);
                 bool  getFragmentData(binaryFile* theWrappedObject, int  index, char**  buffer);
                 QString  getFragmentHeader(binaryFile* theWrappedObject, int  index);
                 int  getFragmentSize(binaryFile* theWrappedObject, int  index);
                 QList<codeFragment* >  getFragments(binaryFile* theWrappedObject);
                 int  getFragmentsCount(binaryFile* theWrappedObject);
                 bool  isopened(binaryFile* theWrappedObject);
                 bool  openFile(binaryFile* theWrappedObject, const QString&  File);
                 bool  openFiles(binaryFile* theWrappedObject, const QStringList&  Files);
                 bool  static_binaryFile_toBinary(QList<codeFragment* >  fragments, const QString&  File);
                 bool  toBinary(binaryFile* theWrappedObject, const QString&  fileName);
                 bool  toSrec(binaryFile* theWrappedObject, const QString&  fileName);
              };
              class PythonQtShell_binaryFileWidget : public binaryFileWidget
              {
              public:
                  PythonQtShell_binaryFileWidget(QWidget*  parent = 0):binaryFileWidget(parent),_wrapper(NULL) {};
                 ~PythonQtShell_binaryFileWidget();
              virtual void reloadFile();
              virtual void setFile(abstractBinFile*  file);
                PythonQtInstanceWrapper* _wrapper;
              };
              class PythonQtPublicPromoter_binaryFileWidget : public binaryFileWidget
              { public:
              inline void promoted_reloadFile() { binaryFileWidget::reloadFile(); }
              inline void promoted_setFile(abstractBinFile*  file) { binaryFileWidget::setFile(file); }
              };
              class PythonQtWrapper_binaryFileWidget : public QObject
              { Q_OBJECT
              public:
              public slots:
              binaryFileWidget* new_binaryFileWidget(QWidget*  parent = 0);
              void delete_binaryFileWidget(binaryFileWidget* obj) { delete obj; }
                 void reloadFile(binaryFileWidget* theWrappedObject);
                 void setFile(binaryFileWidget* theWrappedObject, abstractBinFile*  file);
              };
              class PythonQtShell_codeFragment : public codeFragment
              {
              public:
                  PythonQtShell_codeFragment():codeFragment(),_wrapper(NULL) {};
                  PythonQtShell_codeFragment(char*  data, quint64  size, quint64  address):codeFragment(data, size, address),_wrapper(NULL) {};
                 ~PythonQtShell_codeFragment();
                PythonQtInstanceWrapper* _wrapper;
              };
              class PythonQtWrapper_codeFragment : public QObject
              { Q_OBJECT
              public:
              public slots:
              codeFragment* new_codeFragment();
              codeFragment* new_codeFragment(char*  data, quint64  size, quint64  address);
              void delete_codeFragment(codeFragment* obj) { delete obj; }
              void py_set_size(codeFragment* theWrappedObject, quint64  size){ theWrappedObject->size = size; }
              quint64  py_get_size(codeFragment* theWrappedObject){ return theWrappedObject->size; }
+             void py_set_data(codeFragment* theWrappedObject, char*  data){ theWrappedObject->data = data; }
+             char*  py_get_data(codeFragment* theWrappedObject){ return theWrappedObject->data; }
              void py_set_address(codeFragment* theWrappedObject, quint64  address){ theWrappedObject->address = address; }
              quint64  py_get_address(codeFragment* theWrappedObject){ return theWrappedObject->address; }
-             void py_set_data(codeFragment* theWrappedObject, char*  data){ theWrappedObject->data = data; }
-             char*  py_get_data(codeFragment* theWrappedObject){ return theWrappedObject->data; }
              void py_set_header(codeFragment* theWrappedObject, QString  header){ theWrappedObject->header = header; }
              QString  py_get_header(codeFragment* theWrappedObject){ return theWrappedObject->header; }
              };
              class PythonQtShell_elfFileWidget : public elfFileWidget
              {
              public:
                  PythonQtShell_elfFileWidget(QWidget*  parent = 0):elfFileWidget(parent),_wrapper(NULL) {};
                 ~PythonQtShell_elfFileWidget();
              virtual void reloadFile();
              virtual void setFile(abstractBinFile*  file);
                PythonQtInstanceWrapper* _wrapper;
              };
              class PythonQtPublicPromoter_elfFileWidget : public elfFileWidget
              { public:
              inline void promoted_reloadFile() { elfFileWidget::reloadFile(); }
+             inline void promoted_setFile(abstractBinFile*  file) { elfFileWidget::setFile(file); }
              };
              class PythonQtWrapper_elfFileWidget : public QObject
              { Q_OBJECT
              public:
              public slots:
              elfFileWidget* new_elfFileWidget(QWidget*  parent = 0);
              void delete_elfFileWidget(elfFileWidget* obj) { delete obj; }
                 void reloadFile(elfFileWidget* theWrappedObject);
+                void setFile(elfFileWidget* theWrappedObject, abstractBinFile*  file);
              };
              class PythonQtShell_elfInfoWdgt : public elfInfoWdgt
              {
              public:
                  PythonQtShell_elfInfoWdgt(QWidget*  parent = 0):elfInfoWdgt(parent),_wrapper(NULL) {};
                 ~PythonQtShell_elfInfoWdgt();
              virtual void actionEvent(QActionEvent*  arg__1);
              virtual void changeEvent(QEvent*  arg__1);
              virtual void childEvent(QChildEvent*  arg__1);
              virtual void closeEvent(QCloseEvent*  arg__1);
              virtual void contextMenuEvent(QContextMenuEvent*  arg__1);
              virtual void customEvent(QEvent*  arg__1);
              virtual int  devType() const;
              virtual void dragEnterEvent(QDragEnterEvent*  arg__1);
              virtual void dragLeaveEvent(QDragLeaveEvent*  arg__1);
              virtual void dragMoveEvent(QDragMoveEvent*  arg__1);
              virtual void dropEvent(QDropEvent*  arg__1);
              virtual void enterEvent(QEvent*  arg__1);
              virtual bool  event(QEvent*  arg__1);
              virtual bool  eventFilter(QObject*  arg__1, QEvent*  arg__2);
              virtual void focusInEvent(QFocusEvent*  arg__1);
              virtual bool  focusNextPrevChild(bool  next);
              virtual void focusOutEvent(QFocusEvent*  arg__1);
              virtual bool  hasHeightForWidth() const;
              virtual int  heightForWidth(int  arg__1) const;
              virtual void hideEvent(QHideEvent*  arg__1);
              virtual void initPainter(QPainter*  painter) const;
              virtual void inputMethodEvent(QInputMethodEvent*  arg__1);
              virtual QVariant  inputMethodQuery(Qt::InputMethodQuery  arg__1) const;
              virtual void keyPressEvent(QKeyEvent*  arg__1);
              virtual void keyReleaseEvent(QKeyEvent*  arg__1);
              virtual void leaveEvent(QEvent*  arg__1);
              virtual int  metric(QPaintDevice::PaintDeviceMetric  arg__1) const;
              virtual QSize  minimumSizeHint() const;
              virtual void mouseDoubleClickEvent(QMouseEvent*  arg__1);
              virtual void mouseMoveEvent(QMouseEvent*  arg__1);
              virtual void mousePressEvent(QMouseEvent*  arg__1);
              virtual void mouseReleaseEvent(QMouseEvent*  arg__1);
              virtual void moveEvent(QMoveEvent*  arg__1);
              virtual bool  nativeEvent(const QByteArray&  eventType, void*  message, long*  result);
              virtual QPaintEngine*  paintEngine() const;
              virtual void paintEvent(QPaintEvent*  arg__1);
              virtual QPaintDevice*  redirected(QPoint*  offset) const;
              virtual void resizeEvent(QResizeEvent*  arg__1);
              virtual QPainter*  sharedPainter() const;
              virtual void showEvent(QShowEvent*  arg__1);
              virtual QSize  sizeHint() const;
              virtual void tabletEvent(QTabletEvent*  arg__1);
              virtual void timerEvent(QTimerEvent*  arg__1);
              virtual void wheelEvent(QWheelEvent*  arg__1);
                PythonQtInstanceWrapper* _wrapper;
              };
              class PythonQtWrapper_elfInfoWdgt : public QObject
              { Q_OBJECT
              public:
              public slots:
              elfInfoWdgt* new_elfInfoWdgt(QWidget*  parent = 0);
              void delete_elfInfoWdgt(elfInfoWdgt* obj) { delete obj; }
              };
              class PythonQtWrapper_elfparser : public QObject
              { Q_OBJECT
              public:
              public slots:
              elfparser* new_elfparser();
              void delete_elfparser(elfparser* obj) { delete obj; }
                 int  closeFile(elfparser* theWrappedObject);
                 QString  getABI(elfparser* theWrappedObject);
                 QString  getArchitecture(elfparser* theWrappedObject);
                 QString  getClass(elfparser* theWrappedObject);
                 QString  getEndianness(elfparser* theWrappedObject);
                 qint64  getEntryPointAddress(elfparser* theWrappedObject);
                 bool  getSectionData(elfparser* theWrappedObject, int  index, char**  buffer);
                 qint64  getSectionDatasz(elfparser* theWrappedObject, int  index);
                 qint64  getSectionMemsz(elfparser* theWrappedObject, int  index);
                 QString  getSectionName(elfparser* theWrappedObject, int  index);
                 qint64  getSectionPaddr(elfparser* theWrappedObject, int  index);
                 QString  getSectionType(elfparser* theWrappedObject, int  index);
                 int  getSectioncount(elfparser* theWrappedObject);
                 qint64  getSegmentFilesz(elfparser* theWrappedObject, int  index);
                 QString  getSegmentFlags(elfparser* theWrappedObject, int  index);
                 qint64  getSegmentMemsz(elfparser* theWrappedObject, int  index);
                 qint64  getSegmentOffset(elfparser* theWrappedObject, int  index);
                 qint64  getSegmentPaddr(elfparser* theWrappedObject, int  index);
                 QString  getSegmentType(elfparser* theWrappedObject, int  index);
                 qint64  getSegmentVaddr(elfparser* theWrappedObject, int  index);
                 int  getSegmentcount(elfparser* theWrappedObject);
                 QString  getType(elfparser* theWrappedObject);
                 qint64  getVersion(elfparser* theWrappedObject);
                 bool  static_elfparser_isElf(const QString&  File);
                 bool  iself(elfparser* theWrappedObject);
                 bool  isopened(elfparser* theWrappedObject);
                 int  setFilename(elfparser* theWrappedObject, const QString&  name);
              };
+             class PythonQtShell_genericBinaryFileWidget : public genericBinaryFileWidget
+             {
+             public:
+                 PythonQtShell_genericBinaryFileWidget(QWidget*  parent = 0):genericBinaryFileWidget(parent),_wrapper(NULL) {};
+                ~PythonQtShell_genericBinaryFileWidget();
+             virtual void actionEvent(QActionEvent*  arg__1);
+             virtual void changeEvent(QEvent*  arg__1);
+             virtual void childEvent(QChildEvent*  arg__1);
+             virtual void closeEvent(QCloseEvent*  arg__1);
+             virtual void contextMenuEvent(QContextMenuEvent*  arg__1);
+             virtual void customEvent(QEvent*  arg__1);
+             virtual int  devType() const;
+             virtual void dragEnterEvent(QDragEnterEvent*  arg__1);
+             virtual void dragLeaveEvent(QDragLeaveEvent*  arg__1);
+             virtual void dragMoveEvent(QDragMoveEvent*  arg__1);
+             virtual void dropEvent(QDropEvent*  arg__1);
+             virtual void enterEvent(QEvent*  arg__1);
+             virtual bool  event(QEvent*  arg__1);
+             virtual bool  eventFilter(QObject*  arg__1, QEvent*  arg__2);
+             virtual void focusInEvent(QFocusEvent*  arg__1);
+             virtual bool  focusNextPrevChild(bool  next);
+             virtual void focusOutEvent(QFocusEvent*  arg__1);
+             virtual bool  hasHeightForWidth() const;
+             virtual int  heightForWidth(int  arg__1) const;
+             virtual void hideEvent(QHideEvent*  arg__1);
+             virtual void initPainter(QPainter*  painter) const;
+             virtual void inputMethodEvent(QInputMethodEvent*  arg__1);
+             virtual QVariant  inputMethodQuery(Qt::InputMethodQuery  arg__1) const;
+             virtual void keyPressEvent(QKeyEvent*  arg__1);
+             virtual void keyReleaseEvent(QKeyEvent*  arg__1);
+             virtual void leaveEvent(QEvent*  arg__1);
+             virtual int  metric(QPaintDevice::PaintDeviceMetric  arg__1) const;
+             virtual QSize  minimumSizeHint() const;
+             virtual void mouseDoubleClickEvent(QMouseEvent*  arg__1);
+             virtual void mouseMoveEvent(QMouseEvent*  arg__1);
+             virtual void mousePressEvent(QMouseEvent*  arg__1);
+             virtual void mouseReleaseEvent(QMouseEvent*  arg__1);
+             virtual void moveEvent(QMoveEvent*  arg__1);
+             virtual bool  nativeEvent(const QByteArray&  eventType, void*  message, long*  result);
+             virtual QPaintEngine*  paintEngine() const;
+             virtual void paintEvent(QPaintEvent*  arg__1);
+             virtual QPaintDevice*  redirected(QPoint*  offset) const;
+             virtual void resizeEvent(QResizeEvent*  arg__1);
+             virtual QPainter*  sharedPainter() const;
+             virtual void showEvent(QShowEvent*  arg__1);
+             virtual QSize  sizeHint() const;
+             virtual void tabletEvent(QTabletEvent*  arg__1);
+             virtual void timerEvent(QTimerEvent*  arg__1);
+             virtual void wheelEvent(QWheelEvent*  arg__1);
+               PythonQtInstanceWrapper* _wrapper;
+             };
+             class PythonQtWrapper_genericBinaryFileWidget : public QObject
+             { Q_OBJECT
+             public:
+             public slots:
+             genericBinaryFileWidget* new_genericBinaryFileWidget(QWidget*  parent = 0);
+             void delete_genericBinaryFileWidget(genericBinaryFileWidget* obj) { delete obj; }
+             };
              class PythonQtShell_srecFile : public srecFile
              {
              public:
                  PythonQtShell_srecFile():srecFile(),_wrapper(NULL) {};
                  PythonQtShell_srecFile(const QString&  File):srecFile(File),_wrapper(NULL) {};
                  PythonQtShell_srecFile(const QStringList&  Files):srecFile(Files),_wrapper(NULL) {};
                 ~PythonQtShell_srecFile();
              virtual int  closeFile();
              virtual QList<codeFragment* >  getFragments();
              virtual bool  isopened();
              virtual bool  openFile(const QString&  File);
              virtual bool  toBinary(const QString&  File);
              virtual bool  toSrec(const QString&  File);
                PythonQtInstanceWrapper* _wrapper;
              };
              class PythonQtPublicPromoter_srecFile : public srecFile
              { public:
              inline int  promoted_closeFile() { return srecFile::closeFile(); }
              inline QList<codeFragment* >  promoted_getFragments() { return srecFile::getFragments(); }
              inline bool  promoted_isopened() { return srecFile::isopened(); }
              inline bool  promoted_openFile(const QString&  File) { return srecFile::openFile(File); }
              inline bool  promoted_toBinary(const QString&  File) { return srecFile::toBinary(File); }
              inline bool  promoted_toSrec(const QString&  File) { return srecFile::toSrec(File); }
              };
              class PythonQtWrapper_srecFile : public QObject
              { Q_OBJECT
              public:
              public slots:
              srecFile* new_srecFile();
              srecFile* new_srecFile(const QString&  File);
              srecFile* new_srecFile(const QStringList&  Files);
              void delete_srecFile(srecFile* obj) { delete obj; }
+                bool  static_srecFile_checkSum(const QString&  line);
                 int  closeFile(srecFile* theWrappedObject);
                 codeFragment*  getFragment(srecFile* theWrappedObject, int  index);
                 int  getFragmentAddress(srecFile* theWrappedObject, int  index);
                 bool  getFragmentData(srecFile* theWrappedObject, int  index, char**  buffer);
                 QString  getFragmentHeader(srecFile* theWrappedObject, int  index);
                 int  getFragmentSize(srecFile* theWrappedObject, int  index);
                 QList<codeFragment* >  getFragments(srecFile* theWrappedObject);
                 int  getFragmentsCount(srecFile* theWrappedObject);
                 bool  isSREC(srecFile* theWrappedObject);
                 bool  static_srecFile_isSREC(const QString&  File);
                 bool  isopened(srecFile* theWrappedObject);
                 int  lineCount(srecFile* theWrappedObject);
                 bool  mergingRecords(srecFile* theWrappedObject);
                 bool  openFile(srecFile* theWrappedObject, const QString&  File);
                 bool  openFiles(srecFile* theWrappedObject, const QStringList&  Files);
                 void setMergingRecords(srecFile* theWrappedObject, bool  enabled);
                 bool  toBinary(srecFile* theWrappedObject, const QString&  File);
                 bool  static_srecFile_toSrec(QList<codeFragment* >  fragments, const QString&  File);
                 bool  toSrec(srecFile* theWrappedObject, const QString&  File);
              };
              class PythonQtShell_srecFileWidget : public srecFileWidget
              {
              public:
                  PythonQtShell_srecFileWidget(QWidget*  parent = 0):srecFileWidget(parent),_wrapper(NULL) {};
                 ~PythonQtShell_srecFileWidget();
              virtual void reloadFile();
              virtual void setFile(abstractBinFile*  file);
                PythonQtInstanceWrapper* _wrapper;
              };
              class PythonQtPublicPromoter_srecFileWidget : public srecFileWidget
              { public:
              inline void promoted_reloadFile() { srecFileWidget::reloadFile(); }
              inline void promoted_setFile(abstractBinFile*  file) { srecFileWidget::setFile(file); }
              };
              class PythonQtWrapper_srecFileWidget : public QObject
              { Q_OBJECT
              public:
              public slots:
              srecFileWidget* new_srecFileWidget(QWidget*  parent = 0);
              void delete_srecFileWidget(srecFileWidget* obj) { delete obj; }
                 void reloadFile(srecFileWidget* theWrappedObject);
                 void setFile(srecFileWidget* theWrappedObject, abstractBinFile*  file);
              };

src/common/pythonQtOut/generated_cpp/PySocExplorer/PySocExplorer_init.cpp +1 0

              #include <PythonQt.h>
              #include "PySocExplorer0.h"
              void PythonQt_init_PySocExplorer(PyObject* module) {
              PythonQt::priv()->registerClass(&ElfFile::staticMetaObject, "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_ElfFile>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_ElfFile>, module, 0);
              PythonQt::self()->addParentClass("ElfFile", "abstractBinFile",PythonQtUpcastingOffset<ElfFile,abstractBinFile>());
              PythonQt::priv()->registerClass(&MemSizeWdgt::staticMetaObject, "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_MemSizeWdgt>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_MemSizeWdgt>, module, 0);
              PythonQt::priv()->registerClass(&QHexEdit::staticMetaObject, "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_QHexEdit>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_QHexEdit>, module, 0);
              PythonQt::priv()->registerClass(&QHexSpinBox::staticMetaObject, "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_QHexSpinBox>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_QHexSpinBox>, module, 0);
              PythonQt::priv()->registerClass(&SocExplorerPlot::staticMetaObject, "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_SocExplorerPlot>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_SocExplorerPlot>, module, 0);
              PythonQt::priv()->registerClass(&TCP_Terminal_Client::staticMetaObject, "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_TCP_Terminal_Client>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_TCP_Terminal_Client>, module, 0);
              PythonQt::priv()->registerCPPClass("XByteArray", "", "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_XByteArray>, NULL, module, 0);
              PythonQt::priv()->registerClass(&abstractBinFile::staticMetaObject, "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_abstractBinFile>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_abstractBinFile>, module, 0);
              PythonQt::priv()->registerClass(&abstractBinFileWidget::staticMetaObject, "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_abstractBinFileWidget>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_abstractBinFileWidget>, module, 0);
              PythonQt::priv()->registerClass(&binaryFile::staticMetaObject, "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_binaryFile>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_binaryFile>, module, 0);
              PythonQt::self()->addParentClass("binaryFile", "abstractBinFile",PythonQtUpcastingOffset<binaryFile,abstractBinFile>());
              PythonQt::priv()->registerClass(&binaryFileWidget::staticMetaObject, "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_binaryFileWidget>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_binaryFileWidget>, module, 0);
              PythonQt::self()->addParentClass("binaryFileWidget", "abstractBinFileWidget",PythonQtUpcastingOffset<binaryFileWidget,abstractBinFileWidget>());
              PythonQt::priv()->registerCPPClass("codeFragment", "", "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_codeFragment>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_codeFragment>, module, 0);
              PythonQt::priv()->registerClass(&elfFileWidget::staticMetaObject, "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_elfFileWidget>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_elfFileWidget>, module, 0);
              PythonQt::self()->addParentClass("elfFileWidget", "abstractBinFileWidget",PythonQtUpcastingOffset<elfFileWidget,abstractBinFileWidget>());
              PythonQt::priv()->registerClass(&elfInfoWdgt::staticMetaObject, "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_elfInfoWdgt>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_elfInfoWdgt>, module, 0);
              PythonQt::priv()->registerCPPClass("elfparser", "", "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_elfparser>, NULL, module, 0);
+             PythonQt::priv()->registerClass(&genericBinaryFileWidget::staticMetaObject, "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_genericBinaryFileWidget>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_genericBinaryFileWidget>, module, 0);
              PythonQt::priv()->registerClass(&srecFile::staticMetaObject, "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_srecFile>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_srecFile>, module, 0);
              PythonQt::self()->addParentClass("srecFile", "abstractBinFile",PythonQtUpcastingOffset<srecFile,abstractBinFile>());
              PythonQt::priv()->registerClass(&srecFileWidget::staticMetaObject, "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_srecFileWidget>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_srecFileWidget>, module, 0);
              PythonQt::self()->addParentClass("srecFileWidget", "abstractBinFileWidget",PythonQtUpcastingOffset<srecFileWidget,abstractBinFileWidget>());
              }

src/common/pythonQtgeneratorCfg.txt +9 -50

              <typesystem package="PySocExplorer" default-superclass="com.trolltech.qt.QtJambiObject">
                  <load-typesystem name=":/trolltech/generator/typesystem_core.txt" generate="no" />
                  <load-typesystem name=":/trolltech/generator/typesystem_gui.txt" generate="no" />
                  <load-typesystem name=":/trolltech/generator/typesystem_network.txt" generate="no" />
-                 <object-type name="QHexSpinBox">
-                     <extra-includes>
-                       <include file-name="QWidget" location="global"/>
-                       <include file-name="QObject" location="global"/>
-                       <include file-name="QSpinBox" location="global"/>
-                     </extra-includes>
-                 </object-type>
+                 <object-type name="QHexSpinBox"/>
                  <object-type name="MemSizeWdgt" />
                  <object-type name="QHexEdit" />
                  <object-type name="XByteArray" />
                  <object-type name="SocExplorerPlot" />
                  <object-type name="TCP_Terminal_Client" />
                  <object-type name="codeFragment" />
                  <object-type name="srecFile" />
                  <object-type name="binaryFile" />
                  <rejection class="Elf_Section"/>
                  <object-type name="elfparser" />
-                 <interface-type name="abstractBinFile">
-                     <extra-includes>
-                       <include file-name="QWidget" location="global"/>
-                       <include file-name="QObject" location="global"/>
-                     </extra-includes>
-                 </interface-type>
-                 <object-type name="ElfFile">
-                     <extra-includes>
-                       <include file-name="QWidget" location="global"/>
-                       <include file-name="QObject" location="global"/>
-                     </extra-includes>
-                 </object-type>
-                 <interface-type name="abstractBinFileWidget">
-                     <extra-includes>
-                       <include file-name="QWidget" location="global"/>
-                       <include file-name="QObject" location="global"/>
-                     </extra-includes>
-                 </interface-type>
-                 <object-type name="elfFileWidget">
-                     <extra-includes>
-                       <include file-name="QWidget" location="global"/>
-                       <include file-name="QObject" location="global"/>
-                     </extra-includes>
-                 </object-type>
-                 <object-type name="srecFileWidget">
-                   <extra-includes>
-                     <include file-name="QWidget" location="global"/>
-                     <include file-name="QObject" location="global"/>
-                   </extra-includes>
-                 </object-type>
-                 <object-type name="binaryFileWidget">
-                   <extra-includes>
-                     <include file-name="QWidget" location="global"/>
-                     <include file-name="QObject" location="global"/>
-                   </extra-includes>
-                 </object-type>
-                 <object-type name="elfInfoWdgt">
-                     <extra-includes>
-                       <include file-name="QWidget" location="global"/>
-                       <include file-name="QObject" location="global"/>
-                     </extra-includes>
-                 </object-type>
+                 <interface-type name="abstractBinFile"/>
+                 <object-type name="ElfFile"/>
+                 <interface-type name="abstractBinFileWidget"/>
+                 <object-type name="elfFileWidget"/>
+                 <object-type name="srecFileWidget"/>
+                 <object-type name="binaryFileWidget"/>
+                 <object-type name="elfInfoWdgt"/>
+                 <object-type name="genericBinaryFileWidget"/>
              </typesystem>

src/mainwindow.cpp +1 -1

              /*------------------------------------------------------------------------------
              --  This file is a part of the SocExplorer Software
              --  Copyright (C) 2011, Plasma Physics Laboratory - CNRS
              --
              --  This program is free software; you can redistribute it and/or modify
              --  it under the terms of the GNU General Public License as published by
              --  the Free Software Foundation; either version 2 of the License, or
              --  (at your option) any later version.
              --
              --  This program is distributed in the hope that it will be useful,
              --  but WITHOUT ANY WARRANTY; without even the implied warranty of
              --  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
              --  GNU General Public License for more details.
              --
              --  You should have received a copy of the GNU General Public License
              --  along with this program; if not, write to the Free Software
              --  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
              -------------------------------------------------------------------------------*/
              /*--                  Author : Alexis Jeandet
              --                     Mail : alexis.jeandet@lpp.polytechnique.fr
              ----------------------------------------------------------------------------*/
              #include "mainwindow.h"
              #include <QDockWidget>
              SocExplorerMainWindow::SocExplorerMainWindow(QString ScriptToEval, QWidget *parent)
                  : QMainWindow(parent)
              {
                  QCoreApplication::setApplicationName("SocExplorer");
                  QCoreApplication::setOrganizationName("LPP");
                  QCoreApplication::setOrganizationDomain("lpp.fr");
                  this->makeObjects(ScriptToEval);
                  this->makeLayout();
                  this->makeMenu();
                  this->makeConnections();
-                 this->setWindowIcon(QIcon(tr(":/images/logolppcutted.png")));
+                 this->setWindowIcon(QIcon(tr(":/images/icon.png")));
                  this->setAcceptDrops(true);
                  this->pluginManager->setRootLoadable(true);
                  this->PythonConsoleInst->pyConsoleRunFile(ScriptToEval);
                  QFile file(":/styles/SocExplorer.css");
                  if(file.open(QIODevice::ReadOnly | QIODevice::Text))
                  {
                      qApp->setStyleSheet(file.readAll());
                      file.close();
                  }
              }
              void SocExplorerMainWindow::makeObjects(QString ScriptToEval)
              {
                  Q_UNUSED(ScriptToEval)
                  this->p_pluginGUIlist = new QList<QDockWidget*>();
                  pluginsDockContainer = new QMainWindow;
                  pluginsDockContainer->setWindowFlags(Qt::Widget);
                  pluginsDockContainer->setDockNestingEnabled(true);
                  this->mainWidget = new QSplitter(Qt::Vertical);
                  this->appTranslator = new QTranslator;
                  this->Quit = new QAction(tr("&Quit"),this);
                  this->Quit->setShortcut(tr("CTRL+Q"));
                  this->ManagePlugins = new QAction(tr("&Manage Plugins"),this);
                  this->ManagePlugins->setShortcut(tr("CTRL+P"));
                  this->regsManager = new QAction(tr("&Manage registers"),this);
                  this->exploreRegs = new QAction(tr("&Explore registers"),this);
                  this->help = new QAction(tr("&Help"),this);
                  this->help->setShortcut(tr("CTRL+H"));
                  this->about = new QAction(tr("&About"),this);
                  socexplorerproxy::setMainWindow(this);
                  SocExplorerEngine::setMainWindow(this);
                  SocExplorerEngine::xmlModel()->scanXmlFiles();
                  this->regExplorer = new regsExplorer();
                  this->regExplorer->setAllowedAreas(Qt::AllDockWidgetAreas);
                  this->addPluginInterface(this->regExplorer);
                  this->PythonConsoleInst = new PythonConsole(socexplorerproxy::self());
                  this->PythonConsoleInst->addObject("SocExplorerEngine",SocExplorerEngine::self());
                  this->pluginManager = new dockablePluginManager();
                  this->toolpane = new toolBar;
                  this->p_about = new aboutsocexplorer();
              }
              void SocExplorerMainWindow::makeLayout()
              {
                  this->mainWidget->addWidget(pluginsDockContainer);
                  this->mainWidget->addWidget(this->PythonConsoleInst);
                  this->toolpane->setAllowedAreas(Qt::RightDockWidgetArea|Qt::LeftDockWidgetArea);
                  this->addDockWidget(Qt::LeftDockWidgetArea,this->toolpane);
                  this->toolpane->addTool(this->pluginManager);
                  this->setCentralWidget(this->mainWidget);
              }
              void SocExplorerMainWindow::makeConnections()
              {
                  connect(socexplorerproxy::self(),SIGNAL(clearMenu()),this,SLOT(clearMenu()));
                  connect(this,SIGNAL(translateSig()),socexplorerproxy::self(),SLOT(updateText()));
                  connect(socexplorerproxy::self(),SIGNAL(addPluginGUI(QDockWidget*)),this,SLOT(addPluginInterface(QDockWidget*)));
                  connect(socexplorerproxy::self(),SIGNAL(removePluginGUI(QDockWidget*)),this,SLOT(removePluginInterface(QDockWidget*)));
                  connect(this->ManagePlugins,SIGNAL(triggered()),this,SLOT(launchPluginManager()));
                  connect(this->Quit,SIGNAL(triggered()),qApp,SLOT(quit()));
                  connect(this,SIGNAL(registerObject(QObject*,QString)),this->PythonConsoleInst,SLOT(registerObject(QObject*,QString)));
                  connect(socexplorerproxy::self(),SIGNAL(registerObject(QObject*,QString)),this,SIGNAL(registerObject(QObject*,QString)));
                  connect(this->pluginManager,SIGNAL(geteplugintree()),socexplorerproxy::self(),SLOT(geteplugintree()));
                  connect(socexplorerproxy::self(),SIGNAL(treeChanged(QList<socexplorerplugin*>)),this->pluginManager,SIGNAL(treeChanged(QList<socexplorerplugin*>)));
                  connect(this->pluginManager,SIGNAL(changeSysDriverInstName(QString,QString)),socexplorerproxy::self(),SLOT(changeSysDriverInstName(QString,QString)));
                  connect(this->pluginManager,SIGNAL(changeSysDriverInstName(QString,QString)),this->PythonConsoleInst,SLOT(changeSysDriverInstName(QString,QString)));
                  connect(this->pluginManager,SIGNAL(closeSysDriver(QString)),socexplorerproxy::self(),SLOT(closeSysDriver(QString)));
                  connect(this->pluginManager,SIGNAL(closeSysDriver(QString)),this->PythonConsoleInst,SLOT(removeDriver(QString)));
                  connect(this->pluginManager,SIGNAL(pluginselected(QString)),this,SLOT(pluginselected(QString)));
                  connect(this->about,SIGNAL(triggered()),this,SLOT(showAboutBox()));
                  connect(this->exploreRegs,SIGNAL(triggered()),this->regExplorer,SLOT(show()));
                  this->pluginManager->connect(this->pluginManager,SIGNAL(loadSysDrviver(QString)),socexplorerproxy::self(),SLOT(loadSysDriver(QString)));
                  this->pluginManager->connect(this->pluginManager,SIGNAL(loadSysDriverToParent(QString,QString)),socexplorerproxy::self(),SLOT(loadSysDriverToParent(QString,QString)));
              }
              void SocExplorerMainWindow::launchPluginManager()
              {
                  if(this->pluginManager->isHidden())
                  {
                      this->pluginManager->setHidden(false);
                  }
              }
              void SocExplorerMainWindow::addPluginInterface(QDockWidget *plugin)
              {
                  plugin->setAllowedAreas(Qt::AllDockWidgetAreas);
                  this->pluginsDockContainer->addDockWidget(Qt::TopDockWidgetArea,plugin);
                  if(p_pluginGUIlist->count()!=0)
                      this->pluginsDockContainer->tabifyDockWidget(p_pluginGUIlist->last(),plugin);
                  p_pluginGUIlist->append(plugin);
              }
              void SocExplorerMainWindow::removePluginInterface(QDockWidget *plugin)
              {
                  p_pluginGUIlist->removeOne(plugin);
                  this->pluginsDockContainer->removeDockWidget(plugin);
              }
              void SocExplorerMainWindow::clearMenu()
              {
                  this->menuBar()->clear();
                  this->makeMenu();
              }
              void SocExplorerMainWindow::makeMenu()
              {
                  this->FileMenu = menuBar()->addMenu(tr("&File"));
                  this->PluginsMenu = menuBar()->addMenu(tr("&Plugins"));
                  this->ToolsMenu = menuBar()->addMenu(tr("&Tools"));
                  this->ToolsMenu->addAction(this->exploreRegs);
                  this->FileMenu->addAction(this->Quit);
                  socexplorerproxy::self()->makeMenu(this->PluginsMenu);
                  this->PluginsMenu->addAction(this->ManagePlugins);
                  this->helpMenu = menuBar()->addMenu(tr("Help"));
                  this->helpMenu->addAction(this->help);
                  this->helpMenu->addAction(this->about);
              }
              SocExplorerMainWindow::~SocExplorerMainWindow()
              {
              }
              void SocExplorerMainWindow::setLangage(QAction *action)
              {
                  QString local = action->data().toString();
                  QString qmPath = QDir(QString("translations")).absolutePath();
                  appTranslator->load(qmPath+"/socexplorer_"+local+".qm");
                  qApp->installTranslator(appTranslator);
                  emit this->translateSig();
              }
              void SocExplorerMainWindow::createLangMenu()
              {
                  this->langMenu = menuBar()->addMenu(tr("&Langue"));
                  this->langActionGrp = new QActionGroup(this);
                  connect(this->langActionGrp,SIGNAL(triggered(QAction*)),this,SLOT(setLangage(QAction*)));
                  QDir* qmDir = new QDir(QString("translations"));
                  QStringList LangFiles = qmDir->entryList(QStringList("socexplorer_*.qm"));
                  for(int i=0;i<LangFiles.size();++i)
                  {
                      QString Local = LangFiles[i];
                      Local.remove(0,Local.indexOf('_')+1);
                      Local.chop(3);
                      QTranslator translator;
                      translator.load(LangFiles[i],qmDir->absolutePath());
                      QString langage = translator.translate("MainWindow","English");
                      QAction *action = new QAction(tr("&%1 %2").arg(i+1).arg(langage),this);
                      action->setCheckable(true);
                      action->setData(Local);
                      langMenu->addAction(action);
                      langActionGrp->addAction(action);
                      if(langage==tr("English"))
                          action->setChecked(true);
                  }
              }
              void SocExplorerMainWindow::updateText()
              {
                  emit this->translateSig();
              }
              void SocExplorerMainWindow::showAboutBox()
              {
                  p_about->show();
              }
              void SocExplorerMainWindow::pluginselected(const QString &instanceName)
              {
                  socexplorerplugin* drv=socexplorerproxy::self()->getSysDriver(instanceName);
                  if(drv)
                      drv->raise();
              }
              void SocExplorerMainWindow::closeEvent(QCloseEvent *event)
              {
                  socexplorerproxy::self()->close();
                  qApp->closeAllWindows();
                  event->accept();
              }

src/src.pro +1 0

              #-------------------------------------------------
              #
              # Project created by QtCreator 2011-09-19T22:52:10
              #
              #-------------------------------------------------
              SOCEXPLORER_ROOT = $${PWD}/..
              include(../build_cfg/socexplorer.pri)
              TARGET = socexplorer$${DEBUG_EXT}
              TEMPLATE = app
              CONFIG += pythonqt
              QMAKE_LFLAGS_RELEASE += --enable-auto-import -mstackrealign
              QMAKE_LFLAGS_DEBUG += --enable-auto-import -mstackrealign
              include ( common/pythonQtOut/generated_cpp/PySocExplorer/PySocExplorer.pri )
+             include ( SocExplorerEngine/pythonQtOut/generated_cpp/PySocExplorerEngine/PySocExplorerEngine.pri )
              include ( SocExplorerEngine/plugins/socexplorerplugin.prf )
              INCLUDEPATH+=$${PWD} \
                          $${PWD}/common \
                          $${PWD}/common/qhexedit \
                          $${PWD}/common/QCustomPlot \
                          $${PWD}/common/genericBinaryFiles \
                          $${PWD}/common/genericBinaryFiles/elf \
                          $${PWD}/common/genericBinaryFiles/srec \
                          $${PWD}/common/genericBinaryFiles/BinFile \
                          SocExplorerEngine/engine \
                          SocExplorerEngine/pluginloader \
                          SocExplorerEngine/pluginsInterface \
                          SocExplorerEngine/proxy \
                          SocExplorerEngine/pluginManagerWdgt \
                          SocExplorerEngine/plugins \
                          SocExplorerEngine/RegisterMVS \
                          SocExplorerEngine/XmlEngine \
                          SocExplorerEngine/SOC \
                          SocExplorerEngine/PeripheralWidget/src
              win32:INCLUDEPATH+= \
                          $${PWD}/common/genericBinaryFiles/elf/libelfWin32/include \
                          $${PWD}/common/genericBinaryFiles/elf/libelfWin32/include/libelf \
              RC_FILE = ../win32cfg/socexplorer.rc
              unix:LIBS+=-L$${SOCEXPLORER_ROOT}/bin/linux -lsocexplorercommon$${DEBUG_EXT} -L$${SOCEXPLORER_ROOT}/bin/linux -lsocexplorerengine$${DEBUG_EXT}
              win32-g++:LIBS += $${SOCEXPLORER_ROOT}/bin/win32/socexplorercommon$${DEBUG_EXT}.dll $${SOCEXPLORER_ROOT}/bin/win32/socexplorerengine$${DEBUG_EXT}.dll
              unix{
                  translation.files = $${SOCEXPLORER_ROOT}/translations/socexplorer_fr.qm \
                                      $${SOCEXPLORER_ROOT}/translations/socexplorer_en.qm
                  translation.path = $${SOCEXPLORER_TRANSLATION_INSTALL_PATH}
                  target.path    = /usr/bin
                  INSTALLS += translation target
              }
              header.path = $$[QT_INSTALL_HEADERS]/SocExplorer/common
              header.files = \
                          socexplorer.h
              INSTALLS += header
              SOURCES += main.cpp\
                      mainwindow.cpp \
                  PyWdgt/pythonconsole.cpp \
                  PyWdgt/pythonqtscriptingconsoledandd.cpp \
                  dockablepluginmanager.cpp \
                  toolbar.cpp \
                  toolbarcontainer.cpp \
                  regsExplorer/regsexplorer.cpp \
                  regsExplorer/regsviewer.cpp \
                  regsExplorer/regsexplorercfg.cpp \
                  aboutsocexplorer.cpp
              #    regWidget/xmltagtextedit.cpp \
              #    regWidget/xmltaglabeledit.cpp \
              #    regWidget/xmlelementslistwidget.cpp \
              #    regWidget/xmlelementslistview.cpp \
              #    regWidget/regpropeditor.cpp \
              #    regWidget/registerwdgt.cpp \
              #    regWidget/registereditor.cpp \
              #    regWidget/registercel.cpp \
              #    regWidget/periphpropeditor.cpp \
              #    regWidget/peripherialregs.cpp \
              #    regWidget/bitfieldpropeditor.cpp \
              #    regWidget/bitfield.cpp
              HEADERS  += mainwindow.h \
                  PyWdgt/pythonconsole.h \
                  PyWdgt/pythonqtscriptingconsoledandd.h \
                  dockablepluginmanager.h \
                  toolbar.h \
                  toolbarcontainer.h \
                  regsExplorer/regsexplorer.h \
                  regsExplorer/regsviewer.h \
                  regsExplorer/regsexplorercfg.h \
                  socexplorer.h \
                  SocExplorerEngine/plugins/socexplorerplugin.h \
                  aboutsocexplorer.h
              #    regWidget/xmltagtextedit.h \
              #    regWidget/xmltaglabeledit.h \
              #    regWidget/xmlelementslistwidget.h \
              #    regWidget/xmlelementslistview.h \
              #    regWidget/regpropeditor.h \
              #    regWidget/registerwdgt.h \
              #    regWidget/registereditor.h \
              #    regWidget/registercel.h \
              #    regWidget/periphpropeditor.h \
              #    regWidget/peripherialregs.h \
              #    regWidget/bitfieldpropeditor.h \
              #    regWidget/bitfield.h
              include ( NicePyConsole/NicePyConsole.pri)
              win32{
                  RESOURCES = ../ressources/SocExplorer.qrc
              }
              unix{
                  RESOURCES = ../ressources/SocExplorer.qrc
              }
              TRANSLATIONS = ../translations/socexplorer_fr.ts \
                  ../translations/socexplorer_en.ts

unixcfg/SocExplorer.desktop +1 -1

              [Desktop Entry]
              Version=1.0
              Name=SocExplorer
              Type=Application
              GenericName=SocExplorer
              Comment=Software to monitor and explore Soc devices.
              Exec=socexplorer
-             Icon=/etc/SocExplorer/logo-lpp-cutted.png
+             Icon=/usr/share/SocExplorer/Indiana_Jones_cappello.png
              Terminal=false
              Type=Application
              Categories=Application;Programming;
              Name[fr_FR]=SocExplorer

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages