/*
 * This file was generated automatically by ExtUtils::ParseXS version 3.22 from the
 * contents of GtkWidget.xs. Do not edit this file, edit GtkWidget.xs instead.
 *
 *    ANY CHANGES MADE HERE WILL BE LOST!
 *
 */

#line 1 "xs/GtkWidget.xs"
/*
 * Copyright (c) 2003-2006, 2009, 2010, 2012 by the gtk2-perl team (see the
 * file AUTHORS)
 *
 * Licensed under the LGPL, see LICENSE file for more information.
 *
 * $Id$
 */
#include "gtk2perl.h"

static void
_INSTALL_OVERRIDES (const char * package)
{
    GType gtype;
    guint signal_id;

    gtype = gperl_object_type_from_package (package);
    if (!gtype)
        croak ("package '%s' is not registered with Gtk2-Perl",
                package);
    if (! g_type_is_a (gtype, GTK_TYPE_WIDGET))
        croak ("%s(%s) is not a GtkWidget",
                package, g_type_name (gtype));

    /*
     * GtkWidgets may implement "native scrolling".  Such widgets can
     * be told to use scroll adjustments with the method
     * gtk_widget_set_scroll_adjustments(), which emits the signal whose
     * id is stored in GtkWidgetClass::set_scroll_adjustments_signal.
     * Since we have limited support for class-init, we'll add the
     * somewhat sensible restriction that the signal named
     * "set-scroll-adjustments" is for that purpose.
     */
    signal_id = g_signal_lookup ("set-scroll-adjustments", gtype);
    if (signal_id) {
        GSignalQuery query;

        /* verify that the signal is valid for this purpose. */
        g_signal_query (signal_id, &query);

        /* Note: we are interested iff the signal is defined by the
         * exact type we're initializing.  Do NOT do this for inherited
         * signals. */
        if (query.itype == gtype) {
            if (query.return_type == G_TYPE_NONE &&
                    query.n_params == 2 &&
                    g_type_is_a (query.param_types[0], GTK_TYPE_ADJUSTMENT) &&
                    g_type_is_a (query.param_types[1], GTK_TYPE_ADJUSTMENT)) {
                GtkWidgetClass * class;

                class = g_type_class_peek (gtype);
                g_assert (class);

                class->set_scroll_adjustments_signal = signal_id;
            } else {
                warn ("Signal %s on %s is an invalid set-scroll-"
                        "adjustments signal.  A set-scroll-adjustments "
                        "signal must have no return type and take "
                        "exactly two Gtk2::Adjustment parameters.  "
                        "Ignoring", query.signal_name, package);
            }
        }
    }
}

#line 76 "xs/GtkWidget.c"
#ifndef PERL_UNUSED_VAR
#  define PERL_UNUSED_VAR(var) if (0) var = var
#endif

#ifndef dVAR
#  define dVAR		dNOOP
#endif


/* This stuff is not part of the API! You have been warned. */
#ifndef PERL_VERSION_DECIMAL
#  define PERL_VERSION_DECIMAL(r,v,s) (r*1000000 + v*1000 + s)
#endif
#ifndef PERL_DECIMAL_VERSION
#  define PERL_DECIMAL_VERSION \
	  PERL_VERSION_DECIMAL(PERL_REVISION,PERL_VERSION,PERL_SUBVERSION)
#endif
#ifndef PERL_VERSION_GE
#  define PERL_VERSION_GE(r,v,s) \
	  (PERL_DECIMAL_VERSION >= PERL_VERSION_DECIMAL(r,v,s))
#endif
#ifndef PERL_VERSION_LE
#  define PERL_VERSION_LE(r,v,s) \
	  (PERL_DECIMAL_VERSION <= PERL_VERSION_DECIMAL(r,v,s))
#endif

/* XS_INTERNAL is the explicit static-linkage variant of the default
 * XS macro.
 *
 * XS_EXTERNAL is the same as XS_INTERNAL except it does not include
 * "STATIC", ie. it exports XSUB symbols. You probably don't want that
 * for anything but the BOOT XSUB.
 *
 * See XSUB.h in core!
 */


/* TODO: This might be compatible further back than 5.10.0. */
#if PERL_VERSION_GE(5, 10, 0) && PERL_VERSION_LE(5, 15, 1)
#  undef XS_EXTERNAL
#  undef XS_INTERNAL
#  if defined(__CYGWIN__) && defined(USE_DYNAMIC_LOADING)
#    define XS_EXTERNAL(name) __declspec(dllexport) XSPROTO(name)
#    define XS_INTERNAL(name) STATIC XSPROTO(name)
#  endif
#  if defined(__SYMBIAN32__)
#    define XS_EXTERNAL(name) EXPORT_C XSPROTO(name)
#    define XS_INTERNAL(name) EXPORT_C STATIC XSPROTO(name)
#  endif
#  ifndef XS_EXTERNAL
#    if defined(HASATTRIBUTE_UNUSED) && !defined(__cplusplus)
#      define XS_EXTERNAL(name) void name(pTHX_ CV* cv __attribute__unused__)
#      define XS_INTERNAL(name) STATIC void name(pTHX_ CV* cv __attribute__unused__)
#    else
#      ifdef __cplusplus
#        define XS_EXTERNAL(name) extern "C" XSPROTO(name)
#        define XS_INTERNAL(name) static XSPROTO(name)
#      else
#        define XS_EXTERNAL(name) XSPROTO(name)
#        define XS_INTERNAL(name) STATIC XSPROTO(name)
#      endif
#    endif
#  endif
#endif

/* perl >= 5.10.0 && perl <= 5.15.1 */


/* The XS_EXTERNAL macro is used for functions that must not be static
 * like the boot XSUB of a module. If perl didn't have an XS_EXTERNAL
 * macro defined, the best we can do is assume XS is the same.
 * Dito for XS_INTERNAL.
 */
#ifndef XS_EXTERNAL
#  define XS_EXTERNAL(name) XS(name)
#endif
#ifndef XS_INTERNAL
#  define XS_INTERNAL(name) XS(name)
#endif

/* Now, finally, after all this mess, we want an ExtUtils::ParseXS
 * internal macro that we're free to redefine for varying linkage due
 * to the EXPORT_XSUB_SYMBOLS XS keyword. This is internal, use
 * XS_EXTERNAL(name) or XS_INTERNAL(name) in your code if you need to!
 */

#undef XS_EUPXS
#if defined(PERL_EUPXS_ALWAYS_EXPORT)
#  define XS_EUPXS(name) XS_EXTERNAL(name)
#else
   /* default to internal */
#  define XS_EUPXS(name) XS_INTERNAL(name)
#endif

#ifndef PERL_ARGS_ASSERT_CROAK_XS_USAGE
#define PERL_ARGS_ASSERT_CROAK_XS_USAGE assert(cv); assert(params)

/* prototype to pass -Wmissing-prototypes */
STATIC void
S_croak_xs_usage(pTHX_ const CV *const cv, const char *const params);

STATIC void
S_croak_xs_usage(pTHX_ const CV *const cv, const char *const params)
{
    const GV *const gv = CvGV(cv);

    PERL_ARGS_ASSERT_CROAK_XS_USAGE;

    if (gv) {
        const char *const gvname = GvNAME(gv);
        const HV *const stash = GvSTASH(gv);
        const char *const hvname = stash ? HvNAME(stash) : NULL;

        if (hvname)
            Perl_croak(aTHX_ "Usage: %s::%s(%s)", hvname, gvname, params);
        else
            Perl_croak(aTHX_ "Usage: %s(%s)", gvname, params);
    } else {
        /* Pants. I don't think that it should be possible to get here. */
        Perl_croak(aTHX_ "Usage: CODE(0x%"UVxf")(%s)", PTR2UV(cv), params);
    }
}
#undef  PERL_ARGS_ASSERT_CROAK_XS_USAGE

#ifdef PERL_IMPLICIT_CONTEXT
#define croak_xs_usage(a,b)    S_croak_xs_usage(aTHX_ a,b)
#else
#define croak_xs_usage        S_croak_xs_usage
#endif

#endif

/* NOTE: the prototype of newXSproto() is different in versions of perls,
 * so we define a portable version of newXSproto()
 */
#ifdef newXS_flags
#define newXSproto_portable(name, c_impl, file, proto) newXS_flags(name, c_impl, file, proto, 0)
#else
#define newXSproto_portable(name, c_impl, file, proto) (PL_Sv=(SV*)newXS(name, c_impl, file), sv_setpv(PL_Sv, proto), (CV*)PL_Sv)
#endif /* !defined(newXS_flags) */

#line 218 "xs/GtkWidget.c"

XS_EUPXS(XS_Gtk2__Requisition_width); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Requisition_width)
{
    dVAR; dXSARGS;
    dXSI32;
    if (items < 1 || items > 2)
       croak_xs_usage(cv,  "requisition, newval=NULL");
    {
	GtkRequisition *	requisition = SvGtkRequisition (ST(0))
;
	SV *	newval;
	gint	RETVAL;
	dXSTARG;

	if (items < 2)
	    newval = NULL;
	else {
	    newval = ST(1)
;
	}
#line 75 "xs/GtkWidget.xs"
	switch (ix) {
		case 0:
			RETVAL = requisition->width;
			if (newval) requisition->width = SvIV (newval);
			break;
		case 1:
			RETVAL = requisition->height;
			if (newval) requisition->height = SvIV (newval);
			break;
		default:
			RETVAL = 0;
			g_assert_not_reached ();
	}
#line 254 "xs/GtkWidget.c"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Gtk2__Requisition_new); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Requisition_new)
{
    dVAR; dXSARGS;
    if (items < 1 || items > 3)
       croak_xs_usage(cv,  "class, width=0, height=0");
    {
	gint	width;
	gint	height;
#line 96 "xs/GtkWidget.xs"
	GtkRequisition req;
#line 272 "xs/GtkWidget.c"
	GtkRequisition_copy *	RETVAL;

	if (items < 2)
	    width = 0;
	else {
	    width = (gint)SvIV(ST(1))
;
	}

	if (items < 3)
	    height = 0;
	else {
	    height = (gint)SvIV(ST(2))
;
	}
#line 98 "xs/GtkWidget.xs"
	req.width = width;
	req.height = height;
	RETVAL = &req;
#line 292 "xs/GtkWidget.c"
	ST(0) = newSVGtkRequisition_copy (RETVAL);
	sv_2mortal(ST(0));
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Gtk2__Widget__INSTALL_OVERRIDES); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Widget__INSTALL_OVERRIDES)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "package");
    {
	const char *	package = (const char *)SvPV_nolen(ST(0))
;

	_INSTALL_OVERRIDES(package);
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_Gtk2__Widget_window); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Widget_window)
{
    dVAR; dXSARGS;
    if (items < 1 || items > 2)
       croak_xs_usage(cv,  "widget, new=NULL");
    {
	GtkWidget *	widget = SvGtkWidget (ST(0))
;
	GdkWindow_ornull *	new;
	GdkWindow_ornull *	RETVAL;

	if (items < 2)
	    new = NULL;
	else {
	    new = SvGdkWindow_ornull (ST(1))
;
	}
#line 139 "xs/GtkWidget.xs"
	RETVAL = widget->window;
	if (RETVAL)
		g_object_ref (widget->window);

	if (items == 2 && new != widget->window) {
		if (widget->window)
			g_object_unref (widget->window);
		if (new)
			g_object_ref (new);
		widget->window = new;
	}
#line 346 "xs/GtkWidget.c"
	ST(0) = newSVGdkWindow_ornull (RETVAL);
	sv_2mortal(ST(0));
#line 153 "xs/GtkWidget.xs"
	if (RETVAL) g_object_unref (RETVAL);
#line 351 "xs/GtkWidget.c"
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Gtk2__Widget_requisition); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Widget_requisition)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "widget");
    {
	GtkWidget *	widget = SvGtkWidget (ST(0))
;
	GtkRequisition *	RETVAL;
#line 168 "xs/GtkWidget.xs"
	RETVAL = &(widget->requisition);
#line 369 "xs/GtkWidget.c"
	ST(0) = newSVGtkRequisition (RETVAL);
	sv_2mortal(ST(0));
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Gtk2__Widget_allocation); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Widget_allocation)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "widget");
    {
	GtkWidget *	widget = SvGtkWidget (ST(0))
;
	GdkRectangle *	RETVAL;
#line 184 "xs/GtkWidget.xs"
	RETVAL = &(widget->allocation);
#line 389 "xs/GtkWidget.c"
	ST(0) = newSVGdkRectangle (RETVAL);
	sv_2mortal(ST(0));
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Gtk2__Widget_style); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Widget_style)
{
    dVAR; dXSARGS;
    dXSI32;
    if (items != 1)
       croak_xs_usage(cv,  "widget");
    {
	GtkWidget *	widget = SvGtkWidget (ST(0))
;
	GtkStyle *	RETVAL;
#line 195 "xs/GtkWidget.xs"
	PERL_UNUSED_VAR (ix);
	RETVAL = gtk_widget_get_style(widget);
#line 411 "xs/GtkWidget.c"
	ST(0) = newSVGtkStyle (RETVAL);
	sv_2mortal(ST(0));
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Gtk2__Widget_state); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Widget_state)
{
    dVAR; dXSARGS;
    dXSI32;
    if (items != 1)
       croak_xs_usage(cv,  "widget");
    {
	GtkWidget *	widget = SvGtkWidget (ST(0))
;
	GtkStateType	RETVAL;
#line 211 "xs/GtkWidget.xs"
	switch (ix) {
	    case 0: RETVAL = GTK_WIDGET_STATE (widget);       break;
	    case 1: RETVAL = GTK_WIDGET_SAVED_STATE (widget); break;
	    default: RETVAL = 0; g_assert_not_reached ();
	}
#line 436 "xs/GtkWidget.c"
	ST(0) = newSVGtkStateType (RETVAL);
	sv_2mortal(ST(0));
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Gtk2__Widget_toplevel); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Widget_toplevel)
{
    dVAR; dXSARGS;
    dXSI32;
    if (items < 1)
       croak_xs_usage(cv,  "widget, ...");
    {
	GtkWidget *	widget = SvGtkWidget (ST(0))
;
#line 358 "xs/GtkWidget.xs"
	gboolean value = FALSE;
	GtkWidgetFlags flag = 0;
#line 457 "xs/GtkWidget.c"
	gboolean	RETVAL;
#line 361 "xs/GtkWidget.xs"
	if (items > 2) {
		croak ("Usage: boolean = $widget->%s\n"
		       "       $widget->%s (newvalue)\n"
		       "   too many arguments",
		       GvNAME (CvGV (cv)), GvNAME (CvGV (cv)));
	}

        if ( items == 1 ) {
	    switch (ix) {
		case  0: RETVAL = GTK_WIDGET_TOPLEVEL         (widget); break;
		case  1: RETVAL = GTK_WIDGET_NO_WINDOW        (widget); break;
		case  2: RETVAL = GTK_WIDGET_REALIZED         (widget); break;
		case  3: RETVAL = GTK_WIDGET_MAPPED           (widget); break;
		case  4: RETVAL = GTK_WIDGET_VISIBLE          (widget); break;
		case  5: RETVAL = GTK_WIDGET_DRAWABLE         (widget); break;
		case  6: RETVAL = GTK_WIDGET_SENSITIVE        (widget); break;
		case  7: RETVAL = GTK_WIDGET_PARENT_SENSITIVE (widget); break;
		case  8: RETVAL = GTK_WIDGET_IS_SENSITIVE     (widget); break;
		case  9: RETVAL = GTK_WIDGET_CAN_FOCUS        (widget); break;
		case 10: RETVAL = GTK_WIDGET_HAS_FOCUS        (widget); break;
		case 11: RETVAL = GTK_WIDGET_HAS_GRAB         (widget); break;
		case 12: RETVAL = GTK_WIDGET_RC_STYLE         (widget); break;
		case 13: RETVAL = GTK_WIDGET_COMPOSITE_CHILD  (widget); break;
		case 14: RETVAL = GTK_WIDGET_APP_PAINTABLE    (widget); break;
		case 15: RETVAL = GTK_WIDGET_RECEIVES_DEFAULT (widget); break;
		case 16: RETVAL = GTK_WIDGET_DOUBLE_BUFFERED  (widget); break;
		case 17: RETVAL = GTK_WIDGET_CAN_DEFAULT      (widget); break;
		case 18: RETVAL = GTK_WIDGET_HAS_DEFAULT      (widget); break;
		default:
			RETVAL = FALSE;
			g_assert_not_reached ();
	    }
	} else {
	    value = (gboolean) SvIV(ST(1));
	    switch (ix) {
		case  0: flag = GTK_TOPLEVEL	     ; break;
		case  1: flag = GTK_NO_WINDOW	     ; break;
		case  2: flag = GTK_REALIZED	     ; break;
		case  3: flag = GTK_MAPPED	     ; break;
		case  4: flag = GTK_VISIBLE	     ; break;
		case  5: croak ("widget flag drawable is read only"); break;
		case  6: flag = GTK_SENSITIVE	     ; break;
		case  7: flag = GTK_PARENT_SENSITIVE ; break;
		case  8: croak ("widget flag is_sensitive is read only"); break;
		case  9: flag = GTK_CAN_FOCUS	     ; break;
		case 10: flag = GTK_HAS_FOCUS	     ; break;
		case 11: flag = GTK_HAS_GRAB	     ; break;
		case 12: flag = GTK_RC_STYLE	     ; break;
		case 13: flag = GTK_COMPOSITE_CHILD  ; break;
		case 14: flag = GTK_APP_PAINTABLE    ; break;
		case 15: flag = GTK_RECEIVES_DEFAULT ; break;
		case 16: flag = GTK_DOUBLE_BUFFERED  ; break;
		case 17: flag = GTK_CAN_DEFAULT      ; break;
		case 18: flag = GTK_HAS_DEFAULT      ; break;
		default:
			flag = FALSE;
			g_assert_not_reached ();
	    }
	    if ( value ) {
	    	GTK_WIDGET_SET_FLAGS(widget, flag);
	    } else {
	    	GTK_WIDGET_UNSET_FLAGS(widget, flag);
	    }
	    RETVAL=value;
	}

#line 526 "xs/GtkWidget.c"
	ST(0) = boolSV(RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Gtk2__Widget_flags); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Widget_flags)
{
    dVAR; dXSARGS;
    dXSI32;
    if (items != 1)
       croak_xs_usage(cv,  "widget");
    {
	GtkWidgetFlags	RETVAL;
	GtkWidget *	widget = SvGtkWidget (ST(0))
;
#line 435 "xs/GtkWidget.xs"
	PERL_UNUSED_VAR (ix);
	RETVAL = GTK_WIDGET_FLAGS (widget);
#line 547 "xs/GtkWidget.c"
	ST(0) = newSVGtkWidgetFlags (RETVAL);
	sv_2mortal(ST(0));
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Gtk2__Widget_set_flags); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Widget_set_flags)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "widget, flags");
    {
	GtkWidget *	widget = SvGtkWidget (ST(0))
;
	GtkWidgetFlags	flags = SvGtkWidgetFlags (ST(1))
;
#line 451 "xs/GtkWidget.xs"
	GTK_WIDGET_SET_FLAGS (widget, flags);
#line 568 "xs/GtkWidget.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_Gtk2__Widget_unset_flags); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Widget_unset_flags)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "widget, flags");
    {
	GtkWidget *	widget = SvGtkWidget (ST(0))
;
	GtkWidgetFlags	flags = SvGtkWidgetFlags (ST(1))
;
#line 458 "xs/GtkWidget.xs"
	GTK_WIDGET_UNSET_FLAGS (widget, flags);
#line 587 "xs/GtkWidget.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_Gtk2__Widget_destroy); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Widget_destroy)
{
    dVAR; dXSARGS;
    dXSI32;
    if (items != 1)
       croak_xs_usage(cv,  "widget");
    {
	GtkWidget *	widget = SvGtkWidget (ST(0))
;
#line 516 "xs/GtkWidget.xs"
	switch (ix) {
		case  0: gtk_widget_destroy   (widget); break;
		case  1: gtk_widget_unparent  (widget); break;
		case  2: gtk_widget_show      (widget); break;
		case  3: gtk_widget_show_now  (widget); break;
		case  4: gtk_widget_hide      (widget); break;
		case  5: gtk_widget_show_all  (widget); break;
		case  6: gtk_widget_hide_all  (widget); break;
		case  7: gtk_widget_map       (widget); break;
		case  8: gtk_widget_unmap     (widget); break;
		case  9: gtk_widget_realize   (widget); break;
		case 10: gtk_widget_unrealize (widget); break;
		case 11: gtk_widget_grab_focus   (widget); break;
		case 12: gtk_widget_grab_default (widget); break;
		case 13: gtk_widget_reset_shapes (widget); break;
		case 14: gtk_widget_queue_draw   (widget); break;
		case 15: gtk_widget_queue_resize (widget); break;
		case 16: gtk_widget_freeze_child_notify (widget); break;
		case 17: gtk_widget_thaw_child_notify   (widget); break;
		default:
			 g_assert_not_reached ();
	}
#line 626 "xs/GtkWidget.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_Gtk2__Widget_queue_draw_area); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Widget_queue_draw_area)
{
    dVAR; dXSARGS;
    if (items != 5)
       croak_xs_usage(cv,  "widget, x, y, width, height");
    {
	GtkWidget *	widget = SvGtkWidget (ST(0))
;
	gint	x = (gint)SvIV(ST(1))
;
	gint	y = (gint)SvIV(ST(2))
;
	gint	width = (gint)SvIV(ST(3))
;
	gint	height = (gint)SvIV(ST(4))
;

	gtk_widget_queue_draw_area(widget, x, y, width, height);
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_Gtk2__Widget_size_request); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Widget_size_request)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "widget");
    {
	GtkWidget *	widget = SvGtkWidget (ST(0))
;
#line 568 "xs/GtkWidget.xs"
	GtkRequisition req;
#line 667 "xs/GtkWidget.c"
	GtkRequisition_copy *	RETVAL;
#line 570 "xs/GtkWidget.xs"
	gtk_widget_size_request (widget, &req);
	RETVAL = &req;
#line 672 "xs/GtkWidget.c"
	ST(0) = newSVGtkRequisition_copy (RETVAL);
	sv_2mortal(ST(0));
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Gtk2__Widget_size_allocate); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Widget_size_allocate)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "widget, allocation");
    {
	GtkWidget *	widget = SvGtkWidget (ST(0))
;
	GdkRectangle *	allocation = SvGdkRectangle (ST(1))
;

	gtk_widget_size_allocate(widget, allocation);
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_Gtk2__Widget_get_child_requisition); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Widget_get_child_requisition)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "widget");
    {
#line 607 "xs/GtkWidget.xs"
	GtkRequisition req;
#line 707 "xs/GtkWidget.c"
	GtkRequisition_copy *	RETVAL;
	GtkWidget *	widget = SvGtkWidget (ST(0))
;
#line 609 "xs/GtkWidget.xs"
	gtk_widget_get_child_requisition (widget, &req);
	RETVAL = &req;
#line 714 "xs/GtkWidget.c"
	ST(0) = newSVGtkRequisition_copy (RETVAL);
	sv_2mortal(ST(0));
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Gtk2__Widget_add_accelerator); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Widget_add_accelerator)
{
    dVAR; dXSARGS;
    if (items != 6)
       croak_xs_usage(cv,  "widget, accel_signal, accel_group, accel_key, accel_mods, flags");
    {
	GtkWidget *	widget = SvGtkWidget (ST(0))
;
	const gchar *	accel_signal;
	GtkAccelGroup *	accel_group = SvGtkAccelGroup (ST(2))
;
	guint	accel_key = (guint)SvUV(ST(3))
;
	GdkModifierType	accel_mods = SvGdkModifierType (ST(4))
;
	GtkAccelFlags	flags = SvGtkAccelFlags (ST(5))
;

	/* same as SvGChar(), but not in a function */
	sv_utf8_upgrade (ST(1));
	accel_signal = (const gchar *)SvPV_nolen (ST(1))
;

	gtk_widget_add_accelerator(widget, accel_signal, accel_group, accel_key, accel_mods, flags);
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_Gtk2__Widget_remove_accelerator); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Widget_remove_accelerator)
{
    dVAR; dXSARGS;
    if (items != 4)
       croak_xs_usage(cv,  "widget, accel_group, accel_key, accel_mods");
    {
	GtkWidget *	widget = SvGtkWidget (ST(0))
;
	GtkAccelGroup *	accel_group = SvGtkAccelGroup (ST(1))
;
	guint	accel_key = (guint)SvUV(ST(2))
;
	GdkModifierType	accel_mods = SvGdkModifierType (ST(3))
;
	gboolean	RETVAL;

	RETVAL = gtk_widget_remove_accelerator(widget, accel_group, accel_key, accel_mods);
	ST(0) = boolSV(RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Gtk2__Widget_set_accel_path); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Widget_set_accel_path)
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "widget, accel_path, accel_group");
    {
	GtkWidget *	widget = SvGtkWidget (ST(0))
;
	const gchar_ornull *	accel_path;
	GtkAccelGroup_ornull *	accel_group = SvGtkAccelGroup_ornull (ST(2))
;

	/* same as SvGChar(), but allows undef as NULL */
	if (gperl_sv_is_defined (ST(1))) {
		sv_utf8_upgrade (ST(1));
		accel_path = (const gchar_ornull *)SvPV_nolen (ST(1));
	} else {
		accel_path = NULL;
	}
;

	gtk_widget_set_accel_path(widget, accel_path, accel_group);
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_Gtk2__Widget_mnemonic_activate); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Widget_mnemonic_activate)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "widget, group_cycling");
    {
	GtkWidget *	widget = SvGtkWidget (ST(0))
;
	gboolean	group_cycling = (bool)SvTRUE(ST(1))
;
	gboolean	RETVAL;

	RETVAL = gtk_widget_mnemonic_activate(widget, group_cycling);
	ST(0) = boolSV(RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Gtk2__Widget_event); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Widget_event)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "widget, event");
    {
	gboolean	RETVAL;
	GtkWidget *	widget = SvGtkWidget (ST(0))
;
	GdkEvent *	event = SvGdkEvent (ST(1))
;

	RETVAL = gtk_widget_event(widget, event);
	ST(0) = boolSV(RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Gtk2__Widget_activate); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Widget_activate)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "widget");
    {
	GtkWidget *	widget = SvGtkWidget (ST(0))
;
	gboolean	RETVAL;

	RETVAL = gtk_widget_activate(widget);
	ST(0) = boolSV(RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Gtk2__Widget_set_scroll_adjustments); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Widget_set_scroll_adjustments)
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "widget, hadjustment, vadjustment");
    {
	GtkWidget *	widget = SvGtkWidget (ST(0))
;
	GtkAdjustment_ornull *	hadjustment = SvGtkAdjustment_ornull (ST(1))
;
	GtkAdjustment_ornull *	vadjustment = SvGtkAdjustment_ornull (ST(2))
;
	gboolean	RETVAL;

	RETVAL = gtk_widget_set_scroll_adjustments(widget, hadjustment, vadjustment);
	ST(0) = boolSV(RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Gtk2__Widget_reparent); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Widget_reparent)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "widget, new_parent");
    {
	GtkWidget *	widget = SvGtkWidget (ST(0))
;
	GtkWidget *	new_parent = SvGtkWidget (ST(1))
;

	gtk_widget_reparent(widget, new_parent);
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_Gtk2__Widget_intersect); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Widget_intersect)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "widget, area");
    {
	GtkWidget *	widget = SvGtkWidget (ST(0))
;
	GdkRectangle *	area = SvGdkRectangle (ST(1))
;
#line 700 "xs/GtkWidget.xs"
	GdkRectangle intersection;
#line 915 "xs/GtkWidget.c"
	GdkRectangle_copy *	RETVAL;
#line 702 "xs/GtkWidget.xs"
	if (!gtk_widget_intersect (widget, area, &intersection))
		XSRETURN_UNDEF;
	RETVAL = &intersection;
#line 921 "xs/GtkWidget.c"
	ST(0) = newSVGdkRectangle_copy (RETVAL);
	sv_2mortal(ST(0));
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Gtk2__Widget_region_intersect); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Widget_region_intersect)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "widget, region");
    {
	GdkRegion *	RETVAL;
	GtkWidget *	widget = SvGtkWidget (ST(0))
;
	GdkRegion *	region = SvGdkRegion (ST(1))
;

	RETVAL = gtk_widget_region_intersect(widget, region);
	ST(0) = newSVGdkRegion (RETVAL);
	sv_2mortal(ST(0));
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Gtk2__Widget_child_notify); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Widget_child_notify)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "widget, child_property");
    {
	GtkWidget *	widget = SvGtkWidget (ST(0))
;
	const gchar *	child_property;

	/* same as SvGChar(), but not in a function */
	sv_utf8_upgrade (ST(1));
	child_property = (const gchar *)SvPV_nolen (ST(1))
;

	gtk_widget_child_notify(widget, child_property);
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_Gtk2__Widget_is_focus); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Widget_is_focus)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "widget");
    {
	gboolean	RETVAL;
	GtkWidget *	widget = SvGtkWidget (ST(0))
;

	RETVAL = gtk_widget_is_focus(widget);
	ST(0) = boolSV(RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Gtk2__Widget_set_name); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Widget_set_name)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "widget, name");
    {
	GtkWidget *	widget = SvGtkWidget (ST(0))
;
	const gchar *	name;

	/* same as SvGChar(), but not in a function */
	sv_utf8_upgrade (ST(1));
	name = (const gchar *)SvPV_nolen (ST(1))
;

	gtk_widget_set_name(widget, name);
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_Gtk2__Widget_get_name); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Widget_get_name)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "widget");
    {
	GtkWidget *	widget = SvGtkWidget (ST(0))
;
	const gchar *	RETVAL;

	RETVAL = gtk_widget_get_name(widget);
	ST(0) = sv_newmortal();
	/* same as newSVGChar(), but not in a function */
	sv_setpv ((SV*)ST(0), RETVAL);
	SvUTF8_on (ST(0));
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Gtk2__Widget_set_state); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Widget_set_state)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "widget, state");
    {
	GtkWidget *	widget = SvGtkWidget (ST(0))
;
	GtkStateType	state = SvGtkStateType (ST(1))
;

	gtk_widget_set_state(widget, state);
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_Gtk2__Widget_set_sensitive); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Widget_set_sensitive)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "widget, sensitive");
    {
	GtkWidget *	widget = SvGtkWidget (ST(0))
;
	gboolean	sensitive = (bool)SvTRUE(ST(1))
;

	gtk_widget_set_sensitive(widget, sensitive);
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_Gtk2__Widget_set_app_paintable); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Widget_set_app_paintable)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "widget, app_paintable");
    {
	GtkWidget *	widget = SvGtkWidget (ST(0))
;
	gboolean	app_paintable = (bool)SvTRUE(ST(1))
;

	gtk_widget_set_app_paintable(widget, app_paintable);
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_Gtk2__Widget_set_double_buffered); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Widget_set_double_buffered)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "widget, double_buffered");
    {
	GtkWidget *	widget = SvGtkWidget (ST(0))
;
	gboolean	double_buffered = (bool)SvTRUE(ST(1))
;

	gtk_widget_set_double_buffered(widget, double_buffered);
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_Gtk2__Widget_set_redraw_on_allocate); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Widget_set_redraw_on_allocate)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "widget, redraw_on_allocate");
    {
	GtkWidget *	widget = SvGtkWidget (ST(0))
;
	gboolean	redraw_on_allocate = (bool)SvTRUE(ST(1))
;

	gtk_widget_set_redraw_on_allocate(widget, redraw_on_allocate);
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_Gtk2__Widget_set_parent); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Widget_set_parent)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "widget, parent");
    {
	GtkWidget *	widget = SvGtkWidget (ST(0))
;
	GtkWidget *	parent = SvGtkWidget (ST(1))
;

	gtk_widget_set_parent(widget, parent);
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_Gtk2__Widget_set_parent_window); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Widget_set_parent_window)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "widget, parent_window");
    {
	GtkWidget *	widget = SvGtkWidget (ST(0))
;
	GdkWindow *	parent_window = SvGdkWindow (ST(1))
;

	gtk_widget_set_parent_window(widget, parent_window);
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_Gtk2__Widget_set_child_visible); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Widget_set_child_visible)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "widget, is_visible");
    {
	GtkWidget *	widget = SvGtkWidget (ST(0))
;
	gboolean	is_visible = (bool)SvTRUE(ST(1))
;

	gtk_widget_set_child_visible(widget, is_visible);
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_Gtk2__Widget_get_child_visible); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Widget_get_child_visible)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "widget");
    {
	gboolean	RETVAL;
	GtkWidget *	widget = SvGtkWidget (ST(0))
;

	RETVAL = gtk_widget_get_child_visible(widget);
	ST(0) = boolSV(RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Gtk2__Widget_get_parent); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Widget_get_parent)
{
    dVAR; dXSARGS;
    dXSI32;
    if (items != 1)
       croak_xs_usage(cv,  "widget");
    {
	GtkWidget *	widget = SvGtkWidget (ST(0))
;
	GtkWidget_ornull *	RETVAL;

	RETVAL = gtk_widget_get_parent(widget);
	ST(0) = newSVGtkWidget_ornull (RETVAL);
	sv_2mortal(ST(0));
#line 760 "xs/GtkWidget.xs"
	PERL_UNUSED_VAR (ix);
#line 1212 "xs/GtkWidget.c"
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Gtk2__Widget_get_parent_window); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Widget_get_parent_window)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "widget");
    {
	GdkWindow *	RETVAL;
	GtkWidget *	widget = SvGtkWidget (ST(0))
;

	RETVAL = gtk_widget_get_parent_window(widget);
	ST(0) = newSVGdkWindow (RETVAL);
	sv_2mortal(ST(0));
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Gtk2__Widget_child_focus); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Widget_child_focus)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "widget, direction");
    {
	gboolean	RETVAL;
	GtkWidget *	widget = SvGtkWidget (ST(0))
;
	GtkDirectionType	direction = SvGtkDirectionType (ST(1))
;

	RETVAL = gtk_widget_child_focus(widget, direction);
	ST(0) = boolSV(RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Gtk2__Widget_set_size_request); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Widget_set_size_request)
{
    dVAR; dXSARGS;
    if (items < 1 || items > 3)
       croak_xs_usage(cv,  "widget, width=-1, height=-1");
    {
	GtkWidget *	widget = SvGtkWidget (ST(0))
;
	gint	width;
	gint	height;

	if (items < 2)
	    width = -1;
	else {
	    width = (gint)SvIV(ST(1))
;
	}

	if (items < 3)
	    height = -1;
	else {
	    height = (gint)SvIV(ST(2))
;
	}

	gtk_widget_set_size_request(widget, width, height);
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_Gtk2__Widget_get_size_request); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Widget_get_size_request)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "widget");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
	GtkWidget *	widget = SvGtkWidget (ST(0))
;
#line 788 "xs/GtkWidget.xs"
	gint width, height;
#line 1302 "xs/GtkWidget.c"
#line 790 "xs/GtkWidget.xs"
	gtk_widget_get_size_request (widget, &width, &height);
	XPUSHs (sv_2mortal (newSViv (width)));
	XPUSHs (sv_2mortal (newSViv (height)));
#line 1307 "xs/GtkWidget.c"
	PUTBACK;
	return;
    }
}


XS_EUPXS(XS_Gtk2__Widget_set_events); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Widget_set_events)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "widget, events");
    {
	GtkWidget *	widget = SvGtkWidget (ST(0))
;
	GdkEventMask	events = SvGdkEventMask (ST(1))
;

	gtk_widget_set_events(widget, events);
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_Gtk2__Widget_add_events); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Widget_add_events)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "widget, events");
    {
	GtkWidget *	widget = SvGtkWidget (ST(0))
;
	GdkEventMask	events = SvGdkEventMask (ST(1))
;

	gtk_widget_add_events(widget, events);
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_Gtk2__Widget_set_extension_events); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Widget_set_extension_events)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "widget, mode");
    {
	GtkWidget *	widget = SvGtkWidget (ST(0))
;
	GdkExtensionMode	mode = SvGdkExtensionMode (ST(1))
;

	gtk_widget_set_extension_events(widget, mode);
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_Gtk2__Widget_get_extension_events); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Widget_get_extension_events)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "widget");
    {
	GtkWidget *	widget = SvGtkWidget (ST(0))
;
	GdkExtensionMode	RETVAL;

	RETVAL = gtk_widget_get_extension_events(widget);
	ST(0) = newSVGdkExtensionMode (RETVAL);
	sv_2mortal(ST(0));
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Gtk2__Widget_get_toplevel); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Widget_get_toplevel)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "widget");
    {
	GtkWidget *	widget = SvGtkWidget (ST(0))
;
	GtkWidget *	RETVAL;

	RETVAL = gtk_widget_get_toplevel(widget);
	ST(0) = newSVGtkWidget (RETVAL);
	sv_2mortal(ST(0));
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Gtk2__Widget_get_ancestor); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Widget_get_ancestor)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "widget, ancestor_package");
    {
	GtkWidget *	widget = SvGtkWidget (ST(0))
;
	const char *	ancestor_package = (const char *)SvPV_nolen(ST(1))
;
#line 825 "xs/GtkWidget.xs"
	GtkType widget_type;
#line 1419 "xs/GtkWidget.c"
	GtkWidget_ornull *	RETVAL;
#line 827 "xs/GtkWidget.xs"
	widget_type = gperl_object_type_from_package (ancestor_package);
	if (!widget_type)
		croak ("package %s is not registered to a GType",
		       ancestor_package);
	RETVAL = gtk_widget_get_ancestor (widget, widget_type);
#line 1427 "xs/GtkWidget.c"
	ST(0) = newSVGtkWidget_ornull (RETVAL);
	sv_2mortal(ST(0));
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Gtk2__Widget_get_colormap); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Widget_get_colormap)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "widget");
    {
	GtkWidget *	widget = SvGtkWidget (ST(0))
;
	GdkColormap *	RETVAL;

	RETVAL = gtk_widget_get_colormap(widget);
	ST(0) = newSVGdkColormap (RETVAL);
	sv_2mortal(ST(0));
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Gtk2__Widget_get_visual); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Widget_get_visual)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "widget");
    {
	GdkVisual *	RETVAL;
	GtkWidget *	widget = SvGtkWidget (ST(0))
;

	RETVAL = gtk_widget_get_visual(widget);
	ST(0) = newSVGdkVisual (RETVAL);
	sv_2mortal(ST(0));
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Gtk2__Widget_get_settings); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Widget_get_settings)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "widget");
    {
	GtkSettings *	RETVAL;
	GtkWidget *	widget = SvGtkWidget (ST(0))
;

	RETVAL = gtk_widget_get_settings(widget);
	ST(0) = newSVGtkSettings (RETVAL);
	sv_2mortal(ST(0));
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Gtk2__Widget_get_accessible); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Widget_get_accessible)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "widget");
    {
	AtkObject *	RETVAL;
	GtkWidget *	widget = SvGtkWidget (ST(0))
;

	RETVAL = gtk_widget_get_accessible(widget);
	ST(0) = newSVAtkObject (RETVAL);
	sv_2mortal(ST(0));
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Gtk2__Widget_set_colormap); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Widget_set_colormap)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "widget, colormap");
    {
	GtkWidget *	widget = SvGtkWidget (ST(0))
;
	GdkColormap *	colormap = SvGdkColormap (ST(1))
;

	gtk_widget_set_colormap(widget, colormap);
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_Gtk2__Widget_get_events); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Widget_get_events)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "widget");
    {
	GtkWidget *	widget = SvGtkWidget (ST(0))
;
	GdkEventMask	RETVAL;

	RETVAL = gtk_widget_get_events(widget);
	ST(0) = newSVGdkEventMask (RETVAL);
	sv_2mortal(ST(0));
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Gtk2__Widget_get_pointer); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Widget_get_pointer)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "widget");
    {
	GtkWidget *	widget = SvGtkWidget (ST(0))
;
	gint	x;
	gint	y;

	gtk_widget_get_pointer(widget, &x, &y);
	XSprePUSH;	EXTEND(SP,2);
	PUSHs(sv_newmortal());
	sv_setiv(ST(0), (IV)x);
	PUSHs(sv_newmortal());
	sv_setiv(ST(1), (IV)y);
    }
    XSRETURN(2);
}


XS_EUPXS(XS_Gtk2__Widget_is_ancestor); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Widget_is_ancestor)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "widget, ancestor");
    {
	gboolean	RETVAL;
	GtkWidget *	widget = SvGtkWidget (ST(0))
;
	GtkWidget *	ancestor = SvGtkWidget (ST(1))
;

	RETVAL = gtk_widget_is_ancestor(widget, ancestor);
	ST(0) = boolSV(RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Gtk2__Widget_translate_coordinates); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Widget_translate_coordinates)
{
    dVAR; dXSARGS;
    if (items != 4)
       croak_xs_usage(cv,  "src_widget, dest_widget, src_x, src_y");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
#line 874 "xs/GtkWidget.xs"
	gint dest_x, dest_y;
#line 1602 "xs/GtkWidget.c"
	GtkWidget *	src_widget = SvGtkWidget (ST(0))
;
	GtkWidget *	dest_widget = SvGtkWidget (ST(1))
;
	gint	src_x = (gint)SvIV(ST(2))
;
	gint	src_y = (gint)SvIV(ST(3))
;
#line 876 "xs/GtkWidget.xs"
	if (!gtk_widget_translate_coordinates (src_widget, dest_widget,
	                                     src_x, src_y, &dest_x, &dest_y))
		XSRETURN_EMPTY;
	EXTEND (SP, 2);
	PUSHs (sv_2mortal (newSViv (dest_x)));
	PUSHs (sv_2mortal (newSViv (dest_y)));
#line 1618 "xs/GtkWidget.c"
	PUTBACK;
	return;
    }
}


XS_EUPXS(XS_Gtk2__Widget_hide_on_delete); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Widget_hide_on_delete)
{
    dVAR; dXSARGS;
    if (items < 1)
       croak_xs_usage(cv,  "widget, ...");
    {
	gboolean	RETVAL;
	GtkWidget *	widget = SvGtkWidget (ST(0))
;

	RETVAL = gtk_widget_hide_on_delete(widget);
	ST(0) = boolSV(RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Gtk2__Widget_set_style); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Widget_set_style)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "widget, style");
    {
	GtkWidget *	widget = SvGtkWidget (ST(0))
;
	GtkStyle_ornull *	style = SvGtkStyle_ornull (ST(1))
;

	gtk_widget_set_style(widget, style);
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_Gtk2__Widget_ensure_style); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Widget_ensure_style)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "widget");
    {
	GtkWidget *	widget = SvGtkWidget (ST(0))
;

	gtk_widget_ensure_style(widget);
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_Gtk2__Widget_modify_style); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Widget_modify_style)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "widget, style");
    {
	GtkWidget *	widget = SvGtkWidget (ST(0))
;
	GtkRcStyle *	style = SvGtkRcStyle (ST(1))
;

	gtk_widget_modify_style(widget, style);
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_Gtk2__Widget_get_modifier_style); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Widget_get_modifier_style)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "widget");
    {
	GtkRcStyle *	RETVAL;
	GtkWidget *	widget = SvGtkWidget (ST(0))
;

	RETVAL = gtk_widget_get_modifier_style(widget);
	ST(0) = newSVGtkRcStyle (RETVAL);
	sv_2mortal(ST(0));
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Gtk2__Widget_modify_fg); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Widget_modify_fg)
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "widget, state, color");
    {
	GtkWidget *	widget = SvGtkWidget (ST(0))
;
	GtkStateType	state = SvGtkStateType (ST(1))
;
	GdkColor_ornull *	color = SvGdkColor_ornull (ST(2))
;

	gtk_widget_modify_fg(widget, state, color);
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_Gtk2__Widget_modify_bg); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Widget_modify_bg)
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "widget, state, color");
    {
	GtkWidget *	widget = SvGtkWidget (ST(0))
;
	GtkStateType	state = SvGtkStateType (ST(1))
;
	GdkColor_ornull *	color = SvGdkColor_ornull (ST(2))
;

	gtk_widget_modify_bg(widget, state, color);
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_Gtk2__Widget_modify_text); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Widget_modify_text)
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "widget, state, color");
    {
	GtkWidget *	widget = SvGtkWidget (ST(0))
;
	GtkStateType	state = SvGtkStateType (ST(1))
;
	GdkColor_ornull *	color = SvGdkColor_ornull (ST(2))
;

	gtk_widget_modify_text(widget, state, color);
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_Gtk2__Widget_modify_base); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Widget_modify_base)
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "widget, state, color");
    {
	GtkWidget *	widget = SvGtkWidget (ST(0))
;
	GtkStateType	state = SvGtkStateType (ST(1))
;
	GdkColor_ornull *	color = SvGdkColor_ornull (ST(2))
;

	gtk_widget_modify_base(widget, state, color);
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_Gtk2__Widget_modify_font); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Widget_modify_font)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "widget, font_desc");
    {
	GtkWidget *	widget = SvGtkWidget (ST(0))
;
	PangoFontDescription_ornull *	font_desc = SvPangoFontDescription_ornull (ST(1))
;

	gtk_widget_modify_font(widget, font_desc);
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_Gtk2__Widget_create_pango_context); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Widget_create_pango_context)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "widget");
    {
	PangoContext_noinc *	RETVAL;
	GtkWidget *	widget = SvGtkWidget (ST(0))
;

	RETVAL = gtk_widget_create_pango_context(widget);
	ST(0) = newSVPangoContext_noinc (RETVAL);
	sv_2mortal(ST(0));
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Gtk2__Widget_get_pango_context); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Widget_get_pango_context)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "widget");
    {
	PangoContext *	RETVAL;
	GtkWidget *	widget = SvGtkWidget (ST(0))
;

	RETVAL = gtk_widget_get_pango_context(widget);
	ST(0) = newSVPangoContext (RETVAL);
	sv_2mortal(ST(0));
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Gtk2__Widget_create_pango_layout); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Widget_create_pango_layout)
{
    dVAR; dXSARGS;
    if (items < 1 || items > 2)
       croak_xs_usage(cv,  "widget, text=NULL");
    {
	GtkWidget *	widget = SvGtkWidget (ST(0))
;
	const gchar_ornull *	text;
	PangoLayout_noinc *	RETVAL;

	if (items < 2)
	    text = NULL;
	else {
	    /* same as SvGChar(), but allows undef as NULL */
	    if (gperl_sv_is_defined (ST(1))) {
		    sv_utf8_upgrade (ST(1));
		    text = (const gchar_ornull *)SvPV_nolen (ST(1));
	    } else {
		    text = NULL;
	    }
;
	}

	RETVAL = gtk_widget_create_pango_layout(widget, text);
	ST(0) = newSVPangoLayout_noinc (RETVAL);
	sv_2mortal(ST(0));
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Gtk2__Widget_render_icon); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Widget_render_icon)
{
    dVAR; dXSARGS;
    if (items < 3 || items > 4)
       croak_xs_usage(cv,  "widget, stock_id, size, detail=NULL");
    {
	GtkWidget *	widget = SvGtkWidget (ST(0))
;
	const gchar *	stock_id;
	GtkIconSize	size = SvGtkIconSize (ST(2))
;
	const gchar *	detail;
	GdkPixbuf_noinc *	RETVAL;

	/* same as SvGChar(), but not in a function */
	sv_utf8_upgrade (ST(1));
	stock_id = (const gchar *)SvPV_nolen (ST(1))
;

	if (items < 4)
	    detail = NULL;
	else {
	    /* same as SvGChar(), but not in a function */
	    sv_utf8_upgrade (ST(3));
	    detail = (const gchar *)SvPV_nolen (ST(3))
;
	}

	RETVAL = gtk_widget_render_icon(widget, stock_id, size, detail);
	ST(0) = newSVGdkPixbuf_noinc (RETVAL);
	sv_2mortal(ST(0));
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Gtk2__Widget_set_composite_name); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Widget_set_composite_name)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "widget, name");
    {
	GtkWidget *	widget = SvGtkWidget (ST(0))
;
	const gchar *	name;

	/* same as SvGChar(), but not in a function */
	sv_utf8_upgrade (ST(1));
	name = (const gchar *)SvPV_nolen (ST(1))
;

	gtk_widget_set_composite_name(widget, name);
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_Gtk2__Widget_get_composite_name); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Widget_get_composite_name)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "widget");
    {
	gchar_ornull *	RETVAL;
	GtkWidget *	widget = SvGtkWidget (ST(0))
;

	RETVAL = gtk_widget_get_composite_name(widget);
	ST(0) = sv_newmortal();
	/* newSVGChar() allows NULL, but T_GCHAR does not. allow NULL. */
	if (RETVAL) {
		sv_setpv ((SV*)ST(0), RETVAL);
		SvUTF8_on (ST(0));
	} else {
		SvSetSV (ST(0), &PL_sv_undef);
	}
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Gtk2__Widget_reset_rc_styles); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Widget_reset_rc_styles)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "widget");
    {
	GtkWidget *	widget = SvGtkWidget (ST(0))
;

	gtk_widget_reset_rc_styles(widget);
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_Gtk2__Widget_push_colormap); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Widget_push_colormap)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "class_or_widget, cmap");
    {
	GdkColormap *	cmap = SvGdkColormap (ST(1))
;

	gtk_widget_push_colormap(cmap);
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_Gtk2__Widget_pop_colormap); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Widget_pop_colormap)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "class_or_widget");
    {

	gtk_widget_pop_colormap(/* void */);
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_Gtk2__Widget_push_composite_child); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Widget_push_composite_child)
{
    dVAR; dXSARGS;
    if (items < 0 || items > 1)
       croak_xs_usage(cv,  "class_or_widget=NULL");
    {

	gtk_widget_push_composite_child(/* void */);
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_Gtk2__Widget_pop_composite_child); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Widget_pop_composite_child)
{
    dVAR; dXSARGS;
    if (items < 0 || items > 1)
       croak_xs_usage(cv,  "class_or_widget=NULL");
    {

	gtk_widget_pop_composite_child(/* void */);
    }
    XSRETURN_EMPTY;
}

#if GTK_CHECK_VERSION(2,2,0)
#define XSubPPtmpAAAA 1


XS_EUPXS(XS_Gtk2__Widget_style_get); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Widget_style_get)
{
    dVAR; dXSARGS;
    dXSI32;
    if (items < 2)
       croak_xs_usage(cv,  "widget, first_property_name, ...");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
#line 1012 "xs/GtkWidget.xs"
	int i;
#line 2056 "xs/GtkWidget.c"
	GtkWidget *	widget = SvGtkWidget (ST(0))
;
#line 1014 "xs/GtkWidget.xs"
	PERL_UNUSED_VAR (ix);
	EXTEND (SP, items - 1);
	for (i = 1 ; i < items ; i++) {
		GValue value = {0, };
		gchar * name = SvGChar (ST (i));
		GParamSpec * pspec;
		pspec = gtk_widget_class_find_style_property
		                         (GTK_WIDGET_GET_CLASS (widget), name);
		if (pspec) {
			g_value_init (&value, G_PARAM_SPEC_VALUE_TYPE (pspec));
			gtk_widget_style_get_property (widget, name, &value);
			PUSHs (sv_2mortal (gperl_sv_from_value (&value)));
			g_value_unset (&value);
		} else {
			warn ("Invalid property `%s' used", name);
		}
	}
#line 2077 "xs/GtkWidget.c"
	PUTBACK;
	return;
    }
}

#endif

XS_EUPXS(XS_Gtk2__Widget_set_default_colormap); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Widget_set_default_colormap)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "class_or_widget, colormap");
    {
	GdkColormap *	colormap = SvGdkColormap (ST(1))
;

	gtk_widget_set_default_colormap(colormap);
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_Gtk2__Widget_get_default_style); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Widget_get_default_style)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "class_or_widget");
    {
	GtkStyle *	RETVAL;

	RETVAL = gtk_widget_get_default_style(/* void */);
	ST(0) = newSVGtkStyle (RETVAL);
	sv_2mortal(ST(0));
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Gtk2__Widget_get_default_colormap); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Widget_get_default_colormap)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "class_or_widget");
    {
	GdkColormap *	RETVAL;

	RETVAL = gtk_widget_get_default_colormap(/* void */);
	ST(0) = newSVGdkColormap (RETVAL);
	sv_2mortal(ST(0));
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Gtk2__Widget_get_default_visual); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Widget_get_default_visual)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "class_or_widget");
    {
	GdkVisual *	RETVAL;

	RETVAL = gtk_widget_get_default_visual(/* void */);
	ST(0) = newSVGdkVisual (RETVAL);
	sv_2mortal(ST(0));
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Gtk2__Widget_set_direction); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Widget_set_direction)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "widget, dir");
    {
	GtkWidget *	widget = SvGtkWidget (ST(0))
;
	GtkTextDirection	dir = SvGtkTextDirection (ST(1))
;

	gtk_widget_set_direction(widget, dir);
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_Gtk2__Widget_get_direction); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Widget_get_direction)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "widget");
    {
	GtkTextDirection	RETVAL;
	GtkWidget *	widget = SvGtkWidget (ST(0))
;

	RETVAL = gtk_widget_get_direction(widget);
	ST(0) = newSVGtkTextDirection (RETVAL);
	sv_2mortal(ST(0));
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Gtk2__Widget_set_default_direction); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Widget_set_default_direction)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "class, dir");
    {
	GtkTextDirection	dir = SvGtkTextDirection (ST(1))
;

	gtk_widget_set_default_direction(dir);
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_Gtk2__Widget_get_default_direction); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Widget_get_default_direction)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "class");
    {
	GtkTextDirection	RETVAL;

	RETVAL = gtk_widget_get_default_direction(/* void */);
	ST(0) = newSVGtkTextDirection (RETVAL);
	sv_2mortal(ST(0));
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Gtk2__Widget_shape_combine_mask); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Widget_shape_combine_mask)
{
    dVAR; dXSARGS;
    if (items != 4)
       croak_xs_usage(cv,  "widget, shape_mask, offset_x, offset_y");
    {
	GtkWidget *	widget = SvGtkWidget (ST(0))
;
	GdkBitmap_ornull *	shape_mask = SvGdkBitmap_ornull (ST(1))
;
	gint	offset_x = (gint)SvIV(ST(2))
;
	gint	offset_y = (gint)SvIV(ST(3))
;

	gtk_widget_shape_combine_mask(widget, shape_mask, offset_x, offset_y);
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_Gtk2__Widget_path); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Widget_path)
{
    dVAR; dXSARGS;
    dXSI32;
    if (items != 1)
       croak_xs_usage(cv,  "widget");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
#line 1112 "xs/GtkWidget.xs"
	gchar *path = NULL, *path_reversed = NULL;
#line 2256 "xs/GtkWidget.c"
	GtkWidget *	widget = SvGtkWidget (ST(0))
;
#line 1114 "xs/GtkWidget.xs"
	if (ix == 1)
		gtk_widget_class_path (widget, NULL, &path, &path_reversed);
	else
		gtk_widget_path (widget, NULL, &path, &path_reversed);
	EXTEND (SP, 2);
	PUSHs (sv_2mortal (newSVGChar (path)));
	PUSHs (sv_2mortal (newSVGChar (path_reversed)));
	g_free (path);
	g_free (path_reversed);
#line 2269 "xs/GtkWidget.c"
	PUTBACK;
	return;
    }
}

#if GTK_CHECK_VERSION(2,2,0)
#define XSubPPtmpAAAB 1


XS_EUPXS(XS_Gtk2__Widget_find_style_property); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Widget_find_style_property)
{
    dVAR; dXSARGS;
    dXSI32;
    if (items < 1)
       croak_xs_usage(cv,  "widget_or_class_name, ...");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
	SV *	widget_or_class_name = ST(0)
;
#line 1174 "xs/GtkWidget.xs"
	GType type;
	gchar *name = NULL;
	GtkWidgetClass *widget_class;
#line 2295 "xs/GtkWidget.c"
#line 1178 "xs/GtkWidget.xs"
	/* ENHANCE-ME: share this SV to GType lookup code with
	   Glib::Object::find_property and Gtk2::Container::find_child_property
	   and probably other places.  Might pass GTK_TYPE_WIDGET to say it
	   should be a widget. */
	if (gperl_sv_is_defined (widget_or_class_name) &&
	    SvROK (widget_or_class_name)) {
		GtkWidget * widget = SvGtkWidget (widget_or_class_name);
		if (!widget)
			croak ("wha?  NULL widget in list_style_properties");
		type = G_OBJECT_TYPE (widget);
	} else {
		type = gperl_object_type_from_package
			(SvPV_nolen (widget_or_class_name));
		if (!type)
			croak ("package %s is not registered with GPerl",
			       SvPV_nolen (widget_or_class_name));
	}

	switch (ix) {
	case 0:
		if (items != 2)
			croak ("Usage: Gtk2::Widget::find_style_property (class, name)");
		name = SvGChar (ST (1));
		break;
	default: /* ix==1 */
		if (items != 1)
			croak ("Usage: Gtk2::Widget::list_style_properties (class)");
		break;
	}
	if (! g_type_is_a (type, GTK_TYPE_WIDGET))
		croak ("Not a Gtk2::Widget");

	/* classes registered by perl are kept alive by the bindings.
	 * those coming straight from C are not.  if we had an actual
	 * widget, the class will be alive, but if we just had a
	 * package, the class may not exist yet.  thus, we'll have to
	 * do an honest ref here, rather than a peek.
	 */
	widget_class = g_type_class_ref (type);

	if (ix == 0) {
		GParamSpec *pspec
		  = gtk_widget_class_find_style_property
		      (widget_class, name);
		XPUSHs (pspec
			? sv_2mortal (newSVGParamSpec (pspec))
			: &PL_sv_undef);
	}
	else if (ix == 1) {
		GParamSpec **props;
		guint n_props, i;
		props = gtk_widget_class_list_style_properties
			  (widget_class, &n_props);
		if (n_props) {
			EXTEND (SP, n_props);
			for (i = 0; i < n_props; i++)
				PUSHs (sv_2mortal (newSVGParamSpec (props[i])));
		}
		g_free (props); /* must free even when n_props==0 */
	}

	g_type_class_unref (widget_class);
#line 2359 "xs/GtkWidget.c"
	PUTBACK;
	return;
    }
}


XS_EUPXS(XS_Gtk2__Widget_get_clipboard); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Widget_get_clipboard)
{
    dVAR; dXSARGS;
    if (items < 1 || items > 2)
       croak_xs_usage(cv,  "widget, selection=GDK_SELECTION_CLIPBOARD");
    {
	GtkWidget *	widget = SvGtkWidget (ST(0))
;
	GdkAtom	selection;
	GtkClipboard *	RETVAL;

	if (items < 2)
	    selection = GDK_SELECTION_CLIPBOARD;
	else {
	    selection = SvGdkAtom (ST(1))
;
	}

	RETVAL = gtk_widget_get_clipboard(widget, selection);
	ST(0) = newSVGtkClipboard (RETVAL);
	sv_2mortal(ST(0));
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Gtk2__Widget_get_display); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Widget_get_display)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "widget");
    {
	GdkDisplay *	RETVAL;
	GtkWidget *	widget = SvGtkWidget (ST(0))
;

	RETVAL = gtk_widget_get_display(widget);
	ST(0) = newSVGdkDisplay (RETVAL);
	sv_2mortal(ST(0));
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Gtk2__Widget_get_root_window); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Widget_get_root_window)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "widget");
    {
	GdkWindow *	RETVAL;
	GtkWidget *	widget = SvGtkWidget (ST(0))
;

	RETVAL = gtk_widget_get_root_window(widget);
	ST(0) = newSVGdkWindow (RETVAL);
	sv_2mortal(ST(0));
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Gtk2__Widget_get_screen); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Widget_get_screen)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "widget");
    {
	GdkScreen *	RETVAL;
	GtkWidget *	widget = SvGtkWidget (ST(0))
;

	RETVAL = gtk_widget_get_screen(widget);
	ST(0) = newSVGdkScreen (RETVAL);
	sv_2mortal(ST(0));
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Gtk2__Widget_has_screen); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Widget_has_screen)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "widget");
    {
	gboolean	RETVAL;
	GtkWidget *	widget = SvGtkWidget (ST(0))
;

	RETVAL = gtk_widget_has_screen(widget);
	ST(0) = boolSV(RETVAL);
    }
    XSRETURN(1);
}

#endif
#if GTK_CHECK_VERSION(2,4,0)
#define XSubPPtmpAAAC 1


XS_EUPXS(XS_Gtk2__Widget_set_no_show_all); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Widget_set_no_show_all)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "widget, no_show_all");
    {
	GtkWidget *	widget = SvGtkWidget (ST(0))
;
	gboolean	no_show_all = (bool)SvTRUE(ST(1))
;

	gtk_widget_set_no_show_all(widget, no_show_all);
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_Gtk2__Widget_get_no_show_all); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Widget_get_no_show_all)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "widget");
    {
	gboolean	RETVAL;
	GtkWidget *	widget = SvGtkWidget (ST(0))
;

	RETVAL = gtk_widget_get_no_show_all(widget);
	ST(0) = boolSV(RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Gtk2__Widget_queue_resize_no_redraw); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Widget_queue_resize_no_redraw)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "widget");
    {
	GtkWidget *	widget = SvGtkWidget (ST(0))
;

	gtk_widget_queue_resize_no_redraw(widget);
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_Gtk2__Widget_can_activate_accel); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Widget_can_activate_accel)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "widget, signal_id");
    {
	GtkWidget *	widget = SvGtkWidget (ST(0))
;
	guint	signal_id = (guint)SvUV(ST(1))
;
	gboolean	RETVAL;

	RETVAL = gtk_widget_can_activate_accel(widget, signal_id);
	ST(0) = boolSV(RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Gtk2__Widget_list_mnemonic_labels); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Widget_list_mnemonic_labels)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "widget");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
	GtkWidget *	widget = SvGtkWidget (ST(0))
;
#line 1277 "xs/GtkWidget.xs"
	GList *i, *list = NULL;
#line 2557 "xs/GtkWidget.c"
#line 1279 "xs/GtkWidget.xs"
	list = gtk_widget_list_mnemonic_labels (widget);
	for (i = list; i != NULL; i = i->next)
		XPUSHs (sv_2mortal (newSVGtkWidget (i->data)));
	g_list_free (list);
#line 2563 "xs/GtkWidget.c"
	PUTBACK;
	return;
    }
}


XS_EUPXS(XS_Gtk2__Widget_add_mnemonic_label); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Widget_add_mnemonic_label)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "widget, label");
    {
	GtkWidget *	widget = SvGtkWidget (ST(0))
;
	GtkWidget *	label = SvGtkWidget (ST(1))
;

	gtk_widget_add_mnemonic_label(widget, label);
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_Gtk2__Widget_remove_mnemonic_label); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Widget_remove_mnemonic_label)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "widget, label");
    {
	GtkWidget *	widget = SvGtkWidget (ST(0))
;
	GtkWidget *	label = SvGtkWidget (ST(1))
;

	gtk_widget_remove_mnemonic_label(widget, label);
    }
    XSRETURN_EMPTY;
}

#endif
#if GTK_CHECK_VERSION(2, 10, 0)
#define XSubPPtmpAAAD 1


XS_EUPXS(XS_Gtk2__Widget_input_shape_combine_mask); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Widget_input_shape_combine_mask)
{
    dVAR; dXSARGS;
    if (items != 4)
       croak_xs_usage(cv,  "widget, shape_mask, offset_x, offset_y");
    {
	GtkWidget *	widget = SvGtkWidget (ST(0))
;
	GdkBitmap_ornull *	shape_mask = SvGdkBitmap_ornull (ST(1))
;
	gint	offset_x = (gint)SvIV(ST(2))
;
	gint	offset_y = (gint)SvIV(ST(3))
;

	gtk_widget_input_shape_combine_mask(widget, shape_mask, offset_x, offset_y);
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_Gtk2__Widget_is_composited); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Widget_is_composited)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "widget");
    {
	gboolean	RETVAL;
	GtkWidget *	widget = SvGtkWidget (ST(0))
;

	RETVAL = gtk_widget_is_composited(widget);
	ST(0) = boolSV(RETVAL);
    }
    XSRETURN(1);
}

#endif /* 2.10 */
#if GTK_CHECK_VERSION(2, 12, 0)
#define XSubPPtmpAAAE 1


XS_EUPXS(XS_Gtk2__Widget_keynav_failed); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Widget_keynav_failed)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "widget, direction");
    {
	gboolean	RETVAL;
	GtkWidget *	widget = SvGtkWidget (ST(0))
;
	GtkDirectionType	direction = SvGtkDirectionType (ST(1))
;

	RETVAL = gtk_widget_keynav_failed(widget, direction);
	ST(0) = boolSV(RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Gtk2__Widget_error_bell); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Widget_error_bell)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "widget");
    {
	GtkWidget *	widget = SvGtkWidget (ST(0))
;

	gtk_widget_error_bell(widget);
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_Gtk2__Widget_set_tooltip_window); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Widget_set_tooltip_window)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "widget, custom_window");
    {
	GtkWidget *	widget = SvGtkWidget (ST(0))
;
	GtkWindow_ornull *	custom_window = SvGtkWindow_ornull (ST(1))
;

	gtk_widget_set_tooltip_window(widget, custom_window);
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_Gtk2__Widget_get_tooltip_window); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Widget_get_tooltip_window)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "widget");
    {
	GtkWindow_ornull *	RETVAL;
	GtkWidget *	widget = SvGtkWidget (ST(0))
;

	RETVAL = gtk_widget_get_tooltip_window(widget);
	ST(0) = newSVGtkWindow_ornull (RETVAL);
	sv_2mortal(ST(0));
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Gtk2__Widget_trigger_tooltip_query); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Widget_trigger_tooltip_query)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "widget");
    {
	GtkWidget *	widget = SvGtkWidget (ST(0))
;

	gtk_widget_trigger_tooltip_query(widget);
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_Gtk2__Widget_set_tooltip_text); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Widget_set_tooltip_text)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "widget, text");
    {
	GtkWidget *	widget = SvGtkWidget (ST(0))
;
	const gchar_ornull *	text;

	/* same as SvGChar(), but allows undef as NULL */
	if (gperl_sv_is_defined (ST(1))) {
		sv_utf8_upgrade (ST(1));
		text = (const gchar_ornull *)SvPV_nolen (ST(1));
	} else {
		text = NULL;
	}
;

	gtk_widget_set_tooltip_text(widget, text);
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_Gtk2__Widget_get_tooltip_text); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Widget_get_tooltip_text)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "widget");
    {
	gchar_own *	RETVAL;
	GtkWidget *	widget = SvGtkWidget (ST(0))
;

	RETVAL = gtk_widget_get_tooltip_text(widget);
	ST(0) = sv_newmortal();
	/* used when we can directly own the returned string. */
	/* we have to copy in the case when perl's malloc != gtk's malloc,
         * so best copy all the time. */
	sv_setpv ((SV*)ST(0), RETVAL);
	SvUTF8_on (ST(0));
        g_free (RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Gtk2__Widget_set_tooltip_markup); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Widget_set_tooltip_markup)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "widget, markup");
    {
	GtkWidget *	widget = SvGtkWidget (ST(0))
;
	const gchar_ornull *	markup;

	/* same as SvGChar(), but allows undef as NULL */
	if (gperl_sv_is_defined (ST(1))) {
		sv_utf8_upgrade (ST(1));
		markup = (const gchar_ornull *)SvPV_nolen (ST(1));
	} else {
		markup = NULL;
	}
;

	gtk_widget_set_tooltip_markup(widget, markup);
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_Gtk2__Widget_get_tooltip_markup); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Widget_get_tooltip_markup)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "widget");
    {
	gchar_own *	RETVAL;
	GtkWidget *	widget = SvGtkWidget (ST(0))
;

	RETVAL = gtk_widget_get_tooltip_markup(widget);
	ST(0) = sv_newmortal();
	/* used when we can directly own the returned string. */
	/* we have to copy in the case when perl's malloc != gtk's malloc,
         * so best copy all the time. */
	sv_setpv ((SV*)ST(0), RETVAL);
	SvUTF8_on (ST(0));
        g_free (RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Gtk2__Widget_modify_cursor); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Widget_modify_cursor)
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "widget, primary, secondary");
    {
	GtkWidget *	widget = SvGtkWidget (ST(0))
;
	const GdkColor_ornull *	primary = SvGdkColor_ornull (ST(1))
;
	const GdkColor_ornull *	secondary = SvGdkColor_ornull (ST(2))
;

	gtk_widget_modify_cursor(widget, primary, secondary);
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_Gtk2__Widget_set_has_tooltip); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Widget_set_has_tooltip)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "widget, has_tooltip");
    {
	GtkWidget *	widget = SvGtkWidget (ST(0))
;
	gboolean	has_tooltip = (bool)SvTRUE(ST(1))
;

	gtk_widget_set_has_tooltip(widget, has_tooltip);
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_Gtk2__Widget_get_has_tooltip); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Widget_get_has_tooltip)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "widget");
    {
	gboolean	RETVAL;
	GtkWidget *	widget = SvGtkWidget (ST(0))
;

	RETVAL = gtk_widget_get_has_tooltip(widget);
	ST(0) = boolSV(RETVAL);
    }
    XSRETURN(1);
}

#endif
#if GTK_CHECK_VERSION (2, 14, 0)
#define XSubPPtmpAAAF 1


XS_EUPXS(XS_Gtk2__Widget_get_snapshot); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Widget_get_snapshot)
{
    dVAR; dXSARGS;
    if (items < 1 || items > 2)
       croak_xs_usage(cv,  "widget, clip_rect=NULL");
    {
	GdkPixmap_noinc_ornull *	RETVAL;
	GtkWidget *	widget = SvGtkWidget (ST(0))
;
	GdkRectangle_ornull *	clip_rect;

	if (items < 2)
	    clip_rect = NULL;
	else {
	    clip_rect = SvGdkRectangle_ornull (ST(1))
;
	}

	RETVAL = gtk_widget_get_snapshot(widget, clip_rect);
	ST(0) = newSVGdkPixmap_noinc_ornull (RETVAL);
	sv_2mortal(ST(0));
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Gtk2__Widget_get_window); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Widget_get_window)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "widget");
    {
	GdkWindow_ornull *	RETVAL;
	GtkWidget *	widget = SvGtkWidget (ST(0))
;

	RETVAL = gtk_widget_get_window(widget);
	ST(0) = newSVGdkWindow_ornull (RETVAL);
	sv_2mortal(ST(0));
    }
    XSRETURN(1);
}

#endif /* 2.14 */
#if GTK_CHECK_VERSION (2, 18, 0)
#define XSubPPtmpAAAG 1


XS_EUPXS(XS_Gtk2__Widget_set_allocation); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Widget_set_allocation)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "widget, allocation");
    {
	GtkWidget *	widget = SvGtkWidget (ST(0))
;
	const GdkRectangle *	allocation = SvGdkRectangle (ST(1))
;

	gtk_widget_set_allocation(widget, allocation);
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_Gtk2__Widget_get_allocation); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Widget_get_allocation)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "widget");
    {
#line 1340 "xs/GtkWidget.xs"
        GdkRectangle allocation;
#line 2980 "xs/GtkWidget.c"
	GdkRectangle_copy *	RETVAL;
	GtkWidget *	widget = SvGtkWidget (ST(0))
;
#line 1342 "xs/GtkWidget.xs"
        gtk_widget_get_allocation (widget, &allocation);
        RETVAL = &allocation;
#line 2987 "xs/GtkWidget.c"
	ST(0) = newSVGdkRectangle_copy (RETVAL);
	sv_2mortal(ST(0));
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Gtk2__Widget_get_app_paintable); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Widget_get_app_paintable)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "widget");
    {
	gboolean	RETVAL;
	GtkWidget *	widget = SvGtkWidget (ST(0))
;

	RETVAL = gtk_widget_get_app_paintable(widget);
	ST(0) = boolSV(RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Gtk2__Widget_get_can_default); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Widget_get_can_default)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "widget");
    {
	gboolean	RETVAL;
	GtkWidget *	widget = SvGtkWidget (ST(0))
;

	RETVAL = gtk_widget_get_can_default(widget);
	ST(0) = boolSV(RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Gtk2__Widget_set_can_default); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Widget_set_can_default)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "widget, can_default");
    {
	GtkWidget *	widget = SvGtkWidget (ST(0))
;
	gboolean	can_default = (bool)SvTRUE(ST(1))
;

	gtk_widget_set_can_default(widget, can_default);
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_Gtk2__Widget_get_can_focus); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Widget_get_can_focus)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "widget");
    {
	gboolean	RETVAL;
	GtkWidget *	widget = SvGtkWidget (ST(0))
;

	RETVAL = gtk_widget_get_can_focus(widget);
	ST(0) = boolSV(RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Gtk2__Widget_set_can_focus); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Widget_set_can_focus)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "widget, can_focus");
    {
	GtkWidget *	widget = SvGtkWidget (ST(0))
;
	gboolean	can_focus = (bool)SvTRUE(ST(1))
;

	gtk_widget_set_can_focus(widget, can_focus);
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_Gtk2__Widget_get_double_buffered); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Widget_get_double_buffered)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "widget");
    {
	gboolean	RETVAL;
	GtkWidget *	widget = SvGtkWidget (ST(0))
;

	RETVAL = gtk_widget_get_double_buffered(widget);
	ST(0) = boolSV(RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Gtk2__Widget_set_has_window); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Widget_set_has_window)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "widget, has_window");
    {
	GtkWidget *	widget = SvGtkWidget (ST(0))
;
	gboolean	has_window = (bool)SvTRUE(ST(1))
;

	gtk_widget_set_has_window(widget, has_window);
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_Gtk2__Widget_get_has_window); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Widget_get_has_window)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "widget");
    {
	gboolean	RETVAL;
	GtkWidget *	widget = SvGtkWidget (ST(0))
;

	RETVAL = gtk_widget_get_has_window(widget);
	ST(0) = boolSV(RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Gtk2__Widget_set_receives_default); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Widget_set_receives_default)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "widget, receives_default");
    {
	GtkWidget *	widget = SvGtkWidget (ST(0))
;
	gboolean	receives_default = (bool)SvTRUE(ST(1))
;

	gtk_widget_set_receives_default(widget, receives_default);
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_Gtk2__Widget_get_receives_default); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Widget_get_receives_default)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "widget");
    {
	gboolean	RETVAL;
	GtkWidget *	widget = SvGtkWidget (ST(0))
;

	RETVAL = gtk_widget_get_receives_default(widget);
	ST(0) = boolSV(RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Gtk2__Widget_get_sensitive); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Widget_get_sensitive)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "widget");
    {
	gboolean	RETVAL;
	GtkWidget *	widget = SvGtkWidget (ST(0))
;

	RETVAL = gtk_widget_get_sensitive(widget);
	ST(0) = boolSV(RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Gtk2__Widget_get_state); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Widget_get_state)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "widget");
    {
	GtkStateType	RETVAL;
	GtkWidget *	widget = SvGtkWidget (ST(0))
;

	RETVAL = gtk_widget_get_state(widget);
	ST(0) = newSVGtkStateType (RETVAL);
	sv_2mortal(ST(0));
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Gtk2__Widget_get_visible); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Widget_get_visible)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "widget");
    {
	gboolean	RETVAL;
	GtkWidget *	widget = SvGtkWidget (ST(0))
;

	RETVAL = gtk_widget_get_visible(widget);
	ST(0) = boolSV(RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Gtk2__Widget_set_visible); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Widget_set_visible)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "widget, visible");
    {
	GtkWidget *	widget = SvGtkWidget (ST(0))
;
	gboolean	visible = (bool)SvTRUE(ST(1))
;

	gtk_widget_set_visible(widget, visible);
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_Gtk2__Widget_is_drawable); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Widget_is_drawable)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "widget");
    {
	gboolean	RETVAL;
	GtkWidget *	widget = SvGtkWidget (ST(0))
;

	RETVAL = gtk_widget_is_drawable(widget);
	ST(0) = boolSV(RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Gtk2__Widget_is_toplevel); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Widget_is_toplevel)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "widget");
    {
	gboolean	RETVAL;
	GtkWidget *	widget = SvGtkWidget (ST(0))
;

	RETVAL = gtk_widget_is_toplevel(widget);
	ST(0) = boolSV(RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Gtk2__Widget_set_window); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Widget_set_window)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "widget, window");
    {
	GtkWidget *	widget = SvGtkWidget (ST(0))
;
	GdkWindow *	window = SvGdkWindow (ST(1))
;

	gtk_widget_set_window(widget, window);
    }
    XSRETURN_EMPTY;
}

#endif /* 2.18 */
#if GTK_CHECK_VERSION (2, 20, 0)
#define XSubPPtmpAAAH 1


XS_EUPXS(XS_Gtk2__Widget_set_realized); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Widget_set_realized)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "widget, realized");
    {
	GtkWidget *	widget = SvGtkWidget (ST(0))
;
	gboolean	realized = (bool)SvTRUE(ST(1))
;

	gtk_widget_set_realized(widget, realized);
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_Gtk2__Widget_get_realized); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Widget_get_realized)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "widget");
    {
	gboolean	RETVAL;
	GtkWidget *	widget = SvGtkWidget (ST(0))
;

	RETVAL = gtk_widget_get_realized(widget);
	ST(0) = boolSV(RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Gtk2__Widget_set_mapped); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Widget_set_mapped)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "widget, mapped");
    {
	GtkWidget *	widget = SvGtkWidget (ST(0))
;
	gboolean	mapped = (bool)SvTRUE(ST(1))
;

	gtk_widget_set_mapped(widget, mapped);
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_Gtk2__Widget_get_mapped); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Widget_get_mapped)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "widget");
    {
	gboolean	RETVAL;
	GtkWidget *	widget = SvGtkWidget (ST(0))
;

	RETVAL = gtk_widget_get_mapped(widget);
	ST(0) = boolSV(RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Gtk2__Widget_get_requisition); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Widget_get_requisition)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "widget");
    {
#line 1406 "xs/GtkWidget.xs"
	GtkRequisition requisition;
#line 3387 "xs/GtkWidget.c"
	GtkRequisition_copy *	RETVAL;
	GtkWidget *	widget = SvGtkWidget (ST(0))
;
#line 1408 "xs/GtkWidget.xs"
	gtk_widget_get_requisition (widget, &requisition);
	RETVAL = &requisition;
#line 3394 "xs/GtkWidget.c"
	ST(0) = newSVGtkRequisition_copy (RETVAL);
	sv_2mortal(ST(0));
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Gtk2__Widget_has_rc_style); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Widget_has_rc_style)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "widget");
    {
	gboolean	RETVAL;
	GtkWidget *	widget = SvGtkWidget (ST(0))
;

	RETVAL = gtk_widget_has_rc_style(widget);
	ST(0) = boolSV(RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Gtk2__Widget_style_attach); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Widget_style_attach)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "style");
    {
	GtkWidget *	style = SvGtkWidget (ST(0))
;

	gtk_widget_style_attach(style);
    }
    XSRETURN_EMPTY;
}

#endif /* 2.20 */
#if GTK_CHECK_VERSION (2, 22, 0)
#define XSubPPtmpAAAI 1


XS_EUPXS(XS_Gtk2__Widget_send_focus_change); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Widget_send_focus_change)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "widget, event");
    {
	gboolean	RETVAL;
	GtkWidget *	widget = SvGtkWidget (ST(0))
;
	GdkEvent *	event = SvGdkEvent (ST(1))
;

	RETVAL = gtk_widget_send_focus_change(widget, event);
	ST(0) = boolSV(RETVAL);
    }
    XSRETURN(1);
}

#endif /* 2.22 */
#ifdef __cplusplus
extern "C"
#endif
XS_EXTERNAL(boot_Gtk2__Widget); /* prototype to pass -Wmissing-prototypes */
XS_EXTERNAL(boot_Gtk2__Widget)
{
    dVAR; dXSARGS;
#if (PERL_REVISION == 5 && PERL_VERSION < 9)
    char* file = __FILE__;
#else
    const char* file = __FILE__;
#endif

    PERL_UNUSED_VAR(cv); /* -W */
    PERL_UNUSED_VAR(items); /* -W */
#ifdef XS_APIVERSION_BOOTCHECK
    XS_APIVERSION_BOOTCHECK;
#endif
    XS_VERSION_BOOTCHECK;

    {
        CV * cv;

        cv = newXS("Gtk2::Requisition::height", XS_Gtk2__Requisition_width, file);
        XSANY.any_i32 = 1;
        cv = newXS("Gtk2::Requisition::width", XS_Gtk2__Requisition_width, file);
        XSANY.any_i32 = 0;
        newXS("Gtk2::Requisition::new", XS_Gtk2__Requisition_new, file);
        newXS("Gtk2::Widget::_INSTALL_OVERRIDES", XS_Gtk2__Widget__INSTALL_OVERRIDES, file);
        newXS("Gtk2::Widget::window", XS_Gtk2__Widget_window, file);
        newXS("Gtk2::Widget::requisition", XS_Gtk2__Widget_requisition, file);
        newXS("Gtk2::Widget::allocation", XS_Gtk2__Widget_allocation, file);
        cv = newXS("Gtk2::Widget::get_style", XS_Gtk2__Widget_style, file);
        XSANY.any_i32 = 1;
        cv = newXS("Gtk2::Widget::style", XS_Gtk2__Widget_style, file);
        XSANY.any_i32 = 0;
        cv = newXS("Gtk2::Widget::saved_state", XS_Gtk2__Widget_state, file);
        XSANY.any_i32 = 1;
        cv = newXS("Gtk2::Widget::state", XS_Gtk2__Widget_state, file);
        XSANY.any_i32 = 0;
        cv = newXS("Gtk2::Widget::app_paintable", XS_Gtk2__Widget_toplevel, file);
        XSANY.any_i32 = 14;
        cv = newXS("Gtk2::Widget::can_default", XS_Gtk2__Widget_toplevel, file);
        XSANY.any_i32 = 17;
        cv = newXS("Gtk2::Widget::can_focus", XS_Gtk2__Widget_toplevel, file);
        XSANY.any_i32 = 9;
        cv = newXS("Gtk2::Widget::composite_child", XS_Gtk2__Widget_toplevel, file);
        XSANY.any_i32 = 13;
        cv = newXS("Gtk2::Widget::double_buffered", XS_Gtk2__Widget_toplevel, file);
        XSANY.any_i32 = 16;
        cv = newXS("Gtk2::Widget::drawable", XS_Gtk2__Widget_toplevel, file);
        XSANY.any_i32 = 5;
        cv = newXS("Gtk2::Widget::has_default", XS_Gtk2__Widget_toplevel, file);
        XSANY.any_i32 = 18;
        cv = newXS("Gtk2::Widget::has_focus", XS_Gtk2__Widget_toplevel, file);
        XSANY.any_i32 = 10;
        cv = newXS("Gtk2::Widget::has_grab", XS_Gtk2__Widget_toplevel, file);
        XSANY.any_i32 = 11;
        cv = newXS("Gtk2::Widget::is_sensitive", XS_Gtk2__Widget_toplevel, file);
        XSANY.any_i32 = 8;
        cv = newXS("Gtk2::Widget::mapped", XS_Gtk2__Widget_toplevel, file);
        XSANY.any_i32 = 3;
        cv = newXS("Gtk2::Widget::no_window", XS_Gtk2__Widget_toplevel, file);
        XSANY.any_i32 = 1;
        cv = newXS("Gtk2::Widget::parent_sensitive", XS_Gtk2__Widget_toplevel, file);
        XSANY.any_i32 = 7;
        cv = newXS("Gtk2::Widget::rc_style", XS_Gtk2__Widget_toplevel, file);
        XSANY.any_i32 = 12;
        cv = newXS("Gtk2::Widget::realized", XS_Gtk2__Widget_toplevel, file);
        XSANY.any_i32 = 2;
        cv = newXS("Gtk2::Widget::receives_default", XS_Gtk2__Widget_toplevel, file);
        XSANY.any_i32 = 15;
        cv = newXS("Gtk2::Widget::sensitive", XS_Gtk2__Widget_toplevel, file);
        XSANY.any_i32 = 6;
        cv = newXS("Gtk2::Widget::toplevel", XS_Gtk2__Widget_toplevel, file);
        XSANY.any_i32 = 0;
        cv = newXS("Gtk2::Widget::visible", XS_Gtk2__Widget_toplevel, file);
        XSANY.any_i32 = 4;
        cv = newXS("Gtk2::Widget::flags", XS_Gtk2__Widget_flags, file);
        XSANY.any_i32 = 0;
        cv = newXS("Gtk2::Widget::get_flags", XS_Gtk2__Widget_flags, file);
        XSANY.any_i32 = 1;
        newXS("Gtk2::Widget::set_flags", XS_Gtk2__Widget_set_flags, file);
        newXS("Gtk2::Widget::unset_flags", XS_Gtk2__Widget_unset_flags, file);
        cv = newXS("Gtk2::Widget::destroy", XS_Gtk2__Widget_destroy, file);
        XSANY.any_i32 = 0;
        cv = newXS("Gtk2::Widget::freeze_child_notify", XS_Gtk2__Widget_destroy, file);
        XSANY.any_i32 = 16;
        cv = newXS("Gtk2::Widget::grab_default", XS_Gtk2__Widget_destroy, file);
        XSANY.any_i32 = 12;
        cv = newXS("Gtk2::Widget::grab_focus", XS_Gtk2__Widget_destroy, file);
        XSANY.any_i32 = 11;
        cv = newXS("Gtk2::Widget::hide", XS_Gtk2__Widget_destroy, file);
        XSANY.any_i32 = 4;
        cv = newXS("Gtk2::Widget::hide_all", XS_Gtk2__Widget_destroy, file);
        XSANY.any_i32 = 6;
        cv = newXS("Gtk2::Widget::map", XS_Gtk2__Widget_destroy, file);
        XSANY.any_i32 = 7;
        cv = newXS("Gtk2::Widget::queue_draw", XS_Gtk2__Widget_destroy, file);
        XSANY.any_i32 = 14;
        cv = newXS("Gtk2::Widget::queue_resize", XS_Gtk2__Widget_destroy, file);
        XSANY.any_i32 = 15;
        cv = newXS("Gtk2::Widget::realize", XS_Gtk2__Widget_destroy, file);
        XSANY.any_i32 = 9;
        cv = newXS("Gtk2::Widget::reset_shapes", XS_Gtk2__Widget_destroy, file);
        XSANY.any_i32 = 13;
        cv = newXS("Gtk2::Widget::show", XS_Gtk2__Widget_destroy, file);
        XSANY.any_i32 = 2;
        cv = newXS("Gtk2::Widget::show_all", XS_Gtk2__Widget_destroy, file);
        XSANY.any_i32 = 5;
        cv = newXS("Gtk2::Widget::show_now", XS_Gtk2__Widget_destroy, file);
        XSANY.any_i32 = 3;
        cv = newXS("Gtk2::Widget::thaw_child_notify", XS_Gtk2__Widget_destroy, file);
        XSANY.any_i32 = 17;
        cv = newXS("Gtk2::Widget::unmap", XS_Gtk2__Widget_destroy, file);
        XSANY.any_i32 = 8;
        cv = newXS("Gtk2::Widget::unparent", XS_Gtk2__Widget_destroy, file);
        XSANY.any_i32 = 1;
        cv = newXS("Gtk2::Widget::unrealize", XS_Gtk2__Widget_destroy, file);
        XSANY.any_i32 = 10;
        newXS("Gtk2::Widget::queue_draw_area", XS_Gtk2__Widget_queue_draw_area, file);
        newXS("Gtk2::Widget::size_request", XS_Gtk2__Widget_size_request, file);
        newXS("Gtk2::Widget::size_allocate", XS_Gtk2__Widget_size_allocate, file);
        newXS("Gtk2::Widget::get_child_requisition", XS_Gtk2__Widget_get_child_requisition, file);
        newXS("Gtk2::Widget::add_accelerator", XS_Gtk2__Widget_add_accelerator, file);
        newXS("Gtk2::Widget::remove_accelerator", XS_Gtk2__Widget_remove_accelerator, file);
        newXS("Gtk2::Widget::set_accel_path", XS_Gtk2__Widget_set_accel_path, file);
        newXS("Gtk2::Widget::mnemonic_activate", XS_Gtk2__Widget_mnemonic_activate, file);
        newXS("Gtk2::Widget::event", XS_Gtk2__Widget_event, file);
        newXS("Gtk2::Widget::activate", XS_Gtk2__Widget_activate, file);
        newXS("Gtk2::Widget::set_scroll_adjustments", XS_Gtk2__Widget_set_scroll_adjustments, file);
        newXS("Gtk2::Widget::reparent", XS_Gtk2__Widget_reparent, file);
        newXS("Gtk2::Widget::intersect", XS_Gtk2__Widget_intersect, file);
        newXS("Gtk2::Widget::region_intersect", XS_Gtk2__Widget_region_intersect, file);
        newXS("Gtk2::Widget::child_notify", XS_Gtk2__Widget_child_notify, file);
        newXS("Gtk2::Widget::is_focus", XS_Gtk2__Widget_is_focus, file);
        newXS("Gtk2::Widget::set_name", XS_Gtk2__Widget_set_name, file);
        newXS("Gtk2::Widget::get_name", XS_Gtk2__Widget_get_name, file);
        newXS("Gtk2::Widget::set_state", XS_Gtk2__Widget_set_state, file);
        newXS("Gtk2::Widget::set_sensitive", XS_Gtk2__Widget_set_sensitive, file);
        newXS("Gtk2::Widget::set_app_paintable", XS_Gtk2__Widget_set_app_paintable, file);
        newXS("Gtk2::Widget::set_double_buffered", XS_Gtk2__Widget_set_double_buffered, file);
        newXS("Gtk2::Widget::set_redraw_on_allocate", XS_Gtk2__Widget_set_redraw_on_allocate, file);
        newXS("Gtk2::Widget::set_parent", XS_Gtk2__Widget_set_parent, file);
        newXS("Gtk2::Widget::set_parent_window", XS_Gtk2__Widget_set_parent_window, file);
        newXS("Gtk2::Widget::set_child_visible", XS_Gtk2__Widget_set_child_visible, file);
        newXS("Gtk2::Widget::get_child_visible", XS_Gtk2__Widget_get_child_visible, file);
        cv = newXS("Gtk2::Widget::get_parent", XS_Gtk2__Widget_get_parent, file);
        XSANY.any_i32 = 0;
        cv = newXS("Gtk2::Widget::parent", XS_Gtk2__Widget_get_parent, file);
        XSANY.any_i32 = 1;
        newXS("Gtk2::Widget::get_parent_window", XS_Gtk2__Widget_get_parent_window, file);
        newXS("Gtk2::Widget::child_focus", XS_Gtk2__Widget_child_focus, file);
        newXS("Gtk2::Widget::set_size_request", XS_Gtk2__Widget_set_size_request, file);
        newXS("Gtk2::Widget::get_size_request", XS_Gtk2__Widget_get_size_request, file);
        newXS("Gtk2::Widget::set_events", XS_Gtk2__Widget_set_events, file);
        newXS("Gtk2::Widget::add_events", XS_Gtk2__Widget_add_events, file);
        newXS("Gtk2::Widget::set_extension_events", XS_Gtk2__Widget_set_extension_events, file);
        newXS("Gtk2::Widget::get_extension_events", XS_Gtk2__Widget_get_extension_events, file);
        newXS("Gtk2::Widget::get_toplevel", XS_Gtk2__Widget_get_toplevel, file);
        newXS("Gtk2::Widget::get_ancestor", XS_Gtk2__Widget_get_ancestor, file);
        newXS("Gtk2::Widget::get_colormap", XS_Gtk2__Widget_get_colormap, file);
        newXS("Gtk2::Widget::get_visual", XS_Gtk2__Widget_get_visual, file);
        newXS("Gtk2::Widget::get_settings", XS_Gtk2__Widget_get_settings, file);
        newXS("Gtk2::Widget::get_accessible", XS_Gtk2__Widget_get_accessible, file);
        newXS("Gtk2::Widget::set_colormap", XS_Gtk2__Widget_set_colormap, file);
        newXS("Gtk2::Widget::get_events", XS_Gtk2__Widget_get_events, file);
        newXS("Gtk2::Widget::get_pointer", XS_Gtk2__Widget_get_pointer, file);
        newXS("Gtk2::Widget::is_ancestor", XS_Gtk2__Widget_is_ancestor, file);
        newXS("Gtk2::Widget::translate_coordinates", XS_Gtk2__Widget_translate_coordinates, file);
        newXS("Gtk2::Widget::hide_on_delete", XS_Gtk2__Widget_hide_on_delete, file);
        newXS("Gtk2::Widget::set_style", XS_Gtk2__Widget_set_style, file);
        newXS("Gtk2::Widget::ensure_style", XS_Gtk2__Widget_ensure_style, file);
        newXS("Gtk2::Widget::modify_style", XS_Gtk2__Widget_modify_style, file);
        newXS("Gtk2::Widget::get_modifier_style", XS_Gtk2__Widget_get_modifier_style, file);
        newXS("Gtk2::Widget::modify_fg", XS_Gtk2__Widget_modify_fg, file);
        newXS("Gtk2::Widget::modify_bg", XS_Gtk2__Widget_modify_bg, file);
        newXS("Gtk2::Widget::modify_text", XS_Gtk2__Widget_modify_text, file);
        newXS("Gtk2::Widget::modify_base", XS_Gtk2__Widget_modify_base, file);
        newXS("Gtk2::Widget::modify_font", XS_Gtk2__Widget_modify_font, file);
        newXS("Gtk2::Widget::create_pango_context", XS_Gtk2__Widget_create_pango_context, file);
        newXS("Gtk2::Widget::get_pango_context", XS_Gtk2__Widget_get_pango_context, file);
        newXS("Gtk2::Widget::create_pango_layout", XS_Gtk2__Widget_create_pango_layout, file);
        newXS("Gtk2::Widget::render_icon", XS_Gtk2__Widget_render_icon, file);
        newXS("Gtk2::Widget::set_composite_name", XS_Gtk2__Widget_set_composite_name, file);
        newXS("Gtk2::Widget::get_composite_name", XS_Gtk2__Widget_get_composite_name, file);
        newXS("Gtk2::Widget::reset_rc_styles", XS_Gtk2__Widget_reset_rc_styles, file);
        newXS("Gtk2::Widget::push_colormap", XS_Gtk2__Widget_push_colormap, file);
        newXS("Gtk2::Widget::pop_colormap", XS_Gtk2__Widget_pop_colormap, file);
        newXS("Gtk2::Widget::push_composite_child", XS_Gtk2__Widget_push_composite_child, file);
        newXS("Gtk2::Widget::pop_composite_child", XS_Gtk2__Widget_pop_composite_child, file);
#if XSubPPtmpAAAA
        cv = newXS("Gtk2::Widget::style_get", XS_Gtk2__Widget_style_get, file);
        XSANY.any_i32 = 0;
        cv = newXS("Gtk2::Widget::style_get_property", XS_Gtk2__Widget_style_get, file);
        XSANY.any_i32 = 1;
#endif
        newXS("Gtk2::Widget::set_default_colormap", XS_Gtk2__Widget_set_default_colormap, file);
        newXS("Gtk2::Widget::get_default_style", XS_Gtk2__Widget_get_default_style, file);
        newXS("Gtk2::Widget::get_default_colormap", XS_Gtk2__Widget_get_default_colormap, file);
        newXS("Gtk2::Widget::get_default_visual", XS_Gtk2__Widget_get_default_visual, file);
        newXS("Gtk2::Widget::set_direction", XS_Gtk2__Widget_set_direction, file);
        newXS("Gtk2::Widget::get_direction", XS_Gtk2__Widget_get_direction, file);
        newXS("Gtk2::Widget::set_default_direction", XS_Gtk2__Widget_set_default_direction, file);
        newXS("Gtk2::Widget::get_default_direction", XS_Gtk2__Widget_get_default_direction, file);
        newXS("Gtk2::Widget::shape_combine_mask", XS_Gtk2__Widget_shape_combine_mask, file);
        cv = newXS("Gtk2::Widget::class_path", XS_Gtk2__Widget_path, file);
        XSANY.any_i32 = 1;
        cv = newXS("Gtk2::Widget::path", XS_Gtk2__Widget_path, file);
        XSANY.any_i32 = 0;
#if XSubPPtmpAAAB
        cv = newXS("Gtk2::Widget::find_style_property", XS_Gtk2__Widget_find_style_property, file);
        XSANY.any_i32 = 0;
        cv = newXS("Gtk2::Widget::list_style_properties", XS_Gtk2__Widget_find_style_property, file);
        XSANY.any_i32 = 1;
        newXS("Gtk2::Widget::get_clipboard", XS_Gtk2__Widget_get_clipboard, file);
        newXS("Gtk2::Widget::get_display", XS_Gtk2__Widget_get_display, file);
        newXS("Gtk2::Widget::get_root_window", XS_Gtk2__Widget_get_root_window, file);
        newXS("Gtk2::Widget::get_screen", XS_Gtk2__Widget_get_screen, file);
        newXS("Gtk2::Widget::has_screen", XS_Gtk2__Widget_has_screen, file);
#endif
#if XSubPPtmpAAAC
        newXS("Gtk2::Widget::set_no_show_all", XS_Gtk2__Widget_set_no_show_all, file);
        newXS("Gtk2::Widget::get_no_show_all", XS_Gtk2__Widget_get_no_show_all, file);
        newXS("Gtk2::Widget::queue_resize_no_redraw", XS_Gtk2__Widget_queue_resize_no_redraw, file);
        newXS("Gtk2::Widget::can_activate_accel", XS_Gtk2__Widget_can_activate_accel, file);
        newXS("Gtk2::Widget::list_mnemonic_labels", XS_Gtk2__Widget_list_mnemonic_labels, file);
        newXS("Gtk2::Widget::add_mnemonic_label", XS_Gtk2__Widget_add_mnemonic_label, file);
        newXS("Gtk2::Widget::remove_mnemonic_label", XS_Gtk2__Widget_remove_mnemonic_label, file);
#endif
#if XSubPPtmpAAAD
        newXS("Gtk2::Widget::input_shape_combine_mask", XS_Gtk2__Widget_input_shape_combine_mask, file);
        newXS("Gtk2::Widget::is_composited", XS_Gtk2__Widget_is_composited, file);
#endif
#if XSubPPtmpAAAE
        newXS("Gtk2::Widget::keynav_failed", XS_Gtk2__Widget_keynav_failed, file);
        newXS("Gtk2::Widget::error_bell", XS_Gtk2__Widget_error_bell, file);
        newXS("Gtk2::Widget::set_tooltip_window", XS_Gtk2__Widget_set_tooltip_window, file);
        newXS("Gtk2::Widget::get_tooltip_window", XS_Gtk2__Widget_get_tooltip_window, file);
        newXS("Gtk2::Widget::trigger_tooltip_query", XS_Gtk2__Widget_trigger_tooltip_query, file);
        newXS("Gtk2::Widget::set_tooltip_text", XS_Gtk2__Widget_set_tooltip_text, file);
        newXS("Gtk2::Widget::get_tooltip_text", XS_Gtk2__Widget_get_tooltip_text, file);
        newXS("Gtk2::Widget::set_tooltip_markup", XS_Gtk2__Widget_set_tooltip_markup, file);
        newXS("Gtk2::Widget::get_tooltip_markup", XS_Gtk2__Widget_get_tooltip_markup, file);
        newXS("Gtk2::Widget::modify_cursor", XS_Gtk2__Widget_modify_cursor, file);
        newXS("Gtk2::Widget::set_has_tooltip", XS_Gtk2__Widget_set_has_tooltip, file);
        newXS("Gtk2::Widget::get_has_tooltip", XS_Gtk2__Widget_get_has_tooltip, file);
#endif
#if XSubPPtmpAAAF
        newXS("Gtk2::Widget::get_snapshot", XS_Gtk2__Widget_get_snapshot, file);
        newXS("Gtk2::Widget::get_window", XS_Gtk2__Widget_get_window, file);
#endif
#if XSubPPtmpAAAG
        newXS("Gtk2::Widget::set_allocation", XS_Gtk2__Widget_set_allocation, file);
        newXS("Gtk2::Widget::get_allocation", XS_Gtk2__Widget_get_allocation, file);
        newXS("Gtk2::Widget::get_app_paintable", XS_Gtk2__Widget_get_app_paintable, file);
        newXS("Gtk2::Widget::get_can_default", XS_Gtk2__Widget_get_can_default, file);
        newXS("Gtk2::Widget::set_can_default", XS_Gtk2__Widget_set_can_default, file);
        newXS("Gtk2::Widget::get_can_focus", XS_Gtk2__Widget_get_can_focus, file);
        newXS("Gtk2::Widget::set_can_focus", XS_Gtk2__Widget_set_can_focus, file);
        newXS("Gtk2::Widget::get_double_buffered", XS_Gtk2__Widget_get_double_buffered, file);
        newXS("Gtk2::Widget::set_has_window", XS_Gtk2__Widget_set_has_window, file);
        newXS("Gtk2::Widget::get_has_window", XS_Gtk2__Widget_get_has_window, file);
        newXS("Gtk2::Widget::set_receives_default", XS_Gtk2__Widget_set_receives_default, file);
        newXS("Gtk2::Widget::get_receives_default", XS_Gtk2__Widget_get_receives_default, file);
        newXS("Gtk2::Widget::get_sensitive", XS_Gtk2__Widget_get_sensitive, file);
        newXS("Gtk2::Widget::get_state", XS_Gtk2__Widget_get_state, file);
        newXS("Gtk2::Widget::get_visible", XS_Gtk2__Widget_get_visible, file);
        newXS("Gtk2::Widget::set_visible", XS_Gtk2__Widget_set_visible, file);
        newXS("Gtk2::Widget::is_drawable", XS_Gtk2__Widget_is_drawable, file);
        newXS("Gtk2::Widget::is_toplevel", XS_Gtk2__Widget_is_toplevel, file);
        newXS("Gtk2::Widget::set_window", XS_Gtk2__Widget_set_window, file);
#endif
#if XSubPPtmpAAAH
        newXS("Gtk2::Widget::set_realized", XS_Gtk2__Widget_set_realized, file);
        newXS("Gtk2::Widget::get_realized", XS_Gtk2__Widget_get_realized, file);
        newXS("Gtk2::Widget::set_mapped", XS_Gtk2__Widget_set_mapped, file);
        newXS("Gtk2::Widget::get_mapped", XS_Gtk2__Widget_get_mapped, file);
        newXS("Gtk2::Widget::get_requisition", XS_Gtk2__Widget_get_requisition, file);
        newXS("Gtk2::Widget::has_rc_style", XS_Gtk2__Widget_has_rc_style, file);
        newXS("Gtk2::Widget::style_attach", XS_Gtk2__Widget_style_attach, file);
#endif
#if XSubPPtmpAAAI
        newXS("Gtk2::Widget::send_focus_change", XS_Gtk2__Widget_send_focus_change, file);
#endif
    }

    /* Initialisation Section */

#if XSubPPtmpAAAA
#endif
#if XSubPPtmpAAAB
#endif
#if XSubPPtmpAAAC
#endif
#if XSubPPtmpAAAD
#endif
#if XSubPPtmpAAAE
#endif
#if XSubPPtmpAAAF
#endif
#if XSubPPtmpAAAG
#endif
#if XSubPPtmpAAAH
#endif
#if XSubPPtmpAAAI
#endif
#line 3767 "xs/GtkWidget.c"

    /* End of Initialisation Section */

#if (PERL_REVISION == 5 && PERL_VERSION >= 9)
  if (PL_unitcheckav)
       call_list(PL_scopestack_ix, PL_unitcheckav);
#endif
    XSRETURN_YES;
}

