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

             unix{
                 SocExplorer.path = /usr/share/applications/
                 SocExplorer.files = unixcfg/SocExplorer.desktop
-                icon.path = /etc/SocExplorer
+                icon.path = /usr/share/SocExplorer
-                icon.files = ressources/images/logo-lpp-cutted.png
+                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 \

ressources/SocExplorer.qrc +1 0

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

ressources/txt/about.html +4 -1

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

src/PyWdgt/pythonconsole.cpp +2 -1

             #include <socexplorer.h>
             void PythonQt_init_PySocExplorer(PyObject* module);
+            void PythonQt_init_PySocExplorerEngine(PyObject* module) ;
             PythonConsole::PythonConsole(socexplorerproxy *proxy, QWidget *parent) :
                 QWidget(parent)
                 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 *"));
             }

src/SocExplorerEngine/SocExplorerEngine.pro +5 -2

                 pluginsInterface/socexplorerplugininterface.h \
                 pluginsInterface/socexplorerplugininterface_global.h \
                 proxy/socexplorerproxy.h \
-                SOC/socexplorerenumdevice.h
+                SOC/socexplorerenumdevice.h \
+                PySocExplorerEngine.h
             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 "genericBinaryFiles/srec/srecfilewidget.h"
             #include "genericBinaryFiles/BinFile/binaryfile.h"
             #include "genericBinaryFiles/BinFile/binaryfilewidget.h"
+            #include "genericBinaryFiles/genericbinaryfilewidget.h"

src/common/common.pro +3 0

                 ./pythongenerator.sh \
                 ./pythonQtgeneratorCfg.txt
+            RESOURCES += \
+                genericBinaryFiles/genericBinaryFiles.qrc

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

This diff has been collapsed as it changes many lines, (928 lines changed) Show them Hide them
	@@ -3,12 +3,8
	3	#include <PythonQtMethodInfo.h>	3	#include <PythonQtMethodInfo.h>
	4	#include <PythonQtSignalReceiver.h>	4	#include <PythonQtSignalReceiver.h>
	5	#include <QIconEngine>	5	#include <QIconEngine>
	6	#include <QObject>
	7	#include <QSpinBox>
	8	#include <QVariant>	6	#include <QVariant>
	9	#include <QWidget>
	10	#include <abstractbinfile.h>	7	#include <abstractbinfile.h>
	11	#include <elffile.h>
	12	#include <elfparser.h>	8	#include <elfparser.h>
	13	#include <qaction.h>	9	#include <qaction.h>
	14	#include <qbitmap.h>	10	#include <qbitmap.h>
	@@ -6391,7 +6387,7 if (_wrapper) {
	6391	return;	6387	return;
	6392	}	6388	}
	6393	}	6389	}
	6394		6390	elfFileWidget::setFile(file);
	6395	}	6391	}
	6396	elfFileWidget* PythonQtWrapper_elfFileWidget::new_elfFileWidget(QWidget* parent)	6392	elfFileWidget* PythonQtWrapper_elfFileWidget::new_elfFileWidget(QWidget* parent)
	6397	{	6393	{
	@@ -6402,6 +6398,11 void PythonQtWrapper_elfFileWidget::relo
	6402	( ((PythonQtPublicPromoter_elfFileWidget*)theWrappedObject)->promoted_reloadFile());	6398	( ((PythonQtPublicPromoter_elfFileWidget*)theWrappedObject)->promoted_reloadFile());
	6403	}	6399	}
	6404		6400
			6401	void PythonQtWrapper_elfFileWidget::setFile(elfFileWidget* theWrappedObject, abstractBinFile* file)
			6402	{
			6403	( ((PythonQtPublicPromoter_elfFileWidget*)theWrappedObject)->promoted_setFile(file));
			6404	}
			6405
	6405		6406
	6406		6407
	6407	PythonQtShell_elfInfoWdgt::~PythonQtShell_elfInfoWdgt() {	6408	PythonQtShell_elfInfoWdgt::~PythonQtShell_elfInfoWdgt() {
	@@ -7457,6 +7458,918 int PythonQtWrapper_elfparser::setFilen
	7457		7458
	7458		7459
	7459		7460
			7461	PythonQtShell_genericBinaryFileWidget::~PythonQtShell_genericBinaryFileWidget() {
			7462	PythonQtPrivate* priv = PythonQt::priv();
			7463	if (priv) { priv->shellClassDeleted(this); }
			7464	}
			7465	void PythonQtShell_genericBinaryFileWidget::actionEvent(QActionEvent* arg__1)
			7466	{
			7467	if (_wrapper) {
			7468	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "actionEvent");
			7469	PyErr_Clear();
			7470	if (obj && !PythonQtSlotFunction_Check(obj)) {
			7471	static const char* argumentList[] ={"" , "QActionEvent*"};
			7472	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			7473	void* args[2] = {NULL, (void*)&arg__1};
			7474	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			7475	if (result) { Py_DECREF(result); }
			7476	Py_DECREF(obj);
			7477	return;
			7478	}
			7479	}
			7480	genericBinaryFileWidget::actionEvent(arg__1);
			7481	}
			7482	void PythonQtShell_genericBinaryFileWidget::changeEvent(QEvent* arg__1)
			7483	{
			7484	if (_wrapper) {
			7485	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "changeEvent");
			7486	PyErr_Clear();
			7487	if (obj && !PythonQtSlotFunction_Check(obj)) {
			7488	static const char* argumentList[] ={"" , "QEvent*"};
			7489	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			7490	void* args[2] = {NULL, (void*)&arg__1};
			7491	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			7492	if (result) { Py_DECREF(result); }
			7493	Py_DECREF(obj);
			7494	return;
			7495	}
			7496	}
			7497	genericBinaryFileWidget::changeEvent(arg__1);
			7498	}
			7499	void PythonQtShell_genericBinaryFileWidget::childEvent(QChildEvent* arg__1)
			7500	{
			7501	if (_wrapper) {
			7502	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "childEvent");
			7503	PyErr_Clear();
			7504	if (obj && !PythonQtSlotFunction_Check(obj)) {
			7505	static const char* argumentList[] ={"" , "QChildEvent*"};
			7506	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			7507	void* args[2] = {NULL, (void*)&arg__1};
			7508	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			7509	if (result) { Py_DECREF(result); }
			7510	Py_DECREF(obj);
			7511	return;
			7512	}
			7513	}
			7514	genericBinaryFileWidget::childEvent(arg__1);
			7515	}
			7516	void PythonQtShell_genericBinaryFileWidget::closeEvent(QCloseEvent* arg__1)
			7517	{
			7518	if (_wrapper) {
			7519	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "closeEvent");
			7520	PyErr_Clear();
			7521	if (obj && !PythonQtSlotFunction_Check(obj)) {
			7522	static const char* argumentList[] ={"" , "QCloseEvent*"};
			7523	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			7524	void* args[2] = {NULL, (void*)&arg__1};
			7525	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			7526	if (result) { Py_DECREF(result); }
			7527	Py_DECREF(obj);
			7528	return;
			7529	}
			7530	}
			7531	genericBinaryFileWidget::closeEvent(arg__1);
			7532	}
			7533	void PythonQtShell_genericBinaryFileWidget::contextMenuEvent(QContextMenuEvent* arg__1)
			7534	{
			7535	if (_wrapper) {
			7536	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "contextMenuEvent");
			7537	PyErr_Clear();
			7538	if (obj && !PythonQtSlotFunction_Check(obj)) {
			7539	static const char* argumentList[] ={"" , "QContextMenuEvent*"};
			7540	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			7541	void* args[2] = {NULL, (void*)&arg__1};
			7542	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			7543	if (result) { Py_DECREF(result); }
			7544	Py_DECREF(obj);
			7545	return;
			7546	}
			7547	}
			7548	genericBinaryFileWidget::contextMenuEvent(arg__1);
			7549	}
			7550	void PythonQtShell_genericBinaryFileWidget::customEvent(QEvent* arg__1)
			7551	{
			7552	if (_wrapper) {
			7553	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "customEvent");
			7554	PyErr_Clear();
			7555	if (obj && !PythonQtSlotFunction_Check(obj)) {
			7556	static const char* argumentList[] ={"" , "QEvent*"};
			7557	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			7558	void* args[2] = {NULL, (void*)&arg__1};
			7559	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			7560	if (result) { Py_DECREF(result); }
			7561	Py_DECREF(obj);
			7562	return;
			7563	}
			7564	}
			7565	genericBinaryFileWidget::customEvent(arg__1);
			7566	}
			7567	int PythonQtShell_genericBinaryFileWidget::devType() const
			7568	{
			7569	if (_wrapper) {
			7570	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "devType");
			7571	PyErr_Clear();
			7572	if (obj && !PythonQtSlotFunction_Check(obj)) {
			7573	static const char* argumentList[] ={"int"};
			7574	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
			7575	int returnValue;
			7576	void* args[1] = {NULL};
			7577	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			7578	if (result) {
			7579	args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
			7580	if (args[0]!=&returnValue) {
			7581	if (args[0]==NULL) {
			7582	PythonQt::priv()->handleVirtualOverloadReturnError("devType", methodInfo, result);
			7583	} else {
			7584	returnValue = ((int)args[0]);
			7585	}
			7586	}
			7587	}
			7588	if (result) { Py_DECREF(result); }
			7589	Py_DECREF(obj);
			7590	return returnValue;
			7591	}
			7592	}
			7593	return genericBinaryFileWidget::devType();
			7594	}
			7595	void PythonQtShell_genericBinaryFileWidget::dragEnterEvent(QDragEnterEvent* arg__1)
			7596	{
			7597	if (_wrapper) {
			7598	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragEnterEvent");
			7599	PyErr_Clear();
			7600	if (obj && !PythonQtSlotFunction_Check(obj)) {
			7601	static const char* argumentList[] ={"" , "QDragEnterEvent*"};
			7602	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			7603	void* args[2] = {NULL, (void*)&arg__1};
			7604	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			7605	if (result) { Py_DECREF(result); }
			7606	Py_DECREF(obj);
			7607	return;
			7608	}
			7609	}
			7610	genericBinaryFileWidget::dragEnterEvent(arg__1);
			7611	}
			7612	void PythonQtShell_genericBinaryFileWidget::dragLeaveEvent(QDragLeaveEvent* arg__1)
			7613	{
			7614	if (_wrapper) {
			7615	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragLeaveEvent");
			7616	PyErr_Clear();
			7617	if (obj && !PythonQtSlotFunction_Check(obj)) {
			7618	static const char* argumentList[] ={"" , "QDragLeaveEvent*"};
			7619	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			7620	void* args[2] = {NULL, (void*)&arg__1};
			7621	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			7622	if (result) { Py_DECREF(result); }
			7623	Py_DECREF(obj);
			7624	return;
			7625	}
			7626	}
			7627	genericBinaryFileWidget::dragLeaveEvent(arg__1);
			7628	}
			7629	void PythonQtShell_genericBinaryFileWidget::dragMoveEvent(QDragMoveEvent* arg__1)
			7630	{
			7631	if (_wrapper) {
			7632	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragMoveEvent");
			7633	PyErr_Clear();
			7634	if (obj && !PythonQtSlotFunction_Check(obj)) {
			7635	static const char* argumentList[] ={"" , "QDragMoveEvent*"};
			7636	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			7637	void* args[2] = {NULL, (void*)&arg__1};
			7638	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			7639	if (result) { Py_DECREF(result); }
			7640	Py_DECREF(obj);
			7641	return;
			7642	}
			7643	}
			7644	genericBinaryFileWidget::dragMoveEvent(arg__1);
			7645	}
			7646	void PythonQtShell_genericBinaryFileWidget::dropEvent(QDropEvent* arg__1)
			7647	{
			7648	if (_wrapper) {
			7649	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dropEvent");
			7650	PyErr_Clear();
			7651	if (obj && !PythonQtSlotFunction_Check(obj)) {
			7652	static const char* argumentList[] ={"" , "QDropEvent*"};
			7653	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			7654	void* args[2] = {NULL, (void*)&arg__1};
			7655	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			7656	if (result) { Py_DECREF(result); }
			7657	Py_DECREF(obj);
			7658	return;
			7659	}
			7660	}
			7661	genericBinaryFileWidget::dropEvent(arg__1);
			7662	}
			7663	void PythonQtShell_genericBinaryFileWidget::enterEvent(QEvent* arg__1)
			7664	{
			7665	if (_wrapper) {
			7666	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "enterEvent");
			7667	PyErr_Clear();
			7668	if (obj && !PythonQtSlotFunction_Check(obj)) {
			7669	static const char* argumentList[] ={"" , "QEvent*"};
			7670	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			7671	void* args[2] = {NULL, (void*)&arg__1};
			7672	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			7673	if (result) { Py_DECREF(result); }
			7674	Py_DECREF(obj);
			7675	return;
			7676	}
			7677	}
			7678	genericBinaryFileWidget::enterEvent(arg__1);
			7679	}
			7680	bool PythonQtShell_genericBinaryFileWidget::event(QEvent* arg__1)
			7681	{
			7682	if (_wrapper) {
			7683	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "event");
			7684	PyErr_Clear();
			7685	if (obj && !PythonQtSlotFunction_Check(obj)) {
			7686	static const char* argumentList[] ={"bool" , "QEvent*"};
			7687	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			7688	bool returnValue;
			7689	void* args[2] = {NULL, (void*)&arg__1};
			7690	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			7691	if (result) {
			7692	args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
			7693	if (args[0]!=&returnValue) {
			7694	if (args[0]==NULL) {
			7695	PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
			7696	} else {
			7697	returnValue = ((bool)args[0]);
			7698	}
			7699	}
			7700	}
			7701	if (result) { Py_DECREF(result); }
			7702	Py_DECREF(obj);
			7703	return returnValue;
			7704	}
			7705	}
			7706	return genericBinaryFileWidget::event(arg__1);
			7707	}
			7708	bool PythonQtShell_genericBinaryFileWidget::eventFilter(QObject* arg__1, QEvent* arg__2)
			7709	{
			7710	if (_wrapper) {
			7711	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "eventFilter");
			7712	PyErr_Clear();
			7713	if (obj && !PythonQtSlotFunction_Check(obj)) {
			7714	static const char* argumentList[] ={"bool" , "QObject" , "QEvent"};
			7715	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
			7716	bool returnValue;
			7717	void* args[3] = {NULL, (void)&arg__1, (void)&arg__2};
			7718	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			7719	if (result) {
			7720	args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
			7721	if (args[0]!=&returnValue) {
			7722	if (args[0]==NULL) {
			7723	PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
			7724	} else {
			7725	returnValue = ((bool)args[0]);
			7726	}
			7727	}
			7728	}
			7729	if (result) { Py_DECREF(result); }
			7730	Py_DECREF(obj);
			7731	return returnValue;
			7732	}
			7733	}
			7734	return genericBinaryFileWidget::eventFilter(arg__1, arg__2);
			7735	}
			7736	void PythonQtShell_genericBinaryFileWidget::focusInEvent(QFocusEvent* arg__1)
			7737	{
			7738	if (_wrapper) {
			7739	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusInEvent");
			7740	PyErr_Clear();
			7741	if (obj && !PythonQtSlotFunction_Check(obj)) {
			7742	static const char* argumentList[] ={"" , "QFocusEvent*"};
			7743	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			7744	void* args[2] = {NULL, (void*)&arg__1};
			7745	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			7746	if (result) { Py_DECREF(result); }
			7747	Py_DECREF(obj);
			7748	return;
			7749	}
			7750	}
			7751	genericBinaryFileWidget::focusInEvent(arg__1);
			7752	}
			7753	bool PythonQtShell_genericBinaryFileWidget::focusNextPrevChild(bool next)
			7754	{
			7755	if (_wrapper) {
			7756	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusNextPrevChild");
			7757	PyErr_Clear();
			7758	if (obj && !PythonQtSlotFunction_Check(obj)) {
			7759	static const char* argumentList[] ={"bool" , "bool"};
			7760	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			7761	bool returnValue;
			7762	void* args[2] = {NULL, (void*)&next};
			7763	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			7764	if (result) {
			7765	args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
			7766	if (args[0]!=&returnValue) {
			7767	if (args[0]==NULL) {
			7768	PythonQt::priv()->handleVirtualOverloadReturnError("focusNextPrevChild", methodInfo, result);
			7769	} else {
			7770	returnValue = ((bool)args[0]);
			7771	}
			7772	}
			7773	}
			7774	if (result) { Py_DECREF(result); }
			7775	Py_DECREF(obj);
			7776	return returnValue;
			7777	}
			7778	}
			7779	return genericBinaryFileWidget::focusNextPrevChild(next);
			7780	}
			7781	void PythonQtShell_genericBinaryFileWidget::focusOutEvent(QFocusEvent* arg__1)
			7782	{
			7783	if (_wrapper) {
			7784	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusOutEvent");
			7785	PyErr_Clear();
			7786	if (obj && !PythonQtSlotFunction_Check(obj)) {
			7787	static const char* argumentList[] ={"" , "QFocusEvent*"};
			7788	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			7789	void* args[2] = {NULL, (void*)&arg__1};
			7790	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			7791	if (result) { Py_DECREF(result); }
			7792	Py_DECREF(obj);
			7793	return;
			7794	}
			7795	}
			7796	genericBinaryFileWidget::focusOutEvent(arg__1);
			7797	}
			7798	bool PythonQtShell_genericBinaryFileWidget::hasHeightForWidth() const
			7799	{
			7800	if (_wrapper) {
			7801	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hasHeightForWidth");
			7802	PyErr_Clear();
			7803	if (obj && !PythonQtSlotFunction_Check(obj)) {
			7804	static const char* argumentList[] ={"bool"};
			7805	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
			7806	bool returnValue;
			7807	void* args[1] = {NULL};
			7808	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			7809	if (result) {
			7810	args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
			7811	if (args[0]!=&returnValue) {
			7812	if (args[0]==NULL) {
			7813	PythonQt::priv()->handleVirtualOverloadReturnError("hasHeightForWidth", methodInfo, result);
			7814	} else {
			7815	returnValue = ((bool)args[0]);
			7816	}
			7817	}
			7818	}
			7819	if (result) { Py_DECREF(result); }
			7820	Py_DECREF(obj);
			7821	return returnValue;
			7822	}
			7823	}
			7824	return genericBinaryFileWidget::hasHeightForWidth();
			7825	}
			7826	int PythonQtShell_genericBinaryFileWidget::heightForWidth(int arg__1) const
			7827	{
			7828	if (_wrapper) {
			7829	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "heightForWidth");
			7830	PyErr_Clear();
			7831	if (obj && !PythonQtSlotFunction_Check(obj)) {
			7832	static const char* argumentList[] ={"int" , "int"};
			7833	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			7834	int returnValue;
			7835	void* args[2] = {NULL, (void*)&arg__1};
			7836	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			7837	if (result) {
			7838	args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
			7839	if (args[0]!=&returnValue) {
			7840	if (args[0]==NULL) {
			7841	PythonQt::priv()->handleVirtualOverloadReturnError("heightForWidth", methodInfo, result);
			7842	} else {
			7843	returnValue = ((int)args[0]);
			7844	}
			7845	}
			7846	}
			7847	if (result) { Py_DECREF(result); }
			7848	Py_DECREF(obj);
			7849	return returnValue;
			7850	}
			7851	}
			7852	return genericBinaryFileWidget::heightForWidth(arg__1);
			7853	}
			7854	void PythonQtShell_genericBinaryFileWidget::hideEvent(QHideEvent* arg__1)
			7855	{
			7856	if (_wrapper) {
			7857	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hideEvent");
			7858	PyErr_Clear();
			7859	if (obj && !PythonQtSlotFunction_Check(obj)) {
			7860	static const char* argumentList[] ={"" , "QHideEvent*"};
			7861	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			7862	void* args[2] = {NULL, (void*)&arg__1};
			7863	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			7864	if (result) { Py_DECREF(result); }
			7865	Py_DECREF(obj);
			7866	return;
			7867	}
			7868	}
			7869	genericBinaryFileWidget::hideEvent(arg__1);
			7870	}
			7871	void PythonQtShell_genericBinaryFileWidget::initPainter(QPainter* painter) const
			7872	{
			7873	if (_wrapper) {
			7874	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "initPainter");
			7875	PyErr_Clear();
			7876	if (obj && !PythonQtSlotFunction_Check(obj)) {
			7877	static const char* argumentList[] ={"" , "QPainter*"};
			7878	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			7879	void* args[2] = {NULL, (void*)&painter};
			7880	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			7881	if (result) { Py_DECREF(result); }
			7882	Py_DECREF(obj);
			7883	return;
			7884	}
			7885	}
			7886	genericBinaryFileWidget::initPainter(painter);
			7887	}
			7888	void PythonQtShell_genericBinaryFileWidget::inputMethodEvent(QInputMethodEvent* arg__1)
			7889	{
			7890	if (_wrapper) {
			7891	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodEvent");
			7892	PyErr_Clear();
			7893	if (obj && !PythonQtSlotFunction_Check(obj)) {
			7894	static const char* argumentList[] ={"" , "QInputMethodEvent*"};
			7895	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			7896	void* args[2] = {NULL, (void*)&arg__1};
			7897	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			7898	if (result) { Py_DECREF(result); }
			7899	Py_DECREF(obj);
			7900	return;
			7901	}
			7902	}
			7903	genericBinaryFileWidget::inputMethodEvent(arg__1);
			7904	}
			7905	QVariant PythonQtShell_genericBinaryFileWidget::inputMethodQuery(Qt::InputMethodQuery arg__1) const
			7906	{
			7907	if (_wrapper) {
			7908	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodQuery");
			7909	PyErr_Clear();
			7910	if (obj && !PythonQtSlotFunction_Check(obj)) {
			7911	static const char* argumentList[] ={"QVariant" , "Qt::InputMethodQuery"};
			7912	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			7913	QVariant returnValue;
			7914	void* args[2] = {NULL, (void*)&arg__1};
			7915	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			7916	if (result) {
			7917	args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
			7918	if (args[0]!=&returnValue) {
			7919	if (args[0]==NULL) {
			7920	PythonQt::priv()->handleVirtualOverloadReturnError("inputMethodQuery", methodInfo, result);
			7921	} else {
			7922	returnValue = ((QVariant)args[0]);
			7923	}
			7924	}
			7925	}
			7926	if (result) { Py_DECREF(result); }
			7927	Py_DECREF(obj);
			7928	return returnValue;
			7929	}
			7930	}
			7931	return genericBinaryFileWidget::inputMethodQuery(arg__1);
			7932	}
			7933	void PythonQtShell_genericBinaryFileWidget::keyPressEvent(QKeyEvent* arg__1)
			7934	{
			7935	if (_wrapper) {
			7936	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyPressEvent");
			7937	PyErr_Clear();
			7938	if (obj && !PythonQtSlotFunction_Check(obj)) {
			7939	static const char* argumentList[] ={"" , "QKeyEvent*"};
			7940	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			7941	void* args[2] = {NULL, (void*)&arg__1};
			7942	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			7943	if (result) { Py_DECREF(result); }
			7944	Py_DECREF(obj);
			7945	return;
			7946	}
			7947	}
			7948	genericBinaryFileWidget::keyPressEvent(arg__1);
			7949	}
			7950	void PythonQtShell_genericBinaryFileWidget::keyReleaseEvent(QKeyEvent* arg__1)
			7951	{
			7952	if (_wrapper) {
			7953	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyReleaseEvent");
			7954	PyErr_Clear();
			7955	if (obj && !PythonQtSlotFunction_Check(obj)) {
			7956	static const char* argumentList[] ={"" , "QKeyEvent*"};
			7957	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			7958	void* args[2] = {NULL, (void*)&arg__1};
			7959	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			7960	if (result) { Py_DECREF(result); }
			7961	Py_DECREF(obj);
			7962	return;
			7963	}
			7964	}
			7965	genericBinaryFileWidget::keyReleaseEvent(arg__1);
			7966	}
			7967	void PythonQtShell_genericBinaryFileWidget::leaveEvent(QEvent* arg__1)
			7968	{
			7969	if (_wrapper) {
			7970	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "leaveEvent");
			7971	PyErr_Clear();
			7972	if (obj && !PythonQtSlotFunction_Check(obj)) {
			7973	static const char* argumentList[] ={"" , "QEvent*"};
			7974	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			7975	void* args[2] = {NULL, (void*)&arg__1};
			7976	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			7977	if (result) { Py_DECREF(result); }
			7978	Py_DECREF(obj);
			7979	return;
			7980	}
			7981	}
			7982	genericBinaryFileWidget::leaveEvent(arg__1);
			7983	}
			7984	int PythonQtShell_genericBinaryFileWidget::metric(QPaintDevice::PaintDeviceMetric arg__1) const
			7985	{
			7986	if (_wrapper) {
			7987	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "metric");
			7988	PyErr_Clear();
			7989	if (obj && !PythonQtSlotFunction_Check(obj)) {
			7990	static const char* argumentList[] ={"int" , "QPaintDevice::PaintDeviceMetric"};
			7991	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			7992	int returnValue;
			7993	void* args[2] = {NULL, (void*)&arg__1};
			7994	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			7995	if (result) {
			7996	args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
			7997	if (args[0]!=&returnValue) {
			7998	if (args[0]==NULL) {
			7999	PythonQt::priv()->handleVirtualOverloadReturnError("metric", methodInfo, result);
			8000	} else {
			8001	returnValue = ((int)args[0]);
			8002	}
			8003	}
			8004	}
			8005	if (result) { Py_DECREF(result); }
			8006	Py_DECREF(obj);
			8007	return returnValue;
			8008	}
			8009	}
			8010	return genericBinaryFileWidget::metric(arg__1);
			8011	}
			8012	QSize PythonQtShell_genericBinaryFileWidget::minimumSizeHint() const
			8013	{
			8014	if (_wrapper) {
			8015	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getMinimumSizeHint");
			8016	PyErr_Clear();
			8017	if (obj && !PythonQtSlotFunction_Check(obj)) {
			8018	static const char* argumentList[] ={"QSize"};
			8019	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
			8020	QSize returnValue;
			8021	void* args[1] = {NULL};
			8022	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			8023	if (result) {
			8024	args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
			8025	if (args[0]!=&returnValue) {
			8026	if (args[0]==NULL) {
			8027	PythonQt::priv()->handleVirtualOverloadReturnError("getMinimumSizeHint", methodInfo, result);
			8028	} else {
			8029	returnValue = ((QSize)args[0]);
			8030	}
			8031	}
			8032	}
			8033	if (result) { Py_DECREF(result); }
			8034	Py_DECREF(obj);
			8035	return returnValue;
			8036	}
			8037	}
			8038	return genericBinaryFileWidget::minimumSizeHint();
			8039	}
			8040	void PythonQtShell_genericBinaryFileWidget::mouseDoubleClickEvent(QMouseEvent* arg__1)
			8041	{
			8042	if (_wrapper) {
			8043	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseDoubleClickEvent");
			8044	PyErr_Clear();
			8045	if (obj && !PythonQtSlotFunction_Check(obj)) {
			8046	static const char* argumentList[] ={"" , "QMouseEvent*"};
			8047	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			8048	void* args[2] = {NULL, (void*)&arg__1};
			8049	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			8050	if (result) { Py_DECREF(result); }
			8051	Py_DECREF(obj);
			8052	return;
			8053	}
			8054	}
			8055	genericBinaryFileWidget::mouseDoubleClickEvent(arg__1);
			8056	}
			8057	void PythonQtShell_genericBinaryFileWidget::mouseMoveEvent(QMouseEvent* arg__1)
			8058	{
			8059	if (_wrapper) {
			8060	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseMoveEvent");
			8061	PyErr_Clear();
			8062	if (obj && !PythonQtSlotFunction_Check(obj)) {
			8063	static const char* argumentList[] ={"" , "QMouseEvent*"};
			8064	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			8065	void* args[2] = {NULL, (void*)&arg__1};
			8066	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			8067	if (result) { Py_DECREF(result); }
			8068	Py_DECREF(obj);
			8069	return;
			8070	}
			8071	}
			8072	genericBinaryFileWidget::mouseMoveEvent(arg__1);
			8073	}
			8074	void PythonQtShell_genericBinaryFileWidget::mousePressEvent(QMouseEvent* arg__1)
			8075	{
			8076	if (_wrapper) {
			8077	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mousePressEvent");
			8078	PyErr_Clear();
			8079	if (obj && !PythonQtSlotFunction_Check(obj)) {
			8080	static const char* argumentList[] ={"" , "QMouseEvent*"};
			8081	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			8082	void* args[2] = {NULL, (void*)&arg__1};
			8083	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			8084	if (result) { Py_DECREF(result); }
			8085	Py_DECREF(obj);
			8086	return;
			8087	}
			8088	}
			8089	genericBinaryFileWidget::mousePressEvent(arg__1);
			8090	}
			8091	void PythonQtShell_genericBinaryFileWidget::mouseReleaseEvent(QMouseEvent* arg__1)
			8092	{
			8093	if (_wrapper) {
			8094	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseReleaseEvent");
			8095	PyErr_Clear();
			8096	if (obj && !PythonQtSlotFunction_Check(obj)) {
			8097	static const char* argumentList[] ={"" , "QMouseEvent*"};
			8098	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			8099	void* args[2] = {NULL, (void*)&arg__1};
			8100	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			8101	if (result) { Py_DECREF(result); }
			8102	Py_DECREF(obj);
			8103	return;
			8104	}
			8105	}
			8106	genericBinaryFileWidget::mouseReleaseEvent(arg__1);
			8107	}
			8108	void PythonQtShell_genericBinaryFileWidget::moveEvent(QMoveEvent* arg__1)
			8109	{
			8110	if (_wrapper) {
			8111	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "moveEvent");
			8112	PyErr_Clear();
			8113	if (obj && !PythonQtSlotFunction_Check(obj)) {
			8114	static const char* argumentList[] ={"" , "QMoveEvent*"};
			8115	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			8116	void* args[2] = {NULL, (void*)&arg__1};
			8117	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			8118	if (result) { Py_DECREF(result); }
			8119	Py_DECREF(obj);
			8120	return;
			8121	}
			8122	}
			8123	genericBinaryFileWidget::moveEvent(arg__1);
			8124	}
			8125	bool PythonQtShell_genericBinaryFileWidget::nativeEvent(const QByteArray& eventType, void* message, long* result)
			8126	{
			8127	if (_wrapper) {
			8128	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "nativeEvent");
			8129	PyErr_Clear();
			8130	if (obj && !PythonQtSlotFunction_Check(obj)) {
			8131	static const char* argumentList[] ={"bool" , "const QByteArray&" , "void" , "long"};
			8132	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
			8133	bool returnValue;
			8134	void* args[4] = {NULL, (void)&eventType, (void)&message, (void*)&result};
			8135	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			8136	if (result) {
			8137	args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
			8138	if (args[0]!=&returnValue) {
			8139	if (args[0]==NULL) {
			8140	PythonQt::priv()->handleVirtualOverloadReturnError("nativeEvent", methodInfo, result);
			8141	} else {
			8142	returnValue = ((bool)args[0]);
			8143	}
			8144	}
			8145	}
			8146	if (result) { Py_DECREF(result); }
			8147	Py_DECREF(obj);
			8148	return returnValue;
			8149	}
			8150	}
			8151	return genericBinaryFileWidget::nativeEvent(eventType, message, result);
			8152	}
			8153	QPaintEngine* PythonQtShell_genericBinaryFileWidget::paintEngine() const
			8154	{
			8155	if (_wrapper) {
			8156	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEngine");
			8157	PyErr_Clear();
			8158	if (obj && !PythonQtSlotFunction_Check(obj)) {
			8159	static const char* argumentList[] ={"QPaintEngine*"};
			8160	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
			8161	QPaintEngine* returnValue;
			8162	void* args[1] = {NULL};
			8163	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			8164	if (result) {
			8165	args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
			8166	if (args[0]!=&returnValue) {
			8167	if (args[0]==NULL) {
			8168	PythonQt::priv()->handleVirtualOverloadReturnError("paintEngine", methodInfo, result);
			8169	} else {
			8170	returnValue = ((QPaintEngine*)args[0]);
			8171	}
			8172	}
			8173	}
			8174	if (result) { Py_DECREF(result); }
			8175	Py_DECREF(obj);
			8176	return returnValue;
			8177	}
			8178	}
			8179	return genericBinaryFileWidget::paintEngine();
			8180	}
			8181	void PythonQtShell_genericBinaryFileWidget::paintEvent(QPaintEvent* arg__1)
			8182	{
			8183	if (_wrapper) {
			8184	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEvent");
			8185	PyErr_Clear();
			8186	if (obj && !PythonQtSlotFunction_Check(obj)) {
			8187	static const char* argumentList[] ={"" , "QPaintEvent*"};
			8188	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			8189	void* args[2] = {NULL, (void*)&arg__1};
			8190	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			8191	if (result) { Py_DECREF(result); }
			8192	Py_DECREF(obj);
			8193	return;
			8194	}
			8195	}
			8196	genericBinaryFileWidget::paintEvent(arg__1);
			8197	}
			8198	QPaintDevice* PythonQtShell_genericBinaryFileWidget::redirected(QPoint* offset) const
			8199	{
			8200	if (_wrapper) {
			8201	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "redirected");
			8202	PyErr_Clear();
			8203	if (obj && !PythonQtSlotFunction_Check(obj)) {
			8204	static const char* argumentList[] ={"QPaintDevice" , "QPoint"};
			8205	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			8206	QPaintDevice* returnValue;
			8207	void* args[2] = {NULL, (void*)&offset};
			8208	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			8209	if (result) {
			8210	args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
			8211	if (args[0]!=&returnValue) {
			8212	if (args[0]==NULL) {
			8213	PythonQt::priv()->handleVirtualOverloadReturnError("redirected", methodInfo, result);
			8214	} else {
			8215	returnValue = ((QPaintDevice*)args[0]);
			8216	}
			8217	}
			8218	}
			8219	if (result) { Py_DECREF(result); }
			8220	Py_DECREF(obj);
			8221	return returnValue;
			8222	}
			8223	}
			8224	return genericBinaryFileWidget::redirected(offset);
			8225	}
			8226	void PythonQtShell_genericBinaryFileWidget::resizeEvent(QResizeEvent* arg__1)
			8227	{
			8228	if (_wrapper) {
			8229	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "resizeEvent");
			8230	PyErr_Clear();
			8231	if (obj && !PythonQtSlotFunction_Check(obj)) {
			8232	static const char* argumentList[] ={"" , "QResizeEvent*"};
			8233	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			8234	void* args[2] = {NULL, (void*)&arg__1};
			8235	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			8236	if (result) { Py_DECREF(result); }
			8237	Py_DECREF(obj);
			8238	return;
			8239	}
			8240	}
			8241	genericBinaryFileWidget::resizeEvent(arg__1);
			8242	}
			8243	QPainter* PythonQtShell_genericBinaryFileWidget::sharedPainter() const
			8244	{
			8245	if (_wrapper) {
			8246	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "sharedPainter");
			8247	PyErr_Clear();
			8248	if (obj && !PythonQtSlotFunction_Check(obj)) {
			8249	static const char* argumentList[] ={"QPainter*"};
			8250	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
			8251	QPainter* returnValue;
			8252	void* args[1] = {NULL};
			8253	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			8254	if (result) {
			8255	args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
			8256	if (args[0]!=&returnValue) {
			8257	if (args[0]==NULL) {
			8258	PythonQt::priv()->handleVirtualOverloadReturnError("sharedPainter", methodInfo, result);
			8259	} else {
			8260	returnValue = ((QPainter*)args[0]);
			8261	}
			8262	}
			8263	}
			8264	if (result) { Py_DECREF(result); }
			8265	Py_DECREF(obj);
			8266	return returnValue;
			8267	}
			8268	}
			8269	return genericBinaryFileWidget::sharedPainter();
			8270	}
			8271	void PythonQtShell_genericBinaryFileWidget::showEvent(QShowEvent* arg__1)
			8272	{
			8273	if (_wrapper) {
			8274	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "showEvent");
			8275	PyErr_Clear();
			8276	if (obj && !PythonQtSlotFunction_Check(obj)) {
			8277	static const char* argumentList[] ={"" , "QShowEvent*"};
			8278	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			8279	void* args[2] = {NULL, (void*)&arg__1};
			8280	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			8281	if (result) { Py_DECREF(result); }
			8282	Py_DECREF(obj);
			8283	return;
			8284	}
			8285	}
			8286	genericBinaryFileWidget::showEvent(arg__1);
			8287	}
			8288	QSize PythonQtShell_genericBinaryFileWidget::sizeHint() const
			8289	{
			8290	if (_wrapper) {
			8291	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getSizeHint");
			8292	PyErr_Clear();
			8293	if (obj && !PythonQtSlotFunction_Check(obj)) {
			8294	static const char* argumentList[] ={"QSize"};
			8295	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
			8296	QSize returnValue;
			8297	void* args[1] = {NULL};
			8298	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			8299	if (result) {
			8300	args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
			8301	if (args[0]!=&returnValue) {
			8302	if (args[0]==NULL) {
			8303	PythonQt::priv()->handleVirtualOverloadReturnError("getSizeHint", methodInfo, result);
			8304	} else {
			8305	returnValue = ((QSize)args[0]);
			8306	}
			8307	}
			8308	}
			8309	if (result) { Py_DECREF(result); }
			8310	Py_DECREF(obj);
			8311	return returnValue;
			8312	}
			8313	}
			8314	return genericBinaryFileWidget::sizeHint();
			8315	}
			8316	void PythonQtShell_genericBinaryFileWidget::tabletEvent(QTabletEvent* arg__1)
			8317	{
			8318	if (_wrapper) {
			8319	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "tabletEvent");
			8320	PyErr_Clear();
			8321	if (obj && !PythonQtSlotFunction_Check(obj)) {
			8322	static const char* argumentList[] ={"" , "QTabletEvent*"};
			8323	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			8324	void* args[2] = {NULL, (void*)&arg__1};
			8325	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			8326	if (result) { Py_DECREF(result); }
			8327	Py_DECREF(obj);
			8328	return;
			8329	}
			8330	}
			8331	genericBinaryFileWidget::tabletEvent(arg__1);
			8332	}
			8333	void PythonQtShell_genericBinaryFileWidget::timerEvent(QTimerEvent* arg__1)
			8334	{
			8335	if (_wrapper) {
			8336	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "timerEvent");
			8337	PyErr_Clear();
			8338	if (obj && !PythonQtSlotFunction_Check(obj)) {
			8339	static const char* argumentList[] ={"" , "QTimerEvent*"};
			8340	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			8341	void* args[2] = {NULL, (void*)&arg__1};
			8342	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			8343	if (result) { Py_DECREF(result); }
			8344	Py_DECREF(obj);
			8345	return;
			8346	}
			8347	}
			8348	genericBinaryFileWidget::timerEvent(arg__1);
			8349	}
			8350	void PythonQtShell_genericBinaryFileWidget::wheelEvent(QWheelEvent* arg__1)
			8351	{
			8352	if (_wrapper) {
			8353	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "wheelEvent");
			8354	PyErr_Clear();
			8355	if (obj && !PythonQtSlotFunction_Check(obj)) {
			8356	static const char* argumentList[] ={"" , "QWheelEvent*"};
			8357	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			8358	void* args[2] = {NULL, (void*)&arg__1};
			8359	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			8360	if (result) { Py_DECREF(result); }
			8361	Py_DECREF(obj);
			8362	return;
			8363	}
			8364	}
			8365	genericBinaryFileWidget::wheelEvent(arg__1);
			8366	}
			8367	genericBinaryFileWidget* PythonQtWrapper_genericBinaryFileWidget::new_genericBinaryFileWidget(QWidget* parent)
			8368	{
			8369	return new PythonQtShell_genericBinaryFileWidget(parent); }
			8370
			8371
			8372
	7460	PythonQtShell_srecFile::~PythonQtShell_srecFile() {	8373	PythonQtShell_srecFile::~PythonQtShell_srecFile() {
	7461	PythonQtPrivate* priv = PythonQt::priv();	8374	PythonQtPrivate* priv = PythonQt::priv();
	7462	if (priv) { priv->shellClassDeleted(this); }	8375	if (priv) { priv->shellClassDeleted(this); }
	@@ -7641,6 +8554,11 srecFile* PythonQtWrapper_srecFile::new_
	7641	{	8554	{
	7642	return new PythonQtShell_srecFile(Files); }	8555	return new PythonQtShell_srecFile(Files); }
	7643		8556
			8557	bool PythonQtWrapper_srecFile::static_srecFile_checkSum(const QString& line)
			8558	{
			8559	return (srecFile::checkSum(line));
			8560	}
			8561
	7644	int PythonQtWrapper_srecFile::closeFile(srecFile* theWrappedObject)	8562	int PythonQtWrapper_srecFile::closeFile(srecFile* theWrappedObject)
	7645	{	8563	{
	7646	return ( ((PythonQtPublicPromoter_srecFile*)theWrappedObject)->promoted_closeFile());	8564	return ( ((PythonQtPublicPromoter_srecFile*)theWrappedObject)->promoted_closeFile());

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

@@ -1,9 +1,7
1	#include <PythonQt.h>	1	#include <PythonQt.h>
2	#include <QIconEngine>	2	#include <QIconEngine>
3	#include <QObject>	3	#include <QObject>
4	#include <QSpinBox>
5	#include <QVariant>	4	#include <QVariant>
6	#include <QWidget>
7	#include <SocExplorerPlot.h>	5	#include <SocExplorerPlot.h>
8	#include <abstractbinfile.h>	6	#include <abstractbinfile.h>
9	#include <binaryfile.h>	7	#include <binaryfile.h>
@@ -12,6 +10,7
12	#include <elffilewidget.h>	10	#include <elffilewidget.h>
13	#include <elfinfowdgt.h>	11	#include <elfinfowdgt.h>
14	#include <elfparser.h>	12	#include <elfparser.h>
		13	#include <genericbinaryfilewidget.h>
15	#include <memsizewdgt.h>	14	#include <memsizewdgt.h>
16	#include <qaction.h>	15	#include <qaction.h>
17	#include <qbitmap.h>	16	#include <qbitmap.h>
@@ -778,10 +777,10 codeFragment* new_codeFragment(char* da
778	void delete_codeFragment(codeFragment* obj) { delete obj; }	777	void delete_codeFragment(codeFragment* obj) { delete obj; }
779	void py_set_size(codeFragment* theWrappedObject, quint64 size){ theWrappedObject->size = size; }	778	void py_set_size(codeFragment* theWrappedObject, quint64 size){ theWrappedObject->size = size; }
780	quint64 py_get_size(codeFragment* theWrappedObject){ return theWrappedObject->size; }	779	quint64 py_get_size(codeFragment* theWrappedObject){ return theWrappedObject->size; }
		780	void py_set_data(codeFragment* theWrappedObject, char* data){ theWrappedObject->data = data; }
		781	char* py_get_data(codeFragment* theWrappedObject){ return theWrappedObject->data; }
781	void py_set_address(codeFragment* theWrappedObject, quint64 address){ theWrappedObject->address = address; }	782	void py_set_address(codeFragment* theWrappedObject, quint64 address){ theWrappedObject->address = address; }
782	quint64 py_get_address(codeFragment* theWrappedObject){ return theWrappedObject->address; }	783	quint64 py_get_address(codeFragment* theWrappedObject){ return theWrappedObject->address; }
783	void py_set_data(codeFragment* theWrappedObject, char* data){ theWrappedObject->data = data; }
784	char* py_get_data(codeFragment* theWrappedObject){ return theWrappedObject->data; }
785	void py_set_header(codeFragment* theWrappedObject, QString header){ theWrappedObject->header = header; }	784	void py_set_header(codeFragment* theWrappedObject, QString header){ theWrappedObject->header = header; }
786	QString py_get_header(codeFragment* theWrappedObject){ return theWrappedObject->header; }	785	QString py_get_header(codeFragment* theWrappedObject){ return theWrappedObject->header; }
787	};	786	};
@@ -806,6 +805,7 virtual void setFile(abstractBinFile* f
806	class PythonQtPublicPromoter_elfFileWidget : public elfFileWidget	805	class PythonQtPublicPromoter_elfFileWidget : public elfFileWidget
807	{ public:	806	{ public:
808	inline void promoted_reloadFile() { elfFileWidget::reloadFile(); }	807	inline void promoted_reloadFile() { elfFileWidget::reloadFile(); }
		808	inline void promoted_setFile(abstractBinFile* file) { elfFileWidget::setFile(file); }
809	};	809	};
810		810
811	class PythonQtWrapper_elfFileWidget : public QObject	811	class PythonQtWrapper_elfFileWidget : public QObject
@@ -815,6 +815,7 public slots:
815	elfFileWidget* new_elfFileWidget(QWidget* parent = 0);	815	elfFileWidget* new_elfFileWidget(QWidget* parent = 0);
816	void delete_elfFileWidget(elfFileWidget* obj) { delete obj; }	816	void delete_elfFileWidget(elfFileWidget* obj) { delete obj; }
817	void reloadFile(elfFileWidget* theWrappedObject);	817	void reloadFile(elfFileWidget* theWrappedObject);
		818	void setFile(elfFileWidget* theWrappedObject, abstractBinFile* file);
818	};	819	};
819		820
820		821
@@ -927,6 +928,73 void delete_elfparser(elfparser* obj) {
927		928
928		929
929		930
		931	class PythonQtShell_genericBinaryFileWidget : public genericBinaryFileWidget
		932	{
		933	public:
		934	PythonQtShell_genericBinaryFileWidget(QWidget* parent = 0):genericBinaryFileWidget(parent),_wrapper(NULL) {};
		935
		936	~PythonQtShell_genericBinaryFileWidget();
		937
		938	virtual void actionEvent(QActionEvent* arg__1);
		939	virtual void changeEvent(QEvent* arg__1);
		940	virtual void childEvent(QChildEvent* arg__1);
		941	virtual void closeEvent(QCloseEvent* arg__1);
		942	virtual void contextMenuEvent(QContextMenuEvent* arg__1);
		943	virtual void customEvent(QEvent* arg__1);
		944	virtual int devType() const;
		945	virtual void dragEnterEvent(QDragEnterEvent* arg__1);
		946	virtual void dragLeaveEvent(QDragLeaveEvent* arg__1);
		947	virtual void dragMoveEvent(QDragMoveEvent* arg__1);
		948	virtual void dropEvent(QDropEvent* arg__1);
		949	virtual void enterEvent(QEvent* arg__1);
		950	virtual bool event(QEvent* arg__1);
		951	virtual bool eventFilter(QObject* arg__1, QEvent* arg__2);
		952	virtual void focusInEvent(QFocusEvent* arg__1);
		953	virtual bool focusNextPrevChild(bool next);
		954	virtual void focusOutEvent(QFocusEvent* arg__1);
		955	virtual bool hasHeightForWidth() const;
		956	virtual int heightForWidth(int arg__1) const;
		957	virtual void hideEvent(QHideEvent* arg__1);
		958	virtual void initPainter(QPainter* painter) const;
		959	virtual void inputMethodEvent(QInputMethodEvent* arg__1);
		960	virtual QVariant inputMethodQuery(Qt::InputMethodQuery arg__1) const;
		961	virtual void keyPressEvent(QKeyEvent* arg__1);
		962	virtual void keyReleaseEvent(QKeyEvent* arg__1);
		963	virtual void leaveEvent(QEvent* arg__1);
		964	virtual int metric(QPaintDevice::PaintDeviceMetric arg__1) const;
		965	virtual QSize minimumSizeHint() const;
		966	virtual void mouseDoubleClickEvent(QMouseEvent* arg__1);
		967	virtual void mouseMoveEvent(QMouseEvent* arg__1);
		968	virtual void mousePressEvent(QMouseEvent* arg__1);
		969	virtual void mouseReleaseEvent(QMouseEvent* arg__1);
		970	virtual void moveEvent(QMoveEvent* arg__1);
		971	virtual bool nativeEvent(const QByteArray& eventType, void* message, long* result);
		972	virtual QPaintEngine* paintEngine() const;
		973	virtual void paintEvent(QPaintEvent* arg__1);
		974	virtual QPaintDevice* redirected(QPoint* offset) const;
		975	virtual void resizeEvent(QResizeEvent* arg__1);
		976	virtual QPainter* sharedPainter() const;
		977	virtual void showEvent(QShowEvent* arg__1);
		978	virtual QSize sizeHint() const;
		979	virtual void tabletEvent(QTabletEvent* arg__1);
		980	virtual void timerEvent(QTimerEvent* arg__1);
		981	virtual void wheelEvent(QWheelEvent* arg__1);
		982
		983	PythonQtInstanceWrapper* _wrapper;
		984	};
		985
		986	class PythonQtWrapper_genericBinaryFileWidget : public QObject
		987	{ Q_OBJECT
		988	public:
		989	public slots:
		990	genericBinaryFileWidget* new_genericBinaryFileWidget(QWidget* parent = 0);
		991	void delete_genericBinaryFileWidget(genericBinaryFileWidget* obj) { delete obj; }
		992	};
		993
		994
		995
		996
		997
930	class PythonQtShell_srecFile : public srecFile	998	class PythonQtShell_srecFile : public srecFile
931	{	999	{
932	public:	1000	public:
@@ -964,6 +1032,7 srecFile* new_srecFile();
964	srecFile* new_srecFile(const QString& File);	1032	srecFile* new_srecFile(const QString& File);
965	srecFile* new_srecFile(const QStringList& Files);	1033	srecFile* new_srecFile(const QStringList& Files);
966	void delete_srecFile(srecFile* obj) { delete obj; }	1034	void delete_srecFile(srecFile* obj) { delete obj; }
		1035	bool static_srecFile_checkSum(const QString& line);
967	int closeFile(srecFile* theWrappedObject);	1036	int closeFile(srecFile* theWrappedObject);
968	codeFragment* getFragment(srecFile* theWrappedObject, int index);	1037	codeFragment* getFragment(srecFile* theWrappedObject, int index);
969	int getFragmentAddress(srecFile* theWrappedObject, int index);	1038	int getFragmentAddress(srecFile* theWrappedObject, int index);

src/common/pythonQtOut/generated_cpp/PySocExplorer/PySocExplorer_init.cpp +1 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);

src/common/pythonQtgeneratorCfg.txt +9 -50

@@ -3,14 +3,7
3	<load-typesystem name=":/trolltech/generator/typesystem_gui.txt" generate="no" />	3	<load-typesystem name=":/trolltech/generator/typesystem_gui.txt" generate="no" />
4	<load-typesystem name=":/trolltech/generator/typesystem_network.txt" generate="no" />	4	<load-typesystem name=":/trolltech/generator/typesystem_network.txt" generate="no" />
5		5
6		6	<object-type name="QHexSpinBox"/>
7	<object-type name="QHexSpinBox">
8	<extra-includes>
9	<include file-name="QWidget" location="global"/>
10	<include file-name="QObject" location="global"/>
11	<include file-name="QSpinBox" location="global"/>
12	</extra-includes>
13	</object-type>
14	<object-type name="MemSizeWdgt" />	7	<object-type name="MemSizeWdgt" />
15	<object-type name="QHexEdit" />	8	<object-type name="QHexEdit" />
16	<object-type name="XByteArray" />	9	<object-type name="XByteArray" />
@@ -21,48 +14,14
21	<object-type name="binaryFile" />	14	<object-type name="binaryFile" />
22	<rejection class="Elf_Section"/>	15	<rejection class="Elf_Section"/>
23	<object-type name="elfparser" />	16	<object-type name="elfparser" />
24	<interface-type name="abstractBinFile">	17	<interface-type name="abstractBinFile"/>
25	<extra-includes>	18	<object-type name="ElfFile"/>
26	<include file-name="QWidget" location="global"/>	19	<interface-type name="abstractBinFileWidget"/>
27	<include file-name="QObject" location="global"/>	20	<object-type name="elfFileWidget"/>
28	</extra-includes>	21	<object-type name="srecFileWidget"/>
29	</interface-type>	22	<object-type name="binaryFileWidget"/>
30	<object-type name="~~ElfFile"~~>	23	<object-type name="elfInfoWdgt"/>
31	<extra-includes>	24	<object-type name="genericBinaryFileWidget"/>
32	<include file-name="QWidget" location="global"/>
33	<include file-name="QObject" location="global"/>
34	</extra-includes>
35	</object-type>
36	<interface-type name="abstractBinFileWidget">
37	<extra-includes>
38	<include file-name="QWidget" location="global"/>
39	<include file-name="QObject" location="global"/>
40	</extra-includes>
41	</interface-type>
42	<object-type name="elfFileWidget">
43	<extra-includes>
44	<include file-name="QWidget" location="global"/>
45	<include file-name="QObject" location="global"/>
46	</extra-includes>
47	</object-type>
48	<object-type name="srecFileWidget">
49	<extra-includes>
50	<include file-name="QWidget" location="global"/>
51	<include file-name="QObject" location="global"/>
52	</extra-includes>
53	</object-type>
54	<object-type name="binaryFileWidget">
55	<extra-includes>
56	<include file-name="QWidget" location="global"/>
57	<include file-name="QObject" location="global"/>
58	</extra-includes>
59	</object-type>
60	<object-type name="elfInfoWdgt">
61	<extra-includes>
62	<include file-name="QWidget" location="global"/>
63	<include file-name="QObject" location="global"/>
64	</extra-includes>
65	</object-type>
66		25
67	</typesystem>	26	</typesystem>
68		27

src/mainwindow.cpp +1 -1

                 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);

src/src.pro +1 0

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

unixcfg/SocExplorer.desktop +1 -1

             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;

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