HG_REPOSITORIES/LPP/INSTRUMENTATION/SocExplorer Commit - r47:f8c5117dac7c

added binary file loader, improved elf and srec loaders

jeandet -

r47:f8c5117dac7c default

parent child

Context file:

r47:f8c5117dac7c

Expand all files

src/common/BinFile/binaryfile.cpp created 644 +150 0

@@ -0,0 +1,150
	1	/*------------------------------------------------------------------------------
	2	-- This file is a part of the SocExplorer Software
	3	-- Copyright (C) 2014, Plasma Physics Laboratory - CNRS
	4	--
	5	-- This program is free software; you can redistribute it and/or modify
	6	-- it under the terms of the GNU General Public License as published by
	7	-- the Free Software Foundation; either version 2 of the License, or
	8	-- (at your option) any later version.
	9	--
	10	-- This program is distributed in the hope that it will be useful,
	11	-- but WITHOUT ANY WARRANTY; without even the implied warranty of
	12	-- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	13	-- GNU General Public License for more details.
	14	--
	15	-- You should have received a copy of the GNU General Public License
	16	-- along with this program; if not, write to the Free Software
	17	-- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
	18	-------------------------------------------------------------------------------*/
	19	/*-- Author : Alexis Jeandet
	20	-- Mail : alexis.jeandet@member.fsf.org
	21	----------------------------------------------------------------------------*/
	22	#include "binaryfile.h"
	23
	24	binaryFile::binaryFile()
	25	{
	26	}
	27
	28	binaryFile::binaryFile(const QString &File)
	29	{
	30	openFile(File);
	31	}
	32
	33	binaryFile::binaryFile(const QStringList &Files)
	34	{
	35	openFiles(Files);
	36	}
	37
	38	binaryFile::~binaryFile()
	39	{
	40
	41	}
	42
	43	bool binaryFile::openFile(const QString &File)
	44	{
	45	return openFiles(QStringList()<<File);
	46	}
	47
	48	bool binaryFile::openFiles(const QStringList &Files)
	49	{
	50	this->p_fileNames.clear();
	51	this->p_fileNames.append(Files);
	52	for(int i=0;i<p_files.count();i++)
	53	{
	54	delete p_files.at(i);
	55	}
	56	this->p_files.clear();
	57	for(int i=0;i<Files.count();i++)
	58	{
	59	this->p_files.append(new QFile(Files.at(i)));
	60	this->p_files.at(i)->open(QIODevice::ReadOnly);
	61	loadFile(this->p_files.at(i));
	62	}
	63	return true;
	64	}
	65
	66	bool binaryFile::isopened()
	67	{
	68	bool opened = true;
	69	for(int i=0;i<this->p_files.count();i++)
	70	{
	71	opened &= p_files.at(i)->isOpen();
	72	}
	73	return opened;
	74	}
	75
	76	int binaryFile::closeFile()
	77	{
	78	for(int i=0;i<p_files.count();i++)
	79	{
	80	delete p_files.at(i);
	81	for(int j=0;j<p_fragments.count();j++)
	82	{
	83	if(p_fragments.at(j)->header == p_files.at(i)->fileName())
	84	{
	85	codeFragment* fragment = p_fragments.at(j);
	86	p_fragments.removeAt(j);
	87	free(fragment->data);
	88	delete fragment;
	89	}
	90	}
	91	}
	92	p_files.clear();
	93	p_fileName.clear();
	94	return 0;
	95	}
	96
	97	QList<codeFragment *> binaryFile::getFragments()
	98	{
	99	return p_fragments;
	100	}
	101
	102	int binaryFile::getFragmentsCount()
	103	{
	104	return p_fragments.count();
	105	}
	106
	107	int binaryFile::getFragmentAddress(int index)
	108	{
	109	if((index>=0)&&(index<p_fragments.count()))
	110	return p_fragments.at(index)->address;
	111	return 0;
	112	}
	113
	114	int binaryFile::getFragmentSize(int index)
	115	{
	116	if((index>=0)&&(index<p_fragments.count()))
	117	return p_fragments.at(index)->size;
	118	return 0;
	119	}
	120
	121	QString binaryFile::getFragmentHeader(int index)
	122	{
	123	if((index>=0)&&(index<p_fragments.count()))
	124	return p_fragments.at(index)->header;
	125	return "";
	126	}
	127
	128	bool binaryFile::getFragmentData(int index, char **buffer)
	129	{
	130	if((index>=0)&&(index<p_fragments.count()))
	131	{
	132	*buffer = p_fragments.at(index)->data;
	133	return true;
	134	}
	135	return false;
	136	}
	137
	138	void binaryFile::loadFile(QFile *file)
	139	{
	140	if (file->isOpen())
	141	{
	142	codeFragment* fragment = new codeFragment();
	143	fragment->header = file->fileName();
	144	fragment->address = 0;
	145	fragment->size = file->size();
	146	fragment->data = (char*)malloc(file->size());
	147	file->read(fragment->data,file->size());
	148	p_fragments.append(fragment);
	149	}
	150	}

src/common/BinFile/binaryfile.h created 644 +60 0

@@ -0,0 +1,60
	1	/*------------------------------------------------------------------------------
	2	-- This file is a part of the SocExplorer Software
	3	-- Copyright (C) 2014, Plasma Physics Laboratory - CNRS
	4	--
	5	-- This program is free software; you can redistribute it and/or modify
	6	-- it under the terms of the GNU General Public License as published by
	7	-- the Free Software Foundation; either version 2 of the License, or
	8	-- (at your option) any later version.
	9	--
	10	-- This program is distributed in the hope that it will be useful,
	11	-- but WITHOUT ANY WARRANTY; without even the implied warranty of
	12	-- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	13	-- GNU General Public License for more details.
	14	--
	15	-- You should have received a copy of the GNU General Public License
	16	-- along with this program; if not, write to the Free Software
	17	-- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
	18	-------------------------------------------------------------------------------*/
	19	/*-- Author : Alexis Jeandet
	20	-- Mail : alexis.jeandet@member.fsf.org
	21	----------------------------------------------------------------------------*/
	22	#ifndef BINARYFILE_H
	23	#define BINARYFILE_H
	24	#include "abstractbinfile.h"
	25	#include <QObject>
	26	#include <QString>
	27	#include <QList>
	28	#include <QStringList>
	29	#include <QFile>
	30
	31	class binaryFile : public abstractBinFile
	32	{
	33	Q_OBJECT
	34	public:
	35	explicit binaryFile();
	36	binaryFile(const QString& File);
	37	binaryFile(const QStringList& Files);
	38	~binaryFile();
	39	bool openFile(const QString& File);
	40	bool openFiles(const QStringList& Files);
	41	bool isopened();
	42	int closeFile();
	43	QList<codeFragment*> getFragments();
	44	int getFragmentsCount();
	45	int getFragmentAddress(int index);
	46	int getFragmentSize(int index);
	47	QString getFragmentHeader(int index);
	48	bool getFragmentData(int index, char **buffer);
	49	signals:
	50
	51	public slots:
	52
	53	private:
	54	void loadFile(QFile *file);
	55	QStringList p_fileNames;
	56	QList<QFile*>p_files;
	57	QList<codeFragment*> p_fragments;
	58	};
	59
	60	#endif // BINARYFILE_H

src/common/BinFile/binaryfilewidget.cpp created 644 +82 0

@@ -0,0 +1,82
	1	#include "binaryfilewidget.h"
	2	#include "ui_binaryfilewidget.h"
	3	#include "qtablewidgetintitem.h"
	4	#include <QtWidgets/QTableWidget>
	5
	6	binaryFileWidget::binaryFileWidget(QWidget *parent) :
	7	QWidget(parent),
	8	ui(new Ui::binaryFileWidget)
	9	{
	10	ui->setupUi(this);
	11	connect(this->ui->fragmentList,SIGNAL(cellActivated(int,int)),this,SLOT(fragmentCellActivated(int,int)));
	12	connect(this->ui->fragmentList,SIGNAL(cellChanged(int,int)),this,SLOT(fragmentCellChanged(int,int)));
	13	}
	14
	15	binaryFileWidget::~binaryFileWidget()
	16	{
	17	delete ui;
	18	}
	19
	20	void binaryFileWidget::updateBinaryFile(binaryFile *file)
	21	{
	22	this->p_binfile = file;
	23	if(p_binfile->isopened())
	24	{
	25	updateFragments();
	26	}
	27	}
	28
	29	void binaryFileWidget::updateFragments()
	30	{
	31	this->ui->fragmentList->clear();
	32	this->ui->fragmentList->setRowCount(p_binfile->getFragmentsCount());
	33	this->ui->fragmentList->setHorizontalHeaderLabels(QStringList()<<"File"<<"Size"<<"Address");
	34	for(int i=0;i<p_binfile->getFragmentsCount();i++)
	35	{
	36	QTableWidgetItem *newItem = new QTableWidgetItem(p_binfile->getFragmentHeader(i));
	37	newItem->setFlags(newItem->flags() ^ Qt::ItemIsEditable);
	38	this->ui->fragmentList->setItem(i, 0, newItem);
	39
	40	newItem = (QTableWidgetItem*)new QTableWidgetIntItem(QString("%1").arg(p_binfile->getFragmentSize(i)),DecimalItem);
	41	newItem->setFlags(newItem->flags() ^ Qt::ItemIsEditable);
	42	this->ui->fragmentList->setItem(i, 1, newItem);
	43
	44	newItem = (QTableWidgetItem*)new QTableWidgetIntItem(QString("0x%1").arg(p_binfile->getFragmentAddress(i),8,16).replace(" ","0"),HexaDecimalItem);
	45	// newItem->setFlags(newItem->flags() ^ Qt::ItemIsEditable);
	46	this->ui->fragmentList->setItem(i, 2, newItem);
	47
	48	}
	49	this->ui->fragmentList->resizeColumnsToContents();
	50	}
	51
	52	void binaryFileWidget::fragmentCellActivated(int row, int column)
	53	{
	54	Q_UNUSED(column)
	55	char* buff=NULL;
	56	int index = this->ui->fragmentList->item(row,0)->text().toInt();
	57	if(index!=-1)
	58	{
	59	this->p_binfile->getFragmentData(index,&buff);
	60	this->ui->hexViewer->setData(QByteArray(buff,this->p_binfile->getFragmentSize(index)));
	61	this->ui->hexViewer->setAddressOffset(this->p_binfile->getFragmentAddress(index));
	62	}
	63	}
	64
	65	void binaryFileWidget::fragmentCellChanged(int row, int column)
	66	{
	67	if(column==2)
	68	{
	69	QString newAddressStr = this->ui->fragmentList->item(row,column)->text();
	70	int newAddress = 0;
	71	newAddressStr.remove(" ");
	72	if(newAddressStr.at(0)=='0' && newAddressStr.at(1)=='x')
	73	{
	74	newAddress = newAddressStr.remove("0x").toUInt(0,16);
	75	}
	76	else
	77	{
	78	newAddress = newAddressStr.toUInt();
	79	}
	80	this->p_binfile->getFragments().at(row)->address = newAddress;
	81	}
	82	}

src/common/BinFile/binaryfilewidget.h created 644 +32 0

@@ -0,0 +1,32
	1	#ifndef BINARYFILEWIDGET_H
	2	#define BINARYFILEWIDGET_H
	3
	4	#include <QWidget>
	5	#include "binaryfile.h"
	6
	7	namespace Ui {
	8	class binaryFileWidget;
	9	}
	10
	11	class binaryFileWidget : public QWidget
	12	{
	13	Q_OBJECT
	14
	15	public:
	16	explicit binaryFileWidget(QWidget *parent = 0);
	17	~binaryFileWidget();
	18
	19	public slots:
	20	void updateBinaryFile(binaryFile* file);
	21	void updateFragments();
	22
	23	private slots:
	24	void fragmentCellActivated(int row, int column);
	25	void fragmentCellChanged(int row, int column);
	26
	27	private:
	28	Ui::binaryFileWidget *ui;
	29	binaryFile* p_binfile;
	30	};
	31
	32	#endif // BINARYFILEWIDGET_H

src/common/BinFile/binaryfilewidget.ui created 644 +61 0

@@ -0,0 +1,61
	1	<?xml version="1.0" encoding="UTF-8"?>
	2	<ui version="4.0">
	3	<class>binaryFileWidget</class>
	4	<widget class="QWidget" name="binaryFileWidget">
	5	<property name="geometry">
	6	<rect>
	7	<x>0</x>
	8	<y>0</y>
	9	<width>637</width>
	10	<height>342</height>
	11	</rect>
	12	</property>
	13	<property name="windowTitle">
	14	<string>Form</string>
	15	</property>
	16	<layout class="QGridLayout" name="gridLayout">
	17	<item row="0" column="0">
	18	<widget class="QSplitter" name="splitter">
	19	<property name="orientation">
	20	<enum>Qt::Horizontal</enum>
	21	</property>
	22	<widget class="QHexEdit" name="hexViewer" native="true">
	23	<property name="minimumSize">
	24	<size>
	25	<width>200</width>
	26	<height>0</height>
	27	</size>
	28	</property>
	29	</widget>
	30	<widget class="QTableWidget" name="fragmentList">
	31	<column>
	32	<property name="text">
	33	<string>File</string>
	34	</property>
	35	</column>
	36	<column>
	37	<property name="text">
	38	<string>Size</string>
	39	</property>
	40	</column>
	41	<column>
	42	<property name="text">
	43	<string>Address</string>
	44	</property>
	45	</column>
	46	</widget>
	47	</widget>
	48	</item>
	49	</layout>
	50	</widget>
	51	<customwidgets>
	52	<customwidget>
	53	<class>QHexEdit</class>
	54	<extends>QWidget</extends>
	55	<header location="global">qhexedit.h</header>
	56	<container>1</container>
	57	</customwidget>
	58	</customwidgets>
	59	<resources/>
	60	<connections/>
	61	</ui>

src/SocExplorerEngine/plugins/socexplorerplugin.h +1 -1

             /*------------------------------------------------------------------------------
             ███████╗ ██████╗  ██████╗    ███████╗██╗  ██╗██████╗ ██╗      ██████╗ ██████╗ ███████╗██████╗
             ██╔════╝██╔═══██╗██╔════╝    ██╔════╝╚██╗██╔╝██╔══██╗██║     ██╔═══██╗██╔══██╗██╔════╝██╔══██╗
             ███████╗██║   ██║██║         █████╗   ╚███╔╝ ██████╔╝██║     ██║   ██║██████╔╝█████╗  ██████╔╝
             ╚════██║██║   ██║██║         ██╔══╝   ██╔██╗ ██╔═══╝ ██║     ██║   ██║██╔══██╗██╔══╝  ██╔══██╗
             ███████║╚██████╔╝╚██████╗    ███████╗██╔╝ ██╗██║     ███████╗╚██████╔╝██║  ██║███████╗██║  ██║
             ╚══════╝ ╚═════╝  ╚═════╝    ╚══════╝╚═╝  ╚═╝╚═╝     ╚══════╝ ╚═════╝ ╚═╝  ╚═╝╚══════╝╚═╝  ╚═╝
             --  This file is a part of the SOC Explorer Software
             --  Copyright (C) 2011, Plasma Physics Laboratory - CNRS
             --
             --  This program is free software; you can redistribute it and/or modify
             --  it under the terms of the GNU General Public License as published by
             --  the Free Software Foundation; either version 2 of the License, or
             --  (at your option) any later version.
             --
             --  This program is distributed in the hope that it will be useful,
             --  but WITHOUT ANY WARRANTY; without even the implied warranty of
             --  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             --  GNU General Public License for more details.
             --
             --  You should have received a copy of the GNU General Public License
             --  along with this program; if not, write to the Free Software
             --  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
             -------------------------------------------------------------------------------*/
             /*--                  Author : Alexis Jeandet
             --                     Mail : alexis.jeandet@lpp.polytechnique.fr
             ----------------------------------------------------------------------------*/
             #ifndef SOCEXPLORERPLUGIN_H
             #define SOCEXPLORERPLUGIN_H
             #include <QWidget>
             #include <QAction>
             #include <QDockWidget>
             #include <QMainWindow>
             #include <QList>
             #include <QMenu>
             #include <socexplorer.h>
             #include <QObject>
             #include <QVariant>
             #include <QVariantList>
             #include <malloc.h>
             #include <QFile>
             #include <stdint.h>
             #include <QTextStream>
             #include <genericPySysdriver.h>
             #ifndef driver_Name
             #define driver_Name "Plugin"
             #endif
             #ifndef driver_Author
             #define driver_Author "No Author"
             #endif
             #ifndef driver_Version
             #define driver_Version "0.0.0"
             #endif
             #ifndef driver_Description
             #define driver_Description "No description."
             #endif
             #ifndef driver_can_be_root
             #define driver_can_be_root 0
             #endif
             #ifndef driver_can_be_child
             #define driver_can_be_child 0
             #endif
             #ifndef driver_VID
             #define driver_VID 0
             #endif
             #ifndef driver_PID
             #define driver_PID 0
             #endif
             #if defined(SOCEXPLORER_SDK_BUILD)
             #  define SOCEXPLORER_SDK_EXPORT Q_DECL_EXPORT
             #else
             #  define SOCEXPLORER_SDK_EXPORT Q_DECL_IMPORT
             #endif
             class  genericPySysdriver;
             //! socexplorerplugin is the base class for any SocExplorer plugin, it gives a standard interface to communicate
             //! between each plugins and to interact with SocExplorer software.
             class SOCEXPLORER_SDK_EXPORT socexplorerplugin : public QDockWidget
             {
                 Q_OBJECT
             public:
                 //! Default plugin constructor, any plugin should call this constructor. This constructor creates a
                 //! default python wrapper instance. If you want to connect your own python wrapper, you have to clear
                 //! createPyObject option and instanciate your own genericPySysdriver derivated object.
                 socexplorerplugin(QWidget *parent = 0,bool createPyObject=true):QDockWidget(parent)
                 {
                     closeAction=NULL;
                     menu=NULL;
                     ChildsMenu=NULL;
                     this->Connected = false;
                     this->setFeatures(QDockWidget::DockWidgetMovable|QDockWidget::DockWidgetFloatable|QDockWidget::DockWidgetVerticalTitleBar);
                     _Name = new QString(driver_Name);
                     _Author = new QString(driver_Author);
                     _Version = new QString(driver_Version);
                     _Description = new QString(driver_Description);
                     _canBeChild = driver_can_be_child;
                     _canBeRoot = driver_can_be_root;
                     _VID = driver_VID;
                     _PID = driver_PID;
                     if(createPyObject)
                     {
                         this->makeGenericPyWrapper();
                     }
                 }
                 //! Tells if the plugin is connected, it is used to enable or disable all childrens interfaces.
                 virtual int isConnected();
                 //! Gives the associated Vendor IDentifier, usefull to automatically associate plugins with found
                 //! hardware while board enumeration.
                 virtual int VID(){return _PID;}
                 //! Gives the associated Product IDentifier, usefull to automatically associate plugins with found
                 //! hardware while board enumeration.
                 virtual int PID(){return _VID;}
                 //! Gives the plugin's base name, usefull to automatically generate instance name.
                 virtual QString baseName();
                 //! Gives the base address of the current instance, for example if your plugin is supposed to drive
                 //! an UART it will correspond to the address of it's first register. This address have at least to
                 //! be set by SocExplorer and it can be user accessible if you want.
                 virtual int baseAddress();
                 //! Sets the base address of the current instance, for example if your plugin is supposed to drive
                 //! an UART it will correspond to the address of it's first register. This address have at least to
-                //! be set by lppSocExplorer and it can be user accessible if you want.
+                //! be set by SocExplorer and it can be user accessible if you want.
                 virtual void setBaseAddress(unsigned int baseAddress);
                 genericPySysdriver* getPyObjectWrapper(){return this->pyObject;}
                 QList<socexplorerplugin*> childs;
                 socexplorerplugin* parent;
                 QAction* closeAction;
                 QString  instanceName();
                 QMenu* menu;
                 QMenu* ChildsMenu;
             signals:
                 //! Signal emited each time the plugin is about to be closed.
                 void closePlugin(socexplorerplugin* driver);
                 void activateSig(bool flag);
                 void registerObject(QObject* object,const QString& instanceName);
             public slots:
                 virtual int registermenu(QMenu* menu);
                 virtual void postInstantiationTrigger();
                 //! Write slot this is the way your children plugins ask you for writing data.
                 //! If your plugin is supposed to have childern drivers you should implement this methode.
                 //! By default this methode forward the write request to the parent plugin.
                 //! \param Value Pointer the data buffer.
                 //! \param count Number of 32 bits words you should to write.
                 //! \param address Address from where you should to start to write.
                 //! \return Quantity of 32 bits words writtens.
                 virtual unsigned int Write(unsigned int* Value, unsigned int count,unsigned int address);
                 //! Read slot this is the way your children plugins ask you for reading data.
                 //! If your plugin is supposed to have childern drivers you should implement this methode.
                 //! By default this methode forward the write request to the parent plugin.
                 //! \param Value Pointer the data buffer.
                 //! \param count Number of 32 bits words you should to read.
                 //! \param address Address from where you should to start to read.
                 //! \return Quantity of 32 bits words read.
                 virtual unsigned int Read(unsigned int* Value, unsigned int count,unsigned int address);
                 virtual void closeMe();
                 virtual void activate(bool flag);
                 virtual void setInstanceName(const QString& newName);
             protected:
                 void makeGenericPyWrapper();
                 int BaseAddress;
                 bool Connected;
                 genericPySysdriver* pyObject;
                 QString* _Name;
                 QString* _Author;
                 QString* _Version;
                 QString* _Description;
                 QString  _instanceName;
                 int _canBeChild;
                 int _canBeRoot;
                 int _VID;
                 int _PID;
             };
             #endif // SOCEXPLORERPLUGIN_H

src/common/PySocExplorer.h +2 0

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

src/common/common.pro +12 -4

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

src/common/elf/elffile.cpp +40 -19

             /*------------------------------------------------------------------------------
             --  This file is a part of the SocExplorer Software
             --  Copyright (C) 2014, Plasma Physics Laboratory - CNRS
             --
             --  This program is free software; you can redistribute it and/or modify
             --  it under the terms of the GNU General Public License as published by
             --  the Free Software Foundation; either version 2 of the License, or
             --  (at your option) any later version.
             --
             --  This program is distributed in the hope that it will be useful,
             --  but WITHOUT ANY WARRANTY; without even the implied warranty of
             --  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             --  GNU General Public License for more details.
             --
             --  You should have received a copy of the GNU General Public License
             --  along with this program; if not, write to the Free Software
             --  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
             -------------------------------------------------------------------------------*/
             /*--                  Author :
                     Alexis Jeandet
             --                     Mail :
                     alexis.jeandet@member.fsf.org
             ----------------------------------------------------------------------------*/
             #include "elffile.h"
             #include "srec/srecfile.h"
             ElfFile::ElfFile()
                 :abstractBinFile()
             {
                 this->opened = false;
                 this->type_elf = false;
-                this->elfFile = NULL;
+                this->elfFile = (int)NULL;
                 this->e = NULL;
             }
             ElfFile::ElfFile(const QString &File)
                 :abstractBinFile()
             {
                 this->opened = false;
                 this->type_elf = false;
-                this->elfFile = NULL;
+                this->elfFile = (int)NULL;
                 this->e = NULL;
                 this->p_fileName = File;
                 openFile(File);
             }
             ElfFile::~ElfFile()
             {
                 closeFile();
                 if(scn)free(scn);
                 if(data)free(data);
                 for(int i=0;i<this->sections.count();i++)
                 {
                     delete this->sections.at(i);
                 }
                 this->sections.clear();
                 for(int i=0;i<this->Segments.count();i++)
                 {
                     free(this->Segments.at(i));
                 }
                 this->Segments.clear();
                 for(int i=0;i<symbols.count();i++)
                 {
                     delete this->symbols.at(i);
                 }
                 this->symbols.clear();
             }
             bool ElfFile::openFile(const QString &File)
             {
                 this->p_fileName = File;
                 this->closeFile();
                 if(elf_version(EV_CURRENT)==EV_NONE)return 0;
             #ifdef _ELF_WINDOWS_
                 this->elfFile = open(File.toStdString().c_str(),O_RDONLY|O_BINARY ,0);
             #else
                 this->elfFile = open(File.toStdString().c_str(),O_RDONLY ,0);
             #endif
-                if(this->elfFile==NULL)return 0;
+                if(this->elfFile==(int)NULL)return 0;
                 this->e = elf_begin(this->elfFile,ELF_C_READ,NULL);
                 if(this->e==NULL)return 0;
                 this->ek = elf_kind(this->e);
                 gelf_getehdr (this->e, &this->ehdr );
                 elf_getshdrstrndx (this->e, &this->shstrndx);
                 this->updateSegments();
                 this->updateSections();
                 this->updateSymbols();
                 this->opened = true;
                 return 1;
             }
             bool ElfFile::isopened()
             {
                 return this->opened;
             }
             int ElfFile::closeFile()
             {
-                if(this->elfFile!=NULL)
+                if(this->elfFile!=(int)NULL)
                 {
                     if(this->e!=NULL)
                     {
                         elf_end(this->e);
                         this->e = NULL;
                     }
                     close(this->elfFile);
-                    this->elfFile = NULL;
+                    this->elfFile = (int)NULL;
                 }
                 this->opened = false;
                 return 0;
             }
             QList<codeFragment*> ElfFile::getFragments(QStringList fragmentList)
             {
                 QList<codeFragment*> fragments;
                 if (isopened())
                 {
                     for(int i =0;i<fragmentList.count();i++)
                     {
                         fragments.append(getFragment(fragmentList.at(i)));
                     }
                 }
                 return fragments;
             }
             QList<codeFragment*> ElfFile::getFragments()
             {
                 return getFragments(QStringList()<<".data"<<".text");
             }
             codeFragment *ElfFile::getFragment(const QString &name)
             {
                 codeFragment* fragment= new codeFragment();
                 for(int i=0;i<getSectionCount();i++)
                 {
                     if(getSectionName(i) == name)
                     {
                         fragment->data =NULL;
                         fragment->size = getSectionDatasz(i);
                         fragment->address = getSectionPaddr(i);
                         getSectionData(i,&fragment->data);
                     }
                 }
                 return fragment;
             }
             QString elfresolveMachine(Elf64_Half	e_machine)
             {
                 QString machineName;
                 //Update from with bash script don't write it by yourself!
                 switch(e_machine)
                 {
                 case EM_NONE:
                     machineName = " No machine ";
                     break;
                 case EM_M32:
                     machineName = " AT&T WE 32100 ";
                     break;
                 case EM_SPARC:
                     machineName = " SUN SPARC ";
                     break;
                 case EM_386:
                     machineName = " Intel 80386 ";
                     break;
                 case EM_68K:
                     machineName = " Motorola m68k family ";
                     break;
                 case EM_88K:
                     machineName = " Motorola m88k family ";
                     break;
                 case EM_860:
                     machineName = " Intel 80860 ";
                     break;
                 case EM_MIPS:
                     machineName = " MIPS R3000 big-endian ";
                     break;
                 case EM_S370:
                     machineName = " IBM System/370 ";
                     break;
                 case EM_MIPS_RS3_LE:
                     machineName = " MIPS R3000 little-endian ";
                     break;
                 case EM_PARISC:
                     machineName = " HPPA ";
                     break;
                 case EM_VPP500:
                     machineName = " Fujitsu VPP500 ";
                     break;
                 case EM_SPARC32PLUS:
                     machineName = " Sun's \"v8plus\" ";
                     break;
                 case EM_960:
                     machineName = " Intel 80960 ";
                     break;
                 case EM_PPC:
                     machineName = " PowerPC ";
                     break;
                 case EM_PPC64:
                     machineName = " PowerPC 64-bit ";
                     break;
                 case EM_S390:
                     machineName = " IBM S390 ";
                     break;
                 case EM_V800:
                     machineName = " NEC V800 series ";
                     break;
                 case EM_FR20:
                     machineName = " Fujitsu FR20 ";
                     break;
                 case EM_RH32:
                     machineName = " TRW RH-32 ";
                     break;
                 case EM_RCE:
                     machineName = " Motorola RCE ";
                     break;
                 case EM_ARM:
                     machineName = " ARM ";
                     break;
                 case EM_FAKE_ALPHA:
                     machineName = " Digital Alpha ";
                     break;
                 case EM_SH:
                     machineName = " Hitachi SH ";
                     break;
                 case EM_SPARCV9:
                     machineName = " SPARC v9 64-bit ";
                     break;
                 case EM_TRICORE:
                     machineName = " Siemens Tricore ";
                     break;
                 case EM_ARC:
                     machineName = " Argonaut RISC Core ";
                     break;
                 case EM_H8_300:
                     machineName = " Hitachi H8/300 ";
                     break;
                 case EM_H8_300H:
                     machineName = " Hitachi H8/300H ";
                     break;
                 case EM_H8S:
                     machineName = " Hitachi H8S ";
                     break;
                 case EM_H8_500:
                     machineName = " Hitachi H8/500 ";
                     break;
                 case EM_IA_64:
                     machineName = " Intel Merced ";
                     break;
                 case EM_MIPS_X:
                     machineName = " Stanford MIPS-X ";
                     break;
                 case EM_COLDFIRE:
                     machineName = " Motorola Coldfire ";
                     break;
                 case EM_68HC12:
                     machineName = " Motorola M68HC12 ";
                     break;
                 case EM_MMA:
                     machineName = " Fujitsu MMA Multimedia Accelerator";
                     break;
                 case EM_PCP:
                     machineName = " Siemens PCP ";
                     break;
                 case EM_NCPU:
                     machineName = " Sony nCPU embeeded RISC ";
                     break;
                 case EM_NDR1:
                     machineName = " Denso NDR1 microprocessor ";
                     break;
                 case EM_STARCORE:
                     machineName = " Motorola Start*Core processor ";
                     break;
                 case EM_ME16:
                     machineName = " Toyota ME16 processor ";
                     break;
                 case EM_ST100:
                     machineName = " STMicroelectronic ST100 processor ";
                     break;
                 case EM_TINYJ:
                     machineName = " Advanced Logic Corp. Tinyj emb.fam";
                     break;
                 case EM_X86_64:
                     machineName = " AMD x86-64 architecture ";
                     break;
                 case EM_PDSP:
                     machineName = " Sony DSP Processor ";
                     break;
                 case EM_FX66:
                     machineName = " Siemens FX66 microcontroller ";
                     break;
                 case EM_ST9PLUS:
                     machineName = " STMicroelectronics ST9+ 8/16 mc ";
                     break;
                 case EM_ST7:
                     machineName = " STmicroelectronics ST7 8 bit mc ";
                     break;
                 case EM_68HC16:
                     machineName = " Motorola MC68HC16 microcontroller ";
                     break;
                 case EM_68HC11:
                     machineName = " Motorola MC68HC11 microcontroller ";
                     break;
                 case EM_68HC08:
                     machineName = " Motorola MC68HC08 microcontroller ";
                     break;
                 case EM_68HC05:
                     machineName = " Motorola MC68HC05 microcontroller ";
                     break;
                 case EM_SVX:
                     machineName = " Silicon Graphics SVx ";
                     break;
                 case EM_ST19:
                     machineName = " STMicroelectronics ST19 8 bit mc ";
                     break;
                 case EM_VAX:
                     machineName = " Digital VAX ";
                     break;
                 case EM_CRIS:
                     machineName = " Axis Communications 32-bit embedded processor ";
                     break;
                 case EM_JAVELIN:
                     machineName = " Infineon Technologies 32-bit embedded processor ";
                     break;
                 case EM_FIREPATH:
                     machineName = " Element 14 64-bit DSP Processor ";
                     break;
                 case EM_ZSP:
                     machineName = " LSI Logic 16-bit DSP Processor ";
                     break;
                 case EM_MMIX:
                     machineName = " Donald Knuth's educational 64-bit processor ";
                     break;
                 case EM_HUANY:
                     machineName = " Harvard University machine-independent object files ";
                     break;
                 case EM_PRISM:
                     machineName = " SiTera Prism ";
                     break;
                 case EM_AVR:
                     machineName = " Atmel AVR 8-bit microcontroller ";
                     break;
                 case EM_FR30:
                     machineName = " Fujitsu FR30 ";
                     break;
                 case EM_D10V:
                     machineName = " Mitsubishi D10V ";
                     break;
                 case EM_D30V:
                     machineName = " Mitsubishi D30V ";
                     break;
                 case EM_V850:
                     machineName = " NEC v850 ";
                     break;
                 case EM_M32R:
                     machineName = " Mitsubishi M32R ";
                     break;
                 case EM_MN10300:
                     machineName = " Matsushita MN10300 ";
                     break;
                 case EM_MN10200:
                     machineName = " Matsushita MN10200 ";
                     break;
                 case EM_PJ:
                     machineName = " picoJava ";
                     break;
                 case EM_OPENRISC:
                     machineName = " OpenRISC 32-bit embedded processor ";
                     break;
                 case EM_ARC_A5:
                     machineName = " ARC Cores Tangent-A5 ";
                     break;
                 case EM_XTENSA:
                     machineName = " Tensilica Xtensa Architecture ";
                     break;
                 case EM_AARCH64:
                     machineName = " ARM AARCH64 ";
                     break;
                 case EM_TILEPRO:
                     machineName = " Tilera TILEPro ";
                     break;
                 case EM_MICROBLAZE:
                     machineName = " Xilinx MicroBlaze ";
                     break;
                 case EM_TILEGX:
                     machineName = " Tilera TILE-Gx ";
                     break;
                 case EM_NUM:
                     machineName = "";
                     break;
                 default:
                     machineName ="Unknow Machine";
                     break;
                 }
                 return machineName;
             }
             QString ElfFile::getClass()
             {
                 if(this->e!=NULL)
                 {
                     int eclass = gelf_getclass(this->e);
                     if(eclass==ELFCLASS32)return "ELF32";
                     if(eclass==ELFCLASS64)return "ELF64";
                 }
                 return "none";
             }
             bool ElfFile::iself()
             {
                 return (this->getType()!="Unknow");
             }
             QString ElfFile::getArchitecture()
             {
                 if(this->e!=NULL)
                 {
                     return elfresolveMachine(this->ehdr.e_machine);
                 }
                 return "";
             }
             QString ElfFile::getType()
             {
                 QString kind("");
                 if(this->e!=NULL)
                 {
                     switch(this->ek)
                     {
                     case ELF_K_AR:
                         kind = "Archive";
                         break;
                     case ELF_K_ELF:
                         kind = "Elf";
                         break;
                     case ELF_K_COFF:
                         kind = "COFF";
                         break;
                     case ELF_K_NUM:
                         kind = "NUM";
                         break;
                     case ELF_K_NONE:
                         kind = "Data";
                         break;
                     default:
                         kind = "Unknow";
                         break;
                     }
                 }
                 return kind;
             }
             QString ElfFile::getEndianness()
             {
                 if(this->e!=NULL)
                 {
                     if(this->ehdr.e_ident[EI_DATA]==ELFDATA2LSB)return "2's complement, little endian";
                     if(this->ehdr.e_ident[EI_DATA]==ELFDATA2MSB)return "2's complement, big endian";
                 }
                 return "none";
             }
             QString ElfFile::getABI()
             {
                 if(this->e!=NULL)
                 {
                     if(this->ehdr.e_ident[EI_OSABI]==ELFOSABI_NONE)return "UNIX System V ABI";
                     if(this->ehdr.e_ident[EI_OSABI]==ELFOSABI_SYSV)return "Alias";
                     if(this->ehdr.e_ident[EI_OSABI]==ELFOSABI_HPUX)return "HP-UX";
                     if(this->ehdr.e_ident[EI_OSABI]==ELFOSABI_NETBSD)return "NetBSD";
                     if(this->ehdr.e_ident[EI_OSABI]==ELFOSABI_GNU)return "Object uses GNU ELF extensions";
                     if(this->ehdr.e_ident[EI_OSABI]==ELFOSABI_LINUX)return "Compatibility alias";
                     if(this->ehdr.e_ident[EI_OSABI]==ELFOSABI_SOLARIS)return "Sun Solaris";
                     if(this->ehdr.e_ident[EI_OSABI]==ELFOSABI_AIX)return "IBM AIX";
                     if(this->ehdr.e_ident[EI_OSABI]==ELFOSABI_IRIX)return "SGI Irix";
                     if(this->ehdr.e_ident[EI_OSABI]==ELFOSABI_FREEBSD)return "FreeBSD";
                     if(this->ehdr.e_ident[EI_OSABI]==ELFOSABI_TRU64)return "Compaq TRU64 UNIX";
                     if(this->ehdr.e_ident[EI_OSABI]==ELFOSABI_MODESTO)return " Novell Modesto";
                     if(this->ehdr.e_ident[EI_OSABI]==ELFOSABI_OPENBSD)return "OpenBSD";
                     if(this->ehdr.e_ident[EI_OSABI]==ELFOSABI_ARM_AEABI)return "ARM EABI";
                     if(this->ehdr.e_ident[EI_OSABI]==ELFOSABI_ARM)return "ARM";
                     if(this->ehdr.e_ident[EI_OSABI]==ELFOSABI_STANDALONE)return "Standalone (embedded) application";
                 }
                 return "none";
             }
             qint64 ElfFile::getVersion()
             {
                 if(this->e!=NULL)
                 {
                     return this->ehdr.e_version;
                 }
+                return -1;
             }
             qint64 ElfFile::getEntryPointAddress()
             {
                 if(this->e!=NULL)
                 {
                     return this->ehdr.e_entry;
                 }
+                return -1;
             }
             int ElfFile::getSectionCount()
             {
                 return (int)this->SectionCount;
             }
             int ElfFile::getSymbolCount()
             {
                 return (int)this->SymbolCount;
             }
             int ElfFile::getSegmentCount()
             {
                 return (int)this->SegmentCount;
             }
             QString ElfFile::getSegmentType(int index)
             {
                 QString type("");
                 if(this->e!=NULL)
                 {
                     if(index < this->Segments.count())
                     {
                         switch(this->Segments.at(index)->p_type)
                         {
                         case PT_NULL:
                             type = "Program header table entry unused";
                             break;
                         case PT_LOAD:
                             type = "Loadable program segment";
                             break;
                         case PT_DYNAMIC	:
                             type = "Dynamic linking information";
                             break;
                         case PT_INTERP:
                             type ="Program interpreter";
                             break;
                         case PT_NOTE:
                             type = "Auxiliary information";
                             break;
                         case PT_SHLIB:
                             type = "Reserved";
                             break;
                         case PT_PHDR:
                             type =	"Entry for header table itself";
                             break;
                         case PT_TLS:
                             type = "Thread-local storage segment";
                             break;
                         case PT_NUM:
                             type = "Number of defined types";
                             break;
                         case PT_LOOS:
                             type =	"Start of OS-specific";
                             break;
                         case PT_SUNWSTACK:
                             type = "Stack segment";
                             break;
                         case PT_LOPROC:
                             type = "Start of processor-specific";
                             break;
                         case PT_HIPROC:
                             type = "End of processor-specific";
                             break;
                         default:
                             type = "Unknow Section Type";
                             break;
                         }
                     }
                 }
                 return type;
             }
             qint64 ElfFile::getSegmentOffset(int index)
             {
-                int64_t Offset;
+                qint64 Offset = -1;
                 if(this->e!=NULL)
                 {
                     if(index < this->Segments.count())
                     {
-                        Offset =  (int64_t)this->Segments.at(index)->p_offset;
+                        Offset =  (qint64)this->Segments.at(index)->p_offset;
                     }
                 }
                 return Offset;
             }
             qint64 ElfFile::getSegmentVaddr(int index)
             {
                 int64_t Vaddr = 0;
                 if(this->e!=NULL)
                 {
                     if(index < this->Segments.count())
                     {
                         Vaddr =  (int64_t)this->Segments.at(index)->p_vaddr;
                     }
                 }
                 return Vaddr;
             }
             qint64 ElfFile::getSegmentPaddr(int index)
             {
                 int64_t Paddr=0;
                 if(this->e!=NULL)
                 {
                     if(index < this->Segments.count())
                     {
                         Paddr = (int64_t)this->Segments.at(index)->p_paddr;
                     }
                 }
                 return Paddr;
             }
             qint64 ElfFile::getSectionPaddr(int index)
             {
                 int64_t Paddr=0;
                 if(this->e!=NULL)
                 {
                     if(index < this->sections.count())
                     {
                         Paddr = (int64_t)this->sections.at(index)->section_header->sh_addr;
                     }
                 }
                 return Paddr;
             }
             qint64 ElfFile::getSegmentFilesz(int index)
             {
                 int64_t FileSz=0;
                 if(this->e!=NULL)
                 {
                     if(index < this->Segments.count())
                     {
                         FileSz = (int64_t)this->Segments.at(index)->p_filesz;
                     }
                 }
                 return FileSz;
             }
             qint64 ElfFile::getSectionDatasz(int index)
             {
                 int64_t DataSz=0;
                 if(this->e!=NULL)
                 {
                     if(index < this->sections.count())
                     {
-                        DataSz = (int64_t)this->sections.at(index)->data->d_size;
+                        if(this->sections.at(index)->section_header->sh_type==SHT_NOBITS)
+                        {
+                            DataSz=0;
+                        }
+                        else
+                        {
+                            DataSz = (int64_t)this->sections.at(index)->data->d_size;
+                        }
                     }
                 }
                 return DataSz;
             }
             bool ElfFile::getSectionData(int index, char **buffer)
             {
                 if(this->e!=NULL)
                 {
                     if(index < this->sections.count())
                     {
                         *buffer = (char *)this->sections.at(index)->data->d_buf;
                         return true;
                     }
                 }
                 return false;
             }
             qint64 ElfFile::getSegmentMemsz(int index)
             {
                 int64_t MemSz=0;
                 if(this->e!=NULL)
                 {
                     if(index < this->Segments.count())
                     {
                         MemSz = (int64_t)this->Segments.at(index)->p_memsz;
                     }
                 }
                 return MemSz;
             }
             qint64 ElfFile::getSectionMemsz(int index)
             {
                 int64_t MemSz=0;
                 if(this->e!=NULL)
                 {
                     if(index < this->sections.count())
                     {
                         MemSz = (int64_t)this->sections.at(index)->section_header->sh_size;
                     }
                 }
                 return MemSz;
             }
             QString ElfFile::getSegmentFlags(int index)
             {
                 QString flags("");
                 if(this->e!=NULL)
                 {
                     if(index < this->Segments.count())
                     {
                         if((this->Segments.at(index)->p_flags&PF_X) == PF_X)flags+="x";
                         if((this->Segments.at(index)->p_flags&PF_W) == PF_W)flags+="w";
                         if((this->Segments.at(index)->p_flags&PF_R) == PF_R)flags+="r";
                         if((this->Segments.at(index)->p_flags&PF_MASKOS) == PF_MASKOS)flags+=" OS-specific";
                         if((this->Segments.at(index)->p_flags&PF_MASKPROC) == PF_MASKPROC)flags+=" Processor-specific";
                     }
                 }
                 return flags;
             }
             QString ElfFile::getSectionName(int index)
             {
                 if((index<sections.count()) && (index>=0))
                 {
                     char* nameChr = elf_strptr(this->e , this->shstrndx , this->sections.at(index)->section_header->sh_name);
                     return QString(nameChr);
                 }
                 return "";
             }
             void ElfFile::updateSections()
             {
                 for(int i=0;i<this->sections.count();i++)
                 {
                     delete this->sections.at(i);
                 }
                 this->sections.clear();
                 this->scn = elf_nextscn (this->e , NULL );
                 this->SectionCount = 0;
                 while( this->scn != NULL )
                 {
                     GElf_Shdr* shdr = (GElf_Shdr*)malloc(sizeof(GElf_Shdr));
                     gelf_getshdr ( this->scn , shdr );
                     Elf_Data*  data = elf_getdata(this->scn, NULL);
                     this->sections.append(new Elf_Section(data,shdr));
                     this->SectionCount+=1;
                     this->scn = elf_nextscn(e , scn);
                 }
             }
             void ElfFile::updateSegments()
             {
                 elf_getphdrnum (this->e , &this->SegmentCount);
                 for(int i=0;i<this->Segments.count();i++)
                 {
                     free(this->Segments.at(i));
                 }
                 this->Segments.clear();
-                for(int i=0;i<this->SegmentCount;i++)
+                for(int i=0;i<(int)this->SegmentCount;i++)
                 {
                     GElf_Phdr* header=(GElf_Phdr*)malloc(sizeof(GElf_Phdr));
                     gelf_getphdr (this->e , i , header );
                     this->Segments.append(header);
                 }
             }
             void ElfFile::updateSymbols()
             {
                 for(int i=0;i<symbols.count();i++)
                 {
                     delete this->symbols.at(i);
                 }
                 this->symbols.clear();
                 updateSections(); //Useless in most case but safer to do it
-                for(int i=0;i<SectionCount;i++)
+                for(int i=0;i<(int)SectionCount;i++)
                 {
                     //First find Symbol table
                     if(this->getSectionName(i)==".symtab")
                     {
                         Elf_Section* sec = sections.at(i);
                         this->SymbolCount =   sec->section_header->sh_size / sec->section_header->sh_entsize;
                         //Then list all symbols
-                        for(int j=0;j<this->SymbolCount;j++)
+                        for(int j=0;j<(int)this->SymbolCount;j++)
                         {
                             GElf_Sym* esym = (GElf_Sym*)malloc(sizeof(GElf_Sym));
                             gelf_getsym(sec->data, j, esym);
                             QString name = elf_strptr(this->e,sec->section_header->sh_link,esym->st_name);
                             Elf_Symbol* sym = new Elf_Symbol(name,esym);
                             symbols.append(sym);
                         }
                     }
                 }
             }
             QString ElfFile::getSectionType(int index)
             {
                 QString type("");
                 if(this->e!=NULL)
                 {
-                    if(index < this->Segments.count())
+                    if(index < this->sections.count())
                     {
-                        switch(this->Segments.at(index)->p_type)
+                        switch(this->sections.at(index)->section_header->sh_type)
                         {
                         case SHT_NULL	 :	type = "Section header table entry unused"; break;
                         case SHT_PROGBITS	  :		type = "Program data"; break;
                         case SHT_SYMTAB	  :		type = "Symbol table"; break;
                         case SHT_STRTAB	  :		type = "String table"; break;
                         case SHT_RELA	  :		type = "Relocation entries with addends"; break;
                         case SHT_HASH	  :		type = "Symbol hash table"; break;
                         case SHT_DYNAMIC	 :		type = "Dynamic linking information"; break;
                         case SHT_NOTE	  :		type = "Notes"; break;
                         case SHT_NOBITS    :type = "Program space with no data (bss)"; break;
                         case SHT_REL    :type = "Relocation entries, no addends"; break;
                         case SHT_SHLIB	 :		type = "Reserved"; break;
                         case SHT_DYNSYM	  :		type = "Dynamic linker symbol table"; break;
                         case SHT_INIT_ARRAY	  :		type = "Array of constructors"; break;
                         case SHT_FINI_ARRAY	  :		type = "Array of destructors"; break;
                         case SHT_PREINIT_ARRAY :		type = "Array of pre-constructors"; break;
                         case SHT_GROUP	  :		type = "Section group"; break;
                         case SHT_SYMTAB_SHNDX  :		type = "Extended section indeces"; break;
                         case SHT_NUM		  :		type = "Number of defined types. "; break;
                         case SHT_LOOS	  :	type = "Start OS-specific. "; break;
                         case SHT_LOSUNW	  :	type = "Sun-specific low bound. "; break;
                         case SHT_SUNW_COMDAT  : type = " "; break;
                         case SHT_SUNW_syminfo  : type = " "; break;
                         case SHT_GNU_verdef	  :	type = "Version definition section. "; break;
                         case SHT_GNU_verneed	  :	type = "Version needs section. "; break;
                         case SHT_GNU_versym	  :	type = "Version symbol table. "; break;
                         case SHT_LOPROC	  :	type = "Start of processor-specific"; break;
                         case SHT_HIPROC	 :	type = "End of processor-specific"; break;
                         case SHT_HIUSER	 :	type = "End of application-specific"; break;
                         }
                     }
                 }
                 return type;
             }
             int ElfFile::getSectionIndex(QString name)
             {
                 if(this->e!=NULL)
                 {
                     for(int i=0;i<sections.count();i++)
                     {
-                       if(getSectionName(i)==name)
+                        if(getSectionName(i)==name)
-                           return i;
+                            return i;
                     }
                 }
                 return -1;
             }
+            bool ElfFile::sectionIsNobits(int index)
+            {
+                if(this->e!=NULL)
+                {
+                    if(index < this->sections.count())
+                    {
+                        return this->sections.at(index)->section_header->sh_type== SHT_NOBITS;
+                    }
+                }
+                return false;
+            }
             QString ElfFile::getSymbolName(int index)
             {
                 if(this->e!=NULL)
                 {
                     if(index < this->symbols.count())
                     {
                         return symbols.at(index)->name;
                     }
                 }
                 return "";
             }
             QString ElfFile::getSymbolType(int index)
             {
                 if(this->e!=NULL)
                 {
                     if(index < this->symbols.count())
                     {
                         int type = GELF_ST_TYPE(symbols.at(index)->sym->st_info);
                         switch(type)
                         {
                         case STT_NOTYPE:
                             return "No Type";
                             break;
                         case STT_OBJECT:
                             return "Object";
                             break;
                         case STT_FUNC:
                             return "Function";
                             break;
                         case STT_SECTION:
                             return "Section";
                             break;
                         case STT_FILE:
                             return "File";
                             break;
                         case STT_COMMON:
                             return "Common data object";
                             break;
                         case STT_TLS:
                             return "Thread-local data object";
                             break;
                         case STT_NUM:
                             return "Number of defined types";
                             break;
                         case STT_LOOS:
                             return "Start of OS-specific";
                             break;
                         case STT_HIOS:
                             return "End of OS-specific";
                             break;
                         case STT_LOPROC:
                             return "Start of processor-specific";
                             break;
                         case STT_HIPROC:
                             return "End of processor-specific";
                             break;
                         default:
                             return "none";
                             break;
                         }
                     }
                 }
                 return "none";
             }
             quint64 ElfFile::getSymbolSize(int index)
             {
                 if(this->e!=NULL)
                 {
                     if((index < this->symbols.count()) && (index>=0))
                     {
                         return symbols.at(index)->sym->st_size;
                     }
                 }
                 return 0;
             }
             QString ElfFile::getSymbolSectionName(int index)
             {
                 if(this->e!=NULL)
                 {
                     if((index < this->symbols.count()) && (index>=0))
                     {
-                       return getSectionName(symbols.at(index)->sym->st_shndx-1);
+                        return getSectionName(symbols.at(index)->sym->st_shndx-1);
                     }
                 }
                 return "none";
             }
             int ElfFile::getSymbolSectionIndex(int index)
             {
                 if(this->e!=NULL)
                 {
                     if((index < this->symbols.count()) && (index>=0))
                     {
-                       return symbols.at(index)->sym->st_shndx;
+                        return symbols.at(index)->sym->st_shndx;
                     }
                 }
                 return 0;
             }
             quint64 ElfFile::getSymbolAddress(int index)
             {
                 if(this->e!=NULL)
                 {
                     if((index < this->symbols.count()) && (index>=0))
                     {
                         return symbols.at(index)->sym->st_value;
                     }
                 }
                 return 0;
             }
             QString ElfFile::getSymbolLinkType(int index)
             {
                 if(this->e!=NULL)
                 {
                     if(index < this->symbols.count())
                     {
                         int btype = GELF_ST_BIND(symbols.at(index)->sym->st_info);
                         switch(btype)
                         {
                         case STB_LOCAL:
                             return "Local";
                             break;
                         case STB_GLOBAL:
                             return "Global";
                             break;
                         case STB_WEAK:
                             return "Weak";
                             break;
                         case STB_NUM:
                             return "Number of defined types";
                             break;
                         case STB_LOOS:
                             return "Start of OS-specific";
                             break;
                         case STB_HIOS:
                             return "End of OS-specific";
                             break;
                         case STB_LOPROC:
                             return "Start of processor-specific";
                             break;
                         case STB_HIPROC:
                             return "End of processor-specific";
                             break;
                         default:
                             return "none";
                             break;
                         }
                     }
                 }
                 return "none";
             }
             bool ElfFile::isElf(const QString &File)
             {
                 int file =0;
             #ifdef _ELF_WINDOWS_
                 file = open(File.toStdString().c_str(),O_RDONLY|O_BINARY ,0);
             #else
                 file = open(File.toStdString().c_str(),O_RDONLY ,0);
             #endif
                 char Magic[4];
                 if(file!=-1)
                 {
-                    read(file,Magic,4);
+                    size_t res = read(file,Magic,4);
                     close(file);
-                    if(Magic[0]==0x7f && Magic[1]==0x45 && Magic[2]==0x4c && Magic[3]==0x46)
+                    if((res==4) && (Magic[0]==0x7f) && (Magic[1]==0x45) && (Magic[2]==0x4c) && (Magic[3]==0x46))
                     {
                         return true;
                     }
                 }
                 return false;
             }
             bool ElfFile::toSrec(const QString &File)
             {
                 return srecFile::toSrec(this->getFragments(),File);
             }

src/common/elf/elffile.h +2 -1

             /*------------------------------------------------------------------------------
             --  This file is a part of the SocExplorer Software
             --  Copyright (C) 2014, Plasma Physics Laboratory - CNRS
             --
             --  This program is free software; you can redistribute it and/or modify
             --  it under the terms of the GNU General Public License as published by
             --  the Free Software Foundation; either version 2 of the License, or
             --  (at your option) any later version.
             --
             --  This program is distributed in the hope that it will be useful,
             --  but WITHOUT ANY WARRANTY; without even the implied warranty of
             --  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             --  GNU General Public License for more details.
             --
             --  You should have received a copy of the GNU General Public License
             --  along with this program; if not, write to the Free Software
             --  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
             -------------------------------------------------------------------------------*/
             /*--                  Author : Alexis Jeandet
             --                     Mail : alexis.jeandet@member.fsf.org
             ----------------------------------------------------------------------------*/
             #include <abstractbinfile.h>
             #include <QtCore/QObject>
             #include <QtCore/QStringList>
             #include <libelf.h>
             #include <gelf.h>
             #include <sys/types.h>
             #include <sys/stat.h>
             #include <fcntl.h>
             #include <unistd.h>
             #ifndef ELFFILE_H
             #define ELFFILE_H
             class Elf_Section
             {
             public:
                 Elf_Section(){}
                 Elf_Section(Elf_Data*  data,GElf_Shdr* section_header)
                 {
                     this->data = data;
                     this->section_header = section_header;
                 }
                 ~Elf_Section()
                 {
                     free(section_header);
                 }
                 Elf_Data*  data;
                 GElf_Shdr* section_header;
             };
             class Elf_Symbol
             {
             public:
                 Elf_Symbol(){}
                 Elf_Symbol(const QString& name,GElf_Sym* sym):name(name),sym(sym){}
                 ~Elf_Symbol(){free(sym);}
                 QString name;
                 GElf_Sym* sym;
             };
             class ElfFile : public abstractBinFile
             {
                    Q_OBJECT
             public:
                 ElfFile();
                 ElfFile(const QString& File);
                 ~ElfFile();
                 bool openFile(const QString& File);
                 bool isopened();
                 int closeFile();
                 QList<codeFragment*> getFragments();
                 QList<codeFragment*> getFragments(QStringList fragmentList);
                 QString getClass();
                 QString getArchitecture();
                 QString getType();
                 QString getEndianness();
                 QString getABI();
                 qint64 getVersion();
                 qint64 getEntryPointAddress();
                 int getSectionCount();
                 int getSymbolCount();
                 int getSegmentCount();
                 QString getSegmentType(int index);
                 qint64 getSegmentOffset(int index);
                 qint64 getSegmentVaddr(int index);
                 qint64 getSegmentPaddr(int index);
                 qint64 getSegmentFilesz(int index);
-                qint64 getSectionDatasz(int index);
                 qint64 getSegmentMemsz(int index);
                 QString getSegmentFlags(int index);
                 bool getSectionData(int index, char **buffer);
                 qint64 getSectionPaddr(int index);
                 qint64 getSectionMemsz(int index);
+                qint64 getSectionDatasz(int index);
                 QString getSectionName(int index);
                 QString getSectionType(int index);
                 int getSectionIndex(QString name);
+                bool sectionIsNobits(int index);
                 QString getSymbolName(int index);
                 QString getSymbolType(int index);
                 quint64 getSymbolSize(int index);
                 QString getSymbolSectionName(int index);
                 int getSymbolSectionIndex(int index);
                 quint64 getSymbolAddress(int index);
                 QString getSymbolLinkType(int index);
                 bool iself();
                 static bool isElf(const QString& File);
                 bool toSrec(const QString& File);
             private:
                 codeFragment* getFragment(const QString& name);
                 void updateSections();
                 void updateSegments();
                 void updateSymbols();
                 int elfFile;
                 bool opened;
                 bool type_elf;
                 Elf* e;
                 Elf_Kind ek;
                 GElf_Ehdr ehdr;
                 Elf_Scn * scn;
                 Elf_Data * data;
                 size_t SymbolCount,SectionCount,SegmentCount, shstrndx;
                 QList<GElf_Phdr*> Segments;
                 QList<Elf_Section*> sections;
                 QList<Elf_Symbol*> symbols;
             };
             #endif // ELFFILE_H

src/common/elf/elffilewidget.cpp +142 -4

+            /*------------------------------------------------------------------------------
+            --  This file is a part of the SocExplorer Software
+            --  Copyright (C) 2014, Plasma Physics Laboratory - CNRS
+            --
+            --  This program is free software; you can redistribute it and/or modify
+            --  it under the terms of the GNU General Public License as published by
+            --  the Free Software Foundation; either version 2 of the License, or
+            --  (at your option) any later version.
+            --
+            --  This program is distributed in the hope that it will be useful,
+            --  but WITHOUT ANY WARRANTY; without even the implied warranty of
+            --  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+            --  GNU General Public License for more details.
+            --
+            --  You should have received a copy of the GNU General Public License
+            --  along with this program; if not, write to the Free Software
+            --  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+            -------------------------------------------------------------------------------*/
+            /*--                  Author : Alexis Jeandet
+            --                     Mail : alexis.jeandet@member.fsf.org
+            ----------------------------------------------------------------------------*/
             #include "elffilewidget.h"
             #include "ui_elffilewidget.h"
             #include <QtWidgets/QTableWidgetItem>
+            #include <QtWidgets/QFileDialog>
             #include "qhexedit.h"
             #include "qtablewidgetintitem.h"
+            #include "srec/srecfile.h"
             elfFileWidget::elfFileWidget(QWidget *parent) :
                 QWidget(parent),
                 ui(new Ui::elfFileWidget)
             {
                 ui->setupUi(this);
+                exportToSREC_action = new QAction(tr("Export to SREC"),this);
+                exportToBIN_action = new QAction(tr("Export to Binary"),this);
+                pointInSections_action = new QAction(tr("View in Hexviewer"),this);
                 connect(this->ui->sectionsList,SIGNAL(cellActivated(int,int)),this,SLOT(sectionCellActivated(int,int)));
+                this->ui->sectionsList->addAction(exportToSREC_action);
+                this->ui->sectionsList->addAction(exportToBIN_action);
+                this->ui->symbolsList->addAction(pointInSections_action);
+                connect(this->exportToBIN_action,SIGNAL(triggered()),this,SLOT(exportToBIN()));
+                connect(this->exportToSREC_action,SIGNAL(triggered()),this,SLOT(exportToSREC()));
+                connect(this->ui->symbolsFilter,SIGNAL(textChanged(QString)),this,SLOT(filterSymbols(QString)));
+                connect(this->ui->caseSensitive,SIGNAL(toggled(bool)),this,SLOT(filterSymbolsCaseUpdate(bool)));
+                connect(this->pointInSections_action,SIGNAL(triggered()),this,SLOT(pointSymbol()));
+                this->p_hexviewer = new QHexEdit();
+                this->p_hexviewer->setWindowTitle("SocExplorer Hexadecimal viewer");
+                this->setWindowTitle("SocExplorer Elf viewer");
             }
             elfFileWidget::~elfFileWidget()
             {
                 delete ui;
+                delete p_hexviewer;
             }
             void elfFileWidget::updateElfFile(ElfFile *file)
             {
                 this->p_elf = file;
                 if(p_elf->isopened() && p_elf->iself())
                 {
                     this->ui->classLabel->setText(p_elf->getClass());
                     this->ui->VersionLabel->setText(QString::number(p_elf->getVersion()));
                     this->ui->machineLabel->setText(p_elf->getArchitecture());
                     this->ui->endiannesLabel->setText(p_elf->getEndianness());
                     this->ui->abiLabel->setText(p_elf->getABI());
                     this->ui->entryPointLabel->setText(QString("0x%1").arg((uint)p_elf->getEntryPointAddress(),8,16));
                     this->ui->typeLabel->setText(p_elf->getType());
                     this->ui->sectionCountLabel->setText(QString::number(p_elf->getSectionCount()));
                     this->ui->symbolCountLabel->setText(QString::number(p_elf->getSymbolCount()));
                 }
                 updateSymbols();
                 updateSections();
             }
             void elfFileWidget::updateSymbols()
             {
                 this->ui->symbolsList->clear();
                 this->ui->symbolsList->setRowCount(p_elf->getSymbolCount());
                 this->ui->symbolsList->setHorizontalHeaderLabels(QStringList()<<"Index"<<"Value"<<"Size"<<"Type"<<"Link"<<"Section"<<"Name");
                 for(int i=0;i<p_elf->getSymbolCount();i++)
                 {
                     QTableWidgetItem *newItem = (QTableWidgetItem*)new QTableWidgetIntItem(QString("%1").arg(i),DecimalItem);
                     newItem->setFlags(newItem->flags() ^ Qt::ItemIsEditable);
                     this->ui->symbolsList->setItem(i, 0, newItem);
                     newItem = (QTableWidgetItem*)new QTableWidgetIntItem(QString("0x%1").arg(p_elf->getSymbolAddress(i),8,16).replace(" ","0"),HexaDecimalItem);
                     newItem->setFlags(newItem->flags() ^ Qt::ItemIsEditable);
                     this->ui->symbolsList->setItem(i, 1, newItem);
                     newItem = (QTableWidgetItem*)new QTableWidgetIntItem(QString("%1").arg(p_elf->getSymbolSize(i)),DecimalItem);
                     newItem->setFlags(newItem->flags() ^ Qt::ItemIsEditable);
                     this->ui->symbolsList->setItem(i, 2, newItem);
                     newItem = new QTableWidgetItem(p_elf->getSymbolType(i));
                     newItem->setFlags(newItem->flags() ^ Qt::ItemIsEditable);
                     this->ui->symbolsList->setItem(i, 3, newItem);
                     newItem = new QTableWidgetItem(p_elf->getSymbolLinkType(i));
                     newItem->setFlags(newItem->flags() ^ Qt::ItemIsEditable);
                     this->ui->symbolsList->setItem(i, 4, newItem);
                     newItem = new QTableWidgetItem(p_elf->getSymbolSectionName(i));
                     newItem->setFlags(newItem->flags() ^ Qt::ItemIsEditable);
                     this->ui->symbolsList->setItem(i, 5, newItem);
                     newItem = new QTableWidgetItem(p_elf->getSymbolName(i));
                     newItem->setFlags(newItem->flags() ^ Qt::ItemIsEditable);
                     this->ui->symbolsList->setItem(i, 6, newItem);
                 }
                 this->ui->symbolsList->resizeColumnsToContents();
             }
             void elfFileWidget::updateSections()
             {
                 this->ui->sectionsList->clear();
                 this->ui->sectionsList->setRowCount(p_elf->getSectionCount());
-                this->ui->sectionsList->setHorizontalHeaderLabels(QStringList()<<"Index"<<"Name"<<"Address"<<"Size");
+                this->ui->sectionsList->setHorizontalHeaderLabels(QStringList()<<"Index"<<"Name"<<"Address"<<"Size"<<"File Size"<<"Type");
                 for(int i=0;i<p_elf->getSectionCount();i++)
                 {
                     QTableWidgetItem *newItem = (QTableWidgetItem*) new QTableWidgetIntItem(QString("%1").arg(i),DecimalItem);
                     newItem->setFlags(newItem->flags() ^ Qt::ItemIsEditable);
                     this->ui->sectionsList->setItem(i,0, newItem);
                     newItem = new QTableWidgetItem(p_elf->getSectionName(i));
                     newItem->setFlags(newItem->flags() ^ Qt::ItemIsEditable);
                     this->ui->sectionsList->setItem(i, 1, newItem);
                     newItem = (QTableWidgetItem*) new QTableWidgetIntItem(QString("0x%1").arg(p_elf->getSectionPaddr(i),8,16).replace(" ","0"),HexaDecimalItem);
                     newItem->setFlags(newItem->flags() ^ Qt::ItemIsEditable);
                     this->ui->sectionsList->setItem(i, 2, newItem);
+                    newItem = (QTableWidgetItem*) new QTableWidgetIntItem(QString("%1").arg(p_elf->getSectionMemsz(i)),DecimalItem);
+                    newItem->setFlags(newItem->flags() ^ Qt::ItemIsEditable);
+                    this->ui->sectionsList->setItem(i, 3, newItem);
                     newItem = (QTableWidgetItem*) new QTableWidgetIntItem(QString("%1").arg(p_elf->getSectionDatasz(i)),DecimalItem);
                     newItem->setFlags(newItem->flags() ^ Qt::ItemIsEditable);
-                    this->ui->sectionsList->setItem(i, 3, newItem);
+                    this->ui->sectionsList->setItem(i, 4, newItem);
+                    newItem = new QTableWidgetItem(p_elf->getSectionType(i));
+                    newItem->setFlags(newItem->flags() ^ Qt::ItemIsEditable);
+                    this->ui->sectionsList->setItem(i, 5, newItem);
                 }
                 this->ui->sectionsList->resizeColumnsToContents();
             }
             void elfFileWidget::sectionCellActivated(int row, int column)
             {
                 Q_UNUSED(column)
                 char* buff=NULL;
                 int sectionIndex = p_elf->getSectionIndex(this->ui->sectionsList->item(row,1)->text());
                 if(sectionIndex!=-1)
                 {
-                    this->p_elf->getSectionData(sectionIndex,&buff);
+                    QString type = p_elf->getSectionType(sectionIndex);
-                    this->ui->sectionsHexView->setData(QByteArray(buff,this->p_elf->getSectionDatasz(sectionIndex)));
+                    if(!p_elf->sectionIsNobits(sectionIndex))
+                    {
+                        this->p_elf->getSectionData(sectionIndex,&buff);
+                        this->ui->sectionsHexView->setData(QByteArray(buff,this->p_elf->getSectionDatasz(sectionIndex)));
+                        this->ui->sectionsHexView->setAddressOffset(this->p_elf->getSectionPaddr(sectionIndex));
+                    }
+                }
+            }
+            void elfFileWidget::exportToSREC()
+            {
+                QStringList sectionList=getSelectedSectionsNames();
+                if(sectionList.count()>0)
+                {
+                    QString fileName = QFileDialog::getSaveFileName(this, tr("Save File"),
+                                               NULL,
+                                               tr("SREC Files (*.srec)"));
+                    if(!fileName.isEmpty())
+                    {
+                        srecFile::toSrec(p_elf->getFragments(sectionList),fileName);
+                    }
                 }
+            }
+            void elfFileWidget::exportToBIN()
+            {
+            }
+            void elfFileWidget::pointSymbol()
+            {
+                int row=this->ui->symbolsList->item(this->ui->symbolsList->currentRow(),0)->text().toInt();
+                int section = p_elf->getSectionIndex(p_elf->getSymbolSectionName(row));
+                qint64 address = p_elf->getSymbolAddress(row);
+                qint64 secAddress = p_elf->getSectionPaddr(section);
+                qint64 size = p_elf->getSymbolSize(row);
+                char* buff=NULL;
+                char* symBuff=NULL;
+                if(size && !p_elf->sectionIsNobits(section))
+                {
+                    if(section!=-1)
+                    {
+                        symBuff = (char*)malloc(size);
+                        this->p_elf->getSectionData(section,&buff);
+                        memcpy(symBuff,buff+(address-secAddress),size);
+                        this->p_hexviewer->setData(QByteArray(symBuff,size));
+                        this->p_hexviewer->setAddressOffset(address);
+                        this->p_hexviewer->show();
+                    }
+                }
+            }
+            void elfFileWidget::filterSymbols(const QString &pattern)
+            {
+                Qt::MatchFlags flag = Qt::MatchContains | Qt::MatchStartsWith	| Qt::MatchEndsWith  | Qt::MatchRegExp | Qt::MatchWildcard | Qt::MatchWrap |Qt::MatchRecursive;
+                if(this->ui->caseSensitive->isChecked())
+                    flag |= Qt::MatchCaseSensitive;
+                if(pattern.isEmpty())
+                {
+                    for(int i=0;i<this->ui->symbolsList->rowCount();i++)
+                        this->ui->symbolsList->setRowHidden(i,false);
+                }
+                else
+                {
+                    for(int i=0;i<this->ui->symbolsList->rowCount();i++)
+                        this->ui->symbolsList->setRowHidden(i,true);
+                    QList<QTableWidgetItem*> items = this->ui->symbolsList->findItems(pattern,flag);
+                    for(int i=0;i<items.count();i++)
+                        this->ui->symbolsList->setRowHidden(items.at(i)->row(),false);
+                }
+            }
+            void elfFileWidget::filterSymbolsCaseUpdate(bool toggled)
+            {
+                Q_UNUSED(toggled)
+                this->filterSymbols(this->ui->symbolsFilter->text());
+            }
+            QStringList elfFileWidget::getSelectedSectionsNames()
+            {
+                QStringList sectionList;
+                QList<QTableWidgetItem*> items = this->ui->sectionsList->selectedItems();
+                for(int i=0;i<items.count();i++)
+                {
+                    QString section = p_elf->getSectionName(items.at(i)->row());
+                    if(!sectionList.contains(section))
+                    {
+                        sectionList.append(section);
+                    }
+                }
+                return sectionList;
             }

src/common/elf/elffilewidget.h +33 -1

+            /*------------------------------------------------------------------------------
+            --  This file is a part of the SocExplorer Software
+            --  Copyright (C) 2014, Plasma Physics Laboratory - CNRS
+            --
+            --  This program is free software; you can redistribute it and/or modify
+            --  it under the terms of the GNU General Public License as published by
+            --  the Free Software Foundation; either version 2 of the License, or
+            --  (at your option) any later version.
+            --
+            --  This program is distributed in the hope that it will be useful,
+            --  but WITHOUT ANY WARRANTY; without even the implied warranty of
+            --  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+            --  GNU General Public License for more details.
+            --
+            --  You should have received a copy of the GNU General Public License
+            --  along with this program; if not, write to the Free Software
+            --  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+            -------------------------------------------------------------------------------*/
+            /*--                  Author : Alexis Jeandet
+            --                     Mail : alexis.jeandet@member.fsf.org
+            ----------------------------------------------------------------------------*/
             #ifndef ELFFILEWIDGET_H
             #define ELFFILEWIDGET_H
             #include <QtWidgets/QWidget>
             #include "elffile.h"
+            #include <QtWidgets/QAction>
+            #include <qhexedit.h>
             namespace Ui {
             class elfFileWidget;
             }
             class elfFileWidget : public QWidget
             {
                 Q_OBJECT
             public:
                 elfFileWidget(QWidget *parent = 0);
                 ~elfFileWidget();
             public slots:
                 void updateElfFile(ElfFile* file);
                 void updateSymbols();
                 void updateSections();
             private slots:
                 void sectionCellActivated(int row, int column);
+                void exportToSREC();
+                void exportToBIN();
+                void pointSymbol();
+                void filterSymbols(const QString& pattern);
+                void filterSymbolsCaseUpdate(bool toggled);
             private:
                 Ui::elfFileWidget *ui;
+                QStringList getSelectedSectionsNames();
                 ElfFile* p_elf;
+                QAction* exportToSREC_action;
+                QAction* exportToBIN_action;
+                QAction* pointInSections_action;
+                QHexEdit* p_hexviewer;
             };
             #endif // ELFFILEWIDGET_H

src/common/elf/elffilewidget.ui +75 -39

             <?xml version="1.0" encoding="UTF-8"?>
             <ui version="4.0">
              <class>elfFileWidget</class>
              <widget class="QWidget" name="elfFileWidget">
               <property name="geometry">
                <rect>
                 <x>0</x>
                 <y>0</y>
                 <width>786</width>
                 <height>387</height>
                </rect>
               </property>
               <property name="minimumSize">
                <size>
                 <width>0</width>
                 <height>0</height>
                </size>
               </property>
               <property name="focusPolicy">
                <enum>Qt::NoFocus</enum>
               </property>
               <property name="windowTitle">
                <string>Form</string>
               </property>
               <layout class="QGridLayout" name="gridLayout">
                <item row="0" column="0">
                 <widget class="QTabWidget" name="tabWidget">
                  <property name="currentIndex">
-                  <number>2</number>
+                  <number>0</number>
                  </property>
                  <widget class="QWidget" name="generalInfoTab">
                   <attribute name="title">
                    <string>File Informations</string>
                   </attribute>
                   <layout class="QGridLayout" name="gridLayout_4">
                    <item row="0" column="0">
                     <widget class="QGroupBox" name="groupBox">
                      <property name="title">
                       <string>Elf header</string>
                      </property>
                      <layout class="QFormLayout" name="formLayout">
                       <item row="0" column="0">
                        <widget class="QLabel" name="label">
                         <property name="text">
                          <string>Class:</string>
                         </property>
                        </widget>
                       </item>
                       <item row="0" column="1">
                        <widget class="QLabel" name="classLabel">
                         <property name="text">
                          <string>none</string>
                         </property>
                        </widget>
                       </item>
                       <item row="1" column="0">
                        <widget class="QLabel" name="label_3">
                         <property name="text">
                          <string>Endianness:</string>
                         </property>
                        </widget>
                       </item>
                       <item row="1" column="1">
                        <widget class="QLabel" name="endiannesLabel">
                         <property name="text">
                          <string>none</string>
                         </property>
                        </widget>
                       </item>
                       <item row="2" column="0">
                        <widget class="QLabel" name="label_5">
                         <property name="text">
                          <string>Version:</string>
                         </property>
                        </widget>
                       </item>
                       <item row="3" column="0">
                        <widget class="QLabel" name="label_6">
                         <property name="text">
                          <string>Type:</string>
                         </property>
                        </widget>
                       </item>
                       <item row="4" column="0">
                        <widget class="QLabel" name="label_7">
                         <property name="text">
                          <string>Machine:</string>
                         </property>
                        </widget>
                       </item>
                       <item row="6" column="0">
                        <widget class="QLabel" name="label_8">
                         <property name="text">
                          <string>Entry point address:</string>
                         </property>
                        </widget>
                       </item>
                       <item row="2" column="1">
                        <widget class="QLabel" name="VersionLabel">
                         <property name="text">
                          <string>none</string>
                         </property>
                        </widget>
                       </item>
                       <item row="3" column="1">
                        <widget class="QLabel" name="typeLabel">
                         <property name="text">
                          <string>none</string>
                         </property>
                        </widget>
                       </item>
                       <item row="4" column="1">
                        <widget class="QLabel" name="machineLabel">
                         <property name="text">
                          <string>none</string>
                         </property>
                        </widget>
                       </item>
                       <item row="6" column="1">
                        <widget class="QLabel" name="entryPointLabel">
                         <property name="text">
                          <string>none</string>
                         </property>
                        </widget>
                       </item>
                       <item row="5" column="0">
                        <widget class="QLabel" name="label_17">
                         <property name="text">
                          <string>OS/ABI:</string>
                         </property>
                        </widget>
                       </item>
                       <item row="5" column="1">
                        <widget class="QLabel" name="abiLabel">
                         <property name="text">
                          <string>none</string>
                         </property>
                        </widget>
                       </item>
                      </layout>
                     </widget>
                    </item>
                    <item row="1" column="0">
                     <widget class="QGroupBox" name="groupBox_2">
                      <property name="title">
                       <string>Sections &amp; Symbols</string>
                      </property>
                      <layout class="QFormLayout" name="formLayout_2">
                       <item row="0" column="0">
                        <widget class="QLabel" name="label_9">
                         <property name="text">
                          <string>Section count:</string>
                         </property>
                        </widget>
                       </item>
                       <item row="1" column="0">
                        <widget class="QLabel" name="label_10">
                         <property name="text">
                          <string>Symbols count:</string>
                         </property>
                        </widget>
                       </item>
                       <item row="0" column="1">
                        <widget class="QLabel" name="sectionCountLabel">
                         <property name="text">
                          <string>none</string>
                         </property>
                        </widget>
                       </item>
                       <item row="1" column="1">
                        <widget class="QLabel" name="symbolCountLabel">
                         <property name="text">
                          <string>none</string>
                         </property>
                        </widget>
                       </item>
                      </layout>
                     </widget>
                    </item>
                   </layout>
                  </widget>
                  <widget class="QWidget" name="symbolsTab">
                   <attribute name="title">
                    <string>Symbols</string>
                   </attribute>
                   <layout class="QGridLayout" name="gridLayout_2">
+                   <item row="0" column="1">
+                    <widget class="QLineEdit" name="symbolsFilter"/>
+                   </item>
                    <item row="0" column="0">
+                    <widget class="QLabel" name="label_2">
+                     <property name="text">
+                      <string>Filter:</string>
+                     </property>
+                    </widget>
+                   </item>
+                   <item row="0" column="2">
+                    <widget class="QCheckBox" name="caseSensitive">
+                     <property name="text">
+                      <string>Case Sensitive</string>
+                     </property>
+                    </widget>
+                   </item>
+                   <item row="2" column="0" colspan="3">
                     <widget class="QTableWidget" name="symbolsList">
+                     <property name="contextMenuPolicy">
+                      <enum>Qt::ActionsContextMenu</enum>
+                     </property>
                      <property name="sortingEnabled">
                       <bool>true</bool>
                      </property>
                      <attribute name="verticalHeaderVisible">
                       <bool>false</bool>
                      </attribute>
                      <attribute name="verticalHeaderShowSortIndicator" stdset="0">
                       <bool>false</bool>
                      </attribute>
                      <column>
                       <property name="text">
                        <string>Index</string>
                       </property>
                      </column>
                      <column>
                       <property name="text">
                        <string>Value</string>
                       </property>
                      </column>
                      <column>
                       <property name="text">
                        <string>Size</string>
                       </property>
                      </column>
                      <column>
                       <property name="text">
                        <string>Type</string>
                       </property>
                      </column>
                      <column>
                       <property name="text">
                        <string>Link</string>
                       </property>
                      </column>
                      <column>
                       <property name="text">
                        <string>Section</string>
                       </property>
                      </column>
                      <column>
                       <property name="text">
                        <string>Name</string>
                       </property>
                      </column>
                     </widget>
                    </item>
                   </layout>
                  </widget>
                  <widget class="QWidget" name="sectionsTab">
                   <attribute name="title">
                    <string>Sections</string>
                   </attribute>
                   <layout class="QGridLayout" name="gridLayout_3">
                    <item row="0" column="0">
-                    <widget class="QHexEdit" name="sectionsHexView" native="true">
+                    <widget class="QSplitter" name="splitter">
-                     <property name="minimumSize">
+                     <property name="orientation">
-                      <size>
+                      <enum>Qt::Horizontal</enum>
-                       <width>100</width>
-                       <height>0</height>
-                      </size>
-                     </property>
-                    </widget>
-                   </item>
-                   <item row="0" column="1">
-                    <widget class="QTableWidget" name="sectionsList">
-                     <property name="sortingEnabled">
-                      <bool>true</bool>
                      </property>
-                     <attribute name="verticalHeaderVisible">
+                     <widget class="QHexEdit" name="sectionsHexView" native="true">
-                      <bool>false</bool>
+                      <property name="minimumSize">
-                     </attribute>
+                       <size>
-                     <attribute name="verticalHeaderShowSortIndicator" stdset="0">
+                        <width>100</width>
-                      <bool>false</bool>
+                        <height>0</height>
-                     </attribute>
+                       </size>
-                     <column>
+                      </property>
-                      <property name="text">
+                     </widget>
-                       <string>Index</string>
+                     <widget class="QTableWidget" name="sectionsList">
+                      <property name="contextMenuPolicy">
+                       <enum>Qt::ActionsContextMenu</enum>
+                      </property>
+                      <property name="sortingEnabled">
+                       <bool>true</bool>
                       </property>
-                     </column>
+                      <attribute name="verticalHeaderVisible">
-                     <column>
+                       <bool>false</bool>
-                      <property name="text">
+                      </attribute>
-                       <string>Name</string>
+                      <attribute name="verticalHeaderShowSortIndicator" stdset="0">
-                      </property>
+                       <bool>false</bool>
-                     </column>
+                      </attribute>
-                     <column>
+                      <column>
-                      <property name="text">
+                       <property name="text">
-                       <string>Address</string>
+                        <string>Index</string>
-                      </property>
+                       </property>
-                     </column>
+                      </column>
-                     <column>
+                      <column>
-                      <property name="text">
+                       <property name="text">
-                       <string>Size</string>
+                        <string>Name</string>
-                      </property>
+                       </property>
-                     </column>
+                      </column>
+                      <column>
+                       <property name="text">
+                        <string>Address</string>
+                       </property>
+                      </column>
+                      <column>
+                       <property name="text">
+                        <string>Size</string>
+                       </property>
+                      </column>
+                      <column>
+                       <property name="text">
+                        <string>File Size</string>
+                       </property>
+                      </column>
+                      <column>
+                       <property name="text">
+                        <string>Type</string>
+                       </property>
+                      </column>
+                     </widget>
                     </widget>
                    </item>
                   </layout>
                  </widget>
                 </widget>
                </item>
               </layout>
              </widget>
              <customwidgets>
               <customwidget>
                <class>QHexEdit</class>
                <extends>QWidget</extends>
                <header location="global">qhexedit.h</header>
                <container>1</container>
               </customwidget>
              </customwidgets>
              <resources/>
              <connections/>
             </ui>

src/common/elf/elfparser.cpp +11 -9

             /*------------------------------------------------------------------------------
             --  This file is a part of the SocExplorer Software
             --  Copyright (C) 2013, Plasma Physics Laboratory - CNRS
             --
             --  This program is free software; you can redistribute it and/or modify
             --  it under the terms of the GNU General Public License as published by
             --  the Free Software Foundation; either version 3 of the License, or
             --  (at your option) any later version.
             --
             --  This program is distributed in the hope that it will be useful,
             --  but WITHOUT ANY WARRANTY; without even the implied warranty of
             --  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             --  GNU General Public License for more details.
             --
             --  You should have received a copy of the GNU General Public License
             --  along with this program; if not, write to the Free Software
             --  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
             -------------------------------------------------------------------------------*/
             /*--                  Author : Alexis Jeandet
             --                     Mail : alexis.jeandet@lpp.polytechnique.fr
             ----------------------------------------------------------------------------*/
             #include "elfparser.h"
             #include <sys/types.h>
             #include <sys/stat.h>
             #include <fcntl.h>
             #include <unistd.h>
             extern QString elfresolveMachine(Elf64_Half	e_machine);
             elfparser::elfparser()
             {
                 this->opened = false;
                 this->type_elf = false;
-                this->elfFile = NULL;
+                this->elfFile = (int)NULL;
                 this->e = NULL;
             }
             int elfparser::setFilename(const QString &name)
             {
                 this->closeFile();
                 if(elf_version(EV_CURRENT)==EV_NONE)return 0;
             #ifdef _ELF_WINDOWS_
                 this->elfFile = open(name.toStdString().c_str(),O_RDONLY|O_BINARY ,0);
             #else
                 this->elfFile = open(name.toStdString().c_str(),O_RDONLY ,0);
             #endif
-                if(this->elfFile==NULL)return 0;
+                if(this->elfFile==(int)NULL)return 0;
                 this->e = elf_begin(this->elfFile,ELF_C_READ,NULL);
                 if(this->e==NULL)return 0;
                 this->ek = elf_kind(this->e);
                 gelf_getehdr (this->e, &this->ehdr );
                 elf_getshdrstrndx (this->e, &this->shstrndx);
                 this->updateSegments();
                 this->updateSections();
                 return 1;
             }
             int elfparser::closeFile()
             {
-                if(this->elfFile!=NULL)
+                if(this->elfFile!=(int)NULL)
                 {
                     if(this->e!=NULL)
                     {
                         elf_end(this->e);
                         this->e = NULL;
                     }
                     close(this->elfFile);
-                    this->elfFile = NULL;
+                    this->elfFile = (int)NULL;
                 }
                 return 0;
             }
             QString elfparser::getClass()
             {
                 if(this->e!=NULL)
                 {
                     int eclass = gelf_getclass(this->e);
                     if(eclass==ELFCLASS32)return "ELF32";
                     if(eclass==ELFCLASS64)return "ELF64";
                 }
                 return "none";
             }
             bool elfparser::isopened()
             {
                 return this->opened;
             }
             bool elfparser::iself()
             {
                 return this->type_elf;
             }
             QString elfparser::getArchitecture()
             {
                 if(this->e!=NULL)
                 {
                     return elfresolveMachine(this->ehdr.e_machine);
                 }
                 return "";
             }
             QString elfparser::getType()
             {
                 QString kind("");
                 if(this->e!=NULL)
                 {
                     switch(this->ek)
                     {
                     case ELF_K_AR:
                         kind = "Archive";
                         break;
                     case ELF_K_ELF:
                         kind = "Elf";
                         break;
                     case ELF_K_COFF:
                         kind = "COFF";
                         break;
                     case ELF_K_NUM:
                         kind = "NUM";
                         break;
                     case ELF_K_NONE:
                         kind = "Data";
                         break;
                     default:
                         kind = "Unknow";
                         break;
                     }
                 }
                 return kind;
             }
             QString elfparser::getEndianness()
             {
                 if(this->e!=NULL)
                 {
                     if(this->ehdr.e_ident[EI_DATA]==ELFDATA2LSB)return "2's complement, little endian";
                     if(this->ehdr.e_ident[EI_DATA]==ELFDATA2MSB)return "2's complement, big endian";
                 }
                 return "none";
             }
             QString elfparser::getABI()
             {
                 if(this->e!=NULL)
                 {
                     if(this->ehdr.e_ident[EI_OSABI]==ELFOSABI_NONE)return "UNIX System V ABI";
                     if(this->ehdr.e_ident[EI_OSABI]==ELFOSABI_SYSV)return "Alias";
                     if(this->ehdr.e_ident[EI_OSABI]==ELFOSABI_HPUX)return "HP-UX";
                     if(this->ehdr.e_ident[EI_OSABI]==ELFOSABI_NETBSD)return "NetBSD";
                     if(this->ehdr.e_ident[EI_OSABI]==ELFOSABI_GNU)return "Object uses GNU ELF extensions";
                     if(this->ehdr.e_ident[EI_OSABI]==ELFOSABI_LINUX)return "Compatibility alias";
                     if(this->ehdr.e_ident[EI_OSABI]==ELFOSABI_SOLARIS)return "Sun Solaris";
                     if(this->ehdr.e_ident[EI_OSABI]==ELFOSABI_AIX)return "IBM AIX";
                     if(this->ehdr.e_ident[EI_OSABI]==ELFOSABI_IRIX)return "SGI Irix";
                     if(this->ehdr.e_ident[EI_OSABI]==ELFOSABI_FREEBSD)return "FreeBSD";
                     if(this->ehdr.e_ident[EI_OSABI]==ELFOSABI_TRU64)return "Compaq TRU64 UNIX";
                     if(this->ehdr.e_ident[EI_OSABI]==ELFOSABI_MODESTO)return " Novell Modesto";
                     if(this->ehdr.e_ident[EI_OSABI]==ELFOSABI_OPENBSD)return "OpenBSD";
                     if(this->ehdr.e_ident[EI_OSABI]==ELFOSABI_ARM_AEABI)return "ARM EABI";
                     if(this->ehdr.e_ident[EI_OSABI]==ELFOSABI_ARM)return "ARM";
                     if(this->ehdr.e_ident[EI_OSABI]==ELFOSABI_STANDALONE)return "Standalone (embedded) application";
                 }
                 return "none";
             }
             qint64 elfparser::getVersion()
             {
                 if(this->e!=NULL)
                 {
                     return this->ehdr.e_version;
                 }
+                return -1;
             }
             qint64 elfparser::getEntryPointAddress()
             {
                 if(this->e!=NULL)
                 {
                     return this->ehdr.e_entry;
                 }
+                return -1;
             }
             int elfparser::getSectioncount()
             {
                 return (int)this->SectionCount;
             }
             int elfparser::getSegmentcount()
             {
                 return (int)this->SegmentCount;
             }
             QString elfparser::getSegmentType(int index)
             {
                 QString type("");
                 if(this->e!=NULL)
                 {
                     if(index < this->Segments.count())
                     {
                         switch(this->Segments.at(index)->p_type)
                         {
                         case PT_NULL:
                             type = "Program header table entry unused";
                             break;
                         case PT_LOAD:
                             type = "Loadable program segment";
                             break;
                         case PT_DYNAMIC	:
                             type = "Dynamic linking information";
                             break;
                         case PT_INTERP:
                             type ="Program interpreter";
                             break;
                         case PT_NOTE:
                             type = "Auxiliary information";
                             break;
                         case PT_SHLIB:
                             type = "Reserved";
                             break;
                         case PT_PHDR:
                             type =	"Entry for header table itself";
                             break;
                         case PT_TLS:
                             type = "Thread-local storage segment";
                             break;
                         case PT_NUM:
                             type = "Number of defined types";
                             break;
                         case PT_LOOS:
                             type =	"Start of OS-specific";
                             break;
                         case PT_SUNWSTACK:
                             type = "Stack segment";
                             break;
                         case PT_LOPROC:
                             type = "Start of processor-specific";
                             break;
                         case PT_HIPROC:
                             type = "End of processor-specific";
                             break;
                         default:
                             type = "Unknow Section Type";
                             break;
                         }
                     }
                 }
                 return type;
             }
             qint64 elfparser::getSegmentOffset(int index)
             {
-                int64_t Offset;
+                qint64 Offset=-1;
                 if(this->e!=NULL)
                 {
                     if(index < this->Segments.count())
                     {
-                        Offset =  (int64_t)this->Segments.at(index)->p_offset;
+                        Offset =  (qint64)this->Segments.at(index)->p_offset;
                     }
                 }
                 return Offset;
             }
             qint64 elfparser::getSegmentVaddr(int index)
             {
                 int64_t Vaddr = 0;
                 if(this->e!=NULL)
                 {
                     if(index < this->Segments.count())
                     {
                         Vaddr =  (int64_t)this->Segments.at(index)->p_vaddr;
                     }
                 }
                 return Vaddr;
             }
             qint64 elfparser::getSegmentPaddr(int index)
             {
                 int64_t Paddr=0;
                 if(this->e!=NULL)
                 {
                     if(index < this->Segments.count())
                     {
                         Paddr = (int64_t)this->Segments.at(index)->p_paddr;
                     }
                 }
                 return Paddr;
             }
             qint64 elfparser::getSectionPaddr(int index)
             {
                 int64_t Paddr=0;
                 if(this->e!=NULL)
                 {
                     if(index < this->sections.count())
                     {
                         Paddr = (int64_t)this->sections.at(index)->section_header->sh_addr;
                     }
                 }
                 return Paddr;
             }
             qint64 elfparser::getSegmentFilesz(int index)
             {
                 int64_t FileSz=0;
                 if(this->e!=NULL)
                 {
                     if(index < this->Segments.count())
                     {
                         FileSz = (int64_t)this->Segments.at(index)->p_filesz;
                     }
                 }
                 return FileSz;
             }
             qint64 elfparser::getSectionDatasz(int index)
             {
                 int64_t DataSz=0;
                 if(this->e!=NULL)
                 {
                     if(index < this->sections.count())
                     {
                         DataSz = (int64_t)this->sections.at(index)->data->d_size;
                     }
                 }
                 return DataSz;
             }
             bool elfparser::getSectionData(int index, char **buffer)
             {
                 if(this->e!=NULL)
                 {
                     if(index < this->sections.count())
                     {
                         *buffer = (char *)this->sections.at(index)->data->d_buf;
                         return true;
                     }
                 }
                 return false;
             }
             qint64 elfparser::getSegmentMemsz(int index)
             {
                 int64_t MemSz=0;
                 if(this->e!=NULL)
                 {
                     if(index < this->Segments.count())
                     {
                         MemSz = (int64_t)this->Segments.at(index)->p_memsz;
                     }
                 }
                 return MemSz;
             }
             qint64 elfparser::getSectionMemsz(int index)
             {
                 int64_t MemSz=0;
                 if(this->e!=NULL)
                 {
                     if(index < this->sections.count())
                     {
                         MemSz = (int64_t)this->sections.at(index)->section_header->sh_size;
                     }
                 }
                 return MemSz;
             }
             QString elfparser::getSegmentFlags(int index)
             {
                 QString flags("");
                 if(this->e!=NULL)
                 {
                     if(index < this->Segments.count())
                     {
                         if((this->Segments.at(index)->p_flags&PF_X) == PF_X)flags+="x";
                         if((this->Segments.at(index)->p_flags&PF_W) == PF_W)flags+="w";
                         if((this->Segments.at(index)->p_flags&PF_R) == PF_R)flags+="r";
                         if((this->Segments.at(index)->p_flags&PF_MASKOS) == PF_MASKOS)flags+=" OS-specific";
                         if((this->Segments.at(index)->p_flags&PF_MASKPROC) == PF_MASKPROC)flags+=" Processor-specific";
                     }
                 }
                 return flags;
             }
             QString elfparser::getSectionName(int index)
             {
                 char* nameChr = elf_strptr(this->e , this->shstrndx , this->sections.at(index)->section_header->sh_name);
                 return QString(nameChr);
             }
             void elfparser::updateSections()
             {
                 for(int i=0;i<this->sections.count();i++)
                 {
                     delete this->sections.at(i);
                 }
                 this->sections.clear();
                 this->scn = elf_nextscn (this->e , NULL );
                 this->SectionCount = 0;
                 while( this->scn != NULL )
                 {
                     GElf_Shdr* shdr = (GElf_Shdr*)malloc(sizeof(GElf_Shdr));
                     gelf_getshdr ( this->scn , shdr );
                     Elf_Data*  data = elf_getdata(this->scn, NULL);
                     this->sections.append(new Elf_Section(data,shdr));
                     this->SectionCount+=1;
                     this->scn = elf_nextscn(e , scn);
                 }
             }
             void elfparser::updateSegments()
             {
                 elf_getphdrnum (this->e , &this->SegmentCount);
                 for(int i=0;i<this->Segments.count();i++)
                 {
                     free(this->Segments.at(i));
                 }
                 this->Segments.clear();
-                for(int i=0;i<this->SegmentCount;i++)
+                for(int i=0;i<(int)this->SegmentCount;i++)
                 {
                     GElf_Phdr* header=(GElf_Phdr*)malloc(sizeof(GElf_Phdr));
                     gelf_getphdr (this->e , i , header );
                     this->Segments.append(header);
                 }
             }
             QString elfparser::getSectionType(int index)
             {
                 QString type("");
                 if(this->e!=NULL)
                 {
                     if(index < this->Segments.count())
                     {
                         switch(this->Segments.at(index)->p_type)
                         {
                         case SHT_NULL	 :	type = "Section header table entry unused"; break;
                         case SHT_PROGBITS	  :		type = "Program data"; break;
                         case SHT_SYMTAB	  :		type = "Symbol table"; break;
                         case SHT_STRTAB	  :		type = "String table"; break;
                         case SHT_RELA	  :		type = "Relocation entries with addends"; break;
                         case SHT_HASH	  :		type = "Symbol hash table"; break;
                         case SHT_DYNAMIC	 :		type = "Dynamic linking information"; break;
                         case SHT_NOTE	  :		type = "Notes"; break;
                         case SHT_NOBITS    :type = "Program space with no data (bss)"; break;
                         case SHT_REL    :type = "Relocation entries, no addends"; break;
                         case SHT_SHLIB	 :		type = "Reserved"; break;
                         case SHT_DYNSYM	  :		type = "Dynamic linker symbol table"; break;
                         case SHT_INIT_ARRAY	  :		type = "Array of constructors"; break;
                         case SHT_FINI_ARRAY	  :		type = "Array of destructors"; break;
                         case SHT_PREINIT_ARRAY :		type = "Array of pre-constructors"; break;
                         case SHT_GROUP	  :		type = "Section group"; break;
                         case SHT_SYMTAB_SHNDX  :		type = "Extended section indeces"; break;
                         case SHT_NUM		  :		type = "Number of defined types. "; break;
                         case SHT_LOOS	  :	type = "Start OS-specific. "; break;
                         case SHT_LOSUNW	  :	type = "Sun-specific low bound. "; break;
                         case SHT_SUNW_COMDAT  : type = " "; break;
                         case SHT_SUNW_syminfo  : type = " "; break;
                         case SHT_GNU_verdef	  :	type = "Version definition section. "; break;
                         case SHT_GNU_verneed	  :	type = "Version needs section. "; break;
                         case SHT_GNU_versym	  :	type = "Version symbol table. "; break;
                         case SHT_LOPROC	  :	type = "Start of processor-specific"; break;
                         case SHT_HIPROC	 :	type = "End of processor-specific"; break;
                         case SHT_HIUSER	 :	type = "End of application-specific"; break;
                         }
                     }
                 }
                 return type;
             }
             bool elfparser::isElf(const QString &File)
             {
                 int file =0;
             #ifdef _ELF_WINDOWS_
                 file = open(File.toStdString().c_str(),O_RDONLY|O_BINARY ,0);
             #else
                 file = open(File.toStdString().c_str(),O_RDONLY ,0);
             #endif
                 char Magic[4];
                 if(file!=-1)
                 {
-                    read(file,Magic,4);
+                    size_t res = read(file,Magic,4);
                     close(file);
-                    if(Magic[0]==0x7f && Magic[1]==0x45 && Magic[2]==0x4c && Magic[3]==0x46)
+                    if((res == 4) && (Magic[0]==0x7f) && (Magic[1]==0x45) && (Magic[2]==0x4c) && (Magic[3]==0x46))
                     {
                         return true;
                     }
                 }
                 return false;
             }

src/common/pythonQtOut/generated_cpp/PySocExplorer/PySocExplorer0.cpp +1123 0

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

src/common/pythonQtOut/generated_cpp/PySocExplorer/PySocExplorer0.h +126 -2

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

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

             #include <PythonQt.h>
             #include "PySocExplorer0.h"
             void PythonQt_init_PySocExplorer(PyObject* module) {
             PythonQt::priv()->registerClass(&ElfFile::staticMetaObject, "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_ElfFile>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_ElfFile>, module, 0);
             PythonQt::self()->addParentClass("ElfFile", "abstractBinFile",PythonQtUpcastingOffset<ElfFile,abstractBinFile>());
             PythonQt::priv()->registerClass(&MemSizeWdgt::staticMetaObject, "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_MemSizeWdgt>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_MemSizeWdgt>, module, 0);
             PythonQt::priv()->registerClass(&QHexEdit::staticMetaObject, "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_QHexEdit>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_QHexEdit>, module, 0);
             PythonQt::priv()->registerClass(&QHexSpinBox::staticMetaObject, "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_QHexSpinBox>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_QHexSpinBox>, module, 0);
             PythonQt::priv()->registerClass(&SocExplorerPlot::staticMetaObject, "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_SocExplorerPlot>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_SocExplorerPlot>, module, 0);
             PythonQt::priv()->registerClass(&TCP_Terminal_Client::staticMetaObject, "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_TCP_Terminal_Client>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_TCP_Terminal_Client>, module, 0);
             PythonQt::priv()->registerCPPClass("XByteArray", "", "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_XByteArray>, NULL, module, 0);
             PythonQt::priv()->registerClass(&abstractBinFile::staticMetaObject, "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_abstractBinFile>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_abstractBinFile>, module, 0);
+            PythonQt::priv()->registerClass(&binaryFile::staticMetaObject, "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_binaryFile>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_binaryFile>, module, 0);
+            PythonQt::self()->addParentClass("binaryFile", "abstractBinFile",PythonQtUpcastingOffset<binaryFile,abstractBinFile>());
+            PythonQt::priv()->registerClass(&binaryFileWidget::staticMetaObject, "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_binaryFileWidget>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_binaryFileWidget>, module, 0);
             PythonQt::priv()->registerCPPClass("codeFragment", "", "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_codeFragment>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_codeFragment>, module, 0);
             PythonQt::priv()->registerClass(&elfFileWidget::staticMetaObject, "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_elfFileWidget>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_elfFileWidget>, module, 0);
             PythonQt::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(&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 +7 0

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

src/common/pythongenerator.sh +1 -1

             #!/bin/bash
             #export QTDIR=/usr/include
             #export QTDIR=/usr/include/qt5
-            pythonqt_generator  --include-paths=./elf:./srec:/usr/include/qt5:/usr/include/qt5/QtCore:/usr/include/qt5/QtWidgets  --output-directory=pythonQtOut PySocExplorer.h pythonQtgeneratorCfg.txt
+            pythonqt_generator  --include-paths=./elf:./srec:./BinFile:/usr/include/qt5:/usr/include/qt5/QtCore:/usr/include/qt5/QtWidgets  --output-directory=pythonQtOut PySocExplorer.h pythonQtgeneratorCfg.txt

src/common/qhexedit/qhexedit.cpp +25 0

             #include <QtGui>
             #include "qhexedit.h"
             QHexEdit::QHexEdit(QWidget *parent) : QScrollArea(parent)
             {
                 qHexEdit_p = new QHexEditPrivate(this);
                 setWidget(qHexEdit_p);
                 //setWidgetResizable(true);
                 connect(qHexEdit_p, SIGNAL(currentAddressChanged(int)), this, SIGNAL(currentAddressChanged(int)));
                 connect(qHexEdit_p, SIGNAL(currentSizeChanged(int)), this, SIGNAL(currentSizeChanged(int)));
                 connect(qHexEdit_p, SIGNAL(dataChanged()), this, SIGNAL(dataChanged()));
                 connect(qHexEdit_p, SIGNAL(overwriteModeChanged(bool)), this, SIGNAL(overwriteModeChanged(bool)));
                 setFocusPolicy(Qt::NoFocus);
             }
             int QHexEdit::indexOf(const QByteArray & ba, int from) const
             {
                 return qHexEdit_p->indexOf(ba, from);
             }
             void QHexEdit::insert(int i, const QByteArray & ba)
             {
                 qHexEdit_p->insert(i, ba);
             }
             void QHexEdit::insert(int i, char ch)
             {
                 qHexEdit_p->insert(i, ch);
             }
             int QHexEdit::lastIndexOf(const QByteArray & ba, int from) const
             {
                 return qHexEdit_p->lastIndexOf(ba, from);
             }
             void QHexEdit::remove(int pos, int len)
             {
                 qHexEdit_p->remove(pos, len);
             }
             void QHexEdit::replace( int pos, int len, const QByteArray & after)
             {
                 qHexEdit_p->replace(pos, len, after);
             }
             QString QHexEdit::toReadableString()
             {
                 return qHexEdit_p->toRedableString();
             }
             QString QHexEdit::selectionToReadableString()
             {
                 return qHexEdit_p->selectionToReadableString();
             }
             void QHexEdit::setAddressArea(bool addressArea)
             {
                 qHexEdit_p->setAddressArea(addressArea);
             }
             void QHexEdit::redo()
             {
                 qHexEdit_p->redo();
             }
             void QHexEdit::undo()
             {
                 qHexEdit_p->undo();
             }
             void QHexEdit::setAddressWidth(int addressWidth)
             {
                 qHexEdit_p->setAddressWidth(addressWidth);
             }
             void QHexEdit::setAsciiArea(bool asciiArea)
             {
                 qHexEdit_p->setAsciiArea(asciiArea);
             }
             void QHexEdit::setHighlighting(bool mode)
             {
                 qHexEdit_p->setHighlighting(mode);
             }
             void QHexEdit::setAddressOffset(int offset)
             {
                 qHexEdit_p->setAddressOffset(offset);
             }
             int QHexEdit::addressOffset()
             {
                 return qHexEdit_p->addressOffset();
             }
             void QHexEdit::setCursorPosition(int cursorPos)
             {
                 // cursorPos in QHexEditPrivate is the position of the textcoursor without
                 // blanks, means bytePos*2
                 qHexEdit_p->setCursorPos(cursorPos*2);
             }
             int QHexEdit::cursorPosition()
             {
                 return qHexEdit_p->cursorPos() / 2;
             }
             void QHexEdit::setData(const QByteArray &data)
             {
                 qHexEdit_p->setData(data);
             }
             QByteArray QHexEdit::data()
             {
                 return qHexEdit_p->data();
             }
             void QHexEdit::setAddressAreaColor(const QColor &color)
             {
                 qHexEdit_p->setAddressAreaColor(color);
             }
             QColor QHexEdit::addressAreaColor()
             {
                 return qHexEdit_p->addressAreaColor();
             }
             void QHexEdit::setHighlightingColor(const QColor &color)
             {
                 qHexEdit_p->setHighlightingColor(color);
             }
             QColor QHexEdit::highlightingColor()
             {
                 return qHexEdit_p->highlightingColor();
             }
             void QHexEdit::setSelectionColor(const QColor &color)
             {
                 qHexEdit_p->setSelectionColor(color);
             }
             QColor QHexEdit::selectionColor()
             {
                 return qHexEdit_p->selectionColor();
             }
             void QHexEdit::setOverwriteMode(bool overwriteMode)
             {
                 qHexEdit_p->setOverwriteMode(overwriteMode);
             }
             bool QHexEdit::overwriteMode()
             {
                 return qHexEdit_p->overwriteMode();
             }
             void QHexEdit::setReadOnly(bool readOnly)
             {
                 qHexEdit_p->setReadOnly(readOnly);
             }
             bool QHexEdit::isReadOnly()
             {
                 return qHexEdit_p->isReadOnly();
             }
             void QHexEdit::setFont(const QFont &font)
             {
                 qHexEdit_p->setFont(font);
             }
+            void QHexEdit::resetSelection(int pos)
+            {
+                qHexEdit_p->resetSelection(pos);
+            }
+            void QHexEdit::resetSelection()
+            {
+                qHexEdit_p->resetSelection();
+            }
+            void QHexEdit::setSelection(int pos)
+            {
+                qHexEdit_p->setSelection(pos);
+            }
+            int QHexEdit::getSelectionBegin()
+            {
+                return qHexEdit_p->getSelectionBegin();
+            }
+            int QHexEdit::getSelectionEnd()
+            {
+                return qHexEdit_p->getSelectionEnd();
+            }
             const QFont & QHexEdit::font() const
             {
                 return qHexEdit_p->font();
             }

src/common/qhexedit/qhexedit.h +6 0

             #ifndef QHEXEDIT_H
             #define QHEXEDIT_H
             #include <QtGui>
             #include "qhexedit_p.h"
             #include <QHBoxLayout>
             /** \mainpage
             QHexEdit is a binary editor widget for Qt.
             \version Version 0.6.3
             \image html hexedit.png
             */
             /*! QHexEdit is a hex editor widget written in C++ for the Qt (Qt4) framework.
             It is a simple editor for binary data, just like QPlainTextEdit is for text
             data. There are sip configuration files included, so it is easy to create
             bindings for PyQt and you can use this widget also in python.
             QHexEdit takes the data of a QByteArray (setData()) and shows it. You can use
             the mouse or the keyboard to navigate inside the widget. If you hit the keys
             (0..9, a..f) you will change the data. Changed data is highlighted and can be
             accessed via data().
             Normaly QHexEdit works in the overwrite Mode. You can set overwriteMode(false)
             and insert data. In this case the size of data() increases. It is also possible
             to delete bytes (del or backspace), here the size of data decreases.
             You can select data with keyboard hits or mouse movements. The copy-key will
             copy the selected data into the clipboard. The cut-key copies also but delets
             it afterwards. In overwrite mode, the paste function overwrites the content of
             the (does not change the length) data. In insert mode, clipboard data will be
             inserted. The clipboard content is expected in ASCII Hex notation. Unknown
             characters will be ignored.
             QHexEdit comes with undo/redo functionality. All changes can be undone, by
             pressing the undo-key (usually ctr-z). They can also be redone afterwards.
             The undo/redo framework is cleared, when setData() sets up a new
             content for the editor. You can search data inside the content with indexOf()
             and lastIndexOf(). The replace() function is to change located subdata. This
             'replaced' data can also be undone by the undo/redo framework.
             This widget can only handle small amounts of data. The size has to be below 10
             megabytes, otherwise the scroll sliders ard not shown and you can't scroll any
             more.
             */
                     class QHexEdit : public QScrollArea
             {
                 Q_OBJECT
                 /*! Property data holds the content of QHexEdit. Call setData() to set the
                 content of QHexEdit, data() returns the actual content.
                 */
                 Q_PROPERTY(QByteArray data READ data WRITE setData)
                 /*! Property addressOffset is added to the Numbers of the Address Area.
                 A offset in the address area (left side) is sometimes usefull, whe you show
                 only a segment of a complete memory picture. With setAddressOffset() you set
                 this property - with addressOffset() you get the actual value.
                 */
                 Q_PROPERTY(int addressOffset READ addressOffset WRITE setAddressOffset)
                 /*! Property address area color sets (setAddressAreaColor()) the backgorund
                 color of address areas. You can also read the color (addressaAreaColor()).
                 */
                 Q_PROPERTY(QColor addressAreaColor READ addressAreaColor WRITE setAddressAreaColor)
                 /*! Porperty cursorPosition sets or gets the position of the editor cursor
                 in QHexEdit.
                 */
                 Q_PROPERTY(int cursorPosition READ cursorPosition WRITE setCursorPosition)
                 /*! Property highlighting color sets (setHighlightingColor()) the backgorund
                 color of highlighted text areas. You can also read the color
                 (highlightingColor()).
                 */
                 Q_PROPERTY(QColor highlightingColor READ highlightingColor WRITE setHighlightingColor)
                 /*! Property selection color sets (setSelectionColor()) the backgorund
                 color of selected text areas. You can also read the color
                 (selectionColor()).
                 */
                 Q_PROPERTY(QColor selectionColor READ selectionColor WRITE setSelectionColor)
                 /*! Porperty overwrite mode sets (setOverwriteMode()) or gets (overwriteMode()) the mode
                 in which the editor works. In overwrite mode the user will overwrite existing data. The
                 size of data will be constant. In insert mode the size will grow, when inserting
                 new data.
                 */
                 Q_PROPERTY(bool overwriteMode READ overwriteMode WRITE setOverwriteMode)
                 /*! Porperty readOnly sets (setReadOnly()) or gets (isReadOnly) the mode
                 in which the editor works. In readonly mode the the user can only navigate
                 through the data and select data; modifying is not possible. This
                 property's default is false.
                 */
                 Q_PROPERTY(bool readOnly READ isReadOnly WRITE setReadOnly)
                 /*! Set the font of the widget. Please use fixed width fonts like Mono or Courier.*/
                 Q_PROPERTY(QFont font READ font WRITE setFont)
             public:
                 /*! Creates an instance of QHexEdit.
                 \param parent Parent widget of QHexEdit.
                 */
                 QHexEdit(QWidget *parent = 0);
                 /*! Returns the index position of the first occurrence
                 of the byte array ba in this byte array, searching forward from index position
                 from. Returns -1 if ba could not be found. In addition to this functionality
                 of QByteArray the cursorposition is set to the end of found bytearray and
                 it will be selected.
                 */
                 int indexOf(const QByteArray & ba, int from = 0) const;
                 /*! Inserts a byte array.
                 \param i Index position, where to insert
                 \param ba byte array, which is to insert
                 In overwrite mode, the existing data will be overwritten, in insertmode ba will be
                 inserted and size of data grows.
                 */
                 void insert(int i, const QByteArray & ba);
                 /*! Inserts a char.
                 \param i Index position, where to insert
                 \param ch Char, which is to insert
                 In overwrite mode, the existing data will be overwritten, in insertmode ba will be
                 inserted and size of data grows.
                 */
                 void insert(int i, char ch);
                 /*! Returns the index position of the last occurrence
                 of the byte array ba in this byte array, searching backwards from index position
                 from. Returns -1 if ba could not be found. In addition to this functionality
                 of QByteArray the cursorposition is set to the beginning of found bytearray and
                 it will be selected.
                 */
                 int lastIndexOf(const QByteArray & ba, int from = 0) const;
                 /*! Removes len bytes from the content.
                 \param pos Index position, where to remove
                 \param len Amount of bytes to remove
                 In overwrite mode, the existing bytes will be overwriten with 0x00.
                 */
                 void remove(int pos, int len=1);
                 /*! Replaces len bytes from index position pos with the byte array after.
                 */
                 void replace( int pos, int len, const QByteArray & after);
                 /*! Gives back a formatted image of the content of QHexEdit
                 */
                 QString toReadableString();
                 /*! Gives back a formatted image of the selected content of QHexEdit
                 */
                 QString selectionToReadableString();
                 /*! \cond docNever */
                 void setAddressOffset(int offset);
                 int addressOffset();
                 void setCursorPosition(int cusorPos);
                 int cursorPosition();
                 void setData(QByteArray const &data);
                 QByteArray data();
                 void setAddressAreaColor(QColor const &color);
                 QColor addressAreaColor();
                 void setHighlightingColor(QColor const &color);
                 QColor highlightingColor();
                 void setSelectionColor(QColor const &color);
                 QColor selectionColor();
                 void setOverwriteMode(bool);
                 bool overwriteMode();
                 void setReadOnly(bool);
                 bool isReadOnly();
                 const QFont &font() const;
                 void setFont(const QFont &);
                 /*! \endcond docNever */
+                //Added by Alexis Jeandet to manage selection outside of qhexedit
+                void resetSelection(int pos);       // set selectionStart and selectionEnd to pos
+                void resetSelection();              // set selectionEnd to selectionStart
+                void setSelection(int pos);         // set min (if below init) or max (if greater init)
+                int getSelectionBegin();
+                int getSelectionEnd();
             public slots:
                 /*! Redoes the last operation. If there is no operation to redo, i.e.
                   there is no redo step in the undo/redo history, nothing happens.
                   */
                 void redo();
                 /*! Set the minimum width of the address area.
                   \param addressWidth Width in characters.
                   */
                 void setAddressWidth(int addressWidth);
                 /*! Switch the address area on or off.
                   \param addressArea true (show it), false (hide it).
                   */
                 void setAddressArea(bool addressArea);
                 /*! Switch the ascii area on or off.
                   \param asciiArea true (show it), false (hide it).
                   */
                 void setAsciiArea(bool asciiArea);
                 /*! Switch the highlighting feature on or of.
                   \param mode true (show it), false (hide it).
                   */
                 void setHighlighting(bool mode);
                 /*! Undoes the last operation. If there is no operation to undo, i.e.
                   there is no undo step in the undo/redo history, nothing happens.
                   */
                 void undo();
             signals:
                 /*! Contains the address, where the cursor is located. */
                 void currentAddressChanged(int address);
                 /*! Contains the size of the data to edit. */
                 void currentSizeChanged(int size);
                 /*! The signal is emited every time, the data is changed. */
                 void dataChanged();
                 /*! The signal is emited every time, the overwrite mode is changed. */
                 void overwriteModeChanged(bool state);
             private:
                 /*! \cond docNever */
                 QHexEditPrivate *qHexEdit_p;
                 QHBoxLayout *layout;
                 QScrollArea *scrollArea;
                 /*! \endcond docNever */
             };
             #endif

src/common/qhexedit/qhexedit_p.h +7 -5

             #ifndef QHEXEDIT_P_H
             #define QHEXEDIT_P_H
             /** \cond docNever */
             #include <QtGui>
             #include "xbytearray.h"
             #include <QWidget>
             #include <QObject>
             #include <QScrollArea>
             #include <QUndoStack>
             class QHexEditPrivate : public QWidget
             {
             Q_OBJECT
             public:
                 QHexEditPrivate(QScrollArea *parent);
                 void setAddressAreaColor(QColor const &color);
                 QColor addressAreaColor();
                 void setAddressOffset(int offset);
                 int addressOffset();
                 void setCursorPos(int position);
                 int cursorPos();
                 void setData(QByteArray const &data);
                 QByteArray data();
                 void setHighlightingColor(QColor const &color);
                 QColor highlightingColor();
                 void setOverwriteMode(bool overwriteMode);
                 bool overwriteMode();
                 void setReadOnly(bool readOnly);
                 bool isReadOnly();
                 void setSelectionColor(QColor const &color);
                 QColor selectionColor();
                 XByteArray & xData();
                 int indexOf(const QByteArray & ba, int from = 0);
                 void insert(int index, const QByteArray & ba);
                 void insert(int index, char ch);
                 int lastIndexOf(const QByteArray & ba, int from = 0);
                 void remove(int index, int len=1);
                 void replace(int index, char ch);
                 void replace(int index, const QByteArray & ba);
                 void replace(int pos, int len, const QByteArray & after);
                 void setAddressArea(bool addressArea);
                 void setAddressWidth(int addressWidth);
                 void setAsciiArea(bool asciiArea);
                 void setHighlighting(bool mode);
                 virtual void setFont(const QFont &font);
                 void undo();
                 void redo();
                 QString toRedableString();
                 QString selectionToReadableString();
+                void resetSelection(int pos);       // set selectionStart and selectionEnd to pos
+                void resetSelection();              // set selectionEnd to selectionStart
+                void setSelection(int pos);         // set min (if below init) or max (if greater init)
+                int getSelectionBegin();
+                int getSelectionEnd();
             signals:
                 void currentAddressChanged(int address);
                 void currentSizeChanged(int size);
                 void dataChanged();
                 void overwriteModeChanged(bool state);
             protected:
                 void keyPressEvent(QKeyEvent * event);
                 void mouseMoveEvent(QMouseEvent * event);
                 void mousePressEvent(QMouseEvent * event);
                 void paintEvent(QPaintEvent *event);
                 int cursorPos(QPoint pos);          // calc cursorpos from graphics position. DOES NOT STORE POSITION
-                void resetSelection(int pos);       // set selectionStart and selectionEnd to pos
-                void resetSelection();              // set selectionEnd to selectionStart
-                void setSelection(int pos);         // set min (if below init) or max (if greater init)
-                int getSelectionBegin();
-                int getSelectionEnd();
             private slots:
                 void updateCursor();
             private:
                 void adjust();
                 void ensureVisible();
                 QColor _addressAreaColor;
                 QColor _highlightingColor;
                 QColor _selectionColor;
                 QScrollArea *_scrollArea;
                 QTimer _cursorTimer;
                 QUndoStack *_undoStack;
                 XByteArray _xData;                      // Hält den Inhalt des Hex Editors
                 bool _blink;                            // true: then cursor blinks
                 bool _renderingRequired;                // Flag to store that rendering is necessary
                 bool _addressArea;                      // left area of QHexEdit
                 bool _asciiArea;                        // medium area
                 bool _highlighting;                     // highlighting of changed bytes
                 bool _overwriteMode;
                 bool _readOnly;                         // true: the user can only look and navigate
                 int _charWidth, _charHeight;            // char dimensions (dpendend on font)
                 int _cursorX, _cursorY;                 // graphics position of the cursor
                 int _cursorPosition;                    // character positioin in stream (on byte ends in to steps)
                 int _xPosAdr, _xPosHex, _xPosAscii;     // graphics x-position of the areas
                 int _selectionBegin;                    // First selected char
                 int _selectionEnd;                      // Last selected char
                 int _selectionInit;                     // That's, where we pressed the mouse button
                 int _size;
             };
             /** \endcond docNever */
             #endif

src/common/srec/srecfile.cpp +22 0

+            /*------------------------------------------------------------------------------
+            --  This file is a part of the SocExplorer Software
+            --  Copyright (C) 2014, Plasma Physics Laboratory - CNRS
+            --
+            --  This program is free software; you can redistribute it and/or modify
+            --  it under the terms of the GNU General Public License as published by
+            --  the Free Software Foundation; either version 2 of the License, or
+            --  (at your option) any later version.
+            --
+            --  This program is distributed in the hope that it will be useful,
+            --  but WITHOUT ANY WARRANTY; without even the implied warranty of
+            --  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+            --  GNU General Public License for more details.
+            --
+            --  You should have received a copy of the GNU General Public License
+            --  along with this program; if not, write to the Free Software
+            --  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+            -------------------------------------------------------------------------------*/
+            /*--                  Author : Alexis Jeandet
+            --                     Mail : alexis.jeandet@member.fsf.org
+            ----------------------------------------------------------------------------*/
             #include "srecfile.h"
             #include <QTextStream>
             srecFile::srecFile()
             {
             }
             srecFile::srecFile(const QString &File)
             {
                 openFile(File);
             }
             srecFile::srecFile(const QStringList &Files)
             {
                 openFiles(Files);
             }
             srecFile::~srecFile()
             {
             }
             bool srecFile::openFile(const QString &File)
             {
                 return openFiles(QStringList()<<File);
             }
             bool srecFile::openFiles(const QStringList &Files)
             {
                 this->p_fileNames.clear();
                 this->p_fileNames.append(Files);
                 for(int i=0;i<p_files.count();i++)
                 {
                     delete p_files.at(i);
                 }
                 this->p_files.clear();
                 for(int i=0;i<Files.count();i++)
                 {
                     this->p_isSrec=true;
                     this->p_isSrec &= isSREC(Files.at(i));
                     this->p_files.append(new QFile(Files.at(i)));
                     this->p_files.at(i)->open(QIODevice::ReadOnly);
                     parseFile(this->p_files.at(i));
                 }
                 return true;
             }
             bool srecFile::isopened()
             {
                 bool opened = true;
                 for(int i=0;i<this->p_files.count();i++)
                 {
                     opened &= p_files.at(i)->isOpen();
                 }
                 return opened;
             }
             int srecFile::closeFile()
             {
                 for(int i=0;i<p_files.count();i++)
                 {
                     delete p_files.at(i);
                 }
                 p_files.clear();
                 p_fileName.clear();
+                return 0;
             }
             QList<codeFragment *> srecFile::getFragments()
             {
                 return p_fragments;
             }
             bool srecFile::toSrec(QList<codeFragment *> fragments, const QString &File)
             {
                 QString line;
                 QFile file(File);
                 file.open(QIODevice::WriteOnly);
                 if(file.isOpen())
                 {
                     QTextStream stream( &file );
                     //First build header
                     line.append("S0");
                     line.append(QString("%1").arg(File.count()+3,2,16).replace(' ','0'));
                     line.append("0000");
                     for(int i=0;i<File.count();i++)
                     {
                         line.append(QString("%1").arg((uchar)File.at(i).toLatin1(),2,16).replace(' ','0'));
                     }
                     line.append(QString("%1").arg((uchar)srecFile::lineCheckSum(line),2,16).replace(' ','0'));
                     line.append('\n');
                     stream << line.toUpper();
                     for(int i=0;i<fragments.count();i++)
                     {
                         codeFragment *fragment = fragments.at(i);
                         for(int j=0;j<(int)(fragment->size);j+=16)
                         {
                             line.clear();
                             line.append("S315");
                             line.append(QString("%1").arg(fragment->address+j,8,16).replace(' ','0'));
                             for(int k=0;k<16;k++)
                             {
                                 line.append(QString("%1").arg((uchar)fragment->data[j+k],2,16).replace(' ','0'));
                             }
                             line.append(QString("%1").arg((uchar)srecFile::lineCheckSum(line),2,16).replace(' ','0'));
                             line.append('\n');
                             stream << line.toUpper();
                         }
                         int rem = fragment->size%16;
                         if(rem)
                         {
                             line.clear();
                             line.append("S3");
                             line.append(QString("%1").arg(rem,2,16).replace(' ','0'));
                             line.append(QString("%1").arg(fragment->address+fragment->size-rem,8,16).replace(' ','0'));
                             for(int k=0;k<rem;k++)
                             {
                                 line.append(QString("%1").arg((uchar)fragment->data[fragment->size-rem+k],2,16).replace(' ','0'));
                             }
                             line.append(QString("%1").arg((uchar)srecFile::lineCheckSum(line),2,16).replace(' ','0'));
                             line.append('\n');
                             stream << line.toUpper();
                         }
                         line.clear();
                         line.append("S705");
                         line.append(QString("%1").arg(fragment->address,8,16).replace(' ','0'));
                         line.append(QString("%1").arg((uchar)srecFile::lineCheckSum(line),2,16).replace(' ','0'));
                         line.append('\n');
                         stream << line.toUpper();
                     }
                     file.close();
                     return true;
                 }
                 return false;
             }
             int srecFile::lineCount()
             {
                 return p_lineCount;
             }
             int srecFile::getFragmentsCount()
             {
                 return p_fragments.count();
             }
             int srecFile::getFragmentAddress(int index)
             {
                 if((index < p_fragments.count()) && (index>=0))
                 {
                     return p_fragments.at(index)->address;
                 }
                 return 0;
             }
             int srecFile::getFragmentSize(int index)
             {
                 if((index < p_fragments.count()) && (index>=0))
                 {
                     return p_fragments.at(index)->size;
                 }
                 return 0;
             }
             QString srecFile::getFragmentHeader(int index)
             {
                 if((index < p_fragments.count()) && (index>=0))
                 {
                     return p_fragments.at(index)->header;
                 }
                 return "";
             }
             bool srecFile::getFragmentData(int index, char **buffer)
             {
                 if((index < p_fragments.count()) && (index>=0))
                 {
                     *buffer = (char *)this->p_fragments.at(index)->data;
                     return true;
                 }
                 return false;
             }
             bool srecFile::isSREC()
             {
                 return p_isSrec & isopened();
             }
             bool srecFile::isSREC(const QString &File)
             {
                 QFile file(File);
                 file.open(QIODevice::ReadOnly);
                 if(file.isOpen())
                 {
                     file.seek(0);
                     QString line=file.readLine();
                     file.close();
                     return ((line.at(0)=='S')&&(line.at(1)=='0'));
                 }
                 return false;
             }
             void srecFile::parseFile(QFile *file)
             {
                 if(file->isOpen())
                 {
                     this->p_lineCount = 0;
                     file->seek(0);
                     codeFragment* fragment=NULL;
                     QByteArray data;
                     quint64 size=0;
                     quint64 address=-1;
                     QString header;
                     while (!file->atEnd())
                     {
                         QString line = file->readLine();
                         p_lineCount++;
                         if(line.count()>4)
                         {
                             if(line.at(0)=='S')
                             {
                                 bool ok;
                                 int count = line.mid(2,2).toInt(&ok,16);
                                 if(line.at(1)=='0')
                                 {
                                     header.clear();
                                     for(int i=0;i<(count-3);i++)
                                     {
                                         header.append((char)line.mid((2*i)+8,2).toInt(&ok,16));
                                     }
                                 }
                                 if(line.at(1)=='1')
                                 {
                                 }
                                 if(line.at(1)=='2')
                                 {
                                 }
                                 if(line.at(1)=='3')
                                 {
                                     int naddress =line.mid(4,8).toInt(&ok,16);
                                     if(address !=naddress)
                                     {
                                         if(fragment!=NULL)
                                         {
                                             fragment->size = data.size();
                                             fragment->data = (char*)malloc(data.size());
                                             for(int i =0;i<data.size();i++)
                                             {
                                                 fragment->data[i]=data.at(i);
                                             }
                                             data.clear();
                                             p_fragments.append(fragment);
                                         }
                                         fragment = new codeFragment();
                                         fragment->address = naddress;
                                         fragment->header = header;
                                     }
                                     address = naddress+count-5;
                                     for(int i=0;i<(count-5);i++)
                                     {
                                         data.append((char)line.mid((2*i)+12,2).toInt(&ok,16));
                                     }
                                 }
                                 if(line.at(1)=='5')
                                 {
                                 }
                                 if(line.at(1)=='6')
                                 {
                                 }
                                 if(line.at(1)=='7')
                                 {
                                 }
                                 if(line.at(1)=='8')
                                 {
                                 }
                                 if(line.at(1)=='9')
                                 {
                                 }
                             }
                         }
                     }
                     if(data.size()!=0)
                     {
                         fragment->size = data.size();
                         fragment->data = (char*)malloc(data.size());
                         for(int i =0;i<data.size();i++)
                         {
                             fragment->data[i]=data.at(i);
                         }
                         data.clear();
                         p_fragments.append(fragment);
                     }
                 }
             }
             char srecFile::lineCheckSum(const QString &line)
             {
                 char sum=0;
                 QString localLine = line;
                 bool ok;
                 if(localLine.at(0)=='S') // then should skip the first two digits
                 {
                     localLine.remove(0,2);
                 }
                 for(int i=0;i<localLine.count();i+=2)
                 {
                     sum+=(char)(localLine.mid(i,2).toInt(&ok,16));
                 }
                 return ~sum;
             }

src/common/srec/srecfile.h +21 0

+            /*------------------------------------------------------------------------------
+            --  This file is a part of the SocExplorer Software
+            --  Copyright (C) 2014, Plasma Physics Laboratory - CNRS
+            --
+            --  This program is free software; you can redistribute it and/or modify
+            --  it under the terms of the GNU General Public License as published by
+            --  the Free Software Foundation; either version 2 of the License, or
+            --  (at your option) any later version.
+            --
+            --  This program is distributed in the hope that it will be useful,
+            --  but WITHOUT ANY WARRANTY; without even the implied warranty of
+            --  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+            --  GNU General Public License for more details.
+            --
+            --  You should have received a copy of the GNU General Public License
+            --  along with this program; if not, write to the Free Software
+            --  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+            -------------------------------------------------------------------------------*/
+            /*--                  Author : Alexis Jeandet
+            --                     Mail : alexis.jeandet@member.fsf.org
+            ----------------------------------------------------------------------------*/
             #ifndef SRECFILE_H
             #define SRECFILE_H
             #include <QObject>
             #include <abstractbinfile.h>
             #include <QFile>
             #include <QStringList>
             class srecFile : public abstractBinFile
             {
                 Q_OBJECT
             public:
                 explicit srecFile();
                 srecFile(const QString& File);
                 srecFile(const QStringList& Files);
                 ~srecFile();
                 bool openFile(const QString& File);
                 bool openFiles(const QStringList& Files);
                 bool isopened();
                 int closeFile();
                 QList<codeFragment*> getFragments();
                 static bool toSrec(QList<codeFragment*> fragments,const QString& File);
                 int lineCount();
                 int getFragmentsCount();
                 int getFragmentAddress(int index);
                 int getFragmentSize(int index);
                 QString getFragmentHeader(int index);
                 bool getFragmentData(int index, char **buffer);
                 bool isSREC();
                 static bool isSREC(const QString& File);
             signals:
             public slots:
             private:
                 void parseFile(QFile* file);
                 static char lineCheckSum(const QString& line);
                 QStringList p_fileNames;
                 QList<QFile*>p_files;
                 QList<codeFragment*> p_fragments;
                 int p_lineCount;
                 bool p_isSrec;
             };
             #endif // SRECFILE_H

src/common/srec/srecfilewidget.cpp +23 0

+            /*------------------------------------------------------------------------------
+            --  This file is a part of the SocExplorer Software
+            --  Copyright (C) 2014, Plasma Physics Laboratory - CNRS
+            --
+            --  This program is free software; you can redistribute it and/or modify
+            --  it under the terms of the GNU General Public License as published by
+            --  the Free Software Foundation; either version 2 of the License, or
+            --  (at your option) any later version.
+            --
+            --  This program is distributed in the hope that it will be useful,
+            --  but WITHOUT ANY WARRANTY; without even the implied warranty of
+            --  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+            --  GNU General Public License for more details.
+            --
+            --  You should have received a copy of the GNU General Public License
+            --  along with this program; if not, write to the Free Software
+            --  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+            -------------------------------------------------------------------------------*/
+            /*--                  Author : Alexis Jeandet
+            --                     Mail : alexis.jeandet@member.fsf.org
+            ----------------------------------------------------------------------------*/
             #include "srecfilewidget.h"
             #include "ui_srecfilewidget.h"
             #include <QTableWidgetItem>
             #include <qtablewidgetintitem.h>
             srecFileWidget::srecFileWidget(QWidget *parent) :
                 QWidget(parent),
                 ui(new Ui::srecFileWidget)
             {
                 ui->setupUi(this);
                 connect(this->ui->fragmentsList,SIGNAL(cellActivated(int,int)),this,SLOT(recordCellActivated(int,int)));
+                this->setWindowTitle("SocExplorer SREC viewer");
             }
             srecFileWidget::~srecFileWidget()
             {
                 delete ui;
             }
             void srecFileWidget::updatSrecFile(srecFile *file)
             {
                 this->p_srec = file;
                 if(p_srec->isopened() && p_srec->isSREC())
                 {
                     updateRecords();
                 }
             }
             void srecFileWidget::updateRecords()
             {
                 this->ui->fragmentsList->clear();
                 this->ui->fragmentsList->setRowCount(p_srec->getFragmentsCount());
                 this->ui->fragmentsList->setHorizontalHeaderLabels(QStringList()<<"Index"<<"Address"<<"Size"<<"Header");
                 for(int i=0;i<p_srec->getFragmentsCount();i++)
                 {
                     QTableWidgetItem *newItem = (QTableWidgetItem*)new QTableWidgetIntItem(QString("%1").arg(i),DecimalItem);
                     newItem->setFlags(newItem->flags() ^ Qt::ItemIsEditable);
                     this->ui->fragmentsList->setItem(i, 0, newItem);
                     newItem = (QTableWidgetItem*)new QTableWidgetIntItem(QString("0x%1").arg(p_srec->getFragmentAddress(i),8,16).replace(" ","0"),HexaDecimalItem);
                     newItem->setFlags(newItem->flags() ^ Qt::ItemIsEditable);
                     this->ui->fragmentsList->setItem(i, 1, newItem);
                     newItem = (QTableWidgetItem*)new QTableWidgetIntItem(QString("%1").arg(p_srec->getFragmentSize(i)),DecimalItem);
                     newItem->setFlags(newItem->flags() ^ Qt::ItemIsEditable);
                     this->ui->fragmentsList->setItem(i, 2, newItem);
                     newItem = new QTableWidgetItem(p_srec->getFragmentHeader(i));
                     newItem->setFlags(newItem->flags() ^ Qt::ItemIsEditable);
                     this->ui->fragmentsList->setItem(i, 3, newItem);
                 }
                 this->ui->fragmentsList->resizeColumnsToContents();
             }
             void srecFileWidget::recordCellActivated(int row, int column)
             {
                 Q_UNUSED(column)
                 char* buff=NULL;
                 int index = this->ui->fragmentsList->item(row,0)->text().toInt();
                 if(index!=-1)
                 {
                     this->p_srec->getFragmentData(index,&buff);
                     this->ui->fragmentHexView->setData(QByteArray(buff,this->p_srec->getFragmentSize(index)));
+                    this->ui->fragmentHexView->setAddressOffset(this->p_srec->getFragmentAddress(index));
                 }
             }

src/common/srec/srecfilewidget.h +21 0

+            /*------------------------------------------------------------------------------
+            --  This file is a part of the SocExplorer Software
+            --  Copyright (C) 2014, Plasma Physics Laboratory - CNRS
+            --
+            --  This program is free software; you can redistribute it and/or modify
+            --  it under the terms of the GNU General Public License as published by
+            --  the Free Software Foundation; either version 2 of the License, or
+            --  (at your option) any later version.
+            --
+            --  This program is distributed in the hope that it will be useful,
+            --  but WITHOUT ANY WARRANTY; without even the implied warranty of
+            --  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+            --  GNU General Public License for more details.
+            --
+            --  You should have received a copy of the GNU General Public License
+            --  along with this program; if not, write to the Free Software
+            --  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+            -------------------------------------------------------------------------------*/
+            /*--                  Author : Alexis Jeandet
+            --                     Mail : alexis.jeandet@member.fsf.org
+            ----------------------------------------------------------------------------*/
             #ifndef SRECFILEWIDGET_H
             #define SRECFILEWIDGET_H
             #include <QWidget>
             #include "srecfile.h"
             namespace Ui {
             class srecFileWidget;
             }
             class srecFileWidget : public QWidget
             {
                 Q_OBJECT
             public:
                 explicit srecFileWidget(QWidget *parent = 0);
                 ~srecFileWidget();
             public slots:
                 void updatSrecFile(srecFile* file);
                 void updateRecords();
             private slots:
                 void recordCellActivated(int row, int column);
             private:
                 Ui::srecFileWidget *ui;
                 srecFile* p_srec;
             };
             #endif // SRECFILEWIDGET_H

src/common/srec/srecfilewidget.ui +51 -48

@@ -1,81 +1,84
1	<?xml version="1.0" encoding="UTF-8"?>	1	<?xml version="1.0" encoding="UTF-8"?>
2	<ui version="4.0">	2	<ui version="4.0">
3	<class>srecFileWidget</class>	3	<class>srecFileWidget</class>
4	<widget class="QWidget" name="srecFileWidget">	4	<widget class="QWidget" name="srecFileWidget">
5	<property name="geometry">	5	<property name="geometry">
6	<rect>	6	<rect>
7	<x>0</x>	7	<x>0</x>
8	<y>0</y>	8	<y>0</y>
9	<width>740</width>	9	<width>740</width>
10	<height>516</height>	10	<height>516</height>
11	</rect>	11	</rect>
12	</property>	12	</property>
13	<property name="windowTitle">	13	<property name="windowTitle">
14	<string>Form</string>	14	<string>Form</string>
15	</property>	15	</property>
16	<layout class="QGridLayout" name="gridLayout">	16	<layout class="QGridLayout" name="gridLayout">
17	<item row="0" column="1">	17	<item row="0" column="0">
18	<widget class="Q~~GroupBox" name="groupBox_2~~">	18	<widget class="QSplitter" name="splitter">
19	<property name="~~title~~">	19	<property name="orientation">
20	<string>SREC records list</string>	20	<enum>Qt::Horizontal</enum>
21	</property>	21	</property>
22	<~~layout class="QVBoxLayout" name="verticalLayout_2~~">	22	<widget class="QGroupBox" name="groupBox">
23	<item>	23	<property name="title">
24	<widget class="QTableWidget" name="fragmentsList">	24	<string>Hexadecimal Viewer</string>
25	<column>	25	</property>
26	<property name="text">	26	<layout class="QVBoxLayout" name="verticalLayout">
27	<string>Index</string>	27	<item>
28	</property>	28	<widget class="QHexEdit" name="fragmentHexView" native="true">
29	</column>	29	<property name="minimumSize">
30	~~<column~~>	30	<size>
31	<property name="text">	31	<width>256</width>
32	<string>Address</string>	32	<height>0</height>
33	~~</property~~>	33	</size>
34	</column>
35	<column>
36	<property name="text">
37	<string>Size</string>
38	</property>	34	</property>
39	</~~column~~>	35	</widget>
40	~~<column~~>	36	</item>
41	<property name="text">	37	</layout>
42	<string>Header</string>	38	</widget>
43	</property>	39	<widget class="QGroupBox" name="groupBox_2">
44	</column>	40	<property name="title">
45	</widget>	41	<string>SREC records list</string>
46	</~~item~~>	42	</property>
47	</layout>	43	<layout class="QVBoxLayout" name="verticalLayout_2">
48	~~</widget~~>	44	<item>
49	</item>	45	<widget class="QTableWidget" name="fragmentsList">
50	<item row="0" column="0">	46	<column>
51	<widget class="QGroupBox" name="groupBox">	47	<property name="text">
52	<property name="title">	48	<string>Index</string>
53	<string>Hexadecimal Viewer</string>	49	</property>
54	</property>	50	</column>
55	<layout class="QVBoxLayout" name="verticalLayout">	51	<column>
56	<item>	52	<property name="text">
57	<widget class="QHexEdit" name="fragmentHexView" native="true">	53	<string>Address</string>
58	<property ~~name="minimumSize"~~>	54	</property>
59	<~~size~~>	55	</column>
60	<width>256</width>	56	<column>
61	<height>0</height>	57	<property name="text">
62	</size>	58	<string>Size</string>
63	</property>	59	</property>
64	</widget>	60	</column>
65	~~</item~~>	61	<column>
66	</layout>	62	<property name="text">
		63	<string>Header</string>
		64	</property>
		65	</column>
		66	</widget>
		67	</item>
		68	</layout>
		69	</widget>
67	</widget>	70	</widget>
68	</item>	71	</item>
69	</layout>	72	</layout>
70	</widget>	73	</widget>
71	<customwidgets>	74	<customwidgets>
72	<customwidget>	75	<customwidget>
73	<class>QHexEdit</class>	76	<class>QHexEdit</class>
74	<extends>QWidget</extends>	77	<extends>QWidget</extends>
75	<header location="global">qhexedit.h</header>	78	<header location="global">qhexedit.h</header>
76	<container>1</container>	79	<container>1</container>
77	</customwidget>	80	</customwidget>
78	</customwidgets>	81	</customwidgets>
79	<resources/>	82	<resources/>
80	<connections/>	83	<connections/>
81	</ui>	84	</ui>

src/src.pro +1 0

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

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