/* WindowManager.c generated by valac 0.56.18-dirty, the Vala compiler
 * generated from WindowManager.vala, do not modify */

/*
 * Copyright 2012-2014 Tom Beckmann, Rico Tzschichholz
 * Copyright 2018-2025 elementary, Inc. (https://elementary.io)
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program 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 General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

#include <meta/meta-plugin.h>
#include <glib-object.h>
#include <clutter/clutter.h>
#include <meta/meta-background-group.h>
#include <gio/gio.h>
#include <glib.h>
#include <meta/window.h>
#include <meta/compositor.h>
#include <mtk/mtk.h>
#include <meta/meta-window-actor.h>
#include <meta/common.h>
#include <meta/display.h>
#include <meta/meta-background-actor.h>
#include <float.h>
#include <math.h>
#include <meta/compositor-mutter.h>
#include <meta/meta-monitor-manager.h>
#include <meta/meta-context.h>
#include <meta/meta-backend.h>
#include <meta/keybindings.h>
#include <stdlib.h>
#include <string.h>
#include <meta/util.h>
#include <meta/meta-wayland-client.h>
#include <signal.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <glib/gi18n-lib.h>

#define CONSTANTS_VERSION "8.1.1"
#if !defined(VALA_STRICT_C)
#if !defined(__clang__) && defined(__GNUC__) && (__GNUC__ >= 14)
#pragma GCC diagnostic warning "-Wincompatible-pointer-types"
#elif defined(__clang__) && (__clang_major__ >= 16)
#pragma clang diagnostic ignored "-Wincompatible-function-pointer-types"
#pragma clang diagnostic ignored "-Wincompatible-pointer-types"
#endif
#endif
#if !defined(VALA_EXTERN)
#if defined(_MSC_VER)
#define VALA_EXTERN __declspec(dllexport) extern
#elif __GNUC__ >= 4
#define VALA_EXTERN __attribute__((visibility("default"))) extern
#else
#define VALA_EXTERN extern
#endif
#endif

#define GREETER_COMPOSITOR_TYPE_WINDOW_MANAGER (greeter_compositor_window_manager_get_type ())
#define GREETER_COMPOSITOR_WINDOW_MANAGER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GREETER_COMPOSITOR_TYPE_WINDOW_MANAGER, GreeterCompositorWindowManager))
#define GREETER_COMPOSITOR_WINDOW_MANAGER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GREETER_COMPOSITOR_TYPE_WINDOW_MANAGER, GreeterCompositorWindowManagerClass))
#define GREETER_COMPOSITOR_IS_WINDOW_MANAGER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GREETER_COMPOSITOR_TYPE_WINDOW_MANAGER))
#define GREETER_COMPOSITOR_IS_WINDOW_MANAGER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GREETER_COMPOSITOR_TYPE_WINDOW_MANAGER))
#define GREETER_COMPOSITOR_WINDOW_MANAGER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GREETER_COMPOSITOR_TYPE_WINDOW_MANAGER, GreeterCompositorWindowManagerClass))

typedef struct _GreeterCompositorWindowManager GreeterCompositorWindowManager;
typedef struct _GreeterCompositorWindowManagerClass GreeterCompositorWindowManagerClass;
typedef struct _GreeterCompositorWindowManagerPrivate GreeterCompositorWindowManagerPrivate;

#define GREETER_COMPOSITOR_TYPE_POINTER_LOCATOR (greeter_compositor_pointer_locator_get_type ())
#define GREETER_COMPOSITOR_POINTER_LOCATOR(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GREETER_COMPOSITOR_TYPE_POINTER_LOCATOR, GreeterCompositorPointerLocator))
#define GREETER_COMPOSITOR_POINTER_LOCATOR_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GREETER_COMPOSITOR_TYPE_POINTER_LOCATOR, GreeterCompositorPointerLocatorClass))
#define GREETER_COMPOSITOR_IS_POINTER_LOCATOR(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GREETER_COMPOSITOR_TYPE_POINTER_LOCATOR))
#define GREETER_COMPOSITOR_IS_POINTER_LOCATOR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GREETER_COMPOSITOR_TYPE_POINTER_LOCATOR))
#define GREETER_COMPOSITOR_POINTER_LOCATOR_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GREETER_COMPOSITOR_TYPE_POINTER_LOCATOR, GreeterCompositorPointerLocatorClass))

typedef struct _GreeterCompositorPointerLocator GreeterCompositorPointerLocator;
typedef struct _GreeterCompositorPointerLocatorClass GreeterCompositorPointerLocatorClass;

#define GREETER_COMPOSITOR_TYPE_SYSTEM_BACKGROUND (greeter_compositor_system_background_get_type ())
#define GREETER_COMPOSITOR_SYSTEM_BACKGROUND(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GREETER_COMPOSITOR_TYPE_SYSTEM_BACKGROUND, GreeterCompositorSystemBackground))
#define GREETER_COMPOSITOR_SYSTEM_BACKGROUND_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GREETER_COMPOSITOR_TYPE_SYSTEM_BACKGROUND, GreeterCompositorSystemBackgroundClass))
#define GREETER_COMPOSITOR_IS_SYSTEM_BACKGROUND(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GREETER_COMPOSITOR_TYPE_SYSTEM_BACKGROUND))
#define GREETER_COMPOSITOR_IS_SYSTEM_BACKGROUND_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GREETER_COMPOSITOR_TYPE_SYSTEM_BACKGROUND))
#define GREETER_COMPOSITOR_SYSTEM_BACKGROUND_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GREETER_COMPOSITOR_TYPE_SYSTEM_BACKGROUND, GreeterCompositorSystemBackgroundClass))

typedef struct _GreeterCompositorSystemBackground GreeterCompositorSystemBackground;
typedef struct _GreeterCompositorSystemBackgroundClass GreeterCompositorSystemBackgroundClass;

#define GREETER_COMPOSITOR_TYPE_NOTIFICATION_STACK (greeter_compositor_notification_stack_get_type ())
#define GREETER_COMPOSITOR_NOTIFICATION_STACK(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GREETER_COMPOSITOR_TYPE_NOTIFICATION_STACK, GreeterCompositorNotificationStack))
#define GREETER_COMPOSITOR_NOTIFICATION_STACK_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GREETER_COMPOSITOR_TYPE_NOTIFICATION_STACK, GreeterCompositorNotificationStackClass))
#define GREETER_COMPOSITOR_IS_NOTIFICATION_STACK(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GREETER_COMPOSITOR_TYPE_NOTIFICATION_STACK))
#define GREETER_COMPOSITOR_IS_NOTIFICATION_STACK_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GREETER_COMPOSITOR_TYPE_NOTIFICATION_STACK))
#define GREETER_COMPOSITOR_NOTIFICATION_STACK_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GREETER_COMPOSITOR_TYPE_NOTIFICATION_STACK, GreeterCompositorNotificationStackClass))

typedef struct _GreeterCompositorNotificationStack GreeterCompositorNotificationStack;
typedef struct _GreeterCompositorNotificationStackClass GreeterCompositorNotificationStackClass;

#define GREETER_COMPOSITOR_TYPE_ZOOM (greeter_compositor_zoom_get_type ())
#define GREETER_COMPOSITOR_ZOOM(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GREETER_COMPOSITOR_TYPE_ZOOM, GreeterCompositorZoom))
#define GREETER_COMPOSITOR_ZOOM_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GREETER_COMPOSITOR_TYPE_ZOOM, GreeterCompositorZoomClass))
#define GREETER_COMPOSITOR_IS_ZOOM(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GREETER_COMPOSITOR_TYPE_ZOOM))
#define GREETER_COMPOSITOR_IS_ZOOM_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GREETER_COMPOSITOR_TYPE_ZOOM))
#define GREETER_COMPOSITOR_ZOOM_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GREETER_COMPOSITOR_TYPE_ZOOM, GreeterCompositorZoomClass))

typedef struct _GreeterCompositorZoom GreeterCompositorZoom;
typedef struct _GreeterCompositorZoomClass GreeterCompositorZoomClass;
enum  {
	GREETER_COMPOSITOR_WINDOW_MANAGER_0_PROPERTY,
	GREETER_COMPOSITOR_WINDOW_MANAGER_UI_GROUP_PROPERTY,
	GREETER_COMPOSITOR_WINDOW_MANAGER_STAGE_PROPERTY,
	GREETER_COMPOSITOR_WINDOW_MANAGER_WINDOW_GROUP_PROPERTY,
	GREETER_COMPOSITOR_WINDOW_MANAGER_TOP_WINDOW_GROUP_PROPERTY,
	GREETER_COMPOSITOR_WINDOW_MANAGER_BACKGROUND_GROUP_PROPERTY,
	GREETER_COMPOSITOR_WINDOW_MANAGER_POINTER_LOCATOR_PROPERTY,
	GREETER_COMPOSITOR_WINDOW_MANAGER_SYSTEM_BACKGROUND_PROPERTY,
	GREETER_COMPOSITOR_WINDOW_MANAGER_NUM_PROPERTIES
};
static GParamSpec* greeter_compositor_window_manager_properties[GREETER_COMPOSITOR_WINDOW_MANAGER_NUM_PROPERTIES];
#define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL)))
typedef struct _Block26Data Block26Data;

#define GREETER_COMPOSITOR_TYPE_DBUS_ACCELERATOR (greeter_compositor_dbus_accelerator_get_type ())
#define GREETER_COMPOSITOR_DBUS_ACCELERATOR(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GREETER_COMPOSITOR_TYPE_DBUS_ACCELERATOR, GreeterCompositorDBusAccelerator))
#define GREETER_COMPOSITOR_DBUS_ACCELERATOR_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GREETER_COMPOSITOR_TYPE_DBUS_ACCELERATOR, GreeterCompositorDBusAcceleratorClass))
#define GREETER_COMPOSITOR_IS_DBUS_ACCELERATOR(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GREETER_COMPOSITOR_TYPE_DBUS_ACCELERATOR))
#define GREETER_COMPOSITOR_IS_DBUS_ACCELERATOR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GREETER_COMPOSITOR_TYPE_DBUS_ACCELERATOR))
#define GREETER_COMPOSITOR_DBUS_ACCELERATOR_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GREETER_COMPOSITOR_TYPE_DBUS_ACCELERATOR, GreeterCompositorDBusAcceleratorClass))

typedef struct _GreeterCompositorDBusAccelerator GreeterCompositorDBusAccelerator;
typedef struct _GreeterCompositorDBusAcceleratorClass GreeterCompositorDBusAcceleratorClass;
#define __vala_ClutterColor_free0(var) ((var == NULL) ? NULL : (var = (_vala_ClutterColor_free (var), NULL)))

#define GREETER_COMPOSITOR_TYPE_BACKGROUND_CONTAINER (greeter_compositor_background_container_get_type ())
#define GREETER_COMPOSITOR_BACKGROUND_CONTAINER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GREETER_COMPOSITOR_TYPE_BACKGROUND_CONTAINER, GreeterCompositorBackgroundContainer))
#define GREETER_COMPOSITOR_BACKGROUND_CONTAINER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GREETER_COMPOSITOR_TYPE_BACKGROUND_CONTAINER, GreeterCompositorBackgroundContainerClass))
#define GREETER_COMPOSITOR_IS_BACKGROUND_CONTAINER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GREETER_COMPOSITOR_TYPE_BACKGROUND_CONTAINER))
#define GREETER_COMPOSITOR_IS_BACKGROUND_CONTAINER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GREETER_COMPOSITOR_TYPE_BACKGROUND_CONTAINER))
#define GREETER_COMPOSITOR_BACKGROUND_CONTAINER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GREETER_COMPOSITOR_TYPE_BACKGROUND_CONTAINER, GreeterCompositorBackgroundContainerClass))

typedef struct _GreeterCompositorBackgroundContainer GreeterCompositorBackgroundContainer;
typedef struct _GreeterCompositorBackgroundContainerClass GreeterCompositorBackgroundContainerClass;
typedef void (*GreeterCompositorUtilsWindowActorReadyCallback) (MetaWindowActor* window_actor, gpointer user_data);
typedef struct _GreeterCompositorWindowManagerStartCommandData GreeterCompositorWindowManagerStartCommandData;
typedef struct _Block27Data Block27Data;
#define _g_error_free0(var) ((var == NULL) ? NULL : (var = (g_error_free (var), NULL)))
typedef struct _GreeterCompositorWindowManagerStartWaylandData GreeterCompositorWindowManagerStartWaylandData;
typedef struct _Block28Data Block28Data;
typedef struct _GreeterCompositorWindowManagerStartXData GreeterCompositorWindowManagerStartXData;

#define GREETER_COMPOSITOR_TYPE_SHELL_CLIENTS_MANAGER (greeter_compositor_shell_clients_manager_get_type ())
#define GREETER_COMPOSITOR_SHELL_CLIENTS_MANAGER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GREETER_COMPOSITOR_TYPE_SHELL_CLIENTS_MANAGER, GreeterCompositorShellClientsManager))
#define GREETER_COMPOSITOR_SHELL_CLIENTS_MANAGER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GREETER_COMPOSITOR_TYPE_SHELL_CLIENTS_MANAGER, GreeterCompositorShellClientsManagerClass))
#define GREETER_COMPOSITOR_IS_SHELL_CLIENTS_MANAGER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GREETER_COMPOSITOR_TYPE_SHELL_CLIENTS_MANAGER))
#define GREETER_COMPOSITOR_IS_SHELL_CLIENTS_MANAGER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GREETER_COMPOSITOR_TYPE_SHELL_CLIENTS_MANAGER))
#define GREETER_COMPOSITOR_SHELL_CLIENTS_MANAGER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GREETER_COMPOSITOR_TYPE_SHELL_CLIENTS_MANAGER, GreeterCompositorShellClientsManagerClass))

typedef struct _GreeterCompositorShellClientsManager GreeterCompositorShellClientsManager;
typedef struct _GreeterCompositorShellClientsManagerClass GreeterCompositorShellClientsManagerClass;
typedef struct _Block29Data Block29Data;

#define GREETER_COMPOSITOR_TYPE_ACCESS_DIALOG (greeter_compositor_access_dialog_get_type ())
#define GREETER_COMPOSITOR_ACCESS_DIALOG(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GREETER_COMPOSITOR_TYPE_ACCESS_DIALOG, GreeterCompositorAccessDialog))
#define GREETER_COMPOSITOR_ACCESS_DIALOG_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GREETER_COMPOSITOR_TYPE_ACCESS_DIALOG, GreeterCompositorAccessDialogClass))
#define GREETER_COMPOSITOR_IS_ACCESS_DIALOG(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GREETER_COMPOSITOR_TYPE_ACCESS_DIALOG))
#define GREETER_COMPOSITOR_IS_ACCESS_DIALOG_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GREETER_COMPOSITOR_TYPE_ACCESS_DIALOG))
#define GREETER_COMPOSITOR_ACCESS_DIALOG_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GREETER_COMPOSITOR_TYPE_ACCESS_DIALOG, GreeterCompositorAccessDialogClass))

typedef struct _GreeterCompositorAccessDialog GreeterCompositorAccessDialog;
typedef struct _GreeterCompositorAccessDialogClass GreeterCompositorAccessDialogClass;
#define _g_free0(var) (var = (g_free (var), NULL))

struct _GreeterCompositorWindowManager {
	MetaPlugin parent_instance;
	GreeterCompositorWindowManagerPrivate * priv;
};

struct _GreeterCompositorWindowManagerClass {
	MetaPluginClass parent_class;
};

struct _GreeterCompositorWindowManagerPrivate {
	ClutterActor* _ui_group;
	ClutterStage* _stage;
	ClutterActor* _window_group;
	ClutterActor* _top_window_group;
	MetaBackgroundGroup* _background_group;
	GreeterCompositorPointerLocator* _pointer_locator;
	GreeterCompositorSystemBackground* _system_background;
	ClutterActor* shell_group;
	GreeterCompositorNotificationStack* notification_stack;
	ClutterActor* fade_in_screen;
	MetaPluginInfo info;
	GSettings* application_settings;
	gint reader_pid;
	GreeterCompositorZoom* zoom;
};

struct _Block26Data {
	int _ref_count_;
	GreeterCompositorWindowManager* self;
	MetaDisplay* display;
};

struct _GreeterCompositorWindowManagerStartCommandData {
	int _state_;
	GObject* _source_object_;
	GAsyncResult* _res_;
	GTask* _async_result;
	GreeterCompositorWindowManager* self;
	gchar** command;
	gint command_length1;
};

struct _Block27Data {
	int _ref_count_;
	GreeterCompositorWindowManager* self;
	gchar** command;
	gint command_length1;
	gpointer _async_data_;
};

struct _GreeterCompositorWindowManagerStartWaylandData {
	int _state_;
	GObject* _source_object_;
	GAsyncResult* _res_;
	GTask* _async_result;
	GreeterCompositorWindowManager* self;
	gchar** command;
	gint command_length1;
	Block27Data* _data27_;
	MetaDisplay* display;
	MetaDisplay* _tmp0_;
	GSubprocessLauncher* subprocess_launcher;
	GSubprocessLauncher* _tmp1_;
	MetaWaylandClient* daemon_client;
	MetaWaylandClient* _tmp2_;
	MetaDisplay* _tmp3_;
	MetaContext* _tmp4_;
	GSubprocessLauncher* _tmp5_;
	MetaWaylandClient* _tmp6_;
	MetaWaylandClient* _tmp7_;
	GSubprocess* subprocess;
	MetaWaylandClient* _tmp8_;
	MetaDisplay* _tmp9_;
	GSubprocess* _tmp10_;
	GSubprocess* _tmp11_;
	GError* e;
	GError* _tmp12_;
	const gchar* _tmp13_;
	GError* _inner_error0_;
};

struct _Block28Data {
	int _ref_count_;
	GreeterCompositorWindowManager* self;
	gchar** command;
	gint command_length1;
	gpointer _async_data_;
};

struct _GreeterCompositorWindowManagerStartXData {
	int _state_;
	GObject* _source_object_;
	GAsyncResult* _res_;
	GTask* _async_result;
	GreeterCompositorWindowManager* self;
	gchar** command;
	gint command_length1;
	Block28Data* _data28_;
	GSubprocess* subprocess;
	GSubprocess* _tmp0_;
	GSubprocess* _tmp1_;
	GError* e;
	GError* _tmp2_;
	const gchar* _tmp3_;
	GError* _inner_error0_;
};

struct _Block29Data {
	int _ref_count_;
	GreeterCompositorWindowManager* self;
	gint timeout;
	guint dialog_timeout_id;
};

static gint GreeterCompositorWindowManager_private_offset;
static gpointer greeter_compositor_window_manager_parent_class = NULL;

VALA_EXTERN GType greeter_compositor_window_manager_get_type (void) G_GNUC_CONST ;
G_DEFINE_AUTOPTR_CLEANUP_FUNC (GreeterCompositorWindowManager, g_object_unref)
VALA_EXTERN GType greeter_compositor_pointer_locator_get_type (void) G_GNUC_CONST ;
G_DEFINE_AUTOPTR_CLEANUP_FUNC (GreeterCompositorPointerLocator, g_object_unref)
VALA_EXTERN GType greeter_compositor_system_background_get_type (void) G_GNUC_CONST ;
G_DEFINE_AUTOPTR_CLEANUP_FUNC (GreeterCompositorSystemBackground, g_object_unref)
VALA_EXTERN GType greeter_compositor_notification_stack_get_type (void) G_GNUC_CONST ;
G_DEFINE_AUTOPTR_CLEANUP_FUNC (GreeterCompositorNotificationStack, g_object_unref)
VALA_EXTERN GType greeter_compositor_zoom_get_type (void) G_GNUC_CONST ;
G_DEFINE_AUTOPTR_CLEANUP_FUNC (GreeterCompositorZoom, g_object_unref)
static void greeter_compositor_window_manager_real_start (MetaPlugin* base);
VALA_EXTERN void greeter_compositor_blur_manager_init (GreeterCompositorWindowManager* wm);
static void greeter_compositor_window_manager_show_stage (GreeterCompositorWindowManager* self);
static void __lambda97_ (GreeterCompositorWindowManager* self);
static void greeter_compositor_window_manager_refresh_background (GreeterCompositorWindowManager* self);
static void ___lambda97__meta_display_gl_video_memory_purged (MetaDisplay* _sender,
                                                       gpointer self);
VALA_EXTERN ClutterStage* greeter_compositor_window_manager_get_stage (GreeterCompositorWindowManager* self);
VALA_EXTERN GreeterCompositorSystemBackground* greeter_compositor_window_manager_get_system_background (GreeterCompositorWindowManager* self);
VALA_EXTERN MetaBackgroundActor* greeter_compositor_system_background_get_background_actor (GreeterCompositorSystemBackground* self);
VALA_EXTERN GreeterCompositorSystemBackground* greeter_compositor_system_background_new (MetaDisplay* display);
VALA_EXTERN GreeterCompositorSystemBackground* greeter_compositor_system_background_construct (GType object_type,
                                                                                   MetaDisplay* display);
static void greeter_compositor_window_manager_set_system_background (GreeterCompositorWindowManager* self,
                                                              GreeterCompositorSystemBackground* value);
static Block26Data* block26_data_ref (Block26Data* _data26_);
static void block26_data_unref (void * _userdata_);
VALA_EXTERN void greeter_compositor_media_feedback_init (void);
VALA_EXTERN void greeter_compositor_dbus_init (GreeterCompositorWindowManager* _wm);
VALA_EXTERN gpointer greeter_compositor_dbus_accelerator_ref (gpointer instance);
VALA_EXTERN void greeter_compositor_dbus_accelerator_unref (gpointer instance);
VALA_EXTERN GParamSpec* greeter_compositor_param_spec_dbus_accelerator (const gchar* name,
                                                            const gchar* nick,
                                                            const gchar* blurb,
                                                            GType object_type,
                                                            GParamFlags flags);
VALA_EXTERN void greeter_compositor_value_set_dbus_accelerator (GValue* value,
                                                    gpointer v_object);
VALA_EXTERN void greeter_compositor_value_take_dbus_accelerator (GValue* value,
                                                     gpointer v_object);
VALA_EXTERN gpointer greeter_compositor_value_get_dbus_accelerator (const GValue* value);
VALA_EXTERN GType greeter_compositor_dbus_accelerator_get_type (void) G_GNUC_CONST ;
G_DEFINE_AUTOPTR_CLEANUP_FUNC (GreeterCompositorDBusAccelerator, greeter_compositor_dbus_accelerator_unref)
VALA_EXTERN guint greeter_compositor_dbus_accelerator_register_object (void* object,
                                                           GDBusConnection* connection,
                                                           const gchar* path,
                                                           GError** error);
VALA_EXTERN GreeterCompositorDBusAccelerator* greeter_compositor_dbus_accelerator_init (GreeterCompositorWindowManager* wm);
VALA_EXTERN void greeter_compositor_dbus_wingpanel_manager_init (GreeterCompositorWindowManager* _wm);
VALA_EXTERN void greeter_compositor_keyboard_manager_init (MetaDisplay* display);
VALA_EXTERN GreeterCompositorNotificationStack* greeter_compositor_notification_stack_new (MetaDisplay* display);
VALA_EXTERN GreeterCompositorNotificationStack* greeter_compositor_notification_stack_construct (GType object_type,
                                                                                     MetaDisplay* display);
VALA_EXTERN void greeter_compositor_window_manager_set_stage (GreeterCompositorWindowManager* self,
                                                  ClutterStage* value);
static void _vala_ClutterColor_free (ClutterColor* self);
VALA_EXTERN void greeter_compositor_window_manager_set_ui_group (GreeterCompositorWindowManager* self,
                                                     ClutterActor* value);
VALA_EXTERN ClutterActor* greeter_compositor_window_manager_get_ui_group (GreeterCompositorWindowManager* self);
static void greeter_compositor_window_manager_update_ui_group_size (GreeterCompositorWindowManager* self);
VALA_EXTERN void greeter_compositor_window_manager_set_window_group (GreeterCompositorWindowManager* self,
                                                         ClutterActor* value);
VALA_EXTERN ClutterActor* greeter_compositor_window_manager_get_window_group (GreeterCompositorWindowManager* self);
VALA_EXTERN void greeter_compositor_window_manager_set_top_window_group (GreeterCompositorWindowManager* self,
                                                             ClutterActor* value);
VALA_EXTERN ClutterActor* greeter_compositor_window_manager_get_top_window_group (GreeterCompositorWindowManager* self);
VALA_EXTERN GreeterCompositorBackgroundContainer* greeter_compositor_background_container_new (GreeterCompositorWindowManager* wm);
VALA_EXTERN GreeterCompositorBackgroundContainer* greeter_compositor_background_container_construct (GType object_type,
                                                                                         GreeterCompositorWindowManager* wm);
VALA_EXTERN GType greeter_compositor_background_container_get_type (void) G_GNUC_CONST ;
G_DEFINE_AUTOPTR_CLEANUP_FUNC (GreeterCompositorBackgroundContainer, g_object_unref)
VALA_EXTERN void greeter_compositor_window_manager_set_background_group (GreeterCompositorWindowManager* self,
                                                             MetaBackgroundGroup* value);
VALA_EXTERN MetaBackgroundGroup* greeter_compositor_window_manager_get_background_group (GreeterCompositorWindowManager* self);
VALA_EXTERN GreeterCompositorPointerLocator* greeter_compositor_pointer_locator_new (GreeterCompositorWindowManager* wm);
VALA_EXTERN GreeterCompositorPointerLocator* greeter_compositor_pointer_locator_construct (GType object_type,
                                                                               GreeterCompositorWindowManager* wm);
static void greeter_compositor_window_manager_set_pointer_locator (GreeterCompositorWindowManager* self,
                                                            GreeterCompositorPointerLocator* value);
VALA_EXTERN GreeterCompositorPointerLocator* greeter_compositor_window_manager_get_pointer_locator (GreeterCompositorWindowManager* self);
static void _greeter_compositor_window_manager_update_ui_group_size_meta_monitor_manager_monitors_changed (MetaMonitorManager* _sender,
                                                                                                    gpointer self);
static void __lambda57_ (GreeterCompositorWindowManager* self);
static void ___lambda57__meta_key_handler_func (MetaDisplay* display,
                                         MetaWindow* window,
                                         const ClutterKeyEvent* event,
                                         MetaKeyBinding* binding,
                                         gpointer self);
static void __lambda58_ (GreeterCompositorWindowManager* self);
static void ___lambda58__meta_key_handler_func (MetaDisplay* display,
                                         MetaWindow* window,
                                         const ClutterKeyEvent* event,
                                         MetaKeyBinding* binding,
                                         gpointer self);
static void __lambda59_ (GreeterCompositorWindowManager* self);
static void ___lambda59__meta_key_handler_func (MetaDisplay* display,
                                         MetaWindow* window,
                                         const ClutterKeyEvent* event,
                                         MetaKeyBinding* binding,
                                         gpointer self);
static void __lambda60_ (GreeterCompositorWindowManager* self);
static void ___lambda60__meta_key_handler_func (MetaDisplay* display,
                                         MetaWindow* window,
                                         const ClutterKeyEvent* event,
                                         MetaKeyBinding* binding,
                                         gpointer self);
static void __lambda61_ (GreeterCompositorWindowManager* self);
static void ___lambda61__meta_key_handler_func (MetaDisplay* display,
                                         MetaWindow* window,
                                         const ClutterKeyEvent* event,
                                         MetaKeyBinding* binding,
                                         gpointer self);
static void __lambda62_ (GreeterCompositorWindowManager* self);
static void ___lambda62__meta_key_handler_func (MetaDisplay* display,
                                         MetaWindow* window,
                                         const ClutterKeyEvent* event,
                                         MetaKeyBinding* binding,
                                         gpointer self);
static void __lambda63_ (GreeterCompositorWindowManager* self);
static void ___lambda63__meta_key_handler_func (MetaDisplay* display,
                                         MetaWindow* window,
                                         const ClutterKeyEvent* event,
                                         MetaKeyBinding* binding,
                                         gpointer self);
static void __lambda64_ (GreeterCompositorWindowManager* self);
static void ___lambda64__meta_key_handler_func (MetaDisplay* display,
                                         MetaWindow* window,
                                         const ClutterKeyEvent* event,
                                         MetaKeyBinding* binding,
                                         gpointer self);
static void __lambda65_ (GreeterCompositorWindowManager* self);
static void ___lambda65__meta_key_handler_func (MetaDisplay* display,
                                         MetaWindow* window,
                                         const ClutterKeyEvent* event,
                                         MetaKeyBinding* binding,
                                         gpointer self);
static void __lambda66_ (GreeterCompositorWindowManager* self);
static void ___lambda66__meta_key_handler_func (MetaDisplay* display,
                                         MetaWindow* window,
                                         const ClutterKeyEvent* event,
                                         MetaKeyBinding* binding,
                                         gpointer self);
static void __lambda67_ (GreeterCompositorWindowManager* self);
static void ___lambda67__meta_key_handler_func (MetaDisplay* display,
                                         MetaWindow* window,
                                         const ClutterKeyEvent* event,
                                         MetaKeyBinding* binding,
                                         gpointer self);
static void __lambda68_ (GreeterCompositorWindowManager* self);
static void ___lambda68__meta_key_handler_func (MetaDisplay* display,
                                         MetaWindow* window,
                                         const ClutterKeyEvent* event,
                                         MetaKeyBinding* binding,
                                         gpointer self);
static void __lambda69_ (GreeterCompositorWindowManager* self);
static void ___lambda69__meta_key_handler_func (MetaDisplay* display,
                                         MetaWindow* window,
                                         const ClutterKeyEvent* event,
                                         MetaKeyBinding* binding,
                                         gpointer self);
static void __lambda70_ (GreeterCompositorWindowManager* self);
static void ___lambda70__meta_key_handler_func (MetaDisplay* display,
                                         MetaWindow* window,
                                         const ClutterKeyEvent* event,
                                         MetaKeyBinding* binding,
                                         gpointer self);
static void __lambda71_ (GreeterCompositorWindowManager* self);
static void ___lambda71__meta_key_handler_func (MetaDisplay* display,
                                         MetaWindow* window,
                                         const ClutterKeyEvent* event,
                                         MetaKeyBinding* binding,
                                         gpointer self);
static void __lambda72_ (GreeterCompositorWindowManager* self);
static void ___lambda72__meta_key_handler_func (MetaDisplay* display,
                                         MetaWindow* window,
                                         const ClutterKeyEvent* event,
                                         MetaKeyBinding* binding,
                                         gpointer self);
static void __lambda73_ (GreeterCompositorWindowManager* self);
static void ___lambda73__meta_key_handler_func (MetaDisplay* display,
                                         MetaWindow* window,
                                         const ClutterKeyEvent* event,
                                         MetaKeyBinding* binding,
                                         gpointer self);
static void __lambda74_ (GreeterCompositorWindowManager* self);
static void ___lambda74__meta_key_handler_func (MetaDisplay* display,
                                         MetaWindow* window,
                                         const ClutterKeyEvent* event,
                                         MetaKeyBinding* binding,
                                         gpointer self);
static void __lambda75_ (GreeterCompositorWindowManager* self);
static void ___lambda75__meta_key_handler_func (MetaDisplay* display,
                                         MetaWindow* window,
                                         const ClutterKeyEvent* event,
                                         MetaKeyBinding* binding,
                                         gpointer self);
static void __lambda76_ (GreeterCompositorWindowManager* self);
static void ___lambda76__meta_key_handler_func (MetaDisplay* display,
                                         MetaWindow* window,
                                         const ClutterKeyEvent* event,
                                         MetaKeyBinding* binding,
                                         gpointer self);
static void __lambda77_ (GreeterCompositorWindowManager* self);
static void ___lambda77__meta_key_handler_func (MetaDisplay* display,
                                         MetaWindow* window,
                                         const ClutterKeyEvent* event,
                                         MetaKeyBinding* binding,
                                         gpointer self);
static void __lambda78_ (GreeterCompositorWindowManager* self);
static void ___lambda78__meta_key_handler_func (MetaDisplay* display,
                                         MetaWindow* window,
                                         const ClutterKeyEvent* event,
                                         MetaKeyBinding* binding,
                                         gpointer self);
static void __lambda79_ (GreeterCompositorWindowManager* self);
static void ___lambda79__meta_key_handler_func (MetaDisplay* display,
                                         MetaWindow* window,
                                         const ClutterKeyEvent* event,
                                         MetaKeyBinding* binding,
                                         gpointer self);
VALA_EXTERN GreeterCompositorZoom* greeter_compositor_zoom_new (GreeterCompositorWindowManager* wm);
VALA_EXTERN GreeterCompositorZoom* greeter_compositor_zoom_construct (GType object_type,
                                                          GreeterCompositorWindowManager* wm);
static void greeter_compositor_window_manager_toggle_screen_reader (GreeterCompositorWindowManager* self);
static void _greeter_compositor_window_manager_toggle_screen_reader_g_settings_changed (GSettings* _sender,
                                                                                 const gchar* key,
                                                                                 gpointer self);
static void __lambda80_ (GreeterCompositorWindowManager* self,
                  MetaWindow* window);
VALA_EXTERN void greeter_compositor_utils_wait_for_window_actor_visible (MetaWindow* window,
                                                             GreeterCompositorUtilsWindowActorReadyCallback callback,
                                                             gpointer callback_target,
                                                             GDestroyNotify callback_target_destroy_notify);
static void greeter_compositor_window_manager_check_shell_window (GreeterCompositorWindowManager* self,
                                                           MetaWindowActor* actor);
static void _greeter_compositor_window_manager_check_shell_window_greeter_compositor_utils_window_actor_ready_callback (MetaWindowActor* window_actor,
                                                                                                                 gpointer self);
static void ___lambda80__meta_display_window_created (MetaDisplay* _sender,
                                               MetaWindow* object,
                                               gpointer self);
static gboolean __lambda94_ (Block26Data* _data26_);
VALA_EXTERN void greeter_compositor_shell_clients_manager_init (GreeterCompositorWindowManager* wm);
static void greeter_compositor_window_manager_start_command (GreeterCompositorWindowManager* self,
                                                      gchar** command,
                                                      gint command_length1,
                                                      GAsyncReadyCallback _callback_,
                                                      gpointer _user_data_);
static void greeter_compositor_window_manager_start_command_finish (GreeterCompositorWindowManager* self,
                                                             GAsyncResult* _res_);
static gboolean ___lambda94__gsource_func (gpointer self);
static void greeter_compositor_window_manager_start_command_data_free (gpointer _data);
static gboolean greeter_compositor_window_manager_start_command_co (GreeterCompositorWindowManagerStartCommandData* _data_);
static void greeter_compositor_window_manager_start_wayland (GreeterCompositorWindowManager* self,
                                                      gchar** command,
                                                      gint command_length1,
                                                      GAsyncReadyCallback _callback_,
                                                      gpointer _user_data_);
static void greeter_compositor_window_manager_start_wayland_finish (GreeterCompositorWindowManager* self,
                                                             GAsyncResult* _res_);
static void greeter_compositor_window_manager_start_command_ready (GObject* source_object,
                                                            GAsyncResult* _res_,
                                                            gpointer _user_data_);
static void greeter_compositor_window_manager_start_x (GreeterCompositorWindowManager* self,
                                                gchar** command,
                                                gint command_length1,
                                                GAsyncReadyCallback _callback_,
                                                gpointer _user_data_);
static void greeter_compositor_window_manager_start_x_finish (GreeterCompositorWindowManager* self,
                                                       GAsyncResult* _res_);
static void greeter_compositor_window_manager_start_wayland_data_free (gpointer _data);
static gboolean greeter_compositor_window_manager_start_wayland_co (GreeterCompositorWindowManagerStartWaylandData* _data_);
static Block27Data* block27_data_ref (Block27Data* _data27_);
static void block27_data_unref (void * _userdata_);
static void greeter_compositor_window_manager_start_wayland_ready (GObject* source_object,
                                                            GAsyncResult* _res_,
                                                            gpointer _user_data_);
static gboolean ___lambda95_ (Block27Data* _data27_);
static gboolean ____lambda95__gsource_func (gpointer self);
static void greeter_compositor_window_manager_start_x_data_free (gpointer _data);
static gboolean greeter_compositor_window_manager_start_x_co (GreeterCompositorWindowManagerStartXData* _data_);
static Block28Data* block28_data_ref (Block28Data* _data28_);
static void block28_data_unref (void * _userdata_);
static void greeter_compositor_window_manager_start_x_ready (GObject* source_object,
                                                      GAsyncResult* _res_,
                                                      gpointer _user_data_);
static gboolean ___lambda96_ (Block28Data* _data28_);
static gboolean ____lambda96__gsource_func (gpointer self);
VALA_EXTERN GType greeter_compositor_shell_clients_manager_get_type (void) G_GNUC_CONST ;
G_DEFINE_AUTOPTR_CLEANUP_FUNC (GreeterCompositorShellClientsManager, g_object_unref)
VALA_EXTERN GreeterCompositorShellClientsManager* greeter_compositor_shell_clients_manager_get_instance (void);
VALA_EXTERN gboolean greeter_compositor_shell_clients_manager_is_positioned_window (GreeterCompositorShellClientsManager* self,
                                                                        MetaWindow* window);
VALA_EXTERN void greeter_compositor_utils_clutter_actor_reparent (ClutterActor* actor,
                                                      ClutterActor* new_parent);
VALA_EXTERN gboolean greeter_compositor_notification_stack_is_notification (MetaWindow* window);
VALA_EXTERN void greeter_compositor_notification_stack_show_notification (GreeterCompositorNotificationStack* self,
                                                              MetaWindowActor* notification);
static void greeter_compositor_window_manager_real_show_window_menu_for_rect (MetaPlugin* base,
                                                                       MetaWindow* window,
                                                                       MetaWindowMenuType menu,
                                                                       MtkRectangle* rect);
static void greeter_compositor_window_manager_real_size_change (MetaPlugin* base,
                                                         MetaWindowActor* actor,
                                                         MetaSizeChange which_change,
                                                         MtkRectangle* old_frame_rect,
                                                         MtkRectangle* old_buffer_rect);
static void greeter_compositor_window_manager_real_minimize (MetaPlugin* base,
                                                      MetaWindowActor* actor);
static void greeter_compositor_window_manager_real_unminimize (MetaPlugin* base,
                                                        MetaWindowActor* actor);
static void greeter_compositor_window_manager_real_map (MetaPlugin* base,
                                                 MetaWindowActor* actor);
static void greeter_compositor_window_manager_real_destroy (MetaPlugin* base,
                                                     MetaWindowActor* actor);
static void greeter_compositor_window_manager_real_kill_window_effects (MetaPlugin* base,
                                                                 MetaWindowActor* actor);
static void greeter_compositor_window_manager_real_switch_workspace (MetaPlugin* base,
                                                              gint from,
                                                              gint to,
                                                              MetaMotionDirection direction);
static void greeter_compositor_window_manager_real_locate_pointer (MetaPlugin* base);
VALA_EXTERN void greeter_compositor_pointer_locator_show_ripple (GreeterCompositorPointerLocator* self);
static void greeter_compositor_window_manager_real_confirm_display_change (MetaPlugin* base);
static Block29Data* block29_data_ref (Block29Data* _data29_);
static void block29_data_unref (void * _userdata_);
VALA_EXTERN GType greeter_compositor_access_dialog_get_type (void) G_GNUC_CONST ;
G_DEFINE_AUTOPTR_CLEANUP_FUNC (GreeterCompositorAccessDialog, g_object_unref)
VALA_EXTERN GreeterCompositorAccessDialog* greeter_compositor_access_dialog_new (const gchar* title,
                                                                     const gchar* body,
                                                                     const gchar* icon);
VALA_EXTERN GreeterCompositorAccessDialog* greeter_compositor_access_dialog_construct (GType object_type,
                                                                           const gchar* title,
                                                                           const gchar* body,
                                                                           const gchar* icon);
VALA_EXTERN void greeter_compositor_access_dialog_set_accept_label (GreeterCompositorAccessDialog* self,
                                                        const gchar* value);
VALA_EXTERN void greeter_compositor_access_dialog_set_deny_label (GreeterCompositorAccessDialog* self,
                                                      const gchar* value);
static void __lambda101_ (Block29Data* _data29_);
static gboolean __lambda102_ (Block29Data* _data29_);
static gboolean ___lambda102__gsource_func (gpointer self);
static void ___lambda101__greeter_compositor_access_dialog_show (GreeterCompositorAccessDialog* _sender,
                                                          gpointer self);
static void __lambda103_ (Block29Data* _data29_,
                   guint res);
static void ___lambda103__greeter_compositor_access_dialog_response (GreeterCompositorAccessDialog* _sender,
                                                              guint response,
                                                              gpointer self);
static MetaPluginInfo* greeter_compositor_window_manager_real_plugin_info (MetaPlugin* base);
VALA_EXTERN GreeterCompositorWindowManager* greeter_compositor_window_manager_new (void);
VALA_EXTERN GreeterCompositorWindowManager* greeter_compositor_window_manager_construct (GType object_type);
static GObject * greeter_compositor_window_manager_constructor (GType type,
                                                         guint n_construct_properties,
                                                         GObjectConstructParam * construct_properties);
static void greeter_compositor_window_manager_finalize (GObject * obj);
static GType greeter_compositor_window_manager_get_type_once (void);
static void _vala_greeter_compositor_window_manager_get_property (GObject * object,
                                                           guint property_id,
                                                           GValue * value,
                                                           GParamSpec * pspec);
static void _vala_greeter_compositor_window_manager_set_property (GObject * object,
                                                           guint property_id,
                                                           const GValue * value,
                                                           GParamSpec * pspec);
static void _vala_array_destroy (gpointer array,
                          gssize array_length,
                          GDestroyNotify destroy_func);
static void _vala_array_free (gpointer array,
                       gssize array_length,
                       GDestroyNotify destroy_func);

static inline gpointer
greeter_compositor_window_manager_get_instance_private (GreeterCompositorWindowManager* self)
{
	return G_STRUCT_MEMBER_P (self, GreeterCompositorWindowManager_private_offset);
}

static void
__lambda97_ (GreeterCompositorWindowManager* self)
{
	greeter_compositor_window_manager_refresh_background (self);
}

static void
___lambda97__meta_display_gl_video_memory_purged (MetaDisplay* _sender,
                                                  gpointer self)
{
	__lambda97_ ((GreeterCompositorWindowManager*) self);
}

static void
greeter_compositor_window_manager_real_start (MetaPlugin* base)
{
	GreeterCompositorWindowManager * self;
	ClutterActor* _tmp0_;
	ClutterActor* _tmp1_;
	ClutterActor* _tmp2_;
	ClutterActor* _tmp3_;
	ClutterActor* _tmp4_;
	MetaDisplay* display = NULL;
	MetaDisplay* _tmp5_;
	self = (GreeterCompositorWindowManager*) base;
	greeter_compositor_blur_manager_init (self);
	greeter_compositor_window_manager_show_stage (self);
	_tmp0_ = self->priv->fade_in_screen;
	clutter_actor_save_easing_state (_tmp0_);
	_tmp1_ = self->priv->fade_in_screen;
	clutter_actor_set_easing_duration (_tmp1_, (guint) 1000);
	_tmp2_ = self->priv->fade_in_screen;
	clutter_actor_set_easing_mode (_tmp2_, CLUTTER_EASE);
	_tmp3_ = self->priv->fade_in_screen;
	clutter_actor_set_opacity (_tmp3_, (guint) 0);
	_tmp4_ = self->priv->fade_in_screen;
	clutter_actor_restore_easing_state (_tmp4_);
	_tmp5_ = meta_plugin_get_display ((MetaPlugin*) self);
	display = _tmp5_;
	g_signal_connect_object (display, "gl-video-memory-purged", (GCallback) ___lambda97__meta_display_gl_video_memory_purged, self, 0);
}

static void
greeter_compositor_window_manager_refresh_background (GreeterCompositorWindowManager* self)
{
	MetaDisplay* display = NULL;
	MetaDisplay* _tmp0_;
	ClutterStage* _tmp1_;
	GreeterCompositorSystemBackground* _tmp2_;
	MetaBackgroundActor* _tmp3_;
	MetaBackgroundActor* _tmp4_;
	GreeterCompositorSystemBackground* _tmp5_;
	GreeterCompositorSystemBackground* _tmp6_;
	GreeterCompositorSystemBackground* _tmp7_;
	MetaBackgroundActor* _tmp8_;
	MetaBackgroundActor* _tmp9_;
	ClutterStage* _tmp10_;
	ClutterBindConstraint* _tmp11_;
	ClutterBindConstraint* _tmp12_;
	ClutterStage* _tmp13_;
	GreeterCompositorSystemBackground* _tmp14_;
	MetaBackgroundActor* _tmp15_;
	MetaBackgroundActor* _tmp16_;
	g_return_if_fail (self != NULL);
	_tmp0_ = meta_plugin_get_display ((MetaPlugin*) self);
	display = _tmp0_;
	_tmp1_ = self->priv->_stage;
	_tmp2_ = self->priv->_system_background;
	_tmp3_ = greeter_compositor_system_background_get_background_actor (_tmp2_);
	_tmp4_ = _tmp3_;
	clutter_actor_remove_child ((ClutterActor*) _tmp1_, (ClutterActor*) _tmp4_);
	_tmp5_ = greeter_compositor_system_background_new (display);
	_tmp6_ = _tmp5_;
	greeter_compositor_window_manager_set_system_background (self, _tmp6_);
	_g_object_unref0 (_tmp6_);
	_tmp7_ = self->priv->_system_background;
	_tmp8_ = greeter_compositor_system_background_get_background_actor (_tmp7_);
	_tmp9_ = _tmp8_;
	_tmp10_ = self->priv->_stage;
	_tmp11_ = (ClutterBindConstraint*) clutter_bind_constraint_new ((ClutterActor*) _tmp10_, CLUTTER_BIND_ALL, (gfloat) 0);
	g_object_ref_sink (_tmp11_);
	_tmp12_ = _tmp11_;
	clutter_actor_add_constraint ((ClutterActor*) _tmp9_, (ClutterConstraint*) _tmp12_);
	_g_object_unref0 (_tmp12_);
	_tmp13_ = self->priv->_stage;
	_tmp14_ = self->priv->_system_background;
	_tmp15_ = greeter_compositor_system_background_get_background_actor (_tmp14_);
	_tmp16_ = _tmp15_;
	clutter_actor_insert_child_below ((ClutterActor*) _tmp13_, (ClutterActor*) _tmp16_, NULL);
}

static Block26Data*
block26_data_ref (Block26Data* _data26_)
{
	g_atomic_int_inc (&_data26_->_ref_count_);
	return _data26_;
}

static void
block26_data_unref (void * _userdata_)
{
	Block26Data* _data26_;
	_data26_ = (Block26Data*) _userdata_;
	if (g_atomic_int_dec_and_test (&_data26_->_ref_count_)) {
		GreeterCompositorWindowManager* self;
		self = _data26_->self;
		_g_object_unref0 (self);
		g_slice_free (Block26Data, _data26_);
	}
}

static void
_vala_ClutterColor_free (ClutterColor* self)
{
	g_boxed_free (clutter_color_get_type (), self);
}

static void
_greeter_compositor_window_manager_update_ui_group_size_meta_monitor_manager_monitors_changed (MetaMonitorManager* _sender,
                                                                                               gpointer self)
{
	greeter_compositor_window_manager_update_ui_group_size ((GreeterCompositorWindowManager*) self);
}

static void
__lambda57_ (GreeterCompositorWindowManager* self)
{
}

static void
___lambda57__meta_key_handler_func (MetaDisplay* display,
                                    MetaWindow* window,
                                    const ClutterKeyEvent* event,
                                    MetaKeyBinding* binding,
                                    gpointer self)
{
	__lambda57_ ((GreeterCompositorWindowManager*) self);
}

static void
__lambda58_ (GreeterCompositorWindowManager* self)
{
}

static void
___lambda58__meta_key_handler_func (MetaDisplay* display,
                                    MetaWindow* window,
                                    const ClutterKeyEvent* event,
                                    MetaKeyBinding* binding,
                                    gpointer self)
{
	__lambda58_ ((GreeterCompositorWindowManager*) self);
}

static void
__lambda59_ (GreeterCompositorWindowManager* self)
{
}

static void
___lambda59__meta_key_handler_func (MetaDisplay* display,
                                    MetaWindow* window,
                                    const ClutterKeyEvent* event,
                                    MetaKeyBinding* binding,
                                    gpointer self)
{
	__lambda59_ ((GreeterCompositorWindowManager*) self);
}

static void
__lambda60_ (GreeterCompositorWindowManager* self)
{
}

static void
___lambda60__meta_key_handler_func (MetaDisplay* display,
                                    MetaWindow* window,
                                    const ClutterKeyEvent* event,
                                    MetaKeyBinding* binding,
                                    gpointer self)
{
	__lambda60_ ((GreeterCompositorWindowManager*) self);
}

static void
__lambda61_ (GreeterCompositorWindowManager* self)
{
}

static void
___lambda61__meta_key_handler_func (MetaDisplay* display,
                                    MetaWindow* window,
                                    const ClutterKeyEvent* event,
                                    MetaKeyBinding* binding,
                                    gpointer self)
{
	__lambda61_ ((GreeterCompositorWindowManager*) self);
}

static void
__lambda62_ (GreeterCompositorWindowManager* self)
{
}

static void
___lambda62__meta_key_handler_func (MetaDisplay* display,
                                    MetaWindow* window,
                                    const ClutterKeyEvent* event,
                                    MetaKeyBinding* binding,
                                    gpointer self)
{
	__lambda62_ ((GreeterCompositorWindowManager*) self);
}

static void
__lambda63_ (GreeterCompositorWindowManager* self)
{
}

static void
___lambda63__meta_key_handler_func (MetaDisplay* display,
                                    MetaWindow* window,
                                    const ClutterKeyEvent* event,
                                    MetaKeyBinding* binding,
                                    gpointer self)
{
	__lambda63_ ((GreeterCompositorWindowManager*) self);
}

static void
__lambda64_ (GreeterCompositorWindowManager* self)
{
}

static void
___lambda64__meta_key_handler_func (MetaDisplay* display,
                                    MetaWindow* window,
                                    const ClutterKeyEvent* event,
                                    MetaKeyBinding* binding,
                                    gpointer self)
{
	__lambda64_ ((GreeterCompositorWindowManager*) self);
}

static void
__lambda65_ (GreeterCompositorWindowManager* self)
{
}

static void
___lambda65__meta_key_handler_func (MetaDisplay* display,
                                    MetaWindow* window,
                                    const ClutterKeyEvent* event,
                                    MetaKeyBinding* binding,
                                    gpointer self)
{
	__lambda65_ ((GreeterCompositorWindowManager*) self);
}

static void
__lambda66_ (GreeterCompositorWindowManager* self)
{
}

static void
___lambda66__meta_key_handler_func (MetaDisplay* display,
                                    MetaWindow* window,
                                    const ClutterKeyEvent* event,
                                    MetaKeyBinding* binding,
                                    gpointer self)
{
	__lambda66_ ((GreeterCompositorWindowManager*) self);
}

static void
__lambda67_ (GreeterCompositorWindowManager* self)
{
}

static void
___lambda67__meta_key_handler_func (MetaDisplay* display,
                                    MetaWindow* window,
                                    const ClutterKeyEvent* event,
                                    MetaKeyBinding* binding,
                                    gpointer self)
{
	__lambda67_ ((GreeterCompositorWindowManager*) self);
}

static void
__lambda68_ (GreeterCompositorWindowManager* self)
{
}

static void
___lambda68__meta_key_handler_func (MetaDisplay* display,
                                    MetaWindow* window,
                                    const ClutterKeyEvent* event,
                                    MetaKeyBinding* binding,
                                    gpointer self)
{
	__lambda68_ ((GreeterCompositorWindowManager*) self);
}

static void
__lambda69_ (GreeterCompositorWindowManager* self)
{
}

static void
___lambda69__meta_key_handler_func (MetaDisplay* display,
                                    MetaWindow* window,
                                    const ClutterKeyEvent* event,
                                    MetaKeyBinding* binding,
                                    gpointer self)
{
	__lambda69_ ((GreeterCompositorWindowManager*) self);
}

static void
__lambda70_ (GreeterCompositorWindowManager* self)
{
}

static void
___lambda70__meta_key_handler_func (MetaDisplay* display,
                                    MetaWindow* window,
                                    const ClutterKeyEvent* event,
                                    MetaKeyBinding* binding,
                                    gpointer self)
{
	__lambda70_ ((GreeterCompositorWindowManager*) self);
}

static void
__lambda71_ (GreeterCompositorWindowManager* self)
{
}

static void
___lambda71__meta_key_handler_func (MetaDisplay* display,
                                    MetaWindow* window,
                                    const ClutterKeyEvent* event,
                                    MetaKeyBinding* binding,
                                    gpointer self)
{
	__lambda71_ ((GreeterCompositorWindowManager*) self);
}

static void
__lambda72_ (GreeterCompositorWindowManager* self)
{
}

static void
___lambda72__meta_key_handler_func (MetaDisplay* display,
                                    MetaWindow* window,
                                    const ClutterKeyEvent* event,
                                    MetaKeyBinding* binding,
                                    gpointer self)
{
	__lambda72_ ((GreeterCompositorWindowManager*) self);
}

static void
__lambda73_ (GreeterCompositorWindowManager* self)
{
}

static void
___lambda73__meta_key_handler_func (MetaDisplay* display,
                                    MetaWindow* window,
                                    const ClutterKeyEvent* event,
                                    MetaKeyBinding* binding,
                                    gpointer self)
{
	__lambda73_ ((GreeterCompositorWindowManager*) self);
}

static void
__lambda74_ (GreeterCompositorWindowManager* self)
{
}

static void
___lambda74__meta_key_handler_func (MetaDisplay* display,
                                    MetaWindow* window,
                                    const ClutterKeyEvent* event,
                                    MetaKeyBinding* binding,
                                    gpointer self)
{
	__lambda74_ ((GreeterCompositorWindowManager*) self);
}

static void
__lambda75_ (GreeterCompositorWindowManager* self)
{
}

static void
___lambda75__meta_key_handler_func (MetaDisplay* display,
                                    MetaWindow* window,
                                    const ClutterKeyEvent* event,
                                    MetaKeyBinding* binding,
                                    gpointer self)
{
	__lambda75_ ((GreeterCompositorWindowManager*) self);
}

static void
__lambda76_ (GreeterCompositorWindowManager* self)
{
}

static void
___lambda76__meta_key_handler_func (MetaDisplay* display,
                                    MetaWindow* window,
                                    const ClutterKeyEvent* event,
                                    MetaKeyBinding* binding,
                                    gpointer self)
{
	__lambda76_ ((GreeterCompositorWindowManager*) self);
}

static void
__lambda77_ (GreeterCompositorWindowManager* self)
{
}

static void
___lambda77__meta_key_handler_func (MetaDisplay* display,
                                    MetaWindow* window,
                                    const ClutterKeyEvent* event,
                                    MetaKeyBinding* binding,
                                    gpointer self)
{
	__lambda77_ ((GreeterCompositorWindowManager*) self);
}

static void
__lambda78_ (GreeterCompositorWindowManager* self)
{
}

static void
___lambda78__meta_key_handler_func (MetaDisplay* display,
                                    MetaWindow* window,
                                    const ClutterKeyEvent* event,
                                    MetaKeyBinding* binding,
                                    gpointer self)
{
	__lambda78_ ((GreeterCompositorWindowManager*) self);
}

static void
__lambda79_ (GreeterCompositorWindowManager* self)
{
}

static void
___lambda79__meta_key_handler_func (MetaDisplay* display,
                                    MetaWindow* window,
                                    const ClutterKeyEvent* event,
                                    MetaKeyBinding* binding,
                                    gpointer self)
{
	__lambda79_ ((GreeterCompositorWindowManager*) self);
}

static void
_greeter_compositor_window_manager_toggle_screen_reader_g_settings_changed (GSettings* _sender,
                                                                            const gchar* key,
                                                                            gpointer self)
{
	greeter_compositor_window_manager_toggle_screen_reader ((GreeterCompositorWindowManager*) self);
}

static void
_greeter_compositor_window_manager_check_shell_window_greeter_compositor_utils_window_actor_ready_callback (MetaWindowActor* window_actor,
                                                                                                            gpointer self)
{
	greeter_compositor_window_manager_check_shell_window ((GreeterCompositorWindowManager*) self, window_actor);
}

static void
__lambda80_ (GreeterCompositorWindowManager* self,
             MetaWindow* window)
{
	g_return_if_fail (window != NULL);
	greeter_compositor_utils_wait_for_window_actor_visible (window, _greeter_compositor_window_manager_check_shell_window_greeter_compositor_utils_window_actor_ready_callback, g_object_ref (self), g_object_unref);
}

static void
___lambda80__meta_display_window_created (MetaDisplay* _sender,
                                          MetaWindow* object,
                                          gpointer self)
{
	__lambda80_ ((GreeterCompositorWindowManager*) self, object);
}

static gboolean
__lambda94_ (Block26Data* _data26_)
{
	GreeterCompositorWindowManager* self;
	MetaContext* _tmp0_;
	const gchar* _tmp1_;
	gboolean result;
	self = _data26_->self;
	_tmp0_ = meta_display_get_context (_data26_->display);
	meta_context_notify_ready (_tmp0_);
	greeter_compositor_shell_clients_manager_init (self);
	_tmp1_ = g_getenv ("DESKTOP_SESSION");
	if (g_strcmp0 (_tmp1_, "installer") != 0) {
		gchar* _tmp2_;
		gchar** _tmp3_;
		gchar** _tmp4_;
		gint _tmp4__length1;
		gchar* _tmp5_;
		gchar** _tmp6_;
		gchar** _tmp7_;
		gint _tmp7__length1;
		gchar* _tmp8_;
		gchar** _tmp9_;
		gchar** _tmp10_;
		gint _tmp10__length1;
		_tmp2_ = g_strdup ("io.elementary.greeter-session-manager");
		_tmp3_ = g_new0 (gchar*, 1 + 1);
		_tmp3_[0] = _tmp2_;
		_tmp4_ = _tmp3_;
		_tmp4__length1 = 1;
		greeter_compositor_window_manager_start_command (self, _tmp4_, (gint) 1, NULL, NULL);
		_tmp4_ = (_vala_array_free (_tmp4_, _tmp4__length1, (GDestroyNotify) g_free), NULL);
		_tmp5_ = g_strdup ("io.elementary.greeter");
		_tmp6_ = g_new0 (gchar*, 1 + 1);
		_tmp6_[0] = _tmp5_;
		_tmp7_ = _tmp6_;
		_tmp7__length1 = 1;
		greeter_compositor_window_manager_start_command (self, _tmp7_, (gint) 1, NULL, NULL);
		_tmp7_ = (_vala_array_free (_tmp7_, _tmp7__length1, (GDestroyNotify) g_free), NULL);
		_tmp8_ = g_strdup ("io.elementary.settings-daemon");
		_tmp9_ = g_new0 (gchar*, 1 + 1);
		_tmp9_[0] = _tmp8_;
		_tmp10_ = _tmp9_;
		_tmp10__length1 = 1;
		greeter_compositor_window_manager_start_command (self, _tmp10_, (gint) 1, NULL, NULL);
		_tmp10_ = (_vala_array_free (_tmp10_, _tmp10__length1, (GDestroyNotify) g_free), NULL);
	}
	result = G_SOURCE_REMOVE;
	return result;
}

static gboolean
___lambda94__gsource_func (gpointer self)
{
	gboolean result;
	result = __lambda94_ (self);
	return result;
}

static void
greeter_compositor_window_manager_show_stage (GreeterCompositorWindowManager* self)
{
	Block26Data* _data26_;
	MetaDisplay* _tmp0_;
	GreeterCompositorNotificationStack* _tmp1_;
	ClutterActor* _tmp2_;
	ClutterStage* _tmp3_;
	ClutterColor* _tmp4_;
	ClutterColor* _tmp5_;
	ClutterColor _tmp6_;
	GreeterCompositorSystemBackground* _tmp7_;
	GreeterCompositorSystemBackground* _tmp8_;
	GreeterCompositorSystemBackground* _tmp9_;
	MetaBackgroundActor* _tmp10_;
	MetaBackgroundActor* _tmp11_;
	ClutterStage* _tmp12_;
	ClutterBindConstraint* _tmp13_;
	ClutterBindConstraint* _tmp14_;
	ClutterStage* _tmp15_;
	GreeterCompositorSystemBackground* _tmp16_;
	MetaBackgroundActor* _tmp17_;
	MetaBackgroundActor* _tmp18_;
	ClutterActor* _tmp19_;
	ClutterActor* _tmp20_;
	ClutterActor* _tmp21_;
	ClutterStage* _tmp22_;
	ClutterActor* _tmp23_;
	gint width = 0;
	gint height = 0;
	gint _tmp24_ = 0;
	gint _tmp25_ = 0;
	ClutterColor* _tmp26_;
	ClutterColor* _tmp27_;
	ClutterActor* _tmp28_ = NULL;
	ClutterColor _tmp29_;
	ClutterStage* _tmp30_;
	ClutterActor* _tmp31_;
	ClutterActor* _tmp32_;
	ClutterStage* _tmp33_;
	ClutterActor* _tmp34_;
	ClutterActor* _tmp35_;
	ClutterActor* _tmp36_;
	ClutterActor* _tmp37_;
	ClutterStage* _tmp38_;
	ClutterActor* _tmp39_;
	ClutterActor* _tmp40_;
	ClutterActor* _tmp41_;
	GreeterCompositorBackgroundContainer* _tmp42_;
	GreeterCompositorBackgroundContainer* _tmp43_;
	ClutterActor* _tmp44_;
	MetaBackgroundGroup* _tmp45_;
	ClutterActor* _tmp46_;
	MetaBackgroundGroup* _tmp47_;
	ClutterActor* _tmp48_;
	ClutterActor* _tmp49_;
	ClutterActor* _tmp50_;
	GreeterCompositorPointerLocator* _tmp51_;
	GreeterCompositorPointerLocator* _tmp52_;
	ClutterActor* _tmp53_;
	GreeterCompositorPointerLocator* _tmp54_;
	MetaMonitorManager* monitor_manager = NULL;
	MetaContext* _tmp55_;
	MetaBackend* _tmp56_;
	MetaMonitorManager* _tmp57_;
	GreeterCompositorZoom* _tmp58_;
	GSettings* _tmp59_;
	GSettings* _tmp60_;
	ClutterStage* _tmp61_;
	g_return_if_fail (self != NULL);
	_data26_ = g_slice_new0 (Block26Data);
	_data26_->_ref_count_ = 1;
	_data26_->self = g_object_ref (self);
	_tmp0_ = meta_plugin_get_display ((MetaPlugin*) self);
	_data26_->display = _tmp0_;
	greeter_compositor_media_feedback_init ();
	greeter_compositor_dbus_init (self);
	greeter_compositor_dbus_accelerator_init (self);
	greeter_compositor_dbus_wingpanel_manager_init (self);
	greeter_compositor_keyboard_manager_init (_data26_->display);
	_tmp1_ = greeter_compositor_notification_stack_new (_data26_->display);
	_g_object_unref0 (self->priv->notification_stack);
	self->priv->notification_stack = _tmp1_;
	_tmp2_ = meta_get_stage_for_display (_data26_->display);
	greeter_compositor_window_manager_set_stage (self, G_TYPE_CHECK_INSTANCE_TYPE (_tmp2_, clutter_stage_get_type ()) ? ((ClutterStage*) _tmp2_) : NULL);
	_tmp3_ = self->priv->_stage;
	_tmp4_ = clutter_color_new ((guint8) 0, (guint8) 0, (guint8) 0, (guint8) 255);
	_tmp5_ = _tmp4_;
	_tmp6_ = *_tmp5_;
	clutter_actor_set_background_color ((ClutterActor*) _tmp3_, &_tmp6_);
	__vala_ClutterColor_free0 (_tmp5_);
	_tmp7_ = greeter_compositor_system_background_new (_data26_->display);
	_tmp8_ = _tmp7_;
	greeter_compositor_window_manager_set_system_background (self, _tmp8_);
	_g_object_unref0 (_tmp8_);
	_tmp9_ = self->priv->_system_background;
	_tmp10_ = greeter_compositor_system_background_get_background_actor (_tmp9_);
	_tmp11_ = _tmp10_;
	_tmp12_ = self->priv->_stage;
	_tmp13_ = (ClutterBindConstraint*) clutter_bind_constraint_new ((ClutterActor*) _tmp12_, CLUTTER_BIND_ALL, (gfloat) 0);
	g_object_ref_sink (_tmp13_);
	_tmp14_ = _tmp13_;
	clutter_actor_add_constraint ((ClutterActor*) _tmp11_, (ClutterConstraint*) _tmp14_);
	_g_object_unref0 (_tmp14_);
	_tmp15_ = self->priv->_stage;
	_tmp16_ = self->priv->_system_background;
	_tmp17_ = greeter_compositor_system_background_get_background_actor (_tmp16_);
	_tmp18_ = _tmp17_;
	clutter_actor_insert_child_below ((ClutterActor*) _tmp15_, (ClutterActor*) _tmp18_, NULL);
	_tmp19_ = clutter_actor_new ();
	g_object_ref_sink (_tmp19_);
	_tmp20_ = _tmp19_;
	greeter_compositor_window_manager_set_ui_group (self, _tmp20_);
	_g_object_unref0 (_tmp20_);
	_tmp21_ = self->priv->_ui_group;
	clutter_actor_set_reactive (_tmp21_, TRUE);
	greeter_compositor_window_manager_update_ui_group_size (self);
	_tmp22_ = self->priv->_stage;
	_tmp23_ = self->priv->_ui_group;
	clutter_actor_add_child ((ClutterActor*) _tmp22_, _tmp23_);
	meta_display_get_size (_data26_->display, &_tmp24_, &_tmp25_);
	width = _tmp24_;
	height = _tmp25_;
	_tmp26_ = clutter_color_new ((guint8) 0, (guint8) 0, (guint8) 0, (guint8) 255);
	_tmp27_ = _tmp26_;
	_tmp28_ = clutter_actor_new ();
	clutter_actor_set_width (_tmp28_, (gfloat) width);
	clutter_actor_set_height (_tmp28_, (gfloat) height);
	_tmp29_ = *_tmp27_;
	clutter_actor_set_background_color (_tmp28_, &_tmp29_);
	g_object_ref_sink (_tmp28_);
	_g_object_unref0 (self->priv->fade_in_screen);
	self->priv->fade_in_screen = _tmp28_;
	__vala_ClutterColor_free0 (_tmp27_);
	_tmp30_ = self->priv->_stage;
	_tmp31_ = self->priv->fade_in_screen;
	clutter_actor_add_child ((ClutterActor*) _tmp30_, _tmp31_);
	_tmp32_ = meta_get_window_group_for_display (_data26_->display);
	greeter_compositor_window_manager_set_window_group (self, _tmp32_);
	_tmp33_ = self->priv->_stage;
	_tmp34_ = self->priv->_window_group;
	clutter_actor_remove_child ((ClutterActor*) _tmp33_, _tmp34_);
	_tmp35_ = self->priv->_ui_group;
	_tmp36_ = self->priv->_window_group;
	clutter_actor_add_child (_tmp35_, _tmp36_);
	_tmp37_ = meta_get_top_window_group_for_display (_data26_->display);
	greeter_compositor_window_manager_set_top_window_group (self, _tmp37_);
	_tmp38_ = self->priv->_stage;
	_tmp39_ = self->priv->_top_window_group;
	clutter_actor_remove_child ((ClutterActor*) _tmp38_, _tmp39_);
	_tmp40_ = self->priv->_ui_group;
	_tmp41_ = self->priv->_top_window_group;
	clutter_actor_add_child (_tmp40_, _tmp41_);
	_tmp42_ = greeter_compositor_background_container_new (self);
	g_object_ref_sink (_tmp42_);
	_tmp43_ = _tmp42_;
	greeter_compositor_window_manager_set_background_group (self, (MetaBackgroundGroup*) _tmp43_);
	_g_object_unref0 (_tmp43_);
	_tmp44_ = self->priv->_window_group;
	_tmp45_ = self->priv->_background_group;
	clutter_actor_add_child (_tmp44_, (ClutterActor*) _tmp45_);
	_tmp46_ = self->priv->_window_group;
	_tmp47_ = self->priv->_background_group;
	clutter_actor_set_child_below_sibling (_tmp46_, (ClutterActor*) _tmp47_, NULL);
	_tmp48_ = clutter_actor_new ();
	g_object_ref_sink (_tmp48_);
	_g_object_unref0 (self->priv->shell_group);
	self->priv->shell_group = _tmp48_;
	_tmp49_ = self->priv->_ui_group;
	_tmp50_ = self->priv->shell_group;
	clutter_actor_add_child (_tmp49_, _tmp50_);
	_tmp51_ = greeter_compositor_pointer_locator_new (self);
	g_object_ref_sink (_tmp51_);
	_tmp52_ = _tmp51_;
	greeter_compositor_window_manager_set_pointer_locator (self, _tmp52_);
	_g_object_unref0 (_tmp52_);
	_tmp53_ = self->priv->_ui_group;
	_tmp54_ = self->priv->_pointer_locator;
	clutter_actor_add_child (_tmp53_, (ClutterActor*) _tmp54_);
	_tmp55_ = meta_display_get_context (_data26_->display);
	_tmp56_ = meta_context_get_backend (_tmp55_);
	_tmp57_ = meta_backend_get_monitor_manager (_tmp56_);
	monitor_manager = _tmp57_;
	g_signal_connect_object (monitor_manager, "monitors-changed", (GCallback) _greeter_compositor_window_manager_update_ui_group_size_meta_monitor_manager_monitors_changed, self, 0);
	meta_keybindings_set_custom_handler ("switch-to-workspace-first", ___lambda57__meta_key_handler_func, g_object_ref (self), g_object_unref);
	meta_keybindings_set_custom_handler ("switch-to-workspace-last", ___lambda58__meta_key_handler_func, g_object_ref (self), g_object_unref);
	meta_keybindings_set_custom_handler ("move-to-workspace-first", ___lambda59__meta_key_handler_func, g_object_ref (self), g_object_unref);
	meta_keybindings_set_custom_handler ("move-to-workspace-last", ___lambda60__meta_key_handler_func, g_object_ref (self), g_object_unref);
	meta_keybindings_set_custom_handler ("cycle-workspaces-next", ___lambda61__meta_key_handler_func, g_object_ref (self), g_object_unref);
	meta_keybindings_set_custom_handler ("cycle-workspaces-previous", ___lambda62__meta_key_handler_func, g_object_ref (self), g_object_unref);
	meta_keybindings_set_custom_handler ("panel-main-menu", ___lambda63__meta_key_handler_func, g_object_ref (self), g_object_unref);
	meta_keybindings_set_custom_handler ("toggle-recording", ___lambda64__meta_key_handler_func, g_object_ref (self), g_object_unref);
	meta_keybindings_set_custom_handler ("switch-to-workspace-up", ___lambda65__meta_key_handler_func, g_object_ref (self), g_object_unref);
	meta_keybindings_set_custom_handler ("switch-to-workspace-down", ___lambda66__meta_key_handler_func, g_object_ref (self), g_object_unref);
	meta_keybindings_set_custom_handler ("switch-to-workspace-left", ___lambda67__meta_key_handler_func, g_object_ref (self), g_object_unref);
	meta_keybindings_set_custom_handler ("switch-to-workspace-right", ___lambda68__meta_key_handler_func, g_object_ref (self), g_object_unref);
	meta_keybindings_set_custom_handler ("move-to-workspace-up", ___lambda69__meta_key_handler_func, g_object_ref (self), g_object_unref);
	meta_keybindings_set_custom_handler ("move-to-workspace-down", ___lambda70__meta_key_handler_func, g_object_ref (self), g_object_unref);
	meta_keybindings_set_custom_handler ("move-to-workspace-left", ___lambda71__meta_key_handler_func, g_object_ref (self), g_object_unref);
	meta_keybindings_set_custom_handler ("move-to-workspace-right", ___lambda72__meta_key_handler_func, g_object_ref (self), g_object_unref);
	meta_keybindings_set_custom_handler ("switch-group", ___lambda73__meta_key_handler_func, g_object_ref (self), g_object_unref);
	meta_keybindings_set_custom_handler ("switch-group-backward", ___lambda74__meta_key_handler_func, g_object_ref (self), g_object_unref);
	meta_keybindings_set_custom_handler ("show-desktop", ___lambda75__meta_key_handler_func, g_object_ref (self), g_object_unref);
	meta_keybindings_set_custom_handler ("toggle-tiled-left", ___lambda76__meta_key_handler_func, g_object_ref (self), g_object_unref);
	meta_keybindings_set_custom_handler ("toggle-tiled-right", ___lambda77__meta_key_handler_func, g_object_ref (self), g_object_unref);
	meta_keybindings_set_custom_handler ("minimize", ___lambda78__meta_key_handler_func, g_object_ref (self), g_object_unref);
	meta_keybindings_set_custom_handler ("toggle-maximized", ___lambda79__meta_key_handler_func, g_object_ref (self), g_object_unref);
	_tmp58_ = greeter_compositor_zoom_new (self);
	_g_object_unref0 (self->priv->zoom);
	self->priv->zoom = _tmp58_;
	_tmp59_ = g_settings_new ("org.gnome.desktop.a11y.applications");
	_g_object_unref0 (self->priv->application_settings);
	self->priv->application_settings = _tmp59_;
	greeter_compositor_window_manager_toggle_screen_reader (self);
	_tmp60_ = self->priv->application_settings;
	g_signal_connect_object (_tmp60_, "changed::screen-reader-enabled", (GCallback) _greeter_compositor_window_manager_toggle_screen_reader_g_settings_changed, self, 0);
	g_signal_connect_object (_data26_->display, "window-created", (GCallback) ___lambda80__meta_display_window_created, self, 0);
	_tmp61_ = self->priv->_stage;
	clutter_actor_show ((ClutterActor*) _tmp61_);
	g_idle_add_full (G_PRIORITY_DEFAULT_IDLE, ___lambda94__gsource_func, block26_data_ref (_data26_), block26_data_unref);
	block26_data_unref (_data26_);
	_data26_ = NULL;
}

static void
greeter_compositor_window_manager_update_ui_group_size (GreeterCompositorWindowManager* self)
{
	MetaDisplay* display = NULL;
	MetaDisplay* _tmp0_;
	gint max_width = 0;
	gint max_height = 0;
	gint num_monitors = 0;
	MetaDisplay* _tmp1_;
	ClutterActor* _tmp12_;
	g_return_if_fail (self != NULL);
	_tmp0_ = meta_plugin_get_display ((MetaPlugin*) self);
	display = _tmp0_;
	max_width = 0;
	max_height = 0;
	_tmp1_ = display;
	num_monitors = meta_display_get_n_monitors (_tmp1_);
	{
		gint i = 0;
		i = 0;
		{
			gboolean _tmp2_ = FALSE;
			_tmp2_ = TRUE;
			while (TRUE) {
				MtkRectangle geom = {0};
				MetaDisplay* _tmp4_;
				MtkRectangle _tmp5_ = {0};
				gint total_width = 0;
				MtkRectangle _tmp6_;
				MtkRectangle _tmp7_;
				gint total_height = 0;
				MtkRectangle _tmp8_;
				MtkRectangle _tmp9_;
				gint _tmp10_ = 0;
				gint _tmp11_ = 0;
				if (!_tmp2_) {
					gint _tmp3_;
					_tmp3_ = i;
					i = _tmp3_ + 1;
				}
				_tmp2_ = FALSE;
				if (!(i < num_monitors)) {
					break;
				}
				_tmp4_ = display;
				meta_display_get_monitor_geometry (_tmp4_, i, &_tmp5_);
				geom = _tmp5_;
				_tmp6_ = geom;
				_tmp7_ = geom;
				total_width = _tmp6_.x + _tmp7_.width;
				_tmp8_ = geom;
				_tmp9_ = geom;
				total_height = _tmp8_.y + _tmp9_.height;
				if (max_width > total_width) {
					_tmp10_ = max_width;
				} else {
					_tmp10_ = total_width;
				}
				max_width = _tmp10_;
				if (max_height > total_height) {
					_tmp11_ = max_height;
				} else {
					_tmp11_ = total_height;
				}
				max_height = _tmp11_;
			}
		}
	}
	_tmp12_ = self->priv->_ui_group;
	clutter_actor_set_size (_tmp12_, (gfloat) max_width, (gfloat) max_height);
}

static void
greeter_compositor_window_manager_start_command_data_free (gpointer _data)
{
	GreeterCompositorWindowManagerStartCommandData* _data_;
	_data_ = _data;
	_g_object_unref0 (_data_->self);
	g_slice_free (GreeterCompositorWindowManagerStartCommandData, _data_);
}

static gpointer
_g_object_ref0 (gpointer self)
{
	return self ? g_object_ref (self) : NULL;
}

static void
greeter_compositor_window_manager_start_command (GreeterCompositorWindowManager* self,
                                                 gchar** command,
                                                 gint command_length1,
                                                 GAsyncReadyCallback _callback_,
                                                 gpointer _user_data_)
{
	GreeterCompositorWindowManagerStartCommandData* _data_;
	GreeterCompositorWindowManager* _tmp0_;
	g_return_if_fail (self != NULL);
	_data_ = g_slice_new0 (GreeterCompositorWindowManagerStartCommandData);
	_data_->_async_result = g_task_new (G_OBJECT (self), NULL, _callback_, _user_data_);
	g_task_set_task_data (_data_->_async_result, _data_, greeter_compositor_window_manager_start_command_data_free);
	_tmp0_ = _g_object_ref0 (self);
	_data_->self = _tmp0_;
	_data_->command = command;
	_data_->command_length1 = command_length1;
	greeter_compositor_window_manager_start_command_co (_data_);
}

static void
greeter_compositor_window_manager_start_command_finish (GreeterCompositorWindowManager* self,
                                                        GAsyncResult* _res_)
{
	GreeterCompositorWindowManagerStartCommandData* _data_;
	_data_ = g_task_propagate_pointer (G_TASK (_res_), NULL);
}

static void
greeter_compositor_window_manager_start_command_ready (GObject* source_object,
                                                       GAsyncResult* _res_,
                                                       gpointer _user_data_)
{
	GreeterCompositorWindowManagerStartCommandData* _data_;
	_data_ = _user_data_;
	_data_->_source_object_ = source_object;
	_data_->_res_ = _res_;
	greeter_compositor_window_manager_start_command_co (_data_);
}

static gboolean
greeter_compositor_window_manager_start_command_co (GreeterCompositorWindowManagerStartCommandData* _data_)
{
	switch (_data_->_state_) {
		case 0:
		goto _state_0;
		case 1:
		goto _state_1;
		case 2:
		goto _state_2;
		default:
		g_assert_not_reached ();
	}
	_state_0:
	if (meta_is_wayland_compositor ()) {
		_data_->_state_ = 1;
		greeter_compositor_window_manager_start_wayland (_data_->self, _data_->command, (gint) _data_->command_length1, greeter_compositor_window_manager_start_command_ready, _data_);
		return FALSE;
		_state_1:
		greeter_compositor_window_manager_start_wayland_finish (_data_->self, _data_->_res_);
	} else {
		_data_->_state_ = 2;
		greeter_compositor_window_manager_start_x (_data_->self, _data_->command, (gint) _data_->command_length1, greeter_compositor_window_manager_start_command_ready, _data_);
		return FALSE;
		_state_2:
		greeter_compositor_window_manager_start_x_finish (_data_->self, _data_->_res_);
	}
	g_task_return_pointer (_data_->_async_result, _data_, NULL);
	if (_data_->_state_ != 0) {
		while (!g_task_get_completed (_data_->_async_result)) {
			g_main_context_iteration (g_task_get_context (_data_->_async_result), TRUE);
		}
	}
	g_object_unref (_data_->_async_result);
	return FALSE;
}

static void
greeter_compositor_window_manager_start_wayland_data_free (gpointer _data)
{
	GreeterCompositorWindowManagerStartWaylandData* _data_;
	_data_ = _data;
	_g_object_unref0 (_data_->self);
	g_slice_free (GreeterCompositorWindowManagerStartWaylandData, _data_);
}

static void
greeter_compositor_window_manager_start_wayland (GreeterCompositorWindowManager* self,
                                                 gchar** command,
                                                 gint command_length1,
                                                 GAsyncReadyCallback _callback_,
                                                 gpointer _user_data_)
{
	GreeterCompositorWindowManagerStartWaylandData* _data_;
	GreeterCompositorWindowManager* _tmp0_;
	g_return_if_fail (self != NULL);
	_data_ = g_slice_new0 (GreeterCompositorWindowManagerStartWaylandData);
	_data_->_async_result = g_task_new (G_OBJECT (self), NULL, _callback_, _user_data_);
	g_task_set_task_data (_data_->_async_result, _data_, greeter_compositor_window_manager_start_wayland_data_free);
	_tmp0_ = _g_object_ref0 (self);
	_data_->self = _tmp0_;
	_data_->command = command;
	_data_->command_length1 = command_length1;
	greeter_compositor_window_manager_start_wayland_co (_data_);
}

static void
greeter_compositor_window_manager_start_wayland_finish (GreeterCompositorWindowManager* self,
                                                        GAsyncResult* _res_)
{
	GreeterCompositorWindowManagerStartWaylandData* _data_;
	_data_ = g_task_propagate_pointer (G_TASK (_res_), NULL);
}

static Block27Data*
block27_data_ref (Block27Data* _data27_)
{
	g_atomic_int_inc (&_data27_->_ref_count_);
	return _data27_;
}

static void
block27_data_unref (void * _userdata_)
{
	Block27Data* _data27_;
	_data27_ = (Block27Data*) _userdata_;
	if (g_atomic_int_dec_and_test (&_data27_->_ref_count_)) {
		GreeterCompositorWindowManager* self;
		self = _data27_->self;
		_g_object_unref0 (self);
		g_slice_free (Block27Data, _data27_);
	}
}

static void
greeter_compositor_window_manager_start_wayland_ready (GObject* source_object,
                                                       GAsyncResult* _res_,
                                                       gpointer _user_data_)
{
	GreeterCompositorWindowManagerStartWaylandData* _data_;
	_data_ = _user_data_;
	_data_->_source_object_ = source_object;
	_data_->_res_ = _res_;
	greeter_compositor_window_manager_start_wayland_co (_data_);
}

static gboolean
___lambda95_ (Block27Data* _data27_)
{
	GreeterCompositorWindowManager* self;
	gboolean result;
	self = _data27_->self;
	greeter_compositor_window_manager_start_wayland (self, _data27_->command, (gint) _data27_->command_length1, NULL, NULL);
	result = G_SOURCE_REMOVE;
	return result;
}

static gboolean
____lambda95__gsource_func (gpointer self)
{
	gboolean result;
	result = ___lambda95_ (self);
	return result;
}

static gboolean
greeter_compositor_window_manager_start_wayland_co (GreeterCompositorWindowManagerStartWaylandData* _data_)
{
	switch (_data_->_state_) {
		case 0:
		goto _state_0;
		case 1:
		goto _state_1;
		default:
		g_assert_not_reached ();
	}
	_state_0:
	_data_->_data27_ = g_slice_new0 (Block27Data);
	_data_->_data27_->_ref_count_ = 1;
	_data_->_data27_->self = g_object_ref (_data_->self);
	_data_->_data27_->command = _data_->command;
	_data_->_data27_->command_length1 = _data_->command_length1;
	_data_->_data27_->_async_data_ = _data_;
	_data_->_tmp0_ = meta_plugin_get_display ((MetaPlugin*) _data_->self);
	_data_->display = _data_->_tmp0_;
	_data_->_tmp1_ = g_subprocess_launcher_new (G_SUBPROCESS_FLAGS_INHERIT_FDS);
	_data_->subprocess_launcher = _data_->_tmp1_;
	{
		_data_->_tmp3_ = _data_->display;
		_data_->_tmp4_ = meta_display_get_context (_data_->_tmp3_);
		_data_->_tmp5_ = _data_->subprocess_launcher;
		_data_->_tmp6_ = meta_wayland_client_new (_data_->_tmp4_, _data_->_tmp5_, &_data_->_inner_error0_);
		_data_->_tmp2_ = _data_->_tmp6_;
		if (G_UNLIKELY (_data_->_inner_error0_ != NULL)) {
			_g_object_unref0 (_data_->daemon_client);
			goto __catch0_g_error;
		}
		_data_->_tmp7_ = _data_->_tmp2_;
		_data_->_tmp2_ = NULL;
		_g_object_unref0 (_data_->daemon_client);
		_data_->daemon_client = _data_->_tmp7_;
		_data_->_tmp8_ = _data_->daemon_client;
		_data_->_tmp9_ = _data_->display;
		_data_->_tmp10_ = meta_wayland_client_spawnv (_data_->_tmp8_, _data_->_tmp9_, _data_->_data27_->command, &_data_->_inner_error0_);
		_data_->subprocess = _data_->_tmp10_;
		if (G_UNLIKELY (_data_->_inner_error0_ != NULL)) {
			_g_object_unref0 (_data_->_tmp2_);
			_g_object_unref0 (_data_->daemon_client);
			goto __catch0_g_error;
		}
		_data_->_tmp11_ = _data_->subprocess;
		_data_->_state_ = 1;
		g_subprocess_wait_async (_data_->_tmp11_, NULL, greeter_compositor_window_manager_start_wayland_ready, _data_);
		return FALSE;
		_state_1:
		g_subprocess_wait_finish (_data_->_tmp11_, _data_->_res_, &_data_->_inner_error0_);
		if (G_UNLIKELY (_data_->_inner_error0_ != NULL)) {
			_g_object_unref0 (_data_->subprocess);
			_g_object_unref0 (_data_->_tmp2_);
			_g_object_unref0 (_data_->daemon_client);
			goto __catch0_g_error;
		}
		g_timeout_add_seconds_full (G_PRIORITY_DEFAULT, (guint) 1, ____lambda95__gsource_func, block27_data_ref (_data_->_data27_), block27_data_unref);
		_g_object_unref0 (_data_->subprocess);
		_g_object_unref0 (_data_->_tmp2_);
		_g_object_unref0 (_data_->daemon_client);
	}
	goto __finally0;
	__catch0_g_error:
	{
		_data_->e = _data_->_inner_error0_;
		_data_->_inner_error0_ = NULL;
		_data_->_tmp12_ = _data_->e;
		_data_->_tmp13_ = _data_->_tmp12_->message;
		g_warning ("WindowManager.vala:267: Failed to create greeter client: %s", _data_->_tmp13_);
		_g_error_free0 (_data_->e);
		_g_object_unref0 (_data_->subprocess_launcher);
		block27_data_unref (_data_->_data27_);
		_data_->_data27_ = NULL;
		g_task_return_pointer (_data_->_async_result, _data_, NULL);
		if (_data_->_state_ != 0) {
			while (!g_task_get_completed (_data_->_async_result)) {
				g_main_context_iteration (g_task_get_context (_data_->_async_result), TRUE);
			}
		}
		g_object_unref (_data_->_async_result);
		return FALSE;
	}
	__finally0:
	if (G_UNLIKELY (_data_->_inner_error0_ != NULL)) {
		_g_object_unref0 (_data_->subprocess_launcher);
		block27_data_unref (_data_->_data27_);
		_data_->_data27_ = NULL;
		g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error0_->message, g_quark_to_string (_data_->_inner_error0_->domain), _data_->_inner_error0_->code);
		g_clear_error (&_data_->_inner_error0_);
		g_object_unref (_data_->_async_result);
		return FALSE;
	}
	_g_object_unref0 (_data_->subprocess_launcher);
	block27_data_unref (_data_->_data27_);
	_data_->_data27_ = NULL;
	g_task_return_pointer (_data_->_async_result, _data_, NULL);
	if (_data_->_state_ != 0) {
		while (!g_task_get_completed (_data_->_async_result)) {
			g_main_context_iteration (g_task_get_context (_data_->_async_result), TRUE);
		}
	}
	g_object_unref (_data_->_async_result);
	return FALSE;
}

static void
greeter_compositor_window_manager_start_x_data_free (gpointer _data)
{
	GreeterCompositorWindowManagerStartXData* _data_;
	_data_ = _data;
	_g_object_unref0 (_data_->self);
	g_slice_free (GreeterCompositorWindowManagerStartXData, _data_);
}

static void
greeter_compositor_window_manager_start_x (GreeterCompositorWindowManager* self,
                                           gchar** command,
                                           gint command_length1,
                                           GAsyncReadyCallback _callback_,
                                           gpointer _user_data_)
{
	GreeterCompositorWindowManagerStartXData* _data_;
	GreeterCompositorWindowManager* _tmp0_;
	g_return_if_fail (self != NULL);
	_data_ = g_slice_new0 (GreeterCompositorWindowManagerStartXData);
	_data_->_async_result = g_task_new (G_OBJECT (self), NULL, _callback_, _user_data_);
	g_task_set_task_data (_data_->_async_result, _data_, greeter_compositor_window_manager_start_x_data_free);
	_tmp0_ = _g_object_ref0 (self);
	_data_->self = _tmp0_;
	_data_->command = command;
	_data_->command_length1 = command_length1;
	greeter_compositor_window_manager_start_x_co (_data_);
}

static void
greeter_compositor_window_manager_start_x_finish (GreeterCompositorWindowManager* self,
                                                  GAsyncResult* _res_)
{
	GreeterCompositorWindowManagerStartXData* _data_;
	_data_ = g_task_propagate_pointer (G_TASK (_res_), NULL);
}

static Block28Data*
block28_data_ref (Block28Data* _data28_)
{
	g_atomic_int_inc (&_data28_->_ref_count_);
	return _data28_;
}

static void
block28_data_unref (void * _userdata_)
{
	Block28Data* _data28_;
	_data28_ = (Block28Data*) _userdata_;
	if (g_atomic_int_dec_and_test (&_data28_->_ref_count_)) {
		GreeterCompositorWindowManager* self;
		self = _data28_->self;
		_g_object_unref0 (self);
		g_slice_free (Block28Data, _data28_);
	}
}

static void
greeter_compositor_window_manager_start_x_ready (GObject* source_object,
                                                 GAsyncResult* _res_,
                                                 gpointer _user_data_)
{
	GreeterCompositorWindowManagerStartXData* _data_;
	_data_ = _user_data_;
	_data_->_source_object_ = source_object;
	_data_->_res_ = _res_;
	greeter_compositor_window_manager_start_x_co (_data_);
}

static gboolean
___lambda96_ (Block28Data* _data28_)
{
	GreeterCompositorWindowManager* self;
	gboolean result;
	self = _data28_->self;
	greeter_compositor_window_manager_start_x (self, _data28_->command, (gint) _data28_->command_length1, NULL, NULL);
	result = G_SOURCE_REMOVE;
	return result;
}

static gboolean
____lambda96__gsource_func (gpointer self)
{
	gboolean result;
	result = ___lambda96_ (self);
	return result;
}

static gboolean
greeter_compositor_window_manager_start_x_co (GreeterCompositorWindowManagerStartXData* _data_)
{
	switch (_data_->_state_) {
		case 0:
		goto _state_0;
		case 1:
		goto _state_1;
		default:
		g_assert_not_reached ();
	}
	_state_0:
	_data_->_data28_ = g_slice_new0 (Block28Data);
	_data_->_data28_->_ref_count_ = 1;
	_data_->_data28_->self = g_object_ref (_data_->self);
	_data_->_data28_->command = _data_->command;
	_data_->_data28_->command_length1 = _data_->command_length1;
	_data_->_data28_->_async_data_ = _data_;
	{
		_data_->_tmp0_ = g_subprocess_newv (_data_->_data28_->command, G_SUBPROCESS_FLAGS_INHERIT_FDS, &_data_->_inner_error0_);
		_data_->subprocess = _data_->_tmp0_;
		if (G_UNLIKELY (_data_->_inner_error0_ != NULL)) {
			goto __catch0_g_error;
		}
		_data_->_tmp1_ = _data_->subprocess;
		_data_->_state_ = 1;
		g_subprocess_wait_async (_data_->_tmp1_, NULL, greeter_compositor_window_manager_start_x_ready, _data_);
		return FALSE;
		_state_1:
		g_subprocess_wait_finish (_data_->_tmp1_, _data_->_res_, &_data_->_inner_error0_);
		if (G_UNLIKELY (_data_->_inner_error0_ != NULL)) {
			_g_object_unref0 (_data_->subprocess);
			goto __catch0_g_error;
		}
		g_timeout_add_seconds_full (G_PRIORITY_DEFAULT, (guint) 1, ____lambda96__gsource_func, block28_data_ref (_data_->_data28_), block28_data_unref);
		_g_object_unref0 (_data_->subprocess);
	}
	goto __finally0;
	__catch0_g_error:
	{
		_data_->e = _data_->_inner_error0_;
		_data_->_inner_error0_ = NULL;
		_data_->_tmp2_ = _data_->e;
		_data_->_tmp3_ = _data_->_tmp2_->message;
		g_warning ("WindowManager.vala:283: Failed to create greeter subprocess with x: %s", _data_->_tmp3_);
		_g_error_free0 (_data_->e);
	}
	__finally0:
	if (G_UNLIKELY (_data_->_inner_error0_ != NULL)) {
		block28_data_unref (_data_->_data28_);
		_data_->_data28_ = NULL;
		g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error0_->message, g_quark_to_string (_data_->_inner_error0_->domain), _data_->_inner_error0_->code);
		g_clear_error (&_data_->_inner_error0_);
		g_object_unref (_data_->_async_result);
		return FALSE;
	}
	block28_data_unref (_data_->_data28_);
	_data_->_data28_ = NULL;
	g_task_return_pointer (_data_->_async_result, _data_, NULL);
	if (_data_->_state_ != 0) {
		while (!g_task_get_completed (_data_->_async_result)) {
			g_main_context_iteration (g_task_get_context (_data_->_async_result), TRUE);
		}
	}
	g_object_unref (_data_->_async_result);
	return FALSE;
}

static void
greeter_compositor_window_manager_toggle_screen_reader (GreeterCompositorWindowManager* self)
{
	gboolean _tmp0_ = FALSE;
	GError* _inner_error0_ = NULL;
	g_return_if_fail (self != NULL);
	if (self->priv->reader_pid == 0) {
		GSettings* _tmp1_;
		_tmp1_ = self->priv->application_settings;
		_tmp0_ = g_settings_get_boolean (_tmp1_, "screen-reader-enabled");
	} else {
		_tmp0_ = FALSE;
	}
	if (_tmp0_) {
		{
			gchar** argv = NULL;
			gint argv_length1 = 0;
			gint _argv_size_ = 0;
			gchar** _tmp2_ = NULL;
			gint _tmp3_ = 0;
			gchar** _tmp4_;
			gint _tmp4__length1;
			GPid _tmp5_ = 0;
			g_shell_parse_argv ("orca --replace", &_tmp3_, &_tmp2_, &_inner_error0_);
			argv = (_vala_array_free (argv, argv_length1, (GDestroyNotify) g_free), NULL);
			argv = _tmp2_;
			argv_length1 = _tmp3_;
			_argv_size_ = argv_length1;
			if (G_UNLIKELY (_inner_error0_ != NULL)) {
				argv = (_vala_array_free (argv, argv_length1, (GDestroyNotify) g_free), NULL);
				goto __catch0_g_error;
			}
			_tmp4_ = argv;
			_tmp4__length1 = argv_length1;
			g_spawn_async (NULL, _tmp4_, NULL, G_SPAWN_SEARCH_PATH, NULL, NULL, &_tmp5_, &_inner_error0_);
			self->priv->reader_pid = (gint) _tmp5_;
			if (G_UNLIKELY (_inner_error0_ != NULL)) {
				argv = (_vala_array_free (argv, argv_length1, (GDestroyNotify) g_free), NULL);
				goto __catch0_g_error;
			}
			argv = (_vala_array_free (argv, argv_length1, (GDestroyNotify) g_free), NULL);
		}
		goto __finally0;
		__catch0_g_error:
		{
			GError* e = NULL;
			GError* _tmp6_;
			const gchar* _tmp7_;
			e = _inner_error0_;
			_inner_error0_ = NULL;
			_tmp6_ = e;
			_tmp7_ = _tmp6_->message;
			g_warning ("WindowManager.vala:294: %s", _tmp7_);
			_g_error_free0 (e);
		}
		__finally0:
		if (G_UNLIKELY (_inner_error0_ != NULL)) {
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error0_->message, g_quark_to_string (_inner_error0_->domain), _inner_error0_->code);
			g_clear_error (&_inner_error0_);
			return;
		}
	} else {
		gboolean _tmp8_ = FALSE;
		if (self->priv->reader_pid != 0) {
			GSettings* _tmp9_;
			_tmp9_ = self->priv->application_settings;
			_tmp8_ = !g_settings_get_boolean (_tmp9_, "screen-reader-enabled");
		} else {
			_tmp8_ = FALSE;
		}
		if (_tmp8_) {
			kill ((pid_t) self->priv->reader_pid, (gint) SIGQUIT);
			waitpid ((pid_t) self->priv->reader_pid, NULL, 0);
			self->priv->reader_pid = 0;
		}
	}
}

static void
greeter_compositor_window_manager_check_shell_window (GreeterCompositorWindowManager* self,
                                                      MetaWindowActor* actor)
{
	MetaWindow* window = NULL;
	MetaWindow* _tmp0_;
	GreeterCompositorShellClientsManager* _tmp1_;
	MetaWindow* _tmp2_;
	MetaWindow* _tmp4_;
	g_return_if_fail (self != NULL);
	g_return_if_fail (actor != NULL);
	_tmp0_ = meta_window_actor_get_meta_window (actor);
	window = _tmp0_;
	_tmp1_ = greeter_compositor_shell_clients_manager_get_instance ();
	_tmp2_ = window;
	if (greeter_compositor_shell_clients_manager_is_positioned_window (_tmp1_, _tmp2_)) {
		ClutterActor* _tmp3_;
		_tmp3_ = self->priv->shell_group;
		greeter_compositor_utils_clutter_actor_reparent ((ClutterActor*) actor, _tmp3_);
	}
	_tmp4_ = window;
	if (greeter_compositor_notification_stack_is_notification (_tmp4_)) {
		GreeterCompositorNotificationStack* _tmp5_;
		_tmp5_ = self->priv->notification_stack;
		greeter_compositor_notification_stack_show_notification (_tmp5_, actor);
	}
}

static void
greeter_compositor_window_manager_real_show_window_menu_for_rect (MetaPlugin* base,
                                                                  MetaWindow* window,
                                                                  MetaWindowMenuType menu,
                                                                  MtkRectangle* rect)
{
	GreeterCompositorWindowManager * self;
	MtkRectangle _tmp0_;
	MtkRectangle _tmp1_;
	self = (GreeterCompositorWindowManager*) base;
	g_return_if_fail (window != NULL);
	g_return_if_fail (rect != NULL);
	_tmp0_ = *rect;
	_tmp1_ = *rect;
	G_TYPE_INSTANCE_GET_CLASS ((MetaPlugin*) self, meta_plugin_get_type (), MetaPluginClass)->show_window_menu ((MetaPlugin*) self, window, menu, _tmp0_.x, _tmp1_.y);
}

static void
greeter_compositor_window_manager_real_size_change (MetaPlugin* base,
                                                    MetaWindowActor* actor,
                                                    MetaSizeChange which_change,
                                                    MtkRectangle* old_frame_rect,
                                                    MtkRectangle* old_buffer_rect)
{
	GreeterCompositorWindowManager * self;
	self = (GreeterCompositorWindowManager*) base;
	g_return_if_fail (actor != NULL);
	g_return_if_fail (old_frame_rect != NULL);
	g_return_if_fail (old_buffer_rect != NULL);
	meta_plugin_size_change_completed ((MetaPlugin*) self, actor);
}

static void
greeter_compositor_window_manager_real_minimize (MetaPlugin* base,
                                                 MetaWindowActor* actor)
{
	GreeterCompositorWindowManager * self;
	self = (GreeterCompositorWindowManager*) base;
	g_return_if_fail (actor != NULL);
	clutter_actor_hide ((ClutterActor*) actor);
	meta_plugin_minimize_completed ((MetaPlugin*) self, actor);
}

static void
greeter_compositor_window_manager_real_unminimize (MetaPlugin* base,
                                                   MetaWindowActor* actor)
{
	GreeterCompositorWindowManager * self;
	self = (GreeterCompositorWindowManager*) base;
	g_return_if_fail (actor != NULL);
	clutter_actor_show ((ClutterActor*) actor);
	meta_plugin_unminimize_completed ((MetaPlugin*) self, actor);
}

static void
greeter_compositor_window_manager_real_map (MetaPlugin* base,
                                            MetaWindowActor* actor)
{
	GreeterCompositorWindowManager * self;
	self = (GreeterCompositorWindowManager*) base;
	g_return_if_fail (actor != NULL);
	clutter_actor_show ((ClutterActor*) actor);
	meta_plugin_map_completed ((MetaPlugin*) self, actor);
}

static void
greeter_compositor_window_manager_real_destroy (MetaPlugin* base,
                                                MetaWindowActor* actor)
{
	GreeterCompositorWindowManager * self;
	self = (GreeterCompositorWindowManager*) base;
	g_return_if_fail (actor != NULL);
	meta_plugin_destroy_completed ((MetaPlugin*) self, actor);
}

static void
greeter_compositor_window_manager_real_kill_window_effects (MetaPlugin* base,
                                                            MetaWindowActor* actor)
{
	GreeterCompositorWindowManager * self;
	self = (GreeterCompositorWindowManager*) base;
	g_return_if_fail (actor != NULL);
}

static void
greeter_compositor_window_manager_real_switch_workspace (MetaPlugin* base,
                                                         gint from,
                                                         gint to,
                                                         MetaMotionDirection direction)
{
	GreeterCompositorWindowManager * self;
	self = (GreeterCompositorWindowManager*) base;
	meta_plugin_switch_workspace_completed ((MetaPlugin*) self);
}

static void
greeter_compositor_window_manager_real_locate_pointer (MetaPlugin* base)
{
	GreeterCompositorWindowManager * self;
	GreeterCompositorPointerLocator* _tmp0_;
	self = (GreeterCompositorWindowManager*) base;
	_tmp0_ = self->priv->_pointer_locator;
	greeter_compositor_pointer_locator_show_ripple (_tmp0_);
}

static Block29Data*
block29_data_ref (Block29Data* _data29_)
{
	g_atomic_int_inc (&_data29_->_ref_count_);
	return _data29_;
}

static void
block29_data_unref (void * _userdata_)
{
	Block29Data* _data29_;
	_data29_ = (Block29Data*) _userdata_;
	if (g_atomic_int_dec_and_test (&_data29_->_ref_count_)) {
		GreeterCompositorWindowManager* self;
		self = _data29_->self;
		_g_object_unref0 (self);
		g_slice_free (Block29Data, _data29_);
	}
}

static gboolean
__lambda102_ (Block29Data* _data29_)
{
	GreeterCompositorWindowManager* self;
	gboolean result;
	self = _data29_->self;
	_data29_->dialog_timeout_id = (guint) 0;
	result = G_SOURCE_REMOVE;
	return result;
}

static gboolean
___lambda102__gsource_func (gpointer self)
{
	gboolean result;
	result = __lambda102_ (self);
	return result;
}

static void
__lambda101_ (Block29Data* _data29_)
{
	GreeterCompositorWindowManager* self;
	self = _data29_->self;
	_data29_->dialog_timeout_id = g_timeout_add_seconds_full (G_PRIORITY_DEFAULT, (guint) _data29_->timeout, ___lambda102__gsource_func, block29_data_ref (_data29_), block29_data_unref);
}

static void
___lambda101__greeter_compositor_access_dialog_show (GreeterCompositorAccessDialog* _sender,
                                                     gpointer self)
{
	__lambda101_ (self);
}

static void
__lambda103_ (Block29Data* _data29_,
              guint res)
{
	GreeterCompositorWindowManager* self;
	self = _data29_->self;
	if (_data29_->dialog_timeout_id != ((guint) 0)) {
		g_source_remove (_data29_->dialog_timeout_id);
		_data29_->dialog_timeout_id = (guint) 0;
	}
	meta_plugin_complete_display_change ((MetaPlugin*) self, res == ((guint) 0));
}

static void
___lambda103__greeter_compositor_access_dialog_response (GreeterCompositorAccessDialog* _sender,
                                                         guint response,
                                                         gpointer self)
{
	__lambda103_ (self, response);
}

static void
greeter_compositor_window_manager_real_confirm_display_change (MetaPlugin* base)
{
	GreeterCompositorWindowManager * self;
	Block29Data* _data29_;
	MetaMonitorManager* monitor_manager = NULL;
	MetaDisplay* _tmp0_;
	MetaContext* _tmp1_;
	MetaBackend* _tmp2_;
	MetaMonitorManager* _tmp3_;
	gchar* summary = NULL;
	gchar* _tmp4_;
	GreeterCompositorAccessDialog* dialog = NULL;
	gchar* _tmp5_;
	gchar* _tmp6_;
	gchar* _tmp7_;
	gchar* _tmp8_;
	GreeterCompositorAccessDialog* _tmp9_ = NULL;
	GreeterCompositorAccessDialog* _tmp10_;
	self = (GreeterCompositorWindowManager*) base;
	_data29_ = g_slice_new0 (Block29Data);
	_data29_->_ref_count_ = 1;
	_data29_->self = g_object_ref (self);
	_tmp0_ = meta_plugin_get_display ((MetaPlugin*) self);
	_tmp1_ = meta_display_get_context (_tmp0_);
	_tmp2_ = meta_context_get_backend (_tmp1_);
	_tmp3_ = meta_backend_get_monitor_manager (_tmp2_);
	monitor_manager = _tmp3_;
	_data29_->timeout = meta_monitor_manager_get_display_configuration_timeout (monitor_manager);
	_tmp4_ = g_strdup (ngettext ("Changes will automatically revert after %i second.", "Changes will automatically revert after %i seconds.", (gulong) _data29_->timeout));
	summary = _tmp4_;
	_data29_->dialog_timeout_id = (guint) 0;
	_tmp5_ = g_strdup_printf (summary, _data29_->timeout);
	_tmp6_ = _tmp5_;
	_tmp7_ = g_strdup (_ ("Keep Settings"));
	_tmp8_ = g_strdup (_ ("Use Previous Settings"));
	_tmp9_ = greeter_compositor_access_dialog_new (_ ("Keep new display settings?"), _tmp6_, "preferences-desktop-display");
	greeter_compositor_access_dialog_set_accept_label (_tmp9_, _tmp7_);
	_g_free0 (_tmp7_);
	greeter_compositor_access_dialog_set_deny_label (_tmp9_, _tmp8_);
	_g_free0 (_tmp8_);
	_tmp10_ = _tmp9_;
	_g_free0 (_tmp6_);
	dialog = _tmp10_;
	g_signal_connect_data (dialog, "show", (GCallback) ___lambda101__greeter_compositor_access_dialog_show, block29_data_ref (_data29_), (GClosureNotify) block29_data_unref, 0);
	g_signal_connect_data (dialog, "response", (GCallback) ___lambda103__greeter_compositor_access_dialog_response, block29_data_ref (_data29_), (GClosureNotify) block29_data_unref, 0);
	g_signal_emit_by_name (dialog, "show");
	_g_object_unref0 (dialog);
	_g_free0 (summary);
	block29_data_unref (_data29_);
	_data29_ = NULL;
}

static MetaPluginInfo*
greeter_compositor_window_manager_real_plugin_info (MetaPlugin* base)
{
	GreeterCompositorWindowManager * self;
	MetaPluginInfo _tmp0_;
	MetaPluginInfo* result;
	self = (GreeterCompositorWindowManager*) base;
	_tmp0_ = self->priv->info;
	result = &_tmp0_;
	return result;
}

GreeterCompositorWindowManager*
greeter_compositor_window_manager_construct (GType object_type)
{
	GreeterCompositorWindowManager * self = NULL;
	self = (GreeterCompositorWindowManager*) g_object_new (object_type, NULL);
	return self;
}

GreeterCompositorWindowManager*
greeter_compositor_window_manager_new (void)
{
	return greeter_compositor_window_manager_construct (GREETER_COMPOSITOR_TYPE_WINDOW_MANAGER);
}

ClutterActor*
greeter_compositor_window_manager_get_ui_group (GreeterCompositorWindowManager* self)
{
	ClutterActor* result;
	ClutterActor* _tmp0_;
	g_return_val_if_fail (self != NULL, NULL);
	_tmp0_ = self->priv->_ui_group;
	result = _tmp0_;
	return result;
}

void
greeter_compositor_window_manager_set_ui_group (GreeterCompositorWindowManager* self,
                                                ClutterActor* value)
{
	ClutterActor* old_value;
	g_return_if_fail (self != NULL);
	old_value = greeter_compositor_window_manager_get_ui_group (self);
	if (old_value != value) {
		ClutterActor* _tmp0_;
		_tmp0_ = _g_object_ref0 (value);
		_g_object_unref0 (self->priv->_ui_group);
		self->priv->_ui_group = _tmp0_;
		g_object_notify_by_pspec ((GObject *) self, greeter_compositor_window_manager_properties[GREETER_COMPOSITOR_WINDOW_MANAGER_UI_GROUP_PROPERTY]);
	}
}

ClutterStage*
greeter_compositor_window_manager_get_stage (GreeterCompositorWindowManager* self)
{
	ClutterStage* result;
	ClutterStage* _tmp0_;
	g_return_val_if_fail (self != NULL, NULL);
	_tmp0_ = self->priv->_stage;
	result = _tmp0_;
	return result;
}

void
greeter_compositor_window_manager_set_stage (GreeterCompositorWindowManager* self,
                                             ClutterStage* value)
{
	ClutterStage* old_value;
	g_return_if_fail (self != NULL);
	old_value = greeter_compositor_window_manager_get_stage (self);
	if (old_value != value) {
		ClutterStage* _tmp0_;
		_tmp0_ = _g_object_ref0 (value);
		_g_object_unref0 (self->priv->_stage);
		self->priv->_stage = _tmp0_;
		g_object_notify_by_pspec ((GObject *) self, greeter_compositor_window_manager_properties[GREETER_COMPOSITOR_WINDOW_MANAGER_STAGE_PROPERTY]);
	}
}

ClutterActor*
greeter_compositor_window_manager_get_window_group (GreeterCompositorWindowManager* self)
{
	ClutterActor* result;
	ClutterActor* _tmp0_;
	g_return_val_if_fail (self != NULL, NULL);
	_tmp0_ = self->priv->_window_group;
	result = _tmp0_;
	return result;
}

void
greeter_compositor_window_manager_set_window_group (GreeterCompositorWindowManager* self,
                                                    ClutterActor* value)
{
	ClutterActor* old_value;
	g_return_if_fail (self != NULL);
	old_value = greeter_compositor_window_manager_get_window_group (self);
	if (old_value != value) {
		ClutterActor* _tmp0_;
		_tmp0_ = _g_object_ref0 (value);
		_g_object_unref0 (self->priv->_window_group);
		self->priv->_window_group = _tmp0_;
		g_object_notify_by_pspec ((GObject *) self, greeter_compositor_window_manager_properties[GREETER_COMPOSITOR_WINDOW_MANAGER_WINDOW_GROUP_PROPERTY]);
	}
}

ClutterActor*
greeter_compositor_window_manager_get_top_window_group (GreeterCompositorWindowManager* self)
{
	ClutterActor* result;
	ClutterActor* _tmp0_;
	g_return_val_if_fail (self != NULL, NULL);
	_tmp0_ = self->priv->_top_window_group;
	result = _tmp0_;
	return result;
}

void
greeter_compositor_window_manager_set_top_window_group (GreeterCompositorWindowManager* self,
                                                        ClutterActor* value)
{
	ClutterActor* old_value;
	g_return_if_fail (self != NULL);
	old_value = greeter_compositor_window_manager_get_top_window_group (self);
	if (old_value != value) {
		ClutterActor* _tmp0_;
		_tmp0_ = _g_object_ref0 (value);
		_g_object_unref0 (self->priv->_top_window_group);
		self->priv->_top_window_group = _tmp0_;
		g_object_notify_by_pspec ((GObject *) self, greeter_compositor_window_manager_properties[GREETER_COMPOSITOR_WINDOW_MANAGER_TOP_WINDOW_GROUP_PROPERTY]);
	}
}

MetaBackgroundGroup*
greeter_compositor_window_manager_get_background_group (GreeterCompositorWindowManager* self)
{
	MetaBackgroundGroup* result;
	MetaBackgroundGroup* _tmp0_;
	g_return_val_if_fail (self != NULL, NULL);
	_tmp0_ = self->priv->_background_group;
	result = _tmp0_;
	return result;
}

void
greeter_compositor_window_manager_set_background_group (GreeterCompositorWindowManager* self,
                                                        MetaBackgroundGroup* value)
{
	MetaBackgroundGroup* old_value;
	g_return_if_fail (self != NULL);
	old_value = greeter_compositor_window_manager_get_background_group (self);
	if (old_value != value) {
		MetaBackgroundGroup* _tmp0_;
		_tmp0_ = _g_object_ref0 (value);
		_g_object_unref0 (self->priv->_background_group);
		self->priv->_background_group = _tmp0_;
		g_object_notify_by_pspec ((GObject *) self, greeter_compositor_window_manager_properties[GREETER_COMPOSITOR_WINDOW_MANAGER_BACKGROUND_GROUP_PROPERTY]);
	}
}

GreeterCompositorPointerLocator*
greeter_compositor_window_manager_get_pointer_locator (GreeterCompositorWindowManager* self)
{
	GreeterCompositorPointerLocator* result;
	GreeterCompositorPointerLocator* _tmp0_;
	g_return_val_if_fail (self != NULL, NULL);
	_tmp0_ = self->priv->_pointer_locator;
	result = _tmp0_;
	return result;
}

static void
greeter_compositor_window_manager_set_pointer_locator (GreeterCompositorWindowManager* self,
                                                       GreeterCompositorPointerLocator* value)
{
	GreeterCompositorPointerLocator* old_value;
	g_return_if_fail (self != NULL);
	old_value = greeter_compositor_window_manager_get_pointer_locator (self);
	if (old_value != value) {
		GreeterCompositorPointerLocator* _tmp0_;
		_tmp0_ = _g_object_ref0 (value);
		_g_object_unref0 (self->priv->_pointer_locator);
		self->priv->_pointer_locator = _tmp0_;
		g_object_notify_by_pspec ((GObject *) self, greeter_compositor_window_manager_properties[GREETER_COMPOSITOR_WINDOW_MANAGER_POINTER_LOCATOR_PROPERTY]);
	}
}

GreeterCompositorSystemBackground*
greeter_compositor_window_manager_get_system_background (GreeterCompositorWindowManager* self)
{
	GreeterCompositorSystemBackground* result;
	GreeterCompositorSystemBackground* _tmp0_;
	g_return_val_if_fail (self != NULL, NULL);
	_tmp0_ = self->priv->_system_background;
	result = _tmp0_;
	return result;
}

static void
greeter_compositor_window_manager_set_system_background (GreeterCompositorWindowManager* self,
                                                         GreeterCompositorSystemBackground* value)
{
	GreeterCompositorSystemBackground* old_value;
	g_return_if_fail (self != NULL);
	old_value = greeter_compositor_window_manager_get_system_background (self);
	if (old_value != value) {
		GreeterCompositorSystemBackground* _tmp0_;
		_tmp0_ = _g_object_ref0 (value);
		_g_object_unref0 (self->priv->_system_background);
		self->priv->_system_background = _tmp0_;
		g_object_notify_by_pspec ((GObject *) self, greeter_compositor_window_manager_properties[GREETER_COMPOSITOR_WINDOW_MANAGER_SYSTEM_BACKGROUND_PROPERTY]);
	}
}

static GObject *
greeter_compositor_window_manager_constructor (GType type,
                                               guint n_construct_properties,
                                               GObjectConstructParam * construct_properties)
{
	GObject * obj;
	GObjectClass * parent_class;
	GreeterCompositorWindowManager * self;
	MetaPluginInfo _tmp0_ = {0};
	parent_class = G_OBJECT_CLASS (greeter_compositor_window_manager_parent_class);
	obj = parent_class->constructor (type, n_construct_properties, construct_properties);
	self = G_TYPE_CHECK_INSTANCE_CAST (obj, GREETER_COMPOSITOR_TYPE_WINDOW_MANAGER, GreeterCompositorWindowManager);
	memset (&_tmp0_, 0, sizeof (MetaPluginInfo));
	_tmp0_.name = "GreeterCompositor";
	_tmp0_.version = CONSTANTS_VERSION;
	_tmp0_.author = "elementary LLC.";
	_tmp0_.license = "GPLv3";
	_tmp0_.description = "The greeter compositor";
	self->priv->info = _tmp0_;
	return obj;
}

static void
greeter_compositor_window_manager_class_init (GreeterCompositorWindowManagerClass * klass,
                                              gpointer klass_data)
{
	greeter_compositor_window_manager_parent_class = g_type_class_peek_parent (klass);
	g_type_class_adjust_private_offset (klass, &GreeterCompositorWindowManager_private_offset);
	((MetaPluginClass *) klass)->start = (void (*) (MetaPlugin*)) greeter_compositor_window_manager_real_start;
	((MetaPluginClass *) klass)->show_window_menu_for_rect = (void (*) (MetaPlugin*, MetaWindow*, MetaWindowMenuType, MtkRectangle*)) greeter_compositor_window_manager_real_show_window_menu_for_rect;
	((MetaPluginClass *) klass)->size_change = (void (*) (MetaPlugin*, MetaWindowActor*, MetaSizeChange, MtkRectangle*, MtkRectangle*)) greeter_compositor_window_manager_real_size_change;
	((MetaPluginClass *) klass)->minimize = (void (*) (MetaPlugin*, MetaWindowActor*)) greeter_compositor_window_manager_real_minimize;
	((MetaPluginClass *) klass)->unminimize = (void (*) (MetaPlugin*, MetaWindowActor*)) greeter_compositor_window_manager_real_unminimize;
	((MetaPluginClass *) klass)->map = (void (*) (MetaPlugin*, MetaWindowActor*)) greeter_compositor_window_manager_real_map;
	((MetaPluginClass *) klass)->destroy = (void (*) (MetaPlugin*, MetaWindowActor*)) greeter_compositor_window_manager_real_destroy;
	((MetaPluginClass *) klass)->kill_window_effects = (void (*) (MetaPlugin*, MetaWindowActor*)) greeter_compositor_window_manager_real_kill_window_effects;
	((MetaPluginClass *) klass)->switch_workspace = (void (*) (MetaPlugin*, gint, gint, MetaMotionDirection)) greeter_compositor_window_manager_real_switch_workspace;
	((MetaPluginClass *) klass)->locate_pointer = (void (*) (MetaPlugin*)) greeter_compositor_window_manager_real_locate_pointer;
	((MetaPluginClass *) klass)->confirm_display_change = (void (*) (MetaPlugin*)) greeter_compositor_window_manager_real_confirm_display_change;
	((MetaPluginClass *) klass)->plugin_info = (MetaPluginInfo* (*) (MetaPlugin*)) greeter_compositor_window_manager_real_plugin_info;
	G_OBJECT_CLASS (klass)->get_property = _vala_greeter_compositor_window_manager_get_property;
	G_OBJECT_CLASS (klass)->set_property = _vala_greeter_compositor_window_manager_set_property;
	G_OBJECT_CLASS (klass)->constructor = greeter_compositor_window_manager_constructor;
	G_OBJECT_CLASS (klass)->finalize = greeter_compositor_window_manager_finalize;
	g_object_class_install_property (G_OBJECT_CLASS (klass), GREETER_COMPOSITOR_WINDOW_MANAGER_UI_GROUP_PROPERTY, greeter_compositor_window_manager_properties[GREETER_COMPOSITOR_WINDOW_MANAGER_UI_GROUP_PROPERTY] = g_param_spec_object ("ui-group", "ui-group", "ui-group", clutter_actor_get_type (), G_PARAM_STATIC_STRINGS | G_PARAM_READABLE | G_PARAM_WRITABLE));
	g_object_class_install_property (G_OBJECT_CLASS (klass), GREETER_COMPOSITOR_WINDOW_MANAGER_STAGE_PROPERTY, greeter_compositor_window_manager_properties[GREETER_COMPOSITOR_WINDOW_MANAGER_STAGE_PROPERTY] = g_param_spec_object ("stage", "stage", "stage", clutter_stage_get_type (), G_PARAM_STATIC_STRINGS | G_PARAM_READABLE | G_PARAM_WRITABLE));
	g_object_class_install_property (G_OBJECT_CLASS (klass), GREETER_COMPOSITOR_WINDOW_MANAGER_WINDOW_GROUP_PROPERTY, greeter_compositor_window_manager_properties[GREETER_COMPOSITOR_WINDOW_MANAGER_WINDOW_GROUP_PROPERTY] = g_param_spec_object ("window-group", "window-group", "window-group", clutter_actor_get_type (), G_PARAM_STATIC_STRINGS | G_PARAM_READABLE | G_PARAM_WRITABLE));
	g_object_class_install_property (G_OBJECT_CLASS (klass), GREETER_COMPOSITOR_WINDOW_MANAGER_TOP_WINDOW_GROUP_PROPERTY, greeter_compositor_window_manager_properties[GREETER_COMPOSITOR_WINDOW_MANAGER_TOP_WINDOW_GROUP_PROPERTY] = g_param_spec_object ("top-window-group", "top-window-group", "top-window-group", clutter_actor_get_type (), G_PARAM_STATIC_STRINGS | G_PARAM_READABLE | G_PARAM_WRITABLE));
	g_object_class_install_property (G_OBJECT_CLASS (klass), GREETER_COMPOSITOR_WINDOW_MANAGER_BACKGROUND_GROUP_PROPERTY, greeter_compositor_window_manager_properties[GREETER_COMPOSITOR_WINDOW_MANAGER_BACKGROUND_GROUP_PROPERTY] = g_param_spec_object ("background-group", "background-group", "background-group", meta_background_group_get_type (), G_PARAM_STATIC_STRINGS | G_PARAM_READABLE | G_PARAM_WRITABLE));
	g_object_class_install_property (G_OBJECT_CLASS (klass), GREETER_COMPOSITOR_WINDOW_MANAGER_POINTER_LOCATOR_PROPERTY, greeter_compositor_window_manager_properties[GREETER_COMPOSITOR_WINDOW_MANAGER_POINTER_LOCATOR_PROPERTY] = g_param_spec_object ("pointer-locator", "pointer-locator", "pointer-locator", GREETER_COMPOSITOR_TYPE_POINTER_LOCATOR, G_PARAM_STATIC_STRINGS | G_PARAM_READABLE));
	g_object_class_install_property (G_OBJECT_CLASS (klass), GREETER_COMPOSITOR_WINDOW_MANAGER_SYSTEM_BACKGROUND_PROPERTY, greeter_compositor_window_manager_properties[GREETER_COMPOSITOR_WINDOW_MANAGER_SYSTEM_BACKGROUND_PROPERTY] = g_param_spec_object ("system-background", "system-background", "system-background", GREETER_COMPOSITOR_TYPE_SYSTEM_BACKGROUND, G_PARAM_STATIC_STRINGS | G_PARAM_READABLE));
}

static void
greeter_compositor_window_manager_instance_init (GreeterCompositorWindowManager * self,
                                                 gpointer klass)
{
	self->priv = greeter_compositor_window_manager_get_instance_private (self);
	self->priv->reader_pid = 0;
}

static void
greeter_compositor_window_manager_finalize (GObject * obj)
{
	GreeterCompositorWindowManager * self;
	self = G_TYPE_CHECK_INSTANCE_CAST (obj, GREETER_COMPOSITOR_TYPE_WINDOW_MANAGER, GreeterCompositorWindowManager);
	_g_object_unref0 (self->priv->_ui_group);
	_g_object_unref0 (self->priv->_stage);
	_g_object_unref0 (self->priv->_window_group);
	_g_object_unref0 (self->priv->_top_window_group);
	_g_object_unref0 (self->priv->_background_group);
	_g_object_unref0 (self->priv->_pointer_locator);
	_g_object_unref0 (self->priv->_system_background);
	_g_object_unref0 (self->priv->shell_group);
	_g_object_unref0 (self->priv->notification_stack);
	_g_object_unref0 (self->priv->fade_in_screen);
	_g_object_unref0 (self->priv->application_settings);
	_g_object_unref0 (self->priv->zoom);
	G_OBJECT_CLASS (greeter_compositor_window_manager_parent_class)->finalize (obj);
}

static GType
greeter_compositor_window_manager_get_type_once (void)
{
	static const GTypeInfo g_define_type_info = { sizeof (GreeterCompositorWindowManagerClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) greeter_compositor_window_manager_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (GreeterCompositorWindowManager), 0, (GInstanceInitFunc) greeter_compositor_window_manager_instance_init, NULL };
	GType greeter_compositor_window_manager_type_id;
	greeter_compositor_window_manager_type_id = g_type_register_static (meta_plugin_get_type (), "GreeterCompositorWindowManager", &g_define_type_info, 0);
	GreeterCompositorWindowManager_private_offset = g_type_add_instance_private (greeter_compositor_window_manager_type_id, sizeof (GreeterCompositorWindowManagerPrivate));
	return greeter_compositor_window_manager_type_id;
}

GType
greeter_compositor_window_manager_get_type (void)
{
	static volatile gsize greeter_compositor_window_manager_type_id__once = 0;
	if (g_once_init_enter (&greeter_compositor_window_manager_type_id__once)) {
		GType greeter_compositor_window_manager_type_id;
		greeter_compositor_window_manager_type_id = greeter_compositor_window_manager_get_type_once ();
		g_once_init_leave (&greeter_compositor_window_manager_type_id__once, greeter_compositor_window_manager_type_id);
	}
	return greeter_compositor_window_manager_type_id__once;
}

static void
_vala_greeter_compositor_window_manager_get_property (GObject * object,
                                                      guint property_id,
                                                      GValue * value,
                                                      GParamSpec * pspec)
{
	GreeterCompositorWindowManager * self;
	self = G_TYPE_CHECK_INSTANCE_CAST (object, GREETER_COMPOSITOR_TYPE_WINDOW_MANAGER, GreeterCompositorWindowManager);
	switch (property_id) {
		case GREETER_COMPOSITOR_WINDOW_MANAGER_UI_GROUP_PROPERTY:
		g_value_set_object (value, greeter_compositor_window_manager_get_ui_group (self));
		break;
		case GREETER_COMPOSITOR_WINDOW_MANAGER_STAGE_PROPERTY:
		g_value_set_object (value, greeter_compositor_window_manager_get_stage (self));
		break;
		case GREETER_COMPOSITOR_WINDOW_MANAGER_WINDOW_GROUP_PROPERTY:
		g_value_set_object (value, greeter_compositor_window_manager_get_window_group (self));
		break;
		case GREETER_COMPOSITOR_WINDOW_MANAGER_TOP_WINDOW_GROUP_PROPERTY:
		g_value_set_object (value, greeter_compositor_window_manager_get_top_window_group (self));
		break;
		case GREETER_COMPOSITOR_WINDOW_MANAGER_BACKGROUND_GROUP_PROPERTY:
		g_value_set_object (value, greeter_compositor_window_manager_get_background_group (self));
		break;
		case GREETER_COMPOSITOR_WINDOW_MANAGER_POINTER_LOCATOR_PROPERTY:
		g_value_set_object (value, greeter_compositor_window_manager_get_pointer_locator (self));
		break;
		case GREETER_COMPOSITOR_WINDOW_MANAGER_SYSTEM_BACKGROUND_PROPERTY:
		g_value_set_object (value, greeter_compositor_window_manager_get_system_background (self));
		break;
		default:
		G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
		break;
	}
}

static void
_vala_greeter_compositor_window_manager_set_property (GObject * object,
                                                      guint property_id,
                                                      const GValue * value,
                                                      GParamSpec * pspec)
{
	GreeterCompositorWindowManager * self;
	self = G_TYPE_CHECK_INSTANCE_CAST (object, GREETER_COMPOSITOR_TYPE_WINDOW_MANAGER, GreeterCompositorWindowManager);
	switch (property_id) {
		case GREETER_COMPOSITOR_WINDOW_MANAGER_UI_GROUP_PROPERTY:
		greeter_compositor_window_manager_set_ui_group (self, g_value_get_object (value));
		break;
		case GREETER_COMPOSITOR_WINDOW_MANAGER_STAGE_PROPERTY:
		greeter_compositor_window_manager_set_stage (self, g_value_get_object (value));
		break;
		case GREETER_COMPOSITOR_WINDOW_MANAGER_WINDOW_GROUP_PROPERTY:
		greeter_compositor_window_manager_set_window_group (self, g_value_get_object (value));
		break;
		case GREETER_COMPOSITOR_WINDOW_MANAGER_TOP_WINDOW_GROUP_PROPERTY:
		greeter_compositor_window_manager_set_top_window_group (self, g_value_get_object (value));
		break;
		case GREETER_COMPOSITOR_WINDOW_MANAGER_BACKGROUND_GROUP_PROPERTY:
		greeter_compositor_window_manager_set_background_group (self, g_value_get_object (value));
		break;
		case GREETER_COMPOSITOR_WINDOW_MANAGER_POINTER_LOCATOR_PROPERTY:
		greeter_compositor_window_manager_set_pointer_locator (self, g_value_get_object (value));
		break;
		case GREETER_COMPOSITOR_WINDOW_MANAGER_SYSTEM_BACKGROUND_PROPERTY:
		greeter_compositor_window_manager_set_system_background (self, g_value_get_object (value));
		break;
		default:
		G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
		break;
	}
}

static void
_vala_array_destroy (gpointer array,
                     gssize array_length,
                     GDestroyNotify destroy_func)
{
	if ((array != NULL) && (destroy_func != NULL)) {
		gssize i;
		for (i = 0; i < array_length; i = i + 1) {
			if (((gpointer*) array)[i] != NULL) {
				destroy_func (((gpointer*) array)[i]);
			}
		}
	}
}

static void
_vala_array_free (gpointer array,
                  gssize array_length,
                  GDestroyNotify destroy_func)
{
	_vala_array_destroy (array, array_length, destroy_func);
	g_free (array);
}

