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

#include "sipAPI_core.h"

        #include <wx/vscroll.h>

        #include <wx/window.h>
        #include <wx/gdicmn.h>
        #include <wx/gdicmn.h>
        #include <wx/window.h>
        #include <wx/event.h>
        #include <wx/validate.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/gdicmn.h>
        #include <wx/event.h>
        #include <wx/event.h>
        #include <wx/palette.h>
        #include <wx/colour.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>
    unsigned long _wxVScrolledWindow_GetFirstVisibleLine(wxVScrolledWindow* self)
    {
        return self->GetVisibleRowsBegin();
    }
    unsigned long _wxVScrolledWindow_GetLastVisibleLine(wxVScrolledWindow* self)
    {
        return self->GetVisibleRowsEnd();
    }
    unsigned long _wxVScrolledWindow_GetLineCount(wxVScrolledWindow* self)
    {
        return self->GetRowCount();
    }
    void _wxVScrolledWindow_SetLineCount(wxVScrolledWindow* self, unsigned long count)
    {
        self->SetRowCount(count);
    }
    void _wxVScrolledWindow_RefreshLine(wxVScrolledWindow* self, unsigned long line)
    {
        self->RefreshRow(line);
    }
    void _wxVScrolledWindow_RefreshLines(wxVScrolledWindow* self, unsigned long from_, unsigned long to_)
    {
        self->RefreshRows(from_, to_);
    }
    bool _wxVScrolledWindow_ScrollToLine(wxVScrolledWindow* self, unsigned long line)
    {
        return self->ScrollToRow(line);
    }
    bool _wxVScrolledWindow_ScrollLines(wxVScrolledWindow* self, int lines)
    {
        return self->ScrollRows(lines);
    }
    bool _wxVScrolledWindow_ScrollPages(wxVScrolledWindow* self, int pages)
    {
        return self->ScrollRowPages(pages);
    }


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

    /*
     * 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;
     ::wxCoord sipProtect_OnGetRowHeight(size_t) 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);
     ::wxSize sipProtectVirt_DoGetBorderSize(bool) const;
    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&);

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

public:
    sipSimpleWrapper *sipPySelf;

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

    char sipPyMethods[53];
};

sipwxVScrolledWindow::sipwxVScrolledWindow():  ::wxVScrolledWindow(), sipPySelf(SIP_NULLPTR)
{
    memset(sipPyMethods, 0, sizeof (sipPyMethods));
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

 ::wxCoord sipwxVScrolledWindow::OnGetRowHeight(size_t row) const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,const_cast<char *>(&sipPyMethods[12]),sipPySelf,sipName_VScrolledWindow,sipName_OnGetRowHeight);

    if (!sipMeth)
        return 0;

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

    return sipVH__core_141(sipGILState, 0, sipPySelf, sipMeth, row);
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

 ::wxSize sipwxVScrolledWindow::DoGetBorderSize() const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,const_cast<char *>(&sipPyMethods[21]),sipPySelf,SIP_NULLPTR,sipName_DoGetBorderSize);

    if (!sipMeth)
        return  ::wxVScrolledWindow::DoGetBorderSize();

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

 ::wxCoord sipwxVScrolledWindow::sipProtect_OnGetRowHeight(size_t row) const
{
    return OnGetRowHeight(row);
}

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

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

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

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

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

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

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

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

void sipwxVScrolledWindow::sipProtectVirt_DoEnable(bool sipSelfWasArg,bool enable)
{
    (sipSelfWasArg ?  ::wxVScrolledWindow::DoEnable(enable) : DoEnable(enable));
}

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

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

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

 ::wxSize sipwxVScrolledWindow::sipProtectVirt_DoGetBestSize(bool sipSelfWasArg) const
{
    return (sipSelfWasArg ?  ::wxVScrolledWindow::DoGetBestSize() : DoGetBestSize());
}

 ::wxSize sipwxVScrolledWindow::sipProtectVirt_DoGetBestClientSize(bool sipSelfWasArg) const
{
    return (sipSelfWasArg ?  ::wxVScrolledWindow::DoGetBestClientSize() : DoGetBestClientSize());
}

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

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

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

 ::wxSize sipwxVScrolledWindow::sipProtectVirt_DoGetBorderSize(bool sipSelfWasArg) const
{
    return (sipSelfWasArg ?  ::wxVScrolledWindow::DoGetBorderSize() : DoGetBorderSize());
}

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

void sipwxVScrolledWindow::sipProtectVirt_DoSetWindowVariant(bool sipSelfWasArg, ::wxWindowVariant variant)
{
    (sipSelfWasArg ?  ::wxVScrolledWindow::DoSetWindowVariant(variant) : DoSetWindowVariant(variant));
}

 ::wxBorder sipwxVScrolledWindow::sipProtectVirt_GetDefaultBorder(bool sipSelfWasArg) const
{
    return (sipSelfWasArg ?  ::wxVScrolledWindow::GetDefaultBorder() : GetDefaultBorder());
}

 ::wxBorder sipwxVScrolledWindow::sipProtectVirt_GetDefaultBorderForControl(bool sipSelfWasArg) const
{
    return (sipSelfWasArg ?  ::wxVScrolledWindow::GetDefaultBorderForControl() : GetDefaultBorderForControl());
}

void sipwxVScrolledWindow::sipProtectVirt_DoFreeze(bool sipSelfWasArg)
{
    (sipSelfWasArg ?  ::wxVScrolledWindow::DoFreeze() : DoFreeze());
}

void sipwxVScrolledWindow::sipProtectVirt_DoThaw(bool sipSelfWasArg)
{
    (sipSelfWasArg ?  ::wxVScrolledWindow::DoThaw() : DoThaw());
}

bool sipwxVScrolledWindow::sipProtectVirt_HasTransparentBackground(bool sipSelfWasArg)
{
    return (sipSelfWasArg ?  ::wxVScrolledWindow::HasTransparentBackground() : HasTransparentBackground());
}

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

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


PyDoc_STRVAR(doc_wxVScrolledWindow_OnGetRowsHeightHint, "OnGetRowsHeightHint(rowMin, rowMax)\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_wxVScrolledWindow_OnGetRowsHeightHint(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_wxVScrolledWindow_OnGetRowsHeightHint(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = SIP_NULLPTR;
    bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));

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

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

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, SIP_NULLPTR, "B==", &sipSelf, sipType_wxVScrolledWindow, &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_VScrolledWindow, sipName_OnGetRowsHeightHint, SIP_NULLPTR);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_wxVScrolledWindow_EstimateTotalHeight, "EstimateTotalHeight() -> Coord\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_wxVScrolledWindow_EstimateTotalHeight(PyObject *, PyObject *);}
static PyObject *meth_wxVScrolledWindow_EstimateTotalHeight(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = SIP_NULLPTR;
    bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));

    {
        const sipwxVScrolledWindow *sipCpp;

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

            PyErr_Clear();

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

            if (PyErr_Occurred())
                return 0;

            return SIPLong_FromLong(sipRes);
        }
    }

    sipNoMethod(sipParseErr, sipName_VScrolledWindow, sipName_EstimateTotalHeight, SIP_NULLPTR);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_wxVScrolledWindow_OnGetRowHeight, "OnGetRowHeight(row) -> Coord\n"
"\n"
"This function must be overridden in the derived class, and should\n"
"return the height of the given row in pixels.");

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

    {
        size_t row;
        const sipwxVScrolledWindow *sipCpp;

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

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

            if (!sipOrigSelf)
            {
                sipAbstractMethod(sipName_VScrolledWindow, sipName_OnGetRowHeight);
                return SIP_NULLPTR;
            }

            PyErr_Clear();

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->sipProtect_OnGetRowHeight(row);
            Py_END_ALLOW_THREADS

            if (PyErr_Occurred())
                return 0;

            return SIPLong_FromLong(sipRes);
        }
    }

    sipNoMethod(sipParseErr, sipName_VScrolledWindow, sipName_OnGetRowHeight, SIP_NULLPTR);

    return SIP_NULLPTR;
}


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

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

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

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

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, SIP_NULLPTR, "B==", &sipSelf, sipType_wxVScrolledWindow, &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_VScrolledWindow, sipName_OnGetUnitsSizeHint, doc_wxVScrolledWindow_OnGetUnitsSizeHint);

    return SIP_NULLPTR;
}


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

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

    {
        const sipwxVScrolledWindow *sipCpp;

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

            PyErr_Clear();

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

            if (PyErr_Occurred())
                return 0;

            return SIPLong_FromLong(sipRes);
        }
    }

    sipNoMethod(sipParseErr, sipName_VScrolledWindow, sipName_EstimateTotalSize, doc_wxVScrolledWindow_EstimateTotalSize);

    return SIP_NULLPTR;
}


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

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

    {
        const sipwxVScrolledWindow *sipCpp;

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

            PyErr_Clear();

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

            if (PyErr_Occurred())
                return 0;

            return SIPLong_FromLong(sipRes);
        }
    }

    sipNoMethod(sipParseErr, sipName_VScrolledWindow, sipName_GetNonOrientationTargetSize, doc_wxVScrolledWindow_GetNonOrientationTargetSize);

    return SIP_NULLPTR;
}


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

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

    {
        const sipwxVScrolledWindow *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_wxVScrolledWindow, &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_VScrolledWindow, sipName_GetOrientation, doc_wxVScrolledWindow_GetOrientation);

    return SIP_NULLPTR;
}


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

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

    {
        const sipwxVScrolledWindow *sipCpp;

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

            PyErr_Clear();

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

            if (PyErr_Occurred())
                return 0;

            return SIPLong_FromLong(sipRes);
        }
    }

    sipNoMethod(sipParseErr, sipName_VScrolledWindow, sipName_GetOrientationTargetSize, doc_wxVScrolledWindow_GetOrientationTargetSize);

    return SIP_NULLPTR;
}


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

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

    {
        size_t unit;
        const sipwxVScrolledWindow *sipCpp;

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

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, SIP_NULLPTR, "B=", &sipSelf, sipType_wxVScrolledWindow, &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 SIPLong_FromLong(sipRes);
        }
    }

    sipNoMethod(sipParseErr, sipName_VScrolledWindow, sipName_OnGetUnitSize, doc_wxVScrolledWindow_OnGetUnitSize);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_wxVScrolledWindow_SendDestroyEvent, "SendDestroyEvent()\n"
"\n"
"Generate wxWindowDestroyEvent for this window.");

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

    {
        sipwxVScrolledWindow *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_wxVScrolledWindow, &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_VScrolledWindow, sipName_SendDestroyEvent, SIP_NULLPTR);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_wxVScrolledWindow_Create, "Create(parent, id=ID_ANY, pos=DefaultPosition, size=DefaultSize, style=0, name=PanelNameStr) -> bool\n"
"\n"
"Same as the non-default constructor, but returns a status code: true\n"
"if ok, false if the window couldn't be created.");

extern "C" {static PyObject *meth_wxVScrolledWindow_Create(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_wxVScrolledWindow_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 = wxPanelNameStr;
        const  ::wxString* name = &namedef;
        int nameState = 0;
        sipWrapper *sipOwner = SIP_NULLPTR;
         ::wxVScrolledWindow *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_wxVScrolledWindow, &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_VScrolledWindow, sipName_Create, SIP_NULLPTR);

    return SIP_NULLPTR;
}


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

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

    {
        const  ::wxVScrolledWindow *sipCpp;

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

            PyErr_Clear();

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

            if (PyErr_Occurred())
                return 0;

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

    sipNoMethod(sipParseErr, sipName_VScrolledWindow, sipName_GetClientAreaOrigin, doc_wxVScrolledWindow_GetClientAreaOrigin);

    return SIP_NULLPTR;
}


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

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

    {
         ::wxVScrolledWindow *sipCpp;

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

            PyErr_Clear();

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

            if (PyErr_Occurred())
                return 0;

            return PyBool_FromLong(sipRes);
        }
    }

    sipNoMethod(sipParseErr, sipName_VScrolledWindow, sipName_Validate, doc_wxVScrolledWindow_Validate);

    return SIP_NULLPTR;
}


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

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

    {
         ::wxVScrolledWindow *sipCpp;

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

            PyErr_Clear();

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

            if (PyErr_Occurred())
                return 0;

            return PyBool_FromLong(sipRes);
        }
    }

    sipNoMethod(sipParseErr, sipName_VScrolledWindow, sipName_TransferDataToWindow, doc_wxVScrolledWindow_TransferDataToWindow);

    return SIP_NULLPTR;
}


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

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

    {
         ::wxVScrolledWindow *sipCpp;

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

            PyErr_Clear();

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

            if (PyErr_Occurred())
                return 0;

            return PyBool_FromLong(sipRes);
        }
    }

    sipNoMethod(sipParseErr, sipName_VScrolledWindow, sipName_TransferDataFromWindow, doc_wxVScrolledWindow_TransferDataFromWindow);

    return SIP_NULLPTR;
}


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

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

    {
         ::wxVScrolledWindow *sipCpp;

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

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

            if (PyErr_Occurred())
                return 0;

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    sipNoMethod(sipParseErr, sipName_VScrolledWindow, sipName_InitDialog, doc_wxVScrolledWindow_InitDialog);

    return SIP_NULLPTR;
}


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

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

    {
        const  ::wxVScrolledWindow *sipCpp;

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

            PyErr_Clear();

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

            if (PyErr_Occurred())
                return 0;

            return PyBool_FromLong(sipRes);
        }
    }

    sipNoMethod(sipParseErr, sipName_VScrolledWindow, sipName_AcceptsFocus, doc_wxVScrolledWindow_AcceptsFocus);

    return SIP_NULLPTR;
}


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

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

    {
        const  ::wxVScrolledWindow *sipCpp;

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

            PyErr_Clear();

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

            if (PyErr_Occurred())
                return 0;

            return PyBool_FromLong(sipRes);
        }
    }

    sipNoMethod(sipParseErr, sipName_VScrolledWindow, sipName_AcceptsFocusRecursively, doc_wxVScrolledWindow_AcceptsFocusRecursively);

    return SIP_NULLPTR;
}


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

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

    {
        const  ::wxVScrolledWindow *sipCpp;

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

            PyErr_Clear();

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

            if (PyErr_Occurred())
                return 0;

            return PyBool_FromLong(sipRes);
        }
    }

    sipNoMethod(sipParseErr, sipName_VScrolledWindow, sipName_AcceptsFocusFromKeyboard, doc_wxVScrolledWindow_AcceptsFocusFromKeyboard);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_wxVScrolledWindow_AddChild, "AddChild(self, child: WindowBase)");

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

    {
         ::wxWindowBase* child;
         ::wxVScrolledWindow *sipCpp;

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

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

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

            if (PyErr_Occurred())
                return 0;

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    sipNoMethod(sipParseErr, sipName_VScrolledWindow, sipName_AddChild, doc_wxVScrolledWindow_AddChild);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_wxVScrolledWindow_RemoveChild, "RemoveChild(self, child: WindowBase)");

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

    {
         ::wxWindowBase* child;
         ::wxVScrolledWindow *sipCpp;

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

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

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

            if (PyErr_Occurred())
                return 0;

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    sipNoMethod(sipParseErr, sipName_VScrolledWindow, sipName_RemoveChild, doc_wxVScrolledWindow_RemoveChild);

    return SIP_NULLPTR;
}


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

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

    {
         ::wxVScrolledWindow *sipCpp;

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

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

            if (PyErr_Occurred())
                return 0;

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    sipNoMethod(sipParseErr, sipName_VScrolledWindow, sipName_InheritAttributes, doc_wxVScrolledWindow_InheritAttributes);

    return SIP_NULLPTR;
}


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

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

    {
        const  ::wxVScrolledWindow *sipCpp;

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

            PyErr_Clear();

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

            if (PyErr_Occurred())
                return 0;

            return PyBool_FromLong(sipRes);
        }
    }

    sipNoMethod(sipParseErr, sipName_VScrolledWindow, sipName_ShouldInheritColours, doc_wxVScrolledWindow_ShouldInheritColours);

    return SIP_NULLPTR;
}


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

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

    {
         ::wxVScrolledWindow *sipCpp;

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

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

            if (PyErr_Occurred())
                return 0;

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    sipNoMethod(sipParseErr, sipName_VScrolledWindow, sipName_OnInternalIdle, doc_wxVScrolledWindow_OnInternalIdle);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_wxVScrolledWindow_GetMainWindowOfCompositeControl, "GetMainWindowOfCompositeControl(self) -> Window");

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

    {
         ::wxVScrolledWindow *sipCpp;

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

            PyErr_Clear();

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

            if (PyErr_Occurred())
                return 0;

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

    sipNoMethod(sipParseErr, sipName_VScrolledWindow, sipName_GetMainWindowOfCompositeControl, doc_wxVScrolledWindow_GetMainWindowOfCompositeControl);

    return SIP_NULLPTR;
}


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

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

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

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

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

            PyErr_Clear();

            Py_BEGIN_ALLOW_THREADS
            sipRes = (sipSelfWasArg ? sipCpp-> ::wxVScrolledWindow::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_VScrolledWindow, sipName_InformFirstDirection, doc_wxVScrolledWindow_InformFirstDirection);

    return SIP_NULLPTR;
}


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

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

    {
        bool canFocus;
         ::wxVScrolledWindow *sipCpp;

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

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

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

            if (PyErr_Occurred())
                return 0;

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    sipNoMethod(sipParseErr, sipName_VScrolledWindow, sipName_SetCanFocus, doc_wxVScrolledWindow_SetCanFocus);

    return SIP_NULLPTR;
}


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

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

    {
         ::wxVScrolledWindow *sipCpp;

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

            PyErr_Clear();

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

            if (PyErr_Occurred())
                return 0;

            return PyBool_FromLong(sipRes);
        }
    }

    sipNoMethod(sipParseErr, sipName_VScrolledWindow, sipName_Destroy, doc_wxVScrolledWindow_Destroy);

    return SIP_NULLPTR;
}


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

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

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

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

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

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

            if (PyErr_Occurred())
                return 0;

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    sipNoMethod(sipParseErr, sipName_VScrolledWindow, sipName_SetValidator, doc_wxVScrolledWindow_SetValidator);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_wxVScrolledWindow_GetValidator, "GetValidator(self) -> Validator");

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

    {
         ::wxVScrolledWindow *sipCpp;

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

            PyErr_Clear();

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

            if (PyErr_Occurred())
                return 0;

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

    sipNoMethod(sipParseErr, sipName_VScrolledWindow, sipName_GetValidator, doc_wxVScrolledWindow_GetValidator);

    return SIP_NULLPTR;
}


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

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

    {
        bool enabled;
         ::wxVScrolledWindow *sipCpp;

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

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

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

            if (PyErr_Occurred())
                return 0;

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    sipNoMethod(sipParseErr, sipName_VScrolledWindow, sipName_EnableVisibleFocus, doc_wxVScrolledWindow_EnableVisibleFocus);

    return SIP_NULLPTR;
}


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

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

    {
         ::wxEvent* event;
        sipwxVScrolledWindow *sipCpp;

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

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, SIP_NULLPTR, "BJ9", &sipSelf, sipType_wxVScrolledWindow, &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_VScrolledWindow, sipName_ProcessEvent, doc_wxVScrolledWindow_ProcessEvent);

    return SIP_NULLPTR;
}


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

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

    {
        bool enable;
        sipwxVScrolledWindow *sipCpp;

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

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, SIP_NULLPTR, "Bb", &sipSelf, sipType_wxVScrolledWindow, &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_VScrolledWindow, sipName_DoEnable, doc_wxVScrolledWindow_DoEnable);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_wxVScrolledWindow_DoGetPosition, "DoGetPosition(self) -> Tuple[int, int]");

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

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

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, SIP_NULLPTR, SIP_NULLPTR, "B", &sipSelf, sipType_wxVScrolledWindow, &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_VScrolledWindow, sipName_DoGetPosition, doc_wxVScrolledWindow_DoGetPosition);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_wxVScrolledWindow_DoGetSize, "DoGetSize(self) -> Tuple[int, int]");

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

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

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, SIP_NULLPTR, SIP_NULLPTR, "B", &sipSelf, sipType_wxVScrolledWindow, &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_VScrolledWindow, sipName_DoGetSize, doc_wxVScrolledWindow_DoGetSize);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_wxVScrolledWindow_DoGetClientSize, "DoGetClientSize(self) -> Tuple[int, int]");

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

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

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, SIP_NULLPTR, SIP_NULLPTR, "B", &sipSelf, sipType_wxVScrolledWindow, &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_VScrolledWindow, sipName_DoGetClientSize, doc_wxVScrolledWindow_DoGetClientSize);

    return SIP_NULLPTR;
}


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

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

    {
        const sipwxVScrolledWindow *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_wxVScrolledWindow, &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_VScrolledWindow, sipName_DoGetBestSize, doc_wxVScrolledWindow_DoGetBestSize);

    return SIP_NULLPTR;
}


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

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

    {
        const sipwxVScrolledWindow *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_wxVScrolledWindow, &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_VScrolledWindow, sipName_DoGetBestClientSize, doc_wxVScrolledWindow_DoGetBestClientSize);

    return SIP_NULLPTR;
}


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

extern "C" {static PyObject *meth_wxVScrolledWindow_DoSetSize(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_wxVScrolledWindow_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;
        sipwxVScrolledWindow *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_wxVScrolledWindow, &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_VScrolledWindow, sipName_DoSetSize, doc_wxVScrolledWindow_DoSetSize);

    return SIP_NULLPTR;
}


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

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

    {
        int width;
        int height;
        sipwxVScrolledWindow *sipCpp;

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

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, SIP_NULLPTR, "Bii", &sipSelf, sipType_wxVScrolledWindow, &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_VScrolledWindow, sipName_DoSetClientSize, doc_wxVScrolledWindow_DoSetClientSize);

    return SIP_NULLPTR;
}


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

extern "C" {static PyObject *meth_wxVScrolledWindow_DoSetSizeHints(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_wxVScrolledWindow_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;
        sipwxVScrolledWindow *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_wxVScrolledWindow, &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_VScrolledWindow, sipName_DoSetSizeHints, doc_wxVScrolledWindow_DoSetSizeHints);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_wxVScrolledWindow_DoGetBorderSize, "DoGetBorderSize(self) -> Size");

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

    {
        const sipwxVScrolledWindow *sipCpp;

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

            PyErr_Clear();

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

            if (PyErr_Occurred())
                return 0;

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

    sipNoMethod(sipParseErr, sipName_VScrolledWindow, sipName_DoGetBorderSize, doc_wxVScrolledWindow_DoGetBorderSize);

    return SIP_NULLPTR;
}


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

extern "C" {static PyObject *meth_wxVScrolledWindow_DoMoveWindow(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_wxVScrolledWindow_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;
        sipwxVScrolledWindow *sipCpp;

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

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, SIP_NULLPTR, "Biiii", &sipSelf, sipType_wxVScrolledWindow, &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_VScrolledWindow, sipName_DoMoveWindow, doc_wxVScrolledWindow_DoMoveWindow);

    return SIP_NULLPTR;
}


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

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

    {
         ::wxWindowVariant variant;
        sipwxVScrolledWindow *sipCpp;

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

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, SIP_NULLPTR, "BE", &sipSelf, sipType_wxVScrolledWindow, &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_VScrolledWindow, sipName_DoSetWindowVariant, doc_wxVScrolledWindow_DoSetWindowVariant);

    return SIP_NULLPTR;
}


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

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

    {
        const sipwxVScrolledWindow *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_wxVScrolledWindow, &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_VScrolledWindow, sipName_GetDefaultBorder, doc_wxVScrolledWindow_GetDefaultBorder);

    return SIP_NULLPTR;
}


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

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

    {
        const sipwxVScrolledWindow *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_wxVScrolledWindow, &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_VScrolledWindow, sipName_GetDefaultBorderForControl, doc_wxVScrolledWindow_GetDefaultBorderForControl);

    return SIP_NULLPTR;
}


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

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

    {
        sipwxVScrolledWindow *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_wxVScrolledWindow, &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_VScrolledWindow, sipName_DoFreeze, doc_wxVScrolledWindow_DoFreeze);

    return SIP_NULLPTR;
}


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

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

    {
        sipwxVScrolledWindow *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_wxVScrolledWindow, &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_VScrolledWindow, sipName_DoThaw, doc_wxVScrolledWindow_DoThaw);

    return SIP_NULLPTR;
}


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

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

    {
        sipwxVScrolledWindow *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_wxVScrolledWindow, &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_VScrolledWindow, sipName_HasTransparentBackground, doc_wxVScrolledWindow_HasTransparentBackground);

    return SIP_NULLPTR;
}


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

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

    {
         ::wxEvent* event;
        sipwxVScrolledWindow *sipCpp;

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

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, SIP_NULLPTR, "BJ9", &sipSelf, sipType_wxVScrolledWindow, &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_VScrolledWindow, sipName_TryBefore, doc_wxVScrolledWindow_TryBefore);

    return SIP_NULLPTR;
}


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

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

    {
         ::wxEvent* event;
        sipwxVScrolledWindow *sipCpp;

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

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, SIP_NULLPTR, "BJ9", &sipSelf, sipType_wxVScrolledWindow, &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_VScrolledWindow, sipName_TryAfter, doc_wxVScrolledWindow_TryAfter);

    return SIP_NULLPTR;
}


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

extern "C" {static PyObject *meth_wxVScrolledWindow_GetClassDefaultAttributes(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_wxVScrolledWindow_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( ::wxVScrolledWindow::GetClassDefaultAttributes(variant));
            Py_END_ALLOW_THREADS

            if (PyErr_Occurred())
                return 0;

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

    sipNoMethod(sipParseErr, sipName_VScrolledWindow, sipName_GetClassDefaultAttributes, SIP_NULLPTR);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_wxVScrolledWindow_GetFirstVisibleLine, "GetFirstVisibleLine() -> unsignedlong\n"
"\n"
"Deprecated compatibility helper.");

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

    {
         ::wxVScrolledWindow *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_wxVScrolledWindow, &sipCpp))
        {
            unsigned long sipRes = 0;
            int sipIsErr = 0;

            if (sipDeprecated(sipName_VScrolledWindow,sipName_GetFirstVisibleLine) < 0)
                return SIP_NULLPTR;

        PyErr_Clear();
        Py_BEGIN_ALLOW_THREADS
        sipRes = _wxVScrolledWindow_GetFirstVisibleLine(sipCpp);
        Py_END_ALLOW_THREADS
        if (PyErr_Occurred()) sipIsErr = 1;

            if (sipIsErr)
                return 0;

            return PyLong_FromUnsignedLong(sipRes);
        }
    }

    sipNoMethod(sipParseErr, sipName_VScrolledWindow, sipName_GetFirstVisibleLine, SIP_NULLPTR);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_wxVScrolledWindow_GetLastVisibleLine, "GetLastVisibleLine() -> unsignedlong\n"
"\n"
"Deprecated compatibility helper.");

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

    {
         ::wxVScrolledWindow *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_wxVScrolledWindow, &sipCpp))
        {
            unsigned long sipRes = 0;
            int sipIsErr = 0;

            if (sipDeprecated(sipName_VScrolledWindow,sipName_GetLastVisibleLine) < 0)
                return SIP_NULLPTR;

        PyErr_Clear();
        Py_BEGIN_ALLOW_THREADS
        sipRes = _wxVScrolledWindow_GetLastVisibleLine(sipCpp);
        Py_END_ALLOW_THREADS
        if (PyErr_Occurred()) sipIsErr = 1;

            if (sipIsErr)
                return 0;

            return PyLong_FromUnsignedLong(sipRes);
        }
    }

    sipNoMethod(sipParseErr, sipName_VScrolledWindow, sipName_GetLastVisibleLine, SIP_NULLPTR);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_wxVScrolledWindow_GetLineCount, "GetLineCount() -> unsignedlong\n"
"\n"
"Deprecated compatibility helper.");

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

    {
         ::wxVScrolledWindow *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_wxVScrolledWindow, &sipCpp))
        {
            unsigned long sipRes = 0;
            int sipIsErr = 0;

            if (sipDeprecated(sipName_VScrolledWindow,sipName_GetLineCount) < 0)
                return SIP_NULLPTR;

        PyErr_Clear();
        Py_BEGIN_ALLOW_THREADS
        sipRes = _wxVScrolledWindow_GetLineCount(sipCpp);
        Py_END_ALLOW_THREADS
        if (PyErr_Occurred()) sipIsErr = 1;

            if (sipIsErr)
                return 0;

            return PyLong_FromUnsignedLong(sipRes);
        }
    }

    sipNoMethod(sipParseErr, sipName_VScrolledWindow, sipName_GetLineCount, SIP_NULLPTR);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_wxVScrolledWindow_SetLineCount, "SetLineCount(count)\n"
"\n"
"Deprecated compatibility helper.");

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

    {
        unsigned long count;
         ::wxVScrolledWindow *sipCpp;

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

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, SIP_NULLPTR, "Bm", &sipSelf, sipType_wxVScrolledWindow, &sipCpp, &count))
        {
            int sipIsErr = 0;

            if (sipDeprecated(sipName_VScrolledWindow,sipName_SetLineCount) < 0)
                return SIP_NULLPTR;

        PyErr_Clear();
        Py_BEGIN_ALLOW_THREADS
        _wxVScrolledWindow_SetLineCount(sipCpp, count);
        Py_END_ALLOW_THREADS
        if (PyErr_Occurred()) sipIsErr = 1;

            if (sipIsErr)
                return 0;

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    sipNoMethod(sipParseErr, sipName_VScrolledWindow, sipName_SetLineCount, SIP_NULLPTR);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_wxVScrolledWindow_RefreshLine, "RefreshLine(line)\n"
"\n"
"Deprecated compatibility helper.");

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

    {
        unsigned long line;
         ::wxVScrolledWindow *sipCpp;

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

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, SIP_NULLPTR, "Bm", &sipSelf, sipType_wxVScrolledWindow, &sipCpp, &line))
        {
            int sipIsErr = 0;

            if (sipDeprecated(sipName_VScrolledWindow,sipName_RefreshLine) < 0)
                return SIP_NULLPTR;

        PyErr_Clear();
        Py_BEGIN_ALLOW_THREADS
        _wxVScrolledWindow_RefreshLine(sipCpp, line);
        Py_END_ALLOW_THREADS
        if (PyErr_Occurred()) sipIsErr = 1;

            if (sipIsErr)
                return 0;

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    sipNoMethod(sipParseErr, sipName_VScrolledWindow, sipName_RefreshLine, SIP_NULLPTR);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_wxVScrolledWindow_RefreshLines, "RefreshLines(from_, to_)\n"
"\n"
"Deprecated compatibility helper.");

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

    {
        unsigned long from_;
        unsigned long to_;
         ::wxVScrolledWindow *sipCpp;

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

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, SIP_NULLPTR, "Bmm", &sipSelf, sipType_wxVScrolledWindow, &sipCpp, &from_, &to_))
        {
            int sipIsErr = 0;

            if (sipDeprecated(sipName_VScrolledWindow,sipName_RefreshLines) < 0)
                return SIP_NULLPTR;

        PyErr_Clear();
        Py_BEGIN_ALLOW_THREADS
        _wxVScrolledWindow_RefreshLines(sipCpp, from_, to_);
        Py_END_ALLOW_THREADS
        if (PyErr_Occurred()) sipIsErr = 1;

            if (sipIsErr)
                return 0;

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    sipNoMethod(sipParseErr, sipName_VScrolledWindow, sipName_RefreshLines, SIP_NULLPTR);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_wxVScrolledWindow_ScrollToLine, "ScrollToLine(line) -> bool\n"
"\n"
"Deprecated compatibility helper.");

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

    {
        unsigned long line;
         ::wxVScrolledWindow *sipCpp;

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

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, SIP_NULLPTR, "Bm", &sipSelf, sipType_wxVScrolledWindow, &sipCpp, &line))
        {
            bool sipRes = 0;
            int sipIsErr = 0;

            if (sipDeprecated(sipName_VScrolledWindow,sipName_ScrollToLine) < 0)
                return SIP_NULLPTR;

        PyErr_Clear();
        Py_BEGIN_ALLOW_THREADS
        sipRes = _wxVScrolledWindow_ScrollToLine(sipCpp, line);
        Py_END_ALLOW_THREADS
        if (PyErr_Occurred()) sipIsErr = 1;

            if (sipIsErr)
                return 0;

            return PyBool_FromLong(sipRes);
        }
    }

    sipNoMethod(sipParseErr, sipName_VScrolledWindow, sipName_ScrollToLine, SIP_NULLPTR);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_wxVScrolledWindow_ScrollLines, "ScrollLines(lines) -> bool\n"
"\n"
"Deprecated compatibility helper.");

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

    {
        int lines;
         ::wxVScrolledWindow *sipCpp;

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

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, SIP_NULLPTR, "Bi", &sipSelf, sipType_wxVScrolledWindow, &sipCpp, &lines))
        {
            bool sipRes = 0;
            int sipIsErr = 0;

            if (sipDeprecated(sipName_VScrolledWindow,sipName_ScrollLines) < 0)
                return SIP_NULLPTR;

        PyErr_Clear();
        Py_BEGIN_ALLOW_THREADS
        sipRes = _wxVScrolledWindow_ScrollLines(sipCpp, lines);
        Py_END_ALLOW_THREADS
        if (PyErr_Occurred()) sipIsErr = 1;

            if (sipIsErr)
                return 0;

            return PyBool_FromLong(sipRes);
        }
    }

    sipNoMethod(sipParseErr, sipName_VScrolledWindow, sipName_ScrollLines, SIP_NULLPTR);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_wxVScrolledWindow_ScrollPages, "ScrollPages(pages) -> bool\n"
"\n"
"Deprecated compatibility helper.");

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

    {
        int pages;
         ::wxVScrolledWindow *sipCpp;

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

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, SIP_NULLPTR, "Bi", &sipSelf, sipType_wxVScrolledWindow, &sipCpp, &pages))
        {
            bool sipRes = 0;
            int sipIsErr = 0;

            if (sipDeprecated(sipName_VScrolledWindow,sipName_ScrollPages) < 0)
                return SIP_NULLPTR;

        PyErr_Clear();
        Py_BEGIN_ALLOW_THREADS
        sipRes = _wxVScrolledWindow_ScrollPages(sipCpp, pages);
        Py_END_ALLOW_THREADS
        if (PyErr_Occurred()) sipIsErr = 1;

            if (sipIsErr)
                return 0;

            return PyBool_FromLong(sipRes);
        }
    }

    sipNoMethod(sipParseErr, sipName_VScrolledWindow, sipName_ScrollPages, SIP_NULLPTR);

    return SIP_NULLPTR;
}


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

    if (targetType == sipType_wxPanel)
        return static_cast< ::wxPanel *>(sipCpp);

    if (targetType == sipType_wxWindow)
        return static_cast< ::wxWindow *>(sipCpp);

    if (targetType == sipType_wxWindowBase)
        return static_cast< ::wxWindowBase *>(sipCpp);

    if (targetType == sipType_wxEvtHandler)
        return static_cast< ::wxEvtHandler *>(sipCpp);

    if (targetType == sipType_wxObject)
        return static_cast< ::wxObject *>(sipCpp);

    if (targetType == sipType_wxTrackable)
        return static_cast< ::wxTrackable *>(sipCpp);

    if (targetType == sipType_wxVarVScrollHelper)
        return static_cast< ::wxVarVScrollHelper *>(sipCpp);

    if (targetType == sipType_wxVarScrollHelperBase)
        return static_cast< ::wxVarScrollHelperBase *>(sipCpp);

    return sipCppV;
}


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

    if (sipState & SIP_DERIVED_CLASS)
        delete reinterpret_cast<sipwxVScrolledWindow *>(sipCppV);
    else
        delete reinterpret_cast< ::wxVScrolledWindow *>(sipCppV);

    Py_END_ALLOW_THREADS
}


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

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


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

    {
        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, SIP_NULLPTR, sipUnused, ""))
        {

        if (!wxPyCheckForApp()) return NULL;

            PyErr_Clear();

            Py_BEGIN_ALLOW_THREADS
            sipCpp = new sipwxVScrolledWindow();
            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 = wxPanelNameStr;
        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 sipwxVScrolledWindow(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_wxVScrolledWindow[] = {{387, 255, 0}, {598, 255, 1}};


static PyMethodDef methods_wxVScrolledWindow[] = {
    {SIP_MLNAME_CAST(sipName_AcceptsFocus), meth_wxVScrolledWindow_AcceptsFocus, METH_VARARGS, SIP_MLDOC_CAST(doc_wxVScrolledWindow_AcceptsFocus)},
    {SIP_MLNAME_CAST(sipName_AcceptsFocusFromKeyboard), meth_wxVScrolledWindow_AcceptsFocusFromKeyboard, METH_VARARGS, SIP_MLDOC_CAST(doc_wxVScrolledWindow_AcceptsFocusFromKeyboard)},
    {SIP_MLNAME_CAST(sipName_AcceptsFocusRecursively), meth_wxVScrolledWindow_AcceptsFocusRecursively, METH_VARARGS, SIP_MLDOC_CAST(doc_wxVScrolledWindow_AcceptsFocusRecursively)},
    {SIP_MLNAME_CAST(sipName_AddChild), SIP_MLMETH_CAST(meth_wxVScrolledWindow_AddChild), METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_wxVScrolledWindow_AddChild)},
    {SIP_MLNAME_CAST(sipName_Create), SIP_MLMETH_CAST(meth_wxVScrolledWindow_Create), METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_wxVScrolledWindow_Create)},
    {SIP_MLNAME_CAST(sipName_Destroy), meth_wxVScrolledWindow_Destroy, METH_VARARGS, SIP_MLDOC_CAST(doc_wxVScrolledWindow_Destroy)},
    {SIP_MLNAME_CAST(sipName_DoEnable), SIP_MLMETH_CAST(meth_wxVScrolledWindow_DoEnable), METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_wxVScrolledWindow_DoEnable)},
    {SIP_MLNAME_CAST(sipName_DoFreeze), meth_wxVScrolledWindow_DoFreeze, METH_VARARGS, SIP_MLDOC_CAST(doc_wxVScrolledWindow_DoFreeze)},
    {SIP_MLNAME_CAST(sipName_DoGetBestClientSize), meth_wxVScrolledWindow_DoGetBestClientSize, METH_VARARGS, SIP_MLDOC_CAST(doc_wxVScrolledWindow_DoGetBestClientSize)},
    {SIP_MLNAME_CAST(sipName_DoGetBestSize), meth_wxVScrolledWindow_DoGetBestSize, METH_VARARGS, SIP_MLDOC_CAST(doc_wxVScrolledWindow_DoGetBestSize)},
    {SIP_MLNAME_CAST(sipName_DoGetBorderSize), meth_wxVScrolledWindow_DoGetBorderSize, METH_VARARGS, SIP_MLDOC_CAST(doc_wxVScrolledWindow_DoGetBorderSize)},
    {SIP_MLNAME_CAST(sipName_DoGetClientSize), SIP_MLMETH_CAST(meth_wxVScrolledWindow_DoGetClientSize), METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_wxVScrolledWindow_DoGetClientSize)},
    {SIP_MLNAME_CAST(sipName_DoGetPosition), SIP_MLMETH_CAST(meth_wxVScrolledWindow_DoGetPosition), METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_wxVScrolledWindow_DoGetPosition)},
    {SIP_MLNAME_CAST(sipName_DoGetSize), SIP_MLMETH_CAST(meth_wxVScrolledWindow_DoGetSize), METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_wxVScrolledWindow_DoGetSize)},
    {SIP_MLNAME_CAST(sipName_DoMoveWindow), SIP_MLMETH_CAST(meth_wxVScrolledWindow_DoMoveWindow), METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_wxVScrolledWindow_DoMoveWindow)},
    {SIP_MLNAME_CAST(sipName_DoSetClientSize), SIP_MLMETH_CAST(meth_wxVScrolledWindow_DoSetClientSize), METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_wxVScrolledWindow_DoSetClientSize)},
    {SIP_MLNAME_CAST(sipName_DoSetSize), SIP_MLMETH_CAST(meth_wxVScrolledWindow_DoSetSize), METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_wxVScrolledWindow_DoSetSize)},
    {SIP_MLNAME_CAST(sipName_DoSetSizeHints), SIP_MLMETH_CAST(meth_wxVScrolledWindow_DoSetSizeHints), METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_wxVScrolledWindow_DoSetSizeHints)},
    {SIP_MLNAME_CAST(sipName_DoSetWindowVariant), SIP_MLMETH_CAST(meth_wxVScrolledWindow_DoSetWindowVariant), METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_wxVScrolledWindow_DoSetWindowVariant)},
    {SIP_MLNAME_CAST(sipName_DoThaw), meth_wxVScrolledWindow_DoThaw, METH_VARARGS, SIP_MLDOC_CAST(doc_wxVScrolledWindow_DoThaw)},
    {SIP_MLNAME_CAST(sipName_EnableVisibleFocus), SIP_MLMETH_CAST(meth_wxVScrolledWindow_EnableVisibleFocus), METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_wxVScrolledWindow_EnableVisibleFocus)},
    {SIP_MLNAME_CAST(sipName_EstimateTotalHeight), meth_wxVScrolledWindow_EstimateTotalHeight, METH_VARARGS, SIP_NULLPTR},
    {SIP_MLNAME_CAST(sipName_EstimateTotalSize), meth_wxVScrolledWindow_EstimateTotalSize, METH_VARARGS, SIP_NULLPTR},
    {SIP_MLNAME_CAST(sipName_GetClassDefaultAttributes), SIP_MLMETH_CAST(meth_wxVScrolledWindow_GetClassDefaultAttributes), METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_wxVScrolledWindow_GetClassDefaultAttributes)},
    {SIP_MLNAME_CAST(sipName_GetClientAreaOrigin), meth_wxVScrolledWindow_GetClientAreaOrigin, METH_VARARGS, SIP_MLDOC_CAST(doc_wxVScrolledWindow_GetClientAreaOrigin)},
    {SIP_MLNAME_CAST(sipName_GetDefaultBorder), meth_wxVScrolledWindow_GetDefaultBorder, METH_VARARGS, SIP_MLDOC_CAST(doc_wxVScrolledWindow_GetDefaultBorder)},
    {SIP_MLNAME_CAST(sipName_GetDefaultBorderForControl), meth_wxVScrolledWindow_GetDefaultBorderForControl, METH_VARARGS, SIP_MLDOC_CAST(doc_wxVScrolledWindow_GetDefaultBorderForControl)},
    {SIP_MLNAME_CAST(sipName_GetFirstVisibleLine), meth_wxVScrolledWindow_GetFirstVisibleLine, METH_VARARGS, SIP_MLDOC_CAST(doc_wxVScrolledWindow_GetFirstVisibleLine)},
    {SIP_MLNAME_CAST(sipName_GetLastVisibleLine), meth_wxVScrolledWindow_GetLastVisibleLine, METH_VARARGS, SIP_MLDOC_CAST(doc_wxVScrolledWindow_GetLastVisibleLine)},
    {SIP_MLNAME_CAST(sipName_GetLineCount), meth_wxVScrolledWindow_GetLineCount, METH_VARARGS, SIP_MLDOC_CAST(doc_wxVScrolledWindow_GetLineCount)},
    {SIP_MLNAME_CAST(sipName_GetMainWindowOfCompositeControl), meth_wxVScrolledWindow_GetMainWindowOfCompositeControl, METH_VARARGS, SIP_MLDOC_CAST(doc_wxVScrolledWindow_GetMainWindowOfCompositeControl)},
    {SIP_MLNAME_CAST(sipName_GetNonOrientationTargetSize), meth_wxVScrolledWindow_GetNonOrientationTargetSize, METH_VARARGS, SIP_NULLPTR},
    {SIP_MLNAME_CAST(sipName_GetOrientation), meth_wxVScrolledWindow_GetOrientation, METH_VARARGS, SIP_NULLPTR},
    {SIP_MLNAME_CAST(sipName_GetOrientationTargetSize), meth_wxVScrolledWindow_GetOrientationTargetSize, METH_VARARGS, SIP_NULLPTR},
    {SIP_MLNAME_CAST(sipName_GetValidator), meth_wxVScrolledWindow_GetValidator, METH_VARARGS, SIP_MLDOC_CAST(doc_wxVScrolledWindow_GetValidator)},
    {SIP_MLNAME_CAST(sipName_HasTransparentBackground), meth_wxVScrolledWindow_HasTransparentBackground, METH_VARARGS, SIP_MLDOC_CAST(doc_wxVScrolledWindow_HasTransparentBackground)},
    {SIP_MLNAME_CAST(sipName_InformFirstDirection), SIP_MLMETH_CAST(meth_wxVScrolledWindow_InformFirstDirection), METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_wxVScrolledWindow_InformFirstDirection)},
    {SIP_MLNAME_CAST(sipName_InheritAttributes), meth_wxVScrolledWindow_InheritAttributes, METH_VARARGS, SIP_MLDOC_CAST(doc_wxVScrolledWindow_InheritAttributes)},
    {SIP_MLNAME_CAST(sipName_InitDialog), meth_wxVScrolledWindow_InitDialog, METH_VARARGS, SIP_MLDOC_CAST(doc_wxVScrolledWindow_InitDialog)},
    {SIP_MLNAME_CAST(sipName_OnGetRowHeight), SIP_MLMETH_CAST(meth_wxVScrolledWindow_OnGetRowHeight), METH_VARARGS|METH_KEYWORDS, SIP_NULLPTR},
    {SIP_MLNAME_CAST(sipName_OnGetRowsHeightHint), SIP_MLMETH_CAST(meth_wxVScrolledWindow_OnGetRowsHeightHint), METH_VARARGS|METH_KEYWORDS, SIP_NULLPTR},
    {SIP_MLNAME_CAST(sipName_OnGetUnitSize), SIP_MLMETH_CAST(meth_wxVScrolledWindow_OnGetUnitSize), METH_VARARGS|METH_KEYWORDS, SIP_NULLPTR},
    {SIP_MLNAME_CAST(sipName_OnGetUnitsSizeHint), SIP_MLMETH_CAST(meth_wxVScrolledWindow_OnGetUnitsSizeHint), METH_VARARGS|METH_KEYWORDS, SIP_NULLPTR},
    {SIP_MLNAME_CAST(sipName_OnInternalIdle), meth_wxVScrolledWindow_OnInternalIdle, METH_VARARGS, SIP_MLDOC_CAST(doc_wxVScrolledWindow_OnInternalIdle)},
    {SIP_MLNAME_CAST(sipName_ProcessEvent), SIP_MLMETH_CAST(meth_wxVScrolledWindow_ProcessEvent), METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_wxVScrolledWindow_ProcessEvent)},
    {SIP_MLNAME_CAST(sipName_RefreshLine), SIP_MLMETH_CAST(meth_wxVScrolledWindow_RefreshLine), METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_wxVScrolledWindow_RefreshLine)},
    {SIP_MLNAME_CAST(sipName_RefreshLines), SIP_MLMETH_CAST(meth_wxVScrolledWindow_RefreshLines), METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_wxVScrolledWindow_RefreshLines)},
    {SIP_MLNAME_CAST(sipName_RemoveChild), SIP_MLMETH_CAST(meth_wxVScrolledWindow_RemoveChild), METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_wxVScrolledWindow_RemoveChild)},
    {SIP_MLNAME_CAST(sipName_ScrollLines), SIP_MLMETH_CAST(meth_wxVScrolledWindow_ScrollLines), METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_wxVScrolledWindow_ScrollLines)},
    {SIP_MLNAME_CAST(sipName_ScrollPages), SIP_MLMETH_CAST(meth_wxVScrolledWindow_ScrollPages), METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_wxVScrolledWindow_ScrollPages)},
    {SIP_MLNAME_CAST(sipName_ScrollToLine), SIP_MLMETH_CAST(meth_wxVScrolledWindow_ScrollToLine), METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_wxVScrolledWindow_ScrollToLine)},
    {SIP_MLNAME_CAST(sipName_SendDestroyEvent), meth_wxVScrolledWindow_SendDestroyEvent, METH_VARARGS, SIP_NULLPTR},
    {SIP_MLNAME_CAST(sipName_SetCanFocus), SIP_MLMETH_CAST(meth_wxVScrolledWindow_SetCanFocus), METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_wxVScrolledWindow_SetCanFocus)},
    {SIP_MLNAME_CAST(sipName_SetLineCount), SIP_MLMETH_CAST(meth_wxVScrolledWindow_SetLineCount), METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_wxVScrolledWindow_SetLineCount)},
    {SIP_MLNAME_CAST(sipName_SetValidator), SIP_MLMETH_CAST(meth_wxVScrolledWindow_SetValidator), METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_wxVScrolledWindow_SetValidator)},
    {SIP_MLNAME_CAST(sipName_ShouldInheritColours), meth_wxVScrolledWindow_ShouldInheritColours, METH_VARARGS, SIP_MLDOC_CAST(doc_wxVScrolledWindow_ShouldInheritColours)},
    {SIP_MLNAME_CAST(sipName_TransferDataFromWindow), meth_wxVScrolledWindow_TransferDataFromWindow, METH_VARARGS, SIP_MLDOC_CAST(doc_wxVScrolledWindow_TransferDataFromWindow)},
    {SIP_MLNAME_CAST(sipName_TransferDataToWindow), meth_wxVScrolledWindow_TransferDataToWindow, METH_VARARGS, SIP_MLDOC_CAST(doc_wxVScrolledWindow_TransferDataToWindow)},
    {SIP_MLNAME_CAST(sipName_TryAfter), SIP_MLMETH_CAST(meth_wxVScrolledWindow_TryAfter), METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_wxVScrolledWindow_TryAfter)},
    {SIP_MLNAME_CAST(sipName_TryBefore), SIP_MLMETH_CAST(meth_wxVScrolledWindow_TryBefore), METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_wxVScrolledWindow_TryBefore)},
    {SIP_MLNAME_CAST(sipName_Validate), meth_wxVScrolledWindow_Validate, METH_VARARGS, SIP_MLDOC_CAST(doc_wxVScrolledWindow_Validate)}
};

sipVariableDef variables_wxVScrolledWindow[] = {
    {PropertyVariable, sipName_LineCount, &methods_wxVScrolledWindow[29], &methods_wxVScrolledWindow[53], SIP_NULLPTR, SIP_NULLPTR},
    {PropertyVariable, sipName_LastVisibleLine, &methods_wxVScrolledWindow[28], SIP_NULLPTR, SIP_NULLPTR, SIP_NULLPTR},
    {PropertyVariable, sipName_FirstVisibleLine, &methods_wxVScrolledWindow[27], SIP_NULLPTR, SIP_NULLPTR, SIP_NULLPTR},
};

PyDoc_STRVAR(doc_wxVScrolledWindow, "VScrolledWindow()\n"
"VScrolledWindow(parent, id=ID_ANY, pos=DefaultPosition, size=DefaultSize, style=0, name=PanelNameStr)\n"
"\n"
"In the name of this class, \"V\" may stand for \"variable\" because it can\n"
"be used for scrolling rows of variable heights; \"virtual\", because it\n"
"is not necessary to know the heights of all rows in advance  only\n"
"those which are shown on the screen need to be measured; or even\n"
"\"vertical\", because this class only supports scrolling vertically.");


sipClassTypeDef sipTypeDef__core_wxVScrolledWindow = {
    {
        -1,
        SIP_NULLPTR,
        SIP_NULLPTR,
        SIP_TYPE_ABSTRACT|SIP_TYPE_SCC|SIP_TYPE_CLASS,
        sipNameNr_wxVScrolledWindow,
        {SIP_NULLPTR},
        SIP_NULLPTR
    },
    {
        sipNameNr_VScrolledWindow,
        {0, 0, 1},
        61, methods_wxVScrolledWindow,
        0, SIP_NULLPTR,
        3, variables_wxVScrolledWindow,
        {SIP_NULLPTR, SIP_NULLPTR, SIP_NULLPTR, SIP_NULLPTR, SIP_NULLPTR, SIP_NULLPTR, SIP_NULLPTR, SIP_NULLPTR, SIP_NULLPTR, SIP_NULLPTR},
    },
    doc_wxVScrolledWindow,
    -1,
    -1,
    supers_wxVScrolledWindow,
    SIP_NULLPTR,
    init_type_wxVScrolledWindow,
    SIP_NULLPTR,
    SIP_NULLPTR,
#if PY_MAJOR_VERSION >= 3
    SIP_NULLPTR,
    SIP_NULLPTR,
#else
    SIP_NULLPTR,
    SIP_NULLPTR,
    SIP_NULLPTR,
    SIP_NULLPTR,
#endif
    dealloc_wxVScrolledWindow,
    SIP_NULLPTR,
    SIP_NULLPTR,
    SIP_NULLPTR,
    release_wxVScrolledWindow,
    cast_wxVScrolledWindow,
    SIP_NULLPTR,
    SIP_NULLPTR,
    SIP_NULLPTR,
    SIP_NULLPTR,
    SIP_NULLPTR,
    SIP_NULLPTR
};
