/*
 * Interface wrapper code.
 *
 * Generated by SIP 4.19.16
 *
 *     Copyright: (c) 2018 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>
        #include <wx/position.h>


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

    /*
     * There is a public method for every protected method visible from
     * this class.
     */
     ::wxCoord sipProtectVirt_EstimateTotalWidth(bool) const;
    void sipProtectVirt_OnGetColumnsWidthHint(bool,size_t,size_t) const;
     ::wxCoord sipProtect_OnGetColumnWidth(size_t) const;
    void sipProtectVirt_OnGetRowsHeightHint(bool,size_t,size_t) const;
     ::wxCoord sipProtectVirt_EstimateTotalHeight(bool) const;
     ::wxCoord sipProtect_OnGetRowHeight(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 OnGetRowHeight(size_t) const SIP_OVERRIDE;
     ::wxCoord EstimateTotalHeight() const SIP_OVERRIDE;
    void OnGetRowsHeightHint(size_t,size_t) const SIP_OVERRIDE;
    bool ScrollRows(int) SIP_OVERRIDE;
    bool ScrollRowPages(int) SIP_OVERRIDE;
    void RefreshRows(size_t,size_t) SIP_OVERRIDE;
    void RefreshRow(size_t) SIP_OVERRIDE;
     ::wxCoord OnGetColumnWidth(size_t) const SIP_OVERRIDE;
    void OnGetColumnsWidthHint(size_t,size_t) const SIP_OVERRIDE;
     ::wxCoord EstimateTotalWidth() const SIP_OVERRIDE;
    bool ScrollColumns(int) SIP_OVERRIDE;
    bool ScrollColumnPages(int) SIP_OVERRIDE;
    void RefreshColumns(size_t,size_t) SIP_OVERRIDE;
    void RefreshColumn(size_t) SIP_OVERRIDE;
    void RefreshRowColumn(size_t,size_t) SIP_OVERRIDE;
    void RefreshRowColumn(const  ::wxPosition&) SIP_OVERRIDE;
    void RefreshRowsColumns(size_t,size_t,size_t,size_t) SIP_OVERRIDE;
    void RefreshRowsColumns(const  ::wxPosition&,const  ::wxPosition&) 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 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:
    sipwxHVScrolledWindow(const sipwxHVScrolledWindow &);
    sipwxHVScrolledWindow &operator = (const sipwxHVScrolledWindow &);

    char sipPyMethods[57];
};

sipwxHVScrolledWindow::sipwxHVScrolledWindow():  ::wxHVScrolledWindow(), sipPySelf(SIP_NULLPTR)
{
    memset(sipPyMethods, 0, sizeof (sipPyMethods));
}

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

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

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

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

    if (!sipMeth)
        return 0;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

 ::wxCoord sipwxHVScrolledWindow::OnGetColumnWidth(size_t column) const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,const_cast<char *>(&sipPyMethods[7]),sipPySelf,sipName_HVScrolledWindow,sipName_OnGetColumnWidth);

    if (!sipMeth)
        return 0;

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

    return sipVH__core_130(sipGILState, 0, sipPySelf, sipMeth, column);
}

void sipwxHVScrolledWindow::OnGetColumnsWidthHint(size_t columnMin,size_t columnMax) const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

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

    if (!sipMeth)
    {
         ::wxHVScrolledWindow::OnGetColumnsWidthHint(columnMin,columnMax);
        return;
    }

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

    sipVH__core_129(sipGILState, 0, sipPySelf, sipMeth, columnMin, columnMax);
}

 ::wxCoord sipwxHVScrolledWindow::EstimateTotalWidth() const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

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

    if (!sipMeth)
        return  ::wxHVScrolledWindow::EstimateTotalWidth();

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

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

bool sipwxHVScrolledWindow::ScrollColumns(int columns)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[10],sipPySelf,SIP_NULLPTR,sipName_ScrollColumns);

    if (!sipMeth)
        return  ::wxHVScrolledWindow::ScrollColumns(columns);

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

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

bool sipwxHVScrolledWindow::ScrollColumnPages(int pages)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[11],sipPySelf,SIP_NULLPTR,sipName_ScrollColumnPages);

    if (!sipMeth)
        return  ::wxHVScrolledWindow::ScrollColumnPages(pages);

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

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

void sipwxHVScrolledWindow::RefreshColumns(size_t from_,size_t to_)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

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

    if (!sipMeth)
    {
         ::wxHVScrolledWindow::RefreshColumns(from_,to_);
        return;
    }

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

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

void sipwxHVScrolledWindow::RefreshColumn(size_t column)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

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

    if (!sipMeth)
    {
         ::wxHVScrolledWindow::RefreshColumn(column);
        return;
    }

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

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

void sipwxHVScrolledWindow::RefreshRowColumn(size_t row,size_t column)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

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

    if (!sipMeth)
    {
         ::wxHVScrolledWindow::RefreshRowColumn(row,column);
        return;
    }

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

    sipVH__core_129(sipGILState, 0, sipPySelf, sipMeth, row, column);
}

void sipwxHVScrolledWindow::RefreshRowColumn(const  ::wxPosition& pos)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

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

    if (!sipMeth)
    {
         ::wxHVScrolledWindow::RefreshRowColumn(pos);
        return;
    }

    extern void sipVH__core_133(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const  ::wxPosition&);

    sipVH__core_133(sipGILState, 0, sipPySelf, sipMeth, pos);
}

void sipwxHVScrolledWindow::RefreshRowsColumns(size_t fromRow,size_t toRow,size_t fromColumn,size_t toColumn)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

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

    if (!sipMeth)
    {
         ::wxHVScrolledWindow::RefreshRowsColumns(fromRow,toRow,fromColumn,toColumn);
        return;
    }

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

    sipVH__core_134(sipGILState, 0, sipPySelf, sipMeth, fromRow, toRow, fromColumn, toColumn);
}

void sipwxHVScrolledWindow::RefreshRowsColumns(const  ::wxPosition& from,const  ::wxPosition& to)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[17],sipPySelf,SIP_NULLPTR,sipName_RefreshRowsColumns);

    if (!sipMeth)
    {
         ::wxHVScrolledWindow::RefreshRowsColumns(from,to);
        return;
    }

    extern void sipVH__core_135(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const  ::wxPosition&,const  ::wxPosition&);

    sipVH__core_135(sipGILState, 0, sipPySelf, sipMeth, from, to);
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

 ::wxCoord sipwxHVScrolledWindow::sipProtectVirt_EstimateTotalWidth(bool sipSelfWasArg) const
{
    return (sipSelfWasArg ?  ::wxVarHScrollHelper::EstimateTotalWidth() : EstimateTotalWidth());
}

void sipwxHVScrolledWindow::sipProtectVirt_OnGetColumnsWidthHint(bool sipSelfWasArg,size_t columnMin,size_t columnMax) const
{
    (sipSelfWasArg ?  ::wxVarHScrollHelper::OnGetColumnsWidthHint(columnMin,columnMax) : OnGetColumnsWidthHint(columnMin,columnMax));
}

 ::wxCoord sipwxHVScrolledWindow::sipProtect_OnGetColumnWidth(size_t column) const
{
    return OnGetColumnWidth(column);
}

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

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

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

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

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

void sipwxHVScrolledWindow::sipProtectVirt_DoEnable(bool sipSelfWasArg,bool enable)
{
    (sipSelfWasArg ?  ::wxHVScrolledWindow::DoEnable(enable) : DoEnable(enable));
}

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

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

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

 ::wxSize sipwxHVScrolledWindow::sipProtectVirt_DoGetBestSize(bool sipSelfWasArg) const
{
    return (sipSelfWasArg ?  ::wxHVScrolledWindow::DoGetBestSize() : DoGetBestSize());
}

 ::wxSize sipwxHVScrolledWindow::sipProtectVirt_DoGetBestClientSize(bool sipSelfWasArg) const
{
    return (sipSelfWasArg ?  ::wxHVScrolledWindow::DoGetBestClientSize() : DoGetBestClientSize());
}

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

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

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

 ::wxSize sipwxHVScrolledWindow::sipProtectVirt_DoGetBorderSize(bool sipSelfWasArg) const
{
    return (sipSelfWasArg ?  ::wxHVScrolledWindow::DoGetBorderSize() : DoGetBorderSize());
}

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

void sipwxHVScrolledWindow::sipProtectVirt_DoSetWindowVariant(bool sipSelfWasArg, ::wxWindowVariant variant)
{
    (sipSelfWasArg ?  ::wxHVScrolledWindow::DoSetWindowVariant(variant) : DoSetWindowVariant(variant));
}

 ::wxBorder sipwxHVScrolledWindow::sipProtectVirt_GetDefaultBorder(bool sipSelfWasArg) const
{
    return (sipSelfWasArg ?  ::wxHVScrolledWindow::GetDefaultBorder() : GetDefaultBorder());
}

 ::wxBorder sipwxHVScrolledWindow::sipProtectVirt_GetDefaultBorderForControl(bool sipSelfWasArg) const
{
    return (sipSelfWasArg ?  ::wxHVScrolledWindow::GetDefaultBorderForControl() : GetDefaultBorderForControl());
}

void sipwxHVScrolledWindow::sipProtectVirt_DoFreeze(bool sipSelfWasArg)
{
    (sipSelfWasArg ?  ::wxHVScrolledWindow::DoFreeze() : DoFreeze());
}

void sipwxHVScrolledWindow::sipProtectVirt_DoThaw(bool sipSelfWasArg)
{
    (sipSelfWasArg ?  ::wxHVScrolledWindow::DoThaw() : DoThaw());
}

bool sipwxHVScrolledWindow::sipProtectVirt_HasTransparentBackground(bool sipSelfWasArg)
{
    return (sipSelfWasArg ?  ::wxHVScrolledWindow::HasTransparentBackground() : HasTransparentBackground());
}

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

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


PyDoc_STRVAR(doc_wxHVScrolledWindow_EstimateTotalWidth, "EstimateTotalWidth() -> 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_wxHVScrolledWindow_EstimateTotalWidth(PyObject *, PyObject *);}
static PyObject *meth_wxHVScrolledWindow_EstimateTotalWidth(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = SIP_NULLPTR;
    bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));

    {
        const sipwxHVScrolledWindow *sipCpp;

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

            PyErr_Clear();

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

            if (PyErr_Occurred())
                return 0;

            return SIPLong_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_HVScrolledWindow, sipName_EstimateTotalWidth, SIP_NULLPTR);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_wxHVScrolledWindow_OnGetColumnsWidthHint, "OnGetColumnsWidthHint(columnMin, columnMax)\n"
"\n"
"This function doesn't have to be overridden but it may be useful to do\n"
"so if calculating the columns' sizes is a relatively expensive\n"
"operation as it gives your code a chance to calculate several of them\n"
"at once and cache the result if necessary.");

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

    {
        size_t columnMin;
        size_t columnMax;
        const sipwxHVScrolledWindow *sipCpp;

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

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, SIP_NULLPTR, "B==", &sipSelf, sipType_wxHVScrolledWindow, &sipCpp, &columnMin, &columnMax))
        {
            PyErr_Clear();

            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtectVirt_OnGetColumnsWidthHint(sipSelfWasArg,columnMin,columnMax);
            Py_END_ALLOW_THREADS

            if (PyErr_Occurred())
                return 0;

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_HVScrolledWindow, sipName_OnGetColumnsWidthHint, SIP_NULLPTR);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_wxHVScrolledWindow_OnGetColumnWidth, "OnGetColumnWidth(column) -> Coord\n"
"\n"
"This function must be overridden in the derived class, and should\n"
"return the width of the given column in pixels.");

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

    {
        size_t column;
        const sipwxHVScrolledWindow *sipCpp;

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

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

            if (!sipOrigSelf)
            {
                sipAbstractMethod(sipName_HVScrolledWindow, sipName_OnGetColumnWidth);
                return SIP_NULLPTR;
            }

            PyErr_Clear();

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->sipProtect_OnGetColumnWidth(column);
            Py_END_ALLOW_THREADS

            if (PyErr_Occurred())
                return 0;

            return SIPLong_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_HVScrolledWindow, sipName_OnGetColumnWidth, SIP_NULLPTR);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_wxHVScrolledWindow_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_wxHVScrolledWindow_OnGetRowsHeightHint(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_wxHVScrolledWindow_OnGetRowsHeightHint(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = SIP_NULLPTR;
    bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));

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

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

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

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_HVScrolledWindow, sipName_OnGetRowsHeightHint, SIP_NULLPTR);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_wxHVScrolledWindow_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_wxHVScrolledWindow_EstimateTotalHeight(PyObject *, PyObject *);}
static PyObject *meth_wxHVScrolledWindow_EstimateTotalHeight(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = SIP_NULLPTR;
    bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));

    {
        const sipwxHVScrolledWindow *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_wxHVScrolledWindow, &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);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_HVScrolledWindow, sipName_EstimateTotalHeight, SIP_NULLPTR);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_wxHVScrolledWindow_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_wxHVScrolledWindow_OnGetRowHeight(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_wxHVScrolledWindow_OnGetRowHeight(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = SIP_NULLPTR;
    PyObject *sipOrigSelf = sipSelf;

    {
        size_t row;
        const sipwxHVScrolledWindow *sipCpp;

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

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

            if (!sipOrigSelf)
            {
                sipAbstractMethod(sipName_HVScrolledWindow, 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);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_HVScrolledWindow, sipName_OnGetRowHeight, SIP_NULLPTR);

    return SIP_NULLPTR;
}


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

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

    {
        sipwxHVScrolledWindow *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_wxHVScrolledWindow, &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;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_HVScrolledWindow, sipName_SendDestroyEvent, SIP_NULLPTR);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_wxHVScrolledWindow_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_wxHVScrolledWindow_Create(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_wxHVScrolledWindow_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;
         ::wxHVScrolledWindow *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_wxHVScrolledWindow, &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);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_HVScrolledWindow, sipName_Create, SIP_NULLPTR);

    return SIP_NULLPTR;
}


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

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

    {
        const  ::wxHVScrolledWindow *sipCpp;

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

            PyErr_Clear();

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

            if (PyErr_Occurred())
                return 0;

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

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_HVScrolledWindow, sipName_GetClientAreaOrigin, doc_wxHVScrolledWindow_GetClientAreaOrigin);

    return SIP_NULLPTR;
}


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

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

    {
         ::wxHVScrolledWindow *sipCpp;

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

            PyErr_Clear();

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

            if (PyErr_Occurred())
                return 0;

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_HVScrolledWindow, sipName_Validate, doc_wxHVScrolledWindow_Validate);

    return SIP_NULLPTR;
}


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

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

    {
         ::wxHVScrolledWindow *sipCpp;

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

            PyErr_Clear();

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

            if (PyErr_Occurred())
                return 0;

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_HVScrolledWindow, sipName_TransferDataToWindow, doc_wxHVScrolledWindow_TransferDataToWindow);

    return SIP_NULLPTR;
}


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

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

    {
         ::wxHVScrolledWindow *sipCpp;

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

            PyErr_Clear();

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

            if (PyErr_Occurred())
                return 0;

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_HVScrolledWindow, sipName_TransferDataFromWindow, doc_wxHVScrolledWindow_TransferDataFromWindow);

    return SIP_NULLPTR;
}


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

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

    {
         ::wxHVScrolledWindow *sipCpp;

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

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

            if (PyErr_Occurred())
                return 0;

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_HVScrolledWindow, sipName_InitDialog, doc_wxHVScrolledWindow_InitDialog);

    return SIP_NULLPTR;
}


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

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

    {
        const  ::wxHVScrolledWindow *sipCpp;

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

            PyErr_Clear();

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

            if (PyErr_Occurred())
                return 0;

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_HVScrolledWindow, sipName_AcceptsFocus, doc_wxHVScrolledWindow_AcceptsFocus);

    return SIP_NULLPTR;
}


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

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

    {
        const  ::wxHVScrolledWindow *sipCpp;

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

            PyErr_Clear();

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

            if (PyErr_Occurred())
                return 0;

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_HVScrolledWindow, sipName_AcceptsFocusRecursively, doc_wxHVScrolledWindow_AcceptsFocusRecursively);

    return SIP_NULLPTR;
}


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

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

    {
        const  ::wxHVScrolledWindow *sipCpp;

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

            PyErr_Clear();

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

            if (PyErr_Occurred())
                return 0;

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_HVScrolledWindow, sipName_AcceptsFocusFromKeyboard, doc_wxHVScrolledWindow_AcceptsFocusFromKeyboard);

    return SIP_NULLPTR;
}


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

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

    {
         ::wxWindowBase* child;
         ::wxHVScrolledWindow *sipCpp;

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

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

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

            if (PyErr_Occurred())
                return 0;

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_HVScrolledWindow, sipName_AddChild, doc_wxHVScrolledWindow_AddChild);

    return SIP_NULLPTR;
}


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

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

    {
         ::wxWindowBase* child;
         ::wxHVScrolledWindow *sipCpp;

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

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

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

            if (PyErr_Occurred())
                return 0;

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_HVScrolledWindow, sipName_RemoveChild, doc_wxHVScrolledWindow_RemoveChild);

    return SIP_NULLPTR;
}


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

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

    {
         ::wxHVScrolledWindow *sipCpp;

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

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

            if (PyErr_Occurred())
                return 0;

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_HVScrolledWindow, sipName_InheritAttributes, doc_wxHVScrolledWindow_InheritAttributes);

    return SIP_NULLPTR;
}


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

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

    {
        const  ::wxHVScrolledWindow *sipCpp;

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

            PyErr_Clear();

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

            if (PyErr_Occurred())
                return 0;

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_HVScrolledWindow, sipName_ShouldInheritColours, doc_wxHVScrolledWindow_ShouldInheritColours);

    return SIP_NULLPTR;
}


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

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

    {
         ::wxHVScrolledWindow *sipCpp;

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

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

            if (PyErr_Occurred())
                return 0;

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_HVScrolledWindow, sipName_OnInternalIdle, doc_wxHVScrolledWindow_OnInternalIdle);

    return SIP_NULLPTR;
}


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

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

    {
         ::wxHVScrolledWindow *sipCpp;

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

            PyErr_Clear();

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

            if (PyErr_Occurred())
                return 0;

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

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_HVScrolledWindow, sipName_GetMainWindowOfCompositeControl, doc_wxHVScrolledWindow_GetMainWindowOfCompositeControl);

    return SIP_NULLPTR;
}


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

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

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

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

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

            PyErr_Clear();

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

            if (PyErr_Occurred())
                return 0;

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_HVScrolledWindow, sipName_InformFirstDirection, doc_wxHVScrolledWindow_InformFirstDirection);

    return SIP_NULLPTR;
}


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

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

    {
        bool canFocus;
         ::wxHVScrolledWindow *sipCpp;

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

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

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

            if (PyErr_Occurred())
                return 0;

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_HVScrolledWindow, sipName_SetCanFocus, doc_wxHVScrolledWindow_SetCanFocus);

    return SIP_NULLPTR;
}


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

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

    {
         ::wxHVScrolledWindow *sipCpp;

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

            PyErr_Clear();

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

            if (PyErr_Occurred())
                return 0;

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_HVScrolledWindow, sipName_Destroy, doc_wxHVScrolledWindow_Destroy);

    return SIP_NULLPTR;
}


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

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

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

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

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

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

            if (PyErr_Occurred())
                return 0;

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_HVScrolledWindow, sipName_SetValidator, doc_wxHVScrolledWindow_SetValidator);

    return SIP_NULLPTR;
}


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

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

    {
         ::wxHVScrolledWindow *sipCpp;

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

            PyErr_Clear();

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

            if (PyErr_Occurred())
                return 0;

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

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_HVScrolledWindow, sipName_GetValidator, doc_wxHVScrolledWindow_GetValidator);

    return SIP_NULLPTR;
}


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

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

    {
         ::wxEvent* event;
        sipwxHVScrolledWindow *sipCpp;

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

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, SIP_NULLPTR, "BJ9", &sipSelf, sipType_wxHVScrolledWindow, &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);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_HVScrolledWindow, sipName_ProcessEvent, doc_wxHVScrolledWindow_ProcessEvent);

    return SIP_NULLPTR;
}


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

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

    {
        bool enable;
        sipwxHVScrolledWindow *sipCpp;

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

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, SIP_NULLPTR, "Bb", &sipSelf, sipType_wxHVScrolledWindow, &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;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_HVScrolledWindow, sipName_DoEnable, doc_wxHVScrolledWindow_DoEnable);

    return SIP_NULLPTR;
}


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

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

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

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, SIP_NULLPTR, SIP_NULLPTR, "B", &sipSelf, sipType_wxHVScrolledWindow, &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);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_HVScrolledWindow, sipName_DoGetPosition, doc_wxHVScrolledWindow_DoGetPosition);

    return SIP_NULLPTR;
}


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

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

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

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, SIP_NULLPTR, SIP_NULLPTR, "B", &sipSelf, sipType_wxHVScrolledWindow, &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);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_HVScrolledWindow, sipName_DoGetSize, doc_wxHVScrolledWindow_DoGetSize);

    return SIP_NULLPTR;
}


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

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

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

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, SIP_NULLPTR, SIP_NULLPTR, "B", &sipSelf, sipType_wxHVScrolledWindow, &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);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_HVScrolledWindow, sipName_DoGetClientSize, doc_wxHVScrolledWindow_DoGetClientSize);

    return SIP_NULLPTR;
}


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

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

    {
        const sipwxHVScrolledWindow *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_wxHVScrolledWindow, &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);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_HVScrolledWindow, sipName_DoGetBestSize, doc_wxHVScrolledWindow_DoGetBestSize);

    return SIP_NULLPTR;
}


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

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

    {
        const sipwxHVScrolledWindow *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_wxHVScrolledWindow, &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);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_HVScrolledWindow, sipName_DoGetBestClientSize, doc_wxHVScrolledWindow_DoGetBestClientSize);

    return SIP_NULLPTR;
}


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

extern "C" {static PyObject *meth_wxHVScrolledWindow_DoSetSize(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_wxHVScrolledWindow_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;
        sipwxHVScrolledWindow *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_wxHVScrolledWindow, &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;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_HVScrolledWindow, sipName_DoSetSize, doc_wxHVScrolledWindow_DoSetSize);

    return SIP_NULLPTR;
}


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

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

    {
        int width;
        int height;
        sipwxHVScrolledWindow *sipCpp;

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

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, SIP_NULLPTR, "Bii", &sipSelf, sipType_wxHVScrolledWindow, &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;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_HVScrolledWindow, sipName_DoSetClientSize, doc_wxHVScrolledWindow_DoSetClientSize);

    return SIP_NULLPTR;
}


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

extern "C" {static PyObject *meth_wxHVScrolledWindow_DoSetSizeHints(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_wxHVScrolledWindow_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;
        sipwxHVScrolledWindow *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_wxHVScrolledWindow, &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;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_HVScrolledWindow, sipName_DoSetSizeHints, doc_wxHVScrolledWindow_DoSetSizeHints);

    return SIP_NULLPTR;
}


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

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

    {
        const sipwxHVScrolledWindow *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_wxHVScrolledWindow, &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);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_HVScrolledWindow, sipName_DoGetBorderSize, doc_wxHVScrolledWindow_DoGetBorderSize);

    return SIP_NULLPTR;
}


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

extern "C" {static PyObject *meth_wxHVScrolledWindow_DoMoveWindow(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_wxHVScrolledWindow_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;
        sipwxHVScrolledWindow *sipCpp;

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

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, SIP_NULLPTR, "Biiii", &sipSelf, sipType_wxHVScrolledWindow, &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;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_HVScrolledWindow, sipName_DoMoveWindow, doc_wxHVScrolledWindow_DoMoveWindow);

    return SIP_NULLPTR;
}


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

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

    {
         ::wxWindowVariant variant;
        sipwxHVScrolledWindow *sipCpp;

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

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, SIP_NULLPTR, "BE", &sipSelf, sipType_wxHVScrolledWindow, &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;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_HVScrolledWindow, sipName_DoSetWindowVariant, doc_wxHVScrolledWindow_DoSetWindowVariant);

    return SIP_NULLPTR;
}


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

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

    {
        const sipwxHVScrolledWindow *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_wxHVScrolledWindow, &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);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_HVScrolledWindow, sipName_GetDefaultBorder, doc_wxHVScrolledWindow_GetDefaultBorder);

    return SIP_NULLPTR;
}


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

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

    {
        const sipwxHVScrolledWindow *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_wxHVScrolledWindow, &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);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_HVScrolledWindow, sipName_GetDefaultBorderForControl, doc_wxHVScrolledWindow_GetDefaultBorderForControl);

    return SIP_NULLPTR;
}


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

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

    {
        sipwxHVScrolledWindow *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_wxHVScrolledWindow, &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;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_HVScrolledWindow, sipName_DoFreeze, doc_wxHVScrolledWindow_DoFreeze);

    return SIP_NULLPTR;
}


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

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

    {
        sipwxHVScrolledWindow *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_wxHVScrolledWindow, &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;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_HVScrolledWindow, sipName_DoThaw, doc_wxHVScrolledWindow_DoThaw);

    return SIP_NULLPTR;
}


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

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

    {
        sipwxHVScrolledWindow *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_wxHVScrolledWindow, &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);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_HVScrolledWindow, sipName_HasTransparentBackground, doc_wxHVScrolledWindow_HasTransparentBackground);

    return SIP_NULLPTR;
}


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

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

    {
         ::wxEvent* event;
        sipwxHVScrolledWindow *sipCpp;

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

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, SIP_NULLPTR, "BJ9", &sipSelf, sipType_wxHVScrolledWindow, &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);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_HVScrolledWindow, sipName_TryBefore, doc_wxHVScrolledWindow_TryBefore);

    return SIP_NULLPTR;
}


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

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

    {
         ::wxEvent* event;
        sipwxHVScrolledWindow *sipCpp;

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

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, SIP_NULLPTR, "BJ9", &sipSelf, sipType_wxHVScrolledWindow, &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);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_HVScrolledWindow, sipName_TryAfter, doc_wxHVScrolledWindow_TryAfter);

    return SIP_NULLPTR;
}


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

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

            if (PyErr_Occurred())
                return 0;

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

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_HVScrolledWindow, sipName_GetClassDefaultAttributes, SIP_NULLPTR);

    return SIP_NULLPTR;
}


/* Cast a pointer to a type somewhere in its inheritance hierarchy. */
extern "C" {static void *cast_wxHVScrolledWindow(void *, const sipTypeDef *);}
static void *cast_wxHVScrolledWindow(void *sipCppV, const sipTypeDef *targetType)
{
     ::wxHVScrolledWindow *sipCpp = reinterpret_cast< ::wxHVScrolledWindow *>(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_wxVarHVScrollHelper)
        return static_cast< ::wxVarHVScrollHelper *>(sipCpp);

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

    if (targetType == sipType_wxVarHScrollHelper)
        return static_cast< ::wxVarHScrollHelper *>(sipCpp);

    return sipCppV;
}


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

    if (sipState & SIP_DERIVED_CLASS)
        delete reinterpret_cast<sipwxHVScrolledWindow *>(sipCppV);
    else
        delete reinterpret_cast< ::wxHVScrolledWindow *>(sipCppV);

    Py_END_ALLOW_THREADS
}


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

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


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

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

        if (!wxPyCheckForApp()) return NULL;

            PyErr_Clear();

            Py_BEGIN_ALLOW_THREADS
            sipCpp = new sipwxHVScrolledWindow();
            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 sipwxHVScrolledWindow(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_wxHVScrolledWindow[] = {{373, 255, 0}, {562, 255, 1}};


static PyMethodDef methods_wxHVScrolledWindow[] = {
    {SIP_MLNAME_CAST(sipName_AcceptsFocus), meth_wxHVScrolledWindow_AcceptsFocus, METH_VARARGS, SIP_MLDOC_CAST(doc_wxHVScrolledWindow_AcceptsFocus)},
    {SIP_MLNAME_CAST(sipName_AcceptsFocusFromKeyboard), meth_wxHVScrolledWindow_AcceptsFocusFromKeyboard, METH_VARARGS, SIP_MLDOC_CAST(doc_wxHVScrolledWindow_AcceptsFocusFromKeyboard)},
    {SIP_MLNAME_CAST(sipName_AcceptsFocusRecursively), meth_wxHVScrolledWindow_AcceptsFocusRecursively, METH_VARARGS, SIP_MLDOC_CAST(doc_wxHVScrolledWindow_AcceptsFocusRecursively)},
    {SIP_MLNAME_CAST(sipName_AddChild), SIP_MLMETH_CAST(meth_wxHVScrolledWindow_AddChild), METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_wxHVScrolledWindow_AddChild)},
    {SIP_MLNAME_CAST(sipName_Create), SIP_MLMETH_CAST(meth_wxHVScrolledWindow_Create), METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_wxHVScrolledWindow_Create)},
    {SIP_MLNAME_CAST(sipName_Destroy), meth_wxHVScrolledWindow_Destroy, METH_VARARGS, SIP_MLDOC_CAST(doc_wxHVScrolledWindow_Destroy)},
    {SIP_MLNAME_CAST(sipName_DoEnable), SIP_MLMETH_CAST(meth_wxHVScrolledWindow_DoEnable), METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_wxHVScrolledWindow_DoEnable)},
    {SIP_MLNAME_CAST(sipName_DoFreeze), meth_wxHVScrolledWindow_DoFreeze, METH_VARARGS, SIP_MLDOC_CAST(doc_wxHVScrolledWindow_DoFreeze)},
    {SIP_MLNAME_CAST(sipName_DoGetBestClientSize), meth_wxHVScrolledWindow_DoGetBestClientSize, METH_VARARGS, SIP_MLDOC_CAST(doc_wxHVScrolledWindow_DoGetBestClientSize)},
    {SIP_MLNAME_CAST(sipName_DoGetBestSize), meth_wxHVScrolledWindow_DoGetBestSize, METH_VARARGS, SIP_MLDOC_CAST(doc_wxHVScrolledWindow_DoGetBestSize)},
    {SIP_MLNAME_CAST(sipName_DoGetBorderSize), meth_wxHVScrolledWindow_DoGetBorderSize, METH_VARARGS, SIP_MLDOC_CAST(doc_wxHVScrolledWindow_DoGetBorderSize)},
    {SIP_MLNAME_CAST(sipName_DoGetClientSize), SIP_MLMETH_CAST(meth_wxHVScrolledWindow_DoGetClientSize), METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_wxHVScrolledWindow_DoGetClientSize)},
    {SIP_MLNAME_CAST(sipName_DoGetPosition), SIP_MLMETH_CAST(meth_wxHVScrolledWindow_DoGetPosition), METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_wxHVScrolledWindow_DoGetPosition)},
    {SIP_MLNAME_CAST(sipName_DoGetSize), SIP_MLMETH_CAST(meth_wxHVScrolledWindow_DoGetSize), METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_wxHVScrolledWindow_DoGetSize)},
    {SIP_MLNAME_CAST(sipName_DoMoveWindow), SIP_MLMETH_CAST(meth_wxHVScrolledWindow_DoMoveWindow), METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_wxHVScrolledWindow_DoMoveWindow)},
    {SIP_MLNAME_CAST(sipName_DoSetClientSize), SIP_MLMETH_CAST(meth_wxHVScrolledWindow_DoSetClientSize), METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_wxHVScrolledWindow_DoSetClientSize)},
    {SIP_MLNAME_CAST(sipName_DoSetSize), SIP_MLMETH_CAST(meth_wxHVScrolledWindow_DoSetSize), METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_wxHVScrolledWindow_DoSetSize)},
    {SIP_MLNAME_CAST(sipName_DoSetSizeHints), SIP_MLMETH_CAST(meth_wxHVScrolledWindow_DoSetSizeHints), METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_wxHVScrolledWindow_DoSetSizeHints)},
    {SIP_MLNAME_CAST(sipName_DoSetWindowVariant), SIP_MLMETH_CAST(meth_wxHVScrolledWindow_DoSetWindowVariant), METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_wxHVScrolledWindow_DoSetWindowVariant)},
    {SIP_MLNAME_CAST(sipName_DoThaw), meth_wxHVScrolledWindow_DoThaw, METH_VARARGS, SIP_MLDOC_CAST(doc_wxHVScrolledWindow_DoThaw)},
    {SIP_MLNAME_CAST(sipName_EstimateTotalHeight), meth_wxHVScrolledWindow_EstimateTotalHeight, METH_VARARGS, SIP_NULLPTR},
    {SIP_MLNAME_CAST(sipName_EstimateTotalWidth), meth_wxHVScrolledWindow_EstimateTotalWidth, METH_VARARGS, SIP_NULLPTR},
    {SIP_MLNAME_CAST(sipName_GetClassDefaultAttributes), SIP_MLMETH_CAST(meth_wxHVScrolledWindow_GetClassDefaultAttributes), METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_wxHVScrolledWindow_GetClassDefaultAttributes)},
    {SIP_MLNAME_CAST(sipName_GetClientAreaOrigin), meth_wxHVScrolledWindow_GetClientAreaOrigin, METH_VARARGS, SIP_MLDOC_CAST(doc_wxHVScrolledWindow_GetClientAreaOrigin)},
    {SIP_MLNAME_CAST(sipName_GetDefaultBorder), meth_wxHVScrolledWindow_GetDefaultBorder, METH_VARARGS, SIP_MLDOC_CAST(doc_wxHVScrolledWindow_GetDefaultBorder)},
    {SIP_MLNAME_CAST(sipName_GetDefaultBorderForControl), meth_wxHVScrolledWindow_GetDefaultBorderForControl, METH_VARARGS, SIP_MLDOC_CAST(doc_wxHVScrolledWindow_GetDefaultBorderForControl)},
    {SIP_MLNAME_CAST(sipName_GetMainWindowOfCompositeControl), meth_wxHVScrolledWindow_GetMainWindowOfCompositeControl, METH_VARARGS, SIP_MLDOC_CAST(doc_wxHVScrolledWindow_GetMainWindowOfCompositeControl)},
    {SIP_MLNAME_CAST(sipName_GetValidator), meth_wxHVScrolledWindow_GetValidator, METH_VARARGS, SIP_MLDOC_CAST(doc_wxHVScrolledWindow_GetValidator)},
    {SIP_MLNAME_CAST(sipName_HasTransparentBackground), meth_wxHVScrolledWindow_HasTransparentBackground, METH_VARARGS, SIP_MLDOC_CAST(doc_wxHVScrolledWindow_HasTransparentBackground)},
    {SIP_MLNAME_CAST(sipName_InformFirstDirection), SIP_MLMETH_CAST(meth_wxHVScrolledWindow_InformFirstDirection), METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_wxHVScrolledWindow_InformFirstDirection)},
    {SIP_MLNAME_CAST(sipName_InheritAttributes), meth_wxHVScrolledWindow_InheritAttributes, METH_VARARGS, SIP_MLDOC_CAST(doc_wxHVScrolledWindow_InheritAttributes)},
    {SIP_MLNAME_CAST(sipName_InitDialog), meth_wxHVScrolledWindow_InitDialog, METH_VARARGS, SIP_MLDOC_CAST(doc_wxHVScrolledWindow_InitDialog)},
    {SIP_MLNAME_CAST(sipName_OnGetColumnWidth), SIP_MLMETH_CAST(meth_wxHVScrolledWindow_OnGetColumnWidth), METH_VARARGS|METH_KEYWORDS, SIP_NULLPTR},
    {SIP_MLNAME_CAST(sipName_OnGetColumnsWidthHint), SIP_MLMETH_CAST(meth_wxHVScrolledWindow_OnGetColumnsWidthHint), METH_VARARGS|METH_KEYWORDS, SIP_NULLPTR},
    {SIP_MLNAME_CAST(sipName_OnGetRowHeight), SIP_MLMETH_CAST(meth_wxHVScrolledWindow_OnGetRowHeight), METH_VARARGS|METH_KEYWORDS, SIP_NULLPTR},
    {SIP_MLNAME_CAST(sipName_OnGetRowsHeightHint), SIP_MLMETH_CAST(meth_wxHVScrolledWindow_OnGetRowsHeightHint), METH_VARARGS|METH_KEYWORDS, SIP_NULLPTR},
    {SIP_MLNAME_CAST(sipName_OnInternalIdle), meth_wxHVScrolledWindow_OnInternalIdle, METH_VARARGS, SIP_MLDOC_CAST(doc_wxHVScrolledWindow_OnInternalIdle)},
    {SIP_MLNAME_CAST(sipName_ProcessEvent), SIP_MLMETH_CAST(meth_wxHVScrolledWindow_ProcessEvent), METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_wxHVScrolledWindow_ProcessEvent)},
    {SIP_MLNAME_CAST(sipName_RemoveChild), SIP_MLMETH_CAST(meth_wxHVScrolledWindow_RemoveChild), METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_wxHVScrolledWindow_RemoveChild)},
    {SIP_MLNAME_CAST(sipName_SendDestroyEvent), meth_wxHVScrolledWindow_SendDestroyEvent, METH_VARARGS, SIP_NULLPTR},
    {SIP_MLNAME_CAST(sipName_SetCanFocus), SIP_MLMETH_CAST(meth_wxHVScrolledWindow_SetCanFocus), METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_wxHVScrolledWindow_SetCanFocus)},
    {SIP_MLNAME_CAST(sipName_SetValidator), SIP_MLMETH_CAST(meth_wxHVScrolledWindow_SetValidator), METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_wxHVScrolledWindow_SetValidator)},
    {SIP_MLNAME_CAST(sipName_ShouldInheritColours), meth_wxHVScrolledWindow_ShouldInheritColours, METH_VARARGS, SIP_MLDOC_CAST(doc_wxHVScrolledWindow_ShouldInheritColours)},
    {SIP_MLNAME_CAST(sipName_TransferDataFromWindow), meth_wxHVScrolledWindow_TransferDataFromWindow, METH_VARARGS, SIP_MLDOC_CAST(doc_wxHVScrolledWindow_TransferDataFromWindow)},
    {SIP_MLNAME_CAST(sipName_TransferDataToWindow), meth_wxHVScrolledWindow_TransferDataToWindow, METH_VARARGS, SIP_MLDOC_CAST(doc_wxHVScrolledWindow_TransferDataToWindow)},
    {SIP_MLNAME_CAST(sipName_TryAfter), SIP_MLMETH_CAST(meth_wxHVScrolledWindow_TryAfter), METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_wxHVScrolledWindow_TryAfter)},
    {SIP_MLNAME_CAST(sipName_TryBefore), SIP_MLMETH_CAST(meth_wxHVScrolledWindow_TryBefore), METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_wxHVScrolledWindow_TryBefore)},
    {SIP_MLNAME_CAST(sipName_Validate), meth_wxHVScrolledWindow_Validate, METH_VARARGS, SIP_MLDOC_CAST(doc_wxHVScrolledWindow_Validate)}
};

PyDoc_STRVAR(doc_wxHVScrolledWindow, "HVScrolledWindow()\n"
"HVScrolledWindow(parent, id=ID_ANY, pos=DefaultPosition, size=DefaultSize, style=0, name=PanelNameStr)\n"
"\n"
"This window inherits all functionality of both vertical and\n"
"horizontal, variable scrolled windows.");


sipClassTypeDef sipTypeDef__core_wxHVScrolledWindow = {
    {
        -1,
        SIP_NULLPTR,
        SIP_NULLPTR,
        SIP_TYPE_ABSTRACT|SIP_TYPE_SCC|SIP_TYPE_CLASS,
        sipNameNr_wxHVScrolledWindow,
        {SIP_NULLPTR},
        SIP_NULLPTR
    },
    {
        sipNameNr_HVScrolledWindow,
        {0, 0, 1},
        48, methods_wxHVScrolledWindow,
        0, SIP_NULLPTR,
        0, SIP_NULLPTR,
        {SIP_NULLPTR, SIP_NULLPTR, SIP_NULLPTR, SIP_NULLPTR, SIP_NULLPTR, SIP_NULLPTR, SIP_NULLPTR, SIP_NULLPTR, SIP_NULLPTR, SIP_NULLPTR},
    },
    doc_wxHVScrolledWindow,
    -1,
    -1,
    supers_wxHVScrolledWindow,
    SIP_NULLPTR,
    init_type_wxHVScrolledWindow,
    SIP_NULLPTR,
    SIP_NULLPTR,
#if PY_MAJOR_VERSION >= 3
    SIP_NULLPTR,
    SIP_NULLPTR,
#else
    SIP_NULLPTR,
    SIP_NULLPTR,
    SIP_NULLPTR,
    SIP_NULLPTR,
#endif
    dealloc_wxHVScrolledWindow,
    SIP_NULLPTR,
    SIP_NULLPTR,
    SIP_NULLPTR,
    release_wxHVScrolledWindow,
    cast_wxHVScrolledWindow,
    SIP_NULLPTR,
    SIP_NULLPTR,
    SIP_NULLPTR,
    SIP_NULLPTR,
    SIP_NULLPTR,
    SIP_NULLPTR
};
