/* Braindump.c generated by valac 0.56.19, the Vala compiler
 * generated from Braindump.vala, do not modify */

/*
* Copyright (c) 2024-2026 (https://github.com/phase1geo/Minder)
*
* 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 2 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, write to the
* Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
* Boston, MA 02110-1301 USA
*
* Authored by: Trevor Williams <phase1geo@gmail.com>
*/

#include <glib-object.h>
#include <stdlib.h>
#include <string.h>
#include <glib.h>
#include <gtk/gtk.h>
#include <glib/gi18n-lib.h>
#include <gdk/gdk.h>
#include <pango/pango.h>
#include <float.h>
#include <math.h>
#include <graphene-gobject.h>
#include <cairo-gobject.h>
#include <pango/pangocairo.h>

#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

typedef enum  {
	BRAINDUMP_CHANGE_TYPE_ADD,
	BRAINDUMP_CHANGE_TYPE_REMOVE,
	BRAINDUMP_CHANGE_TYPE_CLEAR
} BraindumpChangeType;

#define TYPE_BRAINDUMP_CHANGE_TYPE (braindump_change_type_get_type ())

#define TYPE_IDEA (idea_get_type ())
#define IDEA(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_IDEA, Idea))
#define IDEA_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_IDEA, IdeaClass))
#define IS_IDEA(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_IDEA))
#define IS_IDEA_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_IDEA))
#define IDEA_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_IDEA, IdeaClass))

typedef struct _Idea Idea;
typedef struct _IdeaClass IdeaClass;
typedef struct _IdeaPrivate IdeaPrivate;
enum  {
	IDEA_0_PROPERTY,
	IDEA_TEXT_PROPERTY,
	IDEA_NUM_PROPERTIES
};
static GParamSpec* idea_properties[IDEA_NUM_PROPERTIES];
#define _g_free0(var) (var = (g_free (var), NULL))

#define TYPE_BRAINDUMP (braindump_get_type ())
#define BRAINDUMP(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_BRAINDUMP, Braindump))
#define BRAINDUMP_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_BRAINDUMP, BraindumpClass))
#define IS_BRAINDUMP(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_BRAINDUMP))
#define IS_BRAINDUMP_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_BRAINDUMP))
#define BRAINDUMP_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_BRAINDUMP, BraindumpClass))

typedef struct _Braindump Braindump;
typedef struct _BraindumpClass BraindumpClass;
typedef struct _BraindumpPrivate BraindumpPrivate;

#define TYPE_MAIN_WINDOW (main_window_get_type ())
#define MAIN_WINDOW(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_MAIN_WINDOW, MainWindow))
#define MAIN_WINDOW_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_MAIN_WINDOW, MainWindowClass))
#define IS_MAIN_WINDOW(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_MAIN_WINDOW))
#define IS_MAIN_WINDOW_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_MAIN_WINDOW))
#define MAIN_WINDOW_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_MAIN_WINDOW, MainWindowClass))

typedef struct _MainWindow MainWindow;
typedef struct _MainWindowClass MainWindowClass;
enum  {
	BRAINDUMP_0_PROPERTY,
	BRAINDUMP_NUM_PROPERTIES
};
static GParamSpec* braindump_properties[BRAINDUMP_NUM_PROPERTIES];
#define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL)))
typedef struct _Block5Data Block5Data;
typedef struct _Block6Data Block6Data;

#define TYPE_THEME (theme_get_type ())
#define THEME(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_THEME, Theme))
#define THEME_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_THEME, ThemeClass))
#define IS_THEME(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_THEME))
#define IS_THEME_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_THEME))
#define THEME_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_THEME, ThemeClass))

typedef struct _Theme Theme;
typedef struct _ThemeClass ThemeClass;

#define TYPE_MIND_MAP (mind_map_get_type ())
#define MIND_MAP(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_MIND_MAP, MindMap))
#define MIND_MAP_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_MIND_MAP, MindMapClass))
#define IS_MIND_MAP(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_MIND_MAP))
#define IS_MIND_MAP_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_MIND_MAP))
#define MIND_MAP_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_MIND_MAP, MindMapClass))

typedef struct _MindMap MindMap;
typedef struct _MindMapClass MindMapClass;

#define TYPE_MAP_MODEL (map_model_get_type ())
#define MAP_MODEL(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_MAP_MODEL, MapModel))
#define MAP_MODEL_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_MAP_MODEL, MapModelClass))
#define IS_MAP_MODEL(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_MAP_MODEL))
#define IS_MAP_MODEL_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_MAP_MODEL))
#define MAP_MODEL_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_MAP_MODEL, MapModelClass))

typedef struct _MapModel MapModel;
typedef struct _MapModelClass MapModelClass;
#define _mind_map_unref0(var) ((var == NULL) ? NULL : (var = (mind_map_unref (var), NULL)))
#define __vala_GdkRGBA_free0(var) ((var == NULL) ? NULL : (var = (_vala_GdkRGBA_free (var), NULL)))
#define _cairo_destroy0(var) ((var == NULL) ? NULL : (var = (cairo_destroy (var), NULL)))
#define __vala_graphene_rect_t_free0(var) ((var == NULL) ? NULL : (var = (_vala_graphene_rect_t_free (var), NULL)))
enum  {
	BRAINDUMP_IDEAS_CHANGED_SIGNAL,
	BRAINDUMP_NUM_SIGNALS
};
static guint braindump_signals[BRAINDUMP_NUM_SIGNALS] = {0};

struct _Idea {
	GObject parent_instance;
	IdeaPrivate * priv;
};

struct _IdeaClass {
	GObjectClass parent_class;
};

struct _IdeaPrivate {
	gchar* _text;
};

struct _Braindump {
	GtkBox parent_instance;
	BraindumpPrivate * priv;
};

struct _BraindumpClass {
	GtkBoxClass parent_class;
};

struct _BraindumpPrivate {
	MainWindow* _win;
	GtkEntry* _entry;
	GtkListBox* _ideas;
	gint _current_index;
};

struct _Block5Data {
	int _ref_count_;
	Braindump* self;
	GtkButton* remove_btn;
};

struct _Block6Data {
	int _ref_count_;
	Braindump* self;
	GtkLabel* label;
	gchar* text;
};

static gint Idea_private_offset;
static gpointer idea_parent_class = NULL;
static gint Braindump_private_offset;
static gpointer braindump_parent_class = NULL;

VALA_EXTERN GType braindump_change_type_get_type (void) G_GNUC_CONST ;
VALA_EXTERN GType idea_get_type (void) G_GNUC_CONST ;
G_DEFINE_AUTOPTR_CLEANUP_FUNC (Idea, g_object_unref)
VALA_EXTERN Idea* idea_new (const gchar* text);
VALA_EXTERN Idea* idea_construct (GType object_type,
                      const gchar* text);
VALA_EXTERN void idea_set_text (Idea* self,
                    const gchar* value);
VALA_EXTERN const gchar* idea_get_text (Idea* self);
static void idea_finalize (GObject * obj);
static GType idea_get_type_once (void);
static void _vala_idea_get_property (GObject * object,
                              guint property_id,
                              GValue * value,
                              GParamSpec * pspec);
static void _vala_idea_set_property (GObject * object,
                              guint property_id,
                              const GValue * value,
                              GParamSpec * pspec);
VALA_EXTERN GType braindump_get_type (void) G_GNUC_CONST ;
G_DEFINE_AUTOPTR_CLEANUP_FUNC (Braindump, g_object_unref)
VALA_EXTERN GType main_window_get_type (void) G_GNUC_CONST ;
G_DEFINE_AUTOPTR_CLEANUP_FUNC (MainWindow, g_object_unref)
VALA_EXTERN Braindump* braindump_new (MainWindow* win);
VALA_EXTERN Braindump* braindump_construct (GType object_type,
                                MainWindow* win);
static Block5Data* block5_data_ref (Block5Data* _data5_);
static void block5_data_unref (void * _userdata_);
static void __lambda172_ (Braindump* self);
static void braindump_add_idea (Braindump* self,
                         const gchar* text);
static void ___lambda172__gtk_entry_activate (GtkEntry* _sender,
                                       gpointer self);
static gboolean __lambda177_ (Braindump* self,
                       guint keyval,
                       guint keycode,
                       GdkModifierType state);
static gboolean ___lambda177__gtk_event_controller_key_key_pressed (GtkEventControllerKey* _sender,
                                                             guint keyval,
                                                             guint keycode,
                                                             GdkModifierType state,
                                                             gpointer self);
static void __lambda178_ (Braindump* self);
static void ___lambda178__gtk_button_clicked (GtkButton* _sender,
                                       gpointer self);
static void __lambda179_ (Block5Data* _data5_,
                   BraindumpChangeType change,
                   const gchar* idea);
static void ___lambda179__braindump_ideas_changed (Braindump* _sender,
                                            BraindumpChangeType change,
                                            const gchar* name_index,
                                            gpointer self);
static Block6Data* block6_data_ref (Block6Data* _data6_);
static void block6_data_unref (void * _userdata_);
static GdkPaintable* braindump_create_icon (Braindump* self,
                                     GtkLabel* label,
                                     const gchar* text);
static GdkContentProvider* __lambda173_ (Block6Data* _data6_,
                                  gdouble x,
                                  gdouble y);
static GdkContentProvider* ___lambda173__gtk_drag_source_prepare (GtkDragSource* _sender,
                                                           gdouble x,
                                                           gdouble y,
                                                           gpointer self);
static void __lambda174_ (Block6Data* _data6_,
                   GdkDrag* d);
static void ___lambda174__gtk_drag_source_drag_begin (GtkDragSource* _sender,
                                               GdkDrag* drag,
                                               gpointer self);
static gboolean __lambda175_ (Braindump* self,
                       GdkDrag* d);
static gboolean ___lambda175__gtk_drag_source_drag_cancel (GtkDragSource* _sender,
                                                    GdkDrag* drag,
                                                    GdkDragCancelReason reason,
                                                    gpointer self);
static void __lambda176_ (Braindump* self,
                   GdkDrag* d,
                   gboolean del);
static void ___lambda176__gtk_drag_source_drag_end (GtkDragSource* _sender,
                                             GdkDrag* drag,
                                             gboolean delete_data,
                                             gpointer self);
VALA_EXTERN GType theme_get_type (void) G_GNUC_CONST ;
G_DEFINE_AUTOPTR_CLEANUP_FUNC (Theme, g_object_unref)
VALA_EXTERN gpointer mind_map_ref (gpointer instance);
VALA_EXTERN void mind_map_unref (gpointer instance);
VALA_EXTERN GParamSpec* param_spec_mind_map (const gchar* name,
                                 const gchar* nick,
                                 const gchar* blurb,
                                 GType object_type,
                                 GParamFlags flags);
VALA_EXTERN void value_set_mind_map (GValue* value,
                         gpointer v_object);
VALA_EXTERN void value_take_mind_map (GValue* value,
                          gpointer v_object);
VALA_EXTERN gpointer value_get_mind_map (const GValue* value);
VALA_EXTERN GType mind_map_get_type (void) G_GNUC_CONST ;
G_DEFINE_AUTOPTR_CLEANUP_FUNC (MindMap, mind_map_unref)
VALA_EXTERN MindMap* main_window_get_current_map (MainWindow* self,
                                      const gchar* caller);
VALA_EXTERN gpointer map_model_ref (gpointer instance);
VALA_EXTERN void map_model_unref (gpointer instance);
VALA_EXTERN GParamSpec* param_spec_map_model (const gchar* name,
                                  const gchar* nick,
                                  const gchar* blurb,
                                  GType object_type,
                                  GParamFlags flags);
VALA_EXTERN void value_set_map_model (GValue* value,
                          gpointer v_object);
VALA_EXTERN void value_take_map_model (GValue* value,
                           gpointer v_object);
VALA_EXTERN gpointer value_get_map_model (const GValue* value);
VALA_EXTERN GType map_model_get_type (void) G_GNUC_CONST ;
G_DEFINE_AUTOPTR_CLEANUP_FUNC (MapModel, map_model_unref)
VALA_EXTERN MapModel* mind_map_get_model (MindMap* self);
VALA_EXTERN Theme* map_model_get_theme (MapModel* self);
VALA_EXTERN void utils_set_context_color_with_alpha (cairo_t* ctx,
                                         GdkRGBA* color,
                                         gdouble alpha);
VALA_EXTERN GdkRGBA* theme_get_color (Theme* self,
                          const gchar* name);
static void _vala_GdkRGBA_free (GdkRGBA* self);
static void _vala_graphene_rect_t_free (graphene_rect_t* self);
static gboolean braindump_real_grab_focus (GtkWidget* base);
VALA_EXTERN void braindump_set_list (Braindump* self,
                         GArray* list);
static void g_cclosure_user_marshal_VOID__ENUM_STRING (GClosure * closure,
                                                GValue * return_value,
                                                guint n_param_values,
                                                const GValue * param_values,
                                                gpointer invocation_hint,
                                                gpointer marshal_data);
static void braindump_finalize (GObject * obj);
static GType braindump_get_type_once (void);

static GType
braindump_change_type_get_type_once (void)
{
	static const GEnumValue values[] = {{BRAINDUMP_CHANGE_TYPE_ADD, "BRAINDUMP_CHANGE_TYPE_ADD", "add"}, {BRAINDUMP_CHANGE_TYPE_REMOVE, "BRAINDUMP_CHANGE_TYPE_REMOVE", "remove"}, {BRAINDUMP_CHANGE_TYPE_CLEAR, "BRAINDUMP_CHANGE_TYPE_CLEAR", "clear"}, {0, NULL, NULL}};
	GType braindump_change_type_type_id;
	braindump_change_type_type_id = g_enum_register_static ("BraindumpChangeType", values);
	return braindump_change_type_type_id;
}

GType
braindump_change_type_get_type (void)
{
	static volatile gsize braindump_change_type_type_id__once = 0;
	if (g_once_init_enter (&braindump_change_type_type_id__once)) {
		GType braindump_change_type_type_id;
		braindump_change_type_type_id = braindump_change_type_get_type_once ();
		g_once_init_leave (&braindump_change_type_type_id__once, braindump_change_type_type_id);
	}
	return braindump_change_type_type_id__once;
}

static inline gpointer
idea_get_instance_private (Idea* self)
{
	return G_STRUCT_MEMBER_P (self, Idea_private_offset);
}

Idea*
idea_construct (GType object_type,
                const gchar* text)
{
	Idea * self = NULL;
	g_return_val_if_fail (text != NULL, NULL);
	self = (Idea*) g_object_new (object_type, NULL);
	idea_set_text (self, text);
	return self;
}

Idea*
idea_new (const gchar* text)
{
	return idea_construct (TYPE_IDEA, text);
}

const gchar*
idea_get_text (Idea* self)
{
	const gchar* result;
	const gchar* _tmp0_;
	g_return_val_if_fail (self != NULL, NULL);
	_tmp0_ = self->priv->_text;
	result = _tmp0_;
	return result;
}

void
idea_set_text (Idea* self,
               const gchar* value)
{
	gchar* old_value;
	g_return_if_fail (self != NULL);
	old_value = idea_get_text (self);
	if (g_strcmp0 (value, old_value) != 0) {
		gchar* _tmp0_;
		_tmp0_ = g_strdup (value);
		_g_free0 (self->priv->_text);
		self->priv->_text = _tmp0_;
		g_object_notify_by_pspec ((GObject *) self, idea_properties[IDEA_TEXT_PROPERTY]);
	}
}

static void
idea_class_init (IdeaClass * klass,
                 gpointer klass_data)
{
	idea_parent_class = g_type_class_peek_parent (klass);
	g_type_class_adjust_private_offset (klass, &Idea_private_offset);
	G_OBJECT_CLASS (klass)->get_property = _vala_idea_get_property;
	G_OBJECT_CLASS (klass)->set_property = _vala_idea_set_property;
	G_OBJECT_CLASS (klass)->finalize = idea_finalize;
	g_object_class_install_property (G_OBJECT_CLASS (klass), IDEA_TEXT_PROPERTY, idea_properties[IDEA_TEXT_PROPERTY] = g_param_spec_string ("text", "text", "text", NULL, G_PARAM_STATIC_STRINGS | G_PARAM_READABLE | G_PARAM_WRITABLE));
}

static void
idea_instance_init (Idea * self,
                    gpointer klass)
{
	gchar* _tmp0_;
	self->priv = idea_get_instance_private (self);
	_tmp0_ = g_strdup ("");
	self->priv->_text = _tmp0_;
}

static void
idea_finalize (GObject * obj)
{
	Idea * self;
	self = G_TYPE_CHECK_INSTANCE_CAST (obj, TYPE_IDEA, Idea);
	_g_free0 (self->priv->_text);
	G_OBJECT_CLASS (idea_parent_class)->finalize (obj);
}

static GType
idea_get_type_once (void)
{
	static const GTypeInfo g_define_type_info = { sizeof (IdeaClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) idea_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (Idea), 0, (GInstanceInitFunc) idea_instance_init, NULL };
	GType idea_type_id;
	idea_type_id = g_type_register_static (G_TYPE_OBJECT, "Idea", &g_define_type_info, 0);
	Idea_private_offset = g_type_add_instance_private (idea_type_id, sizeof (IdeaPrivate));
	return idea_type_id;
}

GType
idea_get_type (void)
{
	static volatile gsize idea_type_id__once = 0;
	if (g_once_init_enter (&idea_type_id__once)) {
		GType idea_type_id;
		idea_type_id = idea_get_type_once ();
		g_once_init_leave (&idea_type_id__once, idea_type_id);
	}
	return idea_type_id__once;
}

static void
_vala_idea_get_property (GObject * object,
                         guint property_id,
                         GValue * value,
                         GParamSpec * pspec)
{
	Idea * self;
	self = G_TYPE_CHECK_INSTANCE_CAST (object, TYPE_IDEA, Idea);
	switch (property_id) {
		case IDEA_TEXT_PROPERTY:
		g_value_set_string (value, idea_get_text (self));
		break;
		default:
		G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
		break;
	}
}

static void
_vala_idea_set_property (GObject * object,
                         guint property_id,
                         const GValue * value,
                         GParamSpec * pspec)
{
	Idea * self;
	self = G_TYPE_CHECK_INSTANCE_CAST (object, TYPE_IDEA, Idea);
	switch (property_id) {
		case IDEA_TEXT_PROPERTY:
		idea_set_text (self, g_value_get_string (value));
		break;
		default:
		G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
		break;
	}
}

static inline gpointer
braindump_get_instance_private (Braindump* self)
{
	return G_STRUCT_MEMBER_P (self, Braindump_private_offset);
}

static Block5Data*
block5_data_ref (Block5Data* _data5_)
{
	g_atomic_int_inc (&_data5_->_ref_count_);
	return _data5_;
}

static void
block5_data_unref (void * _userdata_)
{
	Block5Data* _data5_;
	_data5_ = (Block5Data*) _userdata_;
	if (g_atomic_int_dec_and_test (&_data5_->_ref_count_)) {
		Braindump* self;
		self = _data5_->self;
		_g_object_unref0 (_data5_->remove_btn);
		_g_object_unref0 (self);
		g_slice_free (Block5Data, _data5_);
	}
}

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

static void
__lambda172_ (Braindump* self)
{
	GtkEntry* _tmp0_;
	const gchar* _tmp1_;
	const gchar* _tmp2_;
	GtkEntry* _tmp3_;
	const gchar* _tmp4_;
	const gchar* _tmp5_;
	GtkEntry* _tmp6_;
	_tmp0_ = self->priv->_entry;
	_tmp1_ = gtk_editable_get_text ((GtkEditable*) _tmp0_);
	_tmp2_ = _tmp1_;
	braindump_add_idea (self, _tmp2_);
	_tmp3_ = self->priv->_entry;
	_tmp4_ = gtk_editable_get_text ((GtkEditable*) _tmp3_);
	_tmp5_ = _tmp4_;
	g_signal_emit (self, braindump_signals[BRAINDUMP_IDEAS_CHANGED_SIGNAL], 0, BRAINDUMP_CHANGE_TYPE_ADD, _tmp5_);
	_tmp6_ = self->priv->_entry;
	gtk_editable_set_text ((GtkEditable*) _tmp6_, "");
}

static void
___lambda172__gtk_entry_activate (GtkEntry* _sender,
                                  gpointer self)
{
	__lambda172_ ((Braindump*) self);
}

static gboolean
__lambda177_ (Braindump* self,
              guint keyval,
              guint keycode,
              GdkModifierType state)
{
	GtkListBoxRow* current = NULL;
	GtkListBox* _tmp0_;
	GtkListBoxRow* _tmp1_;
	GtkListBoxRow* _tmp2_;
	GtkListBoxRow* _tmp3_;
	gboolean result;
	_tmp0_ = self->priv->_ideas;
	_tmp1_ = gtk_list_box_get_selected_row (_tmp0_);
	_tmp2_ = _g_object_ref0 (_tmp1_);
	current = _tmp2_;
	_tmp3_ = current;
	if (_tmp3_ != NULL) {
		if (keyval == GDK_KEY_Delete) {
			gint index = 0;
			GtkListBoxRow* _tmp4_;
			GtkListBox* _tmp5_;
			GtkListBoxRow* _tmp6_;
			gchar* _tmp7_;
			gchar* _tmp8_;
			_tmp4_ = current;
			index = gtk_list_box_row_get_index (_tmp4_);
			_tmp5_ = self->priv->_ideas;
			_tmp6_ = current;
			gtk_list_box_remove (_tmp5_, (GtkWidget*) _tmp6_);
			_tmp7_ = g_strdup_printf ("%i", index);
			_tmp8_ = _tmp7_;
			g_signal_emit (self, braindump_signals[BRAINDUMP_IDEAS_CHANGED_SIGNAL], 0, BRAINDUMP_CHANGE_TYPE_REMOVE, _tmp8_);
			_g_free0 (_tmp8_);
			result = TRUE;
			_g_object_unref0 (current);
			return result;
		}
	}
	result = FALSE;
	_g_object_unref0 (current);
	return result;
}

static gboolean
___lambda177__gtk_event_controller_key_key_pressed (GtkEventControllerKey* _sender,
                                                    guint keyval,
                                                    guint keycode,
                                                    GdkModifierType state,
                                                    gpointer self)
{
	gboolean result;
	result = __lambda177_ ((Braindump*) self, keyval, keycode, state);
	return result;
}

static void
__lambda178_ (Braindump* self)
{
	GtkListBox* _tmp0_;
	_tmp0_ = self->priv->_ideas;
	gtk_list_box_remove_all (_tmp0_);
	g_signal_emit (self, braindump_signals[BRAINDUMP_IDEAS_CHANGED_SIGNAL], 0, BRAINDUMP_CHANGE_TYPE_CLEAR, "");
}

static void
___lambda178__gtk_button_clicked (GtkButton* _sender,
                                  gpointer self)
{
	__lambda178_ ((Braindump*) self);
}

static void
__lambda179_ (Block5Data* _data5_,
              BraindumpChangeType change,
              const gchar* idea)
{
	Braindump* self;
	GtkListBox* _tmp0_;
	GtkListBoxRow* _tmp1_;
	self = _data5_->self;
	g_return_if_fail (idea != NULL);
	_tmp0_ = self->priv->_ideas;
	_tmp1_ = gtk_list_box_get_row_at_index (_tmp0_, 0);
	gtk_widget_set_sensitive ((GtkWidget*) _data5_->remove_btn, _tmp1_ != NULL);
}

static void
___lambda179__braindump_ideas_changed (Braindump* _sender,
                                       BraindumpChangeType change,
                                       const gchar* name_index,
                                       gpointer self)
{
	__lambda179_ (self, change, name_index);
}

Braindump*
braindump_construct (GType object_type,
                     MainWindow* win)
{
	Braindump * self = NULL;
	Block5Data* _data5_;
	MainWindow* _tmp0_;
	gchar* _tmp1_;
	GtkEntry* _tmp2_ = NULL;
	GtkEntry* _tmp3_;
	GtkListBox* _tmp4_ = NULL;
	GtkEventControllerKey* key = NULL;
	GtkEventControllerKey* _tmp5_;
	GtkListBox* _tmp6_;
	GtkEventController* _tmp7_;
	GtkScrolledWindow* sw = NULL;
	GtkListBox* _tmp8_;
	GtkWidget* _tmp9_;
	GtkScrolledWindow* _tmp10_ = NULL;
	GtkButton* _tmp11_ = NULL;
	GtkBox* bbar = NULL;
	GtkBox* _tmp12_ = NULL;
	GtkEntry* _tmp13_;
	g_return_val_if_fail (win != NULL, NULL);
	_data5_ = g_slice_new0 (Block5Data);
	_data5_->_ref_count_ = 1;
	self = (Braindump*) g_object_new (object_type, "orientation", GTK_ORIENTATION_VERTICAL, "spacing", 5, NULL);
	_data5_->self = g_object_ref (self);
	_tmp0_ = _g_object_ref0 (win);
	_g_object_unref0 (self->priv->_win);
	self->priv->_win = _tmp0_;
	_tmp1_ = g_strdup (_ ("Enter Idea"));
	_tmp2_ = (GtkEntry*) gtk_entry_new ();
	gtk_widget_set_halign ((GtkWidget*) _tmp2_, GTK_ALIGN_FILL);
	gtk_entry_set_placeholder_text (_tmp2_, _tmp1_);
	_g_free0 (_tmp1_);
	gtk_editable_set_width_chars ((GtkEditable*) _tmp2_, 30);
	gtk_widget_set_margin_top ((GtkWidget*) _tmp2_, 5);
	gtk_widget_set_margin_start ((GtkWidget*) _tmp2_, 5);
	gtk_widget_set_margin_end ((GtkWidget*) _tmp2_, 5);
	g_object_ref_sink (_tmp2_);
	_g_object_unref0 (self->priv->_entry);
	self->priv->_entry = _tmp2_;
	_tmp3_ = self->priv->_entry;
	g_signal_connect_object (_tmp3_, "activate", (GCallback) ___lambda172__gtk_entry_activate, self, 0);
	_tmp4_ = (GtkListBox*) gtk_list_box_new ();
	gtk_widget_set_halign ((GtkWidget*) _tmp4_, GTK_ALIGN_FILL);
	gtk_list_box_set_selection_mode (_tmp4_, GTK_SELECTION_SINGLE);
	gtk_list_box_set_show_separators (_tmp4_, TRUE);
	g_object_ref_sink (_tmp4_);
	_g_object_unref0 (self->priv->_ideas);
	self->priv->_ideas = _tmp4_;
	_tmp5_ = (GtkEventControllerKey*) gtk_event_controller_key_new ();
	key = _tmp5_;
	g_signal_connect_object (key, "key-pressed", (GCallback) ___lambda177__gtk_event_controller_key_key_pressed, self, 0);
	_tmp6_ = self->priv->_ideas;
	_tmp7_ = _g_object_ref0 ((GtkEventController*) key);
	gtk_widget_add_controller ((GtkWidget*) _tmp6_, _tmp7_);
	_tmp8_ = self->priv->_ideas;
	_tmp9_ = _g_object_ref0 ((GtkWidget*) _tmp8_);
	_tmp10_ = (GtkScrolledWindow*) gtk_scrolled_window_new ();
	g_object_set (_tmp10_, "vscrollbar-policy", GTK_POLICY_AUTOMATIC, NULL);
	g_object_set (_tmp10_, "hscrollbar-policy", GTK_POLICY_NEVER, NULL);
	gtk_widget_set_halign ((GtkWidget*) _tmp10_, GTK_ALIGN_FILL);
	gtk_widget_set_valign ((GtkWidget*) _tmp10_, GTK_ALIGN_FILL);
	gtk_widget_set_margin_start ((GtkWidget*) _tmp10_, 5);
	gtk_widget_set_margin_end ((GtkWidget*) _tmp10_, 5);
	gtk_widget_set_vexpand ((GtkWidget*) _tmp10_, TRUE);
	gtk_scrolled_window_set_child (_tmp10_, _tmp9_);
	_g_object_unref0 (_tmp9_);
	g_object_ref_sink (_tmp10_);
	sw = _tmp10_;
	_tmp11_ = (GtkButton*) gtk_button_new_with_label (_ ("Clear Idea List"));
	gtk_widget_set_halign ((GtkWidget*) _tmp11_, GTK_ALIGN_CENTER);
	gtk_widget_set_hexpand ((GtkWidget*) _tmp11_, TRUE);
	g_object_ref_sink (_tmp11_);
	_data5_->remove_btn = _tmp11_;
	g_signal_connect_object (_data5_->remove_btn, "clicked", (GCallback) ___lambda178__gtk_button_clicked, self, 0);
	g_signal_connect_data (self, "ideas-changed", (GCallback) ___lambda179__braindump_ideas_changed, block5_data_ref (_data5_), (GClosureNotify) block5_data_unref, 0);
	_tmp12_ = (GtkBox*) gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 5);
	gtk_widget_set_margin_bottom ((GtkWidget*) _tmp12_, 5);
	gtk_widget_set_margin_start ((GtkWidget*) _tmp12_, 5);
	gtk_widget_set_margin_end ((GtkWidget*) _tmp12_, 5);
	g_object_ref_sink (_tmp12_);
	bbar = _tmp12_;
	gtk_box_append (bbar, (GtkWidget*) _data5_->remove_btn);
	_tmp13_ = self->priv->_entry;
	gtk_box_append ((GtkBox*) self, (GtkWidget*) _tmp13_);
	gtk_box_append ((GtkBox*) self, (GtkWidget*) sw);
	gtk_box_append ((GtkBox*) self, (GtkWidget*) bbar);
	_g_object_unref0 (bbar);
	_g_object_unref0 (sw);
	_g_object_unref0 (key);
	block5_data_unref (_data5_);
	_data5_ = NULL;
	return self;
}

Braindump*
braindump_new (MainWindow* win)
{
	return braindump_construct (TYPE_BRAINDUMP, win);
}

static Block6Data*
block6_data_ref (Block6Data* _data6_)
{
	g_atomic_int_inc (&_data6_->_ref_count_);
	return _data6_;
}

static void
block6_data_unref (void * _userdata_)
{
	Block6Data* _data6_;
	_data6_ = (Block6Data*) _userdata_;
	if (g_atomic_int_dec_and_test (&_data6_->_ref_count_)) {
		Braindump* self;
		self = _data6_->self;
		_g_object_unref0 (_data6_->label);
		_g_free0 (_data6_->text);
		_g_object_unref0 (self);
		g_slice_free (Block6Data, _data6_);
	}
}

static GdkContentProvider*
__lambda173_ (Block6Data* _data6_,
              gdouble x,
              gdouble y)
{
	Braindump* self;
	GValue val = {0};
	GValue _tmp0_ = {0};
	Idea* _tmp1_;
	Idea* _tmp2_;
	GdkContentProvider* provider = NULL;
	GValue _tmp3_;
	GdkContentProvider* _tmp4_;
	GdkContentProvider* result;
	self = _data6_->self;
	g_value_init (&_tmp0_, TYPE_IDEA);
	val = _tmp0_;
	_tmp1_ = idea_new (_data6_->text);
	_tmp2_ = _tmp1_;
	g_value_set_object (&val, (GObject*) _tmp2_);
	_g_object_unref0 (_tmp2_);
	_tmp3_ = val;
	_tmp4_ = gdk_content_provider_new_for_value (&_tmp3_);
	provider = _tmp4_;
	result = provider;
	G_IS_VALUE (&val) ? (g_value_unset (&val), NULL) : NULL;
	return result;
}

static GdkContentProvider*
___lambda173__gtk_drag_source_prepare (GtkDragSource* _sender,
                                       gdouble x,
                                       gdouble y,
                                       gpointer self)
{
	GdkContentProvider* result;
	result = __lambda173_ (self, x, y);
	return result;
}

static void
__lambda174_ (Block6Data* _data6_,
              GdkDrag* d)
{
	Braindump* self;
	GtkListBoxRow* row = NULL;
	GtkWidget* _tmp0_;
	GtkListBoxRow* _tmp1_;
	GtkListBox* _tmp2_;
	self = _data6_->self;
	g_return_if_fail (d != NULL);
	_tmp0_ = gtk_widget_get_parent ((GtkWidget*) _data6_->label);
	_tmp1_ = _g_object_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp0_, gtk_list_box_row_get_type (), GtkListBoxRow));
	row = _tmp1_;
	self->priv->_current_index = gtk_list_box_row_get_index (row);
	_tmp2_ = self->priv->_ideas;
	gtk_list_box_remove (_tmp2_, (GtkWidget*) row);
	_g_object_unref0 (row);
}

static void
___lambda174__gtk_drag_source_drag_begin (GtkDragSource* _sender,
                                          GdkDrag* drag,
                                          gpointer self)
{
	__lambda174_ (self, drag);
}

static gboolean
__lambda175_ (Braindump* self,
              GdkDrag* d)
{
	gboolean result;
	g_return_val_if_fail (d != NULL, FALSE);
	result = FALSE;
	return result;
}

static gboolean
___lambda175__gtk_drag_source_drag_cancel (GtkDragSource* _sender,
                                           GdkDrag* drag,
                                           GdkDragCancelReason reason,
                                           gpointer self)
{
	gboolean result;
	result = __lambda175_ ((Braindump*) self, drag);
	return result;
}

static void
__lambda176_ (Braindump* self,
              GdkDrag* d,
              gboolean del)
{
	gchar* _tmp0_;
	gchar* _tmp1_;
	g_return_if_fail (d != NULL);
	_tmp0_ = g_strdup_printf ("%i", self->priv->_current_index);
	_tmp1_ = _tmp0_;
	g_signal_emit (self, braindump_signals[BRAINDUMP_IDEAS_CHANGED_SIGNAL], 0, BRAINDUMP_CHANGE_TYPE_REMOVE, _tmp1_);
	_g_free0 (_tmp1_);
}

static void
___lambda176__gtk_drag_source_drag_end (GtkDragSource* _sender,
                                        GdkDrag* drag,
                                        gboolean delete_data,
                                        gpointer self)
{
	__lambda176_ ((Braindump*) self, drag, delete_data);
}

static void
braindump_add_idea (Braindump* self,
                    const gchar* text)
{
	Block6Data* _data6_;
	gchar* _tmp0_;
	GtkLabel* _tmp1_ = NULL;
	GtkListBox* _tmp2_;
	GtkDragSource* drag = NULL;
	GtkDragSource* _tmp3_ = NULL;
	GtkEventController* _tmp4_;
	GdkPaintable* _tmp5_;
	GdkPaintable* _tmp6_;
	g_return_if_fail (self != NULL);
	g_return_if_fail (text != NULL);
	_data6_ = g_slice_new0 (Block6Data);
	_data6_->_ref_count_ = 1;
	_data6_->self = g_object_ref (self);
	_tmp0_ = g_strdup (text);
	_g_free0 (_data6_->text);
	_data6_->text = _tmp0_;
	_tmp1_ = (GtkLabel*) gtk_label_new (_data6_->text);
	gtk_label_set_wrap (_tmp1_, TRUE);
	gtk_label_set_wrap_mode (_tmp1_, PANGO_WRAP_WORD);
	gtk_widget_set_halign ((GtkWidget*) _tmp1_, GTK_ALIGN_START);
	gtk_widget_set_hexpand ((GtkWidget*) _tmp1_, TRUE);
	gtk_widget_set_margin_start ((GtkWidget*) _tmp1_, 5);
	gtk_widget_set_margin_end ((GtkWidget*) _tmp1_, 5);
	gtk_widget_set_margin_top ((GtkWidget*) _tmp1_, 10);
	gtk_widget_set_margin_bottom ((GtkWidget*) _tmp1_, 10);
	g_object_ref_sink (_tmp1_);
	_data6_->label = _tmp1_;
	_tmp2_ = self->priv->_ideas;
	gtk_list_box_append (_tmp2_, (GtkWidget*) _data6_->label);
	_tmp3_ = gtk_drag_source_new ();
	gtk_drag_source_set_actions (_tmp3_, GDK_ACTION_MOVE);
	drag = _tmp3_;
	_tmp4_ = _g_object_ref0 ((GtkEventController*) drag);
	gtk_widget_add_controller ((GtkWidget*) _data6_->label, _tmp4_);
	_tmp5_ = braindump_create_icon (self, _data6_->label, _data6_->text);
	_tmp6_ = _tmp5_;
	gtk_drag_source_set_icon (drag, _tmp6_, 10, 10);
	_g_object_unref0 (_tmp6_);
	g_signal_connect_data (drag, "prepare", (GCallback) ___lambda173__gtk_drag_source_prepare, block6_data_ref (_data6_), (GClosureNotify) block6_data_unref, 0);
	g_signal_connect_data (drag, "drag-begin", (GCallback) ___lambda174__gtk_drag_source_drag_begin, block6_data_ref (_data6_), (GClosureNotify) block6_data_unref, 0);
	g_signal_connect_object (drag, "drag-cancel", (GCallback) ___lambda175__gtk_drag_source_drag_cancel, self, 0);
	g_signal_connect_object (drag, "drag-end", (GCallback) ___lambda176__gtk_drag_source_drag_end, self, 0);
	_g_object_unref0 (drag);
	block6_data_unref (_data6_);
	_data6_ = NULL;
}

static void
_vala_GdkRGBA_free (GdkRGBA* self)
{
	g_boxed_free (gdk_rgba_get_type (), self);
}

static void
_vala_graphene_rect_t_free (graphene_rect_t* self)
{
	g_boxed_free (graphene_rect_get_type (), self);
}

static GdkPaintable*
braindump_create_icon (Braindump* self,
                       GtkLabel* label,
                       const gchar* text)
{
	PangoRectangle log = {0};
	PangoRectangle ink = {0};
	Theme* theme = NULL;
	MainWindow* _tmp0_;
	MindMap* _tmp1_;
	MindMap* _tmp2_;
	MapModel* _tmp3_;
	MapModel* _tmp4_;
	Theme* _tmp5_;
	Theme* _tmp6_;
	PangoLayout* layout = NULL;
	PangoLayout* _tmp7_;
	PangoRectangle _tmp8_ = {0};
	PangoRectangle _tmp9_ = {0};
	gint padding = 0;
	gdouble alpha = 0.0;
	gint width = 0;
	PangoRectangle _tmp10_;
	gint height = 0;
	PangoRectangle _tmp11_;
	graphene_rect_t* rect = NULL;
	graphene_rect_t* _tmp12_;
	GtkSnapshot* snapshot = NULL;
	GtkSnapshot* _tmp13_;
	cairo_t* context = NULL;
	graphene_rect_t _tmp14_;
	cairo_t* _tmp15_;
	GdkRGBA* _tmp16_;
	GdkRGBA* _tmp17_;
	GdkRGBA _tmp18_;
	GdkRGBA* _tmp19_;
	GdkRGBA* _tmp20_;
	GdkRGBA _tmp21_;
	PangoRectangle _tmp22_;
	GtkSnapshot* _tmp23_;
	GdkPaintable* _tmp24_;
	GdkPaintable* result;
	g_return_val_if_fail (self != NULL, NULL);
	g_return_val_if_fail (label != NULL, NULL);
	g_return_val_if_fail (text != NULL, NULL);
	_tmp0_ = self->priv->_win;
	_tmp1_ = main_window_get_current_map (_tmp0_, NULL);
	_tmp2_ = _tmp1_;
	_tmp3_ = mind_map_get_model (_tmp2_);
	_tmp4_ = _tmp3_;
	_tmp5_ = map_model_get_theme (_tmp4_);
	_tmp6_ = _tmp5_;
	_mind_map_unref0 (_tmp2_);
	theme = _tmp6_;
	_tmp7_ = gtk_widget_create_pango_layout ((GtkWidget*) label, text);
	layout = _tmp7_;
	pango_layout_set_wrap (layout, PANGO_WRAP_WORD_CHAR);
	pango_layout_set_width (layout, 200 * PANGO_SCALE);
	pango_layout_get_extents (layout, &_tmp8_, &_tmp9_);
	ink = _tmp8_;
	log = _tmp9_;
	padding = 10;
	alpha = 0.5;
	_tmp10_ = log;
	width = (_tmp10_.width / PANGO_SCALE) + (padding * 2);
	_tmp11_ = log;
	height = (_tmp11_.height / PANGO_SCALE) + (padding * 2);
	_tmp12_ = graphene_rect_alloc ();
	rect = _tmp12_;
	graphene_rect_init (rect, (gfloat) 0.0, (gfloat) 0.0, (gfloat) width, (gfloat) height);
	_tmp13_ = gtk_snapshot_new ();
	snapshot = _tmp13_;
	_tmp14_ = *rect;
	_tmp15_ = gtk_snapshot_append_cairo (snapshot, &_tmp14_);
	context = _tmp15_;
	_tmp16_ = theme_get_color (theme, "root_background");
	_tmp17_ = _tmp16_;
	_tmp18_ = *_tmp17_;
	utils_set_context_color_with_alpha (context, &_tmp18_, alpha);
	__vala_GdkRGBA_free0 (_tmp17_);
	cairo_rectangle (context, (gdouble) 0, (gdouble) 0, (gdouble) width, (gdouble) height);
	cairo_fill (context);
	_tmp19_ = theme_get_color (theme, "root_foreground");
	_tmp20_ = _tmp19_;
	_tmp21_ = *_tmp20_;
	utils_set_context_color_with_alpha (context, &_tmp21_, alpha);
	__vala_GdkRGBA_free0 (_tmp20_);
	_tmp22_ = log;
	cairo_move_to (context, (gdouble) (padding - (_tmp22_.x / PANGO_SCALE)), (gdouble) padding);
	pango_cairo_show_layout (context, layout);
	cairo_new_path (context);
	_tmp23_ = _g_object_ref0 (snapshot);
	_tmp24_ = gtk_snapshot_free_to_paintable (_tmp23_, NULL);
	result = _tmp24_;
	_cairo_destroy0 (context);
	_g_object_unref0 (snapshot);
	__vala_graphene_rect_t_free0 (rect);
	_g_object_unref0 (layout);
	_g_object_unref0 (theme);
	return result;
}

static gboolean
braindump_real_grab_focus (GtkWidget* base)
{
	Braindump * self;
	GtkEntry* _tmp0_;
	gboolean result;
	self = (Braindump*) base;
	_tmp0_ = self->priv->_entry;
	result = gtk_widget_grab_focus ((GtkWidget*) _tmp0_);
	return result;
}

void
braindump_set_list (Braindump* self,
                    GArray* list)
{
	GtkListBox* _tmp0_;
	g_return_if_fail (self != NULL);
	g_return_if_fail (list != NULL);
	_tmp0_ = self->priv->_ideas;
	gtk_list_box_remove_all (_tmp0_);
	{
		gint i = 0;
		i = 0;
		{
			gboolean _tmp1_ = FALSE;
			_tmp1_ = TRUE;
			while (TRUE) {
				const gchar* _tmp3_;
				if (!_tmp1_) {
					gint _tmp2_;
					_tmp2_ = i;
					i = _tmp2_ + 1;
				}
				_tmp1_ = FALSE;
				if (!(((guint) i) < list->len)) {
					break;
				}
				_tmp3_ = g_array_index (list, gchar*, (guint) i);
				braindump_add_idea (self, _tmp3_);
			}
		}
	}
}

static void
g_cclosure_user_marshal_VOID__ENUM_STRING (GClosure * closure,
                                           GValue * return_value,
                                           guint n_param_values,
                                           const GValue * param_values,
                                           gpointer invocation_hint,
                                           gpointer marshal_data)
{
	typedef void (*GMarshalFunc_VOID__ENUM_STRING) (gpointer data1, gint arg_1, const char* arg_2, gpointer data2);
	register GMarshalFunc_VOID__ENUM_STRING callback;
	register GCClosure * cc;
	register gpointer data1;
	register gpointer data2;
	cc = (GCClosure *) closure;
	g_return_if_fail (n_param_values == 3);
	if (G_CCLOSURE_SWAP_DATA (closure)) {
		data1 = closure->data;
		data2 = param_values->data[0].v_pointer;
	} else {
		data1 = param_values->data[0].v_pointer;
		data2 = closure->data;
	}
	callback = (GMarshalFunc_VOID__ENUM_STRING) (marshal_data ? marshal_data : cc->callback);
	callback (data1, g_value_get_enum (param_values + 1), g_value_get_string (param_values + 2), data2);
}

static void
braindump_class_init (BraindumpClass * klass,
                      gpointer klass_data)
{
	braindump_parent_class = g_type_class_peek_parent (klass);
	g_type_class_adjust_private_offset (klass, &Braindump_private_offset);
	((GtkWidgetClass *) klass)->grab_focus = (gboolean (*) (GtkWidget*)) braindump_real_grab_focus;
	G_OBJECT_CLASS (klass)->finalize = braindump_finalize;
	braindump_signals[BRAINDUMP_IDEAS_CHANGED_SIGNAL] = g_signal_new ("ideas-changed", TYPE_BRAINDUMP, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_user_marshal_VOID__ENUM_STRING, G_TYPE_NONE, 2, TYPE_BRAINDUMP_CHANGE_TYPE, G_TYPE_STRING);
}

static void
braindump_instance_init (Braindump * self,
                         gpointer klass)
{
	self->priv = braindump_get_instance_private (self);
}

static void
braindump_finalize (GObject * obj)
{
	Braindump * self;
	self = G_TYPE_CHECK_INSTANCE_CAST (obj, TYPE_BRAINDUMP, Braindump);
	_g_object_unref0 (self->priv->_win);
	_g_object_unref0 (self->priv->_entry);
	_g_object_unref0 (self->priv->_ideas);
	G_OBJECT_CLASS (braindump_parent_class)->finalize (obj);
}

static GType
braindump_get_type_once (void)
{
	static const GTypeInfo g_define_type_info = { sizeof (BraindumpClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) braindump_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (Braindump), 0, (GInstanceInitFunc) braindump_instance_init, NULL };
	GType braindump_type_id;
	braindump_type_id = g_type_register_static (gtk_box_get_type (), "Braindump", &g_define_type_info, 0);
	Braindump_private_offset = g_type_add_instance_private (braindump_type_id, sizeof (BraindumpPrivate));
	return braindump_type_id;
}

GType
braindump_get_type (void)
{
	static volatile gsize braindump_type_id__once = 0;
	if (g_once_init_enter (&braindump_type_id__once)) {
		GType braindump_type_id;
		braindump_type_id = braindump_get_type_once ();
		g_once_init_leave (&braindump_type_id__once, braindump_type_id);
	}
	return braindump_type_id__once;
}

