HG_REPOSITORIES/LPP/INSTRUMENTATION/SocExplorer Commit - r51:c839740ef520

Abstract Binary files tools WIP.

jeandet -

r51:c839740ef520 default

parent child

Context file:

r51:c839740ef520

Collapse all files

src/common/BinFile/binaryfile.cpp +33 -7

             /*------------------------------------------------------------------------------
             --  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 "binaryfile.h"
+            #include "srecfile.h"
             binaryFile::binaryFile()
             {
             }
             binaryFile::binaryFile(const QString &File)
             {
                 openFile(File);
             }
             binaryFile::binaryFile(const QStringList &Files)
             {
                 openFiles(Files);
             }
             binaryFile::~binaryFile()
             {
             }
             bool binaryFile::openFile(const QString &File)
             {
                 return openFiles(QStringList()<<File);
             }
             bool binaryFile::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_files.append(new QFile(Files.at(i)));
                     this->p_files.at(i)->open(QIODevice::ReadOnly);
                     loadFile(this->p_files.at(i));
                 }
                 return true;
             }
             bool binaryFile::isopened()
             {
                 bool opened = true;
                 for(int i=0;i<this->p_files.count();i++)
                 {
                     opened &= p_files.at(i)->isOpen();
                 }
                 return opened;
             }
             int binaryFile::closeFile()
             {
                 for(int i=0;i<p_files.count();i++)
                 {
                     delete p_files.at(i);
                     for(int j=0;j<p_fragments.count();j++)
                     {
                         if(p_fragments.at(j)->header == p_files.at(i)->fileName())
                         {
                             codeFragment* fragment = p_fragments.at(j);
                             p_fragments.removeAt(j);
                             free(fragment->data);
                             delete fragment;
                         }
                     }
                 }
                 p_files.clear();
                 p_fileName.clear();
                 return 0;
             }
             QList<codeFragment *> binaryFile::getFragments()
             {
                 return p_fragments;
             }
             int binaryFile::getFragmentsCount()
             {
                 return p_fragments.count();
             }
             int binaryFile::getFragmentAddress(int index)
             {
                 if((index>=0)&&(index<p_fragments.count()))
                     return p_fragments.at(index)->address;
                 return 0;
             }
             int binaryFile::getFragmentSize(int index)
             {
                 if((index>=0)&&(index<p_fragments.count()))
                     return p_fragments.at(index)->size;
                 return 0;
             }
             QString binaryFile::getFragmentHeader(int index)
             {
                 if((index>=0)&&(index<p_fragments.count()))
                     return p_fragments.at(index)->header;
                 return "";
             }
+            codeFragment *binaryFile::getFragment(int index)
+            {
+                if((index>=0)&&(index<p_fragments.count()))
+                    return p_fragments.at(index);
+                return NULL;
+            }
             bool binaryFile::getFragmentData(int index, char **buffer)
             {
                 if((index>=0)&&(index<p_fragments.count()))
                 {
                     *buffer = p_fragments.at(index)->data;
                     return true;
                 }
                 return false;
             }
+            bool binaryFile::toSrec(const QString &fileName)
+            {
+                srecFile::toSrec(p_fragments,fileName);
+            }
+            bool binaryFile::toBinary(const QString &fileName)
+            {
+                toBinary(p_fragments,fileName);
+            }
+            bool binaryFile::toBinary(QList<codeFragment *> fragments, const QString &File)
+            {
+                QFile file(File);
+                file.open(QIODevice::WriteOnly);
+                if(file.isOpen())
+                {
+                    for(int i=0;i<fragments.count();i++)
+                    {
+                        file.write(fragments.at(i)->data,fragments.at(i)->size);
+                    }
+                    return true;
+                }
+                return false;
+            }
             void binaryFile::loadFile(QFile *file)
             {
                 if (file->isOpen())
                 {
                     codeFragment* fragment = new codeFragment();
                     fragment->header = file->fileName();
                     fragment->address = 0;
                     fragment->size = file->size();
                     fragment->data = (char*)malloc(file->size());
                     file->read(fragment->data,file->size());
                     p_fragments.append(fragment);
                 }
             }

src/common/BinFile/binaryfile.h +5 -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 BINARYFILE_H
             #define BINARYFILE_H
             #include "abstractbinfile.h"
             #include <QObject>
             #include <QString>
             #include <QList>
             #include <QStringList>
             #include <QFile>
             class binaryFile : public abstractBinFile
             {
                 Q_OBJECT
             public:
                 explicit binaryFile();
                 binaryFile(const QString& File);
                 binaryFile(const QStringList& Files);
                 ~binaryFile();
                 bool openFile(const QString& File);
                 bool openFiles(const QStringList& Files);
                 bool isopened();
                 int closeFile();
                 QList<codeFragment*> getFragments();
                 int getFragmentsCount();
                 int getFragmentAddress(int index);
                 int getFragmentSize(int index);
                 QString getFragmentHeader(int index);
-                bool getFragmentData(int index, char **buffer);
+                codeFragment* getFragment(int index);
+                bool getFragmentData(int index, char **buffer);
+                bool toSrec(const QString& fileName);
+                bool toBinary(const QString& fileName);
+                static bool toBinary(QList<codeFragment*> fragments,const QString& File);
             signals:
             public slots:
             private:
                 void loadFile(QFile *file);
                 QStringList p_fileNames;
                 QList<QFile*>p_files;
                 QList<codeFragment*> p_fragments;
             };
             #endif // BINARYFILE_H

src/common/BinFile/binaryfilewidget.cpp +73 -5

             #include "binaryfilewidget.h"
             #include "ui_binaryfilewidget.h"
             #include "qtablewidgetintitem.h"
             #include <QtWidgets/QTableWidget>
+            #include <QtWidgets/QFileDialog>
+            #include "srecfile.h"
             binaryFileWidget::binaryFileWidget(QWidget *parent) :
-                QWidget(parent),
+                abstractBinFileWidget(parent),
                 ui(new Ui::binaryFileWidget)
             {
                 ui->setupUi(this);
                 connect(this->ui->fragmentList,SIGNAL(cellActivated(int,int)),this,SLOT(fragmentCellActivated(int,int)));
                 connect(this->ui->fragmentList,SIGNAL(cellChanged(int,int)),this,SLOT(fragmentCellChanged(int,int)));
+                exportToSREC_action = new QAction(tr("Export to SREC"),this);
+                exportToBIN_action = new QAction(tr("Export to Binary"),this);
+                this->ui->fragmentList->addAction(exportToBIN_action);
+                this->ui->fragmentList->addAction(exportToSREC_action);
+                connect(this->exportToBIN_action,SIGNAL(triggered()),this,SLOT(exportToBIN()));
+                connect(this->exportToSREC_action,SIGNAL(triggered()),this,SLOT(exportToSREC()));
             }
             binaryFileWidget::~binaryFileWidget()
             {
                 delete ui;
             }
-            void binaryFileWidget::updateBinaryFile(binaryFile *file)
+            void binaryFileWidget::setFile(abstractBinFile *file)
             {
-                this->p_binfile = file;
+                this->p_binfile = (binaryFile*)file;
                 if(p_binfile->isopened())
                 {
-                    updateFragments();
+                    reloadFile();
                 }
             }
-            void binaryFileWidget::updateFragments()
+            void binaryFileWidget::reloadFile()
             {
                 this->ui->fragmentList->clear();
                 this->ui->fragmentList->setRowCount(p_binfile->getFragmentsCount());
                 this->ui->fragmentList->setHorizontalHeaderLabels(QStringList()<<"File"<<"Size"<<"Address");
                 for(int i=0;i<p_binfile->getFragmentsCount();i++)
                 {
                     QTableWidgetItem *newItem = new QTableWidgetItem(p_binfile->getFragmentHeader(i));
                     newItem->setFlags(newItem->flags() ^ Qt::ItemIsEditable);
                     this->ui->fragmentList->setItem(i, 0, newItem);
                     newItem = (QTableWidgetItem*)new QTableWidgetIntItem(QString("%1").arg(p_binfile->getFragmentSize(i)),DecimalItem);
                     newItem->setFlags(newItem->flags() ^ Qt::ItemIsEditable);
                     this->ui->fragmentList->setItem(i, 1, newItem);
                     newItem = (QTableWidgetItem*)new QTableWidgetIntItem(QString("0x%1").arg(p_binfile->getFragmentAddress(i),8,16).replace(" ","0"),HexaDecimalItem);
             //        newItem->setFlags(newItem->flags() ^ Qt::ItemIsEditable);
                     this->ui->fragmentList->setItem(i, 2, newItem);
                 }
                 this->ui->fragmentList->resizeColumnsToContents();
             }
             void binaryFileWidget::fragmentCellActivated(int row, int column)
             {
                 Q_UNUSED(column)
                 char* buff=NULL;
                 int index = this->ui->fragmentList->item(row,0)->text().toInt();
                 if(index!=-1)
                 {
                     this->p_binfile->getFragmentData(index,&buff);
                     this->ui->hexViewer->setData(QByteArray(buff,this->p_binfile->getFragmentSize(index)));
                     this->ui->hexViewer->setAddressOffset(this->p_binfile->getFragmentAddress(index));
                 }
             }
             void binaryFileWidget::fragmentCellChanged(int row, int column)
             {
                 if(column==2)
                 {
                     QString newAddressStr = this->ui->fragmentList->item(row,column)->text();
                     int newAddress = 0;
                     newAddressStr.remove(" ");
                     if(newAddressStr.at(0)=='0' && newAddressStr.at(1)=='x')
                     {
                         newAddress = newAddressStr.remove("0x").toUInt(0,16);
                     }
                     else
                     {
                         newAddress = newAddressStr.toUInt();
                     }
                     this->p_binfile->getFragments().at(row)->address = newAddress;
                 }
             }
+            void binaryFileWidget::exportToSREC()
+            {
+                QList<codeFragment *>  SelectedFragmentsList=getSelectedFragments();
+                if(SelectedFragmentsList.count()>0)
+                {
+                    QString fileName = QFileDialog::getSaveFileName(this, tr("Save File"),
+                                               NULL,
+                                               tr("SREC Files (*.srec)"));
+                    if(!fileName.isEmpty())
+                    {
+                        srecFile::toSrec(SelectedFragmentsList,fileName);
+                    }
+                }
+            }
+            void binaryFileWidget::exportToBIN()
+            {
+                QList<codeFragment *>  SelectedFragmentsList=getSelectedFragments();
+                if(SelectedFragmentsList.count()>0)
+                {
+                    QString fileName = QFileDialog::getSaveFileName(this, tr("Save File"),
+                                               NULL,
+                                               tr("Binary Files (*.bin)"));
+                    if(!fileName.isEmpty())
+                    {
+                        binaryFile::toBinary(SelectedFragmentsList,fileName);
+                    }
+                }
+            }
+            QStringList binaryFileWidget::getSelectedFilesNames()
+            {
+                QStringList SelectedFilesList;
+                QList<QTableWidgetItem*> items = this->ui->fragmentList->selectedItems();
+                for(int i=0;i<items.count();i++)
+                {
+                    QString file = p_binfile->getFragmentHeader(items.at(i)->row());
+                    if(!SelectedFilesList.contains(file))
+                    {
+                        SelectedFilesList.append(file);
+                    }
+                }
+                return SelectedFilesList;
+            }
+            QList<codeFragment *> binaryFileWidget::getSelectedFragments()
+            {
+                QList<codeFragment *>  SelectedFragmentsList;
+                QList<QTableWidgetItem*> items = this->ui->fragmentList->selectedItems();
+                for(int i=0;i<items.count();i++)
+                {
+                    codeFragment * fragment = p_binfile->getFragment(items.at(i)->row());
+                    if(!SelectedFragmentsList.contains(fragment))
+                    {
+                        SelectedFragmentsList.append(fragment);
+                    }
+                }
+                return SelectedFragmentsList;
+            }

src/common/BinFile/binaryfilewidget.h +31 -3

+            /*------------------------------------------------------------------------------
+            --  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 BINARYFILEWIDGET_H
             #define BINARYFILEWIDGET_H
             #include <QWidget>
             #include "binaryfile.h"
+            #include <QAction>
             namespace Ui {
             class binaryFileWidget;
             }
-            class binaryFileWidget : public QWidget
+            class binaryFileWidget : public abstractBinFileWidget
             {
                 Q_OBJECT
             public:
                 explicit binaryFileWidget(QWidget *parent = 0);
                 ~binaryFileWidget();
             public slots:
-                void updateBinaryFile(binaryFile* file);
+                void setFile(abstractBinFile* file);
-                void updateFragments();
+                void reloadFile();
             private slots:
                 void fragmentCellActivated(int row, int column);
                 void fragmentCellChanged(int row, int column);
+                void exportToSREC();
+                void exportToBIN();
             private:
+                QStringList getSelectedFilesNames();
+                QList<codeFragment *> getSelectedFragments();
                 Ui::binaryFileWidget *ui;
                 binaryFile* p_binfile;
+                QAction* exportToSREC_action;
+                QAction* exportToBIN_action;
             };
             #endif // BINARYFILEWIDGET_H

src/common/BinFile/binaryfilewidget.ui +3 0

             <?xml version="1.0" encoding="UTF-8"?>
             <ui version="4.0">
              <class>binaryFileWidget</class>
              <widget class="QWidget" name="binaryFileWidget">
               <property name="geometry">
                <rect>
                 <x>0</x>
                 <y>0</y>
                 <width>637</width>
                 <height>342</height>
                </rect>
               </property>
               <property name="windowTitle">
                <string>Form</string>
               </property>
               <layout class="QGridLayout" name="gridLayout">
                <item row="0" column="0">
                 <widget class="QSplitter" name="splitter">
                  <property name="orientation">
                   <enum>Qt::Horizontal</enum>
                  </property>
                  <widget class="QHexEdit" name="hexViewer" native="true">
                   <property name="minimumSize">
                    <size>
                     <width>200</width>
                     <height>0</height>
                    </size>
                   </property>
                  </widget>
                  <widget class="QTableWidget" name="fragmentList">
+                  <property name="contextMenuPolicy">
+                   <enum>Qt::ActionsContextMenu</enum>
+                  </property>
                   <column>
                    <property name="text">
                     <string>File</string>
                    </property>
                   </column>
                   <column>
                    <property name="text">
                     <string>Size</string>
                    </property>
                   </column>
                   <column>
                    <property name="text">
                     <string>Address</string>
                    </property>
                   </column>
                  </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/abstractbinfile.h +16 -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 ABSTRACTBINFILE_H
             #define ABSTRACTBINFILE_H
             #include <QtCore/QObject>
+            #include <QtWidgets/QWidget>
             class codeFragment
             {
             public:
                 codeFragment();
                 codeFragment(char* data, quint64 size, quint64 address):data(data),size(size),address(address){}
                 QString header;
                 char* data;
                 quint64 size;
                 quint64 address;
             };
             class abstractBinFile : public QObject
             {
                 Q_OBJECT
             public:
             //    virtual abstractExecFile()=0;
                 virtual bool openFile(const QString& File)=0;
                 virtual bool isopened()=0;
                 virtual int closeFile()=0;
                 virtual QList<codeFragment*> getFragments()=0;
+                virtual bool toSrec(const QString& File)=0;
+                virtual bool toBinary(const QString& File)=0;
             protected:
                  QString p_fileName;
             };
+            class abstractBinFileWidget : public QWidget
+            {
+                Q_OBJECT
+            public:
+                abstractBinFileWidget(QWidget* parent = 0):QWidget(parent){};
+            public slots:
+                virtual void setFile(abstractBinFile* file)=0;
+                virtual void reloadFile()=0;
+            };
             #endif // ABSTRACTBINFILE_H

src/common/common.pro +1 -1

             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 \
                 BinFile/binaryfile.h \
                 BinFile/binaryfilewidget.h \
                 abstractbinfile.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
+            INCLUDEPATH += QCustomPlot qhexedit srec BinFile
             HEADERS += \
                 memsizewdgt.h \
                 qhexspinbox.h \
                 qsvgicon.h \
                 qhexedit/qhexedit_p.h \
                 qhexedit/qhexedit.h \
                 qhexedit/xbytearray.h \
                 qhexedit/commands.h \
                 QCustomPlot/qcustomplot.h \
                 tcp_terminal_client.h \
                 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 \
                 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 \
                 BinFile/binaryfile.cpp \
                 BinFile/binaryfilewidget.cpp
             FORMS += \
                 elf/elffilewidget.ui \
                 srec/srecfilewidget.ui \
                 BinFile/binaryfilewidget.ui
             OTHER_FILES += \
                 ./pythongenerator.sh \
                 ./pythonQtgeneratorCfg.txt

src/common/elf/elffile.cpp +7 -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 "elffile.h"
-            #include "srec/srecfile.h"
+            #include "srecfile.h"
+            #include "binaryfile.h"
             #include <stdint.h>
             ElfFile::ElfFile()
                 :abstractBinFile()
             {
                 this->opened = false;
                 this->type_elf = false;
                 this->elfFile = (int)NULL;
                 this->e = NULL;
             }
             ElfFile::ElfFile(const QString &File)
                 :abstractBinFile()
             {
                 this->opened = false;
                 this->type_elf = false;
                 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==(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!=(int)NULL)
                 {
                     if(this->e!=NULL)
                     {
                         elf_end(this->e);
                         this->e = NULL;
                     }
                     close(this->elfFile);
                     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_LINUX)return "Object uses GNU ELF extensions";
                     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)
             {
                 qint64 Offset = -1;
                 if(this->e!=NULL)
                 {
                     if(index < this->Segments.count())
                     {
                         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())
                     {
                         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<(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<(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<(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->sections.count())
                     {
                         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)
                             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 "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 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)
                 {
                     size_t res = read(file,Magic,4);
                     close(file);
                     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);
             }
+            bool ElfFile::toBinary(const QString &File)
+            {
+                return binaryFile::toBinary(getFragments(),File);
+            }

src/common/elf/elffile.h +1 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 <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 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);
+                bool toBinary(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 +20 -3

             /*------------------------------------------------------------------------------
             --  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"
+            #include "srecfile.h"
+            #include "binaryfile.h"
             elfFileWidget::elfFileWidget(QWidget *parent) :
-                QWidget(parent),
+                abstractBinFileWidget(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)
+            void elfFileWidget::setFile(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()));
                 }
+                reloadFile();
+            }
+            void elfFileWidget::reloadFile()
+            {
                 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"<<"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, 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)
                 {
                     QString type = p_elf->getSectionType(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()
             {
+                QStringList sectionList=getSelectedSectionsNames();
+                if(sectionList.count()>0)
+                {
+                    QString fileName = QFileDialog::getSaveFileName(this, tr("Save File"),
+                                               NULL,
+                                               tr("Binary Files (*.bin)"));
+                    if(!fileName.isEmpty())
+                    {
+                        binaryFile::toBinary(p_elf->getFragments(sectionList),fileName);
+                    }
+                }
             }
             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 +3 -2

             /*------------------------------------------------------------------------------
             --  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
+            class elfFileWidget : public abstractBinFileWidget
             {
                 Q_OBJECT
             public:
                 elfFileWidget(QWidget *parent = 0);
                 ~elfFileWidget();
             public slots:
-                void updateElfFile(ElfFile* file);
+                void setFile(ElfFile* file);
+                void reloadFile();
                 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/pythonQtOut/generated_cpp/PySocExplorer/PySocExplorer0.cpp +1327 -2698

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

src/common/pythonQtOut/generated_cpp/PySocExplorer/PySocExplorer0.h +127 -140

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

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

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

src/common/pythonQtgeneratorCfg.txt +6 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>
+                <interface-type name="abstractBinFileWidget">
+                    <extra-includes>
+                      <include file-name="QWidget" location="global"/>
+                      <include file-name="QObject" location="global"/>
+                    </extra-includes>
+                </interface-type>
                 <object-type name="elfFileWidget">
                     <extra-includes>
                       <include file-name="QWidget" location="global"/>
                       <include file-name="QObject" location="global"/>
                     </extra-includes>
                 </object-type>
                 <object-type name="srecFileWidget">
                   <extra-includes>
                     <include file-name="QWidget" location="global"/>
                     <include file-name="QObject" location="global"/>
                   </extra-includes>
                 </object-type>
                 <object-type name="binaryFileWidget">
                   <extra-includes>
                     <include file-name="QWidget" location="global"/>
                     <include file-name="QObject" location="global"/>
                   </extra-includes>
                 </object-type>
                 <object-type name="elfInfoWdgt">
                     <extra-includes>
                       <include file-name="QWidget" location="global"/>
                       <include file-name="QObject" location="global"/>
                     </extra-includes>
                 </object-type>
             </typesystem>

src/common/srec/srecfile.cpp +23 -7

             /*------------------------------------------------------------------------------
             --  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>
+            #include "binaryfile.h"
             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);
+                    free(p_fragments.at(i)->data);
+                    delete p_fragments.at(i);
                 }
+                p_fragments.clear();
                 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;
             }
+            bool srecFile::toSrec(const QString &File)
+            {
+                return toSrec(p_fragments,File);
+            }
+            bool srecFile::toBinary(const QString &File)
+            {
+                return binaryFile::toBinary(p_fragments,File);
+            }
             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;
             }
+            codeFragment *srecFile::getFragment(int index)
+            {
+                if((index < p_fragments.count()) && (index>=0))
+                {
+                    return p_fragments.at(index);
+                }
+                return NULL;
+            }
             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 +3 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);
+                bool toSrec(const QString &File);
+                bool toBinary(const QString& File);
                 int lineCount();
                 int getFragmentsCount();
                 int getFragmentAddress(int index);
                 int getFragmentSize(int index);
+                codeFragment *getFragment(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 +58 -5

             /*------------------------------------------------------------------------------
             --  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>
+            #include <QtWidgets/QFileDialog>
+            #include "binaryfile.h"
             srecFileWidget::srecFileWidget(QWidget *parent) :
-                QWidget(parent),
+                abstractBinFileWidget(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");
+                exportToSREC_action = new QAction(tr("Export to SREC"),this);
+                exportToBIN_action = new QAction(tr("Export to Binary"),this);
+                this->ui->fragmentsList->addAction(exportToBIN_action);
+                this->ui->fragmentsList->addAction(exportToSREC_action);
+                connect(this->exportToBIN_action,SIGNAL(triggered()),this,SLOT(exportToBIN()));
+                connect(this->exportToSREC_action,SIGNAL(triggered()),this,SLOT(exportToSREC()));
             }
             srecFileWidget::~srecFileWidget()
             {
                 delete ui;
             }
-            void srecFileWidget::updatSrecFile(srecFile *file)
+            void srecFileWidget::setFile(abstractBinFile *file)
             {
-                this->p_srec = file;
+                this->p_srec = (srecFile*)file;
                 if(p_srec->isopened() && p_srec->isSREC())
                 {
-                    updateRecords();
+                    reloadFile();
                 }
             }
-            void srecFileWidget::updateRecords()
+            void srecFileWidget::reloadFile()
             {
                 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));
                 }
             }
+            void srecFileWidget::exportToSREC()
+            {
+                QList<codeFragment *>  SelectedFragmentsList=getSelectedFragments();
+                if(SelectedFragmentsList.count()>0)
+                {
+                    QString fileName = QFileDialog::getSaveFileName(this, tr("Save File"),
+                                               NULL,
+                                               tr("SREC Files (*.srec)"));
+                    if(!fileName.isEmpty())
+                    {
+                        srecFile::toSrec(SelectedFragmentsList,fileName);
+                    }
+                }
+            }
+            void srecFileWidget::exportToBIN()
+            {
+                QList<codeFragment *>  SelectedFragmentsList=getSelectedFragments();
+                if(SelectedFragmentsList.count()>0)
+                {
+                    QString fileName = QFileDialog::getSaveFileName(this, tr("Save File"),
+                                               NULL,
+                                               tr("Binary Files (*.bin)"));
+                    if(!fileName.isEmpty())
+                    {
+                        binaryFile::toBinary(SelectedFragmentsList,fileName);
+                    }
+                }
+            }
+            QList<codeFragment *> srecFileWidget::getSelectedFragments()
+            {
+                QList<codeFragment *>  SelectedFragmentsList;
+                QList<QTableWidgetItem*> items = this->ui->fragmentsList->selectedItems();
+                for(int i=0;i<items.count();i++)
+                {
+                    codeFragment * fragment = p_srec->getFragment(items.at(i)->row());
+                    if(!SelectedFragmentsList.contains(fragment))
+                    {
+                        SelectedFragmentsList.append(fragment);
+                    }
+                }
+                return SelectedFragmentsList;
+            }

src/common/srec/srecfilewidget.h +9 -3

             /*------------------------------------------------------------------------------
             --  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"
+            #include <QAction>
             namespace Ui {
             class srecFileWidget;
             }
-            class srecFileWidget : public QWidget
+            class srecFileWidget : public abstractBinFileWidget
             {
                 Q_OBJECT
             public:
                 explicit srecFileWidget(QWidget *parent = 0);
                 ~srecFileWidget();
             public slots:
-                void updatSrecFile(srecFile* file);
+                void setFile(abstractBinFile* file);
-                void updateRecords();
+                void reloadFile();
             private slots:
                 void recordCellActivated(int row, int column);
+                void exportToSREC();
+                void exportToBIN();
             private:
+                QList<codeFragment *> getSelectedFragments();
                 Ui::srecFileWidget *ui;
                 srecFile* p_srec;
+                QAction* exportToSREC_action;
+                QAction* exportToBIN_action;
             };
             #endif // SRECFILEWIDGET_H

src/common/srec/srecfilewidget.ui +3 0

             <?xml version="1.0" encoding="UTF-8"?>
             <ui version="4.0">
              <class>srecFileWidget</class>
              <widget class="QWidget" name="srecFileWidget">
               <property name="geometry">
                <rect>
                 <x>0</x>
                 <y>0</y>
                 <width>740</width>
                 <height>516</height>
                </rect>
               </property>
               <property name="windowTitle">
                <string>Form</string>
               </property>
               <layout class="QGridLayout" name="gridLayout">
                <item row="0" column="0">
                 <widget class="QSplitter" name="splitter">
                  <property name="orientation">
                   <enum>Qt::Horizontal</enum>
                  </property>
                  <widget class="QGroupBox" name="groupBox">
                   <property name="title">
                    <string>Hexadecimal Viewer</string>
                   </property>
                   <layout class="QVBoxLayout" name="verticalLayout">
                    <item>
                     <widget class="QHexEdit" name="fragmentHexView" native="true">
                      <property name="minimumSize">
                       <size>
                        <width>256</width>
                        <height>0</height>
                       </size>
                      </property>
                     </widget>
                    </item>
                   </layout>
                  </widget>
                  <widget class="QGroupBox" name="groupBox_2">
                   <property name="title">
                    <string>SREC records list</string>
                   </property>
                   <layout class="QVBoxLayout" name="verticalLayout_2">
                    <item>
                     <widget class="QTableWidget" name="fragmentsList">
+                     <property name="contextMenuPolicy">
+                      <enum>Qt::ActionsContextMenu</enum>
+                     </property>
                      <column>
                       <property name="text">
                        <string>Index</string>
                       </property>
                      </column>
                      <column>
                       <property name="text">
                        <string>Address</string>
                       </property>
                      </column>
                      <column>
                       <property name="text">
                        <string>Size</string>
                       </property>
                      </column>
                      <column>
                       <property name="text">
                        <string>Header</string>
                       </property>
                      </column>
                     </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>

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