HG_REPOSITORIES/LPP/INSTRUMENTATION/SocExplorer Commit - r40:91ff842275d6

ElfFile classes WIP....

jeandet -

r40:91ff842275d6 default

parent child

Context file:

r40:91ff842275d6

Collapse all files

src/common/PySocExplorer.h +1 0

             #include <QtCore/QObject>
             #include <QtWidgets/QtWidgets>
             #include "qhexspinbox.h"
             #include "memsizewdgt.h"
             #include "qhexedit/qhexedit.h"
             #include "SocExplorerPlot.h"
             #include "tcp_terminal_client.h"
             #include "elf/elfparser.h"
             #include "abstractexecfile.h"
             #include "elf/elffile.h"
             #include "elf/elffilewidget.h"
             #include "elf/elfinfowdgt.h"
+            #include "QCustomPlot/qcustomplot.h"

src/common/elf/elffile.cpp +16 -4

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

src/common/elf/elffile.h +5 -3

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

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

             #include "elffilewidget.h"
             #include "ui_elffilewidget.h"
             elfFileWidget::elfFileWidget(QWidget *parent) :
                 QWidget(parent),
                 ui(new Ui::elfFileWidget)
             {
                 ui->setupUi(this);
             }
             elfFileWidget::~elfFileWidget()
             {
                 delete ui;
             }
             void elfFileWidget::updateElfFile(ElfFile *file)
             {
                 this->p_elf = file;
                 if(p_elf->isopened() && p_elf->iself())
                 {
                     this->ui->classLabel->setText(p_elf->getClass());
                     this->ui->VersionLabel->setText(QString::number(p_elf->getVersion()));
                     this->ui->machineLabel->setText(p_elf->getArchitecture());
                     this->ui->endiannesLabel->setText(p_elf->getEndianness());
                     this->ui->abiLabel->setText(p_elf->getABI());
-                    this->ui->entryPointLabel->setText("0x"+QString::number(p_elf->getEntryPointAddress(),16,8));
+                    this->ui->entryPointLabel->setText(QString("0x%1").arg((uint)p_elf->getEntryPointAddress(),8,16));
-                    this->ui->sectionCountLabel->setText(QString::number(p_elf->getSectioncount()));
+                    this->ui->typeLabel->setText(p_elf->getType());
+                    this->ui->sectionCountLabel->setText(QString::number(p_elf->getSectionCount()));
+            //        this->ui->symbolCountLabel->setText(p_elf->get);
                 }
             }

src/common/elf/elffilewidget.ui +3 -3

             <?xml version="1.0" encoding="UTF-8"?>
             <ui version="4.0">
              <class>elfFileWidget</class>
              <widget class="QWidget" name="elfFileWidget">
               <property name="geometry">
                <rect>
                 <x>0</x>
                 <y>0</y>
                 <width>622</width>
                 <height>398</height>
                </rect>
               </property>
               <property name="minimumSize">
                <size>
                 <width>0</width>
                 <height>0</height>
                </size>
               </property>
               <property name="focusPolicy">
                <enum>Qt::NoFocus</enum>
               </property>
               <property name="windowTitle">
                <string>Form</string>
               </property>
               <layout class="QGridLayout" name="gridLayout">
                <item row="0" column="0">
                 <widget class="QTabWidget" name="tabWidget">
                  <property name="currentIndex">
                   <number>0</number>
                  </property>
                  <widget class="QWidget" name="generalInfoTab">
                   <attribute name="title">
                    <string>File Informations</string>
                   </attribute>
                   <layout class="QGridLayout" name="gridLayout_4">
                    <item row="0" column="0">
                     <widget class="QGroupBox" name="groupBox">
                      <property name="title">
                       <string>Elf header</string>
                      </property>
                      <layout class="QFormLayout" name="formLayout">
                       <item row="0" column="0">
                        <widget class="QLabel" name="label">
                         <property name="text">
                          <string>Class:</string>
                         </property>
                        </widget>
                       </item>
                       <item row="0" column="1">
                        <widget class="QLabel" name="classLabel">
                         <property name="text">
                          <string>none</string>
                         </property>
                        </widget>
                       </item>
                       <item row="1" column="0">
                        <widget class="QLabel" name="label_3">
                         <property name="text">
                          <string>Endianness:</string>
                         </property>
                        </widget>
                       </item>
                       <item row="1" column="1">
                        <widget class="QLabel" name="endiannesLabel">
                         <property name="text">
                          <string>none</string>
                         </property>
                        </widget>
                       </item>
                       <item row="2" column="0">
                        <widget class="QLabel" name="label_5">
                         <property name="text">
                          <string>Version:</string>
                         </property>
                        </widget>
                       </item>
                       <item row="3" column="0">
                        <widget class="QLabel" name="label_6">
                         <property name="text">
                          <string>Type:</string>
                         </property>
                        </widget>
                       </item>
                       <item row="4" column="0">
                        <widget class="QLabel" name="label_7">
                         <property name="text">
                          <string>Machine:</string>
                         </property>
                        </widget>
                       </item>
                       <item row="6" column="0">
                        <widget class="QLabel" name="label_8">
                         <property name="text">
                          <string>Entry point address:</string>
                         </property>
                        </widget>
                       </item>
                       <item row="2" column="1">
                        <widget class="QLabel" name="VersionLabel">
                         <property name="text">
                          <string>none</string>
                         </property>
                        </widget>
                       </item>
                       <item row="3" column="1">
                        <widget class="QLabel" name="typeLabel">
                         <property name="text">
                          <string>none</string>
                         </property>
                        </widget>
                       </item>
                       <item row="4" column="1">
                        <widget class="QLabel" name="machineLabel">
                         <property name="text">
                          <string>none</string>
                         </property>
                        </widget>
                       </item>
                       <item row="6" column="1">
                        <widget class="QLabel" name="entryPointLabel">
                         <property name="text">
                          <string>none</string>
                         </property>
                        </widget>
                       </item>
                       <item row="5" column="0">
                        <widget class="QLabel" name="label_17">
                         <property name="text">
                          <string>OS/ABI:</string>
                         </property>
                        </widget>
                       </item>
                       <item row="5" column="1">
                        <widget class="QLabel" name="abiLabel">
                         <property name="text">
                          <string>none</string>
                         </property>
                        </widget>
                       </item>
                      </layout>
                     </widget>
                    </item>
                    <item row="1" column="0">
                     <widget class="QGroupBox" name="groupBox_2">
                      <property name="title">
-                      <string>Sections</string>
+                      <string>Sections &amp; Symbols</string>
                      </property>
                      <layout class="QFormLayout" name="formLayout_2">
                       <item row="0" column="0">
                        <widget class="QLabel" name="label_9">
                         <property name="text">
                          <string>Section count:</string>
                         </property>
                        </widget>
                       </item>
                       <item row="1" column="0">
                        <widget class="QLabel" name="label_10">
                         <property name="text">
-                         <string>Sections begin address:</string>
+                         <string>Symbols count:</string>
                         </property>
                        </widget>
                       </item>
                       <item row="0" column="1">
                        <widget class="QLabel" name="sectionCountLabel">
                         <property name="text">
                          <string>none</string>
                         </property>
                        </widget>
                       </item>
                       <item row="1" column="1">
-                       <widget class="QLabel" name="sectionBeginLabel">
+                       <widget class="QLabel" name="symbolCountLabel">
                         <property name="text">
                          <string>none</string>
                         </property>
                        </widget>
                       </item>
                      </layout>
                     </widget>
                    </item>
                   </layout>
                  </widget>
                  <widget class="QWidget" name="symbolsTab">
                   <attribute name="title">
                    <string>Symbols</string>
                   </attribute>
                   <layout class="QGridLayout" name="gridLayout_2">
                    <item row="0" column="0">
                     <widget class="QTableWidget" name="symbolsList"/>
                    </item>
                   </layout>
                  </widget>
                  <widget class="QWidget" name="sectionsTab">
                   <attribute name="title">
                    <string>Sections</string>
                   </attribute>
                   <layout class="QGridLayout" name="gridLayout_3">
                    <item row="0" column="0">
                     <widget class="QHexEdit" name="sectionsHexView" native="true">
                      <property name="minimumSize">
                       <size>
                        <width>100</width>
                        <height>0</height>
                       </size>
                      </property>
                     </widget>
                    </item>
                    <item row="0" column="1">
                     <widget class="QTableWidget" name="sectionsList"/>
                    </item>
                   </layout>
                  </widget>
                 </widget>
                </item>
               </layout>
              </widget>
              <customwidgets>
               <customwidget>
                <class>QHexEdit</class>
                <extends>QWidget</extends>
                <header location="global">qhexedit.h</header>
                <container>1</container>
               </customwidget>
              </customwidgets>
              <resources/>
              <connections/>
             </ui>

src/common/elf/elfinfowdgt.h +7 -7

             /*------------------------------------------------------------------------------
             --  This file is a part of the SocExplorer Software
             --  Copyright (C) 2013, Plasma Physics Laboratory - CNRS
             --
             --  This program is free software; you can redistribute it and/or modify
             --  it under the terms of the GNU General Public License as published by
             --  the Free Software Foundation; either version 3 of the License, or
             --  (at your option) any later version.
             --
             --  This program is distributed in the hope that it will be useful,
             --  but WITHOUT ANY WARRANTY; without even the implied warranty of
             --  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             --  GNU General Public License for more details.
             --
             --  You should have received a copy of the GNU General Public License
             --  along with this program; if not, write to the Free Software
             --  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
             -------------------------------------------------------------------------------*/
             /*--                  Author : Alexis Jeandet
             --                     Mail : alexis.jeandet@lpp.polytechnique.fr
             ----------------------------------------------------------------------------*/
             #ifndef ELFINFOWDGT_H
             #define ELFINFOWDGT_H
-            #include <QWidget>
+            #include <QtWidgets/QWidget>
             #include "elfparser.h"
-            #include <QVBoxLayout>
+            #include <QtWidgets/QVBoxLayout>
-            #include <QHBoxLayout>
+            #include <QtWidgets/QHBoxLayout>
-            #include <QLabel>
+            #include <QtWidgets/QLabel>
-            #include <QTextEdit>
+            #include <QtWidgets/QTextEdit>
-            #include <QTableWidget>
+            #include <QtWidgets/QTableWidget>
             #include <qhexedit.h>
-            #include <QSplitter>
+            #include <QtWidgets/QSplitter>
             class elfInfoWdgt : public QWidget
             {
                 Q_OBJECT
             public:
                 explicit elfInfoWdgt(QWidget *parent = 0);
             signals:
             public slots:
                 void updateInfo(elfparser* parser);
                 void cellActivated ( int row, int column );
             private:
                 void updateSectionsTable(elfparser* parser);
                 void updateSegmentsTable(elfparser* parser);
                 QVBoxLayout* mainLayout;
                 QLabel* ElfArchitecture;
                 QLabel* ElfType;
                 QLabel* ElfVersion;
                 QTableWidget* segmentsListTableWdgt,*sectionsListTableWdgt;
                 QHexEdit* hexViewer;
                 QSplitter* splitter;
                 QWidget* elfInfoWdgtLay;
                 QVBoxLayout* elfInfoWdgtLayout;
                 elfparser* parser;
             };
             #endif // ELFINFOWDGT_H

src/common/pythonQtOut/generated_cpp/PySocExplorer/PySocExplorer0.cpp +5878 -18

This diff has been collapsed as it changes many lines, (5896 lines changed) Show them Hide them
	@@ -1,1007 +1,6867
	1	#include "PySocExplorer0.h"	1	#include "PySocExplorer0.h"
	2	#include <PythonQtConversion.h>	2	#include <PythonQtConversion.h>
	3	#include <PythonQtMethodInfo.h>	3	#include <PythonQtMethodInfo.h>
	4	#include <PythonQtSignalReceiver.h>	4	#include <PythonQtSignalReceiver.h>
			5	#include <QIconEngine>
			6	#include <QObject>
			7	#include <QSpinBox>
	5	#include <QVariant>	8	#include <QVariant>
			9	#include <QWidget>
	6	#include <abstractexecfile.h>	10	#include <abstractexecfile.h>
	7	#include <elffile.h>	11	#include <elffile.h>
	8	#include <elfparser.h>	12	#include <elfparser.h>
			13	#include <qaction.h>
			14	#include <qbitmap.h>
			15	#include <qbytearray.h>
			16	#include <qcolor.h>
			17	#include <qcoreevent.h>
			18	#include <qcursor.h>
			19	#include <qevent.h>
			20	#include <qfont.h>
			21	#include <qgraphicseffect.h>
			22	#include <qgraphicsproxywidget.h>
			23	#include <qkeysequence.h>
			24	#include <qlayout.h>
			25	#include <qlineedit.h>
			26	#include <qlist.h>
			27	#include <qlocale.h>
			28	#include <qmargins.h>
			29	#include <qobject.h>
			30	#include <qpaintdevice.h>
			31	#include <qpaintengine.h>
			32	#include <qpainter.h>
			33	#include <qpalette.h>
			34	#include <qpen.h>
			35	#include <qpixmap.h>
			36	#include <qpoint.h>
			37	#include <qrect.h>
			38	#include <qregion.h>
			39	#include <qscrollarea.h>
			40	#include <qscrollbar.h>
			41	#include <qsize.h>
			42	#include <qsizepolicy.h>
			43	#include <qspinbox.h>
			44	#include <qstringlist.h>
			45	#include <qstyle.h>
			46	#include <qstyleoption.h>
			47	#include <qwidget.h>
	9		48
	10	PythonQtShell_ElfFile::~PythonQtShell_ElfFile() {	49	PythonQtShell_ElfFile::~PythonQtShell_ElfFile() {
	11	PythonQtPrivate* priv = PythonQt::priv();	50	PythonQtPrivate* priv = PythonQt::priv();
	12	if (priv) { priv->shellClassDeleted(this); }	51	if (priv) { priv->shellClassDeleted(this); }
	13	}	52	}
	14	int PythonQtShell_ElfFile::closeFile()	53	int PythonQtShell_ElfFile::closeFile()
	15	{	54	{
	16	if (_wrapper) {	55	if (_wrapper) {
	17	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "closeFile");	56	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "closeFile");
	18	PyErr_Clear();	57	PyErr_Clear();
	19	if (obj && !PythonQtSlotFunction_Check(obj)) {	58	if (obj && !PythonQtSlotFunction_Check(obj)) {
	20	static const char* argumentList[] ={"int"};	59	static const char* argumentList[] ={"int"};
	21	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);	60	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
	22	int returnValue;	61	int returnValue;
	23	void* args[1] = {NULL};	62	void* args[1] = {NULL};
	24	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);	63	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
	25	if (result) {	64	if (result) {
	26	args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);	65	args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
	27	if (args[0]!=&returnValue) {	66	if (args[0]!=&returnValue) {
	28	if (args[0]==NULL) {	67	if (args[0]==NULL) {
	29	PythonQt::priv()->handleVirtualOverloadReturnError("closeFile", methodInfo, result);	68	PythonQt::priv()->handleVirtualOverloadReturnError("closeFile", methodInfo, result);
	30	} else {	69	} else {
	31	returnValue = ((int)args[0]);	70	returnValue = ((int)args[0]);
	32	}	71	}
	33	}	72	}
	34	}	73	}
	35	if (result) { Py_DECREF(result); }	74	if (result) { Py_DECREF(result); }
	36	Py_DECREF(obj);	75	Py_DECREF(obj);
	37	return returnValue;	76	return returnValue;
	38	}	77	}
	39	}	78	}
	40	return ElfFile::closeFile();	79	return ElfFile::closeFile();
	41	}	80	}
	42	QList<codeFragment* > PythonQtShell_ElfFile::getFragments()	81	QList<codeFragment* > PythonQtShell_ElfFile::getFragments()
	43	{	82	{
	44	if (_wrapper) {	83	if (_wrapper) {
	45	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getFragments");	84	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getFragments");
	46	PyErr_Clear();	85	PyErr_Clear();
	47	if (obj && !PythonQtSlotFunction_Check(obj)) {	86	if (obj && !PythonQtSlotFunction_Check(obj)) {
	48	static const char* argumentList[] ={"QList<codeFragment* >"};	87	static const char* argumentList[] ={"QList<codeFragment* >"};
	49	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);	88	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
	50	QList<codeFragment* > returnValue;	89	QList<codeFragment* > returnValue;
	51	void* args[1] = {NULL};	90	void* args[1] = {NULL};
	52	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);	91	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
	53	if (result) {	92	if (result) {
	54	args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);	93	args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
	55	if (args[0]!=&returnValue) {	94	if (args[0]!=&returnValue) {
	56	if (args[0]==NULL) {	95	if (args[0]==NULL) {
	57	PythonQt::priv()->handleVirtualOverloadReturnError("getFragments", methodInfo, result);	96	PythonQt::priv()->handleVirtualOverloadReturnError("getFragments", methodInfo, result);
	58	} else {	97	} else {
	59	returnValue = ((QList<codeFragment >*)args[0]);	98	returnValue = ((QList<codeFragment >*)args[0]);
	60	}	99	}
	61	}	100	}
	62	}	101	}
	63	if (result) { Py_DECREF(result); }	102	if (result) { Py_DECREF(result); }
	64	Py_DECREF(obj);	103	Py_DECREF(obj);
	65	return returnValue;	104	return returnValue;
	66	}	105	}
	67	}	106	}
	68	return ElfFile::getFragments();	107	return ElfFile::getFragments();
	69	}	108	}
	70	bool PythonQtShell_ElfFile::isopened()	109	bool PythonQtShell_ElfFile::isopened()
	71	{	110	{
	72	if (_wrapper) {	111	if (_wrapper) {
	73	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "isopened");	112	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "isopened");
	74	PyErr_Clear();	113	PyErr_Clear();
	75	if (obj && !PythonQtSlotFunction_Check(obj)) {	114	if (obj && !PythonQtSlotFunction_Check(obj)) {
	76	static const char* argumentList[] ={"bool"};	115	static const char* argumentList[] ={"bool"};
	77	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);	116	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
	78	bool returnValue;	117	bool returnValue;
	79	void* args[1] = {NULL};	118	void* args[1] = {NULL};
	80	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);	119	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
	81	if (result) {	120	if (result) {
	82	args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);	121	args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
	83	if (args[0]!=&returnValue) {	122	if (args[0]!=&returnValue) {
	84	if (args[0]==NULL) {	123	if (args[0]==NULL) {
	85	PythonQt::priv()->handleVirtualOverloadReturnError("isopened", methodInfo, result);	124	PythonQt::priv()->handleVirtualOverloadReturnError("isopened", methodInfo, result);
	86	} else {	125	} else {
	87	returnValue = ((bool)args[0]);	126	returnValue = ((bool)args[0]);
	88	}	127	}
	89	}	128	}
	90	}	129	}
	91	if (result) { Py_DECREF(result); }	130	if (result) { Py_DECREF(result); }
	92	Py_DECREF(obj);	131	Py_DECREF(obj);
	93	return returnValue;	132	return returnValue;
	94	}	133	}
	95	}	134	}
	96	return ElfFile::isopened();	135	return ElfFile::isopened();
	97	}	136	}
	98	bool PythonQtShell_ElfFile::openFile(const QString& File)	137	bool PythonQtShell_ElfFile::openFile(const QString& File)
	99	{	138	{
	100	if (_wrapper) {	139	if (_wrapper) {
	101	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "openFile");	140	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "openFile");
	102	PyErr_Clear();	141	PyErr_Clear();
	103	if (obj && !PythonQtSlotFunction_Check(obj)) {	142	if (obj && !PythonQtSlotFunction_Check(obj)) {
	104	static const char* argumentList[] ={"bool" , "const QString&"};	143	static const char* argumentList[] ={"bool" , "const QString&"};
	105	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);	144	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
	106	bool returnValue;	145	bool returnValue;
	107	void* args[2] = {NULL, (void*)&File};	146	void* args[2] = {NULL, (void*)&File};
	108	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);	147	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
	109	if (result) {	148	if (result) {
	110	args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);	149	args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
	111	if (args[0]!=&returnValue) {	150	if (args[0]!=&returnValue) {
	112	if (args[0]==NULL) {	151	if (args[0]==NULL) {
	113	PythonQt::priv()->handleVirtualOverloadReturnError("openFile", methodInfo, result);	152	PythonQt::priv()->handleVirtualOverloadReturnError("openFile", methodInfo, result);
	114	} else {	153	} else {
	115	returnValue = ((bool)args[0]);	154	returnValue = ((bool)args[0]);
	116	}	155	}
	117	}	156	}
	118	}	157	}
	119	if (result) { Py_DECREF(result); }	158	if (result) { Py_DECREF(result); }
	120	Py_DECREF(obj);	159	Py_DECREF(obj);
	121	return returnValue;	160	return returnValue;
	122	}	161	}
	123	}	162	}
	124	return ElfFile::openFile(File);	163	return ElfFile::openFile(File);
	125	}	164	}
	126	ElfFile* PythonQtWrapper_ElfFile::new_ElfFile()	165	ElfFile* PythonQtWrapper_ElfFile::new_ElfFile()
	127	{	166	{
	128	return new PythonQtShell_ElfFile(); }	167	return new PythonQtShell_ElfFile(); }
	129		168
	130	ElfFile* PythonQtWrapper_ElfFile::new_ElfFile(const QString& File)	169	ElfFile* PythonQtWrapper_ElfFile::new_ElfFile(const QString& File)
	131	{	170	{
	132	return new PythonQtShell_ElfFile(File); }	171	return new PythonQtShell_ElfFile(File); }
	133		172
	134	int PythonQtWrapper_ElfFile::closeFile(ElfFile* theWrappedObject)	173	int PythonQtWrapper_ElfFile::closeFile(ElfFile* theWrappedObject)
	135	{	174	{
	136	return ( ((PythonQtPublicPromoter_ElfFile*)theWrappedObject)->promoted_closeFile());	175	return ( ((PythonQtPublicPromoter_ElfFile*)theWrappedObject)->promoted_closeFile());
	137	}	176	}
	138		177
	139	QString PythonQtWrapper_ElfFile::getABI(ElfFile* theWrappedObject)	178	QString PythonQtWrapper_ElfFile::getABI(ElfFile* theWrappedObject)
	140	{	179	{
	141	return ( theWrappedObject->getABI());	180	return ( theWrappedObject->getABI());
	142	}	181	}
	143		182
	144	QString PythonQtWrapper_ElfFile::getArchitecture(ElfFile* theWrappedObject)	183	QString PythonQtWrapper_ElfFile::getArchitecture(ElfFile* theWrappedObject)
	145	{	184	{
	146	return ( theWrappedObject->getArchitecture());	185	return ( theWrappedObject->getArchitecture());
	147	}	186	}
	148		187
	149	QString PythonQtWrapper_ElfFile::getClass(ElfFile* theWrappedObject)	188	QString PythonQtWrapper_ElfFile::getClass(ElfFile* theWrappedObject)
	150	{	189	{
	151	return ( theWrappedObject->getClass());	190	return ( theWrappedObject->getClass());
	152	}	191	}
	153		192
	154	QString PythonQtWrapper_ElfFile::getEndianness(ElfFile* theWrappedObject)	193	QString PythonQtWrapper_ElfFile::getEndianness(ElfFile* theWrappedObject)
	155	{	194	{
	156	return ( theWrappedObject->getEndianness());	195	return ( theWrappedObject->getEndianness());
	157	}	196	}
	158		197
	159	qint64 PythonQtWrapper_ElfFile::getEntryPointAddress(ElfFile* theWrappedObject)	198	qint64 PythonQtWrapper_ElfFile::getEntryPointAddress(ElfFile* theWrappedObject)
	160	{	199	{
	161	return ( theWrappedObject->getEntryPointAddress());	200	return ( theWrappedObject->getEntryPointAddress());
	162	}	201	}
	163		202
	164	QList<codeFragment* > PythonQtWrapper_ElfFile::getFragments(ElfFile* theWrappedObject)	203	QList<codeFragment* > PythonQtWrapper_ElfFile::getFragments(ElfFile* theWrappedObject)
	165	{	204	{
	166	return ( ((PythonQtPublicPromoter_ElfFile*)theWrappedObject)->promoted_getFragments());	205	return ( ((PythonQtPublicPromoter_ElfFile*)theWrappedObject)->promoted_getFragments());
	167	}	206	}
	168		207
	169	QList<codeFragment* > PythonQtWrapper_ElfFile::getFragments(ElfFile* theWrappedObject, QStringList fragmentList)	208	QList<codeFragment* > PythonQtWrapper_ElfFile::getFragments(ElfFile* theWrappedObject, QStringList fragmentList)
	170	{	209	{
	171	return ( theWrappedObject->getFragments(fragmentList));	210	return ( theWrappedObject->getFragments(fragmentList));
	172	}	211	}
	173		212
	174	bool PythonQtWrapper_ElfFile::getSectionData(ElfFile* theWrappedObject, int index, char** buffer)	213	bool PythonQtWrapper_ElfFile::getSectionData(ElfFile* theWrappedObject, int index, char** buffer)
	175	{	214	{
	176	return ( theWrappedObject->getSectionData(index, buffer));	215	return ( theWrappedObject->getSectionData(index, buffer));
	177	}	216	}
	178		217
	179	qint64 PythonQtWrapper_ElfFile::getSectionDatasz(ElfFile* theWrappedObject, int index)	218	qint64 PythonQtWrapper_ElfFile::getSectionDatasz(ElfFile* theWrappedObject, int index)
	180	{	219	{
	181	return ( theWrappedObject->getSectionDatasz(index));	220	return ( theWrappedObject->getSectionDatasz(index));
	182	}	221	}
	183		222
	184	qint64 PythonQtWrapper_ElfFile::getSectionMemsz(ElfFile* theWrappedObject, int index)	223	qint64 PythonQtWrapper_ElfFile::getSectionMemsz(ElfFile* theWrappedObject, int index)
	185	{	224	{
	186	return ( theWrappedObject->getSectionMemsz(index));	225	return ( theWrappedObject->getSectionMemsz(index));
	187	}	226	}
	188		227
	189	QString PythonQtWrapper_ElfFile::getSectionName(ElfFile* theWrappedObject, int index)	228	QString PythonQtWrapper_ElfFile::getSectionName(ElfFile* theWrappedObject, int index)
	190	{	229	{
	191	return ( theWrappedObject->getSectionName(index));	230	return ( theWrappedObject->getSectionName(index));
	192	}	231	}
	193		232
	194	qint64 PythonQtWrapper_ElfFile::getSectionPaddr(ElfFile* theWrappedObject, int index)	233	qint64 PythonQtWrapper_ElfFile::getSectionPaddr(ElfFile* theWrappedObject, int index)
	195	{	234	{
	196	return ( theWrappedObject->getSectionPaddr(index));	235	return ( theWrappedObject->getSectionPaddr(index));
	197	}	236	}
	198		237
	199	QString PythonQtWrapper_ElfFile::getSectionType(ElfFile* theWrappedObject, int index)	238	QString PythonQtWrapper_ElfFile::getSectionType(ElfFile* theWrappedObject, int index)
	200	{	239	{
	201	return ( theWrappedObject->getSectionType(index));	240	return ( theWrappedObject->getSectionType(index));
	202	}	241	}
	203		242
	204	int PythonQtWrapper_ElfFile::getSectioncount(ElfFile* theWrappedObject)	243	int PythonQtWrapper_ElfFile::getSectioncount(ElfFile* theWrappedObject)
	205	{	244	{
	206	return ( theWrappedObject->getSectioncount());	245	return ( theWrappedObject->getSectionCount());
	207	}	246	}
	208		247
	209	qint64 PythonQtWrapper_ElfFile::getSegmentFilesz(ElfFile* theWrappedObject, int index)	248	qint64 PythonQtWrapper_ElfFile::getSegmentFilesz(ElfFile* theWrappedObject, int index)
	210	{	249	{
	211	return ( theWrappedObject->getSegmentFilesz(index));	250	return ( theWrappedObject->getSegmentFilesz(index));
	212	}	251	}
	213		252
	214	QString PythonQtWrapper_ElfFile::getSegmentFlags(ElfFile* theWrappedObject, int index)	253	QString PythonQtWrapper_ElfFile::getSegmentFlags(ElfFile* theWrappedObject, int index)
	215	{	254	{
	216	return ( theWrappedObject->getSegmentFlags(index));	255	return ( theWrappedObject->getSegmentFlags(index));
	217	}	256	}
	218		257
	219	qint64 PythonQtWrapper_ElfFile::getSegmentMemsz(ElfFile* theWrappedObject, int index)	258	qint64 PythonQtWrapper_ElfFile::getSegmentMemsz(ElfFile* theWrappedObject, int index)
	220	{	259	{
	221	return ( theWrappedObject->getSegmentMemsz(index));	260	return ( theWrappedObject->getSegmentMemsz(index));
	222	}	261	}
	223		262
	224	qint64 PythonQtWrapper_ElfFile::getSegmentOffset(ElfFile* theWrappedObject, int index)	263	qint64 PythonQtWrapper_ElfFile::getSegmentOffset(ElfFile* theWrappedObject, int index)
	225	{	264	{
	226	return ( theWrappedObject->getSegmentOffset(index));	265	return ( theWrappedObject->getSegmentOffset(index));
	227	}	266	}
	228		267
	229	qint64 PythonQtWrapper_ElfFile::getSegmentPaddr(ElfFile* theWrappedObject, int index)	268	qint64 PythonQtWrapper_ElfFile::getSegmentPaddr(ElfFile* theWrappedObject, int index)
	230	{	269	{
	231	return ( theWrappedObject->getSegmentPaddr(index));	270	return ( theWrappedObject->getSegmentPaddr(index));
	232	}	271	}
	233		272
	234	QString PythonQtWrapper_ElfFile::getSegmentType(ElfFile* theWrappedObject, int index)	273	QString PythonQtWrapper_ElfFile::getSegmentType(ElfFile* theWrappedObject, int index)
	235	{	274	{
	236	return ( theWrappedObject->getSegmentType(index));	275	return ( theWrappedObject->getSegmentType(index));
	237	}	276	}
	238		277
	239	qint64 PythonQtWrapper_ElfFile::getSegmentVaddr(ElfFile* theWrappedObject, int index)	278	qint64 PythonQtWrapper_ElfFile::getSegmentVaddr(ElfFile* theWrappedObject, int index)
	240	{	279	{
	241	return ( theWrappedObject->getSegmentVaddr(index));	280	return ( theWrappedObject->getSegmentVaddr(index));
	242	}	281	}
	243		282
	244	int PythonQtWrapper_ElfFile::getSegmentcount(ElfFile* theWrappedObject)	283	int PythonQtWrapper_ElfFile::getSegmentcount(ElfFile* theWrappedObject)
	245	{	284	{
	246	return ( theWrappedObject->getSegmentcount());	285	return ( theWrappedObject->getSegmentCount());
	247	}	286	}
	248		287
	249	QString PythonQtWrapper_ElfFile::getType(ElfFile* theWrappedObject)	288	QString PythonQtWrapper_ElfFile::getType(ElfFile* theWrappedObject)
	250	{	289	{
	251	return ( theWrappedObject->getType());	290	return ( theWrappedObject->getType());
	252	}	291	}
	253		292
	254	qint64 PythonQtWrapper_ElfFile::getVersion(ElfFile* theWrappedObject)	293	qint64 PythonQtWrapper_ElfFile::getVersion(ElfFile* theWrappedObject)
	255	{	294	{
	256	return ( theWrappedObject->getVersion());	295	return ( theWrappedObject->getVersion());
	257	}	296	}
	258		297
	259	bool PythonQtWrapper_ElfFile::static_ElfFile_isElf(const QString& File)	298	bool PythonQtWrapper_ElfFile::static_ElfFile_isElf(const QString& File)
	260	{	299	{
	261	return (ElfFile::isElf(File));	300	return (ElfFile::isElf(File));
	262	}	301	}
	263		302
	264	bool PythonQtWrapper_ElfFile::iself(ElfFile* theWrappedObject)	303	bool PythonQtWrapper_ElfFile::iself(ElfFile* theWrappedObject)
	265	{	304	{
	266	return ( theWrappedObject->iself());	305	return ( theWrappedObject->iself());
	267	}	306	}
	268		307
	269	bool PythonQtWrapper_ElfFile::isopened(ElfFile* theWrappedObject)	308	bool PythonQtWrapper_ElfFile::isopened(ElfFile* theWrappedObject)
	270	{	309	{
	271	return ( ((PythonQtPublicPromoter_ElfFile*)theWrappedObject)->promoted_isopened());	310	return ( ((PythonQtPublicPromoter_ElfFile*)theWrappedObject)->promoted_isopened());
	272	}	311	}
	273		312
	274	bool PythonQtWrapper_ElfFile::openFile(ElfFile* theWrappedObject, const QString& File)	313	bool PythonQtWrapper_ElfFile::openFile(ElfFile* theWrappedObject, const QString& File)
	275	{	314	{
	276	return ( ((PythonQtPublicPromoter_ElfFile*)theWrappedObject)->promoted_openFile(File));	315	return ( ((PythonQtPublicPromoter_ElfFile*)theWrappedObject)->promoted_openFile(File));
	277	}	316	}
	278		317
	279		318
	280		319
			320	PythonQtShell_MemSizeWdgt::~PythonQtShell_MemSizeWdgt() {
			321	PythonQtPrivate* priv = PythonQt::priv();
			322	if (priv) { priv->shellClassDeleted(this); }
			323	}
			324	void PythonQtShell_MemSizeWdgt::actionEvent(QActionEvent* arg__1)
			325	{
			326	if (_wrapper) {
			327	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "actionEvent");
			328	PyErr_Clear();
			329	if (obj && !PythonQtSlotFunction_Check(obj)) {
			330	static const char* argumentList[] ={"" , "QActionEvent*"};
			331	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			332	void* args[2] = {NULL, (void*)&arg__1};
			333	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			334	if (result) { Py_DECREF(result); }
			335	Py_DECREF(obj);
			336	return;
			337	}
			338	}
			339	MemSizeWdgt::actionEvent(arg__1);
			340	}
			341	void PythonQtShell_MemSizeWdgt::changeEvent(QEvent* arg__1)
			342	{
			343	if (_wrapper) {
			344	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "changeEvent");
			345	PyErr_Clear();
			346	if (obj && !PythonQtSlotFunction_Check(obj)) {
			347	static const char* argumentList[] ={"" , "QEvent*"};
			348	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			349	void* args[2] = {NULL, (void*)&arg__1};
			350	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			351	if (result) { Py_DECREF(result); }
			352	Py_DECREF(obj);
			353	return;
			354	}
			355	}
			356	MemSizeWdgt::changeEvent(arg__1);
			357	}
			358	void PythonQtShell_MemSizeWdgt::childEvent(QChildEvent* arg__1)
			359	{
			360	if (_wrapper) {
			361	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "childEvent");
			362	PyErr_Clear();
			363	if (obj && !PythonQtSlotFunction_Check(obj)) {
			364	static const char* argumentList[] ={"" , "QChildEvent*"};
			365	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			366	void* args[2] = {NULL, (void*)&arg__1};
			367	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			368	if (result) { Py_DECREF(result); }
			369	Py_DECREF(obj);
			370	return;
			371	}
			372	}
			373	MemSizeWdgt::childEvent(arg__1);
			374	}
			375	void PythonQtShell_MemSizeWdgt::closeEvent(QCloseEvent* arg__1)
			376	{
			377	if (_wrapper) {
			378	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "closeEvent");
			379	PyErr_Clear();
			380	if (obj && !PythonQtSlotFunction_Check(obj)) {
			381	static const char* argumentList[] ={"" , "QCloseEvent*"};
			382	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			383	void* args[2] = {NULL, (void*)&arg__1};
			384	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			385	if (result) { Py_DECREF(result); }
			386	Py_DECREF(obj);
			387	return;
			388	}
			389	}
			390	MemSizeWdgt::closeEvent(arg__1);
			391	}
			392	void PythonQtShell_MemSizeWdgt::contextMenuEvent(QContextMenuEvent* arg__1)
			393	{
			394	if (_wrapper) {
			395	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "contextMenuEvent");
			396	PyErr_Clear();
			397	if (obj && !PythonQtSlotFunction_Check(obj)) {
			398	static const char* argumentList[] ={"" , "QContextMenuEvent*"};
			399	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			400	void* args[2] = {NULL, (void*)&arg__1};
			401	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			402	if (result) { Py_DECREF(result); }
			403	Py_DECREF(obj);
			404	return;
			405	}
			406	}
			407	MemSizeWdgt::contextMenuEvent(arg__1);
			408	}
			409	void PythonQtShell_MemSizeWdgt::customEvent(QEvent* arg__1)
			410	{
			411	if (_wrapper) {
			412	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "customEvent");
			413	PyErr_Clear();
			414	if (obj && !PythonQtSlotFunction_Check(obj)) {
			415	static const char* argumentList[] ={"" , "QEvent*"};
			416	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			417	void* args[2] = {NULL, (void*)&arg__1};
			418	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			419	if (result) { Py_DECREF(result); }
			420	Py_DECREF(obj);
			421	return;
			422	}
			423	}
			424	MemSizeWdgt::customEvent(arg__1);
			425	}
			426	int PythonQtShell_MemSizeWdgt::devType() const
			427	{
			428	if (_wrapper) {
			429	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "devType");
			430	PyErr_Clear();
			431	if (obj && !PythonQtSlotFunction_Check(obj)) {
			432	static const char* argumentList[] ={"int"};
			433	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
			434	int returnValue;
			435	void* args[1] = {NULL};
			436	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			437	if (result) {
			438	args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
			439	if (args[0]!=&returnValue) {
			440	if (args[0]==NULL) {
			441	PythonQt::priv()->handleVirtualOverloadReturnError("devType", methodInfo, result);
			442	} else {
			443	returnValue = ((int)args[0]);
			444	}
			445	}
			446	}
			447	if (result) { Py_DECREF(result); }
			448	Py_DECREF(obj);
			449	return returnValue;
			450	}
			451	}
			452	return MemSizeWdgt::devType();
			453	}
			454	void PythonQtShell_MemSizeWdgt::dragEnterEvent(QDragEnterEvent* arg__1)
			455	{
			456	if (_wrapper) {
			457	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragEnterEvent");
			458	PyErr_Clear();
			459	if (obj && !PythonQtSlotFunction_Check(obj)) {
			460	static const char* argumentList[] ={"" , "QDragEnterEvent*"};
			461	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			462	void* args[2] = {NULL, (void*)&arg__1};
			463	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			464	if (result) { Py_DECREF(result); }
			465	Py_DECREF(obj);
			466	return;
			467	}
			468	}
			469	MemSizeWdgt::dragEnterEvent(arg__1);
			470	}
			471	void PythonQtShell_MemSizeWdgt::dragLeaveEvent(QDragLeaveEvent* arg__1)
			472	{
			473	if (_wrapper) {
			474	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragLeaveEvent");
			475	PyErr_Clear();
			476	if (obj && !PythonQtSlotFunction_Check(obj)) {
			477	static const char* argumentList[] ={"" , "QDragLeaveEvent*"};
			478	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			479	void* args[2] = {NULL, (void*)&arg__1};
			480	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			481	if (result) { Py_DECREF(result); }
			482	Py_DECREF(obj);
			483	return;
			484	}
			485	}
			486	MemSizeWdgt::dragLeaveEvent(arg__1);
			487	}
			488	void PythonQtShell_MemSizeWdgt::dragMoveEvent(QDragMoveEvent* arg__1)
			489	{
			490	if (_wrapper) {
			491	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragMoveEvent");
			492	PyErr_Clear();
			493	if (obj && !PythonQtSlotFunction_Check(obj)) {
			494	static const char* argumentList[] ={"" , "QDragMoveEvent*"};
			495	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			496	void* args[2] = {NULL, (void*)&arg__1};
			497	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			498	if (result) { Py_DECREF(result); }
			499	Py_DECREF(obj);
			500	return;
			501	}
			502	}
			503	MemSizeWdgt::dragMoveEvent(arg__1);
			504	}
			505	void PythonQtShell_MemSizeWdgt::dropEvent(QDropEvent* arg__1)
			506	{
			507	if (_wrapper) {
			508	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dropEvent");
			509	PyErr_Clear();
			510	if (obj && !PythonQtSlotFunction_Check(obj)) {
			511	static const char* argumentList[] ={"" , "QDropEvent*"};
			512	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			513	void* args[2] = {NULL, (void*)&arg__1};
			514	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			515	if (result) { Py_DECREF(result); }
			516	Py_DECREF(obj);
			517	return;
			518	}
			519	}
			520	MemSizeWdgt::dropEvent(arg__1);
			521	}
			522	void PythonQtShell_MemSizeWdgt::enterEvent(QEvent* arg__1)
			523	{
			524	if (_wrapper) {
			525	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "enterEvent");
			526	PyErr_Clear();
			527	if (obj && !PythonQtSlotFunction_Check(obj)) {
			528	static const char* argumentList[] ={"" , "QEvent*"};
			529	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			530	void* args[2] = {NULL, (void*)&arg__1};
			531	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			532	if (result) { Py_DECREF(result); }
			533	Py_DECREF(obj);
			534	return;
			535	}
			536	}
			537	MemSizeWdgt::enterEvent(arg__1);
			538	}
			539	bool PythonQtShell_MemSizeWdgt::event(QEvent* arg__1)
			540	{
			541	if (_wrapper) {
			542	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "event");
			543	PyErr_Clear();
			544	if (obj && !PythonQtSlotFunction_Check(obj)) {
			545	static const char* argumentList[] ={"bool" , "QEvent*"};
			546	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			547	bool returnValue;
			548	void* args[2] = {NULL, (void*)&arg__1};
			549	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			550	if (result) {
			551	args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
			552	if (args[0]!=&returnValue) {
			553	if (args[0]==NULL) {
			554	PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
			555	} else {
			556	returnValue = ((bool)args[0]);
			557	}
			558	}
			559	}
			560	if (result) { Py_DECREF(result); }
			561	Py_DECREF(obj);
			562	return returnValue;
			563	}
			564	}
			565	return MemSizeWdgt::event(arg__1);
			566	}
			567	bool PythonQtShell_MemSizeWdgt::eventFilter(QObject* arg__1, QEvent* arg__2)
			568	{
			569	if (_wrapper) {
			570	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "eventFilter");
			571	PyErr_Clear();
			572	if (obj && !PythonQtSlotFunction_Check(obj)) {
			573	static const char* argumentList[] ={"bool" , "QObject" , "QEvent"};
			574	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
			575	bool returnValue;
			576	void* args[3] = {NULL, (void)&arg__1, (void)&arg__2};
			577	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			578	if (result) {
			579	args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
			580	if (args[0]!=&returnValue) {
			581	if (args[0]==NULL) {
			582	PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
			583	} else {
			584	returnValue = ((bool)args[0]);
			585	}
			586	}
			587	}
			588	if (result) { Py_DECREF(result); }
			589	Py_DECREF(obj);
			590	return returnValue;
			591	}
			592	}
			593	return MemSizeWdgt::eventFilter(arg__1, arg__2);
			594	}
			595	void PythonQtShell_MemSizeWdgt::focusInEvent(QFocusEvent* arg__1)
			596	{
			597	if (_wrapper) {
			598	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusInEvent");
			599	PyErr_Clear();
			600	if (obj && !PythonQtSlotFunction_Check(obj)) {
			601	static const char* argumentList[] ={"" , "QFocusEvent*"};
			602	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			603	void* args[2] = {NULL, (void*)&arg__1};
			604	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			605	if (result) { Py_DECREF(result); }
			606	Py_DECREF(obj);
			607	return;
			608	}
			609	}
			610	MemSizeWdgt::focusInEvent(arg__1);
			611	}
			612	bool PythonQtShell_MemSizeWdgt::focusNextPrevChild(bool next)
			613	{
			614	if (_wrapper) {
			615	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusNextPrevChild");
			616	PyErr_Clear();
			617	if (obj && !PythonQtSlotFunction_Check(obj)) {
			618	static const char* argumentList[] ={"bool" , "bool"};
			619	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			620	bool returnValue;
			621	void* args[2] = {NULL, (void*)&next};
			622	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			623	if (result) {
			624	args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
			625	if (args[0]!=&returnValue) {
			626	if (args[0]==NULL) {
			627	PythonQt::priv()->handleVirtualOverloadReturnError("focusNextPrevChild", methodInfo, result);
			628	} else {
			629	returnValue = ((bool)args[0]);
			630	}
			631	}
			632	}
			633	if (result) { Py_DECREF(result); }
			634	Py_DECREF(obj);
			635	return returnValue;
			636	}
			637	}
			638	return MemSizeWdgt::focusNextPrevChild(next);
			639	}
			640	void PythonQtShell_MemSizeWdgt::focusOutEvent(QFocusEvent* arg__1)
			641	{
			642	if (_wrapper) {
			643	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusOutEvent");
			644	PyErr_Clear();
			645	if (obj && !PythonQtSlotFunction_Check(obj)) {
			646	static const char* argumentList[] ={"" , "QFocusEvent*"};
			647	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			648	void* args[2] = {NULL, (void*)&arg__1};
			649	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			650	if (result) { Py_DECREF(result); }
			651	Py_DECREF(obj);
			652	return;
			653	}
			654	}
			655	MemSizeWdgt::focusOutEvent(arg__1);
			656	}
			657	bool PythonQtShell_MemSizeWdgt::hasHeightForWidth() const
			658	{
			659	if (_wrapper) {
			660	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hasHeightForWidth");
			661	PyErr_Clear();
			662	if (obj && !PythonQtSlotFunction_Check(obj)) {
			663	static const char* argumentList[] ={"bool"};
			664	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
			665	bool returnValue;
			666	void* args[1] = {NULL};
			667	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			668	if (result) {
			669	args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
			670	if (args[0]!=&returnValue) {
			671	if (args[0]==NULL) {
			672	PythonQt::priv()->handleVirtualOverloadReturnError("hasHeightForWidth", methodInfo, result);
			673	} else {
			674	returnValue = ((bool)args[0]);
			675	}
			676	}
			677	}
			678	if (result) { Py_DECREF(result); }
			679	Py_DECREF(obj);
			680	return returnValue;
			681	}
			682	}
			683	return MemSizeWdgt::hasHeightForWidth();
			684	}
			685	int PythonQtShell_MemSizeWdgt::heightForWidth(int arg__1) const
			686	{
			687	if (_wrapper) {
			688	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "heightForWidth");
			689	PyErr_Clear();
			690	if (obj && !PythonQtSlotFunction_Check(obj)) {
			691	static const char* argumentList[] ={"int" , "int"};
			692	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			693	int returnValue;
			694	void* args[2] = {NULL, (void*)&arg__1};
			695	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			696	if (result) {
			697	args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
			698	if (args[0]!=&returnValue) {
			699	if (args[0]==NULL) {
			700	PythonQt::priv()->handleVirtualOverloadReturnError("heightForWidth", methodInfo, result);
			701	} else {
			702	returnValue = ((int)args[0]);
			703	}
			704	}
			705	}
			706	if (result) { Py_DECREF(result); }
			707	Py_DECREF(obj);
			708	return returnValue;
			709	}
			710	}
			711	return MemSizeWdgt::heightForWidth(arg__1);
			712	}
			713	void PythonQtShell_MemSizeWdgt::hideEvent(QHideEvent* arg__1)
			714	{
			715	if (_wrapper) {
			716	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hideEvent");
			717	PyErr_Clear();
			718	if (obj && !PythonQtSlotFunction_Check(obj)) {
			719	static const char* argumentList[] ={"" , "QHideEvent*"};
			720	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			721	void* args[2] = {NULL, (void*)&arg__1};
			722	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			723	if (result) { Py_DECREF(result); }
			724	Py_DECREF(obj);
			725	return;
			726	}
			727	}
			728	MemSizeWdgt::hideEvent(arg__1);
			729	}
			730	void PythonQtShell_MemSizeWdgt::initPainter(QPainter* painter) const
			731	{
			732	if (_wrapper) {
			733	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "initPainter");
			734	PyErr_Clear();
			735	if (obj && !PythonQtSlotFunction_Check(obj)) {
			736	static const char* argumentList[] ={"" , "QPainter*"};
			737	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			738	void* args[2] = {NULL, (void*)&painter};
			739	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			740	if (result) { Py_DECREF(result); }
			741	Py_DECREF(obj);
			742	return;
			743	}
			744	}
			745	MemSizeWdgt::initPainter(painter);
			746	}
			747	void PythonQtShell_MemSizeWdgt::inputMethodEvent(QInputMethodEvent* arg__1)
			748	{
			749	if (_wrapper) {
			750	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodEvent");
			751	PyErr_Clear();
			752	if (obj && !PythonQtSlotFunction_Check(obj)) {
			753	static const char* argumentList[] ={"" , "QInputMethodEvent*"};
			754	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			755	void* args[2] = {NULL, (void*)&arg__1};
			756	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			757	if (result) { Py_DECREF(result); }
			758	Py_DECREF(obj);
			759	return;
			760	}
			761	}
			762	MemSizeWdgt::inputMethodEvent(arg__1);
			763	}
			764	QVariant PythonQtShell_MemSizeWdgt::inputMethodQuery(Qt::InputMethodQuery arg__1) const
			765	{
			766	if (_wrapper) {
			767	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodQuery");
			768	PyErr_Clear();
			769	if (obj && !PythonQtSlotFunction_Check(obj)) {
			770	static const char* argumentList[] ={"QVariant" , "Qt::InputMethodQuery"};
			771	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			772	QVariant returnValue;
			773	void* args[2] = {NULL, (void*)&arg__1};
			774	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			775	if (result) {
			776	args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
			777	if (args[0]!=&returnValue) {
			778	if (args[0]==NULL) {
			779	PythonQt::priv()->handleVirtualOverloadReturnError("inputMethodQuery", methodInfo, result);
			780	} else {
			781	returnValue = ((QVariant)args[0]);
			782	}
			783	}
			784	}
			785	if (result) { Py_DECREF(result); }
			786	Py_DECREF(obj);
			787	return returnValue;
			788	}
			789	}
			790	return MemSizeWdgt::inputMethodQuery(arg__1);
			791	}
			792	void PythonQtShell_MemSizeWdgt::keyPressEvent(QKeyEvent* arg__1)
			793	{
			794	if (_wrapper) {
			795	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyPressEvent");
			796	PyErr_Clear();
			797	if (obj && !PythonQtSlotFunction_Check(obj)) {
			798	static const char* argumentList[] ={"" , "QKeyEvent*"};
			799	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			800	void* args[2] = {NULL, (void*)&arg__1};
			801	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			802	if (result) { Py_DECREF(result); }
			803	Py_DECREF(obj);
			804	return;
			805	}
			806	}
			807	MemSizeWdgt::keyPressEvent(arg__1);
			808	}
			809	void PythonQtShell_MemSizeWdgt::keyReleaseEvent(QKeyEvent* arg__1)
			810	{
			811	if (_wrapper) {
			812	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyReleaseEvent");
			813	PyErr_Clear();
			814	if (obj && !PythonQtSlotFunction_Check(obj)) {
			815	static const char* argumentList[] ={"" , "QKeyEvent*"};
			816	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			817	void* args[2] = {NULL, (void*)&arg__1};
			818	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			819	if (result) { Py_DECREF(result); }
			820	Py_DECREF(obj);
			821	return;
			822	}
			823	}
			824	MemSizeWdgt::keyReleaseEvent(arg__1);
			825	}
			826	void PythonQtShell_MemSizeWdgt::leaveEvent(QEvent* arg__1)
			827	{
			828	if (_wrapper) {
			829	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "leaveEvent");
			830	PyErr_Clear();
			831	if (obj && !PythonQtSlotFunction_Check(obj)) {
			832	static const char* argumentList[] ={"" , "QEvent*"};
			833	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			834	void* args[2] = {NULL, (void*)&arg__1};
			835	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			836	if (result) { Py_DECREF(result); }
			837	Py_DECREF(obj);
			838	return;
			839	}
			840	}
			841	MemSizeWdgt::leaveEvent(arg__1);
			842	}
			843	int PythonQtShell_MemSizeWdgt::metric(QPaintDevice::PaintDeviceMetric arg__1) const
			844	{
			845	if (_wrapper) {
			846	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "metric");
			847	PyErr_Clear();
			848	if (obj && !PythonQtSlotFunction_Check(obj)) {
			849	static const char* argumentList[] ={"int" , "QPaintDevice::PaintDeviceMetric"};
			850	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			851	int returnValue;
			852	void* args[2] = {NULL, (void*)&arg__1};
			853	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			854	if (result) {
			855	args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
			856	if (args[0]!=&returnValue) {
			857	if (args[0]==NULL) {
			858	PythonQt::priv()->handleVirtualOverloadReturnError("metric", methodInfo, result);
			859	} else {
			860	returnValue = ((int)args[0]);
			861	}
			862	}
			863	}
			864	if (result) { Py_DECREF(result); }
			865	Py_DECREF(obj);
			866	return returnValue;
			867	}
			868	}
			869	return MemSizeWdgt::metric(arg__1);
			870	}
			871	QSize PythonQtShell_MemSizeWdgt::minimumSizeHint() const
			872	{
			873	if (_wrapper) {
			874	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getMinimumSizeHint");
			875	PyErr_Clear();
			876	if (obj && !PythonQtSlotFunction_Check(obj)) {
			877	static const char* argumentList[] ={"QSize"};
			878	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
			879	QSize returnValue;
			880	void* args[1] = {NULL};
			881	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			882	if (result) {
			883	args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
			884	if (args[0]!=&returnValue) {
			885	if (args[0]==NULL) {
			886	PythonQt::priv()->handleVirtualOverloadReturnError("getMinimumSizeHint", methodInfo, result);
			887	} else {
			888	returnValue = ((QSize)args[0]);
			889	}
			890	}
			891	}
			892	if (result) { Py_DECREF(result); }
			893	Py_DECREF(obj);
			894	return returnValue;
			895	}
			896	}
			897	return MemSizeWdgt::minimumSizeHint();
			898	}
			899	void PythonQtShell_MemSizeWdgt::mouseDoubleClickEvent(QMouseEvent* arg__1)
			900	{
			901	if (_wrapper) {
			902	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseDoubleClickEvent");
			903	PyErr_Clear();
			904	if (obj && !PythonQtSlotFunction_Check(obj)) {
			905	static const char* argumentList[] ={"" , "QMouseEvent*"};
			906	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			907	void* args[2] = {NULL, (void*)&arg__1};
			908	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			909	if (result) { Py_DECREF(result); }
			910	Py_DECREF(obj);
			911	return;
			912	}
			913	}
			914	MemSizeWdgt::mouseDoubleClickEvent(arg__1);
			915	}
			916	void PythonQtShell_MemSizeWdgt::mouseMoveEvent(QMouseEvent* arg__1)
			917	{
			918	if (_wrapper) {
			919	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseMoveEvent");
			920	PyErr_Clear();
			921	if (obj && !PythonQtSlotFunction_Check(obj)) {
			922	static const char* argumentList[] ={"" , "QMouseEvent*"};
			923	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			924	void* args[2] = {NULL, (void*)&arg__1};
			925	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			926	if (result) { Py_DECREF(result); }
			927	Py_DECREF(obj);
			928	return;
			929	}
			930	}
			931	MemSizeWdgt::mouseMoveEvent(arg__1);
			932	}
			933	void PythonQtShell_MemSizeWdgt::mousePressEvent(QMouseEvent* arg__1)
			934	{
			935	if (_wrapper) {
			936	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mousePressEvent");
			937	PyErr_Clear();
			938	if (obj && !PythonQtSlotFunction_Check(obj)) {
			939	static const char* argumentList[] ={"" , "QMouseEvent*"};
			940	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			941	void* args[2] = {NULL, (void*)&arg__1};
			942	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			943	if (result) { Py_DECREF(result); }
			944	Py_DECREF(obj);
			945	return;
			946	}
			947	}
			948	MemSizeWdgt::mousePressEvent(arg__1);
			949	}
			950	void PythonQtShell_MemSizeWdgt::mouseReleaseEvent(QMouseEvent* arg__1)
			951	{
			952	if (_wrapper) {
			953	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseReleaseEvent");
			954	PyErr_Clear();
			955	if (obj && !PythonQtSlotFunction_Check(obj)) {
			956	static const char* argumentList[] ={"" , "QMouseEvent*"};
			957	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			958	void* args[2] = {NULL, (void*)&arg__1};
			959	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			960	if (result) { Py_DECREF(result); }
			961	Py_DECREF(obj);
			962	return;
			963	}
			964	}
			965	MemSizeWdgt::mouseReleaseEvent(arg__1);
			966	}
			967	void PythonQtShell_MemSizeWdgt::moveEvent(QMoveEvent* arg__1)
			968	{
			969	if (_wrapper) {
			970	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "moveEvent");
			971	PyErr_Clear();
			972	if (obj && !PythonQtSlotFunction_Check(obj)) {
			973	static const char* argumentList[] ={"" , "QMoveEvent*"};
			974	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			975	void* args[2] = {NULL, (void*)&arg__1};
			976	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			977	if (result) { Py_DECREF(result); }
			978	Py_DECREF(obj);
			979	return;
			980	}
			981	}
			982	MemSizeWdgt::moveEvent(arg__1);
			983	}
			984	bool PythonQtShell_MemSizeWdgt::nativeEvent(const QByteArray& eventType, void* message, long* result)
			985	{
			986	if (_wrapper) {
			987	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "nativeEvent");
			988	PyErr_Clear();
			989	if (obj && !PythonQtSlotFunction_Check(obj)) {
			990	static const char* argumentList[] ={"bool" , "const QByteArray&" , "void" , "long"};
			991	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
			992	bool returnValue;
			993	void* args[4] = {NULL, (void)&eventType, (void)&message, (void*)&result};
			994	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			995	if (result) {
			996	args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
			997	if (args[0]!=&returnValue) {
			998	if (args[0]==NULL) {
			999	PythonQt::priv()->handleVirtualOverloadReturnError("nativeEvent", methodInfo, result);
			1000	} else {
			1001	returnValue = ((bool)args[0]);
			1002	}
			1003	}
			1004	}
			1005	if (result) { Py_DECREF(result); }
			1006	Py_DECREF(obj);
			1007	return returnValue;
			1008	}
			1009	}
			1010	return MemSizeWdgt::nativeEvent(eventType, message, result);
			1011	}
			1012	QPaintEngine* PythonQtShell_MemSizeWdgt::paintEngine() const
			1013	{
			1014	if (_wrapper) {
			1015	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEngine");
			1016	PyErr_Clear();
			1017	if (obj && !PythonQtSlotFunction_Check(obj)) {
			1018	static const char* argumentList[] ={"QPaintEngine*"};
			1019	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
			1020	QPaintEngine* returnValue;
			1021	void* args[1] = {NULL};
			1022	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			1023	if (result) {
			1024	args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
			1025	if (args[0]!=&returnValue) {
			1026	if (args[0]==NULL) {
			1027	PythonQt::priv()->handleVirtualOverloadReturnError("paintEngine", methodInfo, result);
			1028	} else {
			1029	returnValue = ((QPaintEngine*)args[0]);
			1030	}
			1031	}
			1032	}
			1033	if (result) { Py_DECREF(result); }
			1034	Py_DECREF(obj);
			1035	return returnValue;
			1036	}
			1037	}
			1038	return MemSizeWdgt::paintEngine();
			1039	}
			1040	void PythonQtShell_MemSizeWdgt::paintEvent(QPaintEvent* arg__1)
			1041	{
			1042	if (_wrapper) {
			1043	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEvent");
			1044	PyErr_Clear();
			1045	if (obj && !PythonQtSlotFunction_Check(obj)) {
			1046	static const char* argumentList[] ={"" , "QPaintEvent*"};
			1047	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			1048	void* args[2] = {NULL, (void*)&arg__1};
			1049	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			1050	if (result) { Py_DECREF(result); }
			1051	Py_DECREF(obj);
			1052	return;
			1053	}
			1054	}
			1055	MemSizeWdgt::paintEvent(arg__1);
			1056	}
			1057	QPaintDevice* PythonQtShell_MemSizeWdgt::redirected(QPoint* offset) const
			1058	{
			1059	if (_wrapper) {
			1060	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "redirected");
			1061	PyErr_Clear();
			1062	if (obj && !PythonQtSlotFunction_Check(obj)) {
			1063	static const char* argumentList[] ={"QPaintDevice" , "QPoint"};
			1064	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			1065	QPaintDevice* returnValue;
			1066	void* args[2] = {NULL, (void*)&offset};
			1067	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			1068	if (result) {
			1069	args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
			1070	if (args[0]!=&returnValue) {
			1071	if (args[0]==NULL) {
			1072	PythonQt::priv()->handleVirtualOverloadReturnError("redirected", methodInfo, result);
			1073	} else {
			1074	returnValue = ((QPaintDevice*)args[0]);
			1075	}
			1076	}
			1077	}
			1078	if (result) { Py_DECREF(result); }
			1079	Py_DECREF(obj);
			1080	return returnValue;
			1081	}
			1082	}
			1083	return MemSizeWdgt::redirected(offset);
			1084	}
			1085	void PythonQtShell_MemSizeWdgt::resizeEvent(QResizeEvent* arg__1)
			1086	{
			1087	if (_wrapper) {
			1088	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "resizeEvent");
			1089	PyErr_Clear();
			1090	if (obj && !PythonQtSlotFunction_Check(obj)) {
			1091	static const char* argumentList[] ={"" , "QResizeEvent*"};
			1092	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			1093	void* args[2] = {NULL, (void*)&arg__1};
			1094	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			1095	if (result) { Py_DECREF(result); }
			1096	Py_DECREF(obj);
			1097	return;
			1098	}
			1099	}
			1100	MemSizeWdgt::resizeEvent(arg__1);
			1101	}
			1102	QPainter* PythonQtShell_MemSizeWdgt::sharedPainter() const
			1103	{
			1104	if (_wrapper) {
			1105	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "sharedPainter");
			1106	PyErr_Clear();
			1107	if (obj && !PythonQtSlotFunction_Check(obj)) {
			1108	static const char* argumentList[] ={"QPainter*"};
			1109	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
			1110	QPainter* returnValue;
			1111	void* args[1] = {NULL};
			1112	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			1113	if (result) {
			1114	args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
			1115	if (args[0]!=&returnValue) {
			1116	if (args[0]==NULL) {
			1117	PythonQt::priv()->handleVirtualOverloadReturnError("sharedPainter", methodInfo, result);
			1118	} else {
			1119	returnValue = ((QPainter*)args[0]);
			1120	}
			1121	}
			1122	}
			1123	if (result) { Py_DECREF(result); }
			1124	Py_DECREF(obj);
			1125	return returnValue;
			1126	}
			1127	}
			1128	return MemSizeWdgt::sharedPainter();
			1129	}
			1130	void PythonQtShell_MemSizeWdgt::showEvent(QShowEvent* arg__1)
			1131	{
			1132	if (_wrapper) {
			1133	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "showEvent");
			1134	PyErr_Clear();
			1135	if (obj && !PythonQtSlotFunction_Check(obj)) {
			1136	static const char* argumentList[] ={"" , "QShowEvent*"};
			1137	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			1138	void* args[2] = {NULL, (void*)&arg__1};
			1139	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			1140	if (result) { Py_DECREF(result); }
			1141	Py_DECREF(obj);
			1142	return;
			1143	}
			1144	}
			1145	MemSizeWdgt::showEvent(arg__1);
			1146	}
			1147	QSize PythonQtShell_MemSizeWdgt::sizeHint() const
			1148	{
			1149	if (_wrapper) {
			1150	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getSizeHint");
			1151	PyErr_Clear();
			1152	if (obj && !PythonQtSlotFunction_Check(obj)) {
			1153	static const char* argumentList[] ={"QSize"};
			1154	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
			1155	QSize returnValue;
			1156	void* args[1] = {NULL};
			1157	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			1158	if (result) {
			1159	args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
			1160	if (args[0]!=&returnValue) {
			1161	if (args[0]==NULL) {
			1162	PythonQt::priv()->handleVirtualOverloadReturnError("getSizeHint", methodInfo, result);
			1163	} else {
			1164	returnValue = ((QSize)args[0]);
			1165	}
			1166	}
			1167	}
			1168	if (result) { Py_DECREF(result); }
			1169	Py_DECREF(obj);
			1170	return returnValue;
			1171	}
			1172	}
			1173	return MemSizeWdgt::sizeHint();
			1174	}
			1175	void PythonQtShell_MemSizeWdgt::tabletEvent(QTabletEvent* arg__1)
			1176	{
			1177	if (_wrapper) {
			1178	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "tabletEvent");
			1179	PyErr_Clear();
			1180	if (obj && !PythonQtSlotFunction_Check(obj)) {
			1181	static const char* argumentList[] ={"" , "QTabletEvent*"};
			1182	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			1183	void* args[2] = {NULL, (void*)&arg__1};
			1184	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			1185	if (result) { Py_DECREF(result); }
			1186	Py_DECREF(obj);
			1187	return;
			1188	}
			1189	}
			1190	MemSizeWdgt::tabletEvent(arg__1);
			1191	}
			1192	void PythonQtShell_MemSizeWdgt::timerEvent(QTimerEvent* arg__1)
			1193	{
			1194	if (_wrapper) {
			1195	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "timerEvent");
			1196	PyErr_Clear();
			1197	if (obj && !PythonQtSlotFunction_Check(obj)) {
			1198	static const char* argumentList[] ={"" , "QTimerEvent*"};
			1199	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			1200	void* args[2] = {NULL, (void*)&arg__1};
			1201	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			1202	if (result) { Py_DECREF(result); }
			1203	Py_DECREF(obj);
			1204	return;
			1205	}
			1206	}
			1207	MemSizeWdgt::timerEvent(arg__1);
			1208	}
			1209	void PythonQtShell_MemSizeWdgt::wheelEvent(QWheelEvent* arg__1)
			1210	{
			1211	if (_wrapper) {
			1212	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "wheelEvent");
			1213	PyErr_Clear();
			1214	if (obj && !PythonQtSlotFunction_Check(obj)) {
			1215	static const char* argumentList[] ={"" , "QWheelEvent*"};
			1216	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			1217	void* args[2] = {NULL, (void*)&arg__1};
			1218	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			1219	if (result) { Py_DECREF(result); }
			1220	Py_DECREF(obj);
			1221	return;
			1222	}
			1223	}
			1224	MemSizeWdgt::wheelEvent(arg__1);
			1225	}
	281	MemSizeWdgt* PythonQtWrapper_MemSizeWdgt::new_MemSizeWdgt(QWidget* parent)	1226	MemSizeWdgt* PythonQtWrapper_MemSizeWdgt::new_MemSizeWdgt(QWidget* parent)
	282	{	1227	{
	283	return new MemSizeWdgt(parent); }	1228	return new PythonQtShell_MemSizeWdgt(parent); }
	284		1229
	285	MemSizeWdgt* PythonQtWrapper_MemSizeWdgt::new_MemSizeWdgt(int defaultSize, QWidget* parent)	1230	MemSizeWdgt* PythonQtWrapper_MemSizeWdgt::new_MemSizeWdgt(int defaultSize, QWidget* parent)
	286	{	1231	{
	287	return new MemSizeWdgt(defaultSize, parent); }	1232	return new PythonQtShell_MemSizeWdgt(defaultSize, parent); }
	288		1233
	289	int PythonQtWrapper_MemSizeWdgt::getsize(MemSizeWdgt* theWrappedObject)	1234	int PythonQtWrapper_MemSizeWdgt::getsize(MemSizeWdgt* theWrappedObject)
	290	{	1235	{
	291	return ( theWrappedObject->getsize());	1236	return ( theWrappedObject->getsize());
	292	}	1237	}
	293		1238
	294	void PythonQtWrapper_MemSizeWdgt::setMaximum(MemSizeWdgt* theWrappedObject, unsigned int max)	1239	void PythonQtWrapper_MemSizeWdgt::setMaximum(MemSizeWdgt* theWrappedObject, unsigned int max)
	295	{	1240	{
	296	( theWrappedObject->setMaximum(max));	1241	( theWrappedObject->setMaximum(max));
	297	}	1242	}
	298		1243
	299	void PythonQtWrapper_MemSizeWdgt::show(MemSizeWdgt* theWrappedObject)	1244	void PythonQtWrapper_MemSizeWdgt::show(MemSizeWdgt* theWrappedObject)
	300	{	1245	{
	301	( theWrappedObject->show());	1246	( theWrappedObject->show());
	302	}	1247	}
	303		1248
	304	void PythonQtWrapper_MemSizeWdgt::updateSizeValue(MemSizeWdgt* theWrappedObject)	1249	void PythonQtWrapper_MemSizeWdgt::updateSizeValue(MemSizeWdgt* theWrappedObject)
	305	{	1250	{
	306	( theWrappedObject->updateSizeValue());	1251	( theWrappedObject->updateSizeValue());
	307	}	1252	}
	308		1253
	309		1254
	310		1255
	311	PythonQtShell_QHexEdit::~PythonQtShell_QHexEdit() {	1256	PythonQtShell_QHexEdit::~PythonQtShell_QHexEdit() {
	312	PythonQtPrivate* priv = PythonQt::priv();	1257	PythonQtPrivate* priv = PythonQt::priv();
	313	if (priv) { priv->shellClassDeleted(this); }	1258	if (priv) { priv->shellClassDeleted(this); }
	314	}	1259	}
			1260	void PythonQtShell_QHexEdit::actionEvent(QActionEvent* arg__1)
			1261	{
			1262	if (_wrapper) {
			1263	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "actionEvent");
			1264	PyErr_Clear();
			1265	if (obj && !PythonQtSlotFunction_Check(obj)) {
			1266	static const char* argumentList[] ={"" , "QActionEvent*"};
			1267	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			1268	void* args[2] = {NULL, (void*)&arg__1};
			1269	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			1270	if (result) { Py_DECREF(result); }
			1271	Py_DECREF(obj);
			1272	return;
			1273	}
			1274	}
			1275	QHexEdit::actionEvent(arg__1);
			1276	}
			1277	void PythonQtShell_QHexEdit::changeEvent(QEvent* arg__1)
			1278	{
			1279	if (_wrapper) {
			1280	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "changeEvent");
			1281	PyErr_Clear();
			1282	if (obj && !PythonQtSlotFunction_Check(obj)) {
			1283	static const char* argumentList[] ={"" , "QEvent*"};
			1284	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			1285	void* args[2] = {NULL, (void*)&arg__1};
			1286	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			1287	if (result) { Py_DECREF(result); }
			1288	Py_DECREF(obj);
			1289	return;
			1290	}
			1291	}
			1292	QHexEdit::changeEvent(arg__1);
			1293	}
			1294	void PythonQtShell_QHexEdit::childEvent(QChildEvent* arg__1)
			1295	{
			1296	if (_wrapper) {
			1297	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "childEvent");
			1298	PyErr_Clear();
			1299	if (obj && !PythonQtSlotFunction_Check(obj)) {
			1300	static const char* argumentList[] ={"" , "QChildEvent*"};
			1301	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			1302	void* args[2] = {NULL, (void*)&arg__1};
			1303	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			1304	if (result) { Py_DECREF(result); }
			1305	Py_DECREF(obj);
			1306	return;
			1307	}
			1308	}
			1309	QHexEdit::childEvent(arg__1);
			1310	}
			1311	void PythonQtShell_QHexEdit::closeEvent(QCloseEvent* arg__1)
			1312	{
			1313	if (_wrapper) {
			1314	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "closeEvent");
			1315	PyErr_Clear();
			1316	if (obj && !PythonQtSlotFunction_Check(obj)) {
			1317	static const char* argumentList[] ={"" , "QCloseEvent*"};
			1318	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			1319	void* args[2] = {NULL, (void*)&arg__1};
			1320	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			1321	if (result) { Py_DECREF(result); }
			1322	Py_DECREF(obj);
			1323	return;
			1324	}
			1325	}
			1326	QHexEdit::closeEvent(arg__1);
			1327	}
			1328	void PythonQtShell_QHexEdit::contextMenuEvent(QContextMenuEvent* arg__1)
			1329	{
			1330	if (_wrapper) {
			1331	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "contextMenuEvent");
			1332	PyErr_Clear();
			1333	if (obj && !PythonQtSlotFunction_Check(obj)) {
			1334	static const char* argumentList[] ={"" , "QContextMenuEvent*"};
			1335	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			1336	void* args[2] = {NULL, (void*)&arg__1};
			1337	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			1338	if (result) { Py_DECREF(result); }
			1339	Py_DECREF(obj);
			1340	return;
			1341	}
			1342	}
			1343	QHexEdit::contextMenuEvent(arg__1);
			1344	}
			1345	void PythonQtShell_QHexEdit::customEvent(QEvent* arg__1)
			1346	{
			1347	if (_wrapper) {
			1348	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "customEvent");
			1349	PyErr_Clear();
			1350	if (obj && !PythonQtSlotFunction_Check(obj)) {
			1351	static const char* argumentList[] ={"" , "QEvent*"};
			1352	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			1353	void* args[2] = {NULL, (void*)&arg__1};
			1354	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			1355	if (result) { Py_DECREF(result); }
			1356	Py_DECREF(obj);
			1357	return;
			1358	}
			1359	}
			1360	QHexEdit::customEvent(arg__1);
			1361	}
			1362	int PythonQtShell_QHexEdit::devType() const
			1363	{
			1364	if (_wrapper) {
			1365	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "devType");
			1366	PyErr_Clear();
			1367	if (obj && !PythonQtSlotFunction_Check(obj)) {
			1368	static const char* argumentList[] ={"int"};
			1369	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
			1370	int returnValue;
			1371	void* args[1] = {NULL};
			1372	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			1373	if (result) {
			1374	args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
			1375	if (args[0]!=&returnValue) {
			1376	if (args[0]==NULL) {
			1377	PythonQt::priv()->handleVirtualOverloadReturnError("devType", methodInfo, result);
			1378	} else {
			1379	returnValue = ((int)args[0]);
			1380	}
			1381	}
			1382	}
			1383	if (result) { Py_DECREF(result); }
			1384	Py_DECREF(obj);
			1385	return returnValue;
			1386	}
			1387	}
			1388	return QHexEdit::devType();
			1389	}
			1390	void PythonQtShell_QHexEdit::dragEnterEvent(QDragEnterEvent* arg__1)
			1391	{
			1392	if (_wrapper) {
			1393	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragEnterEvent");
			1394	PyErr_Clear();
			1395	if (obj && !PythonQtSlotFunction_Check(obj)) {
			1396	static const char* argumentList[] ={"" , "QDragEnterEvent*"};
			1397	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			1398	void* args[2] = {NULL, (void*)&arg__1};
			1399	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			1400	if (result) { Py_DECREF(result); }
			1401	Py_DECREF(obj);
			1402	return;
			1403	}
			1404	}
			1405	QHexEdit::dragEnterEvent(arg__1);
			1406	}
			1407	void PythonQtShell_QHexEdit::dragLeaveEvent(QDragLeaveEvent* arg__1)
			1408	{
			1409	if (_wrapper) {
			1410	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragLeaveEvent");
			1411	PyErr_Clear();
			1412	if (obj && !PythonQtSlotFunction_Check(obj)) {
			1413	static const char* argumentList[] ={"" , "QDragLeaveEvent*"};
			1414	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			1415	void* args[2] = {NULL, (void*)&arg__1};
			1416	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			1417	if (result) { Py_DECREF(result); }
			1418	Py_DECREF(obj);
			1419	return;
			1420	}
			1421	}
			1422	QHexEdit::dragLeaveEvent(arg__1);
			1423	}
			1424	void PythonQtShell_QHexEdit::dragMoveEvent(QDragMoveEvent* arg__1)
			1425	{
			1426	if (_wrapper) {
			1427	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragMoveEvent");
			1428	PyErr_Clear();
			1429	if (obj && !PythonQtSlotFunction_Check(obj)) {
			1430	static const char* argumentList[] ={"" , "QDragMoveEvent*"};
			1431	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			1432	void* args[2] = {NULL, (void*)&arg__1};
			1433	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			1434	if (result) { Py_DECREF(result); }
			1435	Py_DECREF(obj);
			1436	return;
			1437	}
			1438	}
			1439	QHexEdit::dragMoveEvent(arg__1);
			1440	}
			1441	void PythonQtShell_QHexEdit::dropEvent(QDropEvent* arg__1)
			1442	{
			1443	if (_wrapper) {
			1444	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dropEvent");
			1445	PyErr_Clear();
			1446	if (obj && !PythonQtSlotFunction_Check(obj)) {
			1447	static const char* argumentList[] ={"" , "QDropEvent*"};
			1448	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			1449	void* args[2] = {NULL, (void*)&arg__1};
			1450	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			1451	if (result) { Py_DECREF(result); }
			1452	Py_DECREF(obj);
			1453	return;
			1454	}
			1455	}
			1456	QHexEdit::dropEvent(arg__1);
			1457	}
			1458	void PythonQtShell_QHexEdit::enterEvent(QEvent* arg__1)
			1459	{
			1460	if (_wrapper) {
			1461	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "enterEvent");
			1462	PyErr_Clear();
			1463	if (obj && !PythonQtSlotFunction_Check(obj)) {
			1464	static const char* argumentList[] ={"" , "QEvent*"};
			1465	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			1466	void* args[2] = {NULL, (void*)&arg__1};
			1467	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			1468	if (result) { Py_DECREF(result); }
			1469	Py_DECREF(obj);
			1470	return;
			1471	}
			1472	}
			1473	QHexEdit::enterEvent(arg__1);
			1474	}
			1475	bool PythonQtShell_QHexEdit::event(QEvent* arg__1)
			1476	{
			1477	if (_wrapper) {
			1478	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "event");
			1479	PyErr_Clear();
			1480	if (obj && !PythonQtSlotFunction_Check(obj)) {
			1481	static const char* argumentList[] ={"bool" , "QEvent*"};
			1482	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			1483	bool returnValue;
			1484	void* args[2] = {NULL, (void*)&arg__1};
			1485	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			1486	if (result) {
			1487	args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
			1488	if (args[0]!=&returnValue) {
			1489	if (args[0]==NULL) {
			1490	PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
			1491	} else {
			1492	returnValue = ((bool)args[0]);
			1493	}
			1494	}
			1495	}
			1496	if (result) { Py_DECREF(result); }
			1497	Py_DECREF(obj);
			1498	return returnValue;
			1499	}
			1500	}
			1501	return QHexEdit::event(arg__1);
			1502	}
			1503	bool PythonQtShell_QHexEdit::eventFilter(QObject* arg__1, QEvent* arg__2)
			1504	{
			1505	if (_wrapper) {
			1506	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "eventFilter");
			1507	PyErr_Clear();
			1508	if (obj && !PythonQtSlotFunction_Check(obj)) {
			1509	static const char* argumentList[] ={"bool" , "QObject" , "QEvent"};
			1510	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
			1511	bool returnValue;
			1512	void* args[3] = {NULL, (void)&arg__1, (void)&arg__2};
			1513	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			1514	if (result) {
			1515	args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
			1516	if (args[0]!=&returnValue) {
			1517	if (args[0]==NULL) {
			1518	PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
			1519	} else {
			1520	returnValue = ((bool)args[0]);
			1521	}
			1522	}
			1523	}
			1524	if (result) { Py_DECREF(result); }
			1525	Py_DECREF(obj);
			1526	return returnValue;
			1527	}
			1528	}
			1529	return QHexEdit::eventFilter(arg__1, arg__2);
			1530	}
			1531	void PythonQtShell_QHexEdit::focusInEvent(QFocusEvent* arg__1)
			1532	{
			1533	if (_wrapper) {
			1534	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusInEvent");
			1535	PyErr_Clear();
			1536	if (obj && !PythonQtSlotFunction_Check(obj)) {
			1537	static const char* argumentList[] ={"" , "QFocusEvent*"};
			1538	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			1539	void* args[2] = {NULL, (void*)&arg__1};
			1540	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			1541	if (result) { Py_DECREF(result); }
			1542	Py_DECREF(obj);
			1543	return;
			1544	}
			1545	}
			1546	QHexEdit::focusInEvent(arg__1);
			1547	}
			1548	bool PythonQtShell_QHexEdit::focusNextPrevChild(bool next)
			1549	{
			1550	if (_wrapper) {
			1551	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusNextPrevChild");
			1552	PyErr_Clear();
			1553	if (obj && !PythonQtSlotFunction_Check(obj)) {
			1554	static const char* argumentList[] ={"bool" , "bool"};
			1555	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			1556	bool returnValue;
			1557	void* args[2] = {NULL, (void*)&next};
			1558	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			1559	if (result) {
			1560	args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
			1561	if (args[0]!=&returnValue) {
			1562	if (args[0]==NULL) {
			1563	PythonQt::priv()->handleVirtualOverloadReturnError("focusNextPrevChild", methodInfo, result);
			1564	} else {
			1565	returnValue = ((bool)args[0]);
			1566	}
			1567	}
			1568	}
			1569	if (result) { Py_DECREF(result); }
			1570	Py_DECREF(obj);
			1571	return returnValue;
			1572	}
			1573	}
			1574	return QHexEdit::focusNextPrevChild(next);
			1575	}
			1576	void PythonQtShell_QHexEdit::focusOutEvent(QFocusEvent* arg__1)
			1577	{
			1578	if (_wrapper) {
			1579	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusOutEvent");
			1580	PyErr_Clear();
			1581	if (obj && !PythonQtSlotFunction_Check(obj)) {
			1582	static const char* argumentList[] ={"" , "QFocusEvent*"};
			1583	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			1584	void* args[2] = {NULL, (void*)&arg__1};
			1585	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			1586	if (result) { Py_DECREF(result); }
			1587	Py_DECREF(obj);
			1588	return;
			1589	}
			1590	}
			1591	QHexEdit::focusOutEvent(arg__1);
			1592	}
			1593	bool PythonQtShell_QHexEdit::hasHeightForWidth() const
			1594	{
			1595	if (_wrapper) {
			1596	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hasHeightForWidth");
			1597	PyErr_Clear();
			1598	if (obj && !PythonQtSlotFunction_Check(obj)) {
			1599	static const char* argumentList[] ={"bool"};
			1600	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
			1601	bool returnValue;
			1602	void* args[1] = {NULL};
			1603	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			1604	if (result) {
			1605	args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
			1606	if (args[0]!=&returnValue) {
			1607	if (args[0]==NULL) {
			1608	PythonQt::priv()->handleVirtualOverloadReturnError("hasHeightForWidth", methodInfo, result);
			1609	} else {
			1610	returnValue = ((bool)args[0]);
			1611	}
			1612	}
			1613	}
			1614	if (result) { Py_DECREF(result); }
			1615	Py_DECREF(obj);
			1616	return returnValue;
			1617	}
			1618	}
			1619	return QHexEdit::hasHeightForWidth();
			1620	}
			1621	int PythonQtShell_QHexEdit::heightForWidth(int arg__1) const
			1622	{
			1623	if (_wrapper) {
			1624	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "heightForWidth");
			1625	PyErr_Clear();
			1626	if (obj && !PythonQtSlotFunction_Check(obj)) {
			1627	static const char* argumentList[] ={"int" , "int"};
			1628	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			1629	int returnValue;
			1630	void* args[2] = {NULL, (void*)&arg__1};
			1631	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			1632	if (result) {
			1633	args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
			1634	if (args[0]!=&returnValue) {
			1635	if (args[0]==NULL) {
			1636	PythonQt::priv()->handleVirtualOverloadReturnError("heightForWidth", methodInfo, result);
			1637	} else {
			1638	returnValue = ((int)args[0]);
			1639	}
			1640	}
			1641	}
			1642	if (result) { Py_DECREF(result); }
			1643	Py_DECREF(obj);
			1644	return returnValue;
			1645	}
			1646	}
			1647	return QHexEdit::heightForWidth(arg__1);
			1648	}
			1649	void PythonQtShell_QHexEdit::hideEvent(QHideEvent* arg__1)
			1650	{
			1651	if (_wrapper) {
			1652	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hideEvent");
			1653	PyErr_Clear();
			1654	if (obj && !PythonQtSlotFunction_Check(obj)) {
			1655	static const char* argumentList[] ={"" , "QHideEvent*"};
			1656	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			1657	void* args[2] = {NULL, (void*)&arg__1};
			1658	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			1659	if (result) { Py_DECREF(result); }
			1660	Py_DECREF(obj);
			1661	return;
			1662	}
			1663	}
			1664	QHexEdit::hideEvent(arg__1);
			1665	}
			1666	void PythonQtShell_QHexEdit::initPainter(QPainter* painter) const
			1667	{
			1668	if (_wrapper) {
			1669	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "initPainter");
			1670	PyErr_Clear();
			1671	if (obj && !PythonQtSlotFunction_Check(obj)) {
			1672	static const char* argumentList[] ={"" , "QPainter*"};
			1673	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			1674	void* args[2] = {NULL, (void*)&painter};
			1675	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			1676	if (result) { Py_DECREF(result); }
			1677	Py_DECREF(obj);
			1678	return;
			1679	}
			1680	}
			1681	QHexEdit::initPainter(painter);
			1682	}
			1683	void PythonQtShell_QHexEdit::inputMethodEvent(QInputMethodEvent* arg__1)
			1684	{
			1685	if (_wrapper) {
			1686	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodEvent");
			1687	PyErr_Clear();
			1688	if (obj && !PythonQtSlotFunction_Check(obj)) {
			1689	static const char* argumentList[] ={"" , "QInputMethodEvent*"};
			1690	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			1691	void* args[2] = {NULL, (void*)&arg__1};
			1692	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			1693	if (result) { Py_DECREF(result); }
			1694	Py_DECREF(obj);
			1695	return;
			1696	}
			1697	}
			1698	QHexEdit::inputMethodEvent(arg__1);
			1699	}
			1700	QVariant PythonQtShell_QHexEdit::inputMethodQuery(Qt::InputMethodQuery arg__1) const
			1701	{
			1702	if (_wrapper) {
			1703	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodQuery");
			1704	PyErr_Clear();
			1705	if (obj && !PythonQtSlotFunction_Check(obj)) {
			1706	static const char* argumentList[] ={"QVariant" , "Qt::InputMethodQuery"};
			1707	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			1708	QVariant returnValue;
			1709	void* args[2] = {NULL, (void*)&arg__1};
			1710	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			1711	if (result) {
			1712	args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
			1713	if (args[0]!=&returnValue) {
			1714	if (args[0]==NULL) {
			1715	PythonQt::priv()->handleVirtualOverloadReturnError("inputMethodQuery", methodInfo, result);
			1716	} else {
			1717	returnValue = ((QVariant)args[0]);
			1718	}
			1719	}
			1720	}
			1721	if (result) { Py_DECREF(result); }
			1722	Py_DECREF(obj);
			1723	return returnValue;
			1724	}
			1725	}
			1726	return QHexEdit::inputMethodQuery(arg__1);
			1727	}
			1728	void PythonQtShell_QHexEdit::keyPressEvent(QKeyEvent* arg__1)
			1729	{
			1730	if (_wrapper) {
			1731	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyPressEvent");
			1732	PyErr_Clear();
			1733	if (obj && !PythonQtSlotFunction_Check(obj)) {
			1734	static const char* argumentList[] ={"" , "QKeyEvent*"};
			1735	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			1736	void* args[2] = {NULL, (void*)&arg__1};
			1737	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			1738	if (result) { Py_DECREF(result); }
			1739	Py_DECREF(obj);
			1740	return;
			1741	}
			1742	}
			1743	QHexEdit::keyPressEvent(arg__1);
			1744	}
			1745	void PythonQtShell_QHexEdit::keyReleaseEvent(QKeyEvent* arg__1)
			1746	{
			1747	if (_wrapper) {
			1748	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyReleaseEvent");
			1749	PyErr_Clear();
			1750	if (obj && !PythonQtSlotFunction_Check(obj)) {
			1751	static const char* argumentList[] ={"" , "QKeyEvent*"};
			1752	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			1753	void* args[2] = {NULL, (void*)&arg__1};
			1754	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			1755	if (result) { Py_DECREF(result); }
			1756	Py_DECREF(obj);
			1757	return;
			1758	}
			1759	}
			1760	QHexEdit::keyReleaseEvent(arg__1);
			1761	}
			1762	void PythonQtShell_QHexEdit::leaveEvent(QEvent* arg__1)
			1763	{
			1764	if (_wrapper) {
			1765	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "leaveEvent");
			1766	PyErr_Clear();
			1767	if (obj && !PythonQtSlotFunction_Check(obj)) {
			1768	static const char* argumentList[] ={"" , "QEvent*"};
			1769	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			1770	void* args[2] = {NULL, (void*)&arg__1};
			1771	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			1772	if (result) { Py_DECREF(result); }
			1773	Py_DECREF(obj);
			1774	return;
			1775	}
			1776	}
			1777	QHexEdit::leaveEvent(arg__1);
			1778	}
			1779	int PythonQtShell_QHexEdit::metric(QPaintDevice::PaintDeviceMetric arg__1) const
			1780	{
			1781	if (_wrapper) {
			1782	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "metric");
			1783	PyErr_Clear();
			1784	if (obj && !PythonQtSlotFunction_Check(obj)) {
			1785	static const char* argumentList[] ={"int" , "QPaintDevice::PaintDeviceMetric"};
			1786	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			1787	int returnValue;
			1788	void* args[2] = {NULL, (void*)&arg__1};
			1789	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			1790	if (result) {
			1791	args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
			1792	if (args[0]!=&returnValue) {
			1793	if (args[0]==NULL) {
			1794	PythonQt::priv()->handleVirtualOverloadReturnError("metric", methodInfo, result);
			1795	} else {
			1796	returnValue = ((int)args[0]);
			1797	}
			1798	}
			1799	}
			1800	if (result) { Py_DECREF(result); }
			1801	Py_DECREF(obj);
			1802	return returnValue;
			1803	}
			1804	}
			1805	return QHexEdit::metric(arg__1);
			1806	}
			1807	void PythonQtShell_QHexEdit::mouseDoubleClickEvent(QMouseEvent* arg__1)
			1808	{
			1809	if (_wrapper) {
			1810	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseDoubleClickEvent");
			1811	PyErr_Clear();
			1812	if (obj && !PythonQtSlotFunction_Check(obj)) {
			1813	static const char* argumentList[] ={"" , "QMouseEvent*"};
			1814	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			1815	void* args[2] = {NULL, (void*)&arg__1};
			1816	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			1817	if (result) { Py_DECREF(result); }
			1818	Py_DECREF(obj);
			1819	return;
			1820	}
			1821	}
			1822	QHexEdit::mouseDoubleClickEvent(arg__1);
			1823	}
			1824	void PythonQtShell_QHexEdit::mouseMoveEvent(QMouseEvent* arg__1)
			1825	{
			1826	if (_wrapper) {
			1827	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseMoveEvent");
			1828	PyErr_Clear();
			1829	if (obj && !PythonQtSlotFunction_Check(obj)) {
			1830	static const char* argumentList[] ={"" , "QMouseEvent*"};
			1831	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			1832	void* args[2] = {NULL, (void*)&arg__1};
			1833	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			1834	if (result) { Py_DECREF(result); }
			1835	Py_DECREF(obj);
			1836	return;
			1837	}
			1838	}
			1839	QHexEdit::mouseMoveEvent(arg__1);
			1840	}
			1841	void PythonQtShell_QHexEdit::mousePressEvent(QMouseEvent* arg__1)
			1842	{
			1843	if (_wrapper) {
			1844	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mousePressEvent");
			1845	PyErr_Clear();
			1846	if (obj && !PythonQtSlotFunction_Check(obj)) {
			1847	static const char* argumentList[] ={"" , "QMouseEvent*"};
			1848	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			1849	void* args[2] = {NULL, (void*)&arg__1};
			1850	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			1851	if (result) { Py_DECREF(result); }
			1852	Py_DECREF(obj);
			1853	return;
			1854	}
			1855	}
			1856	QHexEdit::mousePressEvent(arg__1);
			1857	}
			1858	void PythonQtShell_QHexEdit::mouseReleaseEvent(QMouseEvent* arg__1)
			1859	{
			1860	if (_wrapper) {
			1861	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseReleaseEvent");
			1862	PyErr_Clear();
			1863	if (obj && !PythonQtSlotFunction_Check(obj)) {
			1864	static const char* argumentList[] ={"" , "QMouseEvent*"};
			1865	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			1866	void* args[2] = {NULL, (void*)&arg__1};
			1867	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			1868	if (result) { Py_DECREF(result); }
			1869	Py_DECREF(obj);
			1870	return;
			1871	}
			1872	}
			1873	QHexEdit::mouseReleaseEvent(arg__1);
			1874	}
			1875	void PythonQtShell_QHexEdit::moveEvent(QMoveEvent* arg__1)
			1876	{
			1877	if (_wrapper) {
			1878	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "moveEvent");
			1879	PyErr_Clear();
			1880	if (obj && !PythonQtSlotFunction_Check(obj)) {
			1881	static const char* argumentList[] ={"" , "QMoveEvent*"};
			1882	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			1883	void* args[2] = {NULL, (void*)&arg__1};
			1884	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			1885	if (result) { Py_DECREF(result); }
			1886	Py_DECREF(obj);
			1887	return;
			1888	}
			1889	}
			1890	QHexEdit::moveEvent(arg__1);
			1891	}
			1892	bool PythonQtShell_QHexEdit::nativeEvent(const QByteArray& eventType, void* message, long* result)
			1893	{
			1894	if (_wrapper) {
			1895	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "nativeEvent");
			1896	PyErr_Clear();
			1897	if (obj && !PythonQtSlotFunction_Check(obj)) {
			1898	static const char* argumentList[] ={"bool" , "const QByteArray&" , "void" , "long"};
			1899	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
			1900	bool returnValue;
			1901	void* args[4] = {NULL, (void)&eventType, (void)&message, (void*)&result};
			1902	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			1903	if (result) {
			1904	args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
			1905	if (args[0]!=&returnValue) {
			1906	if (args[0]==NULL) {
			1907	PythonQt::priv()->handleVirtualOverloadReturnError("nativeEvent", methodInfo, result);
			1908	} else {
			1909	returnValue = ((bool)args[0]);
			1910	}
			1911	}
			1912	}
			1913	if (result) { Py_DECREF(result); }
			1914	Py_DECREF(obj);
			1915	return returnValue;
			1916	}
			1917	}
			1918	return QHexEdit::nativeEvent(eventType, message, result);
			1919	}
			1920	QPaintEngine* PythonQtShell_QHexEdit::paintEngine() const
			1921	{
			1922	if (_wrapper) {
			1923	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEngine");
			1924	PyErr_Clear();
			1925	if (obj && !PythonQtSlotFunction_Check(obj)) {
			1926	static const char* argumentList[] ={"QPaintEngine*"};
			1927	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
			1928	QPaintEngine* returnValue;
			1929	void* args[1] = {NULL};
			1930	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			1931	if (result) {
			1932	args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
			1933	if (args[0]!=&returnValue) {
			1934	if (args[0]==NULL) {
			1935	PythonQt::priv()->handleVirtualOverloadReturnError("paintEngine", methodInfo, result);
			1936	} else {
			1937	returnValue = ((QPaintEngine*)args[0]);
			1938	}
			1939	}
			1940	}
			1941	if (result) { Py_DECREF(result); }
			1942	Py_DECREF(obj);
			1943	return returnValue;
			1944	}
			1945	}
			1946	return QHexEdit::paintEngine();
			1947	}
			1948	void PythonQtShell_QHexEdit::paintEvent(QPaintEvent* arg__1)
			1949	{
			1950	if (_wrapper) {
			1951	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEvent");
			1952	PyErr_Clear();
			1953	if (obj && !PythonQtSlotFunction_Check(obj)) {
			1954	static const char* argumentList[] ={"" , "QPaintEvent*"};
			1955	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			1956	void* args[2] = {NULL, (void*)&arg__1};
			1957	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			1958	if (result) { Py_DECREF(result); }
			1959	Py_DECREF(obj);
			1960	return;
			1961	}
			1962	}
			1963	QHexEdit::paintEvent(arg__1);
			1964	}
			1965	QPaintDevice* PythonQtShell_QHexEdit::redirected(QPoint* offset) const
			1966	{
			1967	if (_wrapper) {
			1968	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "redirected");
			1969	PyErr_Clear();
			1970	if (obj && !PythonQtSlotFunction_Check(obj)) {
			1971	static const char* argumentList[] ={"QPaintDevice" , "QPoint"};
			1972	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			1973	QPaintDevice* returnValue;
			1974	void* args[2] = {NULL, (void*)&offset};
			1975	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			1976	if (result) {
			1977	args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
			1978	if (args[0]!=&returnValue) {
			1979	if (args[0]==NULL) {
			1980	PythonQt::priv()->handleVirtualOverloadReturnError("redirected", methodInfo, result);
			1981	} else {
			1982	returnValue = ((QPaintDevice*)args[0]);
			1983	}
			1984	}
			1985	}
			1986	if (result) { Py_DECREF(result); }
			1987	Py_DECREF(obj);
			1988	return returnValue;
			1989	}
			1990	}
			1991	return QHexEdit::redirected(offset);
			1992	}
			1993	void PythonQtShell_QHexEdit::resizeEvent(QResizeEvent* arg__1)
			1994	{
			1995	if (_wrapper) {
			1996	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "resizeEvent");
			1997	PyErr_Clear();
			1998	if (obj && !PythonQtSlotFunction_Check(obj)) {
			1999	static const char* argumentList[] ={"" , "QResizeEvent*"};
			2000	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			2001	void* args[2] = {NULL, (void*)&arg__1};
			2002	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			2003	if (result) { Py_DECREF(result); }
			2004	Py_DECREF(obj);
			2005	return;
			2006	}
			2007	}
			2008	QHexEdit::resizeEvent(arg__1);
			2009	}
			2010	void PythonQtShell_QHexEdit::scrollContentsBy(int dx, int dy)
			2011	{
			2012	if (_wrapper) {
			2013	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "scrollContentsBy");
			2014	PyErr_Clear();
			2015	if (obj && !PythonQtSlotFunction_Check(obj)) {
			2016	static const char* argumentList[] ={"" , "int" , "int"};
			2017	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
			2018	void* args[3] = {NULL, (void)&dx, (void)&dy};
			2019	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			2020	if (result) { Py_DECREF(result); }
			2021	Py_DECREF(obj);
			2022	return;
			2023	}
			2024	}
			2025	QHexEdit::scrollContentsBy(dx, dy);
			2026	}
			2027	void PythonQtShell_QHexEdit::setupViewport(QWidget* viewport)
			2028	{
			2029	if (_wrapper) {
			2030	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "setupViewport");
			2031	PyErr_Clear();
			2032	if (obj && !PythonQtSlotFunction_Check(obj)) {
			2033	static const char* argumentList[] ={"" , "QWidget*"};
			2034	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			2035	void* args[2] = {NULL, (void*)&viewport};
			2036	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			2037	if (result) { Py_DECREF(result); }
			2038	Py_DECREF(obj);
			2039	return;
			2040	}
			2041	}
			2042	QHexEdit::setupViewport(viewport);
			2043	}
			2044	QPainter* PythonQtShell_QHexEdit::sharedPainter() const
			2045	{
			2046	if (_wrapper) {
			2047	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "sharedPainter");
			2048	PyErr_Clear();
			2049	if (obj && !PythonQtSlotFunction_Check(obj)) {
			2050	static const char* argumentList[] ={"QPainter*"};
			2051	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
			2052	QPainter* returnValue;
			2053	void* args[1] = {NULL};
			2054	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			2055	if (result) {
			2056	args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
			2057	if (args[0]!=&returnValue) {
			2058	if (args[0]==NULL) {
			2059	PythonQt::priv()->handleVirtualOverloadReturnError("sharedPainter", methodInfo, result);
			2060	} else {
			2061	returnValue = ((QPainter*)args[0]);
			2062	}
			2063	}
			2064	}
			2065	if (result) { Py_DECREF(result); }
			2066	Py_DECREF(obj);
			2067	return returnValue;
			2068	}
			2069	}
			2070	return QHexEdit::sharedPainter();
			2071	}
			2072	void PythonQtShell_QHexEdit::showEvent(QShowEvent* arg__1)
			2073	{
			2074	if (_wrapper) {
			2075	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "showEvent");
			2076	PyErr_Clear();
			2077	if (obj && !PythonQtSlotFunction_Check(obj)) {
			2078	static const char* argumentList[] ={"" , "QShowEvent*"};
			2079	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			2080	void* args[2] = {NULL, (void*)&arg__1};
			2081	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			2082	if (result) { Py_DECREF(result); }
			2083	Py_DECREF(obj);
			2084	return;
			2085	}
			2086	}
			2087	QHexEdit::showEvent(arg__1);
			2088	}
			2089	void PythonQtShell_QHexEdit::tabletEvent(QTabletEvent* arg__1)
			2090	{
			2091	if (_wrapper) {
			2092	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "tabletEvent");
			2093	PyErr_Clear();
			2094	if (obj && !PythonQtSlotFunction_Check(obj)) {
			2095	static const char* argumentList[] ={"" , "QTabletEvent*"};
			2096	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			2097	void* args[2] = {NULL, (void*)&arg__1};
			2098	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			2099	if (result) { Py_DECREF(result); }
			2100	Py_DECREF(obj);
			2101	return;
			2102	}
			2103	}
			2104	QHexEdit::tabletEvent(arg__1);
			2105	}
			2106	void PythonQtShell_QHexEdit::timerEvent(QTimerEvent* arg__1)
			2107	{
			2108	if (_wrapper) {
			2109	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "timerEvent");
			2110	PyErr_Clear();
			2111	if (obj && !PythonQtSlotFunction_Check(obj)) {
			2112	static const char* argumentList[] ={"" , "QTimerEvent*"};
			2113	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			2114	void* args[2] = {NULL, (void*)&arg__1};
			2115	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			2116	if (result) { Py_DECREF(result); }
			2117	Py_DECREF(obj);
			2118	return;
			2119	}
			2120	}
			2121	QHexEdit::timerEvent(arg__1);
			2122	}
			2123	bool PythonQtShell_QHexEdit::viewportEvent(QEvent* arg__1)
			2124	{
			2125	if (_wrapper) {
			2126	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "viewportEvent");
			2127	PyErr_Clear();
			2128	if (obj && !PythonQtSlotFunction_Check(obj)) {
			2129	static const char* argumentList[] ={"bool" , "QEvent*"};
			2130	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			2131	bool returnValue;
			2132	void* args[2] = {NULL, (void*)&arg__1};
			2133	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			2134	if (result) {
			2135	args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
			2136	if (args[0]!=&returnValue) {
			2137	if (args[0]==NULL) {
			2138	PythonQt::priv()->handleVirtualOverloadReturnError("viewportEvent", methodInfo, result);
			2139	} else {
			2140	returnValue = ((bool)args[0]);
			2141	}
			2142	}
			2143	}
			2144	if (result) { Py_DECREF(result); }
			2145	Py_DECREF(obj);
			2146	return returnValue;
			2147	}
			2148	}
			2149	return QHexEdit::viewportEvent(arg__1);
			2150	}
			2151	QSize PythonQtShell_QHexEdit::viewportSizeHint() const
			2152	{
			2153	if (_wrapper) {
			2154	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "viewportSizeHint");
			2155	PyErr_Clear();
			2156	if (obj && !PythonQtSlotFunction_Check(obj)) {
			2157	static const char* argumentList[] ={"QSize"};
			2158	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
			2159	QSize returnValue;
			2160	void* args[1] = {NULL};
			2161	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			2162	if (result) {
			2163	args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
			2164	if (args[0]!=&returnValue) {
			2165	if (args[0]==NULL) {
			2166	PythonQt::priv()->handleVirtualOverloadReturnError("viewportSizeHint", methodInfo, result);
			2167	} else {
			2168	returnValue = ((QSize)args[0]);
			2169	}
			2170	}
			2171	}
			2172	if (result) { Py_DECREF(result); }
			2173	Py_DECREF(obj);
			2174	return returnValue;
			2175	}
			2176	}
			2177	return QHexEdit::viewportSizeHint();
			2178	}
			2179	void PythonQtShell_QHexEdit::wheelEvent(QWheelEvent* arg__1)
			2180	{
			2181	if (_wrapper) {
			2182	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "wheelEvent");
			2183	PyErr_Clear();
			2184	if (obj && !PythonQtSlotFunction_Check(obj)) {
			2185	static const char* argumentList[] ={"" , "QWheelEvent*"};
			2186	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			2187	void* args[2] = {NULL, (void*)&arg__1};
			2188	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			2189	if (result) { Py_DECREF(result); }
			2190	Py_DECREF(obj);
			2191	return;
			2192	}
			2193	}
			2194	QHexEdit::wheelEvent(arg__1);
			2195	}
	315	QHexEdit* PythonQtWrapper_QHexEdit::new_QHexEdit(QWidget* parent)	2196	QHexEdit* PythonQtWrapper_QHexEdit::new_QHexEdit(QWidget* parent)
	316	{	2197	{
	317	return new PythonQtShell_QHexEdit(parent); }	2198	return new PythonQtShell_QHexEdit(parent); }
	318		2199
	319	QColor PythonQtWrapper_QHexEdit::addressAreaColor(QHexEdit* theWrappedObject)	2200	QColor PythonQtWrapper_QHexEdit::addressAreaColor(QHexEdit* theWrappedObject)
	320	{	2201	{
	321	return ( theWrappedObject->addressAreaColor());	2202	return ( theWrappedObject->addressAreaColor());
	322	}	2203	}
	323		2204
	324	int PythonQtWrapper_QHexEdit::addressOffset(QHexEdit* theWrappedObject)	2205	int PythonQtWrapper_QHexEdit::addressOffset(QHexEdit* theWrappedObject)
	325	{	2206	{
	326	return ( theWrappedObject->addressOffset());	2207	return ( theWrappedObject->addressOffset());
	327	}	2208	}
	328		2209
	329	int PythonQtWrapper_QHexEdit::cursorPosition(QHexEdit* theWrappedObject)	2210	int PythonQtWrapper_QHexEdit::cursorPosition(QHexEdit* theWrappedObject)
	330	{	2211	{
	331	return ( theWrappedObject->cursorPosition());	2212	return ( theWrappedObject->cursorPosition());
	332	}	2213	}
	333		2214
	334	QByteArray PythonQtWrapper_QHexEdit::data(QHexEdit* theWrappedObject)	2215	QByteArray PythonQtWrapper_QHexEdit::data(QHexEdit* theWrappedObject)
	335	{	2216	{
	336	return ( theWrappedObject->data());	2217	return ( theWrappedObject->data());
	337	}	2218	}
	338		2219
	339	const QFont* PythonQtWrapper_QHexEdit::font(QHexEdit* theWrappedObject) const	2220	const QFont* PythonQtWrapper_QHexEdit::font(QHexEdit* theWrappedObject) const
	340	{	2221	{
	341	return &( theWrappedObject->font());	2222	return &( theWrappedObject->font());
	342	}	2223	}
	343		2224
	344	QColor PythonQtWrapper_QHexEdit::highlightingColor(QHexEdit* theWrappedObject)	2225	QColor PythonQtWrapper_QHexEdit::highlightingColor(QHexEdit* theWrappedObject)
	345	{	2226	{
	346	return ( theWrappedObject->highlightingColor());	2227	return ( theWrappedObject->highlightingColor());
	347	}	2228	}
	348		2229
	349	int PythonQtWrapper_QHexEdit::indexOf(QHexEdit* theWrappedObject, const QByteArray& ba, int from) const	2230	int PythonQtWrapper_QHexEdit::indexOf(QHexEdit* theWrappedObject, const QByteArray& ba, int from) const
	350	{	2231	{
	351	return ( theWrappedObject->indexOf(ba, from));	2232	return ( theWrappedObject->indexOf(ba, from));
	352	}	2233	}
	353		2234
	354	void PythonQtWrapper_QHexEdit::insert(QHexEdit* theWrappedObject, int i, char ch)	2235	void PythonQtWrapper_QHexEdit::insert(QHexEdit* theWrappedObject, int i, char ch)
	355	{	2236	{
	356	( theWrappedObject->insert(i, ch));	2237	( theWrappedObject->insert(i, ch));
	357	}	2238	}
	358		2239
	359	void PythonQtWrapper_QHexEdit::insert(QHexEdit* theWrappedObject, int i, const QByteArray& ba)	2240	void PythonQtWrapper_QHexEdit::insert(QHexEdit* theWrappedObject, int i, const QByteArray& ba)
	360	{	2241	{
	361	( theWrappedObject->insert(i, ba));	2242	( theWrappedObject->insert(i, ba));
	362	}	2243	}
	363		2244
	364	bool PythonQtWrapper_QHexEdit::isReadOnly(QHexEdit* theWrappedObject)	2245	bool PythonQtWrapper_QHexEdit::isReadOnly(QHexEdit* theWrappedObject)
	365	{	2246	{
	366	return ( theWrappedObject->isReadOnly());	2247	return ( theWrappedObject->isReadOnly());
	367	}	2248	}
	368		2249
	369	int PythonQtWrapper_QHexEdit::lastIndexOf(QHexEdit* theWrappedObject, const QByteArray& ba, int from) const	2250	int PythonQtWrapper_QHexEdit::lastIndexOf(QHexEdit* theWrappedObject, const QByteArray& ba, int from) const
	370	{	2251	{
	371	return ( theWrappedObject->lastIndexOf(ba, from));	2252	return ( theWrappedObject->lastIndexOf(ba, from));
	372	}	2253	}
	373		2254
	374	bool PythonQtWrapper_QHexEdit::overwriteMode(QHexEdit* theWrappedObject)	2255	bool PythonQtWrapper_QHexEdit::overwriteMode(QHexEdit* theWrappedObject)
	375	{	2256	{
	376	return ( theWrappedObject->overwriteMode());	2257	return ( theWrappedObject->overwriteMode());
	377	}	2258	}
	378		2259
	379	void PythonQtWrapper_QHexEdit::remove(QHexEdit* theWrappedObject, int pos, int len)	2260	void PythonQtWrapper_QHexEdit::remove(QHexEdit* theWrappedObject, int pos, int len)
	380	{	2261	{
	381	( theWrappedObject->remove(pos, len));	2262	( theWrappedObject->remove(pos, len));
	382	}	2263	}
	383		2264
	384	void PythonQtWrapper_QHexEdit::replace(QHexEdit* theWrappedObject, int pos, int len, const QByteArray& after)	2265	void PythonQtWrapper_QHexEdit::replace(QHexEdit* theWrappedObject, int pos, int len, const QByteArray& after)
	385	{	2266	{
	386	( theWrappedObject->replace(pos, len, after));	2267	( theWrappedObject->replace(pos, len, after));
	387	}	2268	}
	388		2269
	389	QColor PythonQtWrapper_QHexEdit::selectionColor(QHexEdit* theWrappedObject)	2270	QColor PythonQtWrapper_QHexEdit::selectionColor(QHexEdit* theWrappedObject)
	390	{	2271	{
	391	return ( theWrappedObject->selectionColor());	2272	return ( theWrappedObject->selectionColor());
	392	}	2273	}
	393		2274
	394	QString PythonQtWrapper_QHexEdit::selectionToReadableString(QHexEdit* theWrappedObject)	2275	QString PythonQtWrapper_QHexEdit::selectionToReadableString(QHexEdit* theWrappedObject)
	395	{	2276	{
	396	return ( theWrappedObject->selectionToReadableString());	2277	return ( theWrappedObject->selectionToReadableString());
	397	}	2278	}
	398		2279
	399	void PythonQtWrapper_QHexEdit::setAddressAreaColor(QHexEdit* theWrappedObject, const QColor& color)	2280	void PythonQtWrapper_QHexEdit::setAddressAreaColor(QHexEdit* theWrappedObject, const QColor& color)
	400	{	2281	{
	401	( theWrappedObject->setAddressAreaColor(color));	2282	( theWrappedObject->setAddressAreaColor(color));
	402	}	2283	}
	403		2284
	404	void PythonQtWrapper_QHexEdit::setAddressOffset(QHexEdit* theWrappedObject, int offset)	2285	void PythonQtWrapper_QHexEdit::setAddressOffset(QHexEdit* theWrappedObject, int offset)
	405	{	2286	{
	406	( theWrappedObject->setAddressOffset(offset));	2287	( theWrappedObject->setAddressOffset(offset));
	407	}	2288	}
	408		2289
	409	void PythonQtWrapper_QHexEdit::setCursorPosition(QHexEdit* theWrappedObject, int cusorPos)	2290	void PythonQtWrapper_QHexEdit::setCursorPosition(QHexEdit* theWrappedObject, int cusorPos)
	410	{	2291	{
	411	( theWrappedObject->setCursorPosition(cusorPos));	2292	( theWrappedObject->setCursorPosition(cusorPos));
	412	}	2293	}
	413		2294
	414	void PythonQtWrapper_QHexEdit::setData(QHexEdit* theWrappedObject, const QByteArray& data)	2295	void PythonQtWrapper_QHexEdit::setData(QHexEdit* theWrappedObject, const QByteArray& data)
	415	{	2296	{
	416	( theWrappedObject->setData(data));	2297	( theWrappedObject->setData(data));
	417	}	2298	}
	418		2299
	419	void PythonQtWrapper_QHexEdit::setFont(QHexEdit* theWrappedObject, const QFont& arg__1)	2300	void PythonQtWrapper_QHexEdit::setFont(QHexEdit* theWrappedObject, const QFont& arg__1)
	420	{	2301	{
	421	( theWrappedObject->setFont(arg__1));	2302	( theWrappedObject->setFont(arg__1));
	422	}	2303	}
	423		2304
	424	void PythonQtWrapper_QHexEdit::setHighlightingColor(QHexEdit* theWrappedObject, const QColor& color)	2305	void PythonQtWrapper_QHexEdit::setHighlightingColor(QHexEdit* theWrappedObject, const QColor& color)
	425	{	2306	{
	426	( theWrappedObject->setHighlightingColor(color));	2307	( theWrappedObject->setHighlightingColor(color));
	427	}	2308	}
	428		2309
	429	void PythonQtWrapper_QHexEdit::setOverwriteMode(QHexEdit* theWrappedObject, bool arg__1)	2310	void PythonQtWrapper_QHexEdit::setOverwriteMode(QHexEdit* theWrappedObject, bool arg__1)
	430	{	2311	{
	431	( theWrappedObject->setOverwriteMode(arg__1));	2312	( theWrappedObject->setOverwriteMode(arg__1));
	432	}	2313	}
	433		2314
	434	void PythonQtWrapper_QHexEdit::setReadOnly(QHexEdit* theWrappedObject, bool arg__1)	2315	void PythonQtWrapper_QHexEdit::setReadOnly(QHexEdit* theWrappedObject, bool arg__1)
	435	{	2316	{
	436	( theWrappedObject->setReadOnly(arg__1));	2317	( theWrappedObject->setReadOnly(arg__1));
	437	}	2318	}
	438		2319
	439	void PythonQtWrapper_QHexEdit::setSelectionColor(QHexEdit* theWrappedObject, const QColor& color)	2320	void PythonQtWrapper_QHexEdit::setSelectionColor(QHexEdit* theWrappedObject, const QColor& color)
	440	{	2321	{
	441	( theWrappedObject->setSelectionColor(color));	2322	( theWrappedObject->setSelectionColor(color));
	442	}	2323	}
	443		2324
	444	QString PythonQtWrapper_QHexEdit::toReadableString(QHexEdit* theWrappedObject)	2325	QString PythonQtWrapper_QHexEdit::toReadableString(QHexEdit* theWrappedObject)
	445	{	2326	{
	446	return ( theWrappedObject->toReadableString());	2327	return ( theWrappedObject->toReadableString());
	447	}	2328	}
	448		2329
	449		2330
	450		2331
			2332	PythonQtShell_QHexSpinBox::~PythonQtShell_QHexSpinBox() {
			2333	PythonQtPrivate* priv = PythonQt::priv();
			2334	if (priv) { priv->shellClassDeleted(this); }
			2335	}
			2336	void PythonQtShell_QHexSpinBox::actionEvent(QActionEvent* arg__1)
			2337	{
			2338	if (_wrapper) {
			2339	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "actionEvent");
			2340	PyErr_Clear();
			2341	if (obj && !PythonQtSlotFunction_Check(obj)) {
			2342	static const char* argumentList[] ={"" , "QActionEvent*"};
			2343	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			2344	void* args[2] = {NULL, (void*)&arg__1};
			2345	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			2346	if (result) { Py_DECREF(result); }
			2347	Py_DECREF(obj);
			2348	return;
			2349	}
			2350	}
			2351	QHexSpinBox::actionEvent(arg__1);
			2352	}
			2353	void PythonQtShell_QHexSpinBox::changeEvent(QEvent* event)
			2354	{
			2355	if (_wrapper) {
			2356	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "changeEvent");
			2357	PyErr_Clear();
			2358	if (obj && !PythonQtSlotFunction_Check(obj)) {
			2359	static const char* argumentList[] ={"" , "QEvent*"};
			2360	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			2361	void* args[2] = {NULL, (void*)&event};
			2362	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			2363	if (result) { Py_DECREF(result); }
			2364	Py_DECREF(obj);
			2365	return;
			2366	}
			2367	}
			2368	QHexSpinBox::changeEvent(event);
			2369	}
			2370	void PythonQtShell_QHexSpinBox::childEvent(QChildEvent* arg__1)
			2371	{
			2372	if (_wrapper) {
			2373	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "childEvent");
			2374	PyErr_Clear();
			2375	if (obj && !PythonQtSlotFunction_Check(obj)) {
			2376	static const char* argumentList[] ={"" , "QChildEvent*"};
			2377	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			2378	void* args[2] = {NULL, (void*)&arg__1};
			2379	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			2380	if (result) { Py_DECREF(result); }
			2381	Py_DECREF(obj);
			2382	return;
			2383	}
			2384	}
			2385	QHexSpinBox::childEvent(arg__1);
			2386	}
			2387	void PythonQtShell_QHexSpinBox::clear()
			2388	{
			2389	if (_wrapper) {
			2390	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "clear");
			2391	PyErr_Clear();
			2392	if (obj && !PythonQtSlotFunction_Check(obj)) {
			2393	static const char* argumentList[] ={""};
			2394	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
			2395	void* args[1] = {NULL};
			2396	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			2397	if (result) { Py_DECREF(result); }
			2398	Py_DECREF(obj);
			2399	return;
			2400	}
			2401	}
			2402	QHexSpinBox::clear();
			2403	}
			2404	void PythonQtShell_QHexSpinBox::closeEvent(QCloseEvent* event)
			2405	{
			2406	if (_wrapper) {
			2407	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "closeEvent");
			2408	PyErr_Clear();
			2409	if (obj && !PythonQtSlotFunction_Check(obj)) {
			2410	static const char* argumentList[] ={"" , "QCloseEvent*"};
			2411	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			2412	void* args[2] = {NULL, (void*)&event};
			2413	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			2414	if (result) { Py_DECREF(result); }
			2415	Py_DECREF(obj);
			2416	return;
			2417	}
			2418	}
			2419	QHexSpinBox::closeEvent(event);
			2420	}
			2421	void PythonQtShell_QHexSpinBox::contextMenuEvent(QContextMenuEvent* event)
			2422	{
			2423	if (_wrapper) {
			2424	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "contextMenuEvent");
			2425	PyErr_Clear();
			2426	if (obj && !PythonQtSlotFunction_Check(obj)) {
			2427	static const char* argumentList[] ={"" , "QContextMenuEvent*"};
			2428	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			2429	void* args[2] = {NULL, (void*)&event};
			2430	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			2431	if (result) { Py_DECREF(result); }
			2432	Py_DECREF(obj);
			2433	return;
			2434	}
			2435	}
			2436	QHexSpinBox::contextMenuEvent(event);
			2437	}
			2438	void PythonQtShell_QHexSpinBox::customEvent(QEvent* arg__1)
			2439	{
			2440	if (_wrapper) {
			2441	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "customEvent");
			2442	PyErr_Clear();
			2443	if (obj && !PythonQtSlotFunction_Check(obj)) {
			2444	static const char* argumentList[] ={"" , "QEvent*"};
			2445	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			2446	void* args[2] = {NULL, (void*)&arg__1};
			2447	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			2448	if (result) { Py_DECREF(result); }
			2449	Py_DECREF(obj);
			2450	return;
			2451	}
			2452	}
			2453	QHexSpinBox::customEvent(arg__1);
			2454	}
			2455	int PythonQtShell_QHexSpinBox::devType() const
			2456	{
			2457	if (_wrapper) {
			2458	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "devType");
			2459	PyErr_Clear();
			2460	if (obj && !PythonQtSlotFunction_Check(obj)) {
			2461	static const char* argumentList[] ={"int"};
			2462	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
			2463	int returnValue;
			2464	void* args[1] = {NULL};
			2465	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			2466	if (result) {
			2467	args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
			2468	if (args[0]!=&returnValue) {
			2469	if (args[0]==NULL) {
			2470	PythonQt::priv()->handleVirtualOverloadReturnError("devType", methodInfo, result);
			2471	} else {
			2472	returnValue = ((int)args[0]);
			2473	}
			2474	}
			2475	}
			2476	if (result) { Py_DECREF(result); }
			2477	Py_DECREF(obj);
			2478	return returnValue;
			2479	}
			2480	}
			2481	return QHexSpinBox::devType();
			2482	}
			2483	void PythonQtShell_QHexSpinBox::dragEnterEvent(QDragEnterEvent* arg__1)
			2484	{
			2485	if (_wrapper) {
			2486	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragEnterEvent");
			2487	PyErr_Clear();
			2488	if (obj && !PythonQtSlotFunction_Check(obj)) {
			2489	static const char* argumentList[] ={"" , "QDragEnterEvent*"};
			2490	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			2491	void* args[2] = {NULL, (void*)&arg__1};
			2492	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			2493	if (result) { Py_DECREF(result); }
			2494	Py_DECREF(obj);
			2495	return;
			2496	}
			2497	}
			2498	QHexSpinBox::dragEnterEvent(arg__1);
			2499	}
			2500	void PythonQtShell_QHexSpinBox::dragLeaveEvent(QDragLeaveEvent* arg__1)
			2501	{
			2502	if (_wrapper) {
			2503	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragLeaveEvent");
			2504	PyErr_Clear();
			2505	if (obj && !PythonQtSlotFunction_Check(obj)) {
			2506	static const char* argumentList[] ={"" , "QDragLeaveEvent*"};
			2507	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			2508	void* args[2] = {NULL, (void*)&arg__1};
			2509	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			2510	if (result) { Py_DECREF(result); }
			2511	Py_DECREF(obj);
			2512	return;
			2513	}
			2514	}
			2515	QHexSpinBox::dragLeaveEvent(arg__1);
			2516	}
			2517	void PythonQtShell_QHexSpinBox::dragMoveEvent(QDragMoveEvent* arg__1)
			2518	{
			2519	if (_wrapper) {
			2520	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragMoveEvent");
			2521	PyErr_Clear();
			2522	if (obj && !PythonQtSlotFunction_Check(obj)) {
			2523	static const char* argumentList[] ={"" , "QDragMoveEvent*"};
			2524	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			2525	void* args[2] = {NULL, (void*)&arg__1};
			2526	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			2527	if (result) { Py_DECREF(result); }
			2528	Py_DECREF(obj);
			2529	return;
			2530	}
			2531	}
			2532	QHexSpinBox::dragMoveEvent(arg__1);
			2533	}
			2534	void PythonQtShell_QHexSpinBox::dropEvent(QDropEvent* arg__1)
			2535	{
			2536	if (_wrapper) {
			2537	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dropEvent");
			2538	PyErr_Clear();
			2539	if (obj && !PythonQtSlotFunction_Check(obj)) {
			2540	static const char* argumentList[] ={"" , "QDropEvent*"};
			2541	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			2542	void* args[2] = {NULL, (void*)&arg__1};
			2543	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			2544	if (result) { Py_DECREF(result); }
			2545	Py_DECREF(obj);
			2546	return;
			2547	}
			2548	}
			2549	QHexSpinBox::dropEvent(arg__1);
			2550	}
			2551	void PythonQtShell_QHexSpinBox::enterEvent(QEvent* arg__1)
			2552	{
			2553	if (_wrapper) {
			2554	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "enterEvent");
			2555	PyErr_Clear();
			2556	if (obj && !PythonQtSlotFunction_Check(obj)) {
			2557	static const char* argumentList[] ={"" , "QEvent*"};
			2558	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			2559	void* args[2] = {NULL, (void*)&arg__1};
			2560	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			2561	if (result) { Py_DECREF(result); }
			2562	Py_DECREF(obj);
			2563	return;
			2564	}
			2565	}
			2566	QHexSpinBox::enterEvent(arg__1);
			2567	}
			2568	bool PythonQtShell_QHexSpinBox::event(QEvent* event)
			2569	{
			2570	if (_wrapper) {
			2571	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "event");
			2572	PyErr_Clear();
			2573	if (obj && !PythonQtSlotFunction_Check(obj)) {
			2574	static const char* argumentList[] ={"bool" , "QEvent*"};
			2575	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			2576	bool returnValue;
			2577	void* args[2] = {NULL, (void*)&event};
			2578	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			2579	if (result) {
			2580	args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
			2581	if (args[0]!=&returnValue) {
			2582	if (args[0]==NULL) {
			2583	PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
			2584	} else {
			2585	returnValue = ((bool)args[0]);
			2586	}
			2587	}
			2588	}
			2589	if (result) { Py_DECREF(result); }
			2590	Py_DECREF(obj);
			2591	return returnValue;
			2592	}
			2593	}
			2594	return QHexSpinBox::event(event);
			2595	}
			2596	bool PythonQtShell_QHexSpinBox::eventFilter(QObject* arg__1, QEvent* arg__2)
			2597	{
			2598	if (_wrapper) {
			2599	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "eventFilter");
			2600	PyErr_Clear();
			2601	if (obj && !PythonQtSlotFunction_Check(obj)) {
			2602	static const char* argumentList[] ={"bool" , "QObject" , "QEvent"};
			2603	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
			2604	bool returnValue;
			2605	void* args[3] = {NULL, (void)&arg__1, (void)&arg__2};
			2606	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			2607	if (result) {
			2608	args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
			2609	if (args[0]!=&returnValue) {
			2610	if (args[0]==NULL) {
			2611	PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
			2612	} else {
			2613	returnValue = ((bool)args[0]);
			2614	}
			2615	}
			2616	}
			2617	if (result) { Py_DECREF(result); }
			2618	Py_DECREF(obj);
			2619	return returnValue;
			2620	}
			2621	}
			2622	return QHexSpinBox::eventFilter(arg__1, arg__2);
			2623	}
			2624	void PythonQtShell_QHexSpinBox::fixup(QString& str) const
			2625	{
			2626	if (_wrapper) {
			2627	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "fixup");
			2628	PyErr_Clear();
			2629	if (obj && !PythonQtSlotFunction_Check(obj)) {
			2630	static const char* argumentList[] ={"" , "QString&"};
			2631	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			2632	void* args[2] = {NULL, (void*)&str};
			2633	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			2634	if (result) { Py_DECREF(result); }
			2635	Py_DECREF(obj);
			2636	return;
			2637	}
			2638	}
			2639	QHexSpinBox::fixup(str);
			2640	}
			2641	void PythonQtShell_QHexSpinBox::focusInEvent(QFocusEvent* event)
			2642	{
			2643	if (_wrapper) {
			2644	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusInEvent");
			2645	PyErr_Clear();
			2646	if (obj && !PythonQtSlotFunction_Check(obj)) {
			2647	static const char* argumentList[] ={"" , "QFocusEvent*"};
			2648	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			2649	void* args[2] = {NULL, (void*)&event};
			2650	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			2651	if (result) { Py_DECREF(result); }
			2652	Py_DECREF(obj);
			2653	return;
			2654	}
			2655	}
			2656	QHexSpinBox::focusInEvent(event);
			2657	}
			2658	bool PythonQtShell_QHexSpinBox::focusNextPrevChild(bool next)
			2659	{
			2660	if (_wrapper) {
			2661	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusNextPrevChild");
			2662	PyErr_Clear();
			2663	if (obj && !PythonQtSlotFunction_Check(obj)) {
			2664	static const char* argumentList[] ={"bool" , "bool"};
			2665	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			2666	bool returnValue;
			2667	void* args[2] = {NULL, (void*)&next};
			2668	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			2669	if (result) {
			2670	args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
			2671	if (args[0]!=&returnValue) {
			2672	if (args[0]==NULL) {
			2673	PythonQt::priv()->handleVirtualOverloadReturnError("focusNextPrevChild", methodInfo, result);
			2674	} else {
			2675	returnValue = ((bool)args[0]);
			2676	}
			2677	}
			2678	}
			2679	if (result) { Py_DECREF(result); }
			2680	Py_DECREF(obj);
			2681	return returnValue;
			2682	}
			2683	}
			2684	return QHexSpinBox::focusNextPrevChild(next);
			2685	}
			2686	void PythonQtShell_QHexSpinBox::focusOutEvent(QFocusEvent* event)
			2687	{
			2688	if (_wrapper) {
			2689	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusOutEvent");
			2690	PyErr_Clear();
			2691	if (obj && !PythonQtSlotFunction_Check(obj)) {
			2692	static const char* argumentList[] ={"" , "QFocusEvent*"};
			2693	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			2694	void* args[2] = {NULL, (void*)&event};
			2695	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			2696	if (result) { Py_DECREF(result); }
			2697	Py_DECREF(obj);
			2698	return;
			2699	}
			2700	}
			2701	QHexSpinBox::focusOutEvent(event);
			2702	}
			2703	bool PythonQtShell_QHexSpinBox::hasHeightForWidth() const
			2704	{
			2705	if (_wrapper) {
			2706	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hasHeightForWidth");
			2707	PyErr_Clear();
			2708	if (obj && !PythonQtSlotFunction_Check(obj)) {
			2709	static const char* argumentList[] ={"bool"};
			2710	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
			2711	bool returnValue;
			2712	void* args[1] = {NULL};
			2713	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			2714	if (result) {
			2715	args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
			2716	if (args[0]!=&returnValue) {
			2717	if (args[0]==NULL) {
			2718	PythonQt::priv()->handleVirtualOverloadReturnError("hasHeightForWidth", methodInfo, result);
			2719	} else {
			2720	returnValue = ((bool)args[0]);
			2721	}
			2722	}
			2723	}
			2724	if (result) { Py_DECREF(result); }
			2725	Py_DECREF(obj);
			2726	return returnValue;
			2727	}
			2728	}
			2729	return QHexSpinBox::hasHeightForWidth();
			2730	}
			2731	int PythonQtShell_QHexSpinBox::heightForWidth(int arg__1) const
			2732	{
			2733	if (_wrapper) {
			2734	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "heightForWidth");
			2735	PyErr_Clear();
			2736	if (obj && !PythonQtSlotFunction_Check(obj)) {
			2737	static const char* argumentList[] ={"int" , "int"};
			2738	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			2739	int returnValue;
			2740	void* args[2] = {NULL, (void*)&arg__1};
			2741	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			2742	if (result) {
			2743	args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
			2744	if (args[0]!=&returnValue) {
			2745	if (args[0]==NULL) {
			2746	PythonQt::priv()->handleVirtualOverloadReturnError("heightForWidth", methodInfo, result);
			2747	} else {
			2748	returnValue = ((int)args[0]);
			2749	}
			2750	}
			2751	}
			2752	if (result) { Py_DECREF(result); }
			2753	Py_DECREF(obj);
			2754	return returnValue;
			2755	}
			2756	}
			2757	return QHexSpinBox::heightForWidth(arg__1);
			2758	}
			2759	void PythonQtShell_QHexSpinBox::hideEvent(QHideEvent* event)
			2760	{
			2761	if (_wrapper) {
			2762	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hideEvent");
			2763	PyErr_Clear();
			2764	if (obj && !PythonQtSlotFunction_Check(obj)) {
			2765	static const char* argumentList[] ={"" , "QHideEvent*"};
			2766	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			2767	void* args[2] = {NULL, (void*)&event};
			2768	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			2769	if (result) { Py_DECREF(result); }
			2770	Py_DECREF(obj);
			2771	return;
			2772	}
			2773	}
			2774	QHexSpinBox::hideEvent(event);
			2775	}
			2776	void PythonQtShell_QHexSpinBox::initPainter(QPainter* painter) const
			2777	{
			2778	if (_wrapper) {
			2779	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "initPainter");
			2780	PyErr_Clear();
			2781	if (obj && !PythonQtSlotFunction_Check(obj)) {
			2782	static const char* argumentList[] ={"" , "QPainter*"};
			2783	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			2784	void* args[2] = {NULL, (void*)&painter};
			2785	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			2786	if (result) { Py_DECREF(result); }
			2787	Py_DECREF(obj);
			2788	return;
			2789	}
			2790	}
			2791	QHexSpinBox::initPainter(painter);
			2792	}
			2793	void PythonQtShell_QHexSpinBox::inputMethodEvent(QInputMethodEvent* arg__1)
			2794	{
			2795	if (_wrapper) {
			2796	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodEvent");
			2797	PyErr_Clear();
			2798	if (obj && !PythonQtSlotFunction_Check(obj)) {
			2799	static const char* argumentList[] ={"" , "QInputMethodEvent*"};
			2800	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			2801	void* args[2] = {NULL, (void*)&arg__1};
			2802	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			2803	if (result) { Py_DECREF(result); }
			2804	Py_DECREF(obj);
			2805	return;
			2806	}
			2807	}
			2808	QHexSpinBox::inputMethodEvent(arg__1);
			2809	}
			2810	QVariant PythonQtShell_QHexSpinBox::inputMethodQuery(Qt::InputMethodQuery arg__1) const
			2811	{
			2812	if (_wrapper) {
			2813	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodQuery");
			2814	PyErr_Clear();
			2815	if (obj && !PythonQtSlotFunction_Check(obj)) {
			2816	static const char* argumentList[] ={"QVariant" , "Qt::InputMethodQuery"};
			2817	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			2818	QVariant returnValue;
			2819	void* args[2] = {NULL, (void*)&arg__1};
			2820	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			2821	if (result) {
			2822	args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
			2823	if (args[0]!=&returnValue) {
			2824	if (args[0]==NULL) {
			2825	PythonQt::priv()->handleVirtualOverloadReturnError("inputMethodQuery", methodInfo, result);
			2826	} else {
			2827	returnValue = ((QVariant)args[0]);
			2828	}
			2829	}
			2830	}
			2831	if (result) { Py_DECREF(result); }
			2832	Py_DECREF(obj);
			2833	return returnValue;
			2834	}
			2835	}
			2836	return QHexSpinBox::inputMethodQuery(arg__1);
			2837	}
			2838	void PythonQtShell_QHexSpinBox::keyPressEvent(QKeyEvent* event)
			2839	{
			2840	if (_wrapper) {
			2841	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyPressEvent");
			2842	PyErr_Clear();
			2843	if (obj && !PythonQtSlotFunction_Check(obj)) {
			2844	static const char* argumentList[] ={"" , "QKeyEvent*"};
			2845	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			2846	void* args[2] = {NULL, (void*)&event};
			2847	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			2848	if (result) { Py_DECREF(result); }
			2849	Py_DECREF(obj);
			2850	return;
			2851	}
			2852	}
			2853	QHexSpinBox::keyPressEvent(event);
			2854	}
			2855	void PythonQtShell_QHexSpinBox::keyReleaseEvent(QKeyEvent* event)
			2856	{
			2857	if (_wrapper) {
			2858	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyReleaseEvent");
			2859	PyErr_Clear();
			2860	if (obj && !PythonQtSlotFunction_Check(obj)) {
			2861	static const char* argumentList[] ={"" , "QKeyEvent*"};
			2862	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			2863	void* args[2] = {NULL, (void*)&event};
			2864	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			2865	if (result) { Py_DECREF(result); }
			2866	Py_DECREF(obj);
			2867	return;
			2868	}
			2869	}
			2870	QHexSpinBox::keyReleaseEvent(event);
			2871	}
			2872	void PythonQtShell_QHexSpinBox::leaveEvent(QEvent* arg__1)
			2873	{
			2874	if (_wrapper) {
			2875	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "leaveEvent");
			2876	PyErr_Clear();
			2877	if (obj && !PythonQtSlotFunction_Check(obj)) {
			2878	static const char* argumentList[] ={"" , "QEvent*"};
			2879	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			2880	void* args[2] = {NULL, (void*)&arg__1};
			2881	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			2882	if (result) { Py_DECREF(result); }
			2883	Py_DECREF(obj);
			2884	return;
			2885	}
			2886	}
			2887	QHexSpinBox::leaveEvent(arg__1);
			2888	}
			2889	int PythonQtShell_QHexSpinBox::metric(QPaintDevice::PaintDeviceMetric arg__1) const
			2890	{
			2891	if (_wrapper) {
			2892	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "metric");
			2893	PyErr_Clear();
			2894	if (obj && !PythonQtSlotFunction_Check(obj)) {
			2895	static const char* argumentList[] ={"int" , "QPaintDevice::PaintDeviceMetric"};
			2896	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			2897	int returnValue;
			2898	void* args[2] = {NULL, (void*)&arg__1};
			2899	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			2900	if (result) {
			2901	args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
			2902	if (args[0]!=&returnValue) {
			2903	if (args[0]==NULL) {
			2904	PythonQt::priv()->handleVirtualOverloadReturnError("metric", methodInfo, result);
			2905	} else {
			2906	returnValue = ((int)args[0]);
			2907	}
			2908	}
			2909	}
			2910	if (result) { Py_DECREF(result); }
			2911	Py_DECREF(obj);
			2912	return returnValue;
			2913	}
			2914	}
			2915	return QHexSpinBox::metric(arg__1);
			2916	}
			2917	void PythonQtShell_QHexSpinBox::mouseDoubleClickEvent(QMouseEvent* arg__1)
			2918	{
			2919	if (_wrapper) {
			2920	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseDoubleClickEvent");
			2921	PyErr_Clear();
			2922	if (obj && !PythonQtSlotFunction_Check(obj)) {
			2923	static const char* argumentList[] ={"" , "QMouseEvent*"};
			2924	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			2925	void* args[2] = {NULL, (void*)&arg__1};
			2926	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			2927	if (result) { Py_DECREF(result); }
			2928	Py_DECREF(obj);
			2929	return;
			2930	}
			2931	}
			2932	QHexSpinBox::mouseDoubleClickEvent(arg__1);
			2933	}
			2934	void PythonQtShell_QHexSpinBox::mouseMoveEvent(QMouseEvent* event)
			2935	{
			2936	if (_wrapper) {
			2937	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseMoveEvent");
			2938	PyErr_Clear();
			2939	if (obj && !PythonQtSlotFunction_Check(obj)) {
			2940	static const char* argumentList[] ={"" , "QMouseEvent*"};
			2941	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			2942	void* args[2] = {NULL, (void*)&event};
			2943	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			2944	if (result) { Py_DECREF(result); }
			2945	Py_DECREF(obj);
			2946	return;
			2947	}
			2948	}
			2949	QHexSpinBox::mouseMoveEvent(event);
			2950	}
			2951	void PythonQtShell_QHexSpinBox::mousePressEvent(QMouseEvent* event)
			2952	{
			2953	if (_wrapper) {
			2954	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mousePressEvent");
			2955	PyErr_Clear();
			2956	if (obj && !PythonQtSlotFunction_Check(obj)) {
			2957	static const char* argumentList[] ={"" , "QMouseEvent*"};
			2958	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			2959	void* args[2] = {NULL, (void*)&event};
			2960	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			2961	if (result) { Py_DECREF(result); }
			2962	Py_DECREF(obj);
			2963	return;
			2964	}
			2965	}
			2966	QHexSpinBox::mousePressEvent(event);
			2967	}
			2968	void PythonQtShell_QHexSpinBox::mouseReleaseEvent(QMouseEvent* event)
			2969	{
			2970	if (_wrapper) {
			2971	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseReleaseEvent");
			2972	PyErr_Clear();
			2973	if (obj && !PythonQtSlotFunction_Check(obj)) {
			2974	static const char* argumentList[] ={"" , "QMouseEvent*"};
			2975	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			2976	void* args[2] = {NULL, (void*)&event};
			2977	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			2978	if (result) { Py_DECREF(result); }
			2979	Py_DECREF(obj);
			2980	return;
			2981	}
			2982	}
			2983	QHexSpinBox::mouseReleaseEvent(event);
			2984	}
			2985	void PythonQtShell_QHexSpinBox::moveEvent(QMoveEvent* arg__1)
			2986	{
			2987	if (_wrapper) {
			2988	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "moveEvent");
			2989	PyErr_Clear();
			2990	if (obj && !PythonQtSlotFunction_Check(obj)) {
			2991	static const char* argumentList[] ={"" , "QMoveEvent*"};
			2992	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			2993	void* args[2] = {NULL, (void*)&arg__1};
			2994	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			2995	if (result) { Py_DECREF(result); }
			2996	Py_DECREF(obj);
			2997	return;
			2998	}
			2999	}
			3000	QHexSpinBox::moveEvent(arg__1);
			3001	}
			3002	bool PythonQtShell_QHexSpinBox::nativeEvent(const QByteArray& eventType, void* message, long* result)
			3003	{
			3004	if (_wrapper) {
			3005	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "nativeEvent");
			3006	PyErr_Clear();
			3007	if (obj && !PythonQtSlotFunction_Check(obj)) {
			3008	static const char* argumentList[] ={"bool" , "const QByteArray&" , "void" , "long"};
			3009	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
			3010	bool returnValue;
			3011	void* args[4] = {NULL, (void)&eventType, (void)&message, (void*)&result};
			3012	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			3013	if (result) {
			3014	args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
			3015	if (args[0]!=&returnValue) {
			3016	if (args[0]==NULL) {
			3017	PythonQt::priv()->handleVirtualOverloadReturnError("nativeEvent", methodInfo, result);
			3018	} else {
			3019	returnValue = ((bool)args[0]);
			3020	}
			3021	}
			3022	}
			3023	if (result) { Py_DECREF(result); }
			3024	Py_DECREF(obj);
			3025	return returnValue;
			3026	}
			3027	}
			3028	return QHexSpinBox::nativeEvent(eventType, message, result);
			3029	}
			3030	QPaintEngine* PythonQtShell_QHexSpinBox::paintEngine() const
			3031	{
			3032	if (_wrapper) {
			3033	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEngine");
			3034	PyErr_Clear();
			3035	if (obj && !PythonQtSlotFunction_Check(obj)) {
			3036	static const char* argumentList[] ={"QPaintEngine*"};
			3037	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
			3038	QPaintEngine* returnValue;
			3039	void* args[1] = {NULL};
			3040	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			3041	if (result) {
			3042	args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
			3043	if (args[0]!=&returnValue) {
			3044	if (args[0]==NULL) {
			3045	PythonQt::priv()->handleVirtualOverloadReturnError("paintEngine", methodInfo, result);
			3046	} else {
			3047	returnValue = ((QPaintEngine*)args[0]);
			3048	}
			3049	}
			3050	}
			3051	if (result) { Py_DECREF(result); }
			3052	Py_DECREF(obj);
			3053	return returnValue;
			3054	}
			3055	}
			3056	return QHexSpinBox::paintEngine();
			3057	}
			3058	void PythonQtShell_QHexSpinBox::paintEvent(QPaintEvent* event)
			3059	{
			3060	if (_wrapper) {
			3061	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEvent");
			3062	PyErr_Clear();
			3063	if (obj && !PythonQtSlotFunction_Check(obj)) {
			3064	static const char* argumentList[] ={"" , "QPaintEvent*"};
			3065	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			3066	void* args[2] = {NULL, (void*)&event};
			3067	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			3068	if (result) { Py_DECREF(result); }
			3069	Py_DECREF(obj);
			3070	return;
			3071	}
			3072	}
			3073	QHexSpinBox::paintEvent(event);
			3074	}
			3075	QPaintDevice* PythonQtShell_QHexSpinBox::redirected(QPoint* offset) const
			3076	{
			3077	if (_wrapper) {
			3078	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "redirected");
			3079	PyErr_Clear();
			3080	if (obj && !PythonQtSlotFunction_Check(obj)) {
			3081	static const char* argumentList[] ={"QPaintDevice" , "QPoint"};
			3082	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			3083	QPaintDevice* returnValue;
			3084	void* args[2] = {NULL, (void*)&offset};
			3085	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			3086	if (result) {
			3087	args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
			3088	if (args[0]!=&returnValue) {
			3089	if (args[0]==NULL) {
			3090	PythonQt::priv()->handleVirtualOverloadReturnError("redirected", methodInfo, result);
			3091	} else {
			3092	returnValue = ((QPaintDevice*)args[0]);
			3093	}
			3094	}
			3095	}
			3096	if (result) { Py_DECREF(result); }
			3097	Py_DECREF(obj);
			3098	return returnValue;
			3099	}
			3100	}
			3101	return QHexSpinBox::redirected(offset);
			3102	}
			3103	void PythonQtShell_QHexSpinBox::resizeEvent(QResizeEvent* event)
			3104	{
			3105	if (_wrapper) {
			3106	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "resizeEvent");
			3107	PyErr_Clear();
			3108	if (obj && !PythonQtSlotFunction_Check(obj)) {
			3109	static const char* argumentList[] ={"" , "QResizeEvent*"};
			3110	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			3111	void* args[2] = {NULL, (void*)&event};
			3112	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			3113	if (result) { Py_DECREF(result); }
			3114	Py_DECREF(obj);
			3115	return;
			3116	}
			3117	}
			3118	QHexSpinBox::resizeEvent(event);
			3119	}
			3120	QPainter* PythonQtShell_QHexSpinBox::sharedPainter() const
			3121	{
			3122	if (_wrapper) {
			3123	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "sharedPainter");
			3124	PyErr_Clear();
			3125	if (obj && !PythonQtSlotFunction_Check(obj)) {
			3126	static const char* argumentList[] ={"QPainter*"};
			3127	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
			3128	QPainter* returnValue;
			3129	void* args[1] = {NULL};
			3130	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			3131	if (result) {
			3132	args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
			3133	if (args[0]!=&returnValue) {
			3134	if (args[0]==NULL) {
			3135	PythonQt::priv()->handleVirtualOverloadReturnError("sharedPainter", methodInfo, result);
			3136	} else {
			3137	returnValue = ((QPainter*)args[0]);
			3138	}
			3139	}
			3140	}
			3141	if (result) { Py_DECREF(result); }
			3142	Py_DECREF(obj);
			3143	return returnValue;
			3144	}
			3145	}
			3146	return QHexSpinBox::sharedPainter();
			3147	}
			3148	void PythonQtShell_QHexSpinBox::showEvent(QShowEvent* event)
			3149	{
			3150	if (_wrapper) {
			3151	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "showEvent");
			3152	PyErr_Clear();
			3153	if (obj && !PythonQtSlotFunction_Check(obj)) {
			3154	static const char* argumentList[] ={"" , "QShowEvent*"};
			3155	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			3156	void* args[2] = {NULL, (void*)&event};
			3157	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			3158	if (result) { Py_DECREF(result); }
			3159	Py_DECREF(obj);
			3160	return;
			3161	}
			3162	}
			3163	QHexSpinBox::showEvent(event);
			3164	}
			3165	void PythonQtShell_QHexSpinBox::stepBy(int steps)
			3166	{
			3167	if (_wrapper) {
			3168	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "stepBy");
			3169	PyErr_Clear();
			3170	if (obj && !PythonQtSlotFunction_Check(obj)) {
			3171	static const char* argumentList[] ={"" , "int"};
			3172	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			3173	void* args[2] = {NULL, (void*)&steps};
			3174	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			3175	if (result) { Py_DECREF(result); }
			3176	Py_DECREF(obj);
			3177	return;
			3178	}
			3179	}
			3180	QHexSpinBox::stepBy(steps);
			3181	}
			3182	QAbstractSpinBox::StepEnabled PythonQtShell_QHexSpinBox::stepEnabled() const
			3183	{
			3184	if (_wrapper) {
			3185	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "stepEnabled");
			3186	PyErr_Clear();
			3187	if (obj && !PythonQtSlotFunction_Check(obj)) {
			3188	static const char* argumentList[] ={"QAbstractSpinBox::StepEnabled"};
			3189	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
			3190	QAbstractSpinBox::StepEnabled returnValue;
			3191	void* args[1] = {NULL};
			3192	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			3193	if (result) {
			3194	args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
			3195	if (args[0]!=&returnValue) {
			3196	if (args[0]==NULL) {
			3197	PythonQt::priv()->handleVirtualOverloadReturnError("stepEnabled", methodInfo, result);
			3198	} else {
			3199	returnValue = ((QAbstractSpinBox::StepEnabled)args[0]);
			3200	}
			3201	}
			3202	}
			3203	if (result) { Py_DECREF(result); }
			3204	Py_DECREF(obj);
			3205	return returnValue;
			3206	}
			3207	}
			3208	return QHexSpinBox::stepEnabled();
			3209	}
			3210	void PythonQtShell_QHexSpinBox::tabletEvent(QTabletEvent* arg__1)
			3211	{
			3212	if (_wrapper) {
			3213	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "tabletEvent");
			3214	PyErr_Clear();
			3215	if (obj && !PythonQtSlotFunction_Check(obj)) {
			3216	static const char* argumentList[] ={"" , "QTabletEvent*"};
			3217	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			3218	void* args[2] = {NULL, (void*)&arg__1};
			3219	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			3220	if (result) { Py_DECREF(result); }
			3221	Py_DECREF(obj);
			3222	return;
			3223	}
			3224	}
			3225	QHexSpinBox::tabletEvent(arg__1);
			3226	}
			3227	QString PythonQtShell_QHexSpinBox::textFromValue(int value) const
			3228	{
			3229	if (_wrapper) {
			3230	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "textFromValue");
			3231	PyErr_Clear();
			3232	if (obj && !PythonQtSlotFunction_Check(obj)) {
			3233	static const char* argumentList[] ={"QString" , "int"};
			3234	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			3235	QString returnValue;
			3236	void* args[2] = {NULL, (void*)&value};
			3237	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			3238	if (result) {
			3239	args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
			3240	if (args[0]!=&returnValue) {
			3241	if (args[0]==NULL) {
			3242	PythonQt::priv()->handleVirtualOverloadReturnError("textFromValue", methodInfo, result);
			3243	} else {
			3244	returnValue = ((QString)args[0]);
			3245	}
			3246	}
			3247	}
			3248	if (result) { Py_DECREF(result); }
			3249	Py_DECREF(obj);
			3250	return returnValue;
			3251	}
			3252	}
			3253	return QHexSpinBox::textFromValue(value);
			3254	}
			3255	void PythonQtShell_QHexSpinBox::timerEvent(QTimerEvent* event)
			3256	{
			3257	if (_wrapper) {
			3258	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "timerEvent");
			3259	PyErr_Clear();
			3260	if (obj && !PythonQtSlotFunction_Check(obj)) {
			3261	static const char* argumentList[] ={"" , "QTimerEvent*"};
			3262	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			3263	void* args[2] = {NULL, (void*)&event};
			3264	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			3265	if (result) { Py_DECREF(result); }
			3266	Py_DECREF(obj);
			3267	return;
			3268	}
			3269	}
			3270	QHexSpinBox::timerEvent(event);
			3271	}
			3272	QValidator::State PythonQtShell_QHexSpinBox::validate(QString& input, int& pos) const
			3273	{
			3274	if (_wrapper) {
			3275	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "validate");
			3276	PyErr_Clear();
			3277	if (obj && !PythonQtSlotFunction_Check(obj)) {
			3278	static const char* argumentList[] ={"QValidator::State" , "QString&" , "int&"};
			3279	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
			3280	QValidator::State returnValue;
			3281	void* args[3] = {NULL, (void)&input, (void)&pos};
			3282	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			3283	if (result) {
			3284	args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
			3285	if (args[0]!=&returnValue) {
			3286	if (args[0]==NULL) {
			3287	PythonQt::priv()->handleVirtualOverloadReturnError("validate", methodInfo, result);
			3288	} else {
			3289	returnValue = ((QValidator::State)args[0]);
			3290	}
			3291	}
			3292	}
			3293	if (result) { Py_DECREF(result); }
			3294	Py_DECREF(obj);
			3295	return returnValue;
			3296	}
			3297	}
			3298	return QHexSpinBox::validate(input, pos);
			3299	}
			3300	int PythonQtShell_QHexSpinBox::valueFromText(const QString& text) const
			3301	{
			3302	if (_wrapper) {
			3303	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "valueFromText");
			3304	PyErr_Clear();
			3305	if (obj && !PythonQtSlotFunction_Check(obj)) {
			3306	static const char* argumentList[] ={"int" , "const QString&"};
			3307	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			3308	int returnValue;
			3309	void* args[2] = {NULL, (void*)&text};
			3310	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			3311	if (result) {
			3312	args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
			3313	if (args[0]!=&returnValue) {
			3314	if (args[0]==NULL) {
			3315	PythonQt::priv()->handleVirtualOverloadReturnError("valueFromText", methodInfo, result);
			3316	} else {
			3317	returnValue = ((int)args[0]);
			3318	}
			3319	}
			3320	}
			3321	if (result) { Py_DECREF(result); }
			3322	Py_DECREF(obj);
			3323	return returnValue;
			3324	}
			3325	}
			3326	return QHexSpinBox::valueFromText(text);
			3327	}
			3328	void PythonQtShell_QHexSpinBox::wheelEvent(QWheelEvent* event)
			3329	{
			3330	if (_wrapper) {
			3331	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "wheelEvent");
			3332	PyErr_Clear();
			3333	if (obj && !PythonQtSlotFunction_Check(obj)) {
			3334	static const char* argumentList[] ={"" , "QWheelEvent*"};
			3335	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			3336	void* args[2] = {NULL, (void*)&event};
			3337	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			3338	if (result) { Py_DECREF(result); }
			3339	Py_DECREF(obj);
			3340	return;
			3341	}
			3342	}
			3343	QHexSpinBox::wheelEvent(event);
			3344	}
	451	QHexSpinBox* PythonQtWrapper_QHexSpinBox::new_QHexSpinBox(QWidget* parent)	3345	QHexSpinBox* PythonQtWrapper_QHexSpinBox::new_QHexSpinBox(QWidget* parent)
	452	{	3346	{
	453	return new QHexSpinBox(parent); }	3347	return new PythonQtShell_QHexSpinBox(parent); }
	454		3348
	455	void PythonQtWrapper_QHexSpinBox::show(QHexSpinBox* theWrappedObject)	3349	void PythonQtWrapper_QHexSpinBox::show(QHexSpinBox* theWrappedObject)
	456	{	3350	{
	457	( theWrappedObject->show());	3351	( theWrappedObject->show());
	458	}	3352	}
	459		3353
	460	QString PythonQtWrapper_QHexSpinBox::textFromValue(QHexSpinBox* theWrappedObject, int value) const	3354	QString PythonQtWrapper_QHexSpinBox::textFromValue(QHexSpinBox* theWrappedObject, int value) const
	461	{	3355	{
	462	return ( theWrappedObject->textFromValue(value));	3356	return ( ((PythonQtPublicPromoter_QHexSpinBox*)theWrappedObject)->promoted_textFromValue(value));
	463	}	3357	}
	464		3358
	465	QValidator::State PythonQtWrapper_QHexSpinBox::validate(QHexSpinBox* theWrappedObject, QString& input, int& pos) const	3359	QValidator::State PythonQtWrapper_QHexSpinBox::validate(QHexSpinBox* theWrappedObject, QString& input, int& pos) const
	466	{	3360	{
	467	return ( theWrappedObject->validate(input, pos));	3361	return ( ((PythonQtPublicPromoter_QHexSpinBox*)theWrappedObject)->promoted_validate(input, pos));
	468	}	3362	}
	469		3363
	470	int PythonQtWrapper_QHexSpinBox::valueFromText(QHexSpinBox* theWrappedObject, const QString& text) const	3364	int PythonQtWrapper_QHexSpinBox::valueFromText(QHexSpinBox* theWrappedObject, const QString& text) const
	471	{	3365	{
	472	return ( theWrappedObject->valueFromText(text));	3366	return ( ((PythonQtPublicPromoter_QHexSpinBox*)theWrappedObject)->promoted_valueFromText(text));
	473	}	3367	}
	474		3368
	475		3369
	476		3370
	477	PythonQtShell_SocExplorerPlot::~PythonQtShell_SocExplorerPlot() {	3371	PythonQtShell_SocExplorerPlot::~PythonQtShell_SocExplorerPlot() {
	478	PythonQtPrivate* priv = PythonQt::priv();	3372	PythonQtPrivate* priv = PythonQt::priv();
	479	if (priv) { priv->shellClassDeleted(this); }	3373	if (priv) { priv->shellClassDeleted(this); }
	480	}	3374	}
			3375	void PythonQtShell_SocExplorerPlot::actionEvent(QActionEvent* arg__1)
			3376	{
			3377	if (_wrapper) {
			3378	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "actionEvent");
			3379	PyErr_Clear();
			3380	if (obj && !PythonQtSlotFunction_Check(obj)) {
			3381	static const char* argumentList[] ={"" , "QActionEvent*"};
			3382	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			3383	void* args[2] = {NULL, (void*)&arg__1};
			3384	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			3385	if (result) { Py_DECREF(result); }
			3386	Py_DECREF(obj);
			3387	return;
			3388	}
			3389	}
			3390	SocExplorerPlot::actionEvent(arg__1);
			3391	}
			3392	void PythonQtShell_SocExplorerPlot::changeEvent(QEvent* arg__1)
			3393	{
			3394	if (_wrapper) {
			3395	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "changeEvent");
			3396	PyErr_Clear();
			3397	if (obj && !PythonQtSlotFunction_Check(obj)) {
			3398	static const char* argumentList[] ={"" , "QEvent*"};
			3399	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			3400	void* args[2] = {NULL, (void*)&arg__1};
			3401	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			3402	if (result) { Py_DECREF(result); }
			3403	Py_DECREF(obj);
			3404	return;
			3405	}
			3406	}
			3407	SocExplorerPlot::changeEvent(arg__1);
			3408	}
			3409	void PythonQtShell_SocExplorerPlot::childEvent(QChildEvent* arg__1)
			3410	{
			3411	if (_wrapper) {
			3412	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "childEvent");
			3413	PyErr_Clear();
			3414	if (obj && !PythonQtSlotFunction_Check(obj)) {
			3415	static const char* argumentList[] ={"" , "QChildEvent*"};
			3416	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			3417	void* args[2] = {NULL, (void*)&arg__1};
			3418	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			3419	if (result) { Py_DECREF(result); }
			3420	Py_DECREF(obj);
			3421	return;
			3422	}
			3423	}
			3424	SocExplorerPlot::childEvent(arg__1);
			3425	}
			3426	void PythonQtShell_SocExplorerPlot::closeEvent(QCloseEvent* arg__1)
			3427	{
			3428	if (_wrapper) {
			3429	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "closeEvent");
			3430	PyErr_Clear();
			3431	if (obj && !PythonQtSlotFunction_Check(obj)) {
			3432	static const char* argumentList[] ={"" , "QCloseEvent*"};
			3433	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			3434	void* args[2] = {NULL, (void*)&arg__1};
			3435	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			3436	if (result) { Py_DECREF(result); }
			3437	Py_DECREF(obj);
			3438	return;
			3439	}
			3440	}
			3441	SocExplorerPlot::closeEvent(arg__1);
			3442	}
			3443	void PythonQtShell_SocExplorerPlot::contextMenuEvent(QContextMenuEvent* arg__1)
			3444	{
			3445	if (_wrapper) {
			3446	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "contextMenuEvent");
			3447	PyErr_Clear();
			3448	if (obj && !PythonQtSlotFunction_Check(obj)) {
			3449	static const char* argumentList[] ={"" , "QContextMenuEvent*"};
			3450	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			3451	void* args[2] = {NULL, (void*)&arg__1};
			3452	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			3453	if (result) { Py_DECREF(result); }
			3454	Py_DECREF(obj);
			3455	return;
			3456	}
			3457	}
			3458	SocExplorerPlot::contextMenuEvent(arg__1);
			3459	}
			3460	void PythonQtShell_SocExplorerPlot::customEvent(QEvent* arg__1)
			3461	{
			3462	if (_wrapper) {
			3463	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "customEvent");
			3464	PyErr_Clear();
			3465	if (obj && !PythonQtSlotFunction_Check(obj)) {
			3466	static const char* argumentList[] ={"" , "QEvent*"};
			3467	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			3468	void* args[2] = {NULL, (void*)&arg__1};
			3469	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			3470	if (result) { Py_DECREF(result); }
			3471	Py_DECREF(obj);
			3472	return;
			3473	}
			3474	}
			3475	SocExplorerPlot::customEvent(arg__1);
			3476	}
			3477	int PythonQtShell_SocExplorerPlot::devType() const
			3478	{
			3479	if (_wrapper) {
			3480	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "devType");
			3481	PyErr_Clear();
			3482	if (obj && !PythonQtSlotFunction_Check(obj)) {
			3483	static const char* argumentList[] ={"int"};
			3484	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
			3485	int returnValue;
			3486	void* args[1] = {NULL};
			3487	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			3488	if (result) {
			3489	args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
			3490	if (args[0]!=&returnValue) {
			3491	if (args[0]==NULL) {
			3492	PythonQt::priv()->handleVirtualOverloadReturnError("devType", methodInfo, result);
			3493	} else {
			3494	returnValue = ((int)args[0]);
			3495	}
			3496	}
			3497	}
			3498	if (result) { Py_DECREF(result); }
			3499	Py_DECREF(obj);
			3500	return returnValue;
			3501	}
			3502	}
			3503	return SocExplorerPlot::devType();
			3504	}
			3505	void PythonQtShell_SocExplorerPlot::dragEnterEvent(QDragEnterEvent* arg__1)
			3506	{
			3507	if (_wrapper) {
			3508	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragEnterEvent");
			3509	PyErr_Clear();
			3510	if (obj && !PythonQtSlotFunction_Check(obj)) {
			3511	static const char* argumentList[] ={"" , "QDragEnterEvent*"};
			3512	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			3513	void* args[2] = {NULL, (void*)&arg__1};
			3514	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			3515	if (result) { Py_DECREF(result); }
			3516	Py_DECREF(obj);
			3517	return;
			3518	}
			3519	}
			3520	SocExplorerPlot::dragEnterEvent(arg__1);
			3521	}
			3522	void PythonQtShell_SocExplorerPlot::dragLeaveEvent(QDragLeaveEvent* arg__1)
			3523	{
			3524	if (_wrapper) {
			3525	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragLeaveEvent");
			3526	PyErr_Clear();
			3527	if (obj && !PythonQtSlotFunction_Check(obj)) {
			3528	static const char* argumentList[] ={"" , "QDragLeaveEvent*"};
			3529	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			3530	void* args[2] = {NULL, (void*)&arg__1};
			3531	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			3532	if (result) { Py_DECREF(result); }
			3533	Py_DECREF(obj);
			3534	return;
			3535	}
			3536	}
			3537	SocExplorerPlot::dragLeaveEvent(arg__1);
			3538	}
			3539	void PythonQtShell_SocExplorerPlot::dragMoveEvent(QDragMoveEvent* arg__1)
			3540	{
			3541	if (_wrapper) {
			3542	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragMoveEvent");
			3543	PyErr_Clear();
			3544	if (obj && !PythonQtSlotFunction_Check(obj)) {
			3545	static const char* argumentList[] ={"" , "QDragMoveEvent*"};
			3546	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			3547	void* args[2] = {NULL, (void*)&arg__1};
			3548	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			3549	if (result) { Py_DECREF(result); }
			3550	Py_DECREF(obj);
			3551	return;
			3552	}
			3553	}
			3554	SocExplorerPlot::dragMoveEvent(arg__1);
			3555	}
			3556	void PythonQtShell_SocExplorerPlot::dropEvent(QDropEvent* arg__1)
			3557	{
			3558	if (_wrapper) {
			3559	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dropEvent");
			3560	PyErr_Clear();
			3561	if (obj && !PythonQtSlotFunction_Check(obj)) {
			3562	static const char* argumentList[] ={"" , "QDropEvent*"};
			3563	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			3564	void* args[2] = {NULL, (void*)&arg__1};
			3565	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			3566	if (result) { Py_DECREF(result); }
			3567	Py_DECREF(obj);
			3568	return;
			3569	}
			3570	}
			3571	SocExplorerPlot::dropEvent(arg__1);
			3572	}
			3573	void PythonQtShell_SocExplorerPlot::enterEvent(QEvent* arg__1)
			3574	{
			3575	if (_wrapper) {
			3576	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "enterEvent");
			3577	PyErr_Clear();
			3578	if (obj && !PythonQtSlotFunction_Check(obj)) {
			3579	static const char* argumentList[] ={"" , "QEvent*"};
			3580	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			3581	void* args[2] = {NULL, (void*)&arg__1};
			3582	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			3583	if (result) { Py_DECREF(result); }
			3584	Py_DECREF(obj);
			3585	return;
			3586	}
			3587	}
			3588	SocExplorerPlot::enterEvent(arg__1);
			3589	}
			3590	bool PythonQtShell_SocExplorerPlot::event(QEvent* arg__1)
			3591	{
			3592	if (_wrapper) {
			3593	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "event");
			3594	PyErr_Clear();
			3595	if (obj && !PythonQtSlotFunction_Check(obj)) {
			3596	static const char* argumentList[] ={"bool" , "QEvent*"};
			3597	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			3598	bool returnValue;
			3599	void* args[2] = {NULL, (void*)&arg__1};
			3600	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			3601	if (result) {
			3602	args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
			3603	if (args[0]!=&returnValue) {
			3604	if (args[0]==NULL) {
			3605	PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
			3606	} else {
			3607	returnValue = ((bool)args[0]);
			3608	}
			3609	}
			3610	}
			3611	if (result) { Py_DECREF(result); }
			3612	Py_DECREF(obj);
			3613	return returnValue;
			3614	}
			3615	}
			3616	return SocExplorerPlot::event(arg__1);
			3617	}
			3618	bool PythonQtShell_SocExplorerPlot::eventFilter(QObject* arg__1, QEvent* arg__2)
			3619	{
			3620	if (_wrapper) {
			3621	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "eventFilter");
			3622	PyErr_Clear();
			3623	if (obj && !PythonQtSlotFunction_Check(obj)) {
			3624	static const char* argumentList[] ={"bool" , "QObject" , "QEvent"};
			3625	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
			3626	bool returnValue;
			3627	void* args[3] = {NULL, (void)&arg__1, (void)&arg__2};
			3628	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			3629	if (result) {
			3630	args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
			3631	if (args[0]!=&returnValue) {
			3632	if (args[0]==NULL) {
			3633	PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
			3634	} else {
			3635	returnValue = ((bool)args[0]);
			3636	}
			3637	}
			3638	}
			3639	if (result) { Py_DECREF(result); }
			3640	Py_DECREF(obj);
			3641	return returnValue;
			3642	}
			3643	}
			3644	return SocExplorerPlot::eventFilter(arg__1, arg__2);
			3645	}
			3646	void PythonQtShell_SocExplorerPlot::focusInEvent(QFocusEvent* arg__1)
			3647	{
			3648	if (_wrapper) {
			3649	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusInEvent");
			3650	PyErr_Clear();
			3651	if (obj && !PythonQtSlotFunction_Check(obj)) {
			3652	static const char* argumentList[] ={"" , "QFocusEvent*"};
			3653	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			3654	void* args[2] = {NULL, (void*)&arg__1};
			3655	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			3656	if (result) { Py_DECREF(result); }
			3657	Py_DECREF(obj);
			3658	return;
			3659	}
			3660	}
			3661	SocExplorerPlot::focusInEvent(arg__1);
			3662	}
			3663	bool PythonQtShell_SocExplorerPlot::focusNextPrevChild(bool next)
			3664	{
			3665	if (_wrapper) {
			3666	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusNextPrevChild");
			3667	PyErr_Clear();
			3668	if (obj && !PythonQtSlotFunction_Check(obj)) {
			3669	static const char* argumentList[] ={"bool" , "bool"};
			3670	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			3671	bool returnValue;
			3672	void* args[2] = {NULL, (void*)&next};
			3673	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			3674	if (result) {
			3675	args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
			3676	if (args[0]!=&returnValue) {
			3677	if (args[0]==NULL) {
			3678	PythonQt::priv()->handleVirtualOverloadReturnError("focusNextPrevChild", methodInfo, result);
			3679	} else {
			3680	returnValue = ((bool)args[0]);
			3681	}
			3682	}
			3683	}
			3684	if (result) { Py_DECREF(result); }
			3685	Py_DECREF(obj);
			3686	return returnValue;
			3687	}
			3688	}
			3689	return SocExplorerPlot::focusNextPrevChild(next);
			3690	}
			3691	void PythonQtShell_SocExplorerPlot::focusOutEvent(QFocusEvent* arg__1)
			3692	{
			3693	if (_wrapper) {
			3694	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusOutEvent");
			3695	PyErr_Clear();
			3696	if (obj && !PythonQtSlotFunction_Check(obj)) {
			3697	static const char* argumentList[] ={"" , "QFocusEvent*"};
			3698	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			3699	void* args[2] = {NULL, (void*)&arg__1};
			3700	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			3701	if (result) { Py_DECREF(result); }
			3702	Py_DECREF(obj);
			3703	return;
			3704	}
			3705	}
			3706	SocExplorerPlot::focusOutEvent(arg__1);
			3707	}
			3708	bool PythonQtShell_SocExplorerPlot::hasHeightForWidth() const
			3709	{
			3710	if (_wrapper) {
			3711	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hasHeightForWidth");
			3712	PyErr_Clear();
			3713	if (obj && !PythonQtSlotFunction_Check(obj)) {
			3714	static const char* argumentList[] ={"bool"};
			3715	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
			3716	bool returnValue;
			3717	void* args[1] = {NULL};
			3718	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			3719	if (result) {
			3720	args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
			3721	if (args[0]!=&returnValue) {
			3722	if (args[0]==NULL) {
			3723	PythonQt::priv()->handleVirtualOverloadReturnError("hasHeightForWidth", methodInfo, result);
			3724	} else {
			3725	returnValue = ((bool)args[0]);
			3726	}
			3727	}
			3728	}
			3729	if (result) { Py_DECREF(result); }
			3730	Py_DECREF(obj);
			3731	return returnValue;
			3732	}
			3733	}
			3734	return SocExplorerPlot::hasHeightForWidth();
			3735	}
			3736	int PythonQtShell_SocExplorerPlot::heightForWidth(int arg__1) const
			3737	{
			3738	if (_wrapper) {
			3739	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "heightForWidth");
			3740	PyErr_Clear();
			3741	if (obj && !PythonQtSlotFunction_Check(obj)) {
			3742	static const char* argumentList[] ={"int" , "int"};
			3743	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			3744	int returnValue;
			3745	void* args[2] = {NULL, (void*)&arg__1};
			3746	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			3747	if (result) {
			3748	args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
			3749	if (args[0]!=&returnValue) {
			3750	if (args[0]==NULL) {
			3751	PythonQt::priv()->handleVirtualOverloadReturnError("heightForWidth", methodInfo, result);
			3752	} else {
			3753	returnValue = ((int)args[0]);
			3754	}
			3755	}
			3756	}
			3757	if (result) { Py_DECREF(result); }
			3758	Py_DECREF(obj);
			3759	return returnValue;
			3760	}
			3761	}
			3762	return SocExplorerPlot::heightForWidth(arg__1);
			3763	}
			3764	void PythonQtShell_SocExplorerPlot::hideEvent(QHideEvent* arg__1)
			3765	{
			3766	if (_wrapper) {
			3767	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hideEvent");
			3768	PyErr_Clear();
			3769	if (obj && !PythonQtSlotFunction_Check(obj)) {
			3770	static const char* argumentList[] ={"" , "QHideEvent*"};
			3771	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			3772	void* args[2] = {NULL, (void*)&arg__1};
			3773	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			3774	if (result) { Py_DECREF(result); }
			3775	Py_DECREF(obj);
			3776	return;
			3777	}
			3778	}
			3779	SocExplorerPlot::hideEvent(arg__1);
			3780	}
			3781	void PythonQtShell_SocExplorerPlot::initPainter(QPainter* painter) const
			3782	{
			3783	if (_wrapper) {
			3784	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "initPainter");
			3785	PyErr_Clear();
			3786	if (obj && !PythonQtSlotFunction_Check(obj)) {
			3787	static const char* argumentList[] ={"" , "QPainter*"};
			3788	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			3789	void* args[2] = {NULL, (void*)&painter};
			3790	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			3791	if (result) { Py_DECREF(result); }
			3792	Py_DECREF(obj);
			3793	return;
			3794	}
			3795	}
			3796	SocExplorerPlot::initPainter(painter);
			3797	}
			3798	void PythonQtShell_SocExplorerPlot::inputMethodEvent(QInputMethodEvent* arg__1)
			3799	{
			3800	if (_wrapper) {
			3801	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodEvent");
			3802	PyErr_Clear();
			3803	if (obj && !PythonQtSlotFunction_Check(obj)) {
			3804	static const char* argumentList[] ={"" , "QInputMethodEvent*"};
			3805	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			3806	void* args[2] = {NULL, (void*)&arg__1};
			3807	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			3808	if (result) { Py_DECREF(result); }
			3809	Py_DECREF(obj);
			3810	return;
			3811	}
			3812	}
			3813	SocExplorerPlot::inputMethodEvent(arg__1);
			3814	}
			3815	QVariant PythonQtShell_SocExplorerPlot::inputMethodQuery(Qt::InputMethodQuery arg__1) const
			3816	{
			3817	if (_wrapper) {
			3818	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodQuery");
			3819	PyErr_Clear();
			3820	if (obj && !PythonQtSlotFunction_Check(obj)) {
			3821	static const char* argumentList[] ={"QVariant" , "Qt::InputMethodQuery"};
			3822	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			3823	QVariant returnValue;
			3824	void* args[2] = {NULL, (void*)&arg__1};
			3825	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			3826	if (result) {
			3827	args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
			3828	if (args[0]!=&returnValue) {
			3829	if (args[0]==NULL) {
			3830	PythonQt::priv()->handleVirtualOverloadReturnError("inputMethodQuery", methodInfo, result);
			3831	} else {
			3832	returnValue = ((QVariant)args[0]);
			3833	}
			3834	}
			3835	}
			3836	if (result) { Py_DECREF(result); }
			3837	Py_DECREF(obj);
			3838	return returnValue;
			3839	}
			3840	}
			3841	return SocExplorerPlot::inputMethodQuery(arg__1);
			3842	}
			3843	void PythonQtShell_SocExplorerPlot::keyPressEvent(QKeyEvent* arg__1)
			3844	{
			3845	if (_wrapper) {
			3846	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyPressEvent");
			3847	PyErr_Clear();
			3848	if (obj && !PythonQtSlotFunction_Check(obj)) {
			3849	static const char* argumentList[] ={"" , "QKeyEvent*"};
			3850	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			3851	void* args[2] = {NULL, (void*)&arg__1};
			3852	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			3853	if (result) { Py_DECREF(result); }
			3854	Py_DECREF(obj);
			3855	return;
			3856	}
			3857	}
			3858	SocExplorerPlot::keyPressEvent(arg__1);
			3859	}
			3860	void PythonQtShell_SocExplorerPlot::keyReleaseEvent(QKeyEvent* arg__1)
			3861	{
			3862	if (_wrapper) {
			3863	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyReleaseEvent");
			3864	PyErr_Clear();
			3865	if (obj && !PythonQtSlotFunction_Check(obj)) {
			3866	static const char* argumentList[] ={"" , "QKeyEvent*"};
			3867	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			3868	void* args[2] = {NULL, (void*)&arg__1};
			3869	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			3870	if (result) { Py_DECREF(result); }
			3871	Py_DECREF(obj);
			3872	return;
			3873	}
			3874	}
			3875	SocExplorerPlot::keyReleaseEvent(arg__1);
			3876	}
			3877	void PythonQtShell_SocExplorerPlot::leaveEvent(QEvent* arg__1)
			3878	{
			3879	if (_wrapper) {
			3880	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "leaveEvent");
			3881	PyErr_Clear();
			3882	if (obj && !PythonQtSlotFunction_Check(obj)) {
			3883	static const char* argumentList[] ={"" , "QEvent*"};
			3884	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			3885	void* args[2] = {NULL, (void*)&arg__1};
			3886	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			3887	if (result) { Py_DECREF(result); }
			3888	Py_DECREF(obj);
			3889	return;
			3890	}
			3891	}
			3892	SocExplorerPlot::leaveEvent(arg__1);
			3893	}
			3894	int PythonQtShell_SocExplorerPlot::metric(QPaintDevice::PaintDeviceMetric arg__1) const
			3895	{
			3896	if (_wrapper) {
			3897	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "metric");
			3898	PyErr_Clear();
			3899	if (obj && !PythonQtSlotFunction_Check(obj)) {
			3900	static const char* argumentList[] ={"int" , "QPaintDevice::PaintDeviceMetric"};
			3901	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			3902	int returnValue;
			3903	void* args[2] = {NULL, (void*)&arg__1};
			3904	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			3905	if (result) {
			3906	args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
			3907	if (args[0]!=&returnValue) {
			3908	if (args[0]==NULL) {
			3909	PythonQt::priv()->handleVirtualOverloadReturnError("metric", methodInfo, result);
			3910	} else {
			3911	returnValue = ((int)args[0]);
			3912	}
			3913	}
			3914	}
			3915	if (result) { Py_DECREF(result); }
			3916	Py_DECREF(obj);
			3917	return returnValue;
			3918	}
			3919	}
			3920	return SocExplorerPlot::metric(arg__1);
			3921	}
			3922	QSize PythonQtShell_SocExplorerPlot::minimumSizeHint() const
			3923	{
			3924	if (_wrapper) {
			3925	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getMinimumSizeHint");
			3926	PyErr_Clear();
			3927	if (obj && !PythonQtSlotFunction_Check(obj)) {
			3928	static const char* argumentList[] ={"QSize"};
			3929	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
			3930	QSize returnValue;
			3931	void* args[1] = {NULL};
			3932	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			3933	if (result) {
			3934	args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
			3935	if (args[0]!=&returnValue) {
			3936	if (args[0]==NULL) {
			3937	PythonQt::priv()->handleVirtualOverloadReturnError("getMinimumSizeHint", methodInfo, result);
			3938	} else {
			3939	returnValue = ((QSize)args[0]);
			3940	}
			3941	}
			3942	}
			3943	if (result) { Py_DECREF(result); }
			3944	Py_DECREF(obj);
			3945	return returnValue;
			3946	}
			3947	}
			3948	return SocExplorerPlot::minimumSizeHint();
			3949	}
			3950	void PythonQtShell_SocExplorerPlot::mouseDoubleClickEvent(QMouseEvent* arg__1)
			3951	{
			3952	if (_wrapper) {
			3953	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseDoubleClickEvent");
			3954	PyErr_Clear();
			3955	if (obj && !PythonQtSlotFunction_Check(obj)) {
			3956	static const char* argumentList[] ={"" , "QMouseEvent*"};
			3957	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			3958	void* args[2] = {NULL, (void*)&arg__1};
			3959	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			3960	if (result) { Py_DECREF(result); }
			3961	Py_DECREF(obj);
			3962	return;
			3963	}
			3964	}
			3965	SocExplorerPlot::mouseDoubleClickEvent(arg__1);
			3966	}
			3967	void PythonQtShell_SocExplorerPlot::mouseMoveEvent(QMouseEvent* arg__1)
			3968	{
			3969	if (_wrapper) {
			3970	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseMoveEvent");
			3971	PyErr_Clear();
			3972	if (obj && !PythonQtSlotFunction_Check(obj)) {
			3973	static const char* argumentList[] ={"" , "QMouseEvent*"};
			3974	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			3975	void* args[2] = {NULL, (void*)&arg__1};
			3976	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			3977	if (result) { Py_DECREF(result); }
			3978	Py_DECREF(obj);
			3979	return;
			3980	}
			3981	}
			3982	SocExplorerPlot::mouseMoveEvent(arg__1);
			3983	}
			3984	void PythonQtShell_SocExplorerPlot::mousePressEvent(QMouseEvent* arg__1)
			3985	{
			3986	if (_wrapper) {
			3987	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mousePressEvent");
			3988	PyErr_Clear();
			3989	if (obj && !PythonQtSlotFunction_Check(obj)) {
			3990	static const char* argumentList[] ={"" , "QMouseEvent*"};
			3991	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			3992	void* args[2] = {NULL, (void*)&arg__1};
			3993	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			3994	if (result) { Py_DECREF(result); }
			3995	Py_DECREF(obj);
			3996	return;
			3997	}
			3998	}
			3999	SocExplorerPlot::mousePressEvent(arg__1);
			4000	}
			4001	void PythonQtShell_SocExplorerPlot::mouseReleaseEvent(QMouseEvent* arg__1)
			4002	{
			4003	if (_wrapper) {
			4004	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseReleaseEvent");
			4005	PyErr_Clear();
			4006	if (obj && !PythonQtSlotFunction_Check(obj)) {
			4007	static const char* argumentList[] ={"" , "QMouseEvent*"};
			4008	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			4009	void* args[2] = {NULL, (void*)&arg__1};
			4010	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			4011	if (result) { Py_DECREF(result); }
			4012	Py_DECREF(obj);
			4013	return;
			4014	}
			4015	}
			4016	SocExplorerPlot::mouseReleaseEvent(arg__1);
			4017	}
			4018	void PythonQtShell_SocExplorerPlot::moveEvent(QMoveEvent* arg__1)
			4019	{
			4020	if (_wrapper) {
			4021	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "moveEvent");
			4022	PyErr_Clear();
			4023	if (obj && !PythonQtSlotFunction_Check(obj)) {
			4024	static const char* argumentList[] ={"" , "QMoveEvent*"};
			4025	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			4026	void* args[2] = {NULL, (void*)&arg__1};
			4027	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			4028	if (result) { Py_DECREF(result); }
			4029	Py_DECREF(obj);
			4030	return;
			4031	}
			4032	}
			4033	SocExplorerPlot::moveEvent(arg__1);
			4034	}
			4035	bool PythonQtShell_SocExplorerPlot::nativeEvent(const QByteArray& eventType, void* message, long* result)
			4036	{
			4037	if (_wrapper) {
			4038	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "nativeEvent");
			4039	PyErr_Clear();
			4040	if (obj && !PythonQtSlotFunction_Check(obj)) {
			4041	static const char* argumentList[] ={"bool" , "const QByteArray&" , "void" , "long"};
			4042	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
			4043	bool returnValue;
			4044	void* args[4] = {NULL, (void)&eventType, (void)&message, (void*)&result};
			4045	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			4046	if (result) {
			4047	args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
			4048	if (args[0]!=&returnValue) {
			4049	if (args[0]==NULL) {
			4050	PythonQt::priv()->handleVirtualOverloadReturnError("nativeEvent", methodInfo, result);
			4051	} else {
			4052	returnValue = ((bool)args[0]);
			4053	}
			4054	}
			4055	}
			4056	if (result) { Py_DECREF(result); }
			4057	Py_DECREF(obj);
			4058	return returnValue;
			4059	}
			4060	}
			4061	return SocExplorerPlot::nativeEvent(eventType, message, result);
			4062	}
			4063	QPaintEngine* PythonQtShell_SocExplorerPlot::paintEngine() const
			4064	{
			4065	if (_wrapper) {
			4066	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEngine");
			4067	PyErr_Clear();
			4068	if (obj && !PythonQtSlotFunction_Check(obj)) {
			4069	static const char* argumentList[] ={"QPaintEngine*"};
			4070	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
			4071	QPaintEngine* returnValue;
			4072	void* args[1] = {NULL};
			4073	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			4074	if (result) {
			4075	args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
			4076	if (args[0]!=&returnValue) {
			4077	if (args[0]==NULL) {
			4078	PythonQt::priv()->handleVirtualOverloadReturnError("paintEngine", methodInfo, result);
			4079	} else {
			4080	returnValue = ((QPaintEngine*)args[0]);
			4081	}
			4082	}
			4083	}
			4084	if (result) { Py_DECREF(result); }
			4085	Py_DECREF(obj);
			4086	return returnValue;
			4087	}
			4088	}
			4089	return SocExplorerPlot::paintEngine();
			4090	}
			4091	void PythonQtShell_SocExplorerPlot::paintEvent(QPaintEvent* arg__1)
			4092	{
			4093	if (_wrapper) {
			4094	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEvent");
			4095	PyErr_Clear();
			4096	if (obj && !PythonQtSlotFunction_Check(obj)) {
			4097	static const char* argumentList[] ={"" , "QPaintEvent*"};
			4098	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			4099	void* args[2] = {NULL, (void*)&arg__1};
			4100	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			4101	if (result) { Py_DECREF(result); }
			4102	Py_DECREF(obj);
			4103	return;
			4104	}
			4105	}
			4106	SocExplorerPlot::paintEvent(arg__1);
			4107	}
			4108	QPaintDevice* PythonQtShell_SocExplorerPlot::redirected(QPoint* offset) const
			4109	{
			4110	if (_wrapper) {
			4111	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "redirected");
			4112	PyErr_Clear();
			4113	if (obj && !PythonQtSlotFunction_Check(obj)) {
			4114	static const char* argumentList[] ={"QPaintDevice" , "QPoint"};
			4115	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			4116	QPaintDevice* returnValue;
			4117	void* args[2] = {NULL, (void*)&offset};
			4118	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			4119	if (result) {
			4120	args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
			4121	if (args[0]!=&returnValue) {
			4122	if (args[0]==NULL) {
			4123	PythonQt::priv()->handleVirtualOverloadReturnError("redirected", methodInfo, result);
			4124	} else {
			4125	returnValue = ((QPaintDevice*)args[0]);
			4126	}
			4127	}
			4128	}
			4129	if (result) { Py_DECREF(result); }
			4130	Py_DECREF(obj);
			4131	return returnValue;
			4132	}
			4133	}
			4134	return SocExplorerPlot::redirected(offset);
			4135	}
			4136	void PythonQtShell_SocExplorerPlot::resizeEvent(QResizeEvent* arg__1)
			4137	{
			4138	if (_wrapper) {
			4139	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "resizeEvent");
			4140	PyErr_Clear();
			4141	if (obj && !PythonQtSlotFunction_Check(obj)) {
			4142	static const char* argumentList[] ={"" , "QResizeEvent*"};
			4143	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			4144	void* args[2] = {NULL, (void*)&arg__1};
			4145	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			4146	if (result) { Py_DECREF(result); }
			4147	Py_DECREF(obj);
			4148	return;
			4149	}
			4150	}
			4151	SocExplorerPlot::resizeEvent(arg__1);
			4152	}
			4153	QPainter* PythonQtShell_SocExplorerPlot::sharedPainter() const
			4154	{
			4155	if (_wrapper) {
			4156	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "sharedPainter");
			4157	PyErr_Clear();
			4158	if (obj && !PythonQtSlotFunction_Check(obj)) {
			4159	static const char* argumentList[] ={"QPainter*"};
			4160	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
			4161	QPainter* returnValue;
			4162	void* args[1] = {NULL};
			4163	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			4164	if (result) {
			4165	args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
			4166	if (args[0]!=&returnValue) {
			4167	if (args[0]==NULL) {
			4168	PythonQt::priv()->handleVirtualOverloadReturnError("sharedPainter", methodInfo, result);
			4169	} else {
			4170	returnValue = ((QPainter*)args[0]);
			4171	}
			4172	}
			4173	}
			4174	if (result) { Py_DECREF(result); }
			4175	Py_DECREF(obj);
			4176	return returnValue;
			4177	}
			4178	}
			4179	return SocExplorerPlot::sharedPainter();
			4180	}
			4181	void PythonQtShell_SocExplorerPlot::showEvent(QShowEvent* arg__1)
			4182	{
			4183	if (_wrapper) {
			4184	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "showEvent");
			4185	PyErr_Clear();
			4186	if (obj && !PythonQtSlotFunction_Check(obj)) {
			4187	static const char* argumentList[] ={"" , "QShowEvent*"};
			4188	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			4189	void* args[2] = {NULL, (void*)&arg__1};
			4190	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			4191	if (result) { Py_DECREF(result); }
			4192	Py_DECREF(obj);
			4193	return;
			4194	}
			4195	}
			4196	SocExplorerPlot::showEvent(arg__1);
			4197	}
			4198	QSize PythonQtShell_SocExplorerPlot::sizeHint() const
			4199	{
			4200	if (_wrapper) {
			4201	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getSizeHint");
			4202	PyErr_Clear();
			4203	if (obj && !PythonQtSlotFunction_Check(obj)) {
			4204	static const char* argumentList[] ={"QSize"};
			4205	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
			4206	QSize returnValue;
			4207	void* args[1] = {NULL};
			4208	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			4209	if (result) {
			4210	args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
			4211	if (args[0]!=&returnValue) {
			4212	if (args[0]==NULL) {
			4213	PythonQt::priv()->handleVirtualOverloadReturnError("getSizeHint", methodInfo, result);
			4214	} else {
			4215	returnValue = ((QSize)args[0]);
			4216	}
			4217	}
			4218	}
			4219	if (result) { Py_DECREF(result); }
			4220	Py_DECREF(obj);
			4221	return returnValue;
			4222	}
			4223	}
			4224	return SocExplorerPlot::sizeHint();
			4225	}
			4226	void PythonQtShell_SocExplorerPlot::tabletEvent(QTabletEvent* arg__1)
			4227	{
			4228	if (_wrapper) {
			4229	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "tabletEvent");
			4230	PyErr_Clear();
			4231	if (obj && !PythonQtSlotFunction_Check(obj)) {
			4232	static const char* argumentList[] ={"" , "QTabletEvent*"};
			4233	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			4234	void* args[2] = {NULL, (void*)&arg__1};
			4235	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			4236	if (result) { Py_DECREF(result); }
			4237	Py_DECREF(obj);
			4238	return;
			4239	}
			4240	}
			4241	SocExplorerPlot::tabletEvent(arg__1);
			4242	}
			4243	void PythonQtShell_SocExplorerPlot::timerEvent(QTimerEvent* arg__1)
			4244	{
			4245	if (_wrapper) {
			4246	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "timerEvent");
			4247	PyErr_Clear();
			4248	if (obj && !PythonQtSlotFunction_Check(obj)) {
			4249	static const char* argumentList[] ={"" , "QTimerEvent*"};
			4250	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			4251	void* args[2] = {NULL, (void*)&arg__1};
			4252	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			4253	if (result) { Py_DECREF(result); }
			4254	Py_DECREF(obj);
			4255	return;
			4256	}
			4257	}
			4258	SocExplorerPlot::timerEvent(arg__1);
			4259	}
			4260	void PythonQtShell_SocExplorerPlot::wheelEvent(QWheelEvent* arg__1)
			4261	{
			4262	if (_wrapper) {
			4263	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "wheelEvent");
			4264	PyErr_Clear();
			4265	if (obj && !PythonQtSlotFunction_Check(obj)) {
			4266	static const char* argumentList[] ={"" , "QWheelEvent*"};
			4267	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			4268	void* args[2] = {NULL, (void*)&arg__1};
			4269	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			4270	if (result) { Py_DECREF(result); }
			4271	Py_DECREF(obj);
			4272	return;
			4273	}
			4274	}
			4275	SocExplorerPlot::wheelEvent(arg__1);
			4276	}
	481	SocExplorerPlot* PythonQtWrapper_SocExplorerPlot::new_SocExplorerPlot(QWidget* parent)	4277	SocExplorerPlot* PythonQtWrapper_SocExplorerPlot::new_SocExplorerPlot(QWidget* parent)
	482	{	4278	{
	483	return new PythonQtShell_SocExplorerPlot(parent); }	4279	return new PythonQtShell_SocExplorerPlot(parent); }
	484		4280
	485	int PythonQtWrapper_SocExplorerPlot::addGraph(SocExplorerPlot* theWrappedObject)	4281	int PythonQtWrapper_SocExplorerPlot::addGraph(SocExplorerPlot* theWrappedObject)
	486	{	4282	{
	487	return ( theWrappedObject->addGraph());	4283	return ( theWrappedObject->addGraph());
	488	}	4284	}
	489		4285
	490	void PythonQtWrapper_SocExplorerPlot::addGraphData(SocExplorerPlot* theWrappedObject, int graphIndex, QList<QVariant > x, QList<QVariant > y)	4286	void PythonQtWrapper_SocExplorerPlot::addGraphData(SocExplorerPlot* theWrappedObject, int graphIndex, QList<QVariant > x, QList<QVariant > y)
	491	{	4287	{
	492	( theWrappedObject->addGraphData(graphIndex, x, y));	4288	( theWrappedObject->addGraphData(graphIndex, x, y));
	493	}	4289	}
	494		4290
	495	void PythonQtWrapper_SocExplorerPlot::addGraphData(SocExplorerPlot* theWrappedObject, int graphIndex, QVariant x, QVariant y)	4291	void PythonQtWrapper_SocExplorerPlot::addGraphData(SocExplorerPlot* theWrappedObject, int graphIndex, QVariant x, QVariant y)
	496	{	4292	{
	497	( theWrappedObject->addGraphData(graphIndex, x, y));	4293	( theWrappedObject->addGraphData(graphIndex, x, y));
	498	}	4294	}
	499		4295
	500	QPen PythonQtWrapper_SocExplorerPlot::getGraphPen(SocExplorerPlot* theWrappedObject, int graphIndex)	4296	QPen PythonQtWrapper_SocExplorerPlot::getGraphPen(SocExplorerPlot* theWrappedObject, int graphIndex)
	501	{	4297	{
	502	return ( theWrappedObject->getGraphPen(graphIndex));	4298	return ( theWrappedObject->getGraphPen(graphIndex));
	503	}	4299	}
	504		4300
			4301	void PythonQtWrapper_SocExplorerPlot::keyPressEvent(SocExplorerPlot* theWrappedObject, QKeyEvent* arg__1)
			4302	{
			4303	( ((PythonQtPublicPromoter_SocExplorerPlot*)theWrappedObject)->promoted_keyPressEvent(arg__1));
			4304	}
			4305
			4306	void PythonQtWrapper_SocExplorerPlot::keyReleaseEvent(SocExplorerPlot* theWrappedObject, QKeyEvent* arg__1)
			4307	{
			4308	( ((PythonQtPublicPromoter_SocExplorerPlot*)theWrappedObject)->promoted_keyReleaseEvent(arg__1));
			4309	}
			4310
			4311	void PythonQtWrapper_SocExplorerPlot::mouseMoveEvent(SocExplorerPlot* theWrappedObject, QMouseEvent* arg__1)
			4312	{
			4313	( ((PythonQtPublicPromoter_SocExplorerPlot*)theWrappedObject)->promoted_mouseMoveEvent(arg__1));
			4314	}
			4315
			4316	void PythonQtWrapper_SocExplorerPlot::mousePressEvent(SocExplorerPlot* theWrappedObject, QMouseEvent* arg__1)
			4317	{
			4318	( ((PythonQtPublicPromoter_SocExplorerPlot*)theWrappedObject)->promoted_mousePressEvent(arg__1));
			4319	}
			4320
			4321	void PythonQtWrapper_SocExplorerPlot::mouseReleaseEvent(SocExplorerPlot* theWrappedObject, QMouseEvent* arg__1)
			4322	{
			4323	( ((PythonQtPublicPromoter_SocExplorerPlot*)theWrappedObject)->promoted_mouseReleaseEvent(arg__1));
			4324	}
			4325
	505	void PythonQtWrapper_SocExplorerPlot::rescaleAxis(SocExplorerPlot* theWrappedObject)	4326	void PythonQtWrapper_SocExplorerPlot::rescaleAxis(SocExplorerPlot* theWrappedObject)
	506	{	4327	{
	507	( theWrappedObject->rescaleAxis());	4328	( theWrappedObject->rescaleAxis());
	508	}	4329	}
	509		4330
	510	void PythonQtWrapper_SocExplorerPlot::setAdaptativeSampling(SocExplorerPlot* theWrappedObject, int graphIndex, bool enable)	4331	void PythonQtWrapper_SocExplorerPlot::setAdaptativeSampling(SocExplorerPlot* theWrappedObject, int graphIndex, bool enable)
	511	{	4332	{
	512	( theWrappedObject->setAdaptativeSampling(graphIndex, enable));	4333	( theWrappedObject->setAdaptativeSampling(graphIndex, enable));
	513	}	4334	}
	514		4335
	515	void PythonQtWrapper_SocExplorerPlot::setGraphData(SocExplorerPlot* theWrappedObject, int graphIndex, QList<QVariant > x, QList<QVariant > y)	4336	void PythonQtWrapper_SocExplorerPlot::setGraphData(SocExplorerPlot* theWrappedObject, int graphIndex, QList<QVariant > x, QList<QVariant > y)
	516	{	4337	{
	517	( theWrappedObject->setGraphData(graphIndex, x, y));	4338	( theWrappedObject->setGraphData(graphIndex, x, y));
	518	}	4339	}
	519		4340
	520	void PythonQtWrapper_SocExplorerPlot::setGraphLineStyle(SocExplorerPlot* theWrappedObject, int graphIndex, QString lineStyle)	4341	void PythonQtWrapper_SocExplorerPlot::setGraphLineStyle(SocExplorerPlot* theWrappedObject, int graphIndex, QString lineStyle)
	521	{	4342	{
	522	( theWrappedObject->setGraphLineStyle(graphIndex, lineStyle));	4343	( theWrappedObject->setGraphLineStyle(graphIndex, lineStyle));
	523	}	4344	}
	524		4345
	525	void PythonQtWrapper_SocExplorerPlot::setGraphName(SocExplorerPlot* theWrappedObject, int graphIndex, QString name)	4346	void PythonQtWrapper_SocExplorerPlot::setGraphName(SocExplorerPlot* theWrappedObject, int graphIndex, QString name)
	526	{	4347	{
	527	( theWrappedObject->setGraphName(graphIndex, name));	4348	( theWrappedObject->setGraphName(graphIndex, name));
	528	}	4349	}
	529		4350
	530	void PythonQtWrapper_SocExplorerPlot::setGraphPen(SocExplorerPlot* theWrappedObject, int graphIndex, QPen pen)	4351	void PythonQtWrapper_SocExplorerPlot::setGraphPen(SocExplorerPlot* theWrappedObject, int graphIndex, QPen pen)
	531	{	4352	{
	532	( theWrappedObject->setGraphPen(graphIndex, pen));	4353	( theWrappedObject->setGraphPen(graphIndex, pen));
	533	}	4354	}
	534		4355
	535	void PythonQtWrapper_SocExplorerPlot::setGraphScatterStyle(SocExplorerPlot* theWrappedObject, int graphIndex, QString scatterStyle)	4356	void PythonQtWrapper_SocExplorerPlot::setGraphScatterStyle(SocExplorerPlot* theWrappedObject, int graphIndex, QString scatterStyle)
	536	{	4357	{
	537	( theWrappedObject->setGraphScatterStyle(graphIndex, scatterStyle));	4358	( theWrappedObject->setGraphScatterStyle(graphIndex, scatterStyle));
	538	}	4359	}
	539		4360
	540	void PythonQtWrapper_SocExplorerPlot::setLegendFont(SocExplorerPlot* theWrappedObject, QFont font)	4361	void PythonQtWrapper_SocExplorerPlot::setLegendFont(SocExplorerPlot* theWrappedObject, QFont font)
	541	{	4362	{
	542	( theWrappedObject->setLegendFont(font));	4363	( theWrappedObject->setLegendFont(font));
	543	}	4364	}
	544		4365
	545	void PythonQtWrapper_SocExplorerPlot::setLegendSelectedFont(SocExplorerPlot* theWrappedObject, QFont font)	4366	void PythonQtWrapper_SocExplorerPlot::setLegendSelectedFont(SocExplorerPlot* theWrappedObject, QFont font)
	546	{	4367	{
	547	( theWrappedObject->setLegendSelectedFont(font));	4368	( theWrappedObject->setLegendSelectedFont(font));
	548	}	4369	}
	549		4370
	550	void PythonQtWrapper_SocExplorerPlot::setTitle(SocExplorerPlot* theWrappedObject, QString title)	4371	void PythonQtWrapper_SocExplorerPlot::setTitle(SocExplorerPlot* theWrappedObject, QString title)
	551	{	4372	{
	552	( theWrappedObject->setTitle(title));	4373	( theWrappedObject->setTitle(title));
	553	}	4374	}
	554		4375
	555	void PythonQtWrapper_SocExplorerPlot::setXaxisLabel(SocExplorerPlot* theWrappedObject, QString label)	4376	void PythonQtWrapper_SocExplorerPlot::setXaxisLabel(SocExplorerPlot* theWrappedObject, QString label)
	556	{	4377	{
	557	( theWrappedObject->setXaxisLabel(label));	4378	( theWrappedObject->setXaxisLabel(label));
	558	}	4379	}
	559		4380
	560	void PythonQtWrapper_SocExplorerPlot::setXaxisRange(SocExplorerPlot* theWrappedObject, double lower, double upper)	4381	void PythonQtWrapper_SocExplorerPlot::setXaxisRange(SocExplorerPlot* theWrappedObject, double lower, double upper)
	561	{	4382	{
	562	( theWrappedObject->setXaxisRange(lower, upper));	4383	( theWrappedObject->setXaxisRange(lower, upper));
	563	}	4384	}
	564		4385
	565	void PythonQtWrapper_SocExplorerPlot::setYaxisLabel(SocExplorerPlot* theWrappedObject, QString label)	4386	void PythonQtWrapper_SocExplorerPlot::setYaxisLabel(SocExplorerPlot* theWrappedObject, QString label)
	566	{	4387	{
	567	( theWrappedObject->setYaxisLabel(label));	4388	( theWrappedObject->setYaxisLabel(label));
	568	}	4389	}
	569		4390
	570	void PythonQtWrapper_SocExplorerPlot::setYaxisRange(SocExplorerPlot* theWrappedObject, double lower, double upper)	4391	void PythonQtWrapper_SocExplorerPlot::setYaxisRange(SocExplorerPlot* theWrappedObject, double lower, double upper)
	571	{	4392	{
	572	( theWrappedObject->setYaxisRange(lower, upper));	4393	( theWrappedObject->setYaxisRange(lower, upper));
	573	}	4394	}
	574		4395
	575	void PythonQtWrapper_SocExplorerPlot::show(SocExplorerPlot* theWrappedObject)	4396	void PythonQtWrapper_SocExplorerPlot::show(SocExplorerPlot* theWrappedObject)
	576	{	4397	{
	577	( theWrappedObject->show());	4398	( theWrappedObject->show());
	578	}	4399	}
	579		4400
	580		4401	void PythonQtWrapper_SocExplorerPlot::wheelEvent(SocExplorerPlot* theWrappedObject, QWheelEvent* arg__1)
	581		4402	{
			4403	( ((PythonQtPublicPromoter_SocExplorerPlot*)theWrappedObject)->promoted_wheelEvent(arg__1));
			4404	}
			4405
			4406
			4407
			4408	PythonQtShell_TCP_Terminal_Client::~PythonQtShell_TCP_Terminal_Client() {
			4409	PythonQtPrivate* priv = PythonQt::priv();
			4410	if (priv) { priv->shellClassDeleted(this); }
			4411	}
			4412	void PythonQtShell_TCP_Terminal_Client::childEvent(QChildEvent* arg__1)
			4413	{
			4414	if (_wrapper) {
			4415	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "childEvent");
			4416	PyErr_Clear();
			4417	if (obj && !PythonQtSlotFunction_Check(obj)) {
			4418	static const char* argumentList[] ={"" , "QChildEvent*"};
			4419	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			4420	void* args[2] = {NULL, (void*)&arg__1};
			4421	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			4422	if (result) { Py_DECREF(result); }
			4423	Py_DECREF(obj);
			4424	return;
			4425	}
			4426	}
			4427	TCP_Terminal_Client::childEvent(arg__1);
			4428	}
			4429	void PythonQtShell_TCP_Terminal_Client::customEvent(QEvent* arg__1)
			4430	{
			4431	if (_wrapper) {
			4432	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "customEvent");
			4433	PyErr_Clear();
			4434	if (obj && !PythonQtSlotFunction_Check(obj)) {
			4435	static const char* argumentList[] ={"" , "QEvent*"};
			4436	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			4437	void* args[2] = {NULL, (void*)&arg__1};
			4438	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			4439	if (result) { Py_DECREF(result); }
			4440	Py_DECREF(obj);
			4441	return;
			4442	}
			4443	}
			4444	TCP_Terminal_Client::customEvent(arg__1);
			4445	}
			4446	bool PythonQtShell_TCP_Terminal_Client::event(QEvent* arg__1)
			4447	{
			4448	if (_wrapper) {
			4449	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "event");
			4450	PyErr_Clear();
			4451	if (obj && !PythonQtSlotFunction_Check(obj)) {
			4452	static const char* argumentList[] ={"bool" , "QEvent*"};
			4453	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			4454	bool returnValue;
			4455	void* args[2] = {NULL, (void*)&arg__1};
			4456	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			4457	if (result) {
			4458	args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
			4459	if (args[0]!=&returnValue) {
			4460	if (args[0]==NULL) {
			4461	PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
			4462	} else {
			4463	returnValue = ((bool)args[0]);
			4464	}
			4465	}
			4466	}
			4467	if (result) { Py_DECREF(result); }
			4468	Py_DECREF(obj);
			4469	return returnValue;
			4470	}
			4471	}
			4472	return TCP_Terminal_Client::event(arg__1);
			4473	}
			4474	bool PythonQtShell_TCP_Terminal_Client::eventFilter(QObject* arg__1, QEvent* arg__2)
			4475	{
			4476	if (_wrapper) {
			4477	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "eventFilter");
			4478	PyErr_Clear();
			4479	if (obj && !PythonQtSlotFunction_Check(obj)) {
			4480	static const char* argumentList[] ={"bool" , "QObject" , "QEvent"};
			4481	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
			4482	bool returnValue;
			4483	void* args[3] = {NULL, (void)&arg__1, (void)&arg__2};
			4484	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			4485	if (result) {
			4486	args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
			4487	if (args[0]!=&returnValue) {
			4488	if (args[0]==NULL) {
			4489	PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
			4490	} else {
			4491	returnValue = ((bool)args[0]);
			4492	}
			4493	}
			4494	}
			4495	if (result) { Py_DECREF(result); }
			4496	Py_DECREF(obj);
			4497	return returnValue;
			4498	}
			4499	}
			4500	return TCP_Terminal_Client::eventFilter(arg__1, arg__2);
			4501	}
			4502	void PythonQtShell_TCP_Terminal_Client::timerEvent(QTimerEvent* arg__1)
			4503	{
			4504	if (_wrapper) {
			4505	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "timerEvent");
			4506	PyErr_Clear();
			4507	if (obj && !PythonQtSlotFunction_Check(obj)) {
			4508	static const char* argumentList[] ={"" , "QTimerEvent*"};
			4509	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			4510	void* args[2] = {NULL, (void*)&arg__1};
			4511	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			4512	if (result) { Py_DECREF(result); }
			4513	Py_DECREF(obj);
			4514	return;
			4515	}
			4516	}
			4517	TCP_Terminal_Client::timerEvent(arg__1);
			4518	}
	582	TCP_Terminal_Client* PythonQtWrapper_TCP_Terminal_Client::new_TCP_Terminal_Client(QObject* parent)	4519	TCP_Terminal_Client* PythonQtWrapper_TCP_Terminal_Client::new_TCP_Terminal_Client(QObject* parent)
	583	{	4520	{
	584	return new TCP_Terminal_Client(parent); }	4521	return new PythonQtShell_TCP_Terminal_Client(parent); }
	585		4522
	586	void PythonQtWrapper_TCP_Terminal_Client::connectToServer(TCP_Terminal_Client* theWrappedObject)	4523	void PythonQtWrapper_TCP_Terminal_Client::connectToServer(TCP_Terminal_Client* theWrappedObject)
	587	{	4524	{
	588	( theWrappedObject->connectToServer());	4525	( theWrappedObject->connectToServer());
	589	}	4526	}
	590		4527
	591	void PythonQtWrapper_TCP_Terminal_Client::connectToServer(TCP_Terminal_Client* theWrappedObject, const QString& IP, int port)	4528	void PythonQtWrapper_TCP_Terminal_Client::connectToServer(TCP_Terminal_Client* theWrappedObject, const QString& IP, int port)
	592	{	4529	{
	593	( theWrappedObject->connectToServer(IP, port));	4530	( theWrappedObject->connectToServer(IP, port));
	594	}	4531	}
	595		4532
	596	bool PythonQtWrapper_TCP_Terminal_Client::isConnected(TCP_Terminal_Client* theWrappedObject)	4533	bool PythonQtWrapper_TCP_Terminal_Client::isConnected(TCP_Terminal_Client* theWrappedObject)
	597	{	4534	{
	598	return ( theWrappedObject->isConnected());	4535	return ( theWrappedObject->isConnected());
	599	}	4536	}
	600		4537
	601	void PythonQtWrapper_TCP_Terminal_Client::sendText(TCP_Terminal_Client* theWrappedObject, const QString& text)	4538	void PythonQtWrapper_TCP_Terminal_Client::sendText(TCP_Terminal_Client* theWrappedObject, const QString& text)
	602	{	4539	{
	603	( theWrappedObject->sendText(text));	4540	( theWrappedObject->sendText(text));
	604	}	4541	}
	605		4542
	606	void PythonQtWrapper_TCP_Terminal_Client::startServer(TCP_Terminal_Client* theWrappedObject)	4543	void PythonQtWrapper_TCP_Terminal_Client::startServer(TCP_Terminal_Client* theWrappedObject)
	607	{	4544	{
	608	( theWrappedObject->startServer());	4545	( theWrappedObject->startServer());
	609	}	4546	}
	610		4547
	611	void PythonQtWrapper_TCP_Terminal_Client::startServer(TCP_Terminal_Client* theWrappedObject, int port)	4548	void PythonQtWrapper_TCP_Terminal_Client::startServer(TCP_Terminal_Client* theWrappedObject, int port)
	612	{	4549	{
	613	( theWrappedObject->startServer(port));	4550	( theWrappedObject->startServer(port));
	614	}	4551	}
	615		4552
	616		4553
	617		4554
	618	XByteArray* PythonQtWrapper_XByteArray::new_XByteArray()	4555	XByteArray* PythonQtWrapper_XByteArray::new_XByteArray()
	619	{	4556	{
	620	return new XByteArray(); }	4557	return new XByteArray(); }
	621		4558
	622	int PythonQtWrapper_XByteArray::addressOffset(XByteArray* theWrappedObject)	4559	int PythonQtWrapper_XByteArray::addressOffset(XByteArray* theWrappedObject)
	623	{	4560	{
	624	return ( theWrappedObject->addressOffset());	4561	return ( theWrappedObject->addressOffset());
	625	}	4562	}
	626		4563
	627	int PythonQtWrapper_XByteArray::addressWidth(XByteArray* theWrappedObject)	4564	int PythonQtWrapper_XByteArray::addressWidth(XByteArray* theWrappedObject)
	628	{	4565	{
	629	return ( theWrappedObject->addressWidth());	4566	return ( theWrappedObject->addressWidth());
	630	}	4567	}
	631		4568
	632	QChar PythonQtWrapper_XByteArray::asciiChar(XByteArray* theWrappedObject, int index)	4569	QChar PythonQtWrapper_XByteArray::asciiChar(XByteArray* theWrappedObject, int index)
	633	{	4570	{
	634	return ( theWrappedObject->asciiChar(index));	4571	return ( theWrappedObject->asciiChar(index));
	635	}	4572	}
	636		4573
	637	QByteArray* PythonQtWrapper_XByteArray::data(XByteArray* theWrappedObject)	4574	QByteArray* PythonQtWrapper_XByteArray::data(XByteArray* theWrappedObject)
	638	{	4575	{
	639	return &( theWrappedObject->data());	4576	return &( theWrappedObject->data());
	640	}	4577	}
	641		4578
	642	bool PythonQtWrapper_XByteArray::dataChanged(XByteArray* theWrappedObject, int i)	4579	bool PythonQtWrapper_XByteArray::dataChanged(XByteArray* theWrappedObject, int i)
	643	{	4580	{
	644	return ( theWrappedObject->dataChanged(i));	4581	return ( theWrappedObject->dataChanged(i));
	645	}	4582	}
	646		4583
	647	QByteArray PythonQtWrapper_XByteArray::dataChanged(XByteArray* theWrappedObject, int i, int len)	4584	QByteArray PythonQtWrapper_XByteArray::dataChanged(XByteArray* theWrappedObject, int i, int len)
	648	{	4585	{
	649	return ( theWrappedObject->dataChanged(i, len));	4586	return ( theWrappedObject->dataChanged(i, len));
	650	}	4587	}
	651		4588
	652	QByteArray* PythonQtWrapper_XByteArray::insert(XByteArray* theWrappedObject, int i, char ch)	4589	QByteArray* PythonQtWrapper_XByteArray::insert(XByteArray* theWrappedObject, int i, char ch)
	653	{	4590	{
	654	return &( theWrappedObject->insert(i, ch));	4591	return &( theWrappedObject->insert(i, ch));
	655	}	4592	}
	656		4593
	657	QByteArray* PythonQtWrapper_XByteArray::insert(XByteArray* theWrappedObject, int i, const QByteArray& ba)	4594	QByteArray* PythonQtWrapper_XByteArray::insert(XByteArray* theWrappedObject, int i, const QByteArray& ba)
	658	{	4595	{
	659	return &( theWrappedObject->insert(i, ba));	4596	return &( theWrappedObject->insert(i, ba));
	660	}	4597	}
	661		4598
	662	int PythonQtWrapper_XByteArray::realAddressNumbers(XByteArray* theWrappedObject)	4599	int PythonQtWrapper_XByteArray::realAddressNumbers(XByteArray* theWrappedObject)
	663	{	4600	{
	664	return ( theWrappedObject->realAddressNumbers());	4601	return ( theWrappedObject->realAddressNumbers());
	665	}	4602	}
	666		4603
	667	QByteArray* PythonQtWrapper_XByteArray::remove(XByteArray* theWrappedObject, int pos, int len)	4604	QByteArray* PythonQtWrapper_XByteArray::remove(XByteArray* theWrappedObject, int pos, int len)
	668	{	4605	{
	669	return &( theWrappedObject->remove(pos, len));	4606	return &( theWrappedObject->remove(pos, len));
	670	}	4607	}
	671		4608
	672	QByteArray* PythonQtWrapper_XByteArray::replace(XByteArray* theWrappedObject, int index, char ch)	4609	QByteArray* PythonQtWrapper_XByteArray::replace(XByteArray* theWrappedObject, int index, char ch)
	673	{	4610	{
	674	return &( theWrappedObject->replace(index, ch));	4611	return &( theWrappedObject->replace(index, ch));
	675	}	4612	}
	676		4613
	677	QByteArray* PythonQtWrapper_XByteArray::replace(XByteArray* theWrappedObject, int index, const QByteArray& ba)	4614	QByteArray* PythonQtWrapper_XByteArray::replace(XByteArray* theWrappedObject, int index, const QByteArray& ba)
	678	{	4615	{
	679	return &( theWrappedObject->replace(index, ba));	4616	return &( theWrappedObject->replace(index, ba));
	680	}	4617	}
	681		4618
	682	QByteArray* PythonQtWrapper_XByteArray::replace(XByteArray* theWrappedObject, int index, int length, const QByteArray& ba)	4619	QByteArray* PythonQtWrapper_XByteArray::replace(XByteArray* theWrappedObject, int index, int length, const QByteArray& ba)
	683	{	4620	{
	684	return &( theWrappedObject->replace(index, length, ba));	4621	return &( theWrappedObject->replace(index, length, ba));
	685	}	4622	}
	686		4623
	687	void PythonQtWrapper_XByteArray::setAddressOffset(XByteArray* theWrappedObject, int offset)	4624	void PythonQtWrapper_XByteArray::setAddressOffset(XByteArray* theWrappedObject, int offset)
	688	{	4625	{
	689	( theWrappedObject->setAddressOffset(offset));	4626	( theWrappedObject->setAddressOffset(offset));
	690	}	4627	}
	691		4628
	692	void PythonQtWrapper_XByteArray::setAddressWidth(XByteArray* theWrappedObject, int width)	4629	void PythonQtWrapper_XByteArray::setAddressWidth(XByteArray* theWrappedObject, int width)
	693	{	4630	{
	694	( theWrappedObject->setAddressWidth(width));	4631	( theWrappedObject->setAddressWidth(width));
	695	}	4632	}
	696		4633
	697	void PythonQtWrapper_XByteArray::setData(XByteArray* theWrappedObject, QByteArray data)	4634	void PythonQtWrapper_XByteArray::setData(XByteArray* theWrappedObject, QByteArray data)
	698	{	4635	{
	699	( theWrappedObject->setData(data));	4636	( theWrappedObject->setData(data));
	700	}	4637	}
	701		4638
	702	void PythonQtWrapper_XByteArray::setDataChanged(XByteArray* theWrappedObject, int i, bool state)	4639	void PythonQtWrapper_XByteArray::setDataChanged(XByteArray* theWrappedObject, int i, bool state)
	703	{	4640	{
	704	( theWrappedObject->setDataChanged(i, state));	4641	( theWrappedObject->setDataChanged(i, state));
	705	}	4642	}
	706		4643
	707	void PythonQtWrapper_XByteArray::setDataChanged(XByteArray* theWrappedObject, int i, const QByteArray& state)	4644	void PythonQtWrapper_XByteArray::setDataChanged(XByteArray* theWrappedObject, int i, const QByteArray& state)
	708	{	4645	{
	709	( theWrappedObject->setDataChanged(i, state));	4646	( theWrappedObject->setDataChanged(i, state));
	710	}	4647	}
	711		4648
	712	int PythonQtWrapper_XByteArray::size(XByteArray* theWrappedObject)	4649	int PythonQtWrapper_XByteArray::size(XByteArray* theWrappedObject)
	713	{	4650	{
	714	return ( theWrappedObject->size());	4651	return ( theWrappedObject->size());
	715	}	4652	}
	716		4653
	717	QString PythonQtWrapper_XByteArray::toRedableString(XByteArray* theWrappedObject, int start, int end)	4654	QString PythonQtWrapper_XByteArray::toRedableString(XByteArray* theWrappedObject, int start, int end)
	718	{	4655	{
	719	return ( theWrappedObject->toRedableString(start, end));	4656	return ( theWrappedObject->toRedableString(start, end));
	720	}	4657	}
	721		4658
	722		4659
	723		4660
	724	PythonQtShell_abstractExecFile::~PythonQtShell_abstractExecFile() {	4661	PythonQtShell_abstractExecFile::~PythonQtShell_abstractExecFile() {
	725	PythonQtPrivate* priv = PythonQt::priv();	4662	PythonQtPrivate* priv = PythonQt::priv();
	726	if (priv) { priv->shellClassDeleted(this); }	4663	if (priv) { priv->shellClassDeleted(this); }
	727	}	4664	}
			4665	void PythonQtShell_abstractExecFile::childEvent(QChildEvent* arg__1)
			4666	{
			4667	if (_wrapper) {
			4668	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "childEvent");
			4669	PyErr_Clear();
			4670	if (obj && !PythonQtSlotFunction_Check(obj)) {
			4671	static const char* argumentList[] ={"" , "QChildEvent*"};
			4672	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			4673	void* args[2] = {NULL, (void*)&arg__1};
			4674	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			4675	if (result) { Py_DECREF(result); }
			4676	Py_DECREF(obj);
			4677	return;
			4678	}
			4679	}
			4680	abstractExecFile::childEvent(arg__1);
			4681	}
	728	int PythonQtShell_abstractExecFile::closeFile()	4682	int PythonQtShell_abstractExecFile::closeFile()
	729	{	4683	{
	730	if (_wrapper) {	4684	if (_wrapper) {
	731	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "closeFile");	4685	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "closeFile");
	732	PyErr_Clear();	4686	PyErr_Clear();
	733	if (obj && !PythonQtSlotFunction_Check(obj)) {	4687	if (obj && !PythonQtSlotFunction_Check(obj)) {
	734	static const char* argumentList[] ={"int"};	4688	static const char* argumentList[] ={"int"};
	735	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);	4689	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
	736	int returnValue;	4690	int returnValue;
	737	void* args[1] = {NULL};	4691	void* args[1] = {NULL};
	738	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);	4692	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
	739	if (result) {	4693	if (result) {
	740	args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);	4694	args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
	741	if (args[0]!=&returnValue) {	4695	if (args[0]!=&returnValue) {
	742	if (args[0]==NULL) {	4696	if (args[0]==NULL) {
	743	PythonQt::priv()->handleVirtualOverloadReturnError("closeFile", methodInfo, result);	4697	PythonQt::priv()->handleVirtualOverloadReturnError("closeFile", methodInfo, result);
	744	} else {	4698	} else {
	745	returnValue = ((int)args[0]);	4699	returnValue = ((int)args[0]);
	746	}	4700	}
	747	}	4701	}
	748	}	4702	}
	749	if (result) { Py_DECREF(result); }	4703	if (result) { Py_DECREF(result); }
	750	Py_DECREF(obj);	4704	Py_DECREF(obj);
	751	return returnValue;	4705	return returnValue;
	752	}	4706	}
	753	}	4707	}
	754	return int();	4708	return int();
	755	}	4709	}
			4710	void PythonQtShell_abstractExecFile::customEvent(QEvent* arg__1)
			4711	{
			4712	if (_wrapper) {
			4713	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "customEvent");
			4714	PyErr_Clear();
			4715	if (obj && !PythonQtSlotFunction_Check(obj)) {
			4716	static const char* argumentList[] ={"" , "QEvent*"};
			4717	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			4718	void* args[2] = {NULL, (void*)&arg__1};
			4719	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			4720	if (result) { Py_DECREF(result); }
			4721	Py_DECREF(obj);
			4722	return;
			4723	}
			4724	}
			4725	abstractExecFile::customEvent(arg__1);
			4726	}
			4727	bool PythonQtShell_abstractExecFile::event(QEvent* arg__1)
			4728	{
			4729	if (_wrapper) {
			4730	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "event");
			4731	PyErr_Clear();
			4732	if (obj && !PythonQtSlotFunction_Check(obj)) {
			4733	static const char* argumentList[] ={"bool" , "QEvent*"};
			4734	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			4735	bool returnValue;
			4736	void* args[2] = {NULL, (void*)&arg__1};
			4737	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			4738	if (result) {
			4739	args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
			4740	if (args[0]!=&returnValue) {
			4741	if (args[0]==NULL) {
			4742	PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
			4743	} else {
			4744	returnValue = ((bool)args[0]);
			4745	}
			4746	}
			4747	}
			4748	if (result) { Py_DECREF(result); }
			4749	Py_DECREF(obj);
			4750	return returnValue;
			4751	}
			4752	}
			4753	return abstractExecFile::event(arg__1);
			4754	}
			4755	bool PythonQtShell_abstractExecFile::eventFilter(QObject* arg__1, QEvent* arg__2)
			4756	{
			4757	if (_wrapper) {
			4758	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "eventFilter");
			4759	PyErr_Clear();
			4760	if (obj && !PythonQtSlotFunction_Check(obj)) {
			4761	static const char* argumentList[] ={"bool" , "QObject" , "QEvent"};
			4762	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
			4763	bool returnValue;
			4764	void* args[3] = {NULL, (void)&arg__1, (void)&arg__2};
			4765	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			4766	if (result) {
			4767	args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
			4768	if (args[0]!=&returnValue) {
			4769	if (args[0]==NULL) {
			4770	PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
			4771	} else {
			4772	returnValue = ((bool)args[0]);
			4773	}
			4774	}
			4775	}
			4776	if (result) { Py_DECREF(result); }
			4777	Py_DECREF(obj);
			4778	return returnValue;
			4779	}
			4780	}
			4781	return abstractExecFile::eventFilter(arg__1, arg__2);
			4782	}
	756	QList<codeFragment* > PythonQtShell_abstractExecFile::getFragments()	4783	QList<codeFragment* > PythonQtShell_abstractExecFile::getFragments()
	757	{	4784	{
	758	if (_wrapper) {	4785	if (_wrapper) {
	759	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getFragments");	4786	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getFragments");
	760	PyErr_Clear();	4787	PyErr_Clear();
	761	if (obj && !PythonQtSlotFunction_Check(obj)) {	4788	if (obj && !PythonQtSlotFunction_Check(obj)) {
	762	static const char* argumentList[] ={"QList<codeFragment* >"};	4789	static const char* argumentList[] ={"QList<codeFragment* >"};
	763	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);	4790	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
	764	QList<codeFragment* > returnValue;	4791	QList<codeFragment* > returnValue;
	765	void* args[1] = {NULL};	4792	void* args[1] = {NULL};
	766	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);	4793	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
	767	if (result) {	4794	if (result) {
	768	args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);	4795	args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
	769	if (args[0]!=&returnValue) {	4796	if (args[0]!=&returnValue) {
	770	if (args[0]==NULL) {	4797	if (args[0]==NULL) {
	771	PythonQt::priv()->handleVirtualOverloadReturnError("getFragments", methodInfo, result);	4798	PythonQt::priv()->handleVirtualOverloadReturnError("getFragments", methodInfo, result);
	772	} else {	4799	} else {
	773	returnValue = ((QList<codeFragment >*)args[0]);	4800	returnValue = ((QList<codeFragment >*)args[0]);
	774	}	4801	}
	775	}	4802	}
	776	}	4803	}
	777	if (result) { Py_DECREF(result); }	4804	if (result) { Py_DECREF(result); }
	778	Py_DECREF(obj);	4805	Py_DECREF(obj);
	779	return returnValue;	4806	return returnValue;
	780	}	4807	}
	781	}	4808	}
	782	return QList<codeFragment* >();	4809	return QList<codeFragment* >();
	783	}	4810	}
	784	bool PythonQtShell_abstractExecFile::isopened()	4811	bool PythonQtShell_abstractExecFile::isopened()
	785	{	4812	{
	786	if (_wrapper) {	4813	if (_wrapper) {
	787	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "isopened");	4814	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "isopened");
	788	PyErr_Clear();	4815	PyErr_Clear();
	789	if (obj && !PythonQtSlotFunction_Check(obj)) {	4816	if (obj && !PythonQtSlotFunction_Check(obj)) {
	790	static const char* argumentList[] ={"bool"};	4817	static const char* argumentList[] ={"bool"};
	791	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);	4818	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
	792	bool returnValue;	4819	bool returnValue;
	793	void* args[1] = {NULL};	4820	void* args[1] = {NULL};
	794	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);	4821	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
	795	if (result) {	4822	if (result) {
	796	args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);	4823	args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
	797	if (args[0]!=&returnValue) {	4824	if (args[0]!=&returnValue) {
	798	if (args[0]==NULL) {	4825	if (args[0]==NULL) {
	799	PythonQt::priv()->handleVirtualOverloadReturnError("isopened", methodInfo, result);	4826	PythonQt::priv()->handleVirtualOverloadReturnError("isopened", methodInfo, result);
	800	} else {	4827	} else {
	801	returnValue = ((bool)args[0]);	4828	returnValue = ((bool)args[0]);
	802	}	4829	}
	803	}	4830	}
	804	}	4831	}
	805	if (result) { Py_DECREF(result); }	4832	if (result) { Py_DECREF(result); }
	806	Py_DECREF(obj);	4833	Py_DECREF(obj);
	807	return returnValue;	4834	return returnValue;
	808	}	4835	}
	809	}	4836	}
	810	return bool();	4837	return bool();
	811	}	4838	}
	812	bool PythonQtShell_abstractExecFile::openFile(const QString& File)	4839	bool PythonQtShell_abstractExecFile::openFile(const QString& File)
	813	{	4840	{
	814	if (_wrapper) {	4841	if (_wrapper) {
	815	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "openFile");	4842	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "openFile");
	816	PyErr_Clear();	4843	PyErr_Clear();
	817	if (obj && !PythonQtSlotFunction_Check(obj)) {	4844	if (obj && !PythonQtSlotFunction_Check(obj)) {
	818	static const char* argumentList[] ={"bool" , "const QString&"};	4845	static const char* argumentList[] ={"bool" , "const QString&"};
	819	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);	4846	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
	820	bool returnValue;	4847	bool returnValue;
	821	void* args[2] = {NULL, (void*)&File};	4848	void* args[2] = {NULL, (void*)&File};
	822	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);	4849	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
	823	if (result) {	4850	if (result) {
	824	args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);	4851	args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
	825	if (args[0]!=&returnValue) {	4852	if (args[0]!=&returnValue) {
	826	if (args[0]==NULL) {	4853	if (args[0]==NULL) {
	827	PythonQt::priv()->handleVirtualOverloadReturnError("openFile", methodInfo, result);	4854	PythonQt::priv()->handleVirtualOverloadReturnError("openFile", methodInfo, result);
	828	} else {	4855	} else {
	829	returnValue = ((bool)args[0]);	4856	returnValue = ((bool)args[0]);
	830	}	4857	}
	831	}	4858	}
	832	}	4859	}
	833	if (result) { Py_DECREF(result); }	4860	if (result) { Py_DECREF(result); }
	834	Py_DECREF(obj);	4861	Py_DECREF(obj);
	835	return returnValue;	4862	return returnValue;
	836	}	4863	}
	837	}	4864	}
	838	return bool();	4865	return bool();
	839	}	4866	}
			4867	void PythonQtShell_abstractExecFile::timerEvent(QTimerEvent* arg__1)
			4868	{
			4869	if (_wrapper) {
			4870	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "timerEvent");
			4871	PyErr_Clear();
			4872	if (obj && !PythonQtSlotFunction_Check(obj)) {
			4873	static const char* argumentList[] ={"" , "QTimerEvent*"};
			4874	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			4875	void* args[2] = {NULL, (void*)&arg__1};
			4876	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			4877	if (result) { Py_DECREF(result); }
			4878	Py_DECREF(obj);
			4879	return;
			4880	}
			4881	}
			4882	abstractExecFile::timerEvent(arg__1);
			4883	}
	840	abstractExecFile* PythonQtWrapper_abstractExecFile::new_abstractExecFile()	4884	abstractExecFile* PythonQtWrapper_abstractExecFile::new_abstractExecFile()
	841	{	4885	{
	842	return new PythonQtShell_abstractExecFile(); }	4886	return new PythonQtShell_abstractExecFile(); }
	843		4887
	844		4888
	845		4889
	846	PythonQtShell_codeFragment::~PythonQtShell_codeFragment() {	4890	PythonQtShell_codeFragment::~PythonQtShell_codeFragment() {
	847	PythonQtPrivate* priv = PythonQt::priv();	4891	PythonQtPrivate* priv = PythonQt::priv();
	848	if (priv) { priv->shellClassDeleted(this); }	4892	if (priv) { priv->shellClassDeleted(this); }
	849	}	4893	}
	850	codeFragment* PythonQtWrapper_codeFragment::new_codeFragment()	4894	codeFragment* PythonQtWrapper_codeFragment::new_codeFragment()
	851	{	4895	{
	852	return new PythonQtShell_codeFragment(); }	4896	return new PythonQtShell_codeFragment(); }
	853		4897
	854		4898	codeFragment* PythonQtWrapper_codeFragment::new_codeFragment(char* data, unsigned int size, unsigned int address)
	855		4899	{
			4900	return new PythonQtShell_codeFragment(data, size, address); }
			4901
			4902
			4903
			4904	PythonQtShell_elfFileWidget::~PythonQtShell_elfFileWidget() {
			4905	PythonQtPrivate* priv = PythonQt::priv();
			4906	if (priv) { priv->shellClassDeleted(this); }
			4907	}
			4908	void PythonQtShell_elfFileWidget::actionEvent(QActionEvent* arg__1)
			4909	{
			4910	if (_wrapper) {
			4911	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "actionEvent");
			4912	PyErr_Clear();
			4913	if (obj && !PythonQtSlotFunction_Check(obj)) {
			4914	static const char* argumentList[] ={"" , "QActionEvent*"};
			4915	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			4916	void* args[2] = {NULL, (void*)&arg__1};
			4917	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			4918	if (result) { Py_DECREF(result); }
			4919	Py_DECREF(obj);
			4920	return;
			4921	}
			4922	}
			4923	elfFileWidget::actionEvent(arg__1);
			4924	}
			4925	void PythonQtShell_elfFileWidget::changeEvent(QEvent* arg__1)
			4926	{
			4927	if (_wrapper) {
			4928	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "changeEvent");
			4929	PyErr_Clear();
			4930	if (obj && !PythonQtSlotFunction_Check(obj)) {
			4931	static const char* argumentList[] ={"" , "QEvent*"};
			4932	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			4933	void* args[2] = {NULL, (void*)&arg__1};
			4934	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			4935	if (result) { Py_DECREF(result); }
			4936	Py_DECREF(obj);
			4937	return;
			4938	}
			4939	}
			4940	elfFileWidget::changeEvent(arg__1);
			4941	}
			4942	void PythonQtShell_elfFileWidget::childEvent(QChildEvent* arg__1)
			4943	{
			4944	if (_wrapper) {
			4945	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "childEvent");
			4946	PyErr_Clear();
			4947	if (obj && !PythonQtSlotFunction_Check(obj)) {
			4948	static const char* argumentList[] ={"" , "QChildEvent*"};
			4949	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			4950	void* args[2] = {NULL, (void*)&arg__1};
			4951	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			4952	if (result) { Py_DECREF(result); }
			4953	Py_DECREF(obj);
			4954	return;
			4955	}
			4956	}
			4957	elfFileWidget::childEvent(arg__1);
			4958	}
			4959	void PythonQtShell_elfFileWidget::closeEvent(QCloseEvent* arg__1)
			4960	{
			4961	if (_wrapper) {
			4962	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "closeEvent");
			4963	PyErr_Clear();
			4964	if (obj && !PythonQtSlotFunction_Check(obj)) {
			4965	static const char* argumentList[] ={"" , "QCloseEvent*"};
			4966	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			4967	void* args[2] = {NULL, (void*)&arg__1};
			4968	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			4969	if (result) { Py_DECREF(result); }
			4970	Py_DECREF(obj);
			4971	return;
			4972	}
			4973	}
			4974	elfFileWidget::closeEvent(arg__1);
			4975	}
			4976	void PythonQtShell_elfFileWidget::contextMenuEvent(QContextMenuEvent* arg__1)
			4977	{
			4978	if (_wrapper) {
			4979	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "contextMenuEvent");
			4980	PyErr_Clear();
			4981	if (obj && !PythonQtSlotFunction_Check(obj)) {
			4982	static const char* argumentList[] ={"" , "QContextMenuEvent*"};
			4983	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			4984	void* args[2] = {NULL, (void*)&arg__1};
			4985	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			4986	if (result) { Py_DECREF(result); }
			4987	Py_DECREF(obj);
			4988	return;
			4989	}
			4990	}
			4991	elfFileWidget::contextMenuEvent(arg__1);
			4992	}
			4993	void PythonQtShell_elfFileWidget::customEvent(QEvent* arg__1)
			4994	{
			4995	if (_wrapper) {
			4996	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "customEvent");
			4997	PyErr_Clear();
			4998	if (obj && !PythonQtSlotFunction_Check(obj)) {
			4999	static const char* argumentList[] ={"" , "QEvent*"};
			5000	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			5001	void* args[2] = {NULL, (void*)&arg__1};
			5002	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			5003	if (result) { Py_DECREF(result); }
			5004	Py_DECREF(obj);
			5005	return;
			5006	}
			5007	}
			5008	elfFileWidget::customEvent(arg__1);
			5009	}
			5010	int PythonQtShell_elfFileWidget::devType() const
			5011	{
			5012	if (_wrapper) {
			5013	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "devType");
			5014	PyErr_Clear();
			5015	if (obj && !PythonQtSlotFunction_Check(obj)) {
			5016	static const char* argumentList[] ={"int"};
			5017	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
			5018	int returnValue;
			5019	void* args[1] = {NULL};
			5020	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			5021	if (result) {
			5022	args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
			5023	if (args[0]!=&returnValue) {
			5024	if (args[0]==NULL) {
			5025	PythonQt::priv()->handleVirtualOverloadReturnError("devType", methodInfo, result);
			5026	} else {
			5027	returnValue = ((int)args[0]);
			5028	}
			5029	}
			5030	}
			5031	if (result) { Py_DECREF(result); }
			5032	Py_DECREF(obj);
			5033	return returnValue;
			5034	}
			5035	}
			5036	return elfFileWidget::devType();
			5037	}
			5038	void PythonQtShell_elfFileWidget::dragEnterEvent(QDragEnterEvent* arg__1)
			5039	{
			5040	if (_wrapper) {
			5041	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragEnterEvent");
			5042	PyErr_Clear();
			5043	if (obj && !PythonQtSlotFunction_Check(obj)) {
			5044	static const char* argumentList[] ={"" , "QDragEnterEvent*"};
			5045	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			5046	void* args[2] = {NULL, (void*)&arg__1};
			5047	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			5048	if (result) { Py_DECREF(result); }
			5049	Py_DECREF(obj);
			5050	return;
			5051	}
			5052	}
			5053	elfFileWidget::dragEnterEvent(arg__1);
			5054	}
			5055	void PythonQtShell_elfFileWidget::dragLeaveEvent(QDragLeaveEvent* arg__1)
			5056	{
			5057	if (_wrapper) {
			5058	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragLeaveEvent");
			5059	PyErr_Clear();
			5060	if (obj && !PythonQtSlotFunction_Check(obj)) {
			5061	static const char* argumentList[] ={"" , "QDragLeaveEvent*"};
			5062	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			5063	void* args[2] = {NULL, (void*)&arg__1};
			5064	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			5065	if (result) { Py_DECREF(result); }
			5066	Py_DECREF(obj);
			5067	return;
			5068	}
			5069	}
			5070	elfFileWidget::dragLeaveEvent(arg__1);
			5071	}
			5072	void PythonQtShell_elfFileWidget::dragMoveEvent(QDragMoveEvent* arg__1)
			5073	{
			5074	if (_wrapper) {
			5075	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragMoveEvent");
			5076	PyErr_Clear();
			5077	if (obj && !PythonQtSlotFunction_Check(obj)) {
			5078	static const char* argumentList[] ={"" , "QDragMoveEvent*"};
			5079	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			5080	void* args[2] = {NULL, (void*)&arg__1};
			5081	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			5082	if (result) { Py_DECREF(result); }
			5083	Py_DECREF(obj);
			5084	return;
			5085	}
			5086	}
			5087	elfFileWidget::dragMoveEvent(arg__1);
			5088	}
			5089	void PythonQtShell_elfFileWidget::dropEvent(QDropEvent* arg__1)
			5090	{
			5091	if (_wrapper) {
			5092	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dropEvent");
			5093	PyErr_Clear();
			5094	if (obj && !PythonQtSlotFunction_Check(obj)) {
			5095	static const char* argumentList[] ={"" , "QDropEvent*"};
			5096	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			5097	void* args[2] = {NULL, (void*)&arg__1};
			5098	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			5099	if (result) { Py_DECREF(result); }
			5100	Py_DECREF(obj);
			5101	return;
			5102	}
			5103	}
			5104	elfFileWidget::dropEvent(arg__1);
			5105	}
			5106	void PythonQtShell_elfFileWidget::enterEvent(QEvent* arg__1)
			5107	{
			5108	if (_wrapper) {
			5109	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "enterEvent");
			5110	PyErr_Clear();
			5111	if (obj && !PythonQtSlotFunction_Check(obj)) {
			5112	static const char* argumentList[] ={"" , "QEvent*"};
			5113	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			5114	void* args[2] = {NULL, (void*)&arg__1};
			5115	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			5116	if (result) { Py_DECREF(result); }
			5117	Py_DECREF(obj);
			5118	return;
			5119	}
			5120	}
			5121	elfFileWidget::enterEvent(arg__1);
			5122	}
			5123	bool PythonQtShell_elfFileWidget::event(QEvent* arg__1)
			5124	{
			5125	if (_wrapper) {
			5126	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "event");
			5127	PyErr_Clear();
			5128	if (obj && !PythonQtSlotFunction_Check(obj)) {
			5129	static const char* argumentList[] ={"bool" , "QEvent*"};
			5130	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			5131	bool returnValue;
			5132	void* args[2] = {NULL, (void*)&arg__1};
			5133	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			5134	if (result) {
			5135	args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
			5136	if (args[0]!=&returnValue) {
			5137	if (args[0]==NULL) {
			5138	PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
			5139	} else {
			5140	returnValue = ((bool)args[0]);
			5141	}
			5142	}
			5143	}
			5144	if (result) { Py_DECREF(result); }
			5145	Py_DECREF(obj);
			5146	return returnValue;
			5147	}
			5148	}
			5149	return elfFileWidget::event(arg__1);
			5150	}
			5151	bool PythonQtShell_elfFileWidget::eventFilter(QObject* arg__1, QEvent* arg__2)
			5152	{
			5153	if (_wrapper) {
			5154	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "eventFilter");
			5155	PyErr_Clear();
			5156	if (obj && !PythonQtSlotFunction_Check(obj)) {
			5157	static const char* argumentList[] ={"bool" , "QObject" , "QEvent"};
			5158	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
			5159	bool returnValue;
			5160	void* args[3] = {NULL, (void)&arg__1, (void)&arg__2};
			5161	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			5162	if (result) {
			5163	args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
			5164	if (args[0]!=&returnValue) {
			5165	if (args[0]==NULL) {
			5166	PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
			5167	} else {
			5168	returnValue = ((bool)args[0]);
			5169	}
			5170	}
			5171	}
			5172	if (result) { Py_DECREF(result); }
			5173	Py_DECREF(obj);
			5174	return returnValue;
			5175	}
			5176	}
			5177	return elfFileWidget::eventFilter(arg__1, arg__2);
			5178	}
			5179	void PythonQtShell_elfFileWidget::focusInEvent(QFocusEvent* arg__1)
			5180	{
			5181	if (_wrapper) {
			5182	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusInEvent");
			5183	PyErr_Clear();
			5184	if (obj && !PythonQtSlotFunction_Check(obj)) {
			5185	static const char* argumentList[] ={"" , "QFocusEvent*"};
			5186	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			5187	void* args[2] = {NULL, (void*)&arg__1};
			5188	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			5189	if (result) { Py_DECREF(result); }
			5190	Py_DECREF(obj);
			5191	return;
			5192	}
			5193	}
			5194	elfFileWidget::focusInEvent(arg__1);
			5195	}
			5196	bool PythonQtShell_elfFileWidget::focusNextPrevChild(bool next)
			5197	{
			5198	if (_wrapper) {
			5199	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusNextPrevChild");
			5200	PyErr_Clear();
			5201	if (obj && !PythonQtSlotFunction_Check(obj)) {
			5202	static const char* argumentList[] ={"bool" , "bool"};
			5203	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			5204	bool returnValue;
			5205	void* args[2] = {NULL, (void*)&next};
			5206	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			5207	if (result) {
			5208	args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
			5209	if (args[0]!=&returnValue) {
			5210	if (args[0]==NULL) {
			5211	PythonQt::priv()->handleVirtualOverloadReturnError("focusNextPrevChild", methodInfo, result);
			5212	} else {
			5213	returnValue = ((bool)args[0]);
			5214	}
			5215	}
			5216	}
			5217	if (result) { Py_DECREF(result); }
			5218	Py_DECREF(obj);
			5219	return returnValue;
			5220	}
			5221	}
			5222	return elfFileWidget::focusNextPrevChild(next);
			5223	}
			5224	void PythonQtShell_elfFileWidget::focusOutEvent(QFocusEvent* arg__1)
			5225	{
			5226	if (_wrapper) {
			5227	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusOutEvent");
			5228	PyErr_Clear();
			5229	if (obj && !PythonQtSlotFunction_Check(obj)) {
			5230	static const char* argumentList[] ={"" , "QFocusEvent*"};
			5231	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			5232	void* args[2] = {NULL, (void*)&arg__1};
			5233	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			5234	if (result) { Py_DECREF(result); }
			5235	Py_DECREF(obj);
			5236	return;
			5237	}
			5238	}
			5239	elfFileWidget::focusOutEvent(arg__1);
			5240	}
			5241	bool PythonQtShell_elfFileWidget::hasHeightForWidth() const
			5242	{
			5243	if (_wrapper) {
			5244	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hasHeightForWidth");
			5245	PyErr_Clear();
			5246	if (obj && !PythonQtSlotFunction_Check(obj)) {
			5247	static const char* argumentList[] ={"bool"};
			5248	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
			5249	bool returnValue;
			5250	void* args[1] = {NULL};
			5251	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			5252	if (result) {
			5253	args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
			5254	if (args[0]!=&returnValue) {
			5255	if (args[0]==NULL) {
			5256	PythonQt::priv()->handleVirtualOverloadReturnError("hasHeightForWidth", methodInfo, result);
			5257	} else {
			5258	returnValue = ((bool)args[0]);
			5259	}
			5260	}
			5261	}
			5262	if (result) { Py_DECREF(result); }
			5263	Py_DECREF(obj);
			5264	return returnValue;
			5265	}
			5266	}
			5267	return elfFileWidget::hasHeightForWidth();
			5268	}
			5269	int PythonQtShell_elfFileWidget::heightForWidth(int arg__1) const
			5270	{
			5271	if (_wrapper) {
			5272	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "heightForWidth");
			5273	PyErr_Clear();
			5274	if (obj && !PythonQtSlotFunction_Check(obj)) {
			5275	static const char* argumentList[] ={"int" , "int"};
			5276	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			5277	int returnValue;
			5278	void* args[2] = {NULL, (void*)&arg__1};
			5279	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			5280	if (result) {
			5281	args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
			5282	if (args[0]!=&returnValue) {
			5283	if (args[0]==NULL) {
			5284	PythonQt::priv()->handleVirtualOverloadReturnError("heightForWidth", methodInfo, result);
			5285	} else {
			5286	returnValue = ((int)args[0]);
			5287	}
			5288	}
			5289	}
			5290	if (result) { Py_DECREF(result); }
			5291	Py_DECREF(obj);
			5292	return returnValue;
			5293	}
			5294	}
			5295	return elfFileWidget::heightForWidth(arg__1);
			5296	}
			5297	void PythonQtShell_elfFileWidget::hideEvent(QHideEvent* arg__1)
			5298	{
			5299	if (_wrapper) {
			5300	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hideEvent");
			5301	PyErr_Clear();
			5302	if (obj && !PythonQtSlotFunction_Check(obj)) {
			5303	static const char* argumentList[] ={"" , "QHideEvent*"};
			5304	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			5305	void* args[2] = {NULL, (void*)&arg__1};
			5306	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			5307	if (result) { Py_DECREF(result); }
			5308	Py_DECREF(obj);
			5309	return;
			5310	}
			5311	}
			5312	elfFileWidget::hideEvent(arg__1);
			5313	}
			5314	void PythonQtShell_elfFileWidget::initPainter(QPainter* painter) const
			5315	{
			5316	if (_wrapper) {
			5317	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "initPainter");
			5318	PyErr_Clear();
			5319	if (obj && !PythonQtSlotFunction_Check(obj)) {
			5320	static const char* argumentList[] ={"" , "QPainter*"};
			5321	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			5322	void* args[2] = {NULL, (void*)&painter};
			5323	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			5324	if (result) { Py_DECREF(result); }
			5325	Py_DECREF(obj);
			5326	return;
			5327	}
			5328	}
			5329	elfFileWidget::initPainter(painter);
			5330	}
			5331	void PythonQtShell_elfFileWidget::inputMethodEvent(QInputMethodEvent* arg__1)
			5332	{
			5333	if (_wrapper) {
			5334	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodEvent");
			5335	PyErr_Clear();
			5336	if (obj && !PythonQtSlotFunction_Check(obj)) {
			5337	static const char* argumentList[] ={"" , "QInputMethodEvent*"};
			5338	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			5339	void* args[2] = {NULL, (void*)&arg__1};
			5340	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			5341	if (result) { Py_DECREF(result); }
			5342	Py_DECREF(obj);
			5343	return;
			5344	}
			5345	}
			5346	elfFileWidget::inputMethodEvent(arg__1);
			5347	}
			5348	QVariant PythonQtShell_elfFileWidget::inputMethodQuery(Qt::InputMethodQuery arg__1) const
			5349	{
			5350	if (_wrapper) {
			5351	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodQuery");
			5352	PyErr_Clear();
			5353	if (obj && !PythonQtSlotFunction_Check(obj)) {
			5354	static const char* argumentList[] ={"QVariant" , "Qt::InputMethodQuery"};
			5355	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			5356	QVariant returnValue;
			5357	void* args[2] = {NULL, (void*)&arg__1};
			5358	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			5359	if (result) {
			5360	args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
			5361	if (args[0]!=&returnValue) {
			5362	if (args[0]==NULL) {
			5363	PythonQt::priv()->handleVirtualOverloadReturnError("inputMethodQuery", methodInfo, result);
			5364	} else {
			5365	returnValue = ((QVariant)args[0]);
			5366	}
			5367	}
			5368	}
			5369	if (result) { Py_DECREF(result); }
			5370	Py_DECREF(obj);
			5371	return returnValue;
			5372	}
			5373	}
			5374	return elfFileWidget::inputMethodQuery(arg__1);
			5375	}
			5376	void PythonQtShell_elfFileWidget::keyPressEvent(QKeyEvent* arg__1)
			5377	{
			5378	if (_wrapper) {
			5379	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyPressEvent");
			5380	PyErr_Clear();
			5381	if (obj && !PythonQtSlotFunction_Check(obj)) {
			5382	static const char* argumentList[] ={"" , "QKeyEvent*"};
			5383	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			5384	void* args[2] = {NULL, (void*)&arg__1};
			5385	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			5386	if (result) { Py_DECREF(result); }
			5387	Py_DECREF(obj);
			5388	return;
			5389	}
			5390	}
			5391	elfFileWidget::keyPressEvent(arg__1);
			5392	}
			5393	void PythonQtShell_elfFileWidget::keyReleaseEvent(QKeyEvent* arg__1)
			5394	{
			5395	if (_wrapper) {
			5396	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyReleaseEvent");
			5397	PyErr_Clear();
			5398	if (obj && !PythonQtSlotFunction_Check(obj)) {
			5399	static const char* argumentList[] ={"" , "QKeyEvent*"};
			5400	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			5401	void* args[2] = {NULL, (void*)&arg__1};
			5402	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			5403	if (result) { Py_DECREF(result); }
			5404	Py_DECREF(obj);
			5405	return;
			5406	}
			5407	}
			5408	elfFileWidget::keyReleaseEvent(arg__1);
			5409	}
			5410	void PythonQtShell_elfFileWidget::leaveEvent(QEvent* arg__1)
			5411	{
			5412	if (_wrapper) {
			5413	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "leaveEvent");
			5414	PyErr_Clear();
			5415	if (obj && !PythonQtSlotFunction_Check(obj)) {
			5416	static const char* argumentList[] ={"" , "QEvent*"};
			5417	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			5418	void* args[2] = {NULL, (void*)&arg__1};
			5419	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			5420	if (result) { Py_DECREF(result); }
			5421	Py_DECREF(obj);
			5422	return;
			5423	}
			5424	}
			5425	elfFileWidget::leaveEvent(arg__1);
			5426	}
			5427	int PythonQtShell_elfFileWidget::metric(QPaintDevice::PaintDeviceMetric arg__1) const
			5428	{
			5429	if (_wrapper) {
			5430	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "metric");
			5431	PyErr_Clear();
			5432	if (obj && !PythonQtSlotFunction_Check(obj)) {
			5433	static const char* argumentList[] ={"int" , "QPaintDevice::PaintDeviceMetric"};
			5434	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			5435	int returnValue;
			5436	void* args[2] = {NULL, (void*)&arg__1};
			5437	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			5438	if (result) {
			5439	args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
			5440	if (args[0]!=&returnValue) {
			5441	if (args[0]==NULL) {
			5442	PythonQt::priv()->handleVirtualOverloadReturnError("metric", methodInfo, result);
			5443	} else {
			5444	returnValue = ((int)args[0]);
			5445	}
			5446	}
			5447	}
			5448	if (result) { Py_DECREF(result); }
			5449	Py_DECREF(obj);
			5450	return returnValue;
			5451	}
			5452	}
			5453	return elfFileWidget::metric(arg__1);
			5454	}
			5455	QSize PythonQtShell_elfFileWidget::minimumSizeHint() const
			5456	{
			5457	if (_wrapper) {
			5458	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getMinimumSizeHint");
			5459	PyErr_Clear();
			5460	if (obj && !PythonQtSlotFunction_Check(obj)) {
			5461	static const char* argumentList[] ={"QSize"};
			5462	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
			5463	QSize returnValue;
			5464	void* args[1] = {NULL};
			5465	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			5466	if (result) {
			5467	args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
			5468	if (args[0]!=&returnValue) {
			5469	if (args[0]==NULL) {
			5470	PythonQt::priv()->handleVirtualOverloadReturnError("getMinimumSizeHint", methodInfo, result);
			5471	} else {
			5472	returnValue = ((QSize)args[0]);
			5473	}
			5474	}
			5475	}
			5476	if (result) { Py_DECREF(result); }
			5477	Py_DECREF(obj);
			5478	return returnValue;
			5479	}
			5480	}
			5481	return elfFileWidget::minimumSizeHint();
			5482	}
			5483	void PythonQtShell_elfFileWidget::mouseDoubleClickEvent(QMouseEvent* arg__1)
			5484	{
			5485	if (_wrapper) {
			5486	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseDoubleClickEvent");
			5487	PyErr_Clear();
			5488	if (obj && !PythonQtSlotFunction_Check(obj)) {
			5489	static const char* argumentList[] ={"" , "QMouseEvent*"};
			5490	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			5491	void* args[2] = {NULL, (void*)&arg__1};
			5492	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			5493	if (result) { Py_DECREF(result); }
			5494	Py_DECREF(obj);
			5495	return;
			5496	}
			5497	}
			5498	elfFileWidget::mouseDoubleClickEvent(arg__1);
			5499	}
			5500	void PythonQtShell_elfFileWidget::mouseMoveEvent(QMouseEvent* arg__1)
			5501	{
			5502	if (_wrapper) {
			5503	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseMoveEvent");
			5504	PyErr_Clear();
			5505	if (obj && !PythonQtSlotFunction_Check(obj)) {
			5506	static const char* argumentList[] ={"" , "QMouseEvent*"};
			5507	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			5508	void* args[2] = {NULL, (void*)&arg__1};
			5509	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			5510	if (result) { Py_DECREF(result); }
			5511	Py_DECREF(obj);
			5512	return;
			5513	}
			5514	}
			5515	elfFileWidget::mouseMoveEvent(arg__1);
			5516	}
			5517	void PythonQtShell_elfFileWidget::mousePressEvent(QMouseEvent* arg__1)
			5518	{
			5519	if (_wrapper) {
			5520	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mousePressEvent");
			5521	PyErr_Clear();
			5522	if (obj && !PythonQtSlotFunction_Check(obj)) {
			5523	static const char* argumentList[] ={"" , "QMouseEvent*"};
			5524	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			5525	void* args[2] = {NULL, (void*)&arg__1};
			5526	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			5527	if (result) { Py_DECREF(result); }
			5528	Py_DECREF(obj);
			5529	return;
			5530	}
			5531	}
			5532	elfFileWidget::mousePressEvent(arg__1);
			5533	}
			5534	void PythonQtShell_elfFileWidget::mouseReleaseEvent(QMouseEvent* arg__1)
			5535	{
			5536	if (_wrapper) {
			5537	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseReleaseEvent");
			5538	PyErr_Clear();
			5539	if (obj && !PythonQtSlotFunction_Check(obj)) {
			5540	static const char* argumentList[] ={"" , "QMouseEvent*"};
			5541	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			5542	void* args[2] = {NULL, (void*)&arg__1};
			5543	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			5544	if (result) { Py_DECREF(result); }
			5545	Py_DECREF(obj);
			5546	return;
			5547	}
			5548	}
			5549	elfFileWidget::mouseReleaseEvent(arg__1);
			5550	}
			5551	void PythonQtShell_elfFileWidget::moveEvent(QMoveEvent* arg__1)
			5552	{
			5553	if (_wrapper) {
			5554	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "moveEvent");
			5555	PyErr_Clear();
			5556	if (obj && !PythonQtSlotFunction_Check(obj)) {
			5557	static const char* argumentList[] ={"" , "QMoveEvent*"};
			5558	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			5559	void* args[2] = {NULL, (void*)&arg__1};
			5560	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			5561	if (result) { Py_DECREF(result); }
			5562	Py_DECREF(obj);
			5563	return;
			5564	}
			5565	}
			5566	elfFileWidget::moveEvent(arg__1);
			5567	}
			5568	bool PythonQtShell_elfFileWidget::nativeEvent(const QByteArray& eventType, void* message, long* result)
			5569	{
			5570	if (_wrapper) {
			5571	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "nativeEvent");
			5572	PyErr_Clear();
			5573	if (obj && !PythonQtSlotFunction_Check(obj)) {
			5574	static const char* argumentList[] ={"bool" , "const QByteArray&" , "void" , "long"};
			5575	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
			5576	bool returnValue;
			5577	void* args[4] = {NULL, (void)&eventType, (void)&message, (void*)&result};
			5578	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			5579	if (result) {
			5580	args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
			5581	if (args[0]!=&returnValue) {
			5582	if (args[0]==NULL) {
			5583	PythonQt::priv()->handleVirtualOverloadReturnError("nativeEvent", methodInfo, result);
			5584	} else {
			5585	returnValue = ((bool)args[0]);
			5586	}
			5587	}
			5588	}
			5589	if (result) { Py_DECREF(result); }
			5590	Py_DECREF(obj);
			5591	return returnValue;
			5592	}
			5593	}
			5594	return elfFileWidget::nativeEvent(eventType, message, result);
			5595	}
			5596	QPaintEngine* PythonQtShell_elfFileWidget::paintEngine() const
			5597	{
			5598	if (_wrapper) {
			5599	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEngine");
			5600	PyErr_Clear();
			5601	if (obj && !PythonQtSlotFunction_Check(obj)) {
			5602	static const char* argumentList[] ={"QPaintEngine*"};
			5603	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
			5604	QPaintEngine* returnValue;
			5605	void* args[1] = {NULL};
			5606	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			5607	if (result) {
			5608	args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
			5609	if (args[0]!=&returnValue) {
			5610	if (args[0]==NULL) {
			5611	PythonQt::priv()->handleVirtualOverloadReturnError("paintEngine", methodInfo, result);
			5612	} else {
			5613	returnValue = ((QPaintEngine*)args[0]);
			5614	}
			5615	}
			5616	}
			5617	if (result) { Py_DECREF(result); }
			5618	Py_DECREF(obj);
			5619	return returnValue;
			5620	}
			5621	}
			5622	return elfFileWidget::paintEngine();
			5623	}
			5624	void PythonQtShell_elfFileWidget::paintEvent(QPaintEvent* arg__1)
			5625	{
			5626	if (_wrapper) {
			5627	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEvent");
			5628	PyErr_Clear();
			5629	if (obj && !PythonQtSlotFunction_Check(obj)) {
			5630	static const char* argumentList[] ={"" , "QPaintEvent*"};
			5631	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			5632	void* args[2] = {NULL, (void*)&arg__1};
			5633	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			5634	if (result) { Py_DECREF(result); }
			5635	Py_DECREF(obj);
			5636	return;
			5637	}
			5638	}
			5639	elfFileWidget::paintEvent(arg__1);
			5640	}
			5641	QPaintDevice* PythonQtShell_elfFileWidget::redirected(QPoint* offset) const
			5642	{
			5643	if (_wrapper) {
			5644	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "redirected");
			5645	PyErr_Clear();
			5646	if (obj && !PythonQtSlotFunction_Check(obj)) {
			5647	static const char* argumentList[] ={"QPaintDevice" , "QPoint"};
			5648	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			5649	QPaintDevice* returnValue;
			5650	void* args[2] = {NULL, (void*)&offset};
			5651	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			5652	if (result) {
			5653	args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
			5654	if (args[0]!=&returnValue) {
			5655	if (args[0]==NULL) {
			5656	PythonQt::priv()->handleVirtualOverloadReturnError("redirected", methodInfo, result);
			5657	} else {
			5658	returnValue = ((QPaintDevice*)args[0]);
			5659	}
			5660	}
			5661	}
			5662	if (result) { Py_DECREF(result); }
			5663	Py_DECREF(obj);
			5664	return returnValue;
			5665	}
			5666	}
			5667	return elfFileWidget::redirected(offset);
			5668	}
			5669	void PythonQtShell_elfFileWidget::resizeEvent(QResizeEvent* arg__1)
			5670	{
			5671	if (_wrapper) {
			5672	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "resizeEvent");
			5673	PyErr_Clear();
			5674	if (obj && !PythonQtSlotFunction_Check(obj)) {
			5675	static const char* argumentList[] ={"" , "QResizeEvent*"};
			5676	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			5677	void* args[2] = {NULL, (void*)&arg__1};
			5678	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			5679	if (result) { Py_DECREF(result); }
			5680	Py_DECREF(obj);
			5681	return;
			5682	}
			5683	}
			5684	elfFileWidget::resizeEvent(arg__1);
			5685	}
			5686	QPainter* PythonQtShell_elfFileWidget::sharedPainter() const
			5687	{
			5688	if (_wrapper) {
			5689	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "sharedPainter");
			5690	PyErr_Clear();
			5691	if (obj && !PythonQtSlotFunction_Check(obj)) {
			5692	static const char* argumentList[] ={"QPainter*"};
			5693	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
			5694	QPainter* returnValue;
			5695	void* args[1] = {NULL};
			5696	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			5697	if (result) {
			5698	args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
			5699	if (args[0]!=&returnValue) {
			5700	if (args[0]==NULL) {
			5701	PythonQt::priv()->handleVirtualOverloadReturnError("sharedPainter", methodInfo, result);
			5702	} else {
			5703	returnValue = ((QPainter*)args[0]);
			5704	}
			5705	}
			5706	}
			5707	if (result) { Py_DECREF(result); }
			5708	Py_DECREF(obj);
			5709	return returnValue;
			5710	}
			5711	}
			5712	return elfFileWidget::sharedPainter();
			5713	}
			5714	void PythonQtShell_elfFileWidget::showEvent(QShowEvent* arg__1)
			5715	{
			5716	if (_wrapper) {
			5717	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "showEvent");
			5718	PyErr_Clear();
			5719	if (obj && !PythonQtSlotFunction_Check(obj)) {
			5720	static const char* argumentList[] ={"" , "QShowEvent*"};
			5721	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			5722	void* args[2] = {NULL, (void*)&arg__1};
			5723	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			5724	if (result) { Py_DECREF(result); }
			5725	Py_DECREF(obj);
			5726	return;
			5727	}
			5728	}
			5729	elfFileWidget::showEvent(arg__1);
			5730	}
			5731	QSize PythonQtShell_elfFileWidget::sizeHint() const
			5732	{
			5733	if (_wrapper) {
			5734	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getSizeHint");
			5735	PyErr_Clear();
			5736	if (obj && !PythonQtSlotFunction_Check(obj)) {
			5737	static const char* argumentList[] ={"QSize"};
			5738	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
			5739	QSize returnValue;
			5740	void* args[1] = {NULL};
			5741	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			5742	if (result) {
			5743	args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
			5744	if (args[0]!=&returnValue) {
			5745	if (args[0]==NULL) {
			5746	PythonQt::priv()->handleVirtualOverloadReturnError("getSizeHint", methodInfo, result);
			5747	} else {
			5748	returnValue = ((QSize)args[0]);
			5749	}
			5750	}
			5751	}
			5752	if (result) { Py_DECREF(result); }
			5753	Py_DECREF(obj);
			5754	return returnValue;
			5755	}
			5756	}
			5757	return elfFileWidget::sizeHint();
			5758	}
			5759	void PythonQtShell_elfFileWidget::tabletEvent(QTabletEvent* arg__1)
			5760	{
			5761	if (_wrapper) {
			5762	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "tabletEvent");
			5763	PyErr_Clear();
			5764	if (obj && !PythonQtSlotFunction_Check(obj)) {
			5765	static const char* argumentList[] ={"" , "QTabletEvent*"};
			5766	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			5767	void* args[2] = {NULL, (void*)&arg__1};
			5768	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			5769	if (result) { Py_DECREF(result); }
			5770	Py_DECREF(obj);
			5771	return;
			5772	}
			5773	}
			5774	elfFileWidget::tabletEvent(arg__1);
			5775	}
			5776	void PythonQtShell_elfFileWidget::timerEvent(QTimerEvent* arg__1)
			5777	{
			5778	if (_wrapper) {
			5779	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "timerEvent");
			5780	PyErr_Clear();
			5781	if (obj && !PythonQtSlotFunction_Check(obj)) {
			5782	static const char* argumentList[] ={"" , "QTimerEvent*"};
			5783	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			5784	void* args[2] = {NULL, (void*)&arg__1};
			5785	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			5786	if (result) { Py_DECREF(result); }
			5787	Py_DECREF(obj);
			5788	return;
			5789	}
			5790	}
			5791	elfFileWidget::timerEvent(arg__1);
			5792	}
			5793	void PythonQtShell_elfFileWidget::wheelEvent(QWheelEvent* arg__1)
			5794	{
			5795	if (_wrapper) {
			5796	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "wheelEvent");
			5797	PyErr_Clear();
			5798	if (obj && !PythonQtSlotFunction_Check(obj)) {
			5799	static const char* argumentList[] ={"" , "QWheelEvent*"};
			5800	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			5801	void* args[2] = {NULL, (void*)&arg__1};
			5802	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			5803	if (result) { Py_DECREF(result); }
			5804	Py_DECREF(obj);
			5805	return;
			5806	}
			5807	}
			5808	elfFileWidget::wheelEvent(arg__1);
			5809	}
	856	elfFileWidget* PythonQtWrapper_elfFileWidget::new_elfFileWidget(QWidget* parent)	5810	elfFileWidget* PythonQtWrapper_elfFileWidget::new_elfFileWidget(QWidget* parent)
	857	{	5811	{
	858	return new elfFileWidget(parent); }	5812	return new PythonQtShell_elfFileWidget(parent); }
	859		5813
	860		5814
	861		5815
			5816	PythonQtShell_elfInfoWdgt::~PythonQtShell_elfInfoWdgt() {
			5817	PythonQtPrivate* priv = PythonQt::priv();
			5818	if (priv) { priv->shellClassDeleted(this); }
			5819	}
			5820	void PythonQtShell_elfInfoWdgt::actionEvent(QActionEvent* arg__1)
			5821	{
			5822	if (_wrapper) {
			5823	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "actionEvent");
			5824	PyErr_Clear();
			5825	if (obj && !PythonQtSlotFunction_Check(obj)) {
			5826	static const char* argumentList[] ={"" , "QActionEvent*"};
			5827	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			5828	void* args[2] = {NULL, (void*)&arg__1};
			5829	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			5830	if (result) { Py_DECREF(result); }
			5831	Py_DECREF(obj);
			5832	return;
			5833	}
			5834	}
			5835	elfInfoWdgt::actionEvent(arg__1);
			5836	}
			5837	void PythonQtShell_elfInfoWdgt::changeEvent(QEvent* arg__1)
			5838	{
			5839	if (_wrapper) {
			5840	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "changeEvent");
			5841	PyErr_Clear();
			5842	if (obj && !PythonQtSlotFunction_Check(obj)) {
			5843	static const char* argumentList[] ={"" , "QEvent*"};
			5844	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			5845	void* args[2] = {NULL, (void*)&arg__1};
			5846	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			5847	if (result) { Py_DECREF(result); }
			5848	Py_DECREF(obj);
			5849	return;
			5850	}
			5851	}
			5852	elfInfoWdgt::changeEvent(arg__1);
			5853	}
			5854	void PythonQtShell_elfInfoWdgt::childEvent(QChildEvent* arg__1)
			5855	{
			5856	if (_wrapper) {
			5857	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "childEvent");
			5858	PyErr_Clear();
			5859	if (obj && !PythonQtSlotFunction_Check(obj)) {
			5860	static const char* argumentList[] ={"" , "QChildEvent*"};
			5861	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			5862	void* args[2] = {NULL, (void*)&arg__1};
			5863	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			5864	if (result) { Py_DECREF(result); }
			5865	Py_DECREF(obj);
			5866	return;
			5867	}
			5868	}
			5869	elfInfoWdgt::childEvent(arg__1);
			5870	}
			5871	void PythonQtShell_elfInfoWdgt::closeEvent(QCloseEvent* arg__1)
			5872	{
			5873	if (_wrapper) {
			5874	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "closeEvent");
			5875	PyErr_Clear();
			5876	if (obj && !PythonQtSlotFunction_Check(obj)) {
			5877	static const char* argumentList[] ={"" , "QCloseEvent*"};
			5878	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			5879	void* args[2] = {NULL, (void*)&arg__1};
			5880	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			5881	if (result) { Py_DECREF(result); }
			5882	Py_DECREF(obj);
			5883	return;
			5884	}
			5885	}
			5886	elfInfoWdgt::closeEvent(arg__1);
			5887	}
			5888	void PythonQtShell_elfInfoWdgt::contextMenuEvent(QContextMenuEvent* arg__1)
			5889	{
			5890	if (_wrapper) {
			5891	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "contextMenuEvent");
			5892	PyErr_Clear();
			5893	if (obj && !PythonQtSlotFunction_Check(obj)) {
			5894	static const char* argumentList[] ={"" , "QContextMenuEvent*"};
			5895	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			5896	void* args[2] = {NULL, (void*)&arg__1};
			5897	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			5898	if (result) { Py_DECREF(result); }
			5899	Py_DECREF(obj);
			5900	return;
			5901	}
			5902	}
			5903	elfInfoWdgt::contextMenuEvent(arg__1);
			5904	}
			5905	void PythonQtShell_elfInfoWdgt::customEvent(QEvent* arg__1)
			5906	{
			5907	if (_wrapper) {
			5908	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "customEvent");
			5909	PyErr_Clear();
			5910	if (obj && !PythonQtSlotFunction_Check(obj)) {
			5911	static const char* argumentList[] ={"" , "QEvent*"};
			5912	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			5913	void* args[2] = {NULL, (void*)&arg__1};
			5914	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			5915	if (result) { Py_DECREF(result); }
			5916	Py_DECREF(obj);
			5917	return;
			5918	}
			5919	}
			5920	elfInfoWdgt::customEvent(arg__1);
			5921	}
			5922	int PythonQtShell_elfInfoWdgt::devType() const
			5923	{
			5924	if (_wrapper) {
			5925	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "devType");
			5926	PyErr_Clear();
			5927	if (obj && !PythonQtSlotFunction_Check(obj)) {
			5928	static const char* argumentList[] ={"int"};
			5929	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
			5930	int returnValue;
			5931	void* args[1] = {NULL};
			5932	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			5933	if (result) {
			5934	args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
			5935	if (args[0]!=&returnValue) {
			5936	if (args[0]==NULL) {
			5937	PythonQt::priv()->handleVirtualOverloadReturnError("devType", methodInfo, result);
			5938	} else {
			5939	returnValue = ((int)args[0]);
			5940	}
			5941	}
			5942	}
			5943	if (result) { Py_DECREF(result); }
			5944	Py_DECREF(obj);
			5945	return returnValue;
			5946	}
			5947	}
			5948	return elfInfoWdgt::devType();
			5949	}
			5950	void PythonQtShell_elfInfoWdgt::dragEnterEvent(QDragEnterEvent* arg__1)
			5951	{
			5952	if (_wrapper) {
			5953	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragEnterEvent");
			5954	PyErr_Clear();
			5955	if (obj && !PythonQtSlotFunction_Check(obj)) {
			5956	static const char* argumentList[] ={"" , "QDragEnterEvent*"};
			5957	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			5958	void* args[2] = {NULL, (void*)&arg__1};
			5959	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			5960	if (result) { Py_DECREF(result); }
			5961	Py_DECREF(obj);
			5962	return;
			5963	}
			5964	}
			5965	elfInfoWdgt::dragEnterEvent(arg__1);
			5966	}
			5967	void PythonQtShell_elfInfoWdgt::dragLeaveEvent(QDragLeaveEvent* arg__1)
			5968	{
			5969	if (_wrapper) {
			5970	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragLeaveEvent");
			5971	PyErr_Clear();
			5972	if (obj && !PythonQtSlotFunction_Check(obj)) {
			5973	static const char* argumentList[] ={"" , "QDragLeaveEvent*"};
			5974	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			5975	void* args[2] = {NULL, (void*)&arg__1};
			5976	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			5977	if (result) { Py_DECREF(result); }
			5978	Py_DECREF(obj);
			5979	return;
			5980	}
			5981	}
			5982	elfInfoWdgt::dragLeaveEvent(arg__1);
			5983	}
			5984	void PythonQtShell_elfInfoWdgt::dragMoveEvent(QDragMoveEvent* arg__1)
			5985	{
			5986	if (_wrapper) {
			5987	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragMoveEvent");
			5988	PyErr_Clear();
			5989	if (obj && !PythonQtSlotFunction_Check(obj)) {
			5990	static const char* argumentList[] ={"" , "QDragMoveEvent*"};
			5991	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			5992	void* args[2] = {NULL, (void*)&arg__1};
			5993	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			5994	if (result) { Py_DECREF(result); }
			5995	Py_DECREF(obj);
			5996	return;
			5997	}
			5998	}
			5999	elfInfoWdgt::dragMoveEvent(arg__1);
			6000	}
			6001	void PythonQtShell_elfInfoWdgt::dropEvent(QDropEvent* arg__1)
			6002	{
			6003	if (_wrapper) {
			6004	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dropEvent");
			6005	PyErr_Clear();
			6006	if (obj && !PythonQtSlotFunction_Check(obj)) {
			6007	static const char* argumentList[] ={"" , "QDropEvent*"};
			6008	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			6009	void* args[2] = {NULL, (void*)&arg__1};
			6010	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			6011	if (result) { Py_DECREF(result); }
			6012	Py_DECREF(obj);
			6013	return;
			6014	}
			6015	}
			6016	elfInfoWdgt::dropEvent(arg__1);
			6017	}
			6018	void PythonQtShell_elfInfoWdgt::enterEvent(QEvent* arg__1)
			6019	{
			6020	if (_wrapper) {
			6021	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "enterEvent");
			6022	PyErr_Clear();
			6023	if (obj && !PythonQtSlotFunction_Check(obj)) {
			6024	static const char* argumentList[] ={"" , "QEvent*"};
			6025	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			6026	void* args[2] = {NULL, (void*)&arg__1};
			6027	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			6028	if (result) { Py_DECREF(result); }
			6029	Py_DECREF(obj);
			6030	return;
			6031	}
			6032	}
			6033	elfInfoWdgt::enterEvent(arg__1);
			6034	}
			6035	bool PythonQtShell_elfInfoWdgt::event(QEvent* arg__1)
			6036	{
			6037	if (_wrapper) {
			6038	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "event");
			6039	PyErr_Clear();
			6040	if (obj && !PythonQtSlotFunction_Check(obj)) {
			6041	static const char* argumentList[] ={"bool" , "QEvent*"};
			6042	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			6043	bool returnValue;
			6044	void* args[2] = {NULL, (void*)&arg__1};
			6045	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			6046	if (result) {
			6047	args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
			6048	if (args[0]!=&returnValue) {
			6049	if (args[0]==NULL) {
			6050	PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
			6051	} else {
			6052	returnValue = ((bool)args[0]);
			6053	}
			6054	}
			6055	}
			6056	if (result) { Py_DECREF(result); }
			6057	Py_DECREF(obj);
			6058	return returnValue;
			6059	}
			6060	}
			6061	return elfInfoWdgt::event(arg__1);
			6062	}
			6063	bool PythonQtShell_elfInfoWdgt::eventFilter(QObject* arg__1, QEvent* arg__2)
			6064	{
			6065	if (_wrapper) {
			6066	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "eventFilter");
			6067	PyErr_Clear();
			6068	if (obj && !PythonQtSlotFunction_Check(obj)) {
			6069	static const char* argumentList[] ={"bool" , "QObject" , "QEvent"};
			6070	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
			6071	bool returnValue;
			6072	void* args[3] = {NULL, (void)&arg__1, (void)&arg__2};
			6073	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			6074	if (result) {
			6075	args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
			6076	if (args[0]!=&returnValue) {
			6077	if (args[0]==NULL) {
			6078	PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
			6079	} else {
			6080	returnValue = ((bool)args[0]);
			6081	}
			6082	}
			6083	}
			6084	if (result) { Py_DECREF(result); }
			6085	Py_DECREF(obj);
			6086	return returnValue;
			6087	}
			6088	}
			6089	return elfInfoWdgt::eventFilter(arg__1, arg__2);
			6090	}
			6091	void PythonQtShell_elfInfoWdgt::focusInEvent(QFocusEvent* arg__1)
			6092	{
			6093	if (_wrapper) {
			6094	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusInEvent");
			6095	PyErr_Clear();
			6096	if (obj && !PythonQtSlotFunction_Check(obj)) {
			6097	static const char* argumentList[] ={"" , "QFocusEvent*"};
			6098	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			6099	void* args[2] = {NULL, (void*)&arg__1};
			6100	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			6101	if (result) { Py_DECREF(result); }
			6102	Py_DECREF(obj);
			6103	return;
			6104	}
			6105	}
			6106	elfInfoWdgt::focusInEvent(arg__1);
			6107	}
			6108	bool PythonQtShell_elfInfoWdgt::focusNextPrevChild(bool next)
			6109	{
			6110	if (_wrapper) {
			6111	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusNextPrevChild");
			6112	PyErr_Clear();
			6113	if (obj && !PythonQtSlotFunction_Check(obj)) {
			6114	static const char* argumentList[] ={"bool" , "bool"};
			6115	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			6116	bool returnValue;
			6117	void* args[2] = {NULL, (void*)&next};
			6118	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			6119	if (result) {
			6120	args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
			6121	if (args[0]!=&returnValue) {
			6122	if (args[0]==NULL) {
			6123	PythonQt::priv()->handleVirtualOverloadReturnError("focusNextPrevChild", methodInfo, result);
			6124	} else {
			6125	returnValue = ((bool)args[0]);
			6126	}
			6127	}
			6128	}
			6129	if (result) { Py_DECREF(result); }
			6130	Py_DECREF(obj);
			6131	return returnValue;
			6132	}
			6133	}
			6134	return elfInfoWdgt::focusNextPrevChild(next);
			6135	}
			6136	void PythonQtShell_elfInfoWdgt::focusOutEvent(QFocusEvent* arg__1)
			6137	{
			6138	if (_wrapper) {
			6139	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusOutEvent");
			6140	PyErr_Clear();
			6141	if (obj && !PythonQtSlotFunction_Check(obj)) {
			6142	static const char* argumentList[] ={"" , "QFocusEvent*"};
			6143	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			6144	void* args[2] = {NULL, (void*)&arg__1};
			6145	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			6146	if (result) { Py_DECREF(result); }
			6147	Py_DECREF(obj);
			6148	return;
			6149	}
			6150	}
			6151	elfInfoWdgt::focusOutEvent(arg__1);
			6152	}
			6153	bool PythonQtShell_elfInfoWdgt::hasHeightForWidth() const
			6154	{
			6155	if (_wrapper) {
			6156	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hasHeightForWidth");
			6157	PyErr_Clear();
			6158	if (obj && !PythonQtSlotFunction_Check(obj)) {
			6159	static const char* argumentList[] ={"bool"};
			6160	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
			6161	bool returnValue;
			6162	void* args[1] = {NULL};
			6163	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			6164	if (result) {
			6165	args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
			6166	if (args[0]!=&returnValue) {
			6167	if (args[0]==NULL) {
			6168	PythonQt::priv()->handleVirtualOverloadReturnError("hasHeightForWidth", methodInfo, result);
			6169	} else {
			6170	returnValue = ((bool)args[0]);
			6171	}
			6172	}
			6173	}
			6174	if (result) { Py_DECREF(result); }
			6175	Py_DECREF(obj);
			6176	return returnValue;
			6177	}
			6178	}
			6179	return elfInfoWdgt::hasHeightForWidth();
			6180	}
			6181	int PythonQtShell_elfInfoWdgt::heightForWidth(int arg__1) const
			6182	{
			6183	if (_wrapper) {
			6184	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "heightForWidth");
			6185	PyErr_Clear();
			6186	if (obj && !PythonQtSlotFunction_Check(obj)) {
			6187	static const char* argumentList[] ={"int" , "int"};
			6188	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			6189	int returnValue;
			6190	void* args[2] = {NULL, (void*)&arg__1};
			6191	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			6192	if (result) {
			6193	args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
			6194	if (args[0]!=&returnValue) {
			6195	if (args[0]==NULL) {
			6196	PythonQt::priv()->handleVirtualOverloadReturnError("heightForWidth", methodInfo, result);
			6197	} else {
			6198	returnValue = ((int)args[0]);
			6199	}
			6200	}
			6201	}
			6202	if (result) { Py_DECREF(result); }
			6203	Py_DECREF(obj);
			6204	return returnValue;
			6205	}
			6206	}
			6207	return elfInfoWdgt::heightForWidth(arg__1);
			6208	}
			6209	void PythonQtShell_elfInfoWdgt::hideEvent(QHideEvent* arg__1)
			6210	{
			6211	if (_wrapper) {
			6212	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hideEvent");
			6213	PyErr_Clear();
			6214	if (obj && !PythonQtSlotFunction_Check(obj)) {
			6215	static const char* argumentList[] ={"" , "QHideEvent*"};
			6216	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			6217	void* args[2] = {NULL, (void*)&arg__1};
			6218	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			6219	if (result) { Py_DECREF(result); }
			6220	Py_DECREF(obj);
			6221	return;
			6222	}
			6223	}
			6224	elfInfoWdgt::hideEvent(arg__1);
			6225	}
			6226	void PythonQtShell_elfInfoWdgt::initPainter(QPainter* painter) const
			6227	{
			6228	if (_wrapper) {
			6229	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "initPainter");
			6230	PyErr_Clear();
			6231	if (obj && !PythonQtSlotFunction_Check(obj)) {
			6232	static const char* argumentList[] ={"" , "QPainter*"};
			6233	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			6234	void* args[2] = {NULL, (void*)&painter};
			6235	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			6236	if (result) { Py_DECREF(result); }
			6237	Py_DECREF(obj);
			6238	return;
			6239	}
			6240	}
			6241	elfInfoWdgt::initPainter(painter);
			6242	}
			6243	void PythonQtShell_elfInfoWdgt::inputMethodEvent(QInputMethodEvent* arg__1)
			6244	{
			6245	if (_wrapper) {
			6246	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodEvent");
			6247	PyErr_Clear();
			6248	if (obj && !PythonQtSlotFunction_Check(obj)) {
			6249	static const char* argumentList[] ={"" , "QInputMethodEvent*"};
			6250	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			6251	void* args[2] = {NULL, (void*)&arg__1};
			6252	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			6253	if (result) { Py_DECREF(result); }
			6254	Py_DECREF(obj);
			6255	return;
			6256	}
			6257	}
			6258	elfInfoWdgt::inputMethodEvent(arg__1);
			6259	}
			6260	QVariant PythonQtShell_elfInfoWdgt::inputMethodQuery(Qt::InputMethodQuery arg__1) const
			6261	{
			6262	if (_wrapper) {
			6263	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodQuery");
			6264	PyErr_Clear();
			6265	if (obj && !PythonQtSlotFunction_Check(obj)) {
			6266	static const char* argumentList[] ={"QVariant" , "Qt::InputMethodQuery"};
			6267	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			6268	QVariant returnValue;
			6269	void* args[2] = {NULL, (void*)&arg__1};
			6270	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			6271	if (result) {
			6272	args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
			6273	if (args[0]!=&returnValue) {
			6274	if (args[0]==NULL) {
			6275	PythonQt::priv()->handleVirtualOverloadReturnError("inputMethodQuery", methodInfo, result);
			6276	} else {
			6277	returnValue = ((QVariant)args[0]);
			6278	}
			6279	}
			6280	}
			6281	if (result) { Py_DECREF(result); }
			6282	Py_DECREF(obj);
			6283	return returnValue;
			6284	}
			6285	}
			6286	return elfInfoWdgt::inputMethodQuery(arg__1);
			6287	}
			6288	void PythonQtShell_elfInfoWdgt::keyPressEvent(QKeyEvent* arg__1)
			6289	{
			6290	if (_wrapper) {
			6291	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyPressEvent");
			6292	PyErr_Clear();
			6293	if (obj && !PythonQtSlotFunction_Check(obj)) {
			6294	static const char* argumentList[] ={"" , "QKeyEvent*"};
			6295	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			6296	void* args[2] = {NULL, (void*)&arg__1};
			6297	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			6298	if (result) { Py_DECREF(result); }
			6299	Py_DECREF(obj);
			6300	return;
			6301	}
			6302	}
			6303	elfInfoWdgt::keyPressEvent(arg__1);
			6304	}
			6305	void PythonQtShell_elfInfoWdgt::keyReleaseEvent(QKeyEvent* arg__1)
			6306	{
			6307	if (_wrapper) {
			6308	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyReleaseEvent");
			6309	PyErr_Clear();
			6310	if (obj && !PythonQtSlotFunction_Check(obj)) {
			6311	static const char* argumentList[] ={"" , "QKeyEvent*"};
			6312	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			6313	void* args[2] = {NULL, (void*)&arg__1};
			6314	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			6315	if (result) { Py_DECREF(result); }
			6316	Py_DECREF(obj);
			6317	return;
			6318	}
			6319	}
			6320	elfInfoWdgt::keyReleaseEvent(arg__1);
			6321	}
			6322	void PythonQtShell_elfInfoWdgt::leaveEvent(QEvent* arg__1)
			6323	{
			6324	if (_wrapper) {
			6325	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "leaveEvent");
			6326	PyErr_Clear();
			6327	if (obj && !PythonQtSlotFunction_Check(obj)) {
			6328	static const char* argumentList[] ={"" , "QEvent*"};
			6329	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			6330	void* args[2] = {NULL, (void*)&arg__1};
			6331	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			6332	if (result) { Py_DECREF(result); }
			6333	Py_DECREF(obj);
			6334	return;
			6335	}
			6336	}
			6337	elfInfoWdgt::leaveEvent(arg__1);
			6338	}
			6339	int PythonQtShell_elfInfoWdgt::metric(QPaintDevice::PaintDeviceMetric arg__1) const
			6340	{
			6341	if (_wrapper) {
			6342	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "metric");
			6343	PyErr_Clear();
			6344	if (obj && !PythonQtSlotFunction_Check(obj)) {
			6345	static const char* argumentList[] ={"int" , "QPaintDevice::PaintDeviceMetric"};
			6346	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			6347	int returnValue;
			6348	void* args[2] = {NULL, (void*)&arg__1};
			6349	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			6350	if (result) {
			6351	args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
			6352	if (args[0]!=&returnValue) {
			6353	if (args[0]==NULL) {
			6354	PythonQt::priv()->handleVirtualOverloadReturnError("metric", methodInfo, result);
			6355	} else {
			6356	returnValue = ((int)args[0]);
			6357	}
			6358	}
			6359	}
			6360	if (result) { Py_DECREF(result); }
			6361	Py_DECREF(obj);
			6362	return returnValue;
			6363	}
			6364	}
			6365	return elfInfoWdgt::metric(arg__1);
			6366	}
			6367	QSize PythonQtShell_elfInfoWdgt::minimumSizeHint() const
			6368	{
			6369	if (_wrapper) {
			6370	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getMinimumSizeHint");
			6371	PyErr_Clear();
			6372	if (obj && !PythonQtSlotFunction_Check(obj)) {
			6373	static const char* argumentList[] ={"QSize"};
			6374	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
			6375	QSize returnValue;
			6376	void* args[1] = {NULL};
			6377	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			6378	if (result) {
			6379	args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
			6380	if (args[0]!=&returnValue) {
			6381	if (args[0]==NULL) {
			6382	PythonQt::priv()->handleVirtualOverloadReturnError("getMinimumSizeHint", methodInfo, result);
			6383	} else {
			6384	returnValue = ((QSize)args[0]);
			6385	}
			6386	}
			6387	}
			6388	if (result) { Py_DECREF(result); }
			6389	Py_DECREF(obj);
			6390	return returnValue;
			6391	}
			6392	}
			6393	return elfInfoWdgt::minimumSizeHint();
			6394	}
			6395	void PythonQtShell_elfInfoWdgt::mouseDoubleClickEvent(QMouseEvent* arg__1)
			6396	{
			6397	if (_wrapper) {
			6398	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseDoubleClickEvent");
			6399	PyErr_Clear();
			6400	if (obj && !PythonQtSlotFunction_Check(obj)) {
			6401	static const char* argumentList[] ={"" , "QMouseEvent*"};
			6402	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			6403	void* args[2] = {NULL, (void*)&arg__1};
			6404	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			6405	if (result) { Py_DECREF(result); }
			6406	Py_DECREF(obj);
			6407	return;
			6408	}
			6409	}
			6410	elfInfoWdgt::mouseDoubleClickEvent(arg__1);
			6411	}
			6412	void PythonQtShell_elfInfoWdgt::mouseMoveEvent(QMouseEvent* arg__1)
			6413	{
			6414	if (_wrapper) {
			6415	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseMoveEvent");
			6416	PyErr_Clear();
			6417	if (obj && !PythonQtSlotFunction_Check(obj)) {
			6418	static const char* argumentList[] ={"" , "QMouseEvent*"};
			6419	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			6420	void* args[2] = {NULL, (void*)&arg__1};
			6421	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			6422	if (result) { Py_DECREF(result); }
			6423	Py_DECREF(obj);
			6424	return;
			6425	}
			6426	}
			6427	elfInfoWdgt::mouseMoveEvent(arg__1);
			6428	}
			6429	void PythonQtShell_elfInfoWdgt::mousePressEvent(QMouseEvent* arg__1)
			6430	{
			6431	if (_wrapper) {
			6432	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mousePressEvent");
			6433	PyErr_Clear();
			6434	if (obj && !PythonQtSlotFunction_Check(obj)) {
			6435	static const char* argumentList[] ={"" , "QMouseEvent*"};
			6436	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			6437	void* args[2] = {NULL, (void*)&arg__1};
			6438	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			6439	if (result) { Py_DECREF(result); }
			6440	Py_DECREF(obj);
			6441	return;
			6442	}
			6443	}
			6444	elfInfoWdgt::mousePressEvent(arg__1);
			6445	}
			6446	void PythonQtShell_elfInfoWdgt::mouseReleaseEvent(QMouseEvent* arg__1)
			6447	{
			6448	if (_wrapper) {
			6449	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseReleaseEvent");
			6450	PyErr_Clear();
			6451	if (obj && !PythonQtSlotFunction_Check(obj)) {
			6452	static const char* argumentList[] ={"" , "QMouseEvent*"};
			6453	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			6454	void* args[2] = {NULL, (void*)&arg__1};
			6455	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			6456	if (result) { Py_DECREF(result); }
			6457	Py_DECREF(obj);
			6458	return;
			6459	}
			6460	}
			6461	elfInfoWdgt::mouseReleaseEvent(arg__1);
			6462	}
			6463	void PythonQtShell_elfInfoWdgt::moveEvent(QMoveEvent* arg__1)
			6464	{
			6465	if (_wrapper) {
			6466	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "moveEvent");
			6467	PyErr_Clear();
			6468	if (obj && !PythonQtSlotFunction_Check(obj)) {
			6469	static const char* argumentList[] ={"" , "QMoveEvent*"};
			6470	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			6471	void* args[2] = {NULL, (void*)&arg__1};
			6472	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			6473	if (result) { Py_DECREF(result); }
			6474	Py_DECREF(obj);
			6475	return;
			6476	}
			6477	}
			6478	elfInfoWdgt::moveEvent(arg__1);
			6479	}
			6480	bool PythonQtShell_elfInfoWdgt::nativeEvent(const QByteArray& eventType, void* message, long* result)
			6481	{
			6482	if (_wrapper) {
			6483	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "nativeEvent");
			6484	PyErr_Clear();
			6485	if (obj && !PythonQtSlotFunction_Check(obj)) {
			6486	static const char* argumentList[] ={"bool" , "const QByteArray&" , "void" , "long"};
			6487	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
			6488	bool returnValue;
			6489	void* args[4] = {NULL, (void)&eventType, (void)&message, (void*)&result};
			6490	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			6491	if (result) {
			6492	args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
			6493	if (args[0]!=&returnValue) {
			6494	if (args[0]==NULL) {
			6495	PythonQt::priv()->handleVirtualOverloadReturnError("nativeEvent", methodInfo, result);
			6496	} else {
			6497	returnValue = ((bool)args[0]);
			6498	}
			6499	}
			6500	}
			6501	if (result) { Py_DECREF(result); }
			6502	Py_DECREF(obj);
			6503	return returnValue;
			6504	}
			6505	}
			6506	return elfInfoWdgt::nativeEvent(eventType, message, result);
			6507	}
			6508	QPaintEngine* PythonQtShell_elfInfoWdgt::paintEngine() const
			6509	{
			6510	if (_wrapper) {
			6511	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEngine");
			6512	PyErr_Clear();
			6513	if (obj && !PythonQtSlotFunction_Check(obj)) {
			6514	static const char* argumentList[] ={"QPaintEngine*"};
			6515	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
			6516	QPaintEngine* returnValue;
			6517	void* args[1] = {NULL};
			6518	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			6519	if (result) {
			6520	args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
			6521	if (args[0]!=&returnValue) {
			6522	if (args[0]==NULL) {
			6523	PythonQt::priv()->handleVirtualOverloadReturnError("paintEngine", methodInfo, result);
			6524	} else {
			6525	returnValue = ((QPaintEngine*)args[0]);
			6526	}
			6527	}
			6528	}
			6529	if (result) { Py_DECREF(result); }
			6530	Py_DECREF(obj);
			6531	return returnValue;
			6532	}
			6533	}
			6534	return elfInfoWdgt::paintEngine();
			6535	}
			6536	void PythonQtShell_elfInfoWdgt::paintEvent(QPaintEvent* arg__1)
			6537	{
			6538	if (_wrapper) {
			6539	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEvent");
			6540	PyErr_Clear();
			6541	if (obj && !PythonQtSlotFunction_Check(obj)) {
			6542	static const char* argumentList[] ={"" , "QPaintEvent*"};
			6543	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			6544	void* args[2] = {NULL, (void*)&arg__1};
			6545	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			6546	if (result) { Py_DECREF(result); }
			6547	Py_DECREF(obj);
			6548	return;
			6549	}
			6550	}
			6551	elfInfoWdgt::paintEvent(arg__1);
			6552	}
			6553	QPaintDevice* PythonQtShell_elfInfoWdgt::redirected(QPoint* offset) const
			6554	{
			6555	if (_wrapper) {
			6556	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "redirected");
			6557	PyErr_Clear();
			6558	if (obj && !PythonQtSlotFunction_Check(obj)) {
			6559	static const char* argumentList[] ={"QPaintDevice" , "QPoint"};
			6560	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			6561	QPaintDevice* returnValue;
			6562	void* args[2] = {NULL, (void*)&offset};
			6563	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			6564	if (result) {
			6565	args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
			6566	if (args[0]!=&returnValue) {
			6567	if (args[0]==NULL) {
			6568	PythonQt::priv()->handleVirtualOverloadReturnError("redirected", methodInfo, result);
			6569	} else {
			6570	returnValue = ((QPaintDevice*)args[0]);
			6571	}
			6572	}
			6573	}
			6574	if (result) { Py_DECREF(result); }
			6575	Py_DECREF(obj);
			6576	return returnValue;
			6577	}
			6578	}
			6579	return elfInfoWdgt::redirected(offset);
			6580	}
			6581	void PythonQtShell_elfInfoWdgt::resizeEvent(QResizeEvent* arg__1)
			6582	{
			6583	if (_wrapper) {
			6584	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "resizeEvent");
			6585	PyErr_Clear();
			6586	if (obj && !PythonQtSlotFunction_Check(obj)) {
			6587	static const char* argumentList[] ={"" , "QResizeEvent*"};
			6588	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			6589	void* args[2] = {NULL, (void*)&arg__1};
			6590	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			6591	if (result) { Py_DECREF(result); }
			6592	Py_DECREF(obj);
			6593	return;
			6594	}
			6595	}
			6596	elfInfoWdgt::resizeEvent(arg__1);
			6597	}
			6598	QPainter* PythonQtShell_elfInfoWdgt::sharedPainter() const
			6599	{
			6600	if (_wrapper) {
			6601	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "sharedPainter");
			6602	PyErr_Clear();
			6603	if (obj && !PythonQtSlotFunction_Check(obj)) {
			6604	static const char* argumentList[] ={"QPainter*"};
			6605	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
			6606	QPainter* returnValue;
			6607	void* args[1] = {NULL};
			6608	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			6609	if (result) {
			6610	args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
			6611	if (args[0]!=&returnValue) {
			6612	if (args[0]==NULL) {
			6613	PythonQt::priv()->handleVirtualOverloadReturnError("sharedPainter", methodInfo, result);
			6614	} else {
			6615	returnValue = ((QPainter*)args[0]);
			6616	}
			6617	}
			6618	}
			6619	if (result) { Py_DECREF(result); }
			6620	Py_DECREF(obj);
			6621	return returnValue;
			6622	}
			6623	}
			6624	return elfInfoWdgt::sharedPainter();
			6625	}
			6626	void PythonQtShell_elfInfoWdgt::showEvent(QShowEvent* arg__1)
			6627	{
			6628	if (_wrapper) {
			6629	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "showEvent");
			6630	PyErr_Clear();
			6631	if (obj && !PythonQtSlotFunction_Check(obj)) {
			6632	static const char* argumentList[] ={"" , "QShowEvent*"};
			6633	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			6634	void* args[2] = {NULL, (void*)&arg__1};
			6635	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			6636	if (result) { Py_DECREF(result); }
			6637	Py_DECREF(obj);
			6638	return;
			6639	}
			6640	}
			6641	elfInfoWdgt::showEvent(arg__1);
			6642	}
			6643	QSize PythonQtShell_elfInfoWdgt::sizeHint() const
			6644	{
			6645	if (_wrapper) {
			6646	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getSizeHint");
			6647	PyErr_Clear();
			6648	if (obj && !PythonQtSlotFunction_Check(obj)) {
			6649	static const char* argumentList[] ={"QSize"};
			6650	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
			6651	QSize returnValue;
			6652	void* args[1] = {NULL};
			6653	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			6654	if (result) {
			6655	args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
			6656	if (args[0]!=&returnValue) {
			6657	if (args[0]==NULL) {
			6658	PythonQt::priv()->handleVirtualOverloadReturnError("getSizeHint", methodInfo, result);
			6659	} else {
			6660	returnValue = ((QSize)args[0]);
			6661	}
			6662	}
			6663	}
			6664	if (result) { Py_DECREF(result); }
			6665	Py_DECREF(obj);
			6666	return returnValue;
			6667	}
			6668	}
			6669	return elfInfoWdgt::sizeHint();
			6670	}
			6671	void PythonQtShell_elfInfoWdgt::tabletEvent(QTabletEvent* arg__1)
			6672	{
			6673	if (_wrapper) {
			6674	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "tabletEvent");
			6675	PyErr_Clear();
			6676	if (obj && !PythonQtSlotFunction_Check(obj)) {
			6677	static const char* argumentList[] ={"" , "QTabletEvent*"};
			6678	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			6679	void* args[2] = {NULL, (void*)&arg__1};
			6680	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			6681	if (result) { Py_DECREF(result); }
			6682	Py_DECREF(obj);
			6683	return;
			6684	}
			6685	}
			6686	elfInfoWdgt::tabletEvent(arg__1);
			6687	}
			6688	void PythonQtShell_elfInfoWdgt::timerEvent(QTimerEvent* arg__1)
			6689	{
			6690	if (_wrapper) {
			6691	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "timerEvent");
			6692	PyErr_Clear();
			6693	if (obj && !PythonQtSlotFunction_Check(obj)) {
			6694	static const char* argumentList[] ={"" , "QTimerEvent*"};
			6695	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			6696	void* args[2] = {NULL, (void*)&arg__1};
			6697	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			6698	if (result) { Py_DECREF(result); }
			6699	Py_DECREF(obj);
			6700	return;
			6701	}
			6702	}
			6703	elfInfoWdgt::timerEvent(arg__1);
			6704	}
			6705	void PythonQtShell_elfInfoWdgt::wheelEvent(QWheelEvent* arg__1)
			6706	{
			6707	if (_wrapper) {
			6708	PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "wheelEvent");
			6709	PyErr_Clear();
			6710	if (obj && !PythonQtSlotFunction_Check(obj)) {
			6711	static const char* argumentList[] ={"" , "QWheelEvent*"};
			6712	static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
			6713	void* args[2] = {NULL, (void*)&arg__1};
			6714	PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
			6715	if (result) { Py_DECREF(result); }
			6716	Py_DECREF(obj);
			6717	return;
			6718	}
			6719	}
			6720	elfInfoWdgt::wheelEvent(arg__1);
			6721	}
	862	elfInfoWdgt* PythonQtWrapper_elfInfoWdgt::new_elfInfoWdgt(QWidget* parent)	6722	elfInfoWdgt* PythonQtWrapper_elfInfoWdgt::new_elfInfoWdgt(QWidget* parent)
	863	{	6723	{
	864	return new elfInfoWdgt(parent); }	6724	return new PythonQtShell_elfInfoWdgt(parent); }
	865		6725
	866		6726
	867		6727
	868	elfparser* PythonQtWrapper_elfparser::new_elfparser()	6728	elfparser* PythonQtWrapper_elfparser::new_elfparser()
	869	{	6729	{
	870	return new elfparser(); }	6730	return new elfparser(); }
	871		6731
	872	int PythonQtWrapper_elfparser::closeFile(elfparser* theWrappedObject)	6732	int PythonQtWrapper_elfparser::closeFile(elfparser* theWrappedObject)
	873	{	6733	{
	874	return ( theWrappedObject->closeFile());	6734	return ( theWrappedObject->closeFile());
	875	}	6735	}
	876		6736
	877	QString PythonQtWrapper_elfparser::getABI(elfparser* theWrappedObject)	6737	QString PythonQtWrapper_elfparser::getABI(elfparser* theWrappedObject)
	878	{	6738	{
	879	return ( theWrappedObject->getABI());	6739	return ( theWrappedObject->getABI());
	880	}	6740	}
	881		6741
	882	QString PythonQtWrapper_elfparser::getArchitecture(elfparser* theWrappedObject)	6742	QString PythonQtWrapper_elfparser::getArchitecture(elfparser* theWrappedObject)
	883	{	6743	{
	884	return ( theWrappedObject->getArchitecture());	6744	return ( theWrappedObject->getArchitecture());
	885	}	6745	}
	886		6746
	887	QString PythonQtWrapper_elfparser::getClass(elfparser* theWrappedObject)	6747	QString PythonQtWrapper_elfparser::getClass(elfparser* theWrappedObject)
	888	{	6748	{
	889	return ( theWrappedObject->getClass());	6749	return ( theWrappedObject->getClass());
	890	}	6750	}
	891		6751
	892	QString PythonQtWrapper_elfparser::getEndianness(elfparser* theWrappedObject)	6752	QString PythonQtWrapper_elfparser::getEndianness(elfparser* theWrappedObject)
	893	{	6753	{
	894	return ( theWrappedObject->getEndianness());	6754	return ( theWrappedObject->getEndianness());
	895	}	6755	}
	896		6756
	897	qint64 PythonQtWrapper_elfparser::getEntryPointAddress(elfparser* theWrappedObject)	6757	qint64 PythonQtWrapper_elfparser::getEntryPointAddress(elfparser* theWrappedObject)
	898	{	6758	{
	899	return ( theWrappedObject->getEntryPointAddress());	6759	return ( theWrappedObject->getEntryPointAddress());
	900	}	6760	}
	901		6761
	902	bool PythonQtWrapper_elfparser::getSectionData(elfparser* theWrappedObject, int index, char** buffer)	6762	bool PythonQtWrapper_elfparser::getSectionData(elfparser* theWrappedObject, int index, char** buffer)
	903	{	6763	{
	904	return ( theWrappedObject->getSectionData(index, buffer));	6764	return ( theWrappedObject->getSectionData(index, buffer));
	905	}	6765	}
	906		6766
	907	qint64 PythonQtWrapper_elfparser::getSectionDatasz(elfparser* theWrappedObject, int index)	6767	qint64 PythonQtWrapper_elfparser::getSectionDatasz(elfparser* theWrappedObject, int index)
	908	{	6768	{
	909	return ( theWrappedObject->getSectionDatasz(index));	6769	return ( theWrappedObject->getSectionDatasz(index));
	910	}	6770	}
	911		6771
	912	qint64 PythonQtWrapper_elfparser::getSectionMemsz(elfparser* theWrappedObject, int index)	6772	qint64 PythonQtWrapper_elfparser::getSectionMemsz(elfparser* theWrappedObject, int index)
	913	{	6773	{
	914	return ( theWrappedObject->getSectionMemsz(index));	6774	return ( theWrappedObject->getSectionMemsz(index));
	915	}	6775	}
	916		6776
	917	QString PythonQtWrapper_elfparser::getSectionName(elfparser* theWrappedObject, int index)	6777	QString PythonQtWrapper_elfparser::getSectionName(elfparser* theWrappedObject, int index)
	918	{	6778	{
	919	return ( theWrappedObject->getSectionName(index));	6779	return ( theWrappedObject->getSectionName(index));
	920	}	6780	}
	921		6781
	922	qint64 PythonQtWrapper_elfparser::getSectionPaddr(elfparser* theWrappedObject, int index)	6782	qint64 PythonQtWrapper_elfparser::getSectionPaddr(elfparser* theWrappedObject, int index)
	923	{	6783	{
	924	return ( theWrappedObject->getSectionPaddr(index));	6784	return ( theWrappedObject->getSectionPaddr(index));
	925	}	6785	}
	926		6786
	927	QString PythonQtWrapper_elfparser::getSectionType(elfparser* theWrappedObject, int index)	6787	QString PythonQtWrapper_elfparser::getSectionType(elfparser* theWrappedObject, int index)
	928	{	6788	{
	929	return ( theWrappedObject->getSectionType(index));	6789	return ( theWrappedObject->getSectionType(index));
	930	}	6790	}
	931		6791
	932	int PythonQtWrapper_elfparser::getSectioncount(elfparser* theWrappedObject)	6792	int PythonQtWrapper_elfparser::getSectioncount(elfparser* theWrappedObject)
	933	{	6793	{
	934	return ( theWrappedObject->getSectioncount());	6794	return ( theWrappedObject->getSectioncount());
	935	}	6795	}
	936		6796
	937	qint64 PythonQtWrapper_elfparser::getSegmentFilesz(elfparser* theWrappedObject, int index)	6797	qint64 PythonQtWrapper_elfparser::getSegmentFilesz(elfparser* theWrappedObject, int index)
	938	{	6798	{
	939	return ( theWrappedObject->getSegmentFilesz(index));	6799	return ( theWrappedObject->getSegmentFilesz(index));
	940	}	6800	}
	941		6801
	942	QString PythonQtWrapper_elfparser::getSegmentFlags(elfparser* theWrappedObject, int index)	6802	QString PythonQtWrapper_elfparser::getSegmentFlags(elfparser* theWrappedObject, int index)
	943	{	6803	{
	944	return ( theWrappedObject->getSegmentFlags(index));	6804	return ( theWrappedObject->getSegmentFlags(index));
	945	}	6805	}
	946		6806
	947	qint64 PythonQtWrapper_elfparser::getSegmentMemsz(elfparser* theWrappedObject, int index)	6807	qint64 PythonQtWrapper_elfparser::getSegmentMemsz(elfparser* theWrappedObject, int index)
	948	{	6808	{
	949	return ( theWrappedObject->getSegmentMemsz(index));	6809	return ( theWrappedObject->getSegmentMemsz(index));
	950	}	6810	}
	951		6811
	952	qint64 PythonQtWrapper_elfparser::getSegmentOffset(elfparser* theWrappedObject, int index)	6812	qint64 PythonQtWrapper_elfparser::getSegmentOffset(elfparser* theWrappedObject, int index)
	953	{	6813	{
	954	return ( theWrappedObject->getSegmentOffset(index));	6814	return ( theWrappedObject->getSegmentOffset(index));
	955	}	6815	}
	956		6816
	957	qint64 PythonQtWrapper_elfparser::getSegmentPaddr(elfparser* theWrappedObject, int index)	6817	qint64 PythonQtWrapper_elfparser::getSegmentPaddr(elfparser* theWrappedObject, int index)
	958	{	6818	{
	959	return ( theWrappedObject->getSegmentPaddr(index));	6819	return ( theWrappedObject->getSegmentPaddr(index));
	960	}	6820	}
	961		6821
	962	QString PythonQtWrapper_elfparser::getSegmentType(elfparser* theWrappedObject, int index)	6822	QString PythonQtWrapper_elfparser::getSegmentType(elfparser* theWrappedObject, int index)
	963	{	6823	{
	964	return ( theWrappedObject->getSegmentType(index));	6824	return ( theWrappedObject->getSegmentType(index));
	965	}	6825	}
	966		6826
	967	qint64 PythonQtWrapper_elfparser::getSegmentVaddr(elfparser* theWrappedObject, int index)	6827	qint64 PythonQtWrapper_elfparser::getSegmentVaddr(elfparser* theWrappedObject, int index)
	968	{	6828	{
	969	return ( theWrappedObject->getSegmentVaddr(index));	6829	return ( theWrappedObject->getSegmentVaddr(index));
	970	}	6830	}
	971		6831
	972	int PythonQtWrapper_elfparser::getSegmentcount(elfparser* theWrappedObject)	6832	int PythonQtWrapper_elfparser::getSegmentcount(elfparser* theWrappedObject)
	973	{	6833	{
	974	return ( theWrappedObject->getSegmentcount());	6834	return ( theWrappedObject->getSegmentcount());
	975	}	6835	}
	976		6836
	977	QString PythonQtWrapper_elfparser::getType(elfparser* theWrappedObject)	6837	QString PythonQtWrapper_elfparser::getType(elfparser* theWrappedObject)
	978	{	6838	{
	979	return ( theWrappedObject->getType());	6839	return ( theWrappedObject->getType());
	980	}	6840	}
	981		6841
	982	qint64 PythonQtWrapper_elfparser::getVersion(elfparser* theWrappedObject)	6842	qint64 PythonQtWrapper_elfparser::getVersion(elfparser* theWrappedObject)
	983	{	6843	{
	984	return ( theWrappedObject->getVersion());	6844	return ( theWrappedObject->getVersion());
	985	}	6845	}
	986		6846
	987	bool PythonQtWrapper_elfparser::static_elfparser_isElf(const QString& File)	6847	bool PythonQtWrapper_elfparser::static_elfparser_isElf(const QString& File)
	988	{	6848	{
	989	return (elfparser::isElf(File));	6849	return (elfparser::isElf(File));
	990	}	6850	}
	991		6851
	992	bool PythonQtWrapper_elfparser::iself(elfparser* theWrappedObject)	6852	bool PythonQtWrapper_elfparser::iself(elfparser* theWrappedObject)
	993	{	6853	{
	994	return ( theWrappedObject->iself());	6854	return ( theWrappedObject->iself());
	995	}	6855	}
	996		6856
	997	bool PythonQtWrapper_elfparser::isopened(elfparser* theWrappedObject)	6857	bool PythonQtWrapper_elfparser::isopened(elfparser* theWrappedObject)
	998	{	6858	{
	999	return ( theWrappedObject->isopened());	6859	return ( theWrappedObject->isopened());
	1000	}	6860	}
	1001		6861
	1002	int PythonQtWrapper_elfparser::setFilename(elfparser* theWrappedObject, const QString& name)	6862	int PythonQtWrapper_elfparser::setFilename(elfparser* theWrappedObject, const QString& name)
	1003	{	6863	{
	1004	return ( theWrappedObject->setFilename(name));	6864	return ( theWrappedObject->setFilename(name));
	1005	}	6865	}
	1006		6866
	1007		6867

src/common/pythonQtOut/generated_cpp/PySocExplorer/PySocExplorer0.h +404 0

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

src/common/pythonQtOut/generated_cpp/PySocExplorer/PySocExplorer_init.cpp +7 -7

             #include <PythonQt.h>
             #include "PySocExplorer0.h"
             void PythonQt_init_PySocExplorer(PyObject* module) {
             PythonQt::priv()->registerClass(&ElfFile::staticMetaObject, "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_ElfFile>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_ElfFile>, module, 0);
             PythonQt::self()->addParentClass("ElfFile", "abstractExecFile",PythonQtUpcastingOffset<ElfFile,abstractExecFile>());
-            PythonQt::priv()->registerCPPClass("MemSizeWdgt", "", "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_MemSizeWdgt>, NULL, module, 0);
+            PythonQt::priv()->registerClass(&MemSizeWdgt::staticMetaObject, "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_MemSizeWdgt>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_MemSizeWdgt>, module, 0);
-            PythonQt::priv()->registerCPPClass("QHexEdit", "", "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_QHexEdit>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_QHexEdit>, module, 0);
+            PythonQt::priv()->registerClass(&QHexEdit::staticMetaObject, "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_QHexEdit>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_QHexEdit>, module, 0);
-            PythonQt::priv()->registerCPPClass("QHexSpinBox", "", "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_QHexSpinBox>, NULL, module, 0);
+            PythonQt::priv()->registerClass(&QHexSpinBox::staticMetaObject, "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_QHexSpinBox>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_QHexSpinBox>, module, 0);
-            PythonQt::priv()->registerCPPClass("SocExplorerPlot", "", "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_SocExplorerPlot>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_SocExplorerPlot>, module, 0);
+            PythonQt::priv()->registerClass(&SocExplorerPlot::staticMetaObject, "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_SocExplorerPlot>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_SocExplorerPlot>, module, 0);
-            PythonQt::priv()->registerClass(&TCP_Terminal_Client::staticMetaObject, "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_TCP_Terminal_Client>, NULL, module, 0);
+            PythonQt::priv()->registerClass(&TCP_Terminal_Client::staticMetaObject, "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_TCP_Terminal_Client>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_TCP_Terminal_Client>, module, 0);
             PythonQt::priv()->registerCPPClass("XByteArray", "", "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_XByteArray>, NULL, module, 0);
             PythonQt::priv()->registerClass(&abstractExecFile::staticMetaObject, "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_abstractExecFile>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_abstractExecFile>, module, 0);
             PythonQt::priv()->registerCPPClass("codeFragment", "", "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_codeFragment>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_codeFragment>, module, 0);
-            PythonQt::priv()->registerCPPClass("elfFileWidget", "", "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_elfFileWidget>, NULL, module, 0);
+            PythonQt::priv()->registerClass(&elfFileWidget::staticMetaObject, "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_elfFileWidget>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_elfFileWidget>, module, 0);
-            PythonQt::priv()->registerCPPClass("elfInfoWdgt", "", "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_elfInfoWdgt>, NULL, module, 0);
+            PythonQt::priv()->registerClass(&elfInfoWdgt::staticMetaObject, "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_elfInfoWdgt>, PythonQtSetInstanceWrapperOnShell<PythonQtShell_elfInfoWdgt>, module, 0);
             PythonQt::priv()->registerCPPClass("elfparser", "", "PySocExplorer", PythonQtCreateObject<PythonQtWrapper_elfparser>, NULL, module, 0);
             }

src/common/pythonQtgeneratorCfg.txt +31 -5

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

src/common/pythongenerator.sh +1 -1

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

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages