/*
 * Interface wrapper code.
 *
 * Generated by SIP 6.15.1
 *
 *     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/bmpbndl.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);
    ::wxBitmapBundle sipProtect_GetBitmapBundle(const ::wxString&, const ::wxArtClient&, ::wxSize);
    ::wxBitmapBundle sipProtect_GetBitmapBundle(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);
}

::wxBitmapBundle sipwxXmlResourceHandler::sipProtect_GetBitmapBundle(const ::wxString& param, const ::wxArtClient& defaultArtClient, ::wxSize size)
{
    return ::wxXmlResourceHandler::GetBitmapBundle(param, defaultArtClient, size);
}

::wxBitmapBundle sipwxXmlResourceHandler::sipProtect_GetBitmapBundle(const ::wxXmlNode*node, const ::wxArtClient& defaultArtClient, ::wxSize size)
{
    return ::wxXmlResourceHandler::GetBitmapBundle(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) -> None\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) -> None\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() -> None\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) -> None\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) -> 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_GetBitmapBundle, "GetBitmapBundle(param=\"bitmap\", defaultArtClient=ART_OTHER, size=DefaultSize) -> BitmapBundle\n"
"GetBitmapBundle(node, defaultArtClient=ART_OTHER, size=DefaultSize) -> BitmapBundle\n"
"\n"
"Gets a bitmap bundle.\n"
"");

extern "C" {static PyObject *meth_wxXmlResourceHandler_GetBitmapBundle(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_wxXmlResourceHandler_GetBitmapBundle(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))
        {
            ::wxBitmapBundle*sipRes;

            PyErr_Clear();

            Py_BEGIN_ALLOW_THREADS
            sipRes = new ::wxBitmapBundle(sipCpp->sipProtect_GetBitmapBundle(*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_wxBitmapBundle, 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))
        {
            ::wxBitmapBundle*sipRes;

            PyErr_Clear();

            Py_BEGIN_ALLOW_THREADS
            sipRes = new ::wxBitmapBundle(sipCpp->sipProtect_GetBitmapBundle(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_wxBitmapBundle, SIP_NULLPTR);
        }
    }

    sipNoMethod(sipParseErr, sipName_XmlResourceHandler, sipName_GetBitmapBundle, 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) -> int\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 PyLong_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 PyLong_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) -> int\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() -> str\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) -> str\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) -> str\n"
"GetParamValue(node) -> str\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 PyLong_FromLong(sipRes);
        }
    }

    sipNoMethod(sipParseErr, sipName_XmlResourceHandler, sipName_GetStyle, SIP_NULLPTR);

    return SIP_NULLPTR;
}


PyDoc_STRVAR(doc_wxXmlResourceHandler_GetText, "GetText(param, translate=True) -> str\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) -> None\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) -> None\n"
"ReportError(message) -> None\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) -> None\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() -> str\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_wxXmlResourceHandler)
        return sipCppV;

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

    return SIP_NULLPTR;
}


/* 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[] = {{14, 0, 1}};


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

sipVariableDef variables_wxXmlResourceHandler[] = {
    {PropertyVariable, sipName_Style, &methods_wxXmlResourceHandler[38], SIP_NULLPTR, SIP_NULLPTR, SIP_NULLPTR},
    {PropertyVariable, sipName_Size, &methods_wxXmlResourceHandler[37], SIP_NULLPTR, SIP_NULLPTR, SIP_NULLPTR},
    {PropertyVariable, sipName_Resource, &methods_wxXmlResourceHandler[36], SIP_NULLPTR, SIP_NULLPTR, SIP_NULLPTR},
    {PropertyVariable, sipName_Position, &methods_wxXmlResourceHandler[35], SIP_NULLPTR, SIP_NULLPTR, SIP_NULLPTR},
    {PropertyVariable, sipName_ParentAsWindow, &methods_wxXmlResourceHandler[34], SIP_NULLPTR, SIP_NULLPTR, SIP_NULLPTR},
    {PropertyVariable, sipName_Parent, &methods_wxXmlResourceHandler[33], SIP_NULLPTR, SIP_NULLPTR, SIP_NULLPTR},
    {PropertyVariable, sipName_Node, &methods_wxXmlResourceHandler[26], SIP_NULLPTR, SIP_NULLPTR, SIP_NULLPTR},
    {PropertyVariable, sipName_Name, &methods_wxXmlResourceHandler[25], SIP_NULLPTR, SIP_NULLPTR, SIP_NULLPTR},
    {PropertyVariable, sipName_Instance, &methods_wxXmlResourceHandler[23], SIP_NULLPTR, SIP_NULLPTR, SIP_NULLPTR},
    {PropertyVariable, sipName_ImageList, &methods_wxXmlResourceHandler[22], SIP_NULLPTR, SIP_NULLPTR, SIP_NULLPTR},
    {PropertyVariable, sipName_Icon, &methods_wxXmlResourceHandler[20], SIP_NULLPTR, SIP_NULLPTR, SIP_NULLPTR},
    {PropertyVariable, sipName_ID, &methods_wxXmlResourceHandler[19], SIP_NULLPTR, SIP_NULLPTR, SIP_NULLPTR},
    {PropertyVariable, sipName_Font, &methods_wxXmlResourceHandler[18], SIP_NULLPTR, SIP_NULLPTR, SIP_NULLPTR},
    {PropertyVariable, sipName_CurFileSystem, &methods_wxXmlResourceHandler[14], SIP_NULLPTR, SIP_NULLPTR, SIP_NULLPTR},
    {PropertyVariable, sipName_Class, &methods_wxXmlResourceHandler[12], SIP_NULLPTR, SIP_NULLPTR, SIP_NULLPTR},
    {PropertyVariable, sipName_BitmapBundle, &methods_wxXmlResourceHandler[10], 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() -> None\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},
        47, methods_wxXmlResourceHandler,
        0, SIP_NULLPTR,
        18, 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,
    SIP_NULLPTR,
    SIP_NULLPTR,
    dealloc_wxXmlResourceHandler,
    SIP_NULLPTR,
    SIP_NULLPTR,
    SIP_NULLPTR,
    release_wxXmlResourceHandler,
    cast_wxXmlResourceHandler,
    SIP_NULLPTR,
    SIP_NULLPTR,
    SIP_NULLPTR,
    SIP_NULLPTR,
    SIP_NULLPTR,
    SIP_NULLPTR,
    SIP_NULLPTR,
    sizeof (::wxXmlResourceHandler),
};
