HG_REPOSITORIES/LPP/INSTRUMENTATION/SocExplorer Commit - r106:7598f3bdb8ba

Pre-0.7 partially back-ported.

Alexis Jeandet -

r106:7598f3bdb8ba 0.6

parent child

Context file:

r106:7598f3bdb8ba

Expand all files

.hgsubstate +1 -1

 cb664ab4bb3c531d706b1948a378ed9810c0dda src/SocExplorerEngine/PeripheralWidget
 f143e4ae72a0bb4832b546eb76eb50e94049b80 src/common/genericBinaryFiles
-dce25b198558be573f56c1cf337aa95ddd666d6 src/common/lppserial
+b353bf8243cbfb3db44e196f33bd164c11c9949 src/common/lppserial
 afde9cc96bb419cf898560d080ec96991aeca src/common/qhexedit

ressources/Grlib.xml +17 0

             <?xml version='1.0' encoding='utf-8'?>
             <soc name="Leon">
              <peripheral vid="1" name="AHBUART" pid="7">
               <register name="STATUS" addOffset="4">
                <bitField size="1" name="DR" mode="1" desc="Data ready (DR) - indicates that new data has been received by the AMBA AHB master interface. Read only. Reset&#xa;value: ‘0’.&#xa;"/>
                <bitField size="1" name="TS" mode="3" desc="Transmitter shift register empty (TS) - indicates that the transmitter shift register is empty. Read only. Reset value:&#xa;‘1’"/>
                <bitField name="TH" size="1" mode="1" desc="Transmitter hold register empty (TH) - indicates that the transmitter hold register is empty. Read only. Reset value:&#xa;‘1’"/>
                <bitField name="BR" size="1" mode="1" desc="Break (BR) - indicates that a BREAKE has been received. Reset value: ‘0’"/>
                <bitField name="OV" size="1" mode="1" desc="Overflow (OV) - indicates that one or more character have been lost due to receiver overflow. Reset value: ‘0’"/>
                <bitField name="FE" size="1" mode="1" desc="Frame error (FE) - indicates that a framing error was detected. Reset value: ‘0’"/>
               </register>
               <register name="CONTROL" addOffset="8">
                <bitField name="EN" size="1" mode="3" desc="Receiver enable (EN) - if set, enables both the transmitter and receiver. Reset value: ‘0’."/>
                <bitField name="BL" size="1" mode="3" desc="Baud rate locked (BL) - is automatically set when the baud rate is locked. Reset value: ‘0’."/>
               </register>
               <register name="SCALE" addOffset="12">
                <bitField name="SCALER RELOAD VALUE" size="18" mode="3" desc="Baudrate scaler reload value = (((system_clk*10)/(baudrate*8))-5)/10. Reset value: “3FFFF“."/>
               </register>
              </peripheral>
              <peripheral vid="1" name="APBUART" pid="12">
               <register name="DATA">
                <bitField name="DATA" size="8" mode="3" desc="Receiver holding register or FIFO (read access)&#xa;Transmitter holding register or FIFO (write access)&#xa;"/>
               </register>
               <register name="STATUS" addOffset="4">
                <bitField name="DR" size="1" mode="1" desc="Data ready (DR) - indicates that new data is available in the receiver holding register. Reset: 0&#xa;"/>
                <bitField name="TS" size="1" mode="1" desc="Transmitter shift register empty (TS) - indicates that the transmitter shift register is empty. Reset: 1"/>
                <bitField name="TE" size="1" mode="1" desc="Transmitter FIFO empty (TE) - indicates that the transmitter FIFO is empty. Reset: 1&#xa;"/>
                <bitField name="BR" size="1" mode="1" desc="Break received (BR) - indicates that a BREAK has been received. Reset: 0&#xa;"/>
                <bitField name="OV" size="1" mode="1" desc="Overrun (OV) - indicates that one or more character have been lost due to overrun. Reset: 0&#xa;"/>
                <bitField name="PE" size="1" mode="1" desc="Parity error (PE) - indicates that a parity error was detected. Reset: 0&#xa;"/>
                <bitField name="FE" size="1" mode="1" desc="Framing error (FE) - indicates that a framing error was detected. Reset: 0&#xa;"/>
                <bitField name="TH" size="1" mode="1" desc="Transmitter FIFO half-full (TH) - indicates that the FIFO is less than half-full. Reset: 0&#xa;"/>
                <bitField name="RH" size="1" mode="1" desc="Receiver FIFO half-full (RH) -indicates that at least half of the FIFO is holding data. Reset: 0&#xa;"/>
                <bitField name="TF" size="1" mode="1" desc="Transmitter FIFO full (TF) - indicates that the Transmitter FIFO is full. Reset: 0&#xa;"/>
                <bitField name="RF" size="1" mode="1" desc="Receiver FIFO full (RF) - indicates that the Receiver FIFO is full. Reset: 0&#xa;"/>
                <bitField name="TCNT" size="6" mode="1" desc="Transmitter FIFO count (TCNT) - shows the number of data frames in the transmitter FIFO. Reset: 0&#xa;"/>
                <bitField name="RCNT" size="6" mode="1" desc="Receiver FIFO count (RCNT) - shows the number of data frames in the receiver FIFO. Reset: 0"/>
               </register>
               <register name="CONTROL" addOffset="8">
                <bitField name="RE" size="1" mode="3" desc="Receiver enable (RE) - if set, enables the receiver. Reset: 0&#xa;"/>
                <bitField name="TE" size="1" mode="3" desc="Transmitter enable (TE) - if set, enables the transmitter. Reset: 0&#xa;"/>
                <bitField name="RI" size="1" mode="3" desc="Receiver interrupt enable (RI) - if set, interrupts are generated when characters are received (see sec-&#xa;tion 15.6 for details). Not Reset.&#xa;"/>
                <bitField name="TI" size="1" mode="3" desc="Transmitter interrupt enable (TI) - if set, interrupts are generated when characters are transmitted&#xa;(see section 15.6 for details). Not Reset.&#xa;"/>
                <bitField name="PS" size="1" mode="3" desc="Parity select (PS) - selects parity polarity (0 = even parity, 1 = odd parity) (when implemented). Not&#xa;Reset.&#xa;"/>
                <bitField name="PE" size="1" mode="3" desc="Parity enable (PE) - if set, enables parity generation and checking (when implemented). Not Reset.&#xa;"/>
                <bitField name="FL" size="1" mode="3" desc="Flow control (FL) - if set, enables flow control using CTS/RTS (when implemented). Reset: 0&#xa;"/>
                <bitField name="LB" size="1" mode="3" desc="Loop back (LB) - if set, loop back mode will be enabled. Not Reset.&#xa;"/>
                <bitField name="EC" size="1" mode="3" desc="External Clock (EC) - if set, the UART scaler will be clocked by UARTI.EXTCLK. Reset: 0&#xa;"/>
                <bitField name="TF" size="1" mode="3" desc="Transmitter FIFO interrupt enable (TF) - when set, Transmitter FIFO level interrupts are enabled.&#xa;Not Reset.&#xa;"/>
                <bitField name="RF" size="1" mode="3" desc="Receiver FIFO interrupt enable (RF) - when set, Receiver FIFO level interrupts are enabled. Not&#xa;Reset.&#xa;"/>
                <bitField name="DB" size="1" mode="3" desc="FIFO debug mode enable (DB) - when set, it is possible to read and write the FIFO debug register.&#xa;Not Reset.&#xa;"/>
                <bitField name="BI" size="1" mode="3" desc="Break interrupt enable (BI) - When set, an interrupt will be generated each time a break character is&#xa;received. See section 16.6 for more details. Not Reset.&#xa;"/>
                <bitField name="DI" size="1" mode="3" desc="Delayed interrupt enable (DI) - When set, delayed receiver interrupts will be enabled and an inter-&#xa;rupt will only be generated for received characters after a delay of 4 character times + 4 bits if no&#xa;new character has been received during that interval. This is only applicable if receiver interrupt&#xa;enable is set.&#xa;"/>
                <bitField name="SI" size="1" mode="3" desc="Transmitter shift register empty interrupt enable (SI) - When set, an interrupt will be generated when&#xa;the transmitter shift register becomes empty.&#xa;"/>
                <bitField name="FA" size="1" mode="3" desc="FIFOs available (FA) - Set to 1 when receiver and transmitter FIFOs are available. When 0, only&#xa;holding register are available. Read only.&#xa;"/>
               </register>
               <register name="SCALE" addOffset="12">
                <bitField name="SCALER RELOAD VALUE" size="31" mode="3" desc="sbits-1:0  Scaler reload value"/>
               </register>
               <register name="FIFO Debug" addOffset="16">
                <bitField name="DATA" size="8" mode="3" desc="Transmitter holding register or FIFO (read access)&#xa;Receiver holding register or FIFO (write access)&#xa;"/>
               </register>
              </peripheral>
              <peripheral vid="1" name="LEON3" pid="3"/>
              <peripheral vid="1" name="DSU3" pid="4">
               <register name="Control">
                <bitField name="UNUSED" size="20" mode="1" desc="UNUSED" offset="12"/>
                <bitField name="PW" size="1" mode="1" offset="11" desc="Power down (PW). Returns ‘1’ when processor in in power-down mode."/>
                <bitField name="HL" size="1" mode="1" offset="10" desc="Processor halt (HL). Returns ‘1’ on read when processor is halted. If the processor is in debug mode, setting this bit will put the processor in halt mode."/>
                <bitField name="PE" size="1" mode="3" offset="9" desc="Processor error mode (PE) - returns ‘1’ on read when processor is in error mode, else ‘0’. If written with ‘1’, it will clear the error and halt mode."/>
                <bitField name="EB" size="1" mode="1" offset="8" desc="EB - value of the external DSUBRE signal (read-only)"/>
                <bitField name="EE" size="1" mode="1" offset="7" desc="EE - value of the external DSUEN signal (read-only)"/>
                <bitField name="DM" size="1" mode="1" offset="6" desc="Debug mode (DM). Indicates when the processor has entered debug mode (read-only)."/>
                <bitField name="BZ" size="1" mode="3" offset="5" desc="Break on error traps (BZ) - if set, will force the processor into debug mode on all except the following traps: priviledged_instruction, fpu_disabled, window_overflow, window_underflow, asynchronous_interrupt, ticc_trap."/>
                <bitField name="BX" size="1" mode="3" offset="4" desc="Break on trap (BX) - if set, will force the processor into debug mode when any trap occurs."/>
                <bitField name="BS" size="1" mode="3" offset="3" desc="Break on S/W breakpoint (BS) - if set, debug mode will be forced when an breakpoint instruction (ta 1) is executed."/>
                <bitField name="BW" size="1" mode="3" offset="2" desc="Break on IU watchpoint (BW)- if set, debug mode will be forced on a IU watchpoint (trap 0xb)."/>
                <bitField name="BE" size="1" mode="3" offset="1" desc="Break on error (BE) - if set, will force the processor to debug mode when the processor would have entered error condition (trap in trap)."/>
                <bitField name="TE" size="1" mode="3" offset="0" desc="Trace enable (TE). Enables instruction tracing. If set the instructions will be stored in the trace buffer. Remains set&#xa;when then processor enters debug or error mode."/>
               </register>
               <register name="Time tag counter" addOffset="8">
                <bitField name="UNUSED" size="2" mode="1" offset="30" desc=""/>
                <bitField name="DSU TIME TAG VALUE" size="30" mode="1" offset="0" desc="The value is used as time tag in the instruction and AHB trace buffer. The width of the timer (up to 30 bits) is configurable through the DSU generic port."/>
               </register>
               <register name="Break and Single Step" addOffset="32">
                <bitField name="SSx" size="16" mode="3" offset="16" desc="[31:16] : Single step (SSx) - if set, the processor x will execute one instruction and return to debug mode. The bit remains set after the processor goes into the debug mode."/>
                <bitField name="BNx" size="16" mode="3" offset="0" desc="[15:0] : Break now (BNx) -Force processor x into debug mode if the Break on watchpoint (BW) bit in the processors DSU control register is set. If cleared, the processor x will resume execution."/>
               </register>
               <register name="Debug Mode Mask" addOffset="36">
                <bitField name="DMx" size="16" mode="3" offset="16" desc="[31:16]: Debug mode mask. If set, the corresponding processor will not be able to force running processors into debug mode even if it enters debug mode."/>
                <bitField name="EDx" size="16" mode="3" offset="0" desc="[15:0] : Enter debug mode (EDx) - Force processor x into debug mode if any of processors in a multiprocessor system enters the debug mode. If 0, the processor x will not enter the debug mode."/>
               </register>
               <register name="AHB Trace buffer control" addOffset="64">
                <bitField name="DCNT" size="16" mode="1" offset="16" desc="Trace buffer delay counter (DCNT). Note that the number of bits actually implemented depends on the size of the trace buffer."/>
                <bitField name="RESERVED" size="13" mode="1" offset="3" desc=""/>
                <bitField name="BR" size="1" mode="3" offset="2" desc="Break (BR). If set, the processor will be put in debug mode when AHB trace buffer stops due to AHB breakpoint hit."/>
                <bitField name="DM" size="1" mode="1" offset="1" desc="Delay counter mode (DM). Indicates that the trace buffer is in delay counter mode."/>
                <bitField name="EN" size="1" mode="3" offset="0" desc="Trace enable (EN). Enables the trace buffer."/>
               </register>
               <register name="AHB trace buffer index" addOffset="68">
                <bitField name="INDEX" size="28" mode="3" offset="4" desc="Trace buffer index counter (INDEX). Note that the number of bits actually implemented depends on the size of the trace buffer."/>
                <bitField name="UNUSED" size="4" mode="1" offset="0" desc=""/>
               </register>
               <register name="AHB breakpoint address 1" addOffset="80">
                <bitField name="BADDR[31:2]" size="30" mode="3" offset="2" desc="Breakpoint address (bits 31:2)"/>
                <bitField name="UNUSED" size="2" mode="1" offset="0" desc=""/>
               </register>
               <register name="AHB mask register 1" addOffset="84">
                <bitField name="BMASK[31:2]" size="30" mode="3" offset="2" desc="Breakpoint mask"/>
                <bitField name="LD" size="1" mode="3" offset="1" desc="LD - break on data load address"/>
                <bitField name="ST" size="1" mode="3" offset="0" desc="ST - break on data store address"/>
               </register>
               <register name="AHB breakpoint address 2" addOffset="88">
                <bitField name="BADDR[31:2]" size="30" mode="3" offset="2" desc="Breakpoint address (bits 31:2)"/>
                <bitField name="UNUSED" size="2" mode="1" offset="0" desc=""/>
               </register>
               <register name="AHB mask register 2" addOffset="92">
                <bitField name="BMASK[31:2]" size="30" mode="3" offset="2" desc="Breakpoint mask "/>
                <bitField name="LD" size="1" mode="3" offset="1" desc="LD - break on data load address"/>
                <bitField name="ST" size="1" mode="3" offset="0" desc="ST - beak on data store address"/>
               </register>
               <register name="Instruction Trace buffer control" addOffset="1114112">
                <bitField name="RESERVED" size="16" mode="1" offset="16" desc=""/>
                <bitField name="IT POINTER" size="16" mode="3" offset="0" desc="Instruction trace pointer. Note that the number of bits actually implemented depends on the size of the trace buffer."/>
               </register>
               <register name="SP" addOffset="3145784">
                <bitField name="SP" size="32" mode="3" offset="0" desc="IU Window 0 Stack Pointer"/>
               </register>
               <register name="Y" addOffset="4194304"/>
               <register name="PSR" addOffset="4194308">
                <bitField name="IMPL" size="4" mode="3" offset="28" desc="Bits 31 through 28 are hardwired to identify an implementation or class of implementations of the architecture. The hardware should not change this field in response to a WRPSR instruction. Together, the PSR.impl and PSR.ver fields define a unique implementation or class of implementations of the architecture. See Appendix L, “Implementation Characteristics.”"/>
                <bitField name="VER" size="4" mode="3" offset="24" desc="Bits 27 through 24 are implementation-dependent. The ver field is either hardwired to identify one or more particular implementations or is a readable and writable state field whose properties are implementation-dependent. See Appendix L, “Implementation Characteristics.”"/>
                <bitField name="NEGATIVE" size="1" mode="3" offset="23" desc="Bit 23 indicates whether the 32-bit 2’s complement ALU result was negative for the last instruction that modified the icc field. 1 = negative, 0 = not negative."/>
                <bitField name="ZERO" size="1" mode="3" offset="22" desc="Bit 22 indicates whether the 32-bit ALU result was zero for the last instruction that modified the icc field. 1 = zero, 0 = nonzero."/>
                <bitField name="OVERFLOW" size="1" mode="3" offset="21" desc="Bit 21 indicates whether the ALU result was within the range of (was representable in) 32-bit 2’s complement notation for the last instruction that modified the icc field. 1 = overflow, 0 = no overflow."/>
                <bitField name="CARRY" size="1" mode="3" offset="20" desc="Bit 21 indicates whether the ALU result was within the range of (was representable in) 32-bit 2’s complement notation for the last instruction that modified the icc field. 1 = overflow, 0 = no overflow."/>
                <bitField name="RESERVED" size="6" mode="1" offset="14" desc="Bits 19 through 14 are reserved. When read by a RDPSR instruction, these bits deliver zeros. For future compatibility, supervisor software should only issue WRPSR instructions with zero values in this field."/>
                <bitField name="EC" size="1" mode="3" offset="13" desc="Bit 13 determines whether the implementation-dependent coprocessor is enabled. If disabled, a coprocessor instruction will trap. 1 = enabled, 0 = disabled. If an implementation does not support a coprocessor in hardware, PSR.EC should always read as 0 and writes to it should be ignored."/>
                <bitField name="EF" size="1" mode="3" offset="12" desc="Bit 12 determines whether the FPU is enabled. If disabled, a floating-point instruction will trap. 1 = enabled, 0 = disabled. If an implementation does not support a hardware FPU, PSR.EF should always read as 0 and writes to it should be ignored. &#xa; Programming Note Software can use the EF and EC bits to determine whether a particular process uses the FPU or CP. If a process does not use the FPU/CP, its registers do not need to be saved across a context switch."/>
                <bitField name="PIL" size="1" mode="3" offset="11" desc="Bits 11 (the most significant bit) through 8 (the least significant bit) identify the interrupt level above which the processor will accept an interrupt. See Chapter 7, “Traps.”"/>
                <bitField name="S" size="1" mode="3" offset="7" desc="Bit 7 determines whether the processor is in supervisor or user mode. 1 = supervisor mode, 0 = user mode."/>
                <bitField name="PS" size="1" mode="3" offset="6" desc="Bit 6 contains the value of the S bit at the time of the most recent trap."/>
                <bitField name="ET" size="1" mode="3" offset="5" desc="Bit 5 determines whether traps are enabled. A trap automatically resets ET to 0. When ET=0, an interrupt request is ignored and an exception trap causes the IU to halt execution, which typically results in a reset trap that resumes execution at address 0. 1 = traps enabled, 0 = traps disabled. See Chapter 7, “Traps.”"/>
                <bitField name="CWP" size="5" mode="3" offset="0" desc="Bits 4 (the MSB) through 0 (the LSB) comprise the current window pointer, a counter that identifies the current window into the r registers. The hardware decrements the CWP on traps and SAVE instructions, and increments it on RESTORE and RETT instructions (modulo NWINDOWS )."/>
               </register>
               <register name="WIM" addOffset="4194312"/>
               <register name="TBR" addOffset="4194316"/>
               <register name="PC" addOffset="4194320"/>
               <register name="NPC" addOffset="4194324"/>
               <register name="FSR" addOffset="4194328"/>
               <register name="CPSR" addOffset="4194332"/>
               <register name="DSU trap" addOffset="4194336">
                <bitField name="RESERVED" size="19" mode="1" offset="13" desc=""/>
                <bitField name="EM" size="1" mode="1" offset="12" desc="Error mode (EM). Set if the trap would have cause the processor to enter error mode."/>
                <bitField name="TRAP TYPE" size="8" mode="1" offset="4" desc="8-bit SPARC trap type"/>
                <bitField name="UNUSED" size="4" mode="1" offset="0" desc=""/>
               </register>
               <register name="DSU ASI" addOffset="4194340">
                <bitField name="UNUSED" size="24" mode="1" offset="8" desc=""/>
                <bitField name="ASI" size="8" mode="1" offset="0" desc="ASI to be used on diagnostic ASI access"/>
               </register>
               <register name="ASR16" addOffset="4194368"/>
               <register name="ASR17" addOffset="4194372"/>
               <register name="ASR18" addOffset="4194376"/>
               <register name="ASR19" addOffset="4194380"/>
               <register name="ASR20" addOffset="4194384"/>
               <register name="ASR21" addOffset="4194388"/>
               <register name="ASR22" addOffset="4194392"/>
               <register name="ASR23" addOffset="4194396"/>
               <register name="ASR24" addOffset="4194400"/>
               <register name="ASR25" addOffset="4194404"/>
               <register name="ASR26" addOffset="4194408"/>
               <register name="ASR27" addOffset="4194412"/>
               <register name="ASR28" addOffset="4194416"/>
               <register name="ASR29" addOffset="4194420"/>
               <register name="ASR30" addOffset="4194424"/>
               <register name="ASR31" addOffset="4194428"/>
              </peripheral>
              <peripheral vid="1" name="GPTIMER" pid="17">
               <register name="Scaler value">
                <bitField name="SCALER VALUE" size="16" mode="3" desc="Scaler value&#xa;Any unused most significant bits are reserved. Always reads as ‘000...0’."/>
               </register>
               <register name="Scaler reload value" addOffset="4">
                <bitField name="SCALER RELOAD VALUE" size="16" mode="3" desc="Scaler reload value&#xa;Any unused most significant bits are reserved. Always read as ‘000...0’."/>
               </register>
               <register name="Configuration" addOffset="8">
                <bitField name="TIMERS" size="3" mode="1" desc="Number of implemented timers. Read-only.&#xa;"/>
                <bitField name="IRQ" size="5" mode="1" desc="APB Interrupt: If configured to use common interrupt all timers will drive APB interrupt nr. IRQ,&#xa;otherwise timer nwill drive APB Interrupt IRQ+n (has to be less the MAXIRQ). Read-only.&#xa;"/>
                <bitField name="SI" size="1" mode="1" desc="Separate interrupts (SI). Reads ‘1’ if the timer unit generates separate interrupts for each timer, oth-erwise ‘0’. Read-only.&#xa;"/>
                <bitField name="DF" size="1" mode="3" desc="Disable timer freeze (DF). If set the timer unit can not be freezed, otherwise signal GPTI.DHALT&#xa;freezes the timer unit.&#xa;"/>
               </register>
               <register name="Unused" addOffset="12"/>
               <register name="Timer 1 counter value" addOffset="16">
                <bitField name="TIMER COUNTER VALUE" size="32" mode="3" desc="Timer Counter value. Decremented by 1 for each prescaler tick.&#xa;Any unused most significant bits are reserved. Always reads as ‘000...0’."/>
               </register>
               <register name="Timer 1 reload value" addOffset="20">
                <bitField name="TIMER RELOAD VALUE" size="32" mode="3" desc="Timer Reload value. This value is loaded into the timer counter value register when ‘1’ is written to&#xa;load bit in the timers control register or when the RS bit is set in the control register and the timer&#xa;underflows.&#xa;Any unused most significant bits are reserved. Always reads as ‘000...0’."/>
               </register>
               <register name="Timer 1 control" addOffset="24">
                <bitField name="EN" size="1" mode="3" desc="Enable (EN): Enable the timer."/>
                <bitField name="RS" size="1" mode="3" desc="Restart (RS): If set, the timer counter value register is reloaded with the value of the reload register when the timer underflows"/>
                <bitField name="LD"/>
                <bitField name="IE" size="1" mode="3" desc="Interrupt Enable (IE): If set the timer signals interrupt when it underflows.&#xa;"/>
                <bitField name="IP" size="1" mode="3" desc="Interrupt Pending (IP): The core sets this bit to ‘1’ when an interrupt is signalled. This bit remains ‘1’ until cleared by writing ‘1’ to this bit, writes of ‘0’ have no effect.&#xa;"/>
                <bitField name="CH" size="1" mode="3" desc="Chain (CH): Chain with preceding timer. If set for timer n, timer n will be decremented each time when timer (n-1) underflows.&#xa;"/>
                <bitField name="DH" size="1" mode="1" desc="Debug Halt (DH): Value of GPTI.DHALT signal which is used to freeze counters (e.g. when a sys-tem is in debug mode). Read-only.&#xa;"/>
               </register>
              </peripheral>
              <peripheral vid="1" name="GRTIMER" pid="56">
               <register name="Scaler value">
                <bitField name="SCALER Value" size="16" mode="3" desc="Scaler value"/>
               </register>
               <register name="Scaler reload value" addOffset="4">
                <bitField name="SCALER Reload Value" size="32" mode="3" desc="SCALER Reload Value"/>
               </register>
               <register name="Configuration" addOffset="8">
                <bitField name="TIMERS" size="3" mode="1" desc="Number of implemented timers. Read-only.&#xa;"/>
                <bitField name="IRQ" size="5" mode="1" desc="APB Interrupt: If configured to use common interrupt all timers will drive APB interrupt nr. IRQ,&#xa;otherwise timer nwill drive APB Interrupt IRQ+n (has to be less the MAXIRQ). Read-only.&#xa;"/>
                <bitField name="SI" size="1" mode="1" desc="Separate interrupts (SI). Reads ‘1’ if the timer unit generates separate interrupts for each timer, oth-erwise ‘0’. Read-only.&#xa;"/>
                <bitField name="DF" size="1" mode="3" desc="Disable timer freeze (DF). If set the timer unit can not be freezed, otherwise signal GPTI.DHALT&#xa;freezes the timer unit.&#xa;"/>
                <bitField name="EE" size="1" mode="3" desc="Enable external clock source (EE). If set the prescaler is clocked from the external clock source."/>
                <bitField name="EL" size="1" mode="3" desc="Enable latching (EL). If set, on the next matching interrupt, the latches will be loaded with the corresponding timer&#xa;values. The bit is then automatically cleared, not to load a timer value until set again."/>
                <bitField name="ES" size="1" mode="3" desc="Enable set (ES). If set, on the next matching interrupt, the timers will be loaded with the corresponding timer reload&#xa;values. The bit is then automatically cleared, not to reload the timer values until set again. (Added to revision 2)."/>
               </register>
               <register name="Timer latch configuration" addOffset="12">
                <bitField name="LTCV" size="32" mode="3" desc="[nbits-1:0] Latched Timer Counter Value (LTCV). Value latch from corresponding timer."/>
               </register>
               <register name="Timer 1 counter value" addOffset="16">
                <bitField name="TIMER COUNTER VALUE" size="32" mode="3" desc="[nbits-1:0] Timer Counter value. Decremented by 1 for each prescaler tick."/>
               </register>
               <register name="Timer 1 reload value" addOffset="20">
                <bitField name="TIMER RELOAD VALUE" size="32" mode="3" desc="[nbits-1:0] Timer Reload value. This value is loaded into the timer counter value register when ‘1’ is written to load bit in the timers control register."/>
               </register>
               <register name="Timer 1 control" addOffset="24">
                <bitField name="EN" size="1" mode="3" desc="Enable (EN): Enable the timer."/>
                <bitField name="RS" size="1" mode="3" desc="Restart (RS): If set the value from the timer reload register is loaded to the timer counter value register and&#xa;decrementing the timer is restarted."/>
                <bitField name="LD" size="1" mode="3" desc="Load (LD): Load value from the timer reload register to the timer counter value register."/>
                <bitField name="IE" size="1" mode="3" desc="Interrupt Enable (IE): If set the timer signals interrupt when it underflows."/>
                <bitField name="IP" size="1" mode="3" desc="Interrupt Pending (IP): The core sets this bit to ‘1’ when an interrupt is signalled. This bit remains ‘1’ until cleared&#xa;by writing ‘1’ to this bit, writes of ‘0’ have no effect."/>
                <bitField name="CH" size="1" mode="3" desc="Chain (CH): Chain with preceding timer. If set for timer n, timer n will be decremented each time when timer (n-1)&#xa;underflows."/>
                <bitField name="DH" size="1" mode="3" desc="Debug Halt (DH): Value of GPTI.DHALT signal which is used to freeze counters (e.g. when a system is in debug&#xa;mode). Read-only."/>
               </register>
               <register name="Timer 1 latch" addOffset="28">
                <bitField name="LTCV" size="32" mode="3" desc="[nbits-1:0] Latched Timer Counter Value (LTCV). Value latch from corresponding timer."/>
               </register>
              </peripheral>
              <peripheral vid="4" name="MCTRL" pid="15">
               <register name="MCFG1">
                <bitField name="PROM READ WS" size="4" mode="3" desc="PROM read waitstates (PROM READ WS) - Sets the number of wait states for PROM read cycles (“0000”=0, “0001”=1, “0010”=2,...,”1111”=15). Reset to “1111”.&#xa;"/>
                <bitField name="PROM WRITE WS" size="4" mode="3" desc="PROM write waitstates (PROM WRITE WS) - Sets the number of wait states for PROM write cycles&#xa;(“0000”=0, “0001”=1, “0010”=2,..., “1111”=15).&#xa;"/>
                <bitField name="PROM WIDTH" size="2" mode="3" desc="PROM width (PROM WIDTH) - Sets the data width of the PROM area (“00”=8, “01”=16,&#xa;       “10”=32).&#xa;"/>
                <bitField name="PWEN" size="1" mode="3" desc="PROM write enable (PWEN) - Enables write cycles to the PROM area.&#xa;"/>
                <bitField name="RESERVED"/>
                <bitField name="IOEN" size="1" mode="3" desc="I/O enable (IOEN) - Enables accesses to the memory bus I/O area.&#xa;"/>
                <bitField name="IO WAITSTATES" size="4" mode="3" desc="I/O waitstates (IO WAITSTATES) - Sets the number of waitstates during I/O accesses (“0000”=0,   “0001”=1, “0010”=2,..., “1111”=15).&#xa;"/>
                <bitField name="BEXCN" size="1" mode="3" desc="Bus error enable (BEXCN) - Enables bus error signalling. Reset to ‘0’.&#xa;"/>
                <bitField name="IBRDY" size="1" mode="3" desc="I/O bus ready enable (IBRDY) - Enables bus ready (BRDYN) signalling for the I/O area. Reset to ‘0’.&#xa;"/>
                <bitField name="IOBUSW" size="1" mode="3" desc="I/O bus width (IOBUSW) - Sets the data width of the I/O area (“00”=8, “01”=16, “10” =32).&#xa;"/>
               </register>
               <register name="MCFG2" addOffset="4">
                <bitField name="RAM READ WS" size="2" mode="3" desc="RAM read waitstates (RAM READ WS) - Sets the number of wait states for RAM read cycles (“00”=0, “01”=1, “10”=2, “11”=3).&#xa;"/>
                <bitField name="RAM WRITE WS" size="2" mode="3" desc="RAM write waitstates (RAM WRITE WS) - Sets the number of wait states for RAM write cycles (“00”=0, “01”=1, “10”=2, “11”=3).&#xa;"/>
                <bitField name="RAM WIDTH" size="2" mode="3" desc="RAM width (RAM WIDTH) - Sets the data width of the RAM area (“00”=8, “01”=16, “1X”=32).&#xa;"/>
                <bitField name="RMW" size="1" mode="3" desc="Read-modify-write enable (RMW) - Enables read-modify-write cycles for sub-word writes to 16- bit 32-bit areas with common write strobe (no byte write strobe).&#xa;"/>
                <bitField name="RBRDY" size="1" mode="3" desc="RAM bus ready enable (RBRDY) - Enables bus ready signalling for the RAM area.&#xa;"/>
                <bitField name="RAM BANK SIZE" size="4" mode="3" desc="RAM bank size (RAM BANK SIZE) - Sets the size of each RAM bank (“0000”=8 kbyte, “0001”=16 kbyte, ..., “1111”=256 Mbyte).&#xa;"/>
                <bitField name="SI" size="1" mode="3" desc="SRAM disable (SI) - Disables accesses RAM if bit 14 (SE) is set to ‘1’.&#xa;"/>
                <bitField name="SE" size="1" mode="3" desc="SDRAM enable (SE) - Enables the SDRAM controller.&#xa;"/>
                <bitField name="RESERVED" size="1" mode="1" desc=""/>
                <bitField name="MS" size="1" mode="1" desc="Mobile SDR support enabled. ‘1’ = Enabled, ‘0’ = Disabled (read-only)"/>
                <bitField name="RESERVED" size="1" mode="1" desc=""/>
                <bitField name="D64" size="1" mode="1" desc="64-bit SDRAM data bus (D64) - Reads ‘1’ if the memory controller is configured for 64-bit SDRAM data bus width, ‘0’ otherwise. Read-only.&#xa;"/>
                <bitField name="SDRAM CMD" size="2" mode="3" desc="SDRAM command (SDRAM CMD) - Writing a non-zero value will generate a SDRAM command. “01”=PRECHARGE, “10”=AUTO-REFRESH, “11”=LOAD-COMMAND-REGISTER. The field is reset after the command has been executed.&#xa;"/>
                <bitField name="SDRAM COLSZ" size="2" mode="3" desc="SDRAM column size (SDRAM COLSZ) - “00”=256, “01”=512, “10”=1024, “11”=4096 when bit 25:23=”111” 2048 otherwise.&#xa;"/>
                <bitField name="SDRAM BANKSZ" size="3" mode="3" desc="SDRAM bank size (SDRAM BANKSZ) - Sets the bank size for SDRAM chip selects (“000”=4 Mbyte, “001”=8 Mbyte, “010”=16 Mbyte.... “111”=512 Mbyte).&#xa;"/>
                <bitField name="TCAS" size="1" mode="3" desc="SDRAM TCAS parameter (TCAS) - Selects 2 or 3 cycle CAS delay (0/1). When changed, a LOAD-COMMAND-REGISTER command must be issued at the same time. Also sets RAS/CAS delay (tRCD).&#xa;"/>
                <bitField name="SDRAM TRFC" size="3" mode="3" desc="SDRAM TRFC parameter (SDRAM TRFC) - tRFC will be equal to 3+field-value system clocks.&#xa;"/>
                <bitField name="TRP" size="1" mode="3" desc="SDRAM TRP parameter (TRP) - tRP will be equal to 2 or 3 system clocks (0/1).&#xa;"/>
                <bitField name="SDRF" size="1" mode="3" desc="SDRAM refresh (SDRF) - Enables SDRAM refresh.&#xa;"/>
               </register>
               <register name="MCFG3" addOffset="8">
                <bitField name="SDRAM REFRESH RELOAD VALUE" size="15" mode="3" desc="SDRAM refresh counter reload value (SDRAM REFRESH RELOAD VALUE)&#xa;&#xa;The period between each AUTO-REFRESH command is calculated as follows:&#xa;tREFRESH = ((reload value) + 1) / SYSCLK"/>
               </register>
               <register name="MCFG4(Power-Saving configuration)" addOffset="12">
                <bitField name="PASR" size="3" mode="3" desc="Partial Array Self Refresh (Read only when Mobile SDR support is disabled).&#xa;“000”: Full array (Banks 0, 1, 2 and 3)&#xa;“001”: Half array (Banks 0 and 1)&#xa;“010”: Quarter array (Bank 0)&#xa;“101”: One-eighth array (Bank 0 with row MSB = 0)&#xa;“110”: One-sixteenth array (Bank 0 with row MSB = 00)&#xa;"/>
                <bitField name="TCSR" size="2" mode="3" desc="Reserved for Temperature-Compensated Self Refresh (Read only when Mobile SDR support is disa-bled).&#xa;“00”: 70aC&#xa;“01”: 45aC&#xa;“10”: 15aC&#xa;“11”: 85aC&#xa;"/>
                <bitField name="DS" size="2" mode="3" desc="Selectable output drive strength (Read only when Mobile SDR support is disabled).&#xa;“00”: Full&#xa;“01”: One-half&#xa;“10”: One-quarter&#xa;“11”: Three-quarter&#xa;"/>
                <bitField name="PMODE" size="3" mode="3" desc="Power-Saving mode (Read only when Mobile SDR support is disabled).&#xa;“000”: none&#xa;“001”: Power-Down (PD)&#xa;“010”: Self-Refresh (SR)&#xa;“101”: Deep Power-Down (DPD)&#xa;"/>
                <bitField name="tXSR" size="4" mode="3" desc="SDRAM tXSR timing. tXSR will be equal to field-value system clocks. (Read only when Mobile SDR support is disabled).&#xa;"/>
                <bitField name="EM" size="1" mode="3" desc="EMR. When set, the LOAD-COMMAND-REGISTER command issued by the SDRAM command filed in MCFG2 will be interpret as a LOAD-EXTENDED-COMMAND-REGISTER command.&#xa;"/>
                <bitField name="CE" size="1" mode="3" desc="Clock enable (CE). This value is driven on the CKE inputs of the SDRAM. Should be set to ‘1’ for correct operation. This register bit is read only when Power-Saving mode is other then none.&#xa;"/>
                <bitField name="ME" size="1" mode="3" desc="Mobile SDRAM functionality enabled. ‘1’ = Enabled (support for Mobile SDRAM), ‘0’ = disabled (support for standard SDRAM)&#xa;"/>
               </register>
              </peripheral>
              <peripheral vid="1" name="IRQMP" pid="13">
               <register name="Interrupt level"/>
               <register name="Interrupt pending" addOffset="4"/>
               <register name="Interrupt force (NCPU=0)" addOffset="8"/>
               <register name="Interrupt clear" addOffset="12"/>
               <register name="Multiprocessor status" addOffset="16"/>
               <register name="Broadcast" addOffset="20"/>
               <register name="Processor interrupt mask" addOffset="64"/>
               <register name="Processor 1 interrupt mask" addOffset="68"/>
               <register name="Processor interrupt force" addOffset="128"/>
               <register name="Processor 1 interrupt force" addOffset="132"/>
               <register name="Processor extended interrupt acknowledge" addOffset="192"/>
               <register name="Processor 1 extended interrupt acknowledge" addOffset="196"/>
              </peripheral>
              <peripheral vid="1" name="GRSPW2" pid="41">
               <register name="Control"/>
               <register name="Status/Interrupt-source" addOffset="4"/>
               <register name="Node address" addOffset="8"/>
               <register name="Clock divisor" addOffset="12"/>
               <register name="Destination key" addOffset="16"/>
               <register name="Time" addOffset="20"/>
               <register name="DMA channel 1 control/status" addOffset="32"/>
               <register name="DMA channel 1 rx maximum length" addOffset="36"/>
               <register name="DMA channel 1 transmit descriptor table address" addOffset="40"/>
               <register name="DMA channel 1 receive descriptor table address" addOffset="44"/>
               <register name="DMA channel 1 address" addOffset="48"/>
               <register name="DMA channel 2 control/status" addOffset="64"/>
               <register name="DMA channel 2 rx maximum length" addOffset="68"/>
               <register name="DMA channel 2 transmit descriptor table address" addOffset="72"/>
               <register name="DMA channel 2 receive descriptor table address" addOffset="76"/>
               <register name="DMA channel 2 address" addOffset="80"/>
               <register name="DMA channel 3 control/status" addOffset="96"/>
               <register name="DMA channel 3 rx maximum length" addOffset="100"/>
               <register name="DMA channel 3 transmit descriptor table address" addOffset="104"/>
               <register name="DMA channel 3 receive descriptor table address" addOffset="108"/>
               <register name="DMA channel 3 address" addOffset="112"/>
               <register name="DMA channel 4 control/status" addOffset="128"/>
               <register name="DMA channel 4 rx maximum length" addOffset="132"/>
               <register name="DMA channel 4 transmit descriptor table address" addOffset="136"/>
               <register name="DMA channel 4 receive descriptor table address" addOffset="140"/>
               <register name="DMA channel 4 address" addOffset="144"/>
              </peripheral>
              <peripheral vid="1" name="SRCTRL" pid="8"/>
              <peripheral vid="1" name="SSRCTRL" pid="10">
               <register name="Memory configuration"/>
              </peripheral>
              <peripheral vid="1" name="AHBDPRAM" pid="15"/>
              <peripheral vid="1" name="GRGPIO" pid="26">
               <register name="Data">
                 <bitField name="DATA" size="32" mode="1" desc=""/>
               </register>
               <register name="Output" addOffset="4">
                 <bitField name="OUTPUT" size="32" mode="3" desc=""/>
               </register>
               <register name="Direction" addOffset="8">
                 <bitField name="DIRECTION" size="32" mode="3" desc=""/>
               </register>
               <register name="Interrupt mask" addOffset="12"/>
               <register name="Interrupt polarity" addOffset="16"/>
               <register name="Interrupt edge" addOffset="20"/>
               <register name="Bypass" addOffset="24"/>
               <register name="Capability" addOffset="28"/>
               <register name="IRQ map 0" addOffset="32"/>
               <register name="IRQ map 1" addOffset="36"/>
               <register name="IRQ map 2" addOffset="40"/>
               <register name="IRQ map 3" addOffset="44"/>
               <register name="IRQ map 4" addOffset="48"/>
               <register name="IRQ map 5" addOffset="52"/>
               <register name="IRQ map 6" addOffset="56"/>
               <register name="IRQ map 7" addOffset="60"/>
              </peripheral>
              <peripheral vid="1" name="GRSPW" pid="31">
               <register name="Control">
                 <bitField name="RA" size="1" offset="31" mode="1" desc="RMAP available (RA) - Set to one if the RMAP command handler is available. Only readable."/>
                 <bitField name="RX" size="1" offset="30" mode="1" desc="RX unaligned access (RX) - Set to one if unaligned writes are available for the receiver. Only read-
             able."/>
                 <bitField name="RC" size="1" offset="29" mode="1" desc="RMAP CRC available (RC) - Set to one if RMAP CRC is enabled in the core. Only readable."/>
                 <bitField name="PO" size="1" offset="26" mode="1" desc="The number of available SpaceWire ports minus one. Only readable."/>
                 <bitField name="PS" size="1" offset="21" mode="3" desc="Port select (PS) - Selects the active port when the no port force bit is zero. ‘0’ selects the port connected to data and strobe on index 0 while ‘1’ selects index 1. Only available if the ports VHDL
             generic is set to 2. Reset value: ‘0’."/>
                 <bitField name="NP" size="1" offset="20" mode="3" desc="No port force (NP) - Disable port force. When disabled the port select bit cannot be used to select the active port. Instead, it is automatically selected by checking the activity on the respective receive links. Only available if the ports VHDL generic is set to 2. Reset value: ‘0’ if the RMAP command handler is not available. If available the reset value is set to the value of the rmapen input signal."/>
                 <bitField name="RD" size="1" offset="17" mode="3" desc="RMAP buffer disable (RD) - Unused. If set only one RMAP buffer is used. This ensures that all RMAP commands will be executed consecutively. Only available if the rmap VHDL generic is set to1. Reset value: ‘0’."/>
                 <bitField name="RE" size="1" offset="16" mode="3" desc="RMAP Enable (RE) - Unused. Enable RMAP command handler. Only available if rmap VHDL generic is set to 1. Reset value: ‘1’."/>
                 <bitField name="TR" size="1" offset="11" mode="3" desc="Time Rx Enable (TR) - Enable time-code receptions. Reset value: ‘0’."/>
                 <bitField name="TT" size="1" offset="10" mode="3" desc="Time Tx Enable (TT) - Enable time-code transmissions. Reset value: ‘0’."/>
                 <bitField name="LI" size="1" offset="9" mode="3" desc="Link error IRQ (LI) - Generate interrupt when a link error occurs. Not reset."/>
                 <bitField name="TQ" size="1" offset="8" mode="3" desc="Tick-out IRQ (TQ) - Generate interrupt when a valid time-code is received. Not reset."/>
                 <bitField name="RS" size="1" offset="6" mode="3" desc="Reset (RS) - Make complete reset of the SpaceWire node. Self clearing. Reset value: ‘0’."/>
                 <bitField name="PM" size="1" offset="5" mode="3" desc="Promiscuous Mode (PM) - Enable Promiscuous mode. Reset value: ‘0’."/>
                 <bitField name="TI" size="1" offset="4" mode="3" desc="Tick In (TI) - The host can generate a tick by writing a one to this field. This will increment the timer counter and the new value is transmitted after the current character is transferred. A tick can also be generated by asserting the tick_in signal. Reset value: ‘0’."/>
                 <bitField name="IE" size="1" offset="3" mode="3" desc="Interrupt Enable (IE) - If set, an interrupt is generated when one or both of bit 8 to 9 is set and its corresponding event occurs. Reset value: ‘0’."/>
                 <bitField name="AS" size="1" offset="2" mode="3" desc="Autostart (AS) - Automatically start the link when a NULL has been received. Reset value: ‘0’ if the RMAP command handler is not available. If available the reset value is set to the value of the rmapen input signal."/>
                 <bitField name="LS" size="1" offset="1" mode="3" desc="Link Start (LS) - Start the link, i.e. allow a transition from ready to started state. Reset value: ‘0’."/>
                 <bitField name="LD" size="1" offset="0" mode="3" desc="Link Disable (LD) - Disable the SpaceWire codec. Reset value: ‘0’."/>
               </register>
               <register name="Status/Interrupt-source">
                 <bitField name="LS" size="3" offset="21" mode="1" desc="Link State (LS) - The current state of the start-up sequence. 0 = Error-reset, 1 = Error-wait, 2 = Ready, 3 = Started, 4 = Connecting, 5 = Run. Reset value: 0."/>
                 <bitField name="AP" size="1" offset="9" mode="1" desc="Active port (AP) - Shows the currently active port. ‘0’ = Port 0 and ‘1’ = Port 1 where the port numbers refer to the index number of the data and strobe signals. Only available if the ports generic is set to 2."/>
                 <bitField name="EE" size="1" offset="8" mode="1" desc="Early EOP/EEP (EE) - Set to one when a packet is received with an EOP after the first byte for a non-rmap packet and after the second byte for a RMAP packet. Cleared when written with a one. Reset value: ‘0’."/>
                 <bitField name="IA" size="1" offset="7" mode="1" desc="Invalid Address (IA) - Set to one when a packet is received with an invalid destination address field, i.e it does not match the nodeaddr register. Cleared when written with a one. Reset value: ‘0’."/>
                 <bitField name="WE" size="1" offset="6" mode="1" desc="Write synchronization Error (WE) - A synchronization problem has occurred when receiving NChars. Cleared when written with a one. Reset value: ‘0’."/>
                 <bitField name="PE" size="1" offset="4" mode="1" desc="Parity Error (PE) - A parity error has occurred. Cleared when written with a one. Reset value: ‘0’."/>
                 <bitField name="DE" size="1" offset="3" mode="1" desc="Disconnect Error (DE) - A disconnection error has occurred. Cleared when written with a one. Reset value: ‘0’."/>
                 <bitField name="ER" size="1" offset="2" mode="1" desc="Escape Error (ER) - An escape error has occurred. Cleared when written with a one. Reset value: ‘0’."/>
                 <bitField name="CE" size="1" offset="1" mode="1" desc="Credit Error (CE) - A credit has occurred. Cleared when written with a one. Reset value: ‘0’."/>
                 <bitField name="TO" size="1" offset="0" mode="1" desc="Tick Out (TO) - A new time count value was received and is stored in the time counter field. Cleared when written with a one. Reset value: ‘0’."/>
               </register>
               <register name="Node address">
                 <bitField name="NODEADDR" size="8" offset="0" mode="3" desc="Node address (NODEADDR) - 8-bit node address used for node identification on the SpaceWire network. Reset value: 254 (taken from the nodeaddr VHDL generic when /= 255, else from the rmapnodeaddr input signal)"/>
               </register>
               <register name="Clock divisor">
                 <bitField name="DATA" size="32" mode="1" desc=""/>
               </register>
               <register name="Destination key">
                 <bitField name="DESTKEY" size="8" offset="0" mode="3" desc="Destination key (DESTKEY) - RMAP destination key. Only available if the rmap VHDL generic is set to 1. Reset value: 0 (taken from the deskey VHDL generic)"/>
               </register>
               <register name="Time">
                 <bitField name="DATA" size="32" mode="1" desc=""/>
               </register>
               <register name="Timer end Disconnect">
                 <bitField name="DATA" size="32" mode="1" desc=""/>
               </register>
               <register name="DMA channel 1 control/status">
                 <bitField name="DATA" size="32" mode="1" desc=""/>
               </register>
               <register name="DMA channel 1 rx maximum length">
                 <bitField name="DATA" size="32" mode="1" desc=""/>
               </register>
               <register name="DMA channel 1 transmit descriptor table address">
                 <bitField name="DATA" size="32" mode="1" desc=""/>
               </register>
               <register name="DMA channel 1 control/status">
                 <bitField name="DATA" size="32" mode="1" desc=""/>
               </register>
               <register name="DMA channel 1 receive descriptor table address">
                 <bitField name="DATA" size="32" mode="1" desc=""/>
               </register>
              </peripheral>
+             <peripheral vid="1" name="SDCTRL" pid="9">
+              <register name="configuration" addOffset="0">
+               <bitField size="1" name="Refresh" offset="31" mode="3" desc="SDRAM refresh. If set, the SDRAM refresh will be enabled."/>
+               <bitField size="1" name="tRP" offset="30" mode="3" desc="SDRAM tRP timing. tRP will be equal to 2 or 3 system clocks (0/1). When mobile SDRAM support is enabled, this bit also represent the MSB in the tRFC timing."/>
+               <bitField name="tRFC" size="3" offset="27" mode="3" desc="SDRAM tRFC timing. tRFC will be equal to 3 + field-value system clocks. When mobile SDRAM support is enabled, this field is extended with the bit 30."/>
+               <bitField name="tCD" size="1" offset="26" mode="3" desc="SDRAM CAS delay. Selects 2 or 3 cycle CAS delay (0/1). When changed, a LOAD-COMMAND-REGISTER command must be issued at the same time. Also sets RAS/CAS delay (tRCD)."/>
+               <bitField name="SDRAM bank size" offset="23" size="3" mode="3" desc="SDRAM banks size. Defines the decoded memory size for each SDRAM chip select: “000”= 4 Mbyte, “001”= 8 Mbyte, “010”= 16 Mbyte .... “111”= 512 Mbyte."/>
+               <bitField name="SDRAM col. size" offset="21" size="2" mode="3" desc="SDRAM column size. “00”=256, “01”=512, “10”=1024, “11”=2048 except when bit[25:23]= ̆111 ̆then  ̆11 ̆=4096"/>
+               <bitField name="SDRAM command" offset="18" size="3" mode="3" desc="SDRAM command. Writing a non-zero value will generate an SDRAM command: “010”=PRE-CHARGE, “100”=AUTO-REFRESH, “110”=LOAD-COMMAND-REGISTER, “111”=LOAD-EXTENDED-COMMAND-REGISTER. The field is reset after command has been executed."/>
+               <bitField name="Page-Burst" offset="17" size="1" mode="3" desc="1 = pageburst is used for read operations, 0 = line burst of length 8 is used for read operations. (Only available when VHDL generic pageburst i set to 2)"/>
+               <bitField name="MS" offset="16" size="1" mode="3" desc="Mobile SDR support enabled. ‘1’ = Enabled, ‘0’ = Disabled (read-only)"/>
+               <bitField name="D64" offset="15" size="1" mode="3" desc="64-bit data bus (D64) - Reads ‘1’ if memory controller is configured for 64-bit data bus, otherwise‘0’. Read-only."/>
+               <bitField name="SDRAM refresh load value" offset="0" size="15" mode="3" desc="The period between each AUTO-REFRESH command - Calculated as follows: tREFRESH = ((reload value) + 1) / SYSCLK"/>
+              </register>
+              <register name="Power-Saving configuration" addOffset="4">
+              </register>
+             </peripheral>
             </soc>

src/PyWdgt/pythonconsole.cpp 0 -16

             #include "pythonconsole.h"
             #include <QPushButton>
             #include <QFile>
             #include <QTextStream>
             #include <QCustomPlot/qcustomplot.h>
             #include "../common/pythonQtOut/generated_cpp/PySocExplorer/PySocExplorer0.h"
             #include <PythonQt.h>
             #include "pluginloader.h"
             #include <socexplorer.h>
             void PythonQt_init_PySocExplorer(PyObject* module);
             void PythonQt_init_PySocExplorerEngine(PyObject* module) ;
             PythonConsole::PythonConsole(socexplorerproxy *proxy, QWidget *parent) :
                 QWidget(parent)
             {
-                //PythonQt::init();
                 PythonQt::init(PythonQt::RedirectStdOut);
                 PythonQt_QtAll::init();
                 this->proxy = proxy;
                 this->mainlayout = new QHBoxLayout;
                 this->mainContext = new PythonQtObjectPtr(PythonQt::self()->getMainModule());
                 this->mainContext->addVariable(QString("PYMODULES"),QVariant(QString(PYMODULES)));
                 this->console = new PythonQtScriptingConsoleDandD(NULL, PythonQt::self()->getMainModule());
                 this->mainlayout->addWidget(this->console);
                 this->setWindowTitle(tr("Python Scripting Console"));
-                this->bussdriver = 0;
                 this->setAcceptDrops(true);
                 this->setLayout(this->mainlayout);
                 connect(this->console,SIGNAL(pyConsoleRunFiles(QStringList)),this,SLOT(pyConsoleRunFiles(QStringList)));
                 this->mainContext->addObject("proxy", proxy);
                 PythonQt_init_PySocExplorer(0);
                 PythonQt_init_PySocExplorerEngine(0);
                 this->mainContext->evalScript(QString("from PythonQt import *"));
             }
             void PythonConsole::addObject(const QString& name, QObject* object)
             {
               this->mainContext->addObject(name, object);
             }
             void PythonConsole::removeVariable(const QString& name)
             {
               this->mainContext->removeVariable(name);
             }
-            void PythonConsole::setBussDriver(socexplorerplugin *driver)
-                this->bussdriver = driver;
-                this->mainContext->addObject("buss", this->bussdriver);
             void PythonConsole::registerObject(QObject* object,const QString& instanceName)
             {
                 this->mainContext->addObject(instanceName,object);
             }
             void PythonConsole::changeSysDriverInstName(const QString newinstanceName,const QString previnstanceName)
             {
                 socexplorerplugin* obj= this->proxy->getSysDriver(previnstanceName);
                 if(obj==NULL)obj= this->proxy->getSysDriver(newinstanceName);
                 if(obj==NULL)return;
             //    this->mainContext->addObject(newinstanceName,obj->getPyObjectWrapper());
                 this->mainContext->addObject(newinstanceName,obj);
                 this->mainContext->removeVariable(previnstanceName);
             }
             void PythonConsole::removeDriver(const QString& instanceName)
             {
                 this->mainContext->removeVariable(instanceName);
             }
-            void PythonConsole::removeBussDriver()
-                this->bussdriver = 0;
-                this->mainContext->removeVariable("buss");
-                emit this->rootDriverDelete();
             void PythonConsole::pyConsoleRunFiles(const QStringList & pathList)
             {
                 for (int i = 0; i < pathList.size() && i < 32; ++i)
                 {
                     this->pyConsoleRunFile(pathList.at(i));
                 }
             }
             void PythonConsole::pyConsoleRunFile(const QString& fileName)
             {
                 QString code;
                 QFile file;
                 QFileInfo fileinfo;
                 code.clear();
                 file.setFileName(fileName);
                 fileinfo.setFile(fileName);
                 if(!fileinfo.suffix().compare("py"))
                 {
                     QString CMD="execfile(\'"+fileName+"\')";
                     this->console->executePythonCommand(CMD);
                 }
             }
             QSize PythonConsole::sizeHint()
             {
                 return QSize(800,80);
             }

src/PyWdgt/pythonconsole.h 0 -4

             /*------------------------------------------------------------------------------
             --  This file is a part of the SocExplorer Software
             --  Copyright (C) 2011, Plasma Physics Laboratory - CNRS
             --
             --  This program is free software; you can redistribute it and/or modify
             --  it under the terms of the GNU General Public License as published by
             --  the Free Software Foundation; either version 2 of the License, or
             --  (at your option) any later version.
             --
             --  This program is distributed in the hope that it will be useful,
             --  but WITHOUT ANY WARRANTY; without even the implied warranty of
             --  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             --  GNU General Public License for more details.
             --
             --  You should have received a copy of the GNU General Public License
             --  along with this program; if not, write to the Free Software
             --  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
             -------------------------------------------------------------------------------*/
             /*--                  Author : Alexis Jeandet
             --                     Mail : alexis.jeandet@lpp.polytechnique.fr
             ----------------------------------------------------------------------------*/
             #ifndef PYTHONCONSOLE_H
             #define PYTHONCONSOLE_H
             #include <QWidget>
             #include <QDockWidget>
             #include <QHBoxLayout>
             #include <QtGui/QDragEnterEvent>
             #include <QtGui/QDragLeaveEvent>
             #include <QtGui/QDragMoveEvent>
             #include <QtGui/QDropEvent>
             #include <QtCore/QMimeData>
             #include <QtCore/QUrl>
             #include <QtCore/QList>
             #include "PythonQt.h"
             #include "PythonQt_QtAll.h"
             #include <gui/PythonQtScriptingConsole.h>
             #include "../plugins/socexplorerplugin.h"
             #include "pythonqtscriptingconsoledandd.h"
             #include <QMainWindow>
             #include "../proxy/socexplorerproxy.h"
             class SocExplorerMainWindow;
             class PythonConsole : public QWidget
             {
                 Q_OBJECT
             public:
                 explicit PythonConsole(socexplorerproxy* proxy,QWidget *parent = 0);
             signals:
                 void rootDriverDelete();
             public slots:
-                void setBussDriver(socexplorerplugin* driver);
-                void removeBussDriver();
                 void removeDriver(const QString& instanceName);
                 void pyConsoleRunFiles(const QStringList&);
                 void pyConsoleRunFile(const QString& fileName);
                 void registerObject(QObject* object,const QString& instanceName);
                 void changeSysDriverInstName(const QString newinstanceName,const QString previnstanceName);
                 void addObject(const QString& name, QObject* object);
                 void removeVariable(const QString& name);
             protected:
                 QSize sizeHint();
             private:
                 QHBoxLayout* mainlayout;
-                socexplorerplugin* bussdriver;
                 PythonQtScriptingConsoleDandD* console;
                 PythonQtObjectPtr*  mainContext;
                 socexplorerproxy* proxy;
-                //LPMONMainWindow* mainwin;
             };
             #endif // PYTHONCONSOLE_H

src/SocExplorerEngine/SocExplorerEngine.pro +16 -4

             SOCEXPLORER_ROOT = \"$${PWD}/../..\"
             include($${PWD}/../../build_cfg/socexplorer.pri)
             TARGET = socexplorerengine$${DEBUG_EXT}
             TEMPLATE = lib
             #more verbose plugin loader to debug plugin loading issues such as dependencies issues
             SOCEXPLORER_PLUGIN_LOADER="custom"
             SOCEXPLORER_CHAGESETNUM=$$system(hg id)
             isEmpty(SOCEXPLORER_CHAGESETNUM){
                 SOCEXPLORER_CHAGESETNUM=c258386c3c39+
             }
             SOCEXPLORER_CHAGESETNUMSTR = '\\"$${SOCEXPLORER_CHAGESETNUM}\\"'
             SOCEXPLORER_BRANCH=$$system(hg branch)
             isEmpty(SOCEXPLORER_BRANCH){
                 SOCEXPLORER_BRANCH=default
             }
             SOCEXPLORER_BRANCHSTR = '\\"$${SOCEXPLORER_BRANCH}\\"'
             DEFINES += SOCEXPLORER_VERSION="\"\\\"0.6.4"\\\"\"
             DEFINES += SOCEXPLORER_CHAGESET=\"$${SOCEXPLORER_CHAGESETNUMSTR}\"
             DEFINES += SOCEXPLORER_BRANCH=\"$${SOCEXPLORER_BRANCHSTR}\"
             message("Building SOCEXPLORER changeset $${SOCEXPLORER_CHAGESETNUM}")
             DEFINES += SOCEXPLORER_EXPORTS
             include ( plugins/socexplorerplugin.prf )
             include ( PeripheralWidget/PeripheralWidget.pri)
             win32:CONFIG += dll
             win32:CONFIG -= static
             win32:LIBS+=-L$${SOCEXPLORER_ROOT}/bin/win32 -lsocexplorercommon$${DEBUG_EXT}
             contains(SOCEXPLORER_PLUGIN_LOADER,"custom")
             {
                 unix:LIBS+= -ldl
                 unix:DEFINES += SOCEXPLORER_CUSTOM_PLUGIN_LOADER
                 unix:HEADERS += \
                 pluginloader/unix/unixpluginloader.h
                 unix:SOURCES += \
                 pluginloader/unix/unixpluginloader.cpp
             }
             target.path = $$[QT_INSTALL_LIBS]
             isEmpty(target.path) {
                     error(can\'t get QT_INSTALL_LIBS)
             }
             header.path = $$[QT_INSTALL_HEADERS]/SocExplorer
             header.files = engine/socexplorerengine.h \
                             pluginloader/pluginscache.h \
                             plugins/socexplorerplugin.h \
                             proxy/socexplorerproxy.h \
                             engine/socexplorerxmlfile.h \
                             SOC/socexplorerenumdevice.h \
                             XmlEngine/XMLmodel.h \
                             XmlEngine/XMLdata.h \
                             XmlEngine/xmldriver.h \
                             SOC/socmodel.h \
                             SOC/registerdata.h \
                             SOC/socclk.h \
                             PeripheralWidget/src/peripheralwidget.h \
                             PeripheralWidget/src/registerwidget.h \
                             PeripheralWidget/src/socregsviewer.h \
                             PeripheralWidget/src/socregsviewernew.h \
-                            memtester/memtester.h
+                            memtester/memtester.h \
+                            engine/socexplorersettings.h \
+                            engine/socexplorersettingsdialog.h \
+                            engine/socexplorergui.h\
+                            engine/socexplorerconfigkeys.h
             isEmpty(header.path) {
                     error(can\'t get QT_INSTALL_HEADERS)
             }
             pluginif.files = pluginsInterface/*.h \
                             pluginsInterface/*.cpp
             pluginif.path = $$[QT_INSTALL_HEADERS]/SocExplorer/pluginsInterface
             INSTALLS += target header pluginif
             INCLUDEPATH += engine \
                 pluginloader \
                 pluginsInterface \
                 proxy \
                 plugins \
                 pluginManagerWdgt \
                 ../common \
                 ../common/genericBinaryFiles \
                 ../ \
                 RegisterMVS \
                 XmlEngine \
                 SOC \
                 PeripheralWidget/src \
                 memtester
             HEADERS += \
                 pluginloader/pluginscache.h \
                 pluginloader/pluginloader.h \
                 pluginManagerWdgt/plugintree.h \
                 pluginManagerWdgt/pluginmanagerWDGT.h \
                 pluginManagerWdgt/pluginlist.h \
                 pluginManagerWdgt/plugininfoswdgt.h \
                 XmlEngine/XMLmodel.h \
                 XmlEngine/XMLdata.h \
                 SOC/socmodel.h  \
                 SOC/registerdata.h \
                 XmlEngine/xmldriver.h \
                 PeripheralWidget/src/peripheralwidget.h \
                 PeripheralWidget/src/registerwidget.h \
                 PeripheralWidget/src/socregsviewer.h \
                 SOC/socclk.h \
                 engine/socexplorerengine.h \
                 engine/socexplorerxmlfile.h \
                 plugins/socexplorerplugin.h \
                 pluginsInterface/socexplorerplugininterface.h \
                 pluginsInterface/socexplorerplugininterface_global.h \
                 proxy/socexplorerproxy.h \
                 SOC/socexplorerenumdevice.h \
                 PySocExplorerEngine.h \
                 memtester/memtester.h\
                 PeripheralWidget/src/socregsviewernew.h \
-                PeripheralWidget/src/collapsableperipheralwidget.h
+                PeripheralWidget/src/collapsableperipheralwidget.h \
+                engine/socexplorersettings.h \
+                engine/socexplorersettingsdialog.h \
+                engine/socexplorergui.h \
+                engine/socexplorerconfigkeys.h
             SOURCES += \
                 pluginloader/pluginscache.cpp \
                 pluginloader/pluginloader.cpp \
                 pluginManagerWdgt/plugintree.cpp \
                 pluginManagerWdgt/pluginmanagerWDGT.cpp \
                 pluginManagerWdgt/pluginlist.cpp \
                 pluginManagerWdgt/plugininfoswdgt.cpp \
                 XmlEngine/XMLmodel.cpp \
                 XmlEngine/XMLdata.cpp \
                 SOC/socmodel.cpp \
                 SOC/registerdata.cpp \
                 XmlEngine/xmldriver.cpp \
                 PeripheralWidget/src/peripheralwidget.cpp \
                 PeripheralWidget/src/registerwidget.cpp \
                 PeripheralWidget/src/socregsviewer.cpp \
                 SOC/socclk.cpp \
                 engine/socexplorerengine.cpp \
                 engine/socexplorerxmlfile.cpp \
                 proxy/socexplorerproxy.cpp \
                 SOC/socexplorerenumdevice.cpp \
                 plugins/socexplorerplugin.cpp \
                 memtester/memtester.cpp \
                 PeripheralWidget/src/socregsviewernew.cpp \
-                PeripheralWidget/src/collapsableperipheralwidget.cpp
+                PeripheralWidget/src/collapsableperipheralwidget.cpp \
+                engine/socexplorersettings.cpp \
+                engine/socexplorersettingsdialog.cpp \
+                engine/socexplorergui.cpp
             OTHER_FILES += \
                 plugins/socexplorerplugin.cpp \
                 pluginsInterface/socexplorerplugininterface.cpp \
                 plugins/socexplorerplugin.prf \
                 pythongenerator.sh \
                 pythonQtgeneratorCfg.txt
             FORMS += \
                 PeripheralWidget/src/socregsviewernew.ui \
-                PeripheralWidget/src/collapsableperipheralwidget.ui
+                PeripheralWidget/src/collapsableperipheralwidget.ui \
+                engine/socexplorersettingsdialog.ui
             RESOURCES += \
                 PeripheralWidget/ressources/peripheralwidget.qrc

src/SocExplorerEngine/engine/socexplorerengine.cpp +33 -2

             /*------------------------------------------------------------------------------
             --  This file is a part of the SocExplorer Software
             --  Copyright (C) 2012, Plasma Physics Laboratory - CNRS
             --
             --  This program is free software; you can redistribute it and/or modify
             --  it under the terms of the GNU General Public License as published by
             --  the Free Software Foundation; either version 2 of the License, or
             --  (at your option) any later version.
             --
             --  This program is distributed in the hope that it will be useful,
             --  but WITHOUT ANY WARRANTY; without even the implied warranty of
             --  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             --  GNU General Public License for more details.
             --
             --  You should have received a copy of the GNU General Public License
             --  along with this program; if not, write to the Free Software
             --  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
             -------------------------------------------------------------------------------*/
             /*--                  Author : Alexis Jeandet
             --                     Mail : alexis.jeandet@lpp.polytechnique.fr
             ----------------------------------------------------------------------------*/
             #include "socexplorerengine.h"
             #include <proxy/socexplorerproxy.h>
+            #include <socexplorersettings.h>
+            #include <socexplorercoresettingsgui.h>
+            #include <socexplorerconfigkeys.h>
             SocExplorerEngine* SocExplorerEngine::_self = NULL;
             socExplorerXmlModel* SocExplorerEngine::p_xmlmodel=NULL;
             QMainWindow* SocExplorerEngine::mainWindow=NULL;
             QList<SOCModel*>* SocExplorerEngine::SOCs=NULL;
+            QSettings* SocExplorerEngine::m_settings=NULL;
             int SocExplorerEngine::loglvl=1;
             SocExplorerEngine::SocExplorerEngine(QObject *parent) :
                 QObject(parent)
             {
                 if(SOCs==NULL)
                 {
                     SOCs = new QList<SOCModel*>;
                 }
+                m_settings = new QSettings();
+                SocExplorerCoreSettingsGUI* cfggui=new SocExplorerCoreSettingsGUI();
+                SocExplorerSettings::registerConfigEntry(cfggui,QIcon(":/images/config.svg"),"SocExplorer Core");
             }
             void SocExplorerEngine::init()
             {
                 QDir dir;
                 if(!_self)
                 {
                     _self= new SocExplorerEngine;
                 }
                 if(!dir.exists(configFolder()))
                     dir.mkdir(configFolder());
                 p_xmlmodel = new socExplorerXmlModel(_self);
                 p_xmlmodel->updateSOClist();
             }
             QString SocExplorerEngine::configFolder()
             {
                 return QString(SOCEXPLORER_CONFIG_PATH);
             }
             QStringList SocExplorerEngine::pluginFolders()
             {
                 if(!_self)
                     init();
                 QStringList folders;
                 QDir pluginFolders(QString(SOCEXPLORER_CONFIG_PATH)+"/plugin.conf.d");
                 if(pluginFolders.exists())
                 {
                     pluginFolders.setFilter(QDir::Files | QDir::NoSymLinks);
                     QFileInfoList list = pluginFolders.entryInfoList();
                     for (int i = 0; i < list.size(); ++i)
                     {
                         QFileInfo fileInfo = list.at(i);
                         if(fileInfo.suffix()=="conf")
                         {
                             QFile confFile(fileInfo.absoluteFilePath());
                             if(confFile.open(QIODevice::ReadOnly))
                             {
                                 while (!confFile.atEnd())
                                 {
                                     QString line = confFile.readLine();
                                     QDir plugDir(line.remove("\n"));
                                     if(plugDir.exists() && !folders.contains(plugDir.absolutePath()))
                                     {
                                         folders.append(plugDir.absolutePath());
                                     }
                                 }
                             }
                         }
                     }
                 }
+                QStringList localCfg = SocExplorerSettings::value(SOCEXPLORERENGINE_SETTINGS_SCOPE,SOCEXPLORERENGINE_SETTINGS_PLUGINS_LOOKUP_PATH).toString().split(";");
+                QString dir;
+                foreach (dir, localCfg)
+                {
+                    QDir plugDir(dir);
+                    if(plugDir.exists())
+                        folders.append(dir);
+                }
                 return folders;
             }
             SOCModel *SocExplorerEngine::plugin2Soc(socexplorerplugin *plugin)
             {
                 if(!_self)
                     init();
                 if(plugin)
                 {
                     while (plugin->parent!=NULL) {
                         plugin = plugin->parent;
                     }
                     for(int i=0;i<SOCs->count();i++)
                     {
                         if(SOCs->at(i)->isRootDev(plugin))
                             return SOCs->at(i);
                     }
                     //no soc found so create a new one
                     SOCModel* soc=new SOCModel(plugin);
                     SOCs->append(soc);
                     return soc;
                 }
                 return NULL;
             }
             int SocExplorerEngine::addEnumDevice(socexplorerplugin* rootPlugin,int VID, int PID, qint32 baseAddress, const QString &name)
             {
                 if(!_self)
                     init();
                 SOCModel* soc = plugin2Soc(rootPlugin);
                 if(soc && !soc->enumDeviceExists(baseAddress))
                 {
                     emit _self->enumDeviceAdded(soc->addEnumDevice(VID,PID,baseAddress,name));
                     return 1;
                 }
                 return 0;
             }
             QList<SOCModel *> *SocExplorerEngine::getSOCs()
             {
                 if(!_self)
                     init();
                 return SOCs;
             }
             qint32 SocExplorerEngine::getEnumDeviceBaseAddress(const QString& rootPlugin,int VID, int PID, int count)
             {
                 socexplorerplugin* plugin = socexplorerproxy::findPlugin(rootPlugin);
                 if(plugin==NULL)return -1;
                 SOCModel* soc = plugin2Soc(plugin);
                 if(soc==NULL)
                     return -1;
                 return soc->getEnumDeviceBaseAddress(VID,PID,count);
             }
             qint32 SocExplorerEngine::getEnumDeviceBaseAddress(socexplorerplugin *plugin, int VID, int PID, int count)
             {
                 if(plugin==NULL)return -1;
                 SOCModel* soc = plugin2Soc(plugin);
                 if(soc==NULL)
                     return -1;
                 return soc->getEnumDeviceBaseAddress(VID,PID,count);
             }
             qint32 SocExplorerEngine::getEnumDeviceCount(socexplorerplugin *plugin, int VID, int PID)
             {
                 if(plugin==NULL)return 0;
                 SOCModel* soc = plugin2Soc(plugin);
                 if(soc==NULL)
                     return 0;
                 return soc->getEnumDeviceCount(VID,PID);
             }
             qint32 SocExplorerEngine::getEnumDeviceCount(const QString &rootPlugin, int VID, int PID)
             {
                 socexplorerplugin* plugin = socexplorerproxy::findPlugin(rootPlugin);
                 if(plugin==NULL)return 0;
                 SOCModel* soc = plugin2Soc(plugin);
                 if(soc==NULL)
                     return 0;
                 return soc->getEnumDeviceCount(VID,PID);
             }
             int SocExplorerEngine::addEnumDevice(const QString &rootPlugin, int VID, int PID, qint32 baseAddress, const QString &name)
             {
                 socexplorerplugin* plugin = socexplorerproxy::findPlugin(rootPlugin);
                 if(plugin==NULL)return -1;
                 SOCModel* soc = plugin2Soc(plugin);
                 if(soc==NULL)
                     return -1;
                 soc->addEnumDevice(VID,PID,baseAddress,name);
                 return  1;
             }
             unsigned int SocExplorerEngine::memMeasureSize(socexplorerplugin *plugin, unsigned int address, unsigned int maxSize)
             {
               return MemTester::measureMemSize(plugin,address,maxSize);
             }
             unsigned int SocExplorerEngine::memMeasureSize(const QString &plugin, unsigned int address, unsigned int maxSize)
             {
               return MemTester::measureMemSize(plugin,address,maxSize);
             }
             QString SocExplorerEngine::getDevName(int VID, int PID)
             {
                 QList<QDomNodeList> list=p_xmlmodel->getAllNodes("peripheral");
                 for(int i=0;i<list.count();i++)
                 {
                     QDomNodeList nodes=list.at(i);
                     for(int l=0;l<nodes.count();l++)
                     {
                         QDomElement node=nodes.at(l).toElement();
                         int nodeVID=node.attribute("vid","0").toInt();
                         int nodePID=node.attribute("pid","0").toInt();
                         if((nodeVID==VID)&&(nodePID==PID))
                         {
                             return node.attribute("name","Unknow device");
                         }
                     }
                 }
                 return QString("Unknow device");
             }
             QString SocExplorerEngine::SocExplorerVersion(){return QString(SOCEXPLORER_VERSION);}
             QString SocExplorerEngine::SocExplorerChangeset(){return QString(SOCEXPLORER_CHAGESET).split(" ").at(0);}
             QString SocExplorerEngine::SocExplorerBranch(){return QString(SOCEXPLORER_BRANCH);}
             socExplorerXmlModel *SocExplorerEngine::xmlModel()
             {
                 if(!_self)
                     init();
                 return p_xmlmodel;
             }
             void SocExplorerEngine::setMainWindow(QMainWindow *Mainwindow)
             {
                 if(!_self)
                     init();
                 mainWindow=Mainwindow;
             }
             QProgressBar *SocExplorerEngine::getProgressBar(const QString& format, int max)
             {
                 if(!_self)
                     init();
                 QProgressBar* progressBar;
                 if(mainWindow!=NULL)
                 {
                     progressBar = new QProgressBar(mainWindow);
                     mainWindow->statusBar()->addWidget(progressBar);
                 }
                 else
                 {
                     progressBar = new QProgressBar();
                 }
                 progressBar->setMaximum(max);
                 progressBar->setFormat(format);
                 return progressBar;
             }
             void SocExplorerEngine::deleteProgressBar(QProgressBar *progressBar)
             {
                 if(mainWindow!=NULL)
                 {
                     mainWindow->statusBar()->removeWidget(progressBar);
                 }
                 delete progressBar;
             }
             void SocExplorerEngine::addSOC(socexplorerplugin *rootPlugin)
             {
                 plugin2Soc(rootPlugin);
             }
             void SocExplorerEngine::removeSOC(socexplorerplugin *rootPlugin)
             {
                 SOCModel* soc=plugin2Soc(rootPlugin);
                 SOCs->removeAll(soc);
                 delete soc;
             }
             void SocExplorerEngine::message(socexplorerplugin *sender, const QString &message, int debugLevel)
             {
+                if(!_self)
+                    init();
+                 SocExplorerEngine::message(sender->instanceName(),message,debugLevel);
+            }
+            void SocExplorerEngine::message(QObject *sender, const QString &message, int debugLevel)
+            {
+                if(!_self)
+                    init();
+                 SocExplorerEngine::message(sender->objectName(),message,debugLevel);
+            }
+            void SocExplorerEngine::message(const QString &sender, const QString &message, int debugLevel)
+            {
                 // TODO add multi output message manager IE also log in files
+                static QTextStream SocExplorerEngineStdout(stdout);
                 if(!_self)
                     init();
                 if(loglvl>=debugLevel)
-                    qDebug()<< QTime::currentTime().toString()+" " + sender->instanceName()+":"+message;
+                    SocExplorerEngineStdout << QTime::currentTime().toString()+" " + sender+":"+message << endl;
             }
             void SocExplorerEngine::setLogLevel(int level)
             {
                 if(!_self)
                     init();
                 printf("Set log level to %d\n",level);
                 loglvl = level;
             }
             bool SocExplorerEngine::isSocLitleEndian(socexplorerplugin *plugin)
             {
               return plugin2Soc(plugin)->isLitleEndian();
             }

src/SocExplorerEngine/engine/socexplorerengine.h +4 0

             /*------------------------------------------------------------------------------
             --  This file is a part of the SocExplorer Software
             --  Copyright (C) 2012, Plasma Physics Laboratory - CNRS
             --
             --  This program is free software; you can redistribute it and/or modify
             --  it under the terms of the GNU General Public License as published by
             --  the Free Software Foundation; either version 2 of the License, or
             --  (at your option) any later version.
             --
             --  This program is distributed in the hope that it will be useful,
             --  but WITHOUT ANY WARRANTY; without even the implied warranty of
             --  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             --  GNU General Public License for more details.
             --
             --  You should have received a copy of the GNU General Public License
             --  along with this program; if not, write to the Free Software
             --  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
             -------------------------------------------------------------------------------*/
             /*--                  Author : Alexis Jeandet
             --                     Mail : alexis.jeandet@lpp.polytechnique.fr
             ----------------------------------------------------------------------------*/
             #ifndef SOCEXPLORERENGINE_H
             #define SOCEXPLORERENGINE_H
             #include <stdint.h>
             #include <QObject>
             #include <QtWidgets>
             #include <QStringList>
             #include <QDomDocument>
             #include <QDomElement>
             #include <QDomNodeList>
             #include <QFile>
             #include <QTextStream>
             #include <QDir>
             #include <QApplication>
             #include <QtCore/qglobal.h>
             #include <QFileDialog>
             #include <socexplorerxmlfile.h>
             #include <socexplorerenumdevice.h>
             #include <XMLmodel.h>
             #include <peripheralwidget.h>
             #include <registerwidget.h>
             #include <socmodel.h>
             #include <memtester.h>
+            #include <QSettings>
             #if defined(SOCEXPLORER_SDK_BUILD)
             #  define SOCEXPLORER_SDK_EXPORT Q_DECL_EXPORT
             #else
             #  define SOCEXPLORER_SDK_EXPORT Q_DECL_IMPORT
             #endif
             class SOCEXPLORER_SDK_EXPORT SocExplorerAutoProgressBar
             {
             public:
                 SocExplorerAutoProgressBar(QProgressBar* progressBar=NULL)
                 {
                     this->p_progressbar=progressBar;
                 }
                  ~SocExplorerAutoProgressBar()
                 {
                     if(p_progressbar)
                     {
                         delete p_progressbar;
                     }
                 }
                 void setProgressBar(QProgressBar* progressBar)
                 {
                     this->p_progressbar=progressBar;
                 }
                 void setValue(int value)
                 {
                     p_progressbar->setValue(value);
                 }
             private:
                 QProgressBar* p_progressbar;
             };
             //! SocExplorerEngine is a pure static class which aims to provide services for both SocExplorer software and plugins.
             class SOCEXPLORER_SDK_EXPORT SocExplorerEngine : public QObject
             {
                 Q_OBJECT
             private:
                 static SocExplorerEngine* _self;
+                static QSettings* m_settings;
                 SocExplorerEngine(QObject *parent = 0);
                 static void init();
             public:
                 static SocExplorerEngine* self(){ if(!_self){_self= new SocExplorerEngine;}return _self;}
                 //! Return the configuration folder path, OS dependant.
                 SOCEXPLORER_SDK_EXPORT static QString configFolder();
                 //! Return the default plugin folder path, OS dependant.
                  static QStringList pluginFolders();
                  static QString configPath(){return QString(SOCEXPLORER_CONFIG_PATH);}
                  static QString sharePath(){return QString(SOCEXPLORER_SHARE_PATH);}
                  static int addEnumDevice(socexplorerplugin* rootPlugin,int VID,int PID,qint32 baseAddress,const QString& name);
                  static QList<SOCModel*>* getSOCs();
                  static QString getDevName(int VID, int PID);
                  static QString SocExplorerVersion();
                  static QString SocExplorerChangeset();
                  static QString SocExplorerBranch();
                  static socExplorerXmlModel* xmlModel();
                  static void setMainWindow(QMainWindow* Mainwindow);
                  static QProgressBar* getProgressBar(const QString &format, int max);
                  static void deleteProgressBar(QProgressBar* progressBar);
                  static void addSOC(socexplorerplugin* rootPlugin);
                  static void removeSOC(socexplorerplugin* rootPlugin);
                  static void message(socexplorerplugin* sender,const QString& message,int debugLevel=0);
+                 static void message(QObject* sender,const QString& message,int debugLevel=0);
+                 static void message(const QString& sender,const QString& message,int debugLevel=0);
                  static void setLogLevel(int level);
                  static bool isSocLitleEndian(socexplorerplugin* plugin);
             signals:
                  void enumDeviceAdded(socExplorerEnumDevice* device);
             public slots:
                  QString getSocExplorerVersion(){return SocExplorerEngine::SocExplorerVersion();}
                  QString getSocExplorerChangeset(){return SocExplorerEngine::SocExplorerChangeset();}
                  QString getSocExplorerBranch(){return SocExplorerEngine::SocExplorerBranch();}
                  qint32 getEnumDeviceBaseAddress(const QString& rootPlugin,int VID,int PID,int count=0);
                  qint32 getEnumDeviceBaseAddress(socexplorerplugin* plugin,int VID,int PID,int count=0);
                  qint32 getEnumDeviceCount(socexplorerplugin* plugin,int VID,int PID);
                  qint32 getEnumDeviceCount(const QString& rootPlugin,int VID,int PID);
                  int addEnumDevice(const QString& rootPlugin,int VID,int PID,qint32 baseAddress,const QString& name);
                  unsigned int memMeasureSize(socexplorerplugin* plugin, unsigned int address,unsigned int maxSize=0xFFFFFFFF);
                  unsigned int memMeasureSize(const QString& plugin, unsigned int address,unsigned int maxSize=0xFFFFFFFF);
             private:
                 static SOCModel* plugin2Soc(socexplorerplugin* plugin);
                 static socExplorerXmlModel* p_xmlmodel;
                 static QMainWindow* mainWindow;
                 static QList<SOCModel*>* SOCs;
                 static int loglvl;
             };
             #endif // SOCEXPLORERENGINE_H

src/SocExplorerEngine/pluginManagerWdgt/pluginmanagerWDGT.cpp 0 -44

             /*------------------------------------------------------------------------------
             --  This file is a part of the SocExplorer Software
             --  Copyright (C) 2011, Plasma Physics Laboratory - CNRS
             --
             --  This program is free software; you can redistribute it and/or modify
             --  it under the terms of the GNU General Public License as published by
             --  the Free Software Foundation; either version 2 of the License, or
             --  (at your option) any later version.
             --
             --  This program is distributed in the hope that it will be useful,
             --  but WITHOUT ANY WARRANTY; without even the implied warranty of
             --  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             --  GNU General Public License for more details.
             --
             --  You should have received a copy of the GNU General Public License
             --  along with this program; if not, write to the Free Software
             --  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
             -------------------------------------------------------------------------------*/
             /*--                  Author : Alexis Jeandet
             --                     Mail : alexis.jeandet@lpp.polytechnique.fr
             ----------------------------------------------------------------------------*/
             #include "pluginmanagerWDGT.h"
             #include "pluginloader.h"
             #include <QFileDialog>
             #include <unistd.h>
             #include <qsvgicon.h>
             #include <socexplorerengine.h>
             #define mkbutton(button,text,image)button = new QPushButton();\
             button->setIcon(QSvgIcon(image));\
             button->setIconSize(QSize(16,16));\
             button->setToolTip(text)
             pluginmanagerWDGT::pluginmanagerWDGT(QWidget *parent) :
                 QSplitter(parent)
             {
                 this->setWindowTitle("Plugin Manager");
                 this->setOrientation(Qt::Vertical);
                 this->pluginListWidgetContainer = new QWidget();
                 this->mainlayoutSpliter = new QSplitter;
                 this->pluginListLayout = new QVBoxLayout();
                 this->mainlayoutSpliter->setOrientation(Qt::Vertical);
                 this->treeview = new plugintree();
                 this->pluginTable = new PluginList;
                 this->ButtonsLayout = new QHBoxLayout();
                 this->ButtonsLayout->addStretch();
                 this->pluginListLayout->addLayout(this->ButtonsLayout);
                 this->addWidget(this->treeview);
                 this->pluginListWidgetContainer->setLayout(this->pluginListLayout);
                 this->addWidget(this->pluginListWidgetContainer);
                 this->pluginListLayout->addWidget(this->pluginTable);
                 this->pluginInfos = new pluginInfosWdgt;
                 mkbutton(this->addPluginBt,tr("add plugin"),":/images/open.svg");
                 mkbutton(this->removePluginBt,tr("remove plugin(s)"),":/images/trash.svg");
                 mkbutton(this->refreshPluginListBt,tr("Refresh Plugin(s) list"),":/images/refresh.svg");
                 this->ButtonsLayout->addWidget(this->addPluginBt);
                 this->ButtonsLayout->addWidget(this->refreshPluginListBt);
                 this->ButtonsLayout->addWidget(this->removePluginBt);
                 this->addWidget(this->pluginInfos);
                 connect(this->treeview,SIGNAL(geteplugintree()),this,SIGNAL(geteplugintree()));
                 connect(this,SIGNAL(treeChanged(QList<socexplorerplugin*>)),this->treeview,SLOT(treeChanged(QList<socexplorerplugin*>)));
                 connect(this->pluginTable,SIGNAL(currentRowChanged(int)),this,SLOT(libselected(int)));
                 connect(this->pluginTable,SIGNAL(itemSelectionChanged(QStringList)),this->pluginInfos,SLOT(updateInfos(QStringList)));
                 connect(this->addPluginBt,SIGNAL(clicked()),this,SLOT(addPlugin()));
                 connect(this->removePluginBt,SIGNAL(clicked()),this,SLOT(removePlugin()));
                 connect(this->pluginTable,SIGNAL(itemDoubleClicked(QListWidgetItem*)),this,SLOT(loadplugin(QListWidgetItem*)));
                 connect(this->refreshPluginListBt,SIGNAL(clicked()),this->pluginTable,SLOT(refreshPluginList()));
                 connect(this->treeview,SIGNAL(loadSysDriver(QString)),this,SIGNAL(loadSysDrviver(QString)));
                 connect(this->treeview,SIGNAL(loadSysDriverToParent(QString,QString)),this,SIGNAL(loadSysDriverToParent(QString,QString)));
                 connect(this->treeview,SIGNAL(changeSysDriverInstName(QString,QString)),this,SIGNAL(changeSysDriverInstName(QString,QString)));
                 connect(this->treeview,SIGNAL(closeSysDriver(QString)),this,SIGNAL(closeSysDriver(QString)));
                 connect(this->treeview,SIGNAL(pluginselected(QString)),this,SIGNAL(pluginselected(QString)));
                 this->rootLoadable = false;
                 this->childLoadable = false;
                 this->pluginTable->refreshPluginList();
                 this->pluginTable->refreshPluginList();
             }
             void pluginmanagerWDGT::setRootLoadable(bool flag)
             {
                 this->rootLoadable = flag;
             }
             void pluginmanagerWDGT::setChildLoadable(bool flag)
             {
                 this->childLoadable = flag;
             }
-            void pluginmanagerWDGT::addPlugin()
-            //   /!\  TODO update it remove maximum operation from widget
-            //    QString fileName = QFileDialog::getOpenFileName(this,tr("Open Plugin"), QDir::homePath(), tr("Plugin Files Files (*.dll *.so *.so.*)"));
-            //    if(pluginloader::checklibrary(fileName))
-            //    {
-            //        QFile::copy(fileName,QString(SocExplorerEngine::pluginFolder())+"/"+ fileName.section('/',-1));
-            //    }
-            //    this->pluginTable->refreshPluginList();
-            void pluginmanagerWDGT::removePlugin()
-            //    for(int i=0;i<this->pluginTable->selectedItems().count();i++)
-            //    {
-            //        QListWidgetItem* item = this->pluginTable->selectedItems().at(i);
-            //        if(item!=NULL)
-            //        {
-            //            QFile::remove(QString(SocExplorerEngine::pluginFolder())+"/"+item->text());
-            //        }
-            //    }
-            //    this->pluginTable->refreshPluginList();
-            void pluginmanagerWDGT::loadplugin()
-            //    for(int i=0;i<this->pluginTable->selectedItems().count();i++)
-            //    {
-            //        QListWidgetItem* item = this->pluginTable->selectedItems().at(i);
-            //        if(item!=NULL)
-            //        {
-            //            QString plugin = QString(SocExplorerEngine::pluginFolder())+"/"+item->text();
-            //            emit this->loadSysDrviver(plugin);
-            //        }
-            //    }
-            //    this->pluginTable->refreshPluginList();

src/SocExplorerEngine/pluginManagerWdgt/pluginmanagerWDGT.h +1 -5

             /*------------------------------------------------------------------------------
             --  This file is a part of the SocExplorer Software
             --  Copyright (C) 2011, Plasma Physics Laboratory - CNRS
             --
             --  This program is free software; you can redistribute it and/or modify
             --  it under the terms of the GNU General Public License as published by
             --  the Free Software Foundation; either version 2 of the License, or
             --  (at your option) any later version.
             --
             --  This program is distributed in the hope that it will be useful,
             --  but WITHOUT ANY WARRANTY; without even the implied warranty of
             --  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             --  GNU General Public License for more details.
             --
             --  You should have received a copy of the GNU General Public License
             --  along with this program; if not, write to the Free Software
             --  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
             -------------------------------------------------------------------------------*/
             /*--                  Author : Alexis Jeandet
             --                     Mail : alexis.jeandet@lpp.polytechnique.fr
             ----------------------------------------------------------------------------*/
             #ifndef PLUGINMANAGERWDGT_H
             #define PLUGINMANAGERWDGT_H
             #include <QApplication>
             #include <QWidget>
             #include <QDockWidget>
             #include <QVBoxLayout>
             #include <QHBoxLayout>
             #include <QTableWidget>
             #include <QDir>
             #include <QStringList>
             #include <QFileInfoList>
             #include <QFileInfo>
             #include <QTextEdit>
             #include <QPushButton>
             #include <QSplitter>
             #include "plugininfoswdgt.h"
             #include "pluginlist.h"
             #include <socexplorerplugin.h>
             #include <QList>
             #include "plugintree.h"
             #if defined(SOCEXPLORER_SDK_BUILD)
             #  define SOCEXPLORER_SDK_EXPORT Q_DECL_EXPORT
             #else
             #  define SOCEXPLORER_SDK_EXPORT Q_DECL_IMPORT
             #endif
             class pluginmanagerWDGT : public QSplitter
             {
                 Q_OBJECT
             public:
             SOCEXPLORER_SDK_EXPORT        explicit pluginmanagerWDGT(QWidget *parent = 0);
             SOCEXPLORER_SDK_EXPORT        void setRootLoadable(bool flag);
             SOCEXPLORER_SDK_EXPORT        void setChildLoadable(bool flag);
             signals:
                 void updatepluginInfo(const QString libname);
                 void loadSysDrviver(const QString name);
                 void loadSysDriverToParent(const QString name, const QString instanceName);
                 void geteplugintree(void);
                 void treeChanged(const QList<socexplorerplugin*>& drivers);
                 void changeSysDriverInstName(const QString newinstanceName,const QString previnstanceName);
                 void closeSysDriver(const QString instanceName);
                 void pluginselected(const QString& instanceName);
             public slots:
-                //void libselected(int row);
-                void addPlugin();
-                void removePlugin();
-                void loadplugin();
-                //void loadplugin(QListWidgetItem*);
             private:
                 bool rootLoadable;
                 bool childLoadable;
                 QWidget* pluginListWidgetContainer;
                 QVBoxLayout* pluginListLayout;
                 QHBoxLayout* ButtonsLayout;
                 QSplitter* mainlayoutSpliter;
                 PluginList* pluginTable;
                 pluginInfosWdgt* pluginInfos;
                 plugintree* treeview;
                 QPushButton* addPluginBt;
                 QPushButton* removePluginBt;
                 QPushButton* loadPluginBt;
                 QPushButton* refreshPluginListBt;
             };
             #endif // PLUGINMANAGERWDGT_H

src/SocExplorerEngine/pluginloader/pluginloader.cpp +4 -33

             #include "pluginloader.h"
             #include <QDir>
             #include <QFile>
             #include <QFileInfoList>
             #include <QFileInfo>
             #include <QString>
             #include <QStringList>
             #include <QLabel>
             #include <QSettings>
             #include <QApplication>
             #include <QCoreApplication>
             #include <socexplorerengine.h>
             #ifdef SOCEXPLORER_CUSTOM_PLUGIN_LOADER
             #include "unix/unixpluginloader.h"
             #endif
+            #include <socexplorerengine.h>
+            #include <socexplorersettings.h>
             pluginloader* pluginloader::_self = NULL;
             PluginsCache* pluginloader::_cache = NULL;
             QStringList* pluginloader::_folderList = NULL;
             pluginloader::pluginloader()
             {
                 _cache = new PluginsCache();
                 _folderList = new QStringList();
                 _folderList->append(SocExplorerEngine::pluginFolders());
                 scanFolders();
             }
-            QStringList pluginloader::readFoldersList(const QStringList confFiles)
-                QDir testDir;
-                QStringList folders;
-                QFile confFile;
-                for(int i=0;i<confFiles.count();i++)
-                    confFile.setFileName(confFiles.at(i));
-                    if(confFile.exists())
-                        if (confFile.open(QIODevice::ReadOnly | QIODevice::Text))
-                            QTextStream in(&confFile);
-                            QString line = in.readLine();
-                            while (!line.isNull())
-                                testDir.setPath(line);
-                                if(testDir.exists())
-                                    if(!folders.contains(line))
-                                        folders << line;
-                                line = in.readLine();
-                return folders;
             void pluginloader::scanFolders()
             {
                 QDir dir;
                 QStringList filters;
                 filters <<"*.so"<< "*.dll";
                 _cache->flush();
                 for(int d=0;d<_folderList->count();d++)
                 {
                     dir.setPath(_folderList->at(d));
                     dir.setFilter(QDir::Files);
                     dir.setNameFilters(filters);
                     QFileInfoList list = dir.entryInfoList();
                     for (int i = 0; i < list.size(); ++i)
                     {
                         QFileInfo fileInfo = list.at(i);
+                        SocExplorerEngine::message("pluginloader::scanFolders","Checking "+ fileInfo.filePath(),3);
                         if(checklibrary(fileInfo.filePath())!=0)
                         {
                             _cache->append(fileInfo.fileName(),fileInfo.path(),_getlibName(fileInfo.filePath()),_getlibPID(fileInfo.filePath()),_getlibPID(fileInfo.filePath()));
                         }
                     }
                 }
             }
             int pluginloader::p_checklibraryQlib(const QString fileName)
             {
                 QLibrary* lib = new QLibrary;
                 lib->setFileName(fileName);
                 lib->setLoadHints(QLibrary::PreventUnloadHint);
                 lib->load();
                 if(!lib->isLoaded())
                 {
-                    qDebug()<<lib->errorString();
+                    SocExplorerEngine::message("pluginloader::p_checklibraryQlib",lib->errorString(),3);
                     lib->~QLibrary();
                     lib = new QLibrary(fileName);
                     lib->load();
                 }
                 delete lib;
                 if(QLibrary::resolve(fileName,"socexplorerpluginCreateObject"))
                 {
                     if(QLibrary::resolve(fileName,"socexplorerpluginpid"))
                     {
                         if(QLibrary::resolve(fileName,"socexplorerpluginvid"))
                         {
                             if(QLibrary::resolve(fileName,"socexplorerpluginVersion"))
                             {
                                 if(QLibrary::resolve(fileName,"socexplorerpluginAuthor"))
                                 {
                                     if(QLibrary::resolve(fileName,"socexplorerpluginDescription"))
                                     {
                                         return 1;
                                     }
                                 }
                             }
                         }
                     }
                 }
                 return 0;
             }
             int pluginloader::p_checklibraryCustom(const QString fileName)
             {
             #ifdef SOCEXPLORER_CUSTOM_PLUGIN_LOADER
                 unixPluginLoader lib(fileName);
                 if(NULL!=lib.resolve("socexplorerpluginCreateObject"))
                 {
                     if(NULL!=lib.resolve("socexplorerpluginpid"))
                     {
                         if(NULL!=lib.resolve("socexplorerpluginvid"))
                         {
                             if(NULL!=lib.resolve("socexplorerpluginVersion"))
                             {
                                 if(NULL!=lib.resolve("socexplorerpluginAuthor"))
                                 {
                                     if(NULL!=lib.resolve("socexplorerpluginDescription"))
                                     {
                                         return 1;
                                     }
                                 }
                             }
                         }
                     }
                 }
             #endif
                 return 0;
             }
             socexplorerplugin *pluginloader::p_newsocexplorerpluginQlib(const QString Name)
             {
                 QString* libfile= _cacheLookup(Name);
                 if(libfile==NULL)return NULL;
                 QLibrary* lib = new QLibrary(*libfile);
                 delete libfile;
                 socexplorerpluginCreateObjectT newDrvr = NULL;
                 newDrvr=(socexplorerpluginCreateObjectT)lib->resolve("socexplorerpluginCreateObject");
                 if(newDrvr==NULL)
                 {
                     return NULL;
                 }
                 return (socexplorerplugin*) newDrvr();
             }
             socexplorerplugin *pluginloader::p_newsocexplorerpluginCustom(const QString Name)
             {
             #ifdef SOCEXPLORER_CUSTOM_PLUGIN_LOADER
                 QString* libfile= _cacheLookup(Name);
                 if(libfile==NULL)return NULL;
                 unixPluginLoader lib(*libfile);
                 delete libfile;
                 socexplorerpluginCreateObjectT newDrvr = NULL;
                 newDrvr=(socexplorerpluginCreateObjectT)lib.resolve("socexplorerpluginCreateObject");
                 if(newDrvr==NULL)
                 {
                     return NULL;
                 }
                 return (socexplorerplugin*) newDrvr();
             #endif
             }
             QList<PluginsCacheItem*> pluginloader::listAvailiables(bool rescan)
             {
                 if(_self==NULL)
                 {
                     init();
                     return _cache->listDrivers();
                 }
                 if(rescan)
                 {
                     scanFolders();
                 }
                 return _cache->listDrivers();
             }
             void pluginloader::init()
             {
                 if(_self==NULL)
                 {
                     _self=new pluginloader();
                 }
             }
             pluginloader* pluginloader::self()
             {
                 if(_self==NULL)
                 {
                     init();
                 }
                 return _self;
             }
             bool pluginloader::isvalid(QString Name)
             {
                 if(_self==NULL)init();
                 QString* libfile= _cacheLookup(Name);
                 if(libfile==NULL)return false;
                 else
                 {
                     delete libfile;
                     return true;
                 }
             }
             int pluginloader::checklibrary(const QString fileName)
             {
             #ifdef SOCEXPLORER_CUSTOM_PLUGIN_LOADER
                 return _self->p_checklibraryCustom(fileName);
             #else
                 return _self->p_checklibraryQlib(fileName);
             #endif
             }
             socexplorerplugin* pluginloader::newsocexplorerplugin(const QString Name)
             {
             #ifdef SOCEXPLORER_CUSTOM_PLUGIN_LOADER
                 return _self->p_newsocexplorerpluginCustom(Name);
             #else
                 return _self->p_newsocexplorerpluginQlib(Name);
             #endif
             }
             QString pluginloader::getlibTypeStr(QString Name)
             {
                 if(_self==NULL)init();
                 QString* libfile= _cacheLookup(Name);
                 if(libfile==NULL)return NULL;
                 QLibrary* lib = new QLibrary(*libfile);
                 delete libfile;
                 lib->load();
                 if(lib->isLoaded())
                 {
                     socexplorerpluginTypeT plugintype = (socexplorerpluginTypeT)lib->resolve("socexplorerpluginType");
                     if(plugintype!=NULL)
                     {
                         pluginT type = plugintype();
                         switch(type)
                         {
                         case ComDriverT:
                             ////lib->unload();
                             lib->~QLibrary();
                             return QObject::tr("Comunaication Driver Plugin.");
                             break;
                         case PerifDriverT:
                             ////lib->unload();
                             lib->~QLibrary();
                             return QObject::tr("Periferial Driver Plugin.");
                             break;
                         default:
                             ////lib->unload();
                             lib->~QLibrary();
                             return QObject::tr("Unknow Plugin.");
                             break;
                         }
                     }
                 }
                 lib->~QLibrary();
                 return QObject::tr("Can't load Plugin.");
             }
             pluginT pluginloader::getlibType(QString Name)
             {
                 if(_self==NULL)init();
                 QString* libfile= _cacheLookup(Name);
                 if(libfile==NULL)return (pluginT)NULL;
                 QLibrary* lib = new QLibrary(*libfile);
                 delete libfile;
                 lib->load();
                 if(lib->isLoaded())
                 {
                     socexplorerpluginTypeT plugintype = (socexplorerpluginTypeT)lib->resolve("socexplorerpluginType");
                     if(plugintype!=NULL)
                     {
                         return plugintype();
                     }
                 }
                 lib->~QLibrary();
                 return -1;
             }
             QString pluginloader::getlibVersion(const QString Name)
             {
                 if(_self==NULL)init();
                 QString* libfile= _cacheLookup(Name);
                 if(libfile==NULL)return NULL;
                 QLibrary* lib = new QLibrary(*libfile);
                 delete libfile;
                 lib->load();
                 if(lib->isLoaded())
                 {
                     socexplorerpluginVersionT pluginversion = (socexplorerpluginVersionT)lib->resolve("socexplorerpluginVersion");
                     if(pluginversion!=NULL)
                     {
                         QString version = pluginversion();
                         ////lib->unload();
                         lib->~QLibrary();
                         return version;
                     }
                 }
                 lib->~QLibrary();
                 return QObject::tr("Can't load Plugin.");
             }
             QString pluginloader::getlibPIDstr(const QString Name)
             {
                 return QString("0x" + QString::number(pluginloader::getlibPID(Name) , 16));
             }
             QString pluginloader::getlibVIDstr(const QString Name)
             {
                 return QString("0x" + QString::number(pluginloader::getlibVID(Name) , 16));
             }
             int pluginloader::libcanbechild(const QString Name)
             {
                 if(_self==NULL)init();
                 QString* libfile= _cacheLookup(Name);
                 if(libfile==NULL)return (int)NULL;
                 QLibrary* lib = new QLibrary(*libfile);
                 delete libfile;
                 lib->load();
                 if(lib->isLoaded())
                 {
                     socexplorerplugincanbechildT canbechild = (socexplorerplugincanbechildT)lib->resolve("socexplorerplugincanbechild");
                     if(canbechild!=NULL)
                     {
                         int value = canbechild();
                         ////lib->unload();
                         //lib->~QLibrary();
                         return value;
                     }
                 }
                 //lib->~QLibrary();
                 return 0;
             }
             int pluginloader::libcanberoot(const QString Name)
             {
                 if(_self==NULL)init();
                 QString* libfile= _cacheLookup(Name);
                 if(libfile==NULL)return (int)NULL;
                 QLibrary* lib = new QLibrary(*libfile);
                 delete libfile;
                 lib->load();
                 if(lib->isLoaded())
                 {
                     socexplorerplugincanberootT canberoot = (socexplorerplugincanberootT)lib->resolve("socexplorerplugincanberoot");
                     if(canberoot!=NULL)
                     {
                         int value = canberoot();
                         ////lib->unload();
                         //lib->~QLibrary();
                         return value;
                     }
                 }
                 delete lib;
                 //lib->~QLibrary();
                 return 0;
             }
             int pluginloader::getlibVID(const QString Name)
             {
                 if(_self==NULL)init();
                 QString* libfile= _cacheLookup(Name);
                 if(libfile==NULL)return 0;
                 QString file(*libfile);
                 delete libfile;
                 return _getlibVID(file);
             }
             int pluginloader::getlibPID(const QString Name)
             {
                 if(_self==NULL)init();
                 QString* libfile= _cacheLookup(Name);
                 if(libfile==NULL)return 0;
                 QString file(*libfile);
                 delete libfile;
                 return _getlibPID(file);
             }
             QString pluginloader::getlibAuthor(const QString Name)
             {
                 if(_self==NULL)init();
                 QString* libfile= _cacheLookup(Name);
                 if(libfile==NULL)return NULL;
                 QLibrary* lib = new QLibrary(*libfile);
                 delete libfile;
                 lib->load();
                 if(lib->isLoaded())
                 {
                     socexplorerpluginAuthorT pluginauthor = (socexplorerpluginAuthorT)lib->resolve("socexplorerpluginAuthor");
                     if(pluginauthor!=NULL)
                     {
                         QString author = pluginauthor();
                         ////lib->unload();
                         lib->~QLibrary();
                         return author;
                     }
                 }
                 lib->~QLibrary();
                 return QObject::tr("Can't load Plugin.");
             }
             QString pluginloader::getlibName(const QString Name)
             {
                 if(_self==NULL)init();
                 QString* libfile= _cacheLookup(Name);
                 if(libfile==NULL)return QString("");
                 QString file(*libfile);
                 delete libfile;
                 return _getlibName(file);
             }
             QString pluginloader::getlibDescription(const QString Name)
             {
                 if(_self==NULL)init();
                 QString* libfile= _cacheLookup(Name);
                 if(libfile==NULL)return NULL;
                 QLibrary* lib = new QLibrary(*libfile);
                 delete libfile;
                 lib->load();
                 if(lib->isLoaded())
                 {
                     socexplorerpluginDescriptionT plugindescription = (socexplorerpluginDescriptionT)lib->resolve("socexplorerpluginDescription");
                     if(plugindescription!=NULL)
                     {
                         QString description = plugindescription();
                         ////lib->unload();
                         lib->~QLibrary();
                         return description;
                     }
                 }
                 lib->~QLibrary();
                 return QObject::tr("Can't load Plugin.");
             }
             QString pluginloader::getlibDir(const QString Name)
             {
                 if(_self==NULL)init();
                 return *_cacheLookup(Name);
             }
             QString pluginloader::_getlibName(const QString fileName)
             {
                 QLibrary* lib = new QLibrary(fileName);
                 lib->load();
                 if(lib->isLoaded())
                 {
                     socexplorerpluginNameT pluginName = (socexplorerpluginAuthorT)lib->resolve("socexplorerpluginName");
                     if(pluginName!=NULL)
                     {
                         QString name = pluginName();
                         //lib->unload();
                         lib->~QLibrary();
                         return name;
                     }
                 }
                 lib->~QLibrary();
                 return QObject::tr("Can't load Plugin.");
             }
             int pluginloader::_getlibPID(const QString fileName)
             {
                 QLibrary* lib = new QLibrary(fileName);
                 lib->load();
                 if(lib->isLoaded())
                 {
                     socexplorerpluginpidT pluginpid = (socexplorerpluginpidT)lib->resolve("socexplorerpluginpid");
                     if(pluginpid!=NULL)
                     {
                         int pid = pluginpid();
                         //lib->unload();
                         lib->~QLibrary();
                         return pid;
                     }
                 }
                 lib->~QLibrary();
                 return 0;
             }
             int pluginloader::_getlibVID(const QString fileName)
             {
                 QLibrary* lib = new QLibrary(fileName);
                 lib->load();
                 if(lib->isLoaded())
                 {
                     socexplorerpluginvidT pluginvid = (socexplorerpluginvidT)lib->resolve("socexplorerpluginvid");
                     if(pluginvid!=NULL)
                     {
                         int vid = pluginvid();
                         //lib->unload();
                         lib->~QLibrary();
                         return vid;
                     }
                 }
                 lib->~QLibrary();
                 return 0;
             }
             QString* pluginloader::_cacheLookup(const QString Name)
             {
                 QString* libfile= new QString(_cache->first(Name));
                 if(!QFile::exists(*libfile))
                 {
                     scanFolders();
                     *libfile = _cache->first(Name);
                     if(QFile::exists(*libfile))return libfile;
                 }
                 else
                 {
                     return libfile;
                 }
                 delete libfile;
                 return NULL;
             }
             /*QString findlib(QString name)
             {
             }*/

src/SocExplorerEngine/pluginloader/pluginloader.h 0 -1

             /*------------------------------------------------------------------------------
             --  This file is a part of the SocExplorer Software
             --  Copyright (C) 2011, Plasma Physics Laboratory - CNRS
             --
             --  This program is free software; you can redistribute it and/or modify
             --  it under the terms of the GNU General Public License as published by
             --  the Free Software Foundation; either version 2 of the License, or
             --  (at your option) any later version.
             --
             --  This program is distributed in the hope that it will be useful,
             --  but WITHOUT ANY WARRANTY; without even the implied warranty of
             --  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             --  GNU General Public License for more details.
             --
             --  You should have received a copy of the GNU General Public License
             --  along with this program; if not, write to the Free Software
             --  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
             -------------------------------------------------------------------------------*/
             /*--                  Author : Alexis Jeandet
             --                     Mail : alexis.jeandet@lpp.polytechnique.fr
             ----------------------------------------------------------------------------*/
             #ifndef PLUGINLOADER_H
             #define PLUGINLOADER_H
             #include <QString>
             #include <QLibrary>
             #include <QObject>
             #include <QStringList>
             #include <socexplorerplugininterface.h>
             #include <socexplorerplugin.h>
             #include <pluginscache.h>
             /*
               Debug
             */
             #include <stdio.h>
             #define loadlib(filename)   QLibrary* lib = new QLibrary((fileName));\
                                         lib->load();\
                                         if(!lib->isLoaded())\
                                         {\
                                             return 0;\
                                         }
             class pluginloader
             {
             private:
                 static pluginloader* _self;
                 static PluginsCache* _cache;
                 static QStringList* _folderList;
                 ~pluginloader();
                 pluginloader();
             public:
                 static void init();
                 static pluginloader* self();
                 static int checklibrary(const QString fileName);
                 static bool isvalid(QString Name);
                 static socexplorerplugin* newsocexplorerplugin(const QString Name);
                 static QString getlibTypeStr(QString Name);
                 static pluginT getlibType(QString Name);
                 static QString getlibVersion(const QString Name);
                 static QString getlibPIDstr(const QString Name);
                 static QString getlibVIDstr(const QString Name);
                 static int getlibPID(const QString Name);
                 static int getlibVID(const QString Name);
                 static int libcanbechild(const QString Name);
                 static int libcanberoot(const QString Name);
                 static QString getlibAuthor(const QString Name);
                 static QString getlibName(const QString Name);
                 static QString getlibDescription(const QString Name);
                 static QString getlibDir(const QString Name);
                 static QString findlib(QString name);
                 static QList<PluginsCacheItem *> listAvailiables(bool rescan=true);
                 static void scanFolders();
                 static void showCache(){_cache->show();}
             private:
                 int p_checklibraryQlib(const QString fileName);
                 int p_checklibraryCustom(const QString fileName);
                 socexplorerplugin* p_newsocexplorerpluginQlib(const QString Name);
                 socexplorerplugin* p_newsocexplorerpluginCustom(const QString Name);
-                static QStringList readFoldersList(const QStringList confFiles);
                 static QString* _cacheLookup(const QString Name);
                 static QString _getlibName(const QString fileName);
                 static int _getlibPID(const QString fileName);
                 static int _getlibVID(const QString fileName);
             };
             #endif

src/SocExplorerEngine/pluginloader/pluginscache.cpp +3 -2

             #include "pluginscache.h"
             #include <QDebug>
+            #include <socexplorerengine.h>
             PluginsCacheItem::PluginsCacheItem(const QString &fileName, const QString &path, const QString &pluginName, int VID, int PID)
             {
                 this->fileName = new QString(fileName);
                 this->path = new QString(path);
                 this->pluginName = new QString(pluginName);
                 this->VID = VID;
                 this->PID = PID;
             }
             bool PluginsCacheItem::comparePluginName(const QString& pluginName)
             {
                 return (!this->pluginName->compare(pluginName));
             }
             bool PluginsCacheItem::comparefileName(const QString &fileName)
             {
                 bool same=false;
                 same|=!(this->fileName->compare(fileName));
                 same|=!(this->fileName->compare(fileName+".so"));
                 same|=!(this->fileName->compare("lib"+fileName+".so"));
                 return same;
             }
             bool PluginsCacheItem::comparefilePath(const QString &filePath)
             {
                 return (!QString::compare(*this->path +"/"+*this->fileName,filePath));
             }
             bool PluginsCacheItem::compareIDs(int VID,int PID)
             {
                 return (VID==this->VID && PID==this->PID);
             }
             bool PluginsCacheItem::compare(PluginsCacheItem *item)
             {
                 return comparefilePath(item->getpath()+"/"+item->getfileName());
             }
             PluginsCache::PluginsCache(QObject* parent)
                 :QObject(parent)
             {
                 this->items = new QList<PluginsCacheItem*>;
                 this->__view =NULL;
             }
             void PluginsCache::append(const QString &fileName, const QString &path, const QString &pluginName, int VID, int PID)
             {
                 PluginsCacheItem* item=new PluginsCacheItem(fileName,path,pluginName,  VID,  PID);
                 for(int i=0;i<this->items->count();i++)
                 {
                     if(this->items->at(i)->compare(item))
                     {
-                        qDebug()<< fileName << "already in the cache";
+                        SocExplorerEngine::message("PluginsCache",fileName + " already in the cache",3);
                         delete item;
                         return;
                     }
                 }
-                qDebug()<< fileName << "added to cache";
+                SocExplorerEngine::message("PluginsCache",fileName + " added to cache",3);
                 this->items->append(item);
             }
             QString PluginsCache::first(const QString& pluginName)
             {
                 for(int i=0;i<this->items->count();i++)
                 {
                     if(this->items->at(i)->comparePluginName(pluginName))
                     {
                         return QString(this->items->at(i)->getpath()+"/"+this->items->at(i)->getfileName());
                     }
                     if(this->items->at(i)->comparefileName(pluginName))
                     {
                         return QString(this->items->at(i)->getpath()+"/"+this->items->at(i)->getfileName());
                     }
                     if(this->items->at(i)->comparefilePath(pluginName))
                     {
                         return QString(this->items->at(i)->getpath()+"/"+this->items->at(i)->getfileName());
                     }
                 }
                 return QString("");
             }
             QString PluginsCache::first(int VID,int PID)
             {
                 for(int i=0;i<this->items->count();i++)
                 {
                     if(this->items->at(i)->compareIDs(VID,PID))
                     {
                         return QString(this->items->at(i)->getpath()+"/"+this->items->at(i)->getfileName());
                     }
                 }
                 return QString("");
             }
             QList<PluginsCacheItem *> PluginsCache::listDrivers()
             {
                 return *items;
             }
             void PluginsCache::flush()
             {
                 PluginsCacheItem* ptr;
                 for(int i=0;i<this->items->count();i++)
                 {
                     ptr=this->items->at(i);
                     this->items->removeAt(i);
                     delete ptr;
                 }
             }
             void PluginsCache::show()
             {
                 if(this->__view==NULL)this->__view = new QTableWidget(0,5);
                 if(!this->__view->isVisible())
                 {
                     this->__view->clear();
                     this->__view->setHorizontalHeaderLabels(QStringList()<<"File Name"<<"Path"<<"PluginName"<<"VID"<<"PID");
                     QTableWidgetItem* item;
                     this->__view->setRowCount(this->items->count());
                     for(int i=0;i<this->items->count();i++)
                     {
                         item = new QTableWidgetItem(items->at(i)->getfileName());
                         item->setFlags(Qt::ItemIsEnabled|Qt::ItemIsSelectable);
                         this->__view->setItem(i,0,item);
                         item = new QTableWidgetItem(items->at(i)->getpath());
                         item->setFlags(Qt::ItemIsEnabled|Qt::ItemIsSelectable);
                         this->__view->setItem(i,1,item);
                         item = new QTableWidgetItem(items->at(i)->getpluginName());
                         item->setFlags(Qt::ItemIsEnabled|Qt::ItemIsSelectable);
                         this->__view->setItem(i,2,item);
                         item = new QTableWidgetItem(QString::number(items->at(i)->getVID()));
                         item->setFlags(Qt::ItemIsEnabled|Qt::ItemIsSelectable);
                         this->__view->setItem(i,3,item);
                         item = new QTableWidgetItem(QString::number(items->at(i)->getPID()));
                         item->setFlags(Qt::ItemIsEnabled|Qt::ItemIsSelectable);
                         this->__view->setItem(i,4,item);
                     }
                     this->__view->resizeRowsToContents();
                     this->__view->resizeColumnsToContents();
                     this->__view->show();
                 }
             }

src/SocExplorerEngine/pluginloader/unix/unixpluginloader.cpp +8 -7

             #include "unixpluginloader.h"
             #include <stdio.h>
             #include <QDebug>
+            #include <socexplorerengine.h>
             unixPluginLoader::unixPluginLoader(const QString &libPath)
             {
-                qDebug()<<"try to open "+libPath;
+                SocExplorerEngine::message("unixPluginLoader::unixPluginLoader","try to open "+libPath,3);
                 dlHandle = dlopen(libPath.toStdString().c_str(),RTLD_LAZY|RTLD_GLOBAL);
                 if(dlHandle==NULL)
-                    qDebug() << "Failed"<< dlerror();
+                    SocExplorerEngine::message("unixPluginLoader::unixPluginLoader",QString("Failed ") + dlerror(),3);
                 else
-                    qDebug() << "Success";
+                    SocExplorerEngine::message("unixPluginLoader::unixPluginLoader","Success " ,3);
                 this->libPath = libPath;
             }
             void *unixPluginLoader::resolve(const QString &symbol)
             {
                 if(dlHandle!=NULL)
                 {
-                    qDebug()<<"try to resolve "+symbol+" in "+libPath;
+                    SocExplorerEngine::message("unixPluginLoader::resolve","try to resolve "+symbol+" in "+libPath ,3);
                     void* sym =  dlsym (dlHandle, symbol.toStdString().c_str());
                     if(sym==NULL)
-                        qDebug() << "Failed"<< dlerror();
+                        SocExplorerEngine::message("unixPluginLoader::resolve",QString("Failed")+ dlerror() ,3);
                     else
-                        qDebug() << "Success";
+                        SocExplorerEngine::message("unixPluginLoader::resolve","Success",3);
                     return sym;
                 }
                 return NULL;
             }
             void unixPluginLoader::close()
             {
                 if(dlHandle!=NULL)
                 {
                     dlclose(dlHandle);
-                    qDebug() << dlerror();
+                    SocExplorerEngine::message("unixPluginLoader::close",dlerror(),3);
                 }
             }

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

             /*------------------------------------------------------------------------------
             --  This file is a part of the SocExplorer Software
             --  Copyright (C) 2014, Plasma Physics Laboratory - CNRS
             --
             --  This program is free software; you can redistribute it and/or modify
             --  it under the terms of the GNU General Public License as published by
             --  the Free Software Foundation; either version 2 of the License, or
             --  (at your option) any later version.
             --
             --  This program is distributed in the hope that it will be useful,
             --  but WITHOUT ANY WARRANTY; without even the implied warranty of
             --  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             --  GNU General Public License for more details.
             --
             --  You should have received a copy of the GNU General Public License
             --  along with this program; if not, write to the Free Software
             --  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
             -------------------------------------------------------------------------------*/
             /*--                  Author : Alexis Jeandet
             --                     Mail : alexis.jeandet@lpp.polytechnique.fr
             ----------------------------------------------------------------------------*/
             #include <socexplorerplugin.h>
             #include <abstractbinfile.h>
             #include <srec/srecfile.h>
             #include <BinFile/binaryfile.h>
             int socexplorerplugin::isConnected(){return this->Connected;}
             QString socexplorerplugin::baseName(){return *_Name;}
             int socexplorerplugin::baseAddress(){return this->BaseAddress;}
             void socexplorerplugin::setBaseAddress(unsigned int baseAddress){this->BaseAddress = baseAddress;}
             QString socexplorerplugin::instanceName()
             {
               return this->_instanceName;
             }
             int socexplorerplugin::registermenu(QMenu *menu)
             {
               this->menu = menu->addMenu(this->_instanceName);
               this->closeAction = this->menu->addAction(tr("Close plugin"));
               QObject::connect(this->closeAction,SIGNAL(triggered()),this,SLOT(closeMe()));
               this->ChildsMenu = this->menu->addMenu(QString("Childs"));
               for(int i=0;i<this->childs.count();i++)
                 {
                   this->childs.at(i)->registermenu(this->ChildsMenu);
                 }
               emit this->registerObject((QObject*)this,this->instanceName());
               return 0;
             }
             void socexplorerplugin::postInstantiationTrigger()
             {
               return;
             }
             unsigned int socexplorerplugin::Write(unsigned int *Value, unsigned int count, unsigned int address)
             {
               if(parent!=NULL)
                 {
                   return parent->Write(Value,count,address);
                 }
               return 0;
             }
             unsigned int socexplorerplugin::Read(unsigned int *Value, unsigned int count, unsigned int address)
             {
               if(parent!=NULL)
                 {
                   return parent->Read(Value,count,address);
                 }
               return 0;
             }
             QVariantList socexplorerplugin::Read(unsigned int address,unsigned int count)
             {
                 unsigned int data[count];
                 QVariantList result;
                 Read(data,count,address);
                 for(unsigned int i = 0;i<count;i++)
                 {
                     result.append(QVariant((int)data[i]));
                 }
                 return result;
             }
             void socexplorerplugin::Write(unsigned int address,QList<QVariant> dataList)
             {
                 unsigned int data[dataList.count()];
                 for(int i = 0;i<dataList.count();i++)
                 {
                     data[i] = (unsigned int)dataList.at(i).toUInt();
                 }
                 Write(data,dataList.count(),address);
             }
             void socexplorerplugin::closeMe(){emit this->closePlugin(this);}
             void socexplorerplugin::activate(bool flag){this->setEnabled(flag);emit this->activateSig(flag);}
             void socexplorerplugin::setInstanceName(const QString &newName)
             {
               this->_instanceName = newName;
               if(this->menu)
                 this->menu->setTitle(this->_instanceName);
               this->setWindowTitle(newName);
+              this->setObjectName(newName);
             }
             bool socexplorerplugin::dumpMemory(unsigned int address, unsigned int count, QString file)
             {
               unsigned int* buffer = (unsigned int*)malloc(count*sizeof(unsigned int));
               if(buffer!=NULL)
                 {
                   this->Read(buffer,count,address);
                   QFile outfile(file);
                   if (!outfile.open(QIODevice::ReadWrite | QIODevice::Text))
                     return false;
                   QTextStream out(&outfile);
                   for(int i=0;(unsigned int)i<count;i++)
                     out << "0x"+QString::number(address+(i*4),16) + ": 0x" + QString::number(buffer[i],16) + "\n";
                   free(buffer);
                   out.flush();
                   outfile.close();
                   return true;
                 }
               return false;
             }
             bool socexplorerplugin::memSet(unsigned int address, int value, unsigned int count)
             {
               unsigned int* buffer = (unsigned int*)malloc(count*sizeof(unsigned int));
               if(buffer!=NULL)
                 {
                   memset((void*)buffer,value,count*sizeof(unsigned int));
                   this->Write(buffer,count,address);
                   free(buffer );
                   return true;
                 }
               return false;
             }
             bool socexplorerplugin::loadbin(unsigned int address, QString file)
             {
               QFile infile(file);
               if (!infile.open(QIODevice::ReadOnly))
                 return false;
               uint32_t* buffer = (uint32_t*)malloc(infile.size());
               if(buffer!=NULL)
                 {
                   infile.read((char*)buffer,infile.size());
                   for(int i=0;i<(infile.size()/4);i++)
                     {
                       buffer[i] = socexplorerBswap32(buffer[i]);
                     }
                   this->Write(buffer,infile.size()/4,address);
                   free(buffer);
                   return true;
                 }
               return false;
             }
             bool socexplorerplugin::loadfile(abstractBinFile *file)
             {
               if(file->isopened())
                 {
                   QList<codeFragment*> fragments= file->getFragments();
                   for(int i=0;i<fragments.count();i++)
                     {
                       int size = fragments.at(i)->size/4;
                       // TODO fixme, should be the oposite
             #if __BYTE_ORDER == __LITTLE_ENDIAN
                       if(!file->litleendian)
                         {
                           uint32_t* buffer = (uint32_t*)malloc(fragments.at(i)->size);
                           memcpy(buffer,fragments.at(i)->data,fragments.at(i)->size);
                           if(buffer!=NULL)
                             {
                               for(int l=0;l<(size);l++)
                                 {
                                   buffer[l] = socexplorerBswap32(buffer[l]);
                                 }
                               this->Write(buffer,size,fragments.at(i)->address);
                               free(buffer);
                             }
                         }
                       else
                         {
                           this->Write((uint32_t*) fragments.at(i)->data,size,fragments.at(i)->address);
                         }
             #elif __BYTE_ORDER == __BIG_ENDIAN
                       if(file->litleendian)
                         {
                           uint32_t* buffer = (uint32_t*)malloc(fragments.at(i)->size);
                           memcpy(buffer,fragments.at(i)->data,fragments.at(i)->size);
                           if(buffer!=NULL)
                             {
                               for(int l=0;l<(size);l++)
                                 {
                                   buffer[l] = socexplorerBswap32(buffer[l]);
                                 }
                               this->Write(buffer,size,fragments.at(i)->address);
                               free(buffer);
                             }
                         }
                       else
                         {
                           this->Write((uint32_t*) fragments.at(i)->data,size,fragments.at(i)->address);
                         }
             #endif
                     }
                 }
               return true;
             }
             bool socexplorerplugin::dumpMemory(unsigned int address, unsigned int count, QString file, const QString &format)
             {
               unsigned int* buffer = (unsigned int*)malloc(count*sizeof(unsigned int));
               if(buffer!=NULL)
                 {
                   this->Read(buffer,count,address);
                   if(!format.compare("srec",Qt::CaseInsensitive))
                     {
                       //need to convert from in memory endianness to file endianness
                       //SREC is always big endian
             #if __BYTE_ORDER == __LITTLE_ENDIAN
                       for(int l=0;l<(count);l++)
                         {
                           buffer[l] = socexplorerBswap32(buffer[l]);
                         }
             #elif __BYTE_ORDER == __BIG_ENDIAN
             #endif
                       codeFragment fragment((char*)buffer,count*4,address);
                       srecFile::toSrec(QList<codeFragment*>()<<&fragment,file);
                     }
                   if(!format.compare("bin",Qt::CaseInsensitive))
                     {
                       //beware this format is not portable from a big endian host to a litle endian one
                       codeFragment fragment((char*)buffer,count*4,address);
                       binaryFile::toBinary(QList<codeFragment*>()<<&fragment,file);
                     }
                   if(!format.compare("hexa",Qt::CaseInsensitive))
                     {
                       QFile outfile(file);
                       if (!outfile.open(QIODevice::ReadWrite | QIODevice::Text))
                         return false;
                       QTextStream out(&outfile);
                       for(int i=0;(unsigned int)i<count;i++)
                         out << "0x"+QString::number(address+(i*4),16) + ": 0x" + QString::number(buffer[i],16) + "\n";
                       free(buffer);
                       out.flush();
                       outfile.close();
                     }
                   return true;
                 }
               return false;
             }

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

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

src/SocExplorerEngine/proxy/socexplorerproxy.cpp +70 -7

             /*------------------------------------------------------------------------------
             --  This file is a part of the SocExplorer Software
             --  Copyright (C) 2011, Plasma Physics Laboratory - CNRS
             --
             --  This program is free software; you can redistribute it and/or modify
             --  it under the terms of the GNU General Public License as published by
             --  the Free Software Foundation; either version 2 of the License, or
             --  (at your option) any later version.
             --
             --  This program is distributed in the hope that it will be useful,
             --  but WITHOUT ANY WARRANTY; without even the implied warranty of
             --  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             --  GNU General Public License for more details.
             --
             --  You should have received a copy of the GNU General Public License
             --  along with this program; if not, write to the Free Software
             --  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
             -------------------------------------------------------------------------------*/
             /*--                  Author : Alexis Jeandet
             --                     Mail : alexis.jeandet@lpp.polytechnique.fr
             ----------------------------------------------------------------------------*/
             #include "socexplorerproxy.h"
             #include <pluginmanagerWDGT.h>
             #include <socexplorerengine.h>
             #include <pluginloader.h>
             #include <socexplorerplugin.h>
             socexplorerproxy* socexplorerproxy::_self=NULL;
             QMainWindow* socexplorerproxy::mainWindow=NULL;
             QList<socexplorerplugin*>* socexplorerproxy::drivers=NULL;
             QList<socexplorerplugin*>* socexplorerproxy::linearDriverList=NULL;
             socexplorerplugin* socexplorerproxy::root=NULL;
             socexplorerplugin* socexplorerproxy::parent=NULL;
             PluginsCache* socexplorerproxy::cache=NULL;
+            QStringList* socexplorerproxy::linearDriverPathList=NULL;
             socexplorerproxy::socexplorerproxy(QObject *parent) :
                 QObject(parent)
             {
                 cache = new PluginsCache;
                 drivers = new QList<socexplorerplugin*>;
                 linearDriverList=new QList<socexplorerplugin*>;
+                linearDriverPathList=new QStringList;
                 root = NULL;
             }
             socexplorerproxy::socexplorerproxy(QMainWindow *Mainwindow, QObject *parent):
                 QObject(parent)
             {
                 mainWindow = Mainwindow;
                 cache = new PluginsCache;
                 drivers = new QList<socexplorerplugin*>;
                 linearDriverList=new QList<socexplorerplugin*>;
+                linearDriverPathList=new QStringList;
                 root = NULL;
             }
             void socexplorerproxy::init()
             {
                 if(!_self)
                 {
                     _self = new socexplorerproxy();
                     mainWindow = NULL;
                 }
             }
             void socexplorerproxy::setMainWindow(QMainWindow *Mainwindow)
             {
                 if(!_self)init();
                 mainWindow=Mainwindow;
             }
             void socexplorerproxy::loadSysDriver(const QString name)
             {
                 if(!_self)init();
                 if(pluginloader::libcanberoot(name))
                 {
                     socexplorerplugin* driver = pluginloader::newsocexplorerplugin(name);
                     QString driverName = _self->getinstanceName(driver->baseName());
-                    loadSysDriver(driver,driverName);
+                    loadSysDriver(driver,driverName,name);
                 }
             }
             void socexplorerproxy::loadSysDriver(const QString name, const QString instanceName)
             {
                 if(!_self)init();
                 if(pluginloader::libcanberoot(name) && !_self->instanceExists(instanceName))
                 {
                     socexplorerplugin* driver = pluginloader::newsocexplorerplugin(name);
-                    loadSysDriver(driver,instanceName);
+                    loadSysDriver(driver,instanceName,name);
                 }
             }
-            void socexplorerproxy::loadSysDriver(socexplorerplugin *driver, const QString instanceName)
+            void socexplorerproxy::loadSysDriver(socexplorerplugin *driver, const QString instanceName, const QString path)
             {
                 if(!_self)init();
                 driver->setInstanceName(instanceName);
                 driver->parent = NULL;
                 drivers->append(driver);
                 linearDriverList->append(driver);
+                if(path.isEmpty())
+                    linearDriverPathList->append(driver->baseName());
+                else
+                    linearDriverPathList->append(path);
                 connectChildToProxy(driver);
                 emit _self->addPluginGUI(driver);
                 emit _self->clearMenu();
                 emit _self->treeChanged(QList<socexplorerplugin*>(*drivers));
                 SocExplorerEngine::addSOC(driver);
                 driver->postInstantiationTrigger();
             }
             void socexplorerproxy::loadChildSysDriver(socexplorerplugin *parent, const QString child)
             {
                 if(!_self)init();
                 if(pluginloader::libcanbechild(child))
                 {
                     socexplorerplugin* driver = pluginloader::newsocexplorerplugin(child);
                     QString driverName = _self->getinstanceName(driver->baseName());
                     bool ok=true;
                     if(ok)
                     {
-                        if(parent!=NULL)_self->loadSysDriverToParent(driver,parent,driverName);
+                        if(parent!=NULL)_self->loadSysDriverToParent(driver,parent,driverName,child);
                     }
                 }
             }
             void socexplorerproxy::loadSysDriverToParent(const QString name,const QString ParentInst)
             {
                 if(!_self)init();
                 if(pluginloader::libcanbechild(name))
                 {
                     socexplorerplugin* driver = pluginloader::newsocexplorerplugin(name);
                     QString driverName = _self->getinstanceName(driver->baseName());
                     bool ok=true;
                     if(ok)
                     {
                         socexplorerplugin* parent=_self->getSysDriver(ParentInst);
-                        if(parent!=NULL)loadSysDriverToParent(driver,parent,driverName);
+                        if(parent!=NULL)loadSysDriverToParent(driver,parent,driverName,name);
                     }
                 }
             }
             void socexplorerproxy::loadSysDriverToParent(const QString name,const QString instanceName,const QString ParentInst)
             {
                 if(!_self)init();
                 if(pluginloader::libcanbechild(name) && !_self->instanceExists(instanceName))
                 {
                     socexplorerplugin* driver = pluginloader::newsocexplorerplugin(name);
                     bool ok=true;
                     if(ok)
                     {
                         socexplorerplugin* parent=_self->getSysDriver(ParentInst);
-                        if(parent!=NULL)loadSysDriverToParent(driver,parent,instanceName);
+                        if(parent!=NULL)loadSysDriverToParent(driver,parent,instanceName,name);
                     }
                 }
             }
-            void socexplorerproxy::loadSysDriverToParent(socexplorerplugin *driver,socexplorerplugin *parent, const QString instanceName)
+            void socexplorerproxy::loadSysDriverToParent(socexplorerplugin *driver,socexplorerplugin *parent, const QString instanceName,const QString path)
             {
                 if(!_self)init();
                 linearDriverList->append(driver);
+                if(path.isEmpty())
+                    linearDriverPathList->append(driver->baseName());
+                else
+                    linearDriverPathList->append(path);
                 driver->parent = parent;
                 driver->setInstanceName(instanceName);
                 parent->childs.append(driver);
                 connectChildToProxy(driver);
                 connectChildToParent(parent,driver);
                 emit _self->clearMenu();
                 emit _self->addPluginGUI(driver);
                 emit _self->treeChanged(QList<socexplorerplugin*>(*drivers));
                 driver->postInstantiationTrigger();
             }
             void socexplorerproxy::changeSysDriverInstName(const QString instanceName)
             {
                 Q_UNUSED(instanceName)
             }
             void socexplorerproxy::changeSysDriverInstName(const QString newinstanceName, const QString previnstanceName)
             {
                 if(!_self)init();
                 socexplorerplugin*temp=_self->getSysDriver(previnstanceName);
                 if(temp!=NULL)
                 {
                     if(NULL!=_self->getSysDriver(newinstanceName))
                     {
                         emit _self->treeChanged(QList<socexplorerplugin*>(*drivers));
                         return;
                     }
                     temp->setInstanceName(newinstanceName);
                 }
                 emit _self->treeChanged(QList<socexplorerplugin*>(*drivers));
             }
             void socexplorerproxy::connectChildToParent(socexplorerplugin *parent, socexplorerplugin *child)
             {
                 if(!_self)init();
                 connect(parent,SIGNAL(activateSig(bool)),child,SLOT(activate(bool)));
                 child->activate(parent->isConnected());
             }
             void socexplorerproxy::disconnectChildToParent(socexplorerplugin *child)
             {
                 if(!_self)init();
                 disconnect(child->parent,SIGNAL(activateSig(bool)),child,SLOT(activate(bool)));
             }
             void socexplorerproxy::connectChildToProxy(socexplorerplugin *child)
             {
                 if(!_self)init();
                 connect(child,SIGNAL(registerObject(QObject*,QString)),_self,SIGNAL(registerObject(QObject*,QString)));
                 connect(child,SIGNAL(closePlugin(socexplorerplugin*)),_self,SLOT(closeSysDriver(socexplorerplugin*)));
             }
             void socexplorerproxy::disconnectChildToProxy(socexplorerplugin *child)
             {
                 if(!_self)init();
                 disconnect(child,SIGNAL(registerObject(QObject*,QString)),_self,SIGNAL(registerObject(QObject*,QString)));
                 disconnect(child,SIGNAL(closePlugin(socexplorerplugin*)),_self,SLOT(closeSysDriverFromDriver(socexplorerplugin*)));
             }
             QString socexplorerproxy::getinstanceName(const QString& baseName)
             {
                 if(!_self)init();
                 int i=0;
                 QString name;
                 bool validName = false;
                 while(!validName)
                 {
                     name.clear();
                     name.append(baseName+QString::number(i));
                     validName = instanceNameIsValid(name);
                     i++;
                 }
                 return name;
             }
             void socexplorerproxy::changeSysDriverInstName(socexplorerplugin* driver)
             {
                 if(!_self)init();
                 QString prevName(driver->instanceName());
             }
             bool socexplorerproxy::instanceNameIsValid(const QString& instanceName)
             {
                 if(!_self)init();
                 for(int k=0;k<linearDriverList->count();k++)
                 {
                     if(!linearDriverList->at(k)->instanceName().compare(instanceName))
                         return false;
                 }
                 return true;
             }
             socexplorerplugin *socexplorerproxy::findPlugin(const QString &instanceName)
             {
                 if(!_self)init();
                 for(int k=0;k<linearDriverList->count();k++)
                 {
                     if(!linearDriverList->at(k)->instanceName().compare(instanceName))
                         return linearDriverList->at(k);
                 }
                 return NULL;
             }
+            QStringList socexplorerproxy::getPluginsList()
+            {
+                if(!_self)init();
+                QStringList result;
+                socexplorerplugin* plugin;
+                for(int i=0; i<linearDriverList->count();i++)
+                {
+                    QString parent="";
+                    plugin=linearDriverList->at(i);
+                    if(plugin->parent)parent=plugin->parent->instanceName();
+                    result.append(linearDriverList->at(i)->instanceName()+":"+parent+":"+linearDriverPathList->at(i));
+                }
+                return result;
+            }
+            bool socexplorerproxy::loadPluginsList(QStringList plugins)
+            {
+                if(!_self)init();
+                QString plugin;
+                int lastLoadedPlugins=-1;
+                QStringList loadedPlugins;
+                while(plugins.count() && lastLoadedPlugins!=loadedPlugins.count())
+                {
+                    lastLoadedPlugins=loadedPlugins.count();
+                    for (int i = 0; i < plugins.count(); i++)
+                    {
+                        plugin=plugins[i];
+                        QStringList args=plugin.split(':',QString::KeepEmptyParts);
+                        if(args.count()==3)
+                        {
+                            if(args[1].isEmpty())
+                            {
+                                _self->loadSysDriver(args[2],args[0]);
+                                loadedPlugins.append(args[0]);
+                                plugins.removeAt(i);
+                            }
+                            else if(loadedPlugins.contains(args[1]))
+                            {
+                                _self->loadSysDriverToParent(args[2],args[0],args[1]);
+                                loadedPlugins.append(args[0]);
+                                plugins.removeAt(i);
+                            }
+                        }
+                        else
+                        {
+                            plugins.removeAt(i);
+                        }
+                    }
+                }
+            }
             bool socexplorerproxy::instanceExists(const QString &instanceName)
             {
                 return !socexplorerproxy::instanceNameIsValid(instanceName);
             }
             void socexplorerproxy::close()
             {
                 if(!_self)init();
                 socexplorerplugin* tmpPtr;
                 while(drivers->count()>0)
                 {
                     tmpPtr = drivers->last();
                     drivers->removeLast();
                     _self->closeSysDriver(tmpPtr);
                 }
                 if(root!=NULL)
                 {
                     _self->closeSysDriver(root);
                 }
             }
             socexplorerplugin* socexplorerproxy::getSysDriver(const QString instanceName)
             {
                 if(!_self)init();
                 for(int i=0;i<linearDriverList->count();i++)
                 {
                     if(!linearDriverList->at(i)->instanceName().compare(instanceName))
                         return linearDriverList->at(i);
                 }
                 return NULL;
             }
             void socexplorerproxy::closeSysDriver(const QString instanceName)
             {
                 if(!_self)init();
                 closeSysDriver(getSysDriver(instanceName),false);
             }
             void socexplorerproxy::closeSysDriver(socexplorerplugin *driver, bool recursive)
             {
                 if(!_self)init();
                 if(driver!=NULL)
                 {
                     emit _self->removePluginGUI(driver);
                     if(driver->parent==NULL)SocExplorerEngine::removeSOC(driver);
                     while(driver->childs.count()!=0)closeSysDriver(driver->childs.first());
+                    linearDriverPathList->removeAt(linearDriverList->indexOf(driver));
                     linearDriverList->removeOne(driver);
                     if(driver->parent!= NULL)
                     {
                         driver->parent->childs.removeOne(driver);     //Have parent so it's a child
                         disconnectChildToParent(driver);
                         disconnectChildToProxy(driver);
                         delete driver;
                     }
                     else
                     {
                         drivers->removeOne(driver);
                         disconnectChildToProxy(driver);
                         delete driver;
                     }
                     if(!recursive)
                     {
                         emit _self->clearMenu();
                         emit _self->registermenu(mainWindow);
                         emit _self->treeChanged(QList<socexplorerplugin*>(*drivers));
                     }
                 }
             }
             void socexplorerproxy::geteplugintree()
             {
                 if(!_self)init();
                 emit _self->treeChanged(QList<socexplorerplugin*>(*drivers));
             }
             void socexplorerproxy::closeSysDriverFromDriver(socexplorerplugin *driver)
             {
                 if(!_self)init();
                 emit _self->closeSysDriverSig(driver);
             }
             void socexplorerproxy::updateText()
             {
                 if(!_self)init();
                 emit _self->clearMenu();
                 emit _self->registermenu(mainWindow);
             }
             void socexplorerproxy::makeMenu(QMenu* menu)
             {
                 if(!_self)init();
                 for(int i=0;i<drivers->count();i++)
                 {
                     drivers->at(i)->registermenu(menu);
                 }
             }

src/SocExplorerEngine/proxy/socexplorerproxy.h +5 -2

             /*------------------------------------------------------------------------------
             --  This file is a part of the SocExplorer Software
             --  Copyright (C) 2011, Plasma Physics Laboratory - CNRS
             --
             --  This program is free software; you can redistribute it and/or modify
             --  it under the terms of the GNU General Public License as published by
             --  the Free Software Foundation; either version 2 of the License, or
             --  (at your option) any later version.
             --
             --  This program is distributed in the hope that it will be useful,
             --  but WITHOUT ANY WARRANTY; without even the implied warranty of
             --  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             --  GNU General Public License for more details.
             --
             --  You should have received a copy of the GNU General Public License
             --  along with this program; if not, write to the Free Software
             --  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
             -------------------------------------------------------------------------------*/
             /*--                  Author : Alexis Jeandet
             --                     Mail : alexis.jeandet@lpp.polytechnique.fr
             ----------------------------------------------------------------------------*/
             #ifndef SOCEXPLORERPROXY_H
             #define SOCEXPLORERPROXY_H
             #include <QObject>
             #include <QString>
             #include <QList>
             #include "pluginscache.h"
             #include <socexplorerplugin.h>
             #include <socexplorerplugininterface.h>
             #include <QInputDialog>
             #include <QtGlobal>
             #if defined(SOCEXPLORER_SDK_BUILD)
             #  define SOCEXPLORER_SDK_EXPORT Q_DECL_EXPORT
             #else
             #  define SOCEXPLORER_SDK_EXPORT Q_DECL_IMPORT
             #endif
             class SOCEXPLORER_SDK_EXPORT socexplorerproxy : public QObject
             {
                 Q_OBJECT
             private:
                 socexplorerproxy(QObject *parent = 0);
                 socexplorerproxy(QMainWindow* Mainwindow,QObject *parent = 0);
                 static socexplorerproxy* _self;
             public:
                 static socexplorerproxy* self(){if(!_self)init(); return _self;}
                 static void init();
                 static void setMainWindow(QMainWindow* Mainwindow);
                 static void connectChildToParent(socexplorerplugin* parent, socexplorerplugin* child);
                 static void connectChildToProxy(socexplorerplugin* child);
                 static void disconnectChildToParent(socexplorerplugin* child);
                 static void disconnectChildToProxy(socexplorerplugin* child);
                 static bool instanceNameIsValid(const QString& instanceName);
                 static socexplorerplugin* findPlugin(const QString &instanceName);
+                static QStringList getPluginsList();
+                static bool loadPluginsList( QStringList plugins);
                 QT_ENSURE_STACK_ALIGNED_FOR_SSE static void loadChildSysDriver(socexplorerplugin* parent,const QString child);
             signals:
                 void addPluginGUI(QDockWidget* plugin);
                 void removePluginGUI(QDockWidget* plugin);
                 int registermenu(QMainWindow* menuHolder);
                 void clearMenu();
                 QStringList findDrivers(int VID,int PID);
                 void rootDriverAdded(socexplorerplugin* driver);
                 void rootDriverRemoved();
                 void closeSysDriverSig(socexplorerplugin* driver);
                 void registerObject(QObject* object,const QString& instanceName);
                 void treeChanged(const QList<socexplorerplugin*>& drivers);
             public slots:
                 QT_ENSURE_STACK_ALIGNED_FOR_SSE void loadSysDriver(const QString name);
                 QT_ENSURE_STACK_ALIGNED_FOR_SSE void loadSysDriver(const QString name,const QString instanceName);
-                QT_ENSURE_STACK_ALIGNED_FOR_SSE void loadSysDriver(socexplorerplugin* driver,const QString instanceName);
+                QT_ENSURE_STACK_ALIGNED_FOR_SSE void loadSysDriver(socexplorerplugin* driver,const QString instanceName,const QString path="");
                 QT_ENSURE_STACK_ALIGNED_FOR_SSE void loadSysDriverToParent(const QString name,const QString ParentInst);
                 QT_ENSURE_STACK_ALIGNED_FOR_SSE void loadSysDriverToParent(const QString name,const QString instanceName,const QString ParentInst);
-                QT_ENSURE_STACK_ALIGNED_FOR_SSE void loadSysDriverToParent(socexplorerplugin *driver,socexplorerplugin *parent, const QString instanceName);
+                QT_ENSURE_STACK_ALIGNED_FOR_SSE void loadSysDriverToParent(socexplorerplugin *driver,socexplorerplugin *parent, const QString instanceName,const QString path="");
                 QT_ENSURE_STACK_ALIGNED_FOR_SSE void changeSysDriverInstName(const QString instanceName);
                 QT_ENSURE_STACK_ALIGNED_FOR_SSE void changeSysDriverInstName(const QString newinstanceName,const QString previnstanceName);
              //   QT_ENSURE_STACK_ALIGNED_FOR_SSE void loadChild(socexplorerplugin* parent);
                 void updateText();
                 QT_ENSURE_STACK_ALIGNED_FOR_SSE void closeSysDriverFromDriver(socexplorerplugin* driver);
                 QT_ENSURE_STACK_ALIGNED_FOR_SSE void closeSysDriver(socexplorerplugin* driver,bool recursive=false);
                 QT_ENSURE_STACK_ALIGNED_FOR_SSE void closeSysDriver(const QString instanceName);
                 void makeMenu(QMenu* menu);
                 void close();
                 QString getinstanceName(const QString& baseName);
                 void geteplugintree();
                 QT_ENSURE_STACK_ALIGNED_FOR_SSE socexplorerplugin* getSysDriver(const QString instanceName);
                 bool instanceExists(const QString& instanceName);
             private:
                 static void changeSysDriverInstName(socexplorerplugin* driver);
                 static QMainWindow* mainWindow;
                 static QList<socexplorerplugin*>* drivers;
                 static QList<socexplorerplugin*>* linearDriverList;
+                static QStringList* linearDriverPathList;
                 static socexplorerplugin* root;
                 static socexplorerplugin* parent;
                 static PluginsCache* cache;
             };
             #endif // SOCEXPLORERPROXY_H

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

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

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

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

src/main.cpp +71 -34

@@ -1,89 +1,126
1	/*------------------------------------------------------------------------------	1	/*------------------------------------------------------------------------------
2	-- This file is a part of the SocExplorer Software	2	-- This file is a part of the SocExplorer Software
3	-- Copyright (C) 2011, Plasma Physics Laboratory - CNRS	3	-- Copyright (C) 2011, Plasma Physics Laboratory - CNRS
4	--	4	--
5	-- This program is free software; you can redistribute it and/or modify	5	-- This program is free software; you can redistribute it and/or modify
6	-- it under the terms of the GNU General Public License as published by	6	-- it under the terms of the GNU General Public License as published by
7	-- the Free Software Foundation; either version 2 of the License, or	7	-- the Free Software Foundation; either version 2 of the License, or
8	-- (at your option) any later version.	8	-- (at your option) any later version.
9	--	9	--
10	-- This program is distributed in the hope that it will be useful,	10	-- This program is distributed in the hope that it will be useful,
11	-- but WITHOUT ANY WARRANTY; without even the implied warranty of	11	-- but WITHOUT ANY WARRANTY; without even the implied warranty of
12	-- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the	12	-- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13	-- GNU General Public License for more details.	13	-- GNU General Public License for more details.
14	--	14	--
15	-- You should have received a copy of the GNU General Public License	15	-- You should have received a copy of the GNU General Public License
16	-- along with this program; if not, write to the Free Software	16	-- along with this program; if not, write to the Free Software
17	-- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA	17	-- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
18	-------------------------------------------------------------------------------*/	18	-------------------------------------------------------------------------------*/
19	/*-- Author : Alexis Jeandet	19	/*-- Author : Alexis Jeandet
20	-- Mail : alexis.jeandet@lpp.polytechnique.fr	20	-- Mail : alexis.jeandet@lpp.polytechnique.fr
21	----------------------------------------------------------------------------*/	21	----------------------------------------------------------------------------*/
22	#include <QApplication>	22	#include <QApplication>
23	#include "mainwindow.h"	23	#include "mainwindow.h"
24	#include <PythonQt.h>	24	#include <PythonQt.h>
25	#include <PythonQt_QtAll.h>	25	#include <PythonQt_QtAll.h>
26	#include <gui/PythonQtScriptingConsole.h>	26	#include <gui/PythonQtScriptingConsole.h>
27	#include <socexplorerplugin.h>	27	#include <socexplorerplugin.h>
28	#include <QStyle>	28	#include <QStyle>
29	#include <QStyleFactory>	29	#include <QStyleFactory>
30	#include <QStringList>	30	#include <QStringList>
31	#include <QFile>	31	#include <QFile>
		32	#include <QCommandLineOption>
		33	#include <QCommandLineParser>
32		34
33	void usage();	35
		36	QCommandLineOption executeOption = QCommandLineOption (
		37	QStringList() << "e" << "execute",
		38	QCoreApplication::translate("main", "Execute given script <script>."),
		39	QCoreApplication::translate("main", "script"));
		40
		41	QCommandLineOption debugLevelOption = QCommandLineOption (
		42	QStringList() << "d" << "debug-level",
		43	QCoreApplication::translate("main", "Sets debug level to <level>, higher the level is more verbose the application will be."),
		44	QCoreApplication::translate("main", "level"),
		45	"1");
		46
		47	QCommandLineOption noGUIOption = QCommandLineOption (
		48	QStringList() << "n" << "no-gui",
		49	QCoreApplication::translate("main", "Starts SocExplorer in batch mode[not fully implemented yet!]."));
		50
		51	const char* socexplorerDesc="\
		52	SocExplorer is an open source generic System On Chip testing software/framework.\
		53	We write this software for the development and the validation of our instrument,\
		54	the Low Frequency Receiver(LFR) for the Solar Orbiter mission. This instrument is\
		55	based on an actel FPGA hosting a LEON3FT processor and some peripherals. To make\
		56	it more collaborative, we use a plugin based system, the main executable is SocExplorer\
		57	then all the functionality are provided by plugins. Like this everybody can provide\
		58	his set of plugins to handle a new SOC or just a new peripheral. SocExplorer uses\
		59	PythonQt to allow user to automate some tasks such as loading some plugins, configuring\
		60	them and talking with his device. SocExplorer is provided under the terms of the GNU\
		61	General Public License as published by the Free Software Foundation; either version 2\
		62	of the License, or (at your option) any later version.";
34		63
35	int main(int argc, char *argv[])	64	int main(int argc, char *argv[])
36	{	65	{
37	QApplication a(argc, argv);	66	QApplication a(argc, argv);
38	QString scriptToEval;	67	QString scriptToEval;
39	QStringList args= a.arguments();	68	QApplication::setOrganizationName("LPP");
		69	QApplication::setOrganizationDomain("lpp.fr");
		70	QApplication::setApplicationName("SocExplorer");
		71	QCommandLineParser parser;
		72	parser.setApplicationDescription(socexplorerDesc);
		73	parser.addHelpOption();
		74	parser.addVersionOption();
40	bool noGUI=false;	75	bool noGUI=false;
41	for(int i=0;i<=args.count()-1;i++)	76	parser.addPositionalArgument("file", QCoreApplication::translate("main", "The Python file to execute."));
		77	parser.addOption(executeOption);
		78	parser.addOption(debugLevelOption);
		79	parser.addOption(noGUIOption);
		80	parser.process(a);
		81	if(parser.isSet(executeOption))
42	{	82	{
43	if(((args.at(i).compare("-e")==0) \|\| (args.at(i).compare("--execute")==0)) && (i<(args.count()-1)))	83	scriptToEval = parser.value(executeOption);
		84	if(!QFile::exists(scriptToEval))
44	{	85	{
45	scriptToEval = ~~args~~.at(i+1);	86	scriptToEval.clear();
		87	}
		88	}
		89	else
		90	{
		91	QStringList posArgs = parser.positionalArguments();
		92	if(posArgs.count())
		93	{
		94	scriptToEval = posArgs.first();
46	if(!QFile::exists(scriptToEval))	95	if(!QFile::exists(scriptToEval))
47	{	96	{
48	scriptToEval.clear();	97	scriptToEval.clear();
49	}	98	}
50	else
51	qDebug() << "Will execute" << scriptToEval;
52	break;
53	}	99	}
54	if(((args.at(i).compare("-d")==0) \|\| (args.at(i).compare("--debug-level")==0)) && (i<(args.count()-1)))	100	}
		101	if(parser.isSet(debugLevelOption))
		102	{
		103	bool success;
		104	int lvl;
		105	lvl = parser.value(debugLevelOption).toInt(&success,10);
		106	if(success)
55	{	107	{
56	bool success;	108	SocExplorerEngine::setLogLevel(lvl);
57	int lvl;
58	lvl = args.at(i+1).toInt(&success,10);
59	if(success)
60	{
61	SocExplorerEngine::setLogLevel(lvl);
62	}
63	}
64	if((args.at(i).compare("--no-gui")==0))
65	{
66	noGUI = true;
67	qDebug() << "CLI mode";
68	}	109	}
69	}	110	}
70		111	if(parser.isSet(noGUIOption))
		112	{
		113	noGUI = true;
		114	qDebug() << "CLI mode";
		115	}
71	SocExplorerMainWindow w(scriptToEval);	116	SocExplorerMainWindow w(scriptToEval);
72	if(!noGUI)	117	if(!noGUI)
73	{	118	{
74
75	w.show();	119	w.show();
76	}	120	}
77	else	121	else
78	{	122	{
79		123
80	}	124	}
81	return a.exec();	125	return a.exec();
82	}	126	}
83
84
85	void usage()
86	{
87	// TODO respect usual Linux Cli interface, socexplore [OPTION]...FILES...
88	// TODO write an usage helper.
89	}

src/mainwindow.cpp +130 -3

             /*------------------------------------------------------------------------------
             --  This file is a part of the SocExplorer Software
-            --  Copyright (C) 2011, Plasma Physics Laboratory - CNRS
+            --  Copyright (C) 2011-2015, Plasma Physics Laboratory - CNRS
             --
             --  This program is free software; you can redistribute it and/or modify
             --  it under the terms of the GNU General Public License as published by
             --  the Free Software Foundation; either version 2 of the License, or
             --  (at your option) any later version.
             --
             --  This program is distributed in the hope that it will be useful,
             --  but WITHOUT ANY WARRANTY; without even the implied warranty of
             --  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             --  GNU General Public License for more details.
             --
             --  You should have received a copy of the GNU General Public License
             --  along with this program; if not, write to the Free Software
             --  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
             -------------------------------------------------------------------------------*/
             /*--                  Author : Alexis Jeandet
             --                     Mail : alexis.jeandet@lpp.polytechnique.fr
             ----------------------------------------------------------------------------*/
             #include "mainwindow.h"
             #include <QDockWidget>
+            #include <socexplorersettings.h>
+            #include <socexplorerconfigkeys.h>
             SocExplorerMainWindow::SocExplorerMainWindow(QString ScriptToEval, QWidget *parent)
                 : QMainWindow(parent)
             {
                 QCoreApplication::setApplicationName("SocExplorer");
                 QCoreApplication::setOrganizationName("LPP");
                 QCoreApplication::setOrganizationDomain("lpp.fr");
                 this->makeObjects(ScriptToEval);
                 this->makeLayout();
                 this->makeMenu();
+                SocExplorerSettings::init();
                 this->makeConnections();
                 this->setWindowIcon(QIcon(":/images/icon.png"));
                 this->setAcceptDrops(true);
                 this->pluginManager->setRootLoadable(true);
                 this->PythonConsoleInst->pyConsoleRunFile(ScriptToEval);
                 QFile file(":/styles/SocExplorer.css");
                 if(file.open(QIODevice::ReadOnly | QIODevice::Text))
                 {
                     qApp->setStyleSheet(file.readAll());
                     file.close();
                 }
             }
             void SocExplorerMainWindow::makeObjects(QString ScriptToEval)
             {
                 Q_UNUSED(ScriptToEval)
                 this->p_pluginGUIlist = new QList<QDockWidget*>();
                 pluginsDockContainer = new QMainWindow;
+                pluginsDockContainer->setObjectName("pluginsDockContainer");
                 pluginsDockContainer->setWindowFlags(Qt::Widget);
                 pluginsDockContainer->setDockNestingEnabled(true);
+                this->sessionsActions = new QActionGroup(this);
+                this->sessionManagerAction =new QAction(tr("&Session manager"),this);
                 this->mainWidget = new QSplitter(Qt::Vertical);
                 this->appTranslator = new QTranslator;
                 this->Quit = new QAction(tr("&Quit"),this);
                 this->Quit->setShortcut(tr("CTRL+Q"));
                 this->ManagePlugins = new QAction(tr("&Manage Plugins"),this);
                 this->ManagePlugins->setShortcut(tr("CTRL+P"));
                 this->regsManager = new QAction(tr("&Manage registers"),this);
                 this->exploreRegs = new QAction(tr("&Explore registers"),this);
                 this->help = new QAction(tr("&Help"),this);
                 this->help->setShortcut(tr("CTRL+H"));
                 this->about = new QAction(tr("&About"),this);
+                this->p_SessionManagerDialog = new SessionManagerDialog();
                 socexplorerproxy::setMainWindow(this);
                 SocExplorerEngine::setMainWindow(this);
                 SocExplorerEngine::xmlModel()->scanXmlFiles();
                 this->regExplorer = new RegsExplorer();
                 this->regExplorer->setAllowedAreas(Qt::AllDockWidgetAreas);
+                this->regExplorer->setObjectName("regExplorer");
                 this->addPluginInterface(this->regExplorer);
                 this->PythonConsoleInst = new PythonConsole(socexplorerproxy::self());
                 this->PythonConsoleInst->addObject("SocExplorerEngine",SocExplorerEngine::self());
                 this->pluginManager = new dockablePluginManager();
                 this->toolpane = new toolBar;
+                this->toolpane->setObjectName("toolpane");
                 this->p_about = new aboutsocexplorer();
             }
             void SocExplorerMainWindow::makeLayout()
             {
                 this->mainWidget->addWidget(pluginsDockContainer);
                 this->mainWidget->addWidget(this->PythonConsoleInst);
                 this->toolpane->setAllowedAreas(Qt::RightDockWidgetArea|Qt::LeftDockWidgetArea);
                 this->addDockWidget(Qt::LeftDockWidgetArea,this->toolpane);
                 this->toolpane->addTool(this->pluginManager);
                 this->setCentralWidget(this->mainWidget);
             }
             void SocExplorerMainWindow::makeConnections()
             {
                 connect(socexplorerproxy::self(),SIGNAL(clearMenu()),this,SLOT(clearMenu()));
                 connect(this,SIGNAL(translateSig()),socexplorerproxy::self(),SLOT(updateText()));
                 connect(socexplorerproxy::self(),SIGNAL(addPluginGUI(QDockWidget*)),this,SLOT(addPluginInterface(QDockWidget*)));
                 connect(socexplorerproxy::self(),SIGNAL(removePluginGUI(QDockWidget*)),this,SLOT(removePluginInterface(QDockWidget*)));
                 connect(this->ManagePlugins,SIGNAL(triggered()),this,SLOT(launchPluginManager()));
                 connect(this->Quit,SIGNAL(triggered()),qApp,SLOT(quit()));
                 connect(this,SIGNAL(registerObject(QObject*,QString)),this->PythonConsoleInst,SLOT(registerObject(QObject*,QString)));
                 connect(socexplorerproxy::self(),SIGNAL(registerObject(QObject*,QString)),this,SIGNAL(registerObject(QObject*,QString)));
                 connect(this->pluginManager,SIGNAL(geteplugintree()),socexplorerproxy::self(),SLOT(geteplugintree()));
                 connect(socexplorerproxy::self(),SIGNAL(treeChanged(QList<socexplorerplugin*>)),this->pluginManager,SIGNAL(treeChanged(QList<socexplorerplugin*>)));
                 connect(this->pluginManager,SIGNAL(changeSysDriverInstName(QString,QString)),socexplorerproxy::self(),SLOT(changeSysDriverInstName(QString,QString)));
                 connect(this->pluginManager,SIGNAL(changeSysDriverInstName(QString,QString)),this->PythonConsoleInst,SLOT(changeSysDriverInstName(QString,QString)));
                 connect(this->pluginManager,SIGNAL(closeSysDriver(QString)),socexplorerproxy::self(),SLOT(closeSysDriver(QString)));
                 connect(this->pluginManager,SIGNAL(closeSysDriver(QString)),this->PythonConsoleInst,SLOT(removeDriver(QString)));
                 connect(this->pluginManager,SIGNAL(pluginselected(QString)),this,SLOT(pluginselected(QString)));
                 connect(this->about,SIGNAL(triggered()),this,SLOT(showAboutBox()));
                 connect(this->exploreRegs,SIGNAL(triggered()),this->regExplorer,SLOT(show()));
+                connect(this->sessionManagerAction, SIGNAL(triggered(bool)),this,SLOT(showSessionManager(bool)));
+                connect(this->p_SessionManagerDialog, SIGNAL(switchSession(QString)),this,SLOT(setActiveSession(QString)));
+                connect(this->p_SessionManagerDialog, SIGNAL(sessionRenamed(QString,QString)),this,SLOT(renameSession(QString,QString)));
+                connect(this->p_SessionManagerDialog, SIGNAL(sessionAdded(QString)),this,SLOT(addSession(QString)));
+                connect(this->p_SessionManagerDialog, SIGNAL(sessionRemoved(QString)),this,SLOT(removeSession(QString)));
+                connect(this->sessionsActions,SIGNAL(triggered(QAction*)),this,SLOT(setActiveSession(QAction*)));
                 this->pluginManager->connect(this->pluginManager,SIGNAL(loadSysDrviver(QString)),socexplorerproxy::self(),SLOT(loadSysDriver(QString)));
                 this->pluginManager->connect(this->pluginManager,SIGNAL(loadSysDriverToParent(QString,QString)),socexplorerproxy::self(),SLOT(loadSysDriverToParent(QString,QString)));
             }
             void SocExplorerMainWindow::launchPluginManager()
             {
                 if(this->pluginManager->isHidden())
                 {
                     this->pluginManager->setHidden(false);
                 }
             }
             void SocExplorerMainWindow::addPluginInterface(QDockWidget *plugin)
             {
                 plugin->setAllowedAreas(Qt::AllDockWidgetAreas);
                 this->pluginsDockContainer->addDockWidget(Qt::TopDockWidgetArea,plugin);
                 if(p_pluginGUIlist->count()!=0)
                     this->pluginsDockContainer->tabifyDockWidget(p_pluginGUIlist->last(),plugin);
                 p_pluginGUIlist->append(plugin);
             }
             void SocExplorerMainWindow::removePluginInterface(QDockWidget *plugin)
             {
                 p_pluginGUIlist->removeOne(plugin);
                 this->pluginsDockContainer->removeDockWidget(plugin);
             }
             void SocExplorerMainWindow::clearMenu()
             {
                 this->menuBar()->clear();
                 this->makeMenu();
             }
             void SocExplorerMainWindow::makeMenu()
             {
                 this->FileMenu = menuBar()->addMenu(tr("&File"));
+                this->SessionsMenu = this->FileMenu->addMenu(tr("&Sessions"));
+                this->loadSessions();
+                this->FileMenu->addAction(this->sessionManagerAction);
+                this->SettingsMenu = menuBar()->addMenu(tr("&Settings"));
+                SocExplorerGUI::registerMenuBar(menuBar(),this->FileMenu,this->SettingsMenu);
                 this->PluginsMenu = menuBar()->addMenu(tr("&Plugins"));
                 this->ToolsMenu = menuBar()->addMenu(tr("&Tools"));
                 this->ToolsMenu->addAction(this->exploreRegs);
                 this->FileMenu->addAction(this->Quit);
                 socexplorerproxy::self()->makeMenu(this->PluginsMenu);
                 this->PluginsMenu->addAction(this->ManagePlugins);
                 this->helpMenu = menuBar()->addMenu(tr("Help"));
                 this->helpMenu->addAction(this->help);
                 this->helpMenu->addAction(this->about);
             }
+            void SocExplorerMainWindow::loadSessions()
+            {
+                p_Sessions=this->p_SessionManagerDialog->getSessionsList();
+                QAction* sact;
+                QString stext;
+                QList<QAction*> sessions=sessionsActions->actions();
+                foreach (sact, sessions)
+                {
+                      sessionsActions->removeAction(sact);
+                      SessionsMenu->removeAction(sact);
+                      delete sact;
+                }
+                foreach (stext, p_Sessions)
+                {
+                    addSession(stext);
+                }
+            }
+            void SocExplorerMainWindow::savePlugins()
+            {
+            }
+            void SocExplorerMainWindow::saveCurrentSession()
+            {
+                if(p_currentSession.isEmpty())
+                {
+                    SocExplorerSettings::loadSession("default");
+                }
+                SocExplorerSettings::setValue("GLOBAL","LastModified",QDate::currentDate().toString(),SocExplorerSettings::Session);
+                SocExplorerSettings::setValue(this,"DOCK_LOCATIONS",this->saveState(0),SocExplorerSettings::Session);
+                SocExplorerSettings::setValue(this,"PLUGINS_DOCK_LOCATIONS",this->pluginsDockContainer->saveState(0),SocExplorerSettings::Session);
+                SocExplorerSettings::setValue(this,"MAIN_WINDOW_GEOMETRY",this->saveGeometry(),SocExplorerSettings::Session);
+                QStringList plugins = socexplorerproxy::getPluginsList();
+                SocExplorerSettings::setValue(this,"LOADED_PLUGINS",QVariant(plugins),SocExplorerSettings::Session);
+                SocExplorerSettings::sync();
+            }
+            void SocExplorerMainWindow::loadCurrentSession()
+            {
+                QStringList plugins = SocExplorerSettings::value(this,"LOADED_PLUGINS",QVariant(),SocExplorerSettings::Session).toStringList();
+                socexplorerproxy::loadPluginsList(plugins);
+                this->restoreGeometry(SocExplorerSettings::value(this,"MAIN_WINDOW_GEOMETRY",QVariant(),SocExplorerSettings::Session).toByteArray());
+                this->restoreState(SocExplorerSettings::value(this,"DOCK_LOCATIONS",QVariant(),SocExplorerSettings::Session).toByteArray());
+                this->pluginsDockContainer->restoreState(SocExplorerSettings::value(this,"PLUGINS_DOCK_LOCATIONS",QVariant(),SocExplorerSettings::Session).toByteArray());
+            }
             SocExplorerMainWindow::~SocExplorerMainWindow()
             {
             }
             void SocExplorerMainWindow::setLangage(QAction *action)
             {
                 QString local = action->data().toString();
                 QString qmPath = QDir(QString("translations")).absolutePath();
                 appTranslator->load(qmPath+"/socexplorer_"+local+".qm");
                 qApp->installTranslator(appTranslator);
                 emit this->translateSig();
             }
             void SocExplorerMainWindow::createLangMenu()
             {
                 this->langMenu = menuBar()->addMenu(tr("&Langue"));
                 this->langActionGrp = new QActionGroup(this);
                 connect(this->langActionGrp,SIGNAL(triggered(QAction*)),this,SLOT(setLangage(QAction*)));
                 QDir* qmDir = new QDir(QString("translations"));
                 QStringList LangFiles = qmDir->entryList(QStringList("socexplorer_*.qm"));
                 for(int i=0;i<LangFiles.size();++i)
                 {
                     QString Local = LangFiles[i];
                     Local.remove(0,Local.indexOf('_')+1);
                     Local.chop(3);
                     QTranslator translator;
                     translator.load(LangFiles[i],qmDir->absolutePath());
                     QString langage = translator.translate("MainWindow","English");
                     QAction *action = new QAction(tr("&%1 %2").arg(i+1).arg(langage),this);
                     action->setCheckable(true);
                     action->setData(Local);
                     langMenu->addAction(action);
                     langActionGrp->addAction(action);
                     if(langage==tr("English"))
                         action->setChecked(true);
                 }
             }
             void SocExplorerMainWindow::updateText()
             {
                 emit this->translateSig();
             }
             void SocExplorerMainWindow::showAboutBox()
             {
                 p_about->show();
             }
             void SocExplorerMainWindow::pluginselected(const QString &instanceName)
             {
                 socexplorerplugin* drv=socexplorerproxy::self()->getSysDriver(instanceName);
                 if(drv)
                     drv->raise();
             }
+            void SocExplorerMainWindow::setActiveSession(const QString &session)
+            {
+                if(!(p_currentSession.isNull() && session=="default"))
+                    saveCurrentSession();
+                socexplorerproxy::self()->close();
+                this->p_currentSession = session;
+                SocExplorerSettings::loadSession(session);
+                loadCurrentSession();
+            }
+            void SocExplorerMainWindow::setActiveSession(QAction *session)
+            {
+                this->setActiveSession(session->text());
+            }
+            void SocExplorerMainWindow::showSessionManager(bool)
+            {
+                this->p_SessionManagerDialog->show();
+            }
+            void SocExplorerMainWindow::renameSession(const QString &oldName, const QString &newName)
+            {
+                for(int i=0;i<sessionsActions->actions().count();i++)
+                {
+                    if(Q_UNLIKELY(sessionsActions->actions().at(i)->text()==oldName))
+                    {
+                        sessionsActions->actions().at(i)->setText(newName);
+                    }
+                }
+            }
+            void SocExplorerMainWindow::addSession(const QString &newSession)
+            {
+                QAction* sact = new QAction(newSession,this);
+                sact->setCheckable(true);
+                sact->setData(newSession);
+                if(Q_UNLIKELY(p_currentSession==newSession))
+                   sact->setChecked(true);
+                sessionsActions->addAction(sact);
+                SessionsMenu->addAction(sact);
+            }
+            void SocExplorerMainWindow::removeSession(const QString &session)
+            {
+                QAction* sact;
+                foreach (sact, sessionsActions->actions())
+                {
+                    if(Q_UNLIKELY(sact->text()==session))
+                    {
+                        sessionsActions->removeAction(sact);
+                        SessionsMenu->removeAction(sact);
+                        delete sact;
+                    }
+                }
+            }
             void SocExplorerMainWindow::closeEvent(QCloseEvent *event)
             {
+                saveCurrentSession();
                 socexplorerproxy::self()->close();
                 qApp->closeAllWindows();
                 event->accept();
             }

src/mainwindow.h +19 -3

             /*------------------------------------------------------------------------------
             --  This file is a part of the SocExplorer Software
             --  Copyright (C) 2011, Plasma Physics Laboratory - CNRS
             --
             --  This program is free software; you can redistribute it and/or modify
             --  it under the terms of the GNU General Public License as published by
             --  the Free Software Foundation; either version 2 of the License, or
             --  (at your option) any later version.
             --
             --  This program is distributed in the hope that it will be useful,
             --  but WITHOUT ANY WARRANTY; without even the implied warranty of
             --  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             --  GNU General Public License for more details.
             --
             --  You should have received a copy of the GNU General Public License
             --  along with this program; if not, write to the Free Software
             --  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
             -------------------------------------------------------------------------------*/
             /*--                  Author : Alexis Jeandet
             --                     Mail : alexis.jeandet@lpp.polytechnique.fr
             ----------------------------------------------------------------------------*/
             #ifndef MAINWINDOW_H
             #define MAINWINDOW_H
             #include <QMainWindow>
             #include <QApplication>
             #include <QVBoxLayout>
             #include <QIcon>
             #include <QMenuBar>
             #include <QMenu>
             #include <QAction>
             #include <QDockWidget>
             #include <QTranslator>
             #include <QSplitter>
             #include "dockablepluginmanager.h"
             #include <socexplorerproxy.h>
             #include "PyWdgt/pythonconsole.h"
             #include "aboutsocexplorer.h"
             #include "toolbar.h"
             #include "regsExplorer/regsexplorer.h"
+            #include "socexplorergui.h"
+            #include "sessionmanagerdialog.h"
             class SocExplorerMainWindow : public QMainWindow
             {
                 Q_OBJECT
             public:
                 SocExplorerMainWindow(QString ScriptToEval,QWidget *parent = 0);
                 ~SocExplorerMainWindow();
-                QAction* Quit,*LoadPlugin,*ManagePlugins,*help,*regsManager,*exploreRegs,*about,*translateAction;
+                QAction* Quit,*LoadPlugin,*ManagePlugins,*help,*regsManager,*exploreRegs,*about,*translateAction,*sessionManagerAction;
+                QActionGroup*sessionsActions;
                 QActionGroup*langActionGrp;
-                QMenu* FileMenu,*PluginsMenu,*ToolsMenu,*langMenu,*helpMenu;
+                QMenu* FileMenu,*SettingsMenu,*PluginsMenu,*ToolsMenu,*langMenu,*helpMenu,*SessionsMenu;
                 QTranslator* appTranslator;
                 void createLangMenu();
                 void closeEvent(QCloseEvent *event);
                 toolBar* toolpane;
             public slots:
                 void launchPluginManager();
                 void addPluginInterface(QDockWidget* plugin);
                 void removePluginInterface(QDockWidget* plugin);
                 void clearMenu();
                 void updateText();
                 void setLangage(QAction* action);
                 void showAboutBox();
                 void pluginselected(const QString& instanceName);
+                void setActiveSession(const QString & session);
+                void setActiveSession(QAction* session);
+                void showSessionManager(bool);
+                void renameSession(const QString& oldName,const QString& newName);
+                void addSession(const QString& newSession);
+                void removeSession(const QString& session);
             signals:
                 void translateSig();
                 void registerObject(QObject* object,const QString& instanceName);
             private:
                 void makeObjects(QString ScriptToEval);
                 void makeLayout();
                 void makeConnections();
                 void makeMenu();
+                void loadSessions();
+                void savePlugins();
+                void saveCurrentSession();
+                void loadCurrentSession();
                 QMainWindow* pluginsDockContainer;
                 QSplitter* mainWidget;
                 PythonConsole* PythonConsoleInst;
                 dockablePluginManager* pluginManager;
                 RegsExplorer* regExplorer;
                 aboutsocexplorer* p_about;
                 QList<QDockWidget*>* p_pluginGUIlist;
+                QStringList p_Sessions;
+                QString p_currentSession;
+                SessionManagerDialog* p_SessionManagerDialog;
             };
             #endif // MAINWINDOW_H

src/src.pro +9 -3

             #-------------------------------------------------
             #
             # Project created by QtCreator 2011-09-19T22:52:10
             #
             #-------------------------------------------------
             SOCEXPLORER_ROOT = $${PWD}/..
             include(../build_cfg/socexplorer.pri)
             TARGET = socexplorer$${DEBUG_EXT}
             TEMPLATE = app
             CONFIG += pythonqt
             QMAKE_LFLAGS_RELEASE += --enable-auto-import -mstackrealign
             QMAKE_LFLAGS_DEBUG += --enable-auto-import -mstackrealign
             include ( common/pythonQtOut/generated_cpp/PySocExplorer/PySocExplorer.pri )
             include ( SocExplorerEngine/pythonQtOut/generated_cpp/PySocExplorerEngine/PySocExplorerEngine.pri )
             include ( SocExplorerEngine/plugins/socexplorerplugin.prf )
             INCLUDEPATH+=$${PWD} \
                         $${PWD}/common \
                         $${PWD}/common/qhexedit \
                         $${PWD}/common/QCustomPlot \
                         $${PWD}/common/genericBinaryFiles \
                         $${PWD}/common/genericBinaryFiles/elf \
                         $${PWD}/common/genericBinaryFiles/srec \
                         $${PWD}/common/genericBinaryFiles/BinFile \
                         SocExplorerEngine/engine \
                         SocExplorerEngine/pluginloader \
                         SocExplorerEngine/pluginsInterface \
                         SocExplorerEngine/proxy \
                         SocExplorerEngine/pluginManagerWdgt \
                         SocExplorerEngine/plugins \
                         SocExplorerEngine/RegisterMVS \
                         SocExplorerEngine/XmlEngine \
                         SocExplorerEngine/SOC \
                         SocExplorerEngine/PeripheralWidget/src \
                         SocExplorerEngine/memtester
             win32:INCLUDEPATH+= \
                         $${PWD}/common/genericBinaryFiles/elf/libelfWin32/include \
                         $${PWD}/common/genericBinaryFiles/elf/libelfWin32/include/libelf \
             RC_FILE = ../win32cfg/socexplorer.rc
             unix:LIBS+=-L$${SOCEXPLORER_ROOT}/bin/linux -lsocexplorercommon$${DEBUG_EXT} -L$${SOCEXPLORER_ROOT}/bin/linux -lsocexplorerengine$${DEBUG_EXT}
             win32-g++:LIBS += $${SOCEXPLORER_ROOT}/bin/win32/socexplorercommon$${DEBUG_EXT}.dll $${SOCEXPLORER_ROOT}/bin/win32/socexplorerengine$${DEBUG_EXT}.dll
             unix{
                 translation.files = $${SOCEXPLORER_ROOT}/translations/socexplorer_fr.qm \
                                     $${SOCEXPLORER_ROOT}/translations/socexplorer_en.qm
                 translation.path = $${SOCEXPLORER_TRANSLATION_INSTALL_PATH}
                 target.path    = /usr/bin
                 INSTALLS += translation target
             }
             header.path = $$[QT_INSTALL_HEADERS]/SocExplorer/common
             header.files = \
                         socexplorer.h
             INSTALLS += header
             SOURCES += main.cpp\
                     mainwindow.cpp \
                 PyWdgt/pythonconsole.cpp \
                 PyWdgt/pythonqtscriptingconsoledandd.cpp \
                 dockablepluginmanager.cpp \
                 toolbar.cpp \
                 toolbarcontainer.cpp \
                 aboutsocexplorer.cpp \
-                regsExplorer/regsexplorer.cpp
+                regsExplorer/regsexplorer.cpp \
+                socexplorercoresettingsgui.cpp \
+                sessionmanagerdialog.cpp
             HEADERS  += mainwindow.h \
                 PyWdgt/pythonconsole.h \
                 PyWdgt/pythonqtscriptingconsoledandd.h \
                 dockablepluginmanager.h \
                 toolbar.h \
                 toolbarcontainer.h \
                 socexplorer.h \
                 SocExplorerEngine/plugins/socexplorerplugin.h \
                 aboutsocexplorer.h \
-                regsExplorer/regsexplorer.h
+                regsExplorer/regsexplorer.h \
+                socexplorercoresettingsgui.h \
+                sessionmanagerdialog.h
             include ( NicePyConsole/NicePyConsole.pri)
             win32{
                 RESOURCES = ../ressources/SocExplorer.qrc
             }
             unix{
                 RESOURCES = ../ressources/SocExplorer.qrc
             }
             TRANSLATIONS = ../translations/socexplorer_fr.ts \
                 ../translations/socexplorer_en.ts
             FORMS += \
-                regsExplorer/regsexplorernew.ui
+                regsExplorer/regsexplorernew.ui \
+                socexplorercoresettingsgui.ui \
+                sessionmanagerdialog.ui
             DISTFILES += \
                 ../doc/PythonExamples/LEON3_LOAD.py \
                 ../doc/PythonExamples/PythonPlugin.py \
                 ../doc/PythonExamples/simpledemo1.py \
                 ../doc/PythonExamples/SocExplorerPlot.py \
                 ../doc/PythonExamples/SocExplorerPlot2.py \
                 ../doc/PythonExamples/SocExplorerPlot3.py \
                 ../doc/PythonExamples/tcpterminaldemo.py \
                 ../doc/PythonExamples/tcpterminaldemo2.py

unixcfg/socexplorer.desktop +1 -1

             [Desktop Entry]
             Version=1.0
             Name=SocExplorer
             Name[en_US]=SocExplorer
             Type=Application
             GenericName=Soc Explorer
             Comment=Software to monitor and explore Soc devices.
-            Exec=socexplorer -e %U
+            Exec=socexplorer %U
             Icon=/usr/share/SocExplorer/icon.png
             Terminal=false
             Categories=Electronics;Engineering;
             MimeType=text/x-python;

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