# HG changeset patch # User jeandet # Date 2014-06-04 23:47:55 # Node ID c839740ef520b5576aee6e29287b67ac774d6a61 # Parent 4d30eb803748c6be50b3901af8e9150cb10dd727 Abstract Binary files tools WIP. diff --git a/src/common/BinFile/binaryfile.cpp b/src/common/BinFile/binaryfile.cpp --- a/src/common/BinFile/binaryfile.cpp +++ b/src/common/BinFile/binaryfile.cpp @@ -20,6 +20,7 @@ -- Mail : alexis.jeandet@member.fsf.org ----------------------------------------------------------------------------*/ #include "binaryfile.h" +#include "srecfile.h" binaryFile::binaryFile() { @@ -47,13 +48,6 @@ bool binaryFile::openFile(const QString bool binaryFile::openFiles(const QStringList &Files) { - this->p_fileNames.clear(); - this->p_fileNames.append(Files); - for(int i=0;ip_files.clear(); for(int i=0;ip_files.append(new QFile(Files.at(i))); @@ -125,6 +119,13 @@ QString binaryFile::getFragmentHeader(in return ""; } +codeFragment *binaryFile::getFragment(int index) +{ + if((index>=0)&&(index=0)&&(index fragments, const QString &File) +{ + QFile file(File); + file.open(QIODevice::WriteOnly); + if(file.isOpen()) + { + for(int i=0;idata,fragments.at(i)->size); + } + return true; + } + return false; +} + void binaryFile::loadFile(QFile *file) { if (file->isOpen()) diff --git a/src/common/BinFile/binaryfile.h b/src/common/BinFile/binaryfile.h --- a/src/common/BinFile/binaryfile.h +++ b/src/common/BinFile/binaryfile.h @@ -45,7 +45,11 @@ public: 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 fragments,const QString& File); signals: public slots: diff --git a/src/common/BinFile/binaryfilewidget.cpp b/src/common/BinFile/binaryfilewidget.cpp --- a/src/common/BinFile/binaryfilewidget.cpp +++ b/src/common/BinFile/binaryfilewidget.cpp @@ -2,14 +2,22 @@ #include "ui_binaryfilewidget.h" #include "qtablewidgetintitem.h" #include +#include +#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() @@ -17,16 +25,16 @@ 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()); @@ -80,3 +88,63 @@ void binaryFileWidget::fragmentCellChang this->p_binfile->getFragments().at(row)->address = newAddress; } } + +void binaryFileWidget::exportToSREC() +{ + QList 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 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 items = this->ui->fragmentList->selectedItems(); + for(int i=0;igetFragmentHeader(items.at(i)->row()); + if(!SelectedFilesList.contains(file)) + { + SelectedFilesList.append(file); + } + } + return SelectedFilesList; +} + +QList binaryFileWidget::getSelectedFragments() +{ + QList SelectedFragmentsList; + QList items = this->ui->fragmentList->selectedItems(); + for(int i=0;igetFragment(items.at(i)->row()); + if(!SelectedFragmentsList.contains(fragment)) + { + SelectedFragmentsList.append(fragment); + } + } + return SelectedFragmentsList; +} diff --git a/src/common/BinFile/binaryfilewidget.h b/src/common/BinFile/binaryfilewidget.h --- a/src/common/BinFile/binaryfilewidget.h +++ b/src/common/BinFile/binaryfilewidget.h @@ -1,14 +1,36 @@ +/*------------------------------------------------------------------------------ +-- 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 #include "binaryfile.h" +#include namespace Ui { class binaryFileWidget; } -class binaryFileWidget : public QWidget +class binaryFileWidget : public abstractBinFileWidget { Q_OBJECT @@ -17,16 +39,22 @@ public: ~binaryFileWidget(); public slots: - void updateBinaryFile(binaryFile* file); - void updateFragments(); + void setFile(abstractBinFile* file); + void reloadFile(); private slots: void fragmentCellActivated(int row, int column); void fragmentCellChanged(int row, int column); + void exportToSREC(); + void exportToBIN(); private: + QStringList getSelectedFilesNames(); + QList getSelectedFragments(); Ui::binaryFileWidget *ui; binaryFile* p_binfile; + QAction* exportToSREC_action; + QAction* exportToBIN_action; }; #endif // BINARYFILEWIDGET_H diff --git a/src/common/BinFile/binaryfilewidget.ui b/src/common/BinFile/binaryfilewidget.ui --- a/src/common/BinFile/binaryfilewidget.ui +++ b/src/common/BinFile/binaryfilewidget.ui @@ -28,6 +28,9 @@ + + Qt::ActionsContextMenu + File diff --git a/src/common/abstractbinfile.h b/src/common/abstractbinfile.h --- a/src/common/abstractbinfile.h +++ b/src/common/abstractbinfile.h @@ -23,6 +23,7 @@ #define ABSTRACTBINFILE_H #include +#include class codeFragment { @@ -44,9 +45,23 @@ public: virtual bool isopened()=0; virtual int closeFile()=0; virtual QList 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 diff --git a/src/common/common.pro b/src/common/common.pro --- a/src/common/common.pro +++ b/src/common/common.pro @@ -72,7 +72,7 @@ isEmpty(header.path) { INSTALLS += target header -INCLUDEPATH += QCustomPlot qhexedit srec +INCLUDEPATH += QCustomPlot qhexedit srec BinFile HEADERS += \ memsizewdgt.h \ diff --git a/src/common/elf/elffile.cpp b/src/common/elf/elffile.cpp --- a/src/common/elf/elffile.cpp +++ b/src/common/elf/elffile.cpp @@ -22,7 +22,8 @@ alexis.jeandet@member.fsf.org ----------------------------------------------------------------------------*/ #include "elffile.h" -#include "srec/srecfile.h" +#include "srecfile.h" +#include "binaryfile.h" #include ElfFile::ElfFile() @@ -1066,3 +1067,8 @@ bool ElfFile::toSrec(const QString &File { return srecFile::toSrec(this->getFragments(),File); } + +bool ElfFile::toBinary(const QString &File) +{ + return binaryFile::toBinary(getFragments(),File); +} diff --git a/src/common/elf/elffile.h b/src/common/elf/elffile.h --- a/src/common/elf/elffile.h +++ b/src/common/elf/elffile.h @@ -111,6 +111,7 @@ public: static bool isElf(const QString& File); bool toSrec(const QString& File); + bool toBinary(const QString& File); private: codeFragment* getFragment(const QString& name); diff --git a/src/common/elf/elffilewidget.cpp b/src/common/elf/elffilewidget.cpp --- a/src/common/elf/elffilewidget.cpp +++ b/src/common/elf/elffilewidget.cpp @@ -25,10 +25,11 @@ #include #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); @@ -59,7 +60,7 @@ elfFileWidget::~elfFileWidget() -void elfFileWidget::updateElfFile(ElfFile *file) +void elfFileWidget::setFile(ElfFile *file) { this->p_elf = file; if(p_elf->isopened() && p_elf->iself()) @@ -74,6 +75,11 @@ void elfFileWidget::updateElfFile(ElfFil this->ui->sectionCountLabel->setText(QString::number(p_elf->getSectionCount())); this->ui->symbolCountLabel->setText(QString::number(p_elf->getSymbolCount())); } + reloadFile(); +} + +void elfFileWidget::reloadFile() +{ updateSymbols(); updateSections(); } @@ -189,6 +195,17 @@ void elfFileWidget::exportToSREC() 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); + } + } } diff --git a/src/common/elf/elffilewidget.h b/src/common/elf/elffilewidget.h --- a/src/common/elf/elffilewidget.h +++ b/src/common/elf/elffilewidget.h @@ -31,7 +31,7 @@ namespace Ui { class elfFileWidget; } -class elfFileWidget : public QWidget +class elfFileWidget : public abstractBinFileWidget { Q_OBJECT @@ -40,7 +40,8 @@ public: ~elfFileWidget(); public slots: - void updateElfFile(ElfFile* file); + void setFile(ElfFile* file); + void reloadFile(); void updateSymbols(); void updateSections(); diff --git a/src/common/pythonQtOut/generated_cpp/PySocExplorer/PySocExplorer0.cpp b/src/common/pythonQtOut/generated_cpp/PySocExplorer/PySocExplorer0.cpp --- a/src/common/pythonQtOut/generated_cpp/PySocExplorer/PySocExplorer0.cpp +++ b/src/common/pythonQtOut/generated_cpp/PySocExplorer/PySocExplorer0.cpp @@ -8,7 +8,6 @@ #include #include #include -#include #include #include #include @@ -47,7 +46,6 @@ #include #include #include -#include PythonQtShell_ElfFile::~PythonQtShell_ElfFile() { PythonQtPrivate* priv = PythonQt::priv(); @@ -165,6 +163,62 @@ if (_wrapper) { } 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(); } @@ -368,9 +422,14 @@ bool PythonQtWrapper_ElfFile::sectionIs 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)); } @@ -4964,12 +5023,1014 @@ if (_wrapper) { } 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); } @@ -5086,6 +6147,62 @@ if (_wrapper) { } 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(); } @@ -5103,6 +6220,11 @@ int PythonQtWrapper_binaryFile::closeFi 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)); @@ -5148,918 +6270,75 @@ bool PythonQtWrapper_binaryFile::openFi return ( theWrappedObject->openFiles(Files)); } +bool PythonQtWrapper_binaryFile::static_binaryFile_toBinary(QList 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) -{ -if (_wrapper) { - PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "actionEvent"); - PyErr_Clear(); - if (obj && !PythonQtSlotFunction_Check(obj)) { - static const char* argumentList[] ={"" , "QActionEvent*"}; - static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); - void* args[2] = {NULL, (void*)&arg__1}; - PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); - if (result) { Py_DECREF(result); } - Py_DECREF(obj); - return; - } -} - binaryFileWidget::actionEvent(arg__1); -} -void PythonQtShell_binaryFileWidget::changeEvent(QEvent* arg__1) -{ -if (_wrapper) { - PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "changeEvent"); - PyErr_Clear(); - if (obj && !PythonQtSlotFunction_Check(obj)) { - static const char* argumentList[] ={"" , "QEvent*"}; - static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); - void* args[2] = {NULL, (void*)&arg__1}; - PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); - if (result) { Py_DECREF(result); } - Py_DECREF(obj); - return; - } -} - binaryFileWidget::changeEvent(arg__1); -} -void PythonQtShell_binaryFileWidget::childEvent(QChildEvent* arg__1) -{ -if (_wrapper) { - PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "childEvent"); - PyErr_Clear(); - if (obj && !PythonQtSlotFunction_Check(obj)) { - static const char* argumentList[] ={"" , "QChildEvent*"}; - static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); - void* args[2] = {NULL, (void*)&arg__1}; - PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); - if (result) { Py_DECREF(result); } - Py_DECREF(obj); - return; - } -} - binaryFileWidget::childEvent(arg__1); -} -void PythonQtShell_binaryFileWidget::closeEvent(QCloseEvent* arg__1) -{ -if (_wrapper) { - PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "closeEvent"); - PyErr_Clear(); - if (obj && !PythonQtSlotFunction_Check(obj)) { - static const char* argumentList[] ={"" , "QCloseEvent*"}; - static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); - void* args[2] = {NULL, (void*)&arg__1}; - PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); - if (result) { Py_DECREF(result); } - Py_DECREF(obj); - return; - } -} - binaryFileWidget::closeEvent(arg__1); -} -void PythonQtShell_binaryFileWidget::contextMenuEvent(QContextMenuEvent* arg__1) -{ -if (_wrapper) { - PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "contextMenuEvent"); - PyErr_Clear(); - if (obj && !PythonQtSlotFunction_Check(obj)) { - static const char* argumentList[] ={"" , "QContextMenuEvent*"}; - static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); - void* args[2] = {NULL, (void*)&arg__1}; - PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); - if (result) { Py_DECREF(result); } - Py_DECREF(obj); - return; - } -} - binaryFileWidget::contextMenuEvent(arg__1); -} -void PythonQtShell_binaryFileWidget::customEvent(QEvent* arg__1) -{ -if (_wrapper) { - PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "customEvent"); - PyErr_Clear(); - if (obj && !PythonQtSlotFunction_Check(obj)) { - static const char* argumentList[] ={"" , "QEvent*"}; - static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); - void* args[2] = {NULL, (void*)&arg__1}; - PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); - if (result) { Py_DECREF(result); } - Py_DECREF(obj); - return; - } -} - binaryFileWidget::customEvent(arg__1); -} -int PythonQtShell_binaryFileWidget::devType() const -{ -if (_wrapper) { - PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "devType"); - PyErr_Clear(); - if (obj && !PythonQtSlotFunction_Check(obj)) { - static const char* argumentList[] ={"int"}; +void PythonQtShell_binaryFileWidget::reloadFile() +{ +if (_wrapper) { + PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "reloadFile"); + PyErr_Clear(); + if (obj && !PythonQtSlotFunction_Check(obj)) { + static const char* argumentList[] ={""}; static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); - int returnValue; - void* args[1] = {NULL}; - PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); - if (result) { - args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); - if (args[0]!=&returnValue) { - if (args[0]==NULL) { - PythonQt::priv()->handleVirtualOverloadReturnError("devType", methodInfo, result); - } else { - returnValue = *((int*)args[0]); - } - } - } - if (result) { Py_DECREF(result); } - Py_DECREF(obj); - return returnValue; - } -} - return binaryFileWidget::devType(); -} -void PythonQtShell_binaryFileWidget::dragEnterEvent(QDragEnterEvent* arg__1) -{ -if (_wrapper) { - PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragEnterEvent"); - PyErr_Clear(); - if (obj && !PythonQtSlotFunction_Check(obj)) { - static const char* argumentList[] ={"" , "QDragEnterEvent*"}; - static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); - void* args[2] = {NULL, (void*)&arg__1}; - PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); - if (result) { Py_DECREF(result); } - Py_DECREF(obj); - return; - } -} - binaryFileWidget::dragEnterEvent(arg__1); -} -void PythonQtShell_binaryFileWidget::dragLeaveEvent(QDragLeaveEvent* arg__1) -{ -if (_wrapper) { - PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragLeaveEvent"); - PyErr_Clear(); - if (obj && !PythonQtSlotFunction_Check(obj)) { - static const char* argumentList[] ={"" , "QDragLeaveEvent*"}; - static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); - void* args[2] = {NULL, (void*)&arg__1}; - PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); - if (result) { Py_DECREF(result); } - Py_DECREF(obj); - return; - } -} - binaryFileWidget::dragLeaveEvent(arg__1); -} -void PythonQtShell_binaryFileWidget::dragMoveEvent(QDragMoveEvent* arg__1) -{ -if (_wrapper) { - PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragMoveEvent"); - PyErr_Clear(); - if (obj && !PythonQtSlotFunction_Check(obj)) { - static const char* argumentList[] ={"" , "QDragMoveEvent*"}; - static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); - void* args[2] = {NULL, (void*)&arg__1}; - PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); - if (result) { Py_DECREF(result); } - Py_DECREF(obj); - return; - } -} - binaryFileWidget::dragMoveEvent(arg__1); -} -void PythonQtShell_binaryFileWidget::dropEvent(QDropEvent* arg__1) -{ -if (_wrapper) { - PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dropEvent"); - PyErr_Clear(); - if (obj && !PythonQtSlotFunction_Check(obj)) { - static const char* argumentList[] ={"" , "QDropEvent*"}; - static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); - void* args[2] = {NULL, (void*)&arg__1}; - PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); - if (result) { Py_DECREF(result); } - Py_DECREF(obj); - return; - } -} - binaryFileWidget::dropEvent(arg__1); -} -void PythonQtShell_binaryFileWidget::enterEvent(QEvent* arg__1) -{ -if (_wrapper) { - PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "enterEvent"); - PyErr_Clear(); - if (obj && !PythonQtSlotFunction_Check(obj)) { - static const char* argumentList[] ={"" , "QEvent*"}; - static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); - void* args[2] = {NULL, (void*)&arg__1}; - PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); - if (result) { Py_DECREF(result); } - Py_DECREF(obj); - return; - } -} - binaryFileWidget::enterEvent(arg__1); -} -bool PythonQtShell_binaryFileWidget::event(QEvent* arg__1) -{ -if (_wrapper) { - PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "event"); - PyErr_Clear(); - if (obj && !PythonQtSlotFunction_Check(obj)) { - static const char* argumentList[] ={"bool" , "QEvent*"}; - static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); - bool returnValue; - void* args[2] = {NULL, (void*)&arg__1}; - PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); - if (result) { - args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); - if (args[0]!=&returnValue) { - if (args[0]==NULL) { - PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result); - } else { - returnValue = *((bool*)args[0]); - } - } - } - if (result) { Py_DECREF(result); } - Py_DECREF(obj); - return returnValue; - } -} - return binaryFileWidget::event(arg__1); -} -bool PythonQtShell_binaryFileWidget::eventFilter(QObject* arg__1, QEvent* arg__2) -{ -if (_wrapper) { - PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "eventFilter"); - PyErr_Clear(); - if (obj && !PythonQtSlotFunction_Check(obj)) { - static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"}; - static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList); - bool returnValue; - void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2}; - PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); - if (result) { - args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); - if (args[0]!=&returnValue) { - if (args[0]==NULL) { - PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result); - } else { - returnValue = *((bool*)args[0]); - } - } - } - if (result) { Py_DECREF(result); } - Py_DECREF(obj); - return returnValue; - } -} - return binaryFileWidget::eventFilter(arg__1, arg__2); -} -void PythonQtShell_binaryFileWidget::focusInEvent(QFocusEvent* arg__1) -{ -if (_wrapper) { - PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusInEvent"); - PyErr_Clear(); - if (obj && !PythonQtSlotFunction_Check(obj)) { - static const char* argumentList[] ={"" , "QFocusEvent*"}; - static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); - void* args[2] = {NULL, (void*)&arg__1}; - PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); - if (result) { Py_DECREF(result); } - Py_DECREF(obj); - return; - } -} - binaryFileWidget::focusInEvent(arg__1); -} -bool PythonQtShell_binaryFileWidget::focusNextPrevChild(bool next) -{ -if (_wrapper) { - PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusNextPrevChild"); - PyErr_Clear(); - if (obj && !PythonQtSlotFunction_Check(obj)) { - static const char* argumentList[] ={"bool" , "bool"}; - static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); - bool returnValue; - void* args[2] = {NULL, (void*)&next}; - PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); - if (result) { - args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); - if (args[0]!=&returnValue) { - if (args[0]==NULL) { - PythonQt::priv()->handleVirtualOverloadReturnError("focusNextPrevChild", methodInfo, result); - } else { - returnValue = *((bool*)args[0]); - } - } - } - if (result) { Py_DECREF(result); } - Py_DECREF(obj); - return returnValue; - } -} - return binaryFileWidget::focusNextPrevChild(next); -} -void PythonQtShell_binaryFileWidget::focusOutEvent(QFocusEvent* arg__1) -{ -if (_wrapper) { - PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusOutEvent"); - PyErr_Clear(); - if (obj && !PythonQtSlotFunction_Check(obj)) { - static const char* argumentList[] ={"" , "QFocusEvent*"}; - static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); - void* args[2] = {NULL, (void*)&arg__1}; - PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); - if (result) { Py_DECREF(result); } - Py_DECREF(obj); - return; - } -} - binaryFileWidget::focusOutEvent(arg__1); -} -bool PythonQtShell_binaryFileWidget::hasHeightForWidth() const -{ -if (_wrapper) { - PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hasHeightForWidth"); - PyErr_Clear(); - if (obj && !PythonQtSlotFunction_Check(obj)) { - static const char* argumentList[] ={"bool"}; - static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); - bool returnValue; void* args[1] = {NULL}; PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); - if (result) { - args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); - if (args[0]!=&returnValue) { - if (args[0]==NULL) { - PythonQt::priv()->handleVirtualOverloadReturnError("hasHeightForWidth", methodInfo, result); - } else { - returnValue = *((bool*)args[0]); - } - } - } - if (result) { Py_DECREF(result); } - Py_DECREF(obj); - return returnValue; - } -} - return binaryFileWidget::hasHeightForWidth(); -} -int PythonQtShell_binaryFileWidget::heightForWidth(int arg__1) const -{ -if (_wrapper) { - PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "heightForWidth"); - PyErr_Clear(); - if (obj && !PythonQtSlotFunction_Check(obj)) { - static const char* argumentList[] ={"int" , "int"}; - static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); - int returnValue; - void* args[2] = {NULL, (void*)&arg__1}; - PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); - if (result) { - args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); - if (args[0]!=&returnValue) { - if (args[0]==NULL) { - PythonQt::priv()->handleVirtualOverloadReturnError("heightForWidth", methodInfo, result); - } else { - returnValue = *((int*)args[0]); - } - } - } - if (result) { Py_DECREF(result); } - Py_DECREF(obj); - return returnValue; - } -} - return binaryFileWidget::heightForWidth(arg__1); -} -void PythonQtShell_binaryFileWidget::hideEvent(QHideEvent* arg__1) -{ -if (_wrapper) { - PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hideEvent"); - PyErr_Clear(); - if (obj && !PythonQtSlotFunction_Check(obj)) { - static const char* argumentList[] ={"" , "QHideEvent*"}; - static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); - void* args[2] = {NULL, (void*)&arg__1}; - PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); - if (result) { Py_DECREF(result); } - Py_DECREF(obj); - return; - } -} - binaryFileWidget::hideEvent(arg__1); -} -void PythonQtShell_binaryFileWidget::initPainter(QPainter* painter) const -{ -if (_wrapper) { - PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "initPainter"); - PyErr_Clear(); - if (obj && !PythonQtSlotFunction_Check(obj)) { - static const char* argumentList[] ={"" , "QPainter*"}; - static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); - void* args[2] = {NULL, (void*)&painter}; - PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); - if (result) { Py_DECREF(result); } - Py_DECREF(obj); - return; - } -} - binaryFileWidget::initPainter(painter); -} -void PythonQtShell_binaryFileWidget::inputMethodEvent(QInputMethodEvent* arg__1) -{ -if (_wrapper) { - PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodEvent"); - PyErr_Clear(); - if (obj && !PythonQtSlotFunction_Check(obj)) { - static const char* argumentList[] ={"" , "QInputMethodEvent*"}; - static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); - void* args[2] = {NULL, (void*)&arg__1}; - PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); - if (result) { Py_DECREF(result); } - Py_DECREF(obj); - return; - } -} - binaryFileWidget::inputMethodEvent(arg__1); -} -QVariant PythonQtShell_binaryFileWidget::inputMethodQuery(Qt::InputMethodQuery arg__1) const -{ -if (_wrapper) { - PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodQuery"); - PyErr_Clear(); - if (obj && !PythonQtSlotFunction_Check(obj)) { - static const char* argumentList[] ={"QVariant" , "Qt::InputMethodQuery"}; - static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); - QVariant returnValue; - void* args[2] = {NULL, (void*)&arg__1}; - PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); - if (result) { - args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); - if (args[0]!=&returnValue) { - if (args[0]==NULL) { - PythonQt::priv()->handleVirtualOverloadReturnError("inputMethodQuery", methodInfo, result); - } else { - returnValue = *((QVariant*)args[0]); - } - } - } - if (result) { Py_DECREF(result); } - Py_DECREF(obj); - return returnValue; - } -} - return binaryFileWidget::inputMethodQuery(arg__1); -} -void PythonQtShell_binaryFileWidget::keyPressEvent(QKeyEvent* arg__1) -{ -if (_wrapper) { - PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyPressEvent"); - PyErr_Clear(); - if (obj && !PythonQtSlotFunction_Check(obj)) { - static const char* argumentList[] ={"" , "QKeyEvent*"}; - static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); - void* args[2] = {NULL, (void*)&arg__1}; - PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); - if (result) { Py_DECREF(result); } - Py_DECREF(obj); - return; - } -} - binaryFileWidget::keyPressEvent(arg__1); -} -void PythonQtShell_binaryFileWidget::keyReleaseEvent(QKeyEvent* arg__1) -{ -if (_wrapper) { - PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyReleaseEvent"); - PyErr_Clear(); - if (obj && !PythonQtSlotFunction_Check(obj)) { - static const char* argumentList[] ={"" , "QKeyEvent*"}; - static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); - void* args[2] = {NULL, (void*)&arg__1}; - PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); - if (result) { Py_DECREF(result); } - Py_DECREF(obj); - return; - } -} - binaryFileWidget::keyReleaseEvent(arg__1); -} -void PythonQtShell_binaryFileWidget::leaveEvent(QEvent* arg__1) -{ -if (_wrapper) { - PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "leaveEvent"); - PyErr_Clear(); - if (obj && !PythonQtSlotFunction_Check(obj)) { - static const char* argumentList[] ={"" , "QEvent*"}; - static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); - void* args[2] = {NULL, (void*)&arg__1}; - PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); - if (result) { Py_DECREF(result); } - Py_DECREF(obj); - return; - } -} - binaryFileWidget::leaveEvent(arg__1); -} -int PythonQtShell_binaryFileWidget::metric(QPaintDevice::PaintDeviceMetric arg__1) const -{ -if (_wrapper) { - PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "metric"); - PyErr_Clear(); - if (obj && !PythonQtSlotFunction_Check(obj)) { - static const char* argumentList[] ={"int" , "QPaintDevice::PaintDeviceMetric"}; - static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); - int returnValue; - void* args[2] = {NULL, (void*)&arg__1}; - PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); - if (result) { - args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); - if (args[0]!=&returnValue) { - if (args[0]==NULL) { - PythonQt::priv()->handleVirtualOverloadReturnError("metric", methodInfo, result); - } else { - returnValue = *((int*)args[0]); - } - } - } - if (result) { Py_DECREF(result); } - Py_DECREF(obj); - return returnValue; - } -} - return binaryFileWidget::metric(arg__1); -} -QSize PythonQtShell_binaryFileWidget::minimumSizeHint() const -{ -if (_wrapper) { - PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getMinimumSizeHint"); - PyErr_Clear(); - if (obj && !PythonQtSlotFunction_Check(obj)) { - static const char* argumentList[] ={"QSize"}; - static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); - QSize returnValue; - void* args[1] = {NULL}; - PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); - if (result) { - args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); - if (args[0]!=&returnValue) { - if (args[0]==NULL) { - PythonQt::priv()->handleVirtualOverloadReturnError("getMinimumSizeHint", methodInfo, result); - } else { - returnValue = *((QSize*)args[0]); - } - } - } - if (result) { Py_DECREF(result); } - Py_DECREF(obj); - return returnValue; - } -} - return binaryFileWidget::minimumSizeHint(); -} -void PythonQtShell_binaryFileWidget::mouseDoubleClickEvent(QMouseEvent* arg__1) -{ -if (_wrapper) { - PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseDoubleClickEvent"); - PyErr_Clear(); - if (obj && !PythonQtSlotFunction_Check(obj)) { - static const char* argumentList[] ={"" , "QMouseEvent*"}; - static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); - void* args[2] = {NULL, (void*)&arg__1}; - PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); - if (result) { Py_DECREF(result); } - Py_DECREF(obj); - return; - } -} - binaryFileWidget::mouseDoubleClickEvent(arg__1); -} -void PythonQtShell_binaryFileWidget::mouseMoveEvent(QMouseEvent* arg__1) -{ -if (_wrapper) { - PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseMoveEvent"); - PyErr_Clear(); - if (obj && !PythonQtSlotFunction_Check(obj)) { - static const char* argumentList[] ={"" , "QMouseEvent*"}; - static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); - void* args[2] = {NULL, (void*)&arg__1}; - PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); - if (result) { Py_DECREF(result); } - Py_DECREF(obj); - return; - } -} - binaryFileWidget::mouseMoveEvent(arg__1); -} -void PythonQtShell_binaryFileWidget::mousePressEvent(QMouseEvent* arg__1) -{ -if (_wrapper) { - PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mousePressEvent"); - PyErr_Clear(); - if (obj && !PythonQtSlotFunction_Check(obj)) { - static const char* argumentList[] ={"" , "QMouseEvent*"}; - static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); - void* args[2] = {NULL, (void*)&arg__1}; - PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); - if (result) { Py_DECREF(result); } - Py_DECREF(obj); - return; - } -} - binaryFileWidget::mousePressEvent(arg__1); -} -void PythonQtShell_binaryFileWidget::mouseReleaseEvent(QMouseEvent* arg__1) -{ -if (_wrapper) { - PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseReleaseEvent"); - PyErr_Clear(); - if (obj && !PythonQtSlotFunction_Check(obj)) { - static const char* argumentList[] ={"" , "QMouseEvent*"}; - static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); - void* args[2] = {NULL, (void*)&arg__1}; - PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); - if (result) { Py_DECREF(result); } - Py_DECREF(obj); - return; - } -} - binaryFileWidget::mouseReleaseEvent(arg__1); -} -void PythonQtShell_binaryFileWidget::moveEvent(QMoveEvent* arg__1) -{ -if (_wrapper) { - PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "moveEvent"); - PyErr_Clear(); - if (obj && !PythonQtSlotFunction_Check(obj)) { - static const char* argumentList[] ={"" , "QMoveEvent*"}; - static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); - void* args[2] = {NULL, (void*)&arg__1}; - PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); - if (result) { Py_DECREF(result); } - Py_DECREF(obj); - return; - } -} - binaryFileWidget::moveEvent(arg__1); -} -bool PythonQtShell_binaryFileWidget::nativeEvent(const QByteArray& eventType, void* message, long* result) -{ -if (_wrapper) { - PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "nativeEvent"); - PyErr_Clear(); - if (obj && !PythonQtSlotFunction_Check(obj)) { - static const char* argumentList[] ={"bool" , "const QByteArray&" , "void*" , "long*"}; - static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList); - bool returnValue; - void* args[4] = {NULL, (void*)&eventType, (void*)&message, (void*)&result}; - PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); - if (result) { - args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); - if (args[0]!=&returnValue) { - if (args[0]==NULL) { - PythonQt::priv()->handleVirtualOverloadReturnError("nativeEvent", methodInfo, result); - } else { - returnValue = *((bool*)args[0]); - } - } - } - if (result) { Py_DECREF(result); } - Py_DECREF(obj); - return returnValue; - } -} - return binaryFileWidget::nativeEvent(eventType, message, result); -} -QPaintEngine* PythonQtShell_binaryFileWidget::paintEngine() const -{ -if (_wrapper) { - PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEngine"); - PyErr_Clear(); - if (obj && !PythonQtSlotFunction_Check(obj)) { - static const char* argumentList[] ={"QPaintEngine*"}; - static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); - QPaintEngine* returnValue; - void* args[1] = {NULL}; - PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); - if (result) { - args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); - if (args[0]!=&returnValue) { - if (args[0]==NULL) { - PythonQt::priv()->handleVirtualOverloadReturnError("paintEngine", methodInfo, result); - } else { - returnValue = *((QPaintEngine**)args[0]); - } - } - } - if (result) { Py_DECREF(result); } - Py_DECREF(obj); - return returnValue; - } -} - return binaryFileWidget::paintEngine(); -} -void PythonQtShell_binaryFileWidget::paintEvent(QPaintEvent* arg__1) -{ -if (_wrapper) { - PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEvent"); - PyErr_Clear(); - if (obj && !PythonQtSlotFunction_Check(obj)) { - static const char* argumentList[] ={"" , "QPaintEvent*"}; - static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); - void* args[2] = {NULL, (void*)&arg__1}; - PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); - if (result) { Py_DECREF(result); } - Py_DECREF(obj); - return; - } -} - binaryFileWidget::paintEvent(arg__1); -} -QPaintDevice* PythonQtShell_binaryFileWidget::redirected(QPoint* offset) const -{ -if (_wrapper) { - PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "redirected"); - PyErr_Clear(); - if (obj && !PythonQtSlotFunction_Check(obj)) { - static const char* argumentList[] ={"QPaintDevice*" , "QPoint*"}; - static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); - QPaintDevice* returnValue; - void* args[2] = {NULL, (void*)&offset}; - PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); - if (result) { - args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); - if (args[0]!=&returnValue) { - if (args[0]==NULL) { - PythonQt::priv()->handleVirtualOverloadReturnError("redirected", methodInfo, result); - } else { - returnValue = *((QPaintDevice**)args[0]); - } - } - } - if (result) { Py_DECREF(result); } - Py_DECREF(obj); - return returnValue; - } -} - return binaryFileWidget::redirected(offset); -} -void PythonQtShell_binaryFileWidget::resizeEvent(QResizeEvent* arg__1) -{ -if (_wrapper) { - PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "resizeEvent"); - PyErr_Clear(); - if (obj && !PythonQtSlotFunction_Check(obj)) { - static const char* argumentList[] ={"" , "QResizeEvent*"}; - static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); - void* args[2] = {NULL, (void*)&arg__1}; - PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); - if (result) { Py_DECREF(result); } - Py_DECREF(obj); - return; - } -} - binaryFileWidget::resizeEvent(arg__1); -} -QPainter* PythonQtShell_binaryFileWidget::sharedPainter() const -{ -if (_wrapper) { - PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "sharedPainter"); - PyErr_Clear(); - if (obj && !PythonQtSlotFunction_Check(obj)) { - static const char* argumentList[] ={"QPainter*"}; - static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); - QPainter* returnValue; - void* args[1] = {NULL}; - PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); - if (result) { - args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); - if (args[0]!=&returnValue) { - if (args[0]==NULL) { - PythonQt::priv()->handleVirtualOverloadReturnError("sharedPainter", methodInfo, result); - } else { - returnValue = *((QPainter**)args[0]); - } - } - } - if (result) { Py_DECREF(result); } - Py_DECREF(obj); - return returnValue; - } -} - return binaryFileWidget::sharedPainter(); -} -void PythonQtShell_binaryFileWidget::showEvent(QShowEvent* arg__1) -{ -if (_wrapper) { - PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "showEvent"); - PyErr_Clear(); - if (obj && !PythonQtSlotFunction_Check(obj)) { - static const char* argumentList[] ={"" , "QShowEvent*"}; - static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); - void* args[2] = {NULL, (void*)&arg__1}; - PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); - if (result) { Py_DECREF(result); } - Py_DECREF(obj); - return; - } -} - binaryFileWidget::showEvent(arg__1); -} -QSize PythonQtShell_binaryFileWidget::sizeHint() const -{ -if (_wrapper) { - PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getSizeHint"); - PyErr_Clear(); - if (obj && !PythonQtSlotFunction_Check(obj)) { - static const char* argumentList[] ={"QSize"}; - static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); - QSize returnValue; - void* args[1] = {NULL}; - PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); - if (result) { - args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); - if (args[0]!=&returnValue) { - if (args[0]==NULL) { - PythonQt::priv()->handleVirtualOverloadReturnError("getSizeHint", methodInfo, result); - } else { - returnValue = *((QSize*)args[0]); - } - } - } - if (result) { Py_DECREF(result); } - Py_DECREF(obj); - return returnValue; - } -} - return binaryFileWidget::sizeHint(); -} -void PythonQtShell_binaryFileWidget::tabletEvent(QTabletEvent* arg__1) -{ -if (_wrapper) { - PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "tabletEvent"); - PyErr_Clear(); - if (obj && !PythonQtSlotFunction_Check(obj)) { - static const char* argumentList[] ={"" , "QTabletEvent*"}; - static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); - void* args[2] = {NULL, (void*)&arg__1}; - PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); - if (result) { Py_DECREF(result); } - Py_DECREF(obj); - return; - } -} - binaryFileWidget::tabletEvent(arg__1); -} -void PythonQtShell_binaryFileWidget::timerEvent(QTimerEvent* arg__1) -{ -if (_wrapper) { - PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "timerEvent"); - PyErr_Clear(); - if (obj && !PythonQtSlotFunction_Check(obj)) { - static const char* argumentList[] ={"" , "QTimerEvent*"}; - static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); - void* args[2] = {NULL, (void*)&arg__1}; - PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); - if (result) { Py_DECREF(result); } - Py_DECREF(obj); - return; - } -} - binaryFileWidget::timerEvent(arg__1); -} -void PythonQtShell_binaryFileWidget::wheelEvent(QWheelEvent* arg__1) -{ -if (_wrapper) { - PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "wheelEvent"); - PyErr_Clear(); - if (obj && !PythonQtSlotFunction_Check(obj)) { - static const char* argumentList[] ={"" , "QWheelEvent*"}; - static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); - void* args[2] = {NULL, (void*)&arg__1}; - PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); - if (result) { Py_DECREF(result); } - Py_DECREF(obj); - return; - } -} - binaryFileWidget::wheelEvent(arg__1); + if (result) { Py_DECREF(result); } + Py_DECREF(obj); + return; + } +} + binaryFileWidget::reloadFile(); +} +void PythonQtShell_binaryFileWidget::setFile(abstractBinFile* file) +{ +if (_wrapper) { + PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "setFile"); + PyErr_Clear(); + if (obj && !PythonQtSlotFunction_Check(obj)) { + static const char* argumentList[] ={"" , "abstractBinFile*"}; + static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); + void* args[2] = {NULL, (void*)&file}; + PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); + if (result) { Py_DECREF(result); } + Py_DECREF(obj); + return; + } +} + binaryFileWidget::setFile(file); } binaryFileWidget* PythonQtWrapper_binaryFileWidget::new_binaryFileWidget(QWidget* parent) { return new PythonQtShell_binaryFileWidget(parent); } +void PythonQtWrapper_binaryFileWidget::reloadFile(binaryFileWidget* theWrappedObject) +{ + ( ((PythonQtPublicPromoter_binaryFileWidget*)theWrappedObject)->promoted_reloadFile()); +} + +void PythonQtWrapper_binaryFileWidget::setFile(binaryFileWidget* theWrappedObject, abstractBinFile* file) +{ + ( ((PythonQtPublicPromoter_binaryFileWidget*)theWrappedObject)->promoted_setFile(file)); +} + PythonQtShell_codeFragment::~PythonQtShell_codeFragment() { @@ -6080,912 +6359,49 @@ PythonQtShell_elfFileWidget::~PythonQtSh PythonQtPrivate* priv = PythonQt::priv(); if (priv) { priv->shellClassDeleted(this); } } -void PythonQtShell_elfFileWidget::actionEvent(QActionEvent* arg__1) -{ -if (_wrapper) { - PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "actionEvent"); - PyErr_Clear(); - if (obj && !PythonQtSlotFunction_Check(obj)) { - static const char* argumentList[] ={"" , "QActionEvent*"}; - static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); - void* args[2] = {NULL, (void*)&arg__1}; - PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); - if (result) { Py_DECREF(result); } - Py_DECREF(obj); - return; - } -} - elfFileWidget::actionEvent(arg__1); -} -void PythonQtShell_elfFileWidget::changeEvent(QEvent* arg__1) -{ -if (_wrapper) { - PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "changeEvent"); - PyErr_Clear(); - if (obj && !PythonQtSlotFunction_Check(obj)) { - static const char* argumentList[] ={"" , "QEvent*"}; - static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); - void* args[2] = {NULL, (void*)&arg__1}; - PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); - if (result) { Py_DECREF(result); } - Py_DECREF(obj); - return; - } -} - elfFileWidget::changeEvent(arg__1); -} -void PythonQtShell_elfFileWidget::childEvent(QChildEvent* arg__1) -{ -if (_wrapper) { - PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "childEvent"); - PyErr_Clear(); - if (obj && !PythonQtSlotFunction_Check(obj)) { - static const char* argumentList[] ={"" , "QChildEvent*"}; - static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); - void* args[2] = {NULL, (void*)&arg__1}; - PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); - if (result) { Py_DECREF(result); } - Py_DECREF(obj); - return; - } -} - elfFileWidget::childEvent(arg__1); -} -void PythonQtShell_elfFileWidget::closeEvent(QCloseEvent* arg__1) -{ -if (_wrapper) { - PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "closeEvent"); - PyErr_Clear(); - if (obj && !PythonQtSlotFunction_Check(obj)) { - static const char* argumentList[] ={"" , "QCloseEvent*"}; - static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); - void* args[2] = {NULL, (void*)&arg__1}; - PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); - if (result) { Py_DECREF(result); } - Py_DECREF(obj); - return; - } -} - elfFileWidget::closeEvent(arg__1); -} -void PythonQtShell_elfFileWidget::contextMenuEvent(QContextMenuEvent* arg__1) -{ -if (_wrapper) { - PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "contextMenuEvent"); - PyErr_Clear(); - if (obj && !PythonQtSlotFunction_Check(obj)) { - static const char* argumentList[] ={"" , "QContextMenuEvent*"}; - static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); - void* args[2] = {NULL, (void*)&arg__1}; - PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); - if (result) { Py_DECREF(result); } - Py_DECREF(obj); - return; - } -} - elfFileWidget::contextMenuEvent(arg__1); -} -void PythonQtShell_elfFileWidget::customEvent(QEvent* arg__1) -{ -if (_wrapper) { - PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "customEvent"); - PyErr_Clear(); - if (obj && !PythonQtSlotFunction_Check(obj)) { - static const char* argumentList[] ={"" , "QEvent*"}; - static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); - void* args[2] = {NULL, (void*)&arg__1}; - PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); - if (result) { Py_DECREF(result); } - Py_DECREF(obj); - return; - } -} - elfFileWidget::customEvent(arg__1); -} -int PythonQtShell_elfFileWidget::devType() const -{ -if (_wrapper) { - PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "devType"); - PyErr_Clear(); - if (obj && !PythonQtSlotFunction_Check(obj)) { - static const char* argumentList[] ={"int"}; +void PythonQtShell_elfFileWidget::reloadFile() +{ +if (_wrapper) { + PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "reloadFile"); + PyErr_Clear(); + if (obj && !PythonQtSlotFunction_Check(obj)) { + static const char* argumentList[] ={""}; static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); - int returnValue; - void* args[1] = {NULL}; - PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); - if (result) { - args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); - if (args[0]!=&returnValue) { - if (args[0]==NULL) { - PythonQt::priv()->handleVirtualOverloadReturnError("devType", methodInfo, result); - } else { - returnValue = *((int*)args[0]); - } - } - } - if (result) { Py_DECREF(result); } - Py_DECREF(obj); - return returnValue; - } -} - return elfFileWidget::devType(); -} -void PythonQtShell_elfFileWidget::dragEnterEvent(QDragEnterEvent* arg__1) -{ -if (_wrapper) { - PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragEnterEvent"); - PyErr_Clear(); - if (obj && !PythonQtSlotFunction_Check(obj)) { - static const char* argumentList[] ={"" , "QDragEnterEvent*"}; - static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); - void* args[2] = {NULL, (void*)&arg__1}; - PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); - if (result) { Py_DECREF(result); } - Py_DECREF(obj); - return; - } -} - elfFileWidget::dragEnterEvent(arg__1); -} -void PythonQtShell_elfFileWidget::dragLeaveEvent(QDragLeaveEvent* arg__1) -{ -if (_wrapper) { - PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragLeaveEvent"); - PyErr_Clear(); - if (obj && !PythonQtSlotFunction_Check(obj)) { - static const char* argumentList[] ={"" , "QDragLeaveEvent*"}; - static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); - void* args[2] = {NULL, (void*)&arg__1}; - PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); - if (result) { Py_DECREF(result); } - Py_DECREF(obj); - return; - } -} - elfFileWidget::dragLeaveEvent(arg__1); -} -void PythonQtShell_elfFileWidget::dragMoveEvent(QDragMoveEvent* arg__1) -{ -if (_wrapper) { - PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragMoveEvent"); - PyErr_Clear(); - if (obj && !PythonQtSlotFunction_Check(obj)) { - static const char* argumentList[] ={"" , "QDragMoveEvent*"}; - static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); - void* args[2] = {NULL, (void*)&arg__1}; - PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); - if (result) { Py_DECREF(result); } - Py_DECREF(obj); - return; - } -} - elfFileWidget::dragMoveEvent(arg__1); -} -void PythonQtShell_elfFileWidget::dropEvent(QDropEvent* arg__1) -{ -if (_wrapper) { - PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dropEvent"); - PyErr_Clear(); - if (obj && !PythonQtSlotFunction_Check(obj)) { - static const char* argumentList[] ={"" , "QDropEvent*"}; - static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); - void* args[2] = {NULL, (void*)&arg__1}; - PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); - if (result) { Py_DECREF(result); } - Py_DECREF(obj); - return; - } -} - elfFileWidget::dropEvent(arg__1); -} -void PythonQtShell_elfFileWidget::enterEvent(QEvent* arg__1) -{ -if (_wrapper) { - PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "enterEvent"); - PyErr_Clear(); - if (obj && !PythonQtSlotFunction_Check(obj)) { - static const char* argumentList[] ={"" , "QEvent*"}; - static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); - void* args[2] = {NULL, (void*)&arg__1}; - PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); - if (result) { Py_DECREF(result); } - Py_DECREF(obj); - return; - } -} - elfFileWidget::enterEvent(arg__1); -} -bool PythonQtShell_elfFileWidget::event(QEvent* arg__1) -{ -if (_wrapper) { - PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "event"); - PyErr_Clear(); - if (obj && !PythonQtSlotFunction_Check(obj)) { - static const char* argumentList[] ={"bool" , "QEvent*"}; - static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); - bool returnValue; - void* args[2] = {NULL, (void*)&arg__1}; - PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); - if (result) { - args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); - if (args[0]!=&returnValue) { - if (args[0]==NULL) { - PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result); - } else { - returnValue = *((bool*)args[0]); - } - } - } - if (result) { Py_DECREF(result); } - Py_DECREF(obj); - return returnValue; - } -} - return elfFileWidget::event(arg__1); -} -bool PythonQtShell_elfFileWidget::eventFilter(QObject* arg__1, QEvent* arg__2) -{ -if (_wrapper) { - PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "eventFilter"); - PyErr_Clear(); - if (obj && !PythonQtSlotFunction_Check(obj)) { - static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"}; - static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList); - bool returnValue; - void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2}; - PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); - if (result) { - args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); - if (args[0]!=&returnValue) { - if (args[0]==NULL) { - PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result); - } else { - returnValue = *((bool*)args[0]); - } - } - } - if (result) { Py_DECREF(result); } - Py_DECREF(obj); - return returnValue; - } -} - return elfFileWidget::eventFilter(arg__1, arg__2); -} -void PythonQtShell_elfFileWidget::focusInEvent(QFocusEvent* arg__1) -{ -if (_wrapper) { - PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusInEvent"); - PyErr_Clear(); - if (obj && !PythonQtSlotFunction_Check(obj)) { - static const char* argumentList[] ={"" , "QFocusEvent*"}; - static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); - void* args[2] = {NULL, (void*)&arg__1}; - PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); - if (result) { Py_DECREF(result); } - Py_DECREF(obj); - return; - } -} - elfFileWidget::focusInEvent(arg__1); -} -bool PythonQtShell_elfFileWidget::focusNextPrevChild(bool next) -{ -if (_wrapper) { - PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusNextPrevChild"); - PyErr_Clear(); - if (obj && !PythonQtSlotFunction_Check(obj)) { - static const char* argumentList[] ={"bool" , "bool"}; - static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); - bool returnValue; - void* args[2] = {NULL, (void*)&next}; - PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); - if (result) { - args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); - if (args[0]!=&returnValue) { - if (args[0]==NULL) { - PythonQt::priv()->handleVirtualOverloadReturnError("focusNextPrevChild", methodInfo, result); - } else { - returnValue = *((bool*)args[0]); - } - } - } - if (result) { Py_DECREF(result); } - Py_DECREF(obj); - return returnValue; - } -} - return elfFileWidget::focusNextPrevChild(next); -} -void PythonQtShell_elfFileWidget::focusOutEvent(QFocusEvent* arg__1) -{ -if (_wrapper) { - PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusOutEvent"); - PyErr_Clear(); - if (obj && !PythonQtSlotFunction_Check(obj)) { - static const char* argumentList[] ={"" , "QFocusEvent*"}; - static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); - void* args[2] = {NULL, (void*)&arg__1}; - PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); - if (result) { Py_DECREF(result); } - Py_DECREF(obj); - return; - } -} - elfFileWidget::focusOutEvent(arg__1); -} -bool PythonQtShell_elfFileWidget::hasHeightForWidth() const -{ -if (_wrapper) { - PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hasHeightForWidth"); - PyErr_Clear(); - if (obj && !PythonQtSlotFunction_Check(obj)) { - static const char* argumentList[] ={"bool"}; - static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); - bool returnValue; void* args[1] = {NULL}; PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); - if (result) { - args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); - if (args[0]!=&returnValue) { - if (args[0]==NULL) { - PythonQt::priv()->handleVirtualOverloadReturnError("hasHeightForWidth", methodInfo, result); - } else { - returnValue = *((bool*)args[0]); - } - } - } - if (result) { Py_DECREF(result); } - Py_DECREF(obj); - return returnValue; - } -} - return elfFileWidget::hasHeightForWidth(); -} -int PythonQtShell_elfFileWidget::heightForWidth(int arg__1) const -{ -if (_wrapper) { - PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "heightForWidth"); - PyErr_Clear(); - if (obj && !PythonQtSlotFunction_Check(obj)) { - static const char* argumentList[] ={"int" , "int"}; - static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); - int returnValue; - void* args[2] = {NULL, (void*)&arg__1}; - PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); - if (result) { - args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); - if (args[0]!=&returnValue) { - if (args[0]==NULL) { - PythonQt::priv()->handleVirtualOverloadReturnError("heightForWidth", methodInfo, result); - } else { - returnValue = *((int*)args[0]); - } - } - } - if (result) { Py_DECREF(result); } - Py_DECREF(obj); - return returnValue; - } -} - return elfFileWidget::heightForWidth(arg__1); -} -void PythonQtShell_elfFileWidget::hideEvent(QHideEvent* arg__1) -{ -if (_wrapper) { - PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hideEvent"); - PyErr_Clear(); - if (obj && !PythonQtSlotFunction_Check(obj)) { - static const char* argumentList[] ={"" , "QHideEvent*"}; - static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); - void* args[2] = {NULL, (void*)&arg__1}; - PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); - if (result) { Py_DECREF(result); } - Py_DECREF(obj); - return; - } -} - elfFileWidget::hideEvent(arg__1); -} -void PythonQtShell_elfFileWidget::initPainter(QPainter* painter) const -{ -if (_wrapper) { - PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "initPainter"); - PyErr_Clear(); - if (obj && !PythonQtSlotFunction_Check(obj)) { - static const char* argumentList[] ={"" , "QPainter*"}; - static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); - void* args[2] = {NULL, (void*)&painter}; - PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); - if (result) { Py_DECREF(result); } - Py_DECREF(obj); - return; - } -} - elfFileWidget::initPainter(painter); -} -void PythonQtShell_elfFileWidget::inputMethodEvent(QInputMethodEvent* arg__1) -{ -if (_wrapper) { - PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodEvent"); - PyErr_Clear(); - if (obj && !PythonQtSlotFunction_Check(obj)) { - static const char* argumentList[] ={"" , "QInputMethodEvent*"}; - static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); - void* args[2] = {NULL, (void*)&arg__1}; - PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); - if (result) { Py_DECREF(result); } - Py_DECREF(obj); - return; - } -} - elfFileWidget::inputMethodEvent(arg__1); -} -QVariant PythonQtShell_elfFileWidget::inputMethodQuery(Qt::InputMethodQuery arg__1) const -{ -if (_wrapper) { - PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodQuery"); - PyErr_Clear(); - if (obj && !PythonQtSlotFunction_Check(obj)) { - static const char* argumentList[] ={"QVariant" , "Qt::InputMethodQuery"}; - static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); - QVariant returnValue; - void* args[2] = {NULL, (void*)&arg__1}; - PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); - if (result) { - args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); - if (args[0]!=&returnValue) { - if (args[0]==NULL) { - PythonQt::priv()->handleVirtualOverloadReturnError("inputMethodQuery", methodInfo, result); - } else { - returnValue = *((QVariant*)args[0]); - } - } - } - if (result) { Py_DECREF(result); } - Py_DECREF(obj); - return returnValue; - } -} - return elfFileWidget::inputMethodQuery(arg__1); -} -void PythonQtShell_elfFileWidget::keyPressEvent(QKeyEvent* arg__1) -{ -if (_wrapper) { - PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyPressEvent"); - PyErr_Clear(); - if (obj && !PythonQtSlotFunction_Check(obj)) { - static const char* argumentList[] ={"" , "QKeyEvent*"}; - static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); - void* args[2] = {NULL, (void*)&arg__1}; - PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); - if (result) { Py_DECREF(result); } - Py_DECREF(obj); - return; - } -} - elfFileWidget::keyPressEvent(arg__1); -} -void PythonQtShell_elfFileWidget::keyReleaseEvent(QKeyEvent* arg__1) -{ -if (_wrapper) { - PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyReleaseEvent"); - PyErr_Clear(); - if (obj && !PythonQtSlotFunction_Check(obj)) { - static const char* argumentList[] ={"" , "QKeyEvent*"}; - static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); - void* args[2] = {NULL, (void*)&arg__1}; - PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); - if (result) { Py_DECREF(result); } - Py_DECREF(obj); - return; - } -} - elfFileWidget::keyReleaseEvent(arg__1); -} -void PythonQtShell_elfFileWidget::leaveEvent(QEvent* arg__1) -{ -if (_wrapper) { - PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "leaveEvent"); - PyErr_Clear(); - if (obj && !PythonQtSlotFunction_Check(obj)) { - static const char* argumentList[] ={"" , "QEvent*"}; - static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); - void* args[2] = {NULL, (void*)&arg__1}; - PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); - if (result) { Py_DECREF(result); } - Py_DECREF(obj); - return; - } -} - elfFileWidget::leaveEvent(arg__1); -} -int PythonQtShell_elfFileWidget::metric(QPaintDevice::PaintDeviceMetric arg__1) const -{ -if (_wrapper) { - PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "metric"); - PyErr_Clear(); - if (obj && !PythonQtSlotFunction_Check(obj)) { - static const char* argumentList[] ={"int" , "QPaintDevice::PaintDeviceMetric"}; - static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); - int returnValue; - void* args[2] = {NULL, (void*)&arg__1}; - PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); - if (result) { - args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); - if (args[0]!=&returnValue) { - if (args[0]==NULL) { - PythonQt::priv()->handleVirtualOverloadReturnError("metric", methodInfo, result); - } else { - returnValue = *((int*)args[0]); - } - } - } - if (result) { Py_DECREF(result); } - Py_DECREF(obj); - return returnValue; - } -} - return elfFileWidget::metric(arg__1); -} -QSize PythonQtShell_elfFileWidget::minimumSizeHint() const -{ -if (_wrapper) { - PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getMinimumSizeHint"); - PyErr_Clear(); - if (obj && !PythonQtSlotFunction_Check(obj)) { - static const char* argumentList[] ={"QSize"}; - static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); - QSize returnValue; - void* args[1] = {NULL}; - PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); - if (result) { - args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); - if (args[0]!=&returnValue) { - if (args[0]==NULL) { - PythonQt::priv()->handleVirtualOverloadReturnError("getMinimumSizeHint", methodInfo, result); - } else { - returnValue = *((QSize*)args[0]); - } - } - } - if (result) { Py_DECREF(result); } - Py_DECREF(obj); - return returnValue; - } -} - return elfFileWidget::minimumSizeHint(); -} -void PythonQtShell_elfFileWidget::mouseDoubleClickEvent(QMouseEvent* arg__1) -{ -if (_wrapper) { - PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseDoubleClickEvent"); - PyErr_Clear(); - if (obj && !PythonQtSlotFunction_Check(obj)) { - static const char* argumentList[] ={"" , "QMouseEvent*"}; - static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); - void* args[2] = {NULL, (void*)&arg__1}; - PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); - if (result) { Py_DECREF(result); } - Py_DECREF(obj); - return; - } -} - elfFileWidget::mouseDoubleClickEvent(arg__1); -} -void PythonQtShell_elfFileWidget::mouseMoveEvent(QMouseEvent* arg__1) -{ -if (_wrapper) { - PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseMoveEvent"); - PyErr_Clear(); - if (obj && !PythonQtSlotFunction_Check(obj)) { - static const char* argumentList[] ={"" , "QMouseEvent*"}; - static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); - void* args[2] = {NULL, (void*)&arg__1}; - PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); - if (result) { Py_DECREF(result); } - Py_DECREF(obj); - return; - } -} - elfFileWidget::mouseMoveEvent(arg__1); -} -void PythonQtShell_elfFileWidget::mousePressEvent(QMouseEvent* arg__1) -{ -if (_wrapper) { - PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mousePressEvent"); - PyErr_Clear(); - if (obj && !PythonQtSlotFunction_Check(obj)) { - static const char* argumentList[] ={"" , "QMouseEvent*"}; - static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); - void* args[2] = {NULL, (void*)&arg__1}; - PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); - if (result) { Py_DECREF(result); } - Py_DECREF(obj); - return; - } -} - elfFileWidget::mousePressEvent(arg__1); -} -void PythonQtShell_elfFileWidget::mouseReleaseEvent(QMouseEvent* arg__1) -{ -if (_wrapper) { - PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseReleaseEvent"); - PyErr_Clear(); - if (obj && !PythonQtSlotFunction_Check(obj)) { - static const char* argumentList[] ={"" , "QMouseEvent*"}; - static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); - void* args[2] = {NULL, (void*)&arg__1}; - PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); - if (result) { Py_DECREF(result); } - Py_DECREF(obj); - return; - } -} - elfFileWidget::mouseReleaseEvent(arg__1); -} -void PythonQtShell_elfFileWidget::moveEvent(QMoveEvent* arg__1) -{ -if (_wrapper) { - PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "moveEvent"); - PyErr_Clear(); - if (obj && !PythonQtSlotFunction_Check(obj)) { - static const char* argumentList[] ={"" , "QMoveEvent*"}; - static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); - void* args[2] = {NULL, (void*)&arg__1}; - PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); - if (result) { Py_DECREF(result); } - Py_DECREF(obj); - return; - } -} - elfFileWidget::moveEvent(arg__1); -} -bool PythonQtShell_elfFileWidget::nativeEvent(const QByteArray& eventType, void* message, long* result) -{ -if (_wrapper) { - PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "nativeEvent"); - PyErr_Clear(); - if (obj && !PythonQtSlotFunction_Check(obj)) { - static const char* argumentList[] ={"bool" , "const QByteArray&" , "void*" , "long*"}; - static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList); - bool returnValue; - void* args[4] = {NULL, (void*)&eventType, (void*)&message, (void*)&result}; - PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); - if (result) { - args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); - if (args[0]!=&returnValue) { - if (args[0]==NULL) { - PythonQt::priv()->handleVirtualOverloadReturnError("nativeEvent", methodInfo, result); - } else { - returnValue = *((bool*)args[0]); - } - } - } - if (result) { Py_DECREF(result); } - Py_DECREF(obj); - return returnValue; - } -} - return elfFileWidget::nativeEvent(eventType, message, result); -} -QPaintEngine* PythonQtShell_elfFileWidget::paintEngine() const -{ -if (_wrapper) { - PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEngine"); - PyErr_Clear(); - if (obj && !PythonQtSlotFunction_Check(obj)) { - static const char* argumentList[] ={"QPaintEngine*"}; - static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); - QPaintEngine* returnValue; - void* args[1] = {NULL}; - PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); - if (result) { - args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); - if (args[0]!=&returnValue) { - if (args[0]==NULL) { - PythonQt::priv()->handleVirtualOverloadReturnError("paintEngine", methodInfo, result); - } else { - returnValue = *((QPaintEngine**)args[0]); - } - } - } - if (result) { Py_DECREF(result); } - Py_DECREF(obj); - return returnValue; - } -} - return elfFileWidget::paintEngine(); -} -void PythonQtShell_elfFileWidget::paintEvent(QPaintEvent* arg__1) -{ -if (_wrapper) { - PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEvent"); - PyErr_Clear(); - if (obj && !PythonQtSlotFunction_Check(obj)) { - static const char* argumentList[] ={"" , "QPaintEvent*"}; - static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); - void* args[2] = {NULL, (void*)&arg__1}; - PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); - if (result) { Py_DECREF(result); } - Py_DECREF(obj); - return; - } -} - elfFileWidget::paintEvent(arg__1); -} -QPaintDevice* PythonQtShell_elfFileWidget::redirected(QPoint* offset) const -{ -if (_wrapper) { - PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "redirected"); - PyErr_Clear(); - if (obj && !PythonQtSlotFunction_Check(obj)) { - static const char* argumentList[] ={"QPaintDevice*" , "QPoint*"}; - static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); - QPaintDevice* returnValue; - void* args[2] = {NULL, (void*)&offset}; - PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); - if (result) { - args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); - if (args[0]!=&returnValue) { - if (args[0]==NULL) { - PythonQt::priv()->handleVirtualOverloadReturnError("redirected", methodInfo, result); - } else { - returnValue = *((QPaintDevice**)args[0]); - } - } - } - if (result) { Py_DECREF(result); } - Py_DECREF(obj); - return returnValue; - } -} - return elfFileWidget::redirected(offset); -} -void PythonQtShell_elfFileWidget::resizeEvent(QResizeEvent* arg__1) -{ -if (_wrapper) { - PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "resizeEvent"); - PyErr_Clear(); - if (obj && !PythonQtSlotFunction_Check(obj)) { - static const char* argumentList[] ={"" , "QResizeEvent*"}; - static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); - void* args[2] = {NULL, (void*)&arg__1}; - PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); - if (result) { Py_DECREF(result); } - Py_DECREF(obj); - return; - } -} - elfFileWidget::resizeEvent(arg__1); -} -QPainter* PythonQtShell_elfFileWidget::sharedPainter() const -{ -if (_wrapper) { - PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "sharedPainter"); - PyErr_Clear(); - if (obj && !PythonQtSlotFunction_Check(obj)) { - static const char* argumentList[] ={"QPainter*"}; - static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); - QPainter* returnValue; - void* args[1] = {NULL}; - PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); - if (result) { - args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); - if (args[0]!=&returnValue) { - if (args[0]==NULL) { - PythonQt::priv()->handleVirtualOverloadReturnError("sharedPainter", methodInfo, result); - } else { - returnValue = *((QPainter**)args[0]); - } - } - } - if (result) { Py_DECREF(result); } - Py_DECREF(obj); - return returnValue; - } -} - return elfFileWidget::sharedPainter(); -} -void PythonQtShell_elfFileWidget::showEvent(QShowEvent* arg__1) -{ -if (_wrapper) { - PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "showEvent"); - PyErr_Clear(); - if (obj && !PythonQtSlotFunction_Check(obj)) { - static const char* argumentList[] ={"" , "QShowEvent*"}; - static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); - void* args[2] = {NULL, (void*)&arg__1}; - PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); - if (result) { Py_DECREF(result); } - Py_DECREF(obj); - return; - } -} - elfFileWidget::showEvent(arg__1); -} -QSize PythonQtShell_elfFileWidget::sizeHint() const -{ -if (_wrapper) { - PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getSizeHint"); - PyErr_Clear(); - if (obj && !PythonQtSlotFunction_Check(obj)) { - static const char* argumentList[] ={"QSize"}; - static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); - QSize returnValue; - void* args[1] = {NULL}; - PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); - if (result) { - args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); - if (args[0]!=&returnValue) { - if (args[0]==NULL) { - PythonQt::priv()->handleVirtualOverloadReturnError("getSizeHint", methodInfo, result); - } else { - returnValue = *((QSize*)args[0]); - } - } - } - if (result) { Py_DECREF(result); } - Py_DECREF(obj); - return returnValue; - } -} - return elfFileWidget::sizeHint(); -} -void PythonQtShell_elfFileWidget::tabletEvent(QTabletEvent* arg__1) -{ -if (_wrapper) { - PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "tabletEvent"); - PyErr_Clear(); - if (obj && !PythonQtSlotFunction_Check(obj)) { - static const char* argumentList[] ={"" , "QTabletEvent*"}; - static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); - void* args[2] = {NULL, (void*)&arg__1}; - PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); - if (result) { Py_DECREF(result); } - Py_DECREF(obj); - return; - } -} - elfFileWidget::tabletEvent(arg__1); -} -void PythonQtShell_elfFileWidget::timerEvent(QTimerEvent* arg__1) -{ -if (_wrapper) { - PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "timerEvent"); - PyErr_Clear(); - if (obj && !PythonQtSlotFunction_Check(obj)) { - static const char* argumentList[] ={"" , "QTimerEvent*"}; - static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); - void* args[2] = {NULL, (void*)&arg__1}; - PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); - if (result) { Py_DECREF(result); } - Py_DECREF(obj); - return; - } -} - elfFileWidget::timerEvent(arg__1); -} -void PythonQtShell_elfFileWidget::wheelEvent(QWheelEvent* arg__1) -{ -if (_wrapper) { - PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "wheelEvent"); - PyErr_Clear(); - if (obj && !PythonQtSlotFunction_Check(obj)) { - static const char* argumentList[] ={"" , "QWheelEvent*"}; - static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); - void* args[2] = {NULL, (void*)&arg__1}; - PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); - if (result) { Py_DECREF(result); } - Py_DECREF(obj); - return; - } -} - elfFileWidget::wheelEvent(arg__1); + if (result) { Py_DECREF(result); } + Py_DECREF(obj); + return; + } +} + elfFileWidget::reloadFile(); +} +void PythonQtShell_elfFileWidget::setFile(abstractBinFile* file) +{ +if (_wrapper) { + PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "setFile"); + PyErr_Clear(); + if (obj && !PythonQtSlotFunction_Check(obj)) { + static const char* argumentList[] ={"" , "abstractBinFile*"}; + static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); + void* args[2] = {NULL, (void*)&file}; + PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); + if (result) { Py_DECREF(result); } + Py_DECREF(obj); + return; + } +} + } elfFileWidget* 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() { @@ -8157,6 +7573,62 @@ if (_wrapper) { } 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(); } @@ -8174,6 +7646,11 @@ int PythonQtWrapper_srecFile::closeFile 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)); @@ -8234,921 +7711,73 @@ bool PythonQtWrapper_srecFile::openFile 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 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) -{ -if (_wrapper) { - PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "actionEvent"); - PyErr_Clear(); - if (obj && !PythonQtSlotFunction_Check(obj)) { - static const char* argumentList[] ={"" , "QActionEvent*"}; - static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); - void* args[2] = {NULL, (void*)&arg__1}; - PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); - if (result) { Py_DECREF(result); } - Py_DECREF(obj); - return; - } -} - srecFileWidget::actionEvent(arg__1); -} -void PythonQtShell_srecFileWidget::changeEvent(QEvent* arg__1) -{ -if (_wrapper) { - PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "changeEvent"); - PyErr_Clear(); - if (obj && !PythonQtSlotFunction_Check(obj)) { - static const char* argumentList[] ={"" , "QEvent*"}; - static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); - void* args[2] = {NULL, (void*)&arg__1}; - PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); - if (result) { Py_DECREF(result); } - Py_DECREF(obj); - return; - } -} - srecFileWidget::changeEvent(arg__1); -} -void PythonQtShell_srecFileWidget::childEvent(QChildEvent* arg__1) -{ -if (_wrapper) { - PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "childEvent"); - PyErr_Clear(); - if (obj && !PythonQtSlotFunction_Check(obj)) { - static const char* argumentList[] ={"" , "QChildEvent*"}; - static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); - void* args[2] = {NULL, (void*)&arg__1}; - PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); - if (result) { Py_DECREF(result); } - Py_DECREF(obj); - return; - } -} - srecFileWidget::childEvent(arg__1); -} -void PythonQtShell_srecFileWidget::closeEvent(QCloseEvent* arg__1) -{ -if (_wrapper) { - PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "closeEvent"); - PyErr_Clear(); - if (obj && !PythonQtSlotFunction_Check(obj)) { - static const char* argumentList[] ={"" , "QCloseEvent*"}; - static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); - void* args[2] = {NULL, (void*)&arg__1}; - PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); - if (result) { Py_DECREF(result); } - Py_DECREF(obj); - return; - } -} - srecFileWidget::closeEvent(arg__1); -} -void PythonQtShell_srecFileWidget::contextMenuEvent(QContextMenuEvent* arg__1) -{ -if (_wrapper) { - PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "contextMenuEvent"); - PyErr_Clear(); - if (obj && !PythonQtSlotFunction_Check(obj)) { - static const char* argumentList[] ={"" , "QContextMenuEvent*"}; - static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); - void* args[2] = {NULL, (void*)&arg__1}; - PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); - if (result) { Py_DECREF(result); } - Py_DECREF(obj); - return; - } -} - srecFileWidget::contextMenuEvent(arg__1); -} -void PythonQtShell_srecFileWidget::customEvent(QEvent* arg__1) -{ -if (_wrapper) { - PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "customEvent"); - PyErr_Clear(); - if (obj && !PythonQtSlotFunction_Check(obj)) { - static const char* argumentList[] ={"" , "QEvent*"}; - static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); - void* args[2] = {NULL, (void*)&arg__1}; - PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); - if (result) { Py_DECREF(result); } - Py_DECREF(obj); - return; - } -} - srecFileWidget::customEvent(arg__1); -} -int PythonQtShell_srecFileWidget::devType() const -{ -if (_wrapper) { - PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "devType"); - PyErr_Clear(); - if (obj && !PythonQtSlotFunction_Check(obj)) { - static const char* argumentList[] ={"int"}; +void PythonQtShell_srecFileWidget::reloadFile() +{ +if (_wrapper) { + PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "reloadFile"); + PyErr_Clear(); + if (obj && !PythonQtSlotFunction_Check(obj)) { + static const char* argumentList[] ={""}; static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); - int returnValue; - void* args[1] = {NULL}; - PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); - if (result) { - args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); - if (args[0]!=&returnValue) { - if (args[0]==NULL) { - PythonQt::priv()->handleVirtualOverloadReturnError("devType", methodInfo, result); - } else { - returnValue = *((int*)args[0]); - } - } - } - if (result) { Py_DECREF(result); } - Py_DECREF(obj); - return returnValue; - } -} - return srecFileWidget::devType(); -} -void PythonQtShell_srecFileWidget::dragEnterEvent(QDragEnterEvent* arg__1) -{ -if (_wrapper) { - PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragEnterEvent"); - PyErr_Clear(); - if (obj && !PythonQtSlotFunction_Check(obj)) { - static const char* argumentList[] ={"" , "QDragEnterEvent*"}; - static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); - void* args[2] = {NULL, (void*)&arg__1}; - PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); - if (result) { Py_DECREF(result); } - Py_DECREF(obj); - return; - } -} - srecFileWidget::dragEnterEvent(arg__1); -} -void PythonQtShell_srecFileWidget::dragLeaveEvent(QDragLeaveEvent* arg__1) -{ -if (_wrapper) { - PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragLeaveEvent"); - PyErr_Clear(); - if (obj && !PythonQtSlotFunction_Check(obj)) { - static const char* argumentList[] ={"" , "QDragLeaveEvent*"}; - static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); - void* args[2] = {NULL, (void*)&arg__1}; - PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); - if (result) { Py_DECREF(result); } - Py_DECREF(obj); - return; - } -} - srecFileWidget::dragLeaveEvent(arg__1); -} -void PythonQtShell_srecFileWidget::dragMoveEvent(QDragMoveEvent* arg__1) -{ -if (_wrapper) { - PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragMoveEvent"); - PyErr_Clear(); - if (obj && !PythonQtSlotFunction_Check(obj)) { - static const char* argumentList[] ={"" , "QDragMoveEvent*"}; - static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); - void* args[2] = {NULL, (void*)&arg__1}; - PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); - if (result) { Py_DECREF(result); } - Py_DECREF(obj); - return; - } -} - srecFileWidget::dragMoveEvent(arg__1); -} -void PythonQtShell_srecFileWidget::dropEvent(QDropEvent* arg__1) -{ -if (_wrapper) { - PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dropEvent"); - PyErr_Clear(); - if (obj && !PythonQtSlotFunction_Check(obj)) { - static const char* argumentList[] ={"" , "QDropEvent*"}; - static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); - void* args[2] = {NULL, (void*)&arg__1}; - PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); - if (result) { Py_DECREF(result); } - Py_DECREF(obj); - return; - } -} - srecFileWidget::dropEvent(arg__1); -} -void PythonQtShell_srecFileWidget::enterEvent(QEvent* arg__1) -{ -if (_wrapper) { - PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "enterEvent"); - PyErr_Clear(); - if (obj && !PythonQtSlotFunction_Check(obj)) { - static const char* argumentList[] ={"" , "QEvent*"}; - static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); - void* args[2] = {NULL, (void*)&arg__1}; - PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); - if (result) { Py_DECREF(result); } - Py_DECREF(obj); - return; - } -} - srecFileWidget::enterEvent(arg__1); -} -bool PythonQtShell_srecFileWidget::event(QEvent* arg__1) -{ -if (_wrapper) { - PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "event"); - PyErr_Clear(); - if (obj && !PythonQtSlotFunction_Check(obj)) { - static const char* argumentList[] ={"bool" , "QEvent*"}; - static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); - bool returnValue; - void* args[2] = {NULL, (void*)&arg__1}; - PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); - if (result) { - args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); - if (args[0]!=&returnValue) { - if (args[0]==NULL) { - PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result); - } else { - returnValue = *((bool*)args[0]); - } - } - } - if (result) { Py_DECREF(result); } - Py_DECREF(obj); - return returnValue; - } -} - return srecFileWidget::event(arg__1); -} -bool PythonQtShell_srecFileWidget::eventFilter(QObject* arg__1, QEvent* arg__2) -{ -if (_wrapper) { - PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "eventFilter"); - PyErr_Clear(); - if (obj && !PythonQtSlotFunction_Check(obj)) { - static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"}; - static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList); - bool returnValue; - void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2}; - PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); - if (result) { - args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); - if (args[0]!=&returnValue) { - if (args[0]==NULL) { - PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result); - } else { - returnValue = *((bool*)args[0]); - } - } - } - if (result) { Py_DECREF(result); } - Py_DECREF(obj); - return returnValue; - } -} - return srecFileWidget::eventFilter(arg__1, arg__2); -} -void PythonQtShell_srecFileWidget::focusInEvent(QFocusEvent* arg__1) -{ -if (_wrapper) { - PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusInEvent"); - PyErr_Clear(); - if (obj && !PythonQtSlotFunction_Check(obj)) { - static const char* argumentList[] ={"" , "QFocusEvent*"}; - static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); - void* args[2] = {NULL, (void*)&arg__1}; - PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); - if (result) { Py_DECREF(result); } - Py_DECREF(obj); - return; - } -} - srecFileWidget::focusInEvent(arg__1); -} -bool PythonQtShell_srecFileWidget::focusNextPrevChild(bool next) -{ -if (_wrapper) { - PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusNextPrevChild"); - PyErr_Clear(); - if (obj && !PythonQtSlotFunction_Check(obj)) { - static const char* argumentList[] ={"bool" , "bool"}; - static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); - bool returnValue; - void* args[2] = {NULL, (void*)&next}; - PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); - if (result) { - args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); - if (args[0]!=&returnValue) { - if (args[0]==NULL) { - PythonQt::priv()->handleVirtualOverloadReturnError("focusNextPrevChild", methodInfo, result); - } else { - returnValue = *((bool*)args[0]); - } - } - } - if (result) { Py_DECREF(result); } - Py_DECREF(obj); - return returnValue; - } -} - return srecFileWidget::focusNextPrevChild(next); -} -void PythonQtShell_srecFileWidget::focusOutEvent(QFocusEvent* arg__1) -{ -if (_wrapper) { - PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusOutEvent"); - PyErr_Clear(); - if (obj && !PythonQtSlotFunction_Check(obj)) { - static const char* argumentList[] ={"" , "QFocusEvent*"}; - static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); - void* args[2] = {NULL, (void*)&arg__1}; - PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); - if (result) { Py_DECREF(result); } - Py_DECREF(obj); - return; - } -} - srecFileWidget::focusOutEvent(arg__1); -} -bool PythonQtShell_srecFileWidget::hasHeightForWidth() const -{ -if (_wrapper) { - PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hasHeightForWidth"); - PyErr_Clear(); - if (obj && !PythonQtSlotFunction_Check(obj)) { - static const char* argumentList[] ={"bool"}; - static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); - bool returnValue; void* args[1] = {NULL}; PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); - if (result) { - args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); - if (args[0]!=&returnValue) { - if (args[0]==NULL) { - PythonQt::priv()->handleVirtualOverloadReturnError("hasHeightForWidth", methodInfo, result); - } else { - returnValue = *((bool*)args[0]); - } - } - } - if (result) { Py_DECREF(result); } - Py_DECREF(obj); - return returnValue; - } -} - return srecFileWidget::hasHeightForWidth(); -} -int PythonQtShell_srecFileWidget::heightForWidth(int arg__1) const -{ -if (_wrapper) { - PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "heightForWidth"); - PyErr_Clear(); - if (obj && !PythonQtSlotFunction_Check(obj)) { - static const char* argumentList[] ={"int" , "int"}; - static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); - int returnValue; - void* args[2] = {NULL, (void*)&arg__1}; - PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); - if (result) { - args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); - if (args[0]!=&returnValue) { - if (args[0]==NULL) { - PythonQt::priv()->handleVirtualOverloadReturnError("heightForWidth", methodInfo, result); - } else { - returnValue = *((int*)args[0]); - } - } - } - if (result) { Py_DECREF(result); } - Py_DECREF(obj); - return returnValue; - } -} - return srecFileWidget::heightForWidth(arg__1); -} -void PythonQtShell_srecFileWidget::hideEvent(QHideEvent* arg__1) -{ -if (_wrapper) { - PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hideEvent"); - PyErr_Clear(); - if (obj && !PythonQtSlotFunction_Check(obj)) { - static const char* argumentList[] ={"" , "QHideEvent*"}; - static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); - void* args[2] = {NULL, (void*)&arg__1}; - PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); - if (result) { Py_DECREF(result); } - Py_DECREF(obj); - return; - } -} - srecFileWidget::hideEvent(arg__1); -} -void PythonQtShell_srecFileWidget::initPainter(QPainter* painter) const -{ -if (_wrapper) { - PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "initPainter"); - PyErr_Clear(); - if (obj && !PythonQtSlotFunction_Check(obj)) { - static const char* argumentList[] ={"" , "QPainter*"}; - static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); - void* args[2] = {NULL, (void*)&painter}; - PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); - if (result) { Py_DECREF(result); } - Py_DECREF(obj); - return; - } -} - srecFileWidget::initPainter(painter); -} -void PythonQtShell_srecFileWidget::inputMethodEvent(QInputMethodEvent* arg__1) -{ -if (_wrapper) { - PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodEvent"); - PyErr_Clear(); - if (obj && !PythonQtSlotFunction_Check(obj)) { - static const char* argumentList[] ={"" , "QInputMethodEvent*"}; - static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); - void* args[2] = {NULL, (void*)&arg__1}; - PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); - if (result) { Py_DECREF(result); } - Py_DECREF(obj); - return; - } -} - srecFileWidget::inputMethodEvent(arg__1); -} -QVariant PythonQtShell_srecFileWidget::inputMethodQuery(Qt::InputMethodQuery arg__1) const -{ -if (_wrapper) { - PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodQuery"); - PyErr_Clear(); - if (obj && !PythonQtSlotFunction_Check(obj)) { - static const char* argumentList[] ={"QVariant" , "Qt::InputMethodQuery"}; - static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); - QVariant returnValue; - void* args[2] = {NULL, (void*)&arg__1}; - PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); - if (result) { - args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); - if (args[0]!=&returnValue) { - if (args[0]==NULL) { - PythonQt::priv()->handleVirtualOverloadReturnError("inputMethodQuery", methodInfo, result); - } else { - returnValue = *((QVariant*)args[0]); - } - } - } - if (result) { Py_DECREF(result); } - Py_DECREF(obj); - return returnValue; - } -} - return srecFileWidget::inputMethodQuery(arg__1); -} -void PythonQtShell_srecFileWidget::keyPressEvent(QKeyEvent* arg__1) -{ -if (_wrapper) { - PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyPressEvent"); - PyErr_Clear(); - if (obj && !PythonQtSlotFunction_Check(obj)) { - static const char* argumentList[] ={"" , "QKeyEvent*"}; - static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); - void* args[2] = {NULL, (void*)&arg__1}; - PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); - if (result) { Py_DECREF(result); } - Py_DECREF(obj); - return; - } -} - srecFileWidget::keyPressEvent(arg__1); -} -void PythonQtShell_srecFileWidget::keyReleaseEvent(QKeyEvent* arg__1) -{ -if (_wrapper) { - PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyReleaseEvent"); - PyErr_Clear(); - if (obj && !PythonQtSlotFunction_Check(obj)) { - static const char* argumentList[] ={"" , "QKeyEvent*"}; - static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); - void* args[2] = {NULL, (void*)&arg__1}; - PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); - if (result) { Py_DECREF(result); } - Py_DECREF(obj); - return; - } -} - srecFileWidget::keyReleaseEvent(arg__1); -} -void PythonQtShell_srecFileWidget::leaveEvent(QEvent* arg__1) -{ -if (_wrapper) { - PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "leaveEvent"); - PyErr_Clear(); - if (obj && !PythonQtSlotFunction_Check(obj)) { - static const char* argumentList[] ={"" , "QEvent*"}; - static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); - void* args[2] = {NULL, (void*)&arg__1}; - PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); - if (result) { Py_DECREF(result); } - Py_DECREF(obj); - return; - } -} - srecFileWidget::leaveEvent(arg__1); -} -int PythonQtShell_srecFileWidget::metric(QPaintDevice::PaintDeviceMetric arg__1) const -{ -if (_wrapper) { - PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "metric"); - PyErr_Clear(); - if (obj && !PythonQtSlotFunction_Check(obj)) { - static const char* argumentList[] ={"int" , "QPaintDevice::PaintDeviceMetric"}; - static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); - int returnValue; - void* args[2] = {NULL, (void*)&arg__1}; - PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); - if (result) { - args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); - if (args[0]!=&returnValue) { - if (args[0]==NULL) { - PythonQt::priv()->handleVirtualOverloadReturnError("metric", methodInfo, result); - } else { - returnValue = *((int*)args[0]); - } - } - } - if (result) { Py_DECREF(result); } - Py_DECREF(obj); - return returnValue; - } -} - return srecFileWidget::metric(arg__1); -} -QSize PythonQtShell_srecFileWidget::minimumSizeHint() const -{ -if (_wrapper) { - PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getMinimumSizeHint"); - PyErr_Clear(); - if (obj && !PythonQtSlotFunction_Check(obj)) { - static const char* argumentList[] ={"QSize"}; - static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); - QSize returnValue; - void* args[1] = {NULL}; - PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); - if (result) { - args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); - if (args[0]!=&returnValue) { - if (args[0]==NULL) { - PythonQt::priv()->handleVirtualOverloadReturnError("getMinimumSizeHint", methodInfo, result); - } else { - returnValue = *((QSize*)args[0]); - } - } - } - if (result) { Py_DECREF(result); } - Py_DECREF(obj); - return returnValue; - } -} - return srecFileWidget::minimumSizeHint(); -} -void PythonQtShell_srecFileWidget::mouseDoubleClickEvent(QMouseEvent* arg__1) -{ -if (_wrapper) { - PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseDoubleClickEvent"); - PyErr_Clear(); - if (obj && !PythonQtSlotFunction_Check(obj)) { - static const char* argumentList[] ={"" , "QMouseEvent*"}; - static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); - void* args[2] = {NULL, (void*)&arg__1}; - PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); - if (result) { Py_DECREF(result); } - Py_DECREF(obj); - return; - } -} - srecFileWidget::mouseDoubleClickEvent(arg__1); -} -void PythonQtShell_srecFileWidget::mouseMoveEvent(QMouseEvent* arg__1) -{ -if (_wrapper) { - PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseMoveEvent"); - PyErr_Clear(); - if (obj && !PythonQtSlotFunction_Check(obj)) { - static const char* argumentList[] ={"" , "QMouseEvent*"}; - static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); - void* args[2] = {NULL, (void*)&arg__1}; - PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); - if (result) { Py_DECREF(result); } - Py_DECREF(obj); - return; - } -} - srecFileWidget::mouseMoveEvent(arg__1); -} -void PythonQtShell_srecFileWidget::mousePressEvent(QMouseEvent* arg__1) -{ -if (_wrapper) { - PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mousePressEvent"); - PyErr_Clear(); - if (obj && !PythonQtSlotFunction_Check(obj)) { - static const char* argumentList[] ={"" , "QMouseEvent*"}; - static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); - void* args[2] = {NULL, (void*)&arg__1}; - PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); - if (result) { Py_DECREF(result); } - Py_DECREF(obj); - return; - } -} - srecFileWidget::mousePressEvent(arg__1); -} -void PythonQtShell_srecFileWidget::mouseReleaseEvent(QMouseEvent* arg__1) -{ -if (_wrapper) { - PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseReleaseEvent"); - PyErr_Clear(); - if (obj && !PythonQtSlotFunction_Check(obj)) { - static const char* argumentList[] ={"" , "QMouseEvent*"}; - static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); - void* args[2] = {NULL, (void*)&arg__1}; - PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); - if (result) { Py_DECREF(result); } - Py_DECREF(obj); - return; - } -} - srecFileWidget::mouseReleaseEvent(arg__1); -} -void PythonQtShell_srecFileWidget::moveEvent(QMoveEvent* arg__1) -{ -if (_wrapper) { - PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "moveEvent"); - PyErr_Clear(); - if (obj && !PythonQtSlotFunction_Check(obj)) { - static const char* argumentList[] ={"" , "QMoveEvent*"}; - static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); - void* args[2] = {NULL, (void*)&arg__1}; - PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); - if (result) { Py_DECREF(result); } - Py_DECREF(obj); - return; - } -} - srecFileWidget::moveEvent(arg__1); -} -bool PythonQtShell_srecFileWidget::nativeEvent(const QByteArray& eventType, void* message, long* result) -{ -if (_wrapper) { - PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "nativeEvent"); - PyErr_Clear(); - if (obj && !PythonQtSlotFunction_Check(obj)) { - static const char* argumentList[] ={"bool" , "const QByteArray&" , "void*" , "long*"}; - static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList); - bool returnValue; - void* args[4] = {NULL, (void*)&eventType, (void*)&message, (void*)&result}; - PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); - if (result) { - args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); - if (args[0]!=&returnValue) { - if (args[0]==NULL) { - PythonQt::priv()->handleVirtualOverloadReturnError("nativeEvent", methodInfo, result); - } else { - returnValue = *((bool*)args[0]); - } - } - } - if (result) { Py_DECREF(result); } - Py_DECREF(obj); - return returnValue; - } -} - return srecFileWidget::nativeEvent(eventType, message, result); -} -QPaintEngine* PythonQtShell_srecFileWidget::paintEngine() const -{ -if (_wrapper) { - PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEngine"); - PyErr_Clear(); - if (obj && !PythonQtSlotFunction_Check(obj)) { - static const char* argumentList[] ={"QPaintEngine*"}; - static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); - QPaintEngine* returnValue; - void* args[1] = {NULL}; - PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); - if (result) { - args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); - if (args[0]!=&returnValue) { - if (args[0]==NULL) { - PythonQt::priv()->handleVirtualOverloadReturnError("paintEngine", methodInfo, result); - } else { - returnValue = *((QPaintEngine**)args[0]); - } - } - } - if (result) { Py_DECREF(result); } - Py_DECREF(obj); - return returnValue; - } -} - return srecFileWidget::paintEngine(); -} -void PythonQtShell_srecFileWidget::paintEvent(QPaintEvent* arg__1) -{ -if (_wrapper) { - PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEvent"); - PyErr_Clear(); - if (obj && !PythonQtSlotFunction_Check(obj)) { - static const char* argumentList[] ={"" , "QPaintEvent*"}; - static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); - void* args[2] = {NULL, (void*)&arg__1}; - PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); - if (result) { Py_DECREF(result); } - Py_DECREF(obj); - return; - } -} - srecFileWidget::paintEvent(arg__1); -} -QPaintDevice* PythonQtShell_srecFileWidget::redirected(QPoint* offset) const -{ -if (_wrapper) { - PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "redirected"); - PyErr_Clear(); - if (obj && !PythonQtSlotFunction_Check(obj)) { - static const char* argumentList[] ={"QPaintDevice*" , "QPoint*"}; - static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); - QPaintDevice* returnValue; - void* args[2] = {NULL, (void*)&offset}; - PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); - if (result) { - args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); - if (args[0]!=&returnValue) { - if (args[0]==NULL) { - PythonQt::priv()->handleVirtualOverloadReturnError("redirected", methodInfo, result); - } else { - returnValue = *((QPaintDevice**)args[0]); - } - } - } - if (result) { Py_DECREF(result); } - Py_DECREF(obj); - return returnValue; - } -} - return srecFileWidget::redirected(offset); -} -void PythonQtShell_srecFileWidget::resizeEvent(QResizeEvent* arg__1) -{ -if (_wrapper) { - PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "resizeEvent"); - PyErr_Clear(); - if (obj && !PythonQtSlotFunction_Check(obj)) { - static const char* argumentList[] ={"" , "QResizeEvent*"}; - static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); - void* args[2] = {NULL, (void*)&arg__1}; - PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); - if (result) { Py_DECREF(result); } - Py_DECREF(obj); - return; - } -} - srecFileWidget::resizeEvent(arg__1); -} -QPainter* PythonQtShell_srecFileWidget::sharedPainter() const -{ -if (_wrapper) { - PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "sharedPainter"); - PyErr_Clear(); - if (obj && !PythonQtSlotFunction_Check(obj)) { - static const char* argumentList[] ={"QPainter*"}; - static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); - QPainter* returnValue; - void* args[1] = {NULL}; - PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); - if (result) { - args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); - if (args[0]!=&returnValue) { - if (args[0]==NULL) { - PythonQt::priv()->handleVirtualOverloadReturnError("sharedPainter", methodInfo, result); - } else { - returnValue = *((QPainter**)args[0]); - } - } - } - if (result) { Py_DECREF(result); } - Py_DECREF(obj); - return returnValue; - } -} - return srecFileWidget::sharedPainter(); -} -void PythonQtShell_srecFileWidget::showEvent(QShowEvent* arg__1) -{ -if (_wrapper) { - PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "showEvent"); - PyErr_Clear(); - if (obj && !PythonQtSlotFunction_Check(obj)) { - static const char* argumentList[] ={"" , "QShowEvent*"}; - static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); - void* args[2] = {NULL, (void*)&arg__1}; - PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); - if (result) { Py_DECREF(result); } - Py_DECREF(obj); - return; - } -} - srecFileWidget::showEvent(arg__1); -} -QSize PythonQtShell_srecFileWidget::sizeHint() const -{ -if (_wrapper) { - PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getSizeHint"); - PyErr_Clear(); - if (obj && !PythonQtSlotFunction_Check(obj)) { - static const char* argumentList[] ={"QSize"}; - static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); - QSize returnValue; - void* args[1] = {NULL}; - PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); - if (result) { - args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); - if (args[0]!=&returnValue) { - if (args[0]==NULL) { - PythonQt::priv()->handleVirtualOverloadReturnError("getSizeHint", methodInfo, result); - } else { - returnValue = *((QSize*)args[0]); - } - } - } - if (result) { Py_DECREF(result); } - Py_DECREF(obj); - return returnValue; - } -} - return srecFileWidget::sizeHint(); -} -void PythonQtShell_srecFileWidget::tabletEvent(QTabletEvent* arg__1) -{ -if (_wrapper) { - PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "tabletEvent"); - PyErr_Clear(); - if (obj && !PythonQtSlotFunction_Check(obj)) { - static const char* argumentList[] ={"" , "QTabletEvent*"}; - static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); - void* args[2] = {NULL, (void*)&arg__1}; - PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); - if (result) { Py_DECREF(result); } - Py_DECREF(obj); - return; - } -} - srecFileWidget::tabletEvent(arg__1); -} -void PythonQtShell_srecFileWidget::timerEvent(QTimerEvent* arg__1) -{ -if (_wrapper) { - PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "timerEvent"); - PyErr_Clear(); - if (obj && !PythonQtSlotFunction_Check(obj)) { - static const char* argumentList[] ={"" , "QTimerEvent*"}; - static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); - void* args[2] = {NULL, (void*)&arg__1}; - PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); - if (result) { Py_DECREF(result); } - Py_DECREF(obj); - return; - } -} - srecFileWidget::timerEvent(arg__1); -} -void PythonQtShell_srecFileWidget::wheelEvent(QWheelEvent* arg__1) -{ -if (_wrapper) { - PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "wheelEvent"); - PyErr_Clear(); - if (obj && !PythonQtSlotFunction_Check(obj)) { - static const char* argumentList[] ={"" , "QWheelEvent*"}; - static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); - void* args[2] = {NULL, (void*)&arg__1}; - PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); - if (result) { Py_DECREF(result); } - Py_DECREF(obj); - return; - } -} - srecFileWidget::wheelEvent(arg__1); + if (result) { Py_DECREF(result); } + Py_DECREF(obj); + return; + } +} + srecFileWidget::reloadFile(); +} +void PythonQtShell_srecFileWidget::setFile(abstractBinFile* file) +{ +if (_wrapper) { + PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "setFile"); + PyErr_Clear(); + if (obj && !PythonQtSlotFunction_Check(obj)) { + static const char* argumentList[] ={"" , "abstractBinFile*"}; + static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); + void* args[2] = {NULL, (void*)&file}; + PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); + if (result) { Py_DECREF(result); } + Py_DECREF(obj); + return; + } +} + srecFileWidget::setFile(file); } srecFileWidget* PythonQtWrapper_srecFileWidget::new_srecFileWidget(QWidget* parent) { return new PythonQtShell_srecFileWidget(parent); } - +void PythonQtWrapper_srecFileWidget::reloadFile(srecFileWidget* theWrappedObject) +{ + ( ((PythonQtPublicPromoter_srecFileWidget*)theWrappedObject)->promoted_reloadFile()); +} + +void PythonQtWrapper_srecFileWidget::setFile(srecFileWidget* theWrappedObject, abstractBinFile* file) +{ + ( ((PythonQtPublicPromoter_srecFileWidget*)theWrappedObject)->promoted_setFile(file)); +} + + diff --git a/src/common/pythonQtOut/generated_cpp/PySocExplorer/PySocExplorer0.h b/src/common/pythonQtOut/generated_cpp/PySocExplorer/PySocExplorer0.h --- a/src/common/pythonQtOut/generated_cpp/PySocExplorer/PySocExplorer0.h +++ b/src/common/pythonQtOut/generated_cpp/PySocExplorer/PySocExplorer0.h @@ -70,6 +70,8 @@ virtual int closeFile(); virtual QList getFragments(); virtual bool isopened(); virtual bool openFile(const QString& File); +virtual bool toBinary(const QString& File); +virtual bool toSrec(const QString& File); PythonQtInstanceWrapper* _wrapper; }; @@ -80,6 +82,8 @@ inline int promoted_closeFile() { retur inline QList 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 @@ -128,6 +132,7 @@ void delete_ElfFile(ElfFile* obj) { dele 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); }; @@ -575,6 +580,8 @@ virtual QList getFragme 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; }; @@ -591,61 +598,12 @@ void delete_abstractBinFile(abstractBinF -class PythonQtShell_binaryFile : public binaryFile +class PythonQtShell_abstractBinFileWidget : public abstractBinFileWidget { 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 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 promoted_getFragments() { return binaryFile::getFragments(); } -inline bool promoted_isopened() { return binaryFile::isopened(); } -inline bool promoted_openFile(const QString& File) { return binaryFile::openFile(File); } -}; + PythonQtShell_abstractBinFileWidget(QWidget* parent = 0):abstractBinFileWidget(parent),_wrapper(NULL) {}; -class PythonQtWrapper_binaryFile : public QObject -{ Q_OBJECT -public: -public slots: -binaryFile* new_binaryFile(); -binaryFile* new_binaryFile(const QString& File); -binaryFile* new_binaryFile(const QStringList& Files); -void delete_binaryFile(binaryFile* obj) { delete obj; } - int closeFile(binaryFile* theWrappedObject); - int getFragmentAddress(binaryFile* theWrappedObject, int index); - bool getFragmentData(binaryFile* theWrappedObject, int index, char** buffer); - QString getFragmentHeader(binaryFile* theWrappedObject, int index); - int getFragmentSize(binaryFile* theWrappedObject, int index); - QList 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(); + ~PythonQtShell_abstractBinFileWidget(); virtual void actionEvent(QActionEvent* arg__1); virtual void changeEvent(QEvent* arg__1); @@ -684,7 +642,9 @@ virtual bool nativeEvent(const QByteArr 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; @@ -695,12 +655,102 @@ virtual void wheelEvent(QWheelEvent* ar 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 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 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 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 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); }; @@ -747,60 +797,24 @@ public: ~PythonQtShell_elfFileWidget(); -virtual void actionEvent(QActionEvent* arg__1); -virtual void changeEvent(QEvent* arg__1); -virtual void childEvent(QChildEvent* arg__1); -virtual void closeEvent(QCloseEvent* arg__1); -virtual void contextMenuEvent(QContextMenuEvent* arg__1); -virtual void customEvent(QEvent* arg__1); -virtual int devType() const; -virtual void dragEnterEvent(QDragEnterEvent* arg__1); -virtual void dragLeaveEvent(QDragLeaveEvent* arg__1); -virtual void dragMoveEvent(QDragMoveEvent* arg__1); -virtual void dropEvent(QDropEvent* arg__1); -virtual void enterEvent(QEvent* arg__1); -virtual bool event(QEvent* arg__1); -virtual bool eventFilter(QObject* arg__1, QEvent* arg__2); -virtual void focusInEvent(QFocusEvent* arg__1); -virtual bool focusNextPrevChild(bool next); -virtual void focusOutEvent(QFocusEvent* arg__1); -virtual bool hasHeightForWidth() const; -virtual int heightForWidth(int arg__1) const; -virtual void hideEvent(QHideEvent* arg__1); -virtual void initPainter(QPainter* painter) const; -virtual void inputMethodEvent(QInputMethodEvent* arg__1); -virtual QVariant inputMethodQuery(Qt::InputMethodQuery arg__1) const; -virtual void keyPressEvent(QKeyEvent* arg__1); -virtual void keyReleaseEvent(QKeyEvent* arg__1); -virtual void leaveEvent(QEvent* arg__1); -virtual int metric(QPaintDevice::PaintDeviceMetric arg__1) const; -virtual QSize minimumSizeHint() const; -virtual void mouseDoubleClickEvent(QMouseEvent* arg__1); -virtual void mouseMoveEvent(QMouseEvent* arg__1); -virtual void mousePressEvent(QMouseEvent* arg__1); -virtual void mouseReleaseEvent(QMouseEvent* arg__1); -virtual void moveEvent(QMoveEvent* arg__1); -virtual bool nativeEvent(const QByteArray& eventType, void* message, long* result); -virtual QPaintEngine* paintEngine() const; -virtual void paintEvent(QPaintEvent* arg__1); -virtual QPaintDevice* redirected(QPoint* offset) const; -virtual void resizeEvent(QResizeEvent* arg__1); -virtual QPainter* sharedPainter() const; -virtual void showEvent(QShowEvent* arg__1); -virtual QSize sizeHint() const; -virtual void tabletEvent(QTabletEvent* arg__1); -virtual void timerEvent(QTimerEvent* arg__1); -virtual void wheelEvent(QWheelEvent* arg__1); +virtual void reloadFile(); +virtual void setFile(abstractBinFile* file); 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); }; @@ -926,6 +940,8 @@ virtual int closeFile(); virtual QList getFragments(); virtual bool isopened(); virtual bool openFile(const QString& File); +virtual bool toBinary(const QString& File); +virtual bool toSrec(const QString& File); PythonQtInstanceWrapper* _wrapper; }; @@ -936,6 +952,8 @@ inline int promoted_closeFile() { retur inline QList 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 @@ -947,6 +965,7 @@ srecFile* new_srecFile(const QString& F 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); @@ -959,7 +978,9 @@ void delete_srecFile(srecFile* obj) { de 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 fragments, const QString& File); + bool toSrec(srecFile* theWrappedObject, const QString& File); }; @@ -973,60 +994,26 @@ public: ~PythonQtShell_srecFileWidget(); -virtual void actionEvent(QActionEvent* arg__1); -virtual void changeEvent(QEvent* arg__1); -virtual void childEvent(QChildEvent* arg__1); -virtual void closeEvent(QCloseEvent* arg__1); -virtual void contextMenuEvent(QContextMenuEvent* arg__1); -virtual void customEvent(QEvent* arg__1); -virtual int devType() const; -virtual void dragEnterEvent(QDragEnterEvent* arg__1); -virtual void dragLeaveEvent(QDragLeaveEvent* arg__1); -virtual void dragMoveEvent(QDragMoveEvent* arg__1); -virtual void dropEvent(QDropEvent* arg__1); -virtual void enterEvent(QEvent* arg__1); -virtual bool event(QEvent* arg__1); -virtual bool eventFilter(QObject* arg__1, QEvent* arg__2); -virtual void focusInEvent(QFocusEvent* arg__1); -virtual bool focusNextPrevChild(bool next); -virtual void focusOutEvent(QFocusEvent* arg__1); -virtual bool hasHeightForWidth() const; -virtual int heightForWidth(int arg__1) const; -virtual void hideEvent(QHideEvent* arg__1); -virtual void initPainter(QPainter* painter) const; -virtual void inputMethodEvent(QInputMethodEvent* arg__1); -virtual QVariant inputMethodQuery(Qt::InputMethodQuery arg__1) const; -virtual void keyPressEvent(QKeyEvent* arg__1); -virtual void keyReleaseEvent(QKeyEvent* arg__1); -virtual void leaveEvent(QEvent* arg__1); -virtual int metric(QPaintDevice::PaintDeviceMetric arg__1) const; -virtual QSize minimumSizeHint() const; -virtual void mouseDoubleClickEvent(QMouseEvent* arg__1); -virtual void mouseMoveEvent(QMouseEvent* arg__1); -virtual void mousePressEvent(QMouseEvent* arg__1); -virtual void mouseReleaseEvent(QMouseEvent* arg__1); -virtual void moveEvent(QMoveEvent* arg__1); -virtual bool nativeEvent(const QByteArray& eventType, void* message, long* result); -virtual QPaintEngine* paintEngine() const; -virtual void paintEvent(QPaintEvent* arg__1); -virtual QPaintDevice* redirected(QPoint* offset) const; -virtual void resizeEvent(QResizeEvent* arg__1); -virtual QPainter* sharedPainter() const; -virtual void showEvent(QShowEvent* arg__1); -virtual QSize sizeHint() const; -virtual void tabletEvent(QTabletEvent* arg__1); -virtual void timerEvent(QTimerEvent* arg__1); -virtual void wheelEvent(QWheelEvent* arg__1); +virtual void reloadFile(); +virtual void setFile(abstractBinFile* file); PythonQtInstanceWrapper* _wrapper; }; +class PythonQtPublicPromoter_srecFileWidget : public srecFileWidget +{ public: +inline void promoted_reloadFile() { srecFileWidget::reloadFile(); } +inline void promoted_setFile(abstractBinFile* file) { srecFileWidget::setFile(file); } +}; + class PythonQtWrapper_srecFileWidget : public QObject { Q_OBJECT public: public slots: srecFileWidget* new_srecFileWidget(QWidget* parent = 0); void delete_srecFileWidget(srecFileWidget* obj) { delete obj; } + void reloadFile(srecFileWidget* theWrappedObject); + void setFile(srecFileWidget* theWrappedObject, abstractBinFile* file); }; diff --git a/src/common/pythonQtOut/generated_cpp/PySocExplorer/PySocExplorer_init.cpp b/src/common/pythonQtOut/generated_cpp/PySocExplorer/PySocExplorer_init.cpp --- a/src/common/pythonQtOut/generated_cpp/PySocExplorer/PySocExplorer_init.cpp +++ b/src/common/pythonQtOut/generated_cpp/PySocExplorer/PySocExplorer_init.cpp @@ -12,15 +12,19 @@ PythonQt::priv()->registerClass(&SocExpl PythonQt::priv()->registerClass(&TCP_Terminal_Client::staticMetaObject, "PySocExplorer", PythonQtCreateObject, PythonQtSetInstanceWrapperOnShell, module, 0); PythonQt::priv()->registerCPPClass("XByteArray", "", "PySocExplorer", PythonQtCreateObject, NULL, module, 0); PythonQt::priv()->registerClass(&abstractBinFile::staticMetaObject, "PySocExplorer", PythonQtCreateObject, PythonQtSetInstanceWrapperOnShell, module, 0); +PythonQt::priv()->registerClass(&abstractBinFileWidget::staticMetaObject, "PySocExplorer", PythonQtCreateObject, PythonQtSetInstanceWrapperOnShell, module, 0); PythonQt::priv()->registerClass(&binaryFile::staticMetaObject, "PySocExplorer", PythonQtCreateObject, PythonQtSetInstanceWrapperOnShell, module, 0); PythonQt::self()->addParentClass("binaryFile", "abstractBinFile",PythonQtUpcastingOffset()); PythonQt::priv()->registerClass(&binaryFileWidget::staticMetaObject, "PySocExplorer", PythonQtCreateObject, PythonQtSetInstanceWrapperOnShell, module, 0); +PythonQt::self()->addParentClass("binaryFileWidget", "abstractBinFileWidget",PythonQtUpcastingOffset()); PythonQt::priv()->registerCPPClass("codeFragment", "", "PySocExplorer", PythonQtCreateObject, PythonQtSetInstanceWrapperOnShell, module, 0); PythonQt::priv()->registerClass(&elfFileWidget::staticMetaObject, "PySocExplorer", PythonQtCreateObject, PythonQtSetInstanceWrapperOnShell, module, 0); +PythonQt::self()->addParentClass("elfFileWidget", "abstractBinFileWidget",PythonQtUpcastingOffset()); PythonQt::priv()->registerClass(&elfInfoWdgt::staticMetaObject, "PySocExplorer", PythonQtCreateObject, PythonQtSetInstanceWrapperOnShell, module, 0); PythonQt::priv()->registerCPPClass("elfparser", "", "PySocExplorer", PythonQtCreateObject, NULL, module, 0); PythonQt::priv()->registerClass(&srecFile::staticMetaObject, "PySocExplorer", PythonQtCreateObject, PythonQtSetInstanceWrapperOnShell, module, 0); PythonQt::self()->addParentClass("srecFile", "abstractBinFile",PythonQtUpcastingOffset()); PythonQt::priv()->registerClass(&srecFileWidget::staticMetaObject, "PySocExplorer", PythonQtCreateObject, PythonQtSetInstanceWrapperOnShell, module, 0); +PythonQt::self()->addParentClass("srecFileWidget", "abstractBinFileWidget",PythonQtUpcastingOffset()); } diff --git a/src/common/pythonQtgeneratorCfg.txt b/src/common/pythonQtgeneratorCfg.txt --- a/src/common/pythonQtgeneratorCfg.txt +++ b/src/common/pythonQtgeneratorCfg.txt @@ -33,6 +33,12 @@ + + + + + + diff --git a/src/common/srec/srecfile.cpp b/src/common/srec/srecfile.cpp --- a/src/common/srec/srecfile.cpp +++ b/src/common/srec/srecfile.cpp @@ -21,6 +21,7 @@ ----------------------------------------------------------------------------*/ #include "srecfile.h" #include +#include "binaryfile.h" srecFile::srecFile() { @@ -48,13 +49,6 @@ bool srecFile::openFile(const QString &F bool srecFile::openFiles(const QStringList &Files) { - this->p_fileNames.clear(); - this->p_fileNames.append(Files); - for(int i=0;ip_files.clear(); for(int i=0;ip_isSrec=true; @@ -81,7 +75,10 @@ int srecFile::closeFile() for(int i=0;idata); + delete p_fragments.at(i); } + p_fragments.clear(); p_files.clear(); p_fileName.clear(); return 0; @@ -156,6 +153,16 @@ bool srecFile::toSrec(QList=0)) + { + return p_fragments.at(index); + } + return NULL; +} + QString srecFile::getFragmentHeader(int index) { if((index < p_fragments.count()) && (index>=0)) diff --git a/src/common/srec/srecfile.h b/src/common/srec/srecfile.h --- a/src/common/srec/srecfile.h +++ b/src/common/srec/srecfile.h @@ -41,10 +41,13 @@ public: int closeFile(); QList getFragments(); static bool toSrec(QList 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); diff --git a/src/common/srec/srecfilewidget.cpp b/src/common/srec/srecfilewidget.cpp --- a/src/common/srec/srecfilewidget.cpp +++ b/src/common/srec/srecfilewidget.cpp @@ -23,14 +23,22 @@ #include "ui_srecfilewidget.h" #include #include +#include +#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() @@ -38,16 +46,16 @@ 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()); @@ -88,4 +96,49 @@ void srecFileWidget::recordCellActivated } +void srecFileWidget::exportToSREC() +{ + QList 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 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 srecFileWidget::getSelectedFragments() +{ + QList SelectedFragmentsList; + QList items = this->ui->fragmentsList->selectedItems(); + for(int i=0;igetFragment(items.at(i)->row()); + if(!SelectedFragmentsList.contains(fragment)) + { + SelectedFragmentsList.append(fragment); + } + } + return SelectedFragmentsList; +} + + diff --git a/src/common/srec/srecfilewidget.h b/src/common/srec/srecfilewidget.h --- a/src/common/srec/srecfilewidget.h +++ b/src/common/srec/srecfilewidget.h @@ -24,12 +24,13 @@ #include #include "srecfile.h" +#include namespace Ui { class srecFileWidget; } -class srecFileWidget : public QWidget +class srecFileWidget : public abstractBinFileWidget { Q_OBJECT @@ -38,15 +39,20 @@ public: ~srecFileWidget(); public slots: - void updatSrecFile(srecFile* file); - void updateRecords(); + void setFile(abstractBinFile* file); + void reloadFile(); private slots: void recordCellActivated(int row, int column); + void exportToSREC(); + void exportToBIN(); private: + QList getSelectedFragments(); Ui::srecFileWidget *ui; srecFile* p_srec; + QAction* exportToSREC_action; + QAction* exportToBIN_action; }; #endif // SRECFILEWIDGET_H diff --git a/src/common/srec/srecfilewidget.ui b/src/common/srec/srecfilewidget.ui --- a/src/common/srec/srecfilewidget.ui +++ b/src/common/srec/srecfilewidget.ui @@ -43,6 +43,9 @@ + + Qt::ActionsContextMenu + Index