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

#include "sipAPI_xrc.h"

        #include <wx/xrc/xmlres.h>

        #include <wx/window.h>
        #include <wx/object.h>
        #include <wx/xml/xml.h>
        #include <wx/xrc/xmlres.h>
        #include <wx/gdicmn.h>
        #include <wx/gdicmn.h>
        #include <wx/imaglist.h>
        #include <wx/iconbndl.h>
        #include <wx/icon.h>
        #include <wx/font.h>
        #include <wx/filesys.h>
        #include <wx/colour.h>
        #include <wx/bitmap.h>
        #include <wx/object.h>
        #include <wx/object.h>


class sipwxXmlResourceHandler : public  ::wxXmlResourceHandler
{
public:
    sipwxXmlResourceHandler();
    sipwxXmlResourceHandler(const  ::wxXmlResourceHandler&);
    virtual ~sipwxXmlResourceHandler();

    /*
     * There is a public method for every protected method visible from
     * this class.
     */
    void sipProtect_AddStyle(const  ::wxString&,int);
    void sipProtect_AddWindowStyles();
    void sipProtect_CreateChildren( ::wxObject*,bool);
    void sipProtect_CreateChildrenPrivately( ::wxObject*, ::wxXmlNode*);
     ::wxObject* sipProtect_CreateResFromNode( ::wxXmlNode*, ::wxObject*, ::wxObject*);
     ::wxAnimation* sipProtect_GetAnimation(const  ::wxString&, ::wxAnimationCtrl*);
     ::wxBitmap sipProtect_GetBitmap(const  ::wxString&,const  ::wxArtClient&, ::wxSize);
     ::wxBitmap sipProtect_GetBitmap(const  ::wxXmlNode*,const  ::wxArtClient&, ::wxSize);
    bool sipProtect_GetBool(const  ::wxString&,bool);
     ::wxColour sipProtect_GetColour(const  ::wxString&,const  ::wxColour&);
     ::wxFileSystem& sipProtect_GetCurFileSystem();
     ::wxCoord sipProtect_GetDimension(const  ::wxString&, ::wxCoord, ::wxWindow*);
     ::wxDirection sipProtect_GetDirection(const  ::wxString&, ::wxDirection);
     ::wxFont sipProtect_GetFont(const  ::wxString&);
    int sipProtect_GetID();
     ::wxIcon sipProtect_GetIcon(const  ::wxString&,const  ::wxArtClient&, ::wxSize);
     ::wxIcon sipProtect_GetIcon(const  ::wxXmlNode*,const  ::wxArtClient&, ::wxSize);
     ::wxIconBundle sipProtect_GetIconBundle(const  ::wxString&,const  ::wxArtClient&);
     ::wxImageList* sipProtect_GetImageList(const  ::wxString&);
    long sipProtect_GetLong(const  ::wxString&,long);
    float sipProtect_GetFloat(const  ::wxString&,float);
     ::wxString sipProtect_GetName();
    bool sipProtect_IsObjectNode(const  ::wxXmlNode*) const;
     ::wxString sipProtect_GetNodeContent( ::wxXmlNode*);
     ::wxXmlNode* sipProtect_GetNodeParent(const  ::wxXmlNode*) const;
     ::wxXmlNode* sipProtect_GetNodeNext(const  ::wxXmlNode*) const;
     ::wxXmlNode* sipProtect_GetNodeChildren(const  ::wxXmlNode*) const;
     ::wxXmlNode* sipProtect_GetParamNode(const  ::wxString&);
     ::wxString sipProtect_GetParamValue(const  ::wxString&);
     ::wxString sipProtect_GetParamValue(const  ::wxXmlNode*);
     ::wxPoint sipProtect_GetPosition(const  ::wxString&);
     ::wxSize sipProtect_GetSize(const  ::wxString&, ::wxWindow*);
    int sipProtect_GetStyle(const  ::wxString&,int);
     ::wxString sipProtect_GetText(const  ::wxString&,bool);
    bool sipProtect_HasParam(const  ::wxString&);
    bool sipProtect_IsOfClass( ::wxXmlNode*,const  ::wxString&);
    void sipProtect_SetupWindow( ::wxWindow*);
    void sipProtect_ReportError( ::wxXmlNode*,const  ::wxString&);
    void sipProtect_ReportError(const  ::wxString&);
    void sipProtect_ReportParamError(const  ::wxString&,const  ::wxString&);
     ::wxXmlResource* sipProtect_GetResource() const;
     ::wxXmlNode* sipProtect_GetNode() const;
     ::wxString sipProtect_GetClass() const;
     ::wxObject* sipProtect_GetParent() const;
     ::wxObject* sipProtect_GetInstance() const;
     ::wxWindow* sipProtect_GetParentAsWindow() const;

    /*
     * There is a protected method for every virtual method visible from
     * this class.
     */
protected:
    bool CanHandle( ::wxXmlNode*) SIP_OVERRIDE;
     ::wxObject* DoCreateResource() SIP_OVERRIDE;

public:
    sipSimpleWrapper *sipPySelf;

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

    char sipPyMethods[2];
};

sipwxXmlResourceHandler::sipwxXmlResourceHandler():  ::wxXmlResourceHandler(), sipPySelf(SIP_NULLPTR)
{
    memset(sipPyMethods, 0, sizeof (sipPyMethods));
}

sipwxXmlResourceHandler::sipwxXmlResourceHandler(const  ::wxXmlResourceHandler& a0):  ::wxXmlResourceHandler(a0), sipPySelf(SIP_NULLPTR)
{
    memset(sipPyMethods, 0, sizeof (sipPyMethods));
}

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

bool sipwxXmlResourceHandler::CanHandle( ::wxXmlNode*node)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[0],sipPySelf,sipName_XmlResourceHandler,sipName_CanHandle);

    if (!sipMeth)
        return 0;

    extern bool sipVH__xrc_1(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *,  ::wxXmlNode*);

    return sipVH__xrc_1(sipGILState, 0, sipPySelf, sipMeth, node);
}

 ::wxObject* sipwxXmlResourceHandler::DoCreateResource()
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[1],sipPySelf,sipName_XmlResourceHandler,sipName_DoCreateResource);

    if (!sipMeth)
        return 0;

    extern  ::wxObject* sipVH__xrc_0(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *);

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

void sipwxXmlResourceHandler::sipProtect_AddStyle(const  ::wxString& name,int value)
{
     ::wxXmlResourceHandler::AddStyle(name,value);
}

void sipwxXmlResourceHandler::sipProtect_AddWindowStyles()
{
     ::wxXmlResourceHandler::AddWindowStyles();
}

void sipwxXmlResourceHandler::sipProtect_CreateChildren( ::wxObject*parent,bool this_hnd_only)
{
     ::wxXmlResourceHandler::CreateChildren(parent,this_hnd_only);
}

void sipwxXmlResourceHandler::sipProtect_CreateChildrenPrivately( ::wxObject*parent, ::wxXmlNode*rootnode)
{
     ::wxXmlResourceHandler::CreateChildrenPrivately(parent,rootnode);
}

 ::wxObject* sipwxXmlResourceHandler::sipProtect_CreateResFromNode( ::wxXmlNode*node, ::wxObject*parent, ::wxObject*instance)
{
    return  ::wxXmlResourceHandler::CreateResFromNode(node,parent,instance);
}

 ::wxAnimation* sipwxXmlResourceHandler::sipProtect_GetAnimation(const  ::wxString& param, ::wxAnimationCtrl*ctrl)
{
    return  ::wxXmlResourceHandler::GetAnimation(param,ctrl);
}

 ::wxBitmap sipwxXmlResourceHandler::sipProtect_GetBitmap(const  ::wxString& param,const  ::wxArtClient& defaultArtClient, ::wxSize size)
{
    return  ::wxXmlResourceHandler::GetBitmap(param,defaultArtClient,size);
}

 ::wxBitmap sipwxXmlResourceHandler::sipProtect_GetBitmap(const  ::wxXmlNode*node,const  ::wxArtClient& defaultArtClient, ::wxSize size)
{
    return  ::wxXmlResourceHandler::GetBitmap(node,defaultArtClient,size);
}

bool sipwxXmlResourceHandler::sipProtect_GetBool(const  ::wxString& param,bool defaultv)
{
    return  ::wxXmlResourceHandler::GetBool(param,defaultv);
}

 ::wxColour sipwxXmlResourceHandler::sipProtect_GetColour(const  ::wxString& param,const  ::wxColour& defaultColour)
{
    return  ::wxXmlResourceHandler::GetColour(param,defaultColour);
}

 ::wxFileSystem& sipwxXmlResourceHandler::sipProtect_GetCurFileSystem()
{
    return  ::wxXmlResourceHandler::GetCurFileSystem();
}

 ::wxCoord sipwxXmlResourceHandler::sipProtect_GetDimension(const  ::wxString& param, ::wxCoord defaultv, ::wxWindow*windowToUse)
{
    return  ::wxXmlResourceHandler::GetDimension(param,defaultv,windowToUse);
}

 ::wxDirection sipwxXmlResourceHandler::sipProtect_GetDirection(const  ::wxString& param, ::wxDirection dirDefault)
{
    return  ::wxXmlResourceHandler::GetDirection(param,dirDefault);
}

 ::wxFont sipwxXmlResourceHandler::sipProtect_GetFont(const  ::wxString& param)
{
    return  ::wxXmlResourceHandler::GetFont(param);
}

int sipwxXmlResourceHandler::sipProtect_GetID()
{
    return  ::wxXmlResourceHandler::GetID();
}

 ::wxIcon sipwxXmlResourceHandler::sipProtect_GetIcon(const  ::wxString& param,const  ::wxArtClient& defaultArtClient, ::wxSize size)
{
    return  ::wxXmlResourceHandler::GetIcon(param,defaultArtClient,size);
}

 ::wxIcon sipwxXmlResourceHandler::sipProtect_GetIcon(const  ::wxXmlNode*node,const  ::wxArtClient& defaultArtClient, ::wxSize size)
{
    return  ::wxXmlResourceHandler::GetIcon(node,defaultArtClient,size);
}

 ::wxIconBundle sipwxXmlResourceHandler::sipProtect_GetIconBundle(const  ::wxString& param,const  ::wxArtClient& defaultArtClient)
{
    return  ::wxXmlResourceHandler::GetIconBundle(param,defaultArtClient);
}

 ::wxImageList* sipwxXmlResourceHandler::sipProtect_GetImageList(const  ::wxString& param)
{
    return  ::wxXmlResourceHandler::GetImageList(param);
}

long sipwxXmlResourceHandler::sipProtect_GetLong(const  ::wxString& param,long defaultv)
{
    return  ::wxXmlResourceHandler::GetLong(param,defaultv);
}

float sipwxXmlResourceHandler::sipProtect_GetFloat(const  ::wxString& param,float defaultv)
{
    return  ::wxXmlResourceHandler::GetFloat(param,defaultv);
}

 ::wxString sipwxXmlResourceHandler::sipProtect_GetName()
{
    return  ::wxXmlResourceHandler::GetName();
}

bool sipwxXmlResourceHandler::sipProtect_IsObjectNode(const  ::wxXmlNode*node) const
{
    return  ::wxXmlResourceHandler::IsObjectNode(node);
}

 ::wxString sipwxXmlResourceHandler::sipProtect_GetNodeContent( ::wxXmlNode*node)
{
    return  ::wxXmlResourceHandler::GetNodeContent(node);
}

 ::wxXmlNode* sipwxXmlResourceHandler::sipProtect_GetNodeParent(const  ::wxXmlNode*node) const
{
    return  ::wxXmlResourceHandler::GetNodeParent(node);
}

 ::wxXmlNode* sipwxXmlResourceHandler::sipProtect_GetNodeNext(const  ::wxXmlNode*node) const
{
    return  ::wxXmlResourceHandler::GetNodeNext(node);
}

 ::wxXmlNode* sipwxXmlResourceHandler::sipProtect_GetNodeChildren(const  ::wxXmlNode*node) const
{
    return  ::wxXmlResourceHandler::GetNodeChildren(node);
}

 ::wxXmlNode* sipwxXmlResourceHandler::sipProtect_GetParamNode(const  ::wxString& param)
{
    return  ::wxXmlResourceHandler::GetParamNode(param);
}

 ::wxString sipwxXmlResourceHandler::sipProtect_GetParamValue(const  ::wxString& param)
{
    return  ::wxXmlResourceHandler::GetParamValue(param);
}

 ::wxString sipwxXmlResourceHandler::sipProtect_GetParamValue(const  ::wxXmlNode*node)
{
    return  ::wxXmlResourceHandler::GetParamValue(node);
}

 ::wxPoint sipwxXmlResourceHandler::sipProtect_GetPosition(const  ::wxString& param)
{
    return  ::wxXmlResourceHandler::GetPosition(param);
}

 ::wxSize sipwxXmlResourceHandler::sipProtect_GetSize(const  ::wxString& param, ::wxWindow*windowToUse)
{
    return  ::wxXmlResourceHandler::GetSize(param,windowToUse);
}

int sipwxXmlResourceHandler::sipProtect_GetStyle(const  ::wxString& param,int defaults)
{
    return  ::wxXmlResourceHandler::GetStyle(param,defaults);
}

 ::wxString sipwxXmlResourceHandler::sipProtect_GetText(const  ::wxString& param,bool translate)
{
    return  ::wxXmlResourceHandler::GetText(param,translate);
}

bool sipwxXmlResourceHandler::sipProtect_HasParam(const  ::wxString& param)
{
    return  ::wxXmlResourceHandler::HasParam(param);
}

bool sipwxXmlResourceHandler::sipProtect_IsOfClass( ::wxXmlNode*node,const  ::wxString& classname)
{
    return  ::wxXmlResourceHandler::IsOfClass(node,classname);
}

void sipwxXmlResourceHandler::sipProtect_SetupWindow( ::wxWindow*wnd)
{
     ::wxXmlResourceHandler::SetupWindow(wnd);
}

void sipwxXmlResourceHandler::sipProtect_ReportError( ::wxXmlNode*context,const  ::wxString& message)
{
     ::wxXmlResourceHandler::ReportError(context,message);
}

void sipwxXmlResourceHandler::sipProtect_ReportError(const  ::wxString& message)
{
     ::wxXmlResourceHandler::ReportError(message);
}

void sipwxXmlResourceHandler::sipProtect_ReportParamError(const  ::wxString& param,const  ::wxString& message)
{
     ::wxXmlResourceHandler::ReportParamError(param,message);
}

 ::wxXmlResource* sipwxXmlResourceHandler::sipProtect_GetResource() const
{
    return  ::wxXmlResourceHandler::GetResource();
}

 ::wxXmlNode* sipwxXmlResourceHandler::sipProtect_GetNode() const
{
    return  ::wxXmlResourceHandler::GetNode();
}

 ::wxString sipwxXmlResourceHandler::sipProtect_GetClass() const
{
    return  ::wxXmlResourceHandler::GetClass();
}

 ::wxObject* sipwxXmlResourceHandler::sipProtect_GetParent() const
{
    return  ::wxXmlResourceHandler::GetParent();
}

 ::wxObject* sipwxXmlResourceHandler::sipProtect_GetInstance() const
{
    return  ::wxXmlResourceHandler::GetInstance();
}

 ::wxWindow* sipwxXmlResourceHandler::sipProtect_GetParentAsWindow() const
{
    return  ::wxXmlResourceHandler::GetParentAsWindow();
}


PyDoc_STRVAR(doc_wxXmlResourceHandler_CreateResource, "CreateResource(node, parent, instance) -> Object\n"
"\n"
"Creates an object (menu, dialog, control, ...) from an XML node.");

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

    {
         ::wxXmlNode* node;
         ::wxObject* parent;
         ::wxObject* instance;
         ::wxXmlResourceHandler *sipCpp;

        static const char *sipKwdList[] = {
            sipName_node,
            sipName_parent,
            sipName_instance,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, SIP_NULLPTR, "BJ8J8J8", &sipSelf, sipType_wxXmlResourceHandler, &sipCpp, sipType_wxXmlNode, &node, sipType_wxObject, &parent, sipType_wxObject, &instance))
        {
             ::wxObject*sipRes;

            PyErr_Clear();

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->CreateResource(node,parent,instance);
            Py_END_ALLOW_THREADS

            if (PyErr_Occurred())
                return 0;

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

    sipNoMethod(sipParseErr, sipName_XmlResourceHandler, sipName_CreateResource, SIP_NULLPTR);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_wxXmlResourceHandler_DoCreateResource, "DoCreateResource() -> Object\n"
"\n"
"Called from CreateResource after variables were filled.");

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

    {
         ::wxXmlResourceHandler *sipCpp;

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

            if (!sipOrigSelf)
            {
                sipAbstractMethod(sipName_XmlResourceHandler, sipName_DoCreateResource);
                return SIP_NULLPTR;
            }

            PyErr_Clear();

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->DoCreateResource();
            Py_END_ALLOW_THREADS

            if (PyErr_Occurred())
                return 0;

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

    sipNoMethod(sipParseErr, sipName_XmlResourceHandler, sipName_DoCreateResource, SIP_NULLPTR);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_wxXmlResourceHandler_CanHandle, "CanHandle(node) -> bool\n"
"\n"
"Returns true if it understands this node and can create a resource\n"
"from it, false otherwise.");

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

    {
         ::wxXmlNode* node;
         ::wxXmlResourceHandler *sipCpp;

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

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, SIP_NULLPTR, "BJ8", &sipSelf, sipType_wxXmlResourceHandler, &sipCpp, sipType_wxXmlNode, &node))
        {
            bool sipRes;

            if (!sipOrigSelf)
            {
                sipAbstractMethod(sipName_XmlResourceHandler, sipName_CanHandle);
                return SIP_NULLPTR;
            }

            PyErr_Clear();

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->CanHandle(node);
            Py_END_ALLOW_THREADS

            if (PyErr_Occurred())
                return 0;

            return PyBool_FromLong(sipRes);
        }
    }

    sipNoMethod(sipParseErr, sipName_XmlResourceHandler, sipName_CanHandle, SIP_NULLPTR);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_wxXmlResourceHandler_SetParentResource, "SetParentResource(res)\n"
"\n"
"Sets the parent resource.");

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

    {
         ::wxXmlResource* res;
         ::wxXmlResourceHandler *sipCpp;

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

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, SIP_NULLPTR, "BJ8", &sipSelf, sipType_wxXmlResourceHandler, &sipCpp, sipType_wxXmlResource, &res))
        {
            PyErr_Clear();

            Py_BEGIN_ALLOW_THREADS
            sipCpp->SetParentResource(res);
            Py_END_ALLOW_THREADS

            if (PyErr_Occurred())
                return 0;

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    sipNoMethod(sipParseErr, sipName_XmlResourceHandler, sipName_SetParentResource, SIP_NULLPTR);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_wxXmlResourceHandler_AddStyle, "AddStyle(name, value)\n"
"\n"
"Add a style flag (e.g.");

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

    {
        const  ::wxString* name;
        int nameState = 0;
        int value;
        sipwxXmlResourceHandler *sipCpp;

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

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, SIP_NULLPTR, "BJ1i", &sipSelf, sipType_wxXmlResourceHandler, &sipCpp, sipType_wxString,&name, &nameState, &value))
        {
            PyErr_Clear();

            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtect_AddStyle(*name,value);
            Py_END_ALLOW_THREADS
            sipReleaseType(const_cast< ::wxString *>(name),sipType_wxString,nameState);

            if (PyErr_Occurred())
                return 0;

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    sipNoMethod(sipParseErr, sipName_XmlResourceHandler, sipName_AddStyle, SIP_NULLPTR);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_wxXmlResourceHandler_AddWindowStyles, "AddWindowStyles()\n"
"\n"
"Add styles common to all wxWindow-derived classes.");

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

    {
        sipwxXmlResourceHandler *sipCpp;

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

            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtect_AddWindowStyles();
            Py_END_ALLOW_THREADS

            if (PyErr_Occurred())
                return 0;

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    sipNoMethod(sipParseErr, sipName_XmlResourceHandler, sipName_AddWindowStyles, SIP_NULLPTR);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_wxXmlResourceHandler_CreateChildren, "CreateChildren(parent, this_hnd_only=False)\n"
"\n"
"Creates children.");

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

    {
         ::wxObject* parent;
        bool this_hnd_only = 0;
        sipwxXmlResourceHandler *sipCpp;

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

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, SIP_NULLPTR, "BJ8|b", &sipSelf, sipType_wxXmlResourceHandler, &sipCpp, sipType_wxObject, &parent, &this_hnd_only))
        {
            PyErr_Clear();

            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtect_CreateChildren(parent,this_hnd_only);
            Py_END_ALLOW_THREADS

            if (PyErr_Occurred())
                return 0;

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    sipNoMethod(sipParseErr, sipName_XmlResourceHandler, sipName_CreateChildren, SIP_NULLPTR);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_wxXmlResourceHandler_CreateChildrenPrivately, "CreateChildrenPrivately(parent, rootnode=None)\n"
"\n"
"Helper function.");

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

    {
         ::wxObject* parent;
         ::wxXmlNode* rootnode = 0;
        sipwxXmlResourceHandler *sipCpp;

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

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, SIP_NULLPTR, "BJ8|J8", &sipSelf, sipType_wxXmlResourceHandler, &sipCpp, sipType_wxObject, &parent, sipType_wxXmlNode, &rootnode))
        {
            PyErr_Clear();

            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtect_CreateChildrenPrivately(parent,rootnode);
            Py_END_ALLOW_THREADS

            if (PyErr_Occurred())
                return 0;

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    sipNoMethod(sipParseErr, sipName_XmlResourceHandler, sipName_CreateChildrenPrivately, SIP_NULLPTR);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_wxXmlResourceHandler_CreateResFromNode, "CreateResFromNode(node, parent, instance=None) -> Object\n"
"\n"
"Creates a resource from a node.");

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

    {
         ::wxXmlNode* node;
         ::wxObject* parent;
         ::wxObject* instance = 0;
        sipwxXmlResourceHandler *sipCpp;

        static const char *sipKwdList[] = {
            sipName_node,
            sipName_parent,
            sipName_instance,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, SIP_NULLPTR, "BJ8J8|J8", &sipSelf, sipType_wxXmlResourceHandler, &sipCpp, sipType_wxXmlNode, &node, sipType_wxObject, &parent, sipType_wxObject, &instance))
        {
             ::wxObject*sipRes;

            PyErr_Clear();

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->sipProtect_CreateResFromNode(node,parent,instance);
            Py_END_ALLOW_THREADS

            if (PyErr_Occurred())
                return 0;

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

    sipNoMethod(sipParseErr, sipName_XmlResourceHandler, sipName_CreateResFromNode, SIP_NULLPTR);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_wxXmlResourceHandler_GetAnimation, "GetAnimation(param=\"animation\", ctrl=None) -> Animation\n"
"\n"
"Creates an animation (see wxAnimation) from the filename specified in\n"
"param.");

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

    {
        const  ::wxString& paramdef = "animation";
        const  ::wxString* param = &paramdef;
        int paramState = 0;
         ::wxAnimationCtrl* ctrl = 0;
        sipwxXmlResourceHandler *sipCpp;

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

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, SIP_NULLPTR, "B|J1J8", &sipSelf, sipType_wxXmlResourceHandler, &sipCpp, sipType_wxString,&param, &paramState, sipType_wxAnimationCtrl, &ctrl))
        {
             ::wxAnimation*sipRes;

            PyErr_Clear();

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->sipProtect_GetAnimation(*param,ctrl);
            Py_END_ALLOW_THREADS
            sipReleaseType(const_cast< ::wxString *>(param),sipType_wxString,paramState);

            if (PyErr_Occurred())
                return 0;

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

    sipNoMethod(sipParseErr, sipName_XmlResourceHandler, sipName_GetAnimation, SIP_NULLPTR);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_wxXmlResourceHandler_GetBitmap, "GetBitmap(param=\"bitmap\", defaultArtClient=ART_OTHER, size=DefaultSize) -> Bitmap\n"
"GetBitmap(node, defaultArtClient=ART_OTHER, size=DefaultSize) -> Bitmap\n"
"\n"
"Gets a bitmap.\n"
"");

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

    {
        const  ::wxString& paramdef = "bitmap";
        const  ::wxString* param = &paramdef;
        int paramState = 0;
        const  ::wxArtClient& defaultArtClientdef = wxART_OTHER;
        const  ::wxArtClient* defaultArtClient = &defaultArtClientdef;
        int defaultArtClientState = 0;
         ::wxSize sizedef = wxDefaultSize;
         ::wxSize* size = &sizedef;
        int sizeState = 0;
        sipwxXmlResourceHandler *sipCpp;

        static const char *sipKwdList[] = {
            sipName_param,
            sipName_defaultArtClient,
            sipName_size,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, SIP_NULLPTR, "B|J1J1J1", &sipSelf, sipType_wxXmlResourceHandler, &sipCpp, sipType_wxString,&param, &paramState, sipType_wxString,&defaultArtClient, &defaultArtClientState, sipType_wxSize, &size, &sizeState))
        {
             ::wxBitmap*sipRes;

            PyErr_Clear();

            Py_BEGIN_ALLOW_THREADS
            sipRes = new  ::wxBitmap(sipCpp->sipProtect_GetBitmap(*param,*defaultArtClient,*size));
            Py_END_ALLOW_THREADS
            sipReleaseType(const_cast< ::wxString *>(param),sipType_wxString,paramState);
            sipReleaseType(const_cast< ::wxArtClient *>(defaultArtClient),sipType_wxString,defaultArtClientState);
            sipReleaseType(size,sipType_wxSize,sizeState);

            if (PyErr_Occurred())
                return 0;

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

    {
        const  ::wxXmlNode* node;
        const  ::wxArtClient& defaultArtClientdef = wxART_OTHER;
        const  ::wxArtClient* defaultArtClient = &defaultArtClientdef;
        int defaultArtClientState = 0;
         ::wxSize sizedef = wxDefaultSize;
         ::wxSize* size = &sizedef;
        int sizeState = 0;
        sipwxXmlResourceHandler *sipCpp;

        static const char *sipKwdList[] = {
            sipName_node,
            sipName_defaultArtClient,
            sipName_size,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, SIP_NULLPTR, "BJ8|J1J1", &sipSelf, sipType_wxXmlResourceHandler, &sipCpp, sipType_wxXmlNode, &node, sipType_wxString,&defaultArtClient, &defaultArtClientState, sipType_wxSize, &size, &sizeState))
        {
             ::wxBitmap*sipRes;

            PyErr_Clear();

            Py_BEGIN_ALLOW_THREADS
            sipRes = new  ::wxBitmap(sipCpp->sipProtect_GetBitmap(node,*defaultArtClient,*size));
            Py_END_ALLOW_THREADS
            sipReleaseType(const_cast< ::wxArtClient *>(defaultArtClient),sipType_wxString,defaultArtClientState);
            sipReleaseType(size,sipType_wxSize,sizeState);

            if (PyErr_Occurred())
                return 0;

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

    sipNoMethod(sipParseErr, sipName_XmlResourceHandler, sipName_GetBitmap, SIP_NULLPTR);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_wxXmlResourceHandler_GetBool, "GetBool(param, defaultv=False) -> bool\n"
"\n"
"Gets a bool flag (1, t, yes, on, true are true, everything else is\n"
"false).");

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

    {
        const  ::wxString* param;
        int paramState = 0;
        bool defaultv = 0;
        sipwxXmlResourceHandler *sipCpp;

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

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, SIP_NULLPTR, "BJ1|b", &sipSelf, sipType_wxXmlResourceHandler, &sipCpp, sipType_wxString,&param, &paramState, &defaultv))
        {
            bool sipRes;

            PyErr_Clear();

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->sipProtect_GetBool(*param,defaultv);
            Py_END_ALLOW_THREADS
            sipReleaseType(const_cast< ::wxString *>(param),sipType_wxString,paramState);

            if (PyErr_Occurred())
                return 0;

            return PyBool_FromLong(sipRes);
        }
    }

    sipNoMethod(sipParseErr, sipName_XmlResourceHandler, sipName_GetBool, SIP_NULLPTR);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_wxXmlResourceHandler_GetColour, "GetColour(param, defaultColour=NullColour) -> Colour\n"
"\n"
"Gets colour in HTML syntax (#RRGGBB).");

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

    {
        const  ::wxString* param;
        int paramState = 0;
        const  ::wxColour& defaultColourdef = wxNullColour;
        const  ::wxColour* defaultColour = &defaultColourdef;
        int defaultColourState = 0;
        sipwxXmlResourceHandler *sipCpp;

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

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, SIP_NULLPTR, "BJ1|J1", &sipSelf, sipType_wxXmlResourceHandler, &sipCpp, sipType_wxString,&param, &paramState, sipType_wxColour, &defaultColour, &defaultColourState))
        {
             ::wxColour*sipRes;

            PyErr_Clear();

            Py_BEGIN_ALLOW_THREADS
            sipRes = new  ::wxColour(sipCpp->sipProtect_GetColour(*param,*defaultColour));
            Py_END_ALLOW_THREADS
            sipReleaseType(const_cast< ::wxString *>(param),sipType_wxString,paramState);
            sipReleaseType(const_cast< ::wxColour *>(defaultColour),sipType_wxColour,defaultColourState);

            if (PyErr_Occurred())
                return 0;

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

    sipNoMethod(sipParseErr, sipName_XmlResourceHandler, sipName_GetColour, SIP_NULLPTR);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_wxXmlResourceHandler_GetCurFileSystem, "GetCurFileSystem() -> FileSystem\n"
"\n"
"Returns the current file system.");

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

    {
        sipwxXmlResourceHandler *sipCpp;

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

            PyErr_Clear();

            Py_BEGIN_ALLOW_THREADS
            sipRes = &sipCpp->sipProtect_GetCurFileSystem();
            Py_END_ALLOW_THREADS

            if (PyErr_Occurred())
                return 0;

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

    sipNoMethod(sipParseErr, sipName_XmlResourceHandler, sipName_GetCurFileSystem, SIP_NULLPTR);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_wxXmlResourceHandler_GetDimension, "GetDimension(param, defaultv=0, windowToUse=0) -> Coord\n"
"\n"
"Gets a dimension (may be in dialog units).");

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

    {
        const  ::wxString* param;
        int paramState = 0;
         ::wxCoord defaultv = 0;
         ::wxWindow* windowToUse = 0;
        sipwxXmlResourceHandler *sipCpp;

        static const char *sipKwdList[] = {
            sipName_param,
            sipName_defaultv,
            sipName_windowToUse,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, SIP_NULLPTR, "BJ1|iJ8", &sipSelf, sipType_wxXmlResourceHandler, &sipCpp, sipType_wxString,&param, &paramState, &defaultv, sipType_wxWindow, &windowToUse))
        {
             ::wxCoord sipRes;

            PyErr_Clear();

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->sipProtect_GetDimension(*param,defaultv,windowToUse);
            Py_END_ALLOW_THREADS
            sipReleaseType(const_cast< ::wxString *>(param),sipType_wxString,paramState);

            if (PyErr_Occurred())
                return 0;

            return SIPLong_FromLong(sipRes);
        }
    }

    sipNoMethod(sipParseErr, sipName_XmlResourceHandler, sipName_GetDimension, SIP_NULLPTR);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_wxXmlResourceHandler_GetDirection, "GetDirection(param, dirDefault=LEFT) -> Direction\n"
"\n"
"Gets a direction.");

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

    {
        const  ::wxString* param;
        int paramState = 0;
         ::wxDirection dirDefault = wxLEFT;
        sipwxXmlResourceHandler *sipCpp;

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

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, SIP_NULLPTR, "BJ1|E", &sipSelf, sipType_wxXmlResourceHandler, &sipCpp, sipType_wxString,&param, &paramState, sipType_wxDirection, &dirDefault))
        {
             ::wxDirection sipRes;

            PyErr_Clear();

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->sipProtect_GetDirection(*param,dirDefault);
            Py_END_ALLOW_THREADS
            sipReleaseType(const_cast< ::wxString *>(param),sipType_wxString,paramState);

            if (PyErr_Occurred())
                return 0;

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

    sipNoMethod(sipParseErr, sipName_XmlResourceHandler, sipName_GetDirection, SIP_NULLPTR);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_wxXmlResourceHandler_GetFont, "GetFont(param=\"font\") -> Font\n"
"\n"
"Gets a font.");

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

    {
        const  ::wxString& paramdef = "font";
        const  ::wxString* param = &paramdef;
        int paramState = 0;
        sipwxXmlResourceHandler *sipCpp;

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

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, SIP_NULLPTR, "B|J1", &sipSelf, sipType_wxXmlResourceHandler, &sipCpp, sipType_wxString,&param, &paramState))
        {
             ::wxFont*sipRes;

            PyErr_Clear();

            Py_BEGIN_ALLOW_THREADS
            sipRes = new  ::wxFont(sipCpp->sipProtect_GetFont(*param));
            Py_END_ALLOW_THREADS
            sipReleaseType(const_cast< ::wxString *>(param),sipType_wxString,paramState);

            if (PyErr_Occurred())
                return 0;

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

    sipNoMethod(sipParseErr, sipName_XmlResourceHandler, sipName_GetFont, SIP_NULLPTR);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_wxXmlResourceHandler_GetID, "GetID() -> int\n"
"\n"
"Returns the XRCID.");

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

    {
        sipwxXmlResourceHandler *sipCpp;

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

            PyErr_Clear();

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->sipProtect_GetID();
            Py_END_ALLOW_THREADS

            if (PyErr_Occurred())
                return 0;

            return SIPLong_FromLong(sipRes);
        }
    }

    sipNoMethod(sipParseErr, sipName_XmlResourceHandler, sipName_GetID, SIP_NULLPTR);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_wxXmlResourceHandler_GetIcon, "GetIcon(param=\"icon\", defaultArtClient=ART_OTHER, size=DefaultSize) -> Icon\n"
"GetIcon(node, defaultArtClient=ART_OTHER, size=DefaultSize) -> Icon\n"
"\n"
"Returns an icon.\n"
"");

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

    {
        const  ::wxString& paramdef = "icon";
        const  ::wxString* param = &paramdef;
        int paramState = 0;
        const  ::wxArtClient& defaultArtClientdef = wxART_OTHER;
        const  ::wxArtClient* defaultArtClient = &defaultArtClientdef;
        int defaultArtClientState = 0;
         ::wxSize sizedef = wxDefaultSize;
         ::wxSize* size = &sizedef;
        int sizeState = 0;
        sipwxXmlResourceHandler *sipCpp;

        static const char *sipKwdList[] = {
            sipName_param,
            sipName_defaultArtClient,
            sipName_size,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, SIP_NULLPTR, "B|J1J1J1", &sipSelf, sipType_wxXmlResourceHandler, &sipCpp, sipType_wxString,&param, &paramState, sipType_wxString,&defaultArtClient, &defaultArtClientState, sipType_wxSize, &size, &sizeState))
        {
             ::wxIcon*sipRes;

            PyErr_Clear();

            Py_BEGIN_ALLOW_THREADS
            sipRes = new  ::wxIcon(sipCpp->sipProtect_GetIcon(*param,*defaultArtClient,*size));
            Py_END_ALLOW_THREADS
            sipReleaseType(const_cast< ::wxString *>(param),sipType_wxString,paramState);
            sipReleaseType(const_cast< ::wxArtClient *>(defaultArtClient),sipType_wxString,defaultArtClientState);
            sipReleaseType(size,sipType_wxSize,sizeState);

            if (PyErr_Occurred())
                return 0;

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

    {
        const  ::wxXmlNode* node;
        const  ::wxArtClient& defaultArtClientdef = wxART_OTHER;
        const  ::wxArtClient* defaultArtClient = &defaultArtClientdef;
        int defaultArtClientState = 0;
         ::wxSize sizedef = wxDefaultSize;
         ::wxSize* size = &sizedef;
        int sizeState = 0;
        sipwxXmlResourceHandler *sipCpp;

        static const char *sipKwdList[] = {
            sipName_node,
            sipName_defaultArtClient,
            sipName_size,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, SIP_NULLPTR, "BJ8|J1J1", &sipSelf, sipType_wxXmlResourceHandler, &sipCpp, sipType_wxXmlNode, &node, sipType_wxString,&defaultArtClient, &defaultArtClientState, sipType_wxSize, &size, &sizeState))
        {
             ::wxIcon*sipRes;

            PyErr_Clear();

            Py_BEGIN_ALLOW_THREADS
            sipRes = new  ::wxIcon(sipCpp->sipProtect_GetIcon(node,*defaultArtClient,*size));
            Py_END_ALLOW_THREADS
            sipReleaseType(const_cast< ::wxArtClient *>(defaultArtClient),sipType_wxString,defaultArtClientState);
            sipReleaseType(size,sipType_wxSize,sizeState);

            if (PyErr_Occurred())
                return 0;

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

    sipNoMethod(sipParseErr, sipName_XmlResourceHandler, sipName_GetIcon, SIP_NULLPTR);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_wxXmlResourceHandler_GetIconBundle, "GetIconBundle(param, defaultArtClient=ART_OTHER) -> IconBundle\n"
"\n"
"Returns an icon bundle.");

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

    {
        const  ::wxString* param;
        int paramState = 0;
        const  ::wxArtClient& defaultArtClientdef = wxART_OTHER;
        const  ::wxArtClient* defaultArtClient = &defaultArtClientdef;
        int defaultArtClientState = 0;
        sipwxXmlResourceHandler *sipCpp;

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

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, SIP_NULLPTR, "BJ1|J1", &sipSelf, sipType_wxXmlResourceHandler, &sipCpp, sipType_wxString,&param, &paramState, sipType_wxString,&defaultArtClient, &defaultArtClientState))
        {
             ::wxIconBundle*sipRes;

            PyErr_Clear();

            Py_BEGIN_ALLOW_THREADS
            sipRes = new  ::wxIconBundle(sipCpp->sipProtect_GetIconBundle(*param,*defaultArtClient));
            Py_END_ALLOW_THREADS
            sipReleaseType(const_cast< ::wxString *>(param),sipType_wxString,paramState);
            sipReleaseType(const_cast< ::wxArtClient *>(defaultArtClient),sipType_wxString,defaultArtClientState);

            if (PyErr_Occurred())
                return 0;

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

    sipNoMethod(sipParseErr, sipName_XmlResourceHandler, sipName_GetIconBundle, SIP_NULLPTR);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_wxXmlResourceHandler_GetImageList, "GetImageList(param=\"imagelist\") -> ImageList\n"
"\n"
"Creates an image list from the param markup data.");

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

    {
        const  ::wxString& paramdef = "imagelist";
        const  ::wxString* param = &paramdef;
        int paramState = 0;
        sipwxXmlResourceHandler *sipCpp;

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

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, SIP_NULLPTR, "B|J1", &sipSelf, sipType_wxXmlResourceHandler, &sipCpp, sipType_wxString,&param, &paramState))
        {
             ::wxImageList*sipRes;

            PyErr_Clear();

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->sipProtect_GetImageList(*param);
            Py_END_ALLOW_THREADS
            sipReleaseType(const_cast< ::wxString *>(param),sipType_wxString,paramState);

            if (PyErr_Occurred())
                return 0;

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

    sipNoMethod(sipParseErr, sipName_XmlResourceHandler, sipName_GetImageList, SIP_NULLPTR);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_wxXmlResourceHandler_GetLong, "GetLong(param, defaultv=0) -> long\n"
"\n"
"Gets the integer value from the parameter.");

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

    {
        const  ::wxString* param;
        int paramState = 0;
        long defaultv = 0;
        sipwxXmlResourceHandler *sipCpp;

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

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, SIP_NULLPTR, "BJ1|l", &sipSelf, sipType_wxXmlResourceHandler, &sipCpp, sipType_wxString,&param, &paramState, &defaultv))
        {
            long sipRes;

            PyErr_Clear();

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->sipProtect_GetLong(*param,defaultv);
            Py_END_ALLOW_THREADS
            sipReleaseType(const_cast< ::wxString *>(param),sipType_wxString,paramState);

            if (PyErr_Occurred())
                return 0;

            return PyLong_FromLong(sipRes);
        }
    }

    sipNoMethod(sipParseErr, sipName_XmlResourceHandler, sipName_GetLong, SIP_NULLPTR);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_wxXmlResourceHandler_GetFloat, "GetFloat(param, defaultv=0) -> float\n"
"\n"
"Gets a float value from the parameter.");

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

    {
        const  ::wxString* param;
        int paramState = 0;
        float defaultv = 0;
        sipwxXmlResourceHandler *sipCpp;

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

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, SIP_NULLPTR, "BJ1|f", &sipSelf, sipType_wxXmlResourceHandler, &sipCpp, sipType_wxString,&param, &paramState, &defaultv))
        {
            float sipRes;

            PyErr_Clear();

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->sipProtect_GetFloat(*param,defaultv);
            Py_END_ALLOW_THREADS
            sipReleaseType(const_cast< ::wxString *>(param),sipType_wxString,paramState);

            if (PyErr_Occurred())
                return 0;

            return PyFloat_FromDouble((double)sipRes);
        }
    }

    sipNoMethod(sipParseErr, sipName_XmlResourceHandler, sipName_GetFloat, SIP_NULLPTR);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_wxXmlResourceHandler_GetName, "GetName() -> String\n"
"\n"
"Returns the resource name.");

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

    {
        sipwxXmlResourceHandler *sipCpp;

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

            PyErr_Clear();

            Py_BEGIN_ALLOW_THREADS
            sipRes = new  ::wxString(sipCpp->sipProtect_GetName());
            Py_END_ALLOW_THREADS

            if (PyErr_Occurred())
                return 0;

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

    sipNoMethod(sipParseErr, sipName_XmlResourceHandler, sipName_GetName, SIP_NULLPTR);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_wxXmlResourceHandler_IsObjectNode, "IsObjectNode(node) -> bool\n"
"\n"
"Checks if the given node is an object node.");

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

    {
        const  ::wxXmlNode* node;
        const sipwxXmlResourceHandler *sipCpp;

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

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, SIP_NULLPTR, "BJ8", &sipSelf, sipType_wxXmlResourceHandler, &sipCpp, sipType_wxXmlNode, &node))
        {
            bool sipRes;

            PyErr_Clear();

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->sipProtect_IsObjectNode(node);
            Py_END_ALLOW_THREADS

            if (PyErr_Occurred())
                return 0;

            return PyBool_FromLong(sipRes);
        }
    }

    sipNoMethod(sipParseErr, sipName_XmlResourceHandler, sipName_IsObjectNode, SIP_NULLPTR);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_wxXmlResourceHandler_GetNodeContent, "GetNodeContent(node) -> String\n"
"\n"
"Gets node content from wxXML_ENTITY_NODE.");

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

    {
         ::wxXmlNode* node;
        sipwxXmlResourceHandler *sipCpp;

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

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, SIP_NULLPTR, "BJ8", &sipSelf, sipType_wxXmlResourceHandler, &sipCpp, sipType_wxXmlNode, &node))
        {
             ::wxString*sipRes;

            PyErr_Clear();

            Py_BEGIN_ALLOW_THREADS
            sipRes = new  ::wxString(sipCpp->sipProtect_GetNodeContent(node));
            Py_END_ALLOW_THREADS

            if (PyErr_Occurred())
                return 0;

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

    sipNoMethod(sipParseErr, sipName_XmlResourceHandler, sipName_GetNodeContent, SIP_NULLPTR);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_wxXmlResourceHandler_GetNodeParent, "GetNodeParent(node) -> XmlNode\n"
"\n"
"Gets the parent of the node given.");

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

    {
        const  ::wxXmlNode* node;
        const sipwxXmlResourceHandler *sipCpp;

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

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, SIP_NULLPTR, "BJ8", &sipSelf, sipType_wxXmlResourceHandler, &sipCpp, sipType_wxXmlNode, &node))
        {
             ::wxXmlNode*sipRes;

            PyErr_Clear();

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->sipProtect_GetNodeParent(node);
            Py_END_ALLOW_THREADS

            if (PyErr_Occurred())
                return 0;

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

    sipNoMethod(sipParseErr, sipName_XmlResourceHandler, sipName_GetNodeParent, SIP_NULLPTR);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_wxXmlResourceHandler_GetNodeNext, "GetNodeNext(node) -> XmlNode\n"
"\n"
"Gets the next sibling node related to the given node, possibly NULL.");

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

    {
        const  ::wxXmlNode* node;
        const sipwxXmlResourceHandler *sipCpp;

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

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, SIP_NULLPTR, "BJ8", &sipSelf, sipType_wxXmlResourceHandler, &sipCpp, sipType_wxXmlNode, &node))
        {
             ::wxXmlNode*sipRes;

            PyErr_Clear();

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->sipProtect_GetNodeNext(node);
            Py_END_ALLOW_THREADS

            if (PyErr_Occurred())
                return 0;

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

    sipNoMethod(sipParseErr, sipName_XmlResourceHandler, sipName_GetNodeNext, SIP_NULLPTR);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_wxXmlResourceHandler_GetNodeChildren, "GetNodeChildren(node) -> XmlNode\n"
"\n"
"Gets the first child of the given node or NULL.");

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

    {
        const  ::wxXmlNode* node;
        const sipwxXmlResourceHandler *sipCpp;

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

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, SIP_NULLPTR, "BJ8", &sipSelf, sipType_wxXmlResourceHandler, &sipCpp, sipType_wxXmlNode, &node))
        {
             ::wxXmlNode*sipRes;

            PyErr_Clear();

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->sipProtect_GetNodeChildren(node);
            Py_END_ALLOW_THREADS

            if (PyErr_Occurred())
                return 0;

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

    sipNoMethod(sipParseErr, sipName_XmlResourceHandler, sipName_GetNodeChildren, SIP_NULLPTR);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_wxXmlResourceHandler_GetParamNode, "GetParamNode(param) -> XmlNode\n"
"\n"
"Finds the node or returns NULL.");

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

    {
        const  ::wxString* param;
        int paramState = 0;
        sipwxXmlResourceHandler *sipCpp;

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

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, SIP_NULLPTR, "BJ1", &sipSelf, sipType_wxXmlResourceHandler, &sipCpp, sipType_wxString,&param, &paramState))
        {
             ::wxXmlNode*sipRes;

            PyErr_Clear();

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->sipProtect_GetParamNode(*param);
            Py_END_ALLOW_THREADS
            sipReleaseType(const_cast< ::wxString *>(param),sipType_wxString,paramState);

            if (PyErr_Occurred())
                return 0;

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

    sipNoMethod(sipParseErr, sipName_XmlResourceHandler, sipName_GetParamNode, SIP_NULLPTR);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_wxXmlResourceHandler_GetParamValue, "GetParamValue(param) -> String\n"
"GetParamValue(node) -> String\n"
"\n"
"Finds the parameter value or returns the empty string.\n"
"");

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

    {
        const  ::wxString* param;
        int paramState = 0;
        sipwxXmlResourceHandler *sipCpp;

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

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, SIP_NULLPTR, "BJ1", &sipSelf, sipType_wxXmlResourceHandler, &sipCpp, sipType_wxString,&param, &paramState))
        {
             ::wxString*sipRes;

            PyErr_Clear();

            Py_BEGIN_ALLOW_THREADS
            sipRes = new  ::wxString(sipCpp->sipProtect_GetParamValue(*param));
            Py_END_ALLOW_THREADS
            sipReleaseType(const_cast< ::wxString *>(param),sipType_wxString,paramState);

            if (PyErr_Occurred())
                return 0;

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

    {
        const  ::wxXmlNode* node;
        sipwxXmlResourceHandler *sipCpp;

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

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, SIP_NULLPTR, "BJ8", &sipSelf, sipType_wxXmlResourceHandler, &sipCpp, sipType_wxXmlNode, &node))
        {
             ::wxString*sipRes;

            PyErr_Clear();

            Py_BEGIN_ALLOW_THREADS
            sipRes = new  ::wxString(sipCpp->sipProtect_GetParamValue(node));
            Py_END_ALLOW_THREADS

            if (PyErr_Occurred())
                return 0;

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

    sipNoMethod(sipParseErr, sipName_XmlResourceHandler, sipName_GetParamValue, SIP_NULLPTR);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_wxXmlResourceHandler_GetPosition, "GetPosition(param=\"pos\") -> Point\n"
"\n"
"Gets the position (may be in dialog units).");

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

    {
        const  ::wxString& paramdef = "pos";
        const  ::wxString* param = &paramdef;
        int paramState = 0;
        sipwxXmlResourceHandler *sipCpp;

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

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, SIP_NULLPTR, "B|J1", &sipSelf, sipType_wxXmlResourceHandler, &sipCpp, sipType_wxString,&param, &paramState))
        {
             ::wxPoint*sipRes;

            PyErr_Clear();

            Py_BEGIN_ALLOW_THREADS
            sipRes = new  ::wxPoint(sipCpp->sipProtect_GetPosition(*param));
            Py_END_ALLOW_THREADS
            sipReleaseType(const_cast< ::wxString *>(param),sipType_wxString,paramState);

            if (PyErr_Occurred())
                return 0;

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

    sipNoMethod(sipParseErr, sipName_XmlResourceHandler, sipName_GetPosition, SIP_NULLPTR);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_wxXmlResourceHandler_GetSize, "GetSize(param=\"size\", windowToUse=0) -> Size\n"
"\n"
"Gets the size (may be in dialog units).");

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

    {
        const  ::wxString& paramdef = "size";
        const  ::wxString* param = &paramdef;
        int paramState = 0;
         ::wxWindow* windowToUse = 0;
        sipwxXmlResourceHandler *sipCpp;

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

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, SIP_NULLPTR, "B|J1J8", &sipSelf, sipType_wxXmlResourceHandler, &sipCpp, sipType_wxString,&param, &paramState, sipType_wxWindow, &windowToUse))
        {
             ::wxSize*sipRes;

            PyErr_Clear();

            Py_BEGIN_ALLOW_THREADS
            sipRes = new  ::wxSize(sipCpp->sipProtect_GetSize(*param,windowToUse));
            Py_END_ALLOW_THREADS
            sipReleaseType(const_cast< ::wxString *>(param),sipType_wxString,paramState);

            if (PyErr_Occurred())
                return 0;

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

    sipNoMethod(sipParseErr, sipName_XmlResourceHandler, sipName_GetSize, SIP_NULLPTR);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_wxXmlResourceHandler_GetStyle, "GetStyle(param=\"style\", defaults=0) -> int\n"
"\n"
"Gets style flags from text in form \"flag | flag2| flag3 |...\" Only\n"
"understands flags added with AddStyle().");

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

    {
        const  ::wxString& paramdef = "style";
        const  ::wxString* param = &paramdef;
        int paramState = 0;
        int defaults = 0;
        sipwxXmlResourceHandler *sipCpp;

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

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, SIP_NULLPTR, "B|J1i", &sipSelf, sipType_wxXmlResourceHandler, &sipCpp, sipType_wxString,&param, &paramState, &defaults))
        {
            int sipRes;

            PyErr_Clear();

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->sipProtect_GetStyle(*param,defaults);
            Py_END_ALLOW_THREADS
            sipReleaseType(const_cast< ::wxString *>(param),sipType_wxString,paramState);

            if (PyErr_Occurred())
                return 0;

            return SIPLong_FromLong(sipRes);
        }
    }

    sipNoMethod(sipParseErr, sipName_XmlResourceHandler, sipName_GetStyle, SIP_NULLPTR);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_wxXmlResourceHandler_GetText, "GetText(param, translate=True) -> String\n"
"\n"
"Gets text from param and does some conversions:");

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

    {
        const  ::wxString* param;
        int paramState = 0;
        bool translate = 1;
        sipwxXmlResourceHandler *sipCpp;

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

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, SIP_NULLPTR, "BJ1|b", &sipSelf, sipType_wxXmlResourceHandler, &sipCpp, sipType_wxString,&param, &paramState, &translate))
        {
             ::wxString*sipRes;

            PyErr_Clear();

            Py_BEGIN_ALLOW_THREADS
            sipRes = new  ::wxString(sipCpp->sipProtect_GetText(*param,translate));
            Py_END_ALLOW_THREADS
            sipReleaseType(const_cast< ::wxString *>(param),sipType_wxString,paramState);

            if (PyErr_Occurred())
                return 0;

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

    sipNoMethod(sipParseErr, sipName_XmlResourceHandler, sipName_GetText, SIP_NULLPTR);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_wxXmlResourceHandler_HasParam, "HasParam(param) -> bool\n"
"\n"
"Check to see if a parameter exists.");

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

    {
        const  ::wxString* param;
        int paramState = 0;
        sipwxXmlResourceHandler *sipCpp;

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

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, SIP_NULLPTR, "BJ1", &sipSelf, sipType_wxXmlResourceHandler, &sipCpp, sipType_wxString,&param, &paramState))
        {
            bool sipRes;

            PyErr_Clear();

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->sipProtect_HasParam(*param);
            Py_END_ALLOW_THREADS
            sipReleaseType(const_cast< ::wxString *>(param),sipType_wxString,paramState);

            if (PyErr_Occurred())
                return 0;

            return PyBool_FromLong(sipRes);
        }
    }

    sipNoMethod(sipParseErr, sipName_XmlResourceHandler, sipName_HasParam, SIP_NULLPTR);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_wxXmlResourceHandler_IsOfClass, "IsOfClass(node, classname) -> bool\n"
"\n"
"Convenience function.");

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

    {
         ::wxXmlNode* node;
        const  ::wxString* classname;
        int classnameState = 0;
        sipwxXmlResourceHandler *sipCpp;

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

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, SIP_NULLPTR, "BJ8J1", &sipSelf, sipType_wxXmlResourceHandler, &sipCpp, sipType_wxXmlNode, &node, sipType_wxString,&classname, &classnameState))
        {
            bool sipRes;

            PyErr_Clear();

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->sipProtect_IsOfClass(node,*classname);
            Py_END_ALLOW_THREADS
            sipReleaseType(const_cast< ::wxString *>(classname),sipType_wxString,classnameState);

            if (PyErr_Occurred())
                return 0;

            return PyBool_FromLong(sipRes);
        }
    }

    sipNoMethod(sipParseErr, sipName_XmlResourceHandler, sipName_IsOfClass, SIP_NULLPTR);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_wxXmlResourceHandler_SetupWindow, "SetupWindow(wnd)\n"
"\n"
"Sets common window options.");

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

    {
         ::wxWindow* wnd;
        sipwxXmlResourceHandler *sipCpp;

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

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, SIP_NULLPTR, "BJ8", &sipSelf, sipType_wxXmlResourceHandler, &sipCpp, sipType_wxWindow, &wnd))
        {
            PyErr_Clear();

            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtect_SetupWindow(wnd);
            Py_END_ALLOW_THREADS

            if (PyErr_Occurred())
                return 0;

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    sipNoMethod(sipParseErr, sipName_XmlResourceHandler, sipName_SetupWindow, SIP_NULLPTR);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_wxXmlResourceHandler_ReportError, "ReportError(context, message)\n"
"ReportError(message)\n"
"\n"
"Reports error in XRC resources to the user.\n"
"");

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

    {
         ::wxXmlNode* context;
        const  ::wxString* message;
        int messageState = 0;
        sipwxXmlResourceHandler *sipCpp;

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

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, SIP_NULLPTR, "BJ8J1", &sipSelf, sipType_wxXmlResourceHandler, &sipCpp, sipType_wxXmlNode, &context, sipType_wxString,&message, &messageState))
        {
            PyErr_Clear();

            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtect_ReportError(context,*message);
            Py_END_ALLOW_THREADS
            sipReleaseType(const_cast< ::wxString *>(message),sipType_wxString,messageState);

            if (PyErr_Occurred())
                return 0;

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    {
        const  ::wxString* message;
        int messageState = 0;
        sipwxXmlResourceHandler *sipCpp;

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

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, SIP_NULLPTR, "BJ1", &sipSelf, sipType_wxXmlResourceHandler, &sipCpp, sipType_wxString,&message, &messageState))
        {
            PyErr_Clear();

            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtect_ReportError(*message);
            Py_END_ALLOW_THREADS
            sipReleaseType(const_cast< ::wxString *>(message),sipType_wxString,messageState);

            if (PyErr_Occurred())
                return 0;

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    sipNoMethod(sipParseErr, sipName_XmlResourceHandler, sipName_ReportError, SIP_NULLPTR);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_wxXmlResourceHandler_ReportParamError, "ReportParamError(param, message)\n"
"\n"
"Like ReportError(wxXmlNode*, const wxString&), but uses the node of\n"
"parameter param of the currently processed object as the context.");

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

    {
        const  ::wxString* param;
        int paramState = 0;
        const  ::wxString* message;
        int messageState = 0;
        sipwxXmlResourceHandler *sipCpp;

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

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, SIP_NULLPTR, "BJ1J1", &sipSelf, sipType_wxXmlResourceHandler, &sipCpp, sipType_wxString,&param, &paramState, sipType_wxString,&message, &messageState))
        {
            PyErr_Clear();

            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtect_ReportParamError(*param,*message);
            Py_END_ALLOW_THREADS
            sipReleaseType(const_cast< ::wxString *>(param),sipType_wxString,paramState);
            sipReleaseType(const_cast< ::wxString *>(message),sipType_wxString,messageState);

            if (PyErr_Occurred())
                return 0;

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    sipNoMethod(sipParseErr, sipName_XmlResourceHandler, sipName_ReportParamError, SIP_NULLPTR);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_wxXmlResourceHandler_GetResource, "GetResource() -> XmlResource\n"
"\n"
"After CreateResource has been called this will return the current\n"
"wxXmlResource object.");

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

    {
        const sipwxXmlResourceHandler *sipCpp;

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

            PyErr_Clear();

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->sipProtect_GetResource();
            Py_END_ALLOW_THREADS

            if (PyErr_Occurred())
                return 0;

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

    sipNoMethod(sipParseErr, sipName_XmlResourceHandler, sipName_GetResource, SIP_NULLPTR);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_wxXmlResourceHandler_GetNode, "GetNode() -> XmlNode\n"
"\n"
"After CreateResource has been called this will return the XML node\n"
"being processed.");

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

    {
        const sipwxXmlResourceHandler *sipCpp;

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

            PyErr_Clear();

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->sipProtect_GetNode();
            Py_END_ALLOW_THREADS

            if (PyErr_Occurred())
                return 0;

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

    sipNoMethod(sipParseErr, sipName_XmlResourceHandler, sipName_GetNode, SIP_NULLPTR);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_wxXmlResourceHandler_GetClass, "GetClass() -> String\n"
"\n"
"After CreateResource has been called this will return the class name\n"
"of the XML resource node being processed.");

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

    {
        const sipwxXmlResourceHandler *sipCpp;

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

            PyErr_Clear();

            Py_BEGIN_ALLOW_THREADS
            sipRes = new  ::wxString(sipCpp->sipProtect_GetClass());
            Py_END_ALLOW_THREADS

            if (PyErr_Occurred())
                return 0;

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

    sipNoMethod(sipParseErr, sipName_XmlResourceHandler, sipName_GetClass, SIP_NULLPTR);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_wxXmlResourceHandler_GetParent, "GetParent() -> Object\n"
"\n"
"After CreateResource has been called this will return the current\n"
"item's parent, if any.");

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

    {
        const sipwxXmlResourceHandler *sipCpp;

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

            PyErr_Clear();

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->sipProtect_GetParent();
            Py_END_ALLOW_THREADS

            if (PyErr_Occurred())
                return 0;

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

    sipNoMethod(sipParseErr, sipName_XmlResourceHandler, sipName_GetParent, SIP_NULLPTR);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_wxXmlResourceHandler_GetInstance, "GetInstance() -> Object\n"
"\n"
"After CreateResource has been called this will return the instance\n"
"that the XML resource content should be created upon, if it has\n"
"already been created.");

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

    {
        const sipwxXmlResourceHandler *sipCpp;

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

            PyErr_Clear();

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->sipProtect_GetInstance();
            Py_END_ALLOW_THREADS

            if (PyErr_Occurred())
                return 0;

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

    sipNoMethod(sipParseErr, sipName_XmlResourceHandler, sipName_GetInstance, SIP_NULLPTR);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_wxXmlResourceHandler_GetParentAsWindow, "GetParentAsWindow() -> Window\n"
"\n"
"After CreateResource has been called this will return the item's\n"
"parent as a wxWindow.");

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

    {
        const sipwxXmlResourceHandler *sipCpp;

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

            PyErr_Clear();

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->sipProtect_GetParentAsWindow();
            Py_END_ALLOW_THREADS

            if (PyErr_Occurred())
                return 0;

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

    sipNoMethod(sipParseErr, sipName_XmlResourceHandler, sipName_GetParentAsWindow, SIP_NULLPTR);

    return SIP_NULLPTR;
}


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

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

    return sipCppV;
}


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

    if (sipState & SIP_DERIVED_CLASS)
        delete reinterpret_cast<sipwxXmlResourceHandler *>(sipCppV);
    else
        delete reinterpret_cast< ::wxXmlResourceHandler *>(sipCppV);

    Py_END_ALLOW_THREADS
}


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

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


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

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

            Py_BEGIN_ALLOW_THREADS
            sipCpp = new sipwxXmlResourceHandler();
            Py_END_ALLOW_THREADS

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

            sipCpp->sipPySelf = sipSelf;

            return sipCpp;
        }
    }

    {
        const  ::wxXmlResourceHandler* a0;

        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, SIP_NULLPTR, sipUnused, "J9", sipType_wxXmlResourceHandler, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp = new sipwxXmlResourceHandler(*a0);
            Py_END_ALLOW_THREADS

            sipCpp->sipPySelf = sipSelf;

            return sipCpp;
        }
    }

    return SIP_NULLPTR;
}


/* Define this type's super-types. */
static sipEncodedTypeDef supers_wxXmlResourceHandler[] = {{13, 0, 1}};


static PyMethodDef methods_wxXmlResourceHandler[] = {
    {SIP_MLNAME_CAST(sipName_AddStyle), SIP_MLMETH_CAST(meth_wxXmlResourceHandler_AddStyle), METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_wxXmlResourceHandler_AddStyle)},
    {SIP_MLNAME_CAST(sipName_AddWindowStyles), meth_wxXmlResourceHandler_AddWindowStyles, METH_VARARGS, SIP_MLDOC_CAST(doc_wxXmlResourceHandler_AddWindowStyles)},
    {SIP_MLNAME_CAST(sipName_CanHandle), SIP_MLMETH_CAST(meth_wxXmlResourceHandler_CanHandle), METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_wxXmlResourceHandler_CanHandle)},
    {SIP_MLNAME_CAST(sipName_CreateChildren), SIP_MLMETH_CAST(meth_wxXmlResourceHandler_CreateChildren), METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_wxXmlResourceHandler_CreateChildren)},
    {SIP_MLNAME_CAST(sipName_CreateChildrenPrivately), SIP_MLMETH_CAST(meth_wxXmlResourceHandler_CreateChildrenPrivately), METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_wxXmlResourceHandler_CreateChildrenPrivately)},
    {SIP_MLNAME_CAST(sipName_CreateResFromNode), SIP_MLMETH_CAST(meth_wxXmlResourceHandler_CreateResFromNode), METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_wxXmlResourceHandler_CreateResFromNode)},
    {SIP_MLNAME_CAST(sipName_CreateResource), SIP_MLMETH_CAST(meth_wxXmlResourceHandler_CreateResource), METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_wxXmlResourceHandler_CreateResource)},
    {SIP_MLNAME_CAST(sipName_DoCreateResource), meth_wxXmlResourceHandler_DoCreateResource, METH_VARARGS, SIP_MLDOC_CAST(doc_wxXmlResourceHandler_DoCreateResource)},
    {SIP_MLNAME_CAST(sipName_GetAnimation), SIP_MLMETH_CAST(meth_wxXmlResourceHandler_GetAnimation), METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_wxXmlResourceHandler_GetAnimation)},
    {SIP_MLNAME_CAST(sipName_GetBitmap), SIP_MLMETH_CAST(meth_wxXmlResourceHandler_GetBitmap), METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_wxXmlResourceHandler_GetBitmap)},
    {SIP_MLNAME_CAST(sipName_GetBool), SIP_MLMETH_CAST(meth_wxXmlResourceHandler_GetBool), METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_wxXmlResourceHandler_GetBool)},
    {SIP_MLNAME_CAST(sipName_GetClass), meth_wxXmlResourceHandler_GetClass, METH_VARARGS, SIP_MLDOC_CAST(doc_wxXmlResourceHandler_GetClass)},
    {SIP_MLNAME_CAST(sipName_GetColour), SIP_MLMETH_CAST(meth_wxXmlResourceHandler_GetColour), METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_wxXmlResourceHandler_GetColour)},
    {SIP_MLNAME_CAST(sipName_GetCurFileSystem), meth_wxXmlResourceHandler_GetCurFileSystem, METH_VARARGS, SIP_MLDOC_CAST(doc_wxXmlResourceHandler_GetCurFileSystem)},
    {SIP_MLNAME_CAST(sipName_GetDimension), SIP_MLMETH_CAST(meth_wxXmlResourceHandler_GetDimension), METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_wxXmlResourceHandler_GetDimension)},
    {SIP_MLNAME_CAST(sipName_GetDirection), SIP_MLMETH_CAST(meth_wxXmlResourceHandler_GetDirection), METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_wxXmlResourceHandler_GetDirection)},
    {SIP_MLNAME_CAST(sipName_GetFloat), SIP_MLMETH_CAST(meth_wxXmlResourceHandler_GetFloat), METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_wxXmlResourceHandler_GetFloat)},
    {SIP_MLNAME_CAST(sipName_GetFont), SIP_MLMETH_CAST(meth_wxXmlResourceHandler_GetFont), METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_wxXmlResourceHandler_GetFont)},
    {SIP_MLNAME_CAST(sipName_GetID), meth_wxXmlResourceHandler_GetID, METH_VARARGS, SIP_MLDOC_CAST(doc_wxXmlResourceHandler_GetID)},
    {SIP_MLNAME_CAST(sipName_GetIcon), SIP_MLMETH_CAST(meth_wxXmlResourceHandler_GetIcon), METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_wxXmlResourceHandler_GetIcon)},
    {SIP_MLNAME_CAST(sipName_GetIconBundle), SIP_MLMETH_CAST(meth_wxXmlResourceHandler_GetIconBundle), METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_wxXmlResourceHandler_GetIconBundle)},
    {SIP_MLNAME_CAST(sipName_GetImageList), SIP_MLMETH_CAST(meth_wxXmlResourceHandler_GetImageList), METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_wxXmlResourceHandler_GetImageList)},
    {SIP_MLNAME_CAST(sipName_GetInstance), meth_wxXmlResourceHandler_GetInstance, METH_VARARGS, SIP_MLDOC_CAST(doc_wxXmlResourceHandler_GetInstance)},
    {SIP_MLNAME_CAST(sipName_GetLong), SIP_MLMETH_CAST(meth_wxXmlResourceHandler_GetLong), METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_wxXmlResourceHandler_GetLong)},
    {SIP_MLNAME_CAST(sipName_GetName), meth_wxXmlResourceHandler_GetName, METH_VARARGS, SIP_MLDOC_CAST(doc_wxXmlResourceHandler_GetName)},
    {SIP_MLNAME_CAST(sipName_GetNode), meth_wxXmlResourceHandler_GetNode, METH_VARARGS, SIP_MLDOC_CAST(doc_wxXmlResourceHandler_GetNode)},
    {SIP_MLNAME_CAST(sipName_GetNodeChildren), SIP_MLMETH_CAST(meth_wxXmlResourceHandler_GetNodeChildren), METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_wxXmlResourceHandler_GetNodeChildren)},
    {SIP_MLNAME_CAST(sipName_GetNodeContent), SIP_MLMETH_CAST(meth_wxXmlResourceHandler_GetNodeContent), METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_wxXmlResourceHandler_GetNodeContent)},
    {SIP_MLNAME_CAST(sipName_GetNodeNext), SIP_MLMETH_CAST(meth_wxXmlResourceHandler_GetNodeNext), METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_wxXmlResourceHandler_GetNodeNext)},
    {SIP_MLNAME_CAST(sipName_GetNodeParent), SIP_MLMETH_CAST(meth_wxXmlResourceHandler_GetNodeParent), METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_wxXmlResourceHandler_GetNodeParent)},
    {SIP_MLNAME_CAST(sipName_GetParamNode), SIP_MLMETH_CAST(meth_wxXmlResourceHandler_GetParamNode), METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_wxXmlResourceHandler_GetParamNode)},
    {SIP_MLNAME_CAST(sipName_GetParamValue), SIP_MLMETH_CAST(meth_wxXmlResourceHandler_GetParamValue), METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_wxXmlResourceHandler_GetParamValue)},
    {SIP_MLNAME_CAST(sipName_GetParent), meth_wxXmlResourceHandler_GetParent, METH_VARARGS, SIP_MLDOC_CAST(doc_wxXmlResourceHandler_GetParent)},
    {SIP_MLNAME_CAST(sipName_GetParentAsWindow), meth_wxXmlResourceHandler_GetParentAsWindow, METH_VARARGS, SIP_MLDOC_CAST(doc_wxXmlResourceHandler_GetParentAsWindow)},
    {SIP_MLNAME_CAST(sipName_GetPosition), SIP_MLMETH_CAST(meth_wxXmlResourceHandler_GetPosition), METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_wxXmlResourceHandler_GetPosition)},
    {SIP_MLNAME_CAST(sipName_GetResource), meth_wxXmlResourceHandler_GetResource, METH_VARARGS, SIP_MLDOC_CAST(doc_wxXmlResourceHandler_GetResource)},
    {SIP_MLNAME_CAST(sipName_GetSize), SIP_MLMETH_CAST(meth_wxXmlResourceHandler_GetSize), METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_wxXmlResourceHandler_GetSize)},
    {SIP_MLNAME_CAST(sipName_GetStyle), SIP_MLMETH_CAST(meth_wxXmlResourceHandler_GetStyle), METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_wxXmlResourceHandler_GetStyle)},
    {SIP_MLNAME_CAST(sipName_GetText), SIP_MLMETH_CAST(meth_wxXmlResourceHandler_GetText), METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_wxXmlResourceHandler_GetText)},
    {SIP_MLNAME_CAST(sipName_HasParam), SIP_MLMETH_CAST(meth_wxXmlResourceHandler_HasParam), METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_wxXmlResourceHandler_HasParam)},
    {SIP_MLNAME_CAST(sipName_IsObjectNode), SIP_MLMETH_CAST(meth_wxXmlResourceHandler_IsObjectNode), METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_wxXmlResourceHandler_IsObjectNode)},
    {SIP_MLNAME_CAST(sipName_IsOfClass), SIP_MLMETH_CAST(meth_wxXmlResourceHandler_IsOfClass), METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_wxXmlResourceHandler_IsOfClass)},
    {SIP_MLNAME_CAST(sipName_ReportError), SIP_MLMETH_CAST(meth_wxXmlResourceHandler_ReportError), METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_wxXmlResourceHandler_ReportError)},
    {SIP_MLNAME_CAST(sipName_ReportParamError), SIP_MLMETH_CAST(meth_wxXmlResourceHandler_ReportParamError), METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_wxXmlResourceHandler_ReportParamError)},
    {SIP_MLNAME_CAST(sipName_SetParentResource), SIP_MLMETH_CAST(meth_wxXmlResourceHandler_SetParentResource), METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_wxXmlResourceHandler_SetParentResource)},
    {SIP_MLNAME_CAST(sipName_SetupWindow), SIP_MLMETH_CAST(meth_wxXmlResourceHandler_SetupWindow), METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_wxXmlResourceHandler_SetupWindow)}
};

sipVariableDef variables_wxXmlResourceHandler[] = {
    {PropertyVariable, sipName_Style, &methods_wxXmlResourceHandler[37], SIP_NULLPTR, SIP_NULLPTR, SIP_NULLPTR},
    {PropertyVariable, sipName_Size, &methods_wxXmlResourceHandler[36], SIP_NULLPTR, SIP_NULLPTR, SIP_NULLPTR},
    {PropertyVariable, sipName_Resource, &methods_wxXmlResourceHandler[35], SIP_NULLPTR, SIP_NULLPTR, SIP_NULLPTR},
    {PropertyVariable, sipName_Position, &methods_wxXmlResourceHandler[34], SIP_NULLPTR, SIP_NULLPTR, SIP_NULLPTR},
    {PropertyVariable, sipName_ParentAsWindow, &methods_wxXmlResourceHandler[33], SIP_NULLPTR, SIP_NULLPTR, SIP_NULLPTR},
    {PropertyVariable, sipName_Parent, &methods_wxXmlResourceHandler[32], SIP_NULLPTR, SIP_NULLPTR, SIP_NULLPTR},
    {PropertyVariable, sipName_Node, &methods_wxXmlResourceHandler[25], SIP_NULLPTR, SIP_NULLPTR, SIP_NULLPTR},
    {PropertyVariable, sipName_Name, &methods_wxXmlResourceHandler[24], SIP_NULLPTR, SIP_NULLPTR, SIP_NULLPTR},
    {PropertyVariable, sipName_Instance, &methods_wxXmlResourceHandler[22], SIP_NULLPTR, SIP_NULLPTR, SIP_NULLPTR},
    {PropertyVariable, sipName_ImageList, &methods_wxXmlResourceHandler[21], SIP_NULLPTR, SIP_NULLPTR, SIP_NULLPTR},
    {PropertyVariable, sipName_Icon, &methods_wxXmlResourceHandler[19], SIP_NULLPTR, SIP_NULLPTR, SIP_NULLPTR},
    {PropertyVariable, sipName_ID, &methods_wxXmlResourceHandler[18], SIP_NULLPTR, SIP_NULLPTR, SIP_NULLPTR},
    {PropertyVariable, sipName_Font, &methods_wxXmlResourceHandler[17], SIP_NULLPTR, SIP_NULLPTR, SIP_NULLPTR},
    {PropertyVariable, sipName_CurFileSystem, &methods_wxXmlResourceHandler[13], SIP_NULLPTR, SIP_NULLPTR, SIP_NULLPTR},
    {PropertyVariable, sipName_Class, &methods_wxXmlResourceHandler[11], SIP_NULLPTR, SIP_NULLPTR, SIP_NULLPTR},
    {PropertyVariable, sipName_Bitmap, &methods_wxXmlResourceHandler[9], SIP_NULLPTR, SIP_NULLPTR, SIP_NULLPTR},
    {PropertyVariable, sipName_Animation, &methods_wxXmlResourceHandler[8], SIP_NULLPTR, SIP_NULLPTR, SIP_NULLPTR},
};

PyDoc_STRVAR(doc_wxXmlResourceHandler, "XmlResourceHandler()\n"
"\n"
"wxSizerXmlHandler is a class for resource handlers capable of creating\n"
"a wxSizer object from an XML node.");


sipClassTypeDef sipTypeDef__xrc_wxXmlResourceHandler = {
    {
        -1,
        SIP_NULLPTR,
        SIP_NULLPTR,
        SIP_TYPE_ABSTRACT|SIP_TYPE_SCC|SIP_TYPE_CLASS,
        sipNameNr_wxXmlResourceHandler,
        {SIP_NULLPTR},
        SIP_NULLPTR
    },
    {
        sipNameNr_XmlResourceHandler,
        {0, 0, 1},
        46, methods_wxXmlResourceHandler,
        0, SIP_NULLPTR,
        17, variables_wxXmlResourceHandler,
        {SIP_NULLPTR, SIP_NULLPTR, SIP_NULLPTR, SIP_NULLPTR, SIP_NULLPTR, SIP_NULLPTR, SIP_NULLPTR, SIP_NULLPTR, SIP_NULLPTR, SIP_NULLPTR},
    },
    doc_wxXmlResourceHandler,
    -1,
    -1,
    supers_wxXmlResourceHandler,
    SIP_NULLPTR,
    init_type_wxXmlResourceHandler,
    SIP_NULLPTR,
    SIP_NULLPTR,
#if PY_MAJOR_VERSION >= 3
    SIP_NULLPTR,
    SIP_NULLPTR,
#else
    SIP_NULLPTR,
    SIP_NULLPTR,
    SIP_NULLPTR,
    SIP_NULLPTR,
#endif
    dealloc_wxXmlResourceHandler,
    SIP_NULLPTR,
    SIP_NULLPTR,
    SIP_NULLPTR,
    release_wxXmlResourceHandler,
    cast_wxXmlResourceHandler,
    SIP_NULLPTR,
    SIP_NULLPTR,
    SIP_NULLPTR,
    SIP_NULLPTR,
    SIP_NULLPTR,
    SIP_NULLPTR
};
