/*
 * Interface wrapper code.
 *
 * Generated by SIP 6.15.1
 *
 *     Copyright: (c) 2020 by Total Control Software
 *     License:   wxWindows License
 */

#include "sipAPI_core.h"
        #include <wx/vlbox.h>
        #include <wx/window.h>
        #include <wx/gdicmn.h>
        #include <wx/gdicmn.h>
        #include <wx/dc.h>
        #include <wx/gdicmn.h>
        #include <wx/window.h>
        #include <wx/event.h>
        #include <wx/validate.h>
        #include <wx/colour.h>
        #include <wx/event.h>
    #include <wx/setup.h>
    #include <wxPython/wxpy_api.h>
        #include <wx/event.h>
        #include <wx/cursor.h>
        #include <wx/caret.h>
        #include <wx/layout.h>
        #include <wx/sizer.h>
        #include <wx/dnd.h>
        #include <wx/access.h>
        #include <wx/accel.h>
        #include <wx/menu.h>
        #include <wx/tooltip.h>
        #include <wx/event.h>
        #include <wx/event.h>
        #include <wx/event.h>
        #include <wx/palette.h>
        #include <wx/font.h>
        #include <wx/region.h>
        #include <wx/eventfilter.h>
        #include <wx/object.h>
        #include <wx/object.h>
        #include <wx/object.h>


class sipwxVListBox : public ::wxVListBox
{
public:
    sipwxVListBox();
    sipwxVListBox(::wxWindow*, ::wxWindowID, const ::wxPoint&, const ::wxSize&, long, const ::wxString&);
    virtual ~sipwxVListBox();

    /*
     * There is a public method for every protected method visible from
     * this class.
     */
    void sipProtectVirt_OnGetRowsHeightHint(bool, size_t, size_t) const;
    ::wxCoord sipProtectVirt_EstimateTotalHeight(bool) const;
    void sipProtectVirt_OnGetUnitsSizeHint(bool, size_t, size_t) const;
    ::wxCoord sipProtectVirt_EstimateTotalSize(bool) const;
    int sipProtectVirt_GetNonOrientationTargetSize(bool) const;
    ::wxOrientation sipProtectVirt_GetOrientation(bool) const;
    int sipProtectVirt_GetOrientationTargetSize(bool) const;
    ::wxCoord sipProtectVirt_OnGetUnitSize(bool, size_t) const;
    void sipProtect_SendDestroyEvent();
    bool sipProtectVirt_ProcessEvent(bool, ::wxEvent&);
    void sipProtectVirt_DoEnable(bool, bool);
    void sipProtectVirt_DoGetPosition(bool, int*, int*) const;
    void sipProtectVirt_DoGetSize(bool, int*, int*) const;
    void sipProtectVirt_DoGetClientSize(bool, int*, int*) const;
    ::wxSize sipProtectVirt_DoGetBestSize(bool) const;
    ::wxSize sipProtectVirt_DoGetBestClientSize(bool) const;
    void sipProtectVirt_DoSetSize(bool, int, int, int, int, int);
    void sipProtectVirt_DoSetClientSize(bool, int, int);
    void sipProtectVirt_DoSetSizeHints(bool, int, int, int, int, int, int);
    void sipProtectVirt_DoMoveWindow(bool, int, int, int, int);
    void sipProtectVirt_DoSetWindowVariant(bool, ::wxWindowVariant);
    ::wxBorder sipProtectVirt_GetDefaultBorder(bool) const;
    ::wxBorder sipProtectVirt_GetDefaultBorderForControl(bool) const;
    void sipProtectVirt_DoFreeze(bool);
    void sipProtectVirt_DoThaw(bool);
    bool sipProtectVirt_HasTransparentBackground(bool);
    bool sipProtectVirt_TryBefore(bool, ::wxEvent&);
    bool sipProtectVirt_TryAfter(bool, ::wxEvent&);
    void sipProtect_OnDrawItem(::wxDC&, const ::wxRect&, size_t) const;
    void sipProtectVirt_OnDrawBackground(bool, ::wxDC&, const ::wxRect&, size_t) const;
    void sipProtectVirt_OnDrawSeparator(bool, ::wxDC&, ::wxRect&, size_t) const;
    ::wxCoord sipProtect_OnMeasureItem(size_t) const;
    ::wxCoord sipProtectVirt_OnGetRowHeight(bool, size_t) const;

    /*
     * There is a protected method for every virtual method visible from
     * this class.
     */
protected:
    ::wxCoord OnMeasureItem(size_t) const SIP_OVERRIDE;
    void OnDrawSeparator(::wxDC&, ::wxRect&, size_t) const SIP_OVERRIDE;
    void OnDrawBackground(::wxDC&, const ::wxRect&, size_t) const SIP_OVERRIDE;
    void OnDrawItem(::wxDC&, const ::wxRect&, size_t) const SIP_OVERRIDE;
    void RemoveChild(::wxWindowBase*) SIP_OVERRIDE;
    void AddChild(::wxWindowBase*) SIP_OVERRIDE;
    bool ProcessEvent(::wxEvent&) SIP_OVERRIDE;
    bool TryBefore(::wxEvent&) SIP_OVERRIDE;
    bool TryAfter(::wxEvent&) SIP_OVERRIDE;
    bool AcceptsFocus() const SIP_OVERRIDE;
    bool AcceptsFocusFromKeyboard() const SIP_OVERRIDE;
    bool AcceptsFocusRecursively() const SIP_OVERRIDE;
    void SetCanFocus(bool) SIP_OVERRIDE;
    void EnableVisibleFocus(bool) SIP_OVERRIDE;
    bool InformFirstDirection(int, int, int) SIP_OVERRIDE;
    ::wxPoint GetClientAreaOrigin() const SIP_OVERRIDE;
    bool HasTransparentBackground() SIP_OVERRIDE;
    bool ShouldInheritColours() const SIP_OVERRIDE;
    ::wxValidator* GetValidator() SIP_OVERRIDE;
    void SetValidator(const ::wxValidator&) SIP_OVERRIDE;
    bool TransferDataFromWindow() SIP_OVERRIDE;
    bool TransferDataToWindow() SIP_OVERRIDE;
    bool Validate() SIP_OVERRIDE;
    bool Destroy() SIP_OVERRIDE;
    void InheritAttributes() SIP_OVERRIDE;
    void InitDialog() SIP_OVERRIDE;
    void OnInternalIdle() SIP_OVERRIDE;
    ::wxWindow* GetMainWindowOfCompositeControl() SIP_OVERRIDE;
    void DoEnable(bool) SIP_OVERRIDE;
    void DoGetPosition(int*, int*) const SIP_OVERRIDE;
    void DoGetSize(int*, int*) const SIP_OVERRIDE;
    void DoGetClientSize(int*, int*) const SIP_OVERRIDE;
    void DoSetSize(int, int, int, int, int) SIP_OVERRIDE;
    void DoSetClientSize(int, int) SIP_OVERRIDE;
    void DoSetSizeHints(int, int, int, int, int, int) SIP_OVERRIDE;
    void DoMoveWindow(int, int, int, int) SIP_OVERRIDE;
    void DoSetWindowVariant(::wxWindowVariant) SIP_OVERRIDE;
    ::wxBorder GetDefaultBorder() const SIP_OVERRIDE;
    ::wxBorder GetDefaultBorderForControl() const SIP_OVERRIDE;
    void DoFreeze() SIP_OVERRIDE;
    void DoThaw() SIP_OVERRIDE;
    ::wxSize DoGetBestSize() const SIP_OVERRIDE;
    ::wxSize DoGetBestClientSize() const SIP_OVERRIDE;
    ::wxCoord OnGetRowHeight(size_t) const SIP_OVERRIDE;
    ::wxCoord EstimateTotalHeight() const SIP_OVERRIDE;
    void OnGetRowsHeightHint(size_t, size_t) const SIP_OVERRIDE;
    bool ScrollRows(int) SIP_OVERRIDE;
    bool ScrollRowPages(int) SIP_OVERRIDE;
    void RefreshRows(size_t, size_t) SIP_OVERRIDE;
    void RefreshRow(size_t) SIP_OVERRIDE;
    int GetNonOrientationTargetSize() const SIP_OVERRIDE;
    ::wxOrientation GetOrientation() const SIP_OVERRIDE;
    int GetOrientationTargetSize() const SIP_OVERRIDE;
    void OnGetUnitsSizeHint(size_t, size_t) const SIP_OVERRIDE;
    ::wxCoord EstimateTotalSize() const SIP_OVERRIDE;
    ::wxCoord OnGetUnitSize(size_t) const SIP_OVERRIDE;

public:
    sipSimpleWrapper *sipPySelf;

private:
    sipwxVListBox(const sipwxVListBox &);
    sipwxVListBox &operator = (const sipwxVListBox &);

    char sipPyMethods[56];
};

sipwxVListBox::sipwxVListBox(): ::wxVListBox(), sipPySelf(SIP_NULLPTR)
{
    memset(sipPyMethods, 0, sizeof (sipPyMethods));
}

sipwxVListBox::sipwxVListBox(::wxWindow*parent, ::wxWindowID id, const ::wxPoint& pos, const ::wxSize& size, long style, const ::wxString& name): ::wxVListBox(parent, id, pos, size, style, name), sipPySelf(SIP_NULLPTR)
{
    memset(sipPyMethods, 0, sizeof (sipPyMethods));
}

sipwxVListBox::~sipwxVListBox()
{
    sipInstanceDestroyedEx(&sipPySelf);
}

::wxCoord sipwxVListBox::OnMeasureItem(size_t n) const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState, const_cast<char *>(&sipPyMethods[0]), const_cast<sipSimpleWrapper **>(&sipPySelf), sipName_VListBox, sipName_OnMeasureItem);

    if (!sipMeth)
        return 0;

    extern ::wxCoord sipVH__core_145(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, size_t);

    return sipVH__core_145(sipGILState, 0, sipPySelf, sipMeth, n);
}

void sipwxVListBox::OnDrawSeparator(::wxDC& dc, ::wxRect& rect, size_t n) const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState, const_cast<char *>(&sipPyMethods[1]), const_cast<sipSimpleWrapper **>(&sipPySelf), SIP_NULLPTR, sipName_OnDrawSeparator);

    if (!sipMeth)
    {
        ::wxVListBox::OnDrawSeparator(dc, rect, n);
        return;
    }

    extern void sipVH__core_190(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, ::wxDC&, ::wxRect&, size_t);

    sipVH__core_190(sipGILState, 0, sipPySelf, sipMeth, dc, rect, n);
}

void sipwxVListBox::OnDrawBackground(::wxDC& dc, const ::wxRect& rect, size_t n) const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState, const_cast<char *>(&sipPyMethods[2]), const_cast<sipSimpleWrapper **>(&sipPySelf), SIP_NULLPTR, sipName_OnDrawBackground);

    if (!sipMeth)
    {
        ::wxVListBox::OnDrawBackground(dc, rect, n);
        return;
    }

    extern void sipVH__core_189(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, ::wxDC&, const ::wxRect&, size_t);

    sipVH__core_189(sipGILState, 0, sipPySelf, sipMeth, dc, rect, n);
}

void sipwxVListBox::OnDrawItem(::wxDC& dc, const ::wxRect& rect, size_t n) const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState, const_cast<char *>(&sipPyMethods[3]), const_cast<sipSimpleWrapper **>(&sipPySelf), sipName_VListBox, sipName_OnDrawItem);

    if (!sipMeth)
        return;

    extern void sipVH__core_189(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, ::wxDC&, const ::wxRect&, size_t);

    sipVH__core_189(sipGILState, 0, sipPySelf, sipMeth, dc, rect, n);
}

void sipwxVListBox::RemoveChild(::wxWindowBase*child)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState, &sipPyMethods[4], &sipPySelf, SIP_NULLPTR, sipName_RemoveChild);

    if (!sipMeth)
    {
        ::wxVListBox::RemoveChild(child);
        return;
    }

    extern void sipVH__core_125(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, ::wxWindowBase*);

    sipVH__core_125(sipGILState, 0, sipPySelf, sipMeth, child);
}

void sipwxVListBox::AddChild(::wxWindowBase*child)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState, &sipPyMethods[5], &sipPySelf, SIP_NULLPTR, sipName_AddChild);

    if (!sipMeth)
    {
        ::wxVListBox::AddChild(child);
        return;
    }

    extern void sipVH__core_125(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, ::wxWindowBase*);

    sipVH__core_125(sipGILState, 0, sipPySelf, sipMeth, child);
}

bool sipwxVListBox::ProcessEvent(::wxEvent& event)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState, &sipPyMethods[6], &sipPySelf, SIP_NULLPTR, sipName_ProcessEvent);

    if (!sipMeth)
        return ::wxVListBox::ProcessEvent(event);

    extern bool sipVH__core_102(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, ::wxEvent&);

    return sipVH__core_102(sipGILState, 0, sipPySelf, sipMeth, event);
}

bool sipwxVListBox::TryBefore(::wxEvent& event)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState, &sipPyMethods[7], &sipPySelf, SIP_NULLPTR, sipName_TryBefore);

    if (!sipMeth)
        return ::wxVListBox::TryBefore(event);

    extern bool sipVH__core_102(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, ::wxEvent&);

    return sipVH__core_102(sipGILState, 0, sipPySelf, sipMeth, event);
}

bool sipwxVListBox::TryAfter(::wxEvent& event)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState, &sipPyMethods[8], &sipPySelf, SIP_NULLPTR, sipName_TryAfter);

    if (!sipMeth)
        return ::wxVListBox::TryAfter(event);

    extern bool sipVH__core_102(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, ::wxEvent&);

    return sipVH__core_102(sipGILState, 0, sipPySelf, sipMeth, event);
}

bool sipwxVListBox::AcceptsFocus() const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState, const_cast<char *>(&sipPyMethods[9]), const_cast<sipSimpleWrapper **>(&sipPySelf), SIP_NULLPTR, sipName_AcceptsFocus);

    if (!sipMeth)
        return ::wxVListBox::AcceptsFocus();

    extern bool sipVH__core_6(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *);

    return sipVH__core_6(sipGILState, 0, sipPySelf, sipMeth);
}

bool sipwxVListBox::AcceptsFocusFromKeyboard() const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState, const_cast<char *>(&sipPyMethods[10]), const_cast<sipSimpleWrapper **>(&sipPySelf), SIP_NULLPTR, sipName_AcceptsFocusFromKeyboard);

    if (!sipMeth)
        return ::wxVListBox::AcceptsFocusFromKeyboard();

    extern bool sipVH__core_6(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *);

    return sipVH__core_6(sipGILState, 0, sipPySelf, sipMeth);
}

bool sipwxVListBox::AcceptsFocusRecursively() const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState, const_cast<char *>(&sipPyMethods[11]), const_cast<sipSimpleWrapper **>(&sipPySelf), SIP_NULLPTR, sipName_AcceptsFocusRecursively);

    if (!sipMeth)
        return ::wxVListBox::AcceptsFocusRecursively();

    extern bool sipVH__core_6(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *);

    return sipVH__core_6(sipGILState, 0, sipPySelf, sipMeth);
}

void sipwxVListBox::SetCanFocus(bool canFocus)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState, &sipPyMethods[12], &sipPySelf, SIP_NULLPTR, sipName_SetCanFocus);

    if (!sipMeth)
    {
        ::wxVListBox::SetCanFocus(canFocus);
        return;
    }

    extern void sipVH__core_96(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, bool);

    sipVH__core_96(sipGILState, 0, sipPySelf, sipMeth, canFocus);
}

void sipwxVListBox::EnableVisibleFocus(bool enabled)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState, &sipPyMethods[13], &sipPySelf, SIP_NULLPTR, sipName_EnableVisibleFocus);

    if (!sipMeth)
    {
        ::wxVListBox::EnableVisibleFocus(enabled);
        return;
    }

    extern void sipVH__core_96(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, bool);

    sipVH__core_96(sipGILState, 0, sipPySelf, sipMeth, enabled);
}

bool sipwxVListBox::InformFirstDirection(int direction, int size, int availableOtherDir)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState, &sipPyMethods[14], &sipPySelf, SIP_NULLPTR, sipName_InformFirstDirection);

    if (!sipMeth)
        return ::wxVListBox::InformFirstDirection(direction, size, availableOtherDir);

    extern bool sipVH__core_105(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, int, int, int);

    return sipVH__core_105(sipGILState, 0, sipPySelf, sipMeth, direction, size, availableOtherDir);
}

::wxPoint sipwxVListBox::GetClientAreaOrigin() const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState, const_cast<char *>(&sipPyMethods[15]), const_cast<sipSimpleWrapper **>(&sipPySelf), SIP_NULLPTR, sipName_GetClientAreaOrigin);

    if (!sipMeth)
        return ::wxVListBox::GetClientAreaOrigin();

    extern ::wxPoint sipVH__core_126(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *);

    return sipVH__core_126(sipGILState, 0, sipPySelf, sipMeth);
}

bool sipwxVListBox::HasTransparentBackground()
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState, &sipPyMethods[16], &sipPySelf, SIP_NULLPTR, sipName_HasTransparentBackground);

    if (!sipMeth)
        return ::wxVListBox::HasTransparentBackground();

    extern bool sipVH__core_6(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *);

    return sipVH__core_6(sipGILState, 0, sipPySelf, sipMeth);
}

bool sipwxVListBox::ShouldInheritColours() const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState, const_cast<char *>(&sipPyMethods[17]), const_cast<sipSimpleWrapper **>(&sipPySelf), SIP_NULLPTR, sipName_ShouldInheritColours);

    if (!sipMeth)
        return ::wxVListBox::ShouldInheritColours();

    extern bool sipVH__core_6(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *);

    return sipVH__core_6(sipGILState, 0, sipPySelf, sipMeth);
}

::wxValidator* sipwxVListBox::GetValidator()
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState, &sipPyMethods[18], &sipPySelf, SIP_NULLPTR, sipName_GetValidator);

    if (!sipMeth)
        return ::wxVListBox::GetValidator();

    extern ::wxValidator* sipVH__core_127(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *);

    return sipVH__core_127(sipGILState, 0, sipPySelf, sipMeth);
}

void sipwxVListBox::SetValidator(const ::wxValidator& validator)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState, &sipPyMethods[19], &sipPySelf, SIP_NULLPTR, sipName_SetValidator);

    if (!sipMeth)
    {
        ::wxVListBox::SetValidator(validator);
        return;
    }

    extern void sipVH__core_128(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const ::wxValidator&);

    sipVH__core_128(sipGILState, 0, sipPySelf, sipMeth, validator);
}

bool sipwxVListBox::TransferDataFromWindow()
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState, &sipPyMethods[20], &sipPySelf, SIP_NULLPTR, sipName_TransferDataFromWindow);

    if (!sipMeth)
        return ::wxVListBox::TransferDataFromWindow();

    extern bool sipVH__core_6(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *);

    return sipVH__core_6(sipGILState, 0, sipPySelf, sipMeth);
}

bool sipwxVListBox::TransferDataToWindow()
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState, &sipPyMethods[21], &sipPySelf, SIP_NULLPTR, sipName_TransferDataToWindow);

    if (!sipMeth)
        return ::wxVListBox::TransferDataToWindow();

    extern bool sipVH__core_6(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *);

    return sipVH__core_6(sipGILState, 0, sipPySelf, sipMeth);
}

bool sipwxVListBox::Validate()
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState, &sipPyMethods[22], &sipPySelf, SIP_NULLPTR, sipName_Validate);

    if (!sipMeth)
        return ::wxVListBox::Validate();

    extern bool sipVH__core_6(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *);

    return sipVH__core_6(sipGILState, 0, sipPySelf, sipMeth);
}

bool sipwxVListBox::Destroy()
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState, &sipPyMethods[23], &sipPySelf, SIP_NULLPTR, sipName_Destroy);

    if (!sipMeth)
        return ::wxVListBox::Destroy();

    extern bool sipVH__core_6(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *);

    return sipVH__core_6(sipGILState, 0, sipPySelf, sipMeth);
}

void sipwxVListBox::InheritAttributes()
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState, &sipPyMethods[24], &sipPySelf, SIP_NULLPTR, sipName_InheritAttributes);

    if (!sipMeth)
    {
        ::wxVListBox::InheritAttributes();
        return;
    }

    extern void sipVH__core_57(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *);

    sipVH__core_57(sipGILState, 0, sipPySelf, sipMeth);
}

void sipwxVListBox::InitDialog()
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState, &sipPyMethods[25], &sipPySelf, SIP_NULLPTR, sipName_InitDialog);

    if (!sipMeth)
    {
        ::wxVListBox::InitDialog();
        return;
    }

    extern void sipVH__core_57(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *);

    sipVH__core_57(sipGILState, 0, sipPySelf, sipMeth);
}

void sipwxVListBox::OnInternalIdle()
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState, &sipPyMethods[26], &sipPySelf, SIP_NULLPTR, sipName_OnInternalIdle);

    if (!sipMeth)
    {
        ::wxVListBox::OnInternalIdle();
        return;
    }

    extern void sipVH__core_57(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *);

    sipVH__core_57(sipGILState, 0, sipPySelf, sipMeth);
}

::wxWindow* sipwxVListBox::GetMainWindowOfCompositeControl()
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState, &sipPyMethods[27], &sipPySelf, SIP_NULLPTR, sipName_GetMainWindowOfCompositeControl);

    if (!sipMeth)
        return ::wxVListBox::GetMainWindowOfCompositeControl();

    extern ::wxWindow* sipVH__core_129(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *);

    return sipVH__core_129(sipGILState, 0, sipPySelf, sipMeth);
}

void sipwxVListBox::DoEnable(bool enable)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState, &sipPyMethods[28], &sipPySelf, SIP_NULLPTR, sipName_DoEnable);

    if (!sipMeth)
    {
        ::wxVListBox::DoEnable(enable);
        return;
    }

    extern void sipVH__core_96(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, bool);

    sipVH__core_96(sipGILState, 0, sipPySelf, sipMeth, enable);
}

void sipwxVListBox::DoGetPosition(int*x, int*y) const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState, const_cast<char *>(&sipPyMethods[29]), const_cast<sipSimpleWrapper **>(&sipPySelf), SIP_NULLPTR, sipName_DoGetPosition);

    if (!sipMeth)
    {
        ::wxVListBox::DoGetPosition(x, y);
        return;
    }

    extern void sipVH__core_130(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, int*, int*);

    sipVH__core_130(sipGILState, 0, sipPySelf, sipMeth, x, y);
}

void sipwxVListBox::DoGetSize(int*width, int*height) const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState, const_cast<char *>(&sipPyMethods[30]), const_cast<sipSimpleWrapper **>(&sipPySelf), SIP_NULLPTR, sipName_DoGetSize);

    if (!sipMeth)
    {
        ::wxVListBox::DoGetSize(width, height);
        return;
    }

    extern void sipVH__core_130(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, int*, int*);

    sipVH__core_130(sipGILState, 0, sipPySelf, sipMeth, width, height);
}

void sipwxVListBox::DoGetClientSize(int*width, int*height) const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState, const_cast<char *>(&sipPyMethods[31]), const_cast<sipSimpleWrapper **>(&sipPySelf), SIP_NULLPTR, sipName_DoGetClientSize);

    if (!sipMeth)
    {
        ::wxVListBox::DoGetClientSize(width, height);
        return;
    }

    extern void sipVH__core_130(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, int*, int*);

    sipVH__core_130(sipGILState, 0, sipPySelf, sipMeth, width, height);
}

void sipwxVListBox::DoSetSize(int x, int y, int width, int height, int sizeFlags)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState, &sipPyMethods[32], &sipPySelf, SIP_NULLPTR, sipName_DoSetSize);

    if (!sipMeth)
    {
        ::wxVListBox::DoSetSize(x, y, width, height, sizeFlags);
        return;
    }

    extern void sipVH__core_131(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, int, int, int, int, int);

    sipVH__core_131(sipGILState, 0, sipPySelf, sipMeth, x, y, width, height, sizeFlags);
}

void sipwxVListBox::DoSetClientSize(int width, int height)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState, &sipPyMethods[33], &sipPySelf, SIP_NULLPTR, sipName_DoSetClientSize);

    if (!sipMeth)
    {
        ::wxVListBox::DoSetClientSize(width, height);
        return;
    }

    extern void sipVH__core_132(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, int, int);

    sipVH__core_132(sipGILState, 0, sipPySelf, sipMeth, width, height);
}

void sipwxVListBox::DoSetSizeHints(int minW, int minH, int maxW, int maxH, int incW, int incH)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState, &sipPyMethods[34], &sipPySelf, SIP_NULLPTR, sipName_DoSetSizeHints);

    if (!sipMeth)
    {
        ::wxVListBox::DoSetSizeHints(minW, minH, maxW, maxH, incW, incH);
        return;
    }

    extern void sipVH__core_133(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, int, int, int, int, int, int);

    sipVH__core_133(sipGILState, 0, sipPySelf, sipMeth, minW, minH, maxW, maxH, incW, incH);
}

void sipwxVListBox::DoMoveWindow(int x, int y, int width, int height)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState, &sipPyMethods[35], &sipPySelf, SIP_NULLPTR, sipName_DoMoveWindow);

    if (!sipMeth)
    {
        ::wxVListBox::DoMoveWindow(x, y, width, height);
        return;
    }

    extern void sipVH__core_134(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, int, int, int, int);

    sipVH__core_134(sipGILState, 0, sipPySelf, sipMeth, x, y, width, height);
}

void sipwxVListBox::DoSetWindowVariant(::wxWindowVariant variant)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState, &sipPyMethods[36], &sipPySelf, SIP_NULLPTR, sipName_DoSetWindowVariant);

    if (!sipMeth)
    {
        ::wxVListBox::DoSetWindowVariant(variant);
        return;
    }

    extern void sipVH__core_135(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, ::wxWindowVariant);

    sipVH__core_135(sipGILState, 0, sipPySelf, sipMeth, variant);
}

::wxBorder sipwxVListBox::GetDefaultBorder() const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState, const_cast<char *>(&sipPyMethods[37]), const_cast<sipSimpleWrapper **>(&sipPySelf), SIP_NULLPTR, sipName_GetDefaultBorder);

    if (!sipMeth)
        return ::wxVListBox::GetDefaultBorder();

    extern ::wxBorder sipVH__core_136(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *);

    return sipVH__core_136(sipGILState, 0, sipPySelf, sipMeth);
}

::wxBorder sipwxVListBox::GetDefaultBorderForControl() const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState, const_cast<char *>(&sipPyMethods[38]), const_cast<sipSimpleWrapper **>(&sipPySelf), SIP_NULLPTR, sipName_GetDefaultBorderForControl);

    if (!sipMeth)
        return ::wxVListBox::GetDefaultBorderForControl();

    extern ::wxBorder sipVH__core_136(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *);

    return sipVH__core_136(sipGILState, 0, sipPySelf, sipMeth);
}

void sipwxVListBox::DoFreeze()
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState, &sipPyMethods[39], &sipPySelf, SIP_NULLPTR, sipName_DoFreeze);

    if (!sipMeth)
    {
        ::wxVListBox::DoFreeze();
        return;
    }

    extern void sipVH__core_57(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *);

    sipVH__core_57(sipGILState, 0, sipPySelf, sipMeth);
}

void sipwxVListBox::DoThaw()
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState, &sipPyMethods[40], &sipPySelf, SIP_NULLPTR, sipName_DoThaw);

    if (!sipMeth)
    {
        ::wxVListBox::DoThaw();
        return;
    }

    extern void sipVH__core_57(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *);

    sipVH__core_57(sipGILState, 0, sipPySelf, sipMeth);
}

::wxSize sipwxVListBox::DoGetBestSize() const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState, const_cast<char *>(&sipPyMethods[41]), const_cast<sipSimpleWrapper **>(&sipPySelf), SIP_NULLPTR, sipName_DoGetBestSize);

    if (!sipMeth)
        return ::wxVListBox::DoGetBestSize();

    extern ::wxSize sipVH__core_25(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *);

    return sipVH__core_25(sipGILState, 0, sipPySelf, sipMeth);
}

::wxSize sipwxVListBox::DoGetBestClientSize() const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState, const_cast<char *>(&sipPyMethods[42]), const_cast<sipSimpleWrapper **>(&sipPySelf), SIP_NULLPTR, sipName_DoGetBestClientSize);

    if (!sipMeth)
        return ::wxVListBox::DoGetBestClientSize();

    extern ::wxSize sipVH__core_25(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *);

    return sipVH__core_25(sipGILState, 0, sipPySelf, sipMeth);
}

::wxCoord sipwxVListBox::OnGetRowHeight(size_t n) const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState, const_cast<char *>(&sipPyMethods[43]), const_cast<sipSimpleWrapper **>(&sipPySelf), SIP_NULLPTR, sipName_OnGetRowHeight);

    if (!sipMeth)
        return ::wxVListBox::OnGetRowHeight(n);

    extern ::wxCoord sipVH__core_145(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, size_t);

    return sipVH__core_145(sipGILState, 0, sipPySelf, sipMeth, n);
}

::wxCoord sipwxVListBox::EstimateTotalHeight() const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState, const_cast<char *>(&sipPyMethods[44]), const_cast<sipSimpleWrapper **>(&sipPySelf), SIP_NULLPTR, sipName_EstimateTotalHeight);

    if (!sipMeth)
        return ::wxVListBox::EstimateTotalHeight();

    extern ::wxCoord sipVH__core_112(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *);

    return sipVH__core_112(sipGILState, 0, sipPySelf, sipMeth);
}

void sipwxVListBox::OnGetRowsHeightHint(size_t rowMin, size_t rowMax) const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState, const_cast<char *>(&sipPyMethods[45]), const_cast<sipSimpleWrapper **>(&sipPySelf), SIP_NULLPTR, sipName_OnGetRowsHeightHint);

    if (!sipMeth)
    {
        ::wxVListBox::OnGetRowsHeightHint(rowMin, rowMax);
        return;
    }

    extern void sipVH__core_144(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, size_t, size_t);

    sipVH__core_144(sipGILState, 0, sipPySelf, sipMeth, rowMin, rowMax);
}

bool sipwxVListBox::ScrollRows(int rows)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState, &sipPyMethods[46], &sipPySelf, SIP_NULLPTR, sipName_ScrollRows);

    if (!sipMeth)
        return ::wxVListBox::ScrollRows(rows);

    extern bool sipVH__core_147(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, int);

    return sipVH__core_147(sipGILState, 0, sipPySelf, sipMeth, rows);
}

bool sipwxVListBox::ScrollRowPages(int pages)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState, &sipPyMethods[47], &sipPySelf, SIP_NULLPTR, sipName_ScrollRowPages);

    if (!sipMeth)
        return ::wxVListBox::ScrollRowPages(pages);

    extern bool sipVH__core_147(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, int);

    return sipVH__core_147(sipGILState, 0, sipPySelf, sipMeth, pages);
}

void sipwxVListBox::RefreshRows(size_t from_, size_t to_)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState, &sipPyMethods[48], &sipPySelf, SIP_NULLPTR, sipName_RefreshRows);

    if (!sipMeth)
    {
        ::wxVListBox::RefreshRows(from_, to_);
        return;
    }

    extern void sipVH__core_144(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, size_t, size_t);

    sipVH__core_144(sipGILState, 0, sipPySelf, sipMeth, from_, to_);
}

void sipwxVListBox::RefreshRow(size_t row)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState, &sipPyMethods[49], &sipPySelf, SIP_NULLPTR, sipName_RefreshRow);

    if (!sipMeth)
    {
        ::wxVListBox::RefreshRow(row);
        return;
    }

    extern void sipVH__core_146(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, size_t);

    sipVH__core_146(sipGILState, 0, sipPySelf, sipMeth, row);
}

int sipwxVListBox::GetNonOrientationTargetSize() const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState, const_cast<char *>(&sipPyMethods[50]), const_cast<sipSimpleWrapper **>(&sipPySelf), SIP_NULLPTR, sipName_GetNonOrientationTargetSize);

    if (!sipMeth)
        return ::wxVListBox::GetNonOrientationTargetSize();

    extern int sipVH__core_112(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *);

    return sipVH__core_112(sipGILState, 0, sipPySelf, sipMeth);
}

::wxOrientation sipwxVListBox::GetOrientation() const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState, const_cast<char *>(&sipPyMethods[51]), const_cast<sipSimpleWrapper **>(&sipPySelf), SIP_NULLPTR, sipName_GetOrientation);

    if (!sipMeth)
        return ::wxVListBox::GetOrientation();

    extern ::wxOrientation sipVH__core_143(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *);

    return sipVH__core_143(sipGILState, 0, sipPySelf, sipMeth);
}

int sipwxVListBox::GetOrientationTargetSize() const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState, const_cast<char *>(&sipPyMethods[52]), const_cast<sipSimpleWrapper **>(&sipPySelf), SIP_NULLPTR, sipName_GetOrientationTargetSize);

    if (!sipMeth)
        return ::wxVListBox::GetOrientationTargetSize();

    extern int sipVH__core_112(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *);

    return sipVH__core_112(sipGILState, 0, sipPySelf, sipMeth);
}

void sipwxVListBox::OnGetUnitsSizeHint(size_t unitMin, size_t unitMax) const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState, const_cast<char *>(&sipPyMethods[53]), const_cast<sipSimpleWrapper **>(&sipPySelf), SIP_NULLPTR, sipName_OnGetUnitsSizeHint);

    if (!sipMeth)
    {
        ::wxVListBox::OnGetUnitsSizeHint(unitMin, unitMax);
        return;
    }

    extern void sipVH__core_144(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, size_t, size_t);

    sipVH__core_144(sipGILState, 0, sipPySelf, sipMeth, unitMin, unitMax);
}

::wxCoord sipwxVListBox::EstimateTotalSize() const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState, const_cast<char *>(&sipPyMethods[54]), const_cast<sipSimpleWrapper **>(&sipPySelf), SIP_NULLPTR, sipName_EstimateTotalSize);

    if (!sipMeth)
        return ::wxVListBox::EstimateTotalSize();

    extern ::wxCoord sipVH__core_112(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *);

    return sipVH__core_112(sipGILState, 0, sipPySelf, sipMeth);
}

::wxCoord sipwxVListBox::OnGetUnitSize(size_t unit) const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState, const_cast<char *>(&sipPyMethods[55]), const_cast<sipSimpleWrapper **>(&sipPySelf), SIP_NULLPTR, sipName_OnGetUnitSize);

    if (!sipMeth)
        return ::wxVListBox::OnGetUnitSize(unit);

    extern ::wxCoord sipVH__core_145(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, size_t);

    return sipVH__core_145(sipGILState, 0, sipPySelf, sipMeth, unit);
}

void sipwxVListBox::sipProtectVirt_OnGetRowsHeightHint(bool sipSelfWasArg, size_t rowMin, size_t rowMax) const
{
    (sipSelfWasArg ? ::wxVarVScrollHelper::OnGetRowsHeightHint(rowMin, rowMax) : OnGetRowsHeightHint(rowMin, rowMax));
}

::wxCoord sipwxVListBox::sipProtectVirt_EstimateTotalHeight(bool sipSelfWasArg) const
{
    return (sipSelfWasArg ? ::wxVarVScrollHelper::EstimateTotalHeight() : EstimateTotalHeight());
}

void sipwxVListBox::sipProtectVirt_OnGetUnitsSizeHint(bool sipSelfWasArg, size_t unitMin, size_t unitMax) const
{
    (sipSelfWasArg ? ::wxVarVScrollHelper::OnGetUnitsSizeHint(unitMin, unitMax) : OnGetUnitsSizeHint(unitMin, unitMax));
}

::wxCoord sipwxVListBox::sipProtectVirt_EstimateTotalSize(bool sipSelfWasArg) const
{
    return (sipSelfWasArg ? ::wxVarVScrollHelper::EstimateTotalSize() : EstimateTotalSize());
}

int sipwxVListBox::sipProtectVirt_GetNonOrientationTargetSize(bool sipSelfWasArg) const
{
    return (sipSelfWasArg ? ::wxVarVScrollHelper::GetNonOrientationTargetSize() : GetNonOrientationTargetSize());
}

::wxOrientation sipwxVListBox::sipProtectVirt_GetOrientation(bool sipSelfWasArg) const
{
    return (sipSelfWasArg ? ::wxVarVScrollHelper::GetOrientation() : GetOrientation());
}

int sipwxVListBox::sipProtectVirt_GetOrientationTargetSize(bool sipSelfWasArg) const
{
    return (sipSelfWasArg ? ::wxVarVScrollHelper::GetOrientationTargetSize() : GetOrientationTargetSize());
}

::wxCoord sipwxVListBox::sipProtectVirt_OnGetUnitSize(bool sipSelfWasArg, size_t unit) const
{
    return (sipSelfWasArg ? ::wxVarVScrollHelper::OnGetUnitSize(unit) : OnGetUnitSize(unit));
}

void sipwxVListBox::sipProtect_SendDestroyEvent()
{
    ::wxWindow::SendDestroyEvent();
}

bool sipwxVListBox::sipProtectVirt_ProcessEvent(bool sipSelfWasArg, ::wxEvent& event)
{
    return (sipSelfWasArg ? ::wxVListBox::ProcessEvent(event) : ProcessEvent(event));
}

void sipwxVListBox::sipProtectVirt_DoEnable(bool sipSelfWasArg, bool enable)
{
    (sipSelfWasArg ? ::wxVListBox::DoEnable(enable) : DoEnable(enable));
}

void sipwxVListBox::sipProtectVirt_DoGetPosition(bool sipSelfWasArg, int*x, int*y) const
{
    (sipSelfWasArg ? ::wxVListBox::DoGetPosition(x, y) : DoGetPosition(x, y));
}

void sipwxVListBox::sipProtectVirt_DoGetSize(bool sipSelfWasArg, int*width, int*height) const
{
    (sipSelfWasArg ? ::wxVListBox::DoGetSize(width, height) : DoGetSize(width, height));
}

void sipwxVListBox::sipProtectVirt_DoGetClientSize(bool sipSelfWasArg, int*width, int*height) const
{
    (sipSelfWasArg ? ::wxVListBox::DoGetClientSize(width, height) : DoGetClientSize(width, height));
}

::wxSize sipwxVListBox::sipProtectVirt_DoGetBestSize(bool sipSelfWasArg) const
{
    return (sipSelfWasArg ? ::wxVListBox::DoGetBestSize() : DoGetBestSize());
}

::wxSize sipwxVListBox::sipProtectVirt_DoGetBestClientSize(bool sipSelfWasArg) const
{
    return (sipSelfWasArg ? ::wxVListBox::DoGetBestClientSize() : DoGetBestClientSize());
}

void sipwxVListBox::sipProtectVirt_DoSetSize(bool sipSelfWasArg, int x, int y, int width, int height, int sizeFlags)
{
    (sipSelfWasArg ? ::wxVListBox::DoSetSize(x, y, width, height, sizeFlags) : DoSetSize(x, y, width, height, sizeFlags));
}

void sipwxVListBox::sipProtectVirt_DoSetClientSize(bool sipSelfWasArg, int width, int height)
{
    (sipSelfWasArg ? ::wxVListBox::DoSetClientSize(width, height) : DoSetClientSize(width, height));
}

void sipwxVListBox::sipProtectVirt_DoSetSizeHints(bool sipSelfWasArg, int minW, int minH, int maxW, int maxH, int incW, int incH)
{
    (sipSelfWasArg ? ::wxVListBox::DoSetSizeHints(minW, minH, maxW, maxH, incW, incH) : DoSetSizeHints(minW, minH, maxW, maxH, incW, incH));
}

void sipwxVListBox::sipProtectVirt_DoMoveWindow(bool sipSelfWasArg, int x, int y, int width, int height)
{
    (sipSelfWasArg ? ::wxVListBox::DoMoveWindow(x, y, width, height) : DoMoveWindow(x, y, width, height));
}

void sipwxVListBox::sipProtectVirt_DoSetWindowVariant(bool sipSelfWasArg, ::wxWindowVariant variant)
{
    (sipSelfWasArg ? ::wxVListBox::DoSetWindowVariant(variant) : DoSetWindowVariant(variant));
}

::wxBorder sipwxVListBox::sipProtectVirt_GetDefaultBorder(bool sipSelfWasArg) const
{
    return (sipSelfWasArg ? ::wxVListBox::GetDefaultBorder() : GetDefaultBorder());
}

::wxBorder sipwxVListBox::sipProtectVirt_GetDefaultBorderForControl(bool sipSelfWasArg) const
{
    return (sipSelfWasArg ? ::wxVListBox::GetDefaultBorderForControl() : GetDefaultBorderForControl());
}

void sipwxVListBox::sipProtectVirt_DoFreeze(bool sipSelfWasArg)
{
    (sipSelfWasArg ? ::wxVListBox::DoFreeze() : DoFreeze());
}

void sipwxVListBox::sipProtectVirt_DoThaw(bool sipSelfWasArg)
{
    (sipSelfWasArg ? ::wxVListBox::DoThaw() : DoThaw());
}

bool sipwxVListBox::sipProtectVirt_HasTransparentBackground(bool sipSelfWasArg)
{
    return (sipSelfWasArg ? ::wxVListBox::HasTransparentBackground() : HasTransparentBackground());
}

bool sipwxVListBox::sipProtectVirt_TryBefore(bool sipSelfWasArg, ::wxEvent& event)
{
    return (sipSelfWasArg ? ::wxVListBox::TryBefore(event) : TryBefore(event));
}

bool sipwxVListBox::sipProtectVirt_TryAfter(bool sipSelfWasArg, ::wxEvent& event)
{
    return (sipSelfWasArg ? ::wxVListBox::TryAfter(event) : TryAfter(event));
}

void sipwxVListBox::sipProtect_OnDrawItem(::wxDC& dc, const ::wxRect& rect, size_t n) const
{
    OnDrawItem(dc, rect, n);
}

void sipwxVListBox::sipProtectVirt_OnDrawBackground(bool sipSelfWasArg, ::wxDC& dc, const ::wxRect& rect, size_t n) const
{
    (sipSelfWasArg ? ::wxVListBox::OnDrawBackground(dc, rect, n) : OnDrawBackground(dc, rect, n));
}

void sipwxVListBox::sipProtectVirt_OnDrawSeparator(bool sipSelfWasArg, ::wxDC& dc, ::wxRect& rect, size_t n) const
{
    (sipSelfWasArg ? ::wxVListBox::OnDrawSeparator(dc, rect, n) : OnDrawSeparator(dc, rect, n));
}

::wxCoord sipwxVListBox::sipProtect_OnMeasureItem(size_t n) const
{
    return OnMeasureItem(n);
}

::wxCoord sipwxVListBox::sipProtectVirt_OnGetRowHeight(bool sipSelfWasArg, size_t n) const
{
    return (sipSelfWasArg ? ::wxVListBox::OnGetRowHeight(n) : OnGetRowHeight(n));
}


PyDoc_STRVAR(doc_wxVListBox_OnGetRowsHeightHint, "OnGetRowsHeightHint(rowMin, rowMax) -> None\n"
"\n"
"This function doesn't have to be overridden but it may be useful to do\n"
"so if calculating the rows' sizes is a relatively expensive operation\n"
"as it gives your code a chance to calculate several of them at once\n"
"and cache the result if necessary.");

extern "C" {static PyObject *meth_wxVListBox_OnGetRowsHeightHint(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_wxVListBox_OnGetRowsHeightHint(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = SIP_NULLPTR;
    bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));

    {
        size_t rowMin;
        size_t rowMax;
        const sipwxVListBox *sipCpp;

        static const char *sipKwdList[] = {
            sipName_rowMin,
            sipName_rowMax,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, SIP_NULLPTR, "B==", &sipSelf, sipType_wxVListBox, &sipCpp, &rowMin, &rowMax))
        {
            PyErr_Clear();

            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtectVirt_OnGetRowsHeightHint(sipSelfWasArg, rowMin, rowMax);
            Py_END_ALLOW_THREADS

            if (PyErr_Occurred())
                return 0;

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    sipNoMethod(sipParseErr, sipName_VListBox, sipName_OnGetRowsHeightHint, SIP_NULLPTR);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_wxVListBox_EstimateTotalHeight, "EstimateTotalHeight() -> int\n"
"\n"
"This class forwards calls from EstimateTotalSize() to this function so\n"
"derived classes can override either just the height or the width\n"
"estimation, or just estimate both differently if desired in any\n"
"wxHVScrolledWindow derived class.");

extern "C" {static PyObject *meth_wxVListBox_EstimateTotalHeight(PyObject *, PyObject *);}
static PyObject *meth_wxVListBox_EstimateTotalHeight(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = SIP_NULLPTR;
    bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));

    {
        const sipwxVListBox *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_wxVListBox, &sipCpp))
        {
            ::wxCoord sipRes;

            PyErr_Clear();

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->sipProtectVirt_EstimateTotalHeight(sipSelfWasArg);
            Py_END_ALLOW_THREADS

            if (PyErr_Occurred())
                return 0;

            return PyLong_FromLong(sipRes);
        }
    }

    sipNoMethod(sipParseErr, sipName_VListBox, sipName_EstimateTotalHeight, SIP_NULLPTR);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_wxVListBox_OnGetUnitsSizeHint, "OnGetUnitsSizeHint(self, unitMin: int, unitMax: int)");

extern "C" {static PyObject *meth_wxVListBox_OnGetUnitsSizeHint(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_wxVListBox_OnGetUnitsSizeHint(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = SIP_NULLPTR;
    bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));

    {
        size_t unitMin;
        size_t unitMax;
        const sipwxVListBox *sipCpp;

        static const char *sipKwdList[] = {
            sipName_unitMin,
            sipName_unitMax,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, SIP_NULLPTR, "B==", &sipSelf, sipType_wxVListBox, &sipCpp, &unitMin, &unitMax))
        {
            PyErr_Clear();

            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtectVirt_OnGetUnitsSizeHint(sipSelfWasArg, unitMin, unitMax);
            Py_END_ALLOW_THREADS

            if (PyErr_Occurred())
                return 0;

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    sipNoMethod(sipParseErr, sipName_VListBox, sipName_OnGetUnitsSizeHint, doc_wxVListBox_OnGetUnitsSizeHint);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_wxVListBox_EstimateTotalSize, "EstimateTotalSize(self) -> int");

extern "C" {static PyObject *meth_wxVListBox_EstimateTotalSize(PyObject *, PyObject *);}
static PyObject *meth_wxVListBox_EstimateTotalSize(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = SIP_NULLPTR;
    bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));

    {
        const sipwxVListBox *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_wxVListBox, &sipCpp))
        {
            ::wxCoord sipRes;

            PyErr_Clear();

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->sipProtectVirt_EstimateTotalSize(sipSelfWasArg);
            Py_END_ALLOW_THREADS

            if (PyErr_Occurred())
                return 0;

            return PyLong_FromLong(sipRes);
        }
    }

    sipNoMethod(sipParseErr, sipName_VListBox, sipName_EstimateTotalSize, doc_wxVListBox_EstimateTotalSize);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_wxVListBox_GetNonOrientationTargetSize, "GetNonOrientationTargetSize(self) -> int");

extern "C" {static PyObject *meth_wxVListBox_GetNonOrientationTargetSize(PyObject *, PyObject *);}
static PyObject *meth_wxVListBox_GetNonOrientationTargetSize(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = SIP_NULLPTR;
    bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));

    {
        const sipwxVListBox *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_wxVListBox, &sipCpp))
        {
            int sipRes;

            PyErr_Clear();

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->sipProtectVirt_GetNonOrientationTargetSize(sipSelfWasArg);
            Py_END_ALLOW_THREADS

            if (PyErr_Occurred())
                return 0;

            return PyLong_FromLong(sipRes);
        }
    }

    sipNoMethod(sipParseErr, sipName_VListBox, sipName_GetNonOrientationTargetSize, doc_wxVListBox_GetNonOrientationTargetSize);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_wxVListBox_GetOrientation, "GetOrientation(self) -> Orientation");

extern "C" {static PyObject *meth_wxVListBox_GetOrientation(PyObject *, PyObject *);}
static PyObject *meth_wxVListBox_GetOrientation(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = SIP_NULLPTR;
    bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));

    {
        const sipwxVListBox *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_wxVListBox, &sipCpp))
        {
            ::wxOrientation sipRes;

            PyErr_Clear();

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->sipProtectVirt_GetOrientation(sipSelfWasArg);
            Py_END_ALLOW_THREADS

            if (PyErr_Occurred())
                return 0;

            return sipConvertFromEnum(static_cast<int>(sipRes), sipType_wxOrientation);
        }
    }

    sipNoMethod(sipParseErr, sipName_VListBox, sipName_GetOrientation, doc_wxVListBox_GetOrientation);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_wxVListBox_GetOrientationTargetSize, "GetOrientationTargetSize(self) -> int");

extern "C" {static PyObject *meth_wxVListBox_GetOrientationTargetSize(PyObject *, PyObject *);}
static PyObject *meth_wxVListBox_GetOrientationTargetSize(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = SIP_NULLPTR;
    bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));

    {
        const sipwxVListBox *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_wxVListBox, &sipCpp))
        {
            int sipRes;

            PyErr_Clear();

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->sipProtectVirt_GetOrientationTargetSize(sipSelfWasArg);
            Py_END_ALLOW_THREADS

            if (PyErr_Occurred())
                return 0;

            return PyLong_FromLong(sipRes);
        }
    }

    sipNoMethod(sipParseErr, sipName_VListBox, sipName_GetOrientationTargetSize, doc_wxVListBox_GetOrientationTargetSize);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_wxVListBox_OnGetUnitSize, "OnGetUnitSize(self, unit: int) -> int");

extern "C" {static PyObject *meth_wxVListBox_OnGetUnitSize(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_wxVListBox_OnGetUnitSize(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = SIP_NULLPTR;
    bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));

    {
        size_t unit;
        const sipwxVListBox *sipCpp;

        static const char *sipKwdList[] = {
            sipName_unit,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, SIP_NULLPTR, "B=", &sipSelf, sipType_wxVListBox, &sipCpp, &unit))
        {
            ::wxCoord sipRes;

            PyErr_Clear();

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->sipProtectVirt_OnGetUnitSize(sipSelfWasArg, unit);
            Py_END_ALLOW_THREADS

            if (PyErr_Occurred())
                return 0;

            return PyLong_FromLong(sipRes);
        }
    }

    sipNoMethod(sipParseErr, sipName_VListBox, sipName_OnGetUnitSize, doc_wxVListBox_OnGetUnitSize);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_wxVListBox_SendDestroyEvent, "SendDestroyEvent() -> None\n"
"\n"
"Generate wxWindowDestroyEvent for this window.");

extern "C" {static PyObject *meth_wxVListBox_SendDestroyEvent(PyObject *, PyObject *);}
static PyObject *meth_wxVListBox_SendDestroyEvent(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = SIP_NULLPTR;

    {
        sipwxVListBox *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_wxVListBox, &sipCpp))
        {
            PyErr_Clear();

            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtect_SendDestroyEvent();
            Py_END_ALLOW_THREADS

            if (PyErr_Occurred())
                return 0;

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    sipNoMethod(sipParseErr, sipName_VListBox, sipName_SendDestroyEvent, SIP_NULLPTR);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_wxVListBox_SetMargins, "SetMargins(pt) -> None\n"
"SetMargins(x, y) -> None\n"
"\n"
"Set the margins: horizontal margin is the distance between the window\n"
"border and the item contents while vertical margin is half of the\n"
"distance between items.\n"
"");

extern "C" {static PyObject *meth_wxVListBox_SetMargins(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_wxVListBox_SetMargins(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = SIP_NULLPTR;

    {
        const ::wxPoint* pt;
        int ptState = 0;
        ::wxVListBox *sipCpp;

        static const char *sipKwdList[] = {
            sipName_pt,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, SIP_NULLPTR, "BJ1", &sipSelf, sipType_wxVListBox, &sipCpp, sipType_wxPoint, &pt, &ptState))
        {
            PyErr_Clear();

            Py_BEGIN_ALLOW_THREADS
            sipCpp->SetMargins(*pt);
            Py_END_ALLOW_THREADS
            sipReleaseType(const_cast< ::wxPoint *>(pt), sipType_wxPoint, ptState);

            if (PyErr_Occurred())
                return 0;

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    {
        ::wxCoord x;
        ::wxCoord y;
        ::wxVListBox *sipCpp;

        static const char *sipKwdList[] = {
            sipName_x,
            sipName_y,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, SIP_NULLPTR, "Bii", &sipSelf, sipType_wxVListBox, &sipCpp, &x, &y))
        {
            PyErr_Clear();

            Py_BEGIN_ALLOW_THREADS
            sipCpp->SetMargins(x, y);
            Py_END_ALLOW_THREADS

            if (PyErr_Occurred())
                return 0;

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    sipNoMethod(sipParseErr, sipName_VListBox, sipName_SetMargins, SIP_NULLPTR);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_wxVListBox_Clear, "Clear() -> None\n"
"\n"
"Deletes all items from the control.");

extern "C" {static PyObject *meth_wxVListBox_Clear(PyObject *, PyObject *);}
static PyObject *meth_wxVListBox_Clear(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = SIP_NULLPTR;

    {
        ::wxVListBox *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_wxVListBox, &sipCpp))
        {
            PyErr_Clear();

            Py_BEGIN_ALLOW_THREADS
            sipCpp->Clear();
            Py_END_ALLOW_THREADS

            if (PyErr_Occurred())
                return 0;

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    sipNoMethod(sipParseErr, sipName_VListBox, sipName_Clear, SIP_NULLPTR);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_wxVListBox_Create, "Create(parent, id=ID_ANY, pos=DefaultPosition, size=DefaultSize, style=0, name=VListBoxNameStr) -> bool\n"
"\n"
"Creates the control.");

extern "C" {static PyObject *meth_wxVListBox_Create(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_wxVListBox_Create(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = SIP_NULLPTR;

    {
        ::wxWindow* parent;
        ::wxWindowID id = wxID_ANY;
        const ::wxPoint& posdef = wxDefaultPosition;
        const ::wxPoint* pos = &posdef;
        int posState = 0;
        const ::wxSize& sizedef = wxDefaultSize;
        const ::wxSize* size = &sizedef;
        int sizeState = 0;
        long style = 0;
        const ::wxString& namedef = wxVListBoxNameStr;
        const ::wxString* name = &namedef;
        int nameState = 0;
        sipWrapper *sipOwner = SIP_NULLPTR;
        ::wxVListBox *sipCpp;

        static const char *sipKwdList[] = {
            sipName_parent,
            sipName_id,
            sipName_pos,
            sipName_size,
            sipName_style,
            sipName_name,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, SIP_NULLPTR, "BJH|iJ1J1lJ1", &sipSelf, sipType_wxVListBox, &sipCpp, sipType_wxWindow, &parent, &sipOwner, &id, sipType_wxPoint, &pos, &posState, sipType_wxSize, &size, &sizeState, &style, sipType_wxString, &name, &nameState))
        {
            bool sipRes;

            PyErr_Clear();

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->Create(parent, id, *pos, *size, style, *name);
            Py_END_ALLOW_THREADS

            if (sipOwner)
                sipTransferTo(sipSelf, (PyObject *)sipOwner);
            else
                sipTransferBack(sipSelf);
            sipReleaseType(const_cast< ::wxPoint *>(pos), sipType_wxPoint, posState);
            sipReleaseType(const_cast< ::wxSize *>(size), sipType_wxSize, sizeState);
            sipReleaseType(const_cast< ::wxString *>(name), sipType_wxString, nameState);

            if (PyErr_Occurred())
                return 0;

            return PyBool_FromLong(sipRes);
        }
    }

    sipNoMethod(sipParseErr, sipName_VListBox, sipName_Create, SIP_NULLPTR);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_wxVListBox_DeselectAll, "DeselectAll() -> bool\n"
"\n"
"Deselects all the items in the listbox.");

extern "C" {static PyObject *meth_wxVListBox_DeselectAll(PyObject *, PyObject *);}
static PyObject *meth_wxVListBox_DeselectAll(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = SIP_NULLPTR;

    {
        ::wxVListBox *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_wxVListBox, &sipCpp))
        {
            bool sipRes;

            PyErr_Clear();

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->DeselectAll();
            Py_END_ALLOW_THREADS

            if (PyErr_Occurred())
                return 0;

            return PyBool_FromLong(sipRes);
        }
    }

    sipNoMethod(sipParseErr, sipName_VListBox, sipName_DeselectAll, SIP_NULLPTR);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_wxVListBox_GetFirstSelected, "GetFirstSelected() -> Tuple[int, int]\n"
"\n"
"Returns the index of the first selected item in the listbox or\n"
"wxNOT_FOUND if no items are currently selected.");

extern "C" {static PyObject *meth_wxVListBox_GetFirstSelected(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_wxVListBox_GetFirstSelected(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = SIP_NULLPTR;

    {
        unsigned long cookie;
        const ::wxVListBox *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, SIP_NULLPTR, SIP_NULLPTR, "B", &sipSelf, sipType_wxVListBox, &sipCpp))
        {
            int sipRes;

            PyErr_Clear();

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->GetFirstSelected(cookie);
            Py_END_ALLOW_THREADS

            if (PyErr_Occurred())
                return 0;

            return sipBuildResult(0, "(im)", sipRes, cookie);
        }
    }

    sipNoMethod(sipParseErr, sipName_VListBox, sipName_GetFirstSelected, SIP_NULLPTR);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_wxVListBox_GetItemCount, "GetItemCount() -> int\n"
"\n"
"Get the number of items in the control.");

extern "C" {static PyObject *meth_wxVListBox_GetItemCount(PyObject *, PyObject *);}
static PyObject *meth_wxVListBox_GetItemCount(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = SIP_NULLPTR;

    {
        const ::wxVListBox *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_wxVListBox, &sipCpp))
        {
            size_t sipRes;

            PyErr_Clear();

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->GetItemCount();
            Py_END_ALLOW_THREADS

            if (PyErr_Occurred())
                return 0;

            return PyLong_FromUnsignedLong(sipRes);
        }
    }

    sipNoMethod(sipParseErr, sipName_VListBox, sipName_GetItemCount, SIP_NULLPTR);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_wxVListBox_GetMargins, "GetMargins() -> Point\n"
"\n"
"Returns the margins used by the control.");

extern "C" {static PyObject *meth_wxVListBox_GetMargins(PyObject *, PyObject *);}
static PyObject *meth_wxVListBox_GetMargins(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = SIP_NULLPTR;

    {
        const ::wxVListBox *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_wxVListBox, &sipCpp))
        {
            ::wxPoint*sipRes;

            PyErr_Clear();

            Py_BEGIN_ALLOW_THREADS
            sipRes = new ::wxPoint(sipCpp->GetMargins());
            Py_END_ALLOW_THREADS

            if (PyErr_Occurred())
                return 0;

            return sipConvertFromNewType(sipRes, sipType_wxPoint, SIP_NULLPTR);
        }
    }

    sipNoMethod(sipParseErr, sipName_VListBox, sipName_GetMargins, SIP_NULLPTR);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_wxVListBox_GetItemRect, "GetItemRect(item) -> Rect\n"
"\n"
"Returns the rectangle occupied by this item in physical coordinates.");

extern "C" {static PyObject *meth_wxVListBox_GetItemRect(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_wxVListBox_GetItemRect(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = SIP_NULLPTR;

    {
        size_t item;
        const ::wxVListBox *sipCpp;

        static const char *sipKwdList[] = {
            sipName_item,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, SIP_NULLPTR, "B=", &sipSelf, sipType_wxVListBox, &sipCpp, &item))
        {
            ::wxRect*sipRes;

            PyErr_Clear();

            Py_BEGIN_ALLOW_THREADS
            sipRes = new ::wxRect(sipCpp->GetItemRect(item));
            Py_END_ALLOW_THREADS

            if (PyErr_Occurred())
                return 0;

            return sipConvertFromNewType(sipRes, sipType_wxRect, SIP_NULLPTR);
        }
    }

    sipNoMethod(sipParseErr, sipName_VListBox, sipName_GetItemRect, SIP_NULLPTR);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_wxVListBox_GetNextSelected, "GetNextSelected(cookie) -> Tuple[int, int]\n"
"\n"
"Returns the index of the next selected item or wxNOT_FOUND if there\n"
"are no more.");

extern "C" {static PyObject *meth_wxVListBox_GetNextSelected(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_wxVListBox_GetNextSelected(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = SIP_NULLPTR;

    {
        unsigned long cookie;
        const ::wxVListBox *sipCpp;

        static const char *sipKwdList[] = {
            sipName_cookie,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, SIP_NULLPTR, "Bm", &sipSelf, sipType_wxVListBox, &sipCpp, &cookie))
        {
            int sipRes;

            PyErr_Clear();

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->GetNextSelected(cookie);
            Py_END_ALLOW_THREADS

            if (PyErr_Occurred())
                return 0;

            return sipBuildResult(0, "(im)", sipRes, cookie);
        }
    }

    sipNoMethod(sipParseErr, sipName_VListBox, sipName_GetNextSelected, SIP_NULLPTR);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_wxVListBox_GetSelectedCount, "GetSelectedCount() -> int\n"
"\n"
"Returns the number of the items currently selected.");

extern "C" {static PyObject *meth_wxVListBox_GetSelectedCount(PyObject *, PyObject *);}
static PyObject *meth_wxVListBox_GetSelectedCount(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = SIP_NULLPTR;

    {
        const ::wxVListBox *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_wxVListBox, &sipCpp))
        {
            size_t sipRes;

            PyErr_Clear();

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->GetSelectedCount();
            Py_END_ALLOW_THREADS

            if (PyErr_Occurred())
                return 0;

            return PyLong_FromUnsignedLong(sipRes);
        }
    }

    sipNoMethod(sipParseErr, sipName_VListBox, sipName_GetSelectedCount, SIP_NULLPTR);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_wxVListBox_GetSelection, "GetSelection() -> int\n"
"\n"
"Get the currently selected item or wxNOT_FOUND if there is no\n"
"selection.");

extern "C" {static PyObject *meth_wxVListBox_GetSelection(PyObject *, PyObject *);}
static PyObject *meth_wxVListBox_GetSelection(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = SIP_NULLPTR;

    {
        const ::wxVListBox *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_wxVListBox, &sipCpp))
        {
            int sipRes;

            PyErr_Clear();

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->GetSelection();
            Py_END_ALLOW_THREADS

            if (PyErr_Occurred())
                return 0;

            return PyLong_FromLong(sipRes);
        }
    }

    sipNoMethod(sipParseErr, sipName_VListBox, sipName_GetSelection, SIP_NULLPTR);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_wxVListBox_GetSelectionBackground, "GetSelectionBackground() -> Colour\n"
"\n"
"Returns the background colour used for the selected cells.");

extern "C" {static PyObject *meth_wxVListBox_GetSelectionBackground(PyObject *, PyObject *);}
static PyObject *meth_wxVListBox_GetSelectionBackground(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = SIP_NULLPTR;

    {
        const ::wxVListBox *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_wxVListBox, &sipCpp))
        {
            ::wxColour*sipRes;

            PyErr_Clear();

            Py_BEGIN_ALLOW_THREADS
            sipRes = new ::wxColour(sipCpp->GetSelectionBackground());
            Py_END_ALLOW_THREADS

            if (PyErr_Occurred())
                return 0;

            return sipConvertFromNewType(sipRes, sipType_wxColour, SIP_NULLPTR);
        }
    }

    sipNoMethod(sipParseErr, sipName_VListBox, sipName_GetSelectionBackground, SIP_NULLPTR);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_wxVListBox_HasMultipleSelection, "HasMultipleSelection() -> bool\n"
"\n"
"Returns true if the listbox was created with wxLB_MULTIPLE style and\n"
"so supports multiple selection or false if it is a single selection\n"
"listbox.");

extern "C" {static PyObject *meth_wxVListBox_HasMultipleSelection(PyObject *, PyObject *);}
static PyObject *meth_wxVListBox_HasMultipleSelection(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = SIP_NULLPTR;

    {
        const ::wxVListBox *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_wxVListBox, &sipCpp))
        {
            bool sipRes;

            PyErr_Clear();

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->HasMultipleSelection();
            Py_END_ALLOW_THREADS

            if (PyErr_Occurred())
                return 0;

            return PyBool_FromLong(sipRes);
        }
    }

    sipNoMethod(sipParseErr, sipName_VListBox, sipName_HasMultipleSelection, SIP_NULLPTR);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_wxVListBox_IsCurrent, "IsCurrent(item) -> bool\n"
"\n"
"Returns true if this item is the current one, false otherwise.");

extern "C" {static PyObject *meth_wxVListBox_IsCurrent(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_wxVListBox_IsCurrent(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = SIP_NULLPTR;

    {
        size_t item;
        const ::wxVListBox *sipCpp;

        static const char *sipKwdList[] = {
            sipName_item,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, SIP_NULLPTR, "B=", &sipSelf, sipType_wxVListBox, &sipCpp, &item))
        {
            bool sipRes;

            PyErr_Clear();

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->IsCurrent(item);
            Py_END_ALLOW_THREADS

            if (PyErr_Occurred())
                return 0;

            return PyBool_FromLong(sipRes);
        }
    }

    sipNoMethod(sipParseErr, sipName_VListBox, sipName_IsCurrent, SIP_NULLPTR);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_wxVListBox_IsSelected, "IsSelected(item) -> bool\n"
"\n"
"Returns true if this item is selected, false otherwise.");

extern "C" {static PyObject *meth_wxVListBox_IsSelected(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_wxVListBox_IsSelected(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = SIP_NULLPTR;

    {
        size_t item;
        const ::wxVListBox *sipCpp;

        static const char *sipKwdList[] = {
            sipName_item,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, SIP_NULLPTR, "B=", &sipSelf, sipType_wxVListBox, &sipCpp, &item))
        {
            bool sipRes;

            PyErr_Clear();

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->IsSelected(item);
            Py_END_ALLOW_THREADS

            if (PyErr_Occurred())
                return 0;

            return PyBool_FromLong(sipRes);
        }
    }

    sipNoMethod(sipParseErr, sipName_VListBox, sipName_IsSelected, SIP_NULLPTR);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_wxVListBox_Select, "Select(item, select=True) -> bool\n"
"\n"
"Selects or deselects the specified item which must be valid (i.e. not equal to wxNOT_FOUND).");

extern "C" {static PyObject *meth_wxVListBox_Select(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_wxVListBox_Select(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = SIP_NULLPTR;

    {
        size_t item;
        bool select = 1;
        ::wxVListBox *sipCpp;

        static const char *sipKwdList[] = {
            sipName_item,
            sipName_select,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, SIP_NULLPTR, "B=|b", &sipSelf, sipType_wxVListBox, &sipCpp, &item, &select))
        {
            bool sipRes;

            PyErr_Clear();

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->Select(item, select);
            Py_END_ALLOW_THREADS

            if (PyErr_Occurred())
                return 0;

            return PyBool_FromLong(sipRes);
        }
    }

    sipNoMethod(sipParseErr, sipName_VListBox, sipName_Select, SIP_NULLPTR);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_wxVListBox_SelectAll, "SelectAll() -> bool\n"
"\n"
"Selects all the items in the listbox.");

extern "C" {static PyObject *meth_wxVListBox_SelectAll(PyObject *, PyObject *);}
static PyObject *meth_wxVListBox_SelectAll(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = SIP_NULLPTR;

    {
        ::wxVListBox *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_wxVListBox, &sipCpp))
        {
            bool sipRes;

            PyErr_Clear();

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->SelectAll();
            Py_END_ALLOW_THREADS

            if (PyErr_Occurred())
                return 0;

            return PyBool_FromLong(sipRes);
        }
    }

    sipNoMethod(sipParseErr, sipName_VListBox, sipName_SelectAll, SIP_NULLPTR);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_wxVListBox_SelectRange, "SelectRange(from_, to_) -> bool\n"
"\n"
"Selects all items in the specified range which may be given in any\n"
"order.");

extern "C" {static PyObject *meth_wxVListBox_SelectRange(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_wxVListBox_SelectRange(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = SIP_NULLPTR;

    {
        size_t from_;
        size_t to_;
        ::wxVListBox *sipCpp;

        static const char *sipKwdList[] = {
            sipName_from_,
            sipName_to_,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, SIP_NULLPTR, "B==", &sipSelf, sipType_wxVListBox, &sipCpp, &from_, &to_))
        {
            bool sipRes;

            PyErr_Clear();

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->SelectRange(from_, to_);
            Py_END_ALLOW_THREADS

            if (PyErr_Occurred())
                return 0;

            return PyBool_FromLong(sipRes);
        }
    }

    sipNoMethod(sipParseErr, sipName_VListBox, sipName_SelectRange, SIP_NULLPTR);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_wxVListBox_SetItemCount, "SetItemCount(count) -> None\n"
"\n"
"Set the number of items to be shown in the control.");

extern "C" {static PyObject *meth_wxVListBox_SetItemCount(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_wxVListBox_SetItemCount(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = SIP_NULLPTR;

    {
        size_t count;
        ::wxVListBox *sipCpp;

        static const char *sipKwdList[] = {
            sipName_count,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, SIP_NULLPTR, "B=", &sipSelf, sipType_wxVListBox, &sipCpp, &count))
        {
            PyErr_Clear();

            Py_BEGIN_ALLOW_THREADS
            sipCpp->SetItemCount(count);
            Py_END_ALLOW_THREADS

            if (PyErr_Occurred())
                return 0;

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    sipNoMethod(sipParseErr, sipName_VListBox, sipName_SetItemCount, SIP_NULLPTR);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_wxVListBox_SetSelection, "SetSelection(selection) -> None\n"
"\n"
"Set the selection to the specified item, if it is -1 the selection is\n"
"unset.");

extern "C" {static PyObject *meth_wxVListBox_SetSelection(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_wxVListBox_SetSelection(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = SIP_NULLPTR;

    {
        int selection;
        ::wxVListBox *sipCpp;

        static const char *sipKwdList[] = {
            sipName_selection,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, SIP_NULLPTR, "Bi", &sipSelf, sipType_wxVListBox, &sipCpp, &selection))
        {
            PyErr_Clear();

            Py_BEGIN_ALLOW_THREADS
            sipCpp->SetSelection(selection);
            Py_END_ALLOW_THREADS

            if (PyErr_Occurred())
                return 0;

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    sipNoMethod(sipParseErr, sipName_VListBox, sipName_SetSelection, SIP_NULLPTR);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_wxVListBox_SetSelectionBackground, "SetSelectionBackground(col) -> None\n"
"\n"
"Sets the colour to be used for the selected cells background.");

extern "C" {static PyObject *meth_wxVListBox_SetSelectionBackground(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_wxVListBox_SetSelectionBackground(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = SIP_NULLPTR;

    {
        const ::wxColour* col;
        int colState = 0;
        ::wxVListBox *sipCpp;

        static const char *sipKwdList[] = {
            sipName_col,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, SIP_NULLPTR, "BJ1", &sipSelf, sipType_wxVListBox, &sipCpp, sipType_wxColour, &col, &colState))
        {
            PyErr_Clear();

            Py_BEGIN_ALLOW_THREADS
            sipCpp->SetSelectionBackground(*col);
            Py_END_ALLOW_THREADS
            sipReleaseType(const_cast< ::wxColour *>(col), sipType_wxColour, colState);

            if (PyErr_Occurred())
                return 0;

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    sipNoMethod(sipParseErr, sipName_VListBox, sipName_SetSelectionBackground, SIP_NULLPTR);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_wxVListBox_Toggle, "Toggle(item) -> None\n"
"\n"
"Toggles the state of the specified item, i.e. selects it if it was unselected and deselects it if it was selected.");

extern "C" {static PyObject *meth_wxVListBox_Toggle(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_wxVListBox_Toggle(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = SIP_NULLPTR;

    {
        size_t item;
        ::wxVListBox *sipCpp;

        static const char *sipKwdList[] = {
            sipName_item,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, SIP_NULLPTR, "B=", &sipSelf, sipType_wxVListBox, &sipCpp, &item))
        {
            PyErr_Clear();

            Py_BEGIN_ALLOW_THREADS
            sipCpp->Toggle(item);
            Py_END_ALLOW_THREADS

            if (PyErr_Occurred())
                return 0;

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    sipNoMethod(sipParseErr, sipName_VListBox, sipName_Toggle, SIP_NULLPTR);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_wxVListBox_GetClientAreaOrigin, "GetClientAreaOrigin(self) -> Point");

extern "C" {static PyObject *meth_wxVListBox_GetClientAreaOrigin(PyObject *, PyObject *);}
static PyObject *meth_wxVListBox_GetClientAreaOrigin(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = SIP_NULLPTR;
    bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));

    {
        const ::wxVListBox *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_wxVListBox, &sipCpp))
        {
            ::wxPoint*sipRes;

            PyErr_Clear();

            Py_BEGIN_ALLOW_THREADS
            sipRes = new ::wxPoint((sipSelfWasArg ? sipCpp->::wxVListBox::GetClientAreaOrigin() : sipCpp->GetClientAreaOrigin()));
            Py_END_ALLOW_THREADS

            if (PyErr_Occurred())
                return 0;

            return sipConvertFromNewType(sipRes, sipType_wxPoint, SIP_NULLPTR);
        }
    }

    sipNoMethod(sipParseErr, sipName_VListBox, sipName_GetClientAreaOrigin, doc_wxVListBox_GetClientAreaOrigin);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_wxVListBox_Validate, "Validate(self) -> bool");

extern "C" {static PyObject *meth_wxVListBox_Validate(PyObject *, PyObject *);}
static PyObject *meth_wxVListBox_Validate(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = SIP_NULLPTR;
    bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));

    {
        ::wxVListBox *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_wxVListBox, &sipCpp))
        {
            bool sipRes;

            PyErr_Clear();

            Py_BEGIN_ALLOW_THREADS
            sipRes = (sipSelfWasArg ? sipCpp->::wxVListBox::Validate() : sipCpp->Validate());
            Py_END_ALLOW_THREADS

            if (PyErr_Occurred())
                return 0;

            return PyBool_FromLong(sipRes);
        }
    }

    sipNoMethod(sipParseErr, sipName_VListBox, sipName_Validate, doc_wxVListBox_Validate);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_wxVListBox_TransferDataToWindow, "TransferDataToWindow(self) -> bool");

extern "C" {static PyObject *meth_wxVListBox_TransferDataToWindow(PyObject *, PyObject *);}
static PyObject *meth_wxVListBox_TransferDataToWindow(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = SIP_NULLPTR;
    bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));

    {
        ::wxVListBox *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_wxVListBox, &sipCpp))
        {
            bool sipRes;

            PyErr_Clear();

            Py_BEGIN_ALLOW_THREADS
            sipRes = (sipSelfWasArg ? sipCpp->::wxVListBox::TransferDataToWindow() : sipCpp->TransferDataToWindow());
            Py_END_ALLOW_THREADS

            if (PyErr_Occurred())
                return 0;

            return PyBool_FromLong(sipRes);
        }
    }

    sipNoMethod(sipParseErr, sipName_VListBox, sipName_TransferDataToWindow, doc_wxVListBox_TransferDataToWindow);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_wxVListBox_TransferDataFromWindow, "TransferDataFromWindow(self) -> bool");

extern "C" {static PyObject *meth_wxVListBox_TransferDataFromWindow(PyObject *, PyObject *);}
static PyObject *meth_wxVListBox_TransferDataFromWindow(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = SIP_NULLPTR;
    bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));

    {
        ::wxVListBox *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_wxVListBox, &sipCpp))
        {
            bool sipRes;

            PyErr_Clear();

            Py_BEGIN_ALLOW_THREADS
            sipRes = (sipSelfWasArg ? sipCpp->::wxVListBox::TransferDataFromWindow() : sipCpp->TransferDataFromWindow());
            Py_END_ALLOW_THREADS

            if (PyErr_Occurred())
                return 0;

            return PyBool_FromLong(sipRes);
        }
    }

    sipNoMethod(sipParseErr, sipName_VListBox, sipName_TransferDataFromWindow, doc_wxVListBox_TransferDataFromWindow);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_wxVListBox_InitDialog, "InitDialog(self)");

extern "C" {static PyObject *meth_wxVListBox_InitDialog(PyObject *, PyObject *);}
static PyObject *meth_wxVListBox_InitDialog(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = SIP_NULLPTR;
    bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));

    {
        ::wxVListBox *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_wxVListBox, &sipCpp))
        {
            PyErr_Clear();

            Py_BEGIN_ALLOW_THREADS
            (sipSelfWasArg ? sipCpp->::wxVListBox::InitDialog() : sipCpp->InitDialog());
            Py_END_ALLOW_THREADS

            if (PyErr_Occurred())
                return 0;

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    sipNoMethod(sipParseErr, sipName_VListBox, sipName_InitDialog, doc_wxVListBox_InitDialog);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_wxVListBox_AcceptsFocus, "AcceptsFocus(self) -> bool");

extern "C" {static PyObject *meth_wxVListBox_AcceptsFocus(PyObject *, PyObject *);}
static PyObject *meth_wxVListBox_AcceptsFocus(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = SIP_NULLPTR;
    bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));

    {
        const ::wxVListBox *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_wxVListBox, &sipCpp))
        {
            bool sipRes;

            PyErr_Clear();

            Py_BEGIN_ALLOW_THREADS
            sipRes = (sipSelfWasArg ? sipCpp->::wxVListBox::AcceptsFocus() : sipCpp->AcceptsFocus());
            Py_END_ALLOW_THREADS

            if (PyErr_Occurred())
                return 0;

            return PyBool_FromLong(sipRes);
        }
    }

    sipNoMethod(sipParseErr, sipName_VListBox, sipName_AcceptsFocus, doc_wxVListBox_AcceptsFocus);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_wxVListBox_AcceptsFocusRecursively, "AcceptsFocusRecursively(self) -> bool");

extern "C" {static PyObject *meth_wxVListBox_AcceptsFocusRecursively(PyObject *, PyObject *);}
static PyObject *meth_wxVListBox_AcceptsFocusRecursively(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = SIP_NULLPTR;
    bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));

    {
        const ::wxVListBox *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_wxVListBox, &sipCpp))
        {
            bool sipRes;

            PyErr_Clear();

            Py_BEGIN_ALLOW_THREADS
            sipRes = (sipSelfWasArg ? sipCpp->::wxVListBox::AcceptsFocusRecursively() : sipCpp->AcceptsFocusRecursively());
            Py_END_ALLOW_THREADS

            if (PyErr_Occurred())
                return 0;

            return PyBool_FromLong(sipRes);
        }
    }

    sipNoMethod(sipParseErr, sipName_VListBox, sipName_AcceptsFocusRecursively, doc_wxVListBox_AcceptsFocusRecursively);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_wxVListBox_AcceptsFocusFromKeyboard, "AcceptsFocusFromKeyboard(self) -> bool");

extern "C" {static PyObject *meth_wxVListBox_AcceptsFocusFromKeyboard(PyObject *, PyObject *);}
static PyObject *meth_wxVListBox_AcceptsFocusFromKeyboard(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = SIP_NULLPTR;
    bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));

    {
        const ::wxVListBox *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_wxVListBox, &sipCpp))
        {
            bool sipRes;

            PyErr_Clear();

            Py_BEGIN_ALLOW_THREADS
            sipRes = (sipSelfWasArg ? sipCpp->::wxVListBox::AcceptsFocusFromKeyboard() : sipCpp->AcceptsFocusFromKeyboard());
            Py_END_ALLOW_THREADS

            if (PyErr_Occurred())
                return 0;

            return PyBool_FromLong(sipRes);
        }
    }

    sipNoMethod(sipParseErr, sipName_VListBox, sipName_AcceptsFocusFromKeyboard, doc_wxVListBox_AcceptsFocusFromKeyboard);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_wxVListBox_AddChild, "AddChild(self, child: WindowBase|None)");

extern "C" {static PyObject *meth_wxVListBox_AddChild(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_wxVListBox_AddChild(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = SIP_NULLPTR;
    bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));

    {
        ::wxWindowBase* child;
        ::wxVListBox *sipCpp;

        static const char *sipKwdList[] = {
            sipName_child,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, SIP_NULLPTR, "BJ8", &sipSelf, sipType_wxVListBox, &sipCpp, sipType_wxWindowBase, &child))
        {
            PyErr_Clear();

            Py_BEGIN_ALLOW_THREADS
            (sipSelfWasArg ? sipCpp->::wxVListBox::AddChild(child) : sipCpp->AddChild(child));
            Py_END_ALLOW_THREADS

            if (PyErr_Occurred())
                return 0;

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    sipNoMethod(sipParseErr, sipName_VListBox, sipName_AddChild, doc_wxVListBox_AddChild);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_wxVListBox_RemoveChild, "RemoveChild(self, child: WindowBase|None)");

extern "C" {static PyObject *meth_wxVListBox_RemoveChild(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_wxVListBox_RemoveChild(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = SIP_NULLPTR;
    bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));

    {
        ::wxWindowBase* child;
        ::wxVListBox *sipCpp;

        static const char *sipKwdList[] = {
            sipName_child,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, SIP_NULLPTR, "BJ8", &sipSelf, sipType_wxVListBox, &sipCpp, sipType_wxWindowBase, &child))
        {
            PyErr_Clear();

            Py_BEGIN_ALLOW_THREADS
            (sipSelfWasArg ? sipCpp->::wxVListBox::RemoveChild(child) : sipCpp->RemoveChild(child));
            Py_END_ALLOW_THREADS

            if (PyErr_Occurred())
                return 0;

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    sipNoMethod(sipParseErr, sipName_VListBox, sipName_RemoveChild, doc_wxVListBox_RemoveChild);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_wxVListBox_InheritAttributes, "InheritAttributes(self)");

extern "C" {static PyObject *meth_wxVListBox_InheritAttributes(PyObject *, PyObject *);}
static PyObject *meth_wxVListBox_InheritAttributes(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = SIP_NULLPTR;
    bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));

    {
        ::wxVListBox *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_wxVListBox, &sipCpp))
        {
            PyErr_Clear();

            Py_BEGIN_ALLOW_THREADS
            (sipSelfWasArg ? sipCpp->::wxVListBox::InheritAttributes() : sipCpp->InheritAttributes());
            Py_END_ALLOW_THREADS

            if (PyErr_Occurred())
                return 0;

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    sipNoMethod(sipParseErr, sipName_VListBox, sipName_InheritAttributes, doc_wxVListBox_InheritAttributes);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_wxVListBox_ShouldInheritColours, "ShouldInheritColours(self) -> bool");

extern "C" {static PyObject *meth_wxVListBox_ShouldInheritColours(PyObject *, PyObject *);}
static PyObject *meth_wxVListBox_ShouldInheritColours(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = SIP_NULLPTR;
    bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));

    {
        const ::wxVListBox *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_wxVListBox, &sipCpp))
        {
            bool sipRes;

            PyErr_Clear();

            Py_BEGIN_ALLOW_THREADS
            sipRes = (sipSelfWasArg ? sipCpp->::wxVListBox::ShouldInheritColours() : sipCpp->ShouldInheritColours());
            Py_END_ALLOW_THREADS

            if (PyErr_Occurred())
                return 0;

            return PyBool_FromLong(sipRes);
        }
    }

    sipNoMethod(sipParseErr, sipName_VListBox, sipName_ShouldInheritColours, doc_wxVListBox_ShouldInheritColours);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_wxVListBox_OnInternalIdle, "OnInternalIdle(self)");

extern "C" {static PyObject *meth_wxVListBox_OnInternalIdle(PyObject *, PyObject *);}
static PyObject *meth_wxVListBox_OnInternalIdle(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = SIP_NULLPTR;
    bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));

    {
        ::wxVListBox *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_wxVListBox, &sipCpp))
        {
            PyErr_Clear();

            Py_BEGIN_ALLOW_THREADS
            (sipSelfWasArg ? sipCpp->::wxVListBox::OnInternalIdle() : sipCpp->OnInternalIdle());
            Py_END_ALLOW_THREADS

            if (PyErr_Occurred())
                return 0;

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    sipNoMethod(sipParseErr, sipName_VListBox, sipName_OnInternalIdle, doc_wxVListBox_OnInternalIdle);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_wxVListBox_GetMainWindowOfCompositeControl, "GetMainWindowOfCompositeControl(self) -> Window|None");

extern "C" {static PyObject *meth_wxVListBox_GetMainWindowOfCompositeControl(PyObject *, PyObject *);}
static PyObject *meth_wxVListBox_GetMainWindowOfCompositeControl(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = SIP_NULLPTR;
    bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));

    {
        ::wxVListBox *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_wxVListBox, &sipCpp))
        {
            ::wxWindow*sipRes;

            PyErr_Clear();

            Py_BEGIN_ALLOW_THREADS
            sipRes = (sipSelfWasArg ? sipCpp->::wxVListBox::GetMainWindowOfCompositeControl() : sipCpp->GetMainWindowOfCompositeControl());
            Py_END_ALLOW_THREADS

            if (PyErr_Occurred())
                return 0;

            return sipConvertFromType(sipRes, sipType_wxWindow, SIP_NULLPTR);
        }
    }

    sipNoMethod(sipParseErr, sipName_VListBox, sipName_GetMainWindowOfCompositeControl, doc_wxVListBox_GetMainWindowOfCompositeControl);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_wxVListBox_InformFirstDirection, "InformFirstDirection(self, direction: int, size: int, availableOtherDir: int) -> bool");

extern "C" {static PyObject *meth_wxVListBox_InformFirstDirection(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_wxVListBox_InformFirstDirection(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = SIP_NULLPTR;
    bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));

    {
        int direction;
        int size;
        int availableOtherDir;
        ::wxVListBox *sipCpp;

        static const char *sipKwdList[] = {
            sipName_direction,
            sipName_size,
            sipName_availableOtherDir,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, SIP_NULLPTR, "Biii", &sipSelf, sipType_wxVListBox, &sipCpp, &direction, &size, &availableOtherDir))
        {
            bool sipRes;

            PyErr_Clear();

            Py_BEGIN_ALLOW_THREADS
            sipRes = (sipSelfWasArg ? sipCpp->::wxVListBox::InformFirstDirection(direction, size, availableOtherDir) : sipCpp->InformFirstDirection(direction, size, availableOtherDir));
            Py_END_ALLOW_THREADS

            if (PyErr_Occurred())
                return 0;

            return PyBool_FromLong(sipRes);
        }
    }

    sipNoMethod(sipParseErr, sipName_VListBox, sipName_InformFirstDirection, doc_wxVListBox_InformFirstDirection);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_wxVListBox_SetCanFocus, "SetCanFocus(self, canFocus: bool)");

extern "C" {static PyObject *meth_wxVListBox_SetCanFocus(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_wxVListBox_SetCanFocus(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = SIP_NULLPTR;
    bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));

    {
        bool canFocus;
        ::wxVListBox *sipCpp;

        static const char *sipKwdList[] = {
            sipName_canFocus,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, SIP_NULLPTR, "Bb", &sipSelf, sipType_wxVListBox, &sipCpp, &canFocus))
        {
            PyErr_Clear();

            Py_BEGIN_ALLOW_THREADS
            (sipSelfWasArg ? sipCpp->::wxVListBox::SetCanFocus(canFocus) : sipCpp->SetCanFocus(canFocus));
            Py_END_ALLOW_THREADS

            if (PyErr_Occurred())
                return 0;

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    sipNoMethod(sipParseErr, sipName_VListBox, sipName_SetCanFocus, doc_wxVListBox_SetCanFocus);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_wxVListBox_Destroy, "Destroy(self) -> bool");

extern "C" {static PyObject *meth_wxVListBox_Destroy(PyObject *, PyObject *);}
static PyObject *meth_wxVListBox_Destroy(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = SIP_NULLPTR;
    bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));

    {
        ::wxVListBox *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_wxVListBox, &sipCpp))
        {
            bool sipRes;

            PyErr_Clear();

            Py_BEGIN_ALLOW_THREADS
            sipRes = (sipSelfWasArg ? sipCpp->::wxVListBox::Destroy() : sipCpp->Destroy());
            Py_END_ALLOW_THREADS

            if (PyErr_Occurred())
                return 0;

            return PyBool_FromLong(sipRes);
        }
    }

    sipNoMethod(sipParseErr, sipName_VListBox, sipName_Destroy, doc_wxVListBox_Destroy);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_wxVListBox_SetValidator, "SetValidator(self, validator: Validator)");

extern "C" {static PyObject *meth_wxVListBox_SetValidator(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_wxVListBox_SetValidator(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = SIP_NULLPTR;
    bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));

    {
        const ::wxValidator* validator;
        ::wxVListBox *sipCpp;

        static const char *sipKwdList[] = {
            sipName_validator,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, SIP_NULLPTR, "BJ9", &sipSelf, sipType_wxVListBox, &sipCpp, sipType_wxValidator, &validator))
        {
            PyErr_Clear();

            Py_BEGIN_ALLOW_THREADS
            (sipSelfWasArg ? sipCpp->::wxVListBox::SetValidator(*validator) : sipCpp->SetValidator(*validator));
            Py_END_ALLOW_THREADS

            if (PyErr_Occurred())
                return 0;

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    sipNoMethod(sipParseErr, sipName_VListBox, sipName_SetValidator, doc_wxVListBox_SetValidator);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_wxVListBox_GetValidator, "GetValidator(self) -> Validator|None");

extern "C" {static PyObject *meth_wxVListBox_GetValidator(PyObject *, PyObject *);}
static PyObject *meth_wxVListBox_GetValidator(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = SIP_NULLPTR;
    bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));

    {
        ::wxVListBox *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_wxVListBox, &sipCpp))
        {
            ::wxValidator*sipRes;

            PyErr_Clear();

            Py_BEGIN_ALLOW_THREADS
            sipRes = (sipSelfWasArg ? sipCpp->::wxVListBox::GetValidator() : sipCpp->GetValidator());
            Py_END_ALLOW_THREADS

            if (PyErr_Occurred())
                return 0;

            return sipConvertFromType(sipRes, sipType_wxValidator, SIP_NULLPTR);
        }
    }

    sipNoMethod(sipParseErr, sipName_VListBox, sipName_GetValidator, doc_wxVListBox_GetValidator);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_wxVListBox_EnableVisibleFocus, "EnableVisibleFocus(self, enabled: bool)");

extern "C" {static PyObject *meth_wxVListBox_EnableVisibleFocus(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_wxVListBox_EnableVisibleFocus(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = SIP_NULLPTR;
    bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));

    {
        bool enabled;
        ::wxVListBox *sipCpp;

        static const char *sipKwdList[] = {
            sipName_enabled,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, SIP_NULLPTR, "Bb", &sipSelf, sipType_wxVListBox, &sipCpp, &enabled))
        {
            PyErr_Clear();

            Py_BEGIN_ALLOW_THREADS
            (sipSelfWasArg ? sipCpp->::wxVListBox::EnableVisibleFocus(enabled) : sipCpp->EnableVisibleFocus(enabled));
            Py_END_ALLOW_THREADS

            if (PyErr_Occurred())
                return 0;

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    sipNoMethod(sipParseErr, sipName_VListBox, sipName_EnableVisibleFocus, doc_wxVListBox_EnableVisibleFocus);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_wxVListBox_ProcessEvent, "ProcessEvent(self, event: Event) -> bool");

extern "C" {static PyObject *meth_wxVListBox_ProcessEvent(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_wxVListBox_ProcessEvent(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = SIP_NULLPTR;
    bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));

    {
        ::wxEvent* event;
        sipwxVListBox *sipCpp;

        static const char *sipKwdList[] = {
            sipName_event,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, SIP_NULLPTR, "BJ9", &sipSelf, sipType_wxVListBox, &sipCpp, sipType_wxEvent, &event))
        {
            bool sipRes;

            PyErr_Clear();

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->sipProtectVirt_ProcessEvent(sipSelfWasArg, *event);
            Py_END_ALLOW_THREADS

            if (PyErr_Occurred())
                return 0;

            return PyBool_FromLong(sipRes);
        }
    }

    sipNoMethod(sipParseErr, sipName_VListBox, sipName_ProcessEvent, doc_wxVListBox_ProcessEvent);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_wxVListBox_DoEnable, "DoEnable(self, enable: bool)");

extern "C" {static PyObject *meth_wxVListBox_DoEnable(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_wxVListBox_DoEnable(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = SIP_NULLPTR;
    bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));

    {
        bool enable;
        sipwxVListBox *sipCpp;

        static const char *sipKwdList[] = {
            sipName_enable,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, SIP_NULLPTR, "Bb", &sipSelf, sipType_wxVListBox, &sipCpp, &enable))
        {
            PyErr_Clear();

            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtectVirt_DoEnable(sipSelfWasArg, enable);
            Py_END_ALLOW_THREADS

            if (PyErr_Occurred())
                return 0;

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    sipNoMethod(sipParseErr, sipName_VListBox, sipName_DoEnable, doc_wxVListBox_DoEnable);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_wxVListBox_DoGetPosition, "DoGetPosition(self) -> (int, int)");

extern "C" {static PyObject *meth_wxVListBox_DoGetPosition(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_wxVListBox_DoGetPosition(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = SIP_NULLPTR;
    bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));

    {
        int x;
        int y;
        const sipwxVListBox *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, SIP_NULLPTR, SIP_NULLPTR, "B", &sipSelf, sipType_wxVListBox, &sipCpp))
        {
            PyErr_Clear();

            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtectVirt_DoGetPosition(sipSelfWasArg, &x, &y);
            Py_END_ALLOW_THREADS

            if (PyErr_Occurred())
                return 0;

            return sipBuildResult(0, "(ii)", x, y);
        }
    }

    sipNoMethod(sipParseErr, sipName_VListBox, sipName_DoGetPosition, doc_wxVListBox_DoGetPosition);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_wxVListBox_DoGetSize, "DoGetSize(self) -> (int, int)");

extern "C" {static PyObject *meth_wxVListBox_DoGetSize(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_wxVListBox_DoGetSize(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = SIP_NULLPTR;
    bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));

    {
        int width;
        int height;
        const sipwxVListBox *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, SIP_NULLPTR, SIP_NULLPTR, "B", &sipSelf, sipType_wxVListBox, &sipCpp))
        {
            PyErr_Clear();

            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtectVirt_DoGetSize(sipSelfWasArg, &width, &height);
            Py_END_ALLOW_THREADS

            if (PyErr_Occurred())
                return 0;

            return sipBuildResult(0, "(ii)", width, height);
        }
    }

    sipNoMethod(sipParseErr, sipName_VListBox, sipName_DoGetSize, doc_wxVListBox_DoGetSize);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_wxVListBox_DoGetClientSize, "DoGetClientSize(self) -> (int, int)");

extern "C" {static PyObject *meth_wxVListBox_DoGetClientSize(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_wxVListBox_DoGetClientSize(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = SIP_NULLPTR;
    bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));

    {
        int width;
        int height;
        const sipwxVListBox *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, SIP_NULLPTR, SIP_NULLPTR, "B", &sipSelf, sipType_wxVListBox, &sipCpp))
        {
            PyErr_Clear();

            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtectVirt_DoGetClientSize(sipSelfWasArg, &width, &height);
            Py_END_ALLOW_THREADS

            if (PyErr_Occurred())
                return 0;

            return sipBuildResult(0, "(ii)", width, height);
        }
    }

    sipNoMethod(sipParseErr, sipName_VListBox, sipName_DoGetClientSize, doc_wxVListBox_DoGetClientSize);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_wxVListBox_DoGetBestSize, "DoGetBestSize(self) -> Size");

extern "C" {static PyObject *meth_wxVListBox_DoGetBestSize(PyObject *, PyObject *);}
static PyObject *meth_wxVListBox_DoGetBestSize(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = SIP_NULLPTR;
    bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));

    {
        const sipwxVListBox *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_wxVListBox, &sipCpp))
        {
            ::wxSize*sipRes;

            PyErr_Clear();

            Py_BEGIN_ALLOW_THREADS
            sipRes = new ::wxSize(sipCpp->sipProtectVirt_DoGetBestSize(sipSelfWasArg));
            Py_END_ALLOW_THREADS

            if (PyErr_Occurred())
                return 0;

            return sipConvertFromNewType(sipRes, sipType_wxSize, SIP_NULLPTR);
        }
    }

    sipNoMethod(sipParseErr, sipName_VListBox, sipName_DoGetBestSize, doc_wxVListBox_DoGetBestSize);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_wxVListBox_DoGetBestClientSize, "DoGetBestClientSize(self) -> Size");

extern "C" {static PyObject *meth_wxVListBox_DoGetBestClientSize(PyObject *, PyObject *);}
static PyObject *meth_wxVListBox_DoGetBestClientSize(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = SIP_NULLPTR;
    bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));

    {
        const sipwxVListBox *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_wxVListBox, &sipCpp))
        {
            ::wxSize*sipRes;

            PyErr_Clear();

            Py_BEGIN_ALLOW_THREADS
            sipRes = new ::wxSize(sipCpp->sipProtectVirt_DoGetBestClientSize(sipSelfWasArg));
            Py_END_ALLOW_THREADS

            if (PyErr_Occurred())
                return 0;

            return sipConvertFromNewType(sipRes, sipType_wxSize, SIP_NULLPTR);
        }
    }

    sipNoMethod(sipParseErr, sipName_VListBox, sipName_DoGetBestClientSize, doc_wxVListBox_DoGetBestClientSize);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_wxVListBox_DoSetSize, "DoSetSize(self, x: int, y: int, width: int, height: int, sizeFlags: int)");

extern "C" {static PyObject *meth_wxVListBox_DoSetSize(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_wxVListBox_DoSetSize(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = SIP_NULLPTR;
    bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));

    {
        int x;
        int y;
        int width;
        int height;
        int sizeFlags;
        sipwxVListBox *sipCpp;

        static const char *sipKwdList[] = {
            sipName_x,
            sipName_y,
            sipName_width,
            sipName_height,
            sipName_sizeFlags,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, SIP_NULLPTR, "Biiiii", &sipSelf, sipType_wxVListBox, &sipCpp, &x, &y, &width, &height, &sizeFlags))
        {
            PyErr_Clear();

            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtectVirt_DoSetSize(sipSelfWasArg, x, y, width, height, sizeFlags);
            Py_END_ALLOW_THREADS

            if (PyErr_Occurred())
                return 0;

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    sipNoMethod(sipParseErr, sipName_VListBox, sipName_DoSetSize, doc_wxVListBox_DoSetSize);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_wxVListBox_DoSetClientSize, "DoSetClientSize(self, width: int, height: int)");

extern "C" {static PyObject *meth_wxVListBox_DoSetClientSize(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_wxVListBox_DoSetClientSize(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = SIP_NULLPTR;
    bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));

    {
        int width;
        int height;
        sipwxVListBox *sipCpp;

        static const char *sipKwdList[] = {
            sipName_width,
            sipName_height,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, SIP_NULLPTR, "Bii", &sipSelf, sipType_wxVListBox, &sipCpp, &width, &height))
        {
            PyErr_Clear();

            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtectVirt_DoSetClientSize(sipSelfWasArg, width, height);
            Py_END_ALLOW_THREADS

            if (PyErr_Occurred())
                return 0;

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    sipNoMethod(sipParseErr, sipName_VListBox, sipName_DoSetClientSize, doc_wxVListBox_DoSetClientSize);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_wxVListBox_DoSetSizeHints, "DoSetSizeHints(self, minW: int, minH: int, maxW: int, maxH: int, incW: int, incH: int)");

extern "C" {static PyObject *meth_wxVListBox_DoSetSizeHints(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_wxVListBox_DoSetSizeHints(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = SIP_NULLPTR;
    bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));

    {
        int minW;
        int minH;
        int maxW;
        int maxH;
        int incW;
        int incH;
        sipwxVListBox *sipCpp;

        static const char *sipKwdList[] = {
            sipName_minW,
            sipName_minH,
            sipName_maxW,
            sipName_maxH,
            sipName_incW,
            sipName_incH,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, SIP_NULLPTR, "Biiiiii", &sipSelf, sipType_wxVListBox, &sipCpp, &minW, &minH, &maxW, &maxH, &incW, &incH))
        {
            PyErr_Clear();

            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtectVirt_DoSetSizeHints(sipSelfWasArg, minW, minH, maxW, maxH, incW, incH);
            Py_END_ALLOW_THREADS

            if (PyErr_Occurred())
                return 0;

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    sipNoMethod(sipParseErr, sipName_VListBox, sipName_DoSetSizeHints, doc_wxVListBox_DoSetSizeHints);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_wxVListBox_DoMoveWindow, "DoMoveWindow(self, x: int, y: int, width: int, height: int)");

extern "C" {static PyObject *meth_wxVListBox_DoMoveWindow(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_wxVListBox_DoMoveWindow(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = SIP_NULLPTR;
    bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));

    {
        int x;
        int y;
        int width;
        int height;
        sipwxVListBox *sipCpp;

        static const char *sipKwdList[] = {
            sipName_x,
            sipName_y,
            sipName_width,
            sipName_height,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, SIP_NULLPTR, "Biiii", &sipSelf, sipType_wxVListBox, &sipCpp, &x, &y, &width, &height))
        {
            PyErr_Clear();

            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtectVirt_DoMoveWindow(sipSelfWasArg, x, y, width, height);
            Py_END_ALLOW_THREADS

            if (PyErr_Occurred())
                return 0;

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    sipNoMethod(sipParseErr, sipName_VListBox, sipName_DoMoveWindow, doc_wxVListBox_DoMoveWindow);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_wxVListBox_DoSetWindowVariant, "DoSetWindowVariant(self, variant: WindowVariant)");

extern "C" {static PyObject *meth_wxVListBox_DoSetWindowVariant(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_wxVListBox_DoSetWindowVariant(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = SIP_NULLPTR;
    bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));

    {
        ::wxWindowVariant variant;
        sipwxVListBox *sipCpp;

        static const char *sipKwdList[] = {
            sipName_variant,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, SIP_NULLPTR, "BE", &sipSelf, sipType_wxVListBox, &sipCpp, sipType_wxWindowVariant, &variant))
        {
            PyErr_Clear();

            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtectVirt_DoSetWindowVariant(sipSelfWasArg, variant);
            Py_END_ALLOW_THREADS

            if (PyErr_Occurred())
                return 0;

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    sipNoMethod(sipParseErr, sipName_VListBox, sipName_DoSetWindowVariant, doc_wxVListBox_DoSetWindowVariant);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_wxVListBox_GetDefaultBorder, "GetDefaultBorder(self) -> Border");

extern "C" {static PyObject *meth_wxVListBox_GetDefaultBorder(PyObject *, PyObject *);}
static PyObject *meth_wxVListBox_GetDefaultBorder(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = SIP_NULLPTR;
    bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));

    {
        const sipwxVListBox *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_wxVListBox, &sipCpp))
        {
            ::wxBorder sipRes;

            PyErr_Clear();

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->sipProtectVirt_GetDefaultBorder(sipSelfWasArg);
            Py_END_ALLOW_THREADS

            if (PyErr_Occurred())
                return 0;

            return sipConvertFromEnum(static_cast<int>(sipRes), sipType_wxBorder);
        }
    }

    sipNoMethod(sipParseErr, sipName_VListBox, sipName_GetDefaultBorder, doc_wxVListBox_GetDefaultBorder);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_wxVListBox_GetDefaultBorderForControl, "GetDefaultBorderForControl(self) -> Border");

extern "C" {static PyObject *meth_wxVListBox_GetDefaultBorderForControl(PyObject *, PyObject *);}
static PyObject *meth_wxVListBox_GetDefaultBorderForControl(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = SIP_NULLPTR;
    bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));

    {
        const sipwxVListBox *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_wxVListBox, &sipCpp))
        {
            ::wxBorder sipRes;

            PyErr_Clear();

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->sipProtectVirt_GetDefaultBorderForControl(sipSelfWasArg);
            Py_END_ALLOW_THREADS

            if (PyErr_Occurred())
                return 0;

            return sipConvertFromEnum(static_cast<int>(sipRes), sipType_wxBorder);
        }
    }

    sipNoMethod(sipParseErr, sipName_VListBox, sipName_GetDefaultBorderForControl, doc_wxVListBox_GetDefaultBorderForControl);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_wxVListBox_DoFreeze, "DoFreeze(self)");

extern "C" {static PyObject *meth_wxVListBox_DoFreeze(PyObject *, PyObject *);}
static PyObject *meth_wxVListBox_DoFreeze(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = SIP_NULLPTR;
    bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));

    {
        sipwxVListBox *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_wxVListBox, &sipCpp))
        {
            PyErr_Clear();

            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtectVirt_DoFreeze(sipSelfWasArg);
            Py_END_ALLOW_THREADS

            if (PyErr_Occurred())
                return 0;

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    sipNoMethod(sipParseErr, sipName_VListBox, sipName_DoFreeze, doc_wxVListBox_DoFreeze);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_wxVListBox_DoThaw, "DoThaw(self)");

extern "C" {static PyObject *meth_wxVListBox_DoThaw(PyObject *, PyObject *);}
static PyObject *meth_wxVListBox_DoThaw(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = SIP_NULLPTR;
    bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));

    {
        sipwxVListBox *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_wxVListBox, &sipCpp))
        {
            PyErr_Clear();

            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtectVirt_DoThaw(sipSelfWasArg);
            Py_END_ALLOW_THREADS

            if (PyErr_Occurred())
                return 0;

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    sipNoMethod(sipParseErr, sipName_VListBox, sipName_DoThaw, doc_wxVListBox_DoThaw);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_wxVListBox_HasTransparentBackground, "HasTransparentBackground(self) -> bool");

extern "C" {static PyObject *meth_wxVListBox_HasTransparentBackground(PyObject *, PyObject *);}
static PyObject *meth_wxVListBox_HasTransparentBackground(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = SIP_NULLPTR;
    bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));

    {
        sipwxVListBox *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_wxVListBox, &sipCpp))
        {
            bool sipRes;

            PyErr_Clear();

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->sipProtectVirt_HasTransparentBackground(sipSelfWasArg);
            Py_END_ALLOW_THREADS

            if (PyErr_Occurred())
                return 0;

            return PyBool_FromLong(sipRes);
        }
    }

    sipNoMethod(sipParseErr, sipName_VListBox, sipName_HasTransparentBackground, doc_wxVListBox_HasTransparentBackground);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_wxVListBox_TryBefore, "TryBefore(self, event: Event) -> bool");

extern "C" {static PyObject *meth_wxVListBox_TryBefore(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_wxVListBox_TryBefore(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = SIP_NULLPTR;
    bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));

    {
        ::wxEvent* event;
        sipwxVListBox *sipCpp;

        static const char *sipKwdList[] = {
            sipName_event,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, SIP_NULLPTR, "BJ9", &sipSelf, sipType_wxVListBox, &sipCpp, sipType_wxEvent, &event))
        {
            bool sipRes;

            PyErr_Clear();

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->sipProtectVirt_TryBefore(sipSelfWasArg, *event);
            Py_END_ALLOW_THREADS

            if (PyErr_Occurred())
                return 0;

            return PyBool_FromLong(sipRes);
        }
    }

    sipNoMethod(sipParseErr, sipName_VListBox, sipName_TryBefore, doc_wxVListBox_TryBefore);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_wxVListBox_TryAfter, "TryAfter(self, event: Event) -> bool");

extern "C" {static PyObject *meth_wxVListBox_TryAfter(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_wxVListBox_TryAfter(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = SIP_NULLPTR;
    bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));

    {
        ::wxEvent* event;
        sipwxVListBox *sipCpp;

        static const char *sipKwdList[] = {
            sipName_event,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, SIP_NULLPTR, "BJ9", &sipSelf, sipType_wxVListBox, &sipCpp, sipType_wxEvent, &event))
        {
            bool sipRes;

            PyErr_Clear();

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->sipProtectVirt_TryAfter(sipSelfWasArg, *event);
            Py_END_ALLOW_THREADS

            if (PyErr_Occurred())
                return 0;

            return PyBool_FromLong(sipRes);
        }
    }

    sipNoMethod(sipParseErr, sipName_VListBox, sipName_TryAfter, doc_wxVListBox_TryAfter);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_wxVListBox_GetClassDefaultAttributes, "GetClassDefaultAttributes(variant=WINDOW_VARIANT_NORMAL) -> VisualAttributes");

extern "C" {static PyObject *meth_wxVListBox_GetClassDefaultAttributes(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_wxVListBox_GetClassDefaultAttributes(PyObject *, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = SIP_NULLPTR;

    {
        ::wxWindowVariant variant = wxWINDOW_VARIANT_NORMAL;

        static const char *sipKwdList[] = {
            sipName_variant,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, SIP_NULLPTR, "|E", sipType_wxWindowVariant, &variant))
        {
            ::wxVisualAttributes*sipRes;
        if (!wxPyCheckForApp()) return NULL;

            PyErr_Clear();

            Py_BEGIN_ALLOW_THREADS
            sipRes = new ::wxVisualAttributes(::wxVListBox::GetClassDefaultAttributes(variant));
            Py_END_ALLOW_THREADS

            if (PyErr_Occurred())
                return 0;

            return sipConvertFromNewType(sipRes, sipType_wxVisualAttributes, SIP_NULLPTR);
        }
    }

    sipNoMethod(sipParseErr, sipName_VListBox, sipName_GetClassDefaultAttributes, SIP_NULLPTR);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_wxVListBox_OnDrawItem, "OnDrawItem(dc, rect, n) -> None\n"
"\n"
"The derived class must implement this function to actually draw the\n"
"item with the given index on the provided DC.");

extern "C" {static PyObject *meth_wxVListBox_OnDrawItem(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_wxVListBox_OnDrawItem(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = SIP_NULLPTR;
    PyObject *sipOrigSelf = sipSelf;

    {
        ::wxDC* dc;
        const ::wxRect* rect;
        int rectState = 0;
        size_t n;
        const sipwxVListBox *sipCpp;

        static const char *sipKwdList[] = {
            sipName_dc,
            sipName_rect,
            sipName_n,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, SIP_NULLPTR, "BJ9J1=", &sipSelf, sipType_wxVListBox, &sipCpp, sipType_wxDC, &dc, sipType_wxRect, &rect, &rectState, &n))
        {
            if (!sipOrigSelf)
            {
                sipAbstractMethod(sipName_VListBox, sipName_OnDrawItem);
                return SIP_NULLPTR;
            }

            PyErr_Clear();

            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtect_OnDrawItem(*dc, *rect, n);
            Py_END_ALLOW_THREADS
            sipReleaseType(const_cast< ::wxRect *>(rect), sipType_wxRect, rectState);

            if (PyErr_Occurred())
                return 0;

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    sipNoMethod(sipParseErr, sipName_VListBox, sipName_OnDrawItem, SIP_NULLPTR);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_wxVListBox_OnDrawBackground, "OnDrawBackground(dc, rect, n) -> None\n"
"\n"
"This method is used to draw the item's background and, maybe, a border\n"
"around it.");

extern "C" {static PyObject *meth_wxVListBox_OnDrawBackground(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_wxVListBox_OnDrawBackground(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = SIP_NULLPTR;
    bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));

    {
        ::wxDC* dc;
        const ::wxRect* rect;
        int rectState = 0;
        size_t n;
        const sipwxVListBox *sipCpp;

        static const char *sipKwdList[] = {
            sipName_dc,
            sipName_rect,
            sipName_n,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, SIP_NULLPTR, "BJ9J1=", &sipSelf, sipType_wxVListBox, &sipCpp, sipType_wxDC, &dc, sipType_wxRect, &rect, &rectState, &n))
        {
            PyErr_Clear();

            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtectVirt_OnDrawBackground(sipSelfWasArg, *dc, *rect, n);
            Py_END_ALLOW_THREADS
            sipReleaseType(const_cast< ::wxRect *>(rect), sipType_wxRect, rectState);

            if (PyErr_Occurred())
                return 0;

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    sipNoMethod(sipParseErr, sipName_VListBox, sipName_OnDrawBackground, SIP_NULLPTR);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_wxVListBox_OnDrawSeparator, "OnDrawSeparator(dc, rect, n) -> None\n"
"\n"
"This method may be used to draw separators between the lines.");

extern "C" {static PyObject *meth_wxVListBox_OnDrawSeparator(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_wxVListBox_OnDrawSeparator(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = SIP_NULLPTR;
    bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));

    {
        ::wxDC* dc;
        ::wxRect* rect;
        int rectState = 0;
        size_t n;
        const sipwxVListBox *sipCpp;

        static const char *sipKwdList[] = {
            sipName_dc,
            sipName_rect,
            sipName_n,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, SIP_NULLPTR, "BJ9J1=", &sipSelf, sipType_wxVListBox, &sipCpp, sipType_wxDC, &dc, sipType_wxRect, &rect, &rectState, &n))
        {
            PyErr_Clear();

            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtectVirt_OnDrawSeparator(sipSelfWasArg, *dc, *rect, n);
            Py_END_ALLOW_THREADS
            sipReleaseType(rect, sipType_wxRect, rectState);

            if (PyErr_Occurred())
                return 0;

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    sipNoMethod(sipParseErr, sipName_VListBox, sipName_OnDrawSeparator, SIP_NULLPTR);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_wxVListBox_OnMeasureItem, "OnMeasureItem(n) -> int\n"
"\n"
"The derived class must implement this method to return the height of\n"
"the specified item (in pixels).");

extern "C" {static PyObject *meth_wxVListBox_OnMeasureItem(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_wxVListBox_OnMeasureItem(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = SIP_NULLPTR;
    PyObject *sipOrigSelf = sipSelf;

    {
        size_t n;
        const sipwxVListBox *sipCpp;

        static const char *sipKwdList[] = {
            sipName_n,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, SIP_NULLPTR, "B=", &sipSelf, sipType_wxVListBox, &sipCpp, &n))
        {
            ::wxCoord sipRes;

            if (!sipOrigSelf)
            {
                sipAbstractMethod(sipName_VListBox, sipName_OnMeasureItem);
                return SIP_NULLPTR;
            }

            PyErr_Clear();

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->sipProtect_OnMeasureItem(n);
            Py_END_ALLOW_THREADS

            if (PyErr_Occurred())
                return 0;

            return PyLong_FromLong(sipRes);
        }
    }

    sipNoMethod(sipParseErr, sipName_VListBox, sipName_OnMeasureItem, SIP_NULLPTR);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_wxVListBox_OnGetRowHeight, "OnGetRowHeight(self, n: int) -> int");

extern "C" {static PyObject *meth_wxVListBox_OnGetRowHeight(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_wxVListBox_OnGetRowHeight(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = SIP_NULLPTR;
    bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));

    {
        size_t n;
        const sipwxVListBox *sipCpp;

        static const char *sipKwdList[] = {
            sipName_n,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, SIP_NULLPTR, "B=", &sipSelf, sipType_wxVListBox, &sipCpp, &n))
        {
            ::wxCoord sipRes;

            PyErr_Clear();

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->sipProtectVirt_OnGetRowHeight(sipSelfWasArg, n);
            Py_END_ALLOW_THREADS

            if (PyErr_Occurred())
                return 0;

            return PyLong_FromLong(sipRes);
        }
    }

    sipNoMethod(sipParseErr, sipName_VListBox, sipName_OnGetRowHeight, doc_wxVListBox_OnGetRowHeight);

    return SIP_NULLPTR;
}


/* Cast a pointer to a type somewhere in its inheritance hierarchy. */
extern "C" {static void *cast_wxVListBox(void *, const sipTypeDef *);}
static void *cast_wxVListBox(void *sipCppV, const sipTypeDef *targetType)
{
    ::wxVListBox *sipCpp = reinterpret_cast< ::wxVListBox *>(sipCppV);

    if (targetType == sipType_wxVListBox)
        return sipCppV;

    sipCppV = ((const sipClassTypeDef *)sipType_wxVScrolledWindow)->ctd_cast(static_cast< ::wxVScrolledWindow *>(sipCpp), targetType);
    if (sipCppV)
        return sipCppV;

    return SIP_NULLPTR;
}


/* Call the instance's destructor. */
extern "C" {static void release_wxVListBox(void *, int);}
static void release_wxVListBox(void *sipCppV, int sipState)
{
    Py_BEGIN_ALLOW_THREADS

    if (sipState & SIP_DERIVED_CLASS)
        delete reinterpret_cast<sipwxVListBox *>(sipCppV);
    else
        delete reinterpret_cast< ::wxVListBox *>(sipCppV);

    Py_END_ALLOW_THREADS
}


extern "C" {static void dealloc_wxVListBox(sipSimpleWrapper *);}
static void dealloc_wxVListBox(sipSimpleWrapper *sipSelf)
{
    if (sipIsDerivedClass(sipSelf))
        reinterpret_cast<sipwxVListBox *>(sipGetAddress(sipSelf))->sipPySelf = SIP_NULLPTR;

    if (sipIsOwnedByPython(sipSelf))
    {
        release_wxVListBox(sipGetAddress(sipSelf), sipIsDerivedClass(sipSelf));
    }
}


extern "C" {static void *init_type_wxVListBox(sipSimpleWrapper *, PyObject *, PyObject *, PyObject **, PyObject **, PyObject **);}
static void *init_type_wxVListBox(sipSimpleWrapper *sipSelf, PyObject *sipArgs, PyObject *sipKwds, PyObject **sipUnused, PyObject **sipOwner, PyObject **sipParseErr)
{
    sipwxVListBox *sipCpp = SIP_NULLPTR;

    {
        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, SIP_NULLPTR, sipUnused, ""))
        {
        if (!wxPyCheckForApp()) return NULL;

            PyErr_Clear();

            Py_BEGIN_ALLOW_THREADS
            sipCpp = new sipwxVListBox();
            Py_END_ALLOW_THREADS

            if (PyErr_Occurred())
            {
                delete sipCpp;
                return SIP_NULLPTR;
            }

            sipCpp->sipPySelf = sipSelf;

            return sipCpp;
        }
    }

    {
        ::wxWindow* parent;
        ::wxWindowID id = wxID_ANY;
        const ::wxPoint& posdef = wxDefaultPosition;
        const ::wxPoint* pos = &posdef;
        int posState = 0;
        const ::wxSize& sizedef = wxDefaultSize;
        const ::wxSize* size = &sizedef;
        int sizeState = 0;
        long style = 0;
        const ::wxString& namedef = wxVListBoxNameStr;
        const ::wxString* name = &namedef;
        int nameState = 0;

        static const char *sipKwdList[] = {
            sipName_parent,
            sipName_id,
            sipName_pos,
            sipName_size,
            sipName_style,
            sipName_name,
        };

        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, sipKwdList, sipUnused, "JH|iJ1J1lJ1", sipType_wxWindow, &parent, sipOwner, &id, sipType_wxPoint, &pos, &posState, sipType_wxSize, &size, &sizeState, &style, sipType_wxString, &name, &nameState))
        {
        if (!wxPyCheckForApp()) return NULL;

            PyErr_Clear();

            Py_BEGIN_ALLOW_THREADS
            sipCpp = new sipwxVListBox(parent, id, *pos, *size, style, *name);
            Py_END_ALLOW_THREADS
            sipReleaseType(const_cast< ::wxPoint *>(pos), sipType_wxPoint, posState);
            sipReleaseType(const_cast< ::wxSize *>(size), sipType_wxSize, sizeState);
            sipReleaseType(const_cast< ::wxString *>(name), sipType_wxString, nameState);

            if (PyErr_Occurred())
            {
                delete sipCpp;
                return SIP_NULLPTR;
            }

            sipCpp->sipPySelf = sipSelf;

            return sipCpp;
        }
    }

    return SIP_NULLPTR;
}


/* Define this type's super-types. */
static sipEncodedTypeDef supers_wxVListBox[] = {{618, 255, 1}};


static PyMethodDef methods_wxVListBox[] = {
    {sipName_AcceptsFocus, meth_wxVListBox_AcceptsFocus, METH_VARARGS, doc_wxVListBox_AcceptsFocus},
    {sipName_AcceptsFocusFromKeyboard, meth_wxVListBox_AcceptsFocusFromKeyboard, METH_VARARGS, doc_wxVListBox_AcceptsFocusFromKeyboard},
    {sipName_AcceptsFocusRecursively, meth_wxVListBox_AcceptsFocusRecursively, METH_VARARGS, doc_wxVListBox_AcceptsFocusRecursively},
    {sipName_AddChild, SIP_MLMETH_CAST(meth_wxVListBox_AddChild), METH_VARARGS|METH_KEYWORDS, doc_wxVListBox_AddChild},
    {sipName_Clear, meth_wxVListBox_Clear, METH_VARARGS, doc_wxVListBox_Clear},
    {sipName_Create, SIP_MLMETH_CAST(meth_wxVListBox_Create), METH_VARARGS|METH_KEYWORDS, doc_wxVListBox_Create},
    {sipName_DeselectAll, meth_wxVListBox_DeselectAll, METH_VARARGS, doc_wxVListBox_DeselectAll},
    {sipName_Destroy, meth_wxVListBox_Destroy, METH_VARARGS, doc_wxVListBox_Destroy},
    {sipName_DoEnable, SIP_MLMETH_CAST(meth_wxVListBox_DoEnable), METH_VARARGS|METH_KEYWORDS, doc_wxVListBox_DoEnable},
    {sipName_DoFreeze, meth_wxVListBox_DoFreeze, METH_VARARGS, doc_wxVListBox_DoFreeze},
    {sipName_DoGetBestClientSize, meth_wxVListBox_DoGetBestClientSize, METH_VARARGS, doc_wxVListBox_DoGetBestClientSize},
    {sipName_DoGetBestSize, meth_wxVListBox_DoGetBestSize, METH_VARARGS, doc_wxVListBox_DoGetBestSize},
    {sipName_DoGetClientSize, SIP_MLMETH_CAST(meth_wxVListBox_DoGetClientSize), METH_VARARGS|METH_KEYWORDS, doc_wxVListBox_DoGetClientSize},
    {sipName_DoGetPosition, SIP_MLMETH_CAST(meth_wxVListBox_DoGetPosition), METH_VARARGS|METH_KEYWORDS, doc_wxVListBox_DoGetPosition},
    {sipName_DoGetSize, SIP_MLMETH_CAST(meth_wxVListBox_DoGetSize), METH_VARARGS|METH_KEYWORDS, doc_wxVListBox_DoGetSize},
    {sipName_DoMoveWindow, SIP_MLMETH_CAST(meth_wxVListBox_DoMoveWindow), METH_VARARGS|METH_KEYWORDS, doc_wxVListBox_DoMoveWindow},
    {sipName_DoSetClientSize, SIP_MLMETH_CAST(meth_wxVListBox_DoSetClientSize), METH_VARARGS|METH_KEYWORDS, doc_wxVListBox_DoSetClientSize},
    {sipName_DoSetSize, SIP_MLMETH_CAST(meth_wxVListBox_DoSetSize), METH_VARARGS|METH_KEYWORDS, doc_wxVListBox_DoSetSize},
    {sipName_DoSetSizeHints, SIP_MLMETH_CAST(meth_wxVListBox_DoSetSizeHints), METH_VARARGS|METH_KEYWORDS, doc_wxVListBox_DoSetSizeHints},
    {sipName_DoSetWindowVariant, SIP_MLMETH_CAST(meth_wxVListBox_DoSetWindowVariant), METH_VARARGS|METH_KEYWORDS, doc_wxVListBox_DoSetWindowVariant},
    {sipName_DoThaw, meth_wxVListBox_DoThaw, METH_VARARGS, doc_wxVListBox_DoThaw},
    {sipName_EnableVisibleFocus, SIP_MLMETH_CAST(meth_wxVListBox_EnableVisibleFocus), METH_VARARGS|METH_KEYWORDS, doc_wxVListBox_EnableVisibleFocus},
    {sipName_EstimateTotalHeight, meth_wxVListBox_EstimateTotalHeight, METH_VARARGS, SIP_NULLPTR},
    {sipName_EstimateTotalSize, meth_wxVListBox_EstimateTotalSize, METH_VARARGS, SIP_NULLPTR},
    {sipName_GetClassDefaultAttributes, SIP_MLMETH_CAST(meth_wxVListBox_GetClassDefaultAttributes), METH_VARARGS|METH_KEYWORDS, doc_wxVListBox_GetClassDefaultAttributes},
    {sipName_GetClientAreaOrigin, meth_wxVListBox_GetClientAreaOrigin, METH_VARARGS, doc_wxVListBox_GetClientAreaOrigin},
    {sipName_GetDefaultBorder, meth_wxVListBox_GetDefaultBorder, METH_VARARGS, doc_wxVListBox_GetDefaultBorder},
    {sipName_GetDefaultBorderForControl, meth_wxVListBox_GetDefaultBorderForControl, METH_VARARGS, doc_wxVListBox_GetDefaultBorderForControl},
    {sipName_GetFirstSelected, SIP_MLMETH_CAST(meth_wxVListBox_GetFirstSelected), METH_VARARGS|METH_KEYWORDS, doc_wxVListBox_GetFirstSelected},
    {sipName_GetItemCount, meth_wxVListBox_GetItemCount, METH_VARARGS, doc_wxVListBox_GetItemCount},
    {sipName_GetItemRect, SIP_MLMETH_CAST(meth_wxVListBox_GetItemRect), METH_VARARGS|METH_KEYWORDS, doc_wxVListBox_GetItemRect},
    {sipName_GetMainWindowOfCompositeControl, meth_wxVListBox_GetMainWindowOfCompositeControl, METH_VARARGS, doc_wxVListBox_GetMainWindowOfCompositeControl},
    {sipName_GetMargins, meth_wxVListBox_GetMargins, METH_VARARGS, doc_wxVListBox_GetMargins},
    {sipName_GetNextSelected, SIP_MLMETH_CAST(meth_wxVListBox_GetNextSelected), METH_VARARGS|METH_KEYWORDS, doc_wxVListBox_GetNextSelected},
    {sipName_GetNonOrientationTargetSize, meth_wxVListBox_GetNonOrientationTargetSize, METH_VARARGS, SIP_NULLPTR},
    {sipName_GetOrientation, meth_wxVListBox_GetOrientation, METH_VARARGS, SIP_NULLPTR},
    {sipName_GetOrientationTargetSize, meth_wxVListBox_GetOrientationTargetSize, METH_VARARGS, SIP_NULLPTR},
    {sipName_GetSelectedCount, meth_wxVListBox_GetSelectedCount, METH_VARARGS, doc_wxVListBox_GetSelectedCount},
    {sipName_GetSelection, meth_wxVListBox_GetSelection, METH_VARARGS, doc_wxVListBox_GetSelection},
    {sipName_GetSelectionBackground, meth_wxVListBox_GetSelectionBackground, METH_VARARGS, doc_wxVListBox_GetSelectionBackground},
    {sipName_GetValidator, meth_wxVListBox_GetValidator, METH_VARARGS, doc_wxVListBox_GetValidator},
    {sipName_HasMultipleSelection, meth_wxVListBox_HasMultipleSelection, METH_VARARGS, doc_wxVListBox_HasMultipleSelection},
    {sipName_HasTransparentBackground, meth_wxVListBox_HasTransparentBackground, METH_VARARGS, doc_wxVListBox_HasTransparentBackground},
    {sipName_InformFirstDirection, SIP_MLMETH_CAST(meth_wxVListBox_InformFirstDirection), METH_VARARGS|METH_KEYWORDS, doc_wxVListBox_InformFirstDirection},
    {sipName_InheritAttributes, meth_wxVListBox_InheritAttributes, METH_VARARGS, doc_wxVListBox_InheritAttributes},
    {sipName_InitDialog, meth_wxVListBox_InitDialog, METH_VARARGS, doc_wxVListBox_InitDialog},
    {sipName_IsCurrent, SIP_MLMETH_CAST(meth_wxVListBox_IsCurrent), METH_VARARGS|METH_KEYWORDS, doc_wxVListBox_IsCurrent},
    {sipName_IsSelected, SIP_MLMETH_CAST(meth_wxVListBox_IsSelected), METH_VARARGS|METH_KEYWORDS, doc_wxVListBox_IsSelected},
    {sipName_OnDrawBackground, SIP_MLMETH_CAST(meth_wxVListBox_OnDrawBackground), METH_VARARGS|METH_KEYWORDS, doc_wxVListBox_OnDrawBackground},
    {sipName_OnDrawItem, SIP_MLMETH_CAST(meth_wxVListBox_OnDrawItem), METH_VARARGS|METH_KEYWORDS, doc_wxVListBox_OnDrawItem},
    {sipName_OnDrawSeparator, SIP_MLMETH_CAST(meth_wxVListBox_OnDrawSeparator), METH_VARARGS|METH_KEYWORDS, doc_wxVListBox_OnDrawSeparator},
    {sipName_OnGetRowHeight, SIP_MLMETH_CAST(meth_wxVListBox_OnGetRowHeight), METH_VARARGS|METH_KEYWORDS, doc_wxVListBox_OnGetRowHeight},
    {sipName_OnGetRowsHeightHint, SIP_MLMETH_CAST(meth_wxVListBox_OnGetRowsHeightHint), METH_VARARGS|METH_KEYWORDS, SIP_NULLPTR},
    {sipName_OnGetUnitSize, SIP_MLMETH_CAST(meth_wxVListBox_OnGetUnitSize), METH_VARARGS|METH_KEYWORDS, SIP_NULLPTR},
    {sipName_OnGetUnitsSizeHint, SIP_MLMETH_CAST(meth_wxVListBox_OnGetUnitsSizeHint), METH_VARARGS|METH_KEYWORDS, SIP_NULLPTR},
    {sipName_OnInternalIdle, meth_wxVListBox_OnInternalIdle, METH_VARARGS, doc_wxVListBox_OnInternalIdle},
    {sipName_OnMeasureItem, SIP_MLMETH_CAST(meth_wxVListBox_OnMeasureItem), METH_VARARGS|METH_KEYWORDS, doc_wxVListBox_OnMeasureItem},
    {sipName_ProcessEvent, SIP_MLMETH_CAST(meth_wxVListBox_ProcessEvent), METH_VARARGS|METH_KEYWORDS, doc_wxVListBox_ProcessEvent},
    {sipName_RemoveChild, SIP_MLMETH_CAST(meth_wxVListBox_RemoveChild), METH_VARARGS|METH_KEYWORDS, doc_wxVListBox_RemoveChild},
    {sipName_Select, SIP_MLMETH_CAST(meth_wxVListBox_Select), METH_VARARGS|METH_KEYWORDS, doc_wxVListBox_Select},
    {sipName_SelectAll, meth_wxVListBox_SelectAll, METH_VARARGS, doc_wxVListBox_SelectAll},
    {sipName_SelectRange, SIP_MLMETH_CAST(meth_wxVListBox_SelectRange), METH_VARARGS|METH_KEYWORDS, doc_wxVListBox_SelectRange},
    {sipName_SendDestroyEvent, meth_wxVListBox_SendDestroyEvent, METH_VARARGS, SIP_NULLPTR},
    {sipName_SetCanFocus, SIP_MLMETH_CAST(meth_wxVListBox_SetCanFocus), METH_VARARGS|METH_KEYWORDS, doc_wxVListBox_SetCanFocus},
    {sipName_SetItemCount, SIP_MLMETH_CAST(meth_wxVListBox_SetItemCount), METH_VARARGS|METH_KEYWORDS, doc_wxVListBox_SetItemCount},
    {sipName_SetMargins, SIP_MLMETH_CAST(meth_wxVListBox_SetMargins), METH_VARARGS|METH_KEYWORDS, doc_wxVListBox_SetMargins},
    {sipName_SetSelection, SIP_MLMETH_CAST(meth_wxVListBox_SetSelection), METH_VARARGS|METH_KEYWORDS, doc_wxVListBox_SetSelection},
    {sipName_SetSelectionBackground, SIP_MLMETH_CAST(meth_wxVListBox_SetSelectionBackground), METH_VARARGS|METH_KEYWORDS, doc_wxVListBox_SetSelectionBackground},
    {sipName_SetValidator, SIP_MLMETH_CAST(meth_wxVListBox_SetValidator), METH_VARARGS|METH_KEYWORDS, doc_wxVListBox_SetValidator},
    {sipName_ShouldInheritColours, meth_wxVListBox_ShouldInheritColours, METH_VARARGS, doc_wxVListBox_ShouldInheritColours},
    {sipName_Toggle, SIP_MLMETH_CAST(meth_wxVListBox_Toggle), METH_VARARGS|METH_KEYWORDS, doc_wxVListBox_Toggle},
    {sipName_TransferDataFromWindow, meth_wxVListBox_TransferDataFromWindow, METH_VARARGS, doc_wxVListBox_TransferDataFromWindow},
    {sipName_TransferDataToWindow, meth_wxVListBox_TransferDataToWindow, METH_VARARGS, doc_wxVListBox_TransferDataToWindow},
    {sipName_TryAfter, SIP_MLMETH_CAST(meth_wxVListBox_TryAfter), METH_VARARGS|METH_KEYWORDS, doc_wxVListBox_TryAfter},
    {sipName_TryBefore, SIP_MLMETH_CAST(meth_wxVListBox_TryBefore), METH_VARARGS|METH_KEYWORDS, doc_wxVListBox_TryBefore},
    {sipName_Validate, meth_wxVListBox_Validate, METH_VARARGS, doc_wxVListBox_Validate}
};

sipVariableDef variables_wxVListBox[] = {
    {PropertyVariable, sipName_SelectionBackground, &methods_wxVListBox[39], &methods_wxVListBox[67], SIP_NULLPTR, SIP_NULLPTR},
    {PropertyVariable, sipName_Selection, &methods_wxVListBox[38], &methods_wxVListBox[66], SIP_NULLPTR, SIP_NULLPTR},
    {PropertyVariable, sipName_SelectedCount, &methods_wxVListBox[37], SIP_NULLPTR, SIP_NULLPTR, SIP_NULLPTR},
    {PropertyVariable, sipName_Margins, &methods_wxVListBox[32], &methods_wxVListBox[65], SIP_NULLPTR, SIP_NULLPTR},
    {PropertyVariable, sipName_ItemCount, &methods_wxVListBox[29], &methods_wxVListBox[64], SIP_NULLPTR, SIP_NULLPTR},
};

PyDoc_STRVAR(doc_wxVListBox, "VListBox() -> None\n"
"VListBox(parent, id=ID_ANY, pos=DefaultPosition, size=DefaultSize, style=0, name=VListBoxNameStr) -> None\n"
"\n"
"wxVListBox is a wxListBox-like control with the following two main\n"
"differences from a regular wxListBox: it can have an arbitrarily huge\n"
"number of items because it doesn't store them itself but uses the\n"
"OnDrawItem() callback to draw them (so it is a virtual listbox) and\n"
"its items can have variable height as determined by OnMeasureItem()\n"
"(so it is also a listbox with the lines of variable height).");


sipClassTypeDef sipTypeDef__core_wxVListBox = {
    {
        -1,
        SIP_NULLPTR,
        SIP_NULLPTR,
        SIP_TYPE_ABSTRACT|SIP_TYPE_SCC|SIP_TYPE_CLASS,
        sipNameNr_wxVListBox,
        SIP_NULLPTR,
        SIP_NULLPTR,
    },
    {
        sipNameNr_VListBox,
        {0, 0, 1},
        76, methods_wxVListBox,
        0, SIP_NULLPTR,
        5, variables_wxVListBox,
        {SIP_NULLPTR, SIP_NULLPTR, SIP_NULLPTR, SIP_NULLPTR, SIP_NULLPTR, SIP_NULLPTR, SIP_NULLPTR, SIP_NULLPTR, SIP_NULLPTR, SIP_NULLPTR},
    },
    doc_wxVListBox,
    -1,
    -1,
    supers_wxVListBox,
    SIP_NULLPTR,
    init_type_wxVListBox,
    SIP_NULLPTR,
    SIP_NULLPTR,
    SIP_NULLPTR,
    SIP_NULLPTR,
    dealloc_wxVListBox,
    SIP_NULLPTR,
    SIP_NULLPTR,
    SIP_NULLPTR,
    release_wxVListBox,
    cast_wxVListBox,
    SIP_NULLPTR,
    SIP_NULLPTR,
    SIP_NULLPTR,
    SIP_NULLPTR,
    SIP_NULLPTR,
    SIP_NULLPTR,
    SIP_NULLPTR,
    sizeof (::wxVListBox),
};
