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

#line 1 "xs/GtkWindow.xs"
/*
 * Copyright (c) 2003-2006, 2009 by the gtk2-perl team (see the file AUTHORS)
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Library General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Library General Public License for more details.
 *
 * You should have received a copy of the GNU Library General Public
 * License along with this library; if not, write to the 
 * Free Software Foundation, Inc., 59 Temple Place - Suite 330, 
 * Boston, MA  02111-1307  USA.
 *
 * $Id$
 */

#include "gtk2perl.h"

#line 34 "xs/GtkWindow.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 176 "xs/GtkWindow.c"

XS_EUPXS(XS_Gtk2__Window_new); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Window_new)
{
    dVAR; dXSARGS;
    if (items < 1 || items > 2)
       croak_xs_usage(cv,  "class, type=GTK_WINDOW_TOPLEVEL");
    {
	GtkWindowType	type;
	GtkWidget *	RETVAL;

	if (items < 2)
	    type = GTK_WINDOW_TOPLEVEL;
	else {
	    type = SvGtkWindowType (ST(1))
;
	}

	RETVAL = gtk_window_new(type);
	ST(0) = newSVGtkWidget (RETVAL);
	sv_2mortal(ST(0));
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Gtk2__Window_set_title); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Window_set_title)
{
    dVAR; dXSARGS;
    if (items < 1 || items > 2)
       croak_xs_usage(cv,  "window, title=NULL");
    {
	GtkWindow *	window = SvGtkWindow (ST(0))
;
	const gchar_ornull *	title;

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

	gtk_window_set_title(window, title);
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_Gtk2__Window_set_wmclass); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Window_set_wmclass)
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "window, wmclass_name, wmclass_class");
    {
	GtkWindow *	window = SvGtkWindow (ST(0))
;
	const gchar *	wmclass_name;
	const gchar *	wmclass_class;

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

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

	gtk_window_set_wmclass(window, wmclass_name, wmclass_class);
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_Gtk2__Window_set_role); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Window_set_role)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "window, role");
    {
	GtkWindow *	window = SvGtkWindow (ST(0))
;
	const gchar *	role;

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

	gtk_window_set_role(window, role);
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_Gtk2__Window_get_role); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Window_get_role)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "window");
    {
	GtkWindow *	window = SvGtkWindow (ST(0))
;
	const gchar *	RETVAL;

	RETVAL = gtk_window_get_role(window);
	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__Window_add_accel_group); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Window_add_accel_group)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "window, accel_group");
    {
	GtkWindow *	window = SvGtkWindow (ST(0))
;
	GtkAccelGroup *	accel_group = SvGtkAccelGroup (ST(1))
;

	gtk_window_add_accel_group(window, accel_group);
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_Gtk2__Window_remove_accel_group); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Window_remove_accel_group)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "window, accel_group");
    {
	GtkWindow *	window = SvGtkWindow (ST(0))
;
	GtkAccelGroup *	accel_group = SvGtkAccelGroup (ST(1))
;

	gtk_window_remove_accel_group(window, accel_group);
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_Gtk2__Window_set_position); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Window_set_position)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "window, position");
    {
	GtkWindow *	window = SvGtkWindow (ST(0))
;
	GtkWindowPosition	position = SvGtkWindowPosition (ST(1))
;

	gtk_window_set_position(window, position);
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_Gtk2__Window_activate_focus); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Window_activate_focus)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "window");
    {
	GtkWindow *	window = SvGtkWindow (ST(0))
;
	gboolean	RETVAL;

	RETVAL = gtk_window_activate_focus(window);
	ST(0) = boolSV(RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Gtk2__Window_get_focus); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Window_get_focus)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "window");
    {
	GtkWindow *	window = SvGtkWindow (ST(0))
;
	GtkWidget_ornull *	RETVAL;

	RETVAL = gtk_window_get_focus(window);
	ST(0) = newSVGtkWidget_ornull (RETVAL);
	sv_2mortal(ST(0));
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Gtk2__Window_set_focus); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Window_set_focus)
{
    dVAR; dXSARGS;
    if (items < 1 || items > 2)
       croak_xs_usage(cv,  "window, focus=NULL");
    {
	GtkWindow *	window = SvGtkWindow (ST(0))
;
	GtkWidget_ornull *	focus;

	if (items < 2)
	    focus = NULL;
	else {
	    focus = SvGtkWidget_ornull (ST(1))
;
	}

	gtk_window_set_focus(window, focus);
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_Gtk2__Window_set_default); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Window_set_default)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "window, default_widget");
    {
	GtkWindow *	window = SvGtkWindow (ST(0))
;
	GtkWidget_ornull *	default_widget = SvGtkWidget_ornull (ST(1))
;

	gtk_window_set_default(window, default_widget);
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_Gtk2__Window_activate_default); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Window_activate_default)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "window");
    {
	GtkWindow *	window = SvGtkWindow (ST(0))
;
	gboolean	RETVAL;

	RETVAL = gtk_window_activate_default(window);
	ST(0) = boolSV(RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Gtk2__Window_set_default_size); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Window_set_default_size)
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "window, width, height");
    {
	GtkWindow *	window = SvGtkWindow (ST(0))
;
	gint	width = (gint)SvIV(ST(1))
;
	gint	height = (gint)SvIV(ST(2))
;

	gtk_window_set_default_size(window, width, height);
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_Gtk2__Window_set_modal); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Window_set_modal)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "window, modal");
    {
	GtkWindow *	window = SvGtkWindow (ST(0))
;
	gboolean	modal = (bool)SvTRUE(ST(1))
;

	gtk_window_set_modal(window, modal);
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_Gtk2__Window_set_transient_for); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Window_set_transient_for)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "window, parent");
    {
	GtkWindow *	window = SvGtkWindow (ST(0))
;
	GtkWindow_ornull *	parent = SvGtkWindow_ornull (ST(1))
;

	gtk_window_set_transient_for(window, parent);
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_Gtk2__Window_set_type_hint); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Window_set_type_hint)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "window, hint");
    {
	GtkWindow *	window = SvGtkWindow (ST(0))
;
	GdkWindowTypeHint	hint = SvGdkWindowTypeHint (ST(1))
;

	gtk_window_set_type_hint(window, hint);
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_Gtk2__Window_get_title); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Window_get_title)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "window");
    {
	GtkWindow *	window = SvGtkWindow (ST(0))
;
	const gchar *	RETVAL;

	RETVAL = gtk_window_get_title(window);
	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__Window_get_transient_for); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Window_get_transient_for)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "window");
    {
	GtkWindow *	window = SvGtkWindow (ST(0))
;
	GtkWindow_ornull *	RETVAL;

	RETVAL = gtk_window_get_transient_for(window);
	ST(0) = newSVGtkWindow_ornull (RETVAL);
	sv_2mortal(ST(0));
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Gtk2__Window_get_type_hint); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Window_get_type_hint)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "window");
    {
	GtkWindow *	window = SvGtkWindow (ST(0))
;
	GdkWindowTypeHint	RETVAL;

	RETVAL = gtk_window_get_type_hint(window);
	ST(0) = newSVGdkWindowTypeHint (RETVAL);
	sv_2mortal(ST(0));
    }
    XSRETURN(1);
}

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


XS_EUPXS(XS_Gtk2__Window_get_accept_focus); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Window_get_accept_focus)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "window");
    {
	gboolean	RETVAL;
	GtkWindow *	window = SvGtkWindow (ST(0))
;

	RETVAL = gtk_window_get_accept_focus(window);
	ST(0) = boolSV(RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Gtk2__Window_set_accept_focus); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Window_set_accept_focus)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "window, setting");
    {
	GtkWindow *	window = SvGtkWindow (ST(0))
;
	gboolean	setting = (bool)SvTRUE(ST(1))
;

	gtk_window_set_accept_focus(window, setting);
    }
    XSRETURN_EMPTY;
}

#endif

XS_EUPXS(XS_Gtk2__Window_set_destroy_with_parent); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Window_set_destroy_with_parent)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "window, setting");
    {
	GtkWindow *	window = SvGtkWindow (ST(0))
;
	gboolean	setting = (bool)SvTRUE(ST(1))
;

	gtk_window_set_destroy_with_parent(window, setting);
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_Gtk2__Window_get_destroy_with_parent); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Window_get_destroy_with_parent)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "window");
    {
	GtkWindow *	window = SvGtkWindow (ST(0))
;
	gboolean	RETVAL;

	RETVAL = gtk_window_get_destroy_with_parent(window);
	ST(0) = boolSV(RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Gtk2__Window_set_resizable); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Window_set_resizable)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "window, resizable");
    {
	GtkWindow *	window = SvGtkWindow (ST(0))
;
	gboolean	resizable = (bool)SvTRUE(ST(1))
;

	gtk_window_set_resizable(window, resizable);
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_Gtk2__Window_get_resizable); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Window_get_resizable)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "window");
    {
	GtkWindow *	window = SvGtkWindow (ST(0))
;
	gboolean	RETVAL;

	RETVAL = gtk_window_get_resizable(window);
	ST(0) = boolSV(RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Gtk2__Window_set_gravity); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Window_set_gravity)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "window, gravity");
    {
	GtkWindow *	window = SvGtkWindow (ST(0))
;
	GdkGravity	gravity = SvGdkGravity (ST(1))
;

	gtk_window_set_gravity(window, gravity);
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_Gtk2__Window_get_gravity); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Window_get_gravity)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "window");
    {
	GtkWindow *	window = SvGtkWindow (ST(0))
;
	GdkGravity	RETVAL;

	RETVAL = gtk_window_get_gravity(window);
	ST(0) = newSVGdkGravity (RETVAL);
	sv_2mortal(ST(0));
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Gtk2__Window_set_geometry_hints); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Window_set_geometry_hints)
{
    dVAR; dXSARGS;
    if (items < 3 || items > 4)
       croak_xs_usage(cv,  "window, geometry_widget, geometry_ref, geom_mask_sv=NULL");
    {
	GtkWindow *	window = SvGtkWindow (ST(0))
;
	GtkWidget *	geometry_widget = SvGtkWidget (ST(1))
;
	SV *	geometry_ref = ST(2)
;
	SV *	geom_mask_sv;
#line 257 "xs/GtkWindow.xs"
	GdkGeometry *geometry;
	GdkWindowHints geom_mask;
#line 754 "xs/GtkWindow.c"

	if (items < 4)
	    geom_mask_sv = NULL;
	else {
	    geom_mask_sv = ST(3)
;
	}
#line 260 "xs/GtkWindow.xs"
	if (!gperl_sv_is_defined (geom_mask_sv)) {
		geometry = SvGdkGeometryReal (geometry_ref, &geom_mask);
	} else {
		geometry = SvGdkGeometry (geometry_ref);
		geom_mask = SvGdkWindowHints (geom_mask_sv);
	}

	gtk_window_set_geometry_hints (window, geometry_widget, geometry, geom_mask);
#line 771 "xs/GtkWindow.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_Gtk2__Window_get_has_frame); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Window_get_has_frame)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "window");
    {
	GtkWindow *	window = SvGtkWindow (ST(0))
;
	gboolean	RETVAL;

	RETVAL = gtk_window_get_has_frame(window);
	ST(0) = boolSV(RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Gtk2__Window_set_frame_dimensions); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Window_set_frame_dimensions)
{
    dVAR; dXSARGS;
    if (items != 5)
       croak_xs_usage(cv,  "window, left, top, right, bottom");
    {
	GtkWindow *	window = SvGtkWindow (ST(0))
;
	gint	left = (gint)SvIV(ST(1))
;
	gint	top = (gint)SvIV(ST(2))
;
	gint	right = (gint)SvIV(ST(3))
;
	gint	bottom = (gint)SvIV(ST(4))
;

	gtk_window_set_frame_dimensions(window, left, top, right, bottom);
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_Gtk2__Window_get_frame_dimensions); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Window_get_frame_dimensions)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "window");
    {
	GtkWindow *	window = SvGtkWindow (ST(0))
;
	gint	left;
	gint	top;
	gint	right;
	gint	bottom;

	gtk_window_get_frame_dimensions(window, &left, &top, &right, &bottom);
	XSprePUSH;	EXTEND(SP,4);
	PUSHs(sv_newmortal());
	sv_setiv(ST(0), (IV)left);
	PUSHs(sv_newmortal());
	sv_setiv(ST(1), (IV)top);
	PUSHs(sv_newmortal());
	sv_setiv(ST(2), (IV)right);
	PUSHs(sv_newmortal());
	sv_setiv(ST(3), (IV)bottom);
    }
    XSRETURN(4);
}


XS_EUPXS(XS_Gtk2__Window_set_decorated); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Window_set_decorated)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "window, setting");
    {
	GtkWindow *	window = SvGtkWindow (ST(0))
;
	gboolean	setting = (bool)SvTRUE(ST(1))
;

	gtk_window_set_decorated(window, setting);
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_Gtk2__Window_get_decorated); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Window_get_decorated)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "window");
    {
	GtkWindow *	window = SvGtkWindow (ST(0))
;
	gboolean	RETVAL;

	RETVAL = gtk_window_get_decorated(window);
	ST(0) = boolSV(RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Gtk2__Window_set_icon_list); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Window_set_icon_list)
{
    dVAR; dXSARGS;
    if (items < 1)
       croak_xs_usage(cv,  "window, ...");
    {
	GtkWindow *	window = SvGtkWindow (ST(0))
;
#line 322 "xs/GtkWindow.xs"
	GList * list = NULL;
#line 895 "xs/GtkWindow.c"
#line 324 "xs/GtkWindow.xs"
	for( items--; items > 0; items-- )
		list = g_list_prepend(list, SvGdkPixbuf(ST(items)));
	if( list )
	{
		gtk_window_set_icon_list(window, list);
		g_list_free(list);
	}
#line 904 "xs/GtkWindow.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_Gtk2__Window_get_icon_list); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Window_get_icon_list)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "window");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
	GtkWindow *	window = SvGtkWindow (ST(0))
;
#line 340 "xs/GtkWindow.xs"
	GList * list, * i;
#line 923 "xs/GtkWindow.c"
#line 342 "xs/GtkWindow.xs"
	list = gtk_window_get_icon_list (window);
	if (!list)
		XSRETURN_EMPTY;
	for (i = list ; i != NULL ; i = i->next)
		XPUSHs (sv_2mortal (newSVGdkPixbuf (i->data)));
	g_list_free (list);
#line 931 "xs/GtkWindow.c"
	PUTBACK;
	return;
    }
}


XS_EUPXS(XS_Gtk2__Window_set_icon); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Window_set_icon)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "window, icon");
    {
	GtkWindow *	window = SvGtkWindow (ST(0))
;
	GdkPixbuf_ornull *	icon = SvGdkPixbuf_ornull (ST(1))
;

	gtk_window_set_icon(window, icon);
    }
    XSRETURN_EMPTY;
}

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


XS_EUPXS(XS_Gtk2__Window_set_icon_from_file); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Window_set_icon_from_file)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "window, filename");
    {
	GtkWindow *	window = SvGtkWindow (ST(0))
;
	GPerlFilename	filename = (GPerlFilename) gperl_filename_from_sv (ST(1))
;
#line 365 "xs/GtkWindow.xs"
        GError *error = NULL;
#line 972 "xs/GtkWindow.c"
#line 367 "xs/GtkWindow.xs"
	gtk_window_set_icon_from_file(window, filename, &error);
        if (error)
		gperl_croak_gerror (filename, error);
#line 977 "xs/GtkWindow.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_Gtk2__Window_set_default_icon_from_file); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Window_set_default_icon_from_file)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "class_or_instance, filename");
    {
	GPerlFilename	filename = (GPerlFilename) gperl_filename_from_sv (ST(1))
;
#line 380 "xs/GtkWindow.xs"
        GError *error = NULL;
#line 994 "xs/GtkWindow.c"
#line 382 "xs/GtkWindow.xs"
	gtk_window_set_default_icon_from_file(filename, &error);
        if (error)
		gperl_croak_gerror (filename, error);
#line 999 "xs/GtkWindow.c"
    }
    XSRETURN_EMPTY;
}

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


XS_EUPXS(XS_Gtk2__Window_set_default_icon); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Window_set_default_icon)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "class, icon");
    {
	GdkPixbuf *	icon = SvGdkPixbuf (ST(1))
;

	gtk_window_set_default_icon(icon);
    }
    XSRETURN_EMPTY;
}

#endif

XS_EUPXS(XS_Gtk2__Window_get_icon); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Window_get_icon)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "window");
    {
	GtkWindow *	window = SvGtkWindow (ST(0))
;
	GdkPixbuf_ornull *	RETVAL;

	RETVAL = gtk_window_get_icon(window);
	ST(0) = newSVGdkPixbuf_ornull (RETVAL);
	sv_2mortal(ST(0));
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Gtk2__Window_set_default_icon_list); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Window_set_default_icon_list)
{
    dVAR; dXSARGS;
    if (items < 2)
       croak_xs_usage(cv,  "class, pixbuf, ...");
    {
#line 411 "xs/GtkWindow.xs"
	int i;
	GList * list = NULL;
#line 1055 "xs/GtkWindow.c"
#line 414 "xs/GtkWindow.xs"
	for (i = 1; i < items ; i++)
		list = g_list_append (list, SvGdkPixbuf (ST (i)));
	gtk_window_set_default_icon_list (list);
	g_list_free (list);
#line 1061 "xs/GtkWindow.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_Gtk2__Window_get_default_icon_list); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Window_get_default_icon_list)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "class");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
#line 426 "xs/GtkWindow.xs"
	GList * list, * tmp;
#line 1078 "xs/GtkWindow.c"
#line 428 "xs/GtkWindow.xs"
	list = gtk_window_get_default_icon_list ();
	for (tmp = list ; tmp != NULL ; tmp = tmp->next)
		XPUSHs (sv_2mortal (newSVGdkPixbuf (tmp->data)));
	g_list_free (list);
	PERL_UNUSED_VAR (ax);
#line 1085 "xs/GtkWindow.c"
	PUTBACK;
	return;
    }
}


XS_EUPXS(XS_Gtk2__Window_get_modal); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Window_get_modal)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "window");
    {
	GtkWindow *	window = SvGtkWindow (ST(0))
;
	gboolean	RETVAL;

	RETVAL = gtk_window_get_modal(window);
	ST(0) = boolSV(RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Gtk2__Window_list_toplevels); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Window_list_toplevels)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "class");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
#line 446 "xs/GtkWindow.xs"
	GList * toplvls, * i;
#line 1121 "xs/GtkWindow.c"
#line 448 "xs/GtkWindow.xs"
	toplvls = gtk_window_list_toplevels ();
	for (i = toplvls; i != NULL; i = i->next)
		XPUSHs (sv_2mortal (newSVGtkWindow (i->data)));
	/* documentation doesn't mention it, but according to the source,
	 * it's on us to free this! */
	g_list_free (toplvls);
	PERL_UNUSED_VAR (ax);
#line 1130 "xs/GtkWindow.c"
	PUTBACK;
	return;
    }
}


XS_EUPXS(XS_Gtk2__Window_add_mnemonic); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Window_add_mnemonic)
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "window, keyval, target");
    {
	GtkWindow *	window = SvGtkWindow (ST(0))
;
	guint	keyval = (guint)SvUV(ST(1))
;
	GtkWidget *	target = SvGtkWidget (ST(2))
;

	gtk_window_add_mnemonic(window, keyval, target);
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_Gtk2__Window_remove_mnemonic); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Window_remove_mnemonic)
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "window, keyval, target");
    {
	GtkWindow *	window = SvGtkWindow (ST(0))
;
	guint	keyval = (guint)SvUV(ST(1))
;
	GtkWidget *	target = SvGtkWidget (ST(2))
;

	gtk_window_remove_mnemonic(window, keyval, target);
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_Gtk2__Window_mnemonic_activate); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Window_mnemonic_activate)
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "window, keyval, modifier");
    {
	GtkWindow *	window = SvGtkWindow (ST(0))
;
	guint	keyval = (guint)SvUV(ST(1))
;
	GdkModifierType	modifier = SvGdkModifierType (ST(2))
;
	gboolean	RETVAL;

	RETVAL = gtk_window_mnemonic_activate(window, keyval, modifier);
	ST(0) = boolSV(RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Gtk2__Window_set_has_frame); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Window_set_has_frame)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "window, setting");
    {
	GtkWindow *	window = SvGtkWindow (ST(0))
;
	gboolean	setting = (bool)SvTRUE(ST(1))
;

	gtk_window_set_has_frame(window, setting);
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_Gtk2__Window_set_mnemonic_modifier); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Window_set_mnemonic_modifier)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "window, modifier");
    {
	GtkWindow *	window = SvGtkWindow (ST(0))
;
	GdkModifierType	modifier = SvGdkModifierType (ST(1))
;

	gtk_window_set_mnemonic_modifier(window, modifier);
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_Gtk2__Window_get_mnemonic_modifier); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Window_get_mnemonic_modifier)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "window");
    {
	GtkWindow *	window = SvGtkWindow (ST(0))
;
	GdkModifierType	RETVAL;

	RETVAL = gtk_window_get_mnemonic_modifier(window);
	ST(0) = newSVGdkModifierType (RETVAL);
	sv_2mortal(ST(0));
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Gtk2__Window_present); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Window_present)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "window");
    {
	GtkWindow *	window = SvGtkWindow (ST(0))
;

	gtk_window_present(window);
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_Gtk2__Window_iconify); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Window_iconify)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "window");
    {
	GtkWindow *	window = SvGtkWindow (ST(0))
;

	gtk_window_iconify(window);
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_Gtk2__Window_deiconify); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Window_deiconify)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "window");
    {
	GtkWindow *	window = SvGtkWindow (ST(0))
;

	gtk_window_deiconify(window);
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_Gtk2__Window_stick); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Window_stick)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "window");
    {
	GtkWindow *	window = SvGtkWindow (ST(0))
;

	gtk_window_stick(window);
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_Gtk2__Window_unstick); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Window_unstick)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "window");
    {
	GtkWindow *	window = SvGtkWindow (ST(0))
;

	gtk_window_unstick(window);
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_Gtk2__Window_maximize); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Window_maximize)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "window");
    {
	GtkWindow *	window = SvGtkWindow (ST(0))
;

	gtk_window_maximize(window);
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_Gtk2__Window_unmaximize); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Window_unmaximize)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "window");
    {
	GtkWindow *	window = SvGtkWindow (ST(0))
;

	gtk_window_unmaximize(window);
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_Gtk2__Window_begin_resize_drag); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Window_begin_resize_drag)
{
    dVAR; dXSARGS;
    if (items != 6)
       croak_xs_usage(cv,  "window, edge, button, root_x, root_y, timestamp");
    {
	GtkWindow *	window = SvGtkWindow (ST(0))
;
	GdkWindowEdge	edge = SvGdkWindowEdge (ST(1))
;
	gint	button = (gint)SvIV(ST(2))
;
	gint	root_x = (gint)SvIV(ST(3))
;
	gint	root_y = (gint)SvIV(ST(4))
;
	guint32	timestamp = (guint32)SvUV(ST(5))
;

	gtk_window_begin_resize_drag(window, edge, button, root_x, root_y, timestamp);
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_Gtk2__Window_begin_move_drag); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Window_begin_move_drag)
{
    dVAR; dXSARGS;
    if (items != 5)
       croak_xs_usage(cv,  "window, button, root_x, root_y, timestamp");
    {
	GtkWindow *	window = SvGtkWindow (ST(0))
;
	gint	button = (gint)SvIV(ST(1))
;
	gint	root_x = (gint)SvIV(ST(2))
;
	gint	root_y = (gint)SvIV(ST(3))
;
	guint32	timestamp = (guint32)SvUV(ST(4))
;

	gtk_window_begin_move_drag(window, button, root_x, root_y, timestamp);
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_Gtk2__Window_get_default_size); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Window_get_default_size)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "window");
    {
	GtkWindow *	window = SvGtkWindow (ST(0))
;
	gint	width;
	gint	height;

	gtk_window_get_default_size(window, &width, &height);
	XSprePUSH;	EXTEND(SP,2);
	PUSHs(sv_newmortal());
	sv_setiv(ST(0), (IV)width);
	PUSHs(sv_newmortal());
	sv_setiv(ST(1), (IV)height);
    }
    XSRETURN(2);
}


XS_EUPXS(XS_Gtk2__Window_resize); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Window_resize)
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "window, width, height");
    {
	GtkWindow *	window = SvGtkWindow (ST(0))
;
	gint	width = (gint)SvIV(ST(1))
;
	gint	height = (gint)SvIV(ST(2))
;

	gtk_window_resize(window, width, height);
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_Gtk2__Window_get_size); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Window_get_size)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "window");
    {
	GtkWindow *	window = SvGtkWindow (ST(0))
;
	gint	width;
	gint	height;

	gtk_window_get_size(window, &width, &height);
	XSprePUSH;	EXTEND(SP,2);
	PUSHs(sv_newmortal());
	sv_setiv(ST(0), (IV)width);
	PUSHs(sv_newmortal());
	sv_setiv(ST(1), (IV)height);
    }
    XSRETURN(2);
}


XS_EUPXS(XS_Gtk2__Window_move); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Window_move)
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "window, x, y");
    {
	GtkWindow *	window = SvGtkWindow (ST(0))
;
	gint	x = (gint)SvIV(ST(1))
;
	gint	y = (gint)SvIV(ST(2))
;

	gtk_window_move(window, x, y);
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_Gtk2__Window_get_position); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Window_get_position)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "window");
    {
	GtkWindow *	window = SvGtkWindow (ST(0))
;
	gint	root_x;
	gint	root_y;

	gtk_window_get_position(window, &root_x, &root_y);
	XSprePUSH;	EXTEND(SP,2);
	PUSHs(sv_newmortal());
	sv_setiv(ST(0), (IV)root_x);
	PUSHs(sv_newmortal());
	sv_setiv(ST(1), (IV)root_y);
    }
    XSRETURN(2);
}


XS_EUPXS(XS_Gtk2__Window_parse_geometry); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Window_parse_geometry)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "window, geometry");
    {
	GtkWindow *	window = SvGtkWindow (ST(0))
;
	const gchar *	geometry;
	gboolean	RETVAL;

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

	RETVAL = gtk_window_parse_geometry(window, geometry);
	ST(0) = boolSV(RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Gtk2__Window_remove_embedded_xid); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Window_remove_embedded_xid)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "window, xid");
    {
	GtkWindow *	window = SvGtkWindow (ST(0))
;
	guint	xid = (guint)SvUV(ST(1))
;

	gtk_window_remove_embedded_xid(window, xid);
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_Gtk2__Window_add_embedded_xid); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Window_add_embedded_xid)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "window, xid");
    {
	GtkWindow *	window = SvGtkWindow (ST(0))
;
	guint	xid = (guint)SvUV(ST(1))
;

	gtk_window_add_embedded_xid(window, xid);
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_Gtk2__Window_reshow_with_initial_size); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Window_reshow_with_initial_size)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "window");
    {
	GtkWindow *	window = SvGtkWindow (ST(0))
;

	gtk_window_reshow_with_initial_size(window);
    }
    XSRETURN_EMPTY;
}

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


XS_EUPXS(XS_Gtk2__Window_set_screen); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Window_set_screen)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "window, screen");
    {
	GtkWindow *	window = SvGtkWindow (ST(0))
;
	GdkScreen *	screen = SvGdkScreen (ST(1))
;

	gtk_window_set_screen(window, screen);
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_Gtk2__Window_get_screen); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Window_get_screen)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "window");
    {
	GtkWindow *	window = SvGtkWindow (ST(0))
;
	GdkScreen *	RETVAL;

	RETVAL = gtk_window_get_screen(window);
	ST(0) = newSVGdkScreen (RETVAL);
	sv_2mortal(ST(0));
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Gtk2__Window_fullscreen); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Window_fullscreen)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "window");
    {
	GtkWindow *	window = SvGtkWindow (ST(0))
;

	gtk_window_fullscreen(window);
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_Gtk2__Window_unfullscreen); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Window_unfullscreen)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "window");
    {
	GtkWindow *	window = SvGtkWindow (ST(0))
;

	gtk_window_unfullscreen(window);
    }
    XSRETURN_EMPTY;
}

#if GTK_CHECK_VERSION(2,4,0)
#define XSubPPtmpAAAE 1


XS_EUPXS(XS_Gtk2__Window_set_keep_above); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Window_set_keep_above)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "window, setting");
    {
	GtkWindow *	window = SvGtkWindow (ST(0))
;
	gboolean	setting = (bool)SvTRUE(ST(1))
;

	gtk_window_set_keep_above(window, setting);
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_Gtk2__Window_set_keep_below); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Window_set_keep_below)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "window, setting");
    {
	GtkWindow *	window = SvGtkWindow (ST(0))
;
	gboolean	setting = (bool)SvTRUE(ST(1))
;

	gtk_window_set_keep_below(window, setting);
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_Gtk2__Window_is_active); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Window_is_active)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "window");
    {
	gboolean	RETVAL;
	GtkWindow *	window = SvGtkWindow (ST(0))
;

	RETVAL = gtk_window_is_active(window);
	ST(0) = boolSV(RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Gtk2__Window_has_toplevel_focus); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Window_has_toplevel_focus)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "window");
    {
	gboolean	RETVAL;
	GtkWindow *	window = SvGtkWindow (ST(0))
;

	RETVAL = gtk_window_has_toplevel_focus(window);
	ST(0) = boolSV(RETVAL);
    }
    XSRETURN(1);
}

#endif

XS_EUPXS(XS_Gtk2__Window_set_skip_taskbar_hint); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Window_set_skip_taskbar_hint)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "window, setting");
    {
	GtkWindow *	window = SvGtkWindow (ST(0))
;
	gboolean	setting = (bool)SvTRUE(ST(1))
;

	gtk_window_set_skip_taskbar_hint(window, setting);
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_Gtk2__Window_set_skip_pager_hint); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Window_set_skip_pager_hint)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "window, setting");
    {
	GtkWindow *	window = SvGtkWindow (ST(0))
;
	gboolean	setting = (bool)SvTRUE(ST(1))
;

	gtk_window_set_skip_pager_hint(window, setting);
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_Gtk2__Window_get_skip_taskbar_hint); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Window_get_skip_taskbar_hint)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "window");
    {
	GtkWindow *	window = SvGtkWindow (ST(0))
;
	gboolean	RETVAL;

	RETVAL = gtk_window_get_skip_taskbar_hint(window);
	ST(0) = boolSV(RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Gtk2__Window_get_skip_pager_hint); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Window_get_skip_pager_hint)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "window");
    {
	GtkWindow *	window = SvGtkWindow (ST(0))
;
	gboolean	RETVAL;

	RETVAL = gtk_window_get_skip_pager_hint(window);
	ST(0) = boolSV(RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Gtk2__Window_set_auto_startup_notification); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Window_set_auto_startup_notification)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "class, setting");
    {
	gboolean	setting = (bool)SvTRUE(ST(1))
;

	gtk_window_set_auto_startup_notification(setting);
    }
    XSRETURN_EMPTY;
}

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


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

	RETVAL = gtk_window_activate_key(window, (GdkEventKey *) event);
	ST(0) = boolSV(RETVAL);
    }
    XSRETURN(1);
}


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

	RETVAL = gtk_window_propagate_key_event(window, (GdkEventKey *) event);
	ST(0) = boolSV(RETVAL);
    }
    XSRETURN(1);
}

#endif
#if GTK_CHECK_VERSION (2, 6, 0)
#define XSubPPtmpAAAG 1


XS_EUPXS(XS_Gtk2__Window_set_focus_on_map); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Window_set_focus_on_map)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "window, setting");
    {
	GtkWindow *	window = SvGtkWindow (ST(0))
;
	gboolean	setting = (bool)SvTRUE(ST(1))
;

	gtk_window_set_focus_on_map(window, setting);
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_Gtk2__Window_get_focus_on_map); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Window_get_focus_on_map)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "window");
    {
	gboolean	RETVAL;
	GtkWindow *	window = SvGtkWindow (ST(0))
;

	RETVAL = gtk_window_get_focus_on_map(window);
	ST(0) = boolSV(RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Gtk2__Window_set_icon_name); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Window_set_icon_name)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "window, name");
    {
	GtkWindow *	window = SvGtkWindow (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_window_set_icon_name(window, name);
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_Gtk2__Window_get_icon_name); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Window_get_icon_name)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "window");
    {
	const gchar_ornull *	RETVAL;
	GtkWindow *	window = SvGtkWindow (ST(0))
;

	RETVAL = gtk_window_get_icon_name(window);
	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__Window_set_default_icon_name); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Window_set_default_icon_name)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "class, name");
    {
	const gchar_ornull *	name;

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

	gtk_window_set_default_icon_name(name);
    }
    XSRETURN_EMPTY;
}

#endif
#if GTK_CHECK_VERSION (2, 8, 0)
#define XSubPPtmpAAAH 1


XS_EUPXS(XS_Gtk2__Window_set_urgency_hint); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Window_set_urgency_hint)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "window, setting");
    {
	GtkWindow *	window = SvGtkWindow (ST(0))
;
	gboolean	setting = (bool)SvTRUE(ST(1))
;

	gtk_window_set_urgency_hint(window, setting);
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_Gtk2__Window_get_urgency_hint); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Window_get_urgency_hint)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "window");
    {
	gboolean	RETVAL;
	GtkWindow *	window = SvGtkWindow (ST(0))
;

	RETVAL = gtk_window_get_urgency_hint(window);
	ST(0) = boolSV(RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Gtk2__Window_present_with_time); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Window_present_with_time)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "window, timestamp");
    {
	GtkWindow *	window = SvGtkWindow (ST(0))
;
	guint32	timestamp = (guint32)SvUV(ST(1))
;

	gtk_window_present_with_time(window, timestamp);
    }
    XSRETURN_EMPTY;
}

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


XS_EUPXS(XS_Gtk2__Window_set_deletable); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Window_set_deletable)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "window, setting");
    {
	GtkWindow *	window = SvGtkWindow (ST(0))
;
	gboolean	setting = (bool)SvTRUE(ST(1))
;

	gtk_window_set_deletable(window, setting);
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_Gtk2__Window_get_deletable); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Window_get_deletable)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "window");
    {
	gboolean	RETVAL;
	GtkWindow *	window = SvGtkWindow (ST(0))
;

	RETVAL = gtk_window_get_deletable(window);
	ST(0) = boolSV(RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Gtk2__Window_get_group); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Window_get_group)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "window");
    {
	GtkWindowGroup_ornull *	RETVAL;
	GtkWindow *	window = SvGtkWindow (ST(0))
;

	RETVAL = gtk_window_get_group(window);
	ST(0) = newSVGtkWindowGroup_ornull (RETVAL);
	sv_2mortal(ST(0));
    }
    XSRETURN(1);
}

#endif
#if GTK_CHECK_VERSION (2, 12, 0)
#define XSubPPtmpAAAJ 1


XS_EUPXS(XS_Gtk2__Window_set_startup_id); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Window_set_startup_id)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "window, startup_id");
    {
	GtkWindow *	window = SvGtkWindow (ST(0))
;
	const gchar *	startup_id;

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

	gtk_window_set_startup_id(window, startup_id);
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_Gtk2__Window_set_opacity); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Window_set_opacity)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "window, opacity");
    {
	GtkWindow *	window = SvGtkWindow (ST(0))
;
	gdouble	opacity = (double)SvNV(ST(1))
;

	gtk_window_set_opacity(window, opacity);
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_Gtk2__Window_get_opacity); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Window_get_opacity)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "window");
    {
	gdouble	RETVAL;
	dXSTARG;
	GtkWindow *	window = SvGtkWindow (ST(0))
;

	RETVAL = gtk_window_get_opacity(window);
	XSprePUSH; PUSHn((double)RETVAL);
    }
    XSRETURN(1);
}

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


XS_EUPXS(XS_Gtk2__Window_get_default_widget); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Window_get_default_widget)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "window");
    {
	GtkWidget_ornull *	RETVAL;
	GtkWindow *	window = SvGtkWindow (ST(0))
;

	RETVAL = gtk_window_get_default_widget(window);
	ST(0) = newSVGtkWidget_ornull (RETVAL);
	sv_2mortal(ST(0));
    }
    XSRETURN(1);
}

#endif /* 2.14 */
#if GTK_CHECK_VERSION (2, 16, 0)
#define XSubPPtmpAAAL 1


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

	RETVAL = gtk_window_get_default_icon_name(/* void */);
	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);
}

#endif /* 2.16 */
#if GTK_CHECK_VERSION (2, 20, 0)
#define XSubPPtmpAAAM 1


XS_EUPXS(XS_Gtk2__Window_get_window_type); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Window_get_window_type)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "window");
    {
	GtkWindowType	RETVAL;
	GtkWindow *	window = SvGtkWindow (ST(0))
;

	RETVAL = gtk_window_get_window_type(window);
	ST(0) = newSVGtkWindowType (RETVAL);
	sv_2mortal(ST(0));
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Gtk2__Window_set_mnemonics_visible); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Window_set_mnemonics_visible)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "window, setting");
    {
	GtkWindow *	window = SvGtkWindow (ST(0))
;
	gboolean	setting = (bool)SvTRUE(ST(1))
;

	gtk_window_set_mnemonics_visible(window, setting);
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_Gtk2__Window_get_mnemonics_visible); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Window_get_mnemonics_visible)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "window");
    {
	gboolean	RETVAL;
	GtkWindow *	window = SvGtkWindow (ST(0))
;

	RETVAL = gtk_window_get_mnemonics_visible(window);
	ST(0) = boolSV(RETVAL);
    }
    XSRETURN(1);
}

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


XS_EUPXS(XS_Gtk2__Window_has_group); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__Window_has_group)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "window");
    {
	gboolean	RETVAL;
	GtkWindow *	window = SvGtkWindow (ST(0))
;

	RETVAL = gtk_window_has_group(window);
	ST(0) = boolSV(RETVAL);
    }
    XSRETURN(1);
}

#endif /* 2.22 */

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

	RETVAL = gtk_window_group_new(/*void*/);
	ST(0) = newSVGtkWindowGroup (RETVAL);
	sv_2mortal(ST(0));
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Gtk2__WindowGroup_add_window); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__WindowGroup_add_window)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "window_group, window");
    {
	GtkWindowGroup *	window_group = SvGtkWindowGroup (ST(0))
;
	GtkWindow *	window = SvGtkWindow (ST(1))
;

	gtk_window_group_add_window(window_group, window);
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_Gtk2__WindowGroup_remove_window); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__WindowGroup_remove_window)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "window_group, window");
    {
	GtkWindowGroup *	window_group = SvGtkWindowGroup (ST(0))
;
	GtkWindow *	window = SvGtkWindow (ST(1))
;

	gtk_window_group_remove_window(window_group, window);
    }
    XSRETURN_EMPTY;
}

#if GTK_CHECK_VERSION (2, 14, 0)
#define XSubPPtmpAAAO 1


XS_EUPXS(XS_Gtk2__WindowGroup_list_windows); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Gtk2__WindowGroup_list_windows)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "window_group");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
#line 789 "xs/GtkWindow.xs"
	GList *i, *list;
#line 2371 "xs/GtkWindow.c"
	GtkWindowGroup *	window_group = SvGtkWindowGroup (ST(0))
;
#line 791 "xs/GtkWindow.xs"
	list = gtk_window_group_list_windows (window_group);
	for (i = list; i != NULL; i = i->next) {
		XPUSHs (sv_2mortal (newSVGtkWindow (i->data)));
	}
	g_list_free (list);
#line 2380 "xs/GtkWindow.c"
	PUTBACK;
	return;
    }
}

#endif /* 2.14 */
#if GTK_CHECK_VERSION (2, 22, 0)
#define XSubPPtmpAAAP 1


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

	RETVAL = gtk_window_group_get_current_grab(window_group);
	ST(0) = newSVGtkWidget (RETVAL);
	sv_2mortal(ST(0));
    }
    XSRETURN(1);
}

#endif /* 2.22 */
#ifdef __cplusplus
extern "C"
#endif
XS_EXTERNAL(boot_Gtk2__Window); /* prototype to pass -Wmissing-prototypes */
XS_EXTERNAL(boot_Gtk2__Window)
{
    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;

        newXS("Gtk2::Window::new", XS_Gtk2__Window_new, file);
        newXS("Gtk2::Window::set_title", XS_Gtk2__Window_set_title, file);
        newXS("Gtk2::Window::set_wmclass", XS_Gtk2__Window_set_wmclass, file);
        newXS("Gtk2::Window::set_role", XS_Gtk2__Window_set_role, file);
        newXS("Gtk2::Window::get_role", XS_Gtk2__Window_get_role, file);
        newXS("Gtk2::Window::add_accel_group", XS_Gtk2__Window_add_accel_group, file);
        newXS("Gtk2::Window::remove_accel_group", XS_Gtk2__Window_remove_accel_group, file);
        newXS("Gtk2::Window::set_position", XS_Gtk2__Window_set_position, file);
        newXS("Gtk2::Window::activate_focus", XS_Gtk2__Window_activate_focus, file);
        newXS("Gtk2::Window::get_focus", XS_Gtk2__Window_get_focus, file);
        newXS("Gtk2::Window::set_focus", XS_Gtk2__Window_set_focus, file);
        newXS("Gtk2::Window::set_default", XS_Gtk2__Window_set_default, file);
        newXS("Gtk2::Window::activate_default", XS_Gtk2__Window_activate_default, file);
        newXS("Gtk2::Window::set_default_size", XS_Gtk2__Window_set_default_size, file);
        newXS("Gtk2::Window::set_modal", XS_Gtk2__Window_set_modal, file);
        newXS("Gtk2::Window::set_transient_for", XS_Gtk2__Window_set_transient_for, file);
        newXS("Gtk2::Window::set_type_hint", XS_Gtk2__Window_set_type_hint, file);
        newXS("Gtk2::Window::get_title", XS_Gtk2__Window_get_title, file);
        newXS("Gtk2::Window::get_transient_for", XS_Gtk2__Window_get_transient_for, file);
        newXS("Gtk2::Window::get_type_hint", XS_Gtk2__Window_get_type_hint, file);
#if XSubPPtmpAAAA
        newXS("Gtk2::Window::get_accept_focus", XS_Gtk2__Window_get_accept_focus, file);
        newXS("Gtk2::Window::set_accept_focus", XS_Gtk2__Window_set_accept_focus, file);
#endif
        newXS("Gtk2::Window::set_destroy_with_parent", XS_Gtk2__Window_set_destroy_with_parent, file);
        newXS("Gtk2::Window::get_destroy_with_parent", XS_Gtk2__Window_get_destroy_with_parent, file);
        newXS("Gtk2::Window::set_resizable", XS_Gtk2__Window_set_resizable, file);
        newXS("Gtk2::Window::get_resizable", XS_Gtk2__Window_get_resizable, file);
        newXS("Gtk2::Window::set_gravity", XS_Gtk2__Window_set_gravity, file);
        newXS("Gtk2::Window::get_gravity", XS_Gtk2__Window_get_gravity, file);
        newXS("Gtk2::Window::set_geometry_hints", XS_Gtk2__Window_set_geometry_hints, file);
        newXS("Gtk2::Window::get_has_frame", XS_Gtk2__Window_get_has_frame, file);
        newXS("Gtk2::Window::set_frame_dimensions", XS_Gtk2__Window_set_frame_dimensions, file);
        newXS("Gtk2::Window::get_frame_dimensions", XS_Gtk2__Window_get_frame_dimensions, file);
        newXS("Gtk2::Window::set_decorated", XS_Gtk2__Window_set_decorated, file);
        newXS("Gtk2::Window::get_decorated", XS_Gtk2__Window_get_decorated, file);
        newXS("Gtk2::Window::set_icon_list", XS_Gtk2__Window_set_icon_list, file);
        newXS("Gtk2::Window::get_icon_list", XS_Gtk2__Window_get_icon_list, file);
        newXS("Gtk2::Window::set_icon", XS_Gtk2__Window_set_icon, file);
#if XSubPPtmpAAAB
        newXS("Gtk2::Window::set_icon_from_file", XS_Gtk2__Window_set_icon_from_file, file);
        newXS("Gtk2::Window::set_default_icon_from_file", XS_Gtk2__Window_set_default_icon_from_file, file);
#endif
#if XSubPPtmpAAAC
        newXS("Gtk2::Window::set_default_icon", XS_Gtk2__Window_set_default_icon, file);
#endif
        newXS("Gtk2::Window::get_icon", XS_Gtk2__Window_get_icon, file);
        newXS("Gtk2::Window::set_default_icon_list", XS_Gtk2__Window_set_default_icon_list, file);
        newXS("Gtk2::Window::get_default_icon_list", XS_Gtk2__Window_get_default_icon_list, file);
        newXS("Gtk2::Window::get_modal", XS_Gtk2__Window_get_modal, file);
        newXS("Gtk2::Window::list_toplevels", XS_Gtk2__Window_list_toplevels, file);
        newXS("Gtk2::Window::add_mnemonic", XS_Gtk2__Window_add_mnemonic, file);
        newXS("Gtk2::Window::remove_mnemonic", XS_Gtk2__Window_remove_mnemonic, file);
        newXS("Gtk2::Window::mnemonic_activate", XS_Gtk2__Window_mnemonic_activate, file);
        newXS("Gtk2::Window::set_has_frame", XS_Gtk2__Window_set_has_frame, file);
        newXS("Gtk2::Window::set_mnemonic_modifier", XS_Gtk2__Window_set_mnemonic_modifier, file);
        newXS("Gtk2::Window::get_mnemonic_modifier", XS_Gtk2__Window_get_mnemonic_modifier, file);
        newXS("Gtk2::Window::present", XS_Gtk2__Window_present, file);
        newXS("Gtk2::Window::iconify", XS_Gtk2__Window_iconify, file);
        newXS("Gtk2::Window::deiconify", XS_Gtk2__Window_deiconify, file);
        newXS("Gtk2::Window::stick", XS_Gtk2__Window_stick, file);
        newXS("Gtk2::Window::unstick", XS_Gtk2__Window_unstick, file);
        newXS("Gtk2::Window::maximize", XS_Gtk2__Window_maximize, file);
        newXS("Gtk2::Window::unmaximize", XS_Gtk2__Window_unmaximize, file);
        newXS("Gtk2::Window::begin_resize_drag", XS_Gtk2__Window_begin_resize_drag, file);
        newXS("Gtk2::Window::begin_move_drag", XS_Gtk2__Window_begin_move_drag, file);
        newXS("Gtk2::Window::get_default_size", XS_Gtk2__Window_get_default_size, file);
        newXS("Gtk2::Window::resize", XS_Gtk2__Window_resize, file);
        newXS("Gtk2::Window::get_size", XS_Gtk2__Window_get_size, file);
        newXS("Gtk2::Window::move", XS_Gtk2__Window_move, file);
        newXS("Gtk2::Window::get_position", XS_Gtk2__Window_get_position, file);
        newXS("Gtk2::Window::parse_geometry", XS_Gtk2__Window_parse_geometry, file);
        newXS("Gtk2::Window::remove_embedded_xid", XS_Gtk2__Window_remove_embedded_xid, file);
        newXS("Gtk2::Window::add_embedded_xid", XS_Gtk2__Window_add_embedded_xid, file);
        newXS("Gtk2::Window::reshow_with_initial_size", XS_Gtk2__Window_reshow_with_initial_size, file);
#if XSubPPtmpAAAD
        newXS("Gtk2::Window::set_screen", XS_Gtk2__Window_set_screen, file);
        newXS("Gtk2::Window::get_screen", XS_Gtk2__Window_get_screen, file);
        newXS("Gtk2::Window::fullscreen", XS_Gtk2__Window_fullscreen, file);
        newXS("Gtk2::Window::unfullscreen", XS_Gtk2__Window_unfullscreen, file);
#if XSubPPtmpAAAE
        newXS("Gtk2::Window::set_keep_above", XS_Gtk2__Window_set_keep_above, file);
        newXS("Gtk2::Window::set_keep_below", XS_Gtk2__Window_set_keep_below, file);
        newXS("Gtk2::Window::is_active", XS_Gtk2__Window_is_active, file);
        newXS("Gtk2::Window::has_toplevel_focus", XS_Gtk2__Window_has_toplevel_focus, file);
#endif
        newXS("Gtk2::Window::set_skip_taskbar_hint", XS_Gtk2__Window_set_skip_taskbar_hint, file);
        newXS("Gtk2::Window::set_skip_pager_hint", XS_Gtk2__Window_set_skip_pager_hint, file);
        newXS("Gtk2::Window::get_skip_taskbar_hint", XS_Gtk2__Window_get_skip_taskbar_hint, file);
        newXS("Gtk2::Window::get_skip_pager_hint", XS_Gtk2__Window_get_skip_pager_hint, file);
        newXS("Gtk2::Window::set_auto_startup_notification", XS_Gtk2__Window_set_auto_startup_notification, file);
#endif
#if XSubPPtmpAAAF
        newXS("Gtk2::Window::activate_key", XS_Gtk2__Window_activate_key, file);
        newXS("Gtk2::Window::propagate_key_event", XS_Gtk2__Window_propagate_key_event, file);
#endif
#if XSubPPtmpAAAG
        newXS("Gtk2::Window::set_focus_on_map", XS_Gtk2__Window_set_focus_on_map, file);
        newXS("Gtk2::Window::get_focus_on_map", XS_Gtk2__Window_get_focus_on_map, file);
        newXS("Gtk2::Window::set_icon_name", XS_Gtk2__Window_set_icon_name, file);
        newXS("Gtk2::Window::get_icon_name", XS_Gtk2__Window_get_icon_name, file);
        newXS("Gtk2::Window::set_default_icon_name", XS_Gtk2__Window_set_default_icon_name, file);
#endif
#if XSubPPtmpAAAH
        newXS("Gtk2::Window::set_urgency_hint", XS_Gtk2__Window_set_urgency_hint, file);
        newXS("Gtk2::Window::get_urgency_hint", XS_Gtk2__Window_get_urgency_hint, file);
        newXS("Gtk2::Window::present_with_time", XS_Gtk2__Window_present_with_time, file);
#endif
#if XSubPPtmpAAAI
        newXS("Gtk2::Window::set_deletable", XS_Gtk2__Window_set_deletable, file);
        newXS("Gtk2::Window::get_deletable", XS_Gtk2__Window_get_deletable, file);
        newXS("Gtk2::Window::get_group", XS_Gtk2__Window_get_group, file);
#endif
#if XSubPPtmpAAAJ
        newXS("Gtk2::Window::set_startup_id", XS_Gtk2__Window_set_startup_id, file);
        newXS("Gtk2::Window::set_opacity", XS_Gtk2__Window_set_opacity, file);
        newXS("Gtk2::Window::get_opacity", XS_Gtk2__Window_get_opacity, file);
#endif
#if XSubPPtmpAAAK
        newXS("Gtk2::Window::get_default_widget", XS_Gtk2__Window_get_default_widget, file);
#endif
#if XSubPPtmpAAAL
        newXS("Gtk2::Window::get_default_icon_name", XS_Gtk2__Window_get_default_icon_name, file);
#endif
#if XSubPPtmpAAAM
        newXS("Gtk2::Window::get_window_type", XS_Gtk2__Window_get_window_type, file);
        newXS("Gtk2::Window::set_mnemonics_visible", XS_Gtk2__Window_set_mnemonics_visible, file);
        newXS("Gtk2::Window::get_mnemonics_visible", XS_Gtk2__Window_get_mnemonics_visible, file);
#endif
#if XSubPPtmpAAAN
        newXS("Gtk2::Window::has_group", XS_Gtk2__Window_has_group, file);
#endif
        newXS("Gtk2::WindowGroup::new", XS_Gtk2__WindowGroup_new, file);
        newXS("Gtk2::WindowGroup::add_window", XS_Gtk2__WindowGroup_add_window, file);
        newXS("Gtk2::WindowGroup::remove_window", XS_Gtk2__WindowGroup_remove_window, file);
#if XSubPPtmpAAAO
        newXS("Gtk2::WindowGroup::list_windows", XS_Gtk2__WindowGroup_list_windows, file);
#endif
#if XSubPPtmpAAAP
        newXS("Gtk2::WindowGroup::get_current_grab", XS_Gtk2__WindowGroup_get_current_grab, file);
#endif

    /* Initialisation Section */

#if XSubPPtmpAAAA
#endif
#if XSubPPtmpAAAB
#endif
#if XSubPPtmpAAAC
#endif
#if XSubPPtmpAAAD
#if XSubPPtmpAAAE
#endif
#endif
#if XSubPPtmpAAAF
#endif
#if XSubPPtmpAAAG
#endif
#if XSubPPtmpAAAH
#endif
#if XSubPPtmpAAAI
#endif
#if XSubPPtmpAAAJ
#endif
#if XSubPPtmpAAAK
#endif
#if XSubPPtmpAAAL
#endif
#if XSubPPtmpAAAM
#endif
#if XSubPPtmpAAAN
#endif
#if XSubPPtmpAAAO
#endif
#if XSubPPtmpAAAP
#endif
#line 2606 "xs/GtkWindow.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;
}

