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.files = ressources/images/logo-lpp-cutted.png
+                 icon.path = /usr/share/SocExplorer
+                 icon.files = ressources/images/Indiana_Jones_cappello.png
                  Wizard.path = /usr/share/qtcreator/templates/wizards/SocExplorerPlugin
                  Wizard.files = Qt_Creator_Wizard/SocExplorerPlugin/logo-lpp-cutted.png \
                                  Qt_Creator_Wizard/SocExplorerPlugin/plugin.cpp \

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	3	#include <PythonQtMethodInfo.h>
	4	4	#include <PythonQtSignalReceiver.h>
	5	5	#include <QIconEngine>
	6		#include <QObject>
	7		#include <QSpinBox>
	8	6	#include <QVariant>
	9		#include <QWidget>
	10	7	#include <abstractbinfile.h>
	11		#include <elffile.h>
	12	8	#include <elfparser.h>
	13	9	#include <qaction.h>
	14	10	#include <qbitmap.h>
			@@ -6391,7 +6387,7 if (_wrapper) {
	6391	6387	return;
	6392	6388	}
	6393	6389	}
	6394
		6390	elfFileWidget::setFile(file);
	6395	6391	}
	6396	6392	elfFileWidget* PythonQtWrapper_elfFileWidget::new_elfFileWidget(QWidget* parent)
	6397	6393	{
			@@ -6402,6 +6398,11 void PythonQtWrapper_elfFileWidget::relo
	6402	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	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	8373	PythonQtShell_srecFile::~PythonQtShell_srecFile() {
	7461	8374	PythonQtPrivate* priv = PythonQt::priv();
	7462	8375	if (priv) { priv->shellClassDeleted(this); }
			@@ -7641,6 +8554,11 srecFile* PythonQtWrapper_srecFile::new_
	7641	8554	{
	7642	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	8562	int PythonQtWrapper_srecFile::closeFile(srecFile* theWrappedObject)
	7645	8563	{
	7646	8564	return ( ((PythonQtPublicPromoter_srecFile*)theWrappedObject)->promoted_closeFile());

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

              #include <PythonQt.h>
              #include <QIconEngine>
              #include <QObject>
-             #include <QSpinBox>
              #include <QVariant>
-             #include <QWidget>
              #include <SocExplorerPlot.h>
              #include <abstractbinfile.h>
              #include <binaryfile.h>
              #include <elffilewidget.h>
              #include <elfinfowdgt.h>
              #include <elfparser.h>
+             #include <genericbinaryfilewidget.h>
              #include <memsizewdgt.h>
              #include <qaction.h>
              #include <qbitmap.h>
              void delete_codeFragment(codeFragment* obj) { delete obj; }
              void py_set_size(codeFragment* theWrappedObject, quint64  size){ theWrappedObject->size = size; }
              quint64  py_get_size(codeFragment* theWrappedObject){ return theWrappedObject->size; }
+             void py_set_data(codeFragment* theWrappedObject, char*  data){ theWrappedObject->data = data; }
+             char*  py_get_data(codeFragment* theWrappedObject){ return theWrappedObject->data; }
              void py_set_address(codeFragment* theWrappedObject, quint64  address){ theWrappedObject->address = address; }
              quint64  py_get_address(codeFragment* theWrappedObject){ return theWrappedObject->address; }
-             void py_set_data(codeFragment* theWrappedObject, char*  data){ theWrappedObject->data = data; }
-             char*  py_get_data(codeFragment* theWrappedObject){ return theWrappedObject->data; }
              void py_set_header(codeFragment* theWrappedObject, QString  header){ theWrappedObject->header = header; }
              QString  py_get_header(codeFragment* theWrappedObject){ return theWrappedObject->header; }
              };
              class PythonQtPublicPromoter_elfFileWidget : public elfFileWidget
              { public:
              inline void promoted_reloadFile() { elfFileWidget::reloadFile(); }
+             inline void promoted_setFile(abstractBinFile*  file) { elfFileWidget::setFile(file); }
              };
              class PythonQtWrapper_elfFileWidget : public QObject
              elfFileWidget* new_elfFileWidget(QWidget*  parent = 0);
              void delete_elfFileWidget(elfFileWidget* obj) { delete obj; }
                 void reloadFile(elfFileWidget* theWrappedObject);
+                void setFile(elfFileWidget* theWrappedObject, abstractBinFile*  file);
              };
+             class PythonQtShell_genericBinaryFileWidget : public genericBinaryFileWidget
+             {
+             public:
+                 PythonQtShell_genericBinaryFileWidget(QWidget*  parent = 0):genericBinaryFileWidget(parent),_wrapper(NULL) {};
+                ~PythonQtShell_genericBinaryFileWidget();
+             virtual void actionEvent(QActionEvent*  arg__1);
+             virtual void changeEvent(QEvent*  arg__1);
+             virtual void childEvent(QChildEvent*  arg__1);
+             virtual void closeEvent(QCloseEvent*  arg__1);
+             virtual void contextMenuEvent(QContextMenuEvent*  arg__1);
+             virtual void customEvent(QEvent*  arg__1);
+             virtual int  devType() const;
+             virtual void dragEnterEvent(QDragEnterEvent*  arg__1);
+             virtual void dragLeaveEvent(QDragLeaveEvent*  arg__1);
+             virtual void dragMoveEvent(QDragMoveEvent*  arg__1);
+             virtual void dropEvent(QDropEvent*  arg__1);
+             virtual void enterEvent(QEvent*  arg__1);
+             virtual bool  event(QEvent*  arg__1);
+             virtual bool  eventFilter(QObject*  arg__1, QEvent*  arg__2);
+             virtual void focusInEvent(QFocusEvent*  arg__1);
+             virtual bool  focusNextPrevChild(bool  next);
+             virtual void focusOutEvent(QFocusEvent*  arg__1);
+             virtual bool  hasHeightForWidth() const;
+             virtual int  heightForWidth(int  arg__1) const;
+             virtual void hideEvent(QHideEvent*  arg__1);
+             virtual void initPainter(QPainter*  painter) const;
+             virtual void inputMethodEvent(QInputMethodEvent*  arg__1);
+             virtual QVariant  inputMethodQuery(Qt::InputMethodQuery  arg__1) const;
+             virtual void keyPressEvent(QKeyEvent*  arg__1);
+             virtual void keyReleaseEvent(QKeyEvent*  arg__1);
+             virtual void leaveEvent(QEvent*  arg__1);
+             virtual int  metric(QPaintDevice::PaintDeviceMetric  arg__1) const;
+             virtual QSize  minimumSizeHint() const;
+             virtual void mouseDoubleClickEvent(QMouseEvent*  arg__1);
+             virtual void mouseMoveEvent(QMouseEvent*  arg__1);
+             virtual void mousePressEvent(QMouseEvent*  arg__1);
+             virtual void mouseReleaseEvent(QMouseEvent*  arg__1);
+             virtual void moveEvent(QMoveEvent*  arg__1);
+             virtual bool  nativeEvent(const QByteArray&  eventType, void*  message, long*  result);
+             virtual QPaintEngine*  paintEngine() const;
+             virtual void paintEvent(QPaintEvent*  arg__1);
+             virtual QPaintDevice*  redirected(QPoint*  offset) const;
+             virtual void resizeEvent(QResizeEvent*  arg__1);
+             virtual QPainter*  sharedPainter() const;
+             virtual void showEvent(QShowEvent*  arg__1);
+             virtual QSize  sizeHint() const;
+             virtual void tabletEvent(QTabletEvent*  arg__1);
+             virtual void timerEvent(QTimerEvent*  arg__1);
+             virtual void wheelEvent(QWheelEvent*  arg__1);
+               PythonQtInstanceWrapper* _wrapper;
+             };
+             class PythonQtWrapper_genericBinaryFileWidget : public QObject
+             { Q_OBJECT
+             public:
+             public slots:
+             genericBinaryFileWidget* new_genericBinaryFileWidget(QWidget*  parent = 0);
+             void delete_genericBinaryFileWidget(genericBinaryFileWidget* obj) { delete obj; }
+             };
              class PythonQtShell_srecFile : public srecFile
              {
              public:
              srecFile* new_srecFile(const QString&  File);
              srecFile* new_srecFile(const QStringList&  Files);
              void delete_srecFile(srecFile* obj) { delete obj; }
+                bool  static_srecFile_checkSum(const QString&  line);
                 int  closeFile(srecFile* theWrappedObject);
                 codeFragment*  getFragment(srecFile* theWrappedObject, int  index);
                 int  getFragmentAddress(srecFile* theWrappedObject, int  index);

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	3	<load-typesystem name=":/trolltech/generator/typesystem_gui.txt" generate="no" />
4	4	<load-typesystem name=":/trolltech/generator/typesystem_network.txt" generate="no" />
5	5
6
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>
	6	<object-type name="QHexSpinBox"/>
14	7	<object-type name="MemSizeWdgt" />
15	8	<object-type name="QHexEdit" />
16	9	<object-type name="XByteArray" />
		@@ -21,48 +14,14
21	14	<object-type name="binaryFile" />
22	15	<rejection class="Elf_Section"/>
23	16	<object-type name="elfparser" />
24		<interface-type name="abstractBinFile">
25		<extra-includes>
26		<include file-name="QWidget" location="global"/>
27		<include file-name="QObject" location="global"/>
28		</extra-includes>
29		</interface-type>
30		<object-type name="~~ElfFile"~~>
31		<extra-includes>
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>
	17	<interface-type name="abstractBinFile"/>
	18	<object-type name="ElfFile"/>
	19	<interface-type name="abstractBinFileWidget"/>
	20	<object-type name="elfFileWidget"/>
	21	<object-type name="srecFileWidget"/>
	22	<object-type name="binaryFileWidget"/>
	23	<object-type name="elfInfoWdgt"/>
	24	<object-type name="genericBinaryFileWidget"/>
66	25
67	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